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

virtual G4String	GetSetup (const G4String &)=0

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

void	StripNames () const

void	OverlapCheck (G4bool)

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

void	GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)

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

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

G4bool	check

Detailed Description

Definition at line 51 of file G4GDMLReadMaterials.hh.

Constructor & Destructor Documentation

◆ G4GDMLReadMaterials()

G4GDMLReadMaterials::G4GDMLReadMaterials ( )

protected

Definition at line 45 of file G4GDMLReadMaterials.cc.

                                         : G4GDMLReadDefine()
{
}

◆ ~G4GDMLReadMaterials()

G4GDMLReadMaterials::~G4GDMLReadMaterials ( )

protectedvirtual

Definition at line 49 of file G4GDMLReadMaterials.cc.

50{

51}

Member Function Documentation

◆ AtomRead()

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

protected

Definition at line 54 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)
      {
        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 = eval.Evaluate(attValue); }
   }
 
   return value*unit;
}

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

◆ CompositeRead()

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

protected

Definition at line 89 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)
      {
        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 124 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)
      {
        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 = eval.Evaluate(attValue); }
   }
 
   return value*unit;
}

Referenced by MaterialRead().

◆ ElementRead()

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

protected

Definition at line 261 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)
      {
        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 != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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 329 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)
      {
        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 708 of file G4GDMLReadMaterials.cc.

{
   G4Element* elementPtr = G4Element::GetElement(ref,false);
 
   if (!elementPtr)
   {
     elementPtr = G4NistManager::Instance()->FindOrBuildElement(ref);
   }
 
   if (verbose && !elementPtr)
   {
     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 728 of file G4GDMLReadMaterials.cc.

{
   G4Isotope* isotopePtr = G4Isotope::GetIsotope(ref,false);
 
   if (verbose && !isotopePtr)
   {
     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 743 of file G4GDMLReadMaterials.cc.

{
   G4Material *materialPtr = G4Material::GetMaterial(ref,false);
 
   if (!materialPtr)
   {
     materialPtr = G4NistManager::Instance()->FindOrBuildMaterial(ref);
   }
 
   if (verbose && !materialPtr)
   {
     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 364 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)
      {
        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 != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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 421 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)
      {
        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; }
      }
   }
 
   size_t nComponents = 0;
 
   for (xercesc::DOMNode* iter = materialElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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 =  0;
 
   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 != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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 675 of file G4GDMLReadMaterials.cc.

{
   G4cout << "G4GDML: Reading materials..." << G4endl;
 
   for (xercesc::DOMNode* iter = materialsElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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 227 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)
      {
        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 = eval.Evaluate(attValue); }
   }
 
   return value*unit;
}

Referenced by MaterialRead().

◆ MixtureRead() [1/2]

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

protected

Definition at line 530 of file G4GDMLReadMaterials.cc.

{
   for (xercesc::DOMNode* iter = mixtureElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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 557 of file G4GDMLReadMaterials.cc.

{
   for (xercesc::DOMNode* iter = mixtureElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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 (materialPtr != 0) { material->AddMaterial(materialPtr,n); } else
         if (elementPtr != 0)  { material->AddElement(elementPtr,n); }
 
         if ((materialPtr == 0) && (elementPtr == 0))
         {
            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 159 of file G4GDMLReadMaterials.cc.

{
   G4double value = STP_Pressure;
   G4double unit = 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)
      {
        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 = eval.Evaluate(attValue); }
   }
 
   return value*unit;
}

Referenced by MaterialRead().

◆ PropertyRead()

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

protected

Definition at line 606 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)
      {
        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)
   {
     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 (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 193 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)
      {
        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 = eval.Evaluate(attValue); }
   }
 
   return value*unit;
}

Referenced by MaterialRead().

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

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4GDMLReadMaterials()

◆ ~G4GDMLReadMaterials()

Member Function Documentation

◆ AtomRead()

◆ CompositeRead()

◆ DRead()

◆ ElementRead()

◆ FractionRead()

◆ GetElement()

◆ GetIsotope()

◆ GetMaterial()

◆ IsotopeRead()

◆ MaterialRead()

◆ MaterialsRead()

◆ MEERead()

◆ MixtureRead() [1/2]

◆ MixtureRead() [2/2]

◆ PRead()

◆ PropertyRead()

◆ TRead()