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

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	AddExtension (xercesc::DOMElement , const G4LogicalVolume 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	Para_dimensionsWrite (xercesc::DOMElement , const G4Para const)

void	Hype_dimensionsWrite (xercesc::DOMElement , const G4Hype 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	BooleanWrite (xercesc::DOMElement , const G4BooleanSolid 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	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	OpticalSurfaceWrite (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)

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

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

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)

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

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

std::vector< const G4Element * >	elementList

std::vector< const G4Material * >	materialList

xercesc::DOMElement *	materialsElement

Protected Attributes inherited from G4GDMLWriteDefine
xercesc::DOMElement *	defineElement

Protected Attributes inherited from G4GDMLWrite
G4String	SchemaLocation

xercesc::DOMDocument *	doc

xercesc::DOMElement *	extElement

XMLCh	tempStr [10000]

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 57 of file G4GDMLWriteParamvol.hh.

Constructor & Destructor Documentation

◆ G4GDMLWriteParamvol()

G4GDMLWriteParamvol::G4GDMLWriteParamvol ( )

protected

Definition at line 53 of file G4GDMLWriteParamvol.cc.

                      : G4GDMLWriteSetup()
{
}

◆ ~G4GDMLWriteParamvol()

G4GDMLWriteParamvol::~G4GDMLWriteParamvol ( )

protectedvirtual

Definition at line 58 of file G4GDMLWriteParamvol.cc.

60{

61}

Member Function Documentation

◆ Box_dimensionsWrite()

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

protected

Definition at line 63 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 163 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().

◆ Hype_dimensionsWrite()

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

protected

Definition at line 276 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 212 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 246 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 298 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 (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
   {
     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 416 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 395 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().

◆ Sphere_dimensionsWrite()

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

protected

Definition at line 189 of file G4GDMLWriteParamvol.cc.

{
   xercesc::DOMElement* sphere_dimensionsElement =
                        NewElement("sphere_dimensions");
   sphere_dimensionsElement->setAttributeNode(NewAttribute("rmin",
                             sphere->GetInsideRadius()/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 223 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 79 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 140 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()

◆ Hype_dimensionsWrite()

◆ Orb_dimensionsWrite()

◆ Para_dimensionsWrite()

◆ ParametersWrite()

◆ ParamvolAlgorithmWrite()

◆ ParamvolWrite()

◆ Sphere_dimensionsWrite()

◆ Torus_dimensionsWrite()

◆ Trap_dimensionsWrite()

◆ Trd_dimensionsWrite()

◆ Tube_dimensionsWrite()