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

void	SetReverseSearch (G4bool flag)

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 void	UserinfoRead (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	StripName (G4String &) const

void	OverlapCheck (G4bool)

const G4GDMLAuxListType *	GetAuxList () const

Protected Member Functions
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	MultiUnionNodeRead (const xercesc::DOMElement const, G4MultiUnion 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)

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

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

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	GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)

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

G4GDMLAuxStructType	AuxiliaryRead (const xercesc::DOMElement *const auxElem)

Protected Attributes
G4GDMLAuxMapType	auxMap

G4GDMLAssemblyMapType	assemblyMap

G4LogicalVolume *	pMotherLogical = nullptr

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

G4bool	strip = false

Protected Attributes inherited from G4GDMLReadParamvol
G4GDMLParameterisation *	parameterisation = nullptr

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

Protected Attributes inherited from G4GDMLReadDefine
G4bool	reverseSearch = false

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

G4bool	check = false

G4bool	dostrip = true

Detailed Description

Definition at line 51 of file G4GDMLReadStructure.hh.

Constructor & Destructor Documentation

◆ G4GDMLReadStructure()

G4GDMLReadStructure::G4GDMLReadStructure ( )

Definition at line 47 of file G4GDMLReadStructure.cc.

  : G4GDMLReadParamvol()
{
}

◆ ~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 818 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();
  auto aName = GenerateName(name);
  if(reverseSearch)
  {
    assemblyMap.insert_or_assign(aName, pAssembly);
  }
  else
  { 
    assemblyMap.insert(std::make_pair(aName, pAssembly));
  }
 
  for(xercesc::DOMNode* iter = assemblyElement->getFirstChild();
                        iter != nullptr; iter = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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().

◆ AxisRead()

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

protected

Definition at line 643 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 == nullptr)
    {
      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 58 of file G4GDMLReadStructure.cc.

{
  G4String name;
  G4VPhysicalVolume* pv1  = nullptr;
  G4VPhysicalVolume* pv2  = nullptr;
  G4SurfaceProperty* prop = nullptr;
  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 == nullptr)
    {
      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 != nullptr; iter = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
 
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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 1162 of file G4GDMLReadStructure.cc.

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

◆ DivisionvolRead()

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

protected

Definition at line 143 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 = nullptr;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    divisionvolElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
  G4String unitname;
 
  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 == nullptr)
    {
      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     = G4UnitDefinition::GetValueOf(attValue);
      unitname = G4UnitDefinition::GetCategory(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;
      }
    }
  }
 
  if(((axis == kXAxis || axis == kYAxis || axis == kZAxis) &&
      unitname != "Length") ||
     ((axis == kRho || axis == kPhi) && unitname != "Angle"))
  {
    G4Exception("G4GDMLReadStructure::DivisionvolRead()", "InvalidRead",
                FatalException, "Invalid unit!");
  }
 
  width *= unit;
  offset *= unit;
 
  for(xercesc::DOMNode* iter = divisionvolElement->getFirstChild();
                        iter != nullptr; iter = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
 
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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 == nullptr)
  {
    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 != nullptr)
  {
    GeneratePhysvolName(name, pair.first);
  }
  if(pair.second != nullptr)
  {
    GeneratePhysvolName(name, pair.second);
  }
}

Referenced by Volume_contentRead().

◆ FileRead()

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

protected

Definition at line 297 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 == nullptr)
    {
      G4Exception("G4GDMLReadStructure::FileRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return nullptr;
    }
    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())
  {
    for(auto pos = aux->cbegin(); pos != aux->cend(); ++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 1108 of file G4GDMLReadStructure.cc.

{
  auto pos = assemblyMap.find(ref);
  if(pos != assemblyMap.cend())
  {
    return pos->second;
  }
  return nullptr;
}

Referenced by PhysvolRead().

◆ GetAuxMap()

const G4GDMLAuxMapType * G4GDMLReadStructure::GetAuxMap ( ) const

inline

Definition at line 63 of file G4GDMLReadStructure.hh.

63{ return &auxMap; }

Referenced by FileRead().

◆ GetPhysvol()

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

Definition at line 1076 of file G4GDMLReadStructure.cc.

{
  G4VPhysicalVolume* physvolPtr
    = G4PhysicalVolumeStore::GetInstance()->GetVolume(ref,false,reverseSearch);
 
  if(physvolPtr == nullptr)
  {
    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 1092 of file G4GDMLReadStructure.cc.

{
  G4LogicalVolume* volumePtr
    = G4LogicalVolumeStore::GetInstance()->GetVolume(ref,false,reverseSearch);
 
  if(volumePtr == nullptr)
  {
    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 1119 of file G4GDMLReadStructure.cc.

{
  auto pos = auxMap.find(logvol);
  if(pos != auxMap.cend())
  {
    return pos->second;
  }
  else
  {
    return G4GDMLAuxListType();
  }
}

◆ GetWorldVolume()

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

Definition at line 1134 of file G4GDMLReadStructure.cc.

{
  G4String sname = GetSetup(setupName);
  if(sname == "")
  {
    return nullptr;
  }
 
  G4LogicalVolume* volume = GetVolume(GenerateName(sname, dostrip));
  volume->SetVisAttributes(G4VisAttributes::GetInvisible());
 
  G4VPhysicalVolume* pvWorld = nullptr;
 
  if(setuptoPV[setupName])
  {
    pvWorld = setuptoPV[setupName];
  }
  else
  {
    pvWorld = new G4PVPlacement(nullptr, 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 366 of file G4GDMLReadStructure.cc.

{
  G4String name;
  G4LogicalVolume* logvol    = nullptr;
  G4AssemblyVolume* assembly = nullptr;
  G4ThreeVector position(0.0, 0.0, 0.0);
  G4ThreeVector rotation(0.0, 0.0, 0.0);
  G4ThreeVector scale(1.0, 1.0, 1.0);
  G4int copynumber = 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 == nullptr)
    {
      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;
    }
    if(attName == "copynumber")
    {
      copynumber = eval.EvaluateInteger(attValue);
    }
  }
 
  for(xercesc::DOMNode* iter = physvolElement->getFirstChild(); iter != nullptr;
      iter                   = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
 
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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 == nullptr)
      {
        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 != nullptr)  // Fill assembly structure
  {
    if(assembly != nullptr)  // Case of recursive assemblies
    {
      pAssembly->AddPlacedAssembly(assembly, transform);
    }
    if(logvol == nullptr)
    {
      return;
    }
    pAssembly->AddPlacedVolume(logvol, transform);
  }
  else  // Generate physical volume tree or do assembly imprint
  {
    if(assembly != nullptr)
    {
      assembly->MakeImprint(pMotherLogical, transform, 0, check);
    }
    else
    {
      if(logvol == nullptr)
      {
        return;
      }
      G4String pv_name           = logvol->GetName() + "_PV";
      G4PhysicalVolumesPair pair = G4ReflectionFactory::Instance()->Place(
        transform, pv_name, logvol, pMotherLogical, false, copynumber, check);
 
      if(pair.first != nullptr)
      {
        GeneratePhysvolName(name, pair.first);
      }
      if(pair.second != nullptr)
      {
        GeneratePhysvolName(name, pair.second);
      }
    }
  }
}

Referenced by AssemblyRead(), and Volume_contentRead().

◆ QuantityRead()

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

protected

Definition at line 713 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 == nullptr)
    {
      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 = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length" &&
         G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadStructure::QuantityRead()", "InvalidRead",
                    FatalException,
                    "Invalid unit for length or angle (width, offset)!");
      }
    }
    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 563 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 != nullptr;
      iter                   = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
 
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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 != nullptr)
  {
    GeneratePhysvolName(name, pair.first);
  }
  if(pair.second != nullptr)
  {
    GeneratePhysvolName(name, pair.second);
  }
}

Referenced by ReplicavolRead().

◆ ReplicavolRead()

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

protected

Definition at line 520 of file G4GDMLReadStructure.cc.

{
  G4LogicalVolume* logvol = nullptr;
  for(xercesc::DOMNode* iter = replicavolElement->getFirstChild();
                        iter != nullptr; iter = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
 
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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 866 of file G4GDMLReadStructure.cc.

{
  G4String name;
  G4LogicalVolume* logvol = nullptr;
  G4SurfaceProperty* prop = nullptr;
 
  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 == nullptr)
    {
      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 != nullptr; iter = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
 
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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 1022 of file G4GDMLReadStructure.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Reading structure..." << G4endl;
#endif
  for(xercesc::DOMNode* iter = structureElement->getFirstChild();
                        iter != nullptr; iter = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
 
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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 942 of file G4GDMLReadStructure.cc.

{
  for(xercesc::DOMNode* iter = volumeElement->getFirstChild(); iter != nullptr;
      iter                   = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
 
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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 == nullptr)
        {
          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 763 of file G4GDMLReadStructure.cc.

{
  G4VSolid* solidPtr      = nullptr;
  G4Material* materialPtr = nullptr;
  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 != nullptr;
      iter                   = iter->getNextSibling())
  {
    if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
    {
      continue;
    }
 
    const xercesc::DOMElement* const child =
      dynamic_cast<xercesc::DOMElement*>(iter);
    if(child == nullptr)
    {
      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 88 of file G4GDMLReadStructure.hh.

Referenced by AssemblyRead(), and GetAssembly().

◆ auxMap

G4GDMLAuxMapType G4GDMLReadStructure::auxMap

protected

Definition at line 87 of file G4GDMLReadStructure.hh.

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

◆ pMotherLogical

G4LogicalVolume* G4GDMLReadStructure::pMotherLogical = nullptr

protected

Definition at line 89 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 90 of file G4GDMLReadStructure.hh.

Referenced by Clear(), and GetWorldVolume().

◆ strip

G4bool G4GDMLReadStructure::strip = false

protected

Definition at line 91 of file G4GDMLReadStructure.hh.

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

◆ 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

◆ strip