#include <G4GDMLWriteSolids.hh>

Inheritance diagram for G4GDMLWriteSolids:

Public Member Functions
virtual void	AddSolid (const G4VSolid *const)

virtual void	SolidsWrite (xercesc::DOMElement *)

Public Member Functions inherited from G4GDMLWriteMaterials
void	AddIsotope (const G4Isotope *const)

void	AddElement (const G4Element *const)

void	AddMaterial (const G4Material *const)

virtual void	MaterialsWrite (xercesc::DOMElement *)

Public Member Functions inherited from G4GDMLWriteDefine
G4ThreeVector	GetAngles (const G4RotationMatrix &)

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

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

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

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

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

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

virtual void	DefineWrite (xercesc::DOMElement *)

Public Member Functions inherited from G4GDMLWrite
G4Transform3D	Write (const G4String &filename, const G4LogicalVolume *const topLog, const G4String &schemaPath, const G4int depth, G4bool storeReferences=true)

void	AddModule (const G4VPhysicalVolume *const topVol)

void	AddModule (const G4int depth)

void	AddAuxiliary (G4GDMLAuxStructType myaux)

void	SetOutputFileOverwrite (G4bool flag)

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

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

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

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

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

virtual void	SurfacesWrite ()=0

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

virtual void	ExtensionWrite (xercesc::DOMElement *)

virtual void	UserinfoWrite (xercesc::DOMElement *)

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

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

Protected Member Functions
	G4GDMLWriteSolids ()

virtual	~G4GDMLWriteSolids ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	CutTubeWrite (xercesc::DOMElement , const G4CutTubs 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	ZplaneWrite (xercesc::DOMElement *, const G4double &, const G4double &, const G4double &)

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

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

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

Protected Member Functions inherited from G4GDMLWriteMaterials
	G4GDMLWriteMaterials ()

virtual	~G4GDMLWriteMaterials ()

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

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

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

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

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

void	IsotopeWrite (const G4Isotope *const)

void	ElementWrite (const G4Element *const)

void	MaterialWrite (const G4Material *const)

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

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

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

Protected Member Functions inherited from G4GDMLWriteDefine
	G4GDMLWriteDefine ()

virtual	~G4GDMLWriteDefine ()

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

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

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

Protected Member Functions inherited from G4GDMLWrite
	G4GDMLWrite ()

virtual	~G4GDMLWrite ()

VolumeMapType &	VolumeMap ()

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

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

xercesc::DOMElement *	NewElement (const G4String &)

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

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

G4bool	FileExists (const G4String &) const

PhysVolumeMapType &	PvolumeMap ()

DepthMapType &	DepthMap ()

Protected Attributes
std::vector< const G4VSolid * >	solidList

xercesc::DOMElement *	solidsElement = nullptr

Protected Attributes inherited from G4GDMLWriteMaterials
std::vector< const G4Isotope * >	isotopeList

std::vector< const G4Element * >	elementList

std::vector< const G4Material * >	materialList

std::vector< const G4PhysicsOrderedFreeVector * >	propertyList

xercesc::DOMElement *	materialsElement = nullptr

Protected Attributes inherited from G4GDMLWriteDefine
xercesc::DOMElement *	defineElement = nullptr

Protected Attributes inherited from G4GDMLWrite
G4String	SchemaLocation

xercesc::DOMDocument *	doc = nullptr

xercesc::DOMElement *	extElement = nullptr

xercesc::DOMElement *	userinfoElement = nullptr

XMLCh	tempStr [10000]

G4GDMLAuxListType	auxList

G4bool	overwriteOutputFile = false

Static Protected Attributes
static const G4int	maxTransforms = 8

Static Protected Attributes inherited from G4GDMLWriteDefine
static const G4double	kRelativePrecision = DBL_EPSILON

static const G4double	kAngularPrecision = DBL_EPSILON

static const G4double	kLinearPrecision = DBL_EPSILON

Static Protected Attributes inherited from G4GDMLWrite
static G4bool	addPointerToName = true

Additional Inherited Members
Static Public Member Functions inherited from G4GDMLWrite
static void	SetAddPointerToName (G4bool)

Detailed Description

Definition at line 73 of file G4GDMLWriteSolids.hh.

Constructor & Destructor Documentation

◆ G4GDMLWriteSolids()

G4GDMLWriteSolids::G4GDMLWriteSolids ( )

protected

Definition at line 71 of file G4GDMLWriteSolids.cc.

  : G4GDMLWriteMaterials()
{
}

◆ ~G4GDMLWriteSolids()

G4GDMLWriteSolids::~G4GDMLWriteSolids ( )

protectedvirtual

Definition at line 77 of file G4GDMLWriteSolids.cc.

78{

79}

Member Function Documentation

◆ AddSolid()

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

virtual

Definition at line 1146 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 BooleanWrite(), MultiUnionWrite(), ScaledWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

◆ BooleanWrite()

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

protected

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

Referenced by AddSolid().

◆ BoxWrite()

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

protected

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

Referenced by AddSolid().

◆ ConeWrite()

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

protected

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

Referenced by AddSolid().

◆ CutTubeWrite()

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

protected

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

Referenced by AddSolid().

◆ ElconeWrite()

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

protected

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

Referenced by AddSolid().

◆ EllipsoidWrite()

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

protected

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

Referenced by AddSolid().

◆ EltubeWrite()

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

protected

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

Referenced by AddSolid().

◆ GenericPolyconeWrite()

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

protected

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

Referenced by AddSolid().

◆ GenTrapWrite()

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

protected

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

Referenced by AddSolid().

◆ HypeWrite()

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

protected

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

Referenced by AddSolid().

◆ MultiUnionWrite()

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

protected

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", 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 + "_pos", pos);
    }
    if((std::fabs(rot.x()) > kAngularPrecision) ||
       (std::fabs(rot.y()) > kAngularPrecision) ||
       (std::fabs(rot.z()) > kAngularPrecision))
    {
      RotationWrite(multiUnionNodeElement, name + "_rot", rot);
    }
    multiUnionElement->appendChild(multiUnionNodeElement);  // Append node
  }
 
  solElement->appendChild(multiUnionElement);
  // Add the multiUnion solid AFTER the constituent nodes!
}

Referenced by AddSolid().

◆ OpticalSurfaceWrite()

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

protected

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

Referenced by G4GDMLWriteStructure::BorderSurfaceCache(), and G4GDMLWriteStructure::SkinSurfaceCache().

◆ OrbWrite()

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

protected

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

Referenced by AddSolid().

◆ ParaboloidWrite()

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

protected

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

Referenced by AddSolid().

◆ ParaWrite()

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

protected

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

Referenced by AddSolid().

◆ PolyconeWrite()

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

protected

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

Referenced by AddSolid().

◆ PolyhedraWrite()

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

protected

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

Referenced by AddSolid().

◆ PropertyWrite()

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

protected

Definition at line 1084 of file G4GDMLWriteSolids.cc.

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

Referenced by OpticalSurfaceWrite().

◆ RZPointWrite()

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

protected

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

Referenced by GenericPolyconeWrite(), and PolyhedraWrite().

◆ ScaledWrite()

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

protected

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

Referenced by AddSolid().

◆ SolidsWrite()

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

virtual

Implements G4GDMLWrite.

Definition at line 1134 of file G4GDMLWriteSolids.cc.

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

◆ SphereWrite()

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

protected

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

Referenced by AddSolid().

◆ TessellatedWrite()

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

protected

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

Referenced by AddSolid().

◆ TetWrite()

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

protected

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

Referenced by AddSolid().

◆ TorusWrite()

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

protected

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

Referenced by AddSolid().

◆ TrapWrite()

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

protected

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

Referenced by AddSolid().

◆ TrdWrite()

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

protected

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

Referenced by AddSolid().

◆ TubeWrite()

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

protected

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

Referenced by AddSolid().

◆ TwistedboxWrite()

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

protected

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

Referenced by AddSolid().

◆ TwistedtrapWrite()

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

protected

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

◆ TwistedtrdWrite()

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

protected

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

Referenced by AddSolid().

◆ TwistedtubsWrite()

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

protected

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

Referenced by AddSolid().

◆ XtruWrite()

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

protected

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

Referenced by AddSolid().

◆ ZplaneWrite()

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

protected

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

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

Member Data Documentation

◆ maxTransforms

const G4int G4GDMLWriteSolids::maxTransforms = 8

staticprotected

Definition at line 147 of file G4GDMLWriteSolids.hh.

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

◆ solidList

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

protected

Definition at line 145 of file G4GDMLWriteSolids.hh.

Referenced by AddSolid(), and SolidsWrite().

◆ solidsElement

xercesc::DOMElement* G4GDMLWriteSolids::solidsElement = nullptr

protected

Definition at line 146 of file G4GDMLWriteSolids.hh.

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4GDMLWriteSolids()

◆ ~G4GDMLWriteSolids()

Member Function Documentation

◆ AddSolid()

◆ BooleanWrite()

◆ BoxWrite()

◆ ConeWrite()

◆ CutTubeWrite()

◆ ElconeWrite()

◆ EllipsoidWrite()

◆ EltubeWrite()

◆ GenericPolyconeWrite()

◆ GenTrapWrite()

◆ HypeWrite()

◆ MultiUnionWrite()

◆ OpticalSurfaceWrite()

◆ OrbWrite()

◆ ParaboloidWrite()

◆ ParaWrite()

◆ PolyconeWrite()

◆ PolyhedraWrite()

◆ PropertyWrite()

◆ RZPointWrite()

◆ ScaledWrite()

◆ SolidsWrite()

◆ SphereWrite()

◆ TessellatedWrite()

◆ TetWrite()

◆ TorusWrite()

◆ TrapWrite()

◆ TrdWrite()

◆ TubeWrite()

◆ TwistedboxWrite()

◆ TwistedtrapWrite()

◆ TwistedtrdWrite()

◆ TwistedtubsWrite()

◆ XtruWrite()

◆ ZplaneWrite()

Member Data Documentation

◆ maxTransforms

◆ solidList

◆ solidsElement