GCondition.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2010 by Olivier Stezowski                               *
 *   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_GCondition
#define Gw_GCondition


#include "TNamed.h"
#include "TObjArray.h"

#include <vector>
#include <utility>

class TCut;
class TCutG;

namespace Gw {

class Peak1D;
class PeakCreator;


class GCondition : public TNamed 
{
public:
        static const Style_t gCoincStyle = 3004;
        static const Style_t gAnticStyle = 3005;
        
protected:
        TObjArray fListOfConditions; // list of TCut or TGCut
        
protected:
        Bool_t fEnable;         // switch on/off the cut
        Bool_t fExpectedResult; // used for coincidence/anti coincidence treatment
        //
        mutable Bool_t fHasPassed;                  // true if last test has been passed
        mutable std::vector<Bool_t> fHasPassed_;    // individual gate
        
public: 
        GCondition();
        GCondition(const char * name, const char * title);
    GCondition(const GCondition& p);
        virtual ~GCondition();
    
    const TObjArray &GetListOfConditions()
    {
        return fListOfConditions;
    }
    
    // Root copy this to object
    virtual void Copy(TObject &o) const
    {
        ((GCondition &)o) = (*this);
    }
        
        virtual void SetVarName(const Char_t * /*var_name*/, const Char_t * /*which_var*/ = "X")
                {;}
        
        virtual void Browse(TBrowser* /*b*/) 
        {
                Draw();
        }
        
        virtual void Delete(Option_t* option = ""); //*MENU*
    
        virtual Bool_t IsPassed(Double_t, Double_t = 0.0) const
        {
                return !fExpectedResult;
        }
        
        virtual Bool_t HasPassed() const
        {
                return fHasPassed;
        }
        virtual Bool_t HasPassed(UInt_t i) const
        {
                if ( i < fHasPassed_.size() )
                        return fHasPassed_[i];
                
                return false;
        }
        
        virtual void Enable();  //*TOGGLE* *GETTER=IsEnable
        virtual Bool_t IsEnable() const
    {
        return fEnable;
    }
        virtual void UseAsAnti(Bool_t r = false);  //*TOGGLE* *GETTER=IsAnti
        virtual Bool_t IsAnti() const
        { 
                return fExpectedResult == false; 
        } 
        
        
        virtual Short_t Import(const char * /*what*/ = "*", const char * /*from*/ = "gpad", Option_t * /*opt*/ = "+") 
        {
                return 0;
        }
        
        virtual Short_t Export(const char * /*what*/ = "*", const char * /*to*/ = "MyCuts", Option_t * /*opt*/ = "") const
        {
                return 0;
        }
        
    virtual void        Print(Option_t* option = "") const; //*MENU*
    
        ClassDef(GCondition,1)  // a graphical cut (1d,2d)
};      


class GCond1D : public GCondition
{
private:
        TString fVarX;
        
protected:
    // methods to convert peak to/from TCut
        TCut *PeakToCut(const Gw::Peak1D *) const;
    Gw::Peak1D * CutToPeak(TCut *);
    
public:
    // static method to convert a cut to a gate (gw::peak). Peak name is cut name while title is the variable on which this cut applys
    static Gw::Peak1D *TCutToPeak(TCut *);
   
public:
        GCond1D();
        GCond1D(const char * name, const char * title);
    GCond1D(const GCond1D &p);
        virtual ~GCond1D();
        
    // Root copy, this to o
    virtual void Copy(TObject &o) const
    {
        ((GCond1D &)o) = (*this);
    }
    
        virtual void SetVarName(const Char_t * var_name, const Char_t * /*which_var*/ = "X")
        {
                fVarX = var_name;
        }

        void Draw(Option_t* option = "");

        virtual void UseAsAnti(Bool_t r = false);  //*TOGGLE* *GETTER=IsAnti
        
        Gw::Peak1D *AddWindow(Double_t, Double_t, Option_t *opt = "+"); //*MENU*

        virtual Bool_t IsPassed(Double_t, Double_t  = 0.0) const;
        

        virtual Short_t Import(const char *what = "*", const char *from = "gpad", Option_t *opt = "+"); //*MENU*
        

        virtual Short_t Export(const char *what = "*", const char *to = "MyCuts", Option_t *opt = "") const; //*MENU*

        
        Gw::PeakCreator *WindowGCreator(const char *c_name = ""); //*MENU*
        
        ClassDef(GCond1D,1)  // a graphical cut 1d
        
};
                

class GCond2D : public GCondition
{
private:
        TString fVarX;
        TString fVarY;
        
public:
        GCond2D();
        GCond2D(const char * name, const char * title);
    GCond2D(const GCond2D &p);
        virtual ~GCond2D();
    
    // Root copy
    virtual void Copy(TObject &o) const
    {
        ((GCond2D &)o) = (*this);
    }
    
        void Draw(Option_t* option = "");

        virtual void SetVarName(const Char_t * var_name, const Char_t * which_var = "X")
        {
                TString which(which_var); 
                if ( which == "X" )
                        fVarX = var_name;
                if ( which == "Y" )
                        fVarY = var_name;
        }
        
        TCutG *AddWindow(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax, Option_t *opt = "+"); //*MENU*
        
        virtual Bool_t IsPassed(Double_t, Double_t) const;


        virtual Short_t Import(const char *what = "*", const char *from = "gpad", Option_t *opt = "+"); //*MENU*

        virtual Short_t Export(const char *what = "*", const char *to = "MyCuts", Option_t *opt = "") const; //*MENU*

        virtual void WindowGCreator(const char *c_name = ""); //*MENU*

        
        ClassDef(GCond2D,1)  // a graphical cut 2d
        
};
        
        

class GCondHandler
{
protected:
        GCondition *fCond;
public:
        GCondHandler(GCondition *cond) : fCond(cond) 
                {;}
        virtual ~GCondHandler()
                {;}             
        
        GCondition *GetGCondition()
        {
                return fCond;
        }
        
        virtual Bool_t Check()
        {
                return false;
        }
        virtual void Fill()
        {
                ;
        }
};

        
} // namespace

#endif