#include <G4GDMLReadStructure.hh>

Inheritance diagram for G4GDMLReadStructure:

Public Member Functions
	G4GDMLReadStructure ()

virtual	~G4GDMLReadStructure ()

G4VPhysicalVolume *	GetPhysvol (const G4String &) const

G4LogicalVolume *	GetVolume (const G4String &) const

G4AssemblyVolume *	GetAssembly (const G4String &) const

G4GDMLAuxListType	GetVolumeAuxiliaryInformation (G4LogicalVolume *) const

G4VPhysicalVolume *	GetWorldVolume (const G4String &)

const G4GDMLAuxMapType *	GetAuxMap () const

void	Clear ()

virtual void	VolumeRead (const xercesc::DOMElement *const)

virtual void	Volume_contentRead (const xercesc::DOMElement *const)

virtual void	StructureRead (const xercesc::DOMElement *const)

Public Member Functions inherited from G4GDMLReadParamvol
virtual void	ParamvolRead (const xercesc::DOMElement const, G4LogicalVolume )

virtual void	Paramvol_contentRead (const xercesc::DOMElement *const)

Public Member Functions inherited from G4GDMLReadSetup
G4String	GetSetup (const G4String &)

virtual void	SetupRead (const xercesc::DOMElement *const element)

Public Member Functions inherited from G4GDMLReadSolids
G4VSolid *	GetSolid (const G4String &) const

G4SurfaceProperty *	GetSurfaceProperty (const G4String &) const

virtual void	SolidsRead (const xercesc::DOMElement *const)

Public Member Functions inherited from G4GDMLReadMaterials
G4Element *	GetElement (const G4String &, G4bool verbose=true) const

G4Isotope *	GetIsotope (const G4String &, G4bool verbose=true) const

G4Material *	GetMaterial (const G4String &, G4bool verbose=true) const

virtual void	MaterialsRead (const xercesc::DOMElement *const)

Public Member Functions inherited from G4GDMLReadDefine
G4bool	IsValidID (const G4String &) const

G4double	GetConstant (const G4String &)

G4double	GetVariable (const G4String &)

G4double	GetQuantity (const G4String &)

G4ThreeVector	GetPosition (const G4String &)

G4ThreeVector	GetRotation (const G4String &)

G4ThreeVector	GetScale (const G4String &)

G4GDMLMatrix	GetMatrix (const G4String &)

virtual void	DefineRead (const xercesc::DOMElement *const)

Public Member Functions inherited from G4GDMLRead
virtual void	DefineRead (const xercesc::DOMElement *const)=0

virtual void	MaterialsRead (const xercesc::DOMElement *const)=0

virtual void	SetupRead (const xercesc::DOMElement *const)=0

virtual void	SolidsRead (const xercesc::DOMElement *const)=0

virtual void	Paramvol_contentRead (const xercesc::DOMElement *const)=0

virtual void	Volume_contentRead (const xercesc::DOMElement *const)=0

virtual void	StructureRead (const xercesc::DOMElement *const)=0

virtual void	ExtensionRead (const xercesc::DOMElement *const)

virtual G4LogicalVolume *	GetVolume (const G4String &) const =0

virtual G4String	GetSetup (const G4String &)=0

void	Read (const G4String &, G4bool validation, G4bool isModule, G4bool strip=true)

void	StripNames () const

void	OverlapCheck (G4bool)

Protected Member Functions
G4GDMLAuxPairType	AuxiliaryRead (const xercesc::DOMElement *const)

void	AssemblyRead (const xercesc::DOMElement *const)

void	DivisionvolRead (const xercesc::DOMElement *const)

G4LogicalVolume *	FileRead (const xercesc::DOMElement *const)

void	PhysvolRead (const xercesc::DOMElement const, G4AssemblyVolume assembly=0)

void	ReplicavolRead (const xercesc::DOMElement *const, G4int number)

void	ReplicaRead (const xercesc::DOMElement const replicaElement, G4LogicalVolume logvol, G4int number)

EAxis	AxisRead (const xercesc::DOMElement *const axisElement)

G4double	QuantityRead (const xercesc::DOMElement *const readElement)

void	BorderSurfaceRead (const xercesc::DOMElement *const)

void	SkinSurfaceRead (const xercesc::DOMElement *const)

Protected Member Functions inherited from G4GDMLReadParamvol
	G4GDMLReadParamvol ()

virtual	~G4GDMLReadParamvol ()

void	Box_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)

void	Trd_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)

void	Trap_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)

void	Tube_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)

void	Cone_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)

void	Sphere_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)

void	Orb_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)

void	Torus_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)

void	Para_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)

void	Hype_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)

void	ParameterisedRead (const xercesc::DOMElement *const)

void	ParametersRead (const xercesc::DOMElement *const)

Protected Member Functions inherited from G4GDMLReadSetup
	G4GDMLReadSetup ()

virtual	~G4GDMLReadSetup ()

Protected Member Functions inherited from G4GDMLReadSolids
	G4GDMLReadSolids ()

virtual	~G4GDMLReadSolids ()

void	BooleanRead (const xercesc::DOMElement *const, const BooleanOp)

void	BoxRead (const xercesc::DOMElement *const)

void	ConeRead (const xercesc::DOMElement *const)

void	ElconeRead (const xercesc::DOMElement *const)

void	EllipsoidRead (const xercesc::DOMElement *const)

void	EltubeRead (const xercesc::DOMElement *const)

void	XtruRead (const xercesc::DOMElement *const)

void	HypeRead (const xercesc::DOMElement *const)

void	OrbRead (const xercesc::DOMElement *const)

void	ParaRead (const xercesc::DOMElement *const)

void	ParaboloidRead (const xercesc::DOMElement *const)

void	PolyconeRead (const xercesc::DOMElement *const)

void	PolyhedraRead (const xercesc::DOMElement *const)

G4QuadrangularFacet *	QuadrangularRead (const xercesc::DOMElement *const)

void	ReflectedSolidRead (const xercesc::DOMElement *const)

G4ExtrudedSolid::ZSection	SectionRead (const xercesc::DOMElement *const, G4double)

void	SphereRead (const xercesc::DOMElement *const)

void	TessellatedRead (const xercesc::DOMElement *const)

void	TetRead (const xercesc::DOMElement *const)

void	TorusRead (const xercesc::DOMElement *const)

void	GenTrapRead (const xercesc::DOMElement *const)

void	TrapRead (const xercesc::DOMElement *const)

void	TrdRead (const xercesc::DOMElement *const)

void	TubeRead (const xercesc::DOMElement *const)

void	CutTubeRead (const xercesc::DOMElement *const)

void	TwistedboxRead (const xercesc::DOMElement *const)

void	TwistedtrapRead (const xercesc::DOMElement *const)

void	TwistedtrdRead (const xercesc::DOMElement *const)

void	TwistedtubsRead (const xercesc::DOMElement *const)

G4TriangularFacet *	TriangularRead (const xercesc::DOMElement *const)

G4TwoVector	TwoDimVertexRead (const xercesc::DOMElement *const, G4double)

zplaneType	ZplaneRead (const xercesc::DOMElement *const)

void	OpticalSurfaceRead (const xercesc::DOMElement *const)

Protected Member Functions inherited from G4GDMLReadMaterials
	G4GDMLReadMaterials ()

virtual	~G4GDMLReadMaterials ()

G4double	AtomRead (const xercesc::DOMElement *const)

G4int	CompositeRead (const xercesc::DOMElement *const, G4String &)

G4double	DRead (const xercesc::DOMElement *const)

G4double	PRead (const xercesc::DOMElement *const)

G4double	TRead (const xercesc::DOMElement *const)

G4double	MEERead (const xercesc::DOMElement *const)

void	ElementRead (const xercesc::DOMElement *const)

G4double	FractionRead (const xercesc::DOMElement *const, G4String &)

void	IsotopeRead (const xercesc::DOMElement *const)

void	MaterialRead (const xercesc::DOMElement *const)

void	MixtureRead (const xercesc::DOMElement const, G4Element )

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

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

Protected Member Functions inherited from G4GDMLReadDefine
	G4GDMLReadDefine ()

virtual	~G4GDMLReadDefine ()

G4RotationMatrix	GetRotationMatrix (const G4ThreeVector &)

void	VectorRead (const xercesc::DOMElement *const, G4ThreeVector &)

G4String	RefRead (const xercesc::DOMElement *const)

void	ConstantRead (const xercesc::DOMElement *const)

void	MatrixRead (const xercesc::DOMElement *const)

void	PositionRead (const xercesc::DOMElement *const)

void	RotationRead (const xercesc::DOMElement *const)

void	ScaleRead (const xercesc::DOMElement *const)

void	VariableRead (const xercesc::DOMElement *const)

void	QuantityRead (const xercesc::DOMElement *const)

void	ExpressionRead (const xercesc::DOMElement *const)

Protected Member Functions inherited from G4GDMLRead
	G4GDMLRead ()

virtual	~G4GDMLRead ()

G4String	Transcode (const XMLCh *const)

G4String	GenerateName (const G4String &name, G4bool strip=false)

G4String	Strip (const G4String &) const

void	StripName (G4String &) const

void	GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)

void	LoopRead (const xercesc::DOMElement const, void(G4GDMLRead::)(const xercesc::DOMElement *const))

Protected Attributes
G4GDMLAuxMapType	auxMap

G4GDMLAssemblyMapType	assemblyMap

G4LogicalVolume *	pMotherLogical

std::map< std::string, G4VPhysicalVolume * >	setuptoPV

Protected Attributes inherited from G4GDMLReadParamvol
G4GDMLParameterisation *	parameterisation

Protected Attributes inherited from G4GDMLReadSetup
std::map< G4String, G4String >	setupMap

Protected Attributes inherited from G4GDMLReadDefine
std::map< G4String, G4double >	quantityMap

std::map< G4String, G4ThreeVector >	positionMap

std::map< G4String, G4ThreeVector >	rotationMap

std::map< G4String, G4ThreeVector >	scaleMap

std::map< G4String, G4GDMLMatrix >	matrixMap

Protected Attributes inherited from G4GDMLRead
G4GDMLEvaluator	eval

G4bool	validate

G4bool	check

Detailed Description

Definition at line 62 of file G4GDMLReadStructure.hh.

Constructor & Destructor Documentation

◆ G4GDMLReadStructure()

G4GDMLReadStructure::G4GDMLReadStructure ( )

Definition at line 48 of file G4GDMLReadStructure.cc.

  : G4GDMLReadParamvol(), pMotherLogical(0)
{
}

◆ ~G4GDMLReadStructure()

G4GDMLReadStructure::~G4GDMLReadStructure ( )

virtual

Definition at line 53 of file G4GDMLReadStructure.cc.

54{

55}

Member Function Documentation

◆ AssemblyRead()

void G4GDMLReadStructure::AssemblyRead ( const xercesc::DOMElement * const assemblyElement )

protected

Definition at line 634 of file G4GDMLReadStructure.cc.

{
   XMLCh *name_attr = xercesc::XMLString::transcode("name");
   const G4String name = Transcode(assemblyElement->getAttribute(name_attr));
   xercesc::XMLString::release(&name_attr);
 
   G4AssemblyVolume* pAssembly = new G4AssemblyVolume();
   assemblyMap.insert(std::make_pair(GenerateName(name), pAssembly));
 
   for (xercesc::DOMNode* iter = assemblyElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("G4GDMLReadStructure::AssemblyRead()",
                    "InvalidRead", FatalException, "No child found!");
        return;
      }
      const G4String tag = Transcode(child->getTagName());
 
      if (tag=="physvol")
      {
        PhysvolRead(child, pAssembly);
      }
      else
      {
        G4cout << "Unsupported GDML tag '" << tag
               << "' for Geant4 assembly structure !" << G4endl;
      }
   }
}

Referenced by StructureRead().

◆ AuxiliaryRead()

G4GDMLAuxPairType G4GDMLReadStructure::AuxiliaryRead ( const xercesc::DOMElement * const auxiliaryElement )

protected

Definition at line 57 of file G4GDMLReadStructure.cc.

{
   G4GDMLAuxPairType auxpair = {"",""};
 
   const xercesc::DOMNamedNodeMap* const attributes
         = auxiliaryElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
        { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLReadStructure::AuxiliaryRead()",
                    "InvalidRead", FatalException, "No attribute found!");
        return auxpair;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="auxtype") { auxpair.type = attValue; } else
    //      if (attName=="auxvalue") { auxpair.value = eval.Evaluate(attValue); }
      if (attName=="auxvalue") { auxpair.value = attValue; }
   }
 
   return auxpair;
}

Referenced by VolumeRead().

◆ AxisRead()

EAxis G4GDMLReadStructure::AxisRead ( const xercesc::DOMElement *const axisElement )

protected

Definition at line 516 of file G4GDMLReadStructure.cc.

{
   EAxis axis = kUndefined;
 
   const xercesc::DOMNamedNodeMap* const attributes
         = axisElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
        { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLReadStructure::AxisRead()",
                    "InvalidRead", FatalException, "No attribute found!");
        return axis;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
      if (attName=="x")
        { if( eval.Evaluate(attValue)==1.) {axis=kXAxis;} }
      else if (attName=="y")
        { if( eval.Evaluate(attValue)==1.) {axis=kYAxis;} }
      else if (attName=="z")
        { if( eval.Evaluate(attValue)==1.) {axis=kZAxis;} }
      else if (attName=="rho")
        { if( eval.Evaluate(attValue)==1.) {axis=kRho;}   }
      else if (attName=="phi")
        { if( eval.Evaluate(attValue)==1.) {axis=kPhi;}   }
   }
 
   return axis;
}

Referenced by ReplicaRead().

◆ BorderSurfaceRead()

void G4GDMLReadStructure::BorderSurfaceRead ( const xercesc::DOMElement * const bordersurfaceElement )

protected

Definition at line 93 of file G4GDMLReadStructure.cc.

{
   G4String name;
   G4VPhysicalVolume* pv1 = 0;
   G4VPhysicalVolume* pv2 = 0;
   G4SurfaceProperty* prop = 0;
   G4int index = 0;
 
   const xercesc::DOMNamedNodeMap* const attributes
         = bordersurfaceElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
        { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLReadStructure::BorderSurfaceRead()",
                    "InvalidRead", FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name")
        { name = GenerateName(attValue); } else
      if (attName=="surfaceproperty")
        { prop = GetSurfaceProperty(GenerateName(attValue)); }
   }
 
   for (xercesc::DOMNode* iter = bordersurfaceElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("G4GDMLReadStructure::BorderSurfaceRead()",
                    "InvalidRead", FatalException, "No child found!");
        return;
      }
      const G4String tag = Transcode(child->getTagName());
 
      if (tag != "physvolref")  { continue; }
 
      if (index==0)
        { pv1 = GetPhysvol(GenerateName(RefRead(child))); index++; } else
      if (index==1)
        { pv2 = GetPhysvol(GenerateName(RefRead(child))); index++; } else
      break;
   }
 
   new G4LogicalBorderSurface(Strip(name),pv1,pv2,prop);
}

Referenced by StructureRead().

◆ Clear()

void G4GDMLReadStructure::Clear ( )

Definition at line 923 of file G4GDMLReadStructure.cc.

{
  eval.Clear();
  setuptoPV.clear();
}

◆ DivisionvolRead()

void G4GDMLReadStructure::DivisionvolRead ( const xercesc::DOMElement * const divisionvolElement )

protected

Definition at line 158 of file G4GDMLReadStructure.cc.

{
   G4String name;
   G4double unit = 1.0;
   G4double width = 0.0;
   G4double offset = 0.0;
   G4int number = 0;
   EAxis axis = kUndefined;
   G4LogicalVolume* logvol = 0;
   
   const xercesc::DOMNamedNodeMap* const attributes
         = divisionvolElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
        { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLReadStructure::DivisionvolRead()",
                    "InvalidRead", FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name") { name = attValue; } else
      if (attName=="unit") { unit = eval.Evaluate(attValue); } else
      if (attName=="width") { width = eval.Evaluate(attValue); } else
      if (attName=="offset") { offset = eval.Evaluate(attValue); } else
      if (attName=="number") { number = eval.EvaluateInteger(attValue); } else
      if (attName=="axis")
      {
         if (attValue=="kXAxis") { axis = kXAxis; } else
         if (attValue=="kYAxis") { axis = kYAxis; } else
         if (attValue=="kZAxis") { axis = kZAxis; } else
         if (attValue=="kRho") { axis = kRho; } else
         if (attValue=="kPhi") { axis = kPhi; }
      }
   }
 
   width *= unit;
   offset *= unit;
 
   for (xercesc::DOMNode* iter = divisionvolElement->getFirstChild();
        iter != 0;iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("G4GDMLReadStructure::DivisionvolRead()",
                    "InvalidRead", FatalException, "No child found!");
        return;
      }
      const G4String tag = Transcode(child->getTagName());
 
      if (tag=="volumeref") { logvol = GetVolume(GenerateName(RefRead(child))); }
   }
 
   if (!logvol)  { return; }
 
   G4PVDivisionFactory::GetInstance();
   G4PhysicalVolumesPair pair;
 
   G4String pv_name = logvol->GetName() + "_div";
   if ((number != 0) && (width == 0.0))
   {
     pair = G4ReflectionFactory::Instance()
            ->Divide(pv_name,logvol,pMotherLogical,axis,number,offset);
   }
   else if ((number == 0) && (width != 0.0))
   {
     pair = G4ReflectionFactory::Instance()
            ->Divide(pv_name,logvol,pMotherLogical,axis,width,offset);
   }
   else
   {
     pair = G4ReflectionFactory::Instance()
            ->Divide(pv_name,logvol,pMotherLogical,axis,number,width,offset);
   }
 
   if (pair.first != 0) { GeneratePhysvolName(name,pair.first); }
   if (pair.second != 0) { GeneratePhysvolName(name,pair.second); }
}

Referenced by Volume_contentRead().

◆ FileRead()

G4LogicalVolume * G4GDMLReadStructure::FileRead ( const xercesc::DOMElement * const fileElement )

protected

Definition at line 254 of file G4GDMLReadStructure.cc.

{
   G4String name;
   G4String volname;
 
   const xercesc::DOMNamedNodeMap* const attributes
         = fileElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
        { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLReadStructure::FileRead()",
                    "InvalidRead", FatalException, "No attribute found!");
        return 0;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name") { name = attValue; } else
      if (attName=="volname") { volname = attValue; }
   }
 
   const G4bool isModule = true;
   G4GDMLReadStructure structure;
   structure.Read(name,validate,isModule);
 
   // Register existing auxiliar information defined in child module
   //
   const G4GDMLAuxMapType* aux = structure.GetAuxMap();
   if (!aux->empty())
   {
     G4GDMLAuxMapType::const_iterator pos;
     for (pos = aux->begin(); pos != aux->end(); ++pos)
     {
       auxMap.insert(std::make_pair(pos->first,pos->second));
     }
   }
 
   // Return volume structure from child module
   //
   if (volname.empty())
   {
     return structure.GetVolume(structure.GetSetup("Default"));
   }
   else
   {
     return structure.GetVolume(structure.GenerateName(volname));
   }
}

Referenced by PhysvolRead().

◆ GetAssembly()

G4AssemblyVolume * G4GDMLReadStructure::GetAssembly ( const G4String & ref ) const

Definition at line 880 of file G4GDMLReadStructure.cc.

{
   G4GDMLAssemblyMapType::const_iterator pos = assemblyMap.find(ref);
   if (pos != assemblyMap.end()) { return pos->second; }
   return 0;
}

Referenced by PhysvolRead().

◆ GetAuxMap()

const G4GDMLAuxMapType * G4GDMLReadStructure::GetAuxMap ( ) const

Definition at line 896 of file G4GDMLReadStructure.cc.

{
   return &auxMap;
}

Referenced by FileRead().

◆ GetPhysvol()

G4VPhysicalVolume * G4GDMLReadStructure::GetPhysvol ( const G4String & ref ) const

Definition at line 848 of file G4GDMLReadStructure.cc.

{
   G4VPhysicalVolume* physvolPtr =
     G4PhysicalVolumeStore::GetInstance()->GetVolume(ref,false);
 
   if (!physvolPtr)
   {
     G4String error_msg = "Referenced physvol '" + ref + "' was not found!";
     G4Exception("G4GDMLReadStructure::GetPhysvol()", "ReadError",
                 FatalException, error_msg);
   }
 
   return physvolPtr;
}

Referenced by BorderSurfaceRead().

◆ GetVolume()

G4LogicalVolume * G4GDMLReadStructure::GetVolume ( const G4String & ref ) const

virtual

Implements G4GDMLRead.

Definition at line 864 of file G4GDMLReadStructure.cc.

{
   G4LogicalVolume *volumePtr
   = G4LogicalVolumeStore::GetInstance()->GetVolume(ref,false);
 
   if (!volumePtr)
   {
     G4String error_msg = "Referenced volume '" + ref + "' was not found!";
     G4Exception("G4GDMLReadStructure::GetVolume()", "ReadError",
                 FatalException, error_msg);
   }
 
   return volumePtr;
}

Referenced by DivisionvolRead(), FileRead(), GetWorldVolume(), PhysvolRead(), ReplicavolRead(), and SkinSurfaceRead().

◆ GetVolumeAuxiliaryInformation()

G4GDMLAuxListType G4GDMLReadStructure::GetVolumeAuxiliaryInformation ( G4LogicalVolume * logvol ) const

Definition at line 888 of file G4GDMLReadStructure.cc.

{
   G4GDMLAuxMapType::const_iterator pos = auxMap.find(logvol);
   if (pos != auxMap.end()) { return pos->second; }
   else { return G4GDMLAuxListType(); }
}

◆ GetWorldVolume()

G4VPhysicalVolume * G4GDMLReadStructure::GetWorldVolume ( const G4String & setupName )

Definition at line 902 of file G4GDMLReadStructure.cc.

{    
   G4LogicalVolume* volume = GetVolume(Strip(GetSetup(setupName)));
   volume->SetVisAttributes(G4VisAttributes::Invisible);
 
   G4VPhysicalVolume* pvWorld = 0;
 
   if(setuptoPV[setupName])
   {
     pvWorld = setuptoPV[setupName];
   }
   else
   {
     pvWorld = new G4PVPlacement(0,G4ThreeVector(0,0,0),volume,
                                 volume->GetName()+"_PV",0,0,0);
     setuptoPV[setupName] = pvWorld;
   }
   return pvWorld;
}

◆ PhysvolRead()

void G4GDMLReadStructure::PhysvolRead	(	const xercesc::DOMElement * const	physvolElement,
		G4AssemblyVolume *	assembly = `0`
	)

protected

Definition at line 315 of file G4GDMLReadStructure.cc.

{
   G4String name;
   G4LogicalVolume* logvol = 0;
   G4AssemblyVolume* assembly = 0;
   G4ThreeVector position(0.0,0.0,0.0);
   G4ThreeVector rotation(0.0,0.0,0.0);
   G4ThreeVector scale(1.0,1.0,1.0);
 
   const xercesc::DOMNamedNodeMap* const attributes
         = physvolElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
     xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
     if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
       { continue; }
 
     const xercesc::DOMAttr* const attribute
           = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
     if (!attribute)
     {
       G4Exception("G4GDMLReadStructure::PhysvolRead()",
                   "InvalidRead", FatalException, "No attribute found!");
       return;
     }
     const G4String attName = Transcode(attribute->getName());
     const G4String attValue = Transcode(attribute->getValue());
 
     if (attName=="name") { name = attValue; }
   }
 
   for (xercesc::DOMNode* iter = physvolElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
     if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
 
     const xercesc::DOMElement* const child
           = dynamic_cast<xercesc::DOMElement*>(iter);
     if (!child)
     {
       G4Exception("G4GDMLReadStructure::PhysvolRead()",
                   "InvalidRead", FatalException, "No child found!");
       return;
     }
     const G4String tag = Transcode(child->getTagName());
 
     if (tag=="volumeref")
       {
         const G4String& child_name = GenerateName(RefRead(child));
         assembly = GetAssembly(child_name);
         if (!assembly) { logvol = GetVolume(child_name); }
       }
     else if (tag=="file")
       { logvol = FileRead(child); }
     else if (tag=="position")
       { VectorRead(child,position); }
     else if (tag=="rotation")
       { VectorRead(child,rotation); }
     else if (tag=="scale")
       { VectorRead(child,scale); }
     else if (tag=="positionref")
       { position = GetPosition(GenerateName(RefRead(child))); }
     else if (tag=="rotationref")
        { rotation = GetRotation(GenerateName(RefRead(child))); }
     else if (tag=="scaleref")
        { scale = GetScale(GenerateName(RefRead(child))); }
     else
        {
          G4String error_msg = "Unknown tag in physvol: " + tag;
          G4Exception("G4GDMLReadStructure::PhysvolRead()", "ReadError",
                      FatalException, error_msg);
          return;
        }
   }
 
   G4Transform3D transform(GetRotationMatrix(rotation).inverse(),position);
   transform = transform*G4Scale3D(scale.x(),scale.y(),scale.z());
 
   if (pAssembly)   // Fill assembly structure
   {
     if (!logvol) { return; }
     pAssembly->AddPlacedVolume(logvol, transform);
   }
   else             // Generate physical volume tree or do assembly imprint
   {
     if (assembly)
     {
       assembly->MakeImprint(pMotherLogical, transform, 0, check);
     }
     else
     {
       if (!logvol) { return; }
       G4String pv_name = logvol->GetName() + "_PV";
       G4PhysicalVolumesPair pair = G4ReflectionFactory::Instance()
         ->Place(transform,pv_name,logvol,pMotherLogical,false,0,check);
 
       if (pair.first != 0) { GeneratePhysvolName(name,pair.first); }
       if (pair.second != 0) { GeneratePhysvolName(name,pair.second); }
     }
   }
}

Referenced by AssemblyRead(), and Volume_contentRead().

◆ QuantityRead()

G4double G4GDMLReadStructure::QuantityRead ( const xercesc::DOMElement *const readElement )

protected

Definition at line 558 of file G4GDMLReadStructure.cc.

{
   G4double value = 0.0;
   G4double unit = 0.0;
   const xercesc::DOMNamedNodeMap* const attributes
         = readElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
        { continue; }
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLReadStructure::QuantityRead()",
                    "InvalidRead", FatalException, "No attribute found!");
        return value;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="unit") { unit = eval.Evaluate(attValue); } else
      if (attName=="value"){ value= eval.Evaluate(attValue); } 
   }
 
   return value*unit;
}

Referenced by ReplicaRead().

◆ ReplicaRead()

void G4GDMLReadStructure::ReplicaRead	(	const xercesc::DOMElement *const	replicaElement,
		G4LogicalVolume *	logvol,
		G4int	number
	)

protected

Definition at line 459 of file G4GDMLReadStructure.cc.

{
   G4double width = 0.0;
   G4double offset = 0.0;
   G4ThreeVector position(0.0,0.0,0.0);
   G4ThreeVector rotation(0.0,0.0,0.0);
   EAxis axis = kUndefined;
   G4String name;
 
   for (xercesc::DOMNode* iter = replicaElement->getFirstChild();
                          iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("G4GDMLReadStructure::ReplicaRead()",
                    "InvalidRead", FatalException, "No child found!");
        return;
      }
      const G4String tag = Transcode(child->getTagName()); 
 
      if (tag=="position")
        { VectorRead(child,position); } else
      if (tag=="rotation")
        { VectorRead(child,rotation); } else
      if (tag=="positionref")
        { position = GetPosition(GenerateName(RefRead(child))); } else
      if (tag=="rotationref")
        { rotation = GetRotation(GenerateName(RefRead(child))); } else
      if (tag=="direction")
        { axis=AxisRead(child); } else
      if (tag=="width")
        { width=QuantityRead(child); } else
      if (tag=="offset")
        { offset=QuantityRead(child); }
      else
      {
        G4String error_msg = "Unknown tag in ReplicaRead: " + tag;
        G4Exception("G4GDMLReadStructure::ReplicaRead()", "ReadError",
                    FatalException, error_msg);
      }
   }
 
   G4String pv_name = logvol->GetName() + "_PV";
   G4PhysicalVolumesPair pair = G4ReflectionFactory::Instance()
     ->Replicate(pv_name,logvol,pMotherLogical,axis,number,width,offset);
 
   if (pair.first != 0) { GeneratePhysvolName(name,pair.first); }
   if (pair.second != 0) { GeneratePhysvolName(name,pair.second); }
 
}

Referenced by ReplicavolRead().

◆ ReplicavolRead()

void G4GDMLReadStructure::ReplicavolRead	(	const xercesc::DOMElement * const	replicavolElement,
		G4int	number
	)

protected

Definition at line 423 of file G4GDMLReadStructure.cc.

{
  G4LogicalVolume* logvol = 0;
  for (xercesc::DOMNode* iter = replicavolElement->getFirstChild();
                         iter != 0; iter = iter->getNextSibling())
  {
    if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
 
    const xercesc::DOMElement* const child
          = dynamic_cast<xercesc::DOMElement*>(iter);
    if (!child)
    {
      G4Exception("G4GDMLReadStructure::ReplicavolRead()",
                  "InvalidRead", FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if (tag=="volumeref")
    {
      logvol = GetVolume(GenerateName(RefRead(child)));
    }
    else if (tag=="replicate_along_axis")
    {
      if (logvol)  { ReplicaRead(child,logvol,number); }
    }
    else
    {
      G4String error_msg = "Unknown tag in ReplicavolRead: " + tag;
      G4Exception("G4GDMLReadStructure::ReplicavolRead()",
                  "ReadError", FatalException, error_msg);
    }
  }
}

Referenced by Volume_contentRead().

◆ SkinSurfaceRead()

void G4GDMLReadStructure::SkinSurfaceRead ( const xercesc::DOMElement * const skinsurfaceElement )

protected

Definition at line 670 of file G4GDMLReadStructure.cc.

{
   G4String name;
   G4LogicalVolume* logvol = 0;
   G4SurfaceProperty* prop = 0;
 
   const xercesc::DOMNamedNodeMap* const attributes
         = skinsurfaceElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();
 
   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
        { continue; }
 
      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLReadStructure::SkinsurfaceRead()",
                    "InvalidRead", FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());
 
      if (attName=="name")
        { name = GenerateName(attValue); } else
      if (attName=="surfaceproperty")
        { prop = GetSurfaceProperty(GenerateName(attValue)); }
   }
 
   for (xercesc::DOMNode* iter = skinsurfaceElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("G4GDMLReadStructure::SkinsurfaceRead()",
                    "InvalidRead", FatalException, "No child found!");
        return;
      }
      const G4String tag = Transcode(child->getTagName());
 
      if (tag=="volumeref")
      {
        logvol = GetVolume(GenerateName(RefRead(child)));
      }
      else
      {
        G4String error_msg = "Unknown tag in skinsurface: " + tag;
        G4Exception("G4GDMLReadStructure::SkinsurfaceRead()", "ReadError",
                    FatalException, error_msg);
      }
   }
 
   new G4LogicalSkinSurface(Strip(name),logvol,prop);
}

Referenced by StructureRead().

◆ StructureRead()

void G4GDMLReadStructure::StructureRead ( const xercesc::DOMElement * const structureElement )

virtual

Implements G4GDMLRead.

Definition at line 814 of file G4GDMLReadStructure.cc.

{
   G4cout << "G4GDML: Reading structure..." << G4endl;
 
   for (xercesc::DOMNode* iter = structureElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("G4GDMLReadStructure::StructureRead()",
                    "InvalidRead", FatalException, "No child found!");
        return;
      }
      const G4String tag = Transcode(child->getTagName());
 
      if (tag=="bordersurface") { BorderSurfaceRead(child); } else
      if (tag=="skinsurface") { SkinSurfaceRead(child); } else
      if (tag=="volume") { VolumeRead(child); } else
      if (tag=="assembly") { AssemblyRead(child); } else
      if (tag=="loop") { LoopRead(child,&G4GDMLRead::StructureRead); }
      else
      {
        G4String error_msg = "Unknown tag in structure: " + tag;
        G4Exception("G4GDMLReadStructure::StructureRead()",
                    "ReadError", FatalException, error_msg);
      }
   }
}

◆ Volume_contentRead()

void G4GDMLReadStructure::Volume_contentRead ( const xercesc::DOMElement * const volumeElement )

virtual

Implements G4GDMLRead.

Definition at line 736 of file G4GDMLReadStructure.cc.

{
   for (xercesc::DOMNode* iter = volumeElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("G4GDMLReadStructure::Volume_contentRead()",
                    "InvalidRead", FatalException, "No child found!");
        return;
      }
      const G4String tag = Transcode(child->getTagName());
 
      if ((tag=="auxiliary") || (tag=="materialref") || (tag=="solidref"))
      {
        // These are already processed in VolumeRead()
      }
      else if (tag=="paramvol")
      {
        ParamvolRead(child,pMotherLogical);
      }
      else if (tag=="physvol")
      {
        PhysvolRead(child);
      }
      else if (tag=="replicavol")
      {
        G4int number = 1;
        const xercesc::DOMNamedNodeMap* const attributes
              = child->getAttributes();
        XMLSize_t attributeCount = attributes->getLength();
        for (XMLSize_t attribute_index=0;
                       attribute_index<attributeCount; attribute_index++)
        {
          xercesc::DOMNode* attribute_node
                 = attributes->item(attribute_index);
          if (attribute_node->getNodeType()!=xercesc::DOMNode::ATTRIBUTE_NODE)
          {
            continue;
          }
          const xercesc::DOMAttr* const attribute
                = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
          if (!attribute)
          {
            G4Exception("G4GDMLReadStructure::Volume_contentRead()",
                        "InvalidRead", FatalException, "No attribute found!");
            return;
          }
          const G4String attName = Transcode(attribute->getName());
          const G4String attValue = Transcode(attribute->getValue());
          if (attName=="number")
          {
            number = eval.EvaluateInteger(attValue);
          }
        }
        ReplicavolRead(child,number); 
      }
      else if (tag=="divisionvol")
      {
        DivisionvolRead(child);
      }
      else if (tag=="loop")
      {
        LoopRead(child,&G4GDMLRead::Volume_contentRead);
      }
      else
      {
        G4cout << "Treating unknown GDML tag in volume '" << tag
               << "' as GDML extension..." << G4endl;
      }
   }
}

Referenced by VolumeRead().

◆ VolumeRead()

void G4GDMLReadStructure::VolumeRead ( const xercesc::DOMElement * const volumeElement )

virtual

Definition at line 592 of file G4GDMLReadStructure.cc.

{
   G4VSolid* solidPtr = 0;
   G4Material* materialPtr = 0;
   G4GDMLAuxListType auxList;
   
   XMLCh *name_attr = xercesc::XMLString::transcode("name");
   const G4String name = Transcode(volumeElement->getAttribute(name_attr));
   xercesc::XMLString::release(&name_attr);
 
   for (xercesc::DOMNode* iter = volumeElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
 
      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("G4GDMLReadStructure::VolumeRead()",
                    "InvalidRead", FatalException, "No child found!");
        return;
      }
      const G4String tag = Transcode(child->getTagName());
 
      if (tag=="auxiliary")
        { auxList.push_back(AuxiliaryRead(child)); } else
      if (tag=="materialref")
        { materialPtr = GetMaterial(GenerateName(RefRead(child),true)); } else
      if (tag=="solidref")
        { solidPtr = GetSolid(GenerateName(RefRead(child))); }
   }
 
   pMotherLogical = new G4LogicalVolume(solidPtr,materialPtr,
                                        GenerateName(name),0,0,0);
 
   if (!auxList.empty()) { auxMap[pMotherLogical] = auxList; }
 
   Volume_contentRead(volumeElement);
}

Referenced by StructureRead().

Member Data Documentation

◆ assemblyMap

G4GDMLAssemblyMapType G4GDMLReadStructure::assemblyMap

protected

Definition at line 101 of file G4GDMLReadStructure.hh.

Referenced by AssemblyRead(), and GetAssembly().

◆ auxMap

G4GDMLAuxMapType G4GDMLReadStructure::auxMap

protected

Definition at line 100 of file G4GDMLReadStructure.hh.

Referenced by FileRead(), GetAuxMap(), GetVolumeAuxiliaryInformation(), and VolumeRead().

◆ pMotherLogical

G4LogicalVolume* G4GDMLReadStructure::pMotherLogical

protected

Definition at line 102 of file G4GDMLReadStructure.hh.

Referenced by DivisionvolRead(), PhysvolRead(), ReplicaRead(), Volume_contentRead(), and VolumeRead().

◆ setuptoPV

std::map<std::string, G4VPhysicalVolume*> G4GDMLReadStructure::setuptoPV

protected

Definition at line 103 of file G4GDMLReadStructure.hh.

Referenced by Clear(), and GetWorldVolume().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4GDMLReadStructure()

◆ ~G4GDMLReadStructure()

Member Function Documentation

◆ AssemblyRead()

◆ AuxiliaryRead()

◆ AxisRead()

◆ BorderSurfaceRead()

◆ Clear()

◆ DivisionvolRead()

◆ FileRead()

◆ GetAssembly()

◆ GetAuxMap()

◆ GetPhysvol()

◆ GetVolume()

◆ GetVolumeAuxiliaryInformation()

◆ GetWorldVolume()

◆ PhysvolRead()

◆ QuantityRead()

◆ ReplicaRead()

◆ ReplicavolRead()

◆ SkinSurfaceRead()

◆ StructureRead()

◆ Volume_contentRead()

◆ VolumeRead()

Member Data Documentation

◆ assemblyMap

◆ auxMap

◆ pMotherLogical

◆ setuptoPV