HBTAN/AliHBTParticleCut.h

   1 //__________________________________________________________________________
   2 ////////////////////////////////////////////////////////////////////////////
   3 //                                                                        //
   4 // class AliHBTParticleCut                                                //
   5 //                                                                        //
   6 // Classes for single particle cuts                                       //
   7 // User should use only AliHBTParticleCut, eventually                     //
   8 // EmptyCut which passes all particles                                    //
   9 // There is all interface for setting cuts on all particle properties     //
  10 // The main method is Pass - which returns                                //
  11 //         True to reject particle                                        //
  12 //         False in case it meets all the criteria of the given cut       //
  13 //                                                                        //
  14 // User should create (and also destroy) cuts himself                     //
  15 // and then pass them to the Analysis And Function by a proper method     //
  16 //                                                                        //
  17 //                                                                        //
  18 // more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html   //
  19 // resonsible: Piotr Skowronski@cern.ch                                   //
  20 //                                                                        //
  21 ////////////////////////////////////////////////////////////////////////////
  22
  23
  24 #ifndef ALIHBTPARTICLECUT_H
  25 #define ALIHBTPARTICLECUT_H
  26
  27 #include <TObject.h>
  28 #include "AliHBTParticle.h"
  29
  30
  31 class AliHBTEmptyParticleCut;
  32 class AliHBTParticleCut;
  33 class AliHBTPairCut;
  34 class AliHBTPair;
  35 class AliHbtBaseCut;
  36
  37
  38 /******************************************************************/
  39 /******************************************************************/
  40 /******************************************************************/
  41
  42 enum AliHBTCutProperty
  43  {
  44 //codes particle property
  45   kHbtP,  //Momentum
  46   kHbtPt, //Transverse momentum
  47   kHbtE,  //Energy
  48   kHbtRapidity, //
  49   kHbtPseudoRapidity,
  50   kHbtPx, //X coAnddinate of the momentum
  51   kHbtPy, //Y coAnddinate of the momentum
  52   kHbtPz, //Z coAnddinate of the momentum
  53   kHbtPhi,//angle
  54   kHbtTheta,//angle
  55   kHbtVx,  // vertex X coAnddinate
  56   kHbtVy,  // vertex Y coAnddinate
  57   kHbtVz,  // vertex Z coAnddinate
  58   kHbtPid, // vertex Z coAnddinate
  59 //_____________________________
  60   kHbtNone
  61  };
  62
  63 /******************************************************************/
  64 /******************************************************************/
  65 /******************************************************************/
  66
  67 class AliHBTParticleCut: public TObject
  68 {
  69 //Class describing cut on pairs of particles
  70   public:
  71     AliHBTParticleCut();
  72     AliHBTParticleCut(const AliHBTParticleCut& in);
  73     virtual ~AliHBTParticleCut();
  74     const AliHBTParticleCut& operator = (const AliHBTParticleCut& in);
  75
  76     virtual Bool_t Pass(AliHBTParticle* p);
  77     Bool_t IsEmpty() const {return kFALSE;}
  78
  79     void AddBasePartCut(AliHbtBaseCut* basecut);
  80
  81     Int_t GetPID() const { return fPID;}
  82     void SetPID(Int_t pid){fPID=pid;}
  83     void SetMomentumRange(Double_t min, Double_t max);
  84     void SetPRange(Double_t min, Double_t max){SetMomentumRange(min,max);}
  85     void SetPtRange(Double_t min, Double_t max);
  86     void SetEnergyRange(Double_t min, Double_t max);
  87     void SetRapidityRange(Double_t min, Double_t max);
  88     void SetYRange(Double_t min, Double_t max){SetRapidityRange(min,max);}
  89     void SetPseudoRapidityRange(Double_t min, Double_t max);
  90     void SetPxRange(Double_t min, Double_t max);
  91     void SetPyRange(Double_t min, Double_t max);
  92     void SetPzRange(Double_t min, Double_t max);
  93     void SetPhiRange(Double_t min, Double_t max);
  94     void SetThetaRange(Double_t min, Double_t max);
  95     void SetVxRange(Double_t min, Double_t max);
  96     void SetVyRange(Double_t min, Double_t max);
  97     void SetVzRange(Double_t min, Double_t max);
  98
  99     void Print(void) const;
 100   protected:
 101
 102     AliHbtBaseCut* FindCut(AliHBTCutProperty property);
 103
 104     AliHbtBaseCut ** fCuts;//! Array with cuts
 105     Int_t fNCuts; //number of base cuts stored in fCuts
 106
 107     Int_t fPID; //particle PID  - if=0 (rootino) all pids are accepted
 108
 109   private:
 110     static const Int_t fgkMaxCuts; //Size of the fCuts array
 111
 112     ClassDef(AliHBTParticleCut,1)
 113 };
 114 /******************************************************************/
 115 /******************************************************************/
 116 /******************************************************************/
 117
 118 class AliHBTEmptyParticleCut:  public AliHBTParticleCut
 119 {
 120 //Empty - it passes possitively all particles - it means returns always False
 121 //Class describing cut on pairs of particles
 122   public:
 123     AliHBTEmptyParticleCut(){};
 124     virtual ~AliHBTEmptyParticleCut(){};
 125
 126     Bool_t Pass(AliHBTParticle*){return kFALSE;} //accept everything <<CAN NOT BE const!!!!>>
 127     Bool_t IsEmpty() const {return kTRUE;}
 128
 129     ClassDef(AliHBTEmptyParticleCut,1)
 130
 131 };
 132
 133 /******************************************************************/
 134 /******************************************************************/
 135 /******************************************************************/
 136
 137 class AliHbtBaseCut: public TObject
 138  {
 139    //This class defines the range of some property - pure virtual
 140    //Property is coded by AliHBTCutTypes type
 141
 142    public:
 143
 144      AliHbtBaseCut(Double_t min = 0.0, Double_t max = 0.0,AliHBTCutProperty prop = kHbtNone):
 145                    fProperty(prop),fMin(min),fMax(max){}
 146
 147      virtual           ~AliHbtBaseCut(){}
 148
 149      virtual Bool_t    Pass(AliHBTParticle *p);
 150
 151      void              SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
 152
 153      void              SetMinimum(Double_t min){fMin = min;}
 154      void              SetMaximum(Double_t max){fMax = max;}
 155
 156      Double_t          GetMinimum() const {return fMin;}
 157      Double_t          GetMaximum() const {return fMax;}
 158
 159      AliHBTCutProperty GetProperty() const {return fProperty;}
 160      virtual void Print(void) const;
 161
 162    protected:
 163      virtual Double_t  GetValue(AliHBTParticle *) const = 0;
 164
 165      AliHBTCutProperty fProperty; //property that this cut describes
 166      Double_t fMin;//minimum value
 167      Double_t fMax;//maximum value
 168
 169    private:
 170      void PrintProperty(void) const;
 171      ClassDef(AliHbtBaseCut,1)
 172
 173  };
 174
 175 inline Bool_t
 176 AliHbtBaseCut::Pass(AliHBTParticle *p)
 177 {
 178   //cjecks if particle property fits in range
 179   if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
 180   else return kFALSE; //accepted
 181 }
 182 /******************************************************************/
 183 /******************************************************************/
 184 /******************************************************************/
 185
 186
 187 class AliHBTMomentumCut: public AliHbtBaseCut
 188  {
 189   public:
 190     AliHBTMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtP){}
 191     virtual ~AliHBTMomentumCut(){}
 192   protected:
 193     Double_t  GetValue(AliHBTParticle * p)const{return p->P();}
 194     ClassDef(AliHBTMomentumCut,1)
 195  };
 196
 197 class AliHBTPtCut: public AliHbtBaseCut
 198  {
 199   public:
 200     AliHBTPtCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPt){}
 201     virtual ~AliHBTPtCut(){}
 202   protected:
 203     Double_t  GetValue(AliHBTParticle * p)const{return p->Pt();}
 204     ClassDef(AliHBTPtCut,1)
 205  };
 206
 207
 208 class AliHBTEnergyCut: public AliHbtBaseCut
 209  {
 210   public:
 211     AliHBTEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtE){}
 212     virtual ~AliHBTEnergyCut(){}
 213   protected:
 214     Double_t  GetValue(AliHBTParticle * p)const{return p->Energy();}
 215     ClassDef(AliHBTEnergyCut,1)
 216  };
 217
 218 class AliHBTRapidityCut: public AliHbtBaseCut
 219  {
 220   public:
 221     AliHBTRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtRapidity){}
 222     virtual ~AliHBTRapidityCut(){}
 223   protected:
 224     Double_t  GetValue(AliHBTParticle * p)const{return p->Y();}
 225     ClassDef(AliHBTRapidityCut,1)
 226  };
 227
 228 class AliHBTPseudoRapidityCut: public AliHbtBaseCut
 229  {
 230   public:
 231     AliHBTPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPseudoRapidity){}
 232     virtual ~AliHBTPseudoRapidityCut(){}
 233   protected:
 234     Double_t  GetValue(AliHBTParticle * p)const{return p->Eta();}
 235     ClassDef(AliHBTPseudoRapidityCut,1)
 236  };
 237
 238 class AliHBTPxCut: public AliHbtBaseCut
 239  {
 240   public:
 241     AliHBTPxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPx){}
 242     virtual ~AliHBTPxCut(){}
 243   protected:
 244     Double_t  GetValue(AliHBTParticle * p)const{return p->Px();}
 245     ClassDef(AliHBTPxCut,1)
 246  };
 247
 248 class AliHBTPyCut: public AliHbtBaseCut
 249  {
 250   public:
 251     AliHBTPyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPy){}
 252     virtual ~AliHBTPyCut(){}
 253   protected:
 254     Double_t  GetValue(AliHBTParticle * p)const{return p->Py();}
 255     ClassDef(AliHBTPyCut,1)
 256  };
 257
 258
 259 class AliHBTPzCut: public AliHbtBaseCut
 260  {
 261   public:
 262     AliHBTPzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPz){}
 263     virtual ~AliHBTPzCut(){}
 264   protected:
 265     Double_t  GetValue(AliHBTParticle * p)const{return p->Pz();}
 266     ClassDef(AliHBTPzCut,1)
 267  };
 268
 269 class AliHBTPhiCut: public AliHbtBaseCut
 270  {
 271   public:
 272     AliHBTPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPhi){}
 273     virtual ~AliHBTPhiCut(){}
 274   protected:
 275     Double_t  GetValue(AliHBTParticle * p)const{return p->Phi();}
 276     ClassDef(AliHBTPhiCut,1)
 277
 278  };
 279
 280 class AliHBTThetaCut: public AliHbtBaseCut
 281  {
 282   public:
 283     AliHBTThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtTheta){}
 284     virtual ~AliHBTThetaCut(){}
 285   protected:
 286     Double_t  GetValue(AliHBTParticle * p)const{return p->Theta();}
 287     ClassDef(AliHBTThetaCut,1)
 288
 289  };
 290
 291 class AliHBTVxCut: public AliHbtBaseCut
 292  {
 293  //Cut of the X coAnddinate of the vertex position
 294   public:
 295     AliHBTVxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVx){}
 296     virtual ~AliHBTVxCut(){}
 297   protected:
 298     Double_t  GetValue(AliHBTParticle * p)const{return p->Vx();} //retruns value of the vertex
 299     ClassDef(AliHBTVxCut,1)
 300
 301  };
 302
 303
 304 class AliHBTVyCut: public AliHbtBaseCut
 305  {
 306  //Cut of the X coAnddinate of the vertex position
 307   public:
 308     AliHBTVyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVy){}
 309     virtual ~AliHBTVyCut(){}
 310   protected:
 311     Double_t  GetValue(AliHBTParticle * p)const{return p->Vy();} //retruns value of the vertex
 312     ClassDef(AliHBTVyCut,1)
 313
 314  };
 315
 316 class AliHBTVzCut: public AliHbtBaseCut
 317  {
 318  //Cut of the X coAnddinate of the vertex position
 319   public:
 320     AliHBTVzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVz){}
 321     virtual ~AliHBTVzCut(){}
 322   protected:
 323     Double_t  GetValue(AliHBTParticle * p)const{return p->Vz();} //retruns value of the vertex
 324
 325     ClassDef(AliHBTVzCut,1)
 326
 327  };
 328
 329 class AliHBTPIDCut:  public AliHbtBaseCut
 330  {
 331    public:
 332      AliHBTPIDCut():AliHbtBaseCut(0.0,0.0,kHbtPid),fPID(0){}
 333      AliHBTPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliHbtBaseCut(min,max,kHbtPid),fPID(pid){}
 334      virtual ~AliHBTPIDCut(){}
 335    protected:
 336      Double_t  GetValue(AliHBTParticle * p)const{return p->GetPIDprobability(fPID);}
 337      Int_t     fPID; //pid of particle that the pid is set
 338      ClassDef(AliHBTPIDCut,1)
 339  };
 340 //___________________________________________________
 341 /////////////////////////////////////////////////////
 342 //                                                 //
 343 // class AliHBTLogicalOperCut                      //
 344 //                                                 //
 345 // This cut is base class fAnd class that perfAndms  //
 346 // logical operations on cuts                      //
 347 //                                                 //
 348 /////////////////////////////////////////////////////
 349 class AliHBTLogicalOperCut:  public AliHbtBaseCut
 350  {
 351    public:
 352      AliHBTLogicalOperCut();
 353      AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut* second);
 354      virtual   ~AliHBTLogicalOperCut();
 355    protected:
 356      Double_t  GetValue(AliHBTParticle * /*part*/) const {MayNotUse("GetValue");return 0.0;}
 357
 358      AliHbtBaseCut* fFirst;   //second cut
 359      AliHbtBaseCut* fSecond;  //first cut
 360    private:
 361     class  AliHBTDummyBaseCut: public AliHbtBaseCut
 362      {
 363        Double_t  GetValue(AliHBTParticle * /*part*/) const {return 0.0;}
 364        Bool_t    Pass(AliHBTParticle* /*part*/);
 365      };
 366
 367     ClassDef(AliHBTLogicalOperCut,1)
 368  };
 369
 370 class AliHBTOrCut: public AliHBTLogicalOperCut
 371 {
 372    public:
 373      AliHBTOrCut(){}
 374      AliHBTOrCut(AliHbtBaseCut* first, AliHbtBaseCut* second):AliHBTLogicalOperCut(first,second){}
 375      virtual   ~AliHBTOrCut(){}
 376      Bool_t    Pass(AliHBTParticle *p);
 377      ClassDef(AliHBTOrCut,1)
 378 };
 379
 380 class AliHBTAndCut: public AliHBTLogicalOperCut
 381 {
 382    public:
 383      AliHBTAndCut(){}
 384      AliHBTAndCut(AliHbtBaseCut* first, AliHbtBaseCut* second):AliHBTLogicalOperCut(first,second){}
 385      virtual   ~AliHBTAndCut(){}
 386      Bool_t    Pass(AliHBTParticle *p);
 387      ClassDef(AliHBTAndCut,1)
 388 };
 389
 390 #endif