UserLimitsSvc Class Reference

Concrete Tool to apply G4 User Limits. More...

#include "G4AtlasTools/UserLimitsSvc.h"

Inheritance diagram for UserLimitsSvc:

Collaboration diagram for UserLimitsSvc:

Public Member Functions
	UserLimitsSvc (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~UserLimitsSvc ()=default
virtual StatusCode	initialize () override final

Private Member Functions
bool	isMatch (const std::string &pattern, const std::string &logicalVolume) const
	Functions for string comparison.
bool	contains (const std::string &pattern, const std::string &logicalVolume) const

Private Attributes
Gaudi::Property< double >	m_MaxStep {this, "MaxStep", -1., "Maximum step length"}
	Maximum step length.
Gaudi::Property< double >	m_MinEkine {this, "MinEkine", -1., "Minimum remaining kinetic energy for a track"}
	Minimum remaining kinetic energy for a track.
Gaudi::Property< double >	m_MaxTrackLength {this, "MaxTrackLength", -1., "Maximum total track length"}
	Maximum total track length.
Gaudi::Property< double >	m_MaxTime {this, "MaxTime", -1., "Maximum global time for a track"}
	Maximum global time for a track.
Gaudi::Property< double >	m_MinRange {this, "MinRange", -1., "Minimum remaining range for a track"}
	Minimum remaining range for a track.
Gaudi::Property< std::string >	m_matchType {this, "MatchType", "isMatch", "Use 'contains' or 'isMatch' function for string comparison"}
	Use 'contains' or 'isMatch' function for string comparison.
Gaudi::Property< std::vector< std::string > >	m_logicalVolumes {this, "VolumeList" , {}, "List of Logical volume to which these limits should be applied"}
	List of Logical volume to which these limits should be applied.

Detailed Description

Concrete Tool to apply G4 User Limits.

Definition at line 21 of file UserLimitsSvc.h.

Constructor & Destructor Documentation

UserLimitsSvc()

UserLimitsSvc::UserLimitsSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 16 of file UserLimitsSvc.cxx.

  : base_class(name,pSvcLocator)
{
}

~UserLimitsSvc()

virtual UserLimitsSvc::~UserLimitsSvc ( )

virtualdefault

Member Function Documentation

contains()

bool UserLimitsSvc::contains ( const std::string & pattern, const std::string & logicalVolume ) const

private

Definition at line 75 of file UserLimitsSvc.cxx.

{
    return (logicalVolume.find(pattern) != std::string::npos);
}

initialize()

StatusCode UserLimitsSvc::initialize ( )

finaloverridevirtual

Definition at line 22 of file UserLimitsSvc.cxx.

{
  ATH_MSG_INFO(" initializing UserLimitsSvc "<<name() );
  G4LogicalVolumeStore& lvs=*(G4LogicalVolumeStore::GetInstance());
  
  ATH_MSG_INFO("G4LogicalVolumeStore size: " << lvs.size());
  std::set<G4String> volumes;
  for (unsigned int i = 0; i < lvs.size(); i++) {
      volumes.insert(lvs[i]->GetName());
  }
  ATH_MSG_INFO("G4LogicalVolumeStore unique size: " << volumes.size());
 
  // Define with a configurable string which string comparison fucntion to use
  using function_t = bool (UserLimitsSvc::*) (const std::string& pattern, const std::string& logicalVolume) const;
  std::map<std::string, function_t> funcMap;
  funcMap.emplace("isMatch", &UserLimitsSvc::isMatch);
  funcMap.emplace("contains", &UserLimitsSvc::contains);
 
  // Call Limit setting methods here:
  std::vector<std::string>::const_iterator volumeItr(m_logicalVolumes.value().begin());
  const std::vector<std::string>::const_iterator endOfVolumesItr(m_logicalVolumes.value().end());
  while(volumeItr!=endOfVolumesItr)
    {
      const std::string& volName(*volumeItr);
      unsigned int ndone(0);
      for (unsigned int i=0;i<lvs.size();i++)
        {
          G4LogicalVolume *lv=lvs[i];
          // Compare two strings with a configurable method...
          if ( (this->*(funcMap[m_matchType.value()]))(volName, lv->GetName()) ){
              G4UserLimits *ul=lv->GetUserLimits();
              if (!ul) ul=new G4UserLimits;
              if (-0.5 < m_MaxStep)        { ul->SetMaxAllowedStep(m_MaxStep); }
              if (-0.5 < m_MinEkine)       { ul->SetUserMinEkine(m_MinEkine); }
              if (-0.5 < m_MaxTrackLength) { ul->SetUserMaxTrackLength(m_MaxTrackLength); }
              if (-0.5 < m_MaxTime)        { ul->SetUserMaxTime(m_MaxTime); }
              if (-0.5 < m_MinRange)       { ul->SetUserMinRange(m_MinRange); }
              lv->SetUserLimits(ul);
              ++ndone;
            }
        }
      if (-0.5 < m_MaxStep) { ATH_MSG_DEBUG ( "MaxStep set to "<<m_MaxStep<<" to "<<ndone<<" copies of "<<volName ); }
      if (-0.5 < m_MinEkine){ ATH_MSG_DEBUG ( "MinEkine set to "<<m_MinEkine<<" to "<<ndone<<" copies of "<<volName );}
      if (-0.5 < m_MaxTrackLength) { ATH_MSG_DEBUG ( "MaxTrackLength set to "<<m_MaxTrackLength<<" to "<<ndone<<" copies of "<<volName ); }
      if (-0.5 < m_MaxTime)        { ATH_MSG_DEBUG ( "MaxTime set to "<<m_MaxTime<<" to "<<ndone<<" copies of "<<volName ); }
      if (-0.5 < m_MinRange)       { ATH_MSG_DEBUG ( "MinRange set to "<<m_MinRange<<" to "<<ndone<<" copies of "<<volName ); }
 
      ++volumeItr;
    }
  // TODO would probably be more CPU efficient to loop over the geometry and compare with each limit volume.
  return StatusCode::SUCCESS;
}

isMatch()

bool UserLimitsSvc::isMatch ( const std::string & pattern, const std::string & logicalVolume ) const

private

Functions for string comparison.

Definition at line 80 of file UserLimitsSvc.cxx.

{
  // straightforward cases
  if (a=="*") return true;
  if (a==b) return true;
  // wildcards
  boost::char_separator<char> sep{"*"};
  typedef boost::tokenizer< boost::char_separator<char> > tokenizer;
  tokenizer tok{a, sep};
  bool returnValue=true;
  std::string temp=b;
  //FIXME This next bit is a bit hacky
  std::vector<std::string> tokens;
  for (const auto& token : tok)
    {
      tokens.push_back(token);
    }
   for (unsigned int i=0;i<tokens.size();i++)
     {
       if (tokens[i].empty()) continue;
       std::string::size_type npos=temp.find(tokens[i]);
       if (i==0 && npos)
         return false;
       if (npos!=std::string::npos)
         {
           temp=temp.substr(npos, temp.size()-npos);
         }
       else
         {
           returnValue=false;
           break;
         }
     }
   if (returnValue && !tokens[tokens.size()-1].empty())
     {
       std::string temp=tokens[tokens.size()-1];
       std::string temp2=b.substr(b.size()-temp.size(),temp.size());
       if (temp!=temp2)
         return false;
     }
  return returnValue;
}

Member Data Documentation

m_logicalVolumes

Gaudi::Property<std::vector<std::string> > UserLimitsSvc::m_logicalVolumes {this, "VolumeList" , {}, "List of Logical volume to which these limits should be applied"}

private

List of Logical volume to which these limits should be applied.

Definition at line 46 of file UserLimitsSvc.h.

{this, "VolumeList" , {}, "List of Logical volume to which these limits should be applied"};

m_matchType

Gaudi::Property<std::string> UserLimitsSvc::m_matchType {this, "MatchType", "isMatch", "Use 'contains' or 'isMatch' function for string comparison"}

private

Use 'contains' or 'isMatch' function for string comparison.

Definition at line 44 of file UserLimitsSvc.h.

{this, "MatchType", "isMatch", "Use 'contains' or 'isMatch' function for string comparison"};

m_MaxStep

Gaudi::Property<double> UserLimitsSvc::m_MaxStep {this, "MaxStep", -1., "Maximum step length"}

private

Maximum step length.

Definition at line 34 of file UserLimitsSvc.h.

{this, "MaxStep", -1., "Maximum step length"};

m_MaxTime

Gaudi::Property<double> UserLimitsSvc::m_MaxTime {this, "MaxTime", -1., "Maximum global time for a track"}

private

Maximum global time for a track.

Definition at line 40 of file UserLimitsSvc.h.

{this, "MaxTime", -1., "Maximum global time for a track"};

m_MaxTrackLength

Gaudi::Property<double> UserLimitsSvc::m_MaxTrackLength {this, "MaxTrackLength", -1., "Maximum total track length"}

private

Maximum total track length.

Definition at line 38 of file UserLimitsSvc.h.

{this, "MaxTrackLength", -1., "Maximum total track length"};

m_MinEkine

Gaudi::Property<double> UserLimitsSvc::m_MinEkine {this, "MinEkine", -1., "Minimum remaining kinetic energy for a track"}

private

Minimum remaining kinetic energy for a track.

Definition at line 36 of file UserLimitsSvc.h.

{this, "MinEkine", -1., "Minimum remaining kinetic energy for a track"};

m_MinRange

Gaudi::Property<double> UserLimitsSvc::m_MinRange {this, "MinRange", -1., "Minimum remaining range for a track"}

private

Minimum remaining range for a track.

Definition at line 42 of file UserLimitsSvc.h.

{this, "MinRange", -1., "Minimum remaining range for a track"};

---

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

• UserLimitsSvc.h
• UserLimitsSvc.cxx