GammaLib

/***************************************************************************

 *       GOnOffFitter.hpp - Abstract ON-OFF analysis fitter class          *

 * ----------------------------------------------------------------------- *

 *  copyright (C) 2009-2013 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 GOnOffFitter.hpp

 * @brief Abstract ON-OFF analysis fitter class interface definition

 * @author Pierrick Martin

 */

#ifndef GONOFFFITTER_HPP

#define GONOFFFITTER_HPP

/* __ Includes ___________________________________________________________ */

#include <string>

#include <vector>

#include "GBase.hpp"

#include "GObservations.hpp"

#include "GOnOffMaker.hpp"

#include "GOptimizer.hpp"

#include "GOptimizerFunction.hpp"

/***********************************************************************//**

* @class GOnOffFitter

*

* @brief Abstract ON-OFF analysis fitter class

*

* This class implements the interface for an ON-OFF analysis in the way 

* adopted by existing Cherenkov telescopes such as HESS/VERITAS/MAGIC.

* 

* It prepares ON and OFF data through the GOnOffMaker class for different

* background evaluation methods. The result is stored in the form of arrays

* of GOnOffBin elements (spectra or maps or cubes). The observed number of

* excess counts is obtained either through simple arithmetics or through

* obtained by proper rescaling from an expected number of counts for a 

* given input source spectrum.

*

* The fit parameters can be accessed through operator[...] in a way 

* similar to the implementation of GModel. Not sure it is desirable 

* since we may have lots of expected numbers of hadrons and gammas

* to be fitted and it may not be relevant to have access to these.

*

* Also to be clarified:

* - Do we need a complete model=spatial*spectral*temporal here ?

* - Do we fix the background maker type in each derived GOnOffFitter class ?

* - In which format do we output some results (like significance) ?

* - Do we want a pointer to the GOnOffBin array as a member of this class ?

* - What about housekeeping of the parameter array ?

*

***************************************************************************/

class GOnOffFitter : public GBase {

public:

    // Constructors and destructors

    GOnOffFitter(void);

    GOnOffFitter(const GOnOffFitter& onoff);

        explicit GOnOffFitter(const std::string& filename, const GOnOffMaker& maker);

        explicit GOnOffFitter(const GObservations& obs, const GOnOffMaker& maker);

    virtual ~GOnOffFitter(void);

    // Operators

    virtual GOnOffFitter&       operator=(const GOnOffFitter& onoff);

        virtual GModelPar&          operator[](const int& index);

    virtual const GModelPar&    operator[](const int& index) const;

    virtual GModelPar&          operator[](const std::string& name);

    virtual const GModelPar&    operator[](const std::string& name) const;

    // Pure virtual methods

    virtual void                clear(void) = 0;

    virtual GOnOffFitter*       clone(void) const = 0;

    virtual int                 size(void) const = 0;

        virtual std::string         type(void) const = 0;

    virtual std::string         print(const GChatter& chatter = NORMAL) const = 0;

        virtual void                optimize(GOptimizer& opt) = 0;

        // Implemented methods

        GObservations*              obs(void) const;

        void                        obs(const GObservations& obs);

        void                        obs(const std::string& filename);

        GOnOffMaker*                maker(void) const;

        void                        maker(const GOnOffMaker& maker);

    // Optimizer

    class optimizer : public GOptimizerFunction {

    public:

        // Constructors and destructors

        optimizer(void);

        optimizer(GOnOffFitter* onoff);

        optimizer(const optimizer& fct);

        ~optimizer(void);

        // Operators

        optimizer& operator=(const optimizer& fct);

        // Implemented pure virtual base class methods

        double         value(void);

        double         npred(void) const;

        GVector*       gradient(void);

        GMatrixSparse* covar(void);

        // Other methods

        void set(GOnOffFitter* obs);

        void eval(const GOptimizerPars& pars);

                void poisson_binned(const GObservation&   obs,

                            const GOptimizerPars& pars);

    protected:

        // Protected methods

        void           init_members(void);

        void           copy_members(const optimizer& fct);

        void           free_members(void);

        // Protected data members

        double         m_value;       //!< Function value

        double         m_npred;       //!< Total number of predicted events

        double         m_minmod;      //!< Minimum model value

        double         m_minerr;      //!< Minimum error value

        GVector*       m_gradient;    //!< Pointer to gradient vector

        GMatrixSparse* m_covar;       //!< Pointer to covariance matrix

        GVector*       m_wrk_grad;    //!< Pointer to working gradient vector

        GOnOffFitter*  m_this;        //!< Pointer to GOnOffFitter object

    };

    // Optimizer access method

    const GOnOffFitter::optimizer& function(void) const;

protected:

    // Protected methods

    void init_members(void);

    void copy_members(const GOnOffFitter& obs);

    void free_members(void);

    // Protected members

    GObservations*               m_obs;        //!< Container of observations

    GOnOffFitter::optimizer*     m_fct;        //!< Optimizer function

        GOnOffMaker*                 m_maker;      //!< Background maker containing ON-OFF data

        std::vector<GModelPar*>      m_pars;       //!< Parameter pointers

};

#endif /* GONOFFFITTER_HPP */