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

protected

Definition at line 45 of file G4GDMLReadMaterials.cc.

                                          : G4GDMLReadDefine()
 {
 }

G4GDMLReadMaterials::~G4GDMLReadMaterials ( )

protectedvirtual

Definition at line 49 of file G4GDMLReadMaterials.cc.

50 {

51 }

Member Function Documentation

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

protected

Definition at line 54 of file G4GDMLReadMaterials.cc.

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, g(), G4Exception(), python.hepunit::mole, 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	compositeElement,
		G4String &	ref
	)

protected

Definition at line 90 of file G4GDMLReadMaterials.cc.

References G4GDMLRead::eval, G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), 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 DElement )

protected

Definition at line 124 of file G4GDMLReadMaterials.cc.

References python.hepunit::cm3, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, g(), 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 elementElement )

protected

Definition at line 262 of file G4GDMLReadMaterials.cc.

References test::a, AtomRead(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), MixtureRead(), nComponents, 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	fractionElement,
		G4String &	ref
	)

protected

Definition at line 330 of file G4GDMLReadMaterials.cc.

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), 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 &	ref,
		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 &	ref,
		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 &	ref,
		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(), G03ColorReader::VolumeRead(), 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 isotopeElement )

protected

Definition at line 365 of file G4GDMLReadMaterials.cc.

References test::a, AtomRead(), G4GDMLRead::eval, G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), N, 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 materialElement )

protected

Definition at line 422 of file G4GDMLReadMaterials.cc.

References test::a, AtomRead(), DRead(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4Material::GetIonisation(), G4GDMLReadDefine::GetQuantity(), kStateGas, kStateLiquid, kStateSolid, kStateUndefined, eplot::material, MEERead(), MixtureRead(), nComponents, PRead(), PropertyRead(), G4GDMLReadDefine::RefRead(), G4IonisParamMat::SetMeanExcitationEnergy(), python.hepunit::STP_Pressure, python.hepunit::STP_Temperature, 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 materialsElement )

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

protected

Definition at line 227 of file G4GDMLReadMaterials.cc.

References python.hepunit::eV, 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	mixtureElement,
		G4Element *	element
	)

protected

Definition at line 531 of file G4GDMLReadMaterials.cc.

References G4Element::AddIsotope(), FatalException, FractionRead(), G4Exception(), G4GDMLRead::GenerateName(), GetIsotope(), 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);
       }
    }
 }

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

protected

Definition at line 558 of file G4GDMLReadMaterials.cc.

References G4Material::AddElement(), G4Material::AddMaterial(), CompositeRead(), FatalException, FractionRead(), G4Exception(), G4GDMLRead::GenerateName(), GetElement(), GetMaterial(), 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);
       }
    }
 }

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

protected

Definition at line 159 of file G4GDMLReadMaterials.cc.

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

Referenced by MaterialRead().

 {
    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)
       {
         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	propertyElement,
		G4Material *	material
	)

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

protected

Definition at line 193 of file G4GDMLReadMaterials.cc.

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), python.hepunit::kelvin, python.hepunit::STP_Temperature, 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:

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation