ATLAS Offline Software
TileCalCellMonTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // NAME: TileCalCellMonTool.cxx
6 #include "TileCalCellMonTool.h"
7 
8 
9 #include "CaloIdentifier/TileID.h"
10 
11 #include "AthenaMonitoring/DQBadLBFilterTool.h"
12 #include "AthenaMonitoring/DQAtlasReadyFilterTool.h"
13 
14 #include "CaloEvent/CaloCellContainer.h"
15 #include "StoreGate/ReadCondHandle.h"
16 #include "GaudiKernel/ThreadLocalContext.h"
17 #include "AthenaKernel/Units.h"
18 
19 #include "TProfile2D.h"
20 #include "TProfile.h"
21 #include "TH2F.h"
22 #include "TH1F.h"
23 
24 #include <cassert>
25 
26 using Athena::Units::GeV;
27 
29 TileCalCellMonTool::TileCalCellMonTool(const std::string& type, const std::string& name,const IInterface* parent)
30  :CaloMonToolBase(type, name, parent),
31  m_useTwoGaus(true),
32  m_tile_id(nullptr)
33 {
34  declareInterface<IMonitorToolBase>(this);
35 
36  declareProperty("useTwoGaus", m_useTwoGaus=true,"Use double-gaussian noise description for Tile-cells");
37 
38  // min energy for tilecal cells
39  declareProperty("energyThreshold",m_tileThreshold=300.); //Threshold in GeV
40 
41 }
42 
43 
44 
45 TileCalCellMonTool::~TileCalCellMonTool() = default;
46 
48 StatusCode TileCalCellMonTool::initialize() {
49 
50  ATH_MSG_DEBUG("TileCalCellMonTool::initialize() start");
51 
52  ATH_CHECK( detStore()->retrieve(m_tile_id) );
53 
54  ATH_CHECK(m_noiseKey.initialize());
55 
56  initParam();
57 
58  //Initialize read handle key
59  ATH_CHECK( m_cellContainerName.initialize() );
60 
61  ATH_CHECK( ManagedMonitorToolBase::initialize() );
62  ATH_CHECK( CaloMonToolBase::initialize() );
63 
64  ATH_MSG_DEBUG("TileCalCellMonTool::initialize() is done!");
65  return StatusCode::SUCCESS;
66 }
67 
68 
69 void TileCalCellMonTool::initParam(){
70 
71  m_b_Ncells.reserve(3);
72  m_b_Ncells[0]=250;
73  m_b_Ncells[1]=0;
74  m_b_Ncells[2]=500;
75 
76  m_b_CellsE.reserve(3);
77  m_b_CellsE[0]=50;
78  m_b_CellsE[1]=0.;
79  m_b_CellsE[2]=20.;
80 
81  m_b_CellsEta.reserve(3);
82  m_b_CellsEta[0]=100;
83  m_b_CellsEta[1]=-5.0;
84  m_b_CellsEta[2]=5.0;
85 
86  m_b_CellsEtaTile.reserve(3);
87  m_b_CellsEtaTile[0]=17;
88  m_b_CellsEtaTile[1]=-1.7;
89  m_b_CellsEtaTile[2]=1.7;
90 
91  m_b_CellsPhi.reserve(3);
92  m_b_CellsPhi[0]=64;
93  m_b_CellsPhi[1]=-M_PI;
94  m_b_CellsPhi[2]=M_PI;
95 
96 
97  m_b_CellsEtaPhi.reserve(6);
98  m_b_CellsEtaPhi[0]=17;
99  m_b_CellsEtaPhi[1]=-1.7;
100  m_b_CellsEtaPhi[2]=1.7;
101  m_b_CellsEtaPhi[3]=64;
102  m_b_CellsEtaPhi[4]=-M_PI;
103  m_b_CellsEtaPhi[5]=M_PI;
104 
105 
106  m_b_CellsModule.reserve(3);
107  m_b_CellsModule[0]=70;
108  m_b_CellsModule[1]=0.0;
109  m_b_CellsModule[2]=70;
110 
111  m_b_CellsTower.reserve(3);
112  m_b_CellsTower[0]=18;
113  m_b_CellsTower[1]=0.0;
114  m_b_CellsTower[2]=18;
115 
116 }
117 
118 StatusCode TileCalCellMonTool::bookHistograms() {
119 
120  MonGroup tileGroup(this,m_tilePath,run);
121 
122  m_h_Ncells = new TH1F("CellsXN","Number of tile cells",(int)m_b_Ncells[0],m_b_Ncells[1], m_b_Ncells[2]);
123  m_h_Ncells->GetXaxis()->SetTitle("Number" );
124  m_h_Ncells->GetYaxis()->SetTitle("Events");
125  tileGroup.regHist( m_h_Ncells ).ignore();
126 
127  m_h_CellsE = new TH1F("CellsXE","Energy of tile cells",(int)m_b_CellsE[0],m_b_CellsE[1], m_b_CellsE[2]);
128  m_h_CellsE->GetXaxis()->SetTitle("Cell Energy [GeV]");
129  m_h_CellsE->GetYaxis()->SetTitle("Events");
130  tileGroup.regHist( m_h_CellsE ).ignore();
131 
132  m_h_CellsNoiseE = new TH1F("CellsNoiseTile","Energy/Noise(DB) of TileCal",200, -10., 10.);
133  m_h_CellsNoiseE->GetXaxis()->SetTitle("Cell Energy / sigma (DB)");
134  m_h_CellsNoiseE->GetYaxis()->SetTitle("Events");
135  tileGroup.regHist( m_h_CellsNoiseE ).ignore();
136 
137  m_h_CellsEta = new TProfile("CellsXEta","Tile cell energy vs Eta",(int)m_b_CellsEtaTile[0],m_b_CellsEtaTile[1], m_b_CellsEtaTile[2]);
138  m_h_CellsEta->GetXaxis()->SetTitle("Eta");
139  m_h_CellsEta->GetYaxis()->SetTitle("Mean energy [GeV]");
140  tileGroup.regHist( m_h_CellsEta ).ignore();
141 
142 
143  m_h_CellsEtaPhi = new TH2F("CellsXEtaVSPhi","Nr TileCal cells above threshold",(int)m_b_CellsEtaPhi[0],m_b_CellsEtaPhi[1], m_b_CellsEtaPhi[2],
144  (int)m_b_CellsEtaPhi[3],m_b_CellsEtaPhi[4], m_b_CellsEtaPhi[5]);
145  m_h_CellsEtaPhi->GetXaxis()->SetTitle("Eta");
146  m_h_CellsEtaPhi->GetYaxis()->SetTitle("Phi [rad]");
147  m_h_CellsEtaPhi->GetXaxis()->SetNdivisions(530);
148  m_h_CellsEtaPhi->GetYaxis()->SetNdivisions(530);
149  tileGroup.regHist( m_h_CellsEtaPhi ).ignore();
150 
151 
152  m_h_CellsPhi = new TProfile("CellsXPhi","Tile cell energy vs Phi",(int)m_b_CellsPhi[0],m_b_CellsPhi[1], m_b_CellsPhi[2]);
153  m_h_CellsPhi->GetXaxis()->SetTitle("Phi");
154  m_h_CellsPhi->GetYaxis()->SetTitle("Mean energy [GeV]");
155  tileGroup.regHist( m_h_CellsPhi ).ignore();
156 
157  m_h_CellsModuleS1 = new TProfile("CellsXModuleS1","Sampling Nr 1",(int)m_b_CellsModule[0],m_b_CellsModule[1], m_b_CellsModule[2]);
158  m_h_CellsModuleS1->GetXaxis()->SetTitle("Module");
159  m_h_CellsModuleS1->GetYaxis()->SetTitle("Mean cell energy [GeV]");
160  tileGroup.regHist( m_h_CellsModuleS1 ).ignore();
161 
162  m_h_CellsModuleS2 = new TProfile("CellsXModuleS2","Sampling Nr 2",(int)m_b_CellsModule[0],m_b_CellsModule[1], m_b_CellsModule[2]);
163  m_h_CellsModuleS2->GetXaxis()->SetTitle("Module");
164  m_h_CellsModuleS2->GetYaxis()->SetTitle("Mean cell energy [GeV]");
165  tileGroup.regHist( m_h_CellsModuleS2 ).ignore();
166 
167  m_h_CellsModuleS3 = new TProfile("CellsXModuleS3","Sampling Nr 3",(int)m_b_CellsModule[0],m_b_CellsModule[1], m_b_CellsModule[2]);
168  m_h_CellsModuleS3->GetXaxis()->SetTitle("Module");
169  m_h_CellsModuleS3->GetYaxis()->SetTitle("Mean cell energy [GeV]");
170  tileGroup.regHist( m_h_CellsModuleS3 ).ignore();
171 
172 
173  m_h_CellsModuleS4 = new TProfile("CellsXModuleS4","Sampling Nr 4",(int)m_b_CellsModule[0],m_b_CellsModule[1], m_b_CellsModule[2]);
174  m_h_CellsModuleS4->GetXaxis()->SetTitle("Module");
175  m_h_CellsModuleS4->GetYaxis()->SetTitle("Mean cell energy [GeV]");
176  tileGroup.regHist( m_h_CellsModuleS4 ).ignore();
177 
178  m_h_CellsTower = new TProfile("CellsXTower","Towers",(int)m_b_CellsTower[0],m_b_CellsTower[1], m_b_CellsTower[2]);
179  m_h_CellsTower->GetXaxis()->SetTitle("Towers");
180  m_h_CellsTower->GetYaxis()->SetTitle("Mean cell energy [GeV]");
181  tileGroup.regHist( m_h_CellsTower ).ignore();
182 
183 
184  // tilecal
185  m_h_CellsNoiseEta = new TProfile("CellsNoiseXEta","Tile cell sigma(DB) vs Eta",(int)m_b_CellsEtaTile[0],m_b_CellsEtaTile[1], m_b_CellsEtaTile[2]);
186  m_h_CellsNoiseEta->GetXaxis()->SetTitle("Eta");
187  m_h_CellsNoiseEta->GetYaxis()->SetTitle("Mean cell noise (DB) [MeV]");
188  tileGroup.regHist( m_h_CellsNoiseEta ).ignore();
189 
190  m_h_CellsNoisePhi = new TProfile("CellsNoiseXPhi","Tile cell sigma(DB) vs Phi",(int)m_b_CellsPhi[0],m_b_CellsPhi[1], m_b_CellsPhi[2]);
191  m_h_CellsNoisePhi->GetXaxis()->SetTitle("Phi");
192  m_h_CellsNoisePhi->GetYaxis()->SetTitle("Mean cell noise (DB) [MeV]");
193  tileGroup.regHist( m_h_CellsNoisePhi ).ignore();
194 
195  m_h_CellsNoiseEtaPhi = new TH2F("CellsNoiseXEtaVSPhi","Nr of TileCells with E.gt.4 sigma(DB)",(int)m_b_CellsEtaPhi[0],m_b_CellsEtaPhi[1], m_b_CellsEtaPhi[2],
196  (int)m_b_CellsEtaPhi[3],m_b_CellsEtaPhi[4], m_b_CellsEtaPhi[5]);
197  m_h_CellsNoiseEtaPhi->GetXaxis()->SetTitle("Eta");
198  m_h_CellsNoiseEtaPhi->GetYaxis()->SetTitle("Phi [rad]");
199  m_h_CellsNoiseEtaPhi->GetXaxis()->SetNdivisions(530);
200  m_h_CellsNoiseEtaPhi->GetYaxis()->SetNdivisions(530);
201  tileGroup.regHist( m_h_CellsNoiseEtaPhi ).ignore();
202 
203 
204  m_h_CellsNoiseEtaPhiA = new TH2F("CellsNoiseXEtaVSPhiAcells","Nr of Tile cells-A with E.gt.4 sigma(DB)",(int)(2*m_b_CellsEtaPhi[0]),m_b_CellsEtaPhi[1], m_b_CellsEtaPhi[2],
205  (int)m_b_CellsEtaPhi[3],m_b_CellsEtaPhi[4], m_b_CellsEtaPhi[5]);
206  m_h_CellsNoiseEtaPhiA->GetXaxis()->SetTitle("Eta");
207  m_h_CellsNoiseEtaPhiA->GetYaxis()->SetTitle("Phi [rad]");
208  m_h_CellsNoiseEtaPhiA->GetXaxis()->SetNdivisions(530);
209  m_h_CellsNoiseEtaPhiA->GetYaxis()->SetNdivisions(530);
210  tileGroup.regHist( m_h_CellsNoiseEtaPhiA ).ignore();
211 
212 
213  m_h_CellsNoiseEtaPhiBC = new TH2F("CellsNoiseXEtaVSPhiBCcells","Nr of TileCells-BC with E.gt.4 sigma(DB)",(int)(2*m_b_CellsEtaPhi[0]),m_b_CellsEtaPhi[1], m_b_CellsEtaPhi[2],
214  (int)m_b_CellsEtaPhi[3],m_b_CellsEtaPhi[4], m_b_CellsEtaPhi[5]);
215  m_h_CellsNoiseEtaPhiBC->GetXaxis()->SetTitle("Eta");
216  m_h_CellsNoiseEtaPhiBC->GetYaxis()->SetTitle("Phi [rad]");
217  m_h_CellsNoiseEtaPhiBC->GetXaxis()->SetNdivisions(530);
218  m_h_CellsNoiseEtaPhiBC->GetYaxis()->SetNdivisions(530);
219  tileGroup.regHist( m_h_CellsNoiseEtaPhiBC ).ignore();
220 
221 
222  m_h_CellsNoiseEtaPhiD = new TH2F("CellsNoiseXEtaVSPhiDcells","Nr of TileCells-D with E.gt.4 sigma(DB)",(int)m_b_CellsEtaPhi[0],m_b_CellsEtaPhi[1], m_b_CellsEtaPhi[2],
223  (int)m_b_CellsEtaPhi[3],m_b_CellsEtaPhi[4], m_b_CellsEtaPhi[5]);
224  m_h_CellsNoiseEtaPhiD->GetXaxis()->SetTitle("Eta");
225  m_h_CellsNoiseEtaPhiD->GetYaxis()->SetTitle("Phi [rad]");
226  m_h_CellsNoiseEtaPhiD->GetXaxis()->SetNdivisions(530);
227  m_h_CellsNoiseEtaPhiD->GetYaxis()->SetNdivisions(530);
228  tileGroup.regHist( m_h_CellsNoiseEtaPhiD ).ignore();
229 
230  // cell E vs Eta and Phi. Errors show RMS (not error on the mean)
231  m_h_CellsRMSEta = new TProfile("CellsRMSXEta","Tile cell energy with RMS errors for Eta",(int)m_b_CellsEtaTile[0],m_b_CellsEtaTile[1], m_b_CellsEtaTile[2],"s");
232  m_h_CellsRMSEta->GetXaxis()->SetTitle("Eta");
233  m_h_CellsRMSEta->GetYaxis()->SetTitle("Mean cell energy+RMS [GeV]");
234  tileGroup.regHist( m_h_CellsRMSEta ).ignore();
235 
236  m_h_CellsRMSPhi = new TProfile("CellsRMSXPhi","Tile cell energy with RMS errors vs Phi",(int)m_b_CellsPhi[0],m_b_CellsPhi[1], m_b_CellsPhi[2],"s");
237  m_h_CellsRMSPhi->GetXaxis()->SetTitle("Phi");
238  m_h_CellsRMSPhi->GetYaxis()->SetTitle("Mean cell energy+RMS [GeV]");
239  tileGroup.regHist( m_h_CellsRMSPhi ).ignore();
240 
241 
242  char name[256];
243  char title[256];
244  sprintf(name,"%s_%s",(char*)m_h_CellsRMSEta->GetName(),"divNoiseDB");
245  sprintf(title,"%s - %s",(char*)m_h_CellsRMSEta->GetTitle(),"divNoiseDB");
246  m_h_CellsRMSdivDBnoiseEta = new TH1F(name,title,(int)m_b_CellsEtaTile[0],m_b_CellsEtaTile[1], m_b_CellsEtaTile[2]);
247  m_h_CellsRMSdivDBnoiseEta->SetNameTitle(name,title);
248  m_h_CellsRMSdivDBnoiseEta ->GetXaxis()->SetTitle("Eta");
249  m_h_CellsRMSdivDBnoiseEta ->GetYaxis()->SetTitle("Energy cell RMS / Cell noise (DB)");
250  tileGroup.regHist( m_h_CellsRMSdivDBnoiseEta ).ignore();
251 
252  sprintf(name,"%s_%s",(char*)m_h_CellsRMSPhi->GetName(),"divNoiseDB");
253  sprintf(title,"%s - %s",(char*)m_h_CellsRMSPhi->GetTitle(),"divNoiseDB");
254  m_h_CellsRMSdivDBnoisePhi = new TH1F(name,title,(int)m_b_CellsPhi[0],m_b_CellsPhi[1], m_b_CellsPhi[2]);
255  m_h_CellsRMSdivDBnoisePhi->SetNameTitle(name,title);
256  m_h_CellsRMSdivDBnoisePhi ->GetXaxis()->SetTitle("Phi");
257  m_h_CellsRMSdivDBnoisePhi ->GetYaxis()->SetTitle("Energy cell RMS / Cell noise (DB)");
258  tileGroup.regHist( m_h_CellsRMSdivDBnoisePhi ).ignore();
259 
260  m_h_CellsNoiseHash = new TH1F("CellsXNoiseXHash","Number of 4 sigma seeds per hash",5184,-0.5, 5183.5);
261  m_h_CellsNoiseHash->GetXaxis()->SetTitle("HashId" );
262  m_h_CellsNoiseHash->GetYaxis()->SetTitle("Events");
263  tileGroup.regHist( m_h_CellsNoiseHash ).ignore();
264 
265  // ATH_MSG_INFO("end of bookTileHists()");
266 
267 
268  MonGroup summaryGroup(this,m_tilePath+"/Summary",run);
269  ATH_CHECK(bookBaseHists(&summaryGroup)); //from base class
270  return StatusCode::SUCCESS;
271 }
272 
274 StatusCode TileCalCellMonTool::fillHistograms(){
275 
276  const EventContext& ctx = Gaudi::Hive::currentContext();
277 
278  // ATH_MSG_INFO("TileCalCellMonTool::fillHistograms() starts");
279  StatusCode sc = StatusCode::SUCCESS;
280 
281  bool ifPass = 1;
282  sc = checkFilters(ifPass);
283  if(sc.isFailure() || !ifPass) return StatusCode::SUCCESS;
284 
285  SG::ReadCondHandle<CaloNoise> noise (m_noiseKey, ctx);
286 
287  //=====================
288  // CaloCell info
289  //============================
290 
291  SG::ReadHandle<CaloCellContainer> cellContHandle (m_cellContainerName, ctx);
292  if (! cellContHandle.isValid()) { ATH_MSG_WARNING("No CaloCell container found in TDS"); return StatusCode::FAILURE; }
293  const CaloCellContainer* cellCont = cellContHandle.get();
294 
295 
296  CaloCellContainer::const_iterator it = cellCont->beginConstCalo(CaloCell_ID::TILE);
297  CaloCellContainer::const_iterator it_e = cellCont->endConstCalo(CaloCell_ID::TILE);
298  // loop over cells -------------
299  unsigned ncells=0;
300  for ( ; it!=it_e;++it) {
301  // cell info
302  const CaloCell* cell = *it;
303  Identifier id = cell->ID();
304  IdentifierHash hash = m_tile_id->cell_hash(id);
305  long sample=m_tile_id->sample(id);
306  long module=m_tile_id->module(id);
307  long tower=m_tile_id->tower(id);
308  int side=m_tile_id->side(id);
309  float cellen = cell->energy();
310  float cellenGeV=cellen/GeV;
311  double eta = cell->eta();
312  double phi = cell->phi();
313  bool badc=cell->badcell();
314  float cellnoisedb = 0.;
315 
316 
317  if (!m_useTwoGaus)
318  cellnoisedb = noise->getNoise(id, cell->gain());
319  else
320  cellnoisedb = noise->getEffectiveSigma(id, cell->gain(), cell->energy());
321 
322  double rs=999;
323  if (std::isfinite(cellnoisedb) && cellnoisedb > 0 && cellen != 0 && !badc) rs= cellen / cellnoisedb;
324 
325  if (sample < 3) { // Sample E not relevant for topoclusters
326  if (!badc && rs != 999 ) m_h_CellsNoiseE->Fill( rs );
327  if (fabs(rs)>4.0 && !badc && rs != 999 ) {
328  m_h_CellsNoiseEtaPhi->Fill( eta, phi);
329  m_h_CellsNoiseHash->Fill(hash);
330  if (sample ==0 ) m_h_CellsNoiseEtaPhiA->Fill( eta, phi );
331  else if (sample ==1 ) m_h_CellsNoiseEtaPhiBC->Fill( eta, phi );
332  else m_h_CellsNoiseEtaPhiD->Fill( eta, phi );
333 
334  ATH_MSG_DEBUG( "TileCalCellMonTool: Cell rs=" << rs << " e=" << cellen << " eta=" << eta << " phi="<< phi );
335  ATH_MSG_DEBUG( "TileCalCellMonTool: hash=" << hash << " module= " << module+1 << " sample=" << sample
336  << " tower=" << side*tower );
337  }// end of if (fabs(rs)>4.0 && badc == false && rs != 999 )
338 
339  if ( !badc) {
340  m_h_CellsNoiseEta->Fill( eta, cellnoisedb, 1.0 );
341  m_h_CellsNoisePhi->Fill( phi, cellnoisedb, 1.0 );
342  m_h_CellsRMSEta->Fill( eta, cellenGeV, 1.0 );
343  m_h_CellsRMSPhi->Fill( phi, cellenGeV, 1.0 );
344  }
345  } // end of if (sample < 3)
346 
347  if (cellen > m_tileThreshold) {
348  ncells++;
349  m_h_CellsE->Fill( cellenGeV );
350  m_h_CellsEta->Fill( eta, cellenGeV, 1.0 );
351  m_h_CellsPhi->Fill( phi, cellenGeV, 1.0 );
352  if (sample ==0 ) m_h_CellsModuleS1->Fill( module+1, cellenGeV );
353  if (sample ==1 ) m_h_CellsModuleS2->Fill( module+1, cellenGeV );
354  if (sample ==2 ) m_h_CellsModuleS3->Fill( module+1, cellenGeV );
355  if (sample ==3 ) m_h_CellsModuleS4->Fill( module+1, cellenGeV );
356  m_h_CellsTower->Fill( tower+1, cellenGeV );
357  m_h_CellsEtaPhi->Fill( eta, phi );
358  } //end if cell energy above threshold
359  } // end of it loop
360  m_h_Ncells->Fill( (float) ncells ); // count TileCal cells above threshold
361 
362  return StatusCode::SUCCESS;
363 }
364 
365 StatusCode TileCalCellMonTool::procHistograms() {
366  getRMSdevNoise(m_h_CellsRMSEta,m_h_CellsNoiseEta,m_h_CellsRMSdivDBnoiseEta);
367  getRMSdevNoise(m_h_CellsRMSPhi,m_h_CellsNoisePhi,m_h_CellsRMSdivDBnoisePhi);
368  return StatusCode::SUCCESS;
369 }
370 
372 // helpers for process histograms
373 
374 
375 /* The aim of this function is calculate RMS/NoiseDB histogram from 2 profile
376  * histograms.
377  */
378 void TileCalCellMonTool::getRMSdevNoise(TProfile *t1, TProfile *t2, TH1F *t3) {
379  // t1 histogram with RMS as errors
380  // t2 histogram with noise DB
381  // resulting histogram
382 
383  //Check if the histograms are actually defined, if not, return:
384  if( (!t1) || (!t2) || (!t3) ) {
385  return;
386  }
387 
388  int nb=t1->GetNbinsX();
389  for(int ix=1;ix<nb+1;ix++){
390  Double_t ierr1=(t1->GetBinError(ix))*1000; // convert to MeV
391  Double_t ent = t1->GetBinEntries(ix);
392  Double_t ierr2=t2->GetBinError(ix);
393  Double_t ienn2=t2->GetBinContent(ix);
394  double Rat=0.0;
395  if (ienn2>0) Rat=ierr1/ienn2; // ratio: RMS/noiseDB
396  double er1=0;
397  if (ent>0) er1=ierr1/sqrt(ent); // error on RMS
398  double er2=0;
399  if (ienn2>0) er2=ierr2/ienn2;
400  double Err=Rat*sqrt( (er1*er1) + (er2*er2) );
401  t3->SetBinContent(ix,Rat);
402  t3->SetBinError(ix,Err);
403  }
404  t3->SetEntries( nb );
405  t3->SetStats(0);
406 }
407 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileCalCellMonTool::m_h_CellsRMSPhi
TProfile * m_h_CellsRMSPhi
Definition: TileCalCellMonTool.h:102
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TileCalCellMonTool::m_b_CellsEtaTile
std::vector< double > m_b_CellsEtaTile
Definition: TileCalCellMonTool.h:68
TileCalCellMonTool.h
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
TileCalCellMonTool::TileCalCellMonTool
TileCalCellMonTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: TileCalCellMonTool.cxx:29
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
TileCalCellMonTool::m_h_CellsModuleS1
TProfile * m_h_CellsModuleS1
Definition: TileCalCellMonTool.h:86
TileCalCellMonTool::m_h_CellsEtaPhi
TH2F * m_h_CellsEtaPhi
Definition: TileCalCellMonTool.h:83
TileCalCellMonTool::m_cellContainerName
SG::ReadHandleKey< CaloCellContainer > m_cellContainerName
Definition: TileCalCellMonTool.h:51
TileCalCellMonTool::m_h_CellsModuleS3
TProfile * m_h_CellsModuleS3
Definition: TileCalCellMonTool.h:88
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
TileCalCellMonTool::m_tile_id
const TileID * m_tile_id
Definition: TileCalCellMonTool.h:60
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LUCID_EventTPCnv_Dict::t3
std::vector< LUCID_RawData_p1 > t3
Definition: LUCID_EventTPCnvDict.h:28
TileCalCellMonTool::m_h_CellsPhi
TProfile * m_h_CellsPhi
Definition: TileCalCellMonTool.h:85
Tile_Base_ID::side
int side(const Identifier &id) const
Definition: Tile_Base_ID.cxx:153
ALFA_EventTPCnv_Dict::t1
std::vector< ALFA_RawDataCollection_p1 > t1
Definition: ALFA_EventTPCnvDict.h:43
skel.it
it
Definition: skel.GENtoEVGEN.py:423
TileCalCellMonTool::m_b_CellsPhi
std::vector< double > m_b_CellsPhi
Definition: TileCalCellMonTool.h:70
Tile_Base_ID::sample
int sample(const Identifier &id) const
Definition: Tile_Base_ID.cxx:171
CaloCellContainer::beginConstCalo
CaloCellContainer::const_iterator beginConstCalo(CaloCell_ID::SUBCALO caloNum) const
get const iterators on cell of just one calo
Definition: CaloCellContainer.cxx:119
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TileCalCellMonTool::initialize
virtual StatusCode initialize() override
Definition: TileCalCellMonTool.cxx:48
TileCalCellMonTool::m_h_CellsE
TH1F * m_h_CellsE
Definition: TileCalCellMonTool.h:82
Tile_Base_ID::tower
int tower(const Identifier &id) const
Definition: Tile_Base_ID.cxx:165
TileCalCellMonTool::m_tileThreshold
float m_tileThreshold
Definition: TileCalCellMonTool.h:58
TileCalCellMonTool::m_b_CellsEta
std::vector< double > m_b_CellsEta
Definition: TileCalCellMonTool.h:67
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
TileCalCellMonTool::m_h_CellsNoiseEtaPhiBC
TH2F * m_h_CellsNoiseEtaPhiBC
Definition: TileCalCellMonTool.h:95
ReadCondHandle.h
TileID.h
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
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
TileCalCellMonTool::m_b_CellsEtaPhi
std::vector< double > m_b_CellsEtaPhi
Definition: TileCalCellMonTool.h:75
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TileCalCellMonTool::m_h_CellsModuleS4
TProfile * m_h_CellsModuleS4
Definition: TileCalCellMonTool.h:89
python.PyAthena.module
module
Definition: PyAthena.py:134
CaloMonToolBase::checkFilters
StatusCode checkFilters(bool &ifPass)
Definition: CaloMonToolBase.cxx:95
TileCalCellMonTool::m_h_CellsRMSEta
TProfile * m_h_CellsRMSEta
Definition: TileCalCellMonTool.h:103
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:138
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
Tile_Base_ID::module
int module(const Identifier &id) const
Definition: Tile_Base_ID.cxx:159
TileCalCellMonTool::getRMSdevNoise
static void getRMSdevNoise(TProfile *t1, TProfile *t2, TH1F *t3)
Definition: TileCalCellMonTool.cxx:378
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:100
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TileCalCellMonTool::bookHistograms
virtual StatusCode bookHistograms() override
An inheriting class should either override this function or bookHists().
Definition: TileCalCellMonTool.cxx:118
SG::ReadHandle::get
const_pointer_type get() const
Dereference the pointer, but don't cache anything.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TileCalCellMonTool::m_h_CellsEta
TProfile * m_h_CellsEta
Definition: TileCalCellMonTool.h:84
DQAtlasReadyFilterTool.h
covarianceTool.title
title
Definition: covarianceTool.py:542
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TileCalCellMonTool::m_b_CellsE
std::vector< double > m_b_CellsE
Definition: TileCalCellMonTool.h:65
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CaloCell_Base_ID::TILE
@ TILE
Definition: CaloCell_Base_ID.h:46
run
Definition: run.py:1
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
TileCalCellMonTool::~TileCalCellMonTool
virtual ~TileCalCellMonTool()
TileCalCellMonTool::m_h_Ncells
TH1F * m_h_Ncells
Definition: TileCalCellMonTool.h:81
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
ManagedMonitorToolBase::MonGroup::regHist
StatusCode regHist(TH1 *h)
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition: ManagedMonitorToolBase.cxx:195
TileCalCellMonTool::m_h_CellsNoisePhi
TProfile * m_h_CellsNoisePhi
Definition: TileCalCellMonTool.h:101
CaloMonToolBase
Definition: CaloMonToolBase.h:17
TileCalCellMonTool::initParam
void initParam()
Definition: TileCalCellMonTool.cxx:69
TileCalCellMonTool::m_h_CellsNoiseEtaPhi
TH2F * m_h_CellsNoiseEtaPhi
Definition: TileCalCellMonTool.h:93
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
TileCalCellMonTool::m_tilePath
const std::string m_tilePath
Definition: TileCalCellMonTool.h:44
CaloMonToolBase::initialize
StatusCode initialize()
Definition: CaloMonToolBase.cxx:28
TileCalCellMonTool::m_h_CellsNoiseE
TH1F * m_h_CellsNoiseE
Definition: TileCalCellMonTool.h:78
TProfile
Definition: rootspy.cxx:515
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
Units.h
Wrapper to avoid constant divisions when using units.
CaloCellContainer.h
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
TileCalCellMonTool::m_h_CellsRMSdivDBnoiseEta
TH1F * m_h_CellsRMSdivDBnoiseEta
Definition: TileCalCellMonTool.h:104
TileCalCellMonTool::m_h_CellsNoiseHash
TH1F * m_h_CellsNoiseHash
Definition: TileCalCellMonTool.h:97
TileCalCellMonTool::m_b_CellsModule
std::vector< double > m_b_CellsModule
Definition: TileCalCellMonTool.h:73
ALFA_EventTPCnv_Dict::t2
std::vector< ALFA_RawDataContainer_p1 > t2
Definition: ALFA_EventTPCnvDict.h:44
TProfile::Fill
int Fill(double, double)
Definition: rootspy.cxx:523
TileCalCellMonTool::m_h_CellsNoiseEtaPhiA
TH2F * m_h_CellsNoiseEtaPhiA
Definition: TileCalCellMonTool.h:94
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
TH1F
Definition: rootspy.cxx:320
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileCalCellMonTool::m_useTwoGaus
bool m_useTwoGaus
Definition: TileCalCellMonTool.h:53
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TileCalCellMonTool::m_h_CellsRMSdivDBnoisePhi
TH1F * m_h_CellsRMSdivDBnoisePhi
Definition: TileCalCellMonTool.h:105
TileCalCellMonTool::m_h_CellsTower
TProfile * m_h_CellsTower
Definition: TileCalCellMonTool.h:90
CaloCellContainer::endConstCalo
CaloCellContainer::const_iterator endConstCalo(CaloCell_ID::SUBCALO caloNum) const
Definition: CaloCellContainer.cxx:133
TileCalCellMonTool::m_b_Ncells
std::vector< double > m_b_Ncells
Definition: TileCalCellMonTool.h:63
TileCalCellMonTool::m_h_CellsModuleS2
TProfile * m_h_CellsModuleS2
Definition: TileCalCellMonTool.h:87
TileCalCellMonTool::m_b_CellsTower
std::vector< double > m_b_CellsTower
Definition: TileCalCellMonTool.h:72
TileCalCellMonTool::fillHistograms
virtual StatusCode fillHistograms() override
An inheriting class should either override this function or fillHists().
Definition: TileCalCellMonTool.cxx:274
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
Tile_Base_ID::cell_hash
IdentifierHash cell_hash(const Identifier &cell_id) const
fast conversion from ID to hash for cells
Definition: Tile_Base_ID.cxx:1030
TileCalCellMonTool::m_noiseKey
SG::ReadCondHandleKey< CaloNoise > m_noiseKey
Definition: TileCalCellMonTool.h:55
IdentifierHash
Definition: IdentifierHash.h:38
hotSpotInTAG.nb
nb
Definition: hotSpotInTAG.py:164
DQBadLBFilterTool.h
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
CaloMonToolBase::bookBaseHists
virtual StatusCode bookBaseHists(MonGroup *group)
Definition: CaloMonToolBase.cxx:66
TileCalCellMonTool::procHistograms
virtual StatusCode procHistograms() override
An inheriting class should either override this function or finalHists().
Definition: TileCalCellMonTool.cxx:365
TileCalCellMonTool::m_h_CellsNoiseEta
TProfile * m_h_CellsNoiseEta
Definition: TileCalCellMonTool.h:100
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
TileCalCellMonTool::m_h_CellsNoiseEtaPhiD
TH2F * m_h_CellsNoiseEtaPhiD
Definition: TileCalCellMonTool.h:96
Generated on Sun Jun 30 2024 21:28:43 for ATLAS Offline Software by   doxygen 1.8.18