void draw_variations_sta_pp(int ieta, bool plotAll, bool statonly=false)
{
// ieta = 0 (0-1.6), 1 (1.6-2.4)
// plotAll: plot 100 variations for muid+trg if true, plot only +1/-1 sigma if false
// statonly: false -> stat+syst variations, true -> stat only variations
const char* statonly_str = statonly ? "_statonly" : "";
double eta;
double ptmin = 0;
if (ieta==0) {ptmin = 2.1; eta=0.3;}
else {ptmin = 1.5; eta=2.3;}
TCanvas *c1 = new TCanvas();
TH1F *haxes = new TH1F("haxes","haxes",10,0,20);
haxes->GetYaxis()->SetRangeUser(0.8,1.5);
haxes->GetXaxis()->SetTitle("p_{T}");
haxes->GetYaxis()->SetTitle("Correction");
haxes->Draw();
TLegend *tleg = new TLegend(0.55,0.5,0.9,0.83);
tleg->SetFillStyle(0);
tleg->SetFillColor(0);
tleg->SetBorderSize(0);
tleg->SetTextSize(0.035);
if (ieta==0) tleg->SetHeader("STA #eta^{#mu} #in [0.0, 0.9]");
else if (ieta==1) tleg->SetHeader("STA #eta^{#mu} #in [0.9, 1.6]");
else if (ieta==2) tleg->SetHeader("STA #eta^{#mu} #in [1.6, 2.1]");
else tleg->SetHeader("STA #eta^{#mu} #in [2.1, 2.4]");
int istart, istep;
if (plotAll) {
istart = 100; istep = -1;
} else {
istart = -2; istep = 1;
}
for (int i=istart; i*istep<=0; i += istep)
{
TF1 *func = new TF1(Form("var_%i",i),Form("tnp_weight%s_sta_pp(x,%f,%i)",statonly_str,eta,i),ptmin,20);
if (i==0) func->SetLineColor(kRed);
else func->SetLineColor(kBlack);
func->Draw("same");
if (i==0) {
tleg->AddEntry(func,"nominal","l");
} else if (abs(i)==1) {
tleg->AddEntry(func,"variation","l");
}
}
tleg->Draw();
TLatex *lt1 = new TLatex(); lt1->SetNDC();
lt1->SetTextSize(0.05);
lt1->DrawLatex(0.55,0.86,"pp #sqrt{s} = 2.76 TeV");
}
//------------------------------------------//
// Plot nDOM with out any other reqs.
//------------------------------------------//
void plotNDOM(TTree* tree)
{
// Plot the number of DOM's per event
TString var = "DetectorResponseEvent_.totalNumberOfDom_";
// Make canvas
TCanvas* c = makeCanvas("c");
// Create histogram holders
int nbins = 100;
int min = 0;
int max = 2000;
TString xtitle = "nDOMs";
TString ytitle = "Entries";
TH1F* hist = makeFrame("hist",nbins,min,max,
xtitle,ytitle);
// Make legend
TLegend* leg = makeLegend(0.7,0.8,0.8,0.9);
leg->SetHeader("Luminosity");
// Draw
tree->Draw((var+">>hist").Data(),"","hist");
// Add to legend
leg->AddEntry(hist, "All", "l");
// Now draw the figures
hist->Draw("hist");
leg->Draw("same");
c->SaveAs((savedir+"nDoms_total.png").Data());
}
//------------------------------------------//
// Problem 2: There is a requirement that
// at least 400 DOMs launch. I want to look
// at the average, and maybe also the average
// for given event range.
//------------------------------------------//
void checkNDOM(TTree* tree)
{
// Plot the number of DOM's per event
TString var = "DetectorResponseEvent_.totalNumberOfDom_";
// Make canvas
TCanvas* c = makeCanvas("c");
// Make a vector of TCuts
vector<TString> cuts;
cuts.push_back("1"); // 1%
cuts.push_back("3"); // 3%
cuts.push_back("10"); // 10%
cuts.push_back("30"); // 30%
cuts.push_back("51"); // 51%
cuts.push_back("100"); // 100%
// Create histogram holders
TH1F* hists[6];
int nbins = 100;
int min = 0;
int max = 2000;
TString xtitle = "nDOMs";
TString ytitle = "Entries";
// Make legend
TLegend* leg = makeLegend(0.7,0.8,0.6,0.9);
leg->SetHeader("Luminosity");
// Loop and draw
float maximum = -999;
for(unsigned int i=0; i<cuts.size(); ++i){
// get cut value
TString cutval = cuts.at(i);
// create histogram
hists[i] = makeFrame("hist_"+cutval,nbins,min,max,
xtitle,ytitle);
// cut the TCut object from value
TCut cut = lumiCut(cutval);
// Draw and set att
tree->Draw((var+">>hist_"+cutval).Data(),cut,"hist");
setAtt(hists[i],xtitle,ytitle,m_colors[i],m_markers[i]);
setMax(hists[i],maximum);
// Add to legend
leg->AddEntry(hists[i],(cutval+"%").Data(),"l");
}
// Now draw the figures
hists[0]->SetMaximum(maximum*1.1);
hists[0]->Draw("hist");
for(unsigned int i=1; i<cuts.size(); ++i)
hists[i]->Draw("samehist");
leg->Draw("same");
c->SaveAs((savedir+"nDoms_perLumi.png").Data());
}
TLegend* makeNoEWSBLegend(Double_t txtsz,Int_t tanBeta_){
txtsz = txtsz;
Double_t ypos_1 = 0.12;
Double_t ypos_2 = 0.22;
Double_t xpos_1 = 0.82;
Double_t xpos_2 = 0.92;
if(tanBeta_ == 40){
xpos_1 = 0.10;
xpos_2 = 0.20;
ypos_1 = 0.85;
ypos_2 = 0.95;
}
TLegend* legst = new TLegend(xpos_1,ypos_1,xpos_2,ypos_2);
legst->SetHeader("No EWSB");
legst->SetFillStyle(0);
legst->SetBorderSize(0);
legst->SetTextSize(0.03);
legst->SetTextAngle(30);
return legst;
}
void plotSpectraMin() {
vector<TH1F*> hists;
for(int i = 0; i < fileNames.size(); i++) {
hists.push_back(getHist(fileNames[i]));
}
TLegend * leg = new TLegend(0.60, 0.70, 0.88, 0.88);
leg->SetHeader("LED Pulse Width");
for(int i =0; i < hists.size(); i++) {
hists[i]->SetLineColor(i+1);
hists[i]->SetLineWidth(2);
//hists[i]->Sumw2();
hists[i]->Draw("SAME");
leg->AddEntry(hists[i], (TString)leg_entries[i]);
}
hists[hists.size()-1]->SetLineColor(hists.size()+1);
hists[hists.size()-1]->SetTitle("PMT Spectra with Varying LED Pulse Width");
hists[hists.size()-1]->GetXaxis()->SetTitle("Integrated Charge / (pC)");
hists[hists.size()-1]->GetYaxis()->SetTitle("Events");
hists[hists.size()-1]->GetYaxis()->SetRangeUser(0.5, 20000);
gStyle->SetOptStat(0);
leg->Draw();
}
//------------------------------------------//
// Format amplitude plots
//------------------------------------------//
void npulsePlot(TFile* file, vector<TString> filters)
{
// Specify the titles
TString xtitle = "Number of Pulses";
TString ytitle = "Entries";
// Histogram name
TString pname = "h_npulse";
// Create canvas
TCanvas* c = makeCanvas("c");
// Make legend
TLegend* leg = makeLegend(0.7,0.8,0.6,0.9);
//TLegend* leg = makeLegend(0.7,0.8,0.8,0.9);
// Loop and plot
TH1* hist[6];
float maximum = -999;
for(unsigned int i=0; i<filters.size(); ++i){
TString filter = filters.at(i);
hist[i] = getHist(file,pname+"_"+filter,xtitle,ytitle,
m_colors[i], m_markers[i]);
leg->AddEntry(hist[i],(filter+"%").Data(),"l");
if( maximum < hist[i]->GetMaximum() )
maximum = hist[i]->GetMaximum();
}// end loop over filters
/*
for(unsigned int i=0; i<filters.size(); ++i){
leg->Clear();
leg->SetHeader("Filter");
leg->AddEntry(hist[i],(filters.at(i)+"%").Data(),"l");
hist[i]->Draw();
leg->Draw("same");
c->SaveAs((savedir+"npulse_filter"+filters.at(i)+".png").Data());
}
return;
*/
// Set maximum correctly
hist[0]->SetMaximum(1.1*maximum);
hist[0]->Draw();
for(unsigned int i=1; i<filters.size(); ++i){
hist[i]->Draw("same");
}
// Draw legend
leg->SetHeader("Filter");
leg->Draw("same");
c->SaveAs((savedir+"npulse_perLumi.png").Data());
}
// construct the legend
TLegend *make_legend() {
leg_w = .2;
leg_h = .15;
leg_x = .67;
leg_y = .71;
TLegend *leg = new TLegend(leg_x, leg_y, leg_x+leg_w, leg_y+leg_h);
leg->SetHeader("Legend");
return leg;
}
// ----------------------------------------------------------------------
void plotRatioRaw(string era = "2016BF") {
gStyle->SetOptStat(0);
if (era == "all") {
plotRatioRaw("2011");
plotRatioRaw("2012");
plotRatioRaw("2016BF");
plotRatioRaw("2016GH");
return;
}
double eps(0.00001);
TH1D *hresult = new TH1D("hresult", Form("%s", era.c_str()), 80, 0., 0.4);
hresult->GetXaxis()->SetTitle("BDT > ");
hresult->SetMarkerStyle(24); hresult->SetLineColor(kRed+2); hresult->SetMarkerColor(kRed+2);
TH1D *hsresult = new TH1D("hsresult", Form("%s", era.c_str()), 80, 0.+eps, 0.4+eps);
hsresult->SetMarkerStyle(25); hsresult->SetLineColor(kBlue); hsresult->SetMarkerColor(kBlue);
TH1D *hbdtcut = new TH1D("hbdtcut", Form("%s", era.c_str()), 80, 0., 0.4);
hbdtcut->SetMarkerColor(kRed+2); hbdtcut->SetMarkerStyle(20);
TH1D *hsbdtcut = new TH1D("hsbdtcut", Form("%s", era.c_str()), 80, 0.+eps, 0.4+eps);
hsbdtcut->SetMarkerColor(kBlue); hsbdtcut->SetMarkerStyle(21);
invertedMuonIDRaw(era, 0.15, hresult, hsresult);
invertedMuonIDRaw(era, 0.20, hresult, hsresult);
invertedMuonIDRaw(era, 0.25, hresult, hsresult);
invertedMuonIDRaw(era, 0.30, hresult, hsresult);
invertedMuonIDRaw(era, -99., hbdtcut, hsbdtcut);
c0->Clear();
double ymax(50.);
double smax = hresult->GetMaximum();
double dmax = hsresult->GetMaximum();
double themax = (smax>dmax? smax: dmax);
if (themax < 50.) ymax = 50.;
if (themax < 20.) ymax = 30.;
if (themax < 5.) ymax = 10.;
if (themax < 0.5) ymax = 1.0;
hresult->SetMinimum(-ymax);
hresult->SetMaximum(ymax);
hresult->Draw();
hsresult->Draw("same");
hbdtcut->Draw("same");
hsbdtcut->Draw("same");
pl->DrawLine(0., 0., 0.4, 0.);
TLegend *tle = new TLegend(0.25, 0.2, 0.50, 0.5);
tle->SetFillStyle(0);
tle->SetBorderSize(0);
tle->SetHeader(era.c_str());
tle->AddEntry(hresult, "yield at B0", "p");
tle->AddEntry(hsresult, "yield at Bs", "p");
tle->Draw();
c0->SaveAs(Form("invertedMuonIDRaw-%s-result.pdf", era.c_str()));
}
void draw_ratio(std::vector<TH1F*> h,
TString name, TString xTitle,
double xmin, double xmax,
TString legHeader = "", bool legRIGHT = true, bool legTOP = true,
bool logX = false, bool stat = false, int rebin = -1, int orbin = -1,
TString option = "", int nclus = 99) { //double ymin_ratio, double ymax_ratio,
TCanvas* can = new TCanvas(name+"_ratio",name+"_ratio",900,450);
can->cd();
double legxmin = (legRIGHT ? 0.55 : 0.18);
double legxmax = legxmin+0.25;
double legymin = (legTOP ? 0.70 : 0.15);
double legymax = legymin+0.15;
TLegend* leg = new TLegend(legxmin,legymin,legxmax,legymax);
if (legHeader!="") leg->SetHeader(legHeader);
leg->SetTextSize(0.04);
leg->SetFillColor(0);
leg->SetLineColor(0);
TString options = (option=="" ? "pe" : option);
if (rebin>0) h[h.size()-1]->Rebin(rebin); //to rebin benchmark before divide
for (size_t i=0; i<h.size(); i++) {
//if(h[i]->GetNbinsX() != orbin) cout << "WARNING: orbin for " << h[i]->GetName() << " are " << h[i]->GetNbinsX() << endl; //debug - shift of h[][] wrt clu[][]
if (rebin>0 && i<(h.size()-1)) h[i]->Rebin(rebin);
TH1F* ratio = (TH1F*)h[i]->Clone("ratio_"+name);
ratio->Sumw2();
ratio->Divide(h[h.size()-1]); //benchmark is at the end.
if (logX) gPad->SetLogx();
ratio->SetMarkerStyle(20+i);
ratio->SetMarkerSize(1.0); //1.2
ratio->GetXaxis()->SetRangeUser(xmin,xmax);
ratio->SetMinimum(-0.1);
ratio->SetMaximum(4);
if (i==0){ //just for the first one
ratio->GetXaxis()->SetLabelSize(0.05);
ratio->GetXaxis()->SetTitle(xTitle);
ratio->GetXaxis()->SetTitleOffset(1);
ratio->GetXaxis()->SetTitleSize(0.06);
ratio->GetYaxis()->SetTitle("ratio");
ratio->GetYaxis()->SetTitleSize(0.06);
ratio->GetYaxis()->SetTitleOffset(0.7);
ratio->GetYaxis()->SetLabelSize(0.05);
}
string nam = "";
nam = translate(clu[nclus][0].c_str());
if(i==(h.size()-1)) leg->AddEntry(h[i],nam.c_str(),"l"); //to print only benchmark (first in the list)
if (i==1) options = options + (stat ? "sames" : "same"); //once is enought
ratio->Draw(options);
}
leg->Draw("same");
drawPrivate(0.04);
can->Update();
can->SaveAs(Outfolder+name+"_ratio.png");
}
void plotMultiplicity(char target[6], char list[20], char ene[6], char part[4],
char dir[12]="histo", char g4ver[20]="G4.9.1.p01") {
setStyle();
gStyle->SetOptTitle(0);
char name[1024], sym[10];
if (part=="pim") sprintf(sym, "#pi^{-}");
else if (part=="pip") sprintf(sym, "#pi^{+}");
else sprintf(sym, "p");
std::vector<std::string> typeOld = typesOld();
int energy = atoi(ene);
char ofile[100];
sprintf (ofile, "%s/histo_%s%s_%s_%sGeV.root", dir, target, list, part, ene);
std::cout << "Input file " << ofile << "\n";
TFile *fout = TFile::Open(ofile);
fout->cd();
char name[160], title[160], ctype[20], ytitle[20], cname[160];
TH1I *hiMulti[20];
for (unsigned int ii=0; ii<=(typeOld.size()); ii++) {
if (ii == 0) sprintf (ctype, "All Particles");
else sprintf (ctype, "%s", typeOld[ii-1].c_str());
sprintf (name, "Multi%s%s%sGeV(%s)", target, list, ene, ctype);
hiMulti[ii] = (TH1I*)fout->FindObjectAny(name);
// std::cout << ii << " (" << ctype << ") " << name << " " << hiMulti[ii] << "\n";
}
TCanvas *c[20];
std::vector<std::string> types = types();
for (unsigned int ii=0; ii<types.size(); ii++) {
if (ii == 0) sprintf (ctype, "All Particles");
else sprintf (ctype, "%s", types[ii-1].c_str());
sprintf (cname, "Multiplicity (%s)", ctype);
hiMulti[ii]->GetXaxis()->SetTitle(cname);
hiMulti[ii]->SetMarkerStyle(mstyle[ii]);
hiMulti[ii]->SetMarkerSize(msiz[ii]);
hiMulti[ii]->SetMarkerColor(mcolor[ii]);
hiMulti[ii]->SetLineColor(lcolor[ii]);
hiMulti[ii]->SetLineStyle(lstyle[ii]);
hiMulti[ii]->SetLineWidth(lwidth[ii]);
sprintf(cname, "c_%s%s_%s_%sGeV_Multiplicity(%s)", target, list, part,
ene, ctype);
c[ii] = new TCanvas(cname, cname, 800, 500);
hiMulti[ii]->Draw();
TLegend *leg = new TLegend(0.35, 0.80, 0.8, 0.87);
char hdr[160];
sprintf(hdr, "%s+%s at %s GeV (%s-%s)", sym, target, ene, g4ver, list);
leg->SetHeader(hdr); leg->SetFillColor(10); leg->SetMargin(0.45);
leg->SetTextSize(.036); leg->Draw("same");
}
}
//------------------------------------//
// Main
//------------------------------------//
void AnaEField()
{
// Make Canvas
TCanvas* can = makeCanvas("can");
can->SetLogy();
can->SetGridx();
can->SetGridy();
// Define the function here with parameters:
// [0] = L
// [1] = freq
// [2] = k
// [3] = n
// [4] = sqrt(2pi) * mu * mu0
TString func = "[4]*[0]*[1]*sin(x/57.2957)*exp(-pow([2]*[0],2)*pow(cos(x/57.2957)-1/[3],2)/2)";
//TString func = "[4]*[1]*sin(x/57.2957)*exp(-pow([2]*[0],2)*pow(cos(x/57.2957)-1/[3],2)/2)";
//TString func = "[4]*[0]*[1]*exp(-pow([2]*[0],2)*pow(cos(x/57.2957)-1/[3],2)/2)";
// Now fix some of the variables:
double freq = 1e9; //600e6; // Hz
double c = 3e8; // m/s
double n = 1.3; //1.78;
double k = 2*TMath::Pi() * n * freq/c; // 1/m
double Const= sqrt(2*TMath::Pi()) * 4 * TMath::Pi() * 1e-7 * 1;
// Make a dummy histogram
TH1F* h = makeHist("h",100,0,90,"Angle [deg]", "Field Strength",kBlack,0);
h->Fill(1e10);
h->SetMinimum(10);
h->SetMaximum(3000);
h->Draw();
// Make two instances of the function
TF1* f0 = new TF1("f0",func.Data(),0,90);
setParam(f0,1.2,freq,k,n,Const,kBlack);
TF1* f1 = new TF1("f1",func.Data(),0,90);
setParam(f1,0.1,freq,k,n,Const,kBlue);
// Draw
f0->Draw("same");
f1->Draw("same");
// Add Legend
TLegend* leg = makeLegend(0.15,0.3,0.7,0.9);
leg->SetHeader("f = 600 MHz");
leg->AddEntry(f0,"L = 1.2m","l");
leg->AddEntry(f1,"L = 0.1m","l");
leg->Draw("same");
//can->SaveAs("../plots/quickAnalytic_600MHz.png");
}
void DrawTree::setLegend(float xmin, float ymin, float xsize, float ysize,char* header) {
_legend = new TLegend(xmin,ymin,xmin+xsize,ymin+ysize);
_legend->SetTextAlign(12);
_legend->SetTextColor(1);
_legend->SetTextSize(0.03);
_legend->SetFillStyle(0);
_legend->SetFillColor(0);
_legend->SetBorderSize(0);
_legend->SetHeader(header);
}
TLegend *createLegend(const string &text)
{
TLegend *legend = new TLegend( .2, .7, .3, .8);
if (!text.empty())
legend->SetHeader(text.c_str());
legend->SetMargin(0.12);
legend->SetTextSize(0.06);
legend->SetFillColor(10);
legend->SetBorderSize(0);
return legend;
}
void DrawTProfile(TFile** File, char** Histos_Name, std::vector<char*> legend, char* Title, char* Xlegend, char* Ylegend, double xmin, double xmax, double ymin, double ymax, bool save, char* save_path)
{
int Color[] = {2,4,8,1,4,6,3,9,5};
int Marker[] = {21,22,23,20,20,3,2};
int Style[] = {1,5,7,9,10};
int N = legend.size();
TProfile** Histos = new TProfile*[N];
double HistoMax = -1;
int HistoHeighest = -1;
for(int i=0;i<N;i++){
Histos[i] = File[i]->Get(Histos_Name[i]);
Histos[i]->SetTitle();
Histos[i]->SetStats(kFALSE);
Histos[i]->GetXaxis()->SetTitle(Xlegend);
Histos[i]->GetYaxis()->SetTitle(Ylegend);
Histos[i]->GetYaxis()->SetTitleOffset(1.20);
if(xmin!=xmax)Histos[i]->SetAxisRange(xmin,xmax,"X");
if(ymin!=ymax)Histos[i]->SetAxisRange(ymin,ymax,"Y");
Histos[i]->SetMarkerStyle(Marker[i]);
Histos[i]->SetMarkerColor(Color[i]);
Histos[i]->SetMarkerSize(1.5);
}
TLegend* leg;
// leg = new TLegend(0.10,0.90,0.50,0.90-N*0.1);
leg = new TLegend(0.90,0.90,0.55,0.90-N*0.1);
leg->SetFillColor(0);
if(strcmp(Title,"")!=0)leg->SetHeader(Title);
Histos[0]->Draw("");
for(int i=0;i<N;i++){
Histos[i]->Draw("Same");
}
for(int i=0;i<N;i++){
leg->AddEntry(Histos[i], legend[i] ,"P");
}
leg->Draw();
if(save==1){
// char path[255]; sprintf(path,"Pictures/PNG/%s.png",save_path); c1->SaveAs(path);
// char path[255]; sprintf(path,"Pictures/EPS/%s.eps",save_path); c1->SaveAs(path);
// char path[255]; sprintf(path,"Pictures/C/%s.C" ,save_path); c1->SaveAs(path);
c1->SaveAs(save_path);
}
}
TLegend *getLegend(double x1, double y1, double x2, double y2)
{
TLegend *leg = new TLegend(x1,y1,x2,y2,NULL,"BRNDC");
leg->SetHeader("");
leg->SetBorderSize(0);
leg->SetTextFont(42);
leg->SetTextSize(0.06);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(10);
leg->SetFillStyle(1001);
return leg;
}
void main(){
fstream fin1("fitPara_vs_X.txt",ios::in);
fstream fin2("allX_vs_Y.txt",ios::in);
float y,x1,x2; // for fitPara_vs_X.txt
float x,y1,y2;
TGraph* g1 = new TGraph(); g1->SetName("sigma_vs_X");
TGraph* g2 = new TGraph(); g2->SetName("chi2_vs_X");
TGraph* g3 = new TGraph(); g3->SetName("mean_vs_Y");
TGraph* g4 = new TGraph(); g4->SetName("chi2_vs_Y");
int n1=0;
int n2=0;
while(fin1>>y>>x1>>x2){
if(y>=-37 && y<=-20){
g1->SetPoint(n1,x1,y);
g2->SetPoint(n1,x2,y);
//cout<<y<<"\t"<<x1<<"\t"<<x2<<endl;
n1++;
}
}
fin1.close();
while(fin2>>x>>y1>>y2){
g3->SetPoint(n2,x,y1);
g4->SetPoint(n2,x,y2);
n2++;
}
fin2.close();
TCanvas* c = new TCanvas();
g4->GetXaxis()->SetTitle("X offset [mm]"); g4->GetXaxis()->SetTitleSize(0.05); g4->GetXaxis()->SetLabelSize(0.05);
g4->GetYaxis()->SetTitle("Y offset [mm]"); g4->GetYaxis()->SetTitleSize(0.05); g4->GetYaxis()->SetLabelSize(0.05);
g1->SetMarkerStyle(24); g1->SetMarkerColor(kBlack);
g2->SetMarkerStyle(25); g2->SetMarkerColor(kRed);
g3->SetMarkerStyle(26); g3->SetMarkerColor(kBlue);
g4->SetMarkerStyle(27); g4->SetMarkerColor(kPink);
g4->GetYaxis()->SetRangeUser(-38,-20);
g4->GetXaxis()->SetRangeUser(-1910,-1810);
g4->Draw("AP");
g2->Draw("P");
g3->Draw("P");
g1->Draw("P");
TLegend* leg = new TLegend(0.5,0.5,0.9,0.9);
leg->SetHeader("Minimizing from: ");
leg->AddEntry(g1,"residual sigma vs X","lp");
leg->AddEntry(g2,"#chi^{2} vs X","lp");
leg->AddEntry(g3,"residual mean vs Y","lp");
leg->AddEntry(g4,"#chi^{2} vs Y","lp");
leg->Draw();
}
void PlotEff(TString dataFileName = "DataEE_eleEndcap",
TString mcFileName = "DYJetsToEE_M-50_eleEndcap",
TString histBaseName = "ZMassEndcap") {
SetStyle();
TFile * fileData = new TFile(dataFileName+".root");
TFile * fileMC = new TFile(mcFileName+".root");
TGraphAsymmErrors * effData = (TGraphAsymmErrors*)fileData->Get(histBaseName);
TGraphAsymmErrors * effMC = (TGraphAsymmErrors*)fileMC->Get(histBaseName);
effData->SetLineColor(2);
effData->SetMarkerColor(2);
effData->SetMarkerSize(1.2);
effData->SetMarkerStyle(20);
effMC->SetLineColor(4);
effMC->SetMarkerColor(4);
effMC->SetMarkerStyle(21);
effMC->GetXaxis()->SetTitleOffset(1.1);
effMC->GetXaxis()->SetTitleSize(0.05);
effMC->GetYaxis()->SetTitleOffset(1.1);
effMC->GetYaxis()->SetTitleSize(0.05);
effMC->GetYaxis()->SetRangeUser(0.0,1.001);
TString EtaRegion("Endcap");
if (histBaseName.Contains("Barrel"))
EtaRegion = "Barrel";
TCanvas * canv = new TCanvas("canv","",700,600);
effMC->Draw("APE");
effData->Draw("PESame");
TLegend * leg = new TLegend(0.69,0.17,0.94,0.40);
leg->SetFillColor(0);
leg->SetHeader(EtaRegion);
leg->SetTextSize(0.06);
leg->AddEntry(effData,"Data","lp");
leg->AddEntry(effMC,"MC","lp");
leg->Draw();
canv->SetGridx();
canv->SetGridy();
canv->Print(histBaseName+"_eff.png");
canv->Update();
}
void create_boxy_legend(const TString legend_header, const int n_boxes,
const TString *const box_names, const int box_colors[n_boxes],
const float x1 = 0.15, const float x2 = 0.45,
const float y1 = 0.60, const float y2 = 0.90
){
TLegend* leg = new TLegend(x1,y1,x2,y2);
leg->SetHeader(legend_header);
leg->SetFillColor(0);
// TBox* boxes[n_boxes] = new TBox*[n_boxes]; //allocate the memory
TBox* boxes[n_boxes];
for(int i = 0; i < n_boxes; ++i) {
boxes[i] = new TBox(0.0, 0.0, 0.0, 0.0);
boxes[i]->SetFillColor(box_colors[i]);
leg->AddEntry(boxes[i], box_names[i],"F");
}
leg->Draw();
}
void DrawLegend(TObject** Histos, std::vector<char*> legend, char* Title, char* Style, double X, double Y, double W, double H)
{
int N = legend.size();
if(strcmp(legend[0],"")!=0){
TLegend* leg;
leg = new TLegend(X,Y,X-W,Y - N*H);
leg->SetFillColor(0);
leg->SetBorderSize(0);
if(strcmp(Title,"")!=0)leg->SetHeader(Title);
for(int i=0;i<N;i++){
TH2D* temp = (TH2D*)Histos[i]->Clone();
temp->SetMarkerSize(1.3);
leg->AddEntry(temp, legend[i] ,Style);
}
leg->Draw();
}
}
void darkRate() {
//gROOT->SetBatch(true);
gROOT->SetStyle("Plain");
gStyle->SetOptStat(0000);
gStyle->SetOptTitle(0);
TFile * f1300 = new TFile("Spectra/08_12_16_1700V_LightsOff_Short.root", "READ");
TFile * f1500 = new TFile("Spectra/08_12_16_1800V_LightsOff_Short.root", "READ");
TFile * f1700 = new TFile("Spectra/08_12_16_1900V_LightsOff_Short.root", "READ");
TTree * t1300 = (TTree*)f1300->Get("Channel_1");
TTree * t1500 = (TTree*)f1500->Get("Channel_1");
TTree * t1700 = (TTree*)f1700->Get("Channel_1");
TGraphErrors * h1300 = integralHistogram(t1300);
TGraphErrors * h1500 = integralHistogram(t1500);
TGraphErrors * h1700 = integralHistogram(t1700);
h1300->GetYaxis()->SetTitle("Rate [Hz]");
h1300->GetYaxis()->SetRangeUser(0.5, 10e6);
h1300->GetXaxis()->SetTitle("Threshold [mV]");
h1300->GetXaxis()->SetRangeUser(0.5, 1000);
h1300->SetLineColor(kBlack);
h1500->SetLineColor(kRed);
h1700->SetLineColor(kBlue);
TLegend * leg = new TLegend(0.60, 0.70, 0.88, 0.88);
leg->SetHeader("PMT Voltage");
leg->AddEntry(h1300, "1700V", "l");
leg->AddEntry(h1500, "1800V", "l");
leg->AddEntry(h1700, "1900V", "l");
h1300->Draw("ALP");
h1500->Draw("LP");
h1700->Draw("LP");
leg->Draw();
}
//------------------------------------------//
// Format amplitude plots
//------------------------------------------//
void ampPlot(TFile* file, vector<TString> filters)
{
// Specify the titles
TString xtitle = "Amplitude [v]";
TString ytitle = "Entries";
// Histogram name
TString pname = "h_amp";
// Create canvas
TCanvas* c = makeCanvas("c");
c->SetLogx();
c->SetLogy();
// Make legend
TLegend* leg = makeLegend(0.7,0.8,0.8,0.9);
// Loop and plot
TH1* hist = NULL;
for(unsigned int i=0; i<filters.size(); ++i){
leg->Clear();
leg->SetHeader("Filter");
TString filter = filters.at(i);
hist = getHist(file,pname+"_"+filter,xtitle,ytitle,
m_colors[i], m_markers[i]);
leg->AddEntry(hist,(filter+"%").Data(),"l");
hist->Draw();
// Draw legend
leg->Draw("same");
c->SaveAs((savedir+"amp_filter"+filter+".png").Data());
}// end loop over filters
}
//------------------------------------------//
// Plotting the maximum time difference
// for the maximum amplitude wave
//------------------------------------------//
void tDiffMaxPlotForMaxV(TFile* file, vector<TString> filters)
{
// Specify the titles
TString xtitle = "Max(LEtime - wavetime) [ns]";
TString ytitle = "Entries";
// Histogram name
TString pname = "h_maxTDiff_forMaxV";
// Create canvas
TCanvas* c = makeCanvas("c");
//c->SetLogy();
// Make legend
TLegend* leg = makeLegend(0.7,0.8,0.8,0.9);
// Loop and plot
TH1* hist = NULL;
for(unsigned int i=0; i<filters.size(); ++i){
leg->Clear();
leg->SetHeader("Filter");
TString filter = filters.at(i);
hist = getHist(file,pname+"_"+filter,xtitle,ytitle,
m_colors[i], m_markers[i]);
leg->AddEntry(hist,(filter+"%").Data(),"l");
hist->Draw();
// Draw legend
leg->Draw("same");
// Save
//c->SaveAs((savedir+"maxTimeDiff_filter"+filter+"_nonlog.png").Data());
//c->SaveAs((savedir+"maxTimeDiff_cutOnCounter_filter"+filter+"_nonlog.png").Data());
}// end loop over filters
}
//_____________________________________________________
TLegend* GFHistManager::AddLegend(Int_t layer, Int_t histoNum,
const char* header, Bool_t referAll)
{
// adds a legend referencing all hists in same pad 'histoNum' of layer
//
// FIXME: use help of other AddLegend method?
if(!this->CheckHistNum("AddLegend", layer, histoNum)) return NULL;
TObjArray* legendsOfLayer = this->MakeLegends(layer);
TLegend* legend = (legendsOfLayer->GetSize() <= histoNum ?
NULL : static_cast<TLegend*>(legendsOfLayer->At(histoNum)));
if(!legend) {
legend = new TLegend(fLegendX1, fLegendY1, fLegendX2, fLegendY2);
#if ROOT_VERSION_CODE < ROOT_VERSION(5,6,0)
if (TString(gStyle->GetName()) == "Plain") legend->SetBorderSize(1);
#endif
legendsOfLayer->AddAtAndExpand(legend, histoNum);
}
if(header) legend->SetHeader(header);
GFHistArray* hists = this->GetHistsOf(layer, histoNum);
TList* legendEntries = legend->GetListOfPrimitives();
if(referAll){
TIter histsIter(hists);
while(TObject* hist = histsIter.Next()){
Bool_t addNew = kTRUE;
TIter legEntrIter(legendEntries);
while(TLegendEntry* entry = static_cast<TLegendEntry*>(legEntrIter())){
if(hist == entry->GetObject()) {addNew = kFALSE; break;}
}
if(addNew) legend->AddEntry(hist, hist->GetName(), fgLegendEntryOption);
}
}
if(layer < fCanArrays->GetEntriesFast()) {
this->Update(layer); // if canvas already drawn
}
return legend;
}
TLegend* makeStauLegend(Double_t txtsz,Int_t tanBeta_){
Double_t ypos_1 = 0.78;
Double_t ypos_2 = 0.80;
Double_t xpos_1 = 0.16;
Double_t xpos_2 = 0.17;
if(tanBeta_ == 40){
xpos_1 = 0.14;
xpos_2 = 0.15;
ypos_1 = 0.76;
ypos_2 = 0.78;
}
TLegend* legst = new TLegend(xpos_1+0.025,ypos_1,xpos_2+0.025,ypos_2);
legst->SetHeader("#tilde{#tau} = LSP");
legst->SetFillStyle(0);
legst->SetBorderSize(0);
legst->SetTextSize(0.03);
legst->SetTextAngle(80);
return legst;
}
TLegend* makeStauLegend(Double_t txtsz,Int_t tanBeta_){
txtsz = txtsz;
Double_t ypos_1 = 0.78;
Double_t ypos_2 = 0.80;
Double_t xpos_1 = 0.17;
Double_t xpos_2 = 0.19;
if(tanBeta_ == 50){
xpos_1 = 0.17;
xpos_2 = 0.18;
ypos_1 = 0.76;
ypos_2 = 0.78;
}
TLegend* legst = new TLegend(xpos_1,ypos_1,xpos_2,ypos_2);
legst->SetHeader("#tilde{#tau} = LSP");
legst->SetFillStyle(0);
legst->SetBorderSize(0);
legst->SetTextSize(0.03);
legst->SetTextAngle(85);
return legst;
}
void compareGen(std::string mcfile1, std::string mcfile2,
std::string var1, std::string var2="",
std::string xtitle,
std::string output="test",
std::string header="Z(#rightarrow ee)+#geq 1 jet",
std::string mcName1="Data",
std::string mcName2="Madgraph",
float xmin=-9999.0, float xmax=-9999.0,
bool logScale=true
)
{
setTDRStyle();
gStyle->SetOptStat(0);
TH1F* h1;
TH1F* h2;
char tempName[300];
if(var2 == "" )var2=var1;
// first get the histogram files
TFile *fmc1 = TFile::Open(mcfile1.data());
TFile *fmc2 = TFile::Open(mcfile2.data());
h1 = (TH1F*)(fmc1->Get(var1.data()));
h2 = (TH1F*)(fmc2->Get(var2.data()));
TH1D* hscale =(TH1D*) h1->Clone("hscale");
hscale->SetYTitle(Form("%s/%s",mcName1.data(),mcName2.data()));
h1->GetXaxis()->SetNdivisions(5);
h1->GetYaxis()->SetDecimals();
h2->GetXaxis()->SetNdivisions(5);
h2->GetYaxis()->SetDecimals();
hscale->GetXaxis()->SetNdivisions(5);
hscale->GetYaxis()->SetDecimals();
h1->SetLineColor(2);
h1->SetMarkerColor(2);
h1->SetMarkerSize(1);
h1->SetMarkerStyle(24);
h2->SetLineColor(4);
h2->SetMarkerColor(4);
h2->SetMarkerSize(1);
h2->SetMarkerStyle(21);
// if normalizing to the same area, set the scale
int binLo = -1;
int binHi = -1;
int nbins = h1->GetNbinsX();
if(xmin>-9999.0 && xmax>-9999.0)
{
binLo = h1->FindBin(xmin);
binHi = h1->FindBin(xmax)-1;
}
else
{
binLo = 1;
binHi = nbins;
xmin = h1->GetBinLowEdge(1);
xmax = h1->GetBinLowEdge(nbins+1);
}
float scale_mc = (float)h1->Integral(binLo,binHi)/(float)h2->Integral(binLo,binHi);
// cout << "binLo = " << binLo << ", binHi = " << binHi << endl;
// cout << "xmin = " << xmin << "xmax = " << xmax << endl;
// h2->Sumw2();
// // scale_mc = 1000.0*4.890*3048.0/2.29809910000000000e+07;
// h2->Scale(scale_mc);
cout << "h2 integral = " << h2->Integral() << endl;
cout << "h1 integral = " << h1->Integral() << endl;;
// get the ratio
double chi2 = 0;
int realbin = 0;
for(int i=1;i<= nbins;i++){
double nmc=h2->GetBinContent(i);
double ndata=h1->GetBinContent(i);
double nmcerr=h2->GetBinError(i);
double ndataerr=h1->GetBinError(i);
if(nmc<0 || ndata<0)continue;
if(nmcerr==0 && ndataerr==0)continue;
if(nmc==0 && ndata==0)continue;
double chi2ndef = (nmc-ndata)*(nmc-ndata)/
( nmcerr*nmcerr+ ndataerr*ndataerr);
chi2 += chi2ndef;
realbin++;
cout << "Bin " << i << " : " << ndata << ", " << nmc;
cout << " " << chi2ndef << endl;
// now calculate the ratio
if(nmc==0 || nmcerr==0 || ndata==0 || ndataerr==0)
{
hscale->SetBinContent(i,-9999);
hscale->SetBinError(i,1e-4);
continue;
}
cout << "Bin " << i << " ratio = " << ndata/nmc << endl;
hscale->SetBinContent(i,ndata/nmc);
double err = 0;
err=
(ndata/nmc)*sqrt(pow(nmcerr/nmc,2)+pow(ndataerr/ndata,2));
hscale->SetBinError(i,err);
}
for(int i=1;i<=hscale->GetNbinsX();i++)
cout << i << ": " << hscale->GetBinContent(i) << endl;
h1->GetXaxis()->SetRangeUser(xmin,xmax);
h2->GetXaxis()->SetRangeUser(xmin,xmax);
hscale->GetXaxis()->SetRangeUser(xmin,xmax);
TCanvas* c1 = new TCanvas("c1","",700,1000);
c1->Divide(1,2,0.01,0);
c1->cd(1);
if(logScale)
gPad->SetLogy(1);
gPad->SetTopMargin(0.01);
gPad->SetBottomMargin(0);
gPad->SetRightMargin(0.04);
float max_data = h1->GetBinError(h1->GetMaximumBin()) + h1->GetMaximum();
float max_mc = h2->GetBinError(h2->GetMaximumBin()) + h2->GetMaximum();
if(max_data > max_mc)
{
h1->Draw("e");
h2->Draw("hesame");
}
else
{ h2->Draw("he");
h1->Draw("esame");
}
float x1NDC = 0.725;
float y1NDC = 0.615;
float x2NDC = 0.928;
float y2NDC = 0.951;
TLegend* leg = new TLegend(x1NDC,y1NDC,x2NDC,y2NDC);
leg->SetHeader(header.data());
leg->SetFillColor(0);
leg->SetFillStyle(0);
leg->SetTextSize(0.04);
leg->SetBorderSize(0);
leg->AddEntry(h1, mcName1.data());
leg->AddEntry(h2, mcName2.data());
leg->Draw("same");
c1->cd(2);
gStyle->SetStatW (0.3);
gStyle->SetStatH (0.3);
gStyle->SetStatX (0.879447);
gStyle->SetStatY (0.939033);
gStyle->SetStatFontSize(0.05);
gStyle->SetStatBorderSize(0);
gPad->SetRightMargin(0.04);
gPad->SetTopMargin(0);
gPad->SetBottomMargin(0.2);
gPad->SetTickx();
gStyle->SetOptFit(1);
hscale->SetTitle("");
hscale->GetXaxis()->SetTitle(xtitle.data());
// hscale->SetMaximum(3.0);
// hscale->SetMinimum(0.1);
hscale->SetMaximum(2.0);
hscale->SetMinimum(0.5);
hscale->SetTitleOffset(1.2,"Y");
hscale->Draw("e1");
TF1* fline = new TF1("fline","pol1");
TLine* l2 = new TLine(xmin,1.,xmax,1.);
l2->SetLineColor(4);
l2->SetLineStyle(3);
fline->SetLineWidth(3);
fline->SetLineColor(6);
fline->SetNpx(2500);
// hscale->Fit("fline","","");
l2->Draw("same");
string dirName = "compareGen";
gSystem->mkdir(dirName.data());
std::string filename;
std::string psname = dirName + "/" + var1;
if(output !="test")
psname = dirName+ "/" + output;
else
psname = dirName+ "/" + var1;
filename = psname + ".eps";
c1->Print(filename.data());
filename = psname + ".gif";
c1->Print(filename.data());
filename = psname + ".pdf";
c1->Print(filename.data());
// c1->Close();
}
void cutFlowStudyMu( Double_t hltEff_=0.94, Int_t applyHLTData_ = 1, Int_t applyHLTMC_ = 1 , Float_t hMass_ = 115)
{
ofstream out(Form("cutFlow_MuTauStream_iter3_%.0f.txt",hMass_));
out.precision(4);
TCut hltData("((HLTmu==1 && run<=163261) || (HLTx==1 && run>163261))");
TCut hltMC("HLTx==1");
TFile *fFullData = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011_iter3/treeMuTauStream_Run2011-Mu.root","READ");
TFile *fFullSignalVBF = new TFile(Form("/data_CMS/cms/lbianchini//MuTauStream2011_iter3/treeMuTauStream_VBFH%.0f-Mu-powheg-PUS1.root",hMass_),"READ");
float equivalentGGMass = 115;
float scaleGGH = 1.0;
if(hMass_ == 125){
equivalentGGMass = 120;
scaleGGH = 0.821;
}
if(hMass_ == 135){
equivalentGGMass = 130;
scaleGGH = 0.757;
}
TFile *fFullSignalGGH = new TFile(Form("/data_CMS/cms/lbianchini//MuTauStream2011_iter3/treeMuTauStream_GGFH%.0f-Mu-powheg-PUS1.root",equivalentGGMass),"READ");
TFile *fFullBackgroundDYTauTau = new TFile("/data_CMS/cms/lbianchini/MuTauStream2011_iter3/treeMuTauStream_DYJets-Mu-50-madgraph-PUS1.root","READ");
TFile *fFullBackgroundDYMuMu = new TFile("/data_CMS/cms/lbianchini/MuTauStream2011_iter3/treeMuTauStream_DYJets-Mu-50-madgraph-PUS1.root","READ");
//TFile *fFullBackgroundWJets = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011_iter3/treeMuTauStream_WJets-Mu-madgraph-PUS1.root","READ");
TFile *fFullBackgroundEWK = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011_iter3/treeMuTauStream_ElectroWeak.root","READ");
TFile *fFullBackgroundQCD = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011_iter3/treeMuTauStream_QCDmu-pythia-20-15-PUS1.root","READ");
//TFile *fFullBackgroundTTbar = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011_iter3/treeMuTauStream_TTJets-Mu-madgraph-PUS1.root","READ");
//TFile *fFullBackgroundSingleTop = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011_iter3/treeMuTauStream_SingleTop-Mu.root","READ");
//TFile *fFullBackgroundDiBoson = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011_iter3/treeMuTauStream_DiBoson-Mu.root","READ");
TFile *fFullBackgroundTop = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011_iter3/treeMuTauStream_Top.root","READ");
// OpenNTuples
TString fDataName = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleRun2011-Mu_Open_MuTauStream.root";
TString fSignalNameVBF = Form("/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleVBFH%.0f-Mu-powheg-PUS1_Open_MuTauStream.root",hMass_);
TString fSignalNameGGH = Form("/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleGGFH%.0f-Mu-powheg-PUS1_Open_MuTauStream.root",equivalentGGMass);
TString fBackgroundNameDYTauTau = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleDYJets-Mu-50-madgraph-PUS1_Open_MuTauStream.root";
TString fBackgroundNameDYMuMu = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleDYJets-Mu-50-madgraph-PUS1_Open_MuTauStream.root";
TString fBackgroundNameWJets = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleWJets-Mu-madgraph-PUS1_Open_MuTauStream.root";
TString fBackgroundNameEWK = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleElectroWeak_Open_MuTauStream.root";
TString fBackgroundNameQCD = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleQCDmu-pythia-20-15-PUS1_Open_MuTauStream.root";
TString fBackgroundNameTTbar = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleTTJets-Mu-madgraph-PUS1_Open_MuTauStream.root";
TString fBackgroundNameTop = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleTop_Open_MuTauStream.root";
TString fBackgroundNameSingleTop = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleSingleTop-Mu_Open_MuTauStream.root";
TString fBackgroundNameDiBoson = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011_iter3/Inclusive/nTupleDiBoson-Mu_Open_MuTauStream.root";
TFile *fData(0);
TFile *fSignalVBF(0);
TFile *fSignalGGH(0);
TFile *fBackgroundDYTauTau(0);
TFile *fBackgroundDYMuMu(0);
TFile *fBackgroundWJets(0);
TFile *fBackgroundEWK(0);
TFile *fBackgroundQCD(0);
TFile *fBackgroundTTbar(0);
TFile *fBackgroundTop(0);
TFile *fBackgroundSingleTop(0);
TFile *fBackgroundDiBoson(0);
fData = TFile::Open( fDataName );
fSignalVBF = TFile::Open( fSignalNameVBF );
fSignalGGH = TFile::Open( fSignalNameGGH );
fBackgroundDYTauTau = TFile::Open( fBackgroundNameDYTauTau );
fBackgroundDYMuMu = TFile::Open( fBackgroundNameDYMuMu );
//fBackgroundWJets = TFile::Open( fBackgroundNameWJets );
fBackgroundEWK = TFile::Open( fBackgroundNameEWK );
fBackgroundQCD = TFile::Open( fBackgroundNameQCD );
//fBackgroundTTbar = TFile::Open( fBackgroundNameTTbar );
fBackgroundTop = TFile::Open( fBackgroundNameTop );
//fBackgroundSingleTop= TFile::Open( fBackgroundNameSingleTop );
//fBackgroundDiBoson = TFile::Open( fBackgroundNameDiBoson );
if(!fSignalVBF || !fBackgroundDYTauTau || /*!fBackgroundWJets ||*/ !fBackgroundQCD /* || !fBackgroundTTbar || !fBackgroundSingleTop*/ ||
!fSignalGGH || !fBackgroundDYMuMu || /*!fBackgroundDiBoson ||*/ !fBackgroundTop || !fBackgroundEWK || !fData){
std::cout << "ERROR: could not open files" << std::endl;
exit(1);
}
TString tree = "outTreePtOrd";
TTree *data = (TTree*)fData->Get(tree);
TTree *signalVBF = (TTree*)fSignalVBF->Get(tree);
TTree *signalGGH = (TTree*)fSignalGGH->Get(tree);
TFile* dummy1 = new TFile("dummy1.root","RECREATE");
TTree *backgroundDYTauTau = ((TTree*)fBackgroundDYTauTau->Get(tree))->CopyTree("isTauLegMatched>0.5");
TTree *backgroundDYMuMu = ((TTree*)fBackgroundDYMuMu->Get(tree))->CopyTree("isTauLegMatched<0.5");
cout <<backgroundDYTauTau->GetEntries() << " -- " << backgroundDYMuMu->GetEntries() << endl;
//TTree *backgroundWJets = (TTree*)fBackgroundWJets->Get(tree);
TTree *backgroundEWK = (TTree*)fBackgroundEWK->Get(tree);
TTree *backgroundQCD = (TTree*)fBackgroundQCD->Get(tree);
//TTree *backgroundTTbar = (TTree*)fBackgroundTTbar->Get(tree);
TTree *backgroundTop = (TTree*)fBackgroundTop->Get(tree);
//TTree *backgroundSingleTop = (TTree*)fBackgroundSingleTop->Get(tree);
//TTree *backgroundDiBoson = (TTree*)fBackgroundDiBoson->Get(tree);
// here I define the map between a sample name and its tree
std::map<std::string,TTree*> tMap;
tMap["Data"]=data;
tMap["ggH115"]=signalGGH;
tMap["qqH115"]=signalVBF;
tMap["Ztautau"]=backgroundDYTauTau;
tMap["ZfakeTau"]=backgroundDYMuMu;
//tMap["Wjets"]=backgroundWJets;
tMap["EWK"]=backgroundEWK;
tMap["QCD"]=backgroundQCD;
//tMap["TTbar"]=backgroundTTbar;
tMap["Top"]=backgroundTop;
//tMap["SingleTop"]=backgroundSingleTop;
//tMap["DiBoson"]=backgroundDiBoson;
std::map<std::string,TTree*>::iterator jt;
// here I choose the order in the stack
std::vector<string> samples;
samples.push_back("ggH115");
samples.push_back("qqH115");
//samples.push_back("DiBoson");
samples.push_back("Top");
//samples.push_back("SingleTop");
//samples.push_back("TTbar");
//samples.push_back("Wjets");
samples.push_back("EWK");
samples.push_back("QCD");
samples.push_back("ZfakeTau");
samples.push_back("Ztautau");
samples.push_back("Data");
float kFactorQCD=1.0;
std::map<std::string,float> crossSec;
crossSec["ggH115"]=( 7.65e-02 * 18.13 * scaleGGH);
crossSec["qqH115"]=( 0.1012);
//crossSec["DiBoson"]=( -1 );
//crossSec["TTbar"]=( 157.5 );
//crossSec["SingleTop"]=( -1 );
//crossSec["Wjets"]=( 31314.0);
crossSec["EWK"]= (-1);
crossSec["Top"]= (-1);
crossSec["ZfakeTau"]=( 3048 );
crossSec["Ztautau"]=( 3048 );
crossSec["QCD"]=( 296600000*0.0002855 * kFactorQCD); //K-factor from fit in signal region 1.7
crossSec["Data"]=( 0 );
float Lumi = 191.;
// here I choose the order in the stack
std::vector<string> filters;
filters.push_back("total");
filters.push_back("vertex");
filters.push_back("at least 1 mu-tau");
filters.push_back("mu pt-eta");
filters.push_back("mu-ID");
filters.push_back("tau pt-eta");
filters.push_back("tau-ID");
filters.push_back("tau against-mu");
filters.push_back("tau against-e");
filters.push_back("tau-iso");
filters.push_back("mu-iso");
filters.push_back("di-mu veto");
filters.push_back("Mt");
filters.push_back("OS");
filters.push_back("2-jets");
filters.push_back("2-tag jets");
filters.push_back("VBF cuts");
filters.push_back("jet-veto");
filters.push_back("Mass Window");
//filters.push_back("Mass Window");
//filters.push_back("HLT-matching");
// here I define the map between a sample name and its file ptr
std::map<std::string,TFile*> fullMap;
fullMap["Data"] = fFullData;
fullMap["ggH115"] = fFullSignalGGH;
fullMap["qqH115"] = fFullSignalVBF;
fullMap["Ztautau"] = fFullBackgroundDYTauTau;
fullMap["ZfakeTau"] = fFullBackgroundDYMuMu;
//fullMap["Wjets"] = fFullBackgroundWJets;
fullMap["EWK"] = fFullBackgroundEWK;
fullMap["QCD"] = fFullBackgroundQCD;
//fullMap["TTbar"] = fFullBackgroundTTbar;
fullMap["Top"] = fFullBackgroundTop;
//fullMap["SingleTop"]= fFullBackgroundSingleTop;
//fullMap["DiBoson"] = fFullBackgroundDiBoson;
std::map<std::string,TFile*>::iterator it;
std::map<std::string,float> cutMap_allEventsFilter;
std::map<std::string,float> cutMap_allEventsFilterE;
std::map<std::string,float> cutMap_vertexScrapingFilter;
std::map<std::string,float> cutMap_vertexScrapingFilterE;
std::map<std::string,float> cutMap_atLeastOneMuTauFilter;
std::map<std::string,float> cutMap_atLeastOneMuTauFilterE;
std::map<std::string,float> cutMap_muPtEtaFilter;
std::map<std::string,float> cutMap_muPtEtaFilterE;
std::map<std::string,float> cutMap_muPtEtaIDFilter;
std::map<std::string,float> cutMap_muPtEtaIDFilterE;
std::map<std::string,float> cutMap_tauPtEtaFilter;
std::map<std::string,float> cutMap_tauPtEtaFilterE;
std::map<std::string,float> cutMap_tauPtEtaIDFilter;
std::map<std::string,float> cutMap_tauPtEtaIDFilterE;
std::map<std::string,float> cutMap_tauPtEtaIDAgMuFilter;
std::map<std::string,float> cutMap_tauPtEtaIDAgMuFilterE;
std::map<std::string,float> cutMap_tauPtEtaIDAgMuAgElecFilter;
std::map<std::string,float> cutMap_tauPtEtaIDAgMuAgElecFilterE;
std::map<std::string,float> cutMap_TauIso;
std::map<std::string,float> cutMap_TauIsoE;
std::map<std::string,float> cutMap_MuIso;
std::map<std::string,float> cutMap_MuIsoE;
std::map<std::string,float> cutMap_DiMuVeto;
std::map<std::string,float> cutMap_DiMuVetoE;
std::map<std::string,float> cutMap_Mt;
std::map<std::string,float> cutMap_MtE;
std::map<std::string,float> cutMap_OS;
std::map<std::string,float> cutMap_OSE;
std::map<std::string,float> cutMap_2jets;
std::map<std::string,float> cutMap_2jetsE;
std::map<std::string,float> cutMap_VBFPre;
std::map<std::string,float> cutMap_VBFPreE;
std::map<std::string,float> cutMap_VBF;
std::map<std::string,float> cutMap_VBFE;
std::map<std::string,float> cutMap_JetVeto;
std::map<std::string,float> cutMap_JetVetoE;
std::map<std::string,float> cutMap_antiBtag;
std::map<std::string,float> cutMap_antiBtagE;
std::map<std::string,float> cutMap_MassWindow;
std::map<std::string,float> cutMap_MassWindowE;
std::map<std::string,float> cutMap_HLT;
std::map<std::string,float> cutMap_HLTE;
std::vector< std::map<std::string,float> > allFilters;
allFilters.push_back(cutMap_allEventsFilter);
allFilters.push_back(cutMap_vertexScrapingFilter);
allFilters.push_back(cutMap_atLeastOneMuTauFilter);
allFilters.push_back(cutMap_muPtEtaFilter);
allFilters.push_back(cutMap_muPtEtaIDFilter);
allFilters.push_back(cutMap_tauPtEtaFilter);
allFilters.push_back(cutMap_tauPtEtaIDFilter);
allFilters.push_back(cutMap_tauPtEtaIDAgMuFilter);
allFilters.push_back(cutMap_tauPtEtaIDAgMuAgElecFilter);
std::vector< std::map<std::string,float> > allFiltersE;
allFiltersE.push_back(cutMap_allEventsFilterE);
allFiltersE.push_back(cutMap_vertexScrapingFilterE);
allFiltersE.push_back(cutMap_atLeastOneMuTauFilterE);
allFiltersE.push_back(cutMap_muPtEtaFilterE);
allFiltersE.push_back(cutMap_muPtEtaIDFilterE);
allFiltersE.push_back(cutMap_tauPtEtaFilterE);
allFiltersE.push_back(cutMap_tauPtEtaIDFilterE);
allFiltersE.push_back(cutMap_tauPtEtaIDAgMuFilterE);
allFiltersE.push_back(cutMap_tauPtEtaIDAgMuAgElecFilterE);
std::vector< std::map<std::string,float> > offlineFilters;
offlineFilters.push_back(cutMap_TauIso);
offlineFilters.push_back(cutMap_MuIso);
offlineFilters.push_back(cutMap_DiMuVeto);
offlineFilters.push_back(cutMap_Mt);
offlineFilters.push_back(cutMap_OS);
offlineFilters.push_back(cutMap_2jets);
offlineFilters.push_back(cutMap_VBFPre);
offlineFilters.push_back(cutMap_VBF);
offlineFilters.push_back(cutMap_JetVeto);
offlineFilters.push_back(cutMap_MassWindow);
//offlineFilters.push_back(cutMap_HLT);
std::vector< std::map<std::string,float> > offlineFiltersE;
offlineFiltersE.push_back(cutMap_TauIsoE);
offlineFiltersE.push_back(cutMap_MuIsoE);
offlineFiltersE.push_back(cutMap_DiMuVetoE);
offlineFiltersE.push_back(cutMap_MtE);
offlineFiltersE.push_back(cutMap_OSE);
offlineFiltersE.push_back(cutMap_2jetsE);
offlineFiltersE.push_back(cutMap_VBFPreE);
offlineFiltersE.push_back(cutMap_VBFE);
offlineFiltersE.push_back(cutMap_JetVetoE);
offlineFiltersE.push_back(cutMap_MassWindowE);
//offlineFiltersE.push_back(cutMap_HLTE);
std::vector< string > offlineCuts;
offlineCuts.push_back("combIsoLeg2<2");
offlineCuts.push_back("combRelIsoLeg1DBeta<0.10");
offlineCuts.push_back("muFlag==0");
offlineCuts.push_back("(pZeta-1.5*pZetaVis>-20)");
offlineCuts.push_back("diTauCharge==0");
offlineCuts.push_back("pt1>30 && pt2>30");
offlineCuts.push_back("eta1*eta2<0");
offlineCuts.push_back("Deta>3.5 && Mjj>350");
offlineCuts.push_back("ptVeto<30");
offlineCuts.push_back("diTauSVFitMass>85 && diTauSVFitMass<145");
std::vector< string > filtersByName;
filtersByName.push_back("allEventsFilter");
filtersByName.push_back("vertexScrapingFilter");
filtersByName.push_back("atLeastOneMuTauFilter");
filtersByName.push_back("muPtEtaFilter");
filtersByName.push_back("muPtEtaIDFilter");
filtersByName.push_back("tauPtEtaFilter");
filtersByName.push_back("tauPtEtaIDFilter");
filtersByName.push_back("tauPtEtaIDAgMuFilter");
filtersByName.push_back("tauPtEtaIDAgMuAgElecFilter");
for(unsigned int k = 0 ; k <filtersByName.size() ; k++){
for(it = fullMap.begin(); it != fullMap.end(); it++){
TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents");
float totalEvents = allEvents->GetBinContent(1);
allEvents = (TH1F*)(it->second)->Get( (filtersByName[k]+"/totalEvents").c_str() );
float tot = allEvents->GetBinContent(1);
float totalEquivalentEvents = allEvents->GetEffectiveEntries();
if(crossSec[it->first]>0){
tot *= (Lumi/ (totalEvents/crossSec[it->first]) * hltEff_ ) ;
} else if (crossSec[it->first]<0) tot *= Lumi/1000*hltEff_;
(allFilters[k])[it->first] = tot;
(allFiltersE[k])[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0;
}
}
for(unsigned int k =0; k < offlineFilters.size(); k++){
for(jt = tMap.begin(); jt != tMap.end(); jt++){
cout<<jt->first<<endl;
TH1F* h1 = new TH1F("h1","",1,-10,10);
string tmp_cut = "tightestHPSWP>-1";
for(unsigned v = 0; v <=k ; v++){
tmp_cut = tmp_cut + " && "+offlineCuts[v];
}
if((jt->first).find("Data")!=string::npos && applyHLTData_) tmp_cut = tmp_cut+" && ((HLTmu==1 && run<=163261) || (HLTx==1 && run\
>163261))";
if((jt->first).find("Data")==string::npos && applyHLTMC_) tmp_cut = tmp_cut+" && HLTmu==1";
tmp_cut = "sampleWeight*puWeight*("+tmp_cut+")";
cout << tmp_cut << endl;
TCut cut(tmp_cut.c_str());
jt->second->Draw("etaL1>>h1",cut);
if((jt->first).find("Data")==string::npos) h1->Scale(Lumi/1000*hltEff_);
if((jt->first).find("QCD")!=string::npos) h1->Scale(kFactorQCD);
float tot = h1->Integral();
cout << tot << endl;
float totalEquivalentEvents = h1->GetEffectiveEntries();
(offlineFilters[k])[jt->first] = tot;
(offlineFiltersE[k])[jt->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0;
delete h1;
}
}
for(unsigned k = 0; k<offlineFilters.size() ; k++) allFilters.push_back(offlineFilters[k]);
for(unsigned k = 0; k<offlineFilters.size() ; k++) allFiltersE.push_back(offlineFiltersE[k]);
std::vector<std::pair<float,float> > SMsums;
for(unsigned int i = 0; i < allFilters.size(); i++){
float SM=0,SME2=0;
int helper = 0;
for(int k = 0 ; k < samples.size()-1; k++){
if( !(samples[k].find("Z")!=string::npos && i<9 && helper!=0) )
SM+=(allFilters[i].find(samples[k]))->second;
if( !(samples[k].find("Z")!=string::npos && i<9 && helper!=0) )
SME2+=(allFiltersE[i].find(samples[k]))->second*(allFiltersE[i].find(samples[k]))->second;
if( samples[k].find("Z")!=string::npos ) helper++;
}
SMsums.push_back( make_pair(SM,SME2 ));
}
//out<<"\\begin{center}"<<endl;
out<<"\\begin{tabular}[!htbp]{|c";
for(int k = 0 ; k < samples.size(); k++) out<<"|c";
out<<"|c|} \\hline"<<endl;
out<< "Cut & ";
for(int k = 0 ; k < samples.size(); k++){
out << (fullMap.find(samples[k]))->first;
if(k!=samples.size()-1) out <<" & " ;
else out << " & $\\Sigma$ SM \\\\ " << endl;
}
out << " \\hline" << endl;
for(int i = 0; i < allFilters.size(); i++){
out << filters[i] << " & ";
for(int k = 0 ; k < samples.size(); k++){
if(samples[k].find("Data")==string::npos)
out << (allFilters[i].find(samples[k]))->second << " $\\pm$ " << (allFiltersE[i].find(samples[k]))->second;
else
out << (allFilters[i].find(samples[k]))->second;
if(k!=samples.size()-1) out <<" & " ;
else out << " & " << SMsums[i].first << "$\\pm$" << sqrt(SMsums[i].second) << " \\\\ " << endl;
}
out << " \\hline" << endl;
}
out<<"\\end{tabular}"<<endl;
//out<<"\\end{center}"<<endl;
///////////////////////////////////////////////////////////////////////////////////////////////
TCanvas *c1 = new TCanvas("c1CutFlowMass","",5,30,650,600);
c1->SetGrid(0,0);
c1->SetFillStyle(4000);
c1->SetFillColor(10);
c1->SetTicky();
c1->SetObjectStat(0);
c1->SetLogy(1);
TLegend* leg = new TLegend(0.55,0.55,0.80,0.88,NULL,"brNDC");
leg->SetFillStyle(0);
leg->SetBorderSize(0);
leg->SetFillColor(10);
leg->SetTextSize(0.04);
leg->SetHeader( "#mu+#tau" );
THStack* aStack = new THStack("aStack",Form("CMS Preliminary 2011 #sqrt{s}=7 TeV L=%.0f pb^{-1}",Lumi));
std::vector<TH1F*> histos;
for(unsigned int k = 0 ; k < samples.size(); k++){
TH1F* h1 = new TH1F( ("h1_"+samples[k]).c_str(), Form("CMS Preliminary 2011 #sqrt{s}=7 TeV L=%.0f pb^{-1} ; ; Events",Lumi) , filters.size(), 0, filters.size());
if( (samples[k]).find("ZfakeTau")!=string::npos ) {
h1->SetFillColor(7);
leg->AddEntry(h1,"Z+jets, fake-#tau","F");
}
if( (samples[k]).find("Ztautau")!=string::npos ) {
h1->SetFillColor(kRed);
leg->AddEntry(h1,"Z+jets, genuine #tau","F");
}
if( (samples[k]).find("TTbar")!=string::npos ) {
h1->SetFillColor(kBlue);
leg->AddEntry(h1,"t#bar{t}+jets","F");
}
if( (samples[k]).find("SingleTop")!=string::npos ) {
h1->SetFillColor(kMagenta);
leg->AddEntry(h1,"single-t","F");
}
if( (samples[k]).find("Top")!=string::npos ) {
h1->SetFillColor(kMagenta);
leg->AddEntry(h1,"Top","F");
}
if( (samples[k]).find("Wjets")!=string::npos ) {
h1->SetFillColor(kGreen);
leg->AddEntry(h1,"W+jets","F");
}
if( (samples[k]).find("EWK")!=string::npos ) {
h1->SetFillColor(kGreen);
leg->AddEntry(h1,"W+Others","F");
}
if( (samples[k]).find("DiBoson")!=string::npos ) {
h1->SetFillColor(38);
leg->AddEntry(h1,"Di-Boson","F");
}
if( (samples[k]).find("QCD")!=string::npos ) {
h1->SetFillColor(42);
leg->AddEntry(h1,"QCD-multijets","F");
}
if((samples[k]).find("qqH115")!=string::npos){
h1->SetLineWidth(2);
h1->SetLineColor(kBlack);
h1->SetFillColor(kBlack);
h1->SetFillStyle(3004);
leg->AddEntry(h1,"qqH(115)","F");
}
if((samples[k]).find("ggH115")!=string::npos){
h1->SetLineWidth(2);
h1->SetLineColor(kBlack);
h1->SetFillColor(kBlack);
h1->SetFillStyle(3005);
leg->AddEntry(h1,"ggH(115)","F");
}
//h1->SetLineWidth(1.4);
for(int v = 0; v < filters.size(); v++){
h1->GetXaxis()->SetBinLabel(v+1,filters[v].c_str());
h1->SetBinContent(v+1, (allFilters[v].find(samples[k]))->second );
}
if(samples[k].find("Data")!=string::npos){
h1->Sumw2();
h1->SetMarkerStyle(20);
h1->SetMarkerSize(1.2);
h1->SetMarkerColor(kBlack);
h1->SetLineColor(kBlack);
leg->AddEntry(h1,"DATA","P");
}
//else leg->AddEntry(h1,samples[k].c_str(),"L");
histos.push_back(h1);
}
for(unsigned int k = 0 ; k < histos.size(); k++){
string histoName = std::string( histos[k]->GetName() );
if( histoName.find("Data")== string::npos) aStack->Add(histos[k]);
}
aStack->Draw("HIST");
TH1F* hStack = (TH1F*)aStack->GetHistogram();
aStack->GetYaxis()->SetRangeUser(0.01,10000000);
for(unsigned int k = 0 ; k < histos.size(); k++){
string histoName = std::string( histos[k]->GetName() );
if( histoName.find("Data")!= string::npos){
histos[k]->Sumw2();
histos[k]->Draw("PSAME");
}
}
leg->Draw();
return;
}
//___________________________________________________________________________
Double_t* Ifit(int shift, Double_t& dataResult, Double_t& dataErr, std::string dataFile,
TH1D* hsig, TH1D* hbkg, TH1D* hEGdata, Double_t* FitPar,
int ptbin=30, char EBEE[10]="EB", int fit_data=2)
{
printf(" *** calling Ifit for %s , ptbin %d *** \n\n", EBEE,ptbin);
cout << "The number of bins are: " << endl;
cout << "hdata nbins = " << hEGdata->GetNbinsX() << endl;
cout << "hsig nbins = " << hsig->GetNbinsX() << endl;
cout << "hbkg nbins = " << hbkg->GetNbinsX() << endl;
TCanvas *c1 = new TCanvas("HF1", "Histos1", 0, 0, 600, 600);
gStyle->SetOptFit(0);
if(fit_data != 3) dataColl.clear();
sigColl.clear();
bkgColl.clear();
totalColl.clear();
ctauColl.clear();
Para.clear();
Para_err.clear();
info.clear();
info_err.clear();
float ptmax=0.;
if(ptbin== 21) ptmax= 23;
if(ptbin== 23) ptmax= 26;
if(ptbin== 26) ptmax= 30;
if(ptbin== 30) ptmax= 35;
if(ptbin== 35) ptmax= 40;
if(ptbin== 40) ptmax= 45;
if(ptbin== 45) ptmax= 50;
if(ptbin== 50) ptmax= 60;
if(ptbin== 60) ptmax= 85;
if(ptbin== 85) ptmax= 120;
if(ptbin== 120) ptmax= 300;
if(ptbin== 300) ptmax= 500;
Double_t* fitted = new Double_t[6];
fitted[0] = 0.; fitted[1] = 0.; fitted[2] = 0.; fitted[3] = 0.;
fitted[4] = 0.; fitted[5] = 0.;
char hname[30];
hsig->SetLineColor(1);
hbkg->SetLineColor(1);
hsig->SetNdivisions(505,"XY");
hbkg->SetNdivisions(505,"XY");
hsig->SetTitle("");
hbkg->SetTitle("");
hsig->SetXTitle("combined ISO (GeV)");
hbkg->SetXTitle("combined ISO (GeV)");
TH1F *hsum = (TH1F*)hsig->Clone();
hsum->Add(hbkg,1);
float ntemplate = 1.;
if (hsum->Integral()>1.) ntemplate = hsum->Integral();
float sigfrac = hsig->Integral()/ntemplate*0.8;
TH1F *hsum_norm = (TH1F*)hsum->Clone();
hsum_norm->Scale(1./hsum->Integral());
TH1F *hdata = new TH1F();
int ndata=0;
if ( fit_data==1 ) {
hdata = (TH1F*)hEGdata->Clone();
ndata = (int)hdata->Integral();
for(int ibin=1; ibin<=hdata->GetNbinsX(); ibin++){
for(int ipoint=0; ipoint<hdata->GetBinContent(ibin); ipoint++) {
dataColl.push_back(hdata->GetBinCenter(ibin));
}
}
ndata = dataColl.size();
}else if (fit_data==2 ){
hdata = (TH1F*)hEGdata->Clone();
hdata -> Reset();
dataColl.clear();
FILE *infile = fopen(dataFile.data(),"r");
float xdata, xdata1, xdata2; // combined isolation, pt, eta
int flag = 1;
while (flag!=-1){
flag =fscanf(infile,"%f %f %f",&xdata, &xdata1, &xdata2);
if( xdata1 >= ptbin && xdata1 < ptmax && xdata<20.) {
if((strcmp(EBEE,"EB")==0 && TMath::Abs(xdata2)<1.45) ||
(strcmp(EBEE,"EE")==0 && TMath::Abs(xdata2)<2.5 && TMath::Abs(xdata2)>1.7) ) {
dataColl.push_back(xdata);
hdata->Fill(xdata);
}
}
}// keep reading files as long as text exists
ndata = dataColl.size();
printf("test print data 2 %2.3f \n", dataColl[2]);
// cout << "ndata in dataColl = " << ndata << endl;
if ( ndata == 0 ) {
printf(" no data to fit \n");
return fitted;
}
}
if(ndata==0) {
printf(" --- no events in the fit \n");
return fitted;
}
//test fit the template and get PDFs
TCanvas *c10 = new TCanvas("c10","c10",1000,500);
c10->Divide(2,1);
c10->cd(1);
double par[20] = {hsig->GetMaximum(), 1., 0.6, 0.3,
hbkg->GetMaximum(), -.45, -0.05, 0.03, 1., 1., 1., 1.};
if(strcmp(EBEE,"EE")==0) { par[2]=-0.1, par[3]=0.2; par[6]=-0.15; par[7]=0.02; };
int fit_status;
TF1 *f1 = new TF1("f1", exp_conv, -1., 20., 11);
TF1 *fmcsigfit = new TF1("fmcsigfit", exp_conv, -1., 20., 11);
fmcsigfit->SetLineColor(4);
fmcsigfit->SetLineWidth(2);
f1->SetNpx(10000);
f1->SetParameters(par);
f1->SetLineWidth(2);
c10->cd(1);
fit_status = hsig->Fit(f1,"","",-1., 5.);
hsig->Draw();
f1->Draw("same");
if ( fit_status > 0 ) {
printf("fit signal template failed. QUIT \n");
return fitted;
}
if(para_index>0 && para_index<4){
double tmppar = f1->GetParameter(para_index);
f1->SetParameter(para_index, tmppar+para_sigma*f1->GetParError(para_index));
}
TF1 *fmcsig = (TF1*)f1->Clone();
TF1 *fmcsigcorr = (TF1*)f1->Clone();
fmcsig->SetNpx(10000);
fmcsigcorr->SetNpx(10000);
fmcsigfit->SetNpx(10000);
TCanvas *c101 = new TCanvas("c101","c101",1000,500);
c101->Divide(2,1);
c101->cd(1);
fmcsig->SetLineColor(1);
// fmcsig->Draw();
// f1->Draw("same");
TH1F *htmp1 = (TH1F*)fmcsig->GetHistogram();
// TH1F *htmp2 = (TH1F*)fmcsigcorr->GetHistogram();
TH2F *htmp2 = new TH2F("htmp2","",210, -1., 20., 100, 0., htmp1->GetMaximum()*1.25);
htmp2->SetNdivisions(505,"XY");
htmp2->SetXTitle("Iso");
htmp2->SetYTitle("A.U.");
htmp2->SetLineColor(1);
// htmp2->Draw();
// htmp1->Draw("same");
// htmp2->Add(htmp1,-1);
// htmp2->Divide(htmp1);
htmp2->GetXaxis()->SetRangeUser(-1., 10.);
htmp2->SetMinimum(-1.);
//htmp2->SetMaximum(1.5);
htmp2->Draw();
fmcsig->Draw("same");
// fmcsigcorr->Draw("same");
TLegend *tleg1 = new TLegend(0.5, 0.7, 0.93, 0.92);
tleg1->SetHeader("");
tleg1->SetFillColor(0);
tleg1->SetShadowColor(0);
tleg1->SetBorderSize(0);
tleg1->AddEntry(fmcsig,"Zee data","l");
//tleg1->AddEntry(fmcsigcorr,"corrected shape","l");
tleg1->AddEntry(fmcsigfit,"shape from data","l");
tleg1->Draw();
//return fitted;
SigPDFnorm = f1->Integral(-1.,20.);
printf("status %d, sig area %3.3f \n", fit_status,f1->Integral(-1., 20.));
f1->SetParameter(2,f1->GetParameter(2)+0.2);
f1->SetParameter(3,f1->GetParameter(3)+0.1);
Para.push_back(f1->GetParameter(0));
Para.push_back(f1->GetParameter(1));
Para.push_back(f1->GetParameter(2));
Para.push_back(f1->GetParameter(3));
Para_err.push_back(f1->GetParError(0));
Para_err.push_back(f1->GetParError(1));
Para_err.push_back(f1->GetParError(2));
Para_err.push_back(f1->GetParError(3));
c10->cd(2);
TF1 *fbkgfit = new TF1("fbkgfit", expinv_power, -1., 20., 11);
TF1 *f3 = new TF1("f3", expinv_power, -1., 20., 11);
fbkgfit->SetNpx(10000);
fbkgfit->SetLineColor(4);
fbkgfit->SetLineWidth(2);
f3->SetNpx(10000);
f3->SetLineWidth(2);
f3->SetParameters(f1->GetParameters());
f3->SetParLimits(5,-5.,0.);
f3->SetParLimits(6,-0.5,0.);
f3->SetParLimits(7,0.001,0.2);
f3->SetParLimits(8,0.5,5.);
if ( strcmp(EBEE,"EB")==0 ){
// f3->FixParameter(8,1.);
// f3->FixParameter(6,-0.1);
f3->SetParLimits(8,1.,1.5);
}
float bkg_bend_power = 1.;
if ( ptbin==21 ) bkg_bend_power = 4.5;
if ( ptbin==23 ) bkg_bend_power = 4.;
if ( ptbin==26 ) bkg_bend_power = 3.5;
if ( ptbin==30 ) bkg_bend_power = 2.6;
if ( ptbin==35 ) bkg_bend_power = 2.2;
if ( ptbin==40 ) bkg_bend_power = 2.;
if ( ptbin==45 ) bkg_bend_power = 2.;
if ( ptbin==50 ) bkg_bend_power = 1.8;
if ( ptbin==60 ) bkg_bend_power = 1.5;
if ( ptbin==85 ) bkg_bend_power = 1.;
if ( ptbin==120 ) bkg_bend_power = 1.;
if ( strcmp(EBEE,"EE")==0 ){
f3->SetParameter(8,bkg_bend_power);
f3->SetParLimits(8,bkg_bend_power-1., bkg_bend_power+1.);
}
f3->FixParameter(0,f3->GetParameter(0));
f3->FixParameter(1,f3->GetParameter(1));
f3->FixParameter(2,f3->GetParameter(2));
f3->FixParameter(3,f3->GetParameter(3));
hbkg->SetMaximum(hbkg->GetMaximum()*3.);
fit_status = hbkg->Fit(f3,"b","",-1., 20.);
hbkg->Draw();
if ( fit_status > 0 ) {
printf("fit background template failed. QUIT \n");
return fitted;
}else {
f3->Draw("same");
}
TF1 *fmcbkg = (TF1*)f3->Clone();
fmcbkg->SetLineColor(1);
c101->cd(2);
htmp1 = (TH1F*)fmcbkg->GetHistogram();
htmp2 = new TH2F("htmp2","",210, -1., 20., 100, 0., htmp1->GetMaximum()*1.25);
htmp2->SetNdivisions(505,"XY");
htmp2->SetXTitle("Iso");
htmp2->SetYTitle("A.U.");
htmp2->SetLineColor(1);
htmp2->GetXaxis()->SetRangeUser(-1., 20.);
htmp2->SetMinimum(-1.);
htmp2->SetMaximum(1.5);
htmp2->Draw();
fmcbkg->Draw("same");
TLegend *tleg2 = new TLegend(0.25, 0.2, 0.6, 0.42);
tleg2->SetHeader("");
tleg2->SetFillColor(0);
tleg2->SetShadowColor(0);
tleg2->SetBorderSize(0);
if ( strcmp(EBEE,"EB")==0 ){
tleg2->AddEntry(fmcbkg,"MC shape","l");
}else {
tleg2->AddEntry(fmcbkg,"Data SB shape","l");
}
tleg2->AddEntry(fbkgfit,"shape from data","l");
tleg2->Draw();
if(para_index>4){
double tmppar = f3->GetParameter(para_index);
f3->SetParameter(para_index, tmppar+para_sigma*f3->GetParError(para_index));
}
// f3->SetParameter(5,-0.5);
// f3->SetParameter(6,-0.05);
// f3->SetParameter(7,0.02);
// f3->SetParameter(8,1.);
Para.push_back(f3->GetParameter(4));
Para.push_back(f3->GetParameter(5));
Para.push_back(f3->GetParameter(6));
Para.push_back(f3->GetParameter(7));
Para.push_back(f3->GetParameter(8));
Para_err.push_back(f3->GetParError(4));
Para_err.push_back(f3->GetParError(5));
Para_err.push_back(f3->GetParError(6));
Para_err.push_back(f3->GetParError(7));
Para_err.push_back(f3->GetParError(8));
BkgPDFnorm = f3->Integral(-1., 20.);
printf("status %d, bkg area %3.3f \n", fit_status,f3->Integral(-1., 20.)/hdata->GetBinWidth(2));
//test PDFs
TCanvas *c11 = new TCanvas("c11","c11",1000,500);
c11->Divide(2,1);
c11->cd(1);
TF1 *f11 = new TF1("f11",exp_conv_norm, -1., 20., 11);
f11->SetNpx(10000);
f11->SetParameters(f3->GetParameters());
f11->Draw();
printf(" SIG PDF area %2.3f \n", f11->Integral(-1., 20.));
c11->cd(2);
TF1 *f12 = new TF1("f12",expinv_power_norm, -1., 20., 11);
f12->SetNpx(10000);
f12->SetParameters(f3->GetParameters());
f12->Draw();
printf(" BKG PDF area %2.3f \n", f12->Integral(-1., 20.));
//c1->cd();
printf(" --------- before the fit ------------- \n");
printf("Nsig %2.3f, Nbg %2.3f, Ntemplate %3.3f \n", hsig->Integral(), hbkg->Integral(), ntemplate);
printf("Purity %2.3f, init size %4.3f, fit sample size %4d\n", hsig->Integral()/hsum->Integral(), hsum->Integral(), ndata);
printf(" -------------------------------------- \n");
printf( " ----- Got %d, %d, %d events for fit ----- \n ", dataColl.size(),
sigColl.size(), bkgColl.size() );
//--------------------------------------------------
//init parameters for fit
Double_t vstart[11] = {1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.};
vstart[0] = sigfrac*ndata;
vstart[1] = (1-sigfrac)*ndata;
for (int ii=0; ii<9; ii++) {
vstart[ii+2] = Para[ii]; //8 shape parameters
}
TMinuit *gMinuit = new TMinuit(NPAR);
gMinuit->Command("SET STR 1");
gMinuit->SetFCN(fcn);
Double_t arglist[11];
Int_t ierflg = 0;
arglist[0] = 1;
gMinuit->mnexcm("SET ERR", arglist ,1,ierflg);
arglist[0] = 1;
gMinuit->mnexcm("SET PRINT", arglist ,1,ierflg);
Double_t step[] = { 1.,1.,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,};
for ( int ii=0; ii<9; ii++){
printf(" para %d, %.5f, err %.5f \n", ii, Para[ii], Para_err[ii]);
}
float sigma = 3.;
gMinuit->mnparm(0, "Signal yield" , vstart[0], step[0], 0., ndata*2. , ierflg);
gMinuit->mnparm(1, "background yield" , vstart[1], step[1], 0., ndata*2. , ierflg);
// gMinuit->mnparm(2, "constant" , Para[0], 0.00, Para[0], Para[0] , ierflg);
// gMinuit->mnparm(3, "exp tail" , Para[1], 0.01, Para[1]-sigma*Para_err[1], Para[1]+sigma*Para_err[1], ierflg);
// gMinuit->mnparm(4, "exg mean" , Para[2], 0.01, Para[2]-sigma*Para_err[2], Para[2]+sigma*Para_err[2], ierflg);
// gMinuit->mnparm(5, "exg width" , Para[3], 0.01, Para[3]-sigma*Para_err[3], Para[3]+sigma*Para_err[3], ierflg);
// gMinuit->mnparm(6, "constant" , Para[4], 0.00, Para[4] , Para[4] , ierflg);
// gMinuit->mnparm(7, "bg exp turnon", Para[5], 0.01, Para[5]-sigma*Para_err[5], Para[5]+sigma*Para_err[5], ierflg);
// gMinuit->mnparm(8, "bg x offset ", Para[6], 0.01, Para[6]-sigma*Para_err[6], Para[6]+sigma*Para_err[6], ierflg);
// gMinuit->mnparm(9, "bg bend slope", Para[7], 0.01, 0.001 , 0.1 , ierflg);
// // gMinuit->mnparm(10, "bg bend power", Para[8], 0.01, Para[8]-sigma*Para_err[8], Para[8]+sigma*Para_err[8], ierflg);
// gMinuit->mnparm(10, "bg bend power", Para[8], 0.01, 0.5 , 5. , ierflg);
// gMinuit->mnparm(2, "constant" , Para[0], TMath::Abs(Para[0]*0.0) , Para[0], Para[0], ierflg);
// gMinuit->mnparm(3, "exp tail" , Para[1], TMath::Abs(Para[1]*0.01) , Para[1]-sigma*Para_err[1], Para[1]+sigma*Para_err[1], ierflg);
// // gMinuit->mnparm(3, "exp tail" , Para[1], TMath::Abs(Para[1]*0.1) , 0.8 , 1.3 , ierflg);
// gMinuit->mnparm(4, "exg mean" , Para[2], TMath::Abs(Para[2]*0.1) , 0.5 , 1.0 , ierflg);
// gMinuit->mnparm(5, "exg width" , Para[3], TMath::Abs(Para[3]*0.1) , 0.25 , 0.5 , ierflg);
// gMinuit->mnparm(6, "constant" , Para[4], TMath::Abs(Para[4]*0.0) , Para[4], Para[4], ierflg);
// gMinuit->mnparm(7, "bg exp turnon", Para[5], TMath::Abs(Para[5]*0.1) , -0.7 , -0.3 , ierflg);
// gMinuit->mnparm(8, "bg x offset ", Para[6], TMath::Abs(Para[6]*0.0) , -0.15 , -0.05 , ierflg);
// gMinuit->mnparm(9, "bg bend slope", Para[7], TMath::Abs(Para[7]*0.1) , 0.01 , 0.05 , ierflg);
// gMinuit->mnparm(10, "bg bend power", Para[8], TMath::Abs(Para[8]*0.1) , 0.5 , 1.5 , ierflg);
gMinuit->mnparm(2, "constant" , Para[0], 0.00, Para[0], Para[0] , ierflg);
gMinuit->mnparm(3, "exp tail" , Para[1], 0.00, Para[1]-sigma*Para_err[1], Para[1]+sigma*Para_err[1], ierflg);
gMinuit->mnparm(4, "exg mean" , Para[2], 0.00, Para[2]-sigma*Para_err[2], Para[2]+sigma*Para_err[2], ierflg);
gMinuit->mnparm(5, "exg width" , Para[3], 0.00, Para[3]-sigma*Para_err[3], Para[3]+sigma*Para_err[3], ierflg);
gMinuit->mnparm(6, "constant" , Para[4], 0.00, Para[4] , Para[4] , ierflg);
gMinuit->mnparm(7, "bg exp turnon", Para[5], 0.00, Para[5]-sigma*Para_err[5], Para[5]+sigma*Para_err[5], ierflg);
gMinuit->mnparm(8, "bg x offset ", Para[6], 0.00, Para[6]-sigma*Para_err[6], Para[6]+sigma*Para_err[6], ierflg);
gMinuit->mnparm(9, "bg bend slope", Para[7], 0.00, 0.001 , 0.1 , ierflg);
gMinuit->mnparm(10, "bg bend power", Para[8], 0.00, Para[8]-sigma*Para_err[8], Para[8]+sigma*Para_err[8], ierflg);
printf(" --------------------------------------------------------- \n");
printf(" Now ready for minimization step \n --------------------------------------------------------- \n");
arglist[0] = 500; // number of iteration
gMinuit->mnexcm("MIGRAD", arglist,1,ierflg);
//can do scan
// arglist[0] = 0;
// gMinuit->mnexcm("SCAN", arglist,1,ierflg);
printf (" -------------------------------------------- \n");
printf("Finished. ierr = %d \n", ierflg);
double para[NPAR+1],errpara[NPAR+1];
double tmp_errpara[NPAR+1];
for(int j=0; j<=NPAR-1;j++) { tmp_errpara[j]=0.1; }
for(int j=2; j<=NPAR-1;j++) {
if(Para_err[j-2]!=0.) tmp_errpara[j]=TMath::Abs(Para_err[j-2]);
}
int ni=6; if ( strcmp(EBEE,"EE")==0 ) { ni=6; }//if(ptbin==21) ni=0;}
if ( ierflg == 0 ) {
for(int i=0; i<ni; i++) {
float istep[10] = {0.,0.,0.,0.,0.,0.,0.};
if (i<(ni-1)) {
istep[i] = 0.001;
}else {
for (int j=0; j<ni-1; j++) {istep[j] = 0.001;}
}
for(int j=0; j<=NPAR-1;j++) {
gMinuit->GetParameter(j, para[j], errpara[j]);
if (errpara[j] != 0. ) {
tmp_errpara[j] = TMath::Abs(errpara[j]);
}
}
if ( strcmp(EBEE,"EB")==0 ) {
sigma = 10.;
if ( i==(ni-1) ) { sigma=5.;istep[1]=istep[4]=0.; }
if ( ptbin==21 && i==1 ){ sigma=3.; }
if ( ptbin==21 && i==(ni-1) ){ sigma=20.; }
if ( ptbin==23 && i==0 ){ para[7]=-0.5; }
if ( ptbin==23 && i==1 ){ istep[1]=0.; istep[3]=0.01; }
if ( ptbin==23 && i==3 ){ istep[1]=0.01; istep[3]=0.0; }
if ( ptbin==23 && i==(ni-1) ){ sigma=20.; }
if ( ptbin==26 && i==1 ){ sigma=5.; }
if ( ptbin==26 && i==(ni-1) ){ sigma=20.; }
if ( ptbin==30 && i==(ni-1) ){ sigma=3.; }
if ( ptbin==35 && i==(ni-1) ) { sigma=10.; }
if ( ptbin==40 && i==(ni-1) ) { sigma=5.; istep[4]=0.01; }
if ( ptbin==45 && i==(ni-1) ) { sigma=10.; }
if ( ptbin==60 && i==0 ) { para[3]=1.; para[4]=0.6; para[5]=0.32; para[7]=-0.45; para[9]=0.025; para[10] = 1.;}
if ( ptbin==60 && i==(ni-1) ) { sigma=5.; istep[4]=0.01;}
if ( ptbin>=85 && i==(ni-1) ){ sigma=3.; }
if ( ptbin==300 ) { istep[2]=istep[3]=istep[4]=0.; }// para[7] = -5.11907e-02; istep[1]=0.; }
float tmp8=0.;
// if( i!= (ni-1) ) {
gMinuit->mnparm(0, "Signal yield" , para[0], 1., para[0]-100.*tmp_errpara[0], para[0]+100.*tmp_errpara[0], ierflg);
gMinuit->mnparm(1, "background yield", para[1], 1., para[1]-100.*tmp_errpara[1], para[1]+100.*tmp_errpara[1], ierflg);
gMinuit->mnparm(2, "constant" , para[2], 0., para[2]-100.*tmp_errpara[2], para[2]+100.*tmp_errpara[2], ierflg);
gMinuit->mnparm(6, "constant" , para[6], 0., para[6]-100.*tmp_errpara[6], para[6]+100.*tmp_errpara[6], ierflg);
gMinuit->mnparm(3, "exp tail" , para[3], istep[4], para[3]-sigma*tmp_errpara[3], para[3]+sigma*tmp_errpara[3], ierflg);
gMinuit->mnparm(4, "exg mean" , para[4], istep[3], para[4]-sigma*tmp_errpara[4], para[4]+sigma*tmp_errpara[4], ierflg);
gMinuit->mnparm(5, "exg width" , para[5], istep[2], para[5]-sigma*tmp_errpara[5], para[5]+sigma*tmp_errpara[5], ierflg);
gMinuit->mnparm(7, "bg exp turnon", para[7], istep[1], para[7]-sigma*tmp_errpara[7], para[7]+sigma*tmp_errpara[7], ierflg);
gMinuit->mnparm(8, "bg x offset ", para[8], tmp8 , para[8]-sigma*tmp_errpara[8], para[8]+sigma*tmp_errpara[8], ierflg);
gMinuit->mnparm(9, "bg bend slope", para[9], istep[0], para[9]-sigma*tmp_errpara[9], para[9]+sigma*tmp_errpara[9], ierflg);
float sigma10=5.;
if ( para[10]-sigma10*tmp_errpara[10] < 1. )// && i!=(ni-1))
gMinuit->mnparm(10, "bg bend power", para[10], istep[0], 1., para[10]+sigma10*tmp_errpara[10], ierflg);
else
gMinuit->mnparm(10, "bg bend power", para[10], istep[0], para[10]-sigma10*tmp_errpara[10], para[10]+sigma10*tmp_errpara[10], ierflg);
// }else {
// gMinuit->mnparm(2, "constant" , Para[0], TMath::Abs(Para[0]*0.0) , Para[0], Para[0], ierflg);
// //gMinuit->mnparm(3, "exp tail" , Para[1], TMath::Abs(Para[1]*0.01) , Para[1]-sigma*Para_err[1], Para[1]+sigma*Para_err[1], ierflg);
// gMinuit->mnparm(3, "exp tail" , Para[1], TMath::Abs(Para[1]*0.0) , 0.8 , 1.3 , ierflg);
// gMinuit->mnparm(4, "exg mean" , Para[2], TMath::Abs(Para[2]*0.1) , 0.5 , 1.0 , ierflg);
// gMinuit->mnparm(5, "exg width" , Para[3], TMath::Abs(Para[3]*0.1) , 0.25 , 0.5 , ierflg);
// gMinuit->mnparm(6, "constant" , Para[4], TMath::Abs(Para[4]*0.0) , Para[4], Para[4], ierflg);
// gMinuit->mnparm(7, "bg exp turnon", Para[5], TMath::Abs(Para[5]*0.0) , -0.7 , -0.3 , ierflg);
// gMinuit->mnparm(8, "bg x offset ", Para[6], TMath::Abs(Para[6]*0.0) , -0.15 , -0.05 , ierflg);
// gMinuit->mnparm(9, "bg bend slope", Para[7], TMath::Abs(Para[7]*0.1) , 0.01 , 0.05 , ierflg);
// gMinuit->mnparm(10, "bg bend power", Para[8], TMath::Abs(Para[8]*0.1) , 0.5 , 1.5 , ierflg);
// }
if( ptbin >=300 ) {
gMinuit->mnparm(3, "exp tail" , 1.257281, 0.0, para[1]-3.*tmp_errpara[1], para[1]+3.*tmp_errpara[1], ierflg);
gMinuit->mnparm(4, "exg mean" , 0.856906, 0.0, para[2]-3.*tmp_errpara[2], para[2]+3.*tmp_errpara[2], ierflg);
gMinuit->mnparm(5, "exg width" , 0.320847, 0.0, para[3]-3.*tmp_errpara[3], para[3]+3.*tmp_errpara[3], ierflg);
}
}else{
sigma=10.;
if ( i==0 ) { para[10] = bkg_bend_power; tmp_errpara[10] = 0.3; }
if ( i==(ni-1) ) { sigma=3.;istep[1]=istep[4]=0.; } //test of not changing signal template
if ( i==(ni-1) ) { istep[4]=0.;}
if ( ptbin==21 && i==(ni-1) ) { sigma=20.;}
if ( ptbin==23 && i==0 ) { sigma=5.;}
if ( ptbin==23 && i==(ni-1) ) { sigma=10.;}
if ( ptbin<30 && ptbin>21 && i==1 ){ istep[1]=0.; istep[3]=0.01; }
if ( ptbin<30 && ptbin>21 && i==3 ){ istep[1]=0.01; istep[3]=0.0; }
if ( ptbin==26 && i==1 ) { para[7] = -0.8; }
if ( ptbin==26 && i==(ni-1) ) { sigma=10.; }
if ( ptbin==30 && i==(ni-1) ) { sigma=10.; }
if ( ptbin==35) {para[7] = -0.75;}
if ( ptbin==40 && i==0) {para[7] = -0.65; para[10] = 2.;}
if ( ptbin==45 && i==(ni-1) ) {sigma=5.;}
if ( ptbin==85 && i==(ni-1) ) {sigma=10.; istep[4]=0.01;}
if (ptbin >= 85 ) { para[10] = bkg_bend_power; tmp_errpara[10] = 1.; }
if ( ptbin==120 ) { para[7] = -0.615255; istep[1]=0.;}
// if ( ptbin==120 && i==0 ) {
// para[3] = 1.446454; para[4]=-0.016373; para[5]=0.163238;
// istep[2]=istep[3]=istep[4]=0.; sigma=5.; tmp_errpara[10]=0.2;
// }
// if ( ptbin==120 && i==(ni-1) ) { istep[2]=istep[3]=istep[4]=0.; sigma=5.;}
gMinuit->mnparm(0, "Signal yield" , para[0], 1., para[0]-100.*tmp_errpara[0], para[0]+100.*tmp_errpara[0], ierflg);
gMinuit->mnparm(1, "background yield", para[1], 1., para[1]-100.*tmp_errpara[1], para[1]+100.*tmp_errpara[1], ierflg);
gMinuit->mnparm(2, "constant" , para[2], 0., para[2], para[2] , ierflg);
gMinuit->mnparm(6, "constant" , para[6], 0., para[6], para[6], ierflg);
gMinuit->mnparm(3, "exp tail" , para[3], istep[4], para[3]-sigma*tmp_errpara[3], para[3]+sigma*tmp_errpara[3], ierflg);
gMinuit->mnparm(4, "exg mean" , para[4], istep[3], para[4]-sigma*tmp_errpara[4], para[4]+sigma*tmp_errpara[4], ierflg);
gMinuit->mnparm(5, "exg width" , para[5], istep[2], para[5]-sigma*tmp_errpara[5], para[5]+sigma*tmp_errpara[5], ierflg);
gMinuit->mnparm(7, "bg exp turnon", para[7], istep[1], para[7]-sigma*tmp_errpara[7], para[7]+sigma*tmp_errpara[7], ierflg);
gMinuit->mnparm(8, "bg x offset ", para[8], 0.00, para[8]-sigma*tmp_errpara[8], para[8]+sigma*tmp_errpara[8], ierflg);
gMinuit->mnparm(9, "bg bend slope", para[9], istep[0], para[9]-sigma*tmp_errpara[9], para[9]+sigma*tmp_errpara[9], ierflg);
float minerr=1.;
//if ( tmp_errpara[10] > 0.5) tmp_errpara[10] = 0.5;
float sigma10=5.;
if ( para[10]-sigma10*tmp_errpara[10] < 1. )
gMinuit->mnparm(10, "bg bend power", para[10], istep[0], minerr, para[10]+sigma10*tmp_errpara[10], ierflg);
else
gMinuit->mnparm(10, "bg bend power", para[10], istep[0], para[10]-sigma10*tmp_errpara[10], para[10]+sigma10*tmp_errpara[10], ierflg);
}
printf(" ************ \n");
printf(" do %d th fit \n", i);
if(i==5 && dataFile.find("toy") != std::string::npos)
{
cout << "dataResult = " << dataResult << "\t dataErr = " << dataErr << endl;
// fixed turn on at +- 1 sigma
gMinuit->mnparm(7, "bg exp turnon", dataResult-(float)shift*dataErr, 0.00, para[7]-sigma*tmp_errpara[7], para[7]+sigma*tmp_errpara[7], ierflg);
}
else if(dataFile.find("toy") == std::string::npos)
{
dataResult = para[7];
dataErr = tmp_errpara[7];
}
arglist[0] = 500; // number of iteration
gMinuit->mnexcm("MIGRAD", arglist ,1,ierflg);
if ( ierflg != 0 ) {
printf("fit failed at %d iteration \n", i);
c1->cd(); c1->Draw(); hdata->Draw("phe");
return fitted;
}
}
}
Double_t amin,edm,errdef;
if ( ierflg == 0 ) {
for(int j=0; j<=NPAR-1;j++) {
gMinuit->GetParameter(j, para[j],errpara[j]);
info.push_back(para[j]);
info_err.push_back(errpara[j]);
printf("Parameter %d = %f +- %f\n",j,para[j],errpara[j]);
}
para[NPAR] = dataColl.size();
printf(" fitted yield %2.3f \n", (para[0]+para[1])/ndata );
info.push_back(sigColl.size());
for(int j=0; j<=NPAR-1;j++) {
tmp_errpara[j] = errpara[j];
if( tmp_errpara[j] == 0. ) tmp_errpara[j] = par[j]*.1;
}
//do minos if fit sucessed.
}
if (ierflg != 0 ) {
printf(" *********** Fit failed! ************\n");
gMinuit->GetParameter(0, para[0],errpara[0]);
gMinuit->GetParameter(1, para[1],errpara[1]);
para[0]=0.; errpara[0]=0.;
c1->cd();
c1->Draw();
//gPad->SetLogy();
hdata->SetNdivisions(505,"XY");
hdata->SetXTitle("comb. ISO (GeV)");
hdata->SetYTitle("Entries");
hdata->SetTitle("");
hdata->SetMarkerStyle(8);
hdata->SetMinimum(0.);
if ( hdata->GetMaximum()<10.) hdata->SetMaximum(15.);
else hdata->SetMaximum(hdata->GetMaximum()*1.25);
if ( strcmp(EBEE,"EE")==0 &&ptbin == 15 ) hdata->SetMaximum(hdata->GetMaximum()*1.25);
hdata->Draw("phe");
return fitted;
}
// Print results
// Double_t amin,edm,errdef;
Int_t nvpar,nparx,icstat;
gMinuit->mnstat(amin,edm,errdef,nvpar,nparx,icstat);
gMinuit->mnprin(1,amin);
gMinuit->mnmatu(1);
printf(" ========= happy ending !? =========================== \n");
printf("FCN = %3.3f \n", amin);
//use new PDF form
double tmppar[12];
for(int ii=0; ii<9; ii++){
tmppar[ii] = para[ii+2];
fmcsigfit->SetParameter(ii,tmppar[ii]);
fbkgfit->SetParameter(ii,tmppar[ii]);
}
c101->cd(1);
//fmcsigfit->SetParameters(tmppar);
//fmcsigfit->SetParameter(2,0.1);
//fmcsigfit->SetLineStyle(2);
fmcsigfit->Draw("same");
c101->cd(2);
fbkgfit->SetParameter(4,fbkgfit->GetParameter(4)*fmcbkg->Integral(-1., 20.)/fbkgfit->Integral(-1., 20.));
fbkgfit->Draw("same");
char fname[100];
sprintf(fname,"plots/template_Ifit%s_%d.pdf",EBEE,ptbin);
c101->SaveAs(fname);
f11->SetParameters(tmppar);
SigPDFnorm = f11->Integral(-1., 20.);
f12->SetParameters(tmppar);
BkgPDFnorm = f12->Integral(-1., 20.);
// plot
c1->cd();
c1->Draw();
//gPad->SetLogy();
hdata->SetNdivisions(505,"XY");
hdata->SetXTitle("comb. ISO (GeV)");
hdata->SetYTitle("Entries");
hdata->SetTitle("");
hdata->SetMarkerStyle(8);
hdata->SetMinimum(0.);
if ( hdata->GetMaximum()<10.) hdata->SetMaximum(15.);
else hdata->SetMaximum(hdata->GetMaximum()*1.5);
if ( strcmp(EBEE,"EE")==0 &&ptbin == 15 ) hdata->SetMaximum(hdata->GetMaximum()*1.2);
hdata->Draw("p e ");
f11->SetParameter(0, para[0]*f11->GetParameter(0)/f11->Integral(-1., 20.)*hdata->GetBinWidth(2));
// f11->SetFillColor(5);
f11->SetLineColor(4);
//f11->SetFillColor(603);
f11->SetLineWidth(2);
// f11->SetFillStyle(3001);
f11->Draw("same");
f12->SetParameter(4, para[1]*f12->GetParameter(4)/f12->Integral(-1., 20.)*hdata->GetBinWidth(2));
// f12->SetFillColor(8);
f12->SetLineColor(2);
//f12->SetFillColor(603);
f12->SetLineWidth(2);
// f12->SetFillStyle(3013);
f12->Draw("same");
TF1 *f13 = new TF1("f13",sum_norm, -1., 20 ,11);
f13->SetNpx(10000);
f13->SetParameters(f12->GetParameters());
f13->SetParameter(0, para[0]*f11->GetParameter(0)/f11->Integral(-1., 20.)*hdata->GetBinWidth(2));
f13->SetParameter(4, para[1]*f12->GetParameter(4)/f12->Integral(-1., 20.)*hdata->GetBinWidth(2));
f13->SetLineWidth(2);
f13->SetLineColor(1);
f13->Draw("same");
f11->Draw("same");
hdata->Draw("pe same");
// cout << "The number of bins are: " << endl;
// cout << "hdata nbins = " << hdata->GetNbinsX() << endl;
// cout << "hsig nbins = " << hsig->GetNbinsX() << endl;
// cout << "hbkg nbins = " << hbkg->GetNbinsX() << endl;
// get chi2/NDF
double chi2ForThisBin=0;
int nbinForThisBin=0;
chi2Nbins(f13, hdata, chi2ForThisBin, nbinForThisBin);
for(int epar=0; epar < 11; epar++)
{
// cout << "f11 parameter " << epar << " = " <<
// f11->GetParameter(epar) << endl;
FitPar[epar] = f11->GetParameter(epar);
}
for(int epar=0; epar < 11; epar++)
{
// cout << "f12 parameter " << epar << " = " <<
// f12->GetParameter(epar) << endl;
FitPar[epar+11] = f12->GetParameter(epar);
}
for(int epar=0; epar < 11; epar++)
{
// cout << "f13 parameter " << epar << " = " <<
// f13->GetParameter(epar) << endl;
FitPar[epar+22] = f13->GetParameter(epar);
}
// cout << "hdata integral = " << hdata->Integral() << endl;
// cout << endl;
// printf("fit area %3.2f; sig area %3.2f; bg area %3.2f\n", f13->Integral(-1., 20.)/hdata->GetBinWidth(2), f11->Integral(-1., 20.)/hdata->GetBinWidth(2),f12->Integral(-1., 20.)/hdata->GetBinWidth(2));
// for(int i=0; i<12; i++){
// printf(" fit para %d = %4.3f \n", i, f13->GetParameter(i));
// }
TLegend *tleg = new TLegend(0.5, 0.7, 0.93, 0.92);
char text[50];
sprintf(text,"%s Pt %d ~ %.0f GeV",EBEE, ptbin, ptmax);
tleg->SetHeader(text);
tleg->SetFillColor(0);
tleg->SetShadowColor(0);
tleg->SetBorderSize(0);
sprintf(text,"#chi^{2}/NDF = %.1f/%d",chi2ForThisBin,nbinForThisBin);
tleg->AddEntry(hdata,text,"");
sprintf(text,"Data %.1f events",hdata->Integral());
tleg->AddEntry(hdata,text,"pl");
sprintf(text,"Fitted %.1f events",para[0]+para[1]);//f13->Integral(-1., 20.)/hdata->GetBinWidth(2));
tleg->AddEntry(f13,text,"l");
sprintf(text,"SIG %.1f #pm %.1f events",para[0], errpara[0]);
tleg->AddEntry(f11,text,"f");
sprintf(text,"BKG %.1f #pm %.1f events",para[1], errpara[1]);
tleg->AddEntry(f12,text,"f");
tleg->Draw();
gPad->RedrawAxis();
printf("%s, ptbin %d, Data %.1f events \n",EBEE, ptbin, hdata->Integral());
printf("Fitted %.1f (in 5GeV) %.1f events \n",para[0]+para[1],f13->Integral(-1.,5.));
printf("SIG %.1f #pm %.1f events \n",para[0], errpara[0]);
printf("SIG (in 5GeV) %.1f #pm %.1f events \n",f11->Integral(-1.,5.)/hdata->GetBinWidth(2), f11->Integral(-1.,5.)*errpara[0]/para[0]/hdata->GetBinWidth(2));
printf("BKG %.1f #pm %.1f events \n",para[1], errpara[1]);
printf("BKG (in 5GeV) %.1f #pm %.1f events \n",f12->Integral(-1.,5.)/hdata->GetBinWidth(2), f12->Integral(-1.,5.)*errpara[1]/para[1]/hdata->GetBinWidth(2));
float purity = f11->Integral(-1.,5.)/hdata->GetBinWidth(2)/(f11->Integral(-1.,5.)/hdata->GetBinWidth(2)+f12->Integral(-1.,5.)/hdata->GetBinWidth(2));
float purity_err = purity*errpara[0]/para[0];
printf("Purity (in 5GeV) %.3f #pm %.3f \n", purity, purity_err);
// hsig->Scale(para[0]/hsig->Integral());
// hbkg->Scale(para[1]/hbkg->Integral());
// hbkg->Add(hsig);
// hsig->SetLineColor(1);
// hsig->SetFillColor(5);
// hsig->SetFillStyle(3001);
// hbkg->SetLineWidth(2);
// hsig->Draw("same");
// hbkg->Draw("same");
sprintf(fname,"plots/unbinned_free_Ifit%s_%d.pdf",EBEE,ptbin);
if (para_index>0) sprintf(fname,"plots/unbinned_Ifit%s_%d_para%d_sigma%1.0f.pdf",EBEE,ptbin,para_index,para_sigma);
if(Opt_SavePDF == 1) {
c1->SaveAs(fname);
} else {
c1->Close();
c10->Close();
c101->Close();
c11->Close();
}
printf("----- fit results with signal projection ----------- \n");
fitted[0] = para[0];
fitted[1] = errpara[0];
fitted[2] = para[1];
fitted[3] = errpara[1];
fitted[4] = f11->Integral(-1.,5.)/hdata->GetBinWidth(2);
fitted[5] = f11->Integral(-1.,5.)*errpara[0]/para[0]/hdata->GetBinWidth(2);
return fitted;
}
void makePlot(const string tnp_ = "etoTauMargLooseNoCracks70",
const string category_ = "tauAntiEMVA",
const string var_ = "abseta",
const float xLow_=65,
const float xHigh_=113,
bool makeSoupFit_ = true,
bool SumW2_ = false,
bool verbose_ = true,
double bin1_ = 0.0,
double bin2_ = 1.5,
double bin3_ = 2.5
){
// output file
TFile *outFile = new TFile( Form("EtoTauPlots_%s_%s_%s_v5.root",tnp_.c_str(),category_.c_str(),var_.c_str()),"RECREATE");
cout << "******************** bin1" << endl;
vector<Double_t*> bin1Results = simFit(makeSoupFit_, tnp_, category_,string(Form("%s>%f && %s<%f",var_.c_str(),bin1_,var_.c_str(),bin2_)),(bin2_+bin1_)/2,(bin2_-bin1_)/2 ,xLow_, xHigh_, SumW2_, verbose_);
cout << "******************** bin2" << endl;
vector<Double_t*> bin2Results = simFit(makeSoupFit_, tnp_, category_,string(Form("(%s > %f && %s<%f)",var_.c_str(),bin2_,var_.c_str(),bin3_)),(bin3_+bin2_)/2,(bin3_-bin3_)/2 ,xLow_, xHigh_, SumW2_, verbose_);
Double_t truthMC_x[2] = {(bin1Results[0])[0],(bin2Results[0])[0]};
Double_t truthMC_xL[2] = {(bin1Results[0])[1],(bin2Results[0])[1]};
Double_t truthMC_xH[2] = {(bin1Results[0])[2],(bin2Results[0])[2]};
Double_t truthMC_y[2] = {(bin1Results[0])[3],(bin2Results[0])[3]};
Double_t truthMC_yL[2] = {(bin1Results[0])[4],(bin2Results[0])[4]};
Double_t truthMC_yH[2] = {(bin1Results[0])[5],(bin2Results[0])[5]};
//
Double_t tnpMC_x[2] = {0,0};
Double_t tnpMC_xL[2] = {0,0};
Double_t tnpMC_xH[2] = {0,0};
Double_t tnpMC_y[2] = {0,0};
Double_t tnpMC_yL[2] = {0,0};
Double_t tnpMC_yH[2] = {0,0};
if(makeSoupFit_){
tnpMC_x[0] = (bin1Results[2])[0]; tnpMC_x[1] = (bin2Results[2])[0];
tnpMC_xL[0] = (bin1Results[2])[1]; tnpMC_xL[1] = (bin2Results[2])[1];
tnpMC_xH[0] = (bin1Results[2])[2]; tnpMC_xH[1] = (bin2Results[2])[2];
tnpMC_y[0] = (bin1Results[2])[3]; tnpMC_y[1] = (bin2Results[2])[3];
tnpMC_yL[0] = (bin1Results[2])[4]; tnpMC_yL[1] = (bin2Results[2])[4];
tnpMC_yH[0] = (bin1Results[2])[5]; tnpMC_yH[1] = (bin2Results[2])[5];
}
//
Double_t tnpDATA_x[2] = {(bin1Results[1])[0],(bin2Results[1])[0]};
Double_t tnpDATA_xL[2] = {(bin1Results[1])[1],(bin2Results[1])[1]};
Double_t tnpDATA_xH[2] = {(bin1Results[1])[2],(bin2Results[1])[2]};
Double_t tnpDATA_y[2] = {(bin1Results[1])[3],(bin2Results[1])[3]};
Double_t tnpDATA_yL[2] = {(bin1Results[1])[4],(bin2Results[1])[4]};
Double_t tnpDATA_yH[2] = {(bin1Results[1])[5],(bin2Results[1])[5]};
TCanvas *c1 = new TCanvas("effCanvas","Efficiency canvas",10,30,650,600);
c1->SetGrid(0,0);
c1->SetFillStyle(4000);
c1->SetFillColor(10);
c1->SetTicky();
c1->SetObjectStat(0);
TLegend* leg = new TLegend(0.4,0.6,0.89,0.89,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.03);
double binsEdges[3] = {bin1_,bin2_,bin3_};
TH1F* h1 = new TH1F("h1","Passing efficiency plot",2, binsEdges);
h1->SetXTitle( var_.c_str() );
h1->SetYTitle( ("Efficiency of passing "+category_).c_str() );
TGraphAsymmErrors* graph_truthMC = new TGraphAsymmErrors(2,truthMC_x,truthMC_y, truthMC_xL,truthMC_xH,truthMC_yL,truthMC_yH);
graph_truthMC->SetMarkerColor(kBlue);
graph_truthMC->SetMarkerStyle(20);
graph_truthMC->SetMarkerSize(1);
///////////////////////////////////////////////////////
TGraphAsymmErrors* graph_tnpMC = new TGraphAsymmErrors(2,tnpMC_x,tnpMC_y,tnpMC_xL,tnpMC_xH,tnpMC_yL,tnpMC_yH);
graph_tnpMC->SetMarkerColor(kRed);
graph_tnpMC->SetMarkerStyle(21);
graph_tnpMC->SetMarkerSize(1);
///////////////////////////////////////////////////////
TGraphAsymmErrors* graph_tnpDATA = new TGraphAsymmErrors(2,tnpDATA_x, tnpDATA_y,tnpDATA_xL,tnpDATA_xH,tnpDATA_yL,tnpDATA_yH);
graph_tnpDATA->SetMarkerColor(kBlack);
graph_tnpDATA->SetMarkerStyle(22);
graph_tnpDATA->SetMarkerSize(1);
c1->cd();
gPad->SetLeftMargin(0.15);
h1->GetYaxis()->SetTitleOffset(1.4);
h1->Draw("");
graph_truthMC->Draw("PSAME");
if(makeSoupFit_) graph_tnpMC->Draw("PSAME");
graph_tnpDATA->Draw("PSAME");
TH1F* h1mcTruth = new TH1F("h1mcTruth","",1,0,1);
h1mcTruth->SetLineColor(kBlue);
h1mcTruth->SetMarkerStyle(20);
h1mcTruth->SetMarkerSize(1);
TH1F* h1tnpMC = new TH1F("h1tnpMC","",1,0,1);
h1tnpMC->SetLineColor(kRed);
h1tnpMC->SetMarkerStyle(21);
h1tnpMC->SetMarkerSize(1);
TH1F* h1tnpDATA = new TH1F("h1tnpDATA","",1,0,1);
h1tnpDATA->SetLineColor(kBlack);
h1tnpDATA->SetMarkerStyle(22);
h1tnpDATA->SetMarkerSize(1);
leg->SetHeader(Form("#splitline{L=32 pb^{-1} Run2010A/B}{%s passing %s}",tnp_.c_str(),category_.c_str()));
leg->AddEntry(h1mcTruth,"mc-truth");
if(makeSoupFit_) leg->AddEntry(h1tnpMC,"t&p: simulation");
leg->AddEntry(h1tnpDATA,"t&p: 7 TeV Data");
leg->Draw();
outFile->cd();
c1->Write();
outFile->Close();
}
void drawVar( const std::string& outdir, TTree* tree_74, TTree* tree_80, const Signal& signal, const std::string& savename, const std::string& name, int nBins, float xMin, float xMax, const std::string& selection ) {
TCanvas* c1 = new TCanvas("c1", "", 600, 600);
c1->cd();
float binWidth = (xMax-xMin)/((float)nBins);
TH1D* h1_74 = new TH1D( "h1_74", "", nBins, xMin, xMax );
TH1D* h1_80 = new TH1D( "h1_80", "", nBins, xMin, xMax );
h1_74->Sumw2();
h1_80->Sumw2();
h1_80->SetXTitle( name.c_str() );
h1_80->SetYTitle( "Events" );
h1_74->SetLineWidth(2);
h1_80->SetLineWidth(2);
float sf74 = 2.6;
std::string name74 = name;
if( signal.mass==745. && signal.width=="0p014" && name=="boss_mass" ) name74 = name + "-5.";
if( selection=="" ) {
tree_74->Project("h1_74", name74.c_str(), Form("weight*%f", sf74));
tree_80->Project("h1_80", name.c_str(), "weight");
} else {
tree_74->Project("h1_74", name74.c_str(), Form("weight*%f*(%s)", sf74, selection.c_str()));
tree_80->Project("h1_80", name.c_str(), Form("weight*(%s)", selection.c_str()));
}
h1_80->SetLineColor(kRed);
h1_80->DrawNormalized("same");
h1_74->DrawNormalized("same");
ZGDrawTools::addLabels( c1, 2.6 );
std::string legendTitle( Form( "M=%.0f GeV, %s", signal.mass, signal.width.c_str()) );
TLegend* legend;
if( name=="boss_mass" )
legend = new TLegend( 0.2, 0.72, 0.55, 0.9 );
else
legend = new TLegend( 0.65, 0.72, 0.9 , 0.9 );
legend->SetFillColor(0);
legend->SetTextSize(0.038);
legend->SetTextFont(42);
legend->SetHeader( legendTitle.c_str() );
legend->AddEntry( h1_74, "74X MC", "L" );
legend->AddEntry( h1_80, "80X MC", "L" );
legend->Draw("same");
gPad->RedrawAxis();
c1->SaveAs( Form("%s/%s_M%.0f_W%s_74vs80.eps" , outdir.c_str(), savename.c_str(), signal.mass, signal.width.c_str()) );
c1->SaveAs( Form("%s/%s_M%.0f_W%s_74vs80.pdf" , outdir.c_str(), savename.c_str(), signal.mass, signal.width.c_str()) );
c1->SetLogy();
c1->SaveAs( Form("%s/%s_M%.0f_W%s_74vs80_log.eps", outdir.c_str(), savename.c_str(), signal.mass, signal.width.c_str()) );
c1->SaveAs( Form("%s/%s_M%.0f_W%s_74vs80_log.pdf", outdir.c_str(), savename.c_str(), signal.mass, signal.width.c_str()) );
delete c1;
delete h1_74;
delete h1_80;
}