// If two histograms from two files are to be ploted onto
// the same plot. Open the first, and make a copy of the
// histogram and place it in the 2nd file. Then
void Plot2hists1D(TString hist1Name,
TString hist2Name,
TString file1Name,
TString file2Name,
TString hist1Label = "",
TString hist2Label = "",
Double_t scaleFactor1 = 1.0,
Double_t scaleFactor2 = 1.0) {
// Open the 1st file
TFile *file1 = new TFile(file1Name);
// Grab a copy of its histogram
TH1* histTemp = (TH1*)file1->Get(hist1Name);
// Open the 2nd file
TFile *file2 = new TFile(file2Name,"UPDATE");
file2->cd();
// Change the name
histTemp->SetName(hist1Name+"1");
// Write the histogram to the 2nd file
histTemp->Write();
// Now file2 is the currently active file
Plot2hists1D(hist1Name+"1",hist2Name, scaleFactor1, scaleFactor2, hist1Label, hist2Label);
// Close the files, but if they close, the histograms disappear
//file1->Close();
//file2->Close();
}
TH1* makeIntHist(const TH1* hist,bool intIsGreatThan)
{
TH1* cHist = (TH1*) hist->Clone("cHist");
cHist->SetDirectory(0);
cHist->SetName(hist->GetName());
int maxBin = hist->GetNbinsX()+1;
for(int binNr=0;binNr<=hist->GetNbinsX();binNr++){
//if(hist->GetBinContent(binNr) == 0) continue;
float nrEntries = intIsGreatThan ? hist->Integral(binNr,maxBin) : hist->Integral(0,binNr);
cHist->SetBinContent(binNr,nrEntries);
}
return cHist;
}
///////////////////////////////////////////////////////////////////
//////// Go4 GUI example script addhistos.C
// J.Adamczewski, gsi, May 2006
// JAM May 2015: added support for 2d histograms
// NOTE: to be run in Go4 GUI local command line only!
// NEVER call this script in remote analysis process!!!
/////// Functionality:
// adds histogram of name2 to histogram of name1
/////// Usage:
// histogram name2 will be scaled by factor.
// (e.g. if factor==-1, his2 is substracted from his1)
// The draw flag switches if the results are displayed each time this makro is called
// if display is switched off, the result histogram is just updated in browser and existing displays
///////
Bool_t addhistos(const char* name1, const char* name2, Double_t factor, Bool_t draw)
{
if(TGo4AbstractInterface::Instance()==0 || go4!=TGo4AbstractInterface::Instance()) {
std::cout <<"FATAL: Go4 gui macro executed outside Go4 GUI!! returning." << std::endl;
return kFALSE;
}
TString fullname1 = go4->FindItem(name1);
TObject* ob1=go4->GetObject(fullname1,1000); // 1000=timeout to get object from analysis in ms
TH1 *his1(0), *his2(0);
if(ob1 && ob1->InheritsFrom("TH1"))
his1 = (TH1*) ob1;
if(his1==0) {
std::cout <<"addhistos could not get histogram "<<fullname1 << std::endl;
return kFALSE;
}
TString fullname2 = go4->FindItem(name2);
TObject* ob2=go4->GetObject(fullname2,1000); // 1000=timeout to get object from analysis in ms
if(ob2 && ob2->InheritsFrom("TH1"))
his2 = (TH1*)ob2;
if(his2==0) {
std::cout <<"addhistos could not get histogram "<<fullname2 << std::endl;
return kFALSE;
}
if((his1->GetDimension()) != (his2->GetDimension()))
{
std::cout <<"addhistos could not add histograms of different dimensions "<< std::endl;
return kFALSE;
}
TH1* result = (TH1*) his1->Clone();
TString n1 = his1->GetName();
TString n2 = his2->GetName();
TString t1 = his1->GetTitle();
TString t2 = his2->GetTitle();
TString soper;
if(factor>0)
soper.Form(") + %4.1E * (",factor);
else
soper.Form(") - %4.1E * (",-1*factor);
TString finalname = TString("(")+n1+soper+n2+")";
TString finaltitle = TString("(")+t1+soper+t2+")";
result->SetName(finalname);
result->SetTitle(finaltitle);
result->Sumw2();
result->Add(his2,factor);
result->SetDirectory(0);
TString rname = go4->SaveToMemory("Sums", result, kTRUE);
std::cout<< "Saved result histogram to " << rname.Data() <<std::endl;
if(draw) {
ViewPanelHandle vpanel = go4->StartViewPanel();
if(result->GetDimension()>1)
{
// superimpose mode is not supported for 2d histograms
go4->DrawItem(rname, vpanel);
}
else
{
go4->SetSuperimpose(vpanel,kTRUE);
go4->DrawItem(fullname1, vpanel);
go4->DrawItem(fullname2, vpanel);
go4->DrawItem(rname, vpanel);
}
}
return kTRUE;
}
void reingold_ROOThomework(){
// Initalizing the Canvas
TCanvas *c1 = new TCanvas("c1" , "Homework Plots" , 800 , 600 );
c1 -> Divide(3,3);
// Defining the function with three Gaussians on a quadratic background.
TF1 *func = new TF1("func", "pol2(0) + gaus(3) + gaus(6) + gaus(9)" , 0 , 100 );
Double_t param[12] = {9 , 1 , -0.01 , 100 , 20 , 1 , 100 , 50 , 1 , 100 , 80 , 1};
func->SetParameters(param);
// quad, lin, const, A, mu, std , ...
// Generting and filling the histograms
TH1F *h0 = new TH1F("h0" , "Original Spectrum" , 100 , 0 , 100 );
for ( Int_t i = 0 ; i < 2000 ; i++ ){
Float_t rand = func->GetRandom();
h0->Fill(rand);
}
for ( Int_t j = 1 ; j < 4 ; j++ ){
c1->cd(j);
h0->Draw();
}
// Fitting the background using ShowBackground()
c1->cd(4);
TH1 *hPeaks = (TH1*) h0->Clone();
TH1 *hBkgrd = (TH1*) h0->Clone();
hPeaks->SetName("hPeaks");
hBkgrd->SetName("hBkgrd");
hBkgrd = h0->ShowBackground(15);
h0->Draw();
hBkgrd->Draw("same");
hPeaks->Add(hBkgrd,-1);
c1->cd(7);
hPeaks->Draw();
// Fitting the background without excluding the peaks
c1->cd(5);
TH1F *hPeaks2 = (TH1F*) h0->Clone();
TH1F *hBkg2 = (TH1F*) h0->Clone();
hPeaks2->SetName("hPeaks2");
hBkg2->SetName("hBkg2");
TF1 *quadBack = new TF1("quadBack" , "pol2(0)" , 0 , 100 );
hBkg2->Fit(quadBack,"R+");
hBkg2->Draw();
c1->cd(8);
hPeaks2->Add(quadBack , -1 );
hPeaks2->Draw();
// Fitting the background excluding the peaks
c1->cd(6);
TH1F *hPeaks3 = (TH1F*) h0->Clone();
TH1F *hBkg3 = (TH1F*) h0->Clone();
hPeaks3->SetName("hPeaks3");
hBkg3->SetName("hBkg3");
TF1 *quadBack2 = new TF1("quadBack2" , fQuad , 0 , 100 ,3);
hBkg3->Fit(quadBack2,"R+");
hBkg3->Draw();
c1->cd(9);
hPeaks3->Add(quadBack2 , -1 );
hPeaks3->Draw();
}
void comparisonJetMCData(string plot,int rebin){
string tmp;
string dir="/gpfs/cms/data/2011/Observables/";
//string dir=plotpath;
if (isAngularAnalysis){
mcfile=dir+"MC_zjets"+version;
back_w=dir+"MC_wjets"+version;
back_ttbar=dir+"MC_ttbar"+version;
WW=dir+"MC_diW"+version;
ZZ=dir+"MC_siZ"+version;
WZ=dir+"MC_diWZ"+version;
datafile=dir+"DATA"+version;
}
// List of files
TFile *dataf = TFile::Open(datafile.c_str()); //data file
TFile *mcf = TFile::Open(mcfile.c_str()); //MC file
TFile *ttbarf = TFile::Open(back_ttbar.c_str()); //MC background file
TFile *wf = TFile::Open(back_w.c_str());
TFile *qcd23emf = TFile::Open(qcd23em.c_str());
TFile *qcd38emf = TFile::Open(qcd38em.c_str());
TFile *qcd817emf = TFile::Open(qcd817em.c_str());
TFile *qcd23bcf = TFile::Open(qcd23bc.c_str());
TFile *qcd38bcf = TFile::Open(qcd38bc.c_str());
TFile *qcd817bcf = TFile::Open(qcd817bc.c_str());
TFile *WZf = TFile::Open(WZ.c_str());
TFile *ZZf = TFile::Open(ZZ.c_str());
TFile *WWf = TFile::Open(WW.c_str());
// Canvas
if (CanvPlot) delete CanvPlot;
CanvPlot = new TCanvas("CanvPlot","CanvPlot",0,0,800,600);
// Getting, defining ...
dataf->cd("validationJEC");
TObject * obj;
gDirectory->GetObject(plot.c_str(),obj);
TH1 *data;
TH2F *data2;
TH1D *data3;
THStack *hs = new THStack("hs","Total MC");
int flag=-1;
if ((data = dynamic_cast<TH1F *>(obj)) ){
flag=1;
gROOT->Reset();
gROOT->ForceStyle();
gStyle->SetPadRightMargin(0.03);
gPad->SetLogy(1);
gPad->Modified();
gPad->Update();
}
if ((data2 = dynamic_cast<TH2F *>(obj)) ){
flag=2;
gStyle->SetPalette(1);
gStyle->SetPadRightMargin(0.15);
gPad->Modified();
}
//===================
// Dirty jobs :)
if (flag==1){
CanvPlot->cd();
TPad *pad1 = new TPad("pad1","pad1",0,0.3,1,1);
pad1->Draw();
pad1->cd();
pad1->SetLogy(1);
TString str=data->GetTitle();
if (str.Contains("jet") && !str.Contains("zMass") && !str.Contains("Num") && !str.Contains("Eta") && !str.Contains("Phi") && !str.Contains("eld") && !str.Contains("meanPtZVsNjet")) {
if (!isAngularAnalysis) rebin=5;
}
//======================
// DATA
Double_t dataint = data->Integral();
data->SetLineColor(kBlack);
data->Rebin(rebin);
if(str.Contains("nJetVtx")) data->GetXaxis()->SetRangeUser(0,10);
if(str.Contains("zMass")) data->GetXaxis()->SetRangeUser(70,110);
data->SetMinimum(1.);
data->Sumw2();
data->Draw("E1");
TLegend* legend = new TLegend(0.825,0.57,0.95,0.72);
legend->SetFillColor(0);
legend->SetFillStyle(0);
legend->SetBorderSize(0);
legend->AddEntry(data,"data","p");
// hack to calculate some yields in restricted regions...
int num1=0, num2=0, num3=0, num4=0, num5=0;
if(str.Contains("invMass") && !str.Contains("PF")){
for(int j=1;j<=data->GetNbinsX();j++){
num1 += data->GetBinContent(j); //conto quante Z ci sono tra 60 e 120 GeV
if(j>10&&j<=50) num2 += data->GetBinContent(j); // ... tra 70 e 110
if(j>15&&j<=45) num3 += data->GetBinContent(j); // ... tra 75 e 105
}
cout << "\n";
cout << data->GetNbinsX() <<" Number of bins of the invmass histo\n";
printf("Number of Z in 60-120 %i --- 70-110 %i --- 75-105 %i \n",num1,num2,num3);
cout << "\n";
}
if(str.Contains("zYieldVsjets") && !str.Contains("Vtx")){
for(int j=1;j<=data->GetNbinsX();j++){
num1 += data->GetBinContent(j); //conto quante Z
if(j>1) num2 += data->GetBinContent(j); // ... +1,2,3,4... jets
if(j>2) num3 += data->GetBinContent(j); // ... +2,3,4... jets
if(j>3) num4 += data->GetBinContent(j); // .. if(str=="jet_pT"){
if(j>4) num5 += data->GetBinContent(j); // ... +4... jets
}
cout << "\n";
cout << data->GetNbinsX() <<" Number of bins of the zYieldVsjets histo\n";
printf("Number of Z+n jet %i --- >1 %i --- >2 %i --- >3 %i --- >4 %i \n",num1,num2,num3,num4,num5);
cout << "\n";
}
//======================
// Z + jets signal
mcf->cd("validationJEC");
TH1F* mc;
gDirectory->GetObject(plot.c_str(),mc);
TH1F * hsum;
if(mc){
hsum = (TH1F*) mc->Clone();
hsum->SetTitle("hsum");
hsum->SetName("hsum");
hsum->Reset();
Double_t mcint = mc->Integral();
mc->SetFillColor(kRed);
mc->Sumw2();
if(lumiweights==0) mc->Scale(dataint/mcint);
// Blocco da propagare negli altri MC
if(zNumEvents>0.){
if(lumiweights==1) {
if (WholeStat){
if (lumiPixel) mc->Scale( dataLumi2011pix / (zNumEvents / zjetsXsect));
else mc->Scale( dataLumi2011 / (zNumEvents / zjetsXsect));
}
else{
if (RunA){
if (lumiPixel) mc->Scale( dataLumi2011Apix / (zNumEvents / zjetsXsect));
else mc->Scale( dataLumi2011A / (zNumEvents / zjetsXsect));
}
if (!RunA){
if (lumiPixel) mc->Scale( dataLumi2011Bpix / (zNumEvents / zjetsXsect));
else mc->Scale( dataLumi2011B / (zNumEvents / zjetsXsect));
}
}
}
}
else {
if(lumiweights==1) mc->Scale(zjetsScale);
}
// fin qui
if(lumiweights==1) mc->Scale(1./zwemean); // perche' i Weights non fanno 1...
mc->Rebin(rebin);
if(lumiweights==0) mc->Draw("HISTO SAMES");
hsum->Rebin(rebin);
hsum->Add(mc);
legend->AddEntry(mc,"Z+jets","f");
}
//======================
// ttbar
ttbarf->cd("validationJEC");
TH1F* ttbar;
gDirectory->GetObject(plot.c_str(),ttbar);
if(ttbar){
ttbar->SetFillColor(kBlue);
ttbar->Sumw2();
if(ttNumEvents>0.){
if(lumiweights==1) {
if (WholeStat){
if (lumiPixel) ttbar->Scale( dataLumi2011pix / (ttNumEvents / ttbarXsect));
else ttbar->Scale( dataLumi2011 / (ttNumEvents / ttbarXsect));
}
else{
if (RunA){
if (lumiPixel) ttbar->Scale( dataLumi2011Apix / (ttNumEvents / ttbarXsect));
else ttbar->Scale( dataLumi2011A / (ttNumEvents / ttbarXsect));
}
if (!RunA){
if (lumiPixel) ttbar->Scale( dataLumi2011Bpix / (ttNumEvents / ttbarXsect));
else ttbar->Scale( dataLumi2011B / (ttNumEvents / ttbarXsect));
}
}
}
}
else {
if(lumiweights==1) ttbar->Scale(ttwemean);
}
// fin qui
if(lumiweights==1) ttbar->Scale(1./ttwemean); // perche' i Weights non fanno 1...
ttbar->Rebin(rebin);
if(lumiweights==0) ttbar->Draw("HISTO SAMES");
hsum->Rebin(rebin);
hsum->Add(ttbar);
if(lumiweights==1)legend->AddEntry(ttbar,"ttbar","f");
//////////
//Storing the bckgrounds!
//////////
if(str=="jet_pT") evaluateAndFillBackgrounds(ttbar,"jet_pT");
if(str=="jet_pT2") evaluateAndFillBackgrounds(ttbar,"jet_pT2");
if(str=="jet_pT3") evaluateAndFillBackgrounds(ttbar,"jet_pT3");
if(str=="jet_pT4") evaluateAndFillBackgrounds(ttbar,"jet_pT4");
if(str=="Jet_multi") evaluateAndFillBackgrounds(ttbar,"jet_Multiplicity");
}
//======================
// w+jets
wf->cd("validationJEC");
TH1F* w;
gDirectory->GetObject(plot.c_str(),w);
if(w){
w->SetFillColor(kViolet+2);
w->Sumw2();
if(wNumEvents>0.){
if(lumiweights==1) {
if (WholeStat){
if (lumiPixel) w->Scale( dataLumi2011pix / (wNumEvents / wjetsXsect));
else w->Scale( dataLumi2011 / (wNumEvents / wjetsXsect));
}
else{
if (RunA){
if (lumiPixel) w->Scale( dataLumi2011Apix / (wNumEvents / wjetsXsect));
else w->Scale( dataLumi2011A / (wNumEvents / wjetsXsect));
}
if (!RunA){
if (lumiPixel) w->Scale( dataLumi2011Bpix / (wNumEvents / wjetsXsect));
else w->Scale( dataLumi2011B / (wNumEvents / wjetsXsect));
}
}
}
}
else {
if(lumiweights==1) w->Scale(wwemean);
}
// fin qui
if(lumiweights==1) w->Scale(1./wwemean); // perche' i Weights non fanno 1...
w->Rebin(rebin);
if(lumiweights==0) w->Draw("HISTO SAMES");
hsum->Rebin(rebin);
hsum->Add(w);
if(lumiweights==1)legend->AddEntry(w,"W+jets","f");
}
//======================
// wz+jets
WZf->cd("validationJEC");
TH1F* wz;
gDirectory->GetObject(plot.c_str(),wz);
if(wz){
wz->SetFillColor(kYellow+2);
wz->Sumw2();
if(wzEvents>0.){
if(lumiweights==1) {
if (WholeStat){
if (lumiPixel) wz->Scale( dataLumi2011pix / (wzEvents / WZXsect));
else wz->Scale( dataLumi2011 / (wzEvents / WZXsect));
}
else{
if (RunA){
if (lumiPixel) wz->Scale( dataLumi2011Apix / (wzEvents / WZXsect));
else wz->Scale( dataLumi2011A / (wzEvents / WZXsect));
}
if (!RunA){
if (lumiPixel) wz->Scale( dataLumi2011Bpix / (wzEvents / WZXsect));
else wz->Scale( dataLumi2011B / (wzEvents / WZXsect));
}
}
}
}
else {
if(lumiweights==1) wz->Scale(wzjetsScale);
}
// fin qui
if(lumiweights==1) wz->Scale(1./wzwemean); // perche' i Weights non fanno 1...
wz->Rebin(rebin);
if(lumiweights==0) wz->Draw("HISTO SAMES");
hsum->Rebin(rebin);
hsum->Add(wz);
legend->AddEntry(wz,"WZ+jets","f");
//////////
//Storing the bckgrounds!
//////////
if(str=="jet_pT") evaluateAndFillBackgrounds(wz,"jet_pT");
if(str=="jet_pT2") evaluateAndFillBackgrounds(wz,"jet_pT2");
if(str=="jet_pT3") evaluateAndFillBackgrounds(wz,"jet_pT3");
if(str=="jet_pT4") evaluateAndFillBackgrounds(wz,"jet_pT4");
if(str=="Jet_multi") evaluateAndFillBackgrounds(wz,"jet_Multiplicity");
}
//======================
// zz+jets
ZZf->cd("validationJEC");
TH1F* zz;
gDirectory->GetObject(plot.c_str(),zz);
if(zz){
zz->SetFillColor(kOrange+2);
zz->Sumw2();
if(zzEvents>0.){
if(lumiweights==1) {
if (WholeStat){
if (lumiPixel) zz->Scale( dataLumi2011pix / (zzEvents / ZZXsect));
else zz->Scale( dataLumi2011 / (zzEvents / ZZXsect));
}
else{
if (RunA){
if (lumiPixel) zz->Scale( dataLumi2011Apix / (zzEvents / ZZXsect));
else zz->Scale( dataLumi2011A / (zzEvents / ZZXsect));
}
if (!RunA){
if (lumiPixel) zz->Scale( dataLumi2011Bpix / (zzEvents / ZZXsect));
else zz->Scale( dataLumi2011B / (zzEvents / ZZXsect));
}
}
}
}
else {
if(lumiweights==1) zz->Scale(zzjetsScale);
}
// fin qui
if(lumiweights==1) zz->Scale(1./zzwemean); // perche' i Weights non fanno 1...
zz->Rebin(rebin);
if(lumiweights==0) zz->Draw("HISTO SAMES");
hsum->Rebin(rebin);
hsum->Add(zz);
legend->AddEntry(zz,"ZZ+jets","f");
//////////
//Storing the bckgrounds!
//////////
if(str=="jet_pT") evaluateAndFillBackgrounds(zz,"jet_pT");
if(str=="jet_pT2") evaluateAndFillBackgrounds(zz,"jet_pT2");
if(str=="jet_pT3") evaluateAndFillBackgrounds(zz,"jet_pT3");
if(str=="jet_pT4") evaluateAndFillBackgrounds(zz,"jet_pT4");
if(str=="Jet_multi") evaluateAndFillBackgrounds(zz,"jet_Multiplicity");
}
//======================
// ww+jets
WWf->cd("validationJEC");
TH1F* ww;
gDirectory->GetObject(plot.c_str(),ww);
if(ww){
ww->SetFillColor(kBlack);
ww->Sumw2();
if(wwEvents>0.){
if(lumiweights==1) {
if (WholeStat){
if (lumiPixel) ww->Scale( dataLumi2011pix / (wwEvents / WWXsect));
else ww->Scale( dataLumi2011 / (wwEvents / WWXsect));
}
else{
if (RunA){
if (lumiPixel) ww->Scale( dataLumi2011Apix / (wwEvents / WWXsect));
else ww->Scale( dataLumi2011A / (wwEvents / WWXsect));
}
if (!RunA){
if (lumiPixel) ww->Scale( dataLumi2011Bpix / (wwEvents / WWXsect));
else ww->Scale( dataLumi2011B / (wwEvents / WWXsect));
}
}
}
}
else {
if(lumiweights==1) ww->Scale(wwjetsScale);
}
// fin qui
if(lumiweights==1) ww->Scale(1./wwwemean); // perche' i Weights non fanno 1...
ww->Rebin(rebin);
if(lumiweights==0) ww->Draw("HISTO SAMES");
hsum->Rebin(rebin);
hsum->Add(ww);
legend->AddEntry(ww,"WW+jets","f");
//////////
//Storing the bckgrounds!
//////////
if(str=="jet_pT") evaluateAndFillBackgrounds(ww,"jet_pT");
if(str=="jet_pT2") evaluateAndFillBackgrounds(ww,"jet_pT2");
if(str=="jet_pT3") evaluateAndFillBackgrounds(ww,"jet_pT3");
if(str=="jet_pT4") evaluateAndFillBackgrounds(ww,"jet_pT4");
if(str=="Jet_multi") evaluateAndFillBackgrounds(ww,"jet_Multiplicity");
}
/////////
// Print the bkg contributions
////////
for(int j=0;j<bckg_leadingJetPt.size();j++){
cout<<bckg_leadingJetPt[j]<<endl;
}
//======================
// QCD EM enriched
qcd23emf->cd("validationJEC");
TH1F* qcd23emp;
gDirectory->GetObject(plot.c_str(),qcd23emp);
if(qcd23emp){
TH1D * qcdTotEM = (TH1D*) qcd23emp->Clone();
qcdTotEM->SetTitle("qcd em");
qcdTotEM->SetName("qcd em");
qcdTotEM->Reset();
qcdTotEM->Rebin(rebin);
qcd38emf->cd("validationJEC");
TH1F* qcd38emp;
gDirectory->GetObject(plot.c_str(),qcd38emp);
qcd817emf->cd("validationJEC");
TH1F* qcd817emp;
gDirectory->GetObject(plot.c_str(),qcd817emp);
qcd23emp->Rebin(rebin);
qcd23emp->Sumw2();
qcd23emp->Scale(qcd23emScale);
qcd38emp->Rebin(rebin);
qcd38emp->Sumw2();
qcd38emp->Scale(qcd38emScale);
qcd817emp->Rebin(rebin);
qcd817emp->Sumw2();
qcd817emp->Scale(qcd817emScale);
qcdTotEM->SetFillColor(kOrange+1);
qcdTotEM->Add(qcd23emp);
qcdTotEM->Add(qcd38emp);
qcdTotEM->Add(qcd817emp);
hsum->Add(qcdTotEM);
if(lumiweights==1)legend->AddEntry(qcdTotEM,"QCD em","f");
}
//======================
// QCD bc
qcd23bcf->cd("validationJEC");
TH1F* qcd23bcp;
TH1D * qcdTotBC;
bool qcdbcempty=true;
gDirectory->GetObject(plot.c_str(),qcd23bcp);
if(qcd23bcp){
qcdTotBC = (TH1D*) qcd23bcp->Clone();
qcdTotBC->SetTitle("qcd bc");
qcdTotBC->SetName("qcd bc");
qcdTotBC->Reset();
qcdTotBC->Rebin(rebin);
qcd38bcf->cd("validationJEC");
TH1F* qcd38bcp;
gDirectory->GetObject(plot.c_str(),qcd38bcp);
qcd817bcf->cd("validationJEC");
TH1F* qcd817bcp;
gDirectory->GetObject(plot.c_str(),qcd817bcp);
qcd23bcp->Rebin(rebin);
qcd23bcp->Sumw2();
qcd23bcp->Scale(qcd23bcScale);
qcd38bcp->Rebin(rebin);
qcd38bcp->Sumw2();
qcd38bcp->Scale(qcd38bcScale);
qcd817bcp->Rebin(rebin);
qcd817bcp->Sumw2();
qcd817bcp->Scale(qcd817bcScale);
qcdTotBC->SetFillColor(kGreen+2);
qcdTotBC->Add(qcd23bcp);
qcdTotBC->Add(qcd38bcp);
qcdTotBC->Add(qcd817bcp);
hsum->Add(qcdTotBC);
if (qcdTotBC->GetEntries()>0) qcdbcempty=false;
if(lumiweights==1)legend->AddEntry(qcdTotBC,"QCD bc","f");
}
//======================
// Add here other backgrounds
//======================
// Stacked Histogram
//if(qcd23em) hs->Add(qcdTotEM);
if(!qcdbcempty) hs->Add(qcdTotBC);
if (ww) hs->Add(ww);
if (ttbar) hs->Add(ttbar);
if(w) hs->Add(w);
if (zz) hs->Add(zz);
if (wz) hs->Add(wz);
if(mc) hs->Add(mc); //Z+Jets
// per avere le statistiche
if(lumiweights==1) hsum->Draw("HISTO SAMES");
//======================
// Setting the stats
pad1->Update(); // altrimenti non becchi la stat
TPaveStats *r2;
if(lumiweights==0) r2 = (TPaveStats*)mc->FindObject("stats");
if(lumiweights==1) r2 = (TPaveStats*)hsum->FindObject("stats");
r2->SetY1NDC(0.875);
r2->SetY2NDC(0.75);
r2->SetTextColor(kRed);
if(lumiweights==1) hs->Draw("HISTO SAME");
gPad->RedrawAxis();
data->Draw("E1 SAMES");
r2->Draw();
legend->Draw();
TLegend* lumi = new TLegend(0.45,0.3,0.75,0.2);
lumi->SetFillColor(0);
lumi->SetFillStyle(0);
lumi->SetBorderSize(0);
lumi->AddEntry((TObject*)0,"#int L dt =4.9 1/fb","");
lumi->Draw();
//TLatex *latexLabel=CMSPrel(4.890,"",0.65,0.9); // make fancy label
//latexLabel->Draw("same");
CanvPlot->Update();
//===============//
// RATIO DATA MC //
//===============//
CanvPlot->cd();
TPad *pad2 = new TPad("pad2","pad2",0,0,1,0.3);
pad2->Draw();
pad2->cd();
TH1D * ratio = (TH1D*) data->Clone();
ratio->SetTitle("ratio");
ratio->SetName("ratio");
ratio->Reset();
ratio->Sumw2();
//data->Sumw2();
hsum->Sumw2(); // FIXME controlla che sia corretto questo...
ratio->SetMarkerSize(.5);
ratio->SetLineColor(kBlack);
ratio->SetMarkerColor(kBlack);
gStyle->SetOptStat("m");
TH1F* sumMC;
hs->Draw("nostack");
sumMC=(TH1F*) hs->GetHistogram();
ratio->Divide(data,hsum,1.,1.);
ratio->GetYaxis()->SetRangeUser(0,2);
pad2->SetTopMargin(1);
ratio->Draw("E1");
TLine *OLine = new TLine(ratio->GetXaxis()->GetXmin(),1.,ratio->GetXaxis()->GetXmax(),1.);
OLine->SetLineColor(kBlack);
OLine->SetLineStyle(2);
OLine->Draw();
TLegend* label = new TLegend(0.60,0.9,0.50,0.95);
label->SetFillColor(0);
label->SetFillStyle(0);
label->SetBorderSize(0);
//horrible mess
double binContent = 0;
double binSum = 0;
double weightSum = 0;
double binError = 1;
double totalbins = ratio->GetSize() -2;
for(unsigned int bin=1;bin<=totalbins;bin++){
binContent = ratio->GetBinContent(bin);
binError = ratio->GetBinError(bin);
if(binError!=0){
binSum += binContent/binError;
weightSum += 1./binError;
}
}
double ymean = binSum / weightSum;
//double ymean = ratio->GetMean(2);
stringstream sYmean;
sYmean << ymean;
string labeltext=sYmean.str()+" mean Y";
//label->AddEntry((TObject*)0,labeltext.c_str(),""); // mean on Y
//label->Draw();
TPaveStats *r3 = (TPaveStats*)ratio->FindObject("stats");
r3->SetX1NDC(0.01);
r3->SetX2NDC(0.10);
r3->SetY1NDC(0.20);
r3->SetY2NDC(0.50);
gStyle->SetOptStat("mr");
r3->SetTextColor(kWhite);
r3->SetLineColor(kWhite);
r3->Draw();
CanvPlot->Update();
tmp=plotpath+plot+".png";
CanvPlot->Print(tmp.c_str());
OutputFile->cd();
string plotTmp;
plotTmp = plot+"Ratio";
ratio->SetName(plotTmp.c_str());
ratio->Write();
plotTmp = plot+"Data";
data->SetName(plotTmp.c_str());
data->Write();
plotTmp = plot+"MC";
hsum->SetName(plotTmp.c_str());
hsum->Write();
}
else if (flag==2){
//CanvPlot.Divide(2,1);
//CanvPlot.cd(1);
// data
dataf->cd("validationJEC");
gDirectory->GetObject(plot.c_str(),data2);
data2->Draw("COLZ");
gPad->Update(); // altrimenti non becchi la stat
TPaveStats *r1 = (TPaveStats*)data2->FindObject("stats");
r1->SetX1NDC(0.70);
r1->SetX2NDC(0.85);
r1->Draw();
CanvPlot->Update();
tmp=plotpath+plot+"data.png";
CanvPlot->Print(tmp.c_str());
//CanvPlot.cd(2);
// montecarlo
mcf->cd("validationJEC");
gDirectory->GetObject(plot.c_str(),data2);
data2->SetMinimum(1);
data2->Draw("COLZ");
gPad->Update(); // altrimenti non becchi la stat
TPaveStats *r2 = (TPaveStats*)data2->FindObject("stats");
r2->SetX1NDC(0.70);
r2->SetX2NDC(0.85);
r2->Draw();
CanvPlot->Update();
tmp=plotpath+plot+"mc.png";
CanvPlot->Print(tmp.c_str());
}
// else { cout << "You're getting an exception! Most likely there's no histogram here... \n"; }
delete data;
delete data2;
delete hs;
//delete CanvPlot;
dataf->Close();
mcf->Close();
ttbarf->Close();
wf->Close();
qcd23emf->Close();
qcd38emf->Close();
qcd817emf->Close();
qcd23bcf->Close();
qcd38bcf->Close();
qcd817bcf->Close();
WZf->Close();
ZZf->Close();
if (bckg_leadingJetPt.size()>0 && bckg_2leadingJetPt.size()>0 && bckg_3leadingJetPt.size()>0 && bckg_4leadingJetPt.size()>0 && bckg_JetMultiplicity.size()>0 && cold){
fzj->cd();
treeBKG_->Fill();
treeBKG_->Write();
TH1F *leadhisto=new TH1F("leadhisto","leading jet background contribution",bckg_leadingJetPt.size(),0,bckg_leadingJetPt.size());
TH1F *leadhisto2=new TH1F("leadhisto2","subleading jet background contribution",bckg_leadingJetPt.size(),0,bckg_leadingJetPt.size());
TH1F *leadhisto3=new TH1F("leadhisto3","subsubleading jet background contribution",bckg_leadingJetPt.size(),0,bckg_leadingJetPt.size());
TH1F *leadhisto4=new TH1F("leadhisto4","subsubsubleading jet background contribution",bckg_leadingJetPt.size(),0,bckg_leadingJetPt.size());
TH1F *multiphisto=new TH1F("multiphisto","jet multiplicity background contribution",bckg_JetMultiplicity.size(),0,bckg_JetMultiplicity.size());
for (int i=0; i< bckg_leadingJetPt.size(); i++){
leadhisto->Fill(i,bckg_leadingJetPt[i]);
leadhisto2->Fill(i,bckg_2leadingJetPt[i]);
leadhisto3->Fill(i,bckg_3leadingJetPt[i]);
leadhisto4->Fill(i,bckg_4leadingJetPt[i]);
}
leadhisto->Write();
leadhisto2->Write();
leadhisto3->Write();
leadhisto4->Write();
//fzj->Close();
for (int i=0; i< bckg_JetMultiplicity.size(); i++){
multiphisto->Fill(i,bckg_JetMultiplicity[i]);
}
multiphisto->Write();
cold=false;
}
return;
}
/**
* This function fits TH2F slices with a selected fitType function (gaussian, lorentz, ...).
*/
TGraphErrors* fit2DProj(TString name, TString path, int minEntries, int rebinX, int rebinY, int fitType,
TFile * outputFile, const TString & resonanceType, const double & xDisplace, const TString & append) {
//Read the TH2 from file
TFile *inputFile = new TFile(path);
TH2 * histo = (TH2*) inputFile->Get(name);
if( rebinX > 0 ) histo->RebinX(rebinX);
if( rebinY > 0 ) histo->RebinY(rebinY);
//Declare some variables
TH1 * histoY;
TString nameY;
std::vector<double> Ftop;
std::vector<double> Fwidth;
std::vector<double> Fmass;
std::vector<double> Etop;
std::vector<double> Ewidth;
std::vector<double> Emass;
std::vector<double> Fchi2;
std::vector<double> Xcenter;
std::vector<double> Ex;
TString fileOutName("fitCompare2"+name);
fileOutName += append;
fileOutName += ".root";
TFile *fileOut=new TFile(fileOutName,"RECREATE");
for (int i=1; i<=(histo->GetXaxis()->GetNbins());i++) {
//Project on Y (set name and title)
std::stringstream number;
number << i;
TString numberString(number.str());
nameY = name + "_" + numberString;
// std::cout << "nameY " << nameY << std::endl;
histoY = histo->ProjectionY(nameY, i, i);
double xBin = histo->GetXaxis()->GetBinCenter(i);
std::stringstream xBinString;
xBinString << xBin;
TString title("Projection of x = ");
title += xBinString.str();
histoY->SetName(title);
if (histoY->GetEntries() > minEntries) {
//Make the dirty work!
TF1 *fit;
std::cout << "fitType = " << fitType << std::endl;
if(fitType == 1) fit = gaussianFit(histoY, resonanceType);
else if(fitType == 2) fit = lorentzianFit(histoY, resonanceType);
else if(fitType == 3) fit = linLorentzianFit(histoY);
else {
std::cout<<"Wrong fit type: 1=gaussian, 2=lorentzian, 3=lorentzian+linear."<<std::endl;
abort();
}
double *par = fit->GetParameters();
double *err = fit->GetParErrors();
// Check the histogram alone
TCanvas *canvas = new TCanvas(nameY+"alone", nameY+" alone");
histoY->Draw();
canvas->Write();
// Only for check
TCanvas *c = new TCanvas(nameY, nameY);
histoY->Draw();
fit->Draw("same");
fileOut->cd();
c->Write();
if( par[0] == par[0] ) {
//Store the fit results
Ftop.push_back(par[0]);
Fwidth.push_back(fabs(par[1]));//sometimes the gaussian has negative width (checked with Rene Brun)
Fmass.push_back(par[2]);
Etop.push_back(err[0]);
Ewidth.push_back(err[1]);
Emass.push_back(err[2]);
Fchi2.push_back(fit->GetChisquare()/fit->GetNDF());
double xx= histo->GetXaxis()->GetBinCenter(i);
Xcenter.push_back(xx);
double ex = 0;
Ex.push_back(ex);
}
else {
// Skip nan
std::cout << "Skipping nan" << std::endl;
Ftop.push_back(0);
Fwidth.push_back(0);
Fmass.push_back(0);
Etop.push_back(1);
Ewidth.push_back(1);
Emass.push_back(1);
Fchi2.push_back(100000);
Xcenter.push_back(0);
Ex.push_back(1);
}
}
}
fileOut->Close();
//Plots the fit results in TGraphs
const int nn= Ftop.size();
double x[nn],ym[nn],e[nn],eym[nn];
double yw[nn],eyw[nn],yc[nn];
// std::cout << "number of bins = " << nn << std::endl;
// std::cout << "Values:" << std::endl;
for (int j=0;j<nn;j++){
// std::cout << "xCenter["<<j<<"] = " << Xcenter[j] << std::endl;
x[j]=Xcenter[j]+xDisplace;
// std::cout << "Fmass["<<j<<"] = " << Fmass[j] << std::endl;
ym[j]=Fmass[j];
// std::cout << "Emass["<<j<<"] = " << Emass[j] << std::endl;
eym[j]=Emass[j];
// std::cout << "Fwidth["<<j<<"] = " << Fwidth[j] << std::endl;
yw[j]=Fwidth[j];
// std::cout << "Ewidth["<<j<<"] = " << Ewidth[j] << std::endl;
eyw[j]=Ewidth[j];
// std::cout << "Fchi2["<<j<<"] = " << Fchi2[j] << std::endl;
yc[j]=Fchi2[j];
e[j]=0;
}
TGraphErrors *grM = new TGraphErrors(nn,x,ym,e,eym);
grM->SetTitle(name+"_M");
grM->SetName(name+"_M");
TGraphErrors *grW = new TGraphErrors(nn,x,yw,e,eyw);
grW->SetTitle(name+"_W");
grW->SetName(name+"_W");
TGraphErrors *grC = new TGraphErrors(nn,x,yc,e,e);
grC->SetTitle(name+"_chi2");
grC->SetName(name+"_chi2");
grM->SetMarkerColor(4);
grM->SetMarkerStyle(20);
grW->SetMarkerColor(4);
grW->SetMarkerStyle(20);
grC->SetMarkerColor(4);
grC->SetMarkerStyle(20);
//Draw and save the graphs
outputFile->cd();
TCanvas * c1 = new TCanvas(name+"_W",name+"_W");
c1->cd();
grW->Draw("AP");
c1->Write();
TCanvas * c2 = new TCanvas(name+"_M",name+"_M");
c2->cd();
grM->Draw("AP");
c2->Write();
TCanvas * c3 = new TCanvas(name+"_C",name+"_C");
c3->cd();
grC->Draw("AP");
c3->Write();
return grM;
}
void stackPlotter::moveDirHistsToStacks(TDirectory* tdir, TString histname, int color){
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks" << std::endl;
// get metainfo from directory, else exit TODO
metaInfo tMI;
tMI.extractFrom(tdir);
if(debug) {
std::cout << "stackPlotter::moveDirHistsToStacks || metaInfo color=" << tMI.color << std::endl;
std::cout << "stackPlotter::moveDirHistsToStacks || metaInfo legendname=" << tMI.legendname<< std::endl;
std::cout << "stackPlotter::moveDirHistsToStacks || metaInfo legendorder=" << tMI.legendorder << std::endl;
}
TIter histIter(tdir->GetListOfKeys());
TObject* cHistObj;
TKey* cHistKey;
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || Iterating through histograms." << std::endl;
// loop through keys in the directory
while((cHistKey = (TKey*) histIter())) {
if(histname != cHistKey->GetName()) continue;
cHistObj=tdir->Get(cHistKey->GetName());
if(!cHistObj->InheritsFrom(TH1::Class())) continue;
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || Found histogram "
<< cHistKey->GetName() << std::endl;
// prepare the histogram to be added to the stack
TH1* cHist = (TH1*) cHistObj->Clone();
cHist->SetDirectory(0);
TString mapName = cHist->GetName();
std::pair<Int_t,TH1*> newEntry(tMI.legendorder,cHist);
// initialize the stack info if needed
if(!stacksLegEntries_.count(mapName)) {
std::vector<std::pair<Int_t,TH1*> > legInfo(0);
legInfo.push_back(newEntry);
stacksLegEntries_[mapName] = legInfo;
}
cHist->SetFillColor(color);
cHist->SetFillStyle(1001);
cHist->SetMarkerStyle(kNone);
cHist->SetMarkerColor(kBlack);
cHist->SetLineColor(kBlack);
cHist->SetTitle(mapName);
cHist->SetName(tMI.legendname);
std::vector<std::pair<Int_t,TH1*> > legEntries = stacksLegEntries_[mapName];
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || legEntries size is " << legEntries.size() << std::endl;
for(size_t i=0; i < legEntries.size(); i++) {
if(legEntries.at(i).second == cHist && legEntries.at(i).first == tMI.legendorder) break;
if(legEntries.at(i).first >= tMI.legendorder) {
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || i is " << i << std::endl;
stacksLegEntries_[mapName].insert(stacksLegEntries_[mapName].begin()+i,newEntry);
break;
}
if(i==legEntries.size()-1) {
stacksLegEntries_[mapName].push_back(newEntry);
break;
}
}
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || legEntries size is " << legEntries.size() << std::endl;
}
}
void makePlots()
{
TFile * f2 = TFile::Open( "L1ITMuonBarrelPlots2.root");
TFile * f02 = TFile::Open( "L1ITMuonBarrelPlots0.2.root");
TFile * f005 = TFile::Open( "L1ITMuonBarrelPlots0.05.root");
TFile * f002 = TFile::Open( "L1ITMuonBarrelPlots0.02.root");
d2 = (TDirectory *) f2->Get( "L1ITMuPlotter");
d02 = (TDirectory *) f02->Get( "L1ITMuPlotter");
d005 = (TDirectory *) f005->Get( "L1ITMuPlotter");
d002 = (TDirectory *) f002->Get( "L1ITMuPlotter");
TString name;
//////////////////
/// Confirmed
drawConfirmed( "confirmed_st1" );
drawConfirmed( "confirmed_st2" );
drawConfirmed( "confirmed_st3" );
drawConfirmed( "confirmed_st4" );
TH1* conf = d005->Get( "confirmed_st1" )->Clone();
TH1* conf_2 = d005->Get( "confirmed_st2" );
TH1* conf_3 = d005->Get( "confirmed_st3" );
TH1* conf_4 = d005->Get( "confirmed_st4" );
conf->Add( conf_2 );
conf->Add( conf_3 );
conf->Add( conf_4 );
name = "confirmed_all";
TCanvas * confirmed = new TCanvas(name, name);
confirmed->cd();
// confirmed->SetLogy();
confirmed->SetGridy();
conf->SetLineWidth(2);
conf->Draw();
conf->Draw("sametext");
conf->SetTitle("confirmed in all stations");
conf->SetName("confirmed in all stations");
confirmed->SaveAs( name + "_dphi0.05.png" );
////////////////////
/// deltaPhiBin
name = "deltaPhiBin";
TCanvas * deltaPhiBin = new TCanvas(name, name);
deltaPhiBin->cd();
TH1* dphibin = d2->Get(name);
dphibin->SetLineWidth(2);
dphibin->Draw("text");
dphibin->Draw("same");
deltaPhiBin->SaveAs( name + ".png" );
////////////////////
/// deltaPhi
name = "deltaPhi";
TCanvas * deltaPhi = new TCanvas(name, name);
deltaPhi->cd();
TH1* dphi = d2->Get(name);
dphi->SetLineWidth(2);
dphi->Draw();
deltaPhi->SaveAs( name + ".png" );
////////////////////
/// deltaPhiDt
name = "deltaPhiDt";
TCanvas * deltaPhiDt = new TCanvas(name, name);
deltaPhiDt->cd();
TH1* dphiDt = d005->Get(name);
dphiDt->SetLineWidth(2);
dphiDt->Draw();
deltaPhiDt->SaveAs( name + ".png" );
/////////////////////////
/// rpcInHitsPerDtseg
name = "rpcInHitsPerDtseg";
TCanvas * rpcInHitsPerDtseg = new TCanvas(name, name);
rpcInHitsPerDtseg->SetGridy();
rpcInHitsPerDtseg->SetLogy();
rpcInHitsPerDtseg->cd();
TH1* rpcin = d005->Get(name);
rpcin->SetLineWidth(2);
rpcin->Draw();
rpcInHitsPerDtseg->SaveAs( name + "_dphi0.05.png" );
/////////////////////////
/// rpcOutHitsPerDtseg
name = "rpcOutHitsPerDtseg";
TCanvas * rpcOutHitsPerDtseg = new TCanvas(name, name);
rpcOutHitsPerDtseg->SetGridy();
rpcOutHitsPerDtseg->SetLogy();
rpcOutHitsPerDtseg->cd();
TH1* rpcout = d005->Get(name);
rpcout->SetLineWidth(2);
rpcout->Draw();
rpcOutHitsPerDtseg->SaveAs( name + "_dphi0.05.png" );
////////////////////
/// dtQuality_st1
name = "dtQuality_st1";
TCanvas * dtQuality_st1 = new TCanvas(name, name);
dtQuality_st1->SetGridx();
dtQuality_st1->SetGridy();
dtQuality_st1->cd();
// dtQuality_st1->SetLogz();
TH1* qual_st1 = d005->Get(name);
qual_st1->GetZaxis()->SetRangeUser( 0., 1. );
qual_st1->SetStats( 0 );
qual_st1->Draw("colztext");
dtQuality_st1->SaveAs( name + "_dphi0.05.png" );
////////////////////
/// dtQuality_st2
name = "dtQuality_st2";
TCanvas * dtQuality_st2 = new TCanvas(name, name);
dtQuality_st2->SetGridx();
dtQuality_st2->SetGridy();
dtQuality_st2->cd();
// dtQuality_st2->SetLogz();
TH1* qual_st2 = d005->Get(name);
qual_st2->GetZaxis()->SetRangeUser( 0., 1. );
qual_st2->SetStats( 0 );
qual_st2->Draw("colztext");
dtQuality_st2->SaveAs( name + "_dphi0.05.png" );
////////////////////
/// dtQualityNew
name = "dtQualityNew";
TCanvas * dtQualityNew = new TCanvas(name, name);
dtQualityNew->SetGridx();
dtQualityNew->SetGridy();
dtQualityNew->cd();
// dtQualityNew->SetLogz();
TH1* qualNew = d005->Get(name);
qualNew->GetZaxis()->SetRangeUser( 0., 0.5 );
qualNew->SetStats( 0 );
qualNew->Draw("colztext");
dtQualityNew->SaveAs( name + "_dphi0.05.png" );
}
