#include <G4GDMLReadDefine.hh>

Inheritance diagram for G4GDMLReadDefine:

Public Member Functions
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)

Public Member Functions inherited from G4GDMLRead
virtual void	DefineRead (const xercesc::DOMElement *const)=0

virtual void	MaterialsRead (const xercesc::DOMElement *const)=0

virtual void	SetupRead (const xercesc::DOMElement *const)=0

virtual void	SolidsRead (const xercesc::DOMElement *const)=0

virtual void	Paramvol_contentRead (const xercesc::DOMElement *const)=0

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 G4LogicalVolume *	GetVolume (const G4String &) const =0

virtual G4String	GetSetup (const G4String &)=0

void	Read (const G4String &, G4bool validation, G4bool isModule, G4bool strip=true)

void	StripNames () const

void	OverlapCheck (G4bool)

Protected Member Functions
	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	StripName (G4String &) const

void	GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)

void	LoopRead (const xercesc::DOMElement const, void(G4GDMLRead::)(const xercesc::DOMElement *const))

Protected Attributes
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

G4bool	check

Detailed Description

Definition at line 69 of file G4GDMLReadDefine.hh.

Constructor & Destructor Documentation

◆ G4GDMLReadDefine()

G4GDMLReadDefine::G4GDMLReadDefine ( )

protected

Definition at line 123 of file G4GDMLReadDefine.cc.

                                   : G4GDMLRead()
{
}

◆ ~G4GDMLReadDefine()

G4GDMLReadDefine::~G4GDMLReadDefine ( )

protectedvirtual

Definition at line 127 of file G4GDMLReadDefine.cc.

128{

129}

Member Function Documentation

◆ ConstantRead()

void G4GDMLReadDefine::ConstantRead ( const xercesc::DOMElement * const constantElement )

protected

Definition at line 144 of file G4GDMLReadDefine.cc.

{
   G4String name  = "";
   G4double value = 0.0;
 
   const xercesc::DOMNamedNodeMap* const attributes
         = constantElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);
 
      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::ConstantRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name")  { name = attValue; }  else
      if (attName=="value") { value = eval.Evaluate(attValue); }
   }
 
   eval.DefineConstant(name,value);
}

Referenced by DefineRead().

◆ DefineRead()

void G4GDMLReadDefine::DefineRead ( const xercesc::DOMElement * const defineElement )

virtual

Implements G4GDMLRead.

Definition at line 457 of file G4GDMLReadDefine.cc.

{
   G4cout << "G4GDML: Reading definitions..." << G4endl;
 
   for (xercesc::DOMNode* iter = defineElement->getFirstChild();
        iter != 0;iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("G4GDMLRead::DefineRead()", "InvalidRead",
                    FatalException, "No child found!");
        return;
      }
      const G4String tag = Transcode(child->getTagName());
 
      if (tag=="constant") { ConstantRead(child); } else
      if (tag=="matrix")   { MatrixRead(child); }   else
      if (tag=="position") { PositionRead(child); } else
      if (tag=="rotation") { RotationRead(child); } else
      if (tag=="scale")    { ScaleRead(child); }    else
      if (tag=="variable") { VariableRead(child); } else
      if (tag=="quantity") { QuantityRead(child); } else
      if (tag=="expression") { ExpressionRead(child); }
      else
      {
        G4String error_msg = "Unknown tag in define: "+tag;
        G4Exception("G4GDMLReadDefine::defineRead()", "ReadError",
                    FatalException, error_msg);
      }
   }
}

Referenced by G4GDMLReadMaterials::MaterialsRead(), and G4GDMLReadSolids::SolidsRead().

◆ ExpressionRead()

void G4GDMLReadDefine::ExpressionRead ( const xercesc::DOMElement * const expElement )

protected

Definition at line 179 of file G4GDMLReadDefine.cc.

{
   G4String name  = "";
   G4double value = 0.0;
 
   const xercesc::DOMNamedNodeMap* const attributes
         = expElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);
 
      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::ExpressionRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name")  { name = attValue; }
   }
 
   const G4String expValue = Transcode(expElement->getTextContent());
   value = eval.Evaluate(expValue);
   eval.DefineConstant(name,value);
}

Referenced by DefineRead().

◆ GetConstant()

G4double G4GDMLReadDefine::GetConstant ( const G4String & ref )

Definition at line 568 of file G4GDMLReadDefine.cc.

{
   return eval.GetConstant(ref);
}

◆ GetMatrix()

G4GDMLMatrix G4GDMLReadDefine::GetMatrix ( const G4String & ref )

Definition at line 622 of file G4GDMLReadDefine.cc.

{
   if (matrixMap.find(ref) == matrixMap.end())
   {
     G4String error_msg = "Matrix '"+ref+"' was not found!";
     G4Exception("G4GDMLReadDefine::getMatrix()", "ReadError",
                 FatalException, error_msg);
   }
   return matrixMap[ref];
}

Referenced by G4GDMLReadMaterials::PropertyRead().

◆ GetPosition()

G4ThreeVector G4GDMLReadDefine::GetPosition ( const G4String & ref )

Definition at line 589 of file G4GDMLReadDefine.cc.

{
   if (positionMap.find(ref) == positionMap.end())
   {
     G4String error_msg = "Position '"+ref+"' was not found!";
     G4Exception("G4GDMLReadDefine::getPosition()", "ReadError",
                 FatalException, error_msg);
   }
   return positionMap[ref];
}

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadParamvol::ParametersRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadSolids::QuadrangularRead(), G4GDMLReadStructure::ReplicaRead(), G4GDMLReadSolids::TetRead(), and G4GDMLReadSolids::TriangularRead().

◆ GetQuantity()

G4double G4GDMLReadDefine::GetQuantity ( const G4String & ref )

Definition at line 578 of file G4GDMLReadDefine.cc.

{
   if (quantityMap.find(ref) == quantityMap.end())
   {
     G4String error_msg = "Quantity '"+ref+"' was not found!";
     G4Exception("G4GDMLReadDefine::getQuantity()", "ReadError",
                 FatalException, error_msg);
   }
   return quantityMap[ref];
}

Referenced by G4GDMLReadMaterials::MaterialRead().

◆ GetRotation()

G4ThreeVector G4GDMLReadDefine::GetRotation ( const G4String & ref )

Definition at line 600 of file G4GDMLReadDefine.cc.

{
   if (rotationMap.find(ref) == rotationMap.end())
   {
     G4String error_msg = "Rotation '"+ref+"' was not found!";
     G4Exception("G4GDMLReadDefine::getRotation()", "ReadError",
                 FatalException, error_msg);
   }
   return rotationMap[ref];
}

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadParamvol::ParametersRead(), G4GDMLReadStructure::PhysvolRead(), and G4GDMLReadStructure::ReplicaRead().

◆ GetRotationMatrix()

G4RotationMatrix G4GDMLReadDefine::GetRotationMatrix ( const G4ThreeVector & angles )

protected

Definition at line 132 of file G4GDMLReadDefine.cc.

{
   G4RotationMatrix rot;
 
   rot.rotateX(angles.x());
   rot.rotateY(angles.y());
   rot.rotateZ(angles.z());
 
   return rot;
}

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadStructure::PhysvolRead(), and G4GDMLReadSolids::ReflectedSolidRead().

◆ GetScale()

G4ThreeVector G4GDMLReadDefine::GetScale ( const G4String & ref )

Definition at line 611 of file G4GDMLReadDefine.cc.

{
   if (scaleMap.find(ref) == scaleMap.end())
   {
     G4String error_msg = "Scale '"+ref+"' was not found!";
     G4Exception("G4GDMLReadDefine::getScale()", "ReadError",
                 FatalException, error_msg);
   }
   return scaleMap[ref];
}

Referenced by G4GDMLReadStructure::PhysvolRead().

◆ GetVariable()

G4double G4GDMLReadDefine::GetVariable ( const G4String & ref )

Definition at line 573 of file G4GDMLReadDefine.cc.

{
   return eval.GetVariable(ref);
}

◆ IsValidID()

G4bool G4GDMLReadDefine::IsValidID ( const G4String & ref ) const

Definition at line 563 of file G4GDMLReadDefine.cc.

{
   return eval.IsVariable(ref);
}

◆ MatrixRead()

void G4GDMLReadDefine::MatrixRead ( const xercesc::DOMElement * const matrixElement )

protected

Definition at line 215 of file G4GDMLReadDefine.cc.

{
   G4String name = "";
   G4int coldim  = 0;
   G4String values = "";
 
   const xercesc::DOMNamedNodeMap* const attributes
         = matrixElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);
 
      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::MatrixRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name")   { name  = GenerateName(attValue); } else
      if (attName=="coldim") { coldim = eval.EvaluateInteger(attValue); } else
      if (attName=="values") { values = attValue; }
   }
 
   std::stringstream MatrixValueStream(values);
   std::vector<G4double> valueList;
 
   while (!MatrixValueStream.eof())
   {
      G4String MatrixValue;
      MatrixValueStream >> MatrixValue;
      valueList.push_back(eval.Evaluate(MatrixValue));
   }
 
   eval.DefineMatrix(name,coldim,valueList);
 
   G4GDMLMatrix matrix(valueList.size()/coldim,coldim);
 
   for (size_t i=0;i<valueList.size();i++)
   {
      matrix.Set(i/coldim,i%coldim,valueList[i]);
   }
 
   matrixMap[name] = matrix;
}

Referenced by DefineRead().

◆ PositionRead()

void G4GDMLReadDefine::PositionRead ( const xercesc::DOMElement * const positionElement )

protected

Definition at line 271 of file G4GDMLReadDefine.cc.

{
   G4String name = "";
   G4double unit = 1.0;
   G4ThreeVector position(0.,0.,0.);
 
   const xercesc::DOMNamedNodeMap* const attributes
         = positionElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);
 
      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::PositionRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name") { name = GenerateName(attValue); }  else
      if (attName=="unit") { unit = eval.Evaluate(attValue); } else
      if (attName=="x") { position.setX(eval.Evaluate(attValue)); } else
      if (attName=="y") { position.setY(eval.Evaluate(attValue)); } else
      if (attName=="z") { position.setZ(eval.Evaluate(attValue)); }
   }
 
   positionMap[name] = position*unit;
}

Referenced by DefineRead().

◆ QuantityRead()

void G4GDMLReadDefine::QuantityRead ( const xercesc::DOMElement * const element )

protected

Definition at line 419 of file G4GDMLReadDefine.cc.

{
   G4String name = "";
   G4double unit = 1.0;
   G4double value = 0.0;
 
   const xercesc::DOMNamedNodeMap* const attributes
         = element->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);
 
      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::QuantityRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name") { name = attValue; } else
      if (attName=="value") { value = eval.Evaluate(attValue); } else
      if (attName=="unit") { unit = eval.Evaluate(attValue); }
   }
 
   quantityMap[name] = value*unit;
   eval.DefineConstant(name,value*unit);
}

Referenced by DefineRead().

◆ RefRead()

G4String G4GDMLReadDefine::RefRead ( const xercesc::DOMElement * const element )

protected

Definition at line 531 of file G4GDMLReadDefine.cc.

{
   G4String ref;
 
   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
      { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::Read()", "InvalidRead",
                    FatalException, "No attribute found!");
        return ref;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="ref") { ref = attValue; }
   }
 
   return ref;
}

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadStructure::BorderSurfaceRead(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadMaterials::MaterialRead(), G4GDMLReadParamvol::ParametersRead(), G4GDMLReadParamvol::ParamvolRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadStructure::ReplicaRead(), G4GDMLReadStructure::ReplicavolRead(), G4GDMLReadSetup::SetupRead(), G4GDMLReadStructure::SkinSurfaceRead(), and G4GDMLReadStructure::VolumeRead().

◆ RotationRead()

void G4GDMLReadDefine::RotationRead ( const xercesc::DOMElement * const rotationElement )

protected

Definition at line 310 of file G4GDMLReadDefine.cc.

{
   G4String name = "";
   G4double unit = 1.0;
   G4ThreeVector rotation(0.,0.,0.);
 
   const xercesc::DOMNamedNodeMap* const attributes
         = rotationElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);
 
      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::RotationRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name") { name = GenerateName(attValue); }  else
      if (attName=="unit") { unit = eval.Evaluate(attValue); } else
      if (attName=="x") { rotation.setX(eval.Evaluate(attValue)); } else
      if (attName=="y") { rotation.setY(eval.Evaluate(attValue)); } else
      if (attName=="z") { rotation.setZ(eval.Evaluate(attValue)); }
   }
 
   rotationMap[name] = rotation*unit;
}

Referenced by DefineRead().

◆ ScaleRead()

void G4GDMLReadDefine::ScaleRead ( const xercesc::DOMElement * const scaleElement )

protected

Definition at line 348 of file G4GDMLReadDefine.cc.

{
   G4String name = "";
   G4ThreeVector scale(1.0,1.0,1.0);
 
   const xercesc::DOMNamedNodeMap* const attributes
         = scaleElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);
 
      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::ScaleRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name") { name = GenerateName(attValue); }    else
      if (attName=="x") { scale.setX(eval.Evaluate(attValue)); } else
      if (attName=="y") { scale.setY(eval.Evaluate(attValue)); } else
      if (attName=="z") { scale.setZ(eval.Evaluate(attValue)); }
   }
 
   scaleMap[name] = scale;
}

Referenced by DefineRead().

◆ VariableRead()

void G4GDMLReadDefine::VariableRead ( const xercesc::DOMElement * const variableElement )

protected

Definition at line 385 of file G4GDMLReadDefine.cc.

{
   G4String name  = "";
   G4double value = 0.0;
 
   const xercesc::DOMNamedNodeMap* const attributes
         = variableElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);
 
      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::VariableRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name")  { name = attValue; } else
      if (attName=="value") { value = eval.Evaluate(attValue); }
   }
 
   eval.DefineVariable(name,value);
}

Referenced by DefineRead().

◆ VectorRead()

void G4GDMLReadDefine::VectorRead	(	const xercesc::DOMElement * const	vectorElement,
		G4ThreeVector &	vec
	)

protected

Definition at line 494 of file G4GDMLReadDefine.cc.

{
   G4double unit = 1.0;
 
   const xercesc::DOMNamedNodeMap* const attributes
         = vectorElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
      { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::VectorRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="unit") { unit = eval.Evaluate(attValue); } else
      if (attName=="x") { vec.setX(eval.Evaluate(attValue)); } else
      if (attName=="y") { vec.setY(eval.Evaluate(attValue)); } else
      if (attName=="z") { vec.setZ(eval.Evaluate(attValue)); }
   }
 
   vec *= unit;
}

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadParamvol::ParametersRead(), G4GDMLReadStructure::PhysvolRead(), and G4GDMLReadStructure::ReplicaRead().

Member Data Documentation

◆ matrixMap

std::map<G4String,G4GDMLMatrix> G4GDMLReadDefine::matrixMap

protected

Definition at line 109 of file G4GDMLReadDefine.hh.

Referenced by GetMatrix(), and MatrixRead().

◆ positionMap

std::map<G4String,G4ThreeVector> G4GDMLReadDefine::positionMap

protected

Definition at line 106 of file G4GDMLReadDefine.hh.

Referenced by GetPosition(), and PositionRead().

◆ quantityMap

std::map<G4String,G4double> G4GDMLReadDefine::quantityMap

protected

Definition at line 105 of file G4GDMLReadDefine.hh.

Referenced by GetQuantity(), and QuantityRead().

◆ rotationMap

std::map<G4String,G4ThreeVector> G4GDMLReadDefine::rotationMap

protected

Definition at line 107 of file G4GDMLReadDefine.hh.

Referenced by GetRotation(), and RotationRead().

◆ scaleMap

std::map<G4String,G4ThreeVector> G4GDMLReadDefine::scaleMap

protected

Definition at line 108 of file G4GDMLReadDefine.hh.

Referenced by GetScale(), and ScaleRead().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4GDMLReadDefine()

◆ ~G4GDMLReadDefine()

Member Function Documentation

◆ ConstantRead()

◆ DefineRead()

◆ ExpressionRead()

◆ GetConstant()

◆ GetMatrix()

◆ GetPosition()

◆ GetQuantity()

◆ GetRotation()

◆ GetRotationMatrix()

◆ GetScale()

◆ GetVariable()

◆ IsValidID()

◆ MatrixRead()

◆ PositionRead()

◆ QuantityRead()

◆ RefRead()

◆ RotationRead()

◆ ScaleRead()

◆ VariableRead()

◆ VectorRead()

Member Data Documentation

◆ matrixMap

◆ positionMap

◆ quantityMap

◆ rotationMap

◆ scaleMap