ATLAS Offline Software
MonitoringFile_RPCPostProcess.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3  */
4 
5 //*************************************************
6 // Class for the RPC merge histogram and fill the COOL DB
7 // author Michele Bianco michele.bianco@le.infn.it, Gabriele Chiodini gabriele.chiodini@le.infn.it
8 // and Angelo Guida angelo.guida@le.infn.it
9 // 08/April/2009
10 //************************************************
11 
12 #include "DataQualityUtils/MonitoringFile.h"
13 #include "DataQualityUtils/CoolRpc.h"
14 
15 #include <iostream>
16 #include <iomanip>
17 #include <fstream>
18 #include <cmath>
19 #include <cstdlib>
20 
21 #include "TClass.h"
22 #include "TKey.h"
23 
24 namespace {
25  void
26  writeIfValid(TH1F* pH) {
27  if (pH) pH->Write("", TObject::kOverwrite);
28  }
29 
30  void
31  fillIfValid(TH1F* pH, float val) {
32  if (pH) pH->Fill(val);
33  return;
34  }
35 
36  float
37  getBinContentIfValid(TH1F* pH, int binIdx) {
38  float result = -9999;
39 
40  ;
41 
42  if (pH) result = pH->GetBinContent(binIdx);
43  return result;
44  }
45 
46  float
47  getBinErrorIfValid(TH1F* pH, int binIdx) {
48  float result = -1;
49 
50  ;
51 
52  if (pH) result = pH->GetBinError(binIdx);
53  return result;
54  }
55 }
56 
57 namespace dqutils {
58  void
59  MonitoringFile::RPCPostProcess(const std::string& inFilename, bool /* isIncremental */) {
60  // std::cout << "Running RPC post processing \n" ;
61 
62  bool applyEffThreshold = true;
63  bool EffThreshold = false;
64  bool printout = true;
65  float Minimum_efficiency = 0.5;
66 
67 
68 
69  TFile* f = TFile::Open(inFilename.c_str(), "UPDATE");
70 
71  if (f == 0) {
72  std::cerr << "MonitoringFile::RPCPostProcess(): "
73  << "Input file not opened \n";
74  return;
75  }
76  if (f->GetSize() < 1000.) {
77  std::cerr << "MonitoringFile::RPCPostProcess(): "
78  << "Input file empty \n";
79  return;
80  }
81  CoolRpc coolrpc;
82 
83  // get run directory name
84  std::string run_dir;
85  TIter next_run(f->GetListOfKeys());
86  TKey* key_run(0);
87  while ((key_run = dynamic_cast<TKey*>(next_run())) != 0) {
88  TObject* obj_run = key_run->ReadObj();
89  TDirectory* tdir_run = dynamic_cast<TDirectory*>(obj_run);
90  if (tdir_run != 0) {
91  std::string tdir_run_name(tdir_run->GetName());
92  if (tdir_run_name.find("run") != std::string::npos) {
93  run_dir = std::move(tdir_run_name);
94 
95  int run_number;
96  run_number = atoi((run_dir.substr(4, run_dir.size() - 4)).c_str());
97  std::cout << "run_number rpc monitoring " << run_number << std::endl;
98 
99  std::string pathRawMon = run_dir + "/Muon/MuonRawDataMonitoring/RPC/";
100  //std::string pathTrackMon = run_dir + "/Muon/MuonTrackMonitoring/NoTrigger/RPCStandAloneTrackMon/" ;
101  std::string pathTrackMon = run_dir + "/Muon/MuonRawDataMonitoring/RPCStandAloneTrackMon/";
102 
103  std::string dir_ov_raw = pathRawMon + "Overview/";
104  std::string dir_sum_raw = pathRawMon + "Summary/";
105  std::string dir_dqmf_raw = pathRawMon + "Dqmf/";
106 
107  std::string dir_sideA_track = pathTrackMon + "RPCBA/";
108  std::string dir_sideC_track = pathTrackMon + "RPCBC/";
109  std::string dir_glob_track = pathTrackMon + "GLOBAL/";
110  std::string dir_sum_track = pathTrackMon + "Summary/";
111  std::string dir_dqmf_track = pathTrackMon + "Dqmf/";
112  std::string dir_trigger_track = pathTrackMon + "TriggerEfficiency/";
113 
114  double n_hit_f, n_tr_p, panel_eff, panel_err_eff;
115  double nEta, nPhi, nEtaPhi, gapEff = 0.0, gapErrEff = 0.0;
116  double res_mean, res2_mean, res_RMS;
117  double panel_occ;
118  double panelCS, panelCS2, panelCS_entries, panelCS_mean, panelCS2_mean, panelCS_RMS;
119  double Time_mean, Time2_mean, Time_RMS;
120  double noiseCorr, noiseCorrErr;
121  double noiseTot, noiseTotErr;
122  double noiseErrNorm;
123 
124  // trigger efficiency
125  std::string METracks_name = dir_trigger_track + "hMEtracks";
126  std::string MuctpiThr0_name = dir_trigger_track + "hRPCMuctpiThr0";
127  std::string MuctpiThr1_name = dir_trigger_track + "hRPCMuctpiThr1";
128  std::string MuctpiThr2_name = dir_trigger_track + "hRPCMuctpiThr2";
129  std::string MuctpiThr3_name = dir_trigger_track + "hRPCMuctpiThr3";
130  std::string MuctpiThr4_name = dir_trigger_track + "hRPCMuctpiThr4";
131  std::string MuctpiThr5_name = dir_trigger_track + "hRPCMuctpiThr5";
132  std::string PadThr0_name = dir_trigger_track + "hRPCPadThr0";
133  std::string PadThr1_name = dir_trigger_track + "hRPCPadThr1";
134  std::string PadThr2_name = dir_trigger_track + "hRPCPadThr2";
135  std::string PadThr3_name = dir_trigger_track + "hRPCPadThr3";
136  std::string PadThr4_name = dir_trigger_track + "hRPCPadThr4";
137  std::string PadThr5_name = dir_trigger_track + "hRPCPadThr5";
138  std::string PhiEtaCoinThr0_name = dir_trigger_track + "hRPCPhiEtaCoinThr0";
139  std::string PhiEtaCoinThr1_name = dir_trigger_track + "hRPCPhiEtaCoinThr1";
140  std::string PhiEtaCoinThr2_name = dir_trigger_track + "hRPCPhiEtaCoinThr2";
141  std::string PhiEtaCoinThr3_name = dir_trigger_track + "hRPCPhiEtaCoinThr3";
142  std::string PhiEtaCoinThr4_name = dir_trigger_track + "hRPCPhiEtaCoinThr4";
143  std::string PhiEtaCoinThr5_name = dir_trigger_track + "hRPCPhiEtaCoinThr5";
144 
145  std::string MuctpiThr_eff0_name = dir_trigger_track + "hRPCMuctpiThr_eff0";
146  std::string MuctpiThr_eff1_name = dir_trigger_track + "hRPCMuctpiThr_eff1";
147  std::string MuctpiThr_eff2_name = dir_trigger_track + "hRPCMuctpiThr_eff2";
148  std::string MuctpiThr_eff3_name = dir_trigger_track + "hRPCMuctpiThr_eff3";
149  std::string MuctpiThr_eff4_name = dir_trigger_track + "hRPCMuctpiThr_eff4";
150  std::string MuctpiThr_eff5_name = dir_trigger_track + "hRPCMuctpiThr_eff5";
151  std::string PadThr_eff0_name = dir_trigger_track + "hRPCPadThr_eff0";
152  std::string PadThr_eff1_name = dir_trigger_track + "hRPCPadThr_eff1";
153  std::string PadThr_eff2_name = dir_trigger_track + "hRPCPadThr_eff2";
154  std::string PadThr_eff3_name = dir_trigger_track + "hRPCPadThr_eff3";
155  std::string PadThr_eff4_name = dir_trigger_track + "hRPCPadThr_eff4";
156  std::string PadThr_eff5_name = dir_trigger_track + "hRPCPadThr_eff5";
157  std::string PhiEtaCoinThr_eff0_name = dir_trigger_track + "hRPCPhiEtaCoinThr_eff0";
158  std::string PhiEtaCoinThr_eff1_name = dir_trigger_track + "hRPCPhiEtaCoinThr_eff1";
159  std::string PhiEtaCoinThr_eff2_name = dir_trigger_track + "hRPCPhiEtaCoinThr_eff2";
160  std::string PhiEtaCoinThr_eff3_name = dir_trigger_track + "hRPCPhiEtaCoinThr_eff3";
161  std::string PhiEtaCoinThr_eff4_name = dir_trigger_track + "hRPCPhiEtaCoinThr_eff4";
162  std::string PhiEtaCoinThr_eff5_name = dir_trigger_track + "hRPCPhiEtaCoinThr_eff5";
163 
164 
165  if (RPCCheckHistogram(f,
166  METracks_name.c_str()) &&
167  RPCCheckHistogram(f, MuctpiThr0_name.c_str()) && RPCCheckHistogram(f, MuctpiThr_eff0_name.c_str())) {
168  TH1I* hist_METracks = (TH1I*) (f->Get(METracks_name.c_str()));
169  TH1I* hist_MuctpiThr0 = (TH1I*) (f->Get(MuctpiThr0_name.c_str()));
170  TH1I* hist_MuctpiThr1 = (TH1I*) (f->Get(MuctpiThr1_name.c_str()));
171  TH1I* hist_MuctpiThr2 = (TH1I*) (f->Get(MuctpiThr2_name.c_str()));
172  TH1I* hist_MuctpiThr3 = (TH1I*) (f->Get(MuctpiThr3_name.c_str()));
173  TH1I* hist_MuctpiThr4 = (TH1I*) (f->Get(MuctpiThr4_name.c_str()));
174  TH1I* hist_MuctpiThr5 = (TH1I*) (f->Get(MuctpiThr5_name.c_str()));
175  TH1I* hist_PadThr0 = (TH1I*) (f->Get(PadThr0_name.c_str()));
176  TH1I* hist_PadThr1 = (TH1I*) (f->Get(PadThr1_name.c_str()));
177  TH1I* hist_PadThr2 = (TH1I*) (f->Get(PadThr2_name.c_str()));
178  TH1I* hist_PadThr3 = (TH1I*) (f->Get(PadThr3_name.c_str()));
179  TH1I* hist_PadThr4 = (TH1I*) (f->Get(PadThr4_name.c_str()));
180  TH1I* hist_PadThr5 = (TH1I*) (f->Get(PadThr5_name.c_str()));
181  TH1I* hist_PhiEtaCoinThr0 = (TH1I*) (f->Get(PhiEtaCoinThr0_name.c_str()));
182  TH1I* hist_PhiEtaCoinThr1 = (TH1I*) (f->Get(PhiEtaCoinThr1_name.c_str()));
183  TH1I* hist_PhiEtaCoinThr2 = (TH1I*) (f->Get(PhiEtaCoinThr2_name.c_str()));
184  TH1I* hist_PhiEtaCoinThr3 = (TH1I*) (f->Get(PhiEtaCoinThr3_name.c_str()));
185  TH1I* hist_PhiEtaCoinThr4 = (TH1I*) (f->Get(PhiEtaCoinThr4_name.c_str()));
186  TH1I* hist_PhiEtaCoinThr5 = (TH1I*) (f->Get(PhiEtaCoinThr5_name.c_str()));
187  TH1I* hist_MuctpiThr_eff0 = (TH1I*) (f->Get(MuctpiThr_eff0_name.c_str()));
188  TH1I* hist_MuctpiThr_eff1 = (TH1I*) (f->Get(MuctpiThr_eff1_name.c_str()));
189  TH1I* hist_MuctpiThr_eff2 = (TH1I*) (f->Get(MuctpiThr_eff2_name.c_str()));
190  TH1I* hist_MuctpiThr_eff3 = (TH1I*) (f->Get(MuctpiThr_eff3_name.c_str()));
191  TH1I* hist_MuctpiThr_eff4 = (TH1I*) (f->Get(MuctpiThr_eff4_name.c_str()));
192  TH1I* hist_MuctpiThr_eff5 = (TH1I*) (f->Get(MuctpiThr_eff5_name.c_str()));
193  TH1I* hist_PadThr_eff0 = (TH1I*) (f->Get(PadThr_eff0_name.c_str()));
194  TH1I* hist_PadThr_eff1 = (TH1I*) (f->Get(PadThr_eff1_name.c_str()));
195  TH1I* hist_PadThr_eff2 = (TH1I*) (f->Get(PadThr_eff2_name.c_str()));
196  TH1I* hist_PadThr_eff3 = (TH1I*) (f->Get(PadThr_eff3_name.c_str()));
197  TH1I* hist_PadThr_eff4 = (TH1I*) (f->Get(PadThr_eff4_name.c_str()));
198  TH1I* hist_PadThr_eff5 = (TH1I*) (f->Get(PadThr_eff5_name.c_str()));
199  TH1I* hist_PhiEtaCoinThr_eff0 = (TH1I*) (f->Get(PhiEtaCoinThr_eff0_name.c_str()));
200  TH1I* hist_PhiEtaCoinThr_eff1 = (TH1I*) (f->Get(PhiEtaCoinThr_eff1_name.c_str()));
201  TH1I* hist_PhiEtaCoinThr_eff2 = (TH1I*) (f->Get(PhiEtaCoinThr_eff2_name.c_str()));
202  TH1I* hist_PhiEtaCoinThr_eff3 = (TH1I*) (f->Get(PhiEtaCoinThr_eff3_name.c_str()));
203  TH1I* hist_PhiEtaCoinThr_eff4 = (TH1I*) (f->Get(PhiEtaCoinThr_eff4_name.c_str()));
204  TH1I* hist_PhiEtaCoinThr_eff5 = (TH1I*) (f->Get(PhiEtaCoinThr_eff5_name.c_str()));
205 
206  int nb = hist_METracks->GetNbinsX();
207  double Ly_eff, Ly_effErr;
208  auto calculateErr = [](float hitOn, float trPrj) -> double {
209  return std::sqrt(std::abs(hitOn) / trPrj) *
210  std::sqrt(1. - std::abs(hitOn) / trPrj) /
211  std::sqrt(trPrj);
212  };
213  for (int ib = 0; ib != nb; ib++) {
214  float n_Ly_hitOn = hist_MuctpiThr0->GetBinContent(ib + 1);
215  float n_Ly_TrPrj = hist_METracks->GetBinContent(ib + 1);
216 
217 
218  if (n_Ly_TrPrj > 0) {
219  //MuctpiThr0
220  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
221 
222  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
223  hist_MuctpiThr_eff0->SetBinContent(ib + 1, Ly_eff);
224  hist_MuctpiThr_eff0->SetBinError(ib + 1, Ly_effErr);
225 
226  //MuctpiThr1
227  n_Ly_hitOn = hist_MuctpiThr1->GetBinContent(ib + 1);
228  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
229  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
230  hist_MuctpiThr_eff1->SetBinContent(ib + 1, Ly_eff);
231  hist_MuctpiThr_eff1->SetBinError(ib + 1, Ly_effErr);
232  //MuctpiThr2
233  n_Ly_hitOn = hist_MuctpiThr2->GetBinContent(ib + 1);
234  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
235 
236  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
237  hist_MuctpiThr_eff2->SetBinContent(ib + 1, Ly_eff);
238  hist_MuctpiThr_eff2->SetBinError(ib + 1, Ly_effErr);
239  //MuctpiThr3
240  n_Ly_hitOn = hist_MuctpiThr3->GetBinContent(ib + 1);
241  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
242 
243  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
244  hist_MuctpiThr_eff3->SetBinContent(ib + 1, Ly_eff);
245  hist_MuctpiThr_eff3->SetBinError(ib + 1, Ly_effErr);
246  //MuctpiThr4
247  n_Ly_hitOn = hist_MuctpiThr4->GetBinContent(ib + 1);
248  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
249 
250  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
251  hist_MuctpiThr_eff4->SetBinContent(ib + 1, Ly_eff);
252  hist_MuctpiThr_eff4->SetBinError(ib + 1, Ly_effErr);
253  //MuctpiThr5
254  n_Ly_hitOn = hist_MuctpiThr5->GetBinContent(ib + 1);
255  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
256 
257  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
258  hist_MuctpiThr_eff5->SetBinContent(ib + 1, Ly_eff);
259  hist_MuctpiThr_eff5->SetBinError(ib + 1, Ly_effErr);
260  //PadThr0
261  n_Ly_hitOn = hist_PadThr0->GetBinContent(ib + 1);
262  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
263 
264  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
265  hist_PadThr_eff0->SetBinContent(ib + 1, Ly_eff);
266  hist_PadThr_eff0->SetBinError(ib + 1, Ly_effErr);
267  //PadThr1
268  n_Ly_hitOn = hist_PadThr1->GetBinContent(ib + 1);
269  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
270 
271  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
272  hist_PadThr_eff1->SetBinContent(ib + 1, Ly_eff);
273  hist_PadThr_eff1->SetBinError(ib + 1, Ly_effErr);
274  //PadThr2
275  n_Ly_hitOn = hist_PadThr2->GetBinContent(ib + 1);
276  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
277 
278  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
279  hist_PadThr_eff2->SetBinContent(ib + 1, Ly_eff);
280  hist_PadThr_eff2->SetBinError(ib + 1, Ly_effErr);
281  //PadThr3
282  n_Ly_hitOn = hist_PadThr3->GetBinContent(ib + 1);
283  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
284 
285  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
286  hist_PadThr_eff3->SetBinContent(ib + 1, Ly_eff);
287  hist_PadThr_eff3->SetBinError(ib + 1, Ly_effErr);
288  //PadThr4
289  n_Ly_hitOn = hist_PadThr4->GetBinContent(ib + 1);
290  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
291 
292  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
293  hist_PadThr_eff4->SetBinContent(ib + 1, Ly_eff);
294  hist_PadThr_eff4->SetBinError(ib + 1, Ly_effErr);
295  //PadThr5
296  n_Ly_hitOn = hist_PadThr5->GetBinContent(ib + 1);
297  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
298 
299  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
300  hist_PadThr_eff5->SetBinContent(ib + 1, Ly_eff);
301  hist_PadThr_eff5->SetBinError(ib + 1, Ly_effErr);
302  //PhiEtaCoinThr0
303  n_Ly_hitOn = hist_PhiEtaCoinThr0->GetBinContent(ib + 1);
304  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
305 
306  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
307  hist_PhiEtaCoinThr_eff0->SetBinContent(ib + 1, Ly_eff);
308  hist_PhiEtaCoinThr_eff0->SetBinError(ib + 1, Ly_effErr);
309  //PhiEtaCoinThr1
310  n_Ly_hitOn = hist_PhiEtaCoinThr1->GetBinContent(ib + 1);
311  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
312 
313  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
314  hist_PhiEtaCoinThr_eff1->SetBinContent(ib + 1, Ly_eff);
315  hist_PhiEtaCoinThr_eff1->SetBinError(ib + 1, Ly_effErr);
316  //PhiEtaCoinThr2
317  n_Ly_hitOn = hist_PhiEtaCoinThr2->GetBinContent(ib + 1);
318  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
319 
320  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
321  hist_PhiEtaCoinThr_eff2->SetBinContent(ib + 1, Ly_eff);
322  hist_PhiEtaCoinThr_eff2->SetBinError(ib + 1, Ly_effErr);
323  //PhiEtaCoinThr3
324  n_Ly_hitOn = hist_PhiEtaCoinThr3->GetBinContent(ib + 1);
325  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
326 
327  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
328  hist_PhiEtaCoinThr_eff3->SetBinContent(ib + 1, Ly_eff);
329  hist_PhiEtaCoinThr_eff3->SetBinError(ib + 1, Ly_effErr);
330  //PhiEtaCoinThr4
331  n_Ly_hitOn = hist_PhiEtaCoinThr4->GetBinContent(ib + 1);
332  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
333 
334  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
335  hist_PhiEtaCoinThr_eff4->SetBinContent(ib + 1, Ly_eff);
336  hist_PhiEtaCoinThr_eff4->SetBinError(ib + 1, Ly_effErr);
337  //PhiEtaCoinThr5
338  n_Ly_hitOn = hist_PhiEtaCoinThr5->GetBinContent(ib + 1);
339  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
340 
341  Ly_effErr = calculateErr(n_Ly_hitOn, n_Ly_TrPrj);
342  hist_PhiEtaCoinThr_eff5->SetBinContent(ib + 1, Ly_eff);
343  hist_PhiEtaCoinThr_eff5->SetBinError(ib + 1, Ly_effErr);
344  }
345  }
346 
347  // write out histogram
348  TDirectory* dir = f->GetDirectory(dir_trigger_track.c_str());
349  if (dir != 0) {
350  dir->cd();
351  hist_MuctpiThr_eff0->Write("", TObject::kOverwrite);
352  hist_MuctpiThr_eff1->Write("", TObject::kOverwrite);
353  hist_MuctpiThr_eff2->Write("", TObject::kOverwrite);
354  hist_MuctpiThr_eff3->Write("", TObject::kOverwrite);
355  hist_MuctpiThr_eff4->Write("", TObject::kOverwrite);
356  hist_MuctpiThr_eff5->Write("", TObject::kOverwrite);
357  hist_PadThr_eff0->Write("", TObject::kOverwrite);
358  hist_PadThr_eff1->Write("", TObject::kOverwrite);
359  hist_PadThr_eff2->Write("", TObject::kOverwrite);
360  hist_PadThr_eff3->Write("", TObject::kOverwrite);
361  hist_PadThr_eff4->Write("", TObject::kOverwrite);
362  hist_PadThr_eff5->Write("", TObject::kOverwrite);
363  hist_PhiEtaCoinThr_eff0->Write("", TObject::kOverwrite);
364  hist_PhiEtaCoinThr_eff1->Write("", TObject::kOverwrite);
365  hist_PhiEtaCoinThr_eff2->Write("", TObject::kOverwrite);
366  hist_PhiEtaCoinThr_eff3->Write("", TObject::kOverwrite);
367  hist_PhiEtaCoinThr_eff4->Write("", TObject::kOverwrite);
368  hist_PhiEtaCoinThr_eff5->Write("", TObject::kOverwrite);
369  }
370  }
371 
372 
373  // layer efficiency
374  std::string LyHit_name, LyPrj_name, LyEff_name;
375  LyHit_name = dir_glob_track + "Hit_on_Track_Layer";
376  LyPrj_name = dir_glob_track + "Track_Projected_on_Layer";
377  LyEff_name = dir_glob_track + "Layer_Efficiency";
378 
379  if (RPCCheckHistogram(f,
380  LyHit_name.c_str()) &&
381  RPCCheckHistogram(f, LyPrj_name.c_str()) && RPCCheckHistogram(f, LyEff_name.c_str())) {
382  TH1I* hist_LyHit = (TH1I*) (f->Get(LyHit_name.c_str()));
383  TH1I* hist_LyPrj = (TH1I*) (f->Get(LyPrj_name.c_str()));
384  TH1F* hist_LyEff = (TH1F*) (f->Get(LyEff_name.c_str()));
385 
386  int nb = hist_LyEff->GetNbinsX();
387  double Ly_eff, Ly_effErr;
388  for (int ib = 0; ib != nb; ib++) {
389  float n_Ly_hitOn = hist_LyHit->GetBinContent(ib + 1);
390  float n_Ly_TrPrj = hist_LyPrj->GetBinContent(ib + 1);
391 
392  if (n_Ly_TrPrj > 0) {
393  Ly_eff = float(n_Ly_hitOn) / float(n_Ly_TrPrj);
394 
395  Ly_effErr = sqrt(fabs(n_Ly_hitOn) / n_Ly_TrPrj) *
396  sqrt(1. - fabs(n_Ly_hitOn) / n_Ly_TrPrj) /
397  sqrt(n_Ly_TrPrj);
398  hist_LyEff->SetBinContent(ib + 1, Ly_eff);
399  hist_LyEff->SetBinError(ib + 1, Ly_effErr);
400  }
401  }
402 
403  // write out histogram
404  TDirectory* dir = f->GetDirectory(dir_glob_track.c_str());
405  if (dir != 0) {
406  dir->cd();
407  //hist_LyEff->Write();
408  hist_LyEff->Write("", TObject::kOverwrite);
409  }
410  }
411 
412 
413  // layer efficiency Side A
414  std::string LyHit_SideA_name, LyPrj_SideA_name, LyEff_SideA_name;
415  LyHit_SideA_name = dir_sideA_track + "Layer_HitOnTrack_sideA";
416  LyPrj_SideA_name = dir_sideA_track + "Layer_TrackProj_sideA";
417  LyEff_SideA_name = dir_sideA_track + "Layer_Efficiency_sideA";
418 
419  if (RPCCheckHistogram(f,
420  LyHit_SideA_name.c_str()) &&
421  RPCCheckHistogram(f, LyPrj_SideA_name.c_str()) && RPCCheckHistogram(f, LyEff_SideA_name.c_str())) {
422  TH1I* hist_LyHit_SideA = (TH1I*) (f->Get(LyHit_SideA_name.c_str()));
423  TH1I* hist_LyPrj_SideA = (TH1I*) (f->Get(LyPrj_SideA_name.c_str()));
424  TH1F* hist_LyEff_SideA = (TH1F*) (f->Get(LyEff_SideA_name.c_str()));
425 
426  int nb = hist_LyEff_SideA->GetNbinsX();
427  double Ly_eff_SideA, Ly_effErr_SideA;
428  for (int ib = 0; ib != nb; ib++) {
429  float n_Ly_hitOn_SideA = hist_LyHit_SideA->GetBinContent(ib + 1);
430  float n_Ly_TrPrj_SideA = hist_LyPrj_SideA->GetBinContent(ib + 1);
431 
432  if (n_Ly_TrPrj_SideA > 0) {
433  Ly_eff_SideA = float(n_Ly_hitOn_SideA) / float(n_Ly_TrPrj_SideA);
434 
435  Ly_effErr_SideA = sqrt(fabs(n_Ly_hitOn_SideA) / n_Ly_TrPrj_SideA) *
436  sqrt(1. - fabs(n_Ly_hitOn_SideA) / n_Ly_TrPrj_SideA) /
437  sqrt(n_Ly_TrPrj_SideA);
438  hist_LyEff_SideA->SetBinContent(ib + 1, Ly_eff_SideA);
439  hist_LyEff_SideA->SetBinError(ib + 1, Ly_effErr_SideA);
440  }
441  }
442 
443  // write out histogram
444  TDirectory* dir = f->GetDirectory(dir_sideA_track.c_str());
445  if (dir != 0) {
446  dir->cd();
447  //hist_LyEff->Write();
448  hist_LyEff_SideA->Write("", TObject::kOverwrite);
449  }
450  }
451 
452  // layer efficiency Side C
453  std::string LyHit_SideC_name, LyPrj_SideC_name, LyEff_SideC_name;
454  LyHit_SideC_name = dir_sideC_track + "Layer_HitOnTrack_sideC";
455  LyPrj_SideC_name = dir_sideC_track + "Layer_TrackProj_sideC";
456  LyEff_SideC_name = dir_sideC_track + "Layer_Efficiency_sideC";
457 
458  if (RPCCheckHistogram(f,
459  LyHit_SideC_name.c_str()) &&
460  RPCCheckHistogram(f, LyPrj_SideC_name.c_str()) && RPCCheckHistogram(f, LyEff_SideC_name.c_str())) {
461  TH1I* hist_LyHit_SideC = (TH1I*) (f->Get(LyHit_SideC_name.c_str()));
462  TH1I* hist_LyPrj_SideC = (TH1I*) (f->Get(LyPrj_SideC_name.c_str()));
463  TH1F* hist_LyEff_SideC = (TH1F*) (f->Get(LyEff_SideC_name.c_str()));
464 
465  int nb = hist_LyEff_SideC->GetNbinsX();
466  double Ly_eff_SideC, Ly_effErr_SideC;
467  for (int ib = 0; ib != nb; ib++) {
468  float n_Ly_hitOn_SideC = hist_LyHit_SideC->GetBinContent(ib + 1);
469  float n_Ly_TrPrj_SideC = hist_LyPrj_SideC->GetBinContent(ib + 1);
470 
471  if (n_Ly_TrPrj_SideC > 0) {
472  Ly_eff_SideC = float(n_Ly_hitOn_SideC) / float(n_Ly_TrPrj_SideC);
473 
474  Ly_effErr_SideC = sqrt(fabs(n_Ly_hitOn_SideC) / n_Ly_TrPrj_SideC) *
475  sqrt(1. - fabs(n_Ly_hitOn_SideC) / n_Ly_TrPrj_SideC) /
476  sqrt(n_Ly_TrPrj_SideC);
477  hist_LyEff_SideC->SetBinContent(ib + 1, Ly_eff_SideC);
478  hist_LyEff_SideC->SetBinError(ib + 1, Ly_effErr_SideC);
479  }
480  }
481  // write out histogram
482  TDirectory* dir = f->GetDirectory(dir_sideC_track.c_str());
483  if (dir != 0) {
484  dir->cd();
485  //hist_LyEff->Write();
486  hist_LyEff_SideC->Write("", TObject::kOverwrite);
487  }
488  }
489 
490 
491 
492  int rpc_eventstotal = 0;
493  if (RPCCheckHistogram(f, (dir_ov_raw + "Number_of_RPC_hits_per_event").c_str())) {
494  TH1I* rpc_hits = (TH1I*) (f->Get((dir_ov_raw + "Number_of_RPC_hits_per_event").c_str()));
495  rpc_eventstotal = int(rpc_hits->GetEntries());
496  }
497 
498 
499  // distribution plot all atlas
500  std::string AverageEff_C_name = dir_sideC_track + "Efficiency_Distribution_sideC";
501  std::string AverageEff_A_name = dir_sideA_track + "Efficiency_Distribution_sideA";
502  std::string AverageGapEff_C_name = dir_sideC_track + "GapEfficiency_Distribution_sideC";
503  std::string AverageGapEff_A_name = dir_sideA_track + "GapEfficiency_Distribution_sideA";
504  std::string AverageNoiseCorr_C_name = dir_sideC_track + "NoiseCorr_Distribution_sideC";
505  std::string AverageNoiseCorr_A_name = dir_sideA_track + "NoiseCorr_Distribution_sideA";
506  std::string AverageNoiseTot_C_name = dir_sideC_track + "NoiseTot_Distribution_sideC";
507  std::string AverageNoiseTot_A_name = dir_sideA_track + "NoiseTot_Distribution_sideA";
508  std::string AverageCS_C_name = dir_sideC_track + "CS_Distribution_sideC";
509  std::string AverageCS_A_name = dir_sideA_track + "CS_Distribution_sideA";
510  std::string AverageRes_CS1_C_name = dir_sideC_track + "Res_CS1_Distribution_sideC";
511  std::string AverageRes_CS1_A_name = dir_sideA_track + "Res_CS1_Distribution_sideA";
512  std::string AverageRes_CS2_C_name = dir_sideC_track + "Res_CS2_Distribution_sideC";
513  std::string AverageRes_CS2_A_name = dir_sideA_track + "Res_CS2_Distribution_sideA";
514  std::string AverageRes_CSmore2_C_name = dir_sideC_track + "Res_CSmore2_Distribution_sideC";
515  std::string AverageRes_CSmore2_A_name = dir_sideA_track + "Res_CSmore2_Distribution_sideA";
516  std::string AverageRes_CS1rms_C_name = dir_sideC_track + "Res_CS1rms_Distribution_sideC";
517  std::string AverageRes_CS1rms_A_name = dir_sideA_track + "Res_CS1rms_Distribution_sideA";
518  std::string AverageRes_CS2rms_C_name = dir_sideC_track + "Res_CS2rms_Distribution_sideC";
519  std::string AverageRes_CS2rms_A_name = dir_sideA_track + "Res_CS2rms_Distribution_sideA";
520  std::string AverageRes_CSmore2rms_C_name = dir_sideC_track + "Res_CSmore2rms_Distribution_sideC";
521  std::string AverageRes_CSmore2rms_A_name = dir_sideA_track + "Res_CSmore2rms_Distribution_sideA";
522  std::string AverageOccupancy_C_name = dir_sideC_track + "Occupancy_Distribution_sideC";
523  std::string AverageOccupancy_A_name = dir_sideA_track + "Occupancy_Distribution_sideA";
524  std::string AverageTime_C_name = dir_sideC_track + "Time_Distribution_sideC";
525  std::string AverageTime_A_name = dir_sideA_track + "Time_Distribution_sideA";
526 
527 
528  auto initialiseHisto = [f](const std::string& name) -> TH1F* {
529  TH1F* result = (TH1F*) (f->Get(name.c_str()));
530 
531  return result;
532  };
533 
534  TH1F* h_AverageEff_C = initialiseHisto(AverageEff_C_name);
535  TH1F* h_AverageEff_A = initialiseHisto(AverageEff_A_name);
536  TH1F* h_AverageGapEff_C = initialiseHisto(AverageGapEff_C_name);
537  TH1F* h_AverageGapEff_A = initialiseHisto(AverageGapEff_A_name);
538  TH1F* h_AverageNoiseCorr_C = initialiseHisto(AverageNoiseCorr_C_name);
539  TH1F* h_AverageNoiseCorr_A = initialiseHisto(AverageNoiseCorr_A_name);
540  TH1F* h_AverageNoiseTot_C = initialiseHisto(AverageNoiseTot_C_name);
541  TH1F* h_AverageNoiseTot_A = initialiseHisto(AverageNoiseTot_A_name);
542  TH1F* h_AverageCS_C = initialiseHisto(AverageCS_C_name);
543  TH1F* h_AverageCS_A = initialiseHisto(AverageCS_A_name);
544  TH1F* h_AverageRes_CS1_C = initialiseHisto(AverageRes_CS1_C_name);
545  TH1F* h_AverageRes_CS1_A = initialiseHisto(AverageRes_CS1_A_name);
546  TH1F* h_AverageRes_CS2_C = initialiseHisto(AverageRes_CS2_C_name);
547  TH1F* h_AverageRes_CS2_A = initialiseHisto(AverageRes_CS2_A_name);
548  TH1F* h_AverageRes_CSmore2_C = initialiseHisto(AverageRes_CSmore2_C_name);
549  TH1F* h_AverageRes_CSmore2_A = initialiseHisto(AverageRes_CSmore2_A_name);
550  TH1F* h_AverageRes_CS1rms_C = initialiseHisto(AverageRes_CS1rms_C_name);
551  TH1F* h_AverageRes_CS1rms_A = initialiseHisto(AverageRes_CS1rms_A_name);
552  TH1F* h_AverageRes_CS2rms_C = initialiseHisto(AverageRes_CS2rms_C_name);
553  TH1F* h_AverageRes_CS2rms_A = initialiseHisto(AverageRes_CS2rms_A_name);
554  TH1F* h_AverageRes_CSmore2rms_C = initialiseHisto(AverageRes_CSmore2rms_C_name);
555  TH1F* h_AverageRes_CSmore2rms_A = initialiseHisto(AverageRes_CSmore2rms_A_name);
556  TH1F* h_AverageOccupancy_C = initialiseHisto(AverageOccupancy_C_name);
557  TH1F* h_AverageOccupancy_A = initialiseHisto(AverageOccupancy_A_name);
558  TH1F* h_AverageTime_C = initialiseHisto(AverageTime_C_name);
559  TH1F* h_AverageTime_A = initialiseHisto(AverageTime_A_name);
560 
561  auto resetIfValid = [](TH1F* pH) -> void {
562  if (pH) pH->Reset();
563  return;
564  };
565 
566 
567 
568  resetIfValid(h_AverageEff_C);
569  resetIfValid(h_AverageEff_A);
570  resetIfValid(h_AverageGapEff_C);
571  resetIfValid(h_AverageGapEff_A);
572  resetIfValid(h_AverageNoiseCorr_C);
573  resetIfValid(h_AverageNoiseCorr_A);
574  resetIfValid(h_AverageNoiseTot_C);
575  resetIfValid(h_AverageNoiseTot_A);
576  resetIfValid(h_AverageCS_C);
577  resetIfValid(h_AverageCS_A);
578  resetIfValid(h_AverageRes_CS1_C);
579  resetIfValid(h_AverageRes_CS1_A);
580  resetIfValid(h_AverageRes_CS2_C);
581  resetIfValid(h_AverageRes_CS2_A);
582  resetIfValid(h_AverageRes_CSmore2_C);
583  resetIfValid(h_AverageRes_CSmore2_A);
584  resetIfValid(h_AverageRes_CS1rms_C);
585  resetIfValid(h_AverageRes_CS1rms_A);
586  resetIfValid(h_AverageRes_CS2rms_C);
587  resetIfValid(h_AverageRes_CS2rms_A);
588  resetIfValid(h_AverageRes_CSmore2rms_C);
589  resetIfValid(h_AverageRes_CSmore2rms_A);
590  resetIfValid(h_AverageOccupancy_C);
591  resetIfValid(h_AverageOccupancy_A);
592  resetIfValid(h_AverageTime_C);
593  resetIfValid(h_AverageTime_A);
594 
595  // summary plots
596  int countpanelindb = 0;
597  int countpaneleff0 = 0;
598  int countpaneltrack0 = 0;
599  for (int i_sec = 0; i_sec != 15 * 1 + 1; i_sec++) {
600  char sector_char[100];
601  std::string sector_name;
602  sprintf(sector_char, "_Sector%.2d", i_sec + 1); // sector number with 2 digits
603  sector_name = sector_char;
604  std::cout << " RPC sector_name processing " << sector_name << std::endl;
605 
606  std::string TrackProj_name = dir_sum_track + "SummaryTrackProj" + sector_name;
607  std::string HitOnTrack_name = dir_sum_track + "SummaryHitOnTrack" + sector_name;
608  std::string HitOnTrackCross_name = dir_sum_track + "SummaryHitOnTrack_withCrossStrip" + sector_name;
609  std::string Eff_name = dir_sum_track + "SummaryEfficiency" + sector_name;
610  std::string GapEff_name = dir_sum_track + "SummaryGapEfficiency" + sector_name;
611  std::string NoiseCorr_name = dir_sum_track + "SummaryNoiseCorr" + sector_name;
612  std::string NoiseCorr_s_name = dir_sum_track + "SummaryNoiseCorr_NotNorm" + sector_name;
613  std::string NoiseTot_name = dir_sum_track + "SummaryNoiseTot" + sector_name;
614  std::string NoiseTot_s_name = dir_sum_track + "SummaryNoiseTot_NotNorm" + sector_name;
615  std::string Res_CS1_name = dir_sum_track + "SummaryRes_CS1" + sector_name;
616  std::string Res_CS1_s_name = dir_sum_track + "SummaryRes_CS1_NotNorm" + sector_name;
617  std::string Res_CS1_square_name = dir_sum_track + "SummaryRes_CS1_square" + sector_name;
618  std::string Res_CS1_entries_name = dir_sum_track + "SummaryRes_CS1_entries" + sector_name;
619  std::string Res_CS2_name = dir_sum_track + "SummaryRes_CS2" + sector_name;
620  std::string Res_CS2_s_name = dir_sum_track + "SummaryRes_CS2_NotNorm" + sector_name;
621  std::string Res_CS2_square_name = dir_sum_track + "SummaryRes_CS2_square" + sector_name;
622  std::string Res_CS2_entries_name = dir_sum_track + "SummaryRes_CS2_entries" + sector_name;
623  std::string Res_CSmore2_name = dir_sum_track + "SummaryRes_CSmore2" + sector_name;
624  std::string Res_CSmore2_s_name = dir_sum_track + "SummaryRes_CSmore2_NotNorm" + sector_name;
625  std::string Res_CSmore2_square_name = dir_sum_track + "SummaryRes_CSmore2_square" + sector_name;
626  std::string Res_CSmore2_entries_name = dir_sum_track + "SummaryRes_CSmore2_entries" + sector_name;
627  std::string CS_name = dir_sum_track + "SummaryCS" + sector_name;
628  std::string CS_s_name = dir_sum_track + "SummaryCS_NotNorm" + sector_name;
629  std::string CS_square_name = dir_sum_track + "SummaryCS_square" + sector_name;
630  std::string CS_entries_name = dir_sum_track + "SummaryCS_entries" + sector_name;
631  std::string CS1_entries_name = dir_sum_track + "SummaryCS1_entries" + sector_name;
632  std::string CS2_entries_name = dir_sum_track + "SummaryCS2_entries" + sector_name;
633  std::string Time_name = dir_sum_track + "SummaryTime" + sector_name;
634  std::string Time_s_name = dir_sum_track + "SummaryTime_NotNorm" + sector_name;
635  std::string Time_square_name = dir_sum_track + "SummaryTime_square" + sector_name;
636  std::string Occupancy_name = dir_sum_track + "SummaryOccupancy" + sector_name;
637  std::string Occupancy_s_name = dir_sum_track + "SummaryOccupancy_NotNorm" + sector_name;
638  std::string PanelId_name = dir_sum_track + "SummaryPanelID" + sector_name;
639 
640  // distribution plot per sector
641  std::string EffSecDist_name = dir_sum_track + "SummaryEffDistriPerSector" + sector_name;
642  std::string GapEffSecDist_name = dir_sum_track + "SummaryGapEffDistriPerSector" + sector_name;
643  std::string NoiseCorrSecDist_name = dir_sum_track + "SummaryNoiseCorrDistriPerSector" + sector_name;
644  std::string NoiseTotSecDist_name = dir_sum_track + "SummaryNoiseTotDistriPerSector" + sector_name;
645  std::string CSSecDist_name = dir_sum_track + "SummaryCSDistriPerSector" + sector_name;
646  std::string Res_CS1SecDist_name = dir_sum_track + "SummaryRes_CS1DistriPerSector" + sector_name;
647  std::string Res_CS2SecDist_name = dir_sum_track + "SummaryRes_CS2DistriPerSector" + sector_name;
648  std::string Res_CSmore2SecDist_name = dir_sum_track + "SummaryRes_CSmore2DistriPerSector" + sector_name;
649  std::string Res_CS1_rmsSecDist_name = dir_sum_track + "SummaryRes_CS1rmsDistriPerSector" + sector_name;
650  std::string Res_CS2_rmsSecDist_name = dir_sum_track + "SummaryRes_CS2rmsDistriPerSector" + sector_name;
651  std::string Res_CSmore2_rmsSecDist_name = dir_sum_track + "SummaryRes_CSmore2rmsDistriPerSector" +
652  sector_name;
653  std::string TimeSecDist_name = dir_sum_track + "SummaryTimeDistriPerSector" + sector_name;
654  std::string OccupancySecDist_name = dir_sum_track + "SummaryOccupancyDistriPerSector" + sector_name;
655  //
656  auto initialiseHisto = [f](const std::string& name) -> TH1F* {
657  TH1F* result = (TH1F*) (f->Get(name.c_str()));
658 
659  return result;
660  };
661  TH1F* h_TrackProj = initialiseHisto(TrackProj_name);
662  TH1F* h_HitOnTrack = initialiseHisto(HitOnTrack_name);
663  TH1F* h_HitOnTrackCross = initialiseHisto(HitOnTrackCross_name);
664  TH1F* h_Eff = initialiseHisto(Eff_name);
665  TH1F* h_GapEff = initialiseHisto(GapEff_name);
666  TH1F* h_NoiseCorr = initialiseHisto(NoiseCorr_name);
667  TH1F* h_NoiseCorr_s = initialiseHisto(NoiseCorr_s_name);
668  TH1F* h_NoiseTot = initialiseHisto(NoiseTot_name);
669  TH1F* h_NoiseTot_s = initialiseHisto(NoiseTot_s_name);
670  TH1F* h_Res_CS1 = initialiseHisto(Res_CS1_name);
671  TH1F* h_Res_CS1_s = initialiseHisto(Res_CS1_s_name);
672  TH1F* h_Res_CS1_square = initialiseHisto(Res_CS1_square_name);
673  TH1F* h_Res_CS1_entries = initialiseHisto(Res_CS1_entries_name);
674  TH1F* h_Res_CS2 = initialiseHisto(Res_CS2_name);
675  TH1F* h_Res_CS2_s = initialiseHisto(Res_CS2_s_name);
676  TH1F* h_Res_CS2_square = initialiseHisto(Res_CS2_square_name);
677  TH1F* h_Res_CS2_entries = initialiseHisto(Res_CS2_entries_name);
678  TH1F* h_Res_CSmore2 = initialiseHisto(Res_CSmore2_name);
679  TH1F* h_Res_CSmore2_s = initialiseHisto(Res_CSmore2_s_name);
680  TH1F* h_Res_CSmore2_square = initialiseHisto(Res_CSmore2_square_name);
681  TH1F* h_Res_CSmore2_entries = initialiseHisto(Res_CSmore2_entries_name);
682  TH1F* h_CS = initialiseHisto(CS_name);
683  TH1F* h_CS_s = initialiseHisto(CS_s_name);
684  TH1F* h_CS_square = initialiseHisto(CS_square_name);
685  TH1F* h_CS_entries = initialiseHisto(CS_square_name);
686  TH1F* h_CS1_entries = initialiseHisto(CS1_entries_name);
687  TH1F* h_CS2_entries = initialiseHisto(CS2_entries_name);
688  TH1F* h_Time = initialiseHisto(Time_name);
689  TH1F* h_Time_s = initialiseHisto(Time_s_name);
690  TH1F* h_Time_square = initialiseHisto(Time_square_name);
691  TH1F* h_Occupancy = initialiseHisto(Occupancy_name);
692  TH1F* h_Occupancy_s = initialiseHisto(Occupancy_s_name);
693  TH1F* h_PanelId = initialiseHisto(PanelId_name);
694 
695  TH1F* h_EffSecDist = initialiseHisto(EffSecDist_name);
696  TH1F* h_GapEffSecDist = initialiseHisto(GapEffSecDist_name);
697  TH1F* h_NoiseCorrSecDist = initialiseHisto(NoiseCorrSecDist_name);
698  TH1F* h_NoiseTotSecDist = initialiseHisto(NoiseTotSecDist_name);
699  TH1F* h_CSSecDist = initialiseHisto(CSSecDist_name);
700  TH1F* h_Res_CS1SecDist = initialiseHisto(Res_CS1SecDist_name);
701  TH1F* h_Res_CS2SecDist = initialiseHisto(Res_CS2SecDist_name);
702  TH1F* h_Res_CSmore2SecDist = initialiseHisto(Res_CSmore2SecDist_name);
703  TH1F* h_Res_CS1_rmsSecDist = initialiseHisto(Res_CS1_rmsSecDist_name);
704  TH1F* h_Res_CS2_rmsSecDist = initialiseHisto(Res_CS2_rmsSecDist_name);
705  TH1F* h_Res_CSmore2_rmsSecDist = initialiseHisto(Res_CSmore2_rmsSecDist_name);
706  TH1F* h_TimeSecDist = initialiseHisto(TimeSecDist_name);
707  TH1F* h_OccupancySecDist = initialiseHisto(OccupancySecDist_name);
708 
709  auto resetIfValid = [](TH1F* pH) -> void {
710  if (pH) pH->Reset();
711  return;
712  };
713  resetIfValid(h_EffSecDist);
714  resetIfValid(h_GapEffSecDist);
715  resetIfValid(h_NoiseCorrSecDist);
716  resetIfValid(h_NoiseTotSecDist);
717  resetIfValid(h_CSSecDist);
718  resetIfValid(h_Res_CS1SecDist);
719  resetIfValid(h_Res_CS2SecDist);
720  resetIfValid(h_Res_CSmore2SecDist);
721  resetIfValid(h_Res_CS1_rmsSecDist);
722  resetIfValid(h_Res_CS2_rmsSecDist);
723  resetIfValid(h_Res_CSmore2_rmsSecDist);
724  resetIfValid(h_TimeSecDist);
725  resetIfValid(h_OccupancySecDist);
726  resetIfValid(h_Eff);
727 
728  // efficiency
729  if (h_TrackProj && h_HitOnTrack && h_Eff) {
730  for (int ib = 0; ib != h_TrackProj->GetNbinsX(); ib++) {
731  if (h_PanelId) {
732  if ((h_PanelId->GetBinContent(ib + 1)) == 0) {
733  continue;
734  }
735  }
736 
737  n_hit_f = h_HitOnTrack->GetBinContent(ib + 1);
738  n_tr_p = h_TrackProj->GetBinContent(ib + 1);
739 
740  //if ( n_tr_p>50 ) {
741  if (n_tr_p != 0) {
742  panel_eff = n_hit_f / n_tr_p;
743  } else {
744  panel_eff = 0.;
745  }
746  if (n_tr_p != 0) {
747  panel_err_eff = sqrt(fabs(n_hit_f) / n_tr_p) *
748  sqrt(1. - fabs(n_hit_f) / n_tr_p) /
749  sqrt(n_tr_p);
750  } else {
751  panel_err_eff = 0.;
752  }
753  h_Eff->SetBinContent(ib + 1, panel_eff);
754  h_Eff->SetBinError(ib + 1, panel_err_eff);
755  if (h_EffSecDist) h_EffSecDist->Fill(panel_eff);
756  if (ib > (h_TrackProj->GetNbinsX() / 2)) {
757  fillIfValid(h_AverageEff_A, panel_eff);
758  } else {
759  fillIfValid(h_AverageEff_C, panel_eff);
760  }
761  //}
762  }
763  // write out histogram
764  TDirectory* dir = f->GetDirectory(dir_sum_track.c_str());
765  if (dir != 0) {
766  dir->cd();
767  h_Eff->Write("", TObject::kOverwrite);
768  writeIfValid(h_EffSecDist);
769  }
770  }
771 
772  // gap efficiency
773  if (h_TrackProj && h_HitOnTrack && h_HitOnTrackCross && h_GapEff) {
774  h_GapEff->Reset();
775  nEta = 0;
776  nPhi = 0;
777  nEtaPhi = 0;
778  int sign = 1;
779  int bmin = 0;
780  bmin = int( h_GapEff->GetXaxis()->GetXmin());
781  for (int ib = 0; ib != h_TrackProj->GetNbinsX(); ib++) {
782  if (h_PanelId) {
783  if ((h_PanelId->GetBinContent(ib + 1)) == 0) {
784  continue;
785  }
786  }
787  if ((bmin + ib) % 2 != 0) continue; // Phi panel
788  sign = std::copysign(1, (bmin + ib));
789 
790  nEta = h_HitOnTrack->GetBinContent(ib + 1);
791  nPhi = h_HitOnTrack->GetBinContent(ib + 1 + sign);
792  nEtaPhi = h_HitOnTrackCross->GetBinContent(ib + 1);
793  n_tr_p = h_TrackProj->GetBinContent(ib + 1);
794 
795  if (n_tr_p > 0) {
796  gapEff = (nEta + nPhi - nEtaPhi) / n_tr_p;
797  gapErrEff = sqrt(fabs(nEta + nPhi - nEtaPhi) / n_tr_p) *
798  sqrt(1. - fabs(nEta + nPhi - nEtaPhi) / n_tr_p) /
799  sqrt(n_tr_p);
800  } else {
801  gapEff = 0.;
802  gapErrEff = 0.;
803  }
804  h_GapEff->SetBinContent(ib + 1, gapEff);
805  h_GapEff->SetBinError(ib + 1, gapErrEff);
806  fillIfValid(h_GapEffSecDist, gapEff);
807  if (ib > (h_TrackProj->GetNbinsX() / 2)) {
808  fillIfValid(h_AverageGapEff_A, gapEff);
809  } else {
810  fillIfValid(h_AverageGapEff_C, gapEff);
811  }
812  }
813  TDirectory* dir = f->GetDirectory(dir_sum_track.c_str());
814  if (dir != 0) {
815  dir->cd();
816  h_GapEff->Write("", TObject::kOverwrite);
817  if (h_GapEffSecDist) h_GapEffSecDist->Write("", TObject::kOverwrite);
818  }
819  }
820 
821 
822  //residuals CS = 1
823  res_mean = 0;
824  res2_mean = 0;
825  res_RMS = 0;
826 
827  if (h_Res_CS1 && h_Res_CS1_s && h_Res_CS1_square && h_Res_CS1_entries) {
828  for (int ib = 0; ib != h_Res_CS1->GetNbinsX(); ib++) {
829  if (h_PanelId) {
830  if ((h_PanelId->GetBinContent(ib + 1)) == 0) {
831  continue;
832  }
833  }
834  if ((h_Res_CS1_entries->GetBinContent(ib + 1)) != 0) {
835  res_mean = (h_Res_CS1_s->GetBinContent(ib + 1)) / (h_Res_CS1_entries->GetBinContent(ib + 1));
836  res2_mean = (h_Res_CS1_square->GetBinContent(ib + 1)) / (h_Res_CS1_entries->GetBinContent(ib + 1));
837  res_RMS = sqrt((fabs(res2_mean - res_mean * res_mean)) / (h_Res_CS1_entries->GetBinContent(ib + 1)));
838 
839  h_Res_CS1->SetBinContent(ib + 1, res_mean);
840  h_Res_CS1->SetBinError(ib + 1, res_RMS);
841  fillIfValid(h_Res_CS1SecDist, res_mean);
842  fillIfValid(h_Res_CS1_rmsSecDist, res_RMS);
843  if (ib > (h_Res_CS1->GetNbinsX() / 2)) {
844  fillIfValid(h_AverageRes_CS1_A, res_mean);
845  fillIfValid(h_AverageRes_CS1rms_A, res_RMS);
846  } else {
847  fillIfValid(h_AverageRes_CS1_C, res_mean);
848  fillIfValid(h_AverageRes_CS1rms_C, res_RMS);
849  }
850  }
851  } // end for bins
852  TDirectory* dirRes1 = f->GetDirectory(dir_sum_track.c_str());
853  if (dirRes1 != 0) {
854  dirRes1->cd();
855  h_Res_CS1->Write("", TObject::kOverwrite);
856  writeIfValid(h_Res_CS1SecDist);
857  writeIfValid(h_Res_CS1_rmsSecDist);
858  }
859  }
860 
861  //residuals CS = 2
862  res_mean = 0;
863  res2_mean = 0;
864  res_RMS = 0;
865  if (h_Res_CS2 && h_Res_CS2_s && h_Res_CS2_square && h_Res_CS2_entries) {
866  for (int ib = 0; ib != h_Res_CS2->GetNbinsX(); ib++) {
867  if (h_PanelId) {
868  if ((h_PanelId->GetBinContent(ib + 1)) == 0) {
869  continue;
870  }
871  }
872  if ((h_Res_CS2_entries->GetBinContent(ib + 1)) != 0) {
873  res_mean = (h_Res_CS2_s->GetBinContent(ib + 1)) / (h_Res_CS2_entries->GetBinContent(ib + 1));
874  res2_mean = (h_Res_CS2_square->GetBinContent(ib + 1)) / (h_Res_CS2_entries->GetBinContent(ib + 1));
875  res_RMS = sqrt(fabs((res2_mean - res_mean * res_mean) / (h_Res_CS2_entries->GetBinContent(ib + 1))));
876 
877  h_Res_CS2->SetBinContent(ib + 1, res_mean);
878  h_Res_CS2->SetBinError(ib + 1, res_RMS);
879  fillIfValid(h_Res_CS2SecDist, res_mean);
880  fillIfValid(h_Res_CS2_rmsSecDist, res_RMS);
881  if (ib > (h_Res_CS2->GetNbinsX() / 2)) {
882  fillIfValid(h_AverageRes_CS2_A, res_mean);
883  fillIfValid(h_AverageRes_CS2rms_A, res_RMS);
884  } else {
885  fillIfValid(h_AverageRes_CS2_C, res_mean);
886  fillIfValid(h_AverageRes_CS2rms_C, res_RMS);
887  }
888  }
889  }
890  TDirectory* dirRes2 = f->GetDirectory(dir_sum_track.c_str());
891  if (dirRes2 != 0) {
892  dirRes2->cd();
893  h_Res_CS2->Write("", TObject::kOverwrite);
894  writeIfValid(h_Res_CS2SecDist);
895  writeIfValid(h_Res_CS2_rmsSecDist);
896  }
897  }
898 
899  //residuals CS > 2
900  res_mean = 0;
901  res2_mean = 0;
902  res_RMS = 0;
903  if (h_Res_CSmore2 && h_Res_CSmore2_s && h_Res_CSmore2_square && h_Res_CSmore2_entries) {
904  for (int ib = 0; ib != h_Res_CSmore2->GetNbinsX(); ib++) {
905  if (h_PanelId) {
906  if ((h_PanelId->GetBinContent(ib + 1)) == 0) {
907  continue;
908  }
909  }
910  if ((h_Res_CSmore2_entries->GetBinContent(ib + 1)) != 0) {
911  res_mean = (h_Res_CSmore2_s->GetBinContent(ib + 1)) / (h_Res_CSmore2_entries->GetBinContent(ib + 1));
912  res2_mean = (h_Res_CSmore2_square->GetBinContent(ib + 1)) /
913  (h_Res_CSmore2_entries->GetBinContent(ib + 1));
914  res_RMS = sqrt(fabs((res2_mean - res_mean * res_mean) / (h_Res_CSmore2_entries->GetBinContent(
915  ib + 1))));
916 
917  h_Res_CSmore2->SetBinContent(ib + 1, res_mean);
918  h_Res_CSmore2->SetBinError(ib + 1, res_RMS);
919  fillIfValid(h_Res_CSmore2SecDist, res_mean);
920  fillIfValid(h_Res_CSmore2_rmsSecDist, res_RMS);
921  if (ib > (h_Res_CSmore2->GetNbinsX() / 2)) {
922  fillIfValid(h_AverageRes_CSmore2_A, res_mean);
923  fillIfValid(h_AverageRes_CSmore2rms_A, res_RMS);
924  } else {
925  fillIfValid(h_AverageRes_CSmore2_C, res_mean);
926  fillIfValid(h_AverageRes_CSmore2rms_C, res_RMS);
927  }
928  }
929  }
930  TDirectory* dirResp2 = f->GetDirectory(dir_sum_track.c_str());
931  if (dirResp2 != 0) {
932  dirResp2->cd();
933  h_Res_CSmore2->Write("", TObject::kOverwrite);
934  writeIfValid(h_Res_CSmore2SecDist);
935  writeIfValid(h_Res_CSmore2_rmsSecDist);
936  }
937  }
938 
939  // occupancy
940  if ((rpc_eventstotal > 0) && h_Occupancy && h_Occupancy_s) {
941  for (int ib = 0; ib != h_Occupancy->GetNbinsX(); ib++) {
942  if (h_PanelId) {
943  if ((h_PanelId->GetBinContent(ib + 1)) == 0) {
944  continue;
945  }
946  }
947  panel_occ = h_Occupancy_s->GetBinContent(ib + 1);
948  panel_occ = panel_occ / float(rpc_eventstotal);
949 
950  h_Occupancy->SetBinContent(ib + 1, panel_occ);
951  h_Occupancy->SetBinError(ib + 1, sqrt(panel_occ));
952 
953  if (panel_occ > 0) {
954  panel_occ = log10(panel_occ);
955  } else {
956  panel_occ = -10;
957  }
958  fillIfValid(h_OccupancySecDist, panel_occ);
959  if (h_PanelId and(ib > (h_PanelId->GetNbinsX() / 2))) {
960  fillIfValid(h_AverageOccupancy_A, panel_occ);
961  } else {
962  fillIfValid(h_AverageOccupancy_C, panel_occ);
963  }
964  }
965  // write occupancy histograms
966  TDirectory* dirOcc = f->GetDirectory(dir_sum_track.c_str());
967  if (dirOcc != 0) {
968  dirOcc->cd();
969  h_Occupancy->Write("", TObject::kOverwrite);
970  h_OccupancySecDist->Write("", TObject::kOverwrite);
971  }
972  }
973 
974 
975  // CS
976  if (h_CS && h_CS_s && h_CS_square && h_CS_entries) {
977  for (int ib = 0; ib != h_CS->GetNbinsX(); ib++) {
978  if (h_PanelId) {
979  if ((h_PanelId->GetBinContent(ib + 1)) == 0) {
980  continue;
981  }
982  }
983  panelCS_entries = h_CS_entries->GetBinContent(ib + 1);
984  panelCS = h_CS_s->GetBinContent(ib + 1);
985  panelCS2 = h_CS_square->GetBinContent(ib + 1);
986  if (panelCS_entries != 0) {
987  panelCS_mean = panelCS / panelCS_entries;
988  panelCS2_mean = panelCS2 / panelCS_entries;
989  panelCS_RMS = sqrt(fabs((panelCS2_mean - panelCS_mean * panelCS_mean) / panelCS_entries));
990 
991  h_CS->SetBinContent(ib + 1, panelCS_mean);
992  h_CS->SetBinError(ib + 1, panelCS_RMS);
993 
994  fillIfValid(h_CSSecDist, panelCS_mean);
995  if (ib > (h_CS->GetNbinsX() / 2)) {
996  fillIfValid(h_AverageCS_A, panelCS_mean);
997  } else {
998  fillIfValid(h_AverageCS_C, panelCS_mean);
999  }
1000  }
1001  }
1002  // write CS histograms
1003  TDirectory* dirCS = f->GetDirectory(dir_sum_track.c_str());
1004  if (dirCS != 0) {
1005  dirCS->cd();
1006  h_CS->Write("", TObject::kOverwrite);
1007  writeIfValid(h_CSSecDist);
1008  }
1009  }
1010 
1011  // time
1012  if (h_Time && h_Time_s && h_Time_square && h_CS_entries) {
1013  for (int ib = 0; ib != h_Time->GetNbinsX(); ib++) {
1014  if (h_PanelId) {
1015  if ((h_PanelId->GetBinContent(ib + 1)) == 0) {
1016  continue;
1017  }
1018  }
1019  if (h_CS_entries->GetBinContent(ib + 1) != 0) {
1020  Time_mean = (h_Time_s->GetBinContent(ib + 1)) / (h_CS_entries->GetBinContent(ib + 1));
1021  Time2_mean = (h_Time_square->GetBinContent(ib + 1)) / (h_CS_entries->GetBinContent(ib + 1));
1022  Time_RMS = sqrt(fabs((Time2_mean - Time_mean * Time_mean) / (h_CS_entries->GetBinContent(ib + 1))));
1023 
1024  h_Time->SetBinContent(ib + 1, Time_mean);
1025  h_Time->SetBinError(ib + 1, Time_RMS);
1026 
1027  fillIfValid(h_TimeSecDist, Time_mean);
1028  if (ib > (h_Time->GetNbinsX() / 2)) {
1029  fillIfValid(h_AverageTime_A, Time_mean);
1030  } else {
1031  fillIfValid(h_AverageTime_C, Time_mean);
1032  }
1033  }
1034  }
1035  // write time histograms
1036  TDirectory* dirTime = f->GetDirectory(dir_sum_track.c_str());
1037  if (dirTime != 0) {
1038  dirTime->cd();
1039  h_Time->Write("", TObject::kOverwrite);
1040  writeIfValid(h_TimeSecDist);
1041  }
1042  }
1043  // noise
1044  noiseErrNorm = 18257.42;
1045  if ((rpc_eventstotal > 0) && h_NoiseCorr && h_NoiseCorr_s && h_NoiseTot && h_NoiseTot_s && h_CS_entries) {
1046  //std::cout << " Taglio Eventi " << std::endl;
1047  for (int ib = 0; ib != h_NoiseCorr->GetNbinsX(); ib++) {
1048  if (h_PanelId) {
1049  if ((h_PanelId->GetBinContent(ib + 1)) == 0) {
1050  continue;
1051  }
1052  }
1053  if (h_CS_entries->GetBinContent(ib + 1) == 0) continue;
1054  noiseCorr = h_NoiseCorr_s->GetBinContent(ib + 1);
1055  noiseCorrErr = sqrt(noiseCorr) * noiseErrNorm / float(rpc_eventstotal);
1056  noiseCorr = (noiseCorr * 1000000) / float(rpc_eventstotal);
1057  h_NoiseCorr->SetBinContent(ib + 1, noiseCorr);
1058  h_NoiseCorr->SetBinError(ib + 1, noiseCorrErr);
1059  fillIfValid(h_NoiseCorrSecDist, noiseCorr);
1060 
1061  noiseTot = h_NoiseTot_s->GetBinContent(ib + 1);
1062  noiseTotErr = sqrt(noiseTot) * noiseErrNorm / float(rpc_eventstotal);
1063  noiseTot = (noiseTot * 1000000) / float(rpc_eventstotal);
1064  h_NoiseTot->SetBinContent(ib + 1, noiseTot);
1065  h_NoiseTot->SetBinError(ib + 1, noiseTotErr);
1066 
1067  fillIfValid(h_NoiseTotSecDist, noiseTot);
1068 
1069  if (ib > (h_NoiseCorr->GetNbinsX() / 2)) {
1070  fillIfValid(h_AverageNoiseTot_A, noiseTot);
1071  fillIfValid(h_AverageNoiseCorr_A, noiseCorr);
1072  } else {
1073  fillIfValid(h_AverageNoiseTot_C, noiseTot);
1074  fillIfValid(h_AverageNoiseCorr_C, noiseCorr);
1075  }
1076  }
1077  TDirectory* dirNoise = f->GetDirectory(dir_sum_track.c_str());
1078  if (dirNoise != 0) {
1079  dirNoise->cd();
1080  h_NoiseCorr->Write("", TObject::kOverwrite);
1081  h_NoiseTot->Write("", TObject::kOverwrite);
1082 
1083  writeIfValid(h_NoiseCorrSecDist);
1084  writeIfValid(h_NoiseTotSecDist);
1085  }
1086  }
1087 
1088 
1090  // bool do_asciiCoolFile1 = true;
1091  float effeta = -9999;
1092  float effphi = -9999;
1093  char arr_effeta [14] = {};
1094  char arr_effphi [14] = {};
1095  float erreffeta = -1;
1096  float erreffphi = -1;
1097  char arr_erreffeta [14] = {};
1098  char arr_erreffphi [14] = {};
1099  float reseta_cs1 = -9999;
1100  float resphi_cs1 = -9999;
1101  char arr_reseta_cs1 [14] = {};
1102  char arr_resphi_cs1 [14] = {};
1103  float errreseta_cs1 = -1;
1104  float errresphi_cs1 = -1;
1105  char arr_errreseta_cs1 [14] = {};
1106  char arr_errresphi_cs1 [14] = {};
1107  float reseta_cs2 = -9999;
1108  float resphi_cs2 = -9999;
1109  char arr_reseta_cs2 [14] = {};
1110  char arr_resphi_cs2 [14] = {};
1111  float errreseta_cs2 = -1;
1112  float errresphi_cs2 = -1;
1113  char arr_errreseta_cs2 [14] = {};
1114  char arr_errresphi_cs2 [14] = {};
1115  float reseta_csother = -9999;
1116  float resphi_csother = -9999;
1117  char arr_reseta_csother [14] = {};
1118  char arr_resphi_csother [14] = {};
1119  float errreseta_csother = -1;
1120  float errresphi_csother = -1;
1121  char arr_errreseta_csother [14] = {};
1122  char arr_errresphi_csother [14] = {};
1123  float timeeta = -9999;
1124  float timephi = -9999;
1125  char arr_timeeta [14] = {};
1126  char arr_timephi [14] = {};
1127  float errtimeeta = -1;
1128  float errtimephi = -1;
1129  char arr_errtimeeta [14] = {};
1130  char arr_errtimephi [14] = {};
1131  float noiseeta = -9999;
1132  float noisephi = -9999;
1133  char arr_noiseeta [14] = {};
1134  char arr_noisephi [14] = {};
1135  float errnoiseeta = -1;
1136  float errnoisephi = -1;
1137  char arr_errnoiseeta [14] = {};
1138  char arr_errnoisephi [14] = {};
1139  float noiseeta_cor = -9999;
1140  float noisephi_cor = -9999;
1141  char arr_noiseeta_cor [14] = {};
1142  char arr_noisephi_cor [14] = {};
1143  float errnoiseeta_cor = -1;
1144  float errnoisephi_cor = -1;
1145  char arr_errnoiseeta_cor [14] = {};
1146  char arr_errnoisephi_cor [14] = {};
1147  float cl_sizeeta = -9999;
1148  float cl_sizephi = -9999;
1149  char arr_cl_sizeeta [14] = {};
1150  char arr_cl_sizephi [14] = {};
1151  float errcl_sizeeta = -1;
1152  float errcl_sizephi = -1;
1153  char arr_errcl_sizeeta [14] = {};
1154  char arr_errcl_sizephi [14] = {};
1155 
1156  float eta_effphi = 0;
1157  float phi_effeta = 0;
1158 
1159  int PanelCode = 0;
1160  int Binposition = 0;
1161  int TableVersion = 1; //Version of Cool Table Formatting according with Andrea Di Simone Table
1162  int n_tr_peta = 0; //Number of eta tracks reconstructed on a gas volume
1163  int n_tr_pphi = 0; //Number of phi tracks reconstructed on a gas volume
1164  int NumberOfInfo = 1; //Number of information for each variable 1= only pannel, >1 depending on tipy of
1165  // monitoring setting and strip pannel geometry
1166  int StripCluster = 0; //Number of strip that realize de reduction bin and the strip pannel geometry 0=no
1167  // strip info,if panel has 24 strip: 24=strip info, 3 = cluster of 8 strip, 6 =
1168  // cluster of 4 strip and so on
1169 
1170 
1171 
1172  coolrpc.coolDbFolder("sqlite://;schema=RPCDQMFOFFLINE.db;dbname=RPC_DQA", "/OFFLINE/OFFLINE_DQMF");
1173  int nbin = 0;
1174  if (h_Eff) nbin = h_Eff->GetNbinsX();
1175  auto writeToCString = [](float val, char* array0) -> void {
1176  //following two lines reproduce original behaviour
1177  sprintf(array0, "%f ", val); //unsafe!
1178  array0[5] = 0; //ugh!
1179  };
1180 
1181  for (int ibin = 1; ibin != nbin + 1; ibin++) {
1182  if (h_PanelId) PanelCode = (int) h_PanelId->GetBinContent(ibin);
1183  if (PanelCode == 0) continue;
1184  if (ibin % 2 == 0) {
1185  if (h_TrackProj) n_tr_pphi = (int) h_TrackProj->GetBinContent(ibin);
1186  if (n_tr_pphi < 1000) continue;
1187 
1188  effphi = getBinContentIfValid(h_Eff, ibin);
1189  writeToCString(effphi, arr_effphi);
1190  erreffphi = getBinErrorIfValid(h_Eff, ibin);
1191  writeToCString(erreffphi, arr_erreffphi);
1192 
1193  resphi_cs1 = getBinContentIfValid(h_Res_CS1, ibin);
1194  writeToCString(resphi_cs1, arr_resphi_cs1);
1195  errresphi_cs1 = getBinErrorIfValid(h_Res_CS1, ibin);
1196  writeToCString(errresphi_cs1, arr_errresphi_cs1);
1197 
1198  resphi_cs2 = getBinContentIfValid(h_Res_CS2, ibin);
1199  writeToCString(resphi_cs2, arr_resphi_cs2);
1200  errresphi_cs2 = getBinErrorIfValid(h_Res_CS2, ibin);
1201  writeToCString(errresphi_cs2, arr_errresphi_cs2);
1202 
1203  resphi_csother = getBinContentIfValid(h_Res_CSmore2, ibin);
1204  writeToCString(resphi_csother, arr_resphi_csother);
1205  errresphi_csother = getBinErrorIfValid(h_Res_CSmore2, ibin);
1206  writeToCString(errresphi_csother, arr_errresphi_csother);
1207 
1208  timephi = getBinContentIfValid(h_Time, ibin);
1209  writeToCString(timephi, arr_timephi);
1210  errtimephi = getBinErrorIfValid(h_Time, ibin);
1211  writeToCString(errtimephi, arr_errtimephi);
1212 
1213  noisephi = getBinContentIfValid(h_NoiseTot, ibin);
1214  writeToCString(noisephi, arr_noisephi);
1215  errnoisephi = getBinErrorIfValid(h_NoiseTot, ibin);
1216  writeToCString(errnoisephi, arr_errnoisephi);
1217 
1218  noisephi_cor = getBinContentIfValid(h_NoiseCorr, ibin);
1219  writeToCString(noisephi_cor, arr_noisephi_cor);
1220  errnoisephi_cor = getBinErrorIfValid(h_NoiseCorr, ibin);
1221  writeToCString(errnoisephi_cor, arr_errnoisephi_cor);
1222 
1223  cl_sizephi = getBinContentIfValid(h_CS, ibin);
1224  writeToCString(cl_sizephi, arr_cl_sizephi);
1225  errcl_sizephi = getBinErrorIfValid(h_CS, ibin);
1226  writeToCString(errcl_sizephi, arr_errcl_sizephi);
1227  } else {
1228  if (h_TrackProj) {
1229  n_tr_peta = (int) h_TrackProj->GetBinContent(ibin);
1230  }
1231  if (n_tr_peta < 1000) continue;
1232 
1233  effeta = getBinContentIfValid(h_Eff, ibin);
1234  writeToCString(effeta, arr_effeta);
1235  erreffeta = getBinErrorIfValid(h_Eff, ibin);
1236  writeToCString(erreffeta, arr_erreffeta);
1237 
1238  reseta_cs1 = getBinContentIfValid(h_Res_CS1, ibin);
1239  writeToCString(reseta_cs1, arr_reseta_cs1);
1240  errreseta_cs1 = getBinErrorIfValid(h_Res_CS1, ibin);
1241  writeToCString(errreseta_cs1, arr_errreseta_cs1);
1242 
1243  reseta_cs2 = getBinContentIfValid(h_Res_CS2, ibin);
1244  writeToCString(reseta_cs2, arr_reseta_cs2);
1245  errreseta_cs2 = getBinErrorIfValid(h_Res_CS2, ibin);
1246  writeToCString(errreseta_cs2, arr_errreseta_cs2);
1247 
1248  reseta_csother = getBinContentIfValid(h_Res_CSmore2, ibin);
1249  writeToCString(reseta_csother, arr_reseta_csother);
1250  errreseta_csother = getBinErrorIfValid(h_Res_CSmore2, ibin);
1251  writeToCString(errreseta_csother, arr_errreseta_csother);
1252 
1253  timeeta = getBinContentIfValid(h_Time, ibin);
1254  writeToCString(timeeta, arr_timeeta);
1255  errtimeeta = getBinErrorIfValid(h_Time, ibin);
1256  writeToCString(errtimeeta, arr_errtimeeta);
1257 
1258  noiseeta = getBinContentIfValid(h_NoiseTot, ibin);
1259  writeToCString(noiseeta, arr_noiseeta);
1260  errnoiseeta = getBinErrorIfValid(h_NoiseTot, ibin);
1261  writeToCString(errnoiseeta, arr_errnoiseeta);
1262 
1263  noiseeta_cor = getBinContentIfValid(h_NoiseCorr, ibin);
1264  writeToCString(noiseeta_cor, arr_noiseeta_cor);
1265  errnoiseeta_cor = getBinErrorIfValid(h_NoiseCorr, ibin);
1266  writeToCString(errnoiseeta_cor, arr_errnoiseeta_cor);
1267 
1268  cl_sizeeta = getBinContentIfValid(h_CS, ibin);
1269  writeToCString(cl_sizeeta, arr_cl_sizeeta);
1270  errcl_sizeeta = getBinErrorIfValid(h_CS, ibin);
1271  writeToCString(errcl_sizeeta, arr_errcl_sizeeta);
1272 
1273 
1274  //std::cout<<"PanelCode "<<PanelCode<<" etaprimo "<<"\n";
1275 
1276  char recEta [4000]; //eff_eta, res_cs1, res_cs2, res_csother, time, mean and rms
1277  char detEta [4000]; //noise, noise_corr, cs, mean and rms
1278  char recPhi1 [4000]; //eff_phi, res_cs1, res_cs2, res_csother, time, only mean
1279  char recPhi2 [4000]; //eff_phi, res_cs1, res_cs2, res_csother, time, only rms
1280  char detPhi1 [4000]; //noise, noise_corr, cs, mean and rms
1281  char detPhi2 [4000];
1282  sprintf(recEta, "%5d %5d %5d %5d %s %s %s %s %s %s %s %s %s %s ", TableVersion,
1283  n_tr_peta, NumberOfInfo, StripCluster, arr_effeta, arr_erreffeta, arr_reseta_cs1,
1284  arr_errreseta_cs1, arr_reseta_cs2, arr_errreseta_cs2, arr_reseta_csother,
1285  arr_errreseta_csother, arr_timeeta, arr_errtimeeta);
1286  sprintf(detEta, "%s %s %s %s %s %s ", arr_noiseeta, arr_errnoiseeta,
1287  arr_noiseeta_cor, arr_errnoiseeta_cor, arr_cl_sizeeta, arr_errcl_sizeeta);
1288  sprintf(recPhi1, "%5d %5d %5d %s %s %s %s %s ", n_tr_pphi, NumberOfInfo,
1289  StripCluster, arr_effphi, arr_resphi_cs1, arr_resphi_cs2, arr_resphi_csother,
1290  arr_timephi);
1291  sprintf(recPhi2, "%s %s %s %s %s ", arr_erreffphi, arr_errresphi_cs1,
1292  arr_errresphi_cs2, arr_errresphi_csother, arr_errtimephi);
1293  sprintf(detPhi1, "%s %s %s %s %s %s ", arr_noisephi, arr_errnoisephi,
1294  arr_noisephi_cor, arr_errnoisephi_cor, arr_cl_sizephi, arr_errcl_sizephi);
1295  sprintf(detPhi2, "0 ");
1296  std::string cool_tag = "Reco";
1297  coolrpc.setSince(0U, 0U);
1298  coolrpc.setUntil(4294967295U, 0U);
1299  coolrpc.insert_withTag(run_number * 0 + 429496729U, PanelCode, recEta, detEta, recPhi1, recPhi2,
1300  detPhi1, detPhi2, cool_tag);
1301  }
1302  }
1303 
1306 
1307  int TableVersionCondDB = 2; //RPC conditionDB table versioning
1308  float gapeffeta = -9999;
1309  char arr_gapeffeta [10];
1310  float errgapeffeta = -1;
1311  char arr_errgapeffeta [10];
1312  float gapeffphi = -9999;
1313  char arr_gapeffphi [10];
1314  float errgapeffphi = -1;
1315  char arr_errgapeffphi [10];
1316  float gapeff = -9999;
1317  float errgapeff = -1;
1318  float entriesCSeta = -1;
1319  int entriesCS1eta = -1;
1320  int entriesCS2eta = -1;
1321  float entriesCSphi = -1;
1322  int entriesCS1phi = -1;
1323  int entriesCS2phi = -1;
1324  float rateCS1eta = -1;
1325  char arr_rateCS1eta [10];
1326  float rateCS2eta = -1;
1327  char arr_rateCS2eta [10];
1328  float rateCSmore2eta = -1;
1329  char arr_rateCSmore2eta [10];
1330  float rateCS1phi = -1;
1331  char arr_rateCS1phi [10];
1332  float rateCS2phi = -1;
1333  char arr_rateCS2phi [10];
1334  float rateCSmore2phi = -1;
1335  char arr_rateCSmore2phi [10];
1336 
1337 
1338 
1339  coolrpc.coolDbFolder("sqlite://;schema=RPCConditionDB.db;dbname=RPC_DQA", "/OFFLINE/FINAL");
1340  std::string dir_cool_raw = run_dir + "/Muon/MuonRawDataMonitoring/RPC/CoolDB/";
1341  TDirectory* coolFolder = f->GetDirectory(dir_cool_raw.c_str());
1342 
1343  if (coolFolder != 0) {
1344  std::vector<std::string> layerList;
1345  layerList.push_back("LowPt0");
1346  layerList.push_back("LowPt1");
1347  layerList.push_back("Pivot0");
1348  layerList.push_back("Pivot1");
1349  layerList.push_back("HighPt0");
1350  layerList.push_back("HighPt1");
1351  int NumberLayerStrip = 0;
1352  int PanelStripId = 0;
1353  int StripProfileContenent = 0;
1354 
1355  for (std::vector<std::string>::const_iterator iter = layerList.begin(); iter != layerList.end(); ++iter) {
1356  for (int i_dblPhi = 0; i_dblPhi != 2 * 1 + 1; ++i_dblPhi) {
1357  char coolName[40];
1358  sprintf(coolName, "Sector%.2d_%s_dblPhi%d", i_sec + 1, (*iter).c_str(), i_dblPhi + 1);
1359  std::string stripId_name = dir_cool_raw + coolName + "_PanelId";
1360  std::string stripProfile_name = dir_cool_raw + coolName + "_Profile";
1361  TH1F* h_stripId = NULL;
1362  TH1F* h_stripProfile = NULL;
1363 
1364  if (RPCCheckHistogram(f, stripId_name.c_str())) {
1365  h_stripId = (TH1F*) (f->Get(stripId_name.c_str()));
1366  }
1367  if (RPCCheckHistogram(f, stripProfile_name.c_str())) {
1368  h_stripProfile = (TH1F*) (f->Get(stripProfile_name.c_str()));
1369  }
1370 
1371  if (h_stripId && h_stripProfile) {
1372  int SingleStripsValue = 0;
1373  int StripsOnPanel = 1; //number of strip on panel
1374  char SingleStripsStatus [80];
1375  char SingleStripsStatusOK[80];
1376  std::string PanelStripsStatus;
1377  std::string PanelStripsStatusOK;
1378 
1379  NumberLayerStrip = h_stripProfile->GetNbinsX();
1380  for (int Nstrips = 1; Nstrips != NumberLayerStrip + 1; Nstrips++) {
1381  PanelStripId = (int) h_stripId->GetBinContent(Nstrips);
1382  StripProfileContenent = (int) h_stripProfile->GetBinContent(Nstrips);
1383  float StripOccupancy = (float) (StripProfileContenent) / rpc_eventstotal;
1384  if (StripOccupancy == 0) SingleStripsValue = 0;
1385  if (StripOccupancy > 0 && StripOccupancy < 0.9) SingleStripsValue = 5;
1386  if (StripOccupancy > 0.9) SingleStripsValue = 9;
1387 
1388  if (h_stripId->GetBinCenter(Nstrips) > 0) {
1389  sprintf(SingleStripsStatus, "%d 000.0 0.000|", SingleStripsValue);
1390  sprintf(SingleStripsStatusOK, "5 000.0 0.000|");
1391  } else {
1392  sprintf(SingleStripsStatus, "|000.0 0.000 %d", SingleStripsValue);
1393  sprintf(SingleStripsStatusOK, "|000.0 0.000 5");
1394  }
1395  PanelStripsStatus = PanelStripsStatus + SingleStripsStatus;
1396  PanelStripsStatusOK = PanelStripsStatusOK + SingleStripsStatusOK;
1397 
1398 
1399 
1400  if ((int) h_stripId->GetBinContent(Nstrips) ==
1401  (int) h_stripId->GetBinContent(Nstrips + 1)) StripsOnPanel++;
1402  //std::cout <<Nstrips<<" "<< h_stripId-> GetBinCenter(Nstrips)<< " "<< SingleStripsStatus <<"
1403  // PanelStripsStatus " << PanelStripsStatus <<" PanelStripsId " << PanelStripId <<std::endl;
1404 
1405  if ((int) h_stripId->GetBinContent(Nstrips) != (int) h_stripId->GetBinContent(Nstrips + 1)) {
1406  //std::cout <<StripsOnPanel<<" StripsOnPanel "<< std::endl;
1407 
1408  if (h_stripId->GetBinCenter(Nstrips) < 0) {
1409  //std::cout << " PanelStripsStatus " << PanelStripsStatus <<std::endl;
1410  std::reverse(PanelStripsStatus.begin(), PanelStripsStatus.end());
1411  std::reverse(PanelStripsStatusOK.begin(), PanelStripsStatusOK.end());
1412  }
1413 
1414  for (int ibin = 1; ibin != nbin + 1; ibin++) {
1415  if (h_PanelId) PanelCode = (int) h_PanelId->GetBinContent(ibin);
1416  if (PanelCode != PanelStripId) continue;
1417  if (ibin % 2 != 0) {
1418  if (h_TrackProj) {
1419  n_tr_peta = (int) h_TrackProj->GetBinContent(ibin);
1420  }
1421  //if(n_tr_peta >0){
1422  if (h_PanelId) Binposition = (int) h_PanelId->GetBinCenter(ibin);
1423  int ibin_perp = 0;
1424  if (Binposition > 0) {
1425  ibin_perp = ibin + 1;
1426  eta_effphi = getBinContentIfValid(h_Eff, ibin + 1);
1427  } else {
1428  ibin_perp = ibin - 1;
1429  eta_effphi = getBinContentIfValid(h_Eff, ibin - 1);
1430  }
1431  gapeff = getBinContentIfValid(h_GapEff, ibin);
1432  errgapeff = getBinErrorIfValid(h_GapEff, ibin);
1433  effeta = getBinContentIfValid(h_Eff, ibin);
1434  erreffeta = getBinErrorIfValid(h_Eff, ibin);
1435 
1436  gapeffeta = gapeff;
1437  errgapeffeta = errgapeff;
1438  EffThreshold = (effeta < Minimum_efficiency) || (eta_effphi < Minimum_efficiency);
1439 
1440  reseta_cs1 = getBinContentIfValid(h_Res_CS1, ibin);
1441  errreseta_cs1 = getBinErrorIfValid(h_Res_CS1, ibin);
1442 
1443  reseta_cs2 = getBinContentIfValid(h_Res_CS2, ibin);
1444  errreseta_cs2 = getBinErrorIfValid(h_Res_CS2, ibin);
1445 
1446  reseta_csother = getBinContentIfValid(h_Res_CSmore2, ibin);
1447  errreseta_csother = getBinErrorIfValid(h_Res_CSmore2, ibin);
1448 
1449  noiseeta = getBinContentIfValid(h_NoiseTot, ibin);
1450  errnoiseeta = getBinErrorIfValid(h_NoiseTot, ibin);
1451 
1452  noiseeta_cor = getBinContentIfValid(h_NoiseCorr, ibin);
1453  errnoiseeta_cor = getBinErrorIfValid(h_NoiseCorr, ibin);
1454 
1455  cl_sizeeta = getBinContentIfValid(h_CS, ibin);
1456  errcl_sizeeta = getBinErrorIfValid(h_CS, ibin);
1457 
1458  entriesCSeta = getBinContentIfValid(h_CS_entries, ibin);
1459  entriesCS1eta = getBinContentIfValid(h_CS1_entries, ibin);
1460  entriesCS2eta = getBinContentIfValid(h_CS2_entries, ibin);
1461 
1462  if (entriesCSeta > 0) {
1463  rateCS1eta = entriesCS1eta / entriesCSeta;
1464  rateCS2eta = entriesCS2eta / entriesCSeta;
1465  rateCSmore2eta = (entriesCSeta - (entriesCS1eta + entriesCS2eta)) / entriesCSeta;
1466  }
1467 
1468  if (applyEffThreshold) {
1469  if (effeta < Minimum_efficiency && eta_effphi < Minimum_efficiency) {
1470  effeta = Minimum_efficiency;
1471  gapeffeta = Minimum_efficiency;
1472  erreffeta = 0.1;
1473  errgapeffeta = 0.1;
1474  PanelStripsStatus = PanelStripsStatusOK;
1475  cl_sizeeta = 1;
1476  errcl_sizeeta = 0.1,
1477  rateCS1eta = 1;
1478  rateCS2eta = 0;
1479  rateCSmore2eta = 0;
1480  } else if (effeta < Minimum_efficiency && eta_effphi > Minimum_efficiency) {
1481  effeta = Minimum_efficiency;
1482  gapeffeta = eta_effphi;
1483  erreffeta = 0.1;
1484  errgapeffeta = 0.1;
1485  PanelStripsStatus = PanelStripsStatusOK;
1486  cl_sizeeta = 1;
1487  errcl_sizeeta = 0.1,
1488  rateCS1eta = 1;
1489  rateCS2eta = 0;
1490  rateCSmore2eta = 0;
1491  } else if (effeta > Minimum_efficiency && eta_effphi < Minimum_efficiency) {
1492  gapeffeta = effeta;
1493  errgapeffeta = 0.1;
1494  }
1495  }
1496  sprintf(arr_effeta, "%f ", effeta);
1497  arr_effeta [5] = 0;
1498  sprintf(arr_erreffeta, "%f ", erreffeta);
1499  arr_erreffeta [5] = 0;
1500  sprintf(arr_gapeffeta, "%f ", gapeffeta);
1501  arr_gapeffeta [5] = 0;
1502  sprintf(arr_errgapeffeta, "%f ", errgapeffeta);
1503  arr_errgapeffeta [5] = 0;
1504  sprintf(arr_reseta_cs1, "%f ", reseta_cs1);
1505  arr_reseta_cs1 [5] = 0;
1506  sprintf(arr_errreseta_cs1, "%f ", errreseta_cs1);
1507  arr_errreseta_cs1 [5] = 0;
1508  sprintf(arr_reseta_cs2, "%f ", reseta_cs2);
1509  arr_reseta_cs2 [5] = 0;
1510  sprintf(arr_errreseta_cs2, "%f ", errreseta_cs2);
1511  arr_errreseta_cs2 [5] = 0;
1512  sprintf(arr_reseta_csother, "%f ", reseta_csother);
1513  arr_reseta_csother [5] = 0;
1514  sprintf(arr_errreseta_csother, "%f ", errreseta_csother);
1515  arr_errreseta_csother[5] = 0;
1516  sprintf(arr_noiseeta, "%f ", noiseeta);
1517  arr_noiseeta [5] = 0;
1518  sprintf(arr_errnoiseeta, "%f ", errnoiseeta);
1519  arr_errnoiseeta [5] = 0;
1520  sprintf(arr_noiseeta_cor, "%f ", noiseeta_cor);
1521  arr_noiseeta_cor [5] = 0;
1522  sprintf(arr_errnoiseeta_cor, "%f ", errnoiseeta_cor);
1523  arr_errnoiseeta_cor [5] = 0;
1524  sprintf(arr_cl_sizeeta, "%f ", cl_sizeeta);
1525  arr_cl_sizeeta [5] = 0;
1526  sprintf(arr_errcl_sizeeta, "%f ", errcl_sizeeta);
1527  arr_errcl_sizeeta [5] = 0;
1528  sprintf(arr_rateCS1eta, "%f ", rateCS1eta);
1529  arr_rateCS1eta [5] = 0;
1530  sprintf(arr_rateCS2eta, "%f ", rateCS2eta);
1531  arr_rateCS2eta [5] = 0;
1532  sprintf(arr_rateCSmore2eta, "%f ", rateCSmore2eta);
1533  arr_rateCSmore2eta [5] = 0;
1534 
1535  char PanelRes [255]; //eff_eta, res_cs1, res_cs2, res_csother, time, mean and rms
1536  char StripStatus [4096]; //strips status 0 to 9 for dead noisy strips
1537 
1538  sprintf(PanelRes, "%d %d %d %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
1539  TableVersionCondDB, n_tr_peta, StripsOnPanel, arr_effeta, arr_erreffeta,
1540  arr_gapeffeta, arr_errgapeffeta, arr_reseta_cs1, arr_errreseta_cs1, arr_reseta_cs2,
1541  arr_errreseta_cs2, arr_reseta_csother, arr_errreseta_csother, arr_noiseeta,
1542  arr_errnoiseeta, arr_noiseeta_cor, arr_errnoiseeta_cor, arr_cl_sizeeta,
1543  arr_errcl_sizeeta, arr_rateCS1eta, arr_rateCS2eta, arr_rateCSmore2eta);
1544  sprintf(StripStatus, "%s", PanelStripsStatus.c_str());
1545  std::string cool_tagCondDB = "RecoCondDB";
1546  coolrpc.setSince(0U, 0U);
1547  coolrpc.setUntil(4294967295U, 0U);
1548  coolrpc.insertCondDB_withTag(run_number * 0 + 429496729U, PanelCode, PanelRes, StripStatus,
1549  cool_tagCondDB);
1550  if (printout and EffThreshold and h_GapEff) std::cout << stripProfile_name <<
1551  " under THR " << EffThreshold << " " << PanelCode << " ibin " << ibin << " h_EffEta " <<
1552  h_Eff->GetBinContent(ibin) << " h_EffPhi " << h_Eff->GetBinContent(ibin_perp) <<
1553  " h_GapEffEta " << h_GapEff->GetBinContent(ibin) << " h_GapEffPhi " <<
1554  h_GapEff->GetBinContent(ibin_perp) << " cool_EtaEff " << effeta << " cool_GapEffEta " <<
1555  gapeffeta << " --- Eta Summary " << PanelRes << " --- StripStatus " << StripStatus <<
1556  std::endl;
1557  if (printout &&
1558  EffThreshold) std::cout << "inCOOL_ETA_id_ntrk_panelEff_gapEff " << PanelCode << " " <<
1559  n_tr_peta << " " << (int) (n_tr_peta * effeta) << " " << (int) (n_tr_peta * gapeffeta) <<
1560  std::endl;
1561  countpanelindb++;
1562  if (effeta == 0.0) countpaneleff0++;
1563  if (n_tr_peta == 0) countpaneltrack0++;
1564  } else {
1565  if (h_TrackProj) n_tr_pphi = (int) h_TrackProj->GetBinContent(ibin);
1566  //if(n_tr_pphi >0){
1567 
1568  if (h_PanelId) Binposition = (int) h_PanelId->GetBinCenter(ibin);
1569  int ibin_perp = 0;
1570  if (Binposition > 0) {
1571  ibin_perp = ibin - 1;
1572  gapeff = getBinContentIfValid(h_GapEff, ibin - 1);
1573  errgapeff = getBinErrorIfValid(h_GapEff, ibin - 1);
1574  phi_effeta = getBinContentIfValid(h_Eff, ibin - 1);
1575  } else {
1576  ibin_perp = ibin + 1;
1577  gapeff = getBinContentIfValid(h_GapEff, ibin + 1);
1578  errgapeff = getBinErrorIfValid(h_GapEff, ibin + 1);
1579  phi_effeta = getBinContentIfValid(h_Eff, ibin + 1);
1580  }
1581  effphi = getBinContentIfValid(h_Eff, ibin);
1582  erreffphi = getBinErrorIfValid(h_Eff, ibin);
1583  gapeffphi = gapeff;
1584  errgapeffphi = errgapeff;
1585  EffThreshold = (effphi < Minimum_efficiency) || (phi_effeta < Minimum_efficiency);
1586 
1587 
1588  resphi_cs1 = getBinContentIfValid(h_Res_CS1, ibin);
1589  errresphi_cs1 = getBinErrorIfValid(h_Res_CS1, ibin);
1590 
1591  resphi_cs2 = getBinContentIfValid(h_Res_CS2, ibin);
1592  errresphi_cs2 = getBinErrorIfValid(h_Res_CS2, ibin);
1593 
1594  resphi_csother = getBinContentIfValid(h_Res_CSmore2, ibin);
1595  errresphi_csother = getBinErrorIfValid(h_Res_CSmore2, ibin);
1596 
1597  noisephi = getBinContentIfValid(h_NoiseTot, ibin);
1598  errnoisephi = getBinErrorIfValid(h_NoiseTot, ibin);
1599 
1600  noisephi_cor = getBinContentIfValid(h_NoiseCorr, ibin);
1601  errnoisephi_cor = getBinErrorIfValid(h_NoiseCorr, ibin);
1602 
1603  cl_sizephi = getBinContentIfValid(h_CS, ibin);
1604  errcl_sizephi = getBinErrorIfValid(h_CS, ibin);
1605 
1606  entriesCSphi = getBinContentIfValid(h_CS_entries, ibin);
1607  entriesCS1phi = getBinContentIfValid(h_CS1_entries, ibin);
1608  entriesCS2phi = getBinContentIfValid(h_CS2_entries, ibin);
1609  if (entriesCSphi > 0) {
1610  rateCS1phi = entriesCS1phi / entriesCSphi;
1611  rateCS2phi = entriesCS2phi / entriesCSphi;
1612  rateCSmore2phi = (entriesCSphi - (entriesCS1phi + entriesCS2phi)) / entriesCSphi;
1613  }
1614 
1615 
1616  if (applyEffThreshold) {
1617  if (effphi < Minimum_efficiency && phi_effeta < Minimum_efficiency) {
1618  effphi = Minimum_efficiency;
1619  gapeffphi = Minimum_efficiency;
1620  erreffphi = 0.1;
1621  errgapeffphi = 0.1;
1622  PanelStripsStatus = PanelStripsStatusOK;
1623  cl_sizephi = 1;
1624  errcl_sizephi = 0.1,
1625  rateCS1phi = 1;
1626  rateCS2phi = 0;
1627  rateCSmore2phi = 0;
1628  } else if (effphi < Minimum_efficiency && phi_effeta > Minimum_efficiency) {
1629  effphi = Minimum_efficiency;
1630  gapeffphi = phi_effeta;
1631  erreffphi = 0.1;
1632  errgapeffphi = 0.1;
1633  PanelStripsStatus = PanelStripsStatusOK;
1634  cl_sizephi = 1;
1635  errcl_sizephi = 0.1,
1636  rateCS1phi = 1;
1637  rateCS2phi = 0;
1638  rateCSmore2phi = 0;
1639  } else if (effphi > Minimum_efficiency && phi_effeta < Minimum_efficiency) {
1640  gapeffphi = effphi;
1641  errgapeffphi = 0.1;
1642  PanelStripsStatus = PanelStripsStatusOK;
1643  }
1644  }
1645 
1646  sprintf(arr_effphi, "%f ", effphi);
1647  arr_effphi [5] = 0;
1648  sprintf(arr_erreffphi, "%f ", erreffphi);
1649  arr_erreffphi [5] = 0;
1650  sprintf(arr_gapeffphi, "%f ", gapeffphi);
1651  arr_gapeffphi [5] = 0;
1652  sprintf(arr_errgapeffphi, "%f ", errgapeffphi);
1653  arr_errgapeffphi [5] = 0;
1654  sprintf(arr_resphi_cs1, "%f ", resphi_cs1);
1655  arr_resphi_cs1 [5] = 0;
1656  sprintf(arr_errresphi_cs1, "%f ", errresphi_cs1);
1657  arr_errresphi_cs1 [5] = 0;
1658  sprintf(arr_resphi_cs2, "%f ", resphi_cs2);
1659  arr_resphi_cs2 [5] = 0;
1660  sprintf(arr_errresphi_cs2, "%f ", errresphi_cs2);
1661  arr_errresphi_cs2 [5] = 0;
1662  sprintf(arr_resphi_csother, "%f ", resphi_csother);
1663  arr_resphi_csother [5] = 0;
1664  sprintf(arr_errresphi_csother, "%f ", errresphi_csother);
1665  arr_errresphi_csother[5] = 0;
1666  sprintf(arr_noisephi, "%f ", noisephi);
1667  arr_noisephi [5] = 0;
1668  sprintf(arr_errnoisephi, "%f ", errnoisephi);
1669  arr_errnoisephi [5] = 0;
1670  sprintf(arr_noisephi_cor, "%f ", noisephi_cor);
1671  arr_noisephi_cor [5] = 0;
1672  sprintf(arr_errnoisephi_cor, "%f ", errnoisephi_cor);
1673  arr_errnoisephi_cor [5] = 0;
1674  sprintf(arr_cl_sizephi, "%f ", cl_sizephi);
1675  arr_cl_sizephi [5] = 0;
1676  sprintf(arr_errcl_sizephi, "%f ", errcl_sizephi);
1677  arr_errcl_sizephi [5] = 0;
1678  sprintf(arr_rateCS1phi, "%f ", rateCS1phi);
1679  arr_rateCS1phi [5] = 0;
1680  sprintf(arr_rateCS2phi, "%f ", rateCS2phi);
1681  arr_rateCS2phi [5] = 0;
1682  sprintf(arr_rateCSmore2phi, "%f ", rateCSmore2phi);
1683  arr_rateCSmore2phi [5] = 0;
1684 
1685  char PanelRes [255]; //eff_eta, res_cs1, res_cs2, res_csother, time, mean and rms
1686  char StripStatus [4096]; //strips status 0 to 9 for dead noisy strips
1687  sprintf(PanelRes, "%d %d %d %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
1688  TableVersionCondDB, n_tr_pphi,
1689  StripsOnPanel, arr_effphi, arr_erreffphi, arr_gapeffphi, arr_errgapeffphi,
1690  arr_resphi_cs1, arr_errresphi_cs1, arr_resphi_cs2,
1691  arr_errresphi_cs2, arr_resphi_csother, arr_errresphi_csother, arr_noisephi,
1692  arr_errnoisephi, arr_noisephi_cor, arr_errnoisephi_cor,
1693  arr_cl_sizephi, arr_errcl_sizephi, arr_rateCS1phi, arr_rateCS2phi,
1694  arr_rateCSmore2phi);
1695  sprintf(StripStatus, "%s", PanelStripsStatus.c_str());
1696  std::string cool_tag = "RecoCondDB";
1697  coolrpc.setSince(0U, 0U);
1698  coolrpc.setUntil(4294967295U, 0U);
1699  coolrpc.insertCondDB_withTag(run_number * 0 + 429496729U, PanelCode, PanelRes, StripStatus,
1700  cool_tag);
1701 
1702  if (printout &&
1703  EffThreshold) std::cout << stripProfile_name << " under THR " << EffThreshold << " " <<
1704  PanelCode << " ibin " << ibin << " h_EffPhi " << h_Eff->GetBinContent(ibin)
1705  << " h_EffEta " <<
1706  h_Eff->GetBinContent(ibin_perp) << " h_GapEffPhi " << h_GapEff->GetBinContent(ibin) <<
1707  " h_GapEffEta " << h_GapEff->GetBinContent(ibin_perp) << " cool_PhiEff "
1708  << effphi << " cool_GapEffPhi " << gapeffphi <<
1709  " --- Phi Summary " << PanelRes << " --- StripStatus " << StripStatus << std::endl;
1710 
1711  if (printout && EffThreshold) std::cout << "inCOOL_PHI_id_ntrk_panelEff_gapEff " << PanelCode << " " << n_tr_pphi << " " << (int) (n_tr_pphi * effphi) << " " << (int) (n_tr_pphi * gapeffphi) << std::endl;
1712  countpanelindb++;
1713  if (effphi == 0.0) countpaneleff0++;
1714  if (n_tr_pphi == 0) countpaneltrack0++;
1715  }
1716  StripsOnPanel = 1;
1717  PanelStripsStatus.clear();
1718  PanelStripsStatusOK.clear();
1719  }
1720  StripsOnPanel = 1;
1721  PanelStripsStatus.clear();
1722  PanelStripsStatusOK.clear();
1723  }
1724  }
1725  }
1726  } // end loop on DoubletPhi
1727  } // end loop on layers
1728  }// end Cool Folder
1729  std::cout << "Count RC panels in DB " << countpanelindb << " Count RPCpanels in DB with zero efficiency " << countpaneleff0 << " Count RPCpanels in DB with zero track " << countpaneltrack0 << std::endl;
1730  } // end for sectors
1731  std::cout << "Count RC panels in DB " << countpanelindb << " Count RPCpanels in DB with zero efficiency " << countpaneleff0 << " Count RPCpanels in DB with zero track " << countpaneltrack0 << std::endl;
1732  // write distribution plots all ATLAS
1733  TDirectory* dirA = f->GetDirectory(dir_sideA_track.c_str());
1734 
1735  if (dirA != 0) {
1736  dirA->cd();
1737  writeIfValid(h_AverageEff_A);
1738  writeIfValid(h_AverageGapEff_A);
1739  writeIfValid(h_AverageRes_CS1_A);
1740  writeIfValid(h_AverageRes_CS1rms_A);
1741  writeIfValid(h_AverageRes_CS2_A);
1742  writeIfValid(h_AverageRes_CS2rms_A);
1743  writeIfValid(h_AverageRes_CSmore2_A);
1744  writeIfValid(h_AverageRes_CSmore2rms_A);
1745  writeIfValid(h_AverageOccupancy_A);
1746  writeIfValid(h_AverageCS_A);
1747  writeIfValid(h_AverageTime_A);
1748  writeIfValid(h_AverageNoiseCorr_A);
1749  writeIfValid(h_AverageNoiseTot_A);
1750  }
1751  TDirectory* dirC = f->GetDirectory(dir_sideC_track.c_str());
1752  if (dirC != 0) {
1753  dirC->cd();
1754  writeIfValid(h_AverageEff_C);
1755  writeIfValid(h_AverageGapEff_C);
1756  writeIfValid(h_AverageRes_CS1_C);
1757  writeIfValid(h_AverageRes_CS1rms_C);
1758  writeIfValid(h_AverageRes_CS2_C);
1759  writeIfValid(h_AverageRes_CS2rms_C);
1760  writeIfValid(h_AverageRes_CSmore2_C);
1761  writeIfValid(h_AverageRes_CSmore2rms_C);
1762  writeIfValid(h_AverageOccupancy_C);
1763  writeIfValid(h_AverageCS_C);
1764  writeIfValid(h_AverageTime_C);
1765  writeIfValid(h_AverageNoiseCorr_C);
1766  writeIfValid(h_AverageNoiseTot_C);
1767  }
1768  }
1769  } else {
1770  delete obj_run;
1771  } // end if tdir_run !=0
1772  }
1773  f->Close();
1774  delete f;
1775  }
1776 
1777  bool
1778  MonitoringFile::
1779  RPCCheckHistogram(TFile* f, const char* HistoName) {
1780  if (!(f->Get(HistoName))) {
1781  return false;
1782  } else return true;
1783  }
1784 }
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
plotting.plot_kinematics.run_number
run_number
Definition: plot_kinematics.py:29
TH1F::GetBinContent
double GetBinContent(int) const
Definition: rootspy.cxx:326
get_generator_info.result
result
Definition: get_generator_info.py:21
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TH1I
Definition: rootspy.cxx:332
PlotCalibFromCool.ib
ib
Definition: PlotCalibFromCool.py:419
CoolRpc.h
TrigVSI::AlgConsts::nPhi
constexpr int nPhi
Default bin number of phi for vertex map.
Definition: Trigger/TrigTools/TrigVrtSecInclusive/TrigVrtSecInclusive/Constants.h:27
dqutils::CoolRpc::setUntil
void setUntil(cool::Int64 iovmax, cool::Int64 lumi)
DeMoUpdate.reverse
reverse
Definition: DeMoUpdate.py:563
xAOD::StripCluster
StripCluster_v1 StripCluster
Define the version of the strip cluster class.
Definition: StripCluster.h:13
CalibDbCompareRT.cool_tag
cool_tag
Definition: CalibDbCompareRT.py:12
CheckAppliedSFs.bmin
bmin
Definition: CheckAppliedSFs.py:242
dqutils::CoolRpc
Definition: CoolRpc.h:77
dqutils::CoolRpc::coolDbFolder
void coolDbFolder(const std::string &dbStr, const std::string &folderStr)
dqutils::MonitoringFile::RPCPostProcess
static void RPCPostProcess(const std::string &inFilename, bool isIncremental=false)
Definition: MonitoringFile_RPCPostProcess.cxx:59
sign
int sign(int a)
Definition: TRT_StrawNeighbourSvc.h:127
TH1F::SetBinContent
void SetBinContent(int, double)
Definition: rootspy.cxx:327
dqutils::CoolRpc::insertCondDB_withTag
void insertCondDB_withTag(cool::Int64 run, cool::ChannelId channelId, const std::string &PanelRes, const std::string &StringStatus, const std::string &cool_tag)
dqutils
Definition: CoolMdt.h:76
dqutils::CoolRpc::insert_withTag
void insert_withTag(cool::Int64 run, cool::ChannelId channelId, const std::string &recEta, const std::string &DetEta, const std::string &recPhi1, const std::string &recPhi2, const std::string &detPhi1, const std::string &detPhi2, const std::string &cool_tag)
beamspotman.dir
string dir
Definition: beamspotman.py:623
dqutils::MonitoringFile::RPCCheckHistogram
static bool RPCCheckHistogram(TFile *f, const char *HistoName)
Definition: MonitoringFile_RPCPostProcess.cxx:1779
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
dqutils::CoolRpc::setSince
void setSince(cool::Int64 run, cool::Int64 lumi)
MonitoringFile.h
TH1F
Definition: rootspy.cxx:320
TH1I::SetBinContent
void SetBinContent(int, double)
Definition: rootspy.cxx:338
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
TH1I::GetBinContent
double GetBinContent(int) const
Definition: rootspy.cxx:337
TrigVSI::AlgConsts::nEta
constexpr int nEta
Default bin number of eta for vertex map.
Definition: Trigger/TrigTools/TrigVrtSecInclusive/TrigVrtSecInclusive/Constants.h:26
hotSpotInTAG.nb
nb
Definition: hotSpotInTAG.py:164
readCCLHist.float
float
Definition: readCCLHist.py:83
Generated on Tue Jul 2 2024 21:22:03 for ATLAS Offline Software by   doxygen 1.8.18