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; }