#include <G4GDMLReadDefine.hh>

Inheritance diagram for G4GDMLReadDefine:

Public Member Functions
virtual void	DefineRead (const xercesc::DOMElement *const)

virtual void	ExtensionRead (const xercesc::DOMElement *const)

const G4GDMLAuxListType *	GetAuxList () const

G4double	GetConstant (const G4String &)

G4GDMLMatrix	GetMatrix (const G4String &)

G4ThreeVector	GetPosition (const G4String &)

G4double	GetQuantity (const G4String &)

G4ThreeVector	GetRotation (const G4String &)

G4ThreeVector	GetScale (const G4String &)

virtual G4String	GetSetup (const G4String &)=0

G4double	GetVariable (const G4String &)

virtual G4LogicalVolume *	GetVolume (const G4String &) const =0

G4bool	IsValidID (const G4String &) const

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

void	OverlapCheck (G4bool)

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

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

void	SetReverseSearch (G4bool flag)

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

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

void	StripName (G4String &) const

void	StripNames () const

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

virtual void	UserinfoRead (const xercesc::DOMElement *const)

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

Protected Member Functions
G4GDMLAuxStructType	AuxiliaryRead (const xercesc::DOMElement *const auxElem)

void	ConstantRead (const xercesc::DOMElement *const)

void	ExpressionRead (const xercesc::DOMElement *const)

	G4GDMLReadDefine ()

G4String	GenerateName (const G4String &name, G4bool strip=false)

void	GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)

G4RotationMatrix	GetRotationMatrix (const G4ThreeVector &)

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

void	MatrixRead (const xercesc::DOMElement *const)

void	PositionRead (const xercesc::DOMElement *const)

void	QuantityRead (const xercesc::DOMElement *const)

G4String	RefRead (const xercesc::DOMElement *const)

void	RotationRead (const xercesc::DOMElement *const)

void	ScaleRead (const xercesc::DOMElement *const)

G4String	Strip (const G4String &) const

G4String	Transcode (const XMLCh *const)

void	VariableRead (const xercesc::DOMElement *const)

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

virtual	~G4GDMLReadDefine ()

Protected Attributes
G4bool	check = false

G4bool	dostrip = true

G4GDMLEvaluator	eval

std::map< G4String, G4GDMLMatrix >	matrixMap

std::map< G4String, G4ThreeVector >	positionMap

std::map< G4String, G4double >	quantityMap

G4bool	reverseSearch = false

std::map< G4String, G4ThreeVector >	rotationMap

std::map< G4String, G4ThreeVector >	scaleMap

G4bool	validate = true

Private Attributes
G4GDMLAuxListType	auxGlobalList

G4int	inLoop = 0

G4int	loopCount = 0

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.

149{

150}

Member Function Documentation

◆ AuxiliaryRead()

G4GDMLAuxStructType G4GDMLRead::AuxiliaryRead ( const xercesc::DOMElement *const auxElem )

protectedinherited

Definition at line 295 of file G4GDMLRead.cc.

{
  G4GDMLAuxStructType auxstruct = { "", "", "", 0 };
  G4GDMLAuxListType* auxList    = nullptr;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    auxiliaryElement->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::AuxiliaryRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return auxstruct;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "auxtype")
    {
      auxstruct.type = attValue;
    }
    else if(attName == "auxvalue")
    {
      auxstruct.value = attValue;
    }
    else if(attName == "auxunit")
    {
      auxstruct.unit = attValue;
    }
  }
 
  for(xercesc::DOMNode* iter = auxiliaryElement->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)
    {
      G4Exception("G4GDMLRead::AuxiliaryRead()", "InvalidRead", FatalException,
                  "No child found!");
      break;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "auxiliary")
    {
      if(!auxList)
      {
        auxList = new G4GDMLAuxListType;
      }
      auxList->push_back(AuxiliaryRead(child));
    }
  }
 
  if(auxList)
  {
    auxstruct.auxList = auxList;
  }
 
  return auxstruct;
}

References G4GDMLRead::AuxiliaryRead(), G4GDMLAuxStructType::auxList, FatalException, G4Exception(), G4GDMLRead::Transcode(), G4GDMLAuxStructType::type, G4GDMLAuxStructType::unit, and G4GDMLAuxStructType::value.

Referenced by G4GDMLRead::AuxiliaryRead(), G4GDMLRead::UserinfoRead(), and G4GDMLReadStructure::VolumeRead().

◆ 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);
}

References G4GDMLEvaluator::DefineConstant(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

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);
    }
  }
}

References ConstantRead(), ExpressionRead(), FatalException, G4cout, G4endl, G4Exception(), MatrixRead(), PositionRead(), QuantityRead(), RotationRead(), ScaleRead(), G4GDMLRead::Transcode(), and VariableRead().

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);
}

References G4GDMLEvaluator::DefineConstant(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by DefineRead().

◆ ExtensionRead()

void G4GDMLRead::ExtensionRead ( const xercesc::DOMElement * const )

virtualinherited

Definition at line 414 of file G4GDMLRead.cc.

{
  G4String error_msg = "No handle to user-code for parsing extensions!";
  G4Exception("G4GDMLRead::ExtensionRead()", "NotImplemented", JustWarning,
              error_msg);
}

References G4Exception(), and JustWarning.

Referenced by G4GDMLRead::Read().

◆ GenerateName()

G4String G4GDMLRead::GenerateName	(	const G4String &	name,
		G4bool	strip = `false`
	)

protectedinherited

Definition at line 70 of file G4GDMLRead.cc.

{
  G4String nameOut(nameIn);
 
  if(inLoop > 0)
  {
    nameOut = eval.SolveBrackets(nameOut);
  }
  if(strip)
  {
    StripName(nameOut);
  }
 
  return nameOut;
}

References G4GDMLRead::eval, G4GDMLRead::inLoop, G4GDMLEvaluator::SolveBrackets(), G4StrUtil::strip(), and G4GDMLRead::StripName().

◆ GeneratePhysvolName()

void G4GDMLRead::GeneratePhysvolName	(	const G4String &	nameIn,
		G4VPhysicalVolume *	physvol
	)

protectedinherited

Definition at line 87 of file G4GDMLRead.cc.

{
  G4String nameOut(nameIn);
 
  if(nameIn.empty())
  {
    std::stringstream stream;
    stream << physvol->GetLogicalVolume()->GetName() << "_PV";
    nameOut = stream.str();
  }
  nameOut = eval.SolveBrackets(nameOut);
 
  physvol->SetName(nameOut);
}

References G4GDMLRead::eval, G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4VPhysicalVolume::SetName(), and G4GDMLEvaluator::SolveBrackets().

Referenced by G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadStructure::PhysvolRead(), and G4GDMLReadStructure::ReplicaRead().

◆ GetAuxList()

const G4GDMLAuxListType * G4GDMLRead::GetAuxList ( ) const

inherited

Definition at line 563 of file G4GDMLRead.cc.

{
  return &auxGlobalList;
}

References G4GDMLRead::auxGlobalList.

◆ GetConstant()

G4double G4GDMLReadDefine::GetConstant ( const G4String & ref )

Definition at line 758 of file G4GDMLReadDefine.cc.

{
  return eval.GetConstant(ref);
}

References G4GDMLRead::eval, and G4GDMLEvaluator::GetConstant().

◆ 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];
}

References FatalException, G4Exception(), and matrixMap.

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];
}

References FatalException, G4Exception(), and positionMap.

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];
}

References FatalException, G4Exception(), and quantityMap.

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];
}

References FatalException, G4Exception(), and rotationMap.

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;
}

References CLHEP::HepRotation::rectify(), CLHEP::HepRotation::rotateX(), CLHEP::HepRotation::rotateY(), CLHEP::HepRotation::rotateZ(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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];
}

References FatalException, G4Exception(), and scaleMap.

Referenced by G4GDMLReadStructure::PhysvolRead(), and G4GDMLReadSolids::ScaledSolidRead().

◆ GetSetup()

virtual G4String G4GDMLRead::GetSetup ( const G4String & )

pure virtualinherited

Implemented in G4GDMLReadSetup.

◆ GetVariable()

G4double G4GDMLReadDefine::GetVariable ( const G4String & ref )

Definition at line 764 of file G4GDMLReadDefine.cc.

{
  return eval.GetVariable(ref);
}

References G4GDMLRead::eval, and G4GDMLEvaluator::GetVariable().

◆ GetVolume()

virtual G4LogicalVolume * G4GDMLRead::GetVolume ( const G4String & ) const

pure virtualinherited

Implemented in G4GDMLReadStructure.

Referenced by G4GDMLReadParamvol::ParamvolRead().

◆ IsValidID()

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

Definition at line 752 of file G4GDMLReadDefine.cc.

{
  return eval.IsVariable(ref);
}

References G4GDMLRead::eval, and G4GDMLEvaluator::IsVariable().

◆ LoopRead()

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

protectedinherited

Definition at line 194 of file G4GDMLRead.cc.

{
  G4String var;
  G4String from;
  G4String to;
  G4String step;
 
  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::LoopRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return;
    }
    const G4String attribute_name  = Transcode(attribute->getName());
    const G4String attribute_value = Transcode(attribute->getValue());
 
    if(attribute_name == "for")
    {
      var = attribute_value;
    }
    else if(attribute_name == "from")
    {
      from = attribute_value;
    }
    else if(attribute_name == "to")
    {
      to = attribute_value;
    }
    else if(attribute_name == "step")
    {
      step = attribute_value;
    }
  }
 
  if(var.empty())
  {
    G4Exception("G4GDMLRead::loopRead()", "InvalidRead", FatalException,
                "No variable is determined for loop!");
  }
 
  if(!eval.IsVariable(var))
  {
    G4Exception("G4GDMLRead::loopRead()", "InvalidRead", FatalException,
                "Variable is not defined in loop!");
  }
 
  G4int _var  = eval.EvaluateInteger(var);
  G4int _from = eval.EvaluateInteger(from);
  G4int _to   = eval.EvaluateInteger(to);
  G4int _step = eval.EvaluateInteger(step);
 
  if(!from.empty())
  {
    _var = _from;
  }
 
  if((_from < _to) && (_step <= 0))
  {
    G4Exception("G4GDMLRead::loopRead()", "InvalidRead", FatalException,
                "Infinite loop!");
  }
  if((_from > _to) && (_step >= 0))
  {
    G4Exception("G4GDMLRead::loopRead()", "InvalidRead", FatalException,
                "Infinite loop!");
  }
 
  ++inLoop;
 
  while(_var <= _to)
  {
    eval.SetVariable(var, _var);
    (this->*func)(element);
    _var += _step;
    ++loopCount;
  }
 
  --inLoop;
  if(!inLoop)
  {
    loopCount = 0;
  }
}

References G4GDMLRead::eval, G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), G4GDMLRead::inLoop, G4GDMLEvaluator::IsVariable(), G4GDMLRead::loopCount, G4GDMLEvaluator::SetVariable(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadParamvol::ParameterisedRead(), G4GDMLReadParamvol::Paramvol_contentRead(), G4GDMLReadSolids::SolidsRead(), G4GDMLReadStructure::StructureRead(), and G4GDMLReadStructure::Volume_contentRead().

◆ MaterialsRead()

virtual void G4GDMLRead::MaterialsRead ( const xercesc::DOMElement * const )

pure virtualinherited

Implemented in G4GDMLReadMaterials.

Referenced by G4GDMLRead::Read().

◆ 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;
}

References G4GDMLEvaluator::DefineMatrix(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), matrixMap, G4InuclParticleNames::name(), G4GDMLMatrix::Set(), and G4GDMLRead::Transcode().

Referenced by DefineRead().

◆ OverlapCheck()

void G4GDMLRead::OverlapCheck ( G4bool flag )

inherited

Definition at line 64 of file G4GDMLRead.cc.

{
  check = flag;
}

References G4GDMLRead::check.

◆ Paramvol_contentRead()

virtual void G4GDMLRead::Paramvol_contentRead ( const xercesc::DOMElement * const )

pure virtualinherited

Implemented in G4GDMLReadParamvol.

Referenced by G4GDMLReadParamvol::ParameterisedRead(), and G4GDMLReadParamvol::Paramvol_contentRead().

◆ 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;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), position, positionMap, and G4GDMLRead::Transcode().

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);
}

References G4GDMLEvaluator::DefineConstant(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), quantityMap, and G4GDMLRead::Transcode().

Referenced by DefineRead().

◆ Read()

void G4GDMLRead::Read	(	const G4String &	fileName,
		G4bool	validation,
		G4bool	isModule,
		G4bool	strip = `true`
	)

inherited

Definition at line 422 of file G4GDMLRead.cc.

{
  dostrip = strip;
#ifdef G4VERBOSE
  if(isModule)
  {
    G4cout << "G4GDML: Reading module '" << fileName << "'..." << G4endl;
  }
  else
  {
    G4cout << "G4GDML: Reading '" << fileName << "'..." << G4endl;
  }
#endif
  inLoop   = 0;
  validate = validation;
 
  xercesc::ErrorHandler* handler   = new G4GDMLErrorHandler(!validate);
  xercesc::XercesDOMParser* parser = new xercesc::XercesDOMParser;
 
  if(validate)
  {
    parser->setValidationScheme(xercesc::XercesDOMParser::Val_Always);
  }
  parser->setValidationSchemaFullChecking(validate);
  parser->setCreateEntityReferenceNodes(false);
  // Entities will be automatically resolved by Xerces
 
  parser->setDoNamespaces(true);
  parser->setDoSchema(validate);
  parser->setErrorHandler(handler);
 
  try
  {
    parser->parse(fileName.c_str());
  } catch(const xercesc::XMLException& e)
  {
    G4cout << "G4GDML: " << Transcode(e.getMessage()) << G4endl;
  } catch(const xercesc::DOMException& e)
  {
    G4cout << "G4GDML: " << Transcode(e.getMessage()) << G4endl;
  }
 
  xercesc::DOMDocument* doc = parser->getDocument();
 
  if(doc == nullptr)
  {
    G4String error_msg = "Unable to open document: " + fileName;
    G4Exception("G4GDMLRead::Read()", "InvalidRead", FatalException, error_msg);
    return;
  }
  xercesc::DOMElement* element = doc->getDocumentElement();
 
  if(element == nullptr )
  {
    std::ostringstream message;
    message << "ERROR - Empty document or unable to validate schema!" << G4endl
            << "        Check Internet connection is ON in case of schema"
            << G4endl
            << "        validation enabled and location defined as URL in"
            << G4endl << "        the GDML file - " << fileName
            << " - being imported!" << G4endl
            << "        Otherwise, verify GDML schema server is reachable!";
    G4Exception("G4GDMLRead::Read()", "InvalidRead", FatalException, message);
    return;
  }
 
  for(xercesc::DOMNode* iter = element->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::Read()", "InvalidRead", FatalException,
                  "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "define")
    {
      DefineRead(child);
    }
    else if(tag == "materials")
    {
      MaterialsRead(child);
    }
    else if(tag == "solids")
    {
      SolidsRead(child);
    }
    else if(tag == "setup")
    {
      SetupRead(child);
    }
    else if(tag == "structure")
    {
      StructureRead(child);
    }
    else if(tag == "userinfo")
    {
      UserinfoRead(child);
    }
    else if(tag == "extension")
    {
      ExtensionRead(child);
    }
    else
    {
      G4String error_msg = "Unknown tag in gdml: " + tag;
      G4Exception("G4GDMLRead::Read()", "InvalidRead", FatalException,
                  error_msg);
    }
  }
 
  delete parser;
  delete handler;
 
  if(isModule)
  {
#ifdef G4VERBOSE
    G4cout << "G4GDML: Reading module '" << fileName << "' done!" << G4endl;
#endif
  }
  else
  {
    G4cout << "G4GDML: Reading '" << fileName << "' done!" << G4endl;
    if(strip)
    {
      StripNames();
    }
  }
}

References G4GDMLRead::DefineRead(), G4GDMLRead::dostrip, G4GDMLRead::ExtensionRead(), FatalException, G4cout, G4endl, G4Exception(), G4GDMLRead::inLoop, G4GDMLRead::MaterialsRead(), geant4_check_module_cycles::parser, G4GDMLRead::SetupRead(), G4GDMLRead::SolidsRead(), G4StrUtil::strip(), G4GDMLRead::StripNames(), G4GDMLRead::StructureRead(), G4GDMLRead::Transcode(), G4GDMLRead::UserinfoRead(), and G4GDMLRead::validate.

Referenced by G4GDMLReadStructure::FileRead().

◆ 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;
}

References FatalException, G4Exception(), and G4GDMLRead::Transcode().

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;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), rotationMap, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), and G4GDMLRead::Transcode().

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;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4InuclParticleNames::name(), scaleMap, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), and G4GDMLRead::Transcode().

Referenced by DefineRead().

◆ SetReverseSearch()

void G4GDMLReadDefine::SetReverseSearch ( G4bool flag )

inline

Definition at line 81 of file G4GDMLReadDefine.hh.

82 { reverseSearch = flag; }

G4GDMLReadDefine::reverseSearch

G4bool reverseSearch

Definition: G4GDMLReadDefine.hh:103

References reverseSearch.

◆ SetupRead()

virtual void G4GDMLRead::SetupRead ( const xercesc::DOMElement * const )

pure virtualinherited

Implemented in G4GDMLReadSetup.

Referenced by G4GDMLRead::Read().

◆ SolidsRead()

virtual void G4GDMLRead::SolidsRead ( const xercesc::DOMElement * const )

pure virtualinherited

Implemented in G4GDMLReadSolids.

Referenced by G4GDMLRead::Read(), and G4GDMLReadSolids::SolidsRead().

◆ Strip()

G4String G4GDMLRead::Strip ( const G4String & name ) const

protectedinherited

Definition at line 104 of file G4GDMLRead.cc.

{
  G4String sname(name);
  StripName(sname);
  return sname;
}

References G4InuclParticleNames::name(), and G4GDMLRead::StripName().

Referenced by G4GDMLReadStructure::BorderSurfaceRead(), G4GDMLReadMaterials::ElementRead(), G4GDMLReadMaterials::IsotopeRead(), G4GDMLReadMaterials::MaterialRead(), G4GDMLReadMaterials::PropertyRead(), G4GDMLReadSolids::PropertyRead(), and G4GDMLReadStructure::SkinSurfaceRead().

◆ StripName()

void G4GDMLRead::StripName ( G4String & name ) const

inherited

Definition at line 112 of file G4GDMLRead.cc.

{
  auto idx = name.find("0x");
  if(idx != G4String::npos)
  {
    name.erase(idx);
  }
}

References G4InuclParticleNames::name().

Referenced by G4GDMLParser::ExportRegions(), G4GDMLRead::GenerateName(), G4GDMLParser::ImportRegions(), G4GDMLRead::Strip(), and G4GDMLRead::StripNames().

◆ StripNames()

void G4GDMLRead::StripNames ( ) const

inherited

Definition at line 122 of file G4GDMLRead.cc.

{
  // Strips off names of volumes, solids elements and materials from possible
  // reference pointers or IDs attached to their original identifiers.
 
  G4PhysicalVolumeStore* pvols     = G4PhysicalVolumeStore::GetInstance();
  G4LogicalVolumeStore* lvols      = G4LogicalVolumeStore::GetInstance();
  G4SolidStore* solids             = G4SolidStore::GetInstance();
  const G4ElementTable* elements   = G4Element::GetElementTable();
  const G4MaterialTable* materials = G4Material::GetMaterialTable();
 
  G4cout << "Stripping off GDML names of materials, solids and volumes ..."
         << G4endl;
 
  G4String sname;
  std::size_t i;
 
  // Solids...
  //
  for(i = 0; i < solids->size(); ++i)
  {
    G4VSolid* psol = (*solids)[i];
    sname          = psol->GetName();
    StripName(sname);
    psol->SetName(sname);
  }
  solids->UpdateMap();
 
  // Logical volumes...
  //
  for(i = 0; i < lvols->size(); ++i)
  {
    G4LogicalVolume* lvol = (*lvols)[i];
    sname                 = lvol->GetName();
    StripName(sname);
    lvol->SetName(sname);
  }
  lvols->UpdateMap();
 
  // Physical volumes...
  //
  for(i = 0; i < pvols->size(); ++i)
  {
    G4VPhysicalVolume* pvol = (*pvols)[i];
    sname                   = pvol->GetName();
    StripName(sname);
    pvol->SetName(sname);
  }
  pvols->UpdateMap();
 
  // Materials...
  //
  for(i = 0; i < materials->size(); ++i)
  {
    G4Material* pmat = (*materials)[i];
    sname            = pmat->GetName();
    StripName(sname);
    pmat->SetName(sname);
  }
 
  // Elements...
  //
  for(i = 0; i < elements->size(); ++i)
  {
    G4Element* pelm = (*elements)[i];
    sname           = pelm->GetName();
    StripName(sname);
    pelm->SetName(sname);
  }
}

References G4cout, G4endl, G4Element::GetElementTable(), G4LogicalVolumeStore::GetInstance(), G4PhysicalVolumeStore::GetInstance(), G4SolidStore::GetInstance(), G4Material::GetMaterialTable(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4VSolid::GetName(), G4Element::GetName(), G4Material::GetName(), G4VSolid::SetName(), G4Element::SetName(), G4Material::SetName(), G4LogicalVolume::SetName(), G4VPhysicalVolume::SetName(), G4GDMLRead::StripName(), G4LogicalVolumeStore::UpdateMap(), G4PhysicalVolumeStore::UpdateMap(), and G4SolidStore::UpdateMap().

Referenced by G4GDMLRead::Read().

◆ StructureRead()

virtual void G4GDMLRead::StructureRead ( const xercesc::DOMElement * const )

pure virtualinherited

Implemented in G4GDMLReadStructure.

Referenced by G4GDMLRead::Read(), and G4GDMLReadStructure::StructureRead().

◆ Transcode()

G4String G4GDMLRead::Transcode ( const XMLCh * const toTranscode )

protectedinherited

Definition at line 55 of file G4GDMLRead.cc.

{
  char* char_str = xercesc::XMLString::transcode(toTranscode);
  G4String my_str(char_str);
  xercesc::XMLString::release(&char_str);
  return my_str;
}

◆ UserinfoRead()

void G4GDMLRead::UserinfoRead ( const xercesc::DOMElement * const userinfoElement )

virtualinherited

Definition at line 377 of file G4GDMLRead.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Reading userinfo..." << G4endl;
#endif
  for(xercesc::DOMNode* iter = userinfoElement->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)
    {
      G4Exception("G4GDMLRead::UserinfoRead()", "InvalidRead", FatalException,
                  "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "auxiliary")
    {
      auxGlobalList.push_back(AuxiliaryRead(child));
    }
    else
    {
      G4String error_msg = "Unknown tag in structure: " + tag;
      G4Exception("G4GDMLRead::UserinfoRead()", "ReadError", FatalException,
                  error_msg);
    }
  }
}

References G4GDMLRead::auxGlobalList, G4GDMLRead::AuxiliaryRead(), FatalException, G4cout, G4endl, G4Exception(), and G4GDMLRead::Transcode().

Referenced by G4GDMLRead::Read().

◆ 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);
}

References G4GDMLEvaluator::DefineVariable(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

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;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetValueOf(), CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), and G4GDMLRead::Transcode().

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

◆ Volume_contentRead()

virtual void G4GDMLRead::Volume_contentRead ( const xercesc::DOMElement * const )

pure virtualinherited

Implemented in G4GDMLReadStructure.

Referenced by G4GDMLReadStructure::Volume_contentRead().

Field Documentation

◆ auxGlobalList

G4GDMLAuxListType G4GDMLRead::auxGlobalList

privateinherited

Definition at line 164 of file G4GDMLRead.hh.

Referenced by G4GDMLRead::GetAuxList(), and G4GDMLRead::UserinfoRead().

◆ check

G4bool G4GDMLRead::check = false

protectedinherited

Definition at line 158 of file G4GDMLRead.hh.

Referenced by G4GDMLRead::OverlapCheck(), G4GDMLReadParamvol::ParamvolRead(), and G4GDMLReadStructure::PhysvolRead().

◆ dostrip

G4bool G4GDMLRead::dostrip = true

protectedinherited

Definition at line 159 of file G4GDMLRead.hh.

Referenced by G4GDMLReadStructure::GetWorldVolume(), and G4GDMLRead::Read().

◆ eval

G4GDMLEvaluator G4GDMLRead::eval

protectedinherited

Definition at line 156 of file G4GDMLRead.hh.

◆ inLoop

G4int G4GDMLRead::inLoop = 0

privateinherited

Definition at line 163 of file G4GDMLRead.hh.

Referenced by G4GDMLRead::GenerateName(), G4GDMLRead::LoopRead(), and G4GDMLRead::Read().

◆ loopCount

G4int G4GDMLRead::loopCount = 0

privateinherited

Definition at line 163 of file G4GDMLRead.hh.

Referenced by G4GDMLRead::LoopRead().

◆ 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().

◆ validate

G4bool G4GDMLRead::validate = true

protectedinherited

Definition at line 157 of file G4GDMLRead.hh.

Referenced by G4GDMLReadStructure::FileRead(), and G4GDMLRead::Read().

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

source/persistency/gdml/include/G4GDMLReadDefine.hh
source/persistency/gdml/src/G4GDMLReadDefine.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4GDMLReadDefine()

◆ ~G4GDMLReadDefine()

Member Function Documentation

◆ AuxiliaryRead()

◆ ConstantRead()

◆ DefineRead()

◆ ExpressionRead()

◆ ExtensionRead()

◆ GenerateName()

◆ GeneratePhysvolName()

◆ GetAuxList()

◆ GetConstant()

◆ GetMatrix()

◆ GetPosition()

◆ GetQuantity()

◆ GetRotation()

◆ GetRotationMatrix()

◆ GetScale()

◆ GetSetup()

◆ GetVariable()

◆ GetVolume()

◆ IsValidID()

◆ LoopRead()

◆ MaterialsRead()

◆ MatrixRead()

◆ OverlapCheck()

◆ Paramvol_contentRead()

◆ PositionRead()

◆ QuantityRead()

◆ Read()

◆ RefRead()

◆ RotationRead()

◆ ScaleRead()

◆ SetReverseSearch()

◆ SetupRead()

◆ SolidsRead()

◆ Strip()

◆ StripName()

◆ StripNames()

◆ StructureRead()

◆ Transcode()

◆ UserinfoRead()

◆ VariableRead()

◆ VectorRead()

◆ Volume_contentRead()

Field Documentation

◆ auxGlobalList

◆ check

◆ dostrip

◆ eval

◆ inLoop

◆ loopCount

◆ matrixMap

◆ positionMap

◆ quantityMap

◆ reverseSearch

◆ rotationMap

◆ scaleMap

◆ validate