/***********************************************************************//**
* @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 ctexpcube::get_parameters(void)
{
// Setup observations from "inobs" parameter. Do not accept counts cubes.
setup_observations(m_obs, true, true, false);
// Get the incube filename
std::string incube = (*this)["incube"].filename();
// If the "incube" file name is valid then setup the exposure cube from
// the counts cube. Otherwise create a counts cube from the user
// parameters
GCTAEventCube cube = is_valid_filename(incube) ? GCTAEventCube(incube)
: create_cube(m_obs);
// Define exposure cube
m_expcube = GCTACubeExposure(cube);
// Get remaining parameters
m_addbounds = (*this)["addbounds"].boolean();
m_publish = (*this)["publish"].boolean();
m_chatter = static_cast<GChatter>((*this)["chatter"].integer());
// Read output filename (if needed)
if (read_ahead()) {
m_outcube = (*this)["outcube"].filename();
}
// Write parameters into logger
log_parameters(TERSE);
// 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 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 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 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 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;
}
bool Data_logging::update(void)
{
uint32_t time_ms = 0;
if (log_data_ == 1)
{
if (file_opened_)
{
if (!file_init_)
{
add_header_name();
}
if (!state_.is_armed())
{
time_ms = time_keeper_get_ms();
if ((time_ms - logging_time_) > 5000)
{
console_.get_stream()->flush();
logging_time_ = time_ms;
}
}
if (continuous_write_)
{
log_parameters();
}
else
{
if (checksum_control())
{
log_parameters();
}
}
} //end of if (file_opened_)
else
{
if (sys_status_)
{
open_new_log_file();
}
cksum_a_ = 0.0;
cksum_b_ = 0.0;
}//end of else if (file_opened_)
} //end of if (log_data_ == 1)
else
{
sys_status_ = true;
if (file_opened_)
{
bool succeed = console_.get_stream()->close();
cksum_a_ = 0.0;
cksum_b_ = 0.0;
file_opened_ = false;
file_init_ = false;
if (debug_)
{
if (succeed)
{
print_util_dbg_print("File closed\r\n");
}
else
{
print_util_dbg_print("Error closing file\r\n");
}
}
} //end of if (file_opened_)
} //end of else (log_data_ != 1)
return true;
}
/***********************************************************************//**
* @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;
}
/***********************************************************************//**
* @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 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;
}
