GCOSSpaceCraft.cpp

Go to the documentation of this file.

/***************************************************************************
 *               GCOSSpaceCraft.cpp - COSI space craft class               *
 * ----------------------------------------------------------------------- *
 *  copyright (C) 2026 by Juergen Knoedlseder                              *
 * ----------------------------------------------------------------------- *
 *                                                                         *
 *  This program is free software: you can redistribute it and/or modify   *
 *  it under the terms of the GNU General Public License as published by   *
 *  the Free Software Foundation, either version 3 of the License, or      *
 *  (at your option) any later version.                                    *
 *                                                                         *
 *  This program is distributed in the hope that it will be useful,        *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *  GNU General Public License for more details.                           *
 *                                                                         *
 *  You should have received a copy of the GNU General Public License      *
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
 *                                                                         *
 ***************************************************************************/
/**
 * @file GCOSSpaceCraft.cpp
 * @brief COSI space craft class implementation
 * @author Juergen Knoedlseder
 */
 
/* __ Includes ___________________________________________________________ */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <cstdio>             // std::fopen, std::fgets, std::fclose, etc...
#include "GTools.hpp"
#include "GFilename.hpp"
#include "GException.hpp"
#include "GSkyDir.hpp"
#include "GSkyMap.hpp"
#include "GFits.hpp"
#include "GFitsBinTable.hpp"
#include "GFitsTableDoubleCol.hpp"
#include "GFitsTable.hpp"
#include "GFitsTableCol.hpp"
#include "GCOSTools.hpp"
#include "GCOSSpaceCraft.hpp"
 
/* __ Method name definitions ____________________________________________ */
#define G_OPERATOR                         "GCOSSpaceCraft::operator[](int&)"
#define G_LOAD_ORI                     "GCOSSpaceCraft::load_ori(GFilename&)"
 
/* __ Macros _____________________________________________________________ */
 
/* __ Coding definitions _________________________________________________ */
 
/* __ Debug definitions __________________________________________________ */
 
 
 
/*==========================================================================
 =                                                                         =
 =                         Constructors/destructors                        =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Void constructor
 ***************************************************************************/
GCOSSpaceCraft::GCOSSpaceCraft(void)
{
    // Initialise class members
    init_members();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Filename constructor
 *
 * @param[in] filename Space craft file name.
 ***************************************************************************/
GCOSSpaceCraft::GCOSSpaceCraft(const GFilename& filename)
{
    // Initialise class members
    init_members();
 
    // Load space craft file
    load(filename);
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Copy constructor
 *
 * @param[in] spacecraft COSI space craft.
 ***************************************************************************/
GCOSSpaceCraft::GCOSSpaceCraft(const GCOSSpaceCraft& spacecraft)
{
    // Initialise class members
    init_members();
 
    // Copy members
    copy_members(spacecraft);
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Destructor
 ***************************************************************************/
GCOSSpaceCraft::~GCOSSpaceCraft(void)
{
    // Free members
    free_members();
 
    // Return
    return;
}
 
 
/*==========================================================================
 =                                                                         =
 =                               Operators                                 =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Assignment operator
 *
 * @param[in] spacecraft COSI space craft.
 * @return COSI space craft.
 ***************************************************************************/
GCOSSpaceCraft& GCOSSpaceCraft::operator=(const GCOSSpaceCraft& spacecraft)
{
    // Execute only if object is not identical
    if (this != &spacecraft) {
 
        // Free members
        free_members();
 
        // Initialise private members
        init_members();
 
        // Copy members
        copy_members(spacecraft);
 
    } // endif: object was not identical
 
    // Return this object
    return *this;
}
 
 
/***********************************************************************//**
 * @brief Return reference to COSI pointing
 *
 * @param[in] index Pointing index [0,...,size()-1].
 * @return Reference to COSI pointing.
 *
 * @exception GException::out_of_range
 *            Pointing index outside valid range.
 *
 * Returns reference to a COSI pointing.
 ***************************************************************************/
GCOSPointing& GCOSSpaceCraft::operator[](const int& index)
{
    // Optionally check if the index is valid
    #if defined(G_RANGE_CHECK)
    if (index < 0 || index >= size()) {
        throw GException::out_of_range(G_OPERATOR, "Pointing index", index, size());
    }
    #endif
 
    // Return reference
    return (m_pointings[index]);
}
 
 
/***********************************************************************//**
 * @brief Return reference to COSI pointing (const version)
 *
 * @param[in] index Pointing index [0,...,size()-1].
 * @return Reference to COSI pointing.
 *
 * @exception GException::out_of_range
 *            Pointing index outside valid range.
 *
 * Returns reference to a COSI pointing.
 ***************************************************************************/
const GCOSPointing& GCOSSpaceCraft::operator[](const int& index) const
{
    // Optionally check if the index is valid
    #if defined(G_RANGE_CHECK)
    if (index < 0 || index >= size()) {
        throw GException::out_of_range(G_OPERATOR, "Pointing index", index, size());
    }
    #endif
 
    // Return reference
    return (m_pointings[index]);
}
 
 
/*==========================================================================
 =                                                                         =
 =                             Public methods                              =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Clear space craft
 ***************************************************************************/
void GCOSSpaceCraft::clear(void)
{
    // Free members
    free_members();
 
    // Initialise private members
    init_members();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Clone space craft
 *
 * @return Pointer to deep copy of COSI space craft.
 ***************************************************************************/
GCOSSpaceCraft* GCOSSpaceCraft::clone(void) const
{
    return new GCOSSpaceCraft(*this);
}
 
 
/***********************************************************************//**
 * @brief Compute livetime for a given sky direction
 *
 * @param[in] dir Sky direction.
 *
 * Computes the lifetime of a given sky direction taking into account only
 * the time bins during which the source is not occulted by the Earth. The
 * method assumes the Earth to be spherically symmetric with a radius of
 * 6378 km.
 ***************************************************************************/
double GCOSSpaceCraft::livetime(const GSkyDir& dir) const
{
    // Initialise livetime
    double livetime = 0.0;
 
    // Loop over pointings
    for (int i = 0; i < size(); ++i) {
 
        // Get const reference to pointing
        const GCOSPointing& pointing = m_pointings[i];
 
        // Compute the apparent angular radius of the Earth by computing the
        // arcsine of the angle towards the Earth centre and the Earth limb.
        // This ignores the ellipticity of the Earth.
        double earth_radius = std::asin(6378.0 / (6378.0 + pointing.altitude()));
 
        // Compute the distance of the sky direction from the nadir direction
        double distance = pointing.earth_nadir().dist(dir);
 
        // If the distance is larger than the apparent angular radius of the
        // Earth then add-up the livetime
        if (distance > earth_radius) {
            livetime += pointing.livetime();
        }
 
    } // endfor: looped over pointings
 
    // Return livetime
    return livetime;
}
 
 
/***********************************************************************//**
 * @brief Compute livetime for a sky map
 *
 * @param[in] map Sky map.
 *
 * Computes the lifetime for the pixels of a sky map taking into account only
 * the time bins during which the pixels are not occulted by the Earth. The
 * method assumes the Earth to be spherically symmetric with a radius of
 * 6378 km.
 ***************************************************************************/
GSkyMap GCOSSpaceCraft::livetime(const GSkyMap& map) const
{
    // Initialise livetime sky map
    GSkyMap livetime = map.extract(0); // Extract first map for pixel definition
    livetime         = 0.0;            // Set all pixels to zero
 
    // Get number of sky map pixels
    int npix = livetime.npix();
 
    // Build-up list of pixel directions for faster distance computation
    std::vector<GSkyDir> dirs;
    dirs.reserve(npix);
    for (int k = 0; k < npix; ++k) {
        dirs.push_back(livetime.inx2dir(k));
    }
 
    // Loop over pointings
    for (int i = 0; i < size(); ++i) {
 
        // Get const reference to pointing
        const GCOSPointing& pointing = m_pointings[i];
 
        // Compute the apparent angular radius of the Earth by computing the
        // arcsine of the angle towards the Earth centre and the Earth limb.
        // This ignores the ellipticity of the Earth.
        double earth_radius = std::asin(6378.0 / (6378.0 + pointing.altitude()));
 
        // Loop over all sky map pixels
        for (int k = 0; k < npix; ++k) {
 
            // Compute the distance of the sky direction from the nadir
            // direction
            double distance = pointing.earth_nadir().dist(dirs[k]);
 
            // If the distance is larger than the apparent angular radius
            // of the Earth then add-up the livetime
            if (distance > earth_radius) {
                livetime(k) += pointing.livetime();
            }
 
        } // endfor: looped over sky map pixels
 
    } // endfor: looped over pointings
 
    // Return livetime sky map
    return livetime;
}
 
 
/***********************************************************************//**
 * @brief Load COSI space craft file
 *
 * @param[in] filename Space craft file name.
 ***************************************************************************/
void GCOSSpaceCraft::load(const GFilename& filename)
{
    // If space craft file is a FITS file than load FITS file
    if (filename.is_fits()) {
        load_fits(filename);
    }
 
    // ... otherwise load ORI file
    else {
        load_ori(filename);
    }
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Save COSI space craft FITS file
 *
 * @param[in] filename Space craft FITS file name.
 * @param[in] clobber Overwrite existing FITS file?
 *
 * Saves COSI space craft information into a FITS file.
 ***************************************************************************/
void GCOSSpaceCraft::save(const GFilename& filename, const bool& clobber) const
{
    // Open FITS file
    GFits fits;
 
    // Write space craft information
    write(fits);
 
    // Save file
    fits.saveto(filename, clobber);
 
    // Close FITS file
    fits.close();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Read COSI space craft FITS file
 *
 * @param[in] fits FITS file.
 *
 * Read the COSI space craft information from a FITS file object.
 ***************************************************************************/
void GCOSSpaceCraft::read(const GFits& fits)
{
    // Clear object
    clear();
 
    // Read pointings
    read_pointings(fits);
 
    // Read livetimes
    read_livetimes(fits);
 
    // Get GTI table
    const GFitsTable& gti = *fits.table(gammalib::extname_gti);
 
    // Read Good Time Intervals
    m_gti.read(gti);
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Write COSI space craft into FITS file.
 *
 * @param[in] fits FITS file.
 *
 * Write the COSI space craft into FITS file.
 ***************************************************************************/
void GCOSSpaceCraft::write(GFits& fits) const
{
    // Continue only if there are pointings
    if (size() > 0) {
 
        // Write pointings
        write_pointings(fits);
 
        // Write livetimes
        write_livetimes(fits);
 
        // Write Good Time Intervals
        m_gti.write(fits);
 
    } // endif: there were pointings
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Print space craft information
 *
 * @param[in] chatter Chattiness.
 * @return String containing space craft information.
 ***************************************************************************/
std::string GCOSSpaceCraft::print(const GChatter& chatter) const
{
    // Initialise result string
    std::string result;
 
    // Continue only if chatter is not silent
    if (chatter != SILENT) {
 
        // Append header
        result.append("=== GCOSSpaceCraft ===");
 
        // Append information
        result.append("\n"+gammalib::parformat("Pointings"));
        result.append(gammalib::str(size()));
        result.append("\n"+gammalib::parformat("Ontime"));
        result.append(gammalib::str(ontime())+" sec");
        result.append("\n"+gammalib::parformat("Livetime"));
        result.append(gammalib::str(livetime())+" sec");
        result.append("\n"+gammalib::parformat("Deadtime correction"));
        result.append(gammalib::str(m_deadc));
        result.append("\n"+m_gti.print(gammalib::reduce(chatter)));
 
    } // endif: chatter was not silent
 
    // Return result
    return result;
}
 
 
/*==========================================================================
 =                                                                         =
 =                             Private methods                             =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Initialise class members
 ***************************************************************************/
void GCOSSpaceCraft::init_members(void)
{
    // Initialise members
    m_gti.clear();
    m_livetimes.clear();
    m_pointings.clear();
    m_ontime   = 0.0;
    m_livetime = 0.0;
    m_deadc    = 0.0;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Copy class members
 *
 * @param[in] spacecraft COSI space craft.
 ***************************************************************************/
void GCOSSpaceCraft::copy_members(const GCOSSpaceCraft& spacecraft)
{
    // Copy members
    m_gti       = spacecraft.m_gti;
    m_livetimes = spacecraft.m_livetimes;
    m_pointings = spacecraft.m_pointings;
    m_ontime    = spacecraft.m_ontime;
    m_livetime  = spacecraft.m_livetime;
    m_deadc     = spacecraft.m_deadc;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Delete class members
 ***************************************************************************/
void GCOSSpaceCraft::free_members(void)
{
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Load COSI space craft file from ORI file
 *
 * @param[in] filename Space craft ORI file name.
 *
 * Load space craft information from an ORI file. The ORI file is a
 * whitespace separated list of 10 values, with a trailer and footer line.
 * This method does not depend on the existence of the trailer and footer
 * line but it scans all lines that have exactly 10 entries.
 *
 * The method computes the Good Time Intervals that are defined by the ORI
 * file by collecting entries that have non-zero livetime in a single
 * interval.
 ***************************************************************************/
void GCOSSpaceCraft::load_ori(const GFilename& filename)
{
    // Clear instance
    clear();
 
    // Allocate line buffer
    const int n = 10000; 
    char  line[n];
 
    // Expand environment variables
    std::string fname = gammalib::expand_env(filename.url());
 
    // Open CSV table (read-only)
    FILE* fptr = std::fopen(fname.c_str(), "r");
    if (fptr == NULL) {
        std::string msg = "Unable to open file \""+fname+"\" for read access. "
                          "Please specify a readable file.";
        throw GException::file_error(G_LOAD_ORI, msg);
    }
 
    // Initialise file parser
    GTime  tstart;
    GTime  time;
    double altitude     = 0.0;
    double livetime     = 0.0;
    double gti_livetime = 0.0;
 
    // Read lines
    while (std::fgets(line, n, fptr) != NULL) {
 
        // Get line with leading and trailing whitespace removed
        std::string sline =
          gammalib::strip_chars(gammalib::strip_whitespace(std::string(line)),"\n");
 
        // Skip empty lines
        if (sline.length() == 0) {
            continue;
        }
 
        // Split line in elements
        std::vector<std::string> elements = gammalib::split(sline, " ");
        for (int i = 0; i < elements.size(); ++i) {
            elements[i] = gammalib::strip_whitespace(elements[i]);
        }
 
        // Skip lines that have not 9 elements
        if (elements.size() != 10) {
            continue;
        }
 
        // Get information
        time     = gammalib::cos_time(gammalib::todouble(elements[1]));
        GSkyDir sc_x;
        sc_x.lb_deg(gammalib::todouble(elements[2]), gammalib::todouble(elements[3]));
        GSkyDir sc_z;
        sc_z.lb_deg(gammalib::todouble(elements[4]), gammalib::todouble(elements[5]));
        altitude = gammalib::todouble(elements[6]);
        GSkyDir earth_zenith;
        earth_zenith.lb_deg(gammalib::todouble(elements[7]), gammalib::todouble(elements[8]));
        livetime = gammalib::todouble(elements[9]);
 
        // Derive Earth nadir direction
        GSkyDir earth_nadir(earth_zenith);
        earth_nadir.rotate(0.0, gammalib::pi);
 
        // If current GTI lifetime is zero and current pointing has a positive
        // lifetime then start a new GTI
        if ((gti_livetime == 0.0) && (livetime > 0.0)) {
            tstart        = time;
            gti_livetime += livetime;
        }
 
        // ... otherwise update the Good Time Interval
        else {
 
            // If GTI lifetime is positive and livetime is zero then append Good
            // Time Interval and livetime
            if ((gti_livetime > 0.0) && (livetime == 0.0)) {
 
                // Append Good Time Interval and livetime
                m_gti.append(tstart, time);
                m_livetimes.push_back(gti_livetime);
 
                // Update ontime and livetime
                m_ontime   += (time - tstart);
                m_livetime += gti_livetime;
 
                // Reset livetime for next GTI
                gti_livetime = 0.0;
 
            }
 
            // ... otherwise update livetime
            else {
                gti_livetime += livetime;
            }
 
        } // endelse: updated Good Time Interval
 
        // Build COSI pointing
        GCOSPointing pointing;
        pointing.time(time);
        pointing.sc_x(sc_x);
        pointing.sc_z(sc_z);
        pointing.altitude(altitude);
        pointing.earth_zenith(earth_zenith);
        pointing.earth_nadir(earth_nadir);
        pointing.livetime(livetime);
 
        // Append COSI pointing
        m_pointings.push_back(pointing);
 
    } // endwhile: looped over lines
 
    // Set livetime of last element to zero
    if (size() > 0) {
        m_pointings[size()-1].livetime(0.0);
    }
 
    // Correct lifetime since last value is to be ignored
    gti_livetime -= livetime;
 
    // If GTI lifetime is pending then append a final GTI
    if ((gti_livetime > 0.0) && (time > tstart)) {
 
        // Append Good Time Interval and livetime
        m_gti.append(tstart, time);
        m_livetimes.push_back(gti_livetime);
 
        // Update ontime and livetime
        m_ontime   += (time - tstart);
        m_livetime += gti_livetime;
 
    } // endif: GTI lifetime was pending
 
    // Close file
    std::fclose(fptr);
 
    // Compute deadtime correction
    if (m_ontime > 0.0) {
        m_deadc = m_livetime / m_ontime;
    }
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Load COSI space craft file from FITS file
 *
 * @param[in] filename Space craft FITS file name.
 ***************************************************************************/
void GCOSSpaceCraft::load_fits(const GFilename& filename)
{
    // Clear instance
    clear();
 
    // Open FITS file
    GFits fits(filename);
 
    // Read event list from FITS file
    read(fits);
 
    // Close FITS file
    fits.close();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Read pointings from FITS file.
 *
 * @param[in] fits FITS file.
 *
 * Read pointings from FITS file.
 ***************************************************************************/
void GCOSSpaceCraft::read_pointings(const GFits& fits)
{
    // Get reference to FITS table
    const GFitsTable& table = *fits.table("POINTINGS");
 
    // Extract number of pointings in FITS file
    int num = table.nrows();
 
    // If there are pointings then read them
    if (num > 0) {
 
        // Allocate pointings
        m_pointings.resize(num);
 
        // Get column pointers
        const GFitsTableCol* col_time              = table["TIME"];
        const GFitsTableCol* col_sc_x_glon         = table["SC_X_GLON"];
        const GFitsTableCol* col_sc_x_glat         = table["SC_X_GLAT"];
        const GFitsTableCol* col_sc_z_glon         = table["SC_Z_GLON"];
        const GFitsTableCol* col_sc_z_glat         = table["SC_Z_GLAT"];
        const GFitsTableCol* col_altitude          = table["ALTITUDE"];
        const GFitsTableCol* col_earth_zenith_glon = table["EARTH_ZENITH_GLON"];
        const GFitsTableCol* col_earth_zenith_glat = table["EARTH_ZENITH_GLAT"];
        const GFitsTableCol* col_livetime          = table["LIVETIME"];
 
        // Extract pointing data from columns
        for (int i = 0; i < num; ++i) {
 
            // Set directions
            GSkyDir sc_x;
            GSkyDir sc_z;
            GSkyDir earth_zenith;
            sc_x.lb_deg(col_sc_x_glon->real(i), col_sc_x_glat->real(i));
            sc_z.lb_deg(col_sc_z_glon->real(i), col_sc_z_glat->real(i));
            earth_zenith.lb_deg(col_earth_zenith_glon->real(i), col_earth_zenith_glat->real(i));
 
            // Derive Earth nadir direction
            GSkyDir earth_nadir(earth_zenith);
            earth_nadir.rotate(0.0, gammalib::pi);
 
            // Set pointings
            m_pointings[i].time(gammalib::cos_time(col_time->real(i)));
            m_pointings[i].sc_x(sc_x);
            m_pointings[i].sc_z(sc_z);
            m_pointings[i].altitude(col_altitude->real(i));
            m_pointings[i].earth_zenith(earth_zenith);
            m_pointings[i].earth_nadir(earth_nadir);
            m_pointings[i].livetime(col_livetime->real(i));
 
        } // endfor: looped over pointings
 
        // Read ontime, livetime and deadtime correction factor
        m_ontime   = table.real("ONTIME");
        m_livetime = table.real("LIVETIME");
        m_deadc    = table.real("DEADC");
 
    } // endif: there were pointings
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Read livetimes from FITS file.
 *
 * @param[in] fits FITS file.
 *
 * Read livetimes from FITS file.
 ***************************************************************************/
void GCOSSpaceCraft::read_livetimes(const GFits& fits)
{
    // Get reference to FITS table
    const GFitsTable& table = *fits.table("LIVETIMES");
 
    // Extract number of livetimes in FITS file
    int num = table.nrows();
 
    // If there are livetimes then read them
    if (num > 0) {
 
        // Allocate livetimes
        m_livetimes.resize(num);
 
        // Get column pointer
        const GFitsTableCol* col_livetime = table["LIVETIME"];
 
        // Get data
        for (int i = 0; i < num; ++i) {
            m_livetimes[i] = col_livetime->real(i);
        }
 
    } // endif: there were livetimes
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Write pointings into FITS file.
 *
 * @param[in] fits FITS file.
 *
 * Write pointings into FITS file.
 ***************************************************************************/
void GCOSSpaceCraft::write_pointings(GFits& fits) const
{
    // Continue only if there are pointings
    if (size() > 0) {
 
        // Allocate FITS binary table
        GFitsBinTable table;
 
        // Allocate columns
        GFitsTableDoubleCol col_time("TIME", size());
        GFitsTableDoubleCol col_sc_x_glon("SC_X_GLON", size());
        GFitsTableDoubleCol col_sc_x_glat("SC_X_GLAT", size());
        GFitsTableDoubleCol col_sc_z_glon("SC_Z_GLON", size());
        GFitsTableDoubleCol col_sc_z_glat("SC_Z_GLAT", size());
        GFitsTableDoubleCol col_altitude("ALTITUDE", size());
        GFitsTableDoubleCol col_earth_zenith_glon("EARTH_ZENITH_GLON", size());
        GFitsTableDoubleCol col_earth_zenith_glat("EARTH_ZENITH_GLAT", size());
        GFitsTableDoubleCol col_livetime("LIVETIME", size());
 
        // Set units of columns
        // (see http://fits.gsfc.nasa.gov/standard30/fits_standard30aa.pdf)
        col_time.unit("s");
        col_sc_x_glon.unit("deg");
        col_sc_x_glat.unit("deg");
        col_sc_z_glon.unit("deg");
        col_sc_z_glat.unit("deg");
        col_altitude.unit("km");
        col_earth_zenith_glon.unit("deg");
        col_earth_zenith_glat.unit("deg");
        col_livetime.unit("s");
 
        // Fill columns
        for (int i = 0; i < size(); ++i) {
            col_time(i)              = gammalib::cos_seconds(m_pointings[i].time());
            col_sc_x_glon(i)         = m_pointings[i].sc_x().l_deg();
            col_sc_x_glat(i)         = m_pointings[i].sc_x().b_deg();
            col_sc_z_glon(i)         = m_pointings[i].sc_z().l_deg();
            col_sc_z_glat(i)         = m_pointings[i].sc_z().b_deg();
            col_altitude(i)          = m_pointings[i].altitude();
            col_earth_zenith_glon(i) = m_pointings[i].earth_zenith().l_deg();
            col_earth_zenith_glat(i) = m_pointings[i].earth_zenith().b_deg();
            col_livetime(i)          = m_pointings[i].livetime();
        }
 
        // Append columns to table
        table.append(col_time);
        table.append(col_sc_x_glon);
        table.append(col_sc_x_glat);
        table.append(col_sc_z_glon);
        table.append(col_sc_z_glat);
        table.append(col_altitude);
        table.append(col_earth_zenith_glon);
        table.append(col_earth_zenith_glat);
        table.append(col_livetime);
 
        // Set extension name
        table.extname("POINTINGS");
 
        // Write ontime, livetime and deadtime correction factor
        table.card("ONTIME",   m_ontime,   "[s] Ontime");
        table.card("LIVETIME", m_livetime, "[s] Deadtime");
        table.card("DEADC",    m_deadc,    "Deadtime correction factor");
 
        // Append table to FITS file
        fits.append(table);
 
    } // endif: there were pointings
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Write livetimes into FITS file.
 *
 * @param[in] fits FITS file.
 *
 * Write livetimes into FITS file.
 ***************************************************************************/
void GCOSSpaceCraft::write_livetimes(GFits& fits) const
{
    // Determine number of livetimes
    int num = m_livetimes.size();
 
    // Continue only if there are lifetimes
    if (num > 0) {
 
        // Allocate FITS binary table
        GFitsBinTable table;
 
        // Allocate column for livetimes table
        GFitsTableDoubleCol col_livetime("LIVETIME", num);
 
        // Set units of column
        // (see http://fits.gsfc.nasa.gov/standard30/fits_standard30aa.pdf)
        col_livetime.unit("s");
 
        // Fill column
        for (int i = 0; i < num; ++i) {
            col_livetime(i)  = m_livetimes[i];
        }
 
        // Append column to table
        table.append(col_livetime);
 
        // Set extension name
        table.extname("LIVETIMES");
 
        // Write ontime, livetime and deadtime correction factor
        table.card("ONTIME",   m_ontime,   "[s] Ontime");
        table.card("LIVETIME", m_livetime, "[s] Deadtime");
        table.card("DEADC",    m_deadc,    "Deadtime correction factor");
 
        // Append table to FITS file
        fits.append(table);
 
    } // endif: there were lifetimes
 
    // Return
    return;
}