#include <G4GDMLWriteParamvol.hh>

Inheritance diagram for G4GDMLWriteParamvol:

Public Member Functions
virtual void	ParamvolWrite (xercesc::DOMElement , const G4VPhysicalVolume const)

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

Public Member Functions inherited from G4GDMLWriteSetup
virtual void	SetupWrite (xercesc::DOMElement , const G4LogicalVolume const)

Public Member Functions inherited from G4GDMLWriteSolids
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
	G4GDMLWriteParamvol ()

virtual	~G4GDMLWriteParamvol ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Protected Member Functions inherited from G4GDMLWriteSetup
	G4GDMLWriteSetup ()

virtual	~G4GDMLWriteSetup ()

Protected Member Functions inherited from G4GDMLWriteSolids
	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 ()

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

Protected Attributes inherited from G4GDMLWriteSolids
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 inherited from G4GDMLWriteSolids
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

Detailed Description

Definition at line 54 of file G4GDMLWriteParamvol.hh.

Constructor & Destructor Documentation

◆ G4GDMLWriteParamvol()

G4GDMLWriteParamvol::G4GDMLWriteParamvol ( )

protected

Definition at line 54 of file G4GDMLWriteParamvol.cc.

  : G4GDMLWriteSetup()
{
}

◆ ~G4GDMLWriteParamvol()

G4GDMLWriteParamvol::~G4GDMLWriteParamvol ( )

protectedvirtual

Definition at line 60 of file G4GDMLWriteParamvol.cc.

61{

62}

Member Function Documentation

◆ Box_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Cone_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Ellipsoid_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Hype_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Orb_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Para_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ ParametersWrite()

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

protected

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

◆ ParamvolAlgorithmWrite()

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

virtual

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

Referenced by ParamvolWrite().

◆ ParamvolWrite()

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

virtual

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

Referenced by G4GDMLWriteStructure::TraverseVolumeTree().

◆ Polycone_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Polyhedra_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Sphere_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Torus_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Trap_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Trd_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

◆ Tube_dimensionsWrite()

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

protected

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

Referenced by ParametersWrite().

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

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4GDMLWriteParamvol()

◆ ~G4GDMLWriteParamvol()

Member Function Documentation

◆ Box_dimensionsWrite()

◆ Cone_dimensionsWrite()

◆ Ellipsoid_dimensionsWrite()

◆ Hype_dimensionsWrite()

◆ Orb_dimensionsWrite()

◆ Para_dimensionsWrite()

◆ ParametersWrite()

◆ ParamvolAlgorithmWrite()

◆ ParamvolWrite()

◆ Polycone_dimensionsWrite()

◆ Polyhedra_dimensionsWrite()

◆ Sphere_dimensionsWrite()

◆ Torus_dimensionsWrite()

◆ Trap_dimensionsWrite()

◆ Trd_dimensionsWrite()

◆ Tube_dimensionsWrite()