ATLAS Offline Software
CscRdoValAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
6 /* NAME : CscRdoValAlg.cxx
7  * PACKAGE : MuonRawDataMonitoring/CscRawDataMonitoring
8  * PURPOSE : CSC ROD-cluster (RDO) monitoring
9  * AUTHOR : Ken Johns, Xiaowen Lei (U.Arizona)
10  *
11  * MODIFIED: N. Benekos(Illinois)
12  * V. Kaushik(U.Arizona) : 2009-05-10
13  */
14 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
15 
16 // Athena include(s)
17 #include "CscRdoValAlg.h"
18 #include "MuonRDO/CscRawData.h"
19 #include "MuonRDO/CscRawDataCollection.h"
20 
21 // ROOT include(s)
22 #include "TClass.h"
23 #include "TH1F.h"
24 #include "TH2F.h"
25 
26 namespace CscRdoBins {
27  void RdoBinLabels(TH1 *h, int side) {
28  h->GetXaxis()->SetTitle("");
29  h->GetXaxis()->SetLabelSize(0.03);
30  if(side == -1) {
31  for(size_t j=6; j<86; j++) {
32  if( j%5 != 0 ) {
33  float xmid = h->GetBinLowEdge(j) + h->GetBinWidth(j);
34  xmid -= 1.0; xmid *= -1.0;
35  int seclay = int(ceil(xmid*10)); // get sector/layer
36  int sec = seclay/10;
37  int lay = (seclay%10)/2 ;
38  lay = (4 - lay) + 1;
39  h->GetXaxis()->SetBinLabel(j,Form("%c%02d:%d",(sec%2==0?'S':'L'),sec,lay));
40  } // end for
41  } // end if
42  } else if (side == 1) {
43  for(size_t j=6; j<86; j++) {
44  if( j%5 != 0 ) {
45  float xmid = h->GetBinLowEdge(j) + h->GetBinWidth(j);
46  int seclay = int(ceil(xmid*10)); // get sector/layer
47  int sec = seclay/10;
48  int lay = (seclay%10)/2 ;
49  h->GetXaxis()->SetBinLabel(j,Form("%c%02d:%d",(sec%2==0?'S':'L'),sec,lay));
50  }
51  } // end for
52  } // end else
53 
54  } // BinLabels
55 
56 } // end namespace CscBins
57 
58 
59 //
60 // constructor ----------------------------------------------------------------
61 //
62 CscRdoValAlg::CscRdoValAlg(const std::string & type, const std::string & name,
63  const IInterface* parent) : ManagedMonitorToolBase(type, name, parent),
64  m_cscRdoDecoderTool("Muon::CscRDO_Decoder"),
65  m_cscrdo_oviewEA(nullptr),
66  m_cscrdo_oviewEC(nullptr)
67 {
68 
69  declareProperty("CSCRawDataPath", m_cscRDOPath = "Muon/MuonRawDataMonitoring/CSC/RDO");
70  declareProperty("CSCRawDataDecoder",m_cscRdoDecoderTool);
71  declareProperty("NoiseCutADC", m_cscNoiseCut = 50);
72 
73  m_cscGenPath = m_cscRDOPath.substr(0,m_cscRDOPath.find("CSC"));
74 
75  initHistograms();
76 
77 }
78 
79 
80 //
81 // destructor ----------------------------------------------------------------
82 //
83 CscRdoValAlg::~CscRdoValAlg() {
84  if(m_cscrdo_oviewEA) {
85  delete m_cscrdo_oviewEA;
86  m_cscrdo_oviewEA = nullptr;
87  }
88  if(m_cscrdo_oviewEC) {
89  delete m_cscrdo_oviewEC;
90  m_cscrdo_oviewEC = nullptr;
91  }
92  ATH_MSG_DEBUG ( " deleting CscRdoValAlg " );
93 }
94 
95 
96 //
97 // initialize ----------------------------------------------------------------
98 //
99 StatusCode CscRdoValAlg::initialize() {
100  ATH_CHECK(ManagedMonitorToolBase::initialize());
101  ATH_MSG_DEBUG ("CscRdoValAlg : in initialize()");
102  ATH_CHECK(m_idHelperSvc.retrieve());
103  ATH_CHECK(m_cscRdoDecoderTool.retrieve());
104  ATH_CHECK(m_cscRdoKey.initialize());
105  return StatusCode::SUCCESS;
106 }
107 
108 
109 //
112 void CscRdoValAlg::initHistograms() {
113 
114  m_h2csc_rdo_hitmap = nullptr;
115  m_h2csc_rdo_hitmap_signal = nullptr;
116  m_h2csc_rdo_hitmap_noise = nullptr;
117 
118  m_h2csc_rdo_hitmap_norm = nullptr;
119  m_h2csc_rdo_hitmap_norm_signal = nullptr;
120  m_h2csc_rdo_hitmap_norm_noise = nullptr;
121 
122  m_h2csc_rdo_hitmap_signal_EA = nullptr;
123  m_h1csc_rdo_hitmap_signal_EA_count = nullptr;
124  m_h1csc_rdo_hitmap_signal_EA_occupancy = nullptr;
125 
126  m_h2csc_rdo_hitmap_norm_signal_EA = nullptr;
127 
128  m_h2csc_rdo_hitmap_signal_EC = nullptr;
129  m_h1csc_rdo_hitmap_signal_EC_count = nullptr;
130  m_h1csc_rdo_hitmap_signal_EC_occupancy = nullptr;
131 
132  m_h2csc_rdo_hitmap_norm_signal_EC = nullptr;
133 
134  m_h2csc_rdo_phicluswidth = nullptr;
135  m_h2csc_rdo_phicluswidth_signal = nullptr;
136  m_h2csc_rdo_phicluswidth_noise = nullptr;
137 
138  m_h2csc_rdo_phicluswidth_signal_EA = nullptr;
139  m_h1csc_rdo_phicluswidth_signal_EA_count = nullptr;
140  m_h1csc_rdo_phicluswidth_signal_EA_occupancy = nullptr;
141 
142  m_h2csc_rdo_phicluswidth_signal_EC = nullptr;
143  m_h1csc_rdo_phicluswidth_signal_EC_count = nullptr;
144  m_h1csc_rdo_phicluswidth_signal_EC_occupancy = nullptr;
145 
146  m_h2csc_rdo_etacluswidth = nullptr;
147  m_h2csc_rdo_etacluswidth_signal = nullptr;
148  m_h2csc_rdo_etacluswidth_noise = nullptr;
149 
150  m_h2csc_rdo_etacluswidth_signal_EA = nullptr;
151  m_h1csc_rdo_etacluswidth_signal_EA_count = nullptr;
152  m_h1csc_rdo_etacluswidth_signal_EA_occupancy = nullptr;
153  m_h2csc_rdo_etacluswidth_signal_EC = nullptr;
154  m_h1csc_rdo_etacluswidth_signal_EC_count = nullptr;
155  m_h1csc_rdo_etacluswidth_signal_EC_occupancy = nullptr;
156 
157  m_h2csc_rdo_phicluscount = nullptr;
158  m_h2csc_rdo_phicluscount_signal = nullptr;
159  m_h2csc_rdo_phicluscount_noise = nullptr;
160 
161  m_h2csc_rdo_etacluscount = nullptr;
162  m_h2csc_rdo_etacluscount_signal = nullptr;
163  m_h2csc_rdo_etacluscount_noise = nullptr;
164 
165 
166  m_h1csc_rdo_maxdiffamp = nullptr;
167 
168  // Correlation plots
169  m_h2csc_rdo_eta_vs_phi_cluscount = nullptr;
170  m_h2csc_rdo_eta_vs_phi_cluscount_signal = nullptr;
171  m_h2csc_rdo_eta_vs_phi_cluscount_noise = nullptr;
172 
173  m_h2csc_rdo_eta_vs_phi_cluswidth = nullptr;
174  m_h2csc_rdo_eta_vs_phi_cluswidth_signal = nullptr;
175 
176 }
177 
178 //
179 // bookRdoHistograms ----------------------------------------------------------------
180 //
181 void CscRdoValAlg::bookRdoHistograms(){
182 
183  m_regHShift.clear();
184  m_regHExpert.clear();
185  m_regHOviewEA.clear();
186  m_regHOviewEC.clear();
187 
189  int nxbins = 242; // 192 bins for precision, 48 for transverse strips + 2 extra
190  float nxmin = -49.; // -1 -> -48 (for transverse)
191  float nxmax = 193.; // 1 -> 192 (for precision)
192 
193  int nybins = 175; // 32 chambers (16 per side x 5 layers per chamber) + 4 extra
194  float nymin = -17.; //
195  float nymax = 18.; //
196 
197  int nybinsEA = 90; // 16 chambers (x 5 layers per chamber) + 1 set extra
198  float nyminEA = 0.; //
199  float nymaxEA = 18.; //
200 
201  int nybinsEC = 85; // 16 chambers (x 5 layers per chamber) + 1 set extra
202  float nyminEC = -17.; //
203  float nymaxEC = 0.; //
205 
206  // book histograms
207  m_h1csc_rdo_maxdiffamp = new TH1F("h1csc_rdo_maxdiffamp", "Max Amplitude in ROD Cluster;ADC counts;;",500,0,5000);
208 
209  // strip hitmap
210  m_h2csc_rdo_hitmap = new TH2F("h2csc_rdo_hitmap", "Hit Occupancy;channel;[sector] + [0.2 #times layer]",
211  nxbins,nxmin,nxmax,nybins,nymin,nymax);
212  m_h2csc_rdo_hitmap_noise = new TH2F("h2csc_rdo_hitmap_noise", "Noise Occupancy;channel;[sector] + [0.2 #times layer]",
213  nxbins,nxmin,nxmax,nybins,nymin,nymax);
214  m_h2csc_rdo_hitmap_signal = new TH2F("h2csc_rdo_hitmap_signal", "Signal Occupancy;channel;[sector] + [0.2 #times layer]",
215  nxbins,nxmin,nxmax,nybins,nymin,nymax);
216 
217  m_h2csc_rdo_hitmap_norm = new TH2F("h2csc_rdo_hitmap_norm", "Hit Occupancy;channel;[sector] + [0.2 #times layer]",
218  nxbins,nxmin,nxmax,nybins,nymin,nymax);
219  m_h2csc_rdo_hitmap_norm_noise = new TH2F("h2csc_rdo_hitmap_norm_noise", "Noise Occupancy;channel;[sector] + [0.2 #times layer]",
220  nxbins,nxmin,nxmax,nybins,nymin,nymax);
221  m_h2csc_rdo_hitmap_norm_signal = new TH2F("h2csc_rdo_hitmap_norm_signal", "Signal Occupancy;channel;[sector] + [0.2 #times layer]",
222  nxbins,nxmin,nxmax,nybins,nymin,nymax);
223 
224  m_h2csc_rdo_hitmap_signal_EA = new TH2F("h2csc_rdo_hitmap_signal_EA", "EndCap A: Signal Occupancy;channel;[sector] + [0.2 #times layer]",
225  nxbins,nxmin,nxmax,nybinsEA,nyminEA,nymaxEA);
226  m_h1csc_rdo_hitmap_signal_EA_count = new TH1F("h1csc_rdo_hitmap_signal_EA_count", "EndCap A: Signal Occupancy;channel;entries/channel",
227  nxbins,nxmin,nxmax);
228  m_h1csc_rdo_hitmap_signal_EA_occupancy = new TH1F("h1csc_rdo_hitmap_signal_EA_occupancy", "EndCap A: Signal Occupancy;[sector] + [0.2 #times layer];entries/layer",
229  nybinsEA,nyminEA,nymaxEA);
230  CscRdoBins::RdoBinLabels(m_h1csc_rdo_hitmap_signal_EA_occupancy,1);
231 
232  m_h2csc_rdo_hitmap_norm_signal_EA = new TH2F("h2csc_rdo_hitmap_norm_signal_EA", "EndCap A: Signal Occupancy;channel;[sector] + [0.2 #times layer]",
233  nxbins,nxmin,nxmax,nybinsEA,nyminEA,nymaxEA);
234 
235  m_h2csc_rdo_hitmap_signal_EC = new TH2F("h2csc_rdo_hitmap_signal_EC", "EndCap C: Signal Occupancy;channel;[sector] + [0.2 #times layer]",
236  nxbins,nxmin,nxmax,nybinsEC,nyminEC,nymaxEC);
237  m_h1csc_rdo_hitmap_signal_EC_count = new TH1F("h1csc_rdo_hitmap_signal_EC_count", "EndCap C: Signal Occupancy;channel;entries/channel",
238  nxbins,nxmin,nxmax);
239  m_h1csc_rdo_hitmap_signal_EC_occupancy = new TH1F("h1csc_rdo_hitmap_signal_EC_occupancy", "EndCap C: Signal Occupancy;[sector] + [0.2 #times layer];entries/layer",
240  nybinsEC,nyminEC,nymaxEC);
241  CscRdoBins::RdoBinLabels(m_h1csc_rdo_hitmap_signal_EC_occupancy,-1);
242 
243  m_h2csc_rdo_hitmap_norm_signal_EC = new TH2F("h2csc_rdo_hitmap_norm_signal_EC", "EndCap C: Signal Occupancy;channel;[sector] + [0.2 #times layer]",
244  nxbins,nxmin,nxmax,nybinsEC,nyminEC,nymaxEC);
245 
246  // ROD eta-cluster width
247  m_h2csc_rdo_etacluswidth = new TH2F("h2csc_rdo_etacluswidth",
248  "ROD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]",
249  192,0,192,nybins,nymin,nymax);
250  m_h2csc_rdo_etacluswidth_noise = new TH2F("h2csc_rdo_etacluswidth_noise",
251  "ROD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]",
252  192,0,192,nybins,nymin,nymax);
253  m_h2csc_rdo_etacluswidth_signal = new TH2F("h2csc_rdo_etacluswidth_signal",
254  "ROD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]",
255  192,0,192,nybins,nymin,nymax);
256  m_h2csc_rdo_etacluswidth_signal_EA = new TH2F("h2csc_rdo_etacluswidth_signal_EA",
257  "EndCap A: ROD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]",
258  192,0,192,nybinsEA,nyminEA,nymaxEA);
259  m_h1csc_rdo_etacluswidth_signal_EA_count = new TH1F("h1csc_rdo_etacluswidth_signal_EA_count",
260  "EndCap A: ROD precision-cluster width;width(no.of strips);entries;",192,0,192);
261  m_h1csc_rdo_etacluswidth_signal_EA_occupancy = new TH1F("h1csc_rdo_etacluswidth_signal_EA_occupancy",
262  "EndCap A: ROD precision-cluster width;[sector] + [0.2 #times layer];entries/layer",nybinsEA,nyminEA,nymaxEA);
263  CscRdoBins::RdoBinLabels(m_h1csc_rdo_etacluswidth_signal_EA_occupancy,1);
264 
265  m_h2csc_rdo_etacluswidth_signal_EC = new TH2F("h2csc_rdo_etacluswidth_signal_EC",
266  "EndCap C: ROD precision-cluster width;no.of strips;[sector] + [0.2 #times layer]",
267  192,0,192,nybinsEC,nyminEC,nymaxEC);
268  m_h1csc_rdo_etacluswidth_signal_EC_count = new TH1F("h1csc_rdo_etacluswidth_signal_EC_count",
269  "EndCap C: ROD precision-cluster width;width(no.of strips);entries",192,0,192);
270  m_h1csc_rdo_etacluswidth_signal_EC_occupancy = new TH1F("h1csc_rdo_etacluswidth_signal_EC_occupancy",
271  "EndCap C: ROD precision-cluster width;[sector] + [0.2 #times layer];entries/layer",nybinsEC,nyminEC,nymaxEC);
272  CscRdoBins::RdoBinLabels(m_h1csc_rdo_etacluswidth_signal_EC_occupancy,-1);
273 
274  // ROD phi-cluster width
275  m_h2csc_rdo_phicluswidth = new TH2F("h2csc_rdo_phicluswidth",
276  "ROD transverse-cluster width;width(no.of strips);[sector] + [0.2 #times layer]",
277  48,0,48,nybins,nymin,nymax);
278  m_h2csc_rdo_phicluswidth_noise = new TH2F("h2csc_rdo_phicluswidth_noise",
279  "ROD transverse-cluster width;width(no.of strips);[sector] + [0.2 #times layer]",
280  48,0,48,nybins,nymin,nymax);
281  m_h2csc_rdo_phicluswidth_signal = new TH2F("h2csc_rdo_phicluswidth_signal",
282  "ROD transverse-cluster width;width(no.of strips);[sector] + [0.2 #times layer]",
283  48,0,48,nybins,nymin,nymax);
284 
285  m_h2csc_rdo_phicluswidth_signal_EA = new TH2F("h2csc_rdo_phicluswidth_signal_EA",
286  "EndCap A: ROD transverse-cluster width;width(no.of strips);[sector] + [0.2 #times layer]",
287  48,0,48,nybinsEA,nyminEA,nymaxEA);
288  m_h1csc_rdo_phicluswidth_signal_EA_count = new TH1F("h1csc_rdo_phicluswidth_signal_EA_count",
289  "EndCap A: ROD transverse-cluster width;width(no.of strips);entries",48,0,48);
290  m_h1csc_rdo_phicluswidth_signal_EA_occupancy = new TH1F("h1csc_rdo_phicluswidth_signal_EA_occupancy",
291  "EndCap A: ROD transverse-cluster width;[sector] + [0.2 #times layer];entries/layer",nybinsEA,nyminEA,nymaxEA);
292  CscRdoBins::RdoBinLabels(m_h1csc_rdo_phicluswidth_signal_EA_occupancy,1);
293 
294  m_h2csc_rdo_phicluswidth_signal_EC = new TH2F("h2csc_rdo_phicluswidth_signal_EC",
295  "EndCap C: ROD transverse-cluster width;width(no.of strips);[sector] + [0.2 #times layer]",
296  48,0,48,nybinsEC,nyminEC,nymaxEC);
297  m_h1csc_rdo_phicluswidth_signal_EC_count = new TH1F("h1csc_rdo_phicluswidth_signal_EC_count",
298  "EndCap C: ROD transverse-cluster width;width(no.of strips);entries",48,0,48);
299  m_h1csc_rdo_phicluswidth_signal_EC_occupancy = new TH1F("h1csc_rdo_phicluswidth_signal_EC_occupancy",
300  "EndCap C: ROD transverse-cluster width;[sector] + [0.2 #times layer];entries/layer",nybinsEC,nyminEC,nymaxEC);
301  CscRdoBins::RdoBinLabels(m_h1csc_rdo_phicluswidth_signal_EC_occupancy,-1);
302 
303  // ROD eta-cluster count
304  m_h2csc_rdo_etacluscount = new TH2F("h2csc_rdo_etacluscount",
305  "ROD precision-cluster count;no.of clusters;[sector] + [0.2 #times layer]",
306  20,0,20,nybins,nymin,nymax);
307  m_h2csc_rdo_etacluscount_noise = new TH2F("h2csc_rdo_etacluscount_noise",
308  "ROD precision-cluster count;no.of clusters;[sector] + [0.2 #times layer]",
309  20,0,20,nybins,nymin,nymax);
310  m_h2csc_rdo_etacluscount_signal = new TH2F("h2csc_rdo_etacluscount_signal",
311  "ROD precision-cluster count;no.of clusters;[sector] + [0.2 #times layer]",
312  20,0,20,nybins,nymin,nymax);
313 
314  // ROD phi-cluster count
315  m_h2csc_rdo_phicluscount = new TH2F("h2csc_rdo_phicluscount",
316  "ROD transverse-cluster count;no.of clusters;[sector] + [0.2 #times layer]",
317  20,0,20,nybins,nymin,nymax);
318  m_h2csc_rdo_phicluscount_noise = new TH2F("h2csc_rdo_phicluscount_noise",
319  "ROD transverse-cluster count;no.of clusters;[sector] + [0.2 #times layer]",
320  20,0,20,nybins,nymin,nymax);
321  m_h2csc_rdo_phicluscount_signal = new TH2F("h2csc_rdo_phicluscount_signal",
322  "ROD transverse-cluster count;no.of clusters;[sector] + [0.2 #times layer]",
323  20,0,20,nybins,nymin,nymax);
324 
325 
326  // correlation histograms
327  m_h2csc_rdo_eta_vs_phi_cluscount = new TH2F("h2csc_rdo_eta_vs_phi_cluscount",
328  "Eta vs. Phi Cluster count correlation;#varphi-cluster count;#eta-cluster count",100,0,100,100,0,100);
329  m_h2csc_rdo_eta_vs_phi_cluscount_noise = new TH2F("h2csc_rdo_eta_vs_phi_cluscount_noise",
330  "Eta vs. Phi Noise-Cluster count correlation;#varphi-cluster count;#eta-cluster count",100,0,100,100,0,100);
331  m_h2csc_rdo_eta_vs_phi_cluscount_signal = new TH2F("h2csc_rdo_eta_vs_phi_cluscount_signal",
332  "Eta vs. Phi Signal-Cluster count correlation;#varphi-cluster count;#eta-cluster count",100,0,100,100,0,100);
333 
334  m_h2csc_rdo_eta_vs_phi_cluswidth = new TH2F("h2csc_rdo_eta_vs_phi_cluswidth",
335  "Eta vs. Phi Cluster width correlation;#varphi-cluster width;#eta-cluster width",100,0,100,100,0,100);
336 
337  m_regHShift.push_back(m_h1csc_rdo_maxdiffamp); // shift, overview
338 
339  m_regHExpert.push_back(m_h2csc_rdo_hitmap); // expert
340  m_regHShift.push_back(m_h2csc_rdo_hitmap_signal); // shift, overview (dq-flag)
341  m_regHExpert.push_back(m_h2csc_rdo_hitmap_noise); // expert
342 
343  m_regHExpert.push_back(m_h2csc_rdo_hitmap_norm); // expert
344  m_regHShift.push_back(m_h2csc_rdo_hitmap_norm_signal); // shift, overview (dq-flag)
345  m_regHExpert.push_back(m_h2csc_rdo_hitmap_norm_noise); // expert
346 
347  m_regHOviewEA.push_back(m_h2csc_rdo_hitmap_signal_EA);
348  m_regHOviewEA.push_back(m_h1csc_rdo_hitmap_signal_EA_count);
349  m_regHOviewEA.push_back(m_h1csc_rdo_hitmap_signal_EA_occupancy);
350 
351  m_regHOviewEA.push_back(m_h2csc_rdo_hitmap_norm_signal_EA);
352 
353  m_regHOviewEC.push_back(m_h2csc_rdo_hitmap_signal_EC);
354  m_regHOviewEC.push_back(m_h1csc_rdo_hitmap_signal_EC_count);
355  m_regHOviewEC.push_back(m_h1csc_rdo_hitmap_signal_EC_occupancy);
356 
357  m_regHOviewEC.push_back(m_h2csc_rdo_hitmap_norm_signal_EC);
358 
359  m_regHExpert.push_back(m_h2csc_rdo_etacluswidth); // expert
360  m_regHShift.push_back(m_h2csc_rdo_etacluswidth_signal); // shift, overview (dq-flags)
361  m_regHExpert.push_back(m_h2csc_rdo_etacluswidth_noise); // expert
362 
363  m_regHOviewEA.push_back(m_h2csc_rdo_etacluswidth_signal_EA);
364  m_regHOviewEA.push_back(m_h1csc_rdo_etacluswidth_signal_EA_count);
365  m_regHOviewEA.push_back(m_h1csc_rdo_etacluswidth_signal_EA_occupancy);
366 
367  m_regHOviewEC.push_back(m_h2csc_rdo_etacluswidth_signal_EC);
368  m_regHOviewEC.push_back(m_h1csc_rdo_etacluswidth_signal_EC_count);
369  m_regHOviewEC.push_back(m_h1csc_rdo_etacluswidth_signal_EC_occupancy);
370 
371  m_regHExpert.push_back(m_h2csc_rdo_phicluswidth); // expert
372  m_regHShift.push_back(m_h2csc_rdo_phicluswidth_signal); // shift, overview (dq-flags)
373  m_regHExpert.push_back(m_h2csc_rdo_phicluswidth_noise); // expert
374 
375  m_regHOviewEA.push_back(m_h2csc_rdo_phicluswidth_signal_EA);
376  m_regHOviewEA.push_back(m_h1csc_rdo_phicluswidth_signal_EA_count);
377  m_regHOviewEA.push_back(m_h1csc_rdo_phicluswidth_signal_EA_occupancy);
378 
379  m_regHOviewEC.push_back(m_h2csc_rdo_phicluswidth_signal_EC);
380  m_regHOviewEC.push_back(m_h1csc_rdo_phicluswidth_signal_EC_count);
381  m_regHOviewEC.push_back(m_h1csc_rdo_phicluswidth_signal_EC_occupancy);
382 
383  m_regHExpert.push_back(m_h2csc_rdo_etacluscount); // expert
384  m_regHShift.push_back(m_h2csc_rdo_etacluscount_signal); // shift
385  m_regHExpert.push_back(m_h2csc_rdo_etacluscount_noise); // expert
386 
387  m_regHExpert.push_back(m_h2csc_rdo_phicluscount); // expert
388  m_regHShift.push_back(m_h2csc_rdo_phicluscount_signal); // shift
389  m_regHExpert.push_back(m_h2csc_rdo_phicluscount_noise); // expert
390 
391  m_regHExpert.push_back(m_h2csc_rdo_eta_vs_phi_cluscount); // expert
392  m_regHExpert.push_back(m_h2csc_rdo_eta_vs_phi_cluscount_signal); // expert
393  m_regHExpert.push_back(m_h2csc_rdo_eta_vs_phi_cluscount_noise); // expert
394 
395  m_regHExpert.push_back(m_h2csc_rdo_eta_vs_phi_cluswidth); // expert
396 
397 }
398 
399 //
400 // bookHistograms ----------------------------------------------------------------
401 //
402 StatusCode CscRdoValAlg::bookHistograms(){
403  ATH_MSG_DEBUG ( "CSCRdoMon : in bookHistograms()" );
404 
405  StatusCode sc = StatusCode::SUCCESS;
406 
407  bookRdoHistograms();
408 
409  //declare a group of histograms
410  MonGroup cscrdo_shift( this, m_cscRDOPath+"/Shift", run, ATTRIB_MANAGED );
411  MonGroup cscrdo_expert( this, m_cscRDOPath+"/Expert", run, ATTRIB_MANAGED );
412 
413  // register shift histograms with service
414  for(size_t j = 0; j < m_regHShift.size(); j++) {
415  sc=cscrdo_shift.regHist(m_regHShift[j]);
416  if(sc.isFailure()) {
417  ATH_MSG_ERROR ( "Failed to register shift histogram \"" << m_regHShift[j]->GetName() << "\"" );
418  return sc;
419  } // end if
420  } // end for
421 
422  // register expert histograms with service
423  for(size_t j = 0; j < m_regHExpert.size(); j++) {
424  sc=cscrdo_expert.regHist(m_regHExpert[j]);
425  if(sc.isFailure()) {
426  ATH_MSG_ERROR ( "Failed to register expert histogram \"" << m_regHExpert[j]->GetName() << "\"" );
427  return sc;
428  } // end if
429  } // end for
430 
431 
432  // register overview histograms for EA
433  std::vector<TH1 *>::iterator iT;
434  //MonGroup m_cscrdo_oviewEA( this, m_cscGenPath+"CSC/Overview/CSCEA", shift, run );
435  m_cscrdo_oviewEA = new MonGroup( this, m_cscGenPath+"CSC/Overview/CSCEA/RDO", run, ATTRIB_UNMANAGED );
436  iT = m_regHOviewEA.begin();
437  ATH_MSG_DEBUG ( "Found " << m_regHOviewEA.size() << " CSCEA Overview Histograms " );
438  for (; iT != m_regHOviewEA.end(); ++iT) {
439  sc = m_cscrdo_oviewEA->regHist(*iT);
440  if ( sc.isFailure() ) {
441  ATH_MSG_ERROR ( "Cannot register overview histogram for Endcap A: " << (*iT)->GetName() );
442  return sc;
443  }
444  }
445 
446  // register overview histograms for EC
447  //MonGroup m_cscrdo_oviewEC( this, m_cscGenPath+"CSC/Overview/CSCEC", shift, run );
448  m_cscrdo_oviewEC = new MonGroup( this, m_cscGenPath+"CSC/Overview/CSCEC/RDO", run, ATTRIB_UNMANAGED );
449  iT = m_regHOviewEC.begin();
450  ATH_MSG_DEBUG ( "Found " << m_regHOviewEC.size() << " CSCEC Overview Histograms " );
451  for (; iT != m_regHOviewEC.end(); ++iT) {
452  sc = m_cscrdo_oviewEC->regHist(*iT);
453  if ( sc.isFailure() ) {
454  ATH_MSG_ERROR ( "Cannot register overview histogram for Endcap C: " << (*iT)->GetName() );
455  return sc;
456  }
457  }
458 
459  //} // end if newRun
460 
461  return sc;
462 }
463 
464 
465 //
466 // fillHistograms ----------------------------------------------------------------
467 //
468 StatusCode CscRdoValAlg::fillHistograms() {
469 
470  StatusCode sc = StatusCode::SUCCESS;
471  ATH_MSG_DEBUG ( "CscRdoValAlg :: in fillHistograms()" );
472 
473  if(m_cscRdoKey.key()==""){ //it seems that protection is needed for this case
474  ATH_MSG_WARNING("CSC RDO key is blank, returning");
475  return sc;
476  }
477 
478  SG::ReadHandle<CscRawDataContainer> CscRDO(m_cscRdoKey);
479 
480  // ==============================================================================
481  // Field Range Notes
482  // ==============================================================================
483  // StationName unsigned integer maps to "CSS", "CSL", etc.
484  // StationEta [-1,1] -1 for backward, 1 for forward endcap
485  // StationPhi [1,8] increases with Phi
486  // Technology [1] maps to "CSC"
487  // ChamberLayer [1,2] increases with |Z|
488  // WireLayer [1,4] increases with |Z|
489  // MeasuresPhi [0,1] 0 if measures R, 1 if measures Phi
490  // Strip [1,n] increases with R for MeasuresPhi=0
491  // increases with Phi for MeasuresPhi=1
492  // ==============================================================================
493 
494  ATH_MSG_DEBUG ( " Size of RDO Container : " << CscRDO->size() );
495 
496  // Begin Event ==================================================
497  ATH_MSG_DEBUG ( " BEGIN EVENT ========================================== " );
498 
499  for (CscRawDataContainer::const_iterator it = CscRDO->begin(); it != CscRDO->end(); ++it) {
500  const CscRawDataCollection * rdo = *it;
501  ATH_MSG_DEBUG ( " Number of Samples : " << rdo->numSamples() );
502  ATH_MSG_DEBUG ( " Size of Collection : " << rdo->size() );
503 
504  size_t nEtaClusWidthCnt = 0, nPhiClusWidthCnt = 0; // cluster position in each phi-layer
505  Identifier stationId, channelId;
506 
507  int clusCount[33][9], sigclusCount[33][9];
508  for(size_t kl = 0; kl < 33; kl++ ) {
509  for(size_t km = 0; km < 9; km++ ) {
510  clusCount[kl][km] = 0;
511  sigclusCount[kl][km] = 0;
512  }
513  }
514  // loop over ROD-clusters
515  for (CscRawDataCollection::const_iterator ic = (*it)->begin(); ic != (*it)->end(); ++ic) {
516  const CscRawData * raw = (*ic);
517  if( raw ) {
518  // Identify side(A/C), sector(1-16)/layer(1-4)
519  stationId = m_cscRdoDecoderTool->stationIdentifier(raw,&m_idHelperSvc->cscIdHelper());
520  channelId = m_cscRdoDecoderTool->channelIdentifier(raw,&m_idHelperSvc->cscIdHelper(),0);
521  int stationName = m_idHelperSvc->cscIdHelper().stationName(channelId);
522  std::string stationString = m_idHelperSvc->cscIdHelper().stationNameString(stationName);
523  int chamberType = stationString == "CSS" ? 0 : 1;
524  int stationEta = m_idHelperSvc->cscIdHelper().stationEta(channelId);
525  int stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(channelId);
526  int wireLayer = m_idHelperSvc->cscIdHelper().wireLayer(channelId);
527  int measuresPhi = m_idHelperSvc->cscIdHelper().measuresPhi(channelId);
528 
529  // determine the sector number
530 
531  int sectorNo = stationEta * (2 * stationPhi - chamberType);
532 
533  // compute the indices to store cluster count
534  int ns = sectorNo < 0 ? sectorNo*(-1) : sectorNo+16; // [-16 -> -1] shifted to [1 -> 16] and [+1 -> +16] shifted to [+17 -> +32]
535  int nl = (measuresPhi ? wireLayer : wireLayer+4); // [ 1 -> 4] (phi-layers) and [5 -> 8] (eta-layers)
536 
537  clusCount[ns][nl]++;
538 
539  // indices for ns = [+1 -> +32]; 32 places (index '0' is not counted); allocated 33 places
540  // indices for nl = [+1 -> +8]; 8 places (index '0' is not counted); allocated 9 places
541  ATH_MSG_DEBUG(" ns = " << ns << "\tm_nl = " << nl << "\tm_sec = " << sectorNo << "\t m_lay= " << wireLayer << "\tmPhi = " << measuresPhi);
542 
543 
544  // y-axis fill value
545  // sector# +2 layer 1 maps to +2 + 0.2*(1-1) + 0.1 = +2.1
546  // sector# +2 layer 2 maps to +2 + 0.2*(2-1) + 0.1 = +2.3
547  // sector# +2 layer 3 maps to +2 + 0.2*(3-1) + 0.1 = +2.5
548  // sector# +2 layer 4 maps to +2 + 0.2*(4-1) + 0.1 = +2.7
549  float secLayer = sectorNo + 0.2 * (wireLayer - 1) + 0.1;
550  int xfac = measuresPhi ? -1 : 1; // -48 / +192
551 
552  // this way we get 4 time samples per strip
553  ATH_MSG_DEBUG ( " Width of ROD cluster : " << raw->width() );
554  uint16_t diff_max = 0, diff;
555  std::vector<float> xVals ; /*, m_yVals;*/
556  // loop over strips in ROD cluster
557  size_t raw_clus_width = raw->width();
558 
559  if(!measuresPhi) {
560  m_h2csc_rdo_etacluswidth->Fill(raw_clus_width,secLayer); // fill eta-cluster width
561  nEtaClusWidthCnt++;
562  } else {
563  m_h2csc_rdo_phicluswidth->Fill(raw_clus_width,secLayer); // fill phi-cluster width
564  nPhiClusWidthCnt++;
565  }
566 
567  // loop over strips
568  for (size_t n = 0; n < raw_clus_width; n++) {
569 
570  // identify this strip
571  Identifier chID = m_cscRdoDecoderTool->channelIdentifier(raw, &m_idHelperSvc->cscIdHelper(), n);
572  int strip = m_idHelperSvc->cscIdHelper().strip(chID);
573  float stripId = strip * xfac; // x-axis fill value
574 
575  m_h2csc_rdo_hitmap->Fill(stripId, secLayer); // fill hitmap
576 
577  // for every strip that has a hit, store the X,Y values
578  xVals.push_back(stripId);
579 
580  // extract the (four) time samples for this strip
581  std::vector<uint16_t> samples;
582  bool extractSamples = raw->samples(n, rdo->numSamples(), samples);
583  uint16_t n_max = 0, n_min = 9999;
584 
585  // if we have the time samples, identify the max/min sampling values i.e., ADC_max and ADC_min
586  if(extractSamples) {
587  for(size_t np = 0; np < samples.size(); np++) {
588  if(samples[np] < n_min) n_min = samples[np];
589  if(samples[np] > n_max) n_max = samples[np];
590  }
591  // the diff between max and min samplings Delta_ADC = (ADC_max - ADC_min)
592  diff = n_max - n_min;
593 
594  // compute the max difference Max_Delta_ADC
595  if(diff > diff_max) diff_max = diff;
596 
597  ATH_MSG_DEBUG ( n << " Max = " << n_max << " Min = " << n_min << " Diff = " << diff );
598  } // end if extractSamples
599 
600  } // end for loop over strips in cluster
601  ATH_MSG_DEBUG ( " End loop over strips======================" );
602 
603  ATH_MSG_DEBUG ( " Max difference : " << diff_max );
604 
605  m_h1csc_rdo_maxdiffamp->Fill(diff_max); // fill Max_Delta_ADC
606 
607  // determine of the cluster is a noise/signal cluster Max_Delta_ADC > NoiseCut
608  bool signal = diff_max > m_cscNoiseCut ? true : false;
609  if(signal) sigclusCount[ns][nl]++;
610  if(signal) {
611  for(size_t nf = 0; nf < xVals.size(); nf++) {
612  m_h2csc_rdo_hitmap_signal->Fill(xVals[nf],secLayer);
613  if(stationEta == -1) {
614  m_h2csc_rdo_hitmap_signal_EC->Fill(xVals[nf],secLayer);
615  m_h1csc_rdo_hitmap_signal_EC_count->Fill(xVals[nf]);
616  m_h1csc_rdo_hitmap_signal_EC_occupancy->Fill(secLayer);
617  } else {
618  m_h2csc_rdo_hitmap_signal_EA->Fill(xVals[nf],secLayer);
619  m_h1csc_rdo_hitmap_signal_EA_count->Fill(xVals[nf]);
620  m_h1csc_rdo_hitmap_signal_EA_occupancy->Fill(secLayer);
621  }
622  }
623  if(!measuresPhi) {
624  m_h2csc_rdo_etacluswidth_signal->Fill(raw_clus_width,secLayer);
625  if(stationEta == -1) {
626  m_h2csc_rdo_etacluswidth_signal_EC->Fill(raw_clus_width,secLayer);
627  m_h1csc_rdo_etacluswidth_signal_EC_count->Fill(raw_clus_width);
628  m_h1csc_rdo_etacluswidth_signal_EC_occupancy->Fill(secLayer);
629  } else {
630  m_h2csc_rdo_etacluswidth_signal_EA->Fill(raw_clus_width,secLayer);
631  m_h1csc_rdo_etacluswidth_signal_EA_count->Fill(raw_clus_width);
632  m_h1csc_rdo_etacluswidth_signal_EA_occupancy->Fill(secLayer);
633  }
634  }else {
635  m_h2csc_rdo_phicluswidth_signal->Fill(raw_clus_width,secLayer);
636  if(stationEta == -1) {
637  m_h2csc_rdo_phicluswidth_signal_EC->Fill(raw_clus_width,secLayer);
638  m_h1csc_rdo_phicluswidth_signal_EC_count->Fill(raw_clus_width);
639  m_h1csc_rdo_phicluswidth_signal_EC_occupancy->Fill(secLayer);
640  } else {
641  m_h2csc_rdo_phicluswidth_signal_EA->Fill(raw_clus_width,secLayer);
642  m_h1csc_rdo_phicluswidth_signal_EA_count->Fill(raw_clus_width);
643  m_h1csc_rdo_phicluswidth_signal_EA_occupancy->Fill(secLayer);
644  }
645  }
646  } else {
647  for(size_t nf = 0; nf < xVals.size(); nf++)
648  m_h2csc_rdo_hitmap_noise->Fill(xVals[nf],secLayer);
649  if(!measuresPhi) {
650  m_h2csc_rdo_etacluswidth_noise->Fill(raw_clus_width,secLayer);
651  }else {
652  m_h2csc_rdo_phicluswidth_noise->Fill(raw_clus_width,secLayer);
653  }
654  }
655  } // if raw (CscRawData)
656  } // end for loop over ROD-clusters
657  ATH_MSG_DEBUG ( " End loop over clusters======================" );
658 
659 
660  m_h2csc_rdo_eta_vs_phi_cluswidth->Fill(nPhiClusWidthCnt,nEtaClusWidthCnt);
661 
662  int numeta = 0, numphi = 0;
663  int numetasignal = 0, numphisignal = 0;
664  for(int kl = 1; kl < 33; kl++ ) {
665 
666  //int m_sec = kl < 17 ? kl*(-1) : kl; // [1->16](-side) [17-32] (+side)
667  for(int km = 1; km < 9; km++ ) {
668 
669  int lay = (km > 4 && km < 9) ? km-4 : km; // 1,2,3,4 (phi-layers) 5-4, 6-4, 7-4, 8-4 (eta-layers)
670  bool mphi = (km > 0 && km < 5) ? true : false; // 1,2,3,4 (phi-layers) 5,6,7,8 (eta-layers)
671  std::string wlay = mphi ? "Phi-Layer " : "Eta-Layer: ";
672  int count = clusCount[kl][km];
673  int scount = sigclusCount[kl][km];
674 
675  if(count) {
676  float secLayer = kl-16 + 0.2 * (lay - 1) + 0.1;
677  if(mphi) {
678  m_h2csc_rdo_phicluscount->Fill(count,secLayer); // all phi-cluster counts
679  numphi += count;
680  if(scount) {
681  numphisignal += scount;
682  m_h2csc_rdo_phicluscount_signal->Fill(scount,secLayer); // signal phi-cluster count
683  m_h2csc_rdo_phicluscount_noise->Fill((count-scount),secLayer); // noise phi-cluster count
684  } else {
685  m_h2csc_rdo_phicluscount_noise->Fill(count,secLayer); // noise phi-cluster count
686  }
687  } else {
688  m_h2csc_rdo_etacluscount->Fill(count,secLayer);
689  numeta += count;
690  if(scount) {
691  numetasignal += scount;
692  m_h2csc_rdo_etacluscount_signal->Fill(scount,secLayer); // signal eta-cluster count
693  m_h2csc_rdo_etacluscount_noise->Fill((count-scount),secLayer); // noise eta-cluster count
694  } else {
695  m_h2csc_rdo_etacluscount_noise->Fill(count,secLayer); // noise eta-cluster count
696  }
697  }
698  ATH_MSG_DEBUG ( wlay << "Counts sec: [" << kl-16 << "]\tlayer: [" << km << "] = " <<
699  secLayer << "\t = " << count << "\t" << scount);
700  }
701  }
702  }
703 
704  m_h2csc_rdo_eta_vs_phi_cluscount->Fill(numphi,numeta);
705  m_h2csc_rdo_eta_vs_phi_cluscount_signal->Fill(numphisignal,numetasignal);
706  m_h2csc_rdo_eta_vs_phi_cluscount_noise->Fill(numphi-numphisignal, numeta-numetasignal);
707 
708  } // end for if (container)
709  ATH_MSG_DEBUG ( " END EVENT ============================================ " );
710  // End Event ====================================================
711 
712  ATH_MSG_DEBUG ( "done collecting histograms" );
713  ATH_MSG_DEBUG ( "CSCRdoMon::fillHistograms reports success" );
714 
715  return sc;
716 }
717 
718 //
719 // checkHists ----------------------------------------------------------------
720 //
721 StatusCode CscRdoValAlg::checkHists(bool /* fromFinalize */) {
722 
723  ATH_MSG_DEBUG ( "CscRdoValAlg : in checkHists()" );
724 
725  return StatusCode::SUCCESS;
726 }
calibdata.scount
int scount
Definition: calibdata.py:355
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
CscRdoValAlg::m_cscRDOPath
std::string m_cscRDOPath
Definition: CscRdoValAlg.h:46
CscRdoValAlg::m_h2csc_rdo_etacluswidth_noise
TH2F * m_h2csc_rdo_etacluswidth_noise
Definition: CscRdoValAlg.h:88
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:129
CscRdoValAlg::bookHistograms
StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition: CscRdoValAlg.cxx:402
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
CscRdoValAlg::m_h2csc_rdo_phicluswidth_noise
TH2F * m_h2csc_rdo_phicluswidth_noise
Definition: CscRdoValAlg.h:76
SiliconTech::strip
@ strip
CscRdoValAlg::m_h2csc_rdo_phicluscount
TH2F * m_h2csc_rdo_phicluscount
Definition: CscRdoValAlg.h:97
CscRdoValAlg::m_h2csc_rdo_etacluswidth_signal_EA
TH2F * m_h2csc_rdo_etacluswidth_signal_EA
Definition: CscRdoValAlg.h:90
CscRdoValAlg::m_h1csc_rdo_etacluswidth_signal_EA_count
TH1F * m_h1csc_rdo_etacluswidth_signal_EA_count
Definition: CscRdoValAlg.h:91
CscRdoValAlg::m_h2csc_rdo_hitmap
TH2F * m_h2csc_rdo_hitmap
Definition: CscRdoValAlg.h:54
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
CscRdoValAlg::m_h2csc_rdo_hitmap_norm
TH2F * m_h2csc_rdo_hitmap_norm
Definition: CscRdoValAlg.h:58
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:74
dumpTgcDigiDeadChambers.stationName
dictionary stationName
Definition: dumpTgcDigiDeadChambers.py:30
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CscRdoValAlg::m_cscrdo_oviewEC
MonGroup * m_cscrdo_oviewEC
Definition: CscRdoValAlg.h:108
CscRdoValAlg::m_h1csc_rdo_phicluswidth_signal_EA_count
TH1F * m_h1csc_rdo_phicluswidth_signal_EA_count
Definition: CscRdoValAlg.h:79
CscRdoValAlg::m_h1csc_rdo_etacluswidth_signal_EA_occupancy
TH1F * m_h1csc_rdo_etacluswidth_signal_EA_occupancy
Definition: CscRdoValAlg.h:92
CscRdoValAlg::m_h1csc_rdo_hitmap_signal_EC_occupancy
TH1F * m_h1csc_rdo_hitmap_signal_EC_occupancy
Definition: CscRdoValAlg.h:70
skel.it
it
Definition: skel.GENtoEVGEN.py:423
IdentifiableContainerMT::size
size_t size() const
Duplicate of fullSize for backwards compatability.
Definition: IdentifiableContainerMT.h:209
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
CscRdoValAlg::m_regHOviewEA
std::vector< TH1 * > m_regHOviewEA
Definition: CscRdoValAlg.h:120
CscRdoValAlg::m_h1csc_rdo_phicluswidth_signal_EC_occupancy
TH1F * m_h1csc_rdo_phicluswidth_signal_EC_occupancy
Definition: CscRdoValAlg.h:84
CscRdoValAlg::bookRdoHistograms
void bookRdoHistograms()
Definition: CscRdoValAlg.cxx:181
CscRdoValAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: CscRdoValAlg.h:47
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
PlotPulseshapeFromCool.np
np
Definition: PlotPulseshapeFromCool.py:64
CscRdoValAlg::m_h2csc_rdo_etacluswidth_signal_EC
TH2F * m_h2csc_rdo_etacluswidth_signal_EC
Definition: CscRdoValAlg.h:93
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
CscRdoValAlg::m_h2csc_rdo_etacluswidth_signal
TH2F * m_h2csc_rdo_etacluswidth_signal
Definition: CscRdoValAlg.h:87
CscRdoValAlg::m_h2csc_rdo_etacluswidth
TH2F * m_h2csc_rdo_etacluswidth
Definition: CscRdoValAlg.h:86
CscRdoBins
Definition: CscRdoValAlg.cxx:26
CscRdoValAlg::m_h2csc_rdo_etacluscount_signal
TH2F * m_h2csc_rdo_etacluscount_signal
Definition: CscRdoValAlg.h:102
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
CscRdoValAlg::m_h1csc_rdo_etacluswidth_signal_EC_occupancy
TH1F * m_h1csc_rdo_etacluswidth_signal_EC_occupancy
Definition: CscRdoValAlg.h:95
CscRdoValAlg.h
TRT::Hit::side
@ side
Definition: HitInfo.h:83
CscRdoValAlg::m_h2csc_rdo_hitmap_signal_EC
TH2F * m_h2csc_rdo_hitmap_signal_EC
Definition: CscRdoValAlg.h:68
CscRdoValAlg::m_cscGenPath
std::string m_cscGenPath
Definition: CscRdoValAlg.h:46
CscRdoValAlg::m_h1csc_rdo_etacluswidth_signal_EC_count
TH1F * m_h1csc_rdo_etacluswidth_signal_EC_count
Definition: CscRdoValAlg.h:94
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:138
CscRdoValAlg::m_h1csc_rdo_maxdiffamp
TH1F * m_h1csc_rdo_maxdiffamp
Definition: CscRdoValAlg.h:106
CscRdoValAlg::m_h2csc_rdo_phicluswidth_signal_EC
TH2F * m_h2csc_rdo_phicluswidth_signal_EC
Definition: CscRdoValAlg.h:82
CscRdoValAlg::m_h2csc_rdo_eta_vs_phi_cluswidth
TH2F * m_h2csc_rdo_eta_vs_phi_cluswidth
Definition: CscRdoValAlg.h:115
keylayer_zslicemap.kl
kl
Definition: keylayer_zslicemap.py:109
CscRdoValAlg::m_h2csc_rdo_hitmap_norm_signal
TH2F * m_h2csc_rdo_hitmap_norm_signal
Definition: CscRdoValAlg.h:59
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CscRdoValAlg::fillHistograms
StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: CscRdoValAlg.cxx:468
CscRdoValAlg::m_regHShift
std::vector< TH1 * > m_regHShift
Definition: CscRdoValAlg.h:118
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:88
CscRdoValAlg::m_h2csc_rdo_phicluswidth_signal
TH2F * m_h2csc_rdo_phicluswidth_signal
Definition: CscRdoValAlg.h:75
CscRdoValAlg::m_h1csc_rdo_phicluswidth_signal_EA_occupancy
TH1F * m_h1csc_rdo_phicluswidth_signal_EA_occupancy
Definition: CscRdoValAlg.h:80
CscRdoValAlg::~CscRdoValAlg
~CscRdoValAlg()
Definition: CscRdoValAlg.cxx:83
CscRawData::width
uint16_t width() const
Definition: CscRawData.h:128
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
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
01SubmitToGrid.samples
samples
Definition: 01SubmitToGrid.py:58
CscRdoValAlg::initHistograms
void initHistograms()
Definition: CscRdoValAlg.cxx:112
ManagedMonitorToolBase::ATTRIB_UNMANAGED
@ ATTRIB_UNMANAGED
Definition: ManagedMonitorToolBase.h:131
CscRdoValAlg::m_h1csc_rdo_hitmap_signal_EA_occupancy
TH1F * m_h1csc_rdo_hitmap_signal_EA_occupancy
Definition: CscRdoValAlg.h:64
test_pyathena.parent
parent
Definition: test_pyathena.py:15
CscRdoValAlg::m_h2csc_rdo_phicluscount_signal
TH2F * m_h2csc_rdo_phicluscount_signal
Definition: CscRdoValAlg.h:98
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:242
CscRdoValAlg::CscRdoValAlg
CscRdoValAlg(const std::string &type, const std::string &name, const IInterface *parent)
Definition: CscRdoValAlg.cxx:62
run
Definition: run.py:1
ManagedMonitorToolBase::ATTRIB_MANAGED
@ ATTRIB_MANAGED
Definition: ManagedMonitorToolBase.h:131
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
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
CscRdoValAlg::m_cscNoiseCut
size_t m_cscNoiseCut
Definition: CscRdoValAlg.h:44
CaloCondBlobAlgs_fillNoiseFromASCII.channelId
channelId
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:122
CscRawDataCollection
Collection of CSC Raw Hits, arranged according to CSC Detector Elements Author: Ketevi A.
Definition: CscRawDataCollection.h:24
CscRdoBins::RdoBinLabels
void RdoBinLabels(TH1 *h, int side)
Definition: CscRdoValAlg.cxx:27
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
CscRdoValAlg::m_h2csc_rdo_hitmap_noise
TH2F * m_h2csc_rdo_hitmap_noise
Definition: CscRdoValAlg.h:56
CscRawDataCollection::numSamples
uint16_t numSamples() const
Definition: CscRawDataCollection.cxx:8
grepfile.ic
int ic
Definition: grepfile.py:33
CscRawDataCollection.h
CscRdoValAlg::m_h2csc_rdo_hitmap_norm_noise
TH2F * m_h2csc_rdo_hitmap_norm_noise
Definition: CscRdoValAlg.h:60
Cut::signal
@ signal
Definition: SUSYToolsAlg.cxx:64
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
CscRawData::samples
const std::vector< uint16_t > & samples() const
Definition: CscRawData.h:130
CscRdoValAlg::m_h2csc_rdo_eta_vs_phi_cluswidth_signal
TH2F * m_h2csc_rdo_eta_vs_phi_cluswidth_signal
Definition: CscRdoValAlg.h:116
CscRdoValAlg::m_h2csc_rdo_etacluscount
TH2F * m_h2csc_rdo_etacluscount
Definition: CscRdoValAlg.h:101
CscRawData.h
CscRdoValAlg::m_h2csc_rdo_eta_vs_phi_cluscount_signal
TH2F * m_h2csc_rdo_eta_vs_phi_cluscount_signal
Definition: CscRdoValAlg.h:112
CscRawData
Class to hold the electronic output for a single CSC readout channel: n sampling ADC data + the addre...
Definition: CscRawData.h:21
compileRPVLLRates.nf
nf
Definition: compileRPVLLRates.py:89
h
CscRdoValAlg::m_regHExpert
std::vector< TH1 * > m_regHExpert
Definition: CscRdoValAlg.h:119
CscRdoValAlg::m_h2csc_rdo_phicluswidth_signal_EA
TH2F * m_h2csc_rdo_phicluswidth_signal_EA
Definition: CscRdoValAlg.h:78
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CscRdoValAlg::m_h2csc_rdo_eta_vs_phi_cluscount
TH2F * m_h2csc_rdo_eta_vs_phi_cluscount
Definition: CscRdoValAlg.h:111
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TH1
Definition: rootspy.cxx:268
CscRdoValAlg::m_cscRdoDecoderTool
ToolHandle< Muon::ICSC_RDO_Decoder > m_cscRdoDecoderTool
Definition: CscRdoValAlg.h:50
CscRdoValAlg::m_h2csc_rdo_hitmap_signal
TH2F * m_h2csc_rdo_hitmap_signal
Definition: CscRdoValAlg.h:55
CscRdoValAlg::m_h2csc_rdo_phicluswidth
TH2F * m_h2csc_rdo_phicluswidth
Definition: CscRdoValAlg.h:74
CscRdoValAlg::m_h2csc_rdo_phicluscount_noise
TH2F * m_h2csc_rdo_phicluscount_noise
Definition: CscRdoValAlg.h:99
CscRdoValAlg::m_h2csc_rdo_etacluscount_noise
TH2F * m_h2csc_rdo_etacluscount_noise
Definition: CscRdoValAlg.h:103
python.SystemOfUnits.ns
int ns
Definition: SystemOfUnits.py:130
CscRdoValAlg::m_h2csc_rdo_hitmap_signal_EA
TH2F * m_h2csc_rdo_hitmap_signal_EA
Definition: CscRdoValAlg.h:62
CscRdoValAlg::m_h2csc_rdo_hitmap_norm_signal_EC
TH2F * m_h2csc_rdo_hitmap_norm_signal_EC
Definition: CscRdoValAlg.h:72
CscRdoValAlg::m_h1csc_rdo_hitmap_signal_EC_count
TH1F * m_h1csc_rdo_hitmap_signal_EC_count
Definition: CscRdoValAlg.h:69
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
CscRdoValAlg::initialize
StatusCode initialize()
Definition: CscRdoValAlg.cxx:99
CscRdoValAlg::m_h2csc_rdo_hitmap_norm_signal_EA
TH2F * m_h2csc_rdo_hitmap_norm_signal_EA
Definition: CscRdoValAlg.h:66
CscRdoValAlg::m_h1csc_rdo_hitmap_signal_EA_count
TH1F * m_h1csc_rdo_hitmap_signal_EA_count
Definition: CscRdoValAlg.h:63
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:127
CscRdoValAlg::m_cscrdo_oviewEA
MonGroup * m_cscrdo_oviewEA
Definition: CscRdoValAlg.h:108
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
python.SystemOfUnits.km
int km
Definition: SystemOfUnits.py:95
CscRdoValAlg::m_h2csc_rdo_eta_vs_phi_cluscount_noise
TH2F * m_h2csc_rdo_eta_vs_phi_cluscount_noise
Definition: CscRdoValAlg.h:113
CscRdoValAlg::m_regHOviewEC
std::vector< TH1 * > m_regHOviewEC
Definition: CscRdoValAlg.h:121
CscRdoValAlg::checkHists
StatusCode checkHists(bool fromFinalise)
This implementation does nothing; equivalent functionality may be provided by procHists(....
Definition: CscRdoValAlg.cxx:721
CscRdoValAlg::m_h1csc_rdo_phicluswidth_signal_EC_count
TH1F * m_h1csc_rdo_phicluswidth_signal_EC_count
Definition: CscRdoValAlg.h:83
CscRdoValAlg::m_cscRdoKey
SG::ReadHandleKey< CscRawDataContainer > m_cscRdoKey
Definition: CscRdoValAlg.h:45
Generated on Tue Jul 2 2024 21:13:15 for ATLAS Offline Software by   doxygen 1.8.18