PWG2/RESONANCES/AliRsnFunction.h

   1 //
   2 // Class AliRsn Fcn
   3 //
   4 // This class defines a base classe to implement a typical computation
   5 // which uses the internal RSN package event format (AliRsnEvent).
   6 // It contains some default flags which turn out to be useful:
   7 //  - a flag to select only the "true" pairs (tracks from same resonance)
   8 //  - a flag to know if the computation is done over two events (mixing)
   9 //
  10 // Any kind of analysis object should be implemented as inheriting from this
  11 // because the AliRsnAnalyzer which executes the analysis will accept a collection
  12 // of such objects, in order to have a unique format of processing method
  13 //
  14 // The user who implements a kind of computation type should inherit from
  15 // this class and override the virtual functions defined in it, which
  16 // initialize the final output histogram and define how to process data.
  17 //
  18 //
  19 // author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
  20 //
  21
  22 #ifndef ALIRSNFUNCTION_H
  23 #define ALIRSNFUNCTION_H
  24
  25 #include <TClonesArray.h>
  26 #include <TH1.h>
  27 #include <TH2.h>
  28 #include <TH3.h>
  29 #include <THnSparse.h>
  30 #include <TNamed.h>
  31
  32 #include "AliRsnCut.h"
  33
  34 class AliRsnValue;
  35 class AliRsnMother;
  36 class AliRsnPairDef;
  37
  38 class AliRsnFunction : public TObject {
  39
  40 public:
  41
  42    AliRsnFunction(Bool_t single = kFALSE, Bool_t useTH1 = kTRUE);
  43    AliRsnFunction(const AliRsnFunction &copy);
  44    virtual ~AliRsnFunction() { delete fH1; delete fHSparse; }
  45    const AliRsnFunction& operator=(const AliRsnFunction &copy);
  46
  47    void                 SetPairDef(AliRsnPairDef * const def)        {fPairDef = def;}
  48    void                 SetPair(AliRsnMother * const pair)           {fPair = pair;}
  49    void                 SetDaughter(AliRsnDaughter * const daughter) {fDaughter = daughter;}
  50
  51    AliRsnPairDef*       GetPairDef()  const {return fPairDef;}
  52    AliRsnMother*        GetPair()     const {return fPair;}
  53    AliRsnDaughter*      GetDaughter() const {return fDaughter;}
  54    AliRsnEvent*         GetEvent()    const {return fEvent;}
  55    virtual const char*  GetName()     const;
  56
  57    Bool_t               IsSingle() const             {return fSingle;}
  58    void                 SetSingle(Bool_t yn = kTRUE) {fSingle = yn;}
  59    Bool_t               IsUsingTH1()                 {return fUseTH1;}
  60    void                 UseTH1()                     {fUseTH1 = kTRUE;}
  61    void                 UseSparse()                  {fUseTH1 = kFALSE;}
  62
  63    Bool_t               AddAxis(AliRsnValue* const axis);
  64    Int_t                GetNumberOfAxes() {return fAxisList.GetEntries();}
  65
  66    TH1*                 CreateHistogram(const char *histoName, const char *histoTitle);
  67    THnSparseF*          CreateHistogramSparse(const char *histoName, const char *histoTitle);
  68
  69    Bool_t               Fill();
  70
  71 protected:
  72
  73    AliRsnPairDef      *fPairDef;     // reference to used pair definition
  74    TClonesArray        fAxisList;    // list of axis
  75
  76    AliRsnMother       *fPair;        // processed pair
  77    AliRsnEvent        *fEvent;       // processed event
  78    AliRsnDaughter     *fDaughter;    // processed track
  79
  80    Bool_t              fSingle;      // is kTRUE when function processes tracks instead of pairs
  81    Bool_t              fUseTH1;      // use TH1 or not?
  82    Int_t               fSize;        // number of dim of output histogram
  83    TH1                *fH1;          // output histogram (standard type)
  84    THnSparseF         *fHSparse;     // output histogram (sparse type)
  85
  86    // ROOT dictionary
  87    ClassDef(AliRsnFunction, 3)
  88 };
  89
  90 #endif