/***********************************************************************//**
* @brief Read Good Time Intervals and time reference from FITS table
*
* @param[in] table FITS table.
*
* Reads the Good Time Intervals and time reference from a FITS table.
***************************************************************************/
void GGti::read(const GFitsTable& table)
{
// Free members
free_members();
// Initialise attributes
init_members();
// Read time reference
m_reference.read(table);
// Extract GTI information from FITS table
m_num = table.integer("NAXIS2");
if (m_num > 0) {
// Set GTIs
m_start = new GTime[m_num];
m_stop = new GTime[m_num];
for (int i = 0; i < m_num; ++i) {
m_start[i].set(table["START"]->real(i), m_reference);
m_stop[i].set(table["STOP"]->real(i), m_reference);
}
// Set attributes
set_attributes();
}
// Return
return;
}
/***********************************************************************//**
* @brief Load livetime cube from FITS file
*
* @param[in] table FITS table.
***************************************************************************/
void GLATLtCubeMap::read(const GFitsTable& table)
{
// Clear object
clear();
// Load skymap
m_map.read(table);
// Set costheta binning scheme
std::string scheme =
gammalib::strip_whitespace(gammalib::toupper(table.string("THETABIN")));
m_sqrt_bin = (scheme == "SQRT(1-COSTHETA)");
// Read attributes
m_num_ctheta = table.integer("NBRBINS");
m_num_phi = table.integer("PHIBINS");
m_min_ctheta = table.real("COSMIN");
// Return
return;
}
/***********************************************************************//**
* @brief Read energy boundaries from FITS table
*
* @param[in] table FITS table.
*
* Reads the energy boundaries from a FITS table. The method interprets the
* energy units provide in the FITS header. If no energy units are found it
* is assumed that the energies are stored in units of keV.
***************************************************************************/
void GEbounds::read(const GFitsTable& table)
{
// Free members
free_members();
// Initialise attributes
init_members();
// Extract energy boundary information from FITS table
m_num = table.integer("NAXIS2");
if (m_num > 0) {
// Allocate memory
m_min = new GEnergy[m_num];
m_max = new GEnergy[m_num];
// Get units
std::string emin_unit = table["E_MIN"]->unit();
std::string emax_unit = table["E_MAX"]->unit();
if (emin_unit.empty()) {
emin_unit = "keV";
}
if (emax_unit.empty()) {
emax_unit = "keV";
}
// Copy information
for (int i = 0; i < m_num; ++i) {
m_min[i](table["E_MIN"]->real(i), emin_unit);
m_max[i](table["E_MAX"]->real(i), emax_unit);
}
// Set attributes
set_attributes();
} // endif: there were channels to read
// Return
return;
}
/***********************************************************************//**
* @brief Read LAT events from FITS table.
*
* @param[in] table Event table.
*
* Read the LAT events from the event table.
***************************************************************************/
void GLATEventList::read_events(const GFitsTable& table)
{
// Clear existing events
m_events.clear();
// Allocate space for keyword name
char keyword[10];
// Extract number of events in FT1 file
int num = table.integer("NAXIS2");
// If there are events then load them
if (num > 0) {
// Reserve data
m_events.reserve(num);
// Get column pointers
const GFitsTableCol* ptr_time = table["TIME"];
const GFitsTableCol* ptr_energy = table["ENERGY"];
const GFitsTableCol* ptr_ra = table["RA"];
const GFitsTableCol* ptr_dec = table["DEC"];
const GFitsTableCol* ptr_theta = table["THETA"];
const GFitsTableCol* ptr_phi = table["PHI"];
const GFitsTableCol* ptr_zenith = table["ZENITH_ANGLE"];
const GFitsTableCol* ptr_azimuth = table["EARTH_AZIMUTH_ANGLE"];
const GFitsTableCol* ptr_eid = table["EVENT_ID"];
const GFitsTableCol* ptr_rid = table["RUN_ID"];
const GFitsTableCol* ptr_recon = table["RECON_VERSION"];
const GFitsTableCol* ptr_calib = table["CALIB_VERSION"];
const GFitsTableCol* ptr_class = table["EVENT_CLASS"];
const GFitsTableCol* ptr_conv = table["CONVERSION_TYPE"];
const GFitsTableCol* ptr_ltime = table["LIVETIME"];
// Copy data from columns into GLATEventAtom objects
GLATEventAtom event;
for (int i = 0; i < num; ++i) {
event.m_time.set(ptr_time->real(i), m_gti.reference());
event.m_energy.MeV(ptr_energy->real(i));
event.m_dir.dir().radec_deg(ptr_ra->real(i), ptr_dec->real(i));
event.m_theta = ptr_theta->real(i);
event.m_phi = ptr_phi->real(i);
event.m_zenith_angle = ptr_zenith->real(i);
event.m_earth_azimuth_angle = ptr_azimuth->real(i);
event.m_event_id = ptr_eid->integer(i);
event.m_run_id = ptr_rid->integer(i);
event.m_recon_version = ptr_recon->integer(i);
event.m_calib_version[0] = ptr_calib->integer(i,0);
event.m_calib_version[1] = ptr_calib->integer(i,1);
event.m_calib_version[2] = ptr_calib->integer(i,2);
event.m_event_class = ptr_class->integer(i);
event.m_conversion_type = ptr_conv->integer(i);
event.m_livetime = ptr_ltime->real(i);
m_events.push_back(event);
}
// Extract number of diffuse response labels
int num_difrsp = table.integer("NDIFRSP");
// Allocate diffuse response components
if (num_difrsp > 0) {
// Reserve space
m_difrsp_label.reserve(num_difrsp);
// Allocate components
for (int i = 0; i < num; ++i) {
m_events[i].m_difrsp = new double[num_difrsp];
}
// Load diffuse columns
for (int k = 0; k < num_difrsp; ++k) {
// Set keyword name
std::sprintf(keyword, "DIFRSP%d", k);
// Get DIFRSP label
if (table.has_card(std::string(keyword))) {
m_difrsp_label.push_back(table.string(std::string(keyword)));
}
else {
m_difrsp_label.push_back("NONE");
}
// Get column pointer
const GFitsTableCol* ptr_dif = table[std::string(keyword)];
// Copy data from columns into GLATEventAtom objects
for (int i = 0; i < num; ++i) {
m_events[i].m_difrsp[k] = ptr_dif->real(i);
}
} // endfor: looped over diffuse columns
} // endif: diffuse components found
} // endif: events found
// Return
return;
}