G4GDMLReadParamvol Class Reference

#include <G4GDMLReadParamvol.hh>

Inheritance diagram for G4GDMLReadParamvol:

Public Member Functions
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
	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
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 42 of file G4GDMLReadParamvol.hh.

Constructor & Destructor Documentation

G4GDMLReadParamvol()

G4GDMLReadParamvol::G4GDMLReadParamvol ( )

protected

Definition at line 40 of file G4GDMLReadParamvol.cc.

  : G4GDMLReadSetup()
{
}

~G4GDMLReadParamvol()

G4GDMLReadParamvol::~G4GDMLReadParamvol ( )

protectedvirtual

Definition at line 45 of file G4GDMLReadParamvol.cc.

{
}

Member Function Documentation

Box_dimensionsRead()

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

protected

Definition at line 50 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Box_dimensionsRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Box_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "x")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "y")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= 0.5 * lunit;
  parameter.dimension[1] *= 0.5 * lunit;
  parameter.dimension[2] *= 0.5 * lunit;
}

Referenced by ParametersRead().

Cone_dimensionsRead()

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

protected

Definition at line 366 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
  G4double aunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Cone_dimensionsRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Cone_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadParamvol::Cone_dimensions()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "rmin1")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "rmax1")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "rmin2")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
    else if(attName == "rmax2")
    {
      parameter.dimension[3] = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      parameter.dimension[4] = eval.Evaluate(attValue);
    }
    else if(attName == "startphi")
    {
      parameter.dimension[5] = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      parameter.dimension[6] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= lunit;
  parameter.dimension[1] *= lunit;
  parameter.dimension[2] *= lunit;
  parameter.dimension[3] *= lunit;
  parameter.dimension[4] *= 0.5 * lunit;
  parameter.dimension[5] *= aunit;
  parameter.dimension[6] *= aunit;
}

Referenced by ParametersRead().

Ellipsoid_dimensionsRead()

void G4GDMLReadParamvol::Ellipsoid_dimensionsRead ( const xercesc::DOMElement * const  element, G4GDMLParameterisation::PARAMETER &  parameter  )

protected

Definition at line 667 of file G4GDMLReadParamvol.cc.

{
  G4double lunit                                   = 1.0;
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Ellipsoid_dimensionsRead()",
                  "InvalidRead", FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Ellipsoid_dimensionsRead()",
                    "InvalidRead", FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "ax")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "by")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "cz")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
    else if(attName == "zcut1")
    {
      parameter.dimension[3] = eval.Evaluate(attValue);
    }
    else if(attName == "zcut2")
    {
      parameter.dimension[4] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= lunit;
  parameter.dimension[1] *= lunit;
  parameter.dimension[2] *= lunit;
  parameter.dimension[3] *= lunit;
  parameter.dimension[4] *= lunit;
}

Referenced by ParametersRead().

Hype_dimensionsRead()

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

protected

Definition at line 819 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
  G4double aunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "rmin")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "rmax")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "inst")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
    else if(attName == "outst")
    {
      parameter.dimension[3] = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      parameter.dimension[4] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] = lunit;
  parameter.dimension[1] = lunit;
  parameter.dimension[2] = aunit;
  parameter.dimension[3] = aunit;
  parameter.dimension[4] = 0.5 * lunit;
}

Referenced by ParametersRead().

Orb_dimensionsRead()

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

protected

Definition at line 539 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Orb_dimensionsRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
    }
    if(G4UnitDefinition::GetCategory(attValue) != "Length")
    {
      G4Exception("G4GDMLReadParamvol::Orb_dimensionsRead()", "InvalidRead",
                  FatalException, "Invalid unit for length!");
    }
    else if(attName == "r")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= lunit;
}

Referenced by ParametersRead().

Para_dimensionsRead()

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

protected

Definition at line 735 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
  G4double aunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "x")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "y")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
    else if(attName == "alpha")
    {
      parameter.dimension[3] = eval.Evaluate(attValue);
    }
    else if(attName == "theta")
    {
      parameter.dimension[4] = eval.Evaluate(attValue);
    }
    else if(attName == "phi")
    {
      parameter.dimension[5] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] = 0.5 * lunit;
  parameter.dimension[1] = 0.5 * lunit;
  parameter.dimension[2] = 0.5 * lunit;
  parameter.dimension[3] = aunit;
  parameter.dimension[4] = aunit;
  parameter.dimension[5] = aunit;
}

Referenced by ParametersRead().

ParameterisedRead()

void G4GDMLReadParamvol::ParameterisedRead ( const xercesc::DOMElement * const  element )

protected

Definition at line 1219 of file G4GDMLReadParamvol.cc.

{
  for(xercesc::DOMNode* iter = element->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("G4GDMLReadParamvol::ParameterisedRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "parameters")
    {
      const xercesc::DOMNamedNodeMap* const attributes =
        element->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("G4GDMLReadParamvol::ParameterisedRead()", "InvalidRead",
                      FatalException, "No attribute found!");
          return;
        }
        const G4String attName  = Transcode(attribute->getName());
        const G4String attValue = Transcode(attribute->getValue());
 
        if(attName == "number")
        {
          eval.Evaluate(attValue);
        }
      }
      ParametersRead(child);
    }
    else
    {
      if(tag == "loop")
      {
        LoopRead(child, &G4GDMLRead::Paramvol_contentRead);
      }
    }
  }
}

Referenced by Paramvol_contentRead().

ParametersRead()

void G4GDMLReadParamvol::ParametersRead ( const xercesc::DOMElement * const  element )

protected

Definition at line 1106 of file G4GDMLReadParamvol.cc.

{
  G4ThreeVector rotation(0.0, 0.0, 0.0);
  G4ThreeVector position(0.0, 0.0, 0.0);
 
  G4GDMLParameterisation::PARAMETER parameter;
 
  for(xercesc::DOMNode* iter = element->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("G4GDMLReadParamvol::ParametersRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
    if(tag == "rotation")
    {
      VectorRead(child, rotation);
    }
    else if(tag == "position")
    {
      VectorRead(child, position);
    }
    else if(tag == "positionref")
    {
      position = GetPosition(GenerateName(RefRead(child)));
    }
    else if(tag == "rotationref")
    {
      rotation = GetRotation(GenerateName(RefRead(child)));
    }
    else if(tag == "box_dimensions")
    {
      Box_dimensionsRead(child, parameter);
    }
    else if(tag == "trd_dimensions")
    {
      Trd_dimensionsRead(child, parameter);
    }
    else if(tag == "trap_dimensions")
    {
      Trap_dimensionsRead(child, parameter);
    }
    else if(tag == "tube_dimensions")
    {
      Tube_dimensionsRead(child, parameter);
    }
    else if(tag == "cone_dimensions")
    {
      Cone_dimensionsRead(child, parameter);
    }
    else if(tag == "sphere_dimensions")
    {
      Sphere_dimensionsRead(child, parameter);
    }
    else if(tag == "orb_dimensions")
    {
      Orb_dimensionsRead(child, parameter);
    }
    else if(tag == "torus_dimensions")
    {
      Torus_dimensionsRead(child, parameter);
    }
    else if(tag == "ellipsoid_dimensions")
    {
      Ellipsoid_dimensionsRead(child, parameter);
    }
    else if(tag == "para_dimensions")
    {
      Para_dimensionsRead(child, parameter);
    }
    else if(tag == "polycone_dimensions")
    {
      Polycone_dimensionsRead(child, parameter);
    }
    else if(tag == "polyhedra_dimensions")
    {
      Polyhedra_dimensionsRead(child, parameter);
    }
    else if(tag == "hype_dimensions")
    {
      Hype_dimensionsRead(child, parameter);
    }
    else
    {
      G4String error_msg = "Unknown tag in parameters: " + tag;
      G4Exception("G4GDMLReadParamvol::ParametersRead()", "ReadError",
                  FatalException, error_msg);
    }
  }
 
  parameter.pRot = new G4RotationMatrix();
 
  parameter.pRot->rotateX(rotation.x());
  parameter.pRot->rotateY(rotation.y());
  parameter.pRot->rotateZ(rotation.z());
 
  parameter.position = position;
 
  parameterisation->AddParameter(parameter);
}

Referenced by ParameterisedRead().

Paramvol_contentRead()

void G4GDMLReadParamvol::Paramvol_contentRead ( const xercesc::DOMElement * const  element )

virtual

Implements G4GDMLRead.

Definition at line 1284 of file G4GDMLReadParamvol.cc.

{
  for(xercesc::DOMNode* iter = element->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("G4GDMLReadParamvol::Paramvol_contentRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
    if(tag == "parameterised_position_size")
    {
      ParameterisedRead(child);
    }
    else if(tag == "loop")
    {
      LoopRead(child, &G4GDMLRead::Paramvol_contentRead);
    }
  }
}

Referenced by ParamvolRead().

ParamvolRead()

void G4GDMLReadParamvol::ParamvolRead ( const xercesc::DOMElement * const  element, G4LogicalVolume *  mother  )

virtual

Definition at line 1316 of file G4GDMLReadParamvol.cc.

{
  G4String volumeref;
 
  parameterisation = new G4GDMLParameterisation();
  for(xercesc::DOMNode* iter = element->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("G4GDMLReadParamvol::ParamvolRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "volumeref")
    {
      volumeref = RefRead(child);
    }
  }
 
  Paramvol_contentRead(element);
 
  G4LogicalVolume* logvol = GetVolume(GenerateName(volumeref));
 
  if(parameterisation->GetSize() == 0)
  {
    G4Exception("G4GDMLReadParamvol::ParamvolRead()", "ReadError",
                FatalException,
                "No parameters are defined in parameterised volume!");
  }
  G4String pv_name = logvol->GetName() + "_param";
  new G4PVParameterised(pv_name, logvol, mother, kUndefined,
                        parameterisation->GetSize(), parameterisation, check);
}

Referenced by G4GDMLReadStructure::Volume_contentRead().

Polycone_dimensionsRead()

void G4GDMLReadParamvol::Polycone_dimensionsRead ( const xercesc::DOMElement * const  element, G4GDMLParameterisation::PARAMETER &  parameter  )

protected

Definition at line 898 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
  G4double aunit = 1.0;
 
  std::vector<zplaneType> zplaneList;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Polycone_dimensionsRead()",
                  "InvalidRead", FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
                    "InvalidRead", FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadParamvol::Polycone_dimensionsRead()",
                    "InvalidRead", FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "startPhi")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "openPhi")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "numRZ")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= aunit;
  parameter.dimension[1] *= aunit;
 
  for(xercesc::DOMNode* iter = element->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("G4GDMLReadParamVol::Polycone_dimensionsRead()",
                  "InvalidRead", FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "zplane")
    {
      zplaneList.push_back(ZplaneRead(child));
    }
  }
 
  std::size_t numZPlanes = zplaneList.size();
  for(std::size_t i = 0; i < numZPlanes; ++i)
  {
    parameter.dimension[3 + i * 3] = zplaneList[i].rmin * lunit;
    parameter.dimension[4 + i * 3] = zplaneList[i].rmax * lunit;
    parameter.dimension[5 + i * 3] = zplaneList[i].z * lunit;
  }
}

Referenced by ParametersRead().

Polyhedra_dimensionsRead()

void G4GDMLReadParamvol::Polyhedra_dimensionsRead ( const xercesc::DOMElement * const  element, G4GDMLParameterisation::PARAMETER &  parameter  )

protected

Definition at line 1000 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
  G4double aunit = 1.0;
 
  std::vector<zplaneType> zplaneList;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Polycone_dimensionsRead()",
                  "InvalidRead", FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Polyhedra_dimensionsRead()",
                    "InvalidRead", FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadParamvol::Polyhedra_dimensionsRead()",
                    "InvalidRead", FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "startPhi")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "openPhi")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "numRZ")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
    else if(attName == "numSide")
    {
      parameter.dimension[3] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= aunit;
  parameter.dimension[1] *= aunit;
 
  for(auto iter = element->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("G4GDMLReadParamvo::PolyhedraRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "zplane")
    {
      zplaneList.push_back(ZplaneRead(child));
    }
  }
 
  std::size_t numZPlanes = zplaneList.size();
  for(std::size_t i = 0; i < numZPlanes; ++i)
  {
    parameter.dimension[4 + i * 3] = zplaneList[i].rmin * lunit;
    parameter.dimension[5 + i * 3] = zplaneList[i].rmax * lunit;
    parameter.dimension[6 + i * 3] = zplaneList[i].z * lunit;
  }
}

Referenced by ParametersRead().

Sphere_dimensionsRead()

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

protected

Definition at line 455 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
  G4double aunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Sphere_dimensionsRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()",
                    "InvalidRead", FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()",
                    "InvalidRead", FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "rmin")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "rmax")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "startphi")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      parameter.dimension[3] = eval.Evaluate(attValue);
    }
    else if(attName == "starttheta")
    {
      parameter.dimension[4] = eval.Evaluate(attValue);
    }
    else if(attName == "deltatheta")
    {
      parameter.dimension[5] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= lunit;
  parameter.dimension[1] *= lunit;
  parameter.dimension[2] *= aunit;
  parameter.dimension[3] *= aunit;
  parameter.dimension[4] *= aunit;
  parameter.dimension[5] *= aunit;
}

Referenced by ParametersRead().

Torus_dimensionsRead()

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

protected

Definition at line 588 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
  G4double aunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "rmin")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "rmax")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "rtor")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
    else if(attName == "startphi")
    {
      parameter.dimension[3] = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      parameter.dimension[4] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= lunit;
  parameter.dimension[1] *= lunit;
  parameter.dimension[2] *= lunit;
  parameter.dimension[3] *= aunit;
  parameter.dimension[4] *= aunit;
}

Referenced by ParametersRead().

Trap_dimensionsRead()

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

protected

Definition at line 178 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
  G4double aunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "z")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "theta")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "phi")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
    else if(attName == "y1")
    {
      parameter.dimension[3] = eval.Evaluate(attValue);
    }
    else if(attName == "x1")
    {
      parameter.dimension[4] = eval.Evaluate(attValue);
    }
    else if(attName == "x2")
    {
      parameter.dimension[5] = eval.Evaluate(attValue);
    }
    else if(attName == "alpha1")
    {
      parameter.dimension[6] = eval.Evaluate(attValue);
    }
    else if(attName == "y2")
    {
      parameter.dimension[7] = eval.Evaluate(attValue);
    }
    else if(attName == "x3")
    {
      parameter.dimension[8] = eval.Evaluate(attValue);
    }
    else if(attName == "x4")
    {
      parameter.dimension[9] = eval.Evaluate(attValue);
    }
    else if(attName == "alpha2")
    {
      parameter.dimension[10] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= 0.5 * lunit;
  parameter.dimension[1] *= aunit;
  parameter.dimension[2] *= aunit;
  parameter.dimension[3] *= 0.5 * lunit;
  parameter.dimension[4] *= 0.5 * lunit;
  parameter.dimension[5] *= 0.5 * lunit;
  parameter.dimension[6] *= aunit;
  parameter.dimension[7] *= 0.5 * lunit;
  parameter.dimension[8] *= 0.5 * lunit;
  parameter.dimension[9] *= 0.5 * lunit;
  parameter.dimension[10] *= aunit;
}

Referenced by ParametersRead().

Trd_dimensionsRead()

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

protected

Definition at line 109 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Trd_dimensionsRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Trd_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "x1")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "x2")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "y1")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
    else if(attName == "y2")
    {
      parameter.dimension[3] = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      parameter.dimension[4] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= 0.5 * lunit;
  parameter.dimension[1] *= 0.5 * lunit;
  parameter.dimension[2] *= 0.5 * lunit;
  parameter.dimension[3] *= 0.5 * lunit;
  parameter.dimension[4] *= 0.5 * lunit;
}

Referenced by ParametersRead().

Tube_dimensionsRead()

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

protected

Definition at line 287 of file G4GDMLReadParamvol.cc.

{
  G4double lunit = 1.0;
  G4double aunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes = element->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("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "InR")
    {
      parameter.dimension[0] = eval.Evaluate(attValue);
    }
    else if(attName == "OutR")
    {
      parameter.dimension[1] = eval.Evaluate(attValue);
    }
    else if(attName == "hz")
    {
      parameter.dimension[2] = eval.Evaluate(attValue);
    }
    else if(attName == "StartPhi")
    {
      parameter.dimension[3] = eval.Evaluate(attValue);
    }
    else if(attName == "DeltaPhi")
    {
      parameter.dimension[4] = eval.Evaluate(attValue);
    }
  }
 
  parameter.dimension[0] *= lunit;
  parameter.dimension[1] *= lunit;
  parameter.dimension[2] *= 0.5 * lunit;
  parameter.dimension[3] *= aunit;
  parameter.dimension[4] *= aunit;
}

Referenced by ParametersRead().

Member Data Documentation

parameterisation

G4GDMLParameterisation* G4GDMLReadParamvol::parameterisation = nullptr

protected

Definition at line 87 of file G4GDMLReadParamvol.hh.

Referenced by ParametersRead(), and ParamvolRead().

---

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

• G4GDMLReadParamvol.hh
• G4GDMLReadParamvol.cc