ATLAS Offline Software
LArDigitRetriever.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "LArDigitRetriever.h"
6 
7 #include "CLHEP/Units/SystemOfUnits.h"
8 
9 #include "EventContainers/SelectAllObject.h"
10 
11 #include "CaloDetDescr/CaloDetDescrElement.h"
12 #include "LArElecCalib/ILArPedestal.h"
13 #include "LArIdentifier/LArOnlineID.h"
14 #include "LArRawEvent/LArRawChannel.h"
15 #include "LArRawEvent/LArRawChannelContainer.h"
16 #include "Identifier/HWIdentifier.h"
17 #include "CaloIdentifier/TileID.h"
18 #include "StoreGate/ReadCondHandle.h"
19 #include "GaudiKernel/ThreadLocalContext.h"
20 #include <memory>
21 #include <array>
22 
23 using CLHEP::GeV;
24 
25 namespace JiveXML {
26 
33  LArDigitRetriever::LArDigitRetriever(const std::string& type,const std::string& name,const IInterface* parent):
34  AthAlgTool(type,name,parent),
35  m_calocell_id(nullptr)
36  {
37  //Only declare the interface
38  declareInterface<IDataRetriever>(this);
39 
40  m_doDigit = false;
41  m_inputdpd = false;
42 
43  declareProperty("CellThreshold", m_cellThreshold = 50.);
44  declareProperty("RetrieveLAr" , m_lar = true);
45  declareProperty("RetrieveHEC" , m_hec = true);
46  declareProperty("RetrieveFCAL" , m_fcal = true);
47  declareProperty("DoLArDigit", m_doLArDigit = false);
48  declareProperty("DoHECDigit", m_doHECDigit = false);
49  declareProperty("DoFCalDigit", m_doFCalDigit = false);
50  declareProperty("CellEnergyPrec", m_cellEnergyPrec = 3);
51  declareProperty("CellTimePrec", m_cellTimePrec = 3);
52 
53 // Check the cell conditions. Not present in MC data, so false by default. Switch to 'true'
54 // for real (commissioning) cells.
55  declareProperty("CellConditionCut", m_cellConditionCut = false);
56  declareProperty("LArChannelsToIgnoreM5", m_LArChannelsToIgnoreM5);
57  declareProperty("DoMaskLArChannelsM5", m_doMaskLArChannelsM5 = false);
58  }
59 
64  StatusCode LArDigitRetriever::initialize() {
65 
66  ATH_MSG_DEBUG( "Initialising Tool" );
67  ATH_CHECK( detStore()->retrieve (m_calocell_id, "CaloCell_ID") );
68  ATH_CHECK( m_adc2mevKey.initialize() );
69 
70  ATH_CHECK( m_sgKey.initialize() );
71  ATH_CHECK( m_sgKeyLArDigit_raw.initialize() );
72  ATH_CHECK( m_sgKeyLArDigit_esd.initialize() );
73  ATH_CHECK( m_cablingKey.initialize() );
74 
75  return StatusCode::SUCCESS;
76  }
77 
81  StatusCode LArDigitRetriever::retrieve(ToolHandle<IFormatTool> &FormatTool) {
82 
83  ATH_MSG_DEBUG( "in retrieve()" );
84 
85  if (m_doLArDigit || m_doHECDigit || m_doFCalDigit){
86  m_doDigit = true;
87  }
88 
89  SG::ReadHandle<CaloCellContainer> cellContainer(m_sgKey);
90  if (!cellContainer.isValid()){
91  ATH_MSG_WARNING( "Could not retrieve Calorimeter Cells " );
92  }
93  else{
94 
95  if(m_fcal){
96  DataMap data = getLArDigitData(&(*cellContainer),"FCAL",CaloCell_ID::LARFCAL);
97  ATH_CHECK( FormatTool->AddToEvent("FCAL", m_sgKey.key(), &data) );
98  ATH_MSG_DEBUG( "FCAL retrieved" );
99  }
100 
101  if(m_lar){
102  DataMap data = getLArDigitData(&(*cellContainer),"LAr",CaloCell_ID::LAREM);
103  ATH_CHECK( FormatTool->AddToEvent("LAr", m_sgKey.key(), &data) );
104  ATH_MSG_DEBUG( "LAr retrieved" );
105  }
106 
107  if(m_hec){
108  DataMap data = getLArDigitData(&(*cellContainer),"HEC",CaloCell_ID::LARHEC);
109  ATH_CHECK( FormatTool->AddToEvent("HEC", m_sgKey.key(), &data) );
110  ATH_MSG_DEBUG( "HEC retrieved" );
111  }
112  }
113 
114  //Tile cells retrieved okay
115  return StatusCode::SUCCESS;
116  }
117 
118 
123  const DataMap LArDigitRetriever::getLArDigitData(const CaloCellContainer* cellContainer,
124  const std::string& datatype,
125  CaloCell_ID::SUBCALO calotype)
126  {
127 
128  //be verbose
129  ATH_MSG_DEBUG( "getLArDigitData()" );
130  const EventContext& ctx = Gaudi::Hive::currentContext();
131 
132  char rndStr[30];
133  DataMap DataMap;
134 
135  DataVect phi; phi.reserve(cellContainer->size());
136  DataVect eta; eta.reserve(cellContainer->size());
137  DataVect x; x.reserve(cellContainer->size());
138  DataVect y; y.reserve(cellContainer->size());
139  DataVect dx; dx.reserve(cellContainer->size());
140  DataVect dy; dy.reserve(cellContainer->size());
141 
142  DataVect energy; energy.reserve(cellContainer->size());
143  DataVect idVec; idVec.reserve(cellContainer->size());
144  DataVect channel; channel.reserve(cellContainer->size());
145  DataVect feedThrough; feedThrough.reserve(cellContainer->size());
146  DataVect slotVec; slotVec.reserve(cellContainer->size());
147 
148  DataVect cellTimeVec; cellTimeVec.reserve(cellContainer->size());
149  DataVect cellGain; cellGain.reserve(cellContainer->size());
150  DataVect cellPedestal; cellPedestal.reserve(cellContainer->size());
151  DataVect adc2Mev; adc2Mev.reserve(cellContainer->size());
152 
153 // m_sub; m_sub.reserve(cellContainer->size());
154  m_sub.clear(); // need to clear before each event, otherwise appended
155 
156  DataVect LArSampleIndexVec; LArSampleIndexVec.reserve(cellContainer->size());
157 
158  std::string LArSampleIndexStr="adcCounts multiple=\"0\"";
159 
160  SG::ReadHandle<LArDigitContainer> LArDigitCnt_raw_handle(m_sgKeyLArDigit_raw);
161  SG::ReadHandle<LArDigitContainer> LArDigitCnt_esd_handle(m_sgKeyLArDigit_esd);
162  const LArDigitContainer* LArDigitCnt = nullptr;
163  if (LArDigitCnt_raw_handle.isValid()) {
164  LArDigitCnt = &(*LArDigitCnt_raw_handle);
165  }
166  else if (LArDigitCnt_esd_handle.isValid()) {
167  LArDigitCnt = &(*LArDigitCnt_esd_handle);
168  m_inputdpd = true;
169  }
170  else {
171  ATH_MSG_WARNING( "Could not retrieve LArDigits" );
172  }
173 
174  const ILArPedestal* larPedestal = nullptr;
175  if ( detStore()->retrieve(larPedestal).isFailure()){
176  ATH_MSG_ERROR( "in getLArDigitData(), Could not retrieve LAr Pedestal" );
177  }
178 
179  const LArOnlineID* onlineId = nullptr;
180  if ( detStore()->retrieve(onlineId, "LArOnlineID").isFailure()) {
181  ATH_MSG_ERROR( "in getLArDigitData(),Could not get LArOnlineID!" );
182  }
183 
184  SG::ReadCondHandle<LArADC2MeV> adc2mev (m_adc2mevKey, ctx);
185 
186 //------------------------------------------------------
187 //Loop over the digits and find Cell (LAr,HEC, FCAL)
188 //------------------------------------------------------
189 
190  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey, ctx};
191  const LArOnOffIdMapping* cabling{*cablingHdl};
192  if(!cabling) {
193  ATH_MSG_ERROR( "Do not have cabling mapping from key " << m_cablingKey.key() );
194  return DataMap;
195  }
196 
197 
198  if (LArDigitCnt && m_doDigit==true) {
199 
200  auto pCellIndex = std::make_unique<std::array<int, 200000>>();
201  pCellIndex->fill(0);
202  int nLArSamples = 0;
203  HWIdentifier LArHardwareId;
204  Identifier LArId;
205 
206  double energyGeV,cellTime;
207 
208  for (const LArDigit* digit : *LArDigitCnt) {
209 
210  LArHardwareId = digit->hardwareID();
211  if (!cabling->isOnlineConnected(LArHardwareId))continue;
212 
213  LArId = cabling->cnvToIdentifier(LArHardwareId); //converter
214  const IdentifierHash cellhash=m_calocell_id->calo_cell_hash(LArId); //fast method to find cell
215 
216  int Index = cellContainer->findIndex(cellhash); //find Cell Index
217  if (Index >= 0)
218  (*pCellIndex)[Index] = Index;
219 
220  nLArSamples = digit->nsamples();
221  std::vector<short> LArSamples = digit->samples();
222  int largain = digit->gain();
223  int FT = onlineId->feedthrough(LArHardwareId);
224  int slot = onlineId->slot(LArHardwareId);
225  int larchan = onlineId->channel(LArHardwareId);
226  float pedestal=larPedestal->pedestal(LArHardwareId,largain);
227  float pedvalue=0;
228  if (pedestal >= (1.0+LArElecCalib::ERRORCODE)) pedvalue = pedestal;
229  else pedvalue = LArSamples[0];
230 
231  LArVectorProxy polynom_adc2mev = adc2mev->ADC2MEV(LArId,largain);
232 
233  if ( Index >= 0 ){ // can be -1
234  if ( (*cellContainer)[Index]->energy() >m_cellThreshold) {
235 
236  if (((((*cellContainer)[Index]->provenance())&0xFF)!=0xA5)&&m_cellConditionCut) continue; // check full conition for LAr Cells
237 
238  //ignore LAr, HEC, and/or FCAL cells that are to be masked
239  if (m_doMaskLArChannelsM5){
240  bool maskChannel = false;
241  for (size_t i = 0; i < m_LArChannelsToIgnoreM5.size(); i++){
242  if ( (*cellContainer)[Index]->ID().get_compact() == m_LArChannelsToIgnoreM5[i]){
243  maskChannel = true;
244  break; // exit loop over bad channels
245  }
246  }
247  if (maskChannel) continue; // continue loop over all channels
248  }
249 
250 
251  if (datatype == "LAr" && m_calocell_id->is_em(LArId)) {
252 
253  calcEMLayerSub(LArId);
254 
255  energyGeV = (*cellContainer)[Index]->energy() * (1./GeV);
256  energy.push_back(DataType( gcvt( energyGeV, m_cellEnergyPrec, rndStr) ));
257  idVec.push_back(DataType((*cellContainer)[Index]->ID().get_compact() ));
258  phi.push_back(DataType((*cellContainer)[Index]->phi()));
259  eta.push_back(DataType((*cellContainer)[Index]->eta()));
260 
261  cellTime = (*cellContainer)[Index]->time();
262  cellTimeVec.push_back(DataType( gcvt( cellTime, m_cellTimePrec, rndStr) ) );
263  cellPedestal.push_back(DataType(pedvalue));
264  cellGain.push_back(DataType(largain));
265  channel.push_back(DataType(larchan));
266  feedThrough.push_back(DataType(FT));
267  slotVec.push_back(DataType(slot));
268  if (polynom_adc2mev.size()==0){
269  adc2Mev.push_back(DataType(-1));
270  }else{
271  adc2Mev.push_back(DataType(polynom_adc2mev[1]));
272  }
273  if ( m_doLArDigit ) {
274  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
275  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(LArSamples[i]));
276  }
277  } //match datatype LAr
278 
279  else if(datatype == "HEC" && m_calocell_id->is_hec(LArId)) {
280 
281  calcHECLayerSub(LArId);
282  energyGeV = (*cellContainer)[Index]->energy() * (1./GeV);
283  energy.push_back(DataType( gcvt( energyGeV, m_cellEnergyPrec, rndStr) ));
284  idVec.push_back(DataType((*cellContainer)[Index]->ID().get_compact() ));
285  phi.push_back(DataType((*cellContainer)[Index]->phi()));
286  eta.push_back(DataType((*cellContainer)[Index]->eta()));
287 
288 
289  cellTime = (*cellContainer)[Index]->time();
290  cellTimeVec.push_back(DataType( gcvt( cellTime, m_cellTimePrec, rndStr) ) );
291  cellPedestal.push_back(DataType(pedvalue));
292  cellGain.push_back(DataType(largain));
293  channel.push_back(DataType(larchan));
294  feedThrough.push_back(DataType(FT));
295  slotVec.push_back(DataType(slot));
296  if (polynom_adc2mev.size()==0)
297  adc2Mev.push_back(DataType(-1));
298  else
299  adc2Mev.push_back(DataType(polynom_adc2mev[1]));
300  if (m_doHECDigit){
301  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
302  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(LArSamples[i]));
303  }
304  }//match datatype HEC
305 
306  else if(datatype == "FCAL" && m_calocell_id->is_fcal(LArId)) {
307 
308  energyGeV = (*cellContainer)[Index]->energy() * (1./GeV);
309  energy.push_back(DataType( gcvt( energyGeV, m_cellEnergyPrec, rndStr) ));
310  idVec.push_back(DataType((*cellContainer)[Index]->ID().get_compact() ));
311  x.push_back(DataType((*cellContainer)[Index]->x() *0.1));
312  y.push_back(DataType((*cellContainer)[Index]->y() *0.1));
313 
314  const CaloDetDescrElement* elt = (*cellContainer)[Index]->caloDDE();
315 
316  dx.push_back(DataType(elt->dx()*0.1));
317  dy.push_back(DataType(elt->dy()*0.1));
318 
319  if (m_calocell_id->pos_neg(LArId)==2) m_sub.push_back(DataType(1));
320  else m_sub.push_back(DataType(0));
321 
322 
323  cellTime = (*cellContainer)[Index]->time();
324  cellTimeVec.push_back(DataType( gcvt( cellTime, m_cellTimePrec, rndStr) ) );
325  cellPedestal.push_back(DataType(pedvalue));
326  cellGain.push_back(DataType(largain));
327  channel.push_back(DataType(larchan));
328  feedThrough.push_back(DataType(FT));
329  slotVec.push_back(DataType(slot));
330  if (polynom_adc2mev.size()==0)
331  adc2Mev.push_back(DataType(-1));
332  else
333  adc2Mev.push_back(DataType(polynom_adc2mev[1]));
334  if (m_doFCalDigit){
335  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
336  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(LArSamples[i]));
337  }
338  }//match datatype FCAL
339  } //if cellThreshold
340  } // if Index >0
341  } //digit
342 
343 
344 // If the digits are retrived from DPD, retrieve the other cells which do not have the digits avaliable
345 
346  if (m_inputdpd) {
347 
348  CaloCellContainer::const_iterator it1 = cellContainer->beginConstCalo(calotype);
349  CaloCellContainer::const_iterator it2 = cellContainer->endConstCalo(calotype);
350 
351 
352  for (;it1!=it2;++it1) {
353  //---------------------------------------------
354 
355  if ( (*it1)->energy() < m_cellThreshold ) continue;
356 
357  Identifier cellid = (*it1)->ID();
358 
359  const IdentifierHash cellhash=m_calocell_id->calo_cell_hash(cellid); //fast method to find cell
360  int Index = cellContainer->findIndex(cellhash); //find Cell Index
361  if (Index >= 0 && (*pCellIndex)[Index] == Index)
362  continue; //test whether this cell was already retrieved
363 
364  HWIdentifier LArhwid = cabling->createSignalChannelIDFromHash((*it1)->caloDDE()->calo_hash());
365 
366  if (m_calocell_id->is_tile(cellid) ) continue;
367  if (((((*it1)->provenance())&0xFF)!=0xA5)&&m_cellConditionCut) continue; // check full condition for LAr cells
368 
369  //ignore LAr, HEC, and/or FCAL cells that are to be masked
370  if (m_doMaskLArChannelsM5){
371  bool maskChannel = false;
372  for (size_t i = 0; i < m_LArChannelsToIgnoreM5.size(); i++){
373  if (cellid == m_LArChannelsToIgnoreM5[i]){
374  maskChannel = true;
375  break; // exit loop over bad channels
376  }
377  }
378  if (maskChannel) continue; // continue loop over all channels
379  }
380 
381  energyGeV = (*it1)->energy()*(1./GeV);
382  energy.push_back(DataType( gcvt( energyGeV, m_cellEnergyPrec, rndStr) ));
383  idVec.push_back(DataType((*it1)->ID().get_compact() ));
384  channel.push_back(DataType(onlineId->channel(LArhwid)));
385  feedThrough.push_back(DataType(onlineId->feedthrough(LArhwid)));
386  slotVec.push_back(DataType(onlineId->slot(LArhwid)));
387 
388  cellTime = (*it1)->time();
389  cellTimeVec.push_back(DataType( gcvt( cellTime, m_cellTimePrec, rndStr) ) );
390  cellGain.push_back(DataType((*it1)->gain()));
391  int largain = (*it1)->gain();
392  float pedvalue=0;
393  float pedestal=larPedestal->pedestal(LArhwid,largain);
394  if (pedestal >= (1.0+LArElecCalib::ERRORCODE)) pedvalue = pedestal;
395  else pedvalue = 0;
396  cellPedestal.push_back(DataType(pedvalue));
397 
398  LArVectorProxy polynom_adc2mev = adc2mev->ADC2MEV(cellid,largain);
399  if (polynom_adc2mev.size()==0){
400  adc2Mev.push_back(DataType(-1));
401  }else{
402  adc2Mev.push_back(DataType(polynom_adc2mev[1]));
403  }
404 
405 
406  if (datatype == "LAr") {
407  calcEMLayerSub(cellid);
408  phi.push_back(DataType((*it1)->phi()));
409  eta.push_back(DataType((*it1)->eta()));
410  if ( m_doLArDigit ) {
411  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
412  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(0)); }
413  }
414 
415  else if (datatype == "HEC") {
416  calcHECLayerSub(cellid);
417  phi.push_back(DataType((*it1)->phi()));
418  eta.push_back(DataType((*it1)->eta()));
419  if (m_doHECDigit){
420  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
421  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(0)); }
422  }
423 
424  else if (datatype == "FCAL") {
425 
426  x.push_back(DataType( (*it1)->x()*0.1 ));
427  y.push_back(DataType( (*it1)->y()*0.1 ));
428 
429  const CaloDetDescrElement* elt = (*it1)->caloDDE();
430  dx.push_back(DataType( elt->dx()*0.1 ));
431  dy.push_back(DataType( elt->dy()*0.1 ));
432 
433  if (m_calocell_id->pos_neg(cellid)==2) m_sub.push_back(DataType(1));
434  else m_sub.push_back(DataType(0));
435  if (m_doFCalDigit){
436  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
437  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(0));
438  }
439  }
440 
441  }//for(;it1!=it2;it1++)
442  }// if (m_inputdpd)
443  }
444 
445 //----------------above lines are trying to get the LAr,HEC and FCAL tags --------------
446 
447  // write values into DataMap
448  const auto nEntries = phi.size();
449  if(!(datatype=="FCAL")){
450  DataMap["phi"] = std::move(phi);
451  DataMap["eta"] = std::move(eta);
452  } else {
453  DataMap["x"] = std::move(x);
454  DataMap["y"] = std::move(y);
455  DataMap["dx"] = std::move(dx);
456  DataMap["dy"] = std::move(dy);
457  }
458 
459  DataMap["energy"] = std::move(energy);
460  DataMap["id"] = std::move(idVec);
461  DataMap["channel"] = std::move(channel);
462  DataMap["feedThrough"] = std::move(feedThrough);
463  DataMap["slot"] = std::move(slotVec);
464 
465  // adc counts
466  DataMap["cellTime"] = std::move(cellTimeVec);
467  DataMap["cellGain"] = std::move(cellGain);
468  DataMap["cellPedestal"] = std::move(cellPedestal);
469  DataMap["adc2Mev"] = std::move(adc2Mev);
470 
471  DataMap[LArSampleIndexStr] = LArSampleIndexVec; // adcCounts
472 
473  //Be verbose
474  ATH_MSG_DEBUG( dataTypeName() << " retrieved with " << nEntries<< " entries" );
475 
476  //All collections retrieved okay
477  return DataMap;
478 
479  } // getTileData
480 
481 
482  //--------------------------------------------------------------------------
483 
484  void LArDigitRetriever::calcEMLayerSub(Identifier& cellid)
485  {
486  const auto posNeg = std::abs(m_calocell_id->pos_neg(cellid));
487  if (posNeg<1 or posNeg>3) return;
488  static constexpr std::array<int,3> datatypes{2,3,0};
489  m_sub.emplace_back(datatypes[posNeg-1]);
490  }
491 
492  //--------------------------------------------------------------------------
493 
494  void LArDigitRetriever::calcHECLayerSub(Identifier& cellid)
495  {
496  if(m_calocell_id->pos_neg(cellid)==2)
497  m_sub.emplace_back(1);
498  else
499  m_sub.emplace_back(0);
500  }
501 
502 
503  //--------------------------------------------------------------------------
504 
505 } // JiveXML namespace
ILArPedestal::pedestal
virtual float pedestal(const HWIdentifier &id, int gain) const =0
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
JiveXML::LArDigitRetriever::m_hec
bool m_hec
Definition: LArDigitRetriever.h:87
LArADC2MeV::ADC2MEV
const LArVectorProxy ADC2MEV(const HWIdentifier &id, int gain) const
Definition: LArADC2MeV.h:32
JiveXML::LArDigitRetriever::m_sgKey
SG::ReadHandleKey< CaloCellContainer > m_sgKey
Definition: LArDigitRetriever.h:76
CaloCell_Base_ID::LARFCAL
@ LARFCAL
Definition: CaloCell_Base_ID.h:46
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
CaloCell_Base_ID::calo_cell_hash
IdentifierHash calo_cell_hash(const Identifier cellId) const
create hash id from 'global' cell id
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ID
std::vector< Identifier > ID
Definition: CalibHitIDCheck.h:24
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
JiveXML::LArDigitRetriever::LArDigitRetriever
LArDigitRetriever(const std::string &type, const std::string &name, const IInterface *parent)
Standard Constructor.
Definition: LArDigitRetriever.cxx:33
ILArPedestal
Definition: ILArPedestal.h:12
JiveXML::LArDigitRetriever::m_doFCalDigit
bool m_doFCalDigit
Definition: LArDigitRetriever.h:91
CaloCell_Base_ID::pos_neg
int pos_neg(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
JiveXML::DataVect
std::vector< DataType > DataVect
Defines a map with a key and a vector of DataType objects e.g.
Definition: DataType.h:58
JiveXML::LArDigitRetriever::m_fcal
bool m_fcal
Definition: LArDigitRetriever.h:88
DataType
OFFLINE_FRAGMENTS_NAMESPACE::PointerType DataType
Definition: RoIBResultByteStreamTool.cxx:25
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
JiveXML::LArDigitRetriever::m_calocell_id
const CaloCell_ID * m_calocell_id
Definition: LArDigitRetriever.h:84
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_Base_ID::LARHEC
@ LARHEC
Definition: CaloCell_Base_ID.h:46
LArSamples
Definition: AbsShape.h:24
JiveXML::LArDigitRetriever::m_doDigit
bool m_doDigit
Definition: LArDigitRetriever.h:92
JiveXML::LArDigitRetriever::m_cellThreshold
double m_cellThreshold
Definition: LArDigitRetriever.h:97
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
CaloCell_Base_ID::is_tile
bool is_tile(const Identifier id) const
test if the id belongs to the Tiles
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
JiveXML::DataMap
std::map< std::string, DataVect > DataMap
Definition: DataType.h:59
HWIdentifier
Definition: HWIdentifier.h:13
x
#define x
JiveXML::LArDigitRetriever::m_cellTimePrec
int m_cellTimePrec
Definition: LArDigitRetriever.h:96
JiveXML::LArDigitRetriever::m_sgKeyLArDigit_esd
SG::ReadHandleKey< LArDigitContainer > m_sgKeyLArDigit_esd
Definition: LArDigitRetriever.h:78
CaloCell_Base_ID::is_hec
bool is_hec(const Identifier id) const
test if the id belongs to the HEC
ReadCondHandle.h
TileID.h
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
JiveXML::LArDigitRetriever::m_doHECDigit
bool m_doHECDigit
Definition: LArDigitRetriever.h:90
JiveXML::LArDigitRetriever::dataTypeName
virtual std::string dataTypeName() const
Return the name of the data type.
Definition: LArDigitRetriever.h:67
JiveXML::LArDigitRetriever::calcHECLayerSub
void calcHECLayerSub(Identifier &)
Definition: LArDigitRetriever.cxx:494
CaloCell_Base_ID::is_em
bool is_em(const Identifier id) const
test if the id belongs to LArEM
LArOnlineID_Base::channel
int channel(const HWIdentifier id) const
Return the channel number of a hardware cell identifier channel = [0,127] in all FEB.
Definition: LArOnlineID_Base.cxx:1963
Index
IndexedConstituentUserInfo::Index Index
Definition: IndexedConstituentUserInfo.cxx:12
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
JiveXML::LArDigitRetriever::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArDigitRetriever.h:79
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
lumiFormat.i
int i
Definition: lumiFormat.py:85
JiveXML::DataType
Templated class to convert any object that is streamable in a ostringstream in a string.
Definition: DataType.h:21
CaloCell_Base_ID::is_fcal
bool is_fcal(const Identifier id) const
test if the id belongs to the FCAL - true also for MiniFCAL
DetDescrDictionaryDict::it1
std::vector< HWIdentifier >::iterator it1
Definition: DetDescrDictionaryDict.h:17
JiveXML::LArDigitRetriever::getLArDigitData
const DataMap getLArDigitData(const CaloCellContainer *cellContainer, const std::string &datatype, CaloCell_ID::SUBCALO calotype)
Retrieve Tile cell location and details.
Definition: LArDigitRetriever.cxx:123
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
JiveXML::LArDigitRetriever::initialize
StatusCode initialize()
Default AthAlgTool methods.
Definition: LArDigitRetriever.cxx:64
CaloCell_Base_ID::SUBCALO
SUBCALO
enumeration of sub calorimeters
Definition: CaloCell_Base_ID.h:46
test_pyathena.parent
parent
Definition: test_pyathena.py:15
JiveXML::LArDigitRetriever::m_sub
DataVect m_sub
Definition: LArDigitRetriever.h:102
JiveXML::LArDigitRetriever::m_cellEnergyPrec
int m_cellEnergyPrec
Definition: LArDigitRetriever.h:95
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
WriteCellNoiseToCool.cellGain
cellGain
Definition: WriteCellNoiseToCool.py:434
LArDigitRetriever.h
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
JiveXML::LArDigitRetriever::calcEMLayerSub
void calcEMLayerSub(Identifier &)
Definition: LArDigitRetriever.cxx:484
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
JiveXML::LArDigitRetriever::m_inputdpd
bool m_inputdpd
Definition: LArDigitRetriever.h:94
JiveXML
This header is shared inbetween the C-style server thread and the C++ Athena ServerSvc.
Definition: BadLArRetriever.cxx:22
JiveXML::LArDigitRetriever::m_adc2mevKey
SG::ReadCondHandleKey< LArADC2MeV > m_adc2mevKey
Definition: LArDigitRetriever.h:82
calibdata.datatypes
list datatypes
Definition: calibdata.py:55
LArRawChannel.h
HWIdentifier.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArOnlineID
Definition: LArOnlineID.h:20
JiveXML::LArDigitRetriever::m_doLArDigit
bool m_doLArDigit
Definition: LArDigitRetriever.h:89
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
LArNewCalib_Delay_OFC_Cali.FT
FT
Definition: LArNewCalib_Delay_OFC_Cali.py:124
makeTRTBarrelCans.dy
tuple dy
Definition: makeTRTBarrelCans.py:21
JiveXML::LArDigitRetriever::retrieve
virtual StatusCode retrieve(ToolHandle< IFormatTool > &FormatTool)
Retrieve all the data.
Definition: LArDigitRetriever.cxx:81
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
y
#define y
JiveXML::LArDigitRetriever::m_doMaskLArChannelsM5
bool m_doMaskLArChannelsM5
Definition: LArDigitRetriever.h:100
CaloDetDescrElement::dx
float dx() const
cell dx
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:375
ILArPedestal.h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
JiveXML::LArDigitRetriever::m_LArChannelsToIgnoreM5
std::vector< Identifier::value_type > m_LArChannelsToIgnoreM5
Definition: LArDigitRetriever.h:99
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
CaloCellContainer::endConstCalo
CaloCellContainer::const_iterator endConstCalo(CaloCell_ID::SUBCALO caloNum) const
Definition: CaloCellContainer.cxx:133
CaloCellContainer::findIndex
int findIndex(const IdentifierHash theHash) const
Return index of the cell with a given hash.
Definition: CaloCellContainer.cxx:363
LArDigitContainer
Container class for LArDigit.
Definition: LArDigitContainer.h:24
LArElecCalib::ERRORCODE
@ ERRORCODE
Definition: LArCalibErrorCode.h:17
JiveXML::LArDigitRetriever::m_cellConditionCut
bool m_cellConditionCut
Definition: LArDigitRetriever.h:93
JiveXML::LArDigitRetriever::m_sgKeyLArDigit_raw
SG::ReadHandleKey< LArDigitContainer > m_sgKeyLArDigit_raw
Definition: LArDigitRetriever.h:77
SelectAllObject.h
AthAlgTool
Definition: AthAlgTool.h:26
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
JiveXML::LArDigitRetriever::m_lar
bool m_lar
Definition: LArDigitRetriever.h:86
CaloCell_Base_ID::LAREM
@ LAREM
Definition: CaloCell_Base_ID.h:46
dqBeamSpot.nEntries
int nEntries
Definition: dqBeamSpot.py:73
CaloDetDescrElement::dy
float dy() const
cell dy
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:377
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
LArRawChannelContainer.h
LArOnlineID.h
LArVectorProxy
Proxy for accessing a range of float values like a vector.
Definition: LArVectorProxy.h:38
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
python.LArCondContChannels.posNeg
posNeg
Definition: LArCondContChannels.py:659
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Dec 22 2024 21:13:25 for ATLAS Offline Software by   doxygen 1.8.18