ATLAS Offline Software
FCS_StepInfoSDTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "FCS_StepInfoSDTool.h"
6 
7 #include <memory>
8 
9 // External includes
10 #include "CLHEP/Units/SystemOfUnits.h"
11 
12 // Athena includes
17 #include "CaloIdentifier/TileID.h"
19 #include "LArG4Code/VolumeUtils.h"
21 
22 // Local includes
23 #include "LArFCS_StepInfoSD.h"
24 #include "SDWrapper.h"
25 #include "TileFCS_StepInfoSD.h"
26 
30 
31 namespace FCS_Param {
32 
33 //---------------------------------------------------------------------------
34 // Tool constructor
35 //---------------------------------------------------------------------------
37  const std::string& name,
38  const IInterface* parent)
40  m_hitCollName("MergedEventSteps"),
41  m_bpsmodcalc("EMBPresamplerCalculator", name),
42  m_embcalc("EMBCalculator", name),
43  m_emepiwcalc("EMECPosInnerWheelCalculator", name),
44  m_emeniwcalc("EMECNegInnerWheelCalculator", name),
45  m_emepowcalc("EMECPosOuterWheelCalculator", name),
46  m_emenowcalc("EMECNegOuterWheelCalculator", name),
47  m_emepscalc("EMECPresamplerCalculator", name),
48  m_emepobarcalc("EMECPosBackOuterBarretteCalculator", name),
49  m_emenobarcalc("EMECNegBackOuterBarretteCalculator", name),
50  m_heccalc("HECWheelCalculator", name),
51  m_fcal1calc("FCAL1Calculator", name),
52  m_fcal2calc("FCAL2Calculator", name),
53  m_fcal3calc("FCAL3Calculator", name),
54  m_tileCalculator("TileGeoG4SDCalc", name),
55  m_larEmID(nullptr),
56  m_larFcalID(nullptr),
57  m_larHecID(nullptr),
58  m_tileID(nullptr),
59  m_config() {
60  declareProperty("HitCollectionName", m_hitCollName);
61  declareProperty("StacVolumes", m_stacVolumes);
62  declareProperty("PresamplerVolumes", m_presBarVolumes);
63  declareProperty("PosIWVolumes", m_posIWVolumes);
64  declareProperty("NegIWVolumes", m_negIWVolumes);
65  declareProperty("PosOWVolumes", m_posOWVolumes);
66  declareProperty("NegOWVolumes", m_negOWVolumes);
67  declareProperty("PresVolumes", m_presECVolumes);
68  declareProperty("PosBOBarretteVolumes", m_pBOBVolumes);
69  declareProperty("NegBOBarretteVolumes", m_nBOBVolumes);
70  declareProperty("FCAL1Volumes", m_fcal1Volumes);
71  declareProperty("FCAL2Volumes", m_fcal2Volumes);
72  declareProperty("FCAL3Volumes", m_fcal3Volumes);
73  declareProperty("SliceVolumes", m_sliceVolumes);
74  declareProperty("TileVolumes", m_tileVolumes);
75 
76  declareProperty("EMBPSCalculator", m_bpsmodcalc);
77  declareProperty("EMBCalculator", m_embcalc);
78  declareProperty("EMECPosIWCalculator", m_emepiwcalc);
79  declareProperty("EMECNegIWCalculator", m_emeniwcalc);
80  declareProperty("EMECPosOWCalculator", m_emepowcalc);
81  declareProperty("EMECNegOWCalculator", m_emenowcalc);
82  declareProperty("EMECPSCalculator", m_emepscalc);
83  declareProperty("EMECPosBOBCalculator", m_emepobarcalc);
84  declareProperty("EMECNegBOBCalculator", m_emenobarcalc);
85  declareProperty("HECWActiveCalculator", m_heccalc);
86  declareProperty("FCAL1Calculator", m_fcal1calc);
87  declareProperty("FCAL2Calculator", m_fcal2calc);
88  declareProperty("FCAL3Calculator", m_fcal3calc);
89  declareProperty("TileCalculator", m_tileCalculator);
90 
91  declareProperty("shift_lar_subhit", m_config.shift_lar_subhit, "");
92  declareProperty("shorten_lar_step", m_config.shorten_lar_step, "");
93 
94  declareProperty("maxRadiusLateral", m_config.m_maxRadiusLateral, "");
95  declareProperty("maxRadiusLongitudinal", m_config.m_maxRadiusLongitudinal,
96  "");
97 
98  declareProperty("maxTime", m_config.m_maxTime, "");
99  declareProperty("maxTimeLAr", m_config.m_maxTimeLAr, "");
100  declareProperty("maxTimeHEC", m_config.m_maxTimeHEC, "");
101  declareProperty("maxTimeFCAL", m_config.m_maxTimeFCAL, "");
102  declareProperty("maxTimeTile", m_config.m_maxTimeTile, "");
103 }
104 
105 //---------------------------------------------------------------------------
106 // Initialize the tool
107 //---------------------------------------------------------------------------
109  ATH_MSG_DEBUG("Initializing " << name());
110 
111  const CaloIdManager* idMgr = nullptr;
112  CHECK(detStore()->retrieve(idMgr));
113  m_larEmID = idMgr->getEM_ID();
114  if (m_larEmID == nullptr) {
115  ATH_MSG_ERROR("Invalid LAr EM ID helper");
116  return StatusCode::FAILURE;
117  }
118  m_larFcalID = idMgr->getFCAL_ID();
119  if (m_larFcalID == nullptr) {
120  ATH_MSG_ERROR("Invalid LAr FCAL ID helper");
121  return StatusCode::FAILURE;
122  }
123  m_larHecID = idMgr->getHEC_ID();
124  if (m_larHecID == nullptr) {
125  ATH_MSG_ERROR("Invalid LAr HEC ID helper");
126  return StatusCode::FAILURE;
127  }
128  m_tileID = idMgr->getTileID();
129  if (m_tileID == nullptr) {
130  ATH_MSG_ERROR("Invalid Tile ID helper");
131  return StatusCode::FAILURE;
132  }
133 
134  // No general volume list for SensitiveDetectorBase
135  m_noVolumes = true;
136 
138 
139  return StatusCode::SUCCESS;
140 }
141 
142 //---------------------------------------------------------------------------
143 // Initialization of Athena-components
144 //---------------------------------------------------------------------------
146  // Lots of calculators !!!
147  ATH_CHECK(m_bpsmodcalc.retrieve());
148  ATH_CHECK(m_embcalc.retrieve());
149  ATH_CHECK(m_emepiwcalc.retrieve());
150  ATH_CHECK(m_emeniwcalc.retrieve());
151  ATH_CHECK(m_emepowcalc.retrieve());
152  ATH_CHECK(m_emenowcalc.retrieve());
153  ATH_CHECK(m_emepscalc.retrieve());
154  ATH_CHECK(m_emepobarcalc.retrieve());
155  ATH_CHECK(m_emenobarcalc.retrieve());
156  ATH_CHECK(m_heccalc.retrieve());
157  ATH_CHECK(m_fcal1calc.retrieve());
158  ATH_CHECK(m_fcal2calc.retrieve());
159  ATH_CHECK(m_fcal3calc.retrieve());
160  ATH_CHECK(m_tileCalculator.retrieve());
161 
162  return StatusCode::SUCCESS;
163 }
164 
165 //---------------------------------------------------------------------------
166 // Collect hits for this event
167 //---------------------------------------------------------------------------
169  ATH_MSG_DEBUG("Gathering hits to write out in " << name());
170  auto* sdWrapper = dynamic_cast<FCS_StepInfoSDWrapper*>(getSD());
171  if (!sdWrapper) {
172  ATH_MSG_ERROR("Failed to cast SD to FCS_StepInfoSDWrapper");
173  return StatusCode::FAILURE;
174  }
175  sdWrapper->EndOfAthenaEvent();
176  return StatusCode::SUCCESS;
177 }
178 
179 //---------------------------------------------------------------------------
180 // Create SD wrapper for current thread
181 //---------------------------------------------------------------------------
182 G4VSensitiveDetector* FCS_StepInfoSDTool::makeSD() const {
183  // Create the wrapper
184  auto* sdWrapper =
185  new FCS_StepInfoSDWrapper("FCS_StepInfoSDWrapper", m_hitCollName);
186 
187  // Create the SDs.
188  sdWrapper->addSD(makeOneLArSD("Barrel::Presampler::Module::StepInfo",
190  sdWrapper->addSD(
191  makeOneLArSD("EMB::STAC::StepInfo", &*m_embcalc, m_stacVolumes));
192  sdWrapper->addSD(makeOneLArSD("EMEC::Pos::InnerWheel::StepInfo",
194  sdWrapper->addSD(makeOneLArSD("EMEC::Neg::InnerWheel::StepInfo",
196  sdWrapper->addSD(makeOneLArSD("EMEC::Pos::OuterWheel::StepInfo",
198  sdWrapper->addSD(makeOneLArSD("EMEC::Neg::OuterWheel::StepInfo",
200  sdWrapper->addSD(makeOneLArSD("Endcap::Presampler::LiquidArgon::StepInfo",
202  sdWrapper->addSD(makeOneLArSD("EMEC::Pos::BackOuterBarrette::StepInfo",
204  sdWrapper->addSD(makeOneLArSD("EMEC::Neg::BackOuterBarrette::StepInfo",
206  sdWrapper->addSD(makeOneLArSD("FCAL::Module1::Gap::StepInfo", &*m_fcal1calc,
207  m_fcal1Volumes));
208  sdWrapper->addSD(makeOneLArSD("FCAL::Module2::Gap::StepInfo", &*m_fcal2calc,
209  m_fcal2Volumes));
210  sdWrapper->addSD(makeOneLArSD("FCAL::Module3::Gap::StepInfo", &*m_fcal3calc,
211  m_fcal3Volumes));
212  sdWrapper->addSD(makeOneLArSD("HEC::Module::Depth::Slice::Wheel::StepInfo",
214  sdWrapper->addSD(makeOneTileSD("Tile::Scintillator::StepInfo",
216 
217  return sdWrapper;
218 }
219 
220 //---------------------------------------------------------------------------
221 // Create one LAr SD
222 //---------------------------------------------------------------------------
223 std::unique_ptr<FCS_StepInfoSD> FCS_StepInfoSDTool::makeOneLArSD(
224  const std::string& sdName, ILArCalculatorSvc* calc,
225  const std::vector<std::string>& volumes) const {
226  ATH_MSG_VERBOSE(name() << " makeOneSD");
227 
228  // Parse the wildcard patterns for existing volume names
229  auto parsedVolumes = LArG4::findLogicalVolumes(
230  volumes, msg()); // from LArG4Code/VolumeUtils.h
231 
232  // Inject the Calculator into m_config
234  config.m_LArCalculator = calc;
235  if (!calc) {
236  throw GaudiException(
237  "nullptr for ILArCalculatorSvc provided to constructor for: " + sdName,
238  name(), StatusCode::FAILURE);
239  }
240  if (msgLvl(MSG::VERBOSE)) {
241  config.verboseLevel = 10;
242  } else if (msgLvl(MSG::DEBUG)) {
243  config.verboseLevel = 5;
244  }
245  // Create the simple SD
246  std::unique_ptr<FCS_StepInfoSD> sd =
247  std::make_unique<LArFCS_StepInfoSD>(sdName, config);
248  sd->setupHelpers(m_larEmID, m_larFcalID, m_larHecID, m_tileID);
249 
250  // Assign the volumes to the SD
251  if (this->assignSD(sd.get(), parsedVolumes).isFailure()) {
252  // TODO: can I just return NULL here?
253  throw GaudiException("Failed to assign sd: " + sdName, name(),
254  StatusCode::FAILURE);
255  }
256  return sd;
257 }
258 
259 //---------------------------------------------------------------------------
260 // Create one Tile SD
261 //---------------------------------------------------------------------------
262 std::unique_ptr<FCS_StepInfoSD> FCS_StepInfoSDTool::makeOneTileSD(
263  const std::string& sdName, ITileCalculator* calc,
264  const std::vector<std::string>& volumes) const {
265  ATH_MSG_VERBOSE(name() << " makeOneSD");
266 
267  // Inject the Calculator into m_config
269  config.m_TileCalculator = calc;
270  if (!calc) {
271  throw GaudiException(
272  "nullptr for ITileCalculator provided to constructor for: " + sdName,
273  name(), StatusCode::FAILURE);
274  }
275  if (msgLvl(MSG::VERBOSE)) {
276  config.verboseLevel = 10;
277  } else if (msgLvl(MSG::DEBUG)) {
278  config.verboseLevel = 5;
279  }
280  // Create the simple SD
281  std::unique_ptr<FCS_StepInfoSD> sd =
282  std::make_unique<TileFCS_StepInfoSD>(sdName, config);
283  sd->setupHelpers(m_larEmID, m_larFcalID, m_larHecID, m_tileID);
284 
285  // Assign the volumes to the SD
286  if (this->assignSD(sd.get(), volumes).isFailure()) {
287  // TODO: can I just return NULL here?
288  throw GaudiException("Failed to assign sd: " + sdName, name(),
289  StatusCode::FAILURE);
290  }
291  return sd;
292 }
293 
294 } // namespace FCS_Param
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
FCS_Param::FCS_StepInfoSDTool::m_fcal1calc
ServiceHandle< ILArCalculatorSvc > m_fcal1calc
Definition: FCS_StepInfoSDTool.h:111
FCS_Param::FCS_StepInfoSDTool::makeOneTileSD
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.
Definition: FCS_StepInfoSDTool.cxx:262
FCS_Param::FCS_StepInfoSDTool::m_larHecID
const LArHEC_ID * m_larHecID
Definition: FCS_StepInfoSDTool.h:120
FCS_Param::FCS_StepInfoSDTool::makeSD
G4VSensitiveDetector * makeSD() const override final
Create the SD wrapper for current worker thread.
Definition: FCS_StepInfoSDTool.cxx:182
FCS_Param::FCS_StepInfoSDTool::m_fcal1Volumes
std::vector< std::string > m_fcal1Volumes
Definition: FCS_StepInfoSDTool.h:84
FCS_Param::FCS_StepInfoSDTool::m_fcal2Volumes
std::vector< std::string > m_fcal2Volumes
Definition: FCS_StepInfoSDTool.h:85
LArEM_ID.h
TileFCS_StepInfoSD.h
FCS_Param::FCS_StepInfoSDTool::m_negOWVolumes
std::vector< std::string > m_negOWVolumes
Definition: FCS_StepInfoSDTool.h:80
FCS_Param::Config::m_maxRadiusLateral
std::vector< double > m_maxRadiusLateral
property, see LArG4GenShowerLib::LArG4GenShowerLib
Definition: FCS_StepInfoSD.h:46
FCS_Param::FCS_StepInfoSDTool::initializeCalculators
virtual StatusCode initializeCalculators()
Initialize Calculator Services.
Definition: FCS_StepInfoSDTool.cxx:145
FCS_Param::FCS_StepInfoSDTool::m_posOWVolumes
std::vector< std::string > m_posOWVolumes
Definition: FCS_StepInfoSDTool.h:79
FCS_Param::FCS_StepInfoSDTool::FCS_StepInfoSDTool
FCS_StepInfoSDTool(const std::string &type, const std::string &name, const IInterface *parent)
Constructor.
Definition: FCS_StepInfoSDTool.cxx:36
python.base_data.config
config
Definition: base_data.py:20
CaloIdManager::getEM_ID
const LArEM_ID * getEM_ID(void) const
Definition: CaloIdManager.cxx:80
ITileCalculator
Definition: ITileCalculator.h:67
FCS_Param::FCS_StepInfoSDTool::m_fcal2calc
ServiceHandle< ILArCalculatorSvc > m_fcal2calc
Definition: FCS_StepInfoSDTool.h:112
LArG4::findLogicalVolumes
std::set< std::string > findLogicalVolumes(const std::string &pattern)
Search for logical volumes in the G4 volume store.
FCS_Param::Config::shift_lar_subhit
bool shift_lar_subhit
Definition: FCS_StepInfoSD.h:40
SensitiveDetectorBase
Common base class for tools that create and manage Geant4 sensitive detectors.
Definition: SensitiveDetectorBase.h:50
FCS_StepInfoSDTool.h
Defines the FCS_StepInfoSDTool class.
FCS_Param::FCS_StepInfoSDTool::m_emepobarcalc
ServiceHandle< ILArCalculatorSvc > m_emepobarcalc
Definition: FCS_StepInfoSDTool.h:105
FCS_Param::FCS_StepInfoSDTool::m_embcalc
ServiceHandle< ILArCalculatorSvc > m_embcalc
Definition: FCS_StepInfoSDTool.h:94
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
FCS_Param::FCS_StepInfoSDTool::m_presECVolumes
std::vector< std::string > m_presECVolumes
Definition: FCS_StepInfoSDTool.h:81
LArHEC_ID.h
SensitiveDetectorBase::getSD
G4VSensitiveDetector * getSD()
Retrieve the current SD.
Definition: SensitiveDetectorBase.cxx:123
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
VolumeUtils.h
Standalone functions for dealing with LAr G4 volumes.
config
Definition: PhysicsAnalysis/AnalysisCommon/AssociationUtils/python/config.py:1
TileID.h
FCS_Param::FCS_StepInfoSDTool::m_stacVolumes
std::vector< std::string > m_stacVolumes
Definition: FCS_StepInfoSDTool.h:75
FCS_Param::FCS_StepInfoSDTool::m_presBarVolumes
std::vector< std::string > m_presBarVolumes
Definition: FCS_StepInfoSDTool.h:76
FCS_Param::FCS_StepInfoSDTool::m_negIWVolumes
std::vector< std::string > m_negIWVolumes
Definition: FCS_StepInfoSDTool.h:78
python.selector.AtlRunQuerySelectorLhcOlc.sd
sd
Definition: AtlRunQuerySelectorLhcOlc.py:611
FCS_Param::Config::m_maxRadiusLongitudinal
std::vector< double > m_maxRadiusLongitudinal
property, see LArG4GenShowerLib::LArG4GenShowerLib
Definition: FCS_StepInfoSD.h:49
FCS_Param::FCS_StepInfoSDTool::m_emenobarcalc
ServiceHandle< ILArCalculatorSvc > m_emenobarcalc
Definition: FCS_StepInfoSDTool.h:107
FCS_Param::FCS_StepInfoSDTool::m_larFcalID
const LArFCAL_ID * m_larFcalID
Definition: FCS_StepInfoSDTool.h:119
LArFCS_StepInfoSD.h
FCS_Param::FCS_StepInfoSDTool::m_emepowcalc
ServiceHandle< ILArCalculatorSvc > m_emepowcalc
Definition: FCS_StepInfoSDTool.h:99
CaloIdManager::getTileID
const TileID * getTileID(void) const
Definition: CaloIdManager.cxx:100
FCS_Param::FCS_StepInfoSDTool::makeOneLArSD
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.
Definition: FCS_StepInfoSDTool.cxx:223
CaloIdManager::getHEC_ID
const LArHEC_ID * getHEC_ID(void) const
Definition: CaloIdManager.cxx:95
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CaloIdManager
This class initializes the Calo (LAr and Tile) offline identifiers.
Definition: CaloIdManager.h:45
FCS_Param::FCS_StepInfoSDTool::m_fcal3calc
ServiceHandle< ILArCalculatorSvc > m_fcal3calc
Definition: FCS_StepInfoSDTool.h:113
FCS_Param::FCS_StepInfoSDTool::m_tileVolumes
std::vector< std::string > m_tileVolumes
Definition: FCS_StepInfoSDTool.h:88
FCS_Param::Config::m_maxTimeTile
double m_maxTimeTile
Definition: FCS_StepInfoSD.h:57
FCS_Param::FCS_StepInfoSDTool::m_bpsmodcalc
ServiceHandle< ILArCalculatorSvc > m_bpsmodcalc
Definition: FCS_StepInfoSDTool.h:92
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CaloIdManager::getFCAL_ID
const LArFCAL_ID * getFCAL_ID(void) const
Definition: CaloIdManager.cxx:85
FCS_Param::FCS_StepInfoSDTool::m_hitCollName
std::string m_hitCollName
Hit collection name.
Definition: FCS_StepInfoSDTool.h:71
FCS_Param::Config::m_maxTime
double m_maxTime
Definition: FCS_StepInfoSD.h:53
FCS_Param::FCS_StepInfoSDTool::m_config
FCS_Param::Config m_config
Definition: FCS_StepInfoSDTool.h:123
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
ILArCalculatorSvc
Definition: ILArCalculatorSvc.h:25
FCS_Param
Definition: FCS_StepInfoSD.h:35
SDWrapper.h
FCS_Param::Config::m_maxTimeFCAL
double m_maxTimeFCAL
Definition: FCS_StepInfoSD.h:56
FCS_Param::FCS_StepInfoSDTool::m_tileCalculator
ServiceHandle< ITileCalculator > m_tileCalculator
Definition: FCS_StepInfoSDTool.h:114
FCS_Param::FCS_StepInfoSDWrapper
detail::SDWrapper< FCS_StepInfoSD, ISF_FCS_Parametrization::FCS_StepInfoCollection > FCS_StepInfoSDWrapper
Template instantiation for LArG4SimpleSD.
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.h:85
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
FCS_Param::FCS_StepInfoSDTool::m_sliceVolumes
std::vector< std::string > m_sliceVolumes
Definition: FCS_StepInfoSDTool.h:87
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
FCS_Param::FCS_StepInfoSDTool::m_tileID
const TileID * m_tileID
Definition: FCS_StepInfoSDTool.h:121
FCS_Param::FCS_StepInfoSDTool::m_larEmID
const LArEM_ID * m_larEmID
Definition: FCS_StepInfoSDTool.h:118
FCS_Param::FCS_StepInfoSDTool::Gather
StatusCode Gather() override final
Calls down to all the SDs to pack their hits into one collection.
Definition: FCS_StepInfoSDTool.cxx:168
FCS_Param::Config::m_maxTimeHEC
double m_maxTimeHEC
Definition: FCS_StepInfoSD.h:55
FCS_Param::FCS_StepInfoSDTool::m_heccalc
ServiceHandle< ILArCalculatorSvc > m_heccalc
Definition: FCS_StepInfoSDTool.h:110
FCS_Param::FCS_StepInfoSDTool::m_emepscalc
ServiceHandle< ILArCalculatorSvc > m_emepscalc
Definition: FCS_StepInfoSDTool.h:104
LArFCAL_ID.h
ILArCalculatorSvc.h
FCS_Param::Config::m_maxTimeLAr
double m_maxTimeLAr
Definition: FCS_StepInfoSD.h:54
SensitiveDetectorBase::m_noVolumes
Gaudi::Property< bool > m_noVolumes
This SensitiveDetector has no volumes associated with it.
Definition: SensitiveDetectorBase.h:101
FCS_Param::FCS_StepInfoSDTool::m_emepiwcalc
ServiceHandle< ILArCalculatorSvc > m_emepiwcalc
Definition: FCS_StepInfoSDTool.h:95
DEBUG
#define DEBUG
Definition: page_access.h:11
ITileCalculator.h
FCS_StepInfoSD
Common sensitive detector class for LAr systems.
Definition: FCS_StepInfoSD.h:71
ISF_FCS_Parametrization::FCS_StepInfoCollection
Class for collection of StepInfo class (G4 hits) copied and modified version to ISF.
Definition: FCS_StepInfoCollection.h:30
CaloIdManager.h
FCS_Param::detail::SDWrapper
A template class which wraps multiple sensitive detectors.
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.h:47
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
FCS_Param::Config
Definition: FCS_StepInfoSD.h:37
FCS_Param::FCS_StepInfoSDTool::initialize
StatusCode initialize() override final
Initialize the tool.
Definition: FCS_StepInfoSDTool.cxx:108
FCS_Param::Config::shorten_lar_step
bool shorten_lar_step
Definition: FCS_StepInfoSD.h:41
FCS_Param::FCS_StepInfoSDTool::m_posIWVolumes
std::vector< std::string > m_posIWVolumes
Definition: FCS_StepInfoSDTool.h:77
beamspotnt.calc
calc
Definition: bin/beamspotnt.py:1251
FCS_Param::FCS_StepInfoSDTool::m_nBOBVolumes
std::vector< std::string > m_nBOBVolumes
Definition: FCS_StepInfoSDTool.h:83
FCS_Param::FCS_StepInfoSDTool::m_emeniwcalc
ServiceHandle< ILArCalculatorSvc > m_emeniwcalc
Definition: FCS_StepInfoSDTool.h:97
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
FCS_Param::FCS_StepInfoSDTool::m_fcal3Volumes
std::vector< std::string > m_fcal3Volumes
Definition: FCS_StepInfoSDTool.h:86
SensitiveDetectorBase::assignSD
StatusCode assignSD(G4VSensitiveDetector *sd, const std::vector< std::string > &volumes) const
Assign SD to a list of volumes.
Definition: SensitiveDetectorBase.cxx:70
FCS_Param::FCS_StepInfoSDTool::m_emenowcalc
ServiceHandle< ILArCalculatorSvc > m_emenowcalc
Definition: FCS_StepInfoSDTool.h:101
FCS_Param::FCS_StepInfoSDTool::m_pBOBVolumes
std::vector< std::string > m_pBOBVolumes
Definition: FCS_StepInfoSDTool.h:82