G4GDMLReadMaterials Class Reference

#include <G4GDMLReadMaterials.hh>

Inheritance diagram for G4GDMLReadMaterials:

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 &)
G4Element *	GetElement (const G4String &, G4bool verbose=true) const
G4Isotope *	GetIsotope (const G4String &, G4bool verbose=true) const
G4Material *	GetMaterial (const G4String &, G4bool verbose=true) const
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)
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
G4double	AtomRead (const xercesc::DOMElement *const)
G4GDMLAuxStructType	AuxiliaryRead (const xercesc::DOMElement *const auxElem)
G4int	CompositeRead (const xercesc::DOMElement *const, G4String &)
void	ConstantRead (const xercesc::DOMElement *const)
G4double	DRead (const xercesc::DOMElement *const)
void	ElementRead (const xercesc::DOMElement *const)
void	ExpressionRead (const xercesc::DOMElement *const)
G4double	FractionRead (const xercesc::DOMElement *const, G4String &)
	G4GDMLReadMaterials ()
G4String	GenerateName (const G4String &name, G4bool strip=false)
void	GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)
G4RotationMatrix	GetRotationMatrix (const G4ThreeVector &)
void	IsotopeRead (const xercesc::DOMElement *const)
void	LoopRead (const xercesc::DOMElement *const, void(G4GDMLRead::*)(const xercesc::DOMElement *const))
void	MaterialRead (const xercesc::DOMElement *const)
void	MatrixRead (const xercesc::DOMElement *const)
G4double	MEERead (const xercesc::DOMElement *const)
void	MixtureRead (const xercesc::DOMElement *const, G4Element *)
void	MixtureRead (const xercesc::DOMElement *const, G4Material *)
void	PositionRead (const xercesc::DOMElement *const)
G4double	PRead (const xercesc::DOMElement *const)
void	PropertyRead (const xercesc::DOMElement *const, G4Material *)
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)
G4double	TRead (const xercesc::DOMElement *const)
void	VariableRead (const xercesc::DOMElement *const)
void	VectorRead (const xercesc::DOMElement *const, G4ThreeVector &)
virtual	~G4GDMLReadMaterials ()

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 45 of file G4GDMLReadMaterials.hh.

Constructor & Destructor Documentation

G4GDMLReadMaterials()

G4GDMLReadMaterials::G4GDMLReadMaterials ( )

protected

Definition at line 42 of file G4GDMLReadMaterials.cc.

  : G4GDMLReadDefine()
{
}

~G4GDMLReadMaterials()

G4GDMLReadMaterials::~G4GDMLReadMaterials ( )

protectedvirtual

Definition at line 48 of file G4GDMLReadMaterials.cc.

{
}

Member Function Documentation

AtomRead()

G4double G4GDMLReadMaterials::AtomRead ( const xercesc::DOMElement * const  atomElement )

protected

Definition at line 53 of file G4GDMLReadMaterials.cc.

{
  G4double value = 0.0;
  G4double unit  = g / mole;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    atomElement->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("G4GDMLReadMaterials::AtomRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return value;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Molar mass")
      {
        G4Exception("G4GDMLReadMaterials::AtomRead()", "InvalidRead",
                    FatalException, "Invalid unit for atomic mass!");
      }
    }
  }
 
  return value * unit;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, g, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), mole, and G4GDMLRead::Transcode().

Referenced by ElementRead(), IsotopeRead(), and MaterialRead().

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

CompositeRead()

G4int G4GDMLReadMaterials::CompositeRead ( const xercesc::DOMElement * const  compositeElement, G4String &  ref  )

protected

Definition at line 103 of file G4GDMLReadMaterials.cc.

{
  G4int n = 0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    compositeElement->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("G4GDMLReadMaterials::CompositeRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return n;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "n")
    {
      n = eval.EvaluateInteger(attValue);
    }
    else if(attName == "ref")
    {
      ref = attValue;
    }
  }
 
  return n;
}

References G4GDMLRead::eval, G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), CLHEP::detail::n, and G4GDMLRead::Transcode().

Referenced by MixtureRead().

ConstantRead()

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

protectedinherited

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 G4GDMLReadDefine::DefineRead().

DefineRead()

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

virtualinherited

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 G4GDMLReadDefine::ConstantRead(), G4GDMLReadDefine::ExpressionRead(), FatalException, G4cout, G4endl, G4Exception(), G4GDMLReadDefine::MatrixRead(), G4GDMLReadDefine::PositionRead(), G4GDMLReadDefine::QuantityRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadDefine::ScaleRead(), G4GDMLRead::Transcode(), and G4GDMLReadDefine::VariableRead().

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

DRead()

G4double G4GDMLReadMaterials::DRead ( const xercesc::DOMElement * const  DElement )

protected

Definition at line 147 of file G4GDMLReadMaterials.cc.

{
  G4double value = 0.0;
  G4double unit  = g / cm3;
 
  const xercesc::DOMNamedNodeMap* const attributes = DElement->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("G4GDMLReadMaterials::DRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return value;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Volumic Mass")
      {
        G4Exception("G4GDMLReadMaterials::DRead()", "InvalidRead",
                    FatalException, "Invalid unit for density!");
      }
    }
  }
 
  return value * unit;
}

References cm3, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, g, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by MaterialRead().

ElementRead()

void G4GDMLReadMaterials::ElementRead ( const xercesc::DOMElement * const  elementElement )

protected

Definition at line 339 of file G4GDMLReadMaterials.cc.

{
  G4String name;
  G4String formula;
  G4double a = 0.0;
  G4double Z = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    elementElement->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("G4GDMLReadMaterials::ElementRead()", "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 == "formula")
    {
      formula = attValue;
    }
    else if(attName == "Z")
    {
      Z = eval.Evaluate(attValue);
    }
  }
 
  G4int nComponents = 0;
 
  for(xercesc::DOMNode* iter = elementElement->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("G4GDMLReadMaterials::ElementRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "atom")
    {
      a = AtomRead(child);
    }
    else if(tag == "fraction")
    {
      nComponents++;
    }
  }
 
  if(nComponents > 0)
  {
    MixtureRead(elementElement,
                new G4Element(Strip(name), formula, nComponents));
  }
  else
  {
    new G4Element(Strip(name), formula, Z, a);
  }
}

References AtomRead(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), MixtureRead(), G4InuclParticleNames::name(), G4GDMLRead::Strip(), G4GDMLRead::Transcode(), and Z.

Referenced by MaterialsRead().

ExpressionRead()

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

protectedinherited

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 G4GDMLReadDefine::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().

FractionRead()

G4double G4GDMLReadMaterials::FractionRead ( const xercesc::DOMElement * const  fractionElement, G4String &  ref  )

protected

Definition at line 428 of file G4GDMLReadMaterials.cc.

{
  G4double n = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    fractionElement->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("G4GDMLReadMaterials::FractionRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return n;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "n")
    {
      n = eval.Evaluate(attValue);
    }
    else if(attName == "ref")
    {
      ref = attValue;
    }
  }
 
  return n;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), CLHEP::detail::n, and G4GDMLRead::Transcode().

Referenced by MixtureRead().

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

Referenced by G4GDMLReadStructure::AssemblyRead(), G4GDMLReadSolids::BooleanRead(), G4GDMLReadStructure::BorderSurfaceRead(), G4GDMLReadSolids::BoxRead(), G4GDMLReadSolids::ConeRead(), G4GDMLReadSolids::CutTubeRead(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadSolids::ElconeRead(), ElementRead(), G4GDMLReadSolids::EllipsoidRead(), G4GDMLReadSolids::EltubeRead(), G4GDMLReadStructure::FileRead(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), G4GDMLReadStructure::GetWorldVolume(), G4GDMLReadSolids::HypeRead(), IsotopeRead(), MaterialRead(), G4GDMLReadDefine::MatrixRead(), MixtureRead(), G4GDMLReadSolids::MultiUnionNodeRead(), G4GDMLReadSolids::MultiUnionRead(), G4GDMLReadSolids::OpticalSurfaceRead(), G4GDMLReadSolids::OrbRead(), G4GDMLReadSolids::ParaboloidRead(), G4GDMLReadParamvol::ParametersRead(), G4GDMLReadParamvol::ParamvolRead(), G4GDMLReadSolids::ParaRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadSolids::PolyconeRead(), G4GDMLReadSolids::PolyhedraRead(), G4GDMLReadDefine::PositionRead(), PropertyRead(), G4GDMLReadSolids::PropertyRead(), G4GDMLReadSolids::QuadrangularRead(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadStructure::ReplicaRead(), G4GDMLReadStructure::ReplicavolRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadSolids::ScaledSolidRead(), G4GDMLReadDefine::ScaleRead(), G4GDMLReadSetup::SetupRead(), G4GDMLReadStructure::SkinSurfaceRead(), G4GDMLReadSolids::SphereRead(), G4GDMLReadSolids::TessellatedRead(), G4GDMLReadSolids::TetRead(), G4GDMLReadSolids::TorusRead(), G4GDMLReadSolids::TrapRead(), G4GDMLReadSolids::TrdRead(), G4GDMLReadSolids::TriangularRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), G4GDMLReadStructure::VolumeRead(), and G4GDMLReadSolids::XtruRead().

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 )

inherited

Definition at line 758 of file G4GDMLReadDefine.cc.

{
  return eval.GetConstant(ref);
}

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

GetElement()

G4Element * G4GDMLReadMaterials::GetElement	(	const G4String &	ref,
		G4bool	verbose = true
	)		const

Definition at line 932 of file G4GDMLReadMaterials.cc.

{
  G4Element* elementPtr = G4Element::GetElement(ref, false);
 
  if(elementPtr == nullptr)
  {
    elementPtr = G4NistManager::Instance()->FindOrBuildElement(ref);
  }
 
  if(verbose && elementPtr == nullptr)
  {
    G4String error_msg = "Referenced element '" + ref + "' was not found!";
    G4Exception("G4GDMLReadMaterials::GetElement()", "InvalidRead",
                FatalException, error_msg);
  }
 
  return elementPtr;
}

References FatalException, G4NistManager::FindOrBuildElement(), G4Exception(), G4Element::GetElement(), and G4NistManager::Instance().

Referenced by MixtureRead().

GetIsotope()

G4Isotope * G4GDMLReadMaterials::GetIsotope	(	const G4String &	ref,
		G4bool	verbose = true
	)		const

Definition at line 953 of file G4GDMLReadMaterials.cc.

{
  G4Isotope* isotopePtr = G4Isotope::GetIsotope(ref, false);
 
  if(verbose && isotopePtr == nullptr)
  {
    G4String error_msg = "Referenced isotope '" + ref + "' was not found!";
    G4Exception("G4GDMLReadMaterials::GetIsotope()", "InvalidRead",
                FatalException, error_msg);
  }
 
  return isotopePtr;
}

References FatalException, G4Exception(), and G4Isotope::GetIsotope().

Referenced by MixtureRead().

GetMaterial()

G4Material * G4GDMLReadMaterials::GetMaterial	(	const G4String &	ref,
		G4bool	verbose = true
	)		const

Definition at line 969 of file G4GDMLReadMaterials.cc.

{
  G4Material* materialPtr = G4Material::GetMaterial(ref, false);
 
  if(materialPtr == nullptr)
  {
    materialPtr = G4NistManager::Instance()->FindOrBuildMaterial(ref);
  }
 
  if(verbose && materialPtr == nullptr)
  {
    G4String error_msg = "Referenced material '" + ref + "' was not found!";
    G4Exception("G4GDMLReadMaterials::GetMaterial()", "InvalidRead",
                FatalException, error_msg);
  }
 
  return materialPtr;
}

References FatalException, G4NistManager::FindOrBuildMaterial(), G4Exception(), G4Material::GetMaterial(), and G4NistManager::Instance().

Referenced by MixtureRead(), and G4GDMLReadStructure::VolumeRead().

GetMatrix()

G4GDMLMatrix G4GDMLReadDefine::GetMatrix ( const G4String &  ref )

inherited

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 G4GDMLReadDefine::matrixMap.

Referenced by PropertyRead(), and G4GDMLReadSolids::PropertyRead().

GetPosition()

G4ThreeVector G4GDMLReadDefine::GetPosition ( const G4String &  ref )

inherited

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 G4GDMLReadDefine::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 )

inherited

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 G4GDMLReadDefine::quantityMap.

Referenced by MaterialRead().

GetRotation()

G4ThreeVector G4GDMLReadDefine::GetRotation ( const G4String &  ref )

inherited

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 G4GDMLReadDefine::rotationMap.

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

GetRotationMatrix()

G4RotationMatrix G4GDMLReadDefine::GetRotationMatrix ( const G4ThreeVector &  angles )

protectedinherited

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 )

inherited

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 G4GDMLReadDefine::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 )

inherited

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

IsotopeRead()

void G4GDMLReadMaterials::IsotopeRead ( const xercesc::DOMElement * const  isotopeElement )

protected

Definition at line 472 of file G4GDMLReadMaterials.cc.

{
  G4String name;
  G4int Z    = 0;
  G4int N    = 0;
  G4double a = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    isotopeElement->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("G4GDMLReadMaterials::IsotopeRead()", "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 == "Z")
    {
      Z = eval.EvaluateInteger(attValue);
    }
    else if(attName == "N")
    {
      N = eval.EvaluateInteger(attValue);
    }
  }
 
  for(xercesc::DOMNode* iter = isotopeElement->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("G4GDMLReadMaterials::IsotopeRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "atom")
    {
      a = AtomRead(child);
    }
  }
 
  new G4Isotope(Strip(name), Z, N, a);
}

References AtomRead(), G4GDMLRead::eval, G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4InuclParticleNames::name(), G4GDMLRead::Strip(), G4GDMLRead::Transcode(), and Z.

Referenced by MaterialsRead().

IsValidID()

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

inherited

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

MaterialRead()

void G4GDMLReadMaterials::MaterialRead ( const xercesc::DOMElement * const  materialElement )

protected

Definition at line 547 of file G4GDMLReadMaterials.cc.

{
  G4String name;
  G4double Z    = 0.0;
  G4double a    = 0.0;
  G4double D    = 0.0;
  G4State state = kStateUndefined;
  G4double T    = NTP_Temperature;
  G4double P    = STP_Pressure;
  G4double MEE  = -1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    materialElement->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("G4GDMLReadMaterials::MaterialRead()", "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 == "Z")
    {
      Z = eval.Evaluate(attValue);
    }
    else if(attName == "state")
    {
      if(attValue == "solid")
      {
        state = kStateSolid;
      }
      else if(attValue == "liquid")
      {
        state = kStateLiquid;
      }
      else if(attValue == "gas")
      {
        state = kStateGas;
      }
    }
  }
 
  std::size_t nComponents = 0;
 
  for(xercesc::DOMNode* iter = materialElement->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("G4GDMLReadMaterials::MaterialRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "atom")
    {
      a = AtomRead(child);
    }
    else if(tag == "Dref")
    {
      D = GetQuantity(GenerateName(RefRead(child)));
    }
    else if(tag == "Pref")
    {
      P = GetQuantity(GenerateName(RefRead(child)));
    }
    else if(tag == "Tref")
    {
      T = GetQuantity(GenerateName(RefRead(child)));
    }
    else if(tag == "MEEref")
    {
      MEE = GetQuantity(GenerateName(RefRead(child)));
    }
    else if(tag == "D")
    {
      D = DRead(child);
    }
    else if(tag == "P")
    {
      P = PRead(child);
    }
    else if(tag == "T")
    {
      T = TRead(child);
    }
    else if(tag == "MEE")
    {
      MEE = MEERead(child);
    }
    else if(tag == "fraction" || tag == "composite")
    {
      nComponents++;
    }
  }
 
  G4Material* material = nullptr;
 
  if(nComponents == 0)
  {
    material = new G4Material(Strip(name), Z, a, D, state, T, P);
  }
  else
  {
    material = new G4Material(Strip(name), D, nComponents, state, T, P);
    MixtureRead(materialElement, material);
  }
  if(MEE != -1)  // ionisation potential (mean excitation energy)
  {
    material->GetIonisation()->SetMeanExcitationEnergy(MEE);
  }
 
  for(xercesc::DOMNode* iter = materialElement->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("G4GDMLReadMaterials::MaterialRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "property")
    {
      PropertyRead(child, material);
    }
  }
}

References AtomRead(), D(), DRead(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadDefine::GetQuantity(), kStateGas, kStateLiquid, kStateSolid, kStateUndefined, eplot::material, MEERead(), MixtureRead(), G4InuclParticleNames::name(), NTP_Temperature, P, PRead(), PropertyRead(), G4GDMLReadDefine::RefRead(), source.hepunit::STP_Pressure, G4GDMLRead::Strip(), G4GDMLRead::Transcode(), TRead(), and Z.

Referenced by MaterialsRead().

MaterialsRead()

void G4GDMLReadMaterials::MaterialsRead ( const xercesc::DOMElement * const  materialsElement )

virtual

Implements G4GDMLRead.

Definition at line 882 of file G4GDMLReadMaterials.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Reading materials..." << G4endl;
#endif
  for(xercesc::DOMNode* iter = materialsElement->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("G4GDMLReadMaterials::MaterialsRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "define")
    {
      DefineRead(child);
    }
    else if(tag == "element")
    {
      ElementRead(child);
    }
    else if(tag == "isotope")
    {
      IsotopeRead(child);
    }
    else if(tag == "material")
    {
      MaterialRead(child);
    }
    else
    {
      G4String error_msg = "Unknown tag in materials: " + tag;
      G4Exception("G4GDMLReadMaterials::MaterialsRead()", "InvalidSetup",
                  FatalException, error_msg);
    }
  }
}

References G4GDMLReadDefine::DefineRead(), ElementRead(), FatalException, G4cout, G4endl, G4Exception(), IsotopeRead(), MaterialRead(), and G4GDMLRead::Transcode().

MatrixRead()

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

protectedinherited

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(), G4GDMLReadDefine::matrixMap, G4InuclParticleNames::name(), G4GDMLMatrix::Set(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadDefine::DefineRead().

MEERead()

G4double G4GDMLReadMaterials::MEERead ( const xercesc::DOMElement * const  PElement )

protected

Definition at line 291 of file G4GDMLReadMaterials.cc.

{
  G4double value = -1;
  G4double unit  = eV;
 
  const xercesc::DOMNamedNodeMap* const attributes = PElement->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("G4GDMLReadMaterials::MEERead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return value;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Energy")
      {
        G4Exception("G4GDMLReadMaterials::MEERead()", "InvalidRead",
                    FatalException, "Invalid unit for energy!");
      }
    }
  }
 
  return value * unit;
}

References eV, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by MaterialRead().

MixtureRead() [1/2]

void G4GDMLReadMaterials::MixtureRead ( const xercesc::DOMElement * const  mixtureElement, G4Element *  element  )

protected

Definition at line 713 of file G4GDMLReadMaterials.cc.

{
  for(xercesc::DOMNode* iter = mixtureElement->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("G4GDMLReadMaterials::MixtureRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "fraction")
    {
      G4String ref;
      G4double n = FractionRead(child, ref);
      element->AddIsotope(GetIsotope(GenerateName(ref, true)), n);
    }
  }
}

References G4Element::AddIsotope(), FatalException, FractionRead(), G4Exception(), G4GDMLRead::GenerateName(), GetIsotope(), CLHEP::detail::n, and G4GDMLRead::Transcode().

Referenced by ElementRead(), and MaterialRead().

MixtureRead() [2/2]

void G4GDMLReadMaterials::MixtureRead ( const xercesc::DOMElement * const  mixtureElement, G4Material *  material  )

protected

Definition at line 744 of file G4GDMLReadMaterials.cc.

{
  for(xercesc::DOMNode* iter = mixtureElement->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("G4GDMLReadMaterials::MixtureRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "fraction")
    {
      G4String ref;
      G4double n = FractionRead(child, ref);
 
      G4Material* materialPtr = GetMaterial(GenerateName(ref, true), false);
      G4Element* elementPtr   = GetElement(GenerateName(ref, true), false);
 
      if(elementPtr != nullptr)
      {
        material->AddElement(elementPtr, n);
      }
      else if(materialPtr != nullptr)
      {
        material->AddMaterial(materialPtr, n);
      }
 
      if((materialPtr == nullptr) && (elementPtr == nullptr))
      {
        G4String error_msg = "Referenced material/element '" +
                             GenerateName(ref, true) + "' was not found!";
        G4Exception("G4GDMLReadMaterials::MixtureRead()", "InvalidSetup",
                    FatalException, error_msg);
      }
    }
    else if(tag == "composite")
    {
      G4String ref;
      G4int n = CompositeRead(child, ref);
 
      G4Element* elementPtr = GetElement(GenerateName(ref, true));
      material->AddElement(elementPtr, n);
    }
  }
}

References CompositeRead(), FatalException, FractionRead(), G4Exception(), G4GDMLRead::GenerateName(), GetElement(), GetMaterial(), eplot::material, CLHEP::detail::n, and G4GDMLRead::Transcode().

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 )

protectedinherited

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, G4GDMLReadDefine::positionMap, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadDefine::DefineRead().

PRead()

G4double G4GDMLReadMaterials::PRead ( const xercesc::DOMElement * const  PElement )

protected

Definition at line 195 of file G4GDMLReadMaterials.cc.

{
  G4double value = STP_Pressure;
  G4double unit  = hep_pascal;
 
  const xercesc::DOMNamedNodeMap* const attributes = PElement->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("G4GDMLReadMaterials::PRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return value;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Pressure")
      {
        G4Exception("G4GDMLReadMaterials::PRead()", "InvalidRead",
                    FatalException, "Invalid unit for pressure!");
      }
    }
  }
 
  return value * unit;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), hep_pascal, source.hepunit::STP_Pressure, and G4GDMLRead::Transcode().

Referenced by MaterialRead().

PropertyRead()

void G4GDMLReadMaterials::PropertyRead ( const xercesc::DOMElement * const  propertyElement, G4Material *  material  )

protected

Definition at line 802 of file G4GDMLReadMaterials.cc.

{
  G4String name;
  G4String ref;
  G4GDMLMatrix matrix;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    propertyElement->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("G4GDMLReadMaterials::PropertyRead()", "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 == "ref")
    {
      matrix = GetMatrix(ref = attValue);
    }
  }
 
  /*
  if (matrix.GetCols() != 2)
  {
    G4String error_msg = "Referenced matrix '" + ref
           + "' should have \n two columns as a property table for material: "
           + material->GetName();
    G4Exception("G4GDMLReadMaterials::PropertyRead()", "InvalidRead",
                FatalException, error_msg);
  }
  */
 
  if(matrix.GetRows() == 0)
  {
    return;
  }
 
  G4MaterialPropertiesTable* matprop = material->GetMaterialPropertiesTable();
  if(matprop == nullptr)
  {
    matprop = new G4MaterialPropertiesTable();
    material->SetMaterialPropertiesTable(matprop);
  }
  if(matrix.GetCols() == 1)  // constant property assumed
  {
    matprop->AddConstProperty(Strip(name), matrix.Get(0, 0), true);
  }
  else  // build the material properties vector
  {
    G4MaterialPropertyVector* propvect = new G4MaterialPropertyVector();
    for(std::size_t i = 0; i < matrix.GetRows(); ++i)
    {
      propvect->InsertValues(matrix.Get(i, 0), matrix.Get(i, 1));
    }
    matprop->AddProperty(Strip(name), propvect, true);
  }
}

References G4MaterialPropertiesTable::AddConstProperty(), G4MaterialPropertiesTable::AddProperty(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLMatrix::Get(), G4GDMLMatrix::GetCols(), G4GDMLReadDefine::GetMatrix(), G4GDMLMatrix::GetRows(), G4PhysicsFreeVector::InsertValues(), eplot::material, G4InuclParticleNames::name(), G4GDMLRead::Strip(), and G4GDMLRead::Transcode().

Referenced by MaterialRead().

QuantityRead()

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

protectedinherited

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(), G4GDMLReadDefine::quantityMap, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadDefine::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 )

protectedinherited

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(), 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 )

protectedinherited

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(), G4GDMLReadDefine::rotationMap, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadDefine::DefineRead().

ScaleRead()

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

protectedinherited

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(), G4GDMLReadDefine::scaleMap, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadDefine::DefineRead().

SetReverseSearch()

void G4GDMLReadDefine::SetReverseSearch ( G4bool  flag )

inlineinherited

Definition at line 81 of file G4GDMLReadDefine.hh.

    { reverseSearch = flag; }

References G4GDMLReadDefine::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(), ElementRead(), IsotopeRead(), MaterialRead(), 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;
}

Referenced by G4GDMLReadStructure::AssemblyRead(), AtomRead(), G4GDMLRead::AuxiliaryRead(), G4GDMLReadStructure::AxisRead(), G4GDMLReadSolids::BooleanRead(), G4GDMLReadStructure::BorderSurfaceRead(), G4GDMLReadParamvol::Box_dimensionsRead(), G4GDMLReadSolids::BoxRead(), CompositeRead(), G4GDMLReadParamvol::Cone_dimensionsRead(), G4GDMLReadSolids::ConeRead(), G4GDMLReadDefine::ConstantRead(), G4GDMLReadSolids::CutTubeRead(), G4GDMLReadDefine::DefineRead(), G4GDMLReadStructure::DivisionvolRead(), DRead(), G4GDMLReadSolids::ElconeRead(), ElementRead(), G4GDMLReadParamvol::Ellipsoid_dimensionsRead(), G4GDMLReadSolids::EllipsoidRead(), G4GDMLReadSolids::EltubeRead(), G4GDMLReadDefine::ExpressionRead(), G4GDMLReadStructure::FileRead(), FractionRead(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), G4GDMLReadParamvol::Hype_dimensionsRead(), G4GDMLReadSolids::HypeRead(), IsotopeRead(), G4GDMLRead::LoopRead(), MaterialRead(), MaterialsRead(), G4GDMLReadDefine::MatrixRead(), MEERead(), MixtureRead(), G4GDMLReadSolids::MultiUnionNodeRead(), G4GDMLReadSolids::MultiUnionRead(), G4GDMLReadSolids::OpticalSurfaceRead(), G4GDMLReadParamvol::Orb_dimensionsRead(), G4GDMLReadSolids::OrbRead(), G4GDMLReadParamvol::Para_dimensionsRead(), G4GDMLReadSolids::ParaboloidRead(), G4GDMLReadParamvol::ParameterisedRead(), G4GDMLReadParamvol::ParametersRead(), G4GDMLReadParamvol::Paramvol_contentRead(), G4GDMLReadParamvol::ParamvolRead(), G4GDMLReadSolids::ParaRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadParamvol::Polycone_dimensionsRead(), G4GDMLReadSolids::PolyconeRead(), G4GDMLReadParamvol::Polyhedra_dimensionsRead(), G4GDMLReadSolids::PolyhedraRead(), G4GDMLReadDefine::PositionRead(), PRead(), PropertyRead(), G4GDMLReadSolids::PropertyRead(), G4GDMLReadSolids::QuadrangularRead(), G4GDMLReadStructure::QuantityRead(), G4GDMLReadDefine::QuantityRead(), G4GDMLRead::Read(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadDefine::RefRead(), G4GDMLReadStructure::ReplicaRead(), G4GDMLReadStructure::ReplicavolRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadSolids::RZPointRead(), G4GDMLReadSolids::ScaledSolidRead(), G4GDMLReadDefine::ScaleRead(), G4GDMLReadSolids::SectionRead(), G4GDMLReadSetup::SetupRead(), G4GDMLReadStructure::SkinSurfaceRead(), G4GDMLReadSolids::SolidsRead(), G4GDMLReadParamvol::Sphere_dimensionsRead(), G4GDMLReadSolids::SphereRead(), G4GDMLReadStructure::StructureRead(), G4GDMLReadSolids::TessellatedRead(), G4GDMLReadSolids::TetRead(), G4GDMLReadParamvol::Torus_dimensionsRead(), G4GDMLReadSolids::TorusRead(), G4GDMLReadParamvol::Trap_dimensionsRead(), G4GDMLReadSolids::TrapRead(), G4GDMLReadParamvol::Trd_dimensionsRead(), G4GDMLReadSolids::TrdRead(), TRead(), G4GDMLReadSolids::TriangularRead(), G4GDMLReadParamvol::Tube_dimensionsRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), G4GDMLReadSolids::TwoDimVertexRead(), G4GDMLRead::UserinfoRead(), G4GDMLReadDefine::VariableRead(), G4GDMLReadDefine::VectorRead(), G4GDMLReadStructure::Volume_contentRead(), G4GDMLReadStructure::VolumeRead(), G4GDMLReadSolids::XtruRead(), and G4GDMLReadSolids::ZplaneRead().

TRead()

G4double G4GDMLReadMaterials::TRead ( const xercesc::DOMElement * const  TElement )

protected

Definition at line 243 of file G4GDMLReadMaterials.cc.

{
  G4double value = NTP_Temperature;
  G4double unit  = kelvin;
 
  const xercesc::DOMNamedNodeMap* const attributes = TElement->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("G4GDMLReadMaterials::TRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return value;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Temperature")
      {
        G4Exception("G4GDMLReadMaterials::TRead()", "InvalidRead",
                    FatalException, "Invalid unit for temperature!");
      }
    }
  }
 
  return value * unit;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), kelvin, NTP_Temperature, and G4GDMLRead::Transcode().

Referenced by MaterialRead().

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 )

protectedinherited

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 G4GDMLReadDefine::DefineRead().

VectorRead()

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

protectedinherited

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.

Referenced by AtomRead(), G4GDMLReadStructure::AxisRead(), G4GDMLReadParamvol::Box_dimensionsRead(), G4GDMLReadSolids::BoxRead(), G4GDMLReadStructure::Clear(), CompositeRead(), G4GDMLReadParamvol::Cone_dimensionsRead(), G4GDMLReadSolids::ConeRead(), G4GDMLReadDefine::ConstantRead(), G4GDMLReadSolids::CutTubeRead(), G4GDMLReadStructure::DivisionvolRead(), DRead(), G4GDMLReadSolids::ElconeRead(), ElementRead(), G4GDMLReadParamvol::Ellipsoid_dimensionsRead(), G4GDMLReadSolids::EllipsoidRead(), G4GDMLReadSolids::EltubeRead(), G4GDMLReadDefine::ExpressionRead(), FractionRead(), G4GDMLRead::GenerateName(), G4GDMLRead::GeneratePhysvolName(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), G4GDMLReadDefine::GetConstant(), G4GDMLReadDefine::GetVariable(), G4GDMLReadParamvol::Hype_dimensionsRead(), G4GDMLReadSolids::HypeRead(), IsotopeRead(), G4GDMLReadDefine::IsValidID(), G4GDMLRead::LoopRead(), MaterialRead(), G4GDMLReadDefine::MatrixRead(), MEERead(), G4GDMLReadSolids::OpticalSurfaceRead(), G4GDMLReadParamvol::Orb_dimensionsRead(), G4GDMLReadSolids::OrbRead(), G4GDMLReadParamvol::Para_dimensionsRead(), G4GDMLReadSolids::ParaboloidRead(), G4GDMLReadParamvol::ParameterisedRead(), G4GDMLReadSolids::ParaRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadParamvol::Polycone_dimensionsRead(), G4GDMLReadSolids::PolyconeRead(), G4GDMLReadParamvol::Polyhedra_dimensionsRead(), G4GDMLReadSolids::PolyhedraRead(), G4GDMLReadDefine::PositionRead(), PRead(), G4GDMLReadStructure::QuantityRead(), G4GDMLReadDefine::QuantityRead(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadSolids::RZPointRead(), G4GDMLReadDefine::ScaleRead(), G4GDMLReadSolids::SectionRead(), G4GDMLReadParamvol::Sphere_dimensionsRead(), G4GDMLReadSolids::SphereRead(), G4GDMLReadParamvol::Torus_dimensionsRead(), G4GDMLReadSolids::TorusRead(), G4GDMLReadParamvol::Trap_dimensionsRead(), G4GDMLReadSolids::TrapRead(), G4GDMLReadParamvol::Trd_dimensionsRead(), G4GDMLReadSolids::TrdRead(), TRead(), G4GDMLReadParamvol::Tube_dimensionsRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), G4GDMLReadSolids::TwoDimVertexRead(), G4GDMLReadDefine::VariableRead(), G4GDMLReadDefine::VectorRead(), G4GDMLReadStructure::Volume_contentRead(), and G4GDMLReadSolids::ZplaneRead().

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

protectedinherited

Definition at line 108 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadDefine::GetMatrix(), and G4GDMLReadDefine::MatrixRead().

positionMap

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

protectedinherited

Definition at line 105 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadDefine::GetPosition(), and G4GDMLReadDefine::PositionRead().

quantityMap

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

protectedinherited

Definition at line 104 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadDefine::GetQuantity(), and G4GDMLReadDefine::QuantityRead().

reverseSearch

G4bool G4GDMLReadDefine::reverseSearch = false

protectedinherited

Definition at line 103 of file G4GDMLReadDefine.hh.

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

rotationMap

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

protectedinherited

Definition at line 106 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadDefine::GetRotation(), and G4GDMLReadDefine::RotationRead().

scaleMap

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

protectedinherited

Definition at line 107 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadDefine::GetScale(), and G4GDMLReadDefine::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/G4GDMLReadMaterials.hh
• source/persistency/gdml/src/G4GDMLReadMaterials.cc