void newBrezilianflagneventstGc(){
TF1 *fa = new TF1("fa","7.15*x*x",0.001,0.13);
TCanvas *c1 = new TCanvas("c1","upper limit results ",200,10,700,500);
c1->SetGrid();
const int N=2;
//double X[N]={0.001,0.13};
//double nO[N]={0.0365,0.0365 };
//double nE[N]={0.0469,0.0469};
double X[N]={0.001,0.13};
double nO[N]={0.0372,0.0372 };
double nE[N]={0.0481,0.0481};
cout<<"expected tgammac coupling"<<sqrt(nE[0]/7.15)<<endl;
cout<<"observed tgammac coupling"<<sqrt(nO[0]/7.15)<<endl;
cout<<"expected tgammac coupling including k-factor"<<sqrt(nE[0]/(1.375*7.15))<<endl;
cout<<"observed tgammac coupling including k-factor"<<sqrt(nO[0]/(1.375*7.15))<<endl;
double nE1sigmaup[N]={0.0648,0.0648};
double nE1sigmadown[N]={0.0351,0.0351};
double nE2sigmaup[N]={0.0949,0.0949};
double nE2sigmadown[N]={0.0266,0.0266};
double sigma1up[N];
double sigma1down[N];
double sigma2up[N];
double sigma2down[N];
for (int idx=0; idx<N; ++idx){
sigma1up[idx]=nE1sigmaup[idx]-nE[idx];
sigma1down[idx]=nE[idx]-nE1sigmadown[idx];
sigma2up[idx]=nE2sigmaup[idx]-nE[idx];
sigma2down[idx]=nE[idx]-nE2sigmadown[idx];
}
TGraphAsymmErrors *grafexp1sigma=new TGraphAsymmErrors(N);
grafexp1sigma->SetName("grafexp1sigma");
grafexp1sigma->SetTitle("Graph");
grafexp1sigma->SetFillColor(1);
//grafexp1sigma->SetPoint(point number ,x value,y value);
//grafexp1sigma->SetPointError(point number ,0,0,y lower error ,y upper error);
grafexp1sigma->SetPoint(0,X[0],nE[0]);
grafexp1sigma->SetPointError(0,0,0,sigma1down[0],sigma1up[0]);
grafexp1sigma->SetPoint(1,X[1],nE[1]);
grafexp1sigma->SetPointError(1,0,0,sigma1down[1],sigma1up[1]);
/*
grafexp1sigma->SetPoint(2,X[2],nE[2]);
grafexp1sigma->SetPointError(2,0,0,sigma1down[2],sigma1up[2]);
grafexp1sigma->SetPoint(3,X[3],nE[3]);
grafexp1sigma->SetPointError(3,0,0,sigma1down[3],sigma1up[3]);
grafexp1sigma->SetPoint(4,X[4],nE[4]);
grafexp1sigma->SetPointError(4,0,0,sigma1down[4],sigma1up[4]);
*/
grafexp1sigma->SetFillColor(kGreen);
// grafexp1sigma->
// grafexp1sigma->
// grafexp1sigma->
// grafexp1sigma->
TGraphAsymmErrors *grafexp2sigma=new TGraphAsymmErrors(N);
grafexp2sigma->SetPoint(0,X[0],nE[0]);
grafexp2sigma->SetPointError(0,0,0,sigma2down[0],sigma2up[0]);
grafexp2sigma->SetPoint(1,X[1],nE[1]);
grafexp2sigma->SetPointError(1,0,0,sigma2down[1],sigma2up[1]);
/*
grafexp2sigma->SetPoint(2,X[2],nE[2]);
grafexp2sigma->SetPointError(2,0,0,sigma2down[2],sigma2up[2]);
grafexp2sigma->SetPoint(3,X[3],nE[3]);
grafexp2sigma->SetPointError(3,0,0,sigma2down[3],sigma2up[3]);
grafexp2sigma->SetPoint(4,X[4],nE[4]);
grafexp2sigma->SetPointError(4,0,0,sigma2down[4],sigma2up[4]);
*/
grafexp2sigma->SetFillColor(kYellow);
grafexp2sigma->GetXaxis()->SetLabelFont(42);
// grafexp2sigma->SetLabel("");
grafexp2sigma->GetXaxis()->SetLabelOffset(0.007);
grafexp2sigma->GetXaxis()->SetLabelSize(0.034);
grafexp2sigma->GetXaxis()->SetTitleSize(0.045);
grafexp2sigma->GetXaxis()->SetTitleFont(22);
grafexp2sigma->GetXaxis()->SetTitleOffset(0.90);
grafexp2sigma->GetXaxis()->SetRangeUser(0, 0.2);
grafexp2sigma->GetYaxis()->SetRangeUser(0, 0.16);
grafexp2sigma->GetYaxis()->SetTitle("95% CL Limit on [#sigma_{tc#gamma} * Br(w #rightarrow l#nu)] (pb)");
grafexp2sigma->GetYaxis()->SetLabelFont(42);
grafexp2sigma->GetYaxis()->SetLabelOffset(0.007);
grafexp2sigma->GetYaxis()->SetLabelSize(0.034);
grafexp2sigma->GetYaxis()->SetTitleSize(0.045);
grafexp2sigma->GetYaxis()->SetTitleOffset(0.9);
grafexp2sigma->GetYaxis()->SetTitleFont(22);
grafexp2sigma->GetXaxis()->SetTitle("#kappa_{c}");
grafexp2sigma->SetTitle("");
// grafexp2sigma->SetMaximum(8);
TGraph *Expected= new TGraph(N,X,nE);
Expected->SetLineColor(4);
Expected->SetLineWidth(2);
Expected->SetMarkerColor(1);
Expected->SetMarkerStyle(20);
Expected->SetLineStyle(2);
Expected->GetYaxis()->SetTitle("Cross Section [pb]");
Expected->GetXaxis()->SetTitle("#Lambda_{T} [GeV]");
Expected->SetTitle("with ");
Expected->SetFillColor(10);
TGraph *Observed= new TGraph(N,X,nO);
Observed->SetLineColor(1);
Observed->SetLineWidth(2);
Observed->SetMarkerColor(1);
Observed->SetMarkerStyle(20);
// Observed->SetLineStyle(2);
Observed->GetYaxis()->SetTitle("Cross Section [pb]");
Observed->GetXaxis()->SetTitle("#Lambda_{T} [GeV]");
Observed->SetTitle("with ");
Observed->SetFillColor(10);
grafexp2sigma->Draw("AL3");
grafexp1sigma->Draw("L3same");
Expected->Draw("L");
Observed->Draw("L");
fa->SetLineColor(2);
fa->SetLineWidth(3);
fa->SetMarkerColor(1);
fa->Draw("same");
Observed->GetHistogram()->Draw("AXISSAMEY+");
Observed->GetHistogram()->Draw("AXISSAMEX+");
TLegend *leg1 = new TLegend(0.2, 0.6, 0.35, 0.8);
leg1->SetTextSize(0.03);
leg1->SetBorderSize(0);
leg1->SetLineColor(0);
leg1->SetLineWidth(0);
leg1->SetFillColor(kWhite);
leg1->AddEntry(fa, "Predicted", "L");
leg1->AddEntry(Observed, "95% CL Observed Limit", "L");
leg1->AddEntry(Expected, "95% CL Expected Limit", "L");
leg1->AddEntry(grafexp1sigma, "#pm1#sigma Exp.Limit", "F");
leg1->AddEntry(grafexp2sigma, "#pm2#sigma Exp.Limit", "F");
leg1->Draw();
TLine *line1 = new TLine(5, 1, 40, 1);
line1->SetLineColor(2);
line1->SetLineWidth(2);
// line1->Draw("same");
TPaveText *pt = new TPaveText(0.1,0.95,0.4,0.95, "NDC"); // NDC sets coords
pt->SetLineColor(10); // relative to pad dimensions
pt->SetFillColor(10); // text is black on white
pt->SetTextSize(0.045);
pt->SetTextAlign(12);
pt->AddText("CMS Preliminary, 19.1 fb^{-1}, #sqrt{s} = 8 TeV");
pt->SetShadowColor(10);
pt->Draw("same");
}
//---------------------------------------------------------------------------
//function to plot res vs. energy for pions (uses current dir, etc. settings)
//qty: 0 = response, 1 = resolution, 2 = sampling factor
TGraphErrors* g4_plot_res(int snum, int qty, bool do_pion, bool use_f_pion, bool do_fit, bool do_show, bool do_print=false){
Sample* sp = sample_map[snum];
if(!sp) { std::cout << "Sample " << snum << " is not loaded." << std::endl; return 0; }
//store values from get_res
Double_t* vals = new Double_t[maxHDe]; //sigma or mean
Double_t* xvals = new Double_t[maxHDe]; //sigma or mean
Double_t* y_errors = new Double_t[maxHDe]; //errors on pars
Double_t* logxvals = new Double_t[maxHDe]; //sigma or mean
//for storage of output info
energyRes* res_temp;
for (int i = 0; i < maxHDe; i++){
double energy = energies[i];
Double_t v, ve;
if(qty==2){
//get sampling factor for energy without setting value
std::pair<Double_t,Double_t> f_temp = g4_sample(snum,energy,do_pion,0);
v = f_temp.first;
ve = f_temp.second;
}
else {
res_temp = get_res(snum,energy,do_pion,use_f_pion,do_fit,0,0,1);
Double_t m, me, s, se;
if(do_fit){
TF1* fit = res_temp->getFit();
m = fit->GetParameter(1);
me = fit->GetParError(1);
s = fit->GetParameter(2);
se = fit->GetParError(2);
}
else{
m = res_temp->getStat(1);
me = res_temp->getStatErr(1);
s = res_temp->getStat(2);
se = res_temp->getStatErr(2);
}
if(qty==1){
v = s/m;
ve = v*sqrt(se*se/(s*s)+me*me/(m*m));
}
else if(qty==0){
v = m/energy;
ve = me/energy;
}
}
xvals[i] = energy;
logxvals[i] = log(energy);
vals[i] = v;
y_errors[i] = ve;
}
TCanvas* can;
TPaveText* pave;
TGraphErrors* val_graph;
TGraphErrors* fit_graph;
Int_t col, mrk;
col = kBlue; mrk = 21;
//graph values
std::string qtyaxes[] = {"Response (#mu/E_{true})","Resolution (#sigma/#mu)","sampling factor"};
if(do_pion) qtyaxes[0] = sp->name_rat + " #pi^{-} Response (R_{cal}/E_{gen})";
else qtyaxes[0] = sp->name_rat + " e^{-} Response (R_{cal}/E_{gen})";
fit_graph = new TGraphErrors(maxHDe,logxvals,vals,0,y_errors);
val_graph = new TGraphErrors(maxHDe,xvals,vals,0,y_errors);
val_graph->GetXaxis()->SetTitle("Energy [GeV]");
val_graph->GetYaxis()->SetTitle(qtyaxes[qty].c_str());
val_graph->SetTitle("");
val_graph->SetMarkerStyle(mrk);
val_graph->SetMarkerColor(col);
val_graph->SetMarkerSize(1.5);
val_graph->SetLineColor(col);
val_graph->SetFillColor(0);
//fit response for e/pi from pions
TF1* gfit = 0;
TF1* gline = 0;
double c, ce, k, ke;
std::stringstream epiname, ehname, kname;
if(qty==0 && do_pion){
gfit = new TF1("epi_fit","pol1",fit_graph->GetXaxis()->GetXmin(),fit_graph->GetXaxis()->GetXmax());
//gfit = new TF1("epi_fit","(1+([0]-1)*([1]*x))/[0]",val_graph->GetXaxis()->GetXmin(),val_graph->GetXaxis()->GetXmax());
//gfit = new TF1("epi","(1+([0]-1)*([1]*x^[2]))/[0]",val_graph->GetXaxis()->GetXmin(),val_graph->GetXaxis()->GetXmax());
gfit->SetParameter(0,0.9);
gfit->SetParameter(1,0.01);
//gfit->SetParameter(2,-2.8);
fit_graph->Fit(gfit,"NR");
//results
double a, ae, b, be;
a = gfit->GetParameter(0);
ae = gfit->GetParError(0);
b = gfit->GetParameter(1);
be = gfit->GetParError(1);
//transform to desired params
c = 1./a;
ce = ae/(a*a);
k = b/(1.-a);
ke = sqrt(pow(be/(1.-a),2) + pow(ae*b/pow(1-a,2),2));
std::cout.precision(2);
std::cout << "e/h = " << c << " +/- " << ce << ", k = " << k << " +/- " << ke << std::endl;
//store params in sample
sp->eh = c;
sp->eh_err = ce;
sp->k = k;
sp->k_err = ke;
epiname.precision(2);
epiname << "#frac{R}{E} = #frac{#pi}{e}(E) = #frac{1 + (e/h - 1) #upoint k ln(E)}{e/h}";
ehname.precision(2);
ehname << "e/h = " << c << " #pm " << ce;
kname.precision(2);
kname << "k = " << k << " #pm " << ke;
//line for E instead of log(E)
gline = new TF1("epi","(1+([0]-1)*([1]*log(x)))/[0]",val_graph->GetXaxis()->GetXmin(),val_graph->GetXaxis()->GetXmax());
gline->SetParameter(0,c);
gline->SetParameter(1,k);
//formatting
gline->SetLineColor(kRed);
gline->SetMarkerColor(kRed);
gline->SetLineWidth(2);
}
if(do_show){
std::string cname;
cname = "res";
can = new TCanvas(cname.c_str(),cname.c_str(),700,500);
can->cd();
//can->SetLogx();
//if(qty) val_graph->GetYaxis()->SetRangeUser(0,0.4);
//else val_graph->GetYaxis()->SetRangeUser(0,1.1);
val_graph->Draw("APZ");
//legend, pave coords
double y1;
if(qty) y1 = 0.5;
else y1 = 0.2;
std::string pavename = sp->name;
if(do_pion) pavename += " #pi^{-}";
else pavename += " e^{-}";
pave = new TPaveText(0.5,y1,0.95,y1+0.2,"NDC");
if(qty==0 && do_pion){
pave->AddText((epiname.str()).c_str());
pave->AddText((ehname.str()).c_str());
pave->AddText((kname.str()).c_str());
}
else{
pave->AddText(pavename.c_str());
}
pave->SetFillColor(0);
pave->SetBorderSize(0);
pave->SetTextFont(42);
pave->SetTextSize(0.05);
pave->Draw("same");
if(gline) gline->Draw("same");
if(do_print){
std::string fpre = sp->fpre;
if(do_pion) fpre += "_pion";
else fpre += "_elec";
//names
std::string ofit;
if(do_fit) ofit = "fit";
else ofit = "nofit";
std::string qtyname[] = {"mu","sigma","sam"};
std::stringstream oname;
oname << pdir << "/" << fpre;
if(use_f_pion) oname << "_fpion";
oname << "_" << qtyname[qty] << "_" << ofit;
oname << "." << pformat;
can->Print((oname.str()).c_str(),pformat.c_str());
}
}
return val_graph;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// root -l computeDrellYanPtllWeight.C+
// root -l -b -q computeDrellYanPtllWeight.C+
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void computeDrellYanPtllWeight(TString fname = "h_pt2l_mm")
{
gInterpreter->ExecuteMacro("PaperStyle.C");
TFile* file = TFile::Open("figures/Control/01_DY/" + fname + ".root");
TH1D* ratio = (TH1D*)file->Get("ratio");
// Draw the ratio
//----------------------------------------------------------------------------
TCanvas* c1 = new TCanvas("c1", "c1");
ratio->SetMinimum(0.85);
ratio->SetMaximum(1.20);
ratio->Draw("ep");
TString ytitle = Form("data / MC ratio / %.0f GeV", ratio->GetBinWidth(0));
SetAxis(ratio, ratio->GetXaxis()->GetTitle(), ytitle, 1.7, 1.8);
// Draw the old function
//----------------------------------------------------------------------------
TF1* fOld = new TF1("fOld", "[3]*(0.95 - [0]*TMath::Erf((x-[1])/[2]))", 0, 90);
fOld->SetLineColor (kGreen+2);
fOld->SetMarkerColor(kGreen+2);
// https://github.com/latinos/PlotsConfigurations/blob/master/Configurations/ggH/nuisances_iteos.py#L969-L977
fOld->SetParameter(0, 0.1);
fOld->SetParameter(1, 14.0);
fOld->SetParameter(2, 8.8);
fOld->SetParameter(3, 1.08683);
fOld->Draw("same");
// Draw the old function error band
//------------------------------------------------------------------------------
if (errorband)
{
TF1* fOld_down = (TF1*)fOld->Clone("fOld_down");
TF1* fOld_up = (TF1*)fOld->Clone("fOld_up");
fOld_down->SetParameter(0, 13.6);
fOld_down->SetParameter(1, 8.6);
fOld_up->SetParameter(0, 14.4);
fOld_up->SetParameter(1, 9.0);
fOld_down->Draw("same");
fOld_up ->Draw("same");
}
// Update the fit parameters of the old function
//
// 1 p0 6.85257e-02 2.99341e-01 1.42129e-05 4.16760e-04
// 2 p1 1.24518e+01 4.76906e+01 3.55312e-03 6.41625e-07
// 3 p2 5.40627e+00 7.83907e+01 6.49546e-03 -1.96376e-06
// 4 p3 1.05396e+00 3.48880e-01 1.58779e-05 -3.97115e-05
//
//----------------------------------------------------------------------------
TF1* fNew = new TF1("fNew", "[3]*(0.95 - [0]*TMath::Erf((x-[1])/[2]))", 0, 90);
fNew->SetLineColor (kRed+1);
fNew->SetMarkerColor(kRed+1);
fNew->SetParameter(0, 0.1);
fNew->SetParameter(1, 10);
fNew->SetParameter(2, 1);
fNew->SetParameter(3, 1);
ratio->Fit(fNew, "mlr0");
fNew->Draw("same");
// Draw the updated error band
//------------------------------------------------------------------------------
if (errorband)
{
TF1* fNew_down = (TF1*)fNew->Clone("fNew_down");
TF1* fNew_up = (TF1*)fNew->Clone("fNew_up");
fNew_down->SetParameter(0, 0.97 * fNew->GetParameter(0));
fNew_down->SetParameter(1, 0.97 * fNew->GetParameter(1));
fNew_up->SetParameter(0, 1.03 * fNew->GetParameter(0));
fNew_up->SetParameter(1, 1.03 * fNew->GetParameter(1));
fNew_down->Draw("same");
fNew_up ->Draw("same");
}
// Fit Lorenzo's function
//
// 1 p0 1.17864e-01 7.44869e-01 1.03478e-05 1.79528e-03
// 2 p1 1.34231e+01 6.10789e+01 2.78074e-03 6.38697e-06
// 3 p2 9.76801e+00 1.03947e+02 5.51661e-03 -2.28998e-06
// 4 p3 1.01367e+00 6.56154e-01 1.29644e-05 -1.36428e-04
// 5 p4 2.50141e-03 2.62347e-02 1.53669e-07 -1.11290e-01
// 6 p5 1.10637e-05 1.42769e-04 1.32442e-09 1.17953e+01
//
//----------------------------------------------------------------------------
TF1* fLo = new TF1("fLo", "([3] + [4]*x - [5]*x*x) * (0.95 - [0]*TMath::Erf((x-[1])/[2]))", 0, 150);
fLo->SetLineColor (kBlue);
fLo->SetMarkerColor(kBlue);
fLo->SetParameter(0, 0.131835);
fLo->SetParameter(1, 14.1972);
fLo->SetParameter(2, 10.1525);
fLo->SetParameter(3, 0.876979);
fLo->SetParameter(4, 4.11598e-03);
fLo->SetParameter(5, 2.35520e-05);
ratio->Fit(fLo, "mlr0");
// Get the point where the first derivative is closest to zero
//
// fLo = 0.9608 and d(fLo)/d(ptll) = -0.000110 for ptll = 119 GeV
//
//----------------------------------------------------------------------------
float smallest_derivative_value = 999;
float smallest_derivative_x = 999;
for (int x=90; x<120; x++)
{
if (fLo->Derivative(x) < smallest_derivative_value)
{
smallest_derivative_value = fLo->Derivative(x);
smallest_derivative_x = x;
}
}
printf("\n fLo = %.4f and d(fLo)/d(ptll) = %f for ptll = %.0f GeV\n\n",
fLo->Eval(smallest_derivative_x),
fLo->Derivative(smallest_derivative_x),
smallest_derivative_x);
// Draw Lorenzo's function in two ranges
//----------------------------------------------------------------------------
fLo->SetRange(0, smallest_derivative_x);
fLo->Draw("same");
TF1* fHi = new TF1("fHi", "[0]", smallest_derivative_x, 150);
fHi->SetLineColor (kBlue);
fHi->SetMarkerColor(kBlue);
fHi->SetParameter(0, fLo->Eval(smallest_derivative_x));
fHi->Draw("same");
// Legend
//----------------------------------------------------------------------------
DrawLegend(0.69, 0.83, (TObject*)fOld, " old fit");
DrawLegend(0.69, 0.77, (TObject*)fNew, " new fit");
DrawLegend(0.69, 0.71, (TObject*)fLo, " Lorenzo's fit");
// Save
//----------------------------------------------------------------------------
ratio->Draw("ep,same");
c1->SaveAs(fname + "_ratio_fit.png");
}
//------------------------------------
//function to fit energy distributions
energyRes* get_res(int snum, Double_t energy, bool do_pion, bool use_f_pion, bool do_fit, bool do_show, bool do_print=false, bool do_batch=false){
Sample* sp = sample_map[snum];
if(!sp) { std::cout << "Sample " << snum << " is not loaded." << std::endl; energyRes* theRes = new energyRes(0,0); return theRes; }
//select correct file
std::string fpre = sp->fpre;
if(do_pion) fpre += "_pion";
else fpre += "_elec";
//make filenames
std::stringstream drawname, fname, piname;
fname << sp->dir << "/" << fpre << "_" << energy << "gev_10k.root";
if(do_pion) piname << "#pi^{-} " << energy << " GeV";
else piname << "e^{-} " << energy << " GeV";
//open file and tree
TFile* _file;
_file = TFile::Open((fname.str()).c_str());
TTree* totalTree = (TTree*)_file->Get("Total");
//default histo settings
//double Emin = 0.1*energies[num]; //lower cut to remove weird peaks near E=zero
double Emin = 0;
double Emax = 2*energy;
int nbins = 100;
//ecal & hcal energies need to be calibrated
get_sampling_factors(snum);
//make tree drawing expressions
//define mip as ecal < 1 gev = 1000 mev
if(use_f_pion) drawname << sp->sam_pion;
else drawname << sp->sam_elec;
if(sp->det==Hcal) drawname << "*(hcal+" << sp->zeroWt << "*zero)/1000";
else drawname << "*ecal/1000";
drawname << ">>htemp(" << nbins << "," << Emin << "," << Emax << ")";
//std::cout << drawname.str() << std::endl;
TH1F* h_res; //to store histos drawn from tree
TF1* gfit;
TF1* gsnL;
TF1* gsnR;
//plotting variables
TCanvas* can;
TPad* pad;
TLegend* leg;
TPaveText* pave;
TPaveText* pave_par;
TLine *aLline;
TLine *aRline;
//create instance of energyRes object
energyRes* theRes = new energyRes(energy,2);
//draw w/ appropriate cut
totalTree->Draw((drawname.str()).c_str(),"","hist goff");
h_res = (TH1F*)gDirectory->Get("htemp");
h_res->SetTitle("");
h_res->GetXaxis()->SetTitle("Energy [GeV]");
h_res->SetLineWidth(2);
h_res->SetLineColor(kBlack);
//names
std::string ofit;
if(do_fit) ofit = "fit";
else ofit = "nofit";
std::stringstream oname;
oname << pdir << "/" << fpre;
if(use_f_pion) oname << "_fpion";
oname << "_response_" << ofit << "_" << energy << "gev";
//get values from histo
Double_t m = h_res->GetMean();
Double_t me = h_res->GetMeanError();
//Double_t m = h_res->GetBinCenter(h_res->GetMaximumBin()); //peak
Double_t s = h_res->GetRMS();
Double_t se = h_res->GetRMSError();
Int_t N = h_res->GetEntries();
std::vector<Double_t> stats(3,0);
std::vector<Double_t> stat_err(3,0);
stats[0] = N;
stat_err[0] = 0;
stats[1] = m;
stat_err[1] = me;
stats[2] = s;
stat_err[2] = se;
//find peak
TSpectrum *spec = new TSpectrum(5);
if(nbins < 100) spec->Search(h_res,6,"nobackground nodraw goff"); //turn off background removal when nbins too small
else spec->Search(h_res,6,"nodraw goff");
Float_t* xpos = spec->GetPositionX();
Float_t* ypos = spec->GetPositionY();
Double_t p = xpos[0];
Double_t ph = ypos[0];
if(do_show) std::cout << "peak: " << p << std::endl;
//setup fitting function & do fit
if (do_fit){
gfit = new TF1("resp","gaus",0,h_res->GetXaxis()->GetXmax());
//if(do_jet){
// gfit->SetParameters(ph,p,s);
// if(m > p) gfit->SetRange(p-1.5*s,p+1.0*s); //high tail
// else gfit->SetRange(p-1.0*s,p+1.5*s); //low tail
//}
//else{
gfit->SetParameters((Double_t)N,m,s);
gfit->SetRange(m-2*s,m+1*s); //fit within 2 std devs
//if(m > p) gfit->SetRange(p-2*s,p+1*s); //high tail
//else gfit->SetRange(p-1*s,p+2*s); //low tail
//}
//formatting
gfit->SetLineColor(kRed);
gfit->SetMarkerColor(kRed);
gfit->SetLineWidth(2);
//fit
h_res->Fit(gfit,"LNQR");
}
//store parameters
theRes->setStats(stats,stat_err);
if(do_fit) theRes->setFit(gfit);
//store histo
h_res->SetDirectory(0);
theRes->setHist(h_res);
std::stringstream muname, signame, musigname, aLname, nLname, aRname, nRname, Nname, chiname;
muname.precision(2);
signame.precision(2);
musigname.precision(3);
aLname.precision(2);
nLname.precision(2);
aRname.precision(2);
nRname.precision(2);
chiname.precision(5);
if (do_fit) {
muname << fixed << "#mu = " << gfit->GetParameter(1) << " #pm " << gfit->GetParError(1);
signame << fixed << "#sigma = " << gfit->GetParameter(2) << " #pm " << gfit->GetParError(2);
musigname << fixed << "#sigma/#mu = " << gfit->GetParameter(2)/gfit->GetParameter(1) << " #pm " <<
gfit->GetParameter(2)/gfit->GetParameter(1) * sqrt( Power(gfit->GetParError(1),2)/Power(gfit->GetParameter(1),2) + Power(gfit->GetParError(2),2)/Power(gfit->GetParameter(2),2) );
//aLname << fixed << "a_{L} = " << gfit->GetParameter(3) << " #pm " << gfit->GetParError(3);
//nLname << fixed << "n_{L} = " << gfit->GetParameter(4) << " #pm " << gfit->GetParError(4);
//aRname << fixed << "a_{R} = " << gfit->GetParameter(5) << " #pm " << gfit->GetParError(5);
//nRname << fixed << "n_{R} = " << gfit->GetParameter(6) << " #pm " << gfit->GetParError(6);
chiname << fixed << "#chi^{2}/ndf = " << gfit->GetChisquare()/gfit->GetNDF();
}
else {
muname << fixed << "Mean = " << m << " #pm " << me;
signame << fixed << "RMS = " << s << " #pm " << se;
musigname << fixed << "RMS/Mean = " << s/m << " #pm " << s/m*sqrt((me*me)/(m*m)+(se*se)/(s*s));
}
Nname << "N = " << N;
//plotting
if (do_show){
can = new TCanvas((oname.str()).c_str(),(oname.str()).c_str(),700,500);
can->cd();
pad = new TPad("graph","",0,0,1,1);
pad->SetMargin(0.12,0.05,0.15,0.05);
pad->Draw();
pad->cd();
//formatting
h_res->SetStats(kTRUE);
gStyle->SetOptStat("mr");
h_res->GetYaxis()->SetTitleSize(32/(pad->GetWh()*pad->GetAbsHNDC()));
h_res->GetYaxis()->SetLabelSize(28/(pad->GetWh()*pad->GetAbsHNDC()));
h_res->GetXaxis()->SetTitleSize(32/(pad->GetWh()*pad->GetAbsHNDC()));
h_res->GetXaxis()->SetLabelSize(28/(pad->GetWh()*pad->GetAbsHNDC()));
h_res->GetYaxis()->SetTickLength(12/(pad->GetWh()*pad->GetAbsHNDC()));
h_res->GetXaxis()->SetTickLength(12/(pad->GetWh()*pad->GetAbsHNDC()));
//plot histo and fit
h_res->Draw("hist");
if(do_fit) gfit->Draw("same");
//determine placing of legend and paves - par pave goes on side with more space
Double_t xmin;
if (m/((h_res->GetXaxis()->GetXmax() + h_res->GetXaxis()->GetXmin())/2) < 1) xmin = 0.65;
else xmin = 0.2;
if(do_fit) { //legend
leg = new TLegend(xmin,0.78,xmin+0.2,0.88);
leg->AddEntry(h_res,"Standalone");
leg->AddEntry(gfit,"Fit");
leg->SetFillColor(0);
leg->SetBorderSize(0);
leg->SetTextSize(0.05);
leg->SetTextFont(42);
leg->Draw("same");
can->Update();
/*
//left line
Double_t bndL = gfit->GetParameter(1) - gfit->GetParameter(2)*gfit->GetParameter(3);
aLline = new TLine(bndL,pad->GetUymin(),bndL,pad->GetUymax());
aLline->SetLineStyle(2);
aLline->SetLineWidth(3);
aLline->SetLineColor(kBlue);
aLline->Draw("same");
//left gaussian
gsnL = new TF1("gsn","gaus",Emin,bndL);
gsnL->SetParameters(gfit->GetParameter(0),gfit->GetParameter(1),gfit->GetParameter(2));
gsnL->SetLineColor(kRed);
gsnL->SetMarkerColor(kRed);
gsnL->SetLineWidth(2);
gsnL->SetLineStyle(2);
gsnL->Draw("same");
//line
Double_t bndR = gfit->GetParameter(1) + gfit->GetParameter(2)*gfit->GetParameter(5);
aRline = new TLine(bndR,pad->GetUymin(),bndR,pad->GetUymax());
aRline->SetLineStyle(2);
aRline->SetLineWidth(3);
aRline->SetLineColor(kBlue);
aRline->Draw("same");
//right gaussian
gsnR = new TF1("gsn","gaus",bndR,Emax);
gsnR->SetParameters(gfit->GetParameter(0),gfit->GetParameter(1),gfit->GetParameter(2));
gsnR->SetLineColor(kRed);
gsnR->SetMarkerColor(kRed);
gsnR->SetLineWidth(2);
gsnR->SetLineStyle(2);
gsnR->Draw("same");
*/
}
//pave
pave = new TPaveText(xmin,0.68,xmin+0.2,0.78,"NDC");
pave->AddText(sp->name.c_str());
pave->AddText((piname.str()).c_str());
pave->SetFillColor(0);
pave->SetBorderSize(0);
pave->SetTextFont(42);
pave->SetTextSize(0.05);
pave->Draw("same");
//par pave
Double_t ymin1;
//if(do_fit) ymin1 = 0.26;
//else ymin1 = 0.51;
ymin1 = 0.47;
pave_par = new TPaveText(xmin,ymin1,xmin+0.2,ymin1+0.05*4,"NDC");
pave_par->AddText((Nname.str()).c_str());
pave_par->AddText((muname.str()).c_str());
pave_par->AddText((signame.str()).c_str());
pave_par->AddText((musigname.str()).c_str());
//if(do_fit){
// pave_par->AddText((aLname.str()).c_str());
// pave_par->AddText((nLname.str()).c_str());
// pave_par->AddText((aRname.str()).c_str());
// pave_par->AddText((nRname.str()).c_str());
// pave_par->AddText((chiname.str()).c_str());
//}
pave_par->SetFillColor(0);
pave_par->SetBorderSize(0);
pave_par->SetTextFont(42);
pave_par->SetTextSize(0.05);
pave_par->Draw("same");
std::cout << "response:" << std::endl;
std::cout << Nname.str() << std::endl;
std::cout << muname.str() << std::endl;
std::cout << signame.str() << std::endl;
std::cout << musigname.str() << std::endl;
if(do_fit){
// std::cout << "aL = " << gfit->GetParameter(3) << " +/- " << gfit->GetParError(3) << std::endl;
// std::cout << "nL = " << gfit->GetParameter(4) << " +/- " << gfit->GetParError(4) << std::endl;
// std::cout << "aR = " << gfit->GetParameter(5) << " +/- " << gfit->GetParError(5) << std::endl;
// std::cout << "nR = " << gfit->GetParameter(6) << " +/- " << gfit->GetParError(6) << std::endl;
std::cout << "chi^2/ndf = " << gfit->GetChisquare()/gfit->GetNDF() << std::endl;
}
if(do_print) can->Print((oname.str()+"."+pformat).c_str(),pformat.c_str());
if(do_batch) _file->Close();
}
else { _file->Close(); }
//return data structure with relevant info
return theRes;
}
