[u/mrichter/AliRoot.git] / PWG3 / vertexingHF / AliAODRecoDecayHF.h

#ifndef ALIAODRECODECAYHF_H
#define ALIAODRECODECAYHF_H
/* Copyright(c) 1998-2006, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */ 

//***********************************************************
// Class AliAODRecoDecayHF
// base class for AOD reconstructed heavy-flavour decays
// Author: A.Dainese, andrea.dainese@lnl.infn.it
//***********************************************************

#include <TRef.h>
#include <TList.h>
#include "AliAODTrack.h"
#include "AliAODRecoDecay.h"

class AliAODEvent;
class AliRDHFCuts;
class AliKFParticle;

class AliAODRecoDecayHF : public AliAODRecoDecay {

 public:

  AliAODRecoDecayHF();
  AliAODRecoDecayHF(AliAODVertex *vtx2,Int_t nprongs,Short_t charge,
		    Double_t *px,Double_t *py,Double_t *pz,
		    Double_t *d0,Double_t *d0err);
  AliAODRecoDecayHF(AliAODVertex *vtx2,Int_t nprongs,Short_t charge,
		    Double_t *d0,Double_t *d0err);
  AliAODRecoDecayHF(Double_t vtx1[3],Double_t vtx2[3],
		    Int_t nprongs,Short_t charge,
		    Double_t *px,Double_t *py,Double_t *pz,Double_t *d0);
  virtual ~AliAODRecoDecayHF();

  AliAODRecoDecayHF(const AliAODRecoDecayHF& source);
  AliAODRecoDecayHF& operator=(const AliAODRecoDecayHF& source); 
   

  // primary vertex
  void SetPrimaryVtxRef(TObject *vtx) { fEventPrimaryVtx = vtx; }
  AliAODVertex* GetPrimaryVtxRef() const { return (AliAODVertex*)(fEventPrimaryVtx.GetObject()); }
  void SetOwnPrimaryVtx(const AliAODVertex *vtx) { UnsetOwnPrimaryVtx(); fOwnPrimaryVtx = new AliAODVertex(*vtx);}
  void CheckOwnPrimaryVtx() const 
    {if(!fOwnPrimaryVtx) printf("fOwnPrimaryVtx not set"); return;}
  AliAODVertex* GetOwnPrimaryVtx() const {return fOwnPrimaryVtx;}
  void GetOwnPrimaryVtx(Double_t vtx[3]) const 
    {CheckOwnPrimaryVtx();fOwnPrimaryVtx->GetPosition(vtx);}
  void UnsetOwnPrimaryVtx() {if(fOwnPrimaryVtx) {delete fOwnPrimaryVtx; fOwnPrimaryVtx=0;} return;}
  AliAODVertex* GetPrimaryVtx() const { return (GetOwnPrimaryVtx() ? GetOwnPrimaryVtx() : GetPrimaryVtxRef()); }
  AliAODVertex* RemoveDaughtersFromPrimaryVtx(AliAODEvent *aod);  
  void          RecalculateImpPars(AliAODVertex *vtxAODNew,AliAODEvent *aod);


  // kinematics & topology
  Double_t DecayLength2() const 
    { return AliAODRecoDecay::DecayLength2(GetPrimaryVtx());}
  Double_t DecayLength() const 
    { return AliAODRecoDecay::DecayLength(GetPrimaryVtx());}
  Double_t DecayLengthError() const 
    { return AliAODRecoDecay::DecayLengthError(GetPrimaryVtx());}
  Double_t NormalizedDecayLength() const 
    { return AliAODRecoDecay::NormalizedDecayLength(GetPrimaryVtx());}
  Double_t NormalizedDecayLength2() const 
    { return AliAODRecoDecay::NormalizedDecayLength2(GetPrimaryVtx());}
  Double_t DecayLengthXY() const 
    { return AliAODRecoDecay::DecayLengthXY(GetPrimaryVtx());}
  Double_t DecayLengthXYError() const 
    { return AliAODRecoDecay::DecayLengthXYError(GetPrimaryVtx());}
  Double_t NormalizedDecayLengthXY() const 
    { return AliAODRecoDecay::NormalizedDecayLengthXY(GetPrimaryVtx());}
  Double_t Ct(UInt_t pdg) const 
    { return AliAODRecoDecay::Ct(pdg,GetPrimaryVtx());}
  Double_t CosPointingAngle() const 
    { return AliAODRecoDecay::CosPointingAngle(GetPrimaryVtx());}
  Double_t CosPointingAngleXY() const 
    { return AliAODRecoDecay::CosPointingAngleXY(GetPrimaryVtx());}
  Double_t ImpParXY() const 
    { return AliAODRecoDecay::ImpParXY(GetPrimaryVtx());}
  Double_t QtProngFlightLine(Int_t ip) const 
    { return AliAODRecoDecay::QtProngFlightLine(ip,GetPrimaryVtx());}
  Double_t QlProngFlightLine(Int_t ip) const 
    { return AliAODRecoDecay::QlProngFlightLine(ip,GetPrimaryVtx());}

  // prongs
  Double_t Getd0errProng(Int_t ip) const {return fd0err[ip];}
  void     Setd0errProngs(Int_t nprongs,Double_t *d0);
  Double_t Normalizedd0Prong(Int_t ip) const 
    {return Getd0Prong(ip)/Getd0errProng(ip);}
  
  void SetProngIDs(Int_t nIDs,UShort_t *id);
  UShort_t GetProngID(Int_t ip) const 
    {if(fProngID) {return fProngID[ip];} else {return 9999;}}

  // ITS clustermap for daughters
  Bool_t DaughterHasPointOnITSLayer(Int_t dg,Int_t l) const;

  // check if it is like-sign
  Bool_t IsLikeSign() const;

  // list of cuts
  void SetListOfCutsRef(TObject *obj) {fListOfCuts=obj;}
  TList *GetListOfCuts() const {return (TList*)(fListOfCuts.GetObject());}
  AliRDHFCuts *GetCuts(const char* name) const;

  // vertexing KF:
  AliKFParticle *ApplyVertexingKF(Int_t *iprongs,Int_t nprongs,Int_t *pdgs,
				 Bool_t topoCostraint,Double_t bzkG,
				 Double_t *mass) const;
  
  // misalign
  void Misalign(TString misal="null");

  // selection map
  void    SetSelectionBit(Int_t i) {SETBIT(fSelectionMap,i); return;}
  Bool_t  HasSelectionBit(Int_t i) const {return TESTBIT(fSelectionMap,i);}
  ULong_t GetSelectionMap() const {return fSelectionMap;}

  Int_t   NumberOfFakeDaughters() const;

  Bool_t  HasBadDaughters() const; // TPC+ITS tracks not passing the StandardCuts2010 with loose DCA

 protected:

  AliAODVertex *fOwnPrimaryVtx; // primary vertex for this candidate
  TRef          fEventPrimaryVtx; // ref to primary vertex of the event
  TRef          fListOfCuts;  // ref to the list of analysis cuts
  Double_t     *fd0err;  //[fNProngs] error on prongs rphi impact param [cm]
  UShort_t     *fProngID;  //[fNProngs] track ID of daughters
  ULong_t       fSelectionMap; // used to store outcome of selection in AliAnalysisVertexingHF

  ClassDef(AliAODRecoDecayHF,5)  // base class for AOD reconstructed heavy-flavour decays
};

inline void AliAODRecoDecayHF::SetProngIDs(Int_t nIDs,UShort_t *id) 
{
  if(nIDs!=GetNProngs()) { 
    printf("Wrong number of IDs, must be nProngs\n");
    return;
  }
  if(fProngID) delete [] fProngID;
  fProngID = new UShort_t[nIDs];
  for(Int_t i=0;i<nIDs;i++) 
    fProngID[i] = id[i]; 
  return;
}

inline Bool_t AliAODRecoDecayHF::IsLikeSign() const
{
  // check if it is like-sign

  Int_t ndg=GetNDaughters();
  if(!ndg) {
    printf("Daughters not available\n");
    return kFALSE;
  }
  Int_t chargeDg0 = ((AliAODTrack*)GetDaughter(0))->Charge();

  for(Int_t i=1; i<ndg; i++) {
    if(chargeDg0!=((AliAODTrack*)GetDaughter(i))->Charge()) return kFALSE;
  }

  return kTRUE;
}

inline AliRDHFCuts *AliAODRecoDecayHF::GetCuts(const char* name) const
{ 
  // returns the analysis cuts

  TList *list = GetListOfCuts();
  if(!list) return 0;


  return (AliRDHFCuts*)list->FindObject(name);
}

inline Bool_t AliAODRecoDecayHF::DaughterHasPointOnITSLayer(Int_t dg,Int_t l) const
{
  // ITS clustermap for daughters

  if(l<0 || l>5) {
    printf("ERROR: layer has to be in the range 0-5\n");
    return kFALSE;
  }
  AliAODTrack *t = (AliAODTrack*)GetDaughter(dg);
  if(!t) return kFALSE;

  return TESTBIT(t->GetITSClusterMap(),l);
}

inline Int_t AliAODRecoDecayHF::NumberOfFakeDaughters() const 
{
  // Count number of daughters with negative label

  Int_t nfakes=0;
  for(Int_t i=0; i<GetNDaughters(); i++) {
    AliAODTrack *track=(AliAODTrack*)GetDaughter(i);

    if(track->Charge()==0) { // this is a two prong decay
      AliAODRecoDecay *rd=(AliAODRecoDecay*)GetDaughter(i);
      for(Int_t j=0; j<rd->GetNDaughters(); j++) {
	AliAODTrack *track2=(AliAODTrack*)GetDaughter(j);
	if(track2->GetLabel()<0) nfakes++;
      }
      continue;
    }

    if(track->GetLabel()<0) nfakes++;
  }
  return nfakes;
}

inline void AliAODRecoDecayHF::Setd0errProngs(Int_t nprongs,Double_t *d0err) 
{
  if(nprongs!=GetNProngs()) { 
    printf("Wrong number of momenta, must be nProngs");
    return;
  }
  if(!fd0) {
    fd0err = new Double32_t[nprongs];
  }
  for(Int_t i=0;i<nprongs;i++) {
    fd0err[i] = d0err[i]; 
  }

  return;
}

inline Bool_t AliAODRecoDecayHF::HasBadDaughters() const {

  // checks if at least one of ITS+TPC daughters didn't pass the StandardCuts2010 with loose DCA (ie doesn't have the BIT(4) set)

  for(Int_t iDau=0; iDau<GetNDaughters(); iDau++){
    AliAODTrack* at=(AliAODTrack*)GetDaughter(iDau);
    if(at->Charge()==0) continue;
    if(at->GetTPCNcls()==0) continue;
    if(!(at->TestFilterMask(BIT(4)))) return kTRUE;
  }
  return kFALSE;
}


#endif
Commit	Line	Data
3244eeed	1	#ifndef ALIAODRECODECAYHF_H
	2	#define ALIAODRECODECAYHF_H
	3	/* Copyright(c) 1998-2006, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
27de2dfb	6	/* $Id$ */
27de2dfb	7
3244eeed	8	//***********************************************************
	9	// Class AliAODRecoDecayHF
	10	// base class for AOD reconstructed heavy-flavour decays
	11	// Author: A.Dainese, andrea.dainese@lnl.infn.it
	12	//***********************************************************
	13
460cd990	14	#include <TRef.h>
a9b75906	15	#include <TList.h>
ac7797a7	16	#include "AliAODTrack.h"
3244eeed	17	#include "AliAODRecoDecay.h"
3244eeed	18
ead561f0	19	class AliAODEvent;
a9b75906	20	class AliRDHFCuts;
ec653946	21	class AliKFParticle;
ec653946	22
3244eeed	23	class AliAODRecoDecayHF : public AliAODRecoDecay {
	24
	25	public:
	26
	27	AliAODRecoDecayHF();
	28	AliAODRecoDecayHF(AliAODVertex *vtx2,Int_t nprongs,Short_t charge,
	29	Double_t px,Double_t py,Double_t *pz,
	30	Double_t d0,Double_t d0err);
	31	AliAODRecoDecayHF(AliAODVertex *vtx2,Int_t nprongs,Short_t charge,
	32	Double_t d0,Double_t d0err);
b39168f9	33	AliAODRecoDecayHF(Double_t vtx1[3],Double_t vtx2[3],
	34	Int_t nprongs,Short_t charge,
	35	Double_t px,Double_t py,Double_t pz,Double_t d0);
3244eeed	36	virtual ~AliAODRecoDecayHF();
	37
	38	AliAODRecoDecayHF(const AliAODRecoDecayHF& source);
	39	AliAODRecoDecayHF& operator=(const AliAODRecoDecayHF& source);
	40
	41
	42	// primary vertex
460cd990	43	void SetPrimaryVtxRef(TObject *vtx) { fEventPrimaryVtx = vtx; }
	44	AliAODVertex* GetPrimaryVtxRef() const { return (AliAODVertex*)(fEventPrimaryVtx.GetObject()); }
	45	void SetOwnPrimaryVtx(const AliAODVertex vtx) { UnsetOwnPrimaryVtx(); fOwnPrimaryVtx = new AliAODVertex(vtx);}
3244eeed	46	void CheckOwnPrimaryVtx() const
	47	{if(!fOwnPrimaryVtx) printf("fOwnPrimaryVtx not set"); return;}
	48	AliAODVertex* GetOwnPrimaryVtx() const {return fOwnPrimaryVtx;}
	49	void GetOwnPrimaryVtx(Double_t vtx[3]) const
	50	{CheckOwnPrimaryVtx();fOwnPrimaryVtx->GetPosition(vtx);}
0a65d33f	51	void UnsetOwnPrimaryVtx() {if(fOwnPrimaryVtx) {delete fOwnPrimaryVtx; fOwnPrimaryVtx=0;} return;}
460cd990	52	AliAODVertex* GetPrimaryVtx() const { return (GetOwnPrimaryVtx() ? GetOwnPrimaryVtx() : GetPrimaryVtxRef()); }
ead561f0	53	AliAODVertex* RemoveDaughtersFromPrimaryVtx(AliAODEvent *aod);
70841bf2	54	void RecalculateImpPars(AliAODVertex vtxAODNew,AliAODEvent aod);
ead561f0	55
3244eeed	56
3244eeed	57	// kinematics & topology
fcf73952	58	Double_t DecayLength2() const
fcf73952	59	{ return AliAODRecoDecay::DecayLength2(GetPrimaryVtx());}
3244eeed	60	Double_t DecayLength() const
460cd990	61	{ return AliAODRecoDecay::DecayLength(GetPrimaryVtx());}
3244eeed	62	Double_t DecayLengthError() const
460cd990	63	{ return AliAODRecoDecay::DecayLengthError(GetPrimaryVtx());}
3244eeed	64	Double_t NormalizedDecayLength() const
460cd990	65	{ return AliAODRecoDecay::NormalizedDecayLength(GetPrimaryVtx());}
be9cad0c	66	Double_t NormalizedDecayLength2() const
be9cad0c	67	{ return AliAODRecoDecay::NormalizedDecayLength2(GetPrimaryVtx());}
3244eeed	68	Double_t DecayLengthXY() const
460cd990	69	{ return AliAODRecoDecay::DecayLengthXY(GetPrimaryVtx());}
3244eeed	70	Double_t DecayLengthXYError() const
460cd990	71	{ return AliAODRecoDecay::DecayLengthXYError(GetPrimaryVtx());}
3244eeed	72	Double_t NormalizedDecayLengthXY() const
460cd990	73	{ return AliAODRecoDecay::NormalizedDecayLengthXY(GetPrimaryVtx());}
3244eeed	74	Double_t Ct(UInt_t pdg) const
460cd990	75	{ return AliAODRecoDecay::Ct(pdg,GetPrimaryVtx());}
3244eeed	76	Double_t CosPointingAngle() const
460cd990	77	{ return AliAODRecoDecay::CosPointingAngle(GetPrimaryVtx());}
3244eeed	78	Double_t CosPointingAngleXY() const
460cd990	79	{ return AliAODRecoDecay::CosPointingAngleXY(GetPrimaryVtx());}
3244eeed	80	Double_t ImpParXY() const
460cd990	81	{ return AliAODRecoDecay::ImpParXY(GetPrimaryVtx());}
3244eeed	82	Double_t QtProngFlightLine(Int_t ip) const
460cd990	83	{ return AliAODRecoDecay::QtProngFlightLine(ip,GetPrimaryVtx());}
3244eeed	84	Double_t QlProngFlightLine(Int_t ip) const
460cd990	85	{ return AliAODRecoDecay::QlProngFlightLine(ip,GetPrimaryVtx());}
3244eeed	86
	87	// prongs
	88	Double_t Getd0errProng(Int_t ip) const {return fd0err[ip];}
ed6324e5	89	void Setd0errProngs(Int_t nprongs,Double_t *d0);
3244eeed	90	Double_t Normalizedd0Prong(Int_t ip) const
	91	{return Getd0Prong(ip)/Getd0errProng(ip);}
	92
6185d025	93	void SetProngIDs(Int_t nIDs,UShort_t *id);
6185d025	94	UShort_t GetProngID(Int_t ip) const
dcb444c9	95	{if(fProngID) {return fProngID[ip];} else {return 9999;}}
6185d025	96
ac7797a7	97	// ITS clustermap for daughters
	98	Bool_t DaughterHasPointOnITSLayer(Int_t dg,Int_t l) const;
	99
27917274	100	// check if it is like-sign
27917274	101	Bool_t IsLikeSign() const;
3244eeed	102
a9b75906	103	// list of cuts
	104	void SetListOfCutsRef(TObject *obj) {fListOfCuts=obj;}
	105	TList GetListOfCuts() const {return (TList)(fListOfCuts.GetObject());}
	106	AliRDHFCuts GetCuts(const char name) const;
ec653946	107
	108	// vertexing KF:
	109	AliKFParticle ApplyVertexingKF(Int_t iprongs,Int_t nprongs,Int_t *pdgs,
	110	Bool_t topoCostraint,Double_t bzkG,
	111	Double_t *mass) const;
	112
15c6df42	113	// misalign
	114	void Misalign(TString misal="null");
	115
939850df	116	// selection map
	117	void SetSelectionBit(Int_t i) {SETBIT(fSelectionMap,i); return;}
	118	Bool_t HasSelectionBit(Int_t i) const {return TESTBIT(fSelectionMap,i);}
	119	ULong_t GetSelectionMap() const {return fSelectionMap;}
	120
79a848cd	121	Int_t NumberOfFakeDaughters() const;
79a848cd	122
2034c937	123	Bool_t HasBadDaughters() const; // TPC+ITS tracks not passing the StandardCuts2010 with loose DCA
2034c937	124
3244eeed	125	protected:
	126
	127	AliAODVertex *fOwnPrimaryVtx; // primary vertex for this candidate
460cd990	128	TRef fEventPrimaryVtx; // ref to primary vertex of the event
a9b75906	129	TRef fListOfCuts; // ref to the list of analysis cuts
6185d025	130	Double_t *fd0err; //[fNProngs] error on prongs rphi impact param [cm]
6185d025	131	UShort_t *fProngID; //[fNProngs] track ID of daughters
939850df	132	ULong_t fSelectionMap; // used to store outcome of selection in AliAnalysisVertexingHF
3244eeed	133
939850df	134	ClassDef(AliAODRecoDecayHF,5) // base class for AOD reconstructed heavy-flavour decays
3244eeed	135	};
3244eeed	136
6185d025	137	inline void AliAODRecoDecayHF::SetProngIDs(Int_t nIDs,UShort_t *id)
	138	{
	139	if(nIDs!=GetNProngs()) {
	140	printf("Wrong number of IDs, must be nProngs\n");
	141	return;
	142	}
	143	if(fProngID) delete [] fProngID;
	144	fProngID = new UShort_t[nIDs];
	145	for(Int_t i=0;i<nIDs;i++)
	146	fProngID[i] = id[i];
	147	return;
	148	}
	149
27917274	150	inline Bool_t AliAODRecoDecayHF::IsLikeSign() const
	151	{
	152	// check if it is like-sign
	153
	154	Int_t ndg=GetNDaughters();
	155	if(!ndg) {
	156	printf("Daughters not available\n");
	157	return kFALSE;
	158	}
	159	Int_t chargeDg0 = ((AliAODTrack*)GetDaughter(0))->Charge();
	160
	161	for(Int_t i=1; i<ndg; i++) {
	162	if(chargeDg0!=((AliAODTrack*)GetDaughter(i))->Charge()) return kFALSE;
	163	}
	164
	165	return kTRUE;
	166	}
	167
a9b75906	168	inline AliRDHFCuts AliAODRecoDecayHF::GetCuts(const char name) const
	169	{
	170	// returns the analysis cuts
	171
	172	TList *list = GetListOfCuts();
	173	if(!list) return 0;
	174
	175
	176	return (AliRDHFCuts*)list->FindObject(name);
	177	}
	178
ac7797a7	179	inline Bool_t AliAODRecoDecayHF::DaughterHasPointOnITSLayer(Int_t dg,Int_t l) const
	180	{
	181	// ITS clustermap for daughters
	182
	183	if(l<0 \|\| l>5) {
	184	printf("ERROR: layer has to be in the range 0-5\n");
	185	return kFALSE;
	186	}
	187	AliAODTrack t = (AliAODTrack)GetDaughter(dg);
	188	if(!t) return kFALSE;
	189
	190	return TESTBIT(t->GetITSClusterMap(),l);
	191	}
	192
79a848cd	193	inline Int_t AliAODRecoDecayHF::NumberOfFakeDaughters() const
	194	{
	195	// Count number of daughters with negative label
	196
	197	Int_t nfakes=0;
	198	for(Int_t i=0; i<GetNDaughters(); i++) {
	199	AliAODTrack track=(AliAODTrack)GetDaughter(i);
	200
	201	if(track->Charge()==0) { // this is a two prong decay
	202	AliAODRecoDecay rd=(AliAODRecoDecay)GetDaughter(i);
	203	for(Int_t j=0; j<rd->GetNDaughters(); j++) {
	204	AliAODTrack track2=(AliAODTrack)GetDaughter(j);
	205	if(track2->GetLabel()<0) nfakes++;
	206	}
	207	continue;
	208	}
	209
	210	if(track->GetLabel()<0) nfakes++;
	211	}
	212	return nfakes;
	213	}
	214
ed6324e5	215	inline void AliAODRecoDecayHF::Setd0errProngs(Int_t nprongs,Double_t *d0err)
	216	{
	217	if(nprongs!=GetNProngs()) {
	218	printf("Wrong number of momenta, must be nProngs");
	219	return;
	220	}
	221	if(!fd0) {
	222	fd0err = new Double32_t[nprongs];
	223	}
	224	for(Int_t i=0;i<nprongs;i++) {
	225	fd0err[i] = d0err[i];
	226	}
	227
	228	return;
	229	}
	230
2034c937	231	inline Bool_t AliAODRecoDecayHF::HasBadDaughters() const {
	232
	233	// checks if at least one of ITS+TPC daughters didn't pass the StandardCuts2010 with loose DCA (ie doesn't have the BIT(4) set)
	234
	235	for(Int_t iDau=0; iDau<GetNDaughters(); iDau++){
	236	AliAODTrack* at=(AliAODTrack*)GetDaughter(iDau);
	237	if(at->Charge()==0) continue;
	238	if(at->GetTPCNcls()==0) continue;
	239	if(!(at->TestFilterMask(BIT(4)))) return kTRUE;
	240	}
	241	return kFALSE;
	242	}
	243
	244
3244eeed	245	#endif
27917274	246