void fit(boot &A,boot &B,boot &C,bvec &X,bvec &Y)
{
//copy X
X_fit=new double[nens];
for(int iens=0;iens<nens;iens++) X_fit[iens]=X[iens].med();
Y_fit=new double[nens];
err_Y_fit=new double[nens];
TMinuit minu;
minu.SetPrintLevel(-1);
minu.DefineParameter(0,"A",0.0,0.0001,0,0);
minu.DefineParameter(1,"B",0.0,0.0001,0,0);
minu.DefineParameter(2,"C",0.0,0.0001,0,0);
minu.SetFCN(chi2_wr);
double C2;
for(int iboot=0;iboot<nboot+1;iboot++)
{
if(iboot>0)
minu.SetPrintLevel(-1);
minu.DefineParameter(3,"a380",lat[0][iboot],0.0001,0,0);
minu.DefineParameter(4,"a390",lat[1][iboot],0.0001,0,0);
minu.DefineParameter(5,"a405",lat[2][iboot],0.0001,0,0);
minu.DefineParameter(6,"a420",lat[3][iboot],0.0001,0,0);
minu.FixParameter(3);
minu.FixParameter(4);
minu.FixParameter(5);
minu.FixParameter(6);
for(int iens=0;iens<nens;iens++)
{
Y_fit[iens]=Y.data[iens].data[iboot];
err_Y_fit[iens]=Y.data[iens].err();
}
//minimize
minu.Migrad();
//get back parameters
double dum;
minu.GetParameter(0,A.data[iboot],dum);
minu.GetParameter(1,B.data[iboot],dum);
minu.GetParameter(2,C.data[iboot],dum);
double lat_med[4]={lat[0].med(),lat[1].med(),lat[2].med(),lat[3].med()};
if(iboot==0) C2=chi2(A.data[iboot],B[iboot],C[iboot],lat_med);
}
//calculate the chi2
cout<<"A = ("<<A<<"), B=("<<B<<"), C=("<<C<<")"<<endl;
cout<<"Chi2 = "<<C2<<" / "<<nens-3<<" = "<<C2/(nens-3)<<endl;
delete[] X_fit;
delete[] Y_fit;
delete[] err_Y_fit;
}
//______________________________________________________________________________
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 make_lin_fit(double & slope, double & d_slope, double & offset, double & d_offset){
TMinuit min;
min.SetPrintLevel(-1);
//min.SetPrintLevel(0);
int err = min.DefineParameter(0, "slope", slope, d_slope, 0.05, 1.0);
assert(err==0);
err = min.DefineParameter(1, "offset", offset, d_offset, 0.001, 0.2);
assert(err==0);
min.SetFCN(chi2_linear);
min.mnmigr();
min.GetParameter(0, slope, d_slope);
min.GetParameter(1, offset, d_offset);
}
void fit(boot &A,boot &B,boot &C,boot &D)
{
//copy ml
ml_fit=new double[nens];
for(int iens=0;iens<nens;iens++) ml_fit[iens]=ml[iens].med();
//alloc dM2Pi and dM2K
dM2Pi_fit=new double[nens];
err_dM2Pi_fit=new double[nens];
dM2K_fit=new double[nens];
err_dM2K_fit=new double[nens];
TMinuit minu;
minu.SetPrintLevel(-1);
int npars=4;
minu.DefineParameter(0,"A",0.0,0.0001,0,0);
minu.DefineParameter(1,"B",0.0,0.0001,0,0);
minu.DefineParameter(2,"C",0.0,0.0001,0,0);
minu.DefineParameter(3,"D",0.0,0.0001,0,0);
minu.SetFCN(chi2_wr);
double C2;
for(int iboot=0;iboot<nboot+1;iboot++)
{
if(iboot>0) minu.SetPrintLevel(-1);
minu.DefineParameter(4,"a380",lat[0][iboot],0.0001,0,0);
minu.DefineParameter(5,"a390",lat[1][iboot],0.0001,0,0);
minu.DefineParameter(6,"a405",lat[2][iboot],0.0001,0,0);
minu.DefineParameter(7,"a420",lat[3][iboot],0.0001,0,0);
minu.FixParameter(4);
minu.FixParameter(5);
minu.FixParameter(6);
minu.FixParameter(7);
for(int iens=0;iens<nens;iens++)
{
dM2Pi_fit[iens]=dM2Pi.data[iens].data[iboot];
err_dM2Pi_fit[iens]=dM2Pi.data[iens].err();
dM2K_fit[iens]=dM2K.data[iens].data[iboot];
err_dM2K_fit[iens]=dM2K.data[iens].err();
}
//minimize
minu.Migrad();
//get back parameters
double dum;
minu.GetParameter(0,A.data[iboot],dum);
minu.GetParameter(1,B.data[iboot],dum);
minu.GetParameter(2,C.data[iboot],dum);
minu.GetParameter(3,D.data[iboot],dum);
double lat_med[4]={lat[0].med(),lat[1].med(),lat[2].med(),lat[3].med()};
if(iboot==nboot) C2=chi2(A.data[iboot],B[iboot],C[iboot],D[iboot],lat_med,true);
}
//calculate the chi2
cout<<"A=("<<A<<"), B=("<<B<<"), C=("<<C<<"), D=("<<D<<")"<<endl;
cout<<"Chi2 = "<<C2<<" / "<<2*nens-npars<<" = "<<C2/(2*nens-npars)<<endl;
delete[] ml_fit;
delete[] dM2Pi_fit;
delete[] err_dM2Pi_fit;
delete[] dM2K_fit;
delete[] err_dM2K_fit;
}
void parab_fit(double ch2,jack &a,jack &b,jack &c,double *X,jvec Y,const char *path,bool fl_parab=1)
{
ofstream out(path);
out<<"@type xydy\n";
double MX=0;
//copy X
nc_fit=Y.nel;
X_fit=new double[nc_fit];
for(int iel=0;iel<nc_fit;iel++)
if(use[iel])
{
X_fit[iel]=X[iel];
out<<X[iel]<<" "<<Y[iel]<<endl;
if(X[iel]>MX) MX=X[iel];
}
Y_fit=new double[nc_fit];
err_Y_fit=new double[nc_fit];
TMinuit minu;
minu.SetPrintLevel(0);
int npars=3;
minu.DefineParameter(0,"A",0.0,0.0001,0,0);
minu.DefineParameter(1,"B",0.0,0.0001,0,0);
minu.DefineParameter(2,"C",0.0,0.0001,0,0);
if(!fl_parab)
{
minu.FixParameter(0);
npars--;
}
minu.SetFCN(chi2_wr);
for(int ijack=0;ijack<=njack;ijack++)
{
minu.DefineParameter(2,"C",fixed_A[ijack],0.0001,0,0);
minu.FixParameter(2);
if(ijack>0)
minu.SetPrintLevel(-1);
for(int iel=0;iel<nc_fit;iel++)
{
Y_fit[iel]=Y.data[iel].data[ijack];
err_Y_fit[iel]=Y[iel].err();
}
//minimize
minu.Migrad();
//get back parameters
double dum;
minu.GetParameter(0,a.data[ijack],dum);
minu.GetParameter(1,b.data[ijack],dum);
minu.GetParameter(2,c.data[ijack],dum);
}
out<<"&\n@type xy\n";
for(double t=0;t<MX;t+=MX/100)
out<<t<<" "<<parab(a[njack],b[njack],c[njack],t)<<endl;
out.close();
}
//_________________________________________________________________________________
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 runAngleOpt() {
gSystem->AddIncludePath("-I${ANITA_UTIL_INSTALL_DIR}/include");
double startVal=0;
double stepSize=0.1;
double minVal=-2;
double maxVal=2;
Double_t p0 = 0;
//Load libraries. Need to have ANITA_UTIL_INSTALL_DIR/lib and ROOTSYS/lib in the LD_LIBRARY_PATH
gSystem->Load("libfftw3.so");
gSystem->Load("libMathMore.so");
gSystem->Load("libPhysics.so");
gSystem->Load("libGeom.so");
gSystem->Load("libMinuit.so");
gSystem->Load("libRootFftwWrapper.so");
gSystem->Load("libAnitaEvent.so");
gSystem->Load("libAnitaCorrelator.so");
AnitaGeomTool *fGeomTool = AnitaGeomTool::Instance();
gSystem->CompileMacro("anglePlotterOpt.C","k");
Double_t relDeltaOut=0;
TMinuit *myMin = new TMinuit(1);
myMin->SetObjectFit(anglePlotterOpt);
myMin->SetFCN(iHateRoot);
//setArray();
for(int u = 0; u < 1; u++){
int middle = 16;
for(int y = 16; y <32; y++){
int leftOpt, rightOpt;
fGeomTool->getThetaPartners(middle,leftOpt,rightOpt);
myMin->DefineParameter(0, "antNum", middle, stepSize, minVal, maxVal);
myMin->FixParameter(0);
myMin->DefineParameter(1, "deltaT", startVal, stepSize, minVal, maxVal);
Double_t deltaT,deltaTErr;
//*********MINUIT METHOD*******************
myMin->SetPrintLevel(-1);
myMin->Migrad();
myMin->GetParameter(1,deltaT,deltaTErr);
setValue(rightOpt,deltaT);
// printArray();
// cout << middle << " " << rightOpt << " " << deltaT << endl;
cout << "deltaTArrayMod[" << rightOpt << "] = " << deltaT << ";" << endl;
middle = rightOpt;
}
}
// myMin->DeleteArrays();
// myMin->DeleteArrays();
}
//_________________________________________________________________________________
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 runTopRingOpt() {
gSystem->AddIncludePath("-I${ANITA_UTIL_INSTALL_DIR}/include");
double startVal=0;
double stepSize=0.1;
double minVal=-0.5;
double maxVal=0.5;
Double_t p0 = 0;
//Load libraries. Need to have ANITA_UTIL_INSTALL_DIR/lib and ROOTSYS/lib in the LD_LIBRARY_PATH
gSystem->Load("libfftw3.so");
gSystem->Load("libMathMore.so");
gSystem->Load("libPhysics.so");
gSystem->Load("libGeom.so");
gSystem->Load("libMinuit.so");
gSystem->Load("libRootFftwWrapper.so");
gSystem->Load("libAnitaEvent.so");
gSystem->Load("libAnitaCorrelator.so");
AnitaGeomTool *fGeomTool = AnitaGeomTool::Instance();
gSystem->CompileMacro("topRingOpt.C","k");
Double_t relDeltaOut=0;
TMinuit *myMin = new TMinuit(150);
myMin->SetObjectFit(topRingOpt);
myMin->SetFCN(iHateRoot);
//setArray();
double startValDeltaT[16] ={0};
double startValR[16] ={0};
double startValPhi[16] ={0};
// startValDeltaT[0] = -0.0519515; startValR[0] = -0.0101463; startValPhi[0] = -0.00473836 ;
// startValDeltaT[1] = -0.0597062; startValR[1] = -0.02577; startValPhi[1] = 0.00864501 ;
// startValDeltaT[2] = -0.081435; startValR[2] = -0.000224044; startValPhi[2] = -0.000630649;
// startValDeltaT[3] = 0.0118873; startValR[3] = 0.019945; startValPhi[3] = 0.014016;
// startValDeltaT[4] = 0.017917; startValR[4] = -0.00297559; startValPhi[4] = 0.0224936 ;
// startValDeltaT[5] = 0.0377119; startValR[5] = -0.014872; startValPhi[5] = 0.0163349;
// startValDeltaT[6] = -0.0426158; startValR[6] = -0.0562555; startValPhi[6] = 0.0220065 ;
// startValDeltaT[7] = -0.0221673; startValR[7] = -0.034104 ; startValPhi[7] = 0.0158545 ;
// startValDeltaT[8] = 0.0263739; startValR[8] = 0.00248804; startValPhi[8] = 0.013246 ;
// startValDeltaT[9] = -0.0938419; startValR[9] = -0.00344703; startValPhi[9] = -0.00718616;
// startValDeltaT[10] = 0.145264; startValR[10] = -0.0121874 ; startValPhi[10] = 0.0156988 ;
// startValDeltaT[11] = 0.118105; startValR[11] = -0.0337033 ; startValPhi[11] = -0.00324182 ;
// startValDeltaT[12] = 0.321805; startValR[12] = 0.0134362 ; startValPhi[12] = -0.00190277 ;
// startValDeltaT[13] = 0.0197693; startValR[13] = -0.000656063; startValPhi[13] = -0.0162318 ;
// startValDeltaT[14] = -0.115263; startValR[14] = 0.0495637 ; startValPhi[14] = -0.0198119 ;
// startValDeltaT[15] = -0.255707; startValR[15] = 0.00189892 ; startValPhi[15] = 0.0383932 ;
for(int y = 0; y <16; y++){
ofstream newfile("newSimonNumbers.txt");
char name[30];
sprintf(name,"r%d",y);
myMin->DefineParameter(y, name, startValR[y], stepSize, minVal, maxVal);
sprintf(name,"z%d",y);
myMin->DefineParameter(y+16, name, startValDeltaT[y], stepSize, minVal, maxVal);
sprintf(name,"phi%d",y);
myMin->DefineParameter(y+32, name, startValPhi[y], stepSize, minVal, maxVal);
}
Double_t deltaR[32],deltaRErr[32];
Double_t deltaZ[32],deltaZErr[32];
Double_t deltaPhi[32],deltaPhiErr[32];
//*********MINUIT METHOD*******************
myMin->SetPrintLevel(-1);
myMin->Migrad();
for(int u = 0; u <16; u++){
myMin->GetParameter(u,deltaR[u],deltaRErr[u]);
//cout << "deltaR[" << u << "] = " << deltaR[u] ;
myMin->GetParameter(u+16,deltaZ[u],deltaZErr[u]);
//cout << " deltaZ[" << u << "] = " << deltaZ[u] ;
myMin->GetParameter(u+32,deltaPhi[u],deltaPhiErr[u]);
//cout << " deltaPhi[" << u << "] = " << deltaPhi[u] << ";" << endl;
newfile << u << " " << deltaZ[u]<< " " << deltaR[u]<< " " << deltaPhi[u]<< " " << 0 << endl;
}
}
//______________________________________________________________________________
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 AverageMW()
{
// include NuTeV?
if( inclNuTeV ) nVals = 5;
else nVals = 4;
// number of parameters
const int npar = 1;
// create minuit pointer
TMinuit *minuit = new TMinuit( npar );
// set FCN function
minuit->SetFCN( &fcn );
// -1=quiet, 0=normal, 1=verbose
minuit->SetPrintLevel( 0 );
// start values
Double_t startVal = 80;
Double_t fitStep = 0.1;
Double_t limitMin = 70;
Double_t limitMax = 90;
minuit->DefineParameter( 0, "MW", startVal, fitStep, limitMin, limitMax);
// minimize with MIGRAD
Int_t ierr = 0;
Double_t args[2];
args[0] = 0; // maximum function calls (0=default)
args[1] = 0; // tolerance at minimum (0=default)
minuit->mnexcm( "MIGrad", args, 2, ierr );
if ( ierr != 0 )
cout << "Warning: Maybe fit didn't converge!" << endl;
// fit results
Double_t fitval_MW[1], fiterr_MW[1];
minuit->GetParameter( 0, fitval_MW[0], fiterr_MW[0] );
cout << "\n\n*************************************************" << endl;
cout << " chi2Min = " << chi2Min << endl;
cout << " n_dof = " << nVals-1 << endl;
cout << " p-value = " << TMath::Prob(chi2Min, nVals-1) << endl;
cout << " MW = " << fitval_MW[0] << " +- " << fiterr_MW[0] << endl;
cout << "*************************************************" << endl;
// make plot
gStyle->SetOptTitle(0);
gStyle->SetOptStat(0);
gStyle->SetOptFit(0);
TCanvas* c = new TCanvas( "c", "Mean of W boson mass", 0, 0, 850, 500 );
c->SetGridy();
TH2F *frame = new TH2F("frame", "Mean of W boson mass", 1, 80, 80.6, 5, 0, 5. );
frame->SetLineColor(0);
frame->SetTickLength(0,"Y");
frame->SetXTitle("M_{W} [GeV]");
frame->GetYaxis()->CenterLabels( 1 );
frame->GetYaxis()->SetNdivisions( frame->GetNbinsY()+10, 1 );
frame->GetYaxis()->SetBinLabel( 1, "" ); // no labels
frame->Draw();
// make labels
MakeLabels(frame);
// draw fit value
DrawFitValue( frame, fitval_MW[0], fiterr_MW[0] );
// draw measurements
for( Int_t i=0; i<5; i++ ){
DrawMeasurement( frame, 4-i, val_MW[i], err_MW[i] );
}
// Redraw axis
frame->Draw("sameaxis");
}
//_________________________________________________________________________________
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);
}
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 fit(boot &A,boot &B,boot &C,boot &D,bvec &X,bvec &Y)
{
//copy X
X_fit=new double[nens];
for(int iens=0;iens<nens;iens++) X_fit[iens]=X[iens].med();
Y_fit=new double[nens];
err_Y_fit=new double[nens];
TMinuit minu;
minu.SetPrintLevel(-1);
int npars=4;
minu.DefineParameter(0,"A",0.0,0.0001,0,0);
minu.DefineParameter(1,"B",0.0,0.0001,0,0);
minu.DefineParameter(2,"C",0.0,0.0001,0,0);
minu.DefineParameter(3,"D",0.0,0.0001,0,0);
if(!include_a4)
{
minu.FixParameter(3);
npars--;
}
if(!include_ml_term)
{
minu.FixParameter(1);
npars--;
}
minu.SetFCN(chi2_wr);
double C2;
for(int iboot=0;iboot<nboot+1;iboot++)
{
if(iboot>0)
minu.SetPrintLevel(-1);
minu.DefineParameter(4,"a380",lat[0][iboot],0.0001,0,0);
minu.DefineParameter(5,"a390",lat[1][iboot],0.0001,0,0);
minu.DefineParameter(6,"a405",lat[2][iboot],0.0001,0,0);
minu.DefineParameter(7,"a420",lat[3][iboot],0.0001,0,0);
minu.FixParameter(4);
minu.FixParameter(5);
minu.FixParameter(6);
minu.FixParameter(7);
for(int iens=0;iens<nens;iens++)
{
Y_fit[iens]=Y.data[iens].data[iboot];
err_Y_fit[iens]=Y.data[iens].err();
}
//minimize
minu.Migrad();
//get back parameters
double dum;
minu.GetParameter(0,A.data[iboot],dum);
minu.GetParameter(1,B.data[iboot],dum);
minu.GetParameter(2,C.data[iboot],dum);
minu.GetParameter(3,D.data[iboot],dum);
double lat_med[4]={lat[0].med(),lat[1].med(),lat[2].med(),lat[3].med()};
if(iboot==nboot)
{
contr_flag=1;
C2=chi2(A.data[iboot],B[iboot],C[iboot],D[iboot],lat_med);
contr_flag=0;
}
}
int ninc_ens=0;
for(int iens=0;iens<nens;iens++)
if(ibeta[iens]!=0 || include_380) ninc_ens++;
//calculate the chi2
cout<<"A=("<<A<<"), B=("<<B<<"), C=("<<C<<"), D=("<<D<<")"<<endl;
cout<<"Chi2 = "<<C2<<" / "<<ninc_ens-npars<<" = "<<C2/(ninc_ens-npars)<<endl;
delete[] X_fit;
delete[] Y_fit;
delete[] err_Y_fit;
}
