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