TProfile* overlayTProfiles(TH2F* hdata, TH2F* hdy, float ymin, float ymax, TString savename)
{
// See how the mean of the dimumass changes vs some variable by making TProfiles of a 2D histogram with the Dimu mass as the y axis.
// Compare data to MC and save the results as png files.
TString dataname = TString("Golden_JSON_DoubleMuon_Data");
TString dyname = TString("Drell_Yan_Monte_Carlo_2015");
// Make TProfiles from them to see how the mean changes vs the x variable.
TProfile* pdata = hdata->ProfileX();
pdata->SetLineColor(1);
pdata->SetLineWidth(3);
pdata->SetTitle(hdata->GetTitle());
pdata->GetYaxis()->SetTitle(hdata->GetYaxis()->GetTitle());
TProfile* pdy = hdy->ProfileX();
pdy->SetLineColor(2);
pdy->SetLineWidth(3);
pdy->SetTitle(hdy->GetTitle());
pdy->GetYaxis()->SetTitle(hdy->GetYaxis()->GetTitle());
std::cout<< "hdata: " << hdata << std::endl;
std::cout<< "hdy: " << hdy << std::endl;
std::cout<< "pdata: " << pdata << std::endl;
std::cout<< "pdy: " << pdy << std::endl;
TCanvas* c = new TCanvas();
c->SetGridx(kTRUE);
c->SetGridy(kTRUE);
// Draw data and MC on the same plot
// Have to draw the same plots twice to get error bars and a curve through the error bars.
c->cd();
// hdata->Draw("colz");
pdata->SetAxisRange(ymin,ymax,"Y");
pdata->Draw("hist c");
pdata->Draw("E X0 same");
pdy->Draw("hist c same");
pdy->Draw("E X0 same");
// Stat box alignment
DiMuPlottingSystem* dps = new DiMuPlottingSystem();
dps->arrangeStatBox(c);
// Legend
TLegend* l = new TLegend(0.15, 0.15, 0.7, 0.25, "", "brNDC");
l->AddEntry(pdata, dataname, "l");
l->AddEntry(pdy, dyname, "l");
l->Draw("same");
c->Print(savename);
return pdata;
}
//------------------------------------------------------------//
// Get TProfile
//------------------------------------------------------------//
TProfile* getProfile(TFile* file, TString pname, TString xtitle,
TString ytitle, int color, int marker)
{
TProfile* prof = (TProfile*) (file->Get(pname.Data())->Clone(Form("%s_%i",pname.Data(),color)));
prof->GetXaxis()->SetTitle(xtitle.Data());
prof->GetYaxis()->SetTitle(ytitle.Data());
prof->SetMarkerStyle(marker);
prof->SetMarkerColor(color);
//prof->SetMarkerSize(0.5);
prof->SetLineColor(color);
prof->SetTitle("");
prof->SetStats(0);
prof->GetYaxis()->SetTitleOffset(1.5);
return prof;
}
void profile()
{
TCanvas* c1 = new TCanvas("canvas","nhitac",1200,600);
c1->Divide(2,1);
c1->cd(1);
TFile *file1 = new TFile("test_nhitac_modified.root");
//TH1F *histo1 = new TH1F("nhitac1","nhitac1",60,0,300);
TProfile *profile1 = new TProfile("profile","nhitac profile",100,0,100,0,300);
TFile *file2 = new TFile("test_nhitac_unmodified.root");
//TH1F *histo2 = new TH1F("nhitac","nhitac",60,0,300);
TProfile *profile2 = new TProfile("profile2","nhitac profile2",100,0,100,0,300);
TProfile *ratio = new TProfile("ratio","nhitac ratio", 100,0,100,0,2);
//histo2->SetMarkerStyle(31);
TLegend *l1 = new TLegend(0.20, 0.60, 0.3, 0.7);
l1->SetBorderSize(0);
TTree* nhitac_modified = (TTree*)file1->Get("testnhitac");
TTree* nhitac_unmodified = (TTree*)file2->Get("testnhitac");
int testnhitac1, testnhitac2;
nhitac_modified->SetBranchAddress("nhitac",&testnhitac1);
nhitac_unmodified->SetBranchAddress("nhitac",&testnhitac2);
for(int i= 0; i < nhitac_modified->GetEntries(); i++)
{
nhitac_modified->GetEntry(i);
nhitac_unmodified->GetEntry(i);
profile1->Fill(i,testnhitac1);
profile2->Fill(i,testnhitac2);
double temp = testnhitac2;
ratio->Fill(i,testnhitac1/temp);
//histo1->Fill(testnhitac1);
//histo2->Fill(testnhitac2);
}
//histo1->SetMarkerColor(kRed);
//histo1->SetLineColor(kRed);
profile1->SetMarkerColor(kRed);
profile1->SetMarkerStyle(5);
profile2->SetMarkerColor(kBlue);
l1->AddEntry(profile1,"modified od bad channel","P");
l1->AddEntry(profile2,"old od bad channel","l");
l1->SetTextSize(0.04);
profile1->Draw("e1p");
profile1->GetXaxis()->SetTitle("event #");
profile1->GetYaxis()->SetTitle("nhitac");
profile2->Draw("same");
l1->Draw();
c1->cd(2);
ratio->GetXaxis()->SetTitle("event #");
ratio->GetYaxis()->SetTitle("new/old");
//ratio->SetMarkerStyle(5);
//ratio->SetMarkerColor(kRed);
ratio->Draw();
}
TCanvas *Plot2D_profileX_my(TChain *data, TString branchname, TString binning,TString selection,TString opt,TString xLabel, TString yLabel){
//type == 0: data only
//type == 1: MC only
//type == 2: data/MC
TCanvas *c = new TCanvas("c","");
data->Draw(branchname+">>data_hist"+binning,selection,opt);
TH2F *d = (TH2F *) gROOT->FindObject("data_hist");
TCanvas *c1 = new TCanvas("c1","");
TProfile *prof = d->ProfileX("prof",1,-1,"s");
prof->SetMarkerStyle(20);
prof->SetMarkerSize(1);
prof->Draw();
prof->GetYaxis()->SetTitle(yLabel);
prof->GetXaxis()->SetTitle(xLabel);
return c1;
}
TProfile* plotIsoPerformance( TFile* ftt,
const char* signal, // histogram name
const char* background, // histogram name
const char* name, // unique name
bool reverse = false, // normally signal near zero bin, reverse means signal is around max bin
double bkg_eff_min = 0,
double bkg_eff_max = 1,
double sig_eff_min = 0,
double sig_eff_max = 0
)
{
TH1F* S = dynamic_cast<TH1F*>(ftt->Get(signal));
if ( ! S ) {
std::cout << "Error: histogram not found " << signal << std::endl;
return 0;
}
TH1F* B = dynamic_cast<TH1F*>(ftt->Get(background));
if ( ! B ) {
std::cout << "Error: histogram not found " << background << std::endl;
return 0;
}
char buf[1024];
sprintf(buf,"c_%s",name);
// TCanvas* c = new TCanvas(buf,buf,500,500);
sprintf(buf,"p_%s",name);
TProfile* p = new TProfile(buf,buf,50,bkg_eff_min,bkg_eff_max,sig_eff_min,sig_eff_max);
p->SetLineColor(kBlue);
p->SetLineWidth(2);
p->SetMarkerStyle(20);
p->SetMarkerSize(1);
p->GetXaxis()->SetTitle("Background Efficiency");
p->GetYaxis()->SetTitle("Signal Efficiency");
p->SetStats(kFALSE);
for( int i=0;i<=S->GetNbinsX()+1; ++i )
if ( reverse )
p->Fill(B->Integral(i,B->GetNbinsX()+1)/B->Integral(0,B->GetNbinsX()+1),
S->Integral(i,S->GetNbinsX()+1)/S->Integral(0,S->GetNbinsX()+1));
else
p->Fill(B->Integral(0,i)/B->Integral(0,B->GetNbinsX()+1),
S->Integral(0,i)/S->Integral(0,S->GetNbinsX()+1));
// p->Draw();
return p;
}
void Fake100PeVShower(int opt)
{
// opt == 0 implies save to root file
// opt == 1 implies plot and save to canvas
TFile* file = NULL;
TCanvas* c = NULL;
if(opt == 0)
file = new TFile("fake100PeVShower.root","recreate");
if(opt == 1)
c = makeCanvas("c");
TString gaus = "1.5e7*TMath::Exp(-(pow(x-10,2)/9))";
TString bump = "5e6*TMath::Exp(-(pow(x-17,2)/20))";
TF1* f = new TF1("f",(gaus+"+"+bump).Data(),0,30);
int nbins = 3000;
float xmin = 0;
float xmax = 30;
TProfile* prof = new TProfile("prof","",nbins,xmin,xmax);
prof->SetStats(0);
prof->SetTitle("");
prof->GetYaxis()->SetTitle("Charge excess / 1e7");
prof->GetXaxis()->SetTitle("z [m]");
float step = xmax / nbins;
for(int i =0; i<nbins; ++i){
float x = step * i;
if(opt == 1 ) prof->Fill(x, f->Eval(x)/1e7);
else prof->Fill(x, f->Eval(x));
}
if(opt == 1){
prof->Draw();
c->SaveAs("JaimeCheck/FakeProfile100PeV.png");
}
if(opt == 0){
file->Write();
file->Close();
}
}
void fitBjetJES(int ppPbPb=1, int cbinlo=12, int cbinhi=40){
if(!ppPbPb){
cbinlo=0;
cbinhi=40;
}
gStyle->SetOptTitle(0);
gStyle->SetOptStat(0);
TFile *fL;
if(!ppPbPb)fL=new TFile("histos/ppMC_hiReco_jetTrig_highPurity_JEC.root");
else fL=new TFile("histos/PbPbQCDMC_pt30by3_ipHICalibCentWeight.root");
// these are dummy files for pp
TFile *fB=new TFile("histos/PbPbBMC_pt30by3_ipHICalibCentWeight.root");
TFile *fC=new TFile("histos/PbPbCMC_pt30by3_ipHICalibCentWeight.root");
TNtuple *tL = (TNtuple*) fL->Get("nt");
TNtuple *tB = (TNtuple*) fB->Get("nt");
TNtuple *tC = (TNtuple*) fC->Get("nt");
float jtptL, refptL, jtetaL, weightL, refparton_flavorForBL, binL;
tL->SetBranchAddress("jtpt",&jtptL);
tL->SetBranchAddress("jteta",&jtetaL);
tL->SetBranchAddress("refpt",&refptL);
tL->SetBranchAddress("weight",&weightL);
if(ppPbPb)tL->SetBranchAddress("bin",&binL);
tL->SetBranchAddress("refparton_flavorForB",&refparton_flavorForBL);
float jtptB, refptB, jtetaB, weightB, refparton_flavorForBB, binB;
tB->SetBranchAddress("jtpt",&jtptB);
tB->SetBranchAddress("jteta",&jtetaB);
tB->SetBranchAddress("refpt",&refptB);
tB->SetBranchAddress("weight",&weightB);
if(ppPbPb)tB->SetBranchAddress("bin",&binB);
tB->SetBranchAddress("refparton_flavorForB",&refparton_flavorForBB);
float jtptC, refptC, jtetaC, weightC, refparton_flavorForBC, binC;
tC->SetBranchAddress("jtpt",&jtptC);
tC->SetBranchAddress("jteta",&jtetaC);
tC->SetBranchAddress("refpt",&refptC);
tC->SetBranchAddress("weight",&weightC);
if(ppPbPb)tC->SetBranchAddress("bin",&binC);
tC->SetBranchAddress("refparton_flavorForB",&refparton_flavorForBC);
TProfile *hL = new TProfile("hL","hL",250,50,300,0,10);
TProfile *hB = new TProfile("hB","hB",250,50,300,0,10);
TProfile *hC = new TProfile("hC","hC",250,50,300,0,10);
hL->Sumw2(),hB->Sumw2(),hC->Sumw2();
for(int i=0;i<tL->GetEntries();i++){
tL->GetEntry(i);
if(!ppPbPb) binL=39;
if(fabs(jtetaL)<2 && binL>=cbinlo && binL<cbinhi)
hL->Fill(refptL,jtptL/refptL,weightL);
if(!ppPbPb){
if(fabs(jtetaL)<2 && binL>=cbinlo && binL<cbinhi && abs(refparton_flavorForBL)==5)
hB->Fill(refptL,jtptL/refptL,weightL);
if(fabs(jtetaL)<2 && binL>=cbinlo && binL<cbinhi && abs(refparton_flavorForBL)==4)
hC->Fill(refptL,jtptL/refptL,weightL);
}
}
if(ppPbPb){
for(int i=0;i<tB->GetEntries();i++){
tB->GetEntry(i);
if(fabs(jtetaB)<2 && binB>=cbinlo && binB<cbinhi && abs(refparton_flavorForBB)==5)
hB->Fill(refptB,jtptB/refptB,weightB);
}
for(int i=0;i<tC->GetEntries();i++){
tC->GetEntry(i);
if(fabs(jtetaC)<2 && binC>=cbinlo && binC<cbinhi && abs(refparton_flavorForBC)==4)
hC->Fill(refptC,jtptC/refptC,weightC);
}
}
hL->SetMinimum(0.);
hL->SetLineColor(kBlue);
hB->SetLineColor(kRed);
hC->SetLineColor(kGreen);
hL->SetMarkerColor(kBlue);
hB->SetMarkerColor(kRed);
hC->SetMarkerColor(kGreen);
//hL->SetMarkerStyle(4);
//hB->SetMarkerStyle(4);
//hC->SetMarkerStyle(4);
hL->SetXTitle("genJet p_{T} (GeV/c)");
hL->SetYTitle("<reco p_{T} / gen p_{T} >");
hL->GetXaxis()->SetRangeUser(50.,199.999);
hL->GetYaxis()->SetRangeUser(0.5,1.05);
TCanvas *c1=new TCanvas("c1","c1",800,600);
c1->SetGridx(1);
c1->SetGridy(1);
hL->Draw("e1");
hB->Draw("e1,same");
hC->Draw("e1,same");
TLegend *leg=new TLegend(0.4,0.15,0.9,0.45);
leg->SetBorderSize(0);
leg->SetFillStyle(0);
if(ppPbPb&&cbinlo==0&&cbinhi==40)leg->SetHeader("Pythia+Hydjet, 0-100%");
leg->AddEntry(hL,"Inclusive jets","pl");
leg->AddEntry(hC,"c-jets","pl");
leg->AddEntry(hB,"b-jets","pl");
leg->Draw();
TCanvas *c2=new TCanvas("c2","c2",1);
/*
TH1F *hL2 = (TH1F*)hL->Clone("hL2");
TH1F *hB2 = (TH1F*)hB->Clone("hB2");
hL2->Add(hB2,-1);
hL2->Draw();
*/
TH1F *hcorr = new TH1F("hcorr","hcorr",250,50,300);
hcorr->Sumw2();
for(int i=0;i<hL->GetNbinsX();i++){
cout<<" b resp "<<hB->GetBinContent(i+1)<<endl;
cout<<" l resp "<<hL->GetBinContent(i+1)<<endl;
cout<<" l offset "<<1.-hL->GetBinContent(i+1)<<endl;
cout<<" corrected b resp "<<hB->GetBinContent(i+1)+1.-hL->GetBinContent(i+1)<<endl;
float jesOffset = 1.-hL->GetBinContent(i+1);
hcorr->SetBinContent(i+1,hB->GetBinContent(i+1)+jesOffset);
hcorr->SetBinError(i+1,sqrt(hB->GetBinError(i+1)*hB->GetBinError(i+1)+hL->GetBinError(i+1)*hL->GetBinError(i+1)));
}
hcorr->SetMinimum(0.5);
hcorr->SetMaximum(1.1);
hcorr->SetLineColor(kRed);
hcorr->SetMarkerColor(kRed);
hcorr->SetMarkerStyle(4);
hcorr->Draw();
TF1 *fCorr = new TF1("fCorr","[0]+[1]*log(x)+[2]*log(x)*log(x)",50,300);
fCorr->SetLineWidth(1);
fCorr->SetLineColor(kBlue);
hcorr->Fit(fCorr);
TFile *fout;
if(ppPbPb) fout =new TFile(Form("bJEShistos/bJetScale_PbPb_Cent_fineBin_%d_%d.root",cbinlo,cbinhi),"recreate");
else fout =new TFile("bJEShistos/bJetScale_PP_fineBin.root","recreate");
hcorr->Write();
fCorr->Write();
fout->Close();
}
void RunPidGetterQAEff()
{
TString PidFrameworkDir = "/lustre/nyx/cbm/users/klochkov/soft/PidFramework/";
gSystem->Load( PidFrameworkDir + "build/libPid");
gStyle->SetOptStat(0000);
TFile *f2 = new TFile("pid_0.root");
TTree *PidTree = (TTree*) f2->Get("PidTree");
TofPidGetter *getter = new TofPidGetter();
TBranch *PidGet = PidTree->GetBranch("TofPidGetter");
PidGet->SetAddress(&getter);
PidGet->GetEntry(0);
Float_t ret[3];
TProfile *hEffP = new TProfile ("hEffP", "", 100, 0, 10);
TProfile *hEffPi = new TProfile ("hEffPi", "", 100, 0, 6);
TProfile *hEffK = new TProfile ("hEffK", "", 100, 0, 5);
TProfile *hEffPSigma = new TProfile ("hEffPSigma", "", 100, 0, 10);
TProfile *hEffPiSigma = new TProfile ("hEffPiSigma", "", 100, 0, 6);
TProfile *hEffKSigma = new TProfile ("hEffKSigma", "", 100, 0, 5);
TProfile2D *hEffPtYP = new TProfile2D ("hEffPtYP", "", 100, -2.5, 2.5, 100, 0, 4);
TProfile2D *hEffPtYK = new TProfile2D ("hEffPtYK", "", 100, -2.5, 2.5, 100, 0, 4);
TProfile2D *hEffPtYPi = new TProfile2D ("hEffPtYPi", "", 100, -2.5, 2.5, 100, 0, 4);
TString InTreeFileName = "/lustre/nyx/cbm/users/dblau/cbm/mc/UrQMD/AuAu/10AGeV/sis100_electron/SC_ON/2016_09_01/tree/11111.root";
TFile *InFile = new TFile(InTreeFileName);
TTree *InTree = (TTree*) InFile->Get("fDataTree");
DataTreeEvent* DTEvent;
InTree -> SetBranchAddress("DTEvent",&DTEvent);
int nevents = 100000;//InTree->GetEntries();
int outputstep = 100;
std::cout << "Entries = " << nevents << std::endl;
for (int j=0;j<nevents;j++)
{
if ( (j+1) % outputstep == 0) std::cout << j+1 << "/" << nevents << "\r" << std::flush;
InTree->GetEntry(j);
Int_t Nmc[3] = {100,100,100};
Int_t Ntof[3] = {0,0,0};
Int_t PdgCode[3] = {2212, 212, 211};
Double_t sigmas [3] = {0,0,0};
for (int i=0;i<DTEvent->GetNTracks(); i++)
{
TLorentzVector v;
DataTreeTrack* track = DTEvent -> GetTrack(i);
DataTreeMCTrack* mctrack = DTEvent -> GetMCTrack(i);
Double_t p = mctrack->GetPt() * TMath::CosH( mctrack->GetEta() );
if (track->GetTOFHitId() < 0)
{
if (mctrack->GetPdgId() == 2212 )
{
v.SetPtEtaPhiM (track->GetPt(0), track->GetEta(0), track->GetPhi(0), 0.9386);
hEffP->Fill ( p, 0 );
hEffPSigma->Fill ( p, 0 );
hEffPtYP -> Fill( v.Rapidity() - 1.52, v.Pt(), 0 );
}
if (mctrack->GetPdgId() == 321 )
{
v.SetPtEtaPhiM (track->GetPt(0), track->GetEta(0), track->GetPhi(0), 0.5);
hEffK->Fill ( p, 0 );
hEffKSigma->Fill ( p, 0 );
hEffPtYK -> Fill( v.Rapidity() - 1.52, v.Pt(), 0 );
}
if (mctrack->GetPdgId() == 211 )
{
v.SetPtEtaPhiM (track->GetPt(0), track->GetEta(0), track->GetPhi(0), 0.14);
hEffPi->Fill ( p, 0 );
hEffPiSigma->Fill ( p, 0);
hEffPtYPi -> Fill( v.Rapidity() - 1.52, v.Pt(), 0 );
}
continue;
}
//
DataTreeTOFHit* toftrack = DTEvent -> GetTOFHit(track->GetTOFHitId());
p = toftrack->GetP();
Double_t m2 = toftrack->GetMass2 ();
Bool_t cut = toftrack->GetBeta() > 0.1 && ( track->GetChiSq(0)/track->GetNDF(0) < 3 ) && p > 1.0 ;
if ( !cut ) continue;
getter->GetBayesProbability (m2, p, ret);
sigmas[0] = getter->GetSigmaProton (m2, p);
sigmas[1] = getter->GetSigmaKaon (m2, p);
sigmas[2] = getter->GetSigmaPion (m2, p);
// std::cout << "pdg = " << mctrack->GetPdgId() << " p = " << p << " Sp = " << sigmas[0] << " Sk = " << sigmas[1]<< " Spi = " << sigmas[2] << std::endl;
if (mctrack->GetPdgId() == 2212 )
{
v.SetPtEtaPhiM (track->GetPt(0), track->GetEta(0), track->GetPhi(0), 0.9386);
hEffP->Fill ( p, ret[0] > 0.9 );
hEffPSigma->Fill ( p, sigmas[0] < 3&& sigmas[1] > 2 && sigmas[2] > 2 );
hEffPtYP -> Fill( v.Rapidity() - 1.52, v.Pt(), ret[0] > 0.9 );
}
if (mctrack->GetPdgId() == 321 )
{
v.SetPtEtaPhiM (track->GetPt(0), track->GetEta(0), track->GetPhi(0), 0.5);
hEffK->Fill ( p, ret[1] > 0.9 );
hEffKSigma->Fill ( p, sigmas[1] < 3&& sigmas[2] > 2 && sigmas[0] > 2 );
hEffPtYK -> Fill( v.Rapidity() - 1.52, v.Pt(), ret[1] > 0.9 );
}
if (mctrack->GetPdgId() == 211 )
{
v.SetPtEtaPhiM (track->GetPt(0), track->GetEta(0), track->GetPhi(0), 0.14);
hEffPi->Fill ( p, ret[2] > 0.9 );
hEffPiSigma->Fill ( p, sigmas[2] < 3&& sigmas[0] > 2 && sigmas[1] > 2 );
hEffPtYPi -> Fill( v.Rapidity() - 1.52, v.Pt(), ret[2] > 0.9 );
}
}
}
hEffP -> SetMarkerStyle(21); hEffP -> SetMarkerColor(kRed); hEffP -> SetLineColor(kRed);
hEffPi -> SetMarkerStyle(21); hEffPi -> SetMarkerColor(kRed); hEffPi -> SetLineColor(kRed);
hEffK -> SetMarkerStyle(21); hEffK -> SetMarkerColor(kRed); hEffK -> SetLineColor(kRed);
hEffPSigma -> SetMarkerStyle(22); hEffPSigma -> SetMarkerColor(kBlue); hEffPSigma -> SetLineColor(kBlue);
hEffPiSigma -> SetMarkerStyle(22); hEffPiSigma -> SetMarkerColor(kBlue); hEffPiSigma -> SetLineColor(kBlue);
hEffKSigma -> SetMarkerStyle(22); hEffKSigma -> SetMarkerColor(kBlue); hEffKSigma -> SetLineColor(kBlue);
hEffP->GetXaxis()->SetTitle( "p, GeV/c" );
hEffP->GetYaxis()->SetTitle( "Efficiency" );
hEffP->GetYaxis()->SetRangeUser(0.0, 1.);
hEffK->GetXaxis()->SetTitle( "p, GeV/c" );
hEffK->GetYaxis()->SetTitle( "Efficiency" );
hEffK->GetYaxis()->SetRangeUser(0.0, 1.);
hEffPi->GetXaxis()->SetTitle( "p, GeV/c" );
hEffPi->GetYaxis()->SetTitle( "Efficiency" );
hEffPi->GetYaxis()->SetRangeUser(0.0, 1.);
hEffPtYP->GetYaxis()->SetTitle( "p_{T}, GeV/c" );
hEffPtYP->GetXaxis()->SetTitle( "Rapidity" );
hEffPtYK->GetYaxis()->SetTitle( "p_{T}, GeV/c" );
hEffPtYK->GetXaxis()->SetTitle( "Rapidity" );
hEffPtYPi->GetYaxis()->SetTitle( "p_{T}, GeV/c" );
hEffPtYPi->GetXaxis()->SetTitle( "Rapidity" );
TCanvas *c1 = new TCanvas ("c1", "c1", 1400, 700);
c1->Divide(3,1);
c1->cd(1);
hEffP->Draw();
hEffPSigma->Draw("same");
c1->cd(2);
hEffK->Draw();
hEffKSigma->Draw("same");
c1->cd(3);
hEffPi->Draw();
hEffPiSigma->Draw("same");
// c1->cd(4);
// getter->GetProtonSigma()->Draw();
// getter->GetKaonSigma()->Draw("same");
// getter->GetPionSigma()->Draw("same");
//
// c1->cd(5);
// getter->GetProtonA()->Draw();
// getter->GetKaonA()->Draw("same");
// getter->GetPionA()->Draw("same");
//
// c1->cd(6);
// getter->GetProtonM2()->Draw();
// getter->GetKaonM2()->Draw("same");
// getter->GetPionM2()->Draw("same");
TCanvas *c2 = new TCanvas ("c2", "c2", 1400, 700);
c2->Divide(3,1);
c2->cd(1);
hEffPtYP->Draw("colz");
c2->cd(2);
hEffPtYK->Draw("colz");
c2->cd(3);
hEffPtYPi->Draw("colz");
c1->SaveAs("Canvas_Eff_p_all.root");
c1->SaveAs("Canvas_Eff_p_all.C");
c1->SaveAs("Canvas_Eff_p_all.png");
c2->SaveAs("Canvas_Eff_pT_Y_all.root");
c2->SaveAs("Canvas_Eff_pT_Y_all.C");
c2->SaveAs("Canvas_Eff_pT_Y_all.png");
}
void tauStudy(const TString inputfile = "/afs/cern.ch/work/k/klawhorn/HHToBBTT/Conf4_10GeV/HHToBBTT_10GeVJets_14TeV.root") {
// set up input tree
LorentzVector *genTau1=0, *genTau2=0, *genJetTau1=0, *genJetTau2=0, *jetTau1=0, *jetTau2=0;
Float_t genTau1pt, genTau2pt, genJetTau1pt, genJetTau2pt, jetTau1pt, jetTau2pt, corrJetTau1pt, corrJetTau2pt;
Float_t genTau1eta, genTau2eta, genJetTau1eta, genJetTau2eta, jetTau1eta, jetTau2eta;
TFile *infile = new TFile(inputfile, "READ"); assert(infile);
TTree *intree = (TTree*) infile->Get("Events"); assert(intree);
intree->SetBranchAddress("genTau1", &genTau1);
intree->SetBranchAddress("genTau2", &genTau2);
intree->SetBranchAddress("genJetTau1", &genJetTau1);
intree->SetBranchAddress("genJetTau2", &genJetTau2);
intree->SetBranchAddress("jetTau1", &jetTau1);
intree->SetBranchAddress("jetTau2", &jetTau2);
const Float_t PT_MAX = 500;
const Float_t PT_MIN = 0;
const Int_t PT_BINS = 50;
const Float_t ETA_MAX = 2.4;
const Float_t ETA_MIN = -2.4;
const Int_t ETA_BINS = 16;
TProfile *tauTagEffWithPT = new TProfile("tauTagEffWithPT", "Tau Tagging Efficiency", PT_BINS, PT_MIN, PT_MAX);
TProfile *tauTagEffWithEta = new TProfile("tauTagEffWithEta", "Tau Tagging Efficiency", ETA_BINS, ETA_MIN, ETA_MAX);
//TProfile *ptScaleWithPT = new TProfile("ptScaleWithPT", "P_{T} Scale Factor between gen Tau and reco Jet", PT_BINS, PT_MIN, PT_MAX);
//TProfile *ptJetScaleWithPT = new TProfile("ptJetScaleWithPT", "P_{T} Scale Factor between gen Jet and reco Jet", PT_BINS, PT_MIN, PT_MAX);
//TProfile *ptScaleWithEta = new TProfile("ptScaleWithEta", "P_{T} Scale Factor between gen Tau and reco Jet", ETA_BINS, ETA_MIN, ETA_MAX);
//TProfile *ptJetScaleWithEta = new TProfile("ptJetScaleWithEta", "P_{T} Scale Factor between gen Jet and reco Jet", ETA_BINS, ETA_MIN, ETA_MAX);
//TProfile *ptResWithPT = new TProfile("ptResWithPT", "P_{T} Resolution between gen Tau and reco Jet", PT_BINS, PT_MIN, PT_MAX);
TProfile *ptJetResWithPT = new TProfile("ptJetResWithPT", "P_{T} Resolution: (genJet-recoJet)/(genJet)", PT_BINS, PT_MIN, PT_MAX);
TProfile *ptJetResCorrWithPT = new TProfile("ptJetResCorrWithPT", "P_{T} Resolution: (genJet-recoJet)/(genJet)", PT_BINS, PT_MIN, PT_MAX);
//TProfile *ptResWithEta = new TProfile("ptResWithEta", "P_{T} Resolution between gen Tau and reco Jet", ETA_BINS, ETA_MIN, ETA_MAX);
TProfile *ptJetResWithEta = new TProfile("ptJetResWithEta", "P_{T} Resolution: (genJet-recoJet)/(genJet)", ETA_BINS, ETA_MIN, ETA_MAX);
TProfile *ptJetResCorrWithEta = new TProfile("ptJetResCorrWithEta", "P_{T} Resolution: (genJet-recoJet)/(genJet)", ETA_BINS, ETA_MIN, ETA_MAX);
for (Int_t iEntry=0; iEntry<intree->GetEntries(); iEntry++) {
intree->GetEntry(iEntry);
genTau1pt = genTau1->Pt(); genTau1eta = genTau1->Eta();
genTau2pt = genTau2->Pt(); genTau2eta = genTau2->Eta();
genJetTau1pt = genJetTau1->Pt(); genJetTau1eta = genJetTau1->Eta();
genJetTau2pt = genJetTau2->Pt(); genJetTau2eta = genJetTau2->Eta();
jetTau1pt = jetTau1->Pt(); jetTau1eta = jetTau1->Eta();
jetTau2pt = jetTau2->Pt(); jetTau2eta = jetTau2->Eta();
// jet corrections
//if ( (jetTau1pt != 999) ) cout << "eta " << jetTau1eta << " pt " << jetTau1pt << " scaleCorr " << getJetScaleFactor(jetTau1pt, jetTau1eta) << endl;
corrJetTau1pt = jetTau1pt*getJetScaleFactor(jetTau1pt, jetTau1eta);
corrJetTau2pt = jetTau2pt*getJetScaleFactor(jetTau2pt, jetTau2eta);
if ( (genTau1pt != 999) && (jetTau1pt != 999) ) {
tauTagEffWithPT->Fill(genTau1pt, 1);
//ptScaleWithPT->Fill(genTau1pt, jetTau1pt/genTau1pt);
//ptJetScaleWithPT->Fill(genJetTau1pt, jetTau1pt/genJetTau1pt);
//ptResWithPT->Fill(genTau1pt, (genTau1pt-jetTau1pt)/genTau1pt);
ptJetResWithPT->Fill(genJetTau1pt, (genJetTau1pt-jetTau1pt)/genJetTau1pt);
ptJetResCorrWithPT->Fill(genJetTau1pt, (genJetTau1pt-corrJetTau1pt)/genJetTau1pt);
tauTagEffWithEta->Fill(genTau1eta, 1);
//ptScaleWithEta->Fill(genTau1eta, jetTau1pt/genTau1pt);
//ptJetScaleWithEta->Fill(genJetTau1eta, jetTau1pt/genJetTau1pt);
//ptResWithEta->Fill(genTau1eta, (genTau1pt-jetTau1pt)/genTau1pt);
ptJetResWithEta->Fill(genJetTau1eta, (genJetTau1pt-jetTau1pt)/genJetTau1pt);
ptJetResCorrWithEta->Fill(genJetTau1eta, (genJetTau1pt-corrJetTau1pt)/genJetTau1pt);
}
else if ( (genTau1pt != 999) && (jetTau1pt == 999) ) {
tauTagEffWithPT->Fill(genTau1pt, 0);
tauTagEffWithEta->Fill(genTau1eta, 0);
}
if ( (genTau2pt != 999) && (jetTau2pt != 999) ) {
tauTagEffWithPT->Fill(genTau2pt, 1);
//ptScaleWithPT->Fill(genTau2pt, jetTau2pt/genTau2pt);
//ptJetScaleWithPT->Fill(genJetTau2pt, jetTau2pt/genJetTau2pt);
//ptResWithPT->Fill(genTau2pt, (genTau2pt-jetTau2pt)/genTau2pt);
ptJetResWithPT->Fill(genJetTau2pt, (genJetTau2pt-jetTau2pt)/genJetTau2pt);
ptJetResCorrWithPT->Fill(genJetTau2pt, (genJetTau2pt-corrJetTau2pt)/genJetTau2pt);
tauTagEffWithEta->Fill(genTau2eta, 1);
//ptScaleWithEta->Fill(genTau2eta, jetTau2pt/genTau2pt);
//ptJetScaleWithEta->Fill(genJetTau2eta, jetTau2pt/genJetTau2pt);
//ptResWithEta->Fill(genTau2eta, (genTau2pt-jetTau2pt)/genTau2pt);
ptJetResWithEta->Fill(genJetTau2eta, (genJetTau2pt-jetTau2pt)/genJetTau2pt);
ptJetResCorrWithEta->Fill(genJetTau2eta, (genJetTau2pt-corrJetTau2pt)/genJetTau2pt);
}
else if ( (genTau2pt != 999) && (jetTau2pt == 999) ) {
tauTagEffWithPT->Fill(genTau2pt, 0);
tauTagEffWithEta->Fill(genTau2eta, 0);
}
}
TCanvas *c1 = MakeCanvas("c1", "Tau Tagging Efficiency", 800, 600);
tauTagEffWithPT->SetMarkerStyle(1);
tauTagEffWithPT->GetXaxis()->SetTitle("P_{T} of Generator Tau");
tauTagEffWithPT->GetYaxis()->SetTitle("Efficiency");
tauTagEffWithPT->Draw();
c1->SaveAs("tauTagEffWithPT.png");
TCanvas *c2 = MakeCanvas("c2", "Tau Tagging Efficiency", 800, 600);
tauTagEffWithEta->SetMarkerStyle(1);
tauTagEffWithEta->GetXaxis()->SetTitle("Eta of Generator Tau");
tauTagEffWithEta->GetYaxis()->SetTitle("Efficiency");
tauTagEffWithEta->Draw();
c2->SaveAs("tauTagEffWithEta.png");
/*
TCanvas *c3 = MakeCanvas("c3", "Tau P_{T} Scale (reco Tau Jet P_{T}/gen Tau P_{T})", 800, 600);
ptScaleWithPT->SetMarkerStyle(1);
ptScaleWithPT->GetXaxis()->SetTitle("P_{T} of Generator Tau");
ptScaleWithPT->GetYaxis()->SetTitle("P_{T} Scale");
ptScaleWithPT->Draw();
c3->SaveAs("ptScaleWithPT.png");
TCanvas *c4 = MakeCanvas("c4", "Tau P_{T} Scale (reco Tau Jet P_{T}/gen Tau P_{T})", 800, 600);
ptScaleWithEta->SetMarkerStyle(1);
ptScaleWithEta->GetXaxis()->SetTitle("Eta of Generator Tau");
ptScaleWithEta->GetYaxis()->SetTitle("P_{T} Scale");
ptScaleWithEta->Draw();
c4->SaveAs("ptScaleWithEta.png");
TCanvas *c5 = MakeCanvas("c5", "Tau P_{T} Scale (reco Tau Jet P_{T}/gen Tau Jet P_{T})", 800, 600);
ptJetScaleWithPT->SetMarkerStyle(1);
ptJetScaleWithPT->GetXaxis()->SetTitle("P_{T} of Generator Tau Jet");
ptJetScaleWithPT->GetYaxis()->SetTitle("P_{T} Scale");
ptJetScaleWithPT->Draw();
c5->SaveAs("ptJetScaleWithPT.png");
TCanvas *c6 = MakeCanvas("c6", "Tau P_{T} Scale (reco Tau Jet P_{T}/gen Tau Jet P_{T})", 800, 600);
ptJetScaleWithEta->SetMarkerStyle(1);
ptJetScaleWithEta->GetXaxis()->SetTitle("Eta of Generator Tau Jet");
ptJetScaleWithEta->GetYaxis()->SetTitle("P_{T} Scale");
ptJetScaleWithEta->Draw();
c6->SaveAs("ptJetScaleWithEta.png");
TCanvas *c7 = MakeCanvas("c7", "Tau P_{T} Resolution ((reco Tau Jet P_{T} - gen Tau P_{T})/gen Tau P_{T})", 800, 600);
ptResWithPT->SetMarkerStyle(1);
ptResWithPT->GetXaxis()->SetTitle("P_{T} of Generator Tau");
ptResWithPT->GetYaxis()->SetTitle("P_{T} Resolution");
ptResWithPT->Draw();
c7->SaveAs("ptResWithPT.png");
TCanvas *c8 = MakeCanvas("c8", "Tau P_{T} Resolution", 800, 600);
ptResWithEta->SetMarkerStyle(1);
ptResWithEta->GetXaxis()->SetTitle("Eta of Generator Tau");
ptResWithEta->GetYaxis()->SetTitle("P_{T} Resolution");
ptResWithEta->Draw();
c8->SaveAs("ptResWithEta.png");
TCanvas *c9 = MakeCanvas("c9", "Tau P_{T} Resolution", 800, 600);
ptJetResWithPT->SetMarkerStyle(1);
ptJetResWithPT->GetXaxis()->SetTitle("P_{T} of Generator Tau Jet");
ptJetResWithPT->GetYaxis()->SetTitle("P_{T} Resolution");
ptJetResWithPT->Draw();
ptJetResCorrWithPT->SetMarkerStyle(1);
ptJetResCorrWithPT->SetLineColor(2);
ptJetResCorrWithPT->Draw("same");
c9->SaveAs("ptJetResWithPT.png");
TCanvas *c10 = MakeCanvas("c10", "Tau P_{T} Resolution ((reco Tau Jet P_{T} - gen Tau Jet P_{T})/gen Tau Jet P_{T})", 800, 600);
ptJetResWithEta->SetMarkerStyle(1);
ptJetResWithEta->GetXaxis()->SetTitle("Eta of Generator Tau Jet");
ptJetResWithEta->GetYaxis()->SetTitle("P_{T} Resolution");
ptJetResWithEta->Draw();
ptJetResCorrWithEta->SetMarkerStyle(1);
ptJetResCorrWithEta->SetLineColor(2);
ptJetResCorrWithEta->Draw("same");
c10->SaveAs("ptJetResWithEta.png");
*/
}
void balanceMetVsAj(TString infname = "dj_HCPR-J50U-hiGoodMergedTracks_OfficialSelv2_Final0_120_50.root",TCut myCut = "cent<30", char *title = "",bool drawLegend = false)
{
TFile *inf = new TFile(infname);
TTree *t = (TTree*)inf->Get("ntjt");
const int nBin = 3;
double bins[nBin+1] = {0.5,4,8,1000};
double colors[nBin] = {kOrange-8,kBlue-3,kRed};
// Selection cut
TCut evtCut = "nljet>100&&abs(nljetacorr)<2&&aljet>50&&abs(aljetacorr)<2&&jdphi>2./3*TMath::Pi()&&!maskEvt";
cout << "Sel evt: " << t->GetEntries(evtCut&&myCut) << endl;
TProfile *p[nBin];
for (int i=0;i<nBin;i++)
{
p[i] = new TProfile(Form("p%d",i),"",5,0.0001,0.49999);
t->Project(Form("p%d",i),Form("-1*metxMerged%d:Aj",i), "1"*(evtCut&&myCut));
p[i]->SetLineColor(colors[i]);
p[i]->SetMarkerColor(colors[i]);
}
TProfile *pall = new TProfile("pall","",5,0.0001,0.49999);
pall->SetXTitle("A_{J}");
pall->SetYTitle("<#slash{p}_{T}^{#parallel}> (GeV/c)");
pall->GetXaxis()->CenterTitle();
pall->GetYaxis()->CenterTitle();
pall->SetNdivisions(505);
t->Project("pall","-1*metx:Aj", "1"*(evtCut&&myCut));
pall->SetAxisRange(-50,50,"Y");
pall->SetMarkerSize(1);
pall->Draw("E");
for (int i=0;i<nBin;++i) {
p[i]->SetLineWidth(3);
p[i]->Draw("e hist same");
}
pall->Draw("E same");
// 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(p[i],Form("%.1f - %.1f GeV/c",bins[i],bins[i+1]),"l");
} else {
leg->AddEntry(p[i],Form("> %.1f GeV/c",bins[i]),"l");
}
}
if (drawLegend) leg->Draw();
TLine * l0 = new TLine(0,0,0.5,0);
l0->SetLineStyle(2);
l0->Draw();
TText *titleText = new TText(0.3,30,title);
titleText->Draw();
}
void draw_clouds_profiles()
{
// gROOT->ProcessLine(".L ../utils.C");
// gROOT->ProcessLine(".L AliLRCFit.cxx");
TFile *f[8];
// f[0] = new TFile( "output_classesByV0M_LHC10h.root" );
// f[0] = new TFile( "output_classesByV0M_LHC10h_c10_5_1.root" );
f[0] = new TFile( "output_classesByV0M_LHC10h_c10_5_25_1_05.root" );
// f[0] = new TFile( "output_classesByV0M_LHC11h_FemtoPlus_c10_5_CUT_OUTLIERS.root" );
// f[0] = new TFile( "output_classesByV0M_LHC15o_fieldMM_c10_5_CUT_OUTLIERS.root" );
// f[0] = new TFile( "output_classesByV0M_LHC15o_fieldPP_c10_5_CUT_OUTLIERS.root" );
// const int nCW = 2; //nCentrWidths
// const double cWidths[nCW] = { 10, 5 }; //width of the centrality bins
// const double cStep[nCW] = { 5, 2.5 }; //centrality bins step
// const int nCentrBins[nCW] = { 17, 35 }; //n centrality bins
// const int nCW = 3; //nCentrWidths
// const double cWidths[nCW] = { 10, 5, 1.0 }; //width of the centrality bins
// const double cStep[nCW] = { 5, 2.5, 1.0 }; //centrality bins step
// const int nCentrBins[nCW] = { 17, 35, 90 }; //n centrality bins
// const int nCW = 4; //nCentrWidths
// const double cWidths[nCW] = { 10, 5, 1.0, 0.5 }; //width of the centrality bins
// const double cStep[nCW] = { 5, 2.5, 1.0, 1.0 }; //centrality bins step
// const int nCentrBins[nCW] = { 17, 35, 90, 90 }; //n centrality bins
const int nCW = 5; //nCentrWidths
const double cWidths[nCW] = { 10, 5, 2.5, 1.0, 0.5 }; //width of the centrality bins
const double cStep[nCW] = { 5, 2.5, 2.5, 1.0, 1.0 }; //centrality bins step
const int nCentrBins[nCW] = { 17, 35, 36, 90, 90 }; //n centrality bins
TH2D *hist2D;//[200][3];
TProfile *profile;//[200][3];
int cW = 2;
int etaW = 1;
int phiW = 0;
const int kCorrType = 1; //0-NN, 1-PtPt, 2-PtN
TCanvas *canv_tmp_for_fit = new TCanvas("canv_tmp_for_fit","canv_tmp_for_fit",50,50,300,300 );
TCanvas *canv_2D_clouds = new TCanvas("canv_2D_clouds","canv_2D_clouds",150,250,1400,600 );
tuneCanvas(canv_2D_clouds);
canv_2D_clouds->Divide(2,1);
gStyle->SetOptStat( kFALSE );
TGraph *grFromFit2D = new TGraph;
bool firstDraw = true;
// for ( int cBin = 0; cBin < nCentrBins[cW]; cBin++ )
for ( int cBin = nCentrBins[cW]-1; cBin >= 0; cBin-- )
{
if (cBin%2!=0)
continue;
// cout << "cBin=" << cBin << endl;
float cBinMin = cStep[cW] * cBin;
float cBinMax = cWidths[cW] + cStep[cW] * cBin;
// ##### pad 1 - clouds
tunePad( canv_2D_clouds->cd(1) );
if ( kCorrType == 0 )
{
hist2D = (TH2D*)f[0]->Get( Form("hist2D_NN_c%.1f-%.1f_etaW_%d_phiW_%d", cBinMin, cBinMax, etaW, phiW) );
hist2D->SetTitle( "");
hist2D->GetXaxis()->SetTitle( "N_{ch} Forward");
hist2D->GetYaxis()->SetTitle( "N_{ch} Backward");
hist2D->GetXaxis()->SetRangeUser(0,650);
hist2D->GetYaxis()->SetRangeUser(0,650);
}
else if ( kCorrType == 1 )
{
hist2D = (TH2D*)f[0]->Get( Form("hist2D_PtPt_c%.1f-%.1f_etaW_%d_phiW_%d", cBinMin, cBinMax, etaW, phiW) );
hist2D->SetTitle( "");
hist2D->GetXaxis()->SetTitle( "#LTp_{T}#GT Forward");
hist2D->GetYaxis()->SetTitle( "#LTp_{T}#GT Backward");
} hist2D->SetMarkerColor(kOrange-9+cBin);
tuneHist2D_onPad(hist2D);
hist2D->GetXaxis()->CenterTitle();
hist2D->GetYaxis()->CenterTitle();
// removeBinsWithFewEntries(hist2D);
hist2D->DrawCopy( firstDraw ? "" : "same" );
// ##### pad 2 - profiles
tunePad( canv_2D_clouds->cd(2) );
profile = hist2D->ProfileX(); //(TProfile*)f[0]->Get( Form("hist2D_c%.1f-%.1f_etaW_%d_phiW_%d_pfx", cBinMin, cBinMax, etaW, phiW) );
if ( kCorrType == 0 )
{
profile->SetTitle( "");
profile->GetYaxis()->SetTitle( "#LTN_{ch}#GT Backward");
profile->GetXaxis()->SetRangeUser(0,650);
profile->GetYaxis()->SetRangeUser(0,650);
}
else if ( kCorrType == 1 )
{
profile->SetTitle( "");
profile->GetYaxis()->SetTitle( "#LT#LTp_{T}#GT#GT Backward");
}
profile->SetLineColor(kOrange-9+cBin);
profile->SetMarkerStyle(7);
tuneProfile_onPad( profile );
profile->GetYaxis()->CenterTitle();
deleteProfileEmptyBinErrors(profile);
canv_tmp_for_fit->cd();
profile->Fit("pol1","Q");//,"",0.25,1.2);//,"N");
canv_2D_clouds->cd(2);
TF1 *fit = profile->GetFunction("pol1");
Double_t p0 = fit->GetParameter(0);
Double_t p1 = fit->GetParameter(1);
grFromFit2D->SetPoint(grFromFit2D->GetN(), (cBinMax+cBinMin)/2, p1);
double meanX = hist2D->ProjectionX()->GetMean();
double rmsX = hist2D->ProjectionX()->GetRMS();
fit->SetRange( meanX-3*rmsX, meanX+3*rmsX );
fit->SetLineColorAlpha( kRed, 0.6 );
fit->Draw("same");
profile->DrawCopy( firstDraw ? "" : "same" );
firstDraw = false;
}
TGraphErrors *grByFormula; /*[cW][etaW]*/
if ( kCorrType == 0 )
{
grByFormula = (TGraphErrors*)f[0]->Get( Form( "grNN_c%d_eta%d", cW, etaW ) );
}
else if ( kCorrType == 1 )
{
grByFormula = (TGraphErrors*)f[0]->Get( Form( "grPtPt_c%d_eta%d", cW, etaW ) );
}
TCanvas *canv_GrCoeff = new TCanvas("canv_GrCoeff","canv_GrCoeff",20,150,900,700 );
grByFormula->Draw("APL");
grFromFit2D->SetLineColor(kRed);
grFromFit2D->DrawClone("PL");
return;
TGraphErrors *gr[10][10];
for ( int cW = 0; cW < 2; cW++ )
for ( int etaW = 0; etaW < 3; etaW++ )
gr[cW][etaW] = (TGraphErrors*)f[0]->Get( Form( "grPtPt_c%d_eta%d", cW, etaW ) );
drawGraph( gr[1][0], 24, kBlack, "APL" );
drawGraph( gr[0][0], 20, kBlack, "PL" );
// drawGraph( gr[1][1], 24, kBlue, "PL" );
// drawGraph( gr[0][1], 20, kBlue, "PL" );
// drawGraph( gr[1][2], 24, kGreen, "PL" );
// drawGraph( gr[0][2], 20, kGreen, "PL" );
//// drawGraph( gr[6], 24, kRed, "PL" );
// drawGraph( gr[7], 20, kRed, "PL" );
f[1] = new TFile( "output_histos_graphs_LHC15o_fieldMM.root" );
TGraphErrors *grMM[10][10];
for ( int cW = 0; cW < 2; cW++ )
for ( int etaW = 0; etaW < 3; etaW++ )
grMM[cW][etaW] = (TGraphErrors*)f[1]->Get( Form( "grPtPt_c%d_eta%d", cW, etaW ) );
drawGraph( grMM[1][0], 24, kGreen, "PL" );
drawGraph( grMM[0][0], 20, kGreen, "PL" );
// drawGraph( grMM[1][1], 24, kRed, "PL" );
// drawGraph( grMM[0][1], 20, kRed, "PL" );
// drawGraph( grMM[1][2], 24, kGreen, "PL" );
// drawGraph( grMM[0][2], 20, kGreen, "PL" );
// gROOT->ProcessLine( ".q");
}
void getMyPlot(TString name, TString canv){
TFile * f= TFile::Open(name);
TCanvas *c1 = new TCanvas("c", "c",242,131,604,638);
c1->Range(0.3110345,-0.07230999,1.01908,0.6295608);
c1->SetFillColor(0);
c1->SetBorderMode(0);
c1->SetBorderSize(2);
c1->SetLeftMargin(0.12);
c1->SetRightMargin(0.01);
c1->SetTopMargin(0.04);
c1->SetFrameBorderMode(0);
c1->SetFrameBorderMode(0);
c1->Divide(1,3);
c1->cd(1);
TProfile * p = ((TH2D*)f->Get("hFinalFNeg"))->ProfileX();
p->GetXaxis()->SetTitle("F_{L} input");
p->GetYaxis()->SetTitle("F_{L} output");
p->Draw();
c1->cd(2);
TProfile * q = ((TH2D*)f->Get("hFinalFZero"))->ProfileX();
q->GetXaxis()->SetTitle("F_{0} input");
q->GetYaxis()->SetTitle("F_{0} output");
q->Draw();
c1->cd(3);
TProfile * r = ((TH2D*)f->Get("hFinalFPos"))->ProfileX();
r->GetXaxis()->SetTitle("F_{R} input");
r->GetYaxis()->SetTitle("F_{R} output");
r->Draw();
c1->SaveAs(canv+".C");
TCanvas *c2 = new TCanvas("c2", "c2",242,131,604,638);
c2->Range(0.3110345,-0.07230999,1.01908,0.6295608);
c2->SetFillColor(0);
c2->SetBorderMode(0);
c2->SetBorderSize(2);
c2->SetLeftMargin(0.12);
c2->SetRightMargin(0.01);
c2->SetTopMargin(0.04);
c2->SetFrameBorderMode(0);
c2->SetFrameBorderMode(0);
c2->Divide(1,3);
c2->cd(1);
TProfile * p2 = ((TH2D*)f->Get("hFinalFNegVR"))->ProfileX();
p2->GetXaxis()->SetTitle("V_{R} input");
p2->GetYaxis()->SetTitle("F_{L} output");
p2->Draw();
c2->cd(2);
TProfile * q2 = ((TH2D*)f->Get("hFinalFZeroVR"))->ProfileX();
q2->GetXaxis()->SetTitle("V_{R} input");
q2->GetYaxis()->SetTitle("F_{0} output");
q2->Draw();
c2->cd(3);
TProfile * r2 = ((TH2D*)f->Get("hFinalFPosVR"))->ProfileX();
r2->GetXaxis()->SetTitle("V_{R} input");
r2->GetYaxis()->SetTitle("F_{R} output");
r2->Draw();
c2->SaveAs(canv+"_AnomInput.C");
}
void gammaJetRapidity_energyClosure()
{
TH1::SetDefaultSumw2();
TString file;
file = "/mnt/hadoop/cms/store/user/luck/pA2013_MC/HiForest2_QCDPhoton30_5020GeV_100k.root";
HiForest *c = new HiForest(file, "Forest", cPPb, true);
c->InitTree();
TProfile *mcClosure = new TProfile("mcClosure",";p_{T}^{gen};<p_{T}^{reco}/p_{T}^{gen}>",40,0,300);
Int_t notMatched = 0;
//loop over events in each file
int nentries = c->GetEntries();
for(int jentry = 0; jentry<nentries; jentry++)
{
if (jentry% 1000 == 0) {
printf("%d / %d\n",jentry,nentries);
}
c->GetEntry(jentry);
//event selection (mc only)
if( !( c->skim.phfPosFilter1 && c->skim.phfNegFilter1 && c->skim.phltPixelClusterShapeFilter && c->skim.pprimaryvertexFilter) )
continue;
if(c->photon.nPhotons == 0)
continue;
//loop over photons in the event
Float_t leadingPt = 0;
Int_t leadingIndex = -1;
for(int i = 0; i<c->photon.nPhotons; i++)
{
if(c->photon.pt[i] > leadingPt)
{
leadingPt = c->photon.pt[i];
leadingIndex = i;
}
}
if(leadingIndex == -1)
continue;
if(c->photon.isGenMatched[leadingIndex])
{
Double_t genPt = c->photon.genMatchedPt[leadingIndex];
Double_t ratio = leadingPt/genPt;
mcClosure->Fill(genPt,ratio);
}
else
{
notMatched++;
}
}
mcClosure->Draw();
mcClosure->GetYaxis()->SetRangeUser(0.,2.);
TLine *line = new TLine(0, 1, 300, 1);
line->Draw();
drawText("Leading Photons",0.75,0.75);
printf("Number of not matched leading photons: %d\n",notMatched);
}