Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
G4GDMLReadParamvol Class Reference

#include <G4GDMLReadParamvol.hh>

+ Inheritance diagram for G4GDMLReadParamvol:

Public Member Functions

virtual void ParamvolRead (const xercesc::DOMElement *const, G4LogicalVolume *)
 
virtual void Paramvol_contentRead (const xercesc::DOMElement *const)
 
- Public Member Functions inherited from G4GDMLReadSetup
G4String GetSetup (const G4String &)
 
virtual void SetupRead (const xercesc::DOMElement *const element)
 
- Public Member Functions inherited from G4GDMLReadSolids
G4VSolid * GetSolid (const G4String &) const
 
G4SurfaceProperty * GetSurfaceProperty (const G4String &) const
 
virtual void SolidsRead (const xercesc::DOMElement *const)
 
- Public Member Functions inherited from G4GDMLReadMaterials
G4Element * GetElement (const G4String &, G4bool verbose=true) const
 
G4Isotope * GetIsotope (const G4String &, G4bool verbose=true) const
 
G4Material * GetMaterial (const G4String &, G4bool verbose=true) const
 
virtual void MaterialsRead (const xercesc::DOMElement *const)
 
- Public Member Functions inherited from G4GDMLReadDefine
G4bool IsValidID (const G4String &) const
 
G4double GetConstant (const G4String &)
 
G4double GetVariable (const G4String &)
 
G4double GetQuantity (const G4String &)
 
G4ThreeVector GetPosition (const G4String &)
 
G4ThreeVector GetRotation (const G4String &)
 
G4ThreeVector GetScale (const G4String &)
 
G4GDMLMatrix GetMatrix (const G4String &)
 
virtual void DefineRead (const xercesc::DOMElement *const)
 
void SetReverseSearch (G4bool flag)
 
- Public Member Functions inherited from G4GDMLRead
virtual void Volume_contentRead (const xercesc::DOMElement *const)=0
 
virtual void StructureRead (const xercesc::DOMElement *const)=0
 
virtual void ExtensionRead (const xercesc::DOMElement *const)
 
virtual void UserinfoRead (const xercesc::DOMElement *const)
 
virtual G4LogicalVolume * GetVolume (const G4String &) const =0
 
void Read (const G4String &, G4bool validation, G4bool isModule, G4bool strip=true)
 
void StripNames () const
 
void StripName (G4String &) const
 
const G4String & GetSchemaFile () const
 
void SetSchemaFile (const G4String &schemaFile)
 
void OverlapCheck (G4bool)
 
const G4GDMLAuxListType * GetAuxList () const
 

Protected Member Functions

 G4GDMLReadParamvol ()
 
virtual ~G4GDMLReadParamvol ()
 
void Box_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Trd_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Trap_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Tube_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Cone_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Sphere_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Orb_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Torus_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Ellipsoid_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Para_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Hype_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Polycone_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void Polyhedra_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
 
void ParameterisedRead (const xercesc::DOMElement *const)
 
void ParametersRead (const xercesc::DOMElement *const)
 
- Protected Member Functions inherited from G4GDMLReadSetup
 G4GDMLReadSetup ()
 
virtual ~G4GDMLReadSetup ()
 
- Protected Member Functions inherited from G4GDMLReadSolids
 G4GDMLReadSolids ()
 
virtual ~G4GDMLReadSolids ()
 
void BooleanRead (const xercesc::DOMElement *const, const BooleanOp)
 
void BoxRead (const xercesc::DOMElement *const)
 
void ConeRead (const xercesc::DOMElement *const)
 
void ElconeRead (const xercesc::DOMElement *const)
 
void EllipsoidRead (const xercesc::DOMElement *const)
 
void EltubeRead (const xercesc::DOMElement *const)
 
void XtruRead (const xercesc::DOMElement *const)
 
void HypeRead (const xercesc::DOMElement *const)
 
void MultiUnionNodeRead (const xercesc::DOMElement *const, G4MultiUnion *const)
 
void MultiUnionRead (const xercesc::DOMElement *const)
 
void OrbRead (const xercesc::DOMElement *const)
 
void ParaRead (const xercesc::DOMElement *const)
 
void ParaboloidRead (const xercesc::DOMElement *const)
 
void PolyconeRead (const xercesc::DOMElement *const)
 
void GenericPolyconeRead (const xercesc::DOMElement *const)
 
void PolyhedraRead (const xercesc::DOMElement *const)
 
void GenericPolyhedraRead (const xercesc::DOMElement *const)
 
G4QuadrangularFacet * QuadrangularRead (const xercesc::DOMElement *const)
 
void ReflectedSolidRead (const xercesc::DOMElement *const)
 
void ScaledSolidRead (const xercesc::DOMElement *const)
 
G4ExtrudedSolid::ZSection SectionRead (const xercesc::DOMElement *const, G4double)
 
void SphereRead (const xercesc::DOMElement *const)
 
void TessellatedRead (const xercesc::DOMElement *const)
 
void TetRead (const xercesc::DOMElement *const)
 
void TorusRead (const xercesc::DOMElement *const)
 
void GenTrapRead (const xercesc::DOMElement *const)
 
void TrapRead (const xercesc::DOMElement *const)
 
void TrdRead (const xercesc::DOMElement *const)
 
void TubeRead (const xercesc::DOMElement *const)
 
void CutTubeRead (const xercesc::DOMElement *const)
 
void TwistedboxRead (const xercesc::DOMElement *const)
 
void TwistedtrapRead (const xercesc::DOMElement *const)
 
void TwistedtrdRead (const xercesc::DOMElement *const)
 
void TwistedtubsRead (const xercesc::DOMElement *const)
 
G4TriangularFacet * TriangularRead (const xercesc::DOMElement *const)
 
G4TwoVector TwoDimVertexRead (const xercesc::DOMElement *const, G4double)
 
zplaneType ZplaneRead (const xercesc::DOMElement *const)
 
rzPointType RZPointRead (const xercesc::DOMElement *const)
 
void OpticalSurfaceRead (const xercesc::DOMElement *const)
 
void PropertyRead (const xercesc::DOMElement *const, G4OpticalSurface *)
 
- Protected Member Functions inherited from G4GDMLReadMaterials
 G4GDMLReadMaterials ()
 
virtual ~G4GDMLReadMaterials ()
 
G4double AtomRead (const xercesc::DOMElement *const)
 
G4int CompositeRead (const xercesc::DOMElement *const, G4String &)
 
G4double DRead (const xercesc::DOMElement *const)
 
G4double PRead (const xercesc::DOMElement *const)
 
G4double TRead (const xercesc::DOMElement *const)
 
G4double MEERead (const xercesc::DOMElement *const)
 
void ElementRead (const xercesc::DOMElement *const)
 
G4double FractionRead (const xercesc::DOMElement *const, G4String &)
 
void IsotopeRead (const xercesc::DOMElement *const)
 
void MaterialRead (const xercesc::DOMElement *const)
 
void MixtureRead (const xercesc::DOMElement *const, G4Element *)
 
void MixtureRead (const xercesc::DOMElement *const, G4Material *)
 
void PropertyRead (const xercesc::DOMElement *const, G4Material *)
 
- Protected Member Functions inherited from G4GDMLReadDefine
 G4GDMLReadDefine ()
 
virtual ~G4GDMLReadDefine ()
 
G4RotationMatrix GetRotationMatrix (const G4ThreeVector &)
 
void VectorRead (const xercesc::DOMElement *const, G4ThreeVector &)
 
G4String RefRead (const xercesc::DOMElement *const)
 
void ConstantRead (const xercesc::DOMElement *const)
 
void MatrixRead (const xercesc::DOMElement *const)
 
void PositionRead (const xercesc::DOMElement *const)
 
void RotationRead (const xercesc::DOMElement *const)
 
void ScaleRead (const xercesc::DOMElement *const)
 
void VariableRead (const xercesc::DOMElement *const)
 
void QuantityRead (const xercesc::DOMElement *const)
 
void ExpressionRead (const xercesc::DOMElement *const)
 
- Protected Member Functions inherited from G4GDMLRead
 G4GDMLRead ()
 
virtual ~G4GDMLRead ()
 
G4String Transcode (const XMLCh *const)
 
G4String GenerateName (const G4String &name, G4bool strip=false)
 
G4String Strip (const G4String &) const
 
void GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)
 
void LoopRead (const xercesc::DOMElement *const, void(G4GDMLRead::*)(const xercesc::DOMElement *const))
 
G4GDMLAuxStructType AuxiliaryRead (const xercesc::DOMElement *const auxElem)
 

Protected Attributes

G4GDMLParameterisation * parameterisation = nullptr
 
- Protected Attributes inherited from G4GDMLReadSetup
std::map< G4String, G4String > setupMap
 
- Protected Attributes inherited from G4GDMLReadDefine
G4bool reverseSearch = false
 
std::map< G4String, G4double > quantityMap
 
std::map< G4String, G4ThreeVector > positionMap
 
std::map< G4String, G4ThreeVector > rotationMap
 
std::map< G4String, G4ThreeVector > scaleMap
 
std::map< G4String, G4GDMLMatrix > matrixMap
 
- Protected Attributes inherited from G4GDMLRead
G4GDMLEvaluator eval
 
G4bool validate = true
 
G4bool check = false
 
G4bool dostrip = true
 
G4String schema = ""
 

Detailed Description

Definition at line 42 of file G4GDMLReadParamvol.hh.

Constructor & Destructor Documentation

◆ G4GDMLReadParamvol()

G4GDMLReadParamvol::G4GDMLReadParamvol ( )
protected

Definition at line 40 of file G4GDMLReadParamvol.cc.

41 : G4GDMLReadSetup()
42{
43}

◆ ~G4GDMLReadParamvol()

G4GDMLReadParamvol::~G4GDMLReadParamvol ( )
protectedvirtual

Definition at line 45 of file G4GDMLReadParamvol.cc.

46{
47}

Member Function Documentation

◆ Box_dimensionsRead()

void G4GDMLReadParamvol::Box_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 50 of file G4GDMLReadParamvol.cc.

53{
54 G4double lunit = 1.0;
55
56 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
57 XMLSize_t attributeCount = attributes->getLength();
58
59 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
60 ++attribute_index)
61 {
62 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
63
64 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
65 {
66 continue;
67 }
68
69 const xercesc::DOMAttr* const attribute =
70 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
71 if(attribute == nullptr)
72 {
73 G4Exception("G4GDMLReadParamvol::Box_dimensionsRead()", "InvalidRead",
74 FatalException, "No attribute found!");
75 return;
76 }
77 const G4String attName = Transcode(attribute->getName());
78 const G4String attValue = Transcode(attribute->getValue());
79
80 if(attName == "lunit")
81 {
82 lunit = G4UnitDefinition::GetValueOf(attValue);
83 if(G4UnitDefinition::GetCategory(attValue) != "Length")
84 {
85 G4Exception("G4GDMLReadParamvol::Box_dimensionsRead()", "InvalidRead",
86 FatalException, "Invalid unit for length!");
87 }
88 }
89 else if(attName == "x")
90 {
91 parameter.dimension[0] = eval.Evaluate(attValue);
92 }
93 else if(attName == "y")
94 {
95 parameter.dimension[1] = eval.Evaluate(attValue);
96 }
97 else if(attName == "z")
98 {
99 parameter.dimension[2] = eval.Evaluate(attValue);
100 }
101 }
102
103 parameter.dimension[0] *= 0.5 * lunit;
104 parameter.dimension[1] *= 0.5 * lunit;
105 parameter.dimension[2] *= 0.5 * lunit;
106}
FatalException
@ FatalException
Definition G4ExceptionSeverity.hh:67
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition G4Exception.cc:59
G4double
double G4double
Definition G4Types.hh:83
G4GDMLEvaluator::Evaluate
G4double Evaluate(const G4String &)
Definition G4GDMLEvaluator.cc:238
G4GDMLRead::Transcode
G4String Transcode(const XMLCh *const)
Definition G4GDMLRead.cc:57
G4GDMLRead::eval
G4GDMLEvaluator eval
Definition G4GDMLRead.hh:161
G4UnitDefinition::GetValueOf
static G4double GetValueOf(const G4String &)
Definition G4UnitsTable.cc:185
G4UnitDefinition::GetCategory
static G4String GetCategory(const G4String &)
Definition G4UnitsTable.cc:210

Referenced by ParametersRead().

◆ Cone_dimensionsRead()

void G4GDMLReadParamvol::Cone_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 366 of file G4GDMLReadParamvol.cc.

369{
370 G4double lunit = 1.0;
371 G4double aunit = 1.0;
372
373 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
374 XMLSize_t attributeCount = attributes->getLength();
375
376 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
377 ++attribute_index)
378 {
379 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
380
381 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
382 {
383 continue;
384 }
385
386 const xercesc::DOMAttr* const attribute =
387 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
388 if(attribute == nullptr)
389 {
390 G4Exception("G4GDMLReadParamvol::Cone_dimensionsRead()", "InvalidRead",
391 FatalException, "No attribute found!");
392 return;
393 }
394 const G4String attName = Transcode(attribute->getName());
395 const G4String attValue = Transcode(attribute->getValue());
396
397 if(attName == "lunit")
398 {
399 lunit = G4UnitDefinition::GetValueOf(attValue);
400 if(G4UnitDefinition::GetCategory(attValue) != "Length")
401 {
402 G4Exception("G4GDMLReadParamvol::Cone_dimensionsRead()", "InvalidRead",
403 FatalException, "Invalid unit for length!");
404 }
405 }
406 else if(attName == "aunit")
407 {
408 aunit = G4UnitDefinition::GetValueOf(attValue);
409 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
410 {
411 G4Exception("G4GDMLReadParamvol::Cone_dimensions()", "InvalidRead",
412 FatalException, "Invalid unit for angle!");
413 }
414 }
415 else if(attName == "rmin1")
416 {
417 parameter.dimension[0] = eval.Evaluate(attValue);
418 }
419 else if(attName == "rmax1")
420 {
421 parameter.dimension[1] = eval.Evaluate(attValue);
422 }
423 else if(attName == "rmin2")
424 {
425 parameter.dimension[2] = eval.Evaluate(attValue);
426 }
427 else if(attName == "rmax2")
428 {
429 parameter.dimension[3] = eval.Evaluate(attValue);
430 }
431 else if(attName == "z")
432 {
433 parameter.dimension[4] = eval.Evaluate(attValue);
434 }
435 else if(attName == "startphi")
436 {
437 parameter.dimension[5] = eval.Evaluate(attValue);
438 }
439 else if(attName == "deltaphi")
440 {
441 parameter.dimension[6] = eval.Evaluate(attValue);
442 }
443 }
444
445 parameter.dimension[0] *= lunit;
446 parameter.dimension[1] *= lunit;
447 parameter.dimension[2] *= lunit;
448 parameter.dimension[3] *= lunit;
449 parameter.dimension[4] *= 0.5 * lunit;
450 parameter.dimension[5] *= aunit;
451 parameter.dimension[6] *= aunit;
452}

Referenced by ParametersRead().

◆ Ellipsoid_dimensionsRead()

void G4GDMLReadParamvol::Ellipsoid_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 667 of file G4GDMLReadParamvol.cc.

670{
671 G4double lunit = 1.0;
672 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
673 XMLSize_t attributeCount = attributes->getLength();
674
675 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
676 ++attribute_index)
677 {
678 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
679
680 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
681 {
682 continue;
683 }
684
685 const xercesc::DOMAttr* const attribute =
686 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
687 if(attribute == nullptr)
688 {
689 G4Exception("G4GDMLReadParamvol::Ellipsoid_dimensionsRead()",
690 "InvalidRead", FatalException, "No attribute found!");
691 return;
692 }
693 const G4String attName = Transcode(attribute->getName());
694 const G4String attValue = Transcode(attribute->getValue());
695
696 if(attName == "lunit")
697 {
698 lunit = G4UnitDefinition::GetValueOf(attValue);
699 if(G4UnitDefinition::GetCategory(attValue) != "Length")
700 {
701 G4Exception("G4GDMLReadParamvol::Ellipsoid_dimensionsRead()",
702 "InvalidRead", FatalException, "Invalid unit for length!");
703 }
704 }
705 else if(attName == "ax")
706 {
707 parameter.dimension[0] = eval.Evaluate(attValue);
708 }
709 else if(attName == "by")
710 {
711 parameter.dimension[1] = eval.Evaluate(attValue);
712 }
713 else if(attName == "cz")
714 {
715 parameter.dimension[2] = eval.Evaluate(attValue);
716 }
717 else if(attName == "zcut1")
718 {
719 parameter.dimension[3] = eval.Evaluate(attValue);
720 }
721 else if(attName == "zcut2")
722 {
723 parameter.dimension[4] = eval.Evaluate(attValue);
724 }
725 }
726
727 parameter.dimension[0] *= lunit;
728 parameter.dimension[1] *= lunit;
729 parameter.dimension[2] *= lunit;
730 parameter.dimension[3] *= lunit;
731 parameter.dimension[4] *= lunit;
732}

Referenced by ParametersRead().

◆ Hype_dimensionsRead()

void G4GDMLReadParamvol::Hype_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 819 of file G4GDMLReadParamvol.cc.

822{
823 G4double lunit = 1.0;
824 G4double aunit = 1.0;
825
826 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
827 XMLSize_t attributeCount = attributes->getLength();
828
829 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
830 ++attribute_index)
831 {
832 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
833
834 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
835 {
836 continue;
837 }
838
839 const xercesc::DOMAttr* const attribute =
840 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
841 if(attribute == nullptr)
842 {
843 G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
844 FatalException, "No attribute found!");
845 return;
846 }
847 const G4String attName = Transcode(attribute->getName());
848 const G4String attValue = Transcode(attribute->getValue());
849
850 if(attName == "lunit")
851 {
852 lunit = G4UnitDefinition::GetValueOf(attValue);
853 if(G4UnitDefinition::GetCategory(attValue) != "Length")
854 {
855 G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
856 FatalException, "Invalid unit for length!");
857 }
858 }
859 else if(attName == "aunit")
860 {
861 aunit = G4UnitDefinition::GetValueOf(attValue);
862 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
863 {
864 G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
865 FatalException, "Invalid unit for angle!");
866 }
867 }
868 else if(attName == "rmin")
869 {
870 parameter.dimension[0] = eval.Evaluate(attValue);
871 }
872 else if(attName == "rmax")
873 {
874 parameter.dimension[1] = eval.Evaluate(attValue);
875 }
876 else if(attName == "inst")
877 {
878 parameter.dimension[2] = eval.Evaluate(attValue);
879 }
880 else if(attName == "outst")
881 {
882 parameter.dimension[3] = eval.Evaluate(attValue);
883 }
884 else if(attName == "z")
885 {
886 parameter.dimension[4] = eval.Evaluate(attValue);
887 }
888 }
889
890 parameter.dimension[0] = lunit;
891 parameter.dimension[1] = lunit;
892 parameter.dimension[2] = aunit;
893 parameter.dimension[3] = aunit;
894 parameter.dimension[4] = 0.5 * lunit;
895}

Referenced by ParametersRead().

◆ Orb_dimensionsRead()

void G4GDMLReadParamvol::Orb_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 539 of file G4GDMLReadParamvol.cc.

542{
543 G4double lunit = 1.0;
544
545 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
546 XMLSize_t attributeCount = attributes->getLength();
547
548 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
549 ++attribute_index)
550 {
551 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
552
553 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
554 {
555 continue;
556 }
557
558 const xercesc::DOMAttr* const attribute =
559 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
560 if(attribute == nullptr)
561 {
562 G4Exception("G4GDMLReadParamvol::Orb_dimensionsRead()", "InvalidRead",
563 FatalException, "No attribute found!");
564 return;
565 }
566 const G4String attName = Transcode(attribute->getName());
567 const G4String attValue = Transcode(attribute->getValue());
568
569 if(attName == "lunit")
570 {
571 lunit = G4UnitDefinition::GetValueOf(attValue);
572 }
573 if(G4UnitDefinition::GetCategory(attValue) != "Length")
574 {
575 G4Exception("G4GDMLReadParamvol::Orb_dimensionsRead()", "InvalidRead",
576 FatalException, "Invalid unit for length!");
577 }
578 else if(attName == "r")
579 {
580 parameter.dimension[0] = eval.Evaluate(attValue);
581 }
582 }
583
584 parameter.dimension[0] *= lunit;
585}

Referenced by ParametersRead().

◆ Para_dimensionsRead()

void G4GDMLReadParamvol::Para_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 735 of file G4GDMLReadParamvol.cc.

738{
739 G4double lunit = 1.0;
740 G4double aunit = 1.0;
741
742 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
743 XMLSize_t attributeCount = attributes->getLength();
744
745 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
746 ++attribute_index)
747 {
748 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
749
750 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
751 {
752 continue;
753 }
754
755 const xercesc::DOMAttr* const attribute =
756 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
757 if(attribute == nullptr)
758 {
759 G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
760 FatalException, "No attribute found!");
761 return;
762 }
763 const G4String attName = Transcode(attribute->getName());
764 const G4String attValue = Transcode(attribute->getValue());
765
766 if(attName == "lunit")
767 {
768 lunit = G4UnitDefinition::GetValueOf(attValue);
769 if(G4UnitDefinition::GetCategory(attValue) != "Length")
770 {
771 G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
772 FatalException, "Invalid unit for length!");
773 }
774 }
775 else if(attName == "aunit")
776 {
777 aunit = G4UnitDefinition::GetValueOf(attValue);
778 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
779 {
780 G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
781 FatalException, "Invalid unit for angle!");
782 }
783 }
784 else if(attName == "x")
785 {
786 parameter.dimension[0] = eval.Evaluate(attValue);
787 }
788 else if(attName == "y")
789 {
790 parameter.dimension[1] = eval.Evaluate(attValue);
791 }
792 else if(attName == "z")
793 {
794 parameter.dimension[2] = eval.Evaluate(attValue);
795 }
796 else if(attName == "alpha")
797 {
798 parameter.dimension[3] = eval.Evaluate(attValue);
799 }
800 else if(attName == "theta")
801 {
802 parameter.dimension[4] = eval.Evaluate(attValue);
803 }
804 else if(attName == "phi")
805 {
806 parameter.dimension[5] = eval.Evaluate(attValue);
807 }
808 }
809
810 parameter.dimension[0] = 0.5 * lunit;
811 parameter.dimension[1] = 0.5 * lunit;
812 parameter.dimension[2] = 0.5 * lunit;
813 parameter.dimension[3] = aunit;
814 parameter.dimension[4] = aunit;
815 parameter.dimension[5] = aunit;
816}

Referenced by ParametersRead().

◆ ParameterisedRead()

void G4GDMLReadParamvol::ParameterisedRead ( const xercesc::DOMElement * const element)
protected

Definition at line 1219 of file G4GDMLReadParamvol.cc.

1221{
1222 for(xercesc::DOMNode* iter = element->getFirstChild(); iter != nullptr;
1223 iter = iter->getNextSibling())
1224 {
1225 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
1226 {
1227 continue;
1228 }
1229
1230 const xercesc::DOMElement* const child =
1231 dynamic_cast<xercesc::DOMElement*>(iter);
1232 if(child == nullptr)
1233 {
1234 G4Exception("G4GDMLReadParamvol::ParameterisedRead()", "InvalidRead",
1235 FatalException, "No child found!");
1236 return;
1237 }
1238 const G4String tag = Transcode(child->getTagName());
1239
1240 if(tag == "parameters")
1241 {
1242 const xercesc::DOMNamedNodeMap* const attributes =
1243 element->getAttributes();
1244 XMLSize_t attributeCount = attributes->getLength();
1245 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1246 ++attribute_index)
1247 {
1248 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1249
1250 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1251 {
1252 continue;
1253 }
1254
1255 const xercesc::DOMAttr* const attribute =
1256 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1257 if(attribute == nullptr)
1258 {
1259 G4Exception("G4GDMLReadParamvol::ParameterisedRead()", "InvalidRead",
1260 FatalException, "No attribute found!");
1261 return;
1262 }
1263 const G4String attName = Transcode(attribute->getName());
1264 const G4String attValue = Transcode(attribute->getValue());
1265
1266 if(attName == "number")
1267 {
1268 eval.Evaluate(attValue);
1269 }
1270 }
1271 ParametersRead(child);
1272 }
1273 else
1274 {
1275 if(tag == "loop")
1276 {
1277 LoopRead(child, &G4GDMLRead::Paramvol_contentRead);
1278 }
1279 }
1280 }
1281}
G4GDMLReadParamvol::ParametersRead
void ParametersRead(const xercesc::DOMElement *const)
Definition G4GDMLReadParamvol.cc:1106
G4GDMLRead::Paramvol_contentRead
virtual void Paramvol_contentRead(const xercesc::DOMElement *const)=0
G4GDMLRead::LoopRead
void LoopRead(const xercesc::DOMElement *const, void(G4GDMLRead::*)(const xercesc::DOMElement *const))
Definition G4GDMLRead.cc:196

Referenced by Paramvol_contentRead().

◆ ParametersRead()

void G4GDMLReadParamvol::ParametersRead ( const xercesc::DOMElement * const element)
protected

Definition at line 1106 of file G4GDMLReadParamvol.cc.

1108{
1109 G4ThreeVector rotation(0.0, 0.0, 0.0);
1110 G4ThreeVector position(0.0, 0.0, 0.0);
1111
1112 G4GDMLParameterisation::PARAMETER parameter;
1113
1114 for(xercesc::DOMNode* iter = element->getFirstChild(); iter != nullptr;
1115 iter = iter->getNextSibling())
1116 {
1117 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
1118 {
1119 continue;
1120 }
1121
1122 const xercesc::DOMElement* const child =
1123 dynamic_cast<xercesc::DOMElement*>(iter);
1124 if(child == nullptr)
1125 {
1126 G4Exception("G4GDMLReadParamvol::ParametersRead()", "InvalidRead",
1127 FatalException, "No child found!");
1128 return;
1129 }
1130 const G4String tag = Transcode(child->getTagName());
1131 if(tag == "rotation")
1132 {
1133 VectorRead(child, rotation);
1134 }
1135 else if(tag == "position")
1136 {
1137 VectorRead(child, position);
1138 }
1139 else if(tag == "positionref")
1140 {
1141 position = GetPosition(GenerateName(RefRead(child)));
1142 }
1143 else if(tag == "rotationref")
1144 {
1145 rotation = GetRotation(GenerateName(RefRead(child)));
1146 }
1147 else if(tag == "box_dimensions")
1148 {
1149 Box_dimensionsRead(child, parameter);
1150 }
1151 else if(tag == "trd_dimensions")
1152 {
1153 Trd_dimensionsRead(child, parameter);
1154 }
1155 else if(tag == "trap_dimensions")
1156 {
1157 Trap_dimensionsRead(child, parameter);
1158 }
1159 else if(tag == "tube_dimensions")
1160 {
1161 Tube_dimensionsRead(child, parameter);
1162 }
1163 else if(tag == "cone_dimensions")
1164 {
1165 Cone_dimensionsRead(child, parameter);
1166 }
1167 else if(tag == "sphere_dimensions")
1168 {
1169 Sphere_dimensionsRead(child, parameter);
1170 }
1171 else if(tag == "orb_dimensions")
1172 {
1173 Orb_dimensionsRead(child, parameter);
1174 }
1175 else if(tag == "torus_dimensions")
1176 {
1177 Torus_dimensionsRead(child, parameter);
1178 }
1179 else if(tag == "ellipsoid_dimensions")
1180 {
1181 Ellipsoid_dimensionsRead(child, parameter);
1182 }
1183 else if(tag == "para_dimensions")
1184 {
1185 Para_dimensionsRead(child, parameter);
1186 }
1187 else if(tag == "polycone_dimensions")
1188 {
1189 Polycone_dimensionsRead(child, parameter);
1190 }
1191 else if(tag == "polyhedra_dimensions")
1192 {
1193 Polyhedra_dimensionsRead(child, parameter);
1194 }
1195 else if(tag == "hype_dimensions")
1196 {
1197 Hype_dimensionsRead(child, parameter);
1198 }
1199 else
1200 {
1201 G4String error_msg = "Unknown tag in parameters: " + tag;
1202 G4Exception("G4GDMLReadParamvol::ParametersRead()", "ReadError",
1203 FatalException, error_msg);
1204 }
1205 }
1206
1207 parameter.pRot = new G4RotationMatrix();
1208
1209 parameter.pRot->rotateX(rotation.x());
1210 parameter.pRot->rotateY(rotation.y());
1211 parameter.pRot->rotateZ(rotation.z());
1212
1213 parameter.position = position;
1214
1215 parameterisation->AddParameter(parameter);
1216}
G4RotationMatrix
CLHEP::HepRotation G4RotationMatrix
Definition G4RotationMatrix.hh:37
CLHEP::HepRotation::rotateX
HepRotation & rotateX(double delta)
Definition Rotation.cc:61
CLHEP::HepRotation::rotateZ
HepRotation & rotateZ(double delta)
Definition Rotation.cc:87
CLHEP::HepRotation::rotateY
HepRotation & rotateY(double delta)
Definition Rotation.cc:74
G4GDMLParameterisation::AddParameter
void AddParameter(const PARAMETER &)
Definition G4GDMLParameterisation.cc:42
G4GDMLReadDefine::VectorRead
void VectorRead(const xercesc::DOMElement *const, G4ThreeVector &)
Definition G4GDMLReadDefine.cc:662
G4GDMLReadDefine::GetPosition
G4ThreeVector GetPosition(const G4String &)
Definition G4GDMLReadDefine.cc:782
G4GDMLReadDefine::RefRead
G4String RefRead(const xercesc::DOMElement *const)
Definition G4GDMLReadDefine.cc:714
G4GDMLReadDefine::GetRotation
G4ThreeVector GetRotation(const G4String &)
Definition G4GDMLReadDefine.cc:794
G4GDMLReadParamvol::Ellipsoid_dimensionsRead
void Ellipsoid_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:667
G4GDMLReadParamvol::Cone_dimensionsRead
void Cone_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:366
G4GDMLReadParamvol::Box_dimensionsRead
void Box_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:50
G4GDMLReadParamvol::Para_dimensionsRead
void Para_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:735
G4GDMLReadParamvol::Torus_dimensionsRead
void Torus_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:588
G4GDMLReadParamvol::parameterisation
G4GDMLParameterisation * parameterisation
Definition G4GDMLReadParamvol.hh:87
G4GDMLReadParamvol::Sphere_dimensionsRead
void Sphere_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:455
G4GDMLReadParamvol::Hype_dimensionsRead
void Hype_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:819
G4GDMLReadParamvol::Trap_dimensionsRead
void Trap_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:178
G4GDMLReadParamvol::Orb_dimensionsRead
void Orb_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:539
G4GDMLReadParamvol::Trd_dimensionsRead
void Trd_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:109
G4GDMLReadParamvol::Polyhedra_dimensionsRead
void Polyhedra_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:1000
G4GDMLReadParamvol::Tube_dimensionsRead
void Tube_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:287
G4GDMLReadParamvol::Polycone_dimensionsRead
void Polycone_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition G4GDMLReadParamvol.cc:898
G4GDMLRead::GenerateName
G4String GenerateName(const G4String &name, G4bool strip=false)
Definition G4GDMLRead.cc:72

Referenced by ParameterisedRead().

◆ Paramvol_contentRead()

void G4GDMLReadParamvol::Paramvol_contentRead ( const xercesc::DOMElement * const element)
virtual

Implements G4GDMLRead.

Definition at line 1284 of file G4GDMLReadParamvol.cc.

1286{
1287 for(xercesc::DOMNode* iter = element->getFirstChild(); iter != nullptr;
1288 iter = iter->getNextSibling())
1289 {
1290 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
1291 {
1292 continue;
1293 }
1294
1295 const xercesc::DOMElement* const child =
1296 dynamic_cast<xercesc::DOMElement*>(iter);
1297 if(child == nullptr)
1298 {
1299 G4Exception("G4GDMLReadParamvol::Paramvol_contentRead()", "InvalidRead",
1300 FatalException, "No child found!");
1301 return;
1302 }
1303 const G4String tag = Transcode(child->getTagName());
1304 if(tag == "parameterised_position_size")
1305 {
1306 ParameterisedRead(child);
1307 }
1308 else if(tag == "loop")
1309 {
1310 LoopRead(child, &G4GDMLRead::Paramvol_contentRead);
1311 }
1312 }
1313}
G4GDMLReadParamvol::ParameterisedRead
void ParameterisedRead(const xercesc::DOMElement *const)
Definition G4GDMLReadParamvol.cc:1219

Referenced by ParamvolRead().

◆ ParamvolRead()

void G4GDMLReadParamvol::ParamvolRead ( const xercesc::DOMElement * const element,
G4LogicalVolume * mother )
virtual

Definition at line 1316 of file G4GDMLReadParamvol.cc.

1318{
1319 G4String volumeref;
1320
1321 parameterisation = new G4GDMLParameterisation();
1322 for(xercesc::DOMNode* iter = element->getFirstChild(); iter != nullptr;
1323 iter = iter->getNextSibling())
1324 {
1325 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
1326 {
1327 continue;
1328 }
1329
1330 const xercesc::DOMElement* const child =
1331 dynamic_cast<xercesc::DOMElement*>(iter);
1332 if(child == nullptr)
1333 {
1334 G4Exception("G4GDMLReadParamvol::ParamvolRead()", "InvalidRead",
1335 FatalException, "No child found!");
1336 return;
1337 }
1338 const G4String tag = Transcode(child->getTagName());
1339
1340 if(tag == "volumeref")
1341 {
1342 volumeref = RefRead(child);
1343 }
1344 }
1345
1346 Paramvol_contentRead(element);
1347
1348 G4LogicalVolume* logvol = GetVolume(GenerateName(volumeref));
1349
1350 if(parameterisation->GetSize() == 0)
1351 {
1352 G4Exception("G4GDMLReadParamvol::ParamvolRead()", "ReadError",
1353 FatalException,
1354 "No parameters are defined in parameterised volume!");
1355 }
1356 G4String pv_name = logvol->GetName() + "_param";
1357 new G4PVParameterised(pv_name, logvol, mother, kUndefined,
1358 parameterisation->GetSize(), parameterisation, check);
1359}
G4GDMLReadParamvol::Paramvol_contentRead
virtual void Paramvol_contentRead(const xercesc::DOMElement *const)
Definition G4GDMLReadParamvol.cc:1284
G4GDMLRead::check
G4bool check
Definition G4GDMLRead.hh:163
G4GDMLRead::GetVolume
virtual G4LogicalVolume * GetVolume(const G4String &) const =0
G4LogicalVolume::GetName
const G4String & GetName() const
kUndefined
@ kUndefined
Definition geomdefs.hh:61

Referenced by G4GDMLReadStructure::Volume_contentRead().

◆ Polycone_dimensionsRead()

void G4GDMLReadParamvol::Polycone_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 898 of file G4GDMLReadParamvol.cc.

901{
902 G4double lunit = 1.0;
903 G4double aunit = 1.0;
904
905 std::vector<zplaneType> zplaneList;
906
907 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
908 XMLSize_t attributeCount = attributes->getLength();
909
910 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
911 ++attribute_index)
912 {
913 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
914
915 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
916 {
917 continue;
918 }
919
920 const xercesc::DOMAttr* const attribute =
921 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
922 if(attribute == nullptr)
923 {
924 G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
925 "InvalidRead", FatalException, "No attribute found!");
926 return;
927 }
928 const G4String attName = Transcode(attribute->getName());
929 const G4String attValue = Transcode(attribute->getValue());
930
931 if(attName == "lunit")
932 {
933 lunit = G4UnitDefinition::GetValueOf(attValue);
934 if(G4UnitDefinition::GetCategory(attValue) != "Length")
935 {
936 G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
937 "InvalidRead", FatalException, "Invalid unit for length!");
938 }
939 }
940 else if(attName == "aunit")
941 {
942 aunit = G4UnitDefinition::GetValueOf(attValue);
943 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
944 {
945 G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
946 "InvalidRead", FatalException, "Invalid unit for angle!");
947 }
948 }
949 else if(attName == "startPhi")
950 {
951 parameter.dimension[0] = eval.Evaluate(attValue);
952 }
953 else if(attName == "openPhi")
954 {
955 parameter.dimension[1] = eval.Evaluate(attValue);
956 }
957 else if(attName == "numRZ")
958 {
959 parameter.dimension[2] = eval.Evaluate(attValue);
960 }
961 }
962
963 parameter.dimension[0] *= aunit;
964 parameter.dimension[1] *= aunit;
965
966 for(xercesc::DOMNode* iter = element->getFirstChild(); iter != nullptr;
967 iter = iter->getNextSibling())
968 {
969 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
970 {
971 continue;
972 }
973
974 const xercesc::DOMElement* const child =
975 dynamic_cast<xercesc::DOMElement*>(iter);
976 if(child == nullptr)
977 {
978 G4Exception("G4GDMLReadParamVol::Polycone_dimensionsRead()",
979 "InvalidRead", FatalException, "No child found!");
980 return;
981 }
982 const G4String tag = Transcode(child->getTagName());
983
984 if(tag == "zplane")
985 {
986 zplaneList.push_back(ZplaneRead(child));
987 }
988 }
989
990 std::size_t numZPlanes = zplaneList.size();
991 for(std::size_t i = 0; i < numZPlanes; ++i)
992 {
993 parameter.dimension[3 + i * 3] = zplaneList[i].rmin * lunit;
994 parameter.dimension[4 + i * 3] = zplaneList[i].rmax * lunit;
995 parameter.dimension[5 + i * 3] = zplaneList[i].z * lunit;
996 }
997}
G4GDMLReadSolids::ZplaneRead
zplaneType ZplaneRead(const xercesc::DOMElement *const)
Definition G4GDMLReadSolids.cc:3395

Referenced by ParametersRead().

◆ Polyhedra_dimensionsRead()

void G4GDMLReadParamvol::Polyhedra_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 1000 of file G4GDMLReadParamvol.cc.

1003{
1004 G4double lunit = 1.0;
1005 G4double aunit = 1.0;
1006
1007 std::vector<zplaneType> zplaneList;
1008
1009 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
1010 XMLSize_t attributeCount = attributes->getLength();
1011
1012 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1013 ++attribute_index)
1014 {
1015 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1016
1017 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1018 {
1019 continue;
1020 }
1021
1022 const xercesc::DOMAttr* const attribute =
1023 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1024 if(attribute == nullptr)
1025 {
1026 G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
1027 "InvalidRead", FatalException, "No attribute found!");
1028 return;
1029 }
1030 const G4String attName = Transcode(attribute->getName());
1031 const G4String attValue = Transcode(attribute->getValue());
1032
1033 if(attName == "lunit")
1034 {
1035 lunit = G4UnitDefinition::GetValueOf(attValue);
1036 if(G4UnitDefinition::GetCategory(attValue) != "Length")
1037 {
1038 G4Exception("G4GDMLReadParamvol::Polyhedra_dimensionsRead()",
1039 "InvalidRead", FatalException, "Invalid unit for length!");
1040 }
1041 }
1042 else if(attName == "aunit")
1043 {
1044 aunit = G4UnitDefinition::GetValueOf(attValue);
1045 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
1046 {
1047 G4Exception("G4GDMLReadParamvol::Polyhedra_dimensionsRead()",
1048 "InvalidRead", FatalException, "Invalid unit for angle!");
1049 }
1050 }
1051 else if(attName == "startPhi")
1052 {
1053 parameter.dimension[0] = eval.Evaluate(attValue);
1054 }
1055 else if(attName == "openPhi")
1056 {
1057 parameter.dimension[1] = eval.Evaluate(attValue);
1058 }
1059 else if(attName == "numRZ")
1060 {
1061 parameter.dimension[2] = eval.Evaluate(attValue);
1062 }
1063 else if(attName == "numSide")
1064 {
1065 parameter.dimension[3] = eval.Evaluate(attValue);
1066 }
1067 }
1068
1069 parameter.dimension[0] *= aunit;
1070 parameter.dimension[1] *= aunit;
1071
1072 for(auto iter = element->getFirstChild(); iter != nullptr;
1073 iter = iter->getNextSibling())
1074 {
1075 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
1076 {
1077 continue;
1078 }
1079
1080 const xercesc::DOMElement* const child =
1081 dynamic_cast<xercesc::DOMElement*>(iter);
1082 if(child == nullptr)
1083 {
1084 G4Exception("G4GDMLReadParamvo::PolyhedraRead()", "InvalidRead",
1085 FatalException, "No child found!");
1086 return;
1087 }
1088 const G4String tag = Transcode(child->getTagName());
1089
1090 if(tag == "zplane")
1091 {
1092 zplaneList.push_back(ZplaneRead(child));
1093 }
1094 }
1095
1096 std::size_t numZPlanes = zplaneList.size();
1097 for(std::size_t i = 0; i < numZPlanes; ++i)
1098 {
1099 parameter.dimension[4 + i * 3] = zplaneList[i].rmin * lunit;
1100 parameter.dimension[5 + i * 3] = zplaneList[i].rmax * lunit;
1101 parameter.dimension[6 + i * 3] = zplaneList[i].z * lunit;
1102 }
1103}

Referenced by ParametersRead().

◆ Sphere_dimensionsRead()

void G4GDMLReadParamvol::Sphere_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 455 of file G4GDMLReadParamvol.cc.

458{
459 G4double lunit = 1.0;
460 G4double aunit = 1.0;
461
462 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
463 XMLSize_t attributeCount = attributes->getLength();
464
465 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
466 ++attribute_index)
467 {
468 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
469
470 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
471 {
472 continue;
473 }
474
475 const xercesc::DOMAttr* const attribute =
476 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
477 if(attribute == nullptr)
478 {
479 G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()", "InvalidRead",
480 FatalException, "No attribute found!");
481 return;
482 }
483 const G4String attName = Transcode(attribute->getName());
484 const G4String attValue = Transcode(attribute->getValue());
485
486 if(attName == "lunit")
487 {
488 lunit = G4UnitDefinition::GetValueOf(attValue);
489 if(G4UnitDefinition::GetCategory(attValue) != "Length")
490 {
491 G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()",
492 "InvalidRead", FatalException, "Invalid unit for length!");
493 }
494 }
495 else if(attName == "aunit")
496 {
497 aunit = G4UnitDefinition::GetValueOf(attValue);
498 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
499 {
500 G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()",
501 "InvalidRead", FatalException, "Invalid unit for angle!");
502 }
503 }
504 else if(attName == "rmin")
505 {
506 parameter.dimension[0] = eval.Evaluate(attValue);
507 }
508 else if(attName == "rmax")
509 {
510 parameter.dimension[1] = eval.Evaluate(attValue);
511 }
512 else if(attName == "startphi")
513 {
514 parameter.dimension[2] = eval.Evaluate(attValue);
515 }
516 else if(attName == "deltaphi")
517 {
518 parameter.dimension[3] = eval.Evaluate(attValue);
519 }
520 else if(attName == "starttheta")
521 {
522 parameter.dimension[4] = eval.Evaluate(attValue);
523 }
524 else if(attName == "deltatheta")
525 {
526 parameter.dimension[5] = eval.Evaluate(attValue);
527 }
528 }
529
530 parameter.dimension[0] *= lunit;
531 parameter.dimension[1] *= lunit;
532 parameter.dimension[2] *= aunit;
533 parameter.dimension[3] *= aunit;
534 parameter.dimension[4] *= aunit;
535 parameter.dimension[5] *= aunit;
536}

Referenced by ParametersRead().

◆ Torus_dimensionsRead()

void G4GDMLReadParamvol::Torus_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 588 of file G4GDMLReadParamvol.cc.

591{
592 G4double lunit = 1.0;
593 G4double aunit = 1.0;
594
595 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
596 XMLSize_t attributeCount = attributes->getLength();
597
598 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
599 ++attribute_index)
600 {
601 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
602
603 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
604 {
605 continue;
606 }
607
608 const xercesc::DOMAttr* const attribute =
609 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
610 if(attribute == nullptr)
611 {
612 G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
613 FatalException, "No attribute found!");
614 return;
615 }
616 const G4String attName = Transcode(attribute->getName());
617 const G4String attValue = Transcode(attribute->getValue());
618
619 if(attName == "lunit")
620 {
621 lunit = G4UnitDefinition::GetValueOf(attValue);
622 if(G4UnitDefinition::GetCategory(attValue) != "Length")
623 {
624 G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
625 FatalException, "Invalid unit for length!");
626 }
627 }
628 else if(attName == "aunit")
629 {
630 aunit = G4UnitDefinition::GetValueOf(attValue);
631 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
632 {
633 G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
634 FatalException, "Invalid unit for angle!");
635 }
636 }
637 else if(attName == "rmin")
638 {
639 parameter.dimension[0] = eval.Evaluate(attValue);
640 }
641 else if(attName == "rmax")
642 {
643 parameter.dimension[1] = eval.Evaluate(attValue);
644 }
645 else if(attName == "rtor")
646 {
647 parameter.dimension[2] = eval.Evaluate(attValue);
648 }
649 else if(attName == "startphi")
650 {
651 parameter.dimension[3] = eval.Evaluate(attValue);
652 }
653 else if(attName == "deltaphi")
654 {
655 parameter.dimension[4] = eval.Evaluate(attValue);
656 }
657 }
658
659 parameter.dimension[0] *= lunit;
660 parameter.dimension[1] *= lunit;
661 parameter.dimension[2] *= lunit;
662 parameter.dimension[3] *= aunit;
663 parameter.dimension[4] *= aunit;
664}

Referenced by ParametersRead().

◆ Trap_dimensionsRead()

void G4GDMLReadParamvol::Trap_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 178 of file G4GDMLReadParamvol.cc.

181{
182 G4double lunit = 1.0;
183 G4double aunit = 1.0;
184
185 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
186 XMLSize_t attributeCount = attributes->getLength();
187
188 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
189 ++attribute_index)
190 {
191 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
192
193 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
194 {
195 continue;
196 }
197
198 const xercesc::DOMAttr* const attribute =
199 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
200 if(attribute == nullptr)
201 {
202 G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
203 FatalException, "No attribute found!");
204 return;
205 }
206 const G4String attName = Transcode(attribute->getName());
207 const G4String attValue = Transcode(attribute->getValue());
208
209 if(attName == "lunit")
210 {
211 lunit = G4UnitDefinition::GetValueOf(attValue);
212 if(G4UnitDefinition::GetCategory(attValue) != "Length")
213 {
214 G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
215 FatalException, "Invalid unit for length!");
216 }
217 }
218 else if(attName == "aunit")
219 {
220 aunit = G4UnitDefinition::GetValueOf(attValue);
221 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
222 {
223 G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
224 FatalException, "Invalid unit for angle!");
225 }
226 }
227 else if(attName == "z")
228 {
229 parameter.dimension[0] = eval.Evaluate(attValue);
230 }
231 else if(attName == "theta")
232 {
233 parameter.dimension[1] = eval.Evaluate(attValue);
234 }
235 else if(attName == "phi")
236 {
237 parameter.dimension[2] = eval.Evaluate(attValue);
238 }
239 else if(attName == "y1")
240 {
241 parameter.dimension[3] = eval.Evaluate(attValue);
242 }
243 else if(attName == "x1")
244 {
245 parameter.dimension[4] = eval.Evaluate(attValue);
246 }
247 else if(attName == "x2")
248 {
249 parameter.dimension[5] = eval.Evaluate(attValue);
250 }
251 else if(attName == "alpha1")
252 {
253 parameter.dimension[6] = eval.Evaluate(attValue);
254 }
255 else if(attName == "y2")
256 {
257 parameter.dimension[7] = eval.Evaluate(attValue);
258 }
259 else if(attName == "x3")
260 {
261 parameter.dimension[8] = eval.Evaluate(attValue);
262 }
263 else if(attName == "x4")
264 {
265 parameter.dimension[9] = eval.Evaluate(attValue);
266 }
267 else if(attName == "alpha2")
268 {
269 parameter.dimension[10] = eval.Evaluate(attValue);
270 }
271 }
272
273 parameter.dimension[0] *= 0.5 * lunit;
274 parameter.dimension[1] *= aunit;
275 parameter.dimension[2] *= aunit;
276 parameter.dimension[3] *= 0.5 * lunit;
277 parameter.dimension[4] *= 0.5 * lunit;
278 parameter.dimension[5] *= 0.5 * lunit;
279 parameter.dimension[6] *= aunit;
280 parameter.dimension[7] *= 0.5 * lunit;
281 parameter.dimension[8] *= 0.5 * lunit;
282 parameter.dimension[9] *= 0.5 * lunit;
283 parameter.dimension[10] *= aunit;
284}

Referenced by ParametersRead().

◆ Trd_dimensionsRead()

void G4GDMLReadParamvol::Trd_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 109 of file G4GDMLReadParamvol.cc.

112{
113 G4double lunit = 1.0;
114
115 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
116 XMLSize_t attributeCount = attributes->getLength();
117
118 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
119 ++attribute_index)
120 {
121 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
122
123 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
124 {
125 continue;
126 }
127
128 const xercesc::DOMAttr* const attribute =
129 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
130 if(attribute == nullptr)
131 {
132 G4Exception("G4GDMLReadParamvol::Trd_dimensionsRead()", "InvalidRead",
133 FatalException, "No attribute found!");
134 return;
135 }
136 const G4String attName = Transcode(attribute->getName());
137 const G4String attValue = Transcode(attribute->getValue());
138
139 if(attName == "lunit")
140 {
141 lunit = G4UnitDefinition::GetValueOf(attValue);
142 if(G4UnitDefinition::GetCategory(attValue) != "Length")
143 {
144 G4Exception("G4GDMLReadParamvol::Trd_dimensionsRead()", "InvalidRead",
145 FatalException, "Invalid unit for length!");
146 }
147 }
148 else if(attName == "x1")
149 {
150 parameter.dimension[0] = eval.Evaluate(attValue);
151 }
152 else if(attName == "x2")
153 {
154 parameter.dimension[1] = eval.Evaluate(attValue);
155 }
156 else if(attName == "y1")
157 {
158 parameter.dimension[2] = eval.Evaluate(attValue);
159 }
160 else if(attName == "y2")
161 {
162 parameter.dimension[3] = eval.Evaluate(attValue);
163 }
164 else if(attName == "z")
165 {
166 parameter.dimension[4] = eval.Evaluate(attValue);
167 }
168 }
169
170 parameter.dimension[0] *= 0.5 * lunit;
171 parameter.dimension[1] *= 0.5 * lunit;
172 parameter.dimension[2] *= 0.5 * lunit;
173 parameter.dimension[3] *= 0.5 * lunit;
174 parameter.dimension[4] *= 0.5 * lunit;
175}

Referenced by ParametersRead().

◆ Tube_dimensionsRead()

void G4GDMLReadParamvol::Tube_dimensionsRead ( const xercesc::DOMElement * const element,
G4GDMLParameterisation::PARAMETER & parameter )
protected

Definition at line 287 of file G4GDMLReadParamvol.cc.

290{
291 G4double lunit = 1.0;
292 G4double aunit = 1.0;
293
294 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
295 XMLSize_t attributeCount = attributes->getLength();
296
297 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
298 ++attribute_index)
299 {
300 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
301
302 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
303 {
304 continue;
305 }
306
307 const xercesc::DOMAttr* const attribute =
308 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
309 if(attribute == nullptr)
310 {
311 G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
312 FatalException, "No attribute found!");
313 return;
314 }
315 const G4String attName = Transcode(attribute->getName());
316 const G4String attValue = Transcode(attribute->getValue());
317
318 if(attName == "lunit")
319 {
320 lunit = G4UnitDefinition::GetValueOf(attValue);
321 if(G4UnitDefinition::GetCategory(attValue) != "Length")
322 {
323 G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
324 FatalException, "Invalid unit for length!");
325 }
326 }
327 else if(attName == "aunit")
328 {
329 aunit = G4UnitDefinition::GetValueOf(attValue);
330 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
331 {
332 G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
333 FatalException, "Invalid unit for angle!");
334 }
335 }
336 else if(attName == "InR")
337 {
338 parameter.dimension[0] = eval.Evaluate(attValue);
339 }
340 else if(attName == "OutR")
341 {
342 parameter.dimension[1] = eval.Evaluate(attValue);
343 }
344 else if(attName == "hz")
345 {
346 parameter.dimension[2] = eval.Evaluate(attValue);
347 }
348 else if(attName == "StartPhi")
349 {
350 parameter.dimension[3] = eval.Evaluate(attValue);
351 }
352 else if(attName == "DeltaPhi")
353 {
354 parameter.dimension[4] = eval.Evaluate(attValue);
355 }
356 }
357
358 parameter.dimension[0] *= lunit;
359 parameter.dimension[1] *= lunit;
360 parameter.dimension[2] *= 0.5 * lunit;
361 parameter.dimension[3] *= aunit;
362 parameter.dimension[4] *= aunit;
363}

Referenced by ParametersRead().

Member Data Documentation

◆ parameterisation

G4GDMLParameterisation* G4GDMLReadParamvol::parameterisation = nullptr
protected

Definition at line 87 of file G4GDMLReadParamvol.hh.

Referenced by ParametersRead(), and ParamvolRead().

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