Example #1
0
double* fitHist(TCanvas *iC, bool iDoMu,int iPlot, std::string iName,TH1D *iData,TH1D *iW,TH1D *iEWK,TH1D *iAntiData,TH1D *iAntiW,TH1D *iAntiEWK,const Double_t METMAX,const Int_t NBINS,const Double_t lumi,const Int_t Ecm,int iAltQCD) {
    //
    // Declare fit parameters for signal and background yields
    // Note: W signal and EWK+top PDFs are constrained to the ratio described in MC
    //
    RooRealVar nSig(("nSig"+iName).c_str(),("nSig"+iName).c_str(),0.7*(iData->Integral()),0,iData->Integral());
    RooRealVar nQCD(("nQCD"+iName).c_str(),("nQCD"+iName).c_str(),0.3*(iData->Integral()),0,iData->Integral());
    RooRealVar cewk(("cewk"+iName).c_str(),("cewk"+iName).c_str(),0.1,0,5) ;
    cewk.setVal(iEWK->Integral()/iW->Integral());
    cewk.setConstant(kTRUE);
    RooFormulaVar nEWK(("nEWK"+iName).c_str(),("nEWK"+iName).c_str(),("cewk"+iName+"*nSig"+iName).c_str(),RooArgList(nSig,cewk));

    RooRealVar nAntiSig(("nAntiSig"+iName).c_str(),("nAntiSig"+iName).c_str(),0.05*(iAntiData->Integral()),0,iAntiData->Integral());
    RooRealVar nAntiQCD(("nAntiQCD"+iName).c_str(),("nAntiQCD"+iName).c_str(),0.9 *(iAntiData->Integral()),0,iAntiData->Integral());
    RooRealVar dewk    (("dewk"    +iName).c_str(),("dewk"    +iName).c_str(),0.1,0,5) ;
    dewk.setVal(iAntiEWK->Integral()/iAntiW->Integral());
    dewk.setConstant(kTRUE);
    RooFormulaVar nAntiEWK(("nAntiEWK"+iName).c_str(),("nAntiEWK"+iName).c_str(),("dewk"+iName+"*nAntiSig"+iName).c_str(),RooArgList(nAntiSig,dewk));

    //
    // Construct PDFs for fitting
    //
    RooRealVar pfmet(("pfmet"+iName).c_str(),("pfmet"+iName).c_str(),0,METMAX);
    pfmet.setBins(NBINS);

    // Signal PDFs
    RooDataHist wMet  (("wMET" +iName).c_str(), ("wMET" +iName).c_str(),     RooArgSet(pfmet),iW);
    RooHistPdf  pdfW(( "w"+iName).c_str(), ( "w"+iName).c_str(), pfmet, wMet, 1);
    RooDataHist awMet (("awMET"+iName).c_str(), ("awMET"+iName).c_str(),     RooArgSet(pfmet),iAntiW);
    RooHistPdf apdfW(("aw"+iName).c_str(), ("aw"+iName).c_str(), pfmet,awMet, 1);

    // EWK+top PDFs
    RooDataHist ewkMet (("ewkMET" +iName).c_str(),( "ewkMET"+iName).c_str(), RooArgSet(pfmet),iEWK);
    RooHistPdf  pdfEWK (( "ewk"+iName).c_str(),( "ewk"+iName).c_str(), pfmet,ewkMet, 1);
    RooDataHist aewkMet(("aewkMET"+iName).c_str(),("aewkMET"+iName).c_str(), RooArgSet(pfmet),iAntiEWK);
    RooHistPdf apdfEWK (("aewk"+iName).c_str(),("aewk"+iName).c_str(), pfmet,aewkMet, 1);

    // QCD Pdfs
    CPepeModel0 qcd0 (("qcd0" +iName).c_str(),pfmet);
    CPepeModel1 qcd1 (("qcd1" +iName).c_str(),pfmet);
    CPepeModel2 qcd2 (("qcd2" +iName).c_str(),pfmet);
    CPepeModel0 aqcd0(("aqcd0"+iName).c_str(),pfmet);
    CPepeModel1 aqcd1(("aqcd1"+iName).c_str(),pfmet,qcd1.sigma);
    CPepeModel2 aqcd2(("aqcd2"+iName).c_str(),pfmet);
    RooGenericPdf *lQCD  =  qcd0.model;
    RooGenericPdf *lAQCD = aqcd0.model;
    if(iDoMu) lQCD  = qcd1.model;
    if(iDoMu) lAQCD = aqcd1.model;
    if(iAltQCD == 0) lQCD = qcd0.model;
    if(iAltQCD == 1) lQCD = qcd1.model;
    if(iAltQCD == 2) lQCD = qcd2.model;
    if(iAltQCD == 0) lAQCD = aqcd0.model;
    if(iAltQCD == 1) lAQCD = aqcd1.model;
    if(iAltQCD == 2) lAQCD = aqcd2.model;

    // Signal + Background PDFs
    RooAddPdf pdfMet (("pdfMet"+iName).c_str(), ("pdfMet" +iName).c_str(), RooArgList(pdfW ,pdfEWK ,*lQCD), RooArgList(nSig,nEWK,nQCD));
    RooAddPdf apdfMet(("apdfMet"+iName).c_str(),("apdfMet"+iName).c_str(), RooArgList(apdfW,apdfEWK,*lAQCD), RooArgList(nAntiSig,nAntiEWK,nAntiQCD));

    // PDF for simultaneous fit
    RooCategory rooCat("rooCat","rooCat");
    rooCat.defineType("Select");
    rooCat.defineType("Anti");

    RooSimultaneous pdfTotal("pdfTotal","pdfTotal",rooCat);
    pdfTotal.addPdf(pdfMet, "Select");
    if(iDoMu) pdfTotal.addPdf(apdfMet,"Anti");

    // Perform fits
    RooDataHist dataMet  (("dataMet"+iName).c_str(),("dataMet"+iName).c_str(), RooArgSet(pfmet),iData);
    RooDataHist antiMet  (("antiMet"+iName).c_str(),("antiMet"+iName).c_str(), RooArgSet(pfmet),iAntiData);
    RooDataHist dataTotal(("data"   +iName).c_str(),("data"   +iName).c_str(), RooArgList(pfmet), Index(rooCat),
                          Import("Select", dataMet),
                          Import("Anti",   antiMet));

    RooFitResult *fitRes = 0;
    bool runMinos = kTRUE;
    if(iPlot == 0 || iPlot == 3) runMinos = kFALSE; //Remove Minos when running toys (too damn slow)
    if(!iDoMu) fitRes = pdfMet  .fitTo(dataMet  ,Extended(),Minos(runMinos),Save(kTRUE));
    if( iDoMu) fitRes = pdfTotal.fitTo(dataTotal,Extended(),Minos(runMinos),Save(kTRUE));

    double *lResults = new double[16];
    lResults[0]  = nSig.getVal();
    lResults[1]  = nEWK.getVal();
    lResults[2]  = nQCD.getVal();
    lResults[3]  = nAntiSig.getVal();
    lResults[4]  = nAntiEWK.getVal();
    lResults[5]  = nAntiQCD.getVal();
    if(!iDoMu) lResults[6]  = double(qcd0.sigma->getVal());
    if( iDoMu) lResults[6]  = double(qcd1.sigma->getVal());

    lResults[7]  = 0.;
    if(!iDoMu) lResults[7]  = qcd1.a1->getVal();
    lResults[8]   = nSig    .getPropagatedError(*fitRes);
    lResults[9]   = nEWK    .getPropagatedError(*fitRes);
    lResults[10]  = nQCD    .getPropagatedError(*fitRes);
    lResults[11]  = nAntiSig.getPropagatedError(*fitRes);
    lResults[12]  = nAntiEWK.getPropagatedError(*fitRes);
    lResults[13]  = nAntiQCD.getPropagatedError(*fitRes);
    if( iDoMu) lResults[14]  = qcd0.sigma->getError();
    if(!iDoMu) lResults[14]  = qcd1.sigma->getError();
    if( iDoMu) lResults[15]  = 0;
    if(!iDoMu) lResults[15]  = qcd1.a1   ->getError();
    if(iPlot == 0 ) return lResults;
    //
    // Use histogram version of fitted PDFs to make ratio plots
    // (Will also use PDF histograms later for Chi^2 and KS tests)
    //
    TH1D *hPdfMet = (TH1D*)(pdfMet.createHistogram(("hPdfMet"+iName).c_str(), pfmet));
    hPdfMet->Scale((nSig.getVal()+nEWK.getVal()+nQCD.getVal())/hPdfMet->Integral());
    TH1D *hMetDiff = makeDiffHist(iData,hPdfMet,"hMetDiff"+iName);
    hMetDiff->SetMarkerStyle(kFullCircle);
    hMetDiff->SetMarkerSize(0.9);

    TH1D *hPdfAntiMet = (TH1D*)(apdfMet.createHistogram(("hPdfAntiMet"+iName).c_str(), pfmet));
    hPdfAntiMet->Scale((nAntiSig.getVal()+nAntiEWK.getVal()+nAntiQCD.getVal())/hPdfAntiMet->Integral());
    TH1D *hAntiMetDiff = makeDiffHist(iAntiData,hPdfAntiMet,"hAntiMetDiff"+iName);
    hAntiMetDiff->SetMarkerStyle(kFullCircle);
    hAntiMetDiff->SetMarkerSize(0.9);
    if(iPlot == 3 ) {
        //Build best fit QCD with default W and EWK Shap
        TH1D *hPdfMetQCD  = (TH1D*)(lQCD ->createHistogram(("hPdfMetQCD"    +iName).c_str(), pfmet));
        TH1D *hPdfAMetQCD = (TH1D*)(lAQCD->createHistogram(("hPdfAntiMetQCD"+iName).c_str(), pfmet));
        hPdfMetQCD ->Scale(nQCD    .getVal()/hPdfMetQCD ->Integral());
        hPdfAMetQCD->Scale(nAntiQCD.getVal()/hPdfAMetQCD->Integral());

        TH1D *pW    = (TH1D*) iW      ->Clone("WForToys");
        pW   ->Scale(nSig    .getVal()/pW   ->Integral());
        TH1D *pEWK  = (TH1D*) iEWK    ->Clone("EWKForToys");
        pEWK ->Scale(nEWK    .getVal()/pEWK ->Integral());
        TH1D *pAW   = (TH1D*) iAntiW  ->Clone("AWForToys");
        pAW  ->Scale(nAntiSig.getVal()/pAW  ->Integral());
        TH1D *pAEWK = (TH1D*) iAntiEWK->Clone("AEWKForToys");
        pAEWK->Scale(nAntiEWK.getVal()/pAEWK->Integral());
        hPdfMetQCD ->Add(pW);
        hPdfMetQCD ->Add(pEWK);
        hPdfAMetQCD->Add(pAW);
        hPdfAMetQCD->Add(pAEWK);
        fBestFit     = hPdfMetQCD;
        fAntiBestFit = hPdfAMetQCD;
        return lResults;
    }

    //--------------------------------------------------------------------------------------------------------------
    // Make plots
    //==============================================================================================================
    char ylabel[100];  // string buffer for y-axis label

    // file format for output plots
    const TString format("png");

    // label for lumi
    char lumitext[100];
    if(lumi<0.1) sprintf(lumitext,"%.1f pb^{-1}  at  #sqrt{s} = %i TeV",lumi*1000.,Ecm);
    else         sprintf(lumitext,"%.2f fb^{-1}  at  #sqrt{s} = %i TeV",lumi      ,Ecm);

    // plot colors
    Int_t linecolorW   = kOrange-3;
    Int_t fillcolorW   = kOrange-2;
    Int_t linecolorEWK = kOrange+10;
    Int_t fillcolorEWK = kOrange+7;
    Int_t linecolorQCD = kViolet+2;
    Int_t fillcolorQCD = kViolet-5;
    Int_t ratioColor   = kGray+2;

    //
    // Dummy histograms for TLegend
    // (Nobody can figure out how to properly pass RooFit objects...)
    //
    TH1D *hDummyData = new TH1D("hDummyData","",0,0,10);
    hDummyData->SetMarkerStyle(kFullCircle);
    hDummyData->SetMarkerSize(0.9);

    TH1D *hDummyW = new TH1D("hDummyW","",0,0,10);
    hDummyW->SetLineColor(linecolorW);
    hDummyW->SetFillColor(fillcolorW);
    hDummyW->SetFillStyle(1001);

    TH1D *hDummyEWK = new TH1D("hDummyEWK","",0,0,10);
    hDummyEWK->SetLineColor(linecolorEWK);
    hDummyEWK->SetFillColor(fillcolorEWK);
    hDummyEWK->SetFillStyle(1001);

    TH1D *hDummyQCD = new TH1D("hDummyQCD","",0,0,10);
    hDummyQCD->SetLineColor(linecolorQCD);
    hDummyQCD->SetFillColor(fillcolorQCD);
    hDummyQCD->SetFillStyle(1001);

    //
    // W MET plot
    //
    RooPlot *wmframe = pfmet.frame(Bins(NBINS));
    dataMet.plotOn(wmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
    pdfMet.plotOn(wmframe,FillColor(fillcolorW),DrawOption("F"));
    pdfMet.plotOn(wmframe,LineColor(linecolorW));
    pdfMet.plotOn(wmframe,Components(RooArgSet(pdfEWK,*lQCD)),FillColor(fillcolorEWK),DrawOption("F"));
    pdfMet.plotOn(wmframe,Components(RooArgSet(pdfEWK,*lQCD)),LineColor(linecolorEWK));
    pdfMet.plotOn(wmframe,Components(RooArgSet(*lQCD)),FillColor(fillcolorQCD),DrawOption("F"));
    pdfMet.plotOn(wmframe,Components(RooArgSet(*lQCD)),LineColor(linecolorQCD));
    pdfMet.plotOn(wmframe,Components(RooArgSet(pdfW)),LineColor(linecolorW),LineStyle(2));
    dataMet.plotOn(wmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));

    sprintf(ylabel,"Events / %.1f GeV",iData->GetBinWidth(1));
    CPlot plotMet(("fitmet"+iName).c_str(),wmframe,"","",ylabel);
    plotMet.SetLegend(0.68,0.57,0.93,0.77);
    plotMet.GetLegend()->AddEntry(hDummyData,"data","PL");
    plotMet.GetLegend()->AddEntry(hDummyW,"W#rightarrow#mu#nu","F");
    plotMet.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F");
    plotMet.GetLegend()->AddEntry(hDummyQCD,"QCD","F");
    plotMet.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0);
    plotMet.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0);
    plotMet.SetYRange(0.1,1.1*(iData->GetMaximum()));
    plotMet.Draw(iC,kFALSE,format,1);

    CPlot plotMetDiff(("fitmet"+iName).c_str(),"","#slash{E}_{T} [GeV]","#chi");
    plotMetDiff.AddHist1D(hMetDiff,"EX0",ratioColor);
    plotMetDiff.SetYRange(-8,8);
    plotMetDiff.AddLine(0, 0,METMAX, 0,kBlack,1);
    plotMetDiff.AddLine(0, 5,METMAX, 5,kBlack,3);
    plotMetDiff.AddLine(0,-5,METMAX,-5,kBlack,3);
    plotMetDiff.Draw(iC,kTRUE,format,2);
    plotMet.Draw(iC,kTRUE,format,1);

    plotMet.SetName(("fitmetlog"+iName).c_str());
    plotMet.SetLogy();
    plotMet.SetYRange(1e-3*(iData->GetMaximum()),10*(iData->GetMaximum()));
    plotMet.Draw(iC,kTRUE,format,1);

    if(iDoMu) {
        RooPlot *awmframe = pfmet.frame(Bins(NBINS));
        antiMet.plotOn(awmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
        apdfMet.plotOn(awmframe,FillColor(fillcolorW),DrawOption("F"));
        apdfMet.plotOn(awmframe,LineColor(linecolorW));
        apdfMet.plotOn(awmframe,Components(RooArgSet(apdfEWK,*lQCD)),FillColor(fillcolorEWK),DrawOption("F"));
        apdfMet.plotOn(awmframe,Components(RooArgSet(apdfEWK,*lQCD)),LineColor(linecolorEWK));
        apdfMet.plotOn(awmframe,Components(RooArgSet(*lQCD)),FillColor(fillcolorQCD),DrawOption("F"));
        apdfMet.plotOn(awmframe,Components(RooArgSet(*lQCD)),LineColor(linecolorQCD));
        apdfMet.plotOn(awmframe,Components(RooArgSet(apdfW)),LineColor(linecolorW),LineStyle(2));
        antiMet.plotOn(awmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));

        sprintf(ylabel,"Events / %.1f GeV",iAntiData->GetBinWidth(1));
        CPlot plotAntiMet(("fitantimet"+iName).c_str(),awmframe,"","",ylabel);
        plotAntiMet.SetLegend(0.68,0.57,0.93,0.77);
        plotAntiMet.GetLegend()->AddEntry(hDummyData,"data","PL");
        plotAntiMet.GetLegend()->AddEntry(hDummyW,"W#rightarrow#mu#nu","F");
        plotAntiMet.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F");
        plotAntiMet.GetLegend()->AddEntry(hDummyQCD,"QCD","F");
        plotAntiMet.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0);
        plotAntiMet.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0);
        plotAntiMet.SetYRange(0.1,1.1*(iAntiData->GetMaximum()));
        plotAntiMet.Draw(iC,kFALSE,format,1);

        CPlot plotAntiMetDiff(("fitantimet"+iName).c_str(),"","#slash{E}_{T} [GeV]","#chi");
        plotAntiMetDiff.AddHist1D(hMetDiff,"EX0",ratioColor);
        plotAntiMetDiff.SetYRange(-8,8);
        plotAntiMetDiff.AddLine(0, 0,METMAX, 0,kBlack,1);
        plotAntiMetDiff.AddLine(0, 5,METMAX, 5,kBlack,3);
        plotAntiMetDiff.AddLine(0,-5,METMAX,-5,kBlack,3);
        plotAntiMetDiff.Draw(iC,kTRUE,format,2);

        plotAntiMet.SetName(("fitantimetlog"+iName).c_str());
        plotAntiMet.SetLogy();
        plotAntiMet.SetYRange(1e-3*(iAntiData->GetMaximum()),10*(iAntiData->GetMaximum()));
        plotAntiMet.Draw(iC,kTRUE,format,1);
    }
    if(iPlot == 1) return lResults;

    ofstream txtfile;
    std::string txtfName = "fitres"+iName;
    if( iDoMu) txtfName + "Mu.txt";
    if(!iDoMu) txtfName + "Mu.txt";
    ios_base::fmtflags flags;
    cout << " --- test " << iData->Integral() << " -- " << hPdfMet->Integral() << endl;
    Double_t chi2prob = iData->Chi2Test(hPdfMet,"PUW");
    Double_t chi2ndf  = iData->Chi2Test(hPdfMet,"CHI2/NDFUW");
    Double_t ksprob   = iData->KolmogorovTest(hPdfMet);
    Double_t ksprobpe = 1;//iData->KolmogorovTest(hPdfMet,"DX");
    txtfile.open(txtfName.c_str());
    assert(txtfile.is_open());

    flags = txtfile.flags();
    txtfile << setprecision(10);
    txtfile << " *** Yields *** " << endl;
    txtfile << "Selected: " << iData->Integral() << endl;
    txtfile << "  Signal: " << nSig.getVal() << " +/- " << nSig.getPropagatedError(*fitRes) << endl;
    txtfile << "     QCD: " << nQCD.getVal() << " +/- " << nQCD.getPropagatedError(*fitRes) << endl;
    txtfile << "   Other: " << nEWK.getVal() << " +/- " << nEWK.getPropagatedError(*fitRes) << endl;
    txtfile << endl;
    txtfile.flags(flags);

    fitRes->printStream(txtfile,RooPrintable::kValue,RooPrintable::kVerbose);
    txtfile << endl;
    printCorrelations(txtfile, fitRes);
    txtfile << endl;
    printChi2AndKSResults(txtfile, chi2prob, chi2ndf, ksprob, ksprobpe);
    txtfile.close();
    return lResults;
}
Example #2
0
void Draw3paneleff() {
    gStyle->SetOptStat(kFALSE);
    TString outG="G1.root";
    TCanvas *c1  = new TCanvas("","",1000,400);
    c1->Divide(3);
    gStyle->SetErrorX(0);
    double hfbin[]= {0,1,2,3,4,6,8,10,13,16,20,25,30,40,55,70,90};
    int nhfbin = 16;
    TString name, dirname;
    TFile *fDSeff = TFile::Open("/scratch/xuq7/Centrality/pPbHijing_EffCorr_forNBD.root");
    TFile *ftreff = TFile::Open("/scratch/xuq7/Centrality/pPbHist_Hijing_TrandEs.root");
    TH1D* hbef = (TH1D*)ftreff->Get("hHFEnergy4");
    TH1D* rehbef = (TH1D*)hbef->Rebin(nhfbin,"rehHFEnergy4",hfbin);
    TH1D* haft = (TH1D*)ftreff->Get("hHFEnergy4_tr");
    TH1D* rehaft = (TH1D*)haft->Rebin(nhfbin,"rehHFEnergy4_tr",hfbin);
    TGraphAsymmErrors *gtreff = new TGraphAsymmErrors();
    gtreff->BayesDivide(rehaft,rehbef);

    TGraphAsymmErrors *geff = (TGraphAsymmErrors*)fDSeff->Get("regEffHF4");
    for(int i=0; i<geff->GetN(); i++) {
        geff->SetPointEXlow(i,0);
        geff->SetPointEXhigh(i,0);
        gtreff->SetPointEXlow(i,0);
        gtreff->SetPointEXhigh(i,0);
    }

    geff->SetTitle("");
    geff->SetMarkerStyle(33);
    geff->SetMarkerColor(5);
    geff->SetMarkerSize(1.3);

    gtreff->SetTitle("");
    gtreff->SetMarkerStyle(21);
    gtreff->SetMarkerColor(6);
    gtreff->SetMarkerSize(1.3);

    for(int cenvar=0; cenvar<3; cenvar++) {
        TFile *f = TFile::Open(Form("%s/%s",cenvardir[cenvar].Data(),outG.Data()));
        c1->cd(cenvar+1);
        TObjString* dataname = (TObjString*)f->Get(Form("dataname"));
        TObjString* histoname = (TObjString*)f->Get(Form("histoname"));
        TFile *fdata = TFile::Open(dataname->GetString());
        TH1D *histo_obs = (TH1D*)fdata->Get(histoname->GetString());
        histo_obs->Sumw2();
        TH1D* hFrame = histo_obs->Clone();
        hFrame->Reset();
        hFrame->SetTitle("");
        hFrame->SetMaximum(1.2);
        hFrame->SetMinimum(0);
        if(cenvar==0)hFrame->GetYaxis()->SetTitle("ratio");
        else hFrame->GetYaxis()->SetTitle("");
        hFrame->GetXaxis()->SetRangeUser(0,100);
        hFrame->GetXaxis()->CenterTitle(0);
        hFrame->GetYaxis()->CenterTitle(1);
        hFrame->GetYaxis()->SetTitleOffset(1.1);
        hFrame->GetXaxis()->SetTitleOffset(1.1);
        hFrame->GetXaxis()->SetTitleSize(0.056);
        hFrame->GetYaxis()->SetTitleSize(0.056);
        hFrame->GetXaxis()->SetLabelSize(0.05);
        hFrame->GetYaxis()->SetLabelSize(0.05);

        int binnum = histo_obs->GetNbinsX();
        double Minx = histo_obs->GetXaxis()->GetXmin();
        double Maxx = histo_obs->GetXaxis()->GetXmax();
        double binsize = (Double_t)(Maxx-Minx)/binnum;
        hFrame->Draw();
        TLegend *leg = new TLegend(0.40, 0.2, 0.65, 0.4);

        for(int sth=0; sth<3; sth++) {
            int Gth=0;
            if(sth==0) {
                dirname = "std";
            }
            else if(sth==1) {
                dirname ="Gri055";
            }
            else {
                dirname ="Gri101";
            }
            hFrame->GetXaxis()->SetTitle(cenvariable[cenvar]);

            if(Gth==0)
                name = "G0";
            else if(Gth<nGlau)
                name = Form("Glau_%d",Gth);
            else
                name = Form("bin_%d",Gth-nGlau+1);
            TObjString* Glaubername = (TObjString*)f->Get(Form("%s/%s/Glaubername",dirname.Data(),name.Data()));
            TVectorD* xmin = (TVectorD*)f->Get(Form("%s/%s/xmin",dirname.Data(),name.Data()));
            TVectorD* xmax = (TVectorD*)f->Get(Form("%s/%s/xmax",dirname.Data(),name.Data()));
            TVectorD* mubest = (TVectorD*)f->Get(Form("%s/%s/mubest",dirname.Data(),name.Data()));
            TVectorD* kbest = (TVectorD*)f->Get(Form("%s/%s/kbest",dirname.Data(),name.Data()));
            TVectorD* Ndf = (TVectorD*)f->Get(Form("%s/%s/Ndf",dirname.Data(),name.Data()));
            TVectorD* chis = (TVectorD*)f->Get(Form("%s/%s/chis",dirname.Data(),name.Data()));
            TVectorD *kpoint = (TVectorD*)f->Get(Form("%s/%s/kpoint",dirname.Data(),name.Data()));
            int xbinmin=(int)(((*xmin)[0]-Minx)/binsize);
            int xbinmax=(int)(((*xmax)[0]-Minx)/binsize);
            TFile *fGlauber = TFile::Open(Glaubername->GetString());
            TH1D *histo_exp = new TH1D("histo_exp","Simulated distribution;Multiplicity;Event Fraction",binnum,Minx,Maxx);
            histo_exp->Sumw2();
            Int_t ibin;

            TH1D *histo_obs_norm = (TH1D*)histo_obs->Clone();
            histo_obs_norm->Scale(1/histo_obs->Integral(xbinmin,xbinmax));

            TF1 *NBD_fun = new
            TF1("NBD_fun","[0]*TMath::Gamma(x+[1])/(TMath::Gamma(x+1)*TMath::Gamma([1]))*TMath::Power([2]/[1],x)/TMath::Power([2]/[1]+1,x+[1])",0,100);
            NBD_fun->SetParameter(0,1);	//[0]: Normalized constant
            NBD_fun->SetParameter(1,(*kbest)[0]);	//[1]: k value
            NBD_fun->SetParameter(2,(*mubest)[0]);	//[2]: mu value

            TTree *t = (TTree*) fGlauber->Get("nt_p_Pb");
            Long_t Nevent;

            Nevent = (Long_t) t->GetEntries();

            Long_t Ev;
            Int_t Bino;
            Double_t Para, Bi_Para, Mult;
            Float_t Ncoll;
            t->SetBranchAddress("Ncoll",&Ncoll);

            for(Ev=0; Ev<Nevent; Ev++) {
                if(Ev%100000==0)	 cout<<"Have run "<<Ev<<" events"<<endl;
                t->GetEntry(Ev);
                Para = 0; //make sure that Para doesn't accumulate through loops
                for(Bino=0; Bino<Ncoll; Bino++) {
                    Bi_Para = NBD_fun->GetRandom();
                    Para += Bi_Para;
                }
                histo_exp->Fill(Para);
            }
            Double_t SumEvent, scale;
            SumEvent = histo_exp->Integral(xbinmin,xbinmax);
            scale = 1/SumEvent;
            TH1D *histo_exp_norm = (TH1D*) histo_exp->Clone();
            histo_exp_norm->Scale(scale);


            rehisto_obs_norm = (TH1D*)histo_obs_norm->Rebin(nhfbin,"rehisto_obs_norm",hfbin);
            normalizeByBinWidth(rehisto_obs_norm);
            rehisto_exp_norm = (TH1D*)histo_exp_norm->Rebin(nhfbin,"rehisto_exp_norm",hfbin);
            normalizeByBinWidth(rehisto_exp_norm);
            TH1D* ratio = (TH1D*)rehisto_obs_norm->Clone("ratio");
            ratio->Divide(rehisto_exp_norm);

            ratio->SetTitle("");
            ratio->SetLineColor(1);
            ratio->SetMarkerStyle(20);
            ratio->SetMarkerColor(color_[sth]);
            ratio->SetMarkerSize(1.3);
            ratio->Draw("Psame");
            geff->Draw("Psame");
            gtreff->Draw("Psame");
            leg->AddEntry(ratio,Form("data/fit %s",Grilist[sth].Data()),"p");
        }

        leg->SetFillColor(10);
        leg->SetFillStyle(0);
        leg->SetBorderSize(0.035);
        leg->SetTextFont(42);
        leg->SetTextSize(0.045);
        leg->AddEntry(geff,"DS efficiency","p");
        leg->AddEntry(gtreff,"Event selection efficiency","p");
        if(cenvar==2) leg->Draw("same");

        TLine *l = new TLine(0,1,90,1);
        l->SetLineStyle(2);
        l->Draw("same");
    }
    c1->SaveAs(Form("ratiovseff.png"));
    c1->SaveAs(Form("ratiovseff.pdf"));
}
void plotFakeRate_eta(){

  TFile *f1= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/DYJetsToLL_M-50_TuneCUETP8M1_13TeV-amcatnloFXFX-pythia8_hadd.root"); 
  TFile *f2= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/QCD_HT100to200_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *f3= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/QCD_HT200to300_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *f4= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/QCD_HT300to500_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *f5= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/QCD_HT500to700_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *f6= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/QCD_HT700to1000_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *f7= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/QCD_HT1000to1500_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *f8= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/QCD_HT1500to2000_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");

  TFile *g1= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/WJetsToLNu_HT-100To200_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *g2= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/WJetsToLNu_HT-200To400_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *g3= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/WJetsToLNu_HT-400To600_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *g4= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/WJetsToLNu_HT-600To800_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *g5= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/WJetsToLNu_HT-800To1200_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *g6= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/WJetsToLNu_HT-1200To2500_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");
  TFile *g7= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/WJetsToLNu_HT-2500ToInf_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_hadd.root");

  TFile *h1= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds/nominal/DoubleMuon_Run2015C_16Dec2015_hadd.root");
  TFile *h2= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds/nominal/DoubleMuon_Run2015D_16Dec2015_hadd.root");
  TFile *h3= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds/nominal/DoubleEG_Run2015C_16Dec2015_hadd.root");
  TFile *h4= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds/nominal/DoubleEG_Run2015D_16Dec2015_hadd.root");

  TFile *h5= TFile::Open("root://cmseos.fnal.gov//store/user/lpcljm/LJMet_FakeRateTest_step1PtEtahadds_rizki/nominal/TT_TuneCUETP8M1_13TeV-powheg-pythia8_hadd.root");

  /*
   NTotalSLPassed = new TH1D("NTotalSLPassed","",3,0,3);
   NLooseTightEl = new TH1D("NLooseTightEl","",2,0,2);
   NLooseTightMu = new TH1D("NLooseTightMu","",2,0,2);
   NLooseEl_Pt = new TH1D("NLooseEl_Pt","",5,ptbins);
   NLooseMu_Pt = new TH1D("NLooseMu_Pt","",5,ptbins);
   NLooseEl_Eta = new TH1D("NLooseEl_Eta","",4,etabinsEl);
   NLooseMu_Eta = new TH1D("NLooseMu_Eta","",4,etabinsMu);
   NLooseEl_Eta = new TH1D("NLooseEl_Eta","",5,ptbins,4,etabinsEl);
   NLooseMu_Eta = new TH1D("NLooseMu_Eta","",5,ptbins,4,etabinsMu);
   NTightEl_Pt = new TH1D("NTightEl_Pt","",5,ptbins);
   NTightMu_Pt = new TH1D("NTightMu_Pt","",5,ptbins);
   NTightEl_Eta = new TH1D("NTightEl_Eta","",4,etabinsEl);
   NTightMu_Eta = new TH1D("NTightMu_Eta","",4,etabinsMu);
   NTightEl_Eta = new TH1D("NTightEl_Eta","",5,ptbins,4,etabinsEl);
   NTightMu_Eta = new TH1D("NTightMu_Eta","",5,ptbins,4,etabinsMu);
  */

  TH1D *NLEl_DY = (TH1D*)f1->Get("NLooseEl_Eta");
  TH1D *NLMu_DY = (TH1D*)f1->Get("NLooseMu_Eta");
  TH1D *NTEl_DY = (TH1D*)f1->Get("NTightEl_Eta");
  TH1D *NTMu_DY = (TH1D*)f1->Get("NTightMu_Eta");

  TH1D *NLEl_WJ100 = (TH1D*)g1->Get("NLooseEl_Eta");
  TH1D *NLMu_WJ100 = (TH1D*)g1->Get("NLooseMu_Eta");
  TH1D *NTEl_WJ100 = (TH1D*)g1->Get("NTightEl_Eta");
  TH1D *NTMu_WJ100 = (TH1D*)g1->Get("NTightMu_Eta");
  TH1D *NLEl_WJ200 = (TH1D*)g2->Get("NLooseEl_Eta");
  TH1D *NLMu_WJ200 = (TH1D*)g2->Get("NLooseMu_Eta");
  TH1D *NTEl_WJ200 = (TH1D*)g2->Get("NTightEl_Eta");
  TH1D *NTMu_WJ200 = (TH1D*)g2->Get("NTightMu_Eta");
  TH1D *NLEl_WJ400 = (TH1D*)g3->Get("NLooseEl_Eta");
  TH1D *NLMu_WJ400 = (TH1D*)g3->Get("NLooseMu_Eta");
  TH1D *NTEl_WJ400 = (TH1D*)g3->Get("NTightEl_Eta");
  TH1D *NTMu_WJ400 = (TH1D*)g3->Get("NTightMu_Eta");
  TH1D *NLEl_WJ600 = (TH1D*)g4->Get("NLooseEl_Eta");
  TH1D *NLMu_WJ600 = (TH1D*)g4->Get("NLooseMu_Eta");
  TH1D *NTEl_WJ600 = (TH1D*)g4->Get("NTightEl_Eta");
  TH1D *NTMu_WJ600 = (TH1D*)g4->Get("NTightMu_Eta");
  TH1D *NLEl_WJ800 = (TH1D*)g5->Get("NLooseEl_Eta");
  TH1D *NLMu_WJ800 = (TH1D*)g5->Get("NLooseMu_Eta");
  TH1D *NTEl_WJ800 = (TH1D*)g5->Get("NTightEl_Eta");
  TH1D *NTMu_WJ800 = (TH1D*)g5->Get("NTightMu_Eta");
  TH1D *NLEl_WJ1200 = (TH1D*)g6->Get("NLooseEl_Eta");
  TH1D *NLMu_WJ1200 = (TH1D*)g6->Get("NLooseMu_Eta");
  TH1D *NTEl_WJ1200 = (TH1D*)g6->Get("NTightEl_Eta");
  TH1D *NTMu_WJ1200 = (TH1D*)g6->Get("NTightMu_Eta");
  TH1D *NLEl_WJ2500 = (TH1D*)g7->Get("NLooseEl_Eta");
  TH1D *NLMu_WJ2500 = (TH1D*)g7->Get("NLooseMu_Eta");
  TH1D *NTEl_WJ2500 = (TH1D*)g7->Get("NTightEl_Eta");
  TH1D *NTMu_WJ2500 = (TH1D*)g7->Get("NTightMu_Eta");

  TH1D *NLEl_QCD100 = (TH1D*)f2->Get("NLooseEl_Eta");
  TH1D *NLMu_QCD100 = (TH1D*)f2->Get("NLooseMu_Eta");
  TH1D *NTEl_QCD100 = (TH1D*)f2->Get("NTightEl_Eta");
  TH1D *NTMu_QCD100 = (TH1D*)f2->Get("NTightMu_Eta");
  TH1D *NLEl_QCD200 = (TH1D*)f3->Get("NLooseEl_Eta");
  TH1D *NLMu_QCD200 = (TH1D*)f3->Get("NLooseMu_Eta");
  TH1D *NTEl_QCD200 = (TH1D*)f3->Get("NTightEl_Eta");
  TH1D *NTMu_QCD200 = (TH1D*)f3->Get("NTightMu_Eta");
  TH1D *NLEl_QCD300 = (TH1D*)f4->Get("NLooseEl_Eta");
  TH1D *NLMu_QCD300 = (TH1D*)f4->Get("NLooseMu_Eta");
  TH1D *NTEl_QCD300 = (TH1D*)f4->Get("NTightEl_Eta");
  TH1D *NTMu_QCD300 = (TH1D*)f4->Get("NTightMu_Eta");
  TH1D *NLEl_QCD500 = (TH1D*)f5->Get("NLooseEl_Eta");
  TH1D *NLMu_QCD500 = (TH1D*)f5->Get("NLooseMu_Eta");
  TH1D *NTEl_QCD500 = (TH1D*)f5->Get("NTightEl_Eta");
  TH1D *NTMu_QCD500 = (TH1D*)f5->Get("NTightMu_Eta");
  TH1D *NLEl_QCD700 = (TH1D*)f6->Get("NLooseEl_Eta");
  TH1D *NLMu_QCD700 = (TH1D*)f6->Get("NLooseMu_Eta");
  TH1D *NTEl_QCD700 = (TH1D*)f6->Get("NTightEl_Eta");
  TH1D *NTMu_QCD700 = (TH1D*)f6->Get("NTightMu_Eta");
  TH1D *NLEl_QCD1000 = (TH1D*)f7->Get("NLooseEl_Eta");
  TH1D *NLMu_QCD1000 = (TH1D*)f7->Get("NLooseMu_Eta");
  TH1D *NTEl_QCD1000 = (TH1D*)f7->Get("NTightEl_Eta");
  TH1D *NTMu_QCD1000 = (TH1D*)f7->Get("NTightMu_Eta");
  TH1D *NLEl_QCD1500 = (TH1D*)f8->Get("NLooseEl_Eta");
  TH1D *NLMu_QCD1500 = (TH1D*)f8->Get("NLooseMu_Eta");
  TH1D *NTEl_QCD1500 = (TH1D*)f8->Get("NTightEl_Eta");
  TH1D *NTMu_QCD1500 = (TH1D*)f8->Get("NTightMu_Eta");

  TH1D *NLEl_DMC = (TH1D*)h1->Get("NLooseEl_Eta");
  TH1D *NLMu_DMC = (TH1D*)h1->Get("NLooseMu_Eta");
  TH1D *NTEl_DMC = (TH1D*)h1->Get("NTightEl_Eta");
  TH1D *NTMu_DMC = (TH1D*)h1->Get("NTightMu_Eta");
  TH1D *NLEl_DMD = (TH1D*)h2->Get("NLooseEl_Eta");
  TH1D *NLMu_DMD = (TH1D*)h2->Get("NLooseMu_Eta");
  TH1D *NTEl_DMD = (TH1D*)h2->Get("NTightEl_Eta");
  TH1D *NTMu_DMD = (TH1D*)h2->Get("NTightMu_Eta");
  TH1D *NLEl_DEC = (TH1D*)h3->Get("NLooseEl_Eta");
  TH1D *NLMu_DEC = (TH1D*)h3->Get("NLooseMu_Eta");
  TH1D *NTEl_DEC = (TH1D*)h3->Get("NTightEl_Eta");
  TH1D *NTMu_DEC = (TH1D*)h3->Get("NTightMu_Eta");
  TH1D *NLEl_DED = (TH1D*)h4->Get("NLooseEl_Eta");
  TH1D *NLMu_DED = (TH1D*)h4->Get("NLooseMu_Eta");
  TH1D *NTEl_DED = (TH1D*)h4->Get("NTightEl_Eta");
  TH1D *NTMu_DED = (TH1D*)h4->Get("NTightMu_Eta");

  TH1D *NLEl_TT = (TH1D*)h5->Get("NLooseEl_Eta");
  TH1D *NLMu_TT = (TH1D*)h5->Get("NLooseMu_Eta");
  TH1D *NTEl_TT = (TH1D*)h5->Get("NTightEl_Eta");
  TH1D *NTMu_TT = (TH1D*)h5->Get("NTightMu_Eta");
  
  double scale_WJ100 = 201.4*1345.0*1.21/10205377.;
  double scale_WJ200 = 201.4*359.7*1.21/4949568.;
  double scale_WJ400 = 201.4*48.91*1.21/1943664.;
  double scale_WJ600 = 201.4*12.05*1.21/3767766.;
  double scale_WJ800 = 201.4*5.501*1.21/1568277.;
  double scale_WJ1200 = 201.4*1.329*1.21/246239.;
  double scale_WJ2500 = 201.4*0.03216*1.21/251982.;

  double scale_QCD100 = 201.4*27990000.0/82095800.;
  double scale_QCD200 = 201.4*1712000.0/18784379.;
  double scale_QCD300 = 201.4*347700.0/16909004.;
  double scale_QCD500 = 201.4*32100.0/19665695.;
  double scale_QCD700 = 201.4*6831.0/15547962.;
  double scale_QCD1000 = 201.4*1207.0/5049267.;
  double scale_QCD1500 = 201.4*119.9/3939077.;

  double scale_DY = 201.4*6025.2/81236727.;
  double scale_TT = 201.4*831.76/97994442;

  double ElCoeff = 46.8/201.4;

  NTEl_WJ100->Scale(ElCoeff*scale_WJ100);    NTMu_WJ100->Scale(scale_WJ100);  
  NTEl_WJ200->Scale(ElCoeff*scale_WJ200);    NTMu_WJ200->Scale(scale_WJ200);  
  NTEl_WJ400->Scale(ElCoeff*scale_WJ400);    NTMu_WJ400->Scale(scale_WJ400);  
  NTEl_WJ600->Scale(ElCoeff*scale_WJ600);    NTMu_WJ600->Scale(scale_WJ600);  
  NTEl_WJ800->Scale(ElCoeff*scale_WJ800);    NTMu_WJ800->Scale(scale_WJ800);  
  NTEl_WJ1200->Scale(ElCoeff*scale_WJ1200);  NTMu_WJ1200->Scale(scale_WJ1200);
  NTEl_WJ2500->Scale(ElCoeff*scale_WJ2500);  NTMu_WJ2500->Scale(scale_WJ2500);

  NLEl_WJ100->Scale(ElCoeff*scale_WJ100);    NLMu_WJ100->Scale(scale_WJ100);  
  NLEl_WJ200->Scale(ElCoeff*scale_WJ200);    NLMu_WJ200->Scale(scale_WJ200);  
  NLEl_WJ400->Scale(ElCoeff*scale_WJ400);    NLMu_WJ400->Scale(scale_WJ400);  
  NLEl_WJ600->Scale(ElCoeff*scale_WJ600);    NLMu_WJ600->Scale(scale_WJ600);  
  NLEl_WJ800->Scale(ElCoeff*scale_WJ800);    NLMu_WJ800->Scale(scale_WJ800);  
  NLEl_WJ1200->Scale(ElCoeff*scale_WJ1200);  NLMu_WJ1200->Scale(scale_WJ1200);
  NLEl_WJ2500->Scale(ElCoeff*scale_WJ2500);  NLMu_WJ2500->Scale(scale_WJ2500);
  
  NTEl_QCD100->Scale(ElCoeff*scale_QCD100);    NTMu_QCD100->Scale(scale_QCD100);  
  NTEl_QCD200->Scale(ElCoeff*scale_QCD200);    NTMu_QCD200->Scale(scale_QCD200);  
  NTEl_QCD300->Scale(ElCoeff*scale_QCD300);    NTMu_QCD300->Scale(scale_QCD300);  
  NTEl_QCD500->Scale(ElCoeff*scale_QCD500);    NTMu_QCD500->Scale(scale_QCD500);  
  NTEl_QCD700->Scale(ElCoeff*scale_QCD700);    NTMu_QCD700->Scale(scale_QCD700);  
  NTEl_QCD1000->Scale(ElCoeff*scale_QCD1000);  NTMu_QCD1000->Scale(scale_QCD1000);
  NTEl_QCD1500->Scale(ElCoeff*scale_QCD1500);  NTMu_QCD1500->Scale(scale_QCD1500);

  NLEl_QCD100->Scale(ElCoeff*scale_QCD100);    NLMu_QCD100->Scale(scale_QCD100);  
  NLEl_QCD200->Scale(ElCoeff*scale_QCD200);    NLMu_QCD200->Scale(scale_QCD200);  
  NLEl_QCD300->Scale(ElCoeff*scale_QCD300);    NLMu_QCD300->Scale(scale_QCD300);  
  NLEl_QCD500->Scale(ElCoeff*scale_QCD500);    NLMu_QCD500->Scale(scale_QCD500);  
  NLEl_QCD700->Scale(ElCoeff*scale_QCD700);    NLMu_QCD700->Scale(scale_QCD700);  
  NLEl_QCD1000->Scale(ElCoeff*scale_QCD1000);  NLMu_QCD1000->Scale(scale_QCD1000);
  NLEl_QCD1500->Scale(ElCoeff*scale_QCD1500);  NLMu_QCD1500->Scale(scale_QCD1500);
  
  NTEl_DY->Scale(ElCoeff*scale_DY);    NTEl_TT->Scale(ElCoeff*scale_TT);
  NLEl_DY->Scale(ElCoeff*scale_DY);    NLEl_TT->Scale(ElCoeff*scale_TT);
  NTMu_DY->Scale(scale_DY);    NTMu_TT->Scale(scale_TT);
  NLMu_DY->Scale(scale_DY);    NLMu_TT->Scale(scale_TT);

  NTEl_WJ100->Add(NTEl_WJ200);   NTMu_WJ100->Add(NTMu_WJ200); 
  NTEl_WJ100->Add(NTEl_WJ400);   NTMu_WJ100->Add(NTMu_WJ400); 
  NTEl_WJ100->Add(NTEl_WJ600);   NTMu_WJ100->Add(NTMu_WJ600); 
  NTEl_WJ100->Add(NTEl_WJ800);   NTMu_WJ100->Add(NTMu_WJ800); 
  NTEl_WJ100->Add(NTEl_WJ1200);  NTMu_WJ100->Add(NTMu_WJ1200);
  NTEl_WJ100->Add(NTEl_WJ2500);  NTMu_WJ100->Add(NTMu_WJ2500);

  NLEl_WJ100->Add(NLEl_WJ200);   NLMu_WJ100->Add(NLMu_WJ200); 
  NLEl_WJ100->Add(NLEl_WJ400);   NLMu_WJ100->Add(NLMu_WJ400); 
  NLEl_WJ100->Add(NLEl_WJ600);   NLMu_WJ100->Add(NLMu_WJ600); 
  NLEl_WJ100->Add(NLEl_WJ800);   NLMu_WJ100->Add(NLMu_WJ800); 
  NLEl_WJ100->Add(NLEl_WJ1200);  NLMu_WJ100->Add(NLMu_WJ1200);
  NLEl_WJ100->Add(NLEl_WJ2500);  NLMu_WJ100->Add(NLMu_WJ2500);

  NTEl_QCD100->Add(NTEl_QCD200);   NTMu_QCD100->Add(NTMu_QCD200); 
  NTEl_QCD100->Add(NTEl_QCD300);   NTMu_QCD100->Add(NTMu_QCD300); 
  NTEl_QCD100->Add(NTEl_QCD500);   NTMu_QCD100->Add(NTMu_QCD500); 
  NTEl_QCD100->Add(NTEl_QCD700);   NTMu_QCD100->Add(NTMu_QCD700); 
  NTEl_QCD100->Add(NTEl_QCD1000);  NTMu_QCD100->Add(NTMu_QCD1000);
  NTEl_QCD100->Add(NTEl_QCD1500);  NTMu_QCD100->Add(NTMu_QCD1500);

  NLEl_QCD100->Add(NLEl_QCD200);   NLMu_QCD100->Add(NLMu_QCD200); 
  NLEl_QCD100->Add(NLEl_QCD300);   NLMu_QCD100->Add(NLMu_QCD300); 
  NLEl_QCD100->Add(NLEl_QCD500);   NLMu_QCD100->Add(NLMu_QCD500); 
  NLEl_QCD100->Add(NLEl_QCD700);   NLMu_QCD100->Add(NLMu_QCD700); 
  NLEl_QCD100->Add(NLEl_QCD1000);  NLMu_QCD100->Add(NLMu_QCD1000);
  NLEl_QCD100->Add(NLEl_QCD1500);  NLMu_QCD100->Add(NLMu_QCD1500);

  NTEl_DEC->Add(NTEl_DED);  NTMu_DEC->Add(NTMu_DED);
  NTEl_DEC->Add(NTEl_DMC);  NTMu_DEC->Add(NTMu_DMC);
  NTEl_DEC->Add(NTEl_DMD);  NTMu_DEC->Add(NTMu_DMD);

  NLEl_DEC->Add(NLEl_DED);  NLMu_DEC->Add(NLMu_DED);
  NLEl_DEC->Add(NLEl_DMC);  NLMu_DEC->Add(NLMu_DMC);
  NLEl_DEC->Add(NLEl_DMD);  NLMu_DEC->Add(NLMu_DMD);

  TH1D *NREl_WJ100 = (TH1D*)NTEl_WJ100->Clone("NREl_WJ100");
  TH1D *NRMu_WJ100 = (TH1D*)NTMu_WJ100->Clone("NRMu_WJ100");
  TH1D *NREl_QCD100 = (TH1D*)NTEl_QCD100->Clone("NREl_QCD100");
  TH1D *NRMu_QCD100 = (TH1D*)NTMu_QCD100->Clone("NRMu_QCD100");
  TH1D *NREl_DY = (TH1D*)NTEl_DY->Clone("NREl_DY");
  TH1D *NRMu_DY = (TH1D*)NTMu_DY->Clone("NRMu_DY");
  TH1D *NREl_TT = (TH1D*)NTEl_TT->Clone("NREl_TT");
  TH1D *NRMu_TT = (TH1D*)NTMu_TT->Clone("NRMu_TT");
  TH1D *NREl_DEC = (TH1D*)NTEl_DEC->Clone("NREl_DEC");
  TH1D *NRMu_DEC = (TH1D*)NTMu_DEC->Clone("NRMu_DEC");

  NREl_WJ100->Divide(NLEl_WJ100);    NRMu_WJ100->Divide(NLMu_WJ100);  
  NREl_QCD100->Divide(NLEl_QCD100);  NRMu_QCD100->Divide(NLMu_QCD100);
  NREl_DY->Divide(NLEl_DY);       NRMu_DY->Divide(NLMu_DY);	   
  NREl_TT->Divide(NLEl_TT);       NRMu_TT->Divide(NLMu_TT);	   
  NREl_DEC->Divide(NLEl_DEC);    NRMu_DEC->Divide(NLMu_DEC);      

  TCanvas *c1 = new TCanvas("c1","c1",800,600);
  gStyle->SetPalette(1);

  NREl_WJ100->Draw("colz");  
  c1->SaveAs("FakeRatePlots/FakeRate_WJets_El_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_WJets_El_Eta.png");

  NRMu_WJ100->Draw("colz");
  c1->SaveAs("FakeRatePlots/FakeRate_WJets_Mu_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_WJets_Mu_Eta.png");

  NREl_QCD100->Draw("colz");  
  c1->SaveAs("FakeRatePlots/FakeRate_QCD_El_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_QCD_El_Eta.png");

  NRMu_QCD100->Draw("colz");
  c1->SaveAs("FakeRatePlots/FakeRate_QCD_Mu_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_QCD_Mu_Eta.png");

  NREl_DY->Draw("colz");  
  c1->SaveAs("FakeRatePlots/FakeRate_DY_El_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_DY_El_Eta.png");

  NRMu_DY->Draw("colz");
  c1->SaveAs("FakeRatePlots/FakeRate_DY_Mu_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_DY_Mu_Eta.png");

  NREl_TT->Draw("colz");  
  c1->SaveAs("FakeRatePlots/FakeRate_TT_El_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_TT_El_Eta.png");

  NRMu_TT->Draw("colz");
  c1->SaveAs("FakeRatePlots/FakeRate_TT_Mu_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_TT_Mu_Eta.png");

  NREl_DEC->Draw("colz");  
  c1->SaveAs("FakeRatePlots/FakeRate_Data_El_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_Data_El_Eta.png");

  NRMu_DEC->Draw("colz");
  c1->SaveAs("FakeRatePlots/FakeRate_Data_Mu_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_Data_Mu_Eta.png");

  TH1D *newtightEl = (TH1D*)NTEl_DEC->Clone("newtightEl");
  TH1D *newlooseEl = (TH1D*)NLEl_DEC->Clone("newlooseEl");
  newtightEl->Add(NTEl_WJ100,-1);
  newtightEl->Add(NTEl_DY,-1);
  newtightEl->Add(NTEl_TT,-1);
  //  newlooseEl->Add(NLEl_WJ100,-1);
  //  newlooseEl->Add(NLEl_DY,-1);
  //  newlooseEl->Add(NLEl_TT,-1);
  TH1D *newratioEl = (TH1D*)newtightEl->Clone("newratioEl");
  newratioEl->Divide(newlooseEl);

  TH1D *newtightMu = (TH1D*)NTMu_DEC->Clone("newtightMu");
  TH1D *newlooseMu = (TH1D*)NLMu_DEC->Clone("newlooseMu");
  newtightMu->Add(NTMu_WJ100,-1);
  newtightMu->Add(NTMu_DY,-1);
  newtightMu->Add(NTMu_TT,-1);
  //  newlooseMu->Add(NLMu_WJ100,-1);
  //  newlooseMu->Add(NLMu_DY,-1);
  //  newlooseMu->Add(NLMu_TT,-1);
  TH1D *newratioMu = (TH1D*)newtightMu->Clone("newratioMu");
  newratioMu->Divide(newlooseMu);

  TH1D *ratio_QCDdata_el = (TH1D*)newratioEl->Clone("ratio_QCDdata_el");
  ratio_QCDdata_el->Divide(NREl_QCD100);

  TH1D *ratio_QCDdata_mu = (TH1D*)newratioMu->Clone("ratio_QCDdata_mu");
  ratio_QCDdata_mu->Divide(NRMu_QCD100);

  newratioEl->Draw("colz");  
  c1->SaveAs("FakeRatePlots/FakeRate_Data_subtr_El_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_Data_subtr_El_Eta.png");

  newratioMu->Draw("colz");
  c1->SaveAs("FakeRatePlots/FakeRate_Data_subtr_Mu_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_Data_subtr_Mu_Eta.png");
  
  ratio_QCDdata_el->Draw();
  c1->SaveAs("FakeRatePlots/FakeRate_ratio_QCDData_subtr_El_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_ratio_QCDData_subtr_El_Eta.png");

  ratio_QCDdata_mu->Draw();
  c1->SaveAs("FakeRatePlots/FakeRate_ratio_QCDData_subtr_Mu_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_ratio_QCDData_subtr_Mu_Eta.png");

  NREl_TT->GetYaxis()->SetRangeUser(0,1);
  NREl_TT->SetLineColor(kBlue);
  NREl_WJ100->SetLineColor(kGreen);
  NREl_DY->SetLineColor(kViolet);
  NREl_QCD100->SetLineColor(kRed);
  NREl_DEC->SetLineColor(kBlack);
  newratioEl->SetLineColor(kBlack);
  newratioEl->SetLineStyle(5);

  leg_El = new TLegend(0.9-0.38,0.1+0.5,0.9,0.1+0.2+0.5);
  leg_El->AddEntry(NREl_TT,"top","lep");
  leg_El->AddEntry(NREl_WJ100,"W","lep");
  leg_El->AddEntry(NREl_DY,"DY","lep");
  leg_El->AddEntry(NREl_QCD100,"QCD","lep");
  leg_El->AddEntry(NREl_DEC,"Data","lep");
  leg_El->AddEntry(newratioEl,"Data (subtracted)","lep");

  NREl_TT->Draw();
  NREl_WJ100->Draw("same");
  NREl_DY->Draw("same");
  NREl_QCD100->Draw("same");
  NREl_DEC->Draw("same");
  newratioEl->Draw("same");
  leg_El->Draw("same");
  c1->SaveAs("FakeRatePlots/FakeRate_All_El_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_All_El_Eta.png");

  NRMu_TT->GetYaxis()->SetRangeUser(0,1);
  NRMu_TT->SetLineColor(kBlue);
  NRMu_WJ100->SetLineColor(kGreen);
  NRMu_DY->SetLineColor(kViolet);
  NRMu_QCD100->SetLineColor(kRed);
  NRMu_DEC->SetLineColor(kBlack);
  newratioMu->SetLineColor(kBlack);
  newratioMu->SetLineStyle(5);

  leg_Mu = new TLegend(0.9-0.38,0.1,0.9,0.1+0.2);
  leg_Mu->AddEntry(NREl_TT,"top","lep");
  leg_Mu->AddEntry(NREl_WJ100,"W","lep");
  leg_Mu->AddEntry(NREl_DY,"DY","lep");
  leg_Mu->AddEntry(NREl_QCD100,"QCD","lep");
  leg_Mu->AddEntry(NREl_DEC,"Data","lep");
  leg_Mu->AddEntry(newratioEl,"Data (subtracted)","lep");

  NRMu_TT->Draw();
  NRMu_WJ100->Draw("same");
  NRMu_DY->Draw("same");
  NRMu_QCD100->Draw("same");
  NRMu_DEC->Draw("same");
  newratioMu->Draw("same");
  leg_Mu->Draw("same");
  c1->SaveAs("FakeRatePlots/FakeRate_All_Mu_Eta.C");
  c1->SaveAs("FakeRatePlots/FakeRate_All_Mu_Eta.png");

  for(int i = 1; i < NREl_WJ100->GetNbinsX()+1; i++){
    for(int j = 1; j < NREl_WJ100->GetNbinsY()+1; j++){
      cout << "---------------------------------------------------------------" << endl;
      cout << "Pt = " << NREl_WJ100->GetXaxis()->GetBinLowEdge(i) << " - " 
	   << NREl_WJ100->GetXaxis()->GetBinLowEdge(i+1) << ", Eta = " 
	   << NREl_WJ100->GetYaxis()->GetBinLowEdge(j) << " - " 
	   << NREl_WJ100->GetYaxis()->GetBinLowEdge(j+1) << endl;    

      cout << "WJets El: FR = " << NREl_WJ100->GetBinContent(i,j) << " +/- " 
	   << NREl_WJ100->GetBinError(i,j) << ", NT = " << NTEl_WJ100->GetBinContent(i,j) 
	   << ", NL = " << NLEl_WJ100->GetBinContent(i,j) << endl;

      cout << "DY El: FR = " << NREl_DY->GetBinContent(i,j) << " +/- " << NREl_DY->GetBinError(i,j) 
	   << ", NT = " << NTEl_DY->GetBinContent(i,j) 
	   << ", NL = " << NLEl_DY->GetBinContent(i,j)<< endl;

      cout << "TT El: FR = " << NREl_TT->GetBinContent(i,j) << " +/- " << NREl_TT->GetBinError(i,j) 
	   << ", NT = " << NTEl_TT->GetBinContent(i,j) 
	   << ", NL = " << NLEl_TT->GetBinContent(i,j)<< endl;

      cout << "QCD El: FR = " 
	   << NREl_QCD100->GetBinContent(i,j) << " +/- " << NREl_QCD100->GetBinError(i,j)
	   << ", NT = " << NTEl_QCD100->GetBinContent(i,j) 
	   << ", NL = " << NLEl_QCD100->GetBinContent(i,j)<< endl;

      cout << "Data El: FR = " 
	   << NREl_DEC->GetBinContent(i,j) << " +/- " << NREl_DEC->GetBinError(i,j)
	   << ", NT = " << NTEl_DEC->GetBinContent(i,j) 
	   << ", NL = " << NLEl_DEC->GetBinContent(i,j)<< endl;

      cout << "Data El W/Z/T subtracted: FR = " << newratioEl->GetBinContent(i,j) << " +/- " << newratioEl->GetBinError(i,j)
	   << ", NT = " << newtightEl->GetBinContent(i,j) << ", NL = " << newlooseEl->GetBinContent(i,j) << endl;
      
    }
  }

  for(int i = 1; i < NRMu_WJ100->GetNbinsX()+1; i++){
    for(int j = 1; j < NRMu_WJ100->GetNbinsY()+1; j++){
      cout << "---------------------------------------------------------------" << endl;
      cout << "Pt = " << NRMu_WJ100->GetXaxis()->GetBinLowEdge(i) << " - " 
	   << NRMu_WJ100->GetXaxis()->GetBinLowEdge(i+1) << ", Eta = " 
	   << NRMu_WJ100->GetYaxis()->GetBinLowEdge(j) << " - " 
	   << NRMu_WJ100->GetYaxis()->GetBinLowEdge(j+1) << endl;
      cout << "WJets Mu: FR = " << NRMu_WJ100->GetBinContent(i,j) << " +/- " 
	   << NRMu_WJ100->GetBinError(i,j) << ", NT = " << NTMu_WJ100->GetBinContent(i,j) 
	   << ", NL = " << NLMu_WJ100->GetBinContent(i,j) << endl;

      cout << "DY Mu: FR = " << NRMu_DY->GetBinContent(i,j) << " +/- " << NRMu_DY->GetBinError(i,j) 
	   << ", NT = " << NTMu_DY->GetBinContent(i,j) 
	   << ", NL = " << NLMu_DY->GetBinContent(i,j)<< endl;

      cout << "TT Mu: FR = " << NRMu_TT->GetBinContent(i,j) << " +/- " << NRMu_TT->GetBinError(i,j) 
	   << ", NT = " << NTMu_TT->GetBinContent(i,j) 
	   << ", NL = " << NLMu_TT->GetBinContent(i,j)<< endl;

      cout << "QCD Mu: FR = " 
	   << NRMu_QCD100->GetBinContent(i,j) << " +/- " << NRMu_QCD100->GetBinError(i,j)
	   << ", NT = " << NTMu_QCD100->GetBinContent(i,j) 
	   << ", NL = " << NLMu_QCD100->GetBinContent(i,j)<< endl;

      cout << "Data Mu: FR = " 
	   << NRMu_DEC->GetBinContent(i,j) << " +/- " << NRMu_DEC->GetBinError(i,j)
	   << ", NT = " << NTMu_DEC->GetBinContent(i,j) 
	   << ", NL = " << NLMu_DEC->GetBinContent(i,j)<< endl;

      cout << "Data Mu W/Z/T subtracted: FR = " << newratioMu->GetBinContent(i,j) << " +/- " << newratioMu->GetBinError(i,j)
	   << ", NT = " << newtightMu->GetBinContent(i,j) << ", NL = " << newlooseMu->GetBinContent(i,j) << endl;
    }
  }

  cout << "DONE" << endl;

}
Example #4
0
void bfractionVsCent(char *tagger="discr_ssvHighEff", double workingPoint=2., int fixCL=0, char *taggerName="ssvHighEff", float ptlo=80, float pthi=100, float etalo=0., float etahi=2.) {

  gStyle->SetOptStat(0);
  gStyle->SetOptTitle(0);
  gStyle->SetLabelFont(43,"xyz");
  gStyle->SetLabelSize(20,"xyz");
  gStyle->SetTitleFont(43,"xyz");
  gStyle->SetTitleSize(26,"xyz");
  gStyle->SetTitleOffset(1.0,"xy"); 
  gROOT->ForceStyle(1);
  
  int doLTJP=1;
  int doLTCSV=0;

  const int nBins = 2;
  double centBin[nBins+1] = {0,30,100};
  //const int nBins = 3;
  //double centBin[nBins+1] = {0,20,50,100};
 
  
  Double_t bPurMC, bPurData, bEffMC, bEffDataLTJP, bEffDataLTCSV, taggedFracData, bFracMC, bFracData, bFracDataLTJP, bFracDataLTCSV, bFracJPdirect;
  Double_t bPurMCError, bPurDataError, bEffMCError, bEffDataLTJPError, bEffDataLTCSVError, taggedFracDataError, bFracMCError, bFracDataError, bFracDataLTJPError, bFracDataLTCSVError, bFracJPdirectError;
  Enumerations numbers;
  
  TH1D *hBPurityData = new TH1D("hBPurityData","hBPurityData;Centrality;B-Tagging purity",nBins,centBin);
  TH1D *hBPurityMC = new TH1D("hBPurityMC","hBPurityMC;Centrality;B-Tagging purity",nBins,centBin);
  
  TH1D *hBEfficiencyMC = new TH1D("hBEfficiencyMC","hBEfficiencyMC;Centrality;B-Tagging efficiency",nBins,centBin);
  TH1D *hBEfficiencyDataLTJP = new TH1D("hBEfficiencyDataLTJP","hBEfficiencyDataLTJP;Centrality;B-Tagging efficiency",nBins,centBin);
  TH1D *hBEfficiencyDataLTCSV = new TH1D("hBEfficiencyDataLTCSV","hBEfficiencyDataLTCSV;Centrality;B-Tagging efficiency",nBins,centBin);
  
  TH1D *hBFractionMC = new TH1D("hBFractionMC","hBFractionMC;Centrality;B-jet fraction",nBins,centBin);
  TH1D *hBFractionData = new TH1D("hBFractionData","hBFractionData;Centrality;B-jet fraction",nBins,centBin);
  TH1D *hBFractionDataLTJP = new TH1D("hBFractionDataLTJP","hBFractionDataLTJP;Centrality;B-jet fraction",nBins,centBin);
  TH1D *hBFractionDataLTCSV = new TH1D("hBFractionDataLTCSV","hBFractionDataLTCSV;Centrality;B-jet fraction",nBins,centBin);
  TH1D *hBFractionJPdirect = new TH1D("hBFractionJPdirect","hBFractionJPdirect;Centrality;B-jet fraction",nBins,centBin);
  
  int ncol=1;
  int nrow=1;

  if(nBins==3||nBins==2){
    ncol=nBins;
  }
  if(nBins==4){
    ncol=nBins/2;
    nrow=nBins/2;
  }

  TCanvas *c1=new TCanvas("c1","c1",1200,600);
  //c1->Divide(ncol,nrow,0,0);
  c1->Divide(ncol,nrow);
  TCanvas *c2=new TCanvas("c2","c2",1200,600);
  //c2->Divide(ncol,nrow,0,0);
  c2->Divide(ncol,nrow);
  TCanvas *c3=new TCanvas("c3","c3",1200,600);
  //c3->Divide(ncol,nrow,0,0);
  c3->Divide(ncol,nrow);
  TCanvas *c4=new TCanvas("c4","c4",1200,600);
  //c4->Divide(ncol,nrow,0,0);
  c4->Divide(ncol,nrow);

  TCanvas *cCount = new TCanvas("cCount","cCount",600,600);

  for (int n=0;n<nBins;n++) {

    cout<<"Processing jet centrality bin ["<<centBin[n]<<","<<centBin[n+1]<<"] ..."<<endl;
    cCount->cd();
    cout<<"centBin[n]: "<<centBin[n]<<" centBin[n+1]: "<<centBin[n+1]<<" tagger: "<<tagger<<" workingPoint: "<<workingPoint<<" ptlo: "<<ptlo<<" pthi: "<<pthi<<" etalo: "<<etalo<<" etahi: "<<etahi<<endl;
    numbers = count(centBin[n],centBin[n+1],tagger,workingPoint,ptlo,pthi,etalo,etahi);
    
    c1->cd(n+1);
    c1->GetPad(n+1)->SetLogy();
    RooRealVar fitSvtxmTag = bfractionFit(fixCL,"svtxm",0,6,centBin[n],centBin[n+1],ptlo,pthi,etalo,etahi,tagger,workingPoint,6,"b-tagged sample (SSVHE > 2)",9e3);
    //RooRealVar fitSvtxmTag = bfractionFit(fixCL,"svtxm",0,6,centBin[n],centBin[n+1],ptlo,pthi,etalo,etahi,tagger,workingPoint,10,Form("b-tagged sample (%s at %.1f)",taggerName,workingPoint));
    //RooRealVar fitJpDirect = bfractionFit(fixCL,"discr_prob",0,3,centBin[n],centBin[n+1],ptlo,pthi,etalo,etahi,tagger,-2,10,"inclusive sample",5e4);
    c2->cd(n+1);
    c2->GetPad(n+1)->SetLogy();
    RooRealVar fitJpDirect = bfractionFit(fixCL,"discr_prob",0.0,3.,centBin[n],centBin[n+1],ptlo,pthi,etalo,etahi,"discr_prob",0.,3.,"inclusive sample",4e5);

    if (doLTJP) {
      c3->cd(n+1);
      c3->GetPad(n+1)->SetLogy();
      RooRealVar fitJpBeforetag = bfractionFit(fixCL,"discr_prob",0.0,3.,centBin[n],centBin[n+1],ptlo,pthi,etalo,etahi,"discr_prob",0,3.,"jets with JP info",4e5);
      c4->cd(n+1);
      c4->GetPad(n+1)->SetLogy();
      RooRealVar fitJpTag = bfractionFit(fixCL,"discr_prob",0.0,3.,centBin[n],centBin[n+1],ptlo,pthi,etalo,etahi,tagger,workingPoint,6,"b-tagged sample (SSVHE > 2)",4e5);
    } 
    if (doLTCSV) {
      RooRealVar fitCsvBeforetag = bfractionFit(fixCL,"discr_csvSimple",0,1,centBin[n],centBin[n+1],ptlo,pthi,etalo,etahi,tagger,-2,10,"jets with CSV info",4e5);
      RooRealVar fitCsvTag = bfractionFit(fixCL,"discr_csvSimple",0,1,centBin[n],centBin[n+1],ptlo,pthi,etalo,etahi,tagger,workingPoint,10,"b-tagged sample (SSVHE > 2)",4e5);
    } 

    taggedFracData = numbers.nTaggedJetsData / (numbers.nTaggedJetsData+numbers.nUntaggedJetsData);
    taggedFracDataError = fracError(numbers.nTaggedJetsData,numbers.nUntaggedJetsData,numbers.nTaggedJetsDataError,numbers.nUntaggedJetsDataError);
    
    //*  --- b-tagging purity --- 

    bPurMC = numbers.nTaggedBjetsMC / numbers.nTaggedJetsMC;
    cout<<" bPurMC "<<bPurMC<<" numbers.nTaggedBjetsMC "<<numbers.nTaggedBjetsMC<<" numbers.nTaggedJetsMC "<<numbers.nTaggedJetsMC<<endl;
    bPurMCError = fracError(numbers.nTaggedBjetsMC,numbers.nTaggedNonBjetsMC,numbers.nTaggedBjetsMCError,numbers.nTaggedNonBjetsMCError);
    bPurData = fitSvtxmTag.getVal();
    bPurDataError = fitSvtxmTag.getError();

    hBPurityMC->SetBinContent(n+1,bPurMC); 
    hBPurityMC->SetBinError(n+1,bPurMCError); 
    hBPurityData->SetBinContent(n+1,bPurData);    
    hBPurityData->SetBinError(n+1,bPurDataError); 
    //*/
    
    //*  --- b-tagging efficiency --- 

    bEffMC = numbers.nTaggedBjetsMC / numbers.nBjetsMC;
    bEffMCError = fracError(numbers.nTaggedBjetsMC,numbers.nUntaggedBjetsMC,numbers.nTaggedBjetsMCError,numbers.nUntaggedBjetsMCError);
    hBEfficiencyMC->SetBinContent(n+1,bEffMC); 
    hBEfficiencyMC->SetBinError(n+1,bEffMCError);

    if (doLTJP) {
      bEffDataLTJP = taggedFracData * numbers.cbForJP * fitJpTag.getVal() / fitJpBeforetag.getVal();
      bEffDataLTJPError = prodError(taggedFracData,fitJpTag.getVal(),taggedFracDataError,fitJpTag.getError()) * numbers.cbForJP / fitJpBeforetag.getVal(); 
      hBEfficiencyDataLTJP->SetBinContent(n+1,bEffDataLTJP);    
      hBEfficiencyDataLTJP->SetBinError(n+1,bEffDataLTJPError);
    } 

    if (doLTCSV) {
      bEffDataLTCSV = taggedFracData * numbers.cbForCSV * fitCsvTag.getVal() / fitCsvBeforetag.getVal();
      bEffDataLTCSVError = prodError(taggedFracData,fitCsvTag.getVal(),taggedFracDataError,fitCsvTag.getError()) * numbers.cbForCSV / fitCsvBeforetag.getVal(); 
      hBEfficiencyDataLTCSV->SetBinContent(n+1,bEffDataLTCSV);    
      hBEfficiencyDataLTCSV->SetBinError(n+1,bEffDataLTCSVError); 
    } 
    
    //*  --- b fraction --- 

    bFracMC = numbers.nBjetsMC / numbers.nJetsMC;
    //bFracMC = numbers.nTaggedJetsMC * bPurMC / (bEffMC * numbers.nJetsMC); // for check : same as previous
    bFracMCError = fracError(numbers.nBjetsMC,numbers.nNonBjetsMC,numbers.nBjetsMCError,numbers.nNonBjetsMCError); 
    hBFractionMC->SetBinContent(n+1,bFracMC); 
    hBFractionMC->SetBinError(n+1,bFracMCError); 


    bFracData = taggedFracData * bPurData / bEffMC; // efficiency from MC
    bFracDataError = prodError(taggedFracData,bPurData,taggedFracDataError,bPurDataError) / bEffMC; // stat.error from purity and tagged-fraction (assumed independent)
    //bFracDataError = bFracData * bPurDataError / bPurData; // stat.error only from purity
    hBFractionData->SetBinContent(n+1,bFracData);    
    hBFractionData->SetBinError(n+1,bFracDataError);

    if (doLTJP) {
      bFracDataLTJP = taggedFracData * bPurData / bEffDataLTJP ; // efficiency from LTJP method
      bFracDataLTJPError = prodError(taggedFracData,bPurData,taggedFracDataError,bPurDataError) / bEffDataLTJP; // stat.error from purity and tagged-fraction (assumed independent)
      //bFracDataLTJPError = bFracDataLTJP * bPurDataError / bPurData; // stat.error only from purity
      hBFractionDataLTJP->SetBinContent(n+1,bFracDataLTJP);    
      hBFractionDataLTJP->SetBinError(n+1,bFracDataLTJPError);
    } 

    if (doLTCSV) {
      bFracDataLTCSV = taggedFracData * bPurData / bEffDataLTCSV; // efficiency from LTCSV method
      bFracDataLTCSVError = prodError(taggedFracData,bPurData,taggedFracDataError,bPurDataError) / bEffDataLTCSV; // stat.error from purity and tagged-fraction (assumed independent)
      //bFracDataLTCSVError = bFracDataLTCSV * bPurDataError / bPurData; // stat.error only from purity
      hBFractionDataLTCSV->SetBinContent(n+1,bFracDataLTCSV);    
      hBFractionDataLTCSV->SetBinError(n+1,bFracDataLTCSVError);
    } 

    bFracJPdirect = fitJpDirect.getVal();
    bFracJPdirectError = fitJpDirect.getError();
    hBFractionJPdirect->SetBinContent(n+1,bFracJPdirect);   
    hBFractionJPdirect->SetBinError(n+1,bFracJPdirectError);
    //*/

    //*
    cout<<"nTaggedJetsMC "<<numbers.nTaggedJetsMC<<endl;
    cout<<"nUntaggedJetsMC "<<numbers.nUntaggedJetsMC<<endl;
    cout<<"nJetsMC "<<numbers.nJetsMC<<endl;
    cout<<"nTaggedBjetsMC "<<numbers.nTaggedBjetsMC<<endl;
    cout<<"nUntaggedBjetsMC "<<numbers.nUntaggedBjetsMC<<endl;
    cout<<"nBjetsMC "<<numbers.nBjetsMC<<endl;
    cout<<"nNonBjetsMC "<<numbers.nNonBjetsMC<<endl;
    cout<<"nTaggedNonBjetsMC "<<numbers.nTaggedNonBjetsMC<<endl;
    cout<<"nTaggedJetsData "<<numbers.nTaggedJetsData<<endl;
    cout<<"nUntaggedJetsData "<<numbers.nUntaggedJetsData<<endl;
    cout<<"bPurMC "<<bPurMC<<endl;
    cout<<"bPurData "<<bPurData<<endl;
    cout<<"bEffMC "<<bEffMC<<endl;
    cout<<"CbForJP "<<numbers.cbForJP<<endl;
    cout<<"bEffDataLTJP "<<bEffDataLTJP<<endl;
    cout<<"CbForCSV "<<numbers.cbForCSV<<endl;
    cout<<"bEffDataLTCSV "<<bEffDataLTCSV<<endl;
    cout<<"bFracMC "<<bFracMC<<endl;
    cout<<"bFracData "<<bFracData<<endl;
    cout<<"bFracDataLTJP "<<bFracDataLTJP<<endl;
    cout<<"bFracDataLTCSV "<<bFracDataLTCSV<<endl;
    cout<<"bFracJPdirect "<<bFracJPdirect<<endl;
    cout<<endl;
    //*/
  }
  
  TLegend *legPur = new TLegend(0.4,0.15,0.85,0.3,Form("Purity of b-tagged sample (%s at %.1f)",taggerName,workingPoint));
  legPur->SetBorderSize(0);
  //legPur->SetFillColor(kGray);
  legPur->SetFillStyle(0);
  legPur->AddEntry(hBPurityMC,"MC Input","pl");
  legPur->AddEntry(hBPurityData,"Data","pl");
  TCanvas *cBPurity = new TCanvas("cBPurity","b purity",600,600);
  hBPurityMC->SetAxisRange(0,1,"Y");
  hBPurityMC->SetTitleOffset(1.3,"Y");
  hBPurityMC->SetLineColor(2);
  hBPurityMC->SetMarkerColor(2);
  hBPurityMC->SetMarkerStyle(21);
  hBPurityMC->Draw();
  hBPurityData->SetLineColor(1);
  hBPurityData->SetMarkerColor(1);
  hBPurityData->SetMarkerStyle(20);
  hBPurityData->Draw("same");   
  legPur->Draw();
  //cBPurity->SaveAs("purity.gif");

  TLegend *legEff = new TLegend(0.4,0.65,0.85,0.8,Form("Efficiency for tagging b-jets (%s at %.1f)",taggerName,workingPoint));
  legEff->SetBorderSize(0);
  //legEff->SetFillColor(kGray);
  legEff->SetFillStyle(0);
  legEff->AddEntry(hBEfficiencyMC,"MC Efficiency","pl");
  if (doLTJP) legEff->AddEntry(hBEfficiencyDataLTJP,"LT method (JP)","pl");
  if (doLTCSV) legEff->AddEntry(hBEfficiencyDataLTCSV,"LT method (CSV)","pl");
  TCanvas *cBEfficiency = new TCanvas("cBEfficiency","B-Tagging efficiency",600,600);
  hBEfficiencyMC->SetAxisRange(0,1,"Y");
  hBEfficiencyMC->SetTitleOffset(1.3,"Y");
  hBEfficiencyMC->SetLineColor(2);
  hBEfficiencyMC->SetMarkerColor(2);
  hBEfficiencyMC->SetMarkerStyle(21);
  hBEfficiencyMC->Draw();
  if (doLTJP) {
    hBEfficiencyDataLTJP->SetLineColor(8);
    hBEfficiencyDataLTJP->SetMarkerColor(8);
    hBEfficiencyDataLTJP->SetMarkerStyle(20);
    hBEfficiencyDataLTJP->Draw("same");
  }
  if (doLTCSV) {
    hBEfficiencyDataLTCSV->SetLineColor(7);
    hBEfficiencyDataLTCSV->SetMarkerColor(7);
    hBEfficiencyDataLTCSV->SetMarkerStyle(20);
    hBEfficiencyDataLTCSV->Draw("same");
  }
  legEff->Draw();
  //cBEfficiency->SaveAs("efficiency.gif");


  TLegend *legFrac = new TLegend(0.25,0.15,0.85,0.3);
  legFrac->SetBorderSize(0);
  //legFrac->SetFillColor(kGray);
  legFrac->SetFillStyle(0);
  legFrac->AddEntry(hBFractionMC,"MC Input","pl");
  legFrac->AddEntry(hBFractionData,Form("%s at %.1f + pur. from SV mass + eff. from MC",taggerName,workingPoint),"pl");
  if (doLTJP) legFrac->AddEntry(hBFractionDataLTJP,Form("%s at %.1f + pur. from SV mass + eff. from LT (JP)",taggerName,workingPoint),"pl");
  if (doLTCSV) legFrac->AddEntry(hBFractionDataLTCSV,Form("%s at %.1f + pur. from SV mass + eff. from LT (CSV)",taggerName,workingPoint),"pl");
  legFrac->AddEntry(hBFractionJPdirect,"Direct fit to JP","pl");
  TCanvas *cBFraction = new TCanvas("cBFraction","B-jet fraction",600,600);
  hBFractionMC->SetAxisRange(0,0.03,"Y");
  hBFractionMC->SetTitleOffset(1.8,"Y");
  hBFractionMC->SetLineColor(2);
  hBFractionMC->SetMarkerColor(2);
  hBFractionMC->SetMarkerStyle(21);
  hBFractionMC->Draw(); 
  hBFractionData->SetLineColor(1);
  hBFractionData->SetMarkerColor(1);
  hBFractionData->SetMarkerStyle(20);
  hBFractionData->Draw("same");   
  if (doLTJP) {
    hBFractionDataLTJP->SetLineColor(8);
    hBFractionDataLTJP->SetMarkerColor(8);
    hBFractionDataLTJP->SetMarkerStyle(20);
    hBFractionDataLTJP->Draw("same");
  }
  if (doLTCSV) {
    hBFractionDataLTCSV->SetLineColor(7);
    hBFractionDataLTCSV->SetMarkerColor(7);
    hBFractionDataLTCSV->SetMarkerStyle(20);
    hBFractionDataLTCSV->Draw("same");
  }
  hBFractionJPdirect->SetLineColor(4);
  hBFractionJPdirect->SetMarkerColor(4);
  hBFractionJPdirect->SetMarkerStyle(20);
  hBFractionJPdirect->Draw("same");
  legFrac->Draw();
  //cBFraction->SaveAs("bfraction.gif");


  TFile *fout = new TFile(Form("output/bFractionMerged_%sat%.1fFixCL%d_centDep.root",taggerName,workingPoint,fixCL),"recreate");
  hBFractionMC->Write();
  hBFractionData->Write();
  if (doLTJP) hBFractionDataLTJP->Write();
  if (doLTCSV) hBFractionDataLTCSV->Write();
  hBFractionJPdirect->Write();
  fout->Close();

  //c1->SaveAs(Form("gifs/svtxMassFit_%s.gif",fixCL?"CLfixed":"CLfree"));
  //c2->SaveAs(Form("gifs/jpDirectFit_%s.gif",fixCL?"CLfixed":"CLfree"));
  //c3->SaveAs(Form("gifs/jpBeforeTag_%s.gif",fixCL?"CLfixed":"CLfree"));
  //c4->SaveAs(Form("gifs/jpAfterTag_%s.gif",fixCL?"CLfixed":"CLfree"));


}
Example #5
0
void compIsol(int varnum)
{
  TString varname, vartitle;
  if(varnum==1) {
    varname="hHEIsoPt";
    vartitle="H/E Isolation";
  }
  if(varnum==2) {
    varname="hHcalIsoPt";
    vartitle="HCAL Isolation";
  }
  if(varnum==3) {
    varname="hEcalIsoPt";
    vartitle="ECAL Isolation";
  }
  if(varnum==4) {
    varname="hTrkIsoPt";
    vartitle="Track Isolation";
  }
  if(varnum==5) {
    varname="hJetEt";
    vartitle="Jet E_{T} [GeV]";
  }
  if(varnum==6) {
    varname="hNJets";
    vartitle="Number of Jets";
  }
  
  
  TH1D* hBorn;
  TH1D* hADD;
  if(varnum<=4) {
    TH2D* hBorn2d = dynamic_cast<TH2D*>(GetPlot(1, varname));
    TH2D* hADD2d = dynamic_cast<TH2D*>(GetPlot(3, varname));
    hBorn = hBorn2d->ProjectionX(varname+"born");
    hADD = hADD2d->ProjectionX(varname+"add");
    cout << "asdf" << endl;
  } else {
    hBorn = dynamic_cast<TH1D*>(GetPlot(1, varname));
    hADD = dynamic_cast<TH1D*>(GetPlot(3, varname));
  }
  
  hBorn->Scale(1/hBorn->GetSumOfWeights());
  hADD->Scale(1/hADD->GetSumOfWeights());

  hBorn->SetLineColor(kBlue+2);
  hADD->SetLineColor(kCyan+4);
  hBorn->SetFillColor(0);
  hADD->SetFillColor(0);
  hBorn->SetLineStyle(1);
  hADD->SetLineStyle(2);
  
  //  hBorn->SetStats(0);
  //  hADD->SetStats(0);

  gPad->SetLogy(1);
  
  hBorn->GetXaxis()->SetTitle(vartitle);
  hBorn->GetYaxis()->SetTitle("Normalized Units");
  hBorn->SetTitle("Leading Photons in Pythia/Sherpa Samples");

  hBorn->Draw();
  hADD->Draw("sames");

  hBorn->SetMaximum(1);

  gPad->Update();
  TPaveStats *st1=(TPaveStats*)hBorn->GetListOfFunctions()->FindObject("stats");
  TPaveStats *st2=(TPaveStats*)hADD->GetListOfFunctions()->FindObject("stats");
  st1->SetName("Born");
  st2->SetName("ADD");
  st1->SetOptStat(101100);
  st2->SetOptStat(101100);
  st1->SetX1NDC(.25);
  st1->SetX2NDC(.55);
  st1->SetY1NDC(.56);
  st1->SetY2NDC(.80);
  st2->SetX1NDC(.56);
  st2->SetX2NDC(.86);
  st2->SetY1NDC(.56);
  st2->SetY2NDC(.80);

  TLegend* leg=new TLegend(.25,.78,.55,.85);
  leg->AddEntry(hBorn, "Pythia (Born)", "l");
  leg->SetBorderSize(0);
  leg->SetFillColor(0);
  leg->SetTextSize(0.045);
  leg->Draw();

  TLegend* leg=new TLegend(.56,.78,.86,.85);
  leg->AddEntry(hADD, "Sherpa (ADD)", "l");
  leg->SetBorderSize(0);
  leg->SetFillColor(0);
  leg->SetTextSize(0.045);
  leg->Draw();

  gPad->Update();
  

  return;
}
Example #6
0
TH1D* readData(TString dataset, TString name, TString wavel, Double_t peak1, Double_t peak2, Double_t intTime, Double_t shift){

    TString fileName = "./Data/" + dataset + ".txt";

    Double_t histoMin = 99999, histoMax = 0;

    ifstream ifs(fileName); if(!ifs.is_open()){cout << "Error. File " << fileName << " not found. Exiting...\n"; return NULL;}

    Double_t entry, wavelength, photons, stepsize;
    
    while(ifs >> entry >> wavelength >> photons){

        if(entry == 1) stepsize = wavelength;
        else if(entry == 2) stepsize = wavelength - stepsize;
        
        if(wavelength < histoMin) histoMin = wavelength;
        if(wavelength > histoMax) histoMax = wavelength;

    }

    ifs.close();

    TH1D *histo = new TH1D(name + wavel + TString::Format(" %1.2f", shift), name + wavel + TString::Format(" %1.2f", shift), Nint(entry), histoMin + shift - stepsize/2.0, histoMax + shift + stepsize/2.0);


    ifs.open(fileName); if(!ifs.is_open()){cout << "Error. File " << fileName << " not found. Exiting...\n"; return NULL;}
    
    while(ifs >> entry >> wavelength >> photons){
        
        for(Int_t x = 0; x< photons/(1000.0/intTime); x++){
            histo->Fill(wavelength + shift);
        }

    }

    ifs.close();

    TF1 *f;
    if(peak2 == 0.){
        f = new TF1("fit", "[0]+[1]*TMath::Voigt(x-[2],[3],[4])");
        f->SetParameter(0, histo->GetMinimum());
        f->SetParameter(1, histo->GetMaximum()/25.);
        f->SetParameter(2, peak1 + shift);
        f->SetParameter(3, .02);
        f->SetParameter(4, .02);
        f->SetParName(0, "Offset");
        f->SetParName(1, "Normalization");
        f->SetParName(2, "Mean");
        f->SetParName(3, "Sigma");
        f->SetParName(4, "Gamma");
    }
    else{
        f = new TF1("fit", "[0]+[1]*TMath::Voigt(x-[2],[3],[4])+[5]*TMath::Voigt(x-[6],[7],[8])");
        f->SetParameter(0, histo->GetMinimum());
        f->SetParameter(1, histo->GetMaximum()/20.);
        f->SetParameter(2, peak1+shift-0.1);
        f->SetParameter(3, .02);
        f->SetParameter(4, .02);
        f->SetParameter(5, histo->GetMaximum()/20.);
        f->SetParameter(6, peak2+shift+0.1);
        f->SetParameter(7, .02);
        f->SetParameter(8, .02);
        f->SetParName(0, "Offset");
        f->SetParName(1, "Normalization 1");
        f->SetParName(2, "Mean 1");
        f->SetParName(3, "Sigma 1");
        f->SetParName(4, "Gamma 1");
        f->SetParName(5, "Normalization 2");
        f->SetParName(6, "Mean 2");
        f->SetParName(7, "Sigma 2");
        f->SetParName(8, "Gamma 2");
    }

    histo->SetLineWidth(2);
    histo->SetMarkerStyle(20);
    histo->SetMarkerSize(1.5);
    histo->SetMarkerColor(kRed);
    histo->SetLineColor(kBlack);
    histo->GetXaxis()->SetTitle("Wavelength (#AA)");
    histo->GetXaxis()->CenterTitle();
    histo->GetXaxis()->SetTitleSize(0.045);
    histo->GetXaxis()->SetTitleOffset(1.00);
    histo->GetXaxis()->SetLabelOffset(0.010);
    histo->GetXaxis()->SetLabelSize(0.045);
    histo->GetYaxis()->SetTitle("Photon count");
    histo->GetYaxis()->CenterTitle();
    histo->GetYaxis()->SetTitleSize(0.050);
    histo->GetYaxis()->SetTitleOffset(0.95);
    histo->GetYaxis()->SetLabelSize(0.045);
    gStyle->SetTitleSize(0.070, "t");
    if(peak2 == 0.) histo->SetTitle(name + TString::Format(" %4.2f #AA", f->GetParameter(2)));
    else histo->SetTitle(name + TString::Format(" %4.2f / %4.2f #AA", f->GetParameter(2), f->GetParameter(6)));
    //histo->SetTitle("Sodium 5890.522 / 5890.567 #AA");
    cout << shift << endl;

    f->SetLineColor(kBlue);
    f->SetLineWidth(4);
    cout << "Fitting " << name << endl;
    histo->Fit(f, "ME");

    return histo;

}
Example #7
0
void MuScale() {

    //--------------------------------------------------------------------------------------------------------------
    // Settings
    //==============================================================================================================

    // event category enumeration
    enum { eMuMu2HLT=1, eMuMu1HLT1L1, eMuMu1HLT, eMuMuNoSel, eMuSta, eMuTrk };  // event category enum

    TString outputDir = "MuScaleResults";

    vector<TString> infilenamev;
    infilenamev.push_back("/afs/cern.ch/work/c/cmedlock/public/wz-ntuples/Zmumu/ntuples/data_select.trkCuts.root"); // data
    infilenamev.push_back("/afs/cern.ch/work/c/cmedlock/public/wz-ntuples/Zmumu/ntuples/zmm_select.raw.trkCuts.root");  // MC

    const Double_t MASS_LOW  = 60;
    const Double_t MASS_HIGH = 120;
    const Double_t PT_CUT    = 25;
    const Double_t ETA_CUT   = 2.4;
    const Double_t MU_MASS   = 0.105658369;

    vector<pair<Double_t,Double_t> > scEta_limits;
    scEta_limits.push_back(make_pair(0.0,1.2));
    scEta_limits.push_back(make_pair(1.2,2.1));
    scEta_limits.push_back(make_pair(2.1,2.4));

    CPlot::sOutDir = outputDir;

    const TString format("png");

    //--------------------------------------------------------------------------------------------------------------
    // Main analysis code
    //==============================================================================================================

    enum { eData=0, eMC };

    char hname[100];
    vector<TH1D*> hMCv, hDatav;
    for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
        for(UInt_t jbin=ibin; jbin<scEta_limits.size(); jbin++) {
            sprintf(hname,"mc_%i_%i",ibin,jbin);
            hMCv.push_back(new TH1D(hname,"",80,MASS_LOW,MASS_HIGH));
            hMCv.back()->Sumw2();

            sprintf(hname,"data_%i_%i",ibin,jbin);
            hDatav.push_back(new TH1D(hname,"",80,MASS_LOW,MASS_HIGH));
            hDatav.back()->Sumw2();
        }
    }

    //
    // Declare output ntuple variables
    //
    UInt_t  runNum, lumiSec, evtNum;
    Float_t scale1fb, puWeight;
    UInt_t  matchGen;
    UInt_t  category;
    UInt_t  npv, npu;
    Int_t   q1, q2;
    TLorentzVector *dilep=0, *lep1=0, *lep2=0;

    for(UInt_t ifile=0; ifile<infilenamev.size(); ifile++) {
        cout << "Processing " << infilenamev[ifile] << "..." << endl;
        TFile *infile = TFile::Open(infilenamev[ifile]);
        assert(infile);
        TTree *intree = (TTree*)infile->Get("Events");
        assert(intree);

        intree->SetBranchAddress("runNum",   &runNum);    // event run number
        intree->SetBranchAddress("lumiSec",  &lumiSec);   // event lumi section
        intree->SetBranchAddress("evtNum",   &evtNum);    // event number
        intree->SetBranchAddress("scale1fb", &scale1fb);  // event weight
        intree->SetBranchAddress("puWeight", &puWeight);  // pileup reweighting
        intree->SetBranchAddress("matchGen", &matchGen);  // event has both leptons matched to MC Z->ll
        intree->SetBranchAddress("category", &category);  // dilepton category
        intree->SetBranchAddress("npv",      &npv);	      // number of primary vertices
        intree->SetBranchAddress("npu",      &npu);	      // number of in-time PU events (MC)
        intree->SetBranchAddress("q1",       &q1);	      // charge of lead lepton
        intree->SetBranchAddress("q2",       &q2);	      // charge of trail lepton
        intree->SetBranchAddress("dilep",    &dilep);     // dilepton 4-vector
        intree->SetBranchAddress("lep1",     &lep1);      // lead lepton 4-vector
        intree->SetBranchAddress("lep2",     &lep2);      // trail lepton 4-vector

        for(UInt_t ientry=0; ientry<intree->GetEntries(); ientry++) {
            intree->GetEntry(ientry);

            Double_t weight = 1;
            if(ifile==eMC) {
                //if(!matchGen) continue;
                weight=scale1fb*puWeight*1.1*TMath::Power(10,7)/5610.0;
            }

            if((category!=eMuMu2HLT) && (category!=eMuMu1HLT) && (category!=eMuMu1HLT1L1)) continue;
            if(q1 == q2) continue;
            if(dilep->M()	   < MASS_LOW)  continue;
            if(dilep->M()	   > MASS_HIGH) continue;
            if(lep1->Pt()	   < PT_CUT)    continue;
            if(lep2->Pt()	   < PT_CUT)    continue;
            if(fabs(lep1->Eta()) > ETA_CUT)   continue;
            if(fabs(lep2->Eta()) > ETA_CUT)   continue;

            TLorentzVector vLep1(0,0,0,0);
            TLorentzVector vLep2(0,0,0,0);

            vLep1.SetPtEtaPhiM(lep1->Pt(), lep1->Eta(), lep1->Phi(), MU_MASS);
            vLep2.SetPtEtaPhiM(lep2->Pt(), lep2->Eta(), lep2->Phi(), MU_MASS);

            TLorentzVector vDilep = vLep1 + vLep2;

            Int_t bin1=-1, bin2=-1;
            for(UInt_t i=0; i<scEta_limits.size(); i++) {
                Double_t etalow  = scEta_limits.at(i).first;
                Double_t etahigh = scEta_limits.at(i).second;
                if(fabs(lep1->Eta())>=etalow && fabs(lep1->Eta())<=etahigh) bin1=i;
                if(fabs(lep2->Eta())>=etalow && fabs(lep2->Eta())<=etahigh) bin2=i;
            }
            assert(bin1>=0);
            assert(bin2>=0);
            Int_t ibin= (bin1<=bin2) ? bin1 : bin2;
            Int_t jbin= (bin1<=bin2) ? bin2 : bin1;

            UInt_t n=jbin-ibin;
            for(Int_t k=0; k<ibin; k++)
                n+=(scEta_limits.size()-k);

            if(ifile==eData) hDatav[n]->Fill(vDilep.M(),weight);
            if(ifile==eMC)   hMCv[n]->Fill(vDilep.M(),weight);
        }

        delete infile;
        infile=0, intree=0;
    }

    //
    // Fit for energy scale and resolution corrections
    //
    char vname[100];  // buffer for RooFit object names

    char pname[100];
    char str1[100];
    char str2[100];
    TCanvas *c = MakeCanvas("c","c",800,600);

    // Dummy histograms for TLegend (I can't figure out how to properly pass RooFit objects...)
    TH1D *hDummyData = new TH1D("hDummyData","",0,0,10);
    hDummyData->SetMarkerStyle(kFullCircle);
    hDummyData->SetMarkerSize(0.9);
    TH1D *hDummyMC = new TH1D("hDummyMC","",0,0,10);
    hDummyMC->SetLineColor(kBlue);
    hDummyMC->SetFillColor(kBlue);
    hDummyMC->SetFillStyle(3002);
    TH1D *hDummyFit = new TH1D("hDummyFit","",0,0,10);
    hDummyFit->SetLineColor(kGreen+2);

    RooRealVar mass("mass","M_{#mu#mu}",60.0,120.0,"GeV") ;
    mass.setBins(1600,"cache");

    RooRealVar massmc("massmc","massmc",0.0,150.0,"GeV");  // mass variable for building MC template

    RooCategory zscEta_cat("zscEta_cat","zscEta_cat");
    RooSimultaneous combscalefit("combscalefit","combscalefit",zscEta_cat);

    map<string,TH1*> hmap;  // Mapping of category labels and data histograms

    RooArgList scalebins;   // List of RooRealVars storing per bin energy scale corrections
    RooArgList sigmabins;   // List of RooRealVars storing per bin energy resolution corrections
    Int_t intOrder = 1;     // Interpolation order for
    for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
        sprintf(vname,"scale_%i",ibin);
        RooRealVar *scalebinned = new RooRealVar(vname,vname,1.0,0.5,1.5);
        scalebins.add(*scalebinned);

        sprintf(vname,"sigma_%i",ibin);
        RooRealVar *sigmabinned = new RooRealVar(vname,vname,1.0,0.0,2.0);
        sigmabins.add(*sigmabinned);
    }

    for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
        for(UInt_t jbin=ibin; jbin<scEta_limits.size(); jbin++) {
            UInt_t n=jbin-ibin;
            for(UInt_t k=0; k<ibin; k++)
                n+=(scEta_limits.size()-k);

            sprintf(vname,"masslinearshifted_%i_%i",ibin,jbin);
            RooFormulaVar *masslinearshifted = new RooFormulaVar(vname,vname,"sqrt(@0*@1)",RooArgList(*scalebins.at(ibin),*scalebins.at(jbin)));

            sprintf(vname,"massshiftedscEta_%i_%i",ibin,jbin);
            RooLinearVar *massshiftedscEta = new RooLinearVar(vname,vname,mass,*masslinearshifted,RooConst(0.0));

            // MC-based template
            sprintf(vname,"zmassmcscEta_%i_%i",ibin,jbin);
            RooDataHist *zmassmcscEta = new RooDataHist(vname,vname,RooArgList(massmc),hMCv[n]);
            sprintf(vname,"masstemplatescEta_%i_%i",ibin,jbin);
            RooHistPdf *masstemplatescEta = new RooHistPdf(vname,vname,RooArgList(*massshiftedscEta),RooArgList(massmc),*zmassmcscEta,intOrder);

            // Gaussian smearing function
            sprintf(vname,"sigmascEta_%i_%i",ibin,jbin);
            RooFormulaVar *sigmascEta = new RooFormulaVar(vname,vname,"sqrt(@0*@[email protected]*@1)",RooArgList(*sigmabins.at(ibin),*sigmabins.at(jbin)));
            sprintf(vname,"resscEta_%i_%i",ibin,jbin);
            RooGaussian *resscEta = new RooGaussian(vname,vname,mass,RooConst(0.),*sigmascEta);

            // Fit model: MC-template convoluted with Gaussian
            sprintf(vname,"fftscEta_%i_%i",ibin,jbin);
            RooFFTConvPdf *fftscEta = new RooFFTConvPdf(vname,vname,mass,*masstemplatescEta,*resscEta);
            fftscEta->setBufferStrategy(RooFFTConvPdf::Flat);

            // Add bin as a category
            char zscEta_catname[100];
            sprintf(zscEta_catname,"zscEta_cat_%i_%i",ibin,jbin);
            zscEta_cat.defineType(zscEta_catname);
            zscEta_cat.setLabel(zscEta_catname);
            hmap.insert(pair<string,TH1*>(zscEta_catname,hDatav[n]));
            combscalefit.addPdf(*fftscEta,zscEta_catname);
        }
    }

    // perform fit
    RooDataHist zdatascEta_comb("zdatascEta_comb","zdatascEta_comb",RooArgList(mass),zscEta_cat,hmap,1.0);
    combscalefit.fitTo(zdatascEta_comb,PrintEvalErrors(kFALSE),Minos(kFALSE),Strategy(0),Minimizer("Minuit2",""));

    Double_t xval[scEta_limits.size()];
    Double_t xerr[scEta_limits.size()];
    Double_t scaleDatatoMC[scEta_limits.size()];
    Double_t scaleDatatoMCerr[scEta_limits.size()];
    Double_t scaleMCtoData[scEta_limits.size()];
    Double_t scaleMCtoDataerr[scEta_limits.size()];
    Double_t sigmaMCtoData[scEta_limits.size()];
    Double_t sigmaMCtoDataerr[scEta_limits.size()];

    for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
        Double_t etalow  = scEta_limits.at(ibin).first;
        Double_t etahigh = scEta_limits.at(ibin).second;

        xval[ibin] = 0.5*(etahigh+etalow);
        xerr[ibin] = 0.5*(etahigh-etalow);

        scaleDatatoMC[ibin]    = ((RooRealVar*)scalebins.at(ibin))->getVal();
        scaleDatatoMCerr[ibin] = ((RooRealVar*)scalebins.at(ibin))->getError();

        scaleMCtoData[ibin]    = 1.0/scaleDatatoMC[ibin];
        scaleMCtoDataerr[ibin] = scaleDatatoMCerr[ibin]/scaleDatatoMC[ibin]/scaleDatatoMC[ibin];

        sigmaMCtoData[ibin]    = ((RooRealVar*)sigmabins.at(ibin))->getVal();
        sigmaMCtoDataerr[ibin] = ((RooRealVar*)sigmabins.at(ibin))->getError();
    }
    TGraphErrors *grScaleDatatoMC = new TGraphErrors(scEta_limits.size(),xval,scaleDatatoMC,xerr,scaleDatatoMCerr);
    TGraphErrors *grScaleMCtoData = new TGraphErrors(scEta_limits.size(),xval,scaleMCtoData,xerr,scaleMCtoDataerr);
    TGraphErrors *grSigmaMCtoData = new TGraphErrors(scEta_limits.size(),xval,sigmaMCtoData,xerr,sigmaMCtoDataerr);

    CPlot plotScale1("mu_scale_datatomc","","Muon |#eta|","Data scale correction");
    plotScale1.AddGraph(grScaleDatatoMC,"",kBlue);
    plotScale1.SetYRange(0.98,1.02);
    plotScale1.AddLine(0,1,2.5,1,kBlack,7);
    plotScale1.Draw(c,kTRUE,format);

    CPlot plotScale2("mu_scale_mctodata","","Muon |#eta|","MC#rightarrowData scale correction");
    plotScale2.AddGraph(grScaleMCtoData,"",kBlue);
    plotScale2.SetYRange(0.98,1.02);
    plotScale2.AddLine(0,1,2.5,1,kBlack,7);
    plotScale2.Draw(c,kTRUE,format);

    CPlot plotRes("mu_res_mctodata","","Muon |#eta|","MC#rightarrowData additional smear [GeV]");
    plotRes.AddGraph(grSigmaMCtoData,"",kBlue);
    plotRes.SetYRange(0,1.6);
    plotRes.Draw(c,kTRUE,format);

    double nData=0;

    for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
        for(UInt_t jbin=ibin; jbin<scEta_limits.size(); jbin++) {
            UInt_t n=jbin-ibin;
            for(UInt_t k=0; k<ibin; k++)
                n+=(scEta_limits.size()-k);

            // Post-fit plot
            RooPlot *frame = mass.frame();
            char catname[100];
            sprintf(catname,"zscEta_cat_%i_%i",ibin,jbin);
            char cutstr[100];
            sprintf(cutstr,"zscEta_cat==zscEta_cat::%s",catname);
            RooDataHist zmc(catname,catname,RooArgList(mass),hMCv[n]);
            RooHistPdf mctemplate(catname,catname,RooArgList(mass),zmc,intOrder);
            //mctemplate.plotOn(frame,LineColor(kBlue),LineWidth(1),Normalization(hDatav[n]->GetEntries()));
            mctemplate.plotOn(frame,LineColor(kBlue),LineWidth(1),Normalization(hDatav[n]->Integral()));
            //mctemplate.plotOn(frame,LineColor(kBlue),FillColor(kBlue),FillStyle(3002),DrawOption("F"),Normalization(hDatav[n]->GetEntries()));
            mctemplate.plotOn(frame,LineColor(kBlue),FillColor(kBlue),FillStyle(3002),DrawOption("F"),Normalization(hDatav[n]->Integral()));
            zdatascEta_comb.plotOn(frame,Cut(cutstr),MarkerStyle(kFullCircle),MarkerSize(1.0),DrawOption("ZP"));
            combscalefit.plotOn(frame,Slice(zscEta_cat,catname),ProjWData(RooArgSet(mass,catname),zdatascEta_comb),
                                LineColor(kGreen+2));
            sprintf(pname,"postfit_%i_%i",ibin,jbin);
            sprintf(str1,"[%.1f, %.1f]",scEta_limits.at(ibin).first,scEta_limits.at(ibin).second);
            sprintf(str2,"[%.1f, %.1f]",scEta_limits.at(jbin).first,scEta_limits.at(jbin).second);
            CPlot plot(pname,frame,"","m(#mu^{+}#mu^{-}) [GeV/c^{2}]","Events / 0.6 GeV/c^{2}");
            plot.AddTextBox(str1,0.21,0.80,0.45,0.87,0,kBlack,-1);
            plot.AddTextBox(str2,0.21,0.73,0.45,0.80,0,kBlack,-1);
            plot.SetLegend(0.75,0.64,0.93,0.88);
            plot.GetLegend()->AddEntry(hDummyData,"Data","PL");
            plot.GetLegend()->AddEntry(hDummyMC,"Sim","FL");
            plot.GetLegend()->AddEntry(hDummyFit,"Fit","L");
            plot.Draw(c,kTRUE,format);

            nData += hDatav[n]->Integral();
        }
    }

    cout<<"nData = "<<nData<<endl;
    //--------------------------------------------------------------------------------------------------------------
    // Output
    //==============================================================================================================

    cout << "*" << endl;
    cout << "* SUMMARY" << endl;
    cout << "*--------------------------------------------------" << endl;
    cout << endl;

    ofstream txtfile;
    char txtfname[100];
    sprintf(txtfname,"%s/summary.txt",outputDir.Data());
    txtfile.open(txtfname);
    assert(txtfile.is_open());
    txtfile << "  Data->MC scale correction" << endl;
    for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
        Double_t etalow  = scEta_limits.at(ibin).first;
        Double_t etahigh = scEta_limits.at(ibin).second;
        txtfile << "$" << etalow << " < |\\eta| < " << etahigh << "$ & ";
        txtfile << "$" << ((RooRealVar*)scalebins.at(ibin))->getVal() << "$ \\pm $" << ((RooRealVar*)scalebins.at(ibin))->getError() << "$ \\\\" << endl;
    }
    txtfile << endl;
    txtfile << "  MC->Data resolution correction [GeV]" << endl;
    for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
        Double_t etalow  = scEta_limits.at(ibin).first;
        Double_t etahigh = scEta_limits.at(ibin).second;
        txtfile << etalow << " < |\\eta| < " << etahigh << " & ";
        txtfile << "$" << ((RooRealVar*)sigmabins.at(ibin))->getVal() << "$ \\pm $" << ((RooRealVar*)sigmabins.at(ibin))->getError() << "$ \\\\" << endl;
    }
    txtfile.close();

    cout << endl;
    cout << "  <> Output saved in " << outputDir << "/" << endl;
    cout << endl;

}
Example #8
0
TH1D *
GetTPCTOFRatio(TFile *file, Int_t num, Int_t den, Int_t cent, Bool_t cutSpectrum = kTRUE)
{
  /* pt limits for combined spectra */
  Double_t ptMin_[9] = {
    0.0, 0.0, 0.0, 
    0., 0., 0., 
    0.5, 0.5, 0.5
  };
  Double_t ptMax_[9] = {
    1.2, 1.2, 1.2, 
    1.2, 1.2, 1.2, 
    1.8, 1.8, 1.8
  };

  Double_t ptMin = TMath::Max(ptMin_[num], ptMin_[den]);
  Double_t ptMax = TMath::Min(ptMax_[num], ptMax_[den]);

  Int_t part = 0, charge = 0;
  if (num == kPiMinus && den == kPiPlus) {
    part = AliPID::kPion;
    charge = 1;
  }
  else if (num == kKaMinus && den == kKaPlus) {
    part = AliPID::kKaon;
    charge = 1;
  }
  else if (num == kPrMinus && den == kPrPlus) {
    part = AliPID::kProton;
    charge = 1;
  }
  else if (num == kKaMinus && den == kPiMinus) {
    part = AliPID::kKaon;
    charge = 1;
  }
  else if (num == kKaPlus && den == kPiPlus) {
    part = AliPID::kKaon;
    charge = 0;
  }
  else if (num == kPrMinus && den == kPiMinus) {
    part = AliPID::kProton;
    charge = 1;
  }
  else if (num == kPrPlus && den == kPiPlus) {
    part = AliPID::kProton;
    charge = 0;
  }

  TH1D *hin = (TH1D *)file->Get(Form("%sFinal%s%d", TPCTOFPartName[part], TPCTOFChargeName[charge], cent));
  if (!hin) return NULL;

  TH1D *h = new TH1D(Form("hTPCTOF_cent%d_%s_%s", cent, ratioName[num], ratioName[den]), "TPCTOF", NptBins, ptBin);
  Double_t pt, width, value, error;
  Int_t bin;
  for (Int_t ipt = 0; ipt < NptBins; ipt++) {
    /* get input bin */
    pt = h->GetBinCenter(ipt + 1);
    width = h->GetBinWidth(ipt + 1);
    bin = hin->FindBin(pt);
    /* sanity check */
    if (TMath::Abs(hin->GetBinCenter(bin) - pt) > 0.001 ||
	TMath::Abs(hin->GetBinWidth(bin) - width) > 0.001)
      continue;
    /* check pt limits */
    if (cutSpectrum && (pt < ptMin || pt > ptMax)) continue;
    /* copy bin */
    value = hin->GetBinContent(bin);
    error = hin->GetBinError(bin);
    h->SetBinContent(ipt + 1, value);
    h->SetBinError(ipt + 1, error);
  }
  
  h->SetTitle("TPCTOF");
  h->SetLineWidth(1);
  h->SetLineColor(1);
  h->SetMarkerStyle(22);
  h->SetMarkerColor(8);
  h->SetFillStyle(0);
  h->SetFillColor(0);
  
  return h;
}
Example #9
0
TH1D *
GetTOFRatio(TFile *file, Int_t num, Int_t den, Int_t cent, Bool_t cutSpectrum = kTRUE)
{
  /* pt limits for combined spectra */
  Double_t ptMin_[9] = {
    0.5, 0.5, 0.5, 
    0.45, 0.45, 0.45, 
    0.5, 0.5, 0.5
  };
  Double_t ptMax_[9] = {
    3.0, 3.0, 3.0, 
    3.0, 3.0, 3.0, 
    4.5, 4.5, 4.5
  };

  Double_t ptMin = TMath::Max(ptMin_[num], ptMin_[den]);
  Double_t ptMax = TMath::Min(ptMax_[num], ptMax_[den]);
  
  TH1D *hin = (TH1D *)file->Get(Form("hRatio_cent%d_%s_%s", cent, ratioName[num], ratioName[den]));
  if (!hin) return NULL;


#if 0
  /* get matching systematics */
  TFile *fsys = TFile::Open(Form("MATCHSYS_TOF_%s.root", TOFChargeName[charge]));
  TH1 *hsys = fsys->Get(Form("hErr%sMatch", ITSsaPartName[part]));
  TF1 *ffsys = new TF1("fsys", "[0] + [1] * x + [2] * TMath::Exp(-[3] * x)");
  ffsys->SetParameter(0, 0.02);
  ffsys->FixParameter(1, 0.);
  ffsys->SetParameter(2, 0.5);
  ffsys->SetParameter(3, 10.);
  hsys->Fit(ffsys, "W");
  ffsys->ReleaseParameter(1);
  hsys->Fit(ffsys, "W");
  hsys->Fit(ffsys, "W");
  hsys->Fit(ffsys, "W");
  hsys->Draw();
#endif
			
  TH1D *h = new TH1D(Form("hTOF_cent%d_%s_%s", cent, ratioName[num], ratioName[den]), "TOF", NptBins, ptBin);
  Double_t pt, width, value, error, sys;
  Int_t bin;
  for (Int_t ipt = 0; ipt < NptBins; ipt++) {
    /* get input bin */
    pt = h->GetBinCenter(ipt + 1);
    width = h->GetBinWidth(ipt + 1);
    bin = hin->FindBin(pt);
    /* sanity check */
    if (TMath::Abs(hin->GetBinCenter(bin) - pt) > 0.001 ||
	TMath::Abs(hin->GetBinWidth(bin) - width) > 0.001)
      continue;
    /* check pt limits */
    if (cutSpectrum && (pt < ptMin || pt > ptMax)) continue;
    /* copy bin */
    value = hin->GetBinContent(bin);
    error = hin->GetBinError(bin);
    /*** TEMP ADD SYS ***/
    //    sys = ffsys->Eval(pt) * value;
    //    error = TMath::Sqrt(error * error + sys * sys);
    //    h->SetBinContent(ipt + 1, value);
    //    h->SetBinError(ipt + 1, error);

    h->SetBinContent(ipt + 1, value);
    h->SetBinError(ipt + 1, error);
  }
  
  h->SetTitle("TOF");
  h->SetLineWidth(1);
  h->SetLineColor(1);
  h->SetMarkerStyle(23);
  h->SetMarkerColor(4);
  h->SetFillStyle(0);
  h->SetFillColor(0);
  return h;
}
void plotphi(int top, bool phi=kFALSE){
  if (setup("vm","","pol__")==kFALSE) return;
  gStyle->SetOptFit(1111); //pcev = 1111
  //gStyle->SetTitleW(1.5);

  int itop = top-1;
  TFile* fy = _fyexp[itop];

  int nq2wbins = fy->GetNkeys();
  TIter nextkey(fy->GetListOfKeys());
  TKey *key;
  int iq2wbin = 0;
  while (key = (TKey*)nextkey()) {
    TString Q2Wdirname = key->GetName();
    if(Q2Wdirname.EqualTo("hYW_Dir") || Q2Wdirname.EqualTo("hYW"))continue;
    cout << "Q2Wdirname = " << Q2Wdirname << endl;

    THStack* hs[10];
    TF1 *fphi = new TF1("fphi", "([0] + [1]*cos(x*TMath::DegToRad()) + [2]*cos(2*x*TMath::DegToRad()) + [3]*sin(x*TMath::DegToRad()))",0, 360);
    fphi->SetParameter(0,1);
    fphi->SetParameter(1,10);
    fphi->SetParameter(2,20);
    fphi->SetParameter(3,100);
    fphi->SetParName(0, "A");
    fphi->SetParName(1, "B");
    fphi->SetParName(2, "C");
    fphi->SetParName(3, "hPR");
    for (int i = 0; i < 10; i++)
    {
      TString hname_unp = TString::Format("%s/hPhi/Varset1/theta/hphi_%02d",Q2Wdirname.Data(),i+1);
      TString hname_pos = TString::Format("%s/hPhi_POS/Varset1/theta/hphi_%02d",Q2Wdirname.Data(),i+1);
      TString hname_neg = TString::Format("%s/hPhi_NEG/Varset1/theta/hphi_%02d",Q2Wdirname.Data(),i+1);
      cout << "hname_unp = " << hname_unp << endl;
      cout << "hname_pos = " << hname_pos << endl;
      cout << "hname_neg = " << hname_neg << endl;
      TH1D* hunp = (TH1D*)fy->Get(hname_unp);
      TH1D* hpos = (TH1D*)fy->Get(hname_pos);
      TH1D* hneg = (TH1D*)fy->Get(hname_neg);
      if (hunp==NULL || hpos==NULL || hneg==NULL) cout << "histogram not found" << endl;
      hunp->SetLineColor(kBlack);
      hpos->SetLineColor(kRed);
      hneg->SetLineColor(kBlue);
      hunp->Fit(fphi);
      hpos->Fit(fphi);
      hneg->Fit(fphi);

      //! Modify titles
      TObjArray *tarr;
      char t[100];

      TPaveText *ptunp = new TPaveText(0.0, 0.9, 1.0, 1, "NDC");
      TString tunp = hunp->GetTitle();
      tarr = tunp.Tokenize("|");
      sprintf(t, "%s:%s:%s", tarr->At(1)->GetName(), tarr->At(2)->GetName(), tarr->At(3)->GetName());
      ptunp->AddText(tarr->At(0)->GetName());
      ptunp->AddText(t);
      hunp->SetTitle("");

      TPaveText *ptpos = new TPaveText(0.0, 0.9, 1.0, 1, "NDC");
      TString tpos = hpos->GetTitle();
      tarr = tpos.Tokenize("|");
      sprintf(t, "%s:%s:%s", tarr->At(1)->GetName(), tarr->At(2)->GetName(), tarr->At(3)->GetName());
      ptpos->AddText(tarr->At(0)->GetName());
      ptpos->AddText(t);
      hpos->SetTitle("");

      TPaveText *ptneg = new TPaveText(0.0, 0.9, 1.0, 1, "NDC");
      TString tneg = hneg->GetTitle();
      tarr = tneg.Tokenize("|");
      sprintf(t, "%s:%s:%s", tarr->At(1)->GetName(), tarr->At(2)->GetName(), tarr->At(3)->GetName());
      ptneg->AddText(tarr->At(0)->GetName());
      ptneg->AddText(t);
      hneg->SetTitle("");

      //! Draw histograms
      TCanvas *c = new TCanvas(hpos->GetName(),hpos->GetName(),900, 600);
      c->Divide(3,1);
      c->cd(1);
      hunp->Draw();
      ptunp->Draw();
      c->cd(2);
      hpos->Draw();
      ptpos->Draw();
      c->cd(3);
      hneg->Draw();
      ptneg->Draw();
      TString dir = TString::Format("./polobs/top%d/%s/Varset1/theta", top, Q2Wdirname.Data());
      gSystem->mkdir(dir,1);
      c->SaveAs(TString::Format("%s/%s.png", dir.Data(), c->GetName()));
      c->Close();
      c->Delete();
    }
  }
}
Example #11
0
TH1D *
GetITSsaRatio(TFile *file, Int_t num, Int_t den, Int_t cent, Bool_t cutSpectrum = kTRUE, Bool_t addSystematicError = kTRUE)
{
  /* pt limits for combined spectra */
  //  Double_t ptMin[AliPID::kSPECIES] = {0., 0., 0.1, 0.2, 0.3};
  //  Double_t ptMax[AliPID::kSPECIES] = {0., 0., 0.6, 0.5, 0.6};

  TH1 *hnum, *hden;
  Double_t ptMin = 0., ptMax = 10.;
  switch (num) {
  case kPiMinus:
    ptMin = TMath::Min(ptMin, 0.1);
    ptMax = TMath::Min(ptMax, 0.6);
    hnum = GetITSsaSpectrum(file, AliPID::kPion, 1, cent, kFALSE, kFALSE);
    break;
  case kPiPlus:
    ptMin = TMath::Min(ptMin, 0.1);
    ptMax = TMath::Min(ptMax, 0.6);
    hnum = GetITSsaSpectrum(file, AliPID::kPion, 0, cent, kFALSE, kFALSE);
    break;
  case kPi:
    ptMin = TMath::Min(ptMin, 0.1);
    ptMax = TMath::Min(ptMax, 0.6);
    hnum = GetITSsaSpectrum(file, AliPID::kPion, 1, cent, kFALSE, kFALSE);
    hnum->Add(GetITSsaSpectrum(file, AliPID::kPion, 0, cent, kFALSE, kFALSE));
    break;
  case kKaMinus:
    ptMin = TMath::Min(ptMin, 0.2);
    ptMax = TMath::Min(ptMax, 0.5);
    hnum = GetITSsaSpectrum(file, AliPID::kKaon, 1, cent, kFALSE, kFALSE);
    break;
  case kKaPlus:
    ptMin = TMath::Min(ptMin, 0.2);
    ptMax = TMath::Min(ptMax, 0.5);
    hnum = GetITSsaSpectrum(file, AliPID::kKaon, 0, cent, kFALSE, kFALSE);
    break;
  case kKa:
    ptMin = TMath::Min(ptMin, 0.2);
    ptMax = TMath::Min(ptMax, 0.5);
    hnum = GetITSsaSpectrum(file, AliPID::kKaon, 1, cent, kFALSE, kFALSE);
    hnum->Add(GetITSsaSpectrum(file, AliPID::kKaon, 0, cent, kFALSE, kFALSE));
    break;
  case kPrMinus:
    ptMin = TMath::Min(ptMin, 0.3);
    ptMax = TMath::Min(ptMax, 0.6);
    hnum = GetITSsaSpectrum(file, AliPID::kProton, 1, cent, kFALSE, kFALSE);
    break;
  case kPrPlus:
    ptMin = TMath::Min(ptMin, 0.3);
    ptMax = TMath::Min(ptMax, 0.6);
    hnum = GetITSsaSpectrum(file, AliPID::kProton, 0, cent, kFALSE, kFALSE);
    break;
  case kPr:
    ptMin = TMath::Min(ptMin, 0.3);
    ptMax = TMath::Min(ptMax, 0.6);
    hnum = GetITSsaSpectrum(file, AliPID::kProton, 1, cent, kFALSE, kFALSE);
    hnum->Add(GetITSsaSpectrum(file, AliPID::kProton, 0, cent, kFALSE, kFALSE));
    break;
  }
  switch (den) {
  case kPiMinus:
    ptMin = TMath::Max(ptMin, 0.1);
    ptMax = TMath::Min(ptMax, 0.6);
    hden = GetITSsaSpectrum(file, AliPID::kPion, 1, cent, kFALSE, kFALSE);
    break;
  case kPiPlus:
    ptMin = TMath::Max(ptMin, 0.1);
    ptMax = TMath::Min(ptMax, 0.6);
    hden = GetITSsaSpectrum(file, AliPID::kPion, 0, cent, kFALSE, kFALSE);
    break;
  case kPi:
    ptMin = TMath::Max(ptMin, 0.1);
    ptMax = TMath::Min(ptMax, 0.6);
    hden = GetITSsaSpectrum(file, AliPID::kPion, 1, cent, kFALSE, kFALSE);
    hden->Add(GetITSsaSpectrum(file, AliPID::kPion, 0, cent, kFALSE, kFALSE));
    break;
  case kKaMinus:
    ptMin = TMath::Max(ptMin, 0.2);
    ptMax = TMath::Min(ptMax, 0.5);
    hden = GetITSsaSpectrum(file, AliPID::kKaon, 1, cent, kFALSE, kFALSE);
    break;
  case kKaPlus:
    ptMin = TMath::Max(ptMin, 0.2);
    ptMax = TMath::Min(ptMax, 0.5);
    hden = GetITSsaSpectrum(file, AliPID::kKaon, 0, cent, kFALSE, kFALSE);
    break;
  case kKa:
    ptMin = TMath::Max(ptMin, 0.2);
    ptMax = TMath::Min(ptMax, 0.5);
    hden = GetITSsaSpectrum(file, AliPID::kKaon, 1, cent, kFALSE, kFALSE);
    hden->Add(GetITSsaSpectrum(file, AliPID::kKaon, 0, cent, kFALSE, kFALSE));
    break;
  case kPrMinus:
    ptMin = TMath::Max(ptMin, 0.3);
    ptMax = TMath::Min(ptMax, 0.6);
    hden = GetITSsaSpectrum(file, AliPID::kProton, 1, cent, kFALSE, kFALSE);
    break;
  case kPrPlus:
    ptMin = TMath::Max(ptMin, 0.3);
    ptMax = TMath::Min(ptMax, 0.6);
    hden = GetITSsaSpectrum(file, AliPID::kProton, 0, cent, kFALSE, kFALSE);
    break;
  case kPr:
    ptMin = TMath::Max(ptMin, 0.3);
    ptMax = TMath::Min(ptMax, 0.6);
    hden = GetITSsaSpectrum(file, AliPID::kProton, 1, cent, kFALSE, kFALSE);
    hden->Add(GetITSsaSpectrum(file, AliPID::kProton, 0, cent, kFALSE, kFALSE));
    break;
  }

  if (!hnum || !hden) return NULL;  

  Char_t sysname[1024];
  if (num == kPiMinus && den == kPiPlus)
    sprintf(sysname, "Pi_Pos2Neg");
  else if (num == kKaMinus && den == kKaPlus)
    sprintf(sysname, "K_Pos2Neg");
  else if (num == kPrMinus && den == kPrPlus)
    sprintf(sysname, "P_Pos2Neg");
  else if ((num == kKa || num == kKaPlus || num == kKaMinus)
	   && (den == kPi || den == kPiPlus || den == kPiMinus))
    sprintf(sysname, "K2Pi");
  else if ((num == kPr || num == kPrPlus || num == kPrMinus)
	   && (den == kPi || den == kPiPlus || den == kPiMinus))
    sprintf(sysname, "P2Pi");

  TH1D *hin = (TH1D *)hnum->Clone("hin");
  hin->Divide(hden);

  /* get systematics */
  TFile *fsys = TFile::Open("RATIOSYS_ITSsa.root");
  TH1 *hsys = fsys->Get(Form("hSystTot%s", sysname));
			
  TH1D *h = new TH1D(Form("hITSsa_cent%d_%s_%s", cent, ratioName[num], ratioName[den]), "ITSsa", NptBins, ptBin);
  Double_t pt, width, value, error, sys;
  Int_t bin;
  for (Int_t ipt = 0; ipt < NptBins; ipt++) {
    /* get input bin */
    pt = h->GetBinCenter(ipt + 1);
    width = h->GetBinWidth(ipt + 1);
    bin = hin->FindBin(pt);
    /* sanity check */
    if (TMath::Abs(hin->GetBinCenter(bin) - pt) > 0.001 ||
	TMath::Abs(hin->GetBinWidth(bin) - width) > 0.001) {
      //      printf("skipping %f because of sanity checks\n", pt);
      continue;
    }
    /* check pt limits */
    if (cutSpectrum && (pt < ptMin || pt > ptMax)) {
      //      printf("skipping %f because of limits\n", pt);
      continue;
    }
    /* copy bin */
    value = hin->GetBinContent(bin);
    error = hin->GetBinError(bin);
    /*** TEMP ADD SYS ***/
    if (addSystematicError) {
      sys = hsys->GetBinContent(bin) * value;
      error = TMath::Sqrt(error * error + sys * sys);
    }
    h->SetBinContent(ipt + 1, value);
    h->SetBinError(ipt + 1, error);
  }

  h->SetTitle("ITSsa");
  h->SetLineWidth(1);
  h->SetLineColor(1);
  h->SetMarkerStyle(20);
  h->SetMarkerColor(1);
  h->SetFillStyle(0);
  h->SetFillColor(0);
  return h;
}
makeIasPredictionDataPngsFixedBins()
{
  TCanvas t("myCanvas","myCanvas",100,100,800,600);
  t.cd();
  t.SetLogy();

  for(int nom=5; nom < 19; nom+=2)
  {
    for(int etaSlice=0; etaSlice < 16; etaSlice+=2)
    {
      string histName="nom";
      histName+=intToString(nom);
      histName+="to";
      if(nom==5)
        histName+=intToString(nom+3);
      else
        histName+=intToString(nom+1);
      histName+="eta";
      histName+=intToString(etaSlice);
      histName+="to";
      histName+=intToString(etaSlice+2);
      string histNameBeg = histName;
      histName+="iasPredictionFixedLimitsHist";
      //histName+="iasPredictionFixedDiscoveryHist";

      //cout << "Getting hist: " << histName << endl;
      TH1D* iasPredHistThisSlice = (TH1D*)_file0->Get(histName.c_str());

      histName="nom";
      histName+=intToString(nom);
      histName+="to";
      if(nom==5)
        histName+=intToString(nom+3);
      else
        histName+=intToString(nom+1);
      histName+="eta";
      histName+=intToString(etaSlice);
      histName+="to";
      histName+=intToString(etaSlice+2);
      histName+="dRegionFixedHist";

      //cout << "Getting hist: " << histName << endl;
      TH1D* iasDataHistThisSlice = (TH1D*)_file0->Get(histName.c_str());

      iasDataHistThisSlice->SetLineColor(kBlack);
      iasDataHistThisSlice->SetMarkerColor(kBlack);
      iasDataHistThisSlice->SetMarkerStyle(20);
      iasDataHistThisSlice->Draw();
      iasPredHistThisSlice->SetLineColor(kBlue);
      iasPredHistThisSlice->SetMarkerColor(kBlue);
      iasPredHistThisSlice->SetMarkerStyle(21);
      iasPredHistThisSlice->Draw("same");
      // draw 3rd hist?
      string thirdHistName = histNameBeg;
      thirdHistName+="iasPredictionFixedSlopeMinusOneSigmaLimitsHist";
      TH1D* iasPredThirdHist = (TH1D*)_file0->Get(thirdHistName.c_str());
      iasPredThirdHist->SetLineColor(kRed);
      iasPredThirdHist->SetMarkerColor(kRed);
      iasPredThirdHist->SetMarkerStyle(23);
      iasPredThirdHist->Draw("same");
      // draw 4th hist?
      string fourthHistName = histNameBeg;
      fourthHistName+="iasPredictionFixedSlopeAddOneSigmaLimitsHist";
      TH1D* iasPredFourthHist = (TH1D*)_file0->Get(fourthHistName.c_str());
      iasPredFourthHist->SetLineColor(kGreen+2);
      iasPredFourthHist->SetMarkerColor(kGreen+2);
      iasPredFourthHist->SetMarkerStyle(22);
      iasPredFourthHist->Draw("same");

      if(iasDataHistThisSlice->GetMaximum() <= 0)
        iasDataHistThisSlice->GetYaxis()->SetRangeUser(1e-10,iasPredHistThisSlice->GetMaximum()*1.2);
      else
        iasDataHistThisSlice->GetYaxis()->SetRangeUser(1e-10,iasDataHistThisSlice->GetMaximum()*1.2);

      string name="nom";
      name+=intToString(nom);
      name+="to";
      if(nom==5)
        name+=intToString(nom+3);
      else
        name+=intToString(nom+1);
      name+="eta";
      name+=intToString(etaSlice);
      name+="to";
      name+=intToString(etaSlice+2);
      name+="iasDataPred";
      t.Print((name+".png").c_str());
    }
    if(nom==5) nom+=2;
  }
}
Example #13
0
void macroComparison(string sfileA,string sfileB,string sfileC, string fname){

  TFile * fileA = new TFile(TString(sfileA), "READ");
  TFile * fileB = new TFile(TString(sfileB), "READ");
  TFile * fileC = new TFile(TString(sfileC), "READ");

  // get canvas name
  TList *listA = fileA->GetListOfKeys();  
  TString canvasnameA = listA->At(0)->GetName();
 
  TList *listB = fileB->GetListOfKeys();  
  TString canvasnameB = listB->At(0)->GetName();

  TList *listC = fileC->GetListOfKeys();  
  TString canvasnameC = listC->At(0)->GetName();

  // make histogram name out of canvas name
  TString histonameA = canvasnameA;
  Ssiz_t objIndexA = histonameA.Index("canvas");
  histonameA.Resize(objIndexA);
  histonameA+= "_data_hist";

  TString histonameB = canvasnameB;
  Ssiz_t objIndexB = histonameB.Index("canvas");
  histonameB.Resize(objIndexB);
  histonameB+= "_data_hist";

  TString histonameC = canvasnameC;
  Ssiz_t objIndexC = histonameC.Index("canvas");
  histonameC.Resize(objIndexC);
  histonameC+= "_data_hist";

  // get canvas from files
  // get histograms from canvases
  
  TCanvas *cvA = (TCanvas*) fileA->Get(canvasnameA);
  TH1D * histoA = (TH1D*) cvA->FindObject(histonameA)->Clone();
  // set name to different value
  cvA->SetName("dummy");
  
  TCanvas *cvB = (TCanvas*) fileB->Get(canvasnameB);
  TH1D * histoB = (TH1D*) cvB->FindObject(histonameB)->Clone();
  cvB->SetName("dummy2");

  TCanvas *cvC = (TCanvas*) fileC->Get(canvasnameC);
  TH1D * histoC = (TH1D*) cvC->FindObject(histonameC)->Clone();


  // ratio plots
  TH1D * histoAoverBRatio =  (TH1D*) histoA->Clone();
  TH1D * histoAoverCRatio =  (TH1D*) histoA->Clone();
  TH1D * histoBoverCRatio =  (TH1D*) histoB->Clone();

  histoAoverBRatio->Divide(histoB);
  histoAoverCRatio->Divide(histoC);
  histoBoverCRatio->Divide(histoC);

  // make new Canvas for plotting
  TCanvas *cv1 = new TCanvas(histonameA, histonameA, 1024,1024);
  cv1->cd();
  cv1->Clear();
  cv1->Divide(1,2,0.01,0.0);
  

  cv1->cd(1);
  cv1->SetFillColor(0); 
  gStyle->SetOptTitle(0);
  gPad->SetFillColor(0);
  gPad->SetPad( 0.0, 0.25, 1.0, 1.0 );
  gPad->SetTopMargin(0.1);
  gPad->SetLeftMargin(0.16);
  gPad->SetRightMargin(0.04);

  cv1->cd(2);
  cv1->SetFillColor(0);
  gStyle->SetOptTitle(0);
  gPad->SetFillColor(0);
  gPad->SetPad( 0.0, 0.0,  1.0, 0.25 );
  gPad->SetBottomMargin(0.375);
  gPad->SetLeftMargin(0.16);
  gPad->SetRightMargin(0.04);
  gPad->SetGridy();

  cv1->cd(1);

  histoA->SetMarkerStyle(20);
  histoA->SetMarkerSize(2);
  histoA->SetMarkerColor(1);
  histoA->Draw("E1X0");
  //  histoA->DrawNormalized("E1X0");

  histoB->SetMarkerStyle(21);
  histoB->SetMarkerSize(2);
  histoB->SetMarkerColor(2);
  histoB->Draw("E1X0SAME");
  //  histoB->DrawNormalized("E1X0SAME");

  histoC->SetMarkerStyle(22);
  histoC->SetMarkerSize(2);
  histoC->SetMarkerColor(3);
  histoC->Draw("E1X0SAME");
  //  histoC->DrawNormalized("E1X0SAME");

  TLegend *leg = new TLegend(0.685, 0.575, 0.8, 0.875); 
  leg->AddEntry(histoA,"A");
  leg->AddEntry(histoB,"B");
  leg->AddEntry(histoC,"C");

  leg->Draw("SAME");


  // set style for ratio plots

  histoAoverBRatio->SetMarkerStyle(20);
  histoAoverCRatio->SetMarkerStyle(21);
  histoBoverCRatio->SetMarkerStyle(22);
  histoAoverBRatio->SetMarkerSize(1);
  histoAoverCRatio->SetMarkerSize(1);
  histoBoverCRatio->SetMarkerSize(1);
  histoAoverBRatio->SetMarkerColor(1);
  histoAoverCRatio->SetMarkerColor(2);
  histoBoverCRatio->SetMarkerColor(3);
  histoAoverBRatio->SetLineColor(1);
  histoAoverCRatio->SetLineColor(2);
  histoBoverCRatio->SetLineColor(3);

  cv1->cd(2);
  histoAoverBRatio->GetYaxis()->SetRangeUser(0.9,1.1);
  histoAoverBRatio->GetYaxis()->CenterTitle(1);
  histoAoverBRatio->GetYaxis()->SetTitleSize( 0.16 );
  histoAoverBRatio->GetYaxis()->SetTitleOffset( 0.425 );
  histoAoverBRatio->GetYaxis()->SetLabelSize( 0.16 );
  histoAoverBRatio->GetYaxis()->SetNdivisions( 505 );

  histoAoverBRatio->GetXaxis()->SetTitleSize( 0.16 );
  histoAoverBRatio->GetXaxis()->SetLabelSize( 0.16 );
  histoAoverBRatio->GetXaxis()->SetTitleOffset( 1 );
  histoAoverBRatio->GetXaxis()->SetLabelOffset( 0.006 );
  histoAoverBRatio->GetXaxis()->SetNdivisions( 510 );
  histoAoverBRatio->GetXaxis()->SetTickLength( histoAoverBRatio->GetXaxis()->GetTickLength() * 3.0 );
  histoAoverBRatio->SetYTitle("Data/Data"); 

  histoAoverBRatio->Draw("E1X0");
  histoAoverCRatio->Draw("E1X0SAME");
  histoBoverCRatio->Draw("E1X0SAME");

  cv1->Update();
  cv1->Print(TString(fname)+TString("_Linear.png"));


  /// the same with log scale

 // make new Canvas for plotting
  TCanvas *cv2 = new TCanvas(histonameA+"log", histonameA+"log", 1024,1024);
  cv2->cd();
  cv2->Clear();
  cv2->Divide(1,2,0.01,0.0);
  

  cv2->cd(1);
  cv2->SetFillColor(0); 
  gStyle->SetOptTitle(0);
  gPad->SetLogy();
  gPad->SetFillColor(0);
  gPad->SetPad( 0.0, 0.25, 1.0, 1.0 );
  gPad->SetTopMargin(0.1);
  gPad->SetLeftMargin(0.16);
  gPad->SetRightMargin(0.04);

  cv2->cd(2);
  cv2->SetFillColor(0);
  gStyle->SetOptTitle(0);
  gPad->SetFillColor(0);
  gPad->SetPad( 0.0, 0.0,  1.0, 0.25 );
  gPad->SetBottomMargin(0.375);
  gPad->SetLeftMargin(0.16);
  gPad->SetRightMargin(0.04);
  gPad->SetGridy();

  cv2->cd(1);

 
  histoA->Draw("E1X0");
  histoB->Draw("E1X0SAME");
  histoC->Draw("E1X0SAME");

  TLegend *leg2 = new TLegend(0.685, 0.575, 0.8, 0.875); 
  leg2->AddEntry(histoA,"A");
  leg2->AddEntry(histoB,"B");
  leg2->AddEntry(histoC,"C");

  leg2->Draw("SAME");



  cv2->cd(2);
 
  histoAoverBRatio->Draw("E1X0");
  histoAoverCRatio->Draw("E1X0SAME");
  histoBoverCRatio->Draw("E1X0SAME");

  cv2->Update();
  cv2->Print(TString(fname)+TString("_Log.png"));


}
void MidRapAnalysis() {
  //Set up Canvas Area
  TCanvas* can2 = new TCanvas("can2", "Centrality");

  double xAverage[] = {3.42, 2.62, 1.96, 1.45, 1.12, .87, .67, .49, .39, .28, .23};
  double yAverage[] = {5.22, 3.33, 2.21, 1.40, 1.06, .72, .49, .22, .16, .06, .03};
  double yError[] = {.36, .25, .12, .06, .01, .12, .04, .03, .01, .01, 0};
  double xError[] = {0,0,0,0,0,0,0,0,0,0};
  TGraphErrors* Emodel = new TGraphErrors(10, xAverage, yAverage, xError, yError);
  Emodel->SetFillStyle(3001);
  Emodel->SetFillColor(kBlue);

  double xAverageE[] = {4.19, 2.92, 2.03, 1.40, 1.04, .77, .57, .42, .32, .24};
  double yAverageE[] = {5.39, 3.36, 2.14, 1.33, .90, .56, .37, .16, .14, .01};
  double yErrorE[] = {.31, .24, .08, .07, .01, .01, .02, .06, .07, .01};
  double xErrorE[] = {0,0,0,0,0,0,0,0,0,0};
  TGraphErrors* EmodelE = new TGraphErrors(10, xAverageE, yAverageE, xErrorE, yErrorE);
  EmodelE->SetFillStyle(3001);
  EmodelE->SetFillColor(kGreen);

  can2->cd();
  TH1F* frame = can2->DrawFrame(0, 0, 3.5, 7.2);
  TF1* line = new TF1("line", "x", 0, 4.3);
  TF1* line2 = new TF1("line2", "1.6*x", 0, 4.3);
  line2->SetLineColor(kWhite);
  line->SetLineColor(1);
  line2->GetYaxis()->SetTitle("#varUpsilon(1S)/<#varUpsilon(1S)>");
//  line2->GetXaxis()->SetTitle("N_{Ch}^{|#eta|<2.4}/<N_{Ch}^{|#eta|<2.4}>");
  line2->SetTitle("#varUpsilon(1S) Cross Section vs Event Activity");
  line2->Draw();
  Emodel->Draw("P3");
  EmodelE->Draw("3");
 //line2->Draw("same");
  line->SetLineStyle(3);
  line->SetLineColor(kBlack);
  line->Draw("same");
  
  TH1D* mod = new TH1D("mod", "Pythia Model", 400, 0, 4);
  mod->SetLineColor(kBlue);
  TH1D* modEnergy = new TH1D("modEnergy", "Pythia Energy Model", 400, 0, 4);
  modEnergy->SetLineColor(kGreen);

  TH1D* data = new TH1D("data", "CMS Data", 4000, 0, 4);
  data->SetMarkerStyle(20);
  data->SetMarkerColor(kRed);
  //Manually Entering CMS Data Points with Error
  data->SetBinContent(3262, 6.67);
  data->SetBinError(3262, .26);
  data->SetBinContent(2010, 3.12);
  data->SetBinError(2010, .15);
  data->SetBinContent(1240, 1.4);
  data->SetBinError(1240, .06);
  data->SetBinContent(630, .240);
  data->SetBinError(630, .01);
  //data->SetMarkerColor(kBlue);
  data->SetMarkerSize(1);
  data->SetLineColor(kRed);
  data->Draw("sameE");

  TLegend* leg = new TLegend(.1,.7,.38,.9);
  leg->SetHeader("For |#eta| < 2.4");
  leg->AddEntry(modEnergy->DrawCopy("same"), "Pythia 8 - #Sigma E_{T}/<#Sigma E_{T}>", "l");
  leg->AddEntry(mod->DrawCopy("same"), "Pythia 8 - N_{Ch}/<N_{Ch}>", "l");
  leg->AddEntry(data->DrawCopy("sameE"), "CMS data - N_{Ch}/<N_{Ch}>", "l");
  leg->Draw("same");
  mod->SetLineColor(kBlack);
  mod->Draw("same");
  return; }
Example #15
0
void CorrPtCut(char *prodname = "LHC10d4 PYTHIA D6T 7 TeV p+p", char *shortprodname = "LHC10d4", char *filename="Et.ESD.new.sim.LHC10d4.pp.merged.root"){

  gStyle->SetOptTitle(0);
  gStyle->SetOptStat(0);
  gStyle->SetOptFit(0);
  TCanvas *c = new TCanvas("c","c",500,400);
  c->SetTopMargin(0.04);
  c->SetRightMargin(0.04);
  c->SetLeftMargin(0.181452);
  c->SetBottomMargin(0.134409);
  c->SetBorderSize(0);
  c->SetFillColor(0);
  c->SetFillColor(0);
  c->SetBorderMode(0);
  c->SetFrameFillColor(0);
  c->SetFrameBorderMode(0);
  float etacut = 0.7;
  cout<<"Pt cut = 150 MeV/c"<<endl;
  TH1D *High = GetHisto(0.15-.001,"High",filename,etacut);
  float tpcHigh=highbound;
  float tpcLow=lowbound;
  float tpcsyserr = syserr;
  float tpcmean = mean;
  float x1 = High->GetXaxis()->GetBinLowEdge(1);
  //TBox *tpcBox = new TBox(-x1*.99,1.0-tpcLow,x1*.99,1.0-tpcHigh);
  TBox *tpcBox = new TBox(-x1*.99,1.0-(mean-syserr),x1*.99,1.0-(mean+syserr));
  tpcBox->SetFillColor(5);
  tpcBox->SetLineColor(0);
  tpcBox->SetFillStyle(1001);
  cout<<"Pt cut = 100 MeV/c"<<endl;
  TH1D *Low = GetHisto(0.1-.001,"Low",filename,etacut);
  float itsHigh=highbound;
  float itsLow=lowbound;
  float itssyserr = syserr;
  float itsmean = mean;

  cout<<Form("dataset & %2.4f \\pm %2.4f &  %2.4f \\pm %2.4f \\",itsmean,itssyserr,tpcmean,tpcsyserr)<<endl;
  float x = Low->GetXaxis()->GetBinLowEdge(1);
  //TBox *itsBox = new TBox(-x*.99,1.0-itsLow,x*.99,1.0-itsHigh);
  TBox *itsBox = new TBox(-x1*.99,1.0-(mean-syserr),x1*.99,1.0-(mean+syserr));
  itsBox->SetFillColor(5);
  itsBox->SetLineColor(0);
  itsBox->SetFillStyle(1001);
  cout<<"Pt cut = 50 MeV/c"<<endl;
  TH1D *Lowest = GetHisto(0.05-.001,"Lowest",filename,etacut);
  TF1 *funcLow = new TF1("funcLow","[0]",-.7,.7);
  funcLow->SetParameter(0,0.01);
  Low->Fit(funcLow);
  TF1 *funcHigh = new TF1("funcHigh","[0]",-.7,.7);
  funcHigh->SetParameter(0,0.02);
  High->Fit(funcLow);
  High->SetMaximum(0.06);
  High->SetMinimum(0.0);
  High->SetMarkerColor(2);
  Low->SetMarkerColor(4);
  High->SetLineColor(2);
  Low->SetLineColor(4);
  High->SetMinimum(0.0);
  High->SetMarkerStyle(20);
  Low->SetMarkerStyle(21);
  Lowest->SetMarkerStyle(22);
  High->Draw();
  tpcBox->Draw("f");
  High->Draw("same");
  itsBox->Draw("f");
  //return;
  Low->Draw("same");
  //Lowest->Draw("same");
  TLatex *tex = new TLatex(-0.723444,0.0373593+0.019,prodname);
  tex->SetTextSize(0.0537634);
  tex->Draw();
  TLegend *leg = new TLegend(0.217742,0.696237,0.477823,0.873656);
  leg->AddEntry(High,"p_{T} cut-off = 0.15 GeV/c");
  leg->AddEntry(Low,"p_{T} cut-off = 0.1 GeV/c");
  //leg->AddEntry(Lowest,"p_{T} cut-off = 0.05 GeV/c");
  leg->SetFillStyle(0);
  leg->SetFillColor(0);
  leg->SetBorderSize(0);
  leg->SetTextSize(0.0537634);
  leg->Draw();
  c->SaveAs(Form("pics/%s/fptcut.eps",shortprodname));
  c->SaveAs(Form("pics/%s/fptcut.png",shortprodname));
  c->SaveAs(Form("pics/%s/fptcut.pdf",shortprodname));
}
void
//Impose (TDirectory * target, TList * sourcelist, string & np_title_, vector<string> titles,vector<float> xsecs)
Impose (TList * sourcelist, string & np_title_, vector<string> titles,vector<float> xsecs, TString &variable)
{
	cout << "	" << "========================================================" << endl;
	cout << "	" << "This is a macro to superimpose plots of different root files." << endl;
	cout << "	" << "Only TH2Dobjects are superimposed." << endl;
	float Lumi=1;


	Lumi = 15712.;
	bool norm_=false;
        int MaxEventsBin = 10;
	cout<<titles[0]<<"   "<<titles.size()<<endl;

	//not really useful if plots already weighted to lumi - usefull is plots are in a.u.
	vector <float > lumiweights;
	lumiweights.clear();
//	for (unsigned int kk=0; kk<signal_names.size();kk++){
//		cout<<" HERE is some signal  ===============================================  "<<signal_names[kk]<<"  "<<signalnames[kk]<<endl;
//	}

	TH2D* allbkg, *htt,*hstop,*hwj,*hdyj,*hrare,*hdib,*hqcd,*httx, *hrest;

	TFile *first_source = (TFile *) sourcelist->First ();
	first_source->cd ("mutau");

	TH1D* eventCount = (TH1D*)first_source->Get("mutau/histWeightsH");
	//TH1D* eventCount = (TH1D*)first_source->Get("mutau/inputEventsH");
	//TH1D* hxsec = (TH1D*)first_source->Get("mutau/xsec");
	float nGen = eventCount->GetSumOfWeights();
	float xsec = 1;//hxsec->GetMean();
	float norm = xsec*Lumi/nGen;

	norm =1;
	lumiweights.push_back(float(norm));


	//cout<< " for first source file, there where "<<nGen<<" events with xsec "<<xsec<<" weight "<<lumiweights[0]<<endl;//" weight "<<float(xsec*Lumi/nGen)<<"  norm "<<norm<<endl;

	TDirectory *current_sourcedir = gDirectory;
	//gain time, do not add the objects in the list in memory
	Bool_t status = TH1::AddDirectoryStatus ();
	TH1::AddDirectory (kFALSE);
	// loop over all keys in this directory
	TChain *globChain = 0;
	TIter nextkey (current_sourcedir->GetListOfKeys ());
	//TIter nextkey (((TDirectory *) current_sourcedir->Get ("ana"))->GetListOfKeys ());
	TKey *key, *oldkey = 0;
	while ((key = (TKey *) nextkey ())) {
	//variable="met_MTsum_16";

	int count=0;
		count++;
		//if (count>20) break;
		//keep only the highest cycle number for each key
		//        if (oldkey && !strcmp (oldkey->GetName (), key->GetName ()))
		//            continue;

		// read object from first source file and create a canvas
		// first_source->cd (path);
		first_source->cd ("mutau");
		TObject *obj = key->ReadObj ();

		//string nn = obj->GetName();
		// if (std::string::npos == nn.find("Cut")) continue;
		//cout<<obj->GetName()<<endl;



		string nn = obj->GetName();
		bool flcont = true;
		bool NormTT = false;
		if (string::npos != nn.find("_9") || string::npos != nn.find("_10") || string::npos != nn.find("_11") || string::npos != nn.find("_12") || string::npos != nn.find("_13") || string::npos != nn.find("_14") || string::npos != nn.find("_15") || string::npos != nn.find("_16") || string::npos != nn.find("_18") || string::npos != nn.find("_18") || string::npos != nn.find("_18")) NormTT = true;
		//if ( string::npos != nn.find("_11") || string::npos != nn.find("_12") || string::npos != nn.find("_13") || string::npos != nn.find("_14")) NormTT = true;
		NormTT=true;
		//if ( string::npos == nn.find("CutFlowUnW")) flcont=false;
		//if (string::npos == nn.find(""+variable) ) flcont=false;
		if (string::npos == nn.find(variable) ) continue;
		//		if (!flcont) continue;
		if (obj->IsA ()->InheritsFrom ("TTree") ) continue;
		//	if (obj->IsA ()->InheritsFrom ("TH1") ) continue;
		if (obj->IsA ()->InheritsFrom ("TH2") ) {

			cout<<"=================================================== OK for variable "<<variable<<endl;


			TH2D* hh[1500];
			TH2D* hsignal[1500];
			TH2D* h1 = (TH2D*) obj;

			ModifyHist (h1,1,Lumi,lumiweights[0],titles[0],norm_);
			TFile *nextsource = (TFile *) sourcelist->After (first_source);

			int cl, countsignal;
			h1->SetStats(000000);
			cl=1;
			countsignal=1;

			hh[cl]=h1;

			THStack *hs = new THStack(h1->GetName(),h1->GetTitle());



			string sn="stau";
			string sdata="Single";
			string sdata2="MuonEG";
			string cc1="C1";



			while (nextsource) {

			string fname= nextsource->GetName();


				bool flagg= false;

				if (std::string::npos != fname.find(sn) || std::string::npos != fname.find(cc1) || std::string::npos != fname.find(sdata)    ) 	flagg=true;

				//if (flagg) cout<<"=============================================================== "<<fname<<endl;
				// make sure we are at the correct directory level by cd'ing to path
				nextsource->cd("mutau");
				TH1D* eventCountt ;
				
				  if  ( std::string::npos == fname.find("TT_TuneCUETP8M1_13TeV-powheg-pythia8") || !NormTT) eventCountt = (TH1D*)nextsource->Get("mutau/histWeightsH");
				  if ( NormTT && std::string::npos != fname.find("TT_TuneCUETP8M1_13TeV-powheg-pythia8") ) eventCountt = (TH1D*)nextsource->Get("mutau/histTopPt");

				
				TH1D* hxsecc = (TH1D*)nextsource->Get("mutau/xsec");
				float xsecc = xsecs[cl];

				float nGenn = eventCountt->GetSumOfWeights();
				float normm = float(xsecc*Lumi) / float(nGenn)  ;
				if (std::string::npos != fname.find("DataDriven")) normm=1.;

				lumiweights.push_back(normm);

				TKey *key2 = (TKey *) gDirectory->GetListOfKeys ()->FindObject (h1->GetName ());

				if (key2) {
					cl++;
					countsignal++;
					TH2D *h2;

					h2 = (TH2D*) key2->ReadObj ();
					ModifyHist (h2, cl,Lumi,lumiweights[cl-1],titles[cl-1],norm_);
					h2->SetStats(0);
					hh[cl] = h2;

					if (cl==2){
						allbkg  = (TH2D*) h2->Clone();
						allbkg->Reset();
						htt  = (TH2D*) h2->Clone();
						httx  = (TH2D*) h2->Clone();
						hstop  = (TH2D*) h2->Clone();
						hwj  = (TH2D*) h2->Clone();
						hdyj  = (TH2D*) h2->Clone();
						hrare  = (TH2D*) h2->Clone();
						hdib  = (TH2D*) h2->Clone();
						hqcd  = (TH2D*) h2->Clone();
						hrest  = (TH2D*) h2->Clone();

						htt->Reset();
						httx->Reset();
						hstop->Reset();
						hdyj->Reset();
						hwj->Reset();
						hrare->Reset();
						hdib->Reset();
						hqcd->Reset();
						hrest->Reset();


					}



					string  hn_ = obj->GetName();
					cout<<"  "<<fname<<endl;

						if (std::string::npos != fname.find(sn) || std::string::npos != fname.find(cc1) || std::string::npos != fname.find(sdata) ||  std::string::npos != fname.find(sdata2)  )
							flagg=true;


						string  title_ = fname;
							//cout<<"  "<<fname<<endl;

			int col = 0;
						if (!flagg)
						{
			if (std::string::npos != title_.find("wJets")|| std::string::npos != title_.find("WJetsToLNu") || std::string::npos != title_.find("W1JetsToLNu") || std::string::npos != title_.find("W2JetsToLNu") 
			|| std::string::npos != title_.find("W3JetsToLNu") || std::string::npos != title_.find("W4JetsToLNu"))  { col=mycolorwjet ; hwj->Add(h2); hwj->SetLineColor(col);}
			if (std::string::npos != title_.find("TT_TuneCUETP8M1_13TeV-powheg-pythia8") || std::string::npos != title_.find("TTPow")) { col= mycolortt;htt->Add(h2); htt->SetLineColor(col) ;}
			if (std::string::npos != title_.find("QCD"))  {col= mycolorqcd;hqcd->Add(h2); hqcd->SetLineColor(col); cout<<" QCD ======================== "<<hqcd->GetSumOfWeights()<<endl;}
			if (std::string::npos != title_.find("DYJets") || std::string::npos != title_.find("DY1Jets") 
			|| std::string::npos != title_.find("DY2Jets") || std::string::npos != title_.find("DY3Jets") || std::string::npos != title_.find("DY4Jets"))  {col= mycolordyj;hdyj->Add(h2); hdyj->SetLineColor(col);}
			if (std::string::npos != title_.find("ST_") || std::string::npos != title_.find("channel") )  {col= mycolortt; hstop->Add(h2);hstop->SetLineColor(col);}
			if ( std::string::npos != title_.find("WW") || std::string::npos != title_.find("ZZ") ||  std::string::npos != title_.find("WZ") || std::string::npos != title_.find("WG") || std::string::npos != title_.find("ZG") ) {col=mycolorvv; hdib->Add(h2); hdib->SetLineColor(col);}
			if ( std::string::npos != title_.find("TTW") || std::string::npos != title_.find("TTZ") || std::string::npos != title_.find("tZq") || std::string::npos != title_.find("TG") || std::string::npos != title_.find("tG") || std::string::npos != title_.find("TTG") || std::string::npos != title_.find("ttW") || std::string::npos != title_.find("ttZ") || std::string::npos != title_.find("tZ") || std::string::npos != title_.find("TTT_") ) {col=mycolorttx ;httx->Add(h2);   httx->SetLineColor(col);}


							//cout<<" will add histogram "<<h2->GetName()<< " for "<<titles[cl-1]<<"  "<<fname<<"  cl  "<<cl<<endl;
							hs->Add(h2);
							allbkg->Add(h2);
						}

				}


				nextsource = (TFile *) sourcelist->After (nextsource);
			}				// while ( nextsource )
		}


		cout<<" Will now extract and save the 1D "<<endl;
		//const char *s1;
		TString s1;
		TH1D * histbkg;
		string n = obj->GetName();
		vector<float> scales;
		bool b_scale=true;
		if (std::string::npos != n.find(variable) && obj)
		{
			TH2D *hsum = ((TH2D*)(hs->GetStack()->Last())); // the "SUM"
			scales.push_back(40000.);
			for (int sc = 0 ; sc<scales.size();sc++){
	

				float scale = float(scales[sc])/float(Lumi);

				//stringstream ss (stringstream::in | stringstream::out);

	
				TString lumistring = "40invfb";
				TString smFilename = "Templates_"+variable+"_"+lumistring+"_mt_C1C1.root";
				//TString smFilename = "Templates_mt.root";
				TFile *smFile = TFile::Open (smFilename, "recreate");


				smFile->cd();
				//if (sc==0) smFile->mkdir("mt");
				smFile->cd();
				allbkg = hsum;
				allbkg->SetMinimum(0.1);
				allbkg->SetLineColor(kRed);
				allbkg->SetMarkerColor(kRed);
				allbkg->SetFillColor(kRed);
				allbkg->SetFillStyle(3011);
				allbkg->SetMinimum(0.1);
				s1 = "data_obsMC_" + variable;
				//s1 = "data_obsMC";
				allbkg->SetName(s1);
				cout<<" Total Integral before scaling up - "<<allbkg->GetSumOfWeights()<<"  "<<variable<<" data "<<hh[1]->GetSumOfWeights()<<" tt "<<
					htt->GetSumOfWeights()<<" dy "<<hdyj->GetSumOfWeights()<<" wj "<<hwj->GetSumOfWeights()<<" stop "<<hstop->GetSumOfWeights()<<
					" vv "<<hdib->GetSumOfWeights()<<" qcd "<<hqcd->GetSumOfWeights()<<endl;
	if(b_scale)		allbkg->Scale(scale);
				cout<<" Total Integral after scaling up - "<<allbkg->GetSumOfWeights()<<"  "<<variable<<endl;
				allbkg->Write();


				histbkg = Unroll(allbkg,s1,1.);
				s1 = "1D_allbkg_" + variable;
				//s1 = "1D_data_obsMC";//_" + variable+"_"+lumistring;
				histbkg->SetName(s1);
				histbkg->SetMarkerColor(kRed);
				histbkg->SetLineColor(kRed);
				histbkg->Write();
	 if(b_scale){
				htt->Scale(scale);
				hwj->Scale(scale);
				hdyj->Scale(scale);
				hstop->Scale(scale);
				hdib->Scale(scale);
				hqcd->Scale(scale);
				httx->Scale(scale);
	 }

				htt->SetMinimum(0.1);
				hdyj->SetMinimum(0.1);
				hwj->SetMinimum(0.1);
				httx->SetMinimum(0.1);
				hstop->SetMinimum(0.1);
				hdib->SetMinimum(0.1);
				hqcd->SetMinimum(0.1);

				s1 = "tt_"+variable;
				htt->SetName(s1);
				htt->Write();
				histbkg = Unroll(htt,s1,1.);
				s1 = "1D_tt_"+variable;
				histbkg->SetName(s1);
				histbkg->Write();

				s1 = "wj_"+variable;
				hwj->SetName(s1);
				hwj->Write();
				histbkg =Unroll(hwj,s1,1.);
				s1 = "1D_wj_"+variable;
				histbkg->SetName(s1);
				histbkg->Write();

				s1 = "dyj_"+variable;
				hdyj->SetName(s1);
				hdyj->Write();
				histbkg =Unroll(hdyj,s1,1.);
				s1 = "1D_dyj_"+variable;
				histbkg->SetName(s1);
				histbkg->Write();

				s1 = "sT_"+variable;
				hstop->SetName(s1);
				hstop->Write();
				histbkg =Unroll(hstop,s1,1.);
				s1 = "1D_sT_"+variable;
				histbkg->SetName(s1);
				histbkg->Write();

				s1 = "dib_"+variable;
				hdib->SetName(s1);
				hdib->Write();
				histbkg =Unroll(hdib,s1,1.);
				s1 = "1D_dib_"+variable;
				histbkg->SetName(s1);
				histbkg->Write();

				s1 = "ttx_"+variable;
				httx->SetName(s1);
				httx->Write();
				histbkg =Unroll(httx,s1,1.);
				s1 = "1D_ttx_"+variable;
				histbkg->SetName(s1);
				histbkg->Write();

				s1 = "qcd_"+variable;
				hqcd->SetName(s1);
				hqcd->Write();
				histbkg =Unroll(hqcd,s1,1.);
				s1 = "1D_qcd_"+variable;
				histbkg->SetName(s1);
				histbkg->Write();

				//rest of bkg hold all but ttjets and wjets background	
				s1 = "rest_bkg_"+variable;
				//hrest->Add(hdyj,1);
				//hrest->Add(httj,1);
				//hrest->Add(hwj,1);
				hrest->Add(hstop,1);
				hrest->Add(hdib,1);
				hrest->Add(hqcd,1);
				hrest->Add(httx,1);
				hrest->SetName(s1);
				hrest->Write();
				histbkg =Unroll(hrest,s1,1.);
				s1 = "1D_rest_bkg_"+variable;
				histbkg->SetName(s1);
				histbkg->Write();
				

				hh[1]->SetMinimum(0.1);
				hh[1]->SetLineColor(kBlack);
				hh[1]->SetFillColor(kBlack);
				hh[1]->SetMarkerColor(kBlack);
				s1 = "data_obs_"+variable;
				hh[1]->SetName(s1);

	if(b_scale)	hh[1]->Scale(scale);
				hh[1]->Write();
				histbkg =Unroll(hh[1],s1,1.);
				//histbkg =Unroll(allbkg,s1,1.);
				s1 = "1D_data_obs_";
				s1 = "data_obs";
				histbkg->SetName(s1);
				histbkg->Write();

				for (unsigned int ij=0;ij<signal_names.size();++ij){
					//cout<<" again  "<<signal_names[ij]<<endl;
					//cout<<" again  "<<hh[ij+2]->GetName()<<"  "<<ij<<"  "<<signal_names[ij].c_str()<<endl;
					TString ss1 = signal_names[ij].c_str();
					s1 = "1D_"+ss1 +"_"+variable;
	if(b_scale)			hh[ij+2]->Scale(scale);
					histbkg = Unroll(hh[ij+2],s1,1.);
					smFile->cd();
					histbkg->SetName(s1);
					histbkg->SetMarkerColor(kBlue);
					histbkg->SetLineColor(kBlue);
					histbkg->Write();

				}
				smFile->SaveSelf (kTRUE);
				smFile->Close();
				delete smFile;
			}//loop over different predictions

		}///find variable





			}

	//delete c1;
	// save modifications to target file
	//target->SaveSelf (kTRUE);
	TH1::AddDirectory (status);
	cout << "	" << "========================================================" << endl;
	cout<< " Ended SuperImpose of files.... " <<endl;




}
Example #17
0
void packTemplatesMass(const int iMass) {
  // This Root macro is for the purpose of providing input for expected limit computation
  // It packs predicted background and a set of signal samples into a root file per Higgs mass
  // 
  TH1::SetDefaultSumw2();
  TH2::SetDefaultSumw2();
  canvas = new TCanvas ("cg1","PadX",10,10,800,600);
  gStyle->SetPadColor(0);
  canvas->SetFillColor(0);

//   const int nbtag = 4;
  const int nbtag = 1;
  //const std::string sbtag[nbtag] = { "TCHPT", "TCHP6", "CSVT", "SSVHPT" };
  const std::string sbtag[nbtag] = { "CSVT" };

  const int nfc=3;
  const int ncateg=3;
  string sfc[nfc] = { "q", "c", "b" };

  // this is for the combination of triggers in real data
  int nTCombData = 4;
  std::string tCombData[] = {"Trig0", "Trig1", "Trig2", "Trig3"};

  std::string L1L2Mode("Weight");
  std::string signalMode("PU_WEIGHTED-NEW");
//   std::string L1L2Mode("Cut");
//   std::string signalMode("CUT_BASED");

  //std::string scenario("LowMass2011");
  //std::string scenario("MediumMass2011");

  std::string scenario;
  bool useTemplateError;
  bool useNP;
  if (  getHbbCfg(scenario,useTemplateError,useNP) != 0 ) return;

  string IgorVersion("V6");

#include "Analysis/Utilities/interface/HbbMass.h"

  if (iMass >= nSignal) {
    std::cout << "Bad iMass=" << iMass << std::endl;
    return;
  }
//   const int nSignal=7;
//   int signalMass[nSignal] = { 90, 100, 120, 140, 180, 250, 350 };
  // int signalMass[nSignal] = { 90, 100, 120, 130, 140, 160, 180, 200, 250, 350 }
  //  there are also : 450, 500, 600, 700, 800, 900, 1000
//   double efficiency[nSignal] = { 0.0022081, 0.00324694, 0.00600146, 0.00918135,
// 				0.0138382, 0.0189684, 0.0206572 };
  double efficiency[nSignal][nbtag];
  double intLumi = 0;
  string IgorScen("");
  string spacer("");
  string SashaPath("");
  string IgorPath("/data/user/marfin/CMSSW_5_0_1/src/Analysis/HbbMSSMAnalysis/test/SignalTemplates-Production");

  if (IgorVersion == "V4") {
    IgorPath.assign("/data/user/marfin/CMSSW_5_0_1/src/Analysis/HbbMSSMAnalysis/test/Systematics-test-4");
  } else if (IgorVersion == "V6") {
    IgorPath.assign("/data/user/marfin/CMSSW_5_0_1/src/Analysis/HbbMSSMAnalysis/test/SignalTemplates-Production2");
  }

  if (scenario == "LowMass2011") {
    //intLumi = 2.66794; // in fb-1
    intLumi = 2.692643;  // with new method
    IgorScen.assign("low");
    spacer.assign("");
    //SashaPath.assign("Data-Run2011AB");
    SashaPath.assign("Data-Run2011AB/TripleBtagAnalysis_CR3_SF7");
  } else if (scenario == "MediumMass2011") {
    //intLumi = 3.99983; // in fb-1
    intLumi = 4.040802;
    IgorScen.assign("medium");
    spacer.assign("/MEDIUM");
    //SashaPath.assign("Data-Run2011AB-Medium");
    SashaPath.assign("Data-Run2011AB/TripleBtagAnalysis_CR3_SF7_med");
  

  } else if (scenario == "MediumMass2012") {
    //intLumi = 3.99983; // in fb-1
    intLumi = 2.663;
    IgorScen.assign("medium");
    spacer.assign("/MEDIUM");
    //SashaPath.assign("Data-Run2011AB-Medium");
    SashaPath.assign("");
}
else {
    std::cout << "Bad scenario in packing" << std::endl;
    return;
  }
  string signalHistPattern("massEvBtag/mjjEvBTag_%s");
  if (L1L2Mode == "Weight") {
    signalHistPattern.assign("massEvBtagTW/mjjEvBTagTW_%s");
  }

  double fScal[nSignal][nbtag];
  
  // systematics
//   const int nSyst = 3;
//   std::string systName[nSyst] = { "JES", "SFbc", "SFudsg" };
//   bool realDataNuisance[nSyst] = { false, true, true }; // indicate if relevant for real data

  string bbPurity("DataDriven"); //  "MC", "DataDrivenR", "None"
  //string bbPurity("None"); //  "MC", "DataDrivenR", "None"

  bool onlineBtagCorr = true;

  int nSyst = 4;
  std::string systName[] = { "JES", "SFbc", "SFudsg", "JER" };
  bool realDataNuisance[] = { false, true, true, false }; // indicate if relevant for real data

  const int nUpDown = 2;
  std::string signalFile = "";

bool dosignal=true;


#if defined(MEDIUM2012)
dosignal=false;
nTCombData=1; ///only one trigger
//nSyst=0; /// no syst templates

#endif


  // signal templates
  if (IgorVersion != "V3") {
    std::cout << "Using signal files " << IgorVersion << std::endl;
    signalFile.assign( Form("%s/theMergeList-SUSYBBHToBB_M-%d_7TeV-pythia6-tauola%s/SF/job_1/TripleBtagAnalysisM-%d_%s.root",IgorPath.c_str(),signalMass[iMass],spacer.c_str(),signalMass[iMass],IgorScen.c_str() ) );
  } else {
    std::cout << "Using V3 signal files" << std::endl;
    signalFile.assign( Form("/data/user/marfin/CMSSW_5_0_1/src/Analysis/HbbMSSMAnalysis/test/Systematics-test-3/%s/theMergeList-SUSYBBHToBB_M-%d_7TeV-pythia6-tauola%s/SF/job_1/TripleBtagAnalysisM-%d_%s.root",signalMode.c_str(),signalMass[iMass],spacer.c_str(),signalMass[iMass],IgorScen.c_str() ) );
  }
  std::string signalSystFiles[nSyst][nUpDown];
  //bool activeNuisance[nSyst] = { true, true, true };
  std::string upDownName[nUpDown] = { "Up", "Down" };
  TH2F* hSignalSyst[nSyst][nUpDown][nbtag];

  // output file
  TFile* hout = new TFile(Form("packedTemplates-M-%d.root",signalMass[iMass]),"recreate");
  hout->cd();
  TH2::AddDirectory(true);

  TFile* fSig = new TFile( signalFile.c_str() );
  if ( fSig == NULL ) {
    std::cout << "Could not open signal central file " << signalFile.c_str() << std::endl;
    return;
  } else {
    std::cout << "Open signal file " << signalFile.c_str() << std::endl;
  }

  TH2F* hSignalCentral[nbtag];

  for (int ibtag=0; ibtag<nbtag; ++ibtag) {
    hSignalCentral[ibtag] = mergeSignal(fSig,Form(signalHistPattern.c_str(),sbtag[ibtag].c_str()),
					Form("bbH_%s",sbtag[ibtag].c_str()));
    // read the efficiency
    TH1F* histEffMerged = (TH1F*) fSig->Get(Form("TrigEff/EffMerged%s",sbtag[ibtag].c_str()));
    if ( histEffMerged == NULL) {
      std::cout << "Efficiency histo not found" << std::endl;
      return;
    }
    double newEff = histEffMerged->GetBinContent(1);
    std::cout << "Mass= " << signalMass[iMass] 
	      << " btag= " << sbtag[ibtag]
	      << " Efficiency = " << newEff << std::endl;
    efficiency[iMass][ibtag] = newEff;

    double normShould = 1000 * intLumi * efficiency[iMass][ibtag];
    double normIs = hSignalCentral[ibtag]->GetSumOfWeights();
    std::cout << hSignalCentral[ibtag]->GetName() << " TotalContents=" << hSignalCentral[ibtag]->GetSumOfWeights()
	      << std::endl;
    fScal[iMass][ibtag] = normShould / normIs;
    std::cout << "normShould = " << normShould << " normIs " << normIs
	      << " rescale by " << fScal[iMass][ibtag] << std::endl;
    hSignalCentral[ibtag]->Scale( fScal[iMass][ibtag] );
    hout->cd();
    hSignalCentral[ibtag]->Write();
    histEffMerged->Write();

    // create empty file just as marker
    ofstream markerFile;
    markerFile.open(Form("pack-%s-%s.txt",sbtag[ibtag].c_str(),scenario.c_str()),ios::app);
    markerFile << "Template for mass " << signalMass[iMass] << std::endl;
    markerFile.close();
  }

  // read the nominal cross section
  TH1F* histXSect = (TH1F*) fSig->Get("xsection/xsect");
  if ( histXSect == NULL) {
    std::cout << "xsection/xsect" << " not found" << std::endl;
    return;
  }
  histXSect->Write();

  for (int iSyst=0; iSyst<nSyst; ++iSyst) {
    for (int iUpDown=0; iUpDown<nUpDown; ++iUpDown) {
      if (IgorVersion != "V3") {
	signalSystFiles[iSyst][iUpDown] = Form( "%s/theMergeList-SUSYBBHToBB_M-%d_7TeV-pythia6-tauola%s/%s_Sys%s/job_1/TripleBtagAnalysisM-%d_%s.root",
						IgorPath.c_str(),signalMass[iMass],spacer.c_str(),systName[iSyst].c_str(),
						upDownName[iUpDown].c_str(),signalMass[iMass],IgorScen.c_str());
      } else {	
	signalSystFiles[iSyst][iUpDown] = Form( "/data/user/marfin/CMSSW_5_0_1/src/Analysis/HbbMSSMAnalysis/test/Systematics-test-3/%s/theMergeList-SUSYBBHToBB_M-%d_7TeV-pythia6-tauola%s/%s_Sys%s/job_1/TripleBtagAnalysisM-%d_%s.root",
						signalMode.c_str(),signalMass[iMass],spacer.c_str(),systName[iSyst].c_str(),
						upDownName[iUpDown].c_str(),signalMass[iMass],IgorScen.c_str());
      }
      std::cout << "Signal systematics file " << signalSystFiles[iSyst][iUpDown] << std::endl;
      TFile* fSigSys = new TFile( signalSystFiles[iSyst][iUpDown].c_str() );
      if ( fSigSys == NULL ) {
	std::cout << "Could not open signal syst file " << signalSystFiles[iSyst][iUpDown].c_str() << std::endl;
	return;
      }
      for (int ibtag=0; ibtag<nbtag; ++ibtag) {
	hSignalSyst[iSyst][iUpDown][ibtag] 
	  = mergeSignal(fSigSys,Form(signalHistPattern.c_str(),sbtag[ibtag].c_str()),
			Form("bbH_%s_%s_%s",systName[iSyst].c_str(),
			     upDownName[iUpDown].c_str(),sbtag[ibtag].c_str()));
	std::cout << "The merged hist has name " << hSignalSyst[iSyst][iUpDown][ibtag]->GetName() << std::endl;
	std::cout << hSignalSyst[iSyst][iUpDown][ibtag]->GetName() << " TotalContents=" << hSignalSyst[iSyst][iUpDown][ibtag]->GetSumOfWeights()
		  << std::endl;
	
	hSignalSyst[iSyst][iUpDown][ibtag]->Scale( fScal[iMass][ibtag] );
	hout->cd();
	hSignalSyst[iSyst][iUpDown][ibtag]->Write();
      }
      fSigSys->Close();
    }
  }

  // real data
  std::string backgroundFile( Form("/afs/naf.desy.de/user/r/rmankel/scratch/HbbPat/CMSSW_4_2_4_patch1/src/Analysis/HbbMSSMAnalysis/test/results/v1/%s/TripleBtagAnalysis_SF/TripleBtagAnalysis.root",SashaPath.c_str()) );

#if defined(MEDIUM2012)
//bool dosignal=true;
//backgroundFile = std::string("/data/user/marfin/CMSSW_5_3_3/src/Analysis/HbbMSSMAnalysis/test/Analysis2012/MVA-production-selection-trees/TripleBtagAnalysis.root");
backgroundFile = std::string("/data/user/marfin/CMSSW_5_3_3/src/Analysis/HbbMSSMAnalysis/test/Analysis2012/Blind-test-BG-only-Fit/MEDIUM/TripleBtagAnalysis_SF/TripleBtagAnalysis.root");
#endif


  std::cout << "Background central file : " << backgroundFile << std::endl;
  TFile* fBac = new TFile( backgroundFile.c_str() );
  if ( fBac == NULL ) {
    std::cout << "Could not open background central file " << signalFile.c_str() << std::endl;
    return;
  }

  // hist-to-be-fitted
  TH2F* mjjEbtdata[nbtag];
  for (int ibtag=0; ibtag<nbtag; ++ibtag) {
    mjjEbtdata[ibtag] = getTrigsAndMerge(fBac,Form("massEvBtag/mjjEvBTag_%s",sbtag[ibtag].c_str()),nTCombData,tCombData);

    if (mjjEbtdata[ibtag] == NULL) {
      std::cout << "Histogram not found: " << Form("massEvBtag/mjjEvBTag_%s",sbtag[ibtag].c_str()) << std::endl;
      return;
    }
    // rename
    mjjEbtdata[ibtag]->SetName( Form("Data_%s",sbtag[ibtag].c_str() ) );
    hout->cd();
    mjjEbtdata[ibtag]->Write();
  }

  TH2F* hBackgroundCentral[nbtag][ncateg][nfc];
  TH2F* hBackgroundCentralError[nbtag][ncateg][nfc];
  for (int ibtag=0; ibtag<nbtag; ++ibtag) {
    for (int icateg=0; icateg<ncateg; ++icateg) {
      int theTpat;
      if (onlineBtagCorr) {
	theTpat = 3;
      } else {
	theTpat = icateg;
      }

      for (int ifc=0; ifc<nfc; ++ifc) {
	string templateCore("massBTagTemplatesCld/MassBTagTemplateCld");
	if (bbPurity == "None") {
	   templateCore.assign("massBTagTemplatesCld/MassBTagTemplateUncld");
	}
	string hbSystName( Form("%s_%s_%s_Cat%dTpat%d",templateCore.c_str(),
				sfc[ifc].c_str(),sbtag[ibtag].c_str(),icateg,theTpat) );
	hBackgroundCentral[ibtag][icateg][ifc] = getTrigsAndMerge(fBac,Form("%s_%s_%s_Cat%dTpat%d",
									   templateCore.c_str(),
									   sfc[ifc].c_str(),
									   sbtag[ibtag].c_str(),icateg,theTpat),nTCombData,tCombData);

	if ( hBackgroundCentral[ibtag][icateg][ifc] == NULL ) {
	  std::cout << "Hist not found: " << hbSystName << std::endl;
	  return;
	}
	// rename
	templateId tName(ifc,icateg);
	hBackgroundCentral[ibtag][icateg][ifc]->SetName( Form("%s_%s",tName.name().c_str(),sbtag[ibtag].c_str()) );
	// read the template errors
	templateCore.assign("errorMassBTagTemplates/ErrorMassBTagTemplate");
	string hbSystNameError( Form("%s_%s_%s_Cat%dTpat%d",templateCore.c_str(),
				sfc[ifc].c_str(),sbtag[ibtag].c_str(),icateg,theTpat) );
	hBackgroundCentralError[ibtag][icateg][ifc] 
	  = getTrigsAndMerge(fBac,Form("%s_%s_%s_Cat%dTpat%d",
				       templateCore.c_str(),
				       sfc[ifc].c_str(),
				       sbtag[ibtag].c_str(),icateg,theTpat),nTCombData,tCombData);
	if ( hBackgroundCentralError[ibtag][icateg][ifc] == NULL ) {
	  std::cout << "Hist not found: " << hbSystNameError << std::endl;
	  return;
	}
	if (useTemplateError) {
	  // add the template error
	  std::cout << " ==== Adding Btag Errors ==== " << hBackgroundCentral[ibtag][icateg][ifc]->GetName() << std::endl;
	  for (int ibinx=1; ibinx<= (hBackgroundCentral[ibtag][icateg][ifc]->GetXaxis()->GetNbins()); ++ibinx) {
	    for (int ibiny=1; ibiny<= (hBackgroundCentral[ibtag][icateg][ifc]->GetYaxis()->GetNbins()); ++ibiny) {
	      float oldError = hBackgroundCentral[ibtag][icateg][ifc]->GetBinError(ibinx,ibiny);
	      float addError = hBackgroundCentralError[ibtag][icateg][ifc]->GetBinContent(ibinx,ibiny);
	      float newError = sqrt( oldError * oldError + addError * addError );
	      hBackgroundCentral[ibtag][icateg][ifc]->SetBinError(ibinx,ibiny,newError);
	    }
	  }
	}
	hout->cd();
	hBackgroundCentral[ibtag][icateg][ifc]->Write();
      }
    }
  }



  std::string backgroundSystFiles[nSyst][nUpDown];
  std::string systNameSasha[] = { "JES", "SFbc", "SFq" };
  std::string upDownNameSasha[nUpDown] = { "plus2", "minus2" };
  TH2F* hBackgroundSyst[nSyst][nUpDown][nbtag][ncateg][nfc];
  TH2F* hBackgroundSystError[nSyst][nUpDown][nbtag][ncateg][nfc];

//#if !defined(MEDIUM2012)

  // for nuisances like JEC, the up/down templates are just copies of the central templates
  for (int iSyst=0; iSyst<nSyst; ++iSyst) {
    if (! realDataNuisance[iSyst]) {
      std::cout << "Non-real data relevant nuisance: " << systName[iSyst].c_str() << std::endl;
      for (int iUpDown=0; iUpDown<nUpDown; ++iUpDown) {
	for (int ibtag=0; ibtag<nbtag; ++ibtag) {
	  for (int icateg=0; icateg<ncateg; ++icateg) {
	    for (int ifc=0; ifc<nfc; ++ifc) {
	      hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]
		= new TH2F( *hBackgroundCentral[ibtag][icateg][ifc] );
	      // rename
	      templateId tName(ifc,icateg);
	      hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]
		->SetName( Form("%s_%s_%s_%s",
				tName.name().c_str(),systName[iSyst].c_str(),
				upDownName[iUpDown].c_str(),sbtag[ibtag].c_str()) );
	      hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]->Write();
	    }
	  }
	}
      }
    }
  }
//#endif

  fBac->Close();


  for (int iSyst=0; iSyst<nSyst; ++iSyst) {
    if (realDataNuisance[iSyst]) {
      std::cout << "Real data relevant nuisance: " << systName[iSyst].c_str() << std::endl;
      for (int iUpDown=0; iUpDown<nUpDown; ++iUpDown) {
//	backgroundSystFiles[iSyst][iUpDown] = Form( "/afs/naf.desy.de/user/r/rmankel/scratch/HbbPat/CMSSW_4_2_4_patch1/src/Analysis/HbbMSSMAnalysis/test/results/v1/%s/TripleBtagAnalysis_%s%s/TripleBtagAnalysis.root",SashaPath.c_str(),systNameSasha[iSyst].c_str(),upDownNameSasha[iUpDown].c_str() );
	backgroundSystFiles[iSyst][iUpDown] = Form( "/data/user/marfin/CMSSW_5_3_3/src/Analysis/HbbMSSMAnalysis/test/Analysis2012/Blind-test-BG-only-Fit/MEDIUM/TripleBtagAnalysis_%s%s/TripleBtagAnalysis.root",systNameSasha[iSyst].c_str(),upDownNameSasha[iUpDown].c_str() );
	TFile* fBacSys = new TFile( backgroundSystFiles[iSyst][iUpDown].c_str() );
	std::cout << "Background systematics file " << backgroundSystFiles[iSyst][iUpDown] << std::endl;
	if ( fBacSys == NULL ) {
	  std::cout << "Could not open background syst file " << backgroundSystFiles[iSyst][iUpDown] << std::endl;
	  return;
	}
	for (int ibtag=0; ibtag<nbtag; ++ibtag) {
	  for (int icateg=0; icateg<ncateg; ++icateg) {
	    int theTpat;
	    if (onlineBtagCorr) {
	      theTpat = 3;
	    } else {
	      theTpat = icateg;
	    }

	    for (int ifc=0; ifc<nfc; ++ifc) {
	      string templateCore("massBTagTemplatesCld/MassBTagTemplateCld");
	      if (bbPurity == "None") {
		templateCore.assign("massBTagTemplatesCld/MassBTagTemplateUncld");
	      }
	      string hbSystName( Form("%s_%s_%s_Cat%dTpat%d",templateCore.c_str(),
				      sfc[ifc].c_str(),sbtag[ibtag].c_str(),icateg,theTpat) );
	      hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc] 
		= getTrigsAndMerge(fBacSys,Form("%s_%s_%s_Cat%dTpat%d",
						templateCore.c_str(),
						sfc[ifc].c_str(),
						sbtag[ibtag].c_str(),icateg,theTpat),nTCombData,tCombData);
	      if ( hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc] == NULL ) {
		std::cout << "Hist not found: " << hbSystName << std::endl;
		return;
	      }
	      // rename
	      templateId tName(ifc,icateg);
	      hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]
		->SetName( Form("%s_%s_%s_%s",
				tName.name().c_str(),systName[iSyst].c_str(),
				upDownName[iUpDown].c_str(),sbtag[ibtag].c_str()) );
	      
	      // read template errors
	      templateCore.assign("errorMassBTagTemplates/ErrorMassBTagTemplate");
	      string hbSystNameError( Form("%s_%s_%s_Cat%dTpat%d",templateCore.c_str(),
					   sfc[ifc].c_str(),sbtag[ibtag].c_str(),icateg,theTpat) );
	      hBackgroundSystError[iSyst][iUpDown][ibtag][icateg][ifc] 
		= getTrigsAndMerge(fBacSys,Form("%s_%s_%s_Cat%dTpat%d",
						templateCore.c_str(),
						sfc[ifc].c_str(),
						sbtag[ibtag].c_str(),icateg,theTpat),nTCombData,tCombData);
	      if ( hBackgroundSystError[iSyst][iUpDown][ibtag][icateg][ifc] == NULL ) {
		std::cout << "Hist not found: " << hbSystNameError << std::endl;
		return;
	      }
	      if (useTemplateError) {
		// add the template error
		std::cout << " ==== ErrorAdd ==== " << hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]->GetName() << std::endl;
		for (int ibinx=1; ibinx<= (hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]->GetXaxis()->GetNbins()); ++ibinx) {
		  for (int ibiny=1; ibiny<= (hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]->GetYaxis()->GetNbins()); ++ibiny) {
		    float oldError = hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]->GetBinError(ibinx,ibiny);
		    float addError = hBackgroundSystError[iSyst][iUpDown][ibtag][icateg][ifc]->GetBinContent(ibinx,ibiny);
		    float newError = sqrt( oldError * oldError + addError * addError );
		    hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]->SetBinError(ibinx,ibiny,newError);
		  }
		}
	      }
	      hout->cd();
	      hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]->Write();
	    }
	  }
	}
	fBacSys->Close();
      }
    }
  }

  std::cout << "Everything done " << std::endl;

#ifdef PROJECTIONS

TFile * projections_out=TFile::Open("projections.root","RECREATE");

  // loop over background templates
  //TH1D* bgProX[nbtag][ncateg][nfc];
  TH1D* bgSystProX[nSyst][nUpDown][nbtag][ncateg][nfc];
  for (int ibtag=0; ibtag<nbtag; ++ibtag) {
    for (int icateg=0; icateg<ncateg; ++icateg) {
      for (int ifc=0; ifc<nfc; ++ifc) {
	TH2F* theTemp = hBackgroundCentral[ibtag][icateg][ifc];
	TH1D* theTempProX = theTemp->ProjectionX(Form("%sProX",theTemp->GetName()),0,-1,"e");
	theTempProX->SetName( Form("%sProX",theTemp->GetName()) );
	TH1D* theTempProY = theTemp->ProjectionY(Form("%sProY",theTemp->GetName()),0,-1,"e");
	std::cout << "Made projection " << theTempProX->GetName() << std::endl;

	if ( (icateg == 0) && (ifc == 0) ) {
	  for (int ibinx=1; ibinx<= theTempProX->GetXaxis()->GetNbins(); ++ibinx) {
	    std::cout << ibinx << " content " << theTempProX->GetBinContent(ibinx)
		      << " error " << theTempProX->GetBinError(ibinx) << std::endl;
	  }
	}
	theTempProX->SetMarkerStyle(20);
	theTempProX->SetMarkerColor(1);
	theTempProX->SetLineColor(1);
	theTempProX->SetMarkerSize(1);
	std::cout << "Draw" << std::endl;
	theTempProX->Draw("EP");
	theTempProX->Write();






	//theTempProX->Draw("LP,SAME");
	// draw the SFbc systematics
	int colSyst[3] = {1, 2, 4};
	int lstyleUpDown[2] = {1, 1};
	for (int iSyst=1; iSyst<nSyst; ++iSyst) {
	  for (int iUpDown=0; iUpDown<nUpDown; ++iUpDown) {
	    bgSystProX[iSyst][iUpDown][ibtag][icateg][ifc] =  hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]->ProjectionX(Form("%sProXX",hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]->GetName()),0,-1,"e");
	    bgSystProX[iSyst][iUpDown][ibtag][icateg][ifc]->SetName( Form("%sProXX",hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc]->GetName()) );
	    std::cout << "Made projection " << bgSystProX[iSyst][iUpDown][ibtag][icateg][ifc]->GetName() << std::endl;
	     bgSystProX[iSyst][iUpDown][ibtag][icateg][ifc]->SetLineColor( colSyst[iSyst] );
	     bgSystProX[iSyst][iUpDown][ibtag][icateg][ifc]->Draw("HIST,SAME");
		 bgSystProX[iSyst][iUpDown][ibtag][icateg][ifc]->Write();


// 	    TH2F* theTemp = hBackgroundSyst[iSyst][iUpDown][ibtag][icateg][ifc];
// 	    TH1D* theTempProX = theTemp->ProjectionX(Form("%sProX",theTemp->GetName()),0,-1,"e");
// 	    theTempProX->SetLineColor( colSyst[iSyst] );
// 	    TH1D* theTempProY = theTemp->ProjectionY(Form("%sProY",theTemp->GetName()),0,-1,"e");
// 	    theTempProY->SetLineColor( colSyst[iSyst] );
// 	    //theTempProX->Draw("HIST");
	  }
	}

	canvas->Print(Form("Template_%s_%s_Cat%d_ProX.png",sbtag[ibtag].c_str(),sfc[ifc].c_str(),icateg));


	theTempProY->SetMarkerStyle(20);
	theTempProY->SetMarkerColor(1);
	theTempProY->SetLineColor(1);
	theTempProY->SetMarkerSize(1);
	std::cout << "Draw" << std::endl;
	theTempProY->Draw("EP");
	theTempProY->Write();


      }
    }
  }

projections_out->Write();
projections_out->Close();



#endif

  hout->Write();
  hout->Close();

  // close the signal central file
  fSig->Close();

  return;
}
void makePlots_hltEleHT_TTcr( bool printPDF_ = false, int useSample_ = 0 ){

  TH1::SetDefaultSumw2();

  int NumSamples = 3;
  TFile* file[NumSamples];
  file[0] = new TFile("HistoFiles/hltEleHT_treeReader_TTcr_TT_13TeV_Spring15_Asympt25ns_histo.root");
  file[1] = new TFile("HistoFiles/hltEleHT_treeReader_TTcr_ttHTobb_M125_13TeV_powheg_pythia8_Spring15_Asympt25ns_histo.root");
  file[2] = new TFile("HistoFiles/hltEleHT_treeReader_TTcr_SingleElectron_Run2015D_PromptReco_254231_258158_histo.root");

  std::vector<TString> histLabels(NumSamples);
  histLabels[0] = "TTJets";
  histLabels[1] = "ttHTobb";
  histLabels[2] = "Data";

  Color_t color[5];
  color[0] = kBlack;
  color[1] = kBlue;
  color[2] = kRed;
  color[3] = kGreen+1;

  // color[2] = kBlack;
  // color[3] = kGreen+1;
  // color[4] = kMagenta+2;
  // color[5] = kRed+1;
  // color[6] = kGreen-5;
  // color[7] = kRed+3;

  std::vector<std::vector<int> > projection_start_bins;
  std::vector<std::vector<int> > projection_end_bins;
  std::vector<std::vector<TString> > projection_labels;

  // elePt
  std::vector<int> proj_elePt_start_bins;
  proj_elePt_start_bins.push_back(1);
  proj_elePt_start_bins.push_back(4);
  proj_elePt_start_bins.push_back(6);
  proj_elePt_start_bins.push_back(7);

  std::vector<int> proj_elePt_end_bins;
  proj_elePt_end_bins.push_back(12);
  proj_elePt_end_bins.push_back(5);
  proj_elePt_end_bins.push_back(8);
  proj_elePt_end_bins.push_back(12);

  std::vector<TString> proj_elePt_labels;
  proj_elePt_labels.push_back("elePt30toInf");
  proj_elePt_labels.push_back("elePt30to50");
  proj_elePt_labels.push_back("elePt50to80");
  proj_elePt_labels.push_back("elePt80toInf");

  // numJet
  std::vector<int> proj_numJet_start_bins;
  proj_numJet_start_bins.push_back(1);
  proj_numJet_start_bins.push_back(1);
  proj_numJet_start_bins.push_back(4);
  proj_numJet_start_bins.push_back(5);

  std::vector<int> proj_numJet_end_bins;
  proj_numJet_end_bins.push_back(8);
  proj_numJet_end_bins.push_back(3);
  proj_numJet_end_bins.push_back(4);
  proj_numJet_end_bins.push_back(8);

  std::vector<TString> proj_numJet_labels;
  proj_numJet_labels.push_back("numJet0toInf");
  proj_numJet_labels.push_back("numJet0to2");
  proj_numJet_labels.push_back("numJet3to3");
  proj_numJet_labels.push_back("numJet4toInf");


  projection_start_bins.push_back(proj_elePt_start_bins);
  projection_end_bins.push_back(proj_elePt_end_bins);
  projection_labels.push_back(proj_elePt_labels);

  projection_start_bins.push_back(proj_numJet_start_bins);
  projection_end_bins.push_back(proj_numJet_end_bins);
  projection_labels.push_back(proj_numJet_labels);

  projection_start_bins.push_back(proj_elePt_start_bins);
  projection_end_bins.push_back(proj_elePt_end_bins);
  projection_labels.push_back(proj_elePt_labels);

  projection_start_bins.push_back(proj_elePt_start_bins);
  projection_end_bins.push_back(proj_elePt_end_bins);
  projection_labels.push_back(proj_elePt_labels);

  std::vector<int> NumProjBins;
  NumProjBins.push_back( int(proj_elePt_labels.size()) );
  NumProjBins.push_back( int(proj_numJet_labels.size()) );
  NumProjBins.push_back( int(proj_elePt_labels.size()) );
  NumProjBins.push_back( int(proj_elePt_labels.size()) );



  TString dirprefix = "Images/Images_2015_10_13_hltEleHT_TTcr_" + histLabels[useSample_] + "/";

  struct stat st;
  if( stat(dirprefix.Data(),&st) != 0 )  mkdir(dirprefix.Data(),0777);


 /////////////////////////////////////////////////////////////////////////////////////////////////////////////

  std::vector<std::string> histoname1;
  std::vector<std::string> histoname2;
  std::vector<std::string> histoname3;

  histoname1.push_back("h_HT30");
  histoname1.push_back("h_HT30er");
  histoname1.push_back("h_HT30_4j");

  histoname2.push_back("elePt");
  histoname2.push_back("numJet");
  histoname2.push_back("eleEBPt");
  histoname2.push_back("eleEEPt");


  histoname3.push_back("h_event_selection");


 /////////////////////////////////////////////////////////////////////////////////////////////////////////////

  TGaxis::SetMaxDigits(3);

  TString lumiinfo = "553 pb^{-1} (13 TeV)";
  TLatex LumiInfoLatex(0.65, 0.94, lumiinfo);
  LumiInfoLatex.SetNDC(); LumiInfoLatex.SetTextFont(42);
  LumiInfoLatex.SetTextSize(0.04);

  //TString cmsinfo =   "CMS Preliminary";
  TString cmsinfo =   "CMS";
  TLatex CMSInfoLatex(0.13, 0.94, cmsinfo);
  CMSInfoLatex.SetNDC(); CMSInfoLatex.SetTextFont(42);
  CMSInfoLatex.SetTextFont(61);
  CMSInfoLatex.SetTextSize(0.055); //SBOUTLE

  std::string publishinfo =   "Preliminary"; //DPUIGH
  TLatex PublishInfoLatex(0.26, 0.94, publishinfo.c_str()); //SBOUTLE
  PublishInfoLatex.SetNDC();
  PublishInfoLatex.SetTextFont(52);
  PublishInfoLatex.SetTextSize(0.045); //SBOUTLE


  TString plotname;

  TCanvas* c1 = new TCanvas("c1", "c1", 600,700);


  TH2D* h_L1HTT_elePt = (TH2D*)file[useSample_]->Get("h_L1HTT_elePt");
  TH2D* h_HT30_HT30er = (TH2D*)file[useSample_]->Get("h_HT30_HT30er");
  TH2D* h_HT30_L1HTT = (TH2D*)file[useSample_]->Get("h_HT30_L1HTT");

  TProfile* p_L1HTT_elePt = (TProfile*)h_L1HTT_elePt->ProfileX("p_L1HTT_elePt");
  // TProfile* p_HT30_HT30er = (TProfile*)h_HT30_HT30er->ProfileX("p_HT30_HT30er");
  // TProfile* p_HT30_L1HTT = (TProfile*)h_HT30_L1HTT->ProfileX("p_HT30_L1HTT");

  p_L1HTT_elePt->SetMarkerStyle(20);

  h_L1HTT_elePt->Draw("colz");
  p_L1HTT_elePt->Draw("pe1same");
  plotname = dirprefix + "h_L1HTT_elePt" + "_2D_colz.png";
  c1->Print(plotname);

  h_HT30_HT30er->Draw("colz");
  //p_HT30_HT30er->Draw("pe1same");
  plotname = dirprefix + "h_HT30_HT30er" + "_2D_colz.png";
  c1->Print(plotname);

  h_HT30_L1HTT->Draw("colz");
  //p_HT30_L1HTT->Draw("pe1same");
  plotname = dirprefix + "h_HT30_L1HTT" + "_2D_colz.png";
  c1->Print(plotname);


  for( int i=0; i<int(histoname1.size()); i++ ){

    for( int j=0; j<int(histoname2.size()); j++ ){

      for( int k=0; k<2; k++ ){

	TString temp = histoname1[i];

	TString suffix = histoname2[j];

	TString l1suffix = ( k==0 ) ? "125" : "100";

	if( temp!="h_HT30" && suffix!="elePt" ) continue;

	TString temp_L1 = temp + "_L1HTT" + l1suffix + "_" + suffix;
	TString temp_HLT = temp + "_L1HTT" + l1suffix + "_passHLTEle27HT200_" + suffix;

	TString temp_mh = temp;
	temp_mh.ReplaceAll("h_","");


	temp = temp + "_" + suffix;

	//TLegend *legend = new TLegend(0.2,0.83,0.9,0.89);
	TLegend *legend = new TLegend(0.2,0.85,0.9,0.91);

	legend->SetFillColor(kWhite);
	legend->SetLineColor(kWhite);
	legend->SetShadowColor(kWhite);
	legend->SetTextFont(42);
	legend->SetTextSize(0.04);

	legend->SetNColumns(2);

	int rebin = ( useSample_==2 ) ? 25 : 10;


	TH2D* h_all = (TH2D*)file[useSample_]->Get(temp)->Clone(temp+"_"+suffix+"_"+l1suffix);
	TH2D* h_l1t = (TH2D*)file[useSample_]->Get(temp_L1)->Clone(temp_L1+"_"+suffix+"_"+l1suffix);
	TH2D* h_hlt = (TH2D*)file[useSample_]->Get(temp_HLT)->Clone(temp_HLT+"_"+suffix+"_"+l1suffix);


	TH2D* h_temp_hlt_all = (TH2D*)h_all->Clone("h_temp_hlt_all_"+suffix+"_"+l1suffix);
	TH2D* h_temp_l1t_all = (TH2D*)h_all->Clone("h_temp_l1t_all_"+suffix+"_"+l1suffix);
	TH2D* h_temp_hlt_l1t = (TH2D*)h_l1t->Clone("h_temp_hlt_l1t_"+suffix+"_"+l1suffix);

	TH2D* h_ratio_hlt_all = (TH2D*)h_hlt->Clone("h_ratio_hlt_all_"+suffix+"_"+l1suffix);
	TH2D* h_ratio_l1t_all = (TH2D*)h_l1t->Clone("h_ratio_l1t_all_"+suffix+"_"+l1suffix);
	TH2D* h_ratio_hlt_l1t = (TH2D*)h_hlt->Clone("h_ratio_hlt_l1t_"+suffix+"_"+l1suffix);

	h_temp_hlt_all->RebinY(rebin);
	h_temp_l1t_all->RebinY(rebin);
	h_temp_hlt_l1t->RebinY(rebin);

	h_ratio_hlt_all->RebinY(rebin);
	h_ratio_l1t_all->RebinY(rebin);
	h_ratio_hlt_l1t->RebinY(rebin);

	h_ratio_hlt_all->Divide(h_temp_hlt_all);
	h_ratio_l1t_all->Divide(h_temp_l1t_all);
	h_ratio_hlt_l1t->Divide(h_temp_hlt_l1t);


	TProfile* p_all = (TProfile*)h_all->ProfileX("p_all");
	TProfile* p_l1t = (TProfile*)h_l1t->ProfileX("p_l1t");
	TProfile* p_hlt = (TProfile*)h_hlt->ProfileX("p_hlt");

	p_all->SetMarkerStyle(20);
	p_l1t->SetMarkerStyle(20);
	p_hlt->SetMarkerStyle(20);

	h_all->Draw("colz");
	p_all->Draw("pe1same");
	plotname = dirprefix + temp + "_2D_colz.png";
	c1->Print(plotname);

	h_l1t->Draw("colz");
	p_l1t->Draw("pe1same");
	plotname = dirprefix + temp_L1 + "_2D_colz.png";
	c1->Print(plotname);

	h_hlt->Draw("colz");
	p_hlt->Draw("pe1same");
	plotname = dirprefix + temp_HLT + "_2D_colz.png";
	c1->Print(plotname);



	h_ratio_hlt_all->SetStats(0);
	h_ratio_hlt_all->GetYaxis()->SetRangeUser(0.,400.);
	h_ratio_hlt_all->Draw("colz");
	plotname = dirprefix + "h_ratio_hlt_all" + "_2D_colz.png";
	c1->Print(plotname);

	h_ratio_l1t_all->SetStats(0);
	h_ratio_l1t_all->GetYaxis()->SetRangeUser(0.,400.);
	h_ratio_l1t_all->Draw("colz");
	plotname = dirprefix + "h_ratio_l1t_all" + "_2D_colz.png";
	c1->Print(plotname);

	h_ratio_hlt_l1t->SetStats(0);
	h_ratio_hlt_l1t->GetYaxis()->SetRangeUser(0.,400.);
	h_ratio_hlt_l1t->Draw("colz");
	plotname = dirprefix + "h_ratio_hlt_l1t" + "_2D_colz.png";
	c1->Print(plotname);

	int numProjBin = NumProjBins[j];

	TH1D* h_py_all[numProjBin];
	TH1D* h_py_l1t[numProjBin];
	TH1D* h_py_hlt[numProjBin];

	TEfficiency* eff_hlt_all[numProjBin];
	TEfficiency* eff_l1t_all[numProjBin];
	TEfficiency* eff_hlt_l1t[numProjBin];

	for( int iBin=0; iBin<numProjBin; iBin++ ){

	  int bin_start = projection_start_bins[j][iBin];
	  int bin_end   = projection_end_bins[j][iBin];
	  h_py_all[iBin] = (TH1D*)h_all->ProjectionY(Form("h_py_all_%d",iBin),bin_start,bin_end);
	  h_py_l1t[iBin] = (TH1D*)h_l1t->ProjectionY(Form("h_py_l1t_%d",iBin),bin_start,bin_end);
	  h_py_hlt[iBin] = (TH1D*)h_hlt->ProjectionY(Form("h_py_hlt_%d",iBin),bin_start,bin_end);

	  h_py_all[iBin]->Rebin(rebin);
	  h_py_l1t[iBin]->Rebin(rebin);
	  h_py_hlt[iBin]->Rebin(rebin);

	  eff_l1t_all[iBin] = makeEfficiency(h_py_l1t[iBin], h_py_all[iBin]);
	  eff_hlt_l1t[iBin] = makeEfficiency(h_py_hlt[iBin], h_py_l1t[iBin]);
	  eff_hlt_all[iBin] = makeEfficiency(h_py_hlt[iBin], h_py_all[iBin]);

	  eff_l1t_all[iBin]->SetLineColor(color[iBin]);
	  eff_l1t_all[iBin]->SetMarkerColor(color[iBin]);
	  eff_l1t_all[iBin]->SetMarkerStyle(20);

	  eff_hlt_l1t[iBin]->SetLineColor(color[iBin]);
	  eff_hlt_l1t[iBin]->SetMarkerColor(color[iBin]);
	  eff_hlt_l1t[iBin]->SetMarkerStyle(20);

	  eff_hlt_all[iBin]->SetLineColor(color[iBin]);
	  eff_hlt_all[iBin]->SetMarkerColor(color[iBin]);
	  eff_hlt_all[iBin]->SetMarkerStyle(20);

	  legend->AddEntry(eff_l1t_all[iBin], projection_labels[j][iBin],"pe1");
	}



	h_py_all[0]->SetStats(0);
	h_py_all[0]->GetYaxis()->SetTitle("Efficiency");

	h_py_all[0]->GetYaxis()->SetRangeUser(0.,1.15);
	h_py_all[0]->GetXaxis()->SetRangeUser(0.,600.);
	// h_data_all->SetStats(0);

	c1->SetTopMargin(.07);
	c1->SetRightMargin(.05);

	// h_data_all->GetYaxis()->SetTitleOffset(1.0);
	// h_data_all->GetYaxis()->SetTitleSize(0.05);

	// h_data_all->GetYaxis()->SetRangeUser(0.,1.15);
	// if( temp.Contains("_pt") ){
	//   h_data_all->GetXaxis()->SetRangeUser(0.,150.);
	//   myRatio->GetXaxis()->SetRangeUser(0.,150.);
	// }


	//// l1t_all
	h_py_all[0]->Draw("axis");
	for( int iBin=0; iBin<numProjBin; iBin++ ) eff_l1t_all[iBin]->Draw("pe1same");
	legend->Draw();
	LumiInfoLatex.Draw();
	CMSInfoLatex.Draw();
	PublishInfoLatex.Draw();

	plotname = dirprefix + temp_mh + "_"+suffix+"_l1t" + l1suffix + "_all_lin.png";
	c1->Print(plotname);

	plotname = dirprefix + temp_mh + "_"+suffix+"_l1t" + l1suffix + "_all_lin.pdf";
	if( printPDF_ ) c1->Print(plotname);


	//// hlt_all
	h_py_all[0]->Draw("axis");
	for( int iBin=0; iBin<numProjBin; iBin++ ) eff_hlt_all[iBin]->Draw("pe1same");
	legend->Draw();
	LumiInfoLatex.Draw();
	CMSInfoLatex.Draw();
	PublishInfoLatex.Draw();

	plotname = dirprefix + temp_mh + "_"+suffix+"_hlt_l1t" + l1suffix + "_all_lin.png";
	c1->Print(plotname);

	plotname = dirprefix + temp_mh + "_"+suffix+"_hlt_l1t" + l1suffix + "_all_lin.pdf";
	if( printPDF_ ) c1->Print(plotname);


	//// hlt_l1t
	h_py_all[0]->Draw("axis");
	for( int iBin=0; iBin<numProjBin; iBin++ ) eff_hlt_l1t[iBin]->Draw("pe1same");
	legend->Draw();
	LumiInfoLatex.Draw();
	CMSInfoLatex.Draw();
	PublishInfoLatex.Draw();

	plotname = dirprefix + temp_mh + "_"+suffix+"_hlt_l1t" + l1suffix + "_lin.png";
	c1->Print(plotname);

	plotname = dirprefix + temp_mh + "_"+suffix+"_hlt_l1t" + l1suffix + "_lin.pdf";
	if( printPDF_ ) c1->Print(plotname);




	h_py_all[0]->GetYaxis()->SetRangeUser(0.85,1.15);



	//// l1t_all
	h_py_all[0]->Draw("axis");
	for( int iBin=0; iBin<numProjBin; iBin++ ) eff_l1t_all[iBin]->Draw("pe1same");
	legend->Draw();
	LumiInfoLatex.Draw();
	CMSInfoLatex.Draw();
	PublishInfoLatex.Draw();

	plotname = dirprefix + temp_mh + "_"+suffix+"_l1t" + l1suffix + "_all_lin_zoom.png";
	c1->Print(plotname);

	plotname = dirprefix + temp_mh + "_"+suffix+"_l1t" + l1suffix + "_all_lin_zoom.pdf";
	if( printPDF_ ) c1->Print(plotname);


	//// hlt_all
	h_py_all[0]->Draw("axis");
	for( int iBin=0; iBin<numProjBin; iBin++ ) eff_hlt_all[iBin]->Draw("pe1same");
	legend->Draw();
	LumiInfoLatex.Draw();
	CMSInfoLatex.Draw();
	PublishInfoLatex.Draw();

	plotname = dirprefix + temp_mh + "_"+suffix+"_hlt_l1t" + l1suffix + "_all_lin_zoom.png";
	c1->Print(plotname);

	plotname = dirprefix + temp_mh + "_"+suffix+"_hlt_l1t" + l1suffix + "_all_lin_zoom.png";
	if( printPDF_ ) c1->Print(plotname);


	//// hlt_l1t
	h_py_all[0]->Draw("axis");
	for( int iBin=0; iBin<numProjBin; iBin++ ) eff_hlt_l1t[iBin]->Draw("pe1same");
	legend->Draw();
	LumiInfoLatex.Draw();
	CMSInfoLatex.Draw();
	PublishInfoLatex.Draw();

	plotname = dirprefix + temp_mh + "_"+suffix+"_hlt_l1t" + l1suffix + "_lin_zoom.png";
	c1->Print(plotname);

	plotname = dirprefix + temp_mh + "_"+suffix+"_hlt_l1t" + l1suffix + "_lin_zoom.pdf";
	if( printPDF_ ) c1->Print(plotname);


	delete legend;
      } // end loop on hists
    }
  }


  if( true ){

    TString temp = "h_HT30";

    TString temp_L1 = temp + "_L1HTT125";
    TString temp_HLT = temp + "_L1HTT125_passHLTEle27HT200";

    TString temp_mh = temp;
    temp_mh.ReplaceAll("h_","");

    //TLegend *legend = new TLegend(0.2,0.83,0.9,0.89);
    TLegend *legend = new TLegend(0.2,0.87,0.85,0.91);

    legend->SetFillColor(kWhite);
    legend->SetLineColor(kWhite);
    legend->SetShadowColor(kWhite);
    legend->SetTextFont(42);
    legend->SetTextSize(0.04);

    legend->SetNColumns(3);

    int rebin = 25;

    TH1D* h_all[NumSamples];
    TH1D* h_l1t[NumSamples];
    TH1D* h_hlt[NumSamples];

    TEfficiency* eff_hlt_all[NumSamples];
    TEfficiency* eff_l1t_all[NumSamples];
    TEfficiency* eff_hlt_l1t[NumSamples];

    for( int iSample=0; iSample<NumSamples; iSample++ ){
      h_all[iSample] = (TH1D*)file[iSample]->Get(temp.Data())->Clone(Form("%s_%s",temp.Data(),histLabels[iSample].Data()));
      h_l1t[iSample] = (TH1D*)file[iSample]->Get(temp_L1.Data())->Clone(Form("%s_%s",temp.Data(),histLabels[iSample].Data()));
      h_hlt[iSample] = (TH1D*)file[iSample]->Get(temp_HLT.Data())->Clone(Form("%s_%s",temp.Data(),histLabels[iSample].Data()));

      h_all[iSample]->Rebin(rebin);
      h_l1t[iSample]->Rebin(rebin);
      h_hlt[iSample]->Rebin(rebin);

      eff_l1t_all[iSample] = makeEfficiency(h_l1t[iSample], h_all[iSample]);
      eff_hlt_l1t[iSample] = makeEfficiency(h_hlt[iSample], h_l1t[iSample]);
      eff_hlt_all[iSample] = makeEfficiency(h_hlt[iSample], h_all[iSample]);

      eff_l1t_all[iSample]->SetLineColor(color[iSample]);
      eff_l1t_all[iSample]->SetMarkerColor(color[iSample]);
      eff_l1t_all[iSample]->SetMarkerStyle(20);

      eff_hlt_l1t[iSample]->SetLineColor(color[iSample]);
      eff_hlt_l1t[iSample]->SetMarkerColor(color[iSample]);
      eff_hlt_l1t[iSample]->SetMarkerStyle(20);

      eff_hlt_all[iSample]->SetLineColor(color[iSample]);
      eff_hlt_all[iSample]->SetMarkerColor(color[iSample]);
      eff_hlt_all[iSample]->SetMarkerStyle(20);

      legend->AddEntry(eff_l1t_all[iSample], histLabels[iSample],"pl");
    }



    h_all[0]->SetStats(0);
    h_all[0]->GetYaxis()->SetTitle("Efficiency");

    h_all[0]->GetYaxis()->SetRangeUser(0.,1.15);
    h_all[0]->GetXaxis()->SetRangeUser(0.,600.);


    //// l1t_all
    h_all[0]->Draw("axis");
    for( int iSample=0; iSample<NumSamples; iSample++ ) eff_l1t_all[iSample]->Draw("pe1same");
    legend->Draw();
    LumiInfoLatex.Draw();
    CMSInfoLatex.Draw();
    PublishInfoLatex.Draw();

    plotname = dirprefix + temp_mh + "_compareSamples_l1t_all_lin.png";
    c1->Print(plotname);

    plotname = dirprefix + temp_mh + "_compareSamples_l1t_all_lin.pdf";
    if( printPDF_ ) c1->Print(plotname);


    //// hlt_all
    h_all[0]->Draw("axis");
    for( int iSample=0; iSample<NumSamples; iSample++ ) eff_hlt_all[iSample]->Draw("pe1same");
    legend->Draw();
    LumiInfoLatex.Draw();
    CMSInfoLatex.Draw();
    PublishInfoLatex.Draw();

    plotname = dirprefix + temp_mh + "_compareSamples_hlt_all_lin.png";
    c1->Print(plotname);

    plotname = dirprefix + temp_mh + "_compareSamples_hlt_all_lin.pdf";
    if( printPDF_ ) c1->Print(plotname);


    //// hlt_l1t
    h_all[0]->Draw("axis");
    for( int iSample=0; iSample<NumSamples; iSample++ ) eff_hlt_l1t[iSample]->Draw("pe1same");
    legend->Draw();
    LumiInfoLatex.Draw();
    CMSInfoLatex.Draw();
    PublishInfoLatex.Draw();

    plotname = dirprefix + temp_mh + "_compareSamples_hlt_l1t_lin.png";
    c1->Print(plotname);

    plotname = dirprefix + temp_mh + "_compareSamples_hlt_l1t_lin.pdf";
    if( printPDF_ ) c1->Print(plotname);




    h_all[0]->GetYaxis()->SetRangeUser(0.85,1.15);



    //// l1t_all
    h_all[0]->Draw("axis");
    for( int iSample=0; iSample<NumSamples; iSample++ ) eff_l1t_all[iSample]->Draw("pe1same");
    legend->Draw();
    LumiInfoLatex.Draw();
    CMSInfoLatex.Draw();
    PublishInfoLatex.Draw();

    plotname = dirprefix + temp_mh + "_compareSamples_l1t_all_lin_zoom.png";
    c1->Print(plotname);

    plotname = dirprefix + temp_mh + "_compareSamples_l1t_all_lin_zoom.pdf";
    if( printPDF_ ) c1->Print(plotname);


    //// hlt_all
    h_all[0]->Draw("axis");
    for( int iSample=0; iSample<NumSamples; iSample++ ) eff_hlt_all[iSample]->Draw("pe1same");
    legend->Draw();
    LumiInfoLatex.Draw();
    CMSInfoLatex.Draw();
    PublishInfoLatex.Draw();

    plotname = dirprefix + temp_mh + "_compareSamples_hlt_all_lin_zoom.png";
    c1->Print(plotname);

    plotname = dirprefix + temp_mh + "_compareSamples_hlt_all_lin_zoom.pdf";
    if( printPDF_ ) c1->Print(plotname);


    //// hlt_l1t
    h_all[0]->Draw("axis");
    for( int iSample=0; iSample<NumSamples; iSample++ ) eff_hlt_l1t[iSample]->Draw("pe1same");
    legend->Draw();
    LumiInfoLatex.Draw();
    CMSInfoLatex.Draw();
    PublishInfoLatex.Draw();

    plotname = dirprefix + temp_mh + "_compareSamples_hlt_l1t_lin_zoom.png";
    c1->Print(plotname);

    plotname = dirprefix + temp_mh + "_compareSamples_hlt_l1t_lin_zoom.pdf";
    if( printPDF_ ) c1->Print(plotname);


    delete legend;
  }


  if( true ){

    TString temp = "h_HT30";

    std::vector<TString> useL1Name;
    useL1Name.push_back(temp + "_L1HTT125");
    useL1Name.push_back(temp + "_L1HTT100");

    std::vector<TString> labelL1Name;
    labelL1Name.push_back("L1_HTT125");
    labelL1Name.push_back("L1_HTT100");

    std::vector<Color_t> useColor;
    useColor.push_back(kBlack);
    useColor.push_back(kRed);

    TString temp_mh = temp;
    temp_mh.ReplaceAll("h_","");

    //TLegend *legend = new TLegend(0.2,0.83,0.9,0.89);
    TLegend *legend = new TLegend(0.15,0.83,0.85,0.89);

    legend->SetFillColor(kWhite);
    legend->SetLineColor(kWhite);
    legend->SetShadowColor(kWhite);
    legend->SetTextFont(42);
    legend->SetTextSize(0.04);

    legend->SetNColumns(2);

    int rebin = 25;

    int NumL1Samples = int(useL1Name.size());

    TH1D* h_all[NumL1Samples];
    TH1D* h_l1t[NumL1Samples];

    TEfficiency* eff_l1t_all[NumL1Samples];

    for( int iSample=0; iSample<NumL1Samples; iSample++ ){
      h_all[iSample] = (TH1D*)file[useSample_]->Get(temp)->Clone(Form("%s_%s",temp.Data(),labelL1Name[iSample].Data()));
      h_l1t[iSample] = (TH1D*)file[useSample_]->Get(useL1Name[iSample])->Clone(Form("%s_%s",useL1Name[iSample].Data(),labelL1Name[iSample].Data()));

      h_all[iSample]->Rebin(rebin);
      h_l1t[iSample]->Rebin(rebin);

      eff_l1t_all[iSample] = makeEfficiency(h_l1t[iSample], h_all[iSample]);

      eff_l1t_all[iSample]->SetLineColor(useColor[iSample]);
      eff_l1t_all[iSample]->SetMarkerColor(useColor[iSample]);
      eff_l1t_all[iSample]->SetMarkerStyle(20);

      legend->AddEntry(eff_l1t_all[iSample], labelL1Name[iSample],"pl");
    }



    h_all[0]->SetStats(0);
    h_all[0]->GetYaxis()->SetTitle("Efficiency");

    h_all[0]->GetYaxis()->SetRangeUser(0.,1.15);
    h_all[0]->GetXaxis()->SetRangeUser(0.,600.);



    //// l1t_all
    h_all[0]->Draw("axis");
    for( int iSample=0; iSample<NumL1Samples; iSample++ ) eff_l1t_all[iSample]->Draw("pe1same");
    legend->Draw();
    LumiInfoLatex.Draw();
    CMSInfoLatex.Draw();
    PublishInfoLatex.Draw();

    plotname = dirprefix + temp_mh + "_compareL1_l1t_all_lin.png";
    c1->Print(plotname);

    plotname = dirprefix + temp_mh + "_compareL1_l1t_all_lin.pdf";
    if( printPDF_ ) c1->Print(plotname);



    h_all[0]->GetYaxis()->SetRangeUser(0.85,1.15);



    //// l1t_all
    h_all[0]->Draw("axis");
    for( int iSample=0; iSample<NumL1Samples; iSample++ ) eff_l1t_all[iSample]->Draw("pe1same");
    legend->Draw();
    LumiInfoLatex.Draw();
    CMSInfoLatex.Draw();
    PublishInfoLatex.Draw();

    plotname = dirprefix + temp_mh + "_compareL1_l1t_all_lin_zoom.png";
    c1->Print(plotname);

    plotname = dirprefix + temp_mh + "_compareL1_l1t_all_lin_zoom.pdf";
    if( printPDF_ ) c1->Print(plotname);


    delete legend;
  }




  ////////////////////////////////////////////////////////////////////////////

  TCanvas* myC1 = new TCanvas("myC1", "myC1", 600,700);
  gStyle->SetPadBorderMode(0);
  gStyle->SetFrameBorderMode(0);
  Float_t small = 1.e-5;
  myC1->Divide(1,2,small,small);
  const float padding=1e-5; const float ydivide=0.3;
  myC1->GetPad(1)->SetPad( padding, ydivide + padding , 1-padding, 1-padding);
  myC1->GetPad(2)->SetPad( padding, padding, 1-padding, ydivide-padding);
  myC1->GetPad(1)->SetLeftMargin(.11);
  myC1->GetPad(2)->SetLeftMargin(.11);
  myC1->GetPad(1)->SetRightMargin(.05);
  myC1->GetPad(2)->SetRightMargin(.05);
  myC1->GetPad(1)->SetBottomMargin(.3);
  myC1->GetPad(2)->SetBottomMargin(.3);
  myC1->GetPad(1)->Modified();
  myC1->GetPad(2)->Modified();
  myC1->cd(1);
  gPad->SetBottomMargin(small);
  gPad->Modified();


  for( int i=0; i<int(histoname3.size()); i++ ){

    TString temp = histoname3[i];
    
    TString temp_mh = temp;
    temp_mh.ReplaceAll("h_","");

    //TLegend *legend = new TLegend(0.1,0.91,0.9,0.99);
    TLegend *legend = new TLegend(0.2,0.83,0.88,0.89);

    legend->SetFillColor(kWhite);
    legend->SetLineColor(kWhite);
    legend->SetShadowColor(kWhite);
    legend->SetTextFont(42);
    legend->SetTextSize(0.04);

    legend->SetNColumns(2);

    int rebin = 1;

    if( temp.Contains("_mass") ) rebin = 2;
    if( temp.Contains("_L1HTT") ) rebin = 2;
    if( temp.Contains("_met") ) rebin = 5;
    if( temp.Contains("_jet_") && temp.Contains("_pt") ) rebin = 10;
    if( temp.Contains("_jet_") && temp.Contains("_eta") ) rebin = 4;
    if( temp.Contains("_jet_") && temp.Contains("_phi") ) rebin = 4;
    if( temp.Contains("_csv") ) rebin = 8;

    if( temp.Contains("_diele_mass_closestZmass") ) rebin = 5;


    TH1D* h_data = (TH1D*)file[2]->Get(temp.Data());
    TH1D* h_mc   = (TH1D*)file[0]->Get(temp.Data());

    h_data->Rebin(rebin);
    h_mc->Rebin(rebin);

    if( temp.Contains("_numPV") ){
      h_mc->Scale( h_data->Integral() / h_mc->Integral() );
    }


    h_data->SetLineColor(color[0]);
    h_mc->SetLineColor(color[2]);

    h_data->SetMarkerColor(color[0]);
    h_mc->SetMarkerColor(color[2]);

    h_data->SetMarkerStyle(20);
    h_mc->SetMarkerStyle(20);

    legend->AddEntry(h_data,histLabels[2],"p");
    legend->AddEntry(h_mc,histLabels[0],"p");

    //c3->SetTopMargin(.05);
    //c1->SetRightMargin(.05);

    double ratioMax = 1.6;
    double ratioMin = 0.5;

    int nbins = h_data->GetNbinsX();

    double xmin = h_data->GetBinLowEdge(1);
    double xmax = h_data->GetBinLowEdge(nbins) + h_data->GetBinWidth(nbins);

    TH1D* myRatio = new TH1D("ratio", "", nbins, xmin, xmax );

    myRatio->SetStats(0);
    myRatio->Sumw2();
    myRatio->SetLineColor(kBlack);
    myRatio->SetMarkerColor(kBlack);
    myRatio->Divide(h_data,h_mc);

    myRatio->SetMinimum(ratioMin);
    myRatio->SetMaximum(ratioMax);
    //myRatio->GetYaxis()->SetNdivisions(50000+404);
    myRatio->GetYaxis()->SetNdivisions(50000+204);
    myRatio->GetYaxis()->SetLabelSize(0.1); //make y label bigger
    myRatio->GetXaxis()->SetLabelSize(0.1); //make y label bigger
    myRatio->GetXaxis()->SetTitleOffset(1.1);
    myRatio->GetXaxis()->SetTitle(h_data->GetXaxis()->GetTitle()); //make y label bigger
    myRatio->GetXaxis()->SetLabelSize(0.12);
    myRatio->GetXaxis()->SetLabelOffset(0.04);
    myRatio->GetXaxis()->SetTitleSize(0.12);
    myRatio->GetYaxis()->SetTitle("Data/MC");
    myRatio->GetYaxis()->SetTitleSize(0.09);
    myRatio->GetYaxis()->SetTitleOffset(.55);
    myC1->cd(2);
    gPad->SetTopMargin(small);
    gPad->SetTickx();
    gPad->Modified();

    myRatio->GetYaxis()->CenterTitle(kTRUE);


    if( temp.Contains("_selection") ){
      for( int iBin=0; iBin<nbins; iBin++ ) myRatio->GetXaxis()->SetBinLabel(iBin+1,h_data->GetXaxis()->GetBinLabel(iBin+1));
      myC1->GetPad(2)->SetBottomMargin(.4);
      myC1->GetPad(1)->SetRightMargin(.10);
      myC1->GetPad(2)->SetRightMargin(.10);
      myRatio->GetXaxis()->SetTitle("");
    }
    else{
      myC1->GetPad(2)->SetBottomMargin(.3);
      myC1->GetPad(1)->SetRightMargin(.05);
      myC1->GetPad(2)->SetRightMargin(.05);
    }

    h_data->SetStats(0);

    h_data->GetYaxis()->SetTitleOffset(1.0);
    h_data->GetYaxis()->SetTitleSize(0.05);

    h_data->GetYaxis()->SetTitle("Number of Events");


    int max_bin_data = h_data->GetMaximumBin();
    double max_data = h_data->GetBinContent(max_bin_data) + h_data->GetBinError(max_bin_data);

    int max_bin_mc = h_mc->GetMaximumBin();
    double max_mc = h_mc->GetBinContent(max_bin_mc) + h_mc->GetBinError(max_bin_mc);

    double max_content = std::max(max_data, max_mc);

    h_data->GetYaxis()->SetRangeUser(0.,1.2 * max_content);

    if( temp.Contains("_mass") ){
      h_data->GetXaxis()->SetRangeUser(40.,140.);
      myRatio->GetXaxis()->SetRangeUser(40.,140.);
    }

    if( temp.Contains("_met") ){
      h_data->GetXaxis()->SetRangeUser(0.,150.);
      myRatio->GetXaxis()->SetRangeUser(0.,150.);
    }
    // if( temp.Contains("_eta") ) h_all->GetYaxis()->SetRangeUser(0.4,1.1);
    // if( temp.Contains("_numGenPVs") ) h_all->GetYaxis()->SetRangeUser(0.4,1.1);
    // if( temp.Contains("_numJets") ) h_all->GetYaxis()->SetRangeUser(0.4,1.1);


    TLine* myLine;
    if( temp.Contains("_mass") )     myLine = new TLine(40, 1, 140, 1);
    else if( temp.Contains("_met") ) myLine = new TLine(0, 1, 150, 1);
    else                             myLine = new TLine(h_data->GetXaxis()->GetXmin(), 1, h_data->GetXaxis()->GetXmax(), 1);


    // HLT
    myC1->cd(1);
    h_data->Draw("pe1");
    h_mc->Draw("pe1same");
    legend->Draw();
    LumiInfoLatex.Draw();
    CMSInfoLatex.Draw();
    PublishInfoLatex.Draw();

    myC1->cd(2);
    myRatio->SetLineWidth(2);
    myRatio->Draw("pe1");
    myLine->Draw();

    plotname = dirprefix + temp_mh + "_data2mc_lin.png";
    myC1->Print(plotname);

    plotname = dirprefix + temp_mh + "_data2mc_lin.pdf";
    if( printPDF_ ) myC1->Print(plotname);


    // log
    h_data->GetYaxis()->SetRangeUser(0.4,12 * max_content);
    if( temp.Contains("_selection") ){
      h_data->GetYaxis()->SetRangeUser(400,12 * max_content);
    }

    myC1->cd(1);
    gPad->SetLogy(1);

    plotname = dirprefix + temp_mh + "_data2mc_log.png";
    myC1->Print(plotname);

    plotname = dirprefix + temp_mh + "_data2mc_log.pdf";
    if( printPDF_ ) myC1->Print(plotname);

    gPad->SetLogy(0);



    delete myRatio;
    delete myLine;
    delete legend;
  } // end loop on hists

  ////////////////////////////////////////////////////////////////////////////


  // Close the file
  for( int iFile=0; iFile<NumSamples; iFile++ ) file[iFile]->Close();
  std::cout << " Done! " << std::endl;
}
Example #19
0
void updateHIN11010(int etPho = 60, int etJet = 30, bool scaleByR=true, bool drawMC=true, int prodDate=20131021) {
  bool mcOnly=false;

  int percentBin[5] = {0,10,30,50,100};
  TH1D* hxgj[5][10];   //[data kind] [ centrality] 
  TH1D* hxgjpp[20];
  TFile *fSum1 = new TFile(Form("histOutputFiles60GeVInclusive/HisOutput_Photonv7_v29_akPu3PF_InclPtRatio_gamma%djet%ddphiSig2749_Isol0_Norm1.root",etPho,etJet));
  for ( int icent=0; icent<=3 ; icent++) { 
    hxgj[khimc][icent] =  (TH1D*)fSum1->Get(Form("dataSrc%d_reco1_cent%dSubtractedExtrapExtrapNorm",khimc,icent));
    hxgj[khidata][icent] =  (TH1D*)fSum1->Get(Form("dataSrc%d_reco1_cent%dSubtractedExtrapExtrapNorm",khidata,icent));
  }
  hxgjpp[kppdata] = (TH1D*)fSum1->Get("dataSrc2_reco1_cent0SubtractedExtrapExtrapNorm");

  TFile *fSum2 = new TFile(Form("histOutputFiles60GeVInclusive/HisOutput_Photonv7_v29_akPu3PF_InclPtRatio_gamma%djet%ddphiSig2749_Isol0_Norm2.root",etPho,etJet));
  TGraphAsymmErrors* mxhimc = (TGraphAsymmErrors*)fSum2->Get("dataSrc0_reco1_x_Summary_0");
  TGraphAsymmErrors* mxhidata = (TGraphAsymmErrors*)fSum2->Get("dataSrc1_reco1_x_Summary_0");
  //  TGraphAsymmErrors* mxppdata = (TGraphAsymmErrors*)fSum2->Get("dataSrc2_reco1_x_Summary_0");
  TGraphAsymmErrors* mxppdata;
  TGraphAsymmErrors* mxppmc = (TGraphAsymmErrors*)fSum2->Get("dataSrc10_reco1_x_Summary_0");

  TGraphAsymmErrors* rxhimc = (TGraphAsymmErrors*)fSum2->Get("dataSrc0_reco1_R_Summary_0");
  TGraphAsymmErrors* rxhidata = (TGraphAsymmErrors*)fSum2->Get("dataSrc1_reco1_R_Summary_0");
  TGraphAsymmErrors* rxppdata = (TGraphAsymmErrors*)fSum2->Get("dataSrc2_reco1_R_Summary_0");
  TGraphAsymmErrors* rxppmc = (TGraphAsymmErrors*)fSum2->Get("dataSrc10_reco1_R_Summary_0");

  TFile *fSum3 = new TFile(Form("histOutputFiles60GeVInclusive/HisOutput_Photonv7_v29_akPu3PF_InclDeltaPhi_gamma%djet%ddphiSig628_subJ1SS1_Isol0_Norm1.root",etPho,etJet));

  TFile *fSum4 = new TFile("histOutputFiles60GeVInclusive/HisSummary_Photonv7_v29_akPu3PF_InclDeltaPhi_gamma60jet30dphiSig628_subJ1SS1_Isol0_Norm1.root");
  TGraphAsymmErrors* dphihimc = (TGraphAsymmErrors*)fSum4->Get("dataSrc0_reco1_dphi_Summary");
  TGraphAsymmErrors* dphihidata = (TGraphAsymmErrors*)fSum4->Get("dataSrc1_reco1_dphi_Summary");
  TGraphAsymmErrors* dphippdata = (TGraphAsymmErrors*)fSum4->Get("dataSrc2_reco1_dphi_Summary");
  TGraphAsymmErrors* dphippmc = (TGraphAsymmErrors*)fSum4->Get("dataSrc10_reco1_dphi_Summary");

  // new dphihidata points
  //


  double sysDphi[4] = {0.032,0.03,0.045,0.077};
  //0.109940, 0.046998, 0.034206,0.142664};
  double sysDphipp[1] = {sysDphi[3]};
  
  double sysR[4] = {0.045,0.039,0.041,0.037};
  //0.017232,0.012847,0.011691,0.012724};
  double sysRpp[1] = {sysR[3]};
  
  double sysMx[4] = { 0.053,0.048,0.051,0.032};
  double sysMxpp[1] = {0.009};
  double corrSysMx =  0.028;

  TH1D* hdphi[5][5];   //[data kind] [ centrality]                                                                                     
  TH1D* hdphipp[20];
  for ( int icent=0; icent<=3 ; icent++) {
    hdphi[khimc][icent] =  (TH1D*)fSum3->Get(Form("dataSrc%d_reco1_cent%dSubtractedExtrapExtrapNorm",khimc,icent));
    hdphi[khidata][icent] =  (TH1D*)fSum3->Get(Form("dataSrc%d_reco1_cent%dSubtractedExtrapExtrapNorm",khidata,icent));
  }
  hdphipp[kppdata] = (TH1D*)fSum3->Get("dataSrc2_reco1_cent0SubtractedExtrapExtrapNorm");
  
  // 2013 pp data!!!!!!
  TFile* pp13 = new TFile(Form("ffFilesPP60GeVInclusive/photonTrackCorr_ppDATA_output_photonPtThr60_to_9999_jetPtThr30_%d.root", prodDate));
  // TFile* pp13 = new TFile("ffFilesPP60GeVInclusive/oldSmearing.root");

  hdphi[kppdata13][1] =  (TH1D*)pp13->Get("jetDphi_icent10010_final");
  hxgj[kppdata13][1] = (TH1D*)pp13->Get("xjg_icent10010_final");
  hdphi[kppdata13][2] =  (TH1D*)pp13->Get("jetDphi_icent11030_final");
  hxgj[kppdata13][2] = (TH1D*)pp13->Get("xjg_icent11030_final");
  hdphi[kppdata13][3] =  (TH1D*)pp13->Get("jetDphi_icent13050_final");
  hxgj[kppdata13][3] = (TH1D*)pp13->Get("xjg_icent13050_final");
  hdphi[kppdata13][4] =  (TH1D*)pp13->Get("jetDphi_icent15099_final");
  hxgj[kppdata13][4] = (TH1D*)pp13->Get("xjg_icent15099_final");
  hdphi[kppdata13][5] =  (TH1D*)pp13->Get("jetDphi_icent7_final");
  hxgj[kppdata13][5] = (TH1D*)pp13->Get("xjg_icent7_final");
  

  for ( int icent  = 1 ; icent<=5 ; icent++) {
    hdphi[kppdata13][icent]->Scale(1./hdphi[kppdata13][icent]->Integral());
    for ( int i = 1 ; i<=5 ; i++) {
      hdphi[kppdata13][icent]->SetBinContent(i,-1e4);
    }
    //    hxgj[kppdata13][icent]->Rebin(10);  // Now the bins are already rebined from photonTrackCorr_ppDATA_output_photonPtThr60_to_9999_jetPtThr30_20131021.root
    hxgj[kppdata13][icent]->Scale(1./hxgj[kppdata13][icent]->Integral("width"));
  }
  
  TH1D* hPtPP2013[10];  
  hPtPP2013[1] = (TH1D*)pp13->Get("jetPt_icent10010_final");
  hPtPP2013[2] = (TH1D*)pp13->Get("jetPt_icent11030_final");
  hPtPP2013[3] = (TH1D*)pp13->Get("jetPt_icent13050_final");
  hPtPP2013[4] = (TH1D*)pp13->Get("jetPt_icent15099_final");
  hPtPP2013[5] = (TH1D*)pp13->Get("jetPt_icent7_final");
  
  TH1D* hRpp2013[10]; 
  hRpp2013[1] = new TH1D("hrpp2013_icent1","",1, 359.1-10, 359.1+10);
  hRpp2013[2] = new TH1D("hrpp2013_icent2","",1, 235.6-10, 235.6+10);
  hRpp2013[3] = new TH1D("hrpp2013_icent3","",1, 116.4-10, 116.4+10);
  hRpp2013[4] = new TH1D("hrpp2013_icent4","",1, 43.6-10,  43.6 +10);
  hRpp2013[5] = new TH1D("hrpp2013_icent5","",1, -8,  18 );

  for ( int icent=1 ;  icent<=5; icent++) { 
    double temprPP13err;
    double temprPP13 = hPtPP2013[icent]->IntegralAndError(1,hPtPP2013[icent]->GetNbinsX(),temprPP13err,"width");
    hRpp2013[icent]->SetBinContent(1,temprPP13);
    hRpp2013[icent]->SetBinError(1,temprPP13err);
    handsomeTH1(hRpp2013[icent],1);
    hRpp2013[icent]->SetMarkerStyle(21);
  }
  
  TH1D* hMXpp2013[10];
  hMXpp2013[1] = new TH1D("hmxpp2013_icent1","",1, 359.1-10, 359.1+10);
  hMXpp2013[2] = new TH1D("hmxpp2013_icent2","",1, 235.6-10, 235.6+10);
  hMXpp2013[3] = new TH1D("hmxpp2013_icent3","",1, 116.4-10, 116.4+10);
  hMXpp2013[4] = new TH1D("hmxpp2013_icent4","",1, 43.6-10,  43.6 +10);
  hMXpp2013[5] = new TH1D("hmxpp2013_icent5","",1, -8, 18);
  for ( int icent=1 ;  icent<=5; icent++) {
    hMXpp2013[icent]->SetBinContent(1,hxgj[kppdata13][icent]->GetMean());
    hMXpp2013[icent]->SetBinError(1,hxgj[kppdata13][icent]->GetMeanError());
    handsomeTH1(hMXpp2013[icent],1);
    hMXpp2013[icent]->SetMarkerStyle(21);
  }


  TFile* fPPsys = new TFile("ffFilesPP60GeVInclusive/relativeSys_merged_pp60GeV.root");

  TH1D* hdphiWidth  = (TH1D*)fPPsys->Get("dphiWidth_uncertainty_merged");
  
  TH1D* hDphiPPUnc = new TH1D("hdphippunc","",1,0,1);
  hDphiPPUnc->SetBinContent(1, hdphiWidth->GetBinContent(1) );

  TH1D* ppSysX[4];
  ppSysX[0] = (TH1D*)fPPsys->Get("dNdXjg_uncertainty_merged");
  ppSysX[1] = (TH1D*)ppSysX[0]->Clone("ppSysx1");
  ppSysX[2] = (TH1D*)ppSysX[0]->Clone("ppSysx2");
  ppSysX[3] = (TH1D*)ppSysX[0]->Clone("ppSysx3");

  TH1D* meanXpp13Sys = (TH1D*)fPPsys->Get("meanXjg_uncertainty_merged");

  float ppSysMx60 = meanXpp13Sys->GetBinContent(1);    // UPDATED on Oct 22nd
  TH1D* ppSysMx = new TH1D("ppSysMx","",1,0,1);
  ppSysMx->SetBinContent(1,ppSysMx60);

  TH1D* meanRpp13Sys = (TH1D*)fPPsys->Get("meanRjg_uncertainty_merged");
  float ppSysR60 = meanRpp13Sys->GetBinContent(1); // UPDATED on Oct 22nd
  TH1D* ppSysR = new TH1D("ppSysR","",1,0,1);
  ppSysR->SetBinContent(1,ppSysR60);

  
  
  // xjg distributions
  TCanvas *c1 = new TCanvas("c1","",1100,330);
  makeMultiPanelCanvas(c1,4,1,0.0,0.0,0.24,0.15,0.075);
  c1->cd(0);
  drawCMSppPbPb(0.1,0.95);
  //c1->Divide(4,1,0.0,0.0);
  for ( int icent=0; icent<=3 ; icent++) {
    c1->cd( 4 - icent);
    //hxgj[khimc][icent]->SetAxisRange(-.2,2.5,"Y");
    hxgj[khimc][icent]->SetAxisRange(0,2.5,"Y");
    hxgj[khimc][icent]->SetNdivisions(505);
    //    hxgj[khimc][icent]->SetTitle(";x_{J#gamma} = p^{Jet}_{T}/p^{#gamma}_{T}; #frac{1}{N_{J#gamma}} #frac{dN_{J#gamma}}{dx_{J#gamma}}");
    hxgj[khimc][icent]->SetTitle(";x_{J#gamma}; #frac{1}{N_{J#gamma}} #frac{dN_{J#gamma}}{dx_{J#gamma}}");
    handsomeTH1(hxgj[khimc][icent]);
    fixedFontHist(hxgj[khimc][icent],1,1.35);
    mcStyle2(hxgj[khimc][icent]);
    handsomeTH1(hxgj[khidata][icent],2);
    
    hxgj[khimc][icent]->GetYaxis()->SetTitleOffset(1.5);
    TH1D * htemp41 = (TH1D*)hxgj[khimc][icent]->Clone(Form("htemp41_%d",icent));
    for ( int i=0 ; i<=20 ; i++) {
      htemp41->SetBinContent(i,0);
      htemp41->SetBinError(i,0);
    }
    if (scaleByR) {
      htemp41->SetAxisRange(0,2,"Y");
      htemp41->SetYTitle("#frac{1}{N_{#gamma}} #frac{dN_{J#gamma}}{dx_{J#gamma}}");
    }
    htemp41->DrawCopy("hist");

    if (scaleByR)    {
      hxgj[kppdata13][icent+1]->Scale(hRpp2013[icent+1]->GetBinContent(1));
      std::cout <<"  Scaled by pp R :" << hRpp2013[icent+1]->GetBinContent(1) << std::endl;
      
      double x,y;
      rxhidata->GetPoint(icent, x,y);
      hxgj[khidata][icent]->Scale(y);
      std::cout << " scaled by PbPb R: " << y << std::endl;

      rxhimc->GetPoint(icent, x,y);
      hxgj[khimc][icent]->Scale(y);
      std::cout << " scaled by PbPb R: " << y << std::endl;
    }
    if(drawMC) hxgj[khimc][icent]->DrawCopy("hist same");

    if ( !mcOnly )    drawXSys(icent,hxgj[khidata][icent]);
    //   if ( icent==3){ }
    
    handsomeTH1(hxgj[kppdata13][icent+1]);
    hxgj[kppdata13][icent+1]->SetMarkerStyle(21);

    drawSys(hxgj[kppdata13][icent+1],ppSysX[icent],kGreen,3001);

    hxgj[kppdata13][icent+1]->Draw("same ");
    
    if ( !mcOnly )   hxgj[khidata][icent]->Draw("same");
    //onSun(0,0,2,0);
 
    // if ( icent == 2) {
    //   TLegend *leg0  = new TLegend(0.2796373,0.7545885,0.9742202,0.9937661,NULL,"brNDC");
    //     easyLeg(leg0,"");
    //   //      if ( !mcOnly )       leg0->AddEntry(hxgj[khidata][icent],"PbPb Data","p");
    //   leg0->AddEntry(hxgj[khimc][icent],"PYTHIA + HYDJET","f");
    //   leg0->AddEntry(hxgjpp[kppdata],"","");

    //   leg0->Draw();
    // }
    
    if ( icent == 3) {
      TLegend *leg0 = new TLegend(0.2916647,0.7045885,0.9862476,0.9869226,NULL,"brNDC");
      easyLeg(leg0);
      leg0->AddEntry(hxgj[khidata][icent],"PbPb Data","p");
      if ( !mcOnly )       leg0->AddEntry(hxgj[kppdata13][icent+1],"Smeared pp reference","p");
      //    leg0->AddEntry(hxgj[khidata][icent],"","");
      if(drawMC) leg0->AddEntry(hxgj[khimc][icent],"PbPb PYTHIA + HYDJET","f");
      leg0->Draw();
      //drawText("#sqrt{s_{NN}}=2.76 TeV ",0.65,0.74,0,15);
    }
        
    if ( icent == 2) {
      drawText(Form("p^{#gamma}_{T} > %d GeV/c     |#eta^{#gamma}| < 1.44",etPho),0.2,0.85,0,15);
      drawText(Form("p^{Jet}_{T} > %d GeV/c    |#eta^{Jet}| < 1.6",etJet),0.2,0.77,0,15);
      drawText("#Delta#phi_{J#gamma} > #frac{7}{8}#pi",0.2,0.69,0,15);
    }
    if ( icent == 0 ) {
      //      drawText("CMS",0.8,0.9,1);
      //      drawText("pp       #int L dt = 231 nb^{-1}",0.4,0.68,1,15);
    }
    
    if ( icent == 3) 
      drawText(Form("%d%% - %d%%",percentBin[icent],percentBin[icent+1]),0.72,0.5,0,15);
    else 
      drawText(Form("%d%% - %d%%",percentBin[icent],percentBin[icent+1]),0.67,0.5,0,15);
    
    /*    if ( icent == 3)
      drawText("(a)",0.275,0.8,1);
    if ( icent == 2)
      drawText("(b)",0.05,0.8,1);  
    if ( icent == 1)
      drawText("(c)",0.05,0.8,1);   
    if ( icent == 0)
      drawText("(d)",0.05,0.8,1);
    */
    gPad->RedrawAxis();
  }

  c1->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_xjg_distribution.pdf");
  //c1->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_xjg_distribution.png");
  //c1->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_xjg_distribution.gif");
  //c1->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_xjg_distribution.C");

  
  
  // TCanvas *c1all = new TCanvas("c1all","",500,500);

  // for ( int icent=0;icent<4;icent++){
  //   hxgj[khimc][icent]->SetFillStyle(0);
  //   hxgj[khimc][icent]->SetMarkerSize(1.5);
  // }
  // hxgj[khimc][0]->SetMarkerStyle(22);
  // hxgj[khimc][1]->SetMarkerStyle(26);
  // hxgj[khimc][2]->SetMarkerStyle(23);
  // hxgj[khimc][3]->SetMarkerStyle(32);
  // hxgj[khimc][0]->DrawCopy("");
  // hxgj[khimc][1]->DrawCopy(" same");
  // hxgj[khimc][2]->DrawCopy(" same");
  // hxgj[khimc][3]->DrawCopy(" same");
  // jumSun(0,0,2,0);

  // drawText("PYTHIA+HYDJET",0.2,0.80,0,25);
  // TLegend *legc1all = new TLegend(0.6149194,0.6716102,0.9435484,0.9555085,NULL,"brNDC");
  // easyLeg(legc1all,"");
  // legc1all->AddEntry(hxgj[khimc][3],"50-100%","p");
  // legc1all->AddEntry(hxgj[khimc][2],"30-50%","p");
  // legc1all->AddEntry(hxgj[khimc][1],"10-30%","p");
  // legc1all->AddEntry(hxgj[khimc][0],"0-10%","p");
  // legc1all->Draw();
  
  // dphi distributions
  TCanvas *c1ppDphi = new TCanvas("c1ppDphi","",500,500);
  TString fitFunc = "(TMath::Pi()/20.0)*exp(-(TMath::Pi()-x)/[0])/([0]*(1-exp(-TMath::Pi()/[0])))";
  float fitxmin=3.1415926*2./3;
  TF1 *fdphiPP[10];
  TH1D* hDphiPP2013[10];
  hDphiPP2013[1] = new TH1D("hDphiPP2013_icent1","",1, 359.1-10, 359.1+10);
  hDphiPP2013[2] = new TH1D("hDphiPP2013_icent2","",1, 235.6-10, 235.6+10);
  hDphiPP2013[3] = new TH1D("hDphiPP2013_icent3","",1, 116.4-10, 116.4+10);
  hDphiPP2013[4] = new TH1D("hDphiPP2013_icent4","",1, 43.6-10,  43.6 +10);
  hDphiPP2013[5] = new TH1D("hDphiPP2013_icent5","",1, -8, 18);
  
  for ( int icent=1; icent<=5 ; icent++) {
    fdphiPP[icent] = new TF1(Form("fdphiPP_icent%d",icent),fitFunc.Data(),2.0*TMath::Pi()/3.0,TMath::Pi());
    fdphiPP[icent]->SetParName(0,"width");
    fdphiPP[icent]->SetParameter("width",0.3);
    hdphi[kppdata13][icent]->Fit(Form("fdphiPP_icent%d",icent),"0","",fitxmin,3.1415926);
    fdphiPP[icent]->SetLineWidth(1);
    fdphiPP[icent]->SetLineStyle(2);
    fdphiPP[icent]->SetLineColor(1);
    hdphi[kppdata13][icent]->SetAxisRange(1.00001e-3,1,"Y");
    hdphi[kppdata13][icent]->SetStats(0);
    hdphi[kppdata13][icent]->Draw("");
    hdphi[kppdata13][icent]->SetAxisRange(1.00001e-3,1,"Y");
    hdphi[kppdata13][icent]->SetStats(0);
    fdphiPP[icent]->SetLineWidth(2);
    fdphiPP[icent]->SetLineStyle(7); 
    fdphiPP[icent]->DrawCopy("same");
    gPad->SetLogy();
  
    float dphiWidth13 = fdphiPP[icent]->GetParameter(0) ; 
    float dphiWidth13err = fdphiPP[icent]->GetParError(0);
    hDphiPP2013[icent]->SetBinContent(1,dphiWidth13);
    hDphiPP2013[icent]->SetBinError(  1,dphiWidth13err);
    handsomeTH1(hDphiPP2013[icent],1);
    hDphiPP2013[icent]->SetMarkerStyle(21);
  }

  TCanvas *c1dphi = new TCanvas("c1dphi","",1100,330);
  makeMultiPanelCanvas(c1dphi,4,1,0.0,0.0,0.24,0.18,0.075);
  c1dphi->cd(0);
  drawCMSppPbPb(0.1,0.95);

  for ( int icent=0; icent<=3 ; icent++) {
    c1dphi->cd( 4 - icent);
    hdphi[khimc][icent]->SetAxisRange(1.e-3,1,"Y");
    //   hdphi[khimc][icent]->SetNdivisions(505);
    hdphi[khimc][icent]->GetXaxis()->SetNdivisions(3,5,0,kFALSE);
    
    hdphi[khimc][icent]->SetTitle(";#Delta#phi_{J#gamma};Pair Fraction");

    handsomeTH1(hdphi[khimc][icent]);
    fixedFontHist(hdphi[khimc][icent],1,1.35);
    mcStyle2(hdphi[khimc][icent]);
    handsomeTH1(hdphi[khidata][icent],2);

    TF1 *fdphi = new TF1("fdphi",fitFunc.Data(),2.0*TMath::Pi()/3.0,TMath::Pi());
    fdphi->SetParName(0,"width");
    fdphi->SetParameter("width",0.3);
    
    hdphi[khimc][icent]->Fit("fdphi","0llm","",fitxmin,3.1415926);

    fdphi->SetLineWidth(1);
    fdphi->SetLineStyle(2);
    fdphi->SetLineColor(kBlue); 
    // float dphiWidth = fdphi->GetParameter("width");
    // float dphiWidthErr = fdphi->GetParError(0);
    // std::cout << " dphiWidth,dphiWidthErr = " << dphiWidth <<"   "<< dphiWidthErr << std::endl;
    hdphi[khimc][icent]->SetAxisRange(1.00001e-3,1,"Y");
    hdphi[khimc][icent]->SetStats(0);
    TH1D* hdphitemp = (TH1D*)hdphi[khimc][icent]->Clone(Form("hdphitemp55_%d",icent));
    if(!drawMC)
    {
      for ( int i=0;i<=30;i++) { 
	hdphitemp->SetBinContent(i,0);
	hdphitemp->SetBinError(i,0);
      }
    }
    hdphitemp->Draw("hist");
    hdphi[khidata][icent]->SetAxisRange(1.00001e-3,1,"Y");
    if (!mcOnly) hdphi[khidata][icent]->Draw("same ");
    hdphi[khidata][icent]->SetStats(0);
    fdphi->SetLineWidth(2);
    fdphi->SetLineStyle(7);
    if ( mcOnly )    fdphi->DrawCopy("same");


    gPad->SetLogy();
    handsomeTH1(hdphi[kppdata13][icent+1]);
    
    hdphi[kppdata13][icent+1]->SetMarkerStyle(21);
    hdphi[kppdata13][icent+1]->Draw("same");

    
    if ( icent == 3) {
      TLegend *leg0  = new TLegend(0.32,0.7,0.9,0.89,NULL,"brNDC");
      easyLeg(leg0);
      if ( !mcOnly )   leg0->AddEntry(hdphi[kppdata13][icent+1],"Smeared pp reference","p");
      if ( !mcOnly )      leg0->AddEntry(hdphi[khidata][icent],"PbPb Data","p");
      if(drawMC) leg0->AddEntry(hdphi[khimc][icent],"PYTHIA + HYDJET","f");
      leg0->Draw();
    }

    if (( !mcOnly ) && ( icent == 2)) {
      //drawText("#sqrt{s_{NN}}=2.76 TeV ",0.4,0.88,0,15);
      //drawText("#int L dt = 150 #mub^{-1}",0.4,0.75,0,15);
    }

    if ( icent == 1) {
      drawText(Form("p^{#gamma}_{T} > %d GeV/c     |#eta^{#gamma}| < 1.44",etPho),0.15,0.8,0,15);
      drawText(Form("p^{Jet}_{T} > %d GeV/c    |#eta^{Jet}| < 1.6",etJet),0.15,0.7,0,15);
    }

    if ( icent == 0 ) {
      //      drawText("CMS",0.8,0.9,1);
      //      drawText("pp       #int L dt = 231 nb^{-1}",0.4,0.68,1,15);                                                                     
    }


    if ( icent == 3)
      drawText(Form("%d%% - %d%%",percentBin[icent],percentBin[icent+1]),0.313,0.6,0,15);
    else
      drawText(Form("%d%% - %d%%",percentBin[icent],percentBin[icent+1]),0.1,0.6,0,15);

    if ( icent == 3)
      drawText("(a)",0.275,0.8,1);
    if ( icent == 2)
      drawText("(b)",0.05,0.8,1);
    if ( icent == 1)
      drawText("(c)",0.05,0.8,1);
    if ( icent == 0)
      drawText("(d)",0.05,0.8,1);
    
    double bottomY = 0.0009;
    double pi = TMath::Pi();

    drawPatch(-0.5,bottomY/100,pi+0.5,bottomY);

    bottomY = 0.0005;
    drawText("0",0.05,bottomY,0,18,false);
    drawText("#frac{1}{3}#pi",pi/3-0.05,bottomY,0,18,0);
    drawText("#frac{2}{3}#pi",2*pi/3-0.05,bottomY,0,18,0);
    if ( icent==0) 
      drawText("#pi",pi-0.1,bottomY,0,18,0);
    drawText("#Delta#phi_{J#gamma}",pi/2.-0.1,bottomY-0.0002,0,18,0);
    
  }
  


  gPad->RedrawAxis();
  c1dphi->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_dPhi_dist.pdf");
  //c1dphi->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_dPhi_dist.png");
  //c1dphi->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_dPhi_dist.gif");
  //c1dphi->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_dPhi_dist.C");
  
  ////////////////////////////// summary plots
  TCanvas *c2 = new TCanvas("c2","",350,350);
  TH1D* hTemp2 = new TH1D("htemp2",";N_{part};<x_{J#gamma}>",100,-20,400);
  hTemp2->SetNdivisions(505);
  handsomeTH1(hTemp2,1);
  handsomeTGraph(mxhidata,2);
  mxhidata->SetMarkerStyle(20);
  handsomeTGraph(mxhimc,1);
  mxhimc->SetMarkerStyle(24);
  //  handsomeTGraph(mxppdata,1);
  //  mxppdata->SetMarkerStyle(21);
  handsomeTGraph(mxppmc,1);
  mxppmc->SetMarkerStyle(25);
  
    
  hTemp2->SetAxisRange(0.6,1.1,"Y");
  hTemp2->DrawCopy();
  //  TH1D* hMXpp2013_2 = new TH1D("hmxpp2013_2","",1,-10,370);
  //  hMXpp2013_2->SetBinContent(1,hMXpp2013->GetBinContent(1));
  //  if ( !mcOnly )   drawSys(hMXpp2013_2,sysMxpp,kGreen,3001);
  if ( !mcOnly )   drawSys(mxhidata,sysMx,10);
  
  // mxppmc->Draw("p");
  //  if ( !mcOnly )   mxppdata->Draw("p");
  if ( !mcOnly )  {
    hMXpp2013[5]->SetMarkerStyle(20);
    for ( int icent = 1 ; icent<=5 ; icent++) {
      drawSys(hMXpp2013[icent],ppSysMx,kGreen,3001);
      hMXpp2013[icent]->DrawCopy("p same");
    }
  }
  if(drawMC) mxhimc->Draw("p same");
  if ( !mcOnly )  mxhidata->Draw("p same");

  hMXpp2013[5]->SetFillStyle(3001);
  hMXpp2013[5]->SetFillColor(kGreen);
  hMXpp2013[5]->SetLineColor(0);
  hDphiPP2013[2]->SetFillStyle(3001);
  hDphiPP2013[2]->SetFillColor(kGreen);
  hDphiPP2013[2]->SetLineColor(0);
  TH1D *dummyHist = new TH1D("dummyHist","",10,0,1);
  dummyHist->SetFillStyle(1001);
  dummyHist->SetMarkerColor(kRed);
  dummyHist->SetFillColor(90);
  dummyHist->SetLineColor(0);
  
  //// sys bar by energy scale
  /*
  TBox *b1 = new TBox(400-20,0.85 - corrSysMx ,400,  0.85 + corrSysMx);
  b1->SetFillColor(1);
  b1->SetFillStyle(1001);
  if ( !mcOnly )   b1->Draw();
  TBox *b2 = new TBox(400-20+3,0.85 - corrSysMx+ 0.002 ,400-3,  0.85 + corrSysMx- 0.002);
  b2->SetFillColor(0);
  b2->SetFillStyle(1001);
  if ( !mcOnly )   b2->Draw();
  */
  //  drawText("Common uncertainty due to jet ",0.35,0.25,0,15);
  //  drawText("energy scale & photon purity",0.35,0.2,0,15);
  //  drawText("#sqrt{s_{NN}}=2.76 TeV ",0.5,0.85,0,15);
  //  drawText("#int L dt = 150 #mub^{-1}",0.5,0.72,0,15);
  //  drawText("(a)",0.22,0.87,1);
  drawText("#Delta#phi_{J#gamma} > #frac{7}{8}#pi",0.7,0.75,0);
  drawCMSppPbPb(0.1,0.95,12);
  //  drawText("#Delta#phi_{J#gamma} > #frac{7}{8}#pi",0.5,0.38,0);
  // drawText("CMS",0.78,0.88,1);

  TLegend *leg4 =  new TLegend(0.1630303,0.6054839,0.7590909,0.8931183,NULL,"brNDC");
  easyLeg(leg4,"");
  //  if ( !mcOnly )  leg4->AddEntry(mxppdata,"pp Data 231nb^{-1}","p");
  if ( !mcOnly ) leg4->AddEntry(dummyHist,"PbPb Data","fp");
  if ( !mcOnly )  leg4->AddEntry(hMXpp2013[5],"pp Data","fp");
  if ( !mcOnly )  leg4->AddEntry(hDphiPP2013[2],"Smeared pp reference","fp");
  if(drawMC) leg4->AddEntry(mxhimc,"PYTHIA + HYDJET","p");
  //  leg4->AddEntry(mxppmc,"PYTHIA","p");




  //  leg4->AddEntry(hSysTemp,"Sys. Uncertainty","f");                                                                                         
  leg4->Draw();


  gPad->RedrawAxis();
  
  c2->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_xjg_npart.pdf");
  //c2->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_xjg_npart.png");
  //c2->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_xjg_npart.gif");
  //c2->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_xjg_npart.C");
  
  ////////////////////////////// rx 
  TCanvas *c3 = new TCanvas("c3","",350,350);

  TH1D* hTemp3 = new TH1D("htemp2",";N_{part};R_{J#gamma}",100,-20,400);
  hTemp3->SetNdivisions(505);
  handsomeTH1(hTemp3,1);
  handsomeTGraph(rxhidata,2);
  rxhidata->SetMarkerStyle(20);
  handsomeTGraph(rxhimc,1);
  rxhimc->SetMarkerStyle(24);
  handsomeTGraph(rxppdata,1);
  rxppdata->SetMarkerStyle(21);
  handsomeTGraph(rxppmc,1);
  rxppmc->SetMarkerStyle(25);

  hTemp3->SetAxisRange(0.41,1.,"Y");
  hTemp3->Draw();


  // Ratio
  // DivideTG(rxppdata,rxppmc);
  // DivideTG(rxhidata,rxhimc);
  //////////////////////////////////////////////
  //  TH1D* hdphi2013_2 = new TH1D("hdphi2013_2","",1,-10,370);
  //  hdphi2013_2->SetBinContent(1,hRpp2013->GetBinContent(1));
  //  if ( !mcOnly )   drawSys(hdphi2013_2,sysRpp,kGreen,3001);
  if ( !mcOnly )   drawSys(rxhidata,sysR,10);
  //  if ( !mcOnly )   drawSys(rxppdata,sysRpp,10);
  // jumSun(-10,1,400,1);
  if(drawMC) rxhimc->Draw("p");
  //  rxppmc->Draw("p");
  //  if ( !mcOnly )   rxppdata->Draw("p");
  if ( !mcOnly )   {
    hRpp2013[5]->SetMarkerStyle(20);
    for ( int icent =1 ; icent<=5 ; icent++) { 
      drawSys(hRpp2013[icent],ppSysR,kGreen,3001);
      hRpp2013[icent]->Draw("same");
    }
  }
  if ( !mcOnly )   rxhidata->Draw("p same");
  //  drawText(Form("p^{#gamma}_{T} > %d GeV/c",etPho),0.6,0.75,0,15);
  //  drawText(Form("p^{Jet}_{T} > %d GeV/c",etJet),0.6,0.67,0,15);
  //  drawText("CMS",0.78,0.88,1);
  //  drawText("(b)",0.22,0.87,1);
  drawText("#Delta#phi_{J#gamma} > #frac{7}{8}#pi",0.7,0.75,0);
  drawCMSppPbPb(0.1,0.95,12);

  leg4->Draw();
  gPad->RedrawAxis();

  c3->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_r_npart.pdf");
  //c3->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_r_npart.png");
  //c3->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_r_npart.gif");
  //c3->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_r_npart.C");
  
  TCanvas *c4 = new TCanvas("c4","",350,350);

  TH1D* hTemp4 = new TH1D("htemp2",";N_{part};#sigma(#Delta#phi_{J#gamma})",100,-20,400);
  hTemp4->SetNdivisions(505);
  handsomeTH1(hTemp4,1);
  handsomeTGraph(dphihidata,2);
  dphihidata->SetMarkerStyle(20);
  handsomeTGraph(dphihimc,1);
  dphihimc->SetMarkerStyle(24);
  handsomeTGraph(dphippdata,1);
  dphippdata->SetMarkerStyle(21);
  handsomeTGraph(dphippmc,1);
  dphippmc->SetMarkerStyle(25);

  hTemp4->SetAxisRange(0,.5,"Y");
  hTemp4->Draw();
  
                                                                                 
  // TH1D* h2013_3 = new TH1D("hdphi2013_3","",1,-10,370);
  //  h2013_3->SetBinContent(1,hDphiPP2013->GetBinContent(1));

  //  if ( !mcOnly )  drawSys(h2013_3,sysDphipp,kGreen,3001);
  if ( !mcOnly )  drawSys(dphihidata,sysDphi,10);
  if(drawMC) dphihimc->Draw("p same");
  // dphippmc->Draw("p");
  //  if ( !mcOnly )  dphippdata->Draw("p");
  for ( int icent=1 ; icent<=5 ; icent++){
    drawSys(hDphiPP2013[icent], hDphiPPUnc, kGreen,3001);
  }
  
  TH1D* hDphiPP2013Temp = new TH1D("hDphiPP2013Temp","",1,380,400);
  hDphiPP2013Temp->SetBinContent(1,0.27);
  hDphiPP2013[5]->SetMarkerStyle(20);
  for ( int icent=1 ; icent<=5 ; icent++){ 
    hDphiPP2013[icent]->Draw("same");
  }
  if ( !mcOnly )  dphihidata->Draw("p");

  // TLegend *legDphi =  new TLegend(0.32,0.18,0.93,0.7,NULL,"brNDC");
  // easyLeg(legDphi,"");
  // legDphi->SetTextSize(17);
  // //  drawText("|#Delta#phi_{J#gamma}| > #frac{2}{3}#pi",0.5,0.38,0);
  // //  drawText("Fit : #frac{e^{#frac{|#Delta#phi_{J#gamma}|-#pi}{#sigma}}}{#sigma(1-e^{-#pi/#sigma})}",0.5,0.23,0);
  // legDphi->Draw();
  // //  drawText("(a)",0.22,0.87,1);
  // //  drawText("CMS",0.78,0.88,1);


  TH1D* hSysTemp = new TH1D("hSystemp","",1,0,1);
  hSysTemp->SetFillColor(newYellow);
  hSysTemp->SetLineColor(newYellow);

  leg4->Draw();

  drawText(Form("p^{#gamma}_{T} > %d GeV/c     |#eta^{#gamma}| < 1.44",etPho),0.25,0.3,0,15);
  drawText(Form("p^{Jet}_{T} > %d GeV/c    |#eta^{Jet}| < 1.6",etJet),0.25,0.2,0,15);
  drawCMSppPbPb(0.1,0.95,12);

  gPad->RedrawAxis();
  c4->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_dphi_npart.pdf");
  //c4->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_dphi_npart.png");
  //c4->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_dphi_npart.gif");
  //c4->SaveAs("plotPPPbPb/inclusivePt_ppPbPb_dphi_npart.C");

   // // print numbers
   // std::cout << " Summary of Points for PbPb " << std::endl;
   // PrintGraphAndSys(dphihidata,sysDphi);
   // PrintGraphAndSys(mxhidata,sysMx);
   // PrintGraphAndSys(rxhidata,sysR);

   // std::cout << " Summary of Points for PYTHIA + HYDJET " << std::endl;
   // PrintGraph(dphihimc);
   // PrintGraph(mxhimc);
   // PrintGraph(rxhimc);

   //   std::cout << " Summary of Points for pp " << std::endl;
   //  PrintGraphAndSys(dphippdata[5],sysDphipp);
   //  PrintGraphAndSys(mxppdata[5],sysMxpp);
   // PrintGraphAndSys(rxppdata[5],sysRpp);


   
   /*
   TCanvas *c5 = new TCanvas("c5","",500,500);
   hxgj[khidata][0]->SetAxisRange(-.2,2.5,"Y");
   hxgj[khidata][0]->SetNdivisions(505);
   fixedFontHist(hxgj[khidata][0],1,1.35);
   handsomeTH1(hxgj[khidata][0],2);
   hxgj[khidata][0]->GetYaxis()->SetTitleOffset(1.5);
   hxgj[khidata][0]->DrawCopy("");
   handsomeTH1(hxgj[kppdata13][5],4);
   hxgj[kppdata13][5]->Draw("same hist");
   onSun(0,0,2,0);
   */
}
Example #20
0
void drawDCAcontamination(){
gStyle->SetOptStat(0);
    TFile * file = TFile::Open("/Users/sandrobjelogrlic/Analysis/HFCorrelations/Results/MCCE/83_12022015/10f7a/AnalysisResults.root");
    
    TDirectoryFile * dir = (TDirectoryFile*)file->Get("PWGHF_HFCJ_SE_EffY_DEffY_vsPt_32_bins_SE_RECO_reco_2_348_sigmas");
    TList * list = (TList*)dir->Get("OutputMCSE_RECO");
    
    TH1D * isPhysPrimDCA = (TH1D*)list->FindObject("isPhysPrimDCA");
    TH1D * isSecondaryDCA = (TH1D*)list->FindObject("isSecondaryDCA");
    
    isPhysPrimDCA->GetXaxis()->SetRangeUser(0,2);
    
    isPhysPrimDCA->SetLineColor(2);
    isSecondaryDCA->SetLineColor(4);
     isPhysPrimDCA->SetTitle("; DCA_{XY} (cm); Counts");
    isPhysPrimDCA->GetYaxis()->SetTitleOffset(1.2);
    
    TPaveText * PaveText = new TPaveText(0.5,0.55,0.8,0.7,"NDC");
    PaveText->SetBorderSize(0);
    PaveText->SetFillColor(0);
    PaveText->SetName("pave");
   // PaveText->AddText("THIS THESIS");
   // PaveText->AddText(" ");
    PaveText->AddText("Phytia, pp #sqrt{s} = 7 TeV");
    //PaveText->AddText(" ");
   // PaveText->AddText("Fraction of Primary tracks as funct");
    
    TLine * cut = new TLine(0.25,0,0.25,10000000);
    cut->SetLineStyle(2);
    
    TLegend * legend = new TLegend(0.4,0.7,0.8,0.85);
    //  TLegend * legend = new TLegend(0.1, 1.2*DStarPeak->GetBinContent(DStarPeak->GetMaximumBin()),0.4, 1.6*DStarPeak->GetBinContent(DStarPeak->GetMaximumBin()));
    legend->SetFillColor(0);
    legend->SetTextSize(0.03);
    
    legend->SetBorderSize(0);
    legend->AddEntry(isPhysPrimDCA,"Primary tracks","l");
    legend->AddEntry(isSecondaryDCA,"Secondary tracks","l");
    legend->AddEntry(cut,"Standard cut, DCA_{XY} < 0.25 cm","l");
    //legend->AddEntry(h_Perugia2011,"Pythia, Perugia 2011 tune","lep");
    
    
    
    
    TCanvas * c1 = new TCanvas("c1","c1",0,0,1000,1000);
    c1->cd();
    c1->SetLogy();
    isPhysPrimDCA->Draw();
    isSecondaryDCA->Draw("same");
    legend->Draw("same");
    PaveText->Draw("same");
    cut->Draw("same");
    
    
    
   // cout << "Integral is " << getIntegral(DCA,isPhysPrimDCA) << endl;
    TLegend * legend2 = new TLegend(0.4,0.7,0.8,0.85);
    //  TLegend * legend = new TLegend(0.1, 1.2*DStarPeak->GetBinContent(DStarPeak->GetMaximumBin()),0.4, 1.6*DStarPeak->GetBinContent(DStarPeak->GetMaximumBin()));
    legend2->SetFillColor(0);
    legend2->SetTextSize(0.03);
    
    legend2->SetBorderSize(0);
 
    legend2->AddEntry(cut,"Standard cut, DCA_{XY} < 0.25 cm","l");
    
    TPaveText * PaveText2 = new TPaveText(0.5,0.3,0.8,0.5,"NDC");
    PaveText2->SetBorderSize(0);
    PaveText2->SetFillColor(0);
    PaveText2->SetName("pave2");
    // PaveText->AddText("THIS THESIS");
    // PaveText->AddText(" ");
    PaveText2->AddText("PYTHIA, pp #sqrt{s} = 7 TeV");
    TH1D * contamination = (TH1D*)isPhysPrimDCA->Clone("contamination");
    contamination->Reset();
    contamination->SetTitle("; DCA_{XY} (cm); Purity");
    
    contamination->GetYaxis()->SetRangeUser(0.8,1.05);
    contamination->GetXaxis()->SetRangeUser(0,1);
    contamination->SetLineColor(1);
    contamination->SetLineWidth(2);
    contamination->GetYaxis()->SetTitleOffset(1.4);


    Double_t dcavalue = 0;
    
    for(Int_t k=0; k<2000; k++){
     
        dcavalue += 0.001;
        contamination->SetBinContent(k+1,getPurity(dcavalue,isPhysPrimDCA,isSecondaryDCA));
    }
    
    TLine * cut2 = new TLine(0.25,0.8,0.25,1.05);
    cut2->SetLineStyle(2);
    
    TCanvas * c2 = new TCanvas("c2","c2",0,0,1000,1000); c2->cd();
    contamination->Draw();
    PaveText2->Draw("same");
    cut2->Draw("same");
    legend2->Draw("same");
    
    
     c1->SaveAs("/Users/sandrobjelogrlic/PhD_Thesis/Figures/Chapter_3/DCADistrib.pdf");
     c1->SaveAs("/Users/sandrobjelogrlic/PhD_Thesis/Figures/Chapter_3/DCADistrib.eps");
    c1->SaveAs("/Users/sandrobjelogrlic/PhD_Thesis/Figures/Chapter_3/DCADistrib.png");
     c1->SaveAs("/Users/sandrobjelogrlic/PhD_Thesis/Figures/Chapter_3/DCADistrib.root");
    c2->SaveAs("/Users/sandrobjelogrlic/PhD_Thesis/Figures/Chapter_3/purity.pdf");
     c2->SaveAs("/Users/sandrobjelogrlic/PhD_Thesis/Figures/Chapter_3/purity.png");
     c2->SaveAs("/Users/sandrobjelogrlic/PhD_Thesis/Figures/Chapter_3/purity.eps");
     c2->SaveAs("/Users/sandrobjelogrlic/PhD_Thesis/Figures/Chapter_3/purity.root");
   
}
Example #21
0
// -----------------------------------------------------------------------------
//
TCanvas* createPlot( TString path, 
		     TString canvas_name, 
		     TString name, 
		     TString dirmame, 
		     int rebin, 
		     bool norm, 
		     bool log,
		     TDirectory* file )
{

  // SetSomeStyles();

  float lumi = 250.0;// 15.04;//10.9;//6.8;
 
  // Create legend
  TLegend* legend = new TLegend(0.75, 0.6, 0.99, 0.99, "", "brNDC" );
  legend->SetFillColor(0);
  legend->SetLineColor(0); 
  legend->SetShadowColor(0);
  TLatex* prelim = new TLatex(0.6,0.54,"#scale[0.8]{CMS preliminary 2010}");
  prelim->SetNDC();
  TLatex* alumi = new TLatex(0.6,.45,"#scale[0.8]{#int L dt = 35 pb^{-1}, #sqrt{s} = 7 TeV}");
  alumi->SetNDC();

  // Create canvas 
  TCanvas* aCanvas = createCanvas( canvas_name, file, log );

  // Create histogram
  TString aname("nAll");
  // TH1D* data1    = getHisto( path+"S14datacleaned/Edward_Data_Skim/",name,"data.root",aname,rebin);
  // TH1D* data    = getHisto( path+"S14datacleaned/Edward_Data_Skim/",name,"data.root",dirmame,rebin);
 
  TH1D* data    = getHisto( path+"", name, "tt.root", dirmame, rebin );
  TH1D* qcd     = getHisto( path+"", name, "lm1.root", dirmame, rebin );
  TH1D* w_jets  = getHisto( path+"", name, "w.root", dirmame, rebin );
  TH1D* tt_jets = getHisto( path+"", name, "tt.root", dirmame, rebin );
  TH1D* z_jets  = getHisto( path+"", name, "z.root", dirmame, rebin );
  TH1D* lm3     = getHisto( path+"", name, "lm3.root", dirmame, rebin );
  TH1D* lm1     = getHisto( path+"", name, "lm1.root", dirmame, rebin );
  TH1D* lm6     = getHisto( path+"", name, "data.root", dirmame, rebin );
  TH1D* wm     = getHisto( path+"", name, "w.root", dirmame, rebin );
  data->Scale(lumi/100.);
  qcd->Scale(lumi/100.);
  tt_jets->Scale(lumi/100);
  w_jets->Scale(lumi/100);
  //  w_jets->Scale(10);
  //  z_inv->Scale(lumi/100);
  //  lm6->Scale(lumi/100);
  lm1->Scale(lumi/100);
  lm3->Scale(lumi/100);
  z_jets->Scale(lumi/100);
  wm->Scale(lumi/100);
  // Combine Z+jets and Z->inv
  // TH1D* z_all = z_inv->Clone(); 
  //  z_all->Add(z_jets,1);
  //z_jets->Add(z_inv,1);
  TH1D* total = tt_jets->Clone();
  total->Add(w_jets);
  total->Add(z_jets);

  // total->
 
  Int_t binMax =   total->GetNbinsX();
  Double_t& err = new Double_t(0.);
  total->IntegralAndError(10,binMax ,err);
  Double_t& errW = new Double_t(0.);
  w_jets->IntegralAndError(10,binMax ,errW);
  Double_t& errtt = new Double_t(0.);
  tt_jets->IntegralAndError(10,binMax ,errtt);
  Double_t& errZ = new Double_t(0.);
  z_jets->IntegralAndError(10,binMax ,errZ);
  Double_t& errQCD = new Double_t(0.);
  qcd->IntegralAndError(10,binMax ,errQCD );


  cout  <<endl;
  //  cout << "MC:" <<  total->IntegralAndError(11,binMax ,err) <<" && " <<  w_jets->Integral(11,binMax)<<" && "<<tt_jets->Integral(11,binMax) << "&&  "<<z_jets->Integral(11,binMax)<<" && "<< "\/\ /\hline"<<endl;
  //  cout << total->IntegralAndError(0,binMax ,err) <<" & " << lm1->Integral(0,binMax) <<" & " << lm3->Integral(0,binMax)<<" & " << lm6->Integral(0,binMax)   <<"\\\\ \\hline"<<endl;
  //  cout <<"270: " <<  total->IntegralAndError(27,binMax ,err) <<" & " << lm1->Integral(27,binMax) <<" & " << lm3->Integral(27,binMax)<<" & " << lm6->Integral(27,binMax)   <<"\\\\ \\hline"<<endl;


  cout <<"250& " <<  total->IntegralAndError(6,binMax ,err) <<" & " << lm1->Integral(6,binMax) <<" & " << lm3->Integral(6,binMax)<<" & " << lm6->Integral(6,binMax)   <<"\\\\ \\hline"<<endl;
 
  // cout << "300: " <<  total->IntegralAndError(7,binMax ,err) <<" & " << lm1->Integral(7,binMax) <<" & " << lm3->Integral(7,binMax)<<" &" << lm6->Integral(7,binMax)   <<"\\\\ \\hline"<<endl;

  cout <<"350& " <<  total->IntegralAndError(8,binMax ,err) <<" & " << lm1->Integral(8,binMax) <<" & " << lm3->Integral(8,binMax)<<" & " << lm6->Integral(8,binMax)    <<"\\\\ \\hline"<<endl;

  //   cout << "400: " <<  total->IntegralAndError(9,binMax ,err) <<" & " << lm1->Integral(9,binMax) <<" & " << lm3->Integral(9,binMax)<<" & " << lm6->Integral(9,binMax)    <<"\\\\ \\hline"<<endl;

cout << "450& " <<  total->IntegralAndError(10,binMax ,err) <<" & " << lm1->Integral(10,binMax) <<" & " << lm3->Integral(10,binMax)<<" & " << lm6->Integral(10,binMax)    <<"\\\\ \\hline"<<endl;

//cout << "500: " <<   total->IntegralAndError(11,binMax ,err) <<" & " << lm1->Integral(11,binMax) <<" & " << lm3->Integral(11,binMax)<<" & " << lm6->Integral(11,binMax)    <<"\\\\ \\hline"<<endl;

  cout <<"550& " <<  total->IntegralAndError(12,binMax ,err) <<" & " << lm1->Integral(12,binMax) <<" & " << lm3->Integral(12,binMax)<<" & " << lm6->Integral(12,binMax)    <<"\\\\ \\hline"<<endl;
  /*
 cout << "MC:" <<  total->IntegralAndError(7,binMax ,err) <<" && " << lm1->Integral(7,binMax) <<" && " << lm3->Integral(7,binMax)<<" && " << lm6->Integral(6,binMax)   <<"/\/\ /\hline"<<endl;
  cout << "MC:" <<  total->IntegralAndError(8,binMax ,err) <<" && " << lm1->Integral(8,binMax) <<" && " << lm3->Integral(8,binMax)<<" && " << lm6->Integral(7,binMax)   <<"/\/\ /\hline"<<endl;
  cout << "MC:" <<  total->IntegralAndError(10,binMax ,err) <<" && " << lm1->Integral(10,binMax) <<" && " << lm3->Integral(10,binMax)<<" && " << lm6->Integral(10,binMax)   <<"/\/\ /\hline"<<endl;
 cout << "MC:" <<  total->IntegralAndError(11,binMax ,err) <<" && " << lm1->Integral(11,binMax) <<" && " << lm3->Integral(11,binMax)<<" && " << lm6->Integral(11,binMax)   <<"/\/\ /\hline"<<endl;
 cout << "MC:" <<  total->IntegralAndError(12,binMax ,err) <<" && " << lm1->Integral(12,binMax) <<" && " << lm3->Integral(12,binMax)<<" && " << lm6->Integral(12,binMax)   <<"/\/\ /\hline"<<endl;
  // cout << "MC:" << err  <<", W: " << errW<<", tt: "<<errtt << ", Z: "<<errZ<<", QCD: "<<  errQCD<< endl;
  */

  //  cout << "data:" << data->Integral() << endl;


  TH1D* hcen = total->Clone();
  TH1D* herr = total->Clone();
  
  herr->SetLineColor(kTeal+3);
  herr->SetMarkerColor(kAzure+6);
  herr->SetFillColor(kAzure+6);
  herr->SetLineWidth(3);
  
  total->SetLineWidth(3);
  total->SetFillColor(kAzure+2);
  total->SetLineColor(kAzure+2);
  total->SetFillStyle(3245);
 
  hcen->SetFillStyle(0);
  hcen->SetMarkerColor(kTeal+3);
  hcen->SetLineColor(kTeal+3);
  hcen->SetLineWidth(3);

  // Merge Z+jets and Z->inv
  bool combine = false;
  
  // Line colour and fill
  qcd->SetLineColor(kPink+4);
  qcd->SetLineWidth(3);
  tt_jets->SetLineColor(kBlue+1);
  tt_jets->SetLineWidth(3);
  
  w_jets->SetLineColor(kPink+7);
  w_jets->SetLineWidth(3);

  z_jets->SetLineWidth(3);
  z_jets->SetLineColor(kTeal-7);
  
  if ( combine ) {
    z_all->SetLineColor(kBlack);
    z_all->SetLineStyle(3);
    z_all->SetLineWidth(1);
  } else {
    data->SetLineColor(1);
    data->SetLineStyle(1);
    data->SetLineWidth(3);
    data->SetMarkerStyle(20);
    data->SetFillColor(0);
  }
  //  lm0->SetLineColor(kRed);
  //  lm0->SetLineWidth(3);
  // lm1->SetLineColor(kRed+3);
  // lm1->SetLineWidth(3);

  // Populate legend
  // legend->AddEntry( data, "tt fully leptonic/", "LP" );
   legend->AddEntry( herr, "full SM", "LP" );
    legend->AddEntry( z_jets, " Z+jets ", "LP" );
    legend->AddEntry( w_jets, " W+jets", "LP" );
    legend->AddEntry( tt_jets, " t#bar{t}", "LP" );
    //  legend->AddEntry( lm3, " SUSY LM3", "LP" );
    //   legend->AddEntry( lm1, " SUSY LM1", "LP" );
    legend->AddEntry( lm6, " data", "LP" );
    // legend->AddEntry(wm,"W Mad","lp");
    
  // Calc maximum number of entries
  double aMax = 0.;
  if( data->GetMaximum()     > aMax ) { aMax = data->GetMaximum()+data->GetBinError(data->GetMaximumBin()); }
  if ( qcd->GetMaximum()     > aMax ) { aMax = qcd->GetMaximum(); }
  //  if ( lm0->GetMaximum()     > aMax ) { aMax = lm0->GetMaximum(); }
  //  if ( lm1->GetMaximum()     > aMax ) { aMax = lm1->GetMaximum(); }
  if ( tt_jets->GetMaximum() > aMax ) { aMax = tt_jets->GetMaximum(); }  
  if ( w_jets->GetMaximum()  > aMax ) { aMax = w_jets->GetMaximum(); }  
  if ( combine ) {
    if ( z_all->GetMaximum()  > aMax ) { aMax = z_all->GetMaximum(); }  
  } else {
    //   if ( data->GetMaximum()   > aMax ) { aMax = z_inv->GetMaximum(); }  
    if ( z_jets->GetMaximum()  > aMax ) { aMax = z_jets->GetMaximum(); }  
  }

  // Calc minimum number of entries
  double aMin = 1.e12;
  if ( qcd->GetMinimum(1.e-12)     < aMin ) { aMin = qcd->GetMinimum(1.e-12); }
  //  if ( lm0->GetMinimum(1.e-12)     < aMin ) { aMin = lm0->GetMinimum(1.e-12); }
  //  if ( lm1->GetMinimum(1.e-12)     < aMin ) { aMin = lm1->GetMinimum(1.e-12); }
  if ( tt_jets->GetMinimum(1.e-12) < aMin ) { aMin = tt_jets->GetMinimum(1.e-12); }  
  if ( w_jets->GetMinimum(1.e-12)  < aMin ) { aMin = w_jets->GetMinimum(1.e-12); }  
  if ( combine ) {
    if ( z_all->GetMinimum(1.e-12)   < aMin ) { aMin = z_all->GetMinimum(1.e-12); }  
  } else {
    // if ( data->GetMinimum(1.e-12)   < aMin ) { aMin = z_inv->GetMinimum(1.e-12); }  
    if ( z_jets->GetMinimum(1.e-12)  < aMin ) { aMin = z_jets->GetMinimum(1.e-12); }  
  }

  if ( qcd ) qcd->GetYaxis()->SetTitleOffset(1.43);
  if ( qcd ) qcd->GetYaxis()->SetTitleSize(0.06);
  if ( qcd ) qcd->GetXaxis()->SetTitleSize(0.06);
  if ( qcd ) qcd->GetXaxis()->SetTitleOffset(0.9);

 
  if ( log ) {
    if ( qcd ) herr->SetMaximum( aMax * 10. );
    //   if ( qcd ) herr->SetMinimum( aMin * 0.1 );
    if ( qcd ) herr->SetMinimum( 0.005);
  } else {
    if ( qcd ) herr->SetMaximum( aMax * 1.1 );
    //   if ( qcd ) herr->SetMinimum( aMin * 0.9 );
  if ( qcd ) herr->SetMinimum( 0.005);

  }

  /*  TPad* mainPad = new TPad("","",0.01,0.25,0.99,0.99);
  mainPad->SetNumber(1);
  mainPad->SetFillColor(0);
  // mainPad->Range(-288.2483,-2.138147,1344.235,6.918939);
  mainPad->SetFillColor(0);
  mainPad->SetBorderMode(0);
  mainPad->SetBorderSize(2);
  if ( log == true)mainPad->SetLogy();
   mainPad->SetLeftMargin(0.1765705);
  mainPad->SetRightMargin(0.05772496);
  mainPad->SetTopMargin(0.04778761);
  mainPad->SetBottomMargin(0.1256637);
  mainPad->SetFrameFillStyle(0);
  mainPad->SetFrameLineWidth(2);
  mainPad->SetFrameBorderMode(0);
  mainPad->SetFrameFillStyle(0);
  mainPad->SetFrameLineWidth(2);
  mainPad->SetFrameBorderMode(0);
  if ( log == true)mainPad->SetLogy();
  mainPad->Draw();
  TPad*  ratioPad = new TPad("","",0.01,0.01,0.99,0.25);
  ratioPad->SetNumber(2);
  ratioPad->SetFillColor(0);
  ratioPad->SetFillColor(0);
  ratioPad->SetBorderMode(0);
  ratioPad->SetBorderSize(2);
  // if ( log == true)ratioPad->SetLogy();
   ratioPad->SetLeftMargin(0.1765705);
  ratioPad->SetRightMargin(0.05772496);
  ratioPad->SetTopMargin(0.04778761);
  ratioPad->SetBottomMargin(0.1256637);
  ratioPad->SetFrameFillStyle(0);
  ratioPad->SetFrameLineWidth(2);
  ratioPad->SetFrameBorderMode(0);
  ratioPad->SetFrameFillStyle(0);
  ratioPad->SetFrameLineWidth(2);
  ratioPad->SetFrameBorderMode(0);
  //  if ( log == true)ratioPad->SetLogy();
  ratioPad->Draw();
 

  aCanvas->cd(1);
  */

  herr->GetYaxis()->SetTitle("events");


  if ( norm ) {
    if ( qcd ) qcd->DrawNormalized("Ehist");
    // if ( lm0->GetEntries() > 0. )     { lm0->DrawNormalized("hsame"); }
    if ( lm1->GetEntries() > 0. )     { lm1->DrawNormalized("hsame"); }
    if ( tt_jets->GetEntries() > 0. ) { tt_jets->DrawNormalized("hsame"); }
    if ( w_jets->GetEntries() > 0. )  { w_jets->DrawNormalized("hsame"); }
    if ( combine ) {
      if ( z_all->GetEntries() > 0. )   { z_all->DrawNormalized("hsame"); }
    } else {
      if ( data->GetEntries() > 0. )   { z_inv->DrawNormalized("hsame"); }
      if ( z_jets->GetEntries() > 0. )  { z_jets->DrawNormalized("hsame"); }
    }
  } else {
     herr->Draw("hist");
   
   
     // qcd->SetFillStyle(3240);
     // qcd->SetFillColor(kPink+4);
    // qcd->Draw("hist");
    w_jets->Draw("hSameh");
    z_jets->Draw("9Sameh");
    w_jets->Draw("9Sameh");
    tt_jets->Draw("9SAMEh");
    //data1->Draw("9SAMEh");
     //lm0->Draw("9SAMEh");
     lm1->SetLineColor(12);
     lm1->SetLineStyle(2);
     lm1->SetLineWidth(2);
     //     lm1->Draw("9SAMEh");
     lm3->SetLineColor(14);
     lm3->SetLineStyle(2);
     lm3->SetLineWidth(2);
     //  lm3->Draw("9SAMEh");
     lm6->Draw("9SAMEh");
     wm->SetLineStyle(2);
     wm->SetLineColor(kPink+7);
     // wm->Draw("9Sameh");

     // total->DrawNormalized("9E2same");
     //      data->Draw("SAMEh");
    //  tt_jets->Divide(data);
    //  tt_jets->Draw("h");
  //  data->SetLineColor(kRed);
  //  data->Draw("sameh");
     //     data1->SetLineColor(kRed);
     //  data1->Draw("9SAMEP");
  }
  
    legend->Draw();
  // prelim->Draw();
  // alumi->Draw();



  /*  TH1D* ratioBottom = total->Clone();
  TH1D* ratioTop = data->Clone();
  ratioTop->GetYaxis()->SetTitle("data / sim");
  ratioTop->Divide(ratioBottom);
  
  aCanvas->cd(1)->Update();
 
  aCanvas->cd(2);

  ratioTop->SetTitleSize(0.1, "XYZ");
  ratioTop->SetTitleOffset(0.55, "X");
  ratioTop->SetTitleOffset(0.3, "Y");
  ratioTop->SetLabelSize(0.06,"XY");
    
  // ratioTop->GetXaxis().SetRangeUser(MinX,MaxX);
  ratioTop->GetYaxis()->SetRangeUser(0.,2.0);
  ratioTop->Draw();*/
  /* TBox* unity = TBox(ratioTop->GetXaxis()->GetBinLowEdge(ratioTop->GetXaxis()->GetFirst()), 0.89,ratioTop->GetXaxis()->GetBinLowEdge(ratioTop->GetXaxis()->GetLast()), 1.11);
  unity->SetLineWidth(2);
   
  unity->SetLineColor(2);
  unity->SetFillColor(2);
  unity->SetFillStyle(3002);
  unity->Draw();

  */
  file->cd();
 
  aCanvas->SaveAs( std::string(canvas_name+".pdf").c_str() );
  aCanvas->Write();



  //   aCanvas->Print(".png");
 return aCanvas;

}
/* ***************************************************************************************************************** */
int main(int argc, char* argv[]) {

  cout << "sis3316_offline" << endl; // prints sis3316_offline

  /******************************************************************************************************************************/
  /* CERN ROOT                                                                                                                  */
  /******************************************************************************************************************************/

  #ifdef CERN_ROOT_PLOT

    printf("--> CERN_ROOT_PLOT is defined \n");
    int root_graph_x ;
    int root_graph_y ;
    int root_graph_x_size ;
    int root_graph_y_size ;
    char root_graph_text[80] ;

    root_graph_x_size = 1000 ;
    root_graph_y_size = 500 ;

    root_graph_x = 10 ;
    root_graph_y = 620 ;

    cout << "argc: " << argc << endl;
    for (int i = 1; i < argc; i++){ cout << "argv[" << i << "]: " << argv[i] << endl; }


    // this root class extracts data from argc and argv, modifying them in the
    // process
    TApplication theApp("SIS3316 Application: Test", &argc, argv);
    strcpy(root_graph_text,"SIS3316 Graph: Raw data") ;
    gl_graph_raw      = new sis_root_graph(root_graph_text, root_graph_x, root_graph_y, root_graph_x_size, root_graph_y_size) ;

  #endif

  #ifdef raus
    printf("--> raus is defined \n");
    // file read
    gl_FILE_DataEvenFilePointer = fopen("ne213/sis3316_test_data.dat","rb") ;
    if (gl_FILE_DataEvenFilePointer == NULL) {
            printf("gl_FILE_DataEvenFilePointer == NULL \n");
            return -1;
    }
    else {
            printf("file is opened \n");
    }
  #endif
  UInt_t valid_BankBufferHeader_valid_flag ;
  int nof_read ;
  UInt_t buffer_no ;
  UInt_t i_event ;
  UInt_t nof_events ;
  UInt_t buffer_length ;
  UInt_t event_length ;
  UInt_t header_length ;
  UInt_t wfm_length ;
  UInt_t channel_no ;
  UInt_t maw_length ;
  UInt_t i_ch ;
  UInt_t headerformat ;
  UInt_t header_indentifier ;
  UInt_t header_reserved ;


  //gl_graph_raw->sis3316_draw_XYaxis (50000); // clear and draw X/Y
  //gl_graph_raw->sis3316_draw_XYaxis (wfm_length); // clear and draw X/Y
  UInt_t bank_buffer_counter ;

  char filename[128]  ;
  int i_file;

  bank_buffer_counter = 8 ;


  bool doDraw = true;
  if ( gROOT->IsBatch() ) {
    doDraw = false; 
    cout << "--> running in batch mode" << endl;
  }

  // loop over enumerated files in internal directory:
  //for (i_file=0; i_file<10; i_file++) {

    //sprintf(filename,"../data_files/sample_test_gui/sis3316_test_data_%d.dat",i_file ) ;
    //sprintf(filename,"../data_files/external/sis3316_test_data_%d.dat",i_file ) ;
    //sprintf(filename,"../data_files/internal/sis3316_test_data_%d.dat",i_file ) ;

  // loop over args:
  for (i_file = 1; i_file<theApp.Argc(); i_file++) {

    //cout << "filename: " <<  argv[i_file+1] << endl;
    //sprintf(filename,"%s",argv[i_file+1]) ;
    sprintf(filename,"%s", theApp.Argv(i_file)) ;

#ifdef CERN_ROOT_PLOT


    string filename_str(filename);
    if ( filename_str.size() < 3 ) { 
      cout << "option: " << filename_str << endl; 
      continue; 
    }
    cout << "filename: " << filename << endl;
    size_t dot = filename_str.find_last_of(".");
    size_t slash = filename_str.find_last_of("/");
    string basename_str = "tier1_" + filename_str.substr(slash+1, dot-slash-1);
    string config_filename_str = filename_str.substr(0, dot) + ".ini";
    cout << "Setting file label " << basename_str << endl;

    // open a root file
    TFile root_file((basename_str + ".root").c_str(), "recreate");

    // make trees
    TTree *tree[16];

    //default values for branches
    //global parameters
        Bool_t is_external = true;
        Float_t sampling_freq_Hz = 25e6; // in Hz
        UShort_t wfm_delay = 200;
        UShort_t maw_delay = 600;
        Bool_t is_pospolarity[16];
        Bool_t is_50ohm[16];
        Bool_t is_2Vinput[16];
        UShort_t maw_gap = 250;
        UShort_t maw_peaking = 50;
        UShort_t maw_thres = 60;
        for(int i=0; i<=15; i++) {is_pospolarity[i] = is_50ohm[i] = is_2Vinput[i] = true;}

     //read from config file
        ReadConfigFile(config_filename_str, &is_external, &sampling_freq_Hz, &wfm_delay, &maw_delay, is_pospolarity, is_50ohm, is_2Vinput, &maw_gap, &maw_peaking, &maw_thres);

     //other parameters
        Int_t wfm_max = 0; 
        UShort_t wfm_max_time = 0;
        Int_t wfm_min = 0;
        Int_t maw_max = 0; 
        Int_t maw_min = 0; 
        UChar_t channel = 0;
        ULong64_t timestamp = 0;
        Double_t timestampDouble = 0;
        //ULong64_t timestampLo = 0;
        //ULong64_t timestampHi = 0;
        UShort_t * wfm = new UShort_t[65536]; 
        Int_t * maw = new Int_t[2048*4];

    //read configuration file

    for(int i=0; i<=15; i++) { // looping over the 16 trees
        ostringstream treename;
        treename << "tree" << i;
        tree[i] = new TTree(treename.str().c_str(), "tree of SIS waveform data");

        // global parameters
        tree[i]->Branch("is_external", &is_external, "is_external/O");
        tree[i]->Branch("sampling_freq_Hz", &sampling_freq_Hz, "sampling_freq_Hz/F");
        tree[i]->Branch("wfm_delay", &wfm_delay, "wfm_delay/s");
        tree[i]->Branch("wfm_length", &wfm_length, "wfm_length/i");
        tree[i]->Branch("maw_delay", &maw_delay, "maw_delay/s");
        tree[i]->Branch("maw_length", &maw_length, "maw_length/i");
        tree[i]->Branch("is_pospolarity", &is_pospolarity[i], "is_pospolarity/O");
        tree[i]->Branch("is_50ohm", &is_50ohm[i], "is_50ohm/O");
        tree[i]->Branch("is_2Vinput", &is_2Vinput[i], "is_2Vinput/O");
        tree[i]->Branch("maw_gap", &maw_gap, "maw_gap/s");
        tree[i]->Branch("maw_peaking", &maw_peaking, "maw_peaking/s");
        tree[i]->Branch("maw_thres", &maw_thres, "maw_thres/s");

        // create a maximum-value branch
        //UInt_t wfm_max = 0; 
        tree[i]->Branch("wfm_max", &wfm_max, "wfm_max/I");

        // time of waveform max value:
        //UInt_t wfm_max_time = 0;
        tree[i]->Branch("wfm_max_time", &wfm_max_time, "wfm_max_time/s");

        // create a mininum-value branch
        //UInt_t wfm_min = 0; 
        tree[i]->Branch("wfm_min", &wfm_min, "wfm_min/I");

        // create a maximum-value branch
        //signed int maw_max = 0; 
        tree[i]->Branch("maw_max", &maw_max, "maw_max/I");

        // create a mininum-value branch
        //signed int maw_min = 0; 
        tree[i]->Branch("maw_min", &maw_min, "maw_min/I");

        // create a channel branch
        //int channel = 0;
        tree[i]->Branch("channel", &channel, "channel/b"); // 8 bit unsigned integer

        // create a timestamp branch
        //ULong64_t timestamp = 0;
        //double  timestampDouble = 0;
        tree[i]->Branch("timestamp", &timestamp, "timestamp/l"); // 64 bit unsigned integer (ULong64_t)
        tree[i]->Branch("timestampDouble", &timestampDouble, "timestampDouble/D"); // (Double_t)

        // create a buffer number branch
        // tree[i]->Branch("buffer_no", &buffer_no);

        // create an event  number branch
        tree[i]->Branch("event", &i_event, "event/i"); // unsigned integer (UInt_t)
    
        // wfm
        //UShort_t * wfm = new UShort_t[2048*4]; 
        tree[i]->Branch("wfm", wfm, "wfm[wfm_length]/s");

        // maw buffer
        tree[i]->Branch("maw_length", &maw_length);

        // maw
        //signed int * maw = new signed int[2048*4]; 
        tree[i]->Branch("maw", maw, "maw[maw_length]/I");
    }
#endif

    cout << "argc: " << argc << endl;
    for (int i = 1; i < argc; i++){ cout << "argv[" << i << "]: " << argv[i] << endl; }

    //cout << theApp.Argc() << endl;
    //cout << theApp.Argv(i_file) << endl;

    printf("--> processing file: %s\n",filename) ;
    gl_FILE_DataEvenFilePointer = fopen(filename,"rb") ;
    if (gl_FILE_DataEvenFilePointer != NULL) {

      do {

        valid_BankBufferHeader_valid_flag = 0 ;

        // read the buffer header
        nof_read = ReadBufferHeaderCounterNofChannelToDataFile (&header_indentifier, &buffer_no, &channel_no, &nof_events, &event_length, &maw_length, &header_reserved) ;
        buffer_length = event_length * nof_events ;

        printf("\n");
        printf("header information: \tnof_read = %d    \tindentifier = %d   \tbuffer_no = %d  \tchannel_no = %d   \n", nof_read, header_indentifier, buffer_no, channel_no);
        printf("header information: \tnof_events = %d  \tbuffer_length = %d   \tevent_length = %d    \n", nof_events, buffer_length, event_length );
        printf("header information: \tmaw_length = %d \treserved = %d \n",  maw_length, header_reserved);
        unsigned uint_plot_axis_flag;
        if (nof_read == 8) {
          uint_plot_axis_flag = 1 ;
          valid_BankBufferHeader_valid_flag = 1 ;

          // read buffer (of nof_events  events) into gl_ch_data 
          nof_read =  ReadEventsFromDataFile (gl_ch_data, buffer_length);

          // grab header format and channel number from the 0th event; assume
          // this applies to all nof_events 

          // mask to get the header format:
          headerformat =  (gl_ch_data[0] & 0xf) ;

          // mask and bitshift to get the channel number 
          i_ch = (gl_ch_data[0] & 0xfff0) >> 4 ;
          
          printf("nof_read = %d  \tch = %d   \theaderformat = 0x%02X \n", nof_read, i_ch, headerformat);

          if (i_ch != channel_no) {
            cout << "WARNING -- i_ch=" << i_ch << ", channel_no=" << channel_no << endl; 
          }

          header_length = 3 ; // if headerformat == 0
          if((headerformat & 0x1) == 1) {header_length = header_length + 7; }
          if((headerformat & 0x2) == 2) {header_length = header_length + 2; }
          if((headerformat & 0x4) == 4) {header_length = header_length + 3; }
          if((headerformat & 0x8) == 8) {header_length = header_length + 2; }

          // wfm_length is the number of 16-bit ADC samples in each event
       // event_length is the number of 32-bit words in each event
          wfm_length = 2 * (gl_ch_data[header_length-1] & 0x3ffffff) ; // if headerformat == 0

          if(uint_plot_axis_flag == 1) {
                  //printf("uint_plot_axis_flag == 1\n");
                  uint_plot_axis_flag = 0 ;
                  gl_graph_raw->sis3316_draw_XYaxis (wfm_length); // clear and draw X/Y
          }

          // loop over all events in gl_ch_data
          for (i_event = 0; i_event < nof_events; i_event++) {
            //if (i_event<10) { // plot ony the first 10. events
            //if (i_event<1) { // plot ony 1. event

              //cout << sizeof(UInt_t) << endl;
              // gl_ch_data is an UInt_t is 4 bytes (32 bits), at least on
              // Alexis' Mac. Bit mask each part of the timestamp, then bit shift to
              // make the 48-bit timestamp
              // 0xffff = 32 bits, 4 bytes

              size_t event_index = i_event*event_length;

              //cout << "gl_ch_data[event_index + 1] : " << gl_ch_data[event_index + 1] << endl;
              //cout << "gl_ch_data[event_index]: " << gl_ch_data[event_index] << endl;
              //cout << "(gl_ch_data[event_index] & 0xffff0000): " << ( (ULong64_t) (gl_ch_data[event_index] & 0xffff0000)) << endl;
              //cout << "(gl_ch_data[event_index] & 0xffff0000) << 16 :" << ( (ULong64_t) (gl_ch_data[event_index] & 0xffff0000) << 16) << endl;

              timestamp = ( (ULong64_t) (gl_ch_data[event_index] & 0xffff0000) << 16) ;
              timestamp += gl_ch_data[event_index + 1];
              //timestampHi = ( (ULong64_t) (gl_ch_data[event_index] & 0xffff0000) << 16) ;
              //timestampLo = gl_ch_data[event_index + 1];
              timestampDouble = (Double_t) timestamp;


              // find the wfm maximum value
              wfm_max = 0; 
              wfm_max_time = 0;
              wfm_min = pow(2, 14); // max value of ADC
              UShort_t* ushort_adc_buffer_ptr = (UShort_t*) (&gl_ch_data[i_event*(event_length) + header_length]);
              for (UInt_t i = 0; i < wfm_length; i++ ) {
                UInt_t adc_value = (UInt_t) ushort_adc_buffer_ptr[i];
                wfm[i] = adc_value;
                //cout << i << " | " << adc_value << endl;
                if (adc_value > wfm_max){ 
                    wfm_max = adc_value; 
                    wfm_max_time = i;
                }
                if (adc_value < wfm_min){ wfm_min = adc_value; }
              }

              if (doDraw) {
                cout << "wfm_max: " << wfm_max << endl;
                cout << "timestamp: " << timestamp << endl;

                gl_graph_raw->sis3316_draw_chN (wfm_length,
                    &gl_ch_data[event_index + header_length], i_ch&0xf);

                // insert pause 
                cout << "event " << i_event 
                  << " | channel " << i_ch
                  << " |  enter to continue (q=quit, b=batch, p=print)--> ";
                int val = cin.get();
                cout << endl;
                if (val == (int) 'q' || val == (int) 'Q') { return 0; }
                if (val == (int) 'b') { doDraw = false; }
                if (val == (int) 'p') { 

                    ostringstream plotName; 
                    plotName << basename_str  << i_event;
                    //gl_graph_raw->c1->Print((plotName.str() + ".png").c_str());
                    //gl_graph_raw->c1->Print((plotName.str() + ".pdf").c_str());
                }
              }

              //wfm = (UShort_t*) &(gl_ch_data[event_index + header_length]);

              //------------------------------------------------------------------------------
              // MAW
              //------------------------------------------------------------------------------

              // find the maw maximum value
              // I hope this is the MAW
              maw_max = 0; 
              maw_min = INT_MAX; // max value of MAW

              //UShort_t* maw_adc_buffer_ptr = (UShort_t*)
              //(&gl_ch_data[i_event*(event_length) + header_length +
              //wfm_length/2]);

              // Tino says maw is 32 bits:
              UInt_t* maw_adc_buffer_ptr =
              &gl_ch_data[i_event*(event_length) + header_length +
              wfm_length/2];

              for (UInt_t i = 0; i < maw_length; i++ ) {
                signed int maw_value = maw_adc_buffer_ptr[i] - 0x8000000; // per Tino
                maw[i] = maw_value;

                //cout << i 
                //  << " | maw_adc_buffer_ptr[i]:" << maw_adc_buffer_ptr[i] 
                //  << " | maw_value: " << maw_value 
                //  << " | maw[i] " << maw[i] 
                //  << endl;

                if (maw_value > maw_max){ maw_max = maw_value; }
                if (maw_value < maw_min){ maw_min = maw_value; }
              }

              /*
              if (doDraw) {
                cout << "maw_max: " << maw_max << endl;
                cout << "timestamp: " << timestamp << endl;

                gl_graph_raw->sis3316_draw_chN (wfm_length,
                    &gl_ch_data[event_index + header_length + wfm_length/2], i_ch&0xf);

                // insert pause 
                cout << "event " << i_event 
                  << " | channel " << i_ch
                  << " |  enter to continue (q=quit, b=batch)--> ";
                int val = cin.get();
                cout << endl;
                if (val == (int) 'q' || val == (int) 'Q') { return 0; }
                if (val == (int) 'b') { doDraw = false; }
              }
              */

              channel = (gl_ch_data[event_index] & 0xfff0) >> 4;
              tree[channel]->Fill();

              // each buffer should contain data from only one channel
              if (i_ch != channel_no) {
                cout << "WARNING -- channel=" << channel << ", channel_no=" << channel_no << endl; 
              }

            //} // end limit on n events

          } // end loop over events

        } // end if(nof_read==8)
        else {
                valid_BankBufferHeader_valid_flag = 0 ;
        }
      } while(valid_BankBufferHeader_valid_flag == 1) ;
            printf("\n");

            fclose(gl_FILE_DataEvenFilePointer);
            printf("file closed and finished   \n");
            bank_buffer_counter++;
    }


  gROOT->SetStyle("Plain");     
  gStyle->SetOptStat(0);        
  gStyle->SetPalette(1);        
  gStyle->SetTitleStyle(0);     
  gStyle->SetTitleBorderSize(0);       

  int n_bins = 200;
  int min = 0;
  int max = 16384; 

  const size_t n_channels = 16; 
  const size_t n_colors = 4; 
  TH1D* hist_array[n_channels]; 
  int color[n_colors] = {kRed, kBlue, kGreen+1, kViolet}; 
  int fillStyle[n_channels] = {3004, 3005, 3006, 3007, 3001, 3002, 3003, 3016,
      3017, 3018, 3020, 3021}; 

  TH1D frame_hist("frame_hist","",n_bins, min, max);
  frame_hist.SetXTitle("Waveform max (ADC units)");
  frame_hist.SetYTitle("Counts");


  for (size_t i = 0; i <n_channels; i++) {

    ostringstream name; 
    name << "h" << i;
    TH1D* hist = new TH1D(name.str().c_str(), "", n_bins, min, max);
    int i_color = i % n_colors;
    //cout << i << " | " << name.str() << " | " << i_color << endl;
    hist->SetLineColor(color[i_color]);
    hist->SetFillColor(color[i_color]);
    hist->SetFillStyle(fillStyle[i]);
    hist_array[i] = hist;
  }

  TLegend legend(0.1, 0.81, 0.9, 0.99);
  legend.SetNColumns(4); 

  TCanvas canvas("canvas", "");
  canvas.SetLogy(1); 
  canvas.SetGrid(1,1);
  canvas.SetTopMargin(0.2);

  double hist_max = 0;
  frame_hist.Draw();

  for (size_t i = 0; i < n_channels; i++) {
  
    ostringstream entry;
    ostringstream name;
    ostringstream selection;

    name << "wfm_max >> h" << i;  
    selection << "channel==" << i; 
    int n_counts = tree[0]->Draw(name.str().c_str(), selection.str().c_str(), "same");
    cout << i << " | n counts = " << n_counts << " | " << name.str() << " | " << selection.str() << endl;
    entry << "ch " << i+1 << " (" << n_counts << ")";
    TH1D* hist = hist_array[i];
    legend.AddEntry(hist, entry.str().c_str(), "f");
    if ( n_counts > hist_max ) { hist_max = n_counts; }
  }

  frame_hist.SetMaximum(hist_max*1.1);

  legend.Draw();
  canvas.Update();
  //canvas.Print((basename_str + ".png").c_str());
  //canvas.Print((basename_str + ".pdf").c_str());

  for(int i=0; i<=15; i++) {tree[i]->Write();}
  canvas.Write();

// create a run_tree with event parameters
  TTree *run_tree = new TTree("run_tree", "run tree");
  run_tree->Branch("is_external", &is_external, "is_external/O");
  run_tree->Branch("sampling_freq_Hz", &sampling_freq_Hz, "sampling_freq_Hz/F");
  run_tree->Branch("wfm_delay", &wfm_delay, "wfm_delay/s");
  run_tree->Branch("wfm_length", &wfm_length, "wfm_length/i");
  run_tree->Branch("maw_delay", &maw_delay, "maw_delay/s");
  run_tree->Branch("maw_length", &maw_length, "maw_length/i");
  run_tree->Branch("maw_gap", &maw_gap, "maw_gap/s");
  run_tree->Branch("maw_peaking", &maw_peaking, "maw_peaking/s");
  run_tree->Branch("maw_thres", &maw_thres, "maw_thres/s");

  run_tree->Fill();
  run_tree->Write();

  } // end loop over arguments/files
void fakerate (int min = 0 , int max = 999) {

    TStyle * ts = (TStyle*)gROOT->GetStyle("Plain");
    ts->cd();
    ts->SetTitle(0);
    ts->SetOptStat(0000000);
    //ts->SetPalette(1);

    //cross sections in mb

    double sigma_15_20 = 1.46;
    double sigma_20_30 = 0.632;
    double sigma_30_50 = 0.163;
    double sigma_50_80 = 0.0216;
    double sigma_80_120 = 0.00308;

    std::vector<std::string> files;
    std::vector<double> weights;

    files.push_back("new1/FakeRate_qcd_loose_20_30.root");
    files.push_back("new1/FakeRate_qcd_loose_30_50.root");
    files.push_back("new1/FakeRate_qcd_loose_50_80.root");
    files.push_back("new1/FakeRate_qcd_loose_80_120.root");

    weights.push_back(sigma_20_30);
    weights.push_back(sigma_30_50);
    weights.push_back(sigma_50_80);
    weights.push_back(sigma_80_120);

    std::vector<std::string> files1;
    files1.push_back("new1/FakeRate_qcd_medium_20_30.root");
    files1.push_back("new1/FakeRate_qcd_medium_30_50.root");
    files1.push_back("new1/FakeRate_qcd_medium_50_80.root");
    files1.push_back("new1/FakeRate_qcd_medium_80_120.root");

    std::vector<std::string> files2;
    files2.push_back("new1/FakeRate_qcd_tight_20_30.root");
    files2.push_back("new1/FakeRate_qcd_tight_30_50.root");
    files2.push_back("new1/FakeRate_qcd_tight_50_80.root");
    files2.push_back("new1/FakeRate_qcd_tight_80_120.root");

    std::vector<TFile*> tfiles;
    std::vector<TFile*> tfiles1;
    std::vector<TFile*> tfiles2;

    for (int i=0; i<files.size(); i++) {
        tfiles.push_back(new TFile(files[i].c_str()));
    }

    for (int i=0; i<files1.size(); i++) {
        tfiles1.push_back(new TFile(files1[i].c_str()));
    }

    for (int i=0; i<files2.size(); i++) {
        tfiles2.push_back(new TFile(files2[i].c_str()));
    }


    TCanvas* cFakeIdDiv = new TCanvas ("cFakeIdDiv","Electron Id Fake Rate vs Jet Et");
    cFakeIdDiv->SetLogy();
    cFakeIdDiv->SetGridy();
    cFakeIdDiv->SetGridx();
    TH1D* hSelPT = (TH1D*)plot("HFakeNumSelEt","HFakeDenEt",tfiles,weights);
    TH1D* hSelPT1 = (TH1D*)plot("HFakeNumSelEt","HFakeDenEt",tfiles1,weights);
    TH1D* hSelPT2 = (TH1D*)plot("HFakeNumSelEt","HFakeDenEt",tfiles2,weights);
    TH1D* hRecoPT = (TH1D*)plot("HFakeNumEt","HFakeDenEt",tfiles,weights);
    hSelPT->SetTitle(0);
    hRecoPT->SetTitle(0);
    hSelPT->GetXaxis()->SetRangeUser(10,65);
    hSelPT->GetYaxis()->SetRangeUser(1e-3,1);
    //hSelPT->SetMaximum(1.0);
    hSelPT->GetXaxis()->SetTitle("E_{T} of Reco Jet (GeV)");
    hSelPT->GetYaxis()->SetTitle("Electron fake rate from jets (d#epsilon/dE_{T})");
    hSelPT->Draw("E");
    hSelPT->SetLineColor(4);
    hSelPT1->SetLineColor(8);
    hSelPT2->SetLineColor(2);
    hRecoPT->Draw("sameE");
    hSelPT1->Draw("sameE");
    hSelPT2->Draw("sameE");

    TLegend* legA = new TLegend(0.6,0.2,0.85,0.4);
    legA->AddEntry(hRecoPT,"Reconstruction","l");
    legA->AddEntry(hSelPT,"Id loose","l");
    legA->AddEntry(hSelPT1,"Id medium","l");
    legA->AddEntry(hSelPT2,"Id tight","l");
    legA->SetFillColor(0);
    legA->SetTextSize(0.04);
    legA->Draw();
    gPad->Update();


    TCanvas* cFakeIdDiv1 = new TCanvas ("cFakeIdDiv1","Electron Id Fake Rate vs Jet Et (Rel)");
    cFakeIdDiv1->SetLogy();
    cFakeIdDiv1->SetGridy();
    cFakeIdDiv1->SetGridx();
    TH1D* hSelPTA = (TH1D*)plot("HFakeNumSelEt","HFakeNumEt",tfiles,weights);
    TH1D* hSelPT1A = (TH1D*)plot("HFakeNumSelEt","HFakeNumEt",tfiles1,weights);
    TH1D* hSelPT2A = (TH1D*)plot("HFakeNumSelEt","HFakeNumEt",tfiles2,weights);
    hSelPTA->SetTitle(0);
    hSelPTA->GetXaxis()->SetRangeUser(10,65);
    hSelPTA->GetYaxis()->SetRangeUser(1e-2,1);
    //hSelPT->SetMaximum(1.0);
    hSelPTA->GetXaxis()->SetTitle("E_{T} of Reco Jet (GeV)");
    hSelPTA->GetYaxis()->SetTitle("Electron fake rate from jets (d#epsilon/dE_{T})");
    hSelPTA->Draw("E");
    hSelPTA->SetLineColor(4);
    hSelPT1A->SetLineColor(8);
    hSelPT2A->SetLineColor(2);
    hSelPT1A->Draw("sameE");
    hSelPT2A->Draw("sameE");

    TLegend* legAA = new TLegend(0.6,0.2,0.85,0.4);
    legAA->AddEntry(hSelPTA,"Id loose","l");
    legAA->AddEntry(hSelPT1A,"Id medium","l");
    legAA->AddEntry(hSelPT2A,"Id tight","l");
    legAA->SetFillColor(0);
    legAA->SetTextSize(0.04);
    legAA->Draw();
    gPad->Update();



    TCanvas* cFakeIdNum = new TCanvas ("cFakeIdNum","Et spectrum of jets that match reco electrons");
    cFakeIdNum->SetLogy();
    cFakeIdNum->SetGridy();
    cFakeIdNum->SetGridx();
    TH1D* hSelJetPT = (TH1D*)Plot1D("HFakeNumSelEt",tfiles,weights);
    TH1D* hSelJetPT1 = (TH1D*)Plot1D("HFakeNumSelEt",tfiles1,weights);
    TH1D* hSelJetPT2 = (TH1D*)Plot1D("HFakeNumSelEt",tfiles2,weights);
    TH1D* hRecoJetPT = (TH1D*)Plot1D("HFakeNumEt",tfiles,weights);
    hSelJetPT->SetTitle(0);
    hRecoJetPT->SetTitle(0);
    hSelJetPT->GetXaxis()->SetRangeUser(10,65);
    //hSelJetPT->GetYaxis()->SetRangeUser(1e-6,1);
    hSelJetPT->SetMaximum(1e5);
    hSelJetPT->SetMinimum(1.0001);
    hSelJetPT->GetXaxis()->SetTitle("E_{T} of Reco Jet that fakes an electron(GeV)");
    hSelJetPT->GetYaxis()->SetTitle("Arbitrary Scale");
    hSelJetPT->Draw("E");
    hSelJetPT->SetLineColor(4);
    hSelJetPT1->SetLineColor(8);
    hSelJetPT2->SetLineColor(2);
    hRecoJetPT->Draw("sameE");
    hSelJetPT1->Draw("sameE");
    hSelJetPT2->Draw("sameE");

    TLegend* legA1 = new TLegend(0.6,0.2,0.85,0.4);
    legA1->AddEntry(hRecoJetPT,"Reconstruction","l");
    legA1->AddEntry(hSelJetPT,"Id loose","l");
    legA1->AddEntry(hSelJetPT1,"Id medium","l");
    legA1->AddEntry(hSelJetPT2,"Id tight","l");
    legA1->SetFillColor(0);
    legA1->SetTextSize(0.04);
    legA1->Draw();
    gPad->Update();

    TCanvas* cFakeIdDen = new TCanvas ("cFakeIdDen","Et spectrum of jets");
    cFakeIdDen->SetLogy();
    cFakeIdDen->SetGridy();
    cFakeIdDen->SetGridx();
    TH1D* hJetPT = (TH1D*)Plot1D("HFakeDenEt",tfiles,weights);
    //hJetPT->Scale(1.0/hJetPT->Integral());
    hJetPT->SetTitle(0);
    hJetPT->GetXaxis()->SetRangeUser(10,65);
    //hJetPT->GetYaxis()->SetRangeUser(1e-6,1);
    hJetPT->SetMaximum(1e5);
    hJetPT->SetMinimum(1.0001);
    hJetPT->SetLineColor(1);
    hJetPT->GetXaxis()->SetTitle("E_{T} of Reco Jet (GeV)");
    hJetPT->GetYaxis()->SetTitle("Arbitrary Scale");
    hJetPT->Draw("E");



    TCanvas* cFakeIdDivEta = new TCanvas ("cFakeIdDivEta","Electron Id Fake Rate vs Jet Eta");
    cFakeIdDivEta->SetLogy();
    cFakeIdDivEta->SetGridy();
    cFakeIdDivEta->SetGridx();
    TH1D* hSelEta = (TH1D*)plot("HFakeNumSelEta","HFakeDenEta",tfiles,weights);
    TH1D* hSelEta1 = (TH1D*)plot("HFakeNumSelEta","HFakeDenEta",tfiles1,weights);
    TH1D* hSelEta2 = (TH1D*)plot("HFakeNumSelEta","HFakeDenEta",tfiles2,weights);
    TH1D* hRecoEta = (TH1D*)plot("HFakeNumEta","HFakeDenEta",tfiles,weights);
    hSelEta->SetTitle(0);
    hRecoEta->SetTitle(0);
    hSelEta->GetXaxis()->SetRangeUser(10,65);
    hSelEta->GetYaxis()->SetRangeUser(1e-4,1);
    //hSelEta->SetMaximum(1.0);
    hSelEta->GetXaxis()->SetTitle("#eta of Reco Jet (GeV)");
    hSelEta->GetYaxis()->SetTitle("Electron fake rate from jets (d#epsilon/d#eta)");
    hSelEta->Draw("E");
    hSelEta->SetLineColor(4);
    hSelEta1->SetLineColor(8);
    hSelEta2->SetLineColor(2);
    hRecoEta->Draw("sameE");
    hSelEta1->Draw("sameE");
    hSelEta2->Draw("sameE");

    TLegend* legB = new TLegend(0.6,0.2,0.85,0.4);
    legB->AddEntry(hRecoEta,"Reconstruction","l");
    legB->AddEntry(hSelEta,"Id loose","l");
    legB->AddEntry(hSelEta1,"Id medium","l");
    legB->AddEntry(hSelEta2,"Id tight","l");
    legB->SetFillColor(0);
    legB->SetTextSize(0.04);
    legB->Draw();
    gPad->Update();

    TCanvas* cFakeIdDivEta1 = new TCanvas ("cFakeIdDivEta1","Electron Id Fake Rate vs Jet Eta (Rel)");
    cFakeIdDivEta1->SetLogy();
    cFakeIdDivEta1->SetGridy();
    cFakeIdDivEta1->SetGridx();
    TH1D* hSelEtaB = (TH1D*)plot("HFakeNumSelEta","HFakeNumEta",tfiles,weights);
    TH1D* hSelEta1B = (TH1D*)plot("HFakeNumSelEta","HFakeNumEta",tfiles1,weights);
    TH1D* hSelEta2B = (TH1D*)plot("HFakeNumSelEta","HFakeNumEta",tfiles2,weights);
    hSelEtaB->SetTitle(0);
    hSelEtaB->GetXaxis()->SetRangeUser(10,65);
    hSelEtaB->GetYaxis()->SetRangeUser(1e-4,1);
    //hSelEta->SetMaximum(1.0);
    hSelEtaB->GetXaxis()->SetTitle("#eta of Reco Jet (GeV)");
    hSelEtaB->GetYaxis()->SetTitle("Electron fake rate from jets (d#epsilon/d#eta)");
    hSelEtaB->Draw("E");
    hSelEtaB->SetLineColor(4);
    hSelEta1B->SetLineColor(8);
    hSelEta2B->SetLineColor(2);
    hSelEta1B->Draw("sameE");
    hSelEta2B->Draw("sameE");

    TLegend* legBB = new TLegend(0.6,0.2,0.85,0.4);
    legBB->AddEntry(hSelEtaB,"Id loose","l");
    legBB->AddEntry(hSelEta1B,"Id medium","l");
    legBB->AddEntry(hSelEta2B,"Id tight","l");
    legBB->SetFillColor(0);
    legBB->SetTextSize(0.04);
    legBB->Draw();
    gPad->Update();

    TCanvas* cFakeIdNumEta = new TCanvas ("cFakeIdNumEta","#eta spectrum of jets that match reco electrons");
    cFakeIdNumEta->SetLogy();
    cFakeIdNumEta->SetGridy();
    cFakeIdNumEta->SetGridx();
    TH1D* hSelJetEta = (TH1D*)Plot1D("HFakeNumSelEta",tfiles,weights);
    TH1D* hSelJetEta1 = (TH1D*)Plot1D("HFakeNumSelEta",tfiles1,weights);
    TH1D* hSelJetEta2 = (TH1D*)Plot1D("HFakeNumSelEta",tfiles2,weights);
    TH1D* hRecoJetEta = (TH1D*)Plot1D("HFakeNumEta",tfiles,weights);
    hSelJetEta->SetTitle(0);
    hRecoJetEta->SetTitle(0);
    hSelJetEta->GetXaxis()->SetRangeUser(10,65);
    //hSelJetEta->GetYaxis()->SetRangeUser(1e-6,1);
    hSelJetEta->SetMaximum(1e4);
    hSelJetEta->SetMinimum(1.0001);
    hSelJetEta->GetXaxis()->SetTitle("#eta of Reco Jet that fakes an electron(GeV)");
    hSelJetEta->GetYaxis()->SetTitle("Arbitrary Scale");
    hSelJetEta->Draw("E");
    hSelJetEta->SetLineColor(4);
    hSelJetEta1->SetLineColor(8);
    hSelJetEta2->SetLineColor(2);
    hRecoJetEta->Draw("sameE");
    hSelJetEta1->Draw("sameE");
    hSelJetEta2->Draw("sameE");

    TLegend* legB1 = new TLegend(0.6,0.2,0.85,0.4);
    legB1->AddEntry(hRecoJetPT,"Reconstruction","l");
    legB1->AddEntry(hSelJetPT,"Id loose","l");
    legB1->AddEntry(hSelJetPT1,"Id medium","l");
    legB1->AddEntry(hSelJetPT2,"Id tight","l");
    legB1->SetFillColor(0);
    legB1->SetTextSize(0.04);
    legB1->Draw();
    gPad->Update();

    TCanvas* cFakeIdDenEta = new TCanvas ("cFakeIdDenEta","#eta spectrum of jets");
    cFakeIdDenEta->SetLogy();
    cFakeIdDenEta->SetGridy();
    cFakeIdDenEta->SetGridx();
    TH1D* hJetEta = (TH1D*)Plot1D("HFakeDenEta",tfiles,weights);
    hJetEta->SetTitle(0);
    hJetEta->GetXaxis()->SetRangeUser(10,65);
    //hJetEta->GetYaxis()->SetRangeUser(1e-6,1);
    hJetEta->SetMaximum(1e4);
    hJetEta->SetMinimum(1.0001);
    hJetEta->SetLineColor(1);
    hJetEta->GetXaxis()->SetTitle("#eta of Reco Jet (GeV)");
    hJetEta->GetYaxis()->SetTitle("Arbitrary Scale");
    hJetEta->Draw("E");

    TCanvas* cEtJetvsEtElec = new TCanvas ("cEtJetvsEtElec","E_{T} of Electron vs E_{T} of Jet");
    cEtJetvsEtElec->SetLogz();
    TH2D* hJetvsElec = (TH2D*)Plot2D("HEtJetvsEtElectron",tfiles,weights);
    hJetvsElec->SetTitle(0);
    hJetvsElec->GetXaxis()->SetTitle("E_{T} of Reco Jet (GeV)");
    hJetvsElec->GetYaxis()->SetTitle("E_{T} of Reco Electron (GeV)");
    hJetvsElec->Draw("COLZ");

    TCanvas* cDRJetElec = new TCanvas ("cDRJetElec","minimum #DeltaR between electron and jets ");
    cDRJetElec->SetLogy();
    cDRJetElec->SetGridy();
    cDRJetElec->SetGridx();
    TH1D* hDRJetElec = (TH1D*)Plot1D("HdRminElecjet",tfiles,weights);
    hDRJetElec->SetTitle(0);
    hDRJetElec->SetLineColor(1);
    hDRJetElec->GetXaxis()->SetTitle("Minimum #DeltaR between electrons and jets");
    hDRJetElec->GetYaxis()->SetTitle("Arbitrary Scale");
    hDRJetElec->Draw();



}
void run_DataGammaJetsZllToZnunu(){

	// defs ---------------------------------------------------------
	gSystem->CompileMacro("../MT2Code/src/MT2Shapes.cc", "k");
	
	// logStream
	fLogStream = new std::ostringstream();
	
	// create dir
	if(!fOutDir.EndsWith("/")) fOutDir += "/";
	char cmd[500];
	sprintf(cmd,"mkdir -p %s", fOutDir.Data());
	system(cmd);

	DefineCutStreams(fHTmin, fHTmax, fMT2min, fMT2max);
	TString filename=fOutDir+"/"+fRootFile;
	fOutFile = new TFile(filename.Data(), "RECREATE");
	fDir     = (TDirectory*) fOutFile;

	// fix output dir
//	if(fHTmax <10000) fOutDir= TString::Format("%s_%d_HT_%d",  fOutDir.Data(), abs(fHTmin),  abs(fHTmax));
//	else              fOutDir= TString::Format("%s_%d_HT_%s",  fOutDir.Data(), abs(fHTmin),  "Inf");
//	if(fMT2max<10000) fOutDir= TString::Format("%s_%d_MT2_%d", fOutDir.Data(), abs(fMT2min), abs(fMT2max));
//	else              fOutDir= TString::Format("%s_%d_MT2_%s", fOutDir.Data(), abs(fMT2min), "Inf");
	
	// log MT2 and HT cuts
	*fLogStream << "------------------------------------------------------------------------------------------------" << endl;
	*fLogStream << "+++ new Znunu with Gamma+jets prediction                                                     +++" << endl;
	*fLogStream << "+++ outputdir: " << fOutDir <<                                                              "+++" << endl; 
	*fLogStream << "------------------------------------------------------------------------------------------------" << endl;
	
	// new prediction ------------------------------------------------------
	Prediction* prediction = new Prediction();
	prediction->fVerbose=fVerbose;
	prediction->fSave   =fSaveResults;


	// Photon Pt
	if(fDoPhotonPtShape){
  	const int gNMT2bins                   = 11;
  	double  gMT2bins[gNMT2bins+1]   = {150, 160, 170, 180, 190, 200, 225, 250, 300, 400, 550, 800}; 	
	prediction->ChPhotonPt = new Channel("PhotonPt", "photon[0].lv.Pt()", cutStream_PhotonPt.str().c_str(), fTriggerStream.str().c_str(),fSamplesPhotonPt);
	prediction->ChPhotonPt->fVerbose =prediction->fVerbose;
//	prediction->ChPhotonPt->GetShapes("PhotonPt", "#gamma Pt", 2, 300, 800);
	prediction->ChPhotonPt->GetShapes("PhotonPt", "#gamma Pt", 100, 150, 800);
//	prediction->ChPhotonPt->GetShapes("PhotonPt", "#gamma Pt", gNMT2bins, gMT2bins);
	}
	
	// Zll Pt
	if(fDoZllPtShape){
  	const int gNMT2bins                   = 11;
  	double  gMT2bins[gNMT2bins+1]   = {150, 160, 170, 180, 190, 200, 225, 250, 300, 400, 550, 800}; 	
	prediction->ChZllPt = new Channel("ZllPt", "RecoOSDiLeptPt(20,2.4,71,111)", cutStreamZll.str().c_str(), fTriggerStream.str().c_str(),fSamplesZllPt);
	prediction->ChZllPt->fVerbose =prediction->fVerbose;
//	prediction->ChZllPt->GetShapes("ZllPt", "Zll Pt", 2, 300, 800);
	prediction->ChZllPt->GetShapes("ZllPt", "Zll Pt", 100, 150, 800);
//	prediction->ChZllPt->GetShapes("ZllPt", "Zll Pt", gNMT2bins, gMT2bins);
	}

	// compute Zll/gamma pt ratio
	if(fDoPhotonPtShape && fDoZllPtShape){
		TH1D* hPhotonToZllPtRatio = prediction->GetRatio(fDoDataZllToPhotonRatio? prediction->ChZllPt->hData    : prediction->ChZllPt->hZJetsToLL, 
				                                 fDoDataZllToPhotonRatio? prediction->ChPhotonPt->hData : prediction->ChPhotonPt->hPhotons, 4);
		DrawHisto(hPhotonToZllPtRatio,hPhotonToZllPtRatio->GetName(),"EX0");
		TString rationame=hPhotonToZllPtRatio->GetName();
		rationame +="_fittedRatio";
		TF1 *f_lin = new TF1(rationame,"pol0(0)", fZllToGammaFitMin , fZllToGammaFitMax);   f_lin->SetLineColor(8);
		if(fDoFits){ 
			hPhotonToZllPtRatio->Fit(rationame,"0L","", fZllToGammaFitMin, fZllToGammaFitMax);    // set al weights to 1
			fZllToPhotonRatio   = f_lin->GetParameter(0);
		} else{
			fZllToPhotonRatio   = prediction->GetLimitedRatio(fDoDataZllToPhotonRatio? prediction->ChZllPt->hData: prediction->ChZllPt->hZJetsToLL,
			                                              fDoDataZllToPhotonRatio? prediction->ChPhotonPt->hData : prediction->ChPhotonPt->hPhotons,
				                                      fZllToGammaFitMin, fZllToGammaFitMax, false, fZllToPhotonRatioRelErr);
			f_lin->SetParameter(0,fZllToPhotonRatio);
		}
  		const int nBins= 3;
		const double Bins[nBins+1] = {150, fZllToGammaFitMin>150?fZllToGammaFitMin:150.0001, fZllToGammaFitMax<800? fZllToGammaFitMax:799.99, 800};
		TH1D* hErrorbar = new TH1D(rationame.Data(), "", nBins, Bins);
		hErrorbar->SetBinContent(2,fZllToPhotonRatio);
		hErrorbar->SetBinError(2,fZllToPhotonRatioRelErr*fZllToPhotonRatio);
		hErrorbar->SetBinContent(1,-10);
		hErrorbar->SetBinError( 1,0);
		hErrorbar->SetFillColor(5);
		hErrorbar->SetFillStyle(3001);
		hErrorbar->Draw("e2same");
		f_lin->Draw("same");
		hPhotonToZllPtRatio->Draw("EX0same");
	}
	
	// GenLevel Zll Pt, no acceptance cuts
	if(fDoGenZllShape){
	prediction->ChGenZllPt = new Channel("GenZllPt", "GenDiLeptPt(0,10,0,1000,true)", cutStreamGenZll.str().c_str(), fTriggerStream.str().c_str(),fSamplesZllPtMConly);
	prediction->ChGenZllPt->fVerbose =prediction->fVerbose;
	prediction->ChGenZllPt->GetShapes("GenZllPt", "GenZll Pt", 8, 0, 800);
	}
	
	// GenLevel Zll Pt, within acceptance
	if(fDoGenAccZllShape){
	prediction->ChGenZllPtAcc = new Channel("GenZllPtAcc", "GenDiLeptPt(20,2.4,71,111,true)", cutStreamGenZllAcc.str().c_str(), fTriggerStream.str().c_str(),fSamplesZllPtMConly);
	prediction->ChGenZllPtAcc->fVerbose =prediction->fVerbose;
	prediction->ChGenZllPtAcc->GetShapes("GenZllPtAcc", "GenZll Pt", 8, 0, 800);
	}
	// Get Acceptance Efficiency
	if(fDoGenZllShape && fDoGenAccZllShape){
		Bool_t binomial =true;
		TH1D* hZllAccEff = prediction->GetRatio(prediction->ChGenZllPtAcc->hZJetsToLL, prediction->ChGenZllPt->hZJetsToLL, 1, binomial);
		DrawHisto(hZllAccEff,hZllAccEff->GetName(),"EX");
//		TString rationame=hZllAccEff->GetName();
//		rationame +="_fittedRatio";
//		TF1 *f_lin = new TF1(rationame,"pol0(0)", fZllAccFitMin ,   fZllAccFitMax);   f_lin->SetLineColor(8);
//		if(fDoFits){ 
//			hZllAccEff->Fit(rationame,"0L","", fZllAccFitMin, fZllAccFitMax);    // set al weights to 1
//			fZllAccEff= f_lin->GetParameter(0);
//		} else{
//			fZllAccEff= prediction->GetLimitedRatio(prediction->ChGenZllPtAcc->hZJetsToLL,prediction->ChGenZllPt->hZJetsToLL,
//				                                fZllAccFitMin, fZllAccFitMax, true, fZllAccEffRelErr);
//			f_lin->SetParameter(0,fZllAccEff);
//		}
//  		const int nBins= 3;
//		const double Bins[nBins+1] = {150, fZllAccFitMin>150?fZllAccFitMin:150.0001, fZllAccFitMax<800? fZllAccFitMax:799.99, 800};
//		TH1D* hErrorbar = new TH1D(rationame.Data(), "", nBins,Bins);
//		hErrorbar->SetBinContent(2,fZllAccEff);
//		hErrorbar->SetBinError(2,fZllAccEffRelErr*fZllAccEff);
//		hErrorbar->SetBinContent(1,-1);
//		hErrorbar->SetBinError(1,0);
//		hErrorbar->SetFillColor(5);
//		hErrorbar->SetFillStyle(3001);
//		hErrorbar->Draw("e2same");
//		f_lin->Draw("same");
//		hZllAccEff->Draw("EX0same");
	}
	
	// GenLevel Zll Pt, within acceptance, OS dilepton recoed
	if(fDoGenAccZllRecoShape){
	prediction->ChGenZllPtAccRecoed = new Channel("GenZllPtAccRecoed", "GenDiLeptPt(20,2.4,71,111,true)", cutStreamGenZllAcc_recoed.str().c_str(), fTriggerStream.str().c_str(),fSamplesZllPtMConly);
	prediction->ChGenZllPtAccRecoed->fVerbose =prediction->fVerbose;
	prediction->ChGenZllPtAccRecoed->GetShapes("GenZllPtAccRecoed", "GenZll Pt", 100, 150, 800);
	}
	if(fDoGenAccZllShape && fDoGenAccZllRecoShape){
		Bool_t binomial =true;
		TH1D* hZllRecoEff = prediction->GetRatio(prediction->ChGenZllPtAccRecoed->hZJetsToLL, prediction->ChGenZllPtAcc->hZJetsToLL, 4, binomial);
		DrawHisto(hZllRecoEff,hZllRecoEff->GetName(),"EX");
		TString rationame=hZllRecoEff->GetName();
		rationame +="_fittedRatio";
		TF1 *f_lin = new TF1(rationame,"pol0(0)", fZllRecoEffFitMin , fZllRecoEffFitMax);   f_lin->SetLineColor(8);
		if(fDoFits){ 
			hZllRecoEff->Fit(rationame,"0L","", fZllRecoEffFitMin, fZllRecoEffFitMax);    // set al weights to 1
			fZllRecoEff= f_lin->GetParameter(0);
		} else{
			fZllRecoEff= prediction->GetLimitedRatio(prediction->ChGenZllPtAccRecoed->hZJetsToLL,prediction->ChGenZllPtAcc->hZJetsToLL,
				                                fZllRecoEffFitMin, fZllRecoEffFitMax, true, fZllRecoEffRelErr);
			f_lin->SetParameter(0,fZllRecoEff);
		}
  		const int nBins= 3;
		const double Bins[nBins+1] = {150, fZllRecoEffFitMin>150?fZllRecoEffFitMin:150.001, fZllRecoEffFitMax<800? fZllRecoEffFitMax:799.99, 800};
		TH1D* hErrorbar = new TH1D(rationame.Data(), "", nBins,Bins);
		hErrorbar->SetBinContent(2,fZllRecoEff);
		hErrorbar->SetBinError(2,fZllRecoEffRelErr*fZllRecoEff);
		hErrorbar->SetBinContent(1,-1);
		hErrorbar->SetBinError(1,0);
		hErrorbar->SetFillColor(5);
		hErrorbar->SetFillStyle(3001);
		hErrorbar->Draw("e2same");
		f_lin->Draw("same");
		hZllRecoEff->Draw("EX0same");
	}
	
	// Photons Hadronic Search MT2
	if(fDoPhotonMT2Shape){
	prediction->ChPhotonsMT2 = new Channel("PhotonsMT2", "photon[0].lv.Pt()", cutStreamPhotonMT2.str().c_str(), fTriggerStream.str().c_str(),fSamplesPhotonPt);
	prediction->ChPhotonsMT2->fVerbose =prediction->fVerbose;
	prediction->ChPhotonsMT2->GetShapes("PhotonsMT2", "MET", 40, 0, 800);
	}

	// Znunu Hadronic Search MT2
	if(fDoZnunuMT2Shape){
	prediction->ChZnunuMT2 = new Channel("ZnunuMT2", "misc.MET", cutStreamZnunuMT2.str().c_str(), fTriggerStream.str().c_str(),fSamplesZnunu);
	prediction->ChZnunuMT2->fVerbose =prediction->fVerbose;
	prediction->ChZnunuMT2->GetShapes("ZnunuMT2", "MET", 40, 0, 800);
	}

	if(fDoZnunuMT2Shape && fDoPhotonMT2Shape){
	TH1D* ZnunuToPhotonMT2Ratio = prediction->GetRatio(prediction->ChZnunuMT2->hZJetsToNuNu, prediction->ChPhotonsMT2->hPhotons, 1);
	DrawHisto(ZnunuToPhotonMT2Ratio,ZnunuToPhotonMT2Ratio->GetName(),"EX0");
	}


	
	// Do Pt spectra comparison plot
	if(fDoPtSpectraComparison && fDoPhotonPtShape && fDoZllPtShape){
		*fLogStream<< "************************* produce pr spectra plot ****************************** " << endl;
		TH1D* hZllMC_cp      = prediction->GetScaledHisto(prediction->ChZllPt->hZJetsToLL, fDoPtSpectraComparisonScaling?(prediction->ChZllPt->hData->Integral())/(prediction->ChZllPt->hZJetsToLL->Integral())    :1, 0, 1);
		TH1D* hZllData_cp    = prediction->GetScaledHisto(prediction->ChZllPt->hData,    1, 0, 1) ;
		TH1D* hPhotonMC_cp   = prediction->GetScaledHisto(prediction->ChPhotonPt->hPhotons,fDoPtSpectraComparisonScaling?(prediction->ChPhotonPt->hData->Integral())/(prediction->ChPhotonPt->hPhotons->Integral()):1, 0, 1);
		TH1D* hPhotonData_cp = prediction->GetScaledHisto(prediction->ChPhotonPt->hData,    1, 0, 1);

		if(fDoPtSpectraComparisonAccCorr){
			TFile *f = new TFile("../RootMacros/ZllAcceptance.root", "OPEN");
			TH1D*  hZllAcc = (TH1D*) f->Get("ZJetsToLL_GenZllPtAcc_ZJetsToLL_GenZllPt_Ratio");
			if (hZllAcc==0) {cout << "WARNING: could not get histo ZJetsToLL_GenZllPtAcc_ZJetsToLL_GenZllPt_Ratio" << endl; exit(1);}
			for(int i=1; i<=hZllMC_cp->GetNbinsX(); ++i){
				if(hZllAcc->GetBinLowEdge(i) != hZllMC_cp->GetBinLowEdge(i)) {cout << "Zll Acc Correction: binnin does not match!!" << endl; exit(1);}
				if(hZllMC_cp  ->GetBinContent(i)<=0) continue;
				double acc_eff   = hZllAcc->GetBinContent(i);
				double orig_mc   = hZllMC_cp     ->GetBinContent(i);
				double orig_data = hZllData_cp   ->GetBinContent(i);
				cout << "bin i " << i << " acc eff " << acc_eff << " orig_mc " << orig_mc << " become " << orig_mc/acc_eff 
				     << " orig_data " << orig_data << " becomes " << orig_data/acc_eff << endl;
				hZllMC_cp   ->SetBinContent(i, orig_mc  /acc_eff);
				hZllData_cp ->SetBinContent(i, orig_data/acc_eff);
			}
			delete f;
		}
		
		hZllMC_cp->SetMarkerStyle(22);
		hZllMC_cp->SetLineColor(kOrange);
		hZllMC_cp->SetMarkerColor(kOrange);
		hZllMC_cp->SetMarkerSize(1.2);
		hZllData_cp->SetMarkerStyle(26);
		hZllData_cp->SetMarkerColor(kBlack);
		hZllData_cp->SetLineColor(kBlack);
		hPhotonMC_cp->SetLineColor(kMagenta+2);
		hPhotonMC_cp->SetMarkerColor(kMagenta+2);
		hPhotonMC_cp->SetMarkerStyle(20);
		hPhotonMC_cp->SetMarkerSize(1.2);
		hPhotonData_cp->SetMarkerStyle(4);
		hPhotonData_cp->SetMarkerColor(kBlack);
		hPhotonData_cp->SetLineColor(kBlack);

		TCanvas *col = new TCanvas("ZllToGammaPtSpectra", "", 0, 0, 500, 500);
		col->SetFillStyle(0);
		col->SetFrameFillStyle(0);
//		col->cd();
		gPad->SetFillStyle(0);
		gStyle->SetPalette(1);
		gPad->SetRightMargin(0.15);

		TLegend* leg2 = new TLegend(0.2, 0.6, 0.5, 0.9);	
		leg2->AddEntry(hPhotonMC_cp,"Gamma+Jets MC","p" );
		leg2->AddEntry(hPhotonData_cp,"Photon Data","p" );
		leg2->AddEntry(hZllMC_cp ,"Zll MC","p" );
		leg2->AddEntry(hZllData_cp,"Zll Data","p" );
		leg2 -> SetFillColor(0);
		leg2 -> SetBorderSize(0);
	//	
		hPhotonMC_cp->SetXTitle("V boson p_{T} (GeV)");
		hPhotonMC_cp->SetYTitle("Events / 7 GeV");
		hPhotonMC_cp->Draw("EX");
		hPhotonData_cp->Draw("EXsame");
		hZllMC_cp->Draw("EXsame");
		hZllData_cp->Draw("EXsame");
		leg2->Draw();
	
		TCanvas *c3 = new TCanvas("ZllToGammaPtSpectraRatio", "", 500, 500);
		TH1D* h_ratio         = (TH1D*) hZllMC_cp      ->Clone("h_ratio");	
		TH1D* h_ratioData     = (TH1D*) hZllData_cp    ->Clone("h_ratioData");	
		TH1D* hPhotonMC_cp2   = (TH1D*) hPhotonMC_cp   ->Clone("hPhotonMC_cp2");
		TH1D* hPhotonData_cp2 = (TH1D*) hPhotonData_cp ->Clone("hPhotonData_cp2");
		h_ratio->Rebin(1); h_ratioData->Rebin(1);
		h_ratio->SetYTitle("#frac{Z(ll)}{#gamma}");
		h_ratio->SetXTitle("boson p_{T} (GeV)");
		h_ratio    ->Divide(hPhotonMC_cp2->Rebin(1));
		h_ratioData->Divide(hPhotonData_cp2->Rebin(1));
		h_ratio    ->SetMarkerStyle(20);
		h_ratio    ->SetMarkerSize(1.2);
		h_ratio    ->SetLineColor(kMagenta+2);
		h_ratio    ->SetMarkerColor(kMagenta+2);
		h_ratioData->SetMarkerStyle(26);
		h_ratioData->SetMarkerColor(kBlack);
		h_ratio    ->Draw("EX0");
		h_ratioData->Draw("EX0same");
		
		TLegend* leg3 = new TLegend(0.2, 0.6, 0.5, 0.9);	
		leg3->AddEntry(h_ratioData,"Zll/photon Data","p" );
		leg3->AddEntry(h_ratio    ,"Zll/photon MC","p" );
		leg3 -> SetFillColor(0);
		leg3 -> SetBorderSize(0);
		leg3 ->Draw();
	}

	if(fDoMT2SpectraCompaison && fDoZnunuMT2Shape && fDoPhotonMT2Shape){
		*fLogStream<<  "************************* MT2 spectra comparison ***************  " << endl;
		TH1D* hZNunuMT2      = prediction->GetScaledHisto(prediction->ChZnunuMT2   ->hZJetsToNuNu, fDoMT2SpectraCompaisonScaling?(prediction->ChPhotonsMT2 ->hData->Integral())/(prediction->ChPhotonsMT2 ->hPhotons->Integral()):1, 0, 1);
		TH1D* hPhotonMT2     = prediction->GetScaledHisto(prediction->ChPhotonsMT2 ->hPhotons,     fDoMT2SpectraCompaisonScaling?(prediction->ChPhotonsMT2 ->hData->Integral())/(prediction->ChPhotonsMT2 ->hPhotons->Integral()):1, 0, 1);
		TH1D* hPhotonDataMT2 = prediction->GetScaledHisto(prediction->ChPhotonsMT2 ->hData, 1, 0, 1);
		
		hZNunuMT2->SetFillStyle(0);
		hZNunuMT2->SetLineWidth(3);

		TCanvas *col = new TCanvas("ZnunuToGammaPtSpectra", "", 0, 0, 500, 500);
		col->SetFillStyle(0);
		col->SetFrameFillStyle(0);
//		col->cd();
		gPad->SetFillStyle(0);
		gStyle->SetPalette(1);
		gPad->SetRightMargin(0.15);
		gPad->SetLogy(1);

		TLegend* leg2 = new TLegend(0.2, 0.6, 0.5, 0.9);	
		leg2->AddEntry(hPhotonMT2,"#gamma+jets MC","f" );
		leg2->AddEntry(hZNunuMT2,"Z(#nu#nu)+jets MC","l" );
		leg2->AddEntry(hPhotonDataMT2,"data","p" );
		leg2 -> SetFillColor(0);
		leg2 -> SetBorderSize(0);
	//	
		hPhotonMT2->SetXTitle("min #Delta #phi(jets,MET)");
		hPhotonMT2->SetYTitle("Events");
		hPhotonMT2->Draw("hist");
		hZNunuMT2->Draw("histsame");
		hPhotonDataMT2->Draw("EXsame");
		leg2->Draw();
//		gPad->RedrawAxis();
		// cout integral above 250 in MT2 and ratio
//		double sumPhotons=0;
//		double sumZnunu  =0;
//		for(int i=1;  i<=hPhotonMT2->GetNbinsX(); ++i){
//			if(hPhotonMT2->GetBinLowEdge(i)>=250){
//				sumPhotons+=hPhotonMT2->GetBinContent(i);
//				sumZnunu  +=hZNunuMT2 ->GetBinContent(i);
//			}
//		}
//		*fLogStream<< ">>> hPhotonMT2: integral above 250: " << sumPhotons << endl;
//		*fLogStream<< ">>> hZNunuMT2 : integral above 250: " << sumZnunu   << endl;
//		*fLogStream<< ">>> -> Ratio  : "                     << sumZnunu/sumPhotons << endl;
		
	}

	if(fDoZnunuGammaGenPtSpectraComparison){
		*fLogStream<< "*************************ZnunuGammaGenPtSpectraComparison**********" << endl;
		// gen photons
		prediction->ChGenPhotonPt = new Channel("GenPhotonPt", "GenPhoton[0].Pt()", cutStreamGenPhoton.str().c_str(), fTriggerStream.str().c_str(),fSamplesPhotonPtMConly);
		prediction->ChGenPhotonPt->fVerbose =prediction->fVerbose;
		prediction->ChGenPhotonPt->GetShapes("GenPhotonPt", "Gen-level #gamma Pt", 50, 150, 800);
		
		// Gen Znunu
		prediction->ChGenZnunuPt = new Channel("GenZnunuPt", "GenZ[0].Pt()", cutStreamGenZnunu.str().c_str(), fTriggerStream.str().c_str(),fSamplesZnunu);
		prediction->ChGenZnunuPt->fVerbose =prediction->fVerbose;
		prediction->ChGenZnunuPt->GetShapes("GenZnunuPt", "Gen-level Z(#nu#nu) Pt", 50, 150, 800);
		
		prediction->DrawHistos(prediction->ChGenPhotonPt->hPhotons, prediction->ChGenZnunuPt->hZJetsToNuNu,
				       "EX0"                              , "EX0same",
				       kViolet+3                          , kBlack,
				       20                                 ,4,
				       "#gamma Pt"                        ,"Z(#nu#nu)");

		TH1D* hGenPhotonToZnunuRatio = prediction->GetRatio(prediction->ChGenZnunuPt->hZJetsToNuNu, prediction->ChGenPhotonPt->hPhotons, 1, false);
		hGenPhotonToZnunuRatio->SetMarkerColor(kBlack);
		hGenPhotonToZnunuRatio->SetLineColor(kBlack);
		hGenPhotonToZnunuRatio->SetMarkerStyle(4);
		DrawHisto(hGenPhotonToZnunuRatio, "GenPhotonToZnunuRatio","EX0", prediction->ChGenPhotonPt);
	}

	if(fDoPhotonRecoEff){
		prediction->ChGenPhotonPtForRecoEff = new Channel("GenPhotonPtForRecoEff", "GenPhoton[0].Pt()", cutStream_GenPhotonforRecoEff.str().c_str(), fTriggerStream.str().c_str(),fSamplesPhotonPtMConly);
		prediction->ChGenPhotonPtForRecoEff->fVerbose =prediction->fVerbose;
		prediction->ChGenPhotonPtForRecoEff->GetShapes("GenPhotonPtForRecoEff", "Gen-level #gamma Pt", 50, 150, 800);
		
		prediction->ChPhotonPtForRecoEff = new Channel("PhotonPtForRecoEff", "GenPhoton[0].Pt()", cutStream_PhotonPtforRecoEff.str().c_str(), fTriggerStream.str().c_str(),fSamplesPhotonPtMConly);
		prediction->ChPhotonPtForRecoEff->fVerbose =prediction->fVerbose;
		prediction->ChPhotonPtForRecoEff->GetShapes("PhotonPtForRecoEff", "Gen-level #gamma Pt", 50, 150, 800);
		
		prediction->DrawHistos(prediction->ChGenPhotonPtForRecoEff->hPhotons, prediction->ChPhotonPtForRecoEff->hPhotons,
				       "EX0"                              , "EX0same",
				       kViolet+3                          , kBlack,
				       20                                 ,4,
				       "#all"                             ,"recoed");
		TH1D* hPhotonRecoEff = prediction->GetRatio(prediction->ChPhotonPtForRecoEff->hPhotons, prediction->ChGenPhotonPtForRecoEff->hPhotons, 1, false);
		hPhotonRecoEff->SetMarkerColor(kBlack);
		hPhotonRecoEff->SetLineColor(kBlack);
		hPhotonRecoEff->SetMarkerStyle(4);
		DrawHisto(hPhotonRecoEff, "PhotonRecoEff","EX0", prediction->ChPhotonPtForRecoEff);
	}

	// Prediction
	if(fDoPrediction){
		*fLogStream<< "************************* Prediction ****************************** " << endl;

		TH1D* MCZnunu = prediction->GetScaledHisto(prediction->ChZnunuMT2->hZJetsToNuNu,fLumiCorr,0);  // scale to lumi 4400
		double MCZnunuEst    = MCZnunu->GetBinContent(1);
		double MCZnunuEstErr = MCZnunu->GetBinError(1);
		delete MCZnunu;
		if(fDoData){ 
		double nGamma    = prediction->ChPhotonsMT2->hData->Integral();
		double nGammaErr = sqrt(nGamma);
		*fLogStream << "********** Data Prediction ***************************************************** " << endl;
		MakePrediction(nGamma, nGammaErr, fZllToPhotonRatio, fZllToPhotonRatioRelErr, fZllAccEff, fZllAccEffRelErr, fZllRecoEff, fZllRecoEffRelErr, MCZnunuEst, MCZnunuEstErr);
		}
		TH1D* hDummy =   prediction->GetScaledHisto(prediction->ChPhotonsMT2->hPhotons, 1, 0);
		float nGammaMC   =hDummy->GetBinContent(1);
		float nGammaMCErr=hDummy->GetBinError(1);
		*fLogStream << "********** MC Prediction ***************************************************** " << endl;
		MakePrediction(nGammaMC, nGammaMCErr, fZllToPhotonRatio, fZllToPhotonRatioRelErr, fZllAccEff, fZllAccEffRelErr, fZllRecoEff, fZllRecoEffRelErr, MCZnunuEst, MCZnunuEstErr);
	}

	// write -----------
	if(fWriteToFile){
		TString logname =fOutDir + ".log"; 
		ofstream f_log (logname.Data(), ios::app);
		f_log << fLogStream->str();
	} else{
		cout << fLogStream->str();
	}

//	fOutFile->Close();

}
Example #25
0
// Compare energy spectra/coincidences under different experimental conditions 
void CompareRuns(){
	TCanvas* c1 = new TCanvas();
	TCanvas* c2 = new TCanvas();
	TCanvas* c3 = new TCanvas();
	double thresh = 35;
	double dmin = 400, dmax = 6000; //6000=24us;
	//add 100 us
	//dmin += 25000; dmax += 25000;
	double E0 = 5.37873, E1 = 0.157501; //calibration
	double emax = 6000;
	//HV + UCN on
	c1->cd();
	TH1D* hP = new TH1D("hP","hP",emax/4.,0,emax);
	TH2D* hch = new TH2D("hch","hch",16,0,16,16,0,16);
	TH1D* ht = (TH1D*) gROOT->FindObject("ht");
	if (ht != 0) delete ht;
	TH1D* ht = new TH1D("ht","ht",300,0,15000);
	TH2D* hPT = new TH2D("hPT","hPT",500,0,50,emax/4.,0,emax);
	ftf.SetPath("Files/Dec15/Fixed");
	ftf.Open(27); double endtime = 4*500.;
	ftf.GetEvent(0); double lasttime = ftf.Fit_event.t; int lastch = ftf.Fit_event.ch;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		double time = ftf.Fit_event.t;
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {	
			double diff = time - lasttime;
			if (diff < dmax) {
				ht->Fill(diff);
				hPT->Fill(diff*0.004,ftf.Fit_event.E*E1 + E0);
			}
			if (diff > dmin && diff < dmax) {//4 to 24 us
				hP->Fill(ftf.Fit_event.E*E1 + E0);
				hch->Fill(ftf.Fit_event.ch,lastch);
			}
			lasttime = time;
			lastch = ftf.Fit_event.ch;
		}
	}
	ftf.Open(30); double endtime = 4*510.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t; lastch = ftf.Fit_event.ch;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		double time = ftf.Fit_event.t;
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff < dmax){
				ht->Fill(diff);
				hPT->Fill(diff*0.004,ftf.Fit_event.E*E1 + E0);
			}
			if (diff > dmin && diff < dmax) {//4 to 24 us
				hP->Fill(ftf.Fit_event.E*E1 + E0);
				hch->Fill(ftf.Fit_event.ch,lastch);
			}
			lasttime = time;
			lastch = ftf.Fit_event.ch;
		}
	}
	ftf.Open(33); double endtime = 2250.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t; lastch = ftf.Fit_event.ch;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff < dmax){
				ht->Fill(diff);
				hPT->Fill(diff*0.004,ftf.Fit_event.E*E1 + E0);
			}
			if (diff > dmin && diff < dmax) {//4 to 24 us
				hP->Fill(ftf.Fit_event.E*E1 + E0);
				hch->Fill(ftf.Fit_event.ch,lastch);
			}
			lasttime = time;
			lastch = ftf.Fit_event.ch;
		}
	}
	ftf.Open(35); double endtime = 1000.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t; lastch = ftf.Fit_event.ch;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff < dmax){
				ht->Fill(diff);
				hPT->Fill(diff*0.004,ftf.Fit_event.E*E1 + E0);
			}
			if (diff > dmin && diff < dmax) {//4 to 24 us
				hP->Fill(ftf.Fit_event.E*E1 + E0);
				hch->Fill(ftf.Fit_event.ch,lastch);
			}
			lasttime = time;
			lastch = ftf.Fit_event.ch;
		}
	}
	ftf.Open(36); double endtime = 900.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t; lastch = ftf.Fit_event.ch;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff < dmax){
				ht->Fill(diff);
				hPT->Fill(diff*0.004,ftf.Fit_event.E*E1 + E0);
			}
			if (diff > dmin && diff < dmax) {//4 to 24 us
				hP->Fill(ftf.Fit_event.E*E1 + E0);
				hch->Fill(ftf.Fit_event.ch,lastch);
			}
			lasttime = time;
			lastch = ftf.Fit_event.ch;
		}
	}
	ftf.Open(38); double endtime = 1800.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t; lastch = ftf.Fit_event.ch;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff < dmax){
				ht->Fill(diff);
				hPT->Fill(diff,ftf.Fit_event.E*E1 + E0);
			}
			if (diff > dmin && diff < dmax) {//4 to 24 us
				hP->Fill(ftf.Fit_event.E*E1 + E0);
				hch->Fill(ftf.Fit_event.ch,lastch);
			}
			lasttime = time;
			lastch = ftf.Fit_event.ch;
		}
	}
	gROOT->cd();
	c3->cd();
	hPT->Draw("COLZ");
	c2->cd();
	hch->Draw("COLZ");
	c1->cd();
	endtime = 4*(500.+510.) + 2250. + 1000. + 900. + 1800.;
	hP->Scale(1./endtime);
	hP->SetLineColor(kRed);
	hP->Draw();
	//HV off, UCN on
	TH1D* hB = new TH1D("hB","hB",emax/4.,0,emax);
	ftf.Open(26); endtime = 4*220.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff > dmin && diff < dmax) //4 to 24 us
				hB->Fill(ftf.Fit_event.E*E1 + E0);
			lasttime = time;
		}
	}
	ftf.Open(31); endtime = 4*230.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff > dmin && diff < dmax) //4 to 24 us
				hB->Fill(ftf.Fit_event.E*E1 + E0);
			lasttime = time;
		}
	}
	ftf.Open(32); endtime = 4*100.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff > dmin && diff < dmax) //4 to 24 us
				hB->Fill(ftf.Fit_event.E*E1 + E0);
			lasttime = time;
		}
	}
	ftf.Open(37); double endtime = 1300.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t; lastch = ftf.Fit_event.ch;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff > dmin && diff < dmax) //4 to 24 us
				hB->Fill(ftf.Fit_event.E*E1 + E0);
			lasttime = time;
		}
	}
	gROOT->cd();
	endtime = 4*(220.+230.+100.)+1300.;
	hB->Scale(1./endtime);
	hB->SetLineColor(kGreen);
	hB->Draw("same");
	//HV on, UCN off
	TH1D* hO = new TH1D("hO","hO",emax/4,0,emax);
	ftf.Open(29); endtime = 4*165.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff > dmin && diff < dmax) //4 to 24 us
				hO->Fill(ftf.Fit_event.E*E1 + E0);
			lasttime = time;
		}
	}
	ftf.Open(34); endtime = 540.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff > dmin && diff < dmax) //4 to 24 us
				hO->Fill(ftf.Fit_event.E*E1 + E0);
			lasttime = time;
		}
	}
	ftf.Open(39); endtime = 2500.;
	ftf.GetEvent(0); lasttime = ftf.Fit_event.t;
	for (int i = 0; i < ftf.GetNumEvents(); i++) {
		ftf.GetEvent(i);
		
		if (ftf.Fit_event.E > thresh && ftf.Fit_event.shaping > 180 && ftf.Fit_event.shaping < 240 && ftf.Fit_event.t*tsmp < endtime && ftf.Fit_event.ch != 2 && ftf.Fit_event.ch < 16) {
			double diff = time - lasttime;
			if (diff > dmin && diff < dmax) //4 to 24 us
				hO->Fill(ftf.Fit_event.E*E1 + E0);
			lasttime = time;
		}
	}
	gROOT->cd();
	endtime = 4*(165.)+540+2500;
	hO->Scale(1./endtime);
	hO->SetLineColor(kBlack);
	hO->Draw("same");
}
void Channel::GetShapes(TString SelectionName, TString xtitle, const int nbins, const double *bins){ 
	MT2Shapes *tA;
	if(fWriteToFile) tA = new MT2Shapes(fOutDir, fRootFile, fLogStream);
	else             tA = new MT2Shapes(fOutDir, fRootFile);
	tA->setVerbose(fVerbose);
	tA->init(fSamples);
	tA->SetPrintSummary(true);
	tA->SetDraw(false);
	tA->SetWrite(false);
  
//                    variable,      cuts,  njet, nlep,  selection_name,      HLT,   xtitle   nbins  bins   
        tA->GetShapes(fVariable,  fCuts,    -1,  -10  , SelectionName,    fTrigger , xtitle , nbins, bins);

	// retrieve shapes
	for(int i=0; i<tA->GetNShapes(); ++i){
		TString name =tA->fh_shapes[i]->GetName();
		if      (name.Contains("QCD_"))        {hQCD         = (TH1D*) tA->fh_shapes[i]->Clone(tA->fh_shapes[i]->GetName()); hQCD->SetDirectory(fDir);}
		else if (name.Contains("PhotonsJets_")){hPhotons     = (TH1D*) tA->fh_shapes[i]->Clone(tA->fh_shapes[i]->GetName()); hPhotons->SetDirectory(fDir);}
		else if (name.Contains("Data_"))       {hData        = (TH1D*) tA->fh_shapes[i]->Clone(tA->fh_shapes[i]->GetName()); hData->SetDirectory(fDir);}
		else if (name.Contains("WJets_"))      {hWJets       = (TH1D*) tA->fh_shapes[i]->Clone(tA->fh_shapes[i]->GetName()); hWJets->SetDirectory(fDir);}
		else if (name.Contains("ZJetsToLL_"))  {hZJetsToLL   = (TH1D*) tA->fh_shapes[i]->Clone(tA->fh_shapes[i]->GetName()); hZJetsToLL->SetDirectory(fDir);}
		else if (name.Contains("ZJetsToNuNu_")){hZJetsToNuNu = (TH1D*) tA->fh_shapes[i]->Clone(tA->fh_shapes[i]->GetName()); hZJetsToNuNu->SetDirectory(fDir);}
		else if (name.Contains("Top_"))        {hTop         = (TH1D*) tA->fh_shapes[i]->Clone(tA->fh_shapes[i]->GetName()); hTop->SetDirectory(fDir);}
		else if (name.Contains("Signal_"))     {hSignal      = (TH1D*) tA->fh_shapes[i]->Clone(tA->fh_shapes[i]->GetName()); hSignal->SetDirectory(fDir);}
		else if (name.Contains("Other_"))      {hOther       = (TH1D*) tA->fh_shapes[i]->Clone(tA->fh_shapes[i]->GetName()); hOther->SetDirectory(fDir);}
	}
	delete tA;
	fGotShapes=true;

	fDir->cd();

	// fix colors
	if(hQCD!=0)        {hQCD    ->SetLineColor(kYellow+1);    hQCD    ->SetFillColor(kYellow+1);      hQCD    ->SetFillStyle(3001);}
	if(hPhotons!=0)    {hPhotons->SetLineColor(kViolet-3);    hPhotons->SetFillColor(kViolet-3);      hPhotons->SetFillStyle(3001);}
	if(hOther!=0)      {hOther  ->SetLineColor(kCyan+2);      hOther  ->SetFillColor(kCyan+2);        hOther  ->SetFillStyle(3001);}
	if(hZJetsToNuNu!=0){hZJetsToNuNu->SetLineColor(kGreen+1); hZJetsToNuNu->SetFillColor(kGreen+1);   hZJetsToNuNu  ->SetFillStyle(3001);}
	if(hSignal!=0)     {hSignal ->SetLineColor(kBlack);       hSignal  ->SetFillColor(kBlack);        hSignal  ->SetFillStyle(3001);}
	if(hZJetsToLL!=0)  {hZJetsToLL->SetLineColor(kOrange);    hZJetsToLL->SetFillColor(kOrange);      hZJetsToLL->SetFillStyle(3001);}
	if(hTop!=0)        {hTop    ->SetLineColor(600);          hTop     ->SetFillColor(600);           hTop->SetFillStyle(3001);}

	if(fSaveResults){
		if(hQCD!=0)         {hQCD->Write();}
		if(hPhotons!=0)     {hPhotons->Write();}
		if(hOther!=0)       {hOther->Write();}
		if(hData!=0)        {hData->Write();}
		if(hTop!=0)         {hTop->Write();}
		if(hZJetsToLL!=0)   {hZJetsToLL->Write();}
		if(hZJetsToNuNu!=0) {hZJetsToNuNu->Write();}
		if(hSignal!=0)      {hSignal->Write();}
	}
	if(fDraw){
		if(hQCD!=0)        DrawHisto(hQCD,           hQCD->GetName(),            "hist", this);
		if(hPhotons!=0)    DrawHisto(hPhotons,       hPhotons->GetName(),        "hist", this);
		if(hOther!=0)      DrawHisto(hOther,         hOther->GetName(),          "hist", this);
		if(hData!=0)       DrawHisto(hData,          hData->GetName(),           "EXO",  this);
		if(hTop!=0)        DrawHisto(hTop,           hTop ->GetName(),           "hist", this);
		if(hZJetsToNuNu!=0)DrawHisto(hZJetsToNuNu,   hZJetsToNuNu->GetName(),    "hist", this);
		if(hSignal!=0)     DrawHisto(hSignal,        hSignal->GetName(),         "hist", this);
		if(hZJetsToLL!=0)  DrawHisto(hZJetsToLL,     hZJetsToLL->GetName(),      "hist", this);
	}
}
void PtSpectraCombination_StagedNormalization_EtaCM_M03_M08_NoOLDAlignmentRuns_CombpPbPbp()
{
   gROOT->Reset();
   gROOT->ProcessLine(".x rootlogonChristof.C");
   gROOT->ForceStyle();
   gStyle->SetPalette(1);
   gStyle->SetTitleYOffset(1.27);
   gStyle->SetOptFit(0000);
//   gStyle->SetPadRightMargin(0.16);

   bool doSave = true;

   TFile *f_minbias_pPb = new TFile("CombineSpectra_minbias_EtaCM_M03_M08_NoOLDAlignmentRuns.root");
   TFile *f_FullTrack_12_pPb = new TFile("CombineSpectra_FullTrackTrigger_Track12_EtaCM_M03_M08_NoOLDAlignmentRuns.root");
   TFile *f_FullTrack_20_pPb = new TFile("CombineSpectra_FullTrackTrigger_Track20_EtaCM_M03_M08_NoOLDAlignmentRuns.root");
   TFile *f_FullTrack_30_pPb = new TFile("CombineSpectra_FullTrackTrigger_Track30_EtaCM_M03_M08_NoOLDAlignmentRuns.root");

   TFile *f_minbias_Pbp = new TFile("ReverseBeam/CombineSpectra_minbias_EtaCM_P03_P08.root");
   TFile *f_FullTrack_12_Pbp = new TFile("ReverseBeam/CombineSpectra_FullTrackTrigger_Track12_EtaCM_P03_P08.root");
   TFile *f_FullTrack_20_Pbp = new TFile("ReverseBeam/CombineSpectra_FullTrackTrigger_Track20_EtaCM_P03_P08.root");
   TFile *f_FullTrack_30_Pbp = new TFile("ReverseBeam/CombineSpectra_FullTrackTrigger_Track30_Track50_EtaCM_P03_P08.root");

   TFile *f_out = new TFile("PtSpectraCombination_StagedNormalization_EtaCM_M03_M08_NoOLDAlignmentRuns_CombpPbPbp_TrackTrigger.root","recreate");

   //Get spectra
   TH1D* hPartPt_minbias_corrected_pPb = (TH1D*)f_minbias_pPb->Get("hPartPt_minbias_trkCorr_trigCorr");
   TH1D* hPartPt_0_14_minbias_corrected_pPb = (TH1D*)f_minbias_pPb->Get("hPartPt_0_14_minbias_trkCorr_trigCorr");
   TH1D* hPartPt_14_22_FullTrack12_corrected_pPb = (TH1D*)f_FullTrack_12_pPb->Get("hPartPt_FullTrack12_14_22_trkCorr_trigCorr");
   TH1D* hPartPt_22_32_FullTrack20_corrected_pPb = (TH1D*)f_FullTrack_20_pPb->Get("hPartPt_FullTrack20_22_32_trkCorr_trigCorr");
   TH1D* hPartPt_32_X_FullTrack30_corrected_pPb = (TH1D*)f_FullTrack_30_pPb->Get("hPartPt_FullTrack30_SpectComb_trkCorr_trigCorr");

   TH1D* hPartPt_minbias_corrected_Pbp = (TH1D*)f_minbias_Pbp->Get("hPartPt_minbias_trkCorr_trigCorr");
   TH1D* hPartPt_0_14_minbias_corrected_Pbp = (TH1D*)f_minbias_Pbp->Get("hPartPt_0_14_minbias_trkCorr_trigCorr");
   TH1D* hPartPt_14_22_FullTrack12_corrected_Pbp = (TH1D*)f_FullTrack_12_Pbp->Get("hPartPt_FullTrack12_14_22_trkCorr_trigCorr");
   TH1D* hPartPt_22_32_FullTrack20_corrected_Pbp = (TH1D*)f_FullTrack_20_Pbp->Get("hPartPt_FullTrack20_22_32_trkCorr_trigCorr");
   TH1D* hPartPt_32_X_FullTrack30_corrected_Pbp = (TH1D*)f_FullTrack_30_Pbp->Get("hPartPt_FullTrack30_SpectComb_trkCorr_trigCorr");

   TH1D* hPartPt_minbias_corrected = (TH1D*)hPartPt_minbias_corrected_pPb->Clone("hPartPt_minbias_corrected"); hPartPt_minbias_corrected->Add(hPartPt_minbias_corrected_Pbp);
   TH1D* hPartPt_0_14_minbias_corrected = (TH1D*)hPartPt_0_14_minbias_corrected_pPb->Clone("hPartPt_0_14_minbias_corrected"); hPartPt_0_14_minbias_corrected->Add(hPartPt_0_14_minbias_corrected_Pbp);
   TH1D* hPartPt_14_22_FullTrack12_corrected = (TH1D*)hPartPt_14_22_FullTrack12_corrected_pPb->Clone("hPartPt_14_22_FullTrack12_corrected"); hPartPt_14_22_FullTrack12_corrected->Add(hPartPt_14_22_FullTrack12_corrected_Pbp);
   TH1D* hPartPt_22_32_FullTrack20_corrected = (TH1D*)hPartPt_22_32_FullTrack20_corrected_pPb->Clone("hPartPt_22_32_FullTrack20_corrected"); hPartPt_22_32_FullTrack20_corrected->Add(hPartPt_22_32_FullTrack20_corrected_Pbp);
   TH1D* hPartPt_32_X_FullTrack30_corrected = (TH1D*)hPartPt_32_X_FullTrack30_corrected_pPb->Clone("hPartPt_32_X_FullTrack30_corrected"); hPartPt_32_X_FullTrack30_corrected->Add(hPartPt_32_X_FullTrack30_corrected_Pbp);
/*
   hPartPt_0_14_minbias_corrected_pPb->SetBinContent(hPartPt_0_14_minbias_corrected_pPb->FindBin(103.24),0);//Remove muon event
   hPartPt_0_14_minbias_corrected_pPb->SetBinError(hPartPt_0_14_minbias_corrected_pPb->FindBin(103.24),0);//Remove muon event
   hPartPt_minbias_corrected_pPb->SetBinContent(hPartPt_minbias_corrected_pPb->FindBin(103.24),0);//Remove muon event
   hPartPt_minbias_corrected_pPb->SetBinError(hPartPt_minbias_corrected_pPb->FindBin(103.24),0);//Remove muon event
*/
   //Get number of events
   TH1D* hNumEv_minbias_pPb = (TH1D*)f_minbias_pPb->Get("hNumEv_minbias_trigCorr");
   TH1D* hNumEv_0_14_minbias_pPb = (TH1D*)f_minbias_pPb->Get("hNumEv_0_14_minbias_trigCorr");
   TH1D* hNumEv_14_22_minbias_pPb = (TH1D*)f_minbias_pPb->Get("hNumEv_14_22_minbias_trigCorr");
   TH1D* hNumEv_14_22_FullTrack12_pPb = (TH1D*)f_FullTrack_12_pPb->Get("hNumEv_FullTrack12_14_22_trigCorr");
   TH1D* hNumEv_22_32_FullTrack12_pPb = (TH1D*)f_FullTrack_12_pPb->Get("hNumEv_FullTrack12_22_32_trigCorr");
   TH1D* hNumEv_22_32_FullTrack20_pPb = (TH1D*)f_FullTrack_20_pPb->Get("hNumEv_FullTrack20_22_32_trigCorr");
   TH1D* hNumEv_32_X_FullTrack20_pPb = (TH1D*)f_FullTrack_20_pPb->Get("hNumEv_FullTrack20_32_X_trigCorr");
   TH1D* hNumEv_32_X_FullTrack30_pPb = (TH1D*)f_FullTrack_30_pPb->Get("hNumEv_FullTrack30_32_X_trigCorr");

   TH1D* hNumEv_minbias_Pbp = (TH1D*)f_minbias_Pbp->Get("hNumEv_minbias_trigCorr");
   TH1D* hNumEv_0_14_minbias_Pbp = (TH1D*)f_minbias_Pbp->Get("hNumEv_0_14_minbias_trigCorr");
   TH1D* hNumEv_14_22_minbias_Pbp = (TH1D*)f_minbias_Pbp->Get("hNumEv_14_22_minbias_trigCorr");
   TH1D* hNumEv_14_22_FullTrack12_Pbp = (TH1D*)f_FullTrack_12_Pbp->Get("hNumEv_FullTrack12_14_22_trigCorr");
   TH1D* hNumEv_22_32_FullTrack12_Pbp = (TH1D*)f_FullTrack_12_Pbp->Get("hNumEv_FullTrack12_22_32_trigCorr");
   TH1D* hNumEv_22_32_FullTrack20_Pbp = (TH1D*)f_FullTrack_20_Pbp->Get("hNumEv_FullTrack20_22_32_trigCorr");
   TH1D* hNumEv_32_X_FullTrack20_Pbp = (TH1D*)f_FullTrack_20_Pbp->Get("hNumEv_FullTrack20_32_X_trigCorr");
   TH1D* hNumEv_32_X_FullTrack30_Pbp = (TH1D*)f_FullTrack_30_Pbp->Get("hNumEv_FullTrack30_32_X_trigCorr");

   TH1D* hNumEv_minbias = (TH1D*)hNumEv_minbias_pPb->Clone("hNumEv_minbias"); hNumEv_minbias->Add(hNumEv_minbias_Pbp);
   TH1D* hNumEv_0_14_minbias = (TH1D*)hNumEv_0_14_minbias_pPb->Clone("hNumEv_0_14_minbias"); hNumEv_0_14_minbias->Add(hNumEv_0_14_minbias_Pbp);
   TH1D* hNumEv_14_22_minbias = (TH1D*)hNumEv_14_22_minbias_pPb->Clone("hNumEv_14_22_minbias"); hNumEv_14_22_minbias->Add(hNumEv_14_22_minbias_Pbp);
   TH1D* hNumEv_14_22_FullTrack12 = (TH1D*)hNumEv_14_22_FullTrack12_pPb->Clone("hNumEv_14_22_FullTrack12"); hNumEv_14_22_FullTrack12->Add(hNumEv_14_22_FullTrack12_Pbp);
   TH1D* hNumEv_22_32_FullTrack12 = (TH1D*)hNumEv_22_32_FullTrack12_pPb->Clone("hNumEv_22_32_FullTrack12"); hNumEv_22_32_FullTrack12->Add(hNumEv_22_32_FullTrack12_Pbp);
   TH1D* hNumEv_22_32_FullTrack20 = (TH1D*)hNumEv_22_32_FullTrack20_pPb->Clone("hNumEv_22_32_FullTrack20"); hNumEv_22_32_FullTrack20->Add(hNumEv_22_32_FullTrack20_Pbp);
   TH1D* hNumEv_32_X_FullTrack20 = (TH1D*)hNumEv_32_X_FullTrack20_pPb->Clone("hNumEv_32_X_FullTrack20"); hNumEv_32_X_FullTrack20->Add(hNumEv_32_X_FullTrack20_Pbp);
   TH1D* hNumEv_32_X_FullTrack30 = (TH1D*)hNumEv_32_X_FullTrack30_pPb->Clone("hNumEv_32_X_FullTrack30"); hNumEv_32_X_FullTrack30->Add(hNumEv_32_X_FullTrack30_Pbp);

   float numev_minbias = hNumEv_minbias->GetBinContent(1);
   float numev_0_14_minbias = hNumEv_0_14_minbias->GetBinContent(1);
   float numev_14_22_minbias = hNumEv_14_22_minbias->GetBinContent(1);
   float numev_14_22_FullTrack12 = hNumEv_14_22_FullTrack12->GetBinContent(1);
   float numev_22_32_FullTrack12 = hNumEv_22_32_FullTrack12->GetBinContent(1);
   float numev_22_32_FullTrack20 = hNumEv_22_32_FullTrack20->GetBinContent(1);
   float numev_32_X_FullTrack20 = hNumEv_32_X_FullTrack20->GetBinContent(1);
   float numev_32_X_FullTrack30 = hNumEv_32_X_FullTrack30->GetBinContent(1);

   std::cerr<<" Number of minbias events in the normalization classes:" << std::endl;
   std::cerr<<"   All      : " << numev_minbias << std::endl;
   std::cerr<<"    0-14 MB : " << numev_0_14_minbias << std::endl;
   std::cerr<<"   14-22 MB : " << numev_14_22_minbias << std::endl;
   std::cerr<<"   14-22 T12: " << numev_14_22_FullTrack12 << std::endl;
   std::cerr<<"   22-32 T12: " << numev_22_32_FullTrack12 << std::endl;
   std::cerr<<"   22-32 T20: " << numev_22_32_FullTrack20 << std::endl;
   std::cerr<<"   32-X  T20: " << numev_32_X_FullTrack20 << std::endl;
   std::cerr<<"   32-X  T30: " << numev_32_X_FullTrack30 << std::endl;

   std::cerr<<" numev_minbias/numev_0_14_minbias: " << 100.*numev_minbias/numev_0_14_minbias << "%" << std::endl;
   std::cerr<<" numev_14_22_minbias/numev_0_14_minbias: " << 100.*numev_14_22_minbias/numev_0_14_minbias << "%" << std::endl;
   std::cerr<<" numev_14_22_FullTrack12/numev_22_32_FullTrack12: " << 100.*numev_14_22_FullTrack12/numev_22_32_FullTrack12 << std::endl;

   //Prepare the individual normalizations
   float norm_0_14_minbias = numev_minbias;
   float norm_14_22_FullTrack12 = norm_0_14_minbias*numev_14_22_FullTrack12/numev_14_22_minbias;
//   float norm_14_22_FullTrack12 = numev_14_22_FullTrack12*2466.480;
   float norm_22_32_FullTrack20 = norm_14_22_FullTrack12*numev_22_32_FullTrack20/numev_22_32_FullTrack12;
   float norm_32_X_FullTrack30 = norm_22_32_FullTrack20*numev_32_X_FullTrack30/numev_32_X_FullTrack20;

   std::cerr<<"Normalization factors:" << std::endl;
   std::cerr<<"      norm_0_14_minbias     : " << norm_0_14_minbias << std::endl;
   std::cerr<<"      norm_14_22_FullTrack12: " << norm_14_22_FullTrack12 << std::endl;
   std::cerr<<"      norm_22_32_FullTrack20: " << norm_22_32_FullTrack20 << std::endl;
   std::cerr<<"      norm_32_X_FullTrack30 : " << norm_32_X_FullTrack30 << std::endl;

   hPartPt_minbias_corrected->Scale(1./numev_minbias);
   hPartPt_0_14_minbias_corrected->Scale(1./norm_0_14_minbias);
   hPartPt_14_22_FullTrack12_corrected->Scale(1./norm_14_22_FullTrack12);
   hPartPt_22_32_FullTrack20_corrected->Scale(1./norm_22_32_FullTrack20);
   hPartPt_32_X_FullTrack30_corrected->Scale(1./norm_32_X_FullTrack30);

   TCanvas *c1 = new TCanvas("c1","c1");
   c1->cd();
   c1->SetLogy();
   hPartPt_0_14_minbias_corrected->GetXaxis()->CenterTitle();
   hPartPt_0_14_minbias_corrected->GetYaxis()->CenterTitle();
   hPartPt_0_14_minbias_corrected->GetXaxis()->SetTitle("p_{T} [GeV/c]");
   hPartPt_0_14_minbias_corrected->GetYaxis()->SetTitle("1/N_{ev} dN/dp_{T} (|#eta_{CM}|<1)");
//   hPartPt_0_14_minbias_corrected->SetNdivisions(505);
   hPartPt_0_14_minbias_corrected->SetMarkerColor(42);
   hPartPt_0_14_minbias_corrected->SetLineColor(42);
   hPartPt_0_14_minbias_corrected->SetMarkerStyle(34);
   hPartPt_0_14_minbias_corrected->SetMinimum(1e-11);
   hPartPt_0_14_minbias_corrected->SetFillColor(42);
//   hPartPt_0_14_minbias_corrected->SetFillStyle(3305);
   hPartPt_0_14_minbias_corrected->Draw("hist");

   hPartPt_minbias_corrected->SetMarkerStyle(20);
   hPartPt_minbias_corrected->Draw("same");

   hPartPt_14_22_FullTrack12_corrected->SetMarkerColor(2);
   hPartPt_14_22_FullTrack12_corrected->SetLineColor(2);
   hPartPt_14_22_FullTrack12_corrected->SetMarkerStyle(20);
   hPartPt_14_22_FullTrack12_corrected->SetFillColor(2);
   hPartPt_14_22_FullTrack12_corrected->SetFillStyle(3002);
   hPartPt_14_22_FullTrack12_corrected->Draw("same");

   hPartPt_22_32_FullTrack20_corrected->SetMarkerColor(4);
   hPartPt_22_32_FullTrack20_corrected->SetLineColor(4);
   hPartPt_22_32_FullTrack20_corrected->SetMarkerStyle(20);
//   hPartPt_22_32_FullTrack20_corrected->SetFillColor(2);
//   hPartPt_22_32_FullTrack20_corrected->SetFillStyle(3002);
   hPartPt_22_32_FullTrack20_corrected->Draw("samehist");

   hPartPt_32_X_FullTrack30_corrected->SetMarkerColor(2);
   hPartPt_32_X_FullTrack30_corrected->SetLineColor(2);
   hPartPt_32_X_FullTrack30_corrected->SetMarkerStyle(20);
//   hPartPt_32_X_FullTrack30_corrected->SetFillColor(2);
//   hPartPt_32_X_FullTrack30_corrected->SetFillStyle(3002);
   hPartPt_32_X_FullTrack30_corrected->Draw("samehist");

   //Sum
   TH1D * hSumPartPt = (TH1D*)hPartPt_0_14_minbias_corrected->Clone("hSumPartPt");
   hSumPartPt->Add(hPartPt_14_22_FullTrack12_corrected);
   hSumPartPt->Add(hPartPt_22_32_FullTrack20_corrected);
   hSumPartPt->Add(hPartPt_32_X_FullTrack30_corrected);
   hSumPartPt->SetMarkerStyle(25);
   hSumPartPt->SetMarkerColor(1);
   hSumPartPt->SetLineColor(1);
   hSumPartPt->Draw("same");

   TLegend *leg1 = new TLegend(0.48,0.47,0.93,0.95,NULL,"brNDC");
   leg1->AddEntry(hPartPt_minbias_corrected,"MinBias, inclusive","pl");
   leg1->AddEntry(hPartPt_0_14_minbias_corrected,"MinBias, p_{T}<14 GeV/c","f");
   leg1->AddEntry(hPartPt_14_22_FullTrack12_corrected,"FullTrack12, 14<p_{T}<22 GeV/c","pl");
   leg1->AddEntry(hPartPt_22_32_FullTrack20_corrected,"FullTrack20, 22<p_{T}<32 GeV/c","l");
   leg1->AddEntry(hPartPt_32_X_FullTrack30_corrected,"FullTrack30, 32<p_{T} GeV/c","l");
   leg1->AddEntry(hSumPartPt,"Combined spectrum","pl");
   leg1->SetFillStyle(0);
   leg1->SetFillColor(0);
   leg1->SetBorderSize(0);
   leg1->Draw();
   if(doSave) {
      c1->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_M03_M08_NoOLDAlignmentRuns_CombpPbPbp_c1.gif");
      c1->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_M03_M08_NoOLDAlignmentRuns_CombpPbPbp_c1.eps");
      c1->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_M03_M08_NoOLDAlignmentRuns_CombpPbPbp_c1.C");
   }


   TCanvas *c2 = new TCanvas("c2","c2");
   c2->cd();
   TH1D *hSumPartPt_copy1 = (TH1D*)hSumPartPt->Clone("hSumPartPt_copy1");
   hSumPartPt_copy1->Divide(hPartPt_minbias_corrected);
   hSumPartPt_copy1->GetYaxis()->SetTitle("Combined spectrum / MB inclusive");
   hSumPartPt_copy1->Draw();

   TLatex *inf1 = new TLatex(0.33,0.17,"Combined spectrum: from track triggers");
   inf1->SetNDC();
   inf1->SetTextSize(0.035);
   inf1->Draw();

   TPad *c2_zoom = new TPad("c2_zoom","c2_zoom",0.56,0.56,0.94,0.93);
   c2_zoom->SetFillStyle(0);
   c2_zoom->SetLogx();
   c2_zoom->Draw();
   c2_zoom->cd();
   TH1D *hSumPartPt_copy2 = (TH1D*)hSumPartPt_copy1->Clone("hSumPartPt_copy2");
   hSumPartPt_copy2->GetXaxis()->CenterTitle();
   hSumPartPt_copy2->GetYaxis()->CenterTitle();
   hSumPartPt_copy2->GetXaxis()->SetTitle("p_{T} [GeV/c]");
   hSumPartPt_copy2->GetYaxis()->SetTitle("Combined spectrum / MB inclusive ");
   hSumPartPt_copy2->GetXaxis()->SetRangeUser(0.,18.);
   hSumPartPt_copy2->SetMinimum(0.95);
   hSumPartPt_copy2->SetMaximum(1.05);
   hSumPartPt_copy2->Draw();
   if(doSave) {
      c2->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_M03_M08_NoOLDAlignmentRuns_CombpPbPbp_c2.gif");
      c2->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_M03_M08_NoOLDAlignmentRuns_CombpPbPbp_c2.eps");
      c2->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_M03_M08_NoOLDAlignmentRuns_CombpPbPbp_c2.C");
   }

/*
   TLegend *leg2 = new TLegend(0.80,0.75,0.95,0.95,NULL,"brNDC");
   leg2->AddEntry(hPartPt_Jet40_copy1,"Jet40","pl");
   leg2->AddEntry(hPartPt_Jet60_copy1,"Jet60","pl");
   leg2->AddEntry(hPartPt_Jet80_copy1,"Jet80","pl");
   leg2->AddEntry(hPartPt_Jet100_copy1,"Jet100","pl");
   leg2->SetFillStyle(0);
   leg2->SetFillColor(0);
   leg2->SetBorderSize(0);
   leg2->Draw();
*/
   
  f_out->cd();
  hSumPartPt->Write();
  f_out->Close();

}
Example #28
0
// -----------------------------------------------------------------------------
//
TCanvas* aDrawBkgdPlots( TString path, 
			 TString canvas_name, 
			 TString name, 
			 TString dirmame, 
			 int rebin, 
			 bool norm, 
			 bool log,
			 TDirectory* file )
{

  // SetSomeStyles();

  // Create legend
  TLegend* legend = new TLegend( 0.75, 0.65, 0.92, 0.92, NULL, "brNDC" );
  legend->SetFillColor(0);
  legend->SetLineColor(0); 
  
  // Create canvas
  TCanvas* aCanvas = getaCanvas( canvas_name, file, log );
  
  // Create histograms
  TH1D* qcd     = readHist( path, name, "IC5Calo_QCD_Pythia_Merged.root", dirmame, rebin );
  TH1D* tt_jets = readHist( path, name, "IC5Calo_TTbarJets.root", dirmame, rebin );
  TH1D* w_jets  = readHist( path, name, "IC5Calo_WJets.root", dirmame, rebin );
  TH1D* z_inv   = readHist( path, name, "IC5Calo_Zinv.root", dirmame, rebin );
  TH1D* z_jets  = readHist( path, name, "IC5Calo_ZJets.root", dirmame, rebin );
  TH1D* lm0     = readHist( path, name, "IC5Calo_LM0.root", dirmame, rebin );
  TH1D* lm1     = readHist( path, name, "IC5Calo_LM1.root", dirmame, rebin );

  // Combine Z+jets and Z->inv
  TH1D* z_all = z_inv->Clone(); 
  z_all->Add(z_jets,1);

//   TH1D* z_all = 0;
//   if ( z_inv && z_jets ) { 
//     z_all = z_inv->Clone(); 
//     z_all->Add(z_jets,1);
//   } else if ( z_inv ) { 
//     z_all = z_inv->Clone(); 
//   } else if ( z_jets ) { 
//     z_all = z_jets->Clone(); 
//   }
  
  // Select Z+jets and Z->inv separate or not
  bool combine = true;
  
  // Line colour and fill
  if ( qcd ) qcd->SetLineColor(kGreen+2);
  if ( qcd ) qcd->SetFillColor(kGreen+2);
  if ( qcd ) qcd->SetFillStyle(3003);
  if ( tt_jets ) tt_jets->SetLineColor(kBlue);
  if ( tt_jets ) tt_jets->SetLineStyle(1);
  if ( tt_jets ) tt_jets->SetLineWidth(1);
  w_jets->SetLineColor(kBlue);
  w_jets->SetLineStyle(3);
  w_jets->SetLineWidth(1);
  if ( combine ) {
    z_all->SetLineColor(kBlack);
    z_all->SetLineStyle(3);
    z_all->SetLineWidth(1);
  } else {
    z_inv->SetLineColor(kBlack);
    z_inv->SetLineStyle(1);
    z_inv->SetLineWidth(1);
    z_jets->SetLineColor(kBlack);
    z_jets->SetLineStyle(3);
    z_jets->SetLineWidth(1);
  }
  lm0->SetLineColor(kRed);
  lm0->SetLineStyle(1);
  lm0->SetLineWidth(2);
  lm1->SetLineColor(kRed);
  lm1->SetLineStyle(3);
  lm1->SetLineWidth(2);

  // Populate legend
  legend->AddEntry( qcd, " QCD", "f" );
  legend->AddEntry( lm0, " SUSY LM0", "L" );
  legend->AddEntry( lm1, " SUSY LM1", "L" );
  legend->AddEntry( tt_jets, " t#bar{t}+jets", "L" );
  legend->AddEntry( w_jets, " W+jets", "L" );
  if ( combine ) {
    legend->AddEntry( z_all, " Z", "L" );
  } else {
    legend->AddEntry( z_jets, " Z+jets", "L" );
    legend->AddEntry( z_inv, " Z#rightarrow#nu#nu", "L" );
  }

  // Calc maximum number of entries
  double aMax = 0.;
  if ( qcd->GetMaximum()     > aMax ) { aMax = qcd->GetMaximum(); }
  if ( lm0->GetMaximum()     > aMax ) { aMax = lm0->GetMaximum(); }
  if ( lm1->GetMaximum()     > aMax ) { aMax = lm1->GetMaximum(); }
  if ( tt_jets->GetMaximum() > aMax ) { aMax = tt_jets->GetMaximum(); }  
  if ( w_jets->GetMaximum()  > aMax ) { aMax = w_jets->GetMaximum(); }  
  if ( combine ) {
    if ( z_all->GetMaximum()  > aMax ) { aMax = z_all->GetMaximum(); }  
  } else {
    if ( z_inv->GetMaximum()   > aMax ) { aMax = z_inv->GetMaximum(); }  
    if ( z_jets->GetMaximum()  > aMax ) { aMax = z_jets->GetMaximum(); }  
  }

  // Calc minimum number of entries
  double aMin = 1.e12;
  if ( qcd->GetMinimum(1.e-12)     < aMin ) { aMin = qcd->GetMinimum(1.e-12); }
  if ( lm0->GetMinimum(1.e-12)     < aMin ) { aMin = lm0->GetMinimum(1.e-12); }
  if ( lm1->GetMinimum(1.e-12)     < aMin ) { aMin = lm1->GetMinimum(1.e-12); }
  if ( tt_jets->GetMinimum(1.e-12) < aMin ) { aMin = tt_jets->GetMinimum(1.e-12); }  
  if ( w_jets->GetMinimum(1.e-12)  < aMin ) { aMin = w_jets->GetMinimum(1.e-12); }  
  if ( combine ) {
    if ( z_all->GetMinimum(1.e-12)   < aMin ) { aMin = z_all->GetMinimum(1.e-12); }  
  } else {
    if ( z_inv->GetMinimum(1.e-12)   < aMin ) { aMin = z_inv->GetMinimum(1.e-12); }  
    if ( z_jets->GetMinimum(1.e-12)  < aMin ) { aMin = z_jets->GetMinimum(1.e-12); }  
  }

  if ( qcd ) qcd->GetYaxis()->SetTitleOffset(1.43);
  if ( qcd ) qcd->GetYaxis()->SetTitleSize(0.06);
  if ( qcd ) qcd->GetXaxis()->SetTitleSize(0.06);
  if ( qcd ) qcd->GetXaxis()->SetTitleOffset(0.9);

  if ( log ) {
    if ( qcd ) qcd->SetMaximum( aMax * 10. );
    if ( qcd ) qcd->SetMinimum( aMin * 0.1 );
  } else {
    if ( qcd ) qcd->SetMaximum( aMax * 1.1 );
    if ( qcd ) qcd->SetMinimum( aMin * 0.9 );
  }

  if ( norm ) {
    if ( qcd ) qcd->DrawNormalized("Ehist");
    if ( lm0->GetEntries() > 0. )     { lm0->DrawNormalized("hsame"); }
    if ( lm1->GetEntries() > 0. )     { lm1->DrawNormalized("hsame"); }
    if ( tt_jets->GetEntries() > 0. ) { tt_jets->DrawNormalized("hsame"); }
    if ( w_jets->GetEntries() > 0. )  { w_jets->DrawNormalized("hsame"); }
    if ( combine ) {
      if ( z_all->GetEntries() > 0. )   { z_all->DrawNormalized("hsame"); }
    } else {
      if ( z_inv->GetEntries() > 0. )   { z_inv->DrawNormalized("hsame"); }
      if ( z_jets->GetEntries() > 0. )  { z_jets->DrawNormalized("hsame"); }
    }
  } else {
    if ( qcd ) qcd->Draw("h");
    lm0->Draw("sameH");
    lm1->Draw("sameH");
    if ( tt_jets ) tt_jets->Draw("sameh");
    w_jets->Draw("sameH");
    if ( combine ) {
      z_all->Draw("sameH");
    } else {
      z_inv->Draw("sameH");
      z_jets->Draw("sameH");
    }
  }
  
  file->cd();
  legend->Draw("same");
  aCanvas->Write();
  return aCanvas;

}
Example #29
0
void diffXsect() {

//choice of systematic to look at
    int choice = 0;
    bool writeFile =true;

//MET will need choice of variable at the top
// TString Variable ="_MET";
// int Nbins = 6;
// TString bins[6] = {"_bin_0-25", "_bin_25-45", "_bin_45-70", "_bin_70-100", "_bin_100-150", "_bin_150-inf"};
// double width[6] = {25, 20, 25, 30, 50, 100};
// double xbins[7] = {1,25,45,70,100,150, 250};
// TString varBin = "Binned_MET_Analysis/patType1CorrectedPFMet";
// TString Xtitle = "MET [GeV]";

//HT
// TString Variable ="_HT";
// int Nbins = 8;
// TString bins[8] = {"_bin_0-50", "_bin_50-150", "_bin_150-250", "_bin_250-350", "_bin_350-450", "_bin_450-650", "_bin_650-1100", "_bin_1100-inf"};
// double width[8] = {50,100,100,100,100,200,450,400};
// double xbins[9] = {1,50,150,250,350,450,650,1100, 1500};
// TString varBin = "Binned_HT_Analysis/HT";
// TString Xtitle = "HT [GeV]";

//ST
    TString Variable ="_ST";
    int Nbins = 8;
    TString bins[8] = {"_bin_0-150", "_bin_150-250", "_bin_250-350", "_bin_350-450", "_bin_450-550", "_bin_550-750", "_bin_750-1250", "_bin_1250-inf"};
    double width[8] = {150,100,100,100,100,200,500,500};
    double xbins[9] = {1,150,250,350,450,550,750,1250, 1750};
    TString varBin = "Binned_ST_Analysis/ST_with_patType1CorrectedPFMet";
    TString Xtitle = "ST [GeV]";

//MT
// TString Variable ="_MT";
// int Nbins = 5;
// TString bins[5] = {"_bin_0-40", "_bin_40-65", "_bin_65-85", "_bin_85-150", "_bin_150-inf"};
// double width[5] = {40,25,20,65,50};
// double xbins[6] = {1,40,65,85,150,200};
// TString varBin = "Binned_MT_Analysis/MT_with_patType1CorrectedPFMet";
// TString Xtitle = "M(W)_{T} [GeV]";

//int Nsys = 1;
    int Nsys = 27;

//from fit
    double NfitVal[Nbins][Nsys];
    double NfitErr[Nbins][Nsys];
    double NttbarVal[Nbins][Nsys];
    double NttbarErr[Nbins][Nsys];
    double sigmaVal[Nbins][Nsys];
    double sigmaErr[Nbins][Nsys];

//before fit
    double madgraphVals[Nbins][Nsys];
    double mcatnloVals[Nbins][Nsys];
    double powhegVals[Nbins][Nsys];

    double ttbarPre[Nbins][Nsys];
    double singletPre[Nbins][Nsys];
    double wjetsPre[Nbins][Nsys];
    double zjetsPre[Nbins][Nsys];
    double qcdPre[Nbins][Nsys];
    double BGscale[Nbins][Nsys];
    double totXsect[Nsys];

//sample
//TString dir = "central";
//TString dir = "JES_up";
    TString dirs[27] = {"central","JES_up","JES_down", "BJet_up", "BJet_down", "PU_up", "PU_down", "Scale_up_tt", "Scale_down_tt", "Scale_up", "Scale_down", "Match_up_tt", "Match_down_tt", "Match_up", "Match_down", "UnclusteredEnUp", "UnclusteredEnDown", "JetEnUp", "JetEnDown", "JetResUp", "JetResDown", "TauEnUp", "TauEnDown", "MuonEnUp", "MuonEnDown", "ElectronEnUp", "ElectronEnDown"};

//loop over systematics
    for(int sys = 0; sys < Nsys; sys++) {
        TString dir  = dirs[sys];

        totXsect[sys]= 0;

        int rebinFact = 1;
//for ttbar total
        TH1D* tt_tot = getSample("TTJet", lumi*225.197/6920475, rebinFact, "Muon", dir);
        TH1D* mcnlo_tot = getSample("TTJet_MCNLO", lumi*225.197/6920475, rebinFact, "Muon", "central");
        TH1D* powheg_tot = getSample("TTJet_POWHEG", lumi*225.197/6920475, rebinFact, "Muon", "central");
//loop over bins of distribution
        for(int i = 0; i < Nbins; i++) {

            TString bin = varBin;

            if(dir == "UnclusteredEnUp" || dir == "UnclusteredEnDown" || dir == "JetEnUp" || dir == "JetEnDown" || dir == "JetResUp" || dir == "JetResDown" || dir == "TauEnUp" || dir == "TauEnDown" || dir == "MuonEnUp" || dir == "MuonEnDown" || dir == "ElectronEnUp" || dir == "ElectronEnDown")
                bin += dir;

            bin += bins[i];


            bool inclZ = false;
            bool inclW = false;

            if(dir == "Scale_up" || dir == "Scale_down" || dir == "Match_up" || dir == "Match_down") {
                inclZ = true;
                inclW = true;
            }

            cout <<  bin << endl;
            TH1D* tt = getSample("TTJet", lumi*225.197/6920475, rebinFact, bin, dir);
            TH1D* tt_mcnlo = getSample("TTJet_MCNLO", lumi*225.197/6920475, rebinFact, bin, "central");
            TH1D* tt_powheg = getSample("TTJet_POWHEG", lumi*225.197/6920475, rebinFact, bin, "central");

            TH1D* top_t = getSample("T_t-channel", lumi*56.4/3757707, rebinFact, bin, dir);
            TH1D* top_tw = getSample("T_tW-channel", lumi*11.1/497395, rebinFact, bin, dir);
            TH1D* top_s = getSample("T_s-channel", lumi*3.79/249516, rebinFact, bin, dir);
            TH1D* tbar_t = getSample("Tbar_t-channel", lumi*30.7/1934817, rebinFact, bin, dir);
            TH1D* tbar_tw = getSample("Tbar_tW-channel", lumi*11.1/493239, rebinFact, bin, dir);
            TH1D* tbar_s = getSample("Tbar_s-channel", lumi*1.76/139948, rebinFact, bin, dir);


            TH1D* wjets;
//TH1D* w1jets = getSample("W1Jet", lumi*5400.0/23140779, rebinFact, bin, dir);
            TH1D* w2jets = getSample("W2Jets", lumi*1750.0/34041404, rebinFact, bin, dir);
            TH1D* w3jets = getSample("W3Jets", lumi*519.0/15536443, rebinFact, bin, dir);
            TH1D* w4jets = getSample("W4Jets", lumi*214.0/13370904, rebinFact, bin, dir);

            TH1D* zjets;
//TH1D* z1jets = getSample("DY1JetsToLL", lumi*561.0/24042904, rebinFact, bin, dir);
            TH1D* z2jets = getSample("DY2JetsToLL", lumi*181.0/21835749, rebinFact, bin, dir);
            TH1D* z3jets = getSample("DY3JetsToLL", lumi*51.1/11010628, rebinFact, bin, dir);
            TH1D* z4jets = getSample("DY4JetsToLL", lumi*23.04/6391785, rebinFact, bin, dir);

            TH1D* qcd_mc = getSample("QCD_Pt-15to20_MuEnrichedPt5",   lumi*7.022e8 * 0.0039/1722678, rebinFact, bin, dir);
            TH1D* qcd2 = getSample("QCD_Pt-20to30_MuEnrichedPt5",   lumi*2.87e8 * 0.0065/8486893, rebinFact, bin, dir);
            TH1D* qcd3 = getSample("QCD_Pt-30to50_MuEnrichedPt5",   lumi*6.609e7 * 0.0122/8928999, rebinFact, bin, dir);
            TH1D* qcd4 = getSample("QCD_Pt-50to80_MuEnrichedPt5",   lumi*8082000.0 * 0.0218/7256011, rebinFact, bin, dir);
            TH1D* qcd5 = getSample("QCD_Pt-80to120_MuEnrichedPt5",  lumi*1024000.0 * 0.0395/9030624, rebinFact, bin, dir);
            TH1D* qcd6 = getSample("QCD_Pt-120to170_MuEnrichedPt5", lumi*157800.0 * 0.0473/8500505, rebinFact, bin, dir);
            TH1D* qcd7 = getSample("QCD_Pt-170to300_MuEnrichedPt5", lumi*34020.0 * 0.0676/7662483, rebinFact, bin, dir);
            TH1D* qcd8 = getSample("QCD_Pt-300to470_MuEnrichedPt5", lumi*1757.0 * 0.0864/7797481, rebinFact, bin, dir);
            TH1D* qcd9 = getSample("QCD_Pt-470to600_MuEnrichedPt5", lumi*115.2 * 0.1024/2995767, rebinFact, bin, dir);
            TH1D* qcd10 = getSample("QCD_Pt-800to1000_MuEnrichedPt5",lumi*3.57 * 0.1033/4047142, rebinFact, bin, dir);
            TH1D* qcd11 = getSample("QCD_Pt-1000_MuEnrichedPt5",     lumi*0.774 * 0.1097/3807263, rebinFact, bin, dir);

            qcd_mc->Add(qcd2);
            qcd_mc->Add(qcd3);
            qcd_mc->Add(qcd4);
            qcd_mc->Add(qcd5);
            qcd_mc->Add(qcd6);
            qcd_mc->Add(qcd7);
            qcd_mc->Add(qcd8);
            qcd_mc->Add(qcd9);
            qcd_mc->Add(qcd10);
            qcd_mc->Add(qcd11);

            if(inclZ == true) {
                zjets = getSample("DYJetsToLL", lumi*5745.25/30457954, rebinFact, bin, dir);

            } else {
                zjets  = getSample("DY1JetsToLL", lumi*561.0/24042904, rebinFact, bin, dir);
                zjets->Add(z2jets);
                zjets->Add(z3jets);
                zjets->Add(z4jets);
            }

            if(inclW == true) {
                wjets = getSample("WJetsToLNu", lumi*37509/57708550, rebinFact, bin, dir);
            } else {
                wjets = getSample("W1Jet", lumi*5400.0/23140779, rebinFact, bin, dir);
                wjets->Add(w2jets);
                wjets->Add(w3jets);
                wjets->Add(w4jets);
            }

//sum single top into one
            TH1D* single_top = (TH1D*)top_t->Clone("single top");
            single_top->Add(top_tw);
            single_top->Add(top_s);
            single_top->Add(tbar_t);
            single_top->Add(tbar_tw);
            single_top->Add(tbar_s);

            NfitVal[i][sys] = etaFit(bin, "measured",dir);
            NfitErr[i][sys] = etaFit(bin, "measuredErr",dir);
            BGscale[i][sys] = etaFit(bin,"bgscale",dir);

            NttbarVal[i][sys] = NfitVal[i][sys]-single_top->Integral();
            NttbarErr[i][sys] = NfitErr[i][sys] ;

            sigmaVal[i][sys] = ((NfitVal[i][sys]-single_top->Integral())/tt_tot->Integral())*225.197;
            sigmaErr[i][sys] = (((NfitVal[i][sys]+NfitErr[i][sys]-single_top->Integral())/tt_tot->Integral())*225.197)-sigmaVal[i][sys];

//cout << "error: " << sigmaErr[i][sys] << endl;

            madgraphVals[i][sys] = (tt->Integral()/tt_tot->Integral())*225.197;
            mcatnloVals[i][sys] = (tt_mcnlo->Integral()/mcnlo_tot->Integral())*225.197;
            powhegVals[i][sys] = (tt_powheg->Integral()/powheg_tot->Integral())*225.197;

            ttbarPre[i][sys] = tt->Integral();
            singletPre[i][sys] = single_top->Integral();
            wjetsPre[i][sys] = wjets->Integral();
            zjetsPre[i][sys] = zjets->Integral();
            qcdPre[i][sys] = qcd_mc->Integral();

            totXsect[sys] += sigmaVal[i][sys];
        }

    }

    //will need to change MET for other variables
    TFile resultsfile("outFiles/diffResults"+Variable+".root", "UPDATE", "comment");

    for(int sys = 0; sys < Nsys; sys++) {
        TString dir  = dirs[sys];

        resultsfile.mkdir(dir+"_dir");
        resultsfile.cd(dir+"_dir");

        //measured histo will have to put name of systematic in here to write into file
        TH1D *muon_part  = new TH1D(dir+"_signal_fit", "", Nbins, xbins);  //muon
        TH1D *ttbar_fit  = new TH1D(dir+"_ttbar_fit", "", Nbins, xbins);  //muon
        TH1D *ttbar_prefit  = new TH1D(dir+"_ttbar_prefit", "", Nbins, xbins);  //muon
        TH1D *singlet_prefit  = new TH1D(dir+"_singlet_prefit", "", Nbins, xbins);  //muon
        TH1D *wjets_prefit  = new TH1D(dir+"_wjets_prefit", "", Nbins, xbins);  //muon
        TH1D *zjets_prefit  = new TH1D(dir+"_zjets_prefit", "", Nbins, xbins);  //muon
        TH1D *qcd_prefit  = new TH1D(dir+"_qcd_prefit", "", Nbins, xbins);  //muon
        TH1D *wjets_fit  = new TH1D(dir+"_wjets_fit", "", Nbins, xbins);  //mu
        TH1D *zjets_fit  = new TH1D(dir+"_zjets_fit", "", Nbins, xbins);  //mu
        TH1D *qcd_fit  = new TH1D(dir+"_qcd_fit", "", Nbins, xbins);  //muon

//	muon_part->SetDirectory(directory);
        //loop over bins of distribution
        for(int i = 0; i < Nbins; i++) {
            muon_part->SetBinContent(i+1,NfitVal[i][sys]);
            muon_part->SetBinError(i+1, NfitErr[i][sys]);
            ttbar_fit->SetBinContent(i+1,NttbarVal[i][sys]);
            ttbar_fit->SetBinError(i+1, NttbarErr[i][sys]);
            ttbar_prefit->SetBinContent(i+1,ttbarPre[i][sys]);
            singlet_prefit->SetBinContent(i+1,singletPre[i][sys]);
            wjets_prefit->SetBinContent(i+1, wjetsPre[i][sys]);
            zjets_prefit->SetBinContent(i+1, zjetsPre[i][sys]);
            qcd_prefit->SetBinContent(i+1,  qcdPre[i][sys]);
            wjets_fit->SetBinContent(i+1, wjetsPre[i][sys]*BGscale[i][sys]);
            zjets_fit->SetBinContent(i+1, zjetsPre[i][sys]*BGscale[i][sys]);
            qcd_fit->SetBinContent(i+1,  qcdPre[i][sys]*BGscale[i][sys]);

        }

        resultsfile.cd();
    }

    if(writeFile ==true)
        resultsfile.Write();

    resultsfile.Close();


    cout << "N fit: " << endl;
    for(int i = 0; i < Nbins; i++) {
        cout << bins[i] << ": " << " = " << NfitVal[i][choice] << " +- " << NfitErr[i][choice] << endl;
    }

    cout << "partial xsects: " << endl;
    for(int i = 0; i < Nbins; i++) {
        cout << bins[i] << ": " << " = " << sigmaVal[i][choice] << " +- " << sigmaErr[i][choice] << endl;
//cout << bins[i] << ": " << " = " << madgraphVals[i] << endl;
    }

    cout << "normalised xsects: " << endl;
    for(int i = 0; i < Nbins; i++) {
        cout << bins[i] << ": " << " = " << sigmaVal[i][choice]/totXsect[choice] << endl;
    }

    cout << "normalised differential: " << endl;
    for(int i = 0; i < Nbins; i++) {
        cout << bins[i] << ": " << " = " << sigmaVal[i][choice]/(totXsect[choice]*width[i]) << endl;
    }
    cout << "cross section is:  " <<  totXsect[choice] << endl;

    //measured histo will have to put name of systematic in here to write into file
    TH1D *muon_part  = new TH1D("central", "", Nbins, xbins);  //muon

    //different generators
    TH1D *madgraph  = new TH1D("madgraph", "", Nbins, xbins);
    TH1D *mcatnlo  = new TH1D("mcatnlo", "", Nbins, xbins);
    TH1D *powheg  = new TH1D("powheg", "", Nbins, xbins);

    madgraph->SetLineColor(kRed);
    mcatnlo->SetLineColor(kBlue);
    powheg->SetLineColor(kGreen+2);
    for(int i = 0; i < Nbins; i++) {
        muon_part->SetBinContent(i+1,sigmaVal[i][choice]);
        muon_part->SetBinError(i+1, sigmaErr[i][choice]);

        madgraph->SetBinContent(i+1,madgraphVals[i][choice]);
        madgraph->SetBinError(i+1,0.0);
        mcatnlo->SetBinContent(i+1,mcatnloVals[i][choice]);
        mcatnlo->SetBinError(i+1,0.0);
        powheg->SetBinContent(i+1,powhegVals[i][choice]);
        powheg->SetBinError(i+1,0.0);
    }


    //do the plots
    TCanvas *c= new TCanvas("c","c",10,10,800,600);

    muon_part->SetMarkerStyle(20);
    muon_part->Draw("E");
    muon_part->SetMaximum(muon_part->GetBinContent(muon_part->GetMaximumBin())*1.5);
    muon_part->SetMinimum(0.);


    mcatnlo->Draw("same");
    powheg->Draw("same");
    madgraph->Draw("same");
    TLegend *tleg;
    tleg = new TLegend(0.6,0.75,0.85,0.9);
    tleg->SetTextSize(0.03);
    tleg->SetBorderSize(0);
    tleg->SetFillColor(10);

    tleg->AddEntry(muon_part  , "data '12'"      , "lep");
    tleg->AddEntry(madgraph  , "MadGraph"      , "l");
    tleg->AddEntry(mcatnlo  , "[email protected]"      , "l");
    tleg->AddEntry(powheg  , "POWHEG"      , "l");
    tleg->Draw();
    //titles
    muon_part->GetYaxis()->SetTitle("#partial #sigma [pb]");
    muon_part->GetYaxis()->SetTitleSize(0.05);
    muon_part->GetXaxis()->SetTitle(Xtitle);
    muon_part->GetXaxis()->SetTitleSize(0.05);


    TText* textPrelim = doPrelim(0.16,0.96);
    textPrelim->Draw();

    c->SaveAs("plots/Measurments/partialXsect"+Variable+".pdf");

    //normailise
    for(int i = 0; i < Nbins; i++) {

        muon_part->SetBinContent(i+1,sigmaVal[i][choice]/totXsect[choice]);
        muon_part->SetBinError(i+1,sigmaErr[i][choice]/totXsect[choice]);
//	muon_norm_diff->SetBinContent(i+1,sigmaVal[i]/(totXsect*width));

        madgraph->SetBinContent(i+1,madgraphVals[i][choice]/225.197);
        madgraph->SetBinError(i+1,0.0/225.197);
        mcatnlo->SetBinContent(i+1,mcatnloVals[i][choice]/225.197);
        mcatnlo->SetBinError(i+1,0.0/225.197);
        powheg->SetBinContent(i+1,powhegVals[i][choice]/225.197);
        powheg->SetBinError(i+1,0.0/225.197);

    }
    delete c;

    TCanvas *c2= new TCanvas("c2","c2",10,10,800,600);

    muon_part->SetMarkerStyle(20);

    muon_part->Draw("E");
    muon_part->SetMaximum(muon_part->GetBinContent(muon_part->GetMaximumBin())*1.5);


    mcatnlo->Draw("same");
    powheg->Draw("same");
    madgraph->Draw("same");

    tleg->Draw();

    //titles
    muon_part->GetYaxis()->SetTitle("#frac{1}{#sigma} #partial #sigma [pb GeV^{-1}]");
    muon_part->GetYaxis()->SetTitleSize(0.05);
    //muon_part->GetXaxis()->SetTitle(Xtitle);
    //muon_part->GetXaxis()->SetTitleSize(0.05);

    textPrelim->Draw();

    c2->SaveAs("plots/Measurments/partialXsectNorm"+Variable+".pdf");

    //normailise and differential
    for(int i = 0; i < Nbins; i++) {
        double width = muon_part->GetBinWidth(i+1);

        muon_part->SetBinContent(i+1,sigmaVal[i][choice]/(totXsect[choice]*width));
        muon_part->SetBinError(i+1,sigmaErr[i][choice]/(totXsect[choice]*width));

        madgraph->SetBinContent(i+1,madgraphVals[i][choice]/(225.197*width));
        madgraph->SetBinError(i+1,0.0/(225.197*width));
        mcatnlo->SetBinContent(i+1,mcatnloVals[i][choice]/(225.197*width));
        mcatnlo->SetBinError(i+1,0.0/(225.197*width));
        powheg->SetBinContent(i+1,powhegVals[i][choice]/(225.197*width));
        powheg->SetBinError(i+1,0.0/(225.197*width));
    }
    delete c2;

    TCanvas *c3= new TCanvas("c3","c3",10,10,800,600);

    muon_part->SetMarkerStyle(20);
    muon_part->Draw("E");
    muon_part->SetMaximum(muon_part->GetBinContent(muon_part->GetMaximumBin())*1.5);


    mcatnlo->Draw("same");
    powheg->Draw("same");
    madgraph->Draw("same");

    tleg->Draw();

    //titles
    muon_part->GetYaxis()->SetTitle("#frac{1}{#sigma} #frac{#partial #sigma}{#partial MET} 				[GeV^{-1}]");
    muon_part->GetYaxis()->SetTitleSize(0.05);
    //muon_part->GetXaxis()->SetTitle("MET [GeV]");
    //muon_part->GetXaxis()->SetTitleSize(0.05);

    textPrelim->Draw();

    c3->SaveAs("plots/Measurments/partialXsectNormDiff"+Variable+".pdf");
    delete c3;


}
Example #30
0
GenVBosonPlot(TString name, int rebin,float min = -1,float max =0, bool log=false){

  //  TCanvas* aCan = new TCanvas(name,name,0.6,0.6,0.8,0.8);

  TCanvas* aCan = new TCanvas(name);
  aCan->Divide(2,1);
  aCan->cd(1);
  if(log) aCan->SetLogy();
  // int rebin= 10;
  TFile* W = new TFile("results5/IC5Calo_WJets_madgraph.root");
  //W->ls();
  TDirectory* Wdir = ( TDirectory*) W->Get("GenVBoson200");
  Wdir->ls();
  TH1D* Wh = (TH1D*) Wdir->Get(name);
  Wh->Rebin(rebin);
  Wh->SetLineWidth(2);
  Wh->SetLineStyle(2);
  //  Wh->
  if(min>-.2)  Wh->GetXaxis()->SetRangeUser(min,max);
 
  Wh->DrawNormalized();
  //cout << Wh->GetMaximum() <<endl;
  Wh->GetXaxis()->SetRangeUser(0.00001,1);

  //  Wh->SetMaximum( Wh->GetMaximum()*1.75);


  TFile* Z = new TFile("results5/IC5Calo_Zinvisible_jets.root");
  //Z->ls();
  TDirectory* Zdir = ( TDirectory*) Z->Get("GenVBoson200");
  //  Zdir->ls();
  TH1D* Zh = (TH1D*) Zdir->Get(name);
  Zh->SetLineColor(kRed);
  Zh->SetLineWidth(2);
  Zh->SetLineStyle(2);

  Zh->Rebin(rebin);
  Zh->DrawNormalized("same");

  TFile* Ph = new TFile("results5/photon.root");
  Ph->ls();
  TDirectory* Phdir = ( TDirectory*) Ph->Get("GenVBoson200");
  // Phdir->ls();
  TH1D* Phh = (TH1D*) Phdir->Get(name);
  Phh->SetLineColor(kBlue);
  Phh->SetLineWidth(2);
  Phh->Rebin(rebin);
  Phh->DrawNormalized("same"); 

  TLegend* leg = new TLegend(0.5,0.5,0.7,0.7);
  leg->AddEntry(Zh,"Z","l" );
  leg->AddEntry(Wh,"W","l" );
  leg->AddEntry(Phh,"#gamma","l" );
  leg->Draw("same");

  aCan->cd(1);

  TH1D*  DivPhh = Phh->Clone();
  DivPhh->Divide(Zh);
  TH1D*  DivWh = Wh->Clone();
  DivWh->Divide(Zh);
  DivPhh->Draw();
DivWh->Draw("same");

}