Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4GDMLWriteStructure Class Reference

#include <G4GDMLWriteStructure.hh>

+ Inheritance diagram for G4GDMLWriteStructure:

Public Member Functions

 G4GDMLWriteStructure ()
 
virtual ~G4GDMLWriteStructure ()
 
virtual void StructureWrite (xercesc::DOMElement *)
 
void AddVolumeAuxiliary (G4GDMLAuxStructType myaux, const G4LogicalVolume *const)
 
void SetEnergyCutsExport (G4bool)
 
void SetSDExport (G4bool)
 
G4int GetMaxExportLevel () const
 
void SetMaxExportLevel (G4int)
 
- Public Member Functions inherited from G4GDMLWriteParamvol
virtual void ParamvolWrite (xercesc::DOMElement *, const G4VPhysicalVolume *const)
 
virtual void ParamvolAlgorithmWrite (xercesc::DOMElement *paramvolElement, const G4VPhysicalVolume *const paramvol)
 
- Public Member Functions inherited from G4GDMLWriteSetup
virtual void SetupWrite (xercesc::DOMElement *, const G4LogicalVolume *const)
 
- Public Member Functions inherited from G4GDMLWriteSolids
virtual void AddSolid (const G4VSolid *const)
 
virtual void SolidsWrite (xercesc::DOMElement *)
 
- Public Member Functions inherited from G4GDMLWriteMaterials
void AddIsotope (const G4Isotope *const)
 
void AddElement (const G4Element *const)
 
void AddMaterial (const G4Material *const)
 
virtual void MaterialsWrite (xercesc::DOMElement *)
 
- Public Member Functions inherited from G4GDMLWriteDefine
G4ThreeVector GetAngles (const G4RotationMatrix &)
 
void ScaleWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &scl)
 
void RotationWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &rot)
 
void PositionWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &pos)
 
void FirstrotationWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &rot)
 
void FirstpositionWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &pos)
 
void AddPosition (const G4String &name, const G4ThreeVector &pos)
 
virtual void DefineWrite (xercesc::DOMElement *)
 
- Public Member Functions inherited from G4GDMLWrite
G4Transform3D Write (const G4String &filename, const G4LogicalVolume *const topLog, const G4String &schemaPath, const G4int depth, G4bool storeReferences=true)
 
void AddModule (const G4VPhysicalVolume *const topVol)
 
void AddModule (const G4int depth)
 
void AddAuxiliary (G4GDMLAuxStructType myaux)
 
void SetOutputFileOverwrite (G4bool flag)
 
virtual void DefineWrite (xercesc::DOMElement *)=0
 
virtual void MaterialsWrite (xercesc::DOMElement *)=0
 
virtual void SolidsWrite (xercesc::DOMElement *)=0
 
virtual void StructureWrite (xercesc::DOMElement *)=0
 
virtual G4Transform3D TraverseVolumeTree (const G4LogicalVolume *const, const G4int)=0
 
virtual void SurfacesWrite ()=0
 
virtual void SetupWrite (xercesc::DOMElement *, const G4LogicalVolume *const)=0
 
virtual void ExtensionWrite (xercesc::DOMElement *)
 
virtual void UserinfoWrite (xercesc::DOMElement *)
 
virtual void AddExtension (xercesc::DOMElement *, const G4LogicalVolume *const)
 
G4String GenerateName (const G4String &, const void *const)
 

Protected Member Functions

void DivisionvolWrite (xercesc::DOMElement *, const G4PVDivision *const)
 
void PhysvolWrite (xercesc::DOMElement *, const G4VPhysicalVolume *const topVol, const G4Transform3D &transform, const G4String &moduleName)
 
void ReplicavolWrite (xercesc::DOMElement *, const G4VPhysicalVolume *const)
 
void AssemblyWrite (xercesc::DOMElement *, const int assemblyID)
 
G4Transform3D TraverseVolumeTree (const G4LogicalVolume *const topVol, const G4int depth)
 
void SurfacesWrite ()
 
void BorderSurfaceCache (const G4LogicalBorderSurface *const)
 
void SkinSurfaceCache (const G4LogicalSkinSurface *const)
 
const G4LogicalBorderSurfaceGetBorderSurface (const G4VPhysicalVolume *const)
 
const G4LogicalSkinSurfaceGetSkinSurface (const G4LogicalVolume *const)
 
G4bool FindOpticalSurface (const G4SurfaceProperty *)
 
void ExportEnergyCuts (const G4LogicalVolume *const)
 
void ExportSD (const G4LogicalVolume *const)
 
- Protected Member Functions inherited from G4GDMLWriteParamvol
 G4GDMLWriteParamvol ()
 
virtual ~G4GDMLWriteParamvol ()
 
void Box_dimensionsWrite (xercesc::DOMElement *, const G4Box *const)
 
void Trd_dimensionsWrite (xercesc::DOMElement *, const G4Trd *const)
 
void Trap_dimensionsWrite (xercesc::DOMElement *, const G4Trap *const)
 
void Tube_dimensionsWrite (xercesc::DOMElement *, const G4Tubs *const)
 
void Cone_dimensionsWrite (xercesc::DOMElement *, const G4Cons *const)
 
void Sphere_dimensionsWrite (xercesc::DOMElement *, const G4Sphere *const)
 
void Orb_dimensionsWrite (xercesc::DOMElement *, const G4Orb *const)
 
void Torus_dimensionsWrite (xercesc::DOMElement *, const G4Torus *const)
 
void Ellipsoid_dimensionsWrite (xercesc::DOMElement *, const G4Ellipsoid *const)
 
void Para_dimensionsWrite (xercesc::DOMElement *, const G4Para *const)
 
void Hype_dimensionsWrite (xercesc::DOMElement *, const G4Hype *const)
 
void Polycone_dimensionsWrite (xercesc::DOMElement *, const G4Polycone *const)
 
void Polyhedra_dimensionsWrite (xercesc::DOMElement *, const G4Polyhedra *const)
 
void ParametersWrite (xercesc::DOMElement *, const G4VPhysicalVolume *const, const G4int &)
 
- Protected Member Functions inherited from G4GDMLWriteSetup
 G4GDMLWriteSetup ()
 
virtual ~G4GDMLWriteSetup ()
 
- Protected Member Functions inherited from G4GDMLWriteSolids
 G4GDMLWriteSolids ()
 
virtual ~G4GDMLWriteSolids ()
 
void MultiUnionWrite (xercesc::DOMElement *solElement, const G4MultiUnion *const)
 
void BooleanWrite (xercesc::DOMElement *, const G4BooleanSolid *const)
 
void ScaledWrite (xercesc::DOMElement *, const G4ScaledSolid *const)
 
void BoxWrite (xercesc::DOMElement *, const G4Box *const)
 
void ConeWrite (xercesc::DOMElement *, const G4Cons *const)
 
void ElconeWrite (xercesc::DOMElement *, const G4EllipticalCone *const)
 
void EllipsoidWrite (xercesc::DOMElement *, const G4Ellipsoid *const)
 
void EltubeWrite (xercesc::DOMElement *, const G4EllipticalTube *const)
 
void XtruWrite (xercesc::DOMElement *, const G4ExtrudedSolid *const)
 
void HypeWrite (xercesc::DOMElement *, const G4Hype *const)
 
void OrbWrite (xercesc::DOMElement *, const G4Orb *const)
 
void ParaWrite (xercesc::DOMElement *, const G4Para *const)
 
void ParaboloidWrite (xercesc::DOMElement *, const G4Paraboloid *const)
 
void PolyconeWrite (xercesc::DOMElement *, const G4Polycone *const)
 
void GenericPolyconeWrite (xercesc::DOMElement *, const G4GenericPolycone *const)
 
void PolyhedraWrite (xercesc::DOMElement *, const G4Polyhedra *const)
 
void SphereWrite (xercesc::DOMElement *, const G4Sphere *const)
 
void TessellatedWrite (xercesc::DOMElement *, const G4TessellatedSolid *const)
 
void TetWrite (xercesc::DOMElement *, const G4Tet *const)
 
void TorusWrite (xercesc::DOMElement *, const G4Torus *const)
 
void GenTrapWrite (xercesc::DOMElement *, const G4GenericTrap *const)
 
void TrapWrite (xercesc::DOMElement *, const G4Trap *const)
 
void TrdWrite (xercesc::DOMElement *, const G4Trd *const)
 
void TubeWrite (xercesc::DOMElement *, const G4Tubs *const)
 
void CutTubeWrite (xercesc::DOMElement *, const G4CutTubs *const)
 
void TwistedboxWrite (xercesc::DOMElement *, const G4TwistedBox *const)
 
void TwistedtrapWrite (xercesc::DOMElement *, const G4TwistedTrap *const)
 
void TwistedtrdWrite (xercesc::DOMElement *, const G4TwistedTrd *const)
 
void TwistedtubsWrite (xercesc::DOMElement *, const G4TwistedTubs *const)
 
void ZplaneWrite (xercesc::DOMElement *, const G4double &, const G4double &, const G4double &)
 
void RZPointWrite (xercesc::DOMElement *, const G4double &, const G4double &)
 
void OpticalSurfaceWrite (xercesc::DOMElement *, const G4OpticalSurface *const)
 
void PropertyWrite (xercesc::DOMElement *, const G4OpticalSurface *const)
 
- Protected Member Functions inherited from G4GDMLWriteMaterials
 G4GDMLWriteMaterials ()
 
virtual ~G4GDMLWriteMaterials ()
 
void AtomWrite (xercesc::DOMElement *, const G4double &)
 
void DWrite (xercesc::DOMElement *, const G4double &)
 
void PWrite (xercesc::DOMElement *, const G4double &)
 
void TWrite (xercesc::DOMElement *, const G4double &)
 
void MEEWrite (xercesc::DOMElement *, const G4double &)
 
void IsotopeWrite (const G4Isotope *const)
 
void ElementWrite (const G4Element *const)
 
void MaterialWrite (const G4Material *const)
 
void PropertyWrite (xercesc::DOMElement *, const G4Material *const)
 
void PropertyVectorWrite (const G4String &, const G4PhysicsFreeVector *const)
 
void PropertyConstWrite (const G4String &, const G4double, const G4MaterialPropertiesTable *)
 
- Protected Member Functions inherited from G4GDMLWriteDefine
 G4GDMLWriteDefine ()
 
virtual ~G4GDMLWriteDefine ()
 
void Scale_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)
 
void Rotation_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)
 
void Position_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)
 
- Protected Member Functions inherited from G4GDMLWrite
 G4GDMLWrite ()
 
virtual ~G4GDMLWrite ()
 
VolumeMapType & VolumeMap ()
 
xercesc::DOMAttr * NewAttribute (const G4String &, const G4String &)
 
xercesc::DOMAttr * NewAttribute (const G4String &, const G4double &)
 
xercesc::DOMElement * NewElement (const G4String &)
 
G4String Modularize (const G4VPhysicalVolume *const topvol, const G4int depth)
 
void AddAuxInfo (G4GDMLAuxListType *auxInfoList, xercesc::DOMElement *element)
 
G4bool FileExists (const G4String &) const
 
PhysVolumeMapType & PvolumeMap ()
 
DepthMapType & DepthMap ()
 

Protected Attributes

xercesc::DOMElement * structureElement = nullptr
 
std::vector< xercesc::DOMElement * > borderElementVec
 
std::vector< xercesc::DOMElement * > skinElementVec
 
std::map< const G4LogicalVolume *, G4GDMLAuxListTypeauxmap
 
- Protected Attributes inherited from G4GDMLWriteSolids
std::vector< const G4VSolid * > solidList
 
xercesc::DOMElement * solidsElement = nullptr
 
- Protected Attributes inherited from G4GDMLWriteMaterials
std::vector< const G4Isotope * > isotopeList
 
std::vector< const G4Element * > elementList
 
std::vector< const G4Material * > materialList
 
std::vector< const G4PhysicsFreeVector * > propertyList
 
xercesc::DOMElement * materialsElement = nullptr
 
- Protected Attributes inherited from G4GDMLWriteDefine
xercesc::DOMElement * defineElement = nullptr
 
- Protected Attributes inherited from G4GDMLWrite
G4String SchemaLocation
 
xercesc::DOMDocument * doc = nullptr
 
xercesc::DOMElement * extElement = nullptr
 
xercesc::DOMElement * userinfoElement = nullptr
 
G4GDMLAuxListType auxList
 
G4bool overwriteOutputFile = false
 

Additional Inherited Members

- Static Public Member Functions inherited from G4GDMLWrite
static void SetAddPointerToName (G4bool)
 
- Static Protected Attributes inherited from G4GDMLWriteSolids
static const G4int maxTransforms = 8
 
- Static Protected Attributes inherited from G4GDMLWriteDefine
static const G4double kRelativePrecision = DBL_EPSILON
 
static const G4double kAngularPrecision = DBL_EPSILON
 
static const G4double kLinearPrecision = DBL_EPSILON
 
- Static Protected Attributes inherited from G4GDMLWrite
static G4bool addPointerToName = true
 

Detailed Description

Definition at line 51 of file G4GDMLWriteStructure.hh.

Constructor & Destructor Documentation

◆ G4GDMLWriteStructure()

G4GDMLWriteStructure::G4GDMLWriteStructure ( )

Definition at line 61 of file G4GDMLWriteStructure.cc.

63 , maxLevel(INT_MAX)
64{
65 reflFactory = G4ReflectionFactory::Instance();
66}
static G4ReflectionFactory * Instance()
#define INT_MAX
Definition: templates.hh:90

◆ ~G4GDMLWriteStructure()

G4GDMLWriteStructure::~G4GDMLWriteStructure ( )
virtual

Definition at line 69 of file G4GDMLWriteStructure.cc.

70{
71}

Member Function Documentation

◆ AddVolumeAuxiliary()

void G4GDMLWriteStructure::AddVolumeAuxiliary ( G4GDMLAuxStructType  myaux,
const G4LogicalVolume * const  lvol 
)

Definition at line 829 of file G4GDMLWriteStructure.cc.

831{
832 auto pos = auxmap.find(lvol);
833
834 if(pos == auxmap.cend())
835 {
836 auxmap[lvol] = G4GDMLAuxListType();
837 }
838
839 auxmap[lvol].push_back(myaux);
840}
std::vector< G4GDMLAuxStructType > G4GDMLAuxListType
std::map< const G4LogicalVolume *, G4GDMLAuxListType > auxmap

Referenced by ExportEnergyCuts(), and ExportSD().

◆ AssemblyWrite()

void G4GDMLWriteStructure::AssemblyWrite ( xercesc::DOMElement *  volumeElement,
const int  assemblyID 
)
protected

Definition at line 264 of file G4GDMLWriteStructure.cc.

266{
268 G4AssemblyVolume* myassembly = assemblies->GetAssembly(assemblyID);
269
270 xercesc::DOMElement* assemblyElement = NewElement("assembly");
271 G4String name = "Assembly_" + std::to_string(assemblyID);
272
273 assemblyElement->setAttributeNode(NewAttribute("name", name));
274
275 auto vit = myassembly->GetTripletsIterator();
276
277 G4int depth = 0;
278 const G4String ModuleName;
279
280 for(std::size_t i5 = 0; i5 < myassembly->TotalTriplets(); ++i5)
281 {
282 G4LogicalVolume* lvol = (*vit).GetVolume();
283 if (lvol == nullptr)
284 {
285 G4String message = "Nested assemblies not yet supported for exporting. Sorry!";
286 G4Exception("G4GDMLWriteStructure::AssemblyWrite()", "InvalidSetup",
287 FatalException, message);
288 return;
289 }
290 TraverseVolumeTree(lvol, depth + 1);
291
292 const G4ThreeVector rot = GetAngles((*vit).GetRotation()->inverse());
293 const G4ThreeVector pos = (*vit).GetTranslation();
294
295 const G4String pname =
296 GenerateName((*vit).GetVolume()->GetName() + "_pv", &(*vit));
297
298 xercesc::DOMElement* physvolElement = NewElement("physvol");
299 physvolElement->setAttributeNode(NewAttribute("name", pname));
300
301 assemblyElement->appendChild(physvolElement);
302
303 const G4String volumeref =
304 GenerateName((*vit).GetVolume()->GetName(), (*vit).GetVolume());
305
306 xercesc::DOMElement* volumerefElement = NewElement("volumeref");
307 volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
308 physvolElement->appendChild(volumerefElement);
309
310 if(std::fabs(pos.x()) > kLinearPrecision ||
311 std::fabs(pos.y()) > kLinearPrecision ||
312 std::fabs(pos.z()) > kLinearPrecision)
313 {
314 PositionWrite(physvolElement,name+"_position_" + std::to_string(i5), pos);
315 }
316
317 if(std::fabs(rot.x()) > kAngularPrecision ||
318 std::fabs(rot.y()) > kAngularPrecision ||
319 std::fabs(rot.z()) > kAngularPrecision)
320 {
321 RotationWrite(physvolElement,name+"_rotation_" + std::to_string(i5), rot);
322 }
323 ++vit;
324 }
325
326 volumeElement->appendChild(assemblyElement);
327}
@ FatalException
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
int G4int
Definition: G4Types.hh:85
double z() const
double x() const
double y() const
static G4AssemblyStore * GetInstance()
G4AssemblyVolume * GetAssembly(unsigned int id, G4bool verbose=true) const
std::vector< G4AssemblyTriplet >::iterator GetTripletsIterator()
std::size_t TotalTriplets() const
static const G4double kLinearPrecision
void RotationWrite(xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &rot)
static const G4double kAngularPrecision
void PositionWrite(xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &pos)
G4ThreeVector GetAngles(const G4RotationMatrix &)
G4Transform3D TraverseVolumeTree(const G4LogicalVolume *const topVol, const G4int depth)
xercesc::DOMElement * NewElement(const G4String &)
Definition: G4GDMLWrite.cc:192
G4String GenerateName(const G4String &, const void *const)
Definition: G4GDMLWrite.cc:132
xercesc::DOMAttr * NewAttribute(const G4String &, const G4String &)
Definition: G4GDMLWrite.cc:155
const char * name(G4int ptype)

Referenced by TraverseVolumeTree().

◆ BorderSurfaceCache()

void G4GDMLWriteStructure::BorderSurfaceCache ( const G4LogicalBorderSurface * const  bsurf)
protected

Definition at line 330 of file G4GDMLWriteStructure.cc.

332{
333 if(bsurf == nullptr)
334 {
335 return;
336 }
337
338 const G4SurfaceProperty* psurf = bsurf->GetSurfaceProperty();
339
340 // Generate the new element for border-surface
341 //
342 const G4String& bsname = GenerateName(bsurf->GetName(), bsurf);
343 const G4String& psname = GenerateName(psurf->GetName(), psurf);
344 xercesc::DOMElement* borderElement = NewElement("bordersurface");
345 borderElement->setAttributeNode(NewAttribute("name", bsname));
346 borderElement->setAttributeNode(NewAttribute("surfaceproperty", psname));
347
348 const G4String volumeref1 =
349 GenerateName(bsurf->GetVolume1()->GetName(), bsurf->GetVolume1());
350 const G4String volumeref2 =
351 GenerateName(bsurf->GetVolume2()->GetName(), bsurf->GetVolume2());
352 xercesc::DOMElement* volumerefElement1 = NewElement("physvolref");
353 xercesc::DOMElement* volumerefElement2 = NewElement("physvolref");
354 volumerefElement1->setAttributeNode(NewAttribute("ref", volumeref1));
355 volumerefElement2->setAttributeNode(NewAttribute("ref", volumeref2));
356 borderElement->appendChild(volumerefElement1);
357 borderElement->appendChild(volumerefElement2);
358
359 if(FindOpticalSurface(psurf))
360 {
361 const G4OpticalSurface* opsurf =
362 dynamic_cast<const G4OpticalSurface*>(psurf);
363 if(opsurf == nullptr)
364 {
365 G4Exception("G4GDMLWriteStructure::BorderSurfaceCache()", "InvalidSetup",
366 FatalException, "No optical surface found!");
367 return;
368 }
370 }
371
372 borderElementVec.push_back(borderElement);
373}
xercesc::DOMElement * solidsElement
void OpticalSurfaceWrite(xercesc::DOMElement *, const G4OpticalSurface *const)
std::vector< xercesc::DOMElement * > borderElementVec
G4bool FindOpticalSurface(const G4SurfaceProperty *)
const G4VPhysicalVolume * GetVolume2() const
const G4VPhysicalVolume * GetVolume1() const
const G4String & GetName() const
G4SurfaceProperty * GetSurfaceProperty() const
const G4String & GetName() const
const G4String & GetName() const

Referenced by GetBorderSurface().

◆ DivisionvolWrite()

void G4GDMLWriteStructure::DivisionvolWrite ( xercesc::DOMElement *  volumeElement,
const G4PVDivision * const  divisionvol 
)
protected

Definition at line 74 of file G4GDMLWriteStructure.cc.

76{
77 EAxis axis = kUndefined;
78 G4int number = 0;
79 G4double width = 0.0;
80 G4double offset = 0.0;
81 G4bool consuming = false;
82
83 divisionvol->GetReplicationData(axis, number, width, offset, consuming);
84 axis = divisionvol->GetDivisionAxis();
85
86 G4String unitString("mm");
87 G4String axisString("kUndefined");
88 if(axis == kXAxis)
89 {
90 axisString = "kXAxis";
91 }
92 else if(axis == kYAxis)
93 {
94 axisString = "kYAxis";
95 }
96 else if(axis == kZAxis)
97 {
98 axisString = "kZAxis";
99 }
100 else if(axis == kRho)
101 {
102 axisString = "kRho";
103 }
104 else if(axis == kPhi)
105 {
106 axisString = "kPhi";
107 unitString = "rad";
108 }
109
110 const G4String name = GenerateName(divisionvol->GetName(), divisionvol);
111 const G4String volumeref =
112 GenerateName(divisionvol->GetLogicalVolume()->GetName(),
113 divisionvol->GetLogicalVolume());
114
115 xercesc::DOMElement* divisionvolElement = NewElement("divisionvol");
116 divisionvolElement->setAttributeNode(NewAttribute("axis", axisString));
117 divisionvolElement->setAttributeNode(NewAttribute("number", number));
118 divisionvolElement->setAttributeNode(NewAttribute("width", width));
119 divisionvolElement->setAttributeNode(NewAttribute("offset", offset));
120 divisionvolElement->setAttributeNode(NewAttribute("unit", unitString));
121 xercesc::DOMElement* volumerefElement = NewElement("volumeref");
122 volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
123 divisionvolElement->appendChild(volumerefElement);
124 volumeElement->appendChild(divisionvolElement);
125}
double G4double
Definition: G4Types.hh:83
bool G4bool
Definition: G4Types.hh:86
const G4String & GetName() const
EAxis GetDivisionAxis() const
virtual void GetReplicationData(EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const
G4LogicalVolume * GetLogicalVolume() const
EAxis
Definition: geomdefs.hh:54
@ kPhi
Definition: geomdefs.hh:60
@ kYAxis
Definition: geomdefs.hh:56
@ kXAxis
Definition: geomdefs.hh:55
@ kZAxis
Definition: geomdefs.hh:57
@ kUndefined
Definition: geomdefs.hh:61
@ kRho
Definition: geomdefs.hh:58

Referenced by TraverseVolumeTree().

◆ ExportEnergyCuts()

void G4GDMLWriteStructure::ExportEnergyCuts ( const G4LogicalVolume * const  lvol)
protected

Definition at line 849 of file G4GDMLWriteStructure.cc.

850{
851 G4GDMLEvaluator eval;
852 G4ProductionCuts* pcuts = lvol->GetRegion()->GetProductionCuts();
854 G4Gamma* gamma = G4Gamma::Gamma();
858
859 G4double gamma_cut = ctab->ConvertRangeToEnergy(
860 gamma, lvol->GetMaterial(), pcuts->GetProductionCut("gamma"));
861 G4double eminus_cut = ctab->ConvertRangeToEnergy(
862 eminus, lvol->GetMaterial(), pcuts->GetProductionCut("e-"));
863 G4double eplus_cut = ctab->ConvertRangeToEnergy(
864 eplus, lvol->GetMaterial(), pcuts->GetProductionCut("e+"));
865 G4double proton_cut = ctab->ConvertRangeToEnergy(
866 proton, lvol->GetMaterial(), pcuts->GetProductionCut("proton"));
867
868 G4GDMLAuxStructType gammainfo = { "gammaECut",
869 eval.ConvertToString(gamma_cut), "MeV", 0 };
870 G4GDMLAuxStructType eminusinfo = { "electronECut",
871 eval.ConvertToString(eminus_cut), "MeV",
872 0 };
873 G4GDMLAuxStructType eplusinfo = { "positronECut",
874 eval.ConvertToString(eplus_cut), "MeV", 0 };
875 G4GDMLAuxStructType protinfo = { "protonECut",
876 eval.ConvertToString(proton_cut), "MeV", 0 };
877
878 AddVolumeAuxiliary(gammainfo, lvol);
879 AddVolumeAuxiliary(eminusinfo, lvol);
880 AddVolumeAuxiliary(eplusinfo, lvol);
881 AddVolumeAuxiliary(protinfo, lvol);
882}
static G4Electron * Electron()
Definition: G4Electron.cc:93
G4String ConvertToString(G4int ival)
void AddVolumeAuxiliary(G4GDMLAuxStructType myaux, const G4LogicalVolume *const)
static G4Gamma * Gamma()
Definition: G4Gamma.cc:85
G4Region * GetRegion() const
G4Material * GetMaterial() const
static G4Positron * Positron()
Definition: G4Positron.cc:93
static G4ProductionCutsTable * GetProductionCutsTable()
G4double ConvertRangeToEnergy(const G4ParticleDefinition *particle, const G4Material *material, G4double range)
G4double GetProductionCut(G4int index) const
static G4Proton * Proton()
Definition: G4Proton.cc:92
G4ProductionCuts * GetProductionCuts() const

Referenced by TraverseVolumeTree().

◆ ExportSD()

void G4GDMLWriteStructure::ExportSD ( const G4LogicalVolume * const  lvol)
protected

Definition at line 891 of file G4GDMLWriteStructure.cc.

892{
894
895 if(sd != nullptr)
896 {
897 G4String SDname = sd->GetName();
898
899 G4GDMLAuxStructType SDinfo = { "SensDet", SDname, "", 0 };
900 AddVolumeAuxiliary(SDinfo, lvol);
901 }
902}
G4VSensitiveDetector * GetSensitiveDetector() const

Referenced by TraverseVolumeTree().

◆ FindOpticalSurface()

G4bool G4GDMLWriteStructure::FindOpticalSurface ( const G4SurfaceProperty psurf)
protected

Definition at line 417 of file G4GDMLWriteStructure.cc.

418{
419 const G4OpticalSurface* osurf = dynamic_cast<const G4OpticalSurface*>(psurf);
420 auto pos = std::find(opt_vec.cbegin(), opt_vec.cend(), osurf);
421 if(pos != opt_vec.cend())
422 {
423 return false;
424 } // item already created!
425
426 opt_vec.push_back(osurf); // cache it for future reference
427 return true;
428}

Referenced by BorderSurfaceCache(), and SkinSurfaceCache().

◆ GetBorderSurface()

const G4LogicalBorderSurface * G4GDMLWriteStructure::GetBorderSurface ( const G4VPhysicalVolume * const  pvol)
protected

Definition at line 453 of file G4GDMLWriteStructure.cc.

455{
456 G4LogicalBorderSurface* surf = nullptr;
458 if(nsurf)
459 {
460 const G4LogicalBorderSurfaceTable* btable =
462 for(auto pos = btable->cbegin(); pos != btable->cend(); ++pos)
463 {
464 if(pvol == pos->first.first) // just the first in the couple
465 { // could be enough?
466 surf = pos->second; // break;
467 BorderSurfaceCache(surf);
468 }
469 }
470 }
471 return surf;
472}
std::map< std::pair< const G4VPhysicalVolume *, const G4VPhysicalVolume * >, G4LogicalBorderSurface * > G4LogicalBorderSurfaceTable
void BorderSurfaceCache(const G4LogicalBorderSurface *const)
static std::size_t GetNumberOfBorderSurfaces()
static const G4LogicalBorderSurfaceTable * GetSurfaceTable()

Referenced by TraverseVolumeTree().

◆ GetMaxExportLevel()

G4int G4GDMLWriteStructure::GetMaxExportLevel ( ) const

Definition at line 905 of file G4GDMLWriteStructure.cc.

906{
907 return maxLevel;
908}

◆ GetSkinSurface()

const G4LogicalSkinSurface * G4GDMLWriteStructure::GetSkinSurface ( const G4LogicalVolume * const  lvol)
protected

Definition at line 431 of file G4GDMLWriteStructure.cc.

433{
434 G4LogicalSkinSurface* surf = 0;
436 if(nsurf)
437 {
438 const G4LogicalSkinSurfaceTable* stable =
440 for(auto pos = stable->cbegin(); pos != stable->cend(); ++pos)
441 {
442 if(lvol == (*pos)->GetLogicalVolume())
443 {
444 surf = *pos;
445 break;
446 }
447 }
448 }
449 return surf;
450}
std::vector< G4LogicalSkinSurface * > G4LogicalSkinSurfaceTable
static const G4LogicalSkinSurfaceTable * GetSurfaceTable()
static std::size_t GetNumberOfSkinSurfaces()

Referenced by TraverseVolumeTree().

◆ PhysvolWrite()

void G4GDMLWriteStructure::PhysvolWrite ( xercesc::DOMElement *  volumeElement,
const G4VPhysicalVolume *const  topVol,
const G4Transform3D transform,
const G4String moduleName 
)
protected

Definition at line 128 of file G4GDMLWriteStructure.cc.

132{
133 HepGeom::Scale3D scale;
134 HepGeom::Rotate3D rotate;
135 HepGeom::Translate3D translate;
136
137 T.getDecomposition(scale, rotate, translate);
138
139 const G4ThreeVector scl(scale(0, 0), scale(1, 1), scale(2, 2));
140 const G4ThreeVector rot = GetAngles(rotate.getRotation());
141 const G4ThreeVector pos = T.getTranslation();
142
143 const G4String name = GenerateName(physvol->GetName(), physvol);
144 const G4int copynumber = physvol->GetCopyNo();
145
146 xercesc::DOMElement* physvolElement = NewElement("physvol");
147 physvolElement->setAttributeNode(NewAttribute("name", name));
148 if(copynumber)
149 {
150 physvolElement->setAttributeNode(NewAttribute("copynumber", copynumber));
151 }
152
153 volumeElement->appendChild(physvolElement);
154
155 G4LogicalVolume* lv;
156 // Is it reflected?
157 if(reflFactory->IsReflected(physvol->GetLogicalVolume()))
158 {
159 lv = reflFactory->GetConstituentLV(physvol->GetLogicalVolume());
160 }
161 else
162 {
163 lv = physvol->GetLogicalVolume();
164 }
165
166 const G4String volumeref = GenerateName(lv->GetName(), lv);
167
168 if(ModuleName.empty())
169 {
170 xercesc::DOMElement* volumerefElement = NewElement("volumeref");
171 volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
172 physvolElement->appendChild(volumerefElement);
173 }
174 else
175 {
176 xercesc::DOMElement* fileElement = NewElement("file");
177 fileElement->setAttributeNode(NewAttribute("name", ModuleName));
178 fileElement->setAttributeNode(NewAttribute("volname", volumeref));
179 physvolElement->appendChild(fileElement);
180 }
181
182 if(std::fabs(pos.x()) > kLinearPrecision ||
183 std::fabs(pos.y()) > kLinearPrecision ||
184 std::fabs(pos.z()) > kLinearPrecision)
185 {
186 PositionWrite(physvolElement, name + "_pos", pos);
187 }
188 if(std::fabs(rot.x()) > kAngularPrecision ||
189 std::fabs(rot.y()) > kAngularPrecision ||
190 std::fabs(rot.z()) > kAngularPrecision)
191 {
192 RotationWrite(physvolElement, name + "_rot", rot);
193 }
194 if(std::fabs(scl.x() - 1.0) > kRelativePrecision ||
195 std::fabs(scl.y() - 1.0) > kRelativePrecision ||
196 std::fabs(scl.z() - 1.0) > kRelativePrecision)
197 {
198 ScaleWrite(physvolElement, name + "_scl", scl);
199 }
200}
void ScaleWrite(xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &scl)
static const G4double kRelativePrecision
G4bool IsReflected(G4LogicalVolume *lv) const
G4LogicalVolume * GetConstituentLV(G4LogicalVolume *reflLV) const
CLHEP::HepRotation getRotation() const
void getDecomposition(Scale3D &scale, Rotate3D &rotation, Translate3D &translation) const
Definition: Transform3D.cc:173

Referenced by TraverseVolumeTree().

◆ ReplicavolWrite()

void G4GDMLWriteStructure::ReplicavolWrite ( xercesc::DOMElement *  volumeElement,
const G4VPhysicalVolume * const  replicavol 
)
protected

Definition at line 203 of file G4GDMLWriteStructure.cc.

205{
206 EAxis axis = kUndefined;
207 G4int number = 0;
208 G4double width = 0.0;
209 G4double offset = 0.0;
210 G4bool consuming = false;
211 G4String unitString("mm");
212
213 replicavol->GetReplicationData(axis, number, width, offset, consuming);
214
215 const G4String volumeref = GenerateName(
216 replicavol->GetLogicalVolume()->GetName(), replicavol->GetLogicalVolume());
217
218 xercesc::DOMElement* replicavolElement = NewElement("replicavol");
219 replicavolElement->setAttributeNode(NewAttribute("number", number));
220 xercesc::DOMElement* volumerefElement = NewElement("volumeref");
221 volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
222 replicavolElement->appendChild(volumerefElement);
223 xercesc::DOMElement* replicateElement = NewElement("replicate_along_axis");
224 replicavolElement->appendChild(replicateElement);
225
226 xercesc::DOMElement* dirElement = NewElement("direction");
227 if(axis == kXAxis)
228 {
229 dirElement->setAttributeNode(NewAttribute("x", "1"));
230 }
231 else if(axis == kYAxis)
232 {
233 dirElement->setAttributeNode(NewAttribute("y", "1"));
234 }
235 else if(axis == kZAxis)
236 {
237 dirElement->setAttributeNode(NewAttribute("z", "1"));
238 }
239 else if(axis == kRho)
240 {
241 dirElement->setAttributeNode(NewAttribute("rho", "1"));
242 }
243 else if(axis == kPhi)
244 {
245 dirElement->setAttributeNode(NewAttribute("phi", "1"));
246 unitString = "rad";
247 }
248 replicateElement->appendChild(dirElement);
249
250 xercesc::DOMElement* widthElement = NewElement("width");
251 widthElement->setAttributeNode(NewAttribute("value", width));
252 widthElement->setAttributeNode(NewAttribute("unit", unitString));
253 replicateElement->appendChild(widthElement);
254
255 xercesc::DOMElement* offsetElement = NewElement("offset");
256 offsetElement->setAttributeNode(NewAttribute("value", offset));
257 offsetElement->setAttributeNode(NewAttribute("unit", unitString));
258 replicateElement->appendChild(offsetElement);
259
260 volumeElement->appendChild(replicavolElement);
261}
virtual void GetReplicationData(EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const =0

Referenced by TraverseVolumeTree().

◆ SetEnergyCutsExport()

void G4GDMLWriteStructure::SetEnergyCutsExport ( G4bool  fcuts)

Definition at line 843 of file G4GDMLWriteStructure.cc.

844{
845 cexport = fcuts;
846}

◆ SetMaxExportLevel()

void G4GDMLWriteStructure::SetMaxExportLevel ( G4int  level)

Definition at line 911 of file G4GDMLWriteStructure.cc.

912{
913 if(level <= 0)
914 {
915 G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()", "InvalidSetup",
916 FatalException, "Levels to export must be greater than zero!");
917 return;
918 }
919 maxLevel = level;
920 levelNo = 0;
921}

◆ SetSDExport()

void G4GDMLWriteStructure::SetSDExport ( G4bool  fsd)

Definition at line 885 of file G4GDMLWriteStructure.cc.

886{
887 sdexport = fsd;
888}

◆ SkinSurfaceCache()

void G4GDMLWriteStructure::SkinSurfaceCache ( const G4LogicalSkinSurface * const  ssurf)
protected

Definition at line 376 of file G4GDMLWriteStructure.cc.

378{
379 if(ssurf == nullptr)
380 {
381 return;
382 }
383
384 const G4SurfaceProperty* psurf = ssurf->GetSurfaceProperty();
385
386 // Generate the new element for border-surface
387 //
388 const G4String& ssname = GenerateName(ssurf->GetName(), ssurf);
389 const G4String& psname = GenerateName(psurf->GetName(), psurf);
390 xercesc::DOMElement* skinElement = NewElement("skinsurface");
391 skinElement->setAttributeNode(NewAttribute("name", ssname));
392 skinElement->setAttributeNode(NewAttribute("surfaceproperty", psname));
393
394 const G4String volumeref = GenerateName(ssurf->GetLogicalVolume()->GetName(),
395 ssurf->GetLogicalVolume());
396 xercesc::DOMElement* volumerefElement = NewElement("volumeref");
397 volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
398 skinElement->appendChild(volumerefElement);
399
400 if(FindOpticalSurface(psurf))
401 {
402 const G4OpticalSurface* opsurf =
403 dynamic_cast<const G4OpticalSurface*>(psurf);
404 if(opsurf == nullptr)
405 {
406 G4Exception("G4GDMLWriteStructure::SkinSurfaceCache()", "InvalidSetup",
407 FatalException, "No optical surface found!");
408 return;
409 }
411 }
412
413 skinElementVec.push_back(skinElement);
414}
std::vector< xercesc::DOMElement * > skinElementVec
const G4LogicalVolume * GetLogicalVolume() const

Referenced by TraverseVolumeTree().

◆ StructureWrite()

void G4GDMLWriteStructure::StructureWrite ( xercesc::DOMElement *  gdmlElement)
virtual

Implements G4GDMLWrite.

Definition at line 493 of file G4GDMLWriteStructure.cc.

494{
495#ifdef G4VERBOSE
496 G4cout << "G4GDML: Writing structure..." << G4endl;
497#endif
498
499 // filling the list of phys volumes that are parts of assemblies
500
502
503 for(auto it = assemblies->cbegin(); it != assemblies->cend(); ++it)
504 {
505 auto vit = (*it)->GetVolumesIterator();
506
507 for(std::size_t i5 = 0; i5 < (*it)->TotalImprintedVolumes(); ++i5)
508 {
509 G4String pvname = (*vit)->GetName();
510 std::size_t pos = pvname.find("_impr_") + 6;
511 G4String impID = pvname.substr(pos);
512
513 pos = impID.find("_");
514 impID = impID.substr(0, pos);
515
516 assemblyVolMap[*vit] = (*it)->GetAssemblyID();
517 imprintsMap[*vit] = std::atoi(impID.c_str());
518 ++vit;
519 }
520 }
521
522 structureElement = NewElement("structure");
523 gdmlElement->appendChild(structureElement);
524}
#define G4endl
Definition: G4ios.hh:57
G4GLOB_DLL std::ostream G4cout
xercesc::DOMElement * structureElement

◆ SurfacesWrite()

void G4GDMLWriteStructure::SurfacesWrite ( )
protectedvirtual

Implements G4GDMLWrite.

Definition at line 475 of file G4GDMLWriteStructure.cc.

476{
477#ifdef G4VERBOSE
478 G4cout << "G4GDML: Writing surfaces..." << G4endl;
479#endif
480 for(auto pos = skinElementVec.cbegin();
481 pos != skinElementVec.cend(); ++pos)
482 {
483 structureElement->appendChild(*pos);
484 }
485 for(auto pos = borderElementVec.cbegin();
486 pos != borderElementVec.cend(); ++pos)
487 {
488 structureElement->appendChild(*pos);
489 }
490}

◆ TraverseVolumeTree()

G4Transform3D G4GDMLWriteStructure::TraverseVolumeTree ( const G4LogicalVolume *const  topVol,
const G4int  depth 
)
protectedvirtual

Implements G4GDMLWrite.

Definition at line 527 of file G4GDMLWriteStructure.cc.

529{
530 if(VolumeMap().find(volumePtr) != VolumeMap().cend())
531 {
532 return VolumeMap()[volumePtr]; // Volume is already processed
533 }
534
535 G4VSolid* solidPtr = volumePtr->GetSolid();
536 G4Transform3D R, invR;
537 G4int trans = 0;
538
539 std::map<const G4LogicalVolume*, G4GDMLAuxListType>::iterator auxiter;
540
541 ++levelNo;
542
543 while(true) // Solve possible displacement/reflection
544 { // of the referenced solid!
545 if(trans > maxTransforms)
546 {
547 G4String ErrorMessage = "Referenced solid in volume '" +
548 volumePtr->GetName() +
549 "' was displaced/reflected too many times!";
550 G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()", "InvalidSetup",
551 FatalException, ErrorMessage);
552 }
553
554 if(G4ReflectedSolid* refl = dynamic_cast<G4ReflectedSolid*>(solidPtr))
555 {
556 R = R * refl->GetTransform3D();
557 solidPtr = refl->GetConstituentMovedSolid();
558 ++trans;
559 continue;
560 }
561
562 if(G4DisplacedSolid* disp = dynamic_cast<G4DisplacedSolid*>(solidPtr))
563 {
564 R = R * G4Transform3D(disp->GetObjectRotation(),
565 disp->GetObjectTranslation());
566 solidPtr = disp->GetConstituentMovedSolid();
567 ++trans;
568 continue;
569 }
570
571 break;
572 }
573
574 // check if it is a reflected volume
575 G4LogicalVolume* tmplv = const_cast<G4LogicalVolume*>(volumePtr);
576
577 if(reflFactory->IsReflected(tmplv))
578 {
579 tmplv = reflFactory->GetConstituentLV(tmplv);
580 if(VolumeMap().find(tmplv) != VolumeMap().cend())
581 {
582 return R; // Volume is already processed
583 }
584 }
585
586 // Only compute the inverse when necessary!
587 //
588 if(trans > 0)
589 {
590 invR = R.inverse();
591 }
592
593 const G4String name = GenerateName(tmplv->GetName(), tmplv);
594
595 G4String materialref = "NULL";
596
597 if(volumePtr->GetMaterial())
598 {
599 materialref = GenerateName(volumePtr->GetMaterial()->GetName(),
600 volumePtr->GetMaterial());
601 }
602
603 const G4String solidref = GenerateName(solidPtr->GetName(), solidPtr);
604
605 xercesc::DOMElement* volumeElement = NewElement("volume");
606 volumeElement->setAttributeNode(NewAttribute("name", name));
607 xercesc::DOMElement* materialrefElement = NewElement("materialref");
608 materialrefElement->setAttributeNode(NewAttribute("ref", materialref));
609 volumeElement->appendChild(materialrefElement);
610 xercesc::DOMElement* solidrefElement = NewElement("solidref");
611 solidrefElement->setAttributeNode(NewAttribute("ref", solidref));
612 volumeElement->appendChild(solidrefElement);
613
614 std::size_t daughterCount = volumePtr->GetNoDaughters();
615
616 if(levelNo == maxLevel) // Stop exporting if reached levels limit
617 {
618 daughterCount = 0;
619 }
620
621 std::map<G4int, std::vector<G4int> > assemblyIDToAddedImprints;
622
623 for(std::size_t i = 0; i < daughterCount; ++i) // Traverse all the children!
624 {
625 const G4VPhysicalVolume* const physvol = volumePtr->GetDaughter(i);
626 const G4String ModuleName = Modularize(physvol, depth);
627
628 G4Transform3D daughterR;
629
630 if(ModuleName.empty()) // Check if subtree requested to be
631 { // a separate module!
632 daughterR = TraverseVolumeTree(physvol->GetLogicalVolume(), depth + 1);
633 }
634 else
635 {
637 daughterR = writer.Write(ModuleName, physvol->GetLogicalVolume(),
638 SchemaLocation, depth + 1);
639 }
640
641 if(const G4PVDivision* const divisionvol =
642 dynamic_cast<const G4PVDivision*>(physvol)) // Is it division?
643 {
644 if(!G4Transform3D::Identity.isNear(invR * daughterR, kRelativePrecision))
645 {
646 G4String ErrorMessage = "Division volume in '" + name +
647 "' can not be related to reflected solid!";
648 G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
649 "InvalidSetup", FatalException, ErrorMessage);
650 }
651 DivisionvolWrite(volumeElement, divisionvol);
652 }
653 else
654 {
655 if(physvol->IsParameterised()) // Is it a paramvol?
656 {
657 if(!G4Transform3D::Identity.isNear(invR * daughterR,
659 {
660 G4String ErrorMessage = "Parameterised volume in '" + name +
661 "' can not be related to reflected solid!";
662 G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
663 "InvalidSetup", FatalException, ErrorMessage);
664 }
665 ParamvolWrite(volumeElement, physvol);
666 }
667 else
668 {
669 if(physvol->IsReplicated()) // Is it a replicavol?
670 {
671 if(!G4Transform3D::Identity.isNear(invR * daughterR,
673 {
674 G4String ErrorMessage = "Replica volume in '" + name +
675 "' can not be related to reflected solid!";
676 G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
677 "InvalidSetup", FatalException, ErrorMessage);
678 }
679 ReplicavolWrite(volumeElement, physvol);
680 }
681 else // Is it a physvol or an assembly?
682 {
683 if(assemblyVolMap.find(physvol) != assemblyVolMap.cend())
684 {
685 G4int assemblyID = assemblyVolMap[physvol];
686
687 G4String assemblyref = "Assembly_" + std::to_string(assemblyID);
688
689 // here I need to retrieve the imprint ID
690
691 G4int imprintID = imprintsMap[physvol];
692
693 // there are 2 steps:
694 //
695 // 1) add assembly to the structure if that has not yet been done
696 // (but after the constituents volumes have been added)
697 //
698
699 if(std::find(addedAssemblies.cbegin(), addedAssemblies.cend(),
700 assemblyID) == addedAssemblies.cend())
701 {
702 AssemblyWrite(structureElement, assemblyID);
703 addedAssemblies.push_back(assemblyID);
704 assemblyIDToAddedImprints[assemblyID] = std::vector<G4int>();
705 }
706
707 // 2) add the assembly (as physical volume) to the mother volume
708 // (but only once), using it's original position and rotation.
709 //
710
711 // here I need a check if assembly has been already added to the
712 // mother volume
713 std::vector<G4int>& addedImprints = assemblyIDToAddedImprints[assemblyID];
714 if(std::find(addedImprints.cbegin(), addedImprints.cend(),
715 imprintID) == addedImprints.cend())
716 {
717 G4String imprintname = "Imprint_" + std::to_string(imprintID) + "_";
718 imprintname = GenerateName(imprintname, physvol);
719
720 // I need to get those two from the container of imprints from
721 // the assembly I have the imprint ID, I need to get pos and rot
722 //
724 ->GetAssembly(assemblyID)
725 ->GetImprintTransformation(imprintID);
726
727 HepGeom::Scale3D scale;
728 HepGeom::Rotate3D rotate;
729 HepGeom::Translate3D translate;
730
731 transf.getDecomposition(scale, rotate, translate);
732
733 const G4ThreeVector scl(scale(0, 0), scale(1, 1), scale(2, 2));
734 const G4ThreeVector rot = GetAngles(rotate.getRotation().inverse());
735 const G4ThreeVector pos = transf.getTranslation();
736
737 // here I need a normal physvol referencing to my assemblyref
738
739 xercesc::DOMElement* physvolElement = NewElement("physvol");
740 physvolElement->setAttributeNode(NewAttribute("name", imprintname));
741
742 xercesc::DOMElement* volumerefElement = NewElement("volumeref");
743 volumerefElement->setAttributeNode(NewAttribute("ref", assemblyref));
744 physvolElement->appendChild(volumerefElement);
745
746 if(std::fabs(pos.x()) > kLinearPrecision ||
747 std::fabs(pos.y()) > kLinearPrecision ||
748 std::fabs(pos.z()) > kLinearPrecision)
749 {
750 PositionWrite(physvolElement, imprintname + "_pos", pos);
751 }
752 if(std::fabs(rot.x()) > kAngularPrecision ||
753 std::fabs(rot.y()) > kAngularPrecision ||
754 std::fabs(rot.z()) > kAngularPrecision)
755 {
756 RotationWrite(physvolElement, imprintname + "_rot", rot);
757 }
758 if(std::fabs(scl.x() - 1.0) > kRelativePrecision ||
759 std::fabs(scl.y() - 1.0) > kRelativePrecision ||
760 std::fabs(scl.z() - 1.0) > kRelativePrecision)
761 {
762 ScaleWrite(physvolElement, name + "_scl", scl);
763 }
764
765 volumeElement->appendChild(physvolElement);
766 //
767 addedImprints.push_back(imprintID);
768 }
769 }
770 else // not part of assembly, so a normal physical volume
771 {
773 if(physvol->GetFrameRotation() != nullptr)
774 {
775 rot = *(physvol->GetFrameRotation());
776 }
777 G4Transform3D P(rot, physvol->GetObjectTranslation());
778
779 PhysvolWrite(volumeElement, physvol, invR * P * daughterR,
780 ModuleName);
781 }
782 }
783 }
784 }
785 // BorderSurfaceCache(GetBorderSurface(physvol));
786 GetBorderSurface(physvol);
787 }
788
789 if(cexport)
790 {
791 ExportEnergyCuts(volumePtr);
792 }
793 // Add optional energy cuts
794
795 if(sdexport)
796 {
797 ExportSD(volumePtr);
798 }
799 // Add optional SDs
800
801 // Here write the auxiliary info
802 //
803 auxiter = auxmap.find(volumePtr);
804 if(auxiter != auxmap.cend())
805 {
806 AddAuxInfo(&(auxiter->second), volumeElement);
807 }
808
809 structureElement->appendChild(volumeElement);
810 // Append the volume AFTER traversing the children so that
811 // the order of volumes will be correct!
812
813 VolumeMap()[tmplv] = R;
814
815 AddExtension(volumeElement, volumePtr);
816 // Add any possible user defined extension attached to a volume
817
818 AddMaterial(volumePtr->GetMaterial());
819 // Add the involved materials and solids!
820
821 AddSolid(solidPtr);
822
824
825 return R;
826}
HepGeom::Transform3D G4Transform3D
HepRotation inverse() const
G4Transform3D & GetImprintTransformation(unsigned int imprintID)
void AddMaterial(const G4Material *const)
virtual void ParamvolWrite(xercesc::DOMElement *, const G4VPhysicalVolume *const)
virtual void AddSolid(const G4VSolid *const)
static const G4int maxTransforms
const G4LogicalBorderSurface * GetBorderSurface(const G4VPhysicalVolume *const)
void AssemblyWrite(xercesc::DOMElement *, const int assemblyID)
void SkinSurfaceCache(const G4LogicalSkinSurface *const)
const G4LogicalSkinSurface * GetSkinSurface(const G4LogicalVolume *const)
void PhysvolWrite(xercesc::DOMElement *, const G4VPhysicalVolume *const topVol, const G4Transform3D &transform, const G4String &moduleName)
void ExportEnergyCuts(const G4LogicalVolume *const)
void ExportSD(const G4LogicalVolume *const)
void DivisionvolWrite(xercesc::DOMElement *, const G4PVDivision *const)
void ReplicavolWrite(xercesc::DOMElement *, const G4VPhysicalVolume *const)
G4String SchemaLocation
Definition: G4GDMLWrite.hh:130
G4String Modularize(const G4VPhysicalVolume *const topvol, const G4int depth)
Definition: G4GDMLWrite.cc:377
virtual void AddExtension(xercesc::DOMElement *, const G4LogicalVolume *const)
Definition: G4GDMLWrite.cc:80
G4Transform3D Write(const G4String &filename, const G4LogicalVolume *const topLog, const G4String &schemaPath, const G4int depth, G4bool storeReferences=true)
Definition: G4GDMLWrite.cc:203
void AddAuxInfo(G4GDMLAuxListType *auxInfoList, xercesc::DOMElement *element)
Definition: G4GDMLWrite.cc:94
VolumeMapType & VolumeMap()
Definition: G4GDMLWrite.cc:60
virtual G4bool IsReplicated() const =0
const G4RotationMatrix * GetFrameRotation() const
G4ThreeVector GetObjectTranslation() const
virtual G4bool IsParameterised() const =0
G4String GetName() const
static DLL_API const Transform3D Identity
Definition: Transform3D.h:196
CLHEP::Hep3Vector getTranslation() const
Transform3D inverse() const
Definition: Transform3D.cc:141

Referenced by AssemblyWrite(), and TraverseVolumeTree().

Member Data Documentation

◆ auxmap

std::map<const G4LogicalVolume*, G4GDMLAuxListType> G4GDMLWriteStructure::auxmap
protected

Definition at line 94 of file G4GDMLWriteStructure.hh.

Referenced by AddVolumeAuxiliary(), and TraverseVolumeTree().

◆ borderElementVec

std::vector<xercesc::DOMElement*> G4GDMLWriteStructure::borderElementVec
protected

Definition at line 92 of file G4GDMLWriteStructure.hh.

Referenced by BorderSurfaceCache(), and SurfacesWrite().

◆ skinElementVec

std::vector<xercesc::DOMElement*> G4GDMLWriteStructure::skinElementVec
protected

Definition at line 93 of file G4GDMLWriteStructure.hh.

Referenced by SkinSurfaceCache(), and SurfacesWrite().

◆ structureElement

xercesc::DOMElement* G4GDMLWriteStructure::structureElement = nullptr
protected

Definition at line 91 of file G4GDMLWriteStructure.hh.

Referenced by StructureWrite(), SurfacesWrite(), and TraverseVolumeTree().


The documentation for this class was generated from the following files: