//----------------------------------------------------------ROOT includes-------------------------------------------------------

#include <TSystem.h>
#include <TH1.h>
#include <TH2.h>
#include <TProfile.h>
#include <TProfile2D.h>
#include <TSpline.h>
#include <TChain.h>
#include <TGraph.h>
#include <TTree.h>
#include <TFile.h>
#include <TList.h>
#include <TCanvas.h>
#include <TPDF.h>
#include <TPostScript.h>
#include <TPaveText.h>
#include <TStyle.h>
#include <TMath.h>
#include <TLine.h>
#include <TF1.h>
#include <TLegend.h>
#include <TPad.h>
#include <THistPainter.h>
#include <TCanvas.h>
#include <TDirectoryFile.h>
#include <string>
#include <cstring>
#include <vector>
#include <sstream>
#include <fstream>

double   ZoomAuto2D(TH2F* Histo,int iMax)
{
        double Zmax=Histo->GetMaximum();

        for(int i=0;i<iMax;i++)
        {
                Zmax=Histo->GetMaximum(Zmax);
        }

        return Zmax;
}

void  MacroQA()
{


//-------------------------------------------------------Variable declaration---------------------------------------------------

        vector<TFile*> TFileList;
        vector<TList*> TListList;
        vector<string> XAxisLabels;
        vector<double> TRUSumValue(30,0.);
        vector<double> TRUSigma(30,0.);
        vector<double> TRUNormSquareMean(30,0.);
        vector<int> TRUSize(30,0);
        vector<bool> IllTRU(30,false);
        vector<bool> MaskHS(2880,true);
        vector<bool> MaskVHS(2880,true);

        vector< vector<bool> > MaskL0;

        int VectorSize(0);
        int TRUPos(0);
        int MaskPos;
        int AntiMaskSize(0);
        int FastORNumberInLine;
        int CircleSideLength;
        int CheckedFastORNumber;
        int lap;
        int AxisPower;
        int DirectionPower;
        int BinXBis;
        int BinYBis;
        int HSSize;
        int HSCount;
        int VHSCount;

        const int BinXL0(48+1);
        const int BinYL0(60+1);
        const int BinXL1G(47+1);
        const int BinYL1G(59+1);
        const int BinXL1J(9+1);
        const int BinYL1J(13+1);

        double DeadZoneRate(0.);
        double MaxGap(-1.);
        double NormSquareMean(0.);
        double NormSigma(0.);
        double MeanSigma(0.);
        double MeanTRUAmp(0.);
        double GridAmp(0.);
        double GridAmpL1(0.);
        double MeanValue(0.);
        double MaxAmp;
        double IntAmp;
        double HSAmp;
        double VHSAmp;
        double TRUTotalSumValue(0.);

        bool HSSurroundingClear;
        bool HSSurrounded;
        bool VHSDetected;


//---------------------------------------------------------Loading Files--------------------------------------------------------

        ifstream ListFlux("ListeRuns.txt");

        /*
        //Loading RefRun
        TFile *RefFile = new TFile("/home/romain/Bureau/Runs/Run ESD/pp/177 798/Merged_177798.root","read");
        TList *RefList = (TList *) RefFile->Get("EMCALQATrigger");
        */

        if(ListFlux)
        {
                ListFlux.seekg(0, ios::end);
                int FileSize = ListFlux.tellg();
                ListFlux.seekg(0, ios::beg);
                int CursPos;
                string TempName;
                do
                {
                        getline(ListFlux,TempName);
                        if (!TFile(TempName.c_str(),"read").IsZombie())
                        {
                                TFileList.push_back(new TFile(TempName.c_str(),"read"));
                                XAxisLabels.push_back(TempName.substr(TempName.size()-11,6));
                        }
                        CursPos=ListFlux.tellg();
                } while(CursPos<FileSize-1);
                VectorSize = TFileList.size();
        }


//------------------------------------------------------Definition of Canvas-----------------------------------------------------

        TCanvas *c1 = new TCanvas("c1","Main QA",1000,800);
        c1->Divide(3,3);
        gStyle->SetOptFit(1111);
        gStyle->SetOptStat("");

        TCanvas *c2 = new TCanvas("c2","HotSpots",500,400);
        c2->Divide(2,1);
        gStyle->SetOptFit(1111);
        gStyle->SetOptStat("");

        TCanvas *c3 = new TCanvas("c3","Eta & Phi projection, all Clusters",500,400);
        c3->Divide(4,3);
        gStyle->SetOptFit(1111);
        gStyle->SetOptStat("");

        TCanvas *c4 = new TCanvas("c4","Eta & Phi projection, MaxEnergy Clusters",500,400);
        c4->Divide(4,3);
        gStyle->SetOptFit(1111);
        gStyle->SetOptStat("");


//---------------------------------------------Definition of all the histos------------------------------------------------------

        TH1F *hQADeadZone = new TH1F("hQADeadZone","Dead zone rate per run",VectorSize,0,VectorSize);

        TH1F *hQAMaxTriggerGapL1G = new TH1F("hQAMaxTriggerGapL1G","Maximum Trigger Gap for L1G per run",VectorSize,0,VectorSize);
        TH1F *hQASigmaL1G = new TH1F("hQASigmaL1G","Normalized Standard Deviation for L1G per run",VectorSize,0,VectorSize);

        TH1F *hQAMaxTriggerGapL1J = new TH1F("hQAMaxTriggerGapL1J","Maximum Trigger Gap for L1J per run",VectorSize,0,VectorSize);
        TH1F *hQASigmaL1J = new TH1F("hQASigmaL1J","Normalized Standard Deviation for L1J per run",VectorSize,0,VectorSize);

        TH2F *hQAClusEtaL1G = new TH2F("hQAClusEtaL1G","Eta distribution of clusters for L1G per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusEtaL1J = new TH2F("hQAClusEtaL1J","Eta distribution of clusters for L1J per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusPhiL1G = new TH2F("hQAClusPhiL1G","Phi distribution of clusters for L1G per run",VectorSize,0,VectorSize,100,1.4,3.14);
        TH2F *hQAClusPhiL1J = new TH2F("hQAClusPhiL1J","Phi distribution of clusters for L1J per run",VectorSize,0,VectorSize,100,1.4,3.14);

        TH2F *hQAClusEtaL1GOnly = new TH2F("hQAClusEtaL1GOnly","Eta distribution of clusters for L1GOnly per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusEtaL1JOnly = new TH2F("hQAClusEtaL1JOnly","Eta distribution of clusters for L1JOnly per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusPhiL1GOnly = new TH2F("hQAClusPhiL1GOnly","Phi distribution of clusters for L1GOnly per run",VectorSize,0,VectorSize,100,1.4,3.14);
        TH2F *hQAClusPhiL1JOnly = new TH2F("hQAClusPhiL1JOnly","Phi distribution of clusters for L1JOnly per run",VectorSize,0,VectorSize,100,1.4,3.14);

        TH2F *hQAClusEtaL0 = new TH2F("hQAClusEtaL0","Eta distribution of clusters for L0 per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusEtaMB = new TH2F("hQAClusEtaMB","Eta distribution of clusters for MB per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusPhiL0 = new TH2F("hQAClusPhiL0","Phi distribution of clusters for L0 per run",VectorSize,0,VectorSize,100,1.4,3.14);
        TH2F *hQAClusPhiMB = new TH2F("hQAClusPhiMB","Phi distribution of clusters for MB per run",VectorSize,0,VectorSize,100,1.4,3.14);

        TH2F *hQAClusMaxEtaL1G = new TH2F("hQAClusMaxEtaL1G","Eta distribution of Max clusters for L1G per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusMaxEtaL1J = new TH2F("hQAClusMaxEtaL1J","Eta distribution of Max clusters for L1J per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusMaxPhiL1G = new TH2F("hQAClusMaxPhiL1G","Phi distribution of Max clusters for L1G per run",VectorSize,0,VectorSize,100,1.4,3.14);
        TH2F *hQAClusMaxPhiL1J = new TH2F("hQAClusMaxPhiL1J","Phi distribution of Max clusters for L1J per run",VectorSize,0,VectorSize,100,1.4,3.14);

        TH2F *hQAClusMaxEtaL1GOnly = new TH2F("hQAClusMaxEtaL1GOnly","Eta distribution of Max clusters for L1GOnly per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusMaxEtaL1JOnly = new TH2F("hQAClusMaxEtaL1JOnly","Eta distribution of Max clusters for L1JOnly per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusMaxPhiL1GOnly = new TH2F("hQAClusMaxPhiL1GOnly","Phi distribution of Max clusters for L1GOnly per run",VectorSize,0,VectorSize,100,1.4,3.14);
        TH2F *hQAClusMaxPhiL1JOnly = new TH2F("hQAClusMaxPhiL1JOnly","Phi distribution of Max clusters for L1JOnly per run",VectorSize,0,VectorSize,100,1.4,3.14);

        TH2F *hQAClusMaxEtaL0 = new TH2F("hQAClusMaxEtaL0","Eta distribution of Max clusters for L0 per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusMaxEtaMB = new TH2F("hQAClusMaxEtaMB","Eta distribution of Max clusters for MB per run",VectorSize,0,VectorSize,131,-0.8,0.8);
        TH2F *hQAClusMaxPhiL0 = new TH2F("hQAClusMaxPhiL0","Phi distribution of Max clusters for L0 per run",VectorSize,0,VectorSize,100,1.4,3.14);
        TH2F *hQAClusMaxPhiMB = new TH2F("hQAClusMaxPhiMB","Phi distribution of Max clusters for MB per run",VectorSize,0,VectorSize,100,1.4,3.14);

        TH2I *hQATRU = new TH2I("hQATRU","         List of problematic TRU per run",VectorSize,0,VectorSize,30,0.5,30.5);

        TH1F *hQAGridAmp = new TH1F("hQAGridAmp","Normalized Grid Amp for L0 & L1",VectorSize,0,VectorSize);
        TH1F *hQAGridAmpL1 = new TH1F("hQAGridAmpL1","Grid Amplitude for L1Amp per run",VectorSize,0,VectorSize);

        TH1I *hQAHSCount = new TH1I("hQAHSCount","Number of HotSpots for L0Amp per run",VectorSize,0,VectorSize);
        TH1F *hQAHSAmp = new TH1F("hQAHSAmp","HotSpots Total Amplitude for L0Amp per run",VectorSize,0,VectorSize);

        for(int i=0;i<VectorSize;i++) //Main loop
        {
                TListList.push_back((TList *) TFileList[i]->Get("EMCALQATrigger"));


//-----------------------------------------------------Filling XAxisLabels------------------------------------------------------

                hQADeadZone                     ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAMaxTriggerGapL1G     ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQASigmaL1G                     ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAMaxTriggerGapL1J     ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQASigmaL1J                     ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusEtaL1G                   ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusEtaL1J                   ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusPhiL1G                   ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusPhiL1J                   ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusEtaL0                    ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusEtaMB                    ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusPhiL0                    ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusPhiMB                    ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusEtaL1GOnly               ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusEtaL1JOnly               ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusPhiL1GOnly               ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusPhiL1JOnly               ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxEtaL1G                ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxEtaL1J                ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxPhiL1G                ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxPhiL1J                ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxEtaL0         ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxEtaMB         ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxPhiL0         ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxPhiMB         ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxEtaL1GOnly    ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxEtaL1JOnly    ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxPhiL1GOnly    ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAClusMaxPhiL1JOnly    ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQATRU                          ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAGridAmp                      ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAHSCount                      ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());
                hQAHSAmp                                ->GetXaxis()->SetBinLabel(i+1,XAxisLabels[i].c_str());


//-----------------------------------------------------Creating the grid Mask----------------------------------------------------
//ths MaskPos starts from (0,0) and scan the x axis until x=48, then goes on x=0, y=1, etc.

                MaskL0.push_back(vector<bool>(2880,true));

                for(int binx=2;binx<25;binx+=2)
                {
                        for(int biny=2;biny<25;biny+=2)
                        {
                                MaskPos = binx-1+(biny-1)*48;
                                MaskL0[i][MaskPos] = false;
                        }
                }

                for(int binx=25;binx<48;binx+=2)
                {
                        for(int biny=1;biny<36;biny+=2)
                        {
                                MaskPos = binx-1+(biny-1)*48;
                                MaskL0[i][MaskPos] = false;
                        }
                }


//---------------------------------------Dead zone test on hL0Amp, Problematics TRU & Grid Amp part------------------------------

                TH2F *hL0Amp = (TH2F *) TListList[i]->FindObject("hL0Amp");
                TH2F *hL1Amp = (TH2F *) TListList[i]->FindObject("hL1Amp");

                GridAmp = 0.;
                GridAmpL1 = 0.;
                DeadZoneRate = 0.;

                for(int binx=1;binx<BinXL0;binx++)
                {
                        for(int biny=1;biny<BinYL0;biny++)
                        {
                                MaskPos = binx-1+(biny-1)*48;

                                //----------------------Grid part (done before the dead zone, mandatory)-------------------

                                if(MaskL0[i][MaskPos] == false)
                                {
                                        GridAmp += hL0Amp->GetBinContent(binx,biny);
                                        GridAmpL1 += hL1Amp->GetBinContent(binx,biny);
                                }


                                //--------------------------------------Dead zone test-------------------------------------

                                if(hL0Amp->GetBinContent(binx,biny) == 0)
                                {
                                        DeadZoneRate += 1;
                                        MaskL0[i][MaskPos] = false;
                                }


                                //----------------------------------------TRU part-----------------------------------------

                                TRUPos = 0;

                                if(binx<25)
                                {
                                        TRUPos = 15;
                                }

                                TRUPos += ceil((BinYL0-1-biny)/4);

                                if(MaskL0[i][MaskPos])
                                {
                                        TRUSumValue[TRUPos] += hL0Amp->GetBinContent(binx,biny);
                                        TRUNormSquareMean[TRUPos] += pow(hL0Amp->GetBinContent(binx,biny),2);
                                        TRUSize[TRUPos]++;
                                        TRUTotalSumValue += hL0Amp->GetBinContent(binx,biny);
                                }
                        }
                }
                DeadZoneRate /= 2880;
                hQADeadZone->SetBinContent(i+1,DeadZoneRate);

                GridAmp /= hL0Amp->GetSumOfWeights();
                hQAGridAmp->SetBinContent(i+1,GridAmp);

                GridAmpL1 /= hL1Amp->GetSumOfWeights();
                hQAGridAmpL1->SetBinContent(i+1,GridAmpL1);

                MeanSigma = 0.;
                MeanTRUAmp = 0.;

                for(int j=0;j<30;j++)
                {
                        TRUNormSquareMean[j] /= pow(TRUSumValue[j],2);
                        TRUSumValue[j] /= TRUTotalSumValue;
                        TRUSigma[j] = sqrt(TRUNormSquareMean[j]/TRUSize[j]-(pow(1./TRUSize[j],2)));
                        MeanSigma += TRUSigma[j];
                        MeanTRUAmp += TRUSumValue[j];
                }

                TRUTotalSumValue = 0.;
                MeanSigma /= 30;
                MeanTRUAmp /= 30;

                for(int j=0;j<30;j++)
                {
                        if(TRUSumValue[j] > MeanTRUAmp*1.15)
                        {
                                if(TRUSigma[j] < MeanSigma)
                                {
                                        IllTRU[j] = true;
                                        hQATRU->SetBinContent(i+1,j+1,1);
                                }
                        }

                        TRUSumValue[j] = 0.;
                        TRUNormSquareMean[j] = 0.;
                        TRUSigma[j] = 0.;
                        TRUSize[j] = 0;
                }

//---------------------------------------Test Max Trigger Gap L1G + normalized standard deviation--------------------------------

                TH2F *hL1GPatch=(TH2F *) TListList[i]->FindObject("hL1GPatch");

                MaxGap = -1.;
                NormSquareMean = 0.;

                for(int binx=1;binx<BinXL1G;binx++)
                {
                        for(int biny=1;biny<BinYL1G;biny++)
                        {
                                if(hL1GPatch->GetBinContent(binx,biny)/hL1GPatch->GetEntries() > MaxGap)
                                {
                                        MaxGap = hL1GPatch->GetBinContent(binx,biny)/hL1GPatch->GetEntries();
                                }
                                NormSquareMean += pow(hL1GPatch->GetBinContent(binx,biny),2)/pow(hL1GPatch->GetEntries(),2);
                        }
                }

                NormSigma = sqrt(NormSquareMean/2773-pow(1./2773,2));
                hQASigmaL1G->AddBinContent(i+1,NormSigma);
                hQAMaxTriggerGapL1G->AddBinContent(i+1,MaxGap);

//---------------------------------------------------TRU LINK Correlation--------------------------------------------------------

                for(int j=0;j<30;j++)
                {

                        if(j < 15)
                        {
                                for(int binx=25;binx<48;binx++)
                                        {
                                                for(int biny=BinYL1G-1-j*4-2;biny<BinYL1G-j*4;biny++)
                                                {
                                                        TRUSumValue[j] += hL1GPatch->GetBinContent(binx,biny);
                                                        TRUNormSquareMean[j] += pow(hL1GPatch->GetBinContent(binx,biny),2);
                                                        TRUSize[j]++;
                                                }
                                        }
                        }
                        else
                        {
                                for(int binx=1;binx<24;binx++)
                                        {
                                                for(int biny=BinYL1G-1-(j-15)*4-2;biny<BinYL1G-(j-15)*4;biny++)
                                                {
                                                        TRUSumValue[j] += hL1GPatch->GetBinContent(binx,biny);
                                                        TRUNormSquareMean[j] += pow(hL1GPatch->GetBinContent(binx,biny),2);
                                                        TRUSize[j]++;
                                                }
                                        }
                        }
                }

                MeanSigma = 0.;
                MeanTRUAmp = 0.;

                for(int j=0;j<30;j++)
                {
                        TRUNormSquareMean[j] /= pow(TRUSumValue[j],2);
                        TRUSumValue[j] /= hL1GPatch->GetEntries();
                        TRUSigma[j] = sqrt(TRUNormSquareMean[j]/TRUSize[j]-(pow(1./TRUSize[j],2)));
                        MeanSigma += TRUSigma[j];
                        MeanTRUAmp += TRUSumValue[j];
                }

                MeanSigma /= 30;
                MeanTRUAmp /= 30;

                for(int j=0;j<30;j++)
                {
                        if(TRUSumValue[j] > MeanTRUAmp*1.6)
                        {
                                if(TRUSigma[j] < MeanSigma*0.55)
                                {
                                        hQATRU->SetBinContent(i+1,j+1,5);
                                }
                        }

                        TRUSumValue[j] = 0.;
                        TRUNormSquareMean[j] = 0.;
                        TRUSigma[j] = 0.;
                        TRUSize[j] = 0;
                }


//-----------------------------------------------Grid filling with ill TRUs-----------------------------------------------------

                for(int j=0;j<30;j++)
                {
                        if(IllTRU[j] == true)
                        {
                                if(j+1 > 15)
                                {
                                        for(int binx=1;binx<25;binx++)
                                        {
                                                for(int biny=BinYL0-(j+1-15)*4;biny<BinYL0-(j-15)*4;biny++)
                                                {
                                                        MaskPos = binx-1+(biny-1)*48;
                                                        MaskL0[i][MaskPos] = false;
                                                }
                                        }
                                }
                                else
                                {
                                        for(int binx=25;binx<49;binx++)
                                        {
                                                for(int biny=BinYL0-(j+1)*4;biny<BinYL0-(j)*4;biny++)
                                                {
                                                        MaskPos = binx-1+(biny-1)*48;
                                                        MaskL0[i][MaskPos] = false;
                                                }
                                        }
                                }
                        }

                        IllTRU[j] = false;
                }


//------------------------------------Test Max Trigger Gap L1J + normalized standard deviation-----------------------------------

                TH2F *hL1JPatch=(TH2F *) TListList[i]->FindObject("hL1JPatch");

                MaxGap = -1.;
                NormSquareMean = 0.;

                for(int binx=1;binx<BinXL1J;binx++)
                {
                        for(int biny=1;biny<BinYL1J;biny++)
                        {
                                if(hL1JPatch->GetBinContent(binx,biny)/hL1JPatch->GetEntries()>MaxGap)
                                {
                                        MaxGap = hL1JPatch->GetBinContent(binx,biny)/hL1JPatch->GetEntries();
                                }
                                NormSquareMean += pow(hL1JPatch->GetBinContent(binx,biny),2)/pow(hL1JPatch->GetEntries(),2);
                        }
                }

                NormSigma = sqrt(NormSquareMean/117-pow(1./117,2));
                hQASigmaL1J->AddBinContent(i+1,NormSigma);
                hQAMaxTriggerGapL1J->AddBinContent(i+1,MaxGap);


//------------------------------------------------HotSpot search and listing-----------------------------------------------------

                AntiMaskSize=0;
                MeanValue=0.;


                //----------Calcul of the mean amp value of the EMCAL surface without Ill TRUs & Grid-----------

                for(int binx=1;binx<BinXL0;binx++)
                {
                        for(int biny=1;biny<BinYL0;biny++)
                        {
                                MaskPos = binx-1+(biny-1)*48;

                                if(MaskL0[i][MaskPos])
                                {
                                        MeanValue += hL0Amp->GetBinContent(binx,biny);
                                        AntiMaskSize++;
                                }
                        }
                }

                MeanValue /= AntiMaskSize;

                MaskHS = MaskL0[i];
                MaskVHS = MaskL0[i];
                int binx = 1;
                int biny = 1;
                HSCount = 0;
                HSAmp = 0.;
                VHSCount = 0;
                VHSAmp = 0.;


                //---------------VHS are VeryHotSpots : they have an amp > 100 x MeanValue-------------------

                while(biny<BinYL0)
                {
                        binx = 1;

                        while(binx<BinXL0)
                        {
                                MaskPos = binx-1+(biny-1)*48;

                                if(MaskHS[MaskPos])
                                {
                                        VHSDetected = false;

                                        if(hL0Amp->GetBinContent(binx,biny) > MeanValue*6)
                                        {
                                                //When a VHS is spotted, the MeanValue is too disturbed to be considered viable
                                                // -> we exclude the VHS from it and restart the HS search from the beginning
                                                if(hL0Amp->GetBinContent(binx,biny) > MeanValue*100)
                                                {
                                                        MeanValue *= AntiMaskSize;
                                                        MeanValue -= hL0Amp->GetBinContent(binx,biny);
                                                        AntiMaskSize--;
                                                        MeanValue /= AntiMaskSize;
                                                        MaskVHS[MaskPos] = false;
                                                        MaskHS = MaskVHS;
                                                        VHSDetected = true;
                                                        VHSCount++;
                                                        VHSAmp += hL0Amp->GetBinContent(binx,biny);
                                                        HSCount = 0;
                                                        HSAmp = 0.;
                                                        binx = 0;
                                                        biny = 1;
                                                }


                                                //---------------------------Classic HS Search---------------------------

                                                else
                                                {
                                                        CircleSideLength = 2;
                                                        CheckedFastORNumber = 0;
                                                        lap = 0;
                                                        AxisPower = 0;
                                                        DirectionPower = 0;
                                                        MaxAmp = hL0Amp->GetBinContent(binx,biny);
                                                        IntAmp = MaxAmp;
                                                        HSSize = 1;
                                                        BinXBis = binx;
                                                        BinYBis = biny;
                                                        HSSurrounded = false;
                                                        HSSurroundingClear = true;

                                                        //In order to define a HotSpot, when a hot FastOR is found we search around it, in circle,
                                                        //other hot FastOR. If nothing is found the HotSpot has been delimited

                                                        do
                                                        {
                                                                FastORNumberInLine = 0;
                                                                do
                                                                {
                                                                        if(FastORNumberInLine == CircleSideLength/2)
                                                                        {
                                                                                DirectionPower++;
                                                                        }

                                                                        if(pow(-1,DirectionPower) == 1)
                                                                        {
                                                                                BinXBis += pow(-1,AxisPower);
                                                                        }

                                                                        else
                                                                        {
                                                                                BinYBis += pow(-1,AxisPower);
                                                                        }

                                                                        MaskPos = BinXBis-1+(BinYBis-1)*48;

                                                                        if(BinXBis >= 1 && BinXBis <= 48 && BinYBis >= 1 && BinYBis <= 60)
                                                                        {
                                                                                if(MaskHS[MaskPos])
                                                                                {
                                                                                        if(hL0Amp->GetBinContent(BinXBis,BinYBis) > MeanValue*6)
                                                                                        {
                                                                                                //And again if we found a VHS during the "circle" search, we esclude it
                                                                                                //from the MeanValue and restart from zero
                                                                                                if(hL0Amp->GetBinContent(BinXBis,BinYBis) > MeanValue*100)
                                                                                                {
                                                                                                        MeanValue *= AntiMaskSize;
                                                                                                        MeanValue -= hL0Amp->GetBinContent(BinXBis,BinYBis);
                                                                                                        AntiMaskSize--;
                                                                                                        MeanValue /= AntiMaskSize;
                                                                                                        MaskVHS[MaskPos] = false;
                                                                                                        MaskHS = MaskVHS;
                                                                                                        binx = 0;
                                                                                                        biny = 1;
                                                                                                        HSCount = 0;
                                                                                                        VHSCount++;
                                                                                                        VHSAmp += hL0Amp->GetBinContent(BinXBis,BinYBis);
                                                                                                        HSAmp = 0;
                                                                                                        FastORNumberInLine = CircleSideLength+1;
                                                                                                        CheckedFastORNumber = -1;
                                                                                                        HSSurrounded = true;
                                                                                                        VHSDetected = true;
                                                                                                }


                                                                                                //-------------------Classic "circle" search---------------------

                                                                                                else
                                                                                                {
                                                                                                        HSSurroundingClear = false;

                                                                                                        if(MaxAmp < hL0Amp->GetBinContent(BinXBis,BinYBis))
                                                                                                        {
                                                                                                                MaxAmp = hL0Amp->GetBinContent(BinXBis,BinYBis);
                                                                                                        }

                                                                                                        IntAmp += hL0Amp->GetBinContent(BinXBis,BinYBis);
                                                                                                        HSSize++;
                                                                                                }
                                                                                        }

                                                                                        MaskHS[MaskPos] = false;
                                                                                }
                                                                        }

                                                                        CheckedFastORNumber++;
                                                                        FastORNumberInLine++;

                                                                }while(FastORNumberInLine < CircleSideLength);

                                                                CircleSideLength += 2;
                                                                AxisPower++;
                                                                DirectionPower++;

                                                                //We only stop the "circle" search when a full circle is found whithout any HotSpot in it
                                                                if(CheckedFastORNumber == 6+8*lap)
                                                                {
                                                                        CheckedFastORNumber = 0;
                                                                        lap++;
                                                                        if(HSSurroundingClear == true)
                                                                        {
                                                                                HSSurrounded = true;
                                                                        }

                                                                        HSSurroundingClear = true;
                                                                }
                                                        } while(HSSurrounded == false);
                                                        if(!VHSDetected)
                                                        {
                                                                HSAmp += IntAmp;
                                                                MaxAmp = 0;
                                                                IntAmp = 0;
                                                                HSCount++;
                                                        }
                                                }
                                        }

                                        if(!VHSDetected)
                                        {
                                                MaskPos = binx-1+(biny-1)*48;
                                                MaskHS[MaskPos] = false;
                                        }
                                }

                        binx++;
                        }

                biny++;
                }

                hQAHSCount->AddBinContent(i+1,HSCount);
                hQAHSAmp->AddBinContent(i+1,HSAmp/(MeanValue*AntiMaskSize));

                HSAmp = 0.;
                VHSAmp = 0.;


//------------------------------------------------Test Eta distribution for L1G--------------------------------------------------

                TH2F *hClusEtaPhiLowL1G=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowL1G");

                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusEtaL1G->SetBinContent(i+1,binx-14,hClusEtaPhiLowL1G->GetBinContent(binx,biny)/hClusEtaPhiLowL1G->GetEntries()+hQAClusEtaL1G->GetBinContent(i+1,binx-14));
                        }
                }

//------------------------------------------------Test Eta distribution for L1J--------------------------------------------------

                TH2F *hClusEtaPhiLowL1J=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowL1J");//J

                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusEtaL1J->SetBinContent(i+1,binx-14,hClusEtaPhiLowL1J->GetBinContent(binx,biny)/hClusEtaPhiLowL1J->GetEntries()+hQAClusEtaL1J->GetBinContent(i+1,binx-14));
                        }
                }


//------------------------------------------------Test Phi distribution for L1G--------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusPhiL1G->SetBinContent(i+1,biny,hClusEtaPhiLowL1G->GetBinContent(binx,biny)/hClusEtaPhiLowL1G->GetEntries()+hQAClusPhiL1G->GetBinContent(i+1,biny));
                        }
                }


//-----------------------------------------------Test Phi distribution for L1J---------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=1;binx<147;binx++)
                        {
                                hQAClusPhiL1J->SetBinContent(i+1,biny,hClusEtaPhiLowL1J->GetBinContent(binx,biny)/hClusEtaPhiLowL1J->GetEntries()+hQAClusPhiL1J->GetBinContent(i+1,biny));
                        }
                }


//---------------------------------------------Test Eta distribution for L1GOnly------------------------------------------------

                TH2F *hClusEtaPhiLowL1GOnly=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowL1GOnly");
                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusEtaL1GOnly->SetBinContent(i+1,binx-14,hClusEtaPhiLowL1GOnly->GetBinContent(binx,biny)/hClusEtaPhiLowL1GOnly->GetEntries()+hQAClusEtaL1GOnly->GetBinContent(i+1,binx-14));
                        }
                }


//---------------------------------------------Test Eta distribution for L1JOnly------------------------------------------------

                TH2F *hClusEtaPhiLowL1JOnly=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowL1JOnly");
                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusEtaL1JOnly->SetBinContent(i+1,binx-14,hClusEtaPhiLowL1JOnly->GetBinContent(binx,biny)/hClusEtaPhiLowL1JOnly->GetEntries()+hQAClusEtaL1JOnly->GetBinContent(i+1,binx-14));
                        }
                }


//--------------------------------------------Test Phi distribution for L1GOnly-------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusPhiL1GOnly->SetBinContent(i+1,biny,hClusEtaPhiLowL1GOnly->GetBinContent(binx,biny)/hClusEtaPhiLowL1GOnly->GetEntries()+hQAClusPhiL1GOnly->GetBinContent(i+1,biny));
                        }
                }


//--------------------------------------------Test Phi distribution for L1JOnly-------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusPhiL1JOnly->SetBinContent(i+1,biny,hClusEtaPhiLowL1JOnly->GetBinContent(binx,biny)/hClusEtaPhiLowL1JOnly->GetEntries()+hQAClusPhiL1JOnly->GetBinContent(i+1,biny));
                        }
                }


//-----------------------------------------------Test Eta distribution for MB---------------------------------------------------

                TH2F *hClusEtaPhiLowMB=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowMB");
                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusEtaMB->SetBinContent(i+1,binx-14,hClusEtaPhiLowMB->GetBinContent(binx,biny)/hClusEtaPhiLowMB->GetEntries()+hQAClusEtaMB->GetBinContent(i+1,binx-14));
                        }
                }


//----------------------------------------------Test Eta distribution for L0----------------------------------------------------

                TH2F *hClusEtaPhiLowL0=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowL0");
                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusEtaL0->SetBinContent(i+1,binx-14,hClusEtaPhiLowL0->GetBinContent(binx,biny)/hClusEtaPhiLowL0->GetEntries()+hQAClusEtaL0->GetBinContent(i+1,binx-14));
                        }
                }


//---------------------------------------------Test Phi distribution for MB-----------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusPhiMB->SetBinContent(i+1,biny,hClusEtaPhiLowMB->GetBinContent(binx,biny)/hClusEtaPhiLowMB->GetEntries()+hQAClusPhiMB->GetBinContent(i+1,biny));
                        }
                }


//--------------------------------------------Test Phi distribution for L0------------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusPhiL0->SetBinContent(i+1,biny,hClusEtaPhiLowL0->GetBinContent(binx,biny)/hClusEtaPhiLowL0->GetEntries()+hQAClusPhiL0->GetBinContent(i+1,biny));
                        }
                }


//-----------------------------------------Test Eta distribution for L1G Max----------------------------------------------------

                TH2F *hClusEtaPhiLowCluMaxL1G=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowCluMaxL1G");
                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusMaxEtaL1G->SetBinContent(i+1,binx-14,hClusEtaPhiLowCluMaxL1G->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxL1G->GetEntries()+hQAClusMaxEtaL1G->GetBinContent(i+1,binx-14));
                        }
                }


//---------------------------------------Test Eta distribution for L1J Max------------------------------------------------------

                TH2F *hClusEtaPhiLowCluMaxL1J=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowCluMaxL1J");
                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusMaxEtaL1J->SetBinContent(i+1,binx-14,hClusEtaPhiLowCluMaxL1J->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxL1J->GetEntries()+hQAClusMaxEtaL1J->GetBinContent(i+1,binx-14));
                        }
                }


//-------------------------------------------Test Phi distribution for L1G Max---------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusMaxPhiL1G->SetBinContent(i+1,biny,hClusEtaPhiLowCluMaxL1G->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxL1G->GetEntries()+hQAClusMaxPhiL1G->GetBinContent(i+1,biny));
                        }
                }


//--------------------------------------------Test Phi distribution for L1J Max--------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusMaxPhiL1J->SetBinContent(i+1,biny,hClusEtaPhiLowCluMaxL1J->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxL1J->GetEntries()+hQAClusMaxPhiL1J->GetBinContent(i+1,biny));
                        }
                }


//------------------------------------------Test Eta distribution for L1GOnly Max-----------------------------------------------

                TH2F *hClusEtaPhiLowCluMaxL1GOnly=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowCluMaxL1GOnly");
                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusMaxEtaL1GOnly->SetBinContent(i+1,binx-14,hClusEtaPhiLowCluMaxL1GOnly->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxL1GOnly->GetEntries()+hQAClusMaxEtaL1GOnly->GetBinContent(i+1,binx-14));
                        }
                }


//-----------------------------------------Test Eta distribution for L1JOnly Max------------------------------------------------

                TH2F *hClusEtaPhiLowCluMaxL1JOnly=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowCluMaxL1JOnly");
                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusMaxEtaL1JOnly->SetBinContent(i+1,binx-14,hClusEtaPhiLowCluMaxL1JOnly->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxL1JOnly->GetEntries()+hQAClusMaxEtaL1JOnly->GetBinContent(i+1,binx-14));
                        }
                }


//-----------------------------------------Test Phi distribution for L1GOnly Max-------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusMaxPhiL1GOnly->SetBinContent(i+1,biny,hClusEtaPhiLowCluMaxL1GOnly->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxL1GOnly->GetEntries()+hQAClusMaxPhiL1GOnly->GetBinContent(i+1,biny));
                        }
                }


//-----------------------------------------Test Phi distribution for L1JOnly Max------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusMaxPhiL1JOnly->SetBinContent(i+1,biny,hClusEtaPhiLowCluMaxL1JOnly->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxL1JOnly->GetEntries()+hQAClusMaxPhiL1JOnly->GetBinContent(i+1,biny));
                        }
                }


//--------------------------------------------Test Eta distribution for MB Max--------------------------------------------------

                TH2F *hClusEtaPhiLowCluMaxMB=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowCluMaxMB");
                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusMaxEtaMB->SetBinContent(i+1,binx-14,hClusEtaPhiLowCluMaxMB->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxMB->GetEntries()+hQAClusMaxEtaMB->GetBinContent(i+1,binx-14));
                        }
                }


//--------------------------------------------Test Eta distribution for L0 Max--------------------------------------------------

                TH2F *hClusEtaPhiLowCluMaxL0=(TH2F *) TListList[i]->FindObject("hClusEtaPhiLowCluMaxL0");
                for(int binx=15;binx<147;binx++)
                {
                        for(int biny=1;biny<101;biny++)
                        {
                                hQAClusMaxEtaL0->SetBinContent(i+1,binx-14,hClusEtaPhiLowCluMaxL0->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxL0->GetEntries()+hQAClusMaxEtaL0->GetBinContent(i+1,binx-14));
                        }
                }


//-------------------------------------------Test Phi distribution for MB Max---------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusMaxPhiMB->SetBinContent(i+1,biny,hClusEtaPhiLowCluMaxMB->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxMB->GetEntries()+hQAClusMaxPhiMB->GetBinContent(i+1,biny));
                        }
                }


//----------------------------------------------Test Phi distribution for L0 Max-------------------------------------------------

                for(int biny=1;biny<101;biny++)
                {
                        for(int binx=15;binx<147;binx++)
                        {
                                hQAClusMaxPhiL0->SetBinContent(i+1,biny,hClusEtaPhiLowCluMaxL0->GetBinContent(binx,biny)/hClusEtaPhiLowCluMaxL0->GetEntries()+hQAClusMaxPhiL0->GetBinContent(i+1,biny));
                        }
                }

                TFileList[i]->Close("R");
        }


//----------------------------------------------------------Drawing Histos-----------------------------------------------------

//--------------------------------------------c1-------------------------------------------

        //------------------1------------------
        c1->cd(1);
        hQADeadZone   ->SetYTitle("Dead zone rate");
        hQADeadZone   ->SetXTitle("Run #");
        hQADeadZone->GetYaxis()->SetTitleSize(hQADeadZone->GetYaxis()->GetTitleSize()*1.4);
        hQADeadZone->GetYaxis()->SetRangeUser(hQADeadZone->GetBinContent(hQADeadZone->GetMinimumBin())*.85,hQADeadZone->GetBinContent(hQADeadZone->GetMaximumBin())*1.1);

        hQADeadZone->Draw("");

        //------------------2------------------
        c1->cd(2);
        hQAMaxTriggerGapL1G   ->SetYTitle("Max Trigger Gap value");
        hQAMaxTriggerGapL1G   ->SetXTitle("Run #");
        hQAMaxTriggerGapL1G->GetYaxis()->SetTitleSize(hQAMaxTriggerGapL1G->GetYaxis()->GetTitleSize()*1.4);
        hQAMaxTriggerGapL1G->GetYaxis()->SetRangeUser(-0.001,hQAMaxTriggerGapL1G->GetBinContent(hQAMaxTriggerGapL1G->GetMaximumBin())*1.1);

        hQAMaxTriggerGapL1G->Draw("");
        TLine *l1 = new TLine(0,1/2773,VectorSize,1/2773);
        l1->SetLineColor(8);
        l1->Draw();

        TLegend *Legend1 = new TLegend(0.02,0.92,0.18,0.98);
        Legend1->AddEntry(l1,"Ideal case","L");
        Legend1->Draw();

        //------------------3------------------
        c1->cd(3);
        hQASigmaL1G   ->SetYTitle("Normalized Standard Deviation");
        hQASigmaL1G   ->SetXTitle("Run #");
        hQASigmaL1G->GetYaxis()->SetTitleSize(hQASigmaL1G->GetYaxis()->GetTitleSize()*1.4);
        hQASigmaL1G->GetYaxis()->SetRangeUser(0,hQASigmaL1G->GetBinContent(hQASigmaL1G->GetMaximumBin())*1.1);

        hQASigmaL1G->Draw("");

        //------------------4------------------
        c1->cd(4);
        hQAMaxTriggerGapL1J   ->SetYTitle("Max Trigger Gap value");
        hQAMaxTriggerGapL1J   ->SetXTitle("Run #");
        hQAMaxTriggerGapL1J->GetYaxis()->SetTitleSize(hQAMaxTriggerGapL1J->GetYaxis()->GetTitleSize()*1.4);
        hQAMaxTriggerGapL1J->GetYaxis()->SetRangeUser(-0.001,hQAMaxTriggerGapL1J->GetBinContent(hQAMaxTriggerGapL1J->GetMaximumBin())*1.1);

        hQAMaxTriggerGapL1J->Draw("");

        TLine *l2 = new TLine(0,1/117,VectorSize,1/117);
        l2->SetLineColor(8);
        l2->Draw();

        TLegend *Legend5 = new TLegend(0.02,0.92,0.18,0.98);
        Legend5->AddEntry(l2,"Ideal case","L");
        Legend5->Draw();

        //------------------5------------------
        c1->cd(5);
        hQASigmaL1J   ->SetYTitle("Normalized Standard Deviation");
        hQASigmaL1J   ->SetXTitle("Run #");
        hQASigmaL1J->GetYaxis()->SetTitleSize(hQASigmaL1J->GetYaxis()->GetTitleSize()*1.4);
        hQASigmaL1J->GetYaxis()->SetRangeUser(0,hQASigmaL1J->GetBinContent(hQASigmaL1J->GetMaximumBin())*1.1);

        hQASigmaL1J->Draw("");

        //------------------6------------------
        c1->cd(6);
        hQATRU   ->SetYTitle("TRU number");
        hQATRU   ->SetXTitle("Run #");
        hQATRU->GetYaxis()->SetTitleSize(hQATRU->GetYaxis()->GetTitleSize()*1.4);
        hQATRU->GetZaxis()->SetRangeUser(0,5);


        hQATRU->SetContour(13);
        hQATRU->Draw("col");

        for(int i=3;i<=30;i+=3)
        {
                TLine *l2 = new TLine(0,i+0.5,VectorSize,i+0.5);
                l2->Draw();
        }

        TBox *box1 = new TBox();
        TBox *box2 = new TBox();
        box1->SetFillColor(2);
        box2->SetFillColor(kBlue-7);

        TLegend *Legend2 = new TLegend(0.01,0.91,0.28,0.99);
        Legend2->AddEntry(box1,"Link TRU-STU problem","F");
        Legend2->AddEntry(box2,"Average time bin problem","F");
        Legend2->Draw();

        //------------------7------------------
        c1->cd(7);
        hQAGridAmp   ->SetYTitle("Normalized Grid Amp");
        hQAGridAmp   ->SetXTitle("Run #");
        hQAGridAmp->GetYaxis()->SetTitleSize(hQAGridAmp->GetYaxis()->GetTitleSize()*1.4);
        hQAGridAmp->GetYaxis()->SetRangeUser(0,1);

        hQAGridAmp->Draw("");

        hQAGridAmpL1->SetLineColor(2);
        hQAGridAmpL1->Draw("Same");

        TLine *l20 = new TLine(0,0.125,VectorSize,0.125);
        l20->SetLineColor(8);
        l20->Draw();

        TLegend *Legend50 = new TLegend(0.02,0.92,0.18,1);
        Legend50->AddEntry(l20,"Ideal case","L");
        Legend50->AddEntry(hQAGridAmp,"L0","L");
        Legend50->AddEntry(hQAGridAmpL1,"L1","L");
        Legend50->Draw();

        //------------------8------------------
        c1->cd(8);
        hQAClusEtaL1G   ->SetYTitle("Eta");
        hQAClusEtaL1G   ->SetXTitle("Run #");
        hQAClusEtaL1G ->GetYaxis()->SetTitleSize(hQAClusEtaL1G ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusEtaL1G ->GetZaxis()->SetRangeUser(hQAClusEtaL1G->GetMinimum(),ZoomAuto2D(hQAClusEtaL1G,2*VectorSize));

        hQAClusEtaL1G->Draw("colz");

        //------------------9------------------
        c1->cd(9);
        hQAClusEtaL1J   ->SetYTitle("Eta");
        hQAClusEtaL1J   ->SetXTitle("Run #");
        hQAClusEtaL1J ->GetYaxis()->SetTitleSize(hQAClusEtaL1J ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusEtaL1J ->GetZaxis()->SetRangeUser(hQAClusEtaL1J->GetMinimum(),ZoomAuto2D(hQAClusEtaL1J,VectorSize));

        hQAClusEtaL1J->Draw("colz");


//--------------------------------------------c2-------------------------------------------

        //------------------1------------------
        c2->cd(1);
        hQAHSCount   ->SetYTitle("Number of HotSpots");
        hQAHSCount   ->SetXTitle("Run #");
        hQAHSCount ->GetYaxis()->SetTitleSize(hQAHSCount ->GetYaxis()->GetTitleSize()*1.4);
        hQAHSCount->GetYaxis()->SetRangeUser(hQAHSCount->GetBinContent(hQAHSCount->GetMinimumBin())*.85,hQAHSCount->GetBinContent(hQAHSCount->GetMaximumBin())*1.1);

        hQAHSCount->Draw("");

        //------------------2------------------
        c2->cd(2);
        hQAHSAmp   ->SetYTitle("Normalized Total Amplitude of HotSpots");
        hQAHSAmp   ->SetXTitle("Run #");
        hQAHSAmp ->GetYaxis()->SetTitleSize(hQAHSAmp ->GetYaxis()->GetTitleSize()*1.4);
        hQAHSAmp->GetYaxis()->SetRangeUser(hQAHSAmp->GetBinContent(hQAHSAmp->GetMinimumBin())*.85,hQAHSAmp->GetBinContent(hQAHSAmp->GetMaximumBin())*1.1);

        hQAHSAmp->Draw("");
        /*
        //------------------3------------------
        c2->cd(3);
        hQAVHSCount   ->SetYTitle("Number of VeryHotSpots");
        hQAVHSCount   ->SetXTitle("Run #");
        hQAVHSCount->GetYaxis()->SetRangeUser(hQAVHSCount->GetBinContent(hQAVHSCount->GetMinimumBin())*.85,hQAVHSCount->GetBinContent(hQAVHSCount->GetMaximumBin())*1.1);

        hQAVHSCount->Draw("");

        //------------------4------------------
        c2->cd(4);
        hQAVHSAmp   ->SetYTitle("Normalized Total Amplitude of VeryHotSpots");
        hQAVHSAmp   ->SetXTitle("Run #");
        hQAVHSAmp->GetYaxis()->SetRangeUser(hQAVHSAmp->GetBinContent(hQAVHSAmp->GetMinimumBin())*.85,hQAVHSAmp->GetBinContent(hQAVHSAmp->GetMaximumBin())*1.1);

        hQAVHSAmp->Draw("");

        //------------------5------------------
        c2->cd(5);
        hQAHSCountL1G   ->SetYTitle("Number of HotSpots");
        hQAHSCountL1G   ->SetXTitle("Run #");
        hQAHSCountL1G->GetYaxis()->SetRangeUser(hQAHSCountL1G->GetBinContent(hQAHSCountL1G->GetMinimumBin())*.85,hQAHSCountL1G->GetBinContent(hQAHSCountL1G->GetMaximumBin())*1.1);

        hQAHSCountL1G->Draw("");

        TLine *l3 = new TLine(0,0,VectorSize,0);
        l3->Draw();

        TLegend *Legend3 = new TLegend(0.01,0.91,0.24,0.99);
        Legend3->AddEntry((TObject*)0,"<0 indicates a run","");
        Legend3->AddEntry((TObject*)0,"without enough stats","");
        Legend3->SetMargin(Legend3->GetMargin()/4);
        Legend3->Draw();

        //------------------6------------------
        c2->cd(6);
        hQAHSAmpL1G   ->SetYTitle("Normalized Total Amplitude of HotSpots");
        hQAHSAmpL1G   ->SetXTitle("Run #");
        hQAHSAmpL1G->GetYaxis()->SetRangeUser(hQAHSAmpL1G->GetBinContent(hQAHSAmpL1G->GetMinimumBin())*.85,hQAHSAmpL1G->GetBinContent(hQAHSAmpL1G->GetMaximumBin())*1.1);

        hQAHSAmpL1G->Draw("");

        TLine *l4 = new TLine(0,0,VectorSize,0);
        l4->Draw();

        TLegend *Legend4 = new TLegend(0.01,0.91,0.24,0.99);
        Legend4->AddEntry((TObject*)0,"<0 indicates a run","");
        Legend4->AddEntry((TObject*)0,"without enough stats","");
        Legend4->SetMargin(Legend4->GetMargin()/4);
        Legend4->Draw();
        */


//--------------------------------------------c3-------------------------------------------

        //------------------1------------------
        c3->cd(1);
        hQAClusEtaMB   ->SetYTitle("Eta");
        hQAClusEtaMB   ->SetXTitle("Run #");
        hQAClusEtaMB ->GetYaxis()->SetTitleSize(hQAClusEtaMB ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusEtaMB ->GetZaxis()->SetRangeUser(hQAClusEtaMB->GetMinimum(),ZoomAuto2D(hQAClusEtaMB,2*VectorSize));

        hQAClusEtaMB->Draw("colz");

        //------------------2------------------
        c3->cd(2);
        hQAClusPhiMB   ->SetYTitle("Phi");
        hQAClusPhiMB   ->SetXTitle("Run #");
        hQAClusPhiMB ->GetYaxis()->SetTitleSize(hQAClusPhiMB ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusPhiMB ->GetZaxis()->SetRangeUser(hQAClusPhiMB->GetMinimum(),ZoomAuto2D(hQAClusPhiMB,4*VectorSize));

        hQAClusPhiMB->Draw("colz");

        //------------------3------------------
        c3->cd(3);
        hQAClusEtaL0   ->SetYTitle("Eta");
        hQAClusEtaL0   ->SetXTitle("Run #");
        hQAClusEtaL0 ->GetYaxis()->SetTitleSize(hQAClusEtaL0 ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusEtaL0 ->GetZaxis()->SetRangeUser(hQAClusEtaL0->GetMinimum(),ZoomAuto2D(hQAClusEtaL0,3*VectorSize));

        hQAClusEtaL0->Draw("colz");

        //------------------4------------------
        c3->cd(4);
        hQAClusPhiL0   ->SetYTitle("Phi");
        hQAClusPhiL0   ->SetXTitle("Run #");
        hQAClusPhiL0 ->GetYaxis()->SetTitleSize(hQAClusPhiL0 ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusPhiL0 ->GetZaxis()->SetRangeUser(hQAClusPhiL0->GetMinimum(),ZoomAuto2D(hQAClusPhiL0,VectorSize));

        hQAClusPhiL0->Draw("colz");

        //------------------5------------------
        c3->cd(5);
        hQAClusEtaL1G   ->SetYTitle("Eta");
        hQAClusEtaL1G   ->SetXTitle("Run #");
        hQAClusEtaL1G ->GetYaxis()->SetTitleSize(hQAClusEtaL1G ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusEtaL1G ->GetZaxis()->SetRangeUser(hQAClusEtaL1G->GetMinimum(),ZoomAuto2D(hQAClusEtaL1G,2*VectorSize));

        hQAClusEtaL1G->Draw("colz");

        //------------------6------------------
        c3->cd(6);
        hQAClusPhiL1G   ->SetYTitle("Phi");
        hQAClusPhiL1G   ->SetXTitle("Run #");
        hQAClusPhiL1G ->GetYaxis()->SetTitleSize(hQAClusPhiL1G ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusPhiL1G ->GetZaxis()->SetRangeUser(hQAClusPhiL1G->GetMinimum(),ZoomAuto2D(hQAClusPhiL1G,VectorSize));

        hQAClusPhiL1G->Draw("colz");

        //------------------7------------------
        c3->cd(7);
        hQAClusEtaL1J   ->SetYTitle("Eta");
        hQAClusEtaL1J   ->SetXTitle("Run #");
        hQAClusEtaL1J ->GetYaxis()->SetTitleSize(hQAClusEtaL1J ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusEtaL1J ->GetZaxis()->SetRangeUser(hQAClusEtaL1J->GetMinimum(),ZoomAuto2D(hQAClusEtaL1J,VectorSize));

        hQAClusEtaL1J->Draw("colz");

        //------------------8------------------
        c3->cd(8);
        hQAClusPhiL1J   ->SetYTitle("Phi");
        hQAClusPhiL1J   ->SetXTitle("Run #");
        hQAClusPhiL1J ->GetYaxis()->SetTitleSize(hQAClusPhiL1J ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusPhiL1J ->GetZaxis()->SetRangeUser(hQAClusPhiL1J->GetMinimum(),ZoomAuto2D(hQAClusPhiL1J,VectorSize));

        hQAClusPhiL1J->Draw("colz");

        //------------------9------------------
        c3->cd(9);
        hQAClusEtaL1GOnly   ->SetYTitle("Eta");
        hQAClusEtaL1GOnly   ->SetXTitle("Run #");
        hQAClusEtaL1GOnly ->GetYaxis()->SetTitleSize(hQAClusEtaL1GOnly ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusEtaL1GOnly ->GetZaxis()->SetRangeUser(hQAClusEtaL1GOnly->GetMinimum(),ZoomAuto2D(hQAClusEtaL1GOnly,2*VectorSize));

        hQAClusEtaL1GOnly->Draw("colz");

        //------------------10-----------------
        c3->cd(10);
        hQAClusPhiL1GOnly   ->SetYTitle("Phi");
        hQAClusPhiL1GOnly   ->SetXTitle("Run #");
        hQAClusPhiL1GOnly ->GetYaxis()->SetTitleSize(hQAClusPhiL1GOnly ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusPhiL1GOnly ->GetZaxis()->SetRangeUser(hQAClusPhiL1GOnly->GetMinimum(),ZoomAuto2D(hQAClusPhiL1GOnly,VectorSize));

        hQAClusPhiL1GOnly->Draw("colz");

        //------------------11-----------------
        c3->cd(11);
        hQAClusEtaL1JOnly   ->SetYTitle("Eta");
        hQAClusEtaL1JOnly   ->SetXTitle("Run #");
        hQAClusEtaL1JOnly ->GetYaxis()->SetTitleSize(hQAClusEtaL1JOnly ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusEtaL1JOnly ->GetZaxis()->SetRangeUser(hQAClusEtaL1JOnly->GetMinimum(),ZoomAuto2D(hQAClusEtaL1JOnly,VectorSize));

        hQAClusEtaL1JOnly->Draw("colz");

        //------------------12-----------------
        c3->cd(12);
        hQAClusPhiL1JOnly   ->SetYTitle("Phi");
        hQAClusPhiL1JOnly   ->SetXTitle("Run #");
        hQAClusPhiL1JOnly ->GetYaxis()->SetTitleSize(hQAClusPhiL1JOnly ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusPhiL1JOnly ->GetZaxis()->SetRangeUser(hQAClusPhiL1JOnly->GetMinimum(),ZoomAuto2D(hQAClusPhiL1JOnly,VectorSize));

        hQAClusPhiL1JOnly->Draw("colz");


//--------------------------------------------c4-------------------------------------------

        //------------------1------------------
        c4->cd(1);
        hQAClusMaxEtaMB   ->SetYTitle("Eta");
        hQAClusMaxEtaMB   ->SetXTitle("Run #");
        hQAClusMaxEtaMB ->GetYaxis()->SetTitleSize(hQAClusMaxEtaMB ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxEtaMB ->GetZaxis()->SetRangeUser(hQAClusMaxEtaMB->GetMinimum(),ZoomAuto2D(hQAClusMaxEtaMB,3*VectorSize));

        hQAClusMaxEtaMB->Draw("colz");

        //------------------2------------------
        c4->cd(2);
        hQAClusMaxPhiMB   ->SetYTitle("Phi");
        hQAClusMaxPhiMB   ->SetXTitle("Run #");
        hQAClusMaxPhiMB ->GetYaxis()->SetTitleSize(hQAClusMaxPhiMB ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxPhiMB ->GetZaxis()->SetRangeUser(hQAClusMaxPhiMB->GetMinimum(),ZoomAuto2D(hQAClusMaxPhiMB,3*VectorSize));

        hQAClusMaxPhiMB->Draw("colz");

        //------------------3------------------
        c4->cd(3);
        hQAClusMaxEtaL0   ->SetYTitle("Eta");
        hQAClusMaxEtaL0   ->SetXTitle("Run #");
        hQAClusMaxEtaL0 ->GetYaxis()->SetTitleSize(hQAClusMaxEtaL0 ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxEtaL0 ->GetZaxis()->SetRangeUser(hQAClusMaxEtaL0->GetMinimum(),ZoomAuto2D(hQAClusMaxEtaL0,VectorSize));

        hQAClusMaxEtaL0->Draw("colz");

        //------------------4------------------
        c4->cd(4);
        hQAClusMaxPhiL0   ->SetYTitle("Phi");
        hQAClusMaxPhiL0   ->SetXTitle("Run #");
        hQAClusMaxPhiL0 ->GetYaxis()->SetTitleSize(hQAClusMaxPhiL0 ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxPhiL0 ->GetZaxis()->SetRangeUser(hQAClusMaxPhiL0->GetMinimum(),ZoomAuto2D(hQAClusMaxPhiL0,VectorSize));

        hQAClusMaxPhiL0->Draw("colz");

        //------------------5------------------
        c4->cd(5);
        hQAClusMaxEtaL1G   ->SetYTitle("Eta");
        hQAClusMaxEtaL1G   ->SetXTitle("Run #");
        hQAClusMaxEtaL1G ->GetYaxis()->SetTitleSize(hQAClusMaxEtaL1G ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxEtaL1G ->GetZaxis()->SetRangeUser(hQAClusMaxEtaL1G->GetMinimum(),ZoomAuto2D(hQAClusMaxEtaL1G,4*VectorSize));

        hQAClusMaxEtaL1G->Draw("colz");

        //------------------6------------------
        c4->cd(6);
        hQAClusMaxPhiL1G   ->SetYTitle("Phi");
        hQAClusMaxPhiL1G   ->SetXTitle("Run #");
        hQAClusMaxPhiL1G ->GetYaxis()->SetTitleSize(hQAClusMaxPhiL1G ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxPhiL1G ->GetZaxis()->SetRangeUser(hQAClusMaxPhiL1G->GetMinimum(),ZoomAuto2D(hQAClusMaxPhiL1G,4*VectorSize));

        hQAClusMaxPhiL1G->Draw("colz");

        //------------------7------------------
        c4->cd(7);
        hQAClusMaxEtaL1J   ->SetYTitle("Eta");
        hQAClusMaxEtaL1J   ->SetXTitle("Run #");
        hQAClusMaxEtaL1J ->GetYaxis()->SetTitleSize(hQAClusMaxEtaL1J ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxEtaL1J ->GetZaxis()->SetRangeUser(hQAClusMaxEtaL1J->GetMinimum(),ZoomAuto2D(hQAClusMaxEtaL1J,VectorSize));

        hQAClusEtaL1J->Draw("colz");

        //------------------8------------------
        c4->cd(8);
        hQAClusMaxPhiL1J   ->SetYTitle("Phi");
        hQAClusMaxPhiL1J   ->SetXTitle("Run #");
        hQAClusMaxPhiL1J ->GetYaxis()->SetTitleSize(hQAClusMaxPhiL1J ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxPhiL1J ->GetZaxis()->SetRangeUser(hQAClusMaxPhiL1J->GetMinimum(),ZoomAuto2D(hQAClusMaxPhiL1J,VectorSize));

        hQAClusMaxPhiL1J->Draw("colz");

        //------------------9------------------
        c4->cd(9);
        hQAClusMaxEtaL1GOnly   ->SetYTitle("Eta");
        hQAClusMaxEtaL1GOnly   ->SetXTitle("Run #");
        hQAClusMaxEtaL1GOnly ->GetYaxis()->SetTitleSize(hQAClusMaxEtaL1GOnly ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxEtaL1GOnly ->GetZaxis()->SetRangeUser(hQAClusMaxEtaL1GOnly->GetMinimum(),ZoomAuto2D(hQAClusMaxEtaL1GOnly,4*VectorSize));

        hQAClusMaxEtaL1GOnly->Draw("colz");

        //------------------10-----------------
        c4->cd(10);
        hQAClusMaxPhiL1GOnly   ->SetYTitle("Phi");
        hQAClusMaxPhiL1GOnly   ->SetXTitle("Run #");
        hQAClusMaxPhiL1GOnly ->GetYaxis()->SetTitleSize(hQAClusMaxPhiL1GOnly ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxPhiL1GOnly->GetZaxis()->SetRangeUser(hQAClusMaxPhiL1GOnly->GetMinimum(),ZoomAuto2D(hQAClusMaxPhiL1GOnly,4*VectorSize));

        hQAClusMaxPhiL1GOnly->Draw("colz");

        //------------------11-----------------
        c4->cd(11);
        hQAClusMaxEtaL1JOnly   ->SetYTitle("Eta");
        hQAClusMaxEtaL1JOnly   ->SetXTitle("Run #");
        hQAClusMaxEtaL1JOnly ->GetYaxis()->SetTitleSize(hQAClusMaxEtaL1JOnly ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxEtaL1JOnly ->GetZaxis()->SetRangeUser(hQAClusMaxEtaL1JOnly->GetMinimum(),ZoomAuto2D(hQAClusMaxEtaL1JOnly,VectorSize));

        hQAClusMaxEtaL1JOnly->Draw("colz");

        //------------------12-----------------
        c4->cd(12);
        hQAClusMaxPhiL1JOnly   ->SetYTitle("Phi");
        hQAClusMaxPhiL1JOnly   ->SetXTitle("Run #");
        hQAClusMaxPhiL1JOnly ->GetYaxis()->SetTitleSize(hQAClusMaxPhiL1JOnly ->GetYaxis()->GetTitleSize()*1.4);
        hQAClusMaxPhiL1JOnly ->GetZaxis()->SetRangeUser(hQAClusMaxPhiL1JOnly->GetMinimum(),ZoomAuto2D(hQAClusMaxPhiL1JOnly,VectorSize));

        hQAClusMaxPhiL1JOnly->Draw("colz");
}