GBounds.hpp

Go to the documentation of this file.

/***************************************************************************
 *                     GBounds.hpp - Boundaries 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 GBounds.hpp
 * @brief Boundaries class interface definition
 * @author Juergen Knoedlseder
 */
 
#ifndef GBOUNDS_HPP
#define GBOUNDS_HPP
 
/* __ Includes ___________________________________________________________ */
#include <string>
#include <vector>
#include "GContainer.hpp"
#include "GEnergy.hpp"
 
/* __ Forward declarations _______________________________________________ */
class GFits;
class GFitsTable;
class GFilename;
 
/* __ Constants __________________________________________________________ */
namespace gammalib {
    const std::string extname_bounds = "BOUNDS";
}
 
 
/***********************************************************************//**
 * @class GBounds
 *
 * @brief Boundaries container class
 *
 * This class holds a list of intervals which are each defined by a minimum
 * and a maximum value. Intervals may be continuous or not and overlapping or
 * not. The order of the intervals is not managed by the class, they will
 * be stored as provided. An interval is defined by a minimum and maximum
 * value. By definition, the minimum value is included in the interval, the
 * maximum value is excluded.
 ***************************************************************************/
class GBounds : public GContainer {
 
    // Operator friends
    friend bool operator==(const GBounds& a, const GBounds& b);
    friend bool operator!=(const GBounds& a, const GBounds& b);
 
public:
    // Constructors and destructors
    GBounds(void);
    explicit GBounds(const GFilename& filename);
    explicit GBounds(const std::vector<double>& array, const std::string& unit = "");
    GBounds(const GBounds& bounds);
    GBounds(const double& min, const double& max, const std::string& unit = "");
    GBounds(const int&         num,
            const double&      min,
            const double&      max,
            const std::string& method,
            const std::string& unit   = "",
            const double&      gamma  = 1.0);
    virtual ~GBounds(void);
 
    // Operators
    GBounds& operator=(const GBounds& bounds);
 
    // Methods
    void               clear(void);
    GBounds*           clone(void) const;
    std::string        classname(void) const;
    int                size(void) const;
    bool               is_empty(void) const;
    const std::string& unit(void) const;
    void               unit(const std::string& unit);
    void               append(const double& min, const double& max);
    void               insert(const double& min, const double& max);
    void               remove(const int& index);
    void               reserve(const int& num);
    void               extend(const GBounds& bounds);
    void               set(const std::vector<double>& array);
    void               set(const int&         num,
                           const double&      min,
                           const double&      max,
                           const std::string& method,
                           const double&      gamma  = 1.0);
    void               load(const GFilename& filename);
    void               save(const GFilename& filename,
                            const bool& clobber = false) const;
    void               read(const GFitsTable& table);
    void               write(GFits& file,
                             const std::string& extname = gammalib::extname_bounds) const;
    int                index(const double& value) const;
    double             min(void) const;
    double             max(void) const;
    void               min(const int& index, const double& value);
    void               max(const int& index, const double& value);
    double             min(const int& index) const;
    double             max(const int& index) const;
    double             mean(const int& index) const;
    double             logmean(const int& index) const;
    double             width(const int& index) const;
    bool               contains(const double& value) const;
    bool               contains(const double& min, const double& max) const;
    std::string        print(const GChatter& chatter = NORMAL) const;
 
protected:
    // Protected methods
    void init_members(void);
    void copy_members(const GBounds& bounds);
    void free_members(void);
    void insert_interval(const int& index, const double& min, const double& max);
 
    // Protected data area
    std::string         m_unit; //!< Unit of values
    std::vector<double> m_min;  //!< Array of interval minimum values
    std::vector<double> m_max;  //!< Array of interval maximum values
};
 
 
/***********************************************************************//**
 * @brief Return class name
 *
 * @return String containing the class name ("GBounds").
 ***************************************************************************/
inline
std::string GBounds::classname(void) const
{
    return ("GBounds");
}
 
 
/***********************************************************************//**
 * @brief Return number of boundaries
 *
 * @return Number of boundaries.
 ***************************************************************************/
inline
int GBounds::size(void) const
{
    return (m_min.size());
}
 
 
/***********************************************************************//**
 * @brief Signal if there are no boundaries
 *
 * @return True if there are no boundaries.
 ***************************************************************************/
inline
bool GBounds::is_empty(void) const
{
    return (m_min.empty());
}
 
 
/***********************************************************************//**
 * @brief Return boundary units.
 *
 * @return Boundary units.
 ***************************************************************************/
inline
const std::string& GBounds::unit(void) const
{
    return (m_unit);
}
 
 
/***********************************************************************//**
 * @brief Set boundary units.
 *
 * @return unit Boundary units.
 ***************************************************************************/
inline
void GBounds::unit(const std::string& unit)
{
    m_unit = unit;
    return;
}
 
 
/***********************************************************************//**
 * @brief Boundaries inequality operator friend
 *
 * @param[in] a First boundaries.
 * @param[in] b Second boundaries.
 * @return True if both boundaries are different.
 ***************************************************************************/
inline
bool operator!=(const GBounds& a, const GBounds& b)
{
    return (!(a == b));
}
 
#endif /* GBOUNDS_HPP */