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