G4GDMLReadDefine Class Reference

#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)
void	SetReverseSearch (G4bool flag)
Public Member Functions inherited from G4GDMLRead
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 void	UserinfoRead (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	StripName (G4String &) const
const G4String &	GetSchemaFile () const
void	SetSchemaFile (const G4String &schemaFile)
void	OverlapCheck (G4bool)
const G4GDMLAuxListType *	GetAuxList () const

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	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
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 66 of file G4GDMLReadDefine.hh.

Constructor & Destructor Documentation

G4GDMLReadDefine()

G4GDMLReadDefine::G4GDMLReadDefine ( )

protected

Definition at line 142 of file G4GDMLReadDefine.cc.

  : G4GDMLRead()
{
}

~G4GDMLReadDefine()

G4GDMLReadDefine::~G4GDMLReadDefine ( )

protectedvirtual

Definition at line 148 of file G4GDMLReadDefine.cc.

{
}

Member Function Documentation

ConstantRead()

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

protected

Definition at line 167 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 == nullptr)
    {
      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 596 of file G4GDMLReadDefine.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Reading definitions..." << G4endl;
#endif
  for(xercesc::DOMNode* iter = defineElement->getFirstChild(); iter != nullptr;
      iter                   = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
 
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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 212 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 == nullptr)
    {
      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 758 of file G4GDMLReadDefine.cc.

{
  return eval.GetConstant(ref);
}

GetMatrix()

G4GDMLMatrix G4GDMLReadDefine::GetMatrix

(

const G4String &

ref

)

Definition at line 818 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(), and G4GDMLReadSolids::PropertyRead().

GetPosition()

G4ThreeVector G4GDMLReadDefine::GetPosition

(

const G4String &

ref

)

Definition at line 782 of file G4GDMLReadDefine.cc.

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

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

GetQuantity()

G4double G4GDMLReadDefine::GetQuantity

(

const G4String &

ref

)

Definition at line 770 of file G4GDMLReadDefine.cc.

{
  if(quantityMap.find(ref) == quantityMap.cend())
  {
    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 794 of file G4GDMLReadDefine.cc.

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

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

GetRotationMatrix()

G4RotationMatrix G4GDMLReadDefine::GetRotationMatrix ( const G4ThreeVector & angles )

protected

Definition at line 153 of file G4GDMLReadDefine.cc.

{
  G4RotationMatrix rot;
 
  rot.rotateX(angles.x());
  rot.rotateY(angles.y());
  rot.rotateZ(angles.z());
  rot.rectify();  // Rectify matrix from possible roundoff errors
 
  return rot;
}

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

GetScale()

G4ThreeVector G4GDMLReadDefine::GetScale

(

const G4String &

ref

)

Definition at line 806 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(), and G4GDMLReadSolids::ScaledSolidRead().

GetVariable()

G4double G4GDMLReadDefine::GetVariable

(

const G4String &

ref

)

Definition at line 764 of file G4GDMLReadDefine.cc.

{
  return eval.GetVariable(ref);
}

IsValidID()

G4bool G4GDMLReadDefine::IsValidID

(

const G4String &

ref

)

const

Definition at line 752 of file G4GDMLReadDefine.cc.

{
  return eval.IsVariable(ref);
}

MatrixRead()

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

protected

Definition at line 255 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 == nullptr)
    {
      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(std::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 324 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 == nullptr)
    {
      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 = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadDefine::PositionRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    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 547 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 == nullptr)
    {
      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 = G4UnitDefinition::GetValueOf(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 714 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 == nullptr)
    {
      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(), G4GDMLReadSolids::MultiUnionNodeRead(), G4GDMLReadParamvol::ParametersRead(), G4GDMLReadParamvol::ParamvolRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadStructure::ReplicaRead(), G4GDMLReadStructure::ReplicavolRead(), G4GDMLReadSolids::ScaledSolidRead(), G4GDMLReadSetup::SetupRead(), G4GDMLReadStructure::SkinSurfaceRead(), and G4GDMLReadStructure::VolumeRead().

RotationRead()

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

protected

Definition at line 387 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 == nullptr)
    {
      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 = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadDefine::RotationRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    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 450 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 == nullptr)
    {
      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().

SetReverseSearch()

void G4GDMLReadDefine::SetReverseSearch ( G4bool flag )

inline

Definition at line 81 of file G4GDMLReadDefine.hh.

    { reverseSearch = flag; }

VariableRead()

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

protected

Definition at line 502 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 == nullptr)
    {
      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 662 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 == nullptr)
    {
      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 = G4UnitDefinition::GetValueOf(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(), G4GDMLReadSolids::MultiUnionNodeRead(), G4GDMLReadParamvol::ParametersRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadStructure::ReplicaRead(), and G4GDMLReadSolids::ScaledSolidRead().

Member Data Documentation

matrixMap

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

protected

Definition at line 108 of file G4GDMLReadDefine.hh.

Referenced by GetMatrix(), and MatrixRead().

positionMap

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

protected

Definition at line 105 of file G4GDMLReadDefine.hh.

Referenced by GetPosition(), and PositionRead().

quantityMap

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

protected

Definition at line 104 of file G4GDMLReadDefine.hh.

Referenced by GetQuantity(), and QuantityRead().

reverseSearch

G4bool G4GDMLReadDefine::reverseSearch = false

protected

Definition at line 103 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadStructure::AssemblyRead(), G4GDMLReadStructure::GetPhysvol(), G4GDMLReadSolids::GetSolid(), G4GDMLReadStructure::GetVolume(), and SetReverseSearch().

rotationMap

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

protected

Definition at line 106 of file G4GDMLReadDefine.hh.

Referenced by GetRotation(), and RotationRead().

scaleMap

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

protected

Definition at line 107 of file G4GDMLReadDefine.hh.

Referenced by GetScale(), and ScaleRead().

---

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

• G4GDMLReadDefine.hh
• G4GDMLReadDefine.cc