#ifndef _Q_TRUNCATED_FIT_HH_
#define _Q_TRUNCATED_FIT_HH_

/**
 * @file QTruncatedFit.hh
 * @class QTruncatedFit
 * @ingroup nucleustools
 * @brief Class for performing the truncated fit for NUCLEUS EVENTS
 * @author Giorgio Del Castello
 *
 *  Put here an extensive description of what your<br/>
 *  class stores.
 */

#include "QObject.hh"
#include "QBaseType.hh"
#include "QPulse.hh"
#include "QVector.hh"
//#include <TVirtualFitter.h>
#include <Math/Minimizer.h>
#include "Math/Functor.h"

using namespace Diana;

class QTruncatedFit : public Diana::QObject {

    public:
       /** @brief clear members */
       void Clear(){
            TMaxIndex=-1;
            Template_manip.Initialize(0);
            
            BufferClear();
       }
       void BufferClear(){
            fAmpl=0;
            fJitter=0;
            fOffset=0;
            fTrunc=0;
            RMS=0;
            n_freedom=0;
            
            PBaseline=0;
            Pulse_manip.Initialize(0);
            
            amp_exp=0;
            t_exp=0;
            fFittedPulse.Initialize(0);
       }

        QTruncatedFit();
        
        QTruncatedFit(const QVector& Template , QDouble Threshold);
        
        void Initialize(const QVector& Template , QDouble Threshold);
        
        QDouble GetJitter() const {return fJitter; }
        
        QDouble GetAmplitude() const {return fAmpl; }
        
        QDouble GetRMS() const {return RMS; }
        
        QDouble GetThreshold() const {return *fThreshold;}
        
        QDouble GetTruncationLevel() const {return fTrunc;}
        
        QDouble GetOffset() const {return fOffset;}
        
        const QVector& GetFittedPulse() const {return fFittedPulse;}
        
        const QVector& GetTemplate() const {return *fTemplate;}
        
        QVector NormalizeTemplate(const Diana::QVector& vec);
        
        static double RMSCalc(const double *par);
        
        QError Fit(const QPulse& Pulse, const int& pulse_trigger_position);

    private:
        static const QVector* fPulse;
        
        static const QVector* fTemplate;
        
        static const QDouble* fThreshold; //linearity threshold of the pulse
        
        
        ROOT::Math::Minimizer * fitter;

        static const ROOT::Math::Functor* FitFunc;
        
        
        QDouble fAmpl;
        QDouble fJitter;
        QDouble RMS;
        QDouble fOffset;
        QDouble fTrunc;
        
        int n_freedom;
        
        int TMaxIndex;
        
        QVector Template_manip;
        
        QVector Pulse_manip;
        
        double amp_exp;
        double t_exp;
        double PBaseline;
        
        
        QVector fFittedPulse;
        
        QObjectDef(QTruncatedFit,4);

};

#endif