G4GDMLParser Class Reference

#include <G4GDMLParser.hh>

Collaboration diagram for G4GDMLParser:

Public Member Functions
	G4GDMLParser ()
	G4GDMLParser (G4GDMLReadStructure *)
	G4GDMLParser (G4GDMLReadStructure *, G4GDMLWriteStructure *)
	~G4GDMLParser ()
void	Read (const G4String &filename, G4bool Validate=true)
void	ReadModule (const G4String &filename, G4bool Validate=true)
void	Write (const G4String &filename, const G4VPhysicalVolume *pvol=0, G4bool storeReferences=true, const G4String &SchemaLocation=G4GDML_DEFAULT_SCHEMALOCATION)
void	Write (const G4String &filename, const G4LogicalVolume *lvol, G4bool storeReferences=true, const G4String &SchemaLocation=G4GDML_DEFAULT_SCHEMALOCATION)
G4LogicalVolume *	ParseST (const G4String &name, G4Material *medium, G4Material *solid)
G4bool	IsValid (const G4String &name) const
G4double	GetConstant (const G4String &name) const
G4double	GetVariable (const G4String &name) const
G4double	GetQuantity (const G4String &name) const
G4ThreeVector	GetPosition (const G4String &name) const
G4ThreeVector	GetRotation (const G4String &name) const
G4ThreeVector	GetScale (const G4String &name) const
G4GDMLMatrix	GetMatrix (const G4String &name) const
G4LogicalVolume *	GetVolume (const G4String &name) const
G4VPhysicalVolume *	GetWorldVolume (const G4String &setupName="Default") const
G4GDMLAuxListType	GetVolumeAuxiliaryInformation (G4LogicalVolume *lvol) const
const G4GDMLAuxMapType *	GetAuxMap () const
const G4GDMLAuxListType *	GetAuxList () const
void	AddAuxiliary (G4GDMLAuxStructType myaux)
void	StripNamePointers () const
void	SetStripFlag (G4bool)
void	SetOverlapCheck (G4bool)
void	SetRegionExport (G4bool)
void	SetEnergyCutsExport (G4bool)
void	Clear ()
void	AddModule (const G4VPhysicalVolume *const physvol)
void	AddModule (const G4int depth)
void	SetAddPointerToName (G4bool set)
void	AddVolumeAuxiliary (G4GDMLAuxStructType myaux, const G4LogicalVolume *const lvol)

Private Member Functions
void	ImportRegions ()
void	ExportRegions (G4bool storeReferences=true)

Private Attributes
G4GDMLEvaluator	eval
G4GDMLReadStructure *	reader
G4GDMLWriteStructure *	writer
G4GDMLAuxListType *	rlist
G4GDMLAuxListType *	ullist
G4GDMLMessenger *	messenger
G4bool	urcode
G4bool	uwcode
G4bool	strip
G4bool	rexp

Detailed Description

Definition at line 55 of file G4GDMLParser.hh.

Constructor & Destructor Documentation

G4GDMLParser() [1/3]

G4GDMLParser::G4GDMLParser

(

)

Definition at line 44 of file G4GDMLParser.cc.

  : rlist(0), ullist(0), urcode(false), uwcode(false), strip(true), rexp(false)
{
  reader = new G4GDMLReadStructure;
  writer = new G4GDMLWriteStructure;
  messenger = new G4GDMLMessenger(this);

  xercesc::XMLPlatformUtils::Initialize();
}

Here is the call graph for this function:

G4GDMLParser() [2/3]

G4GDMLParser::G4GDMLParser

(

G4GDMLReadStructure *

extr

)

Definition at line 54 of file G4GDMLParser.cc.

  : rlist(0), ullist(0), urcode(true), uwcode(false), strip(true), rexp(false)
{
  reader = extr;
  writer = new G4GDMLWriteStructure;
  messenger = new G4GDMLMessenger(this);

  xercesc::XMLPlatformUtils::Initialize();
}

Here is the call graph for this function:

G4GDMLParser() [3/3]

G4GDMLParser::G4GDMLParser	(	G4GDMLReadStructure *	extr,
		G4GDMLWriteStructure *	extw
	)

Definition at line 64 of file G4GDMLParser.cc.

  : rlist(0), ullist(0), urcode(true), uwcode(true), strip(true), rexp(false)
{
  reader = extr;
  writer = extw;
  messenger = new G4GDMLMessenger(this);

  xercesc::XMLPlatformUtils::Initialize();
}

Here is the call graph for this function:

~G4GDMLParser()

G4GDMLParser::~G4GDMLParser

(

)

Definition at line 75 of file G4GDMLParser.cc.

{
  xercesc::XMLPlatformUtils::Terminate();
  if (!urcode) { delete reader; }
  if (!uwcode) { delete writer; delete ullist; delete rlist; }

  delete messenger;
}

Member Function Documentation

AddAuxiliary()

void G4GDMLParser::AddAuxiliary ( G4GDMLAuxStructType  myaux )

inline

Here is the caller graph for this function:

AddModule() [1/2]

void G4GDMLParser::AddModule ( const G4VPhysicalVolume *const  physvol )

inline

AddModule() [2/2]

void G4GDMLParser::AddModule ( const G4int  depth )

inline

AddVolumeAuxiliary()

void G4GDMLParser::AddVolumeAuxiliary ( G4GDMLAuxStructType  myaux, const G4LogicalVolume *const  lvol  )

inline

Clear()

void G4GDMLParser::Clear ( )

inline

Here is the caller graph for this function:

ExportRegions()

void G4GDMLParser::ExportRegions ( G4bool  storeReferences = true )

private

Definition at line 194 of file G4GDMLParser.cc.

{
  G4RegionStore* rstore = G4RegionStore::GetInstance();
  G4ReflectionFactory* reflFactory = G4ReflectionFactory::Instance();
  for (size_t i=0; i<rstore->size(); ++i)  // Skip default regions associated to worlds
  {
    const G4String& tname = (*rstore)[i]->GetName();
    if (tname.contains("DefaultRegionForParallelWorld")) continue;
    const G4String& rname = writer->GenerateName(tname,(*rstore)[i]);
    rlist = new G4GDMLAuxListType();
    G4GDMLAuxStructType raux = {"Region", rname, "", rlist};
    std::vector<G4LogicalVolume*>::iterator rlvol_iter
       = (*rstore)[i]->GetRootLogicalVolumeIterator();
    for (size_t j=0; j<(*rstore)[i]->GetNumberOfRootVolumes(); ++j)
    {
      G4LogicalVolume* rlvol = *rlvol_iter;
      if(reflFactory->IsReflected(rlvol)) continue;
      G4String vname = writer->GenerateName(rlvol->GetName(), rlvol);
      if (!storeReferences) { reader->StripName(vname); }
      G4GDMLAuxStructType rsubaux = {"volume", vname, "", 0};
      rlist->push_back(rsubaux);
      rlvol_iter++;
    }
    G4double gam_cut = (*rstore)[i]->GetProductionCuts()->GetProductionCut("gamma");
    G4GDMLAuxStructType caux1 = {"gamcut", eval.ConvertToString(gam_cut), "mm", 0};
    rlist->push_back(caux1);
    G4double e_cut = (*rstore)[i]->GetProductionCuts()->GetProductionCut("e-");
    G4GDMLAuxStructType caux2 = {"ecut", eval.ConvertToString(e_cut), "mm", 0};
    rlist->push_back(caux2);
    G4double pos_cut = (*rstore)[i]->GetProductionCuts()->GetProductionCut("e+");
    G4GDMLAuxStructType caux3 = {"poscut", eval.ConvertToString(pos_cut), "mm", 0};
    rlist->push_back(caux3);
    G4double p_cut = (*rstore)[i]->GetProductionCuts()->GetProductionCut("proton");
    G4GDMLAuxStructType caux4 = {"pcut", eval.ConvertToString(p_cut), "mm", 0};
    rlist->push_back(caux4);
    if ((*rstore)[i]->GetUserLimits())
    {
      const G4Track fake_trk;
      ullist = new G4GDMLAuxListType();
      const G4String& utype = (*rstore)[i]->GetUserLimits()->GetType();
      G4GDMLAuxStructType uaux = {"ulimits", utype, "mm", ullist};
      G4double max_step = (*rstore)[i]->GetUserLimits()->GetMaxAllowedStep(fake_trk);
      G4GDMLAuxStructType ulaux1 = {"ustepMax", eval.ConvertToString(max_step), "mm", 0};
      ullist->push_back(ulaux1);
      G4double max_trk = (*rstore)[i]->GetUserLimits()->GetUserMaxTrackLength(fake_trk);
      G4GDMLAuxStructType ulaux2 = {"utrakMax", eval.ConvertToString(max_trk), "mm", 0};
      ullist->push_back(ulaux2);
      G4double max_time = (*rstore)[i]->GetUserLimits()->GetUserMaxTime(fake_trk);
      G4GDMLAuxStructType ulaux3 = {"utimeMax", eval.ConvertToString(max_time), "mm", 0};
      ullist->push_back(ulaux3);
      G4double min_ekin = (*rstore)[i]->GetUserLimits()->GetUserMinEkine(fake_trk);
      G4GDMLAuxStructType ulaux4 = {"uekinMin", eval.ConvertToString(min_ekin), "mm", 0};
      ullist->push_back(ulaux4);
      G4double min_rng = (*rstore)[i]->GetUserLimits()->GetUserMinRange(fake_trk);
      G4GDMLAuxStructType ulaux5 = {"urangMin", eval.ConvertToString(min_rng), "mm", 0};
      ullist->push_back(ulaux5);
      rlist->push_back(uaux);
    }
    AddAuxiliary(raux);
  }
}

Here is the call graph for this function:

GetAuxList()

const G4GDMLAuxListType* G4GDMLParser::GetAuxList ( ) const

inline

Here is the caller graph for this function:

GetAuxMap()

const G4GDMLAuxMapType* G4GDMLParser::GetAuxMap ( ) const

inline

Here is the caller graph for this function:

GetConstant()

G4double G4GDMLParser::GetConstant ( const G4String &  name ) const

inline

GetMatrix()

G4GDMLMatrix G4GDMLParser::GetMatrix ( const G4String &  name ) const

inline

GetPosition()

G4ThreeVector G4GDMLParser::GetPosition ( const G4String &  name ) const

inline

Here is the caller graph for this function:

GetQuantity()

G4double G4GDMLParser::GetQuantity ( const G4String &  name ) const

inline

GetRotation()

G4ThreeVector G4GDMLParser::GetRotation ( const G4String &  name ) const

inline

Here is the caller graph for this function:

GetScale()

G4ThreeVector G4GDMLParser::GetScale ( const G4String &  name ) const

inline

GetVariable()

G4double G4GDMLParser::GetVariable ( const G4String &  name ) const

inline

GetVolume()

G4LogicalVolume* G4GDMLParser::GetVolume ( const G4String &  name ) const

inline

GetVolumeAuxiliaryInformation()

G4GDMLAuxListType G4GDMLParser::GetVolumeAuxiliaryInformation ( G4LogicalVolume *  lvol ) const

inline

Here is the caller graph for this function:

GetWorldVolume()

G4VPhysicalVolume* G4GDMLParser::GetWorldVolume ( const G4String &  setupName = "Default" ) const

inline

Here is the caller graph for this function:

ImportRegions()

void G4GDMLParser::ImportRegions ( )

private

Definition at line 84 of file G4GDMLParser.cc.

{
  G4ReflectionFactory* reflFactory = G4ReflectionFactory::Instance();
  const G4GDMLAuxListType* auxInfoList = GetAuxList();
  for(std::vector<G4GDMLAuxStructType>::const_iterator
      iaux = auxInfoList->begin(); iaux != auxInfoList->end(); iaux++ )
  {
    if (iaux->type != "Region")  return;

    G4String name = iaux->value;
    if (strip) { reader->StripName(name); }
    if (name.contains("DefaultRegionForTheWorld")) continue;

    if (!iaux->auxList)
    {
      G4Exception("G4GDMLParser::ImportRegions()",
                  "ReadError", FatalException,
                  "Invalid definition of geometrical region!");
    }
    else  // Create region and loop over all region attributes
    {
      G4Region* aRegion = new G4Region(name);
      G4ProductionCuts* pcuts = new G4ProductionCuts();
      aRegion->SetProductionCuts(pcuts);
      for(std::vector<G4GDMLAuxStructType>::const_iterator
          raux = iaux->auxList->begin(); raux != iaux->auxList->end(); raux++ )
      {
        const G4String& tag = raux->type;
        if (tag=="volume")
        {
          G4String volname = raux->value;
          if (strip) { reader->StripName(volname); }
          G4LogicalVolume* lvol = G4LogicalVolumeStore::GetInstance()->GetVolume(volname);
          aRegion->AddRootLogicalVolume(lvol);
      if(reflFactory->IsConstituent(lvol)) aRegion->AddRootLogicalVolume(reflFactory->GetReflectedLV(lvol));
        } else
        if (tag=="pcut")
        {
          const G4String& cvalue = raux->value;
          const G4String& cunit = raux->unit;
      if (G4UnitDefinition::GetCategory(cunit)!="Length") {
        G4Exception("G4GDMLParser::ImportRegions()", "InvalidRead",
            FatalException, "Invalid unit for length!");  }   
          G4double cut = eval.Evaluate(cvalue) * G4UnitDefinition::GetValueOf(cunit);
          pcuts->SetProductionCut(cut,"proton");
        } else
        if (tag=="ecut")
        {
          const G4String& cvalue = raux->value;
          const G4String& cunit = raux->unit;
      if (G4UnitDefinition::GetCategory(cunit)!="Length") {
        G4Exception("G4GDMLParser::ImportRegions()", "InvalidRead",
            FatalException, "Invalid unit for length!");  }   
          G4double cut = eval.Evaluate(cvalue) * G4UnitDefinition::GetValueOf(cunit);
          pcuts->SetProductionCut(cut,"e-");
        } else
        if (tag=="poscut")
        {
          const G4String& cvalue = raux->value;
          const G4String& cunit = raux->unit;
      if (G4UnitDefinition::GetCategory(cunit)!="Length") {
        G4Exception("G4GDMLParser::ImportRegions()", "InvalidRead",
            FatalException, "Invalid unit for length!");  }   
          G4double cut = eval.Evaluate(cvalue) * G4UnitDefinition::GetValueOf(cunit);
          pcuts->SetProductionCut(cut,"e+");
        } else
        if (tag=="gamcut")
        {
          const G4String& cvalue = raux->value;
          const G4String& cunit = raux->unit;
      if (G4UnitDefinition::GetCategory(cunit)!="Length") {
        G4Exception("G4GDMLParser::ImportRegions()", "InvalidRead",
            FatalException, "Invalid unit for length!");  }   
          G4double cut = eval.Evaluate(cvalue) * G4UnitDefinition::GetValueOf(cunit);
          pcuts->SetProductionCut(cut,"gamma");
        } else
        if (tag=="ulimits")
        {
          G4double ustepMax=DBL_MAX, utrakMax=DBL_MAX, utimeMax=DBL_MAX;
          G4double uekinMin=0., urangMin=0.;
          const G4String& ulname = raux->value;
          for(std::vector<G4GDMLAuxStructType>::const_iterator
              uaux=raux->auxList->begin(); uaux!=raux->auxList->end(); uaux++ )
          {
            const G4String& ultag = uaux->type;
            const G4String& uvalue = uaux->value;
            const G4String& uunit = uaux->unit;
            G4double ulvalue = eval.Evaluate(uvalue) * eval.Evaluate(uunit);
            if (ultag=="ustepMax") { ustepMax = ulvalue; } else
            if (ultag=="utrakMax") { utrakMax = ulvalue; } else
            if (ultag=="utimeMax") { utimeMax = ulvalue; } else
            if (ultag=="uekinMin") { uekinMin = ulvalue; } else
            if (ultag=="urangMin") { urangMin = ulvalue; }
            else
            {
              G4Exception("G4GDMLParser::ImportRegions()",
                          "ReadError", FatalException,
                          "Invalid definition of user-limits!");
            }
          }
          G4UserLimits* ulimits = new G4UserLimits(ulname, ustepMax, utrakMax,
                                         utimeMax, uekinMin, urangMin);
          aRegion->SetUserLimits(ulimits);
        }
        else continue;  // Ignore unknown tags
      }
    }
  }
}

Here is the call graph for this function:

IsValid()

G4bool G4GDMLParser::IsValid ( const G4String &  name ) const

inline

ParseST()

G4LogicalVolume* G4GDMLParser::ParseST ( const G4String &  name, G4Material *  medium, G4Material *  solid  )

inline

Here is the caller graph for this function:

Read()

void G4GDMLParser::Read ( const G4String &  filename, G4bool  Validate = true  )

inline

Here is the caller graph for this function:

ReadModule()

void G4GDMLParser::ReadModule ( const G4String &  filename, G4bool  Validate = true  )

inline

SetAddPointerToName()

void G4GDMLParser::SetAddPointerToName ( G4bool  set )

inline

SetEnergyCutsExport()

void G4GDMLParser::SetEnergyCutsExport ( G4bool  )

inline

Here is the caller graph for this function:

SetOverlapCheck()

void G4GDMLParser::SetOverlapCheck ( G4bool  )

inline

SetRegionExport()

void G4GDMLParser::SetRegionExport ( G4bool  )

inline

Here is the caller graph for this function:

SetStripFlag()

void G4GDMLParser::SetStripFlag ( G4bool  )

inline

StripNamePointers()

void G4GDMLParser::StripNamePointers ( ) const

inline

Write() [1/2]

void G4GDMLParser::Write ( const G4String &  filename, const G4VPhysicalVolume *  pvol = 0, G4bool  storeReferences = true, const G4String &  SchemaLocation = G4GDML_DEFAULT_SCHEMALOCATION  )

inline

Here is the caller graph for this function:

Write() [2/2]

void G4GDMLParser::Write ( const G4String &  filename, const G4LogicalVolume *  lvol, G4bool  storeReferences = true, const G4String &  SchemaLocation = G4GDML_DEFAULT_SCHEMALOCATION  )

inline

Member Data Documentation

eval

G4GDMLEvaluator G4GDMLParser::eval

private

Definition at line 146 of file G4GDMLParser.hh.

messenger

G4GDMLMessenger* G4GDMLParser::messenger

private

Definition at line 150 of file G4GDMLParser.hh.

reader

G4GDMLReadStructure* G4GDMLParser::reader

private

Definition at line 147 of file G4GDMLParser.hh.

rexp

G4bool G4GDMLParser::rexp

private

Definition at line 151 of file G4GDMLParser.hh.

rlist

G4GDMLAuxListType* G4GDMLParser::rlist

private

Definition at line 149 of file G4GDMLParser.hh.

strip

G4bool G4GDMLParser::strip

private

Definition at line 151 of file G4GDMLParser.hh.

ullist

G4GDMLAuxListType * G4GDMLParser::ullist

private

Definition at line 149 of file G4GDMLParser.hh.

urcode

G4bool G4GDMLParser::urcode

private

Definition at line 151 of file G4GDMLParser.hh.

uwcode

G4bool G4GDMLParser::uwcode

private

Definition at line 151 of file G4GDMLParser.hh.

writer

G4GDMLWriteStructure* G4GDMLParser::writer

private

Definition at line 148 of file G4GDMLParser.hh.

---

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

• G4GDMLParser.hh
• G4GDMLParser.cc