Sensitive detector tool which manages activate-area LAr calib SDs. More...

#include <ActiveSDTool.h>

Inheritance diagram for LArG4::ActiveSDTool:

Collaboration diagram for LArG4::ActiveSDTool:

Public Member Functions
	ActiveSDTool (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
LArG4CalibSD *	makeOneSD (const std::string &name, ILArCalibCalculatorSvc *calc, const std::vector< std::string > &volumes) const
	Helper method to create one SD.
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< G4bool >	m_doPID {this, "ParticleID", false}
	Are we set up to run with PID hits?
Calo identifier helpers
const LArEM_ID *	m_larEmID {nullptr}
const LArFCAL_ID *	m_larFcalID {nullptr}
const LArHEC_ID *	m_larHecID {nullptr}
const CaloDM_ID *	m_caloDmID {nullptr}
const AtlasDetectorID *	m_id_helper {nullptr}

Private Member Functions
StatusCode	initializeCalculators () override final
	Initialize Calculator Services.
std::string	hitCollectionName () const override final
std::string	deadHitCollectionName () const override final
std::string	srHitCollectionName () const override final
G4VSensitiveDetector *	makeSD () const override final
	Create the SDs for current worker thread.

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

Private Attributes
Gaudi::Property< std::string >	m_hitCollName {this, "HitCollectionName", "LArCalibrationHitActive"}
	Hit collection name.
ServiceHandle< ILArCalibCalculatorSvc >	m_bpsmodcalc
ServiceHandle< ILArCalibCalculatorSvc >	m_embcalc
ServiceHandle< ILArCalibCalculatorSvc >	m_emepiwcalc
ServiceHandle< ILArCalibCalculatorSvc >	m_emeniwcalc
ServiceHandle< ILArCalibCalculatorSvc >	m_emepowcalc
ServiceHandle< ILArCalibCalculatorSvc >	m_emenowcalc
ServiceHandle< ILArCalibCalculatorSvc >	m_emepscalc
ServiceHandle< ILArCalibCalculatorSvc >	m_emepobarcalc
ServiceHandle< ILArCalibCalculatorSvc >	m_emenobarcalc
ServiceHandle< ILArCalibCalculatorSvc >	m_heccalc
ServiceHandle< ILArCalibCalculatorSvc >	m_fcal1calc {this, "FCAL1CalibCalculator", "FCAL1CalibCalculator"}
ServiceHandle< ILArCalibCalculatorSvc >	m_fcal2calc {this, "FCAL2CalibCalculator", "FCAL2CalibCalculator"}
ServiceHandle< ILArCalibCalculatorSvc >	m_fcal3calc {this, "FCAL3CalibCalculator", "FCAL3CalibCalculator"}
SD volumes
Gaudi::Property< std::vector< std::string > >	m_stacVolumes {this, "StacVolumes"}
Gaudi::Property< std::vector< std::string > >	m_presBarVolumes {this, "PresamplerVolumes"}
Gaudi::Property< std::vector< std::string > >	m_posIWVolumes {this, "PosIWVolumes"}
Gaudi::Property< std::vector< std::string > >	m_negIWVolumes {this, "NegIWVolumes"}
Gaudi::Property< std::vector< std::string > >	m_posOWVolumes {this, "PosOWVolumes"}
Gaudi::Property< std::vector< std::string > >	m_negOWVolumes {this, "NegOWVolumes"}
Gaudi::Property< std::vector< std::string > >	m_presECVolumes {this, "PresVolumes"}
Gaudi::Property< std::vector< std::string > >	m_pBOBVolumes {this, "PosBOBarretteVolumes"}
Gaudi::Property< std::vector< std::string > >	m_nBOBVolumes {this, "NegBOBarretteVolumes"}
Gaudi::Property< std::vector< std::string > >	m_fcal1Volumes {this, "FCAL1Volumes"}
Gaudi::Property< std::vector< std::string > >	m_fcal2Volumes {this, "FCAL2Volumes"}
Gaudi::Property< std::vector< std::string > >	m_fcal3Volumes {this, "FCAL3Volumes"}
Gaudi::Property< std::vector< std::string > >	m_sliceVolumes {this, "SliceVolumes"}

Detailed Description

Sensitive detector tool which manages activate-area LAr calib SDs.

Design is in flux.

Definition at line 24 of file ActiveSDTool.h.

Constructor & Destructor Documentation

◆ ActiveSDTool()

LArG4::ActiveSDTool::ActiveSDTool	(	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;
}

◆ deadHitCollectionName()

std::string LArG4::ActiveSDTool::deadHitCollectionName ( ) const

finaloverrideprivatevirtual

Reimplemented from LArG4::CalibSDTool.

◆ Gather()

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

finaloverridevirtualinherited

Finalize and record event-owned hit collections.

Reimplemented from SensitiveDetectorBase.

◆ hitCollectionName()

std::string LArG4::ActiveSDTool::hitCollectionName ( ) const

finaloverrideprivatevirtual

Reimplemented from LArG4::CalibSDTool.

◆ initialize()

StatusCode LArG4::CalibSDTool::initialize ( )

finaloverrideinherited

Initialize the tool.

◆ initializeCalculators()

StatusCode LArG4::ActiveSDTool::initializeCalculators ( )

finaloverrideprivatevirtual

Initialize Calculator Services.

Reimplemented from LArG4::CalibSDTool.

◆ initializeSD()

StatusCode LArG4::CalibSDTool::initializeSD ( )

finaloverrideinherited

Create and register all SDs for the current thread.

◆ makeOneSD()

LArG4CalibSD * LArG4::CalibSDTool::makeOneSD	(	const std::string &	name,
		ILArCalibCalculatorSvc *	calc,
		const std::vector< std::string > &	volumes ) const

protectedinherited

Helper method to create one SD.

◆ makeSD()

G4VSensitiveDetector * LArG4::ActiveSDTool::makeSD ( ) const

finaloverrideprivate

Create the SDs for current worker thread.

◆ 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::CalibSDTool::SetupEvent ( HitCollectionMap & )

finaloverridevirtualinherited

Create event-owned hit collections.

Reimplemented from SensitiveDetectorBase.

◆ srHitCollectionName()

std::string LArG4::ActiveSDTool::srHitCollectionName ( ) const

finaloverrideprivatevirtual

Reimplemented from LArG4::CalibSDTool.

Member Data Documentation

◆ m_bpsmodcalc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_bpsmodcalc

private

Initial value:

{this, "EMBPSCalibrationCalculator"

, "BarrelPresamplerCalibrationCalculator"}

Definition at line 62 of file ActiveSDTool.h.

62 {this, "EMBPSCalibrationCalculator"

63 , "BarrelPresamplerCalibrationCalculator"}; //LArG4::BarrelPresampler::CalibrationCalculator

◆ m_caloDmID

const CaloDM_ID* LArG4::CalibSDTool::m_caloDmID {nullptr}

protectedinherited

Definition at line 97 of file CalibSDTool.h.

97{nullptr};

◆ m_doPID

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

protectedinherited

Are we set up to run with PID hits?

Definition at line 88 of file CalibSDTool.h.

88{this, "ParticleID", false};

◆ m_embcalc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_embcalc

private

Initial value:

{this, "EMBCalibrationCalculator"

, "BarrelCalibrationCalculator"}

Definition at line 64 of file ActiveSDTool.h.

64 {this, "EMBCalibrationCalculator"

65 , "BarrelCalibrationCalculator"}; //LArG4::Barrel::CalibrationCalculator

◆ m_emeniwcalc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_emeniwcalc

private

Initial value:

{this, "EMECNegIWCalibrationCalculator"

, "EMECNegInnerWheelCalibrationCalculator"}

Definition at line 68 of file ActiveSDTool.h.

68 {this, "EMECNegIWCalibrationCalculator"

69 , "EMECNegInnerWheelCalibrationCalculator"}; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::InnerAbsorberWheel, -1)

◆ m_emenobarcalc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_emenobarcalc

private

Initial value:

{this, "EMECNegBOBCalibrationCalculator"

, "EMECNegBackOuterBarretteCalibrationCalculator"}

Definition at line 78 of file ActiveSDTool.h.

78 {this, "EMECNegBOBCalibrationCalculator"

79 , "EMECNegBackOuterBarretteCalibrationCalculator"}; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::BackOuterBarretteWheelCalib, 1)

◆ m_emenowcalc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_emenowcalc

private

Initial value:

{this, "EMECNegOWCalibrationCalculator"

, "EMECNegOuterWheelCalibrationCalculator"}

Definition at line 72 of file ActiveSDTool.h.

72 {this, "EMECNegOWCalibrationCalculator"

73 , "EMECNegOuterWheelCalibrationCalculator"}; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::OuterAbsorberWheel, -1)

◆ m_emepiwcalc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_emepiwcalc

private

Initial value:

{this, "EMECPosIWCalibrationCalculator"

, "EMECPosInnerWheelCalibrationCalculator"}

Definition at line 66 of file ActiveSDTool.h.

66 {this, "EMECPosIWCalibrationCalculator"

67 , "EMECPosInnerWheelCalibrationCalculator"}; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::InnerAbsorberWheel, 1)

◆ m_emepobarcalc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_emepobarcalc

private

Initial value:

{this, "EMECPosBOBCalibrationCalculator"

, "EMECPosBackOuterBarretteCalibrationCalculator"}

Definition at line 76 of file ActiveSDTool.h.

76 {this, "EMECPosBOBCalibrationCalculator"

77 , "EMECPosBackOuterBarretteCalibrationCalculator"}; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::BackOuterBarretteWheelCalib, 1)

◆ m_emepowcalc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_emepowcalc

private

Initial value:

{this, "EMECPosOWCalibrationCalculator"

, "EMECPosOuterWheelCalibrationCalculator"}

Definition at line 70 of file ActiveSDTool.h.

70 {this, "EMECPosOWCalibrationCalculator"

71 , "EMECPosOuterWheelCalibrationCalculator"}; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::OuterAbsorberWheel, 1)

◆ m_emepscalc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_emepscalc

private

Initial value:

{this, "EMECPSCalibrationCalculator"

, "EMECPresamplerCalibrationCalculator"}

Definition at line 74 of file ActiveSDTool.h.

74 {this, "EMECPSCalibrationCalculator"

75 , "EMECPresamplerCalibrationCalculator"}; //LArG4::EC::PresamplerCalibrationCalculator

◆ m_fcal1calc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_fcal1calc {this, "FCAL1CalibCalculator", "FCAL1CalibCalculator"}

private

Definition at line 82 of file ActiveSDTool.h.

82{this, "FCAL1CalibCalculator", "FCAL1CalibCalculator"};

◆ m_fcal1Volumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_fcal1Volumes {this, "FCAL1Volumes"}

private

Definition at line 56 of file ActiveSDTool.h.

56{this, "FCAL1Volumes"};

◆ m_fcal2calc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_fcal2calc {this, "FCAL2CalibCalculator", "FCAL2CalibCalculator"}

private

Definition at line 83 of file ActiveSDTool.h.

83{this, "FCAL2CalibCalculator", "FCAL2CalibCalculator"};

◆ m_fcal2Volumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_fcal2Volumes {this, "FCAL2Volumes"}

private

Definition at line 57 of file ActiveSDTool.h.

57{this, "FCAL2Volumes"};

◆ m_fcal3calc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_fcal3calc {this, "FCAL3CalibCalculator", "FCAL3CalibCalculator"}

private

Definition at line 84 of file ActiveSDTool.h.

84{this, "FCAL3CalibCalculator", "FCAL3CalibCalculator"};

◆ m_fcal3Volumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_fcal3Volumes {this, "FCAL3Volumes"}

private

Definition at line 58 of file ActiveSDTool.h.

58{this, "FCAL3Volumes"};

◆ m_heccalc

ServiceHandle<ILArCalibCalculatorSvc> LArG4::ActiveSDTool::m_heccalc

private

Initial value:

{this, "HECWActiveCalculator"

, "HECCalibrationWheelActiveCalculator"}

Definition at line 80 of file ActiveSDTool.h.

80 {this, "HECWActiveCalculator"

81 , "HECCalibrationWheelActiveCalculator"}; //LArG4::HEC::LArHECCalibrationWheelCalculator(LArG4::HEC::kWheelActive)

◆ m_hitCollName

Gaudi::Property<std::string> LArG4::ActiveSDTool::m_hitCollName {this, "HitCollectionName", "LArCalibrationHitActive"}

private

Hit collection name.

Definition at line 43 of file ActiveSDTool.h.

43{this, "HitCollectionName", "LArCalibrationHitActive"};

◆ m_id_helper

const AtlasDetectorID* LArG4::CalibSDTool::m_id_helper {nullptr}

protectedinherited

Definition at line 98 of file CalibSDTool.h.

98{nullptr};

◆ m_larEmID

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

protectedinherited

Definition at line 94 of file CalibSDTool.h.

94{nullptr};

◆ m_larFcalID

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

protectedinherited

Definition at line 95 of file CalibSDTool.h.

95{nullptr};

◆ m_larHecID

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

protectedinherited

Definition at line 96 of file CalibSDTool.h.

96{nullptr};

◆ m_nBOBVolumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_nBOBVolumes {this, "NegBOBarretteVolumes"}

private

Definition at line 55 of file ActiveSDTool.h.

55{this, "NegBOBarretteVolumes"};

◆ m_negIWVolumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_negIWVolumes {this, "NegIWVolumes"}

private

Definition at line 50 of file ActiveSDTool.h.

50{this, "NegIWVolumes"};

◆ m_negOWVolumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_negOWVolumes {this, "NegOWVolumes"}

private

Definition at line 52 of file ActiveSDTool.h.

52{this, "NegOWVolumes"};

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

83{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.

80{this, "OutputCollectionNames", {}};

◆ m_pBOBVolumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_pBOBVolumes {this, "PosBOBarretteVolumes"}

private

Definition at line 54 of file ActiveSDTool.h.

54{this, "PosBOBarretteVolumes"};

◆ m_posIWVolumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_posIWVolumes {this, "PosIWVolumes"}

private

Definition at line 49 of file ActiveSDTool.h.

49{this, "PosIWVolumes"};

◆ m_posOWVolumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_posOWVolumes {this, "PosOWVolumes"}

private

Definition at line 51 of file ActiveSDTool.h.

51{this, "PosOWVolumes"};

◆ m_presBarVolumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_presBarVolumes {this, "PresamplerVolumes"}

private

Definition at line 48 of file ActiveSDTool.h.

48{this, "PresamplerVolumes"};

◆ m_presECVolumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_presECVolumes {this, "PresVolumes"}

private

Definition at line 53 of file ActiveSDTool.h.

53{this, "PresVolumes"};

◆ m_sliceVolumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_sliceVolumes {this, "SliceVolumes"}

private

Definition at line 59 of file ActiveSDTool.h.

59{this, "SliceVolumes"};

◆ m_stacVolumes

Gaudi::Property<std::vector<std::string> > LArG4::ActiveSDTool::m_stacVolumes {this, "StacVolumes"}

private

Definition at line 47 of file ActiveSDTool.h.

47{this, "StacVolumes"};

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

78{this, "LogicalVolumeNames", {}};

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

ActiveSDTool.h

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ActiveSDTool()

Member Function Documentation

◆ assignSD()

◆ deadHitCollectionName()

◆ Gather()

◆ hitCollectionName()

◆ initialize()

◆ initializeCalculators()

◆ initializeSD()

◆ makeOneSD()

◆ makeSD()

◆ matchStrings()

◆ SetSensitiveDetector()

◆ SetupEvent()

◆ srHitCollectionName()

Member Data Documentation

◆ m_bpsmodcalc

◆ m_caloDmID

◆ m_doPID

◆ m_embcalc

◆ m_emeniwcalc

◆ m_emenobarcalc

◆ m_emenowcalc

◆ m_emepiwcalc

◆ m_emepobarcalc

◆ m_emepowcalc

◆ m_emepscalc

◆ m_fcal1calc

◆ m_fcal1Volumes

◆ m_fcal2calc

◆ m_fcal2Volumes

◆ m_fcal3calc

◆ m_fcal3Volumes

◆ m_heccalc

◆ m_hitCollName

◆ m_id_helper

◆ m_larEmID

◆ m_larFcalID

◆ m_larHecID

◆ m_nBOBVolumes

◆ m_negIWVolumes

◆ m_negOWVolumes

◆ m_noVolumes

◆ m_outputCollectionNames

◆ m_pBOBVolumes

◆ m_posIWVolumes

◆ m_posOWVolumes

◆ m_presBarVolumes

◆ m_presECVolumes

◆ m_sliceVolumes

◆ m_stacVolumes

◆ m_volumeNames