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.

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

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

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 55 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()

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

finaloverridevirtual

Finalize and record event-owned hit collections.

Reimplemented from SensitiveDetectorBase.

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 115 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;
}

SetSensitiveDetector()

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

protectedinherited

Method stolen from G4VUserDetectorConstruction in G4 10.2.

Definition at line 142 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()

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

finaloverridevirtual

Create event-owned hit collections.

Reimplemented from SensitiveDetectorBase.

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 83 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 80 of file SensitiveDetectorBase.h.

{this, "OutputCollectionNames", {}};

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 78 of file SensitiveDetectorBase.h.

{this, "LogicalVolumeNames", {}};

---

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

• SimpleSDTool.h