#include <G4GDMLWriteSolids.hh>

Inheritance diagram for G4GDMLWriteSolids:

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

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)

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

Protected Attributes
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
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 79 of file G4GDMLWriteSolids.hh.

Constructor & Destructor Documentation

G4GDMLWriteSolids::G4GDMLWriteSolids ( )

protected

Definition at line 73 of file G4GDMLWriteSolids.cc.

   : G4GDMLWriteMaterials(), solidsElement(0)
 {
 }

G4GDMLWriteSolids::~G4GDMLWriteSolids ( )

protectedvirtual

Definition at line 78 of file G4GDMLWriteSolids.cc.

79 {

80 }

Member Function Documentation

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

virtual

Definition at line 1066 of file G4GDMLWriteSolids.cc.

 {
    for (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);
    }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 size_t num_rzpoints = polycone->GetNumRZCorner();
     for (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);
     }
    
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 84 of file G4GDMLWriteSolids.cc.

 {
    G4Exception("G4GDMLWriteSolids::MultiUnionWrite()",
                "InvalidSetup", FatalException,
                "Installation with USolids primitives required!");
    return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1040 of file G4GDMLWriteSolids.cc.

 {
    xercesc::DOMElement* optElement = NewElement("opticalsurface");
    G4OpticalSurfaceModel smodel = surf->GetModel();
    G4double sval = (smodel==glisur) ? surf->GetPolish() : surf->GetSigmaAlpha();
 
    optElement->setAttributeNode(NewAttribute("name", surf->GetName()));
    optElement->setAttributeNode(NewAttribute("model", smodel));
    optElement->setAttributeNode(NewAttribute("finish", surf->GetFinish()));
    optElement->setAttributeNode(NewAttribute("type", surf->GetType()));
    optElement->setAttributeNode(NewAttribute("value", sval));
 
    solElement->appendChild(optElement);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 518 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 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 (size_t i=0; i<num_zplanes; i++)
     {
       ZplaneWrite(polyconeElement,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 G4GDMLWriteSolids::PolyhedraWrite	(	xercesc::DOMElement *	solElement,
		const G4Polyhedra * const	polyhedra
	)

protected

Definition at line 573 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 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 (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 size_t num_rzpoints = polyhedra->GetNumRZCorner();
     
     for (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);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1030 of file G4GDMLWriteSolids.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 270 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!
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Implements G4GDMLWrite.

Definition at line 1056 of file G4GDMLWriteSolids.cc.

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

Here is the call graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 654 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 size_t NumFacets = tessellated->GetNumberOfFacets();
    size_t NumVertex = 0;
    
    for (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 (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.end())  // 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));
       }
    }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 996 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("endinnerrad",
                        twistedtubs->GetInnerRadius()/mm));
    twistedtubsElement->setAttributeNode(NewAttribute("endouterrad",
                        twistedtubs->GetOuterRadius()/mm));
    twistedtubsElement->setAttributeNode(NewAttribute("zlen",
                        2.0*twistedtubs->GetZHalfLength()/mm));
    twistedtubsElement->setAttributeNode(NewAttribute("phi",
                        twistedtubs->GetDPhi()/degree));
    twistedtubsElement->setAttributeNode(NewAttribute("aunit","deg"));
    twistedtubsElement->setAttributeNode(NewAttribute("lunit","mm"));
    solElement->appendChild(twistedtubsElement);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

const G4int G4GDMLWriteSolids::maxTransforms = 8

staticprotected

Definition at line 149 of file G4GDMLWriteSolids.hh.

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

protected

Definition at line 147 of file G4GDMLWriteSolids.hh.

xercesc::DOMElement* G4GDMLWriteSolids::solidsElement

protected

Definition at line 148 of file G4GDMLWriteSolids.hh.

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation