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