File indexing completed on 2023-10-25 09:40:26
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 "315812", "315984", "316826", "317116", "317193", "317268", "317271", "317273", "317363",
0083 "317444", "317606", "317607", "317609", "317610", "317611", "317612", "317613", "317617",
0084 "317785", "318758", "319198", "319401", "319517", "319519", "319520", "319564", "319612",
0085 "319734", "319771", "319774", "319857", "319969", "320117", "320158", "320203", "320205",
0086 "320348", "320579", "320873", "320892", "320952", "321019", "321036", "321187", "321339",
0087 "321359", "321371", "321447", "321514", "322781", "322782", "323314", "323502", "323579",
0088 "323613", "323742", "324030", "324032", "324138", "324225", "324296", "324919", "325141",
0089 "325787", "326234", "326875", "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 flagHBP17selection = 0;
0120
0121 cout << "************************************** flagHBP17selection = " << flagHBP17selection << 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 HB 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 = 3;
0187 const Int_t NETA0 = 83;
0188 const Int_t NPHI0 = 73;
0189
0190
0191 Double_t mapRATIO[NDEP][NETA0][NPHI0];
0192 Double_t mapRATIOD2[NETA0][NPHI0];
0193 Int_t mapRATIOD20[NETA0][NPHI0];
0194
0195
0196 Double_t normalization[NETA0][NPHI0];
0197 cout << "************************************** NDEP = " << NDEP << " NETA0 = " << NETA0 << " NPHI0 = " << NPHI0
0198 << endl;
0199
0200
0201 Int_t NMAXSIZE = NMAXM;
0202 Float_t X0[NMAXSIZE];
0203 TString LEDruns[NMAXSIZE];
0204 Double_t XX[NMAXSIZE];
0205 Double_t XXE[NMAXSIZE];
0206 Double_t XXX[NMAXSIZE];
0207 Double_t XXXE[NMAXSIZE];
0208 Int_t indWAS[NMAXSIZE];
0209
0210 Double_t YY[NMAXSIZE];
0211 Double_t YYE[NMAXSIZE];
0212 cout << "************************************** NMAXSIZE = " << NMAXSIZE << " NMAXM = " << NMAXM << endl;
0213
0214
0215 Double_t GSMRATIOD2[NMAXSIZE][NETA0][NPHI0];
0216
0217
0218
0219
0220
0221
0222 Int_t NMINmM = 0;
0223 Int_t NMAXmM = NMAXSIZE - 1;
0224 Int_t NMAXaM = NMAXSIZE;
0225 if (yearcase == 1) {
0226
0227 NMINmM = 0;
0228 NMAXmM = 46;
0229 NMAXaM = 47;
0230 } else if (yearcase == 2) {
0231
0232 NMINmM = 53;
0233 NMAXmM = 93;
0234 NMAXaM = 41;
0235 } else if (yearcase == 3) {
0236
0237 NMINmM = 0;
0238 NMAXmM = 93;
0239 NMAXaM = 94;
0240 } else if (yearcase == 4) {
0241
0242 NMINmM = 94;
0243 NMAXmM = -1;
0244 NMAXaM = -1;
0245 } else if (yearcase == 5) {
0246
0247 NMINmM = 0;
0248 NMAXmM = -1;
0249 NMAXaM = -1;
0250 }
0251
0252 cout << "************************************** NMINmM = " << NMINmM << " NMAXmM = " << NMAXmM
0253 << " NMAXaM = " << NMAXaM << endl;
0254 if (NMINmM == -1 || NMAXmM == -1 || NMAXaM == -1)
0255 cout << " STOP !!!!!! NMINmM == -1 || NMAXmM == -1 || NMAXaM == -1 " << endl;
0256
0257 Int_t NMAX = 0;
0258 NMAX = NMAXaM;
0259
0260 for (int jjj = NMINmM; jjj <= NMAXmM; jjj++) {
0261 LEDruns[jjj - NMINmM] = LEDrunsM[jjj];
0262 X0[jjj - NMINmM] = X0M[jjj];
0263
0264 }
0265
0266
0267
0268
0269
0270 Int_t NP = NMAX;
0271 cout << "******************* NP = " << NP << endl;
0272
0273
0274
0275
0276
0277
0278
0279 Double_t cutMinA = 100.;
0280 Double_t cutMaxA = 5000.;
0281
0282
0283
0284
0285
0286
0287 for (int kk1 = 0; kk1 < NP; kk1++) {
0288 XX[kk1] = X0[kk1];
0289 int k10 = 0;
0290 int z1 = X0[k10];
0291 XX[kk1] -= z1;
0292 if (verbosity == 2) {
0293 cout << "ORDINATE points: kk1 = " << kk1 << " XX[kk1]= " << XX[kk1] << endl;
0294 }
0295
0296 XXE[kk1] = 0.001 * XX[kk1];
0297 }
0298
0299
0300
0301
0302
0303 for (int jjj = 0; jjj <= 82; jjj++) {
0304 for (int kkk = 0; kkk <= 72; kkk++) {
0305 mapRATIOD2[jjj][kkk] = 0.;
0306 mapRATIOD20[jjj][kkk] = 0.;
0307 normalization[jjj][kkk] = 0.;
0308
0309 for (int k1 = 0; k1 < NP; k1++) {
0310 GSMRATIOD2[k1][jjj][kkk] = mapRATIOD2[jjj][kkk];
0311 }
0312
0313 for (int iii = 0; iii < NDEP; iii++) {
0314 mapRATIO[iii][jjj][kkk] = 0.;
0315
0316 }
0317
0318 }
0319 }
0320
0321
0322
0323
0324
0325
0326 TString fname = "/afs/cern.ch/cms/CAF/CMSALCA/ALCA_HCALCALIB/HCALMONITORING/RDMweb/histos/LED_";
0327
0328
0329
0330 TH1F* Seff1D = new TH1F("Seff1D", "", 1000, 10., 1010.);
0331 TH1F* Ceff1D = new TH1F("Ceff1D", "", 1500, 10., 8010.);
0332
0333 TH2F* mapBADchannels = new TH2F("mapBADchannels", " ", 82, -41., 41., 72, 0., 72.);
0334 TH2F* mapBADchannels0 = new TH2F("mapBADchannels0", " ", 82, -41., 41., 72, 0., 72.);
0335
0336 TH2F* mapchannelsdepth1 = new TH2F("mapchannelsdepth1", " ", 82, -41., 41., 72, 0., 72.);
0337 TH2F* mapchannelsdepth2 = new TH2F("mapchannelsdepth2", " ", 82, -41., 41., 72, 0., 72.);
0338
0339
0340
0341 TH1F* gainkoeff = new TH1F("gainkoeff", "", 100, y1, y2);
0342 TH1F* gainkoeff0 = new TH1F("gainkoeff0", "", 100, 0.9, 1.1);
0343 TH1F* gainkoeff9 = new TH1F("gainkoeff9", "", 100, 0.1, 1.9);
0344 TH1F* GOODruns = new TH1F("GOODruns", "", NP, 0., float(NP));
0345 TH1F* BADruns = new TH1F("BADruns", "", NP, 0., float(NP));
0346 TH1F* NotEmptyDepthes = new TH1F("NotEmptyDepthes", "", 56, 0., 56.);
0347
0348
0349 Int_t kmm = 0;
0350 Int_t firstrun = 0;
0351
0352 cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! firstrun = " << firstrun << " run = " << LEDruns[firstrun] << endl;
0353
0354
0355
0356
0357
0358
0359 cout << "!!!!!!!!!!!!!!!!!!!!!! use root files from official RMT dir. " << endl;
0360
0361
0362
0363 TH1F* Aeff1D = new TH1F("Aeff1D", "", 250, 0., 500000.);
0364
0365 int ck1count = 0;
0366 for (int k1 = firstrun; k1 < NP; k1++) {
0367
0368 ck1count++;
0369
0370
0371
0372
0373
0374
0375 TString epsName = fname + LEDruns[k1] + ".root";
0376
0377
0378
0379
0380 TFile* hfile = new TFile(epsName, "READ");
0381
0382 TH1F* Aeff1 = (TH1F*)hfile->Get("h_ADCAmpl_HB");
0383
0384 int kx = Aeff1->GetXaxis()->GetNbins();
0385
0386
0387 int maxvalueA = -1;
0388 for (int jjj = 0; jjj < kx; jjj++) {
0389 if (double(Aeff1->GetBinContent(jjj)) > 0. && maxvalueA < jjj)
0390 maxvalueA = jjj;
0391
0392 Aeff1D->Fill(float(jjj), double(Aeff1->GetBinContent(jjj)));
0393 }
0394 cout << " run = " << LEDruns[k1] << " k1= " << k1 << " max bin value= " << maxvalueA << " ck1count= " << ck1count
0395 << endl;
0396
0397
0398
0399
0400 if (k1 == NP - 1) {
0401 c1->Clear();
0402 c1->Divide(1, 1);
0403 c1->cd(1);
0404 gPad->SetGridy();
0405 gPad->SetGridx();
0406 gPad->SetLogy();
0407 gStyle->SetOptStat(101110);
0408 Aeff1->SetMarkerStyle(20);
0409 Aeff1->SetMarkerSize(0.4);
0410 Aeff1->GetYaxis()->SetLabelSize(0.04);
0411 Aeff1->SetTitle("Last run & events & channels");
0412 Aeff1->SetXTitle("Aijk");
0413 Aeff1->SetYTitle("N");
0414 Aeff1->SetMarkerColor(4);
0415 Aeff1->SetLineColor(4);
0416 Aeff1->SetMinimum(0.8);
0417 Aeff1->Draw("PL");
0418 c1->Update();
0419 TString fdir = "testamt5gsmHB2018/";
0420
0421 TString plotName = fdir + "Aijk-Run" + LEDruns[k1] + ".png";
0422 c1->SaveAs(plotName);
0423 cout << "****PLOT AijkLastRun.png is drawn **** " << endl;
0424 }
0425
0426
0427 if (k1 == firstrun) {
0428 c1->Clear();
0429 c1->Divide(1, 1);
0430 c1->cd(1);
0431 gPad->SetGridy();
0432 gPad->SetGridx();
0433
0434 gStyle->SetOptStat(101110);
0435 Aeff1->SetMarkerStyle(20);
0436 Aeff1->SetMarkerSize(0.4);
0437 Aeff1->GetYaxis()->SetLabelSize(0.04);
0438 Aeff1->SetTitle("First run & events & channels");
0439 Aeff1->SetXTitle("Aijk");
0440 Aeff1->SetYTitle("N");
0441 Aeff1->SetMarkerColor(4);
0442 Aeff1->SetLineColor(4);
0443 Aeff1->SetMinimum(0.8);
0444 Aeff1->Draw("PL");
0445 c1->Update();
0446 TString fdir = "testamt5gsmHB2018/";
0447 TString plotName = fdir + "AijkFirstRun.png";
0448 c1->SaveAs(plotName);
0449 cout << "****PLOT AijkFirstRun.png is drawn **** " << endl;
0450 }
0451
0452
0453
0454
0455
0456
0457
0458
0459
0460
0461
0462
0463
0464
0465
0466
0467
0468
0469 TH2F* twod1 = (TH2F*)hfile->Get("h_mapDepth1ADCAmpl12_HB");
0470 TH2F* twod2 = (TH2F*)hfile->Get("h_mapDepth2ADCAmpl12_HB");
0471
0472
0473
0474
0475
0476
0477
0478
0479
0480
0481
0482 int nx = twod1->GetXaxis()->GetNbins();
0483 int ny = twod1->GetYaxis()->GetNbins();
0484
0485
0486 TH2F* t0010 = (TH2F*)hfile->Get("h_mapDepth1_HB");
0487 TH2F* t0020 = (TH2F*)hfile->Get("h_mapDepth2_HB");
0488
0489
0490
0491 TH2F* Ceff1 = (TH2F*)twod1->Clone("Ceff1");
0492 TH2F* Ceff2 = (TH2F*)twod2->Clone("Ceff2");
0493
0494
0495
0496
0497 Ceff1->Divide(twod1, t0010, 1, 1, "B");
0498 Ceff2->Divide(twod2, t0020, 1, 1, "B");
0499
0500
0501
0502
0503 for (int jjj = 0; jjj < nx; jjj++) {
0504 for (int kkk = 0; kkk < ny; kkk++) {
0505
0506 if (flagHBP17selection == 0 ||
0507 (flagHBP17selection == 1 && (((jjj > 56 && jjj < 62) && (kkk > 63 && kkk < 68)) ||
0508 ((jjj > 61 && jjj < 71) && (kkk == 64 || kkk == 66)))) ||
0509 (flagHBP17selection == 2 && !(((jjj > 14 && jjj < 25) && (kkk > 55 && kkk < 64))))) {
0510
0511
0512 if (Ceff1->GetBinContent(jjj, kkk) > 0.)
0513 mapchannelsdepth1->Fill(double(jjj) - 41., double(kkk), Ceff1->GetBinContent(jjj, kkk));
0514 if (Ceff2->GetBinContent(jjj, kkk) > 0.)
0515 mapchannelsdepth2->Fill(double(jjj) - 41., double(kkk), Ceff2->GetBinContent(jjj, kkk));
0516
0517
0518 }
0519 }
0520 }
0521
0522
0523
0524
0525
0526
0527
0528 for (int jjj = 0; jjj < nx; jjj++) {
0529 for (int kkk = 0; kkk < ny; kkk++) {
0530
0531
0532 if (flagHBP17selection == 0 ||
0533 (flagHBP17selection == 1 && (((jjj > 56 && jjj < 62) && (kkk > 63 && kkk < 68)) ||
0534 ((jjj > 61 && jjj < 71) && (kkk == 64 || kkk == 66)))) ||
0535 (flagHBP17selection == 2 && !(((jjj > 14 && jjj < 25) && (kkk > 55 && kkk < 64))))) {
0536
0537
0538 if (Ceff1->GetBinContent(jjj, kkk) != 0.) {
0539 Ceff1D->Fill(Ceff1->GetBinContent(jjj, kkk));
0540 Seff1D->Fill(Ceff1->GetBinContent(jjj, kkk));
0541 }
0542 if (Ceff2->GetBinContent(jjj, kkk) != 0.) {
0543 Ceff1D->Fill(Ceff2->GetBinContent(jjj, kkk));
0544 Seff1D->Fill(Ceff2->GetBinContent(jjj, kkk));
0545 }
0546
0547
0548 }
0549 }
0550 }
0551
0552
0553
0554
0555
0556
0557 for (int jjj = 0; jjj < nx; jjj++) {
0558 for (int kkk = 0; kkk < ny; kkk++) {
0559
0560 if (flagHBP17selection == 0 ||
0561 (flagHBP17selection == 1 && (((jjj > 56 && jjj < 62) && (kkk > 63 && kkk < 68)) ||
0562 ((jjj > 61 && jjj < 71) && (kkk == 64 || kkk == 66)))) ||
0563 (flagHBP17selection == 2 && !(((jjj > 14 && jjj < 25) && (kkk > 55 && kkk < 64))))) {
0564 if (Ceff1->GetBinContent(jjj, kkk) > cutMinA && Ceff1->GetBinContent(jjj, kkk) < cutMaxA)
0565 mapRATIO[1][jjj][kkk] = Ceff1->GetBinContent(jjj, kkk);
0566 if (Ceff2->GetBinContent(jjj, kkk) > cutMinA && Ceff2->GetBinContent(jjj, kkk) < cutMaxA)
0567 mapRATIO[2][jjj][kkk] = Ceff2->GetBinContent(jjj, kkk);
0568
0569
0570 }
0571 }
0572 }
0573
0574
0575
0576
0577
0578
0579
0580
0581
0582
0583
0584
0585
0586
0587
0588
0589
0590
0591
0592
0593
0594 int totalhep17count = 0;
0595 int totalhep17count1 = 0;
0596 int totalhep17count2 = 0;
0597 int totalhep17count3 = 0;
0598 int totalhep17count4 = 0;
0599 int totalhep17count5 = 0;
0600 int totalhep17count6 = 0;
0601 int totalhep17count7 = 0;
0602 for (int iii = 1; iii < NDEP; iii++) {
0603 for (int jjj = 0; jjj < nx; jjj++) {
0604 for (int kkk = 0; kkk < ny; kkk++) {
0605
0606
0607 if (mapRATIO[iii][jjj][kkk] > 0) {
0608
0609 totalhep17count++;
0610 if (verbosity == 4 && k1 == 0) {
0611 cout << " k1= " << k1 << " depth= " << iii << " eta= " << jjj << " phi= " << kkk
0612 << " mapRATIO= " << mapRATIO[iii][jjj][kkk] << endl;
0613 }
0614 if (iii == 1)
0615 totalhep17count1++;
0616 if (iii == 2)
0617 totalhep17count2++;
0618 if (iii == 3)
0619 totalhep17count3++;
0620 if (iii == 4)
0621 totalhep17count4++;
0622 if (iii == 5)
0623 totalhep17count5++;
0624 if (iii == 6)
0625 totalhep17count6++;
0626 if (iii == 7)
0627 totalhep17count7++;
0628
0629 mapRATIOD2[jjj][kkk] += mapRATIO[iii][jjj][kkk];
0630
0631 mapRATIOD20[jjj][kkk]++;
0632 if (verbosity == 3 && iii == 3)
0633 cout << " depth = " << iii << " k1 = " << k1 << " eta = " << jjj
0634 << " mapRATIOD2[jjj][kkk] = " << mapRATIOD2[jjj][kkk] << " #entries = " << mapRATIOD20[jjj][kkk]
0635 << " mapRATIO[iii][jjj][kkk] = " << mapRATIO[iii][jjj][kkk] << endl;
0636 }
0637 }
0638 }
0639 }
0640
0641
0642
0643
0644 if (verbosity == 4 && k1 == 0) {
0645 cout << " k1= " << k1 << " totalhep17count= " << totalhep17count << endl;
0646 cout << " k1= " << k1 << " totalhep17count1= " << totalhep17count1 << endl;
0647 cout << " k1= " << k1 << " totalhep17count2= " << totalhep17count2 << endl;
0648 cout << " k1= " << k1 << " totalhep17count3= " << totalhep17count3 << endl;
0649 cout << " k1= " << k1 << " totalhep17count4= " << totalhep17count4 << endl;
0650 cout << " k1= " << k1 << " totalhep17count5= " << totalhep17count5 << endl;
0651 cout << " k1= " << k1 << " totalhep17count6= " << totalhep17count6 << endl;
0652 cout << " k1= " << k1 << " totalhep17count7= " << totalhep17count7 << endl;
0653 }
0654
0655
0656
0657 Int_t depthAVERAGEcount = 0;
0658 for (int jjj = 0; jjj < nx; jjj++) {
0659 for (int kkk = 0; kkk < ny; kkk++) {
0660
0661
0662 depthAVERAGEcount = 4 * (jjj - 57) + (kkk - 64);
0663 if (mapRATIOD20[jjj][kkk] != 0) {
0664 NotEmptyDepthes->Fill(float(depthAVERAGEcount));
0665 if (verbosity == 1)
0666 cout << "****aver per depthes********* phi = " << kkk << " RunIndex = " << k1 << " eta = " << jjj
0667 << " #entries = " << mapRATIOD20[jjj][kkk] << endl;
0668 mapRATIOD2[jjj][kkk] /= mapRATIOD20[jjj][kkk];
0669 if (verbosity == 3 && kkk == 3)
0670 cout << "****aver per depthes********* phi = " << jjj << " RunIndex = " << k1 << " eta = " << jjj
0671 << " Nphi = " << mapRATIOD20[jjj][kkk] << endl;
0672 }
0673 }
0674 }
0675
0676
0677
0678 if (k1 == firstrun && kmm == 0) {
0679 kmm = 1;
0680 cout << "* to be printed once only CHBCK IT please ************ kmm = " << kmm << endl;
0681
0682
0683 for (int jjj = 0; jjj < nx; jjj++) {
0684 for (int kkk = 0; kkk < ny; kkk++) {
0685 normalization[jjj][kkk] = mapRATIOD2[jjj][kkk];
0686 }
0687 }
0688 }
0689
0690
0691
0692
0693
0694
0695
0696 for (int jjj = 0; jjj < nx; jjj++) {
0697 for (int kkk = 0; kkk < ny; kkk++) {
0698 if (normalization[jjj][kkk] != 0) {
0699 GSMRATIOD2[k1][jjj][kkk] = mapRATIOD2[jjj][kkk] / normalization[jjj][kkk];
0700
0701 if (GSMRATIOD2[k1][jjj][kkk] < RrangeMAX && GSMRATIOD2[k1][jjj][kkk] > RrangeMIN) {
0702 gainkoeff->Fill(GSMRATIOD2[k1][jjj][kkk]);
0703 gainkoeff0->Fill(GSMRATIOD2[k1][jjj][kkk]);
0704 gainkoeff9->Fill(GSMRATIOD2[k1][jjj][kkk]);
0705
0706
0707
0708
0709
0710 GOODruns->Fill(float(k1));
0711 } else {
0712 if (GSMRATIOD2[k1][jjj][kkk] > 0.)
0713 BADruns->Fill(float(k1));
0714 }
0715
0716
0717 }
0718 }
0719 }
0720
0721
0722
0723
0724
0725
0726
0727
0728 for (int jjj = 0; jjj <= 82; jjj++) {
0729 for (int kkk = 0; kkk <= 72; kkk++) {
0730 mapRATIOD2[jjj][kkk] = 0.;
0731 mapRATIOD20[jjj][kkk] = 0.;
0732 for (int iii = 0; iii < NDEP; iii++) {
0733 mapRATIO[iii][jjj][kkk] = 0.;
0734 }
0735 }
0736 }
0737
0738
0739
0740 hfile->Close();
0741
0742
0743
0744
0745
0746
0747 }
0748 cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DONE: last LED run READ " << endl;
0749
0750
0751
0752
0753
0754
0755
0756
0757
0758
0759
0760
0761
0762 cout << "**** **** **** **** **** Draw Dependencies: *** " << endl;
0763
0764
0765 Int_t Method = NMethodsStart;
0766 while (Method < NMethodsToUse + 1) {
0767 if (Method != 9999992) {
0768 cout << " **** START Method " << Method << endl;
0769
0770 if (Method == 0) {
0771 cout << "****Draw 0 Dependencies: <Aijk> for each event and all LED runs *** " << endl;
0772 gPad->SetGridy();
0773 gPad->SetGridx();
0774 gPad->SetLogy();
0775 gStyle->SetOptStat(101110);
0776 Ceff1D->SetMarkerStyle(20);
0777 Ceff1D->SetMarkerSize(0.4);
0778 Ceff1D->GetYaxis()->SetLabelSize(0.04);
0779 Ceff1D->SetTitle("all runs & channels");
0780 Ceff1D->SetXTitle("<Aijk>");
0781 Ceff1D->SetYTitle("N");
0782 Ceff1D->SetMarkerColor(4);
0783 Ceff1D->SetLineColor(4);
0784
0785 Ceff1D->Draw("PL");
0786 }
0787
0788 if (Method == 1) {
0789 cout << "****Draw 1 Dependencies: <Aijk> for each event and all LED runs ZOOM *** " << endl;
0790 gPad->SetGridy();
0791 gPad->SetGridx();
0792 gPad->SetLogy();
0793 gStyle->SetOptStat(101110);
0794
0795 Seff1D->SetMarkerStyle(20);
0796 Seff1D->SetMarkerSize(0.4);
0797 Seff1D->GetYaxis()->SetLabelSize(0.04);
0798 Seff1D->SetTitle("ZOOM all runs & channels");
0799 Seff1D->SetXTitle("<Aijk> ZOOM ");
0800 Seff1D->SetYTitle("N");
0801 Seff1D->SetMarkerColor(4);
0802 Seff1D->SetLineColor(4);
0803
0804 Seff1D->Draw("PL");
0805 }
0806
0807
0808 if (Method == 2) {
0809 cout << "****Draw 2 Dependencies: GSM ratio vs days *** " << endl;
0810 for (int k1 = 0; k1 < NP; k1++) {
0811 YY[k1] = 0.;
0812 }
0813
0814
0815
0816 TPad* pad1 = new TPad("pad1", "This is pad1", 0.02, 0.02, 0.99, 0.99, 0);
0817 pad1->Draw();
0818 pad1->cd();
0819 pad1->Range(-0.255174, -19.25, 2.29657, -6.75);
0820
0821 pad1->DrawFrame(x1, y1, x2, y2);
0822
0823 pad1->GetFrame()->SetFillColor(0);
0824 pad1->Draw();
0825 gPad->SetGridy();
0826 gPad->SetGridx();
0827
0828 Int_t colorlines = 0;
0829 Int_t generalcount = 0;
0830
0831
0832 for (int jjj = 0; jjj < 82; jjj++) {
0833 for (int kkk = 0; kkk < 72; kkk++) {
0834 Int_t sscount = -1;
0835 for (int k1 = 0; k1 < NP; k1++) {
0836 if (GSMRATIOD2[k1][jjj][kkk] != 0) {
0837
0838
0839 if (GSMRATIOD2[k1][jjj][kkk] < RrangeMAX && GSMRATIOD2[k1][jjj][kkk] > RrangeMIN) {
0840
0841
0842 sscount++;
0843 YY[sscount] = GSMRATIOD2[k1][jjj][kkk];
0844 XXX[sscount] = XX[k1];
0845 indWAS[sscount] = k1;
0846 mapBADchannels->Fill(double(jjj) - 42., double(kkk) - 1., GSMRATIOD2[k1][jjj][kkk]);
0847 mapBADchannels0->Fill(double(jjj) - 42., double(kkk) - 1., 1.);
0848 }
0849 else {
0850
0851 }
0852 }
0853 }
0854 Int_t MMcount = sscount + 1;
0855 if (MMcount > 0) {
0856 generalcount++;
0857 if (generalcount == 1 && verbosity == 2)
0858 for (int k1 = 0; k1 < MMcount; k1++) {
0859 cout << "**** All GOOD runs: indWAS[k1](1,..) = " << indWAS[k1] + 1 << " XXX[k1]+1 = " << XXX[k1] + 1
0860 << endl;
0861 }
0862 gr1 = new TGraph(MMcount, XXX, YY);
0863 colorlines = generalcount / 5. + 2;
0864 gr1->SetLineColor(colorlines);
0865 gr1->SetMarkerColor(colorlines);
0866 gr1->SetMarkerStyle(20);
0867 gr1->SetMarkerSize(1.2);
0868 gr1->SetFillStyle(0);
0869 gr1->GetXaxis()->SetTitle("days");
0870 gr1->GetYaxis()->SetTitle("R");
0871 gr1->Draw("PL");
0872 }
0873
0874 }
0875 }
0876
0877
0878
0879 TLegend leg(xx1, yy1, xx2, yy2, "HB: R vs t(days)");
0880
0881 leg.SetMargin(0.3);
0882 leg.SetBorderSize(1);
0883 leg.DrawClone("Same");
0884
0885
0886
0887
0888
0889
0890
0891
0892
0893
0894
0895
0896
0897
0898
0899 }
0900
0901
0902
0903 if (Method == 3) {
0904 cout << "****Draw 3 Dependencies: 2D channels *** " << endl;
0905 TH2F* Cdepth2hbff = (TH2F*)mapBADchannels->Clone("Cdepth2hbff");
0906 Cdepth2hbff->Divide(mapBADchannels, mapBADchannels0, 1, 1, "B");
0907 Cdepth2hbff->Sumw2();
0908 gPad->SetGridy();
0909 gPad->SetGridx();
0910 gStyle->SetOptStat(0000000);
0911 Cdepth2hbff->SetMarkerStyle(20);
0912 Cdepth2hbff->SetMarkerSize(0.4);
0913 Cdepth2hbff->GetYaxis()->SetLabelSize(0.04);
0914 Cdepth2hbff->SetTitle("within R & Weighted by R");
0915 Cdepth2hbff->SetXTitle("#eta \b");
0916 Cdepth2hbff->SetYTitle("#phi \b");
0917 Cdepth2hbff->SetMarkerColor(4);
0918 Cdepth2hbff->SetLineColor(4);
0919 Cdepth2hbff->Draw("COLZ");
0920 }
0921
0922 if (Method == 4) {
0923 cout << "****Draw 4 Dependencies: gains LED runs *** " << endl;
0924 gPad->SetGridy();
0925 gPad->SetGridx();
0926
0927
0928 gStyle->SetOptStat(1100);
0929
0930 gainkoeff->SetMarkerStyle(20);
0931 gainkoeff->SetMarkerSize(0.4);
0932 gainkoeff->GetYaxis()->SetLabelSize(0.04);
0933 gainkoeff->SetXTitle("gains");
0934 gainkoeff->SetYTitle("N");
0935 gainkoeff->SetMarkerColor(4);
0936 gainkoeff->SetLineColor(4);
0937
0938 gainkoeff->Draw("PL");
0939 }
0940
0941 if (Method == 5) {
0942 cout << "****Draw 5 Dependencies: gains LED runs *** " << endl;
0943 gPad->SetGridy();
0944 gPad->SetGridx();
0945 gPad->SetLogy();
0946
0947 gStyle->SetOptStat(1100);
0948
0949 gainkoeff9->SetMarkerStyle(20);
0950 gainkoeff9->SetMarkerSize(0.4);
0951 gainkoeff9->GetYaxis()->SetLabelSize(0.04);
0952 gainkoeff9->SetXTitle("gains");
0953 gainkoeff9->SetYTitle("N");
0954 gainkoeff9->SetMarkerColor(4);
0955 gainkoeff9->SetLineColor(4);
0956
0957 gainkoeff9->Draw("PL");
0958 }
0959
0960 if (Method == 6) {
0961 cout << "****Draw 6 Dependencies: gains LED runs *** " << endl;
0962 gPad->SetGridy();
0963 gPad->SetGridx();
0964 gPad->SetLogy();
0965
0966 gStyle->SetOptStat(1100);
0967
0968 gainkoeff0->SetMarkerStyle(20);
0969 gainkoeff0->SetMarkerSize(0.4);
0970 gainkoeff0->GetYaxis()->SetLabelSize(0.04);
0971 gainkoeff0->SetXTitle("gains");
0972 gainkoeff0->SetYTitle("N");
0973 gainkoeff0->SetMarkerColor(4);
0974 gainkoeff0->SetLineColor(4);
0975
0976 gainkoeff0->Draw("PL");
0977 }
0978
0979 if (Method == 7) {
0980 cout << "****Draw 7 Dependencies: BADruns *** " << endl;
0981 gPad->Update();
0982 gPad->SetGridy();
0983 gPad->SetGridx();
0984 gPad->SetLogy(kFALSE);
0985 gStyle->SetOptStat(101110);
0986 BADruns->SetMarkerStyle(20);
0987 BADruns->SetMarkerSize(0.4);
0988 BADruns->GetYaxis()->SetLabelSize(0.04);
0989 BADruns->SetTitle("#channels outside Rrange VS iRun");
0990 BADruns->SetXTitle("iRun");
0991 BADruns->SetYTitle("#channels");
0992 BADruns->SetMarkerColor(4);
0993 BADruns->SetLineColor(4);
0994
0995 BADruns->Draw("PL");
0996
0997
0998 int cx = BADruns->GetXaxis()->GetNbins();
0999 cout << "***** ************* Number of runs w/ R outside unit-range = " << cx << endl;
1000 int nbadruns = 0;
1001 for (int jjj = 1; jjj <= cx; jjj++) {
1002 if (BADruns->GetBinContent(jjj) > 200.) {
1003 cout << "BADruns w/ content>60: jjj= " << jjj << " run= " << LEDruns[jjj - 1]
1004 << " R ouside unit-range for # channels= " << BADruns->GetBinContent(jjj) << endl;
1005 ++nbadruns;
1006 }
1007
1008 }
1009 cout << "BADruns w/ content>60 nbadruns= " << nbadruns << endl;
1010
1011 }
1012
1013
1014 if (Method == 8) {
1015 cout << "****Draw 8 Dependencies: Goodruns *** " << endl;
1016 gPad->SetGridy();
1017 gPad->SetGridx();
1018
1019 gStyle->SetOptStat(101110);
1020 GOODruns->SetMarkerStyle(20);
1021 GOODruns->SetMarkerSize(0.4);
1022 GOODruns->GetYaxis()->SetLabelSize(0.04);
1023 GOODruns->SetTitle("#channels inside Rrange VS iRun");
1024 GOODruns->SetXTitle("iRun");
1025 GOODruns->SetYTitle("#channels");
1026 GOODruns->SetMarkerColor(4);
1027 GOODruns->SetLineColor(4);
1028
1029 GOODruns->Draw("PL");
1030
1031
1032 int cx = GOODruns->GetXaxis()->GetNbins();
1033 cout << "************* cx = " << cx << endl;
1034 for (int jjj = 0; jjj <= cx; jjj++) {
1035
1036
1037 if (GOODruns->GetBinContent(jjj) > 1400.)
1038 cout << "GOODruns: k1(0,...)= " << jjj
1039 << " GOODruns->GetBinContent(jjj)= " << GOODruns->GetBinContent(jjj) << endl;
1040 }
1041
1042 }
1043
1044
1045 if (Method == 9) {
1046 cout << "****Draw 9 Dependencies: depthes with zero A *** " << endl;
1047 gPad->SetGridy();
1048 gPad->SetGridx();
1049 gPad->SetLogy(kFALSE);
1050 gStyle->SetOptStat(1110000);
1051 NotEmptyDepthes->SetMarkerStyle(20);
1052 NotEmptyDepthes->SetMarkerSize(0.4);
1053 NotEmptyDepthes->GetYaxis()->SetLabelSize(0.04);
1054 NotEmptyDepthes->SetTitle("# Not Empty Channels in etq-phi projection");
1055 NotEmptyDepthes->SetXTitle("4*(eta-57)+(phi-64)");
1056 NotEmptyDepthes->SetYTitle("N");
1057 NotEmptyDepthes->SetMarkerColor(4);
1058 NotEmptyDepthes->SetLineColor(4);
1059
1060 NotEmptyDepthes->Draw("PL");
1061 }
1062
1063 if (Method == 10) {
1064 cout << "****Draw 10 Dependencies: Aijk for each event and all LED runs *** " << endl;
1065
1066 c1->Clear();
1067 c1->Divide(1, 1);
1068
1069 c1->cd(1);
1070
1071
1072
1073
1074 gPad->SetGridy();
1075 gPad->SetGridx();
1076 gPad->SetLogy();
1077 gStyle->SetOptStat(101110);
1078
1079 Aeff1D->SetMarkerStyle(20);
1080 Aeff1D->SetMarkerSize(0.4);
1081 Aeff1D->GetYaxis()->SetLabelSize(0.04);
1082 Aeff1D->SetTitle("all runs & events& channels");
1083 Aeff1D->SetXTitle("Aijk");
1084 Aeff1D->SetYTitle("N");
1085 Aeff1D->SetMarkerColor(4);
1086 Aeff1D->SetLineColor(4);
1087
1088
1089 Aeff1D->SetMinimum(0.8);
1090 Aeff1D->Draw("");
1091
1092 c1->Update();
1093
1094 }
1095
1096 if (Method == 11) {
1097 cout << "****Draw 11 <A>: 2D Depthes1,2,3,4 *** " << endl;
1098
1099
1100
1101 c1->Clear();
1102 c1->Divide(1, 2);
1103
1104 c1->cd(1);
1105 mapchannelsdepth1->SetStats(0);
1106 mapchannelsdepth1->SetTitle("<A> Depth1");
1107 mapchannelsdepth1->SetXTitle("#eta \b");
1108 mapchannelsdepth1->SetYTitle("#phi \b");
1109 mapchannelsdepth1->Draw("COLZ");
1110 c1->cd(2);
1111 mapchannelsdepth2->SetStats(0);
1112 mapchannelsdepth2->SetTitle("<A> Depth2");
1113 mapchannelsdepth2->SetXTitle("#eta \b");
1114 mapchannelsdepth2->SetYTitle("#phi \b");
1115 mapchannelsdepth2->Draw("COLZ");
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130 c1->Update();
1131
1132 }
1133
1134 if (Method == 12) {
1135 cout << "****Draw 12 not used yet *** " << endl;
1136
1137
1138
1139 c1->Clear();
1140 c1->Divide(2, 2);
1141
1142 c1->cd(1);
1143 c1->cd(2);
1144 c1->cd(3);
1145
1146 c1->Update();
1147
1148 }
1149
1150
1151 if (Method == 13) {
1152 cout << "****Draw 13 function, fC *** " << endl;
1153 c1->Clear();
1154 c1->Divide(1, 1);
1155
1156 c1->cd(1);
1157 {
1158 double c0 = 1.000000;
1159 double b1 = 2.71238e-05;
1160 double a2 = 1.32877e-10;
1161 Int_t n = 50;
1162 Double_t x[n], y[n];
1163 for (Int_t i = 0; i < n; i++) {
1164 x[i] = (i + 1) * 20000.;
1165 y[i] = a2 * x[i] * x[i] / 40. / 40. + b1 * x[i] / 40. + c0;
1166 }
1167
1168
1169 TGraph* gr = new TGraph(n, x, y);
1170
1171
1172
1173 gPad->SetGridy();
1174 gPad->SetGridx();
1175
1176 gr->Draw("AC*");
1177
1178
1179
1180
1181
1182
1183 }
1184
1185 c1->Update();
1186
1187 }
1188
1189
1190
1191
1192
1193
1194 TString fdir = "testamt5gsmHB2018/";
1195
1196 TString plotName = fdir + MethodName[Method] + ".png";
1197 c1->SaveAs(plotName);
1198 cout << "****PLOT " << Method << " drawn **** " << endl;
1199
1200 }
1201 ++Method;
1202 }
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218 gSystem->Exit(0);
1219
1220 }
1221