G4GDMLReadMaterials Class Reference

#include <G4GDMLReadMaterials.hh>

Inheritance diagram for G4GDMLReadMaterials:

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

Protected Member Functions
	G4GDMLReadMaterials ()
virtual	~G4GDMLReadMaterials ()
G4double	AtomRead (const xercesc::DOMElement *const)
G4int	CompositeRead (const xercesc::DOMElement *const, G4String &)
G4double	DRead (const xercesc::DOMElement *const)
G4double	PRead (const xercesc::DOMElement *const)
G4double	TRead (const xercesc::DOMElement *const)
G4double	MEERead (const xercesc::DOMElement *const)
void	ElementRead (const xercesc::DOMElement *const)
G4double	FractionRead (const xercesc::DOMElement *const, G4String &)
void	IsotopeRead (const xercesc::DOMElement *const)
void	MaterialRead (const xercesc::DOMElement *const)
void	MixtureRead (const xercesc::DOMElement *const, G4Element *)
void	MixtureRead (const xercesc::DOMElement *const, G4Material *)
void	PropertyRead (const xercesc::DOMElement *const, G4Material *)
Protected Member Functions inherited from G4GDMLReadDefine
	G4GDMLReadDefine ()
virtual	~G4GDMLReadDefine ()
G4RotationMatrix	GetRotationMatrix (const G4ThreeVector &)
void	VectorRead (const xercesc::DOMElement *const, G4ThreeVector &)
G4String	RefRead (const xercesc::DOMElement *const)
void	ConstantRead (const xercesc::DOMElement *const)
void	MatrixRead (const xercesc::DOMElement *const)
void	PositionRead (const xercesc::DOMElement *const)
void	RotationRead (const xercesc::DOMElement *const)
void	ScaleRead (const xercesc::DOMElement *const)
void	VariableRead (const xercesc::DOMElement *const)
void	QuantityRead (const xercesc::DOMElement *const)
void	ExpressionRead (const xercesc::DOMElement *const)
Protected Member Functions inherited from G4GDMLRead
	G4GDMLRead ()
virtual	~G4GDMLRead ()
G4String	Transcode (const XMLCh *const)
G4String	GenerateName (const G4String &name, G4bool strip=false)
G4String	Strip (const G4String &) const
void	GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)
void	LoopRead (const xercesc::DOMElement *const, void(G4GDMLRead::*)(const xercesc::DOMElement *const))
G4GDMLAuxStructType	AuxiliaryRead (const xercesc::DOMElement *const auxElem)

Additional Inherited Members
Protected Attributes inherited from G4GDMLReadDefine
std::map< G4String, G4double >	quantityMap
std::map< G4String, G4ThreeVector >	positionMap
std::map< G4String, G4ThreeVector >	rotationMap
std::map< G4String, G4ThreeVector >	scaleMap
std::map< G4String, G4GDMLMatrix >	matrixMap
Protected Attributes inherited from G4GDMLRead
G4GDMLEvaluator	eval
G4bool	validate = true
G4bool	check = false
G4bool	dostrip = true

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

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

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

Referenced by MixtureRead().

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

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

Referenced by MaterialsRead().

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

Referenced by MixtureRead().

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

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

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

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

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

Referenced by MaterialsRead().

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

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

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

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

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

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

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

Referenced by MaterialRead().

TRead()

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

protected

Definition at line 243 of file G4GDMLReadMaterials.cc.

{
  G4double value = STP_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;
}

Referenced by MaterialRead().

---

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

• G4GDMLReadMaterials.hh
• G4GDMLReadMaterials.cc