LArG4::SimpleSDTool Class Reference

A base class for tools that manage LArG4SimpleSDs. More...

#include <SimpleSDTool.h>

Inheritance diagram for LArG4::SimpleSDTool:

Collaboration diagram for LArG4::SimpleSDTool:

Public Member Functions
	SimpleSDTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
StatusCode	initialize () override final
	Initialize the tool.
StatusCode	initializeSD () override final
	Create and register all SDs for the current thread.
StatusCode	SetupEvent (HitCollectionMap &) override final
	Create event-owned hit collections.
StatusCode	Gather (HitCollectionMap &) override final
	Finalize and record event-owned hit collections.
virtual StatusCode	SetupEvent () override
	Beginning of an athena event.
virtual StatusCode	Gather () override
	End of an athena event.

Protected Member Functions
virtual StatusCode	initializeCalculators ()
	Initialize Calculator Services.
LArG4SimpleSD *	makeOneSD (const std::string &name, ILArCalculatorSvc *calc, const std::vector< std::string > &volumes) const
	Helper method to create one SD.
bool	useFrozenShowers () const
	Are we handling frozen shower fast sim?
virtual std::string	hitCollectionName () const
	Collection receiving the hits for this tool.
StatusCode	assignSD (std::unique_ptr< G4VSensitiveDetector > sd, const std::vector< std::string > &volumes) const
	Assign SD to a list of volumes.
G4VSensitiveDetector *	getSD ()
	Retrieve the current SD.
void	SetSensitiveDetector (G4LogicalVolume *, G4VSensitiveDetector *) const
	Method stolen from G4VUserDetectorConstruction in G4 10.2.

Protected Attributes
Gaudi::Property< std::vector< std::string > >	m_volumeNames {this, "LogicalVolumeNames", {}}
	All the volumes to which this SD is assigned.
Gaudi::Property< std::vector< std::string > >	m_outputCollectionNames {this, "OutputCollectionNames", {}}
	Names of all output collections written out by this SD.
Gaudi::Property< bool >	m_noVolumes {this, "NoVolumes", false}
	This SensitiveDetector has no volumes associated with it.
configuration properties
Gaudi::Property< std::string >	m_timeBinType {this, "TimeBinType", "Default"}
	What time binning type for regular hits?
Gaudi::Property< float >	m_timeBinWidth {this, "TimeBinWidth", 2.5*CLHEP::ns}
	What time bin width for regular hits?
Gaudi::Property< G4bool >	m_useFrozenShowers {this, "UseFrozenShowers", false}
	Is there going to be a fast simulation coming into this SD?
Calo identifier helpers
const LArEM_ID *	m_larEmID {nullptr}
const LArFCAL_ID *	m_larFcalID {nullptr}
const LArHEC_ID *	m_larHecID {nullptr}

Private Member Functions
void	setSD (G4VSensitiveDetector *)
	Set the current SD.

Static Private Member Functions
static bool	matchStrings (const char *first, const char *second)
	Match two strings with wildcard support.

Private Attributes
G4VSensitiveDetector *	m_SD {}
	The sensitive detector to which this thing corresponds.

Detailed Description

A base class for tools that manage LArG4SimpleSDs.

The tool owns only the Athena-event lifecycle of the output collection. Geant4 SD instances write through LArHitContainerBuilder, which carries all per-event merge state and the ordered regular-SD partitions.

Author

Steve Farrell Steve.nosp@m.n.Fa.nosp@m.rrell.nosp@m.@cer.nosp@m.n.ch

Definition at line 49 of file SimpleSDTool.h.

Constructor & Destructor Documentation

SimpleSDTool()

LArG4::SimpleSDTool::SimpleSDTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Constructor.

Member Function Documentation

assignSD()

StatusCode SensitiveDetectorBase::assignSD ( std::unique_ptr< G4VSensitiveDetector > sd, const std::vector< std::string > & volumes ) const

protectedinherited

Assign SD to a list of volumes.

This method supports wild card matching

Definition at line 64 of file SensitiveDetectorBase.cxx.

{
  // Propagate verbosity setting to the SD
  if(msgLvl(MSG::VERBOSE)) sd->SetVerboseLevel(10);
  else if(msgLvl(MSG::DEBUG)) sd->SetVerboseLevel(5);
 
  // Add the sensitive detector to the SD manager in G4 for SDs,
  // even if it has no volumes associated to it.
  auto sdMgr = G4SDManager::GetSDMpointer();
  auto sdPtr = sd.get();
  // SDManager is now the SD owner
  //for later use
  auto sdName = sd->GetName();
  sdMgr->AddNewDetector(sd.release());
 
  if(!volumes.empty()) {
    bool gotOne = false;
    auto logicalVolumeStore = G4LogicalVolumeStore::GetInstance();
    for(const auto& volumeName : volumes) {
      // Keep track of how many volumes we find with this name string.
      // We allow for multiple matches.
      int numFound = 0;
 
      // Find volumes with this name
      for(auto* logVol : *logicalVolumeStore) {
 
        ATH_MSG_VERBOSE("Check whether "<<logVol->GetName()<<" belongs to the set of sensitive detectors "<<volumeName);
        if( matchStrings( volumeName.data(), logVol->GetName() ) ){
          ++numFound;
          SetSensitiveDetector(logVol, sdPtr);
        }
        
      }
      // Warn if no volumes were found
      if(numFound == 0) {
        ATH_MSG_WARNING("Volume " << volumeName <<
                        " not found in G4LogicalVolumeStore.");
      }
      else {
        ATH_MSG_VERBOSE("Found " << numFound << " copies of LV " << volumeName <<
                        "; SD " << sdName << " assigned.");
        gotOne = true;
      }
 
    }
 
    // Abort if we have failed to assign any volume
    if(!gotOne) {
      ATH_MSG_ERROR( "Failed to assign *any* volume to SD " << name() <<
                     " and expected at least one. Size of the volume store "<<G4LogicalVolumeStore::GetInstance()->size() );
      return StatusCode::FAILURE;
    }
  }
 
  return StatusCode::SUCCESS;
}

Gather() [1/2]

StatusCode LArG4::SimpleSDTool::Gather ( HitCollectionMap & )

finaloverridevirtual

Finalize and record event-owned hit collections.

Reimplemented from SensitiveDetectorBase.

Gather() [2/2]

virtual StatusCode SensitiveDetectorBase::Gather ( )

inlineoverridevirtualinherited

End of an athena event.

Store the output collection in SG at this point. If we are using a WriteHandle, then this can be empty!

Reimplemented in AFP_SensitiveDetectorTool, AFP_SiDSensitiveDetectorTool, AFP_TDSensitiveDetectorTool, ALFA_SensitiveDetectorTool, FCS_Param::FCS_StepInfoSDTool, ZDC_FiberSDTool, and ZDC_G4CalibSDTool.

Definition at line 78 of file SensitiveDetectorBase.h.

{ return StatusCode::SUCCESS; }

getSD()

G4VSensitiveDetector * SensitiveDetectorBase::getSD ( )

protectedinherited

Retrieve the current SD.

In AthenaMT, this means the thread-local SD. Otherwise, it is simply the single SD.

Definition at line 122 of file SensitiveDetectorBase.cxx.

{
#ifdef G4MULTITHREADED
  // Get current thread-ID
  const auto tid = std::this_thread::get_id();
  // Retrieve it from the SD map
  auto sdPair = m_sdThreadMap.find(tid);
  if(sdPair == m_sdThreadMap.end()) return nullptr;
  return sdPair->second;
#else
  return m_SD;
#endif
}

hitCollectionName()

virtual std::string LArG4::SimpleSDTool::hitCollectionName ( ) const

protectedvirtual

Collection receiving the hits for this tool.

initialize()

StatusCode LArG4::SimpleSDTool::initialize ( )

finaloverride

Initialize the tool.

initializeCalculators()

virtual StatusCode LArG4::SimpleSDTool::initializeCalculators ( )

inlineprotectedvirtual

Initialize Calculator Services.

Reimplemented in LArG4::EMBSDTool, LArG4::EMECSDTool, LArG4::FCALSDTool, and LArG4::HECSDTool.

Definition at line 73 of file SimpleSDTool.h.

{ return StatusCode::SUCCESS; }

initializeSD()

StatusCode LArG4::SimpleSDTool::initializeSD ( )

finaloverride

Create and register all SDs for the current thread.

makeOneSD()

LArG4SimpleSD * LArG4::SimpleSDTool::makeOneSD ( const std::string & name, ILArCalculatorSvc * calc, const std::vector< std::string > & volumes ) const

protected

Helper method to create one SD.

matchStrings()

bool SensitiveDetectorBase::matchStrings ( const char * first, const char * second )

staticprivateinherited

Match two strings with wildcard support.

Compares two strings character by character with optional * wildcard in the first argument

Definition at line 149 of file SensitiveDetectorBase.cxx.

{
  // If we reach at the end of both strings, we are done
  if (*first == '\0' && *second == '\0')
    return true;
 
  // If there are consecutive '*' present in the first string
  // advance to the next character
  if(*first == '*' && *(first + 1) == '*')
    return matchStrings(first + 1, second);
 
  // Make sure that the characters after '*' are present in second string.
  if (*first == '*' && *(first + 1) != '\0' && *second == '\0')
    return false;
 
  // If the current characters of both strings match
  if (*first == *second)
    return matchStrings(first + 1, second + 1);
 
  // If there is *, then there are two possibilities
  // a) We consider current character of second string
  // b) We ignore current character of second string.
  if (*first == '*')
    return matchStrings(first + 1, second) || matchStrings(first, second + 1);
  return false;
}

setSD()

void SensitiveDetectorBase::setSD ( G4VSensitiveDetector * sd )

privateinherited

Set the current SD.

In hive, this gets assigned as the thread-local SD.

Definition at line 136 of file SensitiveDetectorBase.cxx.

{
#ifdef G4MULTITHREADED
  const auto tid = std::this_thread::get_id();
  ATH_MSG_DEBUG("Creating and registering SD " << sd << " in thread " << tid);
  m_sdThreadMap.insert( std::make_pair(tid, sd) );
#else
  m_SD = sd;
#endif
}

SetSensitiveDetector()

void SensitiveDetectorBase::SetSensitiveDetector ( G4LogicalVolume * logVol, G4VSensitiveDetector * aSD ) const

protectedinherited

Method stolen from G4VUserDetectorConstruction in G4 10.2.

Definition at line 176 of file SensitiveDetectorBase.cxx.

{
  // New Logic: allow for "multiple" SDs being attached to a single LV.
  // To do that we use a special proxy SD called G4MultiSensitiveDetector
 
  // Get existing SD if already set and check if it is of the special type
  G4VSensitiveDetector* originalSD = logVol->GetSensitiveDetector();
  if ( originalSD == nullptr )
    {
      logVol->SetSensitiveDetector(aSD);
    }
  else
    {
      G4MultiSensitiveDetector* msd = dynamic_cast<G4MultiSensitiveDetector*>(originalSD);
      if ( msd != nullptr )
        {
          msd->AddSD(aSD);
        }
      else
        {
          // Construct a unique name using the volume address
          std::stringstream ss;
          ss << static_cast<const void*>(logVol);
          const G4String msdname = "/MultiSD_" + logVol->GetName() + ss.str();
          msd = new G4MultiSensitiveDetector(std::move(msdname));
          // We need to register the proxy to have correct handling of IDs
          G4SDManager::GetSDMpointer()->AddNewDetector(msd);
          msd->AddSD(originalSD);
          msd->AddSD(aSD);
          logVol->SetSensitiveDetector(msd);
        }
    }
}

SetupEvent() [1/2]

StatusCode LArG4::SimpleSDTool::SetupEvent ( HitCollectionMap & )

finaloverridevirtual

Create event-owned hit collections.

Reimplemented from SensitiveDetectorBase.

SetupEvent() [2/2]

virtual StatusCode SensitiveDetectorBase::SetupEvent ( )

inlineoverridevirtualinherited

Beginning of an athena event.

This is where collection initialization should happen. If we are using a WriteHandle, then this could be empty.

Reimplemented in AFP_SensitiveDetectorTool, AFP_SiDSensitiveDetectorTool, AFP_TDSensitiveDetectorTool, and ALFA_SensitiveDetectorTool.

Definition at line 70 of file SensitiveDetectorBase.h.

{ return StatusCode::SUCCESS; }

useFrozenShowers()

bool LArG4::SimpleSDTool::useFrozenShowers ( ) const

inlineprotected

Are we handling frozen shower fast sim?

Definition at line 81 of file SimpleSDTool.h.

{ return m_useFrozenShowers; }

Member Data Documentation

m_larEmID

const LArEM_ID* LArG4::SimpleSDTool::m_larEmID {nullptr}

protected

Definition at line 102 of file SimpleSDTool.h.

{nullptr};

m_larFcalID

const LArFCAL_ID* LArG4::SimpleSDTool::m_larFcalID {nullptr}

protected

Definition at line 103 of file SimpleSDTool.h.

{nullptr};

m_larHecID

const LArHEC_ID* LArG4::SimpleSDTool::m_larHecID {nullptr}

protected

Definition at line 104 of file SimpleSDTool.h.

{nullptr};

m_noVolumes

Gaudi::Property<bool> SensitiveDetectorBase::m_noVolumes {this, "NoVolumes", false}

protectedinherited

This SensitiveDetector has no volumes associated with it.

Definition at line 101 of file SensitiveDetectorBase.h.

{this, "NoVolumes", false};

m_outputCollectionNames

Gaudi::Property<std::vector<std::string> > SensitiveDetectorBase::m_outputCollectionNames {this, "OutputCollectionNames", {}}

protectedinherited

Names of all output collections written out by this SD.

Definition at line 98 of file SensitiveDetectorBase.h.

{this, "OutputCollectionNames", {}};

m_SD

G4VSensitiveDetector* SensitiveDetectorBase::m_SD {}

privateinherited

The sensitive detector to which this thing corresponds.

Definition at line 125 of file SensitiveDetectorBase.h.

{};

m_timeBinType

Gaudi::Property<std::string> LArG4::SimpleSDTool::m_timeBinType {this, "TimeBinType", "Default"}

protected

What time binning type for regular hits?

Definition at line 92 of file SimpleSDTool.h.

{this, "TimeBinType", "Default"};

m_timeBinWidth

Gaudi::Property<float> LArG4::SimpleSDTool::m_timeBinWidth {this, "TimeBinWidth", 2.5*CLHEP::ns}

protected

What time bin width for regular hits?

Definition at line 94 of file SimpleSDTool.h.

{this, "TimeBinWidth", 2.5*CLHEP::ns};

m_useFrozenShowers

Gaudi::Property<G4bool> LArG4::SimpleSDTool::m_useFrozenShowers {this, "UseFrozenShowers", false}

protected

Is there going to be a fast simulation coming into this SD?

Definition at line 96 of file SimpleSDTool.h.

{this, "UseFrozenShowers", false};

m_volumeNames

Gaudi::Property<std::vector<std::string> > SensitiveDetectorBase::m_volumeNames {this, "LogicalVolumeNames", {}}

protectedinherited

All the volumes to which this SD is assigned.

Definition at line 96 of file SensitiveDetectorBase.h.

{this, "LogicalVolumeNames", {}};

---

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

• SimpleSDTool.h