|
|
#include <parameterscan.hh>
#include <iostream>
#include <fstream>
#include <paths.hh>
#include <options.hh>
#include <funcs.hh>
#include <generator.hh>
#include <parameters.hh>
#include <event.hh>
#include <funcs.hh>
#include <pdf.hh>
#include <fitter.hh>
#include <helpers.hh>
#include <TFile.h>
#include <TTree.h>
#include <TCanvas.h>
#include <spdlog.h>
/**
* @file parameterscan.cc * @author Renata Kopecna * @date 2021-03-02 * */
fcnc::parameterscan::parameterscan(options* o): multifit(o) { };
void fcnc::parameterscan::scan(std::string param_name, double min, double max, unsigned int nsteps, unsigned int nevents, unsigned int reruns, pdf* prob, parameters* params, generator* gen, bool only_float_in_generation){ std::vector<unsigned int > events; events.push_back(nevents);
std::vector<pdf* > probs; probs.push_back(prob);
std::vector<parameters* > the_params; the_params.push_back(params);
std::vector<generator* > gens; gens.push_back(gen);
scan(param_name, min, max, nsteps, events, reruns, probs, the_params, gens, only_float_in_generation); }
//void parameterscan::scan(std::string param_name, double min, double max, unsigned int nsteps, unsigned int nevents, unsigned int reruns, pdf_type* prob, params_type* params, generator_type* gen, bool only_float_in_generation) //fixed in fit on fixed value
void fcnc::parameterscan::scan(std::string param_name, double min, double max, unsigned int nsteps, std::vector<unsigned int> nevents, unsigned int reruns, std::vector<pdf*> pdfs, std::vector<parameters*> params, std::vector<generator*> gens, bool only_float_in_generation){ parameter* param_varied = 0; for (unsigned int i=0; i<params.size(); i++){ if (params.at(i)->get_parameter(param_name)) { param_varied = params.at(i)->get_parameter(param_name); break; } }
//open TeX file
std::ofstream myFile; open_Latex_noteFile(latex_paramScan(), myFile);
//parameter* param_varied = params->get_parameter(param_name);
double fit_start_value = param_varied->get_start_value(); if (only_float_in_generation) spdlog::info( "The fit start value will be fixed at: {0:f}",fit_start_value);
int param_index = param_varied->get_index(); if (param_varied != 0){ std::string param_description = param_varied->get_description(); std::string param_root = param_varied->get_root_name(); spdlog::info( "Doing parameter scan of parameter {0:d}: {1:s}", param_index, param_name); spdlog::info( "Varying parameter from {0:f} to {1:f}", min, max);
unsigned int nparams = 0; for (unsigned int i=0; i<params.size(); i++){ nparams += params.at(i)->nparameters(); } //params->nparameters();
TH1D* error_hists[nparams]; TH1D* value_hists[nparams]; double mean_values[nparams][nsteps+1]; double sigma_mean_values[nparams][nsteps+1]; double mean_errors[nparams][nsteps+1]; double sigma_mean_errors[nparams][nsteps+1];
double min_hist = min - 0.5*(max-min)/nsteps; double max_hist = max + 0.5*(max-min)/nsteps; //create histograms
unsigned int start_param = 0; for (unsigned int i=0; i<params.size(); i++){ for (unsigned int j = 0; j < nparams; j++){ unsigned int idx = start_param+j; parameter* param = params.at(i)->get_parameter(j); error_hists[idx] = new TH1D(("error_" + param->get_name()).c_str(), ("#sigma" + param->get_root_name() + ";" + param_root).c_str(), nsteps+1, min_hist, max_hist); error_hists[idx]->SetMarkerStyle(8); error_hists[idx]->SetMarkerColor(4); value_hists[idx] = new TH1D(("value_" + param->get_name()).c_str(), (param->get_root_name() + ";" + param_root).c_str(), nsteps+1, min_hist, max_hist); value_hists[idx]->SetMarkerStyle(8); value_hists[idx]->SetMarkerColor(4); } start_param += params.at(i)->nparameters(); } //do precalculations
for (unsigned int i=0; i<params.size(); i++){ pdfs.at(i)->init(params.at(i)); } //create output trees
//current values to fill into the tree
double value, error, error_up, error_down, start_value, param_value, nominal_error, nominal_value; int step, run, migrad, status_cov; std::vector<TTree*> trees;//one tree for every varied parameter
//start_param = 0;
for (unsigned int i=0; i<params.size(); i++){ for (unsigned int j = 0; j < nparams; j++){ //unsigned int idx = start_param+j;
parameter* param = params.at(i)->get_parameter(j); if (param->get_step_size() != 0.0){ std::string parname(param->get_name()); std::string pardesc(param->get_description());// + " results");
TTree* t = new TTree(parname.c_str(), pardesc.c_str()); t->Branch("step",&step,"step/I"); t->Branch("run",&run,"run/I"); t->Branch("param_value",¶m_value,"param_value/D"); t->Branch("value",&value,"value/D"); t->Branch("error",&error,"error/D"); t->Branch("nominal_value",&nominal_value,"nominal_value/D"); t->Branch("nominal_error",&nominal_error,"nominal_error/D"); t->Branch("error_up",&error_up,"error_up/D"); t->Branch("error_down",&error_down,"error_down/D"); t->Branch("start_value",&start_value,"start_value/D"); t->Branch("migrad",&migrad,"migrad/I"); t->Branch("status_cov",&status_cov,"status_cov/I"); trees.push_back(t); } } //start_param += params.at(i)->nparameters();
}
//enter main loop
for (unsigned int i = 0; i <= nsteps; i++){ //reset all results
std::vector<std::vector<double> > values(nparams, std::vector<double>(reruns, 0.0)); std::vector<std::vector<double> > errors(nparams, std::vector<double>(reruns, 0.0)); std::vector<std::vector<double> > errors_up(nparams, std::vector<double>(reruns, 0.0)); std::vector<std::vector<double> > errors_down(nparams, std::vector<double>(reruns, 0.0)); std::vector<std::vector<double> > nominal_values(nparams, std::vector<double>(reruns, 0.0)); std::vector<std::vector<double> > nominal_errors(nparams, std::vector<double>(reruns, 0.0)); std::vector<int> return_values(reruns);
//only_float_in_generation means that you use a varied parameter
//for generation but in the fit use the start_value
//this can be used for systematic studies
//we would also need to do a nominal fit
//then we can see the actual difference
//choose new value for the scan parameter
param_value = double(i)*(max - min)/(nsteps) + min; if (!only_float_in_generation){ //float in generation and fit
param_varied->set_value(param_value); param_varied->set_start_value(param_value); } // param_varied->init(param_name, param_description,
// param_value,
// param_varied->get_min(), param_varied->get_max(),
// param_varied->get_step_size());
//this is the scanned parameter so usually we change it before generation and fit
//this is the point: we need to do a couple reruns
fitter fit(opts); fit.set_common_parameters(common_params);
for (unsigned int k = 0; k < reruns; k++){ spdlog::info( "Parameter "+param_name+" {0:f}", param_value); spdlog::info( "Run no. {0:d}", k); std::string num; std::stringstream out; out << opts->name << "_" << (i+1) << "_" << (k+1); //TOOD: move to paths
num = out.str();
if (only_float_in_generation){//this generates with updated parameter values
param_varied->set_value(param_value); param_varied->set_start_value(param_value); } // param_varied->init(param_name, param_description,
// param_value,
// param_varied->get_min(), param_varied->get_max(),
// param_varied->get_step_size());
for (unsigned int j=0; j<params.size(); j++){ params.at(j)->reset_parameters();//this line was missing before? did we generate with fitted params?
}
std::vector< std::vector <event> > temp_events; for (unsigned int j=0; j<gens.size(); j++){ std::vector<event> ev = gens.at(j)->generate(nevents.at(j), params.at(j), pdfs.at(j)); temp_events.push_back(ev); } std::vector< std::vector <event> * > events; for (unsigned int j=0; j<gens.size(); j++){ events.push_back(&temp_events.at(j)); }
if (only_float_in_generation){//this tries to fit with original parameter values
param_varied->set_value(fit_start_value); param_varied->set_start_value(fit_start_value); } // param_varied->init(param_name, param_description,
// fit_start_value, //use start value here!
// param_varied->get_min(), param_varied->get_max(),
// param_varied->get_step_size());
for (unsigned int j=0; j<params.size(); j++){ params.at(j)->reset_parameters(); } int result = 0; result = fit.fit(pdfs, params, events, num);
return_values.at(k) = result; if (result != 0 && opts->repeat_on_fail){ spdlog::warn( "Fit failed, repeating run"); k--; continue; } unsigned int start_param = 0; for (unsigned int j = 0; j < params.size(); j++){ for (unsigned int l = 0; l < params.at(j)->nparameters(); l++){ unsigned int idx = start_param+l; parameter* param = params.at(j)->get_parameter(l); values.at(idx).at(k) = param->get_value(); errors.at(idx).at(k) = param->get_error(); errors_up.at(idx).at(k) = param->get_error_up(); errors_down.at(idx).at(k) = param->get_error_down(); } start_param += params.at(j)->nparameters(); } //now we want to do a nominal fit (if the respective options are set)
if (opts->refitting_nominal && only_float_in_generation){//now we do a nominal fit
spdlog::info( "Nominal fit");
param_varied->set_value(param_value); param_varied->set_start_value(param_value); // param_varied->init(param_name, param_description,
// param_value,
// param_varied->get_min(), param_varied->get_max(),
// param_varied->get_step_size());
for (unsigned int j = 0; j < params.size(); j++){ params.at(j)->reset_parameters(); } //and lets fit
fit.fit(pdfs, params, events, num);
//extract the parameters from the fit
start_param = 0; for (unsigned int j = 0; j < params.size(); j++){ for (unsigned int l = 0; l < params.at(j)->nparameters(); l++){ unsigned int idx = start_param+l; parameter* param = params.at(j)->get_parameter(l); nominal_values.at(idx).at(k) = (param->get_value()); nominal_errors.at(idx).at(k) = (param->get_error()); } start_param += params.at(j)->nparameters(); } } else{ for (unsigned int j = 0; j < nparams; j++){ nominal_values.at(j).at(k) = (0.0); nominal_errors.at(j).at(k) = (0.0); } }
}//end reruns
//determine means/widths of the distributions via gauss-fits
unsigned int start_param = 0; for (unsigned int j = 0; j < params.size(); j++){ for (unsigned int k = 0; k < params.at(j)->nparameters(); k++){ unsigned int idx = start_param + k; parameter* param = params.at(j)->get_parameter(k); if (param->get_step_size() != 0.0){ std::string step; std::stringstream out; out << (i+1); step = out.str();
double dummy1, dummy2, dummy3, dummy4, dummy5; double mean_value, mean_error, sigma_mean_value, sigma_mean_error; update_pull(param, values.at(idx), errors.at(idx), dummy1, dummy2, dummy3, dummy4, dummy5, step); update_value(param, values.at(idx), errors.at(idx), mean_value, sigma_mean_value, dummy3, dummy4, dummy5, step); update_error(param, values.at(idx), errors.at(idx), mean_error, sigma_mean_error, dummy3, dummy4, dummy5, step);
value_hists[idx]->SetBinContent(i+1,mean_value); value_hists[idx]->SetBinError(i+1,sigma_mean_value); error_hists[idx]->SetBinContent(i+1,mean_error); error_hists[idx]->SetBinError(i+1,sigma_mean_error);
mean_values[idx][i] = mean_value;//for the output tables
sigma_mean_values[idx][i] = sigma_mean_value;//for the output tables
mean_errors[idx][i] = mean_error; sigma_mean_errors[idx][i] = sigma_mean_error; } } start_param += params.at(j)->nparameters(); }
//save tree results
int param_idx = 0; output->cd(); start_param = 0; for (unsigned int j = 0; j < params.size(); j++){//this gives nice output
for (unsigned int l = 0; l < params.at(j)->nparameters(); l++){ unsigned int idx = start_param+l; parameter* param = params.at(j)->get_parameter(l); if (param->get_step_size() != 0.0){ TTree* t = trees.at(param_idx); for (unsigned int k=0; k<reruns; k++){ step = i; run = k; //param_value is already set;
value = values.at(idx).at(k); error = errors.at(idx).at(k); nominal_value = nominal_values.at(idx).at(k); nominal_error = nominal_errors.at(idx).at(k); error_up = errors_up.at(idx).at(k); error_down = errors_down.at(idx).at(k); start_value = param->get_start_value(); migrad = return_values.at(k) % 100; status_cov = return_values.at(k) / 100; t->Fill(); } param_idx++; } } start_param += params.at(j)->nparameters(); } } //save output trees
for (unsigned int j = 0; j < trees.size(); j++){ trees.at(j)->Write(); }
//summary output
myFile << "Parameter scan results: values\\\\" << std::endl; myFile << "\\begin{tabular}{|c|"; for (unsigned int i=0; i<=nsteps; i++){ myFile << "c"; } myFile << "|}\\hline" << std::endl; myFile << "$" << param_varied->get_description() << "$"; for (unsigned int i=0; i<=nsteps; i++){ double param_value = double(i)*(max - min)/(nsteps) + min; myFile << " & " << std::setprecision(2) << param_value; } myFile << "\\\\ \\hline" << std::endl;
start_param = 0; for (unsigned int i=0; i < params.size(); i++){ for (unsigned int j=0; j < params.at(i)->nparameters(); j++){ unsigned int idx = start_param+j; if (params.at(i)->get_parameter(j)->get_step_size() != 0.0){ myFile << "$" << params.at(i)->get_parameter(j)->get_description() << "$"; for (unsigned int k=0; k <= nsteps; k++){ myFile << " & $" << std::setprecision(2) << mean_values[idx][k] << " \\pm " //<< mean_errors[i][j]
<< sigma_mean_values[idx][k] << "$"; } myFile << "\\\\" << std::endl; } } start_param += params.at(i)->nparameters(); } myFile << "\\hline \\end{tabular}" << std::endl;
myFile << "Parameter scan results: errors\\\\" << std::endl; myFile << "\\begin{tabular}{|c|"; for (unsigned int i=0; i<=nsteps; i++){ myFile << "c"; } myFile << "|}\\hline" << std::endl; myFile << "$" << param_varied->get_description() << "$"; for (unsigned int i=0; i<=nsteps; i++){ double param_value = double(i)*(max - min)/(nsteps) + min; myFile << " & " << std::setprecision(2) << param_value; } myFile << "\\\\ \\hline" << std::endl;
start_param = 0; for (unsigned int i=0; i < params.size(); i++){ for (unsigned int j=0; j < params.at(i)->nparameters(); j++){ unsigned int idx = start_param+j; if (params.at(i)->get_parameter(j)->get_step_size() != 0.0){ myFile << "$" << params.at(i)->get_parameter(j)->get_description() << "$"; for (unsigned int k=0; k <= nsteps; k++){ myFile << " & $" << std::setprecision(2) << mean_errors[idx][k] << " \\pm " << sigma_mean_errors[idx][k] << "$"; } myFile << "\\\\" << std::endl; } } start_param += params.at(i)->nparameters(); } myFile << "\\hline \\end{tabular}" << std::endl;
start_param = 0; for (unsigned int i=0; i < params.size(); i++){ for (unsigned int j=0; j < params.at(i)->nparameters(); j++){ unsigned int idx = start_param+j; //print result histos
if (params.at(i)->get_parameter(j)->get_step_size() != 0.0){ output->cd(); parameter* param = params.at(i)->get_parameter(j);
std::string error_name = "parameter scan sigma(" + param->get_name() + ")"; TCanvas *c1 = new TCanvas(error_name.c_str(), error_name.c_str(), 1600, 1200); c1->cd(); error_hists[idx]->Draw("e"); if (opts->write_eps) c1->Print(get_param_scan_path(param->get_name(),true).c_str(), "eps"); c1->Write(); delete error_hists[idx]; delete c1;
std::string value_name = "Parameter scan "+param->get_name(); TCanvas *c2 = new TCanvas(value_name.c_str(), value_name.c_str(), 1600, 1200); c2->cd(); value_hists[idx]->Draw("e"); if (opts->write_eps) c2->Print(get_param_scan_path(param->get_name(),false).c_str(), "eps"); c2->Write(); delete value_hists[idx]; delete c2;
//TODO add pulls
} } start_param += params.at(i)->nparameters(); } } else{ spdlog::error("Parameter "+param_name+" not found."); assert(0); } }
|