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