PWG3/hfe/AliESDv0KineCuts.h

   1 #ifndef ALIESDV0KINECUTS_H
   2 #define ALIESDV0KINECUTS_H
   3
   4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  * See cxx source for full Copyright notice                               */
   6
   7 /* $Id$ */
   8
   9 /*
  10  * plesae see source file for more details
  11  */
  12
  13 #include <TObject.h>
  14
  15 class AliESDv0;
  16 class AliESDEvent;
  17 class AliVEvent;
  18 class AliESDtrack;
  19 class AliVTrack;
  20 class AliKFParticle;
  21 class AliKFVertex;
  22
  23 class AliESDv0KineCuts : public TObject{
  24  public:
  25   enum{ // Reconstructed V0
  26     kUndef = -1,
  27       kGamma = 0,
  28       kK0 = 1,
  29       kLambda = 2,
  30       kALambda = 3
  31       };
  32   enum{ // data types
  33     kPP = 0,
  34       kPbPb = 1,  // not yet implemented
  35       };
  36   enum{ // operation modes
  37     kPurity = 0, // purely kinematical selection
  38       kEffGamma = 1  // !!! involves TPC dEdx or nSimga cuts !!!
  39       };
  40
  41   AliESDv0KineCuts();
  42   virtual ~AliESDv0KineCuts();
  43
  44   AliESDv0KineCuts(const AliESDv0KineCuts &ref);
  45   AliESDv0KineCuts &operator=(const AliESDv0KineCuts &ref);
  46
  47   // main selection function - called once per V0 candidate
  48   Bool_t ProcessV0(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN);
  49   Bool_t ProcessV0(AliESDv0* const v0, Int_t &pdgP, Int_t &pdgN);
  50
  51   // must be called by the user
  52   void SetEvent(AliESDEvent* const event);
  53   void SetEvent(AliVEvent* const event);
  54   void SetPrimaryVertex(AliKFVertex* const v);
  55
  56   // user can select an operation modes [see .cxx for details]
  57   void   SetMode(Int_t mode, Int_t type);
  58   void   SetMode(Int_t mode, const char* type);
  59
  60   //
  61   // setter functions for V0 cut values
  62   // for default values see the constructor
  63   // see the default contructor for comments
  64   //
  65
  66   // single track cuts
  67   void   SetNTPCclusters(Int_t n) { fTPCNcls = n; };
  68   void   SetTPCrefit(Bool_t r = kTRUE) { fTPCrefit = r; };
  69   void   SetTPCchi2perCls(Float_t chi2) { fTPCchi2perCls = chi2; };
  70   void   SetTPCclusterratio(Float_t r) { fTPCclsRatio = r; };
  71   void   SetNoKinks(Bool_t k = kTRUE) { fNoKinks = k; };
  72
  73   // gamma cuts
  74   void   SetGammaCutChi2NDF(Float_t val)  { fGcutChi2NDF = val; };
  75   void   SetGammaCutCosPoint(Float_t *val) {
  76     fGcutCosPoint[0] = val[0];
  77     fGcutCosPoint[1] = val[1];
  78   };
  79   void   SetGammaCutDCA(Float_t *val){
  80     fGcutDCA[0] = val[0];
  81     fGcutDCA[1] = val[1];
  82   };
  83   void   SetGammaCutVertexR(Float_t *val){
  84     fGcutVertexR[0] = val[0];
  85     fGcutVertexR[1] = val[1];
  86   };
  87   void   SetGammaCutPsiPair(Float_t *val){
  88     fGcutPsiPair[0] = val[0];
  89     fGcutPsiPair[1] = val[1];
  90   };
  91   void   SetGammaCutInvMass(Float_t val){
  92     fGcutInvMass = val;
  93   };
  94   // K0 cuts
  95   void   SetK0CutChi2NDF(Float_t val)  { fK0cutChi2NDF = val; };
  96   void   SetK0CutCosPoint(Float_t *val) {
  97     fK0cutCosPoint[0] = val[0];
  98     fK0cutCosPoint[1] = val[1];
  99   };
 100   void   SetK0CutDCA(Float_t *val){
 101     fK0cutDCA[0] = val[0];
 102     fK0cutDCA[1] = val[1];
 103   };
 104   void   SetK0CutVertexR(Float_t *val){
 105     fK0cutVertexR[0] = val[0];
 106     fK0cutVertexR[1] = val[1];
 107   };
 108   void   SetK0CutInvMass(Float_t *val){
 109     fK0cutInvMass[0] = val[0];
 110     fK0cutInvMass[1] = val[1];
 111   };
 112   // lambda & anti-lambda cuts
 113   void   SetLambdaCutChi2NDF(Float_t val)  { fLcutChi2NDF = val; };
 114   void   SetLambdaCutCosPoint(Float_t *val) {
 115     fLcutCosPoint[0] = val[0];
 116     fLcutCosPoint[1] = val[1];
 117   };
 118   void   SetLambdaCutDCA(Float_t *val){
 119     fLcutDCA[0] = val[0];
 120     fLcutDCA[1] = val[1];
 121   };
 122   void   SetLambdaCutVertexR(Float_t *val){
 123     fLcutVertexR[0] = val[0];
 124     fLcutVertexR[1] = val[1];
 125   };
 126   void   SetLambdaCutInvMass(Float_t *val){
 127     fLcutInvMass[0] = val[0];
 128     fLcutInvMass[1] = val[1];
 129   };
 130
 131
 132   Int_t  PreselectV0(AliESDv0* const v0);
 133
 134   Bool_t CaseGamma(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN);
 135   Bool_t CaseK0(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN);
 136   Bool_t CaseLambda(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN, Int_t id);
 137
 138   Bool_t V0CutsCommon(const AliESDv0 * const v0);
 139   Bool_t SingleTrackCuts(AliESDv0 * const v0);
 140   void   Armenteros(AliESDv0* const v0, Float_t val[2]);
 141   Bool_t CheckSigns(AliESDv0* const v0);
 142
 143   Double_t PsiPair(AliESDv0* const v0);
 144   Bool_t   GetConvPosXY(AliESDtrack * const ptrack, AliESDtrack * const ntrack, Double_t convpos[2]);
 145   Bool_t   GetHelixCenter(AliESDtrack * const track, Double_t b, Int_t charge, Double_t center[2]);
 146
 147  protected:
 148   void Copy(TObject &ref) const;
 149
 150  private:
 151
 152   AliKFParticle *CreateMotherParticle(const AliVTrack* const pdaughter, const AliVTrack* const ndaughter, Int_t pspec, Int_t nspec);
 153   void      SetCuts();                          // setup cuts for selected fMode and fType, see source file for details
 154   Bool_t    GammaEffCuts(AliESDv0 * const v0);  // set of cuts optimized for high gamma efficiency
 155
 156  private:
 157   AliESDEvent           *fEvent;          // current event
 158   AliKFVertex           *fPrimaryVertex;  // primary vertex
 159
 160   Int_t                 fType;            // data type: p-p or Pb-Pb
 161   Int_t                 fMode;            // current operation mode
 162
 163   // single track cuts
 164   Int_t                 fTPCNcls;          // number of TPC clusters
 165   Bool_t                fTPCrefit;         // TPC refit - yes [kTRUE] or do not care [kFALSE]
 166   Float_t               fTPCchi2perCls;    // max. chi2 per TPC cluster
 167   Float_t               fTPCclsRatio;      // min. TPC cluster ratio
 168   Bool_t                fNoKinks;          // kinks - no [kTRUE] or do not care [kFalse]
 169
 170   // gamma cut values
 171   Float_t               fGcutChi2NDF;      // Chi2NF cut value for the AliKFparticle gamma
 172   Float_t               fGcutCosPoint[2];  // cos of the pointing angle [min, max]
 173   Float_t               fGcutDCA[2];       // DCA between the daughter tracks [min, max]
 174   Float_t               fGcutVertexR[2];   // radius of the conversion point [min, max]
 175   Float_t               fGcutPsiPair[2];   // value of the psi pair cut [min, max]
 176   Float_t               fGcutInvMass;      // upper value on the gamma invariant mass
 177   // K0 cut values
 178   Float_t               fK0cutChi2NDF;     // Chi2NF cut value for the AliKFparticle K0
 179   Float_t               fK0cutCosPoint[2]; // cos of the pointing angle [min, max]
 180   Float_t               fK0cutDCA[2];      // DCA between the daughter tracks [min, max]
 181   Float_t               fK0cutVertexR[2];  // radius of the decay point [min, max]
 182   Float_t               fK0cutInvMass[2];  // invariant mass window
 183   // Lambda & anti-Lambda cut values
 184   Float_t               fLcutChi2NDF;      // Chi2NF cut value for the AliKFparticle K0
 185   Float_t               fLcutCosPoint[2];  // cos of the pointing angle [min, max]
 186   Float_t               fLcutDCA[2];       // DCA between the daughter tracks [min, max]
 187   Float_t               fLcutVertexR[2];   // radius of the decay point [min, max]
 188   Float_t               fLcutInvMass[2];   // invariant mass window
 189
 190
 191   ClassDef(AliESDv0KineCuts, 0);
 192
 193 };
 194
 195 #endif