HBTAN/AliHBTParticleCut.h

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