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