#include <G4GDMLWriteStructure.hh>

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

G4int	GetMaxExportLevel () const

void	SetMaxExportLevel (G4int)

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)

void	SetOutputFileOverwrite (G4bool flag)

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)

void	AssemblyWrite (xercesc::DOMElement *, const int assemblyID)

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)

void	PropertyWrite (xercesc::DOMElement , const G4OpticalSurface const)

Protected Member Functions inherited from G4GDMLWriteMaterials
	G4GDMLWriteMaterials ()

virtual	~G4GDMLWriteMaterials ()

void	AtomWrite (xercesc::DOMElement *, const G4double &)

void	DWrite (xercesc::DOMElement *, const G4double &)

void	PWrite (xercesc::DOMElement *, const G4double &)

void	TWrite (xercesc::DOMElement *, const G4double &)

void	MEEWrite (xercesc::DOMElement *, const G4double &)

void	IsotopeWrite (const G4Isotope *const)

void	ElementWrite (const G4Element *const)

void	MaterialWrite (const G4Material *const)

void	PropertyWrite (xercesc::DOMElement , const G4Material const)

void	PropertyVectorWrite (const G4String &, const G4PhysicsFreeVector *const)

void	PropertyConstWrite (const G4String &, const G4double, const G4MaterialPropertiesTable *)

Protected Member Functions inherited from G4GDMLWriteDefine
	G4GDMLWriteDefine ()

virtual	~G4GDMLWriteDefine ()

void	Scale_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)

void	Rotation_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)

void	Position_vectorWrite (xercesc::DOMElement *, const G4String &, const G4String &, const G4ThreeVector &)

Protected Member Functions inherited from G4GDMLWrite
	G4GDMLWrite ()

virtual	~G4GDMLWrite ()

VolumeMapType &	VolumeMap ()

xercesc::DOMAttr *	NewAttribute (const G4String &, const G4String &)

xercesc::DOMAttr *	NewAttribute (const G4String &, const G4double &)

xercesc::DOMElement *	NewElement (const G4String &)

G4String	Modularize (const G4VPhysicalVolume *const topvol, const G4int depth)

void	AddAuxInfo (G4GDMLAuxListType auxInfoList, xercesc::DOMElement element)

G4bool	FileExists (const G4String &) const

PhysVolumeMapType &	PvolumeMap ()

DepthMapType &	DepthMap ()

Protected Attributes
xercesc::DOMElement *	structureElement = nullptr

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 = nullptr

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

std::vector< const G4Element * >	elementList

std::vector< const G4Material * >	materialList

std::vector< const G4PhysicsFreeVector * >	propertyList

xercesc::DOMElement *	materialsElement = nullptr

Protected Attributes inherited from G4GDMLWriteDefine
xercesc::DOMElement *	defineElement = nullptr

Protected Attributes inherited from G4GDMLWrite
G4String	SchemaLocation

xercesc::DOMDocument *	doc = nullptr

xercesc::DOMElement *	extElement = nullptr

xercesc::DOMElement *	userinfoElement = nullptr

G4GDMLAuxListType	auxList

G4bool	overwriteOutputFile = false

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

Constructor & Destructor Documentation

◆ G4GDMLWriteStructure()

G4GDMLWriteStructure::G4GDMLWriteStructure ( )

Definition at line 61 of file G4GDMLWriteStructure.cc.

  : G4GDMLWriteParamvol()
  , maxLevel(INT_MAX)
{
  reflFactory = G4ReflectionFactory::Instance();
}

◆ ~G4GDMLWriteStructure()

G4GDMLWriteStructure::~G4GDMLWriteStructure ( )

virtual

Definition at line 69 of file G4GDMLWriteStructure.cc.

70{

71}

Member Function Documentation

◆ AddVolumeAuxiliary()

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

Definition at line 826 of file G4GDMLWriteStructure.cc.

{
  auto pos = auxmap.find(lvol);
 
  if(pos == auxmap.cend())
  {
    auxmap[lvol] = G4GDMLAuxListType();
  }
 
  auxmap[lvol].push_back(myaux);
}

Referenced by ExportEnergyCuts(), and ExportSD().

◆ AssemblyWrite()

void G4GDMLWriteStructure::AssemblyWrite	(	xercesc::DOMElement *	volumeElement,
		const int	assemblyID )

protected

Definition at line 264 of file G4GDMLWriteStructure.cc.

{
  G4AssemblyStore* assemblies  = G4AssemblyStore::GetInstance();
  G4AssemblyVolume* myassembly = assemblies->GetAssembly(assemblyID);
 
  xercesc::DOMElement* assemblyElement = NewElement("assembly");
  G4String name = "Assembly_" + std::to_string(assemblyID);
 
  assemblyElement->setAttributeNode(NewAttribute("name", name));
 
  auto vit = myassembly->GetTripletsIterator();
 
  G4int depth = 0;
  const G4String ModuleName;
 
  for(std::size_t i5 = 0; i5 < myassembly->TotalTriplets(); ++i5)
  {
    G4LogicalVolume* lvol = (*vit).GetVolume();
    if (lvol == nullptr)
    {
      G4String message = "Nested assemblies not yet supported for exporting. Sorry!";
      G4Exception("G4GDMLWriteStructure::AssemblyWrite()", "InvalidSetup",
                  FatalException, message);
      return;
    }
    TraverseVolumeTree(lvol, depth + 1);
 
    const G4ThreeVector rot = GetAngles((*vit).GetRotation()->inverse());
    const G4ThreeVector pos = (*vit).GetTranslation();
 
    const G4String pname =
      GenerateName((*vit).GetVolume()->GetName() + "_pv", &(*vit));
 
    xercesc::DOMElement* physvolElement = NewElement("physvol");
    physvolElement->setAttributeNode(NewAttribute("name", pname));
 
    assemblyElement->appendChild(physvolElement);
 
    const G4String volumeref =
      GenerateName((*vit).GetVolume()->GetName(), (*vit).GetVolume());
 
    xercesc::DOMElement* volumerefElement = NewElement("volumeref");
    volumerefElement->setAttributeNode(NewAttribute("ref", volumeref));
    physvolElement->appendChild(volumerefElement);
 
    if(std::fabs(pos.x()) > kLinearPrecision ||
       std::fabs(pos.y()) > kLinearPrecision ||
       std::fabs(pos.z()) > kLinearPrecision)
    {
      PositionWrite(physvolElement,name+"_position_" + std::to_string(i5), pos);
    }
 
    if(std::fabs(rot.x()) > kAngularPrecision ||
       std::fabs(rot.y()) > kAngularPrecision ||
       std::fabs(rot.z()) > kAngularPrecision)
    {
      RotationWrite(physvolElement,name+"_rotation_" + std::to_string(i5), rot);
    }
    ++vit;
  }
 
  volumeElement->appendChild(assemblyElement);
}

Referenced by TraverseVolumeTree().

◆ BorderSurfaceCache()

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

protected

Definition at line 330 of file G4GDMLWriteStructure.cc.

{
  if(bsurf == nullptr)
  {
    return;
  }
 
  const G4SurfaceProperty* psurf = bsurf->GetSurfaceProperty();
 
  // Generate the new element for border-surface
  //
  const G4String& bsname             = GenerateName(bsurf->GetName(), bsurf);
  const G4String& psname             = GenerateName(psurf->GetName(), psurf);
  xercesc::DOMElement* borderElement = NewElement("bordersurface");
  borderElement->setAttributeNode(NewAttribute("name", bsname));
  borderElement->setAttributeNode(NewAttribute("surfaceproperty", psname));
 
  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 == nullptr)
    {
      G4Exception("G4GDMLWriteStructure::BorderSurfaceCache()", "InvalidSetup",
                  FatalException, "No optical surface found!");
      return;
    }
    OpticalSurfaceWrite(solidsElement, opsurf);
  }
 
  borderElementVec.push_back(borderElement);
}

Referenced by GetBorderSurface().

◆ DivisionvolWrite()

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

protected

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

Referenced by TraverseVolumeTree().

◆ ExportEnergyCuts()

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

protected

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

Referenced by TraverseVolumeTree().

◆ ExportSD()

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

protected

Definition at line 888 of file G4GDMLWriteStructure.cc.

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

Referenced by TraverseVolumeTree().

◆ FindOpticalSurface()

G4bool G4GDMLWriteStructure::FindOpticalSurface ( const G4SurfaceProperty * psurf )

protected

Definition at line 417 of file G4GDMLWriteStructure.cc.

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

Referenced by BorderSurfaceCache(), and SkinSurfaceCache().

◆ GetBorderSurface()

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

protected

Definition at line 450 of file G4GDMLWriteStructure.cc.

{
  G4LogicalBorderSurface* surf = nullptr;
  std::size_t nsurf = G4LogicalBorderSurface::GetNumberOfBorderSurfaces();
  if(nsurf)
  {
    const G4LogicalBorderSurfaceTable* btable =
      G4LogicalBorderSurface::GetSurfaceTable();
    for(auto pos = btable->cbegin(); pos != btable->cend(); ++pos)
    {
      if(pvol == pos->first.first)  // just the first in the couple
      {                             // could be enough?
        surf = pos->second;         // break;
        BorderSurfaceCache(surf);
      }
    }
  }
  return surf;
}

Referenced by TraverseVolumeTree().

◆ GetMaxExportLevel()

G4int G4GDMLWriteStructure::GetMaxExportLevel ( ) const

Definition at line 902 of file G4GDMLWriteStructure.cc.

{
  return maxLevel;
}

◆ GetSkinSurface()

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

protected

Definition at line 431 of file G4GDMLWriteStructure.cc.

{
  G4LogicalSkinSurface* surf = nullptr;
  std::size_t nsurf = G4LogicalSkinSurface::GetNumberOfSkinSurfaces();
  if(nsurf)
  {
    const G4LogicalSkinSurfaceTable* stable =
      G4LogicalSkinSurface::GetSurfaceTable();
    auto pos = stable->find(lvol);
    if(pos != stable->cend())
    {
      surf = pos->second;
    }
  }
  return surf;
}

Referenced by TraverseVolumeTree().

◆ PhysvolWrite()

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

protected

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

Referenced by TraverseVolumeTree().

◆ ReplicavolWrite()

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

protected

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

Referenced by TraverseVolumeTree().

◆ SetEnergyCutsExport()

void G4GDMLWriteStructure::SetEnergyCutsExport ( G4bool fcuts )

Definition at line 840 of file G4GDMLWriteStructure.cc.

{
  cexport = fcuts;
}

◆ SetMaxExportLevel()

void G4GDMLWriteStructure::SetMaxExportLevel ( G4int level )

Definition at line 908 of file G4GDMLWriteStructure.cc.

{
  if(level <= 0)
  {
    G4Exception("G4GDMLWriteStructure::TraverseVolumeTree()", "InvalidSetup",
                FatalException, "Levels to export must be greater than zero!");
    return;
  }
  maxLevel = level;
  levelNo  = 0;
}

◆ SetSDExport()

void G4GDMLWriteStructure::SetSDExport ( G4bool fsd )

Definition at line 882 of file G4GDMLWriteStructure.cc.

{
  sdexport = fsd;
}

◆ SkinSurfaceCache()

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

protected

Definition at line 376 of file G4GDMLWriteStructure.cc.

{
  if(ssurf == nullptr)
  {
    return;
  }
 
  const G4SurfaceProperty* psurf = ssurf->GetSurfaceProperty();
 
  // Generate the new element for border-surface
  //
  const G4String& ssname           = GenerateName(ssurf->GetName(), ssurf);
  const G4String& psname           = GenerateName(psurf->GetName(), psurf);
  xercesc::DOMElement* skinElement = NewElement("skinsurface");
  skinElement->setAttributeNode(NewAttribute("name", ssname));
  skinElement->setAttributeNode(NewAttribute("surfaceproperty", psname));
 
  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 == nullptr)
    {
      G4Exception("G4GDMLWriteStructure::SkinSurfaceCache()", "InvalidSetup",
                  FatalException, "No optical surface found!");
      return;
    }
    OpticalSurfaceWrite(solidsElement, opsurf);
  }
 
  skinElementVec.push_back(skinElement);
}

Referenced by TraverseVolumeTree().

◆ StructureWrite()

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

virtual

Implements G4GDMLWrite.

Definition at line 490 of file G4GDMLWriteStructure.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Writing structure..." << G4endl;
#endif
 
  // filling the list of phys volumes that are parts of assemblies
 
  G4AssemblyStore* assemblies = G4AssemblyStore::GetInstance();
 
  for(auto it = assemblies->cbegin(); it != assemblies->cend(); ++it)
  {
    auto vit = (*it)->GetVolumesIterator();
 
    for(std::size_t i5 = 0; i5 < (*it)->TotalImprintedVolumes(); ++i5)
    {
      G4String pvname = (*vit)->GetName();
      std::size_t pos = pvname.find("_impr_") + 6;
      G4String impID  = pvname.substr(pos);
 
      pos   = impID.find("_");
      impID = impID.substr(0, pos);
 
      assemblyVolMap[*vit] = (*it)->GetAssemblyID();
      imprintsMap[*vit]    = std::atoi(impID.c_str());
      ++vit;
    }
  }
 
  structureElement = NewElement("structure");
  gdmlElement->appendChild(structureElement);
}

◆ SurfacesWrite()

void G4GDMLWriteStructure::SurfacesWrite ( )

protectedvirtual

Implements G4GDMLWrite.

Definition at line 472 of file G4GDMLWriteStructure.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Writing surfaces..." << G4endl;
#endif
  for(auto pos = skinElementVec.cbegin();
           pos != skinElementVec.cend(); ++pos)
  {
    structureElement->appendChild(*pos);
  }
  for(auto pos = borderElementVec.cbegin();
           pos != borderElementVec.cend(); ++pos)
  {
    structureElement->appendChild(*pos);
  }
}

◆ TraverseVolumeTree()

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

protectedvirtual

Implements G4GDMLWrite.

Definition at line 524 of file G4GDMLWriteStructure.cc.

{
  if(VolumeMap().find(volumePtr) != VolumeMap().cend())
  {
    return VolumeMap()[volumePtr];  // Volume is already processed
  }
 
  G4VSolid* solidPtr = volumePtr->GetSolid();
  G4Transform3D R, invR;
  G4int trans = 0;
 
  std::map<const G4LogicalVolume*, G4GDMLAuxListType>::iterator auxiter;
 
  ++levelNo;
 
  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().cend())
    {
      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);
 
  G4String materialref = "NULL";
 
  if(volumePtr->GetMaterial())
  {
    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);
 
  std::size_t daughterCount = volumePtr->GetNoDaughters();
 
  if(levelNo == maxLevel)  // Stop exporting if reached levels limit
  {
    daughterCount = 0;
  }
 
  std::map<G4int, std::vector<G4int> > assemblyIDToAddedImprints;
 
  for(std::size_t 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 or an assembly?
        {
          if(assemblyVolMap.find(physvol) != assemblyVolMap.cend())
          {
            G4int assemblyID = assemblyVolMap[physvol];
 
            G4String assemblyref = "Assembly_" + std::to_string(assemblyID);
 
            // here I need to retrieve the imprint ID
 
            G4int imprintID = imprintsMap[physvol];
 
            // there are 2 steps:
            //
            // 1) add assembly to the structure if that has not yet been done
            // (but after the constituents volumes have been added)
            //
 
            if(std::find(addedAssemblies.cbegin(), addedAssemblies.cend(),
                         assemblyID) == addedAssemblies.cend())
            {
              AssemblyWrite(structureElement, assemblyID);
              addedAssemblies.push_back(assemblyID);
              assemblyIDToAddedImprints[assemblyID] = std::vector<G4int>();
            }
 
            // 2) add the assembly (as physical volume) to the mother volume
            // (but only once), using it's original position and rotation.
            //
 
            // here I need a check if assembly has been already added to the
            // mother volume
            std::vector<G4int>& addedImprints = assemblyIDToAddedImprints[assemblyID];
            if(std::find(addedImprints.cbegin(), addedImprints.cend(),
                         imprintID) == addedImprints.cend())
            {
              G4String imprintname = "Imprint_" + std::to_string(imprintID) + "_";
              imprintname          = GenerateName(imprintname, physvol);
 
              // I need to get those two from the  container of imprints from
              // the assembly I have the imprint ID, I need to get pos and rot
              //
              G4Transform3D& transf = G4AssemblyStore::GetInstance()
                                        ->GetAssembly(assemblyID)
                                        ->GetImprintTransformation(imprintID);
 
              HepGeom::Scale3D scale;
              HepGeom::Rotate3D rotate;
              HepGeom::Translate3D translate;
 
              transf.getDecomposition(scale, rotate, translate);
 
              const G4ThreeVector scl(scale(0, 0), scale(1, 1), scale(2, 2));
              const G4ThreeVector rot = GetAngles(rotate.getRotation().inverse());
              const G4ThreeVector pos = transf.getTranslation();
 
              // here I need a normal physvol referencing to my assemblyref
 
              xercesc::DOMElement* physvolElement = NewElement("physvol");
              physvolElement->setAttributeNode(NewAttribute("name", imprintname));
 
              xercesc::DOMElement* volumerefElement = NewElement("volumeref");
              volumerefElement->setAttributeNode(NewAttribute("ref", assemblyref));
              physvolElement->appendChild(volumerefElement);
 
              if(std::fabs(pos.x()) > kLinearPrecision ||
                 std::fabs(pos.y()) > kLinearPrecision ||
                 std::fabs(pos.z()) > kLinearPrecision)
              {
                PositionWrite(physvolElement, imprintname + "_pos", pos);
              }
              if(std::fabs(rot.x()) > kAngularPrecision ||
                 std::fabs(rot.y()) > kAngularPrecision ||
                 std::fabs(rot.z()) > kAngularPrecision)
              {
                RotationWrite(physvolElement, imprintname + "_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);
              }
 
              volumeElement->appendChild(physvolElement);
              //
              addedImprints.push_back(imprintID);
            }
          }
          else  // not part of assembly, so a normal physical volume
          {
            G4RotationMatrix rot;
            if(physvol->GetFrameRotation() != nullptr)
            {
              rot = *(physvol->GetFrameRotation());
            }
            G4Transform3D P(rot, physvol->GetObjectTranslation());
 
            PhysvolWrite(volumeElement, physvol, invR * P * daughterR,
                         ModuleName);
          }
        }
      }
    }
    // BorderSurfaceCache(GetBorderSurface(physvol));
    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.cend())
  {
    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;
}

Referenced by AssemblyWrite(), and TraverseVolumeTree().

Member Data Documentation

◆ auxmap

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

protected

Definition at line 94 of file G4GDMLWriteStructure.hh.

Referenced by AddVolumeAuxiliary(), and TraverseVolumeTree().

◆ borderElementVec

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

protected

Definition at line 92 of file G4GDMLWriteStructure.hh.

Referenced by BorderSurfaceCache(), and SurfacesWrite().

◆ skinElementVec

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

protected

Definition at line 93 of file G4GDMLWriteStructure.hh.

Referenced by SkinSurfaceCache(), and SurfacesWrite().

◆ structureElement

xercesc::DOMElement* G4GDMLWriteStructure::structureElement = nullptr

protected

Definition at line 91 of file G4GDMLWriteStructure.hh.

Referenced by StructureWrite(), SurfacesWrite(), and TraverseVolumeTree().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4GDMLWriteStructure()

◆ ~G4GDMLWriteStructure()

Member Function Documentation

◆ AddVolumeAuxiliary()

◆ AssemblyWrite()

◆ BorderSurfaceCache()

◆ DivisionvolWrite()

◆ ExportEnergyCuts()

◆ ExportSD()

◆ FindOpticalSurface()

◆ GetBorderSurface()

◆ GetMaxExportLevel()

◆ GetSkinSurface()

◆ PhysvolWrite()

◆ ReplicavolWrite()

◆ SetEnergyCutsExport()

◆ SetMaxExportLevel()

◆ SetSDExport()

◆ SkinSurfaceCache()

◆ StructureWrite()

◆ SurfacesWrite()

◆ TraverseVolumeTree()

Member Data Documentation

◆ auxmap

◆ borderElementVec

◆ skinElementVec

◆ structureElement