/***********************************************************************//**
* @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 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 without response (not needed)
m_obs = get_observations(false);
} // endif: there was no observation in the container
// Create an event cube based on task parameters
GCTAEventCube cube = create_cube(m_obs);
// Get the skymap from the cube and initialise all pixels to zero
m_cube = cube.map();
m_cube = 0.0;
// Get energy boundaries
m_ebounds = cube.ebounds();
// Optionally read ahead parameters so that they get correctly
// dumped into the log file
if (read_ahead()) {
m_outcube = (*this)["outcube"].filename();
}
// Return
return;
}
/***********************************************************************//**
* @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;
}
/**
get reference data to a specific particle
@param ref_particle: pointer to reference particles
@param ref_histogram: pointer to reference histogram
*/
void get_reference_data(particle * ref_particle, histogram * ref_histogram) {
// first frames are often not too good. So skip them
// only needed, if webcam is used
// read_frame(); read_frame(); read_frame(); read_frame();
// get reference histogram
get_observations (ref_particle, 1, ref_histogram);
}
/***********************************************************************//**
* @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 ctpsfcube::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
// Get the incube filename
std::string incube = (*this)["incube"].filename();
// Get additional binning parameters
double amax = (*this)["amax"].real();
int anumbins = (*this)["anumbins"].integer();
// Check for filename validity
if ((incube == "NONE") || (gammalib::strip_whitespace(incube) == "")) {
// Create an event cube based on task parameters
GCTAEventCube cube = create_cube(m_obs);
// Define psf cube
m_psfcube = GCTACubePsf(cube, amax, anumbins);
}
// ... otherwise setup the exposure cube from the counts map
else {
// Load event cube from filename
GCTAEventCube cube(incube);
// Define psf cube
m_psfcube = GCTACubePsf(cube, amax, anumbins);
} // endelse: cube loaded from file
// Read energy dispersion flag
m_apply_edisp = (*this)["edisp"].boolean();
// Read output filename (if needed)
if (read_ahead()) {
m_outcube = (*this)["outcube"].filename();
}
// 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 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)
{
// Initialise seed vector
m_rans.clear();
// If there are no observations in container then load them via user
// parameters
if (m_obs.size() == 0) {
m_obs = get_observations();
}
// ... otherwise make sure that observation boundaries are set
else {
set_obs_bounds(m_obs);
}
// Read model definition file if required
if (m_obs.models().size() == 0) {
std::string inmodel = (*this)["inmodel"].filename();
m_obs.models(inmodel);
}
// Get other parameters
m_seed = (*this)["seed"].integer();
m_apply_edisp = (*this)["edisp"].boolean();
m_max_rate = (*this)["maxrate"].real();
// Optionally read ahead parameters so that they get correctly
// dumped into the log file
if (read_ahead()) {
m_outevents = (*this)["outevents"].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;
}
