/***********************************************************************//**
* @brief Test CTA Npred computation
*
* Tests the Npred computation for the diffuse source model. This is done
* by loading the model from the XML file and by calling the
* GCTAObservation::npred method which in turn calls the
* GCTAResponse::npred_diffuse method. The test takes a few seconds.
***************************************************************************/
void TestGCTAResponse::test_response_npred_diffuse(void)
{
// Set reference value
double ref = 11212.26274;
// Set parameters
double src_ra = 201.3651;
double src_dec = -43.0191;
double roi_rad = 4.0;
// Setup ROI centred on Cen A with a radius of 4 deg
GCTARoi roi;
GCTAInstDir instDir;
instDir.radec_deg(src_ra, src_dec);
roi.centre(instDir);
roi.radius(roi_rad);
// Setup pointing on Cen A
GSkyDir skyDir;
skyDir.radec_deg(src_ra, src_dec);
GCTAPointing pnt;
pnt.dir(skyDir);
// Setup dummy event list
GGti gti;
GEbounds ebounds;
GTime tstart(0.0);
GTime tstop(1800.0);
GEnergy emin;
GEnergy emax;
emin.TeV(0.1);
emax.TeV(100.0);
gti.append(tstart, tstop);
ebounds.append(emin, emax);
GCTAEventList events;
events.roi(roi);
events.gti(gti);
events.ebounds(ebounds);
// Setup dummy CTA observation
GCTAObservation obs;
obs.ontime(1800.0);
obs.livetime(1600.0);
obs.deadc(1600.0/1800.0);
obs.response(cta_irf, cta_caldb);
obs.events(&events);
obs.pointing(pnt);
// Load models for Npred computation
GModels models(cta_rsp_xml);
// Perform Npred computation
double npred = obs.npred(models, NULL);
// Test Npred
test_value(npred, ref, 1.0e-5, "Diffuse Npred computation");
// Return
return;
}
/***********************************************************************//**
* @brief Test CTA npsf computation
***************************************************************************/
void TestGCTAResponse::test_response_npsf(void)
{
// Setup CTA response
GCTAResponse rsp;
rsp.caldb(cta_caldb);
rsp.load(cta_irf);
// Setup npsf computation
GSkyDir srcDir;
GEnergy srcEng;
GTime srcTime;
GCTAPointing pnt;
GCTARoi roi;
GCTAInstDir instDir;
instDir.radec_deg(0.0, 0.0);
roi.centre(instDir);
roi.radius(2.0);
srcEng.TeV(0.1);
// Test PSF centred on ROI
srcDir.radec_deg(0.0, 0.0);
double npsf = rsp.npsf(srcDir, srcEng.log10TeV(), srcTime, pnt, roi);
test_value(npsf, 1.0, 1.0e-3, "PSF(0,0) integration");
// Test PSF offset but inside ROI
srcDir.radec_deg(1.0, 1.0);
npsf = rsp.npsf(srcDir, srcEng.log10TeV(), srcTime, pnt, roi);
test_value(npsf, 1.0, 1.0e-3, "PSF(1,1) integration");
// Test PSF outside and overlapping ROI
srcDir.radec_deg(0.0, 2.0);
npsf = rsp.npsf(srcDir, srcEng.log10TeV(), srcTime, pnt, roi);
test_value(npsf, 0.492373, 1.0e-3, "PSF(0,2) integration");
// Test PSF outside ROI
srcDir.radec_deg(2.0, 2.0);
npsf = rsp.npsf(srcDir, srcEng.log10TeV(), srcTime, pnt, roi);
test_value(npsf, 0.0, 1.0e-3, "PSF(2,2) integration");
// Return
return;
}
/***********************************************************************//**
* @brief Select events
*
* @param[in] obs CTA observation.
* @param[in] filename File name.
*
* Select events from a FITS file by making use of the selection possibility
* of the cfitsio library on loading a file. A selection string is created
* from the specified criteria that is appended to the filename so that
* cfitsio will automatically filter the event data. This selection string
* is then applied when opening the FITS file. The opened FITS file is then
* saved into a temporary file which is the loaded into the actual CTA
* observation, overwriting the old CTA observation. The ROI, GTI and EBounds
* of the CTA event list are then set accordingly to the specified selection.
* Finally, the temporary file created during this process is removed.
*
* Good Time Intervals of the observation will be limited to the time
* interval [m_tmin, m_tmax]. If m_tmin=m_tmax=0, no time selection is
* performed.
*
* @todo Use INDEF instead of 0.0 for pointing as RA/DEC selection
***************************************************************************/
void ctselect::select_events(GCTAObservation* obs, const std::string& filename)
{
// Allocate selection string
std::string selection;
char cmin[80];
char cmax[80];
char cra[80];
char cdec[80];
char crad[80];
// Set requested selections
bool select_time = (m_tmin != 0.0 || m_tmax != 0.0);
// Set RA/DEC selection
double ra = m_ra;
double dec = m_dec;
if (m_usepnt) {
const GCTAPointing *pnt = obs->pointing();
ra = pnt->dir().ra_deg();
dec = pnt->dir().dec_deg();
}
// Set time selection interval. We make sure here that the time selection
// interval cannot be wider than the GTIs covering the data. This is done
// using GGti's reduce() method.
if (select_time) {
// Reduce GTIs to specified time interval. The complicated cast is
// necessary here because the gti() method is declared const, so
// we're not officially allowed to modify the GTIs.
((GGti*)(&obs->events()->gti()))->reduce(m_timemin, m_timemax);
} // endif: time selection was required
// Save GTI for later usage
GGti gti = obs->events()->gti();
// Make time selection
if (select_time) {
// Extract effective time interval in CTA reference time. We need
// this reference for filtering.
double tmin = gti.tstart().convert(m_cta_ref);
double tmax = gti.tstop().convert(m_cta_ref);
// Format time with sufficient accuracy and add to selection string
sprintf(cmin, "%.8f", tmin);
sprintf(cmax, "%.8f", tmax);
selection = "TIME >= "+std::string(cmin)+" && TIME <= "+std::string(cmax);
if (logTerse()) {
log << parformat("Time range");
log << tmin << " - " << tmax << " s" << std::endl;
}
if (selection.length() > 0) {
selection += " && ";
}
}
// Make energy selection
sprintf(cmin, "%.8f", m_emin);
sprintf(cmax, "%.8f", m_emax);
selection += "ENERGY >= "+std::string(cmin)+" && ENERGY <= "+std::string(cmax);
if (logTerse()) {
log << parformat("Energy range");
log << m_emin << " - " << m_emax << " TeV" << std::endl;
}
if (selection.length() > 0) {
selection += " && ";
}
// Make ROI selection
sprintf(cra, "%.6f", ra);
sprintf(cdec, "%.6f", dec);
sprintf(crad, "%.6f", m_rad);
selection += "ANGSEP("+std::string(cra)+"," +
std::string(cdec)+",RA,DEC) <= " +
std::string(crad);
if (logTerse()) {
log << parformat("Acceptance cone centre");
log << "RA=" << ra << ", DEC=" << dec << " deg" << std::endl;
log << parformat("Acceptance cone radius");
log << m_rad << " deg" << std::endl;
}
if (logTerse()) {
log << parformat("cfitsio selection");
log << selection << std::endl;
}
// Add additional expression
if (strip_whitespace(m_expr).length() > 0) {
if (selection.length() > 0) {
selection += " && ";
}
selection += "("+strip_whitespace(m_expr)+")";
}
// Build input filename including selection expression
std::string expression = filename;
if (selection.length() > 0)
expression += "[EVENTS]["+selection+"]";
if (logTerse()) {
log << parformat("FITS filename");
log << expression << std::endl;
}
// Open FITS file
GFits file(expression);
// Log selected FITS file
if (logExplicit()) {
log << std::endl;
log.header1("FITS file content after selection");
log << file << std::endl;
}
// Check if we have an EVENTS HDU
if (!file.hashdu("EVENTS")) {
std::string message = "No \"EVENTS\" extension found in FITS file "+
expression+".";
throw GException::app_error(G_SELECT_EVENTS, message);
}
// Determine number of events in EVENTS HDU
int nevents = file.table("EVENTS")->nrows();
// If the selected event list is empty then append an empty event list
// to the observation. Otherwise load the data from the temporary file.
if (nevents < 1) {
// Create empty event list
GCTAEventList eventlist;
// Append list to observation
obs->events(&eventlist);
}
else {
// Get temporary file name
std::string tmpname = std::tmpnam(NULL);
// Save FITS file to temporary file
file.saveto(tmpname, true);
// Load observation from temporary file
obs->load_unbinned(tmpname);
// Remove temporary file
std::remove(tmpname.c_str());
}
// Get CTA event list pointer
GCTAEventList* list =
static_cast<GCTAEventList*>(const_cast<GEvents*>(obs->events()));
// Set ROI
GCTARoi roi;
GCTAInstDir instdir;
instdir.radec_deg(ra, dec);
roi.centre(instdir);
roi.radius(m_rad);
list->roi(roi);
// Set GTI
list->gti(gti);
// Set energy boundaries
GEbounds ebounds;
GEnergy emin;
GEnergy emax;
emin.TeV(m_emin);
emax.TeV(m_emax);
ebounds.append(emin, emax);
list->ebounds(ebounds);
// Recompute ontime and livetime.
GTime meantime = 0.5 * (gti.tstart() + gti.tstop());
obs->ontime(gti.ontime());
obs->livetime(gti.ontime() * obs->deadc(meantime));
// Return
return;
}
