[u/mrichter/AliRoot.git] / PWG3 / hfe / AliESDv0KineCuts.h

#ifndef ALIESDV0KINECUTS_H
#define ALIESDV0KINECUTS_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */ 

/*
 * plesae see source file for more details
 */

#include <TObject.h>

class AliESDv0;
class AliESDEvent;
class AliVEvent;
class AliESDtrack;
class AliVTrack;
class AliKFParticle;
class AliKFVertex;

class AliESDv0KineCuts : public TObject{
 public:
  enum{ // Reconstructed V0
    kUndef = -1,
      kGamma = 0,
      kK0 = 1,
      kLambda = 2,
      kALambda = 3
      };
  enum{ // data types
    kPP = 0,
      kPbPb = 1,  // not yet implemented
      };
  enum{ // operation modes
    kPurity = 0, // purely kinematical selection
      kEffGamma = 1  // !!! involves TPC dEdx or nSimga cuts !!!
      };
  
  AliESDv0KineCuts();
  virtual ~AliESDv0KineCuts();

  AliESDv0KineCuts(const AliESDv0KineCuts &ref);
  AliESDv0KineCuts &operator=(const AliESDv0KineCuts &ref);

  // main selection function - called once per V0 candidate
  Bool_t ProcessV0(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN);
  Bool_t ProcessV0(AliESDv0* const v0, Int_t &pdgP, Int_t &pdgN);

  // must be called by the user
  void SetEvent(AliESDEvent* const event);
  void SetEvent(AliVEvent* const event);
  void SetPrimaryVertex(AliKFVertex* const v);

  // user can select an operation modes [see .cxx for details]
  void   SetMode(Int_t mode, Int_t type);
  void   SetMode(Int_t mode, const char* type);

  //
  // setter functions for V0 cut values
  // for default values see the constructor
  // see the default contructor for comments
  //

  // single track cuts
  void   SetNTPCclusters(Int_t n) { fTPCNcls = n; };
  void   SetTPCrefit(Bool_t r = kTRUE) { fTPCrefit = r; };
  void   SetTPCchi2perCls(Float_t chi2) { fTPCchi2perCls = chi2; };
  void   SetTPCclusterratio(Float_t r) { fTPCclsRatio = r; };
  void   SetNoKinks(Bool_t k = kTRUE) { fNoKinks = k; };

  // gamma cuts
  void   SetGammaCutChi2NDF(Float_t val)  { fGcutChi2NDF = val; };
  void   SetGammaCutCosPoint(Float_t *val) { 
    fGcutCosPoint[0] = val[0];
    fGcutCosPoint[1] = val[1];
  };
  void   SetGammaCutDCA(Float_t *val){
    fGcutDCA[0] = val[0];
    fGcutDCA[1] = val[1];
  };
  void   SetGammaCutVertexR(Float_t *val){
    fGcutVertexR[0] = val[0];
    fGcutVertexR[1] = val[1];
  };
  void   SetGammaCutPsiPair(Float_t *val){
    fGcutPsiPair[0] = val[0];
    fGcutPsiPair[1] = val[1];
  };
  void   SetGammaCutInvMass(Float_t val){
    fGcutInvMass = val;
  };
  // K0 cuts
  void   SetK0CutChi2NDF(Float_t val)  { fK0cutChi2NDF = val; };
  void   SetK0CutCosPoint(Float_t *val) { 
    fK0cutCosPoint[0] = val[0];
    fK0cutCosPoint[1] = val[1];
  };
  void   SetK0CutDCA(Float_t *val){
    fK0cutDCA[0] = val[0];
    fK0cutDCA[1] = val[1];
  };
  void   SetK0CutVertexR(Float_t *val){
    fK0cutVertexR[0] = val[0];
    fK0cutVertexR[1] = val[1];
  };
  void   SetK0CutInvMass(Float_t *val){
    fK0cutInvMass[0] = val[0];
    fK0cutInvMass[1] = val[1];
  };
  // lambda & anti-lambda cuts
  void   SetLambdaCutChi2NDF(Float_t val)  { fLcutChi2NDF = val; };
  void   SetLambdaCutCosPoint(Float_t *val) { 
    fLcutCosPoint[0] = val[0];
    fLcutCosPoint[1] = val[1];
  };
  void   SetLambdaCutDCA(Float_t *val){
    fLcutDCA[0] = val[0];
    fLcutDCA[1] = val[1];
  };
  void   SetLambdaCutVertexR(Float_t *val){
    fLcutVertexR[0] = val[0];
    fLcutVertexR[1] = val[1];
  };
  void   SetLambdaCutInvMass(Float_t *val){
    fLcutInvMass[0] = val[0];
    fLcutInvMass[1] = val[1];
  };
  

  Int_t  PreselectV0(AliESDv0* const v0);

  Bool_t CaseGamma(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN);
  Bool_t CaseK0(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN);
  Bool_t CaseLambda(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN, Int_t id);

  Bool_t V0CutsCommon(const AliESDv0 * const v0);
  Bool_t SingleTrackCuts(AliESDv0 * const v0);
  void   Armenteros(AliESDv0* const v0, Float_t val[2]);
  Bool_t CheckSigns(AliESDv0* const v0);

  Double_t PsiPair(AliESDv0* const v0);
  Bool_t   GetConvPosXY(AliESDtrack * const ptrack, AliESDtrack * const ntrack, Double_t convpos[2]);
  Bool_t   GetHelixCenter(AliESDtrack * const track, Double_t b, Int_t charge, Double_t center[2]);

 protected:
  void Copy(TObject &ref) const;

 private:

  AliKFParticle *CreateMotherParticle(const AliVTrack* const pdaughter, const AliVTrack* const ndaughter, Int_t pspec, Int_t nspec);
  void      SetCuts();                          // setup cuts for selected fMode and fType, see source file for details
  Bool_t    GammaEffCuts(AliESDv0 * const v0);  // set of cuts optimized for high gamma efficiency

 private:
  AliESDEvent           *fEvent;          // current event
  AliKFVertex           *fPrimaryVertex;  // primary vertex

  Int_t                 fType;            // data type: p-p or Pb-Pb
  Int_t                 fMode;            // current operation mode

  // single track cuts
  Int_t                 fTPCNcls;          // number of TPC clusters
  Bool_t                fTPCrefit;         // TPC refit - yes [kTRUE] or do not care [kFALSE]
  Float_t               fTPCchi2perCls;    // max. chi2 per TPC cluster
  Float_t               fTPCclsRatio;      // min. TPC cluster ratio
  Bool_t                fNoKinks;          // kinks - no [kTRUE] or do not care [kFalse]

  // gamma cut values
  Float_t               fGcutChi2NDF;      // Chi2NF cut value for the AliKFparticle gamma
  Float_t               fGcutCosPoint[2];  // cos of the pointing angle [min, max]
  Float_t               fGcutDCA[2];       // DCA between the daughter tracks [min, max]
  Float_t               fGcutVertexR[2];   // radius of the conversion point [min, max]
  Float_t               fGcutPsiPair[2];   // value of the psi pair cut [min, max]
  Float_t               fGcutInvMass;      // upper value on the gamma invariant mass
  // K0 cut values
  Float_t               fK0cutChi2NDF;     // Chi2NF cut value for the AliKFparticle K0
  Float_t               fK0cutCosPoint[2]; // cos of the pointing angle [min, max]
  Float_t               fK0cutDCA[2];      // DCA between the daughter tracks [min, max]
  Float_t               fK0cutVertexR[2];  // radius of the decay point [min, max]
  Float_t               fK0cutInvMass[2];  // invariant mass window
  // Lambda & anti-Lambda cut values
  Float_t               fLcutChi2NDF;      // Chi2NF cut value for the AliKFparticle K0
  Float_t               fLcutCosPoint[2];  // cos of the pointing angle [min, max]
  Float_t               fLcutDCA[2];       // DCA between the daughter tracks [min, max]
  Float_t               fLcutVertexR[2];   // radius of the decay point [min, max]
  Float_t               fLcutInvMass[2];   // invariant mass window
  
  
  ClassDef(AliESDv0KineCuts, 0);

};

#endif
Commit	Line	Data
27de2dfb	1	#ifndef ALIESDV0KINECUTS_H
	2	#define ALIESDV0KINECUTS_H
	3
3a72645a	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3a72645a	5	* See cxx source for full Copyright notice */
27de2dfb	6
	7	/* $Id$ */
	8
3a72645a	9	/*
	10	* plesae see source file for more details
	11	*/
3a72645a	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	};
3f6a07d9	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	};
3a72645a	40
	41	AliESDv0KineCuts();
	42	virtual ~AliESDv0KineCuts();
	43
	44	AliESDv0KineCuts(const AliESDv0KineCuts &ref);
	45	AliESDv0KineCuts &operator=(const AliESDv0KineCuts &ref);
	46
3f6a07d9	47	// main selection function - called once per V0 candidate
3a72645a	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
3f6a07d9	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
bf892a6a	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	};
3f6a07d9	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
bf892a6a	131
3f6a07d9	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);
3a72645a	137
3f6a07d9	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]);
3a72645a	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);
3f6a07d9	153	void SetCuts(); // setup cuts for selected fMode and fType, see source file for details
3f6a07d9	154	Bool_t GammaEffCuts(AliESDv0 * const v0); // set of cuts optimized for high gamma efficiency
3a72645a	155
3a72645a	156	private:
3a72645a	157	AliESDEvent *fEvent; // current event
	158	AliKFVertex *fPrimaryVertex; // primary vertex
	159
3f6a07d9	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
bf892a6a	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
3a72645a	191	ClassDef(AliESDv0KineCuts, 0);
	192
	193	};
	194
	195	#endif