/***********************************************************************//**
* @brief Test GTimes
***************************************************************************/
void TestGObservation::test_times(void)
{
// Test void constructor
test_try("Void constructor");
try {
GTimes times;
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Manipulate GTimes starting from an empty object
GTimes times;
test_value(times.size(), 0, "GTimes should have zero size.");
test_assert(times.is_empty(), "GTimes should be empty.");
// Add a time
times.append(GTime());
test_value(times.size(), 1, "GTimes should have 1 time.");
test_assert(!times.is_empty(), "GTimes should not be empty.");
// Remove time
times.remove(0);
test_value(times.size(), 0, "GTimes should have zero size.");
test_assert(times.is_empty(), "GTimes should be empty.");
// Append two times
times.append(GTime());
times.append(GTime());
test_value(times.size(), 2, "GTimes should have 2 times.");
test_assert(!times.is_empty(), "GTimes should not be empty.");
// Clear object
times.clear();
test_value(times.size(), 0, "GTimes should have zero size.");
test_assert(times.is_empty(), "GTimes should be empty.");
// Insert two times
times.insert(0, GTime());
times.insert(0, GTime());
test_value(times.size(), 2, "GTimes should have 2 times.");
test_assert(!times.is_empty(), "GTimes should not be empty.");
// Extend times
times.extend(times);
test_value(times.size(), 4, "GTimes should have 4 times.");
test_assert(!times.is_empty(), "GTimes should not be empty.");
// Return
return;
}
/***********************************************************************//**
* @brief Returns vector of random event times
*
* @param[in] rate Mean event rate (events per second).
* @param[in] tmin Minimum event time.
* @param[in] tmax Maximum event time.
* @param[in,out] ran Random number generator.
*
* This method returns a vector of random event times assuming a constant
* event rate that is specified by the rate parameter.
***************************************************************************/
GTimes GModelTemporalConst::mc(const double& rate, const GTime& tmin,
const GTime& tmax, GRan& ran) const
{
// Allocates empty vector of times
GTimes times;
// Compute event rate (in events per seconds)
double lambda = rate * norm();
// Initialise start and stop times in seconds
double time = tmin.secs();
double tstop = tmax.secs();
// Generate events until maximum event time is exceeded
while (time <= tstop) {
// Simulate next event time
time += ran.exp(lambda);
// Add time if it is not beyod the stop time
if (time <= tstop) {
GTime event;
event.secs(time);
times.append(event);
}
} // endwhile: loop until stop time is reached
// Return vector of times
return times;
}
/***********************************************************************//**
* @brief Returns vector of random event times
*
* @param[in] rate Mean event rate (events per second).
* @param[in] tmin Minimum event time.
* @param[in] tmax Maximum event time.
* @param[in,out] ran Random number generator.
*
* This method returns a vector of random event times between @p tmin and
* @p tmax assuming a light curve specified in a FITS file.
***************************************************************************/
GTimes GModelTemporalLightCurve::mc(const double& rate, const GTime& tmin,
const GTime& tmax, GRan& ran) const
{
// Allocates empty vector of times
GTimes times;
// Update Monte Carlo cache
mc_update(tmin, tmax);
// Continue only if effective duration is positive and cache is not empty
if (m_mc_eff_duration > 0.0 && m_mc_cum.size() > 0) {
// Compute mean number of times by multiplying the rate with the
// effective duration. Note that the light curve normalization factor
// is already included in the effective rate, hence we should not
// multiply it here again (see #2181).
double lambda = rate * m_mc_eff_duration;
// Compute number of times to be sampled
int ntimes = int(ran.poisson(lambda)+0.5);
// Loop over number of times
for (int i = 0; i < ntimes; ++i) {
// Determine in which bin we reside
int inx = 0;
if (m_mc_cum.size() > 1) {
double u = ran.uniform();
for (inx = m_mc_cum.size()-1; inx > 0; --inx) {
if (m_mc_cum[inx-1] <= u) {
break;
}
}
}
// Get random time
double seconds;
if (m_mc_slope[inx] == 0.0) {
seconds = m_mc_dt[inx] * ran.uniform() + m_mc_time[inx];
}
else {
seconds = (std::sqrt(m_mc_offset[inx]*m_mc_offset[inx] +
2.0 * m_mc_slope[inx] * ran.uniform()) -
m_mc_offset[inx]) / m_mc_slope[inx] + m_mc_time[inx];
}
// Append random time
GTime time(seconds, m_timeref);
times.append(time);
} // endfor: looped over times
} // endif: cache was valid
// Return vector of times
return times;
}
