/***********************************************************************//**
* @brief Get application parameters
*
* Get all required task parameters from the parameter file or (if specified)
* by querying the user. Observation dependent parameters will only be read
* if the observation container is actually empty. Observation dependent
* parameters are:
* "stat" (statistics to be used for observation),
* "caldb" (calibration database),
* "irf" (instrument response function), and
* "infile" (input file name).
* The model will only be loaded if no model components exist in the
* observation container.
*
* This method handles both loading of FITS files and of handling XML
* observation definition files.
***************************************************************************/
void ctlike::get_parameters(void)
{
// If there are no observations in container then load them via user
// parameters
if (m_obs.size() == 0) {
// Throw exception if no input observation file is given
require_inobs(G_GET_PARAMETERS);
// Get observation container
m_obs = get_observations();
} // endif: there was no observation in the container
// If only single observation is used, read statistics parameter
if (!m_use_xml) {
// Get other task parameters
std::string statistics = gammalib::toupper((*this)["stat"].string());
// Set statistics
(*m_obs[0]).statistics(statistics);
}
// If there is are no models associated with the observations then
// load now the model definition
if (m_obs.models().size() == 0) {
// Get models XML filename
std::string filename = (*this)["inmodel"].filename();
// Setup models for optimizing.
m_obs.models(GModels(filename));
} // endif: no models were associated with observations
// Get other parameters
m_refit = (*this)["refit"].boolean();
m_apply_edisp = (*this)["edisp"].boolean();
m_fix_spat_for_ts = (*this)["fix_spat_for_ts"].boolean();
// Optionally read ahead parameters so that they get correctly
// dumped into the log file
if (read_ahead()) {
m_outmodel = (*this)["outmodel"].filename();
}
// Set optimizer logger
if (logTerse()) {
static_cast<GOptimizerLM*>(m_opt)->logger(&log);
}
else {
static_cast<GOptimizerLM*>(m_opt)->logger(NULL);
}
// Return
return;
}
/***********************************************************************//**
* @brief Get application parameters
*
* @exception GException::invalid_value
* Test source not found.
*
* Get all task parameters from parameter file or (if required) by querying
* the user.
***************************************************************************/
void cterror::get_parameters(void)
{
// If there are no observations in container then load them via user
// parameters
if (m_obs.size() == 0) {
// Throw exception if no input observation file is given
require_inobs(G_GET_PARAMETERS);
// Build observation container
m_obs = get_observations();
} // endif: there was no observation in the container
// If there are no models associated with the observations then
// load now the model definition
if (m_obs.models().size() == 0) {
// Get models XML filename
std::string filename = (*this)["inmodel"].filename();
// Setup models for optimizing.
m_obs.models(GModels(filename));
} // endif: no models were associated with observations
// Get name of test source and check container for this name
m_srcname = (*this)["srcname"].string();
if (!m_obs.models().contains(m_srcname)) {
std::string msg = "Source \""+m_srcname+"\" not found in model "
"container. Please add a source with that name "
"or check for possible typos.";
throw GException::invalid_value(G_GET_PARAMETERS, msg);
}
// Read energy dispersion flag
m_apply_edisp = (*this)["edisp"].boolean();
// Get confidence level and transform into log-likelihood difference
m_confidence = (*this)["confidence"].real();
double sigma = gammalib::erfinv(m_confidence) * gammalib::sqrt_two;
m_dlogL = (sigma*sigma) / 2.0;
// Read other parameters
m_tol = (*this)["tol"].real();
m_max_iter = (*this)["max_iter"].integer();
// 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;
}
