FunctionInfo::FunctionInfo(const ParValues & start_, const ParValues & step_, const Ranges & ranges_, const ParValues & fixed_parameters): start(start_), step(step_), ranges(ranges_){
ParIds pids = start.get_parameters();
for(ParIds::const_iterator pit=pids.begin(), it_end = pids.end(); pit!=it_end; ++pit){
if(!step.contains(*pit)) throw invalid_argument("FunctionInfo: step does not contain all parameters from start");
// 1. check whether parameter is fixed by step and range:
const pair<double, double> & r = ranges.get(*pit);
if(r.first==r.second){
if(step.get_unchecked(*pit)>0.0){
throw invalid_argument("FunctionInfo: inconsistent range/step given: range empty but step > 0");
}
fixed_parids.insert(*pit);
}
else{
if(step.get_unchecked(*pit)<=0.0){
throw invalid_argument("FunctionInfo: step <= 0.0 for non-empty range given");
}
}
// 2. check whether parameter is fixed by fixed_parameters. Note that
// the value given in fixed_parameter overrides the value according to start.
if(fixed_parameters.contains(*pit)){
double val = fixed_parameters.get(*pit);
start.set(*pit, val);
ranges.set(*pit, make_pair(val, val));
step.set(*pit, 0.0);
fixed_parids.insert(*pit);
}
}
}
boost::shared_ptr<FunctionInfo> Minimizer::create_nll_function_info(const Model & model, const boost::shared_ptr<Distribution> & override_parameter_distribution, const ParValues & fixed_parameters){
const Distribution & dist = override_parameter_distribution.get()? *override_parameter_distribution: model.get_parameter_distribution();
ParValues start;
dist.mode(start);
Ranges ranges(dist);
ParIds pids = fixed_parameters.get_parameters();
for(ParIds::const_iterator pit = pids.begin(); pit!=pids.end(); ++pit){
double val = fixed_parameters.get(*pit);
start.set(*pit, val);
ranges.set(*pit, make_pair(val, val));
}
ParValues step = asimov_likelihood_widths(model, override_parameter_distribution);
return boost::shared_ptr<FunctionInfo>(new DefFunctionInfo(start, step, ranges, fixed_parameters));
}
void cubiclinear_histomorph::add_morph_terms(HT & t, const ParValues & values) const{
const size_t n_sys = hplus_diff.size();
for (size_t isys = 0; isys < n_sys; isys++) {
const double delta = values.get(vid[isys]) * parameter_factors[isys];
if(delta==0.0) continue;
//linear extrpolation beyond 1 sigma:
if(fabs(delta) > 1){
const Histogram1D & t_sys = delta > 0 ? hplus_diff[isys] : hminus_diff[isys];
t.add_with_coeff(fabs(delta), t_sys);
}
else{
//cubic interpolation:
diff_total = diff[isys];
diff_total *= 0.5 * delta;
diff_total.add_with_coeff(delta * delta - 0.5 * pow(fabs(delta), 3), sum[isys]);
t += diff_total;
}
}
double h_sum = 0.0;
for(size_t i=0; i < t.get_nbins(); ++i){
double val = t.get(i);
if(val < 0.0){
t.set(i, 0.0);
}
else{
h_sum += val;
}
}
if(normalize_to_nominal && h_sum > 0.0){
t *= h0_sum / h_sum;
}
}
double multiply::operator()(const ParValues & v) const{
double result = literal_factor;
for(size_t i=0; i<v_pids.size(); ++i){
result *= v.get_unchecked(v_pids[i]);
}
for(size_t i=0; i<functions.size(); ++i){
result *= functions[i](v);
}
return result;
}
MinimizationResult Minimizer::minimize2(const Function & f, const FunctionInfo & info, const ParValues & fixed_parameters){
dynamic_cast<const DefFunctionInfo&>(info); // throws bad_cast
ParIds pids = fixed_parameters.get_parameters();
if(pids.size()==0){
return minimize(f, info.get_start(), info.get_step(), info.get_ranges());
}
else{
ParValues start(info.get_start());
ParValues step(info.get_step());
Ranges ranges(info.get_ranges());
const ParIds & info_fixed = info.get_fixed_parameters();
for(ParIds::const_iterator pit = pids.begin(); pit!=pids.end(); ++pit){
if(!info_fixed.contains(*pit)){
throw invalid_argument("fixed parameter in minimize2 which is not fixed in info. This is not allowed.");
}
double val = fixed_parameters.get(*pit);
start.set(*pit, val);
step.set(*pit, 0.0);
ranges.set(*pit, make_pair(val, val));
}
return minimize(f, start, step, ranges);
}
}
theta::ParValues asimov_likelihood_widths(const theta::Model & model, const boost::shared_ptr<Distribution> & override_parameter_distribution){
const Distribution & dist = override_parameter_distribution.get()? *override_parameter_distribution: model.get_parameter_distribution();
ParIds parameters = model.getParameters();
ParValues mode;
dist.mode(mode);
Data asimov_data;
model.get_prediction(asimov_data, mode);
std::auto_ptr<NLLikelihood> nll = model.getNLLikelihood(asimov_data);
//0 value has same semantics for NLLikelihood:
nll->set_override_distribution(override_parameter_distribution);
double nll_at_min = (*nll)(mode);
ParValues result;
int k=0;
for(ParIds::const_iterator it=parameters.begin(); it!=parameters.end(); ++it, ++k){
ParId pid = *it;
const double pid_mode = mode.get(pid);
std::pair<double, double> support = dist.support(pid);
assert(support.first <= pid_mode && pid_mode <= support.second);
if(support.first == support.second){
result.set(pid, 0.0);
continue;
}
nll_mode_pid f(mode, pid, *nll, nll_at_min + 0.5);
//if one end is finite, try to use it. Save whether the interval end is considered
// "fl0", i.e. the interval end itself is finite but the function value there is invalid (< 0).
bool low_is_fl0 = false, high_is_fl0 = false;
if(std::isfinite(support.second)){
double f2 = f(support.second);
if(f2==0.0){
result.set(pid, fabs(pid_mode - support.second));
continue;
}
if(!std::isfinite(f2) || f2 < 0){
low_is_fl0 = true;
}
else{
result.set(pid, fabs(pid_mode - secant(pid_mode, support.second, 0.0, -0.5, f2, 0.05, f)));
continue;
}
}
if(std::isfinite(support.first)){
double f2 = f(support.first);
if(f2==0.0){
result.set(pid, fabs(pid_mode - support.first));
continue;
}
if(!std::isfinite(f2) || f2 < 0){
high_is_fl0 = true;
}
else{
result.set(pid, fabs(pid_mode - secant(support.first, pid_mode, 0.0, f2, -0.5, 0.05, f)));
continue;
}
}
//the support was either infinite or the values at the borders were not sufficiently high.
// Treat second case first:
if(low_is_fl0 && high_is_fl0){
result.set(pid, support.second - support.first);
continue;
}
//Now, one of the interval ends has to be infinite, otherwise we would not be here.
//Scan in that direction:
assert(std::isinf(support.first) || std::isinf(support.second));
bool found = false;
for(double sign = -1.0; sign <= 1.001; sign+=2.0){
if(!std::isinf(support.first) && sign < 0) continue;
if(!std::isinf(support.second) && sign > 0) continue;
// as step size, try the parameter value, if it is not zero:
double step = fabs(pid_mode);
if(step==0) step = 1.0;
for(int i=0; i<1000; ++i){
double fval = f(pid_mode + sign * step);
if(isinf(fval)){
step /= 1.5;
continue;
}
step *= 2.0;
if(fval > 0){
double xlow, xhigh, flow, fhigh;
xlow = pid_mode; flow = -0.5;
xhigh = pid_mode + sign * step; fhigh = fval;
if(sign < 0){
std::swap(xlow, xhigh);
std::swap(flow, fhigh);
}
assert(xlow <= xhigh);
result.set(pid, fabs(pid_mode - secant(xlow, xhigh, 0.0, flow, fhigh, 0.05, f)));
found = true;
break;
}
}
if(found) break;
}
if(found) continue;
stringstream ss;
ss << "asimov_likelihood_widths: could not find width for parameter " << pid;
throw Exception(ss.str());
}
return result;
}
