/***********************************************************************//**
* @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;
}
/***********************************************************************//**
* @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;
}
