/***********************************************************************//**
* @brief Test binned observation handling
***************************************************************************/
void TestGCTAObservation::test_binned_obs(void)
{
// Set filenames
const std::string file1 = "test_cta_obs_binned.xml";
// Declare observations
GObservations obs;
GCTAObservation run;
// Load binned CTA observation
test_try("Load unbinned CTA observation");
try {
run.load_binned(cta_cntmap);
run.response(cta_irf,cta_caldb);
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Test XML loading
test_try("Test XML loading");
try {
obs = GObservations(cta_bin_xml);
obs.save(file1);
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Exit test
return;
}
/***********************************************************************//**
* @brief Save counts map(s) in XML format.
*
* Save the counts map(s) into FITS files and write the file path information
* into a XML file. The filename of the XML file is specified by the
* m_outfile member, the filename(s) of the counts map(s) are built by
* prepending the prefix given by the m_prefix member to the input counts
* map(s) filenames. Any path present in the input filename will be stripped,
* i.e. the counts map(s) will be written in the local working directory
* (unless a path is specified in the m_prefix member).
***************************************************************************/
void ctbin::save_xml(void)
{
// Get output filename and prefix
m_outfile = (*this)["outfile"].filename();
m_prefix = (*this)["prefix"].string();
// Loop over all observation in the container
for (int i = 0; i < m_obs.size(); ++i) {
// Get CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(&m_obs[i]);
// Handle only CTA observations
if (obs != NULL) {
// Set event output file name
std::string outfile = set_outfile_name(m_infiles[i]);
// Store output file name in observation
obs->eventfile(outfile);
// Save event list
save_counts_map(obs, outfile);
} // endif: observation was a CTA observations
} // endfor: looped over observations
// Save observations in XML file
m_obs.save(m_outfile);
// Return
return;
}
/***********************************************************************//**
* @brief Save counts cube
*
* This method saves the counts cube into a FITS file.
***************************************************************************/
void ctbin::save(void)
{
// Write header
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Save observations");
}
else {
log.header1("Save observation");
}
}
// Get output filename
m_outcube = (*this)["outcube"].filename();
// Get CTA observation from observation container
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[0]);
// Save only if observation is valid
if (obs != NULL) {
obs->save(m_outcube, clobber());
}
// Return
return;
}
/***********************************************************************//**
* @brief Generate the model map(s)
*
* This method reads the task parameters from the parfile, sets up the
* observation container, loops over all CTA observations in the container
* and generates a PSF cube from the CTA observations.
***************************************************************************/
void ctpsfcube::run(void)
{
// If we're in debug mode then all output is also dumped on the screen
if (logDebug()) {
log.cout(true);
}
// Get task parameters
get_parameters();
// Write parameters into logger
if (logTerse()) {
log_parameters();
log << std::endl;
}
// Set energy dispersion flag for all CTA observations and save old
// values in save_edisp vector
std::vector<bool> save_edisp;
save_edisp.assign(m_obs.size(), false);
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs != NULL) {
save_edisp[i] = obs->response()->apply_edisp();
obs->response()->apply_edisp(m_apply_edisp);
}
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Observations");
}
else {
log.header1("Observation");
}
log << m_obs << std::endl;
}
// Write header
if (logTerse()) {
log << std::endl;
log.header1("Generate PSF cube");
}
// Fill PSF
m_psfcube.fill(m_obs);
// Restore energy dispersion flag for all CTA observations
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs != NULL) {
obs->response()->apply_edisp(save_edisp[i]);
}
}
// Return
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 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 Save event list(s) in XML format.
*
* Save the event list(s) into FITS files and write the file path information
* into a XML file. The filename of the XML file is specified by the outfile
* parameter, the filename(s) of the event lists are built by prepending a
* prefix to the input event list filenames. Any path present in the input
* filename will be stripped, i.e. the event list(s) will be written in the
* local working directory (unless a path is specified in the prefix).
***************************************************************************/
void ctobssim::save_xml(void)
{
// Get output filename and prefix
m_outevents = (*this)["outevents"].filename();
m_prefix = (*this)["prefix"].string();
// Issue warning if output filename has no .xml suffix
std::string suffix = gammalib::tolower(m_outevents.substr(m_outevents.length()-4,4));
if (suffix != ".xml") {
log << "*** WARNING: Name of observation definition output file \""+
m_outevents+"\"" << std::endl;
log << "*** WARNING: does not terminate with \".xml\"." << std::endl;
log << "*** WARNING: This is not an error, but might be misleading."
" It is recommended" << std::endl;
log << "*** WARNING: to use the suffix \".xml\" for observation"
" definition files." << std::endl;
}
// Save only if event lists have not yet been saved and disposed
if (!m_save_and_dispose) {
// Loop over all observation in the container
for (int i = 0; i < m_obs.size(); ++i) {
// Get CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
// Handle only CTA observations
if (obs != NULL) {
// Continue only if there is an event list (it may have been disposed)
if (obs->events()->size() != 0) {
// Set event output file name
std::string outfile = m_prefix + gammalib::str(i) + ".fits";
// Store output file name in observation
obs->eventfile(outfile);
// Save observation into FITS file
obs->save(outfile, clobber());
}
} // endif: observation was a CTA observations
} // endfor: looped over observations
} // endif: event list has not yet been saved and disposed
// Save observations in XML file
m_obs.save(m_outevents);
// Return
return;
}
/***********************************************************************//**
* @brief Save event list(s) in XML format.
*
* Save the event list(s) into FITS files and write the file path information
* into a XML file. The filename of the XML file is specified by the outfile
* parameter, the filename(s) of the event lists are built by prepending a
* prefix to the input event list filenames. Any path present in the input
* filename will be stripped, i.e. the event list(s) will be written in the
* local working directory (unless a path is specified in the prefix).
***************************************************************************/
void ctobssim::save_xml(void)
{
// Get output filename and prefix
m_outfile = (*this)["outfile"].filename();
m_prefix = (*this)["prefix"].string();
// Issue warning if output filename has no .xml suffix
std::string suffix = gammalib::tolower(m_outfile.substr(m_outfile.length()-4,4));
if (suffix != ".xml") {
log << "*** WARNING: Name of observation definition output file \""+
m_outfile+"\"" << std::endl;
log << "*** WARNING: does not terminate with \".xml\"." << std::endl;
log << "*** WARNING: This is not an error, but might be misleading."
" It is recommended" << std::endl;
log << "*** WARNING: to use the suffix \".xml\" for observation"
" definition files." << std::endl;
}
// Initialise file number
int file_num = 0;
// Loop over all observation in the container
for (int i = 0; i < m_obs.size(); ++i) {
// Get CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
// Handle only CTA observations
if (obs != NULL) {
// Set event output file name
std::string outfile = m_prefix + gammalib::str(file_num) + ".fits";
// Store output file name in observation
obs->eventfile(outfile);
// Save observation into FITS file
obs->save(outfile, clobber());
// Increment file number
file_num++;
} // endif: observation was a CTA observations
} // endfor: looped over observations
// Save observations in XML file
m_obs.save(m_outfile);
// Return
return;
}
/***********************************************************************//**
* @brief Save event list in FITS format.
*
* Save the event list as a FITS file. The filename of the FITS file is
* specified by the outfile parameter.
***************************************************************************/
void ctobssim::save_fits(void)
{
// Get output filename
m_outfile = (*this)["outfile"].filename();
// Get CTA observation from observation container
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[0]);
// Save observation into FITS file
obs->save(m_outfile, clobber());
// Return
return;
}
/***********************************************************************//**
* @brief Test CTA Npred computation
*
* Tests the Npred computation for the diffuse source model. This is done
* by loading the model from the XML file and by calling the
* GCTAObservation::npred method which in turn calls the
* GCTAResponse::npred_diffuse method. The test takes a few seconds.
***************************************************************************/
void TestGCTAResponse::test_response_npred_diffuse(void)
{
// Set reference value
double ref = 11212.26274;
// Set parameters
double src_ra = 201.3651;
double src_dec = -43.0191;
double roi_rad = 4.0;
// Setup ROI centred on Cen A with a radius of 4 deg
GCTARoi roi;
GCTAInstDir instDir;
instDir.radec_deg(src_ra, src_dec);
roi.centre(instDir);
roi.radius(roi_rad);
// Setup pointing on Cen A
GSkyDir skyDir;
skyDir.radec_deg(src_ra, src_dec);
GCTAPointing pnt;
pnt.dir(skyDir);
// Setup dummy event list
GGti gti;
GEbounds ebounds;
GTime tstart(0.0);
GTime tstop(1800.0);
GEnergy emin;
GEnergy emax;
emin.TeV(0.1);
emax.TeV(100.0);
gti.append(tstart, tstop);
ebounds.append(emin, emax);
GCTAEventList events;
events.roi(roi);
events.gti(gti);
events.ebounds(ebounds);
// Setup dummy CTA observation
GCTAObservation obs;
obs.ontime(1800.0);
obs.livetime(1600.0);
obs.deadc(1600.0/1800.0);
obs.response(cta_irf, cta_caldb);
obs.events(&events);
obs.pointing(pnt);
// Load models for Npred computation
GModels models(cta_rsp_xml);
// Perform Npred computation
double npred = obs.npred(models, NULL);
// Test Npred
test_value(npred, ref, 1.0e-5, "Diffuse Npred computation");
// Return
return;
}
/***********************************************************************//**
* @brief Save event list in FITS format.
*
* Save the event list as a FITS file. The filename of the FITS file is
* specified by the outfile parameter.
***************************************************************************/
void ctobssim::save_fits(void)
{
// Save only if event list has not yet been saved and disposed
if (!m_save_and_dispose) {
// Get output filename
m_outevents = (*this)["outevents"].filename();
// Get CTA observation from observation container
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[0]);
// Save observation into FITS file
obs->save(m_outevents, clobber());
} // endif: event list has not yet been saved and disposed
// Return
return;
}
/***********************************************************************//**
* @brief Set exposure cube from one CTA observation
*
* @param[in] obs CTA observation.
*
* Set the exposure cube from a single CTA observations. The cube pixel
* values are computed as product of the effective area and the livetime.
*
* @todo: Throw an exception if response is not valid
***************************************************************************/
void GCTACubeExposure::set(const GCTAObservation& obs)
{
// Clear GTIs, reset livetime and exposure cube pixels
m_gti.clear();
m_livetime = 0.0;
m_cube = 0.0;
// Extract region of interest from CTA observation
GCTARoi roi = obs.roi();
// Get references on CTA response and pointing direction
const GCTAResponseIrf* rsp = dynamic_cast<const GCTAResponseIrf*>(obs.response());
const GSkyDir& pnt = obs.pointing().dir();
// Continue only if response is valid
if (rsp != NULL) {
// Loop over all pixels in sky map
for (int pixel = 0; pixel < m_cube.npix(); ++pixel) {
// Get pixel sky direction
GSkyDir dir = m_cube.inx2dir(pixel);
// Continue only if pixel is within RoI
if (roi.centre().dir().dist_deg(dir) <= roi.radius()) {
// Compute theta angle with respect to pointing direction
// in radians
double theta = pnt.dist(dir);
// Loop over all exposure cube energy bins
for (int iebin = 0; iebin < m_ebounds.size(); ++iebin){
// Get logE/TeV
double logE = m_ebounds.elogmean(iebin).log10TeV();
// Set exposure cube (effective area * lifetime)
m_cube(pixel, iebin) = rsp->aeff(theta, 0.0, 0.0, 0.0, logE) *
obs.livetime();
} // endfor: looped over energy bins
} // endif: pixel was within RoI
} // endfor: looped over all pixels
// Append GTIs and increment livetime
m_gti.extend(obs.gti());
m_livetime += obs.livetime();
} // endif: response was valid
// 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 Test CTA IRF computation for diffuse source model
*
* Tests the IRF computation for the diffuse source model. This is done
* by calling the GCTAObservation::model method which in turn calls the
* GCTAResponse::irf_diffuse method. The test is done for a small counts
* map to keep the test executing reasonably fast.
***************************************************************************/
void TestGCTAResponse::test_response_irf_diffuse(void)
{
// Set reference value
double ref = 13803.800313356;
// Set parameters
double src_ra = 201.3651;
double src_dec = -43.0191;
int nebins = 5;
// Setup pointing on Cen A
GSkyDir skyDir;
skyDir.radec_deg(src_ra, src_dec);
GCTAPointing pnt;
pnt.dir(skyDir);
// Setup skymap (10 energy layers)
GSkymap map("CAR", "CEL", src_ra, src_dec, 0.5, 0.5, 10, 10, nebins);
// Setup time interval
GGti gti;
GTime tstart(0.0);
GTime tstop(1800.0);
gti.append(tstart, tstop);
// Setup energy boundaries
GEbounds ebounds;
GEnergy emin;
GEnergy emax;
emin.TeV(0.1);
emax.TeV(100.0);
ebounds.setlog(emin, emax, nebins);
// Setup event cube centered on Cen A
GCTAEventCube cube(map, ebounds, gti);
// Setup dummy CTA observation
GCTAObservation obs;
obs.ontime(1800.0);
obs.livetime(1600.0);
obs.deadc(1600.0/1800.0);
obs.response(cta_irf, cta_caldb);
obs.events(&cube);
obs.pointing(pnt);
// Load model for IRF computation
GModels models(cta_rsp_xml);
// Reset sum
double sum = 0.0;
// Iterate over all bins in event cube
for (int i = 0; i < obs.events()->size(); ++i) {
// Get event pointer
const GEventBin* bin = (*(static_cast<const GEventCube*>(obs.events())))[i];
// Get model and add to sum
double model = obs.model(models, *bin, NULL) * bin->size();
sum += model;
}
// Test sum
test_value(sum, ref, 1.0e-5, "Diffuse IRF computation");
// Return
return;
}
/***********************************************************************//**
* @brief Computes
***************************************************************************/
void cterror::run(void)
{
// If we're in debug mode then all output is also dumped on the screen
if (logDebug()) {
log.cout(true);
}
// Get task parameters
get_parameters();
// Write parameters into logger
if (logTerse()) {
log_parameters();
log << std::endl;
}
// Set energy dispersion flag for all CTA observations and save old
// values in save_edisp vector
std::vector<bool> save_edisp;
save_edisp.assign(m_obs.size(), false);
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs != NULL) {
save_edisp[i] = obs->response()->apply_edisp();
obs->response()->apply_edisp(m_apply_edisp);
}
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Observations");
}
else {
log.header1("Observation");
}
log << m_obs << std::endl;
}
// Write header
if (logTerse()) {
log << std::endl;
log.header1("Compute best-fit likelihood");
}
// Optimize and save best log-likelihood
m_obs.optimize(m_opt);
m_obs.errors(m_opt);
m_best_logL = m_obs.logL();
// Store optimizer for later recovery
GOptimizerLM best_opt = m_opt;
// Write optimised model into logger
if (logTerse()) {
log << m_opt << std::endl;
log << gammalib::parformat("Maximum log likelihood");
log << gammalib::str(m_best_logL,3) << std::endl;
log << m_obs.models() << std::endl;
}
// Continue only if source model exists
if (m_obs.models().contains(m_srcname)) {
// Save best fitting models
GModels models_best = m_obs.models();
// Get pointer on model
GModel* model = models_best[m_srcname];
// Get number of parameters
int npars = model->size();
// Loop over parameters of sky model
for (int i = 0; i < npars; ++i) {
// Skip parameter if it is fixed
if (model->at(i).is_fixed()) {
continue;
}
// Initialise with best fitting models
m_obs.models(models_best);
// Get pointer on model parameter
GModels& current_models = const_cast<GModels&>(m_obs.models());
m_model_par = &(current_models[m_srcname]->at(i));
// Extract current value
m_value = m_model_par->factor_value();
// Compute parameter bracketing
double parmin = std::max(m_model_par->factor_min(),
m_value - 10.0*m_model_par->factor_error());
double parmax = std::min(m_model_par->factor_max(),
m_value + 10.0*m_model_par->factor_error());
// Write header
if (logTerse()) {
log << std::endl;
log.header1("Compute error for source \""+m_srcname+"\""
" parameter \""+m_model_par->name()+"\"");
log << gammalib::parformat("Confidence level");
log << m_confidence*100.0 << "%" << std::endl;
log << gammalib::parformat("Log-likelihood difference");
log << m_dlogL << std::endl;
log << gammalib::parformat("Initial factor range");
log << "[";
log << parmin;
log << ", ";
log << parmax;
log << "]" << std::endl;
}
// Compute lower boundary
double value_lo = error_bisection(parmin, m_value);
// Write lower parameter value
if (logTerse()) {
log << gammalib::parformat("Lower parameter factor");
log << value_lo << std::endl;
}
// Compute upper boundary
double value_hi = error_bisection(m_value, parmax);
// Write upper parameter value
if (logTerse()) {
log << gammalib::parformat("Upper parameter factor");
log << value_hi << std::endl;
}
// Compute errors
double error = 0.5 * (value_hi - value_lo);
double error_neg = m_value - value_lo;
double error_pos = value_hi - m_value;
//double error_max = std::max(value_hi-m_value, m_value-value_lo);
//double error_min = std::min(value_hi-m_value, m_value-value_lo);
// Write errors
if (logTerse()) {
log << gammalib::parformat("Error from curvature");
log << m_model_par->error();
log << " " << m_model_par->unit() << std::endl;
log << gammalib::parformat("Error from profile");
log << std::abs(error*m_model_par->scale());
log << " " << m_model_par->unit() << std::endl;
log << gammalib::parformat("Negative profile error");
log << std::abs(error_neg*m_model_par->scale());
log << " " << m_model_par->unit() << std::endl;
log << gammalib::parformat("Positive profile error");
log << std::abs(error_pos*m_model_par->scale());
log << " " << m_model_par->unit() << std::endl;
}
// Save error result
model->at(i).factor_error(error);
} // endfor: looped over spectral parameters
// Restore best fitting models (now with new errors computed)
m_obs.models(models_best);
} // endif: source model exists
// Recover optimizer
m_opt = best_opt;
// Restore energy dispersion flag for all CTA observations
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs != NULL) {
obs->response()->apply_edisp(save_edisp[i]);
}
}
// Return
return;
}
/***********************************************************************//**
* @brief Simulate event data
*
* This method runs the simulation. Results are not saved by this method.
* Invoke "save" to save the results.
***************************************************************************/
void ctobssim::run(void)
{
// Switch screen logging on in debug mode
if (logDebug()) {
log.cout(true);
}
// Get parameters
get_parameters();
// Write input parameters into logger
if (logTerse()) {
log_parameters();
log << std::endl;
}
// Special mode: if read ahead is specified we know that we called
// the execute() method, hence files are saved immediately and event
// lists are disposed afterwards.
if (read_ahead()) {
m_save_and_dispose = true;
}
// Determine the number of valid CTA observations, set energy dispersion flag
// for all CTA observations and save old values in save_edisp vector
int n_observations = 0;
std::vector<bool> save_edisp;
save_edisp.assign(m_obs.size(), false);
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs != NULL) {
save_edisp[i] = obs->response()->apply_edisp();
obs->response()->apply_edisp(m_apply_edisp);
n_observations++;
}
}
// If more than a single observation has been handled then make sure that
// an XML file will be used for storage
if (n_observations > 1) {
m_use_xml = true;
}
// Write execution mode into logger
if (logTerse()) {
log << std::endl;
log.header1("Execution mode");
log << gammalib::parformat("Event list management");
if (m_save_and_dispose) {
log << "Save and dispose (reduces memory needs)" << std::endl;
}
else {
log << "Keep events in memory" << std::endl;
}
log << gammalib::parformat("Output format");
if (m_use_xml) {
log << "Write Observation Definition XML file" << std::endl;
}
else {
log << "Write single event list FITS file" << std::endl;
}
}
// Write seed values into logger
if (logTerse()) {
log << std::endl;
log.header1("Seed values");
for (int i = 0; i < m_rans.size(); ++i) {
log << gammalib::parformat("Seed "+gammalib::str(i));
log << gammalib::str(m_rans[i].seed()) << std::endl;
}
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Observations");
}
else {
log.header1("Observation");
}
log << m_obs << std::endl;
}
// Write header
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Simulate observations");
}
else {
log.header1("Simulate observation");
}
}
// From here on the code can be parallelized if OpenMP support
// is enabled. The code in the following block corresponds to the
// code that will be executed in each thread
#pragma omp parallel
{
// Each thread will have it's own logger to avoid conflicts
GLog wrklog;
if (logDebug()) {
wrklog.cout(true);
}
// Allocate and initialize copies for multi-threading
GModels models(m_obs.models());
// Copy configuration from application logger to thread logger
wrklog.date(log.date());
wrklog.name(log.name());
// Set a big value to avoid flushing
wrklog.max_size(10000000);
// Loop over all observation in the container. If OpenMP support
// is enabled, this loop will be parallelized.
#pragma omp for
for (int i = 0; i < m_obs.size(); ++i) {
// Get pointer on CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
// Continue only if observation is a CTA observation
if (obs != NULL) {
// Write header for observation
if (logTerse()) {
if (obs->name().length() > 1) {
wrklog.header3("Observation "+obs->name());
}
else {
wrklog.header3("Observation");
}
}
// Work on a clone of the CTA observation. This makes sure that
// any memory allocated for computing (for example a response
// cache) is properly de-allocated on exit of this run
GCTAObservation obs_clone = *obs;
// Save number of events before entering simulation
int events_before = obs_clone.events()->size();
// Simulate source events
simulate_source(&obs_clone, models, m_rans[i], &wrklog);
// Simulate source events
simulate_background(&obs_clone, models, m_rans[i], &wrklog);
// Dump simulation results
if (logNormal()) {
wrklog << gammalib::parformat("MC events");
wrklog << obs_clone.events()->size() - events_before;
wrklog << " (all models)";
wrklog << std::endl;
}
// Append the event list to the original observation
obs->events(*(obs_clone.events()));
// If requested, event lists are saved immediately
if (m_save_and_dispose) {
// Set event output file name. If multiple observations are
// handled, build the filename from prefix and observation
// index. Otherwise use the outfile parameter.
std::string outfile;
if (m_use_xml) {
m_prefix = (*this)["prefix"].string();
outfile = m_prefix + gammalib::str(i) + ".fits";
}
else {
outfile = (*this)["outevents"].filename();
}
// Store output file name in original observation
obs->eventfile(outfile);
// Save observation into FITS file. This is a critical zone
// to avoid multiple threads writing simultaneously
#pragma omp critical
{
obs_clone.save(outfile, clobber());
}
// Dispose events
obs->dispose_events();
}
// ... otherwise append the event list to the original observation
/*
else {
obs->events(*(obs_clone.events()));
}
*/
} // endif: CTA observation found
} // endfor: looped over observations
// At the end, the content of the thread logger is added to
// the application logger
#pragma omp critical (log)
{
log << wrklog;
}
} // end pragma omp parallel
// Restore energy dispersion flag for all CTA observations
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs != NULL) {
obs->response()->apply_edisp(save_edisp[i]);
}
}
// Return
return;
}
/***********************************************************************//**
* @brief Create output observation container.
*
* Creates an output observation container that combines all input CTA
* observation into a single cube-style observation. All non CTA observations
* present in the observation container are kept. The method furthermore
* conserves any response information in case that a single CTA observation
* is provided. This supports the original binned analysis.
***************************************************************************/
void ctbin::obs_cube(void)
{
// If we have only a single CTA observation in the container, then
// keep that observation and just attach the event cube to it. Reset
// the filename, otherwise we still will have the old event filename
// in the log file.
if (m_obs.size() == 1) {
// Attach event cube to CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[0]);
if (obs != NULL) {
obs->events(this->cube());
obs->eventfile("");
}
}
// ... otherwise put a single CTA observation in container
else {
// Allocate observation container
GObservations container;
// Allocate CTA observation.
GCTAObservation obs;
// Attach event cube to CTA observation
obs.events(this->cube());
// Set map centre as pointing
GSkyPixel pixel(0.5*double(m_cube.nx()), 0.5*double(m_cube.ny()));
GSkyDir centre = m_cube.pix2dir(pixel);
GCTAPointing pointing(centre);
// Compute deadtime correction
double deadc = (m_ontime > 0.0) ? m_livetime / m_ontime : 0.0;
// Set CTA observation attributes
obs.pointing(pointing);
obs.obs_id(0);
obs.ra_obj(centre.ra_deg()); //!< Dummy
obs.dec_obj(centre.dec_deg()); //!< Dummy
obs.ontime(m_ontime);
obs.livetime(m_livetime);
obs.deadc(deadc);
// Set models in observation container
container.models(m_obs.models());
// Append CTA observation
container.append(obs);
// Copy over all remaining non-CTA observations
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs == NULL) {
container.append(*m_obs[i]);
}
}
// Set observation container
m_obs = container;
} // endelse: there was not a single CTA observation
// Return
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;
}
/***********************************************************************//**
* @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 ctobssim::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 observation parameters
m_infile = (*this)["infile"].filename();
m_caldb = (*this)["caldb"].string();
m_irf = (*this)["irf"].string();
m_ra = (*this)["ra"].real();
m_dec = (*this)["dec"].real();
// Set pointing direction
GCTAPointing pnt;
GSkyDir skydir;
skydir.radec_deg(m_ra, m_dec);
pnt.dir(skydir);
// Allocate CTA observation
GCTAObservation obs;
// Set calibration database. If specified parameter is a directory
// then use this as the pathname to the calibration database. Other-
// wise interpret this as the instrument name, the mission being
// "cta"
GCaldb caldb;
if (gammalib::dir_exists(m_caldb)) {
caldb.rootdir(m_caldb);
}
else {
caldb.open("cta", m_caldb);
}
// Set CTA observation attributes
obs.pointing(pnt);
obs.response(m_irf, caldb);
// Set event list (queries remaining parameters)
set_list(&obs);
// Append CTA observation to container
m_obs.append(obs);
// Load models into container
m_obs.models(m_infile);
// Signal that no XML file should be used for storage
m_use_xml = false;
} // endif: there was no observation in the container
// ... otherwise we signal that an XML file should be written
else {
m_use_xml = true;
}
// Get other parameters
m_seed = (*this)["seed"].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();
}
// Initialise random number generators. We initialise here one random
// number generator per observation so that each observation will
// get it's own random number generator. This will lead to identical
// results independently of code parallelization with OpenMP. The
// seeds for all random number generators are derived randomly but
// fully deterministacally from the seed parameter, so that a given
// seed parameter leads always to the same set of simulated events, and
// this independently of parallelization.
// Get a random number generator for seed determination
GRan master(m_seed);
// Allocate vector of random number generator seeds
std::vector<unsigned long long int> seeds;
// Loop over all observations in the container
for (int i = 0; i < m_obs.size(); ++i) {
// Allocate new seed value
unsigned long long int new_seed;
// Determine new seed value. We make sure that the new seed
// value has not been used already for another observation.
bool repeat = false;
do {
new_seed = (unsigned long long int)(master.uniform() * 1.0e10) +
m_seed;
repeat = false;
for (int j = 0; j < seeds.size(); ++j) {
if (new_seed == seeds[j]) {
repeat = true;
break;
}
}
} while(repeat);
// Add the seed to the vector for bookkeeping
seeds.push_back(new_seed);
// Use the seed to create a random number generator for the
// actual observation
m_rans.push_back(GRan(new_seed));
} // endfor: looped over observations
// Return
return;
}
/***********************************************************************//**
* @brief Simulate event data
*
* This method runs the simulation. Results are not saved by this method.
* Invoke "save" to save the results.
***************************************************************************/
void ctobssim::run(void)
{
// Switch screen logging on in debug mode
if (logDebug()) {
log.cout(true);
}
// Get parameters
get_parameters();
// Write input parameters into logger
if (logTerse()) {
log_parameters();
log << std::endl;
}
// Write seed values into logger
if (logTerse()) {
log << std::endl;
log.header1("Seed values");
for (int i = 0; i < m_rans.size(); ++i) {
log << gammalib::parformat("Seed "+gammalib::str(i));
log << gammalib::str(m_rans[i].seed()) << std::endl;
}
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Observations");
}
else {
log.header1("Observation");
}
log << m_obs << std::endl;
}
// Write header
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Simulate observations");
}
else {
log.header1("Simulate observation");
}
}
// Initialise counters
int n_observations = 0;
// From here on the code can be parallelized if OpenMP support
// is enabled. The code in the following block corresponds to the
// code that will be executed in each thread
#pragma omp parallel
{
// Each thread will have it's own logger to avoid conflicts
GLog wrklog;
if (logDebug()) {
wrklog.cout(true);
}
// Copy configuration from application logger to thread logger
wrklog.date(log.date());
wrklog.name(log.name());
// Set a big value to avoid flushing
wrklog.max_size(10000000);
// Loop over all observation in the container. If OpenMP support
// is enabled, this looped will be parallelized.
#pragma omp for
for (int i = 0; i < m_obs.size(); ++i) {
// Get CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
// Continue only if observation is a CTA observation
if (obs != NULL) {
// Write header for observation
if (logTerse()) {
if (obs->name().length() > 1) {
wrklog.header3("Observation "+obs->name());
}
else {
wrklog.header3("Observation");
}
}
// Increment counter
n_observations++;
// Save number of events before entering simulation
int events_before = obs->events()->size();
// Simulate source events
simulate_source(obs, m_obs.models(), m_rans[i], &wrklog);
// Simulate source events
simulate_background(obs, m_obs.models(), m_rans[i], &wrklog);
// Dump simulation results
if (logNormal()) {
wrklog << gammalib::parformat("MC events");
wrklog << obs->events()->size() - events_before;
wrklog << " (all models)";
wrklog << std::endl;
}
} // endif: CTA observation found
} // endfor: looped over observations
// At the end, the content of the thread logger is added to
// the application logger
#pragma omp critical (log)
{
log << wrklog;
}
} // end pragma omp parallel
// If more than a single observation has been handled then make sure that
// an XML file will be used for storage
if (n_observations > 1) {
m_use_xml = true;
}
// Return
return;
}
/***********************************************************************//**
* @brief Get observation container
*
* Get an observation container according to the user parameters. The method
* supports loading of a individual FITS file or an observation definition
* file in XML format.
*
* If the input filename is empty, the method checks for the existence of the
* "expcube", "psfcube" and "bkgcube" parameters. If file names have been
* specified, the method loads the files and creates a dummy events cube that
* is appended to the observation container.
*
* If no file names are specified for the "expcube", "psfcube" or "bkgcube"
* parameters, the method reads the necessary parameters to build a CTA
* observation from scratch.
*
* The method sets m_append_cube = true and m_binned = true in case that
* a stacked observation is requested (as detected by the presence of the
* "expcube", "psfcube", and "bkgcube" parameters). In that case, it appended
* a dummy event cube to the observation.
***************************************************************************/
void ctmodel::get_obs(void)
{
// Get the filename from the input parameters
std::string filename = (*this)["inobs"].filename();
// If no observation definition file has been specified then read all
// parameters that are necessary to create an observation from scratch
if ((filename == "NONE") || (gammalib::strip_whitespace(filename) == "")) {
// Get response cube filenames
std::string expcube = (*this)["expcube"].filename();
std::string psfcube = (*this)["psfcube"].filename();
std::string bkgcube = (*this)["bkgcube"].filename();
// If the filenames are valid then build an observation from cube
// response information
if ((expcube != "NONE") && (psfcube != "NONE") && (bkgcube != "NONE") &&
(gammalib::strip_whitespace(expcube) != "") &&
(gammalib::strip_whitespace(psfcube) != "") &&
(gammalib::strip_whitespace(bkgcube) != "")) {
// Get exposure, PSF and background cubes
GCTACubeExposure exposure(expcube);
GCTACubePsf psf(psfcube);
GCTACubeBackground background(bkgcube);
// Create energy boundaries
GEbounds ebounds = create_ebounds();
// Create dummy sky map cube
GSkyMap map("CAR","GAL",0.0,0.0,1.0,1.0,1,1,ebounds.size());
// Create event cube
GCTAEventCube cube(map, ebounds, exposure.gti());
// Create CTA observation
GCTAObservation cta;
cta.events(cube);
cta.response(exposure, psf, background);
// Append observation to container
m_obs.append(cta);
// Signal that we are in binned mode
m_binned = true;
// Signal that we appended a cube
m_append_cube = true;
} // endif: cube response information was available
// ... otherwise build an observation from IRF response information
else {
// Create CTA observation
GCTAObservation cta = create_cta_obs();
// Set response
set_obs_response(&cta);
// Append observation to container
m_obs.append(cta);
}
} // endif: filename was "NONE" or ""
// ... otherwise we have a file name
else {
// If file is a FITS file then create an empty CTA observation
// and load file into observation
if (gammalib::is_fits(filename)) {
// Allocate empty CTA observation
GCTAObservation cta;
// Load data
cta.load(filename);
// Set response
set_obs_response(&cta);
// Append observation to container
m_obs.append(cta);
// Signal that no XML file should be used for storage
m_use_xml = false;
}
// ... otherwise load file into observation container
else {
// Load observations from XML file
m_obs.load(filename);
// For all observations that have no response, set the response
// from the task parameters
set_response(m_obs);
// Set observation boundary parameters (emin, emax, rad)
set_obs_bounds(m_obs);
// Signal that XML file should be used for storage
m_use_xml = true;
} // endelse: file was an XML file
}
// Return
return;
}
/***********************************************************************//**
* @brief Select event data
*
* This method reads in the application parameters and loops over all
* observations that were found to perform an event selection. Event
* selection is done by writing each observation to a temporary file and
* re-opening the temporary file using the cfitsio event filter syntax.
* The temporary file is deleted after this action so that no disk overflow
* will occur.
***************************************************************************/
void ctselect::run(void)
{
// Switch screen logging on in debug mode
if (logDebug()) {
log.cout(true);
}
// Get parameters
get_parameters();
// Write parameters into logger
if (logTerse()) {
log_parameters();
log << std::endl;
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
log.header1("Observations before selection");
log << m_obs << std::endl;
}
// Write header
if (logTerse()) {
log << std::endl;
log.header1("Event selection");
}
// Initialise counters
int n_observations = 0;
// Loop over all observation in the container
for (int i = 0; i < m_obs.size(); ++i) {
// Initialise event input and output filenames
m_infiles.push_back("");
// Get CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(&m_obs[i]);
// Continue only if observation is a CTA observation
if (obs != NULL) {
// Write header for observation
if (logTerse()) {
if (obs->name().length() > 1) {
log.header3("Observation "+obs->name());
}
else {
log.header3("Observation");
}
}
// Increment counter
n_observations++;
// Save event file name (for possible saving)
m_infiles[i] = obs->eventfile();
// Get temporary file name
std::string filename = std::tmpnam(NULL);
// Save observation in temporary file
obs->save(filename, true);
// Log saved FITS file
if (logExplicit()) {
GFits tmpfile(filename);
log << std::endl;
log.header1("FITS file content of temporary file");
log << tmpfile << std::endl;
tmpfile.close();
}
// Check temporary file
std::string message = check_infile(filename);
if (message.length() > 0) {
throw GException::app_error(G_RUN, message);
}
// Load observation from temporary file, including event selection
select_events(obs, filename);
// Remove temporary file
std::remove(filename.c_str());
} // endif: had a CTA observation
} // endfor: looped over all observations
// If more than a single observation has been handled then make sure that
// an XML file will be used for storage
if (n_observations > 1) {
m_use_xml = true;
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
log.header1("Observations after selection");
log << m_obs << std::endl;
}
// Return
return;
}
/***********************************************************************//**
* @brief Setup observation container
*
* @exception GException::no_cube
* No event cube found in CTA observation.
*
* This method sets up the observation container for processing. There are
* two cases:
*
* If there are no observations in the actual observation container, the
* method will check in "infile" parameter. If this parameter is "NONE" or
* empty, the task parameters will be used to construct a model map.
* Otherwise, the method first tries to interpret the "infile" parameter as
* a counts map, and attemps loading of the file in an event cube. If this
* fails, the method tries to interpret the "infile" parameter as an
* observation definition XML file. If this also fails, an exception will
* be thrown.
*
* If observations exist already in the observation container, the method
* will simply keep them.
*
* Test if all CTA observations contain counts maps.
*
* Finally, if no models exist so far in the observation container, the
* models will be loaded from the model XML file.
***************************************************************************/
void ctmodel::setup_obs(void)
{
// If there are no observations in the container then try to build some
if (m_obs.size() == 0) {
// If no input filename has been specified, then create a model map
// from the task parameters
if ((m_infile == "NONE") || (gammalib::strip_whitespace(m_infile) == "")) {
// Set pointing direction
GCTAPointing pnt;
GSkyDir skydir;
skydir.radec_deg(m_ra, m_dec);
pnt.dir(skydir);
// Setup energy range covered by model
GEnergy emin(m_emin, "TeV");
GEnergy emax(m_emax, "TeV");
GEbounds ebds(m_enumbins, emin, emax);
// Setup time interval covered by model
GGti gti;
GTime tmin(m_tmin);
GTime tmax(m_tmax);
gti.append(tmin, tmax);
// Setup skymap
GSkymap map = GSkymap(m_proj, m_coordsys,
m_xref, m_yref, -m_binsz, m_binsz,
m_nxpix, m_nypix, m_enumbins);
// Create model cube from sky map
GCTAEventCube cube(map, ebds, gti);
// Allocate CTA observation
GCTAObservation obs;
// Set CTA observation attributes
obs.pointing(pnt);
obs.ontime(gti.ontime());
obs.livetime(gti.ontime()*m_deadc);
obs.deadc(m_deadc);
// Set event cube in observation
obs.events(cube);
// Append CTA observation to container
m_obs.append(obs);
// Signal that no XML file should be used for storage
m_use_xml = false;
} // endif: created model map from task parameters
// ... otherwise try to load information from the file
else {
// First try to open the file as a counts map
try {
// Allocate CTA observation
GCTAObservation obs;
// Load counts map in CTA observation
obs.load_binned(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. This will throw
// an exception if it fails.
m_obs.load(m_infile);
// Signal that XML file should be used for storage
m_use_xml = true;
}
} // endelse: loaded information from input file
} // endif: there was no observation in the container
// If there are no models associated with the observations then
// load now the model definition from the XML file
if (m_obs.models().size() == 0) {
m_obs.models(GModels(m_srcmdl));
}
// Check if all CTA observations contain an event cube and setup response
// for all observations
for (int i = 0; i < m_obs.size(); ++i) {
// Is this observation a CTA observation?
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
// Yes ...
if (obs != NULL) {
// Throw an exception if this observation does not contain
// an event cube
if (dynamic_cast<const GCTAEventCube*>(obs->events()) == NULL) {
throw GException::no_cube(G_SETUP_OBS);
}
// Set response if it isn't set already
if (obs->response().aeff() == NULL) {
// Set calibration database. If specified parameter is a
// directory then use this as the pathname to the calibration
// database. Otherwise interpret this as the instrument name,
// the mission being "cta"
GCaldb caldb;
if (gammalib::dir_exists(m_caldb)) {
caldb.rootdir(m_caldb);
}
else {
caldb.open("cta", m_caldb);
}
// Set reponse
obs->response(m_irf, caldb);
} // endif: observation already has a response
} // endif: observation was a CTA observation
} // endfor: looped over all observations
// Return
return;
}
/***********************************************************************//**
* @brief Generate the model map(s)
*
* This method reads the task parameters from the parfile, sets up the
* observation container, loops over all CTA observations in the container
* and generates a model map for each CTA observation.
***************************************************************************/
void ctmodel::run(void)
{
// If we're in debug mode then all output is also dumped on the screen
if (logDebug()) {
log.cout(true);
}
// Get task parameters
get_parameters();
// Setup observation container
setup_obs();
// Write parameters into logger
if (logTerse()) {
log_parameters();
log << std::endl;
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Observations");
}
else {
log.header1("Observation");
}
log << m_obs << std::endl;
}
// Write header
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Generate model maps");
}
else {
log.header1("Generate model map");
}
}
// Initialise observation counter
int n_observations = 0;
// Loop over all observations in the container
for (int i = 0; i < m_obs.size(); ++i) {
// Initialise event input and output filenames
m_infiles.push_back("");
// Get CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
// Continue only if observation is a CTA observation
if (obs != NULL) {
// Write header for observation
if (logTerse()) {
if (obs->name().length() > 1) {
log.header3("Observation "+obs->name());
}
else {
log.header3("Observation");
}
}
// Increment number of observations
n_observations++;
// Save event file name (for possible saving)
m_infiles[i] = obs->eventfile();
// Generate model map
model_map(obs, m_obs.models());
} // endif: CTA observation found
} // endfor: looped over observations
// If more than a single observation has been handled then make sure
// that an XML file will be used for storage
if (n_observations > 1) {
m_use_xml = true;
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Observations after model map generation");
}
else {
log.header1("Observation after model map generation");
}
log << m_obs << std::endl;
}
// Return
return;
}
/***********************************************************************//**
* @brief Generate the model map(s)
*
* This method reads the task parameters from the parfile, sets up the
* observation container, loops over all CTA observations in the container
* and generates a model map for each CTA observation.
***************************************************************************/
void ctmodel::run(void)
{
// If we're in debug mode then all output is also dumped on the screen
if (logDebug()) {
log.cout(true);
}
// Get task parameters
get_parameters();
// Write parameters into logger
if (logTerse()) {
log_parameters();
log << std::endl;
}
// Set energy dispersion flag for all CTA observations and save old
// values in save_edisp vector
std::vector<bool> save_edisp;
save_edisp.assign(m_obs.size(), false);
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs != NULL) {
save_edisp[i] = obs->response()->apply_edisp();
obs->response()->apply_edisp(m_apply_edisp);
}
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Observations");
}
else {
log.header1("Observation");
}
log << m_obs << std::endl;
}
// Write models into logger
if (logTerse()) {
log << std::endl;
log.header1("Models");
log << m_obs.models() << std::endl;
}
// Write header
if (logTerse()) {
log << std::endl;
log.header1("Generate model cube");
}
// Loop over all observations in the container
for (int i = 0; i < m_obs.size(); ++i) {
// Write header for observation
if (logTerse()) {
std::string header = m_obs[i]->instrument() + " observation";
if (m_obs[i]->name().length() > 1) {
header += " \"" + m_obs[i]->name() + "\"";
}
if (m_obs[i]->id().length() > 1) {
header += " (id=" + m_obs[i]->id() +")";
}
log.header3(header);
}
// Get CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
// Skip observation if it's not CTA
if (obs == NULL) {
if (logTerse()) {
log << " Skipping ";
log << m_obs[i]->instrument();
log << " observation" << std::endl;
}
continue;
}
// Fill cube and leave loop if we are binned mode (meaning we
// only have one binned observation)
if (m_binned) {
fill_cube(obs);
break;
}
// Skip observation if we have a binned observation
if (obs->eventtype() == "CountsCube") {
if (logTerse()) {
log << " Skipping binned ";
log << obs->instrument();
log << " observation" << std::endl;
}
continue;
}
// Fill the cube
fill_cube(obs);
// Dispose events to free memory if event file exists on disk
if (obs->eventfile().length() > 0 &&
gammalib::file_exists(obs->eventfile())) {
obs->dispose_events();
}
} // endfor: looped over observations
// Log cube
if (logTerse()) {
log << std::endl;
log.header1("Model cube");
log << m_cube << std::endl;
}
// Restore energy dispersion flag for all CTA observations
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs != NULL) {
obs->response()->apply_edisp(save_edisp[i]);
}
}
// Return
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 Get application parameters
*
* Get all task parameters from parameter file or (if required) by querying
* the user. The parameters are read in the correct order.
***************************************************************************/
void ctmodel::get_parameters(void)
{
// Reset cube append flag
m_append_cube = false;
// If there are no observations in container then load them via user
// parameters.
if (m_obs.size() == 0) {
get_obs();
}
// If we have now excactly one CTA observation (but no cube has yet been
// appended to the observation) then check whether this observation
// is a binned observation, and if yes, extract the counts cube for
// model generation
if ((m_obs.size() == 1) && (m_append_cube == false)) {
// Get CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[0]);
// Continue only if observation is a CTA observation
if (obs != NULL) {
// Check for binned observation
if (obs->eventtype() == "CountsCube") {
// Set cube from binned observation
GCTAEventCube* evtcube = dynamic_cast<GCTAEventCube*>(const_cast<GEvents*>(obs->events()));
cube(*evtcube);
// Signal that cube has been set
m_has_cube = true;
// Signal that we are in binned mode
m_binned = true;
} // endif: observation was binned
} // endif: observation was CTA
} // endif: had exactly one observation
// Read model definition file if required
if (m_obs.models().size() == 0) {
// Get model filename
std::string inmodel = (*this)["inmodel"].filename();
// Load models from file
m_obs.models(inmodel);
} // endif: there were no models
// Get energy dispersion flag parameters
m_apply_edisp = (*this)["edisp"].boolean();
// If we do not have yet a counts cube for model computation then check
// whether we should read it from the "incube" parameter or whether we
// should create it from scratch using the task parameters
if (!m_has_cube) {
// Read cube definition file
std::string incube = (*this)["incube"].filename();
// If no cube file has been specified then create a cube from
// the task parameters ...
if ((incube == "NONE") ||
(gammalib::strip_whitespace(incube) == "")) {
// Create cube from scratch
m_cube = create_cube(m_obs);
}
// ... otherwise load the cube from file and reset all bins
// to zero
else {
// Load cube from given file
m_cube.load(incube);
// Set all cube bins to zero
for (int i = 0; i < m_cube.size(); ++i) {
m_cube[i]->counts(0.0);
}
}
// Signal that cube has been set
m_has_cube = true;
} // endif: we had no cube yet
// Read optionally output cube filenames
if (read_ahead()) {
m_outcube = (*this)["outcube"].filename();
}
// If cube should be appended to first observation then do that now.
// This is a kluge that makes sure that the cube is passed as part
// of the observation in case that a cube response is used. The kluge
// is needed because the GCTACubeSourceDiffuse::set method needs to
// get the full event cube from the observation. It is also at this
// step that the GTI, which may just be a dummy GTI when create_cube()
// has been used, will be set.
if (m_append_cube) {
//TODO: Check that energy boundaries are compatible
// Attach GTI of observations to model cube
m_cube.gti(m_obs[0]->events()->gti());
// Attach model cube to observations
m_obs[0]->events(m_cube);
} // endif: cube was scheduled for appending
// Return
return;
}
/***********************************************************************//**
* @brief Run maximum likelihood analysis
*
* The following analysis steps are performed:
* 1. Read the parameters (and write them into logger)
* 2. Load observation
* 3. Setup models for optimizing
* 4. Optimize model (and write result into logger)
***************************************************************************/
void ctlike::run(void)
{
// Switch screen logging on in debug mode
if (logDebug()) {
log.cout(true);
}
// Get parameters
get_parameters();
// Write parameters into logger
if (logTerse()) {
log_parameters();
log << std::endl;
}
// Set energy dispersion flag for all CTA observations and save old
// values in save_edisp vector
std::vector<bool> save_edisp;
save_edisp.assign(m_obs.size(), false);
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs != NULL) {
save_edisp[i] = obs->response()->apply_edisp();
obs->response()->apply_edisp(m_apply_edisp);
}
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Observations");
}
else {
log.header1("Observation");
}
log << m_obs << std::endl;
}
// Optimize model parameters using LM optimizer
optimize_lm();
// Store Npred
double npred = m_obs.npred();
// Store models for which TS should be computed
std::vector<std::string> ts_srcs;
GModels models_orig = m_obs.models();
for (int i = 0; i < models_orig.size(); ++i) {
GModel* model = models_orig[i];
if (model->tscalc()) {
ts_srcs.push_back(model->name());
}
}
// Compute TS values if requested
if (!ts_srcs.empty()) {
// Store original maximum likelihood and models
double logL_src = m_logL;
GModels models = m_obs.models();
// Fix spatial parameters if requested
if (m_fix_spat_for_ts) {
// Loop over all models
for (int i = 0; i < models.size(); ++i) {
// Continue only if model is skymodel
GModelSky* sky= dynamic_cast<GModelSky*>(models[i]);
if (sky != NULL) {
// Fix spatial parameters
GModelSpatial* spatial = sky->spatial();
for (int j = 0; j < spatial->size(); j++) {
(*spatial)[j].fix();
} // endfor: looped over spatial parameters
} // endif: there was a sky model
} // endfor: looped over models
} // endif: spatial parameter should be fixed
// Loop over stored models, remove source and refit
for (int i = 0; i < ts_srcs.size(); ++i) {
models.remove(ts_srcs[i]);
m_obs.models(models);
double logL_nosrc = reoptimize_lm();
double ts = 2.0 * (logL_src-logL_nosrc);
models_orig[ts_srcs[i]]->ts(ts);
models = models_orig;
}
// Restore best fit values
m_obs.models(models_orig);
}
// Compute number of observed events in all observations
double num_events = 0.0;
for (int i = 0; i < m_obs.size(); ++i) {
double data = m_obs[i]->events()->number();
if (data >= 0.0) {
num_events += data;
}
}
// Write results into logger
if (logTerse()) {
log << std::endl;
log.header1("Maximum likelihood optimisation results");
log << *m_opt << std::endl;
log << gammalib::parformat("Maximum log likelihood");
log << gammalib::str(m_logL,3) << std::endl;
log << gammalib::parformat("Observed events (Nobs)");
log << gammalib::str(num_events, 3) << std::endl;
log << gammalib::parformat("Predicted events (Npred)");
log << gammalib::str(npred, 3);
log << " (Nobs - Npred = ";
log << gammalib::str(num_events-npred);
log << ")" << std::endl;
log << m_obs.models() << std::endl;
}
// Restore energy dispersion flag for all CTA observations
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs != NULL) {
obs->response()->apply_edisp(save_edisp[i]);
}
}
// Return
return;
}
/***********************************************************************//**
* @brief Bin the event data
*
* This method loops over all observations found in the observation conatiner
* and bins all events from the event list(s) into counts map(s). Note that
* each event list is binned in a separate counts map, hence no summing of
* events is done.
***************************************************************************/
void ctbin::run(void)
{
// If we're in debug mode then all output is also dumped on the screen
if (logDebug()) {
log.cout(true);
}
// Get task parameters
get_parameters();
// Write parameters into logger
if (logTerse()) {
log_parameters();
log << std::endl;
}
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Observations");
}
else {
log.header1("Observation");
}
log << m_obs << std::endl;
}
// Write header
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Bin observations");
}
else {
log.header1("Bin observation");
}
}
// Loop over all observations in the container
for (int i = 0; i < m_obs.size(); ++i) {
// Get CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
// Continue only if observation is a CTA observation
if (obs != NULL) {
// Write header for observation
if (logTerse()) {
if (obs->name().length() > 1) {
log.header3("Observation "+obs->name());
}
else {
log.header3("Observation");
}
}
// Fill the cube
fill_cube(obs);
// Dispose events to free memory
obs->dispose_events();
} // endif: CTA observation found
} // endfor: looped over observations
// Set a single cube in the observation container
obs_cube();
// Write observation(s) into logger
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Binned observations");
}
else {
log.header1("Binned observation");
}
log << m_obs << std::endl;
}
// Return
return;
}
