#include <G4GDMLWriteStructure.hh>

Inheritance diagram for G4GDMLWriteStructure:

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	AddSolid (const G4VSolid *const)

void	AddVolumeAuxiliary (G4GDMLAuxStructType myaux, const G4LogicalVolume *const)

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)

	G4GDMLWriteStructure ()

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

G4ThreeVector	GetAngles (const G4RotationMatrix &)

G4int	GetMaxExportLevel () const

virtual void	MaterialsWrite (xercesc::DOMElement *)

virtual void	ParamvolAlgorithmWrite (xercesc::DOMElement paramvolElement, const G4VPhysicalVolume const paramvol)

virtual void	ParamvolWrite (xercesc::DOMElement , const G4VPhysicalVolume const)

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

void	SetMaxExportLevel (G4int)

void	SetOutputFileOverwrite (G4bool flag)

void	SetSDExport (G4bool)

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

virtual void	SolidsWrite (xercesc::DOMElement *)

virtual void	StructureWrite (xercesc::DOMElement *)

virtual void	UserinfoWrite (xercesc::DOMElement *)

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

virtual	~G4GDMLWriteStructure ()

Static Public Member Functions
static void	SetAddPointerToName (G4bool)

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

void	AssemblyWrite (xercesc::DOMElement *, const int assemblyID)

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

void	BooleanWrite (xercesc::DOMElement , const G4BooleanSolid const)

void	BorderSurfaceCache (const G4LogicalBorderSurface *const)

void	Box_dimensionsWrite (xercesc::DOMElement , const G4Box const)

void	BoxWrite (xercesc::DOMElement , const G4Box const)

void	Cone_dimensionsWrite (xercesc::DOMElement , const G4Cons const)

void	ConeWrite (xercesc::DOMElement , const G4Cons const)

void	CutTubeWrite (xercesc::DOMElement , const G4CutTubs const)

DepthMapType &	DepthMap ()

void	DivisionvolWrite (xercesc::DOMElement , const G4PVDivision const)

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

void	ElconeWrite (xercesc::DOMElement , const G4EllipticalCone const)

void	ElementWrite (const G4Element *const)

void	Ellipsoid_dimensionsWrite (xercesc::DOMElement , const G4Ellipsoid const)

void	EllipsoidWrite (xercesc::DOMElement , const G4Ellipsoid const)

void	EltubeWrite (xercesc::DOMElement , const G4EllipticalTube const)

void	ExportEnergyCuts (const G4LogicalVolume *const)

void	ExportSD (const G4LogicalVolume *const)

G4bool	FileExists (const G4String &) const

G4bool	FindOpticalSurface (const G4SurfaceProperty *)

void	GenericPolyconeWrite (xercesc::DOMElement , const G4GenericPolycone const)

void	GenTrapWrite (xercesc::DOMElement , const G4GenericTrap const)

const G4LogicalBorderSurface *	GetBorderSurface (const G4VPhysicalVolume *const)

const G4LogicalSkinSurface *	GetSkinSurface (const G4LogicalVolume *const)

void	Hype_dimensionsWrite (xercesc::DOMElement , const G4Hype const)

void	HypeWrite (xercesc::DOMElement , const G4Hype const)

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)

void	MultiUnionWrite (xercesc::DOMElement solElement, const G4MultiUnion const)

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

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

xercesc::DOMElement *	NewElement (const G4String &)

void	OpticalSurfaceWrite (xercesc::DOMElement , const G4OpticalSurface const)

void	Orb_dimensionsWrite (xercesc::DOMElement , const G4Orb const)

void	OrbWrite (xercesc::DOMElement , const G4Orb const)

void	Para_dimensionsWrite (xercesc::DOMElement , const G4Para const)

void	ParaboloidWrite (xercesc::DOMElement , const G4Paraboloid const)

void	ParametersWrite (xercesc::DOMElement , const G4VPhysicalVolume const, const G4int &)

void	ParaWrite (xercesc::DOMElement , const G4Para const)

void	PhysvolWrite (xercesc::DOMElement , const G4VPhysicalVolume const topVol, const G4Transform3D &transform, const G4String &moduleName)

void	Polycone_dimensionsWrite (xercesc::DOMElement , const G4Polycone const)

void	PolyconeWrite (xercesc::DOMElement , const G4Polycone const)

void	Polyhedra_dimensionsWrite (xercesc::DOMElement , const G4Polyhedra const)

void	PolyhedraWrite (xercesc::DOMElement , const G4Polyhedra const)

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)

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

PhysVolumeMapType &	PvolumeMap ()

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

void	ReplicavolWrite (xercesc::DOMElement , const G4VPhysicalVolume const)

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

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

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

void	ScaledWrite (xercesc::DOMElement , const G4ScaledSolid const)

void	SkinSurfaceCache (const G4LogicalSkinSurface *const)

void	Sphere_dimensionsWrite (xercesc::DOMElement , const G4Sphere const)

void	SphereWrite (xercesc::DOMElement , const G4Sphere const)

void	SurfacesWrite ()

void	TessellatedWrite (xercesc::DOMElement , const G4TessellatedSolid const)

void	TetWrite (xercesc::DOMElement , const G4Tet const)

void	Torus_dimensionsWrite (xercesc::DOMElement , const G4Torus const)

void	TorusWrite (xercesc::DOMElement , const G4Torus const)

void	Trap_dimensionsWrite (xercesc::DOMElement , const G4Trap const)

void	TrapWrite (xercesc::DOMElement , const G4Trap const)

G4Transform3D	TraverseVolumeTree (const G4LogicalVolume *const topVol, const G4int depth)

void	Trd_dimensionsWrite (xercesc::DOMElement , const G4Trd const)

void	TrdWrite (xercesc::DOMElement , const G4Trd const)

void	Tube_dimensionsWrite (xercesc::DOMElement , const G4Tubs const)

void	TubeWrite (xercesc::DOMElement , const G4Tubs const)

void	TwistedboxWrite (xercesc::DOMElement , const G4TwistedBox const)

void	TwistedtrapWrite (xercesc::DOMElement , const G4TwistedTrap const)

void	TwistedtrdWrite (xercesc::DOMElement , const G4TwistedTrd const)

void	TwistedtubsWrite (xercesc::DOMElement , const G4TwistedTubs const)

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

VolumeMapType &	VolumeMap ()

void	XtruWrite (xercesc::DOMElement , const G4ExtrudedSolid const)

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

Protected Attributes
G4GDMLAuxListType	auxList

std::map< const G4LogicalVolume *, G4GDMLAuxListType >	auxmap

std::vector< xercesc::DOMElement * >	borderElementVec

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

std::vector< xercesc::DOMElement * >	skinElementVec

std::vector< const G4VSolid * >	solidList

xercesc::DOMElement *	solidsElement = nullptr

xercesc::DOMElement *	structureElement = nullptr

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

static const G4int	maxTransforms = 8

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

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

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

Private Attributes
std::vector< G4int >	addedAssemblies

std::map< const G4VPhysicalVolume *, G4int >	assemblyVolMap

G4bool	cexport = false

std::map< const G4VPhysicalVolume *, G4int >	imprintsMap

G4int	maxLevel = 0

std::vector< const G4OpticalSurface * >	opt_vec

G4ReflectionFactory *	reflFactory = nullptr

G4bool	sdexport = false

Static Private Attributes
static G4int	levelNo = 0

Detailed Description

Definition at line 51 of file G4GDMLWriteStructure.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

◆ G4GDMLWriteStructure()

G4GDMLWriteStructure::G4GDMLWriteStructure ( )

Definition at line 61 of file G4GDMLWriteStructure.cc.

  : G4GDMLWriteParamvol()
  , maxLevel(INT_MAX)
{
  reflFactory = G4ReflectionFactory::Instance();
}

References G4ReflectionFactory::Instance(), and reflFactory.

◆ ~G4GDMLWriteStructure()

G4GDMLWriteStructure::~G4GDMLWriteStructure ( )

virtual

Definition at line 69 of file G4GDMLWriteStructure.cc.

70{

71}

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(), TraverseVolumeTree(), and G4GDMLWrite::UserinfoWrite().

◆ AddElement()

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

inherited

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 G4GDMLWriteMaterials::elementList, and G4GDMLWriteMaterials::ElementWrite().

Referenced by G4GDMLWriteMaterials::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 TraverseVolumeTree().

◆ AddIsotope()

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

inherited

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 G4GDMLWriteMaterials::isotopeList, and G4GDMLWriteMaterials::IsotopeWrite().

Referenced by G4GDMLWriteMaterials::ElementWrite().

◆ AddMaterial()

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

inherited

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 G4GDMLWriteMaterials::materialList, and G4GDMLWriteMaterials::MaterialWrite().

Referenced by 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().

◆ AddSolid()

void G4GDMLWriteSolids::AddSolid ( const G4VSolid * const solidPtr )

virtualinherited

Definition at line 1137 of file G4GDMLWriteSolids.cc.

{
  for(std::size_t i = 0; i < solidList.size(); ++i)  // Check if solid is
  {                                                  // already in the list!
    if(solidList[i] == solidPtr)
    {
      return;
    }
  }
 
  solidList.push_back(solidPtr);
 
  if(const G4BooleanSolid* const booleanPtr =
       dynamic_cast<const G4BooleanSolid*>(solidPtr))
  {
    BooleanWrite(solidsElement, booleanPtr);
  }
  else if(const G4ScaledSolid* const scaledPtr =
            dynamic_cast<const G4ScaledSolid*>(solidPtr))
  {
    ScaledWrite(solidsElement, scaledPtr);
  }
  else if(solidPtr->GetEntityType() == "G4MultiUnion")
  {
    const G4MultiUnion* const munionPtr =
      static_cast<const G4MultiUnion*>(solidPtr);
    MultiUnionWrite(solidsElement, munionPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Box")
  {
    const G4Box* const boxPtr = static_cast<const G4Box*>(solidPtr);
    BoxWrite(solidsElement, boxPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Cons")
  {
    const G4Cons* const conePtr = static_cast<const G4Cons*>(solidPtr);
    ConeWrite(solidsElement, conePtr);
  }
  else if(solidPtr->GetEntityType() == "G4EllipticalCone")
  {
    const G4EllipticalCone* const elconePtr =
      static_cast<const G4EllipticalCone*>(solidPtr);
    ElconeWrite(solidsElement, elconePtr);
  }
  else if(solidPtr->GetEntityType() == "G4Ellipsoid")
  {
    const G4Ellipsoid* const ellipsoidPtr =
      static_cast<const G4Ellipsoid*>(solidPtr);
    EllipsoidWrite(solidsElement, ellipsoidPtr);
  }
  else if(solidPtr->GetEntityType() == "G4EllipticalTube")
  {
    const G4EllipticalTube* const eltubePtr =
      static_cast<const G4EllipticalTube*>(solidPtr);
    EltubeWrite(solidsElement, eltubePtr);
  }
  else if(solidPtr->GetEntityType() == "G4ExtrudedSolid")
  {
    const G4ExtrudedSolid* const xtruPtr =
      static_cast<const G4ExtrudedSolid*>(solidPtr);
    XtruWrite(solidsElement, xtruPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Hype")
  {
    const G4Hype* const hypePtr = static_cast<const G4Hype*>(solidPtr);
    HypeWrite(solidsElement, hypePtr);
  }
  else if(solidPtr->GetEntityType() == "G4Orb")
  {
    const G4Orb* const orbPtr = static_cast<const G4Orb*>(solidPtr);
    OrbWrite(solidsElement, orbPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Para")
  {
    const G4Para* const paraPtr = static_cast<const G4Para*>(solidPtr);
    ParaWrite(solidsElement, paraPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Paraboloid")
  {
    const G4Paraboloid* const paraboloidPtr =
      static_cast<const G4Paraboloid*>(solidPtr);
    ParaboloidWrite(solidsElement, paraboloidPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Polycone")
  {
    const G4Polycone* const polyconePtr =
      static_cast<const G4Polycone*>(solidPtr);
    PolyconeWrite(solidsElement, polyconePtr);
  }
  else if(solidPtr->GetEntityType() == "G4GenericPolycone")
  {
    const G4GenericPolycone* const genpolyconePtr =
      static_cast<const G4GenericPolycone*>(solidPtr);
    GenericPolyconeWrite(solidsElement, genpolyconePtr);
  }
  else if(solidPtr->GetEntityType() == "G4Polyhedra")
  {
    const G4Polyhedra* const polyhedraPtr =
      static_cast<const G4Polyhedra*>(solidPtr);
    PolyhedraWrite(solidsElement, polyhedraPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Sphere")
  {
    const G4Sphere* const spherePtr = static_cast<const G4Sphere*>(solidPtr);
    SphereWrite(solidsElement, spherePtr);
  }
  else if(solidPtr->GetEntityType() == "G4TessellatedSolid")
  {
    const G4TessellatedSolid* const tessellatedPtr =
      static_cast<const G4TessellatedSolid*>(solidPtr);
    TessellatedWrite(solidsElement, tessellatedPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Tet")
  {
    const G4Tet* const tetPtr = static_cast<const G4Tet*>(solidPtr);
    TetWrite(solidsElement, tetPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Torus")
  {
    const G4Torus* const torusPtr = static_cast<const G4Torus*>(solidPtr);
    TorusWrite(solidsElement, torusPtr);
  }
  else if(solidPtr->GetEntityType() == "G4GenericTrap")
  {
    const G4GenericTrap* const gtrapPtr =
      static_cast<const G4GenericTrap*>(solidPtr);
    GenTrapWrite(solidsElement, gtrapPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Trap")
  {
    const G4Trap* const trapPtr = static_cast<const G4Trap*>(solidPtr);
    TrapWrite(solidsElement, trapPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Trd")
  {
    const G4Trd* const trdPtr = static_cast<const G4Trd*>(solidPtr);
    TrdWrite(solidsElement, trdPtr);
  }
  else if(solidPtr->GetEntityType() == "G4Tubs")
  {
    const G4Tubs* const tubePtr = static_cast<const G4Tubs*>(solidPtr);
    TubeWrite(solidsElement, tubePtr);
  }
  else if(solidPtr->GetEntityType() == "G4CutTubs")
  {
    const G4CutTubs* const cuttubePtr = static_cast<const G4CutTubs*>(solidPtr);
    CutTubeWrite(solidsElement, cuttubePtr);
  }
  else if(solidPtr->GetEntityType() == "G4TwistedBox")
  {
    const G4TwistedBox* const twistedboxPtr =
      static_cast<const G4TwistedBox*>(solidPtr);
    TwistedboxWrite(solidsElement, twistedboxPtr);
  }
  else if(solidPtr->GetEntityType() == "G4TwistedTrap")
  {
    const G4TwistedTrap* const twistedtrapPtr =
      static_cast<const G4TwistedTrap*>(solidPtr);
    TwistedtrapWrite(solidsElement, twistedtrapPtr);
  }
  else if(solidPtr->GetEntityType() == "G4TwistedTrd")
  {
    const G4TwistedTrd* const twistedtrdPtr =
      static_cast<const G4TwistedTrd*>(solidPtr);
    TwistedtrdWrite(solidsElement, twistedtrdPtr);
  }
  else if(solidPtr->GetEntityType() == "G4TwistedTubs")
  {
    const G4TwistedTubs* const twistedtubsPtr =
      static_cast<const G4TwistedTubs*>(solidPtr);
    TwistedtubsWrite(solidsElement, twistedtubsPtr);
  }
  else
  {
    G4String error_msg = "Unknown solid: " + solidPtr->GetName() +
                         "; Type: " + solidPtr->GetEntityType();
    G4Exception("G4GDMLWriteSolids::AddSolid()", "WriteError", FatalException,
                error_msg);
  }
}

Referenced by G4GDMLWriteSolids::BooleanWrite(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteSolids::ScaledWrite(), and TraverseVolumeTree().

◆ AddVolumeAuxiliary()

void G4GDMLWriteStructure::AddVolumeAuxiliary	(	G4GDMLAuxStructType	myaux,
		const G4LogicalVolume * const	lvol
	)

Definition at line 829 of file G4GDMLWriteStructure.cc.

{
  auto pos = auxmap.find(lvol);
 
  if(pos == auxmap.cend())
  {
    auxmap[lvol] = G4GDMLAuxListType();
  }
 
  auxmap[lvol].push_back(myaux);
}

References auxmap, and pos.

Referenced by ExportEnergyCuts(), and ExportSD().

◆ AssemblyWrite()

void G4GDMLWriteStructure::AssemblyWrite	(	xercesc::DOMElement *	volumeElement,
		const int	assemblyID
	)

protected

Definition at line 264 of file G4GDMLWriteStructure.cc.

{
  G4AssemblyStore* assemblies  = G4AssemblyStore::GetInstance();
  G4AssemblyVolume* myassembly = assemblies->GetAssembly(assemblyID);
 
  xercesc::DOMElement* assemblyElement = NewElement("assembly");
  G4String name = "Assembly_" + std::to_string(assemblyID);
 
  assemblyElement->setAttributeNode(NewAttribute("name", name));
 
  auto vit = myassembly->GetTripletsIterator();
 
  G4int depth = 0;
  const G4String ModuleName;
 
  for(std::size_t i5 = 0; i5 < myassembly->TotalTriplets(); ++i5)
  {
    G4LogicalVolume* lvol = (*vit).GetVolume();
    if (lvol == nullptr)
    {
      G4String message = "Nested assemblies not yet supported for exporting. Sorry!";
      G4Exception("G4GDMLWriteStructure::AssemblyWrite()", "InvalidSetup",
                  FatalException, message);
      return;
    }
    TraverseVolumeTree(lvol, depth + 1);
 
    const G4ThreeVector rot = GetAngles((*vit).GetRotation()->inverse());
    const G4ThreeVector pos = (*vit).GetTranslation();
 
    const G4String pname =
      GenerateName((*vit).GetVolume()->GetName() + "_pv", &(*vit));
 
    xercesc::DOMElement* physvolElement = NewElement("physvol");
    physvolElement->setAttributeNode(NewAttribute("name", pname));
 
    assemblyElement->appendChild(physvolElement);
 
    const G4String volumeref =
      GenerateName((*vit).GetVolume()->GetName(), (*vit).GetVolume());
 
    xercesc::DOMElement* volumerefElement = NewElement("volumeref");
    volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
    physvolElement->appendChild(volumerefElement);
 
    if(std::fabs(pos.x()) > kLinearPrecision ||
       std::fabs(pos.y()) > kLinearPrecision ||
       std::fabs(pos.z()) > kLinearPrecision)
    {
      PositionWrite(physvolElement,name+"_position_" + std::to_string(i5), pos);
    }
 
    if(std::fabs(rot.x()) > kAngularPrecision ||
       std::fabs(rot.y()) > kAngularPrecision ||
       std::fabs(rot.z()) > kAngularPrecision)
    {
      RotationWrite(physvolElement,name+"_rotation_" + std::to_string(i5), rot);
    }
    ++vit;
  }
 
  volumeElement->appendChild(assemblyElement);
}

References FatalException, G4Exception(), G4GDMLWrite::GenerateName(), G4GDMLWriteDefine::GetAngles(), G4AssemblyStore::GetAssembly(), G4AssemblyStore::GetInstance(), G4AssemblyVolume::GetTripletsIterator(), G4GDMLWriteDefine::kAngularPrecision, G4GDMLWriteDefine::kLinearPrecision, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), eplot::pname, pos, G4GDMLWriteDefine::PositionWrite(), G4GDMLWriteDefine::RotationWrite(), G4AssemblyVolume::TotalTriplets(), TraverseVolumeTree(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by TraverseVolumeTree().

◆ AtomWrite()

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

protectedinherited

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 G4GDMLWriteMaterials::ElementWrite(), G4GDMLWriteMaterials::IsotopeWrite(), and G4GDMLWriteMaterials::MaterialWrite().

◆ BooleanWrite()

void G4GDMLWriteSolids::BooleanWrite	(	xercesc::DOMElement *	solElement,
		const G4BooleanSolid * const	boolean
	)

protectedinherited

Definition at line 141 of file G4GDMLWriteSolids.cc.

{
  G4int displaced = 0;
 
  G4String tag("undefined");
  if(dynamic_cast<const G4IntersectionSolid*>(boolean))
  {
    tag = "intersection";
  }
  else if(dynamic_cast<const G4SubtractionSolid*>(boolean))
  {
    tag = "subtraction";
  }
  else if(dynamic_cast<const G4UnionSolid*>(boolean))
  {
    tag = "union";
  }
 
  G4VSolid* firstPtr  = const_cast<G4VSolid*>(boolean->GetConstituentSolid(0));
  G4VSolid* secondPtr = const_cast<G4VSolid*>(boolean->GetConstituentSolid(1));
 
  G4ThreeVector firstpos, firstrot, pos, rot;
 
  // Solve possible displacement of referenced solids!
  //
  while(true)
  {
    if(displaced > 8)
    {
      G4String ErrorMessage = "The referenced solid '" + firstPtr->GetName() +
                              +"in the Boolean shape '" + +boolean->GetName() +
                              +"' was displaced too many times!";
      G4Exception("G4GDMLWriteSolids::BooleanWrite()", "InvalidSetup",
                  FatalException, ErrorMessage);
    }
 
    if(G4DisplacedSolid* disp = dynamic_cast<G4DisplacedSolid*>(firstPtr))
    {
      firstpos += disp->GetObjectTranslation();
      firstrot += GetAngles(disp->GetObjectRotation());
      firstPtr = disp->GetConstituentMovedSolid();
      ++displaced;
      continue;
    }
    break;
  }
  displaced = 0;
  while(true)
  {
    if(displaced > maxTransforms)
    {
      G4String ErrorMessage = "The referenced solid '" + secondPtr->GetName() +
                              +"in the Boolean shape '" + +boolean->GetName() +
                              +"' was displaced too many times!";
      G4Exception("G4GDMLWriteSolids::BooleanWrite()", "InvalidSetup",
                  FatalException, ErrorMessage);
    }
 
    if(G4DisplacedSolid* disp = dynamic_cast<G4DisplacedSolid*>(secondPtr))
    {
      pos += disp->GetObjectTranslation();
      rot += GetAngles(disp->GetObjectRotation());
      secondPtr = disp->GetConstituentMovedSolid();
      ++displaced;
      continue;
    }
    break;
  }
 
  AddSolid(firstPtr);  // At first add the constituent solids!
  AddSolid(secondPtr);
 
  const G4String& name      = GenerateName(boolean->GetName(), boolean);
  const G4String& firstref  = GenerateName(firstPtr->GetName(), firstPtr);
  const G4String& secondref = GenerateName(secondPtr->GetName(), secondPtr);
 
  xercesc::DOMElement* booleanElement = NewElement(tag);
  booleanElement->setAttributeNode(NewAttribute("name", name));
  xercesc::DOMElement* firstElement = NewElement("first");
  firstElement->setAttributeNode(NewAttribute("ref", firstref));
  booleanElement->appendChild(firstElement);
  xercesc::DOMElement* secondElement = NewElement("second");
  secondElement->setAttributeNode(NewAttribute("ref", secondref));
  booleanElement->appendChild(secondElement);
  solElement->appendChild(booleanElement);
  // Add the boolean solid AFTER the constituent solids!
 
  if((std::fabs(pos.x()) > kLinearPrecision) ||
     (std::fabs(pos.y()) > kLinearPrecision) ||
     (std::fabs(pos.z()) > kLinearPrecision))
  {
    PositionWrite(booleanElement, name + "_pos", pos);
  }
 
  if((std::fabs(rot.x()) > kAngularPrecision) ||
     (std::fabs(rot.y()) > kAngularPrecision) ||
     (std::fabs(rot.z()) > kAngularPrecision))
  {
    RotationWrite(booleanElement, name + "_rot", rot);
  }
 
  if((std::fabs(firstpos.x()) > kLinearPrecision) ||
     (std::fabs(firstpos.y()) > kLinearPrecision) ||
     (std::fabs(firstpos.z()) > kLinearPrecision))
  {
    FirstpositionWrite(booleanElement, name + "_fpos", firstpos);
  }
 
  if((std::fabs(firstrot.x()) > kAngularPrecision) ||
     (std::fabs(firstrot.y()) > kAngularPrecision) ||
     (std::fabs(firstrot.z()) > kAngularPrecision))
  {
    FirstrotationWrite(booleanElement, name + "_frot", firstrot);
  }
}

References G4GDMLWriteSolids::AddSolid(), FatalException, G4GDMLWriteDefine::FirstpositionWrite(), G4GDMLWriteDefine::FirstrotationWrite(), G4Exception(), G4GDMLWrite::GenerateName(), G4GDMLWriteDefine::GetAngles(), G4VSolid::GetName(), G4GDMLWriteDefine::kAngularPrecision, G4GDMLWriteDefine::kLinearPrecision, G4GDMLWriteSolids::maxTransforms, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), pos, G4GDMLWriteDefine::PositionWrite(), G4GDMLWriteDefine::RotationWrite(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ BorderSurfaceCache()

void G4GDMLWriteStructure::BorderSurfaceCache ( const G4LogicalBorderSurface * const bsurf )

protected

Definition at line 330 of file G4GDMLWriteStructure.cc.

{
  if(bsurf == nullptr)
  {
    return;
  }
 
  const G4SurfaceProperty* psurf = bsurf->GetSurfaceProperty();
 
  // Generate the new element for border-surface
  //
  const G4String& bsname             = GenerateName(bsurf->GetName(), bsurf);
  const G4String& psname             = GenerateName(psurf->GetName(), psurf);
  xercesc::DOMElement* borderElement = NewElement("bordersurface");
  borderElement->setAttributeNode(NewAttribute("name", bsname));
  borderElement->setAttributeNode(NewAttribute("surfaceproperty", psname));
 
  const G4String volumeref1 =
    GenerateName(bsurf->GetVolume1()->GetName(), bsurf->GetVolume1());
  const G4String volumeref2 =
    GenerateName(bsurf->GetVolume2()->GetName(), bsurf->GetVolume2());
  xercesc::DOMElement* volumerefElement1 = NewElement("physvolref");
  xercesc::DOMElement* volumerefElement2 = NewElement("physvolref");
  volumerefElement1->setAttributeNode(NewAttribute("ref", volumeref1));
  volumerefElement2->setAttributeNode(NewAttribute("ref", volumeref2));
  borderElement->appendChild(volumerefElement1);
  borderElement->appendChild(volumerefElement2);
 
  if(FindOpticalSurface(psurf))
  {
    const G4OpticalSurface* opsurf =
      dynamic_cast<const G4OpticalSurface*>(psurf);
    if(opsurf == nullptr)
    {
      G4Exception("G4GDMLWriteStructure::BorderSurfaceCache()", "InvalidSetup",
                  FatalException, "No optical surface found!");
      return;
    }
    OpticalSurfaceWrite(solidsElement, opsurf);
  }
 
  borderElementVec.push_back(borderElement);
}

References borderElementVec, FatalException, FindOpticalSurface(), G4Exception(), G4GDMLWrite::GenerateName(), G4LogicalSurface::GetName(), G4VPhysicalVolume::GetName(), G4SurfaceProperty::GetName(), G4LogicalSurface::GetSurfaceProperty(), G4LogicalBorderSurface::GetVolume1(), G4LogicalBorderSurface::GetVolume2(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), G4GDMLWriteSolids::OpticalSurfaceWrite(), and G4GDMLWriteSolids::solidsElement.

Referenced by GetBorderSurface().

◆ Box_dimensionsWrite()

void G4GDMLWriteParamvol::Box_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Box * const	box
	)

protectedinherited

Definition at line 65 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* box_dimensionsElement = NewElement("box_dimensions");
  box_dimensionsElement->setAttributeNode(
    NewAttribute("x", 2.0 * box->GetXHalfLength() / mm));
  box_dimensionsElement->setAttributeNode(
    NewAttribute("y", 2.0 * box->GetYHalfLength() / mm));
  box_dimensionsElement->setAttributeNode(
    NewAttribute("z", 2.0 * box->GetZHalfLength() / mm));
  box_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(box_dimensionsElement);
}

References G4Box::GetXHalfLength(), G4Box::GetYHalfLength(), G4Box::GetZHalfLength(), mm, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ BoxWrite()

void G4GDMLWriteSolids::BoxWrite	(	xercesc::DOMElement *	solElement,
		const G4Box * const	box
	)

protectedinherited

Definition at line 292 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(box->GetName(), box);
 
  xercesc::DOMElement* boxElement = NewElement("box");
  boxElement->setAttributeNode(NewAttribute("name", name));
  boxElement->setAttributeNode(
    NewAttribute("x", 2.0 * box->GetXHalfLength() / mm));
  boxElement->setAttributeNode(
    NewAttribute("y", 2.0 * box->GetYHalfLength() / mm));
  boxElement->setAttributeNode(
    NewAttribute("z", 2.0 * box->GetZHalfLength() / mm));
  boxElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(boxElement);
}

References G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4Box::GetXHalfLength(), G4Box::GetYHalfLength(), G4Box::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ Cone_dimensionsWrite()

void G4GDMLWriteParamvol::Cone_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Cons * const	cone
	)

protectedinherited

Definition at line 157 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* cone_dimensionsElement = NewElement("cone_dimensions");
  cone_dimensionsElement->setAttributeNode(
    NewAttribute("rmin1", cone->GetInnerRadiusMinusZ() / mm));
  cone_dimensionsElement->setAttributeNode(
    NewAttribute("rmax1", cone->GetOuterRadiusMinusZ() / mm));
  cone_dimensionsElement->setAttributeNode(
    NewAttribute("rmin2", cone->GetInnerRadiusPlusZ() / mm));
  cone_dimensionsElement->setAttributeNode(
    NewAttribute("rmax2", cone->GetOuterRadiusPlusZ() / mm));
  cone_dimensionsElement->setAttributeNode(
    NewAttribute("z", 2.0 * cone->GetZHalfLength() / mm));
  cone_dimensionsElement->setAttributeNode(
    NewAttribute("startphi", cone->GetStartPhiAngle() / degree));
  cone_dimensionsElement->setAttributeNode(
    NewAttribute("deltaphi", cone->GetDeltaPhiAngle() / degree));
  cone_dimensionsElement->setAttributeNode(NewAttribute("aunit", "deg"));
  cone_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(cone_dimensionsElement);
}

References degree, G4Cons::GetDeltaPhiAngle(), G4Cons::GetInnerRadiusMinusZ(), G4Cons::GetInnerRadiusPlusZ(), G4Cons::GetOuterRadiusMinusZ(), G4Cons::GetOuterRadiusPlusZ(), G4Cons::GetStartPhiAngle(), G4Cons::GetZHalfLength(), mm, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ ConeWrite()

void G4GDMLWriteSolids::ConeWrite	(	xercesc::DOMElement *	solElement,
		const G4Cons * const	cone
	)

protectedinherited

Definition at line 310 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(cone->GetName(), cone);
 
  xercesc::DOMElement* coneElement = NewElement("cone");
  coneElement->setAttributeNode(NewAttribute("name", name));
  coneElement->setAttributeNode(
    NewAttribute("rmin1", cone->GetInnerRadiusMinusZ() / mm));
  coneElement->setAttributeNode(
    NewAttribute("rmax1", cone->GetOuterRadiusMinusZ() / mm));
  coneElement->setAttributeNode(
    NewAttribute("rmin2", cone->GetInnerRadiusPlusZ() / mm));
  coneElement->setAttributeNode(
    NewAttribute("rmax2", cone->GetOuterRadiusPlusZ() / mm));
  coneElement->setAttributeNode(
    NewAttribute("z", 2.0 * cone->GetZHalfLength() / mm));
  coneElement->setAttributeNode(
    NewAttribute("startphi", cone->GetStartPhiAngle() / degree));
  coneElement->setAttributeNode(
    NewAttribute("deltaphi", cone->GetDeltaPhiAngle() / degree));
  coneElement->setAttributeNode(NewAttribute("aunit", "deg"));
  coneElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(coneElement);
}

References degree, G4GDMLWrite::GenerateName(), G4Cons::GetDeltaPhiAngle(), G4Cons::GetInnerRadiusMinusZ(), G4Cons::GetInnerRadiusPlusZ(), G4VSolid::GetName(), G4Cons::GetOuterRadiusMinusZ(), G4Cons::GetOuterRadiusPlusZ(), G4Cons::GetStartPhiAngle(), G4Cons::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ CutTubeWrite()

void G4GDMLWriteSolids::CutTubeWrite	(	xercesc::DOMElement *	solElement,
		const G4CutTubs * const	cuttube
	)

protectedinherited

Definition at line 894 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(cuttube->GetName(), cuttube);
 
  xercesc::DOMElement* cuttubeElement = NewElement("cutTube");
  cuttubeElement->setAttributeNode(NewAttribute("name", name));
  cuttubeElement->setAttributeNode(
    NewAttribute("rmin", cuttube->GetInnerRadius() / mm));
  cuttubeElement->setAttributeNode(
    NewAttribute("rmax", cuttube->GetOuterRadius() / mm));
  cuttubeElement->setAttributeNode(
    NewAttribute("z", 2.0 * cuttube->GetZHalfLength() / mm));
  cuttubeElement->setAttributeNode(
    NewAttribute("startphi", cuttube->GetStartPhiAngle() / degree));
  cuttubeElement->setAttributeNode(
    NewAttribute("deltaphi", cuttube->GetDeltaPhiAngle() / degree));
  cuttubeElement->setAttributeNode(
    NewAttribute("lowX", cuttube->GetLowNorm().getX() / mm));
  cuttubeElement->setAttributeNode(
    NewAttribute("lowY", cuttube->GetLowNorm().getY() / mm));
  cuttubeElement->setAttributeNode(
    NewAttribute("lowZ", cuttube->GetLowNorm().getZ() / mm));
  cuttubeElement->setAttributeNode(
    NewAttribute("highX", cuttube->GetHighNorm().getX() / mm));
  cuttubeElement->setAttributeNode(
    NewAttribute("highY", cuttube->GetHighNorm().getY() / mm));
  cuttubeElement->setAttributeNode(
    NewAttribute("highZ", cuttube->GetHighNorm().getZ() / mm));
  cuttubeElement->setAttributeNode(NewAttribute("aunit", "deg"));
  cuttubeElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(cuttubeElement);
}

References degree, G4GDMLWrite::GenerateName(), G4CutTubs::GetDeltaPhiAngle(), G4CutTubs::GetHighNorm(), G4CutTubs::GetInnerRadius(), G4CutTubs::GetLowNorm(), G4VSolid::GetName(), G4CutTubs::GetOuterRadius(), G4CutTubs::GetStartPhiAngle(), CLHEP::Hep3Vector::getX(), CLHEP::Hep3Vector::getY(), CLHEP::Hep3Vector::getZ(), G4CutTubs::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

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

◆ DivisionvolWrite()

void G4GDMLWriteStructure::DivisionvolWrite	(	xercesc::DOMElement *	volumeElement,
		const G4PVDivision * const	divisionvol
	)

protected

Definition at line 74 of file G4GDMLWriteStructure.cc.

{
  EAxis axis       = kUndefined;
  G4int number     = 0;
  G4double width   = 0.0;
  G4double offset  = 0.0;
  G4bool consuming = false;
 
  divisionvol->GetReplicationData(axis, number, width, offset, consuming);
  axis = divisionvol->GetDivisionAxis();
 
  G4String unitString("mm");
  G4String axisString("kUndefined");
  if(axis == kXAxis)
  {
    axisString = "kXAxis";
  }
  else if(axis == kYAxis)
  {
    axisString = "kYAxis";
  }
  else if(axis == kZAxis)
  {
    axisString = "kZAxis";
  }
  else if(axis == kRho)
  {
    axisString = "kRho";
  }
  else if(axis == kPhi)
  {
    axisString = "kPhi";
    unitString = "rad";
  }
 
  const G4String name = GenerateName(divisionvol->GetName(), divisionvol);
  const G4String volumeref =
    GenerateName(divisionvol->GetLogicalVolume()->GetName(),
                 divisionvol->GetLogicalVolume());
 
  xercesc::DOMElement* divisionvolElement = NewElement("divisionvol");
  divisionvolElement->setAttributeNode(NewAttribute("axis", axisString));
  divisionvolElement->setAttributeNode(NewAttribute("number", number));
  divisionvolElement->setAttributeNode(NewAttribute("width", width));
  divisionvolElement->setAttributeNode(NewAttribute("offset", offset));
  divisionvolElement->setAttributeNode(NewAttribute("unit", unitString));
  xercesc::DOMElement* volumerefElement = NewElement("volumeref");
  volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
  divisionvolElement->appendChild(volumerefElement);
  volumeElement->appendChild(divisionvolElement);
}

References G4GDMLWrite::GenerateName(), G4PVDivision::GetDivisionAxis(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4PVDivision::GetReplicationData(), kPhi, kRho, kUndefined, kXAxis, kYAxis, kZAxis, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by TraverseVolumeTree().

◆ DWrite()

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

protectedinherited

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 G4GDMLWriteMaterials::MaterialWrite().

◆ ElconeWrite()

void G4GDMLWriteSolids::ElconeWrite	(	xercesc::DOMElement *	solElement,
		const G4EllipticalCone * const	elcone
	)

protectedinherited

Definition at line 337 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(elcone->GetName(), elcone);
 
  xercesc::DOMElement* elconeElement = NewElement("elcone");
  elconeElement->setAttributeNode(NewAttribute("name", name));
  elconeElement->setAttributeNode(
    NewAttribute("dx", elcone->GetSemiAxisX() / mm));
  elconeElement->setAttributeNode(
    NewAttribute("dy", elcone->GetSemiAxisY() / mm));
  elconeElement->setAttributeNode(NewAttribute("zmax", elcone->GetZMax() / mm));
  elconeElement->setAttributeNode(
    NewAttribute("zcut", elcone->GetZTopCut() / mm));
  elconeElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(elconeElement);
}

References G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4EllipticalCone::GetSemiAxisX(), G4EllipticalCone::GetSemiAxisY(), G4EllipticalCone::GetZMax(), G4EllipticalCone::GetZTopCut(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ ElementWrite()

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

protectedinherited

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 G4GDMLWriteMaterials::AddIsotope(), G4GDMLWriteMaterials::AtomWrite(), G4GDMLWrite::GenerateName(), G4Element::GetA(), G4Element::GetIsotope(), G4Element::GetName(), G4Isotope::GetName(), G4Element::GetNumberOfIsotopes(), G4Element::GetRelativeAbundanceVector(), G4Element::GetZ(), G4GDMLWriteMaterials::materialsElement, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteMaterials::AddElement().

◆ Ellipsoid_dimensionsWrite()

void G4GDMLWriteParamvol::Ellipsoid_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Ellipsoid * const	ellipsoid
	)

protectedinherited

Definition at line 235 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* ellipsoid_dimensionsElement =
    NewElement("ellipsoid_dimensions");
  ellipsoid_dimensionsElement->setAttributeNode(
    NewAttribute("ax", ellipsoid->GetSemiAxisMax(0) / mm));
  ellipsoid_dimensionsElement->setAttributeNode(
    NewAttribute("by", ellipsoid->GetSemiAxisMax(1) / mm));
  ellipsoid_dimensionsElement->setAttributeNode(
    NewAttribute("cz", ellipsoid->GetSemiAxisMax(2) / mm));
  ellipsoid_dimensionsElement->setAttributeNode(
    NewAttribute("zcut1", ellipsoid->GetZBottomCut() / mm));
  ellipsoid_dimensionsElement->setAttributeNode(
    NewAttribute("zcut2", ellipsoid->GetZTopCut() / mm));
  ellipsoid_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(ellipsoid_dimensionsElement);
}

References G4Ellipsoid::GetSemiAxisMax(), G4Ellipsoid::GetZBottomCut(), G4Ellipsoid::GetZTopCut(), mm, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ EllipsoidWrite()

void G4GDMLWriteSolids::EllipsoidWrite	(	xercesc::DOMElement *	solElement,
		const G4Ellipsoid * const	ellipsoid
	)

protectedinherited

Definition at line 356 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(ellipsoid->GetName(), ellipsoid);
 
  xercesc::DOMElement* ellipsoidElement = NewElement("ellipsoid");
  ellipsoidElement->setAttributeNode(NewAttribute("name", name));
  ellipsoidElement->setAttributeNode(
    NewAttribute("ax", ellipsoid->GetSemiAxisMax(0) / mm));
  ellipsoidElement->setAttributeNode(
    NewAttribute("by", ellipsoid->GetSemiAxisMax(1) / mm));
  ellipsoidElement->setAttributeNode(
    NewAttribute("cz", ellipsoid->GetSemiAxisMax(2) / mm));
  ellipsoidElement->setAttributeNode(
    NewAttribute("zcut1", ellipsoid->GetZBottomCut() / mm));
  ellipsoidElement->setAttributeNode(
    NewAttribute("zcut2", ellipsoid->GetZTopCut() / mm));
  ellipsoidElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(ellipsoidElement);
}

References G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4Ellipsoid::GetSemiAxisMax(), G4Ellipsoid::GetZBottomCut(), G4Ellipsoid::GetZTopCut(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ EltubeWrite()

void G4GDMLWriteSolids::EltubeWrite	(	xercesc::DOMElement *	solElement,
		const G4EllipticalTube * const	eltube
	)

protectedinherited

Definition at line 378 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(eltube->GetName(), eltube);
 
  xercesc::DOMElement* eltubeElement = NewElement("eltube");
  eltubeElement->setAttributeNode(NewAttribute("name", name));
  eltubeElement->setAttributeNode(NewAttribute("dx", eltube->GetDx() / mm));
  eltubeElement->setAttributeNode(NewAttribute("dy", eltube->GetDy() / mm));
  eltubeElement->setAttributeNode(NewAttribute("dz", eltube->GetDz() / mm));
  eltubeElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(eltubeElement);
}

References G4GDMLWrite::GenerateName(), G4EllipticalTube::GetDx(), G4EllipticalTube::GetDy(), G4EllipticalTube::GetDz(), G4VSolid::GetName(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ ExportEnergyCuts()

void G4GDMLWriteStructure::ExportEnergyCuts ( const G4LogicalVolume * const lvol )

protected

Definition at line 849 of file G4GDMLWriteStructure.cc.

{
  G4GDMLEvaluator eval;
  G4ProductionCuts* pcuts     = lvol->GetRegion()->GetProductionCuts();
  G4ProductionCutsTable* ctab = G4ProductionCutsTable::GetProductionCutsTable();
  G4Gamma* gamma              = G4Gamma::Gamma();
  G4Electron* eminus          = G4Electron::Electron();
  G4Positron* eplus           = G4Positron::Positron();
  G4Proton* proton            = G4Proton::Proton();
 
  G4double gamma_cut = ctab->ConvertRangeToEnergy(
    gamma, lvol->GetMaterial(), pcuts->GetProductionCut("gamma"));
  G4double eminus_cut = ctab->ConvertRangeToEnergy(
    eminus, lvol->GetMaterial(), pcuts->GetProductionCut("e-"));
  G4double eplus_cut = ctab->ConvertRangeToEnergy(
    eplus, lvol->GetMaterial(), pcuts->GetProductionCut("e+"));
  G4double proton_cut = ctab->ConvertRangeToEnergy(
    proton, lvol->GetMaterial(), pcuts->GetProductionCut("proton"));
 
  G4GDMLAuxStructType gammainfo  = { "gammaECut",
                                    eval.ConvertToString(gamma_cut), "MeV", 0 };
  G4GDMLAuxStructType eminusinfo = { "electronECut",
                                     eval.ConvertToString(eminus_cut), "MeV",
                                     0 };
  G4GDMLAuxStructType eplusinfo  = { "positronECut",
                                    eval.ConvertToString(eplus_cut), "MeV", 0 };
  G4GDMLAuxStructType protinfo   = { "protonECut",
                                   eval.ConvertToString(proton_cut), "MeV", 0 };
 
  AddVolumeAuxiliary(gammainfo, lvol);
  AddVolumeAuxiliary(eminusinfo, lvol);
  AddVolumeAuxiliary(eplusinfo, lvol);
  AddVolumeAuxiliary(protinfo, lvol);
}

References AddVolumeAuxiliary(), G4ProductionCutsTable::ConvertRangeToEnergy(), G4GDMLEvaluator::ConvertToString(), G4Electron::Electron(), eplus, G4Gamma::Gamma(), G4LogicalVolume::GetMaterial(), G4ProductionCuts::GetProductionCut(), G4Region::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4LogicalVolume::GetRegion(), G4Positron::Positron(), G4Proton::Proton(), and G4InuclParticleNames::proton.

Referenced by TraverseVolumeTree().

◆ ExportSD()

void G4GDMLWriteStructure::ExportSD ( const G4LogicalVolume * const lvol )

protected

Definition at line 891 of file G4GDMLWriteStructure.cc.

{
  G4VSensitiveDetector* sd = lvol->GetSensitiveDetector();
 
  if(sd != nullptr)
  {
    G4String SDname = sd->GetName();
 
    G4GDMLAuxStructType SDinfo = { "SensDet", SDname, "", 0 };
    AddVolumeAuxiliary(SDinfo, lvol);
  }
}

References AddVolumeAuxiliary(), G4VSensitiveDetector::GetName(), and G4LogicalVolume::GetSensitiveDetector().

Referenced by TraverseVolumeTree().

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

◆ FindOpticalSurface()

G4bool G4GDMLWriteStructure::FindOpticalSurface ( const G4SurfaceProperty * psurf )

protected

Definition at line 417 of file G4GDMLWriteStructure.cc.

{
  const G4OpticalSurface* osurf = dynamic_cast<const G4OpticalSurface*>(psurf);
  auto pos = std::find(opt_vec.cbegin(), opt_vec.cend(), osurf);
  if(pos != opt_vec.cend())
  {
    return false;
  }  // item already created!
 
  opt_vec.push_back(osurf);  // cache it for future reference
  return true;
}

References opt_vec, and pos.

Referenced by BorderSurfaceCache(), and SkinSurfaceCache().

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

◆ GenericPolyconeWrite()

void G4GDMLWriteSolids::GenericPolyconeWrite	(	xercesc::DOMElement *	solElement,
		const G4GenericPolycone * const	polycone
	)

protectedinherited

Definition at line 547 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(polycone->GetName(), polycone);
  xercesc::DOMElement* polyconeElement = NewElement("genericPolycone");
  const G4double startPhi              = polycone->GetStartPhi();
  polyconeElement->setAttributeNode(NewAttribute("name", name));
  polyconeElement->setAttributeNode(
    NewAttribute("startphi", startPhi / degree));
  polyconeElement->setAttributeNode(
    NewAttribute("deltaphi", (polycone->GetEndPhi() - startPhi) / degree));
  polyconeElement->setAttributeNode(NewAttribute("aunit", "deg"));
  polyconeElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(polyconeElement);
 
  const std::size_t num_rzpoints = polycone->GetNumRZCorner();
  for(std::size_t i = 0; i < num_rzpoints; ++i)
  {
    const G4double r_point = polycone->GetCorner(i).r;
    const G4double z_point = polycone->GetCorner(i).z;
    RZPointWrite(polyconeElement, r_point, z_point);
  }
}

References degree, G4GDMLWrite::GenerateName(), G4GenericPolycone::GetCorner(), G4GenericPolycone::GetEndPhi(), G4VSolid::GetName(), G4GenericPolycone::GetNumRZCorner(), G4GenericPolycone::GetStartPhi(), G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), G4PolyconeSideRZ::r, G4GDMLWriteSolids::RZPointWrite(), and G4PolyconeSideRZ::z.

Referenced by G4GDMLWriteSolids::AddSolid().

◆ GenTrapWrite()

void G4GDMLWriteSolids::GenTrapWrite	(	xercesc::DOMElement *	solElement,
		const G4GenericTrap * const	gtrap
	)

protectedinherited

Definition at line 780 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(gtrap->GetName(), gtrap);
 
  std::vector<G4TwoVector> vertices = gtrap->GetVertices();
 
  xercesc::DOMElement* gtrapElement = NewElement("arb8");
  gtrapElement->setAttributeNode(NewAttribute("name", name));
  gtrapElement->setAttributeNode(
    NewAttribute("dz", gtrap->GetZHalfLength() / mm));
  gtrapElement->setAttributeNode(NewAttribute("v1x", vertices[0].x()));
  gtrapElement->setAttributeNode(NewAttribute("v1y", vertices[0].y()));
  gtrapElement->setAttributeNode(NewAttribute("v2x", vertices[1].x()));
  gtrapElement->setAttributeNode(NewAttribute("v2y", vertices[1].y()));
  gtrapElement->setAttributeNode(NewAttribute("v3x", vertices[2].x()));
  gtrapElement->setAttributeNode(NewAttribute("v3y", vertices[2].y()));
  gtrapElement->setAttributeNode(NewAttribute("v4x", vertices[3].x()));
  gtrapElement->setAttributeNode(NewAttribute("v4y", vertices[3].y()));
  gtrapElement->setAttributeNode(NewAttribute("v5x", vertices[4].x()));
  gtrapElement->setAttributeNode(NewAttribute("v5y", vertices[4].y()));
  gtrapElement->setAttributeNode(NewAttribute("v6x", vertices[5].x()));
  gtrapElement->setAttributeNode(NewAttribute("v6y", vertices[5].y()));
  gtrapElement->setAttributeNode(NewAttribute("v7x", vertices[6].x()));
  gtrapElement->setAttributeNode(NewAttribute("v7y", vertices[6].y()));
  gtrapElement->setAttributeNode(NewAttribute("v8x", vertices[7].x()));
  gtrapElement->setAttributeNode(NewAttribute("v8y", vertices[7].y()));
  gtrapElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(gtrapElement);
}

References G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4GenericTrap::GetVertices(), G4GenericTrap::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ 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 AssemblyWrite(), G4GDMLWriteSolids::BooleanWrite(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteParamvol::ParametersWrite(), PhysvolWrite(), and TraverseVolumeTree().

◆ GetBorderSurface()

const G4LogicalBorderSurface * G4GDMLWriteStructure::GetBorderSurface ( const G4VPhysicalVolume * const pvol )

protected

Definition at line 453 of file G4GDMLWriteStructure.cc.

{
  G4LogicalBorderSurface* surf = nullptr;
  G4int nsurf = G4LogicalBorderSurface::GetNumberOfBorderSurfaces();
  if(nsurf)
  {
    const G4LogicalBorderSurfaceTable* btable =
      G4LogicalBorderSurface::GetSurfaceTable();
    for(auto pos = btable->cbegin(); pos != btable->cend(); ++pos)
    {
      if(pvol == pos->first.first)  // just the first in the couple
      {                             // could be enough?
        surf = pos->second;         // break;
        BorderSurfaceCache(surf);
      }
    }
  }
  return surf;
}

References BorderSurfaceCache(), G4LogicalBorderSurface::GetNumberOfBorderSurfaces(), G4LogicalBorderSurface::GetSurfaceTable(), and pos.

Referenced by TraverseVolumeTree().

◆ GetMaxExportLevel()

G4int G4GDMLWriteStructure::GetMaxExportLevel ( ) const

Definition at line 905 of file G4GDMLWriteStructure.cc.

{
  return maxLevel;
}

References maxLevel.

◆ GetSkinSurface()

const G4LogicalSkinSurface * G4GDMLWriteStructure::GetSkinSurface ( const G4LogicalVolume * const lvol )

protected

Definition at line 431 of file G4GDMLWriteStructure.cc.

{
  G4LogicalSkinSurface* surf = 0;
  G4int nsurf = G4LogicalSkinSurface::GetNumberOfSkinSurfaces();
  if(nsurf)
  {
    const G4LogicalSkinSurfaceTable* stable =
      G4LogicalSkinSurface::GetSurfaceTable();
    for(auto pos = stable->cbegin(); pos != stable->cend(); ++pos)
    {
      if(lvol == (*pos)->GetLogicalVolume())
      {
        surf = *pos;
        break;
      }
    }
  }
  return surf;
}

References G4LogicalSkinSurface::GetNumberOfSkinSurfaces(), G4LogicalSkinSurface::GetSurfaceTable(), and pos.

Referenced by TraverseVolumeTree().

◆ Hype_dimensionsWrite()

void G4GDMLWriteParamvol::Hype_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Hype * const	hype
	)

protectedinherited

Definition at line 283 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* hype_dimensionsElement = NewElement("hype_dimensions");
  hype_dimensionsElement->setAttributeNode(
    NewAttribute("rmin", hype->GetInnerRadius() / mm));
  hype_dimensionsElement->setAttributeNode(
    NewAttribute("rmax", hype->GetOuterRadius() / mm));
  hype_dimensionsElement->setAttributeNode(
    NewAttribute("inst", hype->GetInnerStereo() / degree));
  hype_dimensionsElement->setAttributeNode(
    NewAttribute("outst", hype->GetOuterStereo() / degree));
  hype_dimensionsElement->setAttributeNode(
    NewAttribute("z", 2.0 * hype->GetZHalfLength() / mm));
  hype_dimensionsElement->setAttributeNode(NewAttribute("aunit", "deg"));
  hype_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(hype_dimensionsElement);
}

References degree, G4Hype::GetInnerRadius(), G4Hype::GetInnerStereo(), G4Hype::GetOuterRadius(), G4Hype::GetOuterStereo(), G4Hype::GetZHalfLength(), mm, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ HypeWrite()

void G4GDMLWriteSolids::HypeWrite	(	xercesc::DOMElement *	solElement,
		const G4Hype * const	hype
	)

protectedinherited

Definition at line 438 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(hype->GetName(), hype);
 
  xercesc::DOMElement* hypeElement = NewElement("hype");
  hypeElement->setAttributeNode(NewAttribute("name", name));
  hypeElement->setAttributeNode(
    NewAttribute("rmin", hype->GetInnerRadius() / mm));
  hypeElement->setAttributeNode(
    NewAttribute("rmax", hype->GetOuterRadius() / mm));
  hypeElement->setAttributeNode(
    NewAttribute("inst", hype->GetInnerStereo() / degree));
  hypeElement->setAttributeNode(
    NewAttribute("outst", hype->GetOuterStereo() / degree));
  hypeElement->setAttributeNode(
    NewAttribute("z", 2.0 * hype->GetZHalfLength() / mm));
  hypeElement->setAttributeNode(NewAttribute("aunit", "deg"));
  hypeElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(hypeElement);
}

References degree, G4GDMLWrite::GenerateName(), G4Hype::GetInnerRadius(), G4Hype::GetInnerStereo(), G4VSolid::GetName(), G4Hype::GetOuterRadius(), G4Hype::GetOuterStereo(), G4Hype::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ IsotopeWrite()

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

protectedinherited

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 G4GDMLWriteMaterials::AtomWrite(), G4GDMLWrite::GenerateName(), G4Isotope::GetA(), G4Isotope::GetN(), G4Isotope::GetName(), G4Isotope::GetZ(), G4GDMLWriteMaterials::materialsElement, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteMaterials::AddIsotope().

◆ MaterialsWrite()

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

virtualinherited

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 G4GDMLWriteMaterials::elementList, G4cout, G4endl, G4GDMLWriteMaterials::isotopeList, G4GDMLWriteMaterials::materialList, G4GDMLWriteMaterials::materialsElement, G4GDMLWrite::NewElement(), and G4GDMLWriteMaterials::propertyList.

◆ MaterialWrite()

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

protectedinherited

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 G4GDMLWriteMaterials::AddMaterial().

◆ MEEWrite()

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

protectedinherited

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 G4GDMLWriteMaterials::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 TraverseVolumeTree().

◆ MultiUnionWrite()

void G4GDMLWriteSolids::MultiUnionWrite	(	xercesc::DOMElement *	solElement,
		const G4MultiUnion * const	munionSolid
	)

protectedinherited

Definition at line 82 of file G4GDMLWriteSolids.cc.

{
  G4int numSolids = munionSolid->GetNumberOfSolids();
  G4String tag("multiUnion");
 
  G4VSolid* solid;
  G4Transform3D transform;
 
  const G4String& name = GenerateName(munionSolid->GetName(), munionSolid);
  xercesc::DOMElement* multiUnionElement = NewElement(tag);
  multiUnionElement->setAttributeNode(NewAttribute("name", name));
 
  for(G4int i = 0; i < numSolids; ++i)
  {
    solid     = munionSolid->GetSolid(i);
    transform = munionSolid->GetTransformation(i);
 
    HepGeom::Rotate3D rot3d;
    HepGeom::Translate3D transl;
    HepGeom::Scale3D scale;
    transform.getDecomposition(scale, rot3d, transl);
 
    G4ThreeVector pos = transl.getTranslation();
    G4RotationMatrix rotm(CLHEP::HepRep3x3(rot3d.xx(), rot3d.xy(), rot3d.xz(),
                                           rot3d.yx(), rot3d.yy(), rot3d.yz(),
                                           rot3d.zx(), rot3d.zy(), rot3d.zz()));
    G4ThreeVector rot = GetAngles(rotm);
 
    AddSolid(solid);
    const G4String& solidref = GenerateName(solid->GetName(), solid);
    std::ostringstream os;
    os << i + 1;
    const G4String& nodeName          = "Node-" + G4String(os.str());
    xercesc::DOMElement* solidElement = NewElement("solid");
    solidElement->setAttributeNode(NewAttribute("ref", solidref));
    xercesc::DOMElement* multiUnionNodeElement = NewElement("multiUnionNode");
    multiUnionNodeElement->setAttributeNode(NewAttribute("name", name+"_"+nodeName));
    multiUnionNodeElement->appendChild(solidElement);  // Append solid to node
    if((std::fabs(pos.x()) > kLinearPrecision) ||
       (std::fabs(pos.y()) > kLinearPrecision) ||
       (std::fabs(pos.z()) > kLinearPrecision))
    {
      PositionWrite(multiUnionNodeElement,name+"_"+nodeName+"_pos",pos);
    }
    if((std::fabs(rot.x()) > kAngularPrecision) ||
       (std::fabs(rot.y()) > kAngularPrecision) ||
       (std::fabs(rot.z()) > kAngularPrecision))
    {
      RotationWrite(multiUnionNodeElement,name+"_"+nodeName+"_rot",rot);
    }
    multiUnionElement->appendChild(multiUnionNodeElement);  // Append node
  }
 
  solElement->appendChild(multiUnionElement);
  // Add the multiUnion solid AFTER the constituent nodes!
}

Referenced by G4GDMLWriteSolids::AddSolid().

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

◆ OpticalSurfaceWrite()

void G4GDMLWriteSolids::OpticalSurfaceWrite	(	xercesc::DOMElement *	solElement,
		const G4OpticalSurface * const	surf
	)

protectedinherited

Definition at line 1058 of file G4GDMLWriteSolids.cc.

{
  xercesc::DOMElement* optElement = NewElement("opticalsurface");
  G4OpticalSurfaceModel smodel    = surf->GetModel();
  G4double sval =
    (smodel == glisur) ? surf->GetPolish() : surf->GetSigmaAlpha();
  const G4String& name = GenerateName(surf->GetName(), surf);
 
  optElement->setAttributeNode(NewAttribute("name", name));
  optElement->setAttributeNode(NewAttribute("model", smodel));
  optElement->setAttributeNode(NewAttribute("finish", surf->GetFinish()));
  optElement->setAttributeNode(NewAttribute("type", surf->GetType()));
  optElement->setAttributeNode(NewAttribute("value", sval));
 
  // Write any property attached to the optical surface...
  //
  if(surf->GetMaterialPropertiesTable())
  {
    PropertyWrite(optElement, surf);
  }
 
  solElement->appendChild(optElement);
}

References G4GDMLWrite::GenerateName(), G4OpticalSurface::GetFinish(), G4OpticalSurface::GetMaterialPropertiesTable(), G4OpticalSurface::GetModel(), G4SurfaceProperty::GetName(), G4OpticalSurface::GetPolish(), G4OpticalSurface::GetSigmaAlpha(), G4SurfaceProperty::GetType(), glisur, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), and G4GDMLWriteSolids::PropertyWrite().

Referenced by BorderSurfaceCache(), and SkinSurfaceCache().

◆ Orb_dimensionsWrite()

void G4GDMLWriteParamvol::Orb_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Orb * const	orb
	)

protectedinherited

Definition at line 204 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* orb_dimensionsElement = NewElement("orb_dimensions");
  orb_dimensionsElement->setAttributeNode(
    NewAttribute("r", orb->GetRadius() / mm));
  orb_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(orb_dimensionsElement);
}

References G4Orb::GetRadius(), mm, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ OrbWrite()

void G4GDMLWriteSolids::OrbWrite	(	xercesc::DOMElement *	solElement,
		const G4Orb * const	orb
	)

protectedinherited

Definition at line 461 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(orb->GetName(), orb);
 
  xercesc::DOMElement* orbElement = NewElement("orb");
  orbElement->setAttributeNode(NewAttribute("name", name));
  orbElement->setAttributeNode(NewAttribute("r", orb->GetRadius() / mm));
  orbElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(orbElement);
}

References G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4Orb::GetRadius(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ Para_dimensionsWrite()

void G4GDMLWriteParamvol::Para_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Para * const	para
	)

protectedinherited

Definition at line 255 of file G4GDMLWriteParamvol.cc.

{
  const G4ThreeVector simaxis = para->GetSymAxis();
 
  const G4double alpha = std::atan(para->GetTanAlpha());
  const G4double theta = std::acos(simaxis.z());
  const G4double phi =
    (simaxis.z() != 1.0) ? (std::atan(simaxis.y() / simaxis.x())) : (0.0);
 
  xercesc::DOMElement* para_dimensionsElement = NewElement("para_dimensions");
  para_dimensionsElement->setAttributeNode(
    NewAttribute("x", 2.0 * para->GetXHalfLength() / mm));
  para_dimensionsElement->setAttributeNode(
    NewAttribute("y", 2.0 * para->GetYHalfLength() / mm));
  para_dimensionsElement->setAttributeNode(
    NewAttribute("z", 2.0 * para->GetZHalfLength() / mm));
  para_dimensionsElement->setAttributeNode(
    NewAttribute("alpha", alpha / degree));
  para_dimensionsElement->setAttributeNode(
    NewAttribute("theta", theta / degree));
  para_dimensionsElement->setAttributeNode(NewAttribute("phi", phi / degree));
  para_dimensionsElement->setAttributeNode(NewAttribute("aunit", "deg"));
  para_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(para_dimensionsElement);
}

References alpha, degree, G4Para::GetSymAxis(), G4Para::GetTanAlpha(), G4Para::GetXHalfLength(), G4Para::GetYHalfLength(), G4Para::GetZHalfLength(), mm, G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ ParaboloidWrite()

void G4GDMLWriteSolids::ParaboloidWrite	(	xercesc::DOMElement *	solElement,
		const G4Paraboloid * const	paraboloid
	)

protectedinherited

Definition at line 501 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(paraboloid->GetName(), paraboloid);
 
  xercesc::DOMElement* paraboloidElement = NewElement("paraboloid");
  paraboloidElement->setAttributeNode(NewAttribute("name", name));
  paraboloidElement->setAttributeNode(
    NewAttribute("rlo", paraboloid->GetRadiusMinusZ() / mm));
  paraboloidElement->setAttributeNode(
    NewAttribute("rhi", paraboloid->GetRadiusPlusZ() / mm));
  paraboloidElement->setAttributeNode(
    NewAttribute("dz", paraboloid->GetZHalfLength() / mm));
  paraboloidElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(paraboloidElement);
}

References G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4Paraboloid::GetRadiusMinusZ(), G4Paraboloid::GetRadiusPlusZ(), G4Paraboloid::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ ParametersWrite()

void G4GDMLWriteParamvol::ParametersWrite	(	xercesc::DOMElement *	paramvolElement,
		const G4VPhysicalVolume * const	paramvol,
		const G4int &	index
	)

protectedinherited

Definition at line 363 of file G4GDMLWriteParamvol.cc.

{
  paramvol->GetParameterisation()->ComputeTransformation(
    index, const_cast<G4VPhysicalVolume*>(paramvol));
  G4ThreeVector Angles;
  G4String name = GenerateName(paramvol->GetName(), paramvol);
  std::stringstream os;
  os.precision(15);
  os << index;
  G4String sncopie = os.str();
 
  xercesc::DOMElement* parametersElement = NewElement("parameters");
  parametersElement->setAttributeNode(NewAttribute("number", index + 1));
 
  PositionWrite(parametersElement, name + sncopie + "_pos",
                paramvol->GetObjectTranslation());
  Angles = GetAngles(paramvol->GetObjectRotationValue());
  if(Angles.mag2() > DBL_EPSILON)
  {
    RotationWrite(parametersElement, name + sncopie + "_rot",
                  GetAngles(paramvol->GetObjectRotationValue()));
  }
  paramvolElement->appendChild(parametersElement);
 
  G4VSolid* solid = paramvol->GetLogicalVolume()->GetSolid();
 
  if(G4Box* box = dynamic_cast<G4Box*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *box, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Box_dimensionsWrite(parametersElement, box);
  }
  else if(G4Trd* trd = dynamic_cast<G4Trd*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *trd, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Trd_dimensionsWrite(parametersElement, trd);
  }
  else if(G4Trap* trap = dynamic_cast<G4Trap*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *trap, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Trap_dimensionsWrite(parametersElement, trap);
  }
  else if(G4Tubs* tube = dynamic_cast<G4Tubs*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *tube, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Tube_dimensionsWrite(parametersElement, tube);
  }
  else if(G4Cons* cone = dynamic_cast<G4Cons*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *cone, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Cone_dimensionsWrite(parametersElement, cone);
  }
  else if(G4Sphere* sphere = dynamic_cast<G4Sphere*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *sphere, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Sphere_dimensionsWrite(parametersElement, sphere);
  }
  else if(G4Orb* orb = dynamic_cast<G4Orb*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *orb, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Orb_dimensionsWrite(parametersElement, orb);
  }
  else if(G4Torus* torus = dynamic_cast<G4Torus*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *torus, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Torus_dimensionsWrite(parametersElement, torus);
  }
  else if(G4Ellipsoid* ellipsoid = dynamic_cast<G4Ellipsoid*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *ellipsoid, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Ellipsoid_dimensionsWrite(parametersElement, ellipsoid);
  }
  else if(G4Para* para = dynamic_cast<G4Para*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *para, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Para_dimensionsWrite(parametersElement, para);
  }
  else if(G4Hype* hype = dynamic_cast<G4Hype*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *hype, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Hype_dimensionsWrite(parametersElement, hype);
  }
  else if(G4Polycone* pcone = dynamic_cast<G4Polycone*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *pcone, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Polycone_dimensionsWrite(parametersElement, pcone);
  }
  else if(G4Polyhedra* polyhedra = dynamic_cast<G4Polyhedra*>(solid))
  {
    paramvol->GetParameterisation()->ComputeDimensions(
      *polyhedra, index, const_cast<G4VPhysicalVolume*>(paramvol));
    Polyhedra_dimensionsWrite(parametersElement, polyhedra);
  }
  else
  {
    G4String error_msg = "Solid '" + solid->GetName() +
                         "' cannot be used in parameterised volume!";
    G4Exception("G4GDMLWriteParamvol::ParametersWrite()", "InvalidSetup",
                FatalException, error_msg);
  }
}

Referenced by G4GDMLWriteParamvol::ParamvolAlgorithmWrite().

◆ ParamvolAlgorithmWrite()

void G4GDMLWriteParamvol::ParamvolAlgorithmWrite	(	xercesc::DOMElement *	paramvolElement,
		const G4VPhysicalVolume *const	paramvol
	)

virtualinherited

Definition at line 498 of file G4GDMLWriteParamvol.cc.

{
  const G4String volumeref = GenerateName(
    paramvol->GetLogicalVolume()->GetName(), paramvol->GetLogicalVolume());
 
  const G4int parameterCount = paramvol->GetMultiplicity();
 
  for(G4int i = 0; i < parameterCount; ++i)
  {
    ParametersWrite(paramvolElement, paramvol, i);
  }
}

References G4GDMLWrite::GenerateName(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetMultiplicity(), G4LogicalVolume::GetName(), and G4GDMLWriteParamvol::ParametersWrite().

Referenced by G4GDMLWriteParamvol::ParamvolWrite().

◆ ParamvolWrite()

void G4GDMLWriteParamvol::ParamvolWrite	(	xercesc::DOMElement *	volumeElement,
		const G4VPhysicalVolume * const	paramvol
	)

virtualinherited

Definition at line 478 of file G4GDMLWriteParamvol.cc.

{
  const G4String volumeref = GenerateName(
    paramvol->GetLogicalVolume()->GetName(), paramvol->GetLogicalVolume());
  xercesc::DOMElement* paramvolElement = NewElement("paramvol");
  paramvolElement->setAttributeNode(
    NewAttribute("ncopies", paramvol->GetMultiplicity()));
  xercesc::DOMElement* volumerefElement = NewElement("volumeref");
  volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
 
  xercesc::DOMElement* algorithmElement =
    NewElement("parameterised_position_size");
  paramvolElement->appendChild(volumerefElement);
  paramvolElement->appendChild(algorithmElement);
  ParamvolAlgorithmWrite(algorithmElement, paramvol);
  volumeElement->appendChild(paramvolElement);
}

References G4GDMLWrite::GenerateName(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetMultiplicity(), G4LogicalVolume::GetName(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), and G4GDMLWriteParamvol::ParamvolAlgorithmWrite().

Referenced by TraverseVolumeTree().

◆ ParaWrite()

void G4GDMLWriteSolids::ParaWrite	(	xercesc::DOMElement *	solElement,
		const G4Para * const	para
	)

protectedinherited

Definition at line 474 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(para->GetName(), para);
 
  const G4ThreeVector simaxis = para->GetSymAxis();
  const G4double alpha        = std::atan(para->GetTanAlpha());
  const G4double phi          = simaxis.phi();
  const G4double theta        = simaxis.theta();
 
  xercesc::DOMElement* paraElement = NewElement("para");
  paraElement->setAttributeNode(NewAttribute("name", name));
  paraElement->setAttributeNode(
    NewAttribute("x", 2.0 * para->GetXHalfLength() / mm));
  paraElement->setAttributeNode(
    NewAttribute("y", 2.0 * para->GetYHalfLength() / mm));
  paraElement->setAttributeNode(
    NewAttribute("z", 2.0 * para->GetZHalfLength() / mm));
  paraElement->setAttributeNode(NewAttribute("alpha", alpha / degree));
  paraElement->setAttributeNode(NewAttribute("theta", theta / degree));
  paraElement->setAttributeNode(NewAttribute("phi", phi / degree));
  paraElement->setAttributeNode(NewAttribute("aunit", "deg"));
  paraElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(paraElement);
}

References alpha, degree, G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4Para::GetSymAxis(), G4Para::GetTanAlpha(), G4Para::GetXHalfLength(), G4Para::GetYHalfLength(), G4Para::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), CLHEP::Hep3Vector::phi(), and CLHEP::Hep3Vector::theta().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ PhysvolWrite()

void G4GDMLWriteStructure::PhysvolWrite	(	xercesc::DOMElement *	volumeElement,
		const G4VPhysicalVolume *const	topVol,
		const G4Transform3D &	transform,
		const G4String &	moduleName
	)

protected

Definition at line 128 of file G4GDMLWriteStructure.cc.

{
  HepGeom::Scale3D scale;
  HepGeom::Rotate3D rotate;
  HepGeom::Translate3D translate;
 
  T.getDecomposition(scale, rotate, translate);
 
  const G4ThreeVector scl(scale(0, 0), scale(1, 1), scale(2, 2));
  const G4ThreeVector rot = GetAngles(rotate.getRotation());
  const G4ThreeVector pos = T.getTranslation();
 
  const G4String name    = GenerateName(physvol->GetName(), physvol);
  const G4int copynumber = physvol->GetCopyNo();
 
  xercesc::DOMElement* physvolElement = NewElement("physvol");
  physvolElement->setAttributeNode(NewAttribute("name", name));
  if(copynumber)
  {
    physvolElement->setAttributeNode(NewAttribute("copynumber", copynumber));
  }
 
  volumeElement->appendChild(physvolElement);
 
  G4LogicalVolume* lv;
  // Is it reflected?
  if(reflFactory->IsReflected(physvol->GetLogicalVolume()))
  {
    lv = reflFactory->GetConstituentLV(physvol->GetLogicalVolume());
  }
  else
  {
    lv = physvol->GetLogicalVolume();
  }
 
  const G4String volumeref = GenerateName(lv->GetName(), lv);
 
  if(ModuleName.empty())
  {
    xercesc::DOMElement* volumerefElement = NewElement("volumeref");
    volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
    physvolElement->appendChild(volumerefElement);
  }
  else
  {
    xercesc::DOMElement* fileElement = NewElement("file");
    fileElement->setAttributeNode(NewAttribute("name", ModuleName));
    fileElement->setAttributeNode(NewAttribute("volname", volumeref));
    physvolElement->appendChild(fileElement);
  }
 
  if(std::fabs(pos.x()) > kLinearPrecision ||
     std::fabs(pos.y()) > kLinearPrecision ||
     std::fabs(pos.z()) > kLinearPrecision)
  {
    PositionWrite(physvolElement, name + "_pos", pos);
  }
  if(std::fabs(rot.x()) > kAngularPrecision ||
     std::fabs(rot.y()) > kAngularPrecision ||
     std::fabs(rot.z()) > kAngularPrecision)
  {
    RotationWrite(physvolElement, name + "_rot", rot);
  }
  if(std::fabs(scl.x() - 1.0) > kRelativePrecision ||
     std::fabs(scl.y() - 1.0) > kRelativePrecision ||
     std::fabs(scl.z() - 1.0) > kRelativePrecision)
  {
    ScaleWrite(physvolElement, name + "_scl", scl);
  }
}

References G4GDMLWrite::GenerateName(), G4GDMLWriteDefine::GetAngles(), G4ReflectionFactory::GetConstituentLV(), G4VPhysicalVolume::GetCopyNo(), HepGeom::Transform3D::getDecomposition(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), HepGeom::Transform3D::getRotation(), HepGeom::Transform3D::getTranslation(), G4ReflectionFactory::IsReflected(), G4GDMLWriteDefine::kAngularPrecision, G4GDMLWriteDefine::kLinearPrecision, G4GDMLWriteDefine::kRelativePrecision, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), pos, G4GDMLWriteDefine::PositionWrite(), reflFactory, G4GDMLWriteDefine::RotationWrite(), G4GDMLWriteDefine::ScaleWrite(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by TraverseVolumeTree().

◆ Polycone_dimensionsWrite()

void G4GDMLWriteParamvol::Polycone_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Polycone * const	pcone
	)

protectedinherited

Definition at line 303 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* pcone_dimensionsElement =
    NewElement("polycone_dimensions");
 
  pcone_dimensionsElement->setAttributeNode(
    NewAttribute("numRZ", pcone->GetOriginalParameters()->Num_z_planes));
  pcone_dimensionsElement->setAttributeNode(NewAttribute(
    "startPhi", pcone->GetOriginalParameters()->Start_angle / degree));
  pcone_dimensionsElement->setAttributeNode(NewAttribute(
    "openPhi", pcone->GetOriginalParameters()->Opening_angle / degree));
  pcone_dimensionsElement->setAttributeNode(NewAttribute("aunit", "deg"));
  pcone_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
 
  parametersElement->appendChild(pcone_dimensionsElement);
  const size_t num_zplanes   = pcone->GetOriginalParameters()->Num_z_planes;
  const G4double* z_array    = pcone->GetOriginalParameters()->Z_values;
  const G4double* rmin_array = pcone->GetOriginalParameters()->Rmin;
  const G4double* rmax_array = pcone->GetOriginalParameters()->Rmax;
 
  for(std::size_t i = 0; i < num_zplanes; ++i)
  {
    ZplaneWrite(pcone_dimensionsElement, z_array[i], rmin_array[i],
                rmax_array[i]);
  }
}

References degree, G4Polycone::GetOriginalParameters(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), G4PolyconeHistorical::Num_z_planes, G4PolyconeHistorical::Opening_angle, G4PolyconeHistorical::Rmax, G4PolyconeHistorical::Rmin, G4PolyconeHistorical::Start_angle, G4PolyconeHistorical::Z_values, and G4GDMLWriteSolids::ZplaneWrite().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ PolyconeWrite()

void G4GDMLWriteSolids::PolyconeWrite	(	xercesc::DOMElement *	solElement,
		const G4Polycone * const	polycone
	)

protectedinherited

Definition at line 519 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(polycone->GetName(), polycone);
 
  xercesc::DOMElement* polyconeElement = NewElement("polycone");
  polyconeElement->setAttributeNode(NewAttribute("name", name));
  polyconeElement->setAttributeNode(NewAttribute(
    "startphi", polycone->GetOriginalParameters()->Start_angle / degree));
  polyconeElement->setAttributeNode(NewAttribute(
    "deltaphi", polycone->GetOriginalParameters()->Opening_angle / degree));
  polyconeElement->setAttributeNode(NewAttribute("aunit", "deg"));
  polyconeElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(polyconeElement);
 
  const std::size_t num_zplanes
        = polycone->GetOriginalParameters()->Num_z_planes;
  const G4double* z_array    = polycone->GetOriginalParameters()->Z_values;
  const G4double* rmin_array = polycone->GetOriginalParameters()->Rmin;
  const G4double* rmax_array = polycone->GetOriginalParameters()->Rmax;
 
  for(std::size_t i = 0; i < num_zplanes; ++i)
  {
    ZplaneWrite(polyconeElement, z_array[i], rmin_array[i], rmax_array[i]);
  }
}

References degree, G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4Polycone::GetOriginalParameters(), G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), G4PolyconeHistorical::Num_z_planes, G4PolyconeHistorical::Opening_angle, G4PolyconeHistorical::Rmax, G4PolyconeHistorical::Rmin, G4PolyconeHistorical::Start_angle, G4PolyconeHistorical::Z_values, and G4GDMLWriteSolids::ZplaneWrite().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ Polyhedra_dimensionsWrite()

void G4GDMLWriteParamvol::Polyhedra_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Polyhedra * const	polyhedra
	)

protectedinherited

Definition at line 332 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* polyhedra_dimensionsElement =
    NewElement("polyhedra_dimensions");
 
  polyhedra_dimensionsElement->setAttributeNode(
    NewAttribute("numRZ", polyhedra->GetOriginalParameters()->Num_z_planes));
  polyhedra_dimensionsElement->setAttributeNode(
    NewAttribute("numSide", polyhedra->GetOriginalParameters()->numSide));
  polyhedra_dimensionsElement->setAttributeNode(NewAttribute(
    "startPhi", polyhedra->GetOriginalParameters()->Start_angle / degree));
  polyhedra_dimensionsElement->setAttributeNode(NewAttribute(
    "openPhi", polyhedra->GetOriginalParameters()->Opening_angle / degree));
  polyhedra_dimensionsElement->setAttributeNode(NewAttribute("aunit", "deg"));
  polyhedra_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
 
  parametersElement->appendChild(polyhedra_dimensionsElement);
  const size_t num_zplanes   = polyhedra->GetOriginalParameters()->Num_z_planes;
  const G4double* z_array    = polyhedra->GetOriginalParameters()->Z_values;
  const G4double* rmin_array = polyhedra->GetOriginalParameters()->Rmin;
  const G4double* rmax_array = polyhedra->GetOriginalParameters()->Rmax;
 
  for(std::size_t i = 0; i < num_zplanes; ++i)
  {
    ZplaneWrite(polyhedra_dimensionsElement, z_array[i], rmin_array[i],
                rmax_array[i]);
  }
}

References degree, G4Polyhedra::GetOriginalParameters(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), G4PolyhedraHistorical::Num_z_planes, G4PolyhedraHistorical::numSide, G4PolyhedraHistorical::Opening_angle, G4PolyhedraHistorical::Rmax, G4PolyhedraHistorical::Rmin, G4PolyhedraHistorical::Start_angle, G4PolyhedraHistorical::Z_values, and G4GDMLWriteSolids::ZplaneWrite().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ PolyhedraWrite()

void G4GDMLWriteSolids::PolyhedraWrite	(	xercesc::DOMElement *	solElement,
		const G4Polyhedra * const	polyhedra
	)

protectedinherited

Definition at line 572 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(polyhedra->GetName(), polyhedra);
  if(polyhedra->IsGeneric() == false)
  {
    xercesc::DOMElement* polyhedraElement = NewElement("polyhedra");
    polyhedraElement->setAttributeNode(NewAttribute("name", name));
    polyhedraElement->setAttributeNode(NewAttribute(
      "startphi", polyhedra->GetOriginalParameters()->Start_angle / degree));
    polyhedraElement->setAttributeNode(NewAttribute(
      "deltaphi", polyhedra->GetOriginalParameters()->Opening_angle / degree));
    polyhedraElement->setAttributeNode(
      NewAttribute("numsides", polyhedra->GetOriginalParameters()->numSide));
    polyhedraElement->setAttributeNode(NewAttribute("aunit", "deg"));
    polyhedraElement->setAttributeNode(NewAttribute("lunit", "mm"));
    solElement->appendChild(polyhedraElement);
 
    const std::size_t num_zplanes
          = polyhedra->GetOriginalParameters()->Num_z_planes;
    const G4double* z_array  = polyhedra->GetOriginalParameters()->Z_values;
    const G4double* rmin_array = polyhedra->GetOriginalParameters()->Rmin;
    const G4double* rmax_array = polyhedra->GetOriginalParameters()->Rmax;
 
    const G4double convertRad =
      std::cos(0.5 * polyhedra->GetOriginalParameters()->Opening_angle /
               polyhedra->GetOriginalParameters()->numSide);
 
    for(std::size_t i = 0; i < num_zplanes; ++i)
    {
      ZplaneWrite(polyhedraElement, z_array[i], rmin_array[i] * convertRad,
                  rmax_array[i] * convertRad);
    }
  }
  else  // generic polyhedra
  {
    xercesc::DOMElement* polyhedraElement = NewElement("genericPolyhedra");
    polyhedraElement->setAttributeNode(NewAttribute("name", name));
    polyhedraElement->setAttributeNode(NewAttribute(
      "startphi", polyhedra->GetOriginalParameters()->Start_angle / degree));
    polyhedraElement->setAttributeNode(NewAttribute(
      "deltaphi", polyhedra->GetOriginalParameters()->Opening_angle / degree));
    polyhedraElement->setAttributeNode(
      NewAttribute("numsides", polyhedra->GetOriginalParameters()->numSide));
    polyhedraElement->setAttributeNode(NewAttribute("aunit", "deg"));
    polyhedraElement->setAttributeNode(NewAttribute("lunit", "mm"));
    solElement->appendChild(polyhedraElement);
 
    const std::size_t num_rzpoints = polyhedra->GetNumRZCorner();
 
    for(std::size_t i = 0; i < num_rzpoints; ++i)
    {
      const G4double r_point = polyhedra->GetCorner(i).r;
      const G4double z_point = polyhedra->GetCorner(i).z;
      RZPointWrite(polyhedraElement, r_point, z_point);
    }
  }
}

References degree, G4GDMLWrite::GenerateName(), G4Polyhedra::GetCorner(), G4VSolid::GetName(), G4Polyhedra::GetNumRZCorner(), G4Polyhedra::GetOriginalParameters(), G4Polyhedra::IsGeneric(), G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), G4PolyhedraHistorical::Num_z_planes, G4PolyhedraHistorical::numSide, G4PolyhedraHistorical::Opening_angle, G4PolyhedraSideRZ::r, G4PolyhedraHistorical::Rmax, G4PolyhedraHistorical::Rmin, G4GDMLWriteSolids::RZPointWrite(), G4PolyhedraHistorical::Start_angle, G4PolyhedraSideRZ::z, G4PolyhedraHistorical::Z_values, and G4GDMLWriteSolids::ZplaneWrite().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ 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 AssemblyWrite(), G4GDMLWriteSolids::BooleanWrite(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteParamvol::ParametersWrite(), PhysvolWrite(), and TraverseVolumeTree().

◆ PropertyConstWrite()

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

protectedinherited

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 G4GDMLWriteMaterials::PropertyWrite().

◆ PropertyVectorWrite()

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

protectedinherited

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 G4GDMLWriteMaterials::propertyList.

Referenced by G4GDMLWriteMaterials::PropertyWrite(), and G4GDMLWriteSolids::PropertyWrite().

◆ PropertyWrite() [1/2]

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

protectedinherited

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(), G4GDMLWriteMaterials::PropertyConstWrite(), G4GDMLWriteMaterials::PropertyVectorWrite(), and second.

Referenced by G4GDMLWriteMaterials::MaterialWrite().

◆ PropertyWrite() [2/2]

void G4GDMLWriteSolids::PropertyWrite	(	xercesc::DOMElement *	optElement,
		const G4OpticalSurface * const	surf
	)

protectedinherited

Definition at line 1084 of file G4GDMLWriteSolids.cc.

{
  xercesc::DOMElement* propElement;
  G4MaterialPropertiesTable* ptable = surf->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]);
      optElement->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", ptable->GetMaterialConstPropertyNames()[i]));
      xercesc::DOMElement* constElement = NewElement("constant");
      constElement->setAttributeNode(NewAttribute(
        "name", ptable->GetMaterialConstPropertyNames()[i]));
      constElement->setAttributeNode(NewAttribute("value", cvec[i].first));
      defineElement->appendChild(constElement);
      optElement->appendChild(propElement);
    }
  }
}

References G4GDMLWriteDefine::defineElement, G4GDMLWrite::GenerateName(), G4MaterialPropertiesTable::GetConstProperties(), G4MaterialPropertiesTable::GetMaterialConstPropertyNames(), G4OpticalSurface::GetMaterialPropertiesTable(), G4MaterialPropertiesTable::GetMaterialPropertyNames(), G4MaterialPropertiesTable::GetProperties(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), G4GDMLWriteMaterials::PropertyVectorWrite(), and second.

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite().

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

protectedinherited

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 G4GDMLWriteMaterials::MaterialWrite().

◆ ReplicavolWrite()

void G4GDMLWriteStructure::ReplicavolWrite	(	xercesc::DOMElement *	volumeElement,
		const G4VPhysicalVolume * const	replicavol
	)

protected

Definition at line 203 of file G4GDMLWriteStructure.cc.

{
  EAxis axis       = kUndefined;
  G4int number     = 0;
  G4double width   = 0.0;
  G4double offset  = 0.0;
  G4bool consuming = false;
  G4String unitString("mm");
 
  replicavol->GetReplicationData(axis, number, width, offset, consuming);
 
  const G4String volumeref = GenerateName(
    replicavol->GetLogicalVolume()->GetName(), replicavol->GetLogicalVolume());
 
  xercesc::DOMElement* replicavolElement = NewElement("replicavol");
  replicavolElement->setAttributeNode(NewAttribute("number", number));
  xercesc::DOMElement* volumerefElement = NewElement("volumeref");
  volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
  replicavolElement->appendChild(volumerefElement);
  xercesc::DOMElement* replicateElement = NewElement("replicate_along_axis");
  replicavolElement->appendChild(replicateElement);
 
  xercesc::DOMElement* dirElement = NewElement("direction");
  if(axis == kXAxis)
  {
    dirElement->setAttributeNode(NewAttribute("x", "1"));
  }
  else if(axis == kYAxis)
  {
    dirElement->setAttributeNode(NewAttribute("y", "1"));
  }
  else if(axis == kZAxis)
  {
    dirElement->setAttributeNode(NewAttribute("z", "1"));
  }
  else if(axis == kRho)
  {
    dirElement->setAttributeNode(NewAttribute("rho", "1"));
  }
  else if(axis == kPhi)
  {
    dirElement->setAttributeNode(NewAttribute("phi", "1"));
    unitString = "rad";
  }
  replicateElement->appendChild(dirElement);
 
  xercesc::DOMElement* widthElement = NewElement("width");
  widthElement->setAttributeNode(NewAttribute("value", width));
  widthElement->setAttributeNode(NewAttribute("unit", unitString));
  replicateElement->appendChild(widthElement);
 
  xercesc::DOMElement* offsetElement = NewElement("offset");
  offsetElement->setAttributeNode(NewAttribute("value", offset));
  offsetElement->setAttributeNode(NewAttribute("unit", unitString));
  replicateElement->appendChild(offsetElement);
 
  volumeElement->appendChild(replicavolElement);
}

References G4GDMLWrite::GenerateName(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetReplicationData(), kPhi, kRho, kUndefined, kXAxis, kYAxis, kZAxis, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by TraverseVolumeTree().

◆ 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 AssemblyWrite(), G4GDMLWriteSolids::BooleanWrite(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteParamvol::ParametersWrite(), PhysvolWrite(), and TraverseVolumeTree().

◆ RZPointWrite()

void G4GDMLWriteSolids::RZPointWrite	(	xercesc::DOMElement *	element,
		const G4double &	r,
		const G4double &	z
	)

protectedinherited

Definition at line 1048 of file G4GDMLWriteSolids.cc.

{
  xercesc::DOMElement* rzpointElement = NewElement("rzpoint");
  rzpointElement->setAttributeNode(NewAttribute("r", r / mm));
  rzpointElement->setAttributeNode(NewAttribute("z", z / mm));
  element->appendChild(rzpointElement);
}

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

Referenced by G4GDMLWriteSolids::GenericPolyconeWrite(), and G4GDMLWriteSolids::PolyhedraWrite().

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

◆ ScaledWrite()

void G4GDMLWriteSolids::ScaledWrite	(	xercesc::DOMElement *	solElement,
		const G4ScaledSolid * const	scaled
	)

protectedinherited

Definition at line 259 of file G4GDMLWriteSolids.cc.

{
  G4String tag("scaledSolid");
 
  G4VSolid* solid         = const_cast<G4VSolid*>(scaled->GetUnscaledSolid());
  G4Scale3D scale         = scaled->GetScaleTransform();
  G4ThreeVector sclVector = G4ThreeVector(scale.xx(), scale.yy(), scale.zz());
 
  AddSolid(solid);  // Add the constituent solid!
 
  const G4String& name     = GenerateName(scaled->GetName(), scaled);
  const G4String& solidref = GenerateName(solid->GetName(), solid);
 
  xercesc::DOMElement* scaledElement = NewElement(tag);
  scaledElement->setAttributeNode(NewAttribute("name", name));
 
  xercesc::DOMElement* solidElement = NewElement("solidref");
  solidElement->setAttributeNode(NewAttribute("ref", solidref));
  scaledElement->appendChild(solidElement);
 
  if((std::fabs(scale.xx()) > kLinearPrecision) &&
     (std::fabs(scale.yy()) > kLinearPrecision) &&
     (std::fabs(scale.zz()) > kLinearPrecision))
  {
    ScaleWrite(scaledElement, name + "_scl", sclVector);
  }
 
  solElement->appendChild(scaledElement);
  // Add the scaled solid AFTER its constituent solid!
}

References G4GDMLWriteSolids::AddSolid(), G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4ScaledSolid::GetScaleTransform(), G4ScaledSolid::GetUnscaledSolid(), G4GDMLWriteDefine::kLinearPrecision, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), G4GDMLWriteDefine::ScaleWrite(), HepGeom::Transform3D::xx(), HepGeom::Transform3D::yy(), and HepGeom::Transform3D::zz().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ 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 PhysvolWrite(), G4GDMLWriteSolids::ScaledWrite(), and TraverseVolumeTree().

◆ SetAddPointerToName()

void G4GDMLWrite::SetAddPointerToName ( G4bool set )

staticinherited

Definition at line 410 of file G4GDMLWrite.cc.

{
  addPointerToName = set;
}

References G4GDMLWrite::addPointerToName.

◆ SetEnergyCutsExport()

void G4GDMLWriteStructure::SetEnergyCutsExport ( G4bool fcuts )

Definition at line 843 of file G4GDMLWriteStructure.cc.

{
  cexport = fcuts;
}

References cexport.

◆ SetMaxExportLevel()

void G4GDMLWriteStructure::SetMaxExportLevel ( G4int level )

Definition at line 911 of file G4GDMLWriteStructure.cc.

{
  if(level <= 0)
  {
    G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()", "InvalidSetup",
                FatalException, "Levels to export must be greater than zero!");
    return;
  }
  maxLevel = level;
  levelNo  = 0;
}

References FatalException, G4Exception(), levelNo, and maxLevel.

◆ SetOutputFileOverwrite()

void G4GDMLWrite::SetOutputFileOverwrite ( G4bool flag )

inherited

Definition at line 404 of file G4GDMLWrite.cc.

{
  overwriteOutputFile = flag; 
}

References G4GDMLWrite::overwriteOutputFile.

◆ SetSDExport()

void G4GDMLWriteStructure::SetSDExport ( G4bool fsd )

Definition at line 885 of file G4GDMLWriteStructure.cc.

{
  sdexport = fsd;
}

References sdexport.

◆ SetupWrite()

void G4GDMLWriteSetup::SetupWrite	(	xercesc::DOMElement *	gdmlElement,
		const G4LogicalVolume * const	logvol
	)

virtualinherited

Implements G4GDMLWrite.

Definition at line 47 of file G4GDMLWriteSetup.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Writing setup..." << G4endl;
#endif
  const G4String worldref = GenerateName(logvol->GetName(), logvol);
 
  xercesc::DOMElement* setupElement = NewElement("setup");
  setupElement->setAttributeNode(NewAttribute("version", "1.0"));
  setupElement->setAttributeNode(NewAttribute("name", "Default"));
  xercesc::DOMElement* worldElement = NewElement("world");
  worldElement->setAttributeNode(NewAttribute("ref", worldref));
  setupElement->appendChild(worldElement);
  gdmlElement->appendChild(setupElement);
}

References G4cout, G4endl, G4GDMLWrite::GenerateName(), G4LogicalVolume::GetName(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

◆ SkinSurfaceCache()

void G4GDMLWriteStructure::SkinSurfaceCache ( const G4LogicalSkinSurface * const ssurf )

protected

Definition at line 376 of file G4GDMLWriteStructure.cc.

{
  if(ssurf == nullptr)
  {
    return;
  }
 
  const G4SurfaceProperty* psurf = ssurf->GetSurfaceProperty();
 
  // Generate the new element for border-surface
  //
  const G4String& ssname           = GenerateName(ssurf->GetName(), ssurf);
  const G4String& psname           = GenerateName(psurf->GetName(), psurf);
  xercesc::DOMElement* skinElement = NewElement("skinsurface");
  skinElement->setAttributeNode(NewAttribute("name", ssname));
  skinElement->setAttributeNode(NewAttribute("surfaceproperty", psname));
 
  const G4String volumeref = GenerateName(ssurf->GetLogicalVolume()->GetName(),
                                          ssurf->GetLogicalVolume());
  xercesc::DOMElement* volumerefElement = NewElement("volumeref");
  volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
  skinElement->appendChild(volumerefElement);
 
  if(FindOpticalSurface(psurf))
  {
    const G4OpticalSurface* opsurf =
      dynamic_cast<const G4OpticalSurface*>(psurf);
    if(opsurf == nullptr)
    {
      G4Exception("G4GDMLWriteStructure::SkinSurfaceCache()", "InvalidSetup",
                  FatalException, "No optical surface found!");
      return;
    }
    OpticalSurfaceWrite(solidsElement, opsurf);
  }
 
  skinElementVec.push_back(skinElement);
}

References FatalException, FindOpticalSurface(), G4Exception(), G4GDMLWrite::GenerateName(), G4LogicalSkinSurface::GetLogicalVolume(), G4LogicalSurface::GetName(), G4LogicalVolume::GetName(), G4SurfaceProperty::GetName(), G4LogicalSurface::GetSurfaceProperty(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), G4GDMLWriteSolids::OpticalSurfaceWrite(), skinElementVec, and G4GDMLWriteSolids::solidsElement.

Referenced by TraverseVolumeTree().

◆ SolidsWrite()

void G4GDMLWriteSolids::SolidsWrite ( xercesc::DOMElement * gdmlElement )

virtualinherited

Implements G4GDMLWrite.

Definition at line 1125 of file G4GDMLWriteSolids.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Writing solids..." << G4endl;
#endif
  solidsElement = NewElement("solids");
  gdmlElement->appendChild(solidsElement);
 
  solidList.clear();
}

References G4cout, G4endl, G4GDMLWrite::NewElement(), G4GDMLWriteSolids::solidList, and G4GDMLWriteSolids::solidsElement.

◆ Sphere_dimensionsWrite()

void G4GDMLWriteParamvol::Sphere_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Sphere * const	sphere
	)

protectedinherited

Definition at line 181 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* sphere_dimensionsElement =
    NewElement("sphere_dimensions");
  sphere_dimensionsElement->setAttributeNode(
    NewAttribute("rmin", sphere->GetInnerRadius() / mm));
  sphere_dimensionsElement->setAttributeNode(
    NewAttribute("rmax", sphere->GetOuterRadius() / mm));
  sphere_dimensionsElement->setAttributeNode(
    NewAttribute("startphi", sphere->GetStartPhiAngle() / degree));
  sphere_dimensionsElement->setAttributeNode(
    NewAttribute("deltaphi", sphere->GetDeltaPhiAngle() / degree));
  sphere_dimensionsElement->setAttributeNode(
    NewAttribute("starttheta", sphere->GetStartThetaAngle() / degree));
  sphere_dimensionsElement->setAttributeNode(
    NewAttribute("deltatheta", sphere->GetDeltaThetaAngle() / degree));
  sphere_dimensionsElement->setAttributeNode(NewAttribute("aunit", "deg"));
  sphere_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(sphere_dimensionsElement);
}

References degree, G4Sphere::GetDeltaPhiAngle(), G4Sphere::GetDeltaThetaAngle(), G4Sphere::GetInnerRadius(), G4Sphere::GetOuterRadius(), G4Sphere::GetStartPhiAngle(), G4Sphere::GetStartThetaAngle(), mm, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ SphereWrite()

void G4GDMLWriteSolids::SphereWrite	(	xercesc::DOMElement *	solElement,
		const G4Sphere * const	sphere
	)

protectedinherited

Definition at line 632 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(sphere->GetName(), sphere);
 
  xercesc::DOMElement* sphereElement = NewElement("sphere");
  sphereElement->setAttributeNode(NewAttribute("name", name));
  sphereElement->setAttributeNode(
    NewAttribute("rmin", sphere->GetInnerRadius() / mm));
  sphereElement->setAttributeNode(
    NewAttribute("rmax", sphere->GetOuterRadius() / mm));
  sphereElement->setAttributeNode(
    NewAttribute("startphi", sphere->GetStartPhiAngle() / degree));
  sphereElement->setAttributeNode(
    NewAttribute("deltaphi", sphere->GetDeltaPhiAngle() / degree));
  sphereElement->setAttributeNode(
    NewAttribute("starttheta", sphere->GetStartThetaAngle() / degree));
  sphereElement->setAttributeNode(
    NewAttribute("deltatheta", sphere->GetDeltaThetaAngle() / degree));
  sphereElement->setAttributeNode(NewAttribute("aunit", "deg"));
  sphereElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(sphereElement);
}

References degree, G4GDMLWrite::GenerateName(), G4Sphere::GetDeltaPhiAngle(), G4Sphere::GetDeltaThetaAngle(), G4Sphere::GetInnerRadius(), G4VSolid::GetName(), G4Sphere::GetOuterRadius(), G4Sphere::GetStartPhiAngle(), G4Sphere::GetStartThetaAngle(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ StructureWrite()

void G4GDMLWriteStructure::StructureWrite ( xercesc::DOMElement * gdmlElement )

virtual

Implements G4GDMLWrite.

Definition at line 493 of file G4GDMLWriteStructure.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Writing structure..." << G4endl;
#endif
 
  // filling the list of phys volumes that are parts of assemblies
 
  G4AssemblyStore* assemblies = G4AssemblyStore::GetInstance();
 
  for(auto it = assemblies->cbegin(); it != assemblies->cend(); ++it)
  {
    auto vit = (*it)->GetVolumesIterator();
 
    for(std::size_t i5 = 0; i5 < (*it)->TotalImprintedVolumes(); ++i5)
    {
      G4String pvname = (*vit)->GetName();
      std::size_t pos = pvname.find("_impr_") + 6;
      G4String impID  = pvname.substr(pos);
 
      pos   = impID.find("_");
      impID = impID.substr(0, pos);
 
      assemblyVolMap[*vit] = (*it)->GetAssemblyID();
      imprintsMap[*vit]    = std::atoi(impID.c_str());
      ++vit;
    }
  }
 
  structureElement = NewElement("structure");
  gdmlElement->appendChild(structureElement);
}

References assemblyVolMap, G4cout, G4endl, G4AssemblyStore::GetInstance(), imprintsMap, G4GDMLWrite::NewElement(), pos, and structureElement.

◆ SurfacesWrite()

void G4GDMLWriteStructure::SurfacesWrite ( )

protectedvirtual

Implements G4GDMLWrite.

Definition at line 475 of file G4GDMLWriteStructure.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Writing surfaces..." << G4endl;
#endif
  for(auto pos = skinElementVec.cbegin();
           pos != skinElementVec.cend(); ++pos)
  {
    structureElement->appendChild(*pos);
  }
  for(auto pos = borderElementVec.cbegin();
           pos != borderElementVec.cend(); ++pos)
  {
    structureElement->appendChild(*pos);
  }
}

References borderElementVec, G4cout, G4endl, pos, skinElementVec, and structureElement.

◆ TessellatedWrite()

void G4GDMLWriteSolids::TessellatedWrite	(	xercesc::DOMElement *	solElement,
		const G4TessellatedSolid * const	tessellated
	)

protectedinherited

Definition at line 657 of file G4GDMLWriteSolids.cc.

{
  const G4String& solid_name = tessellated->GetName();
  const G4String& name       = GenerateName(solid_name, tessellated);
 
  xercesc::DOMElement* tessellatedElement = NewElement("tessellated");
  tessellatedElement->setAttributeNode(NewAttribute("name", name));
  tessellatedElement->setAttributeNode(NewAttribute("aunit", "deg"));
  tessellatedElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(tessellatedElement);
 
  std::map<G4ThreeVector, G4String, G4ThreeVectorCompare> vertexMap;
 
  const std::size_t NumFacets = tessellated->GetNumberOfFacets();
  std::size_t NumVertex       = 0;
 
  for(std::size_t i = 0; i < NumFacets; ++i)
  {
    const G4VFacet* facet          = tessellated->GetFacet(i);
    const size_t NumVertexPerFacet = facet->GetNumberOfVertices();
 
    G4String FacetTag;
 
    if(NumVertexPerFacet == 3)
    {
      FacetTag = "triangular";
    }
    else if(NumVertexPerFacet == 4)
    {
      FacetTag = "quadrangular";
    }
    else
    {
      G4Exception("G4GDMLWriteSolids::TessellatedWrite()", "InvalidSetup",
                  FatalException, "Facet should contain 3 or 4 vertices!");
    }
 
    xercesc::DOMElement* facetElement = NewElement(FacetTag);
    tessellatedElement->appendChild(facetElement);
 
    for(std::size_t j = 0; j < NumVertexPerFacet; ++j)
    {
      std::stringstream name_stream;
      std::stringstream ref_stream;
 
      name_stream << "vertex" << (j + 1);
      ref_stream << solid_name << "_v" << NumVertex;
 
      const G4String& fname = name_stream.str();  // facet's tag variable
      G4String ref          = ref_stream.str();   // vertex tag to be associated
 
      // Now search for the existance of the current vertex in the
      // map of cached vertices. If existing, do NOT store it as
      // position in the GDML file, so avoiding duplication; otherwise
      // cache it in the local map and add it as position in the
      // "define" section of the GDML file.
 
      const G4ThreeVector& vertex = facet->GetVertex(j);
 
      if(vertexMap.find(vertex) != vertexMap.cend())  // Vertex is cached
      {
        ref = vertexMap[vertex];  // Set the proper tag for it
      }
      else  // Vertex not found
      {
        vertexMap.insert(std::make_pair(vertex, ref));  // Cache vertex and ...
        AddPosition(ref, vertex);  // ... add it to define section!
        ++NumVertex;
      }
 
      // Now create association of the vertex with its facet
      //
      facetElement->setAttributeNode(NewAttribute(fname, ref));
    }
  }
}

References G4GDMLWriteDefine::AddPosition(), FatalException, test::fname, G4Exception(), G4GDMLWrite::GenerateName(), G4TessellatedSolid::GetFacet(), G4VSolid::GetName(), G4TessellatedSolid::GetNumberOfFacets(), G4VFacet::GetNumberOfVertices(), G4VFacet::GetVertex(), G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ TetWrite()

void G4GDMLWriteSolids::TetWrite	(	xercesc::DOMElement *	solElement,
		const G4Tet * const	tet
	)

protectedinherited

Definition at line 736 of file G4GDMLWriteSolids.cc.

{
  const G4String& solid_name = tet->GetName();
  const G4String& name       = GenerateName(solid_name, tet);
 
  std::vector<G4ThreeVector> vertexList = tet->GetVertices();
 
  xercesc::DOMElement* tetElement = NewElement("tet");
  tetElement->setAttributeNode(NewAttribute("name", name));
  tetElement->setAttributeNode(NewAttribute("vertex1", solid_name + "_v1"));
  tetElement->setAttributeNode(NewAttribute("vertex2", solid_name + "_v2"));
  tetElement->setAttributeNode(NewAttribute("vertex3", solid_name + "_v3"));
  tetElement->setAttributeNode(NewAttribute("vertex4", solid_name + "_v4"));
  tetElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(tetElement);
 
  AddPosition(solid_name + "_v1", vertexList[0]);
  AddPosition(solid_name + "_v2", vertexList[1]);
  AddPosition(solid_name + "_v3", vertexList[2]);
  AddPosition(solid_name + "_v4", vertexList[3]);
}

References G4GDMLWriteDefine::AddPosition(), G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4Tet::GetVertices(), G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ Torus_dimensionsWrite()

void G4GDMLWriteParamvol::Torus_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Torus * const	torus
	)

protectedinherited

Definition at line 215 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* torus_dimensionsElement = NewElement("torus_dimensions");
  torus_dimensionsElement->setAttributeNode(
    NewAttribute("rmin", torus->GetRmin() / mm));
  torus_dimensionsElement->setAttributeNode(
    NewAttribute("rmax", torus->GetRmax() / mm));
  torus_dimensionsElement->setAttributeNode(
    NewAttribute("rtor", torus->GetRtor() / mm));
  torus_dimensionsElement->setAttributeNode(
    NewAttribute("startphi", torus->GetSPhi() / degree));
  torus_dimensionsElement->setAttributeNode(
    NewAttribute("deltaphi", torus->GetDPhi() / degree));
  torus_dimensionsElement->setAttributeNode(NewAttribute("aunit", "deg"));
  torus_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(torus_dimensionsElement);
}

References degree, G4Torus::GetDPhi(), G4Torus::GetRmax(), G4Torus::GetRmin(), G4Torus::GetRtor(), G4Torus::GetSPhi(), mm, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ TorusWrite()

void G4GDMLWriteSolids::TorusWrite	(	xercesc::DOMElement *	solElement,
		const G4Torus * const	torus
	)

protectedinherited

Definition at line 760 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(torus->GetName(), torus);
 
  xercesc::DOMElement* torusElement = NewElement("torus");
  torusElement->setAttributeNode(NewAttribute("name", name));
  torusElement->setAttributeNode(NewAttribute("rmin", torus->GetRmin() / mm));
  torusElement->setAttributeNode(NewAttribute("rmax", torus->GetRmax() / mm));
  torusElement->setAttributeNode(NewAttribute("rtor", torus->GetRtor() / mm));
  torusElement->setAttributeNode(
    NewAttribute("startphi", torus->GetSPhi() / degree));
  torusElement->setAttributeNode(
    NewAttribute("deltaphi", torus->GetDPhi() / degree));
  torusElement->setAttributeNode(NewAttribute("aunit", "deg"));
  torusElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(torusElement);
}

References degree, G4GDMLWrite::GenerateName(), G4Torus::GetDPhi(), G4VSolid::GetName(), G4Torus::GetRmax(), G4Torus::GetRmin(), G4Torus::GetRtor(), G4Torus::GetSPhi(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ Trap_dimensionsWrite()

void G4GDMLWriteParamvol::Trap_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Trap * const	trap
	)

protectedinherited

Definition at line 99 of file G4GDMLWriteParamvol.cc.

{
  const G4ThreeVector simaxis = trap->GetSymAxis();
  const G4double phi =
    (simaxis.z() != 1.0) ? (std::atan(simaxis.y() / simaxis.x())) : (0.0);
  const G4double theta  = std::acos(simaxis.z());
  const G4double alpha1 = std::atan(trap->GetTanAlpha1());
  const G4double alpha2 = std::atan(trap->GetTanAlpha2());
 
  xercesc::DOMElement* trap_dimensionsElement = NewElement("trap");
  trap_dimensionsElement->setAttributeNode(
    NewAttribute("z", 2.0 * trap->GetZHalfLength() / mm));
  trap_dimensionsElement->setAttributeNode(
    NewAttribute("theta", theta / degree));
  trap_dimensionsElement->setAttributeNode(NewAttribute("phi", phi / degree));
  trap_dimensionsElement->setAttributeNode(
    NewAttribute("y1", 2.0 * trap->GetYHalfLength1() / mm));
  trap_dimensionsElement->setAttributeNode(
    NewAttribute("x1", 2.0 * trap->GetXHalfLength1() / mm));
  trap_dimensionsElement->setAttributeNode(
    NewAttribute("x2", 2.0 * trap->GetXHalfLength2() / mm));
  trap_dimensionsElement->setAttributeNode(
    NewAttribute("alpha1", alpha1 / degree));
  trap_dimensionsElement->setAttributeNode(
    NewAttribute("y2", 2.0 * trap->GetYHalfLength2() / mm));
  trap_dimensionsElement->setAttributeNode(
    NewAttribute("x3", 2.0 * trap->GetXHalfLength3() / mm));
  trap_dimensionsElement->setAttributeNode(
    NewAttribute("x4", 2.0 * trap->GetXHalfLength4() / mm));
  trap_dimensionsElement->setAttributeNode(
    NewAttribute("alpha2", alpha2 / degree));
  trap_dimensionsElement->setAttributeNode(NewAttribute("aunit", "deg"));
  trap_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(trap_dimensionsElement);
}

References alpha2, degree, G4Trap::GetSymAxis(), G4Trap::GetTanAlpha1(), G4Trap::GetTanAlpha2(), G4Trap::GetXHalfLength1(), G4Trap::GetXHalfLength2(), G4Trap::GetXHalfLength3(), G4Trap::GetXHalfLength4(), G4Trap::GetYHalfLength1(), G4Trap::GetYHalfLength2(), G4Trap::GetZHalfLength(), mm, G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ TrapWrite()

void G4GDMLWriteSolids::TrapWrite	(	xercesc::DOMElement *	solElement,
		const G4Trap * const	trap
	)

protectedinherited

Definition at line 812 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(trap->GetName(), trap);
 
  const G4ThreeVector& simaxis = trap->GetSymAxis();
  const G4double phi           = simaxis.phi();
  const G4double theta         = simaxis.theta();
  const G4double alpha1        = std::atan(trap->GetTanAlpha1());
  const G4double alpha2        = std::atan(trap->GetTanAlpha2());
 
  xercesc::DOMElement* trapElement = NewElement("trap");
  trapElement->setAttributeNode(NewAttribute("name", name));
  trapElement->setAttributeNode(
    NewAttribute("z", 2.0 * trap->GetZHalfLength() / mm));
  trapElement->setAttributeNode(NewAttribute("theta", theta / degree));
  trapElement->setAttributeNode(NewAttribute("phi", phi / degree));
  trapElement->setAttributeNode(
    NewAttribute("y1", 2.0 * trap->GetYHalfLength1() / mm));
  trapElement->setAttributeNode(
    NewAttribute("x1", 2.0 * trap->GetXHalfLength1() / mm));
  trapElement->setAttributeNode(
    NewAttribute("x2", 2.0 * trap->GetXHalfLength2() / mm));
  trapElement->setAttributeNode(NewAttribute("alpha1", alpha1 / degree));
  trapElement->setAttributeNode(
    NewAttribute("y2", 2.0 * trap->GetYHalfLength2() / mm));
  trapElement->setAttributeNode(
    NewAttribute("x3", 2.0 * trap->GetXHalfLength3() / mm));
  trapElement->setAttributeNode(
    NewAttribute("x4", 2.0 * trap->GetXHalfLength4() / mm));
  trapElement->setAttributeNode(NewAttribute("alpha2", alpha2 / degree));
  trapElement->setAttributeNode(NewAttribute("aunit", "deg"));
  trapElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(trapElement);
}

References alpha2, degree, G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4Trap::GetSymAxis(), G4Trap::GetTanAlpha1(), G4Trap::GetTanAlpha2(), G4Trap::GetXHalfLength1(), G4Trap::GetXHalfLength2(), G4Trap::GetXHalfLength3(), G4Trap::GetXHalfLength4(), G4Trap::GetYHalfLength1(), G4Trap::GetYHalfLength2(), G4Trap::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), CLHEP::Hep3Vector::phi(), and CLHEP::Hep3Vector::theta().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ TraverseVolumeTree()

G4Transform3D G4GDMLWriteStructure::TraverseVolumeTree	(	const G4LogicalVolume *const	topVol,
		const G4int	depth
	)

protectedvirtual

Implements G4GDMLWrite.

Definition at line 527 of file G4GDMLWriteStructure.cc.

{
  if(VolumeMap().find(volumePtr) != VolumeMap().cend())
  {
    return VolumeMap()[volumePtr];  // Volume is already processed
  }
 
  G4VSolid* solidPtr = volumePtr->GetSolid();
  G4Transform3D R, invR;
  G4int trans = 0;
 
  std::map<const G4LogicalVolume*, G4GDMLAuxListType>::iterator auxiter;
 
  ++levelNo;
 
  while(true)  // Solve possible displacement/reflection
  {            // of the referenced solid!
    if(trans > maxTransforms)
    {
      G4String ErrorMessage = "Referenced solid in volume '" +
                              volumePtr->GetName() +
                              "' was displaced/reflected too many times!";
      G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()", "InvalidSetup",
                  FatalException, ErrorMessage);
    }
 
    if(G4ReflectedSolid* refl = dynamic_cast<G4ReflectedSolid*>(solidPtr))
    {
      R        = R * refl->GetTransform3D();
      solidPtr = refl->GetConstituentMovedSolid();
      ++trans;
      continue;
    }
 
    if(G4DisplacedSolid* disp = dynamic_cast<G4DisplacedSolid*>(solidPtr))
    {
      R        = R * G4Transform3D(disp->GetObjectRotation(),
                            disp->GetObjectTranslation());
      solidPtr = disp->GetConstituentMovedSolid();
      ++trans;
      continue;
    }
 
    break;
  }
 
  // check if it is a reflected volume
  G4LogicalVolume* tmplv = const_cast<G4LogicalVolume*>(volumePtr);
 
  if(reflFactory->IsReflected(tmplv))
  {
    tmplv = reflFactory->GetConstituentLV(tmplv);
    if(VolumeMap().find(tmplv) != VolumeMap().cend())
    {
      return R;  // Volume is already processed
    }
  }
 
  // Only compute the inverse when necessary!
  //
  if(trans > 0)
  {
    invR = R.inverse();
  }
 
  const G4String name = GenerateName(tmplv->GetName(), tmplv);
 
  G4String materialref = "NULL";
 
  if(volumePtr->GetMaterial())
  {
    materialref = GenerateName(volumePtr->GetMaterial()->GetName(),
                               volumePtr->GetMaterial());
  }
 
  const G4String solidref = GenerateName(solidPtr->GetName(), solidPtr);
 
  xercesc::DOMElement* volumeElement = NewElement("volume");
  volumeElement->setAttributeNode(NewAttribute("name", name));
  xercesc::DOMElement* materialrefElement = NewElement("materialref");
  materialrefElement->setAttributeNode(NewAttribute("ref", materialref));
  volumeElement->appendChild(materialrefElement);
  xercesc::DOMElement* solidrefElement = NewElement("solidref");
  solidrefElement->setAttributeNode(NewAttribute("ref", solidref));
  volumeElement->appendChild(solidrefElement);
 
  G4int daughterCount = volumePtr->GetNoDaughters();
 
  if(levelNo == maxLevel)  // Stop exporting if reached levels limit
  {
    daughterCount = 0;
  }
 
  std::map<G4int, std::vector<G4int> > assemblyIDToAddedImprints;
 
  for(G4int i = 0; i < daughterCount; ++i)  // Traverse all the children!
  {
    const G4VPhysicalVolume* const physvol = volumePtr->GetDaughter(i);
    const G4String ModuleName              = Modularize(physvol, depth);
 
    G4Transform3D daughterR;
 
    if(ModuleName.empty())  // Check if subtree requested to be
    {                       // a separate module!
      daughterR = TraverseVolumeTree(physvol->GetLogicalVolume(), depth + 1);
    }
    else
    {
      G4GDMLWriteStructure writer;
      daughterR = writer.Write(ModuleName, physvol->GetLogicalVolume(),
                               SchemaLocation, depth + 1);
    }
 
    if(const G4PVDivision* const divisionvol =
         dynamic_cast<const G4PVDivision*>(physvol))  // Is it division?
    {
      if(!G4Transform3D::Identity.isNear(invR * daughterR, kRelativePrecision))
      {
        G4String ErrorMessage = "Division volume in '" + name +
                                "' can not be related to reflected solid!";
        G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
                    "InvalidSetup", FatalException, ErrorMessage);
      }
      DivisionvolWrite(volumeElement, divisionvol);
    }
    else
    {
      if(physvol->IsParameterised())  // Is it a paramvol?
      {
        if(!G4Transform3D::Identity.isNear(invR * daughterR,
                                           kRelativePrecision))
        {
          G4String ErrorMessage = "Parameterised volume in '" + name +
                                  "' can not be related to reflected solid!";
          G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
                      "InvalidSetup", FatalException, ErrorMessage);
        }
        ParamvolWrite(volumeElement, physvol);
      }
      else
      {
        if(physvol->IsReplicated())  // Is it a replicavol?
        {
          if(!G4Transform3D::Identity.isNear(invR * daughterR,
                                             kRelativePrecision))
          {
            G4String ErrorMessage = "Replica volume in '" + name +
                                    "' can not be related to reflected solid!";
            G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
                        "InvalidSetup", FatalException, ErrorMessage);
          }
          ReplicavolWrite(volumeElement, physvol);
        }
        else  // Is it a physvol or an assembly?
        {
          if(assemblyVolMap.find(physvol) != assemblyVolMap.cend())
          {
            G4int assemblyID = assemblyVolMap[physvol];
 
            G4String assemblyref = "Assembly_" + std::to_string(assemblyID);
 
            // here I need to retrieve the imprint ID
 
            G4int imprintID = imprintsMap[physvol];
 
            // there are 2 steps:
            //
            // 1) add assembly to the structure if that has not yet been done
            // (but after the constituents volumes have been added)
            //
 
            if(std::find(addedAssemblies.cbegin(), addedAssemblies.cend(),
                         assemblyID) == addedAssemblies.cend())
            {
              AssemblyWrite(structureElement, assemblyID);
              addedAssemblies.push_back(assemblyID);
              assemblyIDToAddedImprints[assemblyID] = std::vector<G4int>();
            }
 
            // 2) add the assembly (as physical volume) to the mother volume
            // (but only once), using it's original position and rotation.
            //
 
            // here I need a check if assembly has been already added to the
            // mother volume
            std::vector<G4int>& addedImprints = assemblyIDToAddedImprints[assemblyID];
            if(std::find(addedImprints.cbegin(), addedImprints.cend(),
                         imprintID) == addedImprints.cend())
            {
              G4String imprintname = "Imprint_" + std::to_string(imprintID) + "_";
              imprintname          = GenerateName(imprintname, physvol);
 
              // I need to get those two from the  container of imprints from
              // the assembly I have the imprint ID, I need to get pos and rot
              //
              G4Transform3D& transf = G4AssemblyStore::GetInstance()
                                        ->GetAssembly(assemblyID)
                                        ->GetImprintTransformation(imprintID);
 
              HepGeom::Scale3D scale;
              HepGeom::Rotate3D rotate;
              HepGeom::Translate3D translate;
 
              transf.getDecomposition(scale, rotate, translate);
 
              const G4ThreeVector scl(scale(0, 0), scale(1, 1), scale(2, 2));
              const G4ThreeVector rot = GetAngles(rotate.getRotation().inverse());
              const G4ThreeVector pos = transf.getTranslation();
 
              // here I need a normal physvol referencing to my assemblyref
 
              xercesc::DOMElement* physvolElement = NewElement("physvol");
              physvolElement->setAttributeNode(NewAttribute("name", imprintname));
 
              xercesc::DOMElement* volumerefElement = NewElement("volumeref");
              volumerefElement->setAttributeNode(NewAttribute("ref", assemblyref));
              physvolElement->appendChild(volumerefElement);
 
              if(std::fabs(pos.x()) > kLinearPrecision ||
                 std::fabs(pos.y()) > kLinearPrecision ||
                 std::fabs(pos.z()) > kLinearPrecision)
              {
                PositionWrite(physvolElement, imprintname + "_pos", pos);
              }
              if(std::fabs(rot.x()) > kAngularPrecision ||
                 std::fabs(rot.y()) > kAngularPrecision ||
                 std::fabs(rot.z()) > kAngularPrecision)
              {
                RotationWrite(physvolElement, imprintname + "_rot", rot);
              }
              if(std::fabs(scl.x() - 1.0) > kRelativePrecision ||
                 std::fabs(scl.y() - 1.0) > kRelativePrecision ||
                 std::fabs(scl.z() - 1.0) > kRelativePrecision)
              {
                ScaleWrite(physvolElement, name + "_scl", scl);
              }
 
              volumeElement->appendChild(physvolElement);
              //
              addedImprints.push_back(imprintID);
            }
          }
          else  // not part of assembly, so a normal physical volume
          {
            G4RotationMatrix rot;
            if(physvol->GetFrameRotation() != nullptr)
            {
              rot = *(physvol->GetFrameRotation());
            }
            G4Transform3D P(rot, physvol->GetObjectTranslation());
 
            PhysvolWrite(volumeElement, physvol, invR * P * daughterR,
                         ModuleName);
          }
        }
      }
    }
    // BorderSurfaceCache(GetBorderSurface(physvol));
    GetBorderSurface(physvol);
  }
 
  if(cexport)
  {
    ExportEnergyCuts(volumePtr);
  }
  // Add optional energy cuts
 
  if(sdexport)
  {
    ExportSD(volumePtr);
  }
  // Add optional SDs
 
  // Here write the auxiliary info
  //
  auxiter = auxmap.find(volumePtr);
  if(auxiter != auxmap.cend())
  {
    AddAuxInfo(&(auxiter->second), volumeElement);
  }
 
  structureElement->appendChild(volumeElement);
  // Append the volume AFTER traversing the children so that
  // the order of volumes will be correct!
 
  VolumeMap()[tmplv] = R;
 
  AddExtension(volumeElement, volumePtr);
  // Add any possible user defined extension attached to a volume
 
  AddMaterial(volumePtr->GetMaterial());
  // Add the involved materials and solids!
 
  AddSolid(solidPtr);
 
  SkinSurfaceCache(GetSkinSurface(volumePtr));
 
  return R;
}

References G4GDMLWrite::AddAuxInfo(), addedAssemblies, G4GDMLWrite::AddExtension(), G4GDMLWriteMaterials::AddMaterial(), G4GDMLWriteSolids::AddSolid(), assemblyVolMap, AssemblyWrite(), auxmap, cexport, DivisionvolWrite(), ExportEnergyCuts(), ExportSD(), FatalException, G4Exception(), G4GDMLWrite::GenerateName(), G4GDMLWriteDefine::GetAngles(), G4AssemblyStore::GetAssembly(), GetBorderSurface(), G4ReflectionFactory::GetConstituentLV(), G4LogicalVolume::GetDaughter(), HepGeom::Transform3D::getDecomposition(), G4VPhysicalVolume::GetFrameRotation(), G4AssemblyVolume::GetImprintTransformation(), G4AssemblyStore::GetInstance(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetMaterial(), G4LogicalVolume::GetName(), G4VSolid::GetName(), G4Material::GetName(), G4LogicalVolume::GetNoDaughters(), G4VPhysicalVolume::GetObjectTranslation(), HepGeom::Transform3D::getRotation(), GetSkinSurface(), G4LogicalVolume::GetSolid(), HepGeom::Transform3D::getTranslation(), HepGeom::Transform3D::Identity, imprintsMap, HepGeom::Transform3D::inverse(), CLHEP::HepRotation::inverse(), G4VPhysicalVolume::IsParameterised(), G4ReflectionFactory::IsReflected(), G4VPhysicalVolume::IsReplicated(), G4GDMLWriteDefine::kAngularPrecision, G4GDMLWriteDefine::kLinearPrecision, G4GDMLWriteDefine::kRelativePrecision, levelNo, maxLevel, G4GDMLWriteSolids::maxTransforms, G4GDMLWrite::Modularize(), G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), P, G4GDMLWriteParamvol::ParamvolWrite(), PhysvolWrite(), pos, G4GDMLWriteDefine::PositionWrite(), reflFactory, ReplicavolWrite(), G4GDMLWriteDefine::RotationWrite(), G4GDMLWriteDefine::ScaleWrite(), G4GDMLWrite::SchemaLocation, sdexport, SkinSurfaceCache(), structureElement, TraverseVolumeTree(), G4GDMLWrite::VolumeMap(), G4GDMLWrite::Write(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by AssemblyWrite(), and TraverseVolumeTree().

◆ Trd_dimensionsWrite()

void G4GDMLWriteParamvol::Trd_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Trd * const	trd
	)

protectedinherited

Definition at line 80 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* trd_dimensionsElement = NewElement("trd_dimensions");
  trd_dimensionsElement->setAttributeNode(
    NewAttribute("x1", 2.0 * trd->GetXHalfLength1() / mm));
  trd_dimensionsElement->setAttributeNode(
    NewAttribute("x2", 2.0 * trd->GetXHalfLength2() / mm));
  trd_dimensionsElement->setAttributeNode(
    NewAttribute("y1", 2.0 * trd->GetYHalfLength1() / mm));
  trd_dimensionsElement->setAttributeNode(
    NewAttribute("y2", 2.0 * trd->GetYHalfLength2() / mm));
  trd_dimensionsElement->setAttributeNode(
    NewAttribute("z", 2.0 * trd->GetZHalfLength() / mm));
  trd_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(trd_dimensionsElement);
}

References G4Trd::GetXHalfLength1(), G4Trd::GetXHalfLength2(), G4Trd::GetYHalfLength1(), G4Trd::GetYHalfLength2(), G4Trd::GetZHalfLength(), mm, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ TrdWrite()

void G4GDMLWriteSolids::TrdWrite	(	xercesc::DOMElement *	solElement,
		const G4Trd * const	trd
	)

protectedinherited

Definition at line 849 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(trd->GetName(), trd);
 
  xercesc::DOMElement* trdElement = NewElement("trd");
  trdElement->setAttributeNode(NewAttribute("name", name));
  trdElement->setAttributeNode(
    NewAttribute("x1", 2.0 * trd->GetXHalfLength1() / mm));
  trdElement->setAttributeNode(
    NewAttribute("x2", 2.0 * trd->GetXHalfLength2() / mm));
  trdElement->setAttributeNode(
    NewAttribute("y1", 2.0 * trd->GetYHalfLength1() / mm));
  trdElement->setAttributeNode(
    NewAttribute("y2", 2.0 * trd->GetYHalfLength2() / mm));
  trdElement->setAttributeNode(
    NewAttribute("z", 2.0 * trd->GetZHalfLength() / mm));
  trdElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(trdElement);
}

References G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4Trd::GetXHalfLength1(), G4Trd::GetXHalfLength2(), G4Trd::GetYHalfLength1(), G4Trd::GetYHalfLength2(), G4Trd::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ Tube_dimensionsWrite()

void G4GDMLWriteParamvol::Tube_dimensionsWrite	(	xercesc::DOMElement *	parametersElement,
		const G4Tubs * const	tube
	)

protectedinherited

Definition at line 137 of file G4GDMLWriteParamvol.cc.

{
  xercesc::DOMElement* tube_dimensionsElement = NewElement("tube_dimensions");
  tube_dimensionsElement->setAttributeNode(
    NewAttribute("InR", tube->GetInnerRadius() / mm));
  tube_dimensionsElement->setAttributeNode(
    NewAttribute("OutR", tube->GetOuterRadius() / mm));
  tube_dimensionsElement->setAttributeNode(
    NewAttribute("hz", 2.0 * tube->GetZHalfLength() / mm));
  tube_dimensionsElement->setAttributeNode(
    NewAttribute("StartPhi", tube->GetStartPhiAngle() / degree));
  tube_dimensionsElement->setAttributeNode(
    NewAttribute("DeltaPhi", tube->GetDeltaPhiAngle() / degree));
  tube_dimensionsElement->setAttributeNode(NewAttribute("aunit", "deg"));
  tube_dimensionsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  parametersElement->appendChild(tube_dimensionsElement);
}

References degree, G4Tubs::GetDeltaPhiAngle(), G4Tubs::GetInnerRadius(), G4Tubs::GetOuterRadius(), G4Tubs::GetStartPhiAngle(), G4Tubs::GetZHalfLength(), mm, G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteParamvol::ParametersWrite().

◆ TubeWrite()

void G4GDMLWriteSolids::TubeWrite	(	xercesc::DOMElement *	solElement,
		const G4Tubs * const	tube
	)

protectedinherited

Definition at line 871 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(tube->GetName(), tube);
 
  xercesc::DOMElement* tubeElement = NewElement("tube");
  tubeElement->setAttributeNode(NewAttribute("name", name));
  tubeElement->setAttributeNode(
    NewAttribute("rmin", tube->GetInnerRadius() / mm));
  tubeElement->setAttributeNode(
    NewAttribute("rmax", tube->GetOuterRadius() / mm));
  tubeElement->setAttributeNode(
    NewAttribute("z", 2.0 * tube->GetZHalfLength() / mm));
  tubeElement->setAttributeNode(
    NewAttribute("startphi", tube->GetStartPhiAngle() / degree));
  tubeElement->setAttributeNode(
    NewAttribute("deltaphi", tube->GetDeltaPhiAngle() / degree));
  tubeElement->setAttributeNode(NewAttribute("aunit", "deg"));
  tubeElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(tubeElement);
}

References degree, G4GDMLWrite::GenerateName(), G4Tubs::GetDeltaPhiAngle(), G4Tubs::GetInnerRadius(), G4VSolid::GetName(), G4Tubs::GetOuterRadius(), G4Tubs::GetStartPhiAngle(), G4Tubs::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ TwistedboxWrite()

void G4GDMLWriteSolids::TwistedboxWrite	(	xercesc::DOMElement *	solElement,
		const G4TwistedBox * const	twistedbox
	)

protectedinherited

Definition at line 929 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(twistedbox->GetName(), twistedbox);
 
  xercesc::DOMElement* twistedboxElement = NewElement("twistedbox");
  twistedboxElement->setAttributeNode(NewAttribute("name", name));
  twistedboxElement->setAttributeNode(
    NewAttribute("x", 2.0 * twistedbox->GetXHalfLength() / mm));
  twistedboxElement->setAttributeNode(
    NewAttribute("y", 2.0 * twistedbox->GetYHalfLength() / mm));
  twistedboxElement->setAttributeNode(
    NewAttribute("z", 2.0 * twistedbox->GetZHalfLength() / mm));
  twistedboxElement->setAttributeNode(
    NewAttribute("PhiTwist", twistedbox->GetPhiTwist() / degree));
  twistedboxElement->setAttributeNode(NewAttribute("aunit", "deg"));
  twistedboxElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(twistedboxElement);
}

References degree, G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4TwistedBox::GetPhiTwist(), G4TwistedBox::GetXHalfLength(), G4TwistedBox::GetYHalfLength(), G4TwistedBox::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ TwistedtrapWrite()

void G4GDMLWriteSolids::TwistedtrapWrite	(	xercesc::DOMElement *	solElement,
		const G4TwistedTrap * const	twistedtrap
	)

protectedinherited

Definition at line 950 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(twistedtrap->GetName(), twistedtrap);
 
  xercesc::DOMElement* twistedtrapElement = NewElement("twistedtrap");
  twistedtrapElement->setAttributeNode(NewAttribute("name", name));
  twistedtrapElement->setAttributeNode(
    NewAttribute("y1", 2.0 * twistedtrap->GetY1HalfLength() / mm));
  twistedtrapElement->setAttributeNode(
    NewAttribute("x1", 2.0 * twistedtrap->GetX1HalfLength() / mm));
  twistedtrapElement->setAttributeNode(
    NewAttribute("x2", 2.0 * twistedtrap->GetX2HalfLength() / mm));
  twistedtrapElement->setAttributeNode(
    NewAttribute("y2", 2.0 * twistedtrap->GetY2HalfLength() / mm));
  twistedtrapElement->setAttributeNode(
    NewAttribute("x3", 2.0 * twistedtrap->GetX3HalfLength() / mm));
  twistedtrapElement->setAttributeNode(
    NewAttribute("x4", 2.0 * twistedtrap->GetX4HalfLength() / mm));
  twistedtrapElement->setAttributeNode(
    NewAttribute("z", 2.0 * twistedtrap->GetZHalfLength() / mm));
  twistedtrapElement->setAttributeNode(
    NewAttribute("Alph", twistedtrap->GetTiltAngleAlpha() / degree));
  twistedtrapElement->setAttributeNode(
    NewAttribute("Theta", twistedtrap->GetPolarAngleTheta() / degree));
  twistedtrapElement->setAttributeNode(
    NewAttribute("Phi", twistedtrap->GetAzimuthalAnglePhi() / degree));
  twistedtrapElement->setAttributeNode(
    NewAttribute("PhiTwist", twistedtrap->GetPhiTwist() / degree));
  twistedtrapElement->setAttributeNode(NewAttribute("aunit", "deg"));
  twistedtrapElement->setAttributeNode(NewAttribute("lunit", "mm"));
 
  solElement->appendChild(twistedtrapElement);
}

Referenced by G4GDMLWriteSolids::AddSolid().

◆ TwistedtrdWrite()

void G4GDMLWriteSolids::TwistedtrdWrite	(	xercesc::DOMElement *	solElement,
		const G4TwistedTrd * const	twistedtrd
	)

protectedinherited

Definition at line 986 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(twistedtrd->GetName(), twistedtrd);
 
  xercesc::DOMElement* twistedtrdElement = NewElement("twistedtrd");
  twistedtrdElement->setAttributeNode(NewAttribute("name", name));
  twistedtrdElement->setAttributeNode(
    NewAttribute("x1", 2.0 * twistedtrd->GetX1HalfLength() / mm));
  twistedtrdElement->setAttributeNode(
    NewAttribute("x2", 2.0 * twistedtrd->GetX2HalfLength() / mm));
  twistedtrdElement->setAttributeNode(
    NewAttribute("y1", 2.0 * twistedtrd->GetY1HalfLength() / mm));
  twistedtrdElement->setAttributeNode(
    NewAttribute("y2", 2.0 * twistedtrd->GetY2HalfLength() / mm));
  twistedtrdElement->setAttributeNode(
    NewAttribute("z", 2.0 * twistedtrd->GetZHalfLength() / mm));
  twistedtrdElement->setAttributeNode(
    NewAttribute("PhiTwist", twistedtrd->GetPhiTwist() / degree));
  twistedtrdElement->setAttributeNode(NewAttribute("aunit", "deg"));
  twistedtrdElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(twistedtrdElement);
}

References degree, G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4TwistedTrd::GetPhiTwist(), G4TwistedTrd::GetX1HalfLength(), G4TwistedTrd::GetX2HalfLength(), G4TwistedTrd::GetY1HalfLength(), G4TwistedTrd::GetY2HalfLength(), G4TwistedTrd::GetZHalfLength(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ TwistedtubsWrite()

void G4GDMLWriteSolids::TwistedtubsWrite	(	xercesc::DOMElement *	solElement,
		const G4TwistedTubs * const	twistedtubs
	)

protectedinherited

Definition at line 1011 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(twistedtubs->GetName(), twistedtubs);
 
  xercesc::DOMElement* twistedtubsElement = NewElement("twistedtubs");
  twistedtubsElement->setAttributeNode(NewAttribute("name", name));
  twistedtubsElement->setAttributeNode(
    NewAttribute("twistedangle", twistedtubs->GetPhiTwist() / degree));
  twistedtubsElement->setAttributeNode(
    NewAttribute("midinnerrad", twistedtubs->GetInnerRadius() / mm));
  twistedtubsElement->setAttributeNode(
    NewAttribute("midouterrad", twistedtubs->GetOuterRadius() / mm));
  twistedtubsElement->setAttributeNode(
    NewAttribute("negativeEndz", twistedtubs->GetEndZ(0) / mm));
  twistedtubsElement->setAttributeNode(
    NewAttribute("positiveEndz", twistedtubs->GetEndZ(1) / mm));
  twistedtubsElement->setAttributeNode(
    NewAttribute("phi", twistedtubs->GetDPhi() / degree));
  twistedtubsElement->setAttributeNode(NewAttribute("aunit", "deg"));
  twistedtubsElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(twistedtubsElement);
}

References degree, G4GDMLWrite::GenerateName(), G4TwistedTubs::GetDPhi(), G4TwistedTubs::GetEndZ(), G4TwistedTubs::GetInnerRadius(), G4VSolid::GetName(), G4TwistedTubs::GetOuterRadius(), G4TwistedTubs::GetPhiTwist(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), and G4GDMLWrite::NewElement().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ TWrite()

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

protectedinherited

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 G4GDMLWriteMaterials::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 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 TraverseVolumeTree().

◆ XtruWrite()

void G4GDMLWriteSolids::XtruWrite	(	xercesc::DOMElement *	solElement,
		const G4ExtrudedSolid * const	xtru
	)

protectedinherited

Definition at line 393 of file G4GDMLWriteSolids.cc.

{
  const G4String& name = GenerateName(xtru->GetName(), xtru);
 
  xercesc::DOMElement* xtruElement = NewElement("xtru");
  xtruElement->setAttributeNode(NewAttribute("name", name));
  xtruElement->setAttributeNode(NewAttribute("lunit", "mm"));
  solElement->appendChild(xtruElement);
 
  const G4int NumVertex = xtru->GetNofVertices();
 
  for(G4int i = 0; i < NumVertex; ++i)
  {
    xercesc::DOMElement* twoDimVertexElement = NewElement("twoDimVertex");
    xtruElement->appendChild(twoDimVertexElement);
 
    const G4TwoVector& vertex = xtru->GetVertex(i);
 
    twoDimVertexElement->setAttributeNode(NewAttribute("x", vertex.x() / mm));
    twoDimVertexElement->setAttributeNode(NewAttribute("y", vertex.y() / mm));
  }
 
  const G4int NumSection = xtru->GetNofZSections();
 
  for(G4int i = 0; i < NumSection; ++i)
  {
    xercesc::DOMElement* sectionElement = NewElement("section");
    xtruElement->appendChild(sectionElement);
 
    const G4ExtrudedSolid::ZSection section = xtru->GetZSection(i);
 
    sectionElement->setAttributeNode(NewAttribute("zOrder", i));
    sectionElement->setAttributeNode(
      NewAttribute("zPosition", section.fZ / mm));
    sectionElement->setAttributeNode(
      NewAttribute("xOffset", section.fOffset.x() / mm));
    sectionElement->setAttributeNode(
      NewAttribute("yOffset", section.fOffset.y() / mm));
    sectionElement->setAttributeNode(
      NewAttribute("scalingFactor", section.fScale));
  }
}

References G4ExtrudedSolid::ZSection::fOffset, G4ExtrudedSolid::ZSection::fScale, G4ExtrudedSolid::ZSection::fZ, G4GDMLWrite::GenerateName(), G4VSolid::GetName(), G4ExtrudedSolid::GetNofVertices(), G4ExtrudedSolid::GetNofZSections(), G4ExtrudedSolid::GetVertex(), G4ExtrudedSolid::GetZSection(), mm, G4InuclParticleNames::name(), G4GDMLWrite::NewAttribute(), G4GDMLWrite::NewElement(), CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

Referenced by G4GDMLWriteSolids::AddSolid().

◆ ZplaneWrite()

void G4GDMLWriteSolids::ZplaneWrite	(	xercesc::DOMElement *	element,
		const G4double &	z,
		const G4double &	rmin,
		const G4double &	rmax
	)

protectedinherited

Definition at line 1036 of file G4GDMLWriteSolids.cc.

{
  xercesc::DOMElement* zplaneElement = NewElement("zplane");
  zplaneElement->setAttributeNode(NewAttribute("z", z / mm));
  zplaneElement->setAttributeNode(NewAttribute("rmin", rmin / mm));
  zplaneElement->setAttributeNode(NewAttribute("rmax", rmax / mm));
  element->appendChild(zplaneElement);
}

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

Referenced by G4GDMLWriteParamvol::Polycone_dimensionsWrite(), G4GDMLWriteSolids::PolyconeWrite(), G4GDMLWriteParamvol::Polyhedra_dimensionsWrite(), and G4GDMLWriteSolids::PolyhedraWrite().

Field Documentation

◆ addedAssemblies

std::vector<G4int> G4GDMLWriteStructure::addedAssemblies

private

Definition at line 115 of file G4GDMLWriteStructure.hh.

Referenced by TraverseVolumeTree().

◆ addPointerToName

G4bool G4GDMLWrite::addPointerToName = true

staticprotectedinherited

Definition at line 131 of file G4GDMLWrite.hh.

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

◆ assemblyVolMap

std::map<const G4VPhysicalVolume*, G4int> G4GDMLWriteStructure::assemblyVolMap

private

Definition at line 111 of file G4GDMLWriteStructure.hh.

Referenced by StructureWrite(), and TraverseVolumeTree().

◆ auxList

G4GDMLAuxListType G4GDMLWrite::auxList

protectedinherited

Definition at line 136 of file G4GDMLWrite.hh.

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

◆ auxmap

std::map<const G4LogicalVolume*, G4GDMLAuxListType> G4GDMLWriteStructure::auxmap

protected

Definition at line 94 of file G4GDMLWriteStructure.hh.

Referenced by AddVolumeAuxiliary(), and TraverseVolumeTree().

◆ borderElementVec

std::vector<xercesc::DOMElement*> G4GDMLWriteStructure::borderElementVec

protected

Definition at line 92 of file G4GDMLWriteStructure.hh.

Referenced by BorderSurfaceCache(), and SurfacesWrite().

◆ cexport

G4bool G4GDMLWriteStructure::cexport = false

private

Definition at line 102 of file G4GDMLWriteStructure.hh.

Referenced by SetEnergyCutsExport(), and TraverseVolumeTree().

◆ defineElement

xercesc::DOMElement* G4GDMLWriteDefine::defineElement = nullptr

protectedinherited

Definition at line 98 of file G4GDMLWriteDefine.hh.

Referenced by G4GDMLWriteDefine::AddPosition(), G4GDMLWriteDefine::DefineWrite(), G4GDMLWriteMaterials::PropertyConstWrite(), G4GDMLWriteMaterials::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

protectedinherited

Definition at line 80 of file G4GDMLWriteMaterials.hh.

Referenced by G4GDMLWriteMaterials::AddElement(), and G4GDMLWriteMaterials::MaterialsWrite().

◆ extElement

xercesc::DOMElement* G4GDMLWrite::extElement = nullptr

protectedinherited

Definition at line 133 of file G4GDMLWrite.hh.

◆ imprintsMap

std::map<const G4VPhysicalVolume*, G4int> G4GDMLWriteStructure::imprintsMap

private

Definition at line 113 of file G4GDMLWriteStructure.hh.

Referenced by StructureWrite(), and TraverseVolumeTree().

◆ isotopeList

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

protectedinherited

Definition at line 79 of file G4GDMLWriteMaterials.hh.

Referenced by G4GDMLWriteMaterials::AddIsotope(), and G4GDMLWriteMaterials::MaterialsWrite().

◆ kAngularPrecision

const G4double G4GDMLWriteDefine::kAngularPrecision = DBL_EPSILON

staticprotectedinherited

Definition at line 95 of file G4GDMLWriteDefine.hh.

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

◆ kLinearPrecision

const G4double G4GDMLWriteDefine::kLinearPrecision = DBL_EPSILON

staticprotectedinherited

Definition at line 96 of file G4GDMLWriteDefine.hh.

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

◆ kRelativePrecision

const G4double G4GDMLWriteDefine::kRelativePrecision = DBL_EPSILON

staticprotectedinherited

Definition at line 94 of file G4GDMLWriteDefine.hh.

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

◆ levelNo

G4int G4GDMLWriteStructure::levelNo = 0

staticprivate

Definition at line 108 of file G4GDMLWriteStructure.hh.

Referenced by SetMaxExportLevel(), and TraverseVolumeTree().

◆ materialList

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

protectedinherited

Definition at line 81 of file G4GDMLWriteMaterials.hh.

Referenced by G4GDMLWriteMaterials::AddMaterial(), and G4GDMLWriteMaterials::MaterialsWrite().

◆ materialsElement

xercesc::DOMElement* G4GDMLWriteMaterials::materialsElement = nullptr

protectedinherited

Definition at line 83 of file G4GDMLWriteMaterials.hh.

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

◆ maxLevel

G4int G4GDMLWriteStructure::maxLevel = 0

private

Definition at line 106 of file G4GDMLWriteStructure.hh.

Referenced by GetMaxExportLevel(), SetMaxExportLevel(), and TraverseVolumeTree().

◆ maxTransforms

const G4int G4GDMLWriteSolids::maxTransforms = 8

staticprotectedinherited

Definition at line 147 of file G4GDMLWriteSolids.hh.

Referenced by G4GDMLWriteSolids::BooleanWrite(), and TraverseVolumeTree().

◆ opt_vec

std::vector<const G4OpticalSurface*> G4GDMLWriteStructure::opt_vec

private

Definition at line 98 of file G4GDMLWriteStructure.hh.

Referenced by FindOpticalSurface().

◆ 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

protectedinherited

Definition at line 82 of file G4GDMLWriteMaterials.hh.

Referenced by G4GDMLWriteMaterials::MaterialsWrite(), and G4GDMLWriteMaterials::PropertyVectorWrite().

◆ reflFactory

G4ReflectionFactory* G4GDMLWriteStructure::reflFactory = nullptr

private

Definition at line 100 of file G4GDMLWriteStructure.hh.

Referenced by G4GDMLWriteStructure(), PhysvolWrite(), and TraverseVolumeTree().

◆ SchemaLocation

G4String G4GDMLWrite::SchemaLocation

protectedinherited

Definition at line 130 of file G4GDMLWrite.hh.

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

◆ sdexport

G4bool G4GDMLWriteStructure::sdexport = false

private

Definition at line 104 of file G4GDMLWriteStructure.hh.

Referenced by SetSDExport(), and TraverseVolumeTree().

◆ skinElementVec

std::vector<xercesc::DOMElement*> G4GDMLWriteStructure::skinElementVec

protected

Definition at line 93 of file G4GDMLWriteStructure.hh.

Referenced by SkinSurfaceCache(), and SurfacesWrite().

◆ solidList

std::vector<const G4VSolid*> G4GDMLWriteSolids::solidList

protectedinherited

Definition at line 145 of file G4GDMLWriteSolids.hh.

Referenced by G4GDMLWriteSolids::AddSolid(), and G4GDMLWriteSolids::SolidsWrite().

◆ solidsElement

xercesc::DOMElement* G4GDMLWriteSolids::solidsElement = nullptr

protectedinherited

Definition at line 146 of file G4GDMLWriteSolids.hh.

Referenced by G4GDMLWriteSolids::AddSolid(), BorderSurfaceCache(), SkinSurfaceCache(), and G4GDMLWriteSolids::SolidsWrite().

◆ structureElement

xercesc::DOMElement* G4GDMLWriteStructure::structureElement = nullptr

protected

Definition at line 91 of file G4GDMLWriteStructure.hh.

Referenced by StructureWrite(), SurfacesWrite(), and TraverseVolumeTree().

◆ 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/G4GDMLWriteStructure.hh
source/persistency/gdml/src/G4GDMLWriteStructure.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ DepthMapType

◆ PhysVolumeMapType

◆ VolumeMapType

Constructor & Destructor Documentation

◆ G4GDMLWriteStructure()

◆ ~G4GDMLWriteStructure()

Member Function Documentation

◆ AddAuxiliary()

◆ AddAuxInfo()

◆ AddElement()

◆ AddExtension()

◆ AddIsotope()

◆ AddMaterial()

◆ AddModule() [1/2]

◆ AddModule() [2/2]

◆ AddPosition()

◆ AddSolid()

◆ AddVolumeAuxiliary()

◆ AssemblyWrite()

◆ AtomWrite()

◆ BooleanWrite()

◆ BorderSurfaceCache()

◆ Box_dimensionsWrite()

◆ BoxWrite()

◆ Cone_dimensionsWrite()

◆ ConeWrite()

◆ CutTubeWrite()

◆ DefineWrite()

◆ DepthMap()

◆ DivisionvolWrite()

◆ DWrite()

◆ ElconeWrite()

◆ ElementWrite()

◆ Ellipsoid_dimensionsWrite()

◆ EllipsoidWrite()

◆ EltubeWrite()

◆ ExportEnergyCuts()

◆ ExportSD()

◆ ExtensionWrite()

◆ FileExists()

◆ FindOpticalSurface()

◆ FirstpositionWrite()

◆ FirstrotationWrite()

◆ GenerateName()

◆ GenericPolyconeWrite()

◆ GenTrapWrite()

◆ GetAngles()

◆ GetBorderSurface()

◆ GetMaxExportLevel()

◆ GetSkinSurface()

◆ Hype_dimensionsWrite()

◆ HypeWrite()

◆ IsotopeWrite()

◆ MaterialsWrite()

◆ MaterialWrite()

◆ MEEWrite()

◆ Modularize()

◆ MultiUnionWrite()

◆ NewAttribute() [1/2]

◆ NewAttribute() [2/2]

◆ NewElement()

◆ OpticalSurfaceWrite()

◆ Orb_dimensionsWrite()

◆ OrbWrite()

◆ Para_dimensionsWrite()

◆ ParaboloidWrite()

◆ ParametersWrite()

◆ ParamvolAlgorithmWrite()

◆ ParamvolWrite()

◆ ParaWrite()