#include <G4GDMLWriteMaterials.hh>

Inheritance diagram for G4GDMLWriteMaterials:

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

void	AddAuxiliary (G4GDMLAuxStructType myaux)

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	UserinfoWrite (xercesc::DOMElement *)

virtual void	AddExtension (xercesc::DOMElement , const G4LogicalVolume const)

G4String	GenerateName (const G4String &, const void *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 ()

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)

void	AddAuxInfo (G4GDMLAuxListType auxInfoList, xercesc::DOMElement element)

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

xercesc::DOMElement *	userinfoElement

XMLCh	tempStr [10000]

G4GDMLAuxListType	auxList

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

protected

Definition at line 45 of file G4GDMLWriteMaterials.cc.

   : G4GDMLWriteDefine(), materialsElement(0)
 {
 }

G4GDMLWriteMaterials::~G4GDMLWriteMaterials ( )

protectedvirtual

Definition at line 50 of file G4GDMLWriteMaterials.cc.

51 {

52 }

Member Function Documentation

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 55 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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 64 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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 100 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());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 91 of file G4GDMLWriteMaterials.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 73 of file G4GDMLWriteMaterials.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 82 of file G4GDMLWriteMaterials.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

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

protected

Definition at line 83 of file G4GDMLWriteMaterials.hh.

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

protected

Definition at line 82 of file G4GDMLWriteMaterials.hh.

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

protected

Definition at line 84 of file G4GDMLWriteMaterials.hh.

xercesc::DOMElement* G4GDMLWriteMaterials::materialsElement

protected

Definition at line 85 of file G4GDMLWriteMaterials.hh.

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

geant4.10.03.p01/source/persistency/gdml/include/G4GDMLWriteMaterials.hh
geant4.10.03.p01/source/persistency/gdml/src/G4GDMLWriteMaterials.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation