#include <G4GDMLWriteStructure.hh>

Inheritance diagram for G4GDMLWriteStructure:

Collaboration diagram for G4GDMLWriteStructure:

Public Member Functions
	G4GDMLWriteStructure ()

virtual	~G4GDMLWriteStructure ()

virtual void	StructureWrite (xercesc::DOMElement *)

void	AddVolumeAuxiliary (G4GDMLAuxStructType myaux, const G4LogicalVolume *const)

void	SetEnergyCutsExport (G4bool)

void	SetSDExport (G4bool)

Public Member Functions inherited from G4GDMLWriteParamvol
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	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
void	DivisionvolWrite (xercesc::DOMElement , const G4PVDivision const)

void	PhysvolWrite (xercesc::DOMElement , const G4VPhysicalVolume const topVol, const G4Transform3D &transform, const G4String &moduleName)

void	ReplicavolWrite (xercesc::DOMElement , const G4VPhysicalVolume const)

G4Transform3D	TraverseVolumeTree (const G4LogicalVolume *const topVol, const G4int depth)

void	SurfacesWrite ()

void	BorderSurfaceCache (const G4LogicalBorderSurface *const)

void	SkinSurfaceCache (const G4LogicalSkinSurface *const)

const G4LogicalBorderSurface *	GetBorderSurface (const G4VPhysicalVolume *const)

const G4LogicalSkinSurface *	GetSkinSurface (const G4LogicalVolume *const)

G4bool	FindOpticalSurface (const G4SurfaceProperty *)

void	ExportEnergyCuts (const G4LogicalVolume *const)

void	ExportSD (const G4LogicalVolume *const)

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

Protected Attributes
xercesc::DOMElement *	structureElement

std::vector < xercesc::DOMElement * >	borderElementVec

std::vector < xercesc::DOMElement * >	skinElementVec

std::map< const G4LogicalVolume *, G4GDMLAuxListType >	auxmap

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

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

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 56 of file G4GDMLWriteStructure.hh.

Constructor & Destructor Documentation

G4GDMLWriteStructure::G4GDMLWriteStructure ( )

Definition at line 60 of file G4GDMLWriteStructure.cc.

   : G4GDMLWriteParamvol(), cexport(false)
 {
   reflFactory = G4ReflectionFactory::Instance();
 }

Here is the call graph for this function:

G4GDMLWriteStructure::~G4GDMLWriteStructure ( )

virtual

Definition at line 66 of file G4GDMLWriteStructure.cc.

67 {

68 }

Member Function Documentation

void G4GDMLWriteStructure::AddVolumeAuxiliary	(	G4GDMLAuxStructType	myaux,
		const G4LogicalVolume * const	lvol
	)

Definition at line 564 of file G4GDMLWriteStructure.cc.

 {
   std::map<const G4LogicalVolume*,
            G4GDMLAuxListType>::iterator pos = auxmap.find(lvol);
 
   if (pos == auxmap.end())  { auxmap[lvol] = G4GDMLAuxListType(); }
   
   auxmap[lvol].push_back(myaux);
 }

Here is the caller graph for this function:

void G4GDMLWriteStructure::BorderSurfaceCache ( const G4LogicalBorderSurface * const bsurf )

protected

Definition at line 232 of file G4GDMLWriteStructure.cc.

 {
    if (!bsurf)  { return; }
 
    const G4SurfaceProperty* psurf = bsurf->GetSurfaceProperty();
 
    // Generate the new element for border-surface
    //
    xercesc::DOMElement* borderElement = NewElement("bordersurface");
    borderElement->setAttributeNode(NewAttribute("name", bsurf->GetName()));
    borderElement->setAttributeNode(NewAttribute("surfaceproperty",
                                                 psurf->GetName()));
 
    const G4String volumeref1 = GenerateName(bsurf->GetVolume1()->GetName(),
                                             bsurf->GetVolume1());
    const G4String volumeref2 = GenerateName(bsurf->GetVolume2()->GetName(),
                                             bsurf->GetVolume2());
    xercesc::DOMElement* volumerefElement1 = NewElement("physvolref");
    xercesc::DOMElement* volumerefElement2 = NewElement("physvolref");
    volumerefElement1->setAttributeNode(NewAttribute("ref",volumeref1));
    volumerefElement2->setAttributeNode(NewAttribute("ref",volumeref2));
    borderElement->appendChild(volumerefElement1);
    borderElement->appendChild(volumerefElement2);
 
    if (FindOpticalSurface(psurf))
    {
      const G4OpticalSurface* opsurf =
        dynamic_cast<const G4OpticalSurface*>(psurf);
      if (!opsurf)
      {
        G4Exception("G4GDMLWriteStructure::BorderSurfaceCache()",
                    "InvalidSetup", FatalException, "No optical surface found!");
        return;
      }
      OpticalSurfaceWrite(solidsElement, opsurf);
    }
 
    borderElementVec.push_back(borderElement);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4GDMLWriteStructure::DivisionvolWrite	(	xercesc::DOMElement *	volumeElement,
		const G4PVDivision * const	divisionvol
	)

protected

Definition at line 71 of file G4GDMLWriteStructure.cc.

 {
    EAxis axis = kUndefined;
    G4int number = 0;
    G4double width = 0.0;
    G4double offset = 0.0;
    G4bool consuming = false;
 
    divisionvol->GetReplicationData(axis,number,width,offset,consuming);
    axis = divisionvol->GetDivisionAxis();
 
    G4String unitString("mm");
    G4String axisString("kUndefined");
    if (axis==kXAxis) { axisString = "kXAxis"; }
    else if (axis==kYAxis) { axisString = "kYAxis"; }
    else if (axis==kZAxis) { axisString = "kZAxis"; }
    else if (axis==kRho)   { axisString = "kRho";     }
    else if (axis==kPhi)   { axisString = "kPhi"; unitString = "rad"; }
 
    const G4String name
          = GenerateName(divisionvol->GetName(),divisionvol);
    const G4String volumeref
          = GenerateName(divisionvol->GetLogicalVolume()->GetName(),
                         divisionvol->GetLogicalVolume());
 
    xercesc::DOMElement* divisionvolElement = NewElement("divisionvol");
    divisionvolElement->setAttributeNode(NewAttribute("axis",axisString));
    divisionvolElement->setAttributeNode(NewAttribute("number",number));
    divisionvolElement->setAttributeNode(NewAttribute("width",width));
    divisionvolElement->setAttributeNode(NewAttribute("offset",offset));
    divisionvolElement->setAttributeNode(NewAttribute("unit",unitString));
    xercesc::DOMElement* volumerefElement = NewElement("volumeref");
    volumerefElement->setAttributeNode(NewAttribute("ref",volumeref));
    divisionvolElement->appendChild(volumerefElement);
    volumeElement->appendChild(divisionvolElement);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4GDMLWriteStructure::ExportEnergyCuts ( const G4LogicalVolume * const lvol )

protected

Definition at line 582 of file G4GDMLWriteStructure.cc.

 {
   G4GDMLEvaluator eval;
   G4ProductionCuts* pcuts = lvol->GetRegion()->GetProductionCuts();
   G4ProductionCutsTable* ctab = G4ProductionCutsTable::GetProductionCutsTable();
   G4Gamma* gamma = G4Gamma::Gamma();
   G4Electron* eminus = G4Electron::Electron();
   G4Positron* eplus = G4Positron::Positron();
   G4Proton* proton = G4Proton::Proton();
 
   G4double gamma_cut = ctab->ConvertRangeToEnergy(gamma, lvol->GetMaterial(),
                                             pcuts->GetProductionCut("gamma"));
   G4double eminus_cut = ctab->ConvertRangeToEnergy(eminus, lvol->GetMaterial(),
                                             pcuts->GetProductionCut("e-"));
   G4double eplus_cut = ctab->ConvertRangeToEnergy(eplus, lvol->GetMaterial(),
                                             pcuts->GetProductionCut("e+"));
   G4double proton_cut = ctab->ConvertRangeToEnergy(proton, lvol->GetMaterial(),
                                             pcuts->GetProductionCut("proton"));
 
   G4GDMLAuxStructType gammainfo = {"gammaECut",
                                    eval.ConvertToString(gamma_cut), "MeV", 0};
   G4GDMLAuxStructType eminusinfo = {"electronECut",
                                   eval.ConvertToString(eminus_cut), "MeV", 0};
   G4GDMLAuxStructType eplusinfo = {"positronECut",
                                   eval.ConvertToString(eplus_cut), "MeV", 0};
   G4GDMLAuxStructType protinfo = {"protonECut",
                                   eval.ConvertToString(proton_cut), "MeV", 0};
 
   AddVolumeAuxiliary(gammainfo, lvol);
   AddVolumeAuxiliary(eminusinfo, lvol);
   AddVolumeAuxiliary(eplusinfo, lvol);
   AddVolumeAuxiliary(protinfo, lvol);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4GDMLWriteStructure::ExportSD ( const G4LogicalVolume * const lvol )

protected

Definition at line 624 of file G4GDMLWriteStructure.cc.

 {
   G4VSensitiveDetector* sd = lvol->GetSensitiveDetector();
   
   if(sd)
     {
       G4String SDname = sd->GetName();
       
       G4GDMLAuxStructType SDinfo = {"SensDet", SDname, "", 0};
       AddVolumeAuxiliary(SDinfo, lvol);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4GDMLWriteStructure::FindOpticalSurface ( const G4SurfaceProperty * psurf )

protected

Definition at line 308 of file G4GDMLWriteStructure.cc.

 {
    const G4OpticalSurface* osurf = dynamic_cast<const G4OpticalSurface*>(psurf);
    std::vector<const G4OpticalSurface*>::const_iterator pos;
    pos = std::find(opt_vec.begin(), opt_vec.end(), osurf);
    if (pos != opt_vec.end()) { return false; }  // item already created!
 
    opt_vec.push_back(osurf);              // cache it for future reference
    return true;
 }

Here is the caller graph for this function:

const G4LogicalBorderSurface * G4GDMLWriteStructure::GetBorderSurface ( const G4VPhysicalVolume * const pvol )

protected

Definition at line 341 of file G4GDMLWriteStructure.cc.

 {
   G4LogicalBorderSurface* surf = 0;
   G4int nsurf = G4LogicalBorderSurface::GetNumberOfBorderSurfaces();
   if (nsurf)
   {
     const G4LogicalBorderSurfaceTable* btable =
           G4LogicalBorderSurface::GetSurfaceTable();
     std::vector<G4LogicalBorderSurface*>::const_iterator pos;
     for (pos = btable->begin(); pos != btable->end(); pos++)
     {
       if (pvol == (*pos)->GetVolume1())  // just the first in the couple 
       {                                  // is enough
         surf = *pos; break;
       }
     }
   }
   return surf;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const G4LogicalSkinSurface * G4GDMLWriteStructure::GetSkinSurface ( const G4LogicalVolume * const lvol )

protected

Definition at line 320 of file G4GDMLWriteStructure.cc.

 {
   G4LogicalSkinSurface* surf = 0;
   G4int nsurf = G4LogicalSkinSurface::GetNumberOfSkinSurfaces();
   if (nsurf)
   {
     const G4LogicalSkinSurfaceTable* stable =
           G4LogicalSkinSurface::GetSurfaceTable();
     std::vector<G4LogicalSkinSurface*>::const_iterator pos;
     for (pos = stable->begin(); pos != stable->end(); pos++)
     {
       if (lvol == (*pos)->GetLogicalVolume())
       {
         surf = *pos; break;
       }
     }
   }
   return surf;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4GDMLWriteStructure::PhysvolWrite	(	xercesc::DOMElement *	volumeElement,
		const G4VPhysicalVolume *const	topVol,
		const G4Transform3D &	transform,
		const G4String &	moduleName
	)

protected

Definition at line 109 of file G4GDMLWriteStructure.cc.

 {
    HepGeom::Scale3D scale;
    HepGeom::Rotate3D rotate;
    HepGeom::Translate3D translate;
 
    T.getDecomposition(scale,rotate,translate);
 
    const G4ThreeVector scl(scale(0,0),scale(1,1),scale(2,2));
    const G4ThreeVector rot = GetAngles(rotate.getRotation());
    const G4ThreeVector pos = T.getTranslation();
 
    const G4String name = GenerateName(physvol->GetName(),physvol);
    const G4int copynumber = physvol->GetCopyNo();
 
    xercesc::DOMElement* physvolElement = NewElement("physvol");
    physvolElement->setAttributeNode(NewAttribute("name",name));
    if (copynumber) physvolElement->setAttributeNode(NewAttribute("copynumber", copynumber));
 
    volumeElement->appendChild(physvolElement);
 
    G4LogicalVolume* lv;
    // Is it reflected?
    if (reflFactory->IsReflected(physvol->GetLogicalVolume()))
      {
        lv = reflFactory->GetConstituentLV(physvol->GetLogicalVolume());
      }
    else
      {
        lv = physvol->GetLogicalVolume();
      }
    
    const G4String volumeref = GenerateName(lv->GetName(), lv);
 
    if (ModuleName.empty())
    {
       xercesc::DOMElement* volumerefElement = NewElement("volumeref");
       volumerefElement->setAttributeNode(NewAttribute("ref",volumeref));
       physvolElement->appendChild(volumerefElement);
    }
    else
    {
       xercesc::DOMElement* fileElement = NewElement("file");
       fileElement->setAttributeNode(NewAttribute("name",ModuleName));
       fileElement->setAttributeNode(NewAttribute("volname",volumeref));
       physvolElement->appendChild(fileElement);
    }
 
    if (std::fabs(pos.x()) > kLinearPrecision
     || std::fabs(pos.y()) > kLinearPrecision
     || std::fabs(pos.z()) > kLinearPrecision)
    {
      PositionWrite(physvolElement,name+"_pos",pos);
    }
    if (std::fabs(rot.x()) > kAngularPrecision
     || std::fabs(rot.y()) > kAngularPrecision
     || std::fabs(rot.z()) > kAngularPrecision)
    {
      RotationWrite(physvolElement,name+"_rot",rot);
    }
    if (std::fabs(scl.x()-1.0) > kRelativePrecision
     || std::fabs(scl.y()-1.0) > kRelativePrecision
     || std::fabs(scl.z()-1.0) > kRelativePrecision)
    {
      ScaleWrite(physvolElement,name+"_scl",scl);
    }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4GDMLWriteStructure::ReplicavolWrite	(	xercesc::DOMElement *	volumeElement,
		const G4VPhysicalVolume * const	replicavol
	)

protected

Definition at line 180 of file G4GDMLWriteStructure.cc.

 {
    EAxis axis = kUndefined;
    G4int number = 0;
    G4double width = 0.0;
    G4double offset = 0.0;
    G4bool consuming = false;
    G4String unitString("mm");
 
    replicavol->GetReplicationData(axis,number,width,offset,consuming);
 
    const G4String volumeref
          = GenerateName(replicavol->GetLogicalVolume()->GetName(),
                         replicavol->GetLogicalVolume());
 
    xercesc::DOMElement* replicavolElement = NewElement("replicavol");
    replicavolElement->setAttributeNode(NewAttribute("number",number));
    xercesc::DOMElement* volumerefElement = NewElement("volumeref");
    volumerefElement->setAttributeNode(NewAttribute("ref",volumeref));
    replicavolElement->appendChild(volumerefElement);
    xercesc::DOMElement* replicateElement = NewElement("replicate_along_axis");
    replicavolElement->appendChild(replicateElement);
 
    xercesc::DOMElement* dirElement = NewElement("direction");
    if(axis==kXAxis)
      { dirElement->setAttributeNode(NewAttribute("x","1")); }
    else if(axis==kYAxis)
      { dirElement->setAttributeNode(NewAttribute("y","1")); }
    else if(axis==kZAxis)
      { dirElement->setAttributeNode(NewAttribute("z","1")); }
    else if(axis==kRho)
      { dirElement->setAttributeNode(NewAttribute("rho","1")); }
    else if(axis==kPhi)
      { dirElement->setAttributeNode(NewAttribute("phi","1"));
        unitString="rad"; }
    replicateElement->appendChild(dirElement);
 
    xercesc::DOMElement* widthElement = NewElement("width");
    widthElement->setAttributeNode(NewAttribute("value",width));
    widthElement->setAttributeNode(NewAttribute("unit",unitString));
    replicateElement->appendChild(widthElement);
 
    xercesc::DOMElement* offsetElement = NewElement("offset");
    offsetElement->setAttributeNode(NewAttribute("value",offset));
    offsetElement->setAttributeNode(NewAttribute("unit",unitString));
    replicateElement->appendChild(offsetElement);
 
    volumeElement->appendChild(replicavolElement);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4GDMLWriteStructure::SetEnergyCutsExport ( G4bool fcuts )

Definition at line 576 of file G4GDMLWriteStructure.cc.

 {
   cexport = fcuts;
 }

void G4GDMLWriteStructure::SetSDExport ( G4bool fsd )

Definition at line 617 of file G4GDMLWriteStructure.cc.

 {
   sdexport = fsd;
 }

void G4GDMLWriteStructure::SkinSurfaceCache ( const G4LogicalSkinSurface * const ssurf )

protected

Definition at line 273 of file G4GDMLWriteStructure.cc.

 {
    if (!ssurf)  { return; }
 
    const G4SurfaceProperty* psurf = ssurf->GetSurfaceProperty();
 
    // Generate the new element for border-surface
    //
    xercesc::DOMElement* skinElement = NewElement("skinsurface");
    skinElement->setAttributeNode(NewAttribute("name", ssurf->GetName()));
    skinElement->setAttributeNode(NewAttribute("surfaceproperty",
                                               psurf->GetName()));
 
    const G4String volumeref = GenerateName(ssurf->GetLogicalVolume()->GetName(),
                                            ssurf->GetLogicalVolume());
    xercesc::DOMElement* volumerefElement = NewElement("volumeref");
    volumerefElement->setAttributeNode(NewAttribute("ref",volumeref));
    skinElement->appendChild(volumerefElement);
 
    if (FindOpticalSurface(psurf))
    {
      const G4OpticalSurface* opsurf =
        dynamic_cast<const G4OpticalSurface*>(psurf);
      if (!opsurf)
      {
        G4Exception("G4GDMLWriteStructure::SkinSurfaceCache()",
                    "InvalidSetup", FatalException, "No optical surface found!");
        return;
      }
      OpticalSurfaceWrite(solidsElement, opsurf);
    }
 
    skinElementVec.push_back(skinElement);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4GDMLWriteStructure::StructureWrite ( xercesc::DOMElement * gdmlElement )

virtual

Implements G4GDMLWrite.

Definition at line 376 of file G4GDMLWriteStructure.cc.

 {
    G4cout << "G4GDML: Writing structure..." << G4endl;
 
    structureElement = NewElement("structure");
    gdmlElement->appendChild(structureElement);
 }

Here is the call graph for this function:

void G4GDMLWriteStructure::SurfacesWrite ( )

protectedvirtual

Implements G4GDMLWrite.

Definition at line 361 of file G4GDMLWriteStructure.cc.

 {
    G4cout << "G4GDML: Writing surfaces..." << G4endl;
 
    std::vector<xercesc::DOMElement*>::const_iterator pos;
    for (pos = skinElementVec.begin(); pos != skinElementVec.end(); pos++)
    {
      structureElement->appendChild(*pos);
    }
    for (pos = borderElementVec.begin(); pos != borderElementVec.end(); pos++)
    {
      structureElement->appendChild(*pos);
    }
 }

G4Transform3D G4GDMLWriteStructure::TraverseVolumeTree	(	const G4LogicalVolume *const	topVol,
		const G4int	depth
	)

protectedvirtual

Implements G4GDMLWrite.

Definition at line 385 of file G4GDMLWriteStructure.cc.

 {
    if (VolumeMap().find(volumePtr) != VolumeMap().end())
    {
      return VolumeMap()[volumePtr]; // Volume is already processed
    }
    
    G4VSolid* solidPtr = volumePtr->GetSolid();
    G4Transform3D R,invR;
    G4int trans=0;
 
    std::map<const G4LogicalVolume*, G4GDMLAuxListType>::iterator auxiter; 
 
    while (true) // Solve possible displacement/reflection
    {            // of the referenced solid!
       if (trans>maxTransforms)
       {
         G4String ErrorMessage = "Referenced solid in volume '"
                               + volumePtr->GetName()
                               + "' was displaced/reflected too many times!";
         G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
                     "InvalidSetup", FatalException, ErrorMessage);
       }
 
       if (G4ReflectedSolid* refl = dynamic_cast<G4ReflectedSolid*>(solidPtr))
       {
          R = R*refl->GetTransform3D();
          solidPtr = refl->GetConstituentMovedSolid();
          trans++;
          continue;
       }
 
       if (G4DisplacedSolid* disp = dynamic_cast<G4DisplacedSolid*>(solidPtr))
       {
          R = R*G4Transform3D(disp->GetObjectRotation(),
                              disp->GetObjectTranslation());
          solidPtr = disp->GetConstituentMovedSolid();
          trans++;
          continue;
       }
 
       break;
    }
 
    //check if it is a reflected volume
    G4LogicalVolume* tmplv = const_cast<G4LogicalVolume*>(volumePtr);
   
    if (reflFactory->IsReflected(tmplv))
      {
        tmplv = reflFactory->GetConstituentLV(tmplv);
        if (VolumeMap().find(tmplv) != VolumeMap().end())
      {
        return R; // Volume is already processed
      }    
      }
    
    // Only compute the inverse when necessary!
    //
    if (trans>0) { invR = R.inverse(); }
 
    const G4String name
      = GenerateName(tmplv->GetName(), tmplv);
    const G4String materialref
          = GenerateName(volumePtr->GetMaterial()->GetName(),
                         volumePtr->GetMaterial());
    const G4String solidref
          = GenerateName(solidPtr->GetName(),solidPtr);
 
    xercesc::DOMElement* volumeElement = NewElement("volume");
    volumeElement->setAttributeNode(NewAttribute("name",name));
    xercesc::DOMElement* materialrefElement = NewElement("materialref");
    materialrefElement->setAttributeNode(NewAttribute("ref",materialref));
    volumeElement->appendChild(materialrefElement);
    xercesc::DOMElement* solidrefElement = NewElement("solidref");
    solidrefElement->setAttributeNode(NewAttribute("ref",solidref));
    volumeElement->appendChild(solidrefElement);
 
    const G4int daughterCount = volumePtr->GetNoDaughters();
        
    for (G4int i=0;i<daughterCount;i++)   // Traverse all the children!
      {
        const G4VPhysicalVolume* const physvol = volumePtr->GetDaughter(i);
        const G4String ModuleName = Modularize(physvol,depth);
        
        G4Transform3D daughterR;
        
        if (ModuleName.empty())   // Check if subtree requested to be 
      {                         // a separate module!
        daughterR = TraverseVolumeTree(physvol->GetLogicalVolume(),depth+1);
      }
        else
      {   
        G4GDMLWriteStructure writer;
        daughterR = writer.Write(ModuleName,physvol->GetLogicalVolume(),
                     SchemaLocation,depth+1);
      }     
        
        if (const G4PVDivision* const divisionvol
        = dynamic_cast<const G4PVDivision*>(physvol)) // Is it division?
      {
        if (!G4Transform3D::Identity.isNear(invR*daughterR,kRelativePrecision))
          {
            G4String ErrorMessage = "Division volume in '" + name
          + "' can not be related to reflected solid!";
            G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
                "InvalidSetup", FatalException, ErrorMessage);
          }
        DivisionvolWrite(volumeElement,divisionvol); 
      } else 
      if (physvol->IsParameterised())   // Is it a paramvol?
        {
          if (!G4Transform3D::Identity.isNear(invR*daughterR,kRelativePrecision))
            {
          G4String ErrorMessage = "Parameterised volume in '" + name
            + "' can not be related to reflected solid!";
          G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
                  "InvalidSetup", FatalException, ErrorMessage);
            }
          ParamvolWrite(volumeElement,physvol);
        } else
        if (physvol->IsReplicated())   // Is it a replicavol?
          {
            if (!G4Transform3D::Identity.isNear(invR*daughterR,kRelativePrecision))
          {
            G4String ErrorMessage = "Replica volume in '" + name
              + "' can not be related to reflected solid!";
            G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()",
                    "InvalidSetup", FatalException, ErrorMessage);
          }
            ReplicavolWrite(volumeElement,physvol); 
          }
        else   // Is it a physvol?
          {
            G4RotationMatrix rot;
            if (physvol->GetFrameRotation() != 0)
          {
            rot = *(physvol->GetFrameRotation());
          }
            G4Transform3D P(rot,physvol->GetObjectTranslation());
                    
            PhysvolWrite(volumeElement,physvol,invR*P*daughterR,ModuleName);
          }
        BorderSurfaceCache(GetBorderSurface(physvol));
      }
 
    if (cexport)  { ExportEnergyCuts(volumePtr); }
    // Add optional energy cuts
 
    if (sdexport)  { ExportSD(volumePtr); }
    // Add optional SDs
  
    // Here write the auxiliary info
    //
    auxiter = auxmap.find(volumePtr);  
    if (auxiter != auxmap.end())
      {
        AddAuxInfo(&(auxiter->second), volumeElement);
      }
 
    structureElement->appendChild(volumeElement);
    // Append the volume AFTER traversing the children so that
    // the order of volumes will be correct!
        
    VolumeMap()[tmplv] = R;
        
    AddExtension(volumeElement, volumePtr);
    // Add any possible user defined extension attached to a volume
        
    AddMaterial(volumePtr->GetMaterial());
    // Add the involved materials and solids!
        
    AddSolid(solidPtr);
        
    SkinSurfaceCache(GetSkinSurface(volumePtr));
        
    return R;
 }

Here is the call graph for this function:

Member Data Documentation

std::map<const G4LogicalVolume*, G4GDMLAuxListType> G4GDMLWriteStructure::auxmap

protected

Definition at line 92 of file G4GDMLWriteStructure.hh.

std::vector<xercesc::DOMElement*> G4GDMLWriteStructure::borderElementVec

protected

Definition at line 90 of file G4GDMLWriteStructure.hh.

std::vector<xercesc::DOMElement*> G4GDMLWriteStructure::skinElementVec

protected

Definition at line 91 of file G4GDMLWriteStructure.hh.

xercesc::DOMElement* G4GDMLWriteStructure::structureElement

protected

Definition at line 89 of file G4GDMLWriteStructure.hh.

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

source/geant4.10.03.p03/source/persistency/gdml/include/G4GDMLWriteStructure.hh
source/geant4.10.03.p03/source/persistency/gdml/src/G4GDMLWriteStructure.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation