HBTAN/AliHBTParticleCut.h

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