File indexing completed on 2024-04-06 12:05:40
0001 #include <iostream>
0002 #include <fstream>
0003 #include "TH1.h"
0004 #include "TH2.h"
0005 #include "TH1F.h"
0006 #include "TH2F.h"
0007 #include "TCanvas.h"
0008 #include "TROOT.h"
0009 #include <TMath.h>
0010 #include "TStyle.h"
0011 #include "TSystem.h"
0012 #include "TLegend.h"
0013 #include "TText.h"
0014 #include "TAxis.h"
0015 #include "TFile.h"
0016 #include "TLine.h"
0017 #include "TGraph.h"
0018 #include <TPaveText.h>
0019 #include <TPostScript.h>
0020 #include <TClass.h>
0021 #include <TLatex.h>
0022 #include <TFrame.h>
0023 #include <TPad.h>
0024 #include <TGaxis.h>
0025
0026 #include "TGraphErrors.h"
0027 #include "TF1.h"
0028 #include "TArrow.h"
0029
0030
0031 using namespace std;
0032
0033
0034 int main(int argc, char* argv[]) {
0035 cout << "********************************************************************* START job " << endl;
0036
0037
0038 TGraph* gr1;
0039 TGraph* gr2;
0040 TGraph* gr3;
0041 TGraph* gr4;
0042 TGraph* gr5;
0043 TGraph* gr6;
0044 TGraph* gr7;
0045 TGraph* gr8;
0046 TGraph* gr9;
0047 TGraphErrors* ge1;
0048 TGraphErrors* ge2;
0049 TGraphErrors* ge3;
0050 TGraphErrors* ge4;
0051 TGraphErrors* ge5;
0052 TGraphErrors* ge6;
0053 TGraphErrors* ge7;
0054 TGraphErrors* ge8;
0055 TGraphErrors* ge9;
0056
0057
0058 const Int_t NMethods = 14;
0059 const Int_t NMethodsStart = 0;
0060 const Int_t NMethodsToUse = 13;
0061
0062 TString MethodName[NMethods] = {"PLOT0",
0063 "PLOT1",
0064 "PLOT2",
0065 "PLOT3",
0066 "PLOT4",
0067 "PLOT5",
0068 "PLOT6",
0069 "PLOT7",
0070 "PLOT8",
0071 "PLOT9",
0072 "PLOT10",
0073 "PLOT11",
0074 "PLOT12",
0075 "PLOT13"};
0076
0077 const Int_t NMAXM = 70;
0078
0079 cout << "********************************************************************* NMAXM = " << NMAXM << endl;
0080
0081 TString LEDrunsM[NMAXM] = {
0082
0083 "315812", "315984", "316826", "317116", "317193", "317268", "317271", "317273", "317363", "317444", "317606",
0084 "317607", "317609", "317610", "317611", "317612", "317613", "317617", "317785", "318758", "319198", "319401",
0085 "319517", "319519", "319520", "319564", "319612", "319734", "319771", "319774", "319857", "319969", "320117",
0086 "320158", "320203", "320205", "320348", "320579", "320873", "320892", "320952", "321019", "321036", "321187",
0087 "321339", "321359", "321371", "321447", "321514", "322781", "322782", "323314", "323502", "323579", "323613",
0088 "323742", "324030", "324032", "324138", "324225", "324296", "324919", "325141", "325787", "326234", "326875",
0089 "327288", "327438", "327552", "327579"
0090
0091 };
0092 cout << "********************************************************************* first massives defined " << endl;
0093 Float_t X0M[NMAXM] = {
0094
0095 0., 2., 17., 22., 23., 24., 24., 24., 27., 29., 32., 32., 32., 32., 32., 32., 32., 32.,
0096 38., 51., 58., 63., 65., 65., 65., 66., 68., 70., 71., 71., 72., 74., 77., 78., 79., 79.,
0097 80., 85., 90., 91., 92., 93., 93., 98., 101., 101., 101., 104., 106., 129., 129., 138., 141., 142.,
0098 143., 146., 150., 150., 151., 153., 155., 165., 169., 179., 183., 195., 203., 205., 208., 209.,
0099 };
0100 cout << "********************************************************************* both massives are defined " << endl;
0101
0102
0103
0104 const Int_t yearcase = 0;
0105
0106 cout << "************************************** yearcase = " << yearcase << endl;
0107
0108
0109
0110
0111
0112
0113
0114 Int_t verbosity = 0;
0115
0116
0117
0118
0119 const Int_t flagHFP17selection = 0;
0120
0121 cout << "************************************** flagHFP17selection = " << flagHFP17selection << endl;
0122
0123
0124
0125
0126
0127
0128
0129
0130
0131
0132
0133 TCanvas* c1 = new TCanvas("c1", "GSM", 10, 10, 1010, 1010);
0134
0135
0136
0137
0138 c1->Range(0, 0, 25, 18);
0139
0140 c1->SetFillColor(0);
0141 c1->Clear();
0142
0143 TLatex* t = new TLatex();
0144 t->SetTextFont(32);
0145
0146 t->SetTextSize(0.03);
0147 t->SetTextAlign(12);
0148
0149 t->DrawLatex(
0150 0.9, 15.5, "Time dependence of full Amplitude averaged over events of each LED run for some random HF channels");
0151
0152
0153
0154
0155
0156
0157
0158
0159
0160
0161
0162 Float_t x1 = 0.00;
0163 Float_t x2 = 215.0;
0164
0165
0166
0167 Float_t y1 = 0.9;
0168 Float_t y2 = 1.1;
0169
0170
0171
0172 Float_t RrangeMIN = y1;
0173 Float_t RrangeMAX = y2;
0174
0175
0176 Float_t xx1 = 0.35;
0177 Float_t xx2 = 0.55;
0178 Float_t yy1 = 0.76;
0179 Float_t yy2 = 0.88;
0180
0181 cout << "************************************** RrangeMIN = " << RrangeMIN << " RrangeMAX = " << RrangeMAX << endl;
0182
0183
0184
0185
0186 const Int_t NDEP = 5;
0187 const Int_t NETA0 = 83;
0188 const Int_t NPHI0 = 73;
0189
0190 Double_t mapRATIO[NDEP][NETA0][NPHI0];
0191 Double_t mapRATIOD2[NETA0][NPHI0];
0192 Int_t mapRATIOD20[NETA0][NPHI0];
0193
0194
0195 Double_t normalization[NETA0][NPHI0];
0196 cout << "************************************** NDEP = " << NDEP << " NETA0 = " << NETA0 << " NPHI0 = " << NPHI0
0197 << endl;
0198
0199
0200 Int_t NMAXSIZE = NMAXM;
0201 Float_t X0[NMAXSIZE];
0202 TString LEDruns[NMAXSIZE];
0203 Double_t XX[NMAXSIZE];
0204 Double_t XXE[NMAXSIZE];
0205 Double_t XXX[NMAXSIZE];
0206 Double_t XXXE[NMAXSIZE];
0207 Int_t indWAS[NMAXSIZE];
0208
0209 Double_t YY[NMAXSIZE];
0210 Double_t YYE[NMAXSIZE];
0211 cout << "************************************** NMAXSIZE = " << NMAXSIZE << " NMAXM = " << NMAXM << endl;
0212
0213
0214 Double_t GSMRATIOD2[NMAXSIZE][NETA0][NPHI0];
0215
0216
0217
0218
0219
0220
0221 Int_t NMINmM = 0;
0222 Int_t NMAXmM = NMAXSIZE - 1;
0223 Int_t NMAXaM = NMAXSIZE;
0224 if (yearcase == 1) {
0225
0226 NMINmM = 0;
0227 NMAXmM = 46;
0228 NMAXaM = 47;
0229 } else if (yearcase == 2) {
0230
0231 NMINmM = 53;
0232 NMAXmM = 93;
0233 NMAXaM = 41;
0234 } else if (yearcase == 3) {
0235
0236 NMINmM = 0;
0237 NMAXmM = 93;
0238 NMAXaM = 94;
0239 } else if (yearcase == 4) {
0240
0241 NMINmM = 94;
0242 NMAXmM = -1;
0243 NMAXaM = -1;
0244 } else if (yearcase == 5) {
0245
0246 NMINmM = 0;
0247 NMAXmM = -1;
0248 NMAXaM = -1;
0249 }
0250
0251 cout << "************************************** NMINmM = " << NMINmM << " NMAXmM = " << NMAXmM
0252 << " NMAXaM = " << NMAXaM << endl;
0253 if (NMINmM == -1 || NMAXmM == -1 || NMAXaM == -1)
0254 cout << " STOP !!!!!! NMINmM == -1 || NMAXmM == -1 || NMAXaM == -1 " << endl;
0255
0256 Int_t NMAX = 0;
0257 NMAX = NMAXaM;
0258
0259 for (int jjj = NMINmM; jjj <= NMAXmM; jjj++) {
0260 LEDruns[jjj - NMINmM] = LEDrunsM[jjj];
0261 X0[jjj - NMINmM] = X0M[jjj];
0262
0263 }
0264
0265
0266
0267
0268
0269 Int_t NP = NMAX;
0270 cout << "******************* NP = " << NP << endl;
0271
0272
0273
0274
0275
0276
0277
0278 Double_t cutMinA = 100.;
0279 Double_t cutMaxA = 5000.;
0280
0281
0282
0283
0284
0285
0286 for (int kk1 = 0; kk1 < NP; kk1++) {
0287 XX[kk1] = X0[kk1];
0288 int k10 = 0;
0289 int z1 = X0[k10];
0290 XX[kk1] -= z1;
0291 if (verbosity == 2) {
0292 cout << "ORDINATE points: kk1 = " << kk1 << " XX[kk1]= " << XX[kk1] << endl;
0293 }
0294
0295 XXE[kk1] = 0.001 * XX[kk1];
0296 }
0297
0298
0299
0300
0301
0302 for (int jjj = 0; jjj <= 82; jjj++) {
0303 for (int kkk = 0; kkk <= 72; kkk++) {
0304 mapRATIOD2[jjj][kkk] = 0.;
0305 mapRATIOD20[jjj][kkk] = 0.;
0306 normalization[jjj][kkk] = 0.;
0307
0308 for (int k1 = 0; k1 < NP; k1++) {
0309 GSMRATIOD2[k1][jjj][kkk] = mapRATIOD2[jjj][kkk];
0310 }
0311
0312 for (int iii = 0; iii < NDEP; iii++) {
0313 mapRATIO[iii][jjj][kkk] = 0.;
0314
0315 }
0316
0317 }
0318 }
0319
0320
0321
0322
0323
0324
0325 TString fname = "/afs/cern.ch/cms/CAF/CMSALCA/ALCA_HCALCALIB/HCALMONITORING/RDMweb/histos/LED_";
0326
0327
0328
0329 TH1F* Seff1D = new TH1F("Seff1D", "", 1000, 10., 1010.);
0330 TH1F* Ceff1D = new TH1F("Ceff1D", "", 1500, 10., 8010.);
0331
0332 TH2F* mapBADchannels = new TH2F("mapBADchannels", " ", 82, -41., 41., 72, 0., 72.);
0333 TH2F* mapBADchannels0 = new TH2F("mapBADchannels0", " ", 82, -41., 41., 72, 0., 72.);
0334
0335 TH2F* mapchannelsdepth1 = new TH2F("mapchannelsdepth1", " ", 82, -41., 41., 72, 0., 72.);
0336 TH2F* mapchannelsdepth2 = new TH2F("mapchannelsdepth2", " ", 82, -41., 41., 72, 0., 72.);
0337 TH2F* mapchannelsdepth3 = new TH2F("mapchannelsdepth3", " ", 82, -41., 41., 72, 0., 72.);
0338 TH2F* mapchannelsdepth4 = new TH2F("mapchannelsdepth4", " ", 82, -41., 41., 72, 0., 72.);
0339
0340 TH1F* gainkoeff = new TH1F("gainkoeff", "", 100, y1, y2);
0341 TH1F* gainkoeff0 = new TH1F("gainkoeff0", "", 100, 0.9, 1.1);
0342 TH1F* gainkoeff9 = new TH1F("gainkoeff9", "", 100, 0.1, 1.9);
0343 TH1F* GOODruns = new TH1F("GOODruns", "", NP, 0., float(NP));
0344 TH1F* BADruns = new TH1F("BADruns", "", NP, 0., float(NP));
0345 TH1F* NotEmptyDepthes = new TH1F("NotEmptyDepthes", "", 56, 0., 56.);
0346
0347
0348 Int_t kmm = 0;
0349 Int_t firstrun = 0;
0350
0351 cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! firstrun = " << firstrun << " run = " << LEDruns[firstrun] << endl;
0352
0353
0354
0355
0356
0357
0358 cout << "!!!!!!!!!!!!!!!!!!!!!! use root files from official RMT dir. " << endl;
0359
0360
0361
0362 TH1F* Aeff1D = new TH1F("Aeff1D", "", 250, 0., 500000.);
0363
0364 int ck1count = 0;
0365 for (int k1 = firstrun; k1 < NP; k1++) {
0366
0367 ck1count++;
0368
0369
0370
0371
0372
0373
0374 TString epsName = fname + LEDruns[k1] + ".root";
0375
0376
0377
0378 TFile* hfile = new TFile(epsName, "READ");
0379
0380 TH1F* Aeff1 = (TH1F*)hfile->Get("h_ADCAmpl_HF");
0381
0382 int kx = Aeff1->GetXaxis()->GetNbins();
0383
0384 int maxvalueA = -1;
0385 for (int jjj = 0; jjj < kx; jjj++) {
0386 if (double(Aeff1->GetBinContent(jjj)) > 0. && maxvalueA < jjj)
0387 maxvalueA = jjj;
0388
0389 Aeff1D->Fill(float(jjj), double(Aeff1->GetBinContent(jjj)));
0390 }
0391 cout << " run = " << LEDruns[k1] << " k1= " << k1 << " max bin value= " << maxvalueA << " ck1count= " << ck1count
0392 << endl;
0393
0394
0395
0396
0397 if (k1 == NP - 1) {
0398 c1->Clear();
0399 c1->Divide(1, 1);
0400 c1->cd(1);
0401 gPad->SetGridy();
0402 gPad->SetGridx();
0403 gPad->SetLogy();
0404 gStyle->SetOptStat(101110);
0405 Aeff1->SetMarkerStyle(20);
0406 Aeff1->SetMarkerSize(0.4);
0407 Aeff1->GetYaxis()->SetLabelSize(0.04);
0408 Aeff1->SetTitle("Last run & events & channels");
0409 Aeff1->SetXTitle("Aijk");
0410 Aeff1->SetYTitle("N");
0411 Aeff1->SetMarkerColor(4);
0412 Aeff1->SetLineColor(4);
0413 Aeff1->SetMinimum(0.8);
0414 Aeff1->Draw("PL");
0415 c1->Update();
0416 TString fdir = "testamt5gsmHF2018/";
0417
0418 TString plotName = fdir + "Aijk-Run" + LEDruns[k1] + ".png";
0419 c1->SaveAs(plotName);
0420 cout << "****PLOT AijkLastRun.png is drawn **** " << endl;
0421 }
0422
0423
0424 if (k1 == firstrun) {
0425 c1->Clear();
0426 c1->Divide(1, 1);
0427 c1->cd(1);
0428 gPad->SetGridy();
0429 gPad->SetGridx();
0430
0431 gStyle->SetOptStat(101110);
0432 Aeff1->SetMarkerStyle(20);
0433 Aeff1->SetMarkerSize(0.4);
0434 Aeff1->GetYaxis()->SetLabelSize(0.04);
0435 Aeff1->SetTitle("First run & events & channels");
0436 Aeff1->SetXTitle("Aijk");
0437 Aeff1->SetYTitle("N");
0438 Aeff1->SetMarkerColor(4);
0439 Aeff1->SetLineColor(4);
0440 Aeff1->SetMinimum(0.8);
0441 Aeff1->Draw("PL");
0442 c1->Update();
0443 TString fdir = "testamt5gsmHF2018/";
0444 TString plotName = fdir + "AijkFirstRun.png";
0445 c1->SaveAs(plotName);
0446 cout << "****PLOT AijkFirstRun.png is drawn **** " << endl;
0447 }
0448
0449
0450
0451
0452
0453
0454
0455
0456
0457
0458
0459
0460
0461
0462
0463
0464
0465
0466 TH2F* twod1 = (TH2F*)hfile->Get("h_mapDepth1ADCAmpl12_HF");
0467 TH2F* twod2 = (TH2F*)hfile->Get("h_mapDepth2ADCAmpl12_HF");
0468 TH2F* twod3 = (TH2F*)hfile->Get("h_mapDepth3ADCAmpl12_HF");
0469
0470 TH2F* twod4 = (TH2F*)hfile->Get("h_mapDepth4ADCAmpl12_HF");
0471
0472
0473
0474
0475
0476
0477
0478
0479 int nx = twod1->GetXaxis()->GetNbins();
0480 int ny = twod1->GetYaxis()->GetNbins();
0481
0482
0483 TH2F* t0010 = (TH2F*)hfile->Get("h_mapDepth1_HF");
0484 TH2F* t0020 = (TH2F*)hfile->Get("h_mapDepth2_HF");
0485 TH2F* t0030 = (TH2F*)hfile->Get("h_mapDepth3_HF");
0486 TH2F* t0040 = (TH2F*)hfile->Get("h_mapDepth4_HF");
0487
0488 TH2F* Ceff1 = (TH2F*)twod1->Clone("Ceff1");
0489 TH2F* Ceff2 = (TH2F*)twod2->Clone("Ceff2");
0490 TH2F* Ceff3 = (TH2F*)twod3->Clone("Ceff3");
0491 TH2F* Ceff4 = (TH2F*)twod4->Clone("Ceff4");
0492
0493
0494 Ceff1->Divide(twod1, t0010, 1, 1, "B");
0495 Ceff2->Divide(twod2, t0020, 1, 1, "B");
0496 Ceff3->Divide(twod3, t0030, 1, 1, "B");
0497 Ceff4->Divide(twod4, t0040, 1, 1, "B");
0498
0499
0500 for (int jjj = 0; jjj < nx; jjj++) {
0501 for (int kkk = 0; kkk < ny; kkk++) {
0502
0503 if (flagHFP17selection == 0 ||
0504 (flagHFP17selection == 1 && (((jjj > 56 && jjj < 62) && (kkk > 63 && kkk < 68)) ||
0505 ((jjj > 61 && jjj < 71) && (kkk == 64 || kkk == 66)))) ||
0506 (flagHFP17selection == 2 && !(((jjj > 14 && jjj < 25) && (kkk > 55 && kkk < 64))))) {
0507
0508
0509 if (Ceff1->GetBinContent(jjj, kkk) > 0.)
0510 mapchannelsdepth1->Fill(double(jjj) - 41., double(kkk), Ceff1->GetBinContent(jjj, kkk));
0511 if (Ceff2->GetBinContent(jjj, kkk) > 0.)
0512 mapchannelsdepth2->Fill(double(jjj) - 41., double(kkk), Ceff2->GetBinContent(jjj, kkk));
0513 if (Ceff3->GetBinContent(jjj, kkk) > 0.)
0514 mapchannelsdepth3->Fill(double(jjj) - 41., double(kkk), Ceff3->GetBinContent(jjj, kkk));
0515 if (Ceff4->GetBinContent(jjj, kkk) > 0.)
0516 mapchannelsdepth4->Fill(double(jjj) - 41., double(kkk), Ceff4->GetBinContent(jjj, kkk));
0517 }
0518 }
0519 }
0520
0521
0522
0523
0524
0525
0526
0527 for (int jjj = 0; jjj < nx; jjj++) {
0528 for (int kkk = 0; kkk < ny; kkk++) {
0529
0530
0531 if (flagHFP17selection == 0 ||
0532 (flagHFP17selection == 1 && (((jjj > 56 && jjj < 62) && (kkk > 63 && kkk < 68)) ||
0533 ((jjj > 61 && jjj < 71) && (kkk == 64 || kkk == 66)))) ||
0534 (flagHFP17selection == 2 && !(((jjj > 14 && jjj < 25) && (kkk > 55 && kkk < 64))))) {
0535
0536
0537 if (Ceff1->GetBinContent(jjj, kkk) != 0.) {
0538 Ceff1D->Fill(Ceff1->GetBinContent(jjj, kkk));
0539 Seff1D->Fill(Ceff1->GetBinContent(jjj, kkk));
0540 }
0541 if (Ceff2->GetBinContent(jjj, kkk) != 0.) {
0542 Ceff1D->Fill(Ceff2->GetBinContent(jjj, kkk));
0543 Seff1D->Fill(Ceff2->GetBinContent(jjj, kkk));
0544 }
0545 if (Ceff3->GetBinContent(jjj, kkk) != 0.) {
0546 Ceff1D->Fill(Ceff3->GetBinContent(jjj, kkk));
0547 Seff1D->Fill(Ceff3->GetBinContent(jjj, kkk));
0548 }
0549 if (Ceff4->GetBinContent(jjj, kkk) != 0.) {
0550 Ceff1D->Fill(Ceff4->GetBinContent(jjj, kkk));
0551 Seff1D->Fill(Ceff4->GetBinContent(jjj, kkk));
0552 }
0553 }
0554 }
0555 }
0556
0557
0558
0559
0560
0561
0562 for (int jjj = 0; jjj < nx; jjj++) {
0563 for (int kkk = 0; kkk < ny; kkk++) {
0564
0565 if (flagHFP17selection == 0 ||
0566 (flagHFP17selection == 1 && (((jjj > 56 && jjj < 62) && (kkk > 63 && kkk < 68)) ||
0567 ((jjj > 61 && jjj < 71) && (kkk == 64 || kkk == 66)))) ||
0568 (flagHFP17selection == 2 && !(((jjj > 14 && jjj < 25) && (kkk > 55 && kkk < 64))))) {
0569 if (Ceff1->GetBinContent(jjj, kkk) > cutMinA && Ceff1->GetBinContent(jjj, kkk) < cutMaxA)
0570 mapRATIO[1][jjj][kkk] = Ceff1->GetBinContent(jjj, kkk);
0571 if (Ceff2->GetBinContent(jjj, kkk) > cutMinA && Ceff2->GetBinContent(jjj, kkk) < cutMaxA)
0572 mapRATIO[2][jjj][kkk] = Ceff2->GetBinContent(jjj, kkk);
0573 if (Ceff3->GetBinContent(jjj, kkk) > cutMinA && Ceff3->GetBinContent(jjj, kkk) < cutMaxA)
0574 mapRATIO[3][jjj][kkk] = Ceff3->GetBinContent(jjj, kkk);
0575 if (Ceff4->GetBinContent(jjj, kkk) > cutMinA && Ceff4->GetBinContent(jjj, kkk) < cutMaxA)
0576 mapRATIO[4][jjj][kkk] = Ceff4->GetBinContent(jjj, kkk);
0577 }
0578 }
0579 }
0580
0581
0582
0583
0584
0585
0586
0587
0588
0589
0590
0591
0592
0593
0594
0595
0596
0597
0598
0599
0600
0601 int totalhep17count = 0;
0602 int totalhep17count1 = 0;
0603 int totalhep17count2 = 0;
0604 int totalhep17count3 = 0;
0605 int totalhep17count4 = 0;
0606 int totalhep17count5 = 0;
0607 int totalhep17count6 = 0;
0608 int totalhep17count7 = 0;
0609 for (int iii = 1; iii < NDEP; iii++) {
0610 for (int jjj = 0; jjj < nx; jjj++) {
0611 for (int kkk = 0; kkk < ny; kkk++) {
0612
0613
0614 if (mapRATIO[iii][jjj][kkk] > 0) {
0615
0616 totalhep17count++;
0617 if (verbosity == 4 && k1 == 0) {
0618 cout << " k1= " << k1 << " depth= " << iii << " eta= " << jjj << " phi= " << kkk
0619 << " mapRATIO= " << mapRATIO[iii][jjj][kkk] << endl;
0620 }
0621 if (iii == 1)
0622 totalhep17count1++;
0623 if (iii == 2)
0624 totalhep17count2++;
0625 if (iii == 3)
0626 totalhep17count3++;
0627 if (iii == 4)
0628 totalhep17count4++;
0629 if (iii == 5)
0630 totalhep17count5++;
0631 if (iii == 6)
0632 totalhep17count6++;
0633 if (iii == 7)
0634 totalhep17count7++;
0635
0636 mapRATIOD2[jjj][kkk] += mapRATIO[iii][jjj][kkk];
0637
0638 mapRATIOD20[jjj][kkk]++;
0639 if (verbosity == 3 && iii == 3)
0640 cout << " depth = " << iii << " k1 = " << k1 << " eta = " << jjj
0641 << " mapRATIOD2[jjj][kkk] = " << mapRATIOD2[jjj][kkk] << " #entries = " << mapRATIOD20[jjj][kkk]
0642 << " mapRATIO[iii][jjj][kkk] = " << mapRATIO[iii][jjj][kkk] << endl;
0643 }
0644 }
0645 }
0646 }
0647
0648
0649
0650
0651 if (verbosity == 4 && k1 == 0) {
0652 cout << " k1= " << k1 << " totalhep17count= " << totalhep17count << endl;
0653 cout << " k1= " << k1 << " totalhep17count1= " << totalhep17count1 << endl;
0654 cout << " k1= " << k1 << " totalhep17count2= " << totalhep17count2 << endl;
0655 cout << " k1= " << k1 << " totalhep17count3= " << totalhep17count3 << endl;
0656 cout << " k1= " << k1 << " totalhep17count4= " << totalhep17count4 << endl;
0657 cout << " k1= " << k1 << " totalhep17count5= " << totalhep17count5 << endl;
0658 cout << " k1= " << k1 << " totalhep17count6= " << totalhep17count6 << endl;
0659 cout << " k1= " << k1 << " totalhep17count7= " << totalhep17count7 << endl;
0660 }
0661
0662
0663
0664 Int_t depthAVERAGEcount = 0;
0665 for (int jjj = 0; jjj < nx; jjj++) {
0666 for (int kkk = 0; kkk < ny; kkk++) {
0667
0668
0669 depthAVERAGEcount = 4 * (jjj - 57) + (kkk - 64);
0670 if (mapRATIOD20[jjj][kkk] != 0) {
0671 NotEmptyDepthes->Fill(float(depthAVERAGEcount));
0672 if (verbosity == 1)
0673 cout << "****aver per depthes********* phi = " << kkk << " RunIndex = " << k1 << " eta = " << jjj
0674 << " #entries = " << mapRATIOD20[jjj][kkk] << endl;
0675 mapRATIOD2[jjj][kkk] /= mapRATIOD20[jjj][kkk];
0676 if (verbosity == 3 && kkk == 3)
0677 cout << "****aver per depthes********* phi = " << jjj << " RunIndex = " << k1 << " eta = " << jjj
0678 << " Nphi = " << mapRATIOD20[jjj][kkk] << endl;
0679 }
0680 }
0681 }
0682
0683
0684
0685 if (k1 == firstrun && kmm == 0) {
0686 kmm = 1;
0687 cout << "* to be printed once only CHFCK IT please ************ kmm = " << kmm << endl;
0688
0689
0690 for (int jjj = 0; jjj < nx; jjj++) {
0691 for (int kkk = 0; kkk < ny; kkk++) {
0692 normalization[jjj][kkk] = mapRATIOD2[jjj][kkk];
0693 }
0694 }
0695 }
0696
0697
0698
0699
0700
0701
0702 for (int jjj = 0; jjj < nx; jjj++) {
0703 for (int kkk = 0; kkk < ny; kkk++) {
0704 if (normalization[jjj][kkk] != 0) {
0705 GSMRATIOD2[k1][jjj][kkk] = mapRATIOD2[jjj][kkk] / normalization[jjj][kkk];
0706
0707 if (GSMRATIOD2[k1][jjj][kkk] < RrangeMAX && GSMRATIOD2[k1][jjj][kkk] > RrangeMIN) {
0708 gainkoeff->Fill(GSMRATIOD2[k1][jjj][kkk]);
0709 gainkoeff0->Fill(GSMRATIOD2[k1][jjj][kkk]);
0710 gainkoeff9->Fill(GSMRATIOD2[k1][jjj][kkk]);
0711
0712
0713
0714
0715
0716 GOODruns->Fill(float(k1));
0717 } else {
0718 if (GSMRATIOD2[k1][jjj][kkk] > 0.)
0719 BADruns->Fill(float(k1));
0720 }
0721
0722
0723 }
0724 }
0725 }
0726
0727
0728
0729
0730
0731
0732
0733 for (int jjj = 0; jjj <= 82; jjj++) {
0734 for (int kkk = 0; kkk <= 72; kkk++) {
0735 mapRATIOD2[jjj][kkk] = 0.;
0736 mapRATIOD20[jjj][kkk] = 0.;
0737 for (int iii = 0; iii < NDEP; iii++) {
0738 mapRATIO[iii][jjj][kkk] = 0.;
0739 }
0740 }
0741 }
0742
0743
0744 hfile->Close();
0745
0746
0747
0748
0749 }
0750 cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DONE: last LED run READ " << endl;
0751
0752
0753
0754
0755
0756
0757
0758
0759
0760
0761
0762
0763
0764 cout << "**** **** **** **** **** Draw Dependencies: *** " << endl;
0765
0766
0767 Int_t Method = NMethodsStart;
0768 while (Method < NMethodsToUse + 1) {
0769 if (Method != 9999992) {
0770 cout << " **** START Method " << Method << endl;
0771
0772 if (Method == 0) {
0773 cout << "****Draw 0 Dependencies: <Aijk> for each event and all LED runs *** " << endl;
0774 gPad->SetGridy();
0775 gPad->SetGridx();
0776 gPad->SetLogy();
0777 gStyle->SetOptStat(101110);
0778 Ceff1D->SetMarkerStyle(20);
0779 Ceff1D->SetMarkerSize(0.4);
0780 Ceff1D->GetYaxis()->SetLabelSize(0.04);
0781 Ceff1D->SetTitle("all runs & channels");
0782 Ceff1D->SetXTitle("<Aijk>");
0783 Ceff1D->SetYTitle("N");
0784 Ceff1D->SetMarkerColor(4);
0785 Ceff1D->SetLineColor(4);
0786
0787 Ceff1D->Draw("PL");
0788 }
0789
0790 if (Method == 1) {
0791 cout << "****Draw 1 Dependencies: <Aijk> for each event and all LED runs ZOOM *** " << endl;
0792 gPad->SetGridy();
0793 gPad->SetGridx();
0794 gPad->SetLogy();
0795 gStyle->SetOptStat(101110);
0796
0797 Seff1D->SetMarkerStyle(20);
0798 Seff1D->SetMarkerSize(0.4);
0799 Seff1D->GetYaxis()->SetLabelSize(0.04);
0800 Seff1D->SetTitle("ZOOM all runs & channels");
0801 Seff1D->SetXTitle("<Aijk> ZOOM ");
0802 Seff1D->SetYTitle("N");
0803 Seff1D->SetMarkerColor(4);
0804 Seff1D->SetLineColor(4);
0805
0806 Seff1D->Draw("PL");
0807 }
0808
0809
0810 if (Method == 2) {
0811 cout << "****Draw 2 Dependencies: GSM ratio vs days *** " << endl;
0812 for (int k1 = 0; k1 < NP; k1++) {
0813 YY[k1] = 0.;
0814 }
0815
0816
0817
0818 TPad* pad1 = new TPad("pad1", "This is pad1", 0.02, 0.02, 0.99, 0.99, 0);
0819 pad1->Draw();
0820 pad1->cd();
0821 pad1->Range(-0.255174, -19.25, 2.29657, -6.75);
0822
0823 pad1->DrawFrame(x1, y1, x2, y2);
0824
0825 pad1->GetFrame()->SetFillColor(0);
0826 pad1->Draw();
0827 gPad->SetGridy();
0828 gPad->SetGridx();
0829
0830 Int_t colorlines = 0;
0831 Int_t generalcount = 0;
0832
0833
0834 for (int jjj = 0; jjj < 82; jjj++) {
0835 for (int kkk = 0; kkk < 72; kkk++) {
0836 Int_t sscount = -1;
0837 for (int k1 = 0; k1 < NP; k1++) {
0838 if (GSMRATIOD2[k1][jjj][kkk] != 0) {
0839
0840
0841 if (GSMRATIOD2[k1][jjj][kkk] < RrangeMAX && GSMRATIOD2[k1][jjj][kkk] > RrangeMIN) {
0842
0843
0844 sscount++;
0845 YY[sscount] = GSMRATIOD2[k1][jjj][kkk];
0846 XXX[sscount] = XX[k1];
0847 indWAS[sscount] = k1;
0848 mapBADchannels->Fill(double(jjj) - 42., double(kkk) - 1., GSMRATIOD2[k1][jjj][kkk]);
0849 mapBADchannels0->Fill(double(jjj) - 42., double(kkk) - 1., 1.);
0850 }
0851 else {
0852
0853 }
0854 }
0855 }
0856 Int_t MMcount = sscount + 1;
0857 if (MMcount > 0) {
0858 generalcount++;
0859 if (generalcount == 1 && verbosity == 2)
0860 for (int k1 = 0; k1 < MMcount; k1++) {
0861 cout << "**** All GOOD runs: indWAS[k1](1,..) = " << indWAS[k1] + 1 << " XXX[k1]+1 = " << XXX[k1] + 1
0862 << endl;
0863 }
0864 gr1 = new TGraph(MMcount, XXX, YY);
0865 colorlines = generalcount / 5. + 2;
0866 gr1->SetLineColor(colorlines);
0867 gr1->SetMarkerColor(colorlines);
0868 gr1->SetMarkerStyle(20);
0869 gr1->SetMarkerSize(1.2);
0870 gr1->SetFillStyle(0);
0871 gr1->GetXaxis()->SetTitle("days");
0872 gr1->GetYaxis()->SetTitle("R");
0873 gr1->Draw("PL");
0874 }
0875
0876 }
0877 }
0878
0879
0880
0881 TLegend leg(xx1, yy1, xx2, yy2, "HF: R vs t(days)");
0882
0883 leg.SetMargin(0.3);
0884 leg.SetBorderSize(1);
0885 leg.DrawClone("Same");
0886
0887
0888
0889
0890
0891
0892
0893
0894
0895
0896
0897
0898
0899
0900
0901 }
0902
0903
0904
0905 if (Method == 3) {
0906 cout << "****Draw 3 Dependencies: 2D SiPM channels *** " << endl;
0907 TH2F* Cdepth2hbff = (TH2F*)mapBADchannels->Clone("Cdepth2hbff");
0908 Cdepth2hbff->Divide(mapBADchannels, mapBADchannels0, 1, 1, "B");
0909 Cdepth2hbff->Sumw2();
0910 gPad->SetGridy();
0911 gPad->SetGridx();
0912 gStyle->SetOptStat(0000000);
0913 Cdepth2hbff->SetMarkerStyle(20);
0914 Cdepth2hbff->SetMarkerSize(0.4);
0915 Cdepth2hbff->GetYaxis()->SetLabelSize(0.04);
0916 Cdepth2hbff->SetTitle("within R & Weighted by R");
0917 Cdepth2hbff->SetXTitle("#eta \b");
0918 Cdepth2hbff->SetYTitle("#phi \b");
0919 Cdepth2hbff->SetMarkerColor(4);
0920 Cdepth2hbff->SetLineColor(4);
0921 Cdepth2hbff->Draw("COLZ");
0922 }
0923
0924 if (Method == 4) {
0925 cout << "****Draw 4 Dependencies: gains LED runs *** " << endl;
0926 gPad->SetGridy();
0927 gPad->SetGridx();
0928
0929
0930 gStyle->SetOptStat(1100);
0931
0932 gainkoeff->SetMarkerStyle(20);
0933 gainkoeff->SetMarkerSize(0.4);
0934 gainkoeff->GetYaxis()->SetLabelSize(0.04);
0935 gainkoeff->SetXTitle("gains");
0936 gainkoeff->SetYTitle("N");
0937 gainkoeff->SetMarkerColor(4);
0938 gainkoeff->SetLineColor(4);
0939
0940 gainkoeff->Draw("PL");
0941 }
0942
0943 if (Method == 5) {
0944 cout << "****Draw 5 Dependencies: gains LED runs *** " << endl;
0945 gPad->SetGridy();
0946 gPad->SetGridx();
0947 gPad->SetLogy();
0948
0949 gStyle->SetOptStat(1100);
0950
0951 gainkoeff9->SetMarkerStyle(20);
0952 gainkoeff9->SetMarkerSize(0.4);
0953 gainkoeff9->GetYaxis()->SetLabelSize(0.04);
0954 gainkoeff9->SetXTitle("gains");
0955 gainkoeff9->SetYTitle("N");
0956 gainkoeff9->SetMarkerColor(4);
0957 gainkoeff9->SetLineColor(4);
0958
0959 gainkoeff9->Draw("PL");
0960 }
0961
0962 if (Method == 6) {
0963 cout << "****Draw 6 Dependencies: gains LED runs *** " << endl;
0964 gPad->SetGridy();
0965 gPad->SetGridx();
0966 gPad->SetLogy();
0967
0968 gStyle->SetOptStat(1100);
0969
0970 gainkoeff0->SetMarkerStyle(20);
0971 gainkoeff0->SetMarkerSize(0.4);
0972 gainkoeff0->GetYaxis()->SetLabelSize(0.04);
0973 gainkoeff0->SetXTitle("gains");
0974 gainkoeff0->SetYTitle("N");
0975 gainkoeff0->SetMarkerColor(4);
0976 gainkoeff0->SetLineColor(4);
0977
0978 gainkoeff0->Draw("PL");
0979 }
0980
0981 if (Method == 7) {
0982 cout << "****Draw 7 Dependencies: BADruns *** " << endl;
0983 gPad->Update();
0984 gPad->SetGridy();
0985 gPad->SetGridx();
0986 gPad->SetLogy(kFALSE);
0987 gStyle->SetOptStat(101110);
0988 BADruns->SetMarkerStyle(20);
0989 BADruns->SetMarkerSize(0.4);
0990 BADruns->GetYaxis()->SetLabelSize(0.04);
0991 BADruns->SetTitle("#channels outside Rrange VS iRun");
0992 BADruns->SetXTitle("iRun");
0993 BADruns->SetYTitle("#channels");
0994 BADruns->SetMarkerColor(4);
0995 BADruns->SetLineColor(4);
0996
0997 BADruns->Draw("PL");
0998
0999
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
1010 }
1011 cout << "BADruns w/ content>60 nbadruns= " << nbadruns << endl;
1012
1013 }
1014
1015
1016 if (Method == 8) {
1017 cout << "****Draw 8 Dependencies: Goodruns *** " << endl;
1018 gPad->SetGridy();
1019 gPad->SetGridx();
1020
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
1031 GOODruns->Draw("PL");
1032
1033
1034 int cx = GOODruns->GetXaxis()->GetNbins();
1035 cout << "************* cx = " << cx << endl;
1036 for (int jjj = 0; jjj <= cx; jjj++) {
1037
1038
1039 if (GOODruns->GetBinContent(jjj) > 1400.)
1040 cout << "GOODruns: k1(0,...)= " << jjj
1041 << " GOODruns->GetBinContent(jjj)= " << GOODruns->GetBinContent(jjj) << endl;
1042 }
1043
1044 }
1045
1046
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
1062 NotEmptyDepthes->Draw("PL");
1063 }
1064
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
1073
1074
1075
1076 gPad->SetGridy();
1077 gPad->SetGridx();
1078 gPad->SetLogy();
1079 gStyle->SetOptStat(101110);
1080
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
1090
1091 Aeff1D->SetMinimum(0.8);
1092 Aeff1D->Draw("");
1093
1094 c1->Update();
1095
1096 }
1097
1098 if (Method == 11) {
1099 cout << "****Draw 11 <A>: 2D Depthes1,2,3,4 *** " << endl;
1100
1101
1102
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 }
1134
1135 if (Method == 12) {
1136 cout << "****Draw 12 not used yet *** " << endl;
1137
1138
1139
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 }
1150
1151
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
1170 TGraph* gr = new TGraph(n, x, y);
1171
1172
1173
1174 gPad->SetGridy();
1175 gPad->SetGridx();
1176
1177 gr->Draw("AC*");
1178
1179
1180
1181
1182
1183
1184 }
1185
1186 c1->Update();
1187
1188 }
1189
1190
1191
1192
1193
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 }
1202 ++Method;
1203 }
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219 gSystem->Exit(0);
1220
1221 }
1222