FCS_Param::FCS_StepInfoSDTool Class Reference

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

#include <FCS_StepInfoSDTool.h>

Inheritance diagram for FCS_Param::FCS_StepInfoSDTool:

Collaboration diagram for FCS_Param::FCS_StepInfoSDTool:

Public Member Functions
	FCS_StepInfoSDTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor. More...
StatusCode	initialize () override final
	Initialize the tool. More...
StatusCode	Gather () override final
	Calls down to all the SDs to pack their hits into one collection. More...
StatusCode	initializeSD () override
	Setup an SD in the current thread. More...
virtual StatusCode	SetupEvent () override
	Beginning of an athena event. More...
virtual StatusCode	SetupEvent (HitCollectionMap &) override
virtual StatusCode	Gather (HitCollectionMap &) override

Protected Member Functions
StatusCode	assignSD (G4VSensitiveDetector *sd, const std::vector< std::string > &volumes) const
	Assign SD to a list of volumes. More...
G4VSensitiveDetector *	getSD ()
	Retrieve the current SD. More...
void	SetSensitiveDetector (G4LogicalVolume *, G4VSensitiveDetector *) const
	Method stolen from G4VUserDetectorConstruction in G4 10.2. More...

Protected Attributes
Gaudi::Property< std::vector< std::string > >	m_volumeNames {this, "LogicalVolumeNames", {}}
	All the volumes to which this SD is assigned. More...
Gaudi::Property< std::vector< std::string > >	m_outputCollectionNames {this, "OutputCollectionNames", {}}
	Names of all output collections written out by this SD. More...
Gaudi::Property< bool >	m_noVolumes {this, "NoVolumes", false}
	This SensitiveDetector has no volumes associated with it. More...

Private Member Functions
G4VSensitiveDetector *	makeSD () const override final
	Create the SD wrapper for current worker thread. More...
virtual StatusCode	initializeCalculators ()
	Initialize Calculator Services. More...
std::unique_ptr< FCS_StepInfoSD >	makeOneLArSD (const std::string &name, ILArCalculatorSvc *calc, const std::vector< std::string > &volumes) const
	Helper method to create one SD. More...
std::unique_ptr< FCS_StepInfoSD >	makeOneTileSD (const std::string &name, ITileCalculator *calc, const std::vector< std::string > &volumes) const
	Helper method to create one SD. More...
void	setSD (G4VSensitiveDetector *)
	Set the current SD. More...

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

Private Attributes
std::string	m_hitCollName
	Hit collection name. More...
ServiceHandle< ILArCalculatorSvc >	m_bpsmodcalc
ServiceHandle< ILArCalculatorSvc >	m_embcalc
ServiceHandle< ILArCalculatorSvc >	m_emepiwcalc
ServiceHandle< ILArCalculatorSvc >	m_emeniwcalc
ServiceHandle< ILArCalculatorSvc >	m_emepowcalc
ServiceHandle< ILArCalculatorSvc >	m_emenowcalc
ServiceHandle< ILArCalculatorSvc >	m_emepscalc
ServiceHandle< ILArCalculatorSvc >	m_emepobarcalc
ServiceHandle< ILArCalculatorSvc >	m_emenobarcalc
ServiceHandle< ILArCalculatorSvc >	m_heccalc
ServiceHandle< ILArCalculatorSvc >	m_fcal1calc
ServiceHandle< ILArCalculatorSvc >	m_fcal2calc
ServiceHandle< ILArCalculatorSvc >	m_fcal3calc
ServiceHandle< ITileCalculator >	m_tileCalculator
FCS_Param::Config	m_config
G4VSensitiveDetector *	m_SD {}
	The sensitive detector to which this thing corresponds. More...
SD volumes
std::vector< std::string >	m_stacVolumes
std::vector< std::string >	m_presBarVolumes
std::vector< std::string >	m_posIWVolumes
std::vector< std::string >	m_negIWVolumes
std::vector< std::string >	m_posOWVolumes
std::vector< std::string >	m_negOWVolumes
std::vector< std::string >	m_presECVolumes
std::vector< std::string >	m_pBOBVolumes
std::vector< std::string >	m_nBOBVolumes
std::vector< std::string >	m_fcal1Volumes
std::vector< std::string >	m_fcal2Volumes
std::vector< std::string >	m_fcal3Volumes
std::vector< std::string >	m_sliceVolumes
std::vector< std::string >	m_tileVolumes
Calo identifier helpers
const LArEM_ID *	m_larEmID
const LArFCAL_ID *	m_larFcalID
const LArHEC_ID *	m_larHecID
const TileID *	m_tileID

Detailed Description

A base class for tools that manage FCS_StepInfoSDs.

Todo:

Add more details.

Author

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

Definition at line 40 of file FCS_StepInfoSDTool.h.

Constructor & Destructor Documentation

FCS_StepInfoSDTool()

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

Constructor.

Definition at line 36 of file FCS_StepInfoSDTool.cxx.

    : SensitiveDetectorBase(type, name, parent),
      m_hitCollName("MergedEventSteps"),
      m_bpsmodcalc("EMBPresamplerCalculator", name),
      m_embcalc("EMBCalculator", name),
      m_emepiwcalc("EMECPosInnerWheelCalculator", name),
      m_emeniwcalc("EMECNegInnerWheelCalculator", name),
      m_emepowcalc("EMECPosOuterWheelCalculator", name),
      m_emenowcalc("EMECNegOuterWheelCalculator", name),
      m_emepscalc("EMECPresamplerCalculator", name),
      m_emepobarcalc("EMECPosBackOuterBarretteCalculator", name),
      m_emenobarcalc("EMECNegBackOuterBarretteCalculator", name),
      m_heccalc("HECWheelCalculator", name),
      m_fcal1calc("FCAL1Calculator", name),
      m_fcal2calc("FCAL2Calculator", name),
      m_fcal3calc("FCAL3Calculator", name),
      m_tileCalculator("TileGeoG4SDCalc", name),
      m_larEmID(nullptr),
      m_larFcalID(nullptr),
      m_larHecID(nullptr),
      m_tileID(nullptr),
      m_config() {
  declareProperty("HitCollectionName", m_hitCollName);
  declareProperty("StacVolumes", m_stacVolumes);
  declareProperty("PresamplerVolumes", m_presBarVolumes);
  declareProperty("PosIWVolumes", m_posIWVolumes);
  declareProperty("NegIWVolumes", m_negIWVolumes);
  declareProperty("PosOWVolumes", m_posOWVolumes);
  declareProperty("NegOWVolumes", m_negOWVolumes);
  declareProperty("PresVolumes", m_presECVolumes);
  declareProperty("PosBOBarretteVolumes", m_pBOBVolumes);
  declareProperty("NegBOBarretteVolumes", m_nBOBVolumes);
  declareProperty("FCAL1Volumes", m_fcal1Volumes);
  declareProperty("FCAL2Volumes", m_fcal2Volumes);
  declareProperty("FCAL3Volumes", m_fcal3Volumes);
  declareProperty("SliceVolumes", m_sliceVolumes);
  declareProperty("TileVolumes", m_tileVolumes);
 
  declareProperty("EMBPSCalculator", m_bpsmodcalc);
  declareProperty("EMBCalculator", m_embcalc);
  declareProperty("EMECPosIWCalculator", m_emepiwcalc);
  declareProperty("EMECNegIWCalculator", m_emeniwcalc);
  declareProperty("EMECPosOWCalculator", m_emepowcalc);
  declareProperty("EMECNegOWCalculator", m_emenowcalc);
  declareProperty("EMECPSCalculator", m_emepscalc);
  declareProperty("EMECPosBOBCalculator", m_emepobarcalc);
  declareProperty("EMECNegBOBCalculator", m_emenobarcalc);
  declareProperty("HECWActiveCalculator", m_heccalc);
  declareProperty("FCAL1Calculator", m_fcal1calc);
  declareProperty("FCAL2Calculator", m_fcal2calc);
  declareProperty("FCAL3Calculator", m_fcal3calc);
  declareProperty("TileCalculator", m_tileCalculator);
 
  declareProperty("shift_lar_subhit", m_config.shift_lar_subhit, "");
  declareProperty("shorten_lar_step", m_config.shorten_lar_step, "");
 
  declareProperty("maxRadiusLateral", m_config.m_maxRadiusLateral, "");
  declareProperty("maxRadiusLongitudinal", m_config.m_maxRadiusLongitudinal,
                  "");
 
  declareProperty("maxTime", m_config.m_maxTime, "");
  declareProperty("maxTimeLAr", m_config.m_maxTimeLAr, "");
  declareProperty("maxTimeHEC", m_config.m_maxTimeHEC, "");
  declareProperty("maxTimeFCAL", m_config.m_maxTimeFCAL, "");
  declareProperty("maxTimeTile", m_config.m_maxTimeTile, "");
}

Member Function Documentation

assignSD()

StatusCode SensitiveDetectorBase::assignSD ( 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 69 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();
  sdMgr->AddNewDetector(sd);
 
  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, sd);
        }
        
      }
      // 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]

StatusCode FCS_Param::FCS_StepInfoSDTool::Gather ( )

finaloverridevirtual

Calls down to all the SDs to pack their hits into one collection.

Reimplemented from SensitiveDetectorBase.

Definition at line 168 of file FCS_StepInfoSDTool.cxx.

                                      {
  ATH_MSG_DEBUG("Gathering hits to write out in " << name());
  auto* sdWrapper = dynamic_cast<FCS_StepInfoSDWrapper*>(getSD());
  if (!sdWrapper) {
    ATH_MSG_ERROR("Failed to cast SD to FCS_StepInfoSDWrapper");
    return StatusCode::FAILURE;
  }
  sdWrapper->EndOfAthenaEvent();
  return StatusCode::SUCCESS;
}

Gather() [2/2]

virtual StatusCode SensitiveDetectorBase::Gather ( HitCollectionMap &  )

inlineoverridevirtualinherited

Reimplemented in TileGeoG4SDTool, TileGeoG4CalibSDTool, SctSensorSDTool, PixelSensorSDTool, SctSensor_CTBTool, BCMSensorSDTool, BLMSensorSDTool, 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 123 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 FCS_Param::FCS_StepInfoSDTool::initialize ( )

finaloverride

Initialize the tool.

Definition at line 108 of file FCS_StepInfoSDTool.cxx.

                                          {
  ATH_MSG_DEBUG("Initializing " << name());
 
  const CaloIdManager* idMgr = nullptr;
  CHECK(detStore()->retrieve(idMgr));
  m_larEmID = idMgr->getEM_ID();
  if (m_larEmID == nullptr) {
    ATH_MSG_ERROR("Invalid LAr EM ID helper");
    return StatusCode::FAILURE;
  }
  m_larFcalID = idMgr->getFCAL_ID();
  if (m_larFcalID == nullptr) {
    ATH_MSG_ERROR("Invalid LAr FCAL ID helper");
    return StatusCode::FAILURE;
  }
  m_larHecID = idMgr->getHEC_ID();
  if (m_larHecID == nullptr) {
    ATH_MSG_ERROR("Invalid LAr HEC ID helper");
    return StatusCode::FAILURE;
  }
  m_tileID = idMgr->getTileID();
  if (m_tileID == nullptr) {
    ATH_MSG_ERROR("Invalid Tile ID helper");
    return StatusCode::FAILURE;
  }
 
  // No general volume list for SensitiveDetectorBase
  m_noVolumes = true;
 
  ATH_CHECK(this->initializeCalculators());
 
  return StatusCode::SUCCESS;
}

initializeCalculators()

StatusCode FCS_Param::FCS_StepInfoSDTool::initializeCalculators ( )

privatevirtual

Initialize Calculator Services.

Definition at line 145 of file FCS_StepInfoSDTool.cxx.

                                                     {
  // Lots of calculators !!!
  ATH_CHECK(m_bpsmodcalc.retrieve());
  ATH_CHECK(m_embcalc.retrieve());
  ATH_CHECK(m_emepiwcalc.retrieve());
  ATH_CHECK(m_emeniwcalc.retrieve());
  ATH_CHECK(m_emepowcalc.retrieve());
  ATH_CHECK(m_emenowcalc.retrieve());
  ATH_CHECK(m_emepscalc.retrieve());
  ATH_CHECK(m_emepobarcalc.retrieve());
  ATH_CHECK(m_emenobarcalc.retrieve());
  ATH_CHECK(m_heccalc.retrieve());
  ATH_CHECK(m_fcal1calc.retrieve());
  ATH_CHECK(m_fcal2calc.retrieve());
  ATH_CHECK(m_fcal3calc.retrieve());
  ATH_CHECK(m_tileCalculator.retrieve());
 
  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 30 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 = makeSD();
  if(!sd)
    {
      ATH_MSG_ERROR("Failed to create SD!");
      return StatusCode::FAILURE;
    }
  setSD(sd);
 
  // Assign the SD to our list of volumes
  ATH_CHECK( assignSD( getSD(), m_volumeNames.value() ) );
 
  ATH_MSG_DEBUG( "Initialized and added SD " << name() );
  return StatusCode::SUCCESS;
}

makeOneLArSD()

std::unique_ptr< FCS_StepInfoSD > FCS_Param::FCS_StepInfoSDTool::makeOneLArSD ( const std::string &  name, ILArCalculatorSvc *  calc, const std::vector< std::string > &  volumes  ) const

private

Helper method to create one SD.

Definition at line 223 of file FCS_StepInfoSDTool.cxx.

                                               {
  ATH_MSG_VERBOSE(name() << " makeOneSD");
 
  // Parse the wildcard patterns for existing volume names
  auto parsedVolumes = LArG4::findLogicalVolumes(
      volumes, msg());  // from LArG4Code/VolumeUtils.h
 
  // Inject the Calculator into m_config
  FCS_Param::Config config(m_config);
  config.m_LArCalculator = calc;
  if (!calc) {
    throw GaudiException(
        "nullptr for ILArCalculatorSvc provided to constructor for: " + sdName,
        name(), StatusCode::FAILURE);
  }
  if (msgLvl(MSG::VERBOSE)) {
    config.verboseLevel = 10;
  } else if (msgLvl(MSG::DEBUG)) {
    config.verboseLevel = 5;
  }
  // Create the simple SD
  std::unique_ptr<FCS_StepInfoSD> sd =
      std::make_unique<LArFCS_StepInfoSD>(sdName, config);
  sd->setupHelpers(m_larEmID, m_larFcalID, m_larHecID, m_tileID);
 
  // Assign the volumes to the SD
  if (this->assignSD(sd.get(), parsedVolumes).isFailure()) {
    // TODO: can I just return NULL here?
    throw GaudiException("Failed to assign sd: " + sdName, name(),
                         StatusCode::FAILURE);
  }
  return sd;
}

makeOneTileSD()

std::unique_ptr< FCS_StepInfoSD > FCS_Param::FCS_StepInfoSDTool::makeOneTileSD ( const std::string &  name, ITileCalculator *  calc, const std::vector< std::string > &  volumes  ) const

private

Helper method to create one SD.

Definition at line 262 of file FCS_StepInfoSDTool.cxx.

                                               {
  ATH_MSG_VERBOSE(name() << " makeOneSD");
 
  // Inject the Calculator into m_config
  FCS_Param::Config config(m_config);
  config.m_TileCalculator = calc;
  if (!calc) {
    throw GaudiException(
        "nullptr for ITileCalculator provided to constructor for: " + sdName,
        name(), StatusCode::FAILURE);
  }
  if (msgLvl(MSG::VERBOSE)) {
    config.verboseLevel = 10;
  } else if (msgLvl(MSG::DEBUG)) {
    config.verboseLevel = 5;
  }
  // Create the simple SD
  std::unique_ptr<FCS_StepInfoSD> sd =
      std::make_unique<TileFCS_StepInfoSD>(sdName, config);
  sd->setupHelpers(m_larEmID, m_larFcalID, m_larHecID, m_tileID);
 
  // Assign the volumes to the SD
  if (this->assignSD(sd.get(), volumes).isFailure()) {
    // TODO: can I just return NULL here?
    throw GaudiException("Failed to assign sd: " + sdName, name(),
                         StatusCode::FAILURE);
  }
  return sd;
}

makeSD()

G4VSensitiveDetector * FCS_Param::FCS_StepInfoSDTool::makeSD ( ) const

finaloverrideprivate

Create the SD wrapper for current worker thread.

Definition at line 182 of file FCS_StepInfoSDTool.cxx.

                                                       {
  // Create the wrapper
  auto* sdWrapper =
      new FCS_StepInfoSDWrapper("FCS_StepInfoSDWrapper", m_hitCollName);
 
  // Create the SDs.
  sdWrapper->addSD(makeOneLArSD("Barrel::Presampler::Module::StepInfo",
                                &*m_bpsmodcalc, m_presBarVolumes));
  sdWrapper->addSD(
      makeOneLArSD("EMB::STAC::StepInfo", &*m_embcalc, m_stacVolumes));
  sdWrapper->addSD(makeOneLArSD("EMEC::Pos::InnerWheel::StepInfo",
                                &*m_emepiwcalc, m_posIWVolumes));
  sdWrapper->addSD(makeOneLArSD("EMEC::Neg::InnerWheel::StepInfo",
                                &*m_emeniwcalc, m_negIWVolumes));
  sdWrapper->addSD(makeOneLArSD("EMEC::Pos::OuterWheel::StepInfo",
                                &*m_emepowcalc, m_posOWVolumes));
  sdWrapper->addSD(makeOneLArSD("EMEC::Neg::OuterWheel::StepInfo",
                                &*m_emenowcalc, m_negOWVolumes));
  sdWrapper->addSD(makeOneLArSD("Endcap::Presampler::LiquidArgon::StepInfo",
                                &*m_emepscalc, m_presECVolumes));
  sdWrapper->addSD(makeOneLArSD("EMEC::Pos::BackOuterBarrette::StepInfo",
                                &*m_emepobarcalc, m_pBOBVolumes));
  sdWrapper->addSD(makeOneLArSD("EMEC::Neg::BackOuterBarrette::StepInfo",
                                &*m_emenobarcalc, m_nBOBVolumes));
  sdWrapper->addSD(makeOneLArSD("FCAL::Module1::Gap::StepInfo", &*m_fcal1calc,
                                m_fcal1Volumes));
  sdWrapper->addSD(makeOneLArSD("FCAL::Module2::Gap::StepInfo", &*m_fcal2calc,
                                m_fcal2Volumes));
  sdWrapper->addSD(makeOneLArSD("FCAL::Module3::Gap::StepInfo", &*m_fcal3calc,
                                m_fcal3Volumes));
  sdWrapper->addSD(makeOneLArSD("HEC::Module::Depth::Slice::Wheel::StepInfo",
                                &*m_heccalc, m_sliceVolumes));
  sdWrapper->addSD(makeOneTileSD("Tile::Scintillator::StepInfo",
                                 &*m_tileCalculator, m_tileVolumes));
 
  return sdWrapper;
}

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 150 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 137 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 177 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();
          //ATH_MSG_INFO("MultiSD name: " << msdname);
          msd = new G4MultiSensitiveDetector(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]

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 MuonWallSDTool, AFP_SensitiveDetectorTool, AFP_SiDSensitiveDetectorTool, AFP_TDSensitiveDetectorTool, CaloCellContainerSDTool, and ALFA_SensitiveDetectorTool.

Definition at line 70 of file SensitiveDetectorBase.h.

{ return StatusCode::SUCCESS; }

SetupEvent() [2/2]

virtual StatusCode SensitiveDetectorBase::SetupEvent ( HitCollectionMap &  )

inlineoverridevirtualinherited

Reimplemented in TileGeoG4SDTool, TileGeoG4CalibSDTool, SctSensorSDTool, PixelSensorSDTool, SctSensor_CTBTool, BCMSensorSDTool, BLMSensorSDTool, and TRTSensitiveDetectorTool.

Definition at line 71 of file SensitiveDetectorBase.h.

                                                            {
    return SetupEvent();
  }

Member Data Documentation

m_bpsmodcalc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_bpsmodcalc

private

Definition at line 92 of file FCS_StepInfoSDTool.h.

m_config

FCS_Param::Config FCS_Param::FCS_StepInfoSDTool::m_config

private

Definition at line 123 of file FCS_StepInfoSDTool.h.

m_embcalc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_embcalc

private

Definition at line 94 of file FCS_StepInfoSDTool.h.

m_emeniwcalc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_emeniwcalc

private

Definition at line 97 of file FCS_StepInfoSDTool.h.

m_emenobarcalc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_emenobarcalc

private

Definition at line 107 of file FCS_StepInfoSDTool.h.

m_emenowcalc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_emenowcalc

private

Definition at line 101 of file FCS_StepInfoSDTool.h.

m_emepiwcalc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_emepiwcalc

private

Definition at line 95 of file FCS_StepInfoSDTool.h.

m_emepobarcalc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_emepobarcalc

private

Definition at line 105 of file FCS_StepInfoSDTool.h.

m_emepowcalc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_emepowcalc

private

Definition at line 99 of file FCS_StepInfoSDTool.h.

m_emepscalc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_emepscalc

private

Definition at line 104 of file FCS_StepInfoSDTool.h.

m_fcal1calc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_fcal1calc

private

Definition at line 111 of file FCS_StepInfoSDTool.h.

m_fcal1Volumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_fcal1Volumes

private

Definition at line 84 of file FCS_StepInfoSDTool.h.

m_fcal2calc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_fcal2calc

private

Definition at line 112 of file FCS_StepInfoSDTool.h.

m_fcal2Volumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_fcal2Volumes

private

Definition at line 85 of file FCS_StepInfoSDTool.h.

m_fcal3calc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_fcal3calc

private

Definition at line 113 of file FCS_StepInfoSDTool.h.

m_fcal3Volumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_fcal3Volumes

private

Definition at line 86 of file FCS_StepInfoSDTool.h.

m_heccalc

ServiceHandle<ILArCalculatorSvc> FCS_Param::FCS_StepInfoSDTool::m_heccalc

private

Definition at line 110 of file FCS_StepInfoSDTool.h.

m_hitCollName

std::string FCS_Param::FCS_StepInfoSDTool::m_hitCollName

private

Hit collection name.

Definition at line 71 of file FCS_StepInfoSDTool.h.

m_larEmID

const LArEM_ID* FCS_Param::FCS_StepInfoSDTool::m_larEmID

private

Definition at line 118 of file FCS_StepInfoSDTool.h.

m_larFcalID

const LArFCAL_ID* FCS_Param::FCS_StepInfoSDTool::m_larFcalID

private

Definition at line 119 of file FCS_StepInfoSDTool.h.

m_larHecID

const LArHEC_ID* FCS_Param::FCS_StepInfoSDTool::m_larHecID

private

Definition at line 120 of file FCS_StepInfoSDTool.h.

m_nBOBVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_nBOBVolumes

private

Definition at line 83 of file FCS_StepInfoSDTool.h.

m_negIWVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_negIWVolumes

private

Definition at line 78 of file FCS_StepInfoSDTool.h.

m_negOWVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_negOWVolumes

private

Definition at line 80 of file FCS_StepInfoSDTool.h.

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.

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.

m_pBOBVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_pBOBVolumes

private

Definition at line 82 of file FCS_StepInfoSDTool.h.

m_posIWVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_posIWVolumes

private

Definition at line 77 of file FCS_StepInfoSDTool.h.

m_posOWVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_posOWVolumes

private

Definition at line 79 of file FCS_StepInfoSDTool.h.

m_presBarVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_presBarVolumes

private

Definition at line 76 of file FCS_StepInfoSDTool.h.

m_presECVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_presECVolumes

private

Definition at line 81 of file FCS_StepInfoSDTool.h.

m_SD

G4VSensitiveDetector* SensitiveDetectorBase::m_SD {}

privateinherited

The sensitive detector to which this thing corresponds.

Definition at line 125 of file SensitiveDetectorBase.h.

m_sliceVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_sliceVolumes

private

Definition at line 87 of file FCS_StepInfoSDTool.h.

m_stacVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_stacVolumes

private

Definition at line 75 of file FCS_StepInfoSDTool.h.

m_tileCalculator

ServiceHandle<ITileCalculator> FCS_Param::FCS_StepInfoSDTool::m_tileCalculator

private

Definition at line 114 of file FCS_StepInfoSDTool.h.

m_tileID

const TileID* FCS_Param::FCS_StepInfoSDTool::m_tileID

private

Definition at line 121 of file FCS_StepInfoSDTool.h.

m_tileVolumes

std::vector<std::string> FCS_Param::FCS_StepInfoSDTool::m_tileVolumes

private

Definition at line 88 of file FCS_StepInfoSDTool.h.

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.

---

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

• FCS_StepInfoSDTool.h
• FCS_StepInfoSDTool.cxx