#include <G4GDMLWrite.hh>

Inheritance diagram for G4GDMLWrite:

Collaboration diagram for G4GDMLWrite:

Public Member Functions
G4Transform3D	Write (const G4String &filename, const G4LogicalVolume *const topLog, const G4String &schemaPath, const G4int depth, G4bool storeReferences=true)

void	AddModule (const G4VPhysicalVolume *const topVol)

void	AddModule (const G4int depth)

void	AddAuxiliary (G4GDMLAuxStructType myaux)

virtual void	DefineWrite (xercesc::DOMElement *)=0

virtual void	MaterialsWrite (xercesc::DOMElement *)=0

virtual void	SolidsWrite (xercesc::DOMElement *)=0

virtual void	StructureWrite (xercesc::DOMElement *)=0

virtual G4Transform3D	TraverseVolumeTree (const G4LogicalVolume *const, const G4int)=0

virtual void	SurfacesWrite ()=0

virtual void	SetupWrite (xercesc::DOMElement , const G4LogicalVolume const)=0

virtual void	ExtensionWrite (xercesc::DOMElement *)

virtual void	UserinfoWrite (xercesc::DOMElement *)

virtual void	AddExtension (xercesc::DOMElement , const G4LogicalVolume const)

G4String	GenerateName (const G4String &, const void *const)

Static Public Member Functions
static void	SetAddPointerToName (G4bool)

Protected Member Functions
	G4GDMLWrite ()

virtual	~G4GDMLWrite ()

VolumeMapType &	VolumeMap ()

xercesc::DOMAttr *	NewAttribute (const G4String &, const G4String &)

xercesc::DOMAttr *	NewAttribute (const G4String &, const G4double &)

xercesc::DOMElement *	NewElement (const G4String &)

G4String	Modularize (const G4VPhysicalVolume *const topvol, const G4int depth)

void	AddAuxInfo (G4GDMLAuxListType auxInfoList, xercesc::DOMElement element)

G4bool	FileExists (const G4String &) const

PhysVolumeMapType &	PvolumeMap ()

DepthMapType &	DepthMap ()

Protected Attributes
G4String	SchemaLocation

xercesc::DOMDocument *	doc

xercesc::DOMElement *	extElement

xercesc::DOMElement *	userinfoElement

XMLCh	tempStr [10000]

G4GDMLAuxListType	auxList

Static Protected Attributes
static G4bool	addPointerToName = true

Detailed Description

Definition at line 57 of file G4GDMLWrite.hh.

Constructor & Destructor Documentation

G4GDMLWrite::G4GDMLWrite ( )

protected

Definition at line 46 of file G4GDMLWrite.cc.

                          : doc(0), extElement(0)
 {
 }

G4GDMLWrite::~G4GDMLWrite ( )

protectedvirtual

Definition at line 50 of file G4GDMLWrite.cc.

51 {

52 }

Member Function Documentation

void G4GDMLWrite::AddAuxiliary ( G4GDMLAuxStructType myaux )

Definition at line 349 of file G4GDMLWrite.cc.

 {
    auxList.push_back(myaux);
 }

void G4GDMLWrite::AddAuxInfo	(	G4GDMLAuxListType *	auxInfoList,
		xercesc::DOMElement *	element
	)

protected

Definition at line 90 of file G4GDMLWrite.cc.

 {
   for(std::vector<G4GDMLAuxStructType>::const_iterator
       iaux = auxInfoList->begin(); iaux != auxInfoList->end(); iaux++ )
   {
     xercesc::DOMElement* auxiliaryElement = NewElement("auxiliary");
     element->appendChild(auxiliaryElement);
       
     auxiliaryElement->setAttributeNode(NewAttribute("auxtype", (*iaux).type));
     auxiliaryElement->setAttributeNode(NewAttribute("auxvalue", (*iaux).value));
     if (((*iaux).unit)!="")
     {
       auxiliaryElement->setAttributeNode(NewAttribute("auxunit", (*iaux).unit));
     }
 
     if (iaux->auxList)  { AddAuxInfo(iaux->auxList, auxiliaryElement); }
   }
   return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4GDMLWrite::AddExtension	(	xercesc::DOMElement *	,
		const G4LogicalVolume * const
	)

virtual

Definition at line 78 of file G4GDMLWrite.cc.

 {
    // Empty implementation. To be overwritten by user for specific extensions
    // related to attributes associated to volumes
 }

Here is the caller graph for this function:

void G4GDMLWrite::AddModule ( const G4VPhysicalVolume *const topVol )

Definition at line 281 of file G4GDMLWrite.cc.

 {
    G4String fname = GenerateName(physvol->GetName(),physvol);
    G4cout << "G4GDML: Adding module '" << fname << "'..." << G4endl;
 
    if (physvol == 0)
    {
      G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                  "Invalid NULL pointer is specified for modularization!");
      return;
    }
    if (dynamic_cast<const G4PVDivision*>(physvol))
    {
      G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                  "It is not possible to modularize by divisionvol!");
      return;
    }
    if (physvol->IsParameterised())
    {
      G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                  "It is not possible to modularize by parameterised volume!");
      return;
    }
    if (physvol->IsReplicated())
    {
      G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                  "It is not possible to modularize by replicated volume!");
      return;
    }
 
    PvolumeMap()[physvol] = fname;
 }

Here is the call graph for this function:

void G4GDMLWrite::AddModule ( const G4int depth )

Definition at line 314 of file G4GDMLWrite.cc.

 {
    if (depth<0)
    {
      G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                  "Depth must be a positive number!");
    }
    if (DepthMap().find(depth) != DepthMap().end())
    {
      G4Exception("G4GDMLWrite::AddModule()", "InvalidSetup", FatalException,
                  "Adding module(s) at this depth is already requested!");
    }
    DepthMap()[depth] = 0;
 }

Here is the call graph for this function:

virtual void G4GDMLWrite::DefineWrite ( xercesc::DOMElement * )

pure virtual

Implemented in G4GDMLWriteDefine.

Here is the caller graph for this function:

G4GDMLWrite::DepthMapType & G4GDMLWrite::DepthMap ( )

protected

Definition at line 72 of file G4GDMLWrite.cc.

 {
    static DepthMapType instance;
    return instance;
 }

Here is the caller graph for this function:

void G4GDMLWrite::ExtensionWrite ( xercesc::DOMElement * )

virtual

Definition at line 85 of file G4GDMLWrite.cc.

 {
    // Empty implementation. To be overwritten by user for specific extensions
 }

Here is the caller graph for this function:

G4bool G4GDMLWrite::FileExists ( const G4String & fname ) const

protected

Definition at line 54 of file G4GDMLWrite.cc.

 {
   struct stat FileInfo;
   return (stat(fname.c_str(),&FileInfo) == 0); 
 }

Here is the caller graph for this function:

G4String G4GDMLWrite::GenerateName	(	const G4String &	name,
		const void * const	ptr
	)

Definition at line 123 of file G4GDMLWrite.cc.

 {
    G4String nameOut;
    std::stringstream stream; stream << name;
    if (addPointerToName) { stream << ptr; };
 
    nameOut=G4String(stream.str());
    if(nameOut.contains(' '))
    nameOut.erase(std::remove(nameOut.begin(),nameOut.end(),' '),nameOut.end());
 
    return nameOut;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void G4GDMLWrite::MaterialsWrite ( xercesc::DOMElement * )

pure virtual

Implemented in G4GDMLWriteMaterials.

Here is the caller graph for this function:

G4String G4GDMLWrite::Modularize	(	const G4VPhysicalVolume *const	topvol,
		const G4int	depth
	)

protected

Definition at line 329 of file G4GDMLWrite.cc.

 {
    if (PvolumeMap().find(physvol) != PvolumeMap().end())
    {
      return PvolumeMap()[physvol]; // Modularize via physvol
    }
 
    if (DepthMap().find(depth) != DepthMap().end()) // Modularize via depth
    {
      std::stringstream stream;
      stream << "depth" << depth << "_module" << DepthMap()[depth] << ".gdml";
      DepthMap()[depth]++;           // There can be more modules at this depth!
      return G4String(stream.str());
    }
 
    return G4String(""); // Empty string for module name = no modularization
                         // was requested at that level/physvol!
 }

Here is the call graph for this function:

Here is the caller graph for this function:

xercesc::DOMAttr * G4GDMLWrite::NewAttribute	(	const G4String &	name,
		const G4String &	value
	)

protected

Definition at line 136 of file G4GDMLWrite.cc.

 {
    xercesc::XMLString::transcode(name,tempStr,9999);
    xercesc::DOMAttr* att = doc->createAttribute(tempStr);
    xercesc::XMLString::transcode(value,tempStr,9999);
    att->setValue(tempStr);
    return att;
 }

xercesc::DOMAttr * G4GDMLWrite::NewAttribute	(	const G4String &	name,
		const G4double &	value
	)

protected

Definition at line 146 of file G4GDMLWrite.cc.

 {
    xercesc::XMLString::transcode(name,tempStr,9999);
    xercesc::DOMAttr* att = doc->createAttribute(tempStr);
    std::ostringstream ostream;
    ostream.precision(15);
    ostream << value;
    G4String str = ostream.str();
    xercesc::XMLString::transcode(str,tempStr,9999);
    att->setValue(tempStr);
    return att;
 }

xercesc::DOMElement * G4GDMLWrite::NewElement ( const G4String & name )

protected

Definition at line 160 of file G4GDMLWrite.cc.

 {
    xercesc::XMLString::transcode(name,tempStr,9999);
    return doc->createElement(tempStr);
 }

G4GDMLWrite::PhysVolumeMapType & G4GDMLWrite::PvolumeMap ( )

protected

Definition at line 66 of file G4GDMLWrite.cc.

 {
    static PhysVolumeMapType instance;
    return instance;
 }

Here is the caller graph for this function:

void G4GDMLWrite::SetAddPointerToName ( G4bool set )

static

Definition at line 354 of file G4GDMLWrite.cc.

 {
    addPointerToName = set;
 }

virtual void G4GDMLWrite::SetupWrite	(	xercesc::DOMElement *	,
		const G4LogicalVolume *	const
	)

pure virtual

Implemented in G4GDMLWriteSetup.

Here is the caller graph for this function:

virtual void G4GDMLWrite::SolidsWrite ( xercesc::DOMElement * )

pure virtual

Implemented in G4GDMLWriteSolids.

Here is the caller graph for this function:

virtual void G4GDMLWrite::StructureWrite ( xercesc::DOMElement * )

pure virtual

Implemented in G4GDMLWriteStructure.

Here is the caller graph for this function:

virtual void G4GDMLWrite::SurfacesWrite ( )

pure virtual

Implemented in G4GDMLWriteStructure.

Here is the caller graph for this function:

virtual G4Transform3D G4GDMLWrite::TraverseVolumeTree	(	const G4LogicalVolume *	const,
		const G4int
	)

pure virtual

Implemented in G4GDMLWriteStructure.

Here is the caller graph for this function:

void G4GDMLWrite::UserinfoWrite ( xercesc::DOMElement * gdmlElement )

virtual

Definition at line 111 of file G4GDMLWrite.cc.

 {
   if(auxList.size()>0)
   {
     G4cout << "G4GDML: Writing userinfo..." << G4endl;
       
     userinfoElement = NewElement("userinfo");
     gdmlElement->appendChild(userinfoElement);
     AddAuxInfo(&auxList, userinfoElement);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4GDMLWrite::VolumeMapType & G4GDMLWrite::VolumeMap ( )

protected

Definition at line 60 of file G4GDMLWrite.cc.

 {
    static VolumeMapType instance;
    return instance;
 }

Here is the caller graph for this function:

G4Transform3D G4GDMLWrite::Write	(	const G4String &	filename,
		const G4LogicalVolume *const	topLog,
		const G4String &	schemaPath,
		const G4int	depth,
		G4bool	storeReferences = `true`
	)

Definition at line 166 of file G4GDMLWrite.cc.

 {
    SchemaLocation = setSchemaLocation;
    addPointerToName = refs;
 
    if (depth==0) { G4cout << "G4GDML: Writing '" << fname << "'..." << G4endl; }
    else   { G4cout << "G4GDML: Writing module '" << fname << "'..." << G4endl; }
    
    if (FileExists(fname))
    {
      G4String ErrorMessage = "File '"+fname+"' already exists!";
      G4Exception("G4GDMLWrite::Write()", "InvalidSetup",
                  FatalException, ErrorMessage);
    }
    
    VolumeMap().clear(); // The module map is global for all modules,
                         // so clear it only at once!
 
    xercesc::XMLString::transcode("LS", tempStr, 9999);
      xercesc::DOMImplementationRegistry::getDOMImplementation(tempStr);
    xercesc::XMLString::transcode("Range", tempStr, 9999);
    xercesc::DOMImplementation* impl =
      xercesc::DOMImplementationRegistry::getDOMImplementation(tempStr);
    xercesc::XMLString::transcode("gdml", tempStr, 9999);
    doc = impl->createDocument(0,tempStr,0);
    xercesc::DOMElement* gdml = doc->getDocumentElement();
 
 #if XERCES_VERSION_MAJOR >= 3
                                              // DOM L3 as per Xerces 3.0 API
     xercesc::DOMLSSerializer* writer =
       ((xercesc::DOMImplementationLS*)impl)->createLSSerializer();
 
     xercesc::DOMConfiguration *dc = writer->getDomConfig();
     dc->setParameter(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint, true);
 
 #else
 
    xercesc::DOMWriter* writer =
      ((xercesc::DOMImplementationLS*)impl)->createDOMWriter();
 
    if (writer->canSetFeature(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint, true))
        writer->setFeature(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint, true);
 
 #endif
 
    gdml->setAttributeNode(NewAttribute("xmlns:xsi",
                           "http://www.w3.org/2001/XMLSchema-instance"));
    gdml->setAttributeNode(NewAttribute("xsi:noNamespaceSchemaLocation",
                           SchemaLocation));
 
    ExtensionWrite(gdml);
    DefineWrite(gdml);
    MaterialsWrite(gdml);
    SolidsWrite(gdml);
    StructureWrite(gdml);
    UserinfoWrite(gdml);
    SetupWrite(gdml,logvol);
 
    G4Transform3D R = TraverseVolumeTree(logvol,depth);
 
    SurfacesWrite();
    xercesc::XMLFormatTarget *myFormTarget =
      new xercesc::LocalFileFormatTarget(fname.c_str());
 
    try
    {
 #if XERCES_VERSION_MAJOR >= 3
                                             // DOM L3 as per Xerces 3.0 API
       xercesc::DOMLSOutput *theOutput =
         ((xercesc::DOMImplementationLS*)impl)->createLSOutput();
       theOutput->setByteStream(myFormTarget);
       writer->write(doc, theOutput);
 #else
       writer->writeNode(myFormTarget, *doc);
 #endif
    }
    catch (const xercesc::XMLException& toCatch)
    {
       char* message = xercesc::XMLString::transcode(toCatch.getMessage());
       G4cout << "G4GDML: Exception message is: " << message << G4endl;
       xercesc::XMLString::release(&message);
       return G4Transform3D::Identity;
    }
    catch (const xercesc::DOMException& toCatch)
    {
       char* message = xercesc::XMLString::transcode(toCatch.msg);
       G4cout << "G4GDML: Exception message is: " << message << G4endl;
       xercesc::XMLString::release(&message);
       return G4Transform3D::Identity;
    }
    catch (...)
    {   
       G4cout << "G4GDML: Unexpected Exception!" << G4endl;
       return G4Transform3D::Identity;
    }        
 
    delete myFormTarget;
    writer->release();
 
    if (depth==0)
    {
      G4cout << "G4GDML: Writing '" << fname << "' done !" << G4endl;
    }
    else
    {
      G4cout << "G4GDML: Writing module '" << fname << "' done !" << G4endl;
    }
 
    return R;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

G4bool G4GDMLWrite::addPointerToName = true

staticprotected

Definition at line 132 of file G4GDMLWrite.hh.

G4GDMLAuxListType G4GDMLWrite::auxList

protected

Definition at line 137 of file G4GDMLWrite.hh.

xercesc::DOMDocument* G4GDMLWrite::doc

protected

Definition at line 133 of file G4GDMLWrite.hh.

xercesc::DOMElement* G4GDMLWrite::extElement

protected

Definition at line 134 of file G4GDMLWrite.hh.

G4String G4GDMLWrite::SchemaLocation

protected

Definition at line 131 of file G4GDMLWrite.hh.

XMLCh G4GDMLWrite::tempStr[10000]

protected

Definition at line 136 of file G4GDMLWrite.hh.

xercesc::DOMElement* G4GDMLWrite::userinfoElement

protected

Definition at line 135 of file G4GDMLWrite.hh.

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

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation