G4GDMLReadSolids Class Reference

#include <G4GDMLReadSolids.hh>

Inheritance diagram for G4GDMLReadSolids:

Collaboration diagram for G4GDMLReadSolids:

Classes
struct	zplaneType

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

Protected Member Functions
	G4GDMLReadSolids ()
virtual	~G4GDMLReadSolids ()
void	BooleanRead (const xercesc::DOMElement *const, const BooleanOp)
void	BoxRead (const xercesc::DOMElement *const)
void	ConeRead (const xercesc::DOMElement *const)
void	ElconeRead (const xercesc::DOMElement *const)
void	EllipsoidRead (const xercesc::DOMElement *const)
void	EltubeRead (const xercesc::DOMElement *const)
void	XtruRead (const xercesc::DOMElement *const)
void	HypeRead (const xercesc::DOMElement *const)
void	MultiUnionNodeRead (const xercesc::DOMElement *const, G4MultiUnion *const)
void	MultiUnionRead (const xercesc::DOMElement *const)
void	OrbRead (const xercesc::DOMElement *const)
void	ParaRead (const xercesc::DOMElement *const)
void	ParaboloidRead (const xercesc::DOMElement *const)
void	PolyconeRead (const xercesc::DOMElement *const)
void	GenericPolyconeRead (const xercesc::DOMElement *const)
void	PolyhedraRead (const xercesc::DOMElement *const)
void	GenericPolyhedraRead (const xercesc::DOMElement *const)
G4QuadrangularFacet *	QuadrangularRead (const xercesc::DOMElement *const)
void	ReflectedSolidRead (const xercesc::DOMElement *const)
void	ScaledSolidRead (const xercesc::DOMElement *const)
G4ExtrudedSolid::ZSection	SectionRead (const xercesc::DOMElement *const, G4double)
void	SphereRead (const xercesc::DOMElement *const)
void	TessellatedRead (const xercesc::DOMElement *const)
void	TetRead (const xercesc::DOMElement *const)
void	TorusRead (const xercesc::DOMElement *const)
void	GenTrapRead (const xercesc::DOMElement *const)
void	TrapRead (const xercesc::DOMElement *const)
void	TrdRead (const xercesc::DOMElement *const)
void	TubeRead (const xercesc::DOMElement *const)
void	CutTubeRead (const xercesc::DOMElement *const)
void	TwistedboxRead (const xercesc::DOMElement *const)
void	TwistedtrapRead (const xercesc::DOMElement *const)
void	TwistedtrdRead (const xercesc::DOMElement *const)
void	TwistedtubsRead (const xercesc::DOMElement *const)
G4TriangularFacet *	TriangularRead (const xercesc::DOMElement *const)
G4TwoVector	TwoDimVertexRead (const xercesc::DOMElement *const, G4double)
zplaneType	ZplaneRead (const xercesc::DOMElement *const)
rzPointType	RZPointRead (const xercesc::DOMElement *const)
void	OpticalSurfaceRead (const xercesc::DOMElement *const)
Protected Member Functions inherited from G4GDMLReadMaterials
	G4GDMLReadMaterials ()
virtual	~G4GDMLReadMaterials ()
G4double	AtomRead (const xercesc::DOMElement *const)
G4int	CompositeRead (const xercesc::DOMElement *const, G4String &)
G4double	DRead (const xercesc::DOMElement *const)
G4double	PRead (const xercesc::DOMElement *const)
G4double	TRead (const xercesc::DOMElement *const)
G4double	MEERead (const xercesc::DOMElement *const)
void	ElementRead (const xercesc::DOMElement *const)
G4double	FractionRead (const xercesc::DOMElement *const, G4String &)
void	IsotopeRead (const xercesc::DOMElement *const)
void	MaterialRead (const xercesc::DOMElement *const)
void	MixtureRead (const xercesc::DOMElement *const, G4Element *)
void	MixtureRead (const xercesc::DOMElement *const, G4Material *)
void	PropertyRead (const xercesc::DOMElement *const, G4Material *)
Protected Member Functions inherited from G4GDMLReadDefine
	G4GDMLReadDefine ()
virtual	~G4GDMLReadDefine ()
G4RotationMatrix	GetRotationMatrix (const G4ThreeVector &)
void	VectorRead (const xercesc::DOMElement *const, G4ThreeVector &)
G4String	RefRead (const xercesc::DOMElement *const)
void	ConstantRead (const xercesc::DOMElement *const)
void	MatrixRead (const xercesc::DOMElement *const)
void	PositionRead (const xercesc::DOMElement *const)
void	RotationRead (const xercesc::DOMElement *const)
void	ScaleRead (const xercesc::DOMElement *const)
void	VariableRead (const xercesc::DOMElement *const)
void	QuantityRead (const xercesc::DOMElement *const)
void	ExpressionRead (const xercesc::DOMElement *const)
Protected Member Functions inherited from G4GDMLRead
	G4GDMLRead ()
virtual	~G4GDMLRead ()
G4String	Transcode (const XMLCh *const)
G4String	GenerateName (const G4String &name, G4bool strip=false)
G4String	Strip (const G4String &) const
void	GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)
void	LoopRead (const xercesc::DOMElement *const, void(G4GDMLRead::*)(const xercesc::DOMElement *const))
G4GDMLAuxStructType	AuxiliaryRead (const xercesc::DOMElement *const auxElem)

Additional Inherited Members
Protected Attributes inherited from G4GDMLReadDefine
std::map< G4String, G4double >	quantityMap
std::map< G4String, G4ThreeVector >	positionMap
std::map< G4String, G4ThreeVector >	rotationMap
std::map< G4String, G4ThreeVector >	scaleMap
std::map< G4String, G4GDMLMatrix >	matrixMap
Protected Attributes inherited from G4GDMLRead
G4GDMLEvaluator	eval
G4bool	validate
G4bool	check
G4bool	dostrip

Detailed Description

Definition at line 53 of file G4GDMLReadSolids.hh.

Constructor & Destructor Documentation

G4GDMLReadSolids::G4GDMLReadSolids ( )

protected

Definition at line 73 of file G4GDMLReadSolids.cc.

                                   : G4GDMLReadMaterials()
{
}

G4GDMLReadSolids::~G4GDMLReadSolids ( )

protectedvirtual

Definition at line 77 of file G4GDMLReadSolids.cc.

{
}

Member Function Documentation

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

protected

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)
      {
        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 != 0;iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }

      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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); }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 179 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 229 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 2029 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 297 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 348 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 404 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 977 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)
      {
        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 != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }

      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1156 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)
      {
        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 != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }

      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1714 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)
      {
        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") { 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4VSolid * G4GDMLReadSolids::GetSolid

(

const G4String &

ref

)

const

Definition at line 2655 of file G4GDMLReadSolids.cc.

{
   G4VSolid* solidPtr = G4SolidStore::GetInstance()->GetSolid(ref,false);

   if (!solidPtr)
   {
     G4String error_msg = "Referenced solid '" + ref + "' was not found!";
     G4Exception("G4GDMLReadSolids::GetSolid()", "ReadError",
                 FatalException, error_msg);
   }

   return solidPtr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4SurfaceProperty * G4GDMLReadSolids::GetSurfaceProperty

(

const G4String &

ref

)

const

Definition at line 2670 of file G4GDMLReadSolids.cc.

{
   const G4SurfacePropertyTable* surfaceList
         = G4SurfaceProperty::GetSurfacePropertyTable();
   const size_t surfaceCount = surfaceList->size();

   for (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 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 516 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 579 of file G4GDMLReadSolids.cc.

{
   G4Exception("G4GDMLReadSolids::MultiUnionNodeRead()",
               "InvalidSetup", FatalException,
               "Installation with USolids primitives required!");
   return;
}

Here is the call graph for this function:

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

protected

Definition at line 660 of file G4GDMLReadSolids.cc.

{
   G4Exception("G4GDMLReadSolids::MultiUnionRead()",
               "InvalidSetup", FatalException,
               "Installation with USolids primitives required!");
   return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 2470 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)
      {
        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 { 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 { finish = groundvm2000glue; }

   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_dichroic") || (stype=="3"))
      { type = dielectric_dichroic; } else
   if ((stype=="firsov") || (stype=="4"))
      { type = firsov; }
   else { type = x_ray; }

   new G4OpticalSurface(name,model,finish,type,value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 728 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 836 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 771 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 886 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)
      {
        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 != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }

      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1063 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)
      {
        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 != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }

      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1246 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)
      {
        G4Exception("G4GDMLReadSolids::QuadrangularRead()",
                    "InvalidRead", FatalException, "No attribute found!");
        return 0;
      }
      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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1301 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 2435 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)
      {
        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;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1367 of file G4GDMLReadSolids.cc.

{
   G4String name;
   G4VSolid* solid=0;
   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)
      {
        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 != 0; iter = iter->getNextSibling())
   {
     if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }

     const xercesc::DOMElement* const child
           = dynamic_cast<xercesc::DOMElement*>(iter);
     if (!child)
     {
       G4Exception("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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1435 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Implements G4GDMLRead.

Definition at line 2592 of file G4GDMLReadSolids.cc.

{
   G4cout << "G4GDML: Reading solids..." << G4endl;

   for (xercesc::DOMNode* iter = solidsElement->getFirstChild();
        iter != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }

      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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);
      }
   }
}

Here is the call graph for this function:

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

protected

Definition at line 1478 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1543 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)
      {
        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 != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }

      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1599 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1652 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1784 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1863 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1918 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)
      {
        G4Exception("G4GDMLReadSolids::TriangularRead()",
                    "InvalidRead", FatalException, "No attribute found!");
        return 0;
      }
      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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 1968 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 2100 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 2159 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 2240 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)
      {
        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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 2305 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;

   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)
      {
        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=="phi") { phi = eval.Evaluate(attValue); }
   }

   twistedangle *= aunit;
   endinnerrad *= lunit;
   endouterrad *= lunit;
   zlen *= 0.5*lunit;
   phi *= aunit;

   new G4TwistedTubs(name,twistedangle,endinnerrad,endouterrad,zlen,phi);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 2367 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)
      {
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 453 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)
      {
        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 != 0; iter = iter->getNextSibling())
   {
      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }

      const xercesc::DOMElement* const child
            = dynamic_cast<xercesc::DOMElement*>(iter);
      if (!child)
      {
        G4Exception("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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 2401 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)
      {
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• geant4.10.03.p01/source/persistency/gdml/include/G4GDMLReadSolids.hh
• geant4.10.03.p01/source/persistency/gdml/src/G4GDMLReadSolids.cc