G4GDMLParser Class Reference

#include <G4GDMLParser.hh>

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

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

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

Detailed Description

Definition at line 51 of file G4GDMLParser.hh.

Constructor & Destructor Documentation

G4GDMLParser() [1/3]

G4GDMLParser::G4GDMLParser

(

)

Definition at line 42 of file G4GDMLParser.cc.

  : strip(true)
{
  reader    = new G4GDMLReadStructure;
  writer    = new G4GDMLWriteStructure;
  messenger = new G4GDMLMessenger(this);
 
  xercesc::XMLPlatformUtils::Initialize();
}

References messenger, reader, and writer.

G4GDMLParser() [2/3]

G4GDMLParser::G4GDMLParser

(

G4GDMLReadStructure *

extr

)

Definition at line 53 of file G4GDMLParser.cc.

  : urcode(true), strip(true)
{
  reader    = extr;
  writer    = new G4GDMLWriteStructure;
  messenger = new G4GDMLMessenger(this);
 
  xercesc::XMLPlatformUtils::Initialize();
}

References messenger, reader, and writer.

G4GDMLParser() [3/3]

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

Definition at line 64 of file G4GDMLParser.cc.

  : urcode(true), uwcode(true), strip(true)
{
  reader    = extr;
  writer    = extw;
  messenger = new G4GDMLMessenger(this);
 
  xercesc::XMLPlatformUtils::Initialize();
}

References messenger, reader, and writer.

~G4GDMLParser()

G4GDMLParser::~G4GDMLParser

(

)

Definition at line 76 of file G4GDMLParser.cc.

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

References messenger, reader, rlist, ullist, urcode, uwcode, and writer.

Member Function Documentation

AddAuxiliary()

void G4GDMLParser::AddAuxiliary ( G4GDMLAuxStructType  myaux )

inline

Referenced by ExportRegions().

AddModule() [1/2]

void G4GDMLParser::AddModule ( const G4int  depth )

inline

AddModule() [2/2]

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

inline

AddVolumeAuxiliary()

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

inline

Clear()

void G4GDMLParser::Clear ( )

inline

Referenced by G4GDMLMessenger::SetNewValue().

ExportRegions()

void G4GDMLParser::ExportRegions ( G4bool  storeReferences = true )

private

Definition at line 272 of file G4GDMLParser.cc.

{
  G4RegionStore* rstore            = G4RegionStore::GetInstance();
  G4ReflectionFactory* reflFactory = G4ReflectionFactory::Instance();
  for(std::size_t i = 0; i < rstore->size(); ++i)
     // Skip default regions associated to worlds
  {
    const G4String& tname = (*rstore)[i]->GetName();
    if(G4StrUtil::contains(tname, "DefaultRegionForParallelWorld"))
      continue;
    const G4String& rname    = writer->GenerateName(tname, (*rstore)[i]);
    rlist                    = new G4GDMLAuxListType();
    G4GDMLAuxStructType raux = { "Region", rname, "", rlist };
    auto rlvol_iter = (*rstore)[i]->GetRootLogicalVolumeIterator();
    for(std::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);
  }
}

References AddAuxiliary(), G4StrUtil::contains(), G4GDMLEvaluator::ConvertToString(), eval, G4GDMLWrite::GenerateName(), G4RegionStore::GetInstance(), G4LogicalVolume::GetName(), G4ReflectionFactory::Instance(), G4ReflectionFactory::IsReflected(), reader, rlist, G4GDMLRead::StripName(), ullist, and writer.

GetAuxList()

const G4GDMLAuxListType * G4GDMLParser::GetAuxList ( ) const

inline

Referenced by ImportRegions().

GetAuxMap()

const G4GDMLAuxMapType * G4GDMLParser::GetAuxMap ( ) const

inline

GetConstant()

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

inline

GetMatrix()

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

inline

GetMaxExportLevel()

G4int G4GDMLParser::GetMaxExportLevel ( ) const

inline

GetPhysVolume()

G4VPhysicalVolume * G4GDMLParser::GetPhysVolume ( const G4String &  name ) const

inline

GetPosition()

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

inline

GetQuantity()

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

inline

GetRotation()

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

inline

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

GetWorldVolume()

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

inline

Referenced by export_G4GDMLParser(), and G4GDMLMessenger::SetNewValue().

ImportRegions()

void G4GDMLParser::ImportRegions ( )

private

Definition at line 94 of file G4GDMLParser.cc.

{
  G4ReflectionFactory* reflFactory     = G4ReflectionFactory::Instance();
  const G4GDMLAuxListType* auxInfoList = GetAuxList();
  for(auto iaux = auxInfoList->cbegin(); iaux != auxInfoList->cend(); ++iaux)
  {
    if(iaux->type != "Region")
      continue;
 
    G4String name = iaux->value;
    if(strip)
    {
      reader->StripName(name);
    }
    if(G4StrUtil::contains(name, "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(auto raux = iaux->auxList->cbegin();
               raux != iaux->auxList->cend(); ++raux)
      {
        const G4String& tag = raux->type;
        if(tag == "volume")
        {
          G4String volname = raux->value;
          if(strip)
          {
            reader->StripName(volname);
          }
          G4LogicalVolumeStore* store = G4LogicalVolumeStore::GetInstance();
          auto pos = store->GetMap().find(volname);
          if(pos != store->GetMap().cend())
          {
            // Scan for all possible volumes with same name
            // and set them as root logical volumes for the region...
            // Issue a notification in case more than one logical volume
            // with same name exist and get set.
            //
            if (pos->second.size()>1)
            {
              std::ostringstream message;
              message << "There exists more than ONE logical volume "
                      << "in store named: " << volname << "." << G4endl
                      << "NOTE: assigning all such volumes as root logical "
                      << "volumes for region: " << name << "!";
              G4Exception("G4GDMLParser::ImportRegions()",
                          "Notification", JustWarning, message);
            }
            for (auto vpos = pos->second.cbegin();
                      vpos != pos->second.cend(); ++vpos)
            {
              aRegion->AddRootLogicalVolume(*vpos);
              if(reflFactory->IsConstituent(*vpos))
                aRegion->AddRootLogicalVolume(reflFactory->GetReflectedLV(*vpos));
            }
          }
          else
          {
            std::ostringstream message;
            message << "Volume NOT found in store !" << G4endl
                    << "        Volume " << volname << " NOT found in store !"
                    << G4endl
                    << "        No region is being set.";
            G4Exception("G4GDMLParser::ImportRegions()",
                        "InvalidSetup", JustWarning, message);
          }
        }
        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(auto uaux = raux->auxList->cbegin();
                   uaux != raux->auxList->cend(); ++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
      }
    }
  }
}

References G4Region::AddRootLogicalVolume(), G4StrUtil::contains(), DBL_MAX, eval, G4GDMLEvaluator::Evaluate(), FatalException, G4endl, G4Exception(), GetAuxList(), G4UnitDefinition::GetCategory(), G4LogicalVolumeStore::GetInstance(), G4LogicalVolumeStore::GetMap(), G4ReflectionFactory::GetReflectedLV(), G4UnitDefinition::GetValueOf(), G4ReflectionFactory::Instance(), G4ReflectionFactory::IsConstituent(), JustWarning, G4InuclParticleNames::name(), pos, reader, G4ProductionCuts::SetProductionCut(), G4Region::SetProductionCuts(), G4Region::SetUserLimits(), strip, and G4GDMLRead::StripName().

IsValid()

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

inline

ParseST()

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

inline

Referenced by export_G4GDMLParser().

Read()

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

inline

Referenced by export_G4GDMLParser(), and G4GDMLMessenger::SetNewValue().

ReadModule()

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

inline

Referenced by export_G4GDMLParser().

SetAddPointerToName()

void G4GDMLParser::SetAddPointerToName ( G4bool  set )

inline

Referenced by G4GDMLMessenger::SetNewValue().

SetEnergyCutsExport()

void G4GDMLParser::SetEnergyCutsExport ( G4bool  )

inline

Referenced by G4GDMLMessenger::SetNewValue().

SetMaxExportLevel()

void G4GDMLParser::SetMaxExportLevel ( G4int  )

inline

SetOutputFileOverwrite()

void G4GDMLParser::SetOutputFileOverwrite ( G4bool  flag )

inline

SetOverlapCheck()

void G4GDMLParser::SetOverlapCheck ( G4bool  )

inline

SetRegionExport()

void G4GDMLParser::SetRegionExport ( G4bool  )

inline

Referenced by G4GDMLMessenger::SetNewValue().

SetReverseSearch()

void G4GDMLParser::SetReverseSearch ( G4bool  )

inline

SetSDExport()

void G4GDMLParser::SetSDExport ( G4bool  )

inline

Referenced by G4GDMLMessenger::SetNewValue().

SetStripFlag()

void G4GDMLParser::SetStripFlag ( G4bool  )

inline

Referenced by G4GDMLMessenger::SetNewValue().

StripNamePointers()

void G4GDMLParser::StripNamePointers ( ) const

inline

Write() [1/2]

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

inline

Write() [2/2]

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

inline

Referenced by G4GDMLMessenger::SetNewValue().

Field Documentation

eval

G4GDMLEvaluator G4GDMLParser::eval

private

Definition at line 150 of file G4GDMLParser.hh.

Referenced by ExportRegions(), and ImportRegions().

messenger

G4GDMLMessenger* G4GDMLParser::messenger = nullptr

private

Definition at line 154 of file G4GDMLParser.hh.

Referenced by G4GDMLParser(), and ~G4GDMLParser().

reader

G4GDMLReadStructure* G4GDMLParser::reader = nullptr

private

Definition at line 151 of file G4GDMLParser.hh.

Referenced by ExportRegions(), G4GDMLParser(), ImportRegions(), and ~G4GDMLParser().

rexp

G4bool G4GDMLParser::rexp = false

private

Definition at line 155 of file G4GDMLParser.hh.

rlist

G4GDMLAuxListType* G4GDMLParser::rlist = nullptr

private

Definition at line 153 of file G4GDMLParser.hh.

Referenced by ExportRegions(), and ~G4GDMLParser().

strip

G4bool G4GDMLParser::strip = false

private

Definition at line 155 of file G4GDMLParser.hh.

Referenced by ImportRegions().

ullist

G4GDMLAuxListType * G4GDMLParser::ullist = nullptr

private

Definition at line 153 of file G4GDMLParser.hh.

Referenced by ExportRegions(), and ~G4GDMLParser().

urcode

G4bool G4GDMLParser::urcode = false

private

Definition at line 155 of file G4GDMLParser.hh.

Referenced by ~G4GDMLParser().

uwcode

G4bool G4GDMLParser::uwcode = false

private

Definition at line 155 of file G4GDMLParser.hh.

Referenced by ~G4GDMLParser().

writer

G4GDMLWriteStructure* G4GDMLParser::writer = nullptr

private

Definition at line 152 of file G4GDMLParser.hh.

Referenced by ExportRegions(), G4GDMLParser(), and ~G4GDMLParser().

---

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

• source/persistency/gdml/include/G4GDMLParser.hh
• source/persistency/gdml/src/G4GDMLParser.cc