double YZGetChisquare(){return (yzfitfunc->GetChisquare());};
void fitResolandScale(int collision = 2, int flvOpt = 0, int genOpt = 0){
/* const int kHIcentral = 0; // 0-30%
const int kHIperipheral = 1;//30-100%
const int kPP = 2;
const int kPA = 3;
const int kHI010 = 4; //0-10%
const int kHI1030 = 5; //10-30%
const int kHI3050 = 6;//30-50%
const int kHI50100 = 7;//50-100%
*/
// const int collision = 3;
TLegend *l1 = new TLegend(0.4365615,0.6445304,0.9577623,0.846736,NULL,"brNDC");
TCut centCut = "";
if ( (collision ==0) ) {
centCut = "cBin > 0 && cBin< 12";
easyLeg(l1,"Pb+Pb 0-30%");
}
else if ( (collision ==1) ){ // if it's pp
centCut = "cBin >=12";
easyLeg(l1,"Pb+Pb 30-100%");
}
else if (collision == 2 || collision == 3){ // pPb
centCut = "";
if (collision == 2) easyLeg(l1,"p+p");
else easyLeg(l1, "p+Pb");
}
else if ( (collision ==4) ){ //HI
centCut = "cBin > 0 && cBin < 4";
easyLeg(l1,"Pb+Pb 0-10%");
} else if ( (collision ==5) ){ //HI
centCut = "cBin >= 4 && cBin < 12";
easyLeg(l1,"Pb+Pb 10-30%");
} else if ( (collision ==6) ){ //HI
centCut = "cBin >= 12 && cBin < 20";
easyLeg(l1,"Pb+Pb 30-50%");
} else if ( (collision ==7) ){ //HI
centCut = "cBin >= 20";
easyLeg(l1,"Pb+Pb 50-100%");
}
//
TH1::SetDefaultSumw2();
// gStyle->SetOptFit(0);
gStyle -> SetOptStat(0);
// gStyle -> SetTitleYOffset(2.35);
gStyle -> SetTitleYSize(0.04);
TCut partonCut = "";
if (flvOpt ==0 ) partonCut = "";
else if (flvOpt == 1 ) partonCut = "refPartonFlv == 21";
else if (flvOpt == 2 ) partonCut = "abs(refPartonFlv) < 21";
else partonCut = "refPartonFlv < -200";
const int nPtBin = 12;
//const int nPtBin = 17;
//double ptBin[nPtBin+1] = {30.0, 40.0, 50.0, 80.0, 9999.0};
//double AvePtBin[nPtBin+1] = { 35.0, 45.0, 65.0, 100.0};
double ptBin[nPtBin+1];
double AvePtBin[nPtBin];
ptBin[0] = 30.0;
ptBin[1] = 40.0;
ptBin[2] = 50.0;
ptBin[3] = 60.0;
ptBin[4] = 70.0;
ptBin[5] = 80.0;
ptBin[6] = 90.0;
ptBin[7] = 100.0;
ptBin[8] = 120.0;
ptBin[9] = 140.0;
ptBin[10] = 160.0;
ptBin[11] = 180.0;
ptBin[12] = 200.0;
/*
for(int i=0;i<=nPtBin;i++){
ptBin[i] = 30.0+i*10.0;
}
*/
for(int i=0;i<nPtBin;i++){
AvePtBin[i] = (ptBin[i+1]+ptBin[i])/2.0;
}
// const int nCentBinPa = 3;
// double centBinPa[nCentBinPa+1] = {0,20,30,100};
//
// fake rate
//
int nJetmax = 100;
float refPt[nJetmax], pt[nJetmax], eta[nJetmax], dphi[nJetmax];
int nJet, cBin, refPartonFlv[nJetmax];
EvtSel evtImb;
TBranch *b_evt;
multiTreeUtil* yJet = new multiTreeUtil();
//:PbPb
if(collision ==1 || collision == 0 || collision == 4 || collision == 5 || collision == 6|| collision == 7){
yJet -> addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_qcdAllPhoton30to50_genPhotonPtCut40_allCent.root", "yJet", "",32796./32796);
yJet -> addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_qcdAllPhoton50to80_genPhotonPtCut40_allCent.root", "yJet", "",21470./53876);
yJet -> addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_qcdAllPhoton80to9999_genPhotonPtCut40_allCent.root", "yJet", "",6462./58781);
} else if (collision ==3){
// pA
yJet->addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_PA2013_pyquen_allQCDPhoton30to50_forestv85.root", "yJet","", 56669./50385);
yJet->addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_PA2013_pyquen_allQCDPhoton50to80_forestv85.root", "yJet","", 41906./114136);
yJet->addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_PA2013_pyquen_allQCDPhoton80to120_forestv85.root", "yJet","",12044./103562);
yJet->addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_PA2013_pyquen_allQCDPhoton120to9999_forestv85.root", "yJet","", 4481./151511);
} else if (collision ==2){
//pp
yJet->addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_merged_allQCDPhoton30to50_genPhotonPtCut30_CMSSW538HIp2.root", "yJet", "",29329. / 29329.);
yJet->addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_merged_allQCDPhoton50to80_genPhotonPtCut30_CMSSW538HIp2.root", "yJet", "",8098. / 87988.);
yJet->addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_merged_allQCDPhoton80to120_genPhotonPtCut30_CMSSW538HIp2.root", "yJet", "",1680. / 96756.);
yJet->addFile("/home/jazzitup/forestFiles/yskimmedFiles/yskim_merged_allQCDPhoton120to9999_genPhotonPtCut30_CMSSW538HIp2.root", "yJet", "", 438. / 90972.);
}
yJet -> AddFriend("tgj");
yJet->AddFriend("yPhotonTree");
TCanvas* c4 = new TCanvas("c4","",400,800);
c4->Divide(1,2);
c4->cd(1);
TH1D* hpt1 = new TH1D("hpt1",";p_{T}^{RECO};Entries",20,0,200);
TH1D* hpt0 = (TH1D*)hpt1->Clone("hpt2");
TH1D* hpt2 = (TH1D*)hpt1->Clone("hpt2");
TH1D* hpt3 = (TH1D*)hpt1->Clone("hpt3");
yJet -> Draw2(hpt0, "refPt", Form(" photonEt>40 && genPhotonEt> 30 && abs(genMomId)<=22 && (abs(eta) < 1.6) && (dphi > 7*3.141592/8.0) "),"");
yJet -> Draw2(hpt1, "refPt", Form(" photonEt>40 && genPhotonEt> 30 && abs(genMomId)<=22 && (abs(eta) < 1.6) && (dphi > 7*3.141592/8.0) && refPartonFlv == 21"),"");
yJet -> Draw2(hpt2, "refPt", Form(" photonEt>40 && genPhotonEt> 30 && abs(genMomId)<=22 && (abs(eta) < 1.6) && (dphi > 7*3.141592/8.0) && abs(refPartonFlv)<21 "),"");
yJet -> Draw2(hpt3, "refPt", Form(" photonEt>40 && genPhotonEt> 30 && abs(genMomId)<=22 && (abs(eta) < 1.6) && (dphi > 7*3.141592/8.0) && refPartonFlv < -200"),"");
handsomeTH1(hpt0,1);
handsomeTH1(hpt1,1);
handsomeTH1(hpt2,2);
handsomeTH1(hpt3,4);
hpt0->GetYaxis()->SetTitleOffset(1.8);
hpt0->DrawCopy("hist");
hpt1->DrawCopy("same");
hpt2->DrawCopy("same");
hpt3->DrawCopy("same");
jumSun(30,0,30,7400,2);
c4->cd(2);
hpt1->Divide(hpt0);
hpt2->Divide(hpt0);
hpt3->Divide(hpt0);
hpt1->SetAxisRange(0,1,"Y");
hpt1->SetYTitle("Ratio");
hpt1->DrawCopy();
hpt2->DrawCopy("same");
hpt3->DrawCopy("same");
jumSun(30,0,30,1,2);
// return;
// pt spectrum
// TCanvas* c1= new TCanvas("c1", "", 500,500);
// TH1D* hptHat = new TH1D("hptHat",";pt hat;Entries",200,0,200);
// yJet->Draw3( hptHat, "yPhotonTree.ptHat"," photonEt>40 && genPhotonEt> 30 && abs(genMomId)<=22","");
//yJet->Draw3( hptHat, "yPhotonTree.pt","","");
// return;
// Energy Scale
TCanvas* c2 = new TCanvas("c2", "pt/refPt distribution", 1200, 900);
TCanvas* ccc = new TCanvas("ccc", "pt/refpt 30-40GeV", 400, 400);
makeMultiPanelCanvas(c2,5,4,0.0,0.0,0.2,0.15,0.02);
TH1D* Escale[nCentBinPa+5][nPtBin];
double mean[nCentBinPa+5][nPtBin], var[nCentBinPa+5][nPtBin], resol[nCentBinPa+5][nPtBin], resolVar[nCentBinPa+5][nPtBin];
int icent =1;
// for(int icent=1; icent <= nCentBinPa ; icent++){
for(int i=0; i < nPtBin ; i++){
// c2 -> cd((icent-1)*4+i+1);
c2 -> cd(i+1);
Escale[icent][i] = new TH1D(Form("Escale%d_%d",icent, i) , " ; p_{T}^{RECO}/p_{T}^{GEN}", 50, 0, 2);
if ( genOpt == 0 ) {
yJet -> Draw2(Escale[icent][i], "pt/refPt", centCut && partonCut && Form(" (abs(eta) < 1.6) && (dphi > 7*3.141592/8.0) && (refPt >= %d && refPt < %d)", (int)ptBin[i], (int)ptBin[i+1]),"");
}
else if (genOpt == 1) {
yJet -> Draw2(Escale[icent][i], "pt/refPt", centCut && partonCut && Form(" (abs(eta) < 1.6) && (dphi > 7*3.141592/8.0) && (pt >= %d && pt < %d) ", (int)ptBin[i], (int)ptBin[i+1]),"");
}
// Escale[icent][i] -> Draw();
TF1* ff = cleverGaus(Escale[icent][i]);
gPad->SetLogy();
mean[icent][i] = ff->GetParameter(1);
var[icent][i] = ff->GetParError(1);
resol[icent][i] = ff->GetParameter(2);
resolVar[icent][i] = ff->GetParError(2);
float dx1;
// ((icent==1)||(icent==4))? dx1=0.15 : dx1=0 ;
dx1=0;
// if ( icent == nCentBinPa )
// drawText(Form("E_{T}^{HF|#eta|>4} > %dGeV, ", (int)centBinPa[icent-1]), 0.12+dx1,0.929118,1,15);//yeonju 130805
//else
// drawText(Form("%dGeV < E_{T}^{HF|#eta|>4} < %dGeV, ", (int)centBinPa[icent-1], (int)centBinPa[icent]), 0.12+dx1,0.929118,1,15);
if ( i+1 == nPtBin )
drawText(Form("p_{T}^{GEN Jet} > %dGeV, ", (int)ptBin[i]), 0.17+dx1,0.84,1,15);//yeonju 130823
else
drawText(Form("%dGeV < p_{T}^{GEN Jet} < %dGeV, ", (int)ptBin[i], (int)ptBin[i+1]), 0.17+dx1,0.84,1,12);//yeonju 130823
// TLegend *l1 = new TLegend(0.6365615,0.6445304,0.9577623,0.846736,NULL,"brNDC");
// easyLeg(l1,"p+Pb 5.02TeV");
// l1->AddEntry(hxjgNorm[kPADATA][icent + kPADATA*50][j],"pPb ","p");
// if ( icent==1 && j==1) l1->Draw();
}
// }
c2 -> Update();
ccc -> Divide(2,1);
ccc -> cd(1);
Escale[1][0]->Draw();
ccc -> cd(2);
Escale[1][1]->Draw();
//
// Energy Scale
//
TCanvas *c3 = new TCanvas("c3", "Energy Scale vs. jet pt",147,37,930,465);
c3->Divide(2,1);
c3->cd(1);
double bin[nPtBin+1];
for(int ibin=0; ibin<nPtBin+1; ibin++){
bin[ibin]=ptBin[ibin];
}
TH1D* hscale = new TH1D("hscale", ";JetP_{T}^{GEN} (GeV); Energy Scale ", nPtBin, bin);
l1 -> Draw();
handsomeTH1(hscale,1);
hscale -> SetAxisRange(0.9, 1.15, "Y");
hscale -> Draw();
jumSun(30,1,200,1);
TLegend *l3=new TLegend(0,0,0.4490239,0.08695652,NULL,"brNDC");
l3->SetTextFont(42);
l3->SetTextSize(0.04);
l3->SetFillColor(0);
l3->SetLineColor(0);
for(int i=0; i < nPtBin ; i++){
hscale -> SetBinContent(i+1, mean[icent][i]);
hscale -> SetBinError(i+1, var[icent][i]);
hscale -> SetMarkerStyle(20);
hscale -> SetMarkerSize(1);
hscale -> Draw("same p");
}
TF1 *fs = new TF1("fs", myFunc, 30, 200, 3);
fs -> SetParameters(0.9,0.8,0.001);
fs -> SetParNames("scale_C", "scale_S", "scale_N");
double params[3];
hscale -> Fit("fs", "RLL");
fs->GetParameters(params);
cout << " scale C : " << params[0] << ", S : " << params[1] << ", N : : " << params[2] << endl;
// cout << " N : " << param[0] << endl;
fs->Draw("same");
//
// Energy Resolution
//
c3->cd(2);
TH1D* hresol = new TH1D("hresol", ";JetP_{T} (GeV); Energy Resolution ", nPtBin, bin);
handsomeTH1(hresol,1);
hresol -> SetAxisRange(0.0, 0.3, "Y");
hresol->GetYaxis()->CenterTitle();
hresol -> Draw();
jumSun(30,0.0,30,0.3,2);
TLegend *l_resol=new TLegend(0.40,0.20,0.85,0.42);
l_resol->SetTextFont(42);
l_resol->SetTextSize(0.04);
l_resol->SetFillColor(0);
l_resol->SetLineColor(0);
for(int i=0; i < nPtBin ; i++){
hresol -> SetBinContent(i+1, resol[icent][i]);
hresol -> SetBinError(i+1, resolVar[icent][i]);
hresol -> SetMarkerStyle(20);
hresol -> SetMarkerSize(1);
hresol -> Draw("same p");
}
TF1 *f;
// if(collision==2){
f = new TF1("f", myFunc3, 30, 200, 3);
f -> SetParameters(0.03, 0.8, 0.01);
f -> SetParNames("C", "S", "N");
// } else {
// f = new TF1("f", myFunc3, 30, 200, 3);
// f -> SetParameters(0.041, 0.956,0.001);
// f -> SetParNames("N");
// }
double param[3];
hresol -> Fit("f", "RLL");
f->GetParameters(param);
// cout << " resol_N : " << param[0]<< endl;
// if(collision==2) cout << " resol C : " << param[0] << ", S : " << param[1] << ", N : : " << param[2] << endl;
cout << " resol C : " << param[0] << ", S : " << param[1] << ", N : : " << param[2] << endl;
// else cout << " N : " << param[0] << endl;
f->Draw("same");
l1 -> Draw();
// l_resol->Draw();
//flvOpt = 0, int genOpt
// c1 -> SaveAs(".gif");
//c2 -> SaveAs(Form("./graph/CSnotFix_scale_distribution_collision%d.pdf",collision));
//c3 -> SaveAs(Form("./graph/CSnotFix_scale_resolution_fit_collision%d.pdf",collision));
// c_fake -> SaveAs(".gif");
}
void checkRsnPIDqa(TString filename, TString foldername, Bool_t savePng,
TString plotTPCpi, TString plotTPCka, TString plotTPCpro,
TString plotTTOFpi, TString plotTOFka, TString plotTOFpro)
{
//Open input file
TFile * fin = TFile::Open(filename.Data());
if (!fin) return 0x0;
//Access output of specific wagon
TList * list = (TList*) fin->Get(foldername.Data());
if (!list) return 0x0;
//Set range for fit
Float_t RangeFitMomMin = 0.1; //range in momentum where to check the mean and pull
Float_t RangeFitMomMax = 2.0;
Int_t xbinFitMin = 0;
Int_t xbinFitMax = -1;
Float_t RangeFitNsigmaPIDmin = -2.0; //range in Nsigma where the fit is to be performed
Float_t RangeFitNsigmaPIDmax = 2.0;
//Set range for visualisation
Float_t RangeShowTPC[2] = {0.1, 2.0};
Float_t RangeShowTOF[2] = {0.25, 2.0};
//--------------------------
// TPC PID Nsigma
// fit with simple gaussian
//--------------------------
//Gaussian function
TF1 *fGaus = new TF1("f","gaus", -7.0, 7.0);
//--- pions
TH2F * hTPCsigmaPi = (TH2F*)list->FindObject(plotTPCpi.Data());
hTPCsigmaPi->RebinX(2);
hTPCsigmaPi->SetTitle("TPC Pions");
MakeUpHisto(hTPCsigmaPi,"p_{TPC} (GeV/c)", "N#sigma_{TPC}", 1, kBlack, 2);
hTPCsigmaPi->GetYaxis()->SetRangeUser(-5.1,5.1);
hTPCsigmaPi->GetXaxis()->SetRangeUser(RangeShowTPC[0], RangeShowTPC[1]);
xbinFitMin = hTPCsigmaPi->GetXaxis()->FindBin(RangeFitMomMin);
xbinFitMax = hTPCsigmaPi->GetXaxis()->FindBin(RangeFitMomMax);
hTPCsigmaPi->FitSlicesY(fGaus, xbinFitMin, xbinFitMax );
TH1D * hTPCsigmaPi_mean = ((TH1D*)gDirectory->FindObject(Form("%s_1", plotTPCpi.Data())))->Clone("hNsigmaTPCpi_mean");
TH1D * hTPCsigmaPi_pull = ((TH1D*)gDirectory->FindObject(Form("%s_2", plotTPCpi.Data())))->Clone("hNsigmaTPCpi_pull");
MakeUpHisto(hTPCsigmaPi_mean, "", "", 1, kBlack, 2);
MakeUpHisto(hTPCsigmaPi_pull, "", "", 1, kRed+2, 2);
//--- kaons
TH2F * hTPCsigmaKa = (TH2F*)list->FindObject(plotTPCka.Data());
hTPCsigmaKa->RebinX(2);
hTPCsigmaKa->SetTitle("TPC Kaons");
hTPCsigmaKa->GetYaxis()->SetRangeUser(-5.1,5.1);
hTPCsigmaKa->GetXaxis()->SetRangeUser(RangeShowTPC[0], RangeShowTPC[1]);
hTPCsigmaKa->FitSlicesY(fGaus, xbinFitMin, xbinFitMax );
MakeUpHisto(hTPCsigmaKa,"p_{TPC} (GeV/c)", "N#sigma_{TPC}", 1, kBlack, 2);
TH1D * hTPCsigmaKa_mean = ((TH1D*)gDirectory->FindObject(Form("%s_1", plotTPCka.Data())))->Clone("hNsigmaTPCka_mean");
TH1D * hTPCsigmaKa_pull = ((TH1D*)gDirectory->FindObject(Form("%s_2", plotTPCka.Data())))->Clone("hNsigmaTPCka_pull");
MakeUpHisto(hTPCsigmaKa_mean, "", "", 1, kBlack, 2);
MakeUpHisto(hTPCsigmaKa_pull, "", "", 1, kRed+2, 2);
//--- protons
TH2F * hTPCsigmaPro = (TH2F*)list->FindObject(plotTPCpro.Data());
hTPCsigmaPro->RebinX(2);
hTPCsigmaPro->SetTitle("TPC Protons");
MakeUpHisto(hTPCsigmaPro,"p_{TPC} (GeV/c)", "N#sigma_{TPC}", 1, kBlack, 2);
hTPCsigmaPro->GetYaxis()->SetRangeUser(-5.1,5.1);
hTPCsigmaPro->GetXaxis()->SetRangeUser(RangeShowTPC[0], RangeShowTPC[1]);
hTPCsigmaPro->FitSlicesY(fGaus, xbinFitMin, xbinFitMax );
TH1D * hTPCsigmaPro_mean = ((TH1D*)gDirectory->FindObject(Form("%s_1", plotTPCpro.Data())))->Clone("hNsigmaTPCpro_mean");
TH1D * hTPCsigmaPro_pull = ((TH1D*)gDirectory->FindObject(Form("%s_2", plotTPCpro.Data())))->Clone("hNsigmaTPCpro_pull");
MakeUpHisto(hTPCsigmaPro_mean, "", "", 1, kBlack, 2);
MakeUpHisto(hTPCsigmaPro_pull, "", "", 1, kRed+2, 2);
//--- plot TPC
TLine *l11=new TLine(RangeShowTPC[0],0.,RangeShowTPC[1],0.); l11->SetLineWidth(1); l11->SetLineStyle(7);
TLine *l12=new TLine(RangeShowTPC[0],1.,RangeShowTPC[1],1.); l12->SetLineWidth(1); l12->SetLineStyle(7);
gStyle->SetOptStat(0);
TCanvas *cPidPerformance4 = new TCanvas("cPIDperformance4","TPC PID",1200,500);
cPidPerformance4->Divide(3,1);
cPidPerformance4->cd(1);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTPCsigmaPi->DrawCopy("colz");
hTPCsigmaPi_mean->DrawCopy("same");
hTPCsigmaPi_pull->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
cPidPerformance4->cd(2);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTPCsigmaKa->DrawCopy("colz");
hTPCsigmaKa_mean->DrawCopy("same");
hTPCsigmaKa_pull->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
cPidPerformance4->cd(3);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTPCsigmaPro->DrawCopy("colz");
hTPCsigmaPro_mean->DrawCopy("same");
hTPCsigmaPro_pull->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
TLegend * pidLegTPC = new TLegend(0.15,0.8,0.88,0.88);
pidLegTPC->SetBorderSize(0); pidLegTPC->SetFillStyle(1001); pidLegTPC->SetFillColor(kWhite);
pidLegTPC->SetTextSize(0.04); pidLegTPC->SetNColumns(2);
pidLegTPC->AddEntry(hTPCsigmaPro_mean,"Mean","lp");
pidLegTPC->AddEntry(hTPCsigmaPro_pull,Form("#sigma, Gaus fit (%2.1f,%2.1f)",RangeFitNsigmaPIDmin,RangeFitNsigmaPIDmax),"lp");
pidLegTPC->Draw("same");
if (savePng) cPidPerformance4->SaveAs("RsnQA_TPC_Nsigma.png");
//----------------------------------------------------
// TOF
// fit with signal model = gaussian + exponential tail
//----------------------------------------------------
//Signal model for TOF signal = gaus + exp tail
const Int_t npars = 6;
TF1 *fSignalModel = new TF1("fSignalModel", TOFsignal, -7.0, 7.0, npars);
fSignalModel->SetTitle("TOF Signal");
fSignalModel->SetParameter(0, 1.);
fSignalModel->SetParameter(1, 0.);
fSignalModel->SetParLimits(1, -2., 1.);
fSignalModel->SetParameter(2, 1.);
fSignalModel->SetParLimits(2, 0.5, 2.);
fSignalModel->SetParameter(3, 1.);
fSignalModel->SetParLimits(3, 0.5, 1.5);
fSignalModel->SetParameter(4, 1.);
fSignalModel->SetParLimits(4, 0., 1.e8);
fSignalModel->SetParameter(5, 0.);
fSignalModel->SetParLimits(5, -10., 10.);
fSignalModel->SetNpx(2000);
fSignalModel->SetParNames("Norm", "Mean", "Sigma", "Tail", "Shift", "Slope"/*, "Square"*/);
fSignalModel->SetLineColor(kRed+1);
//results
TObjArray *results[3];
for(Int_t i = 0; i < 3; i++){
results[i] = new TObjArray(10);
}
TH1D * par[3][npars];
//--- pions
TH2F * hTOFsigmaPi = (TH2F*)list->FindObject(plotTOFpi.Data());
hTOFsigmaPi->SetTitle("TOF Pions");
hTOFsigmaPi->RebinX(2);
MakeUpHisto(hTOFsigmaPi,"p (GeV/c)", "N#sigma_{TOF}", 1, kBlack, 2);
hTOFsigmaPi->GetYaxis()->SetRangeUser(-5.1,5.1);
hTOFsigmaPi->GetXaxis()->SetRangeUser(RangeShowTOF[0], RangeShowTOF[1]);
fSignalModel->SetParLimits(4, 0., hTOFsigmaPi->GetMaximum()*0.5);
fSignalModel->SetParLimits(0, 0., hTOFsigmaPi->GetMaximum()*1.2);
hTOFsigmaPi->FitSlicesY(fSignalModel, xbinFitMin, xbinFitMax, 0, "QR", results[0] );
for(Int_t cc = 0; cc < npars ; cc++) {
par[0][cc] = (TH1D*)gDirectory->FindObject(Form("%s_%i", plotTOFpi.Data(), cc));
}
MakeUpHisto(par[0][1], "", "", 1, kBlue, 2);
MakeUpHisto(par[0][2], "", "", 1, kMagenta+2, 2);
//--- KAONS
TH2F * hTOFsigmaKa = (TH2F*)list->FindObject(plotTOFka.Data());
hTOFsigmaKa->SetTitle("TOF Kaons");
hTOFsigmaKa->RebinX(2);
MakeUpHisto(hTOFsigmaKa,"p (GeV/c)", "N#sigma_{TOF}", 1, kBlack, 2);
hTOFsigmaKa->GetYaxis()->SetRangeUser(-5.1,5.1);
hTOFsigmaKa->GetXaxis()->SetRangeUser(RangeShowTOF[0], RangeShowTOF[1]);
fSignalModel->SetParLimits(4, 0., hTOFsigmaKa->GetMaximum()*0.5);
fSignalModel->SetParLimits(0, 0., hTOFsigmaKa->GetMaximum()*1.2);
hTOFsigmaKa->FitSlicesY(fSignalModel, xbinFitMin, xbinFitMax, 0, "QR", results[0] );
for(Int_t cc = 0; cc < npars ; cc++) {
par[1][cc] = (TH1D*)gDirectory->FindObject(Form("%s_%i", plotTOFka.Data(), cc));
}
MakeUpHisto(par[1][1], "", "", 1, kBlue, 2);
MakeUpHisto(par[1][2], "", "", 1, kMagenta+2, 2);
//--- protons
TH2F * hTOFsigmaPro = (TH2F*)list->FindObject(plotTOFpro.Data());
hTOFsigmaPro->SetTitle("TOF Protons");
hTOFsigmaPro->RebinX(2);
MakeUpHisto(hTOFsigmaPro,"p (GeV/c)", "N#sigma_{TOF}", 1, kBlack, 2);
hTOFsigmaPro->GetYaxis()->SetRangeUser(-5.1,5.1);
hTOFsigmaPro->GetXaxis()->SetRangeUser(RangeShowTOF[0], RangeShowTOF[1]);
fSignalModel->SetParLimits(4, 0., hTOFsigmaPro->GetMaximum()*0.5);
fSignalModel->SetParLimits(0, 0., hTOFsigmaPro->GetMaximum()*1.2);
hTOFsigmaPro->FitSlicesY(fSignalModel, xbinFitMin, xbinFitMax, 0, "QR", results[0] );
for(Int_t cc = 0; cc < npars ; cc++) {
par[2][cc] = (TH1D*)gDirectory->FindObject(Form("%s_%i", plotTOFpro.Data(), cc));
}
MakeUpHisto(par[2][1], "", "", 1, kBlue, 2);
MakeUpHisto(par[2][2], "", "", 1, kMagenta+2, 2);
//--- plot TOF
gStyle->SetOptStat(0);
TCanvas *cPidPerformance3 = new TCanvas("cPidPerformance3","TOF PID performance",1200,500);
cPidPerformance3->Divide(3,1);
cPidPerformance3->cd(1);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTOFsigmaPi->DrawCopy("colz");
if(par[0][1]) par[0][1]->DrawCopy("same");
if(par[0][2]) par[0][2]->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
cPidPerformance3->cd(2);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTOFsigmaKa->DrawCopy("colz");
if(par[1][1]) par[1][1]->DrawCopy("same");
if(par[1][2]) par[1][2]->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
cPidPerformance3->cd(3);
gPad->SetLogz(); gPad->SetLogx(); gPad->SetGridx(); gPad->SetGridy();
hTOFsigmaPro->DrawCopy("colz");
if(par[2][1]) par[2][1]->DrawCopy("same");
if(par[2][2]) par[2][2]->DrawCopy("same");
l11->Draw("same"); l12->Draw("same");
TLegend * pidLegTOF = new TLegend(0.15,0.8,0.88,0.88);
pidLegTOF->SetBorderSize(0); pidLegTOF->SetFillStyle(1001); pidLegTOF->SetFillColor(kWhite);
pidLegTOF->SetTextSize(0.04); pidLegTOF->SetNColumns(2);
pidLegTOF->AddEntry(par[0][1],"Mean","lp");
pidLegTOF->AddEntry(par[0][2], Form("#sigma, Gaus+Tail fit (%2.1f,%2.1f)",RangeFitNsigmaPIDmin, RangeFitNsigmaPIDmax),"lp");
pidLegTOF->Draw("same");
if (savePng) cPidPerformance3->Print("RsnQA_TOF_Nsigma.png");
return;
}
//_________________________________________________________________________________________
Int_t checkPullTree(TString pathTree, TString pathNameThetaMap, TString pathNameSigmaMap,
TString mapSuffix, const Int_t collType /*0: pp, 1: pPb, 2: PbPb*/, const Bool_t plotPull = kTRUE,
const Double_t downScaleFactor = 1,
TString pathNameSplinesFile = "", TString prSplinesName = "",
TString fileNameTree = "bhess_PIDetaTree.root", TString treeName = "fTree")
{
const Bool_t isNonPP = collType != 0;
const Double_t massProton = AliPID::ParticleMass(AliPID::kProton);
Bool_t recalculateExpecteddEdx = pathNameSplinesFile != "";
TFile* f = 0x0;
f = TFile::Open(Form("%s/%s", pathTree.Data(), fileNameTree.Data()));
if (!f) {
std::cout << "Failed to open tree file \"" << Form("%s/%s", pathTree.Data(), fileNameTree.Data()) << "\"!" << std::endl;
return -1;
}
// Extract the data Tree
TTree* tree = dynamic_cast<TTree*>(f->Get(treeName.Data()));
if (!tree) {
std::cout << "Failed to load data tree!" << std::endl;
return -1;
}
// Extract the splines, if desired
TSpline3* splPr = 0x0;
if (recalculateExpecteddEdx) {
std::cout << "Loading splines to recalculate expected dEdx!" << std::endl << std::endl;
TFile* fSpl = TFile::Open(pathNameSplinesFile.Data());
if (!fSpl) {
std::cout << "Failed to open spline file \"" << pathNameSplinesFile.Data() << "\"!" << std::endl;
return 0x0;
}
TObjArray* TPCPIDResponse = (TObjArray*)fSpl->Get("TPCPIDResponse");
if (!TPCPIDResponse) {
splPr = (TSpline3*)fSpl->Get(prSplinesName.Data());
// If splines are in file directly, without TPCPIDResponse object, try to load them
if (!splPr) {
std::cout << "Failed to load object array from spline file \"" << pathNameSplinesFile.Data() << "\"!" << std::endl;
return 0x0;
}
}
else {
splPr = (TSpline3*)TPCPIDResponse->FindObject(prSplinesName.Data());
if (!splPr) {
std::cout << "Failed to load splines from file \"" << pathNameSplinesFile.Data() << "\"!" << std::endl;
return 0x0;
}
}
}
else
std::cout << "Taking dEdxExpected from Tree..." << std::endl << std::endl;
// Extract the correction maps
TFile* fMap = TFile::Open(pathNameThetaMap.Data());
if (!fMap) {
std::cout << "Failed to open thetaMap file \"" << pathNameThetaMap.Data() << "\"! Will not additionally correct data...." << std::endl;
}
TH2D* hMap = 0x0;
if (fMap) {
hMap = dynamic_cast<TH2D*>(fMap->Get(Form("hRefined%s", mapSuffix.Data())));
if (!hMap) {
std::cout << "Failed to load theta map!" << std::endl;
return -1;
}
}
TFile* fSigmaMap = TFile::Open(pathNameSigmaMap.Data());
if (!fSigmaMap) {
std::cout << "Failed to open simgaMap file \"" << pathNameSigmaMap.Data() << "\"!" << std::endl;
return -1;
}
TH2D* hThetaMapSigmaPar1 = dynamic_cast<TH2D*>(fSigmaMap->Get("hThetaMapSigmaPar1"));
if (!hThetaMapSigmaPar1) {
std::cout << "Failed to load sigma map for par 1!" << std::endl;
return -1;
}
Double_t c0 = -1;
TNamed* c0Info = dynamic_cast<TNamed*>(fSigmaMap->Get("c0"));
if (!c0Info) {
std::cout << "Failed to extract c0 from file with sigma map!" << std::endl;
return -1;
}
TString c0String = c0Info->GetTitle();
c0 = c0String.Atof();
printf("Loaded parameter 0 for sigma: %f\n\n", c0);
if (plotPull)
std::cout << "Plotting pull..." << std::endl << std::endl;
else
std::cout << "Plotting delta'..." << std::endl << std::endl;
Long64_t nTreeEntries = tree->GetEntriesFast();
Double_t dEdx = 0.; // Measured dE/dx
Double_t dEdxExpected = 0.; // Expected dE/dx according to parametrisation
Double_t tanTheta = 0.; // Tangens of (local) theta at TPC inner wall
Double_t pTPC = 0.; // Momentum at TPC inner wall
UShort_t tpcSignalN = 0; // Number of clusters used for dEdx
UChar_t pidType = 0;
Int_t fMultiplicity = 0;
//Double_t phiPrime = 0;
// Only activate the branches of interest to save processing time
tree->SetBranchStatus("*", 0); // Disable all branches
tree->SetBranchStatus("pTPC", 1);
tree->SetBranchStatus("dEdx", 1);
tree->SetBranchStatus("dEdxExpected", 1);
tree->SetBranchStatus("tanTheta", 1);
tree->SetBranchStatus("tpcSignalN", 1);
tree->SetBranchStatus("pidType", 1);
//tree->SetBranchStatus("phiPrime", 1);
if (isNonPP)
tree->SetBranchStatus("fMultiplicity", 1);
tree->SetBranchAddress("dEdx", &dEdx);
tree->SetBranchAddress("dEdxExpected", &dEdxExpected);
tree->SetBranchAddress("tanTheta", &tanTheta);
tree->SetBranchAddress("tpcSignalN", &tpcSignalN);
tree->SetBranchAddress("pTPC", &pTPC);
tree->SetBranchAddress("pidType", &pidType);
//tree->SetBranchAddress("phiPrime", &phiPrime);
if (isNonPP)
tree->SetBranchAddress("fMultiplicity", &fMultiplicity);
// Output file
TDatime daTime;
TString savefileName = Form("%s%s_checkPullSigma_%04d_%02d_%02d__%02d_%02d.root", fileNameTree.ReplaceAll(".root", "").Data(),
recalculateExpecteddEdx ? "_recalcdEdx" : "",
daTime.GetYear(), daTime.GetMonth(), daTime.GetDay(), daTime.GetHour(), daTime.GetMinute());
TFile* fSave = TFile::Open(Form("%s/%s", pathTree.Data(), savefileName.Data()), "recreate");
if (!fSave) {
std::cout << "Failed to open save file \"" << Form("%s/%s", pathTree.Data(), savefileName.Data()) << "\"!" << std::endl;
return -1;
}
const Double_t pBoundLow = 0.1;
const Double_t pBoundUp = 5;
const Int_t nBins1 = TMath::Ceil(180 / downScaleFactor);
const Int_t nBins2 = TMath::Ceil(100 / downScaleFactor);
const Int_t nBins3 = TMath::Ceil(60 / downScaleFactor);
const Int_t nPbinsForMap = nBins1 + nBins2 + nBins3;
Double_t binsPforMap[nPbinsForMap + 1];
Double_t binWidth1 = (1.0 - pBoundLow) / nBins1;
Double_t binWidth2 = (2.0 - 1.0 ) / nBins2;
Double_t binWidth3 = (pBoundUp - 2.0) / nBins3;
for (Int_t i = 0; i < nBins1; i++) {
binsPforMap[i] = pBoundLow + i * binWidth1;
}
for (Int_t i = nBins1, j = 0; i < nBins1 + nBins2; i++, j++) {
binsPforMap[i] = 1.0 + j * binWidth2;
}
for (Int_t i = nBins1 + nBins2, j = 0; i < nBins1 + nBins2 + nBins3; i++, j++) {
binsPforMap[i] = 2.0 + j * binWidth3;
}
binsPforMap[nPbinsForMap] = pBoundUp;
TH2D* hPull = new TH2D("hPull", "Pull vs. p_{TPC} integrated over tan(#Theta);p_{TPC} (GeV/c);Pull", nPbinsForMap, binsPforMap,
plotPull ? 120 : 240, plotPull ? -6 : -0.6, plotPull ? 6 : 0.6);
TH2D* hPullAdditionalCorr = (TH2D*)hPull->Clone("hPullAdditionalCorr");
hPullAdditionalCorr->SetTitle("Pull vs. p_{TPC} integrated over tan(#Theta) with additional dEdx correction w.r.t. tan(#Theta)");
/*
const Int_t nThetaHistos = 3;
TH2D* hPullTheta[nThetaHistos];
TH2D* hPullAdditionalCorrTheta[nThetaHistos];
Double_t tThetaLow[nThetaHistos] = { 0.0, 0.4, 0.9 };
Double_t tThetaHigh[nThetaHistos] = { 0.1, 0.5, 1.0 };
*/
const Int_t nThetaHistos = 10;
TH2D* hPullTheta[nThetaHistos];
TH2D* hPullAdditionalCorrTheta[nThetaHistos];
Double_t tThetaLow[nThetaHistos] = { 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 };
Double_t tThetaHigh[nThetaHistos] = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 };
for (Int_t i = 0; i < nThetaHistos; i++) {
hPullTheta[i] = new TH2D(Form("hPullTheta_%d", i),
Form("Pull vs. p_{TPC} for %.2f <= |tan(#Theta)| < %.2f;p_{TPC} (GeV/c);Pull", tThetaLow[i], tThetaHigh[i]),
nPbinsForMap, binsPforMap, plotPull ? 120 : 240, plotPull ? -6 : -0.6, plotPull ? 6 : 0.6);
hPullAdditionalCorrTheta[i] =
new TH2D(Form("hPullAdditionalCorrTheta_%d", i),
Form("Pull vs. p_{TPC} for %.2f <= |tan(#Theta)| < %.2f with additional dEdx correction w.r.t. tan(#Theta);p_{TPC} (GeV/c);Pull",
tThetaLow[i], tThetaHigh[i]),
nPbinsForMap, binsPforMap, plotPull ? 120 : 240, plotPull ? -6 : -0.6, plotPull ? 6 : 0.6);
}
TF1 corrFuncMult("corrFuncMult", "[0] + [1]*TMath::Max([4], TMath::Min(x, [3])) + [2] * TMath::Power(TMath::Max([4], TMath::Min(x, [3])), 2)",
0., 0.2);
TF1 corrFuncMultTanTheta("corrFuncMultTanTheta", "[0] * (x -[2]) + [1] * (x * x - [2] * [2])", -1.5, 1.5);
TF1 corrFuncSigmaMult("corrFuncSigmaMul", "TMath::Max(0, [0] + [1]*TMath::Min(x, [3]) + [2] * TMath::Power(TMath::Min(x, [3]), 2))", 0., 0.2);
// LHC13b.pass2
if (isNonPP)
printf("Using corr Parameters for 13b.pass2\n!");
corrFuncMult.SetParameter(0, -5.906e-06);
corrFuncMult.SetParameter(1, -5.064e-04);
corrFuncMult.SetParameter(2, -3.521e-02);
corrFuncMult.SetParameter(3, 2.469e-02);
corrFuncMult.SetParameter(4, 0);
corrFuncMultTanTheta.SetParameter(0, -5.32e-06);
corrFuncMultTanTheta.SetParameter(1, 1.177e-05);
corrFuncMultTanTheta.SetParameter(2, -0.5);
corrFuncSigmaMult.SetParameter(0, 0.);
corrFuncSigmaMult.SetParameter(1, 0.);
corrFuncSigmaMult.SetParameter(2, 0.);
corrFuncSigmaMult.SetParameter(3, 0.);
/* OK, but PID task was not very satisfying
corrFuncMult.SetParameter(0, -6.27187e-06);
corrFuncMult.SetParameter(1, -4.60649e-04);
corrFuncMult.SetParameter(2, -4.26450e-02);
corrFuncMult.SetParameter(3, 2.40590e-02);
corrFuncMult.SetParameter(4, 0);
corrFuncMultTanTheta.SetParameter(0, -5.338e-06);
corrFuncMultTanTheta.SetParameter(1, 1.220e-05);
corrFuncMultTanTheta.SetParameter(2, -0.5);
corrFuncSigmaMult.SetParameter(0, 7.89237e-05);
corrFuncSigmaMult.SetParameter(1, -1.30662e-02);
corrFuncSigmaMult.SetParameter(2, 8.91548e-01);
corrFuncSigmaMult.SetParameter(3, 1.47931e-02);
*/
/*
// LHC11a10a
if (isNonPP)
printf("Using corr Parameters for 11a10a\n!");
corrFuncMult.SetParameter(0, 6.90133e-06);
corrFuncMult.SetParameter(1, -1.22123e-03);
corrFuncMult.SetParameter(2, 1.80220e-02);
corrFuncMult.SetParameter(3, 0.1);
corrFuncMult.SetParameter(4, 6.45306e-03);
corrFuncMultTanTheta.SetParameter(0, -2.85505e-07);
corrFuncMultTanTheta.SetParameter(1, -1.31911e-06);
corrFuncMultTanTheta.SetParameter(2, -0.5);
corrFuncSigmaMult.SetParameter(0, -4.29665e-05);
corrFuncSigmaMult.SetParameter(1, 1.37023e-02);
corrFuncSigmaMult.SetParameter(2, -6.36337e-01);
corrFuncSigmaMult.SetParameter(3, 1.13479e-02);
*/
/* OLD without saturation and large error for negative slopes
corrFuncSigmaMult.SetParameter(0, -4.79684e-05);
corrFuncSigmaMult.SetParameter(1, 1.49938e-02);
corrFuncSigmaMult.SetParameter(2, -7.15269e-01);
corrFuncSigmaMult.SetParameter(3, 1.06855e-02);
*/
/* OLD very good try, but with fewer pBins for the fitting
corrFuncMult.SetParameter(0, 6.88365e-06);
corrFuncMult.SetParameter(1, -1.22324e-03);
corrFuncMult.SetParameter(2, 1.81625e-02);
corrFuncMult.SetParameter(3, 0.1);
corrFuncMult.SetParameter(4, 6.36890e-03);
corrFuncMultTanTheta.SetParameter(0, -2.85505e-07);
corrFuncMultTanTheta.SetParameter(1, -1.31911e-06);
corrFuncMultTanTheta.SetParameter(2, -0.5);
corrFuncSigmaMult.SetParameter(0, -4.28401e-05);
corrFuncSigmaMult.SetParameter(1, 1.24812e-02);
corrFuncSigmaMult.SetParameter(2, -5.28531e-01);
corrFuncSigmaMult.SetParameter(3, 1.25147e-02);
*/
/*OLD good try
corrFuncMult.SetParameter(0, 7.50321e-06);
corrFuncMult.SetParameter(1, -1.25250e-03);
corrFuncMult.SetParameter(2, 1.85437e-02);
corrFuncMult.SetParameter(3, 0.1);
corrFuncMult.SetParameter(4, 6.21192e-03);
corrFuncMultTanTheta.SetParameter(0, -1.43112e-07);
corrFuncMultTanTheta.SetParameter(1, -1.53e-06);
corrFuncMultTanTheta.SetParameter(2, 0.3);
corrFuncSigmaMult.SetParameter(0, -2.54019e-05);
corrFuncSigmaMult.SetParameter(1, 8.68883e-03);
corrFuncSigmaMult.SetParameter(2, -3.36176e-01);
corrFuncSigmaMult.SetParameter(3, 1.29230e-02);
*/
/*
// LHC10h.pass2
if (isNonPP)
printf("Using corr Parameters for 10h.pass2\n!");
corrFuncMult.SetParameter(0, 3.21636e-07);
corrFuncMult.SetParameter(1, -6.65876e-04);
corrFuncMult.SetParameter(2, 1.28786e-03);
corrFuncMult.SetParameter(3, 1.47677e-02);
corrFuncMult.SetParameter(4, 0.);
corrFuncMultTanTheta.SetParameter(0, 7.23591e-08);
corrFuncMultTanTheta.SetParameter(1, 2.7469e-06);
corrFuncMultTanTheta.SetParameter(2, -0.5);
corrFuncSigmaMult.SetParameter(0, -1.22590e-05);
corrFuncSigmaMult.SetParameter(1, 6.88888e-03);
corrFuncSigmaMult.SetParameter(2, -3.20788e-01);
corrFuncSigmaMult.SetParameter(3, 1.07345e-02);
*/
/*OLD bad try
corrFuncMult.SetParameter(0, 2.71514e-07);
corrFuncMult.SetParameter(1, -6.92031e-04);
corrFuncMult.SetParameter(2, 3.56042e-03);
corrFuncMult.SetParameter(3, 1.47497e-02);
corrFuncMult.SetParameter(4, 0.);
corrFuncMultTanTheta.SetParameter(0, 8.53204e-08);
corrFuncMultTanTheta.SetParameter(1, 2.85591e-06);
corrFuncMultTanTheta.SetParameter(2, -0.5);
corrFuncSigmaMult.SetParameter(0, -6.82477e-06);
corrFuncSigmaMult.SetParameter(1, 4.97051e-03);
corrFuncSigmaMult.SetParameter(2, -1.64954e-01);
corrFuncSigmaMult.SetParameter(3, 9.21061e-03);
*/
//TODO NOW
TF1* fShapeSmallP = new TF1("fShapeSmallP", "pol5", -0.4, 0.4);
fShapeSmallP->SetParameters(1.01712, -0.0202725, -0.260692, 0.261623, 0.671854, -1.14014);
for (Long64_t i = 0; i < nTreeEntries; i++) {
tree->GetEntry(i);
if (dEdx <= 0 || dEdxExpected <= 0 || tpcSignalN <= 10)
continue;
/*
Double_t pT = pTPC*TMath::Sin(-TMath::ATan(tanTheta)+TMath::Pi()/2.0);
if ((phiPrime > 0.072/pT+TMath::Pi()/18.0-0.035 && phiPrime < 0.07/pT/pT+0.1/pT+TMath::Pi()/18.0+0.035))
continue;
*/
if (pidType != kMCid) {
if (pidType == kTPCid && pTPC > 0.6)
continue;
if (pidType == kTPCandTOFid && (pTPC < 0.6 || pTPC > 2.0))
continue;
if ((collType == 2) && pidType == kTPCandTOFid && pTPC > 1.0)
continue;// Only V0's in case of PbPb above 1.0 GeV/c
if (pidType == kV0idPlusTOFrejected) //TODO NOW NEW
continue;
}
if (recalculateExpecteddEdx) {
dEdxExpected = 50. * splPr->Eval(pTPC / massProton); //WARNING: What, if MIP is different from 50.? Seems not to be used (tested for pp, MC_pp, PbPb and MC_PbPb), but can in principle happen
}
//TODO NOW
/*
if (TMath::Abs(tanTheta) <= 0.4) {
Double_t p0 = fShapeSmallP->Eval(tanTheta) - 1.0; // Strength of the correction
Double_t p1 = -9.0; // How fast the correction is turned off
Double_t p2 = -0.209; // Turn off correction around 0.2 GeV/c
Double_t p3 = 1.0; // Delta' for large p should be 1
Double_t corrFactor = TMath::Erf((pTPC + p2) * p1) * p0 + p3 + p0; // Add p0 to have 1 for p3 = 1 and large pTPC
dEdxExpected *= corrFactor;
}*/
/*TODO old unsuccessful try
Double_t thetaGlobalTPC = -TMath::ATan(tanTheta) + TMath::Pi() / 2.;
Double_t pTtpc = pTPC * TMath::Sin(thetaGlobalTPC);
Double_t pTtpcInv = (pTtpc > 0) ? 1. / pTtpc : 0;
Double_t p0 = 1.0;
Double_t p1 = 1./ 0.5;//TODO 2.0;
Double_t p2 = -0.2;//TODO 0.1
Double_t pTcorrFactor = p0 + (pTtpcInv > p1) * p2 * (pTtpcInv - p1);
dEdxExpected *= pTcorrFactor;
*/
// From the momentum (via dEdxExpected) and the tanTheta of the track, the expected dEdx can be calculated (correctedDeDxExpected).
// If the splines are correct, this should give in average the same value as dEdx.
// Now valid: Maps created from corrected data with splines adopted to corrected data, so lookup should be for dEdxExpected=dEdxSplines (no further
// eta correction) or the corrected dEdx from the track (which should ideally be = dEdxSplines)
// Tested with corrected data for LHC10d.pass2: using dEdx for the lookup (which is the corrected value and should ideally be = dEdxSplines):
// Results almost the same. Maybe slightly better for dEdxExpected.
// No longer valid: Note that the maps take always the uncorrected dEdx w.r.t.
// tanTheta, so that correctedDeDxExpected is needed here normally. However, the information for the correction will be lost at some point.
// Therefore, dEdxExpected can be used instead and should provide a good approximation.
Double_t c1FromSigmaMap = hThetaMapSigmaPar1->GetBinContent(getBinX(hThetaMapSigmaPar1, tanTheta), getBinY(hThetaMapSigmaPar1, 1./dEdxExpected));
Double_t expectedSigma = dEdxExpected * TMath::Sqrt( c0 * c0 + (c1FromSigmaMap * c1FromSigmaMap) / tpcSignalN);
Double_t pull = (dEdx - dEdxExpected) / (plotPull ? expectedSigma: dEdxExpected);
// Fill pull histo
hPull->Fill(pTPC, pull);
Double_t tanThetaAbs = TMath::Abs(tanTheta);
for (Int_t j = 0; j < nThetaHistos; j++) {
if (tanThetaAbs >= tThetaLow[j] && tanThetaAbs < tThetaHigh[j]) {
hPullTheta[j]->Fill(pTPC, pull);
}
}
if (!hMap)
continue;
Double_t correctionFactor = 1.;
if (isNonPP) {
// 1. Correct eta dependence
correctionFactor = hMap->GetBinContent(getBinX(hMap, tanTheta), getBinY(hMap, 1./dEdxExpected));
// 2. Correct for multiplicity dependence:
Double_t multCorrectionFactor = 1.;
if (fMultiplicity > 0) {
Double_t relSlope = corrFuncMult.Eval(1. / (dEdxExpected * correctionFactor));
relSlope += corrFuncMultTanTheta.Eval(tanTheta);
multCorrectionFactor = 1. + relSlope * fMultiplicity;
}
c1FromSigmaMap = hThetaMapSigmaPar1->GetBinContent(getBinX(hThetaMapSigmaPar1, tanTheta), getBinY(hThetaMapSigmaPar1, 1./dEdxExpected));
// Multiplicity dependence of sigma depends on the real dEdx at zero multiplicity, i.e. the eta (only) corrected dEdxExpected value has to be used
// since all maps etc. have been created for ~zero multiplicity
Double_t relSigmaSlope = corrFuncSigmaMult.Eval(1. / (dEdxExpected * correctionFactor));
Double_t multSigmaCorrectionFactor = 1. + relSigmaSlope * fMultiplicity;
dEdxExpected *= correctionFactor * multCorrectionFactor;
expectedSigma = dEdxExpected * TMath::Sqrt( c0 * c0 + (c1FromSigmaMap * c1FromSigmaMap) / tpcSignalN);
expectedSigma *= multSigmaCorrectionFactor;
pull = (dEdx - dEdxExpected) / (plotPull ? expectedSigma: dEdxExpected);
}
else {
correctionFactor = hMap->GetBinContent(getBinX(hMap, tanTheta), getBinY(hMap, 1./dEdxExpected));
c1FromSigmaMap = hThetaMapSigmaPar1->GetBinContent(getBinX(hThetaMapSigmaPar1, tanTheta), getBinY(hThetaMapSigmaPar1, 1./dEdxExpected));
dEdxExpected *= correctionFactor; // If data is not corrected, but the sigma map is for corrected data, re-do analysis with corrected dEdx
expectedSigma = dEdxExpected * TMath::Sqrt( c0 * c0 + (c1FromSigmaMap * c1FromSigmaMap) / tpcSignalN);
pull = (dEdx - dEdxExpected) / (plotPull ? expectedSigma: dEdxExpected);
}
pull = (dEdx - dEdxExpected) / (plotPull ? expectedSigma: dEdxExpected);
hPullAdditionalCorr->Fill(pTPC, pull);
for (Int_t j = 0; j < nThetaHistos; j++) {
if (tanThetaAbs >= tThetaLow[j] && tanThetaAbs < tThetaHigh[j]) {
hPullAdditionalCorrTheta[j]->Fill(pTPC, pull);
}
}
}
/*
// Mean, Sigma, chi^2/NDF of pull of different theta bins and all in one plot
TCanvas* canvPullMean = new TCanvas("canvPullMean", "canvPullMean", 100,10,1380,800);
canvPullMean->SetLogx(kTRUE);
canvPullMean->SetGridx(kTRUE);
canvPullMean->SetGridy(kTRUE);
TCanvas* canvPullSigma = new TCanvas("canvPullSigma", "canvPullSigma", 100,10,1380,800);
canvPullSigma->SetLogx(kTRUE);
canvPullSigma->SetGridx(kTRUE);
canvPullSigma->SetGridy(kTRUE);
TCanvas* canvPullChi2 = new TCanvas("canvPullChi2", "canvPullChi2", 100,10,1380,800);
canvPullChi2->SetLogx(kTRUE);
canvPullChi2->SetGridx(kTRUE);
canvPullChi2->SetGridy(kTRUE);
TCanvas* canvPull[nThetaHistos + 1];
for (Int_t i = 0, j = nThetaHistos; i < nThetaHistos + 1; i++, j--) {
canvPull[i] = new TCanvas(Form("canvPull_%d", i), "canvPull", 100,10,1380,800);
canvPull[i]->cd();
canvPull[i]->SetLogx(kTRUE);
canvPull[i]->SetLogz(kTRUE);
canvPull[i]->SetGrid(kTRUE, kTRUE);
TH2D* hTemp = 0x0;
TString thetaString = "";
if (i == nThetaHistos) {
hTemp = hPull;
thetaString = "tan(#Theta) integrated";
}
else {
hTemp = hPullTheta[i];
thetaString = Form("%.2f #leq |tan(#Theta)| < %.2f", tThetaLow[i], tThetaHigh[i]);
}
normaliseHisto(hTemp);
hTemp->FitSlicesY();
hTemp->GetYaxis()->SetNdivisions(12);
hTemp->GetXaxis()->SetMoreLogLabels(kTRUE);
TH1D* hTempMean = (TH1D*)gDirectory->Get(Form("%s_1", hTemp->GetName()));
hTempMean->SetTitle(Form("mean(pull), %s", thetaString.Data()));
hTempMean->GetXaxis()->SetMoreLogLabels(kTRUE);
hTempMean->SetLineWidth(2);
hTempMean->SetMarkerStyle(20);
TH1D* hTempSigma = (TH1D*)gDirectory->Get(Form("%s_2", hTemp->GetName()));
hTempSigma->SetTitle(Form("#sigma(pull), %s", thetaString.Data()));
hTempSigma->GetXaxis()->SetMoreLogLabels(kTRUE);
hTempSigma->SetLineColor(kMagenta);
hTempSigma->SetMarkerStyle(20);
hTempSigma->SetMarkerColor(kMagenta);
hTempSigma->SetLineWidth(2);
TH1D* hTempChi2 = (TH1D*)gDirectory->Get(Form("%s_chi2", hTemp->GetName()));
hTempChi2->SetTitle(Form("#chi^{2} / NDF (pull), %s", thetaString.Data()));
hTempChi2->GetXaxis()->SetMoreLogLabels(kTRUE);
hTempChi2->SetLineColor(kMagenta + 2);
hTempChi2->SetMarkerStyle(20);
hTempChi2->SetMarkerColor(kMagenta + 2);
hTempChi2->SetLineWidth(2);
hTemp->DrawCopy("colz");
hTempMean->DrawCopy("same");
hTempSigma->DrawCopy("same");
hTempChi2->Scale(-1./10.);
hTempChi2->DrawCopy("same");
hTempChi2->Scale(-10.);
canvPullMean->cd();
hTempMean->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempMean->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempMean->DrawCopy((i == 0 ? "" : "same"));
canvPullSigma->cd();
hTempSigma->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempSigma->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempSigma->DrawCopy((i == 0 ? "" : "same"));
canvPullChi2->cd();
hTempChi2->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempChi2->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempChi2->DrawCopy((i == 0 ? "" : "same"));
}
canvPullMean->BuildLegend();
canvPullSigma->BuildLegend();
canvPullChi2->BuildLegend();
*/
// Histograms with additional correction
TCanvas* canvPullMeanCorr = 0x0;
TCanvas* canvPullSigmaCorr = 0x0;
TCanvas* canvPullChi2Corr = 0x0;
TCanvas* canvPullCorr[nThetaHistos + 1];
for (Int_t i = 0; i < nThetaHistos + 1; i++)
canvPullCorr[i] = 0x0;
if (hMap) {
// Mean, Sigma, chi^2/NDF of pull of different theta bins and all in one plot
canvPullMeanCorr = new TCanvas("canvPullMeanCorr", "canvPullMeanCorr", 100,10,1380,800);
canvPullMeanCorr->SetLogx(kTRUE);
canvPullMeanCorr->SetGridx(kTRUE);
canvPullMeanCorr->SetGridy(kTRUE);
canvPullSigmaCorr = new TCanvas("canvPullSigmaCorr", "canvPullSigmaCorr", 100,10,1380,800);
canvPullSigmaCorr->SetLogx(kTRUE);
canvPullSigmaCorr->SetGridx(kTRUE);
canvPullSigmaCorr->SetGridy(kTRUE);
canvPullChi2Corr = new TCanvas("canvPullChi2Corr", "canvPullChi2Corr", 100,10,1380,800);
canvPullChi2Corr->SetLogx(kTRUE);
canvPullChi2Corr->SetGridx(kTRUE);
canvPullChi2Corr->SetGridy(kTRUE);
for (Int_t i = 0, j = nThetaHistos; i < nThetaHistos + 1; i++, j--) {
canvPullCorr[i] = new TCanvas(Form("canvPullCorr_%d", i), "canvPullCorr", 100,10,1380,800);
canvPullCorr[i]->cd();
canvPullCorr[i]->SetLogx(kTRUE);
canvPullCorr[i]->SetLogz(kTRUE);
canvPullCorr[i]->SetGrid(kTRUE, kTRUE);
TH2D* hTemp = 0x0;
TString thetaString = "";
if (i == nThetaHistos) {
hTemp = hPullAdditionalCorr;
thetaString = "tan(#Theta) integrated";
}
else {
hTemp = hPullAdditionalCorrTheta[i];
thetaString = Form("%.2f #leq |tan(#Theta)| < %.2f", tThetaLow[i], tThetaHigh[i]);
}
normaliseHisto(hTemp);
hTemp->FitSlicesY();
hTemp->GetYaxis()->SetNdivisions(12);
hTemp->GetXaxis()->SetMoreLogLabels(kTRUE);
TH1D* hTempMean = (TH1D*)gDirectory->Get(Form("%s_1", hTemp->GetName()));
hTempMean->SetTitle(Form("mean(pull), %s", thetaString.Data()));
hTempMean->GetXaxis()->SetMoreLogLabels(kTRUE);
hTempMean->SetLineWidth(2);
hTempMean->SetMarkerStyle(20);
TH1D* hTempSigma = (TH1D*)gDirectory->Get(Form("%s_2", hTemp->GetName()));
hTempSigma->SetTitle(Form("#sigma(pull), %s", thetaString.Data()));
hTempSigma->GetXaxis()->SetMoreLogLabels(kTRUE);
hTempSigma->SetLineColor(kMagenta);
hTempSigma->SetMarkerStyle(20);
hTempSigma->SetMarkerColor(kMagenta);
hTempSigma->SetLineWidth(2);
TH1D* hTempChi2 = (TH1D*)gDirectory->Get(Form("%s_chi2", hTemp->GetName()));
hTempChi2->SetTitle(Form("#chi^{2} / NDF (pull), %s", thetaString.Data()));
hTempChi2->GetXaxis()->SetMoreLogLabels(kTRUE);
hTempChi2->SetLineColor(kMagenta + 2);
hTempChi2->SetMarkerStyle(20);
hTempChi2->SetMarkerColor(kMagenta + 2);
hTempChi2->SetLineWidth(2);
hTemp->DrawCopy("colz");
hTempMean->DrawCopy("same");
hTempSigma->DrawCopy("same");
hTempChi2->Scale(-1./10.);
hTempChi2->DrawCopy("same");
hTempChi2->Scale(-10.);
canvPullMeanCorr->cd();
hTempMean->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempMean->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempMean->DrawCopy((i == 0 ? "" : "same"));
canvPullSigmaCorr->cd();
hTempSigma->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempSigma->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempSigma->DrawCopy((i == 0 ? "" : "same"));
canvPullChi2Corr->cd();
hTempChi2->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempChi2->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j));
hTempChi2->DrawCopy((i == 0 ? "" : "same"));
}
canvPullMeanCorr->BuildLegend();
canvPullSigmaCorr->BuildLegend();
canvPullChi2Corr->BuildLegend();
}
fSave->cd();
/*canvPullMean->Write();
canvPullSigma->Write();
canvPullChi2->Write();
for (Int_t i = 0; i < nThetaHistos + 1; i++) {
canvPull[i]->Write();
}*/
canvPullMeanCorr->Write();
canvPullSigmaCorr->Write();
canvPullChi2Corr->Write();
for (Int_t i = 0; i < nThetaHistos + 1; i++) {
canvPullCorr[i]->Write();
}
TNamed* info = new TNamed(Form("Theta map: %s\n\nSigma map: %s\n\nSplines file: %s\n\nSplines name: %s", pathNameThetaMap.Data(),
pathNameSigmaMap.Data(), pathNameSplinesFile.Data(), prSplinesName.Data()),
"info");
info->Write();
fSave->Close();
return 0;
}
int fit_dscb(TH1F*& hrsp,
const double nsigma,
const double jtptmin,
const int niter,
const string alg,
const double fitmin,
const double fitmax
)
{
if (0==hrsp) {
cout<<"ERROR: Empty pointer to fit_dscb()"<<endl;return -1;
}
// first use a gaussian to constrain crystal ball gaussian core
fit_gaussian(hrsp, nsigma, jtptmin, niter, alg);
TF1* fgaus = hrsp->GetFunction("fgaus");
if (0==fgaus) {
hrsp->GetListOfFunctions()->Delete();
return -1;
}
// implementation of the low pt bias threshold
string histname = hrsp->GetName();
double ptRefMax(1.0),rspMax(0.0);
int pos1 = histname.find("RefPt");
int pos2 = histname.find("to",pos1);
string ss = histname.substr(pos1+5,pos2);
if (from_string(ptRefMax,ss,std::dec)) {
if (histname.find("RelRsp")==0)
rspMax = jtptmin/ptRefMax;
if (histname.find("AbsRsp")==0)
rspMax = jtptmin-ptRefMax;
}
double fitrange_min(fitmin);
double fitrange_max(fitmax);
fitrange_min = std::max(rspMax,fitmin);
adjust_fitrange(hrsp,fitrange_min,fitrange_max);
TF1* fdscb = new TF1("fdscb",fnc_dscb,fitrange_min,fitrange_max,7);
fdscb->SetLineWidth(2);
fdscb->SetLineStyle(2);
double norm = 2*fgaus->GetParameter(0);
double mean = fgaus->GetParameter(1);
double sigma= fgaus->GetParameter(2);
//cout << hrsp->GetName() << " fgaus "<< mean << " \t " << hrsp->GetMean() << endl;
// double norm = 2*hrsp->GetMaximum();
// double mean = hrsp->GetMean();
// //double mean = GetPeak(hrsp);
// cout << " mean : " << mean << " hist mean : "<< hrsp->GetMean() << endl;
// double sigma= hrsp->GetRMS();
double aone(2.0),atwo(2.0),pone(10.0),ptwo(10.0);
//double aone(1.0),atwo(1.0),pone(10.0),ptwo(10.0);
TVirtualFitter::SetDefaultFitter("Minuit");
int fitstatus(0);
for (int i=0;i<niter;i++) {
fdscb->SetParameter(0,norm); // N
fdscb->SetParameter(1,mean); // mean
fdscb->SetParameter(2,sigma);// sigma
fdscb->SetParameter(3,aone); // a1
fdscb->SetParameter(4,pone); // p1
fdscb->SetParameter(5,atwo); // a2
fdscb->SetParameter(6,ptwo); // p2
fdscb->FixParameter(1,mean);
fdscb->FixParameter(2,sigma);
if (i>0) fdscb->FixParameter(3,aone);
else{
fdscb->SetParLimits(3,0.,20.); //! best
}
if (i>1) fdscb->FixParameter(5,atwo);
else{
fdscb->SetParLimits(5,0.,20.); //! best
}
//! best
fdscb->SetParLimits(4,0.,60.);
fdscb->SetParLimits(6,0.,60.);
fitstatus = hrsp->Fit(fdscb,"RQ+");
if (0==fitstatus) i=999;
delete fdscb;
fdscb = hrsp->GetFunction("fdscb");
if (0==fdscb) return -1;
norm = fdscb->GetParameter(0);
aone = fdscb->GetParameter(3);
pone = fdscb->GetParameter(4);
atwo = fdscb->GetParameter(5);
ptwo = fdscb->GetParameter(6);
//cout << " aone : " << aone << " atwo : " << atwo << " pone : " << pone << " ptwo : " << ptwo << endl;
//reset sigma and mean to gauss values...
fdscb->SetParameter(1,fgaus->GetParameter(1));
fdscb->SetParError (1,fgaus->GetParError(1));
fdscb->SetParameter(2,fgaus->GetParameter(2));
fdscb->SetParError (2,fgaus->GetParError(2));
}
if (0!=fitstatus){
cout<<"fit_fdscb() to "<<alg.c_str()<<" " <<hrsp->GetName()
<<" failed. Fitstatus: "<<fitstatus<<endl;
hrsp->GetFunction("fdscb")->Delete();
}
else fdscb->ResetBit(TF1::kNotDraw);
//cout << " aone : " << aone << " atwo : " << atwo << " pone : " << pone << " ptwo : " << ptwo << endl;
return fitstatus;
}
void ConfidenceIntervals()
{
TCanvas *myc = new TCanvas("myc",
"Confidence intervals on the fitted function",1200, 500);
myc->Divide(3,1);
/////1. A graph
//Create and fill a graph
Int_t ngr = 100;
TGraph *gr = new TGraph(ngr);
gr->SetName("GraphNoError");
Double_t x, y;
Int_t i;
for (i=0; i<ngr; i++){
x = gRandom->Uniform(-1, 1);
y = -1 + 2*x + gRandom->Gaus(0, 1);
gr->SetPoint(i, x, y);
}
//Create the fitting function
TF1 *fpol = new TF1("fpol", "pol1", -1, 1);
fpol->SetLineWidth(2);
gr->Fit(fpol, "Q");
//Create a TGraphErrors to hold the confidence intervals
TGraphErrors *grint = new TGraphErrors(ngr);
grint->SetTitle("Fitted line with .95 conf. band");
for (i=0; i<ngr; i++)
grint->SetPoint(i, gr->GetX()[i], 0);
//Compute the confidence intervals at the x points of the created graph
(TVirtualFitter::GetFitter())->GetConfidenceIntervals(grint);
//Now the "grint" graph contains function values as its y-coordinates
//and confidence intervals as the errors on these coordinates
//Draw the graph, the function and the confidence intervals
myc->cd(1);
grint->SetLineColor(kRed);
grint->Draw("ap");
gr->SetMarkerStyle(5);
gr->SetMarkerSize(0.7);
gr->Draw("psame");
/////2. A histogram
myc->cd(2);
//Create, fill and fit a histogram
Int_t nh=5000;
TH1D *h = new TH1D("h",
"Fitted gaussian with .95 conf.band", 100, -3, 3);
h->FillRandom("gaus", nh);
TF1 *f = new TF1("fgaus", "gaus", -3, 3);
f->SetLineWidth(2);
h->Fit(f, "Q");
h->Draw();
//Create a histogram to hold the confidence intervals
TH1D *hint = new TH1D("hint",
"Fitted gaussian with .95 conf.band", 100, -3, 3);
(TVirtualFitter::GetFitter())->GetConfidenceIntervals(hint);
//Now the "hint" histogram has the fitted function values as the
//bin contents and the confidence intervals as bin errors
hint->SetStats(kFALSE);
hint->SetFillColor(2);
hint->Draw("e3 same");
/////3. A 2d graph
//Create and fill the graph
Int_t ngr2 = 100;
Double_t z, rnd, e=0.3;
TGraph2D *gr2 = new TGraph2D(ngr2);
gr2->SetName("Graph2DNoError");
TF2 *f2 = new TF2("f2",
"1000*(([0]*sin(x)/x)*([1]*sin(y)/y))+250",-6,6,-6,6);
f2->SetParameters(1,1);
for (i=0; i<ngr2; i++){
f2->GetRandom2(x,y);
// Generate a random number in [-e,e]
rnd = 2*gRandom->Rndm()*e-e;
z = f2->Eval(x,y)*(1+rnd);
gr2->SetPoint(i,x,y,z);
}
//Create a graph with errors to store the intervals
TGraph2DErrors *grint2 = new TGraph2DErrors(ngr2);
for (i=0; i<ngr2; i++)
grint2->SetPoint(i, gr2->GetX()[i], gr2->GetY()[i], 0);
//Fit the graph
f2->SetParameters(0.5,1.5);
gr2->Fit(f2, "Q");
//Compute the confidence intervals
(TVirtualFitter::GetFitter())->GetConfidenceIntervals(grint2);
//Now the "grint2" graph contains function values as z-coordinates
//and confidence intervals as their errors
//draw
myc->cd(3);
f2->SetNpx(30);
f2->SetNpy(30);
f2->SetFillColor(kBlue);
f2->Draw("surf4");
grint2->SetNpx(20);
grint2->SetNpy(20);
grint2->SetMarkerStyle(24);
grint2->SetMarkerSize(0.7);
grint2->SetMarkerColor(kRed);
grint2->SetLineColor(kRed);
grint2->Draw("E0 same");
grint2->SetTitle("Fitted 2d function with .95 error bars");
myc->cd();
}
void DrawCalibrationPlotsEE (
Char_t* infile1 = "data_LC_20120131_ALPHA_test_prompt/SingleElectron_Run2011AB-WElectron-data_LC_20120131_ALPHA_test_prompt_EoPcaibEE_11032011_Z_R9_EE.root",
Char_t* infile2 = "data_LC_20120131_ALPHA_test_prompt/Even_SingleElectron_Run2011AB-WElectron-data_LC_20120131_ALPHA_test_prompt_EoPcaibEE_11032011_Z_R9_EE.root",
Char_t* infile3 = "data_LC_20120131_ALPHA_test_prompt/Odd_SingleElectron_Run2011AB-WElectron-data_LC_20120131_ALPHA_test_prompt_EoPcaibEE_11032011_Z_R9_EE.root",
//Char_t* infile1 = "FT_R_42_V21B/WZAnalysis_PromptSkim_W-DoubleElectron_FT_R_42_V21B_Z_R9_EE.root",
//Char_t* infile2 = "FT_R_42_V21B/Even_WZAnalysis_PromptSkim_W-DoubleElectron_FT_R_42_V21B_Z_R9_EE.root",
//Char_t* infile3 = "FT_R_42_V21B/Odd_WZAnalysis_PromptSkim_W-DoubleElectron_FT_R_42_V21B_Z_R9_EE.root",
int evalStat = 1,
bool isMC=false,
Char_t* fileType = "png",
Char_t* dirName = ".")
{
bool printPlots = false;
/// by xtal
int nbins = 250;
/// Set style options
gROOT->Reset();
gROOT->SetStyle("Plain");
gStyle->SetPadTickX(1);
gStyle->SetPadTickY(1);
gStyle->SetOptTitle(0);
gStyle->SetOptStat(11110);
gStyle->SetOptFit(0);
gStyle->SetFitFormat("6.3g");
gStyle->SetPalette(1);
gStyle->SetTextFont(42);
gStyle->SetTextSize(0.05);
gStyle->SetTitleFont(42,"xyz");
gStyle->SetTitleSize(0.05);
gStyle->SetLabelFont(42,"xyz");
gStyle->SetLabelSize(0.05);
gStyle->SetTitleXOffset(0.8);
gStyle->SetTitleYOffset(1.1);
gROOT->ForceStyle();
if ( !infile1 ) {
cout << " No input file specified !" << endl;
return;
}
if ( evalStat && (!infile2 || !infile3 )){
cout << " No input files to evaluate statistical precision specified !" << endl;
return;
}
cout << "Making calibration plots for: " << infile1 << endl;
/// imput file with full statistic normlized to the mean in a ring
TFile *f = new TFile(infile1);
TH2F *hcmap[2];
hcmap[0] = (TH2F*)f->Get("h_scale_map_EEM");
hcmap[1] = (TH2F*)f->Get("h_scale_map_EEP");
/// ring geometry for the endcap
TH2F *hrings[2];
hrings[0] = (TH2F*)hcmap[0]->Clone("hringsEEM");
hrings[1] = (TH2F*)hcmap[0]->Clone("hringsEEP");
hrings[0] ->Reset("ICMES");
hrings[1] ->Reset("ICMES");
hrings[0] ->ResetStats();
hrings[1] ->ResetStats();
FILE *fRing;
fRing = fopen("macros/eerings.dat","r");
int x,y,z,ir;
while(fscanf(fRing,"(%d,%d,%d) %d \n",&x,&y,&z,&ir) !=EOF ) {
if(z>0) hrings[1]->Fill(x,y,ir);
if(z<0) hrings[0]->Fill(x,y,ir);
}
TFile *f4 = TFile::Open("MCtruthIC_EE.root");
TFile *f5 = TFile::Open("MCRecoIC_EE.root");
TH2F *hcmapMcT_EEP = (TH2F*)f4->Get("h_scale_EEP");
TH2F *hcmapMcT_EEM = (TH2F*)f4->Get("h_scale_EEM");
TH2F *hcmapMcR_EEP = (TH2F*)f5->Get("h_scale_EEP");
TH2F *hcmapMcR_EEM = (TH2F*)f5->Get("h_scale_EEM");
///--------------------------------------------------------------------------------
///--- Build the precision vs ring plot starting from the TH2F of IC folded and not
///--------------------------------------------------------------------------------
char hname[100];
char htitle[100];
TH1F *hspread[2][50];
TH1F* hspreadAll [40];
TH2F* ICComparison [2];
ICComparison[0] = (TH2F*) hcmapMcT_EEP->Clone("ICComparison_EEM");
ICComparison[1] = (TH2F*) hcmapMcT_EEM->Clone("ICComparison_EEP");
ICComparison[0]->Reset("ICMES");
ICComparison[1]->Reset("ICMES");
ICComparison[0]->ResetStats();
ICComparison[1]->ResetStats();
for (int k = 0; k < 2; k++){
for (int iring = 0; iring < 40 ; iring++){
if (k==0)
{
sprintf(hname,"hspreadAll_ring%02d",iring);
hspreadAll[iring] = new TH1F(hname, hname, nbins,0.,2.);
sprintf(hname,"hspreadEEM_MCTruth_ring%02d",iring);
hspread[k][iring] = new TH1F(hname, hname, nbins,0.,2.);
}
else{
sprintf(hname,"hspreadEEP_ring%02d",iring);
hspread[k][iring] = new TH1F(hname, hname, nbins,0.,2.);
}
}
}
/// spread all distribution, spread for EE+ and EE- and comparison with the MC truth
for (int k = 0; k < 2 ; k++){
for (int ix = 1; ix < 101; ix++){
for (int iy = 1; iy < 101; iy++){
int iz = k;
if (k==0) iz = -1;
int mybin = hcmap[k] -> FindBin(ix,iy);
int ring = hrings[1]-> GetBinContent(mybin);
float ic = hcmap[k]->GetBinContent(mybin);
float ic2=0;
if(k==0 && hcmapMcT_EEM->GetBinContent(mybin)!=0 && hcmapMcR_EEM->GetBinContent(mybin)!=0 ) ic2 = hcmapMcT_EEM->GetBinContent(mybin)/hcmapMcR_EEM->GetBinContent(mybin);
else if(hcmapMcT_EEP->GetBinContent(mybin)!=0 && hcmapMcR_EEP->GetBinContent(mybin)!=0 ) ic2 = hcmapMcT_EEP->GetBinContent(mybin)/hcmapMcR_EEP->GetBinContent(mybin);
if ( ic>0 && ic2>0 ) {
hspread[k][ring]->Fill(ic);
hspreadAll[ring]->Fill(ic);
ICComparison[k]->Fill(ix,iy,ic/ic2);
}
}
}
}
/// Graph Error for spread EE+ and EE-
TGraphErrors *sigma_vs_ring[3];
sigma_vs_ring[0] = new TGraphErrors();
sigma_vs_ring[0]->SetMarkerStyle(20);
sigma_vs_ring[0]->SetMarkerSize(1);
sigma_vs_ring[0]->SetMarkerColor(kBlue+2);
sigma_vs_ring[1] = new TGraphErrors();
sigma_vs_ring[1]->SetMarkerStyle(20);
sigma_vs_ring[1]->SetMarkerSize(1);
sigma_vs_ring[1]->SetMarkerColor(kBlue+2);
sigma_vs_ring[2] = new TGraphErrors();
sigma_vs_ring[2]->SetMarkerStyle(20);
sigma_vs_ring[2]->SetMarkerSize(1);
sigma_vs_ring[2]->SetMarkerColor(kBlue+2);
/// Graph for scale vs ring EE+, EE- and folded
TGraphErrors *scale_vs_ring[3];
scale_vs_ring[0] = new TGraphErrors();
scale_vs_ring[0]->SetMarkerStyle(20);
scale_vs_ring[0]->SetMarkerSize(1);
scale_vs_ring[0]->SetMarkerColor(kBlue+2);
scale_vs_ring[1] = new TGraphErrors();
scale_vs_ring[1]->SetMarkerStyle(20);
scale_vs_ring[1]->SetMarkerSize(1);
scale_vs_ring[1]->SetMarkerColor(kBlue+2);
scale_vs_ring[2] = new TGraphErrors();
scale_vs_ring[2]->SetMarkerStyle(20);
scale_vs_ring[2]->SetMarkerSize(1);
scale_vs_ring[2]->SetMarkerColor(kBlue+2);
TF1 *fgaus = new TF1("fgaus","gaus",-10,10);
int np[3] = {0};
/// Gaussian fit for EE+ and EE-
for (int k = 0; k < 2 ; k++){
for (int iring = 0; iring < 40; iring++){
if (hspread[k][iring]-> GetEntries() == 0) continue;
float e = 0.5*hcmap[k]-> GetYaxis()->GetBinWidth(1);
fgaus->SetParameter(1,1);
fgaus->SetParameter(2,hspread[k][iring]->GetRMS());
fgaus->SetRange(1-5*hspread[k][iring]->GetRMS(),1+5*hspread[k][iring]->GetRMS());
hspread[k][iring]->Fit("fgaus","QR");
sigma_vs_ring[k]-> SetPoint(np[k],iring,fgaus->GetParameter(2));
sigma_vs_ring[k]-> SetPointError(np[k], e ,fgaus->GetParError(2));
scale_vs_ring[k]-> SetPoint(np[k],iring,fgaus->GetParameter(1));
scale_vs_ring[k]-> SetPointError(np[k],e,fgaus->GetParError(1));
np[k]++;
}
}
for (int iring = 0; iring < 40; iring++){
if (hspreadAll[iring]-> GetEntries() == 0) continue;
float e = 0.5*hcmap[0]-> GetYaxis()->GetBinWidth(1);
fgaus->SetParameter(1,1);
fgaus->SetParameter(2,hspreadAll[iring]->GetRMS());
fgaus->SetRange(1-5*hspreadAll[iring]->GetRMS(),1+5*hspreadAll[iring]->GetRMS());
hspreadAll[iring]->Fit("fgaus","QR");
sigma_vs_ring[2]-> SetPoint(np[2],iring,fgaus->GetParameter(2));
sigma_vs_ring[2]-> SetPointError(np[2], e ,fgaus->GetParError(2));
scale_vs_ring[2]-> SetPoint(np[2],iring,fgaus->GetParameter(1));
scale_vs_ring[2]-> SetPointError(np[2],e,fgaus->GetParError(1));
np[2]++;
}
/// Intercalibration constant vs phi
/* TGraphErrors *IC_vs_phi[2];
IC_vs_phi[0] = new TGraphErrors();
IC_vs_phi[0]->SetMarkerStyle(20);
IC_vs_phi[0]->SetMarkerSize(1);
IC_vs_phi[0]->SetMarkerColor(kBlue+2);
IC_vs_phi[1] = new TGraphErrors();
IC_vs_phi[1]->SetMarkerStyle(20);
IC_vs_phi[1]->SetMarkerSize(1);
IC_vs_phi[1]->SetMarkerColor(kBlue+2);
TH1F* Spread_vs_phi[2][360];
for (int k = 0; k < 2; k++){
for (int iphi = 0; iphi < 360 ; iphi++){
if (k==0)
{
sprintf(hname,"hspread_vs_phi%02d_EEP",iphi);
Spread_vs_phi[k][iphi] = new TH1F(hname, hname, nbins,0.,2.);
}
else{
sprintf(hname,"hspread_vs_ring%02d_EEM",iphi);
Spread_vs_phi[k][iphi] = new TH1F(hname, hname, nbins,0.,2.);}
}
}
for (int k = 0; k < 2 ; k++){
for (int ix = 1; ix < 101; ix++){
for (int iy = 1; iy < 101; iy++){
float iphibin;
if((atan2(iy-50.,ix-50.)-int(atan2(iy-50.,ix-50.)))*(360./(2.*3.14159)) <0.5) iphibin=floor(180.+atan2(iy-50.,ix-50.)*(360./(2.*3.14159)));
else iphibin=ceil(180.+atan2(iy-50.,ix-50.)*(360./(2.*3.14159)));
if(iphibin>359) iphibin=359;
int mybin = hcmap[k] -> FindBin(ix,iy);
float ic = hcmap[k]->GetBinContent(mybin);
if ( ic>0 ) {
Spread_vs_phi[k][iphibin] ->Fill(ic);
}
}
}
}
int N[2]={0};
for (int k = 0; k < 2 ; k++){
for (int iphi = 0; iphi < 360; iphi++){
if (Spread_vs_phi[k][iphi]-> GetEntries() == 0) continue;
IC_vs_phi[k]-> SetPoint(N[k],iphi,Spread_vs_phi[k][iphi]->GetMean());
IC_vs_phi[k]-> SetPointError(N[k],0,Spread_vs_phi[k][iphi]->GetRMS()/sqrt(Spread_vs_phi[k][iphi]->GetEntries()));
N[k]++;
}
}
*/
///----------------- Statistical Precision and Residual --------------------
TGraphErrors *statprecision_vs_ring[3];
statprecision_vs_ring[0] = new TGraphErrors();
statprecision_vs_ring[0]->SetMarkerStyle(20);
statprecision_vs_ring[0]->SetMarkerSize(1);
statprecision_vs_ring[0]->SetMarkerColor(kRed+2);
statprecision_vs_ring[1] = new TGraphErrors();
statprecision_vs_ring[1]->SetMarkerStyle(20);
statprecision_vs_ring[1]->SetMarkerSize(1);
statprecision_vs_ring[1]->SetMarkerColor(kRed+2);
statprecision_vs_ring[2] = new TGraphErrors();
statprecision_vs_ring[2]->SetMarkerStyle(20);
statprecision_vs_ring[2]->SetMarkerSize(1);
statprecision_vs_ring[2]->SetMarkerColor(kRed+2);
TGraphErrors *residual_vs_ring[3];
residual_vs_ring[0] = new TGraphErrors();
residual_vs_ring[0]->SetMarkerStyle(20);
residual_vs_ring[0]->SetMarkerSize(1);
residual_vs_ring[0]->SetMarkerColor(kGreen+2);
residual_vs_ring[1] = new TGraphErrors();
residual_vs_ring[1]->SetMarkerStyle(20);
residual_vs_ring[1]->SetMarkerSize(1);
residual_vs_ring[1]->SetMarkerColor(kGreen+2);
residual_vs_ring[2] = new TGraphErrors();
residual_vs_ring[2]->SetMarkerStyle(20);
residual_vs_ring[2]->SetMarkerSize(1);
residual_vs_ring[2]->SetMarkerColor(kGreen+2);
if (evalStat){
/// acquisition file for statistical precision
TFile *f2 = new TFile(infile2);
TFile *f3 = new TFile(infile3);
TH2F *hcmap2[2];
hcmap2[0] = (TH2F*)f2->Get("h_scale_map_EEM");
hcmap2[1] = (TH2F*)f2->Get("h_scale_map_EEP");
TH2F *hcmap3[2];
hcmap3[0] = (TH2F*)f3->Get("h_scale_map_EEM");
hcmap3[1] = (TH2F*)f3->Get("h_scale_map_EEP");
TH1F *hstatprecision[2][40];
TH1F *hstatprecisionAll[40];
/// stat precision histos for each EE ring
for (int k = 0; k < 2; k++){
for (int iring = 0; iring < 40 ; iring ++){
if (k==0)
{ sprintf(hname,"hstatprecisionAll_ring%02d",iring);
hstatprecisionAll[iring] = new TH1F(hname, hname, nbins,-2.,2.);
sprintf(hname,"hstatprecisionEEM_ring%02d",iring);
hstatprecision[k][iring] = new TH1F(hname, hname, nbins,-2.,2.);
}
else {
sprintf(hname,"hstatprecisionEEP_ring%02d",iring);
hstatprecision[k][iring] = new TH1F(hname, hname, nbins,-2.,2.);
}
}
}
for (int k = 0; k < 2 ; k++){
for (int ix = 1; ix < 102; ix++){
for (int iy = 1; iy < 102; iy++){
int iz = k;
if (k==0) iz = -1;
int mybin = hcmap2[k] -> FindBin(ix,iy);
int ring = hrings[1]-> GetBinContent(mybin);
float ic1 = hcmap2[k]->GetBinContent(mybin);
float ic2 = hcmap3[k]->GetBinContent(mybin);
if (ic1>0 && ic2 >0){
hstatprecision[k][ring]->Fill((ic1-ic2)/(ic1+ic2)); /// sigma (diff/sum) gives the stat. precision on teh entire sample
hstatprecisionAll[ring]->Fill((ic1-ic2)/(ic1+ic2));
}
}
}
}
TCanvas* c44 [120];
/// Gaussian fit of the even/odd distribution (rms of the distribution can be also used)
int n[3] = {0};
for (int k = 0; k < 2; k++){
for (int iring = 0; iring < 40 ; iring++){
if ( hstatprecision[k][iring]->GetEntries() == 0) continue;
float e = 0.5*hcmap2[k]-> GetYaxis()->GetBinWidth(1);
fgaus->SetParameter(1,1);
fgaus->SetParameter(2,hstatprecision[k][iring]->GetRMS());
fgaus->SetRange(-5*hstatprecision[k][iring]->GetRMS(),5*hstatprecision[k][iring]->GetRMS());
TString name = Form("ff%d_%d",iring,k);
hstatprecision[k][iring]->Fit("fgaus","QR");
statprecision_vs_ring[k]-> SetPoint(n[k],iring,fgaus->GetParameter(2));
statprecision_vs_ring[k]-> SetPointError(n[k],e,fgaus->GetParError(2));
n[k]++;
}
}
for (int iring = 0; iring < 40 ; iring++){
if ( hstatprecisionAll[iring]->GetEntries() == 0) continue;
float e = 0.5*hcmap2[0]-> GetYaxis()->GetBinWidth(1);
fgaus->SetParameter(1,1);
fgaus->SetParameter(2,hstatprecisionAll[iring]->GetRMS());
fgaus->SetRange(-5*hstatprecisionAll[iring]->GetRMS(),5*hstatprecisionAll[iring]->GetRMS());
TString name = Form("ffAll%d",iring);
hstatprecisionAll[iring]->Fit("fgaus","QR");
statprecision_vs_ring[2]-> SetPoint(n[2],iring,fgaus->GetParameter(2));
statprecision_vs_ring[2]-> SetPointError(n[2],e,fgaus->GetParError(2));
n[2]++;
}
TH1F *hresidual[3];
hresidual[0] = new TH1F("hresidualEEM","hresidualEEM",1000,0,1);
hresidual[1] = new TH1F("hresidualEEP","hresidualEEP",1000,0,1);
hresidual[2] = new TH1F("hresidualAll","hresidualAll",1000,0,1);
TH1F *hstat[3];
hstat[0] = new TH1F("hstatEEM","hstatEEM",1000,0,0.5);
hstat[1] = new TH1F("hstatEEP","hstatEEP",1000,0,0.5);
hstat[2] = new TH1F("hstatAll","hstatAll",1000,0,0.5);
TH1F *hspre[3];
hspre[0] = new TH1F("hspreEEM","hspreEEM",1000,0,0.5);
hspre[1] = new TH1F("hspreEEP","hspreEEP",1000,0,0.5);
hspre[2] = new TH1F("hspreAll","hspreAll",1000,0,0.5);
/// Residual spread plot
for (int k = 0; k < 3 ; k++){
for (int i= 0; i < statprecision_vs_ring[k]-> GetN(); i++){
double spread, espread;
double stat, estat;
double residual, eresidual;
double xdummy,ex;
sigma_vs_ring[k]-> GetPoint(i, xdummy, spread );
espread = sigma_vs_ring[k]-> GetErrorY(i);
statprecision_vs_ring[k]-> GetPoint(i, xdummy, stat );
estat = statprecision_vs_ring[k]-> GetErrorY(i);
ex = statprecision_vs_ring[k]-> GetErrorX(i);
if (spread > stat ){
residual = sqrt( spread*spread - stat*stat );
eresidual = sqrt( pow(spread*espread,2) + pow(stat*estat,2))/residual;
}
else {
residual = 0;
eresidual = 0;
}
residual_vs_ring[k]->SetPoint(i,xdummy, residual);
residual_vs_ring[k]->SetPointError(i,ex,eresidual);
}
}
}
///-----------------------------------------------------------------
///--- Draw plots
///-----------------------------------------------------------------
TCanvas *cEEP[12];
TCanvas *cEEM[12];
/// --- plot 0 : map of coefficients
cEEP[0] = new TCanvas("cmapEEP","cmapEEP");
cEEP[0] -> cd();
cEEP[0]->SetLeftMargin(0.1);
cEEP[0]->SetRightMargin(0.13);
cEEP[0]->SetGridx();
cEEP[0]->SetGridy();
// hcmap[1]->GetXaxis()->SetNdivisions(1020);
hcmap[1]->GetXaxis() -> SetLabelSize(0.03);
hcmap[1]->Draw("COLZ");
hcmap[1]->GetXaxis() ->SetTitle("ix");
hcmap[1]->GetYaxis() ->SetTitle("iy");
hcmap[1]->GetZaxis() ->SetRangeUser(0.8,1.2);
cEEM[0] = new TCanvas("cmapEEM","cmapEEM");
cEEM[0] -> cd();
cEEM[0]->SetLeftMargin(0.1);
cEEM[0]->SetRightMargin(0.13);
cEEM[0]->SetGridx();
cEEM[0]->SetGridy();
//hcmap[0]->GetXaxis()->SetNdivisions(1020);
hcmap[0]->GetXaxis() -> SetLabelSize(0.03);
hcmap[0]->Draw("COLZ");
hcmap[0]->GetXaxis() ->SetTitle("ix");
hcmap[0]->GetYaxis() ->SetTitle("iy");
hcmap[0]->GetZaxis() ->SetRangeUser(0.8,1.2);
/// --- plot 1 : ring precision vs ieta
cEEP[1] = new TCanvas("csigmaEEP","csigmaEEP");
cEEP[1]->SetGridx();
cEEP[1]->SetGridy();
sigma_vs_ring[1]->GetHistogram()->GetYaxis()-> SetRangeUser(0.00,0.20);
sigma_vs_ring[1]->GetHistogram()->GetXaxis()-> SetRangeUser(-85,85);
sigma_vs_ring[1]->GetHistogram()->GetYaxis()-> SetTitle("#sigma_{c}");
sigma_vs_ring[1]->GetHistogram()->GetXaxis()-> SetTitle("ring");
sigma_vs_ring[1]->Draw("ap");
if (evalStat){
statprecision_vs_ring[1]->Draw("psame");
sigma_vs_ring[1]->Draw("psame");
TLegend * leg = new TLegend(0.6,0.7,0.89, 0.89);
leg->SetFillColor(0);
leg->AddEntry(statprecision_vs_ring[1],"statistical precision", "LP");
leg->AddEntry(sigma_vs_ring[1],"spread", "LP");
leg->Draw("same");
}
cEEM[1] = new TCanvas("csigmaEEM","csigmaEEM");
cEEM[1]->SetGridx();
cEEM[1]->SetGridy();
sigma_vs_ring[0]->GetHistogram()->GetYaxis()-> SetRangeUser(0.00,0.20);
sigma_vs_ring[0]->GetHistogram()->GetXaxis()-> SetRangeUser(-85,85);
sigma_vs_ring[0]->GetHistogram()->GetYaxis()-> SetTitle("#sigma_{c}");
sigma_vs_ring[0]->GetHistogram()->GetXaxis()-> SetTitle("ring");
sigma_vs_ring[0]->Draw("ap");
if (evalStat){
statprecision_vs_ring[0]->Draw("psame");
sigma_vs_ring[0]->Draw("psame");
TLegend * leg = new TLegend(0.6,0.7,0.89, 0.89);
leg->SetFillColor(0);
leg->AddEntry(statprecision_vs_ring[0],"statistical precision", "LP");
leg->AddEntry(sigma_vs_ring[0],"spread", "LP");
leg->Draw("same");
}
/// --- plot 5 : statistical precision vs ieta
if (evalStat){
cEEP[5] = new TCanvas("cstat","cstat");
cEEP[5]->SetGridx();
cEEP[5]->SetGridy();
statprecision_vs_ring[1]->GetHistogram()->GetYaxis()-> SetRangeUser(0.0001,0.10);
statprecision_vs_ring[1]->GetHistogram()->GetXaxis()-> SetRangeUser(-85,85);
statprecision_vs_ring[1]->GetHistogram()->GetYaxis()-> SetTitle("#sigma((c_{P}-c_{D})/(c_{P}+c_{D}))");
statprecision_vs_ring[1]->GetHistogram()->GetXaxis()-> SetTitle("i#eta");
statprecision_vs_ring[1]->Draw("ap");
cEEP[6] = new TCanvas("cresidualP","cresidualP");
cEEP[6]->SetGridx();
cEEP[6]->SetGridy();
residual_vs_ring[1]->GetHistogram()->GetYaxis()-> SetRangeUser(0.0001,0.10);
residual_vs_ring[1]->GetHistogram()->GetXaxis()-> SetRangeUser(-85,85);
residual_vs_ring[1]->GetHistogram()->GetYaxis()-> SetTitle("residual spread");
residual_vs_ring[1]->GetHistogram()->GetXaxis()-> SetTitle("i#eta");
residual_vs_ring[1]->Draw("ap");
cEEM[5] = new TCanvas("cstatM","cstatM");
cEEM[5]->SetGridx();
cEEM[5]->SetGridy();
statprecision_vs_ring[0]->GetHistogram()->GetYaxis()-> SetRangeUser(0.0001,0.10);
statprecision_vs_ring[0]->GetHistogram()->GetXaxis()-> SetRangeUser(-85,85);
statprecision_vs_ring[0]->GetHistogram()->GetYaxis()-> SetTitle("#sigma((c_{P}-c_{D})/(c_{P}+c_{D}))");
statprecision_vs_ring[0]->GetHistogram()->GetXaxis()-> SetTitle("i#eta");
statprecision_vs_ring[0]->Draw("ap");
cEEM[6] = new TCanvas("cresidualM","cresidualM");
cEEM[6]->SetGridx();
cEEM[6]->SetGridy();
residual_vs_ring[0]->GetHistogram()->GetYaxis()-> SetRangeUser(0.0001,0.10);
residual_vs_ring[0]->GetHistogram()->GetXaxis()-> SetRangeUser(-85,85);
residual_vs_ring[0]->GetHistogram()->GetYaxis()-> SetTitle("residual spread");
residual_vs_ring[0]->GetHistogram()->GetXaxis()-> SetTitle("i#eta");
residual_vs_ring[0]->Draw("ap");
cEEP[8] = new TCanvas("csigmaFolded","csigmaFolded");
cEEP[8]->SetGridx();
cEEP[8]->SetGridy();
sigma_vs_ring[2]->GetHistogram()->GetYaxis()-> SetRangeUser(0.00,0.20);
sigma_vs_ring[2]->GetHistogram()->GetXaxis()-> SetRangeUser(-85,85);
sigma_vs_ring[2]->GetHistogram()->GetYaxis()-> SetTitle("#sigma_{c}");
sigma_vs_ring[2]->GetHistogram()->GetXaxis()-> SetTitle("ring");
sigma_vs_ring[2]->Draw("ap");
if (evalStat){
statprecision_vs_ring[2]->Draw("psame");
sigma_vs_ring[2]->Draw("psame");
TLegend * leg = new TLegend(0.6,0.7,0.89, 0.89);
leg->SetFillColor(0);
leg->AddEntry(statprecision_vs_ring[2],"statistical precision", "LP");
leg->AddEntry(sigma_vs_ring[2],"spread", "LP");
leg->Draw("same");
}
cEEP[9] = new TCanvas("cresidualFolded","cresidualFolded");
cEEP[9]->SetGridx();
cEEP[9]->SetGridy();
residual_vs_ring[2]->GetHistogram()->GetYaxis()-> SetRangeUser(0.0001,0.10);
residual_vs_ring[2]->GetHistogram()->GetXaxis()-> SetRangeUser(-85,85);
residual_vs_ring[2]->GetHistogram()->GetYaxis()-> SetTitle("residual spread");
residual_vs_ring[2]->GetHistogram()->GetXaxis()-> SetTitle("i#eta");
residual_vs_ring[2]->Draw("ap");
/// save precision for MC comparison
if(isMC==true)
{
TFile * output = new TFile ("StatPrec_MC_EE.root","RECREATE");
output->cd();
statprecision_vs_ring[0]->SetName("gr_stat_prec_EEP");
statprecision_vs_ring[1]->SetName("gr_stat_prec_EEM");
statprecision_vs_ring[2]->SetName("gr_stat_prec");
statprecision_vs_ring[0]->Write();
statprecision_vs_ring[1]->Write();
statprecision_vs_ring[2]->Write();
}
}
/// Comparison Plot MC - Data
TCanvas* canEEP[10], *canEEM[10];
if(isMC == true)
{
canEEM[0] = new TCanvas("ICComparison MC EEM","ICComparison MC EEM");
canEEM[0]->SetGridx();
canEEM[0]->SetGridy();
ICComparison[0]->GetXaxis() -> SetLabelSize(0.03);
ICComparison[0]->Draw("COLZ");
ICComparison[0]->GetXaxis() ->SetTitle("ix");
ICComparison[0]->GetYaxis() ->SetTitle("iy");
ICComparison[0]->GetZaxis() ->SetRangeUser(0.85,1.15);
canEEP[0] = new TCanvas("ICComparison MC EEP","ICComparison MC EEP");
canEEP[0]->SetGridx();
canEEP[0]->SetGridy();
ICComparison[1]->GetXaxis() -> SetLabelSize(0.03);
ICComparison[1]->Draw("COLZ");
ICComparison[1]->GetXaxis() ->SetTitle("ix");
ICComparison[1]->GetYaxis() ->SetTitle("iy");
ICComparison[1]->GetZaxis() ->SetRangeUser(0.85,1.15);
TFile* output = new TFile ("IC_MC_4Correction.root","RECREATE");
output->cd();
ICComparison[0]->Write();
ICComparison[1]->Write();
output->Close();
}
TFile *exisistingEE = new TFile ("existingEE.root","READ");
TH2F* exmap = (TH2F*) exisistingEE->Get("endcap");
TH2F* warning_Map_EEP = (TH2F*) exmap->Clone("warning_Map_EEP");
warning_Map_EEP->Reset("ICMES");
warning_Map_EEP->Reset();
TH2F* warning_Map_EEM = (TH2F*) exmap->Clone("warning_Map_EEM");
warning_Map_EEM->Reset("ICMES");
warning_Map_EEM->Reset();
if(isMC == false)
{
std::ofstream outTxt ("Calibration_Coefficient_EE_dinamic_alpha.txt",std::ios::out);
outTxt << "---------------------------------------------------------------" << std::endl;
outTxt << std::fixed << std::setprecision(0) << std::setw(10) << "iX"
<< std::fixed << std::setprecision(0) << std::setw(10) << "iY"
<< std::fixed << std::setprecision(0) << std::setw(10) << "iZ"
<< std::fixed << std::setprecision(6) << std::setw(15) << "IC"
<< std::fixed << std::setprecision(6) << std::setw(15) << "error"
<< std::endl;
outTxt << "---------------------------------------------------------------" << std::endl;
for (int ix = 1; ix < hcmap[0]->GetNbinsX()+1 ; ix ++)
{
for (int iy = 1; iy < hcmap[0] -> GetNbinsY()+1; iy++)
{
if( exmap->GetBinContent(ix,iy) !=1) continue;
double x,statPrec;
statprecision_vs_ring[0]->GetPoint(hrings[0]->GetBinContent(ix,iy),x,statPrec);
outTxt << std::fixed << std::setprecision(0) << std::setw(10) << hcmap[0]->GetXaxis()->GetBinLowEdge(ix)
<< std::fixed << std::setprecision(0) << std::setw(10) << hcmap[0]->GetYaxis()->GetBinLowEdge(iy)
<< std::fixed << std::setprecision(0) << std::setw(10) << "-1";
if( hcmap[0]->GetBinContent(ix,iy) == 0. )
{
outTxt << std::fixed << std::setprecision(6) << std::setw(15) << "-1."
<< std::fixed << std::setprecision(6) << std::setw(15) << "999."
<< std::endl;
}
else
{
outTxt << std::fixed << std::setprecision(6) << std::setw(15) << hcmap[0]->GetBinContent(ix,iy)
<< std::fixed << std::setprecision(6) << std::setw(15) << statPrec
<< std::endl;
//warning_Map_EEM->Fill(ix,iy);
}
}
}
for (int ix = 1; ix < hcmap[1]->GetNbinsX()+1 ; ix ++)
{
for (int iy = 1; iy < hcmap[1] -> GetNbinsY()+1; iy++)
{
if( exmap->GetBinContent(ix,iy) !=1) continue;
double x,statPrec;
statprecision_vs_ring[1]->GetPoint(hrings[1]->GetBinContent(ix,iy),x,statPrec);
outTxt << std::fixed << std::setprecision(0) << std::setw(10) << hcmap[1]->GetXaxis()->GetBinLowEdge(ix)
<< std::fixed << std::setprecision(0) << std::setw(10) << hcmap[1]->GetYaxis()->GetBinLowEdge(iy)
<< std::fixed << std::setprecision(0) << std::setw(10) << "1";
if( hcmap[1]->GetBinContent(ix,iy) == 0. )
{
outTxt << std::fixed << std::setprecision(6) << std::setw(15) << "-1."
<< std::fixed << std::setprecision(6) << std::setw(15) << "999."
<< std::endl;
}
else
{
outTxt << std::fixed << std::setprecision(6) << std::setw(15) << hcmap[1]->GetBinContent(ix,iy)
<< std::fixed << std::setprecision(6) << std::setw(15) << statPrec
<< std::endl;
//warning_Map_EEM->Fill(ix,iy);
}
}
}
}
canEEP[1] = new TCanvas("Warning_EEP","Warning_EEP");
canEEP[1]->SetGridx();
canEEP[1]->SetGridy();
warning_Map_EEP->GetXaxis() -> SetLabelSize(0.03);
warning_Map_EEP->Draw("COLZ");
warning_Map_EEP->GetXaxis() ->SetTitle("ix");
warning_Map_EEP->GetYaxis() ->SetTitle("iy");
warning_Map_EEP->GetZaxis() ->SetRangeUser(0.85,1.15);
canEEM[1] = new TCanvas("Warning_EEM","Warning_EEM");
canEEM[1]->SetGridx();
canEEM[1]->SetGridy();
warning_Map_EEM->GetXaxis() -> SetLabelSize(0.03);
warning_Map_EEM->Draw("COLZ");
warning_Map_EEM->GetXaxis() ->SetTitle("ix");
warning_Map_EEM->GetYaxis() ->SetTitle("iy");
warning_Map_EEM->GetZaxis() ->SetRangeUser(0.85,1.15);
}
void DoAnalysisWithTree(TFile* file, int run, int x, int y)
{
gout << 0 << " " << run << " " << x << " " << y << " ";
TF1* flandau = new TF1("flandau","landau",0,400);
TCanvas *c1 = new TCanvas("c1","",1280,960);
c1->Divide(4,2);
TCanvas *c2 = new TCanvas("c2","",1280,960);
c2->Divide(4,2);
TCanvas *c3 = new TCanvas("c3","",1280,960);
c3->Divide(4,2);
TCanvas *c4 = new TCanvas("c4","",1280,960);
c4->Divide(4,2);
TTree* tree = (TTree*)file->Get("T");
tree->SetAlias("Average_HODO_HORIZONTAL","Sum$(TOWER_CALIB_HODO_HORIZONTAL.towerid * (abs(TOWER_CALIB_HODO_HORIZONTAL.energy)>30) * abs(TOWER_CALIB_HODO_HORIZONTAL.energy))/Sum$((abs(TOWER_CALIB_HODO_HORIZONTAL.energy)>30) * abs(TOWER_CALIB_HODO_HORIZONTAL.energy))");
tree->SetAlias("Average_HODO_VERTICAL","Sum$(TOWER_CALIB_HODO_VERTICAL.towerid * (abs(TOWER_CALIB_HODO_VERTICAL.energy)>30) * abs(TOWER_CALIB_HODO_VERTICAL.energy))/Sum$((abs(TOWER_CALIB_HODO_VERTICAL.energy)>30) * abs(TOWER_CALIB_HODO_VERTICAL.energy))");
tree->SetAlias("Valid_HODO_HORIZONTAL","Sum$(abs(TOWER_CALIB_HODO_HORIZONTAL.energy)>30) > 0");
tree->SetAlias("Valid_HODO_VERTICAL","Sum$(abs(TOWER_CALIB_HODO_VERTICAL.energy)>30) > 0");
ofstream fout((const char*)Form("DataRunByRun/mapper_run%d.dat",run));
for ( int i = 0; i < 8; ++i )
{
TString drawstring1 = "TOWER_CALIB_TILE_MAPPER[";
drawstring1 += i*2;
drawstring1 += "].energy>>hs1_";
drawstring1 += i+1;
drawstring1 += "(100,0,400)";
c1->cd(i+1);
tree->Fit("flandau",drawstring1,"","","");
TString drawstring2 = "TOWER_CALIB_TILE_MAPPER[";
drawstring2 += i*2;
drawstring2 += "].energy>>hs2_";
drawstring2 += i+1;
drawstring2 += "(100,0,400)";
c2->cd(i+1);
tree->Fit("flandau",drawstring2,"Valid_HODO_VERTICAL && Valid_HODO_HORIZONTAL","","");
fout << run << " " << 9999 << " " << 9999 << " " << flandau->GetParameter(1) << " " << flandau->GetParError(1) << endl;
gout << flandau->GetParameter(1) << " " << flandau->GetParError(1) << " ";
TString drawstring3 = "TOWER_CALIB_TILE_MAPPER[";
drawstring3 += i*2;
drawstring3 += "].energy>>hs3_";
drawstring3 += i+1;
drawstring3 += "(100,0,400)";
c3->cd(i+1);
tree->Fit("flandau",drawstring3,"Valid_HODO_VERTICAL && Valid_HODO_HORIZONTAL && abs(TOWER_CALIB_C2[3].energy)<200","","");
TString drawstring4 = "TOWER_CALIB_TILE_MAPPER[";
drawstring4 += i*2;
drawstring4 += "].energy>>hs4_";
drawstring4 += i+1;
drawstring4 += "(100,0,400)";
c4->cd(i+1);
tree->Fit("flandau",drawstring4,"Valid_HODO_VERTICAL && Valid_HODO_HORIZONTAL && abs(TOWER_CALIB_C2[3].energy)>200","","");
}
c1->Print(Form("FigsRunByRun/mapper_run%d_step1.png",run));
c2->Print(Form("FigsRunByRun/mapper_run%d_step2.png",run));
c3->Print(Form("FigsRunByRun/mapper_run%d_step3.png",run));
c4->Print(Form("FigsRunByRun/mapper_run%d_step4.png",run));
c1->Print(Form("FigsRunByRun/mapper_run%d_step1.pdf",run));
c2->Print(Form("FigsRunByRun/mapper_run%d_step2.pdf",run));
c3->Print(Form("FigsRunByRun/mapper_run%d_step3.pdf",run));
c4->Print(Form("FigsRunByRun/mapper_run%d_step4.pdf",run));
delete c1;
delete c2;
delete c3;
delete c4;
gout << endl;
return;
// --- let's try to have a look at the hodoscope positions
TCanvas* c5 = new TCanvas("c5","",800,800);
TH2D* th2d_hodo_fine = new TH2D("th2d_hodo_fine","",40,-0.5,7.5,40,-0.5,7.5);
TH2D* th2d_hodo_coarse = new TH2D("th2d_hodo_coarse","",8,-0.5,7.5,8,-0.5,7.5);
th2d_hodo_fine->GetXaxis()->SetTitle("Horizontal Hodoscope");
th2d_hodo_fine->GetYaxis()->SetTitle("Vertical Hodoscope");
th2d_hodo_coarse->GetXaxis()->SetTitle("Horizontal Hodoscope");
th2d_hodo_coarse->GetYaxis()->SetTitle("Vertical Hodoscope");
tree->Draw("Average_HODO_HORIZONTAL:Average_HODO_VERTICAL>>th2d_hodo_fine","Valid_HODO_VERTICAL && Valid_HODO_HORIZONTAL","colz");
c5->Print(Form("FigsRunByRun/hodoscope_fine_run%d.png",run));
c5->Print(Form("FigsRunByRun/hodoscope_fine_run%d.pdf",run));
tree->Draw("Average_HODO_HORIZONTAL:Average_HODO_VERTICAL>>th2d_hodo_coarse","Valid_HODO_VERTICAL && Valid_HODO_HORIZONTAL","colz");
c5->Print(Form("FigsRunByRun/hodoscope_coarse_run%d.png",run));
c5->Print(Form("FigsRunByRun/hodoscope_coarse_run%d.pdf",run));
delete c5;
// --- now lets try to look at the distributions for each hodoscope position
TCanvas* c6 = new TCanvas("c6","",1280,960);
c6->Divide(4,2);
for ( int indexHorizontal = 0; indexHorizontal < 8; ++indexHorizontal)
{
for ( int indexVertical = 0; indexVertical < 8; ++indexVertical )
{
for ( int indexTile = 0; indexTile < 8; ++indexTile )
{
TString drawstring = "TOWER_CALIB_TILE_MAPPER[";
drawstring += indexTile*2;
drawstring += "].energy>>hs_";
drawstring += indexTile+1;
drawstring += "(100,0,400)";
cout << "drawstring is " << drawstring << endl;
TString cutstring = "Valid_HODO_VERTICAL && Valid_HODO_HORIZONTAL";
cutstring += " && abs(Average_HODO_HORIZONTAL-";
cutstring += indexHorizontal;
cutstring += ")<0.5";
cutstring += " && abs(Average_HODO_VERTICAL-";
cutstring += indexVertical;
cutstring += ")<0.5";
cout << "cutstring is " << cutstring << endl;
c6->cd(indexTile+1);
tree->Fit("flandau",drawstring,cutstring,"","");
fout << run << " " << indexHorizontal << " " << indexVertical << " " << flandau->GetParameter(1) << " " << flandau->GetParError(1) << endl;
}
c6->Print(Form("FigsRunByRun/HodoscopeGridFigs/mapper_run%d_H%dV%d.png",run,indexHorizontal,indexVertical));
c6->Print(Form("FigsRunByRun/HodoscopeGridFigs/mapper_run%d_H%dV%d.pdf",run,indexHorizontal,indexVertical));
}
}
fout.close();
delete c6;
}
double extractLimitAtQuantile(TString inFileName, TString plotName, double d_quantile ){
TFile *f = TFile::Open(inFileName);
TF1 *expoFit = new TF1("expoFit","[0]*exp([1]*(x-[2]))", rMin, rMax);
TGraphErrors *limitPlot_ = new TGraphErrors();
/* bool done = false; */
if (_debug > 0) std::cout << "Search for upper limit using pre-computed grid of p-values" << std::endl;
readAllToysFromFile(limitPlot_, f, d_quantile );
f->Close();
limitPlot_->Sort();
double minDist=1e3;
int n= limitPlot_->GetN();
cout<<" Number of points in limitPlot_ : "<<n<<endl;
if(n<=0) return 0;
clsMin.first=0;
clsMin.second=0;
clsMax.first=0;
clsMax.second=0;
limit = 0; limitErr = 0;
for (int i = 0; i < n; ++i) {
double x = limitPlot_->GetX()[i], y = limitPlot_->GetY()[i]; //, ey = limitPlot_->GetErrorY(i);
if (fabs(y-clsTarget) < minDist) { limit = x; minDist = fabs(y-clsTarget); }
}
int ntmp =0;
for (int j = 0; j < n; ++j) {
int i = n-j-1;
double x = limitPlot_->GetX()[i], y = limitPlot_->GetY()[i], ey = limitPlot_->GetErrorY(i);
if (y-3*ey >= clsTarget && ntmp<=2) {
rMin = x; clsMin = CLs_t(y,ey);
ntmp ++ ;
}
}
ntmp =0;
for (int i = 0; i < n; ++i) {
double x = limitPlot_->GetX()[i], y = limitPlot_->GetY()[i], ey = limitPlot_->GetErrorY(i);
if (y+3*ey <= clsTarget && ntmp<=2) {
rMax = x; clsMax = CLs_t(y,ey);
ntmp ++ ;
}
}
if((clsMin.first==0 and clsMin.second==0) )
{
rMin = limitPlot_->GetX()[0]; clsMin=CLs_t(limitPlot_->GetY()[0], limitPlot_->GetErrorY(0));
}
if((clsMax.first==0 and clsMax.second==0))
{
rMax = limitPlot_->GetX()[n-1]; clsMax=CLs_t(limitPlot_->GetY()[n-1], limitPlot_->GetErrorY(n-1));
}
if (_debug > 0) std::cout << " after scan x ~ " << limit << ", bounds [ " << rMin << ", " << rMax << "]" << std::endl;
limitErr = std::max(limit-rMin, rMax-limit);
expoFit->SetRange(rMin,rMax);
//expoFit.SetRange(limitPlot_->GetXaxis()->GetXmin(),limitPlot_->GetXaxis()->GetXmax());
//expoFit->SetRange(1.7,2.25);
if (limitErr < std::max(rAbsAccuracy_, rRelAccuracy_ * limit)) {
if (_debug > 1) std::cout << " reached accuracy " << limitErr << " below " << std::max(rAbsAccuracy_, rRelAccuracy_ * limit) << std::endl;
/* done = true; */
}
//if (!done) { // didn't reach accuracy with scan, now do fit
if (1) { // didn't reach accuracy with scan, now do fit
if (_debug) {
std::cout << "\n -- HybridNew, before fit -- \n";
std::cout << "Limit: r" << " < " << limit << " +/- " << limitErr << " [" << rMin << ", " << rMax << "]\n";
std::cout<<"rMin="<<rMin<<" clsMin="<<clsMin.first<<", rMax="<<rMax<<" clsMax="<<clsMax.first<<endl;
}
expoFit->FixParameter(0,clsTarget);
expoFit->SetParameter(1,log(clsMax.first/clsMin.first)/(rMax-rMin));
expoFit->SetParameter(2,limit);
double rMinBound, rMaxBound; expoFit->GetRange(rMinBound, rMaxBound);
limitErr = std::max(fabs(rMinBound-limit), fabs(rMaxBound-limit));
int npoints = 0;
for (int j = 0; j < limitPlot_->GetN(); ++j) {
if (limitPlot_->GetX()[j] >= rMinBound && limitPlot_->GetX()[j] <= rMaxBound) npoints++;
}
for (int i = 0, imax = 0; i <= imax; ++i, ++npoints) {
limitPlot_->Sort();
limitPlot_->Fit(expoFit,(_debug <= 1 ? "QNR EX0" : "NR EXO"));
if (_debug) {
std::cout << "Fit to " << npoints << " points: " << expoFit->GetParameter(2) << " +/- " << expoFit->GetParError(2) << std::endl;
}
// only when both "cls+3e<0.05 and cls-3e>0.05" are satisfied, we require below ...
// if ((rMin < expoFit->GetParameter(2)) && (expoFit->GetParameter(2) < rMax) && (expoFit->GetParError(2) < 0.5*(rMaxBound-rMinBound))) {
// sanity check fit result
limit = expoFit->GetParameter(2);
limitErr = expoFit->GetParError(2);
if (limitErr < std::max(rAbsAccuracy_, rRelAccuracy_ * limit)) break;
// }
}
}
if (limitPlot_) {
TCanvas *c1 = new TCanvas("c1","c1");
limitPlot_->Sort();
limitPlot_->SetLineWidth(2);
double rMinBound, rMaxBound; expoFit->GetRange(rMinBound, rMaxBound);
if(bPlotInFittedRange){
limitPlot_->GetXaxis()->SetRangeUser(rMinBound, rMaxBound);
limitPlot_->GetYaxis()->SetRangeUser(0.5*clsTarget, 1.5*clsTarget);
}
limitPlot_->Draw("AP");
expoFit->Draw("SAME");
TLine line(limitPlot_->GetX()[0], clsTarget, limitPlot_->GetX()[limitPlot_->GetN()-1], clsTarget);
line.SetLineColor(kRed); line.SetLineWidth(2); line.Draw();
line.DrawLine(limit, 0, limit, limitPlot_->GetY()[0]);
line.SetLineWidth(1); line.SetLineStyle(2);
line.DrawLine(limit-limitErr, 0, limit-limitErr, limitPlot_->GetY()[0]);
line.DrawLine(limit+limitErr, 0, limit+limitErr, limitPlot_->GetY()[0]);
limitPlot_->SetTitle(";#mu;CLs");
c1->Print(plotName+".gif");
c1->Print(plotName+".root");
if(_debug)limitPlot_->Print("v");
}
std::cout << "\n -- Hybrid New -- \n";
if(limit<0) { limit=0; cout<<" WARNING: fitted limit <0, need more toys and more points of signal strength"<<endl; }
std::cout << "Limit: r" << " < " << limit << " +/- " << limitErr << " @ " << (1-clsTarget) * 100 << "% CL\n";
return limit;
}
void mk_sigaccjecupdown(string flavor = "112", const string uncert = "jec")
{
// gStyle->SetOptFit(1100); // chi2 and prob, not parameters
// gStyle->SetOptFit(1); // chi2 and prob, not parameters
// gStyle->SetOptStat("irme"); // integral, RMS, mean, # of entries
// gStyle->SetStatFontSize(0.005);
// gStyle->SetStatY(0.4);
TLatex * tex = new TLatex(0.678392,0.9283217,"CMS Preliminary 9.95 fb^{-1} at #sqrt{s} = 8 TeV");
tex->SetNDC();
tex->SetTextAlign(22);
tex->SetTextFont(42);
// tex->SetTextSize(0.03846154);
tex->SetLineWidth(2);
cout<<"blabl"<<endl;
// for(int k=0; k<3; k++){
// for(int k=0; k<2; k++){
for(int k=2; k<3; k++) {
//Which plots to make
//define input variables
vector <string > namelist;
vector <string > VarList;
vector <TFile* > data;
vector <TFile* > filelist;
vector <TFile* > filelist_btag;
vector <TFile* > filelist_2D;
vector <TFile* > filelist_kin;
vector <TFile* > filelist_param;
vector <TFile* > filelist_diag;
vector <TFile* > filelist_stealth;
vector <TFile* > filelist0b;
vector <float > EvtGen;
vector <float > Xsec;
vector <float > GlunioMass;
vector<float> nEvtTot;
vector<float> McXsec;
vector<float> lumis;
vector<float> DataLumi;
vector<float> GaussMeanIni;
vector<float> LeftEdge;
vector<float> RightEdge;
vector<vector<float > > MassBins;
// string uncert="btagup";
// if(k==1) uncert="btagdown";
// if(k==1) uncert="down";
// if(k==2) uncert="";
namelist.push_back("KinematicOptimization");
// filelist_kin.push_back(TFile::Open(("Acc_Gluino_NoLumi_pt110_8TeVxsec_BtagMap_2500GeV"+uncert+".root").c_str()));
// filelist_kin.push_back(TFile::Open("Acc_Gluino_NoLumi_pt60_pt110_8TeVxsec_BtagMap.root"));
// filelist_kin.push_back(TFile::Open(("Acc_RPV112" + uncert + ".root").c_str()));
filelist_kin.push_back(TFile::Open(("Acc_RPV" + flavor + "_Sph4.root").c_str()));
filelist_kin.push_back(TFile::Open(("Acc_RPV" + flavor + uncert + "up_Sph4.root").c_str()));
filelist_kin.push_back(TFile::Open(("Acc_RPV" + flavor + uncert + "down_Sph4.root").c_str()));
// filelist_kin.push_back(TFile::Open(("Acc_Gluino_NoLumi_pt60_pt110_8TeVxsec_BtagMap" + uncert + ".root").c_str()));
TFile f1(("RPV_" + flavor + "_accandwdith"+uncert+".root").c_str(), "recreate");
f1.cd();
string nameIN;
string cuts;
string prefix;
string postfix;
string folder;
string ptcut;
folder="plots/";
postfix=".pdf";
/////////////Plots for each Mass separatly//////////////
/////////////----------------------------------------/////////////
for (int p = 0; p < 2; p++) {
// ptcut="112";
// if(p==1) ptcut="" + flavor;
ptcut="60";
if(p==1) ptcut="110";
///////////////////////////////////////////////////////////////////
///////////Plot nice Mjjj plots
//////////////////////////////////////////////////////////////////
// string histname = string("GausWidth_vs_Mass_112") + ptcut;
string histname = string("GausWidth_vs_Mass_" + flavor) + "_" + ptcut;
cout<< histname << endl;
TGraphErrors *h_gauswidth = (TGraphErrors*) filelist_kin[0]->Get(histname.c_str())->Clone();
TGraphErrors *h_gauswidthup = (TGraphErrors*) filelist_kin[1]->Get(histname.c_str())->Clone();
TGraphErrors *h_gauswidthdown = (TGraphErrors*) filelist_kin[2]->Get(histname.c_str())->Clone();
histname = string("GausAcceptance_vs_Mass_" + flavor) + "_" + ptcut;
// histname = string("GausAcceptance_vs_Mass_112") + ptcut;
cout<< histname << endl;
TGraphErrors *h_gausacc = (TGraphErrors*) filelist_kin[0]->Get(histname.c_str())->Clone();
TGraphErrors *h_gausaccup = (TGraphErrors*) filelist_kin[1]->Get(histname.c_str())->Clone();
TGraphErrors *h_gausaccdown = (TGraphErrors*) filelist_kin[2]->Get(histname.c_str())->Clone();
TCanvas * cGluinoFitsOpti = new TCanvas(("RPV_"+ptcut+"_"+cuts).c_str(), ("RPV_" + ptcut+"_"+cuts).c_str(), 800, 600);
//h_gauswidth->SetFillColor(kOrange-2);
// h_gauswidth->SetLineColor(kBlack);
string title;
string systematic = "pile-up";
// title="Gaussian Width vs. Mass for Light-ptcut RPV";
string tag = "Heavy", sphericity = " Sphericity Cut";
if (flavor.compare("112") == 0)
tag = "Light";
else if (ptcut == "60")
sphericity = "";
string titlepart = tag + "-flavor RPV " + flavor + " p_{T} = " + ptcut + sphericity;
title = "Width for " + titlepart;
/*
if(k==0){
title="RPV gluino #bf{" + systematic + " up} m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 60 GeV}";
if (i>=5 || p==0) title="RPV gluino #bf{" + systematic + " up} m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 110 GeV}";
}
if(k==1){
title="RPV gluino #bf{" + systematic + " down} m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 60 GeV}";
if (i>=5 || p==0) title="RPV gluino #bf{" + systematic + " down} m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 110 GeV}";
}
if(k==2){
title="RPV gluino m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 60 GeV}";
if (i>=5 || p==0) title="RPV gluino m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 110 GeV}";
}
*/
TLegend *leg;
leg = new TLegend(0.6,0.2,0.8994975,0.5,NULL,"brNDC");
float linesiz = 2.0;
h_gauswidthup->SetLineColor(kBlue);
h_gauswidthup->SetLineWidth(linesiz);
h_gauswidthup->SetMarkerColor(kBlue);
TF1 *fitfunc = h_gauswidthup->GetFunction("GausWidth");
if (fitfunc != NULL)
fitfunc->SetLineColor(kBlue);
leg->AddEntry(h_gauswidthup,"JES up", "L");
h_gauswidthup->GetYaxis()->SetTitle("Width [GeV]");
h_gauswidthup->GetYaxis()->SetTitleOffset(1.3);
h_gauswidthup->GetXaxis()->SetTitle("RPV Mass [GeV]");
h_gauswidthup->SetTitle(title.c_str());
h_gauswidthup->Draw("A*");
fitfunc = h_gauswidth->GetFunction("GausWidth");
if (fitfunc != NULL)
fitfunc->SetLineColor(kBlack);
else cout << "Bad func name\n";
h_gauswidth->SetLineColor(kBlack);
h_gauswidth->SetMarkerColor(kBlack);
h_gauswidth->SetLineWidth(linesiz);
// h_gauswidth->SetTitleSize(0.01);
// h_gauswidth->Draw("AL");
leg->AddEntry(h_gauswidth,"Nominal JES", "L");
h_gauswidth->Draw("same*");
h_gauswidthdown->SetLineWidth(linesiz);
h_gauswidthdown->SetMarkerColor(kRed);
h_gauswidthdown->SetLineColor(kRed);
fitfunc = h_gauswidthdown->GetFunction("GausWidth");
if (fitfunc != NULL)
fitfunc->SetLineColor(kRed);
leg->AddEntry(h_gauswidthdown,"JES down", "L");
h_gauswidthdown->Draw("same*");
leg->Draw();
cGluinoFitsOpti->Write();
cGluinoFitsOpti->SaveAs((folder + "RPVwidthjesupdn" +flavor + ptcut+uncert+postfix).c_str());
TCanvas * cGluinoFitsOpt2 = new TCanvas(("RPVacc_"+ptcut+"_"+cuts).c_str(), ("RPV_" + ptcut+"_"+cuts).c_str(), 800, 600);
leg = new TLegend(0.6,0.2,0.8994975,0.5,NULL,"brNDC");
title="Acceptance for " + titlepart;
h_gausacc->SetTitle(title.c_str());
h_gausacc->GetYaxis()->SetTitle("Acceptance");
h_gausacc->GetYaxis()->SetTitleOffset(1.4);
h_gausacc->GetXaxis()->SetTitle("RPV Mass [GeV]");
// if (flavor.compare("113_223") == 0 && ptcut == "110") {
// gStyle->SetStatY(0.8);
// h_gausacc->GetYaxis()->SetRangeUser(0.0, 0.035);
//}
fitfunc = h_gausacc->GetFunction("total");
if (fitfunc != NULL)
fitfunc->SetLineColor(kBlack);
else cout << "Bad func name\n";
h_gausacc->SetLineColor(kBlack);
h_gausacc->SetMarkerColor(kBlack);
h_gausacc->SetLineWidth(linesiz);
leg->AddEntry(h_gausacc,"Nominal JES", "L");
// h_gausacc->Draw("AL");
h_gausacc->Draw("A*");
fitfunc = h_gausaccup->GetFunction("total");
if (fitfunc != NULL)
fitfunc->SetLineColor(kBlue);
else cout << "Bad func name\n";
h_gausaccup->SetLineColor(kBlue);
h_gausaccup->SetMarkerColor(kBlue);
h_gausaccup->SetLineWidth(linesiz);
leg->AddEntry(h_gausaccup,"JES up", "L");
h_gausaccup->Draw("same*");
fitfunc = h_gausaccdown->GetFunction("total");
if (fitfunc != NULL)
fitfunc->SetLineColor(kRed);
else cout << "Bad func name\n";
h_gausaccdown->SetLineColor(kRed);
h_gausaccdown->SetMarkerColor(kRed);
h_gausaccdown->SetLineWidth(linesiz);
leg->AddEntry(h_gausaccdown,"JES down", "L");
h_gausaccdown->Draw("same*");
leg->Draw();
cGluinoFitsOpt2->Write();
cGluinoFitsOpt2->SaveAs((folder + "RPVaccjesupdn" +flavor + ptcut+uncert+postfix).c_str());
f1.cd();
/////////////////Make some DataPlots///////////////////////
}
}
}
void Calibrate()
{
TCanvas *mycan1 = (TCanvas*)gROOT->FindObject("mycan1");
if(!mycan1)
{
mycan1 = new TCanvas("mycan1","",1200,1000);
mycan1->Divide(4,4,0.0000001,0.0000001);
}
float energy[2][32][5] = {0.};
float peak[2][32][5] = {0.};
ifstream file("SiCalibPoints.txt");
if(!file.is_open())
{
cout << "No Si Calib Data" << endl;
return;
}
ofstream out("SiRecalib.cal");
int itele = -1;
int istrip = -1;
for(int i = 0;i<64;i++)
{
file >> itele >> istrip;
itele = itele-6;
file >>energy[itele][istrip][0];
file >> energy[itele][istrip][1] >> energy[itele][istrip][2];
file >> energy[itele][istrip][3] >> energy[itele][istrip][4];
file >> peak[itele][istrip][0] >> peak[itele][istrip][1];
file >> peak[itele][istrip][2] >> peak[itele][istrip][3];
file >> peak[itele][istrip][4];
}
float slope = 0.;
float inter = 0.;
for(int i = 0;i<16;i++)
{
mycan1->cd(i+1);
TGraph *mygraph = new TGraph(5,peak[0][i],energy[0][i]);
mygraph->SetMarkerStyle(20);
mygraph->Draw("AP");
TF1 *fit = new TF1("fit","pol1",0,500);
mygraph->Fit("fit","RQ");
slope = fit->GetParameter(1);
inter = fit->GetParameter(0);
cout << istrip <<" Slope = " << slope;
cout << " inter = " << inter << endl;
out << 0 << " " << i << " " << slope << " " << inter << endl;
}
TCanvas *mycan2 = (TCanvas*)gROOT->FindObject("mycan2");
if(!mycan2)
{
mycan2 = new TCanvas("mycan2","",1200,1000);
mycan2->Divide(4,4,0.0000001,0.0000001);
}
for(int i = 0;i<16;i++)
{
int istrip = i+16;
mycan2->cd(i+1);
TGraph *mygraph = new TGraph(5,peak[0][istrip],energy[0][istrip]);
mygraph->SetTitle(Form("Strip %i",istrip));
mygraph->SetMarkerStyle(20);
mygraph->Draw("AP");
TF1 *fit = new TF1("fit","pol1",0,500);
mygraph->Fit("fit","RQ");
cout << istrip << " Slope = " << fit->GetParameter(1);
cout << " inter = " << fit->GetParameter(0) << endl;
slope = fit->GetParameter(1);
inter = fit->GetParameter(0);
out << 0 << " " << istrip << " " << slope << " " << inter << endl;
}
TCanvas *mycan3 = (TCanvas*)gROOT->FindObject("mycan3");
if(!mycan3)
{
mycan3 = new TCanvas("mycan3","",1200,1000);
mycan3->Divide(4,4,0.0000001,0.0000001);
}
for(int i = 0;i<16;i++)
{
int istrip = i;
mycan3->cd(i+1);
TGraph *mygraph = new TGraph(5,peak[1][istrip],energy[1][istrip]);
mygraph->SetTitle(Form("Strip %i",istrip));
mygraph->SetMarkerStyle(20);
mygraph->Draw("AP");
TF1 *fit = new TF1("fit","pol1",0,500);
mygraph->Fit("fit","RQ");
cout << istrip << " Slope = " << fit->GetParameter(1);
cout << " inter = " << fit->GetParameter(0) << endl;
slope = fit->GetParameter(1);
inter = fit->GetParameter(0);
out << 1 << " " << istrip << " " << slope << " " << inter << endl;
}
TCanvas *mycan4 = (TCanvas*)gROOT->FindObject("mycan4");
if(!mycan4)
{
mycan4 = new TCanvas("mycan4","",1200,1000);
mycan4->Divide(4,4,0.0000001,0.0000001);
}
for(int i = 0;i<16;i++)
{
int istrip = i+16;
mycan4->cd(i+1);
TGraph *mygraph = new TGraph(5,peak[1][istrip],energy[1][istrip]);
mygraph->SetTitle(Form("Strip %i",istrip));
mygraph->SetMarkerStyle(20);
mygraph->Draw("AP");
TF1 *fit = new TF1("fit","pol1",0,500);
mygraph->Fit("fit","RQ");
cout << istrip << " Slope = " << fit->GetParameter(1);
cout << " inter = " << fit->GetParameter(0) << endl;
slope = fit->GetParameter(1);
inter = fit->GetParameter(0);
out << 1 << " " << istrip << " " << slope << " " << inter << endl;
}
return;
}
// /r06/lc/sg568/HCAL_Optimisation_Studies/EnergyResolutionResults/Detector_Model_103/Reco_Stage_38/Photon
// EnergyResolution_PandoraSettingsDefault_DetectorModel_103_ReconstructionVariant_38_Photon.root
void DrawNumLayersSiECal100GeV()
{
const int recoVar(71);
const int energy(100);
std::vector<int> detectorModels;
detectorModels.push_back(96);
detectorModels.push_back(97);
detectorModels.push_back(98);
detectorModels.push_back(99);
std::map<int, int> detModelToLayerNumber;
detModelToLayerNumber[96] = 30;
detModelToLayerNumber[97] = 26;
detModelToLayerNumber[98] = 20;
detModelToLayerNumber[99] = 16;
TCanvas *pTCanvas = new TCanvas();
TGraphErrors *pTGraphErrors = new TGraphErrors("EResVsLayer","EResVsLayer");
for (std::vector<int>::iterator it = detectorModels.begin(); it != detectorModels.end(); it++)
{
const int detModel(*it);
const int layerNumber(detModelToLayerNumber.find(detModel)->second);
std::string rootFile("/r06/lc/sg568/HCAL_Optimisation_Studies/EnergyResolutionResults/Detector_Model_" + NumberToString(detModel) + "/Reco_Stage_" + NumberToString(recoVar) + "/Photon/EnergyResolution_PandoraSettingsDefault_DetectorModel_" + NumberToString(detModel) + "_ReconstructionVariant_" + NumberToString(recoVar) + "_Photon.root");
std::cout << rootFile << std::endl;
TFile *pTFile = new TFile(rootFile.c_str());
std::string histogramName("Resolution_DetectorModel_" + NumberToString(detModel) + "_ReconstructionVariant_" + NumberToString(recoVar) + "/PFOEnergyHistogram_DetectorModel_" + NumberToString(detModel) + "_ReconstructionVariant_" + NumberToString(recoVar) + ";4");
std::cout << histogramName << std::endl;
TH1F *pTH1F = (TH1F*)pTFile->Get(histogramName.c_str());
std::string fitTitle = "PFOEnergyHistogramGaussianFit_DetectorModel_" + NumberToString(detModel) + "_ReconstructionVariant_" + NumberToString(recoVar) + "_Energy" + NumberToString(energy) + "GeV";
TF1 *pGaussianFit = new TF1(fitTitle.c_str(),"gaus",0,1000);
pTH1F->Fit(fitTitle.c_str());
const float fitAmplitude(pGaussianFit->GetParameter(0));
const float fitMean(pGaussianFit->GetParameter(1));
const float fitStdDev(pGaussianFit->GetParameter(2));
const float energyResolution(fitStdDev/fitMean);
const float meanError(pGaussianFit->GetParError(1));
const float meanFracError(meanError / fitMean);
const float stdDevError(pGaussianFit->GetParError(2));
const float stdDevFracError(stdDevError / fitStdDev);
const float energyResolutionError = energyResolution * std::pow( (meanFracError*meanFracError) + (stdDevFracError*stdDevFracError) ,0.5);
pTGraphErrors->SetPoint(pTGraphErrors->GetN(),layerNumber,energyResolution*100.f);
pTGraphErrors->SetPointError(pTGraphErrors->GetN()-1,0,energyResolutionError*100.f);
std::cout << "For energy : " << energy << std::endl;
std::cout << "Amplitude : " << fitAmplitude << std::endl;
std::cout << "Mean : " << fitMean << std::endl;
std::cout << "Standard Deviation : " << fitStdDev << std::endl;
std::cout << "Det model " << detModel << std::endl;
std::cout << "Energy Resolution : " << energyResolution*100 << std::endl;
}
TH2F *pAxes = new TH2F("axesEj","",100,14,32,1000,2.4,3.4);
pAxes->SetTitle("100 GeV Photon Energy Resolution vs Number of Layers in ECal (Si)");
pAxes->GetYaxis()->SetTitle("#sigma_{Reco} / E_{Reco}");
pAxes->GetXaxis()->SetTitle("Number of ECal Layers");
pAxes->Draw();
pTGraphErrors->Draw("same PL");
const std::string name("SiECal" + NumberToString(energy) + "GeVPhotonResVsLayerNumber.C");
pTCanvas->SaveAs(name.c_str());
}
double GetTheta(){
phi = GetPhi();
// if((xzfitfunc->GetParameter(1)*fabs(cos(phi))) != 0)
theta = absval(atan(1/(yzfitfunc->GetParameter(1)*(sin(phi)))));
return theta;};
double YZGetParameter(int i){return (yzfitfunc->GetParameter(i));};
void fitB_extend(bool ispPb=true,TString infname="",bool doweight = 1)
{
if(ispPb==true){
inputdata="/afs/cern.ch/work/w/wangj/public/nt_20140727_PAMuon_HIRun2013_Merged_y24_Using03090319Bfinder.root";
inputmc="/afs/cern.ch/work/w/wangj/public/nt_20140801_mixed_fromQMBFinder_Kp.root";
luminosity=34.6*1e-3;
outputname="../ResultsBplus/SigmaBplus_extend.root";
cut="abs(y)<2.4&&(HLT_PAMu3_v1)&&abs(mumumass-3.096916)<0.15&&mass>5&&mass<6&& isbestchi2&&trk1Pt>0.9&&chi2cl>1.32e-02&&(d0/d0Err)>3.41&&cos(dtheta)>-3.46e01&&mu1pt>1.5&&mu2pt>1.5";
}
else{
//inputdata="/data/bmeson/data//nt_20141022_PPMuon_Run2013A_PromptReco_v1_resub20141126.root";
//inputmc="/afs/cern.ch/work/w/wangj/public/nt_20140801_mixed_fromQMBFinder_Kp.root";
inputdata="/data/bmeson/data/nt_20141022_PPMuon_Run2013A_PromptReco_v1_resub20141126_HLT_PAL1DoubleMu0_HighQ_v1.root";
inputmc="/data/bmeson/MC/nt_2015251_PYTHIA6_BuJpsiK_pp_PAL1DoubleMu0_HighQ_v1.root";
luminosity=5400*1e-3;
outputname="../ResultsBplus_pp/SigmaBplus_extend.root";
cut="abs(y)<2.4&&(HLT_PAL1DoubleMu0_HighQ_v1)&&abs(mumumass-3.096916)<0.15&&mass>5&&mass<6&& isbestchi2&&trk1Pt>0.9&&chi2cl>1.32e-02&&(d0/d0Err)>3.41&&cos(dtheta)>-3.46e01&&mu1pt>1.5&&mu2pt>1.5";
}
seldata_2y=Form("%s",cut.Data());
selmc=Form("abs(y)<2.4&&gen==23333&&%s",cut.Data());
selmcgen="abs(y)<2.4&&abs(pdgId)==521&&isSignal==1";
if (doweight==0) weight="1";
if (infname=="") infname=inputdata.Data();
TFile *inf = new TFile(infname.Data());
TTree *nt = (TTree*) inf->Get("ntKp");
TFile *infMC = new TFile(inputmc.Data());
TTree *ntGen = (TTree*)infMC->Get("ntGen");
TTree *ntGen2 = (TTree*)inf->Get("ntGen");
TTree *ntMC = (TTree*)infMC->Get("ntKp");
ntGen->AddFriend(ntMC);
ntGen2->AddFriend(ntMC);
const int nBins = 5;
double ptBins[nBins+1] = {10,15,20,25,30,60};
//const int nBins = 1;
//double ptBins[nBins+1] = {10,60};
TH1D *hPt = new TH1D("hPt","",nBins,ptBins);
TH1D *hPtRecoTruth = new TH1D("hPtRecoTruth","",nBins,ptBins);
TH1D *hGenPtSelected = new TH1D("hGenPtSelected","",nBins,ptBins);
TH1D *hPtMC = new TH1D("hPtMC","",nBins,ptBins);
TH1D *hPtGen = new TH1D("hPtGen","",nBins,ptBins);
TH1D *hPtGen2 = new TH1D("hPtGen2","",nBins,ptBins);
TFile *outf = new TFile(outputname.Data(),"recreate");
for (int i=0;i<nBins+1;i++)
{
if (i==nBins) {fit(nt,ntMC,10,60,ispPb,i);continue;}
TF1 *f = fit(nt,ntMC,ptBins[i],ptBins[i+1],ispPb,i);
double yield = f->Integral(5,6)/0.02;
double yieldErr = f->Integral(5,6)/0.02*f->GetParError(0)/f->GetParameter(0);
hPt->SetBinContent(i+1,yield/(ptBins[i+1]-ptBins[i]));
hPt->SetBinError(i+1,yieldErr/(ptBins[i+1]-ptBins[i]));
}
TCanvas *c= new TCanvas("cResult","",600,600);
hPt->SetXTitle("B^{+} p_{T} (GeV/c)");
hPt->SetYTitle("Uncorrected B^{+} dN/dp_{T}");
hPt->Sumw2();
hPt->Draw();
ntMC->Project("hPtMC","pt",TCut(weight)*(TCut(selmc.Data())&&"gen==23333"));
nt->Project("hPtRecoTruth","pt",TCut(seldata_2y.Data())&&"gen==23333");
ntGen->Project("hPtGen","pt",TCut(weight)*(TCut(selmcgen.Data())));
ntGen2->Project("hPtGen2","pt",(TCut(selmcgen.Data())));
divideBinWidth(hPtRecoTruth);
hPtRecoTruth->Draw("same hist");
divideBinWidth(hPtMC);
divideBinWidth(hPtGen);
divideBinWidth(hPtGen2);
hPtMC->Sumw2();
TH1D *hEff = (TH1D*)hPtMC->Clone("hEff");
hPtMC->Sumw2();
hEff->Divide(hPtGen);
TH1D *hPtCor = (TH1D*)hPt->Clone("hPtCor");
hPtCor->Divide(hEff);
TCanvas *cCor= new TCanvas("cCorResult","",600,600);
hPtCor->SetYTitle("Corrected B^{+} dN/dp_{T}");
hPtCor->Draw();
hPtGen->Draw("same hist");
hPtGen2->Draw("same hist");
TH1D *hPtSigma= (TH1D*)hPtCor->Clone("hPtSigma");
double BRchain=6.09604e-5;
hPtSigma->Scale(1./(2*luminosity*BRchain));
hPtSigma->SetYTitle("d#sigma (B^{+})/dp_{T}");
TCanvas *cSigma= new TCanvas("cSigma","",600,600);
hPtSigma->Draw();
outf->cd();
hPt->Write();
hEff->Write();
hPtGen->Write();
hPtCor->Write();
hPtSigma->Write();
outf->Close();
delete outf;
}
TH1D* getYield(TTree* nt, TTree* ntMC, TString triggerpass, TString triggername, TString prescale, TString variable, TString varname, TString varlatex, Int_t BIN_NUM, Double_t BIN_MIN, Double_t BIN_MAX, TString addcut="")
{
TH1D* hDistrib = new TH1D(Form("h%s_Distrib_%s",triggername.Data(),varname.Data()),"",BIN_NUM,BIN_MIN,BIN_MAX);
for(float ivar=0;ivar<BIN_NUM;ivar++)
{
TCanvas* c = new TCanvas(Form("c%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"",500,500);
TH1D* h = new TH1D(Form("h%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),";D^{0} mass (GeV/c^{2});Candidates",60,1.7,2.0);
TH1D* hMC = new TH1D(Form("hMC%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"",60,1.75,1.95);
TH1D* hSW = new TH1D(Form("hSW%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"",60,1.75,1.95);
Float_t varmin = BIN_MIN+ivar*((BIN_MAX-BIN_MIN)/BIN_NUM);
Float_t varmax = BIN_MIN+(ivar+1)*((BIN_MAX-BIN_MIN)/BIN_NUM);
nt->Project(Form("h%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),Form("Dmass%s",prescale.Data()),Form("%s%s&&(%s>%f&&%s<%f)%s",prefilter.Data(),addcut.Data(),variable.Data(),varmin,variable.Data(),varmax,triggerpass.Data()));
ntMC->Project(Form("hMC%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"Dmass",Form("%s%s&&(%s>%f&&%s<%f)%s",prefilterMC.Data(),addcut.Data(),variable.Data(),varmin,variable.Data(),varmax,"&&1"));
ntMC->Project(Form("hSW%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"Dmass",Form("%s%s&&(%s>%f&&%s<%f)%s",prefilterSW.Data(),addcut.Data(),variable.Data(),varmin,variable.Data(),varmax,"&&1"));
h->SetMaximum(h->GetMaximum()*1.20);
h->Draw();
TF1* f = new TF1(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"[0]*([7]*([9]*Gaus(x,[1],[2]*(1+[11]))/(sqrt(2*3.14159)*[2]*(1+[11]))+(1-[9])*Gaus(x,[1],[10]*(1+[11]))/(sqrt(2*3.14159)*[10]*(1+[11])))+(1-[7])*Gaus(x,[1],[8]*(1+[11]))/(sqrt(2*3.14159)*[8]*(1+[11])))+[3]+[4]*x+[5]*x*x+[6]*x*x*x", 1.7, 2.0);
f->SetParLimits(4,-1000,1000);
f->SetParLimits(10,0.001,0.05);
f->SetParLimits(2,0.01,0.1);
f->SetParLimits(8,0.02,0.2);
f->SetParLimits(7,0,1);
f->SetParLimits(9,0,1);
f->SetParameter(0,setparam0);
f->SetParameter(1,setparam1);
f->SetParameter(2,setparam2);
f->SetParameter(10,setparam10);
f->SetParameter(9,setparam9);
f->FixParameter(8,setparam8);
f->FixParameter(7,1);
f->FixParameter(1,fixparam1);
f->FixParameter(3,0);
f->FixParameter(4,0);
f->FixParameter(5,0);
f->FixParameter(6,0);
f->FixParameter(11,0);
h->GetEntries();
hMC->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"q","",1.7,2.0);
hMC->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"q","",1.7,2.0);
f->ReleaseParameter(1);
hMC->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L q","",1.7,2.0);
hMC->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L q","",1.7,2.0);
hMC->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L m","",1.7,2.0);
f->FixParameter(1,f->GetParameter(1));
f->FixParameter(2,f->GetParameter(2));
f->FixParameter(10,f->GetParameter(10));
f->FixParameter(9,f->GetParameter(9));
f->FixParameter(7,0);
f->ReleaseParameter(8);
f->SetParameter(8,setparam8);
hSW->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L q","",1.7,2.0);
hSW->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L q","",1.7,2.0);
hSW->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L q","",1.7,2.0);
hSW->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L m","",1.7,2.0);
f->FixParameter(7,hMC->Integral(0,1000)/(hSW->Integral(0,1000)+hMC->Integral(0,1000)));
f->FixParameter(8,f->GetParameter(8));
f->ReleaseParameter(3);
f->ReleaseParameter(4);
f->ReleaseParameter(5);
f->ReleaseParameter(6);
f->SetLineColor(kRed);
h->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"q","",1.7,2.0);
h->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"q","",1.7,2.0);
f->ReleaseParameter(1);
f->SetParLimits(1,1.86,1.87);
f->ReleaseParameter(11);
f->SetParLimits(11,-1.,1.);
h->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L q","",1.7,2.0);
h->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L q","",1.7,2.0);
h->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L q","",1.7,2.0);
h->Fit(Form("f%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"L m","",1.7,2.0);
h->SetMarkerSize(0.8);
h->SetMarkerStyle(20);
TF1* background = new TF1(Form("background%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"[0]+[1]*x+[2]*x*x+[3]*x*x*x");
background->SetParameter(0,f->GetParameter(3));
background->SetParameter(1,f->GetParameter(4));
background->SetParameter(2,f->GetParameter(5));
background->SetParameter(3,f->GetParameter(6));
background->SetLineColor(4);
background->SetRange(1.7,2.0);
background->SetLineStyle(2);
TF1* mass = new TF1(Form("fmass%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"[0]*([3]*([4]*Gaus(x,[1],[2]*(1+[6]))/(sqrt(2*3.14159)*[2]*(1+[6]))+(1-[4])*Gaus(x,[1],[5]*(1+[6]))/(sqrt(2*3.14159)*[5]*(1+[6]))))");
mass->SetParameters(f->GetParameter(0),f->GetParameter(1),f->GetParameter(2),f->GetParameter(7),f->GetParameter(9),f->GetParameter(10),f->GetParameter(11));
mass->SetParError(0,f->GetParError(0));
mass->SetParError(1,f->GetParError(1));
mass->SetParError(2,f->GetParError(2));
mass->SetParError(3,f->GetParError(7));
mass->SetParError(4,f->GetParError(9));
mass->SetParError(5,f->GetParError(10));
mass->SetFillColor(kOrange-3);
mass->SetFillStyle(3002);
mass->SetLineColor(kOrange-3);
mass->SetLineWidth(3);
mass->SetLineStyle(2);
TF1* massSwap = new TF1(Form("fmassSwap%s_Fit_%s_%.0f",triggername.Data(),varname.Data(),ivar),"[0]*(1-[2])*Gaus(x,[1],[3]*(1+[4]))/(sqrt(2*3.14159)*[3]*(1+[4]))");
massSwap->SetParameters(f->GetParameter(0),f->GetParameter(1),f->GetParameter(7),f->GetParameter(8),f->GetParameter(11));
massSwap->SetParError(0,f->GetParError(0));
massSwap->SetParError(1,f->GetParError(1));
massSwap->SetParError(2,f->GetParError(7));
massSwap->SetParError(3,f->GetParError(8));
massSwap->SetFillColor(kGreen+4);
massSwap->SetFillStyle(3005);
massSwap->SetLineColor(kGreen+4);
massSwap->SetLineWidth(3);
massSwap->SetLineStyle(1);
h->SetXTitle("m_{#piK} (GeV/c^{2})");
h->SetYTitle("Entries / (5 MeV/c^{2})");
h->GetXaxis()->CenterTitle();
h->GetYaxis()->CenterTitle();
h->SetAxisRange(0,h->GetMaximum()*1.4*1.2,"Y");
h->GetXaxis()->SetTitleOffset(1.3);
h->GetYaxis()->SetTitleOffset(1.8);
h->GetXaxis()->SetLabelOffset(0.007);
h->GetYaxis()->SetLabelOffset(0.007);
h->GetXaxis()->SetTitleSize(0.045);
h->GetYaxis()->SetTitleSize(0.045);
h->GetXaxis()->SetTitleFont(42);
h->GetYaxis()->SetTitleFont(42);
h->GetXaxis()->SetLabelFont(42);
h->GetYaxis()->SetLabelFont(42);
h->GetXaxis()->SetLabelSize(0.04);
h->GetYaxis()->SetLabelSize(0.04);
h->SetMarkerSize(0.8);
h->SetMarkerStyle(20);
h->SetStats(0);
h->Draw("e");
background->Draw("same");
mass->SetRange(1.7,2.0);
mass->Draw("same");
massSwap->SetRange(1.7,2.0);
massSwap->Draw("same");
f->Draw("same");
Double_t yield = mass->Integral(1.7,2.0)/0.005;
Double_t yieldErr = (mass->Integral(1.7,2.0)/0.005)*(mass->GetParError(0)/mass->GetParameter(0));
std::cout<<"YIELD="<<yield<<std::endl;
// Draw the legend:)
TLegend* leg = myLegend(0.20,0.60,0.53,0.94);
leg->SetFillColor(0);
leg->SetBorderSize(0);
leg->AddEntry((TObject*)0,"CMS Preliminary","");
if(isPbPb) leg->AddEntry((TObject*)0,"PbPb #sqrt{s_{NN}}= 5.02 TeV","");
else leg->AddEntry((TObject*)0,"pp #sqrt{s_{NN}}= 5.02 TeV","");
leg->AddEntry((TObject*)0,Form("%.1f<%s<%.1f",varmin,varlatex.Data(),varmax),"");
leg->AddEntry(h,"Data","pl");
leg->AddEntry(f,"Fit","l");
leg->AddEntry(mass,"Signal","f");
leg->AddEntry(massSwap,"K-#pi swapped","f");
leg->AddEntry(background,"Combinatorial Background","l");
leg->Draw();
TLegend* leg2 = myLegend(0.45,0.80,0.90,0.94);
leg2->SetFillColor(0);
leg2->SetBorderSize(0);
leg2->AddEntry(h,"D meson","");
leg2->AddEntry(h,Form("M_{D}=%.2f #pm %.2f MeV/c^{2}",mass->GetParameter(1)*1000.,mass->GetParError(1)*1000.),"");
leg2->AddEntry(h,Form("N_{D}=%.0f #pm %.0f", yield, yieldErr),"");
leg2->Draw();
hDistrib->SetBinContent(ivar+1,yield);
hDistrib->SetBinError(ivar+1,yieldErr);
if(isPbPb) c->SaveAs(Form("fitefficiencyPbPb/c%s_Fit_%s_%.0f.pdf",triggername.Data(),varname.Data(),ivar));
else c->SaveAs(Form("fitefficiencyPP/c%s_Fit_%s_%.0f.pdf",triggername.Data(),varname.Data(),ivar));
}
TCanvas* cDistrib = new TCanvas(Form("c%s_Distrib_%s",triggername.Data(),varname.Data()),"",500,500);
hDistrib->Draw();
hDistrib->SetStats(0);
if(isPbPb) cDistrib->SaveAs(Form("fitefficiencyPbPb/c%s_Distrib_%s.pdf",triggername.Data(),varname.Data()));
else cDistrib->SaveAs(Form("fitefficiencyPP/data/pp/c%s_Distrib_%s.pdf",triggername.Data(),varname.Data()));
return hDistrib;
}
TF1 *fit(TTree *nt,TTree *ntMC,double ptmin,double ptmax, bool ispPb, int count){
//cout<<cut.Data()<<endl;
//static int count=0;
//count++;
TCanvas *c= new TCanvas(Form("c%d",count),"",600,600);
TH1D *h = new TH1D(Form("h%d",count),"",50,5,6);
TH1D *hMC = new TH1D(Form("hMC%d",count),"",50,5,6);
TString iNP="7.26667e+00*Gaus(x,5.10472e+00,2.63158e-02)/(sqrt(2*3.14159)*2.63158e-02)+4.99089e+01*Gaus(x,4.96473e+00,9.56645e-02)/(sqrt(2*3.14159)*9.56645e-02)+3.94417e-01*(3.74282e+01*Gaus(x,5.34796e+00,3.11510e-02)+1.14713e+01*Gaus(x,5.42190e+00,1.00544e-01))";
TF1 *f = new TF1(Form("f%d",count),"[0]*([7]*Gaus(x,[1],[2])/(sqrt(2*3.14159)*[2])+(1-[7])*Gaus(x,[1],[8])/(sqrt(2*3.14159)*[8]))+[3]+[4]*x+[5]*("+iNP+")");
nt->Project(Form("h%d",count),"mass",Form("%s&&pt>%f&&pt<%f",seldata_2y.Data(),ptmin,ptmax));
ntMC->Project(Form("hMC%d",count),"mass",Form("%s&&pt>%f&&pt<%f",seldata_2y.Data(),ptmin,ptmax));
clean0(h);
TH1D *hraw = new TH1D(Form("hraw%d",count),"",50,5,6);
clean0(hraw);
hraw = (TH1D*)h->Clone(Form("hraw%d",count));
h->Draw();
f->SetParLimits(4,-1000,0);
f->SetParLimits(2,0.01,0.05);
f->SetParLimits(8,0.01,0.05);
f->SetParLimits(7,0,1);
f->SetParLimits(5,0,1000);
f->SetParameter(0,setparam0);
f->SetParameter(1,setparam1);
f->SetParameter(2,setparam2);
f->SetParameter(8,setparam3);
f->FixParameter(1,fixparam1);
h->GetEntries();
hMC->Fit(Form("f%d",count),"q","",5,6);
hMC->Fit(Form("f%d",count),"q","",5,6);
f->ReleaseParameter(1);
hMC->Fit(Form("f%d",count),"L q","",5,6);
hMC->Fit(Form("f%d",count),"L q","",5,6);
hMC->Fit(Form("f%d",count),"L q","",5,6);
hMC->Fit(Form("f%d",count),"L m","",5,6);
f->FixParameter(1,f->GetParameter(1));
f->FixParameter(2,f->GetParameter(2));
f->FixParameter(7,f->GetParameter(7));
f->FixParameter(8,f->GetParameter(8));
h->Fit(Form("f%d",count),"q","",5,6);
h->Fit(Form("f%d",count),"q","",5,6);
f->ReleaseParameter(1);
h->Fit(Form("f%d",count),"L q","",5,6);
h->Fit(Form("f%d",count),"L q","",5,6);
h->Fit(Form("f%d",count),"L q","",5,6);
h->Fit(Form("f%d",count),"L m","",5,6);
h->SetMarkerSize(0.8);
h->SetMarkerStyle(20);
cout <<h->GetEntries()<<endl;
// function for background shape plotting. take the fit result from f
TF1 *background = new TF1(Form("background%d",count),"[0]+[1]*x");
background->SetParameter(0,f->GetParameter(3));
background->SetParameter(1,f->GetParameter(4));
background->SetParameter(2,f->GetParameter(5));
background->SetParameter(3,f->GetParameter(6));
background->SetLineColor(4);
background->SetRange(5,6);
background->SetLineStyle(2);
// function for signal shape plotting. take the fit result from f
TF1 *Bkpi = new TF1(Form("fBkpi%d",count),"[0]*("+iNP+")");
Bkpi->SetParameter(0,f->GetParameter(5));
Bkpi->SetLineColor(kGreen+1);
Bkpi->SetFillColor(kGreen+1);
// Bkpi->SetRange(5.00,5.28);
Bkpi->SetRange(5.00,6.00);
Bkpi->SetLineStyle(1);
Bkpi->SetFillStyle(3004);
// function for signal shape plotting. take the fit result from f
TF1 *mass = new TF1(Form("fmass%d",count),"[0]*([3]*Gaus(x,[1],[2])/(sqrt(2*3.14159)*[2])+(1-[3])*Gaus(x,[1],[4])/(sqrt(2*3.14159)*[4]))");
mass->SetParameters(f->GetParameter(0),f->GetParameter(1),f->GetParameter(2),f->GetParameter(7),f->GetParameter(8));
mass->SetParError(0,f->GetParError(0));
mass->SetParError(1,f->GetParError(1));
mass->SetParError(2,f->GetParError(2));
mass->SetParError(7,f->GetParError(7));
mass->SetParError(8,f->GetParError(8));
mass->SetLineColor(2);
mass->SetLineStyle(2);
// cout <<mass->Integral(0,1.2)<<" "<<mass->IntegralError(0,1.2)<<endl;
h->SetMarkerStyle(24);
h->SetStats(0);
h->Draw("e");
h->SetXTitle("M_{B} (GeV/c^{2})");
h->SetYTitle("Entries / (20 MeV/c^{2})");
h->GetXaxis()->CenterTitle();
h->GetYaxis()->CenterTitle();
h->SetTitleOffset(1.5,"Y");
h->SetAxisRange(0,h->GetMaximum()*1.2,"Y");
Bkpi->Draw("same");
background->Draw("same");
mass->SetRange(5,6);
mass->Draw("same");
mass->SetLineStyle(2);
mass->SetFillStyle(3004);
mass->SetFillColor(2);
f->Draw("same");
hraw->Draw("same");
double yield = mass->Integral(5,6)/0.02;
double yieldErr = mass->Integral(5,6)/0.02*mass->GetParError(0)/mass->GetParameter(0);
// Draw the legend:)
TLegend *leg = myLegend(0.50,0.5,0.86,0.89);
leg->AddEntry(h,"CMS Preliminary","");
leg->AddEntry(h,"pPb #sqrt{s_{NN}} = 5.02 TeV","");
leg->AddEntry(h,Form("%.0f < p_{T}^{B} < %.0f GeV/c",ptmin,ptmax),"");
leg->AddEntry(h,"Data","pl");
leg->AddEntry(f,"Fit","l");
leg->AddEntry(mass,"Signal","f");
leg->AddEntry(background,"Combinatorial Background","l");
leg->AddEntry(Bkpi,"Non-prompt J/#psi","f");
leg->Draw();
TLegend *leg2 = myLegend(0.44,0.33,0.89,0.50);
leg2->AddEntry(h,"B meson","");
leg2->AddEntry(h,Form("M_{B} = %.2f #pm %.2f MeV/c^{2}",mass->GetParameter(1)*1000.,mass->GetParError(1)*1000.),"");
leg2->AddEntry(h,Form("N_{B} = %.0f #pm %.0f", yield, yieldErr),"");
leg2->Draw();
if(ispPb)c->SaveAs(Form("../ResultsBplus/BMass-%d.pdf",count));
else c->SaveAs(Form("../ResultsBplus_pp/BMass-%d.pdf",count));
h->Write();
hMC->Write();
f->Write();
background->Write();
Bkpi->Write();
mass->Write();
hraw->Write();
return mass;
}
TF1* fit(Double_t ptmin, Double_t ptmax)
{
TCanvas* c = new TCanvas(Form("c_%.0f_%.0f",ptmin,ptmax),"",600,600);
TFile* infile = new TFile(Form("%s_%s_%.0f_%.0f.root",infname.Data(),collisionsystem.Data(),ptmin,ptmax));
TH1D* h = (TH1D*)infile->Get("h"); h->SetName(Form("h_%.0f_%.0f",ptmin,ptmax));
TH1D* hMCSignal = (TH1D*)infile->Get("hMCSignal"); hMCSignal->SetName(Form("hMCSignal_%.0f_%.0f",ptmin,ptmax));
TH1D* hMCSwapped = (TH1D*)infile->Get("hMCSwapped"); hMCSwapped->SetName(Form("hMCSwapped_%.0f_%.0f",ptmin,ptmax));
TF1* f = new TF1(Form("f_%.0f_%.0f",ptmin,ptmax),"[0]*([7]*([9]*Gaus(x,[1],[2])/(sqrt(2*3.14159)*[2])+(1-[9])*Gaus(x,[1],[10])/(sqrt(2*3.14159)*[10]))+(1-[7])*Gaus(x,[1],[8])/(sqrt(2*3.14159)*[8]))+[3]+[4]*x+[5]*x*x", 1.7, 2.0);
f->SetParLimits(4,-1000,1000);
f->SetParLimits(10,0.001,0.05);
f->SetParLimits(2,0.01,0.1);
f->SetParLimits(8,0.02,0.2);
f->SetParLimits(7,0,1);
f->SetParLimits(9,0,1);
f->SetParameter(0,setparam0);
f->SetParameter(1,setparam1);
f->SetParameter(2,setparam2);
f->SetParameter(10,setparam10);
f->SetParameter(9,setparam9);
f->FixParameter(8,setparam8);
f->FixParameter(7,1);
f->FixParameter(1,fixparam1);
f->FixParameter(3,0);
f->FixParameter(4,0);
f->FixParameter(5,0);
h->GetEntries();
hMCSignal->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"q","",minhisto,maxhisto);
hMCSignal->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"q","",minhisto,maxhisto);
f->ReleaseParameter(1);
hMCSignal->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
hMCSignal->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
hMCSignal->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L m","",minhisto,maxhisto);
f->FixParameter(1,f->GetParameter(1));
f->FixParameter(2,f->GetParameter(2));
f->FixParameter(10,f->GetParameter(10));
f->FixParameter(9,f->GetParameter(9));
f->FixParameter(7,0);
f->ReleaseParameter(8);
f->SetParameter(8,setparam8);
hMCSwapped->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
hMCSwapped->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
hMCSwapped->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
hMCSwapped->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L m","",minhisto,maxhisto);
f->FixParameter(7,hMCSignal->Integral(0,1000)/(hMCSwapped->Integral(0,1000)+hMCSignal->Integral(0,1000)));
f->FixParameter(8,f->GetParameter(8));
f->ReleaseParameter(3);
f->ReleaseParameter(4);
f->ReleaseParameter(5);
f->SetLineColor(kRed);
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"q","",minhisto,maxhisto);
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"q","",minhisto,maxhisto);
f->ReleaseParameter(1);
//f->ReleaseParameter(2); // you need to release these two parameters if you want to perform studies on the sigma shape
//f->ReleaseParameter(10); // you need to release these two parameters if you want to perform studies on the sigma shape
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L m","",minhisto,maxhisto);
TF1* background = new TF1(Form("background_%.0f_%.0f",ptmin,ptmax),"[0]+[1]*x+[2]*x*x");
background->SetParameter(0,f->GetParameter(3));
background->SetParameter(1,f->GetParameter(4));
background->SetParameter(2,f->GetParameter(5));
background->SetLineColor(4);
background->SetRange(minhisto,maxhisto);
background->SetLineStyle(2);
TF1* mass = new TF1(Form("fmass_%.0f_%.0f",ptmin,ptmax),"[0]*([3]*([4]*Gaus(x,[1],[2])/(sqrt(2*3.14159)*[2])+(1-[4])*Gaus(x,[1],[5])/(sqrt(2*3.14159)*[5])))");
mass->SetParameters(f->GetParameter(0),f->GetParameter(1),f->GetParameter(2),f->GetParameter(7),f->GetParameter(9),f->GetParameter(10));
mass->SetParError(0,f->GetParError(0));
mass->SetParError(1,f->GetParError(1));
mass->SetParError(2,f->GetParError(2));
mass->SetParError(3,f->GetParError(7));
mass->SetParError(4,f->GetParError(9));
mass->SetParError(5,f->GetParError(10));
mass->SetFillColor(kOrange-3);
mass->SetFillStyle(3002);
mass->SetLineColor(kOrange-3);
mass->SetLineWidth(3);
mass->SetLineStyle(2);
TF1* massSwap = new TF1(Form("fmassSwap_%.0f_%.0f",ptmin,ptmax),"[0]*(1-[2])*Gaus(x,[1],[3])/(sqrt(2*3.14159)*[3])");
massSwap->SetParameters(f->GetParameter(0),f->GetParameter(1),f->GetParameter(7),f->GetParameter(8));
massSwap->SetParError(0,f->GetParError(0));
massSwap->SetParError(1,f->GetParError(1));
massSwap->SetParError(2,f->GetParError(7));
massSwap->SetParError(3,f->GetParError(8));
massSwap->SetFillColor(kGreen+4);
massSwap->SetFillStyle(3005);
massSwap->SetLineColor(kGreen+4);
massSwap->SetLineWidth(3);
massSwap->SetLineStyle(1);
h->SetXTitle("m_{#piK} (GeV/c^{2})");
h->SetYTitle("Entries / (5 MeV/c^{2})");
h->GetXaxis()->CenterTitle();
h->GetYaxis()->CenterTitle();
h->SetAxisRange(0,h->GetMaximum()*1.4*1.2,"Y");
h->GetXaxis()->SetTitleOffset(1.3);
h->GetYaxis()->SetTitleOffset(1.8);
h->GetXaxis()->SetLabelOffset(0.007);
h->GetYaxis()->SetLabelOffset(0.007);
h->GetXaxis()->SetTitleSize(0.045);
h->GetYaxis()->SetTitleSize(0.045);
h->GetXaxis()->SetTitleFont(42);
h->GetYaxis()->SetTitleFont(42);
h->GetXaxis()->SetLabelFont(42);
h->GetYaxis()->SetLabelFont(42);
h->GetXaxis()->SetLabelSize(0.04);
h->GetYaxis()->SetLabelSize(0.04);
h->SetMarkerSize(0.8);
h->SetMarkerStyle(20);
h->SetStats(0);
h->Draw("e");
background->Draw("same");
mass->SetRange(minhisto,maxhisto);
mass->Draw("same");
massSwap->SetRange(minhisto,maxhisto);
massSwap->Draw("same");
f->Draw("same");
Double_t yield = mass->Integral(minhisto,maxhisto)/binwidthmass;
Double_t yieldErr = mass->Integral(minhisto,maxhisto)/binwidthmass*mass->GetParError(0)/mass->GetParameter(0);
std::cout<<"YIELD="<<yield<<std::endl;
TLegend* leg = new TLegend(0.65,0.58,0.82,0.88,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.04);
leg->SetTextFont(42);
leg->SetFillStyle(0);
leg->AddEntry(h,"Data","pl");
leg->AddEntry(f,"Fit","l");
leg->AddEntry(mass,"D^{0}+#bar{D^{#lower[0.2]{0}}} Signal","f");
leg->AddEntry(massSwap,"K-#pi swapped","f");
leg->AddEntry(background,"Combinatorial","l");
leg->Draw("same");
TLatex* texCms = new TLatex(0.18,0.93, "#scale[1.25]{CMS} Preliminary");
texCms->SetNDC();
texCms->SetTextAlign(12);
texCms->SetTextSize(0.04);
texCms->SetTextFont(42);
texCms->Draw();
TLatex* texCol = new TLatex(0.96,0.93, Form("%s #sqrt{s_{NN}} = 5.02 TeV",collisionsystem.Data()));
texCol->SetNDC();
texCol->SetTextAlign(32);
texCol->SetTextSize(0.04);
texCol->SetTextFont(42);
texCol->Draw();
TLatex* texPt = new TLatex(0.22,0.78,Form("%.1f < p_{T} < %.1f GeV/c",ptmin,ptmax));
texPt->SetNDC();
texPt->SetTextFont(42);
texPt->SetTextSize(0.04);
texPt->SetLineWidth(2);
texPt->Draw();
TLatex* texY = new TLatex(0.22,0.83,"|y| < 1.0");
texY->SetNDC();
texY->SetTextFont(42);
texY->SetTextSize(0.04);
texY->SetLineWidth(2);
texY->Draw();
TLatex* texYield = new TLatex(0.22,0.73,Form("N_{D} = %.0f #pm %.0f",yield,yieldErr));
texYield->SetNDC();
texYield->SetTextFont(42);
texYield->SetTextSize(0.04);
texYield->SetLineWidth(2);
texYield->Draw();
c->SaveAs(Form("plotFits/DMass_poly2_%s_%.0f_%.0f.pdf",collisionsystem.Data(),ptmin,ptmax));
TCanvas* cPull = new TCanvas(Form("cPull_%.0f_%.0f",ptmin,ptmax),"",600,700);
TH1D* hPull = (TH1D*)h->Clone("hPull");
for(int i=0;i<h->GetNbinsX();i++)
{
Double_t nfit = f->Integral(h->GetBinLowEdge(i+1),h->GetBinLowEdge(i+1)+h->GetBinWidth(i+1))/h->GetBinWidth(i+1);
hPull->SetBinContent(i+1,(h->GetBinContent(i+1)-nfit)/h->GetBinError(i+1));
hPull->SetBinError(i+1,0);
}
hPull->SetMinimum(-4.);
hPull->SetMaximum(4.);
hPull->SetYTitle("Pull");
hPull->GetXaxis()->SetTitleOffset(1.);
hPull->GetYaxis()->SetTitleOffset(0.65);
hPull->GetXaxis()->SetLabelOffset(0.007);
hPull->GetYaxis()->SetLabelOffset(0.007);
hPull->GetXaxis()->SetTitleSize(0.12);
hPull->GetYaxis()->SetTitleSize(0.12);
hPull->GetXaxis()->SetLabelSize(0.1);
hPull->GetYaxis()->SetLabelSize(0.1);
hPull->GetYaxis()->SetNdivisions(504);
TLine* lPull = new TLine(1.7, 0, 2., 0);
lPull->SetLineWidth(1);
lPull->SetLineStyle(7);
lPull->SetLineColor(1);
TPad* pFit = new TPad("pFit","",0,0.3,1,1);
pFit->SetBottomMargin(0);
pFit->Draw();
pFit->cd();
h->Draw("e");
background->Draw("same");
mass->Draw("same");
massSwap->Draw("same");
f->Draw("same");
leg->Draw("same");
texCms->Draw();
texCol->Draw();
texPt->Draw();
texY->Draw();
texYield->Draw();
cPull->cd();
TPad* pPull = new TPad("pPull","",0,0,1,0.3);
pPull->SetTopMargin(0);
pPull->SetBottomMargin(0.3);
pPull->Draw();
pPull->cd();
hPull->Draw("p");
lPull->Draw();
cPull->cd();
cPull->SaveAs(Form("plotFits/DMass_poly2_%s_%.0f_%.0f_Pull.pdf",collisionsystem.Data(),ptmin,ptmax));
return mass;
}
/**
* This function fits TH2F slices with a selected fitType function (gaussian, lorentz, ...).
*/
TGraphErrors* fit2DProj(TString name, TString path, int minEntries, int rebinX, int rebinY, int fitType,
TFile * outputFile, const TString & resonanceType, const double & xDisplace, const TString & append) {
//Read the TH2 from file
TFile *inputFile = new TFile(path);
TH2 * histo = (TH2*) inputFile->Get(name);
if( rebinX > 0 ) histo->RebinX(rebinX);
if( rebinY > 0 ) histo->RebinY(rebinY);
//Declare some variables
TH1 * histoY;
TString nameY;
std::vector<double> Ftop;
std::vector<double> Fwidth;
std::vector<double> Fmass;
std::vector<double> Etop;
std::vector<double> Ewidth;
std::vector<double> Emass;
std::vector<double> Fchi2;
std::vector<double> Xcenter;
std::vector<double> Ex;
TString fileOutName("fitCompare2"+name);
fileOutName += append;
fileOutName += ".root";
TFile *fileOut=new TFile(fileOutName,"RECREATE");
for (int i=1; i<=(histo->GetXaxis()->GetNbins());i++) {
//Project on Y (set name and title)
std::stringstream number;
number << i;
TString numberString(number.str());
nameY = name + "_" + numberString;
// std::cout << "nameY " << nameY << std::endl;
histoY = histo->ProjectionY(nameY, i, i);
double xBin = histo->GetXaxis()->GetBinCenter(i);
std::stringstream xBinString;
xBinString << xBin;
TString title("Projection of x = ");
title += xBinString.str();
histoY->SetName(title);
if (histoY->GetEntries() > minEntries) {
//Make the dirty work!
TF1 *fit;
std::cout << "fitType = " << fitType << std::endl;
if(fitType == 1) fit = gaussianFit(histoY, resonanceType);
else if(fitType == 2) fit = lorentzianFit(histoY, resonanceType);
else if(fitType == 3) fit = linLorentzianFit(histoY);
else {
std::cout<<"Wrong fit type: 1=gaussian, 2=lorentzian, 3=lorentzian+linear."<<std::endl;
abort();
}
double *par = fit->GetParameters();
double *err = fit->GetParErrors();
// Check the histogram alone
TCanvas *canvas = new TCanvas(nameY+"alone", nameY+" alone");
histoY->Draw();
canvas->Write();
// Only for check
TCanvas *c = new TCanvas(nameY, nameY);
histoY->Draw();
fit->Draw("same");
fileOut->cd();
c->Write();
if( par[0] == par[0] ) {
//Store the fit results
Ftop.push_back(par[0]);
Fwidth.push_back(fabs(par[1]));//sometimes the gaussian has negative width (checked with Rene Brun)
Fmass.push_back(par[2]);
Etop.push_back(err[0]);
Ewidth.push_back(err[1]);
Emass.push_back(err[2]);
Fchi2.push_back(fit->GetChisquare()/fit->GetNDF());
double xx= histo->GetXaxis()->GetBinCenter(i);
Xcenter.push_back(xx);
double ex = 0;
Ex.push_back(ex);
}
else {
// Skip nan
std::cout << "Skipping nan" << std::endl;
Ftop.push_back(0);
Fwidth.push_back(0);
Fmass.push_back(0);
Etop.push_back(1);
Ewidth.push_back(1);
Emass.push_back(1);
Fchi2.push_back(100000);
Xcenter.push_back(0);
Ex.push_back(1);
}
}
}
fileOut->Close();
//Plots the fit results in TGraphs
const int nn= Ftop.size();
double x[nn],ym[nn],e[nn],eym[nn];
double yw[nn],eyw[nn],yc[nn];
// std::cout << "number of bins = " << nn << std::endl;
// std::cout << "Values:" << std::endl;
for (int j=0;j<nn;j++){
// std::cout << "xCenter["<<j<<"] = " << Xcenter[j] << std::endl;
x[j]=Xcenter[j]+xDisplace;
// std::cout << "Fmass["<<j<<"] = " << Fmass[j] << std::endl;
ym[j]=Fmass[j];
// std::cout << "Emass["<<j<<"] = " << Emass[j] << std::endl;
eym[j]=Emass[j];
// std::cout << "Fwidth["<<j<<"] = " << Fwidth[j] << std::endl;
yw[j]=Fwidth[j];
// std::cout << "Ewidth["<<j<<"] = " << Ewidth[j] << std::endl;
eyw[j]=Ewidth[j];
// std::cout << "Fchi2["<<j<<"] = " << Fchi2[j] << std::endl;
yc[j]=Fchi2[j];
e[j]=0;
}
TGraphErrors *grM = new TGraphErrors(nn,x,ym,e,eym);
grM->SetTitle(name+"_M");
grM->SetName(name+"_M");
TGraphErrors *grW = new TGraphErrors(nn,x,yw,e,eyw);
grW->SetTitle(name+"_W");
grW->SetName(name+"_W");
TGraphErrors *grC = new TGraphErrors(nn,x,yc,e,e);
grC->SetTitle(name+"_chi2");
grC->SetName(name+"_chi2");
grM->SetMarkerColor(4);
grM->SetMarkerStyle(20);
grW->SetMarkerColor(4);
grW->SetMarkerStyle(20);
grC->SetMarkerColor(4);
grC->SetMarkerStyle(20);
//Draw and save the graphs
outputFile->cd();
TCanvas * c1 = new TCanvas(name+"_W",name+"_W");
c1->cd();
grW->Draw("AP");
c1->Write();
TCanvas * c2 = new TCanvas(name+"_M",name+"_M");
c2->cd();
grM->Draw("AP");
c2->Write();
TCanvas * c3 = new TCanvas(name+"_C",name+"_C");
c3->cd();
grC->Draw("AP");
c3->Write();
return grM;
}
void v2_cent_plotter(int jpsiCategory = 2, // 1 : Prompt, 2 : Non-Prompt, 3: Bkg
string nDphiBins = "4",
const char* outputDir = "output",
const char* inputDir = "outputNumbers",// where phi and v2 numbers are (root, and txt format)
bool bDoDebug = true,
bool bAddCent010 = false,
bool bSavePlots = true
)
{
gSystem->mkdir(Form("./%s/png",outputDir), kTRUE);
gSystem->mkdir(Form("./%s/pdf",outputDir), kTRUE);
// set the style
setTDRStyle();
gStyle->SetOptFit(0);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(kFALSE);
// input files: prompt and non-prompt ones
const char* v2InFileDirs[1] = {"histsV2Yields_20150823_v2W_Lxyz_pTtune_PRMC_dPhiBins4"};
const char* legend[4] = {"","Prompt J/#psi","Non-prompt J/#psi","Background"};
const char* signal[4] = {"", "Prp","NPrp","Bkg"};
// Reminder for TGraphAssymError: gr = new TGraphAsymmErrors(n,x,y,exl,exh,eyl,eyh);// n,x,y,err_x, err_y
int nBins = nCentBins_pr;
if(jpsiCategory==2) nBins = nCentBins_np;
cout<<" !!!!! Number of Y bins: "<< nBins<<endl;
double adXaxis[nBins];// location on x-axis
double adV2[nBins] ; // v2 values
double adV2_stat[nBins] ;// stat uncert
double adV2_syst[nBins] ;// stat uncert
double adV2_err0[nBins] ;// error 0
double adWidth_systBox[nBins]; // width of the systm. uncert.
for(int ib=0; ib<nBins; ib++)
{
adWidth_systBox[ib] = 10;
adV2_syst[ib] = adV2Cent_pr_syst[ib];
adXaxis[ib] = adXaxisCent_pr[ib];
if(jpsiCategory==2)
{
adV2_syst[ib] = adV2Cent_np_syst[ib];
adXaxis[ib] = adXaxisCent_np[ib];
}
if(bDoDebug) cout<<"Bin "<<ib<<"\t adAxis= "<<adXaxis[ib]<<endl;
}
// // open the files with yields and do the math
ifstream in;
std::string nameVar = outFilePlot[3]; // cent
std::string nameSig = signal[jpsiCategory]; // prompt, non-pro or bkg
std::string nameDir = v2InFileDirs[0];
string inputFile = nameVar + "_"+ nameSig + "_nphibin" + nDphiBins + ".dat";
cout << "!!!!!! Input file name: "<< inputFile <<endl;
in.open(Form("%s/%s/data/%s",inputDir,nameDir.c_str(),inputFile.c_str()));
// read the v2 and v2_stat uncert from input file
string whatBin[3];
double x[4]={0};
int iline=0;
string tmpstring;
getline(in,tmpstring);
while ( in.good() && iline<nBins)
{
in >> whatBin[0] >> whatBin[1] >> whatBin[2] >> x[0] >> x[1] >> x[2] >> x[3];
adV2[nBins-iline-1] = x[2];
adV2_stat[nBins-iline-1] = x[3];
cout<< "Bin " << whatBin[0] << "\t"<< whatBin[1] << "\t" << whatBin[2]<<"\t";
cout <<"v2= "<< x[2] << "\t error= "<< x[3]<<endl;
iline++;
}
in.close();
if(bDoDebug)
{
for(int ib=0; ib<nBins; ib++)
cout<<"Bin "<<ib<<"\t adXaxis: "<< adXaxis[ib]<<"\t v2= "<<adV2[ib]<<endl;
}
// high-pt
TGraphErrors *pgV2 = new TGraphErrors(nBins, adXaxis, adV2, adV2_stat, adV2_stat);
TGraphAsymmErrors *pgV2_sys = new TGraphAsymmErrors(nBins, adXaxis, adV2, adWidth_systBox,adWidth_systBox, adV2_syst, adV2_syst);
TGraphErrors *pgV2_cont = new TGraphErrors(nBins, adXaxis, adV2, adV2_err0, adV2_err0);
// //-------------------------------------------------- Drawing stuff
// colors and symbols
// high-pt
pgV2->SetMarkerColor(kRed+1);
pgV2_sys->SetFillColor(kRed-9);
pgV2->SetMarkerStyle(21);
pgV2_sys->SetMarkerStyle(21);
pgV2_cont->SetMarkerStyle(25);
pgV2->SetMarkerSize(1.1);
pgV2_cont->SetMarkerSize(1.1);
if(jpsiCategory==2)
{
pgV2->SetMarkerColor(kOrange+2);
pgV2_sys->SetFillColor(kOrange-9);
}
if(jpsiCategory==3)// bkg
{
pgV2->SetMarkerColor(1);
pgV2_sys->SetFillColor(19);
}
//-------------------------------------------------------
// general labels
TLatex *lt1 = new TLatex();
lt1->SetNDC();
TH1F *phAxis = new TH1F("phAxis",";N_{part};v_{2}",10,0,400);
phAxis->GetYaxis()->SetRangeUser(-0.05,0.25);
phAxis->GetXaxis()->CenterTitle();
phAxis->GetYaxis()->CenterTitle();
TF1 *line = new TF1("line","0",0,400);
line->SetLineWidth(1);
TLatex *pre = new TLatex(20.0,0.22,Form("%s",legend[jpsiCategory]));
pre->SetTextFont(42);
pre->SetTextSize(0.05);
TLatex *ly = new TLatex(20.0,0.18,Form("%s",yBinsLegend[0]));
ly->SetTextFont(42);
ly->SetTextSize(0.04);
TLatex *lpt = new TLatex(20.0,0.2,Form("%s",ptBinsLegend[0]));
lpt->SetTextFont(42);
lpt->SetTextSize(0.04);
TLatex *lcent = new TLatex(10.0,-0.025,Form("Cent."));
lcent->SetTextFont(42);
lcent->SetTextSize(0.04);
//-------------- Drawing
TCanvas *pc = new TCanvas("pc","pc");
phAxis->Draw();
CMS_lumi(pc,101,33);
pre->Draw();
lpt->Draw();
ly->Draw();
lcent->Draw();
int write2 = nBins;
if(!bAddCent010)
{
write2 = nBins-1;
pgV2_sys->RemovePoint(write2);
pgV2->RemovePoint(write2);
pgV2_cont->RemovePoint(write2);
}
for(int ib=0; ib<write2; ib++)
{
if(jpsiCategory==2) lcent->DrawLatex(adXaxis[ib]-30,-0.025,Form("%s",centBinsLegend[nCentBins-1-ib]));
else lcent->DrawLatex(adXaxis[ib]-30,-0.025,Form("%s",centBinsLegend[nCentBins-nBins-ib]));
}
pgV2_sys->Draw("2");
pgV2->Draw("PZ");
pgV2_cont->Draw("P");
gPad->RedrawAxis();
if(bSavePlots)
{
pc->SaveAs(Form("%s/png/v2_%s_%s_nphi%s.png",outputDir,outFilePlot[2],signal[jpsiCategory],nDphiBins.c_str()));
pc->SaveAs(Form("%s/pdf/v2_%s_%s_nphi%s.pdf",outputDir,outFilePlot[2],signal[jpsiCategory],nDphiBins.c_str()));
}
}
void toyMC_testFitter(int runIeta=-1, int runIpt=-1, int startExp=0){
cout << "ROOT version = " << gROOT->GetVersion() << endl;
// gSystem->mkdir("toysPlot");
char tmp[1000];
TRandom2* r2 = new TRandom2();
TH1D* htoyResult_pull[nEtaBin][nPtBin];
TH1D* htoyResult_bias[nEtaBin][nPtBin];
TFile *fsumFile = new TFile("/afs/cern.ch/user/s/syu/scratch0/LxplusArea/proj_comb_comb3Iso_template.root");
TFile* finFile = new TFile("/afs/cern.ch/user/s/syu/scratch0/LxplusArea/template_comb3Iso_template.root");
TFile* zeeFile = new TFile("/afs/cern.ch/user/s/syu/scratch0/LxplusArea/anadipho_Zee_Vg_3pb.root");
TH1D* hTemplate = (TH1D*)finFile->FindObjectAny("h_EB_comb3Iso_EGdata_pt21");
hTemplate->Reset();
char* dec[2] = {"EB","EE"};
for(int ieta=0; ieta<nEtaBin; ieta++){
for(int ipt=0; ipt < nPtBin; ipt++){
htoyResult_pull[ieta][ipt] = new TH1D(Form("hpull_%s_pt_%d",
dec[ieta],
(int)fBinsPt[ipt]),
"",50,-5.0,5.0);
htoyResult_bias[ieta][ipt] = new TH1D(Form("hbias_%s_pt_%d",
dec[ieta],
(int)fBinsPt[ipt]),
"",100,-0.5,0.5);
}
}
TH1D* hfit_sig;
TH1D* hfit_bkg;
TH1D* hTemplate_S[nEtaBin][nPtBin];
TH1D* hTemplate_B[nEtaBin][nPtBin];
TH1D* hZeeTemplate_S[nEtaBin];
TH1D* hdata_data[nEtaBin][nPtBin];
TH1D* htemp;
for(int ieta=0; ieta< nEtaBin; ieta++){
// getting a different signal template
if(ieta==0){
sprintf(tmp,"h_%s_combIso",dec[ieta]);
cout << "looking for histogram " << tmp << " in file " <<
zeeFile->GetName() << endl;
hZeeTemplate_S[ieta]= (TH1D*)zeeFile->FindObjectAny(tmp);
hZeeTemplate_S[ieta]->Rebin(REBINNINGS_TEMP);
}
else {
sprintf(tmp,"h_%s_comb3Iso_sig_sum_SIG",dec[ieta]); //no pt dep.
cout << "looking for histogram " << tmp << " in file " <<
fsumFile->GetName() << endl;
hZeeTemplate_S[ieta]= (TH1D*)fsumFile->FindObjectAny(tmp);
hZeeTemplate_S[ieta]->Rebin(REBINNINGS_TEMP);
}
for(int ipt=0; ipt < nPtBin; ipt++){
if(runIeta>=0 && ieta!=runIeta)continue;
if(runIpt>=0 && ipt!=runIpt)continue;
// getting histograms from data root file
sprintf(tmp,"h_%s_comb3Iso_EGdata_pt%d",dec[ieta],(int)fBinsPt[ipt]);
cout << "looking for histogram " << tmp << " in file " <<
finFile->GetName() << endl;
hdata_data[ieta][ipt] = (TH1D*)finFile->FindObjectAny(tmp);
hdata_data[ieta][ipt]->Rebin(REBINNINGS_DATA);
// filling unbinned data
htemp = (TH1D*)hdata_data[ieta][ipt]->Clone("htemp");
htemp->Reset();
sprintf(tmp,"h_%s_comb3Iso_sig_pt%d",dec[ieta],(int)fBinsPt[ipt]);
cout << "looking for histogram " << tmp << " in file " <<
finFile->GetName() << endl;
hTemplate_S[ieta][ipt] = (TH1D*)finFile->FindObjectAny(tmp);
hTemplate_S[ieta][ipt]->Rebin(REBINNINGS_TEMP);
if(ieta==0 && fBinsPt[ipt]>=50)
sprintf(tmp,"h_%s_comb3Iso_bkg_pt%d",dec[ieta],50);
else if(ieta==0 )
sprintf(tmp,"h_%s_comb3Iso_bkg_pt%d",dec[ieta],(int)fBinsPt[ipt]);
else if(ieta==1 && fBinsPt[ipt]>=60)
sprintf(tmp,"h_%s_comb3IsoSB_EGdata_pt%d",dec[ieta],60);
else if(ieta==1)
sprintf(tmp,"h_%s_comb3IsoSB_EGdata_pt%d",dec[ieta],(int)fBinsPt[ipt]);
cout << "looking for histogram " << tmp << " in file " <<
finFile->GetName() << endl;
hTemplate_B[ieta][ipt] = (TH1D*)finFile->FindObjectAny(tmp);
hTemplate_B[ieta][ipt]->Rebin(REBINNINGS_TEMP);
const int NRETURN = 3*NPAR;
Double_t myFitPar[NRETURN]={0};
Double_t* FuncFitResult;
FuncFitResult = Ifit("/afs/cern.ch/user/s/syu/scratch0/LxplusArea/EGdata_comb3Iso_et.dat",
hZeeTemplate_S[ieta],hTemplate_B[ieta][ipt],
hdata_data[ieta][ipt], myFitPar,
(int)fBinsPt[ipt], dec[ieta],2);
Double_t nsig_input = FuncFitResult[0];
Double_t nsigerr_input = FuncFitResult[1];
Double_t nbkg_input = FuncFitResult[2];
Double_t nbkgerr_input = FuncFitResult[3];
Double_t nsig_input5GeV = FuncFitResult[4];
Double_t nsigerr_input5GeV = FuncFitResult[5];
// force the parameters since EE pt=40 fails
if(ieta==1 && ipt==5)
{
nsig_input = 3172.0;
nbkg_input = 10031.0;
nsig_input5GeV = 3158.7;
Double_t tempPar[NRETURN]={
22517.049862,
0.900766,
0.044772,
0.191920,
313.878244,
-0.545069,
-0.281830,
0.026143,
2.549494,
0.,
0.,
22517.049862,
0.900766,
0.044772,
0.191920,
313.878244,
-0.545069,
-0.281830,
0.026143,
2.549494,
0.,
0.,
22517.049862,
0.900766,
0.044772,
0.191920,
313.878244,
-0.545069,
-0.281830,
0.026143,
2.549494,
0.,
0.
};
for(int ipar=0; ipar <NRETURN; ipar++)
myFitPar[ipar] = tempPar[ipar];
} // end if EE, Et=40 GeV
Double_t sigFitPar[NPAR]={0};
for(int ipar=0; ipar<NPAR; ipar++)
sigFitPar[ipar] = myFitPar[ipar];
Double_t bkgFitPar[NPAR]={0};
for(int ipar=0; ipar<NPAR; ipar++)
bkgFitPar[ipar] = myFitPar[ipar+NPAR];
Double_t sumFitPar[NPAR]={0};
for(int ipar=0; ipar<NPAR; ipar++)
sumFitPar[ipar] = myFitPar[ipar+NPAR*2];
TF1* fsig = new TF1("fsig", exp_conv, fit_lo, fit_hi, 11);
fsig->SetParameters(sigFitPar);
fsig->SetParameter(0,1.0);
mySigPDFnorm = fsig->Integral(fit_lo,fit_hi);
cout << "mySigPDFnorm = " << mySigPDFnorm << endl;
TF1* fbkg = new TF1("fbkg", expinv_power, fit_lo, fit_hi, 11);
fbkg->SetParameters(bkgFitPar);
fbkg->SetParameter(4,1.0);
myBkgPDFnorm = fbkg->Integral(fit_lo, fit_hi);
cout << "myBkgPDFnorm = " << myBkgPDFnorm << endl;
TF1* fsum = new TF1("fsum",mysum_norm, fit_lo, fit_hi,11);
fsum->SetParameters(sumFitPar);
cout << "Using nsig_input = " << nsig_input << endl;
cout << "Using nbkg_input = " << nbkg_input << endl;
cout << "Using nsig_input5GeV = " << nsig_input5GeV << endl;
fsum->SetParameter(0, nsig_input*hdata_data[ieta][ipt]->GetBinWidth(2));
fsum->SetParameter(4, nbkg_input*hdata_data[ieta][ipt]->GetBinWidth(2));
fsum->SetLineColor(2);
fsum->SetNpx(2500);
// cout << "fsum integral = " << fsum->Integral(fit_lo,fit_hi) << endl;
// for(int ipar=0; ipar<NPAR; ipar++)cout << "fsum par " << ipar << " = " << fsum->GetParameter(ipar) << endl;
// FILE *infile = fopen("/afs/cern.ch/user/s/syu/scratch0/LxplusArea/EGdata_comb3Iso_et.dat","r");
// float xdata, xdata1, xdata2; // combined isolation, pt, eta
// int flag = 1;
// while (flag!=-1){
// flag =fscanf(infile,"%f %f %f",&xdata, &xdata1, &xdata2);
// if( xdata1 >= fBinsPt[ipt] && xdata1 < fBinsPt[ipt+1] && xdata<20.) {
// if((ieta==0 && TMath::Abs(xdata2)<1.5) ||
// (ieta==1 && TMath::Abs(xdata2)>1.5) ) {
// htemp->Fill(xdata);
// }
// }
// }// keep reading files as long as text exists
// TCanvas* myCanvas = new TCanvas("myCanvas","myCanvas");
// htemp->Draw();
// fsum->Draw("same");
ofstream dumpout;
dumpout.open(Form("pull_bias%d_%s_pt%d.dat",startExp, dec[ieta],(int)fBinsPt[ipt]));
// // loops over toys
for(int iexp=NEXP*startExp; iexp<NEXP*(startExp+1); iexp++){
TH1D* htoyMC_data = (TH1D*)hdata_data[ieta][ipt]->Clone("htoyMC_data");
htoyMC_data->Reset();
TH1D* htoyMC_sig = (TH1D*)hZeeTemplate_S[ieta]->Clone("htoyMC_sig");
TH1D* htoyMC_bkg = (TH1D*)hTemplate_B[ieta][ipt]->Clone("htoyMC_bkg");
UInt_t nowSeed = (unsigned long)gSystem->Now();
r2->SetSeed(nowSeed);
int nsiggen = r2->Poisson(nsig_input);
int nbkggen = r2->Poisson(nbkg_input);
int ndata = nsiggen + nbkggen;
// reset toy MC data
htoyMC_data->Reset();
ofstream fout;
std::string toyData = Form("/tmp/syu/testtoy%d_%d_%d.dat",startExp,ieta,ipt);
fout.open(toyData.data());
for(int ieve=0; ieve < nsiggen; ieve++)
{
Double_t xvalue = fsig->GetRandom(fit_lo,fit_hi);
fout << xvalue << " " <<
0.5*(fBinsPt[ipt]+fBinsPt[ipt+1]) << " " << fBinsEta[ieta] << endl;
htoyMC_data->Fill(xvalue);
}
for(int ieve=0; ieve < nbkggen; ieve++)
{
Double_t xvalue = fbkg->GetRandom(fit_lo,fit_hi);
fout << xvalue << " " <<
0.5*(fBinsPt[ipt]+fBinsPt[ipt+1]) << " " << fBinsEta[ieta] << endl;
htoyMC_data->Fill(xvalue);
}
fout.close();
Double_t* toyFitResult;
Double_t toyMyFitPar[NRETURN]={0};
toyFitResult = Ifit(toyData.data(),
htoyMC_sig, htoyMC_bkg,
htoyMC_data, toyMyFitPar,
(int)fBinsPt[ipt], dec[ieta],2);
Double_t nsigtoyfit = toyFitResult[0];
Double_t errnsigtoyfit = toyFitResult[1];
Double_t nbkgtoyfit = toyFitResult[2];
Double_t errnbkgtoyfit = toyFitResult[3];
Double_t nsigtoyfit_5GeV = toyFitResult[4];
Double_t errnsigtoyfit_5GeV = toyFitResult[5];
if(errnsigtoyfit < 1e-6 || errnbkgtoyfit < 1e-6 ||
nsigtoyfit < 1e-6 || nbkgtoyfit < 1e-6 ||
nsig_input < 1e-6 || fabs(nsigtoyfit - nsig_input)<1e-4)continue;
Double_t toySumFitPar[NPAR]={0};
for(int ipar=0; ipar<NPAR; ipar++)
toySumFitPar[ipar] = toyMyFitPar[ipar+NPAR*2];
fsum->SetParameters(toySumFitPar);
fsum->SetParameter(0, nsigtoyfit*hdata_data[ieta][ipt]->GetBinWidth(2));
fsum->SetParameter(4, nbkgtoyfit*hdata_data[ieta][ipt]->GetBinWidth(2));
// fsum->SetParameter(0, (float)nsiggen*hdata_data[ieta][ipt]->GetBinWidth(2));
// fsum->SetParameter(4, (float)nbkggen*hdata_data[ieta][ipt]->GetBinWidth(2));
// if(iexp%20==0){
// TCanvas* myCanvas = new TCanvas("myCanvas","SHIT");
// htoyMC_data->SetMaximum(htoyMC_data->GetMaximum()*1.5);
// htoyMC_data->Draw();
// fsum->Draw("same");
// myCanvas->Print(Form("toysPlot/fit_%03i.gif",iexp));
// delete myCanvas;
// }
// cout << "fsum integral = " << fsum->Integral(-1,20) << endl;
// for(int ipar=0; ipar<NPAR; ipar++)cout << "fsum par " << ipar << " = " << fsum->GetParameter(ipar) << endl;
Double_t pull = (nsigtoyfit - nsig_input)/errnsigtoyfit;
Double_t bias = (nsigtoyfit - nsig_input)/nsig_input;
dumpout << pull << " " << bias << endl;
htoyResult_pull[ieta][ipt]->Fill(pull);
htoyResult_bias[ieta][ipt]->Fill(bias);
} // end loops of toys
dumpout.close();
delete fsig;
delete fbkg;
} // end of loop over pt bins
}
// TFile* outFile = new TFile(Form("fittertest%d_%s_pt%d.root",
// startExp,
// dec[runIeta], (int)fBinsPt[runIpt]),
// "recreate");
// for(int ieta=0; ieta < nEtaBin; ieta++){
// for(int ipt=0; ipt < nPtBin; ipt++){
// if(htoyResult_pull[ieta][ipt]->GetEntries()>0)
// htoyResult_pull[ieta][ipt]->Write();
// if(htoyResult_bias[ieta][ipt]->GetEntries()>0)
// htoyResult_bias[ieta][ipt]->Write();
// }
// }
// outFile->Close();
}
//==============================================
void RecoEff::Loop(Int_t selDimuType, Bool_t useMCWeight)
{
if (fChain == 0) return;
Long64_t nentries = fChain->GetEntries();
Long64_t cutAtRecEvent = nentries;
Long64_t countRecEvent = 0;
Long64_t nb = 0;
printf("<RecoEff> number of entries = %d\n", (Int_t) nentries);
//apply a weight as the ratio of pT distributions:
//1.) default Pythia (parametrization)
TF1 *fPT = new TF1("fPT", "[0]*x*pow(1.+(1./([1]-2.))*x*x/[2],-[1])", 0., 50.);
fPT->FixParameter(0, 0.61554); fPT->SetParName(0, "norm");
fPT->FixParameter(1, 4.05847); fPT->SetParName(1, "beta");
fPT->FixParameter(2, 19.93); fPT->SetParName(2, "<pT2> [GeV2]");
//alternatively, the pT distribution can be taken from
//a CASCADE calculation:
TF1 *fPTCASCADE = new TF1("fPTCASCADE", "[0]*x*pow(1.+(1./([1]-2.))*x*x/[2],-[1])", 0., 50.);
fPTCASCADE->FixParameter(0, 1.); fPTCASCADE->SetParName(0, "norm");
fPTCASCADE->FixParameter(1, 3.87004); fPTCASCADE->SetParName(1, "beta");
fPTCASCADE->FixParameter(2, 15.5821); fPTCASCADE->SetParName(2, "<pT2> [GeV2]");
//alternatively, the pT distribution can be taken from the
//preliminary ATLAS data shown in Moriond, 17th April
TF1 *fPTATLAS = new TF1("fPTATLAS", "[0]*x*pow(1.+(1./([1]-2.))*x*x/[2],-[1])", 0., 50.);
fPTATLAS->FixParameter(0, 1.); fPTATLAS->SetParName(0, "norm");
fPTATLAS->FixParameter(1, 3.87004); fPTATLAS->SetParName(1, "beta");
fPTATLAS->FixParameter(2, 15.5821); fPTATLAS->SetParName(2, "<pT2> [GeV2]");
//loop over the events
for (Long64_t jentry=0; jentry<nentries;jentry++) {
if(jentry % 100000 == 0) printf("event %d\n", (Int_t) jentry);
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry);
//===================================================================
//1.) check all generated (and filtered) events and
//fill the corresponding histograms
//===================================================================
Bool_t genMuonsInPS = kTRUE;
Double_t etaMuPos_Gen = muPos_Gen->PseudoRapidity();
Double_t etaMuNeg_Gen = muNeg_Gen->PseudoRapidity();
Double_t pTMuPos_Gen = muPos_Gen->Pt();
Double_t pTMuNeg_Gen = muNeg_Gen->Pt();
Double_t pMuPos_Gen = muPos_Gen->P();
Double_t pMuNeg_Gen = muNeg_Gen->P();
//take muons only within a certain eta range
if((fabs(etaMuPos_Gen) < jpsi::etaPS[0] && pTMuPos_Gen < jpsi::pTMuMin[0]) || //mid-rapidity cut
(fabs(etaMuPos_Gen) > jpsi::etaPS[0] && fabs(etaMuPos_Gen) < jpsi::etaPS[1] && pMuPos_Gen < jpsi::pMuMin[1]) ||
(fabs(etaMuPos_Gen) > jpsi::etaPS[1] && fabs(etaMuPos_Gen) < jpsi::etaPS[2] && pTMuPos_Gen < jpsi::pTMuMin[2]))
genMuonsInPS = kFALSE;
// continue;
//(b) on the negative muon
if((fabs(etaMuNeg_Gen) < jpsi::etaPS[0] && pTMuNeg_Gen < jpsi::pTMuMin[0]) || //mid-rapidity cut
(fabs(etaMuNeg_Gen) > jpsi::etaPS[0] && fabs(etaMuNeg_Gen) < jpsi::etaPS[1] && pMuNeg_Gen < jpsi::pMuMin[1]) ||
(fabs(etaMuNeg_Gen) > jpsi::etaPS[1] && fabs(etaMuNeg_Gen) < jpsi::etaPS[2] && pTMuNeg_Gen < jpsi::pTMuMin[2]))
genMuonsInPS = kFALSE;
// continue;
Double_t weight = 1.; //allows to weigh with different input distributions (pT, cosTheta, phi, ...)
if(useMCWeight)
weight *= MCweight;
if(genMuonsInPS){ //fill the generator level info only if the muons are emitted in the PS
Double_t onia_Gen_mass = onia_Gen->M();
Double_t onia_Gen_pt = onia_Gen->Pt();
Double_t onia_Gen_P = onia_Gen->P();
Double_t onia_Gen_eta = onia_Gen->PseudoRapidity();
Double_t onia_Gen_rap = onia_Gen->Rapidity();
Double_t onia_Gen_phi = onia_Gen->Phi();
Double_t onia_Gen_mT = sqrt(onia_Gen_mass*onia_Gen_mass + onia_Gen_pt*onia_Gen_pt);
Int_t rapIndex_Gen = -1;
for(int iRap = 0; iRap < 2*jpsi::kNbRapBins; iRap++){
if(onia_Gen_rap > jpsi::rapRange[iRap] && onia_Gen_rap < jpsi::rapRange[iRap+1]){
rapIndex_Gen = iRap;
break;
}
}
Int_t rapForPTIndex_Gen = -1;
for(int iRap = 0; iRap < jpsi::kNbRapForPTBins; iRap++){
if(TMath::Abs(onia_Gen_rap) > jpsi::rapForPTRange[iRap] &&
TMath::Abs(onia_Gen_rap) < jpsi::rapForPTRange[iRap+1]){
rapForPTIndex_Gen = iRap+1;
break;
}
}
Int_t pTIndex_Gen = -1;
for(int iPT = 0; iPT < jpsi::kNbPTBins[rapForPTIndex_Gen]; iPT++){
if(onia_Gen_pt > jpsi::pTRange[rapForPTIndex_Gen][iPT] && onia_Gen_pt < jpsi::pTRange[rapForPTIndex_Gen][iPT+1]){
pTIndex_Gen = iPT+1;
break;
}
}
Int_t rapIntegratedPTIndex_Gen = -1;
for(int iPT = 0; iPT < jpsi::kNbPTBins[0]; iPT++){
if(onia_Gen_pt > jpsi::pTRange[0][iPT] && onia_Gen_pt < jpsi::pTRange[0][iPT+1]){
rapIntegratedPTIndex_Gen = iPT+1;
break;
}
}
// if(rapIndex_Gen < 0){
// // printf("rapIndex_Gen %d, rap(onia) = %f\n", rapIndex_Gen, onia_rap);
// continue;
// }
// if(rapForPTIndex_Gen < 1){
// // printf("rapForPTIndex_Gen %d, rap(onia) = %f\n", rapForPTIndex_Gen, onia_rap);
// continue;
// }
// if(pTIndex_Gen < 1){
// // printf("pTIndex_Gen %d, pT(onia) = %f\n", pTIndex_Gen, onia_pt);
// continue;
// }
Bool_t DimuonInPS = kTRUE;
//select events within a narrow mass window around the J/psi
//(rapidity dependence of the resolution --> different mass windows)
//values obtained from Gaussian fits in "plotMass.C"
Double_t jPsiMassMin = jpsi::polMassJpsi[rapForPTIndex_Gen] - jpsi::nSigMass*jpsi::sigmaMassJpsi[rapForPTIndex_Gen];
Double_t jPsiMassMax = jpsi::polMassJpsi[rapForPTIndex_Gen] + jpsi::nSigMass*jpsi::sigmaMassJpsi[rapForPTIndex_Gen];
if(onia_Gen_mass < jPsiMassMin || onia_Gen_mass > jPsiMassMax)
DimuonInPS = kFALSE;
if(TMath::Abs(onia_Gen_rap) > jpsi::rapYPS)
DimuonInPS = kFALSE;
if(rapIndex_Gen >= 0 && rapForPTIndex_Gen > 0 && pTIndex_Gen > 0 && DimuonInPS == kTRUE){
//==============================
calcPol(*muPos_Gen, *muNeg_Gen);
//==============================
// weight *= fPTCASCADE->Eval(onia_Gen_pt) / fPT->Eval(onia_Gen_pt);
weight *= fPTATLAS->Eval(onia_Gen_pt) / fPT->Eval(onia_Gen_pt);
//fill the generator level histograms
for(int iFrame = 0; iFrame < jpsi::kNbFrames; iFrame++){
//weight = CalcPolWeight(thisCosTh[iFrame]);
//histos for neg. and pos. rapidity separately:
if(rapIndex_Gen >= 0)
hGen2D_pol_pT_rapNP[iFrame][0][rapIndex_Gen]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
if(pTIndex_Gen > 0 && rapIndex_Gen >= 0)
hGen2D_pol_pT_rapNP[iFrame][pTIndex_Gen][rapIndex_Gen]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
//histos taking together +y and -y
hGen2D_pol_pT_rap[iFrame][0][0]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
if(rapIntegratedPTIndex_Gen > 0)
hGen2D_pol_pT_rap[iFrame][rapIntegratedPTIndex_Gen][0]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
if(rapForPTIndex_Gen > 0)
hGen2D_pol_pT_rap[iFrame][0][rapForPTIndex_Gen]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
if(pTIndex_Gen > 0 && rapForPTIndex_Gen > 0)
hGen2D_pol_pT_rap[iFrame][pTIndex_Gen][rapForPTIndex_Gen]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
//histos taking together +y and -y and phi-4-folding
Double_t phiFolded = thisPhi[iFrame];
Double_t thetaAdjusted = thisCosTh[iFrame];
if(thisPhi[iFrame] > -90. && thisPhi[iFrame] < 0.)
phiFolded *= -1;
else if(thisPhi[iFrame] > 90 && thisPhi[iFrame] < 180){
phiFolded = 180. - thisPhi[iFrame];
thetaAdjusted *= -1;
}
else if(thisPhi[iFrame] > -180. && thisPhi[iFrame] < -90.){
phiFolded = 180. + thisPhi[iFrame];
thetaAdjusted *= -1;
}
hGen2D_pol_pT_rap_phiFolded[iFrame][0][0]->Fill(thetaAdjusted, phiFolded, weight);
if(rapIntegratedPTIndex_Gen > 0)
hGen2D_pol_pT_rap_phiFolded[iFrame][rapIntegratedPTIndex_Gen][0]->Fill(thetaAdjusted, phiFolded, weight);
if(rapForPTIndex_Gen > 0)
hGen2D_pol_pT_rap_phiFolded[iFrame][0][rapForPTIndex_Gen]->Fill(thetaAdjusted, phiFolded, weight);
if(pTIndex_Gen > 0 && rapForPTIndex_Gen > 0)
hGen2D_pol_pT_rap_phiFolded[iFrame][pTIndex_Gen][rapForPTIndex_Gen]->Fill(thetaAdjusted, phiFolded, weight);
}
}
}
//===================================================================
//end of Generator level block
//===================================================================
//continue only to process RECO info if
//there is really a RECO dimuon in the event:
if(onia->Pt() > 990.)
continue;
//reject processing of events where the dimuon type (GG, GT or TT)
//does not correspond to the chosen one
if(selDimuType < 3 && JpsiType != selDimuType)
continue;
else if(selDimuType == 3 && JpsiType > 1) //only GG or GT
continue;
// Reco_StatEv->Fill(2.5);//count all events
Double_t etaMuPos = muPos->PseudoRapidity();
Double_t etaMuNeg = muNeg->PseudoRapidity();
Double_t pTMuPos = muPos->Pt();
Double_t pTMuNeg = muNeg->Pt();
Double_t pMuPos = muPos->P();
Double_t pMuNeg = muNeg->P();
//take muons only within a certain eta range
if((fabs(etaMuPos) < jpsi::etaPS[0] && pTMuPos < jpsi::pTMuMin[0]) || //mid-rapidity cut
(fabs(etaMuPos) > jpsi::etaPS[0] && fabs(etaMuPos) < jpsi::etaPS[1] && pMuPos < jpsi::pMuMin[1]) ||
(fabs(etaMuPos) > jpsi::etaPS[1] && fabs(etaMuPos) < jpsi::etaPS[2] && pTMuPos < jpsi::pTMuMin[2]))
continue;
//(b) on the negative muon
if((fabs(etaMuNeg) < jpsi::etaPS[0] && pTMuNeg < jpsi::pTMuMin[0]) || //mid-rapidity cut
(fabs(etaMuNeg) > jpsi::etaPS[0] && fabs(etaMuNeg) < jpsi::etaPS[1] && pMuNeg < jpsi::pMuMin[1]) ||
(fabs(etaMuNeg) > jpsi::etaPS[1] && fabs(etaMuNeg) < jpsi::etaPS[2] && pTMuNeg < jpsi::pTMuMin[2]))
continue;
// Reco_StatEv->Fill(4.5);
Double_t onia_mass = onia->M();
Double_t onia_pt = onia->Pt();
Double_t onia_P = onia->P();
Double_t onia_eta = onia->PseudoRapidity();
Double_t onia_rap = onia->Rapidity();
Double_t onia_phi = onia->Phi();
Double_t onia_mT = sqrt(onia_mass*onia_mass + onia_pt*onia_pt);
Int_t rapIndex = -1;
for(int iRap = 0; iRap < 2*jpsi::kNbRapBins; iRap++){
if(onia_rap > jpsi::rapRange[iRap] && onia_rap < jpsi::rapRange[iRap+1]){
rapIndex = iRap;
break;
}
}
Int_t rapForPTIndex = -1;
for(int iRap = 0; iRap < jpsi::kNbRapForPTBins; iRap++){
if(TMath::Abs(onia_rap) > jpsi::rapForPTRange[iRap] &&
TMath::Abs(onia_rap) < jpsi::rapForPTRange[iRap+1]){
rapForPTIndex = iRap+1;
break;
}
}
Int_t pTIndex = -1;
for(int iPT = 0; iPT < jpsi::kNbPTBins[rapForPTIndex]; iPT++){
if(onia_pt > jpsi::pTRange[rapForPTIndex][iPT] && onia_pt < jpsi::pTRange[rapForPTIndex][iPT+1]){
pTIndex = iPT+1;
break;
}
}
Int_t rapIntegratedPTIndex = -1;
for(int iPT = 0; iPT < jpsi::kNbPTBins[0]; iPT++){
if(onia_pt > jpsi::pTRange[0][iPT] && onia_pt < jpsi::pTRange[0][iPT+1]){
rapIntegratedPTIndex = iPT+1;
break;
}
}
if(rapIndex < 0){
// printf("rapIndex %d, rap(onia) = %f\n", rapIndex, onia_rap);
continue;
}
if(rapForPTIndex < 1){
// printf("rapForPTIndex %d, rap(onia) = %f\n", rapForPTIndex, onia_rap);
continue;
}
if(pTIndex < 1){
// printf("pTIndex %d, pT(onia) = %f\n", pTIndex, onia_pt);
continue;
}
// Reco_StatEv->Fill(5.5);
// //select events with a cut on the lifetime to reject NP J/psis:
// if(Jpsict > jpsi::JpsiCtauMax)
// continue;
// Reco_StatEv->Fill(6.5);
//select events within a narrow mass window around the J/psi
//(rapidity dependence of the resolution --> different mass windows)
//values obtained from Gaussian fits in "plotMass.C"
Double_t jPsiMassMin = jpsi::polMassJpsi[rapForPTIndex] - jpsi::nSigMass*jpsi::sigmaMassJpsi[rapForPTIndex];
Double_t jPsiMassMax = jpsi::polMassJpsi[rapForPTIndex] + jpsi::nSigMass*jpsi::sigmaMassJpsi[rapForPTIndex];
if(onia_mass < jPsiMassMin || onia_mass > jPsiMassMax)
continue;
// Reco_StatEv->Fill(7.5);
if(TMath::Abs(onia_rap) > jpsi::rapYPS)
continue;
// Reco_StatEv->Fill(8.5);
//remaining of the events will be used for the analysis
countRecEvent++;
//fill mass, phi, pt, eta and rap distributions
//a) all bins
Reco_Onia_mass[0][0]->Fill(onia_mass);
Reco_Onia_mass[rapIntegratedPTIndex][0]->Fill(onia_mass);
Reco_Onia_mass[0][rapForPTIndex]->Fill(onia_mass);
//
if(onia_mass > (jpsi::polMassJpsi[rapForPTIndex] - 2.*jpsi::sigmaMassJpsi[rapForPTIndex]) &&
onia_mass < (jpsi::polMassJpsi[rapForPTIndex] + 2.*jpsi::sigmaMassJpsi[rapForPTIndex])){
Reco_Onia_phi[0][0]->Fill(onia_phi);
Reco_Onia_phi[rapIntegratedPTIndex][0]->Fill(onia_phi);
Reco_Onia_phi[0][rapForPTIndex]->Fill(onia_phi);
//
Reco_Onia_pt[0]->Fill(onia_pt);
}
//b) individual pT and rap bins:
Reco_Onia_mass[pTIndex][rapForPTIndex]->Fill(onia_mass);
if(onia_mass > (jpsi::polMassJpsi[rapForPTIndex] - 2.*jpsi::sigmaMassJpsi[rapForPTIndex]) &&
onia_mass < (jpsi::polMassJpsi[rapForPTIndex] + 2.*jpsi::sigmaMassJpsi[rapForPTIndex])){
Reco_Onia_phi[pTIndex][rapForPTIndex]->Fill(onia_phi);
Reco_Onia_pt[rapForPTIndex]->Fill(onia_pt);
Reco_Onia_rap_pT->Fill(onia_rap, onia_pt);
}
//=====================
calcPol(*muPos, *muNeg);
//=====================
// //===================================================
// //calculate delta, the angle between the CS and HX frame
// //Formula from: EJP C69 (2010) 657
// Double_t deltaHXToCS = TMath::ACos(onia_mass * onia->Pz() / (onia_mT * onia_P));
// // Double_t deltaCSToHX = -deltaHXToCS;
// Double_t sin2Delta = pow((onia_pt * onia->Energy() / (onia_P * onia_mT)),2);
// //sin2Delta does not change sign when going from HX-->CS or vice versa
// hDelta[pTIndex][rapForPTIndex]->Fill(deltaHXToCS * 180./TMath::Pi());
// hSin2Delta[pTIndex][rapForPTIndex]->Fill(sin2Delta);
// //===================================================
// Double_t deltaPhi = muPos->Phi() - muNeg->Phi();
// if(deltaPhi < -TMath::Pi()) deltaPhi += 2.*TMath::Pi();
// else if(deltaPhi > TMath::Pi()) deltaPhi -= 2.*TMath::Pi();
// //debugging histos
// hPhiPos_PhiNeg[pTIndex][rapForPTIndex]->Fill(180./TMath::Pi() * muNeg->Phi(), 180./TMath::Pi() * muPos->Phi());
// hPtPos_PtNeg[pTIndex][rapForPTIndex]->Fill(muNeg->Pt(), muPos->Pt());
// hEtaPos_EtaNeg[pTIndex][rapForPTIndex]->Fill(muNeg->PseudoRapidity(), muPos->PseudoRapidity());
// hDeltaPhi[pTIndex][rapForPTIndex]->Fill(deltaPhi);
// Reco_mupl_pt[pTIndex][rapForPTIndex]->Fill(muPos->Pt());
// Reco_mupl_eta[pTIndex][rapForPTIndex]->Fill(muPos->PseudoRapidity());
// Reco_mupl_phi[pTIndex][rapForPTIndex]->Fill(muPos->Phi());
// Reco_mumi_pt[pTIndex][rapForPTIndex]->Fill(muNeg->Pt());
// Reco_mumi_eta[pTIndex][rapForPTIndex]->Fill(muNeg->PseudoRapidity());
// Reco_mumi_phi[pTIndex][rapForPTIndex]->Fill(muNeg->Phi());
//fill the histos for all the different frames
for(int iFrame = 0; iFrame < jpsi::kNbFrames; iFrame++){
// weight *= CalcPolWeight(thisCosTh[iFrame]);
//histos for neg. and pos. rapidity separately:
if(rapIndex >= 0)
Reco2D_pol_pT_rapNP[iFrame][0][rapIndex]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
if(pTIndex > 0 && rapIndex >= 0)
Reco2D_pol_pT_rapNP[iFrame][pTIndex][rapIndex]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
//histos taking together +y and -y
Reco2D_pol_pT_rap[iFrame][0][0]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
if(rapIntegratedPTIndex > 0)
Reco2D_pol_pT_rap[iFrame][rapIntegratedPTIndex][0]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
if(rapForPTIndex > 0)
Reco2D_pol_pT_rap[iFrame][0][rapForPTIndex]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
if(pTIndex > 0 && rapForPTIndex > 0)
Reco2D_pol_pT_rap[iFrame][pTIndex][rapForPTIndex]->Fill(thisCosTh[iFrame], thisPhi[iFrame], weight);
//histos taking together +y and -y and phi-4-folding
Double_t phiFolded = thisPhi[iFrame];
Double_t thetaAdjusted = thisCosTh[iFrame];
if(thisPhi[iFrame] > -90. && thisPhi[iFrame] < 0.)
phiFolded *= -1;
else if(thisPhi[iFrame] > 90 && thisPhi[iFrame] < 180){
phiFolded = 180. - thisPhi[iFrame];
thetaAdjusted *= -1;
}
else if(thisPhi[iFrame] > -180. && thisPhi[iFrame] < -90.){
phiFolded = 180. + thisPhi[iFrame];
thetaAdjusted *= -1;
}
Reco2D_pol_pT_rap_phiFolded[iFrame][0][0]->Fill(thetaAdjusted, phiFolded, weight);
if(rapIntegratedPTIndex > 0)
Reco2D_pol_pT_rap_phiFolded[iFrame][rapIntegratedPTIndex][0]->Fill(thetaAdjusted, phiFolded, weight);
if(rapForPTIndex > 0)
Reco2D_pol_pT_rap_phiFolded[iFrame][0][rapForPTIndex]->Fill(thetaAdjusted, phiFolded, weight);
if(pTIndex > 0 && rapForPTIndex > 0)
Reco2D_pol_pT_rap_phiFolded[iFrame][pTIndex][rapForPTIndex]->Fill(thetaAdjusted, phiFolded, weight);
}
}//loop over entries
printf("nb. of rec. events is %d of a total of %d events\n", (Int_t) countRecEvent, (Int_t) nentries);
}
void fillTree(TTree*& tree, TGraph*& graph, double& limit, double& lowlimit, unsigned int itype, std::map<double, std::string>& tanb_values, bool upper_exclusion, unsigned int verbosity)
{
double value=-99;
double tanb_help=-99;
unsigned int ibin=0;
// fill graph with scanned points
cout << "now looping on map" << endl;
for(std::map<double, std::string>::const_iterator tanb = tanb_values.begin(); tanb!=tanb_values.end(); ++tanb){
value = singlePointLimit(tanb->second, tanb->first, itype, verbosity);
cout << "value = " << value << " = singlePointLimit(" << tanb->second <<", " << tanb->first << ", " << itype << ", " << verbosity << ");" << endl;
if( value>0 ){
graph->SetPoint(ibin++, tanb->first, value);
cout << "graph->SetPoint("<< ibin++ <<", " << tanb->first<<", "<< value << ");"<< endl;
}
tanb_help=tanb->first;
}
cout << "Filled graph. Will now determine the smooth curve on graph for interpolation" << endl;
// determine smooth curve on graph for interpolation
TSpline3* spline = new TSpline3("spline", graph, "r", 3., 10.);
// linear polarisation func
TF1 *fnc = 0;
// determine all crossing points with y==1
std::vector<CrossPoint> points = crossPoints(graph);
int dist = 1;
bool filled = false, lowfilled=false;
unsigned int np = 0;
unsigned int steps = 10e6;
if(points.size()>0) limit = graph->GetX()[upper_exclusion ? points.begin()->first : points.end()->first];
cout << "Starting loop on the points for determining crossings. Points.size()=" << points.size() << endl;
for(std::vector<CrossPoint>::const_reverse_iterator point = points.rbegin(); point!=points.rend(); ++point, ++np){
//for(std::vector<CrossPoint>::iterator point = points.begin(); point!=points.end(); ++point, ++np){
//double min = (point->first-dist)>0 ? graph->GetX()[point->first-dist] : graph->GetX()[0];
double min = (point->first)>0 ? graph->GetX()[point->first] : graph->GetX()[0];
double max = (point->first+dist)<graph->GetN() ? graph->GetX()[point->first+dist] : graph->GetX()[graph->GetN()-1];
//double y_min = (point->first-dist)>0 ? graph->GetY()[point->first-dist] : graph->GetY()[0];
double y_min = (point->first)>0 ? graph->GetY()[point->first] : graph->GetY()[0];
double y_max = (point->first+dist)<graph->GetN() ? graph->GetY()[point->first+dist] : graph->GetY()[graph->GetN()-1];
vector<double> crossing;
crossing.push_back((min-max-y_max*min+y_min*max)/(y_min-y_max));
//double crossing;
//crossing = (1.-y_min)/(y_max-y_min)*(max-min);
double deltaM = -999.;
double offset = min; double step_size = (max-min)/steps;
double splinelimit;
for(unsigned int scan=0; scan<=steps; ++scan){
if(deltaM<0 || fabs(spline->Eval(offset+scan*step_size)-1.)<deltaM){
splinelimit=offset+scan*step_size;
deltaM=fabs(spline->Eval(offset+scan*step_size)-1.);
}
}
std::cout << "****************************************************************" << std::endl;
std::cout << "* [" << np+1 << "|" << point->second << "] asymptotic limit(";
std::cout << limitType(itype) << ") :" << crossing[np] << " -- " << splinelimit << " deltaM : " << deltaM;
// if(((upper_exclusion && point->second) || (!upper_exclusion && !(point->second))) && !filled){
// //std::cout << "limit is taken from linear interpolation at the moment" << std::endl;
// //limit = crossing;
// std::cout << " [-->to file]"; filled=true; tree->Fill();
// }
if(np==0){
fnc = new TF1("fnc", "[0]*x+[1]", min, max);
fnc->SetParameter(0, (y_min-y_max)/(min-max));
fnc->SetParameter(1, (y_max*min-y_min*max)/(min-max));
std::cout << std::endl;
std::cout << "high limit is taken from linear interpolation at the moment" << std::endl;
limit = crossing[np];
std::cout << "high limit = " << limit << std::endl;
filled=true;
//std::cout << " [-->to file]"; filled=true; tree->Fill();
}
if(np==1){
fnc = new TF1("fnc", "[0]*x+[1]", min, max);
fnc->SetParameter(0, (y_min-y_max)/(min-max));
fnc->SetParameter(1, (y_max*min-y_min*max)/(min-max));
std::cout << std::endl;
std::cout << "low limit is taken from a spline fit at the moment" << std::endl;
lowlimit = splinelimit; //crossing[np];
std::cout << "low limit = " << lowlimit << std::endl;
lowfilled=true;
//std::cout << " [-->to file]"; lowfilled=true; tree->Fill();
}
std::cout << endl;
std::cout << "****************************************************************" << std::endl;
}
if(filled){
if(lowfilled) {std::cout << " [-->to file]"; tree->Fill();}
else{ lowlimit = 0.5; std::cout << " [-->to file]"; tree->Fill();}
}
// catch cases where no crossing point was found
if(!filled){
if(value<1)
{
std::cout << "WARNING: no crossing found - all tanb values excluded: " << value << std::endl;
if(itype == observed) { limit=1.00; lowlimit=1.00;}
if(itype == plus_2sigma) { limit=3.00; lowlimit=3.00;}
if(itype == plus_1sigma) { limit=2.00; lowlimit=2.00;}
if(itype == expected) { limit=1.50; lowlimit=1.50;}
if(itype == minus_1sigma) { limit=1.00; lowlimit=1.00;}
if(itype == minus_2sigma) { limit=0.50; lowlimit=0.50;}
// limit=2;
// lowlimit=2;
tree->Fill();
}
else
{
std::cout << "WARNING: no crossing found - no tanb value excluded: " << value << " -- " << tanb_help << std::endl;
if(itype == observed) { limit=tanb_help*value; }
if(itype == plus_2sigma) { limit=tanb_help*value; }
if(itype == plus_1sigma) { limit=tanb_help*value; }
if(itype == expected) { limit=tanb_help*value; }
if(itype == minus_1sigma) { limit=tanb_help*value; }
if(itype == minus_2sigma) { limit=tanb_help*value; }
lowlimit=0.2;///////0.5;
tree->Fill();
}
}
cout << "Evaluated crossings. Now plotting" << endl;
//if( verbosity>0 ){
std::string monitor = std::string("SCAN-")+limitType(itype);
TCanvas* canv = new TCanvas(monitor.c_str(), monitor.c_str(), 600, 600);
cout << "Canva created. Now creating frame taking values from graph" << endl;
cout << "Graph getx " << graph->GetX()[0] << endl;
cout << "Graph getn " << graph->GetN() << endl;
cout << "Graph getxn " << graph->GetX()[graph->GetN()-1];
TH1F* frame = canv->DrawFrame(graph->GetX()[0]-0.1, 0., graph->GetX()[graph->GetN()-1]+0.1, 10.);
cout << "Frame created, taking values from graph" << endl;
canv->SetGridx(1); canv->SetGridy(1); canv->cd();
graph->SetMarkerStyle(20.);
graph->SetMarkerColor(kBlack);
graph->SetMarkerSize(1.3);
graph->Draw("P");
//spline->SetLineColor(kBlue);
//spline->SetLineWidth(3.);
//spline->Draw("same");
if(filled) fnc->SetLineColor(kRed);
if(filled) fnc->SetLineWidth(3.);
if(filled) fnc->Draw("same");
canv->Print(monitor.append(".png").c_str(), "png");
delete frame; delete canv; delete spline;
if(filled) delete fnc;
//}
return;
}
void bToDRawYield()
{
gStyle->SetTextSize(0.05);
gStyle->SetTextFont(42);
gStyle->SetPadRightMargin(0.04);
gStyle->SetPadLeftMargin(0.14);
gStyle->SetPadTopMargin(0.1);
gStyle->SetPadBottomMargin(0.14);
gStyle->SetTitleX(.0f);
gStyle->SetOptFit(1111);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
TCanvas* c4 = new TCanvas("c4","",800,600);
c4->Divide(2,2);
TCanvas* c2 = new TCanvas("c2","",400,600);
c2->Divide(1,2);
TCanvas* c1 = new TCanvas();
TCanvas* c15 = new TCanvas("c15","",1300,1000);
// c15->Divide(3,5);
c15->Divide(5,5);
TFile* fPP = new TFile("bFeedDownPP.hist.root");
TFile* fPPMB = new TFile("bFeedDownPPMB.hist.root");
TFile* fPPMC = new TFile("bFeedDownPPMC.hist.root");
TFile* fPPMBMC = new TFile("bFeedDownPPMBMC.hist.root");
TH3D* hDataPP = (TH3D*)fPP->Get("hData");
TH3D* hSidebandPP = (TH3D*)fPP->Get("hSideband");
TH3D* hDataPPMB = (TH3D*)fPPMB->Get("hData");
TH3D* hSidebandPPMB = (TH3D*)fPPMB->Get("hSideband");
TH3D* hPtMD0DcaPP = (TH3D*)fPP->Get("hPtMD0Dca");
TH3D* hPtMD0DcaPPMB = (TH3D*)fPPMB->Get("hPtMD0Dca");
TH3D* hMCPSignalPP = (TH3D*)fPPMC->Get("hMCPSignal");
TH3D* hMCNPSignalPP = (TH3D*)fPPMC->Get("hMCNPSignal");
TH3D* hMCPSignalPPMB = (TH3D*)fPPMBMC->Get("hMCPSignal");
TH3D* hMCNPSignalPPMB = (TH3D*)fPPMBMC->Get("hMCNPSignal");
TH3D* hPtMD0DcaMCPSignalPP = (TH3D*)fPPMC->Get("hPtMD0DcaMCPSignal");
TH3D* hPtMD0DcaMCPSwappedPP = (TH3D*)fPPMC->Get("hPtMD0DcaMCPSwapped");
TH3D* hPtMD0DcaMCPSignalPPMB =(TH3D*)fPPMBMC->Get("hPtMD0DcaMCPSignal");
TH3D* hPtMD0DcaMCPSwappedPPMB = (TH3D*)fPPMBMC->Get("hPtMD0DcaMCPSwapped");
TH3D* hData = (TH3D*)hDataPP->Clone("hData");
hData->Sumw2();
hData->Add(hDataPPMB);
TH3D* hSideband = (TH3D*)hSidebandPP->Clone("hSideband");
hSideband->Sumw2();
hSideband->Add(hSidebandPPMB);
TH3D* hPtMD0Dca = (TH3D*)hPtMD0DcaPP->Clone("hPtMD0Dca");
hPtMD0Dca->Sumw2();
hPtMD0Dca->Add(hPtMD0DcaPPMB);
TH3D* hMCPSignal = (TH3D*)hMCPSignalPP->Clone("hMCPSignal");
hMCPSignal->Sumw2();
hMCPSignal->Add(hMCPSignalPPMB);
TH3D* hMCNPSignal = (TH3D*)hMCNPSignalPP->Clone("hMCNPSignal");
hMCNPSignal->Sumw2();
hMCNPSignal->Add(hMCNPSignalPPMB);
TH3D* hPtMD0DcaMCPSignal = (TH3D*)hPtMD0DcaMCPSignalPP->Clone("hPtMD0DcaMCPSignal");
hPtMD0DcaMCPSignal->Sumw2();
hPtMD0DcaMCPSignal->Add(hPtMD0DcaMCPSignalPPMB);
TH3D* hPtMD0DcaMCPSwapped =(TH3D*)hPtMD0DcaMCPSwappedPP->Clone("hPtMD0DcaMCPSwapped");
hPtMD0DcaMCPSwapped->Sumw2();
hPtMD0DcaMCPSwapped->Add(hPtMD0DcaMCPSwappedPPMB);
TLatex* texCms = new TLatex(0.18,0.93, "#scale[1.25]{CMS} Preliminary");
texCms->SetNDC();
texCms->SetTextAlign(12);
texCms->SetTextSize(0.06);
texCms->SetTextFont(42);
TLatex* texCol = new TLatex(0.96,0.93, "PP #sqrt{s_{NN}} = 5.02 TeV");
texCol->SetNDC();
texCol->SetTextAlign(32);
texCol->SetTextSize(0.06);
texCol->SetTextFont(42);
// const int nPtBins = 14;
// float ptBins[nPtBins+1] = {2.,3.,4.,5.,6.,8.,10.,12.5,15.0,20.,25.,30.,40.,60.,100};
const int nPtBins = 9;
float ptBins[nPtBins+1] = {2.,4.,6.,8.,10.,12.5,20.,40.,60.,100};
float pts[nPtBins];
float ptErrors[nPtBins];
float promptFraction[nPtBins];
float totalYield[nPtBins];
float totalYieldInvMassFit[nPtBins];
float totalYieldInvMassFitError[nPtBins];
float bToDYield[nPtBins];
float bToDYieldError[nPtBins];
float bToDYieldErrorDataOnly[nPtBins];
float promptDYield[nPtBins];
float promptDYieldError[nPtBins];
float promptDYieldErrorDataOnly[nPtBins];
TH1D *D0DcaDataOut[nPtBins];
/*
const int nBinY = 14;
Float_t binsY[nBinY+1];
float firstBinYWidth = 0.001;
float binYWidthRatio = 1.27;
binsY[0]=0;
for(int i=1; i<=nBinY; i++)
binsY[i] = binsY[i-1]+firstBinYWidth*pow(binYWidthRatio,i-1);
cout<<"last y bin: "<<binsY[nBinY]<<endl;
*/
const int nBinY = 20;
Float_t binsY[nBinY+1] = {-0.0734,-0.0562,-0.0428,-0.0320,-0.0236,-0.0170,-0.0118,-0.0078,-0.0046,-0.002,0.0,0.002,0.0046,0.0078,0.0118,0.0170,0.0236,0.0320,0.0428,0.0562,0.0734};
for(int i=1; i<=nPtBins; i++)
{
pts[i-1] = 0.5*(ptBins[i-1]+ptBins[i]);
ptErrors[i-1] = 0.5*(ptBins[i]-ptBins[i-1]);
float ptLow = ptBins[i-1];
float ptHigh = ptBins[i];
cout<<endl<<"======================================="<<endl;
cout<<"pT range: "<<ptLow<<" "<<ptHigh<<endl;
TLatex* texPtY = new TLatex(0.32,0.82,Form("%.1f < p_{T} < %.1f GeV/c |y| < 1.0",ptLow,ptHigh));
texPtY->SetNDC();
texPtY->SetTextFont(42);
texPtY->SetTextSize(0.06);
texPtY->SetLineWidth(2);
TLatex* texPt = new TLatex(0.18,0.82,Form("%.1f < p_{T} < %.1f GeV/c",ptLow,ptHigh));
texPt->SetNDC();
texPt->SetTextFont(42);
texPt->SetTextSize(0.06);
texPt->SetLineWidth(2);
TLatex* texY = new TLatex(0.18,0.74,Form("|y| < 1.0"));
texY->SetNDC();
texY->SetTextFont(42);
texY->SetTextSize(0.06);
texY->SetLineWidth(2);
c2->cd(1);
hPtMD0Dca->GetZaxis()->SetRange(1,100);
hPtMD0Dca->GetXaxis()->SetRangeUser(ptLow+0.001,ptHigh-0.001);
hPtMD0DcaMCPSignal->GetXaxis()->SetRangeUser(ptLow+0.001,ptHigh-0.001);
hPtMD0DcaMCPSwapped->GetXaxis()->SetRangeUser(ptLow+0.001,ptHigh-0.001);
TH1D* hMData = (TH1D*)hPtMD0Dca->Project3D("y")->Clone(Form("hM_%1.1f_%1.1f", ptLow, ptHigh));
TH1D* hMMCSignal = (TH1D*)hPtMD0DcaMCPSignal->Project3D("y");
TH1D* hMMCSwapped = (TH1D*)hPtMD0DcaMCPSwapped->Project3D("y");
setColorTitleLabel(hMData);
setColorTitleLabel(hMMCSignal);
setColorTitleLabel(hMMCSwapped);
TF1* fMass = fitMass(hMData, hMMCSignal, hMMCSwapped);
texCms->Draw();
texCol->Draw();
texPt->Draw();
texY->Draw();
TF1* fSignalAndSwapped = new TF1("fSignalAndSwapped","[0]*([3]*([5]*Gaus(x,[1],[2]*(1+[7]))/(sqrt(2*3.1415927)*[2]*(1+[7]))+(1-[5])*Gaus(x,[1],[6]*(1+[7]))/(sqrt(2*3.1415927)*[6]*(1+[7])))+(1-[3])*Gaus(x,[1],[4]*(1+[7]))/(sqrt(2*3.1415927)*[4]*(1+[7])))", 1.7, 2.0);
fSignalAndSwapped->SetParameter(0,fMass->GetParameter(0));
fSignalAndSwapped->SetParameter(1,fMass->GetParameter(1));
fSignalAndSwapped->SetParameter(2,fMass->GetParameter(2));
fSignalAndSwapped->SetParameter(3,fMass->GetParameter(7));
fSignalAndSwapped->SetParameter(4,fMass->GetParameter(8));
fSignalAndSwapped->SetParameter(5,fMass->GetParameter(9));
fSignalAndSwapped->SetParameter(6,fMass->GetParameter(10));
fSignalAndSwapped->SetParameter(7,fMass->GetParameter(11));
TF1* background = new TF1("fBackground","[0]+[1]*x+[2]*x*x+[3]*x*x*x");
background->SetParameter(0,fMass->GetParameter(3));
background->SetParameter(1,fMass->GetParameter(4));
background->SetParameter(2,fMass->GetParameter(5));
background->SetParameter(3,fMass->GetParameter(6));
cout<<"MC signal width: "<<fMass->GetParameter(2)<<" "<<fMass->GetParameter(10)<<endl;
cout<<"MC swapped width: "<<fMass->GetParameter(8)<<endl;
float massD = 1.8649;
float massSignal1 = massD-0.025;
float massSignal2 = massD+0.025;
float massSideBand1 = massD-0.1;
float massSideBand2 = massD-0.075;
float massSideBand3 = massD+0.075;
float massSideBand4 = massD+0.1;
float scaleSideBandBackground = background->Integral(massSignal1, massSignal2)/(background->Integral(massSideBand1, massSideBand2)+background->Integral(massSideBand3, massSideBand4));
cout<<"scaleSideBandBackground: "<<scaleSideBandBackground<<endl;
totalYieldInvMassFit[i-1] = fMass->GetParameter(0)*fMass->GetParameter(7)/hMData->GetBinWidth(1);
totalYieldInvMassFitError[i-1] = fMass->GetParError(0)*fMass->GetParameter(7)/hMData->GetBinWidth(1);
cout<<"totalYieldInvMassFit: "<<totalYieldInvMassFit[i-1]<<" +- "<<totalYieldInvMassFitError[i-1]<<endl;
float scaleSideBandMethodSignal = fSignalAndSwapped->GetParameter(0)*fSignalAndSwapped->GetParameter(3) / (fSignalAndSwapped->Integral(massSignal1, massSignal2)-fSignalAndSwapped->Integral(massSideBand1, massSideBand2)-fSignalAndSwapped->Integral(massSideBand3, massSideBand4));
cout<<"scaleSideBandMethodSignal: "<<scaleSideBandMethodSignal<<endl;
TLatex* texScale = new TLatex(0.18,0.66,Form("side band bg scale: %1.3f", scaleSideBandBackground));
texScale->SetNDC();
texScale->SetTextFont(42);
texScale->SetTextSize(0.06);
texScale->SetLineWidth(2);
texScale->Draw();
TLine* lineSignal1 = new TLine(massSignal1, 0, massSignal1, hMData->GetMaximum()*0.5);
TLine* lineSignal2 = new TLine(massSignal2, 0, massSignal2, hMData->GetMaximum()*0.5);
TLine* lineSideBand1 = new TLine(massSideBand1, 0, massSideBand1, hMData->GetMaximum()*0.5);
TLine* lineSideBand2 = new TLine(massSideBand2, 0, massSideBand2, hMData->GetMaximum()*0.5);
TLine* lineSideBand3 = new TLine(massSideBand3, 0, massSideBand3, hMData->GetMaximum()*0.5);
TLine* lineSideBand4 = new TLine(massSideBand4, 0, massSideBand4, hMData->GetMaximum()*0.5);
lineSignal1->Draw();
lineSignal2->Draw();
lineSideBand1->Draw();
lineSideBand2->Draw();
lineSideBand3->Draw();
lineSideBand4->Draw();
c2->cd(2);
gPad->SetLogy();
hData->GetXaxis()->SetRangeUser(ptLow+0.001,ptHigh-0.001);
hSideband->GetXaxis()->SetRangeUser(ptLow+0.001,ptHigh-0.001);
hMCPSignal->GetXaxis()->SetRangeUser(ptLow+0.001,ptHigh-0.001);
hMCNPSignal->GetXaxis()->SetRangeUser(ptLow+0.001,ptHigh-0.001);
TH1D* hD0DcaData0 = (TH1D*)hData->Project3D("y")->Clone("hD0DcaData0");
TH1D* hD0DcaSideband = (TH1D*)hSideband->Project3D("y")->Clone("hD0DcaSideband");
TH1D* hD0DcaMCPSignal0 = (TH1D*)hMCPSignal->Project3D("y")->Clone("hD0DcaMCPSignal0");
TH1D* hD0DcaMCNPSignal0 = (TH1D*)hMCNPSignal->Project3D("y")->Clone("hD0DcaMCNPSignal0");
float integralRawYieldMCP = hD0DcaMCPSignal0->Integral();
float integralRawYieldMCNP = hD0DcaMCNPSignal0->Integral();
cout<<"integralRawYieldMCP: "<<integralRawYieldMCP<<endl;
cout<<"integralRawYieldMCNP: "<<integralRawYieldMCNP<<endl;
hD0DcaMCPSignal = hD0DcaMCPSignal0;
hD0DcaMCNPSignal = hD0DcaMCNPSignal0;
divideBinWidth(hD0DcaData0);
divideBinWidth(hD0DcaSideband);
setColorTitleLabel(hD0DcaData0, 1);
hD0DcaData0->GetXaxis()->SetRangeUser(-0.07,0.07);
hD0DcaData0->GetYaxis()->SetTitle("counts per cm");
TH1D* hD0DcaSideband0 = (TH1D*)hD0DcaSideband->Clone("hD0DcaSideband0");
hD0DcaSideband->Scale(scaleSideBandBackground);
TH1D* hD0DcaDataSubSideBand = (TH1D*)hD0DcaData0->Clone("hD0DcaDataSubSideBand");
hD0DcaDataSubSideBand->Add(hD0DcaSideband,-1);
hD0DcaDataSubSideBand->Scale(scaleSideBandMethodSignal);
hD0DcaData0->SetMarkerSize(0.6);
hD0DcaData0->Draw();
hD0DcaSideband->Draw("hsame");
hD0DcaSideband0->SetLineStyle(2);
hD0DcaSideband0->Draw("hsame");
TLegend* leg1 = new TLegend(0.44,0.6,0.90,0.76,NULL,"brNDC");
leg1->SetBorderSize(0);
leg1->SetTextSize(0.06);
leg1->SetTextFont(42);
leg1->SetFillStyle(0);
leg1->AddEntry(hD0DcaData0,"D^{0} candidate","pl");
leg1->AddEntry(hD0DcaSideband,"side band","l");
leg1->AddEntry(hD0DcaSideband0,"side band unscaled","l");
leg1->Draw("same");
texCms->Draw();
texCol->Draw();
texPtY->Draw();
c2->SaveAs(Form("plots/PP_%.0f_%.0f_sideBand.pdf",ptLow,ptHigh));
c2->cd(1);
hMMCSignal->Draw();
texCms->Draw();
texCol->Draw();
texPt->Draw();
texY->Draw();
c2->cd(2);
gPad->SetLogy(0);
hMMCSwapped->Draw();
texCms->Draw();
texCol->Draw();
texPt->Draw();
texY->Draw();
c2->SaveAs(Form("plots/PP_%.0f_%.0f_McInvMassFit.pdf",ptLow,ptHigh));
c15->cd(1);
fitMass(hMData, hMMCSignal, hMMCSwapped);
texPt->Draw();
texY->Draw();
TH1D* hD0DcaDataFit = new TH1D("hD0DcaDataFit", ";D^{0} DCA (cm);dN / d(D^{0} DCA) (cm^{-1})", nBinY, binsY);
for(int j=1; j<=20; j++)
{
c15->cd(j+1);
hPtMD0Dca->GetZaxis()->SetRange(j,j);
float D0DcaLow = hPtMD0Dca->GetZaxis()->GetBinLowEdge(j);
float D0DcaHigh = hPtMD0Dca->GetZaxis()->GetBinUpEdge(j);
TH1D* hMData_D0Dca = (TH1D*)hPtMD0Dca->Project3D("y")->Clone(Form("hM_pt_%1.1f_%1.1f_D0Dca_%1.4f_%1.4f", ptLow, ptHigh, D0DcaLow, D0DcaHigh));
setColorTitleLabel(hMData_D0Dca);
fMass = fitMass(hMData_D0Dca, hMMCSignal, hMMCSwapped);
float yield = fMass->GetParameter(0)*fMass->GetParameter(7)/hMData_D0Dca->GetBinWidth(1);
float yieldError = fMass->GetParError(0)*fMass->GetParameter(7)/hMData_D0Dca->GetBinWidth(1);
hD0DcaDataFit->SetBinContent(j, yield);
hD0DcaDataFit->SetBinError(j, yieldError);
TLatex* texD0Dca = new TLatex(0.18,0.82,Form("D^{0} DCA: %1.4f - %1.4f",D0DcaLow,D0DcaHigh));
texD0Dca->SetNDC();
texD0Dca->SetTextFont(42);
texD0Dca->SetTextSize(0.06);
texD0Dca->SetLineWidth(2);
texD0Dca->Draw();
TLatex* texYield = new TLatex(0.18,0.74,Form("D^{0} yield: %1.0f #pm %1.0f",yield,yieldError));
texYield->SetNDC();
texYield->SetTextFont(42);
texYield->SetTextSize(0.06);
texYield->SetLineWidth(2);
texYield->Draw();
}
c15->SaveAs(Form("plots/PP_%.0f_%.0f_invMassFit.pdf",ptLow,ptHigh));
if(pts[i-1]<=20)
{ D0DcaDataOut[i-1]=(TH1D*)hD0DcaDataFit->Clone(Form("D0DcaDataOut_pt%i",i-1));}
if(pts[i-1]>20)
{ D0DcaDataOut[i-1]=(TH1D*)hD0DcaDataSubSideBand->Clone(Form("D0DcaDataOut_pt%i",i-1));
mutiplyBinWidth(D0DcaDataOut[i-1]);
}
divideBinWidth(hD0DcaDataFit);
c4->cd(1);
gPad->SetLogy();
normalize(hD0DcaMCPSignal);
setColorTitleLabel(hD0DcaMCPSignal, 2);
hD0DcaMCPSignal->GetXaxis()->SetRangeUser(-0.07,0.07);
normalize(hD0DcaMCNPSignal);
setColorTitleLabel(hD0DcaMCNPSignal, 4);
hD0DcaMCNPSignal->GetXaxis()->SetRangeUser(-0.07,0.07);
hD0DcaMCNPSignal->GetYaxis()->SetTitle("dN / d(D^{0} DCA) (cm^{-1})");
hD0DcaMCNPSignal->GetXaxis()->SetTitle("D^{0} DCA (cm)");
hD0DcaMCNPSignal->SetMaximum(hD0DcaMCPSignal->GetMaximum()*3.);
hD0DcaMCNPSignal->Draw("");
hD0DcaMCPSignal->Draw("same");
TLegend* leg2 = new TLegend(0.54,0.72,0.90,0.88,NULL,"brNDC");
leg2->SetBorderSize(0);
leg2->SetTextSize(0.06);
leg2->SetTextFont(42);
leg2->SetFillStyle(0);
leg2->AddEntry(hD0DcaMCPSignal,"MC Prompt D^{0}","pl");
leg2->AddEntry(hD0DcaMCNPSignal,"MC Non-prompt D^{0}","pl");
leg2->Draw("same");
c4->cd(2);
gPad->SetLogy();
TH1D* hD0DcaData = hD0DcaDataFit;
if(pts[i-1]>8) hD0DcaData = hD0DcaDataSubSideBand;
setColorTitleLabel(hD0DcaData, 1);
double integralTotalYield = hD0DcaData->Integral(1,hD0DcaData->GetXaxis()->GetNbins(),"width");
cout<<"integralTotalYield: "<<integralTotalYield<<endl;
TF1* fMix = new TF1("fMix",&funMix, -0.5, 0.5, 2);
fMix->SetParameters(0.5*integralTotalYield,0.5*integralTotalYield);
fMix->SetParLimits(0,0,2*integralTotalYield);
fMix->SetParLimits(1,0,2*integralTotalYield);
fMix->SetLineColor(2);
fMix->SetFillColor(kRed-9);
fMix->SetFillStyle(1001);
float fitRangeL = -0.08;
float fitRangeH = 0.08;
hD0DcaData->GetXaxis()->SetRangeUser(-0.07,0.07);
hD0DcaData->Draw();
int fitStatus = 1;
TFitResultPtr fitResult;
double fitPrecision = 1.e-6;
while(fitStatus)
{
TFitter::SetPrecision(fitPrecision);
fMix->SetParameters(0.5*integralTotalYield,0.5*integralTotalYield);
fMix->SetParError(0,0.1*integralTotalYield);
fMix->SetParError(1,0.1*integralTotalYield);
fitResult = hD0DcaData->Fit("fMix","E SNQ0", "", fitRangeL, fitRangeH);
fitStatus = fitResult->Status();
cout<<"fit precision: "<<TFitter::GetPrecision()<<" status: "<<fitStatus<<endl;
if(fitStatus)
fitPrecision *= 10;
}
cout<<"============== do main fit ============"<<endl;
fMix->SetParameters(integralTotalYield,0.9);
fMix->SetParError(0,0.1*integralTotalYield);
fMix->SetParError(1,0.1);
fMix->SetNpx(10000);
fitResult = hD0DcaData->Fit("fMix","E S0", "", fitRangeL, fitRangeH);
hD0DcaData->GetFunction("fMix")->Draw("flsame");
fitStatus = fitResult->Status();
cout<<"fit precision: "<<TFitter::GetPrecision()<<" status: "<<fitStatus<<endl;
TF1* fNP = new TF1("fNP",&funNonPrompt, 0., 0.5, 2);
fNP->SetParameters(fMix->GetParameter(0),fMix->GetParameter(1));
fNP->SetRange(fitRangeL,fitRangeH);
fNP->SetLineColor(4);
fNP->SetFillStyle(1001);
fNP->SetFillColor(kBlue-9);
fNP->SetNpx(10000);
fNP->Draw("same");
hD0DcaData->Draw("same");
promptDYield[i-1] = fMix->GetParameter(0);
promptDYieldErrorDataOnly[i-1] = fMix->GetParError(0);
bToDYield[i-1] = fMix->GetParameter(1);
bToDYieldErrorDataOnly[i-1] = fMix->GetParError(1);
totalYield[i-1] = promptDYield[i-1]+bToDYield[i-1];
promptFraction[i-1] = promptDYield[i-1]/totalYield[i-1];
cout<<"chi2 / NDF: "<<fitResult->Chi2()<<" / "<<fitResult->Ndf()<<endl;
texCms->Draw();
texCol->Draw();
texPtY->Draw();
TLatex* texPrompt = new TLatex(0.4,0.73,Form("Prompt D^{0} yield : %.0f #pm %.0f",fMix->GetParameter(0),fMix->GetParError(0)));
texPrompt->SetNDC();
texPrompt->SetTextFont(42);
texPrompt->SetTextSize(0.06);
texPrompt->SetLineWidth(2);
texPrompt->Draw();
TLatex* texNonPrompt = new TLatex(0.4,0.65,Form("B to D^{0} yield : %.0f #pm %.0f",fMix->GetParameter(1),fMix->GetParError(1)));
texNonPrompt->SetNDC();
texNonPrompt->SetTextFont(42);
texNonPrompt->SetTextSize(0.06);
texNonPrompt->SetLineWidth(2);
texNonPrompt->Draw();
TLegend* leg4 = new TLegend(0.56,0.38,0.90,0.62);
leg4->SetBorderSize(0);
leg4->SetTextSize(0.06);
leg4->SetTextFont(42);
leg4->SetFillStyle(0);
leg4->AddEntry(hD0DcaData,"Data","pl");
leg4->AddEntry(fMix,"Prompt D^{0}","f");
leg4->AddEntry(fNP,"B to D^{0}","f");
leg4->Draw("same");
//smear MC smaple with the error, to simulate the MC statistic error effect.
c4->cd(3);
hD0DcaMCPSignal = (TH1D*)hD0DcaMCPSignal0->Clone("hMCPSignal");
hD0DcaMCNPSignal = (TH1D*)hD0DcaMCNPSignal0->Clone("hMCNPSignal");
TH1D* hNPYield = new TH1D("hNPYield", ";hNPYield", 100, 0., 1.1*(fMix->GetParameter(0)+fMix->GetParameter(1)));
TH1D* hPYield = new TH1D("hPYield", ";hPYield", 100, 0., 1.1*(fMix->GetParameter(0)+fMix->GetParameter(1)));
setColorTitleLabel(hNPYield, 1);
setColorTitleLabel(hPYield, 1);
int nSmear = 1000;
for(int j=0; j<nSmear; j++)
{
RandomSmear(hD0DcaMCPSignal0, hD0DcaMCPSignal);
RandomSmear(hD0DcaMCNPSignal0, hD0DcaMCNPSignal);
fMix->SetParameters(0.5*integralTotalYield,0.5*integralTotalYield);
fMix->SetParError(0,0.1*integralTotalYield);
fMix->SetParError(1,0.1*integralTotalYield);
hD0DcaData->Fit("fMix","E QN0");
hPYield->Fill(fMix->GetParameter(0));
hNPYield->Fill(fMix->GetParameter(1));
}
hPYield->GetXaxis()->SetTitle("prompt D^{0} yield");
hPYield->GetYaxis()->SetTitle("counts");
hPYield->GetYaxis()->SetRangeUser(0.5, 1.4*hPYield->GetMaximum());
hPYield->SetMarkerStyle(20);
hPYield->SetStats(0);
hPYield->Draw("e");
hPYield->Fit("gaus");
TLatex* texGaussMeanSigmaP = new TLatex(0.27,0.83,Form("#mu: %.0f #sigma: %.0f",hPYield->GetFunction("gaus")->GetParameter(1),hPYield->GetFunction("gaus")->GetParameter(2)));
texGaussMeanSigmaP->SetNDC();
texGaussMeanSigmaP->SetTextFont(42);
texGaussMeanSigmaP->SetTextSize(0.06);
texGaussMeanSigmaP->SetLineWidth(2);
texGaussMeanSigmaP->Draw();
float promptYieldErrorMc = hPYield->GetFunction("gaus")->GetParameter(2);
promptDYieldError[i-1] = sqrt(pow(promptDYieldErrorDataOnly[i-1],2)+pow(promptYieldErrorMc,2));
c4->cd(4);
hNPYield->GetXaxis()->SetTitle("B to D^{0} yield");
hNPYield->GetYaxis()->SetTitle("counts");
hNPYield->GetYaxis()->SetRangeUser(0.5, 1.4*hNPYield->GetMaximum());
hNPYield->SetMarkerStyle(20);
hNPYield->SetStats(0);
hNPYield->Draw("e");
hNPYield->Fit("gaus");
TLatex* texGaussMeanSigmaNP = new TLatex(0.27,0.83,Form("#mu: %.0f #sigma: %.0f",hNPYield->GetFunction("gaus")->GetParameter(1),hNPYield->GetFunction("gaus")->GetParameter(2)));
texGaussMeanSigmaNP->SetNDC();
texGaussMeanSigmaNP->SetTextFont(42);
texGaussMeanSigmaNP->SetTextSize(0.06);
texGaussMeanSigmaNP->SetLineWidth(2);
texGaussMeanSigmaNP->Draw();
float bToDYieldErrorMc = hNPYield->GetFunction("gaus")->GetParameter(2);
bToDYieldError[i-1] = sqrt(pow(bToDYieldErrorDataOnly[i-1],2)+pow(bToDYieldErrorMc,2));
cout<<"prompt D yield: "<<promptDYield[i-1]<<" +- "<<promptDYieldError[i-1]<<" (+- "<<promptDYieldErrorDataOnly[i-1]<<" +- "<<promptYieldErrorMc<<" )"<<endl;
cout<<"B to D yield: "<<bToDYield[i-1]<<" +- "<<bToDYieldError[i-1]<<" (+- "<<bToDYieldErrorDataOnly[i-1]<<" +- "<<bToDYieldErrorMc<<" )"<<endl;
cout<<"total yield: "<<totalYield[i-1]<<endl;
cout<<"prompt fraction: "<<promptFraction[i-1]<<endl;
float promptMCScale = promptDYield[i-1]/integralRawYieldMCP;
float nonPromptMCScale = bToDYield[i-1]/integralRawYieldMCNP;
cout<<"promptMCScale: "<<promptMCScale<<endl;
cout<<"nonPromptMCScale: "<<nonPromptMCScale<<endl;
//restore original unsmeared histograms before saving plots
delete hD0DcaMCPSignal;
delete hD0DcaMCNPSignal;
hD0DcaMCPSignal = hD0DcaMCPSignal0;
hD0DcaMCNPSignal = hD0DcaMCNPSignal0;
hD0DcaData->Fit("fMix","E QN0");
c4->SaveAs(Form("plots/PP_%.0f_%.0f_fit.pdf",ptLow,ptHigh));
c1->cd();
TH1D* hD0DcaDataOverFit = (TH1D*)hD0DcaData->Clone("hD0DcaDataOverFit");
hD0DcaDataOverFit->Divide(fMix);
hD0DcaDataOverFit->GetYaxis()->SetTitle("data / fit");
hD0DcaDataOverFit->GetYaxis()->SetRangeUser(0,5);
hD0DcaDataOverFit->GetXaxis()->SetRangeUser(-0.07,0.07);
setColorTitleLabel(hD0DcaDataOverFit, 1);
hD0DcaDataOverFit->Draw("e");
TF1* fLine1 = new TF1("fLine1", "1", 0,1);
fLine1->Draw("same");
hD0DcaDataOverFit->Draw("esame");
c1->SaveAs(Form("plots/dataOverFit_%.0f_%.0f_fit.pdf",ptLow,ptHigh));
delete hD0DcaMCPSignal;
delete hD0DcaMCNPSignal;
}
c1->cd();
TH1D* hStupidJie = new TH1D("hStupidJie", "", 100, 0, 100);
hStupidJie->GetYaxis()->SetRangeUser(0,1);
hStupidJie->GetXaxis()->SetTitle("p_{T} (GeV/c)");
hStupidJie->GetYaxis()->SetTitle("prompt fraction");
hStupidJie->SetStats(0);
hStupidJie->Draw();
TGraph* grFraction = new TGraph(nPtBins, pts, promptFraction);
grFraction->SetName("grPromptFraction");
grFraction->SetMarkerStyle(20);
grFraction->Draw("psame");
c1->SaveAs("promptFraction.pdf");
c1->SetLogy();
TH1D* hBtoDRawYield = new TH1D("hBtoDRawYield", ";p_{T} (GeV/c);dN/dp_{T} ((GeV/c)^{-1})", nPtBins, ptBins);
for(int i=1; i<=nPtBins; i++)
{
if(bToDYield[i-1] <= 0) continue;
hBtoDRawYield->SetBinContent(i, bToDYield[i-1]);
hBtoDRawYield->SetBinError(i, bToDYieldError[i-1]);
}
divideBinWidth(hBtoDRawYield);
setColorTitleLabel(hBtoDRawYield, 1);
c1->SetBottomMargin(0.14);
hBtoDRawYield->Draw("p");
c1->SaveAs("BtoD.pdf");
TH1D* hPromptDRawYield = new TH1D("hPromptDRawYield", ";p_{T} (GeV/c);dN/dp_{T} ((GeV/c)^{-1})", nPtBins, ptBins);
for(int i=1; i<=nPtBins; i++)
{
if(promptDYield[i-1] <= 0) continue;
hPromptDRawYield->SetBinContent(i, promptDYield[i-1]);
hPromptDRawYield->SetBinError(i, promptDYieldError[i-1]);
}
divideBinWidth(hPromptDRawYield);
setColorTitleLabel(hPromptDRawYield, 1);
c1->SetBottomMargin(0.14);
hPromptDRawYield->Draw("p");
c1->SaveAs("promptD.pdf");
TH1D* hTotalDYieldInvMassFit = new TH1D("hTotalDYieldInvMassFit", ";p_{T} (GeV/c);dN/dp_{T} ((GeV/c)^{-1})", nPtBins, ptBins);
for(int i=1; i<=nPtBins; i++)
{
if(totalYieldInvMassFit[i-1] <= 0) continue;
hTotalDYieldInvMassFit->SetBinContent(i, totalYieldInvMassFit[i-1]);
hTotalDYieldInvMassFit->SetBinError(i, totalYieldInvMassFitError[i-1]);
}
divideBinWidth(hTotalDYieldInvMassFit);
setColorTitleLabel(hTotalDYieldInvMassFit, 1);
hTotalDYieldInvMassFit->Draw("p");
c1->SaveAs("totalDInvMassFit.pdf");
TFile* fOut = new TFile("bFeedDownResult.root", "recreate");
fOut->WriteTObject(grFraction);
fOut->WriteTObject(hBtoDRawYield);
fOut->WriteTObject(hPromptDRawYield);
fOut->WriteTObject(hTotalDYieldInvMassFit);
fOut->cd();
for (int i = 0; i<nPtBins;i++){
D0DcaDataOut[i]->Write();
}
fOut->Write();
fOut->Close();
cout<<"end of main"<<endl;
}
int CaloL3(const char *ctype="Calo")
{
bool iSave=false;
double minx=1.0;
LoadStyle();
gStyle->SetOptStat(1);
gStyle->SetOptFit(1);
//string outdir="txtfiles/";
string outdir="junk/";
cout << " # of bins in pt : " << nbins << endl;
//return 0;
TVirtualFitter::SetDefaultFitter("Minuit");
TH1F *hrsp[knj][nbins];
TGraphErrors *grsp[knj], *gcor[knj];
TH1F *hMean[knj], *hRMS[knj];
//TFile *fin = new TFile("jra_hiF_akcalo_ppReco_757p1_dijet.root","r");
//TFile *fin = new TFile("jra_hiF_akcalo_ppReco_757p1_dijet_fulleta_fullpt.root","r");
TFile *fin = new TFile("jra_hiF_akcalo_ppReco_757p1_HcalRespCorrs_v4_00_mc_dijet.root","r");
double refptmin=0;
double refptmax=1000;
TLegend *l0 = getLegend(0.6349664,0.3265565,0.8491835,0.7128335);
l0->SetHeader(Form("Anti-k_{T}, %s",ctype));
TLegend *l1 = getLegend(0.1500646,0.5052258,0.3653091,0.7490942);
l1->SetHeader("");
TF1 *fgaus=0;
TH1F *hrefpt=0, *hjetpt=0;
int njmin=0;
int njmax=knj;
for(int i=njmin; i<njmax; i++){
grsp[i] = new TGraphErrors(nbins);
gcor[i] = new TGraphErrors(nbins);
//grsp[i]->SetName(Form("L3RspVsRefPt_%d",i));
grsp[i]->SetName(Form("L3RspVsRefPt_%s",calgo[i]));
grsp[i]->SetTitle(Form("L3RspVsRefPt %s",calgo[i]));
grsp[i]->SetLineColor(1);
grsp[i]->SetMarkerColor(1);
grsp[i]->SetMarkerStyle(20);
grsp[i]->SetMarkerSize(1.2);
//gcor[i]->SetName(Form("L3CorVsJetPt_%d",i));
gcor[i]->SetName(Form("L3CorVsJetPt_%s",calgo[i]));
gcor[i]->SetTitle(Form("L3CorVsJetPt %s",calgo[i]));
gcor[i]->SetLineColor(1);
gcor[i]->SetMarkerColor(1);
gcor[i]->SetMarkerStyle(20);
gcor[i]->SetMarkerSize(1.2);
hMean [i] = new TH1F(Form("hMean_%d",i),Form("%s%s",calgo[i],ctype),nbins,ptbins);
hMean [i]->SetMarkerColor(1);
hMean [i]->SetMarkerStyle(20);
hMean [i]->SetLineColor(1);
hMean [i]->GetXaxis()->SetMoreLogLabels();
hMean [i]->GetXaxis()->SetNoExponent();
hRMS [i] = new TH1F(Form("hRMS_%d",i),Form("%s%s",calgo[i],ctype),nbins,ptbins);
hRMS [i]->SetMarkerColor(1);
hRMS [i]->SetMarkerStyle(20);
hRMS [i]->SetLineColor(1);
std::ostringstream strs;
//strs << "ak" << i+1 << "CaloJetAnalyzer/";
strs << calgo[i] << "CaloJetAnalyzer/";
cout << " Running for : " << strs.str().c_str() << endl;
for(int j=0; j<nbins; j++){
if(ptbins[j]<minx)continue;
//if(j<2)continue;
std::ostringstream spt;
spt << ptbins[j] << "to" << ptbins[j+1];
//cout << " ptbins : " << ptbins[j] << endl;
std::string sone (strs.str()+"RefPt_Barrel_RefPt"+spt.str());
std::string stwo (strs.str()+"JetPt_Barrel_RefPt"+spt.str());
std::string sthree(strs.str()+"RelRsp_Barrel_RefPt"+spt.str());
hrefpt = (TH1F*)fin->Get(sone.c_str());
hjetpt = (TH1F*)fin->Get(stwo.c_str());
hrsp[i][j] = (TH1F*)fin->Get(sthree.c_str());
//hrsp[i][j]->Rebin(2);
assert(hrefpt->GetEntries()>0 && hjetpt->GetEntries()>0);
// if( ptbins[j] < 30.0 ){
// SetHistRange(hrsp[i][j]);
// }
double refpt =hrefpt->GetMean();
double erefpt =hrefpt->GetMeanError();
double jetpt =hjetpt->GetMean();
double ejetpt =hjetpt->GetMeanError();
hrsp[i][j]->SetLineColor(1);
hrsp[i][j]->SetMarkerColor(1);
hrsp[i][j]->SetMarkerStyle(20);
if(j==0)l0->AddEntry(hrsp[i][j],Form("R = %0.1f",(i+1)*0.1),"p");
//if(i==0)cout <<" refpt : " << refpt << " rawpt : " << jetpt << endl;
//if(j<10)hrsp[i][j]->Rebin(2);
//hrsp[i][j]->Rebin(5);
double norm = hrsp[i][j]->GetMaximumStored();
double rms = hrsp[i][j]->GetRMS();
double peak = hrsp[i][j]->GetMean();
//double peak = (GetPeak(hrsp[i][j]) + hrsp[i][j]->GetMean())/2.;
double epeak = hrsp[i][j]->GetMeanError();
// double tmppeak = GetPeak(hrsp[i][j]);
// fgaus = new TF1("fgaus","gaus", 0.07, 1.2);
// fgaus->SetParameters(norm, peak, 0.15);
// //fgaus->SetParLimits(1, peak - 1.5*rms, peak + 1.5*rms);
// int fitstatus = hrsp[i][j]->Fit(fgaus,"QR");
// peak = (fgaus==0) ? hrsp[i][j]->GetMean() : fgaus->GetParameter(1);
// epeak = (fgaus==0) ? hrsp[i][j]->GetMeanError() : fgaus->GetParError(1);
// if(i==0)fit_dscb(hrsp[i][j], 1.03, minx, 5, Form("%s%s",calgo[i],ctype), 0.17, 1.70);
// else if(i==5)fit_dscb(hrsp[i][j], 1.00, minx, 5, Form("%s%s",calgo[i],ctype), 0.05, 1.45);
// else fit_dscb(hrsp[i][j], 1.03, minx, 5, Form("%s%s",calgo[i],ctype), 0.10, 1.50);
if(i==0)fit_dscb(hrsp[i][j], 1.03, minx, 5, Form("%s%s",calgo[i],ctype), 0.17, 1.70);
else if(i !=5 )fit_dscb(hrsp[i][j], 1.03, minx, 5, Form("%s%s",calgo[i],ctype), 0.10, 1.50);
//! pp reco
// if( i==0 )fit_dscb(hrsp[i][j], 0.85, minx, 5, Form("%s%s",calgo[i],ctype));
// else if(i==1)fit_dscb(hrsp[i][j], 1.03, minx, 5, Form("%s%s",calgo[i],ctype));
// else if(i==2)fit_dscb(hrsp[i][j], 1.00, minx, 5, Form("%s%s",calgo[i],ctype));
// else if(i==3)fit_dscb(hrsp[i][j], 1.05, minx, 5, Form("%s%s",calgo[i],ctype));
// else if(i==4)fit_dscb(hrsp[i][j], 1.05, minx, 5, Form("%s%s",calgo[i],ctype));
// else fit_dscb(hrsp[i][j], 1.00, minx, 5, Form("%s%s",calgo[i],ctype));
//! HI reco
// if( i==0 )fit_dscb(hrsp[i][j], 0.75, minx, 5, Form("ak%d%s",i+1,ctype));
// else if(i==1)fit_dscb(hrsp[i][j], 0.95, minx, 5, Form("ak%d%s",i+1,ctype));
// else if(i==2)fit_dscb(hrsp[i][j], 1.45, minx, 5, Form("ak%d%s",i+1,ctype));
// else if(i==3 || i==4)fit_dscb(hrsp[i][j], 1.50, minx, 4, Form("ak%d%s",i+1,ctype));
// else fit_dscb(hrsp[i][j], 1.30, minx, 5, Form("ak%d%s",i+1,ctype));
TF1* frelrsp = (TF1*)hrsp[i][j]->GetListOfFunctions()->Last();
peak = (frelrsp==0) ? hrsp[i][j]->GetMean() : frelrsp->GetParameter(1);
epeak = (frelrsp==0) ? hrsp[i][j]->GetMeanError() : frelrsp->GetParError(1);
//cout << " peak : " << peak << " mean : " << hrsp[i][j]->GetMean() << " " << frelrsp->GetParameter(1) << endl;
double cor = 1.0/peak;
double ecor = cor*cor*epeak;
//if(i==0)cout <<ptbins[j] << " ratio of " << refpt/jetpt << " " << cor << " " << ftemp->Eval(jetpt) << " " << 1/ ftemp->Eval(jetpt) << endl;
grsp[i]->SetPoint (j, refpt, peak);
grsp[i]->SetPointError(j, erefpt, epeak);
gcor[i]->SetPoint (j, jetpt, cor);
gcor[i]->SetPointError(j, ejetpt, ecor);
}
}
if( gPad )gPad->Close();
//hrsp[0][0]->Draw("p");
//return 0;
int ipad=0;
//! 0 - 20 GeV
TCanvas *c98[knj];
for(int nj=njmin;nj<njmax;nj++){
c98[nj] = new TCanvas(Form("c99_%d",nj),Form("Fine %s Fitting plots",calgo[nj]),100,102,1399,942);
c98[nj]->Divide(6,3,0,0);
//c98[nj]->Divide(10,5,0,0);
//c98[nj]->Divide(6,5,0,0);
//c98[nj]->Divide(7,4,0,0);
//c98[nj]->Divide(6,4,0,0);
ipad=0;
for(int ip=0;ip<nbins;ip++){
if(ptbins[ip]<minx)continue;
c98[nj]->cd(++ipad);
gPad->SetLeftMargin(0.15);
gPad->SetRightMargin(0.01);
gPad->SetBottomMargin(0.15);
gPad->SetLogy();
//if(ipad%10==0)gPad->SetRightMargin(0.02);
//if(ipad%(ip+1)==0)gPad->SetLeftMargin(0.15);
//hrsp[nj][ip]->SetMaximum(hrsp[nj][ip]->GetMaximum() + 0.25*hrsp[nj][ip]->GetMaximum());
hrsp[nj][ip]->SetMaximum(hrsp[nj][ip]->Integral()*2e-00);
hrsp[nj][ip]->SetMinimum(hrsp[nj][ip]->Integral()*1e-07);
hrsp[nj][ip]->SetTitle(0);
hrsp[nj][ip]->GetXaxis()->SetTitle("<reco jet p_{T} / gen jet p_{T}>");
hrsp[nj][ip]->GetXaxis()->SetTitleFont(42);
hrsp[nj][ip]->GetXaxis()->SetLabelFont(42);
hrsp[nj][ip]->GetXaxis()->SetLabelSize(0.08);
hrsp[nj][ip]->GetXaxis()->SetTitleSize(0.07);
hrsp[nj][ip]->GetXaxis()->SetNdivisions(507);
hrsp[nj][ip]->GetYaxis()->SetTitle("");
hrsp[nj][ip]->GetYaxis()->SetTitleFont(42);
hrsp[nj][ip]->GetYaxis()->SetLabelFont(42);
hrsp[nj][ip]->GetYaxis()->SetLabelSize(0.08);
hrsp[nj][ip]->GetYaxis()->SetNdivisions(507);
hrsp[nj][ip]->SetMarkerStyle(20);
hrsp[nj][ip]->SetMarkerColor(1);
hrsp[nj][ip]->SetLineColor(1);
hrsp[nj][ip]->SetMarkerSize(1.1);
hrsp[nj][ip]->Draw("hist");
TF1 *fdscb = (TF1*)hrsp[nj][ip]->GetFunction("fdscb");
if(fdscb){
fdscb->SetLineWidth(1);
fdscb->SetLineColor(2);
fdscb->SetLineColor(2);
fdscb->Draw("lsame");
}
TF1 *fgaus = (TF1*)hrsp[nj][ip]->GetFunction("fgaus");
if(fgaus){
fgaus->SetLineWidth(1);
fgaus->SetLineColor(4);
fgaus->Draw("lsame");
}
// TF1 *fdg = (TF1*)hrsp[nj][ip]->GetFunction("fdgaus");
// if(fdg){
// TF1 *fg1 = (TF1*)hrsp[nj][ip]->GetFunction("fg1");
// TF1 *fg2 = (TF1*)hrsp[nj][ip]->GetFunction("fg2");
// fdg->Draw("lsame");
// fg1->Draw("lsame");
// fg2->Draw("lsame");
// }
std::ostringstream strs;
strs << ptbins[ip] << "< p_{T} (GeV/c) <" << ptbins[ip+1];
std::string spt = strs.str();
if(ipad==1){drawText2(Form("%s%s",calgo[nj],ctype),0.28,0.90,18);
drawText2(spt.c_str(),0.22,0.80,15);
} else drawText2(spt.c_str(),0.17,0.80,15);
}
//if(nj!=0)c98[nj]->Close();
//if( strcmp(calgo[nj],"ak4")!=0 )c98[nj]->Close();
}
//return 0;
cout << endl;
cout << endl;
cout << "Fitting the L3 Response " << endl;
//cout << endl;
//cout << endl;
TF1 *fitrsp=0, *fitcor=0;
std::string fcn_rsp="";
std::string fcn_cor="";
//! Org
// fcn_rsp="[0]-[1]/(pow(log10(x),[2])+[3])";
// fcn_cor="[0]+[1]/(pow(log10(x),[2])+[3])";
//! Using this one
//fcn_rsp="[0]-[1]/(pow(log10(x),[2])+[3])+[4]/x";
//fcn_cor="[0]+[1]/(pow(log10(x),[2])+[3])-[4]/x";
fcn_rsp="[0]-[1]/(pow(log10(x),[2])+[3])+[4]/x+[5]/x/x";
fcn_cor="[0]+[1]/(pow(log10(x),[2])+[3])-[4]/x-[5]/x/x";
// double *rawpt = 0;
// double *genpt = 0;
TCanvas *c11 = new TCanvas("c11","L3 Response",1217,707/*1531,683*/);
c11->Divide(3,2);
TCanvas *c12 = new TCanvas("c12","L3 Corrections",1217,707/*1531,683*/);
c12->Divide(3,2);
for(int i=njmin; i<njmax; i++){
c11->cd(i+1);
fitrsp = new TF1("fitrsp",fcn_rsp.c_str(), minx, grsp[i]->GetX()[grsp[i]->GetN()-1]);
fitrsp->SetParameter(0,1.0);
fitrsp->SetParameter(1,1.0);
fitrsp->SetParameter(2,1.0);
fitrsp->SetParameter(3,1.0);
fitrsp->SetParameter(4,1.0);
fitrsp->SetParameter(5,1.0);
grsp[i]->Fit(fitrsp,"QR");
//if( i<knj )grsp[i]->Fit(fitrsp,"QR","",grsp[i]->GetX()[1],grsp[i]->GetX()[grsp[i]->GetN()-1]);
//else grsp[i]->Fit(fitrsp,"QR");
grsp[i]->SetMaximum(1.2);
grsp[i]->SetMinimum(0.2);
grsp[i]->Draw("ap");
gPad->SetLogx();
gPad->SetLeftMargin(0.15);
gPad->SetBottomMargin(0.15);
gPad->Update();
grsp[i]->GetXaxis()->SetTitle("< Ref p_{T} > (GeV/c)");
grsp[i]->GetXaxis()->SetTitleFont(42);
grsp[i]->GetXaxis()->SetLabelFont(42);
grsp[i]->GetXaxis()->SetLabelSize(0.06);
grsp[i]->GetXaxis()->SetTitleSize(0.06);
grsp[i]->GetXaxis()->SetNdivisions(507);
grsp[i]->GetXaxis()->SetNoExponent();
grsp[i]->GetXaxis()->SetMoreLogLabels();
grsp[i]->GetYaxis()->SetTitle("L3 Response");
grsp[i]->GetYaxis()->SetTitleFont(42);
grsp[i]->GetYaxis()->SetLabelFont(42);
grsp[i]->GetYaxis()->SetLabelSize(0.06);
grsp[i]->GetYaxis()->SetTitleSize(0.06);
grsp[i]->GetYaxis()->SetNdivisions(507);
grsp[i]->GetYaxis()->SetRangeUser(0,1.160);
//grsp[i]->GetXaxis()->SetRangeUser(15,600);
drawText2(Form("%s%s",calgo[i],ctype),0.20,0.78,21);
TPaveStats *strsp = (TPaveStats*)grsp[i]->FindObject("stats");
strsp->SetX1NDC(0.46);
strsp->SetY1NDC(0.18);
strsp->SetX2NDC(0.87);
strsp->SetY2NDC(0.59);
strsp->Draw();
//delete fitrsp;
//continue;
c12->cd(i+1);
//cout << endl;
//cout << endl;
// cout << "Fitting the L3 Corrections " << endl;
// cout << endl;
fitcor = new TF1("fitcor",fcn_cor.c_str(), minx, gcor[i]->GetX()[gcor[i]->GetN()-1]);
fitcor->SetParameter(0,1.0);
fitcor->SetParameter(1,1.0);
fitcor->SetParameter(2,1.0);
fitcor->SetParameter(3,1.0);
fitcor->SetParameter(4,1.0);
fitcor->SetParameter(5,1.0);
gcor[i]->Fit(fitcor,"QR");
//if(i<knj)gcor[i]->Fit(fitcor,"QR","",gcor[i]->GetX()[1],gcor[i]->GetX()[gcor[i]->GetN()-1]);
//else gcor[i]->Fit(fitcor,"QR");
string algn=Form("%d",i+1);
string era="JEC_pp_PYTHIA_TuneCUETP8M1_5020GeV_patch3";
//string era="JEC_pp_HIReco_PYTHIA_TuneCUETP8M1_5020GeV_patch3";
string txtfilename = outdir+era+"_L3Absolute_AK"+algn+"Calo.txt";
ofstream outf(txtfilename.c_str());
//outf.setf(ios::left);
//cout<<"{1 JetEta 1 JetPt "<<fcn_cor<<" Correction L3Absolute}"<<endl;
outf<<"{1 JetEta 1 JetPt "<<fcn_cor<<" Correction L3Absolute}"<<endl;
// cout<<setw(12)<<-3.000 // eta_min
// <<setw(12)<<+3.000 // eta_max
// <<setw(12)<<fitcor->GetNpar()+2 // number of parameters + 2
// <<setw(12)<<7.0 // minimum pT
// <<setw(11)<<1000.0; // maximum pT
outf<<setw(12)<<-3.000 // eta_min
<<setw(12)<<+3.000 // eta_max
<<setw(12)<<fitcor->GetNpar()+2 // number of parameters + 2
<<setw(12)<<7.0 // minimum pT
<<setw(12)<<1000.0; // maximum pT
for(int p=0; p<fitcor->GetNpar(); p++){
//cout<<setw(12)<<fitcor->GetParameter(p); // p0-p4
outf<<setw(12)<<fitcor->GetParameter(p); // p0-p4
}
outf.close();
//cout<<endl;
// if(i==0)cout <<Form("if(i==%d)fl3cor->SetParameters(",i);
// else cout <<Form("else if(i==%d)fl3cor->SetParameters(",i);
// for(int p=0; p<fitcor->GetNpar(); p++){
// if(p==fitcor->GetNpar()-1)cout<<setw(12)<<fitcor->GetParameter(p); // p0-p4
// else cout<<setw(12)<<fitcor->GetParameter(p)<<","; // p0-p4
// }
// cout <<");"<<endl;
// rawpt = gcor[i]->GetX();
// genpt = grsp[i]->GetX();
// for(int ix=0; ix<gcor[i]->GetN(); ix++){
// double cor_fac = fitcor->Eval(rawpt[ix]);
// double corrpt = cor_fac*rawpt[ix];
// //std::cout << " genpt : " << genpt[ix] << " rawpt : " << rawpt[ix] << " corrpt : " << corrpt << " cor_fac : " << cor_fac << std::endl;
// std::cout << genpt[ix] << " : " << (fabs(corrpt - genpt[ix])/genpt[ix])*100. << std::endl;
// }
// gcor[i]->GetXaxis()->SetRangeUser(15,600);
gcor[i]->SetMaximum(3.35);
gcor[i]->SetMinimum(0.89);
gcor[i]->Draw("ap");
gPad->SetLogx();
gPad->SetLeftMargin(0.15);
gPad->SetBottomMargin(0.15);
gPad->Update();
gcor[i]->GetXaxis()->SetTitle("< raw jet p_{T} > (GeV/c)");
gcor[i]->GetXaxis()->SetTitleFont(42);
gcor[i]->GetXaxis()->SetLabelFont(42);
gcor[i]->GetXaxis()->SetLabelSize(0.06);
gcor[i]->GetXaxis()->SetTitleSize(0.06);
gcor[i]->GetXaxis()->SetNdivisions(507);
gcor[i]->GetXaxis()->SetNoExponent();
gcor[i]->GetXaxis()->SetMoreLogLabels();
gcor[i]->GetYaxis()->SetTitle("L3 Correction");
gcor[i]->GetYaxis()->SetTitleFont(42);
gcor[i]->GetYaxis()->SetLabelFont(42);
gcor[i]->GetYaxis()->SetLabelSize(0.06);
gcor[i]->GetYaxis()->SetTitleSize(0.06);
gcor[i]->GetYaxis()->SetNdivisions(507);
gcor[i]->GetXaxis()->SetMoreLogLabels();
gcor[i]->GetXaxis()->SetNoExponent();
drawText2(Form("%s%s",calgo[i],ctype),0.20,0.78,21);
TPaveStats *stcor = (TPaveStats*)gcor[i]->FindObject("stats");
stcor->SetX1NDC(0.48);
stcor->SetY1NDC(0.53);
stcor->SetX2NDC(0.89);
stcor->SetY2NDC(0.89);
stcor->Draw();
// cout << endl;
//delete fitcor;
}
if(iSave){
c12->SaveAs("CorrectionPlots/L3Absolute_Corrections_ppReco_CaloJets_757p1.pdf");
}
TFile *fout = new TFile("l3calo_input.root","RECREATE");
for(int nj=njmin;nj<njmax;nj++){
fout->mkdir(Form("%sCaloJetAnalyzer",calgo[nj]),Form("%sCaloJetAnalyzer",calgo[nj]));
fout->cd(Form("%sCaloJetAnalyzer",calgo[nj]));
grsp[nj]->Write();
gcor[nj]->Write();
fout->cd("../");
}
fout->Close();
return 0;
}
TF1* fitMass(TH1D* hData, TH1D* hMCSignal, TH1D* hMCSwapped)
{
Double_t setparam0=100.;
Double_t setparam1=1.865;
Double_t setparam2=0.03;
Double_t setparam10=0.005;
Double_t setparam8=0.1;
Double_t setparam9=0.1;
Double_t fixparam1=1.865;
Double_t minhisto=1.7;
Double_t maxhisto=2.0;
TF1* f = new TF1("fMass","[0]*([7]*([9]*Gaus(x,[1],[2]*(1+[11]))/(sqrt(2*3.1415927)*[2]*(1+[11]))+(1-[9])*Gaus(x,[1],[10]*(1+[11]))/(sqrt(2*3.1415927)*[10]*(1+[11])))+(1-[7])*Gaus(x,[1],[8]*(1+[11]))/(sqrt(2*3.1415927)*[8]*(1+[11])))+[3]+[4]*x+[5]*x*x+[6]*x*x*x", 1.7, 2.0);
f->SetParLimits(4,-1000,1000);
f->SetParLimits(10,0.005,0.05);
f->SetParLimits(2,0.01,0.1);
f->SetParLimits(8,0.02,0.2);
f->SetParLimits(7,0,1);
f->SetParLimits(9,0,1);
f->SetParameter(0,setparam0);
f->SetParameter(1,setparam1);
f->SetParameter(2,setparam2);
f->SetParameter(10,setparam10);
f->SetParameter(9,setparam9);
f->FixParameter(8,setparam8);
f->FixParameter(7,1);
f->FixParameter(1,fixparam1);
f->FixParameter(3,0);
f->FixParameter(4,0);
f->FixParameter(5,0);
f->FixParameter(6,0);
f->FixParameter(11,0);
hMCSignal->Fit("fMass","q","",minhisto,maxhisto);
hMCSignal->Fit("fMass","q","",minhisto,maxhisto);
f->ReleaseParameter(1);
hMCSignal->Fit("fMass","L q","",minhisto,maxhisto);
hMCSignal->Fit("fMass","L q","",minhisto,maxhisto);
hMCSignal->Fit("fMass","L m","",minhisto,maxhisto);
f->FixParameter(1,f->GetParameter(1));
f->FixParameter(2,f->GetParameter(2));
f->FixParameter(10,f->GetParameter(10));
f->FixParameter(9,f->GetParameter(9));
f->FixParameter(7,0);
f->ReleaseParameter(8);
f->SetParameter(8,setparam8);
hMCSwapped->Fit("fMass","L q","",minhisto,maxhisto);
hMCSwapped->Fit("fMass","L q","",minhisto,maxhisto);
hMCSwapped->Fit("fMass","L q","",minhisto,maxhisto);
hMCSwapped->Fit("fMass","L m","",minhisto,maxhisto);
f->FixParameter(7,hMCSignal->Integral(0,1000)/(hMCSwapped->Integral(0,1000)+hMCSignal->Integral(0,1000)));
f->FixParameter(8,f->GetParameter(8));
f->ReleaseParameter(3);
f->ReleaseParameter(4);
f->ReleaseParameter(5);
f->ReleaseParameter(6);
f->SetLineColor(kRed);
hData->Fit("fMass","q","",minhisto,maxhisto);
hData->Fit("fMass","q","",minhisto,maxhisto);
f->ReleaseParameter(1);
f->SetParLimits(1,1.86,1.87);
f->ReleaseParameter(11);
f->SetParLimits(11,-0.2,0.2);
hData->Fit("fMass","L q","",minhisto,maxhisto);
hData->Fit("fMass","L q","",minhisto,maxhisto);
hData->Fit("fMass","L q","",minhisto,maxhisto);
hData->Fit("fMass","L m","",minhisto,maxhisto);
TF1* background = new TF1("fBackground","[0]+[1]*x+[2]*x*x+[3]*x*x*x");
background->SetParameter(0,f->GetParameter(3));
background->SetParameter(1,f->GetParameter(4));
background->SetParameter(2,f->GetParameter(5));
background->SetParameter(3,f->GetParameter(6));
background->SetLineColor(4);
background->SetRange(minhisto,maxhisto);
background->SetLineStyle(2);
TF1* mass = new TF1("fSignal","[0]*([3]*([4]*Gaus(x,[1],[2]*(1+[6]))/(sqrt(2*3.1415927)*[2]*(1+[6]))+(1-[4])*Gaus(x,[1],[5]*(1+[6]))/(sqrt(2*3.1415927)*[5]*(1+[6]))))");
mass->SetParameters(f->GetParameter(0),f->GetParameter(1),f->GetParameter(2),f->GetParameter(7),f->GetParameter(9),f->GetParameter(10),f->GetParameter(11));
mass->SetParError(0,f->GetParError(0));
mass->SetParError(1,f->GetParError(1));
mass->SetParError(2,f->GetParError(2));
mass->SetParError(3,f->GetParError(7));
mass->SetParError(4,f->GetParError(9));
mass->SetParError(5,f->GetParError(10));
mass->SetFillColor(kOrange-3);
mass->SetFillStyle(3002);
mass->SetLineColor(kOrange-3);
mass->SetLineWidth(3);
mass->SetLineStyle(2);
TF1* massSwap = new TF1("fBackground","[0]*(1-[2])*Gaus(x,[1],[3]*(1+[4]))/(sqrt(2*3.1415927)*[3]*(1+[4]))");
massSwap->SetParameters(f->GetParameter(0),f->GetParameter(1),f->GetParameter(7),f->GetParameter(8),f->GetParameter(11));
massSwap->SetParError(0,f->GetParError(0));
massSwap->SetParError(1,f->GetParError(1));
massSwap->SetParError(2,f->GetParError(7));
massSwap->SetParError(3,f->GetParError(8));
massSwap->SetFillColor(kGreen+4);
massSwap->SetFillStyle(3005);
massSwap->SetLineColor(kGreen+4);
massSwap->SetLineWidth(3);
massSwap->SetLineStyle(1);
hData->SetXTitle("m_{#piK} (GeV/c^{2})");
hData->SetYTitle("Entries / (5 MeV/c^{2})");
hData->SetAxisRange(0,hData->GetBinContent(hData->GetMaximumBin())*1.4*1.2,"Y");
hData->SetMarkerSize(0.3);
hData->Draw("e");
cout<<"hData->GetMaximum(): "<<hData->GetMaximum()<<endl;
background->Draw("same");
mass->SetRange(minhisto,maxhisto);
mass->Draw("same");
massSwap->SetRange(minhisto,maxhisto);
massSwap->Draw("same");
f->Draw("same");
Double_t yield = mass->Integral(minhisto,maxhisto)/hData->GetBinWidth(1);
Double_t yieldErr = mass->Integral(minhisto,maxhisto)/hData->GetBinWidth(1)*mass->GetParError(0)/mass->GetParameter(0);
std::cout<<"integral function yield: "<<yield<<" fit yield: "<<f->GetParameter(0)*f->GetParameter(7)/hData->GetBinWidth(1)<<" +- "<<f->GetParError(0)*f->GetParameter(7)/hData->GetBinWidth(1)<<std::endl;
TLegend* leg = new TLegend(0.65,0.5,0.82,0.88,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.06);
leg->SetTextFont(42);
leg->SetFillStyle(0);
leg->AddEntry(hData,"Data","pl");
leg->AddEntry(f,"Fit","l");
leg->AddEntry(mass,"D^{0}+#bar{D^{#lower[0.2]{0}}} Signal","f");
leg->AddEntry(massSwap,"K-#pi swapped","f");
leg->AddEntry(background,"Combinatorial","l");
leg->Draw("same");
hData->GetFunction("fMass")->Delete();
TH1D* hDataNoFitFun = (TH1D*) hData->Clone("hDataNoFitFun");
hDataNoFitFun->Draw("esame");
return f;
}
void printhistos(){
/// print muon resolution data, MC and MC sim
gStyle->SetOptFit(1111);
TString gifname[NPThist];
//TString gifname_inv[NPThist];
TString gifmethod = "DoubleGauss";
//TString gifmethodinv = "DoubleGauss";
//TString gifmethod = "BWnonrel";
//TString gifmethodinv = "Voigtian";
gStyle->SetPalette(1,0); // blue to red false color palette. Use 9 for b/w
gStyle->SetOptTitle(1);
TF1* fitDoubleGauss = new TF1("fitDoubleGauss", DoubleGauss, -0.1, 0.1, 5);
TF1* fitDoubleGauss2 = new TF1("fitDoubleGauss2", DoubleGauss, -0.1, 0.1, 5);
for(int iPT = 0; iPT < NPThist; iPT++){
gifname[iPT] = Form("plots/ResolutionPTScaleFactor%1.2f_"+gifmethod+"_%d", ScaleFactor, iPT);
gifname[iPT] = gifname[iPT]+Extra;
TCanvas *c20 = new TCanvas("c20","Resolution",3000,1700);
TCanvas *c21 = new TCanvas("c21","Resolution mass",3000,1700);
c20-> Divide(4,2);
c21-> Divide(4,2);
int Neta = NETAhist;
if(Neta > 8) {Neta = 8; cout << "more then 8 bins, change canvas size" << endl;}
for(int iETA = 0; iETA < Neta; iETA++){
int iK = iPT + iETA*NPThist;
c20 -> cd(iETA+1);
if(ETAbin[iETA] < 0.) c20 -> cd(int(Neta/2) - iETA);
//
fitDoubleGauss->SetParameters(0., 0.85*hmuonRes[iK] -> GetRMS(), 0.07,0.85*hmuonRes[iK] -> GetRMS()+0.015, 1000.);
//if(ETAbin[iETA] > 0.75 || ETAbin[iETA] < -0.85) fitDoubleGauss->SetParameters(0., hmuonRes[iK] -> GetRMS(), 0.035, 0.03, 1000.);
//if(PTbin[iPT] > 90.) fitDoubleGauss->SetParameters(0., 0.024, 0.08, 0.054, 160.);
//if( (PTbin[iPT] > 65. && ( ETAbin[iETA] > 0.75 || ETAbin[iETA] < -0.85) )
if( (PTbin[iPT] > 65. && ( ETAbin[iETA] > 1.15 || ETAbin[iETA] < -1.25) )
|| (PTbin[iPT] > 145.) ){
fitDoubleGauss->SetParameters(0., hmuonRes[iK] -> GetRMS(), 0.0, 0.03, 100.);
fitDoubleGauss->FixParameter(2,0.);//fix Asig2 to 0
fitDoubleGauss->FixParameter(3,3.); // fix sig2 to any big value (sig1 < sig2)
fitDoubleGauss->SetParLimits(1, 0.005, 0.1);//restrict sigma1
}
else{
fitDoubleGauss->SetParLimits(2, 0.01, 0.4);//restrict Asig2
fitDoubleGauss->SetParLimits(3,0.005, 0.1); //restrict sig2
fitDoubleGauss->SetParLimits(1, 0.005, hmuonRes[iK] -> GetRMS());//restrict sigma1
}
//fitDoubleGauss->FixParameter(0,0.); // fix mean of resolution
fitDoubleGauss->SetParName(0,"mean");
fitDoubleGauss->SetParName(1,"sig1");
fitDoubleGauss->SetParName(2,"Asig2");
fitDoubleGauss->SetParName(3,"sig2");
fitDoubleGauss->SetParName(4,"Norm");
hmuonRes[iK] -> Fit(fitDoubleGauss,"RLE");
fitDoubleGauss2->SetParameters(fitDoubleGauss->GetParameter(0),fitDoubleGauss->GetParameter(1),fitDoubleGauss->GetParameter(2),fitDoubleGauss->GetParameter(3),fitDoubleGauss->GetParameter(4));
//if( (PTbin[iPT] > 65. && ( ETAbin[iETA] > 0.75 || ETAbin[iETA] < -0.85) )
if( (PTbin[iPT] > 65. && ( ETAbin[iETA] > 1.15 || ETAbin[iETA] < -1.25) )
|| (PTbin[iPT] > 145.) ){
fitDoubleGauss2->FixParameter(2,0.);//fix Asig2 to 0
fitDoubleGauss2->FixParameter(3,3.); // fix sig2 to any big value (sig1 < sig2)
fitDoubleGauss2->SetParLimits(1, 0.005, 0.1);//restrict sigma1
}
else{
fitDoubleGauss2->SetParLimits(2, 0.01, 0.4);//restrict Asig2
fitDoubleGauss2->SetParLimits(3,0.005, 0.1); //restrict sig2
fitDoubleGauss2->SetParLimits(1, 0.005, hmuonRes[iK] -> GetRMS());//restrict sigma1
}
//fitDoubleGauss2->FixParameter(0,0.); // fix mean of resolution
fitDoubleGauss2->SetParName(0,"mean");
fitDoubleGauss2->SetParName(1,"sig1");
fitDoubleGauss2->SetParName(2,"Asig2");
fitDoubleGauss2->SetParName(3,"sig2");
fitDoubleGauss2->SetParName(4,"Norm");
hmuonRes[iK] -> Fit(fitDoubleGauss2,"RLE");
TLegend* histinfo = SetLegend(.6,.57,1.,.73);
histinfo->AddEntry(hmuonRes[iK], "MC reco + Fit","lep");
histinfo->AddEntry(fitDoubleGauss2, Form("Fit, RMS = %4.3f#pm%4.3f", ResRMS[iK], ErrResRMS[iK]),"l");
hmuonRes[iK] -> GetXaxis() ->SetNdivisions(505);// n = n1 + 100*n2 + 10000*n3
hmuonRes[iK] -> GetXaxis()->SetTitle("p_{T}^{reco}(#mu)/p_{T}^{gen}(#mu)-1");
hmuonRes[iK] -> GetYaxis()->SetTitle("Entries");
hmuonRes[iK] -> Draw("e");
histinfo -> Draw("same");
//c21 -> cd(iETA+1);
//hDimuonRes[iK] -> Draw("e");
}
c20 ->Print(gifname[iPT]+".png");
c20 ->Print(gifname[iPT]+".root");
//c21 ->Print(gifname_inv[iPT]);
}
/// end: print muon resolution data, MC and MC sim
}
int main(int argc, char** argv){
// because root is a piece of shit
gSystem->Load("libTree");
if (argc != 2){
printf("Usage: ./pulse_shape <gain_meas root file>\n\te.g. ./pulse_shape test.root\n");
return -1;
}
char* file_name = argv[1];
// float t_min = -70e-9, t_max = 130e-9, u_min = -1., u_max = 2.;
int sample_len;
float baseline;
// open root file and extract tree
printf("[Pulse Shape] - Opening file '%s'..\n", file_name);
TFile* in_file = TFile::Open(file_name, "READ");
TTree* in_tree = (TTree*)in_file->Get("outtree");
in_tree->SetBranchAddress("len", &sample_len);
in_tree->SetBranchAddress("baseline", &baseline);
in_tree->GetEntry(0);
double* u = new double[sample_len];
double* t = new double[sample_len];
in_tree->SetBranchAddress("amplitude", u);
in_tree->SetBranchAddress("time", t);
const int nEvents = in_tree->GetEntries();
printf("[Pulse Shape] - Found tree with %i events, %i samples per event.\n", nEvents, sample_len);
TFile* out_file = new TFile("out.root", "RECREATE");
TTree* out_tree = new TTree("out_tree", "outtree");
double riseTime, fallTime, pulseDuration;
out_tree->Branch("risetime", &riseTime);
out_tree->Branch("falltime", &fallTime);
out_tree->Branch("pulseduration", &pulseDuration);
TCanvas* c1 = new TCanvas();
TGraph* pulse = new TGraph();
pulse->SetTitle("Output pulse;t [s];U [V]");
pulse->SetMarkerStyle(7);
TGraph* rf = new TGraph(); // drawing rise and fall time points
rf->SetMarkerStyle(8);
rf->SetMarkerColor(46);
TF1* bl = new TF1("baseline", "[0]", -100, 100); // baseline
bl->SetLineColor(38);
// loop over data
float uMax, lPos, hPos, lTime, hTime, rTime, buf;
int maxEntry;
for (int iEvent = 0; iEvent < nEvents; iEvent++){
uMax = -1.;
in_tree->GetEntry(iEvent);
for (int i = 0; i < sample_len; i++){
u[i] *= -1;
pulse->SetPoint(i, t[i], u[i]);
// find Maximum by Hand because root apparently isnt able to do so
if (u[i] > uMax){
uMax = u[i];
maxEntry = i;
}
}
// get 10% and 90% amplitude
lPos = 0.1*(uMax - baseline) + baseline;
hPos = 0.9*(uMax - baseline) + baseline;
// get rise time -> start at maximum and go left
lTime = -1;
hTime = -1;
for (int i = maxEntry; (buf = pulse->GetY()[i]) > 0.9*lPos; i--){
if ( buf > hPos )
hTime = pulse->GetX()[i];
if ( buf > lPos ){
lTime = pulse->GetX()[i];
}
}
riseTime = hTime - lTime;
rf->SetPoint(0, lTime, lPos);
rf->SetPoint(1, hTime, hPos);
// get fall time -> start at maximum and go right
rTime = -1;
hTime = -1;
for (int i = maxEntry; (buf = pulse->GetY()[i]) > 0.9*lPos; i++){
if ( buf > hPos )
hTime = pulse->GetX()[i];
if ( buf > lPos ){
rTime = pulse->GetX()[i];
}
}
fallTime = rTime - hTime;
pulseDuration = rTime - lTime;
rf->SetPoint(2, rTime, lPos);
rf->SetPoint(3, hTime, hPos);
out_tree->Fill();
// draw & save every 500th event
if (iEvent%100 == 0) {
printf("[Pulse Shape] - Risetime = %e s\n", riseTime);
printf("[Pulse Shape] - Falltime = %e s\n", pulseDuration);
printf("[Pulse Shape] - Pulse duration = %e s\n", fallTime);
bl->SetParameter(0, baseline);
pulse->Draw("A*");
bl->Draw("SAME");
rf->Draw("SAME*");
c1->Write();
}
}
// cleanup
out_tree->Write();
out_file->Close();
in_file->Close();
return 0;
}
int macro_004_8 ()
{
TFile input ("../testBkg_004.root") ;
//PG get the histograms
//PG ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
THStack * stack_m4_upper = (THStack *) input.Get ("stack_m4_upper") ;
TH1F * m4_upper_total = (TH1F*) stack_m4_upper->GetStack ()->Last () ;
TH1F * m4_upper_Wjet = (TH1F *) input.Get ("m4_upper_Wjet") ;
THStack * stack_m4_lower = (THStack *) input.Get ("stack_m4_lower") ;
TH1F * m4_lower_total = (TH1F *) stack_m4_lower->GetStack ()->Last () ;
TH1F * m4_lower_Wjet = (TH1F *) input.Get ("m4_lower_Wjet") ;
THStack * stack_m4_signal = (THStack *) input.Get ("stack_m4_signal") ;
TH1F * m4_signal_total = (TH1F *) stack_m4_signal->GetStack ()->Last () ;
TH1F * m4_signal_Wjet = (TH1F *) input.Get ("m4_signal_Wjet") ;
THStack * stack_m4_sideband = (THStack *) input.Get ("stack_m4_sideband") ;
TH1F * m4_sideband_total = (TH1F *) stack_m4_sideband->GetStack ()->Last () ;
TH1F * m4_sideband_Wjet = (TH1F *) input.Get ("m4_sideband_Wjet") ;
TH1F * m4_upper_DATA = (TH1F *) input.Get ("m4_upper_DATA") ;
TH1F * m4_signal_DATA = (TH1F *) input.Get ("m4_signal_DATA") ;
TH1F * m4_lower_DATA = (TH1F *) input.Get ("m4_lower_DATA") ;
TH1F * m4_sideband_DATA = (TH1F *) input.Get ("m4_sideband_DATA") ;
//PG fit separately numerator and denominator
//PG ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
TF1 * numFitFunc = new TF1 ("numFitFunc", attenuatedCB, 0., 1000., 7) ;
numFitFunc->SetLineWidth (1) ;
numFitFunc->SetLineColor (kBlue+2) ;
numFitFunc->SetNpx (10000) ;
numFitFunc->SetParameter (0, m4_signal_total->Integral ()) ; //PG N
numFitFunc->SetParameter (1, 200.) ; //PG gaussian mean
numFitFunc->SetParameter (2, 20.) ; //PG gaussian sigma
numFitFunc->SetParameter (3, 0.1) ; //PG joint point
numFitFunc->SetParameter (4, 10) ; //PG power law exponent
numFitFunc->SetParameter (5, 200) ; //PG fermi E
numFitFunc->SetParameter (6, 10) ; //PG kT
m4_signal_total->Fit (numFitFunc, "L", "", 100., 800.) ;
TH1F * num_fit_error = new TH1F ("num_fit_error", "", 70, 100., 800.) ;
(TVirtualFitter::GetFitter ())->GetConfidenceIntervals (num_fit_error, 0.68) ;
TF1 * denFitFunc = new TF1 ("denFitFunc", attenuatedCB, 0., 1000., 7) ;
denFitFunc->SetLineWidth (1) ;
denFitFunc->SetLineColor (kBlue+2) ;
denFitFunc->SetNpx (10000) ;
denFitFunc->SetParameter (0, m4_sideband_total->Integral ()) ;
denFitFunc->SetParameter (1, 200.) ;
denFitFunc->SetParameter (2, 20.) ;
denFitFunc->SetParameter (3, 0.1) ;
denFitFunc->SetParameter (4, 10) ;
denFitFunc->SetParameter (5, 200) ;
denFitFunc->SetParameter (6, 10) ;
m4_sideband_total->Fit (denFitFunc, "L", "", 100., 800.) ;
TH1F * den_fit_error = new TH1F ("den_fit_error", "", 70, 100., 800.) ;
(TVirtualFitter::GetFitter ())->GetConfidenceIntervals (den_fit_error, 0.68) ;
TCanvas c1 ;
den_fit_error->SetFillColor (kGray+2) ;
den_fit_error->Draw ("E3") ;
m4_sideband_total->Draw ("same") ;
c1.Print ("denominator_fit.pdf", "pdf") ;
//PG calculate the ratio of the functions
//PG ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
TH1F * func_ratio = (TH1F *) m4_signal_total->Clone ("func_ratio") ;
func_ratio->Reset () ;
for (int j = 1 ; j <= func_ratio->GetNbinsX () ; ++j)
{
double x = func_ratio->GetBinCenter (j) ;
func_ratio->SetBinContent (j, numFitFunc->Eval (x) / denFitFunc->Eval (x)) ;
double sqRelError = num_fit_error->GetBinError (j) * num_fit_error->GetBinError (j) /
(num_fit_error->GetBinContent (j) * num_fit_error->GetBinContent (j)) +
den_fit_error->GetBinError (j) * den_fit_error->GetBinError (j) /
(den_fit_error->GetBinContent (j) * den_fit_error->GetBinContent (j)) ;
double error = sqrt (sqRelError) * func_ratio->GetBinContent (j) ;
func_ratio->SetBinError (j, error) ;
}
//PG look at the ratio of the functions
//PG ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
stack_m4_signal->Draw ("hist") ;
c1.Print ("numerator.pdf", "pdf") ;
stack_m4_sideband->Draw ("hist") ;
c1.Print ("denominator.pdf", "pdf") ;
TH1F * ratio_total = (TH1F *) m4_signal_total->Clone ("ratio") ;
ratio_total->Divide (m4_sideband_total) ;
func_ratio->SetLineColor (kBlue) ;
func_ratio->SetFillStyle (0) ;
c1.DrawFrame (100., 0., 1000., 2.) ;
ratio_total->Draw ("same") ;
func_ratio->Draw ("histE2same") ;
c1.Print ("ratio.pdf", "pdf") ;
//PG extrapolate the background from side-band
//PG ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
// TH1F * extrapolated_bkg = m4_sideband_total->Clone ("extrapolated_bkg") ; //PG simil-closure test --> stats issue
TH1F * extrapolated_bkg = m4_sideband_DATA->Clone ("extrapolated_bkg") ; //PG analysis
extrapolated_bkg->Multiply (func_ratio) ;
TLegend leg_compare (0.2, 0.2, 0.6, 0.4, NULL, "brNDC") ;
leg_compare.SetBorderSize (0) ;
leg_compare.SetTextFont (42) ;
leg_compare.SetTextSize (0.04) ;
leg_compare.SetLineColor (1) ;
leg_compare.SetLineStyle (1) ;
leg_compare.SetLineWidth (1) ;
leg_compare.SetFillColor (0) ;
leg_compare.SetFillStyle (0) ;
leg_compare.AddEntry (m4_signal_total, "simulation in signal region", "lp") ;
leg_compare.AddEntry (extrapolated_bkg, "extrapolated bkg in SR", "lp") ;
c1.SetLogy () ;
c1.DrawFrame (100, 0.1, 800, 5000) ;
extrapolated_bkg->SetStats (0) ;
extrapolated_bkg->SetTitle ("") ;
extrapolated_bkg->SetLineColor (kRed) ;
extrapolated_bkg->Draw ("same") ;
// m4_signal_total->SetStats (0) ;
// m4_signal_total->SetMarkerStyle (5) ;
// m4_signal_total->SetMarkerColor (kBlack) ;
// m4_signal_total->Draw ("same") ;
// leg_compare.Draw () ;
c1.Print ("compare_signal_region_new.pdf", "pdf") ;
}
double XZGetParameter(int i){return (xzfitfunc->GetParameter(i));};
