void MVA_allsrcComp()
{
//InpFile = new TFile("../srcbatch/scTTMuon/TTsemiMuon.root");
//InpFile = new TFile("../srcbatch/scTTElectron/TTsemiElectron.root");
//InpFile = new TFile("../srcbatch/MonoJet_MET/MonoJet.root");
InpFile = new TFile("../srcbatch/mSUGRA_MET/mSUGRA.root");
//InpFile = new TFile("../srcbatch/scTT2Hadron/TT2Hadron.root");
//InpFile = new TFile("../srcbatch/scWToENu/WToENu.root");
//InpFile = new TFile("../srcbatch/scWToMuNu/WToMuNu.root");
//InpFile = new TFile("../srcbatch/scDYElEl/DYElEl.root");
//InpFile = new TFile("../srcbatch/scDYMuMu/DYMuMu.root");
//InpFile = new TFile("../srcbatch/scZZ4Mu/ZZ4Mu.root");
//InpFile = new TFile("../srcbatch/scZZ4El/ZZ4El.root");
//InpFile = new TFile("../srcbatch/scZZMuEl/ZZMuEl.root");
//InpFile = new TFile("../srcbatch/ZZ2Mu2Nu_MET/ZZ2Mu2Nu.root");
//InpFile = new TFile("../srcbatch/ZZ2El2Nu_MET/ZZ2El2Nu.root");
//InpFile = new TFile("../srcbatch/scWW/WW.root");
//InpFile = new TFile("../srcbatch/scWZ/WZ.root");
//InpFile = new TFile("../srcbatch/scMonoPhoton/MonoPhoton.root");
//InpFileall = new TFile("../allbatch/TTsemiMuon_MET/TTsemiMuon.root");
//InpFileall = new TFile("../allbatch/TTsemiElectron_MET/TTsemiElectron.root");
//InpFileall = new TFile("../allbatch/MonoJet_MET/MonoJet.root");
InpFileall = new TFile("../allbatch/mSUGRA_MET/mSUGRA.root");
//InpFileall = new TFile("../allbatch/TT2Hadron_MET/TT2Hadron.root");
//InpFileall = new TFile("../allbatch/WToENu_MET/WToENu.root");
//InpFileall = new TFile("../allbatch/WToMuNu_MET/WToMuNu.root");
//InpFileall = new TFile("../allbatch/DYElEl_MET/DYElEl.root");
//InpFileall = new TFile("../allbatch/DYMuMu_MET/DYMuMu.root");
//InpFileall = new TFile("../allbatch/ZZ4Mu_MET/ZZ4Mu.root");
//InpFileall = new TFile("../allbatch/ZZ4El_MET/ZZ4El.root");
//InpFileall = new TFile("../allbatch/ZZMuEl_MET/ZZMuEl.root");
//InpFileall = new TFile("../allbatch/ZZ2Mu2Nu_MET/ZZ2Mu2Nu.root");
//InpFileall = new TFile("../allbatch/ZZ2El2Nu_MET/ZZ2El2Nu.root");
//InpFileall = new TFile("../allbatch/WW_MET/WW.root");
//InpFileall = new TFile("../allbatch/WZ_MET/WZ.root");
//InpFileall = new TFile("../allbatch/MonoPhoton_MET/MonoPhoton.root");
char ylabel[100];
char histName[100];
char histName_org[100];
TH1D *pfMet;
TH1D *NoPUmet;
TH1D *MVAmet;
TH1D *NoPUmetall;
TH1D *MVAmetall;
sprintf(histName,"pfMet");
sprintf(histName_org,"pfMET_0");
pfMet =(TH1D*)InpFile->Get(histName_org)->Clone(histName);pfMet->Sumw2();
sprintf(histName,"NoPUmet");
sprintf(histName_org,"NoPuMET_0");
NoPUmet =(TH1D*)InpFile->Get(histName_org)->Clone(histName);NoPUmet->Sumw2();
sprintf(histName,"NoPUmetall");
sprintf(histName_org,"NoPuMET_0");
NoPUmetall =(TH1D*)InpFileall->Get(histName_org)->Clone(histName);NoPUmetall->Sumw2();
sprintf(histName,"MVAmet");
sprintf(histName_org,"MVaMET_0");
MVAmet =(TH1D*)InpFile->Get(histName_org)->Clone(histName);MVAmet->Sumw2();
sprintf(histName,"MVAmetall");
sprintf(histName_org,"MVaMET_0");
MVAmetall =(TH1D*)InpFileall->Get(histName_org)->Clone(histName);MVAmetall->Sumw2();
pfMet->SetLineWidth(2);
pfMet->SetLineColor(kBlack);
pfMet->SetMarkerStyle(26);
pfMet->SetMarkerColor(kBlack);
NoPUmet->SetLineWidth(2);
NoPUmet->SetLineColor(kRed);
NoPUmet->SetMarkerStyle(kFullCircle);
NoPUmet->SetMarkerColor(kRed);
NoPUmetall->SetLineWidth(2);
NoPUmetall->SetLineColor(kRed);
NoPUmetall->SetMarkerStyle(kCircle);
NoPUmetall->SetMarkerColor(kRed);
MVAmet->SetLineWidth(2);
MVAmet->SetLineColor(kBlue);
MVAmet->SetMarkerStyle(kFullSquare);
MVAmet->SetMarkerColor(kBlue);
MVAmetall->SetLineWidth(2);
MVAmetall->SetLineColor(kBlue);
MVAmetall->SetMarkerStyle(25);
MVAmetall->SetMarkerColor(kBlue);
sprintf(ylabel,"MET-genMEtTrue",MVAmet->GetBinWidth(1));
MVAmet->GetYaxis()->SetTitle(ylabel);
MVAmet->GetYaxis()->SetTitleOffset(1.2);
MVAmet->GetYaxis()->SetTitleSize(0.04);
MVAmet->GetYaxis()->SetLabelSize(0.04);
MVAmet->GetXaxis()->SetTitle("genMEt");
MVAmet->GetXaxis()->SetTitleOffset(1.0);
//MVAmet->GetXaxis()->SetTitleSize(0.13);
//MVAmet->GetYaxis()->SetRangeUser(-15,30);//WJet TTsemiPU012
//MVAmet->GetYaxis()->SetRangeUser(-25,30);// TTsemiPU3
//MVAmet->GetYaxis()->SetRangeUser(-20,30);//WW
//MVAmet->GetYaxis()->SetRangeUser(-5,20);//WZ 1
//MVAmet->GetYaxis()->SetRangeUser(-15,25);//WZ 0,2
//MVAmet->GetYaxis()->SetRangeUser(-20,35);//WZ 3
//MVAmet->GetYaxis()->SetRangeUser(-15,30);//W
//MVAmet->GetYaxis()->SetRangeUser(-20,30);//W muon3
//MVAmet->GetYaxis()->SetRangeUser(-20,55);//ZZ4El
//MVAmet->GetYaxis()->SetRangeUser(-25,55);//ZZ4Mu012
//MVAmet->GetYaxis()->SetRangeUser(-25,65);//ZZ4Mu3
//MVAmet->GetYaxis()->SetRangeUser(-70,70);//ZZMuEl 1
//MVAmet->GetYaxis()->SetRangeUser(-30,40);//ZZMuEl 0 2
//MVAmet->GetYaxis()->SetRangeUser(-50,50);//ZZMuEl 3
//MVAmet->GetYaxis()->SetRangeUser(-30,30);//ZZ2El2Nu 0 2
//MVAmet->GetYaxis()->SetRangeUser(-50,70);//ZZ2El2Nu 3
//MVAmet->GetYaxis()->SetRangeUser(-30,60);//ZZ2El2Nu 1
//MVAmet->GetYaxis()->SetRangeUser(-20,30);//DY 012
//MVAmet->GetYaxis()->SetRangeUser(-30,60);//DYmuon1
//MVAmet->GetYaxis()->SetRangeUser(-40,70);//DYele3
//MVAmet->GetYaxis()->SetRangeUser(-50,85);//DYmuon3
//MVAmet->GetYaxis()->SetRangeUser(-10,35);//TThadron
//MVAmet->GetYaxis()->SetRangeUser(0,700);//monoJet
MVAmet->GetYaxis()->SetRangeUser(-90,80);//mSUGRA 0
//MVAmet->GetYaxis()->SetRangeUser(-130,110);//mSUGRA 1
//MVAmet->GetYaxis()->SetRangeUser(-80,80);//mSUGRA 2
//MVAmet->GetYaxis()->SetRangeUser(-140,130);//mSUGRA 3
//MVAmet->GetYaxis()->SetRangeUser(-50,1000);//monoPhoton0
//MVAmet->GetYaxis()->SetRangeUser(-50,1300);//monoPhoton2
//MVAmet->GetYaxis()->SetRangeUser(-50,750);//monoPhoton13
//MVAmet->GetXaxis()->SetRangeUser(0,75);//X-axis 80
TCanvas c1("c1","c1",800,700);
gStyle->SetOptTitle(0);
MVAmet->Draw("E1");
pfMet->Draw("E1 same");
NoPUmet->Draw("E1 same");
MVAmetall->Draw("E1 same");
NoPUmetall->Draw("E1 same");
TLegend *rL =new TLegend(0.55,0.68,0.99,0.95);
rL->SetFillColor(0); rL->SetBorderSize(0);
rL->AddEntry(pfMet,"pfMet","PL");
rL->AddEntry(NoPUmet,"NoPU_wSrcLept","PL");
rL->AddEntry(NoPUmetall,"NoPU_wAllSrcLept","PL");
rL->AddEntry(MVAmet,"MVA_wSrcLept","PL");
rL->AddEntry(MVAmetall,"MVA_wAllSrcLept","PL");
rL->Draw();
//midile line
//TLine line(0,0,200,0);//TTsemi
//TLine line(0,0,300,0);//ZZ2Lept2Nu
//TLine line(0,0,100,0);
TLine line(0,0,1500,0);//mSUGRA
//TLine line(0,0,80,0);//ZZ4Mu ZZMuEl MonoPhoton
line->Draw();
//All 0To7 7To21 21To
//sprintf(histName,"muonTTJetsemiLept_PURange_All.png");
//sprintf(histName,"electronTTJetsemiLept_PURange_All.png");
//sprintf(histName,"monoJet_PURange_All.png");
sprintf(histName,"mSUGRA_PURange_All.png");
//sprintf(histName,"hadronTT2hadron_PURange_All.png");
//sprintf(histName,"electronWToENu_PURange_All.png");
//sprintf(histName,"muonWToMuNu_PURange_All.png");
//sprintf(histName,"electronDYElEl_PURange_All.png");
//sprintf(histName,"muonDYMuNu_PURange_All.png");
//sprintf(histName,"ZZ4Mu_PURange_All.png");
//sprintf(histName,"ZZ4El_PURange_All.png");
//sprintf(histName,"ZZ2Mu2El_PURange_All.png");
//sprintf(histName,"ZZ2Mu2Nu_PURange_All.png");
//sprintf(histName,"ZZ2El2Nu_PURange_All.png");
//sprintf(histName,"WW_PURange_All.png");
//sprintf(histName,"WZ_PURange_All.png");
//sprintf(histName,"monoPhoton_PURange_All.png");
c1.SaveAs(histName);
}
TCanvas *drawRatioPlot(TH1D *prediction, TH1D *sr, TString xTitle, TString filename){
TCanvas *c = new TCanvas("c"+filename,"c",0,0,500,500);
float y = 0.3;
TPad *pad1 = new TPad("pad1", "Control Plots 1", 0.01, y, 0.99, 0.99);
TPad *padRatio = new TPad("rp1", "Ratio1", 0.01, 0.01, 0.99, y-0.01);
TH1D *ratio = 0;
//ratio = (TH1D*) sr->Clone();
//ratio->Divide(prediction);
ratio = (TH1D*) prediction->Clone();
ratio->Divide(sr);
for(int i=1; i<=ratio->GetNbinsX();i++){
cout<<"Scaling Factor in "<<i<<". bin ="<<ratio->GetBinContent(i)<<" +/- "<<ratio->GetBinError(i)<<endl;
}
ratio->GetYaxis()->SetTitle("Pred/Bkg");
ratio->SetTitle("");
ratio->SetLabelSize(0.1,"X");
ratio->SetLabelSize(0.1,"Y");
ratio->SetTitleOffset(0.5,"Y");
ratio->SetTitleSize(0.15,"Y");
padRatio->cd();
//ratio->GetYaxis()->SetRangeUser(0,2);
ratio->Draw();
// Draw line at one!
float xmin = ratio->GetXaxis()->GetXmin();
float xmax = ratio->GetXaxis()->GetXmax();
TLine *line = new TLine(xmin,1,xmax,1);
line->SetLineWidth(2);
line->Draw("same");
padRatio->Modified();
TLegend *leg = new TLegend(0.6,0.8,0.9,0.9);
leg->AddEntry(sr,"bkg","l");
leg->AddEntry(prediction,"bkg prediction","pel");
pad1->cd();
pad1->SetLogy();
sr->SetLineColor(kRed);
sr->SetMarkerColor(kRed);
sr->SetMarkerStyle(20);
sr->SetTitle("");
prediction->SetMarkerStyle(20);
prediction->SetTitle("");
prediction->GetXaxis()->SetTitle(xTitle);
sr->GetXaxis()->SetTitle(xTitle);
prediction->SetTitleSize(0.07,"X");
prediction->GetXaxis()->SetTitleOffset(0.7);
sr->SetTitleSize(0.07,"X");
sr->GetXaxis()->SetTitleOffset(0.7);
prediction->Draw("e");
sr->Draw("e same");
double maximum =prediction->GetMaximum()*2.5;
double minimum = 0.00001;
if(sr->GetMinimum()!=0) minimum=sr->GetMinimum()*0.5;
if(prediction->GetMinimum()!=0) minimum=prediction->GetMinimum()*0.5;
if(sr->GetMaximum()>prediction->GetMaximum()){
maximum=sr->GetMaximum()*2.5;
}
prediction->GetYaxis()->SetRangeUser(minimum,maximum);
leg->Draw("same");
// Draw both pads to canvas
c->cd();
pad1->Draw();
padRatio->SetGridy();
padRatio->Draw();
c->SaveAs(filename);
return c;
}
void drawPtDependence_yeonju0815(bool drawPbPb=1, int xNorm = 1) {
gStyle -> SetOptStat(0);
const int nPtBin = 5;
double ptBin[nPtBin+1] = {40, 50,60,80,120,9999};
double AvePtBin[nPtBin+1] = { 45, 54.1479, 67.4204, 99.6956, 150, 9999};
TH1D* hxjg[7][1000]; // [species][centrality]
TH1D* hxjgNorm[7][1000];
TH1D* hdphi[7][1000];
valPair meanX[7][1000];
valPair rjg[7][1000];
TGraphAsymmErrors* gr[7];
TGraphAsymmErrors* gx[7];
for (int i=0;i<7;i++) {
gr[i] = new TGraphAsymmErrors();
gr[i]->SetName(Form("gr_%d",i));
gx[i] = new TGraphAsymmErrors();
gx[i]->SetName(Form("gx_%d",i));
}
TFile* fff[7][1000];
for ( int ipt = 0 ; ipt<nPtBin ; ipt++) {
for ( int iSpecies=0 ; iSpecies<=5 ; iSpecies++){
if ( (iSpecies!=kPPDATA)&&(iSpecies!=kHIDATA) )
continue;
int iglb = ipt + iSpecies*50.;
int icent = -1;
if ( iSpecies == kPPDATA) {
icent = 7;
fff[iSpecies][iglb] = new TFile(Form("ffFiles/photonTrackCorr_ppDATA_output_photonPtThr%d_to_%d_jetPtThr30_20130815.root",(int)ptBin[ipt],(int)ptBin[ipt+1]));
}
if ( iSpecies == kHIDATA) {
icent = 10030;
fff[iSpecies][iglb] = new TFile(Form("ffFiles/photonTrackCorr_pbpbDATA_output_photonPtThr%d_to_%d_jetPtThr30_20130815.root",(int)ptBin[ipt],(int)ptBin[ipt+1]));
}
hdphi[iSpecies][iglb] = (TH1D*)fff[iSpecies][iglb]->Get(Form("jetDphi_icent%d_final",icent));
hxjg[iSpecies][iglb] = (TH1D*)fff[iSpecies][iglb]->Get(Form("xjg_icent%d_final",icent));
hxjgNorm[iSpecies][iglb] = (TH1D*)hxjg[iSpecies][iglb]->Clone(Form("norm_%s",hxjg[iSpecies][iglb]->GetName()) );
meanX[iSpecies][iglb].val = hxjg[iSpecies][iglb]->GetMean();
meanX[iSpecies][iglb].err = hxjg[iSpecies][iglb]->GetMeanError();
gx[iSpecies]->SetPoint (ipt+1, AvePtBin[ipt], meanX[iSpecies][iglb].val);
gx[iSpecies]->SetPointError(ipt+1, 0.001,0.001, meanX[iSpecies][iglb].err, meanX[iSpecies][iglb].err);
double rError;
rjg[iSpecies][iglb].val = hxjg[iSpecies][iglb]->IntegralAndError(1, hxjg[iSpecies][iglb]->GetNbinsX(), rError, "width");
rjg[iSpecies][iglb].err = rError;
gr[iSpecies]->SetPoint (ipt+1, AvePtBin[ipt], rjg[iSpecies][iglb].val);
gr[iSpecies]->SetPointError(ipt+1, 0.001,0.001, rjg[iSpecies][iglb].err, rjg[iSpecies][iglb].err);
}
}
// for PbPb 30-9999!!!!
for ( int ipt = 0 ; ipt<nPtBin ; ipt++) {
int iSpecies=6;
int iglb = ipt + iSpecies*50.;
int icent = 13099;
fff[iSpecies][iglb] = new TFile(Form("photonTrackCorr_pbpbDATA_output_photonPtThr%d_to_%d_jetPtThr30_20130815.root",(int)ptBin[ipt],(int)ptBin[ipt+1]));
hdphi[iSpecies][iglb] = (TH1D*)fff[iSpecies][iglb]->Get(Form("jetDphi_icent%d_final",icent));
hxjg[iSpecies][iglb] = (TH1D*)fff[iSpecies][iglb]->Get(Form("xjg_icent%d_final",icent));
hxjgNorm[iSpecies][iglb] = (TH1D*)hxjg[iSpecies][iglb]->Clone(Form("norm_%s",hxjg[iSpecies][iglb]->GetName()) );
meanX[iSpecies][iglb].val = hxjg[iSpecies][iglb]->GetMean();
meanX[iSpecies][iglb].err = hxjg[iSpecies][iglb]->GetMeanError();
gx[iSpecies]->SetPoint (ipt+1, AvePtBin[ipt], meanX[iSpecies][iglb].val);
gx[iSpecies]->SetPointError(ipt+1, 0.001,0.001, meanX[iSpecies][iglb].err, meanX[iSpecies][iglb].err);
double rError;
rjg[iSpecies][iglb].val = hxjg[iSpecies][iglb]->IntegralAndError(1, hxjg[iSpecies][iglb]->GetNbinsX(), rError, "width");
rjg[iSpecies][iglb].err = rError;
gr[iSpecies]->SetPoint (ipt+1, AvePtBin[ipt], rjg[iSpecies][iglb].val);
gr[iSpecies]->SetPointError(ipt+1, 0.001,0.001, rjg[iSpecies][iglb].err, rjg[iSpecies][iglb].err);
}
TCanvas* c1 = new TCanvas("c1","",1350,350);
makeMultiPanelCanvas(c1,nPtBin,1,0.0,0.0,0.2,0.15,0.02);
for ( int ipt = 0 ; ipt<nPtBin ; ipt++) {
c1->cd(ipt+1);
int iSpecies = kPPDATA;
int iglb = ipt + iSpecies*50.;
handsomeTH1(hxjgNorm[iSpecies][iglb],1);
if (xNorm==1) scaleInt(hxjgNorm[iSpecies][iglb]);
hxjgNorm[iSpecies][iglb]->SetXTitle("x_{J,#gamma}");
hxjgNorm[iSpecies][iglb]->SetYTitle("#frac{dN}{dx} #frac{1}{N}");
if (xNorm==1) hxjgNorm[iSpecies][iglb]->SetAxisRange(-0.015,0.3,"Y");
else hxjgNorm[iSpecies][iglb]->SetAxisRange(-0.06,1.5,"Y");
hxjgNorm[iSpecies][iglb]->SetMarkerStyle(24);
hxjgNorm[iSpecies][iglb]->Draw();
iSpecies = kHIDATA;
iglb = ipt + iSpecies*50.;
if (xNorm==1) scaleInt(hxjgNorm[iSpecies][iglb]);
handsomeTH1(hxjgNorm[iSpecies][iglb],2);
if (drawPbPb) hxjgNorm[iSpecies][iglb]->Draw("same");
//for PbPb 30-9999!!!!
iSpecies = 6;
iglb = ipt + iSpecies*50.;
if (xNorm==1) scaleInt(hxjgNorm[iSpecies][iglb]);
handsomeTH1(hxjgNorm[iSpecies][iglb],2);
hxjgNorm[iSpecies][iglb] -> SetMarkerStyle(24);
if (drawPbPb) hxjgNorm[iSpecies][iglb]->Draw("same");
onSun(0,0,2,0);
// onSun(meanX[iSpecies][iglb].val - meanX[iSpecies][iglb].err, 0, meanX[iSpecies][iglb].val+meanX[iSpecies][iglb].err,0,ycolor[ipt+1],2);
float dx1;
(ipt==0)? dx1=0.15 : dx1=0 ;
if ( ipt == nPtBin-1 )
drawText(Form("p_{T}^{#gamma} > %dGeV, p_{T}^{jet}>30GeV", (int)ptBin[ipt]), 0.12+dx1+0.25,0.889118,1,15);
else
drawText(Form("%dGeV < p_{T}^{#gamma} < %dGeV, p_{T}^{jet}>30GeV", (int)ptBin[ipt], (int)ptBin[ipt+1]), 0.12+dx1,0.889118,1,15);
TLegend *l1 = new TLegend(0.6365615,0.6445304,0.9577623,0.846736,NULL,"brNDC");
easyLeg(l1,"2.76TeV");
l1->AddEntry(hxjgNorm[kPPDATA][ipt + kPPDATA*50],"pp ","p");
if (drawPbPb) l1->AddEntry(hxjgNorm[kHIDATA][iglb],"PbPb 0-30%","p");
if (drawPbPb) l1->AddEntry(hxjgNorm[6][iglb],"PbPb 30-100%","p");
if ( ipt==0 ) l1->Draw();
}
c1->SaveAs(Form("gifs/xjg_ptDependence_drawPbPb%d_norm%d.pdf",drawPbPb,xNorm));
TCanvas* cDphi = new TCanvas("cDphi","",1350,350);
makeMultiPanelCanvas(cDphi,nPtBin,1,0.0,0.0,0.2,0.15,0.02);
for ( int ipt = 0 ; ipt<nPtBin ; ipt++) {
cDphi->cd(ipt+1);
int iSpecies = kPPDATA;
int iglb = ipt + iSpecies*50.;
handsomeTH1(hdphi[iSpecies][iglb],1);
hdphi[iSpecies][iglb]->SetYTitle("x_{J,#gamma}");
hdphi[iSpecies][iglb]->SetXTitle("#Delta#phi_{J,#gamma}");
hdphi[iSpecies][iglb]->Scale(1./hdphi[iSpecies][iglb]->Integral("width"));
hdphi[iSpecies][iglb]->SetAxisRange(0.01,30,"Y");
hdphi[iSpecies][iglb]->SetMarkerStyle(24);
hdphi[iSpecies][iglb]->Draw();
iSpecies = kHIDATA;
iglb = ipt + iSpecies*50.;
hdphi[iSpecies][iglb]->Scale(1./hdphi[iSpecies][iglb]->Integral("width"));
handsomeTH1(hdphi[iSpecies][iglb],2);
if (drawPbPb) hdphi[iSpecies][iglb]->Draw("same");
//for PbPb 30-100!!!
iSpecies = 6;
iglb = ipt + iSpecies*50.;
hdphi[iSpecies][iglb]->Scale(1./hdphi[iSpecies][iglb]->Integral("width"));
handsomeTH1(hdphi[iSpecies][iglb],2);
hdphi[iSpecies][iglb]->SetMarkerStyle(24);
if (drawPbPb) hdphi[iSpecies][iglb]->Draw("same");
gPad->SetLogy();
float dx1;
(ipt==0)? dx1=0.15 : dx1=0 ;
if ( ipt == nPtBin-1 )
drawText(Form("%dGeV<p_{T}^{#gamma}, p_{T}^{jet}>30GeV", (int)ptBin[ipt]), 0.15+dx1+0.25,0.889118,1,15);
else
drawText(Form("%dGeV<p_{T}^{#gamma}<%dGeV, p_{T}^{jet}>30GeV", (int)ptBin[ipt], (int)ptBin[ipt+1]), 0.15+dx1,0.889118,1,15);
TLegend *l1 = new TLegend(0.6365615,0.6445304,0.9577623,0.846736,NULL,"brNDC");
easyLeg(l1,"2.76TeV");
l1->AddEntry(hdphi[kPPDATA][ipt + kPPDATA*50],"pp ","p");
if (drawPbPb) l1->AddEntry(hdphi[kHIDATA][iglb],"PbPb 0-30%","p");
if (drawPbPb) l1->AddEntry(hdphi[kHIDATA][iglb],"PbPb 30-100%","p");
if ( ipt==0 ) l1->Draw();
}
cDphi->SaveAs(Form("gifs/dphi_ptDependence_drawPbPb%d_norm%d.pdf",drawPbPb,xNorm));
TCanvas* c2 = new TCanvas("c2","",800,400);
c2->Divide(2,1);
c2->cd(2);
TH1D* hr = new TH1D("hr",";p_{T}^{#gamma};r_{J,#gamma}",200,20,180);
handsomeTH1(hr,1);
hr->SetAxisRange(0.0,1.1,"Y");
// hr->SetNdivisions(5);
hr->Draw();
handsomeTGraph(gr[kPPDATA],1);
handsomeTGraph(gr[kHIDATA],2);
handsomeTGraph(gr[6],2);
gr[kPPDATA]->SetMarkerStyle(24);
gr[kPPDATA]->Draw("same p");
gr[6]->SetMarkerStyle(24);
if (drawPbPb) gr[kHIDATA]->Draw("same p");
if (drawPbPb) gr[6]->Draw("same p");
jumSun(20,1,180,1);
gStyle->SetEndErrorSize(0);
c2->cd(1);
TH1D* hx = (TH1D*)hr->Clone("hx");
handsomeTH1(hx,1);
hx->SetYTitle("<x_{J,#gamma}>");
hx->SetAxisRange(0.6,1.05,"Y");
// hx->SetNdivisions(5);
hx->Draw();
handsomeTGraph(gx[kPPDATA],1);
handsomeTGraph(gx[kHIDATA],2);
handsomeTGraph(gx[6],2);
gx[kPPDATA]->SetMarkerStyle(24);
gx[kPPDATA]->Draw("same p");
gx[6]->SetMarkerStyle(24);
if (drawPbPb) gx[kHIDATA]->Draw("same p");
if (drawPbPb) gx[6]->Draw("same p");
jumSun(20,1,180,1);
c2->cd(2);
TLegend *l1= new TLegend(0.5226071,0.6300415,0.9597724,0.8332584,NULL,"brNDC");
easyLeg(l1,"2.76TeV");
l1->AddEntry(gr[kPPDATA],"pp ","p");
if (drawPbPb) l1->AddEntry(gr[kHIDATA],"PbPb 0-30%","p");
if (drawPbPb) l1->AddEntry(gr[6],"PbPb 30-100%","p");
l1->Draw();
c2->SaveAs(Form("gifs/summaryPlot_ptDependence_drawPbPb%d_norm%d.pdf",drawPbPb,xNorm));
}
void drawMixedEvent()
{
gStyle->SetOptStat(0);
gStyle->SetLabelFont(132, "x");
gStyle->SetLabelFont(132, "y");
gStyle->SetTitleFont(132, "x");
gStyle->SetTitleFont(132, "y");
gStyle->SetLegendFont(132);
TFile *f = new TFile("mixedEventSeparatedByCharge.root");
const float massFrom = 0;
const float massTo = 3;
const float fixedBinWidth = 0.01;
const int massNBins = (massTo - massFrom) / fixedBinWidth;
TCanvas *C = new TCanvas("C", "mass plot", 500, 500);
TH1D* sig = new TH1D("sig", "", massNBins, massFrom, massTo);
TH1D* bkgSELS = new TH1D("bkgSELS", "", massNBins, massFrom, massTo);
TH1D* bkgMEUS = new TH1D("bkgMEUS", "", massNBins, massFrom, massTo);
TH1D* bkgMELS = new TH1D("bkgMELS", "", massNBins, massFrom, massTo);
//--------------------------------------------------
for (int iCent = minCent; iCent < maxCent; ++iCent)
{
for (int iVz = 0; iVz < 10; ++iVz)
{
std::string baseName = Form("Cent_%i_Vz_%i",iCent,iVz);
TH2F* hSE_LS = static_cast<TH2F*>(f->Get(Form("%s_se_ls_mass", baseName.data())));
TH2F* hSE_US_plus = static_cast<TH2F*>(f->Get(Form("%s_se_us_plus_mass", baseName.data())));
TH2F* hSE_US_minus = static_cast<TH2F*>(f->Get(Form("%s_se_us_minus_mass", baseName.data())));
TH2F* hME_LS = static_cast<TH2F*>(f->Get(Form("%s_me_ls_mass", baseName.data())));
TH2F* hME_US_plus = static_cast<TH2F*>(f->Get(Form("%s_me_us_plus_mass", baseName.data())));
TH2F* hME_US_minus = static_cast<TH2F*>(f->Get(Form("%s_me_us_minus_mass", baseName.data())));
const int firstPtBin = 10.*minPt + 1;
cout << "first bin " << firstPtBin << endl;
const int lastPtBin = 10.*maxPt;
cout << "last bin " << lastPtBin << endl;
TH1D* massProj_SE_LS = hSE_LS->ProjectionY(Form("%s_se_ls_mass_proj", baseName.data()), firstPtBin, lastPtBin);
TH1D* massProj_SE_US_plus = hSE_US_plus->ProjectionY(Form("%s_se_us_plus_mass_proj", baseName.data()), firstPtBin, lastPtBin);
TH1D* massProj_SE_US_minus = hSE_US_minus->ProjectionY(Form("%s_se_us_minus_mass_proj", baseName.data()), firstPtBin, lastPtBin);
TH1D* massProj_ME_LS = hME_LS->ProjectionY(Form("%s_me_ls_mass_proj", baseName.data()), firstPtBin, lastPtBin);
TH1D* massProj_ME_US_plus = hME_US_plus->ProjectionY(Form("%s_me_us_plus_mass_proj", baseName.data()), firstPtBin, lastPtBin);
TH1D* massProj_ME_US_minus = hME_US_minus->ProjectionY(Form("%s_me_us_minus_mass_proj", baseName.data()), firstPtBin, lastPtBin);
// add the bin content
const int firstBin = massFrom / fixedBinWidth;
for (int iBin = 0; iBin < massNBins; ++iBin)
{
const int histBin = iBin+1;
const int movedBin = firstBin + iBin + 1;
sig->SetBinContent(histBin, massProj_SE_US_plus->GetBinContent(movedBin) + sig->GetBinContent(histBin));
sig->SetBinContent(histBin, massProj_SE_US_minus->GetBinContent(movedBin) + sig->GetBinContent(histBin));
bkgSELS->SetBinContent(histBin, massProj_SE_LS->GetBinContent(movedBin) + bkgSELS->GetBinContent(histBin));
bkgMEUS->SetBinContent(histBin, massProj_ME_US_plus->GetBinContent(movedBin) + bkgMEUS->GetBinContent(histBin));
bkgMEUS->SetBinContent(histBin, massProj_ME_US_minus->GetBinContent(movedBin) + bkgMEUS->GetBinContent(histBin));
bkgMELS->SetBinContent(histBin, massProj_ME_LS->GetBinContent(movedBin) + bkgMELS->GetBinContent(histBin));
sig->SetBinError(histBin, addErrors(sig->GetBinError(histBin), massProj_SE_US_plus->GetBinError(movedBin)) );
sig->SetBinError(histBin, addErrors(sig->GetBinError(histBin), massProj_SE_US_minus->GetBinError(movedBin)) );
bkgSELS->SetBinError(histBin, addErrors(bkgSELS->GetBinError(histBin), massProj_SE_LS->GetBinError(movedBin)) );
bkgMEUS->SetBinError(histBin, addErrors(bkgMEUS->GetBinError(histBin), massProj_ME_US_plus->GetBinError(movedBin)) );
bkgMEUS->SetBinError(histBin, addErrors(bkgMEUS->GetBinError(histBin), massProj_ME_US_minus->GetBinError(movedBin)) );
bkgMELS->SetBinError(histBin, addErrors(bkgMELS->GetBinError(histBin), massProj_ME_LS->GetBinError(movedBin)) );
}
}
}
//--------------------------------------------------
const float sigma = 7.76446e-03; // taken from fit of the whole dataset +-3.64310e-03
const float meanInclusive = 2.28359; // +-2.14540e-03
const float nSigma = 8.;
const float sideBandTo = roundToPreviousBin(meanInclusive - nSigma*sigma, massNBins, massFrom, massTo);
const float sideBandFrom = roundToNextBin(meanInclusive + nSigma*sigma, massNBins, massFrom, massTo);
const float sideBand = sig->Integral(massFrom, sideBandTo) + sig->Integral(sideBandFrom, massTo);
cout << "Side-band yield = " << sideBand << endl;
// scaling the mixed event BKG by the yield of the side-band
float sideBandYield = 0;
float mixedSideBandYield = 0;
for (int i = 0; i < massNBins; ++i)
{
const float binCenter = sig->GetXaxis()->GetBinCenter(i+1);
if(binCenter < sideBandTo || binCenter > sideBandFrom)
{
sideBandYield += sig->GetBinContent(i+1);
mixedSideBandYield += bkgMEUS->GetBinContent(i+1);
}
}
TH1D* sideBandMarker = new TH1D("sideBandMarker","marker for the sideband in the form of a histogram", massNBins, massFrom, massTo);
const float binWidth = (massTo - massFrom) / static_cast<float>(massNBins);
for(int i = 0; i < massNBins; ++i)
sideBandMarker->SetBinContent(i+1, 1000);
for(float bin = sideBandTo; bin < sideBandFrom; bin += binWidth)
{
// cout << bin << endl;
sideBandMarker->Fill(bin + 0.5*binWidth, -1e6);
}
sideBandMarker->SetFillColor(kRed);
sideBandMarker->SetFillStyle(3004);
sideBandMarker->SetLineColorAlpha(kRed,0);
bkgSELS->Scale(1./3.);
cout << "Scaling mixed event bg by " << sideBandYield / mixedSideBandYield << endl;
bkgMEUS->Scale(sideBandYield / (mixedSideBandYield) );
TF1 *line = new TF1("line", "[0] + [1]*x");
TF1 *gaussPlusLine = new TF1("gaussPlusLine", "[0] + [1]*x + [2]*TMath::Gaus(x,[3],[4],1)");
bkgMEUS->Fit(line, "", "", 2.1, 2.5);
double offset = line->GetParameter(0);
double slope = line->GetParameter(1);
const double LcMass = 2.28646;
gaussPlusLine->FixParameter(0,offset);
gaussPlusLine->FixParameter(1,slope);
gaussPlusLine->SetParameter(3,LcMass);
gaussPlusLine->SetParameter(2,1);
gaussPlusLine->SetParameter(4,sigma);
sig->Fit(gaussPlusLine, "", "", 2.1, 2.5);
// -- Drawing
sig->GetXaxis()->SetTitle("#font[12]{m}_{pK#pi} (GeV/#font[12]{c}^{2})");
sig->GetXaxis()->CenterTitle();
sig->GetXaxis()->SetLabelSize(0.04);
sig->GetXaxis()->SetTitleSize(0.055);
sig->GetXaxis()->SetTitleOffset(0.8);
// sig->GetXaxis()->SetTickLength(0.001);
sig->GetYaxis()->SetTitle("#font[12]{N}/(10 MeV/#font[12]{c}^{2})");
sig->GetYaxis()->CenterTitle();
sig->GetYaxis()->SetLabelSize(0.04);
sig->GetYaxis()->SetTitleSize(0.055);
sig->GetYaxis()->SetTitleOffset(0.8);
// sig->GetYaxis()->SetRangeUser(17, 95);
sig->SetMarkerStyle(20);
sig->SetLineColor(kBlack);
bkgMEUS->SetMarkerStyle(21);
bkgMEUS->SetMarkerColor(kOrange+5);
bkgMEUS->SetLineColor(kOrange+5);
bkgMEUS->GetFunction("line")->SetLineColor(kRed);
bkgMEUS->GetFunction("line")->SetLineStyle(2);
bkgMEUS->GetFunction("line")->SetNpx(10000);
bkgSELS->SetMarkerStyle(22);
bkgSELS->SetMarkerColor(kBlue-7);
bkgSELS->SetLineColor(kBlue-7);
bkgMELS->SetMarkerStyle(23);
bkgMELS->SetMarkerColor(kGreen+2);
bkgMELS->SetLineColor(kGreen+2);
sig->GetFunction("gaussPlusLine")->SetLineColor(kRed);
sig->GetFunction("gaussPlusLine")->SetNpx(10000);
sig->GetXaxis()->SetRangeUser(2.1,2.5);
sig->Draw("E");
bkgMEUS->Draw("Esame");
bkgSELS->Draw("Esame");
// bkgMELS->Draw("Esame");
TLegend *leg = new TLegend(0.5,0.6,0.89,0.8);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
leg->AddEntry(sig, "Same event correct sign", "pl");
leg->AddEntry(bkgSELS, "Same event wrong sign", "pl");
leg->AddEntry(bkgMEUS, "Mixed event correct sign", "pl");
// leg->AddEntry(bkgMELS, "Mixed event wrong sign", "pl");
leg->Draw();
// sideBandMarker->Draw("same BAR");
TLegend *dataSet = new TLegend(0., 0.7, 0.4, 0.89);
dataSet->SetFillStyle(0);
dataSet->SetBorderSize(0);
dataSet->AddEntry("", "#font[22]{Au+Au 200 GeV, 10-60%}","");
dataSet->AddEntry("",Form("%1.0f GeV/#font[12]{c} < #font[12]{p}_{T} < %1.0f GeV/#font[12]{c}", minPt, maxPt),"");
dataSet->Draw();
// -- yield calculation
const float min = 2.26;
const float max = 2.31;
// -- get part of the Gauss curve
TF1 *normGaus = new TF1("normGaus", "TMath::Gaus(x,[0],[1],1)");
double mean = gaussPlusLine->GetParameter(3);
double width= gaussPlusLine->GetParameter(4);
normGaus->SetParameter(0,mean);
normGaus->SetParameter(1,width);
double norm = normGaus->Integral(min, max);
int minBin = sig->FindBin(min) + 1;
int maxBin = sig->FindBin(max);
cout << "integral from " << sig->GetBinCenter(minBin) - 0.005 << " to " << sig->GetBinCenter(maxBin) + 0.005 << endl;
float NSig = sig->Integral(minBin,maxBin);
float NBkg = bkgMEUS->Integral(minBin, maxBin);
float Nlc = (NSig - NBkg)/norm;
float error = std::sqrt(NSig/norm);
cout << "N Sig = " << NSig << endl;
cout << "N Bkg = " << NBkg << endl;
cout << "norm = " << norm << endl;
cout << "N Lambda_c = " << Nlc << endl;
cout << "sigma = " << error << endl;
}
//void drawBinsOfMet(const TString var = "minDeltaPhiN", const TString treestring = "/cu2/ra2b/reducedTrees/V00-02-25_fullpf2pat/reducedTree.SSVHPT_PF2PATjets_JES0_JER0_PFMET_METunc0_PUunc0_BTagEff0_HLTEff0.PythiaPUQCD.root")
void mdpBinsOfMet(const TString var = "min_delta_phi_met_N", const TString btag_cut="num_csvm_jets>=1", TString plotTitle="", bool logy = false, const TString treestring = "reduced_trees/QCD_Pt*v75*.root")
{
const TCut btag(btag_cut);
//const TCut btag = "nbjetsSSVHPT>=2";
//const TCut btag = "nbjetsSSVHPT==0";
//const TCut btag = "nbjetsSSV0>=1";
//const TString var ="minDeltaPhiN";
//const TString var ="minDeltaPhi";
// const TString var ="bestTopMass";
// const TString var ="MET/(MET+HT)";
// const TString var ="deltaPhiMPTcaloMET";
const bool drawLSB = true;
const bool drawMSB = true;
const bool drawSB = true;
const bool drawSIG = true;
float customMax = 1;
if(logy) customMax = 10;
//const float customMax = -1;
const bool doRatio=false; //hack for a specific ratio plot
const int nbins=10;
float min=0;
float max=0;
if (var=="bestTopMass") max=800;
else if (var=="min_delta_phi_met"||var=="min_delta_phi_met_loose_jets") max=TMath::Pi();
else if (var.Contains("min_delta_phi_met_N")) max=20;
else if (var.Contains("minDeltaPhiK")) max=20;
else if (var=="deltaPhiMPTcaloMET") max=TMath::Pi();
else max = 0.6;
//updated to use reducedTrees
bool addOverflow = true;
if (var.Contains("min_delta_phi_met")) addOverflow=false;
else if (var=="bestTopMass") addOverflow=false;
else if (var=="deltaPhiMPTcaloMET") addOverflow=false;
// gROOT->SetStyle("CMS");
gStyle->SetOptStat(0);
TCut baseline ="ht40>=400&&jet1_pt>70&&jet2_pt>70&&jet3_pt>50"; //no mindp, no MET
TString dp_cut(var);
if (var.Contains("min_delta_phi_met_N")) dp_cut+=">4.";
else if (var.Contains("min_delta_phi_met")) dp_cut+=">0.3";
TCut minDPcut(dp_cut);
//TCut minDPcut = "minDeltaPhi > 0.2"; cout<<"warning -- using special minDeltaPhi cut! "<<minDPcut.GetTitle()<<endl;
if (!var.Contains("min_delta_phi_met")) baseline = baseline&&minDPcut;
TCut LSB = "met<75";
TCut MSB = "met>=75 && met<150";
TCut SB = "met>=150 && met <225";
TCut SIG = "met>225";
TCut cut1=baseline && LSB && btag;
TCut cut2=baseline && MSB && btag;
TCut cut3=baseline && SB && btag;
TCut cut4=baseline && SIG && btag;
TString selection1 = TString("weightppb*(")+cut1.GetTitle()+")";
TString selection2 = TString("weightppb*(")+cut2.GetTitle()+")";
TString selection3 = TString("weightppb*(")+cut3.GetTitle()+")";
TString selection4 = TString("weightppb*(")+cut4.GetTitle()+")";
// TChain madgraph("reducedTree");
// madgraph.Add("/cu2/joshmt/V00-03-01_6/reducedTree.Baseline0_PF_JERbias6_pfMEThigh_PFLepRA20e0mu_minDP_MuonCleaning.QCD.root");
TChain * pypu = new TChain("reduced_tree");
//pypu->Add("/cu2/ra2b/reducedTrees/V00-02-05_v2/reducedTree.SSVHPT.PythiaPUQCD.root");
//pypu->Add("/cu2/ra2b/reducedTrees/V00-02-25_fullpf2pat/reducedTree.SSVHPT_PF2PATjets_JES0_JER0_PFMET_METunc0_PUunc0_BTagEff0_HLTEff0.PythiaPUQCD.root");
pypu->Add(treestring);// treestring is passed as an argument
// TChain py("reducedTree");
// py.Add("/cu2/joshmt/V00-03-01_6/reducedTree.Baseline0_PF_JERbias6_pfMEThigh_PFLepRA20e0mu_minDP_MuonCleaning.PythiaQCD.root");
TH1::SetDefaultSumw2(); //trick to turn on Sumw2 for all histos
//constint nbins=6;
// const double varbins[]={0.,160.,180.,260.,400.,800.,2000};
int height= doRatio ? 800 : 600;
TCanvas * thecanvas= new TCanvas("thecanvas","the canvas",700,height);
if (doRatio) {
thecanvas->Divide(1,2);
const float padding=0.01; const float ydivide=0.2;
thecanvas->GetPad(1)->SetPad( padding, ydivide + padding, 1-padding, 1-padding);
thecanvas->GetPad(2)->SetPad( padding, padding, 1-padding, ydivide-padding);
thecanvas->cd(1);
}
TH1D * Hlow = new TH1D("Hlow","",nbins,min,max);
TH1D * Hmed = new TH1D("Hmed","",nbins,min,max);
TH1D * Hmh = new TH1D("Hmh","",nbins,min,max);
TH1D * Hhigh = new TH1D("Hhigh","",nbins,min,max);
TH1D * Hratio = new TH1D("Hratio","",nbins,min,max);
/*
TH1D Hlow("Hlow","",nbins,varbins);
TH1D Hmed("Hmed","",nbins,varbins);
TH1D Hmh("Hmh","",nbins,varbins);
TH1D Hhigh("Hhigh","",nbins,varbins);
*/
Hlow->SetLineColor(46);
Hmed->SetLineColor(38);
Hmh->SetLineColor(8);
Hhigh->SetLineColor(kOrange);
Hlow->SetMarkerColor(46);
Hmed->SetMarkerColor(38);
Hmh->SetMarkerColor(8);
Hhigh->SetMarkerColor(kOrange);
Hlow->SetMarkerStyle(23);
Hmed->SetMarkerStyle(22);
Hmh->SetMarkerStyle(21);
Hhigh->SetMarkerStyle(20);
Hlow->SetMarkerSize(1);
Hmed->SetMarkerSize(1);
Hmh->SetMarkerSize(1);
Hhigh->SetMarkerSize(1);
Width_t width=2;
Hlow->SetLineWidth(width);
Hmed->SetLineWidth(width);
Hmh->SetLineWidth(width);
Hhigh->SetLineWidth(width);
if(logy){
Hlow->SetMinimum(1E-2);
Hmed->SetMinimum(1E-2);
Hmh->SetMinimum(1E-2);
Hhigh->SetMinimum(1E-2);
}
cout << "drawLSB" << endl;
if (drawLSB) pypu->Draw(var+">>Hlow", selection1);
cout << "drawMSB" << endl;
if (drawMSB) pypu->Draw(var+">>Hmed", selection2);
cout << "drawSB" << endl;
if (drawSB) pypu->Draw(var+">>Hmh", selection3);
cout << "drawSIG" << endl;
if (drawSIG) pypu->Draw(var+">>Hhigh",selection4);
gPad->SetRightMargin(0.1);
gPad->SetLogy(logy);
gPad->Modified();
if (addOverflow) {
Hlow->SetBinContent(nbins, Hlow->GetBinContent(nbins)+Hlow->GetBinContent(nbins+1));
Hmed->SetBinContent(nbins, Hmed->GetBinContent(nbins)+Hmed->GetBinContent(nbins+1));
Hmh->SetBinContent(nbins, Hmh->GetBinContent(nbins)+Hmh->GetBinContent(nbins+1));
Hhigh->SetBinContent(nbins, Hhigh->GetBinContent(nbins)+Hhigh->GetBinContent(nbins+1));
}
if (Hlow->Integral()>0) Hlow->Scale( 1.0 / Hlow->Integral());
if (Hmed->Integral()>0) Hmed->Scale( 1.0 / Hmed->Integral());
if (Hmh->Integral()>0) Hmh->Scale( 1.0 / Hmh->Integral());
if (Hhigh->Integral()>0) Hhigh->Scale( 1.0 / Hhigh->Integral());
if (var=="min_delta_phi_met"||var=="min_delta_phi_met_loose_jets") Hhigh->SetXTitle("#Delta #phi_{min} [rad.]");
else if (var=="bestTopMass") {
TString title="best 3-jet mass (GeV)";
Hhigh->SetXTitle(title);
Hmh->SetXTitle(title);
Hmed->SetXTitle(title);
Hlow->SetXTitle(title);
}
else if (var.Contains("min_delta_phi_met_N")) {
Hhigh->SetXTitle("#Delta #hat{#phi}_{N}^{min}");
}
else {
Hhigh->SetXTitle(var);
}
TString ytitle="(a.u.)";
Hhigh->SetYTitle(ytitle);
Hmh->SetYTitle(ytitle);
Hmed->SetYTitle(ytitle);
Hlow->SetYTitle(ytitle);
//TString thetitle=btag.GetTitle();
TString thetitle="";
// thetitle += " (fail minDeltaPhi)";
Hhigh->SetTitle(thetitle);
Hmh->SetTitle(thetitle);
Hmed->SetTitle(thetitle);
Hlow->SetTitle(thetitle);
TString drawopt="hist e";
if (drawSIG) {Hhigh->Draw(drawopt); drawopt="hist e SAME"; if (customMax>0) Hhigh->SetMaximum(customMax);}
if (drawSB) {Hmh->Draw(drawopt); drawopt="hist e SAME"; if (customMax>0) Hmh->SetMaximum(customMax);}
if (drawMSB) {Hmed->Draw(drawopt); drawopt="hist e SAME"; if (customMax>0) Hmed->SetMaximum(customMax);}
if (drawLSB) {Hlow->Draw(drawopt); drawopt="hist e SAME"; if (customMax>0) Hlow->SetMaximum(customMax);}
// if (var=="minDeltaPhi") {
// Hhigh->SetMinimum(0);
// Hhigh->GetXaxis()->SetRangeUser(0,2);
// }
TLegend * leg = 0;
if(logy) leg = new TLegend(0.38,0.65,0.8,0.85);
else {leg = new TLegend(0.38,0.55,0.8,0.85);}
leg->SetFillColor(0);
leg->SetBorderSize(0);
leg->SetLineStyle(0);
leg->SetFillStyle(0);
leg->SetTextFont(132);
leg->SetTextSize(.04);
if(logy) leg->SetTextSize(0.03);
char label[100];
if (drawLSB) {
sprintf(label,"E_{T}^{miss} < 75 GeV (#mu=%3.2f)",Hlow->GetMean());
leg->AddEntry(Hlow,label);
}
if (drawMSB) {
sprintf(label,"75 < E_{T}^{miss} < 150 GeV (#mu=%3.2f)",Hmed->GetMean());
leg->AddEntry(Hmed,label);
}
if (drawSB) {
sprintf(label,"150 < E_{T}^{miss} < 225 Ge (#mu=%3.2f)",Hmh->GetMean());
leg->AddEntry(Hmh,label);
}
if (drawSIG) {
sprintf(label,"E_{T}^{miss} > 225 GeV (#mu=%3.2f)",Hhigh->GetMean());
leg->AddEntry(Hhigh,label);
}
leg->Draw();
// TLatex* text1=0;
// text1 = new TLatex(3.570061,23.08044,"CMS Simulation");
// text1->SetNDC();
// text1->SetTextAlign(13);
// text1->SetX(0.45);
// text1->SetY(.9);
// text1->SetTextFont(132);
// text1->SetTextSizePixels(24);
// text1->Draw();
if (doRatio) {
Hratio->Divide(Hmh,Hlow);
Hratio->SetLineWidth(2);
thecanvas->cd(2);
Hratio->Draw();
Hratio->SetMinimum(0);
Hratio->SetMaximum(3);
TLine* l1 = new TLine(min,1,max,1);
l1->SetLineColor(kMagenta);
l1->SetLineWidth(2);
l1->Draw();
cout<<"KS test results = "<<Hmh->KolmogorovTest(Hlow)<<endl;
}
// double chi2=0;
// for (int i=1; i<=nbins; i++) {
// double denom=Hlow->GetBinError(i)*Hlow->GetBinError(i) + Hmh->GetBinError(i)*Hmh->GetBinError(i);
// double c2= denom>0 ? pow( Hlow->GetBinContent(i) - Hmh->GetBinContent(i) ,2) / denom : 0;
// chi2+=c2;
// }
// cout<<"Hand chi^2 = "<<chi2<<endl;
// Hlow->Chi2Test(Hmh,"WW p");
if (plotTitle=="") {
if(logy) {thecanvas->Print("macros/qcd_control/plots/METcorrelation_"+var+"_logy.png");thecanvas->Print("macros/qcd_control/plots/METcorrelation_"+var+"_logy.pdf");}
else {thecanvas->Print("macros/qcd_control/plots/METcorrelation_"+var+".png"); thecanvas->Print("macros/qcd_control/plots/METcorrelation_"+var+".pdf"); }
}
else {
if(logy) {thecanvas->Print("macros/qcd_control/plots/"+plotTitle+"_logy.png");thecanvas->Print("macros/qcd_control/plots/"+plotTitle+"_logy.pdf");}
else {thecanvas->Print("macros/qcd_control/plots/"+plotTitle+".png"); thecanvas->Print("macros/qcd_control/plots/"+plotTitle+".pdf"); }
}
delete pypu;
delete Hlow;
delete Hmed;
delete Hmh;
delete Hhigh;
delete Hratio;
delete thecanvas;
}
// -----------------------------------------------------------------------------
//
int qcdBkgdEst_new() {
// int nn = 100;
// std::vector<float> xx;
// std::vector<float> yy;
// for ( uint i = 0; i < nn; ++i ) { xx.push_back( i*100. ); }
// for ( uint ilumi = 0; ilumi < nn; ++ilumi ) {
bool plots = true;
// 0 = false (force to gaussian), 1 = true, 2 = for prescales
int use_sumw2 = 2;
std::string label = "";
//int last_bin = 7;
setTDRStyle();
// Misc
bool efficiency = false;
enum choices { PLOT_NUMERATOR=1, PLOT_DENOMINATOR=2, PLOT_RATIO=5 };
int choice = 5;
bool min_max_with_errors = true;
bool use_meff = false;
double axis_offset = 2.;
bool simulation = false;
// Some analysis defaults
double offset = 0.;
//double pt1_default = 100.;
//double pt2_default = 100.;
//double pt3_default = 50.;
//double ht_default = 375. + offset;
//double meff_default = ht_default + pt3_default;
//double x1_default = pt1_default / meff_default;
//double x2_default = pt2_default / meff_default;
//double x3_default = pt3_default / meff_default ;
//double x3_factor = ( 1. - x3_default ) / ( x3_default );
std::string dir = "/vols/cms04/bainbrid/qcd/stable/SUSY2/results/";
//std::string histo = "HtAfterAlphaT";
//std::string histo = "HtAfterRecHit";
std::string histo = "HtAfterBaby";
std::vector<double> at;
at.push_back(0.51);
at.push_back(0.52);
at.push_back(0.53);
at.push_back(0.54);
at.push_back(0.55);
//at.push_back(0.60);
const uint nat = at.size();
std::vector<int> multi;
multi.push_back(-2);
const uint nmulti = multi.size();
double ht_min = 0.;
double ht_max = 0.;
int nht = 20; //@@ number of bins
std::vector<double> ht;
std::vector<double> ht_step;
// override histo binning
if ( true ) {
ht.push_back(275.);
ht.push_back(325.);
for ( uint iht = 0; iht <= 6; ++iht ) { ht.push_back(375.+iht*100.); }
//for ( uint iht = 0; iht <= 8; ++iht ) { ht.push_back(300.+iht*100.); }
nht = ht.size() - 1;
ht_min = ht.front() + offset;
ht_max = ht.back() + offset;
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
StringVV files;
bool test = true;
if ( test ) {
//std::string trunk = dir + "v02/Ratio__";
//StringV q; q.push_back(trunk+"data.root"); files.push_back(q);
//StringV q1; q1.push_back(dir + "v19/Ratio__data.root"); files.push_back(q1);
StringV q3; q3.push_back(dir + "v21/Ratio__data.root"); files.push_back(q3);
StringV q1; q1.push_back(dir + "v26/Ratio__data_1fb.root"); files.push_back(q1);
StringV q2; q2.push_back(dir + "v22/Ratio__data.root"); files.push_back(q2);
//StringV q; q.push_back("../python/Ratio_QCDPY.root");
//StringV w(q); w.push_back(trunk+"wjets.root");
//StringV z(q); z.push_back(trunk+"zinv.root");
//StringV tt(q); tt.push_back(trunk+"ttbar.root");
}
bool results = false;
if ( results ) {
std::string trunk = dir + "v08/Ratio__";
StringV q; q.push_back(trunk+"qcdmg.root");
StringV sm(q);
sm.push_back(trunk+"wjets.root");
sm.push_back(trunk+"zinv.root");
sm.push_back(trunk+"ttbar.root");
files.push_back(sm);
StringV sm1(q);
sm1.push_back(trunk+"wjets_incl.root");
sm1.push_back(trunk+"zinv.root");
sm1.push_back(trunk+"ttbar.root");
files.push_back(sm1);
//StringV lm6(sm); lm6.push_back(trunk+"lm6.root"); files.push_back(lm6);
StringV wi(q); wi.push_back(trunk+"wjets_incl.root"); files.push_back(wi);
StringV w(q); w.push_back(trunk+"wjets.root"); files.push_back(w);
StringV z(q); z.push_back(trunk+"zinv.root"); files.push_back(z);
StringV tt(q); tt.push_back(trunk+"ttbar.root"); files.push_back(tt);
//StringV t(q); t.push_back(trunk+"top.root"); files.push_back(t);
files.push_back(StringV(1,dir+"v08/Ratio__data.root"));
// std::string trunk = dir + "v36/Ratio__";
// StringV sm1;
// sm1.push_back(trunk+"qcdpy.root");
// //sm1.push_back(trunk+"wjets.root");
// sm1.push_back(trunk+"zinv.root");
// sm1.push_back(trunk+"ttbar.root");
// sm1.push_back(trunk+"top.root");
// trunk = dir + "v37/Ratio__";
// StringV sm2;
// sm2.push_back(trunk+"qcdpy.root");
// sm2.push_back(trunk+"wjets.root");
// sm2.push_back(trunk+"zinv.root");
// sm2.push_back(trunk+"ttbar.root");
// trunk = dir + "v40/Ratio__";
// StringV sm3;
// sm3.push_back(trunk+"qcdpy.root");
// sm3.push_back(trunk+"wjets.root");
// sm3.push_back(trunk+"zinv.root");
// sm3.push_back(trunk+"ttbar.root");
// files.push_back(sm1);
// files.push_back(sm2);
// files.push_back(sm3);
}
const uint nfile = files.size();
std::vector<std::string> his;
if ( his.size() < nfile ) { his.resize(nfile,histo); }
std::vector<std::string> type;
if ( test ) {
// type.push_back("1");
// type.push_back("2");
//type.push_back("Data");
type.push_back("HT-aT cross triggers");
type.push_back("HT-MHT cross triggers");
type.push_back("HT prescaled triggers");
//type.push_back("QcdMg");
//type.push_back("Nominal");
//type.push_back("Alternative");
}
if ( results ) {
//type.push_back("SM + LM6 (Spring11)");
//type.push_back("Spring11");
//type.push_back("Summer11(Wincl)");
//type.push_back("Summer11(W300)");
type.push_back("SM (W+jets HT-binned)");
type.push_back("SM (W+jets inclusive)");
// type.push_back("SM ");
type.push_back("Wjets (incl)");
type.push_back("Wjets (HT-binned)");
type.push_back("Zinv ");
type.push_back("TTbar");
//type.push_back("Single top ");
type.push_back("Data ");
}
if ( type.size() < nfile ) { type.resize(nfile,"unknown"); }
double lumi = 4650.;
std::vector<double> lumis;
if ( test ) {
lumi = 4650;
lumis.push_back(100.);
//lumis.push_back(100.*lumi/1140.);
lumis.push_back(100.);
//lumis.push_back(lumi);
}
if ( results ) {
double tmp = 4650.;//xx[ilumi];
lumi = tmp;
lumis.push_back(tmp);
lumis.push_back(tmp);
lumis.push_back(tmp);
lumis.push_back(tmp);
lumis.push_back(tmp);
lumis.push_back(tmp);
lumis.push_back(100.);
}
if ( lumis.size() < nfile ) { lumis.resize(nfile,100.); }
// Which file is the data file
int data_file = -1;
for ( uint itype = 0; itype < nfile; ++itype ) {
if ( type[itype] == "data" ||
type[itype] == "Data" ) {
data_file = itype;
break;
}
}
// if ( data_file == -1 ) {
// data_file = 0;
// std::cout << "Problem identifying data file!" << std::endl;
// }
std::vector<int> style;
if ( test ) {
style.push_back(20);
style.push_back(24);
style.push_back(25);
}
if ( results ) {
style.push_back(24);
style.push_back(25);
style.push_back(26);
style.push_back(28);
style.push_back(27);
style.push_back(30);
style.push_back(20);
}
if ( style.size() < nfile ) { style.resize(nfile,25); }
std::vector<double> size;
if ( size.size() < nfile ) { size.resize(nfile,1.5); }
std::vector<int> col;
if ( test ) {
col.push_back(1);
col.push_back(2);
col.push_back(4);
}
if ( results ) {
col.push_back(2);
col.push_back(4);
col.push_back(6);
col.push_back(6);
col.push_back(6);
col.push_back(6);
col.push_back(1);
}
if ( col.size() < nfile ) { col.resize(nfile,1); }
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
DoubleVVVV numer; resize( numer, nfile, nmulti, nat, nht );
DoubleVVVV numer_errh; resize( numer_errh, nfile, nmulti, nat, nht );
DoubleVVVV numer_errl; resize( numer_errl, nfile, nmulti, nat, nht );
DoubleVVVV denom; resize( denom, nfile, nmulti, nat, nht );
DoubleVVVV denom_errh; resize( denom_errh, nfile, nmulti, nat, nht );
DoubleVVVV denom_errl; resize( denom_errl, nfile, nmulti, nat, nht );
DoubleVVVV ratio; resize( ratio, nfile, nmulti, nat, nht );
DoubleVVVV errh; resize( errh, nfile, nmulti, nat, nht );
DoubleVVVV errl; resize( errl, nfile, nmulti, nat, nht );
IntVVV length; resize( length, nfile, nmulti, nat );
// Min/max values for ratios
DoubleVV min; min.resize( nmulti, DoubleV( nat, 0. ) );
DoubleVV max; max.resize( nmulti, DoubleV( nat, 0. ) );
std::cout << " nfile: " << nfile
<< " nmulti: " << nmulti
<< " nat: " << nat
<< " nht: " << nht
<< " total: " << nfile*nmulti*nat*nht
<< std::endl;
// Init arrays
for ( uint imulti = 0; imulti < nmulti; ++imulti ) {
for ( uint iat = 0; iat < nat; ++iat ) {
for ( uint ifile = 0; ifile < nfile; ++ifile ) {
for ( int iht = 0; iht < nht; ++iht ) {
numer[ifile][imulti][iat][iht] = 0.;
numer_errh[ifile][imulti][iat][iht] = 0.;
numer_errl[ifile][imulti][iat][iht] = 0.;
denom[ifile][imulti][iat][iht] = 0.;
denom_errh[ifile][imulti][iat][iht] = 0.;
denom_errl[ifile][imulti][iat][iht] = 0.;
ratio[ifile][imulti][iat][iht] = 0.;
errh[ifile][imulti][iat][iht] = 0.;
errl[ifile][imulti][iat][iht] = 0.;
}
length[ifile][imulti][iat] = 0;
}
min[imulti][iat] = 0.;
max[imulti][iat] = 0.;
}
}
std::cout << " CALCULATING RATIOS..." << std::endl;
calcRatio( nfile, nmulti, nat, nht,
his, files, lumis,
multi, at, ht, ht_min, ht_max,
numer, numer_errh, numer_errl,
denom, denom_errh, denom_errl,
ratio, errh, errl, length,
label,
efficiency, use_sumw2,
data_file );
ht_step.clear();
for ( int iht = 0; iht < nht; ++iht ) { ht_step.push_back( ht[iht+1] - ht[iht] ); }
// std::cout << " size " << ht.size()
// << " nbins " << nht
// << " htmin " << ht_min
// << " htmax " << ht_max
// << std::endl;
// for ( int iht = 0; iht <= nht; ++iht ) {
// std::cout << " ibin " << iht
// << " ht " << ht[iht]
// << " htstep " << (iht<nht?ht_step[iht]:0.)
// << std::endl;
// }
// // -----------------------------------------------------------------------------
// // -----------------------------------------------------------------------------
// // -----------------------------------------------------------------------------
// Print numbers
bool print = true;
if (print) {
for ( uint ifile = 0; ifile < nfile; ++ifile ) {
for ( uint imulti = 0; imulti < nmulti; ++imulti ) {
for ( uint iat = 0; iat < nat; ++iat ) {
for ( int iht = 0; iht < nht; ++iht ) {
double n = numer[ifile][imulti][iat][iht];
double neh = numer_errh[ifile][imulti][iat][iht];
double nel = numer_errl[ifile][imulti][iat][iht];
double d = denom[ifile][imulti][iat][iht];
double deh = denom_errh[ifile][imulti][iat][iht];
double del = denom_errl[ifile][imulti][iat][iht];
double r = ratio[ifile][imulti][iat][iht];
double eh = errh[ifile][imulti][iat][iht];
double el = errl[ifile][imulti][iat][iht];
std::cout
//<< " PRINT: "
<< "" << type[ifile] << ""
//<< " njets: " << multi[imulti]
<< " aT: " << at[iat]
<< std::fixed << std::setprecision(0)
<< " HT: " << ht[iht]
<< std::scientific << std::setprecision(3)
<< ", pass: "******" + " << neh
<< " - " << nel
// << ",pass," << n
// << "," << neh
// << "," << nel
//<< " (" << ( n > 0. ? sqrt(n)/n : -1. ) << ")"
<< ", fail: " << d
<< " + " << deh
<< " - " << del
// << ",fail," << d
// << "," << deh
// << "," << del
//<< " (" << ( d > 0. ? sqrt(d)/d : -1. ) << ")"
//<< " R: " << ( d > 0. ? n/d : -1. )
//<< " E: " << ( d > 0. ? sqrt(n*(n/(n+d))*(1-(n/(n+d)))) : -1. )
<< ", ratio: " << r
<< " + " << eh
<< " - " << el
// << ", ratio ," << r
// << "," << eh
// << "," << el
// << " (" << int(( r > 0. ? eh/r : -1. )*100.) << ","
// << int(( r > 0. ? el/r : -1. )*100.) << ")"
<< std::endl;
}
}
}
}
}
// -----------------------------------------------------------------------------
// For Ted
bool print_ted = true;
if (print_ted) {
for ( uint ifile = 0; ifile < nfile; ++ifile ) {
for ( uint imulti = 0; imulti < nmulti; ++imulti ) {
for ( uint iat = 0; iat < nat; ++iat ) {
std::stringstream ted;
ted << " sample: \"" << type[ifile] << "\""
<< " Multiplicity: " << multi[imulti]
<< " AlphaT: " << at[iat]
<< std::endl;
ted << "\"had\":\t\t" << float(lumi) << ", #lumi" << std::endl;
ted << "\"hadBulk\":\t" << float(lumi) << ", #lumi" << std::endl;
// Bulk
ted << "\"nHadBulk\":\t(";
for ( int iht = 0; iht < nht; ++iht ) {
double d = denom[ifile][imulti][iat][iht];
ted << std::setw(9) << std::scientific << std::setprecision(3) << d << ", ";
}
ted << ")" << std::endl;
// Tail
ted << "\"nHad\":\t\t(";
for ( int iht = 0; iht < nht; ++iht ) {
double n = numer[ifile][imulti][iat][iht];
ted << std::setw(9) << std::scientific << std::setprecision(3) << n << ", ";
}
ted << ")" << std::endl;
// Mean HT
ted << "self._htMeans = (";
for ( int iht = 0; iht < nht; ++iht ) {
ted << std::setw(9) << std::scientific << std::setprecision(3) << ht[iht] << ", ";
}
ted << ")" << std::endl;
std::cout << ted.str() << std::endl;
}
}
}
}
// -----------------------------------------------------------------------------
if (!plots) return 0;
// Variable to plot
std::cout << " EXTRACTING VALUES TO PLOT..." << std::endl;
double valx[nfile][nmulti][nat][nht];
double errxh[nfile][nmulti][nat][nht];
double errxl[nfile][nmulti][nat][nht];
double valy[nfile][nmulti][nat][nht];
double erryh[nfile][nmulti][nat][nht];
double erryl[nfile][nmulti][nat][nht];
for ( uint ifile = 0; ifile < nfile; ++ifile ) {
for ( uint imulti = 0; imulti < nmulti; ++imulti ) {
for ( uint iat = 0; iat < nat; ++iat ) {
for ( int iht = 0; iht < nht; ++iht ) {
valx[ifile][imulti][iat][iht] = 0.;
errxh[ifile][imulti][iat][iht] = 0.;
errxl[ifile][imulti][iat][iht] = 0.;
valy[ifile][imulti][iat][iht] = 0.;
erryh[ifile][imulti][iat][iht] = 0.;
erryl[ifile][imulti][iat][iht] = 0.;
double width = (1.*ht_step[nht-1]) / (1.*ht_step[iht]);
//std::cout << " iht " << iht << " width " << width << std::endl;
if ( choice == PLOT_NUMERATOR ) {
valx[ifile][imulti][iat][iht] = ht[iht] + ht_step[iht]/2. + axis_offset*ifile;
errxh[ifile][imulti][iat][iht] = ht_step[iht]/2. + axis_offset*ifile;
errxl[ifile][imulti][iat][iht] = ht_step[iht]/2. - axis_offset*ifile;
valy[ifile][imulti][iat][iht] = numer[ifile][imulti][iat][iht] * width;
erryh[ifile][imulti][iat][iht] = numer_errh[ifile][imulti][iat][iht] * width;
erryl[ifile][imulti][iat][iht] = numer_errl[ifile][imulti][iat][iht] * width;
} else if ( choice == PLOT_DENOMINATOR ) {
valx[ifile][imulti][iat][iht] = ht[iht] + ht_step[iht]/2. + axis_offset*ifile;
errxh[ifile][imulti][iat][iht] = ht_step[iht]/2. + axis_offset*ifile;
errxl[ifile][imulti][iat][iht] = ht_step[iht]/2. - axis_offset*ifile;
valy[ifile][imulti][iat][iht] = denom[ifile][imulti][iat][iht] * width;
erryh[ifile][imulti][iat][iht] = denom_errh[ifile][imulti][iat][iht] * width;
erryl[ifile][imulti][iat][iht] = denom_errl[ifile][imulti][iat][iht] * width;
} else if ( choice == PLOT_RATIO ) {
//if ( iht < length[ifile][imulti][iat] ) {
valx[ifile][imulti][iat][iht] = ht[iht] + ht_step[iht]/2. + axis_offset*ifile;
errxh[ifile][imulti][iat][iht] = ht_step[iht]/2. + axis_offset*ifile;
errxl[ifile][imulti][iat][iht] = ht_step[iht]/2. - axis_offset*ifile;
valy[ifile][imulti][iat][iht] = ratio[ifile][imulti][iat][iht];
erryh[ifile][imulti][iat][iht] = errh[ifile][imulti][iat][iht];
erryl[ifile][imulti][iat][iht] = errl[ifile][imulti][iat][iht];
//}
}
}
}
}
}
if ( choice == PLOT_NUMERATOR ) {
std::cout << "Plotting numerator..." << std::endl;
} else if ( choice == PLOT_DENOMINATOR ) {
std::cout << "Plotting denominator..." << std::endl;
} else if ( choice == PLOT_RATIO ) {
std::cout << "Plotting ratio..." << std::endl;
} else {
std::cout << "Plotting unknown!!..." << std::endl;
}
// -----------------------------------------------------------------------------
// Calculate min and max values for y-axis (ratio)
for ( uint imulti = 0; imulti < nmulti; ++imulti ) {
for ( uint iat = 0; iat < nat; ++iat ) {
min[imulti][iat] = 1.e12;
max[imulti][iat] = 1.e-12;
for ( uint ifile = 0; ifile < nfile; ++ifile ) {
for ( int iht = 0; iht < nht; ++iht ) {
if ( ht[iht] < ht_min && ht[iht] > ht_max ) { continue; }
double ymin = valy[ifile][imulti][iat][iht] - erryl[ifile][imulti][iat][iht];
double ymax = valy[ifile][imulti][iat][iht] + erryh[ifile][imulti][iat][iht];
if ( valy[ifile][imulti][iat][iht] > 0. &&
valy[ifile][imulti][iat][iht] < min[imulti][iat] ) {
if ( min_max_with_errors && ymin > 0. && ymin < min[imulti][iat] ) { min[imulti][iat] = ymin; }
else { min[imulti][iat] = valy[ifile][imulti][iat][iht]; }
}
if ( valy[ifile][imulti][iat][iht] > 0. &&
valy[ifile][imulti][iat][iht] > max[imulti][iat] ) {
if ( min_max_with_errors && ymax > 0. && ymax > max[imulti][iat] ) { max[imulti][iat] = ymax; }
else { max[imulti][iat] = valy[ifile][imulti][iat][iht]; }
}
}
}
}
}
if (false) {
for ( uint ifile = 0; ifile < nfile; ++ifile ) {
for ( uint imulti = 0; imulti < nmulti; ++imulti ) {
for ( uint iat = 0; iat < nat; ++iat ) {
std::cout << " sample:\"" << type[ifile] << "\""
<< " multi: " << multi[imulti]
<< " aT:" << at[iat]
<< " min:" << min[imulti][iat]
<< " max:" << max[imulti][iat]
<< std::endl;
}
}
}
}
if (false) {
for ( uint ifile = 0; ifile < nfile; ++ifile ) {
for ( uint imulti = 0; imulti < nmulti; ++imulti ) {
for ( uint iat = 0; iat < nat; ++iat ) {
std::cout << " PLOTTING:"
<< " sample:\"" << type[ifile] << "\""
<< " multi: " << multi[imulti]
<< " aT:" << at[iat]
<< " valy: " << valy[ifile][imulti][iat]
<< " erryh: " << erryh[ifile][imulti][iat]
<< " erryl: " << erryl[ifile][imulti][iat]
<< std::endl;
}
}
}
}
// -----------------------------------------------------------------------------
// Check number of pt and ht bins are the same
std::cout << " CREATING PLOTS..." << std::endl;
std::vector<double> rat;
std::vector<float> fits;
for ( uint imulti = 0; imulti < nmulti; ++imulti ) {
for ( uint iat = 0; iat < nat; ++iat ) {
std::string name;
if ( choice == PLOT_NUMERATOR ) { name = "Pass"; }
else if ( choice == PLOT_DENOMINATOR ) {
if ( efficiency ) { name = "Total"; }
else { name = "Fail"; }
}
else if ( choice == PLOT_RATIO ) {
if ( efficiency ) { name = "Eff"; }
else { name = "Ratio"; }
}
else { name = "Unknown"; }
std::stringstream ss_canvas;
ss_canvas << "Multi";
if ( multi[imulti] >= 0 ) { ss_canvas << multi[imulti]; }
else { ss_canvas << abs(multi[imulti]) << "Incl"; }
ss_canvas << "_AlphaT" << at[iat];
gStyle->SetOptFit(111);
TCanvas* canvas = 0;
TLegend* legend = 0;
TLatex* prelim = 0;
TLatex* lumitxt = 0;
TMultiGraph* mg = 0;
canvas = new TCanvas(TString(name+"_"+ss_canvas.str()),
TString(name+"_"+ss_canvas.str()),800,600);
canvas->SetFillColor(0);
canvas->SetLineColor(0);
canvas->SetLeftMargin(0.17);
legend = new TLegend( 0.65, 0.7-(nfile*0.04), 0.85, 0.7, NULL, "brNDC" );
legend->SetTextSize(0.035);
legend->SetFillColor(0);
legend->SetLineColor(0);
legend->SetShadowColor(0);
if (!simulation) {
prelim = new TLatex( 0.20, 0.88, "#scale[0.8]{CMS preliminary 2011}" );
} else {
prelim = new TLatex( 0.20, 0.88, "#scale[0.8]{CMS simulation 2011}" );
}
prelim->SetTextSize(0.035);
prelim->SetNDC();
std::stringstream ssl;
ssl << "#scale[0.8]{#int L dt = " << std::setprecision(3) << lumi/1000. << " fb^{-1}, #sqrt{s} = 7 TeV}";
lumitxt = new TLatex( 0.68, 0.88, ssl.str().c_str() );
lumitxt->SetTextSize(0.035);
lumitxt->SetNDC();
mg = new TMultiGraph();
std::stringstream ss_axis;
if ( choice == PLOT_NUMERATOR ) {
ss_axis << "N(#alpha_{T}>" << at[iat] << ") / " << ht_step[nht-1] << " GeV";
} else if ( choice == PLOT_DENOMINATOR ) {
if ( efficiency ) { ss_axis << "Total"; }
else { ss_axis << "N(#alpha_{T}<" << at[iat] << ") / " << ht_step[nht-1] << " GeV"; }
} else if ( choice == PLOT_RATIO ) {
if ( !efficiency ) {
//ss_axis << "R_{#alpha_{T}}(" << at[iat] << ")";
if ( iat+1 < nat ) {
ss_axis << "N(" << at[iat] << "<#alpha_{T}<" << at[iat+1] << ") / N(#alpha_{T}<" << at[iat] << ")";
} else {
ss_axis << "N(#alpha_{T}>" << at[iat] << ") / N(#alpha_{T}<" << at[iat] << ")";
}
}
else { ss_axis << "#varepsilon(#alpha_{T}=" << at[iat] << ")"; }
}
else { ss_axis << "a.u."; }
std::stringstream ss_flat;
std::stringstream ss_line;
std::stringstream ss_expo;
for ( uint ifile = 0; ifile < nfile; ++ifile ) {
std::stringstream ss_histo;
ss_histo << name << "_" << type[ifile] << "_" << ss_canvas.str();
gStyle->SetOptFit(0);
TGraphAsymmErrors* gr = new TGraphAsymmErrors(nht,
valx[ifile][imulti][iat],
valy[ifile][imulti][iat],
errxh[ifile][imulti][iat],
errxl[ifile][imulti][iat],
erryl[ifile][imulti][iat],
erryh[ifile][imulti][iat]);
// Fitting
if (true) {
TGraphAsymmErrors* tmp_gr = new TGraphAsymmErrors(*gr);
//tmp_gr->Fit("pol0","Q0","",valx[ifile][imulti][iat][0]-1.e-6,valx[ifile][imulti][iat][last_bin]+1.e-6);
tmp_gr->Fit("pol0","Q0","",ht_min-1.e-6,ht_max+1.e-6);
TF1* fit_c = (TF1*)tmp_gr->FindObject("pol0");
if ( fit_c ) {
if ( ifile == 0 ) { ss_flat << "Constant (y=A):" << std::endl; }
ss_flat << "" << type[ifile] << " "
<< std::setprecision(3)
<< fit_c->GetChisquare() << "/"
<< std::setprecision(0)
<< fit_c->GetNDF() << " ("
<< std::setprecision(3)
<< fit_c->GetProb() << ") "
<< std::endl
<< "" << type[ifile] << " "
<< std::scientific << std::setprecision(3)
<< "A: " << fit_c->GetParameter(0) << " +/- " << fit_c->GetParError(0)
<< std::endl;
//yy.push_back( fit_c->GetProb() ); //@@ ADDED
if ( (int)ifile == data_file ) { fits.push_back( fit_c->GetProb() ); }
//rat.push_back( fit_c->GetParameter(0) );
} else {
//yy.push_back( 0. ); //@@ ADDED
std::cout << " NULL PTR! " << std::endl;
}
//tmp_gr->Fit("pol1","Q0","",valx[ifile][imulti][iat][0]-1.e-6,valx[ifile][imulti][iat][last_bin]+1.e-6);
tmp_gr->Fit("pol1","Q0","",ht_min-1.e-6,ht_max+1.e-6);
TF1* fit_l = (TF1*)tmp_gr->FindObject("pol1");
if ( fit_l ) {
if ( ifile == 0 ) { ss_line << "Linear (y=A+Bx):" << std::endl; }
ss_line << "" << type[ifile] << " "
<< std::setprecision(3)
<< fit_l->GetChisquare() << "/"
<< std::setprecision(0)
<< fit_l->GetNDF() << " ("
<< std::setprecision(3)
<< fit_l->GetProb() << ") "
<< std::endl
<< "" << type[ifile] << " "
<< std::scientific << std::setprecision(3)
<< "A: " << fit_l->GetParameter(0) << " +/- " << fit_l->GetParError(0)
<< " B: " << fit_l->GetParameter(1) << " +/- " << fit_l->GetParError(1)
<< std::endl;
if ( (int)ifile == data_file ) { fits.push_back( fit_l->GetProb() ); }
//rat.push_back( fit_l->GetParameter(0) );
} else {
std::cout << " NULL PTR! " << std::endl;
}
//tmp_gr->Fit("expo","Q0","",valx[ifile][imulti][iat][0]-1.e-6,valx[ifile][imulti][iat][last_bin]+1.e-6);
//TF1* fit_e = new TF1("expo+expo", tmp_gr->FindObject("expo");
//tmp_gr->Fit("expo","Q0","",ht_min-1.e-6,ht_max+1.e-6);
tmp_gr->Fit("expo","Q0","",325.-1.e-6,675.+1.e-6);
TF1* fit_e = (TF1*)tmp_gr->FindObject("expo");
if ( fit_e ) {
if ( ifile == 0 ) { ss_expo << "Exponential (y=e^{A+kx}):" << std::endl; }
ss_expo << "" << type[ifile] << " "
<< std::fixed
<< std::setprecision(3)
<< fit_e->GetChisquare() << "/"
<< std::setprecision(0)
<< fit_e->GetNDF() << " ("
<< std::setprecision(3)
<< fit_e->GetProb() << ") "
<< std::endl
<< "" << type[ifile] << " "
<< std::scientific << std::setprecision(3)
<< "A: " << fit_e->GetParameter(0) << " +/- " << fit_e->GetParError(0)
<< " k: " << fit_e->GetParameter(1) << " +/- " << fit_e->GetParError(1)
<< std::endl;
if ( (int)ifile == data_file ) { fits.push_back( fit_e->GetProb() ); }
rat.push_back( fit_e->GetParameter(1) );
} else {
std::cout << " NULL PTR! " << std::endl;
}
//if (tmp_gr) delete tmp_gr;
}
for ( int ii = 0; ii < nht; ++ii ) {
double x = 0.;
double y = 0.;
gr->GetPoint(ii,x,y);
//if ( y == 0. ) { gr->SetPointEYhigh(ii,0.); gr->SetPointEYlow(ii,0.); }
if (false) {
std::cout << " sample:\"" << type[ifile] << "\""
<< " multi: " << multi[imulti]
<< " aT:" << at[iat]
<< " HT:" << ht[ii]
<< " ARRAY x: " << valx[ifile][imulti][iat][ii]
<< " y: " << valy[ifile][imulti][iat][ii]
<< " + " << erryh[ifile][imulti][iat][ii]
<< " - " << erryl[ifile][imulti][iat][ii]
<< " HISTO x: " << x
<< " y: " << y
<< " + " << gr->GetErrorYhigh(ii)
<< " - " << gr->GetErrorYlow(ii)
<< std::endl;
}
}
if ( nfile - ifile == 1 ) {
//std::cout << ss_flat.str() << std::endl;
//std::cout << ss_line.str() << std::endl;
std::cout << ss_expo.str() << std::endl;
}
mg->Add(gr,"p");
std::stringstream ss_legend;
ss_legend << type[ifile];
legend->AddEntry( gr, TString(ss_legend.str()), "p" );
gr->SetTitle(TString(ss_legend.str()));
gr->SetMarkerStyle(style[ifile]);
gr->SetMarkerSize(size[ifile]);
gr->SetMarkerColor(col[ifile]);
gr->SetLineColor(col[ifile]);
} // ifile
mg->Draw("a");
mg->GetXaxis()->SetTitle(label.c_str());
if (!use_meff) mg->GetXaxis()->SetTitle("H_{T} (GeV)");
else mg->GetXaxis()->SetTitle("M_{eff} (GeV)");
mg->GetYaxis()->SetTitle(TString(ss_axis.str()));
mg->GetYaxis()->SetTitleOffset(1.3);
mg->GetXaxis()->SetRangeUser(ht_min+offset,ht_max+offset);
mg->GetYaxis()->SetRangeUser(min[imulti][iat]/2.0,max[imulti][iat]*1.2);
//else mg->GetYaxis()->SetRangeUser(0.,0.12e-3);
//mg->GetYaxis()->SetNoExponent(true);
//mg->GetXaxis()->SetRangeUser(250,450.);
//mg->GetYaxis()->SetRangeUser(0.,25.e-6);
//mg->GetYaxis()->SetRangeUser(0.,0.05e-3);
//mg->GetYaxis()->SetRangeUser(0.,0.04e-3);
canvas->SetLogy();
//if (choice==1) mg->GetYaxis()->SetRangeUser(0.1,1.e4);
//else if (choice==2) mg->GetYaxis()->SetRangeUser(0.1,1.e8);
legend->Draw("same");
//prelim->Draw("same");
//lumitxt->Draw("same");
canvas->Update();
std::stringstream ss_text;
ss_text << "#alpha_{T} = " << at[iat];
TLatex* text = new TLatex(0.5,0.92,TString(ss_text.str()));
text->SetNDC(kTRUE);
text->SetTextSize(0.04);
//text->Draw();
//canvas->SaveAs(TString(name+"_"+ss_canvas.str()+".C"));
//canvas->SaveAs(TString(name+"_"+ss_canvas.str()+".png"));
//canvas->SaveAs(TString(name+"_"+ss_canvas.str()+".pdf"));
//if (canvas) delete canvas;
} // iat
} // imulti
int index = 0;
std::vector<float> cuts;
std::vector<float>::const_iterator ifit = fits.begin();
std::vector<float>::const_iterator jfit = fits.end();
for ( ; ifit != jfit; ++ifit ) { cuts.push_back(at[index]); index++; }
//if ( !fits.empty() ) qcd(cuts,fits);
// Draw RaT
if ( false && !rat.empty() ) {
bool plot_ratio = false;
setTDRStyle();
gStyle->SetOptStat("emr");
TCanvas* c2 = new TCanvas("RaTvsEwkComposition","RaTvsEwkComposition");
c2->SetFillColor(0);
c2->SetLineColor(0);
TH1D* diff = 0;
if ( !plot_ratio ) {
diff = new TH1D("RaTvsEwkComposition","",1000,0.,1e-3);
//diff = new TH1D("RaTvsEwkComposition","",1000,-20.,0.);
for ( uint ifile = 0; ifile < nfile; ++ifile ) {
std::cout << "sample: " << type[ifile] << " fit: " << rat[ifile] << std::endl;
diff->Fill( rat[ifile], 1. );
}
} else {
diff = new TH1D("RaTvsEwkComposition","",200,0.6,1.4);
for ( uint ifile = 1; ifile < nfile; ++ifile ) {
std::cout << "sample: " << type[ifile] << " nominal: " << rat[0] << " ratio: " << rat[ifile]/rat[0] << std::endl;
diff->Fill( rat[ifile]/rat[0], 1. );
}
}
c2->cd();
c2->SetRightMargin(0.12);
c2->SetBottomMargin(0.15);
diff->Draw("h");
if (!plot_ratio) diff->GetXaxis()->SetTitle("Best fit value");
else {
//diff->GetXaxis()->SetTitle("Best fit value relative to nominal");
diff->GetXaxis()->SetTitle("R_{#alpha_{T}}^{(#pm15%)} / R_{#alpha_{T}}^{(nominal)}");
diff->GetXaxis()->SetTitleOffset(1.1);
}
diff->GetYaxis()->SetTitle("Number of tests with #pm15%");
if (!plot_ratio) c2->SaveAs("RaTvsEwkComposition.pdf");
else c2->SaveAs("RaTvsEwkComposition_ratio.pdf");
}
// }
// yy.resize(xx.size(),0.);
// TCanvas* c1 = new TCanvas();
// TGraph* gr = new TGraph(nn, &(xx.front()), &(yy.front()) );
// c1->cd();
// gr->Draw("ap");
// //gr->SetBorderSize(0);
// gr->SetTitle("Fit range: 325 < HT < 985");
// gr->GetXaxis()->SetTitle("Integrated Lumi (pb^{-1})");
// gr->GetYaxis()->SetTitle("p-value");
// c1->SaveAs("tmp.C");
// delete c1;
// std::cout << std::endl;
// for ( uint i = 0; i < nn; ++i ) { std::cout << xx[i] << std::endl; }
// std::cout << std::endl;
// for ( uint i = 0; i < nn; ++i ) { std::cout << yy[i] << std::endl; }
// std::cout << std::endl;
return 0;
}
int QA_calm_plots_diff(const char* filename1, const char* filename2, const char* type = "PipPip", const char* type2 = "PipPip", bool ifSave = false)
{
TFile* f1 = new TFile(filename1,"READ");
TH2F* hevmultPID = ((TH2F*) f1->Get(Form("hevmultPID%s",type)));
TH1D* heta = ((TH1D*) f1->Get(Form("heta%s",type)));
TH1D* hpt = ((TH1D*) f1->Get(Form("hpt%s",type)));
TH1D* hphiS = ((TH1D*) f1->Get(Form("hphiS%s",type)));
TH1D* hphiP = ((TH1D*) f1->Get(Form("hphiP%s",type)));
TH1D* hpid1 = ((TH1D*) f1->Get(Form("hpid1%s",type)));
TH1D* hpid2 = ((TH1D*) f1->Get(Form("hpid2%s",type)));
TH1D* hevmultAll = ((TH1D*) f1->Get(Form("hevmultAll%s",type)));
TH1D* hevmult = ((TH1D*) f1->Get(Form("hevmult%s",type)));
TH1D* hevweight = ((TH1D*) f1->Get(Form("hevweight%s",type)));
TH1D* hevweighttaken = ((TH1D*) f1->Get(Form("hevweighttaken%s",type)));
TH1D* hevweightdensity= ((TH1D*) f1->Get(Form("hevweightdensity%s",type)));
TH1D* hptTotal = ((TH1D*) f1->Get(Form("hptTotal%s",type)));
TFile* f2 = new TFile(filename2,"READ");
TH2F* hevmultPID2 = ((TH2F*) f2->Get(Form("hevmultPID%s",type2)));
TH1D* heta2 = ((TH1D*) f2->Get(Form("heta%s",type2)));
TH1D* hpt2 = ((TH1D*) f2->Get(Form("hpt%s",type2)));
TH1D* hphiS2 = ((TH1D*) f2->Get(Form("hphiS%s",type2)));
TH1D* hphiP2 = ((TH1D*) f2->Get(Form("hphiP%s",type2)));
TH1D* hpid12 = ((TH1D*) f2->Get(Form("hpid1%s",type2)));
TH1D* hpid22 = ((TH1D*) f2->Get(Form("hpid2%s",type2)));
TH1D* hevmultAll2 = ((TH1D*) f2->Get(Form("hevmultAll%s",type2)));
TH1D* hevmult2 = ((TH1D*) f2->Get(Form("hevmult%s",type2)));
TH1D* hevweight2 = ((TH1D*) f2->Get(Form("hevweight%s",type2)));
TH1D* hevweighttaken2 = ((TH1D*) f2->Get(Form("hevweighttaken%s",type2)));
TH1D* hevweightdensity2= ((TH1D*) f2->Get(Form("hevweightdensity%s",type2)));
TH1D* hptTotal2 = ((TH1D*) f2->Get(Form("hptTotal%s",type)));
int rebin = 2;
double eta = 1.1;
gStyle->SetOptStat(000);//111);
const char* first = "";//Cons. laws only";
const char* second = "";//Minijets";
if(rebin>0)
{
heta->Rebin(rebin);
hpt->Rebin(rebin);
hphiS->Rebin(rebin);
hphiP->Rebin(rebin);
heta2->Rebin(rebin);
hpt2->Rebin(rebin);
hphiS2->Rebin(rebin);
hphiP2->Rebin(rebin);
}
heta2->SetLineColor(kGreen+2);
hpt2->SetLineColor(kGreen+2);
hphiS2->SetLineColor(kGreen+1);
hphiP2->SetLineColor(kGreen+2);
hpid12->SetLineColor(kGreen+2);
hpid22->SetLineColor(kGreen+2);
hevmultAll2->SetLineColor(kGreen+2);
hevmult2->SetLineColor(kGreen+2);
heta->Scale(1./heta->Integral());
heta2->Scale(1./heta2->Integral());
hpt->Scale(1./hpt->Integral());
hpt2->Scale(1./hpt2->Integral());
hevmult->Scale(1./hevmult->Integral());
hevmult2->Scale(1./hevmult2->Integral());
hevmultAll->Scale(1./hevmultAll->Integral());
hevmultAll2->Scale(1./hevmultAll2->Integral());
hpid1->Scale(1./hpid1->Integral());
hpid2->Scale(1./hpid2->Integral());
hpid12->Scale(1./hpid12->Integral());
hpid22->Scale(1./hpid22->Integral());
hphiP->Scale(1./hphiP->Integral());
hphiS->Scale(1./hphiS->Integral());
hphiP2->Scale(1./hphiP2->Integral());
hphiS2->Scale(1./hphiS2->Integral());
hptTotal->Scale(1./hptTotal->Integral());
hptTotal2->Scale(1./hptTotal2->Integral());
TCanvas* canv = new TCanvas("canv", "GENBOD results", 10,10,3*550,2*400);
canv->Divide(3,3);
canv->cd(1);
heta->Draw();
heta2->Draw("same");
canv->cd(2);
hpt->GetXaxis()->SetRangeUser(0,5);
hpt->Draw();
hpt2->Draw("same");
hptTotal->SetLineColor(kMagenta);
hptTotal->Draw("same");
canv->cd(3);
hphiS->Draw();
hphiP->SetLineColor(kRed);
hphiP->Draw("same");
hphiP2->Draw("same");
hphiS2->Draw("same");
canv->cd(4);
hpid1->Draw();
hpid12->Draw("same");
canv->cd(5);
hpid2->Draw();
hpid22->Draw("same");
canv->cd(6);
hevmultAll->GetXaxis()->SetRangeUser(5,41);
hevmultAll->Draw();
hevmultAll2->Draw("same");
canv->cd(7);
hevmult->GetXaxis()->SetRangeUser(0,41);
hevmult->Draw();
hevmult2->Draw("same");
canv->cd(8);
hevweight->Draw();
hevweight->Draw("same");
canv->cd(9);
//hevweightdensity->SetLineColor(kRed);
//hevweightdensity->Draw();
//hevweightdensity2->Draw("same");
hptTotal->Draw();
hptTotal2->SetLineColor(kGreen+2);
hptTotal2->Draw("same");
TF1* Ptot = new TF1("Ptot","4.33538e-02*TMath::Landau(x,3.24886e+00,2.17010e+00)*exp(8.34570e-03*x)",0,30);
Ptot->Draw("same");
TCanvas* canv2 = new TCanvas("canv2", "GENBOD results", 10,10,550,400);
//canv->Divide(3,3);
canv2->cd();
hevmultPID->Draw("colz");
double counter[11];
double counttrue[] = {1.493,1.493, 1.493,0.183, 0.183,0.083,0.083, 0.048, 0.048,0.183,0.183};
for(int i=1;i<12;i++)
counter[i-1] = ((TH1F*)hevmultPID->ProjectionY("_py",i,i))->GetMean();
for(int i=1;i<12;i++)
{
TLatex *part = new TLatex(0.072*i+0.05,0.7,Form("%.2f",counter[i-1]));
part->SetNDC();
//part->SetTextColor(kRed+2);
part->SetTextFont(42);
part->SetTextSize(0.04);
part->SetLineWidth(2);
part->Draw();
TLatex *part1 = new TLatex(0.072*i+0.05,0.6,Form("%.1f%%",counter[i-1]/counter[0]*100.));
cout<<Form("%.1f%%",counter[i-1]/counter[0]*100.)<<endl;
part1->SetNDC();
part1->SetTextColor(kRed+2);
part1->SetTextFont(42);
part1->SetTextSize(0.03);
part1->SetLineWidth(2);
part1->Draw();
TLatex *part2 = new TLatex(0.072*i+0.05,0.5,Form("%.1f%%",counttrue[i-1]/counttrue[0]*100.));
cout<<Form("%.1f%%",counttrue[i-1]/counttrue[0]*100.)<<endl;
part2->SetNDC();
part2->SetTextColor(kBlue+2);
part2->SetTextFont(42);
part2->SetTextSize(0.03);
part2->SetLineWidth(2);
part2->Draw();
}
}
void limit() {
//This program demonstrates the computation of 95 % C.L. limits.
//It uses a set of randomly created histograms.
//
//Author: [email protected] on 21.08.02
// Create a new canvas.
TCanvas *c1 = new TCanvas("c1","Dynamic Filling Example",200,10,700,500);
c1->SetFillColor(42);
// Create some histograms
TH1D* background = new TH1D("background","The expected background",30,-4,4);
TH1D* signal = new TH1D("signal","the expected signal",30,-4,4);
TH1D* data = new TH1D("data","some fake data points",30,-4,4);
background->SetFillColor(48);
signal->SetFillColor(41);
data->SetMarkerStyle(21);
data->SetMarkerColor(kBlue);
background->Sumw2(); // needed for stat uncertainty
signal->Sumw2(); // needed for stat uncertainty
// Fill histograms randomly
TRandom2 r;
Float_t bg,sig,dt;
for (Int_t i = 0; i < 25000; i++) {
bg = r.Gaus(0,1);
sig = r.Gaus(1,.2);
background->Fill(bg,0.02);
signal->Fill(sig,0.001);
}
for (Int_t i = 0; i < 500; i++) {
dt = r.Gaus(0,1);
data->Fill(dt);
}
THStack *hs = new THStack("hs","Signal and background compared to data...");
hs->Add(background);
hs->Add(signal);
hs->Draw("hist");
data->Draw("PE1,Same");
c1->Modified();
c1->Update();
c1->GetFrame()->SetFillColor(21);
c1->GetFrame()->SetBorderSize(6);
c1->GetFrame()->SetBorderMode(-1);
c1->Modified();
c1->Update();
gSystem->ProcessEvents();
// Compute the limits
cout << "Computing limits... " << endl;
TLimitDataSource* mydatasource = new TLimitDataSource(signal,background,data);
TConfidenceLevel *myconfidence = TLimit::ComputeLimit(mydatasource,50000);
cout << "CLs : " << myconfidence->CLs() << endl;
cout << "CLsb : " << myconfidence->CLsb() << endl;
cout << "CLb : " << myconfidence->CLb() << endl;
cout << "< CLs > : " << myconfidence->GetExpectedCLs_b() << endl;
cout << "< CLsb > : " << myconfidence->GetExpectedCLsb_b() << endl;
cout << "< CLb > : " << myconfidence->GetExpectedCLb_b() << endl;
// Add stat uncertainty
cout << endl << "Computing limits with stat systematics... " << endl;
TConfidenceLevel *mystatconfidence = TLimit::ComputeLimit(mydatasource,50000,true);
cout << "CLs : " << mystatconfidence->CLs() << endl;
cout << "CLsb : " << mystatconfidence->CLsb() << endl;
cout << "CLb : " << mystatconfidence->CLb() << endl;
cout << "< CLs > : " << mystatconfidence->GetExpectedCLs_b() << endl;
cout << "< CLsb > : " << mystatconfidence->GetExpectedCLsb_b() << endl;
cout << "< CLb > : " << mystatconfidence->GetExpectedCLb_b() << endl;
// Add some systematics
cout << endl << "Computing limits with systematics... " << endl;
TVectorD errorb(2);
TVectorD errors(2);
TObjArray* names = new TObjArray();
TObjString name1("bg uncertainty");
TObjString name2("sig uncertainty");
names->AddLast(&name1);
names->AddLast(&name2);
errorb[0]=0.05; // error source 1: 5%
errorb[1]=0; // error source 2: 0%
errors[0]=0; // error source 1: 0%
errors[1]=0.01; // error source 2: 1%
TLimitDataSource* mynewdatasource = new TLimitDataSource();
mynewdatasource->AddChannel(signal,background,data,&errors,&errorb,names);
TConfidenceLevel *mynewconfidence = TLimit::ComputeLimit(mynewdatasource,50000,true);
cout << "CLs : " << mynewconfidence->CLs() << endl;
cout << "CLsb : " << mynewconfidence->CLsb() << endl;
cout << "CLb : " << mynewconfidence->CLb() << endl;
cout << "< CLs > : " << mynewconfidence->GetExpectedCLs_b() << endl;
cout << "< CLsb > : " << mynewconfidence->GetExpectedCLsb_b() << endl;
cout << "< CLb > : " << mynewconfidence->GetExpectedCLb_b() << endl;
// show canonical -2lnQ plots in a new canvas
// - The histogram of -2lnQ for background hypothesis (full)
// - The histogram of -2lnQ for signal and background hypothesis (dashed)
TCanvas *c2 = new TCanvas("c2");
myconfidence->Draw();
// clean up (except histograms and canvas)
delete myconfidence;
delete mydatasource;
delete mystatconfidence;
delete mynewconfidence;
delete mynewdatasource;
}
void metStudy( TString sampleName, TString CutName){
TString OutDir = "CtrPlots_metStudy";
gSystem->mkdir(OutDir);
TString ChannelName[4];
ChannelName[0] = "of0j";
ChannelName[1] = "of1j";
ChannelName[2] = "of2j";
ChannelName[3] = "Incl";
TString LgdTitle[4];
LgdTitle[0] = "njet = 0, e#mu";
LgdTitle[1] = "njet = 1, e#mu";
LgdTitle[2] = "njet #geq 2, e#mu";
LgdTitle[3] = "Incl.jet, e#mu";
TString fileName = sampleName+"/"+sampleName+"_"+CutName+".root";
cout<<"File used: "<<fileName<<endl;
TFile *fname = new TFile(fileName);
char tmpName[30];
char histName[30];
char histNameOrg[30];
TH1D *h1_genMet[4];
TH1D *h1_pupMet[4];
TH1D *h1_pfMet[4];
TH1D *h1_trkMet[4];
TH2D* h2_pfGenResol[4];
TH2D* h2_pupGenResol[4];
TH2D* h2_trkGenResol[4];
TProfile* pr_pfGenResol[4];
TProfile* pr_pupGenResol[4];
TProfile* pr_trkGenResol[4];
//=====================================
//Looping for each Channel
//=====================================
for (int i(0);i<4;i++) {
TCanvas *myCan = new TCanvas("myCan","Can",800,800);
sprintf(histNameOrg,"h1_genMet_%d",i);
h1_genMet[i]= (TH1D*)fname->Get(histNameOrg)->Clone(histNameOrg); h1_genMet[i]->Sumw2();
sprintf(histNameOrg,"h1_pfMet_%d",i);
h1_pfMet[i]= (TH1D*)fname->Get(histNameOrg)->Clone(histNameOrg); h1_pfMet[i]->Sumw2();
sprintf(histNameOrg,"h1_pupMet_%d",i);
h1_pupMet[i]= (TH1D*)fname->Get(histNameOrg)->Clone(histNameOrg); h1_pupMet[i]->Sumw2();
sprintf(histNameOrg,"h1_trkMet_%d",i);
h1_trkMet[i]= (TH1D*)fname->Get(histNameOrg)->Clone(histNameOrg); h1_trkMet[i]->Sumw2();
char fileName[30];
char Ytitle[30];
sprintf(fileName,sampleName+"_Met_%djet",i);
sprintf(Ytitle,"Events / %.1f",h1_genMet[i]->GetBinWidth(1));
CPlot* Plot_MET = new CPlot(fileName,sampleName,"MET[GeV]",Ytitle);
Plot_MET->setOutDir(OutDir);
Plot_MET->AddHist1D(h1_genMet[i],"HIST",kBlack);
Plot_MET->AddHist1D(h1_pfMet[i],"HIST",kRed);
Plot_MET->AddHist1D(h1_pupMet[i],"HIST",kBlue);
Plot_MET->AddHist1D(h1_trkMet[i],"HIST",kGreen);
//Plot_MET->AddTextBox(LgdTitle[i],0.7,0.92,0.9,0.97,0,kBlack,-1);
Plot_MET->SetLegend(0.65,0.7,0.92,0.85);
Plot_MET->GetLegend()->AddEntry(h1_genMet[i],"gen","l");
Plot_MET->GetLegend()->AddEntry(h1_pfMet[i],"pf","l");
Plot_MET->GetLegend()->AddEntry(h1_pupMet[i],"pup","l");
Plot_MET->GetLegend()->AddEntry(h1_trkMet[i],"trk","l");
if(sampleName == "DYJetsToLL")Plot_MET->SetLogy();
Plot_MET->Draw(myCan,kTRUE,"png");
// 2D plot party===================
//
sprintf(histNameOrg,"h2_pup_gen_MetResol_%d",i);
sprintf(histName,"h2_pupGenResol_%d",i);
h2_pupGenResol[i] = (TH2D*)fname->Get(histNameOrg)->Clone(histName);
h2_pupGenResol[i] -> SetMarkerSize(0.4);
sprintf(histNameOrg,"h2_pf_gen_MetResol_%d",i);
sprintf(histName,"h2_pfGenResol_%d",i);
h2_pfGenResol[i] = (TH2D*)fname->Get(histNameOrg)->Clone(histName);
h2_pfGenResol[i] -> SetMarkerSize(0.4);
sprintf(histNameOrg,"h2_trk_gen_MetResol_%d",i);
sprintf(histName,"h2_trkGenResol_%d",i);
h2_trkGenResol[i] = (TH2D*)fname->Get(histNameOrg)->Clone(histName);
h2_trkGenResol[i] -> SetMarkerSize(0.4);
myCan->Clear();
h2_pupGenResol[i]->GetYaxis()->SetTitle("(met-gen)/gen");
h2_pupGenResol[i]->Draw();
sprintf(tmpName,OutDir+"/"+sampleName+"_metGenRes2d_%dj.png",i);
//myCan->SaveAs(tmpName);
// Making profile ======================
sprintf(histName,"pr_pupGenResol_%d",i);
// name , first, last , option
//pr_pupGenResol[i] = h2_pupGenResol[i]->ProfileX(histName);
pr_pupGenResol[i] = h2_pupGenResol[i]->ProfileX(histName,1,-1,"s");
sprintf(histName,"pr_trkGenResol_%d",i);
pr_trkGenResol[i] = h2_trkGenResol[i]->ProfileX(histName,1,-1,"s");
sprintf(histName,"pr_pfGenResol_%d",i);
pr_pfGenResol[i] = h2_pfGenResol[i]->ProfileX(histName,1,-1,"s");
//pr_trkGenResol[i]->GetXaxis()->SetTitle("genMet");
//pr_trkGenResol[i]->GetYaxis()->SetTitle("trkmet");
//pr_trkGenResol[i]->SetTitle("");
//Leg_met->Draw();
//sprintf(tmpName,OutDir+"/"+sampleName+"_trkGenResol_%djet.png",i);
//myCan->SaveAs(tmpName);
//Each Profiles and 2D
//pr_pfGenResol[i]->GetXaxis()->SetTitle("genMet");
//pr_pfGenResol[i]->GetYaxis()->SetTitle("pfmet");
//pr_pfGenResol[i]->SetTitle("");
//Leg_met->SetHeader(LgdTitle[i]+" "+sampleName);
//pr_pfGenResol[i]->Draw();
//h2_pfGenResol[i]->Draw("same");
//pr_pfGenResol[i]->Draw("E1same");
//Leg_met->Draw();
//sprintf(tmpName,OutDir+"/"+sampleName+"_pfGenResol_%djet.png",i);
//myCan->SaveAs(tmpName);
//
//
//
pr_pupGenResol[i]->GetXaxis()->SetTitle("genMet[GeV]");
pr_pupGenResol[i]->GetYaxis()->SetTitle("(met-gen)/gen");
pr_pupGenResol[i]->SetTitle("");
pr_pupGenResol[i]->SetLineColor(kBlue);
pr_pupGenResol[i]->SetMarkerColor(kBlue);
pr_trkGenResol[i]->SetLineColor(kGreen);
pr_trkGenResol[i]->SetMarkerColor(kGreen);
pr_pfGenResol[i]->SetLineColor(kRed);
pr_pfGenResol[i]->SetMarkerColor(kRed);
pr_pupGenResol[i]->Draw("p");
//pr_pupGenResol[i]->Draw("E1");
pr_trkGenResol[i]->Draw("psame");
pr_pfGenResol[i]->Draw("psame");
TLegend *Leg_met =new TLegend(0.6,0.7,0.9,0.9); Leg_met->SetFillColor(0); Leg_met->SetBorderSize(0);
Leg_met->SetHeader(sampleName);
Leg_met->AddEntry(pr_pupGenResol[i],"pupMet","PL");
Leg_met->AddEntry(pr_trkGenResol[i],"trkMet","PL");
Leg_met->AddEntry(pr_pfGenResol[i],"pfMet","PL");
myCan->SetLogy(0);
Leg_met->Draw();
TLine myLine(0,0,120,0);
myLine.Draw();
sprintf(tmpName,OutDir+"/"+sampleName+"_metGenResol_%djet.png",i);
myCan->SaveAs(tmpName);
// RMS Draw
TH1D pupRMS("pupRMS","RMS",50,0,51);
TH1D trkRMS("trkRMS","RMS",50,0,51);
TH1D pfRMS ("pfRMS", "RMS" ,50,0,51);
for ( int j(0);j<50; j++)
{
pupRMS.SetBinContent(j,pr_pupGenResol[i]->GetBinError(j));
trkRMS.SetBinContent(j,pr_trkGenResol[i]->GetBinError(j));
pfRMS.SetBinContent(j,pr_pfGenResol[i]->GetBinError(j));
}
pupRMS.GetXaxis()->SetTitle("genMet[GeV]");
pupRMS.GetYaxis()->SetTitle("Resolution");
pupRMS.SetLineColor(kBlue);
trkRMS.SetLineColor(kGreen);
pfRMS.SetLineColor(kRed);
pupRMS.Draw();
trkRMS.Draw("same");
pfRMS.Draw("same");
TLegend *Leg_RMS =new TLegend(0.6,0.7,0.9,0.9);
Leg_RMS->SetFillColor(0);
Leg_RMS->SetBorderSize(0);
Leg_RMS->SetHeader(sampleName);
Leg_RMS->AddEntry(&pupRMS,"pupMet","L");
Leg_RMS->AddEntry(&trkRMS,"trkMet","L");
Leg_RMS->AddEntry(& pfRMS,"pfMet" ,"L");
Leg_RMS->Draw();
sprintf(tmpName,OutDir+"/"+sampleName+"_metGenRMS_%djet.png",i);
myCan->SaveAs(tmpName);
//h2_pupGenResol[i]->SetMaximum(10);
//h2_pupGenResol[i]->SetMinimum(-10);
//h2_trkGenResol[i]->Draw("same");
//h2_pfGenResol[i]->Draw("same");
}
}
void msquared() {
double yPos, xPos, theta, energy = 0.; // NOTE: theta comes in degrees
int numHit, pID = 0;
// Initialize histograms
double nEnergyMin = 10; // MeV
double nEnergyMax = 510; // MeV
int nEnergyBins = 50;
double dEnergyBinSize = (double)(nEnergyMax - nEnergyMin) / (double)nEnergyBins;
double nThetaMin = 34; // mrad
double nThetaMax = 88; // mrad
int nThetaBins = 50;
double dThetaBinSize = (nThetaMax - nThetaMin) / nThetaBins;
double nM2Min = -5000; // MeV
double nM2Max = 5000; // MeV
int nM2Bins = 100;
double dM2BinSize = (nM2Max - nM2Min)/nM2Bins;
THStack *hs = new THStack("hs","Stacked M^2");
TFile* file = new TFile("e+e-2yyGUN.root");
TTree* Hits_Info = (TTree *)file->Get("Signal");
Hits_Info->SetBranchAddress("numHits", &numHit);
Hits_Info->SetBranchAddress("energyTot", &energy);
Hits_Info->SetBranchAddress("XPosition", &xPos);
Hits_Info->SetBranchAddress("YPosition", &yPos);
Hits_Info->SetBranchAddress("Particle_ID", &pID);
Hits_Info->SetBranchAddress("Theta", &theta);
TH1D* hmyy = new TH1D("M_{A'}^{2}" , // plot label
"e+e- > yy", // title
nM2Bins, // x number of bins
nM2Min, // x lower bound
nM2Max); // x upper bound
// go through all entries and fill the histograms
int nentries = Hits_Info->GetEntries();
for (int i=0; i<nentries; i++) {
Hits_Info->GetEntry(i);
if (pID == 22) { // gammas only
theta*= TMath::Pi()/180; //radians
cout << "M^2 is: " << mSquared(energy, theta) << endl;
cout << "Energy is: " << energy << endl;
hmyy->Fill(mSquared(energy, theta), XSECyy * BINNING_WEIGHT / dM2BinSize);
}
}
cout << "DM2binsize is:" << dM2BinSize << endl;
hmyy->SetFillColor(kBlue);
hmyy->SetFillStyle(3001);
hmyy->GetXaxis()->SetTitle("M_{A'}^{2} (MeV^{2})");
hmyy->GetYaxis()->SetTitle("Photons per MeV^{2} per Second (MeV^{-2} s^{-1})");
hmyy->GetXaxis()->CenterTitle();
hmyy->GetYaxis()->CenterTitle();
TFile* fileyyy = new TFile("e+e-2yyyGUN.root");
TTree* Hits_Infoyyy = (TTree *)fileyyy->Get("Signal");
Hits_Infoyyy->SetBranchAddress("numHits", &numHit);
Hits_Infoyyy->SetBranchAddress("energyTot", &energy);
Hits_Infoyyy->SetBranchAddress("XPosition", &xPos);
Hits_Infoyyy->SetBranchAddress("YPosition", &yPos);
Hits_Infoyyy->SetBranchAddress("Particle_ID", &pID);
Hits_Infoyyy->SetBranchAddress("Theta", &theta);
TH1D* hmyyy = new TH1D("M_{A'}^{2}" , // plot label
"e+e- > yyy", // title
nM2Bins, // x number of bins
nM2Min, // x lower bound
nM2Max); // x upper bound
// go through all entries and fill the histograms
nentries = Hits_Infoyyy->GetEntries();
for (int i=0; i<nentries; i++) {
Hits_Infoyyy->GetEntry(i);
if (pID == 22) { // gammas only
theta*= TMath::Pi()/180; //radians
cout << "M^2 is: " << mSquared(energy, theta) << endl;
cout << "Energy is: " << energy << endl;
hmyyy->Fill(mSquared(energy, theta), XSECyyy * BINNING_WEIGHT / dM2BinSize);
}
}
cout << "DM2binsize is:" << dM2BinSize << endl;
hmyyy->SetFillColor(kRed);
hmyyy->SetFillStyle(3001);
hmyyy->GetXaxis()->SetTitle("M_{A'}^{2} (MeV^{2})");
hmyyy->GetYaxis()->SetTitle("Photons per MeV^{2} per Second (MeV^{-2} s^{-1})");
hmyyy->GetXaxis()->CenterTitle();
hmyyy->GetYaxis()->CenterTitle();
TFile* fileepluseminusy = new TFile("e+e-2e+e-yECUT0.3NOPT_2_5_1000000.root");
//This is 1000000 events so DOWNEIGHT IT:
XSECepluseminusy = 0.1 * XSECepluseminusy;
TTree* Hits_Infoepluseminusy = (TTree *)fileepluseminusy->Get("Signal");
Hits_Infoepluseminusy->SetBranchAddress("numHits", &numHit);
Hits_Infoepluseminusy->SetBranchAddress("energyTot", &energy);
Hits_Infoepluseminusy->SetBranchAddress("XPosition", &xPos);
Hits_Infoepluseminusy->SetBranchAddress("YPosition", &yPos);
Hits_Infoepluseminusy->SetBranchAddress("Particle_ID", &pID);
Hits_Infoepluseminusy->SetBranchAddress("Theta", &theta);
TH1D* hmepluseminusy = new TH1D("M_{A'}^{2}" , // plot label
"e+e- > e+e-y (only registering gammas)", // title
nM2Bins, // x number of bins
nM2Min, // x lower bound
nM2Max); // x upper bound
// go through all entries and fill the histograms
nentries = Hits_Infoepluseminusy->GetEntries();
for (int i=0; i<nentries; i++) {
Hits_Infoepluseminusy->GetEntry(i);
if (pID == 22) { // gammas only
theta*= TMath::Pi()/180; //radians
cout << "M^2 is: " << mSquared(energy, theta) << endl;
cout << "Energy is: " << energy << endl;
hmepluseminusy->Fill(mSquared(energy, theta), XSECepluseminusy * BINNING_WEIGHT / dM2BinSize);
}
}
cout << "DM2binsize is:" << dM2BinSize << endl;
hmepluseminusy->SetFillColor(7);
hmepluseminusy->SetFillStyle(3001);
hmepluseminusy->GetXaxis()->SetTitle("M_{A'}^{2} (MeV^{2})");
hmepluseminusy->GetYaxis()->SetTitle("Photons per MeV^{2} per Second (MeV^{-2} s^{-1})");
hmepluseminusy->GetXaxis()->CenterTitle();
hmepluseminusy->GetYaxis()->CenterTitle();
//ADD YIMIN'S PLOT
TFile *f = new TFile("YIMINPLOTBREM.root");
f->ls();
TH1F * hYIMIN = (TH1F*)f->Get("M^2");
hYIMIN->SetFillColor(kOrange);
hYIMIN->SetTitle("Bremsstrahlung");
hYIMIN->SetFillStyle(3001);
hYIMIN->GetXaxis()->SetTitle("M_{A'}^{2} (MeV^{2})");
hYIMIN->GetYaxis()->SetTitle("Photons per MeV^{2} per Second (MeV^{-2} s^{-1})");
hYIMIN->GetXaxis()->CenterTitle();
hYIMIN->GetYaxis()->CenterTitle();
/**********************
ADD BRIANS PLOT
********************/
NUM_TOT_POSITRONS = 1e+07;
BIAS = 1e+04;
BINNING_WEIGHT = POSITRONS_PER_SEC/(BIAS*NUM_TOT_POSITRONS);
B = pow(1-pow(GAMMA_PLUS, -2.), .5);
TFile* fileinelastic = new TFile("brian_1e7_pos_1e4_bias.root");
TTree* Hits_Infoinelastic = (TTree *)fileinelastic->Get("Signal");
Hits_Infoinelastic->SetBranchAddress("numHits", &numHit);
Hits_Infoinelastic->SetBranchAddress("energyTot", &energy);
Hits_Infoinelastic->SetBranchAddress("XPosition", &xPos);
Hits_Infoinelastic->SetBranchAddress("YPosition", &yPos);
Hits_Infoinelastic->SetBranchAddress("Particle_ID", &pID);
Hits_Infoinelastic->SetBranchAddress("Theta", &theta);
TH1D* hminelastic = new TH1D("M_{A'}^{2}" , // plot label
"Inelastic (only registering gammas)", // title
nM2Bins, // x number of bins
nM2Min, // x lower bound
nM2Max); // x upper bound
// go through all entries and fill the histograms
nentries = Hits_Infoinelastic->GetEntries();
for (int i=0; i<nentries; i++) {
Hits_Infoinelastic->GetEntry(i);
if (pID == 22) { // gammas only
theta*= TMath::Pi()/180; //radians
cout << "M^2 is: " << mSquared(energy, theta) << endl;
cout << "Energy is: " << energy << endl;
hminelastic->Fill(mSquared(energy, theta), BINNING_WEIGHT / dM2BinSize);
}
}
cout << "DM2binsize is:" << dM2BinSize << endl;
hminelastic->SetFillColor(kGreen);
hminelastic->SetFillStyle(3001);
hminelastic->GetXaxis()->SetTitle("M_{A'}^{2} (MeV^{2})");
hminelastic->GetYaxis()->SetTitle("Photons per MeV^{2} per Second (MeV^{-2} s^{-1})");
hminelastic->GetXaxis()->CenterTitle();
hminelastic->GetYaxis()->CenterTitle();
hs->Add(hminelastic);
hs->Add(hYIMIN);
hs->Add(hmyyy);
hs->Add(hmepluseminusy);
hs->Add(hmyy);
// create canvas and draw histogram
TCanvas* canvas = new TCanvas("canvas", "canvas", 700, 700);
canvas->Divide(3,2);
TPad* p;
p = (TPad*)canvas->cd(1);
//p->SetGrid();
p->SetLogy();
hs->Draw();
hs->GetXaxis()->SetTitle("M_{A'}^{2} (MeV^{2})");
hs->GetYaxis()->SetTitle("Photons per MeV^{2} per Second (MeV^{-2} s^{-1})");
hs->GetXaxis()->CenterTitle();
hs->GetYaxis()->CenterTitle();
p = (TPad*)canvas->cd(4);
hmepluseminusy->Draw();
p = (TPad*)canvas->cd(3);
hmyyy->Draw();
p = (TPad*)canvas->cd(2);
hmyy->Draw();
p = (TPad*)canvas->cd(5);
hYIMIN->Draw();
p = (TPad*)canvas->cd(6);
hminelastic->Draw();
/*
p = (TPad*)canvas->cd(4);
p->SetLogy();
p->SetGrid();
hm2->Draw();*/
}
int main(int ac, char *av[]) {
try {
double fMin, fMax;
string ext;
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("include-path,I", po::value< vector<string> >(),
"include path")
("input-file", po::value< vector<string> >(), "input file")
("min,m", po::value<double>(&fMin)->default_value(60), "minimum value for fit range")
("max,M", po::value<double>(&fMax)->default_value(120), "maximum value for fit range")
("convbwintgamg",
"fit to the convolution of a breit-wigner plus interference term and gamma propagator and a gaussian")
("convexpbwintgamg",
"fit to the convolution of the product between an exponential and a breit-wigner plus interference term and gamma propagator with a gaussian")
("convbwintgam2gf",
"fit to the convolution of the breit-wigner plus interference term and gamma propagator with a linear combination of fixed gaussians")
("output-file,O", po::value<string>(&ext)->default_value(".ps"),
"output file format")
;
po::positional_options_description p;
p.add("input-file", -1);
po::variables_map vm;
po::store(po::command_line_parser(ac, av).
options(desc).positional(p).run(), vm);
po::notify(vm);
if (vm.count("help")) {
cout << "Usage: options_description [options]\n";
cout << desc;
return 0;
}
if (vm.count("include-path")) {
cout << "Include paths are: "
<< vm["include-path"].as< vector<string> >() << "\n";
}
vector<string> v_file;
vector<TH1D*> v_ZMassHistos;
vector<string> v_eps;
if (vm.count("input-file")) {
cout << "Input files are: "
<< vm["input-file"].as< vector<string> >() << "\n";
v_file = vm["input-file"].as< vector<string> >();
for(vector<string>::const_iterator it = v_file.begin();
it != v_file.end(); ++it) {
TFile * root_file = new TFile(it->c_str(),"read");
TDirectory *Histos = (TDirectory*) root_file->GetDirectory("ZHisto");
TDirectory *RecoHistos = (TDirectory*) Histos->GetDirectory("ZRecoHisto");
TH1D * zMass = (TH1D*) RecoHistos->Get("ZMass");
zMass->Rebin(4); //remember...
zMass->GetXaxis()->SetTitle("#mu #mu invariant mass (GeV/c^{2})");
v_ZMassHistos.push_back(zMass);
gROOT->SetStyle("Plain");
//gStyle->SetOptFit(1111);
string f_string = *it;
replace(f_string.begin(), f_string.end(), '.', '_');
string eps_string = f_string + ext;
v_eps.push_back(eps_string);
cout << ">>> histogram loaded\n";
}
cout << v_file.size() << ", " << v_ZMassHistos.size() << ", " << v_eps.size() << endl;
cout <<">>> Input files loaded\n";
}
IntegratorConv integratorConv(1.e-5);
//Values for Z mass and width
funct::Parameter mass("Mass", 91.364);
funct::Parameter gamma("Gamma", 4.11);
//Parameters for Z Line Shape
funct::Parameter f_gamma("Photon factor", 0.838);
funct::Parameter f_int("Interference factor", -0.00197);
//Parameters for fits with gaussians
funct::Parameter yield("Yield", 283000);
funct::Parameter alpha("Alpha", 0.771); //the first gaussian is narrow
funct::Parameter mean("Mean", 0); //0.229
funct::Parameter sigma1("Sigma 1", 0.76);
funct::Parameter sigma2("Sigma 2", 2.94);
//Parameter for exponential
funct::Parameter lambda("Lambda", 0);
if (vm.count("convbwintgamg")) {
cout << "Fitting histograms in input files to the convolution of the Breit-Wigner plus Z/photon interference and photon propagator with a Gaussian\n";
cout << ">>> set pars: " << endl;
cout << yield << endl;
cout << mass << endl;
cout << gamma << endl;
cout << f_gamma << endl;
cout << f_int << endl;
cout << mean << endl;
cout << sigma1 << endl;
for(unsigned int i = 0; i < v_ZMassHistos.size(); ++i) {
TH1D * zMass = v_ZMassHistos[i];
funct::ZLineShape zls(mass, gamma, f_gamma, f_int);
funct::Gaussian gauss(mean, sigma1);
double range = 3 * sigma1.value();
funct::Convolution<funct::ZLineShape, funct::Gaussian, IntegratorConv>::type
czg(zls, gauss, -range , range, integratorConv);
funct::Constant c(yield);
typedef funct::Product<funct::Constant,
funct::Convolution<funct::ZLineShape, funct::Gaussian, IntegratorConv>::type >::type FitFunction;
FitFunction f = c * czg;
cout << "set functions" << endl;
typedef fit::HistoChiSquare<FitFunction> ChiSquared;
ChiSquared chi2(f, zMass, fMin, fMax);
int fullBins = chi2.numberOfBins();
cout << "N. deg. of freedom: " << fullBins << endl;
fit::RootMinuit<ChiSquared> minuit(chi2, true);
minuit.addParameter(yield, 10, 100, 10000000);
minuit.addParameter(mass, .1, 70., 110);
minuit.addParameter(gamma, 1, 1, 10);
minuit.addParameter(f_gamma, 0.1, -100, 1000);
minuit.addParameter(f_int, .0001, -1000000, 1000000);
minuit.addParameter(mean, 0.001, -0.5, 0.5);
minuit.fixParameter(mean.name());
minuit.addParameter(sigma1, 0.1, -5., 5.);
minuit.minimize();
minuit.printFitResults();
vector<shared_ptr<double> > pars;
pars.push_back(yield.ptr());
pars.push_back(mass.ptr());
pars.push_back(gamma.ptr());
pars.push_back(f_gamma.ptr());
pars.push_back(f_int.ptr());
pars.push_back(mean.ptr());
pars.push_back(sigma1.ptr());
TF1 fun = root::tf1("fun", f, fMin, fMax, pars);
fun.SetParNames(yield.name().c_str(), mass.name().c_str(), gamma.name().c_str(),
f_gamma.name().c_str(), f_int.name().c_str(),
mean.name().c_str(), sigma1.name().c_str());
fun.SetLineColor(kRed);
fun.SetNpx(100000);
TCanvas *canvas = new TCanvas("canvas");
zMass->Draw("e");
fun.Draw("same");
string epsFilename = "ZMassFitCoBwInGaG_" + v_eps[i];
canvas->SaveAs(epsFilename.c_str());
canvas->SetLogy();
string epsLogFilename = "ZMassFitCoBwInGaG_Log_" + v_eps[i];
canvas->SaveAs(epsLogFilename.c_str());
}
}
if (vm.count("convexpbwintgamg")) {
cout << "Fitting histograms in input files to the convolution of the product between an exponential and a breit-wigner plus interference term and gamma propagator with a gaussian"
<< endl;
cout << ">>> set pars: " << endl;
cout << yield << endl;
cout << lambda << endl;
cout << mass << endl;
cout << gamma << endl;
cout << f_gamma << endl;
cout << f_int << endl;
cout << mean << endl;
cout << sigma1 << endl;
for(unsigned int i = 0; i < v_ZMassHistos.size(); ++i) {
TH1D * zMass = v_ZMassHistos[i];
funct::Exponential expo(lambda);
funct::ZLineShape zls(mass, gamma, f_gamma, f_int);
funct::Gaussian gauss(mean, sigma1);
typedef funct::Product<funct::Exponential, funct::ZLineShape>::type ExpZLS;
ExpZLS expz = expo * zls;
double range = 3 * sigma1.value();
funct::Convolution<ExpZLS, funct::Gaussian, IntegratorConv>::type cezg(expz, gauss, -range , range, integratorConv);
funct::Constant c(yield);
typedef funct::Product<funct::Constant, funct::Convolution<ExpZLS, funct::Gaussian, IntegratorConv>::type >::type FitFunction;
FitFunction f = c * cezg;
cout << "set functions" << endl;
typedef fit::HistoChiSquare<FitFunction> ChiSquared;
ChiSquared chi2(f, zMass, fMin, fMax);
int fullBins = chi2.numberOfBins();
cout << "N. deg. of freedom: " << fullBins << endl;
fit::RootMinuit<ChiSquared> minuit(chi2, true);
minuit.addParameter(yield, 10, 100, 10000000);
minuit.addParameter(lambda, 0.1, -100, 100);
minuit.fixParameter(lambda.name());
minuit.addParameter(mass, .1, 70., 110);
minuit.addParameter(gamma, 1, 1, 10);
minuit.addParameter(f_gamma, 0.1, -100, 1000);
minuit.addParameter(f_int, .0001, -1000000, 1000000);
minuit.addParameter(mean, 0.001, -0.5, 0.5);
minuit.fixParameter(mean.name());
minuit.addParameter(sigma1, 0.1, -5., 5.);
minuit.minimize();
minuit.printFitResults();
minuit.releaseParameter(lambda.name());
minuit.minimize();
minuit.printFitResults();
vector<shared_ptr<double> > pars;
pars.push_back(yield.ptr());
pars.push_back(lambda.ptr());
pars.push_back(mass.ptr());
pars.push_back(gamma.ptr());
pars.push_back(f_gamma.ptr());
pars.push_back(f_int.ptr());
pars.push_back(mean.ptr());
pars.push_back(sigma1.ptr());
TF1 fun = root::tf1("fun", f, fMin, fMax, pars);
fun.SetParNames(yield.name().c_str(), lambda.name().c_str(),
mass.name().c_str(), gamma.name().c_str(),
f_gamma.name().c_str(), f_int.name().c_str(),
mean.name().c_str(), sigma1.name().c_str());
fun.SetLineColor(kRed);
fun.SetNpx(100000);
TCanvas *canvas = new TCanvas("canvas");
zMass->Draw("e");
fun.Draw("same");
string epsFilename = "ZMassFitCoExBwInGaG_" + v_eps[i];
canvas->SaveAs(epsFilename.c_str());
canvas->SetLogy();
string epsLogFilename = "ZMassFitCoExBwInGaG_Log_" + v_eps[i];
canvas->SaveAs(epsLogFilename.c_str());
}
}
if (vm.count("convbwintgam2gf")) {
cout << "Fitting histograms in input files to the convolution of the Breit-Wigner plus Z/photon interference and photon propagator with a linear combination of fixed Gaussians\n";
cout << ">>> set pars: " << endl;
cout << yield << endl;
cout << alpha << endl;
cout << mass << endl;
cout << gamma << endl;
cout << f_gamma << endl;
cout << f_int << endl;
cout << mean << endl;
cout << sigma1 << endl;
cout << sigma2 << endl;
for(unsigned int i = 0; i < v_ZMassHistos.size(); ++i) {
TH1D * zMass = v_ZMassHistos[i];
funct::ZLineShape zls(mass, gamma, f_gamma, f_int);
funct::Gaussian gaus1(mean, sigma1);
funct::Gaussian gaus2(mean, sigma2);
funct::Number _1(1);
typedef funct::Product<funct::Constant, funct::Gaussian>::type G1;
typedef funct::Product<funct::Difference<funct::Number, funct::Constant>::type,
funct::Gaussian>::type G2;
typedef funct::Product<funct::Constant, funct::Sum<G1, G2>::type>::type GaussComb;
funct::Constant c_alpha(alpha), c_yield(yield);
GaussComb gc = c_yield*(c_alpha*gaus1 + (_1 - c_alpha)*gaus2);
typedef funct::Convolution<funct::ZLineShape, GaussComb, IntegratorConv>::type FitFunction;
double range = 3 * max(sigma1.value(), sigma2.value());
FitFunction f(zls, gc, -range , range, integratorConv);
cout << "set functions" << endl;
typedef fit::HistoChiSquare<FitFunction> ChiSquared;
ChiSquared chi2(f, zMass, fMin, fMax);
int fullBins = chi2.numberOfBins();
cout << "N. deg. of freedom: " << fullBins << endl;
fit::RootMinuit<ChiSquared> minuit(chi2, true);
minuit.addParameter(yield, 10, 100, 10000000);
minuit.addParameter(alpha, 0.1, -1., 1.);
minuit.addParameter(mass, .1, 70., 110);
minuit.addParameter(gamma, 1, 1, 10);
minuit.addParameter(f_gamma, 0.1, -100, 1000);
minuit.addParameter(f_int, .0001, -1000000, 1000000);
minuit.addParameter(mean, 0.001, -0.5, 0.5);
minuit.fixParameter(mean.name());
minuit.addParameter(sigma1, 0.1, -5., 5.);
minuit.addParameter(sigma2, 0.1, -5., 5.);
minuit.minimize();
minuit.printFitResults();
vector<shared_ptr<double> > pars;
pars.push_back(yield.ptr());
pars.push_back(alpha.ptr());
pars.push_back(mass.ptr());
pars.push_back(gamma.ptr());
pars.push_back(f_gamma.ptr());
pars.push_back(f_int.ptr());
pars.push_back(mean.ptr());
pars.push_back(sigma1.ptr());
pars.push_back(sigma2.ptr());
TF1 fun = root::tf1("fun", f, fMin, fMax, pars);
fun.SetParNames(yield.name().c_str(), alpha.name().c_str(),
mass.name().c_str(), gamma.name().c_str(),
f_gamma.name().c_str(), f_int.name().c_str(),
mean.name().c_str(), sigma1.name().c_str(), sigma2.name().c_str());
fun.SetLineColor(kRed);
TCanvas *canvas = new TCanvas("canvas");
zMass->Draw("e");
fun.Draw("same");
string epsFilename = "ZMassFitCoBwInGaGGf_" + v_eps[i];
canvas->SaveAs(epsFilename.c_str());
canvas->SetLogy();
string epsLogFilename = "ZMassFitCoBwInGaGGf_Log_" + v_eps[i];
canvas->SaveAs(epsLogFilename.c_str());
}
}
cout << "It works!\n";
}
catch(std::exception& e) {
cerr << "error: " << e.what() << "\n";
return 1;
}
catch(...) {
cerr << "Exception of unknown type!\n";
}
return 0;
}
void fitD(TString inputdata="/data/dmeson2015/DataDntuple/nt_20160112_DfinderData_pp_20160111_dPt0tkPt1_D0Dstar3p5p_DCSJSON_v2.root", TString inputmc="/afs/cern.ch/work/w/wangj/public/Dmeson/ntD_20151110_DfinderMC_20151110_EvtMatching_Pythia_D0pt15p0_Pthat15_TuneZ2_5020GeV_GENSIM_75x_1015_20151110_ppGlobaTrackingPPmenuHFlowpuv11_MBseed_twang-Pythia_1107.root", TString trgselection="((HLT_DmesonPPTrackingGlobal_Dpt15_v1&&Dpt>25&&Dpt<40)||(HLT_DmesonPPTrackingGlobal_Dpt30_v1&&Dpt>40&&Dpt<60)||(HLT_DmesonPPTrackingGlobal_Dpt50_v1&&Dpt>60))", TString cut="Dy>-1.&&Dy<1.&&(Dtrk1highPurity&&Dtrk2highPurity)&&(DsvpvDistance/DsvpvDisErr)>3.5&&Dchi2cl>0.05&&Dalpha<0.12&&Dtrk1Pt>1.5&&Dtrk2Pt>1.5", TString selmcgen="((GisSignal==1||GisSignal==2)&&(Gy>-1&&Gy<1))", int isMC=0, Double_t luminosity=26., int doweight=0, TString collsyst="PbPb", TString outputfile="mytest.root")
{
collisionsystem=collsyst;
seldata = Form("%s&&%s",trgselection.Data(),cut.Data());
selmc = Form("%s",cut.Data());
gStyle->SetTextSize(0.05);
gStyle->SetTextFont(42);
gStyle->SetPadRightMargin(0.043);
gStyle->SetPadLeftMargin(0.18);
gStyle->SetPadTopMargin(0.1);
gStyle->SetPadBottomMargin(0.145);
gStyle->SetTitleX(.0f);
void clean0 (TH1D* h);
TF1* fit (TTree* nt, TTree* ntMC, double ptmin, double ptmax, int isMC);
if(!doweight) weight="1";
TFile* inf = new TFile(inputdata.Data());
TFile* infMC = new TFile(inputmc.Data());
TTree* nt = (TTree*) inf->Get("ntDkpi");
TTree* HltTree= (TTree*) inf->Get("ntHlt");
HltTree->AddFriend(nt);
nt->AddFriend(HltTree);
TTree* ntHid = (TTree*) inf->Get("ntHi");
nt->AddFriend(ntHid);
TTree* ntMC = (TTree*)infMC->Get("ntDkpi");
TTree* ntGen = (TTree*)infMC->Get("ntGen");
TTree* ntHi = (TTree*)infMC->Get("ntHi");
ntGen->AddFriend(ntMC);
ntGen->AddFriend(ntHi);
ntMC->AddFriend(ntGen);
ntMC->AddFriend(ntHi);
ntHi->AddFriend(ntMC);
TH1D* hPt = new TH1D("hPt","",nBins,ptBins);
TH1D* hPtRecoTruth = new TH1D("hPtRecoTruth","",nBins,ptBins);
TH1D* hPtMC = new TH1D("hPtMC","",nBins,ptBins);
TH1D* hPtGen = new TH1D("hPtGen","",nBins,ptBins);
TH1D* hMean = new TH1D("hMean","",nBins,ptBins);
TH1D* hSigmaGaus1 = new TH1D("hSigmaGaus1","",nBins,ptBins);
TH1D* hSigmaGaus2 = new TH1D("hSigmaGaus2","",nBins,ptBins);
TH1D* hRelMagnGaus1Gaus2 = new TH1D("hRelMagnGaus1Gaus2","",nBins,ptBins);
for(int i=0;i<nBins;i++)
{
TF1* f = fit(nt,ntMC,ptBins[i],ptBins[i+1],isMC);
double yield = f->Integral(minhisto,maxhisto)/binwidthmass;
double yieldErr = f->Integral(minhisto,maxhisto)/binwidthmass*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]));
hMean->SetBinContent(i+1,f->GetParameter(1));
hMean->SetBinError(i+1,f->GetParError(1));
hSigmaGaus1->SetBinContent(i+1,f->GetParameter(2));
hSigmaGaus1->SetBinError(i+1,f->GetParError(2));
hSigmaGaus2->SetBinContent(i+1,f->GetParameter(5));
hSigmaGaus2->SetBinError(i+1,f->GetParError(5));
hRelMagnGaus1Gaus2->SetBinContent(i+1,f->GetParameter(4));
hRelMagnGaus1Gaus2->SetBinError(i+1,f->GetParError(4));
}
ntMC->Project("hPtMC","Dpt",TCut(weight)*(TCut(selmc.Data())&&"(Dgen==23333)"));
divideBinWidth(hPtMC);
ntMC->Project("hPtRecoTruth","Dpt",TCut(selmc.Data())&&"(Dgen==23333)");
divideBinWidth(hPtRecoTruth);
ntGen->Project("hPtGen","Gpt",TCut(weight)*(TCut(selmcgen.Data())));
divideBinWidth(hPtGen);
TCanvas* cPt = new TCanvas("cPt","",600,600);
cPt->SetLogy();
hPt->SetXTitle("D^{0} p_{T} (GeV/c)");
hPt->SetYTitle("Uncorrected dN(D^{0})/dp_{T}");
hPt->Sumw2();
hPt->Draw();
if(isMC)
{
hPtMC->Draw("same hist");
TLegend* legPt = myLegend(0.55,0.80,0.90,0.94);
legPt->AddEntry(hPt,"Signal extraction","pl");
legPt->AddEntry(hPtMC,"Matched reco","lf");
legPt->Draw("same");
}
hPtMC->Sumw2();
TH1D* hEff = (TH1D*)hPtMC->Clone("hEff");
hEff->SetTitle(";D^{0} p_{T} (GeV/c);Efficiency");
hEff->Sumw2();
hEff->Divide(hPtGen);
TCanvas* cEff = new TCanvas("cEff","",600,600);
hEff->Draw();
TH1D* hPtCor = (TH1D*)hPt->Clone("hPtCor");
hPtCor->SetTitle(";D^{0} p_{T} (GeV/c);Corrected dN(D^{0})/dp_{T}");
hPtCor->Divide(hEff);
TCanvas* cPtCor= new TCanvas("cCorResult","",600,600);
cPtCor->SetLogy();
hPtCor->Draw();
if(isMC)
{
hPtGen->Draw("same hist");
TLegend* legPtCor = myLegend(0.55,0.80,0.90,0.94);
legPtCor->AddEntry(hPtCor,"Corrected signal","pl");
legPtCor->AddEntry(hPtGen,"Generated D^{0}","lf");
legPtCor->Draw("same");
}
TH1D* hPtSigma= (TH1D*)hPtCor->Clone("hPtSigma");
hPtSigma->SetTitle(";D^{0} p_{T} (GeV/c);d#sigma(D^{0})/dp_{T} (pb/GeV)");
hPtSigma->Scale(1./(2*luminosity*BRchain));
TCanvas* cPtSigma= new TCanvas("cPtSigma","",600,600);
cPtSigma->SetLogy();
hPtSigma->Draw();
TFile* outf = new TFile(outputfile.Data(),"recreate");
outf->cd();
hPt->Write();
hEff->Write();
hPtGen->Write();
hPtMC->Write();
hPtCor->Write();
hPtSigma->Write();
hMean->Write();
hSigmaGaus1->Write();
hSigmaGaus2->Write();
hRelMagnGaus1Gaus2->Write();
outf->Close();
}
TF1* fit(TTree* nt, TTree* ntMC, Double_t ptmin, Double_t ptmax, int isMC)
{
static int count=0;
count++;
TCanvas* c= new TCanvas(Form("c%d",count),"",600,600);
TH1D* h = new TH1D(Form("h-%d",count),"",nbinsmasshisto,minhisto,maxhisto);
TH1D* hMCSignal = new TH1D(Form("hMCSignal-%d",count),"",nbinsmasshisto,minhisto,maxhisto);
TH1D* hMCSwapped = new TH1D(Form("hMCSwapped-%d",count),"",nbinsmasshisto,minhisto,maxhisto);
TF1* f = new TF1(Form("f%d",count),"[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+[6]*x*x*x", 1.7, 2.0);
if(isMC==1) nt->Project(Form("h-%d",count),"Dmass",Form("%s*(%s&&Dpt>%f&&Dpt<%f)",weight.Data(),seldata.Data(),ptmin,ptmax));
else nt->Project(Form("h-%d",count),"Dmass",Form("(%s&&Dpt>%f&&Dpt<%f)",seldata.Data(),ptmin,ptmax));
ntMC->Project(Form("hMCSignal-%d",count),"Dmass",Form("%s*(%s&&Dpt>%f&&Dpt<%f&&(Dgen==23333))",weight.Data(),selmc.Data(),ptmin,ptmax));
ntMC->Project(Form("hMCSwapped-%d",count),"Dmass",Form("%s*(%s&&Dpt>%f&&Dpt<%f&&(Dgen==23344))",weight.Data(),selmc.Data(),ptmin,ptmax));
/*
TFile *fout=new TFile(Form("FitsFiles/Fits_%s_%d.root",collisionsystem.Data(),count),"recreate");
fout->cd();
hMCSignal->Write();
hMCSwapped->Write();
h->Write();
*/
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);
h->GetEntries();
hMCSignal->Fit(Form("f%d",count),"q","",minhisto,maxhisto);
hMCSignal->Fit(Form("f%d",count),"q","",minhisto,maxhisto);
f->ReleaseParameter(1);
hMCSignal->Fit(Form("f%d",count),"L q","",minhisto,maxhisto);
hMCSignal->Fit(Form("f%d",count),"L q","",minhisto,maxhisto);
hMCSignal->Fit(Form("f%d",count),"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%d",count),"L q","",minhisto,maxhisto);
hMCSwapped->Fit(Form("f%d",count),"L q","",minhisto,maxhisto);
hMCSwapped->Fit(Form("f%d",count),"L q","",minhisto,maxhisto);
hMCSwapped->Fit(Form("f%d",count),"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);
h->Fit(Form("f%d",count),"q","",minhisto,maxhisto);
h->Fit(Form("f%d",count),"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%d",count),"L q","",minhisto,maxhisto);
h->Fit(Form("f%d",count),"L q","",minhisto,maxhisto);
h->Fit(Form("f%d",count),"L q","",minhisto,maxhisto);
h->Fit(Form("f%d",count),"L m","",minhisto,maxhisto);
TF1* background = new TF1(Form("background%d",count),"[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(Form("fmass%d",count),"[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%d",count),"[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 Tl;
Tl.SetNDC();
Tl.SetTextAlign(12);
Tl.SetTextSize(0.04);
Tl.SetTextFont(42);
Tl.DrawLatex(0.18,0.93, "#scale[1.25]{CMS} Preliminary");
Tl.DrawLatex(0.65,0.93, Form("%s #sqrt{s_{NN}} = 5.02 TeV",collisionsystem.Data()));
TLatex* tex;
tex = new TLatex(0.22,0.78,Form("%.1f < p_{T} < %.1f GeV/c",ptmin,ptmax));
tex->SetNDC();
tex->SetTextFont(42);
tex->SetTextSize(0.04);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.22,0.83,"|y| < 1.0");
tex->SetNDC();
tex->SetTextFont(42);
tex->SetTextSize(0.04);
tex->SetLineWidth(2);
tex->Draw();
h->GetFunction(Form("f%d",count))->Delete();
TH1F* histo_copy_nofitfun = ( TH1F * ) h->Clone("histo_copy_nofitfun");
histo_copy_nofitfun->Draw("esame");
//
if(nBins==1) c->SaveAs(Form("DMass-inclusive%s_%d.pdf",collisionsystem.Data(),count));
else c->SaveAs(Form("DMass%s_%d.pdf",collisionsystem.Data(),count));
return mass;
}
void PlotMacro_Core(string input, string input2, string moduleName, string output)
{
FILE* pFile;
TCanvas* c1;
TObject** Histos = new TObject*[10];
std::vector<string> legend;
unsigned int tree1_Index;
unsigned int tree1_DetId;
unsigned char tree1_APVId;
unsigned char tree1_SubDet;
float tree1_x;
float tree1_y;
float tree1_z;
float tree1_Eta;
float tree1_R;
float tree1_Phi;
float tree1_Thickness;
float tree1_FitMPV;
float tree1_FitMPVErr;
float tree1_FitWidth;
float tree1_FitWidthErr;
float tree1_FitChi2NDF;
double tree1_Gain;
double tree1_PrevGain;
double tree1_NEntries;
bool tree1_isMasked;
unsigned int tree2_Index;
unsigned int tree2_DetId;
unsigned char tree2_APVId;
unsigned char tree2_SubDet;
float tree2_x;
float tree2_y;
float tree2_z;
float tree2_Eta;
float tree2_R;
float tree2_Phi;
float tree2_Thickness;
float tree2_FitMPV;
float tree2_FitMPVErr;
float tree2_FitWidth;
float tree2_FitWidthErr;
float tree2_FitChi2NDF;
double tree2_Gain;
double tree2_PrevGain;
double tree2_NEntries;
bool tree2_isMasked;
TFile* f1 = new TFile(input.c_str());
TTree *t1 = (TTree*)GetObjectFromPath(f1,moduleName+"/APVGain");
TH2D* ChargeDistrib1 = (TH2D*)GetObjectFromPath(f1,moduleName+"/Charge_Vs_Index");
t1->SetBranchAddress("Index" ,&tree1_Index );
t1->SetBranchAddress("DetId" ,&tree1_DetId );
t1->SetBranchAddress("APVId" ,&tree1_APVId );
t1->SetBranchAddress("SubDet" ,&tree1_SubDet );
t1->SetBranchAddress("x" ,&tree1_x );
t1->SetBranchAddress("y" ,&tree1_y );
t1->SetBranchAddress("z" ,&tree1_z );
t1->SetBranchAddress("Eta" ,&tree1_Eta );
t1->SetBranchAddress("R" ,&tree1_R );
t1->SetBranchAddress("Phi" ,&tree1_Phi );
t1->SetBranchAddress("Thickness" ,&tree1_Thickness );
t1->SetBranchAddress("FitMPV" ,&tree1_FitMPV );
t1->SetBranchAddress("FitMPVErr" ,&tree1_FitMPVErr );
t1->SetBranchAddress("FitWidth" ,&tree1_FitWidth );
t1->SetBranchAddress("FitWidthErr" ,&tree1_FitWidthErr);
t1->SetBranchAddress("FitChi2NDF" ,&tree1_FitChi2NDF );
t1->SetBranchAddress("Gain" ,&tree1_Gain );
t1->SetBranchAddress("PrevGain" ,&tree1_PrevGain );
t1->SetBranchAddress("NEntries" ,&tree1_NEntries );
t1->SetBranchAddress("isMasked" ,&tree1_isMasked );
TFile* f2 = new TFile(input2.c_str());
TTree *t2 = (TTree*)GetObjectFromPath(f2,moduleName+"/APVGain");
TH2D* ChargeDistrib2 = (TH2D*)GetObjectFromPath(f2,moduleName+"/Charge_Vs_Index");
t2->SetBranchAddress("Index" ,&tree2_Index );
t2->SetBranchAddress("DetId" ,&tree2_DetId );
t2->SetBranchAddress("APVId" ,&tree2_APVId );
t2->SetBranchAddress("SubDet" ,&tree2_SubDet );
t2->SetBranchAddress("x" ,&tree2_x );
t2->SetBranchAddress("y" ,&tree2_y );
t2->SetBranchAddress("z" ,&tree2_z );
t2->SetBranchAddress("Eta" ,&tree2_Eta );
t2->SetBranchAddress("R" ,&tree2_R );
t2->SetBranchAddress("Phi" ,&tree2_Phi );
t2->SetBranchAddress("Thickness" ,&tree2_Thickness );
t2->SetBranchAddress("FitMPV" ,&tree2_FitMPV );
t2->SetBranchAddress("FitMPVErr" ,&tree2_FitMPVErr );
t2->SetBranchAddress("FitWidth" ,&tree2_FitWidth );
t2->SetBranchAddress("FitWidthErr" ,&tree2_FitWidthErr);
t2->SetBranchAddress("FitChi2NDF" ,&tree2_FitChi2NDF );
t2->SetBranchAddress("Gain" ,&tree2_Gain );
t2->SetBranchAddress("PrevGain" ,&tree2_PrevGain );
t2->SetBranchAddress("NEntries" ,&tree2_NEntries );
t2->SetBranchAddress("isMasked" ,&tree2_isMasked );
pFile = fopen("GainDiff.txt","w");
unsigned int PreviousId = 0;
unsigned int NAPV = 0;
double MPV1 = 0;
double MPV2 = 0;
double Min = 10000;
double Max =-10000;
printf("Progressing Bar :0%% 20%% 40%% 60%% 80%% 100%%\n");
printf("Looping on the Tree :");
int TreeStep = t1->GetEntries()/50;if(TreeStep==0)TreeStep=1;
cout<<t1->GetEntries()<<" - "<<t2->GetEntries()<<endl;
for (unsigned int ientry = 0; ientry < t1->GetEntries(); ientry++) {
if(ientry%TreeStep==0){printf(".");fflush(stdout);}
t1->GetEntry(ientry);
t2->GetEntry(ientry);
if(tree2_FitMPV>0 and tree2_FitMPV<150){
TH1D* Proj1 = ChargeDistrib1 ->ProjectionY("proj1" ,tree1_Index, tree1_Index, "e");
TH1D* Proj2 = ChargeDistrib2 ->ProjectionY("proj2" ,tree2_Index, tree2_Index, "e");
TCanvas* c1 = new TCanvas("c1", "c1", 600,600);
// c1->SetLogy(true);
TH1D* frame = new TH1D("frame", "frame", 1,0, 1000);
frame->GetXaxis()->SetNdivisions(505);
frame->SetTitle("");
frame->SetStats(kFALSE);
frame->GetXaxis()->SetTitle("charge/path-length (ADC/mm)");
frame->GetYaxis()->SetTitle("#clusters");
frame->SetMaximum(std::max(tree1_NEntries, tree2_NEntries)*0.04);
frame->SetMinimum(0.0);
frame->GetYaxis()->SetTitleOffset(1.50);
frame->Draw();
//Proj1->Scale(1.0/Proj1->Integral());
Proj1->SetLineColor(2);
Proj1->SetLineWidth(2);
Proj1->Draw("H same");
TF1* Fit1 = new TF1("MyLandau1","landau", 0, 2000);
Fit1->SetParameters(tree1_NEntries/tree1_FitWidth, tree1_FitMPV, tree1_FitWidth);
Fit1->SetLineColor(2);
Fit1->SetLineWidth(2);
Fit1->Draw("L same");
TF1* Fit1b = getPeakOfLandau(Proj1, "MyLandau1bis");
Fit1b->SetLineColor(8);
Fit1b->SetLineWidth(2);
Fit1b->Draw("L same");
printf("period1 MPV vs new MPV --> %6.2f vs %6.2f\n", tree1_FitMPV, Fit1b->GetParameter(1));
//Proj2->Scale(1.0/Proj2->Integral());
Proj2->SetLineColor(4);
Proj2->SetLineWidth(2);
Proj2->Draw("H same");
TF1* Fit2 = new TF1("MyLandau2","landau", 0, 2000);
Fit2->SetParameters(tree2_NEntries/tree2_FitWidth, tree2_FitMPV, tree2_FitWidth);
Fit2->SetLineColor(4);
Fit2->SetLineWidth(2);
Fit2->Draw("L same");
TF1* Fit2b = getPeakOfLandau(Proj2, "MyLandau2bis");
Fit2b->SetLineColor(8);
Fit2b->SetLineWidth(2);
Fit2b->Draw("L same");
printf("period2 MPV vs new MPV --> %6.2f vs %6.2f\n", tree2_FitMPV, Fit2b->GetParameter(1));
char buffer[256];
sprintf(buffer, "Pictures/Charge/SubDet%i_Id%i_Apv%i_N%i.png",tree1_SubDet, tree1_DetId, tree1_APVId, (int)tree1_NEntries);
c1->SaveAs(buffer);
}
if(tree1_APVId==0 && PreviousId>0){
double Mean = (MPV2/NAPV) / (MPV1/NAPV);
if(Mean<Min)Min=Mean;
if(Mean>Max)Max=Mean;
if(NAPV>0) fprintf(pFile,"%i %f\n",PreviousId,Mean);
NAPV=0; MPV1=0; MPV2=0;
}
PreviousId = tree1_DetId;
if(tree1_FitMPV<=0 || tree2_FitMPV<=0)continue;
NAPV++;
MPV1+=tree1_FitMPV;
MPV2+=tree2_FitMPV;
}printf("\n");
fclose(pFile);
printf("Min=%f - Max=%f\n",Min,Max);
}
void plotTurnOn()
{
const Int_t INPUTFILES = 4;
// TString outFileTag = "MBData_200Hz";
// TString inFileName[INPUTFILES] = {"hist_MBData_zeroWalls.root",
// "hist_MBData_sigmaSubtraction.root",
// "hist_MBData_oneByOneAndzeroWalls.root",
// "hist_MBData_twoByTwoANDzeroWalls.root"
// };
// TString labels[INPUTFILES] = {"zeroWalls, L1_40, 206Hz",
// "sigma subtracted, L1_24, 187Hz",
// "1x1 jets +ZW, L1_16, 191Hz",
// "2x2 jets +ZW, L1_52, 228Hz"};
// const Double_t L1_THRESHOLD[INPUTFILES] = {40, 24, 16, 32};
// // TString labels[INPUTFILES] = {"zeroWalls, L1_44, 550Hz",
// // "sigma subtracted, L1_20, 505Hz",
// // "1x1 jets +ZW, L1_20, 441Hz",
// // "2x2 jets +ZW, L1_36, 444Hz"};
// // const Double_t L1_THRESHOLD[INPUTFILES] = {44, 20, 20, 36};
// TString outFileTag = "Hydjet276_270Hz";
// TString inFileName[INPUTFILES] = {"hist_Hydjet276_zeroWalls.root",
// "hist_Hydjet276_sigmaSubtraction.root",
// "hist_Hydjet276_oneByOneAndzeroWalls.root",
// "hist_Hydjet276_twoByTwoANDzeroWalls.root"};
// // const TString labels[INPUTFILES] = {"zeroWalls, L1_60, 104Hz",
// // "sigma subtracted, L1_28, 102Hz",
// // "1x1 jets, L1_28, 112Hz",
// // "2x2 jets, L1_48, 107Hz"};
// // const Double_t L1_THRESHOLD[INPUTFILES] = {60, 28, 28, 48};
// const TString labels[INPUTFILES] = {"zeroWalls, L1_40, 276Hz",
// "sigma subtracted, L1_24, 280Hz",
// "1x1 jets +ZW, L1_20, 270Hz",
// "2x2 jets +ZW, L1_32, 272Hz"};
// const Double_t L1_THRESHOLD[INPUTFILES] = {40, 24, 20, 32};
// TString outFileTag = "Hydjet502_200Hz";
// TString inFileName[INPUTFILES] = {"hist_Hydjet502_zeroWalls.root",
// "hist_Hydjet502_sigmaSubtraction.root",
// "hist_Hydjet502_oneByOneAndzeroWalls.root",
// "hist_Hydjet502_twoByTwoANDzeroWalls.root"
// };
// // TString labels[INPUTFILES] = {"zeroWalls, L1_80, 150Hz",
// // "sigma subtracted, L1_36, 163Hz",
// // "1x1 jets, L1_36, 167Hz",
// // "2x2 jets, L1_88, 155Hz"};
// // const Double_t L1_THRESHOLD[INPUTFILES] = {80, 36, 36, 64};
// TString outFileTag = "Photon502_60GeV";
// TString inFileName[INPUTFILES] = {"hist_Photon502_isophoton_regions.root",
// "hist_Photon502_isophotons_eta1.44_2x2jets.root",
// "hist_Photon502_isophotons_eta1.44_3x3jets.root",
// "hist_Photon502_isophotons_noHoEorFG_emcands.root"};
// TString labels[INPUTFILES] = {"Single Regions 50GeV, |#eta| < 1.74",
// "2x2 Jets 48GeV, |#eta| < 1.74",
// "3x3 Jets 48GeV, |#eta| < 1.74",
// "EG cands 50GeV"};
// const Double_t L1_THRESHOLD[INPUTFILES] = {50, 48, 48,50};
TString outFileTag = "Photon502_40GeV";
TString inFileName[INPUTFILES] = {"hist_Photon502_isophoton_regions.root",
"hist_Photon502_isophotons_eta1.44_2x2jets.root",
"hist_Photon502_isophotons_eta1.44_3x3jets.root",
"hist_Photon502_isophotons_noHoEorFG_emcands.root"};
TString labels[INPUTFILES] = {"Single Regions 20GeV, |#eta| < 1.74",
"2x2 Jets 24GeV, |#eta| < 1.74",
"3x3 Jets 28GeV, |#eta| < 1.74",
"EG cands 32GeV"};
const Double_t L1_THRESHOLD[INPUTFILES] = {20, 24, 28,32};
TFile *inFile[INPUTFILES];
const Int_t COLORS[INPUTFILES] = {kBlack, kRed, kBlue, kGreen+3};//, kMagenta+3};
TGraphAsymmErrors *asymm[INPUTFILES];//[2];
for(int i = 0; i < INPUTFILES; i++)
{
//for(int j = 0; j < 2; j++)
{
inFile[i] = TFile::Open(inFileName[i]);
asymm[i] = (TGraphAsymmErrors*)inFile[i]->Get(Form("asymm_pt_%d_0",(int)L1_THRESHOLD[i]));
asymm[i]->SetMarkerColor(COLORS[i]);
asymm[i]->SetLineColor(COLORS[i]);
}
//asymm[i][1]->SetMarkerStyle(25);
}
// these values MUST MATCH those used in makeTurnOn.C
const int nBins = 75;
const double maxPt = 200;
TH1D *hEmpty = new TH1D("hEmpty",Form(";Isolated Photon p_{T} (GeV);Efficiency"),nBins,0,maxPt);
TCanvas *c1 = new TCanvas();
hEmpty->SetMinimum(0);
hEmpty->SetMaximum(1.2);
hEmpty->Draw();
//c1->SetLogy();
TLine *line = new TLine(0,1,maxPt,1);
line->Draw();
for(int i = 0; i < INPUTFILES; i++)
{
//for(int j = 0; j < 2; j++)
{
asymm[i]->Draw("p");
}
}
TLegend *leg = new TLegend(0.55,0.2,0.9,0.5,"|#eta| < 1.44");
leg->SetFillColor(0);
leg->SetTextFont(42);
leg->SetTextSizePixels(18);
for(int i = 0; i < INPUTFILES; i++)
{
//for(int j = 0; j < 2; j++)
{
leg->AddEntry(asymm[i], Form("%s", labels[i].Data()), "lp");
}
}
leg->Draw();
c1->SaveAs(Form("%s_turnon.pdf",outFileTag.Data()));
}
void PtSpectraCombination_StagedNormalization_EtaCM_P08_P13_NoOLDAlignmentRuns_CombpPbPbp()
{
gROOT->Reset();
gROOT->ProcessLine(".x rootlogonChristof.C");
gROOT->ForceStyle();
gStyle->SetPalette(1);
gStyle->SetTitleYOffset(1.27);
gStyle->SetOptFit(0000);
// gStyle->SetPadRightMargin(0.16);
bool doSave = true;
TFile *f_minbias_pPb = new TFile("CombineSpectra_minbias_EtaCM_P08_P13_NoOLDAlignmentRuns.root");
TFile *f_FullTrack_12_pPb = new TFile("CombineSpectra_FullTrackTrigger_Track12_EtaCM_P08_P13_NoOLDAlignmentRuns.root");
TFile *f_FullTrack_20_pPb = new TFile("CombineSpectra_FullTrackTrigger_Track20_EtaCM_P08_P13_NoOLDAlignmentRuns.root");
TFile *f_FullTrack_30_pPb = new TFile("CombineSpectra_FullTrackTrigger_Track30_EtaCM_P08_P13_NoOLDAlignmentRuns.root");
TFile *f_minbias_Pbp = new TFile("ReverseBeam/CombineSpectra_minbias_EtaCM_M08_M13.root");
TFile *f_FullTrack_12_Pbp = new TFile("ReverseBeam/CombineSpectra_FullTrackTrigger_Track12_EtaCM_M08_M13.root");
TFile *f_FullTrack_20_Pbp = new TFile("ReverseBeam/CombineSpectra_FullTrackTrigger_Track20_EtaCM_M08_M13.root");
TFile *f_FullTrack_30_Pbp = new TFile("ReverseBeam/CombineSpectra_FullTrackTrigger_Track30_Track50_EtaCM_M08_M13.root");
TFile *f_out = new TFile("PtSpectraCombination_StagedNormalization_EtaCM_P08_P13_NoOLDAlignmentRuns_CombpPbPbp_TrackTrigger.root","recreate");
//Get spectra
TH1D* hPartPt_minbias_corrected_pPb = (TH1D*)f_minbias_pPb->Get("hPartPt_minbias_trkCorr_trigCorr");
TH1D* hPartPt_0_14_minbias_corrected_pPb = (TH1D*)f_minbias_pPb->Get("hPartPt_0_14_minbias_trkCorr_trigCorr");
TH1D* hPartPt_14_22_FullTrack12_corrected_pPb = (TH1D*)f_FullTrack_12_pPb->Get("hPartPt_FullTrack12_14_22_trkCorr_trigCorr");
TH1D* hPartPt_22_32_FullTrack20_corrected_pPb = (TH1D*)f_FullTrack_20_pPb->Get("hPartPt_FullTrack20_22_32_trkCorr_trigCorr");
TH1D* hPartPt_32_X_FullTrack30_corrected_pPb = (TH1D*)f_FullTrack_30_pPb->Get("hPartPt_FullTrack30_SpectComb_trkCorr_trigCorr");
TH1D* hPartPt_minbias_corrected_Pbp = (TH1D*)f_minbias_Pbp->Get("hPartPt_minbias_trkCorr_trigCorr");
TH1D* hPartPt_0_14_minbias_corrected_Pbp = (TH1D*)f_minbias_Pbp->Get("hPartPt_0_14_minbias_trkCorr_trigCorr");
TH1D* hPartPt_14_22_FullTrack12_corrected_Pbp = (TH1D*)f_FullTrack_12_Pbp->Get("hPartPt_FullTrack12_14_22_trkCorr_trigCorr");
TH1D* hPartPt_22_32_FullTrack20_corrected_Pbp = (TH1D*)f_FullTrack_20_Pbp->Get("hPartPt_FullTrack20_22_32_trkCorr_trigCorr");
TH1D* hPartPt_32_X_FullTrack30_corrected_Pbp = (TH1D*)f_FullTrack_30_Pbp->Get("hPartPt_FullTrack30_SpectComb_trkCorr_trigCorr");
TH1D* hPartPt_minbias_corrected = (TH1D*)hPartPt_minbias_corrected_pPb->Clone("hPartPt_minbias_corrected"); hPartPt_minbias_corrected->Add(hPartPt_minbias_corrected_Pbp);
TH1D* hPartPt_0_14_minbias_corrected = (TH1D*)hPartPt_0_14_minbias_corrected_pPb->Clone("hPartPt_0_14_minbias_corrected"); hPartPt_0_14_minbias_corrected->Add(hPartPt_0_14_minbias_corrected_Pbp);
TH1D* hPartPt_14_22_FullTrack12_corrected = (TH1D*)hPartPt_14_22_FullTrack12_corrected_pPb->Clone("hPartPt_14_22_FullTrack12_corrected"); hPartPt_14_22_FullTrack12_corrected->Add(hPartPt_14_22_FullTrack12_corrected_Pbp);
TH1D* hPartPt_22_32_FullTrack20_corrected = (TH1D*)hPartPt_22_32_FullTrack20_corrected_pPb->Clone("hPartPt_22_32_FullTrack20_corrected"); hPartPt_22_32_FullTrack20_corrected->Add(hPartPt_22_32_FullTrack20_corrected_Pbp);
TH1D* hPartPt_32_X_FullTrack30_corrected = (TH1D*)hPartPt_32_X_FullTrack30_corrected_pPb->Clone("hPartPt_32_X_FullTrack30_corrected"); hPartPt_32_X_FullTrack30_corrected->Add(hPartPt_32_X_FullTrack30_corrected_Pbp);
/*
hPartPt_0_14_minbias_corrected_pPb->SetBinContent(hPartPt_0_14_minbias_corrected_pPb->FindBin(103.24),0);//Remove muon event
hPartPt_0_14_minbias_corrected_pPb->SetBinError(hPartPt_0_14_minbias_corrected_pPb->FindBin(103.24),0);//Remove muon event
hPartPt_minbias_corrected_pPb->SetBinContent(hPartPt_minbias_corrected_pPb->FindBin(103.24),0);//Remove muon event
hPartPt_minbias_corrected_pPb->SetBinError(hPartPt_minbias_corrected_pPb->FindBin(103.24),0);//Remove muon event
*/
//Get number of events
TH1D* hNumEv_minbias_pPb = (TH1D*)f_minbias_pPb->Get("hNumEv_minbias_trigCorr");
TH1D* hNumEv_0_14_minbias_pPb = (TH1D*)f_minbias_pPb->Get("hNumEv_0_14_minbias_trigCorr");
TH1D* hNumEv_14_22_minbias_pPb = (TH1D*)f_minbias_pPb->Get("hNumEv_14_22_minbias_trigCorr");
TH1D* hNumEv_14_22_FullTrack12_pPb = (TH1D*)f_FullTrack_12_pPb->Get("hNumEv_FullTrack12_14_22_trigCorr");
TH1D* hNumEv_22_32_FullTrack12_pPb = (TH1D*)f_FullTrack_12_pPb->Get("hNumEv_FullTrack12_22_32_trigCorr");
TH1D* hNumEv_22_32_FullTrack20_pPb = (TH1D*)f_FullTrack_20_pPb->Get("hNumEv_FullTrack20_22_32_trigCorr");
TH1D* hNumEv_32_X_FullTrack20_pPb = (TH1D*)f_FullTrack_20_pPb->Get("hNumEv_FullTrack20_32_X_trigCorr");
TH1D* hNumEv_32_X_FullTrack30_pPb = (TH1D*)f_FullTrack_30_pPb->Get("hNumEv_FullTrack30_32_X_trigCorr");
TH1D* hNumEv_minbias_Pbp = (TH1D*)f_minbias_Pbp->Get("hNumEv_minbias_trigCorr");
TH1D* hNumEv_0_14_minbias_Pbp = (TH1D*)f_minbias_Pbp->Get("hNumEv_0_14_minbias_trigCorr");
TH1D* hNumEv_14_22_minbias_Pbp = (TH1D*)f_minbias_Pbp->Get("hNumEv_14_22_minbias_trigCorr");
TH1D* hNumEv_14_22_FullTrack12_Pbp = (TH1D*)f_FullTrack_12_Pbp->Get("hNumEv_FullTrack12_14_22_trigCorr");
TH1D* hNumEv_22_32_FullTrack12_Pbp = (TH1D*)f_FullTrack_12_Pbp->Get("hNumEv_FullTrack12_22_32_trigCorr");
TH1D* hNumEv_22_32_FullTrack20_Pbp = (TH1D*)f_FullTrack_20_Pbp->Get("hNumEv_FullTrack20_22_32_trigCorr");
TH1D* hNumEv_32_X_FullTrack20_Pbp = (TH1D*)f_FullTrack_20_Pbp->Get("hNumEv_FullTrack20_32_X_trigCorr");
TH1D* hNumEv_32_X_FullTrack30_Pbp = (TH1D*)f_FullTrack_30_Pbp->Get("hNumEv_FullTrack30_32_X_trigCorr");
TH1D* hNumEv_minbias = (TH1D*)hNumEv_minbias_pPb->Clone("hNumEv_minbias"); hNumEv_minbias->Add(hNumEv_minbias_Pbp);
TH1D* hNumEv_0_14_minbias = (TH1D*)hNumEv_0_14_minbias_pPb->Clone("hNumEv_0_14_minbias"); hNumEv_0_14_minbias->Add(hNumEv_0_14_minbias_Pbp);
TH1D* hNumEv_14_22_minbias = (TH1D*)hNumEv_14_22_minbias_pPb->Clone("hNumEv_14_22_minbias"); hNumEv_14_22_minbias->Add(hNumEv_14_22_minbias_Pbp);
TH1D* hNumEv_14_22_FullTrack12 = (TH1D*)hNumEv_14_22_FullTrack12_pPb->Clone("hNumEv_14_22_FullTrack12"); hNumEv_14_22_FullTrack12->Add(hNumEv_14_22_FullTrack12_Pbp);
TH1D* hNumEv_22_32_FullTrack12 = (TH1D*)hNumEv_22_32_FullTrack12_pPb->Clone("hNumEv_22_32_FullTrack12"); hNumEv_22_32_FullTrack12->Add(hNumEv_22_32_FullTrack12_Pbp);
TH1D* hNumEv_22_32_FullTrack20 = (TH1D*)hNumEv_22_32_FullTrack20_pPb->Clone("hNumEv_22_32_FullTrack20"); hNumEv_22_32_FullTrack20->Add(hNumEv_22_32_FullTrack20_Pbp);
TH1D* hNumEv_32_X_FullTrack20 = (TH1D*)hNumEv_32_X_FullTrack20_pPb->Clone("hNumEv_32_X_FullTrack20"); hNumEv_32_X_FullTrack20->Add(hNumEv_32_X_FullTrack20_Pbp);
TH1D* hNumEv_32_X_FullTrack30 = (TH1D*)hNumEv_32_X_FullTrack30_pPb->Clone("hNumEv_32_X_FullTrack30"); hNumEv_32_X_FullTrack30->Add(hNumEv_32_X_FullTrack30_Pbp);
float numev_minbias = hNumEv_minbias->GetBinContent(1);
float numev_0_14_minbias = hNumEv_0_14_minbias->GetBinContent(1);
float numev_14_22_minbias = hNumEv_14_22_minbias->GetBinContent(1);
float numev_14_22_FullTrack12 = hNumEv_14_22_FullTrack12->GetBinContent(1);
float numev_22_32_FullTrack12 = hNumEv_22_32_FullTrack12->GetBinContent(1);
float numev_22_32_FullTrack20 = hNumEv_22_32_FullTrack20->GetBinContent(1);
float numev_32_X_FullTrack20 = hNumEv_32_X_FullTrack20->GetBinContent(1);
float numev_32_X_FullTrack30 = hNumEv_32_X_FullTrack30->GetBinContent(1);
std::cerr<<" Number of minbias events in the normalization classes:" << std::endl;
std::cerr<<" All : " << numev_minbias << std::endl;
std::cerr<<" 0-14 MB : " << numev_0_14_minbias << std::endl;
std::cerr<<" 14-22 MB : " << numev_14_22_minbias << std::endl;
std::cerr<<" 14-22 T12: " << numev_14_22_FullTrack12 << std::endl;
std::cerr<<" 22-32 T12: " << numev_22_32_FullTrack12 << std::endl;
std::cerr<<" 22-32 T20: " << numev_22_32_FullTrack20 << std::endl;
std::cerr<<" 32-X T20: " << numev_32_X_FullTrack20 << std::endl;
std::cerr<<" 32-X T30: " << numev_32_X_FullTrack30 << std::endl;
std::cerr<<" numev_minbias/numev_0_14_minbias: " << 100.*numev_minbias/numev_0_14_minbias << "%" << std::endl;
std::cerr<<" numev_14_22_minbias/numev_0_14_minbias: " << 100.*numev_14_22_minbias/numev_0_14_minbias << "%" << std::endl;
std::cerr<<" numev_14_22_FullTrack12/numev_22_32_FullTrack12: " << 100.*numev_14_22_FullTrack12/numev_22_32_FullTrack12 << std::endl;
//Prepare the individual normalizations
float norm_0_14_minbias = numev_minbias;
float norm_14_22_FullTrack12 = norm_0_14_minbias*numev_14_22_FullTrack12/numev_14_22_minbias;
// float norm_14_22_FullTrack12 = numev_14_22_FullTrack12*2466.480;
float norm_22_32_FullTrack20 = norm_14_22_FullTrack12*numev_22_32_FullTrack20/numev_22_32_FullTrack12;
float norm_32_X_FullTrack30 = norm_22_32_FullTrack20*numev_32_X_FullTrack30/numev_32_X_FullTrack20;
std::cerr<<"Normalization factors:" << std::endl;
std::cerr<<" norm_0_14_minbias : " << norm_0_14_minbias << std::endl;
std::cerr<<" norm_14_22_FullTrack12: " << norm_14_22_FullTrack12 << std::endl;
std::cerr<<" norm_22_32_FullTrack20: " << norm_22_32_FullTrack20 << std::endl;
std::cerr<<" norm_32_X_FullTrack30 : " << norm_32_X_FullTrack30 << std::endl;
hPartPt_minbias_corrected->Scale(1./numev_minbias);
hPartPt_0_14_minbias_corrected->Scale(1./norm_0_14_minbias);
hPartPt_14_22_FullTrack12_corrected->Scale(1./norm_14_22_FullTrack12);
hPartPt_22_32_FullTrack20_corrected->Scale(1./norm_22_32_FullTrack20);
hPartPt_32_X_FullTrack30_corrected->Scale(1./norm_32_X_FullTrack30);
TCanvas *c1 = new TCanvas("c1","c1");
c1->cd();
c1->SetLogy();
hPartPt_0_14_minbias_corrected->GetXaxis()->CenterTitle();
hPartPt_0_14_minbias_corrected->GetYaxis()->CenterTitle();
hPartPt_0_14_minbias_corrected->GetXaxis()->SetTitle("p_{T} [GeV/c]");
hPartPt_0_14_minbias_corrected->GetYaxis()->SetTitle("1/N_{ev} dN/dp_{T} (|#eta_{CM}|<1)");
// hPartPt_0_14_minbias_corrected->SetNdivisions(505);
hPartPt_0_14_minbias_corrected->SetMarkerColor(42);
hPartPt_0_14_minbias_corrected->SetLineColor(42);
hPartPt_0_14_minbias_corrected->SetMarkerStyle(34);
hPartPt_0_14_minbias_corrected->SetMinimum(1e-11);
hPartPt_0_14_minbias_corrected->SetFillColor(42);
// hPartPt_0_14_minbias_corrected->SetFillStyle(3305);
hPartPt_0_14_minbias_corrected->Draw("hist");
hPartPt_minbias_corrected->SetMarkerStyle(20);
hPartPt_minbias_corrected->Draw("same");
hPartPt_14_22_FullTrack12_corrected->SetMarkerColor(2);
hPartPt_14_22_FullTrack12_corrected->SetLineColor(2);
hPartPt_14_22_FullTrack12_corrected->SetMarkerStyle(20);
hPartPt_14_22_FullTrack12_corrected->SetFillColor(2);
hPartPt_14_22_FullTrack12_corrected->SetFillStyle(3002);
hPartPt_14_22_FullTrack12_corrected->Draw("same");
hPartPt_22_32_FullTrack20_corrected->SetMarkerColor(4);
hPartPt_22_32_FullTrack20_corrected->SetLineColor(4);
hPartPt_22_32_FullTrack20_corrected->SetMarkerStyle(20);
// hPartPt_22_32_FullTrack20_corrected->SetFillColor(2);
// hPartPt_22_32_FullTrack20_corrected->SetFillStyle(3002);
hPartPt_22_32_FullTrack20_corrected->Draw("samehist");
hPartPt_32_X_FullTrack30_corrected->SetMarkerColor(2);
hPartPt_32_X_FullTrack30_corrected->SetLineColor(2);
hPartPt_32_X_FullTrack30_corrected->SetMarkerStyle(20);
// hPartPt_32_X_FullTrack30_corrected->SetFillColor(2);
// hPartPt_32_X_FullTrack30_corrected->SetFillStyle(3002);
hPartPt_32_X_FullTrack30_corrected->Draw("samehist");
//Sum
TH1D * hSumPartPt = (TH1D*)hPartPt_0_14_minbias_corrected->Clone("hSumPartPt");
hSumPartPt->Add(hPartPt_14_22_FullTrack12_corrected);
hSumPartPt->Add(hPartPt_22_32_FullTrack20_corrected);
hSumPartPt->Add(hPartPt_32_X_FullTrack30_corrected);
hSumPartPt->SetMarkerStyle(25);
hSumPartPt->SetMarkerColor(1);
hSumPartPt->SetLineColor(1);
hSumPartPt->Draw("same");
TLegend *leg1 = new TLegend(0.48,0.47,0.93,0.95,NULL,"brNDC");
leg1->AddEntry(hPartPt_minbias_corrected,"MinBias, inclusive","pl");
leg1->AddEntry(hPartPt_0_14_minbias_corrected,"MinBias, p_{T}<14 GeV/c","f");
leg1->AddEntry(hPartPt_14_22_FullTrack12_corrected,"FullTrack12, 14<p_{T}<22 GeV/c","pl");
leg1->AddEntry(hPartPt_22_32_FullTrack20_corrected,"FullTrack20, 22<p_{T}<32 GeV/c","l");
leg1->AddEntry(hPartPt_32_X_FullTrack30_corrected,"FullTrack30, 32<p_{T} GeV/c","l");
leg1->AddEntry(hSumPartPt,"Combined spectrum","pl");
leg1->SetFillStyle(0);
leg1->SetFillColor(0);
leg1->SetBorderSize(0);
leg1->Draw();
if(doSave) {
c1->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_P08_P13_NoOLDAlignmentRuns_CombpPbPbp_c1.gif");
c1->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_P08_P13_NoOLDAlignmentRuns_CombpPbPbp_c1.eps");
c1->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_P08_P13_NoOLDAlignmentRuns_CombpPbPbp_c1.C");
}
TCanvas *c2 = new TCanvas("c2","c2");
c2->cd();
TH1D *hSumPartPt_copy1 = (TH1D*)hSumPartPt->Clone("hSumPartPt_copy1");
hSumPartPt_copy1->Divide(hPartPt_minbias_corrected);
hSumPartPt_copy1->GetYaxis()->SetTitle("Combined spectrum / MB inclusive");
hSumPartPt_copy1->Draw();
TLatex *inf1 = new TLatex(0.33,0.17,"Combined spectrum: from track triggers");
inf1->SetNDC();
inf1->SetTextSize(0.035);
inf1->Draw();
TPad *c2_zoom = new TPad("c2_zoom","c2_zoom",0.56,0.56,0.94,0.93);
c2_zoom->SetFillStyle(0);
c2_zoom->SetLogx();
c2_zoom->Draw();
c2_zoom->cd();
TH1D *hSumPartPt_copy2 = (TH1D*)hSumPartPt_copy1->Clone("hSumPartPt_copy2");
hSumPartPt_copy2->GetXaxis()->CenterTitle();
hSumPartPt_copy2->GetYaxis()->CenterTitle();
hSumPartPt_copy2->GetXaxis()->SetTitle("p_{T} [GeV/c]");
hSumPartPt_copy2->GetYaxis()->SetTitle("Combined spectrum / MB inclusive ");
hSumPartPt_copy2->GetXaxis()->SetRangeUser(0.,18.);
hSumPartPt_copy2->SetMinimum(0.95);
hSumPartPt_copy2->SetMaximum(1.05);
hSumPartPt_copy2->Draw();
if(doSave) {
c2->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_P08_P13_NoOLDAlignmentRuns_CombpPbPbp_c2.gif");
c2->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_P08_P13_NoOLDAlignmentRuns_CombpPbPbp_c2.eps");
c2->SaveAs("Figs/PtSpectraCombination_StagedNormalization_EtaCM_P08_P13_NoOLDAlignmentRuns_CombpPbPbp_c2.C");
}
/*
TLegend *leg2 = new TLegend(0.80,0.75,0.95,0.95,NULL,"brNDC");
leg2->AddEntry(hPartPt_Jet40_copy1,"Jet40","pl");
leg2->AddEntry(hPartPt_Jet60_copy1,"Jet60","pl");
leg2->AddEntry(hPartPt_Jet80_copy1,"Jet80","pl");
leg2->AddEntry(hPartPt_Jet100_copy1,"Jet100","pl");
leg2->SetFillStyle(0);
leg2->SetFillColor(0);
leg2->SetBorderSize(0);
leg2->Draw();
*/
f_out->cd();
hSumPartPt->Write();
f_out->Close();
}
void dumpStg6Results(string inFile,string outFile, int nEvents = 0,bool useRBM = 1,double theta2Cut = 0.03, bool NoFromStg5 = true,string Stg5Path = "/data/veritas/bzitzer/bootes_1/data/root/")
{
gROOT->SetBatch(true);
TH1D* hSigRF = new TH1D("SigDistRF","Significance Distrbution RF",50,-5,5);
TH1D* hSigCBG = new TH1D("SigDistCBG","Significance Distrbution CBG",50,-5,5);
// Opening files and getting VEGAS objects:
TFile* f = new TFile(inFile.c_str(),"READ");
if(!f->IsOpen() )
{
cerr << "Problem opening ROOT file!" << endl;
return;
}
TTree* EventTree = (TTree*)gDirectory->Get("EventStatsTree");
if( EventTree == NULL )
{
cout << "No Event Tree!" << endl;
return;
}
TTree* RunTree = (TTree*)gDirectory->Get("RunStatsTree");
if( RunTree == NULL )
{
cout << "No Run Tree!" << endl;
return;
}
VASkyMap* vaMapOn = (VASkyMap*)gDirectory->Get("RingBackgroundModelAnalysis/SkyMapOn");
VASkyMap* vaMapAlpha = (VASkyMap*)gDirectory->Get("RingBackgroundModelAnalysis/fAlphaMap");
VACoordinatePair onCenter = vaMapOn->GetCenter();
VACoordinatePair eventCoord;
VACoordinatePair trackCoord;
VACoordinatePair fRootCoord;
VACoordinatePair sourceCoord;
// --------------------
// Exclusion regions:
// --------------------
TDirectory* RBMExclusion = (TDirectory*)gDirectory->Get("RingBackgroundModelAnalysis/ExclusionRegions");
if( RBMExclusion == NULL )
{
cerr << "Problem loading the RBM exclusion directory!" << endl;
return;
}
int nRegions = RBMExclusion->GetNkeys();
VASkyMapExclusionRegion* hSourceExclusion;
const int tmp = nRegions;
VASkyMapExclusionRegion* exclList[tmp];
vector<VASkyMapExclusionRegion*> vaSourceExcl;
TIter next(RBMExclusion->GetListOfKeys());
TKey *key;
int i=0;
while(key=(TKey*)next())
{
hSourceExclusion = (VASkyMapExclusionRegion*)RBMExclusion->FindObjectAny(key->GetName())->Clone();
if( hSourceExclusion != NULL)
{
if( hSourceExclusion->wasUsed() )
{
cout << i << endl;
exclList[i] = hSourceExclusion;
vaSourceExcl.push_back(hSourceExclusion);
cout << hSourceExclusion->GetName() << endl;
//cout << "Exclusion Center RA: " << hSourceExclusion->center().getRA_J2000_Deg() << endl;
cout << "Exclusion Center RA: " << exclList[i]->center().getRA_J2000_Deg() << endl;
cout << "Exclusion Center Dec: " << hSourceExclusion->center().getDec_J2000_Deg() << endl;
cout << "Exclusion Radius: " << hSourceExclusion->radius_Deg() << endl;
i++;
}
}
}
nRegions = i;
dumpExcl(exclList,nRegions,outFile);
double TelLatRad = 5.52828386357865242e-01;
double TelLongRad = -1.93649167430676461e+00;
Float_t EffArea,EnergyGeV,El,Az;
double RA,Dec;
double RATrack,DecTrack;
double DayNS;
UInt_t MJD;
UInt_t RunID;
Float_t El_track,Az_track;
Float_t El_check,Az_check;
double MJDDbl;
Double_t W;
Double_t liveTime;
Double_t PsiEventTree;
int NumRuns = RunTree->GetEntries();
Bool_t IsOn,IsOff;
double Noise;
Float_t RA_fRoot,Dec_fRoot;
EventTree->SetBranchAddress("RunNum",&RunID);
EventTree->SetBranchAddress("Azimuth",&Az);
EventTree->SetBranchAddress("Elevation",&El);
EventTree->SetBranchAddress("Noise",&Noise);
EventTree->SetBranchAddress("EnergyGeV",&EnergyGeV);
EventTree->SetBranchAddress("TrackingAzimuth",&Az_track);
EventTree->SetBranchAddress("TrackingElevation",&El_track);
EventTree->SetBranchAddress("OnEvent",&IsOn);
EventTree->SetBranchAddress("OffEvent",&IsOff);
EventTree->SetBranchAddress("Weight",&W);
EventTree->SetBranchAddress("Psi",&PsiEventTree);
// EventTree->SetBranchAddress("RA",&RA_fRoot);
// EventTree->SetBranchAddress("Dec",&Dec_fRoot);
EventTree->SetBranchAddress("MJDDbl",&MJDDbl);
EventTree->SetBranchAddress("DayNSDbl",&DayNS);
EventTree->SetBranchAddress("EffectiveArea",&EffArea);
double RASource,DecSource,RAOffset,DecOffset;
double RAError,DecError;
double fSigRF,fSigCBG;
int RunNumRunTree;
RunTree->SetBranchAddress("faLiveTime",&liveTime);
RunTree->SetBranchAddress("fSourceDecDeg",&DecSource);
RunTree->SetBranchAddress("fSourceRADeg",&RASource);
RunTree->SetBranchAddress("fOffsetDecDeg",&DecOffset);
RunTree->SetBranchAddress("fOffsetRADeg",&RAOffset);
RunTree->SetBranchAddress("fSignificance",&fSigRF);
RunTree->SetBranchAddress("faRunNumber",&RunNumRunTree);
// Signficance distributions:
VAAzElRADecXY coord(TelLongRad,TelLatRad);
VATime time;
TGraph* map = new TGraph();
TGraph* trackError = new TGraph();
TH2D* map2 = new TH2D("skymap","raw counts map",100,65,115,100,10,30);
double X,Y;
double XRot,YRot;
double theta;
double RunIDOld = 0;
int j = 0;
int k = 0;
filebuf fb;
fb.open(outFile.c_str(),ios::out);
ostream os(&fb);
TGraph* geffAreaVTime = new TGraph();
if( nEvents == 0 ){ nEvents = EventTree->GetEntries(); }
int NumOnEvents = 0;
int NumOffEvents = 0;
// Stuff to make RBM work;
double upperRadRBM = 0.8;
double lowerRadRBM = 0.6;
double angularSep,psi;
bool IsInExcl;
// Stuff to make zCresent work:
double areaBgRegion = DBL_EPSILON;
double upperRadCres = 0.4;
double lowerRadCres = 0.6;
double areaOnRegion = TMath::TwoPi()*(1.0 - TMath::Cos(TMath::Sqrt(theta2Cut)*TMath::DegToRad())); // rad^2
areaOnRegion *= pow(TMath::RadToDeg(),2.0); // deg^2
//double areaOnRegion = TMath::Pi()*theta2Cut;
double wobOffset;
// vaStage6 Generalized LiMa calc stuff:
vector<double> Non;
vector<double> Noff;
vector<double> Alpha;
vector<double> ExpOn;
vector<double> ExpOff;
vector<int> RunIDVec;
vector<double> SigmaVec;
int NumRuns = 0;
// header
os << "RunID LiveTime(min) Time(MJD) RA Dec RA_track Dec_track Energy(GeV) IsOn Weight Elevation Azimuth Noise Offset" << endl;
os << "----------------------------------------------------------------------------------------------------------" << endl;
cout.precision(12);
os.precision(7);
double AvgNoiseFromStg5;
for(int i=0; i<nEvents; i++)
{
EventTree->GetEntry(i);
if(i%1000==0)
cout << "On Event: " << i << " of " << nEvents <<endl;
if(RunID != RunIDOld)
{
// A new run has started:
if(RunIDOld != 0)
{
Non.push_back(NumOnEvents);
Noff.push_back(NumOffEvents);
ExpOn.push_back(liveTime/60);
ExpOff.push_back(liveTime/60);
Alpha.push_back(areaOnRegion/areaBgRegion);
cout << RunIDOld << " Non: " << NumOnEvents << " Noff: " << NumOffEvents << " Alpha: " << areaOnRegion/areaBgRegion << " Exp: " << liveTime/60 << endl;
fSigCBG = lima(NumOnEvents,NumOffEvents,areaOnRegion/areaBgRegion);
SigmaVec.push_back(fSigCBG);
RunIDVec.push_back(RunIDOld);
hSigCBG->Fill(fSigCBG);
NumOnEvents = 0;
NumOffEvents = 0;
}
RunTree->GetEntry(j);
if(RunID != RunNumRunTree)
{
cout << "Run mis-match! " << endl;
cout << " Event Tree thinks it is run number: " << RunID << endl;
cout << " Run Tree thinks it is run number: " << RunNumRunTree << endl;
}
j++;
hSigRF->Fill(fSigRF);
cout << fSigRF << endl;
// RASource, RAOffset in Deg
if(NoFromStg5 == true)
AvgNoiseFromStg5 = getAvgPedVar(RunID,Stg5Path);
// I confess to a bit of a Kludge here:
coord.setRASource2000((RASource + RAOffset)*TMath::DegToRad());
coord.setDecSource2000((DecSource + DecOffset)*TMath::DegToRad());
sourceCoord.setCoordinates_Deg(RASource,DecSource,2);
cout << RunID << " " << liveTime << " " << RASource << " " << DecSource << " " << RAOffset << " " << DecOffset << endl;
}
time.setFromMJDDbl(MJDDbl);
// --------------------
// Coordinate transforms:
// --------------------
// Az,El already in radians
coord.AzEl2RADec2000(Az,El,time,RA,Dec); // RA,Dec in radians
// Az_track, El_track in degrees
coord.AzEl2RADec2000(Az_track*TMath::DegToRad(),El_track*TMath::DegToRad(),time,RATrack,DecTrack); // RATrack,DecTrack in radians
coord.AzElToXY(Az,El,time,RASource*TMath::DegToRad(),DecSource*TMath::DegToRad(),X,Y);
coord.AzElToXY(Az,El,time,X,Y);
// coord.XY2RADec2000(X,Y,time,RA,Dec);
coord.Derotate(time,X,Y,RATrack*TMath::DegToRad(),DecTrack*TMath::DegToRad(),XRot,YRot);
// Flip axis:
//XRot = -1.0*XRot;
// RA Dec in Degrees now
RA *= TMath::RadToDeg();
Dec *= TMath::RadToDeg();
RATrack *= TMath::RadToDeg();
DecTrack *= TMath::RadToDeg();
// RA_fRoot *= TMath::RadToDeg();
// Dec_fRoot *= TMath::RadToDeg();
// RA = XRot + RATrack - RAOffset;
//Dec = YRot + DecTrack - DecOffset;
// RAError = RA - RA_fRoot;
// DecError = Dec - Dec_fRoot;
RAError = RASource - (RATrack - RAOffset);
DecError = DecSource - (DecTrack - DecOffset);
// error corrections:
// RA += RAError;
// Dec += DecError;
RAError *= 3600; //arc sec
DecError *= 3600; // arc sec
coord.RADec2000ToAzEl(RATrack*TMath::DegToRad(),DecTrack*TMath::DegToRad(),time,Az_check,El_check);
// checks in Deg
Az_check*=TMath::RadToDeg();
El_check*=TMath::RadToDeg();
eventCoord.setCoordinates_Deg(RA,Dec,2);
//trackCoord.setCoordinates_Deg(RATrack,DecTrack,2);
trackCoord.setCoordinates_Deg(RASource+RAOffset,DecSource+DecOffset,2);
fRootCoord.setCoordinates_Deg(RA_fRoot,Dec_fRoot,2);
angularSep = onCenter.angularSeparation_Deg(eventCoord);
//psi = trackCoord.angularSeparation_Deg(eventCoord);
theta = sourceCoord.angularSeparation_Deg(eventCoord);
psi = PsiEventTree;
// cout << "dPsi: " << psi - PsiEventTree << endl;
//-------------------------
// Stuff for RBM analysis:
//-------------------------
if(useRBM)
{
IsOff = 0;
IsInExcl = 0;
if(RunID != RunIDOld)
{
//wobOffset = sqrt(pow(DecOffset,2.0)+pow(RAOffset,2.0));
wobOffset = sourceCoord.angularSeparation_Deg(trackCoord);
upperRadCres = wobOffset + sqrt(theta2Cut);
lowerRadCres = wobOffset - sqrt(theta2Cut);
// Segue North Kludge/Hack:
/*
if(TMath::Abs(trackCoord.getRA_J2000_Deg()-151.767) < 0.1 && TMath::Abs(trackCoord.getDec_J2000_Deg()-16.582) < 0.1)
{
cout << "Warning! I think this is a Segue North Run!" << endl;
upperRadCres = 0.5;
}
*/
VASkyMap* vaMapCustom = new VASkyMap("h","h1",sourceCoord,6.0,0.01);
//VASkyMap* vaMapCustom = new VASkyMap("h","h1",trackCoord,6.0,0.01);
vaMapCustom->MakeBinAreaMap();
areaBgRegion = IntegrateBgArea(vaMapCustom,exclList,trackCoord,lowerRadCres,upperRadCres,nRegions);
vaMapCustom->Delete();
cout << "Alpha for Run# " << RunID << " is: " << areaOnRegion/areaBgRegion << endl;
}
//if( lowerRadRBM < angularSep && angularSep < upperRadRBM )
if( lowerRadCres < psi && psi < upperRadCres )
{
for(int m=0; m<nRegions; m++)
{
if( exclList[m]->isWithinRegion(eventCoord) )
IsInExcl = 1;
}
if(!IsInExcl)
{
IsOff = 1;
W = areaOnRegion/areaBgRegion;
}
}
}
// IsOn = reDefOnFlag(sourceCoord,eventCoord,theta2Cut);
if(IsOff || IsOn)
{
map->SetPoint(k,RA,Dec);
trackError->SetPoint(k,RAError,DecError);
if(TMath::Abs(RAError) > 40.0 || TMath::Abs(DecError) > 40.0)
cout << "Warning! Tracking Error large for for: " << RunID << " RA Error: " << RAError << " Dec Error: " << DecError << endl;
k++;
if(IsOn)
{
// if( sqrt((RA - RASource)**2.0 + (Dec - DecSource)**2.0) > sqrt(theta2Cut))
if( theta > sqrt(theta2Cut) )
{
cout << "Theta: " << theta << endl;
}
NumOnEvents++;
}
if(IsOff){ NumOffEvents++; }
// putting needed output into ASCII file
os << RunID << " ";
os << liveTime << " ";
os.precision(12);
os << MJDDbl << " ";
os.precision(9);
os << RA << " ";
os << Dec << " ";
os << RATrack << " ";
os << DecTrack << " ";
os.precision(7);
os << EnergyGeV << " ";
os << IsOn << " ";
os << W << " ";
os << El_track << " ";
os << Az_track << " ";
if(!NoFromStg5)
os << Noise << " ";
else
os << AvgNoiseFromStg5 << " ";
os << psi << " ";
os << endl;
}
RunIDOld = RunID;
}
Non.push_back(NumOnEvents);
Noff.push_back(NumOffEvents);
ExpOn.push_back(liveTime/60);
ExpOff.push_back(liveTime/60);
Alpha.push_back(areaOnRegion/areaBgRegion);
fSigCBG = lima(NumOnEvents,NumOffEvents,areaOnRegion/areaBgRegion);
SigmaVec.push_back(fSigCBG);
RunIDVec.push_back(RunIDOld);
cout << RunIDOld << " Non: " << NumOnEvents << " Noff: " << NumOffEvents << " Alpha: " << areaOnRegion/areaBgRegion << " Exp: " << liveTime/60 << endl;
VAStatisticsUtilitiesAnl* StatAnl = new VAStatisticsUtilitiesAnl(Non,Noff,ExpOn,ExpOff,Alpha);
cout.precision(7);
cout << "Number of ON events: " << sumVector(Non) << endl;
cout << "Number of OFF events: " << sumVector(Noff) << endl;
cout << "Mean Alpha: " << sumVector(Alpha)/Alpha.size() << endl;
cout << "Total Exp Time: " << sumVector(ExpOn) << endl;
cout << "Excess : " << StatAnl->ExcessRate() << " +/- " << StatAnl->ExcessRateError() << endl;
cout << "Generalized LiMa Significance: " << StatAnl->GeneralisedLiMa() << endl;
fb.close();
fb.open("Results.txt",ios::out);
ostream os(&fb);
for(int i=0; i<Non.size(); i++)
{
os << "Results for run# " << RunIDVec.at(i) << endl;
os << " Number of ON events: " << Non.at(i) << endl;
os << " Number of OFF events: " << Noff.at(i) << endl;
os << " Alpha: " << Alpha.at(i) << endl;
os << " Exp Time: " << ExpOn.at(i) << endl;
os << " Significance: " << SigmaVec.at(i) << endl;
os << " " << endl;
}
os << "---------------------------" << endl;
os << "Final Results for all runs:" << endl;
os << " Number of ON events: " << sumVector(Non) << endl;
os << " Number of OFF events: " << sumVector(Noff) << endl;
os << " Mean Alpha: " << calcWeightAvgVector(Alpha,ExpOn) << endl;
os << " Total Exp Time: " << sumVector(ExpOn) << endl;
os << " Excess : " << StatAnl->ExcessRate() << " +/- " << StatAnl->ExcessRateError() << endl;
os << " Generalized LiMa Significance: " << StatAnl->GeneralisedLiMa() << endl;
fb.close();
TCanvas* c1 = new TCanvas();
map->Draw("A*");
TEllipse* drawBg[tmp];
for(int k=0; k<nRegions; k++)
{
drawBg[k] = new TEllipse(exclList[k]->center().getRA_J2000_Deg(),exclList[k]->center().getDec_J2000_Deg(), exclList[k]->radius_Deg(),exclList[k]->radius_Deg());
drawBg[k]->SetLineColor(kBlue);
drawBg[k]->SetFillColor(0);
drawBg[k]->SetFillStyle(0);
drawBg[k]->Draw("same");
}
// ON region:
TEllipse* drawONregion = new TEllipse(RASource,DecSource,sqrt(theta2Cut),sqrt(theta2Cut));
drawONregion->SetLineColor(kRed);
drawONregion->SetFillColor(0);
drawONregion->SetFillStyle(0);
drawONregion->Draw("same");
TCanvas* c2 = new TCanvas();
trackError->GetXaxis()->SetTitle("#delta RA (asec)");
trackError->GetYaxis()->SetTitle("#delta Dec (asec)");
trackError->Draw("A*");
fSigCBG = lima(NumOnEvents,NumOffEvents,areaOnRegion/areaBgRegion);
hSigCBG->Fill(fSigCBG);
TCanvas* c3 = new TCanvas();
TH1F* hSigRBM = (TH1F*)gDirectory->Get("RingBackgroundModelAnalysis/SigDistributionMinusAllExcl");
TLegend* l = new TLegend(0.7,0.7,0.9,0.9);
//hSigRBM->SetDirectory(0);
hSigRF->SetDirectory(0);
hSigCBG->SetDirectory(0);
hSigRF->Scale(1.0/hSigRF->GetEntries());
//hSigRBM->Scale(1.0/hSigRBM->GetEntries());
hSigCBG->Scale(1.0/hSigCBG->GetEntries());
hSigCBG->Draw();
hSigCBG->SetLineColor(kBlue);
hSigRF->Draw("same");
hSigRF->SetLineColor(kBlack);
//hSigRBM->SetLineColor(kRed);
//hSigRBM->Draw("same");
//l->AddEntry(hSigRBM,"Ring Background Model");
l->AddEntry(hSigRF,"Reflected Ring Model");
l->AddEntry(hSigCBG,"Cresent Background Model");
l->Draw("same");
hSigRF->Fit("gaus","LLN");
hSigCBG->Fit("gaus","LLN");
//hSigRBM->Fit("gaus","LLN");
/*
TF1* hFitRF = hSigRF->GetFunction("gaus");
TF1* hFitCBG = hSigRF->GetFunction("gaus");
TF1* hFitRBM = hSigRF->GetFunction("gaus");
hFitRF->Draw("same");
hFitRF->SetLineColor(kBlue);
hFitCBG->Draw("same");
hFitRBM->Draw("same");
hFitRBM->SetLineColor(kRed);
*/
cout << "Number of RF entries: " << hSigRF->GetEntries() << endl;
cout << "Number of CBG entries: " << hSigCBG->GetEntries() << endl;
cout << "CBG Results in Results.txt and Results.root. Remember to rename them!" << endl;
f->Close();
TFile* fOut = new TFile("Results.root","RECREATE");
if(!fOut->IsOpen())
{
cerr << "Problem with output root file!" << endl;
return;
}
//hSigRBM->Write();
hSigRF->Write();
hSigCBG->Write();
c1->Write();
c2->Write();
c3->Write();
fOut->Close();
}
void control(TString var,TString bin, TCut cuts, TCut cutsA, TString cutpoint,bool log,Double_t ymax){
setstyle();
TH1::SetDefaultSumw2(true);
TCanvas *c2 = new TCanvas("canvas"+var+cutpoint,"canname"+var+cutpoint,700,800);
TPad *mainPad = new TPad("","",0.01,0.25,0.99,0.99);
mainPad->SetNumber(1);
mainPad->Draw();
TPad *ratioPad = new TPad("","",0.01,0.01,0.99,0.25);
ratioPad->SetNumber(2);
ratioPad->Draw();
c2->cd(1);
TCut lo = cuts && mu_pt_lo;
TCut hi = cuts && mu_pt_hi;
// TH1D *Ctrl_lo = GetHist("AS",kBlack,var,lo,bin,astQCD,cutpoint);
// TH1D *Sig_lo = GetHist("S",kRed,var,lo,bin,stQCD,cutpoint);
TH1D *Ctrl_hi = GetHist("AS",kBlack,var,cuts,bin,astQCD,cutpoint);
TH1D *Sig_hi = GetHist("S",kRed,var,cuts,bin,stQCD,cutpoint);
// Ctrl_lo->Scale(1.94);
// Sig_lo->Scale(1.94);
TH1D *Ctrl = Ctrl_hi->Clone();
TH1D *Sig = Sig_hi->Clone();
// Ctrl->Add(Ctrl_hi);
// Sig->Add(Sig_hi);
Sig->Scale(intlumi);
// TH1D *Ctrl = GetHist("AS",kBlack,var,cuts,bin,astQCD,cutpoint);
if(Ctrl->Integral()!=0){
Ctrl->Scale(Sig->Integral()/Ctrl->Integral());
}
if(log){ c2->cd(1)->SetLogy();}
TLegend *leg = new TLegend(0.564,0.719,0.775,0.875);
leg->SetTextSize(0.054);
leg->SetFillColor(0);
leg->SetLineColor(0);
// leg->AddEntry(Ctrl,"Anti-Selected","LF");
leg->AddEntry(Sig,"Selected","LF");
leg->AddEntry(Ctrl,"Anti-Selected","LF");
Ctrl->Draw("EHIST9");
Sig->Draw("E9same");
Sig->SetMarkerStyle(20); Sig->SetMarkerColor(kRed);
leg->Draw("same");
Ctrl->SetTitle();
Ctrl->GetXaxis()->SetTitle(var);
if(log){
Ctrl->GetYaxis()->SetRangeUser(0.001,ymax);
}
else{
ymax=(Ctrl->GetMaximum()*1.6);
Ctrl->GetYaxis()->SetRangeUser(0.,ymax);
}
TH1D *RatioBottom = (TH1D*)Ctrl->Clone("Ratiob");
TH1D *RatioTop = (TH1D*)Sig->Clone("Ratiot");
RatioTop->GetYaxis()->SetTitle("Selected / Anti-Selected");
RatioTop->GetXaxis()->SetTitle();
RatioTop->SetTitle();
RatioTop->Divide(RatioBottom);
c2->cd(2);
gPad->SetGridx(); gPad->SetGridy();
RatioTop->SetTitleSize(0.1, "XYZ");
RatioTop->SetTitleOffset(0.55, "X");
RatioTop->SetTitleOffset(0.3, "Y");
RatioTop->SetLabelSize(0.06,"XY");
RatioTop->GetYaxis()->SetRangeUser(-2.,5.0);
RatioTop->SetLineColor(kBlack);
RatioTop->Draw();
TBox *unity = new TBox(RatioTop->GetXaxis()->GetBinLowEdge(RatioTop->GetXaxis()->GetFirst()), 0.79,RatioTop->GetXaxis()->GetBinLowEdge(RatioTop->GetXaxis()->GetLast()), 1.21);
unity->SetLineWidth(2);
unity->SetLineColor(2);
unity->SetFillColor(2);
unity->SetFillStyle(3002);
unity->Draw();
c2->Update();
c2->SaveAs(plots+"SAS_Muon_10to25"+var+"_"+cutpoint+".png");
// c2->Close();
}
void sillyMacro(){
char headerName[1000];
char gpsName[1000];
char corName[1000];
RawAnitaHeader *header =0;
Adu5Pat *pat =0;
Adu5Pat *pat2 =0;
CorrelationSummaryAnita3 *cor=0;
TChain *gpsChain = new TChain("adu5PatTree");
TChain *gpsChain2 = new TChain("adu5PatTree");
TChain *headChain = new TChain("headTree");
TChain *corChain = new TChain("corTree");
for (unsigned int run=331;run<355;++run){
sprintf(headerName,"/unix/anita3/flight1415/root/run%d/timedHeadFile%d.root",run,run);
sprintf(gpsName,"/unix/anita3/flight1415/root/run%d/gpsEvent%d.root",run,run);
sprintf(corName, "/unix/anita3/linda/corTrees/corRun_NEW11_HPOL_%d.root", run);
headChain->Add(headerName);
gpsChain->Add(gpsName);
gpsChain2->Add(gpsName);
corChain->Add(corName);
}
headChain->SetBranchAddress("header",&header);
gpsChain->SetBranchAddress("pat",&pat);
gpsChain2->SetBranchAddress("pat",&pat2);
corChain->SetBranchAddress("cor",&cor);
UInt_t gps_eventNumber;
gpsChain->SetBranchAddress("eventNumber", &gps_eventNumber);
UInt_t gps2_eventNumber;
gpsChain2->SetBranchAddress("eventNumber", &gps2_eventNumber);
headChain->BuildIndex("header->eventNumber");
gpsChain->BuildIndex("eventNumber");
gpsChain2->BuildIndex("pat->realTime");
int maxEntry=corChain->GetEntries();
// AnitaPol::AnitaPol_t pol = AnitaPol::kHorizontal;
AnitaPol::AnitaPol_t pol = AnitaPol::kVertical;
Double_t sourceLat, sourceLon, sourceAlt, timeOffset;
char cpol[100];
Double_t phiWave, thetaWave, lower, upper;
Double_t maxCorrTime, deltaTExpected;
int ant1, ant2;
headChain->GetEntry(0);
double firstTS = header->triggerTime;
headChain->GetEntry(headChain->GetEntries()-1);
double lastTS = header->triggerTime;
Double_t additionalPhi = 22.5*TMath::DegToRad();
Double_t TwoPi = TMath::Pi()*2.;
// TH2D *h1 = new TH2D("h1", "", 100, firstTS, lastTS, 100, 0, 3600*24);
TH2D *h1 = new TH2D("h1", "", 100, firstTS, lastTS, 100, -49.5, 50.5);
TH1D *dHeading = new TH1D("dHeading", "", 100, -5, 5);
for(Long64_t entry=0;entry<maxEntry;++entry) {
corChain->GetEntry(entry);
Long64_t headEntry = headChain->GetEntryNumberWithIndex(cor->eventNumber);
if(headEntry < 0 ) continue;
headChain->GetEntry(headEntry);
Long64_t gpsEntry = gpsChain->GetEntryNumberWithIndex(cor->eventNumber);
if(gpsEntry < 0 ) continue;
gpsChain->GetEntry(gpsEntry);
Long64_t gpsEntry2 = gpsChain2->GetEntryNumberWithIndex(header->triggerTime);
if(gpsEntry2 < 0 ) continue;
gpsChain2->GetEntry(gpsEntry2);
if(gps_eventNumber!=gps2_eventNumber) cout << header->eventNumber << " " << gps2_eventNumber << endl;
// if ((header->triggerTime%(3600*24))!=(pat->timeOfDay/1e3)) cout << header->triggerTime%(3600*24) << " " << pat->timeOfDay/1e3 << endl;
double tday = (header->triggerTime%(3600*24));
h1->Fill(header->triggerTime, (tday - pat->timeOfDay/1e3) );
dHeading->Fill((pat->heading-pat2->heading));
}
h1->Draw("colz");
TCanvas *c1 = new TCanvas("c1");
gStyle->SetOptStat(1);
dHeading->SetTitle("Heading(eventNumber)-heading(realTime);Heading(eventNumber)-heading(realTime) [degrees];Number of events");
dHeading->Draw();
c1->Print("dheading.png");
}
void plotEfficiency_barrelEta() {
TString fbrem = "(Trk_P_Vtx - Trk_P_Out)/Trk_P_Vtx";
TCut PtCut="Pt>10";
TCut EtaCut ="abs(Eta)<2.5";
TCut Signal ="MatchedGen && MatchedGenFromWZ";
TCut Bkg ="(!MatchedGen || (MatchedGen && !MatchedGenFromWZ ))";
TCut barr = "abs(Eta)<1.479";
TCut endc = "abs(Eta)>1.550&&abs(Eta)<2.5";
TCut qcd ="(processID==11 || processID==12 || processID==13 || processID==28 || processID==53 || processID==68)";
TFile *_file2 = TFile::Open("Data/Gumbo/New/Gumbo_All.root");
TTree* g = _file2->Get("ElTree");
TFile *_file1 = TFile::Open("Data/WZ_3l/New/WZCSA07-WZ.root");
TTree* s = _file1->Get("ElTree");
TH1D* h1 = new TH1D("h1", "",50,0,1.5);
TH1D* h2 = new TH1D("h2", "",50,0,1.5);
TH1D* sig = new TH1D("sig","",50,0,1.5);
h1->Sumw2();
h2->Sumw2();
TH1D* b1 = new TH1D("b1", "",50,0,1.5);
TH1D* b2 = new TH1D("b2", "",50,0,1.5);
TH1D* bkg = new TH1D("bkg","",50,0,1.5);
b1->Sumw2();
b2->Sumw2();
TCut sig_preselection = PtCut && Signal && barr;
TCut bkg_preselection = PtCut && Bkg && qcd && barr;
// Barrel- Loose Id
TCut eb_deta = "DeltaEtaVtx < 0.009";
TCut eb_dphi = "DeltaPhiVtx < 0.05";
TCut eb_sEE = "sqrt(CovEtaEta)<0.012";
TCut eb_trkIso = "(IsoKFTrackDR030 - IsoKFTrackDR005)/Pt<0.1";
TCut eb_EseedPout = "ESeed/Trk_P_Out>0.9";
// additional cut for Tight criteria
TCut eb_EmHadIso = "(IsoEmCaloRecHitDR030 + IsoHadCaloRecHitDR030 - ESC)/ESC<0.18";
TCut eb_id = eb_deta && eb_dphi && eb_sEE && eb_trkIso && eb_EseedPout; // && eb_EmHadIso;
s->Draw("Eta>>h1", sig_preselection);
s->Draw("Eta>>h2", sig_preselection && eb_id);
g->Draw("Eta>>b1", "weight"*(bkg_preselection));
g->Draw("Eta>>b2", "weight"*(bkg_preselection && eb_id));
sig->Divide(h2, h1, 1, 1, "B");
bkg->Divide(b2, b1, 1, 1, "B");
sig->SetMarkerColor(2);
sig->SetMarkerStyle(21);
sig->SetMarkerSize(1);
bkg->SetMarkerColor(4);
bkg->SetMarkerStyle(22);
bkg->SetMarkerSize(1);
gStyle->SetOptStat(0);
TH2F* f = new TH2F("f","",1000,0,1.5,1000,0,1);
f->Draw();
f->GetXaxis()->SetTitle("|#eta|");
f->GetYaxis()->SetTitle("Efficiency");
sig->Draw("SAMEE");
bkg->Draw("SAMEE");
TLegend* leg = new TLegend(0.5,0.5,0.8,0.8);
leg->AddEntry(sig, "Signal electron");
leg->AddEntry(bkg, "mis-identified jet (Gumbo)");
leg->SetLineColor(0);
leg->SetBorderSize(0);
leg->Draw();
}
void DrawEfficiency(const char* channel, Int_t selection = 0, Int_t ieff = 7){
gROOT->SetStyle("Plain");
gStyle->SetPalette(1);
gStyle->SetOptStat(0);
gStyle->SetPalette(1);
gStyle->SetCanvasColor(0);
gStyle->SetFrameFillColor(0);
gStyle->SetOptTitle(0);
gSystem->SetIncludePath("-I. -I$ALICE_ROOT/include -I$ROOTSYS/include");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("$ALICE_ROOT/CORRFW/libCORRFW") ;
gSystem->Load("libPWGHFbase");
gSystem->Load("libPWGHFvertexingHF");
Int_t mcAcc_over_mcLimAcc = 0x001;
Int_t recPPR_over_mcAcc = 0x002;
Int_t recPID_over_mcAcc = 0x004;
// pt index
Int_t ipt =0;
Int_t stepNum = -1;
Int_t stepDen = -1;
// Read the container from file
TFile* f = new TFile("AnalysisResults.root");
TString directoryName;
TString containerName;
TString cutName;
TString outfileName;
if (channel == "D0") {
if (selection == 0){
directoryName = "PWG3_D2H_CFtaskD0toKpi";
containerName = "CFHFccontainer0";
cutName = "Cuts";
outfileName = "fileEff_D0_from_c.root";
}
else if (selection == 1){
directoryName = "PWG3_D2H_CFtaskD0toKpiKeepD0fromBOnly";
containerName = "CFHFccontainer0D0fromB";
cutName = "Cuts";
outfileName = "fileEff_D0_from_b.root";
}
else if (selection == 2){
directoryName = "PWG3_D2H_CFtaskD0toKpiKeepD0fromB";
containerName = "CFHFccontainer0allD0";
cutName = "Cuts";
outfileName = "fileEff_D0_from_c_and_b.root";
}
else {
Printf("not a valid selection, return");
return;
}
}
else if (channel == "D0_New"){
if (selection == 0){
directoryName = "PWG3_D2H_CFtaskD0toKpi_NEW";
containerName = "CFHFccontainer0_New";
cutName = "Cuts_New";
//directoryName = "PWG3_D2H_CFtaskD0toKpi_CommonFramework";
//containerName = "CFHFccontainer0_CommonFramework";
//cutName = "Cuts_CommonFramework";
outfileName = "fileEff_D0_CommonFramework_from_c.root";
}
else if (selection == 1){
directoryName = "PWG3_D2H_CFtaskD0toKpiKeepDfromBOnly";
containerName = "CFHFccontainer0DfromB_New";
cutName = "Cuts_New";
//directoryName = "PWG3_D2H_CFtaskD0toKpiKeepDfromBOnly_CommonFramework";
//containerName = "CFHFccontainer0DfromB_CommonFramework";
//cutName = "Cuts_CommonFramework";
outfileName = "fileEff_D0_CommonFramework_from_b.root";
}
else if (selection == 2){
directoryName = "PWG3_D2H_CFtaskD0toKpiKeepDfromB_NEW";
containerName = "CFHFccontainer0allD_New";
cutName = "Cuts_New";
//directoryName = "PWG3_D2H_CFtaskD0toKpiKeepDfromB_CommonFramework";
//containerName = "CFHFccontainer0allD_CommonFramework";
//cutName = "Cuts_CommonFramework";
outfileName = "fileEff_D0_CommonFramework_from_c_and_b.root";
}
else {
Printf("not a valid selection, return");
return;
}
}
else if (channel == "Dplus_New"){
if (selection == 0){
directoryName = "PWG3_D2H_CFtaskDplustoKpipi_NEW";
containerName = "CFHFccontainer0_New_3Prong";
cutName = "Cuts_3Prong";
//directoryName = "PWG3_D2H_CFtaskDplustoKpipi_CommonFramework";
//containerName = "CFHFccontainer0_3Prong_CommonFramework";
//cutName = "Cuts_3Prong_CommonFramework";
outfileName = "fileEff_Dplus_CommonFramework_from_c.root";
}
else if (selection == 1){
directoryName = "PWG3_D2H_CFtaskDplustoKpipiKeepDfromBOnly";
containerName = "CFHFccontainer0DfromB_New_3Prong";
cutName = "Cuts_3Prong";
//directoryName = "PWG3_D2H_CFtaskDplustoKpipiKeepDfromBOnly_CommonFramework";
//containerName = "CFHFccontainer0DfromB_3Prong_CommonFramework";
//cutName = "Cuts_3Prong_CommonFramework";
outfileName = "fileEff_Dplus_CommonFramework_from_b.root";
}
else if (selection == 2){
directoryName = "PWG3_D2H_CFtaskDplustoKpipiKeepDfromB_NEW";
containerName = "CFHFccontainer0allD_New_3Prong";
cutName = "Cuts_3Prong";
//directoryName = "PWG3_D2H_CFtaskDplustoKpipiKeepDfromB_CommonFramework";
//containerName = "CFHFccontainer0allD_3Prong_CommonFramework";
//cutName = "Cuts_3Prong_CommonFramework";
outfileName = "fileEff_Dplus_CommonFramework_from_c_and_b.root";
}
else {
Printf("not a valid selection, return");
return;
}
}
else {
Printf("not a valid channel, return");
return;
}
Printf("Opening file Analysisresults.root");
Printf("Reading Directory \"%s\"",directoryName.Data());
Printf("Getting CF Container \"%s\"",containerName.Data());
Printf("Getting Cut Object \"%s\"",cutName.Data());
TDirectoryFile* d = (TDirectoryFile*)f->Get(directoryName.Data());
if (!d){
Printf("Directory does not exist! Check directory name (%s) in file AnalysisResults.root - returning...", directoryName.Data());
return;
}
AliCFContainer *data = (AliCFContainer*) (d->Get(containerName.Data()));
AliRDHFCuts *cutsRDHF = (AliRDHFCuts*)(d->Get(cutName.Data()));
if (!data){
Printf("Container does not exist! Check container name (%s) in directory %s - returning...", containerName.Data(), directoryName.Data());
return;
}
TFile* fileEff = new TFile(outfileName.Data(), "RECREATE");
TString plotDir(Form("EffPlots/%s",channel));
gSystem->Exec(Form("mkdir EffPlots"));
gSystem->Exec(Form("mkdir %s",plotDir.Data()));
//construct the efficiency grid from the data container
AliCFEffGrid *eff = new AliCFEffGrid("eff"," The efficiency",*data);
TCanvas *ceffpt = new TCanvas("ceffpt","Efficiency vs pt",50,50,550,550);
ceffpt->cd();
ceffpt->SetLeftMargin(0.15);
ceffpt->SetRightMargin(0.05);
TH1D *hpteffCF = 0x0; //the efficiency vs pt
if (ieff & mcAcc_over_mcLimAcc){
AliCFEffGrid *eff = new AliCFEffGrid("eff"," The efficiency",*data);
stepDen = (Int_t)(AliCFTaskVertexingHF::kStepGeneratedLimAcc);
stepNum = (Int_t)(AliCFTaskVertexingHF::kStepAcceptance);
printf("Calculating efficiency for mcAcc_over_mcLimAcc: stepDen = %d, stepNum = %d\n",stepDen,stepNum);
eff->CalculateEfficiency(stepNum,stepDen); //eff= step1/step0
//canvas
ceffpt->cd();
//The efficiency along the variables
hpteffCF = eff->Project(ipt);
SetHistoEff(hpteffCF,8,20,"mcAcc_over_mcLimAcc");
hpteffCF->Draw("hist");
hpteffCF->Draw("err same");
fileEff->cd();
hpteffCF->Write("hpteffCF_mcAcc_over_mcLimAcc");
// printing png files
ceffpt->Print(Form("%s/effpt_mcAcc_over_mcLimAcc.png", plotDir.Data()));
ceffpt->Print(Form("%s/effpt_mcAcc_over_mcLimAcc.eps", plotDir.Data()));
ceffpt->Print(Form("%s/effpt_mcAcc_over_mcLimAcc.gif", plotDir.Data()));
delete eff;
eff = 0x0;
}
if (ieff & recPPR_over_mcAcc){
AliCFEffGrid *eff = new AliCFEffGrid("eff"," The efficiency",*data);
stepDen = (Int_t)(AliCFTaskVertexingHF::kStepAcceptance);
stepNum = (Int_t)(AliCFTaskVertexingHF::kStepRecoPPR);
printf("Calculating efficiency for RecPPR_over_mcAcc: stepDen = %d, stepNum = %d\n",stepDen,stepNum);
eff->CalculateEfficiency(stepNum,stepDen); //eff= step1/step0
//canvas
ceffpt->cd();
//The efficiency along the variables
hpteffCF = eff->Project(ipt);
SetHistoEff(hpteffCF,8,20, "recAnCuts_over_mcAcc");
hpteffCF->Draw("hist");
hpteffCF->Draw("err same");
fileEff->cd();
hpteffCF->Write("hpteffCF_RecAnCut_over_mcAcc");
// printing png files
ceffpt->Print(Form("%s/effpt_RecAnCut_over_mcAcc.png", plotDir.Data()));
ceffpt->Print(Form("%s/effpt_RecAnCut_over_mcAcc.eps", plotDir.Data()));
ceffpt->Print(Form("%s/effpt_RecAnCut_over_mcAcc.gif", plotDir.Data()));
delete eff;
eff = 0x0;
}
if (ieff & recPID_over_mcAcc){
AliCFEffGrid *eff = new AliCFEffGrid("eff"," The efficiency",*data);
stepDen = (Int_t)(AliCFTaskVertexingHF::kStepAcceptance);
stepNum = (Int_t)(AliCFTaskVertexingHF::kStepRecoPID);
printf("Calculating efficiency for RecPID_over_mcAcc: stepDen = %d, stepNum = %d\n",stepDen,stepNum);
eff->CalculateEfficiency(stepNum,stepDen); //eff= step1/step0
//canvas
ceffpt->cd();
//The efficiency along the variables
hpteffCF = eff->Project(ipt);
SetHistoEff(hpteffCF,8,20,"recPID_over_mcAcc");
hpteffCF->Draw("hist");
hpteffCF->Draw("err same");
fileEff->cd();
hpteffCF->Write("hpteffCF_RecPID_over_mcAcc");
// printing png files
ceffpt->Print(Form("%s/effpt_RecPID_over_mcAcc.png", plotDir.Data()));
ceffpt->Print(Form("%s/effpt_RecPID_over_mcAcc.eps", plotDir.Data()));
ceffpt->Print(Form("%s/effpt_RecPID_over_mcAcc.gif", plotDir.Data()));
delete eff;
eff = 0x0;
}
cutsRDHF->Write("Cuts");
// writing single distributions
TH1D *hMCAccpt = data->ShowProjection(ipt, AliCFTaskVertexingHF::kStepAcceptance);
SetHistoDistribution(hMCAccpt, 1, 20);
hMCAccpt->Draw();
TH1D *hMCLimAccpt = data->ShowProjection(ipt, AliCFHeavyFlavourTaskMultiVarMultiStep::kStepGeneratedLimAcc);
SetHistoDistribution(hMCLimAccpt, 4, 20);
TH1D *hRecoAnCutspt = data->ShowProjection(ipt, AliCFTaskVertexingHF::kStepRecoPPR);
SetHistoDistribution(hRecoAnCutspt, 8, 20);
TH1D *hRecoPIDpt = data->ShowProjection(ipt, AliCFTaskVertexingHF::kStepRecoPID);
SetHistoDistribution(hRecoPIDpt, 6, 20);
hMCAccpt->Write("hMCAccpt");
hMCLimAccpt->Write("hMCLimAccpt");
hRecoAnCutspt->Write("hRecoAnCutspt");
hRecoPIDpt->Write("hRecoPIDpt");
// fileEff->Close(); // commented out to see the canvas on the screen....
}
void analyzeEventsSlice(double onDelta = 100.0) {
gStyle->SetOptFit(1);
initialize();
int decodedTDC;
for (Long64_t iEvent=0; iEvent<myTree->GetEntries();iEvent++) {
std::cout << "Processing Event " << iEvent << std::endl;
myTree->GetEntry(iEvent);
decodedTDC = TDC-4;
if (decodedTDC<0) continue;
if (decodedTDC>8) {
std::cerr << "Help, this should not happen" << std::endl;
continue;
}
if (nHits>0) myHistoIntegral[decodedTDC]->Fill(thresh, 1 /* nHits*/ );
//myHistoIntegral[decodedTDC]->Fill(thresh, nHits );
}
TH1D* antani = new TH1D("diff", Form("diffTDC_%f", onDelta), 10, -0.5, 9.5);
bool gotTDC[13];
for (int i=0; i<13; ++i) { gotTDC[i]=false; }
for (int iTDC=0; iTDC<9; ++iTDC) {
double thisVal, prevVal;
double thisX, prevX;
prevVal=0;
prevX=-9999;
bool firstVal = true;
for (int iBin=1; iBin<myHistoIntegral[iTDC]->GetNbinsX(); ++iBin) {
thisVal = myHistoIntegral[iTDC]->GetBinContent(iBin);
thisX = myHistoIntegral[iTDC]->GetXaxis()->GetBinCenter(iBin);
if (thisVal==0) continue;
if (!firstVal) {
addPoint(myGraphDifferential[iTDC],
(thisX+prevX)/2., prevVal-thisVal
, fabs(thisX-prevX)/2., sqrt(prevVal+thisVal));
if (((thisX+prevX)/2.>onDelta)&&(!gotTDC[iTDC])) {
gotTDC[iTDC]=true;
antani->Fill(iTDC, (prevVal-thisVal)/(thisX-prevX));
}
} else firstVal=false;
// myHistoDifferential[iTDC]->SetBinContent(iBin, prevVal-thisVal);
prevVal = thisVal;
prevX = thisX;
}
TCanvas* myCanvas;
//myCanvas = new TCanvas();
//myCanvas->cd();
//myCanvas->SetLogy();
myGraphDifferential[iTDC]->SetMarkerStyle(8);
// myGraphDifferential[iTDC]->Draw("ap");
//edit G. Auzinger: fit distribution for every TDC with a landau in range 30 to 200
// TF1* myLandau = new TF1("fit", "TMath::Landau(x)", 30, 200);
// myGraphDifferential[iTDC]->Fit("landau", "RM+","same", 50, 250);
// myGraphDifferential[iTDC]->Fit(
// myHistoDifferential[iTDC]->Rebin(2);
// myHistoDifferential[iTDC]->Draw();
// myCanvas = new TCanvas();
// myCanvas->SetLogy();
// myHistoIntegral[iTDC]->Draw();
}
new TCanvas();
antani->Draw();
}
void drawRAA(bool doInclusiveJet=0, bool useUnfolded=1, bool drawTheory=1){
bool drawPowheg = 0;
float etalo=-2;
float etahi=2;
TH1D *dEta80To110 = new TH1D("dEta80To110","",4,-2.465,1.535);
TH1D *dEta110To150 = new TH1D("dEta110To150","",4,-2.365,1.635);
TH1D *dEta70To80 = new TH1D("dEta70To80","",4,-2.565,1.435);
TH1D *dEta150To190 = new TH1D("dEta150To190","",4,-2.265,1.735);
int nbins = 3;
double xbins[4] = {0,20,50,100};
double xbins2[4] = {2,22,52,102};
double xbins3[4] = {-2,18,48,98};
double xbins4[4] = {4,24,54,104};
TH1D *dCent70To80 = new TH1D("dCent70To80","",nbins,xbins3);
TH1D *dCent80To110 = new TH1D("dCent80To110","",nbins,xbins);
TH1D *dCent110To150 = new TH1D("dCent110To150","",nbins,xbins2);
TH1D *dCent150To190 = new TH1D("dCent150To190","",nbins,xbins4);
//for(int ieta=-2; ieta<2; ieta++){
// etalo=(float)(ieta+0.5);
// etahi=(float)(ieta+1.5);
int binLo, binHi;
//for(int icent=0; icent<3; icent++){
// if(icent==0){ binLo = 0; binHi=20; }
// if(icent==1){ binLo = 20; binHi=50; }
// if(icent==2){ binLo = 50; binHi=100; }
TH1D *h = new TH1D();
TH1D *h2 = new TH1D();
TH1D *h_den = new TH1D();
h->Sumw2();
h2->Sumw2();
h_den->Sumw2();
TH1D *he1 = new TH1D();
TH1D *he2 = new TH1D();
TH1D *he3 = new TH1D();
TH1D *he4 = new TH1D();
he1->Sumw2(); he2->Sumw2(); he3->Sumw2(); he4->Sumw2();
//grab unfolded histograms from the unfolding output (inclusive)
TFile *f0, *f2, *f5,*f6,*f7,*f8;
TFile *fIncl = new TFile("~/bTagTrees/pPb/raa_pPb_numerator-inc_eta-1.0To1.0.root");
TFile *fInclB = new TFile("~/bTagTrees/pPb/raa_pp_denomForpA-inc_eta-1.0To1.0.root");
TH1D *hinclTop = (TH1D*)fIncl->Get("hReco0")->Clone("hinclTop");
TH1D *hinclBot = (TH1D*)fInclB->Get("hGen_cent1")->Clone("hinclBot");
for(int i=1; i<=hinclTop->GetNbinsX(); i++){
hinclTop->SetBinError(i,hinclTop->GetBinError(i)/hinclTop->GetBinWidth(i));
hinclTop->SetBinContent(i,hinclTop->GetBinContent(i)/hinclTop->GetBinWidth(i));
hinclBot->SetBinError(i,hinclBot->GetBinError(i)/hinclBot->GetBinWidth(i));
hinclBot->SetBinContent(i,hinclBot->GetBinContent(i)/hinclBot->GetBinWidth(i));
}
hinclTop->Scale(1./6.9);
hinclTop->Divide(hinclBot);
hinclTop->SetMarkerColor(4);
//hinclTop->Scale(0.689);
//grab unfolded histograms from the unfolding output (bjet)
if(doInclusiveJet) f0 = new TFile(Form("~/bTagTrees/pPb/raa_pPb_numerator-inc_eta%.1fTo%.1f.root",etalo,etahi));
//else f0 = new TFile(Form("~/bTagTrees/pPb/raa_pPb_numerator-Incljet_FullDataset_ssvhe20_etaCM_v2_bin0_100_eta%.1fTo%.1f.root",etalo,etahi)); //incl jet unfolding
else if(useUnfolded){
f0 = new TFile(Form("~/bTagTrees/pPb/raa_pPb_numerator-Bjet_FullDataset_ssvhe20_etaCM_v2_bin0_100_eta%.1fTo%.1f.root",etalo,etahi)); //bjet unfolding
f5 = new TFile("~/bTagTrees/pPb/raa_pPb_numerator-Bjet_FullDataset_ssvhe20_etaCM_eta-2.0To-1.0.root");
f6 = new TFile("~/bTagTrees/pPb/raa_pPb_numerator-Bjet_FullDataset_ssvhe20_etaCM_eta-1.0To0.0.root");
f7 = new TFile("~/bTagTrees/pPb/raa_pPb_numerator-Bjet_FullDataset_ssvhe20_etaCM_eta0.0To1.0.root");
f8 = new TFile("~/bTagTrees/pPb/raa_pPb_numerator-Bjet_FullDataset_ssvhe20_etaCM_eta1.0To2.0.root");
}
else{
f0 = new TFile(Form("~/bTagTrees/pPb/raa_pPb_numerator-Bjet_NoUnfolding_FullDataset_ssvhe20_etaCM_v2_bin0_100_eta%.1fTo%.1f.root",etalo,etahi));
}
if(useUnfolded){
h = (TH1D*)(f0->Get("hReco0"));
he1 = (TH1D*)(f5->Get("hReco0"));
he2 = (TH1D*)(f6->Get("hReco0"));
he3 = (TH1D*)(f7->Get("hReco0"));
he4 = (TH1D*)(f8->Get("hReco0"));
}
else if(doInclusiveJet) h = (TH1D*)(f0->Get("hIncJetsData"));
else h = (TH1D*)(f0->Get("hReco0"));
//h = (TH1D*)he1->Clone("h");
//he1->Add(he2);
//he1->Add(he3);
//he1->Add(he4);
//h->Scale(1./6.9);
/* for(int i=1; i<=h->GetNbinsX(); i++){
h->SetBinError(i, h->GetBinError(i)/h->GetBinWidth(i));
h->SetBinContent(i, h->GetBinContent(i)/h->GetBinWidth(i));
}*/
//h->Scale(1./6.9); //pPb total N coll (L*pp x-sec * A, sigma_pp = 70 mb @ CERN)
if(doInclusiveJet) f2 = new TFile(Form("~/bTagTrees/pPb/raa_pp_denomForpA-inc_eta%.1fTo%.1f.root",etalo,etahi),"OLD");
else f2 = new TFile(Form("~/bTagTrees/pPb/raa_pp_denomForpA-Bjet_etaCM_v2_bin0_100_eta%.1fTo%.1f.root",etalo,etahi),"OLD"); //incl jet unfolding
//else f2 = new TFile(Form("raa_pp_denomForpA-Bjet_etaLab_eta%.1fTo%.1f.root",etalo,etahi),"OLD"); //bjet unfolding
f2->cd();
//h_den = (TH1D*)(f2->Get("hRawBMC"));
if(useUnfolded) h_den = (TH1D*)f2->Get("hGen_cent1");
else if(doInclusiveJet) h_den = (TH1D*)(f2->Get("hIncJetsMC"));
else h_den = (TH1D*)(f2->Get("hGen_cent1"));
TFile *xchk = new TFile("histos/ppMC_ppReco_akPu3PF_QCDjetTrig_etashift_Fix2Sample_MCWeightFinalWithVz_noTrgSelection_Full.root");
TTree *nt1 = (TTree*)xchk->Get("nt");
double xbinsXchk[19] = {0, 5, 10, 15, 20, 25, 30, 35, 40, 55, 70, 90, 110, 140, 170, 220, 400, 700, 1000};
TH1D *hf = new TH1D("hf","",18,xbinsXchk); hf->Sumw2();
nt1->Project("hf","refpt","weight*(abs(refparton_flavorForB)==5 && jteta<2 && jteta>-2 && jtpt>35 && rawpt>20)");
for(int i=1; i<=hf->GetNbinsX(); i++){
hf->SetBinError(i,hf->GetBinError(i)/hf->GetBinWidth(i));
hf->SetBinContent(i,hf->GetBinContent(i)/hf->GetBinWidth(i));
}
hf->SetLineColor(kRed+2);
//hf->Scale(1E9);
//hf->Scale(1./70.);
//hf->Scale(10.);
//h_den = hf;
TFile *ff = new TFile("pPb_Unfo_inCM_v31_officialMC_ak3PF_akPu3PF_noGplus_FirstHalfOnly_Converged_usedParameterizedUnfold0_jtpt35_bJets_clo0_chi100_v8_eta_-2.00To2.00_.root");
TH1D *hfCheck2 = (TH1D*)ff->Get("hGen_cent1");
TFile *ff2 = new TFile("pPb_Unfo_inCM_v31_officialMC_Reverse_WithResCorr_ak3PF_akPu3PF_noGplus_SecondHalfOnly_Converged_usedParameterizedUnfold0_jtpt35_bJets_clo0_chi100_v8_eta_-2.00To2.00_.root");
TH1D *hfCheck3 = (TH1D*)ff2->Get("hGen_cent1");
hfCheck2->Add(hfCheck3);
//hfCheck2 = (TH1D*)hfCheck2->Rebin(16,hfCheck2->GetName(),xbinsXchk);
//Fix raw B MC histogram to have 14 bins to be compatible with the unfolded nonsense
/*const int fixNbin = h->GetNbinsX();
Double_t binBoundaries[15];
for(int ibin=0; ibin<fixNbin; ibin++){
binBoundaries[ibin] = h->GetBinLowEdge(ibin+1);
}
binBoundaries[fixNbin] = h->GetBinLowEdge(fixNbin)+h->GetBinWidth(fixNbin);
TH1D *h_den_fix = new TH1D("h_den_fix","",fixNbin,binBoundaries); h_den_fix->Sumw2();
for(int ibin=0; ibin<fixNbin-h_den->GetNbinsX(); ibin++){
h_den_fix->SetBinContent(ibin+1,0);
h_den_fix->SetBinError(ibin+1,0);
}
for(int ibin=fixNbin-h_den->GetNbinsX(); ibin<fixNbin; ibin++){
h_den_fix->SetBinContent(ibin+1,h_den->GetBinContent(ibin-(fixNbin-h_den->GetNbinsX())+1));
h_den_fix->SetBinError(ibin+1,h_den->GetBinError(ibin-(fixNbin-h_den->GetNbinsX())+1));
}*/
//end fix
//h->Draw();
h->SetTitle("");
//h_den->SetMarkerColor(2);
//h_den->Draw("same");
//h->Divide(h_den);
h->SetYTitle("#frac{1}{T_{pA}} #frac{d#sigma}{dp_{T}} (1/GeV/c)");
h->SetMaximum(1E-6);
h->SetMinimum(1E-11);
h->Draw();
h_den->SetMarkerColor(4);
h_den->Draw("same");
hfCheck2->Scale(1./70.);
hfCheck2->SetLineColor(kGreen+2);
hf->Draw("same");
he2->SetMarkerColor(kOrange+2);
he2->Draw("same");
//hfCheck2->Draw("same");
//h_den = hfCheck2;
//c1->SetLogy();
for(int j=1; j<=h->GetNbinsX(); j++){
cout << h->GetBinLowEdge(j) << " ";
}
cout << h->GetBinLowEdge(h->GetNbinsX())+h->GetBinWidth(h->GetNbinsX()) << endl;
for(int j=1; j<=h_den->GetNbinsX(); j++){
cout << h_den->GetBinLowEdge(j) << " ";
}
cout << h_den->GetBinLowEdge(h_den->GetNbinsX())+h_den->GetBinWidth(h_den->GetNbinsX()) << endl;
TH1F *hpow, *hpow15;
//if(drawPowheg){
TFile *fpowheg50 = new TFile("Powheg/CMS-Dijet-Analysis-5tev-kt0-pt50Cut-mstwCL60PDF.root");
hpow = (TH1F*)fpowheg50->Get("d05-x01-y01")->Clone("hpow"); //inclusive eta, ak3 jets
TFile *fpowheg15 = new TFile("Powheg/CMS-Dijet-Analysis-5tev-kt0-pt20Cut-mstwCL60PDF.root");
hpow15 = (TH1F*)fpowheg15->Get("d05-x01-y01")->Clone("hpow15");
hpow15->Scale(25.4); //pthat20 relative (to pthat50) efficiency
//hpow15->Scale(405.); //pthat 5 relative efficiency
//hpow15->Scale(15.95);
for(int i=1; i<=hpow->GetNbinsX(); i++){
if(hpow->GetBinLowEdge(i)<100){
//cout << "edge: "<< hpow->GetBinLowEdge(i) << endl;
//cout << "hpow: "<< hpow->GetBinContent(i) << " hpow15: "<< hpow15->GetBinContent(i) << endl;
hpow->SetBinContent(i, hpow15->GetBinContent(i));
hpow->SetBinError(i, hpow15->GetBinError(i));
}
}
hpow->SetMarkerStyle(20);
hpow->SetMarkerColor(kOrange+2);
hpow->SetLineColor(kOrange+2);
hpow->Scale(2./10.); //fix eta selection
hpow->Scale(1./70E-3); //correct for sigma_pp
hpow->Scale(1.851e-3); //correct pthat50 efficiency (148086/80M)
//hpow->Scale(4.7e-2);
hpow->Scale(1e-9); //correct ncoll & translate to mb, not pb
//hpow->Scale(1./50.);
//hpow->Scale(0.85/(30.));
if(drawPowheg) hpow->Draw("same");
// }
TLegend *t1 = new TLegend(0.5,0.697,0.879,0.906);
t1->AddEntry(h,"pPb data b-jet spec.","p");
t1->AddEntry(h2,"pPb MC b-jet spec.","p");
t1->AddEntry(h_den,"pp MC b-jet spec.","p");
if(drawPowheg) t1->AddEntry(hpow,"Powheg Spec.","p");
t1->SetFillColor(0);
t1->Draw("same");
TCanvas *c2 = new TCanvas("c2","",600,600); //800,800
//formatCanvas(c2);
TH1D *hcln = (TH1D*)h->Clone("hcln");
cout << "nbin: "<< hcln->GetNbinsX() << endl;
//double xbinsrebin[17] = {0,5,10,15,20,25,30,35,40,55,70,90,110,140,170,220,400};
//TH1D *hcln = new TH1D("hcln","",16,xbinsrebin);
for(int ibin=1; ibin<=hcln->GetNbinsX(); ibin++){
cout << "content bin " << ibin << " " << hcln->GetBinContent(ibin) << endl;
cout << "powheg content bin " << ibin << " " << hpow->GetBinContent(ibin) << endl;
//hcln->SetBinError(ibin,hcln_tmp->GetBinError(ibin));
//hcln->SetBinContent(ibin,hcln_tmp->GetBinContent(ibin));
}
TH1D *hdencln = (TH1D*)h_den->Clone("hdencln");
TH1D *hclnpow = (TH1D*)hcln->Clone("hclnpow");
//cout << "WARNING! Scaling denominator for neutrinoless definition change!" << endl;
//hdencln->Scale(1./1.243);
if(!drawPowheg) hcln->Divide(hdencln);
else{
for(int ibin=1; ibin<=16; ibin++){
int powbin=ibin;
if(!useUnfolded) powbin+=8;
if(!useUnfolded && ibin>8) continue;
hcln->SetBinError(powbin,sqrt(pow(h_den->GetBinError(ibin)/h_den->GetBinContent(ibin),2)+pow(hpow->GetBinError(powbin)/hpow->GetBinContent(powbin),2)));
hcln->SetBinContent(powbin,h_den->GetBinContent(ibin)/hpow->GetBinContent(powbin));
}
}
//hcln->Divide(hcln);
//Apply systematic errors to the inclusive eta plot
TGraphErrors *systErr[7];
TGraphErrors *unfoldErr[7];
//set systematics
const int nBins = 18;
double xp[nBins], yp[nBins], xerr[nBins], yerr[nBins];
//double yerrTot[nBins] = {0,0,0,0,0,0,0,0,0.13729, 0.1306, 0.1235, 0.146166, 0.16266, 0.1437,0.1816,0.23813}; //before recalibration
double yerrTot[nBins] = {0,0,0,0,0,0,0,0,0,0.131694,0.0976, 0.0957, 0.1139, 0.1209, 0.1773, 0.2162,0,0}; //after recalibration
double unfoldErrTot[nBins] = {0,0,0,0,0,0,0,0,0,0.05,0.05,0.05,0.05,0.05,0.05,0.06,0,0};
double unfoldErrTotEta1[nBins] = {0,0,0,0,0,0,0,0,0,0.15,0.08,0.06,0.06,0.08,0.04,0.04,0,0};
//double pythiaSysErr[nBins+1] = {0,0,0,0,0,0,0,0.136,0.138,0.140,0.142,0.148,0.152,0.157,0.164,0.174,0.182}; //option B
// double optionBExtra[nBins+1] = {0,0,0,0,0,0,0,0,0,0.10,0.111,0.078,0.119,0.108,0.053,0.122,0.168};
double pythiaSysErr[1] = {0.22}; //option A
double pythiaYpoints[1] = {1};
double pythiaXpoints[1] = {10};
double pythiaXerr[1] = {10};
for(int i=0; i<nBins; i++){ yerrTot[i] = sqrt(pow(yerrTot[i],2)+pow(unfoldErrTot[i],2)); }
int j=0;
if(!doInclusiveJet){
for(int i=1; i<=hcln->GetNbinsX(); i++){
xp[i-1] = hcln->GetBinLowEdge(i)+hcln->GetBinWidth(i)/2.;
yp[i-1] = hcln->GetBinContent(i);
xerr[i-1] = hcln->GetBinWidth(i)*0.495;
yerr[i-1] = yerrTot[i-1];
//pythiaXpoints[i-1] = xp[i-1];
//pythiaXerr[i-1] = xerr[i-1];
if(yerr[i-1]>0.001 && yp[i-1]>-1){
systErr[j] = new TGraphErrors(1,&xp[i-1],&yp[i-1],&xerr[i-1],&yerrTot[i-1]);
unfoldErr[j] = new TGraphErrors(1,&xp[i-1],&yp[i-1],&xerr[i-1],&unfoldErrTot[i-1]);
systErr[j]->SetName(Form("RpA_SystErr_bin%d",j));
j++;
}
}
//pythiaXerr[16] = 0.;
//pythiaXpoints[16] = 400.;
/*for(int jj=0; jj<nBins+1; jj++){
pythiaSysErr[jj]*=(1+optionBExtra[jj]);
}*/
TGraphErrors *pythiaErr = new TGraphErrors(1,pythiaXpoints,pythiaYpoints,pythiaXerr,pythiaSysErr);
}
//TGraphErrors *systErr = new TGraphErrors(nBins,xp,yp,xerr,yerr);
double jesx[1]={2.365};
double jesy[1]={1};
double jesxerr[1]={.1};
double jesyerr[1]={0.035};
TGraphErrors *JESNorm = new TGraphErrors(1,jesx,jesy,jesxerr,jesyerr);
JESNorm->SetFillColor(kGreen+3);
hcln->SetMaximum(2.5);
hcln->SetMinimum(0);
if(doInclusiveJet) hcln->SetYTitle("Inclusive Jet R_{pA}");
else hcln->SetYTitle("Nuclear Modification Factor");
//else hcln->SetYTitle("b-jet R_{pA}^{PYTHIA}");
hcln->SetXTitle("b-jet p_{T} [GeV/c]");
hcln->GetXaxis()->SetRangeUser(0,400);
hcln->GetXaxis()->CenterTitle(0);
hcln->GetYaxis()->CenterTitle(0);
hcln->SetMarkerStyle(20);
hcln->SetMarkerColor(1);
hcln->SetMarkerSize(1.2);
for(int i=1; i<hcln->GetNbinsX(); i++){
if(hcln->GetBinLowEdge(i) < 55){
hcln->SetBinContent(i,-1);
hcln->SetBinError(i,0.0001);
}
}
hcln->Draw();
hclnpow->SetMarkerColor(kOrange+2);
hclnpow->SetLineColor(kOrange+2);
if(drawPowheg) hclnpow->Draw("same");
TLine *at2 = new TLine(0,1,400,1);
at2->SetLineStyle(7);
at2->SetLineWidth(1);
pythiaErr->SetFillColor(kRed-7);
//pythiaErr->SetFillStyle(1); //3844
if(!doInclusiveJet){
for(int i=0; i<7; i++){
unfoldErr[i]->SetFillColor(kCyan-7);
systErr[i]->SetFillColor(kYellow-7);
systErr[i]->SetMarkerStyle(20);
systErr[i]->Draw("2,same");
//unfoldErr[i]->Draw("2,same");
}
}
pythiaErr->Draw("2,same");
double lumix[1] = {10}; double lumiy[1] = {1}; double lumierrx[1] = {10}; double lumierry[1] = {0.035};
TGraphErrors *lumiErr = new TGraphErrors(1,lumix,lumiy,lumierrx,lumierry);
lumiErr->SetFillColor(kGreen+3);
lumiErr->Draw("2,same");
at2->Draw("same");
//JESNorm->Draw("2,same");
hcln->Draw("same");
//JESNorm->Draw("2,same");
TLine *phigh1 = new TLine(380,1.22,400,1.22);
phigh1->SetLineColor(2);
phigh1->SetLineStyle(4);
phigh1->SetLineWidth(1);
//phigh1->Draw("same");
TLine *phigh2 = new TLine(380,0.78,400,0.78);
phigh2->SetLineColor(2);
phigh2->SetLineStyle(4);
phigh2->SetLineWidth(1);
//phigh2->Draw("same");
double zeroTemp[1] = {0};
TGraphErrors *inclJetSys = new TGraphErrors(1,zeroTemp,zeroTemp,zeroTemp,zeroTemp);
inclJetSys->SetMarkerColor(2);
inclJetSys->SetMarkerStyle(21);
inclJetSys->SetFillColor(8);
//gROOT->ProcessLine(".x ~/Downloads/UnfoldedakPu3PFIncJetRpAvsPtInterpolatedRefEtaBin7.C");
//gROOT->ProcessLine(".x ~/Downloads/RAA_drawFinal.C");
if(drawTheory){
gROOT->ProcessLine(".x ~/Downloads/drawpPbTheory.C");
}
TGraph *raaErr = new TGraph();
raaErr->SetFillColor(kMagenta+1);
raaErr->SetMarkerStyle(20);
raaErr->SetMarkerSize(1.2);
TLegend *leg1 = new TLegend(0.41,0.729,0.88,0.886);
leg1->SetFillColor(0);
//leg1->AddEntry(inclJetSys,"Inclusive-Jet R_{pA}, |#eta_{CM}|<0.5","fp");
//leg1->AddEntry(raaErr,"b-jet R_{AA}, (0-100%), |#eta|<2","fp");
leg1->AddEntry(systErr[0],"pPb Data, -2 < #eta_{CM} < 2","fp");
leg1->AddEntry(grepPbtheory,"Ref. [32]","lp");
//leg1->AddEntry(pythiaErr,"Reference Unc.","f");
//leg1->AddEntry(lumiErr,"Luminosity Unc.","f");
//leg1->AddEntry(systErr[0],"Total Systematic Error","f");
//leg1->AddEntry(unfoldErr[0],"Unfolding Uncertainty","f");
leg1->Draw("same");
TLegend *leg3 = new TLegend(0.2,0.207,0.567,0.328);
leg3->SetFillColor(0);
leg3->AddEntry(lumiErr,"pPb Luminosity Unc.","f");
leg3->AddEntry(pythiaErr,"pPb Reference Unc.","f");
leg3->Draw("same");
grepPbtheory->Draw("C,same");
c2->SetTopMargin(0.0734);
c2->RedrawAxis();
TLatex *cmsP = new TLatex(16.7,2.25,"CMS ");
cmsP->SetTextFont(62);
cmsP->SetTextSize(0.0558);
cmsP->Draw("same");
TLatex *l1 = new TLatex(-0.5,0.18,Form("0-100%%",etalo,etahi));
//l1->Draw("same");
TLatex *l4 = new TLatex(236.8,2.56,"35 nb^{-1} (5.02 TeV)");//; PbPb L = 150 #mub^{-1}");
l4->SetTextFont(43);
l4->SetTextSize(25);
l4->Draw("same");
TLatex *l2 = new TLatex(20.77,0.175,"pPb #sqrt{s_{NN}} = 5.02 TeV #int L dt = 35 nb^{-1}"); //35, 20.7, 14
l2->SetTextSize(0.035);
//l2->Draw("same");
TLatex *l3 = new TLatex(-2,0.22,"PbPb #sqrt{s_{NN}} = 2.76 TeV #int L dt = 150 #mub^{-1}");
l3->SetTextSize(0.035);
//l3->Draw("same");
//TLatex *ltag = new TLatex(65,2.2,"CSV > 0.679");
TLatex *ltag = new TLatex(65,2.2,"SSVHE > 2.0");
//ltag->Draw("same");
TFile *out = new TFile("RpA_BJet_Output.root","RECREATE");
out->cd();
hcln->SetName("RpA");//,"b jet RpA");
hcln->Write();
h->Write();
h_den->Write();
for(int i=0; i<7; i++){
systErr[i]->Write();
}
out->Close();
// hcln->Fit("pol0","","",45,250);
//hcln->Fit("pol1","","",45,250);
cout << "values: { ";
for(int i=1; i<=hcln->GetNbinsX(); i++){
cout << hcln->GetBinContent(i) << " ";
}
cout << " }" << endl;
cout << "stat err: { ";
for(int i=1; i<=hcln->GetNbinsX(); i++){
cout << hcln->GetBinError(i) << " ";
}
cout << " }" << endl;
cout << "syst err: { ";
for(int i=1; i<=hcln->GetNbinsX(); i++){
cout << yerrTot[i-1]+(yerrTot[i-1]*hcln->GetBinContent(i)) << " ";
}
cout << " }" << endl;
}
void clusterGaussReso() {
TFile* file = new TFile("complete.root");
TTree* tree = (TTree *)file->Get("Signal");
int nEvents = tree->GetEntries();
double addresses[121] = {};
for (int k=0; k<121; k++){
std::stringstream ss2;
ss2 << k;
string str = "Crystal_"+ss2.str();
const char* charstr = str.c_str();
tree->SetBranchAddress(charstr, &addresses[k]);
}
TH1D* energyResoG = new TH1D("energyResoG", "Gauss_Energy_Resolution",
100, -10, 10);
TH2D* posResoG = new TH2D("posResoG", "Gauss_Pos_Resolution",
11, -5, 5, 11, -5, 5);
double energyThresHi = 50.; //set energy threshold to start looking for bumps
double energyThresLo = .5; //energy lower bound
//Going through each scan of the calorimeter
for (int k=0; k<nEvents; k++)
{
tree->GetEntry(k);
pair<int, double> bump(0, 0.);
vector<pair<int, double> > geant;
vector<pair<int, double> > hitMap;
for(int i=0; i<121; i++)
{
pair<int, double> hit(i, addresses[i]);
geant.push_back(hit);
if (addresses[i] > energyThresHi)
{ hitMap.push_back(hit);}
if (hit.second>bump.second)
{ bump = hit;}
}
gaussFit(bump, geant, energyResoG, posResoG);
} //end of event
TCanvas* canvas = new TCanvas("canvas", "canvas", 700,700);
canvas->Divide(2, 1);
TF1* g1d = new TF1("g1d", "gaus", -10, 10);
TF2* g2d2 = new TF2("g2d2", Gaus2D, -10, 10, -10, 10, 6);
g2d2->SetParameters(0., 0., 1., 1., 0., 100000);
g2d2->FixParameter(4, 0.);
energyResoG->Fit(g1d);
canvas->cd(1); energyResoG->Draw();
posResoG->Fit(g2d2);
canvas->cd(2); posResoG->Draw("BOX");
}
//_________________________________________________________________________________
void integratedSplinesV4b(double seed = 231)
{
//Load the data
int nEvents = 1000; //number of times the data will be randomized
int nPoints = 9;
vector< vector<double> > xEvents, yEvents, yErrorEvents; //each of these is a vector of vectors (of randomized data points)
for(int i = 0; i < nEvents; i++)
{
vector <double> xData, yData, yErrorData; //temporary vectors that are only used to get random values from FillRand function
FillRandVectors(nPoints, xData, yData, yErrorData, seed*(i+1)); //populates random vectors for y values and y error vector
xEvents.push_back(xData);
yEvents.push_back(yData);
yErrorEvents.push_back(yErrorData);
}
//Intialization of the variables
const int npar = nPoints;
const int orderSpline = 4;
const int nbreak = npar+2-orderSpline;
double stepSpline = 0.01;
double xminBSplineWorkspace = 0;
double xmaxBSplineWorkspace = 9;
double startCSplineWorkspace = 15.;
double stepCSplineWorkspace = 1.5;
acc_GLOB = gsl_interp_accel_alloc ();
spline_GLOB = gsl_spline_alloc (gsl_interp_cspline, nPoints);
bw_GLOB = gsl_bspline_alloc(orderSpline, nbreak);
//B- and C-splines
clock_t tbstart, tbstop, tcstart, tcstop;
vector <double> timeb, timec;
vector< vector<double> > xBSplineValues, yBSplineValues;
vector< vector<double> > xCSplineValues, yCSplineValues;
for(int i = 0; i < (int)xEvents.size(); i++)
{
tbstart = clock();
vector< vector<double> > bSplineValues = bSpline(nPoints, npar, xEvents.at(i), yEvents.at(i), yErrorEvents.at(i), stepSpline, xminBSplineWorkspace, xmaxBSplineWorkspace);
tbstop = clock();
timeb.push_back(((float)tbstop-(float)tbstart)/ (CLOCKS_PER_SEC/1000.) );
xBSplineValues.push_back(bSplineValues.at(0));
yBSplineValues.push_back(bSplineValues.at(1));
tcstart = clock();
vector< vector<double> > cSplineValues = cSpline(nPoints, npar, xEvents.at(i), yEvents.at(i), yErrorEvents.at(i), stepSpline, startCSplineWorkspace, stepCSplineWorkspace);
tcstop = clock();
timec.push_back(((float)tcstop-(float)tcstart)/ (CLOCKS_PER_SEC/1000.) );
xCSplineValues.push_back(cSplineValues.at(0));
yCSplineValues.push_back(cSplineValues.at(1));
}
//Histograms______________________________________________________________________________________
//Time
int nbins = 100;
double xlow = 0;
double xup = 1.;
TH1D *hTimeB = new TH1D("Time","; time [ms]; number of runs", nbins, xlow, xup);
hTimeB->SetStats(0);
TH1D *hTimeC = new TH1D("TimeC","; time [ms]; number of runs", nbins, xlow, xup);
hTimeC->SetLineColor(kRed);
hTimeC->SetStats(0);
for(int i=0; i<(int)timec.size(); i++)
{
hTimeB->Fill(timeb.at(i));
hTimeC->Fill(timec.at(i));
}
//Interpolation distance -> Should FIND THE RIGHT J FOR SPLINE
vector <double> interpB, interpC;
for(int i = 0; i < (int)yEvents.size(); i++)
{
for(int j = 0; j < (int)yEvents[i].size(); j++)
{
double key = xEvents[i][j];
int indexForB = binarySearch(xBSplineValues[i], key);
int indexForC = binarySearch(xCSplineValues[i], key);
std::cout << "B: " << indexForB << " C: " << indexForC << endl;
if(indexForB != -1)
interpB.push_back( (yEvents[i][j]-yBSplineValues[i][indexForB])/yErrorEvents[i][indexForB] );
if(indexForC != -1)
interpC.push_back( (yEvents[i][j]-yCSplineValues[i][indexForC])/yErrorEvents[i][indexForC] );
}
}
int nbinsI = 40;
int xlowI = -4;
int xupI = 4;
TH1D *hInterpB = new TH1D("Interp B","; xAxis; yAxis", nbinsI, xlowI, xupI);
for(int i=0; i<(int)interpB.size(); i++) hInterpB->Fill(interpB.at(i));
hInterpB->SetStats(0);
TH1D *hInterpC = new TH1D("Interp C","; xAxis; yAxis", nbinsI, xlowI, xupI);
for (int i=0; i<(int)interpC.size(); i++) hInterpC->Fill(interpC.at(i));
hInterpC->SetLineColor(kRed);
hInterpC->SetStats(0);
//Draws______________________________________________________________________________________
//Interpolation distance
TCanvas *c1 = new TCanvas("c1", "Interpolation distance");
c1->cd();
hInterpB->Draw("");
hInterpC->Draw("same");
//Time
TLegend *leg = new TLegend(0.75,0.70,0.4,0.85);
leg->SetLineColor(kWhite);
leg->SetFillColor(kWhite);
leg->SetMargin(0.3);
leg->AddEntry(hTimeB,"b-spline","l");
leg->AddEntry(hTimeC,"c-spline","l");
TCanvas *c2 = new TCanvas("c2", "Computation time");
c2->cd();
hTimeB->Draw("");
hTimeC->Draw("same");
leg-> Draw();
//Free the memory for the spline
gsl_spline_free (spline_GLOB); //frees the memory used by the spline
gsl_interp_accel_free (acc_GLOB);
gsl_bspline_free(bw_GLOB);
}
void balanceMetVsAj(TString infname = "dj_HCPR-J50U-hiGoodMergedTracks_OfficialSelv2_Final0_120_50.root",
TCut myCut = "cent<30", char *title = "",bool drawLegend = false,
bool drawSys = true
)
{
// ===========================================================
// Get Input
// ===========================================================
TFile *inf = new TFile(infname);
TTree *t = (TTree*)inf->Get("ntjt");
t->SetAlias("metxMergedAll","(metConex0+metConex1+metConex2+metConex3+metConex4+metConex5)");
t->SetAlias("metxMerged0","(metConex0)");
t->SetAlias("metxMerged1","(metConex1)");
t->SetAlias("metxMerged2","(metConex2)");
t->SetAlias("metxMerged3","(metConex3)");
t->SetAlias("metxMerged4","(metConex4+metConex5)");
// ===========================================================
// Analysis Setup
// ===========================================================
const int nBin = 5;
double bins[nBin+1] = {0.5,1.0,1.5,4,8,1000};
int colors[5] = {kBlue-10,kYellow-7, kOrange-2,kGreen-5,kRed-3};
const int nBinAj = 4;
double ajBins[nBinAj+1] = {0.0001,0.11,0.22,0.33,0.49999};
// Selection cut
TCut evtCut = "nljet>120&&abs(nljetacorr)<2&&aljet>50&&abs(aljetacorr)<2&&jdphi>2./3*TMath::Pi()&&!maskEvt";
cout << "Sel evt: " << t->GetEntries(evtCut&&myCut) << endl;
// ===========================================================
// Find Average Weights
// ===========================================================
TH1D *hw[nBinAj];
float meanWt[nBinAj];
for ( int iaj = 0 ; iaj< nBinAj ; iaj++) {
hw[iaj] = new TH1D(Form("hw_aj%d",iaj),"",1000,0,100);
TCut ajCut = Form("Aj>%f && Aj<%f", ajBins[iaj],ajBins[iaj+1]);
t->Draw(Form("weight>>hw_aj%d",iaj), evtCut&&myCut&&ajCut);
meanWt[iaj] = hw[iaj]->GetMean();
cout << " <Weight>: " << meanWt[iaj] << endl;
}
// ===========================================================
// Draw Weighted Averages
// ===========================================================
TH1D *ppos[nBin];
TH1D *pneg[nBin];
TH1D *pe[nBin];
for (int i=0;i<nBin;i++)
{
TH1D *h1 = new TH1D(Form("h1%d",i),"",nBinAj,ajBins);
TH1D *h2 = new TH1D(Form("h2%d",i),"",nBinAj,ajBins);
TH1D *he[nBinAj];
// =================================
// Get Weighted Mean for each Aj bin
// =================================
h1->Sumw2();
h2->Sumw2();
t->Draw(Form("Aj>>h1%d",i), "weight"*(evtCut&&myCut));
t->Draw(Form("Aj>>h2%d",i), Form("((-weight*metxMerged%d))",i)*(evtCut&&myCut));
pe[i]=(TH1D*)h2->Clone();
pe[i]->SetName(Form("p%d",i));
pe[i]->Divide(h1);
ppos[i] = new TH1D(Form("ppos%d",i),"",nBinAj,ajBins);
ppos[i]->SetLineColor(1);
ppos[i]->SetMarkerColor(colors[i]);
ppos[i]->SetFillColor(colors[i]);
ppos[i]->SetFillStyle(1001);
pneg[i] = new TH1D(Form("pneg%d",i),"",nBinAj,ajBins);
pneg[i]->SetLineColor(1);
pneg[i]->SetMarkerColor(colors[i]);
pneg[i]->SetFillColor(colors[i]);
pneg[i]->SetFillStyle(1001);
// =================================
// Caculated Stat Error of the Mean
// =================================
cout << "Stat Error for pt bin " << i << ": ";
for ( int iaj = 0 ; iaj< nBinAj ; iaj++) {
he[iaj] = new TH1D(Form("he%d_aj%d",i,iaj),"",100,-200,200);
TCut ajCut = Form("Aj>%f && Aj<%f", ajBins[iaj],ajBins[iaj+1]);
t->Draw(Form("((metxMerged%d))>>he%d_aj%d",i,i,iaj), "weight" * evtCut&&myCut&&ajCut);
float theError = he[iaj]->GetRMS()/ (sqrt(he[iaj]->GetEntries()));
cout << theError << " ";
pe[i]->SetBinError(iaj+1, theError);
}
cout << endl;
}
// Stack
for (int i=nBin-1;i>=0;i--)
{
for(int iaj = 0 ; iaj< nBinAj ; iaj++) {
double posVal=0, negVal=0;
double posValErr=0, negValErr=0;
if (i!=nBin-1) {
posVal = ppos[i+1]->GetBinContent(iaj+1);
posValErr = ppos[i+1]->GetBinError(iaj+1);
negVal = pneg[i+1]->GetBinContent(iaj+1);
negValErr = pneg[i+1]->GetBinError(iaj+1);
}
if (pe[i]->GetBinContent(iaj+1)<0) {
negVal+=pe[i]->GetBinContent(iaj+1);
negValErr=pe[i]->GetBinError(iaj+1);
posValErr=0;
} else if (pe[i]->GetBinContent(iaj+1)>0) {
posVal+=pe[i]->GetBinContent(iaj+1);
posValErr=pe[i]->GetBinError(iaj+1);
negValErr=0;
}
ppos[i]->SetBinContent(iaj+1,posVal);
ppos[i]->SetBinError(iaj+1,posValErr);
pneg[i]->SetBinContent(iaj+1,negVal);
pneg[i]->SetBinError(iaj+1,negValErr);
}
}
TH1D *pall;
TH1D *pallE;
TH1D *h1 = new TH1D(Form("hAll1"),"",nBinAj,ajBins);
TH1D *h2 = new TH1D(Form("hAll2"),"",nBinAj,ajBins);
h1->Sumw2();
h2->Sumw2();
t->Draw(Form("Aj>>hAll1"), "weight"*(evtCut&&myCut));
t->Draw(Form("Aj>>hAll2"), Form("((-weight*metxMergedAll))")*(evtCut&&myCut));
pall=(TH1D*)h2->Clone();
pall->SetName("pall");
pall->Divide(h1);
// replace the sys error from pallE to pall
TH1D *he[nBinAj];
cout << "Stat Error for All pt: ";
for ( int iaj = 0 ; iaj< nBinAj ; iaj++) {
he[iaj] = new TH1D(Form("heAll_aj%d",iaj),"",100,-200,200);
TCut ajCut = Form("Aj>%f && Aj<%f", ajBins[iaj],ajBins[iaj+1]);
t->Draw(Form("((metxMergedAll))>>heAll_aj%d",iaj), "weight" * evtCut&&myCut&&ajCut);
float theError = he[iaj]->GetRMS()/ (sqrt(he[iaj]->GetEntries()));
cout << theError << " ";
pall->SetBinError(iaj+1, theError);
}
cout << endl;
pall->SetXTitle("A_{J}");
pall->SetYTitle("<#slash{p}_{T}^{#parallel}> (GeV/c)");
pall->GetXaxis()->CenterTitle();
pall->GetYaxis()->CenterTitle();
pall->GetXaxis()->SetLabelSize(22);
pall->GetXaxis()->SetLabelFont(43);
pall->GetXaxis()->SetTitleSize(24);
pall->GetXaxis()->SetTitleFont(43);
pall->GetYaxis()->SetLabelSize(22);
pall->GetYaxis()->SetLabelFont(43);
pall->GetYaxis()->SetTitleSize(24);
pall->GetYaxis()->SetTitleFont(43);
pall->GetXaxis()->SetTitleOffset(1.8);
pall->GetYaxis()->SetTitleOffset(2.4);
pall->SetNdivisions(505);
pall->SetAxisRange(-59.9,59.9,"Y");
pall->SetMarkerSize(1);
pall->Draw("E");
float addSys = 0;
if ( drawSys==1) addSys=0; // No sys error at this moment
// ====================
// Finally Draw
// ====================
for (int i=0;i<nBin;++i) {
ppos[i]->SetLineWidth(1);
ppos[i]->Draw("hist same");
pneg[i]->SetLineWidth(1);
pneg[i]->Draw("hist same");
}
// ====================
// Draw Statistical Error bars
// ====================
for (int i=0;i<nBin;++i) {
if ( i==0 ) drawErrorShift(ppos[i],-0.016, addSys);
if ( i==1 ) drawErrorShift(ppos[i],-0.008,addSys);
if ( i==2 ) drawErrorShift(ppos[i],0.008,addSys);
if ( i==3 ) drawErrorShift(ppos[i],0.016,addSys);
if ( i==4 ) drawErrorShift(ppos[i],0.024,addSys);
if ( i==0 ) drawErrorShift(pneg[i],-0.016, addSys);
if ( i==1 ) drawErrorShift(pneg[i],-0.008,addSys);
if ( i==2 ) drawErrorShift(pneg[i],0.008,addSys);
if ( i==3 ) drawErrorShift(pneg[i],0.016,addSys);
if ( i==4 ) drawErrorShift(pneg[i],0.024,addSys);
}
pall->Draw("E same");
// ====================
// Draw Systematic Errors
// ====================
if (drawSys == 1) {
for(int i = 0; i < nBinAj; ++i){
double x = pall->GetBinCenter(i+1);
double y = pall->GetBinContent(i+1);
// Quote the difference between GEN and RECO in >8 Bin (20%) before adjusting eff as systematics
double err = fabs(pe[nBin-1]->GetBinContent(i+1)*0.2);
DrawTick(y,err,err,x,1,0.02,1);
}
}
// ====================
// Draw Legend
// ====================
TLegend *leg = new TLegend(0.10,0.68,0.70,0.96);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
leg->SetTextFont(63);
leg->SetTextSize(16);
leg->AddEntry(pall,Form("> %.1f GeV/c",bins[0]),"pl");
for (int i=0;i<nBin;++i) {
if (i!=nBin-1){
leg->AddEntry(ppos[i],Form("%.1f - %.1f GeV/c",bins[i],bins[i+1]),"f");
} else {
leg->AddEntry(ppos[i],Form("> %.1f GeV/c",bins[i]),"f");
}
}
if (drawLegend) leg->Draw();
TLine * l0 = new TLine(0,0,0.5,0);
l0->SetLineStyle(2);
l0->Draw();
TLine * l1 = new TLine(0.0001,-10,0.0001,10);
l1->Draw();
TText *titleText = new TText(0.3,30,title);
titleText->Draw();
}
void RPCSeedValidator(string FileName) {
gStyle->SetOptStat("");
gStyle->SetOptTitle(0);
if(debug) cout << FileName << endl;
string theFileName = "../" + FileName;
TFile* RootFile = TFile::Open(theFileName.c_str());
string OutputPlotNameFix = ".eps";
string FinalOutput = FileName + "_";
unsigned int EventNumber;
int SimTrackId;
int SimTrackType;
double SimTrackMomentum;
double SimTrackDirectionPhi;
int SimTrackCharge;
int SimTrackvalid;
bool PassSegmentFilter;
double SimMomentumPtatRef;
double SimDirectionPhiatRef;
double SimDirectionEtaatRef;
double SimBendingPhi;
double SimBendingEntryPositionX;
double SimBendingEntryPositionY;
double SimBendingEntryPositionZ;
double SimBendingLeavePositionX;
double SimBendingLeavePositionY;
double SimBendingLeavePositionZ;
unsigned int SeedNumber;
int SeedCharge;
double SeedPurity;
double SeedQuality;
double RecMomentumPtatRef;
double RecDirectionPhiatRef;
double RecDirectionEtaatRef;
double RecBendingPhi;
double RecBendingEntryPositionX;
double RecBendingEntryPositionY;
double RecBendingEntryPositionZ;
double RecBendingLeavePositionX;
double RecBendingLeavePositionY;
double RecBendingLeavePositionZ;
double RecBendingLastPhi;
TTree* T0 = (TTree*)RootFile->Get("ExTree");
T0->SetBranchAddress("EventNumber", &EventNumber);
T0->SetBranchAddress("SimTrackId", &SimTrackId);
T0->SetBranchAddress("SimTrackType", &SimTrackType);
T0->SetBranchAddress("SimTrackMomentum", &SimTrackMomentum);
T0->SetBranchAddress("SimTrackDirectionPhi", &SimTrackDirectionPhi);
T0->SetBranchAddress("SimTrackCharge", &SimTrackCharge);
T0->SetBranchAddress("SimTrackValid", &SimTrackvalid);
T0->SetBranchAddress("PassSegmentFilter", &PassSegmentFilter);
T0->SetBranchAddress("SimMomentumPtatRef", &SimMomentumPtatRef);
T0->SetBranchAddress("SimDirectionPhiatRef", &SimDirectionPhiatRef);
T0->SetBranchAddress("SimDirectionEtaatRef", &SimDirectionEtaatRef);
T0->SetBranchAddress("SimBendingPhi", &SimBendingPhi);
T0->SetBranchAddress("SimBendingEntryPositionX", &SimBendingEntryPositionX);
T0->SetBranchAddress("SimBendingEntryPositionY", &SimBendingEntryPositionY);
T0->SetBranchAddress("SimBendingEntryPositionZ", &SimBendingEntryPositionZ);
T0->SetBranchAddress("SimBendingLeavePositionX", &SimBendingLeavePositionX);
T0->SetBranchAddress("SimBendingLeavePositionY", &SimBendingLeavePositionY);
T0->SetBranchAddress("SimBendingLeavePositionZ", &SimBendingLeavePositionZ);
T0->SetBranchAddress("SeedNumber", &SeedNumber);
T0->SetBranchAddress("SeedCharge", &SeedCharge);
T0->SetBranchAddress("SeedPurity", &SeedPurity);
T0->SetBranchAddress("SeedQuality", &SeedQuality);
T0->SetBranchAddress("RecMomentumPtatRef", &RecMomentumPtatRef);
T0->SetBranchAddress("RecDirectionPhiatRef", &RecDirectionPhiatRef);
T0->SetBranchAddress("RecDirectionEtaatRef", &RecDirectionEtaatRef);
T0->SetBranchAddress("RecBendingPhi", &RecBendingPhi);
T0->SetBranchAddress("RecBendingEntryPositionX", &RecBendingEntryPositionX);
T0->SetBranchAddress("RecBendingEntryPositionY", &RecBendingEntryPositionY);
T0->SetBranchAddress("RecBendingEntryPositionZ", &RecBendingEntryPositionZ);
T0->SetBranchAddress("RecBendingLeavePositionX", &RecBendingLeavePositionX);
T0->SetBranchAddress("RecBendingLeavePositionY", &RecBendingLeavePositionY);
T0->SetBranchAddress("RecBendingLeavePositionZ", &RecBendingLeavePositionZ);
T0->SetBranchAddress("RecBendingLastPhi", &RecBendingLastPhi);
TH1D* SimTrackvalidHist = (TH1D*) new TH1D("SimTrackvalidHist", "SimTrackvalidHist", 2, 0, 2);
TH1D* SeedPtforSimTrackvalidHist = (TH1D*) new TH1D("SeedPtforSimTrackvalidHist", "SeedPtforSimTrackvalidHist", 100, 0, 100);
TH1D* SeeddeltaPtforSimTrackvalidHist = (TH1D*) new TH1D("SeeddeltaPtforSimTrackvalidHist", "SeeddeltaPtforSimTrackvalidHist", 150, -3., 3.);
TH1D* SeeddeltaPhiforSimTrackvalidHist = (TH1D*) new TH1D("SeeddeltaPhiforSimTrackvalidHist", "SeeddeltaPhiforSimTrackvalidHist", 628, -3.14/6, 3.14/6);
TH1D* SeeddeltaEtaforSimTrackvalidHist = (TH1D*) new TH1D("SeeddeltaEtaforSimTrackvalidHist", "SeeddeltaEtaforSimTrackvalidHist", 200, -1., 1.);
TH1D* SeedPurityforSimTrackvalidHist = (TH1D*) new TH1D("SeedPurityforSimTrackvalidHist", "SeedPurityforSimTrackvalidHist", 20, 0, 2);
TH1D* ChargeCheckforSimTrackvalidHist = (TH1D*) new TH1D("ChargeCheckforSimTrackvalidHist", "ChargeCheckforSimTrackvalidHist", 5, -2.5, 2.5);
TH1D* SeedNumberforSimTrackvalidHist = (TH1D*) new TH1D("SeedNumberforSimTrackvalidHist", "SeedNumberforSimTrackvalidHist", 30, 0, 30);
TH1D* SeedEfficiencyforSimTrackvalidHist = (TH1D*) new TH1D("SeedEfficiencyforSimTrackvalidHist", "SeedEfficiencyforSimTrackvalidHist", 2, 0, 2);
TH1D* SeedNumberforSimTrackinvalidHist = (TH1D*) new TH1D("SeedNumberforSimTrackinvalidHist", "SeedNumberforSimTrackinvalidHist", 20, 0, 20);
TH1D* SeedEfficiencyforSimTrackinvalidHist = (TH1D*) new TH1D("SeedEfficiencyforSimTrackinvalidHist", "SeedEfficiencyforSimTrackinvalidHist", 2, 0, 2);
TH1D* RecBendingLastPhiHist = (TH1D*) new TH1D("RecBendingLastPhiHist", "RecBendingLastPhiHist", 628, -3.14/2, 3.14/2);
TH1D* SeedEfficiencyHist = (TH1D*) new TH1D("SeedEfficiency", "SeedEfficiency", 2, 0, 2);
TH2D* RecBendingPhi2PtHist = new TH2D("RecBendingPhi2PtHist", "RecBendingPhi2PtHist", 2000, -100, 100, 628, -3.14/4, 3.14/4);
TH2D* PtRatoofRecBendingPhiHist = new TH2D("", "", 628, -3.14/4, 3.14/4, 2000, -100, 100);
TObjArray* SimReverseBending = (TObjArray*) new TObjArray();
unsigned int LastSeedNumber = -1;
unsigned int LastSimTrackvalid = 0;
bool LastPassSegmentFilter = false;
bool LastPurityFull = false;
int Nentries = T0->GetEntries();
for(int i = 0; i < Nentries; i++) {
T0->GetEntry(i);
if(debug) cout << "SimTrackId: " << SimTrackId << ", SimTrackType: " << SimTrackType << ", PassSegmentFilter: " << PassSegmentFilter << ", SeedNumber: " << SeedNumber << ", SeedPurity: " << SeedPurity << ", SeedCharge: " << SeedCharge << ", SimTrackCharge: " << SimTrackCharge << ", SimBendingPhi: " << SimBendingPhi << ", RecBendingPhi: " << RecBendingPhi << ", RecBendingLastPhi: " << RecBendingLastPhi << ", RecMomentumPtatRef: " << RecMomentumPtatRef << ", SimMomentumPtatRef: " << SimMomentumPtatRef << ", LastSeedNumber: " << LastSeedNumber << endl;
//if(SimTrackMomentum > 20.0)
//continue;
if(SeedNumber != 0) {
if(SimTrackvalid == 1 && SeedPurity == 1. && PassSegmentFilter == true) {
SeedPtforSimTrackvalidHist->Fill(RecMomentumPtatRef);
SeeddeltaPtforSimTrackvalidHist->Fill((RecMomentumPtatRef-SimMomentumPtatRef)/SimMomentumPtatRef);
SeeddeltaPhiforSimTrackvalidHist->Fill(RecDirectionPhiatRef-SimDirectionPhiatRef);
SeeddeltaEtaforSimTrackvalidHist->Fill(RecDirectionEtaatRef-SimDirectionEtaatRef);
RecBendingPhi2PtHist->Fill(SimMomentumPtatRef*SimTrackCharge, RecBendingPhi);
double PtRato = SimMomentumPtatRef / RecMomentumPtatRef;
if(debug) cout << "PtRato: " << PtRato << ", at RecBendingPhi: " << RecBendingPhi << endl;
PtRatoofRecBendingPhiHist->Fill(RecBendingPhi, PtRato);
RecBendingLastPhiHist->Fill((RecBendingLastPhi == 0. ? 0 : RecBendingLastPhi/fabs(RecBendingLastPhi))*SimTrackCharge);
SeedPurityforSimTrackvalidHist->Fill(SeedPurity);
ChargeCheckforSimTrackvalidHist->Fill(SeedCharge*SimTrackCharge);
/*
if(SeedPurity == 1) {
//SeedPtforSimTrackvalidHist->Fill(RecMomentumPtatRef);
//SeeddeltaPtforSimTrackvalidHist->Fill(RecMomentumPtatRef-SimMomentumPtatRef);
RecBendingPhi2PtHist->Fill(SimMomentumPtatRef*SimTrackCharge, RecBendingPhi);
double PtRato = SimMomentumPtatRef / RecMomentumPtatRef;
if(debug) cout << "PtRato: " << PtRato << ", at RecBendingPhi: " << RecBendingPhi << endl;
PtRatoofRecBendingPhiHist->Fill(RecBendingPhi, PtRato);
RecBendingLastPhiHist->Fill((RecBendingLastPhi == 0. ? 0 : RecBendingLastPhi/fabs(RecBendingLastPhi))*SimTrackCharge);
}
*/
if(SeedCharge*SimTrackCharge == -1) {
if(debug) cout << "R1: " << sqrt(SimBendingEntryPositionX*SimBendingEntryPositionX+SimBendingEntryPositionY*SimBendingEntryPositionY) << ", R2: " << sqrt(SimBendingLeavePositionX*SimBendingLeavePositionX+SimBendingLeavePositionY*SimBendingLeavePositionY) << endl;
TLine* SimSegment = new TLine(SimBendingEntryPositionX, SimBendingEntryPositionY, SimBendingLeavePositionX, SimBendingLeavePositionY);
SimReverseBending->AddLast(SimSegment);
}
LastPurityFull = true;
}
}
else {
if(LastSeedNumber != -1) {
if(LastSimTrackvalid == 1 && LastPassSegmentFilter == true) {
if(debug) cout << "Filling valid track efficiency " << LastSeedNumber << endl;
SeedNumberforSimTrackvalidHist->Fill(LastSeedNumber);
SeedEfficiencyforSimTrackvalidHist->Fill(LastPurityFull==true?1:0);
}
else {
SeedNumberforSimTrackinvalidHist->Fill(LastSeedNumber);
SeedEfficiencyforSimTrackinvalidHist->Fill(LastPurityFull==true?1:0);
}
LastPurityFull = false;
}
}
LastPassSegmentFilter = PassSegmentFilter;
LastSeedNumber = SeedNumber;
LastSimTrackvalid = SimTrackvalid;
}
if(LastSeedNumber != -1) {
if(LastSimTrackvalid == 1 && LastPassSegmentFilter == true) {
SeedNumberforSimTrackvalidHist->Fill(LastSeedNumber);
SeedEfficiencyforSimTrackvalidHist->Fill(LastPurityFull==true?1:0);
}
else {
SeedNumberforSimTrackinvalidHist->Fill(LastSeedNumber);
SeedEfficiencyforSimTrackinvalidHist->Fill(LastPurityFull == true?1:0);
}
}
TCanvas* SimTrackvalidCanvas = new TCanvas("SimTrackvalidCanvas", "SimTrackvalidCanvas", 800, 600);
SimTrackvalidCanvas->cd();
SimTrackvalidHist->Draw();
string SimTrackvalidCanvasName = FinalOutput + "SimTrackvalid" + OutputPlotNameFix;
SimTrackvalidCanvas->SaveAs(SimTrackvalidCanvasName.c_str());
TCanvas* SeedPtforSimTrackvalidCanvas = new TCanvas("SeedPtforSimTrackvalidCanvas", "SeedPtforSimTrackvalidCanvas", 800, 600);
SeedPtforSimTrackvalidCanvas->cd();
SeedPtforSimTrackvalidHist->Draw();
string SeedPtforSimTrackvalidCanvasName = FinalOutput + "SeedPtforSimTrackvalid" + OutputPlotNameFix;
SeedPtforSimTrackvalidCanvas->SaveAs(SeedPtforSimTrackvalidCanvasName.c_str());
TCanvas* SeeddeltaPtforSimTrackvalidCanvas = new TCanvas("SeeddeltaPtforSimTrackvalidCanvas", "SeeddeltaPtforSimTrackvalidCanvas", 800, 600);
SeeddeltaPtforSimTrackvalidCanvas->cd();
SeeddeltaPtforSimTrackvalidHist->SetStats(1);
gStyle->SetOptFit(0111);
//SeeddeltaPtforSimTrackvalidHist->Fit("gaus", "", "", -1., 1.);
SeeddeltaPtforSimTrackvalidHist->GetXaxis()->SetTitle("(recPt-simPt)/simPt");
SeeddeltaPtforSimTrackvalidHist->GetXaxis()->CenterTitle();
SeeddeltaPtforSimTrackvalidHist->Draw();
string SeeddeltaPtforSimTrackvalidCanvasName = FinalOutput + "SeeddeltaPtforSimTrackvalid" + OutputPlotNameFix;
SeeddeltaPtforSimTrackvalidCanvas->SaveAs(SeeddeltaPtforSimTrackvalidCanvasName.c_str());
TCanvas* SeeddeltaPhiforSimTrackvalidCanvas = new TCanvas("SeeddeltaPhiforSimTrackvalidCanvas", "SeeddeltaPhiforSimTrackvalidCanvas", 800, 600);
SeeddeltaPhiforSimTrackvalidCanvas->cd();
SeeddeltaPhiforSimTrackvalidHist->SetStats(1);
SeeddeltaPhiforSimTrackvalidHist->GetXaxis()->SetTitle("(recPhi-simPhi)");
SeeddeltaPhiforSimTrackvalidHist->GetXaxis()->CenterTitle();
SeeddeltaPhiforSimTrackvalidHist->Draw();
string SeeddeltaPhiforSimTrackvalidCanvasName = FinalOutput + "SeeddeltaPhiforSimTrackvalid" + OutputPlotNameFix;
SeeddeltaPhiforSimTrackvalidCanvas->SaveAs(SeeddeltaPhiforSimTrackvalidCanvasName.c_str());
TCanvas* SeeddeltaEtaforSimTrackvalidCanvas = new TCanvas("SeeddeltaEtaforSimTrackvalidCanvas", "SeeddeltaEtaforSimTrackvalidCanvas", 800, 600);
SeeddeltaEtaforSimTrackvalidCanvas->cd();
SeeddeltaEtaforSimTrackvalidHist->SetStats(1);
SeeddeltaEtaforSimTrackvalidHist->GetXaxis()->SetTitle("(recEta-simEta)");
SeeddeltaEtaforSimTrackvalidHist->GetXaxis()->CenterTitle();
SeeddeltaEtaforSimTrackvalidHist->Draw();
string SeeddeltaEtaforSimTrackvalidCanvasName = FinalOutput + "SeeddeltaEtaforSimTrackvalid" + OutputPlotNameFix;
SeeddeltaEtaforSimTrackvalidCanvas->SaveAs(SeeddeltaEtaforSimTrackvalidCanvasName.c_str());
TCanvas* SeedPurityforSimTrackvalidCanvas = new TCanvas("SeedPurityforSimTrackvalidCanvas", "SeedPurityforSimTrackvalidCanvas", 800, 600);
SeedPurityforSimTrackvalidCanvas->cd();
SeedPurityforSimTrackvalidHist->Draw();
string SeedPurityforSimTrackvalidCanvasName = FinalOutput + "SeedPurityforSimTrackvalid" + OutputPlotNameFix;
SeedPurityforSimTrackvalidCanvas->SaveAs(SeedPurityforSimTrackvalidCanvasName.c_str());
TCanvas* ChargeCheckforSimTrackvalidCanvas = new TCanvas("ChargeCheckforSimTrackvalidCanvas", "ChargeCheckforSimTrackvalidCanvas", 800, 600);
ChargeCheckforSimTrackvalidCanvas->cd();
double HistEntries = ChargeCheckforSimTrackvalidHist->GetEntries() / 100.;
ChargeCheckforSimTrackvalidHist->Scale(1./HistEntries);
ChargeCheckforSimTrackvalidHist->GetXaxis()->SetTitle("simCharge*recCharge");
ChargeCheckforSimTrackvalidHist->GetXaxis()->CenterTitle(1);
ChargeCheckforSimTrackvalidHist->GetYaxis()->SetTitle("fraction %");
ChargeCheckforSimTrackvalidHist->GetYaxis()->CenterTitle(1);
ChargeCheckforSimTrackvalidHist->Draw();
string ChargeCheckforSimTrackvalidCanvasName = FinalOutput + "ChargeCheckforSimTrackvalid" + OutputPlotNameFix;
ChargeCheckforSimTrackvalidCanvas->SaveAs(ChargeCheckforSimTrackvalidCanvasName.c_str());
TCanvas* SeedNumberforSimTrackvalidCanvas = new TCanvas("SeedNumberforSimTrackvalidCanvas", "SeedNumberforSimTrackvalidCanvas", 800, 600);
SeedNumberforSimTrackvalidCanvas->cd();
SeedNumberforSimTrackvalidHist->Draw();
string SeedNumberforSimTrackvalidCanvasName = FinalOutput + "SeedNumberforSimTrackvalid" + OutputPlotNameFix;
SeedNumberforSimTrackvalidCanvas->SaveAs(SeedNumberforSimTrackvalidCanvasName.c_str());
TCanvas* SeedEfficiencyforSimTrackvalidCanvas = new TCanvas("SeedEfficiencyforSimTrackvalidCanvas", "SeedEfficiencyforSimTrackvalidCanvas", 800, 600);
SeedEfficiencyforSimTrackvalidCanvas->cd();
SeedEfficiencyforSimTrackvalidHist->Draw();
string SeedEfficiencyforSimTrackvalidCanvasName = FinalOutput + "SeedEfficiencyforSimTrackvalid" + OutputPlotNameFix;
SeedEfficiencyforSimTrackvalidCanvas->SaveAs(SeedEfficiencyforSimTrackvalidCanvasName.c_str());
TCanvas* SeedNumberforSimTrackinvalidCanvas = new TCanvas("SeedNumberforSimTrackinvalidCanvas", "SeedNumberforSimTrackinvalidCanvas", 800, 600);
SeedNumberforSimTrackinvalidCanvas->cd();
SeedNumberforSimTrackinvalidHist->Draw();
string SeedNumberforSimTrackinvalidCanvasName = FinalOutput + "SeedNumberforSimTrackinvalid" + OutputPlotNameFix;
SeedNumberforSimTrackinvalidCanvas->SaveAs(SeedNumberforSimTrackinvalidCanvasName.c_str());
TCanvas* SeedEfficiencyforSimTrackinvalidCanvas = new TCanvas("SeedEfficiencyforSimTrackinvalidCanvas", "SeedEfficiencyforSimTrackinvalidCanvas", 800, 600);
SeedEfficiencyforSimTrackinvalidCanvas->cd();
SeedEfficiencyforSimTrackinvalidHist->Draw();
string SeedEfficiencyforSimTrackinvalidCanvasName = FinalOutput + "SeedEfficiencyforSimTrackinvalid" + OutputPlotNameFix;
SeedEfficiencyforSimTrackinvalidCanvas->SaveAs(SeedEfficiencyforSimTrackinvalidCanvasName.c_str());
double SeedEfficiencyforSimTrackinvalid = 100. * SeedEfficiencyforSimTrackinvalidHist->GetMean();
double SeedEfficiencyforSimTrackvalid = 100. * SeedEfficiencyforSimTrackvalidHist->GetMean();
SeedEfficiencyHist->SetBinContent(1, SeedEfficiencyforSimTrackinvalid);
SeedEfficiencyHist->SetBinContent(2, SeedEfficiencyforSimTrackvalid);
SeedEfficiencyHist->GetXaxis()->SetBinLabel(1, "for invalid simTrack");
SeedEfficiencyHist->GetXaxis()->SetBinLabel(2, "for valid simTrack");
TCanvas* SeedEfficiencyCanvas = new TCanvas("SeedEfficiencyCanvas", "SeedEfficiencyCanvas", 800, 600);
SeedEfficiencyCanvas->cd();
SeedEfficiencyHist->GetYaxis()->SetTitle("Efficiency %");
SeedEfficiencyHist->GetYaxis()->CenterTitle(1);
SeedEfficiencyHist->SetMarkerStyle(3);
SeedEfficiencyHist->SetMarkerSize(3);
SeedEfficiencyHist->Draw("P");
string SeedEfficiencyCanvasName = FinalOutput + "SeedEfficiency" + OutputPlotNameFix;
SeedEfficiencyCanvas->SaveAs(SeedEfficiencyCanvasName.c_str());
TCanvas* RecBendingPhi2PtCanvas = new TCanvas("RecBendingPhi2PtCanvas", "RecBendingPhi2PtCanvas", 800, 600);
RecBendingPhi2PtCanvas->cd();
RecBendingPhi2PtHist->Draw();
string RecBendingPhi2PtCanvasName = FinalOutput + "RecBendingPhi2Pt" + OutputPlotNameFix;
RecBendingPhi2PtCanvas->SaveAs(RecBendingPhi2PtCanvasName.c_str());
TCanvas* PtRatoofRecBendingPhiCanvas = new TCanvas("PtRatoofRecBendingPhiCanvas", "PtRatoofRecBendingPhiCanvas", 800, 600);
PtRatoofRecBendingPhiCanvas->cd();
PtRatoofRecBendingPhiHist->Draw();
string PtRatoofRecBendingPhiCanvasName = FinalOutput + "PtRatoofRecBendingPhi" + OutputPlotNameFix;
PtRatoofRecBendingPhiCanvas->SaveAs(PtRatoofRecBendingPhiCanvasName.c_str());
TCanvas* RecBendingLastPhiCanvas = new TCanvas("RecBendingLastPhiCanvas", "RecBendingLastPhiCanvas", 800, 600);
RecBendingLastPhiCanvas->cd();
RecBendingLastPhiHist->Draw();
string RecBendingLastPhiCanvasName = FinalOutput + "RecBendingLastPhi" + OutputPlotNameFix;
RecBendingLastPhiCanvas->SaveAs(RecBendingLastPhiCanvasName.c_str());
Int_t linsav = gStyle->GetLineWidth();
gStyle->SetLineWidth(2);
TCanvas* SimReverseBendingCanvas = new TCanvas("SimReverseBendingCanvas", "SimReverseBendingCanvas", 800, 800);
SimReverseBendingCanvas->cd();
TPad* SimReverseBendingPad = new TPad("SimReverseBendingPad", "SimReverseBendingPad", 0, 0, 1, 1);
SimReverseBendingPad->Draw();
SimReverseBendingPad->cd();
SimReverseBendingPad->Range(-800, -800, 800, 800);
unsigned int segmentNumber = SimReverseBending->GetEntries();
cout << "Number of segments: " << segmentNumber << endl;
for(unsigned int j = 0; j < segmentNumber; j++) {
((TLine*)(SimReverseBending->At(j)))->Print();
((TLine*)(SimReverseBending->At(j)))->Draw("SAME");
}
string SimReverseBendingCanvasName = FinalOutput + "SimReverseBending" + OutputPlotNameFix;
SimReverseBendingCanvas->SaveAs(SimReverseBendingCanvasName.c_str());
}
//_________________________________________________________________________________
void integratedSplinesV5(double seed = 231)
{
//Load the data
int nEvents = 1000; //number of times the data will be randomized
int nPoints = 9;
double lowerBound = 10; //bounds for random vector function
double upperBound = 20;
double lowerErrorBound = 1;
double upperErrorBound = 2;
vector< vector<double> > xEvents, yEvents, yErrorEvents; //each of these is a vector of vectors (of randomized data points)
for(int i = 0; i < nEvents; i++)
{
vector <double> xData, yData, yErrorData; //temporary vectors that are only used to get random values from FillRand function
FillRandVectors(nPoints, xData, yData, yErrorData, seed*(i+1), lowerBound, upperBound, lowerErrorBound, upperErrorBound); //populates random vectors for y values and y error vector
xEvents.push_back(xData);
yEvents.push_back(yData);
yErrorEvents.push_back(yErrorData);
//Populate the global variables
xData_GLOB = xData;
yData_GLOB = yData;
yErrorData_GLOB = yErrorData;
}
//Intialization of the variables
const int npar = nPoints;
const int orderSpline = 4;
const int nbreak = npar+2-orderSpline;
double stepSpline = 0.01;
double xminBSplineWorkspace = 0;
double xmaxBSplineWorkspace = 9;
double startCSplineWorkspace = 15.;
double stepCSplineWorkspace = 1.5;
acc_GLOB = gsl_interp_accel_alloc ();
spline_GLOB = gsl_spline_alloc (gsl_interp_cspline, nPoints);
gsl_bspline_workspace *bw = gsl_bspline_alloc(orderSpline, nbreak);
//Setup for the C-spline_________________________________________________________________________
//Setting up TMinuit for C-spline minimization
TMinuit *myMinuit = new TMinuit(npar); //initialize TMinuit with a maximum of npar
myMinuit->SetFCN(fcn);
myMinuit->SetPrintLevel(-1); //No output: -1, output:1
double arglist[10];
int ierflg = 0;
arglist[0] = 1;
myMinuit->mnexcm("SET ERR", arglist, 1, ierflg);
vector<double> vstart, vstep;
for(int i=0; i < npar; i++) //set starting values and step sizes for parameters
{
vstart.push_back(startCSplineWorkspace);
vstep.push_back(stepCSplineWorkspace);
}
for (int i = 0; i < npar; i++)
{
stringstream ss;
ss<<"a"<<i;
myMinuit->mnparm(i, ss.str().c_str(), vstart.at(i), vstep.at(i), 0, 0, ierflg);
}
//Perform the Minuit fit
arglist[0] = 500;
arglist[1] = 1.;
//Setup for the B-spline_________________________________________________________________________
//Declare and allocate memory to compose data set of control points
gsl_vector *xControl = gsl_vector_alloc(nPoints);
gsl_vector *yControl = gsl_vector_alloc(nPoints);
gsl_vector *w = gsl_vector_alloc(nPoints);
gsl_vector *B = gsl_vector_alloc(npar);
gsl_matrix *X = gsl_matrix_alloc(nPoints, npar);
//Create a b spline workspace and allocate its memory
gsl_bspline_knots_uniform(xminBSplineWorkspace, xmaxBSplineWorkspace, bw);
//Set up the variables for the fit matrix
for (int i = 0; i < nPoints; ++i)
{
gsl_bspline_eval(gsl_vector_get(xControl, i), B, bw); //Compute B_j(xi) for all j
for (int j = 0; j < npar; ++j) gsl_matrix_set(X, i, j, gsl_vector_get(B, j)); //Fill in row i of X
}
gsl_vector *c = gsl_vector_alloc(npar);
gsl_multifit_linear_workspace *mw = gsl_multifit_linear_alloc(nPoints, npar);
gsl_matrix *cov = gsl_matrix_alloc(npar, npar);
//B and C spline loops__________________________________________________________________________
clock_t tbstart, tbstop, tcstart, tcstop;
vector <double> timeb, timec;
vector< vector<double> > xBSplineValues, yBSplineValues;
vector< vector<double> > xCSplineValues, yCSplineValues;
for(int i = 0; i < (int)xEvents.size(); i++)
{
//Populate gsl vectors with the appropriate data
for (int j = 0; j < nPoints; j++)
{
double xi = xEvents[i][j];
double yi = yEvents[i][j];
double sigma = yErrorEvents[i][j];
gsl_vector_set(xControl, j, xi);
gsl_vector_set(yControl, j, yi);
gsl_vector_set(w, j, 1.0/(sigma*sigma));
}
tbstart = clock();
vector< vector<double> > bSplineValues = bSpline(xEvents.at(i),stepSpline, bw, yControl, B, X, c, mw, cov);
tbstop = clock();
timeb.push_back(((float)tbstop-(float)tbstart)/ (CLOCKS_PER_SEC/1000.) );
xBSplineValues.push_back(bSplineValues.at(0));
yBSplineValues.push_back(bSplineValues.at(1));
tcstart = clock();
vector< vector<double> > cSplineValues = cSpline(nPoints, npar, xEvents.at(i), stepSpline, myMinuit, arglist, ierflg);
tcstop = clock();
timec.push_back(((float)tcstop-(float)tcstart)/ (CLOCKS_PER_SEC/1000.) );
xCSplineValues.push_back(cSplineValues.at(0));
yCSplineValues.push_back(cSplineValues.at(1));
}
//Histograms______________________________________________________________________________________
//Time
int nbins = 100;
double xlow = 0;
double xup = 1.;
TH1D *hTimeB = new TH1D("Time","Timing; time [ms]; Number of Events", nbins, xlow, xup);
hTimeB->SetStats(0);
TH1D *hTimeC = new TH1D("TimeC","Timing; time [ms]; Number of Events", nbins, xlow, xup);
hTimeC->SetLineColor(kRed);
hTimeC->SetStats(0);
for(int i=0; i<(int)timec.size(); i++)
{
hTimeB->Fill(timeb.at(i));
hTimeC->Fill(timec.at(i));
}
//Interpolation distance
vector <double> interpB, interpC;
for(int i = 0; i < (int)yEvents.size(); i++)
{
for(int j = 0; j < (int)yEvents[i].size(); j++)
{
double key = xEvents[i][j];
int indexForB = binarySearch(xBSplineValues[i], key);
int indexForC = binarySearch(xCSplineValues[i], key);
if(indexForB != -1)
interpB.push_back( (yEvents[i][j]-yBSplineValues[i][indexForB])/yErrorEvents[i][indexForB] );
if(indexForC != -1)
interpC.push_back( (yEvents[i][j]-yCSplineValues[i][indexForC])/yErrorEvents[i][indexForC] );
}
}
int nbinsI = 40;
int xlowI = -4;
int xupI = 4;
TH1D *hInterpB = new TH1D("Interp B","Interpolation; Distance between spline and data normalized by error; Number of Events", nbinsI, xlowI, xupI);
for(int i=0; i<(int)interpB.size(); i++) hInterpB->Fill(interpB.at(i));
hInterpB->SetStats(0);
TH1D *hInterpC = new TH1D("Interp C","Interpolation; Distance between spline and data normalized by error; Number of Events", nbinsI, xlowI, xupI);
for (int i=0; i<(int)interpC.size(); i++) hInterpC->Fill(interpC.at(i));
hInterpC->SetLineColor(kRed);
hInterpC->SetStats(0);
//Draws______________________________________________________________________________________
//Interpolation
TLegend *legInterp = new TLegend(0.9,0.70,0.75,0.85);
legInterp->SetLineColor(kWhite);
legInterp->SetFillColor(kWhite);
legInterp->SetMargin(0.3);
legInterp->AddEntry(hInterpB,"b-spline","l");
legInterp->AddEntry(hInterpC,"c-spline","l");
legInterp->SetTextSize(0.05);
TCanvas *c1 = new TCanvas("c1", "Interpolation distance");
c1->cd();
hInterpB->Draw("");
hInterpC->Draw("same");
legInterp->Draw();
//Time
TLegend *legTime = new TLegend(0.9,0.70,0.75,0.85);
legTime->SetLineColor(kWhite);
legTime->SetFillColor(kWhite);
legTime->SetMargin(0.3);
legTime->AddEntry(hTimeB,"b-spline","l");
legTime->AddEntry(hTimeC,"c-spline","l");
legTime->SetTextSize(0.05);
TCanvas *c2 = new TCanvas("c2", "Computation time");
c2->cd();
hTimeB->Draw("");
hTimeC->Draw("same");
legTime-> Draw();
//Free the memory____________________________________________________________________________
gsl_spline_free (spline_GLOB);
gsl_interp_accel_free (acc_GLOB);
gsl_bspline_free(bw);
gsl_vector_free(xControl);
gsl_vector_free(yControl);
gsl_vector_free(B);
gsl_matrix_free(X);
gsl_vector_free(c);
gsl_multifit_linear_free(mw);
gsl_matrix_free(cov);
}
void chipHistos(const char *filenames = "/export/data1/dambach/hardware/ntpls/gradeA/*.root")
{
Init(); // do not forget to load the Utilities.C
TH1D *gainH = new TH1D("gainH", "RMS(gain)/Mean(gain)", 100, 0., 0.2);
TH1D *pedH = new TH1D("pedH", "RMS(pedestal)", 100, 0., 100.);
TH1D *noiseH = new TH1D("noiseH", "RMS(trimmed threshold)", 100, 0., 8.);
TH1D *tthrH = new TH1D("tthrH", "Mean (trimmed threshold)", 100, 50., 70.);
TH1D *gainDist = new TH1D("gainDist", "gainR/gainM", 100, 0., 10.);
TH1D *pedDist = new TH1D("pedDist", "pedR", 100, -1000., 1000.);
TChain *c = new TChain("mod");
c->Add(filenames);
float ped[16][4160], gain[16][4160];
int defects[16][4160];
c->SetBranchAddress("ped", ped);
c->SetBranchAddress("gain", gain);
c->SetBranchAddress("defects", defects);
int nb(0), nbytes(0);
for (int i = 0; i < c->GetEntries(); ++i)
{
nb = c->GetEntry(i); nbytes += nb;
for(int chipId = 0; chipId < 16; chipId++)
{
gainDist->Reset();
pedDist->Reset();
int allPix = 4160;
for (int p = 0; p < allPix; p++)
{
if(defects[chipId][p] == 0)
{
gainDist->Fill(gain[chipId][p]);
pedDist->Fill(ped[chipId][p]);
}
}
double gainRMS = gainDist->GetRMS();
double pedRMS = pedDist->GetRMS();
double gainMean = gainDist->GetMean();
double pedMean = pedDist->GetMean();
if (gainMean != 0) gainH->Fill(gainRMS/gainMean);
pedH->Fill(pedRMS);
}
}
canvas->Clear();
canvas->Divide(2,2);
canvas->cd(1);
InitPad("log");
gainH->GetXaxis()->SetTitle("DAC units");
gainH->GetYaxis()->SetTitle("# pixels");
gainH->GetXaxis()->SetTitleSize(0.055);
gainH->GetYaxis()->SetTitleSize(0.055);
gainH->Draw();
canvas->cd(2);
InitPad("log");
pedH->GetXaxis()->SetTitle("DAC units");
pedH->GetYaxis()->SetTitle("# pixels");
pedH->GetXaxis()->SetTitleSize(0.055);
pedH->GetYaxis()->SetTitleSize(0.055);
pedH->Draw();
canvas->cd(3);
InitPad("log");
noiseH->GetXaxis()->SetTitle("DAC units");
noiseH->GetYaxis()->SetTitle("# pixels");
noiseH->GetXaxis()->SetTitleSize(0.055);
noiseH->GetYaxis()->SetTitleSize(0.055);
c->Draw("tthrR>>noiseH");
canvas->cd(4);
InitPad("log");
tthrH->SetMinimum(0.5);
tthrH->GetXaxis()->SetTitle("DAC units");
tthrH->GetYaxis()->SetTitle("# pixels");
tthrH->GetXaxis()->SetTitleSize(0.055);
tthrH->GetYaxis()->SetTitleSize(0.055);
c->Draw("tthrM>>tthrH");
}
void mcClosure(bool isFW=1, bool isPrompt=1) {
TString direction;
if (isFW) direction="FW";
else direction ="BW";
TH1::SetDefaultSumw2();
TFile* f1;
if ( isPrompt) f1 = new TFile("/home/samba/songkyo/efficiency/PRMC_eff_rootFile/merged_PRMC_eff_Histos.root");
else f1 = new TFile("/home/samba/songkyo/efficiency/NPMC_eff_rootFile/merged_NPMC_eff_Histos.root");
//read-in tree
TTree *mytree = (TTree*)f1->Get("myTree");
TFile * fEff;
if ( isPrompt) fEff = new TFile("EffAna_PRMC_boosted.root");
else fEff = new TFile("EffAna_NPMC_boosted.root");
TH1D* hEff[10];
hEff[0] = (TH1D*)fEff->Get(Form("h1D_EffDimu_pt_bin_%s",direction.Data()));
hEff[1] = (TH1D*)fEff->Get(Form("h1D_EffDimu_pt_bin_%s_trig",direction.Data()));
hEff[2] = (TH1D*)fEff->Get(Form("h1D_EffDimu_pt_bin_%s_mupl",direction.Data()));
hEff[3] = (TH1D*)fEff->Get(Form("h1D_EffDimu_pt_bin_%s_mumi",direction.Data()));
hEff[4] = (TH1D*)fEff->Get(Form("h1D_EffDimu_pt_bin_%s_jpsi",direction.Data()));
hEff[5] = (TH1D*)fEff->Get(Form("h1D_EffDimu_pt_bin_%s_mass",direction.Data()));
cout << "///////////////////////////////////////////////////////////////////////" << endl;
cout << " Acceptance is calculated by YONGSUN's code not from Hyunchul's code" << endl;
cout << "///////////////////////////////////////////////////////////////////////" << endl;
TH1D* hAcc = (TH1D*)fEff->Get(Form("h1D_Acc_pt_bin_%s",direction.Data()));
for ( int i=0 ; i<=5 ;i++) {
handsomeTH1(hEff[i],i+1);
}
/*
TFile * fAcc;
if ( isPrompt) fAcc = new TFile("AccAna_20131219_PromptJpsi_boosted_binCode_1.root");
else fAcc = new TFile("AccAna_20131219_PromptJpsi_boosted_binCode_1.root");
TH1D* hAcc = (TH1D*)fAcc->Get(Form("h1D_Acc_pt_bin2_%s_20131219",direction.Data()));
*/
TCanvas* c0 = new TCanvas("c0","",1000,500);
c0->Divide(2,1);
c0->cd(1);
hEff[0]->SetXTitle("p_{T} (GeV)");
hEff[0]->SetYTitle("Efficiency");
hEff[0]->SetAxisRange(0,1.1,"Y");
hEff[0]->Draw();
for (int i=1; i<=4 ;i++) {
hEff[i]->Draw("same");
}
jumSun(6.5,1,30,1);
c0->cd(2);
handsomeTH1(hAcc,1);
hAcc->SetXTitle("p_{T} (GeV)");
hAcc->SetYTitle("Acceptance");
hAcc->SetAxisRange(0,1.1,"Y");
hAcc->Draw();
jumSun(6.5,1,30,1);
TCanvas* c1 = new TCanvas("c1","",500,500);
c1->cd();
double ptBin[] = {6.5, 7.5, 8.5, 9.5, 10.5, 11.5, 13.0, 16.0, 20.0, 30.0};
const int nPtBin = sizeof(ptBin)/sizeof(double) - 1;
TH1D* hptGen = new TH1D("hptGen",";J/psi p_{T} (GeV)",nPtBin,ptBin);
TH1D* hptReco = (TH1D*)hptGen->Clone("hptReco");
// Cuts
TCut genRapCut, recoRapCut;
if (isFW) {
genRapCut = "(Gen_QQ_4mom[0].Rapidity()>-2.4) && (Gen_QQ_4mom[0].Rapidity()<-.47)";
recoRapCut = "(Reco_QQ_4mom[0].Rapidity()>-2.4) && (Reco_QQ_4mom[0].Rapidity()<-.47) && (Reco_QQ_mupl_4mom[0].Rapidity()>-2.4) && (Reco_QQ_mupl_4mom[0].Rapidity()<-.47) && (Reco_QQ_mumi_4mom[0].Rapidity()>-2.4) && (Reco_QQ_mumi_4mom[0].Rapidity()<-.47) && (Reco_QQ_trig&1)==1";
}
else {
genRapCut = "Gen_QQ_4mom[0].Rapidity()>-.47 && Gen_QQ_4mom[0].Rapidity()<1.47";
recoRapCut = "(Reco_QQ_4mom[0].Rapidity()>-.47) && (Reco_QQ_4mom[0].Rapidity()<1.47) && (Reco_QQ_mupl_4mom[0].Rapidity()>-.47 && Reco_QQ_mupl_4mom[0].Rapidity()<1.47) && (Reco_QQ_mumi_4mom[0].Rapidity()>-.47 && Reco_QQ_mumi_4mom[0].Rapidity()<1.47) && (Reco_QQ_trig&1)==1";
}
TCut recoMassCut = "Reco_QQ_4mom[0].M()>2.95 && Reco_QQ_4mom[0].M()<3.25";
TCut recoAccCutPlus = ""; //" Reco_QQ_mupl_4mom[0].Eta()>-2.4 && Reco_QQ_mupl_4mom[0].Eta()<1.47 && ( ( abs(Reco_QQ_mupl_4mom[0].Eta())>2.2 && abs(Reco_QQ_mupl_4mom[0].Eta())<2.4 && Reco_QQ_mupl_4mom[0].Pt()>0.8 ) || ( abs(Reco_QQ_mupl_4mom[0].Eta())>1.3 && abs(Reco_QQ_mupl_4mom[0].Eta())<=2.2 && Reco_QQ_mupl_4mom[0].P()>2.9 ) || ( abs(Reco_QQ_mupl_4mom[0].Eta())<=1.3 && Reco_QQ_mupl_4mom[0].Pt()>3.3 ) )";
TCut recoAccCutMinus = ""; //" Reco_QQ_mumi_4mom[0].Eta()>-2.4 && Reco_QQ_mumi_4mom[0].Eta()<1.47 && ( ( abs(Reco_QQ_mumi_4mom[0].Eta())>2.2 && abs(Reco_QQ_mumi_4mom[0].Eta())<2.4 && Reco_QQ_mumi_4mom[0].Pt()>0.8 ) || ( abs(Reco_QQ_mumi_4mom[0].Eta())>1.3 && abs(Reco_QQ_mumi_4mom[0].Eta())<=2.2 && Reco_QQ_mumi_4mom[0].P()>2.9 ) || ( abs(Reco_QQ_mumi_4mom[0].Eta())<=1.3 && Reco_QQ_mumi_4mom[0].Pt()>3.3 ) )";
TCut recoAccCut = recoAccCutPlus && recoAccCutMinus;
Long64_t nEntry = 100000000;
mytree->Draw(Form("Gen_QQ_4mom[0].Pt()>>%s",hptGen->GetName()), genRapCut, "",nEntry);
mytree->Draw(Form("Reco_QQ_4mom[0].Pt()>>%s",hptReco->GetName()), recoRapCut && recoMassCut && recoAccCut, "",nEntry);
TH1D* hptRecoCorr = (TH1D*)hptReco->Clone("hptRecoCorr");
hptRecoCorr->Divide(hEff[0]);
hptRecoCorr->Divide(hAcc);
handsomeTH1(hptGen,1);
hptGen->SetAxisRange(1,1.5e5,"Y");
hptGen->Draw("hist");
handsomeTH1(hptReco,2);
hptReco->SetMarkerStyle(24);
hptReco->Draw("same");
handsomeTH1(hptRecoCorr,2);
hptRecoCorr->Draw("same");
TLegend *l = new TLegend(0.4233871,0.5042373,0.8689516,0.7521186,NULL,"brNDC");
easyLeg(l,"Yield");
l->AddEntry(hptGen,"Generated J/#psi","l");
l->AddEntry(hptReco,"Reco yield","p");
l->AddEntry(hptRecoCorr,"Reco/(Acc*Eff)","p");
l->Draw();
}