You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
245 lines
8.9 KiB
245 lines
8.9 KiB
/**
|
|
* @file parameters.hh
|
|
* @author Christoph Langenbruch, Renata Kopecna
|
|
* @date 2009-03-18
|
|
*
|
|
*/
|
|
#ifndef PARAMETERS_H
|
|
#define PARAMETERS_H
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace fcnc {
|
|
|
|
class parameters;
|
|
|
|
/// The parameter class stores the different attributes of a parameter used in the analysis, e.g. the name, start value and the parameter range.
|
|
class parameter {
|
|
friend class parameters;
|
|
friend class feldman_cousins;
|
|
private:
|
|
///blind this parameter
|
|
bool blind;
|
|
///blinding string
|
|
std::string blinding_string;
|
|
///blinding delta, never look at this
|
|
double blinding_delta;
|
|
///blinding range
|
|
double blinding_scale;
|
|
///This name is supplied as the parameter name to minuit. Please give every parameter a different name.
|
|
std::string name;
|
|
///The parameter description is used by the plotter for plot captions and axis titles.
|
|
std::string description;
|
|
///The start value of the parameter. After every step in the toy study, the parameter is reset to this value.
|
|
double start_value;
|
|
///The current value of the parameter
|
|
double value;
|
|
///The minimum possible value for the parameter
|
|
double min;
|
|
///The maximum possible value for the parameter
|
|
double max;
|
|
///The initial step size used by minuit
|
|
double step_size;
|
|
///The error of the fitted result
|
|
double error;
|
|
///asymmetric errors if a minos error analysis has been performed
|
|
double error_up;
|
|
///asymmetric errors if a minos error analysis has been performed
|
|
double error_down;
|
|
///the index of this parameter in the params array of the parameter set
|
|
int index;
|
|
///should the parameter float without limits?
|
|
bool unlimited;
|
|
///this has been the error of a previous measurement
|
|
double previous_error_low;
|
|
double previous_error_high;
|
|
///previous measurement, this can be different from the start value, e.g. when running a toy study
|
|
double previous_measurement;
|
|
///do we want to vary the parameter so that it is compatible with an earlier measurement
|
|
bool gaussian_constraint;
|
|
bool do_minos;
|
|
///pointer to parent parameterset this parameter was added to!
|
|
parameters* parent;
|
|
public:
|
|
///
|
|
void set_parent(parameters* p) {parent = p;};
|
|
//correlations
|
|
std::vector<double> correlations;
|
|
///public set routines
|
|
void set_name(std::string n) {name = n;};
|
|
void set_min(double m) {min = m;};
|
|
void set_max(double m) {max = m;};
|
|
void set_step_size(double s) {step_size = s;};
|
|
void set_value(double v) {value = v;};
|
|
void set_start_value(double v) {start_value = v;};
|
|
//void set_true_value(double v) {true_value = v;};
|
|
void set_description(std::string d) {description = d;};
|
|
void set_error(double e) {error = e;};
|
|
void set_error_down(double e) {error_down = e;};
|
|
void set_error_up(double e) {error_up = e;};
|
|
void set_unlimited(bool u) {unlimited = u;};
|
|
void set_index(int idx) {index = idx;};
|
|
void set_previous_measurement(double m) {previous_measurement = m;};
|
|
void set_previous_error_low(double e) {previous_error_low = e;};
|
|
void set_previous_error_high(double e) {previous_error_high = e;};
|
|
void set_values_n_errors(double v, double e);
|
|
void reset_correlations();
|
|
void set_correlation(double corr, unsigned int idx);
|
|
void set_correlations(std::vector<double> corrs, unsigned int first, unsigned int last, double scalefactor = 1.0);
|
|
|
|
///set blinding string
|
|
void set_blinding_string(std::string s);
|
|
void set_minos(bool minos) { do_minos = minos; };
|
|
bool get_minos() { return do_minos; };
|
|
void set_blinding(bool b, double b_scale, bool is_angle=false, std::string b_string="DefaultBlinder");
|
|
|
|
///set all values which make sense on initialisation
|
|
void init(double v, double min, double max, double stepsize)
|
|
{
|
|
set_value(v);
|
|
start_value = v;
|
|
set_min(min);
|
|
set_max(max);
|
|
set_step_size(stepsize);
|
|
set_error(0.0);
|
|
set_error_up(0.0);
|
|
set_error_down(0.0);
|
|
set_unlimited(false);
|
|
set_minos(false);
|
|
gaussian_constraint = false;
|
|
previous_measurement = v;
|
|
correlations.clear();
|
|
};
|
|
|
|
void init_fixed(double v){
|
|
init(v, v-0.01, v+0.01, 0.0);
|
|
//This eaquals to the previous init with limits of v-0.01, v+0.01
|
|
//Not sure if there is a < or <= further in the code, so let's play it safe
|
|
}
|
|
void init(double v, double min, double max, double stepsize, double previous_measurement_error, bool constrain)
|
|
{
|
|
init(v, min, max, stepsize);
|
|
previous_error_low = previous_measurement_error;
|
|
previous_error_high = previous_measurement_error;
|
|
gaussian_constraint = constrain;
|
|
}
|
|
void init(double v, double min, double max, double stepsize, double previous_measurement_error_low, double previous_measurement_error_high, bool constrain)
|
|
{
|
|
init(v, min, max, stepsize);
|
|
previous_error_low = previous_measurement_error_low;
|
|
previous_error_high = previous_measurement_error_high;
|
|
gaussian_constraint = constrain;
|
|
}
|
|
void init_unlimited( double v, double min, double max, double stepsize, bool nolimits)
|
|
{
|
|
init(v, min, max, stepsize);
|
|
unlimited = nolimits;
|
|
};
|
|
|
|
///public get routines
|
|
std::string get_name() const {return name;};
|
|
const char* get_mn_name() const {return get_name().c_str();};
|
|
double get_min() const {return min;};
|
|
double get_max() const {return max;};
|
|
double get_blinding_delta() const {return blinding_delta;};
|
|
double get_step_size() const {return step_size;};
|
|
double get_value() const {return value;};
|
|
double get_start_value() const {return start_value;};
|
|
//double get_true_value() const {return true_value;};
|
|
double get_previous_error() const {return 0.5*(previous_error_low+previous_error_high);};
|
|
double get_previous_error_low() const {return previous_error_low;};
|
|
double get_previous_error_high() const {return previous_error_high;};
|
|
double get_previous_measurement() const {return previous_measurement;};
|
|
std::string get_description() const {return description;};
|
|
bool get_unlimited() const {return unlimited;};
|
|
bool get_gaussian_constraint() const {return gaussian_constraint;};
|
|
|
|
std::string get_root_name() const;
|
|
///public set routines
|
|
void set_constant() {step_size = 0.0;};
|
|
double operator() () const {return value;};
|
|
double get_error() const {return error;};
|
|
double get_error_up() const {return error_up;};
|
|
double get_error_down() const {return error_down;};
|
|
int get_index() const {return index;};
|
|
void reset_start() {value = start_value; error = 0.0;};
|
|
///default constructor
|
|
parameter(std::string n, std::string d):
|
|
blind(false),
|
|
blinding_string("DefaultBlinder"),
|
|
blinding_delta(0.0),
|
|
name(n),
|
|
description(d),
|
|
start_value(0.0),
|
|
value(0.0),
|
|
min(-1.0),
|
|
max(+1.0),
|
|
step_size(0.001),
|
|
error(0.0),
|
|
error_up(0.0),
|
|
error_down(0.0),
|
|
index(-1),
|
|
unlimited(false),
|
|
previous_error_low(0.0),
|
|
previous_error_high(0.0),
|
|
previous_measurement(0.0),
|
|
gaussian_constraint(false)
|
|
{};
|
|
///normal constructor
|
|
parameter(std::string n, std::string d, double v,
|
|
double minimum, double maximum, double stepsize = 0.0, bool nolimits=false):
|
|
blind(false),
|
|
blinding_string("DefaultBlinder"),
|
|
blinding_delta(0.0),
|
|
name(n),
|
|
description(d),
|
|
start_value(v),
|
|
// true_value(v),
|
|
value(v),
|
|
min(minimum),
|
|
max(maximum),
|
|
step_size(stepsize),
|
|
error(0.0),
|
|
error_up(0.0),
|
|
error_down(0.0),
|
|
index(-1),
|
|
unlimited(nolimits),
|
|
gaussian_constraint(false)
|
|
{};
|
|
bool is_blind() {
|
|
return blind;
|
|
};
|
|
};
|
|
|
|
///The parameters class stores a collection of parameters used in the analysis. Every analysis should implement its own set e.g. bs2jpsiphi_parameters
|
|
class parameters
|
|
{
|
|
private:
|
|
///this vector holds the different parameters
|
|
std::vector<parameter*> params;
|
|
protected:
|
|
///Add a certain parameter to the params vector.
|
|
void add_parameter(parameter* param);
|
|
public:
|
|
bool is_blind() const;
|
|
virtual ~parameters() {};
|
|
///Method gives back he number of parameters
|
|
unsigned int nparameters() const;
|
|
///Methos returns a pointer to parameter with index i
|
|
parameter* get_parameter(unsigned int i) const;
|
|
///returns parameter with specific name
|
|
parameter* get_parameter(std::string name) const;
|
|
///Resets all parameters to their start values
|
|
void reset_parameters();
|
|
///Method that prints the parameter set, the current values, errors and the deviation from the start value in sigma
|
|
void print_parameters(bool latex_output=true) const;
|
|
///fix all parameters
|
|
void fix_parameters();
|
|
///set all parameters to current values! Careful with this, please.
|
|
void take_current_as_start();
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|