G4GDMLWriteMaterials Class Reference

#include <G4GDMLWriteMaterials.hh>

Inheritance diagram for G4GDMLWriteMaterials:

Public Member Functions
void	AddIsotope (const G4Isotope *const)
void	AddElement (const G4Element *const)
void	AddMaterial (const G4Material *const)
virtual void	MaterialsWrite (xercesc::DOMElement *)
Public Member Functions inherited from G4GDMLWriteDefine
G4ThreeVector	GetAngles (const G4RotationMatrix &)
void	ScaleWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &scl)
void	RotationWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &rot)
void	PositionWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &pos)
void	FirstrotationWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &rot)
void	FirstpositionWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &pos)
void	AddPosition (const G4String &name, const G4ThreeVector &pos)
virtual void	DefineWrite (xercesc::DOMElement *)
Public Member Functions inherited from G4GDMLWrite
G4Transform3D	Write (const G4String &filename, const G4LogicalVolume *const topLog, const G4String &schemaPath, const G4int depth, G4bool storeReferences=true)
void	AddModule (const G4VPhysicalVolume *const topVol)
void	AddModule (const G4int depth)
virtual void	DefineWrite (xercesc::DOMElement *)=0
virtual void	MaterialsWrite (xercesc::DOMElement *)=0
virtual void	SolidsWrite (xercesc::DOMElement *)=0
virtual void	StructureWrite (xercesc::DOMElement *)=0
virtual G4Transform3D	TraverseVolumeTree (const G4LogicalVolume *const, const G4int)=0
virtual void	SurfacesWrite ()=0
virtual void	SetupWrite (xercesc::DOMElement *, const G4LogicalVolume *const)=0
virtual void	ExtensionWrite (xercesc::DOMElement *)
virtual void	AddExtension (xercesc::DOMElement *, const G4LogicalVolume *const)

Protected Member Functions
	G4GDMLWriteMaterials ()
virtual	~G4GDMLWriteMaterials ()
void	AtomWrite (xercesc::DOMElement *, const G4double &)
void	DWrite (xercesc::DOMElement *, const G4double &)
void	PWrite (xercesc::DOMElement *, const G4double &)
void	TWrite (xercesc::DOMElement *, const G4double &)
void	MEEWrite (xercesc::DOMElement *, const G4double &)
void	IsotopeWrite (const G4Isotope *const)
void	ElementWrite (const G4Element *const)
void	MaterialWrite (const G4Material *const)
void	PropertyWrite (xercesc::DOMElement *, const G4Material *const)
void	PropertyVectorWrite (const G4String &, const G4PhysicsOrderedFreeVector *const)
Protected Member Functions inherited from G4GDMLWriteDefine
	G4GDMLWriteDefine ()
virtual	~G4GDMLWriteDefine ()
void	Scale_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)
void	Rotation_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)
void	Position_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)
Protected Member Functions inherited from G4GDMLWrite
	G4GDMLWrite ()
virtual	~G4GDMLWrite ()
VolumeMapType &	VolumeMap ()
G4String	GenerateName (const G4String &, const void *const)
xercesc::DOMAttr *	NewAttribute (const G4String &, const G4String &)
xercesc::DOMAttr *	NewAttribute (const G4String &, const G4double &)
xercesc::DOMElement *	NewElement (const G4String &)
G4String	Modularize (const G4VPhysicalVolume *const topvol, const G4int depth)
G4bool	FileExists (const G4String &) const
PhysVolumeMapType &	PvolumeMap ()
DepthMapType &	DepthMap ()

Protected Attributes
std::vector< const G4Isotope * >	isotopeList
std::vector< const G4Element * >	elementList
std::vector< const G4Material * >	materialList
xercesc::DOMElement *	materialsElement
Protected Attributes inherited from G4GDMLWriteDefine
xercesc::DOMElement *	defineElement
Protected Attributes inherited from G4GDMLWrite
G4String	SchemaLocation
xercesc::DOMDocument *	doc
xercesc::DOMElement *	extElement
XMLCh	tempStr [10000]

Additional Inherited Members
Static Public Member Functions inherited from G4GDMLWrite
static void	SetAddPointerToName (G4bool)
Static Protected Attributes inherited from G4GDMLWriteDefine
static const G4double	kRelativePrecision = DBL_EPSILON
static const G4double	kAngularPrecision = DBL_EPSILON
static const G4double	kLinearPrecision = DBL_EPSILON
Static Protected Attributes inherited from G4GDMLWrite
static G4bool	addPointerToName = true

Detailed Description

Definition at line 53 of file G4GDMLWriteMaterials.hh.

Constructor & Destructor Documentation

G4GDMLWriteMaterials()

G4GDMLWriteMaterials::G4GDMLWriteMaterials ( )

protected

Definition at line 45 of file G4GDMLWriteMaterials.cc.

  : G4GDMLWriteDefine(), materialsElement(0)
{
}

~G4GDMLWriteMaterials()

G4GDMLWriteMaterials::~G4GDMLWriteMaterials ( )

protectedvirtual

Definition at line 50 of file G4GDMLWriteMaterials.cc.

{
}

Member Function Documentation

AddElement()

void G4GDMLWriteMaterials::AddElement

(

const G4Element * const

elementPtr

)

Definition at line 296 of file G4GDMLWriteMaterials.cc.

{
   for (size_t i=0;i<elementList.size();i++)     // Check if element is
   {                                             // already in the list!
      if (elementList[i] == elementPtr) { return; }
   }
   elementList.push_back(elementPtr);
   ElementWrite(elementPtr);
}

Referenced by MaterialWrite().

AddIsotope()

void G4GDMLWriteMaterials::AddIsotope

(

const G4Isotope * const

isotopePtr

)

Definition at line 286 of file G4GDMLWriteMaterials.cc.

{
   for (size_t i=0; i<isotopeList.size(); i++)   // Check if isotope is
   {                                             // already in the list!
     if (isotopeList[i] == isotopePtr)  { return; }
   }
   isotopeList.push_back(isotopePtr);
   IsotopeWrite(isotopePtr);
}

Referenced by ElementWrite().

AddMaterial()

void G4GDMLWriteMaterials::AddMaterial

(

const G4Material * const

materialPtr

)

Definition at line 306 of file G4GDMLWriteMaterials.cc.

{
   for (size_t i=0;i<materialList.size();i++)    // Check if material is
   {                                             // already in the list!
      if (materialList[i] == materialPtr)  { return; }
   }
   materialList.push_back(materialPtr);
   MaterialWrite(materialPtr);
}

Referenced by G4GDMLWriteStructure::TraverseVolumeTree().

AtomWrite()

void G4GDMLWriteMaterials::AtomWrite ( xercesc::DOMElement *  element, const G4double &  a  )

protected

Definition at line 54 of file G4GDMLWriteMaterials.cc.

{
   xercesc::DOMElement* atomElement = NewElement("atom");
   atomElement->setAttributeNode(NewAttribute("unit","g/mole"));
   atomElement->setAttributeNode(NewAttribute("value",a*mole/g));
   element->appendChild(atomElement);
}

Referenced by ElementWrite(), IsotopeWrite(), and MaterialWrite().

DWrite()

void G4GDMLWriteMaterials::DWrite ( xercesc::DOMElement *  element, const G4double &  d  )

protected

Definition at line 63 of file G4GDMLWriteMaterials.cc.

{
   xercesc::DOMElement* DElement = NewElement("D");
   DElement->setAttributeNode(NewAttribute("unit","g/cm3"));
   DElement->setAttributeNode(NewAttribute("value",d*cm3/g));
   element->appendChild(DElement);
}

Referenced by MaterialWrite().

ElementWrite()

void G4GDMLWriteMaterials::ElementWrite ( const G4Element * const  elementPtr )

protected

Definition at line 112 of file G4GDMLWriteMaterials.cc.

{
   const G4String name = GenerateName(elementPtr->GetName(),elementPtr);
 
   xercesc::DOMElement* elementElement = NewElement("element");
   elementElement->setAttributeNode(NewAttribute("name",name));
 
   const size_t NumberOfIsotopes = elementPtr->GetNumberOfIsotopes();
 
   if (NumberOfIsotopes>0)
   {
      const G4double* RelativeAbundanceVector =
            elementPtr->GetRelativeAbundanceVector();             
      for (size_t i=0;i<NumberOfIsotopes;i++)
      {
         G4String fractionref = GenerateName(elementPtr->GetIsotope(i)->GetName(),
                                             elementPtr->GetIsotope(i));
         xercesc::DOMElement* fractionElement = NewElement("fraction");
         fractionElement->setAttributeNode(NewAttribute("n",
                                           RelativeAbundanceVector[i]));
         fractionElement->setAttributeNode(NewAttribute("ref",fractionref));
         elementElement->appendChild(fractionElement);
         AddIsotope(elementPtr->GetIsotope(i));
      }
   }
   else
   {
      elementElement->setAttributeNode(NewAttribute("Z",elementPtr->GetZ()));
      AtomWrite(elementElement,elementPtr->GetA());
   }
 
   materialsElement->appendChild(elementElement);
     // Append the element AFTER all the possible components are appended!
}

Referenced by AddElement().

IsotopeWrite()

void G4GDMLWriteMaterials::IsotopeWrite ( const G4Isotope * const  isotopePtr )

protected

Definition at line 99 of file G4GDMLWriteMaterials.cc.

{
   const G4String name = GenerateName(isotopePtr->GetName(),isotopePtr);
 
   xercesc::DOMElement* isotopeElement = NewElement("isotope");
   isotopeElement->setAttributeNode(NewAttribute("name",name));
   isotopeElement->setAttributeNode(NewAttribute("N",isotopePtr->GetN()));
   isotopeElement->setAttributeNode(NewAttribute("Z",isotopePtr->GetZ()));
   materialsElement->appendChild(isotopeElement);
   AtomWrite(isotopeElement,isotopePtr->GetA());
}

Referenced by AddIsotope().

MaterialsWrite()

void G4GDMLWriteMaterials::MaterialsWrite ( xercesc::DOMElement *  element )

virtual

Implements G4GDMLWrite.

Definition at line 274 of file G4GDMLWriteMaterials.cc.

{
   G4cout << "G4GDML: Writing materials..." << G4endl;
 
   materialsElement = NewElement("materials");
   element->appendChild(materialsElement);
 
   isotopeList.clear();
   elementList.clear();
   materialList.clear();
}

MaterialWrite()

void G4GDMLWriteMaterials::MaterialWrite ( const G4Material * const  materialPtr )

protected

Definition at line 147 of file G4GDMLWriteMaterials.cc.

{
   G4String state_str("undefined");
   const G4State state = materialPtr->GetState();
   if (state==kStateSolid) { state_str = "solid"; } else
   if (state==kStateLiquid) { state_str = "liquid"; } else
   if (state==kStateGas) { state_str = "gas"; }
 
   const G4String name = GenerateName(materialPtr->GetName(), materialPtr);
 
   xercesc::DOMElement* materialElement = NewElement("material");
   materialElement->setAttributeNode(NewAttribute("name",name));
   materialElement->setAttributeNode(NewAttribute("state",state_str));
 
   // Write any property attached to the material...
   //
   if (materialPtr->GetMaterialPropertiesTable())
   {
     PropertyWrite(materialElement, materialPtr);
   }
 
   if (materialPtr->GetTemperature() != STP_Temperature)
     { TWrite(materialElement,materialPtr->GetTemperature()); }
   if (materialPtr->GetPressure() != STP_Pressure)
     { PWrite(materialElement,materialPtr->GetPressure()); }
 
   // Write Ionisation potential (mean excitation energy)
   MEEWrite(materialElement,materialPtr->GetIonisation()->GetMeanExcitationEnergy());
   
   DWrite(materialElement,materialPtr->GetDensity());
  
   const size_t NumberOfElements = materialPtr->GetNumberOfElements();
 
   if ( (NumberOfElements>1)
      || ( materialPtr->GetElement(0)
        && materialPtr->GetElement(0)->GetNumberOfIsotopes()>1 ) )
   {
      const G4double* MassFractionVector = materialPtr->GetFractionVector();
 
      for (size_t i=0;i<NumberOfElements;i++)
      {
         const G4String fractionref =
                        GenerateName(materialPtr->GetElement(i)->GetName(),
                                     materialPtr->GetElement(i));
         xercesc::DOMElement* fractionElement = NewElement("fraction");
         fractionElement->setAttributeNode(NewAttribute("n",
                                           MassFractionVector[i]));
         fractionElement->setAttributeNode(NewAttribute("ref",fractionref));
         materialElement->appendChild(fractionElement);
         AddElement(materialPtr->GetElement(i));
      }
   }
   else
   {
      materialElement->setAttributeNode(NewAttribute("Z",materialPtr->GetZ()));
      AtomWrite(materialElement,materialPtr->GetA());
   }
 
   // Append the material AFTER all the possible components are appended!
   //
   materialsElement->appendChild(materialElement);
}

Referenced by AddMaterial().

MEEWrite()

void G4GDMLWriteMaterials::MEEWrite ( xercesc::DOMElement *  element, const G4double &  MEE  )

protected

Definition at line 90 of file G4GDMLWriteMaterials.cc.

{
   xercesc::DOMElement* PElement = NewElement("MEE");
   PElement->setAttributeNode(NewAttribute("unit","eV"));
   PElement->setAttributeNode(NewAttribute("value",MEE/electronvolt));
   element->appendChild(PElement);
}

Referenced by MaterialWrite().

PropertyVectorWrite()

void G4GDMLWriteMaterials::PropertyVectorWrite ( const G4String &  key, const G4PhysicsOrderedFreeVector * const  pvec  )

protected

Definition at line 210 of file G4GDMLWriteMaterials.cc.

{
   const G4String matrixref = GenerateName(key, pvec);
   xercesc::DOMElement* matrixElement = NewElement("matrix");
   matrixElement->setAttributeNode(NewAttribute("name", matrixref));
   matrixElement->setAttributeNode(NewAttribute("coldim", "2"));
   std::ostringstream pvalues;
   for (size_t i=0; i<pvec->GetVectorLength(); i++)
   {
       if (i!=0)  { pvalues << " "; }
       pvalues << pvec->Energy(i) << " " << (*pvec)[i];
   }
   matrixElement->setAttributeNode(NewAttribute("values", pvalues.str()));
 
   defineElement->appendChild(matrixElement);
}

Referenced by PropertyWrite().

PropertyWrite()

void G4GDMLWriteMaterials::PropertyWrite ( xercesc::DOMElement *  matElement, const G4Material * const  mat  )

protected

Definition at line 228 of file G4GDMLWriteMaterials.cc.

{
   xercesc::DOMElement* propElement;
   G4MaterialPropertiesTable* ptable = mat->GetMaterialPropertiesTable();
   const std::map< G4String, G4PhysicsOrderedFreeVector*,
                 std::less<G4String> >* pmap = ptable->GetPropertiesMap();
   const std::map< G4String, G4double,
                 std::less<G4String> >* cmap = ptable->GetPropertiesCMap();
   std::map< G4String, G4PhysicsOrderedFreeVector*,
                 std::less<G4String> >::const_iterator mpos;
   std::map< G4String, G4double,
                 std::less<G4String> >::const_iterator cpos;
   for (mpos=pmap->begin(); mpos!=pmap->end(); mpos++)
   {
      propElement = NewElement("property");
      propElement->setAttributeNode(NewAttribute("name", mpos->first));
      propElement->setAttributeNode(NewAttribute("ref",
                                    GenerateName(mpos->first, mpos->second)));
      if (mpos->second)
      {
         PropertyVectorWrite(mpos->first, mpos->second);
         matElement->appendChild(propElement);
      }
      else
      {
         G4String warn_message = "Null pointer for material property -"
                  + mpos->first + "- of material -" + mat->GetName() + "- !";
         G4Exception("G4GDMLWriteMaterials::PropertyWrite()", "NullPointer",
                     JustWarning, warn_message);
         continue;
      }
   }
   for (cpos=cmap->begin(); cpos!=cmap->end(); cpos++)
   {
      propElement = NewElement("property");
      propElement->setAttributeNode(NewAttribute("name", cpos->first));
      propElement->setAttributeNode(NewAttribute("ref", cpos->first));
      xercesc::DOMElement* constElement = NewElement("constant");
      constElement->setAttributeNode(NewAttribute("name", cpos->first));
      constElement->setAttributeNode(NewAttribute("value", cpos->second));
      defineElement->appendChild(constElement);
      matElement->appendChild(propElement);
   }
}

Referenced by MaterialWrite().

PWrite()

void G4GDMLWriteMaterials::PWrite ( xercesc::DOMElement *  element, const G4double &  P  )

protected

Definition at line 72 of file G4GDMLWriteMaterials.cc.

{
   xercesc::DOMElement* PElement = NewElement("P");
   PElement->setAttributeNode(NewAttribute("unit","pascal"));
   PElement->setAttributeNode(NewAttribute("value",P/pascal));
   element->appendChild(PElement);
}

Referenced by MaterialWrite().

TWrite()

void G4GDMLWriteMaterials::TWrite ( xercesc::DOMElement *  element, const G4double &  T  )

protected

Definition at line 81 of file G4GDMLWriteMaterials.cc.

{
   xercesc::DOMElement* TElement = NewElement("T");
   TElement->setAttributeNode(NewAttribute("unit","K"));
   TElement->setAttributeNode(NewAttribute("value",T/kelvin));
   element->appendChild(TElement);
}

Referenced by MaterialWrite().

Member Data Documentation

elementList

std::vector<const G4Element*> G4GDMLWriteMaterials::elementList

protected

Definition at line 83 of file G4GDMLWriteMaterials.hh.

Referenced by AddElement(), and MaterialsWrite().

isotopeList

std::vector<const G4Isotope*> G4GDMLWriteMaterials::isotopeList

protected

Definition at line 82 of file G4GDMLWriteMaterials.hh.

Referenced by AddIsotope(), and MaterialsWrite().

materialList

std::vector<const G4Material*> G4GDMLWriteMaterials::materialList

protected

Definition at line 84 of file G4GDMLWriteMaterials.hh.

Referenced by AddMaterial(), and MaterialsWrite().

materialsElement

xercesc::DOMElement* G4GDMLWriteMaterials::materialsElement

protected

Definition at line 85 of file G4GDMLWriteMaterials.hh.

Referenced by ElementWrite(), IsotopeWrite(), MaterialsWrite(), and MaterialWrite().

---

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

• G4GDMLWriteMaterials.hh
• G4GDMLWriteMaterials.cc