#include <G4GDMLWriteParamvol.hh>

Inheritance diagram for G4GDMLWriteParamvol:

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

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

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

virtual void	SurfacesWrite ()=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)

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

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

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

xercesc::DOMElement *	userinfoElement

XMLCh	tempStr [10000]

G4GDMLAuxListType	auxList

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

Constructor & Destructor Documentation

G4GDMLWriteParamvol::G4GDMLWriteParamvol ( )

protected

Definition at line 58 of file G4GDMLWriteParamvol.cc.

                       : G4GDMLWriteSetup()
 {
 }

G4GDMLWriteParamvol::~G4GDMLWriteParamvol ( )

protectedvirtual

Definition at line 63 of file G4GDMLWriteParamvol.cc.

64 {

65 }

Member Function Documentation

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 325 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 (size_t i=0; i<num_zplanes; i++)
    {
      ZplaneWrite(pcone_dimensionsElement,z_array[i],
                  rmin_array[i],rmax_array[i]);
    }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 354 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 (size_t i=0; i<num_zplanes; i++)
    {
      ZplaneWrite(polyhedra_dimensionsElement,z_array[i],
                  rmin_array[i],rmax_array[i]);
    }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

geant4.10.03.p01/source/persistency/gdml/include/G4GDMLWriteParamvol.hh
geant4.10.03.p01/source/persistency/gdml/src/G4GDMLWriteParamvol.cc

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation