static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
struct params *params = state->input;
switch (key)
{
case ARGP_KEY_NO_ARGS:
printf ("NO ARGS\n");
break;
case ARGP_KEY_ARG:
if (state->arg_num > 0)
return ARGP_ERR_UNKNOWN; /* Leave it for the sub-arg parser. */
printf ("ARG: %s\n", arg);
break;
case 'f':
if (arg)
params->foonly = atoi (arg);
else
params->foonly = params->foonly_default;
popt (key, arg);
break;
case 'p': case 'P': case OPT_PGRP: case 'x': case 'Q':
case 'r': case OPT_SESS: case 'z':
popt (key, arg);
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
void Minimizer_minimizeManyTimes (Minimizer me, long numberOfTimes, long maxIterationsPerTime, double tolerance) {
double fopt = my minimum;
int monitorSingle = numberOfTimes == 1;
autoNUMvector<double> popt (NUMvector_copy<double> (my p, 1, my nParameters), 1);
if (! monitorSingle) {
Melder_progress (0.0, L"Minimize many times");
}
/* on first iteration start with current parameters 27/11/97 */
for (long i = 1; i <= numberOfTimes; i++) {
Minimizer_minimize (me, maxIterationsPerTime, tolerance, monitorSingle);
Melder_casual ("Current %ld: minimum = %.17g", i, my minimum);
if (my minimum < fopt) {
NUMvector_copyElements (my p, popt.peek(), 1, my nParameters);
fopt = my minimum;
}
Minimizer_reset (me, 0);
if (! monitorSingle) {
try {
Melder_progress ( (double) i / numberOfTimes, Melder_integer (i), L" from ",
Melder_integer (numberOfTimes)); therror
} catch (MelderError) {
Melder_clearError (); // interrurpt, no error
break;
}
}
}
if (! monitorSingle) {
Melder_progress (1.0, 0);
}
Minimizer_reset (me, popt.peek());
}
int main(int argc, char* argv[])
{
// Number of threads
unsigned int n_threads = boost::thread::hardware_concurrency();
std::cout << "Number of available threads " << n_threads << std::endl;
likelihood l(5, 5, 9);
double nexp[5][5] = {{1., 1.6, 0.6, 0.2, 0.0},
{0., 15.4, 2.3, 0.0, 0.0},
{0., 2.5, 4.1, 0.0, 0.0},
{0., 3.3, 0.0, 1.1, 0.0},
{0., 9.5, 10.0, 0.7, 39.2}};
std::cout << "n(regions) = " << l.nr()
<< ", n(processes) = " << l.np()
<< ", n(systematics) = " << l.ns() << std::endl;
for (unsigned int ir = 0; ir < l.nr(); ir++)
for (unsigned int ip = 0; ip < l.np(); ip++) {
l.set_nexp(ir, ip, nexp[ir][ip]);
for (unsigned int is = 0; is < l.ns(); is++) {
double dsyst = 0.;
if (is < 2 && ip != 4) // Jet/MET
dsyst = (0.1 - 0.05 * is) * (1. + ir * 0.05);
else if (is < 7 && (is - 2 == ip)) // Theory
dsyst = (ip == 4) ? 1. : 0.5;
else if (is == 7 && (ir == 1 || ir == 2)) // b-tagging
dsyst = (-1. + (ir - 1) * 2.) * 0.1;
else if (is == 8) // Photon id efficiency
dsyst = 0.05;
l.set_dsyst(ir, ip, is, dsyst);
}
}
// Setup minimizer
unsigned int nparams = l.np()+l.ns();
boost::scoped_array<double> p0(new double[nparams]);
boost::scoped_array<double> popt(new double[nparams]);
for (unsigned int i = 0; i < nparams; i++)
p0[i] = (i < l.np()) ? 1. : 0.;
boost::function<double (double * const)> feval;
feval = boost::bind(&likelihood::eval, &l, _1);
optimize::minimizer_nm mle_nm(feval, l.np()+l.ns());
optimize::minimizer_bfgs mle_bfgs(feval, l.np()+l.ns());
// Setup random generation of poisson distributed numbers
boost::mt19937 gen;
typedef boost::poisson_distribution<unsigned int> t_poisson;
typedef boost::scoped_ptr< t_poisson > t_ptr_poisson;
typedef boost::variate_generator< boost::mt19937&, t_poisson > t_gen;
typedef boost::scoped_ptr< t_gen > t_ptr_gen;
boost::scoped_array< t_ptr_poisson > pdist(new t_ptr_poisson[l.nr()]);
boost::scoped_array< t_ptr_gen > rndgen(new t_ptr_gen[l.ns()]);
for (unsigned int ir = 0; ir < l.nr(); ir++) {
std::cout << "region" << ir << " nexp = "
<< l.nexp(ir, p0.get()) << std::endl;
pdist[ir].reset(new t_poisson(l.nexp(ir, p0.get())));
rndgen[ir].reset(new t_gen(gen, *(pdist[ir])));
}
boost::timer time_monitor;
double dt[3] = {0., 0., 0.};
unsigned int ntoys = 10;
for (unsigned int iexp = 0; iexp < ntoys; iexp++) {
std::cout << "Starting experiment " << iexp << std::endl;
// Generate pseudo-experiment random numbers
for (unsigned int ir = 0; ir < l.nr(); ir++) {
l.set_nobs(ir, (*(rndgen[ir]))());
std::cout << " region" << ir
<< " nobs = " << l.nobs(ir)
<< " nexp = " << l.nexp(ir, p0.get()) << std::endl;
}
std::cout << " Perform a minimization " << std::endl;
// Minimize with Nelder-Mean without mt
mle_nm.set_is_mt(false);
time_monitor.restart();
mle_nm.minimize(p0.get());
dt[0] = time_monitor.elapsed();
std::cout << " min = (";
for (size_t i = 0; i < nparams; i++)
popt[i] = mle_nm.get_opt_var(i).value();
for (size_t i = 0; i < nparams; i++) {
if (i < l.nr())
std::cout << l.nexp(i, popt.get());
else
std::cout << mle_nm.get_opt_var(i).value();
if (i < nparams - 1) std::cout << ", ";
}
std::cout << ") fmin = " << mle_nm.get_fmin() << std::endl;
// Minimize with Nelder-Mean with mt
mle_nm.set_is_mt(true);
time_monitor.restart();
mle_nm.minimize(p0.get());
dt[1] = time_monitor.elapsed();
std::cout << " min = (";
for (size_t i = 0; i < nparams; i++)
popt[i] = mle_nm.get_opt_var(i).value();
for (size_t i = 0; i < nparams; i++) {
if (i < l.nr())
std::cout << l.nexp(i, popt.get());
else
std::cout << mle_nm.get_opt_var(i).value();
if (i < nparams - 1) std::cout << ", ";
}
std::cout << ") fmin = " << mle_nm.get_fmin() << std::endl;
// Minimize with BFGS
time_monitor.restart();
mle_bfgs.minimize(p0.get());
dt[2] = time_monitor.elapsed();
std::cout << " min = (";
for (size_t i = 0; i < nparams; i++)
popt[i] = mle_bfgs.get_opt_var(i).value();
for (size_t i = 0; i < nparams; i++) {
if (i < l.nr())
std::cout << l.nexp(i, popt.get());
else
std::cout << mle_bfgs.get_opt_var(i).value();
if (i < nparams - 1) std::cout << ", ";
}
std::cout << ") fmin = " << mle_bfgs.get_fmin() << std::endl;
std::cout << " timing " << dt[0] << " " << dt[1] << " " << dt[2]
<< std::endl;
std::cout << " ... done." << std::endl;
}
return 0;
}
