LArG4SDTool Class Reference

A base class for tools that manage LAr SDs. More...

#include <LArG4SDTool.h>

Inherits SensitiveDetectorBase.

Inherited by LArG4H62004ActiveSDTool, LArG4H62004DeadSDTool, LArG4H62004EMECSDTool, LArG4H62004FCALSDTool, LArG4H62004HECSDTool, LArG4H62004InactiveSDTool, TBECBackOuterBarretteTool, TBECInnerModuleTool, and TBECOuterModuleTool.

Collaboration diagram for LArG4SDTool:

Public Member Functions
	LArG4SDTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
virtual	~LArG4SDTool ()=default
	Destructor.
StatusCode	initialize () override final
virtual StatusCode	initializeCalculators ()
void	setupHelpers (LArG4SimpleSD *) const
	Helper method to pass the ID helper pointers to the SDs.
void	setupHelpers (LArG4CalibSD *) const
	Overload of the above method for calib SDs.
StatusCode	initializeSD () override
	Setup an SD in the current thread.
virtual StatusCode	SetupEvent () override
	Beginning of an athena event.
virtual StatusCode	SetupEvent (HitCollectionMap &) override
virtual StatusCode	Gather () override
	End of an athena event.
virtual StatusCode	Gather (HitCollectionMap &) override

Protected Member Functions
G4VSensitiveDetector *	makeSD () const override final
void	setupAllSDs (const std::map< G4VSensitiveDetector *, std::vector< std::string > * > &configuration) const
	Method actually doing the work to assign all of these SDs FIXME: this argument type is nasty:
bool	match (const char *first, const char *second) const
	Helper function for matching strings with wildcards.
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< G4bool >	m_doPID {this, "ParticleID", false}
	Are we set up to run with PID hits?
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?
const LArEM_ID *	m_larEmID {nullptr}
	Pointers to the identifier helpers.
const LArFCAL_ID *	m_larFcalID {nullptr}
const LArHEC_ID *	m_larHecID {nullptr}
const CaloDM_ID *	m_caloDmID {nullptr}
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.

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 LAr SDs.

This tool class adds functionality on top of SensitiveDetectorBase which is specific to the LAr setups.

NOTE: this design is not yet good for multi-threading in the existing ATLAS MT simulation model. Thus, there may be some refactoring needed.

Definition at line 34 of file LArG4SDTool.h.

Constructor & Destructor Documentation

LArG4SDTool()

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

Constructor.

~LArG4SDTool()

virtual LArG4SDTool::~LArG4SDTool ( )

virtualdefault

Destructor.

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
  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 " << sd->GetName() << " 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]

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, CaloCellContainerSDTool, FCS_Param::FCS_StepInfoSDTool, LArG4::CalibSDTool, LArG4::SimpleSDTool, LArG4H62004ActiveSDTool, LArG4H62004DeadSDTool, LArG4H62004EMECSDTool, LArG4H62004FCALSDTool, LArG4H62004HECSDTool, LArG4H62004InactiveSDTool, LArG4H6WarmTCSDTool, MinBiasScintillatorSDTool, MuonWallSDTool, TBECBackOuterBarretteTool, TBECInnerModuleTool, TBECOuterModuleTool, ZDC_FiberSDTool, and ZDC_G4CalibSDTool.

Definition at line 78 of file SensitiveDetectorBase.h.

{ return StatusCode::SUCCESS; }

Gather() [2/2]

virtual StatusCode SensitiveDetectorBase::Gather ( HitCollectionMap & )

inlineoverridevirtualinherited

Reimplemented in BCMSensorSDTool, BLMSensorSDTool, CSCSensitiveDetectorCosmicsTool, CSCSensitiveDetectorTool, GenericMuonSensitiveDetectorTool, MDTSensitiveDetectorCosmicsTool, MDTSensitiveDetectorTool, MicromegasSensitiveDetectorTool, PixelSensorSDTool, RPCSensitiveDetectorCosmicsTool, RPCSensitiveDetectorTool, SctSensor_CTBTool, SctSensorSDTool, sTGCSensitiveDetectorTool, TGCSensitiveDetectorCosmicsTool, TGCSensitiveDetectorTool, TileGeoG4CalibSDTool, TileGeoG4SDTool, and TRTSensitiveDetectorTool.

Definition at line 79 of file SensitiveDetectorBase.h.

                                                        {
    return Gather();
  };

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 120 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
}

initialize()

StatusCode LArG4SDTool::initialize ( )

finaloverride

initializeCalculators()

virtual StatusCode LArG4SDTool::initializeCalculators ( )

inlinevirtual

Reimplemented in LArG4H62004ActiveSDTool, LArG4H62004DeadSDTool, LArG4H62004EMECSDTool, LArG4H62004FCALSDTool, LArG4H62004HECSDTool, LArG4H62004InactiveSDTool, TBECBackOuterBarretteTool, TBECInnerModuleTool, and TBECOuterModuleTool.

Definition at line 45 of file LArG4SDTool.h.

{ return StatusCode::SUCCESS; }

initializeSD()

StatusCode SensitiveDetectorBase::initializeSD ( )

overrideinherited

Setup an SD in the current thread.

Separate from the AthAlgTool initialize() method because it needs to be called once per worker thread in AthenaMT. Don't confuse this with the G4 SD method Initialize which is called at the beginning of every G4 event.

Definition at line 25 of file SensitiveDetectorBase.cxx.

{
  ATH_MSG_VERBOSE( name() << "::initializeSD()" );
 
  // Sanity check for volume configuration problems.
  // It would be better to have a more robust solution for this.
  if(m_volumeNames.empty() != m_noVolumes) {
    ATH_MSG_ERROR("Initializing SD from " << name() << ", NoVolumes = "
                  << (m_noVolumes? "true" : "false") << ", but LogicalVolumeNames = "
                  << m_volumeNames.value());
    return StatusCode::FAILURE;
  }
 
  // Make sure SD isn't already registered
  if(getSD())
    {
      ATH_MSG_ERROR("Trying to create a SD which already exists!");
      return StatusCode::FAILURE;
    }
 
  // Make the SD stored by this tool
  auto sd = std::unique_ptr<G4VSensitiveDetector>(makeSD());
  if(!sd)
    {
      ATH_MSG_ERROR("Failed to create SD!");
      return StatusCode::FAILURE;
    }
  setSD(sd.get());
 
  // Assign the SD to our list of volumes
  ATH_CHECK( assignSD( std::move(sd), m_volumeNames.value() ) );
 
  ATH_MSG_DEBUG( "Initialized and added SD " << name() );
  return StatusCode::SUCCESS;
}

makeSD()

G4VSensitiveDetector * LArG4SDTool::makeSD ( ) const

inlinefinaloverrideprotected

Definition at line 54 of file LArG4SDTool.h.

{ return nullptr; }

match()

bool LArG4SDTool::match ( const char * first, const char * second ) const

protected

Helper function for matching strings with wildcards.

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 147 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 134 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 174 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);
        }
    }
}

setupAllSDs()

void LArG4SDTool::setupAllSDs ( const std::map< G4VSensitiveDetector *, std::vector< std::string > * > & configuration ) const

protected

Method actually doing the work to assign all of these SDs FIXME: this argument type is nasty:

• non-const ptr to list of strings

SetupEvent() [1/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, ALFA_SensitiveDetectorTool, CaloCellContainerSDTool, and MuonWallSDTool.

Definition at line 70 of file SensitiveDetectorBase.h.

{ return StatusCode::SUCCESS; }

SetupEvent() [2/2]

virtual StatusCode SensitiveDetectorBase::SetupEvent ( HitCollectionMap & )

inlineoverridevirtualinherited

Reimplemented in BCMSensorSDTool, BLMSensorSDTool, CSCSensitiveDetectorCosmicsTool, CSCSensitiveDetectorTool, GenericMuonSensitiveDetectorTool, MDTSensitiveDetectorCosmicsTool, MDTSensitiveDetectorTool, MicromegasSensitiveDetectorTool, PixelSensorSDTool, RPCSensitiveDetectorCosmicsTool, RPCSensitiveDetectorTool, SctSensor_CTBTool, SctSensorSDTool, sTGCSensitiveDetectorTool, TGCSensitiveDetectorCosmicsTool, TGCSensitiveDetectorTool, TileGeoG4CalibSDTool, TileGeoG4SDTool, and TRTSensitiveDetectorTool.

Definition at line 71 of file SensitiveDetectorBase.h.

                                                            {
    return SetupEvent();
  }

setupHelpers() [1/2]

void LArG4SDTool::setupHelpers

(

LArG4CalibSD *

)

const

Overload of the above method for calib SDs.

setupHelpers() [2/2]

void LArG4SDTool::setupHelpers

(

LArG4SimpleSD *

)

const

Helper method to pass the ID helper pointers to the SDs.

Member Data Documentation

m_caloDmID

const CaloDM_ID* LArG4SDTool::m_caloDmID {nullptr}

protected

Definition at line 74 of file LArG4SDTool.h.

{nullptr};

m_doPID

Gaudi::Property<G4bool> LArG4SDTool::m_doPID {this, "ParticleID", false}

protected

Are we set up to run with PID hits?

Definition at line 57 of file LArG4SDTool.h.

{this, "ParticleID", false};

m_larEmID

const LArEM_ID* LArG4SDTool::m_larEmID {nullptr}

protected

Pointers to the identifier helpers.

Definition at line 71 of file LArG4SDTool.h.

{nullptr};

m_larFcalID

const LArFCAL_ID* LArG4SDTool::m_larFcalID {nullptr}

protected

Definition at line 72 of file LArG4SDTool.h.

{nullptr};

m_larHecID

const LArHEC_ID* LArG4SDTool::m_larHecID {nullptr}

protected

Definition at line 73 of file LArG4SDTool.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> LArG4SDTool::m_timeBinType {this, "TimeBinType", "Default"}

protected

What time binning type for regular hits?

Definition at line 59 of file LArG4SDTool.h.

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

m_timeBinWidth

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

protected

What time bin width for regular hits?

Definition at line 61 of file LArG4SDTool.h.

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

m_useFrozenShowers

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

protected

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

Definition at line 63 of file LArG4SDTool.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:

• LArG4SDTool.h