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)
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 *)

---

Detailed Description

Definition at line 51 of file G4GDMLReadMaterials.hh.

---

Constructor & Destructor Documentation

G4GDMLReadMaterials::G4GDMLReadMaterials

(

)

[protected]

Definition at line 45 of file G4GDMLReadMaterials.cc.

                                         : G4GDMLReadDefine()
{
}

G4GDMLReadMaterials::~G4GDMLReadMaterials

(

)

[protected, virtual]

Definition at line 49 of file G4GDMLReadMaterials.cc.

{
}

---

Member Function Documentation

G4double G4GDMLReadMaterials::AtomRead

(

const xercesc::DOMElement *

const

)

[protected]

Definition at line 54 of file G4GDMLReadMaterials.cc.

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

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

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

G4int G4GDMLReadMaterials::CompositeRead	(	const xercesc::DOMElement *	const,
		G4String &
	)			[protected]

Definition at line 90 of file G4GDMLReadMaterials.cc.

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

Referenced by MixtureRead().

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

G4double G4GDMLReadMaterials::DRead

(

const xercesc::DOMElement *

const

)

[protected]

Definition at line 124 of file G4GDMLReadMaterials.cc.

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

Referenced by MaterialRead().

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

void G4GDMLReadMaterials::ElementRead

(

const xercesc::DOMElement *

const

)

[protected]

Definition at line 262 of file G4GDMLReadMaterials.cc.

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

Referenced by MaterialsRead().

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

G4double G4GDMLReadMaterials::FractionRead	(	const xercesc::DOMElement *	const,
		G4String &
	)			[protected]

Definition at line 330 of file G4GDMLReadMaterials.cc.

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

Referenced by MixtureRead().

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

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

Definition at line 709 of file G4GDMLReadMaterials.cc.

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

Referenced by MixtureRead().

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

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

Definition at line 728 of file G4GDMLReadMaterials.cc.

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

Referenced by MixtureRead().

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

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

Definition at line 743 of file G4GDMLReadMaterials.cc.

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

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

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

void G4GDMLReadMaterials::IsotopeRead

(

const xercesc::DOMElement *

const

)

[protected]

Definition at line 365 of file G4GDMLReadMaterials.cc.

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

Referenced by MaterialsRead().

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

void G4GDMLReadMaterials::MaterialRead

(

const xercesc::DOMElement *

const

)

[protected]

Definition at line 422 of file G4GDMLReadMaterials.cc.

References AtomRead(), DRead(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4Material::GetIonisation(), G4GDMLReadDefine::GetQuantity(), kStateGas, kStateLiquid, kStateSolid, kStateUndefined, MEERead(), MixtureRead(), PRead(), PropertyRead(), G4GDMLReadDefine::RefRead(), G4IonisParamMat::SetMeanExcitationEnergy(), G4GDMLRead::Strip(), G4GDMLRead::Transcode(), and TRead().

Referenced by MaterialsRead().

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

void G4GDMLReadMaterials::MaterialsRead

(

const xercesc::DOMElement *

const

)

[virtual]

Implements G4GDMLRead.

Definition at line 676 of file G4GDMLReadMaterials.cc.

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

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

G4double G4GDMLReadMaterials::MEERead

(

const xercesc::DOMElement *

const

)

[protected]

Definition at line 227 of file G4GDMLReadMaterials.cc.

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

Referenced by MaterialRead().

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

void G4GDMLReadMaterials::MixtureRead	(	const xercesc::DOMElement *	const,
		G4Material *
	)			[protected]

Definition at line 558 of file G4GDMLReadMaterials.cc.

References G4Material::AddElement(), G4Material::AddMaterial(), CompositeRead(), FatalException, FractionRead(), G4Exception(), G4GDMLRead::GenerateName(), GetElement(), GetMaterial(), CLHEP::detail::n, and G4GDMLRead::Transcode().

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

void G4GDMLReadMaterials::MixtureRead	(	const xercesc::DOMElement *	const,
		G4Element *
	)			[protected]

Definition at line 531 of file G4GDMLReadMaterials.cc.

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

Referenced by ElementRead(), and MaterialRead().

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

G4double G4GDMLReadMaterials::PRead

(

const xercesc::DOMElement *

const

)

[protected]

Definition at line 159 of file G4GDMLReadMaterials.cc.

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), pascal, and G4GDMLRead::Transcode().

Referenced by MaterialRead().

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

void G4GDMLReadMaterials::PropertyRead	(	const xercesc::DOMElement *	const,
		G4Material *
	)			[protected]

Definition at line 607 of file G4GDMLReadMaterials.cc.

References G4MaterialPropertiesTable::AddConstProperty(), G4MaterialPropertiesTable::AddProperty(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLMatrix::Get(), G4GDMLMatrix::GetCols(), G4Material::GetMaterialPropertiesTable(), G4GDMLReadDefine::GetMatrix(), G4GDMLMatrix::GetRows(), G4PhysicsOrderedFreeVector::InsertValues(), G4Material::SetMaterialPropertiesTable(), G4GDMLRead::Strip(), and G4GDMLRead::Transcode().

Referenced by MaterialRead().

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

G4double G4GDMLReadMaterials::TRead

(

const xercesc::DOMElement *

const

)

[protected]

Definition at line 193 of file G4GDMLReadMaterials.cc.

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

Referenced by MaterialRead().

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

---

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

• G4GDMLReadMaterials.hh
• G4GDMLReadMaterials.cc

---