Asymmetry estimateAsymmetry(
const TH1* hist, const TH2* cov,
const char * minName = "Minuit2",
const char *algoName = "" )
{
TH1* normHist=(TH1*)hist->Clone("normHist");
TH2* normCov=(TH2*)cov->Clone("normCov");
normHist->Scale(1.0/hist->Integral());
normCov->Scale(1.0/hist->Integral()/hist->Integral());
const int N = hist->GetNbinsX();
TMatrixD covMatrix(N,N);
for (int i=0; i<N;++i)
{
for (int j=0; j<N;++j)
{
covMatrix[i][j]=normCov->GetBinContent(i+1,j+1);
}
}
TMatrixD invCovMatrix = TMatrixD(TMatrixD::kInverted,covMatrix);
ROOT::Math::Minimizer* min = ROOT::Math::Factory::CreateMinimizer(minName, algoName);
// set tolerance , etc...
min->SetMaxFunctionCalls(1000000); // for Minuit/Minuit2
min->SetMaxIterations(10000); // for GSL
min->SetTolerance(0.001);
min->SetPrintLevel(1);
//const double xx[1] = {0.5};
std::function<double(const TH1*, const TMatrixD*, const double*)> unboundFct = chi2A;
std::function<double(const double*)> boundFct = std::bind(unboundFct,normHist, &invCovMatrix, std::placeholders::_1);
//boundFct(xx);
ROOT::Math::Functor fct(boundFct,1);
min->SetFunction(fct);
min->SetVariable(0,"A",0.2, 0.01);
min->Minimize();
const double *xs = min->X();
const double *error = min->Errors();
log(INFO,"min: %f\n",xs[0]);
log(INFO,"err: %f\n",error[0]);
Asymmetry res;
res.mean=xs[0];
res.uncertainty=error[0];
return res;
}
void solve(TString outFileName){
ROOT::Math::Minimizer* min = ROOT::Math::Factory::CreateMinimizer("Minuit2", "MIGRAD");
min->SetMaxFunctionCalls(1000000);
min->SetTolerance(0.001);
min->SetPrintLevel(10);
ROOT::Math::Functor f(&totalDist,4);
double step[4] = {0.01,0.01,.01,.01};
double variable[4] = { 0,0,50,0};
min->SetFunction(f);
min->SetVariable(0,"x" ,variable[0], step[0]);
min->SetVariable(1,"y" ,variable[1], step[1]);
min->SetVariable(2,"z" ,variable[2], step[2]);
min->SetVariable(3,"phi",variable[3], step[3]);
// do the minimization
min->Minimize();
const double *xs = min->X();
std::cout << "Minimum: f(" << xs[0] << "," << xs[1]<< "," << xs[2]<< "," << xs[3] << "): "
<< min->MinValue() << std::endl;
setZ=xs[2];
ROOT::Math::Minimizer* min2 = ROOT::Math::Factory::CreateMinimizer("Minuit2", "MIGRAD");
min2->SetMaxFunctionCalls(1000000);
min2->SetTolerance(0.001);
min2->SetPrintLevel(10);
ROOT::Math::Functor f2(&totalDistWithoutZ,3);
double step2[3] = {0.01,0.01,.01};
double variable2[3] = { xs[0],xs[1],xs[3]};
min2->SetFunction(f2);
min2->SetVariable(0,"x" ,variable2[0], step2[0]);
min2->SetVariable(1,"y" ,variable2[1], step2[1]);
min2->SetVariable(2,"phi",variable2[2], step2[2]);
// do the minimization
min2->Minimize();
const double *xs2 = min2->X();
std::cout << "Minimum: f(" << xs2[0] << "," << xs2[1]<< "," << xs2[2] << "): "
<< min2->MinValue() << std::endl;
// // expected minimum is 0
// if ( min->MinValue() < 1.E-4 && f(xs) < 1.E-4)
// std::cout << " converged to the right minimum" << std::endl;
// else {
// std::cout << " failed to converge !!!" << std::endl;
// Error("NumericalMinimization","fail to converge");
// }
}
void find_chisqMin()
{
chisq=0.;
for(int i=0; i<numSpectra; i++)
{
// for more information see minimizer class documentation
// https://root.cern.ch/root/html/ROOT__Math__Minimizer.html
char minName[132] = "Minuit";
char algoName[132] = ""; // default conjugate gradient type method
ROOT::Math::Minimizer* min = ROOT::Math::Factory::CreateMinimizer(minName, algoName);
// set tolerance , etc...
min->SetMaxFunctionCalls(1000000); // for Minuit
min->SetMaxIterations(10000); // for GSL
min->SetTolerance(0.001);
min->SetPrintLevel(0); // set to 1 for more info
// communication to the likelihood ratio function
// (via global parameters)
for(int j=0; j<S32K; j++)
{
expCurrent[j] = (double)expHist[spectrum[i]][j];
simCurrent[j] = (double)dOutHist[spectrum[i]][j];
}
spCurrent = i;
// create funciton wrapper for minmizer
// a IMultiGenFunction type
ROOT::Math::Functor lr(&lrchisq,3);
// behaves best when these are small
// starting point
double variable[3] = {0.001,0.001,0.001};
// step size
double step[3] = {0.0001,0.0001,0.0001};
min->SetFunction(lr);
// Set pars for minimization
min->SetVariable(0,"a0",variable[0],step[0]);
min->SetVariable(1,"a1",variable[1],step[1]);
min->SetVariable(2,"a2",variable[2],step[2]);
// do the minimization
min->Minimize();
// grab parameters from minimum
const double *xs = min->X();
// print results
/* std::cout << "Minimum: f(" << xs[0] << "," << xs[1] << "," << xs[2] << "): " */
/* << min->MinValue() << std::endl; */
// assuming 3 parameters
// save pars
for(int j=0;j<3;j++)
aFinal[j][i] = xs[j];
// add to total chisq
chisq += min->MinValue();
}
}
/* Main part of macro */
void fitData( TGraphErrors *gdata , TF1* ffit , double *startval )
{
cout << "\n***** fitData.C: Starting fitting procedure... *****" << endl;
g_data_global = gdata;
f_fit_global = ffit;
if ( g_data_global == NULL )
{
cout << "fitData.C: Did no find any data to fit." << endl;
return NULL;
}
const char * minName = "Minuit2";
const char *algoName = "Migrad";
// create minimizer giving a name and a name (optionally) for the specific
// algorithm
// possible choices are:
// minName algoName
// Minuit /Minuit2 Migrad, Simplex,Combined,Scan (default is Migrad)
// Minuit2 Fumili2
// Fumili
// GSLMultiMin ConjugateFR, ConjugatePR, BFGS,
// BFGS2, SteepestDescent
// GSLMultiFit
// GSLSimAn
// Genetic
ROOT::Math::Minimizer* min =
ROOT::Math::Factory::CreateMinimizer(minName, algoName);
/* Alternatice constructor for Minuit */
//ROOT::Minuit2::Minuit2Minimizer *min = new ROOT::Minuit2::Minuit2Minimizer();
//TMinuit *min = new TMinuit();
// set tolerance , etc...
min->SetMaxFunctionCalls(1000000); // for Minuit/Minuit2
min->SetMaxIterations(10000); // for GSL
min->SetTolerance(0.001);
min->SetPrintLevel(1);
// create funciton wrapper for minmizer
// a IMultiGenFunction type
ROOT::Math::Functor f(&Chi2_log,3);
double step[3] = {0.1,0.1,10};
// starting point
double variable[3] = { startval[0],startval[1],startval[2]};
// set function to minimize (this is the Chi2 function)
min->SetFunction(f);
// Set the free variables to be minimized!
min->SetVariable(0,"x",variable[0], step[0]);
min->SetVariable(1,"y",variable[1], step[1]);
min->SetVariable(2,"z",variable[2], step[2]);
// do the minimization
min->Minimize();
/* set function parameters to best fit results */
const double *xs = min->X();
f_fit_global->SetParameter(0, xs[0]);
f_fit_global->SetParameter(1, xs[1]);
f_fit_global->SetParameter(2, xs[2]);
/* Print summaries of minimization process */
std::cout << "Minimum: f(" << xs[0] << ", " << xs[1] << ", " << xs[2] << "): "
<< min->MinValue() << std::endl;
// expected minimum is 0
if ( min->MinValue() < 1.E-4 && f(xs) < 1.E-4)
std::cout << "Minimizer " << minName << " - " << algoName
<< " converged to the right minimum" << std::endl;
else {
std::cout << "Minimizer " << minName << " - " << algoName
<< " failed to converge !!!" << std::endl;
Error("NumericalMinimization","fail to converge");
}
/* Get degrees of freedom NDF */
unsigned ndf = 0;
/* get range of function used for fit */
double fit_min, fit_max;
f_fit_global->GetRange(fit_min,fit_max);
/* count data points in range of function */
for ( int p = 0; p < g_data_global->GetN(); p++ )
{
if ( g_data_global->GetX()[p] >= fit_min && g_data_global->GetX()[p] <= fit_max )
{
ndf++;
}
}
ndf -= 3; // 3 parameters in fit
cout << "Degrees of freedom: " << ndf << " --> chi2 / NDF = " << min->MinValue() / ndf << endl;
/* Get error covariance matrix from minimizer */
TMatrixD matrix0(3,3);
for ( unsigned i = 0; i < 3; i++ )
{
for ( unsigned j = 0; j < 3; j++ )
{
matrix0[i][j] = min->CovMatrix(i,j);
}
}
matrix0.Print();
/* Get minos error */
double par0_minos_error_up = 0;
double par0_minos_error_low = 0;
double par1_minos_error_up = 0;
double par1_minos_error_low = 0;
double par2_minos_error_up = 0;
double par2_minos_error_low = 0;
min->GetMinosError( 0, par0_minos_error_low, par0_minos_error_up );
min->GetMinosError( 1, par1_minos_error_low, par1_minos_error_up );
min->GetMinosError( 2, par2_minos_error_low, par2_minos_error_up );
cout << "Minos uncertainty parameter 0: up = " << par0_minos_error_up << ", low = " << par0_minos_error_low << endl;
cout << "Minos uncertainty parameter 1: up = " << par1_minos_error_up << ", low = " << par1_minos_error_low << endl;
cout << "Minos uncertainty parameter 2: up = " << par2_minos_error_up << ", low = " << par2_minos_error_low << endl;
/* Plot chi2 */
/* sigmas symmetric from covariance matrix */
//double sigmas[6] = {sqrt(matrix0[0][0]), sqrt(matrix0[0][0]), sqrt(matrix0[1][1]), sqrt(matrix0[1][1]), sqrt(matrix0[2][2]), sqrt(matrix0[2][2])};
/* sigmas asymmetric from minos */
double sigmas[6] = {par0_minos_error_low, par0_minos_error_up, par1_minos_error_low, par1_minos_error_up, par2_minos_error_low, par2_minos_error_up};
plotChi2( g_data_global, f_fit_global, 3, sigmas );
/* Draw contour plots */
TGraph2D* gcontour3D = plotContour( min , 3 , ndf );
/* Find error boundaries */
TF1* flow = (TF1*)f_fit_global->Clone("flow");
TF1* fup = (TF1*)f_fit_global->Clone("fup");
flow->SetRange(0,100000);
flow->SetLineColor(kBlue);
flow->SetLineStyle(2);
fup->SetRange(0,100000);
fup->SetLineColor(kBlue);
fup->SetLineStyle(2);
findErrorBounds( f_fit_global, flow, fup, gcontour3D );
/* plot residuals data w.r.t. fit */
plotResiduals( g_data_global, f_fit_global, flow, fup );
/* Draw data, best fit, and 1-sigma band */
TCanvas *cfit = new TCanvas();
g_data_global->Draw("AP");
//f_fit_global->SetRange(0,4000);
f_fit_global->Draw("same");
flow->Draw("same");
fup->Draw("same");
cfit->Print("new_FitResult.png");
/* Fit Extrapolation */
double t_extrapolate_months = 6;
double t_extrapolate_s = t_extrapolate_months * 30 * 24 * 60 * 60;
cout << "Extrapolation to " << t_extrapolate_months
<< " months: " << ffit->Eval( t_extrapolate_s )
<< " , up: " << fup->Eval( t_extrapolate_s ) - ffit->Eval( t_extrapolate_s )
<< " , low: " << flow->Eval( t_extrapolate_s ) - ffit->Eval( t_extrapolate_s )
<< endl;
return f_fit_global;
}
int main(int argc, char** argv)
{
// ROOT::Math::Minimizer* minuit = ROOT::Math::Factory::CreateMinimizer("Genetic"); //---> next ROOT release!
ROOT::Math::Minimizer* minuit = ROOT::Math::Factory::CreateMinimizer("Minuit", "Migrad2");
ROOT::Math::Functor functorChi2(&Chi2Func,6);
TString genCut; //==== (eleFBrem<0.8&&eleCharge>0)
bool traslationX ;
bool traslationY ;
bool traslationZ ;
bool rotationPhi ;
bool rotationTheta ;
bool rotationPsi ;
std::string fileName (argv[1]) ;
boost::shared_ptr<edm::ParameterSet> parameterSet = edm::readConfig(fileName) ;
edm::ParameterSet subPSetInput = parameterSet->getParameter<edm::ParameterSet> ("inputTree") ;
std::vector<std::string> nameFileIn = subPSetInput.getParameter<std::vector<std::string> > ("inputFiles") ;
std::string nameTree = subPSetInput.getParameter<std::string> ("nameTree") ;
std::string selection = subPSetInput.getParameter<std::string> ("selection") ;
genCut = Form("%s",selection.c_str());
traslationX = subPSetInput.getParameter<bool> ("traslationX") ;
traslationY = subPSetInput.getParameter<bool> ("traslationY") ;
traslationZ = subPSetInput.getParameter<bool> ("traslationZ") ;
rotationPhi = subPSetInput.getParameter<bool> ("rotationPhi") ;
rotationTheta = subPSetInput.getParameter<bool> ("rotationTheta") ;
rotationPsi = subPSetInput.getParameter<bool> ("rotationPsi") ;
double setRotationPhi = subPSetInput.getUntrackedParameter<double> ("setRotationPhi",0) ;
double setRotationTheta = subPSetInput.getUntrackedParameter<double> ("setRotationTheta",0) ;
double setRotationPsi = subPSetInput.getUntrackedParameter<double> ("setRotationPsi",0) ;
even = subPSetInput.getUntrackedParameter<bool> ("even",true) ;
odd = subPSetInput.getUntrackedParameter<bool> ("odd",true) ;
edm::ParameterSet subPSetOutput = parameterSet->getParameter<edm::ParameterSet> ("outputTree") ;
std::string nameFileOut = subPSetOutput.getParameter<std::string> ("outputFile") ;
//==== plot input/output ====
std::cout << " nameFileIn = ";
for (unsigned int i=0; i<nameFileIn.size(); i++ ) std::cout << " " << nameFileIn.at(i) << std::endl;
std::cout << " nameFileOut = " << nameFileOut << std::endl;
std::cout << " genCut = " << genCut.Data() << std::endl;
///==== input DATA ====
myTree = new TChain(nameTree.c_str());
int numberInput = 0;
for (std::vector<std::string>::const_iterator listIt = nameFileIn.begin () ; listIt != nameFileIn.end () ; ++listIt) {
numberInput++;
myTree->Add (listIt->c_str ()) ;
if (numberInput%4 == 0) std::cerr << "Input number " << numberInput << " ... " << listIt->c_str () << std::endl;
}
///==== bias functions ====
std::string FunctionDetaName = subPSetInput.getUntrackedParameter<std::string> ("DetaBias","0") ; // x = eta, y = charge
std::string FunctionDphiName = subPSetInput.getUntrackedParameter<std::string> ("DphiBias","0") ;
FunctionDeta = new TF2 ("DetaBias",FunctionDetaName.c_str(),-5,5,-2,2);
FunctionDphi = new TF2 ("DphiBias",FunctionDphiName.c_str(),-5,5,-2,2);
//==== output DATA ====
///==== Input ECAL position ====
std::string inputFilesPosition = subPSetInput.getUntrackedParameter<std::string> ("inputFilesPosition","") ;
///==== Build variables ====
double DX_SC_Mean[4];
double DX_SC_RMS[4];
double DY_SC_Mean[4];
double DY_SC_RMS[4];
double DZ_SC_Mean[4];
double DZ_SC_RMS[4];
double DTHETAe_SC_Mean[4];
double DTHETAe_SC_RMS[4];
double DPSIe_SC_Mean[4];
double DPSIe_SC_RMS[4];
double DPHIe_SC_Mean[4];
double DPHIe_SC_RMS[4];
std::ifstream* file;
if (inputFilesPosition != ""){
file = new std::ifstream(inputFilesPosition.c_str());
if(!file->is_open())
{
return false;
}
}
for (int iSC = 0; iSC<4; iSC++){
TString cut;
cut = Form("%s && iDetEB < -10 && iDetEE == %d",genCut.Data(),iSC);
std::cout << " cut = " << cut.Data() << std::endl;
///===========================
///==== Chi2 minimization ====
double inputDX = 0;
double inputDY = 0;
double inputDZ = 0;
double inputDPHIe = 0;
double inputDTHETAe = 0;
double inputDPSIe = 0;
if (inputFilesPosition != ""){
std::string buffer;
getline(*file,buffer);
std::stringstream line( buffer );
line >> inputDPHIe;
line >> inputDTHETAe;
line >> inputDPSIe;
line >> inputDX; inputDX/=100;
line >> inputDY; inputDY/=100;
line >> inputDZ; inputDZ/=100;
}
std::cerr << " inputDPHIe = " << inputDPHIe << std::endl;
std::cerr << " inputDTHETAe = " << inputDTHETAe << std::endl;
std::cerr << " inputDPSIe = " << inputDPSIe << std::endl;
std::cerr << " inputDX = " << inputDX << std::endl;
std::cerr << " inputDY = " << inputDY << std::endl;
std::cerr << " inputDZ = " << inputDZ << std::endl;
std::cout << " Chi2 minimization " << std::endl;
globalCut = cut;
// unsigned int iNoSteps = 1000;
// unsigned int iPar_NoBG = 0;
minuit->SetFunction(functorChi2);
minuit->SetMaxFunctionCalls(100000);
minuit->SetMaxIterations(10000);
minuit->SetTolerance(0.000002);
if (traslationX) minuit->SetLimitedVariable(0,"DX",inputDX, 0.00001,-0.050,0.050);
else minuit->SetFixedVariable(0,"DX",0);
if (traslationY) minuit->SetLimitedVariable(1,"DY",inputDY, 0.00001,-0.050,0.050);
else minuit->SetFixedVariable(1,"DY",0);
if (traslationZ) minuit->SetLimitedVariable(2,"DZ",inputDZ, 0.00001,-0.050,0.050);
else minuit->SetFixedVariable(2,"DZ",0);
if (rotationPhi) minuit->SetLimitedVariable(3,"DPHIe",inputDPHIe, 0.00001,-3.15,3.15);
else minuit->SetFixedVariable(3,"DPHIe",inputDPHIe);
if (rotationTheta) minuit->SetLimitedVariable(4,"DTHETAe",inputDTHETAe, 0.00001,-3.15,3.15);
else minuit->SetFixedVariable(4,"DTHETAe",inputDTHETAe);
if (rotationPsi) minuit->SetLimitedVariable(5,"DPSIe",inputDPSIe, 0.00001,-3.15,3.15);
else minuit->SetFixedVariable(5,"DPSIe",inputDPSIe);
minuit->Minimize();
minuit->PrintResults();
DX_SC_Mean[iSC] = (minuit->X()[0]);
DY_SC_Mean[iSC] = (minuit->X()[1]);
DZ_SC_Mean[iSC] = (minuit->X()[2]);
DX_SC_RMS[iSC] = (minuit->Errors()[0]);
DY_SC_RMS[iSC] = (minuit->Errors()[1]);
DZ_SC_RMS[iSC] = (minuit->Errors()[2]);
DPHIe_SC_Mean[iSC] = (minuit->X()[3]);
DTHETAe_SC_Mean[iSC] = (minuit->X()[4]);
DPSIe_SC_Mean[iSC] = (minuit->X()[5]);
DPHIe_SC_RMS[iSC] = (minuit->Errors()[3]);
DTHETAe_SC_RMS[iSC] = (minuit->Errors()[4]);
DPSIe_SC_RMS[iSC] = (minuit->Errors()[5]);
///==== end Chi2 minimization ====
std::cout << " iSC = " << iSC << " DPhi = " << DPHIe_SC_Mean[iSC] << " +/- " << DPHIe_SC_RMS[iSC] << std::endl;
std::cout << " iSC = " << iSC << " DTheta = " << DTHETAe_SC_Mean[iSC] << " +/- " << DTHETAe_SC_RMS[iSC] << std::endl;
std::cout << " iSC = " << iSC << " DPsi = " << DPSIe_SC_Mean[iSC] << " +/- " << DPSIe_SC_RMS[iSC] << std::endl;
std::cout << " iSC = " << iSC << " DX = " << DX_SC_Mean[iSC] << " +/- " << DX_SC_RMS[iSC] << std::endl;
std::cout << " iSC = " << iSC << " DY = " << DY_SC_Mean[iSC] << " +/- " << DY_SC_RMS[iSC] << std::endl;
std::cout << " iSC = " << iSC << " DZ = " << DZ_SC_Mean[iSC] << " +/- " << DZ_SC_RMS[iSC] << std::endl;
std::cout << "============================================================================" << std::endl;
std::cout << "============================================================================" << std::endl;
std::cout << "============================================================================" << std::endl;
}
int NumericalMinimization(const char * minName = "Minuit2",
const char *algoName = "" ,
int randomSeed = -1)
{
// create minimizer giving a name and a name (optionally) for the specific
// algorithm
// possible choices are:
// minName algoName
// Minuit /Minuit2 Migrad, Simplex,Combined,Scan (default is Migrad)
// Minuit2 Fumili2
// Fumili
// GSLMultiMin ConjugateFR, ConjugatePR, BFGS,
// BFGS2, SteepestDescent
// GSLMultiFit
// GSLSimAn
// Genetic
ROOT::Math::Minimizer* minimum =
ROOT::Math::Factory::CreateMinimizer(minName, algoName);
// set tolerance , etc...
minimum->SetMaxFunctionCalls(1000000); // for Minuit/Minuit2
minimum->SetMaxIterations(10000); // for GSL
minimum->SetTolerance(0.001);
minimum->SetPrintLevel(1);
// create function wrapper for minimizer
// a IMultiGenFunction type
ROOT::Math::Functor f(&RosenBrock,2);
double step[2] = {0.01,0.01};
// starting point
double variable[2] = { -1.,1.2};
if (randomSeed >= 0) {
TRandom2 r(randomSeed);
variable[0] = r.Uniform(-20,20);
variable[1] = r.Uniform(-20,20);
}
minimum->SetFunction(f);
// Set the free variables to be minimized !
minimum->SetVariable(0,"x",variable[0], step[0]);
minimum->SetVariable(1,"y",variable[1], step[1]);
// do the minimization
minimum->Minimize();
const double *xs = minimum->X();
std::cout << "Minimum: f(" << xs[0] << "," << xs[1] << "): "
<< minimum->MinValue() << std::endl;
// expected minimum is 0
if ( minimum->MinValue() < 1.E-4 && f(xs) < 1.E-4)
std::cout << "Minimizer " << minName << " - " << algoName
<< " converged to the right minimum" << std::endl;
else {
std::cout << "Minimizer " << minName << " - " << algoName
<< " failed to converge !!!" << std::endl;
Error("NumericalMinimization","fail to converge");
}
return 0;
}
