ATLAS Offline Software
LArSuperCellMonAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // NAME: LArSuperCellMonAlg.cxx
6 // based on LArCellMonAlg:
7 // L. Morvaj, P.Strizenec, D. Oliveira Damazio - develop for Digital Trigger monitoring (2021)
8 // ********************************************************************
9 #include "LArSuperCellMonAlg.h"
10 
11 #include "CaloDetDescr/CaloDetDescrElement.h"
13 #include "Identifier/Identifier.h"
17 
18 //#include "AthenaMonitoring/DQBadLBFilterTool.h"
19 //#include "AthenaMonitoring/DQAtlasReadyFilterTool.h"
20 
22 #include "AthenaKernel/Units.h"
23 
25 
26 #include <cassert>
27 #include <algorithm>
28 
30 LArSuperCellMonAlg::LArSuperCellMonAlg(const std::string& name, ISvcLocator* pSvcLocator)
31  :AthMonitorAlgorithm(name, pSvcLocator),
32  // m_badChannelMask("BadLArRawChannelMask",this),
33  m_calo_id(nullptr)
34 {
35 }
36 
37 
38 
40 }
41 
44 
45  ATH_MSG_DEBUG("LArSuperCellMonAlg::initialize() start");
46 
47 
48  //Identfier-helpers
50 
55 
58 
59  ATH_MSG_DEBUG("LArSuperCellMonAlg::initialize() is done!");
60 
62 }
63 
64 
65 
67 
68  return StatusCode::SUCCESS;
69 }
70 
71 
73 StatusCode LArSuperCellMonAlg::fillHistograms(const EventContext& ctx) const{
74 
75  ATH_MSG_DEBUG("LArSuperCellMonAlg::fillHistograms() starts");
76 
78  const CaloCellContainer* superCellCont = superCellHdl.cptr();
79  if(!superCellCont){
80  ATH_MSG_ERROR("The requested SC container key " << m_superCellContainerKey.key() << " could not be retrieved. !!!");
81  return StatusCode::SUCCESS;
82  }
83 
85  const CaloCellContainer* superCellRefCont = superCellRefHdl.cptr();
86  if(!superCellRefCont){
87  ATH_MSG_ERROR("The requested SC ref container key " << m_superCellContainerRefKey.key() << " could not be retrieved. !!!");
88  return StatusCode::SUCCESS;
89  }
90 
91  const CaloCellContainer *superCellRecoCont = nullptr;
92  if(m_doSCReco){
94  if (!hSCetRecoContainer.isValid()) {
95  ATH_MSG_ERROR("The requested SC ET reco container key could not be retrieved. !!!");
96  }else{
97  superCellRecoCont = hSCetRecoContainer.cptr();
98  ATH_MSG_DEBUG("SCetRecoContainer.size() " << hSCetRecoContainer->size());
99  }
100  }
101 
102  if (ctx.evt()==0) {
104  const CaloNoise *noisep = *noiseHdl;
105  ATH_CHECK(createPerJobHistograms(superCellCont, noisep));
106  }
107 
108  // FIXME: "lumiBlock" is not monitored
109  //auto lumiBlock = Monitored::Scalar<unsigned int>("lumiBlock",0);
110  //lumiBlock = ctx.eventID().lumi_block();
111  // FIXME: "bcid" is not monitored nor used, only bcidFFB is
112  //auto bcid = Monitored::Scalar<unsigned int>("bcid",0);
113  //bcid = ctx.eventID().bunch_crossing_id();
114  unsigned int bcid = ctx.eventID().bunch_crossing_id();
115  int bcidFFB = bcid;
116  if (!m_bcDataKey.empty()){
119  }
120 
121  // create local variables to speed up things
122  // per layer
123  std::vector<std::vector<std::string> > nameHistos;
124  for (const auto& layerName : m_layerNames){
125  nameHistos.insert(nameHistos.end(),
126  {"superCellEt_"+layerName,
127  "superCelltime_"+layerName,
128  "superCellprovenance_"+layerName,
129  "superCellEta_"+layerName,
130  "superCellPhi_"+layerName,
131  "resolution_"+layerName,
132  "resolutionPass_"+layerName,
133  "resolutionHET_"+layerName,
134  "superCellEtRef_"+layerName,
135  "superCelltimeRef_"+layerName,
136  "superCellprovenanceRef_"+layerName,
137  "superCellEtDiff_"+layerName});
138  }
139 
140 
142 
143  CaloCellContainer::const_iterator SCit = superCellCont->begin();
144  CaloCellContainer::const_iterator SCit_e = superCellCont->end();
145 
146  std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>> variables;
147 
148  for ( ; SCit!=SCit_e;++SCit) {
149 
150  const CaloCell* superCell = *SCit;
151  variables.clear();
152  // Discard masked cells from monitoring
153  int SCprov = superCell->provenance()&0xFFF;
154  if (m_removeMasked && ((SCprov&0x80)==0x80)) continue;
155  float SCet = superCell->et();
156  const CaloDetDescrElement* SCcaloDDE = superCell->caloDDE();
157  float SCeta,SCphi;
158  unsigned iLyr, iLyrNS;
159  float SCt = superCell->time();
160 
161  getHistoCoordinates(SCcaloDDE, SCeta, SCphi, iLyr, iLyrNS);
162 
163 
164  bool SCpassTime = LArProv::test(SCprov,LArProv::SCTIMEPASS);//SCprov & 0x200;
165  bool SCpassPF = LArProv::test(SCprov,LArProv::SCPASSBCIDMAX);// SCprov & 0x40;
166 
167  const CaloCell* superCellRef = superCellRefCont->findCell( SCcaloDDE->identifyHash() );
168  float SCetRef = superCellRef->et();
169  float SCetDiff = SCet - SCetRef;
170  float resolution = -1000;
171  float resolutionPass = -1000;
172  float resolutionHET = -1000;
173  if ( SCetRef > m_thresholdsForResolution) resolution = 100.0*(SCet-SCetRef)/SCetRef;
174  if ( SCpassTime || SCpassPF ) resolutionPass = resolution;
175  if ( SCet > 4e3 ) resolutionHET=resolution;
176 
177  // real monitoring business
178  auto MSCet = Monitored::Scalar<float>("superCellEt",SCet);
179  auto MSCt = Monitored::Scalar<float>("superCelltime",SCt);
180  auto MSCprov = Monitored::Scalar<int>("superCellprovenance",SCprov);
181  auto MSCeta = Monitored::Scalar<float>("superCellEta",SCeta);
182  auto MSCphi = Monitored::Scalar<float>("superCellPhi",SCphi);
183  auto MSCres = Monitored::Scalar<float>("resolution",resolution);
184  auto MSCresPass = Monitored::Scalar<float>("resolutionPass",resolutionPass);
185  auto MSCresHET = Monitored::Scalar<float>("resolutionHET",resolutionHET);
186  auto MSCetRef = Monitored::Scalar<float>("superCellEtRef",SCetRef);
187  auto MSCtRef = Monitored::Scalar<float>("superCelltimeRef",superCellRef->time());
188  auto MSCprovRef = Monitored::Scalar<int>("superCellprovenanceRef",(superCellRef->provenance()&0xFFF));
189  auto MSCetDiff = Monitored::Scalar<float>("superCellEtDiff",SCetDiff);
190  // 'push_back' conditional variables one at a time, and 'insert' all other variables in one go
191  if ( SCetRef > m_thresholdsForResolution ) variables.push_back(MSCres);
192  if ( (SCetRef > m_thresholdsForResolution ) && (SCpassTime || SCpassPF ) ) variables.push_back(MSCresPass);
193  if ( (SCetRef > m_thresholdsForResolution ) && (SCet > 4e3 ) ) variables.push_back(MSCresHET);
194 
195  // let us put conditional to force building the linearity plot
196  // only when the new signal passes BCID
197 
198  // per layer
199  auto layerName=m_layerNames[iLyr];
200  auto LMSCet = Monitored::Scalar<float>(nameHistos[iLyr][0],SCet);
201  auto LMSCt = Monitored::Scalar<float>(nameHistos[iLyr][1],SCt);
202  auto LMSCprov = Monitored::Scalar<int>(nameHistos[iLyr][2],SCprov);
203  auto LMSCeta = Monitored::Scalar<float>(nameHistos[iLyr][3],SCeta);
204  auto LMSCphi = Monitored::Scalar<float>(nameHistos[iLyr][4],SCphi);
205  auto LMSCres = Monitored::Scalar<float>(nameHistos[iLyr][5],resolution);
206  auto LMSCresPass = Monitored::Scalar<float>(nameHistos[iLyr][6],resolutionPass);
207  auto LMSCresHET = Monitored::Scalar<float>(nameHistos[iLyr][7],resolutionHET);
208  auto LMSCetRef = Monitored::Scalar<float>(nameHistos[iLyr][8],SCetRef);
209  auto LMSCtRef = Monitored::Scalar<float>(nameHistos[iLyr][9],superCellRef->time());
210  auto LMSCprovRef = Monitored::Scalar<int>(nameHistos[iLyr][10],(superCellRef->provenance()&0xFFF));
211 
212  auto MBCIDFFB = Monitored::Scalar<int>("BCID",bcidFFB);
213  auto LMSCetDiff = Monitored::Scalar<float>(nameHistos[iLyr][11],SCetDiff);
214  if ( SCetRef > m_thresholdsForResolution ) variables.push_back(LMSCres);
215  if ( (SCetRef > m_thresholdsForResolution ) && (SCpassTime || SCpassPF ) ) variables.push_back(LMSCresPass);
216  if ( (SCetRef > m_thresholdsForResolution ) && (SCet > 4e3 ) ) variables.push_back(LMSCresHET);
217  if ( SCpassTime || SCpassPF ) variables.push_back(LMSCtRef);
218 
219  variables.insert(variables.end(),
220  {MSCet,
221  MSCt,
222  MSCprov,
223  MSCeta,
224  MSCphi,
225  MSCetRef,
226  MSCtRef,
227  MSCprovRef,
228  MSCetDiff,
229  LMSCet,
230  LMSCt,
231  LMSCprov,
232  LMSCeta,
233  LMSCphi,
234  LMSCetRef,
235  LMSCprovRef,
236  MBCIDFFB,
237  LMSCetDiff});
238 
239 
240  if(m_doSCReco){
241  auto MSCtReco = Monitored::Scalar<float>("superCelltimeReco",0.);
242  auto MSCetReco = Monitored::Scalar<float>("superCellEtReco",0.);
243  auto LMSCtReco = Monitored::Scalar<float>("superCelltimeReco_"+layerName,0.);
244  const CaloCell* superCellReco = superCellRecoCont->findCell( SCcaloDDE->identifyHash() );
245  if(superCellReco) {
246  float SCetReco = superCellReco->et();
247  float SCtimeReco = superCellReco->time();
248  MSCtReco = SCtimeReco;
249  MSCetReco = SCetReco;
250  LMSCtReco = SCtimeReco;
251 
252  variables.insert(variables.end(),
253  {MSCtReco,
254  LMSCtReco,
255  MSCetReco});
256  }
257  }
259 
260  } // end loop over SC
261 
262 
263 
264  ATH_MSG_DEBUG("LArSuperCellMonAlg::fillLarHists() is done");
265  return StatusCode::SUCCESS;
266 }
267 
268 
270 
271  ATH_MSG_INFO("Creating the once-per-job histograms");
272 
273  if(!noisep){
274  ATH_MSG_ERROR("Do not have DB noise, doing nothing !!!");
275  return StatusCode::SUCCESS;
276  }
277 
278  //The following histograms can be considered constants for one job
279  //(in fact, they are constant for an entire run or even run-periode)
280  //ActiveCells in eta/phi (to normalize 1D occupancy plots)
281  //BadChannel word
282  //Database noise
283 
284  auto doDatabaseNoisePlot = Monitored::Scalar<bool>("doDatabaseNoisePlot",m_doDatabaseNoiseVsEtaPhi);
285 
286  // if(!doDatabaseNoisePlot && !doCellsActiveEtaPlot && !doCellsActivePhiPlot) {
287  if(!doDatabaseNoisePlot) {
288  ATH_MSG_INFO("No once-per-job histogram requested");
289  return StatusCode::SUCCESS;
290  }
291 
292 
293  //filling:
294 
296  CaloCellContainer::const_iterator it_e = cellCont->end();
297  for ( ; it!=it_e;++it) {
298  const CaloCell* cell = *it;
299  Identifier id = cell->ID();
300  bool is_lar=m_calo_id->is_lar(id);
301  if(!is_lar) continue;
302  const CaloDetDescrElement* caloDDEl=cell->caloDDE();
303  float celleta, cellphi;
304  unsigned iLyr, iLyrNS;
305 
306 
307  getHistoCoordinates(caloDDEl, celleta, cellphi, iLyr, iLyrNS);
308 
309  auto mon_eta = Monitored::Scalar<float>("celleta_"+m_layerNames[iLyr],celleta);
310  auto mon_phi = Monitored::Scalar<float>("cellphi_"+m_layerNames[iLyr],cellphi);
311  auto cellnoisedb = Monitored::Scalar<float>("cellnoisedb_"+m_layerNames[iLyr],noisep->getNoise(id,cell->gain()));
312 
313  fill(m_MonGroupName,cellnoisedb,mon_eta,mon_phi);
314 
315 
316  }//end loop over cells
317 
318  return StatusCode::SUCCESS;
319 }
320 
321 
322 
323 std::string LArSuperCellMonAlg::strToLower(const std::string& input) const {
324  std::string output;
325  for (const auto& c : input) {
326  output.push_back(std::tolower(c));
327  }
328  return output;
329 }
330 
331 
332 
333 void LArSuperCellMonAlg::getHistoCoordinates(const CaloDetDescrElement* dde, float& celleta, float& cellphi, unsigned& iLyr, unsigned& iLyrNS) const {
334 
335  celleta=dde->eta_raw();
336  cellphi=dde->phi_raw();
337 
338  int calosample=dde->getSampling();
339  if (dde->is_lar_em_endcap_inner()) calosample-=1; //Here, we consider the two layers of the EMEC IW as EME1 and EME2 instad of layer 2 and 3
340  iLyrNS=m_caloSamplingToLyrNS.at(calosample); //will throw if out of bounds
341  if ((iLyrNS==EMB1NS || iLyrNS==EMB2NS) && m_calo_id->region(dde->identify())==1) {
342  //We are in the awkward region 1 of the EM Barrel
343  //Looking at the image at http://atlas.web.cern.ch/Atlas/GROUPS/LIQARGEXT/TDR/figures6/figure6-17.eps
344  //may be useful to understand what's going on here.
345 
346  //In brief: Region 1, layer 1 is closer related ot the middle compartment (aka layer 2)
347  // and region 1, layer 2 closer related to the back compartment (aka layer 3)
348  iLyrNS+=1;
349 
350  //Layer 2: 0<eta<1.4 + 1.4<eta<1.475, deta = 0.025. 3 rows of cells from region 1
351  //Layer 3: 0<eta<1.35 (deta=0.050) + 1.4<eta<1.475 (deta = 0.075). 1 row of cell from region 1 with different dEta
352  }
353 
354  const unsigned side=(celleta>0) ? 0 : 1; //Value >0 means A-side
355  iLyr=iLyrNS*2+side; //Getting LayerEnum value. This logic works because of the way the enums LayerEnum and LayerEnumNoSides are set up.
356  return;
357 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
CaloDetDescrElement::is_lar_em_endcap_inner
bool is_lar_em_endcap_inner() const
cell belongs to the inner wheel of EM end cap
Definition: CaloDetDescrElement.cxx:113
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
LArSuperCellMonAlg::m_superCellContainerRefKey
SG::ReadHandleKey< CaloCellContainer > m_superCellContainerRefKey
Definition: LArSuperCellMonAlg.h:55
CaloCell_Base_ID::region
int region(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
checkCoolLatestUpdate.variables
variables
Definition: checkCoolLatestUpdate.py:12
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LArSuperCellMonAlg.h
AtlasDetectorID::is_lar
bool is_lar(Identifier id) const
Definition: AtlasDetectorID.h:696
LArProv::SCPASSBCIDMAX
@ SCPASSBCIDMAX
Definition: LArProvenance.h:25
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
LArSuperCellMonAlg::m_doSCReco
BooleanProperty m_doSCReco
Definition: LArSuperCellMonAlg.h:96
skel.it
it
Definition: skel.GENtoEVGEN.py:407
LArSuperCellMonAlg::m_doDatabaseNoiseVsEtaPhi
BooleanProperty m_doDatabaseNoiseVsEtaPhi
Definition: LArSuperCellMonAlg.h:94
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
LArSuperCellMonAlg::m_thresholdsForResolution
FloatProperty m_thresholdsForResolution
Definition: LArSuperCellMonAlg.h:110
CaloCell::provenance
uint16_t provenance() const
get provenance (data member)
Definition: CaloCell.h:348
LArSuperCellMonAlg::m_calo_id
const CaloCell_ID * m_calo_id
Definition: LArSuperCellMonAlg.h:143
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
LArSuperCellMonAlg::m_layerNames
StringArrayProperty m_layerNames
Definition: LArSuperCellMonAlg.h:83
CaloCell::time
float time() const
get time (data member)
Definition: CaloCell.h:362
CaloNoise::getNoise
float getNoise(const IdentifierHash h, const int gain) const
Accessor by IdentifierHash and gain.
Definition: CaloNoise.h:34
Dedxcorrection::resolution
double resolution[nGasTypes][nParametersResolution]
Definition: TRT_ToT_Corrections.h:46
LArSuperCellMonAlg::m_superCellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_superCellContainerKey
Definition: LArSuperCellMonAlg.h:54
CaloDetDescrManager.h
Definition of CaloDetDescrManager.
CaloDetDescrElement::eta_raw
float eta_raw() const
cell eta_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:350
CaloCell_ID.h
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TRT::Hit::side
@ side
Definition: HitInfo.h:83
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
LArSuperCellMonAlg::m_bcDataKey
SG::ReadCondHandleKey< BunchCrossingCondData > m_bcDataKey
Property: Bunch crossing data (MC only) (conditions input).
Definition: LArSuperCellMonAlg.h:60
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition: CaloDetDescrElement.cxx:63
LArSuperCellMonAlg::m_MonGroupName
Gaudi::Property< std::string > m_MonGroupName
Definition: LArSuperCellMonAlg.h:62
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
LArSuperCellMonAlg::LArSuperCellMonAlg
LArSuperCellMonAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: LArSuperCellMonAlg.cxx:30
LArSuperCellMonAlg::~LArSuperCellMonAlg
~LArSuperCellMonAlg()
Definition: LArSuperCellMonAlg.cxx:39
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LArSuperCellMonAlg::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override final
adds event to the monitoring histograms
Definition: LArSuperCellMonAlg.cxx:73
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CaloCell::caloDDE
const CaloDetDescrElement * caloDDE() const
get pointer to CaloDetDescrElement (data member)
Definition: CaloCell.h:315
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:108
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
BunchCrossingCondData::BunchCrossings
@ BunchCrossings
Distance in units of 25 nanoseconds.
Definition: BunchCrossingCondData.h:132
CaloCell::et
virtual double et() const override final
get et
Definition: CaloCell.h:417
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
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
LArProv::SCTIMEPASS
@ SCTIMEPASS
Definition: LArProvenance.h:30
LArSuperCellMonAlg::EMB1NS
@ EMB1NS
Definition: LArSuperCellMonAlg.h:106
LArSuperCellMonAlg::strToLower
std::string strToLower(const std::string &input) const
Definition: LArSuperCellMonAlg.cxx:323
BunchCrossingCondData::distanceFromFront
int distanceFromFront(const bcid_type bcid, const BunchDistanceType type=NanoSec) const
The distance of the specific bunch crossing from the front of the train.
Definition: BunchCrossingCondData.cxx:38
CaloCellContainer::findCell
const CaloCell * findCell(const IdentifierHash theHash) const
fast find method given identifier hash.
Definition: CaloCellContainer.cxx:345
CaloNoise
Definition: CaloNoise.h:16
LArSuperCellMonAlg::initThresh
StatusCode initThresh()
Definition: LArSuperCellMonAlg.cxx:66
HWIdentifier.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
LArProv::test
bool test(const uint16_t prov, const LArProvenance check)
Definition: LArProvenance.h:38
CaloDetDescrElement::identifyHash
IdentifierHash identifyHash() const override final
cell subcalo hash same as subcalo_hash(), but kept for backward compatibility
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:424
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
xAOD::bcid
setEventNumber setTimeStamp bcid
Definition: EventInfo_v1.cxx:133
Units.h
Wrapper to avoid constant divisions when using units.
CaloCellContainer.h
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
LArSuperCellMonAlg::initialize
virtual StatusCode initialize() override final
initialize
Definition: LArSuperCellMonAlg.cxx:43
LArSuperCellMonAlg::m_superCellContainerRecoKey
SG::ReadHandleKey< CaloCellContainer > m_superCellContainerRecoKey
Definition: LArSuperCellMonAlg.h:56
LArSuperCellMonAlg::m_noiseCDOKey
SG::ReadCondHandleKey< CaloNoise > m_noiseCDOKey
Definition: LArSuperCellMonAlg.h:69
LArProvenance.h
LArSuperCellMonAlg::m_removeMasked
BooleanProperty m_removeMasked
Definition: LArSuperCellMonAlg.h:111
LArSuperCellMonAlg::m_caloSamplingToLyrNS
const std::map< unsigned, LayerEnumNoSides > m_caloSamplingToLyrNS
Definition: LArSuperCellMonAlg.h:119
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
CaloGain.h
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
LArSuperCellMonAlg::getHistoCoordinates
void getHistoCoordinates(const CaloDetDescrElement *dde, float &celleta, float &cellphi, unsigned &iLyr, unsigned &iLyrNS) const
Definition: LArSuperCellMonAlg.cxx:333
LArSuperCellMonAlg::EMB2NS
@ EMB2NS
Definition: LArSuperCellMonAlg.h:106
python.compressB64.c
def c
Definition: compressB64.py:93
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
CaloDetDescrElement::phi_raw
float phi_raw() const
cell phi_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:352
LArSuperCellMonAlg::createPerJobHistograms
StatusCode createPerJobHistograms(const CaloCellContainer *cellcont, const CaloNoise *noisep) const
Definition: LArSuperCellMonAlg.cxx:269
Identifier
Definition: IdentifierFieldParser.cxx:14