Peak1D.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski, B. Rosse & Christian Finck   *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   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 2 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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef Gw_Peak1D
#define Gw_Peak1D

#include "GwLogMessage.h"
#include "BasePeak.h"

#include "Rtypes.h"
#include "TPolyLine.h"
#include "TVector2.h"
#include "TList.h"
#include "TGraph.h"
#include "NDB.h"

class TF1;
class TH1;
class TMarker;

namespace Gw {

class Peak1D : public BasePeak {

public:
        enum EDrawAs { kPeak, kGate };
  
public:
        static Color_t GetDefaultMarkerColor()     
                { return fgMarkerColor; } 
        static Color_t GetDefaultFuncColor()       
                { return fgFuncColor; }   
        static void    SetDefaultMarkerColor(Color_t c)     
                { fgMarkerColor = c; }
        static void    SetDefaultFuncColor(Color_t c)       
                { fgFuncColor = c; } 

public:
        Peak1D();
        Peak1D(const char* name, const char* title);
        Peak1D(TPolyLine* polyline);
    Peak1D(const Peak1D& p);
        virtual ~Peak1D();

        // Peak1D& operator=(const Peak1D& p);
    // Root copy, copy this to o
    virtual void Copy(TObject &o) const;

// Actions : Area, Fit  
        virtual void Fit(TH1 *histo, Option_t* optFit = "RN", Option_t* optBkg = "pol1"); 
        
        virtual void FitCombined(TH1 *histo, TList* peakList, Option_t* optFit = "RN", Option_t* optBkg = "pol1"); 
        
        void FitMenu(const char* nameFunc = "gaus", Option_t* optFit = "RN", Option_t* optBkg = "pol1"); //*MENU*

    virtual void Print(Option_t* opt ="f") const; //*MENU*


        virtual void Area(Option_t *opt = "h"); //*MENU*
        
// Set/Get methods 
        void SetPeak(Double_t pos,  Double_t height,  Double_t fwhm, Double_t intensity=0); //*MENU={Hierarchy="SetPeak/All"}*
        void SetPeakFromFit(); 
        void SetHeight(const Double_t height);       // *MENU={Hierarchy="SetPeak/Height"}* *GETTER=GetHeight
        void SetIntensity(const Double_t intensity); 
        virtual void SetPosition(const Double_t position, Option_t* axis = "X");  // *MENU={Hierarchy="SetPeak/Position"}* *GETTER=GetPosition  
        virtual void SetFWHM(const Double_t FWHM, Option_t* axis = "X");          // *MENU={Hierarchy="SetPeak/FWHM"}* *GETTER=GetFWHM
        void SetBackground(Double_t bgLeft1, Double_t bgLeft2, Double_t bgRight1,Double_t bgRight2,
                                                         Double_t bgLevelLeft1, Double_t bgLevelLeft2, Double_t bgLevelRight1,Double_t bgLevelRight2); 
        // void SetBackground( Double_t bgLeft1, Double_t bgLeft2, Double_t bgRight1, Double_t bgRight2, const TVirtualPad *pad = 0x0); 
        void SetBackground( Double_t bgLeft1, Double_t bgLeft2, Double_t bgRight1, Double_t bgRight2, const TH1* ); 
        void SetMarkerColor(Int_t color);

        virtual Double_t GetPosition(Option_t* axis = "X") const;
        virtual Double_t GetFWHM(Option_t* axis = "X") const;
    virtual TF1 *SetSignalFunction(const char* nameFunc = "gaus", TH1 *h=0x0);
        virtual TF1 *SetSignalFunction(const TF1* func); 
        virtual TF1 *SignalFunction()
                { return fSigFunc; }
    virtual TF1 *PeakFunction()
        { return fPeakFunc; }
        virtual TF1 *SetBkgFunction(const char* nameFunc = "-"); 
        virtual TF1 *SetBkgFunction(const TF1* func); 
        virtual TF1 *BkgFunction()
                { return fBkgFunc; }    
        virtual TF1 *SignalAndBkgFunction();

    double Landau(double*xx,double*pp);
    double Gaus(double*xx,double*pp);
    double DoubleSidedCrystalBallFct(double*xx,double*pp);
    double DoubleTailedGaussian(double*xx,double*pp);
    double DoubleTailedStepedGaussian(double*xx,double*pp);

    TF1 *ExtractBkgFromDTGStep(TString Name);

        void WithBkg(Bool_t with_bg = true); //*TOGGLE* *GETTER=IsWithBkg
        
        Bool_t IsWithBkg() const  
                { return fBkgFlag; }
        
    virtual void SetBinWidth(Double_t width) {fBinWidth = width;}
    virtual Double_t GetBinWidth() {return fBinWidth;}

        virtual void    SetFillColorPeak(Color_t color);
        virtual void    SetFillStylePeak(Style_t style);  
        virtual void    SetLineColorPeak(Color_t color); 
        virtual void    SetLineWidthPeak(Width_t width); 
        
        virtual void    SetFillColorBkg(Color_t color);
        virtual void    SetFillStyleBkg(Style_t style);  
        virtual void    SetLineColorBkg(Color_t color);  
        virtual void    SetLineWidthBkg(Width_t width); 
        
        virtual Color_t GetLineColorPeak();
        
        virtual TMarker* GetMarker(Int_t markerId);
        
        virtual TF1* GetSigFunction() 
                {return fSigFunc;}
        
        virtual void SetDrawAs(EDrawAs d);
        virtual EDrawAs GetDrawAs() const
                { return fDrawAs; }
        virtual void SetDrawOption(Option_t* option = ""); //*MENU*
        
        virtual Bool_t  IsSortable() const 
                {return kTRUE;}
        virtual Int_t Compare(const TObject *obj) const;

        Double_t GetBase() const 
                { return fPolyLinePeak.GetY()[0]; }

        const TVector2 GetBkgLeft()  const
                { return TVector2(fBkgLeft1,  fBkgLeft2); }
        const TVector2 GetBkgRight() const
                { return TVector2(fBkgRight1, fBkgRight2); } 
        
        Short_t IsPointInBkg(Double_t x, Double_t /*y*/ = 0)
        {
                if ( x < fBkgLeft1 || x > fBkgRight2 )
                        return 2;
                if ( x <= fBkgLeft2 || x >= fBkgRight1 )
                        return 1;
                return 0;
        }
         
   Double_t GetBkgIntegral()     const { return fBkgIntegral;}

   Double_t GetPeakIntegral()    const { return fPeakIntegral;}
   Double_t GetPeakIntegralError()    const { return fPeakIntegralError;}
   void SetPeakIntegralError(Double_t IntErr) { fPeakIntegralError = IntErr;}

   Double_t GetSubPeakIntegral() const { return fSubPeakIntegral;}
   
// Draw/Paint methods

        virtual void Paint(Option_t* opt ="");
        virtual void Draw(Option_t* opt = "");
    virtual void Browse(TBrowser * /*b*/)
    {
        Peak1D::Draw();
    }
        virtual void PaintFor(Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax);
    
        virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);

        virtual Int_t   DistancetoPrimitive(Int_t px, Int_t py);

        Double_t SignalAndBkg(Double_t* x, Double_t* par);
        Double_t Bkg(Double_t* x, Double_t* par);
        
private:
        void SetPeakPoints();

        void SetPeakPoints(TPolyLine* polyline);

        void SetBkgPoints();

        void UpdatePeak();

        void UpdateBkg();
        
        void SetModified(TPolyLine &p, Bool_t modif = true);
        Bool_t IsModified(TPolyLine &p);

        void InitPeakMarkers();
        void ShiftPolyline(TPolyLine &, Double_t, Double_t);
        void SetAllPointsinPolyline(TPolyLine &, Double_t x = 0.0, Double_t y = 0.0);

        void FitIsWithBkg(TH1* h, Option_t* optFit);

private:
        // peak's definition
        Double_t fPosition;     // Position of the Peak in energy
        Double_t fFWHM;         // FWHM of the Peak
        
        Double_t fBkgLeft1;     // lower limit for left side background
        Double_t fBkgLeft2;     // upper limit for left side background
        Double_t fBkgRight1;    // lower limit for right side background
        Double_t fBkgRight2;    // upper limit for right side background
        Double_t fBkgLevelLeft1;     // level lower limit for left side background
        Double_t fBkgLevelLeft2;     // level upper limit for left side background
        Double_t fBkgLevelRight1;    // level lower limit for right side background
        Double_t fBkgLevelRight2;    // level upper limit for right side background
    Double_t fBkgIntegral;       // Total counts in background
    Double_t fPeakIntegral;      // Total counts in peak (bg substracted)
    Double_t fPeakIntegralError;
    Double_t fSubPeakIntegral;   // Integral of background under peak
  
        Bool_t   fBkgFlag;      // flag w/o background
        
protected:

    Double_t fBinWidth;

        // peak's display
        TPolyLine  fPolyLinePeak;   // pointer to polyline peak
        TPolyLine  fPolyLineBkgL;   // pointer to polyline left background
        TPolyLine  fPolyLineBkgR;   // pointer to polyline right background
        
        TPolyLine*  fCPolyline;      
        TPolyLine   fCopyPolyline;   
        
        TList       fMarkerList;          // list of different markers 
    EDrawAs     fDrawAs;          // flag for drawing polyline as gate ot peak

public:

    bool        IsDrawAs(EDrawAs mode){if(fDrawAs == mode) return true; else return false;}

        // peak's fit
        TF1*        fSigFunc;    // pointer to signal function
        TF1*        fBkgFunc;    // pointer to bkg function
        TF1*        fPeakFunc;   
    TF1*        fFitCombined;   
        
protected:
        static const Int_t fgkPointsPeak;     // nb of polyline points for the peak
        static const Int_t fgkPointsBkg;      // nb of polyline points for background
        static const Int_t fgkPeakIdx;        // index of the peak central point

        static Color_t     fgLineColorPeak[]; // default line color for peak
        static Style_t     fgFillStylePeak;   // default fill style for peak
        static Color_t     fgLineColorBkg;    // default line color for background
        static Style_t     fgFillStyleBkg;    // default fill style for background
        static Color_t     fgMarkerColor;     // default marker color
        static Color_t     fgFuncColor;       // default function color


protected:
    bool fIsAGammaSourceRay;
    GammaSourceRay *fGammaSourceRay;

public:
    bool IsAGammaSourceRay() {return fIsAGammaSourceRay;}
    GammaSourceRay *GetGammaSourceRay() {return fGammaSourceRay;}
    void SetGammaSourceRay(GammaSourceRay *gsr) { fIsAGammaSourceRay = true; fGammaSourceRay = gsr;}

protected:
        mutable LogMessage fLog; 

private:
    TGraph *fEfficiencyGraph;
    TF1 *fEfficiencyFunc;
    Float_t fRefArea;
    Float_t fRefAreaError;
    Float_t fEffRelError; //Relative error on afficiency curves
public:
    void SetEfficiencyGraph(TGraph *gr, Float_t EffRelError = 0.1){fEfficiencyGraph = gr; fRefArea = 1; fRefAreaError = 0.;fEffRelError = EffRelError;}
    void SetEfficiencyFunc(TF1 *f, Float_t EffRelError = 0.1){fEfficiencyFunc = f; fRefArea = 1; fRefAreaError = 0.;fEffRelError = EffRelError;}
    void SetRefArea(Float_t a, Float_t ea){fRefArea = a; fRefAreaError = ea;}

public:
    ClassDef(Peak1D,5) // A 1D Peak
};

}
#endif