ANALYSIS/AliAODPairCut.h

   1 #ifndef AliAODPairCUT_H
   2 #define AliAODPairCUT_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 "AliAODPair.h"
  12
  13 class AliAODParticleCut;
  14 class AliAODBasePairCut;
  15
  16 enum AliAODPairCutProperty
  17 {
  18   kHbtPairCutPropQInv, //Q invariant
  19   kHbtPairCutPropKt,
  20   kHbtPairCutPropKStar,
  21   kHbtPairCutPropQSideLCMS,
  22   kHbtPairCutPropQOutLCMS,
  23   kHbtPairCutPropQLongLCMS,
  24   kHbtPairCutPropDeltaPhi,
  25   kHbtPairCutPropDeltaTheta,
  26   kHbtPairCutPropDeltaP,
  27   kHbtPairCutPropDeltaPt,
  28   kHbtPairCutPropAvSepar,
  29   kHbtPairCutPropSepar,
  30   kHbtPairCutPropClOverlap,
  31   kHbtPairCutPropPixelSepar,
  32   kHbtPairCutPropNone
  33 };
  34 /******************************************************************/
  35
  36 class AliAODPairCut: public TNamed
  37 {
  38  public:
  39   AliAODPairCut();
  40   AliAODPairCut(const AliAODPairCut& in);
  41   AliAODPairCut& operator = (const AliAODPairCut& in);
  42
  43   virtual ~AliAODPairCut();
  44   virtual Bool_t Pass(AliAODPair* pair) const;
  45   virtual Bool_t PassPairProp(AliAODPair* pair) const;
  46
  47   virtual Bool_t IsEmpty() const {return kFALSE;}
  48   void SetFirstPartCut(AliAODParticleCut* cut);  //sets the cut on the first particle
  49   void SetSecondPartCut(AliAODParticleCut* cut); //sets the cut on the second particle
  50
  51   void SetPartCut(AliAODParticleCut* cut);//sets the the same cut on both particles
  52
  53   virtual void AddBasePairCut(AliAODBasePairCut* 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   AliAODParticleCut* GetFirstPartCut() const {return fFirstPartCut;}
  68   AliAODParticleCut* GetSecondPartCut() const {return fSecondPartCut;}
  69
  70  protected:
  71   AliAODParticleCut*      fFirstPartCut;//cut on first particle in pair
  72   AliAODParticleCut*      fSecondPartCut;//cut on second particle in pair
  73
  74   AliAODBasePairCut** fCuts; //! array of poiters to base cuts
  75   Int_t fNCuts;//Number of cuts in fCuts array
  76
  77
  78   AliAODBasePairCut* FindCut(AliAODPairCutProperty cut);
  79  private:
  80   static const Int_t fgkMaxCuts; // Max number of cuts
  81   ClassDef(AliAODPairCut,2)
  82 };
  83 /******************************************************************/
  84 /******************************************************************/
  85 /******************************************************************/
  86
  87 class AliAODEmptyPairCut:  public AliAODPairCut
  88 {
  89   //Empty - it passes possitively all particles - it means returns always False
  90   //Class describing cut on pairs of particles
  91  public:
  92   AliAODEmptyPairCut(){};
  93   AliAODEmptyPairCut(const AliAODEmptyPairCut& in):AliAODPairCut(in){};
  94   virtual ~AliAODEmptyPairCut(){};
  95
  96   Bool_t Pass(AliAODPair*) const {return kFALSE;} //accpept everything
  97   Bool_t IsEmpty() const {return kTRUE;}
  98
  99   ClassDef(AliAODEmptyPairCut,1)
 100 };
 101
 102
 103
 104 /******************************************************************/
 105 /******************************************************************/
 106 /******************************************************************/
 107
 108 class AliAODBasePairCut: public TObject
 109 {
 110   //This class defines the range of some property - pure virtual
 111   //Property is coded by AliAODCutTypes type
 112
 113  public:
 114
 115   AliAODBasePairCut(Double_t min = 0.0, Double_t max = 0.0, AliAODPairCutProperty prop= kHbtPairCutPropNone):
 116     fMin(min),fMax(max),fProperty(prop){}
 117
 118   virtual   ~AliAODBasePairCut(){}
 119
 120   virtual Bool_t    Pass(AliAODPair* 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   AliAODPairCutProperty GetProperty() const {return fProperty;}
 131
 132  protected:
 133   virtual Double_t  GetValue(AliAODPair* pair) const = 0;
 134
 135   Double_t fMin; // Lower boundary of the range
 136   Double_t fMax; // Upper boundary of the range
 137
 138   AliAODPairCutProperty fProperty; // The property itself
 139
 140   ClassDef(AliAODBasePairCut,1)
 141
 142  };
 143 /******************************************************************/
 144
 145 inline Bool_t AliAODBasePairCut::Pass(AliAODPair* pair) const
 146 {
 147   //checks if pair proprty is in range
 148   //null pointer check is made by AliAODPairCut, 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 AliAODQInvCut: public AliAODBasePairCut
 159 {
 160  public:
 161   AliAODQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBasePairCut(min,max,kHbtPairCutPropQInv){}
 162   virtual ~AliAODQInvCut(){}
 163  protected:
 164   virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetQInv();}
 165
 166   ClassDef(AliAODQInvCut,1)
 167  };
 168 /******************************************************************/
 169
 170 class AliAODKtCut: public AliAODBasePairCut {
 171  public:
 172   AliAODKtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBasePairCut(min,max,kHbtPairCutPropKt){}
 173   virtual ~AliAODKtCut(){}
 174  protected:
 175   virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKt();}
 176
 177   ClassDef(AliAODKtCut,1)
 178  };
 179 /******************************************************************/
 180
 181 class AliAODKStarCut: public AliAODBasePairCut
 182 {
 183  public:
 184   AliAODKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBasePairCut(min,max,kHbtPairCutPropKStar){}
 185   virtual ~AliAODKStarCut(){}
 186  protected:
 187   virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKStar();}
 188
 189   ClassDef(AliAODKStarCut,1)
 190 };
 191 /******************************************************************/
 192
 193 class AliAODQSideLCMSCut: public AliAODBasePairCut
 194 {
 195  public:
 196   AliAODQSideLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
 197     AliAODBasePairCut(min,max,kHbtPairCutPropQSideLCMS){}
 198   virtual ~AliAODQSideLCMSCut(){}
 199  protected:
 200   virtual Double_t  GetValue(AliAODPair* pair) const
 201     {return pair->GetQSideLCMS();}
 202
 203   ClassDef(AliAODQSideLCMSCut,1)
 204 };
 205 /******************************************************************/
 206
 207
 208 class AliAODQOutLCMSCut: public AliAODBasePairCut
 209 {
 210  public:
 211   AliAODQOutLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
 212     AliAODBasePairCut(min,max,kHbtPairCutPropQOutLCMS){}
 213   virtual ~AliAODQOutLCMSCut(){}
 214  protected:
 215   virtual Double_t  GetValue(AliAODPair* pair) const
 216     {return pair->GetQOutLCMS();}
 217
 218   ClassDef(AliAODQOutLCMSCut,1)
 219 };
 220 /******************************************************************/
 221
 222 class AliAODQLongLCMSCut: public AliAODBasePairCut
 223 {
 224  public:
 225   AliAODQLongLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
 226     AliAODBasePairCut(min,max,kHbtPairCutPropQLongLCMS){}
 227   virtual ~AliAODQLongLCMSCut(){}
 228  protected:
 229   virtual Double_t  GetValue(AliAODPair* pair) const
 230     {return pair->GetQLongLCMS();}
 231
 232   ClassDef(AliAODQLongLCMSCut,1)
 233 };
 234 /******************************************************************/
 235
 236 class AliAODDeltaPhiCut: public AliAODBasePairCut
 237 {
 238  public:
 239   AliAODDeltaPhiCut(Double_t min = 0.0, Double_t max = 0.0):
 240     AliAODBasePairCut(min,max,kHbtPairCutPropDeltaPhi){}
 241   virtual ~AliAODDeltaPhiCut(){}
 242  protected:
 243   virtual Double_t  GetValue(AliAODPair* pair) const
 244     {return TMath::Abs(pair->GetDeltaPhi());}
 245
 246   ClassDef(AliAODDeltaPhiCut,1)
 247 };
 248 /******************************************************************/
 249
 250 class AliAODDeltaThetaCut: public AliAODBasePairCut
 251 {
 252  public:
 253   AliAODDeltaThetaCut(Double_t min = 0.0, Double_t max = 0.0):
 254     AliAODBasePairCut(min,max,kHbtPairCutPropDeltaTheta){}
 255   virtual ~AliAODDeltaThetaCut(){}
 256  protected:
 257   virtual Double_t  GetValue(AliAODPair* pair) const
 258     {return TMath::Abs(pair->GetDeltaTheta());}
 259
 260   ClassDef(AliAODDeltaThetaCut,1)
 261 };
 262 /******************************************************************/
 263
 264 class AliAODCluterOverlapCut: public AliAODBasePairCut
 265 {
 266  public:
 267   AliAODCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
 268     AliAODBasePairCut(min,max,kHbtPairCutPropClOverlap){}
 269   virtual ~AliAODCluterOverlapCut(){}
 270
 271  protected:
 272   virtual Double_t  GetValue(AliAODPair* pair) const;
 273   ClassDef(AliAODCluterOverlapCut,1)
 274 };
 275 /******************************************************************/
 276
 277 class AliAODAvSeparationCut: public AliAODBasePairCut
 278 {
 279  public:
 280   AliAODAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
 281     AliAODBasePairCut(min,max,kHbtPairCutPropAvSepar){}
 282   virtual ~AliAODAvSeparationCut(){}
 283
 284  protected:
 285   virtual Double_t  GetValue(AliAODPair* pair) const;
 286   ClassDef(AliAODAvSeparationCut,1)
 287 };
 288 /******************************************************************/
 289
 290 class AliAODSeparationCut: public AliAODBasePairCut
 291 {
 292  public:
 293   AliAODSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
 294     AliAODBasePairCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
 295   virtual ~AliAODSeparationCut(){}
 296
 297  protected:
 298   Int_t fPoint;//index of the point that distance should be measured
 299   virtual Double_t  GetValue(AliAODPair* pair) const;
 300   ClassDef(AliAODSeparationCut,1)
 301 };
 302 /******************************************************************/
 303
 304 class AliAODITSSeparationCut: public AliAODBasePairCut
 305 {
 306 //Anti merging cut for the first layer of pixels
 307  public:
 308   AliAODITSSeparationCut(Int_t layer = 0, Double_t deltarphi = 0.01, Double_t deltaz = 0.08):
 309     AliAODBasePairCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
 310   virtual ~AliAODITSSeparationCut(){}
 311   Bool_t   Pass(AliAODPair* 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(AliAODPair* /*pair*/) const {return 0.0;}//not used
 316   ClassDef(AliAODITSSeparationCut,1)
 317 };
 318 /******************************************************************/
 319
 320 class AliAODOutSideSameSignCut: public AliAODBasePairCut
 321 {
 322  public:
 323   AliAODOutSideSameSignCut(){}
 324   virtual ~AliAODOutSideSameSignCut(){}
 325   virtual Bool_t Pass(AliAODPair *p) const;
 326  protected:
 327   virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
 328   ClassDef(AliAODOutSideSameSignCut,1)
 329 };
 330 /******************************************************************/
 331
 332 class AliAODOutSideDiffSignCut: public AliAODBasePairCut
 333 {
 334  public:
 335   AliAODOutSideDiffSignCut(){}
 336   virtual ~AliAODOutSideDiffSignCut(){}
 337   virtual Bool_t Pass(AliAODPair *p) const;
 338  protected:
 339   virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
 340   ClassDef(AliAODOutSideDiffSignCut,1)
 341 };
 342 /******************************************************************/
 343
 344 class AliAODLogicalOperPairCut:  public AliAODBasePairCut
 345  {
 346    public:
 347      AliAODLogicalOperPairCut();
 348      AliAODLogicalOperPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second);
 349      virtual   ~AliAODLogicalOperPairCut();
 350    protected:
 351      Double_t  GetValue(AliAODPair * /*pair*/) const {MayNotUse("GetValue");return 0.0;}
 352
 353      AliAODBasePairCut* fFirst;   //second cut
 354      AliAODBasePairCut* fSecond;  //first cut
 355    private:
 356     class  AliAODDummyBasePairCut: public AliAODBasePairCut
 357      {
 358        Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
 359        Bool_t    Pass(AliAODPair* /*pair*/) const;
 360      };
 361
 362     ClassDef(AliAODLogicalOperPairCut,1)
 363  };
 364 /******************************************************************/
 365
 366 class AliAODOrPairCut: public AliAODLogicalOperPairCut
 367 {
 368    public:
 369      AliAODOrPairCut(){}
 370      AliAODOrPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second):AliAODLogicalOperPairCut(first,second){}
 371      virtual   ~AliAODOrPairCut(){}
 372      Bool_t    Pass(AliAODPair *p) const;
 373      ClassDef(AliAODOrPairCut,1)
 374 };
 375 /******************************************************************/
 376
 377 class AliAODAndPairCut: public AliAODLogicalOperPairCut
 378 {
 379    public:
 380      AliAODAndPairCut(){}
 381      AliAODAndPairCut(AliAODBasePairCut* first, AliAODBasePairCut* second):AliAODLogicalOperPairCut(first,second){}
 382      virtual   ~AliAODAndPairCut(){}
 383      Bool_t    Pass(AliAODPair *p) const;
 384      ClassDef(AliAODAndPairCut,1)
 385 };
 386
 387 #endif