/***********************************************************************//**
* @brief Simulate background events from model
*
* @param[in] obs Pointer on CTA observation.
* @param[in] models Models.
* @param[in] ran Random number generator.
* @param[in] wrklog Pointer to logger.
*
* Simulate background events from models. The events are stored as event
* list in the observation.
*
* This method does nothing if the observation pointer is NULL.
***************************************************************************/
void ctobssim::simulate_background(GCTAObservation* obs,
const GModels& models,
GRan& ran,
GLog* wrklog)
{
// Continue only if observation pointer is valid
if (obs != NULL) {
// If no logger is specified then use the default logger
if (wrklog == NULL) {
wrklog = &log;
}
// Get pointer on event list (circumvent const correctness)
GCTAEventList* events =
static_cast<GCTAEventList*>(const_cast<GEvents*>(obs->events()));
// Loop over all models
for (int i = 0; i < models.size(); ++i) {
// Get data model (NULL if not a data model)
const GModelData* model =
dynamic_cast<const GModelData*>(models[i]);
// If we have a data model that applies to the present observation
// then simulate events
if (model != NULL &&
model->is_valid(obs->instrument(), obs->id())) {
// Get simulated CTA event list. Note that this method
// includes the deadtime correction.
GCTAEventList* list =
dynamic_cast<GCTAEventList*>(model->mc(*obs, ran));
// Continue only if we got a CTA event list
if (list != NULL) {
// Reserves space for events
events->reserve(list->size()+events->size());
// Append events
for (int k = 0; k < list->size(); k++) {
// Get event pointer
GCTAEventAtom* event = (*list)[k];
// Use event only if it falls within ROI
if (events->roi().contains(*event)) {
// Set event identifier
event->event_id(m_event_id);
m_event_id++;
// Append event
events->append(*event);
} // endif: event was within ROI
} // endfor: looped over all events
// Dump simulation results
if (logNormal()) {
*wrklog << gammalib::parformat("MC background events");
*wrklog << list->size() << std::endl;
}
// Free event list
delete list;
} // endif: we had a CTA event list
} // endif: model was valid
} // endfor: looped over all models
} // endif: observation pointer was valid
// Return
return;
}
/***********************************************************************//**
* @brief Simulate source events from photon list
*
* @param[in] obs Pointer on CTA observation.
* @param[in] models Model list.
* @param[in] ran Random number generator.
* @param[in] wrklog Pointer to logger.
*
* Simulate source events from a photon list for a given CTA observation.
* The events are stored in as event list in the observation.
*
* This method does nothing if the observation pointer is NULL. It also
* verifies if the observation has a valid pointing and response.
***************************************************************************/
void ctobssim::simulate_source(GCTAObservation* obs, const GModels& models,
GRan& ran, GLog* wrklog)
{
// Continue only if observation pointer is valid
if (obs != NULL) {
// If no logger is specified then use the default logger
if (wrklog == NULL) {
wrklog = &log;
}
// Get CTA response
const GCTAResponseIrf* rsp =
dynamic_cast<const GCTAResponseIrf*>(obs->response());
if (rsp == NULL) {
std::string msg = "Response is not an IRF response.\n" +
obs->response()->print();
throw GException::invalid_value(G_SIMULATE_SOURCE, msg);
}
// Get pointer on event list (circumvent const correctness)
GCTAEventList* events =
static_cast<GCTAEventList*>(const_cast<GEvents*>(obs->events()));
// Extract simulation region.
GSkyDir dir = events->roi().centre().dir();
double rad = events->roi().radius() + g_roi_margin;
// Dump simulation cone information
if (logNormal()) {
*wrklog << gammalib::parformat("Simulation area");
*wrklog << m_area << " cm2" << std::endl;
*wrklog << gammalib::parformat("Simulation cone");
*wrklog << "RA=" << dir.ra_deg() << " deg";
*wrklog << ", Dec=" << dir.dec_deg() << " deg";
*wrklog << ", r=" << rad << " deg" << std::endl;
}
// Initialise indentation for logging
int indent = 0;
// Loop over all Good Time Intervals
for (int it = 0; it < events->gti().size(); ++it) {
// Extract time interval
GTime tmin = events->gti().tstart(it);
GTime tmax = events->gti().tstop(it);
// Dump time interval
if (logNormal()) {
if (events->gti().size() > 1) {
indent++;
wrklog->indent(indent);
}
*wrklog << gammalib::parformat("Time interval", indent);
*wrklog << tmin.convert(m_cta_ref);
*wrklog << " - ";
*wrklog << tmax.convert(m_cta_ref);
*wrklog << " s" << std::endl;
}
// Loop over all energy boundaries
for (int ie = 0; ie < events->ebounds().size(); ++ie) {
// Extract energy boundaries
GEnergy emin = events->ebounds().emin(ie);
GEnergy emax = events->ebounds().emax(ie);
// Set true photon energy limits for simulation. If observation
// has energy dispersion then add margin
GEnergy e_true_min = emin;
GEnergy e_true_max = emax;
if (rsp->use_edisp()) {
e_true_min = rsp->ebounds(e_true_min).emin();
e_true_max = rsp->ebounds(e_true_max).emax();
}
// Dump energy range
if (logNormal()) {
if (events->ebounds().size() > 1) {
indent++;
wrklog->indent(indent);
}
*wrklog << gammalib::parformat("Photon energy range", indent);
*wrklog << e_true_min << " - " << e_true_max << std::endl;
*wrklog << gammalib::parformat("Event energy range", indent);
*wrklog << emin << " - " << emax << std::endl;
}
// Loop over all sky models
for (int i = 0; i < models.size(); ++i) {
// Get sky model (NULL if not a sky model)
const GModelSky* model =
dynamic_cast<const GModelSky*>(models[i]);
// If we have a sky model that applies to the present
// observation then simulate events
if (model != NULL &&
model->is_valid(obs->instrument(), obs->id())) {
// Determine duration of a time slice by limiting the
// number of simulated photons to m_max_photons.
// The photon rate is estimated from the model flux
// and used to set the duration of the time slice.
double flux = get_model_flux(model, emin, emax,
dir, rad);
double rate = flux * m_area;
double duration = 1800.0; // default: 1800 sec
if (rate > 0.0) {
duration = m_max_photons / rate;
if (duration < 1.0) { // not <1 sec
duration = 1.0;
}
else if (duration > 180000.0) { // not >50 hr
duration = 180000.0;
}
}
GTime tslice(duration, "sec");
// If photon rate exceeds the maximum photon rate
// then throw an exception
if (rate > m_max_rate) {
std::string modnam = (model->name().length() > 0) ?
model->name() : "Unknown";
std::string msg = "Photon rate "+
gammalib::str(rate)+
" photons/sec for model \""+
modnam+"\" exceeds maximum"
" allowed photon rate of "+
gammalib::str(m_max_rate)+
" photons/sec. Please check"
" the model parameters for"
" model \""+modnam+"\" or"
" increase the value of the"
" hidden \"maxrate\""
" parameter.";
throw GException::invalid_value(G_SIMULATE_SOURCE, msg);
}
// Dump length of time slice and rate
if (logExplicit()) {
*wrklog << gammalib::parformat("Photon rate", indent);
*wrklog << rate << " photons/sec";
if (model->name().length() > 0) {
*wrklog << " [" << model->name() << "]";
}
*wrklog << std::endl;
}
// To reduce memory requirements we split long time
// intervals into several slices.
GTime tstart = tmin;
GTime tstop = tstart + tslice;
// Initialise cumulative photon counters
int nphotons = 0;
// Loop over time slices
while (tstart < tmax) {
// Make sure that tstop <= tmax
if (tstop > tmax) {
tstop = tmax;
}
// Dump time slice
if (logExplicit()) {
if (tmax - tmin > tslice) {
indent++;
wrklog->indent(indent);
}
*wrklog << gammalib::parformat("Time slice", indent);
*wrklog << tstart.convert(m_cta_ref);
*wrklog << " - ";
*wrklog << tstop.convert(m_cta_ref);
*wrklog << " s";
if (model->name().length() > 0) {
*wrklog << " [" << model->name() << "]";
}
*wrklog << std::endl;
}
// Get photons
GPhotons photons = model->mc(m_area, dir, rad,
e_true_min, e_true_max,
tstart, tstop, ran);
// Dump number of simulated photons
if (logExplicit()) {
*wrklog << gammalib::parformat("MC source photons/slice", indent);
*wrklog << photons.size();
if (model->name().length() > 0) {
*wrklog << " [" << model->name() << "]";
}
*wrklog << std::endl;
}
// Simulate events from photons
for (int i = 0; i < photons.size(); ++i) {
// Increment photon counter
nphotons++;
// Simulate event. Note that this method
// includes the deadtime correction.
GCTAEventAtom* event = rsp->mc(m_area,
photons[i],
*obs,
ran);
if (event != NULL) {
// Use event only if it falls within ROI
// energy boundary and time slice
if (events->roi().contains(*event) &&
event->energy() >= emin &&
event->energy() <= emax &&
event->time() >= tstart &&
event->time() <= tstop) {
event->event_id(m_event_id);
events->append(*event);
m_event_id++;
}
delete event;
}
} // endfor: looped over events
// Go to next time slice
tstart = tstop;
tstop = tstart + tslice;
// Reset indentation
if (logExplicit()) {
if (tmax - tmin > tslice) {
indent--;
wrklog->indent(indent);
}
}
} // endwhile: looped over time slices
// Dump simulation results
if (logNormal()) {
*wrklog << gammalib::parformat("MC source photons", indent);
*wrklog << nphotons;
if (model->name().length() > 0) {
*wrklog << " [" << model->name() << "]";
}
*wrklog << std::endl;
*wrklog << gammalib::parformat("MC source events", indent);
*wrklog << events->size();
if (model->name().length() > 0) {
*wrklog << " [" << model->name() << "]";
}
*wrklog << std::endl;
}
} // endif: model was a sky model
} // endfor: looped over models
// Dump simulation results
if (logNormal()) {
*wrklog << gammalib::parformat("MC source events", indent);
*wrklog << events->size();
*wrklog << " (all source models)";
*wrklog << std::endl;
}
// Reset indentation
if (logNormal()) {
if (events->ebounds().size() > 1) {
indent--;
wrklog->indent(indent);
}
}
} // endfor: looped over all energy boundaries
// Reset indentation
if (logNormal()) {
if (events->gti().size() > 1) {
indent--;
wrklog->indent(indent);
}
}
} // endfor: looped over all time intervals
// Reset indentation
wrklog->indent(0);
} // endif: observation pointer was valid
// Return
return;
}
/***********************************************************************//**
* @brief Simulate source events from photon list
*
* @param[in] obs Pointer on CTA observation.
* @param[in] models Model list.
* @param[in] ran Random number generator.
* @param[in] wrklog Pointer to logger.
*
* Simulate source events from a photon list for a given CTA observation.
* The events are stored in as event list in the observation.
*
* This method does nothing if the observation pointer is NULL. It also
* verifies if the observation has a valid pointing and response.
***************************************************************************/
void ctobssim::simulate_source(GCTAObservation* obs, const GModels& models,
GRan& ran, GLog* wrklog)
{
// Continue only if observation pointer is valid
if (obs != NULL) {
// If no logger is specified then use the default logger
if (wrklog == NULL) {
wrklog = &log;
}
// Get pointer on CTA response. Throw an exception if the response
// is not defined.
const GCTAResponse& rsp = obs->response();
// Make sure that the observation holds a CTA event list. If this
// is not the case then allocate and attach a CTA event list now.
if (dynamic_cast<const GCTAEventList*>(obs->events()) == NULL) {
set_list(obs);
}
// Get pointer on event list (circumvent const correctness)
GCTAEventList* events = static_cast<GCTAEventList*>(const_cast<GEvents*>(obs->events()));
// Extract simulation region.
GSkyDir dir = events->roi().centre().dir();
double rad = events->roi().radius() + g_roi_margin;
// Dump simulation cone information
if (logNormal()) {
*wrklog << gammalib::parformat("Simulation area");
*wrklog << m_area << " cm2" << std::endl;
*wrklog << gammalib::parformat("Simulation cone");
*wrklog << "RA=" << dir.ra_deg() << " deg";
*wrklog << ", Dec=" << dir.dec_deg() << " deg";
*wrklog << ", r=" << rad << " deg" << std::endl;
}
// Initialise indentation for logging
int indent = 0;
// Loop over all Good Time Intervals
for (int it = 0; it < events->gti().size(); ++it) {
// Extract time interval
GTime tmin = events->gti().tstart(it);
GTime tmax = events->gti().tstop(it);
// Dump time interval
if (logNormal()) {
if (events->gti().size() > 1) {
indent++;
wrklog->indent(indent);
}
*wrklog << gammalib::parformat("Time interval", indent);
*wrklog << tmin.convert(m_cta_ref);
*wrklog << " - ";
*wrklog << tmax.convert(m_cta_ref);
*wrklog << " s" << std::endl;
}
// Loop over all energy boundaries
for (int ie = 0; ie < events->ebounds().size(); ++ie) {
// Extract energy boundaries
GEnergy emin = events->ebounds().emin(ie);
GEnergy emax = events->ebounds().emax(ie);
// Dump energy range
if (logNormal()) {
if (events->ebounds().size() > 1) {
indent++;
wrklog->indent(indent);
}
*wrklog << gammalib::parformat("Energy range", indent);
*wrklog << emin << " - " << emax << std::endl;
}
// Loop over all sky models
for (int i = 0; i < models.size(); ++i) {
// Get sky model (NULL if not a sky model)
const GModelSky* model =
dynamic_cast<const GModelSky*>(models[i]);
// If we have a sky model that applies to the present
// observation then simulate events
if (model != NULL &&
model->is_valid(obs->instrument(), obs->id())) {
// Determine duration of a time slice by limiting the
// number of simulated photons to m_max_photons.
// The photon rate is estimated from the model flux
// and used to set the duration of the time slice.
double flux = model->spectral()->flux(emin, emax);
double rate = flux * m_area;
double duration = 1800.0; // default: 1800 sec
if (rate > 0.0) {
duration = m_max_photons / rate;
if (duration < 1.0) { // not <1 sec
duration = 1.0;
}
else if (duration > 180000.0) { // not >50 hr
duration = 180000.0;
}
}
GTime tslice(duration, "sec");
// To reduce memory requirements we split long time
// intervals into several slices.
GTime tstart = tmin;
GTime tstop = tstart + tslice;
// Initialise cumulative photon counters
int nphotons = 0;
// Loop over time slices
while (tstart < tmax) {
// Make sure that tstop <= tmax
if (tstop > tmax) {
tstop = tmax;
}
// Dump time slice
if (logExplicit()) {
if (tmax - tmin > tslice) {
indent++;
wrklog->indent(indent);
}
*wrklog << gammalib::parformat("Time slice", indent);
*wrklog << tstart.convert(m_cta_ref);
*wrklog << " - ";
*wrklog << tstop.convert(m_cta_ref);
*wrklog << " s" << std::endl;
}
// Get photons
GPhotons photons = model->mc(m_area, dir, rad,
emin, emax,
tstart, tstop, ran);
// Dump number of simulated photons
if (logExplicit()) {
*wrklog << gammalib::parformat("MC source photons/slice", indent);
*wrklog << photons.size();
if (model->name().length() > 0) {
*wrklog << " [" << model->name() << "]";
}
*wrklog << std::endl;
}
// Simulate events from photons
for (int i = 0; i < photons.size(); ++i) {
// Increment photon counter
nphotons++;
// Simulate event. Note that this method
// includes the deadtime correction.
GCTAEventAtom* event = rsp.mc(m_area,
photons[i],
*obs,
ran);
if (event != NULL) {
// Use event only if it falls within ROI
if (events->roi().contains(*event)) {
event->event_id(m_event_id);
events->append(*event);
m_event_id++;
}
delete event;
}
} // endfor: looped over events
// Go to next time slice
tstart = tstop;
tstop = tstart + tslice;
// Reset indentation
if (logExplicit()) {
if (tmax - tmin > tslice) {
indent--;
wrklog->indent(indent);
}
}
} // endwhile: looped over time slices
// Dump simulation results
if (logNormal()) {
*wrklog << gammalib::parformat("MC source photons", indent);
*wrklog << nphotons;
if (model->name().length() > 0) {
*wrklog << " [" << model->name() << "]";
}
*wrklog << std::endl;
*wrklog << gammalib::parformat("MC source events", indent);
*wrklog << events->size();
if (model->name().length() > 0) {
*wrklog << " [" << model->name() << "]";
}
*wrklog << std::endl;
}
} // endif: model was a sky model
} // endfor: looped over models
// Dump simulation results
if (logNormal()) {
*wrklog << gammalib::parformat("MC source events", indent);
*wrklog << events->size();
*wrklog << " (all source models)";
*wrklog << std::endl;
}
// Reset indentation
if (logNormal()) {
if (events->ebounds().size() > 1) {
indent--;
wrklog->indent(indent);
}
}
} // endfor: looped over all energy boundaries
// Reset indentation
if (logNormal()) {
if (events->gti().size() > 1) {
indent--;
wrklog->indent(indent);
}
}
} // endfor: looped over all time intervals
// Reset indentation
wrklog->indent(0);
} // endif: observation pointer was valid
// Return
return;
}