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