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)
void	AddAuxiliary (G4GDMLAuxStructType myaux)
void	SetOutputFileOverwrite (G4bool flag)
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	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)
void	PropertyConstWrite (const G4String &, const G4double, const G4MaterialPropertiesTable *)
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
std::vector< const G4PhysicsOrderedFreeVector * >	propertyList
xercesc::DOMElement *	materialsElement = nullptr
Protected Attributes inherited from G4GDMLWriteDefine
xercesc::DOMElement *	defineElement = nullptr
Protected Attributes inherited from G4GDMLWrite
G4String	SchemaLocation
xercesc::DOMDocument *	doc = nullptr
xercesc::DOMElement *	extElement = nullptr
xercesc::DOMElement *	userinfoElement = nullptr
XMLCh	tempStr [10000]
G4GDMLAuxListType	auxList
G4bool	overwriteOutputFile = false

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 48 of file G4GDMLWriteMaterials.hh.

Constructor & Destructor Documentation

G4GDMLWriteMaterials()

G4GDMLWriteMaterials::G4GDMLWriteMaterials ( )

protected

Definition at line 42 of file G4GDMLWriteMaterials.cc.

  : G4GDMLWriteDefine()
{
}

~G4GDMLWriteMaterials()

G4GDMLWriteMaterials::~G4GDMLWriteMaterials ( )

protectedvirtual

Definition at line 48 of file G4GDMLWriteMaterials.cc.

{
}

Member Function Documentation

AddElement()

void G4GDMLWriteMaterials::AddElement

(

const G4Element * const

elementPtr

)

Definition at line 358 of file G4GDMLWriteMaterials.cc.

{
  for(std::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 344 of file G4GDMLWriteMaterials.cc.

{
  for(std::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 372 of file G4GDMLWriteMaterials.cc.

{
  for(std::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 53 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 116 of file G4GDMLWriteMaterials.cc.

{
  const G4String name = GenerateName(elementPtr->GetName(), elementPtr);
 
  xercesc::DOMElement* elementElement = NewElement("element");
  elementElement->setAttributeNode(NewAttribute("name", name));
 
  const std::size_t NumberOfIsotopes = elementPtr->GetNumberOfIsotopes();
 
  if(NumberOfIsotopes > 0)
  {
    const G4double* RelativeAbundanceVector
      = elementPtr->GetRelativeAbundanceVector();
    for(std::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 103 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 329 of file G4GDMLWriteMaterials.cc.

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

MaterialWrite()

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

protected

Definition at line 152 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 std::size_t NumberOfElements = materialPtr->GetNumberOfElements();
 
  if((NumberOfElements > 1) ||
     (materialPtr->GetElement(0) != nullptr &&
      materialPtr->GetElement(0)->GetNumberOfIsotopes() > 1))
  {
    const G4double* MassFractionVector = materialPtr->GetFractionVector();
 
    for(std::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 93 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().

PropertyConstWrite()

void G4GDMLWriteMaterials::PropertyConstWrite ( const G4String &  key, const G4double  pval, const G4MaterialPropertiesTable *  ptable  )

protected

Definition at line 261 of file G4GDMLWriteMaterials.cc.

{
  const G4String matrixref           = GenerateName(key, ptable);
  xercesc::DOMElement* matrixElement = NewElement("matrix");
  matrixElement->setAttributeNode(NewAttribute("name", matrixref));
  matrixElement->setAttributeNode(NewAttribute("coldim", "1"));
  std::ostringstream pvalues;
 
  pvalues << pval;
  matrixElement->setAttributeNode(NewAttribute("values", pvalues.str()));
 
  defineElement->appendChild(matrixElement);
}

Referenced by PropertyWrite().

PropertyVectorWrite()

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

protected

Definition at line 230 of file G4GDMLWriteMaterials.cc.

{
  for(std::size_t i = 0; i < propertyList.size(); ++i)  // Check if property is
  {                                                     // already in the list!
    if(propertyList[i] == pvec)
    {
      return;
    }
  }
  propertyList.push_back(pvec);
 
  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(std::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(), and G4GDMLWriteSolids::PropertyWrite().

PropertyWrite()

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

protected

Definition at line 278 of file G4GDMLWriteMaterials.cc.

{
  xercesc::DOMElement* propElement;
  G4MaterialPropertiesTable* ptable = mat->GetMaterialPropertiesTable();
 
  auto pmap = ptable->GetPropertyMap();
  auto cmap = ptable->GetConstPropertyMap();
 
  for(auto mpos = pmap->cbegin(); mpos != pmap->cend(); ++mpos)
  {
    propElement = NewElement("property");
    propElement->setAttributeNode(
      NewAttribute("name", ptable->GetMaterialPropertyNames()[mpos->first]));
    propElement->setAttributeNode(NewAttribute(
      "ref", GenerateName(ptable->GetMaterialPropertyNames()[mpos->first],
                          mpos->second)));
    if(mpos->second)
    {
      PropertyVectorWrite(ptable->GetMaterialPropertyNames()[mpos->first],
                          mpos->second);
      matElement->appendChild(propElement);
    }
    else
    {
      G4String warn_message = "Null pointer for material property -" +
                              ptable->GetMaterialPropertyNames()[mpos->first] +
                              "- of material -" + mat->GetName() + "- !";
      G4Exception("G4GDMLWriteMaterials::PropertyWrite()", "NullPointer",
                  JustWarning, warn_message);
      continue;
    }
  }
 
  for(auto cpos = cmap->cbegin(); cpos != cmap->cend(); ++cpos)
  {
    propElement = NewElement("property");
    propElement->setAttributeNode(NewAttribute(
      "name", ptable->GetMaterialConstPropertyNames()[cpos->first]));
    propElement->setAttributeNode(NewAttribute(
      "ref", GenerateName(ptable->GetMaterialConstPropertyNames()[cpos->first],
                          ptable)));
 
    PropertyConstWrite(ptable->GetMaterialConstPropertyNames()[cpos->first],
                       cpos->second, ptable);
 
    matElement->appendChild(propElement);
  }
}

Referenced by MaterialWrite().

PWrite()

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

Referenced by MaterialWrite().

TWrite()

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

protected

Definition at line 83 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 80 of file G4GDMLWriteMaterials.hh.

Referenced by AddElement(), and MaterialsWrite().

isotopeList

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

protected

Definition at line 79 of file G4GDMLWriteMaterials.hh.

Referenced by AddIsotope(), and MaterialsWrite().

materialList

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

protected

Definition at line 81 of file G4GDMLWriteMaterials.hh.

Referenced by AddMaterial(), and MaterialsWrite().

materialsElement

xercesc::DOMElement* G4GDMLWriteMaterials::materialsElement = nullptr

protected

Definition at line 83 of file G4GDMLWriteMaterials.hh.

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

propertyList

std::vector<const G4PhysicsOrderedFreeVector*> G4GDMLWriteMaterials::propertyList

protected

Definition at line 82 of file G4GDMLWriteMaterials.hh.

Referenced by MaterialsWrite(), and PropertyVectorWrite().

---

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

• G4GDMLWriteMaterials.hh
• G4GDMLWriteMaterials.cc