//______________________________________________________________________________
void Ifit()
{
// The z values
z[0]=1;
z[1]=0.96;
z[2]=0.89;
z[3]=0.85;
z[4]=0.78;
// The errors on z values
Float_t error = 0.01;
errorz[0]=error;
errorz[1]=error;
errorz[2]=error;
errorz[3]=error;
errorz[4]=error;
// the x values
x[0]=1.5751;
x[1]=1.5825;
x[2]=1.6069;
x[3]=1.6339;
x[4]=1.6706;
// the y values
y[0]=1.0642;
y[1]=0.97685;
y[2]=1.13168;
y[3]=1.128654;
y[4]=1.44016;
TMinuit *gMinuit = new TMinuit(5); //initialize TMinuit with a maximum of 5 params
gMinuit->SetFCN(fcn);
Double_t arglist[10];
Int_t ierflg = 0;
arglist[0] = 1;
gMinuit->mnexcm("SET ERR", arglist ,1,ierflg);
// Set starting values and step sizes for parameters
static Double_t vstart[4] = {3, 1 , 0.1 , 0.01};
static Double_t step[4] = {0.1 , 0.1 , 0.01 , 0.001};
gMinuit->mnparm(0, "a1", vstart[0], step[0], 0,0,ierflg);
gMinuit->mnparm(1, "a2", vstart[1], step[1], 0,0,ierflg);
gMinuit->mnparm(2, "a3", vstart[2], step[2], 0,0,ierflg);
gMinuit->mnparm(3, "a4", vstart[3], step[3], 0,0,ierflg);
// Now ready for minimization step
arglist[0] = 500;
arglist[1] = 1.;
gMinuit->mnexcm("MIGRAD", arglist ,2,ierflg);
// Print results
Double_t amin,edm,errdef;
Int_t nvpar,nparx,icstat;
gMinuit->mnstat(amin,edm,errdef,nvpar,nparx,icstat);
//gMinuit->mnprin(3,amin);
}
std::vector<double> run_fit(double parSRS){
TMinuit minuit;
double arglist[10];
int iflag;
arglist[0] = -1;
minuit.mnexcm("SET PRINT",arglist,1,iflag);
minuit.mnexcm("SET NOW",arglist,0,iflag);
minuit.SetFCN(fcn);
minuit.mnexcm("SET STR",arglist,1,iflag);
minuit.mnparm(0,"parSRS",parSRS,0.1,-100,100,iflag);
arglist[0] = 10000;
arglist[1] = 0.01;
minuit.mnexcm("MIGRAD",arglist,2,iflag);
minuit.mnexcm("HESSE",arglist,0,iflag);
double fmin, fedm,errdef;
int npari, nparx, istat;
minuit.mnstat(fmin,fedm,errdef,npari,nparx,istat);
double val,err;
std::vector<double> ret_ary;
for(int p = 0; p < 1; p++) {
minuit.GetParameter(p, val, err);
ret_ary.push_back(val);
}
ret_ary.push_back(fmin);
return ret_ary;
}
//______________________________________________________________________________
vector< vector<double> > cSpline(int nPoints, int npar, vector <double> xData, vector <double> yData, vector <double> yErrorData, double stepSpline, double start, double step)
{
//Populate the global variables//-> DONE IN THE MAIN
xData_GLOB = xData;//-> DONE IN THE MAIN
yData_GLOB = yData;//-> DONE IN THE MAIN
yErrorData_GLOB = yErrorData;//-> DONE IN THE MAIN
//Initialize Minuit
vector<double> vstart, vstep;
for(int i=0; i<npar; i++) //set starting values and step sizes for parameters
{
vstart.push_back(start);
vstep.push_back(step);
}
TMinuit *myMinuit = new TMinuit(npar); //initialize TMinuit with a maximum of npar (5) -> PASSED AS ARGUMENT
myMinuit->SetFCN(fcn);//-> DONE IN THE MAIN
myMinuit->SetPrintLevel(-1);//No output: -1, output:1//-> DONE IN THE MAIN
double arglist[10];//-> DONE IN THE MAIN
int ierflg = 0;//-> DONE IN THE MAIN
arglist[0] = 1;//-> DONE IN THE MAIN
myMinuit->mnexcm("SET ERR", arglist, 1, ierflg);//-> DONE IN THE MAIN
for (int i = 0; i < npar; i++) {//-> DONE IN THE MAIN
stringstream ss;//-> DONE IN THE MAIN
ss<<"a"<<i;//-> DONE IN THE MAIN
myMinuit->mnparm(i, ss.str().c_str(), vstart.at(i), vstep.at(i), 0, 0, ierflg);//-> DONE IN THE MAIN
}//-> DONE IN THE MAIN
//Perform the Minuit fit
arglist[0] = 500;//-> DONE IN THE MAIN
arglist[1] = 1.;//-> DONE IN THE MAIN
myMinuit->mnexcm("MIGRAD", arglist, 2, ierflg); //minimization
//Retrieve best-fit parameters
vector< double > bestFitParams, e_bestFitParams;
for(int i=0; i<npar; i++)
{
double par, epar;
myMinuit->GetParameter(i, par, epar); //retrieve best fit parameters
bestFitParams.push_back(par);
e_bestFitParams.push_back(epar);
}
//Store the best-fit spline in a TGraph
gsl_spline_init (spline_GLOB, &xData[0], &bestFitParams[0], xData.size()); //initialize the spline
int nPointsSpline = int ((xData[nPoints-1]-xData[0])/stepSpline); //calculate the number of points of the spline
vector< vector<double> > cSplineValues;
cSplineValues.push_back( vector< double > ());//x
cSplineValues.push_back( vector< double > ());//y
for (int i= 0; i < nPointsSpline; i++){
cSplineValues[0].push_back(xData[0]+i*stepSpline);
cSplineValues[1].push_back(gsl_spline_eval (spline_GLOB, cSplineValues[0].back(), acc_GLOB));
}
return cSplineValues;
}
void unbinFitosc_pts()
{
TMinuit *gMinuit = new TMinuit(4);
gMinuit -> SetFCN(mll_fit_pts);
Double_t arglist[10];
Double_t vstart[10];
Double_t step[10];
Double_t p0=0,p1=1,p2=2,p3=3;
Int_t ierflg=0;
Double_t par0;
Double_t err0;
// Set to 0.5 for likelihood, 1 for chisquare
arglist[0] = 0.5;
gMinuit->mnexcm("SET ERR", arglist, 1, ierflg);
// Set initial values of parameters
vstart[0] = oscpar0_init;
step[0] = oscerr0_step;
gMinuit->mnparm(0, "mistag", vstart[0], step[0], 0., 0., ierflg);
// Do minimization
arglist[0] = 3000.;
arglist[1] = 0.1;
gMinuit->mnexcm("CALL FCN", &p1, 1, ierflg);
gMinuit->mnexcm("MIGRAD", arglist, 2, ierflg);
gMinuit->mnexcm("CALL FCN", &p3, 1, ierflg);
// Get parameters
gMinuit->GetParameter(0,par0,err0);
// Export the fitted parameters so we can graph them.
fitpar=par0;
fiterr=err0;
RooComplex ct = RooMath::ComplexErrFunc(2.,1.);
Double_t ctre=ct.re();
Double_t ctim=ct.im();
printf("ct %10.5f %10.5f \n",ctre,ctim);
delete gMinuit;
}
std::vector<double> run_fit(double parOOR, double parOEFG, double parOFTMR,
double parOTO, double parSRS) {
TMinuit minuit;
double arglist[10];
int iflag;
arglist[0] = -1;
minuit.mnexcm("SET PRINT",arglist,1,iflag);
minuit.mnexcm("SET NOW",arglist,0,iflag);
minuit.SetFCN(fcn);
arglist[0] = 2;
minuit.mnexcm("SET STR",arglist,1,iflag);
minuit.mnparm(0,"parOOR",parOOR,0.1,0,0,iflag);//or
minuit.mnparm(1,"parEFG",parOEFG,0.1,0,0,iflag);//efgp
minuit.mnparm(2,"parFTMR",parOFTMR,0.1,0,0,iflag);//ftr
minuit.mnparm(3,"parTO",parOTO,0.1,0,0,iflag);//top
minuit.mnparm(4,"parSRS",parSRS,0.1,0,0,iflag);//srs
if (parSRS == 0)
minuit.FixParameter(4);
arglist[0] = 10000;
arglist[1] = 0.0001;
minuit.mnexcm("MIGRAD",arglist,2,iflag);
minuit.mnexcm("HESSE",arglist,0,iflag);
double fmin, fedm,errdef;
int npari, nparx, istat;
minuit.mnstat(fmin,fedm,errdef,npari,nparx,istat);
double val,err;
std::vector<double> ret_ary;
for(int p = 0; p < 5; p++) {
minuit.GetParameter(p, val, err);
ret_ary.push_back(val);
}
ret_ary.push_back(fmin);
return ret_ary;
}
Double_t Fitter::MinuitFit() {
TMinuit *gMinuit = new TMinuit(1);
gMinuit->SetFCN(ChiSquare);
//settings
Double_t arglist[6];
Int_t ierflg = 0;
// Set starting values and step sizes for parameters
gMinuit->mnparm(0, "Sig", _W1, _step, _W1min, _W1max,ierflg);
//gMinuit->mnparm(0, "Sig", _W1, _step,0,0,ierflg);
// Now ready for minimization step
gMinuit->mnexcm("MIGRAD", arglist ,0,ierflg);
// Print results
Double_t amin,edm,errdef;
Int_t nvpar,nparx,icstat;
gMinuit->mnstat(amin, edm, errdef, nvpar, nparx, icstat);
gMinuit->mnprin(3, amin);
//gMinuit->mnexcm("MINOS", arglist ,0,ierflg);
for(int i=0; i<1; i++)
{
gMinuit -> GetParameter(i, _W1, _W1err);
cout<<"Parameter fit "<<i<<" value "<<_W1<<" err "<<_W1err<<endl;
}
delete gMinuit;
//calculate bkg error:
double entries_mc = _hsig->Integral(_hdata->GetXaxis()->FindBin(_xmin), _hdata->GetXaxis()->FindBin(_xmax));
double entries_bkg = _hbkg->Integral(_hdata->GetXaxis()->FindBin(_xmin), _hdata->GetXaxis()->FindBin(_xmax));
_W2err = _W1err*entries_mc/entries_bkg;
return amin;
}
void fill_minEE_class::Loop()
{
TFile *fpyt = new TFile("files/pythiaD6T_ee_v1.root");
TTree *tree_pyt = (TTree*)gDirectory->Get("tree_");
// TFile *fpom = (TFile*)gROOT->GetListOfFiles()->FindObject("files/DiffractiveMC.root");
TFile *fpom = new TFile("files/DiffractiveMC_ee_v1.root");
TTree *tree_pom = (TTree*)gDirectory->Get("tree_");
// TFile *fzee = (TFile*)gROOT->GetListOfFiles()->FindObject("files/ZetaSkim_ee.root");
TFile *fzee = new TFile("files/ZetaSkim_ee_v1.root");
// TFile *fzee = new TFile("files/ZetaSkim_mm.root");
TTree *tree_zee = (TTree*)gDirectory->Get("tree_");
// Int_t hnbin = 25;
Float_t llow = 0.;
Float_t lup = 250.;
TH1F *Hpompyt = new TH1F("Hpompyt", "pompyt", hnbin, llow, lup);
TH1F *Hpythia = new TH1F("Hpythia", "pythia", hnbin, llow, lup);
TH1F *Hdata = new TH1F("Hdata", "data", hnbin, llow, lup);
TH1F *HSum = new TH1F("HSum", "HSum", hnbin, llow, lup);
NCanvas(1,1);
//Go to Pythia
fChain =tree_pyt;
Init(fChain);
Long64_t nentries = fChain->GetEntriesFast();
cout << "number of entries in Pythia = " << nentries << endl;
Long64_t nbytes = 0, nb = 0;
for (Long64_t jentry=0; jentry<nentries;jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry); nbytes += nb;
// if (Cut(ientry) < 0) continue;
if (numberOfVertexes == 1){
Hpythia->Fill(TMath::Min(energyTot_PF_EE_minus,energyTot_PF_EE_plus));
}
}
// go to Pompyt
fChain = tree_pom;
Init(fChain);
nentries = fChain->GetEntriesFast();
cout << "number of entries in Pompyt = " << nentries << endl;
nbytes = 0, nb = 0;
for (jentry=0; jentry<nentries;jentry++) {
ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry); nbytes += nb;
// if (Cut(ientry) < 0) continue;
if (numberOfVertexes == 1){
Hpompyt->Fill(TMath::Min(energyTot_PF_EE_minus,energyTot_PF_EE_plus));
}
}
// go to Zee
fChain = tree_zee;
Init(fChain);
nentries = fChain->GetEntriesFast();
cout << "number of entries in Zee = " << nentries << endl;
nbytes = 0, nb = 0;
for (jentry=0; jentry<nentries;jentry++) {
ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry); nbytes += nb;
// if (Cut(ientry) < 0) continue;
// Zee->cd();
if (numberOfVertexes == 1){
Hdata->Fill(TMath::Min(energyTot_PF_EE_minus,energyTot_PF_EE_plus));
}
}
// Show the results
MyC->cd(1);
Hpythia->Draw();
Hpompyt->Draw("SAMES");
Hdata->Draw("SAMES");
// cout << Pcdata->lenght() << endl;
NHtoV(Hdata, Pcdata, Pedata);
NHtoV(Hpompyt, Pcpompyt, Pepompyt);
NHtoV(Hpythia, Pcpythia, Pepythia);
cout << " the content of data[2] is = " << Pcdata[2] << "+-"<<Pedata[2] << endl ;
cout << " the content of pythia[2] is = " << Pcpythia[2] << "+-"<<Pepythia[2] << endl ;
cout << " the content of pythia[2] is = " << Pcpompyt[2] << "+-"<<Pepompyt[2] << endl ;
// Here we go: the minuit show
TMinuit *gMinuit = new TMinuit(NPAR); //initialize TMinuit with a maximum of NPAR params
gMinuit->SetFCN(fcn);
Double_t arglist[NPAR]; // ???
Int_t ierflg = 0;
// Set starting values and step sizes for parameters
Double_t vstart[NPAR] ;
Double_t step[NPAR] ;
Double_t par[NPAR] ,fpar[NPAR];
char parName[NPAR];
Int_t n;
parName[0] = "Pythia";
parName[1] = "Pompyt";
par[0] = Hdata->Integral()/Hpythia->Integral();
par[1] = 0.05*Hdata->Integral()/Hpompyt->Integral();
for (n=0 ; n<NPAR ; n++)
{
vstart[n] = par[n] ;
step[n] = 0.5 ;
sprintf(parName,"a%d",n);
gMinuit->mnparm(n, parName, vstart[n], step[n], 0,0,ierflg);
}
cout << "par[0] set to = " << par[0] << " while par[1] = " << par[1] << endl;
arglist[0] = 1;
gMinuit->mnexcm("SET ERR", arglist ,1,ierflg);
gMinuit->mnexcm("SET PRINT", arglist,1,ierflg);
//Scan on parameter = 1
arglist[0] = 1;
gMinuit->mnexcm("SCAN", arglist,1,ierflg);
//Maximum number of calls
arglist[0] = 500;
gMinuit->mnexcm("MIGRAD", arglist,1,ierflg);
// Print results
Double_t amin,edm,errdef;
Int_t nvpar,nparx,icstat;
gMinuit->mnstat(amin,edm,errdef,nvpar,nparx,icstat);
gMinuit->mnprin(3,amin);
//Get the final fit parameters
for (n=0 ; n<NPAR ; n++)
{
Double_t parameter, erro ;
gMinuit->GetParameter(n,parameter,erro) ;
fpar[n] = parameter ;
}
cout << " The final parameter values are: "<< fpar[0] << " , " << fpar[1] << endl;
Float_t SD_frac = (fpar[1]*Hpompyt->Integral())/Hdata->Integral();
// Float_t NSD_events = fpar[0]*Hpythia->Integral();
// Float_t Data_events = Hdata->Integral();
cout << " The fraction of SD events is = " << SD_frac << endl;
// }
// void fill_minEE_class::show(){
//Show the final plot
MyC->cd(1);
Hpythia->Scale(fpar[0]);
Hpompyt->Scale(fpar[1]);
Hdata->SetMarkerColor(2);
Hdata->GetXaxis()->SetTitle("Min(EE-,EE+) Energy [GeV] ");
Hdata->GetYaxis()->SetTitle("Entries");
Hpompyt->SetLineColor(4);
Hpythia->SetLineColor(6);
Hpompyt->SetLineStyle(2);
Hpythia->SetLineStyle(2);
Float_t DMax = 1.2*Hdata->GetMaximum();
Hdata->SetMaximum(DMax);
Hdata->Draw("p");
Hpythia->Draw("SAMES");
Hpompyt->Draw("SAMES");
HSum->Add(Hpythia);
HSum->Add(Hpompyt);
HSum->SetLineColor(1);
HSum->SetLineStyle(1);
HSum->Draw("SAMES");
}
//_________________________________________________________________________________
void multipleSplinesWithHistogramsVb(int iEventLook = 163, int nEvents = 1000, int nPoints = 9, double seed = 231)
{
double lowerBound = 10; //bounds for random vector function
double upperBound = 20;
double lowerErrorBound = 1;
double upperErrorBound = 2;
//Load the data
vector< vector<double> > xEvents, yEvents, yErrorEvents; //each of these is a vector of vectors (of randomized data points)
for(int i = 0; i < nEvents; i++)
{
vector <double> xData, yData, yErrorData; //temporary vectors that are only used to get random values from FillRand function
FillRandVectors(nPoints, xData, yData, yErrorData, seed*(i+1), lowerBound, upperBound, lowerErrorBound, upperErrorBound); //populates random vectors for y values and y error vector
xEvents.push_back(xData);
yEvents.push_back(yData);
yErrorEvents.push_back(yErrorData);
}
//Intialization of the variables
const int npar = nPoints;
const int orderSpline = 4;
const int nbreak = npar+2-orderSpline;
double stepSpline = 0.01;
double xminBSplineWorkspace = 0;
double xmaxBSplineWorkspace = 9;
double startCSplineWorkspace = 15.;
double stepCSplineWorkspace = 1.5;
acc_GLOB = gsl_interp_accel_alloc ();
spline_GLOB = gsl_spline_alloc (gsl_interp_cspline, nPoints);
bw_GLOB = gsl_bspline_alloc(orderSpline, nbreak);
//B- and C-splines
clock_t tbstart, tbstop, tcstart, tcstop;
vector <double> timeb, timec;
vector< vector<double> > xBSplineValues, yBSplineValues;
vector< vector<double> > xCSplineValues, yCSplineValues;
//Setup for the C-spline_________________________________________________________________________
TMinuit *myMinuit = new TMinuit(npar); //initialize TMinuit with a maximum of npar
myMinuit->SetFCN(fcn);
myMinuit->SetPrintLevel(-1);//No output: -1, output:1
double arglist[10];
int ierflg = 0;
arglist[0] = 1;
myMinuit->mnexcm("SET ERR", arglist, 1, ierflg);
//Initialize Minuit
vector<double> vstart, vstep;
for(int i=0; i<npar; i++) //set starting values and step sizes for parameters
{
vstart.push_back(startCSplineWorkspace);
vstep.push_back(stepCSplineWorkspace);
}
for (int i = 0; i < npar; i++) {
stringstream ss;
ss<<"a"<<i;
myMinuit->mnparm(i, ss.str().c_str(), vstart.at(i), vstep.at(i), 0, 0, ierflg);
}
//Setup for the B-spline_________________________________________________________________________
//Looping begins for the calculations of the B and C-splines for each event
for(int i = 0; i < (int)xEvents.size(); i++)
{
//Populate the global variables
xData_GLOB = xEvents.at(i);
yData_GLOB = yEvents.at(i);
yErrorData_GLOB = yErrorEvents.at(i);
tbstart = clock();
vector< vector<double> > bSplineValues = bSpline(nPoints, npar, xEvents.at(i), yEvents.at(i), yErrorEvents.at(i), stepSpline, xminBSplineWorkspace, xmaxBSplineWorkspace);
tbstop = clock();
timeb.push_back(((float)tbstop-(float)tbstart)/ (CLOCKS_PER_SEC/1000.) );
std::cout<<timeb.back()<<std::endl;
xBSplineValues.push_back(bSplineValues.at(0));
yBSplineValues.push_back(bSplineValues.at(1));
tcstart = clock();
vector< vector<double> > cSplineValues = cSpline(nPoints, npar, xEvents.at(i), stepSpline, myMinuit);
tcstop = clock();
timec.push_back(((float)tcstop-(float)tcstart)/ (CLOCKS_PER_SEC/1000.) );
xCSplineValues.push_back(cSplineValues.at(0));
yCSplineValues.push_back(cSplineValues.at(1));
}
//Histograms______________________________________________________________________________________
//Time
int nbins = 100;
double xlow = 0;
double xup = 1.;
TH1D *hTimeB = new TH1D("Time","Timing; time [ms]; Number of Events", nbins, xlow, xup);
hTimeB->SetStats(0);
hTimeB->SetMarkerStyle(10);
TH1D *hTimeC = new TH1D("TimeC","Timing; time [ms]; Number of Events", nbins, xlow, xup);
hTimeC->SetLineColor(kRed);
hTimeC->SetMarkerStyle(10);
hTimeC->SetStats(0);
for(int i=0; i<(int)timec.size(); i++)
{
hTimeB->Fill(timeb.at(i));
hTimeC->Fill(timec.at(i));
}
//Interpolation
vector <double> interpB, interpC;
for(int i = 0; i < (int)yEvents.size(); i++)
{
for(int j = 0; j < (int)yEvents[i].size(); j++)
{
int indexForB = binarySearch(xBSplineValues[i], xEvents[i][j]);
int indexForC = binarySearch(xCSplineValues[i], xEvents[i][j]);
interpB.push_back( (yEvents[i][j]-yBSplineValues[i][indexForB])/yErrorEvents[i][j] );
interpC.push_back( (yEvents[i][j]-yCSplineValues[i][indexForC])/yErrorEvents[i][j] );
}
}
//Test graphs for splines
TGraph *GCspline = new TGraph(xCSplineValues[iEventLook].size(), &xCSplineValues[iEventLook][0], &yCSplineValues[iEventLook][0]);
GCspline->SetLineColor(kRed);
TGraph *GBspline = new TGraph(xBSplineValues[iEventLook].size(), &xBSplineValues[iEventLook][0], &yBSplineValues[iEventLook][0]);
TGraph *Gdata = new TGraph(xEvents[0].size(), &xEvents[iEventLook][0], &yEvents[iEventLook][0]);
Gdata->SetMarkerStyle(20);
int nbinsI = 101;
double xlowI = -0.1;
double xupI = 0.1;
TH1D *hInterpB = new TH1D("Interp B","Interpolation; Distance between spline and data normalized by error; Number of Events", nbinsI, xlowI, xupI);
for(int i=0; i<(int)interpB.size(); i++) hInterpB->Fill(interpB.at(i));
hInterpB->SetStats(0);
TH1D *hInterpC = new TH1D("Interp C","Interpolation; Distance between spline and data normalized by error; Number of Events", nbinsI, xlowI, xupI);
for (int i=0; i<(int)interpC.size(); i++) hInterpC->Fill(interpC.at(i));
hInterpC->SetLineColor(kGreen);
hInterpC->SetStats(0);
//Draws______________________________________________________________________________________
//Interpolation
TLegend *legInterp = new TLegend(0.9,0.70,0.75,0.85);
legInterp->SetLineColor(kWhite);
legInterp->SetFillColor(kWhite);
legInterp->SetMargin(0.3);
legInterp->AddEntry(hInterpB,"b-spline","l");
legInterp->AddEntry(hInterpC,"c-spline","l");
legInterp->SetTextSize(0.05);
TCanvas *c1 = new TCanvas("c1", "Interpolation distance");
c1->cd();
hInterpB->Draw("");
hInterpC->Draw("same");
legInterp->Draw();
//Time
TLegend *legTime = new TLegend(0.9,0.70,0.75,0.85);
legTime->SetLineColor(kWhite);
legTime->SetFillColor(kWhite);
legTime->SetMargin(0.3);
legTime->AddEntry(hTimeB,"b-spline","l");
legTime->AddEntry(hTimeC,"c-spline","l");
legTime->SetTextSize(0.05);
TCanvas *c2 = new TCanvas("c2", "Computation time");
c2->cd();
hTimeB->Draw();
// hTimeC->Draw("same");
legTime-> Draw();
TCanvas *c3 = new TCanvas("c3", "Test splines");
c3->cd();
Gdata->Draw("ap");
GCspline->Draw("samel");
GBspline->Draw("samel");
//Free the memory used
gsl_spline_free (spline_GLOB);
gsl_interp_accel_free (acc_GLOB);
gsl_bspline_free(bw_GLOB);
}
//_________________________________________________________________________________
void integratedSplinesV4a(double seed = 231)
{
//Load the data
int nEvents = 1000; //number of times the data will be randomized
int nPoints = 9;
vector< vector<double> > xEvents, yEvents, yErrorEvents; //each of these is a vector of vectors (of randomized data points)
for(int i = 0; i < nEvents; i++)
{
vector <double> xData, yData, yErrorData; //temporary vectors that are only used to get random values from FillRand function
FillRandVectors(nPoints, xData, yData, yErrorData, seed*(i+1)); //populates random vectors for y values and y error vector
xEvents.push_back(xData);
yEvents.push_back(yData);
yErrorEvents.push_back(yErrorData);
//Populate the global variables
xData_GLOB = xData;
yData_GLOB = yData;
yErrorData_GLOB = yErrorData;
}
//Intialization of the variables
const int npar = nPoints;
const int orderSpline = 4;
const int nbreak = npar+2-orderSpline;
double stepSpline = 0.01;
double xminBSplineWorkspace = 0;
double xmaxBSplineWorkspace = 9;
double startCSplineWorkspace = 15.;
double stepCSplineWorkspace = 1.5;
acc_GLOB = gsl_interp_accel_alloc ();
spline_GLOB = gsl_spline_alloc (gsl_interp_cspline, nPoints);
gsl_bspline_workspace *bw = gsl_bspline_alloc(orderSpline, nbreak);
//Setting up TMinuit for C-spline minimization
TMinuit *myMinuit = new TMinuit(npar); //initialize TMinuit with a maximum of npar (5)
myMinuit->SetFCN(fcn);
myMinuit->SetPrintLevel(-1);//No output: -1, output:1
double arglist[10];
int ierflg = 0;
arglist[0] = 1;
myMinuit->mnexcm("SET ERR", arglist, 1, ierflg);
vector<double> vstart, vstep;
for(int i=0; i < npar; i++) //set starting values and step sizes for parameters
{
vstart.push_back(startCSplineWorkspace);
vstep.push_back(stepCSplineWorkspace);
}
for (int i = 0; i < npar; i++)
{
stringstream ss;
ss<<"a"<<i;
myMinuit->mnparm(i, ss.str().c_str(), vstart.at(i), vstep.at(i), 0, 0, ierflg);
}
//Perform the Minuit fit
arglist[0] = 500;
arglist[1] = 1.;
//B and C spline loops__________________________________________________________________________
clock_t tbstart, tbstop, tcstart, tcstop;
vector <double> timeb, timec;
vector< vector<double> > xBSplineValues, yBSplineValues;
vector< vector<double> > xCSplineValues, yCSplineValues;
for(int i = 0; i < (int)xEvents.size(); i++)
{
tbstart = clock();
vector< vector<double> > bSplineValues = bSpline(nPoints, npar, xEvents.at(i), yEvents.at(i), yErrorEvents.at(i), stepSpline, xminBSplineWorkspace, xmaxBSplineWorkspace, bw);
tbstop = clock();
timeb.push_back(((float)tbstop-(float)tbstart)/ (CLOCKS_PER_SEC/1000.) );
xBSplineValues.push_back(bSplineValues.at(0));
yBSplineValues.push_back(bSplineValues.at(1));
tcstart = clock();
vector< vector<double> > cSplineValues = cSpline(nPoints, npar, xEvents.at(i), stepSpline, myMinuit, arglist, ierflg);
tcstop = clock();
timec.push_back(((float)tcstop-(float)tcstart)/ (CLOCKS_PER_SEC/1000.) );
xCSplineValues.push_back(cSplineValues.at(0));
yCSplineValues.push_back(cSplineValues.at(1));
}
//Histograms______________________________________________________________________________________
//Time
int nbins = 100;
double xlow = 0;
double xup = 5.;
TH1D *hTimeB = new TH1D("Time","; time [ms]; number of runs", nbins, xlow, xup);
hTimeB->SetStats(0);
TH1D *hTimeC = new TH1D("TimeC","; time [ms]; number of runs", nbins, xlow, xup);
hTimeC->SetLineColor(kRed);
hTimeC->SetStats(0);
for(int i=0; i<(int)timec.size(); i++)
{
hTimeB->Fill(timeb.at(i));
hTimeC->Fill(timec.at(i));
}
//Interpolation distance -> Should FIND THE RIGHT J FOR SPLINE
vector <double> interpB, interpC;
for(int i = 0; i < (int)yEvents.size(); i++)
{
for(int j = 0; j < (int)yEvents[i].size(); j++)
{
double key = xEvents[i][j];
int indexForB = binarySearch(xBSplineValues[i], key);
int indexForC = binarySearch(xCSplineValues[i], key);
// std::cout << "B: " << indexForB << " C: " << indexForC << endl;
if(indexForB != -1)
interpB.push_back( (yEvents[i][j]-yBSplineValues[i][indexForB])/yErrorEvents[i][indexForB] );
if(indexForC != -1)
interpC.push_back( (yEvents[i][j]-yCSplineValues[i][indexForC])/yErrorEvents[i][indexForC] );
}
}
int nbinsI = 40;
int xlowI = -4;
int xupI = 4;
TH1D *hInterpB = new TH1D("Interp B","; xAxis; yAxis", nbinsI, xlowI, xupI);
for(int i=0; i<(int)interpB.size(); i++) hInterpB->Fill(interpB.at(i));
hInterpB->SetStats(0);
TH1D *hInterpC = new TH1D("Interp C","; xAxis; yAxis", nbinsI, xlowI, xupI);
for (int i=0; i<(int)interpC.size(); i++) hInterpC->Fill(interpC.at(i));
hInterpC->SetLineColor(kRed);
hInterpC->SetStats(0);
//Draws______________________________________________________________________________________
//Interpolation distance
TLegend *legInterp = new TLegend(0.75,0.70,0.4,0.85);
legInterp->SetLineColor(kWhite);
legInterp->SetFillColor(kWhite);
legInterp->SetMargin(0.3);
legInterp->AddEntry(hInterpB,"b-spline","l");
legInterp->AddEntry(hInterpC,"c-spline","l");
TCanvas *c1 = new TCanvas("c1", "Interpolation distance");
c1->cd();
hInterpB->Draw("");
hInterpC->Draw("same");
legInterp->Draw();
//Time
TLegend *legTime = new TLegend(0.75,0.70,0.4,0.85);
legTime->SetLineColor(kWhite);
legTime->SetFillColor(kWhite);
legTime->SetMargin(0.3);
legTime->AddEntry(hTimeB,"b-spline","l");
legTime->AddEntry(hTimeC,"c-spline","l");
TCanvas *c2 = new TCanvas("c2", "Computation time");
c2->cd();
hTimeB->Draw("");
hTimeC->Draw("same");
legTime-> Draw();
//Free the memory for the spline
gsl_spline_free (spline_GLOB); //frees the memory used by the spline
gsl_interp_accel_free (acc_GLOB);
gsl_bspline_free(bw);
}
void testZeeMCSmearWithScale(string datareco = "jan16 or nov30",int phtcorr = 231, int test_fitdet= 1, string test_smearmethod = "corrSmear or uncorrSmear",string test_fitmethod = "lh or lhpoisson",int fixscale = 0,int fitstra = 1, int testpaircat=0, double test_fitlow = 70, double test_fithigh = 110, double test_binwidth = 1.0){
int phtcorr_test = phtcorr;
if( phtcorr_test == 486){
phtcorr = 485;
}
fitdet = test_fitdet;
smearMethod = test_smearmethod ;
testOnlyCat = testpaircat;
fitrangeLow = test_fitlow;
fitrangeHigh = test_fithigh;
binwidth = test_binwidth;
fitmethod = test_fitmethod;
gStyle->SetOptStat(0);
gStyle->SetNdivisions(508,"X");
gStyle->SetNdivisions(512,"Y");
int mc = 1;
fillMapIndex();
TString filename;
fChainMC = new TChain("Analysis");
fChainData = new TChain("Analysis");
string dataset;
int iflag = 2;
if( datareco == "nov30"){
iflag = 1;
dataset = "DoubleElectronRun2011AB30Nov2011v1AOD";
}else if( datareco == "jan16"){
iflag = 2;
dataset = "DoubleElectronRun2011AB16Jan2012v1AOD";
}else{
cout<<"dataset ? " << datareco.c_str()<<endl;
return;
}
///MC
filename = TString(Form("/home/raid2/yangyong/data/CMSSW/v1/CMSSW_4_2_8/src/zSelector/dielectrontree/makeDiElectronTree.v3.DYJetsToLL_TuneZ2_M50_7TeVmadgraphtauolaFall11PU_S6_START42_V14Bv1AODSIMallstat.etcut20.corr%d.eleid1.datapu6.mcpu1.r1to92.scale0.root",phtcorr));
cout<<filename<<endl;
fChainMC->Add(filename);
//fChainMC->SetBranchAddress("isRealData", &isRealData);
fChainMC->SetBranchAddress("elescr9", elescr9);
fChainMC->SetBranchAddress("elesceta", elesceta);
fChainMC->SetBranchAddress("eleen", eleen);
//fChainMC->SetBranchAddress("eleen0", eleen0);
fChainMC->SetBranchAddress("mpair", &mpair);
// fChainMC->SetBranchAddress("mpair0", &mpair0);
fChainMC->SetBranchAddress("eleeta", eleeta);
fChainMC->SetBranchAddress("eleieta", eleieta);
fChainMC->SetBranchAddress("eleiphi", eleiphi);
fChainMC->SetBranchAddress("runNumber", &runNumber);
fChainMC->SetBranchAddress("evtNumber", &evtNumber);
fChainMC->SetBranchAddress("lumiBlock", &lumiBlock);
fChainMC->SetBranchAddress("eleetrue", eleetrue);
// fChainMC->SetBranchAddress("eleetruenofsr", eleetruenofsr);
// fChainMC->SetBranchAddress("eleetrueplusfsrdrbc003", eleetrueplusfsrdrbc003);
// fChainMC->SetBranchAddress("eleetrueplusfsrdrbc004", eleetrueplusfsrdrbc004);
fChainMC->SetBranchAddress("eleetrueplusfsrdrbc005", eleetrueplusfsrdrbc005);
// fChainMC->SetBranchAddress("eleetrueplusfsrdrbc006", eleetrueplusfsrdrbc006);
// fChainMC->SetBranchAddress("eleetrueplusfsrdrbc007", eleetrueplusfsrdrbc007);
// fChainMC->SetBranchAddress("eleetrueplusfsrdrbc008", eleetrueplusfsrdrbc008);
// fChainMC->SetBranchAddress("eleetrueplusfsrdrbc009", eleetrueplusfsrdrbc009);
fChainMC->SetBranchAddress("eleetrueplusfsrdrbc01", eleetrueplusfsrdrbc01);
// fChainMC->SetBranchAddress("eletrueelematched", eletrueelematched);
// fChainMC->SetBranchAddress("eletrueelematchednofsr", eletrueelematchednofsr);
fChainMC->SetBranchAddress("weight", &weight);
//Data
filename = TString(Form("/home/raid2/yangyong/data/CMSSW/v1/CMSSW_4_2_8/src/zSelector/dielectrontree/makeDiElectronTree.v3.%s.etcut20.corr%d.eleid1.datapu0.mcpu0.r1to131.scale0.root",dataset.c_str(),phtcorr));
cout<<filename<<endl;
fChainData->Add(filename);
fChainData->SetBranchAddress("isRealData", &isRealData);
fChainData->SetBranchAddress("elescr9", elescr9);
fChainData->SetBranchAddress("elesceta", elesceta);
fChainData->SetBranchAddress("eleen", eleen);
fChainData->SetBranchAddress("eleen0", eleen0);
fChainData->SetBranchAddress("mpair", &mpair);
fChainData->SetBranchAddress("mpair0", &mpair0);
fChainData->SetBranchAddress("eleeta", eleeta);
fChainData->SetBranchAddress("eleieta", eleieta);
fChainData->SetBranchAddress("eleiphi", eleiphi);
fChainData->SetBranchAddress("runNumber", &runNumber);
fChainData->SetBranchAddress("evtNumber", &evtNumber);
fChainData->SetBranchAddress("lumiBlock", &lumiBlock);
NMC = fChainMC->GetEntries();
NData = fChainData->GetEntries();
cout<<"nMC " << NMC <<" "<< NData <<endl;
filename = TString(Form("testZeeMCSmearWithScale.%s.%s.%s.testpair%d.fitrange%dto%d.binwidth%2.2f.fitdet%d.corr%d.fitstra%d.fixscale%d.etcut%d.root",datareco.c_str(),test_smearmethod.c_str(),test_fitmethod.c_str(),testpaircat,int(fitrangeLow+0.1),int(fitrangeHigh+0.1),binwidth,fitdet,phtcorr_test,fitstra,fixscale,etcut));
TFile *fnew = new TFile(filename,"recreate");
//filename = TString(Form("testZeeMCSmearWithScale.%s.%s.%s.testpair%d.fitrange%dto%d.binwidth%2.2f.fitdet%d.corr%d.fitstra%d.fixscale%d.etcut%d.txt",datareco.c_str(),test_smearmethod.c_str(),test_fitmethod.c_str(),testpaircat,int(fitrangeLow+0.1),int(fitrangeHigh+0.1),binwidth,fitdet,phtcorr,fitstra,fixscale,etcut));
//txtout.open(filename,ios::out);
TTree *mytree = new TTree("Analysis","");
float mcfitpar[8] = {0};
float mcfitparErr[8] = {0};
int mcfitStatus;
float fAmin;
mytree->Branch("mcfitpar",mcfitpar,"mcfitpar[8]/F");
mytree->Branch("mcfitparErr",mcfitparErr,"mcfitparErr[8]/F");
mytree->Branch("mcfitStatus",&mcfitStatus,"mcfitStatus/I");
mytree->Branch("fAmin",&fAmin,"fAmin/F");
rv_mass = new RooRealVar("rv_mass","mass",100,0,1E6);
rv_weight = new RooRealVar("rv_weight","weight",1.0,0,1E6);
for(int j=0;j<20;j++){
string sname = string(Form("mpairmc_indscpair%d",j));
makeRootDataSetAndTH1F(sname,int( (fitrangeHigh-fitrangeLow)/binwidth+0.1),fitrangeLow,fitrangeHigh);
sname = string(Form("mpairdata_indscpair%d",j));
makeRootDataSetAndTH1F(sname,int( (fitrangeHigh-fitrangeLow)/binwidth+0.1),fitrangeLow,fitrangeHigh);
}
int sc1cat;
int sc2cat;
cout<<" nMC " <<NMC <<endl;
for(int n=0; n< NMC; n++){
fChainMC->GetEntry(n);
if(phtcorr==94){
if(evtNumber%2==0) continue;
}
///same as 485, for test purpose only
if(phtcorr_test==486){
if(evtNumber%2==0) continue;
}
if(n%500000==0) cout<<"n " << n <<endl;
if(fitdet==1){
if( fabs(elesceta[0])>1.48 || fabs(elesceta[1])>1.48) continue;
}else if( fitdet==2){
if( fabs(elesceta[0])<1.48 || fabs(elesceta[1])<1.48) continue;
}
///scale r9 in MC
for(int j=0; j<2; j++){
if(fabs(elesceta[j])<1.48) elescr9[j] *= 1.004;
else elescr9[j] *= 1.006;
}
///get pair index
sc1cat = scCategoryEight(elesceta[0],elescr9[0]);
sc2cat = scCategoryEight(elesceta[1],elescr9[1]);
if(sc2cat < sc1cat){
exChangeTwoNumber(sc1cat,sc2cat);
}
int indpair;
if(fitdet==1){
indpair = map_indscpairBarrel[sc1cat][sc2cat];
}else{
indpair = map_indscpairEndcap[sc1cat][sc2cat];
}
//test one category
if(testOnlyCat >=0 && indpair != testOnlyCat) continue;
float e1true;
if( fabs(elesceta[0])<1.48){
e1true = eleetrueplusfsrdrbc005[0];
}else{
e1true = eleetrueplusfsrdrbc01[0];
}
float e2true;
if( fabs(elesceta[1])<1.48){
e2true = eleetrueplusfsrdrbc005[1];
}else{
e2true = eleetrueplusfsrdrbc01[1];
}
if(e1true <1 || e2true<1) continue;
vindpair.push_back(indpair);
sc1cat = scCategoryEight(elesceta[0],elescr9[0]);
sc2cat = scCategoryEight(elesceta[1],elescr9[1]);
if(fitdet==2){ //Endcap, starting with 4,5,6,7
sc1cat -=4;
sc2cat -=4;
}
vsc1cat.push_back(sc1cat);
vsc2cat.push_back(sc2cat);
vele1eta.push_back(eleeta[0]);
vele1ieta.push_back(eleieta[0]);
vele1iphi.push_back(eleiphi[0]);
vele2eta.push_back(eleeta[1]);
vele2ieta.push_back(eleieta[1]);
vele2iphi.push_back(eleiphi[1]);
vele1en.push_back(eleen[0]);
vele2en.push_back(eleen[1]);
vmpair.push_back(mpair);
vweight.push_back(weight);
vele1etrue.push_back(e1true);
vele2etrue.push_back(e2true);
if( eleen[0]* sin(2*atan(exp(-eleeta[0]))) < etcut) continue;
if( eleen[1]* sin(2*atan(exp(-eleeta[1]))) < etcut) continue;
string sname = string(Form("mpairmc_indscpair%d",indpair));
fillRootDataSetAndTH1F(sname,mpair,weight);
}
setMap_cat_runbin();
loadRunbyRunScaleCorrectionNoR9(iflag,phtcorr);
loadScaleCorrectionR9(iflag,phtcorr);
for(int n=0; n< NData; n++){
fChainData->GetEntry(n);
if(n%500000==0) cout<<"n " << n <<endl;
if(fitdet==1){
if( fabs(elesceta[0])>1.48 || fabs(elesceta[1])>1.48) continue;
}else if( fitdet==2){
if( fabs(elesceta[0])<1.48 || fabs(elesceta[1])<1.48) continue;
}
float scorr = 1.0;
for(int j=0; j<2; j++){
float dEoE = energyScaleRunNoR9(elesceta[j]);
float dEoE1 = energyScaleR9(elesceta[j],elescr9[j]);
eleen[j] *= 1.0/(1+dEoE) * 1.0/(1+dEoE1);
scorr *= 1.0/(1+dEoE) * 1.0/(1+dEoE1);
}
mpair *= sqrt(scorr);
if( eleen[0]*sin(2*atan(exp(-eleeta[0]))) < etcut) continue;
if( eleen[1]*sin(2*atan(exp(-eleeta[1]))) < etcut) continue;
sc1cat = scCategoryEight(elesceta[0],elescr9[0]);
sc2cat = scCategoryEight(elesceta[1],elescr9[1]);
if(sc2cat < sc1cat){
exChangeTwoNumber(sc1cat,sc2cat);
}
int indpair;
if(fitdet==1){
indpair = map_indscpairBarrel[sc1cat][sc2cat];
}else{
indpair = map_indscpairEndcap[sc1cat][sc2cat];
}
string sname = string(Form("mpairdata_indscpair%d",indpair));
fillRootDataSetAndTH1F(sname,mpair,1);
}
for(int j=0;j<10;j++){
string sname = string(Form("mpairmc_indscpair%d",j));
string snamed = string(Form("mpairdata_indscpair%d",j));
cout<<"mpair catpair " << th1f_map[sname]->GetEntries()<<" "<< th1f_map[snamed]->GetEntries()<<endl;
}
generateGaussRandom();
//return;
TMinuit *minuit;
int npar = 8;
minuit = new TMinuit(npar);
//minuit->SetFCN(function);
//minuit->SetFCN(function1);
minuit->SetFCN(function2);
//settings
Double_t arglist[1];
Int_t ierflg = 0;
//double STEPMN = 0.01;
double STEPMN = 0.0001;
// 1 for Chi square
// 0.5 for negative log likelihood
if(fitmethod== "lh" || fitmethod == "lhpoisson"){
minuit->SetErrorDef(0.5);
}else{
minuit->SetErrorDef(1);
}
double fitpar[10];
double fitparErr[10];
double smearcat[4] = {1.1,1.1,1.1,1.1};
double smearcatMax[4] = {3,3,3,3};
double deltaEcat[4] = {0,0,0,0};
if(smearMethod=="uncorrSmear"){
smearcatMax[0] = 0.05;
smearcatMax[1] = 0.05;
smearcatMax[2] = 0.05;
smearcatMax[3] = 0.05;
smearcat[0] = 0.007;
smearcat[1] = 0.01;
smearcat[2] = 0.015;
smearcat[3] = 0.02;
if(fitdet==2){
smearcat[0] = 0.02;
smearcat[1] = 0.02;
smearcat[2] = 0.02;
smearcat[3] = 0.02;
}
}
for(int j=0; j<4; j++){
TString parname = TString (Form("smearcat%d",j));
if(smearMethod=="corrSmear"){
minuit->mnparm(j, parname, smearcat[j], STEPMN, 0.5,smearcatMax[j],ierflg);
}else if(smearMethod=="uncorrSmear"){
minuit->mnparm(j, parname, smearcat[j], STEPMN, 0,smearcatMax[j],ierflg);
}
fitpar[j] = smearcat[j]; //initialized values
}
for(int j=4; j<npar; j++){
TString parname = TString (Form("scalecat%d",j-4));
minuit->mnparm(j, parname, deltaEcat[j-4], STEPMN, -0.03,0.03,ierflg);
fitpar[j] = deltaEcat[j-4]; //initialized values
}
if(fixscale==1){
for(int j=4; j<npar; j++){
minuit->FixParameter(j);
}
}
if(testpaircat==1){
minuit->FixParameter(0);
minuit->FixParameter(2);
minuit->FixParameter(3);
minuit->FixParameter(4);
minuit->FixParameter(6);
minuit->FixParameter(7);
}else if( testpaircat==0){
minuit->FixParameter(1);
minuit->FixParameter(2);
minuit->FixParameter(3);
minuit->FixParameter(5);
minuit->FixParameter(6);
minuit->FixParameter(7);
} else if( testpaircat==2){
minuit->FixParameter(0);
minuit->FixParameter(1);
minuit->FixParameter(3);
minuit->FixParameter(4);
minuit->FixParameter(5);
minuit->FixParameter(7);
} else if( testpaircat==3){
minuit->FixParameter(0);
minuit->FixParameter(1);
minuit->FixParameter(2);
minuit->FixParameter(4);
minuit->FixParameter(5);
minuit->FixParameter(6);
}
arglist[0] = 0.0001;
minuit->mnexcm("SET EPS",arglist,1,ierflg);
//minuit->mnsimp();
////arglist[0] = 1;
///minuit->mnexcm("SET STR",arglist,1,ierflg);
//minuit->mnexcm("MIGRAD", arglist ,1,ierflg);
arglist[0] = fitstra;
minuit->mnexcm("SET STR",arglist,1,ierflg);
bool dofit = true;
if( dofit){
minuit->Migrad();
if (!minuit->fCstatu.Contains("CONVERGED")) {
mcfitStatus = 1; //first try not converged.
minuit->Migrad();
}else{
mcfitStatus = 0;
}
}
double ftest[1000];
double atest[1000];
//minuit->GetParameter(0,fitpar[0],fitparErr[0]);
if (!minuit->fCstatu.Contains("CONVERGED")) {
printf("No convergence at fitting, routine Fit \n");
printf("Minuit return string: %s \n",minuit->fCstatu.Data());
mcfitStatus = 2; //2nd try not converged.
}else{
mcfitStatus = -1;
}
fAmin = minuit->fAmin;
for(int j=0; j<npar; j++){
minuit->GetParameter(j,fitpar[j],fitparErr[j]);
mcfitpar[j] = fitpar[j];
mcfitparErr[j] = fitparErr[j];
}
double par[10];
for(int j=0;j<npar;j++){
par[j] = fitpar[j];
}
bool printScan = false;
//bool printScan = true;
par[0] = 0.0076;
if(printScan && testpaircat>=0){
double fmin = function2(par,true);
float x1 = fitpar[testpaircat] - 0.1;
float x2 = fitpar[testpaircat] + 0.1;
float teststep = 0.01;
if(smearMethod=="uncorrSmear"){
x1 = fitpar[testpaircat] - 0.005 >0 ? fitpar[testpaircat] - 0.005: 0;
x2 = fitpar[testpaircat] +0.005;
teststep = 0.001;
}
double dmin1 = 1;
double dmin2 = 1;
double fitparErrLow[10];
double fitparErrHigh[10];
int ntest = 0;
for(float x = x1; x <= x2; x += teststep){
cout<<"x " << x <<endl;
par[testpaircat] = x ;
//double f = function2(par,false);
double f = function2(par,true);
if(fabs(f-fmin-1)< dmin1 && x < fitpar[testpaircat]){
dmin1 = fabs(f-fmin-0.5);
fitparErrLow[testpaircat] = fitpar[testpaircat] -x;
}
if(fabs(f-fmin-1)< dmin2 && x > fitpar[testpaircat]){
dmin2 = fabs(f-fmin-0.5);
fitparErrHigh[testpaircat] = x-fitpar[testpaircat];
}
atest[ntest] = x;
ftest[ntest] = f;
ntest ++;
}
cout<<"fitpar[testpaircat]" << fitpar[testpaircat]<<" +/- "<<fitparErr[testpaircat]<<" - "<< fitparErrLow[testpaircat]<<" + "<< fitparErrHigh[testpaircat]<<endl;
TCanvas *can0 = new TCanvas("can0","c000",200,10,550,500);
setTCanvasNice(can0);
TGraph *gr = new TGraph(ntest,atest,ftest);
gr->Draw("ap");
//TF1 *ff = new TF1("ff","[0]+[1]*x+[2]*x*x",0,0.0);
//gr->Fit(ff,"r");
can0->Print("testconverge1.pdf");
can0->Print("testconverge1.C");
}
mytree->Fill();
mytree->Write();
fnew->Write();
fnew->Close();
}
// fit with 2 components
void fit_chi2_err_two_components(TH1F* dataInput, TH1F* sigTemplate, TH1F* bkgTemplate1,/* TH1F* bkgTemplate2,*/ std::string prefix,
Double_t& sigFrac, Double_t& sigFrac_intial , Double_t& sigFrac_err,
/*Double_t& bkg1Frac, Double_t& bkg1Frac_intial , Double_t& bkg1Frac_err,*/ Double_t& FitChi2)
/* fit with 3 components
void fit_chi2_err_manytimes(TH1F* dataInput, TH1F* sigTemplate, TH1F* bkgTemplate1, TH1F* bkgTemplate2, std::string prefix,
Double_t& sigFrac, Double_t& sigFrac_intial , Double_t& sigFrac_err,
Double_t& bkg1Frac, Double_t& bkg1Frac_intial , Double_t& bkg1Frac_err, Double_t& FitChi2)
*/
//void fit_chi2_err(TH1F* dataInput, TH1F* sigTemplate, TH1F* bkgTemplate, Double_t& sigFrac, Double_t& sigFrac_err)
//void fit_chi2_err(TH1F* dataInput, TH1F* sigTemplate, TH1F* bkgTemplate, Double_t& sigFrac, Double_t& sigFrac_err, Double_t& FitChi2)
{
gStyle->SetOptStat(kFALSE);
gStyle->SetCanvasColor(0);
gStyle->SetCanvasBorderMode(0);
gStyle->SetPadBorderMode(0);
gStyle->SetFrameBorderMode(0);
Double_t scale=1.;
data = (TH1D*)dataInput->Clone();
data->SetName("data");
data->SetLineColor(1);
data->SetMarkerColor(1);
data->SetXTitle("SigmaIetaIeta");
data->Sumw2();
// scale = 1.0/(Double_t)data->Integral(0,1000);
scale = 1.0/(Double_t)data->Integral();
// scale = 1.0/(Double_t)data->Integral();//changed by Yu-hsiang
//cout << "scale for data = " << scale << endl;
data->Scale(scale);
fit_result = (TH1D*)dataInput->Clone();
fit_result->SetName("fit_result");
fit_result->SetLineColor(8);
fit_result->SetMarkerColor(8);
fit_result->SetLineStyle(2);
fit_result->Sumw2();
fit_result->Reset();
signal_pos = (TH1D*)sigTemplate->Clone();
signal_pos->SetName("signal_pos");
signal_pos->SetLineColor(2);
signal_pos->SetMarkerColor(2);
signal_pos->SetFillColor(2);
signal_pos->SetXTitle("SigmaIetaIeta");
signal_pos->Sumw2();
// scale = 1.0/(Double_t)signal_pos->Integral(0,1000);
scale = 1.0/(Double_t)signal_pos->Integral();
// scale = 1.0/(Double_t)signal_pos->Integral();//changed by Yu-hsiang
//cout << "scale for signal template = " << scale << endl;
signal_pos->Scale(scale);
background_pos1 = (TH1D*)bkgTemplate1->Clone();
background_pos1->SetName("background_pos1");
background_pos1->SetLineColor(4);
background_pos1->SetMarkerColor(4);
background_pos1->SetFillColor(4);
background_pos1->SetXTitle("SigmaIetaIeta");
background_pos1->Sumw2();
// scale = 1.0/(Double_t)background_pos->Integral(0,1000);
scale = 1.0/(Double_t)background_pos1->Integral();
// scale = 1.0/(Double_t)background_pos->Integral();//changed by Yu-hsiang
//cout << "scale for background template = " << scale << endl;
background_pos1->Scale(scale);
/*
background_pos2 = (TH1D*)bkgTemplate2->Clone();
background_pos2->SetName("background_pos2");
background_pos2->SetLineColor(7);
background_pos2->SetMarkerColor(7);
background_pos2->SetFillColor(7);
background_pos2->SetXTitle("SigmaIetaIeta");
background_pos2->Sumw2();
scale = 1.0/(Double_t)background_pos2->Integral();
//cout << "scale for background template = " << scale << endl;
background_pos2->Scale(scale);
*/
////////// count the number of points and the dof
int Number_of_points =0 ;
// for (int i=1;i<2000;i++){ //the Sig or Bkg histo has 2000 bins
for (int i=1;i<= sigTemplate->GetNbinsX();i++){
if(/* ( ( bkgTemplate2->GetBinContent(i) ) != 0) ||*/ ( ( bkgTemplate1->GetBinContent(i) ) != 0) || ( ( sigTemplate->GetBinContent(i) ) != 0 ) ){
Number_of_points = Number_of_points+1;
}
}
//cout<<"Number_of_points:"<<Number_of_points<<endl;
int dof = Number_of_points-1 ;//dof=Number_of_points - free_par
//and in this case we normalize it so free_par =1
//cout<<"dof of this fit:"<<dof<<endl;
/////////
TMinuit *gMinuit = new TMinuit(1); // initialize TMinuit with a maximum of 1 params
// TMinuit *gMinuit = new TMinuit(2); //initialize TMinuit with a maximum of 5 (1param??) params
gMinuit->SetFCN(fcn); // sets function to minimize: fcn is Chi2 with errors on templates
Double_t arglist[10];
Int_t ierflg = 0; // status flag, it is 0 when ereything goes fine
// -- sets error
arglist[0] = 1;
gMinuit->mnexcm("SET ERR", arglist ,1,ierflg);
// set first parameter
Double_t vstart = sigFrac_intial;
//Double_t vstart = 0.48 ;//0.11;//intial value
Double_t step = 0.001;
gMinuit->mnparm(0, "fsig", vstart, step, 0,1,ierflg);
/*
// set second parameter
vstart = bkg1Frac_intial;
// vstart = 0.4; //0.69;//intial value
step = 0.001;
gMinuit->mnparm(1, "fbk1", vstart, step, 0,1,ierflg);
*/
// Now ready for minimization step
arglist[0] = 1000;
arglist[1] = 0.01;
gMinuit->mnexcm("MIGRAD", arglist ,2,ierflg);
Double_t fsig=0;
Double_t fsigerr=0;
Double_t fbk1=0;
// Double_t fbk1err=0;
Double_t chi2 = 0;
if ( ierflg == 0 )
{
// Print results
Double_t amin,edm,errdef;
Int_t nvpar,nparx,icstat;
gMinuit->mnstat(amin,edm,errdef,nvpar,nparx,icstat);
gMinuit->mnprin(3,amin);
chi2 = (gMinuit->fAmin)/dof;
gMinuit->GetParameter(0, fsig, fsigerr );
// gMinuit->GetParameter(1, fbk1, fbk1err );
//cout << "Fsig = " << fsig << " +- " << fsigerr << endl;
//cout << "Fbk1 = " << fbk1 << " +- " << fbk1err << endl;
//cout << "Chi2/degree of freedom = " << chi2 <<endl;
fbk1 = 1 - fsig ;
// TCanvas* c1 = new TCanvas("c1","",500,500);
TH2F *htmp2 = new TH2F("htmp2","",100, 0., 0.025, 100, 0., data->GetMaximum()*1.25);
htmp2->SetNdivisions(505,"XY");
htmp2->SetXTitle("SigmaIetaIeta");
htmp2->SetYTitle("A.U.");
htmp2->SetLineColor(1);
// htmp2->Draw();
TH1D* signal_display = (TH1D*)signal_pos->Clone();
signal_display->SetName("signal_display");
Double_t scale_sig = signal_display->Integral();
signal_display->Scale(fsig/scale_sig);
signal_display->SetFillStyle(3001);
TH1D* background_display1 = (TH1D*)background_pos1->Clone();
background_display1->SetName("background_display1");
Double_t scale_background1 = background_display1->Integral();
background_display1->Scale(fbk1/scale_background1);
background_display1->SetFillStyle(3001);
/*
TH1D* background_display2 = (TH1D*)background_pos2->Clone();
background_display2->SetName("background_display2");
Double_t scale_background2 = background_display2->Integral();
background_display2->Scale((1-fsig-fbk1)/scale_background2);
background_display2->SetFillStyle(3001);
*/
fit_result->GetXaxis()->SetRangeUser(100,600);
fit_result->GetYaxis()->SetRangeUser(0.,0.2);
fit_result->SetXTitle("mass of hadronic top");
// fit_result->SetXTitle("#sigma_{i#eta i#eta}");
fit_result->SetTitleSize(0.04,"X");
fit_result->GetXaxis()->SetLabelSize(0.04);
//fit_result->Draw("histe");
//data->Draw("esame");
//signal_display->Draw("histsame");
//background_display1->Draw("histsame");
//background_display2->Draw("histsame");
char result[300];
sprintf(result,"fsig = %.3lf #pm %.3lf",fsig,fsigerr );
sigFrac = fsig;
sigFrac_err = fsigerr ;
// bkg1Frac =fbk1;
// bkg1Frac_err =fbk1err;
FitChi2 = chi2;
TLegend* leg = new TLegend(0.9,0.6,0.6,0.9);
leg->SetHeader(result);
leg->SetFillColor(0);
leg->SetFillStyle(0);
leg->SetTextSize(0.035);
leg->SetBorderSize(0);
leg->AddEntry(data,"data");
leg->AddEntry(fit_result,"fit");
leg->AddEntry(signal_display,"signal template");
leg->AddEntry(background_display1,"background template1");
// leg->AddEntry(background_display2,"background template2");
//leg->Draw("same");
std::string outputFile = "plots_of_fit_results/"+ prefix + ".eps";
//c1->Print(outputFile.data());
// outputFile = prefix + ".gif";
outputFile = "plots_of_fit_results/"+ prefix + ".gif";
//c1->Print(outputFile.data());
outputFile = "plots_of_fit_results/"+ prefix + ".C";
//c1->Print(outputFile.data());
outputFile = "plots_of_fit_results/"+ prefix + ".pdf";
//c1->Print(outputFile.data());
}
else{
//cout << "Fit failed!\n";
sigFrac = 0;
sigFrac_err = 0;
}
return;
}
//___________________________________________________________________________
Double_t* Ifit( TFile* fin, std::string name, std::string output=".", std::string xTitle="", std::string yTitle="Events", int rebin=1, int channel=0, int fit_data=1 )
{
Double_t* fitted = new Double_t[8];
TCanvas *c1 = new TCanvas("HF1", "Histos1", 258,92,748,702);
c1->Range(-104.4905,-2560.33,537.9965,11563.46);
c1->SetFillColor(0);
c1->SetBorderMode(0);
c1->SetBorderSize(2);
c1->SetLeftMargin(0.1626344);
c1->SetRightMargin(0.05913978);
c1->SetTopMargin(0.05349183);
c1->SetBottomMargin(0.1812779);
c1->SetFrameBorderMode(0);
c1->SetFrameBorderMode(0);
double count=0;
dataColl.clear();
sigColl.clear();
bkgColl.clear();
totalColl.clear();
ctauColl.clear();
//Get data from looping tree
//TFile *fin = new TFile("results/15Dec_LepJet_MCDATA/Template_EvtChi2_Top_Hadronic_Mass.root");
//TFile *fin = new TFile("results/15Dec_LepJet_MCDATA/Template_EvtChi2_Top_Leptonic_Mbl.root");
// TH1D *hsig = new TH1D();
// TH1D *hbkg = new TH1D();
TH1D *hsig_toymc = new TH1D();
TH1D *hbkg_toymc = new TH1D();
char hname[30];
std::string ch;
if( channel == 1 )
ch="_El";
else if( channel == 2)
ch="_Mu";
else
ch="";
TH1D * hsig = (TH1D*)((TH1D*)fin->Get(("SigMC"+ch).c_str()))->Clone();
TH1D * hbkg = (TH1D*)((TH1D*)fin->Get(("BkgMC"+ch).c_str()))->Clone();
TH1D *hEGdata;
hEGdata = (TH1D*)((TH1D*)fin->Get(("DATA"+ch).c_str()))->Clone();
// hsig->Sumw2();
//hbkg->Sumw2();
// hsig->Rebin(2);
// hbkg->Rebin(2);
// hEGdata->Rebin(2);
// hbkg_toymc->Rebin(2);
// hsig_toymc->Rebin(2);
hsig->Rebin(rebin);
hbkg->Rebin(rebin);
hEGdata->Rebin(rebin);
// normalize template
hsig->Scale(1./hsig->Integral());
hbkg->Scale(1./hbkg->Integral());
if(fit_data==0){
hsig_toymc->Scale(1./hsig_toymc->Integral());
hbkg_toymc->Scale(1./hbkg_toymc->Integral());
}
TH1D *hsum = new TH1D();
int ntemplate = 1000.;
float sigfrac = 0.5;
TH1D *hsum_norm = new TH1D();
TH1D *hdata = new TH1D();
int ndata=0;
if ( fit_data>0 ) {
hdata = (TH1D*)hEGdata->Clone();
ndata = hdata->GetEntries();
}else { //generate toymc
hsum = (TH1D*)hsig_toymc->Clone();
hsum->Scale(toymc_sig);
hsum->Add(hbkg_toymc,toymc_bkg);
hsum_norm = (TH1D*)hsum->Clone();
hsum_norm->Scale(1./hsum->Integral());
hdata = (TH1D*)hsum_norm->Clone();
//ndata = (int) gRandom->Poisson(hsum->Integral());
ndata=toymc_sig+toymc_bkg;
hdata->FillRandom(hsum_norm, ndata);
}
if(ndata==0) {
printf(" --- no events in the fit \n");
fitted[0] = 0.;
fitted[1] = 0.;
fitted[2] = 0.;
fitted[3] = 0.;
fitted[4] = 0.;
fitted[5] = 0.;
fitted[6] = 0.;
fitted[7] = 0.;
fin_data->Close();
fin->Close();
fin_gjet6000->Close();
return fitted;
}
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, test sample size %4d\n", hsig->Integral()/hsum->Integral(), hsum->Integral(), ndata);
printf(" -------------------------------------- \n");
int nbins = hdata->GetNbinsX();
for (int ibin=1; ibin<=nbins; ibin++) {
dataColl.push_back(hdata->GetBinContent(ibin));
sigColl.push_back(hsig->GetBinContent(ibin));
bkgColl.push_back(hbkg->GetBinContent(ibin));
}
printf( " ----- Got %d, %d, %d events for fit ----- \n ", dataColl.size(), sigColl.size(), bkgColl.size() );
if ( dataColl.size() != sigColl.size() || sigColl.size()!=bkgColl.size() ) {
printf(" error ... inconsistent hit collection size \n");
fin_data->Close();
fin->Close();
fin_gjet6000->Close();
return fitted;
}
//--------------------------------------------------
//init parameters for fit
Double_t vstart[10] = {1., 1.};
vstart[0] = sigfrac*ndata;
vstart[1] = (1-sigfrac)*ndata;
TMinuit *gMinuit = new TMinuit(NPAR);
gMinuit->Command("SET STR 1");
gMinuit->SetFCN(fcn);
Double_t arglist[10];
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[] = { 0.1, 0.1,};
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);
printf(" --------------------------------------------------------- \n");
printf(" Now ready for minimization step \n --------------------------------------------------------- \n");
arglist[0] = 2000; // number of iteration
arglist[1] = 1.;
gMinuit->mnexcm("MIGRAD", arglist ,2,ierflg);
printf (" -------------------------------------------- \n");
printf("Finished. ierr = %2.2f \n", ierflg);
info.clear();
info_err.clear();
double para[NPAR+1],errpara[NPAR+1];
if ( ierflg == 0 )
{
for(int j=0; j<=NPAR-1;j++) {
gMinuit->GetParameter(j, para[j],errpara[j]);
para[NPAR] = dataColl.size();
info.push_back(para[j]);
info_err.push_back(errpara[j]);
printf("Parameter (yeild) %d = %f +- %f\n",j,para[j],errpara[j]);
}
printf(" fitted yield %2.3f \n", (para[0]+para[1])/ndata );
info.push_back(sigColl.size());
//do minos if fit sucessed.
// printf(" ---------------------------------------------------------\n");
// printf(" Now call for minos step \n");
// printf(" ---------------------------------------------------------\n");
// arglist[0] = 200; // number of iteration
// arglist[1] = 1;
// gMinuit->mnexcm("MINOS", arglist ,2,ierflg);
// printf(" --------------------------------------------------------- \n");
// printf(" Done Minos. ierr = %d \n", ierflg);
// Double_t amin;
// gMinuit->mnprin(1,amin);
}
else {
printf(" *********** Fit failed! ************\n");
gMinuit->GetParameter(0, para[0],errpara[0]);
gMinuit->GetParameter(1, para[1],errpara[1]);
para[0]=0.; errpara[0]=0.;
}
// 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);
double yerr[100];
for(int i=0;i<100;i++){
yerr[i] = 0.;
}
hsig->Scale(para[0]);
hbkg->Scale(para[1]);
TH1D *hfit = (TH1D*)hbkg->Clone();
hfit->Add(hsig);
hsig->SetLineColor(4);
hsig->SetLineWidth(2);
// hsig->SetFillColor(5);
// hsig->SetFillStyle(3001);
// hbkg->SetLineWidth(2);
// plot
c1->Draw();
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
//gPad->SetLogy();
hdata->SetLineColor(1);
hdata->SetXTitle(xTitle.c_str());
hdata->SetYTitle(yTitle.c_str());
hdata->SetTitle("");
hdata->SetMarkerStyle(8);
hdata->SetMinimum(0.);
hdata->GetXaxis()->SetNdivisions(505);
hdata->GetXaxis()->SetLabelFont(42);
hdata->GetXaxis()->SetLabelSize(0.05);
hdata->GetXaxis()->SetTitleSize(0.06);
hdata->GetXaxis()->SetTitleOffset(1.15);
hdata->GetXaxis()->SetTitleFont(42);
hdata->GetYaxis()->SetNdivisions(505);
hdata->GetYaxis()->SetLabelFont(42);
hdata->GetYaxis()->SetLabelSize(0.035);
hdata->GetYaxis()->SetTitleSize(0.06);
hdata->GetYaxis()->SetTitleOffset(1.21);
hdata->GetYaxis()->SetTitleFont(42);
float ymax = hdata->GetMaximum();
if ( hfit->GetMaximum() > hdata->GetMaximum() ) ymax = hfit->GetMaximum();
if ( hdata->GetMaximum() < 15 ) ymax = 15;
hdata->SetMaximum(ymax*1.4);
hfit->SetMaximum(ymax*1.4);
hsig->SetMaximum(ymax*1.4);
hbkg->SetMaximum(ymax*1.4);
hdata->Draw("p e");
hbkg->SetMarkerStyle(0);
hbkg->SetFillColor(2);
hbkg->SetLineWidth(1);
hbkg->SetLineColor(2);
hbkg->SetFillStyle(3005);
hbkg->SetError(yerr);
hbkg->Draw("h same");
hsig->SetMarkerStyle(0);
hsig->SetError(yerr);
hsig->Draw("h same");
hfit->SetMarkerStyle(0);
hfit->SetLineColor(1);
hfit->SetLineWidth(2);
hfit->SetError(yerr);
//printf("nbins hfit %d \n", hfit->GetNbinsX());
hfit->Draw("h same");
hdata->Draw("p e same");
TLegend *tleg = new TLegend(0.5241935,0.6344725,0.8682796,0.9331352,NULL,"brNDC");
char text[50];
sprintf(text,"Top Mass");
//tleg->SetHeader(text);
tleg->SetBorderSize(0);
tleg->SetTextSize(0.03120357);
tleg->SetLineColor(1);
tleg->SetLineStyle(1);
tleg->SetLineWidth(1);
tleg->SetFillColor(0);
tleg->SetFillStyle(0);
sprintf(text,"Data %5.1f events",hdata->Integral());
tleg->AddEntry(hdata,text,"pl");
sprintf(text,"Fitted %5.1f events",hfit->Integral());
tleg->AddEntry(hfit,text,"l");
sprintf(text,"SIG %5.1f #pm %5.1f events",para[0], errpara[0]);
tleg->AddEntry(hsig,text,"f");
sprintf(text,"BKG %5.1f #pm %5.1f events",para[1], errpara[1]);
tleg->AddEntry(hbkg,text,"f");
tleg->Draw();
TLatex *tlx = new TLatex(6.247421e-06,9218.143,"CMS #sqrt{s} = 8TeV, L=19.7 fb^{-1}");
tlx->SetTextSize(0.035);
tlx->SetLineWidth(2);
tlx->Draw();
//gPad->RedrawAxis();
if(fit_data>0) hdata->Chi2Test(hfit,"P");
c1->SaveAs((output+"/FittingResults_"+name+ch+".pdf").c_str());
return fitted;
// float sig_part = hsig->Integral(ibin1,hfit->GetNbinsX());
// float sig_part_err = hsig->Integral(ibin1,hfit->GetNbinsX())*errpara[0]/para[0];
// float bkg_part = hbkg->Integral(ibin1,hfit->GetNbinsX());
// float bkg_part_err = hbkg->Integral(ibin1,hfit->GetNbinsX())*errpara[1]/para[1];
// printf("%s Data %5.1f events, fitted %5.1f\n", EBEE, hdata->Integral(), hfit->Integral());
// printf("%s Data %5.1f, and fitted (in 5GeV) %5.1f events \n", EBEE, hdata->Integral(ibin1,hfit->GetNbinsX()), hfit->Integral(ibin1,hfit->GetNbinsX()));
// printf("%s SIG %5.1f #pm %5.1f events \n", EBEE, para[0], errpara[0]);
// printf("%s SIG (in 5GeV) %5.1f #pm %5.1f events \n", EBEE, sig_part, sig_part_err);
// printf("%s BKG %5.1f #pm %5.1f events \n", EBEE, para[1], errpara[1]);
// printf("%s BKG (in 5GeV) %5.1f #pm %5.1f events \n", EBEE, bkg_part, bkg_part_err);
// char fname[30];
// sprintf(fname,"plots/test_Ifit%s_%d_%d.pdf",EBEE, jetbin, ptbin);
// printf("----- fit results with signal projection ----------- \n");
// if(fit_data>0) hdata->Chi2Test(hfit,"P");
// //ftemplate->Close();
// fitted[0] = para[0];
// fitted[1] = errpara[0]/TMath::Sqrt(2);
// fitted[2] = para[1];
// if (fit_data==2 ) fitted[2] += hdata->GetBinContent(hdata->GetNbinsX()+1);
// fitted[3] = errpara[1]/TMath::Sqrt(2);
// fitted[4] = sig_part;
// fitted[5] = sig_part_err/TMath::Sqrt(2);
// fitted[6] = bkg_part;
// fitted[7] = bkg_part_err/TMath::Sqrt(2);
// if(fit_data==0){
// fin_filter->Close();
// fin_data->Close();
// fin->Close();
// fin_gjet6000->Close();
// fin_DYMC->Close();
// fin_DYData->Close();
// fin_WJetMC->Close();
// fin_WJetData->Close();
// fin_WJetTemplate->Close();
// fin_WJetTemplate_alt->Close();
// }
return fitted;
}
// -- main function
void fit_chi2(TH1D* dataInput, TH1D* sigTemplate, TH1D* bkgTemplate, std::string prefix, Double_t& sigFrac, Double_t& sigFrac_err)
{
gStyle->SetOptStat(kFALSE);
gStyle->SetCanvasColor(0);
gStyle->SetCanvasBorderMode(0);
gStyle->SetPadBorderMode(0);
gStyle->SetFrameBorderMode(0);
Double_t scale=1.;
data = (TH1D*)dataInput->Clone();
data->SetName("data");
data->SetLineColor(1);
data->SetMarkerColor(1);
data->SetXTitle("Fisher's isolation [GeV]");
data->Sumw2();
scale = 1.0/(Double_t)data->Integral(0,1000);
cout << "scale for data = " << scale << endl;
data->Scale(scale);
fit_result = (TH1D*)dataInput->Clone();
fit_result->SetName("fit_result");
fit_result->SetLineColor(8);
fit_result->SetMarkerColor(8);
fit_result->SetLineStyle(2);
fit_result->Sumw2();
fit_result->Reset();
signal_pos = (TH1D*)sigTemplate->Clone();
signal_pos->SetName("signal_pos");
signal_pos->SetLineColor(2);
signal_pos->SetMarkerColor(2);
signal_pos->SetFillColor(2);
signal_pos->SetXTitle("Fisher's isolation [GeV]");
signal_pos->Sumw2();
scale = 1.0/(Double_t)signal_pos->Integral(0,1000);
cout << "scale for signal template = " << scale << endl;
signal_pos->Scale(scale);
background_pos = (TH1D*)bkgTemplate->Clone();
background_pos->SetName("background_pos");
background_pos->SetLineColor(4);
background_pos->SetMarkerColor(4);
background_pos->SetFillColor(4);
background_pos->SetXTitle("Fisher's isolation [GeV]");
background_pos->Sumw2();
scale = 1.0/(Double_t)background_pos->Integral(0,1000);
cout << "scale for background template = " << scale << endl;
background_pos->Scale(scale);
TMinuit *gMinuit = new TMinuit(1); //initialize TMinuit with a maximum of 5 (1param??) params
gMinuit->SetFCN(fcn); // sets function to minimize: fcn is Chi2 with errors on templates
Double_t arglist[10];
Int_t ierflg = 0; // status flag, it is 0 when ereything goes fine
// -- sets error
arglist[0] = 1;
gMinuit->mnexcm("SET ERR", arglist ,1,ierflg);
Double_t vstart = 0.5;
Double_t step = 0.001;
gMinuit->mnparm(0, "fsig", vstart, step, 0,1,ierflg);
// Now ready for minimization step
arglist[0] = 1000;
arglist[1] = 0.01;
gMinuit->mnexcm("MIGRAD", arglist ,2,ierflg);
Double_t fsig=0;
Double_t fsigerr=0;
Double_t chi2 = 0;
if ( ierflg == 0 )
{
// Print results
Double_t amin,edm,errdef;
Int_t nvpar,nparx,icstat;
gMinuit->mnstat(amin,edm,errdef,nvpar,nparx,icstat);
gMinuit->mnprin(3,amin);
chi2 = gMinuit->fAmin;
gMinuit->GetParameter(0, fsig, fsigerr);
cout << "Fsig = " << fsig << " +- " << fsigerr << endl;
TCanvas* c1 = new TCanvas("c1","",500,500);
data->Draw();
TH1D* signal_display = (TH1D*)signal_pos->Clone();
signal_display->SetName("signal_display");
signal_display->Scale(fsig/signal_display->Integral(0,1000));
signal_display->SetFillStyle(3001);
signal_display->Draw("histsame");
TH1D* background_display = (TH1D*)background_pos->Clone();
background_display->SetName("background_display");
background_display->Scale((1-fsig)/background_display->Integral(0,1000));
background_display->SetFillStyle(3001);
background_display->Draw("histsame");
fit_result->Draw("histesame");
char result[300];
sprintf(result,"fsig = %.3lf #pm %.3lf",fsig,fsigerr);
sigFrac = fsig;
sigFrac_err = fsigerr;
TLegend* leg = new TLegend(0.2,0.6,0.4,0.9);
leg->SetHeader(result);
leg->SetFillColor(0);
leg->SetFillStyle(0);
leg->SetTextSize(0.045);
leg->SetBorderSize(0);
leg->AddEntry(data,"data");
leg->AddEntry(fit_result,"fit");
leg->AddEntry(signal_display,"signal template");
leg->AddEntry(background_display,"background template");
leg->Draw("same");
std::string outputFile = prefix + ".eps";
c1->Print(outputFile.data());
outputFile = prefix + ".gif";
c1->Print(outputFile.data());
outputFile = prefix + ".C";
c1->Print(outputFile.data());
}
else{
cout << "Fit failed!\n";
sigFrac = 0;
sigFrac_err = 0;
}
return;
}
//___________________________________________________________________________
Double_t* IfitBin(TH1F* dataInput, TH1F* sigTemplate, TH1F* bkgTemplate,
int fit_data=1)
{
cout << "Input files are " << dataInput->GetName() << "\t" << sigTemplate->GetName() << "\t" << bkgTemplate->GetName() << endl;
TCanvas *c1 = new TCanvas("HF1", "Histos1", 0, 0, 600, 600);
dataCollBin.clear();
sigCollBin.clear();
bkgCollBin.clear();
Double_t* fitted = new Double_t[8];
fitted[0] = fitted[1] = fitted[2] = fitted[3] = fitted[4] = fitted[5] = fitted[6] = fitted[7] = 0.0;
TH1F *hsum = new TH1F();
float ntemplate = 1.;
float sigfrac = 0.1;
TH1F *hsum_norm = new TH1F();
TH1F *hdata;
TH1F *hsig = (TH1F*)sigTemplate->Clone();
hsig->SetName("hsig");
hsig->Rebin(6);
TH1F *hbkg = (TH1F*)bkgTemplate->Clone();
hbkg->SetName("hbkg");
hbkg->Rebin(6);
float ndata=0;
if ( fit_data>0 ) {
hdata = (TH1F*)dataInput->Clone();
hdata -> SetName("hdata");
ndata = hdata->Integral();
}else {
hsum = (TH1F*)hsig->Clone();
hsum->Add(hbkg,1);
cout << "For histogram " << sigTemplate->GetName() << " and " << bkgTemplate->GetName() << " sum = " <<
hsum->Integral() << endl;
if (hsum->Integral()>1.) ntemplate = hsum->Integral();
sigfrac = hsig->Integral()/ntemplate;
hsum_norm = (TH1F*)hsum->Clone();
hsum_norm->Scale(1./hsum->Integral());
hdata = (TH1F*)hsum_norm->Clone();
hdata -> SetName("hdata");
ndata=ntemplate;
hdata->FillRandom(hsum_norm, ndata);
}
if(ndata==0) {
printf(" --- no events in the fit \n");
return fitted;
}
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, test sample size %4d\n", hsig->Integral()/hsum->Integral(), hsum->Integral(), ndata);
printf(" -------------------------------------- \n");
hdata->Rebin(6);
int nbins = hdata->GetNbinsX();
hsig->Scale(1./hsig->Integral());
hbkg->Scale(1./hbkg->Integral());
for (int ibin=1; ibin<=nbins; ibin++) {
dataCollBin.push_back(hdata->GetBinContent(ibin));
sigCollBin.push_back(hsig->GetBinContent(ibin));
bkgCollBin.push_back(hbkg->GetBinContent(ibin));
}
printf( " ----- Got %d, %d, %d events for fit ----- \n ", dataCollBin.size(),
sigCollBin.size(), bkgCollBin.size() );
if ( dataCollBin.size() != sigCollBin.size() || sigCollBin.size()!=bkgCollBin.size() ) {
printf(" error ... inconsistent hit collection size \n");
return fitted;
}
//--------------------------------------------------
//init parameters for fit
Double_t vstart[10] = {1., 1.};
vstart[0] = sigfrac*ndata;
vstart[1] = (1-sigfrac)*ndata;
TMinuit *gMinuit = new TMinuit(NPARBIN);
gMinuit->Command("SET STR 1");
gMinuit->SetFCN(fcnBin);
Double_t arglist[10];
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[] = { 0.1, 0.1,};
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);
printf(" --------------------------------------------------------- \n");
printf(" Now ready for minimization step \n --------------------------------------------------------- \n");
arglist[0] = 2000; // number of iteration
arglist[1] = 1.;
gMinuit->mnexcm("MIGRAD", arglist ,2,ierflg);
printf (" -------------------------------------------- \n");
printf("Finished. ierr = %d \n", ierflg);
infoBin.clear();
infoBin_err.clear();
double para[NPARBIN+1],errpara[NPARBIN+1];
if ( ierflg == 0 )
{
for(int j=0; j<=NPARBIN-1;j++) {
gMinuit->GetParameter(j, para[j],errpara[j]);
para[NPARBIN] = dataCollBin.size();
infoBin.push_back(para[j]);
infoBin_err.push_back(errpara[j]);
printf("Parameter (yeild) %d = %f +- %f\n",j,para[j],errpara[j]);
}
printf(" fitted yield %2.3f \n", (para[0]+para[1])/ndata );
infoBin.push_back(sigCollBin.size());
}
else {
printf(" *********** Fit failed! ************\n");
gMinuit->GetParameter(0, para[0],errpara[0]);
gMinuit->GetParameter(1, para[1],errpara[1]);
para[0]=0.; errpara[0]=0.;
}
// 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);
double yerr[20];
for(int i=0;i<20;i++){
yerr[i] = 0.;
}
hsig->Scale(para[0]);
hbkg->Scale(para[1]);
TH1F *hfit = (TH1F*)hsig->Clone();
hfit->Add(hbkg);
hsig->SetLineColor(1);
hsig->SetFillColor(5);
hsig->SetFillStyle(3001);
hbkg->SetLineWidth(2);
// plot
c1->Draw();
//gPad->SetLogy();
hdata->SetLineColor(1);
hdata->SetNdivisions(505,"XY");
hdata->SetXTitle("Iso_{ECAL}+Iso_{HCAL}+Iso_{TRK} (GeV)");
hdata->SetYTitle("Entries");
hdata->SetTitle("");
hdata->SetMarkerStyle(8);
hdata->SetMinimum(0.);
hdata->SetMaximum(hdata->GetMaximum()*1.5);
hdata->Draw("p e");
hsig->Draw("hist same");
hbkg->SetMarkerStyle(0);
hbkg->SetFillColor(8);
hbkg->SetLineWidth(1);
hbkg->SetFillStyle(3013);
hbkg->SetError(yerr);
hbkg->Draw("hist same");
hfit->SetMarkerStyle(0);
hfit->SetLineColor(1);
hfit->SetLineWidth(2);
hfit->SetError(yerr);
hfit->Draw("hist same");
double chi2ForThisBin=0;
int nbinForThisBin=0;
chi2NbinsHisto(hfit, hdata, chi2ForThisBin, nbinForThisBin);
TPaveText *pavetex = new TPaveText(0.43, 0.87, 0.90, 0.92,"NDCBR");
pavetex->SetBorderSize(0);
pavetex->SetFillColor(0);
pavetex->SetFillStyle(0);
pavetex->SetLineWidth(3);
pavetex->SetTextAlign(12);
pavetex->SetTextSize(0.03);
pavetex->AddText(Form("#chi^{2}/NDF=%.1f/%d",chi2ForThisBin, nbinForThisBin));
pavetex->Draw();
char text[1000];
TLegend *tleg = new TLegend(0.43, 0.60, 0.90, 0.87);
tleg->SetHeader(dataInput->GetTitle());
tleg->SetTextSize(0.03);
tleg->SetFillColor(0);
tleg->SetShadowColor(0);
tleg->SetBorderSize(0);
sprintf(text,"Data %5.1f events",hdata->Integral());
tleg->AddEntry(hdata,text,"pl");
sprintf(text,"Fitted %5.1f events",hfit->Integral());
tleg->AddEntry(hfit,text,"l");
sprintf(text,"SIG %5.1f #pm %5.1f events",para[0], errpara[0]);
tleg->AddEntry(hsig,text,"f");
sprintf(text,"BKG %5.1f #pm %5.1f events",para[1], errpara[1]);
tleg->AddEntry(hbkg,text,"f");
tleg->Draw();
gPad->RedrawAxis();
cout << dataInput->GetName() << endl;
char fname[300];
sprintf(fname,"plots/Ifit_%s.eps",dataInput->GetName());
c1->SaveAs(fname);
sprintf(fname,"plots/Ifit_%s.gif",dataInput->GetName());
c1->SaveAs(fname);
printf("----- fit results with signal projection ----------- \n");
// ftemplate->Close();
int purityMaxBin = hsig->FindBin(5.0)-1;
Double_t scale_signal = hsig->Integral(1,purityMaxBin)/hsig->Integral();
Double_t scale_background = hbkg->Integral(1,purityMaxBin)/hbkg->Integral();
fitted[0] = para[0];
fitted[1] = errpara[0];
fitted[2] = para[1];
fitted[3] = errpara[1];
// for integral up to 5 GeV
fitted[4] = para[0]*scale_signal;
fitted[5] = errpara[0]*scale_signal;
fitted[6] = para[1]*scale_background;
fitted[7] = errpara[1]*scale_background;
return fitted;
}
//___________________________________________________________________________
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 hrstrans3(){
// LeRose SNAKE scaled by 1.4
THRSTrans *trans = new THRSTrans( 0.1746, -0.1385, -0.1281, 0.050178, 0.037056, THRSTrans::kStd);
//
//
// // Fit to data optics
// THRSTrans *trans = new THRSTrans( 0.178259, -0.137781, -0.128674, 0.050178, 0.037056, THRSTrans::kStd);
/*
// trans->GetElement(5)->Print();
trans->ShowOutput();
trans->ShowAcc();
trans->ShowFocalLengths();
return;
*/
// LeRose Translated Numbers
//THRSTrans *trans = new THRSTrans( 0.1861, -0.1415, -0.1375, 0.5, 0.5, THRSTrans::kStd);
// trans->ShowOutput();
// return;
// LeRose Numbers Fit to Transport matrix elements, PREX
// THRSTrans *trans = new THRSTrans( 1.34761e-01, -1.38523e-01, -2.13742e-01, 0.02075 };
//
//
// THRSTrans *trans = new THRSTrans( 1.344e-01, -1.431e-01, -1.855e-01, 0.005763, 0.000014, THRSTrans::kPREX);
// trans->SetSeptumPsi( 1.22603, 0.929424);
// HRS Database fit forcing
// THRSTrans *trans = new THRSTrans( 1.38796e-01, -1.39940e-01, -1.73034e-01, 0.02075, THRSTrans::kPREX);
// trans->ShowOutput(4);
// trans->ShowOutput();
// trans->ShowFocalLengths();
// trans->ShowAcc();
// return;
TMinuit *gMinuit = new TMinuit(5);
gMinuit->SetFCN(fcn);
Double_t arglist[10];
Int_t ierflg = 0;
arglist[0] = 1;
gMinuit->mnexcm("SET ERR", arglist ,1,ierflg);
Double_t vstart[5] = {
// Standard tune from data
0.178615, -0.137474, -0.128384, 0.043667, 0.036814};
//PREX Tune
Double_t step[5] = {0.001 , 0.001 , 0.001, 0.001, 0.001};
gMinuit->mnparm(0, "q1", vstart[0], step[0], 0,0,ierflg);
gMinuit->mnparm(1, "q2", vstart[1], step[1], 0,0,ierflg);
gMinuit->mnparm(2, "q3", vstart[2], step[2], 0, 0,ierflg);
gMinuit->mnparm(3, "K1", vstart[3], step[3], 0.0,1.5,ierflg);
gMinuit->mnparm(4, "K2", vstart[4], step[4], 0.0,1.5,ierflg);
arglist[0] = 5000;
arglist[1] = 1.;
gMinuit->mnexcm("SIMPLEX", arglist ,2,ierflg);
Double_t amin,edm,errdef;
Int_t nvpar,nparx,icstat;
gMinuit->mnstat(amin,edm,errdef,nvpar,nparx,icstat);
gMinuit->mnimpr();
gMinuit->mnimpr();
double q1, q2, q3, psi1, psi2, e1;
gMinuit->GetParameter(0, q1, e1);
gMinuit->GetParameter(1, q2, e1);
gMinuit->GetParameter(2, q3, e1);
gMinuit->GetParameter(3, psi1, e1);
gMinuit->GetParameter(4, psi2, e1);
THRSTrans *result = new THRSTrans( q1, q2, q3, psi1, psi2);
result->ShowOutput();
result->GetOptics()->Print();
result->ShowAcc();
result->ShowFocalLengths();
return;
}
void testEnergySmearZee(int barrelorEndcap=1, int energyRegrVer = 0, int test_eleID = 2, int testcat=-1 ,int fixscale = 1,
double test_fitlow = 70, double test_fithigh = 110, double test_binwidth = 0.5, int test_Ntrial=50){
Ntrial = test_Ntrial;
eleID = test_eleID;
test_cat = testcat;
fitrangeLow = test_fitlow;
fitrangeHigh = test_fithigh;
binwidth = test_binwidth;
TString inputdatafile = "/afs/cern.ch/work/s/sixie/public/LeptonScaleAndResolution/ZeeEvents/ZeeNtuple_HCP2012.root";
TString inputmcfile = "/afs/cern.ch/work/s/sixie/public/LeptonScaleAndResolution/ZeeEvents/ZeeNtuple_Summer12DY53X.root";
TString filename = TString(Form("testEnergySmearZee_barend%d_regver%d_eleID%d_fitrange%dto%d_binwidth%2.2f_Ntrial%d.root",barrelorEndcap,energyRegrVer,eleID,
int(fitrangeLow+0.1),int(fitrangeHigh+0.1),binwidth, Ntrial));
TFile *fnew = new TFile(filename,"recreate");
nbins = int( (fitrangeHigh-fitrangeLow)/binwidth+0.1);
for(int j=0; j<10; j++){
TString histname = TString(Form("th1f_Mee_data_%d",j));
th1f_Mee_data[j] =new TH1F(histname,histname,nbins,fitrangeLow,fitrangeHigh);
histname = TString(Form("th1f_Mee_mc0_%d",j));
th1f_Mee_mc0[j] =new TH1F(histname,histname,nbins,fitrangeLow,fitrangeHigh);
}
fChainData = new TChain("ZeeEvent");
fChainMC = new TChain("ZeeEvent");
//data
fChainData->Add(inputdatafile);
fChainMC->Add(inputmcfile);
setbranchaddress();
int totalEntriesMC = fChainMC->GetEntries();
int totalEntriesData = fChainData->GetEntries();
cout<<" totalEntriesMC /data " << totalEntriesMC << " "<< totalEntriesData <<endl;
//totalEntriesData = 1E6;
load_energyScaleCorrection_eta_RunByRun();
load_energyScaleCorrection_etaR9bin();
cout<< " fill data histograms " <<endl;
for(int entry=0; entry< totalEntriesData; entry++){
fChainData->GetEntry(entry);
if(entry%100000==0) cout<<"entry " << entry <<endl;
if(barrelorEndcap==1 && (fabs(Ele1SCEta)>1.49 || fabs(Ele2SCEta)>1.49)) continue;
if(barrelorEndcap==2 && (fabs(Ele1SCEta)<1.49 || fabs(Ele2SCEta)<1.49)) continue;
///
if(eleID==1 || eleID==2){
if( Ele1PassMediumSimpleCuts ==0 || Ele2PassMediumSimpleCuts == 0) continue;
}
//here missing run-by-run corrections. TBD
int sccat1 = scCategoryEight(Ele1SCEta,Ele1R9);
int sccat2 = scCategoryEight(Ele2SCEta,Ele2R9);
if( barrelorEndcap==2){
sccat1 -=4;
sccat2 -=4;
}
int mcat = MeesmearCategory(sccat1,sccat2);
if(testcat >=0 && testcat != mcat) continue;
float e1 = Ele1Energy;
float e2 = Ele2Energy;
if(energyRegrVer==0){
e1 = Ele1EnergyRegressionV0;
e2 = Ele2EnergyRegressionV0;
} else if(energyRegrVer==1){
e1 = Ele1EnergyRegressionV1;
e2 = Ele2EnergyRegressionV1;
} else if(energyRegrVer==2){
e1 = Ele1EnergyRegressionV2;
e2 = Ele2EnergyRegressionV2;
}
float corr1 = energyScaleCorrection_eta_RunByRun(Ele1SCEta,run);
e1 *= ( 1- corr1);
float corr2 = energyScaleCorrection_eta_RunByRun(Ele2SCEta,run);
e2 *= ( 1- corr2);
corr1 = energyScaleCorrection_etaR9bin(Ele1SCEta,Ele1R9);
e1 *= (1-corr1);
corr2 = energyScaleCorrection_etaR9bin(Ele2SCEta,Ele2R9);
e2 *= (1-corr2);
float et1 = e1 * sin(2*atan(exp(-Ele1Eta)));
float et2 = e2 * sin(2*atan(exp(-Ele2Eta)));
if(eleID==1){
if(et1<15 || et2 <15) continue;
}
if(eleID==2){
if(et1<20 || et2 <20) continue;
}
float mee = calcZmass(e1,Ele1Eta,Ele1Phi,e2,Ele2Eta,Ele2Phi);
th1f_Mee_data[mcat]->Fill(mee);
}
//totalEntriesMC = 1E6;
int nMC = 0;
///MC
for(int entry=0; entry< totalEntriesMC; entry++){
fChainMC->GetEntry(entry);
if(entry%100000==0) cout<<"entry " << entry <<endl;
if( event%2==0) continue; ///used for training.
if(barrelorEndcap==1 && (fabs(Ele1SCEta)>1.49 || fabs(Ele2SCEta)>1.49)) continue;
if(barrelorEndcap==2 && (fabs(Ele1SCEta)<1.49 || fabs(Ele2SCEta)<1.49)) continue;
///
if(eleID==1 || eleID==2){
if( Ele1PassMediumSimpleCuts ==0 || Ele2PassMediumSimpleCuts == 0) continue;
}
int sccat1 = scCategoryEight(Ele1SCEta,Ele1R9);
int sccat2 = scCategoryEight(Ele2SCEta,Ele2R9);
if( barrelorEndcap==2){
sccat1 -=4;
sccat2 -=4;
}
int mcat = MeesmearCategory(sccat1,sccat2);
if(testcat >=0 && testcat != mcat) continue;
nMC ++;
float e1 = Ele1Energy;
float e2 = Ele2Energy;
if(energyRegrVer==0){
e1 = Ele1EnergyRegressionV0;
e2 = Ele2EnergyRegressionV0;
} else if(energyRegrVer==1){
e1 = Ele1EnergyRegressionV1;
e2 = Ele2EnergyRegressionV1;
} else if(energyRegrVer==2){
e1 = Ele1EnergyRegressionV2;
e2 = Ele2EnergyRegressionV2;
}
float mee = calcZmass(e1,Ele1Eta,Ele1Phi,e2,Ele2Eta,Ele2Phi);
v_e1.push_back(e1);
v_e2.push_back(e2);
v_sc1cat.push_back(sccat1);
v_sc2cat.push_back(sccat2);
v_mee.push_back(mee);
v_mcat.push_back(mcat);
v_wt.push_back(weight);
v_e1eta.push_back(Ele1Eta);
v_e2eta.push_back(Ele2Eta);
float et1 = e1 * sin(2*atan(exp(-Ele1Eta)));
float et2 = e2 * sin(2*atan(exp(-Ele2Eta)));
if(eleID==1){
if(et1<15 || et2 <15) continue;
}
if(eleID==2){
if(et1<20 || et2 <20) continue;
}
th1f_Mee_mc0[mcat]->Fill(mee,weight);
}
cout<<"mc "<< th1f_Mee_mc0[0]->GetEntries()<<" " << th1f_Mee_mc0[0]->Integral()<<endl;
Nrand = Ntrial * nMC;
cout<<"filling random " << Ntrial * nMC <<endl;
grand = new TRandom3(12345);
for(int j=0; j< Nrand; j++){
v_rand1.push_back( grand->Gaus() );
v_rand2.push_back( grand->Gaus() );
}
// par_fit[0] = 0.005;
// for(int j=0;j<10;j++){
// function(par_fit);
// par_fit[0] += 0.0005;
// }
TTree *mytree = new TTree("Analysis","");
float mcfitpar[8] = {0};
float mcfitparErr[8] = {0};
int mcfitStatus;
float fAmin;
mytree->Branch("mcfitpar",mcfitpar,"mcfitpar[8]/F");
mytree->Branch("mcfitparErr",mcfitparErr,"mcfitparErr[8]/F");
mytree->Branch("mcfitStatus",&mcfitStatus,"mcfitStatus/I");
mytree->Branch("fAmin",&fAmin,"fAmin/F");
//return;
TMinuit *minuit;
int npar = 8;
minuit = new TMinuit(npar);
minuit->SetFCN(fcn);
//settings
Double_t arglist[1];
Int_t ierflg = 0;
//double STEPMN = 0.01;
double STEPMN = 0.0001;
double fitpar[10];
double fitparErr[10];
double smearcat[4] = {0.02,0.02,0.02,0.02};
double smearcatMax[4] = {0.1,0.1,0.1,0.1};
double deltaEcat[4] = {0,0,0,0};
smearcatMax[0] = 0.05;
smearcatMax[1] = 0.05;
smearcatMax[2] = 0.05;
smearcatMax[3] = 0.05;
smearcat[0] = 0.005;
smearcat[1] = 0.01;
smearcat[2] = 0.015;
smearcat[3] = 0.02;
if(barrelorEndcap==2){
smearcat[0] = 0.02;
smearcat[1] = 0.02;
smearcat[2] = 0.02;
smearcat[3] = 0.02;
}
for(int j=0; j<4; j++){
TString parname = TString (Form("smearcat%d",j));
minuit->mnparm(j, parname, smearcat[j], STEPMN, 0,smearcatMax[j],ierflg);
fitpar[j] = smearcat[j]; //initialized values
}
for(int j=4; j<npar; j++){
TString parname = TString (Form("scalecat%d",j-4));
minuit->mnparm(j, parname, deltaEcat[j-4], STEPMN, -0.03,0.03,ierflg);
fitpar[j] = deltaEcat[j-4]; //initialized values
}
if(fixscale==1){
for(int j=4; j<npar; j++){
minuit->FixParameter(j);
}
}
int testpaircat = testcat;
if(testpaircat==1){
minuit->FixParameter(0);
minuit->FixParameter(2);
minuit->FixParameter(3);
minuit->FixParameter(4);
minuit->FixParameter(6);
minuit->FixParameter(7);
}else if( testpaircat==0){
minuit->FixParameter(1);
minuit->FixParameter(2);
minuit->FixParameter(3);
minuit->FixParameter(5);
minuit->FixParameter(6);
minuit->FixParameter(7);
} else if( testpaircat==2){
minuit->FixParameter(0);
minuit->FixParameter(1);
minuit->FixParameter(3);
minuit->FixParameter(4);
minuit->FixParameter(5);
minuit->FixParameter(7);
} else if( testpaircat==3){
minuit->FixParameter(0);
minuit->FixParameter(1);
minuit->FixParameter(2);
minuit->FixParameter(4);
minuit->FixParameter(5);
minuit->FixParameter(6);
}
arglist[0] = 0.0001;
minuit->mnexcm("SET EPS",arglist,1,ierflg);
arglist[0] = 1;
minuit->mnexcm("SET STR",arglist,1,ierflg);
bool dofit = true;
if( dofit){
minuit->Migrad();
if (!minuit->fCstatu.Contains("CONVERGED")) {
mcfitStatus = 1; //first try not converged.
minuit->Migrad();
}else{
mcfitStatus = 0;
}
//minuit->mnmnos();
}
if (!minuit->fCstatu.Contains("CONVERGED")) {
printf("No convergence at fitting, routine Fit \n");
printf("Minuit return string: %s \n",minuit->fCstatu.Data());
mcfitStatus = 2; //2nd try not converged.
}else{
mcfitStatus = -1;
}
fAmin = minuit->fAmin;
for(int j=0; j<npar; j++){
minuit->GetParameter(j,fitpar[j],fitparErr[j]);
mcfitpar[j] = fitpar[j];
mcfitparErr[j] = fitparErr[j];
}
mytree->Fill();
mytree->Write();
fnew->Write();
fnew->Close();
}
int main(int argc, char *argv[])
{
setenv("TZ","UTC",1);
tzset();
gROOT->SetStyle("Plain");
static struct RecEvent RecEvent30;
static struct RecEvent RecEvent17;
static struct channel_profiles channel_profiles30;
static struct channel_profiles channel_profiles17;
static struct h3 h330;
static struct h3 h317;
//get pointer to data
TChain *TRecEvent30 = new TChain ("TRecEvent");
CreateTRecEventChain30(TRecEvent30);
cout << "TRecEvent entries = " << TRecEvent30->GetEntries() << endl;
CreateTRecEvent(TRecEvent30, &RecEvent30);
CreateTGrande(TRecEvent30, &h330, false);
TChain *TRecEvent17 = new TChain ("TRecEvent");
CreateTRecEventChain17(TRecEvent17);
cout << "TRecEvent entries = " << TRecEvent17->GetEntries() << endl;
CreateTRecEvent(TRecEvent17, &RecEvent17);
CreateTGrande(TRecEvent17, &h317, false);
char cut[2048];
sprintf(cut, "Eg>0");
sprintf(cut, "Eg>8.5 && abs(Zenith1Third)+2*Zenith1Third_err>Zeg && abs(Zenith1Third)-2*Zenith1Third_err<Zeg && LDFSlope<0");
// sprintf(cut, "Eg>6 && abs(Zenith1Third)+2*Zenith1Third_err>Zeg && abs(Zenith1Third)-2*Zenith1Third_err<Zeg && event_id!=2768428"); //slope!!
cout << "cut = " << cut << endl;
TRecEvent30->Draw(">>ListRecEvent30",cut);
TEventList *EventList30 = (TEventList*) gDirectory->Get("ListRecEvent30");
if(EventList30==NULL) cerr << "error - EventList30 has null entries" << endl;
TRecEvent30->SetEventList(EventList30);
cout << "30: events to analyse = " << EventList30->GetN() << endl;
TRecEvent17->Draw(">>ListRecEvent17",cut);
TEventList *EventList17 = (TEventList*) gDirectory->Get("ListRecEvent17");
if(EventList17==NULL) cerr << "error - EventList17 has null entries" << endl;
TRecEvent17->SetEventList(EventList17);
cout << "17: events to analyse = " << EventList17->GetN() << endl;
TChain *Tchannel_profile30 = new TChain("Tchannel_profile");
int NoChannels30;
Tchannel_profile30->AddFile("~/analysis/AnaFlag/AF_D30_run21-49_v28.root");
CreateTchannel_profiles(Tchannel_profile30, &channel_profiles30);
NoChannels30 = Tchannel_profile30->GetEntries();
cout << "Tchannel_profile30 entries = " << NoChannels30 << endl;
TChain *Tchannel_profile17 = new TChain("Tchannel_profile");
int NoChannels17;
Tchannel_profile17->AddFile("~/analysis/AnaFlag/AF_D17_run12-60_v28.root");
CreateTchannel_profiles(Tchannel_profile17, &channel_profiles17);
NoChannels17 = Tchannel_profile17->GetEntries();
cout << "Tchannel_profile17 entries = " << NoChannels17 << endl;
gEntries = 0;
float errScale = 1;
float errScale2 = 0.14; //0.0737; //0.048*1;
bool bNS = false, bEW = false;
//fill data pointers
for(int i=0; i<EventList30->GetN(); i++){
TRecEvent30->GetEntry(EventList30->GetEntry(i));
bNS = false;
bEW = false;
for(int k=0; k<RecEvent30.DetCh; k++){
for(int j=0; j<NoChannels30; j++){
Tchannel_profile30->GetEntry(j);
if((int)channel_profiles30.ch_id == RecEvent30.channel_id[k]){
if( strncmp(channel_profiles30.polarisation,"East",4) == 0 ){
bEW = true;
gFieldStrengthEW[gEntries] = RecEvent30.FieldStrengthChannel[k];
gFieldStrengthEWErr[gEntries] = RecEvent30.ChannelErrBackground[k]*errScale + RecEvent30.FieldStrengthChannel[k]*errScale2;
gFieldStrengthAnt[gEntries] = RecEvent30.FieldStrengthAntenna[k];
gDistanceShowerAxis[gEntries] = RecEvent30.DistanceShowerAxis[k];
}
else{
bNS = true;
gFieldStrengthNS[gEntries] = RecEvent30.FieldStrengthChannel[k];
gFieldStrengthNSErr[gEntries] = RecEvent30.ChannelErrBackground[k]*errScale + RecEvent30.FieldStrengthChannel[k]*errScale2;
gFieldStrengthAnt[gEntries] = RecEvent30.FieldStrengthAntenna[k];
gDistanceShowerAxis[gEntries] = RecEvent30.DistanceShowerAxis[k];
}
if(bNS && bEW){
gAzimuth[gEntries] = h330.Azg;
while(gAzimuth[gEntries]>360) gAzimuth[gEntries] -= 360;
gBAngle[gEntries] = RecEvent30.BAngle;
while(gBAngle[gEntries]>360) gBAngle[gEntries] -= 360;
gZenith[gEntries] = h330.Zeg;
gEg[gEntries] = h330.Eg;
if(0){
cout << gAzimuth[gEntries] << " -- " << gBAngle[gEntries] << endl;
cout << channel_profiles30.polarisation << endl;
cout << gFieldStrengthNS[gEntries] << " -- " << gFieldStrengthEW[gEntries] << " ----- " << gFieldStrengthNS[gEntries]/gFieldStrengthEW[gEntries] << endl;
cout << gFieldStrengthAnt[gEntries] << endl;
cout << h330.Zeg << " -- " << RecEvent30.Zenith1Third << " -- " << RecEvent30.Zenith1Third_err << endl;
cout << RecEvent30.event_id << endl;
cout << endl;
}
gEntries++;
bNS = false;
bEW = false;
}
break;
}
}
}
}
if(true)
for(int i=0; i<EventList17->GetN(); i++){
TRecEvent17->GetEntry(EventList17->GetEntry(i));
bNS = false;
bEW = false;
for(int k=0; k<RecEvent17.DetCh; k++){
for(int j=0; j<NoChannels17; j++){
Tchannel_profile17->GetEntry(j);
if((int)channel_profiles17.ch_id == RecEvent17.channel_id[k]){
if( strncmp(channel_profiles17.polarisation,"East",4) == 0 ){
bEW = true;
gFieldStrengthEW[gEntries] = RecEvent17.FieldStrengthChannel[k];
gFieldStrengthEWErr[gEntries] = RecEvent17.ChannelErrBackground[k]*errScale + RecEvent17.FieldStrengthChannel[k]*errScale2;
gFieldStrengthAnt[gEntries] = RecEvent17.FieldStrengthAntenna[k];
gDistanceShowerAxis[gEntries] = RecEvent17.DistanceShowerAxis[k];
}
else{
bNS = true;
gFieldStrengthNS[gEntries] = RecEvent17.FieldStrengthChannel[k];
gFieldStrengthNSErr[gEntries] = RecEvent17.ChannelErrBackground[k]*errScale + RecEvent17.FieldStrengthChannel[k]*errScale2;
gFieldStrengthAnt[gEntries] = RecEvent17.FieldStrengthAntenna[k];
gDistanceShowerAxis[gEntries] = RecEvent17.DistanceShowerAxis[k];
}
if(bNS && bEW){
gAzimuth[gEntries] = h317.Azg;
while(gAzimuth[gEntries]>360) gAzimuth[gEntries] -= 360;
gBAngle[gEntries] = RecEvent17.BAngle;
while(gBAngle[gEntries]>360) gBAngle[gEntries] -= 360;
gZenith[gEntries] = h317.Zeg;
gEg[gEntries] = h317.Eg;
if(0){
cout << "index = " << i << endl;
cout << gAzimuth[gEntries] << " -- " << gBAngle[gEntries] << endl;
cout << channel_profiles17.polarisation << endl;
cout << gFieldStrengthNS[gEntries] << " -- " << gFieldStrengthEW[gEntries] << " ----- " << gFieldStrengthNS[gEntries]/gFieldStrengthEW[gEntries] << endl;
cout << gFieldStrengthAnt[gEntries] << endl;
cout << h317.Zeg << " -- " << RecEvent17.Zenith1Third << " -- " << RecEvent17.Zenith1Third_err << endl;
cout << endl;
}
gEntries++;
bNS = false;
bEW = false;
}
break;
}
}
}
}
cout << gEntries << endl;
if(NoChannels30+NoChannels17 > gMaxCh || gEntries > gMaxEvents) {
cout << "constants limit reached" << endl;
exit(1);
}
TMinuit *gMinuit = new TMinuit(10);
gMinuit->SetPrintLevel(-1);
Double_t arglist[10];
Int_t ierflg = 0;
int NoPar = 6;
bool AntFit = false;
if(AntFit){
// Antenna Fit Settings
//++++++++++++++++++++++
cout << "Antenna Fit" << endl;
cout << "+++++++++++" << endl;
gMinuit->SetFCN(FcnParFS);
// no effect
arglist[0] = 1;
gMinuit->mnexcm("SET ERR", arglist ,1,ierflg);
arglist[0] = 1;
gMinuit->mnexcm("SET STRATEGY", arglist, 1, ierflg);
gMinuit->mnparm(0, "scale", 1., 0.01, 0, 0, ierflg);
gMinuit->mnparm(1, "r0", 400., 1, 0, 0, ierflg);
gMinuit->mnparm(2, "Epower", 1., 0.01, 0.8, 1.2, ierflg);
// gMinuit->mnparm(2, "Epower", 1., 0.1, 0, 0, ierflg);
gMinuit->mnparm(3, "Zphase", 0., 0.1, -TMath::Pi()*2, TMath::Pi()*2, ierflg);
gMinuit->mnparm(4, "Bphase", 0., 0.1, -TMath::Pi()*2, TMath::Pi()*2, ierflg);
gMinuit->mnparm(5, "offset", 2., 0.1, 0, 0, ierflg);
// gMinuit->FixParameter(0);
// gMinuit->FixParameter(2);
gMinuit->FixParameter(3);
gMinuit->FixParameter(4);
gMinuit->FixParameter(5);
}
else{
// Channel Fit Settings
//+++++++++++++++++++++
cout << "Channel Fit" << endl;
cout << "+++++++++++" << endl;
gMinuit->SetFCN(FcnParFSChannel);
// no effect
arglist[0] = 1;
gMinuit->mnexcm("SET ERR", arglist ,1,ierflg);
arglist[0] = 1;
gMinuit->mnexcm("SET STRATEGY", arglist, 1, ierflg);
gMinuit->mnparm(0, "scale", 1., 0.01, 0.1, 100, ierflg);
gMinuit->mnparm(1, "r0", 400., 1, 100, 1000, ierflg);
gMinuit->mnparm(2, "Epower", 1., 0.01, 0.8, 1.2, ierflg);
// gMinuit->mnparm(2, "Epower", 1., 0.01, 0, 0, ierflg);
gMinuit->mnparm(3, "Zphase", 0., 0.1, -TMath::Pi()*2, TMath::Pi()*2, ierflg);
gMinuit->mnparm(4, "Bphase", 0., 0.1, -TMath::Pi()*2, TMath::Pi()*2, ierflg);
gMinuit->mnparm(5, "offset", 2., 0.1, 0, 0, ierflg);
// gMinuit->FixParameter(0);
// gMinuit->FixParameter(2);
gMinuit->FixParameter(3);
gMinuit->FixParameter(4);
gMinuit->FixParameter(5);
}
//scan par space
for(int i=0; i<1; i++){
gMinuit->mnexcm("SCA", arglist, 0, ierflg);
}
// Now ready for minimization step
arglist[0] = 50000; // steps of iteration
arglist[1] = 1.; // tolerance
gMinuit->mnexcm("MIGRAD", arglist ,2,ierflg); //MIGRAD
cout << " MINIMIZE flag is " << ierflg << endl;
if(ierflg!=0){
cout << "+++++++++++++++++++++" << endl;
cout << "+ ups.. check again +" << endl;
cout << "+++++++++++++++++++++" << endl;
}
// MIGRAD: error optimiser
if(ierflg==0 && 0){
arglist[0] = 500000;
gMinuit->mnexcm("MIGRAD", arglist ,1,ierflg);
cout << " MIGRAD flag is " << ierflg << endl;
if(ierflg!=0){
cout << "+++++++++++++++++++++" << endl;
cout << "+ ups.. check again +" << endl;
cout << "+++++++++++++++++++++" << endl;
}
}
// Minos: error optimiser
if(ierflg==0 && 0){
arglist[0] = 500000;
gMinuit->mnexcm("MINOS", arglist ,1,ierflg);
cout << " MINOS flag is " << ierflg << endl;
if(ierflg!=0){
cout << "+++++++++++++++++++++" << endl;
cout << "+ ups.. check again +" << endl;
cout << "+++++++++++++++++++++" << endl;
}
}
// Print results
Double_t amin,edm,errdef;
Int_t nvpar,nparx,icstat;
gMinuit->mnstat(amin,edm,errdef,nvpar,nparx,icstat);
gMinuit->mnprin(3,amin);
cout << "prob = " << TMath::Prob(amin,gEntriesUsed-gMinuit->GetNumFreePars())*100 << " %" << endl;
cout << "ndf = " << gEntriesUsed-gMinuit->GetNumFreePars() << endl;
cout << "output" << endl;
// gMinuit->mnexcm("SHO COV", arglist ,0,ierflg);
// gMinuit->mnexcm("SHO COR", arglist ,0,ierflg);
// gMinuit->mnexcm("SHO EIG", arglist ,0,ierflg);
//get fit parameters
double par[15], epar;
for(int i=0; i<NoPar; i++){
gMinuit->GetParameter(i,par[i],epar);
}
TFile *output = new TFile("FitParFieldStrength_out.root","RECREATE");
int tcount = 0;
float tmpBAngle, tmpZenith;
float r0x[gMaxEvents], r0y[gMaxEvents];
float bx[gMaxEvents], by[gMaxEvents];
for(int i=0; i<gEntries; i++){
if(gFieldStrengthAnt[i]>0 && gFieldStrengthNS[i]>0 && gFieldStrengthEW[i]>0){
tmpBAngle = gBAngle[i] * TMath::Pi() / 180.;
tmpZenith = gZenith[i] * TMath::Pi() / 180.;
r0x[tcount] = -gDistanceShowerAxis[i];
r0y[tcount] = (log( (gFieldStrengthAnt[i]/gEffBand) / ( par[0]*cos(tmpZenith+par[3])*(par[5]+sin(tmpBAngle+par[4]))*powf(10,par[2]*(gEg[i]-8)))) );
//if(r0y[tcount] < -4 && r0x[tcount] > 50) cout << "E = " << gEg[i] << " -- i = " << i << endl;
bx[tcount] = tmpBAngle;
by[tcount] = gFieldStrengthAnt[i]/gEffBand / (par[0]*cos(tmpZenith+par[3])*exp(-gDistanceShowerAxis[i]/par[1])*powf(10,par[2]*(gEg[i]-8))) - par[5];
// if(by[tcount]>1.5) cout << " E = " << gEg[i] << " -- i = " << i << endl;
tcount++;
}
}
TCanvas *can1 = new TCanvas("can1");
can1->Divide(2,2);
TGraph *gr0 = new TGraph(tcount,r0x, r0y);
gr0->SetName("gr0");
gr0->SetMarkerStyle(20);
gr0->SetTitle("lateral distribution");
TGraph *gb = new TGraph(tcount,bx, by);
gb->SetName("gb");
gb->SetMarkerStyle(20);
gb->SetTitle("geomagnetic angle");
can1->cd(1);
gr0->Draw("ap");
can1->cd(2);
gb->Draw("ap");
gr0->Write();
gb->Write();
can1->Write();
output->Close();
}
//_________________________________________________________________________________
void integratedSplinesV5(double seed = 231)
{
//Load the data
int nEvents = 1000; //number of times the data will be randomized
int nPoints = 9;
double lowerBound = 10; //bounds for random vector function
double upperBound = 20;
double lowerErrorBound = 1;
double upperErrorBound = 2;
vector< vector<double> > xEvents, yEvents, yErrorEvents; //each of these is a vector of vectors (of randomized data points)
for(int i = 0; i < nEvents; i++)
{
vector <double> xData, yData, yErrorData; //temporary vectors that are only used to get random values from FillRand function
FillRandVectors(nPoints, xData, yData, yErrorData, seed*(i+1), lowerBound, upperBound, lowerErrorBound, upperErrorBound); //populates random vectors for y values and y error vector
xEvents.push_back(xData);
yEvents.push_back(yData);
yErrorEvents.push_back(yErrorData);
//Populate the global variables
xData_GLOB = xData;
yData_GLOB = yData;
yErrorData_GLOB = yErrorData;
}
//Intialization of the variables
const int npar = nPoints;
const int orderSpline = 4;
const int nbreak = npar+2-orderSpline;
double stepSpline = 0.01;
double xminBSplineWorkspace = 0;
double xmaxBSplineWorkspace = 9;
double startCSplineWorkspace = 15.;
double stepCSplineWorkspace = 1.5;
acc_GLOB = gsl_interp_accel_alloc ();
spline_GLOB = gsl_spline_alloc (gsl_interp_cspline, nPoints);
gsl_bspline_workspace *bw = gsl_bspline_alloc(orderSpline, nbreak);
//Setup for the C-spline_________________________________________________________________________
//Setting up TMinuit for C-spline minimization
TMinuit *myMinuit = new TMinuit(npar); //initialize TMinuit with a maximum of npar
myMinuit->SetFCN(fcn);
myMinuit->SetPrintLevel(-1); //No output: -1, output:1
double arglist[10];
int ierflg = 0;
arglist[0] = 1;
myMinuit->mnexcm("SET ERR", arglist, 1, ierflg);
vector<double> vstart, vstep;
for(int i=0; i < npar; i++) //set starting values and step sizes for parameters
{
vstart.push_back(startCSplineWorkspace);
vstep.push_back(stepCSplineWorkspace);
}
for (int i = 0; i < npar; i++)
{
stringstream ss;
ss<<"a"<<i;
myMinuit->mnparm(i, ss.str().c_str(), vstart.at(i), vstep.at(i), 0, 0, ierflg);
}
//Perform the Minuit fit
arglist[0] = 500;
arglist[1] = 1.;
//Setup for the B-spline_________________________________________________________________________
//Declare and allocate memory to compose data set of control points
gsl_vector *xControl = gsl_vector_alloc(nPoints);
gsl_vector *yControl = gsl_vector_alloc(nPoints);
gsl_vector *w = gsl_vector_alloc(nPoints);
gsl_vector *B = gsl_vector_alloc(npar);
gsl_matrix *X = gsl_matrix_alloc(nPoints, npar);
//Create a b spline workspace and allocate its memory
gsl_bspline_knots_uniform(xminBSplineWorkspace, xmaxBSplineWorkspace, bw);
//Set up the variables for the fit matrix
for (int i = 0; i < nPoints; ++i)
{
gsl_bspline_eval(gsl_vector_get(xControl, i), B, bw); //Compute B_j(xi) for all j
for (int j = 0; j < npar; ++j) gsl_matrix_set(X, i, j, gsl_vector_get(B, j)); //Fill in row i of X
}
gsl_vector *c = gsl_vector_alloc(npar);
gsl_multifit_linear_workspace *mw = gsl_multifit_linear_alloc(nPoints, npar);
gsl_matrix *cov = gsl_matrix_alloc(npar, npar);
//B and C spline loops__________________________________________________________________________
clock_t tbstart, tbstop, tcstart, tcstop;
vector <double> timeb, timec;
vector< vector<double> > xBSplineValues, yBSplineValues;
vector< vector<double> > xCSplineValues, yCSplineValues;
for(int i = 0; i < (int)xEvents.size(); i++)
{
//Populate gsl vectors with the appropriate data
for (int j = 0; j < nPoints; j++)
{
double xi = xEvents[i][j];
double yi = yEvents[i][j];
double sigma = yErrorEvents[i][j];
gsl_vector_set(xControl, j, xi);
gsl_vector_set(yControl, j, yi);
gsl_vector_set(w, j, 1.0/(sigma*sigma));
}
tbstart = clock();
vector< vector<double> > bSplineValues = bSpline(xEvents.at(i),stepSpline, bw, yControl, B, X, c, mw, cov);
tbstop = clock();
timeb.push_back(((float)tbstop-(float)tbstart)/ (CLOCKS_PER_SEC/1000.) );
xBSplineValues.push_back(bSplineValues.at(0));
yBSplineValues.push_back(bSplineValues.at(1));
tcstart = clock();
vector< vector<double> > cSplineValues = cSpline(nPoints, npar, xEvents.at(i), stepSpline, myMinuit, arglist, ierflg);
tcstop = clock();
timec.push_back(((float)tcstop-(float)tcstart)/ (CLOCKS_PER_SEC/1000.) );
xCSplineValues.push_back(cSplineValues.at(0));
yCSplineValues.push_back(cSplineValues.at(1));
}
//Histograms______________________________________________________________________________________
//Time
int nbins = 100;
double xlow = 0;
double xup = 1.;
TH1D *hTimeB = new TH1D("Time","Timing; time [ms]; Number of Events", nbins, xlow, xup);
hTimeB->SetStats(0);
TH1D *hTimeC = new TH1D("TimeC","Timing; time [ms]; Number of Events", nbins, xlow, xup);
hTimeC->SetLineColor(kRed);
hTimeC->SetStats(0);
for(int i=0; i<(int)timec.size(); i++)
{
hTimeB->Fill(timeb.at(i));
hTimeC->Fill(timec.at(i));
}
//Interpolation distance
vector <double> interpB, interpC;
for(int i = 0; i < (int)yEvents.size(); i++)
{
for(int j = 0; j < (int)yEvents[i].size(); j++)
{
double key = xEvents[i][j];
int indexForB = binarySearch(xBSplineValues[i], key);
int indexForC = binarySearch(xCSplineValues[i], key);
if(indexForB != -1)
interpB.push_back( (yEvents[i][j]-yBSplineValues[i][indexForB])/yErrorEvents[i][indexForB] );
if(indexForC != -1)
interpC.push_back( (yEvents[i][j]-yCSplineValues[i][indexForC])/yErrorEvents[i][indexForC] );
}
}
int nbinsI = 40;
int xlowI = -4;
int xupI = 4;
TH1D *hInterpB = new TH1D("Interp B","Interpolation; Distance between spline and data normalized by error; Number of Events", nbinsI, xlowI, xupI);
for(int i=0; i<(int)interpB.size(); i++) hInterpB->Fill(interpB.at(i));
hInterpB->SetStats(0);
TH1D *hInterpC = new TH1D("Interp C","Interpolation; Distance between spline and data normalized by error; Number of Events", nbinsI, xlowI, xupI);
for (int i=0; i<(int)interpC.size(); i++) hInterpC->Fill(interpC.at(i));
hInterpC->SetLineColor(kRed);
hInterpC->SetStats(0);
//Draws______________________________________________________________________________________
//Interpolation
TLegend *legInterp = new TLegend(0.9,0.70,0.75,0.85);
legInterp->SetLineColor(kWhite);
legInterp->SetFillColor(kWhite);
legInterp->SetMargin(0.3);
legInterp->AddEntry(hInterpB,"b-spline","l");
legInterp->AddEntry(hInterpC,"c-spline","l");
legInterp->SetTextSize(0.05);
TCanvas *c1 = new TCanvas("c1", "Interpolation distance");
c1->cd();
hInterpB->Draw("");
hInterpC->Draw("same");
legInterp->Draw();
//Time
TLegend *legTime = new TLegend(0.9,0.70,0.75,0.85);
legTime->SetLineColor(kWhite);
legTime->SetFillColor(kWhite);
legTime->SetMargin(0.3);
legTime->AddEntry(hTimeB,"b-spline","l");
legTime->AddEntry(hTimeC,"c-spline","l");
legTime->SetTextSize(0.05);
TCanvas *c2 = new TCanvas("c2", "Computation time");
c2->cd();
hTimeB->Draw("");
hTimeC->Draw("same");
legTime-> Draw();
//Free the memory____________________________________________________________________________
gsl_spline_free (spline_GLOB);
gsl_interp_accel_free (acc_GLOB);
gsl_bspline_free(bw);
gsl_vector_free(xControl);
gsl_vector_free(yControl);
gsl_vector_free(B);
gsl_matrix_free(X);
gsl_vector_free(c);
gsl_multifit_linear_free(mw);
gsl_matrix_free(cov);
}
//______________________________________________________________________________
vector< vector<double> > cSpline(int nPoints, int npar, vector <double> xData, vector <double> yData, vector <double> yErrorData, double stepSpline =.01, double start = 10., double step = 0.01)
{
//Populate the global variables
xData_GLOB = xData;
yData_GLOB = yData;
yErrorData_GLOB = yErrorData;
//Initialize Minuit
vector<double> vstart, vstep;
for(int i=0; i<npar; i++) //set starting values and step sizes for parameters
{
vstart.push_back(start);
vstep.push_back(step);
}
TMinuit *myMinuit = new TMinuit(npar); //initialize TMinuit with a maximum of npar (5)
myMinuit->SetFCN(fcn);
myMinuit->SetPrintLevel(-1);//No output: -1, output:1
double arglist[10];
int ierflg = 0;
arglist[0] = 1;
myMinuit->mnexcm("SET ERR", arglist, 1, ierflg);
for (int i = 0; i < npar; i++) {
stringstream ss;
ss<<"a"<<i;
myMinuit->mnparm(i, ss.str().c_str(), vstart.at(i), vstep.at(i), 0, 0, ierflg);
}
//Perform the Minuit fit
arglist[0] = 500;
arglist[1] = 1.;
myMinuit->mnexcm("MIGRAD", arglist, 2, ierflg); //minimization
//Retrieve best-fit parameters
vector< double > bestFitParams, e_bestFitParams;
for(int i=0; i<npar; i++)
{
double par, epar;
myMinuit->GetParameter(i, par, epar); //retrieve best fit parameters
bestFitParams.push_back(par);
e_bestFitParams.push_back(epar);
}
//Store the best-fit spline in a TGraph
gsl_spline_init (spline_GLOB, &xData[0], &bestFitParams[0], xData.size()); //initialize the spline
int nPointsSpline = int ((xData[nPoints-1]-xData[0])/stepSpline); //calculate the number of points of the spline
vector< double > xSpline, ySpline;
for (int i= 0; i < nPointsSpline; i++){
xSpline.push_back(xData[0]+i*stepSpline);
ySpline.push_back(gsl_spline_eval (spline_GLOB, xSpline.back(), acc_GLOB));
}
//Construct a vector of vectors that will store the xSpline values and the ySpline values
vector< vector<double> > cSplineValues;
cSplineValues.push_back(xSpline);
cSplineValues.push_back(ySpline);
return cSplineValues;
}
//______________________________________________________________________________
void Ifit2()
{
file = new TFile("run41800dETIFWC1.root");
Bool_t IsFWC1 = kTRUE;
TMinuit *minuit = new TMinuit(3);
minuit->SetFCN(fcn);
Double_t arglist[10];
Int_t ierflg;
//ToF peak position from MC
Double_t ToFFWC1Theta[6] =
{
2.088228e+01,2.092216e+01,2.112093e+01,2.149825e+01,2.212018e+01,2.297665e+01
};
Double_t ToFFWC2Theta[6] =
{
1.976750e+01,1.988218e+01,2.025691e+01,2.078644e+01,2.158632e+01,2.263857e+01
};
Double_t ToFFWCTheta[6];
for(Int_t i = 0; i<6; i++){
if(IsFWC1) ToFFWCTheta[i] = ToFFWC1Theta[i];
else ToFFWCTheta[i] = ToFFWC2Theta[i];
}
// Int_t nbin = 3;
TH2D* hdEToF[6][24];
TF1* fFit[6][24];
for(Int_t el = 1; el<25; el++){
Double_t vstart[3];
for(Int_t bin = 1; bin<7; bin++){
hdEToF[bin-1][el-1] = (TH2D*)file->Get(Form("hToFFWCdEFWC_bin%02d_ifwc%02d",bin,el));
hdE = hdEToF[bin-1][el-1];
//err x and y
//So here I fit x coordinate of THE point
//Then I calculate where I would like to cut the whole thing off
TF1* g1 = new TF1("g1","gaus",15.,28.);
Double_t maxt = ToFFWCTheta[bin-1];
hdE->ProjectionX("hproj1")->Fit("g1", "IQ", "", maxt-2.5, maxt+2.5);
merrx = g1->GetParameter(2);
cutx = maxt+3*merrx;
//Same for y.
TF1* g2 = new TF1("g2","gaus",0.,4000.);
Int_t BinDown = hdE->GetXaxis()->FindBin(maxt-2.5);
Int_t BinUp = hdE->GetXaxis()->FindBin(maxt+2.5);
Double_t maxy = hdE->ProjectionY()->GetMaximumBin();
Double_t maxdE = hdE->GetYaxis()->GetBinCenter(maxy);
hdE->ProjectionY("hproj2",BinDown,BinUp)->Fit("g2", "I", "", maxdE-500., maxdE+500);
merry = g2->GetParameter(2);
cuty = maxdE+5*merry;
cout<<"err: "<<merrx<<" "<<merry<<endl;
cout<<"cut: "<<cutx<<" "<<cuty<<endl;
//Ranges of fitting
nbinsx = hdE->GetXaxis()->FindBin(38.);
nbinx0 = hdE->GetXaxis()->FindBin(maxt+4*merrx);
//I set range of fitting in y
Int_t up = hdE->GetYaxis()->GetNbins();
nbinsy = up;
Int_t nentr = hdE->GetEntries();
for(Int_t i=0; i<nbinsy; i++){
if(i<maxy) continue;
if(hdE->ProjectionX("hproj",i+1,i+1)->GetEntries()<0.0005*nentr){
nbinsy = i+1;
}
}
cout<<"x range: "<<maxt+4*merrx<<" - "<<38.<<endl;
cout<<"Y range: "<<hdE->GetYaxis()->GetBinCenter(nbinsy)<<endl;
//3Hen peak position
ym = maxdE;
xm = hdE->GetXaxis()->GetBinCenter(hdE->ProjectionX()->GetMaximumBin());
cout<<" xm, ym: "<<xm<<" "<<ym<<endl;
//Fit to profile - start parameters
TF1* g0 = new TF1("g0","pol2",15.,38.);
TProfile* pp;
pp = hdE->ProfileX();
pp->Fit("g0","IQ","0",maxt-5*merrx,/*hdE->GetXaxis()->GetBinCenter(nbinsx)*/38.);
//initialize TMinuit with a maximum of 3 params
ierflg = 0;
arglist[0] = 1;
minuit->mnexcm("SET ERR", arglist ,1,ierflg);
// Set starting values and step sizes for parameters
if(bin<5){
vstart[0] = g0->GetParameter(2);
vstart[1] = g0->GetParameter(1);
// vstart[2] = g0->GetParameter(0);
}
Double_t step[3] = {0.01 , 1. , 10.};
minuit->mnparm(0, "a", vstart[0], step[0], 0,0,ierflg);
minuit->mnparm(1, "b", vstart[1], step[1], 0,0,ierflg);
// minuit->mnparm(2, "c", vstart[2], step[2], 0,0,ierflg);
// Now ready for minimization step
arglist[0] = 1500;
arglist[1] = 1;
minuit->mnexcm("MIGRAD", arglist ,2,ierflg);
// Print results
Double_t amin,edm,errdef;
Int_t nvpar,nparx,icstat;
minuit->mnstat(amin,edm,errdef,nvpar,nparx,icstat);
//gMinuit->mnprin(3,amin);
// get parameters
double pval[2],perr[2],plo[2],phi[2];
TString para0,para1,para2;
int istat;
minuit->mnpout(0,para0,pval[0],perr[0],plo[0],phi[0],istat);
minuit->mnpout(1,para1,pval[1],perr[1],plo[1],phi[1],istat);
//minuit->mnpout(2,para2,pval[2],perr[2],plo[2],phi[2],istat);
fFit[bin-1][el-1] = new TF1(Form("fFit_bin%02d_el%02d",bin,el), "pol2", 0., 40.);
fFit[bin-1][el-1]->FixParameter(2, pval[0]);
fFit[bin-1][el-1]->FixParameter(1, pval[1]);
fFit[bin-1][el-1]->FixParameter(0, ym - pval[0]*xm*xm - pval[1]*xm);
}
}
TCanvas* cc[6];
for(Int_t el=0; el<6; el++){
cc[el] = new TCanvas(Form("c_el%02d",el),Form("c_el%02d",el),1350,950);
cc[el]->Divide(4,6);
for(Int_t bin = 0; bin<24; bin++){
cc[el]->cd(bin+1);
hdEToF[el][bin]->Draw("colz");
fFit[el][bin]->Draw("same");
}
}
}
