/***********************************************************************//**
* @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;
}
// Generate an EventCube, rate is the number of event per second. Events have a time between tmin and tmax.
virtual GTestEventCube* generateCube(const double &rate, const GTime &tmin, const GTime &tmax, GRan &ran)
{
// Create an event list
GTestEventCube* cube = new GTestEventCube();
// Set min and max energy for ebounds
// npred method integrate the model on time and energy.
// In order to have a rate which not depend on energy we create an interval of 1 Mev.
GEnergy engmin,engmax;
engmin.MeV(1.0);
engmax.MeV(2.0);
// Instrument Direction
GTestInstDir dir;
// Generate an times list.
GTimes times = m_modelTps->mc(rate, tmin, tmax, ran);
GTestEventBin bin;
bin.time(times[0]);
bin.energy(engmin);
bin.ewidth(engmax-engmin);
bin.dir(dir);
bin.ontime(10); // 10 sec per bin
for (int i = 0; i < times.size(); ++i) {
if ((bin.time().secs() + bin.ontime()) < times[i].secs()) {
// Add the event to the cube
cube->append(bin);
bin.counts(0.0);
bin.time(times[i]);
bin.energy(engmin);
bin.ewidth(engmax-engmin);
bin.dir(dir);
bin.ontime(10); // 10 sec per bin
}
bin.counts(bin.counts()+1);
}
// Create a time interval and add it to the list.
GGti gti;
gti.append(tmin,tmax);
cube->gti(gti);
// Create an energy interval and add it to the list
GEbounds ebounds;
ebounds.append(engmin,engmax);
cube->ebounds(ebounds);
return cube;
};
/***********************************************************************//**
* @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;
}
// Generate an EventList, rate is the number of event per second. Events have a time between tmin and tmax.
virtual GTestEventList* generateList(const double &rate, const GTime &tmin, const GTime &tmax, GRan &ran)
{
// Create an event list
GTestEventList * list = new GTestEventList();
// Set min and max energy for ebounds
// npred method integrate the model on time and energy.
// In order to have a rate which not depend on energy we create an interval of 1 Mev.
GEnergy engmin,engmax;
engmin.MeV(1.0);
engmax.MeV(2.0);
// Instrument Direction
GTestInstDir dir;
// Generate an times list.
GTimes times = m_modelTps->mc(rate,tmin, tmax,ran);
for (int i = 0; i < times.size() ; ++i) {
GTestEventAtom event;
event.dir(dir);
event.energy(engmin);
event.time(times[i]);
// Add the event to the list
list->append(event);
}
// Create a time interval and add it to the list.
GGti gti;
gti.append(tmin,tmax);
list->gti(gti);
// Create an energy interval and add it to the list
GEbounds ebounds;
ebounds.append(engmin,engmax);
list->ebounds(ebounds);
return list;
}
/***********************************************************************//**
* @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 Return simulated list of events
*
* @param[in] obs Observation.
* @param[in] ran Random number generator.
* @return Pointer to list of simulated events (needs to be de-allocated by
* client)
*
* @exception GException::invalid_argument
* No CTA event list found in observation.
*
* Draws a sample of events from the background model using a Monte
* Carlo simulation. The pointing information, the energy boundaries and the
* good time interval for the sampling will be extracted from the observation
* argument that is passed to the method. The method also requires a random
* number generator of type GRan which is passed by reference, hence the
* state of the random number generator will be changed by the method.
*
* The method also applies a deadtime correction using a Monte Carlo process,
* taking into account temporal deadtime variations. For this purpose, the
* method makes use of the time dependent GObservation::deadc method.
***************************************************************************/
GCTAEventList* GCTAModelBackground::mc(const GObservation& obs, GRan& ran) const
{
// Initialise new event list
GCTAEventList* list = new GCTAEventList;
// Continue only if model is valid)
if (valid_model()) {
// Extract event list to access the ROI, energy boundaries and GTIs
const GCTAEventList* events = dynamic_cast<const GCTAEventList*>(obs.events());
if (events == NULL) {
std::string msg = "No CTA event list found in observation.\n" +
obs.print();
throw GException::invalid_argument(G_MC, msg);
}
// Get simulation region
const GCTARoi& roi = events->roi();
const GEbounds& ebounds = events->ebounds();
const GGti& gti = events->gti();
// Set simulation region for result event list
list->roi(roi);
list->ebounds(ebounds);
list->gti(gti);
// Loop over all energy boundaries
for (int ieng = 0; ieng < ebounds.size(); ++ieng) {
// Initialise de-allocation flag
bool free_spectral = false;
// Set pointer to spectral model
GModelSpectral* spectral = m_spectral;
// If the spectral model is a diffuse cube then create a node
// function spectral model that is the product of the diffuse
// cube node function and the spectral model evaluated at the
// energies of the node function
GModelSpatialDiffuseCube* cube =
dynamic_cast<GModelSpatialDiffuseCube*>(m_spatial);
if (cube != NULL) {
// Set MC simulation cone based on ROI
cube->set_mc_cone(roi.centre().dir(), roi.radius());
// Allocate node function to replace the spectral component
GModelSpectralNodes* nodes = new GModelSpectralNodes(cube->spectrum());
for (int i = 0; i < nodes->nodes(); ++i) {
GEnergy energy = nodes->energy(i);
double intensity = nodes->intensity(i);
double norm = m_spectral->eval(energy, events->tstart());
nodes->intensity(i, norm*intensity);
}
// Signal that node function needs to be de-allocated later
free_spectral = true;
// Set the spectral model pointer to the node function
spectral = nodes;
} // endif: spatial model was a diffuse cube
// Compute the background rate in model within the energy boundaries
// from spectral component (units: cts/s).
// Note that the time here is ontime. Deadtime correction will be done
// later.
double rate = spectral->flux(ebounds.emin(ieng), ebounds.emax(ieng));
// Debug option: dump rate
#if defined(G_DUMP_MC)
std::cout << "GCTAModelBackground::mc(\"" << name() << "\": ";
std::cout << "rate=" << rate << " cts/s)" << std::endl;
#endif
// Loop over all good time intervals
for (int itime = 0; itime < gti.size(); ++itime) {
// Get Monte Carlo event arrival times from temporal model
GTimes times = m_temporal->mc(rate,
gti.tstart(itime),
gti.tstop(itime),
ran);
// Get number of events
int n_events = times.size();
// Reserve space for events
if (n_events > 0) {
list->reserve(n_events);
}
// Loop over events
for (int i = 0; i < n_events; ++i) {
// Apply deadtime correction
double deadc = obs.deadc(times[i]);
if (deadc < 1.0) {
if (ran.uniform() > deadc) {
continue;
}
}
// Get Monte Carlo event energy from spectral model
GEnergy energy = spectral->mc(ebounds.emin(ieng),
ebounds.emax(ieng),
times[i],
ran);
// Get Monte Carlo event direction from spatial model
GSkyDir dir = spatial()->mc(energy, times[i], ran);
// Allocate event
GCTAEventAtom event;
// Set event attributes
event.dir(GCTAInstDir(dir));
event.energy(energy);
event.time(times[i]);
// Append event to list if it falls in ROI
if (events->roi().contains(event)) {
list->append(event);
}
} // endfor: looped over all events
} // endfor: looped over all GTIs
// Free spectral model if required
if (free_spectral) delete spectral;
} // endfor: looped over all energy boundaries
} // endif: model was valid
// Return
return list;
}
/***********************************************************************//**
* @brief Return simulated list of photons
*
* @param[in] area Simulation surface area (cm2).
* @param[in] dir Centre of simulation cone.
* @param[in] radius Radius of simulation cone (deg).
* @param[in] emin Minimum photon energy.
* @param[in] emax Maximum photon energy.
* @param[in] tmin Minimum photon arrival time.
* @param[in] tmax Maximum photon arrival time.
* @param[in] ran Random number generator.
*
* This method returns a list of photons that has been derived by Monte Carlo
* simulation from the model. A simulation region is define by specification
* of a simulation cone (a circular region on the sky),
* of an energy range [emin, emax], and
* of a time interval [tmin, tmax].
* The simulation cone may eventually cover the entire sky (by setting
* the radius to 180 degrees), yet simulations will be more efficient if
* only the sky region will be simulated that is actually observed by the
* telescope.
*
* @todo Check usage for diffuse models
* @todo Implement photon arrival direction simulation for diffuse models
* @todo Implement unique model ID to assign as Monte Carlo ID
***************************************************************************/
GPhotons GModelSky::mc(const double& area,
const GSkyDir& dir, const double& radius,
const GEnergy& emin, const GEnergy& emax,
const GTime& tmin, const GTime& tmax,
GRan& ran) const
{
// Allocate photons
GPhotons photons;
// Continue only if model is valid)
if (valid_model()) {
// Get point source pointer
GModelSpatialPtsrc* ptsrc = dynamic_cast<GModelSpatialPtsrc*>(m_spatial);
// Check if model will produce any photons in the specified
// simulation region. If the model is a point source we check if the
// source is located within the simulation code. If the model is a
// diffuse source we check if the source overlaps with the simulation
// code
bool use_model = true;
if (ptsrc != NULL) {
if (dir.dist(ptsrc->dir()) > radius) {
use_model = false;
}
}
else {
//TODO
}
// Continue only if model overlaps with simulation region
if (use_model) {
// Compute flux within [emin, emax] in model from spectral
// component (units: ph/cm2/s)
double flux = m_spectral->flux(emin, emax);
// Derive expecting counting rate within simulation surface
// (units: ph/s)
double rate = flux * area;
// Debug option: dump rate
#if G_DUMP_MC
std::cout << "GModelSky::mc(\"" << name() << "\": ";
std::cout << "flux=" << flux << " ph/cm2/s, ";
std::cout << "rate=" << rate << " ph/s)" << std::endl;
#endif
// Get photon arrival times from temporal model
GTimes times = m_temporal->mc(rate, tmin, tmax, ran);
// Reserve space for photons
if (times.size() > 0) {
photons.reserve(times.size());
}
// Loop over photons
for (int i = 0; i < times.size(); ++i) {
// Allocate photon
GPhoton photon;
// Set photon arrival time
photon.time(times[i]);
// Set incident photon direction
photon.dir(m_spatial->mc(ran));
// Set photon energy
photon.energy(m_spectral->mc(emin, emax, ran));
// Append photon
photons.append(photon);
} // endfor: looped over photons
} // endif: model was used
} // endif: model was valid
// Return photon list
return photons;
}
/***********************************************************************//**
* @brief Return simulated list of events
*
* @param[in] obs Observation.
* @param[in] ran Random number generator.
* @return Pointer to list of simulated events (needs to be de-allocated by
* client)
*
* @exception GException::invalid_argument
* Specified observation is not a CTA observation.
*
* Draws a sample of events from the background model using a Monte
* Carlo simulation. The region of interest, the energy boundaries and the
* good time interval for the sampling will be extracted from the observation
* argument that is passed to the method. The method also requires a random
* number generator of type GRan which is passed by reference, hence the
* state of the random number generator will be changed by the method.
*
* The method also applies a deadtime correction using a Monte Carlo process,
* taking into account temporal deadtime variations. For this purpose, the
* method makes use of the time dependent GObservation::deadc method.
*
* For each event in the returned event list, the sky direction, the nominal
* coordinates (DETX and DETY), the energy and the time will be set.
***************************************************************************/
GCTAEventList* GCTAModelAeffBackground::mc(const GObservation& obs,
GRan& ran) const
{
// Initialise new event list
GCTAEventList* list = new GCTAEventList;
// Continue only if model is valid)
if (valid_model()) {
// Retrieve CTA observation
const GCTAObservation* cta = dynamic_cast<const GCTAObservation*>(&obs);
if (cta == NULL) {
std::string msg = "Specified observation is not a CTA "
"observation.\n" + obs.print();
throw GException::invalid_argument(G_MC, msg);
}
// Get pointer on CTA IRF response
const GCTAResponseIrf* rsp =
dynamic_cast<const GCTAResponseIrf*>(cta->response());
if (rsp == NULL) {
std::string msg = "Specified observation does not contain"
" an IRF response.\n" + obs.print();
throw GException::invalid_argument(G_MC, msg);
}
// Retrieve CTA response and pointing
const GCTAPointing& pnt = cta->pointing();
// Get pointer to CTA effective area
const GCTAAeff* aeff = rsp->aeff();
if (aeff == NULL) {
std::string msg = "Specified observation contains no effective area"
" information.\n" + obs.print();
throw GException::invalid_argument(G_MC, msg);
}
// Retrieve event list to access the ROI, energy boundaries and GTIs
const GCTAEventList* events =
dynamic_cast<const GCTAEventList*>(obs.events());
if (events == NULL) {
std::string msg = "No CTA event list found in observation.\n" +
obs.print();
throw GException::invalid_argument(G_MC, msg);
}
// Get simulation region
const GCTARoi& roi = events->roi();
const GEbounds& ebounds = events->ebounds();
const GGti& gti = events->gti();
// Get maximum offset value for simulations
double max_theta = pnt.dir().dist(roi.centre().dir()) +
roi.radius() * gammalib::deg2rad;
double cos_max_theta = std::cos(max_theta);
// Set simulation region for result event list
list->roi(roi);
list->ebounds(ebounds);
list->gti(gti);
// Set up spectral model to draw random energies from. Here we use
// a fixed energy sampling for an instance of GModelSpectralNodes.
// This is analogous to to the GCTAModelIrfBackground::mc method.
// We make sure that only non-negative nodes get appended.
GEbounds spectral_ebounds =
GEbounds(m_n_mc_energies, ebounds.emin(), ebounds.emax(), true);
GModelSpectralNodes spectral;
for (int i = 0; i < spectral_ebounds.size(); ++i) {
GEnergy energy = spectral_ebounds.elogmean(i);
double intensity = aeff_integral(obs, energy.log10TeV());
double norm = m_spectral->eval(energy, events->tstart());
double arg = norm * intensity;
if (arg > 0.0) {
spectral.append(energy, arg);
}
}
// Loop over all energy bins
for (int ieng = 0; ieng < ebounds.size(); ++ieng) {
// Compute the background rate in model within the energy
// boundaries from spectral component (units: cts/s).
// Note that the time here is ontime. Deadtime correction will
// be done later.
double rate = spectral.flux(ebounds.emin(ieng), ebounds.emax(ieng));
// Debug option: dump rate
#if defined(G_DUMP_MC)
std::cout << "GCTAModelAeffBackground::mc(\"" << name() << "\": ";
std::cout << "rate=" << rate << " cts/s)" << std::endl;
#endif
// If the rate is not positive then skip this energy bins
if (rate <= 0.0) {
continue;
}
// Loop over all good time intervals
for (int itime = 0; itime < gti.size(); ++itime) {
// Get Monte Carlo event arrival times from temporal model
GTimes times = m_temporal->mc(rate,
gti.tstart(itime),
gti.tstop(itime),
ran);
// Get number of events
int n_events = times.size();
// Reserve space for events
if (n_events > 0) {
list->reserve(n_events);
}
// Debug option: provide number of times and initialize
// statisics
#if defined(G_DUMP_MC)
std::cout << " Interval " << itime;
std::cout << " times=" << n_events << std::endl;
int n_killed_by_deadtime = 0;
int n_killed_by_roi = 0;
#endif
// Loop over events
for (int i = 0; i < n_events; ++i) {
// Apply deadtime correction
double deadc = obs.deadc(times[i]);
if (deadc < 1.0) {
if (ran.uniform() > deadc) {
#if defined(G_DUMP_MC)
n_killed_by_deadtime++;
#endif
continue;
}
}
// Get Monte Carlo event energy from spectral model
GEnergy energy = spectral.mc(ebounds.emin(ieng),
ebounds.emax(ieng),
times[i],
ran);
// Get maximum effective area for rejection method
double max_aeff = aeff->max(energy.log10TeV(), pnt.zenith(),
pnt.azimuth(), false);
// Skip event if the maximum effective area is not positive
if (max_aeff <= 0.0) {
continue;
}
// Initialise randomised coordinates
double offset = 0.0;
double phi = 0.0;
// Initialise acceptance fraction and counter of zeros for
// rejection method
double acceptance_fraction = 0.0;
int zeros = 0;
// Start rejection method loop
do {
// Throw random offset and azimuth angle in
// considered range
offset = std::acos(1.0 - ran.uniform() *
(1.0 - cos_max_theta));
phi = ran.uniform() * gammalib::twopi;
// Compute function value at this offset angle
double value = (*aeff)(energy.log10TeV(), offset, phi,
pnt.zenith(), pnt.azimuth(),
false);
// If the value is not positive then increment the
// zeros counter and fall through. The counter assures
// that this loop does not lock up.
if (value <= 0.0) {
zeros++;
continue;
}
// Value is non-zero so reset the zeros counter
zeros = 0;
// Compute acceptance fraction
acceptance_fraction = value / max_aeff;
} while ((ran.uniform() > acceptance_fraction) &&
(zeros < 1000));
// If the zeros counter is non-zero then the loop was
// exited due to exhaustion and the event is skipped
if (zeros > 0) {
continue;
}
// Convert CTA pointing direction in instrument system
GCTAInstDir mc_dir(pnt.dir());
// Rotate pointing direction by offset and azimuth angle
mc_dir.dir().rotate_deg(phi * gammalib::rad2deg,
offset * gammalib::rad2deg);
// Compute DETX and DETY coordinates
double detx(0.0);
double dety(0.0);
if (offset > 0.0 ) {
detx = offset * std::cos(phi);
dety = offset * std::sin(phi);
}
// Set DETX and DETY coordinates
mc_dir.detx(detx);
mc_dir.dety(dety);
// Allocate event
GCTAEventAtom event;
// Set event attributes
event.dir(mc_dir);
event.energy(energy);
event.time(times[i]);
// Append event to list if it falls in ROI
if (events->roi().contains(event)) {
list->append(event);
}
#if defined(G_DUMP_MC)
else {
n_killed_by_roi++;
}
#endif
} // endfor: looped over all events
// Debug option: provide statisics
#if defined(G_DUMP_MC)
std::cout << " Killed by deadtime=";
std::cout << n_killed_by_deadtime << std::endl;
std::cout << " Killed by ROI=";
std::cout << n_killed_by_roi << std::endl;
#endif
} // endfor: looped over all GTIs
} // endfor: looped over all energy boundaries
} // endif: model was valid
// Return
return list;
}
/***********************************************************************//**
* @brief Return simulated list of events
*
* @param[in] obs Observation.
* @param[in] ran Random number generator.
* @return Pointer to list of simulated events (needs to be de-allocated by
* client)
*
* @exception GException::invalid_argument
* Specified observation is not a CTA observation.
*
* Draws a sample of events from the background model using a Monte
* Carlo simulation. The region of interest, the energy boundaries and the
* good time interval for the sampling will be extracted from the observation
* argument that is passed to the method. The method also requires a random
* number generator of type GRan which is passed by reference, hence the
* state of the random number generator will be changed by the method.
*
* The method also applies a deadtime correction using a Monte Carlo process,
* taking into account temporal deadtime variations. For this purpose, the
* method makes use of the time dependent GObservation::deadc method.
*
* For each event in the returned event list, the sky direction, the nominal
* coordinates (DETX and DETY), the energy and the time will be set.
***************************************************************************/
GCTAEventList* GCTAModelIrfBackground::mc(const GObservation& obs, GRan& ran) const
{
// Initialise new event list
GCTAEventList* list = new GCTAEventList;
// Continue only if model is valid)
if (valid_model()) {
// Retrieve CTA observation
const GCTAObservation* cta = dynamic_cast<const GCTAObservation*>(&obs);
if (cta == NULL) {
std::string msg = "Specified observation is not a CTA observation.\n" +
obs.print();
throw GException::invalid_argument(G_MC, msg);
}
// Get pointer on CTA IRF response
const GCTAResponseIrf* rsp = dynamic_cast<const GCTAResponseIrf*>(cta->response());
if (rsp == NULL) {
std::string msg = "Specified observation does not contain"
" an IRF response.\n" + obs.print();
throw GException::invalid_argument(G_MC, msg);
}
// Retrieve CTA response and pointing
const GCTAPointing& pnt = cta->pointing();
// Get pointer to CTA background
const GCTABackground* bgd = rsp->background();
if (bgd == NULL) {
std::string msg = "Specified observation contains no background"
" information.\n" + obs.print();
throw GException::invalid_argument(G_MC, msg);
}
// Retrieve event list to access the ROI, energy boundaries and GTIs
const GCTAEventList* events = dynamic_cast<const GCTAEventList*>(obs.events());
if (events == NULL) {
std::string msg = "No CTA event list found in observation.\n" +
obs.print();
throw GException::invalid_argument(G_MC, msg);
}
// Get simulation region
const GCTARoi& roi = events->roi();
const GEbounds& ebounds = events->ebounds();
const GGti& gti = events->gti();
// Set simulation region for result event list
list->roi(roi);
list->ebounds(ebounds);
list->gti(gti);
// Create a spectral model that combines the information from the
// background information and the spectrum provided by the model
GModelSpectralNodes spectral(bgd->spectrum());
for (int i = 0; i < spectral.nodes(); ++i) {
GEnergy energy = spectral.energy(i);
double intensity = spectral.intensity(i);
double norm = m_spectral->eval(energy, events->tstart());
spectral.intensity(i, norm*intensity);
}
// Loop over all energy boundaries
for (int ieng = 0; ieng < ebounds.size(); ++ieng) {
// Compute the background rate in model within the energy
// boundaries from spectral component (units: cts/s).
// Note that the time here is ontime. Deadtime correction will
// be done later.
double rate = spectral.flux(ebounds.emin(ieng), ebounds.emax(ieng));
// Debug option: dump rate
#if defined(G_DUMP_MC)
std::cout << "GCTAModelIrfBackground::mc(\"" << name() << "\": ";
std::cout << "rate=" << rate << " cts/s)" << std::endl;
#endif
// Loop over all good time intervals
for (int itime = 0; itime < gti.size(); ++itime) {
// Get Monte Carlo event arrival times from temporal model
GTimes times = m_temporal->mc(rate,
gti.tstart(itime),
gti.tstop(itime),
ran);
// Get number of events
int n_events = times.size();
// Reserve space for events
if (n_events > 0) {
list->reserve(n_events);
}
// Debug option: provide number of times and initialize
// statisics
#if defined(G_DUMP_MC)
std::cout << " Interval " << itime;
std::cout << " times=" << n_events << std::endl;
int n_killed_by_deadtime = 0;
int n_killed_by_roi = 0;
#endif
// Loop over events
for (int i = 0; i < n_events; ++i) {
// Apply deadtime correction
double deadc = obs.deadc(times[i]);
if (deadc < 1.0) {
if (ran.uniform() > deadc) {
#if defined(G_DUMP_MC)
n_killed_by_deadtime++;
#endif
continue;
}
}
// Get Monte Carlo event energy from spectral model
GEnergy energy = spectral.mc(ebounds.emin(ieng),
ebounds.emax(ieng),
times[i],
ran);
// Get Monte Carlo event direction from spatial model.
// This only will set the DETX and DETY coordinates.
GCTAInstDir instdir = bgd->mc(energy, times[i], ran);
// Derive sky direction from instrument coordinates
GSkyDir skydir = pnt.skydir(instdir);
// Set sky direction in GCTAInstDir object
instdir.dir(skydir);
// Allocate event
GCTAEventAtom event;
// Set event attributes
event.dir(instdir);
event.energy(energy);
event.time(times[i]);
// Append event to list if it falls in ROI
if (events->roi().contains(event)) {
list->append(event);
}
#if defined(G_DUMP_MC)
else {
n_killed_by_roi++;
}
#endif
} // endfor: looped over all events
// Debug option: provide statisics
#if defined(G_DUMP_MC)
std::cout << " Killed by deadtime=";
std::cout << n_killed_by_deadtime << std::endl;
std::cout << " Killed by ROI=";
std::cout << n_killed_by_roi << std::endl;
#endif
} // endfor: looped over all GTIs
} // endfor: looped over all energy boundaries
} // endif: model was valid
// Return
return list;
}