ATLAS Offline Software
CBNT_Timing.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "CBNT_Timing.h"
6 
7 #include "CLHEP/Units/SystemOfUnits.h"
8 
9 #include "CaloEvent/CaloCell.h"
10 #include "CaloEvent/CaloCellContainer.h"
11 
12 #include "CaloIdentifier/CaloCell_ID.h"
13 
14 #include "LArIdentifier/LArOnlineID.h"
15 #include "TBEvent/TBScintillatorCont.h"
16 #include "TBEvent/TBBPCCont.h"
17 #include "TBEvent/TBPhase.h"
18 #include "AthenaKernel/Units.h"
19 #include <vector>
20 
21 
22 using Athena::Units::GeV;
23 using Athena::Units::ns;
24 
25 
26 CBNT_Timing::CBNT_Timing(const std::string & name, ISvcLocator * pSvcLocator)
27  :CBNT_TBRecBase(name, pSvcLocator)
28  , m_onlineHelper(0)
29  , m_energy_cut(2.*GeV)
30  , m_first_event(true)
31  , m_caloCellName("AllCalo")
32 {
33  m_sampling_names.resize(0);
34 
35  declareProperty("TBPhase",m_tbphase="TBPhase");
36  declareProperty("CellContainerName", m_caloCellName);
37  declareProperty("EnergyCut", m_energy_cut);
38  declareProperty("IncludedSamplings", m_sampling_names);
39 
40  m_energy = 0;
41  m_tdc_phase = 0;
42  m_time = 0;
43 
44  m_energy_cell = 0;
45  m_eta_cell = 0;
46  m_febId_cell = 0;
47  m_febId_feb = 0;
48  m_feedthrough_feb = 0;
49  m_layer_cell = 0;
50  m_layer_layer = 0;
51  m_phi_cell = 0;
52  m_slot_feb = 0;
53  m_time_cell = 0;
54  m_time_feb = 0;
55  m_time_layer = 0;
56 }
57 
58 CBNT_Timing::~CBNT_Timing()
59 {//empty
60 }
61 
62 StatusCode CBNT_Timing::CBNT_initialize() {
63 
64  ATH_MSG_DEBUG ( "CBNT_Timing in initialize()" );
65 
66  ATH_CHECK( m_cablingKey.initialize() );
67  ATH_CHECK( detStore()->retrieve(m_onlineHelper, "LArOnlineID") );
68 
69  addBranch ("TDC_TimeCell",m_time_cell);
70  addBranch ("TDC_EnergyCell",m_energy_cell);
71  addBranch ("TDC_LayerCell",m_layer_cell);
72  addBranch ("TDC_EtaCell", m_eta_cell);
73  addBranch ("TDC_PhiCell", m_phi_cell);
74  addBranch ("TDC_FebIDCell", m_febId_cell);
75  addBranch ("TDC_TimeLayer",m_time_layer);
76  addBranch ("TDC_LayerIDLayer",m_layer_layer);
77  addBranch ("TDC_TimeFeb",m_time_feb);
78  addBranch ("TDC_FebIdFeb",m_febId_feb);
79  addBranch ("TDC_SlotFeb", m_slot_feb);
80  addBranch ("TDC_FeedthroughFeb", m_feedthrough_feb);
81  addBranch ("TDC_Phase",m_tdc_phase, "Phase/F");
82  addBranch ("TDC_TimeTotal",m_time, "TimeTotal/F");
83  addBranch ("TDC_EnergyTotal",m_energy, "EnergyTotal/F");
84 
85 
86 
87 
88  // setup calorimeter module and sampling lookup tables
89  ATH_CHECK( this->setupLookupTables() );
90 
91  // get calorimeter samplings ids for the requested samplings
92  msg() << MSG::INFO << "Included calorimeter samplings: ";
93  for (const std::string& sampling : m_sampling_names) {
94  CaloSampling::CaloSample idSamp = m_samplingFromNameLookup[sampling];
95  if (idSamp != CaloSampling::Unknown) {
96  m_samplingIndices.push_back(idSamp);
97  msg() << MSG::INFO << "\042" << sampling
98  << "\042 ";
99  }
100  }
101  msg() << MSG::INFO << endmsg;
102 
103  // get an idCalo keyed map of vectors of idSample for the requested samplings
104  for (CaloSampling::CaloSample idSample : m_samplingIndices) {
105  // find the idCalo
106  CaloCell_ID::SUBCALO idCalo = m_caloLookup[idSample];
107  // build the vector of idSample
108  std::vector<CaloSampling::CaloSample> samplingV = m_calosAndSamplings[idCalo];
109  samplingV.push_back(idSample);
110  m_calosAndSamplings[idCalo] = samplingV;
111  }
112  // printout
113  for (const auto& p : m_calosAndSamplings) {
114  CaloCell_ID::SUBCALO idCalo = p.first;
115  msg() << MSG::INFO
116  << "Included calorimeter : \042"
117  << m_caloToNameLookup[idCalo]
118  << "\042 samplings:";
119  const std::vector<CaloSampling::CaloSample>& samplingV = p.second;
120  for (CaloSampling::CaloSample sample : samplingV) {
121  msg() << MSG::INFO
122  << " \042"
123  << m_samplingToNameLookup[sample]
124  << "\042";
125  }
126  msg() << MSG::INFO << endmsg;
127  }
128 
129  return StatusCode::SUCCESS;
130 
131 }
132 
133 
134 StatusCode CBNT_Timing::CBNT_execute()
135 {
136  ATH_MSG_DEBUG ( "in execute()" );
137 
139  // Data Access //
141 
142  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
143  const LArOnOffIdMapping* cabling{*cablingHdl};
144  if(!cabling) {
145  ATH_MSG_ERROR( "Do not have cabling mapping from key " << m_cablingKey.key() );
146  return StatusCode::FAILURE;
147  }
148 
149  // CaloCells
150  const CaloCellContainer* cellContainer = nullptr;
151  ATH_CHECK( evtStore()->retrieve(cellContainer, m_caloCellName ) );
152 
153  // TBPhase
154  TBPhase * phase = nullptr;
155  ATH_CHECK( evtStore()->retrieve(phase,m_tbphase) );
156 
157  m_tdc_phase = phase->getPhase();
158 
160  // First Event Action //
162 
163  if (m_first_event) {
164 
165  // find all febID's related to the requested samplings
166  // loop over desired calorimeter modules first, more efficient this way
167  for (const auto& p : m_calosAndSamplings) {
168  CaloCell_ID::SUBCALO idCalo = p.first;
169  std::vector<CaloSampling::CaloSample> samplingV = p.second;
170 
171  // loop over the corresponding CaloCell's
172  for (CaloCellContainer::const_iterator cell = cellContainer->beginConstCalo(idCalo);
173  cell != cellContainer->endConstCalo(idCalo); ++cell) {
174 
175  // get the corresponding sample
176  CaloSampling::CaloSample idSample;
177  const CaloDetDescrElement * theCaloDDE= (*cell)->caloDDE();
178  if (theCaloDDE) {
179  idSample = (CaloSampling::CaloSample) theCaloDDE->getSampling();
180  }else{
181  idSample = CaloSampling::Unknown;
182  }
183 
184  // only consider CaloCell's in the requested sampling
185  if (find(samplingV.begin(), samplingV.end(), idSample) != samplingV.end()) {
186 
187  // here you have the CaloCell with idCalo, idSample, **cell
188  // find the hardware ID and the corresponding febID
189 
190  HWIdentifier id = cabling->createSignalChannelID((*cell)->ID());
191  HWIdentifier febID = m_onlineHelper->feb_Id(id);
192 
193  // store it if you don't have it already
194  if (find(m_febIDs.begin(), m_febIDs.end(), febID) == m_febIDs.end()) m_febIDs.push_back(febID);
195 
196  }
197  }
198  }
199  // print out
200  msg() << MSG::INFO << "FEB IDs: ";
201  for (HWIdentifier febID : m_febIDs) {
202  std::ostringstream os;
203  os << std::hex << febID;
204  msg() << MSG::INFO << " \042" << os.str() << "\042";
205  }
206  msg() << MSG::INFO << endmsg;
207 
208  m_first_event = false;
209  }
210 
211 
213  // sampling timing distributions //
215 
216  // energy weighted time stores
217  std::map<CaloSampling::CaloSample, double> sumEPerSampling, sumETimePerSampling; // sampling id keyed
218  std::map<HWIdentifier, double> sumEPerFeb, sumETimePerFeb; // febID keyed
219  double sumETotal = 0, sumETimeTotal = 0;
220  bool eSet = false;
221 
222  // fill energy weighted time stores
223  // loop over desired calorimeter modules first, more efficient this way
224  m_energy = 0;
225 
226  for (const auto& p : m_calosAndSamplings) {
227  CaloCell_ID::SUBCALO idCalo = p.first;
228  ATH_MSG_DEBUG
229  ( "Looping over CaloCells of calorimeter : \042"
230  << m_caloToNameLookup[idCalo]
231  << "\042" );
232  std::vector<CaloSampling::CaloSample> samplingV = p.second;
233 
234  // loop over the corresponding CaloCell's
235  for (CaloCellContainer::const_iterator cell = cellContainer->beginConstCalo(idCalo);
236  cell != cellContainer->endConstCalo(idCalo); ++cell) {
237 
238  // get the corresponding sample
239  //CaloSampling::CaloSample idSample = CaloSampling::getSampling(**cell);
240  CaloSampling::CaloSample idSample;
241  const CaloDetDescrElement * theCaloDDE= (*cell)->caloDDE();
242  if (theCaloDDE) {
243  idSample = (CaloSampling::CaloSample) theCaloDDE->getSampling();
244  }else{
245  idSample = CaloSampling::Unknown;
246  }
247 
248  // only consider CaloCell's in the requested sampling
249  if (find(samplingV.begin(), samplingV.end(), idSample) != samplingV.end()) {
250 
251  // here you have the CaloCell with idCalo, idSample, **cell
252  // find the hardware ID and the corresponding febID
253 
254  HWIdentifier id = cabling->createSignalChannelID((*cell)->ID());
255  HWIdentifier febID = m_onlineHelper->feb_Id(id);
256 
257  // gather sums for energy weighted cubic peaking time
258  // select cells for which the cubic interpolation was successfully applied
259  // *** for now, this is done by requiring that time(ns) is not too close to 25ns * n
260  // *** but it should be done using the CaloCell quality, when available...
261  // select cells above an energy threshold
262 
263  double energy = (*cell)->e();
264  double time = (*cell)->time();
265  if (fabs(time/ns - float(int(time/(25*ns))*25.)) > 0.001 && energy > m_energy_cut) {
266 
267  m_time_cell->push_back(time/ns);
268  m_energy_cell->push_back(energy/GeV);
269  m_energy += energy/GeV;
270 
271  sumEPerSampling[idSample] += energy;
272  sumETimePerSampling[idSample] += energy * time;
273 
274  sumEPerFeb[febID] += energy;
275  sumETimePerFeb[febID] += energy * time;
276 
277  sumETotal += energy;
278  sumETimeTotal += energy * time;
279  eSet = true;
280 
281  ATH_MSG_DEBUG
282  ( "cell time = " << time/ns << " ns"
283  << "; energy = " << energy/GeV << " GeV" );
284 
285  } else {
286  // below energy cut
287  m_time_cell->push_back(NOTIME);
288  m_energy_cell->push_back(NOENERGY);
289  }
290 
291  m_febId_cell->push_back(febID.get_identifier32().get_compact());
292  //try {
293  //const Identifier ident = cabling->cnvToIdentifier(id);
294  if ( m_emId->is_lar_em((*cell)->ID()) ) {
295  m_eta_cell->push_back(m_emId->eta((*cell)->ID()));
296  m_phi_cell->push_back(m_emId->phi((*cell)->ID()));
297  m_layer_cell->push_back(m_emId->sampling((*cell)->ID()));
298  } else {
299  m_eta_cell->push_back(0);
300  m_phi_cell->push_back(0);
301  m_layer_cell->push_back(0);
302  }
303  //}
304  /*catch (LArID_Exception & except) {
305  m_eta_cell->push_back(-999);
306  m_phi_cell->push_back(-999);
307  m_layer_cell->push_back(-999);
308  }*/
309 
310  }
311  }
312  }
313 
314  // fill energy weighted cubic peaking time for each requested sampling
315  for (CaloSampling::CaloSample idSample : m_samplingIndices) {
316  // go on only if there is data stored for this sample:
317  //if (sumEPerSampling.find(idSample) != sumEPerSampling.end()) {
318  double peakTime = (sumEPerSampling[idSample] > 0.) ? sumETimePerSampling[idSample]/sumEPerSampling[idSample] : NOTIME;
319  m_time_layer->push_back(peakTime/ns);
320  m_layer_layer->push_back(idSample);
321  //}
322  }
323 
324  // fill energy weighted cubic peaking time for each requested FEB
325  for (HWIdentifier febID : m_febIDs) {
326  // go on only if there is data stored for this febID
327  //if (sumEPerFeb.find(febID) != sumEPerFeb.end()) {
328  double peakTime = (sumEPerFeb[febID] > 0.) ? sumETimePerFeb[febID]/sumEPerFeb[febID] : NOTIME;
329  m_time_feb->push_back(peakTime/ns);
330  m_febId_feb->push_back(febID.get_identifier32().get_compact());
331  m_slot_feb->push_back(m_onlineHelper->slot(febID));
332  m_feedthrough_feb->push_back(m_onlineHelper->feedthrough(febID));
333  //}
334  }
335 
336  // fill energy weighted cubic peaking time for everything
337  if (eSet) {
338  m_time = (sumETotal > 0.) ? sumETimeTotal/sumETotal : 0.;
339  }
340 
341  //if (m_Ncells > 0) std::cout << "#cells: " << m_Ncells << std::endl;
342  return StatusCode::SUCCESS;
343 }
344 
345 
346 
347 
348 
349 StatusCode CBNT_Timing::CBNT_finalize()
350 {
351  ATH_MSG_DEBUG ( "in finalize()" );
352  return StatusCode::SUCCESS;
353 }
354 
355 
356 StatusCode CBNT_Timing::setupLookupTables() {
357 
358  // fill slot and febName lookup table for EM barrel online
359  m_slotToFebNameLookup[1]="Presampler";
360  m_slotToFebNameLookup[2]="Front 0";
361  m_slotToFebNameLookup[3]="Front 1";
362  m_slotToFebNameLookup[4]="Front 2";
363  m_slotToFebNameLookup[5]="Front 3";
364  m_slotToFebNameLookup[6]="Front 4";
365  m_slotToFebNameLookup[7]="Front 5";
366  m_slotToFebNameLookup[8]="Front 6";
367  m_slotToFebNameLookup[9]="Back 0";
368  m_slotToFebNameLookup[10]="Back 1";
369  m_slotToFebNameLookup[11]="Middle 0";
370  m_slotToFebNameLookup[12]="Middle 1";
371  m_slotToFebNameLookup[13]="Middle 2";
372  m_slotToFebNameLookup[14]="Middle 3";
373 
374  // fill calo names lookup tables
375  m_caloToNameLookup[CaloCell_ID::LAREM] = "LAREM";
376  m_caloToNameLookup[CaloCell_ID::LARHEC] = "LARHEC";
377  m_caloToNameLookup[CaloCell_ID::LARFCAL] = "LARFCAL";
378  m_caloToNameLookup[CaloCell_ID::TILE] = "TILE";
379 
380  m_caloFromNameLookup["LAREM"] = CaloCell_ID::LAREM;
381  m_caloFromNameLookup["LARHEC"] = CaloCell_ID::LARHEC;
382  m_caloFromNameLookup["LARFCAL"] = CaloCell_ID::LARFCAL;
383  m_caloFromNameLookup["TILE"] = CaloCell_ID::TILE;
384 
385  // fill sampling names lookup table
386  m_samplingToNameLookup[CaloSampling::PreSamplerB] = "PreSamplerB"; // electromagnetic barrel
387  m_samplingToNameLookup[CaloSampling::EMB1] = "EMB1";
388  m_samplingToNameLookup[CaloSampling::EMB2] = "EMB2";
389  m_samplingToNameLookup[CaloSampling::EMB3] = "EMB3";
390  m_samplingToNameLookup[CaloSampling::PreSamplerE] = "PreSamplerE"; // electromagnetic endcap
391  m_samplingToNameLookup[CaloSampling::EME1] = "EME1";
392  m_samplingToNameLookup[CaloSampling::EME2] = "EME2";
393  m_samplingToNameLookup[CaloSampling::EME3] = "EME3";
394  m_samplingToNameLookup[CaloSampling::HEC0] = "HEC0"; // hadronic endcap
395  m_samplingToNameLookup[CaloSampling::HEC1] = "HEC1";
396  m_samplingToNameLookup[CaloSampling::HEC2] = "HEC2";
397  m_samplingToNameLookup[CaloSampling::HEC3] = "HEC3";
398  m_samplingToNameLookup[CaloSampling::TileBar0] = "TileBar0"; // tile barrel
399  m_samplingToNameLookup[CaloSampling::TileBar1] = "TileBar1";
400  m_samplingToNameLookup[CaloSampling::TileBar2] = "TileBar2";
401  m_samplingToNameLookup[CaloSampling::TileGap1] = "TileGap1"; // tile gap scintillators
402  m_samplingToNameLookup[CaloSampling::TileGap2] = "TileGap2";
403  m_samplingToNameLookup[CaloSampling::TileGap3] = "TileGap3";
404  m_samplingToNameLookup[CaloSampling::TileExt0] = "TileExt0"; // tile extended barrel
405  m_samplingToNameLookup[CaloSampling::TileExt1] = "TileExt1";
406  m_samplingToNameLookup[CaloSampling::TileExt2] = "TileExt2";
407  m_samplingToNameLookup[CaloSampling::FCAL0] = "FCal1"; // fcal
408  m_samplingToNameLookup[CaloSampling::FCAL1] = "FCal2";
409  m_samplingToNameLookup[CaloSampling::FCAL2] = "FCal3";
410  m_samplingToNameLookup[CaloSampling::Unknown] = "unknown";
411 
412  m_samplingFromNameLookup["PreSamplerB"] = CaloSampling::PreSamplerB; // electromagnetic barrel
413  m_samplingFromNameLookup["EMB1"] = CaloSampling::EMB1;
414  m_samplingFromNameLookup["EMB2"] = CaloSampling::EMB2;
415  m_samplingFromNameLookup["EMB3"] = CaloSampling::EMB3;
416  m_samplingFromNameLookup["PreSamplerE"] = CaloSampling::PreSamplerE; // electromagnetic endcap
417  m_samplingFromNameLookup["EME1"] = CaloSampling::EME1;
418  m_samplingFromNameLookup["EME2"] = CaloSampling::EME2;
419  m_samplingFromNameLookup["EME3"] = CaloSampling::EME3;
420  m_samplingFromNameLookup["HEC0"] = CaloSampling::HEC0; // hadronic endcap
421  m_samplingFromNameLookup["HEC1"] = CaloSampling::HEC1;
422  m_samplingFromNameLookup["HEC2"] = CaloSampling::HEC2;
423  m_samplingFromNameLookup["HEC3"] = CaloSampling::HEC3;
424  m_samplingFromNameLookup["TileBar0"] = CaloSampling::TileBar0; // tile barrel
425  m_samplingFromNameLookup["TileBar1"] = CaloSampling::TileBar1;
426  m_samplingFromNameLookup["TileBar2"] = CaloSampling::TileBar2;
427  m_samplingFromNameLookup["TileGap1"] = CaloSampling::TileGap1; // tile gap scintillators
428  m_samplingFromNameLookup["TileGap2"] = CaloSampling::TileGap2;
429  m_samplingFromNameLookup["TileGap3"] = CaloSampling::TileGap3;
430  m_samplingFromNameLookup["TileExt0"] = CaloSampling::TileExt0; // tile extended barrel
431  m_samplingFromNameLookup["TileExt1"] = CaloSampling::TileExt1;
432  m_samplingFromNameLookup["TileExt2"] = CaloSampling::TileExt2;
433  m_samplingFromNameLookup["FCal1"] = CaloSampling::FCAL0; // fcal
434  m_samplingFromNameLookup["FCal2"] = CaloSampling::FCAL1;
435  m_samplingFromNameLookup["FCal3"] = CaloSampling::FCAL2;
436  m_samplingFromNameLookup["unknown"] = CaloSampling::Unknown;
437 
438  // fill calo lookup table
439  m_caloLookup[CaloSampling::PreSamplerB] = CaloCell_ID::LAREM;
440  m_caloLookup[CaloSampling::EMB1] = CaloCell_ID::LAREM;
441  m_caloLookup[CaloSampling::EMB2] = CaloCell_ID::LAREM;
442  m_caloLookup[CaloSampling::EMB3] = CaloCell_ID::LAREM;
443  m_caloLookup[CaloSampling::PreSamplerE] = CaloCell_ID::LAREM;
444  m_caloLookup[CaloSampling::EME1] = CaloCell_ID::LAREM;
445  m_caloLookup[CaloSampling::EME2] = CaloCell_ID::LAREM;
446  m_caloLookup[CaloSampling::EME3] = CaloCell_ID::LAREM;
447  m_caloLookup[CaloSampling::HEC0] = CaloCell_ID::LARHEC;
448  m_caloLookup[CaloSampling::HEC1] = CaloCell_ID::LARHEC;
449  m_caloLookup[CaloSampling::HEC2] = CaloCell_ID::LARHEC;
450  m_caloLookup[CaloSampling::HEC3] = CaloCell_ID::LARHEC;
451  m_caloLookup[CaloSampling::TileBar0] = CaloCell_ID::TILE;
452  m_caloLookup[CaloSampling::TileBar1] = CaloCell_ID::TILE;
453  m_caloLookup[CaloSampling::TileBar2] = CaloCell_ID::TILE;
454  m_caloLookup[CaloSampling::TileGap1] = CaloCell_ID::TILE;
455  m_caloLookup[CaloSampling::TileGap2] = CaloCell_ID::TILE;
456  m_caloLookup[CaloSampling::TileGap3] = CaloCell_ID::TILE;
457  m_caloLookup[CaloSampling::TileExt0] = CaloCell_ID::TILE;
458  m_caloLookup[CaloSampling::TileExt1] = CaloCell_ID::TILE;
459  m_caloLookup[CaloSampling::TileExt2] = CaloCell_ID::TILE;
460  m_caloLookup[CaloSampling::FCAL0] = CaloCell_ID::LARFCAL;
461  m_caloLookup[CaloSampling::FCAL1] = CaloCell_ID::LARFCAL;
462  m_caloLookup[CaloSampling::FCAL2] = CaloCell_ID::LARFCAL;
463 
464  return StatusCode::SUCCESS;
465 }
466 
467 StatusCode CBNT_Timing::CBNT_clear() {
468 
469  if(m_layer_cell) m_layer_cell->clear();
470  if(m_eta_cell) m_eta_cell->clear();
471  if(m_phi_cell) m_phi_cell->clear();
472  if(m_febId_cell) m_febId_cell->clear();
473  if(m_energy_cell) m_energy_cell->clear();
474  if(m_time_cell) m_time_cell->clear();
475  if(m_time_layer) m_time_layer->clear();
476  if(m_layer_layer) m_layer_layer->clear();
477  if(m_febId_feb) m_febId_feb->clear();
478  if(m_time_feb) m_time_feb->clear();
479  if(m_slot_feb) m_slot_feb->clear();
480  if(m_feedthrough_feb) m_feedthrough_feb->clear();
481  return StatusCode::SUCCESS;
482 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
CBNT_Timing::CBNT_Timing
CBNT_Timing(const std::string &name, ISvcLocator *pSvcLocator)
Definition: CBNT_Timing.cxx:26
GetLCDefs::Unknown
@ Unknown
Definition: GetLCDefs.h:21
CBNT_Timing::m_slotToFebNameLookup
std::map< int, std::string > m_slotToFebNameLookup
Definition: CBNT_Timing.h:57
LArEM_Base_ID::phi
int phi(const Identifier id) const
return phi according to :
CaloCell_Base_ID::LARFCAL
@ LARFCAL
Definition: CaloCell_Base_ID.h:46
ReadOfcFromCool.phase
phase
Definition: ReadOfcFromCool.py:127
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
CBNT_Timing::setupLookupTables
StatusCode setupLookupTables()
internal helpers
Definition: CBNT_Timing.cxx:356
CBNT_Timing::m_feedthrough_feb
std::vector< long > * m_feedthrough_feb
Definition: CBNT_Timing.h:76
CaloCell_ID_FCS::TileExt2
@ TileExt2
Definition: FastCaloSim_CaloCell_ID.h:39
CBNT_Timing::m_first_event
bool m_first_event
Definition: CBNT_Timing.h:43
constants.EMB1
int EMB1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:53
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
TBScintillatorCont.h
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CaloCell_ID_FCS::TileExt0
@ TileExt0
Definition: FastCaloSim_CaloCell_ID.h:37
CaloCell_ID_FCS::TileBar1
@ TileBar1
Definition: FastCaloSim_CaloCell_ID.h:32
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
CBNT_Timing::m_eta_cell
std::vector< long > * m_eta_cell
Definition: CBNT_Timing.h:66
CBNT_Timing::m_slot_feb
std::vector< long > * m_slot_feb
Definition: CBNT_Timing.h:75
CaloCellContainer::beginConstCalo
CaloCellContainer::const_iterator beginConstCalo(CaloCell_ID::SUBCALO caloNum) const
get const iterators on cell of just one calo
Definition: CaloCellContainer.cxx:119
LArOnlineID_Base::slot
int slot(const HWIdentifier id) const
Return the slot number of a hardware cell identifier: slot = [1,15] Slot-ID in top part of the crat...
Definition: LArOnlineID_Base.cxx:1957
CaloCell_ID_FCS::FCAL1
@ FCAL1
Definition: FastCaloSim_CaloCell_ID.h:41
Identifier::get_identifier32
Identifier32 get_identifier32() const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
CaloCell.h
LArEM_Base_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
CaloCell_Base_ID::LARHEC
@ LARHEC
Definition: CaloCell_Base_ID.h:46
CaloCell_ID_FCS::HEC2
@ HEC2
Definition: FastCaloSim_CaloCell_ID.h:29
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
HWIdentifier
Definition: HWIdentifier.h:13
Identifier32::get_compact
value_type get_compact() const
Get the compact id.
Definition: Identifier32.h:44
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
LArEM_Base_ID::eta
int eta(const Identifier id) const
return eta according to :
CaloCell_ID.h
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
CBNT_Timing::NOTIME
static const int NOTIME
Definition: CBNT_Timing.h:36
CBNT_Timing::m_sampling_names
std::vector< std::string > m_sampling_names
Definition: CBNT_Timing.h:46
CBNT_Timing::m_energy
float m_energy
Definition: CBNT_Timing.h:79
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
CBNT_Timing::m_tdc_phase
float m_tdc_phase
Definition: CBNT_Timing.h:79
CBNT_Timing::m_layer_cell
std::vector< long > * m_layer_cell
Definition: CBNT_Timing.h:66
CBNT_Timing::m_energy_cell
std::vector< float > * m_energy_cell
Definition: CBNT_Timing.h:67
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
CaloCell_ID_FCS::HEC1
@ HEC1
Definition: FastCaloSim_CaloCell_ID.h:28
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
CBNT_TBRecBase
Definition: CBNT_TBRecBase.h:21
constants.EMB2
int EMB2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:54
CBNT_TBRecBase::m_emId
const LArEM_ID * m_emId
Definition: CBNT_TBRecBase.h:65
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:116
CBNT_Timing::m_febId_cell
std::vector< long > * m_febId_cell
Definition: CBNT_Timing.h:66
CBNT_Timing::~CBNT_Timing
virtual ~CBNT_Timing()
Definition: CBNT_Timing.cxx:58
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
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
CBNT_Timing::m_samplingToNameLookup
std::map< CaloSampling::CaloSample, std::string > m_samplingToNameLookup
Definition: CBNT_Timing.h:60
CaloCell_ID_FCS::TileGap2
@ TileGap2
Definition: FastCaloSim_CaloCell_ID.h:35
CBNT_Timing::m_febIDs
std::vector< HWIdentifier > m_febIDs
Definition: CBNT_Timing.h:53
CaloCell_Base_ID::SUBCALO
SUBCALO
enumeration of sub calorimeters
Definition: CaloCell_Base_ID.h:46
CBNT_TBRecBase::addBranch
void addBranch(const std::string &branchname, T &obj, const std::string &leaflist)
Definition: CBNT_TBRecBase.h:44
constants.EME1
int EME1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:55
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CBNT_Timing::m_febId_feb
std::vector< long > * m_febId_feb
Definition: CBNT_Timing.h:73
CaloCell_Base_ID::TILE
@ TILE
Definition: CaloCell_Base_ID.h:46
CBNT_Timing::m_caloToNameLookup
std::map< CaloCell_ID::SUBCALO, std::string > m_caloToNameLookup
Definition: CBNT_Timing.h:58
CaloCell_ID_FCS::TileGap1
@ TileGap1
Definition: FastCaloSim_CaloCell_ID.h:34
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
LArOnlineID_Base::feb_Id
HWIdentifier feb_Id(int barrel_ec, int pos_neg, int feedthrough, int slot) const
Create feb_Id from fields.
Definition: LArOnlineID_Base.cxx:1479
CBNT_Timing::m_onlineHelper
const LArOnlineID * m_onlineHelper
Definition: CBNT_Timing.h:40
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
CaloCell_ID_FCS::TileExt1
@ TileExt1
Definition: FastCaloSim_CaloCell_ID.h:38
CaloCell_ID_FCS::EME3
@ EME3
Definition: FastCaloSim_CaloCell_ID.h:26
CBNT_Timing::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: CBNT_Timing.h:39
TBBPCCont.h
CBNT_Timing::NOENERGY
static const int NOENERGY
Definition: CBNT_Timing.h:37
CBNT_Timing::CBNT_finalize
virtual StatusCode CBNT_finalize() override
Definition: CBNT_Timing.cxx:349
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
CBNT_Timing::CBNT_initialize
virtual StatusCode CBNT_initialize() override
Definition: CBNT_Timing.cxx:62
Units.h
Wrapper to avoid constant divisions when using units.
CaloCellContainer.h
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
CaloCell_ID_FCS::HEC0
@ HEC0
Definition: FastCaloSim_CaloCell_ID.h:27
CBNT_Timing::m_time_layer
std::vector< float > * m_time_layer
Definition: CBNT_Timing.h:69
CBNT_Timing::m_layer_layer
std::vector< long > * m_layer_layer
Definition: CBNT_Timing.h:70
LArOnlineID_Base::feedthrough
int feedthrough(const HWIdentifier id) const
Return the feedthrough of a hardware cell identifier : feedthrough = [0,31] Barrel - A/C side or H/...
Definition: LArOnlineID_Base.cxx:1944
CBNT_Timing::m_caloCellName
std::string m_caloCellName
Definition: CBNT_Timing.h:47
CBNT_Timing::CBNT_execute
virtual StatusCode CBNT_execute() override
Definition: CBNT_Timing.cxx:134
TBPhase
Definition: TBPhase.h:22
CBNT_Timing::m_samplingFromNameLookup
std::map< std::string, CaloSampling::CaloSample > m_samplingFromNameLookup
Definition: CBNT_Timing.h:61
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
CaloCell_ID_FCS::PreSamplerE
@ PreSamplerE
Definition: FastCaloSim_CaloCell_ID.h:23
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
CBNT_Timing::m_energy_cut
double m_energy_cut
Definition: CBNT_Timing.h:42
CBNT_Timing::m_time_feb
std::vector< float > * m_time_feb
Definition: CBNT_Timing.h:74
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CBNT_Timing::m_phi_cell
std::vector< long > * m_phi_cell
Definition: CBNT_Timing.h:66
CBNT_Timing::m_time_cell
std::vector< float > * m_time_cell
Definition: CBNT_Timing.h:67
TBPhase.h
CaloCellContainer::endConstCalo
CaloCellContainer::const_iterator endConstCalo(CaloCell_ID::SUBCALO caloNum) const
Definition: CaloCellContainer.cxx:133
CBNT_Timing::m_samplingIndices
std::vector< CaloSampling::CaloSample > m_samplingIndices
stores
Definition: CBNT_Timing.h:51
CBNT_Timing::m_caloFromNameLookup
std::map< std::string, CaloCell_ID::SUBCALO > m_caloFromNameLookup
Definition: CBNT_Timing.h:59
CBNT_Timing::m_calosAndSamplings
std::map< CaloCell_ID::SUBCALO, std::vector< CaloSampling::CaloSample > > m_calosAndSamplings
Definition: CBNT_Timing.h:52
CBNT_Timing::CBNT_clear
virtual StatusCode CBNT_clear() override
Definition: CBNT_Timing.cxx:467
python.SystemOfUnits.ns
int ns
Definition: SystemOfUnits.py:130
CaloCell_ID_FCS::FCAL2
@ FCAL2
Definition: FastCaloSim_CaloCell_ID.h:42
CBNT_Timing.h
CaloCell_ID_FCS::HEC3
@ HEC3
Definition: FastCaloSim_CaloCell_ID.h:30
CaloCell_Base_ID::LAREM
@ LAREM
Definition: CaloCell_Base_ID.h:46
CaloCell_ID_FCS::FCAL0
@ FCAL0
Definition: FastCaloSim_CaloCell_ID.h:40
CBNT_Timing::m_tbphase
std::string m_tbphase
Definition: CBNT_Timing.h:45
CaloCell_ID_FCS::EMB3
@ EMB3
Definition: FastCaloSim_CaloCell_ID.h:22
CBNT_Timing::m_time
float m_time
Definition: CBNT_Timing.h:79
AtlasDetectorID::is_lar_em
bool is_lar_em(Identifier id) const
Definition: AtlasDetectorID.h:818
CaloCell_ID_FCS::TileBar2
@ TileBar2
Definition: FastCaloSim_CaloCell_ID.h:33
CBNT_Timing::m_caloLookup
std::map< CaloSampling::CaloSample, CaloCell_ID::SUBCALO > m_caloLookup
Definition: CBNT_Timing.h:62
constants.EME2
int EME2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:56
LArOnlineID.h
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
Generated on Thu Nov 7 2024 21:11:50 for ATLAS Offline Software by   doxygen 1.8.18