#include <G4GDMLWriteMaterials.hh>

Inheritance diagram for G4GDMLWriteMaterials:

Public Member Functions
void	AddAuxiliary (G4GDMLAuxStructType myaux)

void	AddElement (const G4Element *const)

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

void	AddIsotope (const G4Isotope *const)

void	AddMaterial (const G4Material *const)

void	AddModule (const G4int depth)

void	AddModule (const G4VPhysicalVolume *const topVol)

void	AddPosition (const G4String &name, const G4ThreeVector &pos)

virtual void	DefineWrite (xercesc::DOMElement *)

virtual void	ExtensionWrite (xercesc::DOMElement *)

void	FirstpositionWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &pos)

void	FirstrotationWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &rot)

G4String	GenerateName (const G4String &, const void *const)

G4ThreeVector	GetAngles (const G4RotationMatrix &)

virtual void	MaterialsWrite (xercesc::DOMElement *)

void	PositionWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &pos)

void	RotationWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &rot)

void	ScaleWrite (xercesc::DOMElement *element, const G4String &name, const G4ThreeVector &scl)

void	SetOutputFileOverwrite (G4bool flag)

virtual void	SetupWrite (xercesc::DOMElement , const G4LogicalVolume const)=0

virtual void	SolidsWrite (xercesc::DOMElement *)=0

virtual void	StructureWrite (xercesc::DOMElement *)=0

virtual void	SurfacesWrite ()=0

virtual G4Transform3D	TraverseVolumeTree (const G4LogicalVolume *const, const G4int)=0

virtual void	UserinfoWrite (xercesc::DOMElement *)

G4Transform3D	Write (const G4String &filename, const G4LogicalVolume *const topLog, const G4String &schemaPath, const G4int depth, G4bool storeReferences=true)

Static Public Member Functions
static void	SetAddPointerToName (G4bool)

Protected Member Functions
void	AddAuxInfo (G4GDMLAuxListType auxInfoList, xercesc::DOMElement element)

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

DepthMapType &	DepthMap ()

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

void	ElementWrite (const G4Element *const)

G4bool	FileExists (const G4String &) const

	G4GDMLWriteMaterials ()

void	IsotopeWrite (const G4Isotope *const)

void	MaterialWrite (const G4Material *const)

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

G4String	Modularize (const G4VPhysicalVolume *const topvol, const G4int depth)

xercesc::DOMAttr *	NewAttribute (const G4String &, const G4double &)

xercesc::DOMAttr *	NewAttribute (const G4String &, const G4String &)

xercesc::DOMElement *	NewElement (const G4String &)

void	Position_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)

void	PropertyConstWrite (const G4String &, const G4double, const G4MaterialPropertiesTable *)

void	PropertyVectorWrite (const G4String &, const G4PhysicsFreeVector *const)

void	PropertyWrite (xercesc::DOMElement , const G4Material const)

PhysVolumeMapType &	PvolumeMap ()

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

void	Rotation_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)

void	Scale_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)

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

VolumeMapType &	VolumeMap ()

virtual	~G4GDMLWriteMaterials ()

Protected Attributes
G4GDMLAuxListType	auxList

xercesc::DOMElement *	defineElement = nullptr

xercesc::DOMDocument *	doc = nullptr

std::vector< const G4Element * >	elementList

xercesc::DOMElement *	extElement = nullptr

std::vector< const G4Isotope * >	isotopeList

std::vector< const G4Material * >	materialList

xercesc::DOMElement *	materialsElement = nullptr

G4bool	overwriteOutputFile = false

std::vector< const G4PhysicsFreeVector * >	propertyList

G4String	SchemaLocation

xercesc::DOMElement *	userinfoElement = nullptr

Static Protected Attributes
static G4bool	addPointerToName = true

static const G4double	kAngularPrecision = DBL_EPSILON

static const G4double	kLinearPrecision = DBL_EPSILON

static const G4double	kRelativePrecision = DBL_EPSILON

Private Types
using	DepthMapType = std::map< G4int, G4int >

using	PhysVolumeMapType = std::map< const G4VPhysicalVolume *, G4String >

using	VolumeMapType = std::map< const G4LogicalVolume *, G4Transform3D >

Detailed Description

Definition at line 48 of file G4GDMLWriteMaterials.hh.

Member Typedef Documentation

◆ DepthMapType

using G4GDMLWrite::DepthMapType = std::map<G4int, G4int>

privateinherited

Definition at line 55 of file G4GDMLWrite.hh.

◆ PhysVolumeMapType

using G4GDMLWrite::PhysVolumeMapType = std::map<const G4VPhysicalVolume*, G4String>

privateinherited

Definition at line 54 of file G4GDMLWrite.hh.

◆ VolumeMapType

using G4GDMLWrite::VolumeMapType = std::map<const G4LogicalVolume*, G4Transform3D>

privateinherited

Definition at line 53 of file G4GDMLWrite.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.

49{

50}

Member Function Documentation

◆ AddAuxiliary()

void G4GDMLWrite::AddAuxiliary ( G4GDMLAuxStructType myaux )

inherited

Definition at line 398 of file G4GDMLWrite.cc.

{
  auxList.push_back(myaux);
}

References G4GDMLWrite::auxList.

◆ AddAuxInfo()

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

protectedinherited

Definition at line 94 of file G4GDMLWrite.cc.

{
  for(auto iaux = auxInfoList->cbegin(); iaux != auxInfoList->cend(); ++iaux)
  {
    xercesc::DOMElement* auxiliaryElement = NewElement("auxiliary");
    element->appendChild(auxiliaryElement);
 
    auxiliaryElement->setAttributeNode(NewAttribute("auxtype", (*iaux).type));
    auxiliaryElement->setAttributeNode(NewAttribute("auxvalue", (*iaux).value));
    if(((*iaux).unit) != "")
    {
      auxiliaryElement->setAttributeNode(NewAttribute("auxunit", (*iaux).unit));
    }
 
    if(iaux->auxList)
    {
      AddAuxInfo(iaux->auxList, auxiliaryElement);
    }
  }
  return;
}

References G4GDMLWrite::AddAuxInfo(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWrite::AddAuxInfo(), G4GDMLWriteStructure::TraverseVolumeTree(), and G4GDMLWrite::UserinfoWrite().

◆ AddElement()

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

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

References elementList, and ElementWrite().

Referenced by MaterialWrite().

◆ AddExtension()

void G4GDMLWrite::AddExtension	(	xercesc::DOMElement *	,
		const G4LogicalVolume * const
	)

virtualinherited

Definition at line 80 of file G4GDMLWrite.cc.

{
  // Empty implementation. To be overwritten by user for specific extensions
  // related to attributes associated to volumes
}

Referenced by G4GDMLWriteStructure::TraverseVolumeTree().

◆ AddIsotope()

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

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

References isotopeList, and IsotopeWrite().

Referenced by ElementWrite().

◆ AddMaterial()

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

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

References materialList, and MaterialWrite().

Referenced by G4GDMLWriteStructure::TraverseVolumeTree().

◆ AddModule() [1/2]

void G4GDMLWrite::AddModule ( const G4int depth )

inherited

Definition at line 361 of file G4GDMLWrite.cc.

{
  if(depth < 0)
  {
    G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                "Depth must be a positive number!");
  }
  if(DepthMap().find(depth) != DepthMap().end())
  {
    G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                "Adding module(s) at this depth is already requested!");
  }
  DepthMap()[depth] = 0;
}

References G4GDMLWrite::DepthMap(), FatalException, and G4Exception().

◆ AddModule() [2/2]

void G4GDMLWrite::AddModule ( const G4VPhysicalVolume *const topVol )

inherited

Definition at line 327 of file G4GDMLWrite.cc.

{
  G4String fname = GenerateName(physvol->GetName(), physvol);
  G4cout << "G4GDML: Adding module '" << fname << "'..." << G4endl;
 
  if(physvol == nullptr)
  {
    G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                "Invalid NULL pointer is specified for modularization!");
    return;
  }
  if(dynamic_cast<const G4PVDivision*>(physvol))
  {
    G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                "It is not possible to modularize by divisionvol!");
    return;
  }
  if(physvol->IsParameterised())
  {
    G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                "It is not possible to modularize by parameterised volume!");
    return;
  }
  if(physvol->IsReplicated())
  {
    G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                "It is not possible to modularize by replicated volume!");
    return;
  }
 
  PvolumeMap()[physvol] = fname;
}

References FatalException, test::fname, G4cout, G4endl, G4Exception(), G4GDMLWrite::GenerateName(), G4VPhysicalVolume::GetName(), G4VPhysicalVolume::IsParameterised(), G4VPhysicalVolume::IsReplicated(), and G4GDMLWrite::PvolumeMap().

◆ AddPosition()

void G4GDMLWriteDefine::AddPosition	(	const G4String &	name,
		const G4ThreeVector &	pos
	)

inlineinherited

Definition at line 73 of file G4GDMLWriteDefine.hh.

    {
      Position_vectorWrite(defineElement, "position", name, pos);
    }

References G4GDMLWriteDefine::defineElement, G4InuclParticleNames::name(), pos, and G4GDMLWriteDefine::Position_vectorWrite().

Referenced by G4GDMLWriteSolids::TessellatedWrite(), and G4GDMLWriteSolids::TetWrite().

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

References g, mole, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

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

◆ DefineWrite()

void G4GDMLWriteDefine::DefineWrite ( xercesc::DOMElement * element )

virtualinherited

Implements G4GDMLWrite.

Definition at line 137 of file G4GDMLWriteDefine.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Writing definitions..." << G4endl;
#endif
  defineElement = NewElement("define");
  element->appendChild(defineElement);
}

References G4GDMLWriteDefine::defineElement, G4cout, G4endl, and G4GDMLWrite::NewElement().

◆ DepthMap()

G4GDMLWrite::DepthMapType & G4GDMLWrite::DepthMap ( )

protectedinherited

Definition at line 73 of file G4GDMLWrite.cc.

{
  static DepthMapType instance;
  return instance;
}

Referenced by G4GDMLWrite::AddModule(), and G4GDMLWrite::Modularize().

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

References cm3, g, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

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

References AddIsotope(), AtomWrite(), G4GDMLWrite::GenerateName(), G4Element::GetA(), G4Element::GetIsotope(), G4Element::GetName(), G4Isotope::GetName(), G4Element::GetNumberOfIsotopes(), G4Element::GetRelativeAbundanceVector(), G4Element::GetZ(), materialsElement, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by AddElement().

◆ ExtensionWrite()

void G4GDMLWrite::ExtensionWrite ( xercesc::DOMElement * )

virtualinherited

Definition at line 88 of file G4GDMLWrite.cc.

{
  // Empty implementation. To be overwritten by user for specific extensions
}

Referenced by G4GDMLWrite::Write().

◆ FileExists()

G4bool G4GDMLWrite::FileExists ( const G4String & fname ) const

protectedinherited

Definition at line 53 of file G4GDMLWrite.cc.

{
  struct stat FileInfo;
  return (stat(fname.c_str(), &FileInfo) == 0);
}

References test::fname.

Referenced by G4GDMLWrite::Write().

◆ FirstpositionWrite()

void G4GDMLWriteDefine::FirstpositionWrite	(	xercesc::DOMElement *	element,
		const G4String &	name,
		const G4ThreeVector &	pos
	)

inlineinherited

Definition at line 68 of file G4GDMLWriteDefine.hh.

    {
      Position_vectorWrite(element, "firstposition", name, pos);
    }

References G4InuclParticleNames::name(), pos, and G4GDMLWriteDefine::Position_vectorWrite().

Referenced by G4GDMLWriteSolids::BooleanWrite().

◆ FirstrotationWrite()

void G4GDMLWriteDefine::FirstrotationWrite	(	xercesc::DOMElement *	element,
		const G4String &	name,
		const G4ThreeVector &	rot
	)

inlineinherited

Definition at line 63 of file G4GDMLWriteDefine.hh.

    {
      Rotation_vectorWrite(element, "firstrotation", name, rot);
    }

References G4InuclParticleNames::name(), and G4GDMLWriteDefine::Rotation_vectorWrite().

Referenced by G4GDMLWriteSolids::BooleanWrite().

◆ GenerateName()

G4String G4GDMLWrite::GenerateName	(	const G4String &	name,
		const void * const	ptr
	)

inherited

Definition at line 132 of file G4GDMLWrite.cc.

{
  G4String nameOut;
  std::stringstream stream;
  stream << name;
  if(addPointerToName)
  {
    stream << ptr;
  };
 
  nameOut = G4String(stream.str());
  std::vector<char> toremove = { ' ', '/', ':', '#', '+' };
  for(auto c : toremove)
  {
    if(G4StrUtil::contains(nameOut, c))
    {
      std::replace(nameOut.begin(), nameOut.end(), c, '_');
    }
  }
  return nameOut;
}

References G4GDMLWrite::addPointerToName, G4StrUtil::contains(), and G4InuclParticleNames::name().

◆ GetAngles()

G4ThreeVector G4GDMLWriteDefine::GetAngles ( const G4RotationMatrix & mtx )

inherited

Definition at line 50 of file G4GDMLWriteDefine.cc.

{
  G4double x, y, z;
  G4RotationMatrix mat = mtx;
  mat.rectify();  // Rectify matrix from possible roundoff errors
 
  // Direction of rotation given by left-hand rule; clockwise rotation
 
  static const G4double kMatrixPrecision = 10E-10;
  const G4double cosb = std::sqrt(mtx.xx() * mtx.xx() + mtx.yx() * mtx.yx());
 
  if(cosb > kMatrixPrecision)
  {
    x = std::atan2(mtx.zy(), mtx.zz());
    y = std::atan2(-mtx.zx(), cosb);
    z = std::atan2(mtx.yx(), mtx.xx());
  }
  else
  {
    x = std::atan2(-mtx.yz(), mtx.yy());
    y = std::atan2(-mtx.zx(), cosb);
    z = 0.0;
  }
 
  return G4ThreeVector(x, y, z);
}

References CLHEP::HepRotation::rectify(), CLHEP::HepRotation::xx(), CLHEP::HepRotation::yx(), CLHEP::HepRotation::yy(), CLHEP::HepRotation::yz(), CLHEP::HepRotation::zx(), CLHEP::HepRotation::zy(), and CLHEP::HepRotation::zz().

Referenced by G4GDMLWriteStructure::AssemblyWrite(), G4GDMLWriteSolids::BooleanWrite(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteParamvol::ParametersWrite(), G4GDMLWriteStructure::PhysvolWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

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

References AtomWrite(), G4GDMLWrite::GenerateName(), G4Isotope::GetA(), G4Isotope::GetN(), G4Isotope::GetName(), G4Isotope::GetZ(), materialsElement, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by AddIsotope().

◆ MaterialsWrite()

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

virtual

Implements G4GDMLWrite.

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

References elementList, G4cout, G4endl, isotopeList, materialList, materialsElement, G4GDMLWrite::NewElement(), and propertyList.

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

References AddElement(), AtomWrite(), DWrite(), G4GDMLWrite::GenerateName(), G4Material::GetA(), G4Material::GetDensity(), G4Material::GetElement(), G4Material::GetFractionVector(), G4Material::GetIonisation(), G4Material::GetMaterialPropertiesTable(), G4IonisParamMat::GetMeanExcitationEnergy(), G4Element::GetName(), G4Material::GetName(), G4Material::GetNumberOfElements(), G4Element::GetNumberOfIsotopes(), G4Material::GetPressure(), G4Material::GetState(), G4Material::GetTemperature(), G4Material::GetZ(), kStateGas, kStateLiquid, kStateSolid, materialsElement, MEEWrite(), G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), PropertyWrite(), PWrite(), source.hepunit::STP_Pressure, source.hepunit::STP_Temperature, and TWrite().

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

References electronvolt, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by MaterialWrite().

◆ Modularize()

G4String G4GDMLWrite::Modularize	(	const G4VPhysicalVolume *const	topvol,
		const G4int	depth
	)

protectedinherited

Definition at line 377 of file G4GDMLWrite.cc.

{
  if(PvolumeMap().find(physvol) != PvolumeMap().cend())
  {
    return PvolumeMap()[physvol];  // Modularize via physvol
  }
 
  if(DepthMap().find(depth) != DepthMap().cend())  // Modularize via depth
  {
    std::stringstream stream;
    stream << "depth" << depth << "_module" << DepthMap()[depth] << ".gdml";
    DepthMap()[depth]++;  // There can be more modules at this depth!
    return G4String(stream.str());
  }
 
  return G4String("");  // Empty string for module name = no modularization
                        // was requested at that level/physvol!
}

References G4GDMLWrite::DepthMap(), and G4GDMLWrite::PvolumeMap().

Referenced by G4GDMLWriteStructure::TraverseVolumeTree().

◆ NewAttribute() [1/2]

xercesc::DOMAttr * G4GDMLWrite::NewAttribute	(	const G4String &	name,
		const G4double &	value
	)

protectedinherited

Definition at line 171 of file G4GDMLWrite.cc.

{
  XMLCh* tempStr = NULL;
  tempStr = xercesc::XMLString::transcode(name);
  xercesc::DOMAttr* att = doc->createAttribute(tempStr);
  xercesc::XMLString::release(&tempStr);
 
  std::ostringstream ostream;
  ostream.precision(15);
  ostream << value;
  G4String str = ostream.str();
 
  tempStr = xercesc::XMLString::transcode(str);
  att->setValue(tempStr);
  xercesc::XMLString::release(&tempStr);
 
  return att;
}

References G4GDMLWrite::doc, and G4InuclParticleNames::name().

◆ NewAttribute() [2/2]

xercesc::DOMAttr * G4GDMLWrite::NewAttribute	(	const G4String &	name,
		const G4String &	value
	)

protectedinherited

Definition at line 155 of file G4GDMLWrite.cc.

{
  XMLCh* tempStr = NULL;
  tempStr = xercesc::XMLString::transcode(name);
  xercesc::DOMAttr* att = doc->createAttribute(tempStr);
  xercesc::XMLString::release(&tempStr);
 
  tempStr = xercesc::XMLString::transcode(value);
  att->setValue(tempStr);
  xercesc::XMLString::release(&tempStr);
 
  return att;
}

References G4GDMLWrite::doc, and G4InuclParticleNames::name().

◆ NewElement()

xercesc::DOMElement * G4GDMLWrite::NewElement ( const G4String & name )

protectedinherited

Definition at line 192 of file G4GDMLWrite.cc.

{
  XMLCh* tempStr = NULL;
  tempStr = xercesc::XMLString::transcode(name);
  xercesc::DOMElement* elem = doc->createElement(tempStr);
  xercesc::XMLString::release(&tempStr);
 
  return elem;
}

References G4GDMLWrite::doc, elem, and G4InuclParticleNames::name().

◆ Position_vectorWrite()

void G4GDMLWriteDefine::Position_vectorWrite	(	xercesc::DOMElement *	element,
		const G4String &	tag,
		const G4String &	name,
		const G4ThreeVector &	pos
	)

protectedinherited

Definition at line 118 of file G4GDMLWriteDefine.cc.

{
  const G4double x = (std::fabs(pos.x()) < kLinearPrecision) ? 0.0 : pos.x();
  const G4double y = (std::fabs(pos.y()) < kLinearPrecision) ? 0.0 : pos.y();
  const G4double z = (std::fabs(pos.z()) < kLinearPrecision) ? 0.0 : pos.z();
 
  xercesc::DOMElement* positionElement = NewElement(tag);
  positionElement->setAttributeNode(NewAttribute("name", name));
  positionElement->setAttributeNode(NewAttribute("x", x / mm));
  positionElement->setAttributeNode(NewAttribute("y", y / mm));
  positionElement->setAttributeNode(NewAttribute("z", z / mm));
  positionElement->setAttributeNode(NewAttribute("unit", "mm"));
  element->appendChild(positionElement);
}

References G4GDMLWriteDefine::kLinearPrecision, mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), and pos.

Referenced by G4GDMLWriteDefine::AddPosition(), G4GDMLWriteDefine::FirstpositionWrite(), and G4GDMLWriteDefine::PositionWrite().

◆ PositionWrite()

void G4GDMLWriteDefine::PositionWrite	(	xercesc::DOMElement *	element,
		const G4String &	name,
		const G4ThreeVector &	pos
	)

inlineinherited

Definition at line 58 of file G4GDMLWriteDefine.hh.

    {
      Position_vectorWrite(element, "position", name, pos);
    }

References G4InuclParticleNames::name(), pos, and G4GDMLWriteDefine::Position_vectorWrite().

Referenced by G4GDMLWriteStructure::AssemblyWrite(), G4GDMLWriteSolids::BooleanWrite(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteParamvol::ParametersWrite(), G4GDMLWriteStructure::PhysvolWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

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

References G4GDMLWriteDefine::defineElement, G4GDMLWrite::GenerateName(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by PropertyWrite().

◆ PropertyVectorWrite()

void G4GDMLWriteMaterials::PropertyVectorWrite	(	const G4String &	key,
		const G4PhysicsFreeVector * 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);
}

References G4GDMLWriteDefine::defineElement, G4PhysicsVector::Energy(), G4GDMLWrite::GenerateName(), G4PhysicsVector::GetVectorLength(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), and propertyList.

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 pvec = ptable->GetProperties();
  auto cvec = ptable->GetConstProperties();
 
  for(size_t i = 0; i < pvec.size(); ++i)
  {
    if (pvec[i] != nullptr)
    {
      propElement = NewElement("property");
      propElement->setAttributeNode(
        NewAttribute("name", ptable->GetMaterialPropertyNames()[i]));
      propElement->setAttributeNode(NewAttribute(
        "ref", GenerateName(ptable->GetMaterialPropertyNames()[i],
                            pvec[i])));
      PropertyVectorWrite(ptable->GetMaterialPropertyNames()[i],
                          pvec[i]);
      matElement->appendChild(propElement);
    }
  }
 
  for(size_t i = 0; i < cvec.size(); ++i)
  {
    if (cvec[i].second == true)
    {
      propElement = NewElement("property");
      propElement->setAttributeNode(NewAttribute(
        "name", ptable->GetMaterialConstPropertyNames()[i]));
      propElement->setAttributeNode(NewAttribute(
        "ref", GenerateName(ptable->GetMaterialConstPropertyNames()[i],
                            ptable)));
      PropertyConstWrite(ptable->GetMaterialConstPropertyNames()[i],
                         cvec[i].first, ptable);
      matElement->appendChild(propElement);
    }
  }
}

References G4GDMLWrite::GenerateName(), G4MaterialPropertiesTable::GetConstProperties(), G4MaterialPropertiesTable::GetMaterialConstPropertyNames(), G4Material::GetMaterialPropertiesTable(), G4MaterialPropertiesTable::GetMaterialPropertyNames(), G4MaterialPropertiesTable::GetProperties(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), PropertyConstWrite(), PropertyVectorWrite(), and second.

Referenced by MaterialWrite().

◆ PvolumeMap()

G4GDMLWrite::PhysVolumeMapType & G4GDMLWrite::PvolumeMap ( )

protectedinherited

Definition at line 66 of file G4GDMLWrite.cc.

{
  static PhysVolumeMapType instance;
  return instance;
}

Referenced by G4GDMLWrite::AddModule(), and G4GDMLWrite::Modularize().

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

References hep_pascal, G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), and P.

Referenced by MaterialWrite().

◆ Rotation_vectorWrite()

void G4GDMLWriteDefine::Rotation_vectorWrite	(	xercesc::DOMElement *	element,
		const G4String &	tag,
		const G4String &	name,
		const G4ThreeVector &	rot
	)

protectedinherited

Definition at line 99 of file G4GDMLWriteDefine.cc.

{
  const G4double x = (std::fabs(rot.x()) < kAngularPrecision) ? 0.0 : rot.x();
  const G4double y = (std::fabs(rot.y()) < kAngularPrecision) ? 0.0 : rot.y();
  const G4double z = (std::fabs(rot.z()) < kAngularPrecision) ? 0.0 : rot.z();
 
  xercesc::DOMElement* rotationElement = NewElement(tag);
  rotationElement->setAttributeNode(NewAttribute("name", name));
  rotationElement->setAttributeNode(NewAttribute("x", x / degree));
  rotationElement->setAttributeNode(NewAttribute("y", y / degree));
  rotationElement->setAttributeNode(NewAttribute("z", z / degree));
  rotationElement->setAttributeNode(NewAttribute("unit", "deg"));
  element->appendChild(rotationElement);
}

References degree, G4GDMLWriteDefine::kAngularPrecision, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GDMLWriteDefine::FirstrotationWrite(), and G4GDMLWriteDefine::RotationWrite().

◆ RotationWrite()

void G4GDMLWriteDefine::RotationWrite	(	xercesc::DOMElement *	element,
		const G4String &	name,
		const G4ThreeVector &	rot
	)

inlineinherited

Definition at line 53 of file G4GDMLWriteDefine.hh.

    {
      Rotation_vectorWrite(element, "rotation", name, rot);
    }

References G4InuclParticleNames::name(), and G4GDMLWriteDefine::Rotation_vectorWrite().

Referenced by G4GDMLWriteStructure::AssemblyWrite(), G4GDMLWriteSolids::BooleanWrite(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteParamvol::ParametersWrite(), G4GDMLWriteStructure::PhysvolWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

◆ Scale_vectorWrite()

void G4GDMLWriteDefine::Scale_vectorWrite	(	xercesc::DOMElement *	element,
		const G4String &	tag,
		const G4String &	name,
		const G4ThreeVector &	scl
	)

protectedinherited

Definition at line 78 of file G4GDMLWriteDefine.cc.

{
  const G4double x =
    (std::fabs(scl.x() - 1.0) < kRelativePrecision) ? 1.0 : scl.x();
  const G4double y =
    (std::fabs(scl.y() - 1.0) < kRelativePrecision) ? 1.0 : scl.y();
  const G4double z =
    (std::fabs(scl.z() - 1.0) < kRelativePrecision) ? 1.0 : scl.z();
 
  xercesc::DOMElement* scaleElement = NewElement(tag);
  scaleElement->setAttributeNode(NewAttribute("name", name));
  scaleElement->setAttributeNode(NewAttribute("x", x));
  scaleElement->setAttributeNode(NewAttribute("y", y));
  scaleElement->setAttributeNode(NewAttribute("z", z));
  element->appendChild(scaleElement);
}

References G4GDMLWriteDefine::kRelativePrecision, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GDMLWriteDefine::ScaleWrite().

◆ ScaleWrite()

void G4GDMLWriteDefine::ScaleWrite	(	xercesc::DOMElement *	element,
		const G4String &	name,
		const G4ThreeVector &	scl
	)

inlineinherited

Definition at line 48 of file G4GDMLWriteDefine.hh.

    {
      Scale_vectorWrite(element, "scale", name, scl);
    }

References G4InuclParticleNames::name(), and G4GDMLWriteDefine::Scale_vectorWrite().

Referenced by G4GDMLWriteStructure::PhysvolWrite(), G4GDMLWriteSolids::ScaledWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

◆ SetAddPointerToName()

void G4GDMLWrite::SetAddPointerToName ( G4bool set )

staticinherited

Definition at line 410 of file G4GDMLWrite.cc.

{
  addPointerToName = set;
}

References G4GDMLWrite::addPointerToName.

◆ SetOutputFileOverwrite()

void G4GDMLWrite::SetOutputFileOverwrite ( G4bool flag )

inherited

Definition at line 404 of file G4GDMLWrite.cc.

{
  overwriteOutputFile = flag; 
}

References G4GDMLWrite::overwriteOutputFile.

◆ SetupWrite()

virtual void G4GDMLWrite::SetupWrite	(	xercesc::DOMElement *	,
		const G4LogicalVolume * const
	)

pure virtualinherited

Implemented in G4GDMLWriteSetup.

Referenced by G4GDMLWrite::Write().

◆ SolidsWrite()

virtual void G4GDMLWrite::SolidsWrite ( xercesc::DOMElement * )

pure virtualinherited

Implemented in G4GDMLWriteSolids.

Referenced by G4GDMLWrite::Write().

◆ StructureWrite()

virtual void G4GDMLWrite::StructureWrite ( xercesc::DOMElement * )

pure virtualinherited

Implemented in G4GDMLWriteStructure.

Referenced by G4GDMLWrite::Write().

◆ SurfacesWrite()

virtual void G4GDMLWrite::SurfacesWrite ( )

pure virtualinherited

Implemented in G4GDMLWriteStructure.

Referenced by G4GDMLWrite::Write().

◆ TraverseVolumeTree()

virtual G4Transform3D G4GDMLWrite::TraverseVolumeTree	(	const G4LogicalVolume * const	,
		const	G4int
	)

pure virtualinherited

Implemented in G4GDMLWriteStructure.

Referenced by G4GDMLWrite::Write().

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

References kelvin, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by MaterialWrite().

◆ UserinfoWrite()

void G4GDMLWrite::UserinfoWrite ( xercesc::DOMElement * gdmlElement )

virtualinherited

Definition at line 118 of file G4GDMLWrite.cc.

{
  if(auxList.size() > 0)
  {
#ifdef G4VERBOSE
    G4cout << "G4GDML: Writing userinfo..." << G4endl;
#endif
    userinfoElement = NewElement("userinfo");
    gdmlElement->appendChild(userinfoElement);
    AddAuxInfo(&auxList, userinfoElement);
  }
}

References G4GDMLWrite::AddAuxInfo(), G4GDMLWrite::auxList, G4cout, G4endl, G4GDMLWrite::NewElement(), and G4GDMLWrite::userinfoElement.

Referenced by G4GDMLWrite::Write().

◆ VolumeMap()

G4GDMLWrite::VolumeMapType & G4GDMLWrite::VolumeMap ( )

protectedinherited

Definition at line 60 of file G4GDMLWrite.cc.

{
  static VolumeMapType instance;
  return instance;
}

Referenced by G4GDMLWriteStructure::TraverseVolumeTree(), and G4GDMLWrite::Write().

◆ Write()

G4Transform3D G4GDMLWrite::Write	(	const G4String &	filename,
		const G4LogicalVolume *const	topLog,
		const G4String &	schemaPath,
		const G4int	depth,
		G4bool	storeReferences = `true`
	)

inherited

Definition at line 203 of file G4GDMLWrite.cc.

{
  SchemaLocation   = setSchemaLocation;
  addPointerToName = refs;
#ifdef G4VERBOSE
  if(depth == 0)
  {
    G4cout << "G4GDML: Writing '" << fname << "'..." << G4endl;
  }
  else
  {
    G4cout << "G4GDML: Writing module '" << fname << "'..." << G4endl;
  }
#endif
  if(!overwriteOutputFile && FileExists(fname))
  {
    G4String ErrorMessage = "File '" + fname + "' already exists!";
    G4Exception("G4GDMLWrite::Write()", "InvalidSetup", FatalException,
                ErrorMessage);
  }
 
  VolumeMap().clear();  // The module map is global for all modules,
                        // so clear it only at once!
 
  XMLCh* tempStr = NULL;
  tempStr = xercesc::XMLString::transcode("LS");
  xercesc::DOMImplementationRegistry::getDOMImplementation(tempStr);
  xercesc::XMLString::release(&tempStr);
  tempStr = xercesc::XMLString::transcode("Range");
  xercesc::DOMImplementation* impl =
    xercesc::DOMImplementationRegistry::getDOMImplementation(tempStr);
  xercesc::XMLString::release(&tempStr);
  tempStr = xercesc::XMLString::transcode("gdml");
  doc                       = impl->createDocument(0, tempStr, 0);
  xercesc::XMLString::release(&tempStr);
  xercesc::DOMElement* gdml = doc->getDocumentElement();
 
#if XERCES_VERSION_MAJOR >= 3
  // DOM L3 as per Xerces 3.0 API
  xercesc::DOMLSSerializer* writer =
    ((xercesc::DOMImplementationLS*) impl)->createLSSerializer();
 
  xercesc::DOMConfiguration* dc = writer->getDomConfig();
  dc->setParameter(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint, true);
 
#else
 
  xercesc::DOMWriter* writer =
    ((xercesc::DOMImplementationLS*) impl)->createDOMWriter();
 
  if(writer->canSetFeature(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint, true))
    writer->setFeature(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint, true);
 
#endif
 
  gdml->setAttributeNode(
    NewAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"));
  gdml->setAttributeNode(
    NewAttribute("xsi:noNamespaceSchemaLocation", SchemaLocation));
 
  ExtensionWrite(gdml);
  DefineWrite(gdml);
  MaterialsWrite(gdml);
  SolidsWrite(gdml);
  StructureWrite(gdml);
  UserinfoWrite(gdml);
  SetupWrite(gdml, logvol);
 
  G4Transform3D R = TraverseVolumeTree(logvol, depth);
 
  SurfacesWrite();
  xercesc::XMLFormatTarget* myFormTarget =
    new xercesc::LocalFileFormatTarget(fname.c_str());
 
  try
  {
#if XERCES_VERSION_MAJOR >= 3
    // DOM L3 as per Xerces 3.0 API
    xercesc::DOMLSOutput* theOutput =
      ((xercesc::DOMImplementationLS*) impl)->createLSOutput();
    theOutput->setByteStream(myFormTarget);
    writer->write(doc, theOutput);
#else
    writer->writeNode(myFormTarget, *doc);
#endif
  } catch(const xercesc::XMLException& toCatch)
  {
    char* message = xercesc::XMLString::transcode(toCatch.getMessage());
    G4cout << "G4GDML: Exception message is: " << message << G4endl;
    xercesc::XMLString::release(&message);
    return G4Transform3D::Identity;
  } catch(const xercesc::DOMException& toCatch)
  {
    char* message = xercesc::XMLString::transcode(toCatch.msg);
    G4cout << "G4GDML: Exception message is: " << message << G4endl;
    xercesc::XMLString::release(&message);
    return G4Transform3D::Identity;
  } catch(...)
  {
    G4cout << "G4GDML: Unexpected Exception!" << G4endl;
    return G4Transform3D::Identity;
  }
 
  delete myFormTarget;
  writer->release();
 
  if(depth == 0)
  {
    G4cout << "G4GDML: Writing '" << fname << "' done !" << G4endl;
  }
  else
  {
#ifdef G4VERBOSE
    G4cout << "G4GDML: Writing module '" << fname << "' done !" << G4endl;
#endif
  }
 
  return R;
}

References G4GDMLWrite::addPointerToName, G4GDMLWrite::DefineWrite(), G4GDMLWrite::doc, G4GDMLWrite::ExtensionWrite(), FatalException, G4GDMLWrite::FileExists(), test::fname, G4cout, G4endl, G4Exception(), HepGeom::Transform3D::Identity, G4GDMLWrite::MaterialsWrite(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::overwriteOutputFile, G4GDMLWrite::SchemaLocation, G4GDMLWrite::SetupWrite(), G4GDMLWrite::SolidsWrite(), G4GDMLWrite::StructureWrite(), G4GDMLWrite::SurfacesWrite(), G4GDMLWrite::TraverseVolumeTree(), G4GDMLWrite::UserinfoWrite(), and G4GDMLWrite::VolumeMap().

Referenced by G4GDMLWriteStructure::TraverseVolumeTree().

Field Documentation

◆ addPointerToName

G4bool G4GDMLWrite::addPointerToName = true

staticprotectedinherited

Definition at line 131 of file G4GDMLWrite.hh.

Referenced by G4GDMLWrite::GenerateName(), G4GDMLWrite::SetAddPointerToName(), and G4GDMLWrite::Write().

◆ auxList

G4GDMLAuxListType G4GDMLWrite::auxList

protectedinherited

Definition at line 136 of file G4GDMLWrite.hh.

Referenced by G4GDMLWrite::AddAuxiliary(), and G4GDMLWrite::UserinfoWrite().

◆ defineElement

xercesc::DOMElement* G4GDMLWriteDefine::defineElement = nullptr

protectedinherited

Definition at line 98 of file G4GDMLWriteDefine.hh.

Referenced by G4GDMLWriteDefine::AddPosition(), G4GDMLWriteDefine::DefineWrite(), PropertyConstWrite(), PropertyVectorWrite(), and G4GDMLWriteSolids::PropertyWrite().

◆ doc

xercesc::DOMDocument* G4GDMLWrite::doc = nullptr

protectedinherited

Definition at line 132 of file G4GDMLWrite.hh.

Referenced by G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), and G4GDMLWrite::Write().

◆ elementList

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

protected

Definition at line 80 of file G4GDMLWriteMaterials.hh.

Referenced by AddElement(), and MaterialsWrite().

◆ extElement

xercesc::DOMElement* G4GDMLWrite::extElement = nullptr

protectedinherited

Definition at line 133 of file G4GDMLWrite.hh.

◆ isotopeList

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

protected

Definition at line 79 of file G4GDMLWriteMaterials.hh.

Referenced by AddIsotope(), and MaterialsWrite().

◆ kAngularPrecision

const G4double G4GDMLWriteDefine::kAngularPrecision = DBL_EPSILON

staticprotectedinherited

Definition at line 95 of file G4GDMLWriteDefine.hh.

Referenced by G4GDMLWriteStructure::AssemblyWrite(), G4GDMLWriteSolids::BooleanWrite(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteStructure::PhysvolWrite(), G4GDMLWriteDefine::Rotation_vectorWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

◆ kLinearPrecision

const G4double G4GDMLWriteDefine::kLinearPrecision = DBL_EPSILON

staticprotectedinherited

Definition at line 96 of file G4GDMLWriteDefine.hh.

Referenced by G4GDMLWriteStructure::AssemblyWrite(), G4GDMLWriteSolids::BooleanWrite(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteStructure::PhysvolWrite(), G4GDMLWriteDefine::Position_vectorWrite(), G4GDMLWriteSolids::ScaledWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

◆ kRelativePrecision

const G4double G4GDMLWriteDefine::kRelativePrecision = DBL_EPSILON

staticprotectedinherited

Definition at line 94 of file G4GDMLWriteDefine.hh.

Referenced by G4GDMLWriteStructure::PhysvolWrite(), G4GDMLWriteDefine::Scale_vectorWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

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

◆ overwriteOutputFile

G4bool G4GDMLWrite::overwriteOutputFile = false

protectedinherited

Definition at line 137 of file G4GDMLWrite.hh.

Referenced by G4GDMLWrite::SetOutputFileOverwrite(), and G4GDMLWrite::Write().

◆ propertyList

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

protected

Definition at line 82 of file G4GDMLWriteMaterials.hh.

Referenced by MaterialsWrite(), and PropertyVectorWrite().

◆ SchemaLocation

G4String G4GDMLWrite::SchemaLocation

protectedinherited

Definition at line 130 of file G4GDMLWrite.hh.

Referenced by G4GDMLWriteStructure::TraverseVolumeTree(), and G4GDMLWrite::Write().

◆ userinfoElement

xercesc::DOMElement* G4GDMLWrite::userinfoElement = nullptr

protectedinherited

Definition at line 134 of file G4GDMLWrite.hh.

Referenced by G4GDMLWrite::UserinfoWrite().

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

source/persistency/gdml/include/G4GDMLWriteMaterials.hh
source/persistency/gdml/src/G4GDMLWriteMaterials.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Detailed Description

Member Typedef Documentation

◆ DepthMapType

◆ PhysVolumeMapType

◆ VolumeMapType

Constructor & Destructor Documentation

◆ G4GDMLWriteMaterials()

◆ ~G4GDMLWriteMaterials()

Member Function Documentation

◆ AddAuxiliary()

◆ AddAuxInfo()

◆ AddElement()

◆ AddExtension()

◆ AddIsotope()

◆ AddMaterial()

◆ AddModule() [1/2]

◆ AddModule() [2/2]

◆ AddPosition()

◆ AtomWrite()

◆ DefineWrite()

◆ DepthMap()

◆ DWrite()

◆ ElementWrite()

◆ ExtensionWrite()

◆ FileExists()

◆ FirstpositionWrite()

◆ FirstrotationWrite()

◆ GenerateName()

◆ GetAngles()

◆ IsotopeWrite()

◆ MaterialsWrite()

◆ MaterialWrite()

◆ MEEWrite()

◆ Modularize()

◆ NewAttribute() [1/2]

◆ NewAttribute() [2/2]

◆ NewElement()

◆ Position_vectorWrite()

◆ PositionWrite()

◆ PropertyConstWrite()

◆ PropertyVectorWrite()

◆ PropertyWrite()

◆ PvolumeMap()

◆ PWrite()

◆ Rotation_vectorWrite()

◆ RotationWrite()

◆ Scale_vectorWrite()

◆ ScaleWrite()

◆ SetAddPointerToName()

◆ SetOutputFileOverwrite()

◆ SetupWrite()

◆ SolidsWrite()

◆ StructureWrite()

◆ SurfacesWrite()

◆ TraverseVolumeTree()

◆ TWrite()

◆ UserinfoWrite()

◆ VolumeMap()

◆ Write()

Field Documentation

◆ addPointerToName

◆ auxList

◆ defineElement

◆ doc

◆ elementList

◆ extElement

◆ isotopeList

◆ kAngularPrecision

◆ kLinearPrecision

◆ kRelativePrecision

◆ materialList

◆ materialsElement

◆ overwriteOutputFile

◆ propertyList