HBTAN/AliHBTPairCut.h

   1 #ifndef ALIHBTPAIRCUT_H
   2 #define ALIHBTPAIRCUT_H
   3
   4 /* $Id$ */
   5
   6 //Piotr Skowronski@cern.ch
   7 //Class implements cut on the pair of particles
   8 //
   9 //more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
  10
  11 #include "AliHBTPair.h"
  12
  13 class AliHBTParticleCut;
  14 class AliHbtBasePairCut;
  15
  16 enum AliHBTPairCutProperty
  17 {
  18   kHbtPairCutPropQInv, //Q invariant
  19   kHbtPairCutPropKt,
  20   kHbtPairCutPropKStar,
  21   kHbtPairCutPropQSideCMSLC,
  22   kHbtPairCutPropQOutCMSLC,
  23   kHbtPairCutPropQLongCMSLC,
  24   kHbtPairCutPropAvSepar,
  25   kHbtPairCutPropNone
  26 };
  27
  28 class AliHBTPairCut: public TNamed
  29 {
  30  public:
  31   AliHBTPairCut();
  32   AliHBTPairCut(const AliHBTPairCut& in);
  33   AliHBTPairCut& operator = (const AliHBTPairCut& in);
  34
  35   virtual ~AliHBTPairCut();
  36   virtual Bool_t Pass(AliHBTPair* pair) const;
  37   virtual Bool_t PassPairProp(AliHBTPair* pair) const;
  38
  39   virtual Bool_t IsEmpty() const {return kFALSE;}
  40   void SetFirstPartCut(AliHBTParticleCut* cut);  //sets the cut on the first particle
  41   void SetSecondPartCut(AliHBTParticleCut* cut); //sets the cut on the second particle
  42
  43   void SetPartCut(AliHBTParticleCut* cut);//sets the the same cut on both particles
  44
  45   virtual void AddBasePairCut(AliHbtBasePairCut* cut);
  46
  47   void SetQInvRange(Double_t min, Double_t max);
  48   void SetKtRange(Double_t min, Double_t max);
  49   void SetKStarRange(Double_t min, Double_t max);
  50   void SetQOutCMSLRange(Double_t min, Double_t max);
  51   void SetQSideCMSLRange(Double_t min, Double_t max);
  52   void SetQLongCMSLRange(Double_t min, Double_t max);
  53   void SetAvSeparationRange(Double_t min,Double_t max = 10e5);
  54
  55   AliHBTParticleCut* GetFirstPartCut() const {return fFirstPartCut;}
  56   AliHBTParticleCut* GetSecondPartCut() const {return fSecondPartCut;}
  57
  58  protected:
  59   AliHBTParticleCut*      fFirstPartCut;//cut on first particle in pair
  60   AliHBTParticleCut*      fSecondPartCut;//cut on second particle in pair
  61
  62   AliHbtBasePairCut** fCuts; //! array of poiters to base cuts
  63   Int_t fNCuts;//Number of cuts in fCuts array
  64
  65
  66   AliHbtBasePairCut* FindCut(AliHBTPairCutProperty cut);
  67  private:
  68   static const Int_t fgkMaxCuts; // Max number of cuts
  69   ClassDef(AliHBTPairCut,2)
  70 };
  71 /******************************************************************/
  72 /******************************************************************/
  73 /******************************************************************/
  74
  75 class AliHBTEmptyPairCut:  public AliHBTPairCut
  76 {
  77   //Empty - it passes possitively all particles - it means returns always False
  78   //Class describing cut on pairs of particles
  79  public:
  80   AliHBTEmptyPairCut(){};
  81   AliHBTEmptyPairCut(const AliHBTEmptyPairCut& in):AliHBTPairCut(in){};
  82   virtual ~AliHBTEmptyPairCut(){};
  83
  84   Bool_t Pass(AliHBTPair*) const {return kFALSE;} //accpept everything
  85   Bool_t IsEmpty() const {return kTRUE;}
  86
  87   ClassDef(AliHBTEmptyPairCut,1)
  88 };
  89
  90
  91
  92 /******************************************************************/
  93 /******************************************************************/
  94 /******************************************************************/
  95
  96 class AliHbtBasePairCut: public TObject
  97 {
  98   //This class defines the range of some property - pure virtual
  99   //Property is coded by AliHBTCutTypes type
 100
 101  public:
 102
 103   AliHbtBasePairCut(Double_t min = 0.0, Double_t max = 0.0, AliHBTPairCutProperty prop= kHbtPairCutPropNone):
 104     fMin(min),fMax(max),fProperty(prop){}
 105
 106   virtual   ~AliHbtBasePairCut(){}
 107
 108   Bool_t    Pass(AliHBTPair* pair) const;
 109
 110   void      SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
 111
 112   void      SetMinimum(Double_t min){fMin = min;}
 113   void      SetMaximum(Double_t max){fMax = max;}
 114
 115   Double_t  GetMinimum() const {return fMin;}
 116   Double_t  GetMaximum() const {return fMax;}
 117
 118   AliHBTPairCutProperty GetProperty() const {return fProperty;}
 119
 120  protected:
 121   virtual Double_t  GetValue(AliHBTPair* pair) const = 0;
 122
 123   Double_t fMin; // Lower boundary of the range
 124   Double_t fMax; // Upper boundary of the range
 125
 126   AliHBTPairCutProperty fProperty; // The property itself
 127
 128   ClassDef(AliHbtBasePairCut,1)
 129
 130  };
 131
 132 inline Bool_t AliHbtBasePairCut::Pass(AliHBTPair* pair) const
 133 {
 134   //checks if pair proprty is in range
 135   //null pointer check is made by AliHBTPairCut, so here is unnecesary
 136
 137   Double_t value = GetValue(pair);
 138   if ( (value > fMin) && (value <fMax ) ) return kFALSE; //accepted
 139   else return kTRUE; //rejected
 140 }
 141 /******************************************************************/
 142 /******************************************************************/
 143 /******************************************************************/
 144 class AliHBTQInvCut: public AliHbtBasePairCut
 145 {
 146  public:
 147   AliHBTQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropQInv){}
 148   virtual ~AliHBTQInvCut(){}
 149  protected:
 150   virtual Double_t  GetValue(AliHBTPair* pair) const {return pair->GetQInv();}
 151
 152   ClassDef(AliHBTQInvCut,1)
 153  };
 154
 155
 156 class AliHBTKtCut: public AliHbtBasePairCut {
 157  public:
 158   AliHBTKtCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropKt){}
 159   virtual ~AliHBTKtCut(){}
 160  protected:
 161   virtual Double_t  GetValue(AliHBTPair* pair) const {return pair->GetKt();}
 162
 163   ClassDef(AliHBTKtCut,1)
 164  };
 165
 166 class AliHBTKStarCut: public AliHbtBasePairCut
 167 {
 168  public:
 169   AliHBTKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropKStar){}
 170   virtual ~AliHBTKStarCut(){}
 171  protected:
 172   virtual Double_t  GetValue(AliHBTPair* pair) const {return pair->GetKStar();}
 173
 174   ClassDef(AliHBTKStarCut,1)
 175 };
 176
 177 class AliHBTQSideCMSLCCut: public AliHbtBasePairCut
 178 {
 179  public:
 180   AliHBTQSideCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
 181     AliHbtBasePairCut(min,max,kHbtPairCutPropQSideCMSLC){}
 182   virtual ~AliHBTQSideCMSLCCut(){}
 183  protected:
 184   virtual Double_t  GetValue(AliHBTPair* pair) const
 185     {return pair->GetQSideCMSLC();}
 186
 187   ClassDef(AliHBTQSideCMSLCCut,1)
 188 };
 189
 190
 191 class AliHBTQOutCMSLCCut: public AliHbtBasePairCut
 192 {
 193  public:
 194   AliHBTQOutCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
 195     AliHbtBasePairCut(min,max,kHbtPairCutPropQOutCMSLC){}
 196   virtual ~AliHBTQOutCMSLCCut(){}
 197  protected:
 198   virtual Double_t  GetValue(AliHBTPair* pair) const
 199     {return pair->GetQOutCMSLC();}
 200
 201   ClassDef(AliHBTQOutCMSLCCut,1)
 202 };
 203
 204 class AliHBTQLongCMSLCCut: public AliHbtBasePairCut
 205 {
 206  public:
 207   AliHBTQLongCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
 208     AliHbtBasePairCut(min,max,kHbtPairCutPropQLongCMSLC){}
 209   virtual ~AliHBTQLongCMSLCCut(){}
 210  protected:
 211   virtual Double_t  GetValue(AliHBTPair* pair) const
 212     {return pair->GetQLongCMSLC();}
 213
 214   ClassDef(AliHBTQLongCMSLCCut,1)
 215 };
 216
 217
 218 class AliHBTAvSeparationCut: public AliHbtBasePairCut
 219 {
 220  public:
 221   AliHBTAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
 222     AliHbtBasePairCut(min,max,kHbtPairCutPropAvSepar){}
 223   virtual ~AliHBTAvSeparationCut(){}
 224
 225  protected:
 226   virtual Double_t  GetValue(AliHBTPair* pair) const;
 227   ClassDef(AliHBTAvSeparationCut,1)
 228 };
 229
 230 #endif