G4GDMLRead Class Reference

#include <G4GDMLRead.hh>

Inheritance diagram for G4GDMLRead:

Collaboration diagram for G4GDMLRead:

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

Protected Member Functions
	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
G4GDMLEvaluator	eval
G4bool	validate
G4bool	check
G4bool	dostrip

Detailed Description

Definition at line 89 of file G4GDMLRead.hh.

Constructor & Destructor Documentation

G4GDMLRead::G4GDMLRead ( )

protected

Definition at line 45 of file G4GDMLRead.cc.

  : validate(true), check(false), dostrip(true), inLoop(0), loopCount(0)
{
   G4UnitDefinition::BuildUnitsTable();
}

Here is the call graph for this function:

G4GDMLRead::~G4GDMLRead ( )

protectedvirtual

Definition at line 51 of file G4GDMLRead.cc.

{
}

Member Function Documentation

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

protected

Definition at line 262 of file G4GDMLRead.cc.

{
   G4GDMLAuxStructType auxstruct = {"","","",0};
   G4GDMLAuxListType* auxList=0;
  
   const xercesc::DOMNamedNodeMap* const attributes
         = auxiliaryElement->getAttributes();
   XMLSize_t attributeCount = attributes->getLength();

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

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

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

      if (attName=="auxtype") { auxstruct.type = attValue; } else
      if (attName=="auxvalue") { auxstruct.value = attValue; } else
      if (attName=="auxunit") { auxstruct.unit = attValue; }
   }

   for (xercesc::DOMNode* iter = auxiliaryElement->getFirstChild();
        iter != 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::AuxiliaryRead()",
                     "InvalidRead", FatalException, "No child found!");
         break;
      }
      const G4String tag = Transcode(child->getTagName());
       
      if (tag=="auxiliary")
      {
         if(!auxList) { auxList = new G4GDMLAuxListType; }
         auxList->push_back(AuxiliaryRead(child));
      }
   }
   
   if (auxList) { auxstruct.auxList = auxList; }

   return auxstruct;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

pure virtual

Implemented in G4GDMLReadDefine.

Here is the caller graph for this function:

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

virtual

Definition at line 354 of file G4GDMLRead.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 68 of file G4GDMLRead.cc.

{
   G4String nameOut(nameIn);

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

Here is the call graph for this function:

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

protected

Definition at line 81 of file G4GDMLRead.cc.

{
   G4String nameOut(nameIn);

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

   physvol->SetName(nameOut);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const G4GDMLAuxListType * G4GDMLRead::GetAuxList

(

)

const

Definition at line 470 of file G4GDMLRead.cc.

{
   return &auxGlobalList;
}

virtual G4String G4GDMLRead::GetSetup ( const G4String &  )

pure virtual

Implemented in G4GDMLReadSetup.

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

pure virtual

Implemented in G4GDMLReadStructure.

Here is the caller graph for this function:

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

protected

Definition at line 176 of file G4GDMLRead.cc.

{
   G4String var;
   G4String from;
   G4String to;
   G4String step;

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

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

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

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

      if (attribute_name=="for")  { var = attribute_value; }  else
      if (attribute_name=="from") { from = attribute_value; } else
      if (attribute_name=="to")   { to = attribute_value; }   else
      if (attribute_name=="step") { step = attribute_value; }
   }

   if (var.empty())
   {
     G4Exception("G4GDMLRead::loopRead()", "InvalidRead",
                 FatalException, "No variable is determined for loop!");
   }

   if (!eval.IsVariable(var))
   {
     G4Exception("G4GDMLRead::loopRead()", "InvalidRead",
                 FatalException, "Variable is not defined in loop!");
   }

   G4int _var = eval.EvaluateInteger(var);
   G4int _from = eval.EvaluateInteger(from);
   G4int _to = eval.EvaluateInteger(to);
   G4int _step = eval.EvaluateInteger(step);
   
   if (!from.empty()) { _var = _from; }

   if (_from == _to)
   {
     G4Exception("G4GDMLRead::loopRead()", "InvalidRead",
                 FatalException, "Empty loop!");
   }
   if ((_from < _to) && (_step <= 0))
   {
     G4Exception("G4GDMLRead::loopRead()", "InvalidRead",
                 FatalException, "Infinite loop!");
   }
   if ((_from > _to) && (_step >= 0))
   {
     G4Exception("G4GDMLRead::loopRead()", "InvalidRead",
                 FatalException, "Infinite loop!");
   }

   inLoop++;

   while (_var <= _to)
   {
      eval.SetVariable(var,_var);
      (this->*func)(element);
      _var += _step;
      loopCount++;
   }

   inLoop--;
   if (!inLoop) { loopCount = 0; }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

pure virtual

Implemented in G4GDMLReadMaterials.

Here is the caller graph for this function:

void G4GDMLRead::OverlapCheck

(

G4bool

flag

)

Definition at line 63 of file G4GDMLRead.cc.

{
   check = flag;
}

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

pure virtual

Implemented in G4GDMLReadParamvol.

Here is the caller graph for this function:

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

Definition at line 361 of file G4GDMLRead.cc.

{
   dostrip = strip;
   if (isModule)
   {
      G4cout << "G4GDML: Reading module '" << fileName << "'..." << G4endl;
   }
   else
   {
      G4cout << "G4GDML: Reading '" << fileName << "'..." << G4endl;
   }

   inLoop = 0;
   validate = validation;

   xercesc::ErrorHandler* handler = new G4GDMLErrorHandler(!validate);
   xercesc::XercesDOMParser* parser = new xercesc::XercesDOMParser;

   if (validate)
   {
     parser->setValidationScheme(xercesc::XercesDOMParser::Val_Always);
   }
   parser->setValidationSchemaFullChecking(validate);
   parser->setCreateEntityReferenceNodes(false); 
     // Entities will be automatically resolved by Xerces

   parser->setDoNamespaces(true);
   parser->setDoSchema(validate);
   parser->setErrorHandler(handler);

   try { parser->parse(fileName.c_str()); }
   catch (const xercesc::XMLException &e)
     { G4cout << "G4GDML: " << Transcode(e.getMessage()) << G4endl; }
   catch (const xercesc::DOMException &e)
     { G4cout << "G4GDML: " << Transcode(e.getMessage()) << G4endl; }

   xercesc::DOMDocument* doc = parser->getDocument();

   if (!doc)
   {
     G4String error_msg = "Unable to open document: " + fileName;
     G4Exception("G4GDMLRead::Read()", "InvalidRead",
                 FatalException, error_msg);
     return;
   }
   xercesc::DOMElement* element = doc->getDocumentElement();

   if (!element)
   {
     std::ostringstream message;
     message << "ERROR - Empty document or unable to validate schema!" << G4endl
             << "        Check Internet connection is ON in case of schema"
             << G4endl
             << "        validation enabled and location defined as URL in"
             << G4endl
             << "        the GDML file - " << fileName << " - being imported!"
             << G4endl
             << "        Otherwise, verify GDML schema server is reachable!";
     G4Exception("G4GDMLRead::Read()", "InvalidRead", FatalException, message);
     return;
   }

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

      if (tag=="define")    { DefineRead(child);    } else
      if (tag=="materials") { MaterialsRead(child); } else
      if (tag=="solids")    { SolidsRead(child);    } else
      if (tag=="setup")     { SetupRead(child);     } else
      if (tag=="structure") { StructureRead(child); } else
      if (tag=="userinfo")  { UserinfoRead(child);  } else
      if (tag=="extension") { ExtensionRead(child); }
      else
      {
        G4String error_msg = "Unknown tag in gdml: " + tag;
        G4Exception("G4GDMLRead::Read()", "InvalidRead",
                    FatalException, error_msg);
      }
   }

   delete parser;
   delete handler;

   if (isModule)
   {
      G4cout << "G4GDML: Reading module '" << fileName << "' done!" << G4endl;
   }
   else
   {
      G4cout << "G4GDML: Reading '" << fileName << "' done!" << G4endl;
      if (strip)  { StripNames(); }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

pure virtual

Implemented in G4GDMLReadSetup.

Here is the caller graph for this function:

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

pure virtual

Implemented in G4GDMLReadSolids.

Here is the caller graph for this function:

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

protected

Definition at line 97 of file G4GDMLRead.cc.

{
  G4String sname(name);
  return sname.remove(sname.find("0x"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4GDMLRead::StripName

(

G4String &

name

)

const

Definition at line 103 of file G4GDMLRead.cc.

{
  name.remove(name.find("0x"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4GDMLRead::StripNames

(

)

const

Definition at line 108 of file G4GDMLRead.cc.

{
  // Strips off names of volumes, solids elements and materials from possible
  // reference pointers or IDs attached to their original identifiers.

  G4PhysicalVolumeStore* pvols = G4PhysicalVolumeStore::GetInstance();
  G4LogicalVolumeStore* lvols = G4LogicalVolumeStore::GetInstance();
  G4SolidStore* solids = G4SolidStore::GetInstance();
  const G4ElementTable* elements = G4Element::GetElementTable();
  const G4MaterialTable* materials = G4Material::GetMaterialTable();

  G4cout << "Stripping off GDML names of materials, solids and volumes ..."
         << G4endl;

  G4String sname;
  size_t i;

  // Solids...
  //
  for (i=0; i<solids->size(); ++i)
  {
    G4VSolid* psol = (*solids)[i];
    sname = psol->GetName();
    StripName(sname);
    psol->SetName(sname);
  }

  // Logical volumes...
  //
  for (i=0; i<lvols->size(); ++i)
  {
    G4LogicalVolume* lvol = (*lvols)[i];
    sname = lvol->GetName();
    StripName(sname);
    lvol->SetName(sname);
  }

  // Physical volumes...
  //
  for (i=0; i<pvols->size(); ++i)
  {
    G4VPhysicalVolume* pvol = (*pvols)[i];
    sname = pvol->GetName();
    StripName(sname);
    pvol->SetName(sname);
  }

  // Materials...
  //
  for (i=0; i<materials->size(); ++i)
  {
    G4Material* pmat = (*materials)[i];
    sname = pmat->GetName();
    StripName(sname);
    pmat->SetName(sname);
  }

  // Elements...
  //
  for (i=0; i<elements->size(); ++i)
  {
    G4Element* pelm = (*elements)[i];
    sname = pelm->GetName();
    StripName(sname);
    pelm->SetName(sname);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

pure virtual

Implemented in G4GDMLReadStructure.

Here is the caller graph for this function:

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

protected

Definition at line 55 of file G4GDMLRead.cc.

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

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

virtual

Definition at line 322 of file G4GDMLRead.cc.

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

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

      if (tag=="auxiliary")
      {
        auxGlobalList.push_back(AuxiliaryRead(child));
      }
      else
      {
        G4String error_msg = "Unknown tag in structure: " + tag;
        G4Exception("G4GDMLRead::UserinfoRead()",
                    "ReadError", FatalException, error_msg);
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

pure virtual

Implemented in G4GDMLReadStructure.

Here is the caller graph for this function:

Member Data Documentation

G4bool G4GDMLRead::check

protected

Definition at line 157 of file G4GDMLRead.hh.

G4bool G4GDMLRead::dostrip

protected

Definition at line 158 of file G4GDMLRead.hh.

G4GDMLEvaluator G4GDMLRead::eval

protected

Definition at line 155 of file G4GDMLRead.hh.

G4bool G4GDMLRead::validate

protected

Definition at line 156 of file G4GDMLRead.hh.

---

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

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