/***********************************************************************//**
* @brief Optimize function
*
* This code illustrates the optimization of a function.
***************************************************************************/
int main(void) {
// Allocate logger
GLog log;
log.cout(true);
// Allocate optimizer
GOptimizerLM opt;
// Allocate function
parabola fct;
// Allocate parameters and set initial value
GOptimizerPars pars(1);
pars[0]->value(1.5);
// Optimize parameters
opt.optimize(fct, pars);
// Print derivatives
std::cout << "Function value .....: " << fct.value() << std::endl;
std::cout << "Parameter value ....: " << pars[0]->value() << std::endl;
// Exit
return 0;
}
/***********************************************************************//**
* @brief Initialise class members
***************************************************************************/
void ctlike::init_members(void)
{
// Initialise members
m_outmodel.clear();
m_obs.clear();
m_refit = false;
m_max_iter = 100; // Set maximum number of iterations
m_max_stall = 10; // Set maximum number of stalls
m_logL = 0.0;
m_opt = NULL;
m_apply_edisp = false;
m_fix_spat_for_ts = false;
// Set logger properties
log.date(true);
// Allocate LM optimizer
GOptimizerLM* opt = new GOptimizerLM();
// Set optimizer parameters
opt->max_iter(m_max_iter);
opt->max_stalls(m_max_stall);
// Set optimizer pointer
m_opt = opt;
// Return
return;
}
/***********************************************************************//**
* @brief Test binned optimizer
***************************************************************************/
void TestGCTAOptimize::test_binned_optimizer(void)
{
// Declare observations
GObservations obs;
GCTAObservation run;
// Load binned CTA observation
test_try("Load binned CTA observation");
try {
run.load_binned(cta_cntmap);
run.response(cta_irf,cta_caldb);
obs.append(run);
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Load models from XML file
obs.models(cta_model_xml);
// Perform LM optimization
double fit_results[] = {83.6331, 0,
22.0145, 0,
5.616410411e-16, 1.904730785e-17,
-2.481781246, -0.02580905077,
300000, 0,
1, 0,
2.933677595, 0.06639644824,
6.550723074e-05, 1.945714239e-06,
-1.833781187, -0.0161464076,
1000000, 0,
1, 0};
test_try("Perform LM optimization");
try {
GOptimizerLM opt;
opt.max_iter(100);
obs.optimize(opt);
test_try_success();
for (int i = 0, j = 0; i < obs.models().size(); ++i) {
GModel* model = obs.models()[i];
for (int k = 0; k < model->size(); ++k) {
GModelPar& par = (*model)[k];
std::string msg = "Verify optimization result for " + par.print();
test_value(par.real_value(), fit_results[j++], 5.0e-5, msg);
test_value(par.real_error(), fit_results[j++], 5.0e-5, msg);
}
}
}
catch (std::exception &e) {
test_try_failure(e);
}
// Exit test
return;
}
/***********************************************************************//**
* @brief Test unbinned optimizer
***************************************************************************/
void TestGCTAOptimize::test_unbinned_optimizer(void)
{
// Declare observations
GObservations obs;
GCTAObservation run;
// Load unbinned CTA observation
test_try("Load unbinned CTA observation");
try {
run.load_unbinned(cta_events);
run.response(cta_irf,cta_caldb);
obs.append(run);
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Load models from XML file
obs.models(cta_model_xml);
// Perform LM optimization
double fit_results[] = {83.6331, 0,
22.0145, 0,
5.656246512e-16, 1.91458426e-17,
-2.484100472, -0.02573396361,
300000, 0,
1, 0,
2.993705325, 0.03572658413,
6.490832107e-05, 1.749021094e-06,
-1.833584022, -0.01512223495,
1000000, 0,
1, 0};
test_try("Perform LM optimization");
try {
GOptimizerLM opt;
opt.max_iter(100);
obs.optimize(opt);
test_try_success();
for (int i = 0, j = 0; i < obs.models().size(); ++i) {
GModel* model = obs.models()[i];
for (int k = 0; k < model->size(); ++k) {
GModelPar& par = (*model)[k];
std::string msg = "Verify optimization result for " + par.print();
test_value(par.real_value(), fit_results[j++], 5.0e-5, msg);
test_value(par.real_error(), fit_results[j++], 5.0e-5, msg);
}
}
}
catch (std::exception &e) {
test_try_failure(e);
}
// Exit test
return;
}
/***********************************************************************//**
* @brief Optimize model parameters using Levenberg-Marquardt method
***************************************************************************/
void ctlike::optimize_lm(void)
{
// Free any existing optimizer
if (m_opt != NULL) delete m_opt;
m_opt = NULL;
// Allocate optimizer. The logger is only passed to the optimizer
// constructor if optimizer logging is requested.
GOptimizerLM* opt = (logTerse()) ? new GOptimizerLM(log)
: new GOptimizerLM();
// Assign optimizer
m_opt = opt;
// Set optimizer parameters
opt->max_iter(m_max_iter);
opt->max_stalls(m_max_stall);
// Write Header for optimization and indent for optimizer logging
if (logTerse()) {
log << std::endl;
log.header1("Maximum likelihood optimisation");
log.indent(1);
}
// Perform LM optimization
m_obs.optimize(*opt);
// Optionally refit
if (m_refit) {
// Dump new header
log.indent(0);
if (logTerse()) {
log << std::endl;
log.header1("Maximum likelihood re-optimisation");
log.indent(1);
}
// Optimise again
m_obs.optimize(*opt);
}
// Compute errors
m_obs.errors(*opt);
// Store maximum log likelihood value
m_logL = -(opt->value());
// Remove indent
log.indent(0);
// Return
return;
}
/***********************************************************************//**
* @brief Test binned optimizer
*
* @param[in] datadir Directory of test data.
* @param[in] irf Instrument response function.
* @param[in] fit_results Expected fit result.
*
* Verifies the ability optimize binned Fermi/LAT data.
***************************************************************************/
void TestGLATOptimize::test_one_binned_optimizer(const std::string& datadir,
const std::string& irf,
const double* fit_results)
{
// Set filenames
std::string lat_srcmap = datadir+"/srcmap.fits";
std::string lat_expmap = datadir+"/binned_expmap.fits";
std::string lat_ltcube = datadir+"/ltcube.fits";
std::string lat_model_xml = datadir+"/source_model.xml";
// Setup GObservations for optimizing
GObservations obs;
GLATObservation run;
test_try("Setup for optimization");
try {
run.load_binned(lat_srcmap, lat_expmap, lat_ltcube);
run.response(irf, lat_caldb);
obs.append(run);
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Load models from XML file
obs.models(lat_model_xml);
// Setup LM optimizer
test_try("Perform LM optimization");
try {
GOptimizerLM opt;
opt.max_iter(1000);
obs.optimize(opt);
obs.errors(opt);
test_try_success();
for (int i = 0, j = 0; i < obs.models().size(); ++i) {
const GModel* model = obs.models()[i];
for (int k = 0; k < model->size(); ++k) {
GModelPar par = (*model)[k];
std::string msg = "Verify optimization result for " + par.print();
test_value(par.value(), fit_results[j++], 5.0e-5, msg);
test_value(par.error(), fit_results[j++], 5.0e-5, msg);
}
}
}
catch (std::exception &e) {
test_try_failure(e);
}
// Exit test
return;
}
/***********************************************************************//**
* @brief Re-optimize model parameters using Levenberg-Marquardt method
* for TS computation
***************************************************************************/
double ctlike::reoptimize_lm(void)
{
// Allocate optimizer. The logger is only passed to the optimizer
// constructor if optimizer logging is requested.
GOptimizerLM* opt = (logTerse()) ? new GOptimizerLM(log)
: new GOptimizerLM();
// Set optimizer parameters
opt->max_iter(m_max_iter);
opt->max_stalls(m_max_stall);
// Write Header for optimization and indent for optimizer logging
if (logTerse()) {
log << std::endl;
log.header1("Maximum likelihood re-optimisation");
log.indent(1);
}
// Perform LM optimization
m_obs.optimize(*opt);
// Optionally refit
if (m_refit) {
m_obs.optimize(*opt);
}
// Store maximum log likelihood value
double logL = -(opt->value());
// Write optimization results
log.indent(0);
if (logTerse()) {
log << std::endl;
log.header1("Maximum likelihood re-optimization results");
log << *opt << std::endl;
}
// Return
return (logL);
}
