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