CMS 3D CMS Logo
zamt5GSMHF.cc
Go to the documentation of this file.
1 #include <iostream>
2 #include <fstream>
3 #include "TH1.h"
4 #include "TH2.h"
5 #include "TH1F.h"
6 #include "TH2F.h"
7 #include "TCanvas.h"
8 #include "TROOT.h"
9 #include <TMath.h>
10 #include "TStyle.h"
11 #include "TSystem.h"
12 #include "TLegend.h"
13 #include "TText.h"
14 #include "TAxis.h"
15 #include "TFile.h"
16 #include "TLine.h"
17 #include "TGraph.h"
18 #include <TPaveText.h>
19 #include <TPostScript.h>
20 #include <TClass.h>
21 #include <TLatex.h>
22 #include <TFrame.h>
23 #include <TPad.h>
24 #include <TGaxis.h>
25 
26 #include "TGraphErrors.h"
27 #include "TF1.h"
28 #include "TArrow.h"
29 
30 //
31 using namespace std;
32 //
33 //
34 int main(int argc, char* argv[]) {
35  cout << "********************************************************************* START job " << endl;
36  //______________________________________________________________________________________________________________________________
37  //TCanvas *c1;
38  TGraph* gr1;
39  TGraph* gr2;
40  TGraph* gr3;
41  TGraph* gr4;
42  TGraph* gr5;
43  TGraph* gr6;
44  TGraph* gr7;
45  TGraph* gr8;
46  TGraph* gr9;
47  TGraphErrors* ge1;
48  TGraphErrors* ge2;
49  TGraphErrors* ge3;
50  TGraphErrors* ge4;
51  TGraphErrors* ge5;
52  TGraphErrors* ge6;
53  TGraphErrors* ge7;
54  TGraphErrors* ge8;
55  TGraphErrors* ge9;
56 
57  //
58  const Int_t NMethods = 14; // total number of Methods (all-together 37 methods)
59  const Int_t NMethodsStart = 0; // since which method to start ( min= 0)
60  const Int_t NMethodsToUse = 13; // choose Number of methods to use ( max= 36)
61  //
62  TString MethodName[NMethods] = {"PLOT0",
63  "PLOT1",
64  "PLOT2",
65  "PLOT3",
66  "PLOT4",
67  "PLOT5",
68  "PLOT6",
69  "PLOT7",
70  "PLOT8",
71  "PLOT9",
72  "PLOT10",
73  "PLOT11",
74  "PLOT12",
75  "PLOT13"};
76  //______________________________________________________________________________________________________________________________
77  const Int_t NMAXM = 70; //
78 
79  cout << "********************************************************************* NMAXM = " << NMAXM << endl;
80 
81  TString LEDrunsM[NMAXM] = {
82 
83  "315812", "315984", "316826", "317116", "317193", "317268", "317271", "317273", "317363", "317444", "317606",
84  "317607", "317609", "317610", "317611", "317612", "317613", "317617", "317785", "318758", "319198", "319401",
85  "319517", "319519", "319520", "319564", "319612", "319734", "319771", "319774", "319857", "319969", "320117",
86  "320158", "320203", "320205", "320348", "320579", "320873", "320892", "320952", "321019", "321036", "321187",
87  "321339", "321359", "321371", "321447", "321514", "322781", "322782", "323314", "323502", "323579", "323613",
88  "323742", "324030", "324032", "324138", "324225", "324296", "324919", "325141", "325787", "326234", "326875",
89  "327288", "327438", "327552", "327579"
90 
91  };
92  cout << "********************************************************************* first massives defined " << endl;
93  Float_t X0M[NMAXM] = {
94 
95  0., 2., 17., 22., 23., 24., 24., 24., 27., 29., 32., 32., 32., 32., 32., 32., 32., 32.,
96  38., 51., 58., 63., 65., 65., 65., 66., 68., 70., 71., 71., 72., 74., 77., 78., 79., 79.,
97  80., 85., 90., 91., 92., 93., 93., 98., 101., 101., 101., 104., 106., 129., 129., 138., 141., 142.,
98  143., 146., 150., 150., 151., 153., 155., 165., 169., 179., 183., 195., 203., 205., 208., 209.,
99  }; // days of year time points (abscissa) !!!
100  cout << "********************************************************************* both massives are defined " << endl;
102  //define yearcase:
103  // ____________________________________________________________________________ THIS line below is MAIN to make a yearcase selection !!!!!!!!!!!!!!!!!!!!!!!!!!
104  const Int_t yearcase = 0;
105  //
106  cout << "************************************** yearcase = " << yearcase << endl;
107  // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
108  // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
109  // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
110  // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
111  // Int_t verbosity = 2;//
112  // Int_t verbosity = 3;//
113  // Int_t verbosity = 4;// to clarify # channels in HFP17
114  Int_t verbosity = 0; //
115  // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
116 
117  // const Int_t flagHFP17selection = 2;// -> ALL channels w/o bad
118  // const Int_t flagHFP17selection = 1;// ==1 HFP17;
119  const Int_t flagHFP17selection = 0; // -> ALL channels
120 
121  cout << "************************************** flagHFP17selection = " << flagHFP17selection << endl;
122  // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
123  //______________________________________________________________________________
124 
125  //______________________________________________________________________________
126  //______________________________________________________________________________
127  //
128  //---=[ SetCanvasDef ]=----------------
129  // Create a new canvas.
130  //TCanvas *c1 = new TCanvas("c1","GSM",10,10,900,700);
131 
132  //TCanvas *c1 = new TCanvas("c1","GSM",20,50,920,850);
133  TCanvas* c1 = new TCanvas("c1", "GSM", 10, 10, 1010, 1010);
134 
135  //TCanvas *c1 = new TCanvas("c1","GSM",200,10,700,900);
136  //TCanvas *c1 = new TCanvas("c1","Hcal4test",200,10,700,900);
137 
138  c1->Range(0, 0, 25, 18);
139  //c1->SetFillColor(40);
140  c1->SetFillColor(0);
141  c1->Clear();
142 
143  TLatex* t = new TLatex();
144  t->SetTextFont(32);
145  //t->SetTextColor(4);
146  t->SetTextSize(0.03);
147  t->SetTextAlign(12);
148  //______________________________________________________________________________
149  t->DrawLatex(
150  0.9, 15.5, "Time dependence of full Amplitude averaged over events of each LED run for some random HF channels");
151 
152  //-----------------------------------------------------------------------------------------------------
153  //
154  // x1 y1 x2 y2
155  // pad1->DrawFrame(1, 0.8, 370, 1.2);// all
156 
157  //
158  // Float_t x1=0.00; Float_t x2=170.00;
159  // Float_t x1=0.00; Float_t x2=850.00;
160 
161  // Float_t x1=0.00; Float_t x2=45.00;
162  Float_t x1 = 0.00;
163  Float_t x2 = 215.0;
164 
165  // y(ordinate) for All Days
166  // Float_t y1=0.985; Float_t y2= 1.015;
167  Float_t y1 = 0.9;
168  Float_t y2 = 1.1;
169 
170  //
171  // x(abscissa) for Days
172  Float_t RrangeMIN = y1;
173  Float_t RrangeMAX = y2;
174 
175  //
176  Float_t xx1 = 0.35;
177  Float_t xx2 = 0.55;
178  Float_t yy1 = 0.76;
179  Float_t yy2 = 0.88;
180  //
181  cout << "************************************** RrangeMIN = " << RrangeMIN << " RrangeMAX = " << RrangeMAX << endl;
182 
183  //-----------------------------------------------------------------------------------------------------
184  //-----------------------------------------------------------------------------------------------------
186  const Int_t NDEP = 5;
187  const Int_t NETA0 = 83;
188  const Int_t NPHI0 = 73;
189  //
190  Double_t mapRATIO[NDEP][NETA0][NPHI0];
191  Double_t mapRATIOD2[NETA0][NPHI0];
192  Int_t mapRATIOD20[NETA0][NPHI0];
193 
194  //Double_t normalization[NDEP][NETA0][NPHI0];
195  Double_t normalization[NETA0][NPHI0];
196  cout << "************************************** NDEP = " << NDEP << " NETA0 = " << NETA0 << " NPHI0 = " << NPHI0
197  << endl;
198 
199  // define max size of massives (to be just NMAXSIZE ):
200  Int_t NMAXSIZE = NMAXM;
201  Float_t X0[NMAXSIZE];
202  TString LEDruns[NMAXSIZE];
203  Double_t XX[NMAXSIZE];
204  Double_t XXE[NMAXSIZE];
205  Double_t XXX[NMAXSIZE];
206  Double_t XXXE[NMAXSIZE];
207  Int_t indWAS[NMAXSIZE];
208 
209  Double_t YY[NMAXSIZE];
210  Double_t YYE[NMAXSIZE];
211  cout << "************************************** NMAXSIZE = " << NMAXSIZE << " NMAXM = " << NMAXM << endl;
212  //----------------------------------------------------------------------
213 
214  Double_t GSMRATIOD2[NMAXSIZE][NETA0][NPHI0];
215 
219  // define where to run inside massives above:
220  // yearcase=0
221  Int_t NMINmM = 0;
222  Int_t NMAXmM = NMAXSIZE - 1;
223  Int_t NMAXaM = NMAXSIZE;
224  if (yearcase == 1) {
225  // 2016 only: yearcase=1
226  NMINmM = 0;
227  NMAXmM = 46;
228  NMAXaM = 47; // M
229  } else if (yearcase == 2) {
230  // 2017 only:: yearcase=2
231  NMINmM = 53;
232  NMAXmM = 93;
233  NMAXaM = 41; // M
234  } else if (yearcase == 3) {
235  // 20167 only:: yearcase=3
236  NMINmM = 0;
237  NMAXmM = 93;
238  NMAXaM = 94; // M
239  } else if (yearcase == 4) {
240  // 2018 only:: yearcase=4
241  NMINmM = 94;
242  NMAXmM = -1;
243  NMAXaM = -1; // M
244  } else if (yearcase == 5) {
245  // 20168 only:: yearcase=5
246  NMINmM = 0;
247  NMAXmM = -1;
248  NMAXaM = -1; // M
249  }
250 
251  cout << "************************************** NMINmM = " << NMINmM << " NMAXmM = " << NMAXmM
252  << " NMAXaM = " << NMAXaM << endl;
253  if (NMINmM == -1 || NMAXmM == -1 || NMAXaM == -1)
254  cout << " STOP !!!!!! NMINmM == -1 || NMAXmM == -1 || NMAXaM == -1 " << endl;
256  Int_t NMAX = 0;
257  NMAX = NMAXaM;
258  // cout << "NMAX= " << NMAX << "NMINmM= " << NMINmM << "NMAXmM= " << NMAXmM <<endl;
259  for (int jjj = NMINmM; jjj <= NMAXmM; jjj++) {
260  LEDruns[jjj - NMINmM] = LEDrunsM[jjj];
261  X0[jjj - NMINmM] = X0M[jjj];
262  // cout << "jjj= " << jjj << " jjj-NMINmM= " << jjj-NMINmM << " LEDrunsM[jjj]= " << LEDrunsM[jjj] << " X0M[jjj]= " << X0M[jjj] <<endl;
263  }
265  //========================================================================================================================
266  //---------------------------------------------------------------------------------------------------------------------
267  //---------------------------------------------------------------------------------------------------------------------
268  // Int_t NP = 22; // for loop over time points(LED runs) NMAX is number of LED runs(time abscissa)
269  Int_t NP = NMAX; // for loop over time points(LED runs) NMAX is number of LED runs(time abscissa)
270  cout << "******************* NP = " << NP << endl;
271  //
272  //--------------------------------------------------------------------------------------------------------------------- !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
273  // take into account for future treatment only channels with <Aijk>_runevents within cutMinA to cutMaxA:
274  // Double_t cutMinA =400.; Double_t cutMaxA = 1200.; // HPD HF only
275 
276  // Double_t cutMinA =0.; Double_t cutMaxA = 999999999999.;
277  // Double_t cutMinA =50000.; Double_t cutMaxA = 150000.;
278  Double_t cutMinA = 100.;
279  Double_t cutMaxA = 5000.;
280 
281  // Double_t cutMinA =9000.; Double_t cutMaxA = 40000.;
282  //
283  // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
284  //---------------------------------------------------------------------------------------------------------------------
285  //------------------------------------ define DELTA (days) of current point wrt first point
286  for (int kk1 = 0; kk1 < NP; kk1++) {
287  XX[kk1] = X0[kk1];
288  int k10 = 0;
289  int z1 = X0[k10];
290  XX[kk1] -= z1;
291  if (verbosity == 2) {
292  cout << "ORDINATE points: kk1 = " << kk1 << " XX[kk1]= " << XX[kk1] << endl;
293  }
294 
295  XXE[kk1] = 0.001 * XX[kk1];
296  } //XXE - errors at fit
297  //-----------------------------------------------------------------------------------------------------
298 
299  //----------------------------------------------------------------------------------------------------
300  //----------------------------------------------------------------------------------------------------
302  for (int jjj = 0; jjj <= 82; jjj++) {
303  for (int kkk = 0; kkk <= 72; kkk++) {
304  mapRATIOD2[jjj][kkk] = 0.;
305  mapRATIOD20[jjj][kkk] = 0.;
306  normalization[jjj][kkk] = 0.;
307 
308  for (int k1 = 0; k1 < NP; k1++) {
309  GSMRATIOD2[k1][jjj][kkk] = mapRATIOD2[jjj][kkk];
310  }
311 
312  for (int iii = 0; iii < NDEP; iii++) {
313  mapRATIO[iii][jjj][kkk] = 0.;
314  // normalization[iii][jjj][kkk] = 0.;
315  }
316 
317  } // for
318  } // for
319 
321 
322  //______________________________________________________________________________
323  // ls -latr /afs/cern.ch/cms/CAF/CMSALCA/ALCA_HCALCALIB/HCALMONITORING/RDMweb/histos/LED_* | less
324 
325  TString fname = "/afs/cern.ch/cms/CAF/CMSALCA/ALCA_HCALCALIB/HCALMONITORING/RDMweb/histos/LED_";
326  // TString fname = "/afs/cern.ch/cms/CAF/CMSALCA/ALCA_HCALCALIB/HCALMONITORING/RDMweb/histos/LASER_";
327 
328  // booking:
329  TH1F* Seff1D = new TH1F("Seff1D", "", 1000, 10., 1010.);
330  TH1F* Ceff1D = new TH1F("Ceff1D", "", 1500, 10., 8010.);
331 
332  TH2F* mapBADchannels = new TH2F("mapBADchannels", " ", 82, -41., 41., 72, 0., 72.);
333  TH2F* mapBADchannels0 = new TH2F("mapBADchannels0", " ", 82, -41., 41., 72, 0., 72.);
334 
335  TH2F* mapchannelsdepth1 = new TH2F("mapchannelsdepth1", " ", 82, -41., 41., 72, 0., 72.);
336  TH2F* mapchannelsdepth2 = new TH2F("mapchannelsdepth2", " ", 82, -41., 41., 72, 0., 72.);
337  TH2F* mapchannelsdepth3 = new TH2F("mapchannelsdepth3", " ", 82, -41., 41., 72, 0., 72.);
338  TH2F* mapchannelsdepth4 = new TH2F("mapchannelsdepth4", " ", 82, -41., 41., 72, 0., 72.);
339 
340  TH1F* gainkoeff = new TH1F("gainkoeff", "", 100, y1, y2);
341  TH1F* gainkoeff0 = new TH1F("gainkoeff0", "", 100, 0.9, 1.1);
342  TH1F* gainkoeff9 = new TH1F("gainkoeff9", "", 100, 0.1, 1.9);
343  TH1F* GOODruns = new TH1F("GOODruns", "", NP, 0., float(NP));
344  TH1F* BADruns = new TH1F("BADruns", "", NP, 0., float(NP));
345  TH1F* NotEmptyDepthes = new TH1F("NotEmptyDepthes", "", 56, 0., 56.);
346 
348  Int_t kmm = 0;
349  Int_t firstrun = 0;
350  //
351  cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! firstrun = " << firstrun << " run = " << LEDruns[firstrun] << endl;
352 
356 
358  cout << "!!!!!!!!!!!!!!!!!!!!!! use root files from official RMT dir. " << endl;
359  // cout << "!!!!!!!!!!!!!!!!!!!!!! use root files from my dir. " <<endl;
361 
362  TH1F* Aeff1D = new TH1F("Aeff1D", "", 250, 0., 500000.);
363  // TH1F* Aeff1D = new TH1F("Aeff1D","", 200, 0.,2000000.);
364  int ck1count = 0;
365  for (int k1 = firstrun; k1 < NP; k1++) {
366  // for(int k1 = 0; k1<NP; k1++) {
367  ck1count++;
369  // my dir.
370  // TString epsName = "root/LEDtest" + LEDruns[k1] + ".root";
371  // TString epsName = "rootshunt1/LEDtest" + LEDruns[k1] + ".root";
372 
373  // RMT:
374  TString epsName = fname + LEDruns[k1] + ".root";
375 
377 
378  TFile* hfile = new TFile(epsName, "READ");
379  // cout << "!!!! read LED run with k1= " << k1 <<" run: " << LEDruns[k1] <<endl;
380  TH1F* Aeff1 = (TH1F*)hfile->Get("h_ADCAmpl_HF");
381 
382  int kx = Aeff1->GetXaxis()->GetNbins();
383  // cout <<"BEGINNING k1= " << k1 <<" kx= " << kx <<endl;
384  int maxvalueA = -1;
385  for (int jjj = 0; jjj < kx; jjj++) {
386  if (double(Aeff1->GetBinContent(jjj)) > 0. && maxvalueA < jjj)
387  maxvalueA = jjj;
388  // cout <<" k1= " << k1 <<" jjj= " << jjj <<" content= " << Aeff1->GetBinContent(jjj) <<endl;
389  Aeff1D->Fill(float(jjj), double(Aeff1->GetBinContent(jjj)));
390  } // for
391  cout << " run = " << LEDruns[k1] << " k1= " << k1 << " max bin value= " << maxvalueA << " ck1count= " << ck1count
392  << endl;
393 
394  //
395  //
396  // display last-run existing histoes:
397  if (k1 == NP - 1) {
398  c1->Clear();
399  c1->Divide(1, 1);
400  c1->cd(1);
401  gPad->SetGridy();
402  gPad->SetGridx();
403  gPad->SetLogy();
404  gStyle->SetOptStat(101110);
405  Aeff1->SetMarkerStyle(20);
406  Aeff1->SetMarkerSize(0.4);
407  Aeff1->GetYaxis()->SetLabelSize(0.04);
408  Aeff1->SetTitle("Last run & events & channels");
409  Aeff1->SetXTitle("Aijk");
410  Aeff1->SetYTitle("N");
411  Aeff1->SetMarkerColor(4);
412  Aeff1->SetLineColor(4);
413  Aeff1->SetMinimum(0.8);
414  Aeff1->Draw("PL");
415  c1->Update();
416  TString fdir = "testamt5gsmHF2018/";
417  // TString plotName = fdir + "Aijk.png";
418  TString plotName = fdir + "Aijk-Run" + LEDruns[k1] + ".png";
419  c1->SaveAs(plotName);
420  cout << "****PLOT AijkLastRun.png is drawn **** " << endl;
421  }
422  // display first runt existing histoes:
423  // if(k1== 0 ) {
424  if (k1 == firstrun) {
425  c1->Clear();
426  c1->Divide(1, 1);
427  c1->cd(1);
428  gPad->SetGridy();
429  gPad->SetGridx();
430  // gPad->SetLogy();
431  gStyle->SetOptStat(101110);
432  Aeff1->SetMarkerStyle(20);
433  Aeff1->SetMarkerSize(0.4);
434  Aeff1->GetYaxis()->SetLabelSize(0.04);
435  Aeff1->SetTitle("First run & events & channels");
436  Aeff1->SetXTitle("Aijk");
437  Aeff1->SetYTitle("N");
438  Aeff1->SetMarkerColor(4);
439  Aeff1->SetLineColor(4);
440  Aeff1->SetMinimum(0.8);
441  Aeff1->Draw("PL");
442  c1->Update();
443  TString fdir = "testamt5gsmHF2018/";
444  TString plotName = fdir + "AijkFirstRun.png";
445  c1->SaveAs(plotName);
446  cout << "****PLOT AijkFirstRun.png is drawn **** " << endl;
447  }
448  // 000000000000000000000000000000000000000000000000000000000000000000000000
449  // TH2F *twod1= (TH2F*)hfile->Get("h_mapDepth1ADCAmpl");
450  // TH2F *twod2= (TH2F*)hfile->Get("h_mapDepth2ADCAmpl");
451  // TH2F *twod3= (TH2F*)hfile->Get("h_mapDepth3ADCAmpl");
452  // 111111111111111111111111111111111111111111111111111111111111111111111111
453  // h_mapDepth1ADCAmpl12 means ADCcounts(massive) within -1 max +1 +2
454 
455  /*
456  TH2F *twod1= (TH2F*)hfile->Get("h_mapDepth1ADCAmpl12_HF");
457  TH2F *twod2= (TH2F*)hfile->Get("h_mapDepth2ADCAmpl12_HF");
458  TH2F *twod3= (TH2F*)hfile->Get("h_mapDepth3ADCAmpl12_HF");
459 */
460  // HFP17 of 2017:
461  // TH2F *twod1= (TH2F*)hfile->Get("h_mapDepth1ADCAmpl12SiPM_HF");
462  // TH2F *twod2= (TH2F*)hfile->Get("h_mapDepth2ADCAmpl12SiPM_HF");
463  // TH2F *twod3= (TH2F*)hfile->Get("h_mapDepth3ADCAmpl12SiPM_HF");
464  // all:
465 
466  TH2F* twod1 = (TH2F*)hfile->Get("h_mapDepth1ADCAmpl12_HF");
467  TH2F* twod2 = (TH2F*)hfile->Get("h_mapDepth2ADCAmpl12_HF");
468  TH2F* twod3 = (TH2F*)hfile->Get("h_mapDepth3ADCAmpl12_HF");
469 
470  TH2F* twod4 = (TH2F*)hfile->Get("h_mapDepth4ADCAmpl12_HF");
471 
472  // all TS bins:
473  // TH2F *twod1= (TH2F*)hfile->Get("h_mapDepth1ADCAmpl_HF");
474  // TH2F *twod2= (TH2F*)hfile->Get("h_mapDepth2ADCAmpl_HF");
475  // TH2F *twod3= (TH2F*)hfile->Get("h_mapDepth3ADCAmpl_HF");
476 
477  // TH2F *twod4= (TH2F*)hfile->Get("h_mapDepth4ADCAmpl_HF");
478 
479  int nx = twod1->GetXaxis()->GetNbins();
480  int ny = twod1->GetYaxis()->GetNbins();
481  // cout <<"BEGINNING k1= " << k1 <<" nx= " << nx <<" ny= " << ny <<endl;
482 
483  TH2F* t0010 = (TH2F*)hfile->Get("h_mapDepth1_HF");
484  TH2F* t0020 = (TH2F*)hfile->Get("h_mapDepth2_HF");
485  TH2F* t0030 = (TH2F*)hfile->Get("h_mapDepth3_HF");
486  TH2F* t0040 = (TH2F*)hfile->Get("h_mapDepth4_HF");
487 
488  TH2F* Ceff1 = (TH2F*)twod1->Clone("Ceff1");
489  TH2F* Ceff2 = (TH2F*)twod2->Clone("Ceff2");
490  TH2F* Ceff3 = (TH2F*)twod3->Clone("Ceff3");
491  TH2F* Ceff4 = (TH2F*)twod4->Clone("Ceff4");
492 
493  // <Aijk>_runevents:
494  Ceff1->Divide(twod1, t0010, 1, 1, "B");
495  Ceff2->Divide(twod2, t0020, 1, 1, "B");
496  Ceff3->Divide(twod3, t0030, 1, 1, "B");
497  Ceff4->Divide(twod4, t0040, 1, 1, "B");
498  // Ceff1->Sumw2();Ceff2->Sumw2();Ceff3->Sumw2();
500  for (int jjj = 0; jjj < nx; jjj++) {
501  for (int kkk = 0; kkk < ny; kkk++) {
502  // HFP17 selection:
503  if (flagHFP17selection == 0 ||
504  (flagHFP17selection == 1 && (((jjj > 56 && jjj < 62) && (kkk > 63 && kkk < 68)) ||
505  ((jjj > 61 && jjj < 71) && (kkk == 64 || kkk == 66)))) ||
506  (flagHFP17selection == 2 && !(((jjj > 14 && jjj < 25) && (kkk > 55 && kkk < 64))))) {
507  // if(Ceff1->GetBinContent(jjj,kkk) !=0.) cout <<" k1=111111 " << k1 <<" eta= " << jjj <<" phi= " << kkk <<" Ceff1= " << Ceff1->GetBinContent(jjj,kkk) <<endl;
508  // if(Ceff7->GetBinContent(jjj,kkk) !=0.) cout <<" k1=77777777777 " << k1 <<" eta= " << jjj <<" phi= " << kkk <<" Ceff7= " << Ceff7->GetBinContent(jjj,kkk) <<endl;
509  if (Ceff1->GetBinContent(jjj, kkk) > 0.)
510  mapchannelsdepth1->Fill(double(jjj) - 41., double(kkk), Ceff1->GetBinContent(jjj, kkk));
511  if (Ceff2->GetBinContent(jjj, kkk) > 0.)
512  mapchannelsdepth2->Fill(double(jjj) - 41., double(kkk), Ceff2->GetBinContent(jjj, kkk));
513  if (Ceff3->GetBinContent(jjj, kkk) > 0.)
514  mapchannelsdepth3->Fill(double(jjj) - 41., double(kkk), Ceff3->GetBinContent(jjj, kkk));
515  if (Ceff4->GetBinContent(jjj, kkk) > 0.)
516  mapchannelsdepth4->Fill(double(jjj) - 41., double(kkk), Ceff4->GetBinContent(jjj, kkk));
517  } // if HFP17 selection
518  } // for
519  } // for
521  // }
522 
523  //
524  //
525  // fill:
526  // fill massive <Aijk>_runevents , where iii=depth, jjj=eta, kkk=phi
527  for (int jjj = 0; jjj < nx; jjj++) {
528  for (int kkk = 0; kkk < ny; kkk++) {
529  //
530  // HFP17 selection:
531  if (flagHFP17selection == 0 ||
532  (flagHFP17selection == 1 && (((jjj > 56 && jjj < 62) && (kkk > 63 && kkk < 68)) ||
533  ((jjj > 61 && jjj < 71) && (kkk == 64 || kkk == 66)))) ||
534  (flagHFP17selection == 2 && !(((jjj > 14 && jjj < 25) && (kkk > 55 && kkk < 64))))) {
535  // FILL NEW PLOTS:
536  // Aijk: Ceff1D & Seff1D plots
537  if (Ceff1->GetBinContent(jjj, kkk) != 0.) {
538  Ceff1D->Fill(Ceff1->GetBinContent(jjj, kkk));
539  Seff1D->Fill(Ceff1->GetBinContent(jjj, kkk));
540  }
541  if (Ceff2->GetBinContent(jjj, kkk) != 0.) {
542  Ceff1D->Fill(Ceff2->GetBinContent(jjj, kkk));
543  Seff1D->Fill(Ceff2->GetBinContent(jjj, kkk));
544  }
545  if (Ceff3->GetBinContent(jjj, kkk) != 0.) {
546  Ceff1D->Fill(Ceff3->GetBinContent(jjj, kkk));
547  Seff1D->Fill(Ceff3->GetBinContent(jjj, kkk));
548  }
549  if (Ceff4->GetBinContent(jjj, kkk) != 0.) {
550  Ceff1D->Fill(Ceff4->GetBinContent(jjj, kkk));
551  Seff1D->Fill(Ceff4->GetBinContent(jjj, kkk));
552  }
553  } //if
554  }
555  }
556 
557  //--------------------------------------
558  // take into account for future treatment only HFP17 channels and cuts on <Aijk>_runevents within cutMinA to cutMaxA:
559  // apply cut on <Aijk>_runevents
560  // -41 +41
561  // 82 bins
562  for (int jjj = 0; jjj < nx; jjj++) {
563  for (int kkk = 0; kkk < ny; kkk++) {
564  // HFP17 selection:
565  if (flagHFP17selection == 0 ||
566  (flagHFP17selection == 1 && (((jjj > 56 && jjj < 62) && (kkk > 63 && kkk < 68)) ||
567  ((jjj > 61 && jjj < 71) && (kkk == 64 || kkk == 66)))) ||
568  (flagHFP17selection == 2 && !(((jjj > 14 && jjj < 25) && (kkk > 55 && kkk < 64))))) {
569  if (Ceff1->GetBinContent(jjj, kkk) > cutMinA && Ceff1->GetBinContent(jjj, kkk) < cutMaxA)
570  mapRATIO[1][jjj][kkk] = Ceff1->GetBinContent(jjj, kkk);
571  if (Ceff2->GetBinContent(jjj, kkk) > cutMinA && Ceff2->GetBinContent(jjj, kkk) < cutMaxA)
572  mapRATIO[2][jjj][kkk] = Ceff2->GetBinContent(jjj, kkk);
573  if (Ceff3->GetBinContent(jjj, kkk) > cutMinA && Ceff3->GetBinContent(jjj, kkk) < cutMaxA)
574  mapRATIO[3][jjj][kkk] = Ceff3->GetBinContent(jjj, kkk);
575  if (Ceff4->GetBinContent(jjj, kkk) > cutMinA && Ceff4->GetBinContent(jjj, kkk) < cutMaxA)
576  mapRATIO[4][jjj][kkk] = Ceff4->GetBinContent(jjj, kkk);
577  } //if
578  } // for
579  } // for
581  /*
582  // define A for refRun : k1=[0]
584  if(k1==firstrun && kmm==0 ) {
585  kmm=1; //Int_t mcount=0;
586  cout<<"* to be printed once only CHFCK IT please ************ kmm = " << kmm <<endl;
587  for(int iii = 1; iii<4; iii++) {
588 // for (int jjj=1;jjj<=82;jjj++) {
589 // for (int kkk=1;kkk<=72;kkk++) {
590  for (int jjj=0;jjj<nx;jjj++) {
591  for (int kkk=0;kkk<ny;kkk++) {
592  normalization[iii][jjj][kkk] = mapRATIO[iii][jjj][kkk];
593  }//for
594  }//for
595  }//for
596  }// if(k1=firstrun
597 */
598  //--------------------------------------
599  // then, averaging over depthes, but first sum over depthes before!!! any dividing. Use mapRATIOD2[jjj][kkk] and mapRATIOD20[jjj][kkk]
601  int totalhep17count = 0;
602  int totalhep17count1 = 0;
603  int totalhep17count2 = 0;
604  int totalhep17count3 = 0;
605  int totalhep17count4 = 0;
606  int totalhep17count5 = 0;
607  int totalhep17count6 = 0;
608  int totalhep17count7 = 0;
609  for (int iii = 1; iii < NDEP; iii++) {
610  for (int jjj = 0; jjj < nx; jjj++) {
611  for (int kkk = 0; kkk < ny; kkk++) {
612  // for (int jjj=1;jjj<=82;jjj++) {
613  // for (int kkk=1;kkk<=72;kkk++) {
614  if (mapRATIO[iii][jjj][kkk] > 0) {
615  // calculate # channels in HFP17 for each depth:
616  totalhep17count++;
617  if (verbosity == 4 && k1 == 0) {
618  cout << " k1= " << k1 << " depth= " << iii << " eta= " << jjj << " phi= " << kkk
619  << " mapRATIO= " << mapRATIO[iii][jjj][kkk] << endl;
620  }
621  if (iii == 1)
622  totalhep17count1++;
623  if (iii == 2)
624  totalhep17count2++;
625  if (iii == 3)
626  totalhep17count3++;
627  if (iii == 4)
628  totalhep17count4++;
629  if (iii == 5)
630  totalhep17count5++;
631  if (iii == 6)
632  totalhep17count6++;
633  if (iii == 7)
634  totalhep17count7++;
635  // ---------------------------------------- sum over depthes before!!! any dividing:
636  mapRATIOD2[jjj][kkk] += mapRATIO[iii][jjj][kkk];
637  // count entries with digis only:
638  mapRATIOD20[jjj][kkk]++;
639  if (verbosity == 3 && iii == 3)
640  cout << " depth = " << iii << " k1 = " << k1 << " eta = " << jjj
641  << " mapRATIOD2[jjj][kkk] = " << mapRATIOD2[jjj][kkk] << " #entries = " << mapRATIOD20[jjj][kkk]
642  << " mapRATIO[iii][jjj][kkk] = " << mapRATIO[iii][jjj][kkk] << endl;
643  } // if mapRATIO[iii][jjj][kkk] != 0
644  } //for
645  } //for
646  } //for
647 
648  // ERROR printout !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
649  // if(totalhep17count != 184 ) {cout <<"!!!!!! ERROR:NOT ALL CHANNELS HFP17 INVOLEVED FOR RUN WITH k1= " << k1 <<" totalhep17count= " << totalhep17count <<endl;}
650 
651  if (verbosity == 4 && k1 == 0) {
652  cout << " k1= " << k1 << " totalhep17count= " << totalhep17count << endl;
653  cout << " k1= " << k1 << " totalhep17count1= " << totalhep17count1 << endl;
654  cout << " k1= " << k1 << " totalhep17count2= " << totalhep17count2 << endl;
655  cout << " k1= " << k1 << " totalhep17count3= " << totalhep17count3 << endl;
656  cout << " k1= " << k1 << " totalhep17count4= " << totalhep17count4 << endl;
657  cout << " k1= " << k1 << " totalhep17count5= " << totalhep17count5 << endl;
658  cout << " k1= " << k1 << " totalhep17count6= " << totalhep17count6 << endl;
659  cout << " k1= " << k1 << " totalhep17count7= " << totalhep17count7 << endl;
660  }
661 
664  Int_t depthAVERAGEcount = 0;
665  for (int jjj = 0; jjj < nx; jjj++) {
666  for (int kkk = 0; kkk < ny; kkk++) {
667  // for (int jjj=1;jjj<=82;jjj++) {
668  //for(int kkk=1;kkk<=72;kkk++) {
669  depthAVERAGEcount = 4 * (jjj - 57) + (kkk - 64);
670  if (mapRATIOD20[jjj][kkk] != 0) {
671  NotEmptyDepthes->Fill(float(depthAVERAGEcount));
672  if (verbosity == 1)
673  cout << "****aver per depthes********* phi = " << kkk << " RunIndex = " << k1 << " eta = " << jjj
674  << " #entries = " << mapRATIOD20[jjj][kkk] << endl;
675  mapRATIOD2[jjj][kkk] /= mapRATIOD20[jjj][kkk];
676  if (verbosity == 3 && kkk == 3)
677  cout << "****aver per depthes********* phi = " << jjj << " RunIndex = " << k1 << " eta = " << jjj
678  << " Nphi = " << mapRATIOD20[jjj][kkk] << endl;
679  } // if(mapRATIOD20 != 0
680  } //for kkk
681  } //for jjj
683  // define A for refRun : k1=[0]
685  if (k1 == firstrun && kmm == 0) {
686  kmm = 1; //Int_t mcount=0;
687  cout << "* to be printed once only CHFCK IT please ************ kmm = " << kmm << endl;
688  // for (int jjj=1;jjj<=82;jjj++) {
689  // for (int kkk=1;kkk<=72;kkk++) {
690  for (int jjj = 0; jjj < nx; jjj++) {
691  for (int kkk = 0; kkk < ny; kkk++) {
692  normalization[jjj][kkk] = mapRATIOD2[jjj][kkk];
693  } //for
694  } //for
695  } // if(k1=firstrun
696  //--------------------------------------
699  // int etaphicount = 0;
700  // for (int jjj=1;jjj<=82;jjj++) {
701  // for (int kkk=1;kkk<=72;kkk++) {
702  for (int jjj = 0; jjj < nx; jjj++) {
703  for (int kkk = 0; kkk < ny; kkk++) {
704  if (normalization[jjj][kkk] != 0) {
705  GSMRATIOD2[k1][jjj][kkk] = mapRATIOD2[jjj][kkk] / normalization[jjj][kkk];
706  // plotting:
707  if (GSMRATIOD2[k1][jjj][kkk] < RrangeMAX && GSMRATIOD2[k1][jjj][kkk] > RrangeMIN) {
708  gainkoeff->Fill(GSMRATIOD2[k1][jjj][kkk]);
709  gainkoeff0->Fill(GSMRATIOD2[k1][jjj][kkk]);
710  gainkoeff9->Fill(GSMRATIOD2[k1][jjj][kkk]);
711  // printout
712  // etaphicount++;
713  // if(etaphicount > 30 ) cout <<"etaphicount = " << etaphicount << "for k1= " << k1 <<endl;
714  // if(etaphicount == 30 ) cout <<"etaphicount == 30 for k1= " << k1 <<endl;
715  // cout <<" k1= " << k1 <<" eta= " << jjj <<" phi= " << kkk <<endl;
716  GOODruns->Fill(float(k1)); // fill #channels w/ R inside unit
717  } else {
718  if (GSMRATIOD2[k1][jjj][kkk] > 0.)
719  BADruns->Fill(float(k1));
720  } // fill #channels outside R unit
721  // else{if(GSMRATIOD2[k1][jjj][kkk]>0.) BADruns->Fill(float(k1));}
722 
723  } // if(normalization[jjj][kkk] != 0
724  } //for kkk
725  } //for jjj
726 
727  //
733  for (int jjj = 0; jjj <= 82; jjj++) {
734  for (int kkk = 0; kkk <= 72; kkk++) {
735  mapRATIOD2[jjj][kkk] = 0.;
736  mapRATIOD20[jjj][kkk] = 0.;
737  for (int iii = 0; iii < NDEP; iii++) {
738  mapRATIO[iii][jjj][kkk] = 0.;
739  }
740  } // for
741  } // for
742 
744  hfile->Close();
746 
747  // }//if(k1==0 || (k1>37
749  } //for k1 loop over time points(LED runs)
750  cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DONE: last LED run READ " << endl;
751 
752  // c1->Clear();
753 
754  // ////////////////////////////////////////////////////////////////////////////////////////////////// END OF LOOP OVER LED RUNS
758 
764  cout << "**** **** **** **** **** Draw Dependencies: *** " << endl;
765 
767  Int_t Method = NMethodsStart;
768  while (Method < NMethodsToUse + 1) {
769  if (Method != 9999992) {
770  cout << " **** START Method " << Method << endl;
771  //======================================================================================================= PLOT0: <Aijk> for each event and all LED runs
772  if (Method == 0) {
773  cout << "****Draw 0 Dependencies: <Aijk> for each event and all LED runs *** " << endl;
774  gPad->SetGridy();
775  gPad->SetGridx();
776  gPad->SetLogy();
777  gStyle->SetOptStat(101110);
778  Ceff1D->SetMarkerStyle(20);
779  Ceff1D->SetMarkerSize(0.4);
780  Ceff1D->GetYaxis()->SetLabelSize(0.04);
781  Ceff1D->SetTitle("all runs & channels");
782  Ceff1D->SetXTitle("<Aijk>");
783  Ceff1D->SetYTitle("N");
784  Ceff1D->SetMarkerColor(4);
785  Ceff1D->SetLineColor(4);
786  // Ceff1D->Draw("Error");
787  Ceff1D->Draw("PL");
788  } //Method = 0
789  //======================================================================================================= PLOT1: <Aijk> for each event and all LED runs ZOOM
790  if (Method == 1) {
791  cout << "****Draw 1 Dependencies: <Aijk> for each event and all LED runs ZOOM *** " << endl;
792  gPad->SetGridy();
793  gPad->SetGridx();
794  gPad->SetLogy();
795  gStyle->SetOptStat(101110);
796  // Seff1D->SetTitle("any Error, HF Depth1 \n");
797  Seff1D->SetMarkerStyle(20);
798  Seff1D->SetMarkerSize(0.4);
799  Seff1D->GetYaxis()->SetLabelSize(0.04);
800  Seff1D->SetTitle("ZOOM all runs & channels");
801  Seff1D->SetXTitle("<Aijk> ZOOM ");
802  Seff1D->SetYTitle("N");
803  Seff1D->SetMarkerColor(4);
804  Seff1D->SetLineColor(4);
805  // Seff1D->Draw("Error");
806  Seff1D->Draw("PL");
807  } //Method = 1
808  // //////////////////////////////////////////////////////////////////////////
809  //======================================================================================================= PLOT2 GSM ratio vs days
810  if (Method == 2) {
811  cout << "****Draw 2 Dependencies: GSM ratio vs days *** " << endl;
812  for (int k1 = 0; k1 < NP; k1++) {
813  YY[k1] = 0.;
814  }
815  // c1->Range(0,0,25,18);
816  // c1->SetFillColor(0);
817  // c1->Clear();
818  TPad* pad1 = new TPad("pad1", "This is pad1", 0.02, 0.02, 0.99, 0.99, 0);
819  pad1->Draw();
820  pad1->cd();
821  pad1->Range(-0.255174, -19.25, 2.29657, -6.75);
822  // x1 y1 x2 y2
823  pad1->DrawFrame(x1, y1, x2, y2); // 1-A,
824  // pad1->DrawFrame(1, 0., 370, 2.0); // 1-A,
825  pad1->GetFrame()->SetFillColor(0);
826  pad1->Draw();
827  gPad->SetGridy();
828  gPad->SetGridx();
829  // - - - - - - - - - - - -
830  Int_t colorlines = 0;
831  Int_t generalcount = 0;
832  // for (int jjj=1;jjj<=82;jjj++) {
833  // for (int kkk=1;kkk<=72;kkk++) {
834  for (int jjj = 0; jjj < 82; jjj++) {
835  for (int kkk = 0; kkk < 72; kkk++) {
836  Int_t sscount = -1;
837  for (int k1 = 0; k1 < NP; k1++) {
838  if (GSMRATIOD2[k1][jjj][kkk] != 0) {
839  // if(GSMRATIOD2[k1][jjj][kkk]< 1.033 && GSMRATIOD2[k1][jjj][kkk] > 0.91 ) {
840  // if(GSMRATIOD2[k1][jjj][kkk]< 9. && GSMRATIOD2[k1][jjj][kkk] > 0. ) {
841  if (GSMRATIOD2[k1][jjj][kkk] < RrangeMAX && GSMRATIOD2[k1][jjj][kkk] > RrangeMIN) {
842  // if(GSMRATIOD2[k1][jjj][kkk]< 1.05 && GSMRATIOD2[k1][jjj][kkk] > 0.91 ) {
843  // if(GSMRATIOD2[k1][jjj][kkk]< 1.15 && GSMRATIOD2[k1][jjj][kkk] > 0.85 ) {
844  sscount++;
845  YY[sscount] = GSMRATIOD2[k1][jjj][kkk]; //
846  XXX[sscount] = XX[k1];
847  indWAS[sscount] = k1;
848  mapBADchannels->Fill(double(jjj) - 42., double(kkk) - 1., GSMRATIOD2[k1][jjj][kkk]);
849  mapBADchannels0->Fill(double(jjj) - 42., double(kkk) - 1., 1.);
850  } // GSMRATIOD2[k1][jjj][kkk] < 1.05
851  else {
852  // mapBADchannels->Fill(double(jjj)-42., double(kkk)-1., GSMRATIOD2[k1][jjj][kkk]);
853  }
854  } // GSMRATIOD2[k1][jjj][kkk] != 0
855  } //for k1
856  Int_t MMcount = sscount + 1;
857  if (MMcount > 0) {
858  generalcount++;
859  if (generalcount == 1 && verbosity == 2)
860  for (int k1 = 0; k1 < MMcount; k1++) {
861  cout << "**** All GOOD runs: indWAS[k1](1,..) = " << indWAS[k1] + 1 << " XXX[k1]+1 = " << XXX[k1] + 1
862  << endl;
863  }
864  gr1 = new TGraph(MMcount, XXX, YY);
865  colorlines = generalcount / 5. + 2;
866  gr1->SetLineColor(colorlines);
867  gr1->SetMarkerColor(colorlines);
868  gr1->SetMarkerStyle(20);
869  gr1->SetMarkerSize(1.2);
870  gr1->SetFillStyle(0);
871  gr1->GetXaxis()->SetTitle("days");
872  gr1->GetYaxis()->SetTitle("R");
873  gr1->Draw("PL");
874  } // if
875  // else {cout<<"****ERROR for PLOT2: MMcount is lower 1, MMcount = *** " << MMcount << endl;}
876  } //for kkk
877  } //for jjj
878 
879  // TLegend leg(.6,.67,.78,.88, " HFP Depth1");
880  // TLegend leg(xx1,yy1,xx2,yy2, "HFP17: R vs t");
881  TLegend leg(xx1, yy1, xx2, yy2, "HF: R vs t(days)");
882  // leg.AddEntry(gr1);
883  leg.SetMargin(0.3);
884  leg.SetBorderSize(1);
885  leg.DrawClone("Same");
886  /*
887  // Draw labels on the y axis
888  TText *t7 = new TText();
889  t7->SetTextAlign(32);
890  t7->SetTextSize(0.035);
891  t7->SetTextFont(72);
892  char *labels[NP+1] = {"31","1","7","7","8","9","12","13","19","22","22","24","24","24","24","24","24","Feb."};
893  float X7[NP];
894  for(int k1 = 0; k1<NP; k1++) {
895  // cout<<"**** XXX[k1] = " << XXX[k1] <<" YY[k1] = " << YY[k1] << endl;
896  t7->DrawText(0.2+XXX[k1],0.890,labels[k1]);
897  }
898  t7->DrawText(0.2+XXX[NP-1]+75.,0.890,labels[NP]);
899 */
900 
901  }
902  //
903 
904  //======================================================================================================= PLOT3: 2D SiPM channels
905  if (Method == 3) {
906  cout << "****Draw 3 Dependencies: 2D SiPM channels *** " << endl;
907  TH2F* Cdepth2hbff = (TH2F*)mapBADchannels->Clone("Cdepth2hbff");
908  Cdepth2hbff->Divide(mapBADchannels, mapBADchannels0, 1, 1, "B");
909  Cdepth2hbff->Sumw2();
910  gPad->SetGridy();
911  gPad->SetGridx();
912  gStyle->SetOptStat(0000000);
913  Cdepth2hbff->SetMarkerStyle(20);
914  Cdepth2hbff->SetMarkerSize(0.4);
915  Cdepth2hbff->GetYaxis()->SetLabelSize(0.04);
916  Cdepth2hbff->SetTitle("within R & Weighted by R");
917  Cdepth2hbff->SetXTitle("#eta \b");
918  Cdepth2hbff->SetYTitle("#phi \b");
919  Cdepth2hbff->SetMarkerColor(4);
920  Cdepth2hbff->SetLineColor(4);
921  Cdepth2hbff->Draw("COLZ");
922  } //Method = 3
923  //======================================================================================================= PLOT4:gains LED runs
924  if (Method == 4) {
925  cout << "****Draw 4 Dependencies: gains LED runs *** " << endl;
926  gPad->SetGridy();
927  gPad->SetGridx();
928  // gPad->SetLogy();
929  //gStyle->SetOptStat(1110000);
930  gStyle->SetOptStat(1100); // only mean & rms
931  //gStyle->SetOptStat(1111111);// only mean & rms
932  gainkoeff->SetMarkerStyle(20);
933  gainkoeff->SetMarkerSize(0.4);
934  gainkoeff->GetYaxis()->SetLabelSize(0.04);
935  gainkoeff->SetXTitle("gains");
936  gainkoeff->SetYTitle("N");
937  gainkoeff->SetMarkerColor(4);
938  gainkoeff->SetLineColor(4);
939  // gainkoeff->Draw("Error");
940  gainkoeff->Draw("PL");
941  } //Method = 4
942  //======================================================================================================= PLOT5:gains LED runs
943  if (Method == 5) {
944  cout << "****Draw 5 Dependencies: gains LED runs *** " << endl;
945  gPad->SetGridy();
946  gPad->SetGridx();
947  gPad->SetLogy();
948  //gStyle->SetOptStat(1110000);
949  gStyle->SetOptStat(1100); // only mean & rms
950  //gStyle->SetOptStat(1111111);// only mean & rms
951  gainkoeff9->SetMarkerStyle(20);
952  gainkoeff9->SetMarkerSize(0.4);
953  gainkoeff9->GetYaxis()->SetLabelSize(0.04);
954  gainkoeff9->SetXTitle("gains");
955  gainkoeff9->SetYTitle("N");
956  gainkoeff9->SetMarkerColor(4);
957  gainkoeff9->SetLineColor(4);
958  // gainkoeff9->Draw("Error");
959  gainkoeff9->Draw("PL");
960  } //Method = 5
961  //======================================================================================================= PLOT6:gains LED runs
962  if (Method == 6) {
963  cout << "****Draw 6 Dependencies: gains LED runs *** " << endl;
964  gPad->SetGridy();
965  gPad->SetGridx();
966  gPad->SetLogy();
967  //gStyle->SetOptStat(1110000);
968  gStyle->SetOptStat(1100); // only mean & rms
969  //gStyle->SetOptStat(1111111);// only mean & rms
970  gainkoeff0->SetMarkerStyle(20);
971  gainkoeff0->SetMarkerSize(0.4);
972  gainkoeff0->GetYaxis()->SetLabelSize(0.04);
973  gainkoeff0->SetXTitle("gains");
974  gainkoeff0->SetYTitle("N");
975  gainkoeff0->SetMarkerColor(4);
976  gainkoeff0->SetLineColor(4);
977  // gainkoeff0->Draw("Error");
978  gainkoeff0->Draw("PL");
979  } //Method = 6
980  //======================================================================================================= PLOT7: BADruns
981  if (Method == 7) {
982  cout << "****Draw 7 Dependencies: BADruns *** " << endl;
983  gPad->Update();
984  gPad->SetGridy();
985  gPad->SetGridx();
986  gPad->SetLogy(kFALSE);
987  gStyle->SetOptStat(101110);
988  BADruns->SetMarkerStyle(20);
989  BADruns->SetMarkerSize(0.4);
990  BADruns->GetYaxis()->SetLabelSize(0.04);
991  BADruns->SetTitle("#channels outside Rrange VS iRun");
992  BADruns->SetXTitle("iRun");
993  BADruns->SetYTitle("#channels");
994  BADruns->SetMarkerColor(4);
995  BADruns->SetLineColor(4);
996  // BADruns->Draw("Error");
997  BADruns->Draw("PL");
998  // PRINTOUT ONLY:
999  // if(verbosity == 4 ){
1000  int cx = BADruns->GetXaxis()->GetNbins();
1001  cout << "***** ************* Number of runs w/ R outside unit-range = " << cx << endl;
1002  int nbadruns = 0;
1003  for (int jjj = 1; jjj <= cx; jjj++) {
1004  if (BADruns->GetBinContent(jjj) > 200.) {
1005  cout << "BADruns w/ content>60: jjj= " << jjj << " run= " << LEDruns[jjj - 1]
1006  << " R ouside unit-range for # channels= " << BADruns->GetBinContent(jjj) << endl;
1007  ++nbadruns;
1008  }
1009  // if( BADruns->GetBinContent(jjj) >8.) {cout<<"BADruns w/ content>60: jjj= " << jjj <<" run= " << LEDruns[jjj-1] <<" R ouside unit-range for # channels= " << BADruns->GetBinContent(jjj) <<endl;++nbadruns;}
1010  } //jjj
1011  cout << "BADruns w/ content>60 nbadruns= " << nbadruns << endl;
1012  // }// if(verbosity == 2 )
1013  } //Method = 7
1014 
1015  //======================================================================================================= PLOT8: Goodruns
1016  if (Method == 8) {
1017  cout << "****Draw 8 Dependencies: Goodruns *** " << endl;
1018  gPad->SetGridy();
1019  gPad->SetGridx();
1020  // gPad->SetLogy();
1021  gStyle->SetOptStat(101110);
1022  GOODruns->SetMarkerStyle(20);
1023  GOODruns->SetMarkerSize(0.4);
1024  GOODruns->GetYaxis()->SetLabelSize(0.04);
1025  GOODruns->SetTitle("#channels inside Rrange VS iRun");
1026  GOODruns->SetXTitle("iRun");
1027  GOODruns->SetYTitle("#channels");
1028  GOODruns->SetMarkerColor(4);
1029  GOODruns->SetLineColor(4);
1030  // GOODruns->Draw("Error");
1031  GOODruns->Draw("PL");
1032  // PRINTOUT ONLY:
1033  // if(verbosity == 4 ){
1034  int cx = GOODruns->GetXaxis()->GetNbins();
1035  cout << "************* cx = " << cx << endl;
1036  for (int jjj = 0; jjj <= cx; jjj++) {
1037  // if( GOODruns->GetBinContent(jjj) >100.) cout<<"GOODruns: k1= " << jjj <<endl;
1038  // if( GOODruns->GetBinContent(jjj) >5.) cout<<"GOODruns: k1= " << jjj <<endl;
1039  if (GOODruns->GetBinContent(jjj) > 1400.)
1040  cout << "GOODruns: k1(0,...)= " << jjj
1041  << " GOODruns->GetBinContent(jjj)= " << GOODruns->GetBinContent(jjj) << endl;
1042  } //jjj
1043  // }// if(verbosity == 2 )
1044  } //Method = 8
1045 
1046  //======================================================================================================= PLOT9:depthes with zero A
1047  if (Method == 9) {
1048  cout << "****Draw 9 Dependencies: depthes with zero A *** " << endl;
1049  gPad->SetGridy();
1050  gPad->SetGridx();
1051  gPad->SetLogy(kFALSE);
1052  gStyle->SetOptStat(1110000);
1053  NotEmptyDepthes->SetMarkerStyle(20);
1054  NotEmptyDepthes->SetMarkerSize(0.4);
1055  NotEmptyDepthes->GetYaxis()->SetLabelSize(0.04);
1056  NotEmptyDepthes->SetTitle("# Not Empty Channels in etq-phi projection");
1057  NotEmptyDepthes->SetXTitle("4*(eta-57)+(phi-64)");
1058  NotEmptyDepthes->SetYTitle("N");
1059  NotEmptyDepthes->SetMarkerColor(4);
1060  NotEmptyDepthes->SetLineColor(4);
1061  // NotEmptyDepthes->Draw("Error");
1062  NotEmptyDepthes->Draw("PL");
1063  } //Method = 9
1064  //======================================================================================================= PLOT10: Aijk for each event and all LED runs
1065  if (Method == 10) {
1066  cout << "****Draw 10 Dependencies: Aijk for each event and all LED runs *** " << endl;
1067 
1068  c1->Clear();
1069  c1->Divide(1, 1);
1070 
1071  c1->cd(1);
1072  // TString epsName = fname + LEDruns[0] +".root";
1073  // TFile *hfile= new TFile(epsName, "READ");
1074  // TH1F * Aeff1D= (TH1F*)hfile->Get("h_ADCAmpl_HF");
1075 
1076  gPad->SetGridy();
1077  gPad->SetGridx();
1078  gPad->SetLogy();
1079  gStyle->SetOptStat(101110);
1080  // Aeff1D->SetStats(0);
1081  Aeff1D->SetMarkerStyle(20);
1082  Aeff1D->SetMarkerSize(0.4);
1083  Aeff1D->GetYaxis()->SetLabelSize(0.04);
1084  Aeff1D->SetTitle("all runs & events& channels");
1085  Aeff1D->SetXTitle("Aijk");
1086  Aeff1D->SetYTitle("N");
1087  Aeff1D->SetMarkerColor(4);
1088  Aeff1D->SetLineColor(4);
1089  // Aeff1D->Draw("Error");
1090  // Aeff1D->Draw("PL");
1091  Aeff1D->SetMinimum(0.8);
1092  Aeff1D->Draw("");
1093 
1094  c1->Update();
1095 
1096  } //Method = 10
1097  //======================================================================================================= PLOT11: 2D SiPM channels Depthes1,2,3,4
1098  if (Method == 11) {
1099  cout << "****Draw 11 <A>: 2D Depthes1,2,3,4 *** " << endl;
1100  // gPad->SetGridy();
1101  // gPad->SetGridx();
1102  // gStyle->SetOptStat(0000000);
1103  c1->Clear();
1104  c1->Divide(2, 2);
1105 
1106  c1->cd(1);
1107  mapchannelsdepth1->SetStats(0);
1108  mapchannelsdepth1->SetTitle("<A> Depth1");
1109  mapchannelsdepth1->SetXTitle("#eta \b");
1110  mapchannelsdepth1->SetYTitle("#phi \b");
1111  mapchannelsdepth1->Draw("COLZ");
1112  c1->cd(2);
1113  mapchannelsdepth2->SetStats(0);
1114  mapchannelsdepth2->SetTitle("<A> Depth2");
1115  mapchannelsdepth2->SetXTitle("#eta \b");
1116  mapchannelsdepth2->SetYTitle("#phi \b");
1117  mapchannelsdepth2->Draw("COLZ");
1118  c1->cd(3);
1119  mapchannelsdepth3->SetStats(0);
1120  mapchannelsdepth3->SetTitle("<A> Depth3");
1121  mapchannelsdepth3->SetXTitle("#eta \b");
1122  mapchannelsdepth3->SetYTitle("#phi \b");
1123  mapchannelsdepth3->Draw("COLZ");
1124  c1->cd(4);
1125  mapchannelsdepth4->SetStats(0);
1126  mapchannelsdepth4->SetTitle("<A> Depth4");
1127  mapchannelsdepth4->SetXTitle("#eta \b");
1128  mapchannelsdepth4->SetYTitle("#phi \b");
1129  mapchannelsdepth4->Draw("COLZ");
1130 
1131  c1->Update();
1132 
1133  } //Method = 11
1134  //======================================================================================================= PLOT12:
1135  if (Method == 12) {
1136  cout << "****Draw 12 not used yet *** " << endl;
1137  // gPad->SetGridy();
1138  // gPad->SetGridx();
1139  // gStyle->SetOptStat(0000000);
1140  c1->Clear();
1141  c1->Divide(2, 2);
1142 
1143  c1->cd(1);
1144  c1->cd(2);
1145  c1->cd(3);
1146 
1147  c1->Update();
1148 
1149  } //Method = 12
1150 
1151  //======================================================================================================= PLOT13: 2D SiPM channels Depthes5,6,7
1152  if (Method == 13) {
1153  cout << "****Draw 13 function, fC *** " << endl;
1154  c1->Clear();
1155  c1->Divide(1, 1);
1156 
1157  c1->cd(1);
1158  {
1159  double c0 = 1.000000;
1160  double b1 = 2.71238e-05;
1161  double a2 = 1.32877e-10;
1162  Int_t n = 50;
1163  Double_t x[n], y[n];
1164  for (Int_t i = 0; i < n; i++) {
1165  x[i] = (i + 1) * 20000.;
1166  y[i] = a2 * x[i] * x[i] / 40. / 40. + b1 * x[i] / 40. + c0;
1167  }
1168 
1169  // create graph
1170  TGraph* gr = new TGraph(n, x, y);
1171 
1172  // draw the graph with axis, continuous line, and put
1173  // a * at each point
1174  gPad->SetGridy();
1175  gPad->SetGridx();
1176  // gPad->SetLogy();
1177  gr->Draw("AC*");
1178  /*
1179  gr1 = new TGraph(MMcount,XXX,YY);
1180  colorlines = generalcount/5.+2;
1181  gr1->SetLineColor(colorlines); gr1->SetMarkerColor(colorlines);
1182  gr1->SetMarkerStyle(20); gr1->SetMarkerSize(1.2); gr1->SetFillStyle(0); gr1->Draw("PL");
1183  */
1184  }
1185 
1186  c1->Update();
1187 
1188  } //Method = 13
1189 
1190  // //////////////////////////////////////////////////////////////////////////
1191 
1192  //=======================================================================================================
1193  //======================================================================================================= finish loop over Methods
1194  //=======================================================================================================
1195  TString fdir = "testamt5gsmHF2018/";
1196  //
1197  TString plotName = fdir + MethodName[Method] + ".png";
1198  c1->SaveAs(plotName);
1199  cout << "****PLOT " << Method << " drawn **** " << endl;
1200 
1201  } //if( Method != 9
1202  ++Method;
1203  } //while loop over Methods
1204  //=======================================================================================================
1205  //=======================================================================================================
1206  //=======================================================================================================
1207  //=======================================================================================================
1208  //=======================================================================================================
1209  //=======================================================================================================
1210  //=======================================================================================================
1211  //=======================================================================================================
1212  //=======================================================================================================
1213  //______________________________________________________________________________
1214  //______________________________________________________________________________
1215  //
1216  //______________________________________________________________________________
1217  //______________________________________________________________________________
1218  //
1219  gSystem->Exit(0);
1220  //______________________________________________________________________________
1221 }
1222 //______________________________________________________________________________
PostProcessor_cff.normalization
normalization
Definition: PostProcessor_cff.py:9
HIPAlignmentAlgorithm_cfi.verbosity
verbosity
Definition: HIPAlignmentAlgorithm_cfi.py:7
cmsBatch.argv
argv
Definition: cmsBatch.py:279
mps_fire.i
i
Definition: mps_fire.py:428
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
dir2webdir.argc
argc
Definition: dir2webdir.py:39
testProducerWithPsetDescEmpty_cfi.x2
x2
Definition: testProducerWithPsetDescEmpty_cfi.py:28
gather_cfg.cout
cout
Definition: gather_cfg.py:144
AlignmentPI::YY
Definition: AlignmentPayloadInspectorHelper.h:46
testProducerWithPsetDescEmpty_cfi.a2
a2
Definition: testProducerWithPsetDescEmpty_cfi.py:35
b1
static constexpr float b1
Definition: L1EGammaCrystalsEmulatorProducer.cc:82
testProducerWithPsetDescEmpty_cfi.x1
x1
Definition: testProducerWithPsetDescEmpty_cfi.py:33
testProducerWithPsetDescEmpty_cfi.y1
y1
Definition: testProducerWithPsetDescEmpty_cfi.py:29
L1TEGammaDiff_cfi.plotName
plotName
Definition: L1TEGammaDiff_cfi.py:21
testProducerWithPsetDescEmpty_cfi.y2
y2
Definition: testProducerWithPsetDescEmpty_cfi.py:30
main
int main(int argc, char *argv[])
Definition: zamt5GSMHF.cc:34
alignmentValidation.c1
c1
do drawing
Definition: alignmentValidation.py:1025
writedatasetfile.firstrun
firstrun
Definition: writedatasetfile.py:27
MonitorAlCaEcalPi0_cfi.X0
X0
Definition: MonitorAlCaEcalPi0_cfi.py:77
alignmentValidation.fname
string fname
main script
Definition: alignmentValidation.py:959
std
Definition: JetResolutionObject.h:76
fftjetpileupestimator_calo_uncalib_cfi.c0
c0
Definition: fftjetpileupestimator_calo_uncalib_cfi.py:8
hgcalConcentratorProducer_cfi.Method
Method
Definition: hgcalConcentratorProducer_cfi.py:30
submitPVValidationJobs.t
string t
Definition: submitPVValidationJobs.py:644
XX
double XX[2]
Definition: herwig.h:145
Generated for CMSSW Reference Manual by doxygen 1.8.16