/***********************************************************************//**
* @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 Get application parameters
*
* Get all task parameters from parameter file or (if required) by querying
* the user. Most parameters are only required if no observation exists so
* far in the observation container. In this case, a single CTA observation
* will be added to the container, using the definition provided in the
* parameter file.
***************************************************************************/
void ctbin::get_parameters(void)
{
// If there are no observations in container then add a single CTA
// observation using the parameters from the parameter file
if (m_obs.size() == 0) {
// Get name of CTA events file
m_evfile = (*this)["evfile"].filename();
// Allocate CTA observation
GCTAObservation obs;
// Try first to open as FITS file
try {
// Load event list in CTA observation
obs.load_unbinned(m_evfile);
// Append CTA observation to container
m_obs.append(obs);
// Signal that no XML file should be used for storage
m_use_xml = false;
}
// ... otherwise try to open as XML file
catch (GException::fits_open_error &e) {
// Load observations from XML file
m_obs.load(m_evfile);
// Signal that XML file should be used for storage
m_use_xml = true;
}
// Use the xref and yref parameters for binning (otherwise the
// pointing direction(s) is/are used)
//m_xref = (*this)["xref"].real();
//m_yref = (*this)["yref"].real();
} // endif: there was no observation in the container
// Get remaining parameters
m_emin = (*this)["emin"].real();
m_emax = (*this)["emax"].real();
m_enumbins = (*this)["enumbins"].integer();
m_proj = (*this)["proj"].string();
m_coordsys = (*this)["coordsys"].string();
m_xref = (*this)["xref"].real();
m_yref = (*this)["yref"].real();
m_binsz = (*this)["binsz"].real();
m_nxpix = (*this)["nxpix"].integer();
m_nypix = (*this)["nypix"].integer();
// Optionally read ahead parameters so that they get correctly
// dumped into the log file
if (m_read_ahead) {
m_outfile = (*this)["outfile"].filename();
m_prefix = (*this)["prefix"].string();
}
// Return
return;
}
/***********************************************************************//**
* @brief Test unbinned observation handling
***************************************************************************/
void TestGCTAObservation::test_unbinned_obs(void)
{
// Set filenames
const std::string file1 = "test_cta_obs_unbinned.xml";
// 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);
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Add observation (twice) to data
test_try("Load unbinned CTA observation");
try {
obs.append(run);
obs.append(run);
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Loop over all events using iterators
int num = 0;
for (GObservations::iterator event = obs.begin(); event != obs.end(); ++event) {
num++;
}
test_value(num, 8794, 1.0e-20, "Test observation iterator");
// Loop over all events using iterator
num = 0;
GCTAEventList *ptr = static_cast<GCTAEventList*>(const_cast<GEvents*>(run.events()));
for (GCTAEventList::iterator event = ptr->begin(); event != ptr->end(); ++event) {
num++;
}
test_value(num, 4397, 1.0e-20, "Test event iterator");
// Test XML loading
test_try("Test XML loading");
try {
obs = GObservations(cta_unbin_xml);
obs.save(file1);
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Exit test
return;
}
/***********************************************************************//**
* @brief Get application parameters
*
* Get all task parameters from parameter file or (if required) by querying
* the user. Times are assumed to be in the native CTA MJD format.
*
* This method also loads observations if no observations are yet allocated.
* Observations are either loaded from a single CTA even list, or from a
* XML file using the metadata information that is stored in that file.
***************************************************************************/
void ctselect::get_parameters(void)
{
// If there are no observations in container then add a single CTA
// observation using the parameters from the parameter file
if (m_obs.size() == 0) {
// Get CTA event list file name
m_infile = (*this)["infile"].filename();
// Allocate CTA observation
GCTAObservation obs;
// Try first to open as FITS file
try {
// Load event list in CTA observation
obs.load_unbinned(m_infile);
// Append CTA observation to container
m_obs.append(obs);
// Signal that no XML file should be used for storage
m_use_xml = false;
}
// ... otherwise try to open as XML file
catch (GException::fits_open_error &e) {
// Load observations from XML file
m_obs.load(m_infile);
// Signal that XML file should be used for storage
m_use_xml = true;
}
} // endif: there was no observation in the container
// Get parameters
m_usepnt = (*this)["usepnt"].boolean();
if (!m_usepnt) {
m_ra = (*this)["ra"].real();
m_dec = (*this)["dec"].real();
}
m_rad = (*this)["rad"].real();
m_tmin = (*this)["tmin"].real();
m_tmax = (*this)["tmax"].real();
m_emin = (*this)["emin"].real();
m_emax = (*this)["emax"].real();
m_expr = (*this)["expr"].string();
// Optionally read ahead parameters so that they get correctly
// dumped into the log file
if (m_read_ahead) {
m_outfile = (*this)["outfile"].filename();
m_prefix = (*this)["prefix"].string();
}
// Set time interval with input times given in CTA reference
// time (in seconds)
m_timemin.set(m_tmin, m_cta_ref);
m_timemax.set(m_tmax, m_cta_ref);
// Return
return;
}
