Changeset 1228 for trunk/source/persistency/gdml
- Timestamp:
- Jan 8, 2010, 11:56:51 AM (14 years ago)
- Location:
- trunk/source/persistency/gdml
- Files:
-
- 38 edited
-
History (modified) (2 diffs)
-
include/G4GDMLEvaluator.hh (modified) (2 diffs)
-
include/G4GDMLParameterisation.hh (modified) (1 diff)
-
include/G4GDMLParser.hh (modified) (3 diffs)
-
include/G4GDMLParser.icc (modified) (1 diff)
-
include/G4GDMLRead.hh (modified) (3 diffs)
-
include/G4GDMLReadDefine.hh (modified) (4 diffs)
-
include/G4GDMLReadMaterials.hh (modified) (3 diffs)
-
include/G4GDMLReadParamvol.hh (modified) (3 diffs)
-
include/G4GDMLReadSetup.hh (modified) (2 diffs)
-
include/G4GDMLReadSolids.hh (modified) (4 diffs)
-
include/G4GDMLReadStructure.hh (modified) (6 diffs)
-
include/G4GDMLWrite.hh (modified) (3 diffs)
-
include/G4GDMLWriteDefine.hh (modified) (2 diffs)
-
include/G4GDMLWriteMaterials.hh (modified) (4 diffs)
-
include/G4GDMLWriteParamvol.hh (modified) (3 diffs)
-
include/G4GDMLWriteSetup.hh (modified) (2 diffs)
-
include/G4GDMLWriteSolids.hh (modified) (3 diffs)
-
include/G4GDMLWriteStructure.hh (modified) (2 diffs)
-
include/G4STRead.hh (modified) (2 diffs)
-
src/G4GDMLEvaluator.cc (modified) (2 diffs)
-
src/G4GDMLParameterisation.cc (modified) (1 diff)
-
src/G4GDMLParser.cc (modified) (4 diffs)
-
src/G4GDMLRead.cc (modified) (5 diffs)
-
src/G4GDMLReadDefine.cc (modified) (7 diffs)
-
src/G4GDMLReadMaterials.cc (modified) (4 diffs)
-
src/G4GDMLReadParamvol.cc (modified) (2 diffs)
-
src/G4GDMLReadSetup.cc (modified) (2 diffs)
-
src/G4GDMLReadSolids.cc (modified) (7 diffs)
-
src/G4GDMLReadStructure.cc (modified) (10 diffs)
-
src/G4GDMLWrite.cc (modified) (5 diffs)
-
src/G4GDMLWriteDefine.cc (modified) (2 diffs)
-
src/G4GDMLWriteMaterials.cc (modified) (4 diffs)
-
src/G4GDMLWriteParamvol.cc (modified) (2 diffs)
-
src/G4GDMLWriteSetup.cc (modified) (2 diffs)
-
src/G4GDMLWriteSolids.cc (modified) (5 diffs)
-
src/G4GDMLWriteStructure.cc (modified) (11 diffs)
-
src/G4STRead.cc (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/source/persistency/gdml/History
r987 r1228 1 $Id: History,v 1.1 01 2009/02/26 10:13:49gcosmo Exp $1 $Id: History,v 1.116 2009/12/04 13:59:05 gcosmo Exp $ 2 2 ------------------------------------------------------------------- 3 3 … … 17 17 * Reverse chronological order (last date on top), please * 18 18 ---------------------------------------------------------- 19 20 04 Dec 2009 Gabriele Cosmo (gdml-V09-02-18) 21 - Updated list of optical properties in G4GDMLReadSolid according to 22 last changes to G4OpticalSurface and G4SurfaceProperty. 23 24 14 Oct 2009 Gabriele Cosmo (gdml-V09-02-17) 25 - Added support for GDML 'expression' tag, implementing generic expressions 26 stored as literal constants. 27 - Corrected handling of 'quantity' tag; added missing caching of evaluation. 28 29 24 Sep 2009 Gabriele Cosmo (gdml-V09-02-16) 30 - Added support for the GDML 'assembly' tag, implementing assemblies of 31 simple placements through G4AssemblyVolume. 32 33 12 May 2009 Gabriele Cosmo (gdml-V09-02-15) 34 - Restricted usage of loops only for placement of volumes. Now correctly 35 handling most common use-case of multiple copies of the same volume/solid 36 through loop statement. Addressing problem report #1063. 37 38 11 May 2009 Gabriele Cosmo (gdml-V09-02-14) 39 - Allow for name stripping of volumes which are included in loops; do not 40 store appended internal counter reference. 41 42 27 April 2009 Gabriele Cosmo (gdml-V09-02-13) 43 - Get rid of unused parameter in G4GDMLWriteMaterials::PropertyVectorWrite(). 44 45 24 April 2009 Gabriele Cosmo (gdml-V09-02-12) 46 - Some code cleanup: rationalised inclusion of headers, replacing them 47 with forward declarations where possible. 48 49 24 April 2009 Gabriele Cosmo (gdml-V09-02-11) 50 - Allow for reading/writing of constant material properties. 51 - Implemented ability to write surface properties associated to volumes 52 and material properties. 53 54 17 April 2009 Gabriele Cosmo (gdml-V09-02-10) 55 - Defined missing copy constructor and operator=() to G4GDMLMatrix 56 internal class, to avoid cases of memory corruption when handling matrices. 57 58 15 April 2009 Gabriele Cosmo (gdml-V09-02-09) 59 - Completed virtual layer for allowing customisation of the writer for 60 user-extended schemas. 61 62 09 April 2009 Gabriele Cosmo (gdml-V09-02-08) 63 - Correction in G4GDMLWriteSolids::BooleanWrite() in order to handle 64 cases of nested displaced solids given to both operands in a Boolean 65 operation (ATLAS use case). 66 - Renamed flag for maximum number of transformations applied to a solid 67 and moved to G4GDMLWriteSolids base class. 68 - First virtual layer for custom writer classes G4GDMLWriteSolids and 69 G4GDMLWriteStructure. 70 71 03 April 2009 Tatiana Nikitina (gdml-V09-02-07) 72 - Correction in materials and solids tags for allowing parsing of 73 definitions within the tag scope; possibility foreseen by the schema. 74 75 24 March 2009 Gabriele Cosmo (gdml-V09-02-06) 76 - Added empty default constructor and virtual destructor to classes in the 77 inheritance chain. 78 79 02 March 2009 Gabriele Cosmo (gdml-V09-02-05) 80 - Fixed association of entities in nested loops for solids and materials. 81 Definitions of materials are not supposed to be included in loops being 82 therefore repeated... 83 - Strip off white spaces from names G4GDMLWrite::GenerateName(), to avoid 84 parsing problems in imported files. 19 85 20 86 26 February 2009 Tatiana Nikitina (gdml-V09-02-04) -
trunk/source/persistency/gdml/include/G4GDMLEvaluator.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLEvaluator.hh,v 1.1 6 2008/07/16 15:46:33gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLEvaluator.hh,v 1.17 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 45 45 #include <vector> 46 46 47 #include " globals.hh"47 #include "G4Types.hh" 48 48 49 49 class G4GDMLEvaluator -
trunk/source/persistency/gdml/include/G4GDMLParameterisation.hh
r987 r1228 26 26 // 27 27 // $Id: G4GDMLParameterisation.hh,v 1.10 2008/07/16 15:46:33 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // -
trunk/source/persistency/gdml/include/G4GDMLParser.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLParser.hh,v 1.5 7 2009/01/22 11:02:07gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLParser.hh,v 1.58 2009/04/15 13:29:30 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 54 54 G4GDMLParser(); 55 55 G4GDMLParser(G4GDMLReadStructure*); 56 G4GDMLParser(G4GDMLReadStructure*, G4GDMLWriteStructure*); 56 57 ~G4GDMLParser(); 57 58 // … … 113 114 G4GDMLReadStructure* reader; 114 115 G4GDMLWriteStructure* writer; 115 G4bool u code;116 G4bool urcode, uwcode; 116 117 117 118 }; -
trunk/source/persistency/gdml/include/G4GDMLParser.icc
r987 r1228 26 26 // 27 27 // $Id: G4GDMLParser.icc,v 1.8 2009/01/22 11:02:07 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // -
trunk/source/persistency/gdml/include/G4GDMLRead.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLRead.hh,v 1. 27 2009/01/22 11:02:07gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLRead.hh,v 1.31 2009/05/12 15:46:43 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // class G4GDMLRead … … 47 47 #include <xercesc/dom/DOM.hpp> 48 48 49 #include "G4Types.hh" 50 49 51 #include "G4GDMLEvaluator.hh" 50 52 51 #include "G4LogicalVolume.hh" 52 #include "G4VisAttributes.hh" 53 #include "G4PVPlacement.hh" 54 55 #include <sstream> 53 class G4LogicalVolume; 54 class G4VPhysicalVolume; 56 55 57 56 class G4GDMLErrorHandler : public xercesc::ErrorHandler … … 149 148 private: 150 149 151 G4int inLoop ;150 G4int inLoop, loopCount; 152 151 153 152 }; -
trunk/source/persistency/gdml/include/G4GDMLReadDefine.hh
r987 r1228 41 41 42 42 #include "G4ThreeVector.hh" 43 #include "G4RotationMatrix.hh" 44 43 45 #include "G4GDMLRead.hh" 44 46 … … 50 52 G4GDMLMatrix(); 51 53 G4GDMLMatrix(size_t rows0,size_t cols0); 52 ~G4GDMLMatrix(); 54 G4GDMLMatrix(const G4GDMLMatrix& rhs); 55 G4GDMLMatrix& operator=(const G4GDMLMatrix& rhs); 56 ~G4GDMLMatrix(); 53 57 54 58 void Set(size_t r,size_t c,G4double a); … … 80 84 protected: 81 85 86 G4GDMLReadDefine(); 87 virtual ~G4GDMLReadDefine(); 88 82 89 G4RotationMatrix GetRotationMatrix(const G4ThreeVector&); 83 90 void VectorRead(const xercesc::DOMElement* const,G4ThreeVector&); … … 90 97 void ScaleRead(const xercesc::DOMElement* const); 91 98 void VariableRead(const xercesc::DOMElement* const); 92 void QuantityRead(const xercesc::DOMElement* const); 99 void QuantityRead(const xercesc::DOMElement* const); 100 void ExpressionRead(const xercesc::DOMElement* const); 93 101 94 102 protected: -
trunk/source/persistency/gdml/include/G4GDMLReadMaterials.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLReadMaterials.hh,v 1. 9 2008/11/20 15:33:52gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLReadMaterials.hh,v 1.11 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 43 43 #define _G4GDMLREADMATERIALS_INCLUDED_ 44 44 45 #include "G4Element.hh" 46 #include "G4Isotope.hh" 47 #include "G4Material.hh" 48 #include "G4NistManager.hh" 45 #include "G4Types.hh" 46 #include "G4GDMLReadDefine.hh" 49 47 50 #include "G4GDMLReadDefine.hh" 48 class G4Element; 49 class G4Isotope; 50 class G4Material; 51 51 52 52 class G4GDMLReadMaterials : public G4GDMLReadDefine … … 62 62 63 63 protected: 64 65 G4GDMLReadMaterials(); 66 virtual ~G4GDMLReadMaterials(); 64 67 65 68 G4double AtomRead(const xercesc::DOMElement* const); -
trunk/source/persistency/gdml/include/G4GDMLReadParamvol.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLReadParamvol.hh,v 1. 6 2008/11/20 15:33:52gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLReadParamvol.hh,v 1.8 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 42 42 #define _G4GDMLREADPARAMVOL_INCLUDED_ 43 43 44 #include "G4LogicalVolume.hh" 45 #include "G4PVParameterised.hh" 46 #include "G4PVPlacement.hh" 47 #include "G4VPhysicalVolume.hh" 44 #include "G4GDMLReadSetup.hh" 45 #include "G4GDMLParameterisation.hh" 48 46 49 #include "G4GDMLParameterisation.hh" 50 #include "G4GDMLReadSetup.hh" 47 class G4LogicalVolume; 51 48 52 49 class G4GDMLReadParamvol : public G4GDMLReadSetup … … 60 57 61 58 protected: 59 60 G4GDMLReadParamvol(); 61 virtual ~G4GDMLReadParamvol(); 62 62 63 63 void Box_dimensionsRead(const xercesc::DOMElement* const, -
trunk/source/persistency/gdml/include/G4GDMLReadSetup.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLReadSetup.hh,v 1. 5 2008/11/20 15:33:52gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLReadSetup.hh,v 1.6 2009/03/24 15:47:33 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 58 58 protected: 59 59 60 G4GDMLReadSetup(); 61 virtual ~G4GDMLReadSetup(); 62 63 protected: 64 60 65 std::map<G4String,G4String> setupMap; 61 66 }; -
trunk/source/persistency/gdml/include/G4GDMLReadSolids.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLReadSolids.hh,v 1.1 2 2008/11/21 09:32:46gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLReadSolids.hh,v 1.15 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 42 42 #define _G4GDMLREADSOLIDS_INCLUDED_ 43 43 44 #include "G4Box.hh" 45 #include "G4Cons.hh" 46 #include "G4Ellipsoid.hh" 47 #include "G4EllipticalCone.hh" 48 #include "G4EllipticalTube.hh" 44 #include "G4Types.hh" 45 #include "G4GDMLReadMaterials.hh" 49 46 #include "G4ExtrudedSolid.hh" 50 #include "G4Hype.hh"51 #include "G4IntersectionSolid.hh"52 #include "G4Orb.hh"53 #include "G4Para.hh"54 #include "G4Paraboloid.hh"55 #include "G4Polycone.hh"56 #include "G4Polyhedra.hh"57 #include "G4QuadrangularFacet.hh"58 #include "G4ReflectedSolid.hh"59 #include "G4Sphere.hh"60 #include "G4SolidStore.hh"61 #include "G4SubtractionSolid.hh"62 #include "G4TessellatedSolid.hh"63 #include "G4Tet.hh"64 #include "G4Torus.hh"65 #include "G4Transform3D.hh"66 #include "G4Trap.hh"67 #include "G4Trd.hh"68 #include "G4TriangularFacet.hh"69 #include "G4Tubs.hh"70 #include "G4TwistedBox.hh"71 #include "G4TwistedTrap.hh"72 #include "G4TwistedTrd.hh"73 #include "G4TwistedTubs.hh"74 #include "G4UnionSolid.hh"75 #include "G4OpticalSurface.hh"76 #include "G4SurfaceProperty.hh"77 47 78 #include "G4GDMLReadMaterials.hh" 48 class G4VSolid; 49 class G4QuadrangularFacet; 50 class G4TriangularFacet; 51 class G4SurfaceProperty; 79 52 80 53 class G4GDMLReadSolids : public G4GDMLReadMaterials … … 91 64 92 65 protected: 66 67 G4GDMLReadSolids(); 68 virtual ~G4GDMLReadSolids(); 93 69 94 70 void BooleanRead(const xercesc::DOMElement* const,const BooleanOp); … … 122 98 G4TwoVector TwoDimVertexRead(const xercesc::DOMElement* const,G4double); 123 99 zplaneType ZplaneRead(const xercesc::DOMElement* const); 124 void Optical surfaceRead(const xercesc::DOMElement* const);100 void OpticalSurfaceRead(const xercesc::DOMElement* const); 125 101 }; 126 102 -
trunk/source/persistency/gdml/include/G4GDMLReadStructure.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLReadStructure.hh,v 1.2 4 2009/02/24 17:41:44 gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLReadStructure.hh,v 1.28 2009/09/24 15:04:34 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 42 42 #define _G4GDMLREADSTRUCTURE_INCLUDED_ 43 43 44 #include "G4AssemblyVolume.hh" 45 #include "G4LogicalVolume.hh" 46 #include "G4LogicalVolumeStore.hh" 47 #include "G4PhysicalVolumeStore.hh" 48 #include "G4PVDivision.hh" 49 #include "G4PVPlacement.hh" 50 #include "G4PVReplica.hh" 51 #include "G4SolidStore.hh" 52 #include "G4VPhysicalVolume.hh" 53 #include "G4ReflectionFactory.hh" 54 #include "G4PhysicalVolumeStore.hh" 55 #include "G4LogicalSkinSurface.hh" 56 #include "G4LogicalBorderSurface.hh" 57 #include "G4PVDivisionFactory.hh" 44 #include "G4Types.hh" 45 #include "geomdefs.hh" 58 46 59 47 #include "G4GDMLReadParamvol.hh" 48 49 class G4AssemblyVolume; 50 class G4LogicalVolume; 51 class G4VPhysicalVolume; 60 52 61 53 struct G4GDMLAuxPairType … … 67 59 typedef std::vector<G4GDMLAuxPairType> G4GDMLAuxListType; 68 60 typedef std::map<const G4LogicalVolume*,G4GDMLAuxListType> G4GDMLAuxMapType; 61 typedef std::map<G4String, G4AssemblyVolume*> G4GDMLAssemblyMapType; 69 62 70 63 class G4GDMLReadStructure : public G4GDMLReadParamvol … … 73 66 public: 74 67 68 G4GDMLReadStructure(); 69 virtual ~G4GDMLReadStructure(); 70 75 71 G4VPhysicalVolume* GetPhysvol(const G4String&) const; 76 72 G4LogicalVolume* GetVolume(const G4String&) const; 73 G4AssemblyVolume* GetAssembly(const G4String&) const; 77 74 G4GDMLAuxListType GetVolumeAuxiliaryInformation(const G4LogicalVolume* const); 78 75 G4VPhysicalVolume* GetWorldVolume(const G4String&); … … 86 83 87 84 G4GDMLAuxPairType AuxiliaryRead(const xercesc::DOMElement* const); 88 void BordersurfaceRead(const xercesc::DOMElement* const);85 void AssemblyRead(const xercesc::DOMElement* const); 89 86 void DivisionvolRead(const xercesc::DOMElement* const); 90 87 G4LogicalVolume* FileRead(const xercesc::DOMElement* const); 91 void PhysvolRead(const xercesc::DOMElement* const); 88 void PhysvolRead(const xercesc::DOMElement* const, 89 G4AssemblyVolume* assembly=0); 92 90 void ReplicavolRead(const xercesc::DOMElement* const, G4int number); 93 91 void ReplicaRead(const xercesc::DOMElement* const replicaElement, … … 95 93 EAxis AxisRead(const xercesc::DOMElement* const axisElement); 96 94 G4double QuantityRead(const xercesc::DOMElement* const readElement); 97 void SkinsurfaceRead(const xercesc::DOMElement* const); 95 void BorderSurfaceRead(const xercesc::DOMElement* const); 96 void SkinSurfaceRead(const xercesc::DOMElement* const); 98 97 99 98 protected: 100 99 101 100 G4GDMLAuxMapType auxMap; 101 G4GDMLAssemblyMapType assemblyMap; 102 102 G4LogicalVolume *pMotherLogical; 103 103 -
trunk/source/persistency/gdml/include/G4GDMLWrite.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWrite.hh,v 1. 37 2008/08/19 15:03:17gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWrite.hh,v 1.41 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 42 42 #define _G4GDMLWRITE_INCLUDED_ 43 43 44 #include <sys/stat.h> 45 #include <iostream> 44 #include <map> 46 45 47 46 #include <xercesc/dom/DOM.hpp> … … 50 49 #include <xercesc/framework/LocalFileFormatTarget.hpp> 51 50 52 #include "G4LogicalVolume.hh"53 51 #include "G4Transform3D.hh" 54 #include "G4PVDivision.hh" 52 53 class G4LogicalVolume; 54 class G4VPhysicalVolume; 55 55 56 56 class G4GDMLWrite 57 57 { 58 59 60 58 typedef std::map<const G4LogicalVolume*,G4Transform3D> VolumeMapType; 59 typedef std::map<const G4VPhysicalVolume*,G4String> PhysVolumeMapType; 60 typedef std::map<G4int,G4int> DepthMapType; 61 61 62 public: // withoutdescription62 public: // with description 63 63 64 G4Transform3D Write(const G4String& filename, 65 const G4LogicalVolume* const topLog, 66 const G4String& schemaPath, 67 const G4int depth, G4bool storeReferences=true); 68 void AddModule(const G4VPhysicalVolume* const topVol); 69 void AddModule(const G4int depth); 70 static void SetAddPointerToName(G4bool); 64 G4Transform3D Write(const G4String& filename, 65 const G4LogicalVolume* const topLog, 66 const G4String& schemaPath, 67 const G4int depth, G4bool storeReferences=true); 68 // 69 // Main method for writing GDML files. 71 70 72 protected: 71 void AddModule(const G4VPhysicalVolume* const topVol); 72 void AddModule(const G4int depth); 73 // 74 // Split geometry structure in modules, by volume subtree or level 73 75 74 G4String SchemaLocation; 76 static void SetAddPointerToName(G4bool); 77 // 78 // Specify if to add or not memory addresses to IDs. 75 79 76 VolumeMapType& VolumeMap(); 80 virtual void DefineWrite(xercesc::DOMElement*)=0; 81 virtual void MaterialsWrite(xercesc::DOMElement*)=0; 82 virtual void SolidsWrite(xercesc::DOMElement*)=0; 83 virtual void StructureWrite(xercesc::DOMElement*)=0; 84 virtual G4Transform3D TraverseVolumeTree(const G4LogicalVolume* const, 85 const G4int)=0; 86 virtual void SurfacesWrite()=0; 87 virtual void SetupWrite(xercesc::DOMElement*, 88 const G4LogicalVolume* const)=0; 89 // 90 // Pure virtual methods implemented in concrete writer plugin's classes 77 91 78 G4String GenerateName(const G4String&,const void* const); 79 xercesc::DOMAttr* NewAttribute(const G4String&, const G4String&); 80 xercesc::DOMAttr* NewAttribute(const G4String&, const G4double&); 81 xercesc::DOMElement* NewElement(const G4String&); 82 virtual void DefineWrite(xercesc::DOMElement*)=0; 83 virtual void MaterialsWrite(xercesc::DOMElement*)=0; 84 virtual void SolidsWrite(xercesc::DOMElement*)=0; 85 virtual void StructureWrite(xercesc::DOMElement*)=0; 86 virtual G4Transform3D TraverseVolumeTree(const G4LogicalVolume* const, 87 const G4int)=0; 88 virtual void SetupWrite(xercesc::DOMElement*, 89 const G4LogicalVolume* const)=0; 90 G4String Modularize(const G4VPhysicalVolume* const topvol, 91 const G4int depth); 92 virtual void ExtensionWrite(xercesc::DOMElement*); 93 virtual void AddExtension(xercesc::DOMElement*, 94 const G4LogicalVolume* const); 95 // 96 // To be implemented in the client code for handling extensions 97 // to the GDML schema, identified with the tag "extension". 98 // The implementation should be placed inside a user-class 99 // inheriting from G4GDMLWriteStructure and being registered 100 // as argument to G4GDMLParser. 92 101 93 private:102 protected: 94 103 95 G4bool FileExists(const G4String&) const; 96 PhysVolumeMapType& PvolumeMap(); 97 DepthMapType& DepthMap(); 104 G4GDMLWrite(); 105 virtual ~G4GDMLWrite(); 98 106 99 private:107 VolumeMapType& VolumeMap(); 100 108 101 static G4bool addPointerToName; 102 xercesc::DOMDocument* doc; 103 XMLCh tempStr[100]; 109 G4String GenerateName(const G4String&,const void* const); 110 xercesc::DOMAttr* NewAttribute(const G4String&, const G4String&); 111 xercesc::DOMAttr* NewAttribute(const G4String&, const G4double&); 112 xercesc::DOMElement* NewElement(const G4String&); 113 G4String Modularize(const G4VPhysicalVolume* const topvol, 114 const G4int depth); 115 116 G4bool FileExists(const G4String&) const; 117 PhysVolumeMapType& PvolumeMap(); 118 DepthMapType& DepthMap(); 119 120 protected: 121 122 G4String SchemaLocation; 123 static G4bool addPointerToName; 124 xercesc::DOMDocument* doc; 125 xercesc::DOMElement* extElement; 126 XMLCh tempStr[100]; 104 127 105 128 }; -
trunk/source/persistency/gdml/include/G4GDMLWriteDefine.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteDefine.hh,v 1.1 1 2008/07/16 15:46:33gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteDefine.hh,v 1.14 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 42 42 #define _G4GDMLWRITEDEFINE_INCLUDED_ 43 43 44 #include "G4Types.hh" 45 #include "G4ThreeVector.hh" 46 #include "G4RotationMatrix.hh" 47 44 48 #include "G4GDMLWrite.hh" 45 #include <sstream>46 49 47 50 class G4GDMLWriteDefine : public G4GDMLWrite 48 51 { 49 52 50 protected:53 public: 51 54 52 G4ThreeVector GetAngles(const G4RotationMatrix&); 53 void ScaleWrite(xercesc::DOMElement* element, const G4String& name, 54 const G4ThreeVector& scl) 55 { Scale_vectorWrite(element,"scale",name,scl); } 56 void RotationWrite(xercesc::DOMElement* element, const G4String& name, 57 const G4ThreeVector& rot) 58 { Rotation_vectorWrite(element,"rotation",name,rot); } 59 void PositionWrite(xercesc::DOMElement* element, const G4String& name, 60 const G4ThreeVector& pos) 61 { Position_vectorWrite(element,"position",name,pos); } 62 void FirstrotationWrite(xercesc::DOMElement* element, const G4String& name, 63 const G4ThreeVector& rot) 64 { Rotation_vectorWrite(element,"firstrotation",name,rot); } 65 void FirstpositionWrite(xercesc::DOMElement* element, const G4String& name, 66 const G4ThreeVector& pos) 67 { Position_vectorWrite(element,"firstposition",name,pos); } 68 void AddPosition(const G4String& name, 69 const G4ThreeVector& pos) 70 { Position_vectorWrite(defineElement,"position",name,pos); } 55 G4ThreeVector GetAngles(const G4RotationMatrix&); 56 void ScaleWrite(xercesc::DOMElement* element, 57 const G4String& name, const G4ThreeVector& scl) 58 { Scale_vectorWrite(element,"scale",name,scl); } 59 void RotationWrite(xercesc::DOMElement* element, 60 const G4String& name, const G4ThreeVector& rot) 61 { Rotation_vectorWrite(element,"rotation",name,rot); } 62 void PositionWrite(xercesc::DOMElement* element, 63 const G4String& name, const G4ThreeVector& pos) 64 { Position_vectorWrite(element,"position",name,pos); } 65 void FirstrotationWrite(xercesc::DOMElement* element, 66 const G4String& name, const G4ThreeVector& rot) 67 { Rotation_vectorWrite(element,"firstrotation",name,rot); } 68 void FirstpositionWrite(xercesc::DOMElement* element, 69 const G4String& name, const G4ThreeVector& pos) 70 { Position_vectorWrite(element,"firstposition",name,pos); } 71 void AddPosition(const G4String& name, const G4ThreeVector& pos) 72 { Position_vectorWrite(defineElement,"position",name,pos); } 71 73 72 protected:74 virtual void DefineWrite(xercesc::DOMElement*); 73 75 74 static const G4double kRelativePrecision; 75 static const G4double kAngularPrecision; 76 static const G4double kLinearPrecision; 76 protected: 77 78 G4GDMLWriteDefine(); 79 virtual ~G4GDMLWriteDefine(); 80 81 void Scale_vectorWrite(xercesc::DOMElement*, const G4String&, 82 const G4String&, const G4ThreeVector&); 83 void Rotation_vectorWrite(xercesc::DOMElement*, const G4String&, 84 const G4String&, const G4ThreeVector&); 85 void Position_vectorWrite(xercesc::DOMElement*, const G4String&, 86 const G4String&, const G4ThreeVector&); 87 88 protected: 89 90 static const G4double kRelativePrecision; 91 static const G4double kAngularPrecision; 92 static const G4double kLinearPrecision; 77 93 78 private: 79 80 void Scale_vectorWrite(xercesc::DOMElement*, const G4String&, 81 const G4String&, const G4ThreeVector&); 82 void Rotation_vectorWrite(xercesc::DOMElement*, const G4String&, 83 const G4String&, const G4ThreeVector&); 84 void Position_vectorWrite(xercesc::DOMElement*, const G4String&, 85 const G4String&, const G4ThreeVector&); 86 void DefineWrite(xercesc::DOMElement*); 87 88 private: 89 90 xercesc::DOMElement* defineElement; 94 xercesc::DOMElement* defineElement; 91 95 92 96 }; -
trunk/source/persistency/gdml/include/G4GDMLWriteMaterials.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteMaterials.hh,v 1.1 2 2008/07/16 15:46:33gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteMaterials.hh,v 1.17 2009/04/27 07:22:36 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 42 42 #define _G4GDMLWRITEMATERIALS_INCLUDED_ 43 43 44 #include "G4Element.hh" 45 #include "G4Isotope.hh" 46 #include "G4Material.hh" 44 #include "G4Types.hh" 45 #include <vector> 47 46 48 47 #include "G4GDMLWriteDefine.hh" 48 49 class G4Isotope; 50 class G4Element; 51 class G4Material; 52 class G4MaterialPropertyVector; 49 53 50 54 class G4GDMLWriteMaterials : public G4GDMLWriteDefine 51 55 { 52 56 53 p rotected:57 public: 54 58 55 59 void AddIsotope(const G4Isotope* const); … … 57 61 void AddMaterial(const G4Material* const); 58 62 59 private: 63 virtual void MaterialsWrite(xercesc::DOMElement*); 64 65 protected: 66 67 G4GDMLWriteMaterials(); 68 virtual ~G4GDMLWriteMaterials(); 60 69 61 70 void AtomWrite(xercesc::DOMElement*,const G4double&); … … 66 75 void ElementWrite(const G4Element* const); 67 76 void MaterialWrite(const G4Material* const); 68 void MaterialsWrite(xercesc::DOMElement*); 69 70 private: 77 void PropertyWrite(xercesc::DOMElement*, const G4Material* const); 78 void PropertyVectorWrite(const G4String&, 79 const G4MaterialPropertyVector* const); 80 protected: 71 81 72 82 std::vector<const G4Isotope*> isotopeList; -
trunk/source/persistency/gdml/include/G4GDMLWriteParamvol.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteParamvol.hh,v 1.1 0 2008/08/13 13:58:53gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteParamvol.hh,v 1.13 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 42 42 #define _G4GDMLWRITEPARAMVOL_INCLUDED_ 43 43 44 #include "G4PVParameterised.hh" 45 #include "G4VPhysicalVolume.hh" 44 #include "G4GDMLWriteSetup.hh" 46 45 47 #include "G4GDMLWriteSetup.hh" 46 class G4Box; 47 class G4Trd; 48 class G4Trap; 49 class G4Tubs; 50 class G4Cons; 51 class G4Sphere; 52 class G4Orb; 53 class G4Torus; 54 class G4Para; 55 class G4Hype; 56 class G4VPhysicalVolume; 48 57 49 58 class G4GDMLWriteParamvol : public G4GDMLWriteSetup 50 59 { 51 60 61 public: 62 63 virtual void ParamvolWrite(xercesc::DOMElement*, 64 const G4VPhysicalVolume* const); 65 virtual void ParamvolAlgorithmWrite(xercesc::DOMElement* paramvolElement, 66 const G4VPhysicalVolume* const paramvol); 67 52 68 protected: 53 69 54 void ParamvolWrite(xercesc::DOMElement*, const G4VPhysicalVolume* const); 55 56 private: 70 G4GDMLWriteParamvol(); 71 virtual ~G4GDMLWriteParamvol(); 57 72 58 73 void Box_dimensionsWrite(xercesc::DOMElement*, const G4Box* const); … … 68 83 void ParametersWrite(xercesc::DOMElement*, 69 84 const G4VPhysicalVolume* const, const G4int&); 70 void ParamvolAlgorithmWrite(xercesc::DOMElement* paramvolElement,71 const G4VPhysicalVolume* const paramvol);72 85 73 86 }; -
trunk/source/persistency/gdml/include/G4GDMLWriteSetup.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteSetup.hh,v 1. 7 2008/07/16 15:46:34gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteSetup.hh,v 1.9 2009/04/15 13:29:30 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 46 46 class G4GDMLWriteSetup : public G4GDMLWriteSolids 47 47 { 48 private:48 public: 49 49 50 void SetupWrite(xercesc::DOMElement*, const G4LogicalVolume* const); 50 virtual void SetupWrite(xercesc::DOMElement*, const G4LogicalVolume* const); 51 52 protected: 53 54 G4GDMLWriteSetup(); 55 virtual ~G4GDMLWriteSetup(); 56 51 57 }; 52 58 -
trunk/source/persistency/gdml/include/G4GDMLWriteSolids.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteSolids.hh,v 1.3 2 2008/11/21 09:32:46gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteSolids.hh,v 1.38 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 42 42 #define _G4GDMLWRITESOLIDS_INCLUDED_ 43 43 44 #include "G4BooleanSolid.hh" 45 #include "G4Box.hh" 46 #include "G4Cons.hh" 47 #include "G4Ellipsoid.hh" 48 #include "G4EllipticalCone.hh" 49 #include "G4EllipticalTube.hh" 50 #include "G4ExtrudedSolid.hh" 51 #include "G4Hype.hh" 52 #include "G4Orb.hh" 53 #include "G4Para.hh" 54 #include "G4Paraboloid.hh" 55 #include "G4IntersectionSolid.hh" 56 #include "G4Polycone.hh" 57 #include "G4Polyhedra.hh" 58 #include "G4ReflectedSolid.hh" 59 #include "G4Sphere.hh" 60 #include "G4SubtractionSolid.hh" 61 #include "G4TessellatedSolid.hh" 62 #include "G4Tet.hh" 63 #include "G4Torus.hh" 64 #include "G4Trap.hh" 65 #include "G4Trd.hh" 66 #include "G4Tubs.hh" 67 #include "G4TwistedBox.hh" 68 #include "G4TwistedTrap.hh" 69 #include "G4TwistedTrd.hh" 70 #include "G4TwistedTubs.hh" 71 #include "G4UnionSolid.hh" 44 #include "G4Types.hh" 72 45 73 46 #include "G4GDMLWriteMaterials.hh" 74 47 48 class G4BooleanSolid; 49 class G4Box; 50 class G4Cons; 51 class G4EllipticalCone; 52 class G4Ellipsoid; 53 class G4EllipticalTube; 54 class G4ExtrudedSolid; 55 class G4Hype; 56 class G4Orb; 57 class G4Para; 58 class G4Paraboloid; 59 class G4Polycone; 60 class G4Polyhedra; 61 class G4Sphere; 62 class G4TessellatedSolid; 63 class G4Tet; 64 class G4Torus; 65 class G4Trap; 66 class G4Trd; 67 class G4Tubs; 68 class G4TwistedBox; 69 class G4TwistedTrap; 70 class G4TwistedTrd; 71 class G4TwistedTubs; 72 class G4VSolid; 73 class G4OpticalSurface; 74 75 75 class G4GDMLWriteSolids : public G4GDMLWriteMaterials 76 76 { 77 public: 77 78 78 protected: 79 virtual void AddSolid(const G4VSolid* const); 80 virtual void SolidsWrite(xercesc::DOMElement*); 79 81 80 void AddSolid(const G4VSolid* const);82 protected: 81 83 82 private: 84 G4GDMLWriteSolids(); 85 virtual ~G4GDMLWriteSolids(); 83 86 84 87 void BooleanWrite(xercesc::DOMElement*, const G4BooleanSolid* const); … … 108 111 void ZplaneWrite(xercesc::DOMElement*, const G4double&, 109 112 const G4double&, const G4double&); 110 void SolidsWrite(xercesc::DOMElement*); 113 void OpticalSurfaceWrite(xercesc::DOMElement*, 114 const G4OpticalSurface* const); 111 115 112 private:116 protected: 113 117 114 118 std::vector<const G4VSolid*> solidList; 115 119 xercesc::DOMElement* solidsElement; 120 static const G4int maxTransforms = 8; // Constant for limiting the number 121 // of displacements/reflections 122 // applied to a single solid 116 123 }; 117 124 -
trunk/source/persistency/gdml/include/G4GDMLWriteStructure.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteStructure.hh,v 1.3 4 2008/07/16 15:46:34gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteStructure.hh,v 1.39 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 42 42 #define _G4GDMLWRITESTRUCTURE_INCLUDED_ 43 43 44 #include "G4LogicalVolumeStore.hh" 45 #include "G4PhysicalVolumeStore.hh" 46 #include "G4Material.hh" 47 #include "G4PVDivision.hh" 48 #include "G4PVReplica.hh" 49 #include "G4VPhysicalVolume.hh" 50 #include "G4ReflectedSolid.hh" 44 #include "G4Types.hh" 51 45 #include "G4Transform3D.hh" 52 46 53 47 #include "G4GDMLWriteParamvol.hh" 54 48 49 class G4LogicalVolume; 50 class G4VPhysicalVolume; 51 class G4PVDivision; 52 class G4LogicalBorderSurface; 53 class G4LogicalSkinSurface; 54 class G4OpticalSurface; 55 class G4SurfaceProperty; 56 55 57 class G4GDMLWriteStructure : public G4GDMLWriteParamvol 56 58 { 57 59 58 p rivate:60 public: 59 61 60 void DivisionvolWrite(xercesc::DOMElement*,const G4PVDivision* const); 62 G4GDMLWriteStructure(); 63 virtual ~G4GDMLWriteStructure(); 64 65 virtual void StructureWrite(xercesc::DOMElement*); 66 67 protected: 68 69 void DivisionvolWrite(xercesc::DOMElement*, const G4PVDivision* const); 61 70 void PhysvolWrite(xercesc::DOMElement*,const G4VPhysicalVolume* const topVol, 62 const G4Transform3D& transform, 63 const G4String& moduleName); 64 void ReplicavolWrite(xercesc::DOMElement*,const G4VPhysicalVolume* const); 65 void StructureWrite(xercesc::DOMElement*); 71 const G4Transform3D& transform, const G4String& moduleName); 72 void ReplicavolWrite(xercesc::DOMElement*, const G4VPhysicalVolume* const); 66 73 G4Transform3D TraverseVolumeTree(const G4LogicalVolume* const topVol, 67 74 const G4int depth); 68 private: 75 void SurfacesWrite(); 76 void BorderSurfaceCache(const G4LogicalBorderSurface* const); 77 void SkinSurfaceCache(const G4LogicalSkinSurface* const); 78 const G4LogicalBorderSurface* GetBorderSurface(const G4VPhysicalVolume* const); 79 const G4LogicalSkinSurface* GetSkinSurface(const G4LogicalVolume* const); 80 G4bool FindOpticalSurface(const G4SurfaceProperty*); 81 82 protected: 69 83 70 84 xercesc::DOMElement* structureElement; 71 static const int maxReflections = 8; // Constant for limiting the number 72 // of displacements/reflections applied 73 // to a single solid 85 std::vector<xercesc::DOMElement*> borderElementVec; 86 std::vector<xercesc::DOMElement*> skinElementVec; 87 88 private: // cache for optical surfaces... 89 90 std::vector<const G4OpticalSurface*> opt_vec; 74 91 }; 75 92 -
trunk/source/persistency/gdml/include/G4STRead.hh
r987 r1228 25 25 // 26 26 // 27 // $Id: G4STRead.hh,v 1. 3 2008/07/17 14:05:50 gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4STRead.hh,v 1.4 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 44 44 #define _G4STREAD_INCLUDED_ 45 45 46 #include <fstream>47 46 #include <vector> 48 47 #include <map> 49 48 50 #include "G4TessellatedSolid.hh" 51 #include "G4QuadrangularFacet.hh" 52 #include "G4TriangularFacet.hh" 53 #include "G4LogicalVolume.hh" 54 #include "G4PVPlacement.hh" 55 #include "G4Material.hh" 56 #include "G4Box.hh" 49 #include "G4ThreeVector.hh" 50 51 class G4Material; 52 class G4Box; 53 class G4TessellatedSolid; 54 class G4LogicalVolume; 57 55 58 56 class G4STRead -
trunk/source/persistency/gdml/src/G4GDMLEvaluator.cc
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLEvaluator.cc,v 1.2 2 2009/02/26 10:13:35gcosmo Exp $27 // $Id: G4GDMLEvaluator.cc,v 1.23 2009/04/24 15:34:20 gcosmo Exp $ 28 28 // GEANT4 tag $ Name:$ 29 29 // … … 35 35 36 36 #include <sstream> 37 38 #include "globals.hh" 39 37 40 #include "G4GDMLEvaluator.hh" 38 41 -
trunk/source/persistency/gdml/src/G4GDMLParameterisation.cc
r987 r1228 25 25 // 26 26 // $Id: G4GDMLParameterisation.cc,v 1.11 2008/07/16 15:46:34 gcosmo Exp $ 27 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // GEANT4 tag $Name: geant4-09-03 $ 28 28 // 29 29 // class G4GDMLParameterisation Implementation -
trunk/source/persistency/gdml/src/G4GDMLParser.cc
r921 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLParser.cc,v 1.1 3 2008/11/20 15:33:52gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-cand-01$27 // $Id: G4GDMLParser.cc,v 1.14 2009/04/15 13:29:30 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // … … 36 36 37 37 G4GDMLParser::G4GDMLParser() 38 : u code(false)38 : urcode(false), uwcode(false) 39 39 { 40 40 reader = new G4GDMLReadStructure; … … 43 43 } 44 44 45 G4GDMLParser::G4GDMLParser(G4GDMLReadStructure* ext )46 : u code(true)45 G4GDMLParser::G4GDMLParser(G4GDMLReadStructure* extr) 46 : urcode(true), uwcode(false) 47 47 { 48 reader = ext ;48 reader = extr; 49 49 writer = new G4GDMLWriteStructure; 50 xercesc::XMLPlatformUtils::Initialize(); 51 } 52 53 G4GDMLParser::G4GDMLParser(G4GDMLReadStructure* extr, 54 G4GDMLWriteStructure* extw) 55 : urcode(true), uwcode(true) 56 { 57 reader = extr; 58 writer = extw; 50 59 xercesc::XMLPlatformUtils::Initialize(); 51 60 } … … 54 63 { 55 64 xercesc::XMLPlatformUtils::Terminate(); 56 delete writer;57 if (!u code) { delete reader; }65 if (!urcode) { delete reader; } 66 if (!uwcode) { delete writer; } 58 67 } -
trunk/source/persistency/gdml/src/G4GDMLRead.cc
r987 r1228 24 24 // ******************************************************************** 25 25 // 26 // $Id: G4GDMLRead.cc,v 1.4 1 2009/01/22 11:02:07gcosmo Exp $27 // GEANT4 tag $Name: geant4-09-0 2-ref-02$26 // $Id: G4GDMLRead.cc,v 1.47 2009/05/12 15:46:43 gcosmo Exp $ 27 // GEANT4 tag $Name: geant4-09-03 $ 28 28 // 29 29 // class G4GDMLRead Implementation … … 33 33 // ------------------------------------------------------------------------- 34 34 35 #include "globals.hh" 36 35 37 #include "G4GDMLRead.hh" 38 39 #include "G4UnitsTable.hh" 36 40 #include "G4Element.hh" 37 41 #include "G4Material.hh" … … 39 43 #include "G4LogicalVolumeStore.hh" 40 44 #include "G4PhysicalVolumeStore.hh" 41 #include "G4UnitsTable.hh"42 45 43 46 G4GDMLRead::G4GDMLRead() 44 : validate(true), check(false) 47 : validate(true), check(false), inLoop(0), loopCount(0) 45 48 { 46 49 G4UnitDefinition::BuildUnitsTable(); … … 68 71 G4String nameOut(nameIn); 69 72 70 if (inLoop>0) { nameOut = eval.SolveBrackets(nameOut); } 73 if (inLoop>0) 74 { 75 nameOut = eval.SolveBrackets(nameOut); 76 // std::stringstream stream; 77 // stream << "0x" << loopCount; 78 // nameOut = nameOut + stream.str(); 79 } 71 80 if (strip) { StripName(nameOut); } 72 81 … … 235 244 236 245 inLoop++; 237 246 238 247 while (_var <= _to) 239 248 { 240 249 eval.SetVariable(var,_var); 241 250 (this->*func)(element); 242 243 251 _var += _step; 252 loopCount++; 244 253 } 245 254 246 255 inLoop--; 256 if (!inLoop) { loopCount = 0; } 247 257 } 248 258 -
trunk/source/persistency/gdml/src/G4GDMLReadDefine.cc
r987 r1228 24 24 // ******************************************************************** 25 25 // 26 // $Id: G4GDMLReadDefine.cc,v 1.2 0 2008/07/16 15:46:34gcosmo Exp $27 // GEANT4 tag $Name: geant4-09-0 2-ref-02$26 // $Id: G4GDMLReadDefine.cc,v 1.24 2009/10/14 13:10:18 gcosmo Exp $ 27 // GEANT4 tag $Name: geant4-09-03 $ 28 28 // 29 29 // class G4GDMLReadDefine Implementation … … 36 36 37 37 G4GDMLMatrix::G4GDMLMatrix() 38 { 39 rows = 0; 40 cols = 0; 41 m = 0; 42 } 43 44 G4GDMLMatrix::G4GDMLMatrix(size_t rows0,size_t cols0) 38 : m(0), rows(0), cols(0) 39 { 40 } 41 42 G4GDMLMatrix::G4GDMLMatrix(size_t rows0, size_t cols0) 45 43 { 44 if ((rows<=0) || (cols<=0)) 45 { 46 G4Exception("G4GDMLMatrix::G4GDMLMatrix(r,c)", "InvalidSetup", 47 FatalException, "Zero indeces as arguments!?"); 48 } 46 49 rows = rows0; 47 50 cols = cols0; … … 49 52 } 50 53 54 G4GDMLMatrix::G4GDMLMatrix(const G4GDMLMatrix& rhs) 55 : m(0), rows(0), cols(0) 56 { 57 if (rhs.m) 58 { 59 rows = rhs.rows; 60 cols = rhs.cols; 61 m = new G4double[rows*cols]; 62 for (size_t i=0; i<rows*cols; i++) { m[i] = rhs.m[i]; } 63 } 64 } 65 66 G4GDMLMatrix& G4GDMLMatrix::operator=(const G4GDMLMatrix& rhs) 67 { 68 // Check assignment to self 69 // 70 if (this == &rhs) { return *this; } 71 72 // Copy data 73 // 74 rows = rhs.rows; 75 cols = rhs.cols; 76 if (rhs.m) 77 { 78 m = new G4double[rows*cols]; 79 for (size_t i=0; i<rows*cols; i++) { m[i] = rhs.m[i]; } 80 } 81 else 82 { 83 m = 0; 84 } 85 86 return *this; 87 } 88 51 89 G4GDMLMatrix::~G4GDMLMatrix() 52 90 { 53 if (m) { delete [] m; }91 delete [] m; 54 92 } 55 93 … … 84 122 } 85 123 124 G4GDMLReadDefine::G4GDMLReadDefine() : G4GDMLRead() 125 { 126 } 127 128 G4GDMLReadDefine::~G4GDMLReadDefine() 129 { 130 } 131 86 132 G4RotationMatrix 87 133 G4GDMLReadDefine::GetRotationMatrix(const G4ThreeVector& angles) … … 122 168 } 123 169 170 eval.DefineConstant(name,value); 171 } 172 173 void 174 G4GDMLReadDefine::ExpressionRead(const xercesc::DOMElement* const expElement) 175 { 176 G4String name = ""; 177 G4double value = 0.0; 178 179 const xercesc::DOMNamedNodeMap* const attributes 180 = expElement->getAttributes(); 181 XMLSize_t attributeCount = attributes->getLength(); 182 183 for (XMLSize_t attribute_index=0; 184 attribute_index<attributeCount; attribute_index++) 185 { 186 xercesc::DOMNode* node = attributes->item(attribute_index); 187 188 if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; } 189 190 const xercesc::DOMAttr* const attribute 191 = dynamic_cast<xercesc::DOMAttr*>(node); 192 const G4String attName = Transcode(attribute->getName()); 193 const G4String attValue = Transcode(attribute->getValue()); 194 195 if (attName=="name") { name = attValue; } 196 } 197 198 const G4String expValue = Transcode(expElement->getTextContent()); 199 value = eval.Evaluate(expValue); 124 200 eval.DefineConstant(name,value); 125 201 } … … 328 404 329 405 quantityMap[name] = value*unit; 406 eval.DefineConstant(name,value*unit); 330 407 } 331 408 … … 350 427 if (tag=="scale") { ScaleRead(child); } else 351 428 if (tag=="variable") { VariableRead(child); } else 352 if (tag=="quantity") { QuantityRead(child); } 429 if (tag=="quantity") { QuantityRead(child); } else 430 if (tag=="expression") { ExpressionRead(child); } 353 431 else 354 432 { -
trunk/source/persistency/gdml/src/G4GDMLReadMaterials.cc
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLReadMaterials.cc,v 1. 16 2008/08/22 10:00:20 gcosmo Exp $27 // $Id: G4GDMLReadMaterials.cc,v 1.20 2009/04/24 15:34:20 gcosmo Exp $ 28 28 // GEANT4 tag $ Name:$ 29 29 // … … 35 35 36 36 #include "G4GDMLReadMaterials.hh" 37 38 #include "G4Element.hh" 39 #include "G4Isotope.hh" 40 #include "G4Material.hh" 41 #include "G4NistManager.hh" 42 43 G4GDMLReadMaterials::G4GDMLReadMaterials() : G4GDMLReadDefine() 44 { 45 } 46 47 G4GDMLReadMaterials::~G4GDMLReadMaterials() 48 { 49 } 37 50 38 51 G4double … … 497 510 if (matrix.GetRows() == 0) { return; } 498 511 499 G4MaterialPropertiesTable* matprop =material->GetMaterialPropertiesTable();512 G4MaterialPropertiesTable* matprop=material->GetMaterialPropertiesTable(); 500 513 if (!matprop) 501 514 { 502 material->SetMaterialPropertiesTable( 503 matprop = new G4MaterialPropertiesTable()); 504 } 505 G4MaterialPropertyVector* propvect = new G4MaterialPropertyVector(0,0,0); 506 for (size_t i=0; i<matrix.GetRows(); i++) 507 { 508 propvect->AddElement(matrix.Get(i,0),matrix.Get(i,1)); 509 } 510 matprop->AddProperty(Strip(name),propvect); 515 matprop = new G4MaterialPropertiesTable(); 516 material->SetMaterialPropertiesTable(matprop); 517 } 518 if (matrix.GetCols() == 1) // constant property assumed 519 { 520 matprop->AddConstProperty(Strip(name), matrix.Get(0,0)); 521 } 522 else // build the material properties vector 523 { 524 G4MaterialPropertyVector* propvect = new G4MaterialPropertyVector(0,0,0); 525 for (size_t i=0; i<matrix.GetRows(); i++) 526 { 527 propvect->AddElement(matrix.Get(i,0),matrix.Get(i,1)); 528 } 529 matprop->AddProperty(Strip(name),propvect); 530 } 511 531 } 512 532 … … 524 544 = dynamic_cast<xercesc::DOMElement*>(iter); 525 545 const G4String tag = Transcode(child->getTagName()); 526 546 547 if (tag=="define") { DefineRead(child); } else 527 548 if (tag=="element") { ElementRead(child); } else 528 549 if (tag=="isotope") { IsotopeRead(child); } else -
trunk/source/persistency/gdml/src/G4GDMLReadParamvol.cc
r987 r1228 24 24 // ******************************************************************** 25 25 // 26 // $Id: G4GDMLReadParamvol.cc,v 1.1 1 2009/01/22 11:02:07gcosmo Exp $27 // GEANT4 tag $Name: geant4-09-0 2-ref-02$26 // $Id: G4GDMLReadParamvol.cc,v 1.13 2009/04/24 15:34:20 gcosmo Exp $ 27 // GEANT4 tag $Name: geant4-09-03 $ 28 28 // 29 29 // class G4GDMLReadParamvol Implementation … … 34 34 35 35 #include "G4GDMLReadParamvol.hh" 36 37 #include "G4LogicalVolume.hh" 38 #include "G4PVParameterised.hh" 39 #include "G4PVPlacement.hh" 40 #include "G4VPhysicalVolume.hh" 41 42 G4GDMLReadParamvol::G4GDMLReadParamvol() : G4GDMLReadSetup() 43 { 44 } 45 46 G4GDMLReadParamvol::~G4GDMLReadParamvol() 47 { 48 } 36 49 37 50 void G4GDMLReadParamvol:: -
trunk/source/persistency/gdml/src/G4GDMLReadSetup.cc
r987 r1228 24 24 // ******************************************************************** 25 25 // 26 // $Id: G4GDMLReadSetup.cc,v 1. 9 2008/07/16 15:46:34gcosmo Exp $27 // GEANT4 tag $Name: geant4-09-0 2-ref-02$26 // $Id: G4GDMLReadSetup.cc,v 1.10 2009/03/24 15:47:33 gcosmo Exp $ 27 // GEANT4 tag $Name: geant4-09-03 $ 28 28 // 29 29 // class G4GDMLReadSetup Implementation … … 34 34 35 35 #include "G4GDMLReadSetup.hh" 36 37 G4GDMLReadSetup::G4GDMLReadSetup() : G4GDMLReadSolids() 38 { 39 } 40 41 G4GDMLReadSetup::~G4GDMLReadSetup() 42 { 43 } 36 44 37 45 G4String G4GDMLReadSetup::GetSetup(const G4String& ref) -
trunk/source/persistency/gdml/src/G4GDMLReadSolids.cc
r987 r1228 24 24 // ******************************************************************** 25 25 // 26 // $Id: G4GDMLReadSolids.cc,v 1.2 2 2008/11/21 09:32:46gcosmo Exp $27 // GEANT4 tag $Name: geant4-09-0 2-ref-02$26 // $Id: G4GDMLReadSolids.cc,v 1.27 2009/12/04 13:58:51 gcosmo Exp $ 27 // GEANT4 tag $Name: geant4-09-03 $ 28 28 // 29 29 // class G4GDMLReadSolids Implementation … … 34 34 35 35 #include "G4GDMLReadSolids.hh" 36 37 #include "G4Box.hh" 38 #include "G4Cons.hh" 39 #include "G4Ellipsoid.hh" 40 #include "G4EllipticalCone.hh" 41 #include "G4EllipticalTube.hh" 42 #include "G4Hype.hh" 43 #include "G4IntersectionSolid.hh" 44 #include "G4Orb.hh" 45 #include "G4Para.hh" 46 #include "G4Paraboloid.hh" 47 #include "G4Polycone.hh" 48 #include "G4Polyhedra.hh" 49 #include "G4QuadrangularFacet.hh" 50 #include "G4ReflectedSolid.hh" 51 #include "G4Sphere.hh" 52 #include "G4SolidStore.hh" 53 #include "G4SubtractionSolid.hh" 54 #include "G4TessellatedSolid.hh" 55 #include "G4Tet.hh" 56 #include "G4Torus.hh" 57 #include "G4Transform3D.hh" 58 #include "G4Trap.hh" 59 #include "G4Trd.hh" 60 #include "G4TriangularFacet.hh" 61 #include "G4Tubs.hh" 62 #include "G4TwistedBox.hh" 63 #include "G4TwistedTrap.hh" 64 #include "G4TwistedTrd.hh" 65 #include "G4TwistedTubs.hh" 66 #include "G4UnionSolid.hh" 67 #include "G4OpticalSurface.hh" 68 #include "G4SurfaceProperty.hh" 69 70 G4GDMLReadSolids::G4GDMLReadSolids() : G4GDMLReadMaterials() 71 { 72 } 73 74 G4GDMLReadSolids::~G4GDMLReadSolids() 75 { 76 } 36 77 37 78 void G4GDMLReadSolids:: … … 1478 1519 1479 1520 void G4GDMLReadSolids:: 1480 Optical surfaceRead(const xercesc::DOMElement* const opticalsurfaceElement)1521 OpticalSurfaceRead(const xercesc::DOMElement* const opticalsurfaceElement) 1481 1522 { 1482 1523 G4String name; … … 1514 1555 G4SurfaceType type; 1515 1556 1516 if (smodel="unified") { model = unified; } else { model = glisur; } 1557 if (smodel="unified") { model = unified; } else 1558 if (smodel="glisur") { model = glisur; } 1559 else { model = LUT; } 1517 1560 1518 1561 if (sfinish=="polishedfrontpainted") { finish = polishedfrontpainted; } else … … 1520 1563 if (sfinish=="groundfrontpainted") { finish = groundfrontpainted; } else 1521 1564 if (sfinish=="groundbackpainted") { finish = groundbackpainted; } else 1522 if (sfinish=="ground") { finish = ground; } else { finish = polished; } 1565 if (sfinish=="ground") { finish = ground; } else 1566 if (sfinish=="polished") { finish = polished; } else 1567 if (sfinish=="polishedlumirrorair") { finish = polishedlumirrorair; } else 1568 if (sfinish=="polishedlumirrorglue") { finish = polishedlumirrorglue; } else 1569 if (sfinish=="polishedair") { finish = polishedair; } else 1570 if (sfinish=="polishedteflonair") { finish = polishedteflonair; } else 1571 if (sfinish=="polishedtioair") { finish = polishedtioair; } else 1572 if (sfinish=="polishedtyvekair") { finish = polishedtyvekair; } else 1573 if (sfinish=="polishedvm2000air") { finish = polishedvm2000air; } else 1574 if (sfinish=="polishedvm2000glue") { finish = polishedvm2000glue; } else 1575 if (sfinish=="etchedlumirrorair") { finish = etchedlumirrorair; } else 1576 if (sfinish=="etchedlumirrorglue") { finish = etchedlumirrorglue; } else 1577 if (sfinish=="etchedair") { finish = etchedair; } else 1578 if (sfinish=="etchedteflonair") { finish = etchedteflonair; } else 1579 if (sfinish=="etchedtioair") { finish = etchedtioair; } else 1580 if (sfinish=="etchedtyvekair") { finish = etchedtyvekair; } else 1581 if (sfinish=="etchedvm2000air") { finish = etchedvm2000air; } else 1582 if (sfinish=="etchedvm2000glue") { finish = etchedvm2000glue; } else 1583 if (sfinish=="groundlumirrorair") { finish = groundlumirrorair; } else 1584 if (sfinish=="groundlumirrorglue") { finish = groundlumirrorglue; } else 1585 if (sfinish=="groundair") { finish = groundair; } else 1586 if (sfinish=="groundteflonair") { finish = groundteflonair; } else 1587 if (sfinish=="groundtioair") { finish = groundtioair; } else 1588 if (sfinish=="groundtyvekair") { finish = groundtyvekair; } else 1589 if (sfinish=="groundvm2000air") { finish = groundvm2000air; } 1590 else { finish = groundvm2000glue; } 1523 1591 1524 1592 if (stype=="dielectric_metal") { type = dielectric_metal; } else 1525 if (stype=="x_ray") { type = x_ray; } else 1526 if (stype=="firsov") { type = firsov; } else { type = dielectric_dielectric; } 1593 if (stype=="dielectric_dielectric") { type = dielectric_dielectric; } else 1594 if (stype=="dielectric_LUT") { type = dielectric_LUT; } else 1595 if (stype=="x_ray") { type = x_ray; } 1596 else { type = firsov; } 1527 1597 1528 1598 new G4OpticalSurface(name,model,finish,type,value); … … 1541 1611 = dynamic_cast<xercesc::DOMElement*>(iter); 1542 1612 const G4String tag = Transcode(child->getTagName()); 1543 1544 if (tag=="box") { BoxRead(child); } else1545 if (tag=="cone") { ConeRead(child); } else1613 if (tag=="define") { DefineRead(child); } else 1614 if (tag=="box") { BoxRead(child); } else 1615 if (tag=="cone") { ConeRead(child); } else 1546 1616 if (tag=="elcone") { ElconeRead(child); } else 1547 1617 if (tag=="ellipsoid") { EllipsoidRead(child); }else … … 1569 1639 if (tag=="twistedtubs") { TwistedtubsRead(child); } else 1570 1640 if (tag=="union") { BooleanRead(child,UNION); } else 1571 if (tag=="opticalsurface") { Optical surfaceRead(child); } else1641 if (tag=="opticalsurface") { OpticalSurfaceRead(child); } else 1572 1642 if (tag=="loop") { LoopRead(child,&G4GDMLRead::SolidsRead); } 1573 1643 else -
trunk/source/persistency/gdml/src/G4GDMLReadStructure.cc
r987 r1228 24 24 // ******************************************************************** 25 25 // 26 // $Id: G4GDMLReadStructure.cc,v 1. 56 2009/02/24 17:41:44 gcosmo Exp $27 // GEANT4 tag $Name: geant4-09-0 2-ref-02$26 // $Id: G4GDMLReadStructure.cc,v 1.62 2009/09/24 15:04:34 gcosmo Exp $ 27 // GEANT4 tag $Name: geant4-09-03 $ 28 28 // 29 29 // class G4GDMLReadStructure Implementation … … 35 35 #include "G4GDMLReadStructure.hh" 36 36 37 #include "G4LogicalVolume.hh" 38 #include "G4VPhysicalVolume.hh" 39 #include "G4PVPlacement.hh" 40 #include "G4LogicalVolumeStore.hh" 41 #include "G4PhysicalVolumeStore.hh" 42 #include "G4AssemblyVolume.hh" 43 #include "G4ReflectionFactory.hh" 44 #include "G4PVDivisionFactory.hh" 45 #include "G4LogicalBorderSurface.hh" 46 #include "G4LogicalSkinSurface.hh" 47 #include "G4VisAttributes.hh" 48 49 G4GDMLReadStructure::G4GDMLReadStructure() : G4GDMLReadParamvol() 50 { 51 } 52 53 G4GDMLReadStructure::~G4GDMLReadStructure() 54 { 55 } 56 37 57 G4GDMLAuxPairType G4GDMLReadStructure:: 38 58 AuxiliaryRead(const xercesc::DOMElement* const auxiliaryElement) … … 65 85 66 86 void G4GDMLReadStructure:: 67 Border surfaceRead(const xercesc::DOMElement* const bordersurfaceElement)87 BorderSurfaceRead(const xercesc::DOMElement* const bordersurfaceElement) 68 88 { 69 89 G4String name; … … 255 275 256 276 void G4GDMLReadStructure:: 257 PhysvolRead(const xercesc::DOMElement* const physvolElement) 277 PhysvolRead(const xercesc::DOMElement* const physvolElement, 278 G4AssemblyVolume* pAssembly) 258 279 { 259 280 G4String name; 260 281 G4LogicalVolume* logvol = 0; 282 G4AssemblyVolume* assembly = 0; 261 283 G4ThreeVector position(0.0,0.0,0.0); 262 284 G4ThreeVector rotation(0.0,0.0,0.0); … … 270 292 attribute_index<attributeCount; attribute_index++) 271 293 { 272 273 274 275 276 277 278 279 280 281 282 294 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 295 296 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 297 { continue; } 298 299 const xercesc::DOMAttr* const attribute 300 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 301 const G4String attName = Transcode(attribute->getName()); 302 const G4String attValue = Transcode(attribute->getValue()); 303 304 if (attName=="name") { name = attValue; } 283 305 } 284 306 … … 286 308 iter != 0; iter = iter->getNextSibling()) 287 309 { 288 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } 289 290 const xercesc::DOMElement* const child 291 = dynamic_cast<xercesc::DOMElement*>(iter); 292 const G4String tag = Transcode(child->getTagName()); 293 294 if (tag=="file") 295 { logvol = FileRead(child); } else 296 if (tag=="volumeref") 297 { logvol = GetVolume(GenerateName(RefRead(child))); } else 298 if (tag=="position") 299 { VectorRead(child,position); } else 300 if (tag=="rotation") 301 { VectorRead(child,rotation); } else 302 if (tag=="scale") 303 { VectorRead(child,scale); } else 304 if (tag=="positionref") 305 { position = GetPosition(GenerateName(RefRead(child))); } else 306 if (tag=="rotationref") 307 { rotation = GetRotation(GenerateName(RefRead(child))); } else 308 if (tag=="scaleref") 310 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } 311 312 const xercesc::DOMElement* const child 313 = dynamic_cast<xercesc::DOMElement*>(iter); 314 const G4String tag = Transcode(child->getTagName()); 315 316 if (tag=="volumeref") 317 { 318 const G4String& child_name = GenerateName(RefRead(child)); 319 assembly = GetAssembly(child_name); 320 if (!assembly) { logvol = GetVolume(child_name); } 321 } 322 else if (tag=="file") 323 { logvol = FileRead(child); } 324 else if (tag=="position") 325 { VectorRead(child,position); } 326 else if (tag=="rotation") 327 { VectorRead(child,rotation); } 328 else if (tag=="scale") 329 { VectorRead(child,scale); } 330 else if (tag=="positionref") 331 { position = GetPosition(GenerateName(RefRead(child))); } 332 else if (tag=="rotationref") 333 { rotation = GetRotation(GenerateName(RefRead(child))); } 334 else if (tag=="scaleref") 309 335 { scale = GetScale(GenerateName(RefRead(child))); } 310 311 {312 G4String error_msg = "Unknown tag in physvol: " + tag;313 G4Exception("G4GDMLReadStructure::PhysvolRead()", "ReadError",314 FatalException, error_msg);315 }336 else 337 { 338 G4String error_msg = "Unknown tag in physvol: " + tag; 339 G4Exception("G4GDMLReadStructure::PhysvolRead()", "ReadError", 340 FatalException, error_msg); 341 } 316 342 } 317 343 … … 319 345 transform = transform*G4Scale3D(scale.x(),scale.y(),scale.z()); 320 346 321 G4String pv_name = logvol->GetName() + "_PV"; 322 G4PhysicalVolumesPair pair = G4ReflectionFactory::Instance() 323 ->Place(transform,pv_name,logvol,pMotherLogical,false,0,check); 324 325 if (pair.first != 0) { GeneratePhysvolName(name,pair.first); } 326 if (pair.second != 0) { GeneratePhysvolName(name,pair.second); } 347 if (pAssembly) // Fill assembly structure 348 { 349 pAssembly->AddPlacedVolume(logvol, transform); 350 } 351 else // Generate physical volume tree or do assembly imprint 352 { 353 if (assembly) 354 { 355 assembly->MakeImprint(pMotherLogical, transform, 0, check); 356 } 357 else 358 { 359 G4String pv_name = logvol->GetName() + "_PV"; 360 G4PhysicalVolumesPair pair = G4ReflectionFactory::Instance() 361 ->Place(transform,pv_name,logvol,pMotherLogical,false,0,check); 362 363 if (pair.first != 0) { GeneratePhysvolName(name,pair.first); } 364 if (pair.second != 0) { GeneratePhysvolName(name,pair.second); } 365 } 366 } 327 367 } 328 368 … … 510 550 511 551 void G4GDMLReadStructure:: 512 SkinsurfaceRead(const xercesc::DOMElement* const skinsurfaceElement) 552 AssemblyRead(const xercesc::DOMElement* const assemblyElement) 553 { 554 XMLCh *name_attr = xercesc::XMLString::transcode("name"); 555 const G4String name = Transcode(assemblyElement->getAttribute(name_attr)); 556 xercesc::XMLString::release(&name_attr); 557 558 G4AssemblyVolume* pAssembly = new G4AssemblyVolume(); 559 assemblyMap.insert(std::make_pair(GenerateName(name), pAssembly)); 560 561 for (xercesc::DOMNode* iter = assemblyElement->getFirstChild(); 562 iter != 0; iter = iter->getNextSibling()) 563 { 564 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } 565 const xercesc::DOMElement* const child 566 = dynamic_cast<xercesc::DOMElement*>(iter); 567 const G4String tag = Transcode(child->getTagName()); 568 569 if (tag=="physvol") 570 { 571 PhysvolRead(child, pAssembly); 572 } 573 else 574 { 575 G4cout << "Unsupported GDML tag '" << tag 576 << "' for Geant4 assembly structure !" << G4endl; 577 } 578 } 579 } 580 581 void G4GDMLReadStructure:: 582 SkinSurfaceRead(const xercesc::DOMElement* const skinsurfaceElement) 513 583 { 514 584 G4String name; … … 643 713 const G4String tag = Transcode(child->getTagName()); 644 714 645 if (tag=="bordersurface") { Border surfaceRead(child); } else646 if (tag=="skinsurface") { Skin surfaceRead(child); } else715 if (tag=="bordersurface") { BorderSurfaceRead(child); } else 716 if (tag=="skinsurface") { SkinSurfaceRead(child); } else 647 717 if (tag=="volume") { VolumeRead(child); } else 718 if (tag=="assembly") { AssemblyRead(child); } else 648 719 if (tag=="loop") { LoopRead(child,&G4GDMLRead::StructureRead); } 649 720 else … … 688 759 } 689 760 761 G4AssemblyVolume* G4GDMLReadStructure:: 762 GetAssembly(const G4String& ref) const 763 { 764 G4GDMLAssemblyMapType::const_iterator pos = assemblyMap.find(ref); 765 if (pos != assemblyMap.end()) { return pos->second; } 766 return 0; 767 } 768 690 769 G4GDMLAuxListType G4GDMLReadStructure:: 691 770 GetVolumeAuxiliaryInformation(const G4LogicalVolume* const logvol) 692 771 { 693 if (auxMap.find(logvol) != auxMap.end()) { return auxMap[logvol]; } 772 G4GDMLAuxMapType::const_iterator pos = auxMap.find(logvol); 773 if (pos != auxMap.end()) { return pos->second; } 694 774 else { return G4GDMLAuxListType(); } 695 775 } -
trunk/source/persistency/gdml/src/G4GDMLWrite.cc
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWrite.cc,v 1.5 0 2008/11/13 17:00:50 gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWrite.cc,v 1.55 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // class G4GDMLWrite Implementation … … 34 34 // -------------------------------------------------------------------- 35 35 36 #include <sys/stat.h> 37 #include <iostream> 38 36 39 #include "G4GDMLWrite.hh" 37 40 41 #include "G4LogicalVolume.hh" 42 #include "G4Transform3D.hh" 43 #include "G4PVDivision.hh" 44 38 45 G4bool G4GDMLWrite::addPointerToName = true; 46 47 G4GDMLWrite::G4GDMLWrite() : extElement(0) 48 { 49 } 50 51 G4GDMLWrite::~G4GDMLWrite() 52 { 53 } 39 54 40 55 G4bool G4GDMLWrite::FileExists(const G4String& fname) const … … 62 77 } 63 78 79 void G4GDMLWrite::AddExtension(xercesc::DOMElement*, 80 const G4LogicalVolume* const) 81 { 82 // Empty implementation. To be overwritten by user for specific extensions 83 // related to attributes associated to volumes 84 } 85 86 void G4GDMLWrite::ExtensionWrite(xercesc::DOMElement*) 87 { 88 // Empty implementation. To be overwritten by user for specific extensions 89 } 90 64 91 G4String G4GDMLWrite::GenerateName(const G4String& name, const void* const ptr) 65 92 { 93 G4String nameOut; 66 94 std::stringstream stream; stream << name; 67 if (addPointerToName) { stream << ptr; } 68 return G4String(stream.str()); 95 if (addPointerToName) { stream << ptr; }; 96 97 nameOut=G4String(stream.str()); 98 if(nameOut.contains(' ')) 99 nameOut.erase(std::remove(nameOut.begin(),nameOut.end(),' '),nameOut.end()); 100 101 return nameOut; 69 102 } 70 103 … … 153 186 SchemaLocation)); 154 187 188 ExtensionWrite(gdml); 155 189 DefineWrite(gdml); 156 190 MaterialsWrite(gdml); … … 161 195 G4Transform3D R = TraverseVolumeTree(logvol,depth); 162 196 197 SurfacesWrite(); 163 198 xercesc::XMLFormatTarget *myFormTarget = 164 199 new xercesc::LocalFileFormatTarget(fname.c_str()); -
trunk/source/persistency/gdml/src/G4GDMLWriteDefine.cc
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteDefine.cc,v 1.1 8 2008/07/16 15:46:34gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteDefine.cc,v 1.19 2009/03/24 15:47:33 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // class G4GDMLWriteDefine Implementation … … 39 39 const G4double G4GDMLWriteDefine::kAngularPrecision = DBL_EPSILON; 40 40 const G4double G4GDMLWriteDefine::kLinearPrecision = DBL_EPSILON; 41 42 G4GDMLWriteDefine::G4GDMLWriteDefine() : G4GDMLWrite() 43 { 44 } 45 46 G4GDMLWriteDefine::~G4GDMLWriteDefine() 47 { 48 } 41 49 42 50 G4ThreeVector G4GDMLWriteDefine::GetAngles(const G4RotationMatrix& mat) -
trunk/source/persistency/gdml/src/G4GDMLWriteMaterials.cc
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteMaterials.cc,v 1.2 0 2008/07/16 15:46:34gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteMaterials.cc,v 1.24 2009/04/27 07:22:36 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // class G4GDMLWriteMaterials Implementation … … 34 34 // -------------------------------------------------------------------- 35 35 36 #include <sstream> 36 37 #include "G4GDMLWriteMaterials.hh" 38 39 #include "G4Element.hh" 40 #include "G4Isotope.hh" 41 #include "G4Material.hh" 42 43 G4GDMLWriteMaterials:: 44 G4GDMLWriteMaterials() : G4GDMLWriteDefine() 45 { 46 } 47 48 G4GDMLWriteMaterials:: 49 ~G4GDMLWriteMaterials() 50 { 51 } 37 52 38 53 void G4GDMLWriteMaterials:: … … 134 149 materialElement->setAttributeNode(NewAttribute("state",state_str)); 135 150 151 // Write any property attached to the material... 152 // 153 if (materialPtr->GetMaterialPropertiesTable()) 154 { 155 PropertyWrite(materialElement, materialPtr); 156 } 157 136 158 if (materialPtr->GetTemperature() != STP_Temperature) 137 159 { TWrite(materialElement,materialPtr->GetTemperature()); } … … 165 187 } 166 188 189 // Append the material AFTER all the possible components are appended! 190 // 167 191 materialsElement->appendChild(materialElement); 168 // Append the material AFTER all the possible components are appended! 192 } 193 194 void G4GDMLWriteMaterials::PropertyVectorWrite(const G4String& key, 195 const G4MaterialPropertyVector* const pvec) 196 { 197 xercesc::DOMElement* matrixElement = NewElement("matrix"); 198 matrixElement->setAttributeNode(NewAttribute("name", key)); 199 matrixElement->setAttributeNode(NewAttribute("coldim", "2")); 200 std::ostringstream pvalues; 201 for (G4int i=0; i<pvec->Entries(); i++) 202 { 203 G4MPVEntry cval = pvec->GetEntry(i); 204 if (i!=0) { pvalues << " "; } 205 pvalues << cval.GetPhotonEnergy() << " " << cval.GetProperty(); 206 } 207 matrixElement->setAttributeNode(NewAttribute("values", pvalues.str())); 208 209 defineElement->appendChild(matrixElement); 210 } 211 212 void G4GDMLWriteMaterials::PropertyWrite(xercesc::DOMElement* matElement, 213 const G4Material* const mat) 214 { 215 xercesc::DOMElement* propElement; 216 G4MaterialPropertiesTable* ptable = mat->GetMaterialPropertiesTable(); 217 const std::map< G4String, G4MaterialPropertyVector*, 218 std::less<G4String> >* pmap = ptable->GetPropertiesMap(); 219 const std::map< G4String, G4double, 220 std::less<G4String> >* cmap = ptable->GetPropertiesCMap(); 221 std::map< G4String, G4MaterialPropertyVector*, 222 std::less<G4String> >::const_iterator mpos; 223 std::map< G4String, G4double, 224 std::less<G4String> >::const_iterator cpos; 225 for (mpos=pmap->begin(); mpos!=pmap->end(); mpos++) 226 { 227 propElement = NewElement("property"); 228 propElement->setAttributeNode(NewAttribute("name", mpos->first)); 229 propElement->setAttributeNode(NewAttribute("ref", mpos->first)); 230 PropertyVectorWrite(mpos->first, mpos->second); 231 matElement->appendChild(propElement); 232 } 233 for (cpos=cmap->begin(); cpos!=cmap->end(); cpos++) 234 { 235 propElement = NewElement("property"); 236 propElement->setAttributeNode(NewAttribute("name", cpos->first)); 237 propElement->setAttributeNode(NewAttribute("ref", cpos->first)); 238 xercesc::DOMElement* constElement = NewElement("constant"); 239 constElement->setAttributeNode(NewAttribute("name", cpos->first)); 240 constElement->setAttributeNode(NewAttribute("value", cpos->second)); 241 defineElement->appendChild(constElement); 242 matElement->appendChild(propElement); 243 } 169 244 } 170 245 -
trunk/source/persistency/gdml/src/G4GDMLWriteParamvol.cc
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteParamvol.cc,v 1.2 3 2008/08/20 08:56:32gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteParamvol.cc,v 1.25 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // class G4GDMLParamVol Implementation … … 35 35 36 36 #include "G4GDMLWriteParamvol.hh" 37 #include <sstream> 37 38 #include "G4Box.hh" 39 #include "G4Trd.hh" 40 #include "G4Trap.hh" 41 #include "G4Tubs.hh" 42 #include "G4Cons.hh" 43 #include "G4Sphere.hh" 44 #include "G4Orb.hh" 45 #include "G4Torus.hh" 46 #include "G4Para.hh" 47 #include "G4Hype.hh" 48 #include "G4LogicalVolume.hh" 49 #include "G4VPhysicalVolume.hh" 50 #include "G4PVParameterised.hh" 51 #include "G4VPVParameterisation.hh" 52 53 G4GDMLWriteParamvol:: 54 G4GDMLWriteParamvol() : G4GDMLWriteSetup() 55 { 56 } 57 58 G4GDMLWriteParamvol:: 59 ~G4GDMLWriteParamvol() 60 { 61 } 38 62 39 63 void G4GDMLWriteParamvol:: -
trunk/source/persistency/gdml/src/G4GDMLWriteSetup.cc
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteSetup.cc,v 1.1 1 2008/07/16 15:46:34gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteSetup.cc,v 1.13 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // class G4GDMLWriteSetup Implementation … … 35 35 36 36 #include "G4GDMLWriteSetup.hh" 37 38 #include "G4LogicalVolume.hh" 39 40 G4GDMLWriteSetup::G4GDMLWriteSetup() : G4GDMLWriteSolids() 41 { 42 } 43 44 G4GDMLWriteSetup::~G4GDMLWriteSetup() 45 { 46 } 37 47 38 48 void G4GDMLWriteSetup::SetupWrite(xercesc::DOMElement* gdmlElement, -
trunk/source/persistency/gdml/src/G4GDMLWriteSolids.cc
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteSolids.cc,v 1. 59 2008/11/21 09:32:46gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteSolids.cc,v 1.65 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // class G4GDMLWriteSolids Implementation … … 36 36 #include "G4GDMLWriteSolids.hh" 37 37 38 #include "G4BooleanSolid.hh" 39 #include "G4Box.hh" 40 #include "G4Cons.hh" 41 #include "G4Ellipsoid.hh" 42 #include "G4EllipticalCone.hh" 43 #include "G4EllipticalTube.hh" 44 #include "G4ExtrudedSolid.hh" 45 #include "G4Hype.hh" 46 #include "G4Orb.hh" 47 #include "G4Para.hh" 48 #include "G4Paraboloid.hh" 49 #include "G4IntersectionSolid.hh" 50 #include "G4Polycone.hh" 51 #include "G4Polyhedra.hh" 52 #include "G4ReflectedSolid.hh" 53 #include "G4Sphere.hh" 54 #include "G4SubtractionSolid.hh" 55 #include "G4TessellatedSolid.hh" 56 #include "G4Tet.hh" 57 #include "G4Torus.hh" 58 #include "G4Trap.hh" 59 #include "G4Trd.hh" 60 #include "G4Tubs.hh" 61 #include "G4TwistedBox.hh" 62 #include "G4TwistedTrap.hh" 63 #include "G4TwistedTrd.hh" 64 #include "G4TwistedTubs.hh" 65 #include "G4UnionSolid.hh" 66 #include "G4OpticalSurface.hh" 67 #include "G4SurfaceProperty.hh" 68 69 G4GDMLWriteSolids:: 70 G4GDMLWriteSolids() : G4GDMLWriteMaterials() 71 { 72 } 73 74 G4GDMLWriteSolids:: 75 ~G4GDMLWriteSolids() 76 { 77 } 78 38 79 void G4GDMLWriteSolids:: 39 80 BooleanWrite(xercesc::DOMElement* solidsElement, 40 81 const G4BooleanSolid* const boolean) 41 82 { 83 G4int displaced=0; 84 42 85 G4String tag("undefined"); 43 86 if (dynamic_cast<const G4IntersectionSolid*>(boolean)) … … 53 96 G4ThreeVector firstpos,firstrot,pos,rot; 54 97 55 if (const G4DisplacedSolid* disp 56 = dynamic_cast<const G4DisplacedSolid*>(firstPtr)) 57 { 58 firstpos = disp->GetObjectTranslation(); 59 firstrot = GetAngles(disp->GetObjectRotation()); 60 firstPtr = disp->GetConstituentMovedSolid(); 61 } 62 63 if (const G4DisplacedSolid* disp 64 = dynamic_cast<const G4DisplacedSolid*>(secondPtr)) 65 { 66 pos = disp->GetObjectTranslation(); 67 rot = GetAngles(disp->GetObjectRotation()); 68 secondPtr = disp->GetConstituentMovedSolid(); 98 // Solve possible displacement of referenced solids! 99 // 100 while (true) 101 { 102 if ( displaced>8 ) 103 { 104 G4String ErrorMessage = "The referenced solid '" 105 + firstPtr->GetName() + 106 + "in the Boolean shape '" + 107 + boolean->GetName() + 108 + "' was displaced too many times!"; 109 G4Exception("G4GDMLWriteSolids::BooleanWrite()", 110 "InvalidSetup", FatalException, ErrorMessage); 111 } 112 113 if (G4DisplacedSolid* disp = dynamic_cast<G4DisplacedSolid*>(firstPtr)) 114 { 115 firstpos += disp->GetObjectTranslation(); 116 firstrot += firstrot + GetAngles(disp->GetObjectRotation()); 117 firstPtr = disp->GetConstituentMovedSolid(); 118 displaced++; 119 continue; 120 } 121 break; 122 } 123 displaced = 0; 124 while (true) 125 { 126 if ( displaced>maxTransforms ) 127 { 128 G4String ErrorMessage = "The referenced solid '" 129 + secondPtr->GetName() + 130 + "in the Boolean shape '" + 131 + boolean->GetName() + 132 + "' was displaced too many times!"; 133 G4Exception("G4GDMLWriteSolids::BooleanWrite()", 134 "InvalidSetup", FatalException, ErrorMessage); 135 } 136 137 if (G4DisplacedSolid* disp = dynamic_cast<G4DisplacedSolid*>(secondPtr)) 138 { 139 pos += disp->GetObjectTranslation(); 140 rot += GetAngles(disp->GetObjectRotation()); 141 secondPtr = disp->GetConstituentMovedSolid(); 142 displaced++; 143 continue; 144 } 145 break; 69 146 } 70 147 … … 727 804 zplaneElement->setAttributeNode(NewAttribute("rmax",rmax/mm)); 728 805 element->appendChild(zplaneElement); 806 } 807 808 void G4GDMLWriteSolids:: 809 OpticalSurfaceWrite(xercesc::DOMElement* solidsElement, 810 const G4OpticalSurface* const surf) 811 { 812 xercesc::DOMElement* optElement = NewElement("opticalsurface"); 813 G4OpticalSurfaceModel smodel = surf->GetModel(); 814 G4double sval = (smodel==glisur) ? surf->GetPolish() : surf->GetSigmaAlpha(); 815 816 optElement->setAttributeNode(NewAttribute("name", surf->GetName())); 817 optElement->setAttributeNode(NewAttribute("model", smodel)); 818 optElement->setAttributeNode(NewAttribute("finish", surf->GetFinish())); 819 optElement->setAttributeNode(NewAttribute("type", surf->GetType())); 820 optElement->setAttributeNode(NewAttribute("value", sval)); 821 822 solidsElement->appendChild(optElement); 729 823 } 730 824 … … 822 916 else 823 917 { 824 G4String error_msg = "Unknown solid: " + solidPtr->GetName(); 825 G4Exception("G4GDMLWriteSolids::AddSolid()", "ReadError", 918 G4String error_msg = "Unknown solid: " + solidPtr->GetName() 919 + "; Type: " + solidPtr->GetEntityType(); 920 G4Exception("G4GDMLWriteSolids::AddSolid()", "WriteError", 826 921 FatalException, error_msg); 827 922 } -
trunk/source/persistency/gdml/src/G4GDMLWriteStructure.cc
r987 r1228 25 25 // 26 26 // 27 // $Id: G4GDMLWriteStructure.cc,v 1. 74 2008/11/13 16:48:19gcosmo Exp $28 // GEANT4 tag $Name: geant4-09-0 2-ref-02$27 // $Id: G4GDMLWriteStructure.cc,v 1.80 2009/04/24 15:34:20 gcosmo Exp $ 28 // GEANT4 tag $Name: geant4-09-03 $ 29 29 // 30 30 // class G4GDMLWriteStructure Implementation … … 35 35 36 36 #include "G4GDMLWriteStructure.hh" 37 38 #include "G4Material.hh" 39 #include "G4ReflectedSolid.hh" 40 #include "G4DisplacedSolid.hh" 41 #include "G4LogicalVolumeStore.hh" 42 #include "G4PhysicalVolumeStore.hh" 43 #include "G4PVDivision.hh" 44 #include "G4PVReplica.hh" 45 #include "G4OpticalSurface.hh" 46 #include "G4LogicalSkinSurface.hh" 47 #include "G4LogicalBorderSurface.hh" 48 49 G4GDMLWriteStructure::G4GDMLWriteStructure() 50 : G4GDMLWriteParamvol() 51 { 52 } 53 54 G4GDMLWriteStructure::~G4GDMLWriteStructure() 55 { 56 } 37 57 38 58 void … … 50 70 G4String unitString("mm"); 51 71 G4String axisString("kUndefined"); 52 if (axis==kXAxis) { axisString = "kXAxis"; } else53 if (axis==kYAxis) { axisString = "kYAxis"; } else54 if (axis==kZAxis) { axisString = "kZAxis"; } else55 if (axis==kRho) { axisString = "kRho"; } else56 if (axis==kPhi){ axisString = "kPhi"; unitString = "degree"; }72 if (axis==kXAxis) { axisString = "kXAxis"; } 73 else if (axis==kYAxis) { axisString = "kYAxis"; } 74 else if (axis==kZAxis) { axisString = "kZAxis"; } 75 else if (axis==kRho) { axisString = "kRho"; } 76 else if (axis==kPhi) { axisString = "kPhi"; unitString = "degree"; } 57 77 58 78 const G4String name … … 154 174 volumerefElement->setAttributeNode(NewAttribute("ref",volumeref)); 155 175 replicavolElement->appendChild(volumerefElement); 156 157 176 xercesc::DOMElement* replicateElement = NewElement("replicate_along_axis"); 158 177 replicavolElement->appendChild(replicateElement); 159 178 160 179 xercesc::DOMElement* dirElement = NewElement("direction"); 161 if(axis==kXAxis)dirElement->setAttributeNode(NewAttribute("x","1")); 162 if(axis==kYAxis)dirElement->setAttributeNode(NewAttribute("y","1")); 163 if(axis==kZAxis)dirElement->setAttributeNode(NewAttribute("z","1")); 164 if(axis==kRho)dirElement->setAttributeNode(NewAttribute("rho","1")); 165 if(axis==kPhi)dirElement->setAttributeNode(NewAttribute("phi","1")); 180 if(axis==kXAxis) 181 { dirElement->setAttributeNode(NewAttribute("x","1")); } 182 else if(axis==kYAxis) 183 { dirElement->setAttributeNode(NewAttribute("y","1")); } 184 else if(axis==kZAxis) 185 { dirElement->setAttributeNode(NewAttribute("z","1")); } 186 else if(axis==kRho) 187 { dirElement->setAttributeNode(NewAttribute("rho","1")); } 188 else if(axis==kPhi) 189 { dirElement->setAttributeNode(NewAttribute("phi","1")); } 166 190 replicateElement->appendChild(dirElement); 167 191 … … 179 203 } 180 204 205 void G4GDMLWriteStructure:: 206 BorderSurfaceCache(const G4LogicalBorderSurface* const bsurf) 207 { 208 if (!bsurf) { return; } 209 210 const G4SurfaceProperty* psurf = bsurf->GetSurfaceProperty(); 211 212 // Generate the new element for border-surface 213 // 214 xercesc::DOMElement* borderElement = NewElement("bordersurface"); 215 borderElement->setAttributeNode(NewAttribute("name", bsurf->GetName())); 216 borderElement->setAttributeNode(NewAttribute("surfaceproperty", 217 psurf->GetName())); 218 219 const G4String volumeref1 = GenerateName(bsurf->GetVolume1()->GetName(), 220 bsurf->GetVolume1()); 221 const G4String volumeref2 = GenerateName(bsurf->GetVolume2()->GetName(), 222 bsurf->GetVolume2()); 223 xercesc::DOMElement* volumerefElement1 = NewElement("physvolref"); 224 xercesc::DOMElement* volumerefElement2 = NewElement("physvolref"); 225 volumerefElement1->setAttributeNode(NewAttribute("ref",volumeref1)); 226 volumerefElement2->setAttributeNode(NewAttribute("ref",volumeref2)); 227 borderElement->appendChild(volumerefElement1); 228 borderElement->appendChild(volumerefElement2); 229 230 if (FindOpticalSurface(psurf)) 231 { 232 OpticalSurfaceWrite(solidsElement, 233 dynamic_cast<const G4OpticalSurface*>(psurf)); 234 } 235 236 borderElementVec.push_back(borderElement); 237 } 238 239 void G4GDMLWriteStructure:: 240 SkinSurfaceCache(const G4LogicalSkinSurface* const ssurf) 241 { 242 if (!ssurf) { return; } 243 244 const G4SurfaceProperty* psurf = ssurf->GetSurfaceProperty(); 245 246 // Generate the new element for border-surface 247 // 248 xercesc::DOMElement* skinElement = NewElement("skinsurface"); 249 skinElement->setAttributeNode(NewAttribute("name", ssurf->GetName())); 250 skinElement->setAttributeNode(NewAttribute("surfaceproperty", 251 psurf->GetName())); 252 253 const G4String volumeref = GenerateName(ssurf->GetLogicalVolume()->GetName(), 254 ssurf->GetLogicalVolume()); 255 xercesc::DOMElement* volumerefElement = NewElement("volumeref"); 256 volumerefElement->setAttributeNode(NewAttribute("ref",volumeref)); 257 skinElement->appendChild(volumerefElement); 258 259 if (FindOpticalSurface(psurf)) 260 { 261 OpticalSurfaceWrite(solidsElement, 262 dynamic_cast<const G4OpticalSurface*>(psurf)); 263 } 264 265 skinElementVec.push_back(skinElement); 266 } 267 268 G4bool G4GDMLWriteStructure::FindOpticalSurface(const G4SurfaceProperty* psurf) 269 { 270 const G4OpticalSurface* osurf = dynamic_cast<const G4OpticalSurface*>(psurf); 271 std::vector<const G4OpticalSurface*>::const_iterator pos; 272 pos = std::find(opt_vec.begin(), opt_vec.end(), osurf); 273 if (pos != opt_vec.end()) { return false; } // item already created! 274 275 opt_vec.push_back(osurf); // cache it for future reference 276 return true; 277 } 278 279 const G4LogicalSkinSurface* 280 G4GDMLWriteStructure::GetSkinSurface(const G4LogicalVolume* const lvol) 281 { 282 G4LogicalSkinSurface* surf = 0; 283 G4int nsurf = G4LogicalSkinSurface::GetNumberOfSkinSurfaces(); 284 if (nsurf) 285 { 286 const G4LogicalSkinSurfaceTable* stable = 287 G4LogicalSkinSurface::GetSurfaceTable(); 288 std::vector<G4LogicalSkinSurface*>::const_iterator pos; 289 for (pos = stable->begin(); pos != stable->end(); pos++) 290 { 291 if (lvol == (*pos)->GetLogicalVolume()) 292 { 293 surf = *pos; break; 294 } 295 } 296 } 297 return surf; 298 } 299 300 const G4LogicalBorderSurface* 301 G4GDMLWriteStructure::GetBorderSurface(const G4VPhysicalVolume* const pvol) 302 { 303 G4LogicalBorderSurface* surf = 0; 304 G4int nsurf = G4LogicalBorderSurface::GetNumberOfBorderSurfaces(); 305 if (nsurf) 306 { 307 const G4LogicalBorderSurfaceTable* btable = 308 G4LogicalBorderSurface::GetSurfaceTable(); 309 std::vector<G4LogicalBorderSurface*>::const_iterator pos; 310 for (pos = btable->begin(); pos != btable->end(); pos++) 311 { 312 if (pvol == (*pos)->GetVolume1()) // just the first in the couple 313 { // is enough 314 surf = *pos; break; 315 } 316 } 317 } 318 return surf; 319 } 320 321 void G4GDMLWriteStructure::SurfacesWrite() 322 { 323 G4cout << "G4GDML: Writing surfaces..." << G4endl; 324 325 std::vector<xercesc::DOMElement*>::const_iterator pos; 326 for (pos = skinElementVec.begin(); pos != skinElementVec.end(); pos++) 327 { 328 structureElement->appendChild(*pos); 329 } 330 for (pos = borderElementVec.begin(); pos != borderElementVec.end(); pos++) 331 { 332 structureElement->appendChild(*pos); 333 } 334 } 335 181 336 void G4GDMLWriteStructure::StructureWrite(xercesc::DOMElement* gdmlElement) 182 337 { … … 197 352 G4VSolid* solidPtr = volumePtr->GetSolid(); 198 353 G4Transform3D R,invR; 199 G4int reflected =0;354 G4int trans=0; 200 355 201 356 while (true) // Solve possible displacement/reflection 202 357 { // of the referenced solid! 203 if ( reflected>maxReflections)358 if (trans>maxTransforms) 204 359 { 205 360 G4String ErrorMessage = "Referenced solid in volume '" … … 214 369 R = R*refl->GetTransform3D(); 215 370 solidPtr = refl->GetConstituentMovedSolid(); 216 reflected++;371 trans++; 217 372 continue; 218 373 } … … 223 378 disp->GetObjectTranslation()); 224 379 solidPtr = disp->GetConstituentMovedSolid(); 225 reflected++;380 trans++; 226 381 continue; 227 382 } … … 230 385 } 231 386 232 if (reflected>0) { invR = R.inverse(); } 233 // Only compute the inverse when necessary! 387 // Only compute the inverse when necessary! 388 // 389 if (trans>0) { invR = R.inverse(); } 234 390 235 391 const G4String name … … 318 474 PhysvolWrite(volumeElement,physvol,invR*P*daughterR,ModuleName); 319 475 } 476 BorderSurfaceCache(GetBorderSurface(physvol)); 320 477 } 321 478 … … 326 483 VolumeMap()[volumePtr] = R; 327 484 328 G4GDMLWriteMaterials::AddMaterial(volumePtr->GetMaterial()); 485 AddExtension(volumeElement, volumePtr); 486 // Add any possible user defined extension attached to a volume 487 488 AddMaterial(volumePtr->GetMaterial()); 329 489 // Add the involved materials and solids! 330 490 331 G4GDMLWriteSolids::AddSolid(solidPtr); 491 AddSolid(solidPtr); 492 493 SkinSurfaceCache(GetSkinSurface(volumePtr)); 332 494 333 495 return R; -
trunk/source/persistency/gdml/src/G4STRead.cc
r987 r1228 24 24 // ******************************************************************** 25 25 // 26 // $Id: G4STRead.cc,v 1. 3 2008/07/17 14:05:50 gcosmo Exp $27 // GEANT4 tag $Name: geant4-09-0 2-ref-02$26 // $Id: G4STRead.cc,v 1.4 2009/04/24 15:34:20 gcosmo Exp $ 27 // GEANT4 tag $Name: geant4-09-03 $ 28 28 // 29 29 // class G4STRead Implementation … … 33 33 // ------------------------------------------------------------------------- 34 34 35 #include <fstream> 36 35 37 #include "G4STRead.hh" 38 39 #include "G4Material.hh" 40 #include "G4Box.hh" 41 #include "G4QuadrangularFacet.hh" 42 #include "G4TriangularFacet.hh" 43 #include "G4TessellatedSolid.hh" 44 #include "G4LogicalVolume.hh" 45 #include "G4PVPlacement.hh" 36 46 37 47 void G4STRead::TessellatedRead(const std::string& line)
Note: See TracChangeset
for help on using the changeset viewer.
