G4GDMLReadDefine Class Reference

#include <G4GDMLReadDefine.hh>

Inheritance diagram for G4GDMLReadDefine:

Collaboration diagram for G4GDMLReadDefine:

Public Member Functions
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	MaterialsRead (const xercesc::DOMElement *const)=0
virtual void	SetupRead (const xercesc::DOMElement *const)=0
virtual void	SolidsRead (const xercesc::DOMElement *const)=0
virtual void	Paramvol_contentRead (const xercesc::DOMElement *const)=0
virtual void	Volume_contentRead (const xercesc::DOMElement *const)=0
virtual void	StructureRead (const xercesc::DOMElement *const)=0
virtual void	ExtensionRead (const xercesc::DOMElement *const)
virtual void	UserinfoRead (const xercesc::DOMElement *const)
virtual G4LogicalVolume *	GetVolume (const G4String &) const =0
virtual G4String	GetSetup (const G4String &)=0
void	Read (const G4String &, G4bool validation, G4bool isModule, G4bool strip=true)
void	StripNames () const
void	StripName (G4String &) const
void	OverlapCheck (G4bool)
const G4GDMLAuxListType *	GetAuxList () const

Protected Member Functions
	G4GDMLReadDefine ()
virtual	~G4GDMLReadDefine ()
G4RotationMatrix	GetRotationMatrix (const G4ThreeVector &)
void	VectorRead (const xercesc::DOMElement *const, G4ThreeVector &)
G4String	RefRead (const xercesc::DOMElement *const)
void	ConstantRead (const xercesc::DOMElement *const)
void	MatrixRead (const xercesc::DOMElement *const)
void	PositionRead (const xercesc::DOMElement *const)
void	RotationRead (const xercesc::DOMElement *const)
void	ScaleRead (const xercesc::DOMElement *const)
void	VariableRead (const xercesc::DOMElement *const)
void	QuantityRead (const xercesc::DOMElement *const)
void	ExpressionRead (const xercesc::DOMElement *const)
Protected Member Functions inherited from G4GDMLRead
	G4GDMLRead ()
virtual	~G4GDMLRead ()
G4String	Transcode (const XMLCh *const)
G4String	GenerateName (const G4String &name, G4bool strip=false)
G4String	Strip (const G4String &) const
void	GeneratePhysvolName (const G4String &, G4VPhysicalVolume *)
void	LoopRead (const xercesc::DOMElement *const, void(G4GDMLRead::*)(const xercesc::DOMElement *const))
G4GDMLAuxStructType	AuxiliaryRead (const xercesc::DOMElement *const auxElem)

Protected Attributes
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 69 of file G4GDMLReadDefine.hh.

Constructor & Destructor Documentation

G4GDMLReadDefine::G4GDMLReadDefine ( )

protected

Definition at line 124 of file G4GDMLReadDefine.cc.

                                   : G4GDMLRead()
{
}

G4GDMLReadDefine::~G4GDMLReadDefine ( )

protectedvirtual

Definition at line 128 of file G4GDMLReadDefine.cc.

{
}

Member Function Documentation

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

protected

Definition at line 146 of file G4GDMLReadDefine.cc.

{
   G4String name  = "";
   G4double value = 0.0;

   const xercesc::DOMNamedNodeMap* const attributes
         = constantElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);

      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }

      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::ConstantRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());

      if (attName=="name")  { name = attValue; }  else
      if (attName=="value") { value = eval.Evaluate(attValue); }
   }

   eval.DefineConstant(name,value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Implements G4GDMLRead.

Definition at line 467 of file G4GDMLReadDefine.cc.

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

   for (xercesc::DOMNode* iter = defineElement->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("G4GDMLRead::DefineRead()", "InvalidRead",
                    FatalException, "No child found!");
        return;
      }
      const G4String tag = Transcode(child->getTagName());

      if (tag=="constant") { ConstantRead(child); } else
      if (tag=="matrix")   { MatrixRead(child); }   else
      if (tag=="position") { PositionRead(child); } else
      if (tag=="rotation") { RotationRead(child); } else
      if (tag=="scale")    { ScaleRead(child); }    else
      if (tag=="variable") { VariableRead(child); } else
      if (tag=="quantity") { QuantityRead(child); } else
      if (tag=="expression") { ExpressionRead(child); }
      else
      {
        G4String error_msg = "Unknown tag in define: "+tag;
        G4Exception("G4GDMLReadDefine::defineRead()", "ReadError",
                    FatalException, error_msg);
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 181 of file G4GDMLReadDefine.cc.

{
   G4String name  = "";
   G4double value = 0.0;

   const xercesc::DOMNamedNodeMap* const attributes
         = expElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);

      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }

      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::ExpressionRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());

      if (attName=="name")  { name = attValue; }
   }

   const G4String expValue = Transcode(expElement->getTextContent());
   value = eval.Evaluate(expValue);
   eval.DefineConstant(name,value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4GDMLReadDefine::GetConstant

(

const G4String &

ref

)

Definition at line 578 of file G4GDMLReadDefine.cc.

{
   return eval.GetConstant(ref);
}

Here is the call graph for this function:

G4GDMLMatrix G4GDMLReadDefine::GetMatrix

(

const G4String &

ref

)

Definition at line 632 of file G4GDMLReadDefine.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4ThreeVector G4GDMLReadDefine::GetPosition

(

const G4String &

ref

)

Definition at line 599 of file G4GDMLReadDefine.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4GDMLReadDefine::GetQuantity

(

const G4String &

ref

)

Definition at line 588 of file G4GDMLReadDefine.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4ThreeVector G4GDMLReadDefine::GetRotation

(

const G4String &

ref

)

Definition at line 610 of file G4GDMLReadDefine.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4RotationMatrix G4GDMLReadDefine::GetRotationMatrix ( const G4ThreeVector &  angles )

protected

Definition at line 133 of file G4GDMLReadDefine.cc.

{
   G4RotationMatrix rot;

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

   return rot;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4ThreeVector G4GDMLReadDefine::GetScale

(

const G4String &

ref

)

Definition at line 621 of file G4GDMLReadDefine.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4GDMLReadDefine::GetVariable

(

const G4String &

ref

)

Definition at line 583 of file G4GDMLReadDefine.cc.

{
   return eval.GetVariable(ref);
}

Here is the call graph for this function:

G4bool G4GDMLReadDefine::IsValidID

(

const G4String &

ref

)

const

Definition at line 573 of file G4GDMLReadDefine.cc.

{
   return eval.IsVariable(ref);
}

Here is the call graph for this function:

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

protected

Definition at line 217 of file G4GDMLReadDefine.cc.

{
   G4String name = "";
   G4int coldim  = 0;
   G4String values = "";

   const xercesc::DOMNamedNodeMap* const attributes
         = matrixElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);

      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }

      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::MatrixRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());

      if (attName=="name")   { name  = GenerateName(attValue); } else
      if (attName=="coldim") { coldim = eval.EvaluateInteger(attValue); } else
      if (attName=="values") { values = attValue; }
   }

   std::stringstream MatrixValueStream(values);
   std::vector<G4double> valueList;

   while (!MatrixValueStream.eof())
   {
      G4String MatrixValue;
      MatrixValueStream >> MatrixValue;
      valueList.push_back(eval.Evaluate(MatrixValue));
   }

   eval.DefineMatrix(name,coldim,valueList);

   G4GDMLMatrix matrix(valueList.size()/coldim,coldim);

   for (size_t i=0;i<valueList.size();i++)
   {
      matrix.Set(i/coldim,i%coldim,valueList[i]);
   }

   matrixMap[name] = matrix;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 273 of file G4GDMLReadDefine.cc.

{
   G4String name = "";
   G4double unit = 1.0;
   G4ThreeVector position(0.,0.,0.);

   const xercesc::DOMNamedNodeMap* const attributes
         = positionElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);

      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }

      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::PositionRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());

      if (attName=="name") { name = GenerateName(attValue); }  else
      if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue);
    if (G4UnitDefinition::GetCategory(attValue)!="Length") {
      G4Exception("G4GDMLReadDefine::PositionRead()", "InvalidRead",
              FatalException, "Invalid unit for length!");  }     
      } else
      if (attName=="x") { position.setX(eval.Evaluate(attValue)); } else
      if (attName=="y") { position.setY(eval.Evaluate(attValue)); } else
      if (attName=="z") { position.setZ(eval.Evaluate(attValue)); }
   }

   positionMap[name] = position*unit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 429 of file G4GDMLReadDefine.cc.

{
   G4String name = "";
   G4double unit = 1.0;
   G4double value = 0.0;

   const xercesc::DOMNamedNodeMap* const attributes
         = element->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);

      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }

      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::QuantityRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());

      if (attName=="name") { name = attValue; } else
      if (attName=="value") { value = eval.Evaluate(attValue); } else
      if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); }
   }

   quantityMap[name] = value*unit;
   eval.DefineConstant(name,value*unit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 541 of file G4GDMLReadDefine.cc.

{
   G4String ref;

   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);

      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
      { continue; }

      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::Read()", "InvalidRead",
                    FatalException, "No attribute found!");
        return ref;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());

      if (attName=="ref") { ref = attValue; }
   }

   return ref;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 316 of file G4GDMLReadDefine.cc.

{
   G4String name = "";
   G4double unit = 1.0;
   G4ThreeVector rotation(0.,0.,0.);

   const xercesc::DOMNamedNodeMap* const attributes
         = rotationElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);

      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }

      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::RotationRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());

      if (attName=="name") { name = GenerateName(attValue); }  else
      if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue);
    if (G4UnitDefinition::GetCategory(attValue)!="Angle") {
      G4Exception("G4GDMLReadDefine::RotationRead()", "InvalidRead",
              FatalException, "Invalid unit for angle!");  }
      } else
    if (attName=="x") { rotation.setX(eval.Evaluate(attValue)); } else
      if (attName=="y") { rotation.setY(eval.Evaluate(attValue)); } else
      if (attName=="z") { rotation.setZ(eval.Evaluate(attValue)); }
   }

   rotationMap[name] = rotation*unit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 358 of file G4GDMLReadDefine.cc.

{
   G4String name = "";
   G4ThreeVector scale(1.0,1.0,1.0);

   const xercesc::DOMNamedNodeMap* const attributes
         = scaleElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);

      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }

      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::ScaleRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());

      if (attName=="name") { name = GenerateName(attValue); }    else
      if (attName=="x") { scale.setX(eval.Evaluate(attValue)); } else
      if (attName=="y") { scale.setY(eval.Evaluate(attValue)); } else
      if (attName=="z") { scale.setZ(eval.Evaluate(attValue)); }
   }

   scaleMap[name] = scale;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 395 of file G4GDMLReadDefine.cc.

{
   G4String name  = "";
   G4double value = 0.0;

   const xercesc::DOMNamedNodeMap* const attributes
         = variableElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* node = attributes->item(attribute_index);

      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }

      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::VariableRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());

      if (attName=="name")  { name = attValue; } else
      if (attName=="value") { value = eval.Evaluate(attValue); }
   }

   eval.DefineVariable(name,value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 504 of file G4GDMLReadDefine.cc.

{
   G4double unit = 1.0;

   const xercesc::DOMNamedNodeMap* const attributes
         = vectorElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

   for (XMLSize_t attribute_index=0;
        attribute_index<attributeCount; attribute_index++)
   {
      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);

      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
      { continue; }

      const xercesc::DOMAttr* const attribute
            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
      if (!attribute)
      {
        G4Exception("G4GDMLRead::VectorRead()", "InvalidRead",
                    FatalException, "No attribute found!");
        return;
      }
      const G4String attName = Transcode(attribute->getName());
      const G4String attValue = Transcode(attribute->getValue());

      if (attName=="unit") { unit = G4UnitDefinition::GetValueOf(attValue); } else
      if (attName=="x") { vec.setX(eval.Evaluate(attValue)); } else
      if (attName=="y") { vec.setY(eval.Evaluate(attValue)); } else
      if (attName=="z") { vec.setZ(eval.Evaluate(attValue)); }
   }

   vec *= unit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

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

protected

Definition at line 109 of file G4GDMLReadDefine.hh.

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

protected

Definition at line 106 of file G4GDMLReadDefine.hh.

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

protected

Definition at line 105 of file G4GDMLReadDefine.hh.

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

protected

Definition at line 107 of file G4GDMLReadDefine.hh.

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

protected

Definition at line 108 of file G4GDMLReadDefine.hh.

---

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

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