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
13 #include "CaloIdentifier/CaloIdManager.h"
14 #include "CaloIdentifier/LArEM_ID.h"
15 #include "CaloIdentifier/LArFCAL_ID.h"
16 #include "CaloIdentifier/LArHEC_ID.h"
17 #include "CaloIdentifier/TileID.h"
18 #include "LArG4Code/ILArCalculatorSvc.h"
19 #include "LArG4Code/VolumeUtils.h"
20 #include "TileG4Interfaces/ITileCalculator.h"
21 
22 // Local includes
23 #include "LArFCS_StepInfoSD.h"
24 #include "TileFCS_StepInfoSD.h"
25 #include "SDWrapper.h"
26 
28 using FCS_StepInfoSDWrapper = FCS_Param::detail::SDWrapper<FCS_StepInfoSD, ISF_FCS_Parametrization::FCS_StepInfoCollection>;
29 
30 namespace FCS_Param
31 {
32 
33  //---------------------------------------------------------------------------
34  // Tool constructor
35  //---------------------------------------------------------------------------
36  FCS_StepInfoSDTool::FCS_StepInfoSDTool(const std::string& type, const std::string& name,
37  const IInterface* parent)
38  : SensitiveDetectorBase(type, name, parent)
39  , m_hitCollName("MergedEventSteps")
40  , m_bpsmodcalc("EMBPresamplerCalculator", name)
41  , m_embcalc("EMBCalculator", name)
42  , m_emepiwcalc("EMECPosInnerWheelCalculator", name)
43  , m_emeniwcalc("EMECNegInnerWheelCalculator", name)
44  , m_emepowcalc("EMECPosOuterWheelCalculator", name)
45  , m_emenowcalc("EMECNegOuterWheelCalculator", name)
46  , m_emepscalc("EMECPresamplerCalculator", name)
47  , m_emepobarcalc("EMECPosBackOuterBarretteCalculator", name)
48  , m_emenobarcalc("EMECNegBackOuterBarretteCalculator", name)
49  , m_heccalc("HECWheelCalculator", name)
50  , m_fcal1calc("FCAL1Calculator", name)
51  , m_fcal2calc("FCAL2Calculator", name)
52  , m_fcal3calc("FCAL3Calculator", name)
53  , m_tileCalculator("TileGeoG4SDCalc", name)
54  , m_larEmID(nullptr)
55  , m_larFcalID(nullptr)
56  , m_larHecID(nullptr)
57  , m_tileID(nullptr)
58  , m_config()
59  {
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("maxRadius",m_config.m_maxRadius, "");
95  declareProperty("maxRadiusFine",m_config.m_maxRadiusFine, "");
96  declareProperty("maxRadiusLAr",m_config.m_maxRadiusLAr, "");
97  declareProperty("maxRadiusHEC",m_config.m_maxRadiusHEC, "");
98  declareProperty("maxRadiusFCAL",m_config.m_maxRadiusFCAL, "");
99  declareProperty("maxRadiusTile",m_config.m_maxRadiusTile, "");
100 
101  declareProperty("maxTime",m_config.m_maxTime, "");
102  declareProperty("maxTimeLAr",m_config.m_maxTimeLAr, "");
103  declareProperty("maxTimeHEC",m_config.m_maxTimeHEC, "");
104  declareProperty("maxTimeFCAL",m_config.m_maxTimeFCAL, "");
105  declareProperty("maxTimeTile",m_config.m_maxTimeTile, "");
106 
107  declareProperty("maxEtaPS", m_config.m_maxEtaPS, "");
108  declareProperty("maxPhiPS", m_config.m_maxPhiPS, "");
109  declareProperty("maxrPS", m_config.m_maxrPS, "");
110 
111  declareProperty("maxEtaEM1", m_config.m_maxEtaEM1, "");
112  declareProperty("maxPhiEM1", m_config.m_maxPhiEM1, "");
113  declareProperty("maxrEM1", m_config.m_maxrEM1, "");
114 
115  declareProperty("maxEtaEM2", m_config.m_maxEtaEM2, "");
116  declareProperty("maxPhiEM2", m_config.m_maxPhiEM2, "");
117  declareProperty("maxrEM2", m_config.m_maxrEM2, "");
118 
119  declareProperty("maxEtaEM3", m_config.m_maxEtaEM3, "");
120  declareProperty("maxPhiEM3", m_config.m_maxPhiEM3, "");
121  declareProperty("maxrEM3", m_config.m_maxrEM3, "");
122  }
123 
124  //---------------------------------------------------------------------------
125  // Initialize the tool
126  //---------------------------------------------------------------------------
127  StatusCode FCS_StepInfoSDTool::initialize()
128  {
129  ATH_MSG_DEBUG( "Initializing " << name() );
130 
131  const CaloIdManager* idMgr = nullptr;
132  CHECK( detStore()->retrieve(idMgr) );
133  m_larEmID = idMgr->getEM_ID();
134  if(m_larEmID == nullptr) {
135  ATH_MSG_ERROR("Invalid LAr EM ID helper");
136  return StatusCode::FAILURE;
137  }
138  m_larFcalID = idMgr->getFCAL_ID();
139  if(m_larFcalID == nullptr) {
140  ATH_MSG_ERROR("Invalid LAr FCAL ID helper");
141  return StatusCode::FAILURE;
142  }
143  m_larHecID = idMgr->getHEC_ID();
144  if(m_larHecID == nullptr) {
145  ATH_MSG_ERROR("Invalid LAr HEC ID helper");
146  return StatusCode::FAILURE;
147  }
148  m_tileID = idMgr->getTileID();
149  if(m_tileID == nullptr) {
150  ATH_MSG_ERROR("Invalid Tile ID helper");
151  return StatusCode::FAILURE;
152  }
153 
154  // No general volume list for SensitiveDetectorBase
155  m_noVolumes = true;
156 
157  ATH_CHECK(this->initializeCalculators());
158 
159  return StatusCode::SUCCESS;
160  }
161 
162  //---------------------------------------------------------------------------
163  // Initialization of Athena-components
164  //---------------------------------------------------------------------------
165  StatusCode FCS_StepInfoSDTool::initializeCalculators()
166  {
167  // Lots of calculators !!!
168  ATH_CHECK(m_bpsmodcalc.retrieve());
169  ATH_CHECK(m_embcalc.retrieve());
170  ATH_CHECK(m_emepiwcalc.retrieve());
171  ATH_CHECK(m_emeniwcalc.retrieve());
172  ATH_CHECK(m_emepowcalc.retrieve());
173  ATH_CHECK(m_emenowcalc.retrieve());
174  ATH_CHECK(m_emepscalc.retrieve());
175  ATH_CHECK(m_emepobarcalc.retrieve());
176  ATH_CHECK(m_emenobarcalc.retrieve());
177  ATH_CHECK(m_heccalc.retrieve());
178  ATH_CHECK(m_fcal1calc.retrieve());
179  ATH_CHECK(m_fcal2calc.retrieve());
180  ATH_CHECK(m_fcal3calc.retrieve());
181  ATH_CHECK(m_tileCalculator.retrieve());
182 
183  return StatusCode::SUCCESS;
184  }
185 
186  //---------------------------------------------------------------------------
187  // Collect hits for this event
188  //---------------------------------------------------------------------------
189  StatusCode FCS_StepInfoSDTool::Gather()
190  {
191  ATH_MSG_DEBUG("Gathering hits to write out in " << name());
192  auto *sdWrapper = dynamic_cast<FCS_StepInfoSDWrapper*>( getSD() );
193  if(!sdWrapper) {
194  ATH_MSG_ERROR("Failed to cast SD to FCS_StepInfoSDWrapper");
195  return StatusCode::FAILURE;
196  }
197  sdWrapper->EndOfAthenaEvent();
198  return StatusCode::SUCCESS;
199  }
200 
201  //---------------------------------------------------------------------------
202  // Create SD wrapper for current thread
203  //---------------------------------------------------------------------------
204  G4VSensitiveDetector* FCS_StepInfoSDTool::makeSD() const
205  {
206  // Create the wrapper
207  auto *sdWrapper = new FCS_StepInfoSDWrapper("FCS_StepInfoSDWrapper", m_hitCollName);
208 
209  // Create the SDs.
210  sdWrapper->addSD( makeOneLArSD( "Barrel::Presampler::Module::StepInfo", &*m_bpsmodcalc, m_presBarVolumes ) );
211  sdWrapper->addSD( makeOneLArSD( "EMB::STAC::StepInfo", &*m_embcalc, m_stacVolumes ) );
212  sdWrapper->addSD( makeOneLArSD( "EMEC::Pos::InnerWheel::StepInfo", &*m_emepiwcalc, m_posIWVolumes ) );
213  sdWrapper->addSD( makeOneLArSD( "EMEC::Neg::InnerWheel::StepInfo", &*m_emeniwcalc, m_negIWVolumes ) );
214  sdWrapper->addSD( makeOneLArSD( "EMEC::Pos::OuterWheel::StepInfo", &*m_emepowcalc, m_posOWVolumes ) );
215  sdWrapper->addSD( makeOneLArSD( "EMEC::Neg::OuterWheel::StepInfo", &*m_emenowcalc, m_negOWVolumes ) );
216  sdWrapper->addSD( makeOneLArSD( "Endcap::Presampler::LiquidArgon::StepInfo", &*m_emepscalc, m_presECVolumes ) );
217  sdWrapper->addSD( makeOneLArSD( "EMEC::Pos::BackOuterBarrette::StepInfo", &*m_emepobarcalc, m_pBOBVolumes ) );
218  sdWrapper->addSD( makeOneLArSD( "EMEC::Neg::BackOuterBarrette::StepInfo", &*m_emenobarcalc, m_nBOBVolumes ) );
219  sdWrapper->addSD( makeOneLArSD( "FCAL::Module1::Gap::StepInfo", &*m_fcal1calc, m_fcal1Volumes ) );
220  sdWrapper->addSD( makeOneLArSD( "FCAL::Module2::Gap::StepInfo", &*m_fcal2calc, m_fcal2Volumes ) );
221  sdWrapper->addSD( makeOneLArSD( "FCAL::Module3::Gap::StepInfo", &*m_fcal3calc, m_fcal3Volumes ) );
222  sdWrapper->addSD( makeOneLArSD( "HEC::Module::Depth::Slice::Wheel::StepInfo", &*m_heccalc, m_sliceVolumes ) );
223  sdWrapper->addSD( makeOneTileSD( "Tile::Scintillator::StepInfo", &*m_tileCalculator, m_tileVolumes ) );
224 
225  return sdWrapper;
226  }
227 
228  //---------------------------------------------------------------------------
229  // Create one LAr SD
230  //---------------------------------------------------------------------------
231  std::unique_ptr<FCS_StepInfoSD>
232  FCS_StepInfoSDTool::makeOneLArSD(const std::string& sdName, ILArCalculatorSvc* calc,
233  const std::vector<std::string>& volumes) const
234  {
235  ATH_MSG_VERBOSE( name() << " makeOneSD" );
236 
237  // Parse the wildcard patterns for existing volume names
238  auto parsedVolumes = LArG4::findLogicalVolumes(volumes, msg()); // from LArG4Code/VolumeUtils.h
239 
240  // Inject the Calculator into m_config
241  FCS_Param::Config config(m_config);
242  config.m_LArCalculator = calc;
243  if(!calc) {
244  throw GaudiException("nullptr for ILArCalculatorSvc provided to constructor for: " + sdName,
245  name(), StatusCode::FAILURE);
246  }
247  if(msgLvl(MSG::VERBOSE)) { config.verboseLevel = 10; }
248  else if(msgLvl(MSG::DEBUG)) { config.verboseLevel = 5; }
249  // Create the simple SD
250  std::unique_ptr<FCS_StepInfoSD> sd =
251  std::make_unique<LArFCS_StepInfoSD>(sdName, config);
252  sd->setupHelpers(m_larEmID, m_larFcalID, m_larHecID, m_tileID);
253 
254  // Assign the volumes to the SD
255  if( this->assignSD( sd.get(), parsedVolumes ).isFailure() ) {
256  // TODO: can I just return NULL here?
257  throw GaudiException("Failed to assign sd: " + sdName,
258  name(), StatusCode::FAILURE);
259  }
260  return sd;
261  }
262 
263  //---------------------------------------------------------------------------
264  // Create one Tile SD
265  //---------------------------------------------------------------------------
266  std::unique_ptr<FCS_StepInfoSD>
267  FCS_StepInfoSDTool::makeOneTileSD(const std::string& sdName, ITileCalculator* calc,
268  const std::vector<std::string>& volumes) const
269  {
270  ATH_MSG_VERBOSE( name() << " makeOneSD" );
271 
272  // Inject the Calculator into m_config
273  FCS_Param::Config config(m_config);
274  config.m_TileCalculator = calc;
275  if(!calc) {
276  throw GaudiException("nullptr for ITileCalculator provided to constructor for: " + sdName,
277  name(), StatusCode::FAILURE);
278  }
279  if(msgLvl(MSG::VERBOSE)) { config.verboseLevel = 10; }
280  else if(msgLvl(MSG::DEBUG)) { config.verboseLevel = 5; }
281  // Create the simple SD
282  std::unique_ptr<FCS_StepInfoSD> sd =
283  std::make_unique<TileFCS_StepInfoSD>(sdName, config);
284  sd->setupHelpers(m_larEmID, m_larFcalID, m_larHecID, m_tileID);
285 
286  // Assign the volumes to the SD
287  if( this->assignSD( sd.get(), volumes ).isFailure() ) {
288  // TODO: can I just return NULL here?
289  throw GaudiException("Failed to assign sd: " + sdName,
290  name(), StatusCode::FAILURE);
291  }
292  return sd;
293  }
294 
295 } // 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:105
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:267
FCS_Param::FCS_StepInfoSDTool::m_larHecID
const LArHEC_ID * m_larHecID
Definition: FCS_StepInfoSDTool.h:114
FCS_Param::FCS_StepInfoSDTool::makeSD
G4VSensitiveDetector * makeSD() const override final
Create the SD wrapper for current worker thread.
Definition: FCS_StepInfoSDTool.cxx:204
FCS_Param::FCS_StepInfoSDTool::m_fcal1Volumes
std::vector< std::string > m_fcal1Volumes
Definition: FCS_StepInfoSDTool.h:88
FCS_Param::Config::m_maxEtaEM3
double m_maxEtaEM3
Definition: FCS_StepInfoSD.h:76
FCS_Param::FCS_StepInfoSDTool::m_fcal2Volumes
std::vector< std::string > m_fcal2Volumes
Definition: FCS_StepInfoSDTool.h:89
LArEM_ID.h
TileFCS_StepInfoSD.h
FCS_Param::FCS_StepInfoSDTool::m_negOWVolumes
std::vector< std::string > m_negOWVolumes
Definition: FCS_StepInfoSDTool.h:84
FCS_Param::FCS_StepInfoSDTool::initializeCalculators
virtual StatusCode initializeCalculators()
Initialize Calculator Services.
Definition: FCS_StepInfoSDTool.cxx:165
FCS_Param::Config::m_maxRadius
double m_maxRadius
property, see LArG4GenShowerLib::LArG4GenShowerLib
Definition: FCS_StepInfoSD.h:50
FCS_Param::FCS_StepInfoSDTool::m_posOWVolumes
std::vector< std::string > m_posOWVolumes
Definition: FCS_StepInfoSDTool.h:83
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
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:106
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:45
SensitiveDetectorBase
Common base class for tools that create and manage Geant4 sensitive detectors.
Definition: SensitiveDetectorBase.h:42
FCS_StepInfoSDTool.h
Defines the FCS_StepInfoSDTool class.
FCS_Param::FCS_StepInfoSDTool::m_emepobarcalc
ServiceHandle< ILArCalculatorSvc > m_emepobarcalc
Definition: FCS_StepInfoSDTool.h:102
FCS_Param::Config::m_maxRadiusFine
double m_maxRadiusFine
property, see LArG4GenShowerLib::LArG4GenShowerLib
Definition: FCS_StepInfoSD.h:51
FCS_Param::Config::m_maxEtaPS
double m_maxEtaPS
Definition: FCS_StepInfoSD.h:64
FCS_Param::FCS_StepInfoSDTool::m_embcalc
ServiceHandle< ILArCalculatorSvc > m_embcalc
Definition: FCS_StepInfoSDTool.h:96
FCS_Param::Config::m_maxrEM3
double m_maxrEM3
Definition: FCS_StepInfoSD.h:78
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:85
LArHEC_ID.h
FCS_Param::Config::m_maxrEM1
double m_maxrEM1
Definition: FCS_StepInfoSD.h:70
FCS_Param::Config::m_maxrEM2
double m_maxrEM2
Definition: FCS_StepInfoSD.h:74
SensitiveDetectorBase::getSD
G4VSensitiveDetector * getSD()
Retrieve the current SD.
Definition: SensitiveDetectorBase.cxx:123
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:79
FCS_Param::FCS_StepInfoSDTool::m_presBarVolumes
std::vector< std::string > m_presBarVolumes
Definition: FCS_StepInfoSDTool.h:80
FCS_Param::Config::m_maxPhiPS
double m_maxPhiPS
Definition: FCS_StepInfoSD.h:65
FCS_Param::FCS_StepInfoSDTool::m_negIWVolumes
std::vector< std::string > m_negIWVolumes
Definition: FCS_StepInfoSDTool.h:82
python.selector.AtlRunQuerySelectorLhcOlc.sd
sd
Definition: AtlRunQuerySelectorLhcOlc.py:612
FCS_Param::Config::m_maxPhiEM3
double m_maxPhiEM3
Definition: FCS_StepInfoSD.h:77
FCS_Param::FCS_StepInfoSDTool::m_emenobarcalc
ServiceHandle< ILArCalculatorSvc > m_emenobarcalc
Definition: FCS_StepInfoSDTool.h:103
FCS_Param::Config::m_maxrPS
double m_maxrPS
Definition: FCS_StepInfoSD.h:66
FCS_Param::FCS_StepInfoSDTool::m_larFcalID
const LArFCAL_ID * m_larFcalID
Definition: FCS_StepInfoSDTool.h:113
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:232
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:107
FCS_Param::FCS_StepInfoSDTool::m_tileVolumes
std::vector< std::string > m_tileVolumes
Definition: FCS_StepInfoSDTool.h:92
FCS_Param::Config::m_maxTimeTile
double m_maxTimeTile
Definition: FCS_StepInfoSD.h:61
FCS_Param::FCS_StepInfoSDTool::m_bpsmodcalc
ServiceHandle< ILArCalculatorSvc > m_bpsmodcalc
Definition: FCS_StepInfoSDTool.h:95
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:75
FCS_Param::Config::m_maxTime
double m_maxTime
Definition: FCS_StepInfoSD.h:57
FCS_Param::FCS_StepInfoSDTool::m_config
FCS_Param::Config m_config
Definition: FCS_StepInfoSDTool.h:117
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:39
SDWrapper.h
FCS_Param::Config::m_maxTimeFCAL
double m_maxTimeFCAL
Definition: FCS_StepInfoSD.h:60
FCS_Param::FCS_StepInfoSDTool::m_tileCalculator
ServiceHandle< ITileCalculator > m_tileCalculator
Definition: FCS_StepInfoSDTool.h:108
FCS_Param::Config::m_maxPhiEM1
double m_maxPhiEM1
Definition: FCS_StepInfoSD.h:69
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:90
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
FCS_Param::FCS_StepInfoSDTool::m_sliceVolumes
std::vector< std::string > m_sliceVolumes
Definition: FCS_StepInfoSDTool.h:91
FCS_Param::Config::m_maxRadiusLAr
double m_maxRadiusLAr
property, see LArG4GenShowerLib::LArG4GenShowerLib
Definition: FCS_StepInfoSD.h:52
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
FCS_Param::FCS_StepInfoSDTool::m_tileID
const TileID * m_tileID
Definition: FCS_StepInfoSDTool.h:115
FCS_Param::FCS_StepInfoSDTool::m_larEmID
const LArEM_ID * m_larEmID
Definition: FCS_StepInfoSDTool.h:112
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:189
FCS_Param::Config::m_maxTimeHEC
double m_maxTimeHEC
Definition: FCS_StepInfoSD.h:59
FCS_Param::FCS_StepInfoSDTool::m_heccalc
ServiceHandle< ILArCalculatorSvc > m_heccalc
Definition: FCS_StepInfoSDTool.h:104
FCS_Param::FCS_StepInfoSDTool::m_emepscalc
ServiceHandle< ILArCalculatorSvc > m_emepscalc
Definition: FCS_StepInfoSDTool.h:101
LArFCAL_ID.h
FCS_Param::Config::m_maxRadiusTile
double m_maxRadiusTile
property, see LArG4GenShowerLib::LArG4GenShowerLib
Definition: FCS_StepInfoSD.h:55
ILArCalculatorSvc.h
FCS_Param::Config::m_maxTimeLAr
double m_maxTimeLAr
Definition: FCS_StepInfoSD.h:58
SensitiveDetectorBase::m_noVolumes
Gaudi::Property< bool > m_noVolumes
This SensitiveDetector has no volumes associated with it.
Definition: SensitiveDetectorBase.h:87
FCS_Param::FCS_StepInfoSDTool::m_emepiwcalc
ServiceHandle< ILArCalculatorSvc > m_emepiwcalc
Definition: FCS_StepInfoSDTool.h:97
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DEBUG
#define DEBUG
Definition: page_access.h:11
config
std::vector< std::string > config
Definition: fbtTestBasics.cxx:72
ITileCalculator.h
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
CaloIdManager.h
FCS_Param::Config::m_maxEtaEM2
double m_maxEtaEM2
Definition: FCS_StepInfoSD.h:72
FCS_Param::detail::SDWrapper
A template class which wraps multiple sensitive detectors.
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.h:51
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
FCS_Param::Config
Definition: FCS_StepInfoSD.h:42
FCS_Param::FCS_StepInfoSDTool::initialize
StatusCode initialize() override final
Initialize the tool.
Definition: FCS_StepInfoSDTool.cxx:127
FCS_Param::Config::shorten_lar_step
bool shorten_lar_step
Definition: FCS_StepInfoSD.h:46
FCS_Param::FCS_StepInfoSDTool::m_posIWVolumes
std::vector< std::string > m_posIWVolumes
Definition: FCS_StepInfoSDTool.h:81
beamspotnt.calc
calc
Definition: bin/beamspotnt.py:1252
FCS_Param::FCS_StepInfoSDTool::m_nBOBVolumes
std::vector< std::string > m_nBOBVolumes
Definition: FCS_StepInfoSDTool.h:87
FCS_Param::FCS_StepInfoSDTool::m_emeniwcalc
ServiceHandle< ILArCalculatorSvc > m_emeniwcalc
Definition: FCS_StepInfoSDTool.h:98
FCS_Param::Config::m_maxRadiusFCAL
double m_maxRadiusFCAL
property, see LArG4GenShowerLib::LArG4GenShowerLib
Definition: FCS_StepInfoSD.h:54
FCS_Param::Config::m_maxPhiEM2
double m_maxPhiEM2
Definition: FCS_StepInfoSD.h:73
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
FCS_Param::FCS_StepInfoSDTool::m_fcal3Volumes
std::vector< std::string > m_fcal3Volumes
Definition: FCS_StepInfoSDTool.h:90
FCS_Param::Config::m_maxRadiusHEC
double m_maxRadiusHEC
property, see LArG4GenShowerLib::LArG4GenShowerLib
Definition: FCS_StepInfoSD.h:53
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:100
FCS_Param::FCS_StepInfoSDTool::m_pBOBVolumes
std::vector< std::string > m_pBOBVolumes
Definition: FCS_StepInfoSDTool.h:86
FCS_Param::Config::m_maxEtaEM1
double m_maxEtaEM1
Definition: FCS_StepInfoSD.h:68
Generated on Fri Jul 5 2024 21:15:51 for ATLAS Offline Software by   doxygen 1.8.18