G4GDMLReadParamvol Class Reference

#include <G4GDMLReadParamvol.hh>

Inheritance diagram for G4GDMLReadParamvol:

Public Member Functions
virtual void	DefineRead (const xercesc::DOMElement *const)
virtual void	ExtensionRead (const xercesc::DOMElement *const)
const G4GDMLAuxListType *	GetAuxList () const
G4double	GetConstant (const G4String &)
G4Element *	GetElement (const G4String &, G4bool verbose=true) const
G4Isotope *	GetIsotope (const G4String &, G4bool verbose=true) const
G4Material *	GetMaterial (const G4String &, G4bool verbose=true) const
G4GDMLMatrix	GetMatrix (const G4String &)
G4ThreeVector	GetPosition (const G4String &)
G4double	GetQuantity (const G4String &)
G4ThreeVector	GetRotation (const G4String &)
G4ThreeVector	GetScale (const G4String &)
G4String	GetSetup (const G4String &)
G4VSolid *	GetSolid (const G4String &) const
G4SurfaceProperty *	GetSurfaceProperty (const G4String &) const
G4double	GetVariable (const G4String &)
virtual G4LogicalVolume *	GetVolume (const G4String &) const =0
G4bool	IsValidID (const G4String &) const
virtual void	MaterialsRead (const xercesc::DOMElement *const)
void	OverlapCheck (G4bool)
virtual void	Paramvol_contentRead (const xercesc::DOMElement *const)
virtual void	ParamvolRead (const xercesc::DOMElement *const, G4LogicalVolume *)
void	Read (const G4String &, G4bool validation, G4bool isModule, G4bool strip=true)
void	SetReverseSearch (G4bool flag)
virtual void	SetupRead (const xercesc::DOMElement *const element)
virtual void	SolidsRead (const xercesc::DOMElement *const)
void	StripName (G4String &) const
void	StripNames () const
virtual void	StructureRead (const xercesc::DOMElement *const)=0
virtual void	UserinfoRead (const xercesc::DOMElement *const)
virtual void	Volume_contentRead (const xercesc::DOMElement *const)=0

Protected Member Functions
G4double	AtomRead (const xercesc::DOMElement *const)
G4GDMLAuxStructType	AuxiliaryRead (const xercesc::DOMElement *const auxElem)
void	BooleanRead (const xercesc::DOMElement *const, const BooleanOp)
void	Box_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	BoxRead (const xercesc::DOMElement *const)
G4int	CompositeRead (const xercesc::DOMElement *const, G4String &)
void	Cone_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	ConeRead (const xercesc::DOMElement *const)
void	ConstantRead (const xercesc::DOMElement *const)
void	CutTubeRead (const xercesc::DOMElement *const)
G4double	DRead (const xercesc::DOMElement *const)
void	ElconeRead (const xercesc::DOMElement *const)
void	ElementRead (const xercesc::DOMElement *const)
void	Ellipsoid_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	EllipsoidRead (const xercesc::DOMElement *const)
void	EltubeRead (const xercesc::DOMElement *const)
void	ExpressionRead (const xercesc::DOMElement *const)
G4double	FractionRead (const xercesc::DOMElement *const, G4String &)
	G4GDMLReadParamvol ()
G4String	GenerateName (const G4String &name, G4bool strip=false)
void	GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)
void	GenericPolyconeRead (const xercesc::DOMElement *const)
void	GenericPolyhedraRead (const xercesc::DOMElement *const)
void	GenTrapRead (const xercesc::DOMElement *const)
G4RotationMatrix	GetRotationMatrix (const G4ThreeVector &)
void	Hype_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	HypeRead (const xercesc::DOMElement *const)
void	IsotopeRead (const xercesc::DOMElement *const)
void	LoopRead (const xercesc::DOMElement *const, void(G4GDMLRead::*)(const xercesc::DOMElement *const))
void	MaterialRead (const xercesc::DOMElement *const)
void	MatrixRead (const xercesc::DOMElement *const)
G4double	MEERead (const xercesc::DOMElement *const)
void	MixtureRead (const xercesc::DOMElement *const, G4Element *)
void	MixtureRead (const xercesc::DOMElement *const, G4Material *)
void	MultiUnionNodeRead (const xercesc::DOMElement *const, G4MultiUnion *const)
void	MultiUnionRead (const xercesc::DOMElement *const)
void	OpticalSurfaceRead (const xercesc::DOMElement *const)
void	Orb_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	OrbRead (const xercesc::DOMElement *const)
void	Para_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	ParaboloidRead (const xercesc::DOMElement *const)
void	ParameterisedRead (const xercesc::DOMElement *const)
void	ParametersRead (const xercesc::DOMElement *const)
void	ParaRead (const xercesc::DOMElement *const)
void	Polycone_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	PolyconeRead (const xercesc::DOMElement *const)
void	Polyhedra_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	PolyhedraRead (const xercesc::DOMElement *const)
void	PositionRead (const xercesc::DOMElement *const)
G4double	PRead (const xercesc::DOMElement *const)
void	PropertyRead (const xercesc::DOMElement *const, G4Material *)
void	PropertyRead (const xercesc::DOMElement *const, G4OpticalSurface *)
G4QuadrangularFacet *	QuadrangularRead (const xercesc::DOMElement *const)
void	QuantityRead (const xercesc::DOMElement *const)
void	ReflectedSolidRead (const xercesc::DOMElement *const)
G4String	RefRead (const xercesc::DOMElement *const)
void	RotationRead (const xercesc::DOMElement *const)
rzPointType	RZPointRead (const xercesc::DOMElement *const)
void	ScaledSolidRead (const xercesc::DOMElement *const)
void	ScaleRead (const xercesc::DOMElement *const)
G4ExtrudedSolid::ZSection	SectionRead (const xercesc::DOMElement *const, G4double)
void	Sphere_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	SphereRead (const xercesc::DOMElement *const)
G4String	Strip (const G4String &) const
void	TessellatedRead (const xercesc::DOMElement *const)
void	TetRead (const xercesc::DOMElement *const)
void	Torus_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	TorusRead (const xercesc::DOMElement *const)
G4String	Transcode (const XMLCh *const)
void	Trap_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	TrapRead (const xercesc::DOMElement *const)
void	Trd_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	TrdRead (const xercesc::DOMElement *const)
G4double	TRead (const xercesc::DOMElement *const)
G4TriangularFacet *	TriangularRead (const xercesc::DOMElement *const)
void	Tube_dimensionsRead (const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
void	TubeRead (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)
G4TwoVector	TwoDimVertexRead (const xercesc::DOMElement *const, G4double)
void	VariableRead (const xercesc::DOMElement *const)
void	VectorRead (const xercesc::DOMElement *const, G4ThreeVector &)
void	XtruRead (const xercesc::DOMElement *const)
zplaneType	ZplaneRead (const xercesc::DOMElement *const)
virtual	~G4GDMLReadParamvol ()

Protected Attributes
G4bool	check = false
G4bool	dostrip = true
G4GDMLEvaluator	eval
std::map< G4String, G4GDMLMatrix >	matrixMap
G4GDMLParameterisation *	parameterisation = nullptr
std::map< G4String, G4ThreeVector >	positionMap
std::map< G4String, G4double >	quantityMap
G4bool	reverseSearch = false
std::map< G4String, G4ThreeVector >	rotationMap
std::map< G4String, G4ThreeVector >	scaleMap
std::map< G4String, G4String >	setupMap
G4bool	validate = true

Private Types
enum	BooleanOp { UNION , SUBTRACTION , INTERSECTION }

Private Attributes
G4GDMLAuxListType	auxGlobalList
G4int	inLoop = 0
G4int	loopCount = 0
std::map< G4String, G4MaterialPropertyVector * >	mapOfMatPropVects

Detailed Description

Definition at line 42 of file G4GDMLReadParamvol.hh.

Member Enumeration Documentation

BooleanOp

enum G4GDMLReadSolids::BooleanOp

privateinherited

Enumerator
UNION
SUBTRACTION
INTERSECTION

Definition at line 51 of file G4GDMLReadSolids.hh.

  {
    UNION,
    SUBTRACTION,
    INTERSECTION
  };

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

AtomRead()

G4double G4GDMLReadMaterials::AtomRead ( const xercesc::DOMElement * const  atomElement )

protectedinherited

Definition at line 53 of file G4GDMLReadMaterials.cc.

{
  G4double value = 0.0;
  G4double unit  = g / mole;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    atomElement->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("G4GDMLReadMaterials::AtomRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return value;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Molar mass")
      {
        G4Exception("G4GDMLReadMaterials::AtomRead()", "InvalidRead",
                    FatalException, "Invalid unit for atomic mass!");
      }
    }
  }
 
  return value * unit;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, g, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), mole, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadMaterials::ElementRead(), G4GDMLReadMaterials::IsotopeRead(), and G4GDMLReadMaterials::MaterialRead().

AuxiliaryRead()

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

protectedinherited

Definition at line 295 of file G4GDMLRead.cc.

{
  G4GDMLAuxStructType auxstruct = { "", "", "", 0 };
  G4GDMLAuxListType* auxList    = nullptr;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    auxiliaryElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
 
  for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
      ++attribute_index)
  {
    xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 
    if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(attribute_node);
    if(!attribute)
    {
      G4Exception("G4GDMLRead::AuxiliaryRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return auxstruct;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "auxtype")
    {
      auxstruct.type = attValue;
    }
    else if(attName == "auxvalue")
    {
      auxstruct.value = attValue;
    }
    else if(attName == "auxunit")
    {
      auxstruct.unit = attValue;
    }
  }
 
  for(xercesc::DOMNode* iter = auxiliaryElement->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)
    {
      G4Exception("G4GDMLRead::AuxiliaryRead()", "InvalidRead", FatalException,
                  "No child found!");
      break;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "auxiliary")
    {
      if(!auxList)
      {
        auxList = new G4GDMLAuxListType;
      }
      auxList->push_back(AuxiliaryRead(child));
    }
  }
 
  if(auxList)
  {
    auxstruct.auxList = auxList;
  }
 
  return auxstruct;
}

References G4GDMLRead::AuxiliaryRead(), G4GDMLAuxStructType::auxList, FatalException, G4Exception(), G4GDMLRead::Transcode(), G4GDMLAuxStructType::type, G4GDMLAuxStructType::unit, and G4GDMLAuxStructType::value.

Referenced by G4GDMLRead::AuxiliaryRead(), G4GDMLRead::UserinfoRead(), and G4GDMLReadStructure::VolumeRead().

BooleanRead()

void G4GDMLReadSolids::BooleanRead ( const xercesc::DOMElement * const  booleanElement, const BooleanOp  op  )

protectedinherited

Definition at line 82 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4String first;
  G4String scnd;
  G4ThreeVector position(0.0, 0.0, 0.0);
  G4ThreeVector rotation(0.0, 0.0, 0.0);
  G4ThreeVector firstposition(0.0, 0.0, 0.0);
  G4ThreeVector firstrotation(0.0, 0.0, 0.0);
 
  const xercesc::DOMNamedNodeMap* const attributes =
    booleanElement->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("G4GDMLReadSolids::BooleanRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "name")
    {
      name = GenerateName(attValue);
    }
  }
 
  for(xercesc::DOMNode* iter = booleanElement->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("G4GDMLReadSolids::BooleanRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "first")
    {
      first = RefRead(child);
    }
    else if(tag == "second")
    {
      scnd = RefRead(child);
    }
    else 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 == "firstposition")
    {
      VectorRead(child, firstposition);
    }
    else if(tag == "firstrotation")
    {
      VectorRead(child, firstrotation);
    }
    else if(tag == "firstpositionref")
    {
      firstposition = GetPosition(GenerateName(RefRead(child)));
    }
    else if(tag == "firstrotationref")
    {
      firstrotation = GetRotation(GenerateName(RefRead(child)));
    }
    else
    {
      G4String error_msg = "Unknown tag in boolean solid: " + tag;
      G4Exception("G4GDMLReadSolids::BooleanRead()", "ReadError",
                  FatalException, error_msg);
    }
  }
 
  G4VSolid* firstSolid  = GetSolid(GenerateName(first));
  G4VSolid* secondSolid = GetSolid(GenerateName(scnd));
 
  G4Transform3D transform(GetRotationMatrix(rotation), position);
 
  if(((firstrotation.x() != 0.0) || (firstrotation.y() != 0.0) ||
      (firstrotation.z() != 0.0)) ||
     ((firstposition.x() != 0.0) || (firstposition.y() != 0.0) ||
      (firstposition.z() != 0.0)))
  {
    G4Transform3D firsttransform(GetRotationMatrix(firstrotation),
                                 firstposition);
    firstSolid = new G4DisplacedSolid(GenerateName("displaced_" + first),
                                      firstSolid, firsttransform);
  }
 
  if(op == UNION)
  {
    new G4UnionSolid(name, firstSolid, secondSolid, transform);
  }
  else if(op == SUBTRACTION)
  {
    new G4SubtractionSolid(name, firstSolid, secondSolid, transform);
  }
  else if(op == INTERSECTION)
  {
    new G4IntersectionSolid(name, firstSolid, secondSolid, transform);
  }
}

References FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadDefine::GetPosition(), G4GDMLReadDefine::GetRotation(), G4GDMLReadDefine::GetRotationMatrix(), G4GDMLReadSolids::GetSolid(), G4GDMLReadSolids::INTERSECTION, G4InuclParticleNames::name(), position, G4GDMLReadDefine::RefRead(), G4GDMLReadSolids::SUBTRACTION, G4GDMLRead::Transcode(), G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform(), G4GDMLReadSolids::UNION, G4GDMLReadDefine::VectorRead(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GDMLReadSolids::SolidsRead().

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

BoxRead()

void G4GDMLReadSolids::BoxRead ( const xercesc::DOMElement * const  boxElement )

protectedinherited

Definition at line 221 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double x     = 0.0;
  G4double y     = 0.0;
  G4double z     = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    boxElement->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("G4GDMLReadSolids::BoxRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::BoxRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "x")
    {
      x = eval.Evaluate(attValue);
    }
    else if(attName == "y")
    {
      y = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
  }
 
  x *= 0.5 * lunit;
  y *= 0.5 * lunit;
  z *= 0.5 * lunit;
 
  new G4Box(name, x, y, z);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

CompositeRead()

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

protectedinherited

Definition at line 103 of file G4GDMLReadMaterials.cc.

{
  G4int n = 0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    compositeElement->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("G4GDMLReadMaterials::CompositeRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return n;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "n")
    {
      n = eval.EvaluateInteger(attValue);
    }
    else if(attName == "ref")
    {
      ref = attValue;
    }
  }
 
  return n;
}

References G4GDMLRead::eval, G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), CLHEP::detail::n, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadMaterials::MixtureRead().

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

ConeRead()

void G4GDMLReadSolids::ConeRead ( const xercesc::DOMElement * const  coneElement )

protectedinherited

Definition at line 289 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double rmin1    = 0.0;
  G4double rmax1    = 0.0;
  G4double rmin2    = 0.0;
  G4double rmax2    = 0.0;
  G4double z        = 0.0;
  G4double startphi = 0.0;
  G4double deltaphi = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    coneElement->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("G4GDMLReadSolids::ConeRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::ConeRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::ConeRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "rmin1")
    {
      rmin1 = eval.Evaluate(attValue);
    }
    else if(attName == "rmax1")
    {
      rmax1 = eval.Evaluate(attValue);
    }
    else if(attName == "rmin2")
    {
      rmin2 = eval.Evaluate(attValue);
    }
    else if(attName == "rmax2")
    {
      rmax2 = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
    else if(attName == "startphi")
    {
      startphi = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      deltaphi = eval.Evaluate(attValue);
    }
  }
 
  rmin1 *= lunit;
  rmax1 *= lunit;
  rmin2 *= lunit;
  rmax2 *= lunit;
  z *= 0.5 * lunit;
  startphi *= aunit;
  deltaphi *= aunit;
 
  new G4Cons(name, rmin1, rmax1, rmin2, rmax2, z, startphi, deltaphi);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

ConstantRead()

void G4GDMLReadDefine::ConstantRead ( const xercesc::DOMElement * const  constantElement )

protectedinherited

Definition at line 167 of file G4GDMLReadDefine.cc.

{
  G4String name  = "";
  G4double value = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    constantElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
 
  for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
      ++attribute_index)
  {
    xercesc::DOMNode* node = attributes->item(attribute_index);
 
    if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(node);
    if(attribute == nullptr)
    {
      G4Exception("G4GDMLRead::ConstantRead()", "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 == "value")
    {
      value = eval.Evaluate(attValue);
    }
  }
 
  eval.DefineConstant(name, value);
}

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

Referenced by G4GDMLReadDefine::DefineRead().

CutTubeRead()

void G4GDMLReadSolids::CutTubeRead ( const xercesc::DOMElement * const  cuttubeElement )

protectedinherited

Definition at line 2782 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double rmin     = 0.0;
  G4double rmax     = 0.0;
  G4double z        = 0.0;
  G4double startphi = 0.0;
  G4double deltaphi = 0.0;
  G4ThreeVector lowNorm(0);
  G4ThreeVector highNorm(0);
 
  const xercesc::DOMNamedNodeMap* const attributes =
    cuttubeElement->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("G4GDMLReadSolids::CutTubeRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::CutTubeRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::CutTubeRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "rmin")
    {
      rmin = eval.Evaluate(attValue);
    }
    else if(attName == "rmax")
    {
      rmax = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
    else if(attName == "startphi")
    {
      startphi = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      deltaphi = eval.Evaluate(attValue);
    }
    else if(attName == "lowX")
    {
      lowNorm.setX(eval.Evaluate(attValue));
    }
    else if(attName == "lowY")
    {
      lowNorm.setY(eval.Evaluate(attValue));
    }
    else if(attName == "lowZ")
    {
      lowNorm.setZ(eval.Evaluate(attValue));
    }
    else if(attName == "highX")
    {
      highNorm.setX(eval.Evaluate(attValue));
    }
    else if(attName == "highY")
    {
      highNorm.setY(eval.Evaluate(attValue));
    }
    else if(attName == "highZ")
    {
      highNorm.setZ(eval.Evaluate(attValue));
    }
  }
 
  rmin *= lunit;
  rmax *= lunit;
  z *= 0.5 * lunit;
  startphi *= aunit;
  deltaphi *= aunit;
 
  new G4CutTubs(name, rmin, rmax, z, startphi, deltaphi, lowNorm, highNorm);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

DefineRead()

void G4GDMLReadDefine::DefineRead ( const xercesc::DOMElement * const  defineElement )

virtualinherited

Implements G4GDMLRead.

Definition at line 596 of file G4GDMLReadDefine.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Reading definitions..." << G4endl;
#endif
  for(xercesc::DOMNode* iter = defineElement->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("G4GDMLRead::DefineRead()", "InvalidRead", FatalException,
                  "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "constant")
    {
      ConstantRead(child);
    }
    else if(tag == "matrix")
    {
      MatrixRead(child);
    }
    else if(tag == "position")
    {
      PositionRead(child);
    }
    else if(tag == "rotation")
    {
      RotationRead(child);
    }
    else if(tag == "scale")
    {
      ScaleRead(child);
    }
    else if(tag == "variable")
    {
      VariableRead(child);
    }
    else if(tag == "quantity")
    {
      QuantityRead(child);
    }
    else if(tag == "expression")
    {
      ExpressionRead(child);
    }
    else
    {
      G4String error_msg = "Unknown tag in define: " + tag;
      G4Exception("G4GDMLReadDefine::defineRead()", "ReadError", FatalException,
                  error_msg);
    }
  }
}

References G4GDMLReadDefine::ConstantRead(), G4GDMLReadDefine::ExpressionRead(), FatalException, G4cout, G4endl, G4Exception(), G4GDMLReadDefine::MatrixRead(), G4GDMLReadDefine::PositionRead(), G4GDMLReadDefine::QuantityRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadDefine::ScaleRead(), G4GDMLRead::Transcode(), and G4GDMLReadDefine::VariableRead().

Referenced by G4GDMLReadMaterials::MaterialsRead(), and G4GDMLReadSolids::SolidsRead().

DRead()

G4double G4GDMLReadMaterials::DRead ( const xercesc::DOMElement * const  DElement )

protectedinherited

Definition at line 147 of file G4GDMLReadMaterials.cc.

{
  G4double value = 0.0;
  G4double unit  = g / cm3;
 
  const xercesc::DOMNamedNodeMap* const attributes = DElement->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("G4GDMLReadMaterials::DRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return value;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Volumic Mass")
      {
        G4Exception("G4GDMLReadMaterials::DRead()", "InvalidRead",
                    FatalException, "Invalid unit for density!");
      }
    }
  }
 
  return value * unit;
}

References cm3, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, g, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadMaterials::MaterialRead().

ElconeRead()

void G4GDMLReadSolids::ElconeRead ( const xercesc::DOMElement * const  elconeElement )

protectedinherited

Definition at line 391 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double dx    = 0.0;
  G4double dy    = 0.0;
  G4double zmax  = 0.0;
  G4double zcut  = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    elconeElement->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("G4GDMLReadSolids::ElconeRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::ElconeRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "dx")
    {
      dx = eval.Evaluate(attValue);
    }
    else if(attName == "dy")
    {
      dy = eval.Evaluate(attValue);
    }
    else if(attName == "zmax")
    {
      zmax = eval.Evaluate(attValue);
    }
    else if(attName == "zcut")
    {
      zcut = eval.Evaluate(attValue);
    }
  }
 
  zmax *= lunit;
  zcut *= lunit;
 
  new G4EllipticalCone(name, dx, dy, zmax, zcut);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

ElementRead()

void G4GDMLReadMaterials::ElementRead ( const xercesc::DOMElement * const  elementElement )

protectedinherited

Definition at line 339 of file G4GDMLReadMaterials.cc.

{
  G4String name;
  G4String formula;
  G4double a = 0.0;
  G4double Z = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    elementElement->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("G4GDMLReadMaterials::ElementRead()", "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 == "formula")
    {
      formula = attValue;
    }
    else if(attName == "Z")
    {
      Z = eval.Evaluate(attValue);
    }
  }
 
  G4int nComponents = 0;
 
  for(xercesc::DOMNode* iter = elementElement->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("G4GDMLReadMaterials::ElementRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "atom")
    {
      a = AtomRead(child);
    }
    else if(tag == "fraction")
    {
      nComponents++;
    }
  }
 
  if(nComponents > 0)
  {
    MixtureRead(elementElement,
                new G4Element(Strip(name), formula, nComponents));
  }
  else
  {
    new G4Element(Strip(name), formula, Z, a);
  }
}

References G4GDMLReadMaterials::AtomRead(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadMaterials::MixtureRead(), G4InuclParticleNames::name(), G4GDMLRead::Strip(), G4GDMLRead::Transcode(), and Z.

Referenced by G4GDMLReadMaterials::MaterialsRead().

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

EllipsoidRead()

void G4GDMLReadSolids::EllipsoidRead ( const xercesc::DOMElement * const  ellipsoidElement )

protectedinherited

Definition at line 464 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double ax    = 0.0;
  G4double by    = 0.0;
  G4double cz    = 0.0;
  G4double zcut1 = 0.0;
  G4double zcut2 = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    ellipsoidElement->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("G4GDMLReadSolids::EllipsoidRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::EllipsoidRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "ax")
    {
      ax = eval.Evaluate(attValue);
    }
    else if(attName == "by")
    {
      by = eval.Evaluate(attValue);
    }
    else if(attName == "cz")
    {
      cz = eval.Evaluate(attValue);
    }
    else if(attName == "zcut1")
    {
      zcut1 = eval.Evaluate(attValue);
    }
    else if(attName == "zcut2")
    {
      zcut2 = eval.Evaluate(attValue);
    }
  }
 
  ax *= lunit;
  by *= lunit;
  cz *= lunit;
  zcut1 *= lunit;
  zcut2 *= lunit;
 
  new G4Ellipsoid(name, ax, by, cz, zcut1, zcut2);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

EltubeRead()

void G4GDMLReadSolids::EltubeRead ( const xercesc::DOMElement * const  eltubeElement )

protectedinherited

Definition at line 545 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double dx    = 0.0;
  G4double dy    = 0.0;
  G4double dz    = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    eltubeElement->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("G4GDMLReadSolids::EltubeRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::EltubeRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "dx")
    {
      dx = eval.Evaluate(attValue);
    }
    else if(attName == "dy")
    {
      dy = eval.Evaluate(attValue);
    }
    else if(attName == "dz")
    {
      dz = eval.Evaluate(attValue);
    }
  }
 
  dx *= lunit;
  dy *= lunit;
  dz *= lunit;
 
  new G4EllipticalTube(name, dx, dy, dz);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

ExpressionRead()

void G4GDMLReadDefine::ExpressionRead ( const xercesc::DOMElement * const  expElement )

protectedinherited

Definition at line 212 of file G4GDMLReadDefine.cc.

{
  G4String name  = "";
  G4double value = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    expElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
 
  for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
      ++attribute_index)
  {
    xercesc::DOMNode* node = attributes->item(attribute_index);
 
    if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(node);
    if(attribute == nullptr)
    {
      G4Exception("G4GDMLRead::ExpressionRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "name")
    {
      name = attValue;
    }
  }
 
  const G4String expValue = Transcode(expElement->getTextContent());
  value                   = eval.Evaluate(expValue);
  eval.DefineConstant(name, value);
}

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

Referenced by G4GDMLReadDefine::DefineRead().

ExtensionRead()

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

virtualinherited

Definition at line 414 of file G4GDMLRead.cc.

{
  G4String error_msg = "No handle to user-code for parsing extensions!";
  G4Exception("G4GDMLRead::ExtensionRead()", "NotImplemented", JustWarning,
              error_msg);
}

References G4Exception(), and JustWarning.

Referenced by G4GDMLRead::Read().

FractionRead()

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

protectedinherited

Definition at line 428 of file G4GDMLReadMaterials.cc.

{
  G4double n = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    fractionElement->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("G4GDMLReadMaterials::FractionRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return n;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "n")
    {
      n = eval.Evaluate(attValue);
    }
    else if(attName == "ref")
    {
      ref = attValue;
    }
  }
 
  return n;
}

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

Referenced by G4GDMLReadMaterials::MixtureRead().

GenerateName()

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

protectedinherited

Definition at line 70 of file G4GDMLRead.cc.

{
  G4String nameOut(nameIn);
 
  if(inLoop > 0)
  {
    nameOut = eval.SolveBrackets(nameOut);
  }
  if(strip)
  {
    StripName(nameOut);
  }
 
  return nameOut;
}

References G4GDMLRead::eval, G4GDMLRead::inLoop, G4GDMLEvaluator::SolveBrackets(), G4StrUtil::strip(), and G4GDMLRead::StripName().

Referenced by G4GDMLReadStructure::AssemblyRead(), G4GDMLReadSolids::BooleanRead(), G4GDMLReadStructure::BorderSurfaceRead(), G4GDMLReadSolids::BoxRead(), G4GDMLReadSolids::ConeRead(), G4GDMLReadSolids::CutTubeRead(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadSolids::ElconeRead(), G4GDMLReadMaterials::ElementRead(), G4GDMLReadSolids::EllipsoidRead(), G4GDMLReadSolids::EltubeRead(), G4GDMLReadStructure::FileRead(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), G4GDMLReadStructure::GetWorldVolume(), G4GDMLReadSolids::HypeRead(), G4GDMLReadMaterials::IsotopeRead(), G4GDMLReadMaterials::MaterialRead(), G4GDMLReadDefine::MatrixRead(), G4GDMLReadMaterials::MixtureRead(), G4GDMLReadSolids::MultiUnionNodeRead(), G4GDMLReadSolids::MultiUnionRead(), G4GDMLReadSolids::OpticalSurfaceRead(), G4GDMLReadSolids::OrbRead(), G4GDMLReadSolids::ParaboloidRead(), ParametersRead(), ParamvolRead(), G4GDMLReadSolids::ParaRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadSolids::PolyconeRead(), G4GDMLReadSolids::PolyhedraRead(), G4GDMLReadDefine::PositionRead(), G4GDMLReadMaterials::PropertyRead(), G4GDMLReadSolids::PropertyRead(), G4GDMLReadSolids::QuadrangularRead(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadStructure::ReplicaRead(), G4GDMLReadStructure::ReplicavolRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadSolids::ScaledSolidRead(), G4GDMLReadDefine::ScaleRead(), G4GDMLReadSetup::SetupRead(), G4GDMLReadStructure::SkinSurfaceRead(), G4GDMLReadSolids::SphereRead(), G4GDMLReadSolids::TessellatedRead(), G4GDMLReadSolids::TetRead(), G4GDMLReadSolids::TorusRead(), G4GDMLReadSolids::TrapRead(), G4GDMLReadSolids::TrdRead(), G4GDMLReadSolids::TriangularRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), G4GDMLReadStructure::VolumeRead(), and G4GDMLReadSolids::XtruRead().

GeneratePhysvolName()

void G4GDMLRead::GeneratePhysvolName ( const G4String &  nameIn, G4VPhysicalVolume *  physvol  )

protectedinherited

Definition at line 87 of file G4GDMLRead.cc.

{
  G4String nameOut(nameIn);
 
  if(nameIn.empty())
  {
    std::stringstream stream;
    stream << physvol->GetLogicalVolume()->GetName() << "_PV";
    nameOut = stream.str();
  }
  nameOut = eval.SolveBrackets(nameOut);
 
  physvol->SetName(nameOut);
}

References G4GDMLRead::eval, G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4VPhysicalVolume::SetName(), and G4GDMLEvaluator::SolveBrackets().

Referenced by G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadStructure::PhysvolRead(), and G4GDMLReadStructure::ReplicaRead().

GenericPolyconeRead()

void G4GDMLReadSolids::GenericPolyconeRead ( const xercesc::DOMElement * const  polyconeElement )

protectedinherited

Definition at line 1284 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double startphi = 0.0;
  G4double deltaphi = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    polyconeElement->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("G4GDMLReadSolids::GenericPolyconeRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "startphi")
    {
      startphi = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      deltaphi = eval.Evaluate(attValue);
    }
  }
 
  startphi *= aunit;
  deltaphi *= aunit;
 
  std::vector<rzPointType> rzPointList;
 
  for(xercesc::DOMNode* iter = polyconeElement->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("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "rzpoint")
    {
      rzPointList.push_back(RZPointRead(child));
    }
  }
 
  G4int numRZPoints = rzPointList.size();
 
  G4double* r_array = new G4double[numRZPoints];
  G4double* z_array = new G4double[numRZPoints];
 
  for(G4int i = 0; i < numRZPoints; ++i)
  {
    r_array[i] = rzPointList[i].r * lunit;
    z_array[i] = rzPointList[i].z * lunit;
  }
  new G4GenericPolycone(name, startphi, deltaphi, numRZPoints, r_array,
                        z_array);
  delete[] r_array;
  delete[] z_array;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), G4GDMLReadSolids::RZPointRead(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

GenericPolyhedraRead()

void G4GDMLReadSolids::GenericPolyhedraRead ( const xercesc::DOMElement * const  polyhedraElement )

protectedinherited

Definition at line 1518 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double startphi = 0.0;
  G4double deltaphi = 0.0;
  G4int numsides    = 0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    polyhedraElement->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("G4GDMLReadSolids::GenericPolyhedraRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "startphi")
    {
      startphi = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      deltaphi = eval.Evaluate(attValue);
    }
    else if(attName == "numsides")
    {
      numsides = eval.EvaluateInteger(attValue);
    }
  }
 
  startphi *= aunit;
  deltaphi *= aunit;
 
  std::vector<rzPointType> rzpointList;
 
  for(xercesc::DOMNode* iter = polyhedraElement->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("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "rzpoint")
    {
      rzpointList.push_back(RZPointRead(child));
    }
  }
 
  G4int numRZPoints = rzpointList.size();
 
  G4double* r_array = new G4double[numRZPoints];
  G4double* z_array = new G4double[numRZPoints];
 
  for(G4int i = 0; i < numRZPoints; ++i)
  {
    r_array[i] = rzpointList[i].r * lunit;
    z_array[i] = rzpointList[i].z * lunit;
  }
 
  new G4Polyhedra(name, startphi, deltaphi, numsides, numRZPoints, r_array,
                  z_array);
 
  delete[] r_array;
  delete[] z_array;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), G4GDMLReadSolids::RZPointRead(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

GenTrapRead()

void G4GDMLReadSolids::GenTrapRead ( const xercesc::DOMElement * const  gtrapElement )

protectedinherited

Definition at line 2285 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double dz    = 0.0;
  G4double v1x = 0.0, v1y = 0.0, v2x = 0.0, v2y = 0.0, v3x = 0.0, v3y = 0.0,
           v4x = 0.0, v4y = 0.0, v5x = 0.0, v5y = 0.0, v6x = 0.0, v6y = 0.0,
           v7x = 0.0, v7y = 0.0, v8x = 0.0, v8y = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    gtrapElement->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("G4GDMLReadSolids::GenTrapRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::GenTrapRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "dz")
    {
      dz = eval.Evaluate(attValue);
    }
    else if(attName == "v1x")
    {
      v1x = eval.Evaluate(attValue);
    }
    else if(attName == "v1y")
    {
      v1y = eval.Evaluate(attValue);
    }
    else if(attName == "v2x")
    {
      v2x = eval.Evaluate(attValue);
    }
    else if(attName == "v2y")
    {
      v2y = eval.Evaluate(attValue);
    }
    else if(attName == "v3x")
    {
      v3x = eval.Evaluate(attValue);
    }
    else if(attName == "v3y")
    {
      v3y = eval.Evaluate(attValue);
    }
    else if(attName == "v4x")
    {
      v4x = eval.Evaluate(attValue);
    }
    else if(attName == "v4y")
    {
      v4y = eval.Evaluate(attValue);
    }
    else if(attName == "v5x")
    {
      v5x = eval.Evaluate(attValue);
    }
    else if(attName == "v5y")
    {
      v5y = eval.Evaluate(attValue);
    }
    else if(attName == "v6x")
    {
      v6x = eval.Evaluate(attValue);
    }
    else if(attName == "v6y")
    {
      v6y = eval.Evaluate(attValue);
    }
    else if(attName == "v7x")
    {
      v7x = eval.Evaluate(attValue);
    }
    else if(attName == "v7y")
    {
      v7y = eval.Evaluate(attValue);
    }
    else if(attName == "v8x")
    {
      v8x = eval.Evaluate(attValue);
    }
    else if(attName == "v8y")
    {
      v8y = eval.Evaluate(attValue);
    }
  }
 
  dz *= lunit;
  std::vector<G4TwoVector> vertices;
  vertices.push_back(G4TwoVector(v1x * lunit, v1y * lunit));
  vertices.push_back(G4TwoVector(v2x * lunit, v2y * lunit));
  vertices.push_back(G4TwoVector(v3x * lunit, v3y * lunit));
  vertices.push_back(G4TwoVector(v4x * lunit, v4y * lunit));
  vertices.push_back(G4TwoVector(v5x * lunit, v5y * lunit));
  vertices.push_back(G4TwoVector(v6x * lunit, v6y * lunit));
  vertices.push_back(G4TwoVector(v7x * lunit, v7y * lunit));
  vertices.push_back(G4TwoVector(v8x * lunit, v8y * lunit));
  new G4GenericTrap(name, dz, vertices);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

GetAuxList()

const G4GDMLAuxListType * G4GDMLRead::GetAuxList ( ) const

inherited

Definition at line 563 of file G4GDMLRead.cc.

{
  return &auxGlobalList;
}

References G4GDMLRead::auxGlobalList.

GetConstant()

G4double G4GDMLReadDefine::GetConstant ( const G4String &  ref )

inherited

Definition at line 758 of file G4GDMLReadDefine.cc.

{
  return eval.GetConstant(ref);
}

References G4GDMLRead::eval, and G4GDMLEvaluator::GetConstant().

GetElement()

G4Element * G4GDMLReadMaterials::GetElement ( const G4String &  ref, G4bool  verbose = true  ) const

inherited

Definition at line 932 of file G4GDMLReadMaterials.cc.

{
  G4Element* elementPtr = G4Element::GetElement(ref, false);
 
  if(elementPtr == nullptr)
  {
    elementPtr = G4NistManager::Instance()->FindOrBuildElement(ref);
  }
 
  if(verbose && elementPtr == nullptr)
  {
    G4String error_msg = "Referenced element '" + ref + "' was not found!";
    G4Exception("G4GDMLReadMaterials::GetElement()", "InvalidRead",
                FatalException, error_msg);
  }
 
  return elementPtr;
}

References FatalException, G4NistManager::FindOrBuildElement(), G4Exception(), G4Element::GetElement(), and G4NistManager::Instance().

Referenced by G4GDMLReadMaterials::MixtureRead().

GetIsotope()

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

inherited

Definition at line 953 of file G4GDMLReadMaterials.cc.

{
  G4Isotope* isotopePtr = G4Isotope::GetIsotope(ref, false);
 
  if(verbose && isotopePtr == nullptr)
  {
    G4String error_msg = "Referenced isotope '" + ref + "' was not found!";
    G4Exception("G4GDMLReadMaterials::GetIsotope()", "InvalidRead",
                FatalException, error_msg);
  }
 
  return isotopePtr;
}

References FatalException, G4Exception(), and G4Isotope::GetIsotope().

Referenced by G4GDMLReadMaterials::MixtureRead().

GetMaterial()

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

inherited

Definition at line 969 of file G4GDMLReadMaterials.cc.

{
  G4Material* materialPtr = G4Material::GetMaterial(ref, false);
 
  if(materialPtr == nullptr)
  {
    materialPtr = G4NistManager::Instance()->FindOrBuildMaterial(ref);
  }
 
  if(verbose && materialPtr == nullptr)
  {
    G4String error_msg = "Referenced material '" + ref + "' was not found!";
    G4Exception("G4GDMLReadMaterials::GetMaterial()", "InvalidRead",
                FatalException, error_msg);
  }
 
  return materialPtr;
}

References FatalException, G4NistManager::FindOrBuildMaterial(), G4Exception(), G4Material::GetMaterial(), and G4NistManager::Instance().

Referenced by G4GDMLReadMaterials::MixtureRead(), and G4GDMLReadStructure::VolumeRead().

GetMatrix()

G4GDMLMatrix G4GDMLReadDefine::GetMatrix ( const G4String &  ref )

inherited

Definition at line 818 of file G4GDMLReadDefine.cc.

{
  if(matrixMap.find(ref) == matrixMap.end())
  {
    G4String error_msg = "Matrix '" + ref + "' was not found!";
    G4Exception("G4GDMLReadDefine::getMatrix()", "ReadError", FatalException,
                error_msg);
  }
  return matrixMap[ref];
}

References FatalException, G4Exception(), and G4GDMLReadDefine::matrixMap.

Referenced by G4GDMLReadMaterials::PropertyRead(), and G4GDMLReadSolids::PropertyRead().

GetPosition()

G4ThreeVector G4GDMLReadDefine::GetPosition ( const G4String &  ref )

inherited

Definition at line 782 of file G4GDMLReadDefine.cc.

{
  if(positionMap.find(ref) == positionMap.cend())
  {
    G4String error_msg = "Position '" + ref + "' was not found!";
    G4Exception("G4GDMLReadDefine::getPosition()", "ReadError", FatalException,
                error_msg);
  }
  return positionMap[ref];
}

References FatalException, G4Exception(), and G4GDMLReadDefine::positionMap.

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadSolids::MultiUnionNodeRead(), ParametersRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadSolids::QuadrangularRead(), G4GDMLReadStructure::ReplicaRead(), G4GDMLReadSolids::TetRead(), and G4GDMLReadSolids::TriangularRead().

GetQuantity()

G4double G4GDMLReadDefine::GetQuantity ( const G4String &  ref )

inherited

Definition at line 770 of file G4GDMLReadDefine.cc.

{
  if(quantityMap.find(ref) == quantityMap.cend())
  {
    G4String error_msg = "Quantity '" + ref + "' was not found!";
    G4Exception("G4GDMLReadDefine::getQuantity()", "ReadError", FatalException,
                error_msg);
  }
  return quantityMap[ref];
}

References FatalException, G4Exception(), and G4GDMLReadDefine::quantityMap.

Referenced by G4GDMLReadMaterials::MaterialRead().

GetRotation()

G4ThreeVector G4GDMLReadDefine::GetRotation ( const G4String &  ref )

inherited

Definition at line 794 of file G4GDMLReadDefine.cc.

{
  if(rotationMap.find(ref) == rotationMap.cend())
  {
    G4String error_msg = "Rotation '" + ref + "' was not found!";
    G4Exception("G4GDMLReadDefine::getRotation()", "ReadError", FatalException,
                error_msg);
  }
  return rotationMap[ref];
}

References FatalException, G4Exception(), and G4GDMLReadDefine::rotationMap.

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadSolids::MultiUnionNodeRead(), ParametersRead(), G4GDMLReadStructure::PhysvolRead(), and G4GDMLReadStructure::ReplicaRead().

GetRotationMatrix()

G4RotationMatrix G4GDMLReadDefine::GetRotationMatrix ( const G4ThreeVector &  angles )

protectedinherited

Definition at line 153 of file G4GDMLReadDefine.cc.

{
  G4RotationMatrix rot;
 
  rot.rotateX(angles.x());
  rot.rotateY(angles.y());
  rot.rotateZ(angles.z());
  rot.rectify();  // Rectify matrix from possible roundoff errors
 
  return rot;
}

References CLHEP::HepRotation::rectify(), CLHEP::HepRotation::rotateX(), CLHEP::HepRotation::rotateY(), CLHEP::HepRotation::rotateZ(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadSolids::MultiUnionNodeRead(), G4GDMLReadStructure::PhysvolRead(), and G4GDMLReadSolids::ReflectedSolidRead().

GetScale()

G4ThreeVector G4GDMLReadDefine::GetScale ( const G4String &  ref )

inherited

Definition at line 806 of file G4GDMLReadDefine.cc.

{
  if(scaleMap.find(ref) == scaleMap.end())
  {
    G4String error_msg = "Scale '" + ref + "' was not found!";
    G4Exception("G4GDMLReadDefine::getScale()", "ReadError", FatalException,
                error_msg);
  }
  return scaleMap[ref];
}

References FatalException, G4Exception(), and G4GDMLReadDefine::scaleMap.

Referenced by G4GDMLReadStructure::PhysvolRead(), and G4GDMLReadSolids::ScaledSolidRead().

GetSetup()

G4String G4GDMLReadSetup::GetSetup ( const G4String &  ref )

virtualinherited

Implements G4GDMLRead.

Definition at line 45 of file G4GDMLReadSetup.cc.

{
  if(setupMap.size() == 1)  // If there is only one setup defined,
  {                         // no matter how it is named
    return setupMap.cbegin()->second;
  }
 
  if(setupMap.find(ref) == setupMap.cend())
  {
#ifdef G4VERBOSE
    std::ostringstream message;
    message << "Referenced setup '" << ref << "' was not found!";
    G4Exception("G4GDMLReadSetup::getSetup()", "NullSetup", JustWarning,
                message, "Returning NULL pointer!");
#endif
    return "";
  }
 
  return setupMap[ref];
}

References G4Exception(), JustWarning, and G4GDMLReadSetup::setupMap.

Referenced by G4GDMLReadStructure::FileRead(), and G4GDMLReadStructure::GetWorldVolume().

GetSolid()

G4VSolid * G4GDMLReadSolids::GetSolid ( const G4String &  ref ) const

inherited

Definition at line 4057 of file G4GDMLReadSolids.cc.

{
  G4VSolid* solidPtr = G4SolidStore::GetInstance()
                                    ->GetSolid(ref,false,reverseSearch);
 
  if(solidPtr == nullptr)
  {
    G4String error_msg = "Referenced solid '" + ref + "' was not found!";
    G4Exception("G4GDMLReadSolids::GetSolid()", "ReadError", FatalException,
                error_msg);
  }
 
  return solidPtr;
}

References FatalException, G4Exception(), G4SolidStore::GetInstance(), G4SolidStore::GetSolid(), and G4GDMLReadDefine::reverseSearch.

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadSolids::MultiUnionNodeRead(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadSolids::ScaledSolidRead(), and G4GDMLReadStructure::VolumeRead().

GetSurfaceProperty()

G4SurfaceProperty * G4GDMLReadSolids::GetSurfaceProperty ( const G4String &  ref ) const

inherited

Definition at line 4073 of file G4GDMLReadSolids.cc.

{
  const G4SurfacePropertyTable* surfaceList =
    G4SurfaceProperty::GetSurfacePropertyTable();
  const std::size_t surfaceCount = surfaceList->size();
 
  for(std::size_t i = 0; i < surfaceCount; ++i)
  {
    if((*surfaceList)[i]->GetName() == ref)
    {
      return (*surfaceList)[i];
    }
  }
 
  G4String error_msg =
    "Referenced optical surface '" + ref + "' was not found!";
  G4Exception("G4GDMLReadSolids::GetSurfaceProperty()", "ReadError",
              FatalException, error_msg);
 
  return nullptr;
}

References FatalException, G4Exception(), and G4SurfaceProperty::GetSurfacePropertyTable().

Referenced by G4GDMLReadStructure::BorderSurfaceRead(), and G4GDMLReadStructure::SkinSurfaceRead().

GetVariable()

G4double G4GDMLReadDefine::GetVariable ( const G4String &  ref )

inherited

Definition at line 764 of file G4GDMLReadDefine.cc.

{
  return eval.GetVariable(ref);
}

References G4GDMLRead::eval, and G4GDMLEvaluator::GetVariable().

GetVolume()

virtual G4LogicalVolume * G4GDMLRead::GetVolume ( const G4String &  ) const

pure virtualinherited

Implemented in G4GDMLReadStructure.

Referenced by ParamvolRead().

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

HypeRead()

void G4GDMLReadSolids::HypeRead ( const xercesc::DOMElement * const  hypeElement )

protectedinherited

Definition at line 694 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double aunit = 1.0;
  G4double rmin  = 0.0;
  G4double rmax  = 0.0;
  G4double inst  = 0.0;
  G4double outst = 0.0;
  G4double z     = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    hypeElement->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("G4GDMLReadSolids::HypeRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::HypeRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::HypeRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "rmin")
    {
      rmin = eval.Evaluate(attValue);
    }
    else if(attName == "rmax")
    {
      rmax = eval.Evaluate(attValue);
    }
    else if(attName == "inst")
    {
      inst = eval.Evaluate(attValue);
    }
    else if(attName == "outst")
    {
      outst = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
  }
 
  rmin *= lunit;
  rmax *= lunit;
  inst *= aunit;
  outst *= aunit;
  z *= 0.5 * lunit;
 
  new G4Hype(name, rmin, rmax, inst, outst, z);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

IsotopeRead()

void G4GDMLReadMaterials::IsotopeRead ( const xercesc::DOMElement * const  isotopeElement )

protectedinherited

Definition at line 472 of file G4GDMLReadMaterials.cc.

{
  G4String name;
  G4int Z    = 0;
  G4int N    = 0;
  G4double a = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    isotopeElement->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("G4GDMLReadMaterials::IsotopeRead()", "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 == "Z")
    {
      Z = eval.EvaluateInteger(attValue);
    }
    else if(attName == "N")
    {
      N = eval.EvaluateInteger(attValue);
    }
  }
 
  for(xercesc::DOMNode* iter = isotopeElement->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("G4GDMLReadMaterials::IsotopeRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "atom")
    {
      a = AtomRead(child);
    }
  }
 
  new G4Isotope(Strip(name), Z, N, a);
}

References G4GDMLReadMaterials::AtomRead(), G4GDMLRead::eval, G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4InuclParticleNames::name(), G4GDMLRead::Strip(), G4GDMLRead::Transcode(), and Z.

Referenced by G4GDMLReadMaterials::MaterialsRead().

IsValidID()

G4bool G4GDMLReadDefine::IsValidID ( const G4String &  ref ) const

inherited

Definition at line 752 of file G4GDMLReadDefine.cc.

{
  return eval.IsVariable(ref);
}

References G4GDMLRead::eval, and G4GDMLEvaluator::IsVariable().

LoopRead()

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

protectedinherited

Definition at line 194 of file G4GDMLRead.cc.

{
  G4String var;
  G4String from;
  G4String to;
  G4String step;
 
  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)
    {
      G4Exception("G4GDMLRead::LoopRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return;
    }
    const G4String attribute_name  = Transcode(attribute->getName());
    const G4String attribute_value = Transcode(attribute->getValue());
 
    if(attribute_name == "for")
    {
      var = attribute_value;
    }
    else if(attribute_name == "from")
    {
      from = attribute_value;
    }
    else if(attribute_name == "to")
    {
      to = attribute_value;
    }
    else if(attribute_name == "step")
    {
      step = attribute_value;
    }
  }
 
  if(var.empty())
  {
    G4Exception("G4GDMLRead::loopRead()", "InvalidRead", FatalException,
                "No variable is determined for loop!");
  }
 
  if(!eval.IsVariable(var))
  {
    G4Exception("G4GDMLRead::loopRead()", "InvalidRead", FatalException,
                "Variable is not defined in loop!");
  }
 
  G4int _var  = eval.EvaluateInteger(var);
  G4int _from = eval.EvaluateInteger(from);
  G4int _to   = eval.EvaluateInteger(to);
  G4int _step = eval.EvaluateInteger(step);
 
  if(!from.empty())
  {
    _var = _from;
  }
 
  if((_from < _to) && (_step <= 0))
  {
    G4Exception("G4GDMLRead::loopRead()", "InvalidRead", FatalException,
                "Infinite loop!");
  }
  if((_from > _to) && (_step >= 0))
  {
    G4Exception("G4GDMLRead::loopRead()", "InvalidRead", FatalException,
                "Infinite loop!");
  }
 
  ++inLoop;
 
  while(_var <= _to)
  {
    eval.SetVariable(var, _var);
    (this->*func)(element);
    _var += _step;
    ++loopCount;
  }
 
  --inLoop;
  if(!inLoop)
  {
    loopCount = 0;
  }
}

References G4GDMLRead::eval, G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), G4GDMLRead::inLoop, G4GDMLEvaluator::IsVariable(), G4GDMLRead::loopCount, G4GDMLEvaluator::SetVariable(), and G4GDMLRead::Transcode().

Referenced by ParameterisedRead(), Paramvol_contentRead(), G4GDMLReadSolids::SolidsRead(), G4GDMLReadStructure::StructureRead(), and G4GDMLReadStructure::Volume_contentRead().

MaterialRead()

void G4GDMLReadMaterials::MaterialRead ( const xercesc::DOMElement * const  materialElement )

protectedinherited

Definition at line 547 of file G4GDMLReadMaterials.cc.

{
  G4String name;
  G4double Z    = 0.0;
  G4double a    = 0.0;
  G4double D    = 0.0;
  G4State state = kStateUndefined;
  G4double T    = NTP_Temperature;
  G4double P    = STP_Pressure;
  G4double MEE  = -1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    materialElement->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("G4GDMLReadMaterials::MaterialRead()", "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 == "Z")
    {
      Z = eval.Evaluate(attValue);
    }
    else if(attName == "state")
    {
      if(attValue == "solid")
      {
        state = kStateSolid;
      }
      else if(attValue == "liquid")
      {
        state = kStateLiquid;
      }
      else if(attValue == "gas")
      {
        state = kStateGas;
      }
    }
  }
 
  std::size_t nComponents = 0;
 
  for(xercesc::DOMNode* iter = materialElement->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("G4GDMLReadMaterials::MaterialRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "atom")
    {
      a = AtomRead(child);
    }
    else if(tag == "Dref")
    {
      D = GetQuantity(GenerateName(RefRead(child)));
    }
    else if(tag == "Pref")
    {
      P = GetQuantity(GenerateName(RefRead(child)));
    }
    else if(tag == "Tref")
    {
      T = GetQuantity(GenerateName(RefRead(child)));
    }
    else if(tag == "MEEref")
    {
      MEE = GetQuantity(GenerateName(RefRead(child)));
    }
    else if(tag == "D")
    {
      D = DRead(child);
    }
    else if(tag == "P")
    {
      P = PRead(child);
    }
    else if(tag == "T")
    {
      T = TRead(child);
    }
    else if(tag == "MEE")
    {
      MEE = MEERead(child);
    }
    else if(tag == "fraction" || tag == "composite")
    {
      nComponents++;
    }
  }
 
  G4Material* material = nullptr;
 
  if(nComponents == 0)
  {
    material = new G4Material(Strip(name), Z, a, D, state, T, P);
  }
  else
  {
    material = new G4Material(Strip(name), D, nComponents, state, T, P);
    MixtureRead(materialElement, material);
  }
  if(MEE != -1)  // ionisation potential (mean excitation energy)
  {
    material->GetIonisation()->SetMeanExcitationEnergy(MEE);
  }
 
  for(xercesc::DOMNode* iter = materialElement->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("G4GDMLReadMaterials::MaterialRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "property")
    {
      PropertyRead(child, material);
    }
  }
}

References G4GDMLReadMaterials::AtomRead(), D(), G4GDMLReadMaterials::DRead(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadDefine::GetQuantity(), kStateGas, kStateLiquid, kStateSolid, kStateUndefined, eplot::material, G4GDMLReadMaterials::MEERead(), G4GDMLReadMaterials::MixtureRead(), G4InuclParticleNames::name(), NTP_Temperature, P, G4GDMLReadMaterials::PRead(), G4GDMLReadMaterials::PropertyRead(), G4GDMLReadDefine::RefRead(), source.hepunit::STP_Pressure, G4GDMLRead::Strip(), G4GDMLRead::Transcode(), G4GDMLReadMaterials::TRead(), and Z.

Referenced by G4GDMLReadMaterials::MaterialsRead().

MaterialsRead()

void G4GDMLReadMaterials::MaterialsRead ( const xercesc::DOMElement * const  materialsElement )

virtualinherited

Implements G4GDMLRead.

Definition at line 882 of file G4GDMLReadMaterials.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Reading materials..." << G4endl;
#endif
  for(xercesc::DOMNode* iter = materialsElement->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("G4GDMLReadMaterials::MaterialsRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "define")
    {
      DefineRead(child);
    }
    else if(tag == "element")
    {
      ElementRead(child);
    }
    else if(tag == "isotope")
    {
      IsotopeRead(child);
    }
    else if(tag == "material")
    {
      MaterialRead(child);
    }
    else
    {
      G4String error_msg = "Unknown tag in materials: " + tag;
      G4Exception("G4GDMLReadMaterials::MaterialsRead()", "InvalidSetup",
                  FatalException, error_msg);
    }
  }
}

References G4GDMLReadDefine::DefineRead(), G4GDMLReadMaterials::ElementRead(), FatalException, G4cout, G4endl, G4Exception(), G4GDMLReadMaterials::IsotopeRead(), G4GDMLReadMaterials::MaterialRead(), and G4GDMLRead::Transcode().

MatrixRead()

void G4GDMLReadDefine::MatrixRead ( const xercesc::DOMElement * const  matrixElement )

protectedinherited

Definition at line 255 of file G4GDMLReadDefine.cc.

{
  G4String name   = "";
  G4int coldim    = 0;
  G4String values = "";
 
  const xercesc::DOMNamedNodeMap* const attributes =
    matrixElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
 
  for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
      ++attribute_index)
  {
    xercesc::DOMNode* node = attributes->item(attribute_index);
 
    if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(node);
    if(attribute == nullptr)
    {
      G4Exception("G4GDMLRead::MatrixRead()", "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 == "coldim")
    {
      coldim = eval.EvaluateInteger(attValue);
    }
    else if(attName == "values")
    {
      values = attValue;
    }
  }
 
  std::stringstream MatrixValueStream(values);
  std::vector<G4double> valueList;
 
  while(!MatrixValueStream.eof())
  {
    G4String MatrixValue;
    MatrixValueStream >> MatrixValue;
    valueList.push_back(eval.Evaluate(MatrixValue));
  }
 
  eval.DefineMatrix(name, coldim, valueList);
 
  G4GDMLMatrix matrix(valueList.size() / coldim, coldim);
 
  for(std::size_t i = 0; i < valueList.size(); ++i)
  {
    matrix.Set(i / coldim, i % coldim, valueList[i]);
  }
 
  matrixMap[name] = matrix;
}

References G4GDMLEvaluator::DefineMatrix(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadDefine::matrixMap, G4InuclParticleNames::name(), G4GDMLMatrix::Set(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadDefine::DefineRead().

MEERead()

G4double G4GDMLReadMaterials::MEERead ( const xercesc::DOMElement * const  PElement )

protectedinherited

Definition at line 291 of file G4GDMLReadMaterials.cc.

{
  G4double value = -1;
  G4double unit  = eV;
 
  const xercesc::DOMNamedNodeMap* const attributes = PElement->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("G4GDMLReadMaterials::MEERead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return value;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Energy")
      {
        G4Exception("G4GDMLReadMaterials::MEERead()", "InvalidRead",
                    FatalException, "Invalid unit for energy!");
      }
    }
  }
 
  return value * unit;
}

References eV, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadMaterials::MaterialRead().

MixtureRead() [1/2]

void G4GDMLReadMaterials::MixtureRead ( const xercesc::DOMElement * const  mixtureElement, G4Element *  element  )

protectedinherited

Definition at line 713 of file G4GDMLReadMaterials.cc.

{
  for(xercesc::DOMNode* iter = mixtureElement->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("G4GDMLReadMaterials::MixtureRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "fraction")
    {
      G4String ref;
      G4double n = FractionRead(child, ref);
      element->AddIsotope(GetIsotope(GenerateName(ref, true)), n);
    }
  }
}

References G4Element::AddIsotope(), FatalException, G4GDMLReadMaterials::FractionRead(), G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadMaterials::GetIsotope(), CLHEP::detail::n, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadMaterials::ElementRead(), and G4GDMLReadMaterials::MaterialRead().

MixtureRead() [2/2]

void G4GDMLReadMaterials::MixtureRead ( const xercesc::DOMElement * const  mixtureElement, G4Material *  material  )

protectedinherited

Definition at line 744 of file G4GDMLReadMaterials.cc.

{
  for(xercesc::DOMNode* iter = mixtureElement->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("G4GDMLReadMaterials::MixtureRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "fraction")
    {
      G4String ref;
      G4double n = FractionRead(child, ref);
 
      G4Material* materialPtr = GetMaterial(GenerateName(ref, true), false);
      G4Element* elementPtr   = GetElement(GenerateName(ref, true), false);
 
      if(elementPtr != nullptr)
      {
        material->AddElement(elementPtr, n);
      }
      else if(materialPtr != nullptr)
      {
        material->AddMaterial(materialPtr, n);
      }
 
      if((materialPtr == nullptr) && (elementPtr == nullptr))
      {
        G4String error_msg = "Referenced material/element '" +
                             GenerateName(ref, true) + "' was not found!";
        G4Exception("G4GDMLReadMaterials::MixtureRead()", "InvalidSetup",
                    FatalException, error_msg);
      }
    }
    else if(tag == "composite")
    {
      G4String ref;
      G4int n = CompositeRead(child, ref);
 
      G4Element* elementPtr = GetElement(GenerateName(ref, true));
      material->AddElement(elementPtr, n);
    }
  }
}

References G4GDMLReadMaterials::CompositeRead(), FatalException, G4GDMLReadMaterials::FractionRead(), G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadMaterials::GetElement(), G4GDMLReadMaterials::GetMaterial(), eplot::material, CLHEP::detail::n, and G4GDMLRead::Transcode().

MultiUnionNodeRead()

void G4GDMLReadSolids::MultiUnionNodeRead ( const xercesc::DOMElement * const  unionNodeElement, G4MultiUnion * const  multiUnionSolid  )

protectedinherited

Definition at line 784 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4String solid;
  G4ThreeVector position(0.0, 0.0, 0.0);
  G4ThreeVector rotation(0.0, 0.0, 0.0);
 
  const xercesc::DOMNamedNodeMap* const attributes =
    unionNodeElement->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("G4GDMLReadSolids::MultiUnionNodeRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "name")
    {
      name = GenerateName(attValue);
    }
  }
 
  for(xercesc::DOMNode* iter = unionNodeElement->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("G4GDMLReadSolids::MultiUnionNodeRead()", "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 == "solid")
    {
      solid = RefRead(child);
    }
    else
    {
      G4String error_msg = "Unknown tag in MultiUnion structure: " + tag;
      G4Exception("G4GDMLReadSolids::MultiUnionNodeRead()", "ReadError",
                  FatalException, error_msg);
    }
  }
  G4VSolid* solidNode = GetSolid(GenerateName(solid));
  G4Transform3D transform(GetRotationMatrix(rotation), position);
  multiUnionSolid->AddNode(*solidNode, transform);
}

References G4MultiUnion::AddNode(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadDefine::GetPosition(), G4GDMLReadDefine::GetRotation(), G4GDMLReadDefine::GetRotationMatrix(), G4GDMLReadSolids::GetSolid(), G4InuclParticleNames::name(), position, G4GDMLReadDefine::RefRead(), G4GDMLRead::Transcode(), G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform(), and G4GDMLReadDefine::VectorRead().

Referenced by G4GDMLReadSolids::MultiUnionRead().

MultiUnionRead()

void G4GDMLReadSolids::MultiUnionRead ( const xercesc::DOMElement * const  unionElement )

protectedinherited

Definition at line 875 of file G4GDMLReadSolids.cc.

{
  G4String name;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    unionElement->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("G4GDMLReadSolids::MultiUnionRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "name")
    {
      name = GenerateName(attValue);
    }
  }
 
  G4MultiUnion* multiUnion = new G4MultiUnion(name);
 
  for(xercesc::DOMNode* iter = unionElement->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("G4GDMLReadSolids::MultiUnionRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "multiUnionNode")
    {
      MultiUnionNodeRead(child, multiUnion);
    }
    else
    {
      G4String error_msg = "Unknown tag in MultiUnion structure: " + tag;
      G4Exception("G4GDMLReadSolids::MultiUnionRead()", "ReadError",
                  FatalException, error_msg);
    }
  }
  multiUnion->Voxelize();
}

References FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadSolids::MultiUnionNodeRead(), G4InuclParticleNames::name(), G4GDMLRead::Transcode(), and G4MultiUnion::Voxelize().

Referenced by G4GDMLReadSolids::SolidsRead().

OpticalSurfaceRead()

void G4GDMLReadSolids::OpticalSurfaceRead ( const xercesc::DOMElement * const  opticalsurfaceElement )

protectedinherited

Definition at line 3584 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4String smodel;
  G4String sfinish;
  G4String stype;
  G4double value = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    opticalsurfaceElement->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("G4GDMLReadSolids::OpticalSurfaceRead()", "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 == "model")
    {
      smodel = attValue;
    }
    else if(attName == "finish")
    {
      sfinish = attValue;
    }
    else if(attName == "type")
    {
      stype = attValue;
    }
    else if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
  }
 
  G4OpticalSurfaceModel model;
  G4OpticalSurfaceFinish finish;
  G4SurfaceType type;
 
  if((smodel == "glisur") || (smodel == "0"))
  {
    model = glisur;
  }
  else if((smodel == "unified") || (smodel == "1"))
  {
    model = unified;
  }
  else if((smodel == "LUT") || (smodel == "2"))
  {
    model = LUT;
  }
  else if((smodel == "DAVIS") || (smodel == "3"))
  {
    model = DAVIS;
  }
  else
  {
    model = dichroic;
  }
 
  if((sfinish == "polished") || (sfinish == "0"))
  {
    finish = polished;
  }
  else if((sfinish == "polishedfrontpainted") || (sfinish == "1"))
  {
    finish = polishedfrontpainted;
  }
  else if((sfinish == "polishedbackpainted") || (sfinish == "2"))
  {
    finish = polishedbackpainted;
  }
  else if((sfinish == "ground") || (sfinish == "3"))
  {
    finish = ground;
  }
  else if((sfinish == "groundfrontpainted") || (sfinish == "4"))
  {
    finish = groundfrontpainted;
  }
  else if((sfinish == "groundbackpainted") || (sfinish == "5"))
  {
    finish = groundbackpainted;
  }
  else if((sfinish == "polishedlumirrorair") || (sfinish == "6"))
  {
    finish = polishedlumirrorair;
  }
  else if((sfinish == "polishedlumirrorglue") || (sfinish == "7"))
  {
    finish = polishedlumirrorglue;
  }
  else if((sfinish == "polishedair") || (sfinish == "8"))
  {
    finish = polishedair;
  }
  else if((sfinish == "polishedteflonair") || (sfinish == "9"))
  {
    finish = polishedteflonair;
  }
  else if((sfinish == "polishedtioair") || (sfinish == "10"))
  {
    finish = polishedtioair;
  }
  else if((sfinish == "polishedtyvekair") || (sfinish == "11"))
  {
    finish = polishedtyvekair;
  }
  else if((sfinish == "polishedvm2000air") || (sfinish == "12"))
  {
    finish = polishedvm2000air;
  }
  else if((sfinish == "polishedvm2000glue") || (sfinish == "13"))
  {
    finish = polishedvm2000glue;
  }
  else if((sfinish == "etchedlumirrorair") || (sfinish == "14"))
  {
    finish = etchedlumirrorair;
  }
  else if((sfinish == "etchedlumirrorglue") || (sfinish == "15"))
  {
    finish = etchedlumirrorglue;
  }
  else if((sfinish == "etchedair") || (sfinish == "16"))
  {
    finish = etchedair;
  }
  else if((sfinish == "etchedteflonair") || (sfinish == "17"))
  {
    finish = etchedteflonair;
  }
  else if((sfinish == "etchedtioair") || (sfinish == "18"))
  {
    finish = etchedtioair;
  }
  else if((sfinish == "etchedtyvekair") || (sfinish == "19"))
  {
    finish = etchedtyvekair;
  }
  else if((sfinish == "etchedvm2000air") || (sfinish == "20"))
  {
    finish = etchedvm2000air;
  }
  else if((sfinish == "etchedvm2000glue") || (sfinish == "21"))
  {
    finish = etchedvm2000glue;
  }
  else if((sfinish == "groundlumirrorair") || (sfinish == "22"))
  {
    finish = groundlumirrorair;
  }
  else if((sfinish == "groundlumirrorglue") || (sfinish == "23"))
  {
    finish = groundlumirrorglue;
  }
  else if((sfinish == "groundair") || (sfinish == "24"))
  {
    finish = groundair;
  }
  else if((sfinish == "groundteflonair") || (sfinish == "25"))
  {
    finish = groundteflonair;
  }
  else if((sfinish == "groundtioair") || (sfinish == "26"))
  {
    finish = groundtioair;
  }
  else if((sfinish == "groundtyvekair") || (sfinish == "27"))
  {
    finish = groundtyvekair;
  }
  else if((sfinish == "groundvm2000air") || (sfinish == "28"))
  {
    finish = groundvm2000air;
  }
  else if((sfinish == "groundvm2000glue") || (sfinish == "29"))
  {
    finish = groundvm2000glue;
  }
  else if((sfinish == "Rough_LUT") || (sfinish == "30"))
  {
    finish = Rough_LUT;
  }
  else if((sfinish == "RoughTeflon_LUT") || (sfinish == "31"))
  {
    finish = RoughTeflon_LUT;
  }
  else if((sfinish == "RoughESR_LUT") || (sfinish == "32"))
  {
    finish = RoughESR_LUT;
  }
  else if((sfinish == "RoughESRGrease_LUT") || (sfinish == "33"))
  {
    finish = RoughESRGrease_LUT;
  }
  else if((sfinish == "Polished_LUT") || (sfinish == "34"))
  {
    finish = Polished_LUT;
  }
  else if((sfinish == "PolishedTeflon_LUT") || (sfinish == "35"))
  {
    finish = PolishedTeflon_LUT;
  }
  else if((sfinish == "PolishedESR_LUT") || (sfinish == "36"))
  {
    finish = PolishedESR_LUT;
  }
  else if((sfinish == "PolishedESRGrease_LUT") || (sfinish == "37"))
  {
    finish = PolishedESRGrease_LUT;
  }
  else
  {
    finish = Detector_LUT;
  }
 
  if((stype == "dielectric_metal") || (stype == "0"))
  {
    type = dielectric_metal;
  }
  else if((stype == "dielectric_dielectric") || (stype == "1"))
  {
    type = dielectric_dielectric;
  }
  else if((stype == "dielectric_LUT") || (stype == "2"))
  {
    type = dielectric_LUT;
  }
  else if((stype == "dielectric_LUTDAVIS") || (stype == "3"))
  {
    type = dielectric_LUTDAVIS;
  }
  else if((stype == "dielectric_dichroic") || (stype == "4"))
  {
    type = dielectric_dichroic;
  }
  else if((stype == "firsov") || (stype == "5"))
  {
    type = firsov;
  }
  else
  {
    type = x_ray;
  }
 
  G4OpticalSurface* opticalsurface =
    new G4OpticalSurface(name, model, finish, type, value);
 
  for(xercesc::DOMNode* iter = opticalsurfaceElement->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("G4GDMLReadSolids::OpticalSurfaceRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "property")
    {
      PropertyRead(child, opticalsurface);
    }
  }
}

References DAVIS, Detector_LUT, dichroic, dielectric_dichroic, dielectric_dielectric, dielectric_LUT, dielectric_LUTDAVIS, dielectric_metal, etchedair, etchedlumirrorair, etchedlumirrorglue, etchedteflonair, etchedtioair, etchedtyvekair, etchedvm2000air, etchedvm2000glue, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, firsov, G4Exception(), G4GDMLRead::GenerateName(), glisur, ground, groundair, groundbackpainted, groundfrontpainted, groundlumirrorair, groundlumirrorglue, groundteflonair, groundtioair, groundtyvekair, groundvm2000air, groundvm2000glue, LUT, G4InuclParticleNames::name(), polished, Polished_LUT, polishedair, polishedbackpainted, PolishedESR_LUT, PolishedESRGrease_LUT, polishedfrontpainted, polishedlumirrorair, polishedlumirrorglue, PolishedTeflon_LUT, polishedteflonair, polishedtioair, polishedtyvekair, polishedvm2000air, polishedvm2000glue, G4GDMLReadSolids::PropertyRead(), Rough_LUT, RoughESR_LUT, RoughESRGrease_LUT, RoughTeflon_LUT, G4GDMLRead::Transcode(), unified, and x_ray.

Referenced by G4GDMLReadSolids::SolidsRead().

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

OrbRead()

void G4GDMLReadSolids::OrbRead ( const xercesc::DOMElement * const  orbElement )

protectedinherited

Definition at line 946 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double r     = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    orbElement->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("G4GDMLReadSolids::OrbRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::OrbRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "r")
    {
      r = eval.Evaluate(attValue);
    }
  }
 
  r *= lunit;
 
  new G4Orb(name, r);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

OverlapCheck()

void G4GDMLRead::OverlapCheck ( G4bool  flag )

inherited

Definition at line 64 of file G4GDMLRead.cc.

{
  check = flag;
}

References G4GDMLRead::check.

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

ParaboloidRead()

void G4GDMLReadSolids::ParaboloidRead ( const xercesc::DOMElement * const  paraElement )

protectedinherited

Definition at line 1098 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double rlo   = 0.0;
  G4double rhi   = 0.0;
  G4double dz    = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    paraElement->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("G4GDMLReadSolids::ParaboloidRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::ParaboloidRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "rlo")
    {
      rlo = eval.Evaluate(attValue);
    }
    else if(attName == "rhi")
    {
      rhi = eval.Evaluate(attValue);
    }
    else if(attName == "dz")
    {
      dz = eval.Evaluate(attValue);
    }
  }
 
  rlo *= 1. * lunit;
  rhi *= 1. * lunit;
  dz *= 1. * lunit;
 
  new G4Paraboloid(name, dz, rlo, rhi);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

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

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

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

References G4GDMLParameterisation::AddParameter(), Box_dimensionsRead(), Cone_dimensionsRead(), Ellipsoid_dimensionsRead(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadDefine::GetPosition(), G4GDMLReadDefine::GetRotation(), Hype_dimensionsRead(), Orb_dimensionsRead(), Para_dimensionsRead(), parameterisation, Polycone_dimensionsRead(), Polyhedra_dimensionsRead(), position, G4GDMLParameterisation::PARAMETER::position, G4GDMLParameterisation::PARAMETER::pRot, G4GDMLReadDefine::RefRead(), CLHEP::HepRotation::rotateX(), CLHEP::HepRotation::rotateY(), CLHEP::HepRotation::rotateZ(), Sphere_dimensionsRead(), Torus_dimensionsRead(), G4GDMLRead::Transcode(), Trap_dimensionsRead(), Trd_dimensionsRead(), Tube_dimensionsRead(), G4GDMLReadDefine::VectorRead(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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

References FatalException, G4Exception(), G4GDMLRead::LoopRead(), ParameterisedRead(), G4GDMLRead::Paramvol_contentRead(), and G4GDMLRead::Transcode().

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

References G4GDMLRead::check, FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4LogicalVolume::GetName(), G4GDMLParameterisation::GetSize(), G4GDMLRead::GetVolume(), kUndefined, parameterisation, Paramvol_contentRead(), G4GDMLReadDefine::RefRead(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadStructure::Volume_contentRead().

ParaRead()

void G4GDMLReadSolids::ParaRead ( const xercesc::DOMElement * const  paraElement )

protectedinherited

Definition at line 1002 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double aunit = 1.0;
  G4double x     = 0.0;
  G4double y     = 0.0;
  G4double z     = 0.0;
  G4double alpha = 0.0;
  G4double theta = 0.0;
  G4double phi   = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    paraElement->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("G4GDMLReadSolids::ParaRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::ParaRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::ParaRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "x")
    {
      x = eval.Evaluate(attValue);
    }
    else if(attName == "y")
    {
      y = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
    else if(attName == "alpha")
    {
      alpha = eval.Evaluate(attValue);
    }
    else if(attName == "theta")
    {
      theta = eval.Evaluate(attValue);
    }
    else if(attName == "phi")
    {
      phi = eval.Evaluate(attValue);
    }
  }
 
  x *= 0.5 * lunit;
  y *= 0.5 * lunit;
  z *= 0.5 * lunit;
  alpha *= aunit;
  theta *= aunit;
  phi *= aunit;
 
  new G4Para(name, x, y, z, alpha, theta, phi);
}

References alpha, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

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));
    }
  }
 
  G4int numZPlanes = zplaneList.size();
  for(G4int 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;
  }
}

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4GDMLRead::Transcode(), and G4GDMLReadSolids::ZplaneRead().

Referenced by ParametersRead().

PolyconeRead()

void G4GDMLReadSolids::PolyconeRead ( const xercesc::DOMElement * const  polyconeElement )

protectedinherited

Definition at line 1167 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double startphi = 0.0;
  G4double deltaphi = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    polyconeElement->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("G4GDMLReadSolids::PolyconeRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::PolyconeRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::PolyconeRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "startphi")
    {
      startphi = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      deltaphi = eval.Evaluate(attValue);
    }
  }
 
  startphi *= aunit;
  deltaphi *= aunit;
 
  std::vector<zplaneType> zplaneList;
 
  for(xercesc::DOMNode* iter = polyconeElement->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("G4GDMLReadSolids::PolyconeRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "zplane")
    {
      zplaneList.push_back(ZplaneRead(child));
    }
  }
 
  G4int numZPlanes = zplaneList.size();
 
  G4double* rmin_array = new G4double[numZPlanes];
  G4double* rmax_array = new G4double[numZPlanes];
  G4double* z_array    = new G4double[numZPlanes];
 
  for(G4int i = 0; i < numZPlanes; ++i)
  {
    rmin_array[i] = zplaneList[i].rmin * lunit;
    rmax_array[i] = zplaneList[i].rmax * lunit;
    z_array[i]    = zplaneList[i].z * lunit;
  }
 
  new G4Polycone(name, startphi, deltaphi, numZPlanes, z_array, rmin_array,
                 rmax_array);
 
  delete[] rmin_array;
  delete[] rmax_array;
  delete[] z_array;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), G4GDMLRead::Transcode(), and G4GDMLReadSolids::ZplaneRead().

Referenced by G4GDMLReadSolids::SolidsRead().

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(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("G4GDMLReadParamvo::PolyhedraRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "zplane")
    {
      zplaneList.push_back(ZplaneRead(child));
    }
  }
 
  G4int numZPlanes = zplaneList.size();
  for(G4int 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;
  }
}

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4GDMLRead::Transcode(), and G4GDMLReadSolids::ZplaneRead().

Referenced by ParametersRead().

PolyhedraRead()

void G4GDMLReadSolids::PolyhedraRead ( const xercesc::DOMElement * const  polyhedraElement )

protectedinherited

Definition at line 1396 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double startphi = 0.0;
  G4double deltaphi = 0.0;
  G4int numsides    = 0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    polyhedraElement->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("G4GDMLReadSolids::PolyhedraRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "startphi")
    {
      startphi = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      deltaphi = eval.Evaluate(attValue);
    }
    else if(attName == "numsides")
    {
      numsides = eval.EvaluateInteger(attValue);
    }
  }
 
  startphi *= aunit;
  deltaphi *= aunit;
 
  std::vector<zplaneType> zplaneList;
 
  for(xercesc::DOMNode* iter = polyhedraElement->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("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "zplane")
    {
      zplaneList.push_back(ZplaneRead(child));
    }
  }
 
  G4int numZPlanes = zplaneList.size();
 
  G4double* rmin_array = new G4double[numZPlanes];
  G4double* rmax_array = new G4double[numZPlanes];
  G4double* z_array    = new G4double[numZPlanes];
 
  for(G4int i = 0; i < numZPlanes; ++i)
  {
    rmin_array[i] = zplaneList[i].rmin * lunit;
    rmax_array[i] = zplaneList[i].rmax * lunit;
    z_array[i]    = zplaneList[i].z * lunit;
  }
 
  new G4Polyhedra(name, startphi, deltaphi, numsides, numZPlanes, z_array,
                  rmin_array, rmax_array);
 
  delete[] rmin_array;
  delete[] rmax_array;
  delete[] z_array;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), G4GDMLEvaluator::EvaluateInteger(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), G4GDMLRead::Transcode(), and G4GDMLReadSolids::ZplaneRead().

Referenced by G4GDMLReadSolids::SolidsRead().

PositionRead()

void G4GDMLReadDefine::PositionRead ( const xercesc::DOMElement * const  positionElement )

protectedinherited

Definition at line 324 of file G4GDMLReadDefine.cc.

{
  G4String name = "";
  G4double unit = 1.0;
  G4ThreeVector position(0., 0., 0.);
 
  const xercesc::DOMNamedNodeMap* const attributes =
    positionElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
 
  for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
      ++attribute_index)
  {
    xercesc::DOMNode* node = attributes->item(attribute_index);
 
    if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(node);
    if(attribute == nullptr)
    {
      G4Exception("G4GDMLRead::PositionRead()", "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 == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadDefine::PositionRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "x")
    {
      position.setX(eval.Evaluate(attValue));
    }
    else if(attName == "y")
    {
      position.setY(eval.Evaluate(attValue));
    }
    else if(attName == "z")
    {
      position.setZ(eval.Evaluate(attValue));
    }
  }
 
  positionMap[name] = position * unit;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), position, G4GDMLReadDefine::positionMap, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadDefine::DefineRead().

PRead()

G4double G4GDMLReadMaterials::PRead ( const xercesc::DOMElement * const  PElement )

protectedinherited

Definition at line 195 of file G4GDMLReadMaterials.cc.

{
  G4double value = STP_Pressure;
  G4double unit  = hep_pascal;
 
  const xercesc::DOMNamedNodeMap* const attributes = PElement->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("G4GDMLReadMaterials::PRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return value;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Pressure")
      {
        G4Exception("G4GDMLReadMaterials::PRead()", "InvalidRead",
                    FatalException, "Invalid unit for pressure!");
      }
    }
  }
 
  return value * unit;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), hep_pascal, source.hepunit::STP_Pressure, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadMaterials::MaterialRead().

PropertyRead() [1/2]

void G4GDMLReadMaterials::PropertyRead ( const xercesc::DOMElement * const  propertyElement, G4Material *  material  )

protectedinherited

Definition at line 802 of file G4GDMLReadMaterials.cc.

{
  G4String name;
  G4String ref;
  G4GDMLMatrix matrix;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    propertyElement->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("G4GDMLReadMaterials::PropertyRead()", "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 == "ref")
    {
      matrix = GetMatrix(ref = attValue);
    }
  }
 
  /*
  if (matrix.GetCols() != 2)
  {
    G4String error_msg = "Referenced matrix '" + ref
           + "' should have \n two columns as a property table for material: "
           + material->GetName();
    G4Exception("G4GDMLReadMaterials::PropertyRead()", "InvalidRead",
                FatalException, error_msg);
  }
  */
 
  if(matrix.GetRows() == 0)
  {
    return;
  }
 
  G4MaterialPropertiesTable* matprop = material->GetMaterialPropertiesTable();
  if(matprop == nullptr)
  {
    matprop = new G4MaterialPropertiesTable();
    material->SetMaterialPropertiesTable(matprop);
  }
  if(matrix.GetCols() == 1)  // constant property assumed
  {
    matprop->AddConstProperty(Strip(name), matrix.Get(0, 0), true);
  }
  else  // build the material properties vector
  {
    G4MaterialPropertyVector* propvect = new G4MaterialPropertyVector();
    for(std::size_t i = 0; i < matrix.GetRows(); ++i)
    {
      propvect->InsertValues(matrix.Get(i, 0), matrix.Get(i, 1));
    }
    matprop->AddProperty(Strip(name), propvect, true);
  }
}

References G4MaterialPropertiesTable::AddConstProperty(), G4MaterialPropertiesTable::AddProperty(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLMatrix::Get(), G4GDMLMatrix::GetCols(), G4GDMLReadDefine::GetMatrix(), G4GDMLMatrix::GetRows(), G4PhysicsFreeVector::InsertValues(), eplot::material, G4InuclParticleNames::name(), G4GDMLRead::Strip(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadMaterials::MaterialRead().

PropertyRead() [2/2]

void G4GDMLReadSolids::PropertyRead ( const xercesc::DOMElement * const  propertyElement, G4OpticalSurface *  opticalsurface  )

protectedinherited

Definition at line 3487 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4String ref;
  G4GDMLMatrix matrix;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    propertyElement->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("G4GDMLReadSolids::PropertyRead()", "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 == "ref")
    {
      matrix = GetMatrix(ref = attValue);
    }
  }
 
  /*
  if (matrix.GetCols() != 2)
  {
    G4String error_msg = "Referenced matrix '" + ref
           + "' should have \n two columns as a property table for
  opticalsurface: "
           + opticalsurface->GetName();
    G4Exception("G4GDMLReadSolids::PropertyRead()", "InvalidRead",
                FatalException, error_msg);
  }
  */
 
  if(matrix.GetRows() == 0)
  {
    return;
  }
 
  G4MaterialPropertiesTable* matprop =
    opticalsurface->GetMaterialPropertiesTable();
  if(matprop == nullptr)
  {
    matprop = new G4MaterialPropertiesTable();
    opticalsurface->SetMaterialPropertiesTable(matprop);
  }
  if(matrix.GetCols() == 1)  // constant property assumed
  {
    matprop->AddConstProperty(Strip(name), matrix.Get(0, 0), true);
  }
  else  // build the material properties vector
  {
    G4MaterialPropertyVector* propvect;
    G4String temp = name + ref;
    // first check if it was already built
    if(mapOfMatPropVects.find(temp) == mapOfMatPropVects.end())
    {
      // if not create a new one
      propvect = new G4MaterialPropertyVector();
      for(size_t i = 0; i < matrix.GetRows(); i++)
      {
        propvect->InsertValues(matrix.Get(i, 0), matrix.Get(i, 1));
      }
      // and add it to the list for potential future reuse
      mapOfMatPropVects[temp] = propvect;
    }
    else
    {
      propvect = mapOfMatPropVects[temp];
    }
 
    matprop->AddProperty(Strip(name), propvect, true);
  }
}

References G4MaterialPropertiesTable::AddConstProperty(), G4MaterialPropertiesTable::AddProperty(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLMatrix::Get(), G4GDMLMatrix::GetCols(), G4OpticalSurface::GetMaterialPropertiesTable(), G4GDMLReadDefine::GetMatrix(), G4GDMLMatrix::GetRows(), G4PhysicsFreeVector::InsertValues(), G4GDMLReadSolids::mapOfMatPropVects, G4InuclParticleNames::name(), G4OpticalSurface::SetMaterialPropertiesTable(), G4GDMLRead::Strip(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::OpticalSurfaceRead().

QuadrangularRead()

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

protectedinherited

Definition at line 1637 of file G4GDMLReadSolids.cc.

{
  G4ThreeVector vertex1;
  G4ThreeVector vertex2;
  G4ThreeVector vertex3;
  G4ThreeVector vertex4;
  G4FacetVertexType type = ABSOLUTE;
  G4double lunit         = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    quadrangularElement->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("G4GDMLReadSolids::QuadrangularRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return nullptr;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "vertex1")
    {
      vertex1 = GetPosition(GenerateName(attValue));
    }
    else if(attName == "vertex2")
    {
      vertex2 = GetPosition(GenerateName(attValue));
    }
    else if(attName == "vertex3")
    {
      vertex3 = GetPosition(GenerateName(attValue));
    }
    else if(attName == "vertex4")
    {
      vertex4 = GetPosition(GenerateName(attValue));
    }
    else if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::QuadrangularRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "type")
    {
      if(attValue == "RELATIVE")
      {
        type = RELATIVE;
      }
    }
  }
 
  return new G4QuadrangularFacet(vertex1 * lunit, vertex2 * lunit,
                                 vertex3 * lunit, vertex4 * lunit, type);
}

References ABSOLUTE, FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4GDMLReadDefine::GetPosition(), G4UnitDefinition::GetValueOf(), RELATIVE, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::TessellatedRead().

QuantityRead()

void G4GDMLReadDefine::QuantityRead ( const xercesc::DOMElement * const  element )

protectedinherited

Definition at line 547 of file G4GDMLReadDefine.cc.

{
  G4String name  = "";
  G4double unit  = 1.0;
  G4double value = 0.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* node = attributes->item(attribute_index);
 
    if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(node);
    if(attribute == nullptr)
    {
      G4Exception("G4GDMLRead::QuantityRead()", "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 == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
    }
  }
 
  quantityMap[name] = value * unit;
  eval.DefineConstant(name, value * unit);
}

References G4GDMLEvaluator::DefineConstant(), G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), G4GDMLReadDefine::quantityMap, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadDefine::DefineRead().

Read()

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

inherited

Definition at line 422 of file G4GDMLRead.cc.

{
  dostrip = strip;
#ifdef G4VERBOSE
  if(isModule)
  {
    G4cout << "G4GDML: Reading module '" << fileName << "'..." << G4endl;
  }
  else
  {
    G4cout << "G4GDML: Reading '" << fileName << "'..." << G4endl;
  }
#endif
  inLoop   = 0;
  validate = validation;
 
  xercesc::ErrorHandler* handler   = new G4GDMLErrorHandler(!validate);
  xercesc::XercesDOMParser* parser = new xercesc::XercesDOMParser;
 
  if(validate)
  {
    parser->setValidationScheme(xercesc::XercesDOMParser::Val_Always);
  }
  parser->setValidationSchemaFullChecking(validate);
  parser->setCreateEntityReferenceNodes(false);
  // Entities will be automatically resolved by Xerces
 
  parser->setDoNamespaces(true);
  parser->setDoSchema(validate);
  parser->setErrorHandler(handler);
 
  try
  {
    parser->parse(fileName.c_str());
  } catch(const xercesc::XMLException& e)
  {
    G4cout << "G4GDML: " << Transcode(e.getMessage()) << G4endl;
  } catch(const xercesc::DOMException& e)
  {
    G4cout << "G4GDML: " << Transcode(e.getMessage()) << G4endl;
  }
 
  xercesc::DOMDocument* doc = parser->getDocument();
 
  if(doc == nullptr)
  {
    G4String error_msg = "Unable to open document: " + fileName;
    G4Exception("G4GDMLRead::Read()", "InvalidRead", FatalException, error_msg);
    return;
  }
  xercesc::DOMElement* element = doc->getDocumentElement();
 
  if(element == nullptr )
  {
    std::ostringstream message;
    message << "ERROR - Empty document or unable to validate schema!" << G4endl
            << "        Check Internet connection is ON in case of schema"
            << G4endl
            << "        validation enabled and location defined as URL in"
            << G4endl << "        the GDML file - " << fileName
            << " - being imported!" << G4endl
            << "        Otherwise, verify GDML schema server is reachable!";
    G4Exception("G4GDMLRead::Read()", "InvalidRead", FatalException, message);
    return;
  }
 
  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("G4GDMLRead::Read()", "InvalidRead", FatalException,
                  "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "define")
    {
      DefineRead(child);
    }
    else if(tag == "materials")
    {
      MaterialsRead(child);
    }
    else if(tag == "solids")
    {
      SolidsRead(child);
    }
    else if(tag == "setup")
    {
      SetupRead(child);
    }
    else if(tag == "structure")
    {
      StructureRead(child);
    }
    else if(tag == "userinfo")
    {
      UserinfoRead(child);
    }
    else if(tag == "extension")
    {
      ExtensionRead(child);
    }
    else
    {
      G4String error_msg = "Unknown tag in gdml: " + tag;
      G4Exception("G4GDMLRead::Read()", "InvalidRead", FatalException,
                  error_msg);
    }
  }
 
  delete parser;
  delete handler;
 
  if(isModule)
  {
#ifdef G4VERBOSE
    G4cout << "G4GDML: Reading module '" << fileName << "' done!" << G4endl;
#endif
  }
  else
  {
    G4cout << "G4GDML: Reading '" << fileName << "' done!" << G4endl;
    if(strip)
    {
      StripNames();
    }
  }
}

References G4GDMLRead::DefineRead(), G4GDMLRead::dostrip, G4GDMLRead::ExtensionRead(), FatalException, G4cout, G4endl, G4Exception(), G4GDMLRead::inLoop, G4GDMLRead::MaterialsRead(), geant4_check_module_cycles::parser, G4GDMLRead::SetupRead(), G4GDMLRead::SolidsRead(), G4StrUtil::strip(), G4GDMLRead::StripNames(), G4GDMLRead::StructureRead(), G4GDMLRead::Transcode(), G4GDMLRead::UserinfoRead(), and G4GDMLRead::validate.

Referenced by G4GDMLReadStructure::FileRead().

ReflectedSolidRead()

void G4GDMLReadSolids::ReflectedSolidRead ( const xercesc::DOMElement * const  reflectedSolidElement )

protectedinherited

Definition at line 1711 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double aunit = 1.0;
  G4String solid;
  G4ThreeVector scale(1.0, 1.0, 1.0);
  G4ThreeVector rotation;
  G4ThreeVector position;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    reflectedSolidElement->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("G4GDMLReadSolids::ReflectedSolidRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::ReflectedSolidRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::ReflectedSolidRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "solid")
    {
      solid = GenerateName(attValue);
    }
    else if(attName == "sx")
    {
      scale.setX(eval.Evaluate(attValue));
    }
    else if(attName == "sy")
    {
      scale.setY(eval.Evaluate(attValue));
    }
    else if(attName == "sz")
    {
      scale.setZ(eval.Evaluate(attValue));
    }
    else if(attName == "rx")
    {
      rotation.setX(eval.Evaluate(attValue));
    }
    else if(attName == "ry")
    {
      rotation.setY(eval.Evaluate(attValue));
    }
    else if(attName == "rz")
    {
      rotation.setZ(eval.Evaluate(attValue));
    }
    else if(attName == "dx")
    {
      position.setX(eval.Evaluate(attValue));
    }
    else if(attName == "dy")
    {
      position.setY(eval.Evaluate(attValue));
    }
    else if(attName == "dz")
    {
      position.setZ(eval.Evaluate(attValue));
    }
  }
 
  rotation *= aunit;
  position *= lunit;
 
  G4Transform3D transform(GetRotationMatrix(rotation), position);
  transform = transform * G4Scale3D(scale.x(), scale.y(), scale.z());
 
  new G4ReflectedSolid(name, GetSolid(solid), transform);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4GDMLReadDefine::GetRotationMatrix(), G4GDMLReadSolids::GetSolid(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), position, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), G4GDMLRead::Transcode(), G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GDMLReadSolids::SolidsRead().

RefRead()

G4String G4GDMLReadDefine::RefRead ( const xercesc::DOMElement * const  element )

protectedinherited

Definition at line 714 of file G4GDMLReadDefine.cc.

{
  G4String ref;
 
  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("G4GDMLRead::Read()", "InvalidRead", FatalException,
                  "No attribute found!");
      return ref;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "ref")
    {
      ref = attValue;
    }
  }
 
  return ref;
}

References FatalException, G4Exception(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadStructure::BorderSurfaceRead(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadMaterials::MaterialRead(), G4GDMLReadSolids::MultiUnionNodeRead(), ParametersRead(), ParamvolRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadStructure::ReplicaRead(), G4GDMLReadStructure::ReplicavolRead(), G4GDMLReadSolids::ScaledSolidRead(), G4GDMLReadSetup::SetupRead(), G4GDMLReadStructure::SkinSurfaceRead(), and G4GDMLReadStructure::VolumeRead().

RotationRead()

void G4GDMLReadDefine::RotationRead ( const xercesc::DOMElement * const  rotationElement )

protectedinherited

Definition at line 387 of file G4GDMLReadDefine.cc.

{
  G4String name = "";
  G4double unit = 1.0;
  G4ThreeVector rotation(0., 0., 0.);
 
  const xercesc::DOMNamedNodeMap* const attributes =
    rotationElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
 
  for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
      ++attribute_index)
  {
    xercesc::DOMNode* node = attributes->item(attribute_index);
 
    if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(node);
    if(attribute == nullptr)
    {
      G4Exception("G4GDMLRead::RotationRead()", "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 == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadDefine::RotationRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "x")
    {
      rotation.setX(eval.Evaluate(attValue));
    }
    else if(attName == "y")
    {
      rotation.setY(eval.Evaluate(attValue));
    }
    else if(attName == "z")
    {
      rotation.setZ(eval.Evaluate(attValue));
    }
  }
 
  rotationMap[name] = rotation * unit;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), G4GDMLReadDefine::rotationMap, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadDefine::DefineRead().

RZPointRead()

G4GDMLReadSolids::rzPointType G4GDMLReadSolids::RZPointRead ( const xercesc::DOMElement * const  zplaneElement )

protectedinherited

Definition at line 3443 of file G4GDMLReadSolids.cc.

{
  rzPointType rzpoint = { 0., 0. };
 
  const xercesc::DOMNamedNodeMap* const attributes =
    zplaneElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
 
  for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
      ++attribute_index)
  {
    xercesc::DOMNode* node = attributes->item(attribute_index);
 
    if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(node);
    if(attribute == nullptr)
    {
      G4Exception("G4GDMLReadSolids::RZPointRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return rzpoint;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "r")
    {
      rzpoint.r = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      rzpoint.z = eval.Evaluate(attValue);
    }
  }
 
  return rzpoint;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLReadSolids::rzPointType::r, G4GDMLRead::Transcode(), and G4GDMLReadSolids::rzPointType::z.

Referenced by G4GDMLReadSolids::GenericPolyconeRead(), and G4GDMLReadSolids::GenericPolyhedraRead().

ScaledSolidRead()

void G4GDMLReadSolids::ScaledSolidRead ( const xercesc::DOMElement * const  scaledSolidElement )

protectedinherited

Definition at line 1821 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4VSolid* solid = nullptr;
  G4ThreeVector scale(1.0, 1.0, 1.0);
 
  const xercesc::DOMNamedNodeMap* const attributes =
    scaledSolidElement->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("G4GDMLReadSolids::ScaledSolidRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "name")
    {
      name = GenerateName(attValue);
    }
  }
 
  for(xercesc::DOMNode* iter = scaledSolidElement->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("G4GDMLReadSolids::ScaledSolidRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "solidref")
    {
      solid = GetSolid(GenerateName(RefRead(child)));
    }
    else if(tag == "scale")
    {
      VectorRead(child, scale);
    }
    else if(tag == "scaleref")
    {
      scale = GetScale(GenerateName(RefRead(child)));
    }
    else
    {
      G4String error_msg = "Unknown tag in scaled solid: " + tag;
      G4Exception("G4GDMLReadSolids::ScaledSolidRead()", "ReadError",
                  FatalException, error_msg);
      return;
    }
  }
 
  G4Scale3D transform = G4Scale3D(scale.x(), scale.y(), scale.z());
 
  new G4ScaledSolid(name, solid, transform);
}

References FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4GDMLReadDefine::GetScale(), G4GDMLReadSolids::GetSolid(), G4InuclParticleNames::name(), G4GDMLReadDefine::RefRead(), G4GDMLRead::Transcode(), G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform(), G4GDMLReadDefine::VectorRead(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GDMLReadSolids::SolidsRead().

ScaleRead()

void G4GDMLReadDefine::ScaleRead ( const xercesc::DOMElement * const  scaleElement )

protectedinherited

Definition at line 450 of file G4GDMLReadDefine.cc.

{
  G4String name = "";
  G4ThreeVector scale(1.0, 1.0, 1.0);
 
  const xercesc::DOMNamedNodeMap* const attributes =
    scaleElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
 
  for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
      ++attribute_index)
  {
    xercesc::DOMNode* node = attributes->item(attribute_index);
 
    if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(node);
    if(attribute == nullptr)
    {
      G4Exception("G4GDMLRead::ScaleRead()", "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 == "x")
    {
      scale.setX(eval.Evaluate(attValue));
    }
    else if(attName == "y")
    {
      scale.setY(eval.Evaluate(attValue));
    }
    else if(attName == "z")
    {
      scale.setZ(eval.Evaluate(attValue));
    }
  }
 
  scaleMap[name] = scale;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4InuclParticleNames::name(), G4GDMLReadDefine::scaleMap, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadDefine::DefineRead().

SectionRead()

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

protectedinherited

Definition at line 1904 of file G4GDMLReadSolids.cc.

{
  G4double zPosition = 0.0;
  G4TwoVector Offset;
  G4double scalingFactor = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    sectionElement->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("G4GDMLReadSolids::SectionRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return G4ExtrudedSolid::ZSection(zPosition, Offset, scalingFactor);
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "zPosition")
    {
      zPosition = eval.Evaluate(attValue) * lunit;
    }
    else if(attName == "xOffset")
    {
      Offset.setX(eval.Evaluate(attValue) * lunit);
    }
    else if(attName == "yOffset")
    {
      Offset.setY(eval.Evaluate(attValue) * lunit);
    }
    else if(attName == "scalingFactor")
    {
      scalingFactor = eval.Evaluate(attValue);
    }
  }
 
  return G4ExtrudedSolid::ZSection(zPosition, Offset, scalingFactor);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), CLHEP::Hep2Vector::setX(), CLHEP::Hep2Vector::setY(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::XtruRead().

SetReverseSearch()

void G4GDMLReadDefine::SetReverseSearch ( G4bool  flag )

inlineinherited

Definition at line 81 of file G4GDMLReadDefine.hh.

    { reverseSearch = flag; }

References G4GDMLReadDefine::reverseSearch.

SetupRead()

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

virtualinherited

Implements G4GDMLRead.

Definition at line 67 of file G4GDMLReadSetup.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Reading setup..." << G4endl;
#endif
  G4String name;
 
  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("G4GDMLReadSetup::SetupRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "name")
    {
      name = attValue;
    }
  }
 
  for(xercesc::DOMNode* iter = 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("G4GDMLReadSetup::SetupRead()", "InvalidRead", FatalException,
                  "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "world")
    {
      setupMap[name] = GenerateName(RefRead(child));
    }
  }
}

References FatalException, G4cout, G4endl, G4Exception(), G4GDMLRead::GenerateName(), G4InuclParticleNames::name(), G4GDMLReadDefine::RefRead(), G4GDMLReadSetup::setupMap, and G4GDMLRead::Transcode().

SolidsRead()

void G4GDMLReadSolids::SolidsRead ( const xercesc::DOMElement * const  solidsElement )

virtualinherited

Implements G4GDMLRead.

Definition at line 3880 of file G4GDMLReadSolids.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Reading solids..." << G4endl;
#endif
  for(xercesc::DOMNode* iter = solidsElement->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("G4GDMLReadSolids::SolidsRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
    if(tag == "define")
    {
      DefineRead(child);
    }
    else if(tag == "box")
    {
      BoxRead(child);
    }
    else if(tag == "cone")
    {
      ConeRead(child);
    }
    else if(tag == "elcone")
    {
      ElconeRead(child);
    }
    else if(tag == "ellipsoid")
    {
      EllipsoidRead(child);
    }
    else if(tag == "eltube")
    {
      EltubeRead(child);
    }
    else if(tag == "xtru")
    {
      XtruRead(child);
    }
    else if(tag == "hype")
    {
      HypeRead(child);
    }
    else if(tag == "intersection")
    {
      BooleanRead(child, INTERSECTION);
    }
    else if(tag == "multiUnion")
    {
      MultiUnionRead(child);
    }
    else if(tag == "orb")
    {
      OrbRead(child);
    }
    else if(tag == "para")
    {
      ParaRead(child);
    }
    else if(tag == "paraboloid")
    {
      ParaboloidRead(child);
    }
    else if(tag == "polycone")
    {
      PolyconeRead(child);
    }
    else if(tag == "genericPolycone")
    {
      GenericPolyconeRead(child);
    }
    else if(tag == "polyhedra")
    {
      PolyhedraRead(child);
    }
    else if(tag == "genericPolyhedra")
    {
      GenericPolyhedraRead(child);
    }
    else if(tag == "reflectedSolid")
    {
      ReflectedSolidRead(child);
    }
    else if(tag == "scaledSolid")
    {
      ScaledSolidRead(child);
    }
    else if(tag == "sphere")
    {
      SphereRead(child);
    }
    else if(tag == "subtraction")
    {
      BooleanRead(child, SUBTRACTION);
    }
    else if(tag == "tessellated")
    {
      TessellatedRead(child);
    }
    else if(tag == "tet")
    {
      TetRead(child);
    }
    else if(tag == "torus")
    {
      TorusRead(child);
    }
    else if(tag == "arb8")
    {
      GenTrapRead(child);
    }
    else if(tag == "trap")
    {
      TrapRead(child);
    }
    else if(tag == "trd")
    {
      TrdRead(child);
    }
    else if(tag == "tube")
    {
      TubeRead(child);
    }
    else if(tag == "cutTube")
    {
      CutTubeRead(child);
    }
    else if(tag == "twistedbox")
    {
      TwistedboxRead(child);
    }
    else if(tag == "twistedtrap")
    {
      TwistedtrapRead(child);
    }
    else if(tag == "twistedtrd")
    {
      TwistedtrdRead(child);
    }
    else if(tag == "twistedtubs")
    {
      TwistedtubsRead(child);
    }
    else if(tag == "union")
    {
      BooleanRead(child, UNION);
    }
    else if(tag == "opticalsurface")
    {
      OpticalSurfaceRead(child);
    }
    else if(tag == "loop")
    {
      LoopRead(child, &G4GDMLRead::SolidsRead);
    }
    else
    {
      G4String error_msg = "Unknown tag in solids: " + tag;
      G4Exception("G4GDMLReadSolids::SolidsRead()", "ReadError", FatalException,
                  error_msg);
    }
  }
}

References G4GDMLReadSolids::BooleanRead(), G4GDMLReadSolids::BoxRead(), G4GDMLReadSolids::ConeRead(), G4GDMLReadSolids::CutTubeRead(), G4GDMLReadDefine::DefineRead(), G4GDMLReadSolids::ElconeRead(), G4GDMLReadSolids::EllipsoidRead(), G4GDMLReadSolids::EltubeRead(), FatalException, G4cout, G4endl, G4Exception(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), G4GDMLReadSolids::HypeRead(), G4GDMLReadSolids::INTERSECTION, G4GDMLRead::LoopRead(), G4GDMLReadSolids::MultiUnionRead(), G4GDMLReadSolids::OpticalSurfaceRead(), G4GDMLReadSolids::OrbRead(), G4GDMLReadSolids::ParaboloidRead(), G4GDMLReadSolids::ParaRead(), G4GDMLReadSolids::PolyconeRead(), G4GDMLReadSolids::PolyhedraRead(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadSolids::ScaledSolidRead(), G4GDMLRead::SolidsRead(), G4GDMLReadSolids::SphereRead(), G4GDMLReadSolids::SUBTRACTION, G4GDMLReadSolids::TessellatedRead(), G4GDMLReadSolids::TetRead(), G4GDMLReadSolids::TorusRead(), G4GDMLRead::Transcode(), G4GDMLReadSolids::TrapRead(), G4GDMLReadSolids::TrdRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), G4GDMLReadSolids::UNION, and G4GDMLReadSolids::XtruRead().

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

SphereRead()

void G4GDMLReadSolids::SphereRead ( const xercesc::DOMElement * const  sphereElement )

protectedinherited

Definition at line 1958 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit      = 1.0;
  G4double aunit      = 1.0;
  G4double rmin       = 0.0;
  G4double rmax       = 0.0;
  G4double startphi   = 0.0;
  G4double deltaphi   = 0.0;
  G4double starttheta = 0.0;
  G4double deltatheta = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    sphereElement->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("G4GDMLReadSolids::SphereRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::SphereRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::SphereRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "rmin")
    {
      rmin = eval.Evaluate(attValue);
    }
    else if(attName == "rmax")
    {
      rmax = eval.Evaluate(attValue);
    }
    else if(attName == "startphi")
    {
      startphi = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      deltaphi = eval.Evaluate(attValue);
    }
    else if(attName == "starttheta")
    {
      starttheta = eval.Evaluate(attValue);
    }
    else if(attName == "deltatheta")
    {
      deltatheta = eval.Evaluate(attValue);
    }
  }
 
  rmin *= lunit;
  rmax *= lunit;
  startphi *= aunit;
  deltaphi *= aunit;
  starttheta *= aunit;
  deltatheta *= aunit;
 
  new G4Sphere(name, rmin, rmax, startphi, deltaphi, starttheta, deltatheta);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

Strip()

G4String G4GDMLRead::Strip ( const G4String &  name ) const

protectedinherited

Definition at line 104 of file G4GDMLRead.cc.

{
  G4String sname(name);
  StripName(sname);
  return sname;
}

References G4InuclParticleNames::name(), and G4GDMLRead::StripName().

Referenced by G4GDMLReadStructure::BorderSurfaceRead(), G4GDMLReadMaterials::ElementRead(), G4GDMLReadMaterials::IsotopeRead(), G4GDMLReadMaterials::MaterialRead(), G4GDMLReadMaterials::PropertyRead(), G4GDMLReadSolids::PropertyRead(), and G4GDMLReadStructure::SkinSurfaceRead().

StripName()

void G4GDMLRead::StripName ( G4String &  name ) const

inherited

Definition at line 112 of file G4GDMLRead.cc.

{
  auto idx = name.find("0x");
  if(idx != G4String::npos)
  {
    name.erase(idx);
  }
}

References G4InuclParticleNames::name().

Referenced by G4GDMLParser::ExportRegions(), G4GDMLRead::GenerateName(), G4GDMLParser::ImportRegions(), G4GDMLRead::Strip(), and G4GDMLRead::StripNames().

StripNames()

void G4GDMLRead::StripNames ( ) const

inherited

Definition at line 122 of file G4GDMLRead.cc.

{
  // Strips off names of volumes, solids elements and materials from possible
  // reference pointers or IDs attached to their original identifiers.
 
  G4PhysicalVolumeStore* pvols     = G4PhysicalVolumeStore::GetInstance();
  G4LogicalVolumeStore* lvols      = G4LogicalVolumeStore::GetInstance();
  G4SolidStore* solids             = G4SolidStore::GetInstance();
  const G4ElementTable* elements   = G4Element::GetElementTable();
  const G4MaterialTable* materials = G4Material::GetMaterialTable();
 
  G4cout << "Stripping off GDML names of materials, solids and volumes ..."
         << G4endl;
 
  G4String sname;
  std::size_t i;
 
  // Solids...
  //
  for(i = 0; i < solids->size(); ++i)
  {
    G4VSolid* psol = (*solids)[i];
    sname          = psol->GetName();
    StripName(sname);
    psol->SetName(sname);
  }
  solids->UpdateMap();
 
  // Logical volumes...
  //
  for(i = 0; i < lvols->size(); ++i)
  {
    G4LogicalVolume* lvol = (*lvols)[i];
    sname                 = lvol->GetName();
    StripName(sname);
    lvol->SetName(sname);
  }
  lvols->UpdateMap();
 
  // Physical volumes...
  //
  for(i = 0; i < pvols->size(); ++i)
  {
    G4VPhysicalVolume* pvol = (*pvols)[i];
    sname                   = pvol->GetName();
    StripName(sname);
    pvol->SetName(sname);
  }
  pvols->UpdateMap();
 
  // Materials...
  //
  for(i = 0; i < materials->size(); ++i)
  {
    G4Material* pmat = (*materials)[i];
    sname            = pmat->GetName();
    StripName(sname);
    pmat->SetName(sname);
  }
 
  // Elements...
  //
  for(i = 0; i < elements->size(); ++i)
  {
    G4Element* pelm = (*elements)[i];
    sname           = pelm->GetName();
    StripName(sname);
    pelm->SetName(sname);
  }
}

References G4cout, G4endl, G4Element::GetElementTable(), G4LogicalVolumeStore::GetInstance(), G4PhysicalVolumeStore::GetInstance(), G4SolidStore::GetInstance(), G4Material::GetMaterialTable(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4VSolid::GetName(), G4Element::GetName(), G4Material::GetName(), G4VSolid::SetName(), G4Element::SetName(), G4Material::SetName(), G4LogicalVolume::SetName(), G4VPhysicalVolume::SetName(), G4GDMLRead::StripName(), G4LogicalVolumeStore::UpdateMap(), G4PhysicalVolumeStore::UpdateMap(), and G4SolidStore::UpdateMap().

Referenced by G4GDMLRead::Read().

StructureRead()

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

pure virtualinherited

Implemented in G4GDMLReadStructure.

Referenced by G4GDMLRead::Read(), and G4GDMLReadStructure::StructureRead().

TessellatedRead()

void G4GDMLReadSolids::TessellatedRead ( const xercesc::DOMElement * const  tessellatedElement )

protectedinherited

Definition at line 2055 of file G4GDMLReadSolids.cc.

{
  G4String name;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    tessellatedElement->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("G4GDMLReadSolids::TessellatedRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "name")
    {
      name = GenerateName(attValue);
    }
  }
 
  G4TessellatedSolid* tessellated = new G4TessellatedSolid(name);
 
  for(xercesc::DOMNode* iter = tessellatedElement->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("G4GDMLReadSolids::TessellatedRead()", "InvalidRead",
                  FatalException, "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "triangular")
    {
      tessellated->AddFacet(TriangularRead(child));
    }
    else if(tag == "quadrangular")
    {
      tessellated->AddFacet(QuadrangularRead(child));
    }
  }
 
  tessellated->SetSolidClosed(true);
}

References G4TessellatedSolid::AddFacet(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4InuclParticleNames::name(), G4GDMLReadSolids::QuadrangularRead(), G4TessellatedSolid::SetSolidClosed(), G4GDMLRead::Transcode(), and G4GDMLReadSolids::TriangularRead().

Referenced by G4GDMLReadSolids::SolidsRead().

TetRead()

void G4GDMLReadSolids::TetRead ( const xercesc::DOMElement * const  tetElement )

protectedinherited

Definition at line 2125 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4ThreeVector vertex1;
  G4ThreeVector vertex2;
  G4ThreeVector vertex3;
  G4ThreeVector vertex4;
  G4double lunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    tetElement->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("G4GDMLReadSolids::TetRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::TetRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "vertex1")
    {
      vertex1 = GetPosition(GenerateName(attValue));
    }
    else if(attName == "vertex2")
    {
      vertex2 = GetPosition(GenerateName(attValue));
    }
    else if(attName == "vertex3")
    {
      vertex3 = GetPosition(GenerateName(attValue));
    }
    else if(attName == "vertex4")
    {
      vertex4 = GetPosition(GenerateName(attValue));
    }
  }
 
  new G4Tet(name, vertex1 * lunit, vertex2 * lunit, vertex3 * lunit,
            vertex4 * lunit);
}

References FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4GDMLReadDefine::GetPosition(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

TorusRead()

void G4GDMLReadSolids::TorusRead ( const xercesc::DOMElement * const  torusElement )

protectedinherited

Definition at line 2195 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double rmin     = 0.0;
  G4double rmax     = 0.0;
  G4double rtor     = 0.0;
  G4double startphi = 0.0;
  G4double deltaphi = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    torusElement->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("G4GDMLReadSolids::TorusRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::TorusRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::TorusRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "rmin")
    {
      rmin = eval.Evaluate(attValue);
    }
    else if(attName == "rmax")
    {
      rmax = eval.Evaluate(attValue);
    }
    else if(attName == "rtor")
    {
      rtor = eval.Evaluate(attValue);
    }
    else if(attName == "startphi")
    {
      startphi = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      deltaphi = eval.Evaluate(attValue);
    }
  }
 
  rmin *= lunit;
  rmax *= lunit;
  rtor *= lunit;
  startphi *= aunit;
  deltaphi *= aunit;
 
  new G4Torus(name, rmin, rmax, rtor, startphi, deltaphi);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

Transcode()

G4String G4GDMLRead::Transcode ( const XMLCh * const  toTranscode )

protectedinherited

Definition at line 55 of file G4GDMLRead.cc.

{
  char* char_str = xercesc::XMLString::transcode(toTranscode);
  G4String my_str(char_str);
  xercesc::XMLString::release(&char_str);
  return my_str;
}

Referenced by G4GDMLReadStructure::AssemblyRead(), G4GDMLReadMaterials::AtomRead(), G4GDMLRead::AuxiliaryRead(), G4GDMLReadStructure::AxisRead(), G4GDMLReadSolids::BooleanRead(), G4GDMLReadStructure::BorderSurfaceRead(), Box_dimensionsRead(), G4GDMLReadSolids::BoxRead(), G4GDMLReadMaterials::CompositeRead(), Cone_dimensionsRead(), G4GDMLReadSolids::ConeRead(), G4GDMLReadDefine::ConstantRead(), G4GDMLReadSolids::CutTubeRead(), G4GDMLReadDefine::DefineRead(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadMaterials::DRead(), G4GDMLReadSolids::ElconeRead(), G4GDMLReadMaterials::ElementRead(), Ellipsoid_dimensionsRead(), G4GDMLReadSolids::EllipsoidRead(), G4GDMLReadSolids::EltubeRead(), G4GDMLReadDefine::ExpressionRead(), G4GDMLReadStructure::FileRead(), G4GDMLReadMaterials::FractionRead(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), Hype_dimensionsRead(), G4GDMLReadSolids::HypeRead(), G4GDMLReadMaterials::IsotopeRead(), G4GDMLRead::LoopRead(), G4GDMLReadMaterials::MaterialRead(), G4GDMLReadMaterials::MaterialsRead(), G4GDMLReadDefine::MatrixRead(), G4GDMLReadMaterials::MEERead(), G4GDMLReadMaterials::MixtureRead(), G4GDMLReadSolids::MultiUnionNodeRead(), G4GDMLReadSolids::MultiUnionRead(), G4GDMLReadSolids::OpticalSurfaceRead(), Orb_dimensionsRead(), G4GDMLReadSolids::OrbRead(), Para_dimensionsRead(), G4GDMLReadSolids::ParaboloidRead(), ParameterisedRead(), ParametersRead(), Paramvol_contentRead(), ParamvolRead(), G4GDMLReadSolids::ParaRead(), G4GDMLReadStructure::PhysvolRead(), Polycone_dimensionsRead(), G4GDMLReadSolids::PolyconeRead(), Polyhedra_dimensionsRead(), G4GDMLReadSolids::PolyhedraRead(), G4GDMLReadDefine::PositionRead(), G4GDMLReadMaterials::PRead(), G4GDMLReadMaterials::PropertyRead(), G4GDMLReadSolids::PropertyRead(), G4GDMLReadSolids::QuadrangularRead(), G4GDMLReadStructure::QuantityRead(), G4GDMLReadDefine::QuantityRead(), G4GDMLRead::Read(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadDefine::RefRead(), G4GDMLReadStructure::ReplicaRead(), G4GDMLReadStructure::ReplicavolRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadSolids::RZPointRead(), G4GDMLReadSolids::ScaledSolidRead(), G4GDMLReadDefine::ScaleRead(), G4GDMLReadSolids::SectionRead(), G4GDMLReadSetup::SetupRead(), G4GDMLReadStructure::SkinSurfaceRead(), G4GDMLReadSolids::SolidsRead(), Sphere_dimensionsRead(), G4GDMLReadSolids::SphereRead(), G4GDMLReadStructure::StructureRead(), G4GDMLReadSolids::TessellatedRead(), G4GDMLReadSolids::TetRead(), Torus_dimensionsRead(), G4GDMLReadSolids::TorusRead(), Trap_dimensionsRead(), G4GDMLReadSolids::TrapRead(), Trd_dimensionsRead(), G4GDMLReadSolids::TrdRead(), G4GDMLReadMaterials::TRead(), G4GDMLReadSolids::TriangularRead(), Tube_dimensionsRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), G4GDMLReadSolids::TwoDimVertexRead(), G4GDMLRead::UserinfoRead(), G4GDMLReadDefine::VariableRead(), G4GDMLReadDefine::VectorRead(), G4GDMLReadStructure::Volume_contentRead(), G4GDMLReadStructure::VolumeRead(), G4GDMLReadSolids::XtruRead(), and G4GDMLReadSolids::ZplaneRead().

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

TrapRead()

void G4GDMLReadSolids::TrapRead ( const xercesc::DOMElement * const  trapElement )

protectedinherited

Definition at line 2417 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit  = 1.0;
  G4double aunit  = 1.0;
  G4double z      = 0.0;
  G4double theta  = 0.0;
  G4double phi    = 0.0;
  G4double y1     = 0.0;
  G4double x1     = 0.0;
  G4double x2     = 0.0;
  G4double alpha1 = 0.0;
  G4double y2     = 0.0;
  G4double x3     = 0.0;
  G4double x4     = 0.0;
  G4double alpha2 = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    trapElement->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("G4GDMLReadSolids::TrapRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::TrapRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::TrapRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
    else if(attName == "theta")
    {
      theta = eval.Evaluate(attValue);
    }
    else if(attName == "phi")
    {
      phi = eval.Evaluate(attValue);
    }
    else if(attName == "y1")
    {
      y1 = eval.Evaluate(attValue);
    }
    else if(attName == "x1")
    {
      x1 = eval.Evaluate(attValue);
    }
    else if(attName == "x2")
    {
      x2 = eval.Evaluate(attValue);
    }
    else if(attName == "alpha1")
    {
      alpha1 = eval.Evaluate(attValue);
    }
    else if(attName == "y2")
    {
      y2 = eval.Evaluate(attValue);
    }
    else if(attName == "x3")
    {
      x3 = eval.Evaluate(attValue);
    }
    else if(attName == "x4")
    {
      x4 = eval.Evaluate(attValue);
    }
    else if(attName == "alpha2")
    {
      alpha2 = eval.Evaluate(attValue);
    }
  }
 
  z *= 0.5 * lunit;
  theta *= aunit;
  phi *= aunit;
  y1 *= 0.5 * lunit;
  x1 *= 0.5 * lunit;
  x2 *= 0.5 * lunit;
  alpha1 *= aunit;
  y2 *= 0.5 * lunit;
  x3 *= 0.5 * lunit;
  x4 *= 0.5 * lunit;
  alpha2 *= aunit;
 
  new G4Trap(name, z, theta, phi, y1, x1, x2, alpha1, y2, x3, x4, alpha2);
}

References alpha2, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

TrdRead()

void G4GDMLReadSolids::TrdRead ( const xercesc::DOMElement * const  trdElement )

protectedinherited

Definition at line 2543 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
  G4double x1    = 0.0;
  G4double x2    = 0.0;
  G4double y1    = 0.0;
  G4double y2    = 0.0;
  G4double z     = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    trdElement->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("G4GDMLReadSolids::TrdRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::TrdRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "x1")
    {
      x1 = eval.Evaluate(attValue);
    }
    else if(attName == "x2")
    {
      x2 = eval.Evaluate(attValue);
    }
    else if(attName == "y1")
    {
      y1 = eval.Evaluate(attValue);
    }
    else if(attName == "y2")
    {
      y2 = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
  }
 
  x1 *= 0.5 * lunit;
  x2 *= 0.5 * lunit;
  y1 *= 0.5 * lunit;
  y2 *= 0.5 * lunit;
  z *= 0.5 * lunit;
 
  new G4Trd(name, x1, x2, y1, y2, z);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

TRead()

G4double G4GDMLReadMaterials::TRead ( const xercesc::DOMElement * const  TElement )

protectedinherited

Definition at line 243 of file G4GDMLReadMaterials.cc.

{
  G4double value = NTP_Temperature;
  G4double unit  = kelvin;
 
  const xercesc::DOMNamedNodeMap* const attributes = TElement->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("G4GDMLReadMaterials::TRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return value;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "value")
    {
      value = eval.Evaluate(attValue);
    }
    else if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Temperature")
      {
        G4Exception("G4GDMLReadMaterials::TRead()", "InvalidRead",
                    FatalException, "Invalid unit for temperature!");
      }
    }
  }
 
  return value * unit;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), kelvin, NTP_Temperature, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadMaterials::MaterialRead().

TriangularRead()

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

protectedinherited

Definition at line 2623 of file G4GDMLReadSolids.cc.

{
  G4ThreeVector vertex1;
  G4ThreeVector vertex2;
  G4ThreeVector vertex3;
  G4FacetVertexType type = ABSOLUTE;
  G4double lunit         = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    triangularElement->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("G4GDMLReadSolids::TriangularRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return nullptr;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "vertex1")
    {
      vertex1 = GetPosition(GenerateName(attValue));
    }
    else if(attName == "vertex2")
    {
      vertex2 = GetPosition(GenerateName(attValue));
    }
    else if(attName == "vertex3")
    {
      vertex3 = GetPosition(GenerateName(attValue));
    }
    else if(attName == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::TriangularRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "type")
    {
      if(attValue == "RELATIVE")
      {
        type = RELATIVE;
      }
    }
  }
 
  return new G4TriangularFacet(vertex1 * lunit, vertex2 * lunit,
                               vertex3 * lunit, type);
}

References ABSOLUTE, FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4GDMLReadDefine::GetPosition(), G4UnitDefinition::GetValueOf(), RELATIVE, and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::TessellatedRead().

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

References G4GDMLParameterisation::PARAMETER::dimension, G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), and G4GDMLRead::Transcode().

Referenced by ParametersRead().

TubeRead()

void G4GDMLReadSolids::TubeRead ( const xercesc::DOMElement * const  tubeElement )

protectedinherited

Definition at line 2692 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double rmin     = 0.0;
  G4double rmax     = 0.0;
  G4double z        = 0.0;
  G4double startphi = 0.0;
  G4double deltaphi = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    tubeElement->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("G4GDMLReadSolids::TubeRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::TubeRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::TubeRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "rmin")
    {
      rmin = eval.Evaluate(attValue);
    }
    else if(attName == "rmax")
    {
      rmax = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
    else if(attName == "startphi")
    {
      startphi = eval.Evaluate(attValue);
    }
    else if(attName == "deltaphi")
    {
      deltaphi = eval.Evaluate(attValue);
    }
  }
 
  rmin *= lunit;
  rmax *= lunit;
  z *= 0.5 * lunit;
  startphi *= aunit;
  deltaphi *= aunit;
 
  new G4Tubs(name, rmin, rmax, z, startphi, deltaphi);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

TwistedboxRead()

void G4GDMLReadSolids::TwistedboxRead ( const xercesc::DOMElement * const  twistedboxElement )

protectedinherited

Definition at line 2899 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double PhiTwist = 0.0;
  G4double x        = 0.0;
  G4double y        = 0.0;
  G4double z        = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    twistedboxElement->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("G4GDMLReadSolids::TwistedboxRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::TwistedBoxRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::TwistedboxRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "PhiTwist")
    {
      PhiTwist = eval.Evaluate(attValue);
    }
    else if(attName == "x")
    {
      x = eval.Evaluate(attValue);
    }
    else if(attName == "y")
    {
      y = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
  }
 
  PhiTwist *= aunit;
  x *= 0.5 * lunit;
  y *= 0.5 * lunit;
  z *= 0.5 * lunit;
 
  new G4TwistedBox(name, PhiTwist, x, y, z);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

TwistedtrapRead()

void G4GDMLReadSolids::TwistedtrapRead ( const xercesc::DOMElement * const  twistedtrapElement )

protectedinherited

Definition at line 2984 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double PhiTwist = 0.0;
  G4double z        = 0.0;
  G4double Theta    = 0.0;
  G4double Phi      = 0.0;
  G4double y1       = 0.0;
  G4double x1       = 0.0;
  G4double x2       = 0.0;
  G4double y2       = 0.0;
  G4double x3       = 0.0;
  G4double x4       = 0.0;
  G4double Alph     = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    twistedtrapElement->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("G4GDMLReadSolids::TwistedtrapRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::TwistedtrapRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::TwistedtrapRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "PhiTwist")
    {
      PhiTwist = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
    else if(attName == "Theta")
    {
      Theta = eval.Evaluate(attValue);
    }
    else if(attName == "Phi")
    {
      Phi = eval.Evaluate(attValue);
    }
    else if(attName == "y1")
    {
      y1 = eval.Evaluate(attValue);
    }
    else if(attName == "x1")
    {
      x1 = eval.Evaluate(attValue);
    }
    else if(attName == "x2")
    {
      x2 = eval.Evaluate(attValue);
    }
    else if(attName == "y2")
    {
      y2 = eval.Evaluate(attValue);
    }
    else if(attName == "x3")
    {
      x3 = eval.Evaluate(attValue);
    }
    else if(attName == "x4")
    {
      x4 = eval.Evaluate(attValue);
    }
    else if(attName == "Alph")
    {
      Alph = eval.Evaluate(attValue);
    }
  }
 
  PhiTwist *= aunit;
  z *= 0.5 * lunit;
  Theta *= aunit;
  Phi *= aunit;
  Alph *= aunit;
  y1 *= 0.5 * lunit;
  x1 *= 0.5 * lunit;
  x2 *= 0.5 * lunit;
  y2 *= 0.5 * lunit;
  x3 *= 0.5 * lunit;
  x4 *= 0.5 * lunit;
 
  new G4TwistedTrap(name, PhiTwist, z, Theta, Phi, y1, x1, x2, y2, x3, x4,
                    Alph);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

TwistedtrdRead()

void G4GDMLReadSolids::TwistedtrdRead ( const xercesc::DOMElement * const  twistedtrdElement )

protectedinherited

Definition at line 3112 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit    = 1.0;
  G4double aunit    = 1.0;
  G4double x1       = 0.0;
  G4double x2       = 0.0;
  G4double y1       = 0.0;
  G4double y2       = 0.0;
  G4double z        = 0.0;
  G4double PhiTwist = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    twistedtrdElement->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("G4GDMLReadSolids::TwistedtrdRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::TwistedtrdRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::TwistedtrdRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "x1")
    {
      x1 = eval.Evaluate(attValue);
    }
    else if(attName == "x2")
    {
      x2 = eval.Evaluate(attValue);
    }
    else if(attName == "y1")
    {
      y1 = eval.Evaluate(attValue);
    }
    else if(attName == "y2")
    {
      y2 = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      z = eval.Evaluate(attValue);
    }
    else if(attName == "PhiTwist")
    {
      PhiTwist = eval.Evaluate(attValue);
    }
  }
 
  x1 *= 0.5 * lunit;
  x2 *= 0.5 * lunit;
  y1 *= 0.5 * lunit;
  y2 *= 0.5 * lunit;
  z *= 0.5 * lunit;
  PhiTwist *= aunit;
 
  new G4TwistedTrd(name, x1, x2, y1, y2, z, PhiTwist);
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

TwistedtubsRead()

void G4GDMLReadSolids::TwistedtubsRead ( const xercesc::DOMElement * const  twistedtubsElement )

protectedinherited

Definition at line 3209 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit        = 1.0;
  G4double aunit        = 1.0;
  G4double twistedangle = 0.0;
  G4double endinnerrad  = 0.0;
  G4double endouterrad  = 0.0;
  G4double zlen         = 0.0;
  G4double phi          = 0.0;
  G4double totphi       = 0.0;
  G4double midinnerrad  = 0.0;
  G4double midouterrad  = 0.0;
  G4double positiveEndz = 0.0;
  G4double negativeEndz = 0.0;
  G4int nseg            = 0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    twistedtubsElement->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("G4GDMLReadSolids::TwistedtubsRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::TwistedtubsRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
    else if(attName == "aunit")
    {
      aunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Angle")
      {
        G4Exception("G4GDMLReadSolids::TwistedtubsRead()", "InvalidRead",
                    FatalException, "Invalid unit for angle!");
      }
    }
    else if(attName == "twistedangle")
    {
      twistedangle = eval.Evaluate(attValue);
    }
    else if(attName == "endinnerrad")
    {
      endinnerrad = eval.Evaluate(attValue);
    }
    else if(attName == "endouterrad")
    {
      endouterrad = eval.Evaluate(attValue);
    }
    else if(attName == "zlen")
    {
      zlen = eval.Evaluate(attValue);
    }
    else if(attName == "midinnerrad")
    {
      midinnerrad = eval.Evaluate(attValue);
    }
    else if(attName == "midouterrad")
    {
      midouterrad = eval.Evaluate(attValue);
    }
    else if(attName == "negativeEndz")
    {
      negativeEndz = eval.Evaluate(attValue);
    }
    else if(attName == "positiveEndz")
    {
      positiveEndz = eval.Evaluate(attValue);
    }
    else if(attName == "nseg")
    {
      nseg = eval.Evaluate(attValue);
    }
    else if(attName == "totphi")
    {
      totphi = eval.Evaluate(attValue);
    }
    else if(attName == "phi")
    {
      phi = eval.Evaluate(attValue);
    }
  }
 
  twistedangle *= aunit;
  endinnerrad *= lunit;
  endouterrad *= lunit;
  zlen *= 0.5 * lunit;
  midinnerrad *= lunit;
  midouterrad *= lunit;
  positiveEndz *= lunit;
  negativeEndz *= lunit;
  phi *= aunit;
  totphi *= aunit;
 
  if(zlen != 0.0)
  {
    if(nseg != 0)
      new G4TwistedTubs(name, twistedangle, endinnerrad, endouterrad, zlen,
                        nseg, totphi);
    else
      new G4TwistedTubs(name, twistedangle, endinnerrad, endouterrad, zlen,
                        phi);
  }
  else
  {
    if(nseg != 0)
      new G4TwistedTubs(name, twistedangle, midinnerrad, midouterrad,
                        negativeEndz, positiveEndz, nseg, totphi);
    else
      new G4TwistedTubs(name, twistedangle, midinnerrad, midouterrad,
                        negativeEndz, positiveEndz, phi);
  }
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::SolidsRead().

TwoDimVertexRead()

G4TwoVector G4GDMLReadSolids::TwoDimVertexRead ( const xercesc::DOMElement * const  element, G4double  lunit  )

protectedinherited

Definition at line 3352 of file G4GDMLReadSolids.cc.

{
  G4TwoVector vec;
 
  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("G4GDMLReadSolids::TwoDimVertexRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return vec;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "x")
    {
      vec.setX(eval.Evaluate(attValue) * lunit);
    }
    else if(attName == "y")
    {
      vec.setY(eval.Evaluate(attValue) * lunit);
    }
  }
 
  return vec;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), CLHEP::Hep2Vector::setX(), CLHEP::Hep2Vector::setY(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::XtruRead().

UserinfoRead()

void G4GDMLRead::UserinfoRead ( const xercesc::DOMElement * const  userinfoElement )

virtualinherited

Definition at line 377 of file G4GDMLRead.cc.

{
#ifdef G4VERBOSE
  G4cout << "G4GDML: Reading userinfo..." << G4endl;
#endif
  for(xercesc::DOMNode* iter = userinfoElement->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)
    {
      G4Exception("G4GDMLRead::UserinfoRead()", "InvalidRead", FatalException,
                  "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "auxiliary")
    {
      auxGlobalList.push_back(AuxiliaryRead(child));
    }
    else
    {
      G4String error_msg = "Unknown tag in structure: " + tag;
      G4Exception("G4GDMLRead::UserinfoRead()", "ReadError", FatalException,
                  error_msg);
    }
  }
}

References G4GDMLRead::auxGlobalList, G4GDMLRead::AuxiliaryRead(), FatalException, G4cout, G4endl, G4Exception(), and G4GDMLRead::Transcode().

Referenced by G4GDMLRead::Read().

VariableRead()

void G4GDMLReadDefine::VariableRead ( const xercesc::DOMElement * const  variableElement )

protectedinherited

Definition at line 502 of file G4GDMLReadDefine.cc.

{
  G4String name  = "";
  G4double value = 0.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    variableElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
 
  for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
      ++attribute_index)
  {
    xercesc::DOMNode* node = attributes->item(attribute_index);
 
    if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(node);
    if(attribute == nullptr)
    {
      G4Exception("G4GDMLRead::VariableRead()", "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 == "value")
    {
      value = eval.Evaluate(attValue);
    }
  }
 
  eval.DefineVariable(name, value);
}

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

Referenced by G4GDMLReadDefine::DefineRead().

VectorRead()

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

protectedinherited

Definition at line 662 of file G4GDMLReadDefine.cc.

{
  G4double unit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    vectorElement->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("G4GDMLRead::VectorRead()", "InvalidRead", FatalException,
                  "No attribute found!");
      return;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "unit")
    {
      unit = G4UnitDefinition::GetValueOf(attValue);
    }
    else if(attName == "x")
    {
      vec.setX(eval.Evaluate(attValue));
    }
    else if(attName == "y")
    {
      vec.setY(eval.Evaluate(attValue));
    }
    else if(attName == "z")
    {
      vec.setZ(eval.Evaluate(attValue));
    }
  }
 
  vec *= unit;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4UnitDefinition::GetValueOf(), CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), and G4GDMLRead::Transcode().

Referenced by G4GDMLReadSolids::BooleanRead(), G4GDMLReadSolids::MultiUnionNodeRead(), ParametersRead(), G4GDMLReadStructure::PhysvolRead(), G4GDMLReadStructure::ReplicaRead(), and G4GDMLReadSolids::ScaledSolidRead().

Volume_contentRead()

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

pure virtualinherited

Implemented in G4GDMLReadStructure.

Referenced by G4GDMLReadStructure::Volume_contentRead().

XtruRead()

void G4GDMLReadSolids::XtruRead ( const xercesc::DOMElement * const  xtruElement )

protectedinherited

Definition at line 614 of file G4GDMLReadSolids.cc.

{
  G4String name;
  G4double lunit = 1.0;
 
  const xercesc::DOMNamedNodeMap* const attributes =
    xtruElement->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("G4GDMLReadSolids::XtruRead()", "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 == "lunit")
    {
      lunit = G4UnitDefinition::GetValueOf(attValue);
      if(G4UnitDefinition::GetCategory(attValue) != "Length")
      {
        G4Exception("G4GDMLReadSolids::XtruRead()", "InvalidRead",
                    FatalException, "Invalid unit for length!");
      }
    }
  }
 
  std::vector<G4TwoVector> twoDimVertexList;
  std::vector<G4ExtrudedSolid::ZSection> sectionList;
 
  for(xercesc::DOMNode* iter = xtruElement->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("G4GDMLReadSolids::XtruRead()", "InvalidRead", FatalException,
                  "No child found!");
      return;
    }
    const G4String tag = Transcode(child->getTagName());
 
    if(tag == "twoDimVertex")
    {
      twoDimVertexList.push_back(TwoDimVertexRead(child, lunit));
    }
    else if(tag == "section")
    {
      sectionList.push_back(SectionRead(child, lunit));
    }
  }
 
  new G4ExtrudedSolid(name, twoDimVertexList, sectionList);
}

References FatalException, G4Exception(), G4GDMLRead::GenerateName(), G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), G4GDMLReadSolids::SectionRead(), G4GDMLRead::Transcode(), and G4GDMLReadSolids::TwoDimVertexRead().

Referenced by G4GDMLReadSolids::SolidsRead().

ZplaneRead()

G4GDMLReadSolids::zplaneType G4GDMLReadSolids::ZplaneRead ( const xercesc::DOMElement * const  zplaneElement )

protectedinherited

Definition at line 3395 of file G4GDMLReadSolids.cc.

{
  zplaneType zplane = { 0., 0., 0. };
 
  const xercesc::DOMNamedNodeMap* const attributes =
    zplaneElement->getAttributes();
  XMLSize_t attributeCount = attributes->getLength();
 
  for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
      ++attribute_index)
  {
    xercesc::DOMNode* node = attributes->item(attribute_index);
 
    if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
    {
      continue;
    }
 
    const xercesc::DOMAttr* const attribute =
      dynamic_cast<xercesc::DOMAttr*>(node);
    if(attribute == nullptr)
    {
      G4Exception("G4GDMLReadSolids::ZplaneRead()", "InvalidRead",
                  FatalException, "No attribute found!");
      return zplane;
    }
    const G4String attName  = Transcode(attribute->getName());
    const G4String attValue = Transcode(attribute->getValue());
 
    if(attName == "rmin")
    {
      zplane.rmin = eval.Evaluate(attValue);
    }
    else if(attName == "rmax")
    {
      zplane.rmax = eval.Evaluate(attValue);
    }
    else if(attName == "z")
    {
      zplane.z = eval.Evaluate(attValue);
    }
  }
 
  return zplane;
}

References G4GDMLRead::eval, G4GDMLEvaluator::Evaluate(), FatalException, G4Exception(), G4GDMLReadSolids::zplaneType::rmax, G4GDMLReadSolids::zplaneType::rmin, G4GDMLRead::Transcode(), and G4GDMLReadSolids::zplaneType::z.

Referenced by Polycone_dimensionsRead(), G4GDMLReadSolids::PolyconeRead(), Polyhedra_dimensionsRead(), and G4GDMLReadSolids::PolyhedraRead().

Field Documentation

auxGlobalList

G4GDMLAuxListType G4GDMLRead::auxGlobalList

privateinherited

Definition at line 164 of file G4GDMLRead.hh.

Referenced by G4GDMLRead::GetAuxList(), and G4GDMLRead::UserinfoRead().

check

G4bool G4GDMLRead::check = false

protectedinherited

Definition at line 158 of file G4GDMLRead.hh.

Referenced by G4GDMLRead::OverlapCheck(), ParamvolRead(), and G4GDMLReadStructure::PhysvolRead().

dostrip

G4bool G4GDMLRead::dostrip = true

protectedinherited

Definition at line 159 of file G4GDMLRead.hh.

Referenced by G4GDMLReadStructure::GetWorldVolume(), and G4GDMLRead::Read().

eval

G4GDMLEvaluator G4GDMLRead::eval

protectedinherited

Definition at line 156 of file G4GDMLRead.hh.

Referenced by G4GDMLReadMaterials::AtomRead(), G4GDMLReadStructure::AxisRead(), Box_dimensionsRead(), G4GDMLReadSolids::BoxRead(), G4GDMLReadStructure::Clear(), G4GDMLReadMaterials::CompositeRead(), Cone_dimensionsRead(), G4GDMLReadSolids::ConeRead(), G4GDMLReadDefine::ConstantRead(), G4GDMLReadSolids::CutTubeRead(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadMaterials::DRead(), G4GDMLReadSolids::ElconeRead(), G4GDMLReadMaterials::ElementRead(), Ellipsoid_dimensionsRead(), G4GDMLReadSolids::EllipsoidRead(), G4GDMLReadSolids::EltubeRead(), G4GDMLReadDefine::ExpressionRead(), G4GDMLReadMaterials::FractionRead(), G4GDMLRead::GenerateName(), G4GDMLRead::GeneratePhysvolName(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), G4GDMLReadDefine::GetConstant(), G4GDMLReadDefine::GetVariable(), Hype_dimensionsRead(), G4GDMLReadSolids::HypeRead(), G4GDMLReadMaterials::IsotopeRead(), G4GDMLReadDefine::IsValidID(), G4GDMLRead::LoopRead(), G4GDMLReadMaterials::MaterialRead(), G4GDMLReadDefine::MatrixRead(), G4GDMLReadMaterials::MEERead(), G4GDMLReadSolids::OpticalSurfaceRead(), Orb_dimensionsRead(), G4GDMLReadSolids::OrbRead(), Para_dimensionsRead(), G4GDMLReadSolids::ParaboloidRead(), ParameterisedRead(), G4GDMLReadSolids::ParaRead(), G4GDMLReadStructure::PhysvolRead(), Polycone_dimensionsRead(), G4GDMLReadSolids::PolyconeRead(), Polyhedra_dimensionsRead(), G4GDMLReadSolids::PolyhedraRead(), G4GDMLReadDefine::PositionRead(), G4GDMLReadMaterials::PRead(), G4GDMLReadStructure::QuantityRead(), G4GDMLReadDefine::QuantityRead(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadSolids::RZPointRead(), G4GDMLReadDefine::ScaleRead(), G4GDMLReadSolids::SectionRead(), Sphere_dimensionsRead(), G4GDMLReadSolids::SphereRead(), Torus_dimensionsRead(), G4GDMLReadSolids::TorusRead(), Trap_dimensionsRead(), G4GDMLReadSolids::TrapRead(), Trd_dimensionsRead(), G4GDMLReadSolids::TrdRead(), G4GDMLReadMaterials::TRead(), Tube_dimensionsRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), G4GDMLReadSolids::TwoDimVertexRead(), G4GDMLReadDefine::VariableRead(), G4GDMLReadDefine::VectorRead(), G4GDMLReadStructure::Volume_contentRead(), and G4GDMLReadSolids::ZplaneRead().

inLoop

G4int G4GDMLRead::inLoop = 0

privateinherited

Definition at line 163 of file G4GDMLRead.hh.

Referenced by G4GDMLRead::GenerateName(), G4GDMLRead::LoopRead(), and G4GDMLRead::Read().

loopCount

G4int G4GDMLRead::loopCount = 0

privateinherited

Definition at line 163 of file G4GDMLRead.hh.

Referenced by G4GDMLRead::LoopRead().

mapOfMatPropVects

std::map<G4String, G4MaterialPropertyVector*> G4GDMLReadSolids::mapOfMatPropVects

privateinherited

Definition at line 126 of file G4GDMLReadSolids.hh.

Referenced by G4GDMLReadSolids::PropertyRead().

matrixMap

std::map<G4String, G4GDMLMatrix> G4GDMLReadDefine::matrixMap

protectedinherited

Definition at line 108 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadDefine::GetMatrix(), and G4GDMLReadDefine::MatrixRead().

parameterisation

G4GDMLParameterisation* G4GDMLReadParamvol::parameterisation = nullptr

protected

Definition at line 87 of file G4GDMLReadParamvol.hh.

Referenced by ParametersRead(), and ParamvolRead().

positionMap

std::map<G4String, G4ThreeVector> G4GDMLReadDefine::positionMap

protectedinherited

Definition at line 105 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadDefine::GetPosition(), and G4GDMLReadDefine::PositionRead().

quantityMap

std::map<G4String, G4double> G4GDMLReadDefine::quantityMap

protectedinherited

Definition at line 104 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadDefine::GetQuantity(), and G4GDMLReadDefine::QuantityRead().

reverseSearch

G4bool G4GDMLReadDefine::reverseSearch = false

protectedinherited

Definition at line 103 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadStructure::AssemblyRead(), G4GDMLReadStructure::GetPhysvol(), G4GDMLReadSolids::GetSolid(), G4GDMLReadStructure::GetVolume(), and G4GDMLReadDefine::SetReverseSearch().

rotationMap

std::map<G4String, G4ThreeVector> G4GDMLReadDefine::rotationMap

protectedinherited

Definition at line 106 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadDefine::GetRotation(), and G4GDMLReadDefine::RotationRead().

scaleMap

std::map<G4String, G4ThreeVector> G4GDMLReadDefine::scaleMap

protectedinherited

Definition at line 107 of file G4GDMLReadDefine.hh.

Referenced by G4GDMLReadDefine::GetScale(), and G4GDMLReadDefine::ScaleRead().

setupMap

std::map<G4String, G4String> G4GDMLReadSetup::setupMap

protectedinherited

Definition at line 58 of file G4GDMLReadSetup.hh.

Referenced by G4GDMLReadSetup::GetSetup(), and G4GDMLReadSetup::SetupRead().

validate

G4bool G4GDMLRead::validate = true

protectedinherited

Definition at line 157 of file G4GDMLRead.hh.

Referenced by G4GDMLReadStructure::FileRead(), and G4GDMLRead::Read().

---

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

• source/persistency/gdml/include/G4GDMLReadParamvol.hh
• source/persistency/gdml/src/G4GDMLReadParamvol.cc