G4GDMLReadStructure Class Reference

#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	ExtensionRead (const xercesc::DOMElement *const)
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	Ellipsoid_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	Polycone_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	Polyhedra_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	MultiUnionRead (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	GenericPolyconeRead (const xercesc::DOMElement *const)
void	PolyhedraRead (const xercesc::DOMElement *const)
void	GenericPolyhedraRead (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)
rzPointType	RZPointRead (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

(

)

Definition at line 48 of file G4GDMLReadStructure.cc.

  : G4GDMLReadParamvol(), pMotherLogical(0)
{
}

G4GDMLReadStructure::~G4GDMLReadStructure ( )

virtual

Definition at line 53 of file G4GDMLReadStructure.cc.

{
}

Member Function Documentation

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

protected

Definition at line 635 of file G4GDMLReadStructure.cc.

References assemblyMap, FatalException, G4cout, G4endl, G4Exception(), G4GDMLRead::GenerateName(), PhysvolRead(), and G4GDMLRead::Transcode().

Referenced by StructureRead().

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

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

protected

Definition at line 58 of file G4GDMLReadStructure.cc.

References FatalException, G4Exception(), G4GDMLRead::Transcode(), G4GDMLAuxPairType::type, and G4GDMLAuxPairType::value.

Referenced by G03ColorReader::VolumeRead(), and VolumeRead().

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

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

protected

Definition at line 517 of file G4GDMLReadStructure.cc.

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), kPhi, kRho, kUndefined, kXAxis, kYAxis, kZAxis, and G4GDMLRead::Transcode().

Referenced by ReplicaRead().

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

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

protected

Definition at line 94 of file G4GDMLReadStructure.cc.

References FatalException, G4Exception(), G4GDMLRead::GenerateName(), GetPhysvol(), G4GDMLReadSolids::GetSurfaceProperty(), G4GDMLReadDefine::RefRead(), G4GDMLRead::Strip(), and G4GDMLRead::Transcode().

Referenced by StructureRead().

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

void G4GDMLReadStructure::Clear

(

)

Definition at line 923 of file G4GDMLReadStructure.cc.

References G4GDMLEvaluator::Clear(), G4GDMLRead::eval, and setuptoPV.

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

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

protected

Definition at line 159 of file G4GDMLReadStructure.cc.

References G4ReflectionFactory::Divide(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), G4GDMLEvaluator::EvaluateInteger(), FatalException, G4String::first(), G4Exception(), G4GDMLRead::GenerateName(), G4GDMLRead::GeneratePhysvolName(), G4PVDivisionFactory::GetInstance(), G4LogicalVolume::GetName(), GetVolume(), G4ReflectionFactory::Instance(), kPhi, kRho, kUndefined, kXAxis, kYAxis, kZAxis, pMotherLogical, G4GDMLReadDefine::RefRead(), G4GDMLRead::Transcode(), and width.

Referenced by Volume_contentRead().

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

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

protected

Definition at line 255 of file G4GDMLReadStructure.cc.

References auxMap, FatalException, G4Exception(), G4GDMLRead::GenerateName(), GetAuxMap(), G4GDMLReadSetup::GetSetup(), GetVolume(), G4GDMLRead::Read(), G4GDMLRead::Transcode(), and G4GDMLRead::validate.

Referenced by PhysvolRead().

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

G4AssemblyVolume * G4GDMLReadStructure::GetAssembly

(

const G4String &

ref

)

const

Definition at line 881 of file G4GDMLReadStructure.cc.

References assemblyMap.

Referenced by PhysvolRead().

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

const G4GDMLAuxMapType * G4GDMLReadStructure::GetAuxMap

(

)

const

Definition at line 897 of file G4GDMLReadStructure.cc.

References auxMap.

Referenced by FileRead().

{
   return &auxMap;
}

G4VPhysicalVolume * G4GDMLReadStructure::GetPhysvol

(

const G4String &

ref

)

const

Definition at line 849 of file G4GDMLReadStructure.cc.

References FatalException, G4Exception(), G4PhysicalVolumeStore::GetInstance(), and G4PhysicalVolumeStore::GetVolume().

Referenced by BorderSurfaceRead().

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

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

virtual

Implements G4GDMLRead.

Definition at line 865 of file G4GDMLReadStructure.cc.

References FatalException, G4Exception(), G4LogicalVolumeStore::GetInstance(), and G4LogicalVolumeStore::GetVolume().

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

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

G4GDMLAuxListType G4GDMLReadStructure::GetVolumeAuxiliaryInformation

(

G4LogicalVolume *

logvol

)

const

Definition at line 889 of file G4GDMLReadStructure.cc.

References auxMap.

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

G4VPhysicalVolume * G4GDMLReadStructure::GetWorldVolume

(

const G4String &

setupName

)

Definition at line 903 of file G4GDMLReadStructure.cc.

References G4LogicalVolume::GetName(), G4GDMLReadSetup::GetSetup(), GetVolume(), G4VisAttributes::Invisible, setuptoPV, G4LogicalVolume::SetVisAttributes(), and G4GDMLRead::Strip().

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

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

protected

Definition at line 316 of file G4GDMLReadStructure.cc.

References G4AssemblyVolume::AddPlacedVolume(), G4GDMLRead::check, FatalException, FileRead(), G4String::first(), G4Exception(), G4GDMLRead::GenerateName(), G4GDMLRead::GeneratePhysvolName(), GetAssembly(), G4LogicalVolume::GetName(), G4GDMLReadDefine::GetPosition(), G4GDMLReadDefine::GetRotation(), G4GDMLReadDefine::GetRotationMatrix(), G4GDMLReadDefine::GetScale(), GetVolume(), G4ReflectionFactory::Instance(), G4AssemblyVolume::MakeImprint(), G4ReflectionFactory::Place(), pMotherLogical, position, G4GDMLReadDefine::RefRead(), G4GDMLRead::Transcode(), G4GDMLReadDefine::VectorRead(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by AssemblyRead(), and Volume_contentRead().

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

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

protected

Definition at line 559 of file G4GDMLReadStructure.cc.

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), and G4GDMLRead::Transcode().

Referenced by ReplicaRead().

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

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

protected

Definition at line 460 of file G4GDMLReadStructure.cc.

References AxisRead(), FatalException, G4String::first(), G4Exception(), G4GDMLRead::GenerateName(), G4GDMLRead::GeneratePhysvolName(), G4LogicalVolume::GetName(), G4GDMLReadDefine::GetPosition(), G4GDMLReadDefine::GetRotation(), G4ReflectionFactory::Instance(), kUndefined, pMotherLogical, position, QuantityRead(), G4GDMLReadDefine::RefRead(), G4ReflectionFactory::Replicate(), G4GDMLRead::Transcode(), G4GDMLReadDefine::VectorRead(), and width.

Referenced by ReplicavolRead().

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

}

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

protected

Definition at line 424 of file G4GDMLReadStructure.cc.

References FatalException, G4Exception(), G4GDMLRead::GenerateName(), GetVolume(), G4GDMLReadDefine::RefRead(), ReplicaRead(), and G4GDMLRead::Transcode().

Referenced by Volume_contentRead().

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

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

protected

Definition at line 671 of file G4GDMLReadStructure.cc.

References FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadSolids::GetSurfaceProperty(), GetVolume(), G4GDMLReadDefine::RefRead(), G4GDMLRead::Strip(), and G4GDMLRead::Transcode().

Referenced by StructureRead().

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

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

virtual

Implements G4GDMLRead.

Definition at line 815 of file G4GDMLReadStructure.cc.

References AssemblyRead(), BorderSurfaceRead(), FatalException, G4cout, G4endl, G4Exception(), G4GDMLRead::LoopRead(), SkinSurfaceRead(), G4GDMLRead::StructureRead(), G4GDMLRead::Transcode(), and VolumeRead().

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

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

virtual

Implements G4GDMLRead.

Definition at line 737 of file G4GDMLReadStructure.cc.

References DivisionvolRead(), G4GDMLRead::eval, G4GDMLEvaluator::EvaluateInteger(), FatalException, G4cout, G4endl, G4Exception(), G4GDMLRead::LoopRead(), G4GDMLReadParamvol::ParamvolRead(), PhysvolRead(), pMotherLogical, ReplicavolRead(), G4GDMLRead::Transcode(), and G4GDMLRead::Volume_contentRead().

Referenced by G03ColorReader::VolumeRead(), and VolumeRead().

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

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

virtual

Reimplemented in G03ColorReader.

Definition at line 593 of file G4GDMLReadStructure.cc.

References AuxiliaryRead(), auxMap, FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadMaterials::GetMaterial(), G4GDMLReadSolids::GetSolid(), pMotherLogical, G4GDMLReadDefine::RefRead(), G4GDMLRead::Transcode(), and Volume_contentRead().

Referenced by StructureRead().

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

Field Documentation

G4GDMLAssemblyMapType G4GDMLReadStructure::assemblyMap

protected

Definition at line 101 of file G4GDMLReadStructure.hh.

Referenced by AssemblyRead(), and GetAssembly().

G4GDMLAuxMapType G4GDMLReadStructure::auxMap

protected

Definition at line 100 of file G4GDMLReadStructure.hh.

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

G4LogicalVolume* G4GDMLReadStructure::pMotherLogical

protected

Definition at line 102 of file G4GDMLReadStructure.hh.

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

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:

• G4GDMLReadStructure.hh
• G4GDMLReadStructure.cc