cterror.cpp

Go to the documentation of this file.

/***************************************************************************
 *                 cterror - Parameter error calculation tool              *
 * ----------------------------------------------------------------------- *
 *  copyright (C) 2015-2024 by Florent Forest                              *
 * ----------------------------------------------------------------------- *
 *                                                                         *
 *  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 cterror.cpp
 * @brief Parameter error calculation tool interface implementation
 * @author Florent Forest
 */
 
/* __ Includes ___________________________________________________________ */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <iostream>
#include "cterror.hpp"
#include "GTools.hpp"
#include "GOptimizer.hpp"
 
/* __ OpenMP section _____________________________________________________ */
#ifdef _OPENMP
#include <omp.h>
#endif
 
/* __ Method name definitions ____________________________________________ */
#define G_ERR_BISECTION          "cterror::error_bisection(double&, double&)"
 
/* __ Debug definitions __________________________________________________ */
 
/* __ Coding definitions _________________________________________________ */
 
 
/*==========================================================================
 =                                                                         =
 =                        Constructors/destructors                         =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Void constructor
 *
 * Constructs an empty cterror tool.
 ***************************************************************************/
cterror::cterror(void) : ctlikelihood(CTERROR_NAME, VERSION)
{
    // Initialise members
    init_members();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Observations constructor
 *
 * param[in] obs Observation container.
 *
 * Constructs cterror tool from an observations container.
 ***************************************************************************/
cterror::cterror(const GObservations& obs) :
         ctlikelihood(CTERROR_NAME, VERSION, obs)
{
    // Initialise members
    init_members();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Command line constructor
 *
 * @param[in] argc Number of arguments in command line.
 * @param[in] argv Array of command line arguments.
 *
 * Constructs an instance of the cterror tool that will parse user
 * parameters that are provided as command line arguments.
 ***************************************************************************/
cterror::cterror(int argc, char *argv[]) :
         ctlikelihood(CTERROR_NAME, VERSION, argc, argv)
{
    // Initialise members
    init_members();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Copy constructor
 *
 * @param[in] app Application.
 *
 * Constructs an instance of the cterror tool by copying information from
 * another ctulimit tool.
 ***************************************************************************/
cterror::cterror(const cterror& app) : ctlikelihood(app)
{
    // Initialise members
    init_members();
 
    // Copy members
    copy_members(app);
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Destructor
 *
 * Destructs the cterror tool.
 ***************************************************************************/
cterror::~cterror(void)
{
    // Free members
    free_members();
 
    // Return
    return;
}
 
 
/*==========================================================================
 =                                                                         =
 =                               Operators                                 =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Assignment operator
 *
 * @param[in] app Application.
 * @return Application.
 *
 * Assigns a cterror tool.
 ***************************************************************************/
cterror& cterror::operator=(const cterror& app)
{
    // Execute only if object is not identical
    if (this != &app) {
 
        // Copy base class members
        this->ctlikelihood::operator=(app);
 
        // Free members
        free_members();
 
        // Initialise members
        init_members();
 
        // Copy members
        copy_members(app);
 
    } // endif: object was not identical
 
    // Return this object
    return *this;
}
 
 
/*==========================================================================
 =                                                                         =
 =                            Public methods                               =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Clear cterror tool
 *
 * Clears cterror tool.
 ***************************************************************************/
void cterror::clear(void)
{
    // Free members
    free_members();
    this->ctlikelihood::free_members();
    this->ctobservation::free_members();
    this->ctool::free_members();
 
    // Clear base class (needed to conserve tool name and version)
    this->GApplication::clear();
 
    // Initialise members
    this->ctool::init_members();
    this->ctobservation::init_members();
    this->ctlikelihood::init_members();
    init_members();
 
    // Write header into logger
    log_header();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Compute parameter errors using a likelihood profile method
 *
 * Computes the parameter errors using a likelihood profile method.
 ***************************************************************************/
void cterror::process(void)
{
    // Get task parameters
    get_parameters();
 
    // Set energy dispersion flags of all CTA observations and save old
    // values in save_edisp vector
    std::vector<bool> save_edisp = set_edisp(m_obs, m_apply_edisp);
 
    // Write input observation container into logger
    log_observations(NORMAL, m_obs, "Input observation");
 
    // Write header into logger
    log_header1(TERSE, "Compute best-fit likelihood");
 
    // Optimize and save best log-likelihood
    m_obs.optimize(m_opt);
    m_obs.errors(m_opt);
    m_best_logL = m_obs.logL();
 
    // Store optimizer for later recovery
    GOptimizerLM best_opt = m_opt;
 
    // Initialise intensity vectors
    update_intensities();
 
    // Write optimisation results and models into logger
    log_string(NORMAL, m_opt.print(m_chatter));
    log_value(NORMAL, "Maximum log likelihood", gammalib::str(m_best_logL,3));
    log_string(NORMAL, m_obs.models().print(m_chatter));
 
    // Save best fitting models
    GModels models_best = m_obs.models();
 
    // Get pointer on model
    GModel* model = models_best[m_srcname];
 
    // Get number of parameters
    int npars = model->size();
 
    // Loop over parameters of sky model
    for (int i = 0; i < npars; ++i) {
 
        // Skip parameter if it is fixed
        if (model->at(i).is_fixed()) {
            continue;
        }
 
        // Initialise with best fitting models
        m_obs.models(models_best);
 
        // Get pointer on model parameter
        GModels& current_models = const_cast<GModels&>(m_obs.models());
        m_model_par             = &(current_models[m_srcname]->at(i));
 
        // Extract current value
        m_value = m_model_par->factor_value();
 
        // Compute parameter bracketing
        double parmin = std::max(m_model_par->factor_min(),
                                 m_value - 10.0*m_model_par->factor_error());
        double parmax = std::min(m_model_par->factor_max(),
                                 m_value + 10.0*m_model_par->factor_error());
 
        // Write header and initial parameters into logger
        log_header1(TERSE, "Compute error for source \""+m_srcname+"\""
                           " parameter \""+m_model_par->name()+"\"");
        log_value(NORMAL, "Confidence level",
                  gammalib::str(m_confidence*100.0)+" %");
        log_value(NORMAL, "Log-likelihood difference", m_dlogL);
        log_value(NORMAL, "Initial factor range",
                  "["+gammalib::str(parmin)+", "+gammalib::str(parmax)+"]");
 
        // Compute lower boundary, store best fitting model, and update intensities
        double  value_lo  = error_bisection(parmin, m_value);
        GModels models_lo = m_obs.models();
        update_intensities();
 
        // Compute upper boundaries, store best fitting model, and update intensities
        double  value_hi  = error_bisection(m_value, parmax);
        GModels models_hi = m_obs.models();
        update_intensities();
 
        // Compute errors
        double error           = 0.5 * (value_hi - value_lo);
        double error_neg       = m_value  - value_lo;
        double error_pos       = value_hi - m_value;
        double error_value     = std::abs(error*m_model_par->scale());
        double error_value_neg = std::abs(error_neg*m_model_par->scale());
        double error_value_pos = std::abs(error_pos*m_model_par->scale());
 
        // Write results into logger
        std::string unit = " " + m_model_par->unit();
        log_value(NORMAL, "Lower parameter factor", value_lo);
        log_value(NORMAL, "Upper parameter factor", value_hi);
        log_value(NORMAL, "Error from curvature",
                  gammalib::str(m_model_par->error()) + unit);
        log_value(NORMAL, "Error from profile",
                  gammalib::str(error_value) + unit);
        log_value(NORMAL, "Negative profile error",
                  gammalib::str(error_value_neg) + unit);
        log_value(NORMAL, "Positive profile error",
                  gammalib::str(error_value_pos) + unit);
 
        // Optionally write best lower boundary and upper boundary model
        // into logger
        log_header3(NORMAL, "Model at lower parameter value");
        log_string(NORMAL, models_lo[m_srcname]->print());
        log_header3(NORMAL, "Model at upper parameter value");
        log_string(NORMAL, models_hi[m_srcname]->print());
 
        // Save error result
        model->at(i).factor_error(error);
 
    } // endfor: looped over spectral parameters
 
    // Restore best fitting models (now with new errors computed)
    m_obs.models(models_best);
 
    // Recover optimizer
    m_opt = best_opt;
 
    // Restore energy dispersion flags of all CTA observations
    restore_edisp(m_obs, save_edisp);
 
    // Create FITS table
    create_fits();
 
    // Write header into logger
    log_header1(TERSE, "Butterfly");
 
    // Show results by converting from MeV to TeV
    for (int k = 0; k < m_energies.size(); ++k) {
 
        // Write message
        std::string key   = "Intensity at " +
                            gammalib::str(m_energies[k].TeV()) +
                            " TeV";
        std::string value = gammalib::str(m_intensities[k]*1.0e6) + " (" +
                            gammalib::str(m_min_intensities[k]*1.0e6) + ", " +
                            gammalib::str(m_max_intensities[k]*1.0e6) +
                            ") ph/cm2/s/TeV";
 
        // Write results into logger
        log_value(NORMAL, key, value);
 
    } // endfor: loop over energy bins
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Save model
 *
 * Saves the model into an XML file.
 ***************************************************************************/
void cterror::save(void)
{
    // Write header
    log_header1(TERSE, "Save results");
 
    // Save only if filename is valid
    if ((*this)["outmodel"].is_valid()) {
 
        // Get output filename
        GFilename outmodel = (*this)["outmodel"].filename();
 
        // Log filename
        log_value(NORMAL, "Model definition file", outmodel.url());
 
        // Write results out as XML model
        m_obs.models().save(outmodel.url());
 
    }
 
    // ... otherwise signal that file was not saved
    else {
        log_value(NORMAL, "Model definition file", "NONE");
    }
 
    // Save only if filename is valid
    if ((*this)["outfile"].is_valid()) {
 
        // Get output filename
        GFilename outfile = (*this)["outfile"].filename();
 
        // Log butterfly diagram file name
        log_value(NORMAL, "Butterfly file", outfile.url());
 
        // Save FITS table
        m_fits.saveto(outfile.url(), clobber());
 
    }
 
    // ... otherwise signal that file was not saved
    else {
        log_value(NORMAL, "Butterfly file", "NONE");
    }
 
    // Return
    return;
}
 
 
/*==========================================================================
 =                                                                         =
 =                             Private methods                             =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Initialise class members
 ***************************************************************************/
void cterror::init_members(void)
{
    // Initialise user parameters
    m_srcname.clear();
    m_confidence  = 0.68;
    m_tol         = 1.0e-3;
    m_max_iter    = 50;
    m_apply_edisp = false;
    m_chatter     = static_cast<GChatter>(2);
 
    // Initialise protected members
    m_value       = 0.0;
    m_dlogL       = 0.0;
    m_best_logL   = 0.0;
    m_model_par   = NULL;
 
    // Initialise protected members for butterfly
    m_energies.clear();
    m_intensities.clear();
    m_min_intensities.clear();
    m_max_intensities.clear();
    m_fits.clear();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Copy class members
 *
 * @param[in] app Application.
 ***************************************************************************/
void cterror::copy_members(const cterror& app)
{
    // Copy user parameters
    m_srcname     = app.m_srcname;
    m_confidence  = app.m_confidence;
    m_tol         = app.m_tol;
    m_max_iter    = app.m_max_iter;
    m_apply_edisp = app.m_apply_edisp;
    m_chatter     = app.m_chatter;
 
    // Copy protected members
    m_value     = app.m_value;
    m_dlogL     = app.m_dlogL;
    m_best_logL = app.m_best_logL;
    m_model_par = NULL;
 
    // Copy protected members for butterfly
    m_energies        = app.m_energies;
    m_intensities     = app.m_intensities;
    m_min_intensities = app.m_min_intensities;
    m_max_intensities = app.m_max_intensities;
    m_fits            = app.m_fits;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Delete class members
 ***************************************************************************/
void cterror::free_members(void)
{
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Get application parameters
 *
 * Get all task parameters from parameter file.
 ***************************************************************************/
void cterror::get_parameters(void)
{
    // Setup observations from "inobs" parameter
    setup_observations(m_obs);
 
    // Set observation statistic
    set_obs_statistic(gammalib::toupper((*this)["statistic"].string()));
 
    // Setup models from "inmodel" parameter
    setup_models(m_obs, (*this)["srcname"].string());
 
    // Get name of test source
    m_srcname = (*this)["srcname"].string();
 
    // Read energy dispersion flag
    m_apply_edisp = (*this)["edisp"].boolean();
 
    // Get confidence level and transform into log-likelihood difference
    m_confidence = (*this)["confidence"].real();
    double sigma = gammalib::erfinv(m_confidence) * gammalib::sqrt_two;
    m_dlogL      = (sigma*sigma) / 2.0;
 
    // Set optimizer characteristics from user parameters
    m_opt.eps((*this)["like_accuracy"].real());
    m_opt.max_iter((*this)["max_iter"].integer());
 
    // Read other parameters
    m_tol      = (*this)["tol"].real();
    m_max_iter = (*this)["max_iter"].integer();
    m_chatter  = static_cast<GChatter>((*this)["chatter"].integer());
 
    // Create energies from user parameters
    m_energies = create_energies();
 
    // If needed later, query output filename now
    if (read_ahead()) {
        (*this)["outmodel"].query();
        (*this)["outfile"].query();
    }
 
    // Set number of OpenMP threads
    #ifdef _OPENMP
    int nthreads = (*this)["nthreads"].integer();
    if (nthreads > 0) {
        omp_set_num_threads(nthreads);
    }
    #endif
 
    // Write parameters into logger
    log_parameters(TERSE);
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Calculate error using a bisection method
 *
 * @param[in] min Minimum parameter value
 * @param[in] max Maximum parameter value
 *
 * Calculates the error using a bisection method.
 ***************************************************************************/
double cterror::error_bisection(const double& min, const double& max)
{
    // Copy values to working values
    double wrk_min = min;
    double wrk_max = max;
 
    // Initialise iteration counter
    int iter = 1;
 
    // Initialize mid value
    double mid = (wrk_min + wrk_max) / 2.0;
 
    // Loop until breaking condition is reached
    while (true) {
 
        // Throw exception if maximum iterations are reached
        if (iter > m_max_iter) {
            if (wrk_min - m_model_par->factor_min() < m_tol) {
                std::string msg = "The \""+m_model_par->name()+"\" parameter "
                                  "minimum has been reached during error "
                                  "calculation. To obtain accurate errors, "
                                  "consider setting the minimum parameter "
                                  "value to a lower value, and re-run "
                                  "cterror.";
                log_string(TERSE, msg);
                break;
            }
            else if (m_model_par->factor_max() - wrk_max < m_tol) {
                std::string msg = "The \""+m_model_par->name()+"\" parameter "
                                  "maximum has been reached during error "
                                  "calculation. To obtain accurate errors, "
                                  "consider setting the maximum parameter "
                                  "value to a higher value, and re-run "
                                  "cterror.";
                log_string(TERSE, msg);
                break;
            }
            else {
                std::string msg = "The maximum number of "+
                                  gammalib::str(m_max_iter)+" iterations has "
                                  "been reached. Please increase the "
                                  "\"max_iter\" parameter, and re-run "
                                  "cterror.";
                throw GException::invalid_value(G_ERR_BISECTION, msg);
            }
        }
 
        // Compute center of boundary
        mid = (wrk_min + wrk_max) / 2.0;
 
        // Calculate function value
        double eval_mid = evaluate(*m_model_par, mid) - (m_best_logL + m_dlogL);
 
        // Write interval into logger
        log_value(EXPLICIT, "  Iteration "+gammalib::str(iter),
                  "["+gammalib::str(wrk_min)+", "+gammalib::str(wrk_max)+"]");
 
        // Check for convergence inside tolerance
        if (std::abs(eval_mid) < m_tol) {
            break;
        }
 
        // Check if interval is smaller than 1.0e-6
        if (std::abs(wrk_max-wrk_min) < 1.0e-6) {
            break;
        }
 
        // If we are on the crescent side of the parabola ...
        if (mid > m_value) {
 
            // Change boundaries for further iteration
            if (eval_mid > 0.0) {
                wrk_max = mid;
            }
            else if (eval_mid < 0.0) {
                wrk_min = mid;
            }
        }
 
        // ... otherwise we are on the decrescent side of the parabola
        else {
 
            // Change boundaries for further iteration
            if (eval_mid > 0.0) {
                wrk_min = mid;
            }
            else if (eval_mid < 0.0) {
                wrk_max = mid;
            }
        }
 
        // Increment counter
        iter++;
 
    } // endwhile
 
    // Return mid value
    return mid;
 
}
 
 
/***********************************************************************//**
 * @brief Update intensities
 *
 * Update the intensities using the current model in the observation
 * container. If the method is called with empty vectors, intensity vectors
 * are allocated.
 ***************************************************************************/
void cterror::update_intensities(void)
{
    // Determine mode
    bool set = (m_intensities.size() == 0);
 
    // If spectra are to be set then initialise intensities
    if (set) {
        m_intensities.assign(m_energies.size(), 0.0);
        m_min_intensities.assign(m_energies.size(), 0.0);
        m_max_intensities.assign(m_energies.size(), 0.0);
        log_header3(TERSE, "Initialise intensities for butterfly");
    }
 
    // Get source model as sky model
    const GModelSky* skymodel = dynamic_cast<const GModelSky*>(m_obs.models()[m_srcname]);
 
    // Continue only if model is a sky model
    if (skymodel != NULL) {
 
        // Get pointer to spectral model
        GModelSpectral* spectral = skymodel->spectral();
 
        // Loop over energies
        for (int i = 0; i < m_energies.size(); ++i) {
 
            // Get model value
            double value = spectral->eval(m_energies[i]);
 
            // Make sure that model is not negative
            if (value < 0.0) {
                value = 0.0;
            }
 
            // If intensities are to be set the set all intensity vectors
            if (set) {
                m_intensities[i]     = value;
                m_min_intensities[i] = value;
                m_max_intensities[i] = value;
            }
 
            // ... otherwise update intensity vectors
            else {
                if (value < m_min_intensities[i]) {
                    m_min_intensities[i] = value;
                }
                if (value > m_max_intensities[i]) {
                    m_max_intensities[i] = value;
                }
            }
 
        } // endfor: looped over energies
 
    } // endif: model was a sky model
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Set result FITS file
 *
 * Set the FITS file with the butterfly results.
 ***************************************************************************/
void cterror::create_fits(void)
{
    // Determine the number of energies
    int nrows = m_energies.size();
 
    // Allocate FITS table columns
    GFitsTableDoubleCol col_energy("ENERGY", nrows);
    GFitsTableDoubleCol col_intensity("INTENSITY", nrows);
    GFitsTableDoubleCol col_intensity_min("INTENSITY_MIN", nrows);
    GFitsTableDoubleCol col_intensity_max("INTENSITY_MAX", nrows);
 
    // Set units of columns
    col_energy.unit("TeV");
    col_intensity.unit("ph/cm2/s/TeV");
    col_intensity_min.unit("ph/cm2/s/TeV");
    col_intensity_max.unit("ph/cm2/s/TeV");
 
    // Fill columns and convert MeV units to TeV units
    for (int i = 0; i < nrows; ++i) {
        col_energy(i)        = m_energies[i].TeV();
        col_intensity(i)     = m_intensities[i]     * 1.0e6;
        col_intensity_min(i) = m_min_intensities[i] * 1.0e6;
        col_intensity_max(i) = m_max_intensities[i] * 1.0e6;
    }
 
    // Create binary table
    GFitsBinTable table;
    table.extname("BUTTERFLY");
 
    // Stamp header
    stamp(table);
 
    // Add keywords
    table.card("INSTRUME", "CTA",  "Name of Instrument");
    table.card("TELESCOP", "CTA",  "Name of Telescope");
 
    // Append columns to table
    table.append(col_energy);
    table.append(col_intensity);
    table.append(col_intensity_min);
    table.append(col_intensity_max);
 
    // Create the FITS file
    m_fits.clear();
    m_fits.append(table);
 
    // Return
    return;
}