[u/mrichter/AliRoot.git] / EMCAL / AliEMCALTracker.h

//========================================================================  
// Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.  
// See cxx source for full Copyright notice                                
//========================================================================  
//                       
//                       Class AliEMCALTracker 
//                      -----------------------
// Implementation of the track matching method between barrel tracks and
// EMCAL clusters.
// Besides algorithm implementation, some cuts are required to be set
// in order to define, for each track, an acceptance window where clusters
// are searched to find best match (if any).
// The class accepts as input an ESD container, and works directly on it,
// simply setting, for each of its tracks, the fEMCALindex flag, for each
// track which is matched to a cluster.
// In order to use method, one must launch PropagateBack().
//
// ------------------------------------------------------------------------
// author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
//=========================================================================

#ifndef ALIEMCALTRACKER_H
#define ALIEMCALTRACKER_H

#include "AliTracker.h"
#include <TMath.h>
#include <TVector3.h>
class TList;
class TTree;
class TObjArray;
class AliESDEvent;
class AliESDCaloCluster;
class AliEMCALTrack;
class AliEMCALRecPoint;
class AliEMCALGeometry;

class AliEMCALTracker : public AliTracker 
{
public:

	AliEMCALTracker();
	AliEMCALTracker(const AliEMCALTracker &t);
	AliEMCALTracker& operator=(const AliEMCALTracker &source);
	
	virtual ~AliEMCALTracker() {Clear();}
	
	virtual void        Clear(Option_t *option="ALL");
	virtual Int_t       Clusters2Tracks(AliESDEvent*) {return -1;}
	        void        InitParameters();
	virtual Int_t       LoadClusters(TTree*);
	        Int_t       LoadClusters(AliESDEvent* esd);
	        Int_t       LoadTracks(AliESDEvent* esd);
	virtual Int_t       PropagateBack(AliESDEvent* esd);
	virtual Int_t       RefitInward(AliESDEvent*) {return -1;}
	virtual void        UnloadClusters();
	virtual AliCluster* GetCluster(Int_t) const {return NULL;};
	TTree*              SearchTrueMatches();
	void                SetCorrection(Double_t rho, Double_t x0) {fRho=rho;fX0=x0;}
	void                SetCutAlpha(Double_t min, Double_t max) {fCutAlphaMin=min;fCutAlphaMax=max;}
	void                SetCutAngle(Double_t value) {fCutAngle=value;}
	void                SetCutX(Double_t value) {fCutX=value;}
	void                SetCutY(Double_t value) {fCutY=value;}
	void                SetCutZ(Double_t value) {fCutZ=value;}
	void                SetGeometry(AliEMCALGeometry *geom) {fGeom=geom;}
	void                SetMaxDistance(Double_t value) {fMaxDist=value;}
	void                SetCutNITS(Double_t value) {fCutNITS=value;}
	void                SetCutNTPC(Double_t value) {fCutNTPC=value;}
	void                SetNumberOfSteps(Int_t n) {fNPropSteps=n;if(!n)SetTrackCorrectionMode("NONE");}
	void                SetTrackCorrectionMode(Option_t *option);
        TVector3            FindExtrapolationPoint(Double_t x, Double_t y, Double_t z, AliESDtrack *track);

	enum {
		kUnmatched = -99999
	};
	
	class  AliEMCALMatchCluster : public TObject
	{
	public:
		AliEMCALMatchCluster(Int_t ID, AliEMCALRecPoint *recPoint);
		AliEMCALMatchCluster(Int_t ID, AliESDCaloCluster *caloCluster);
		virtual ~AliEMCALMatchCluster() { }
		//----------------------------------------------------------------------------
		Int_t     Index() const {return fIndex;}
		Int_t     Label() const {return fLabel;}
		Double_t  X() const {return fX;}
		Double_t  Y() const {return fY;} 
		Double_t  Z() const {return fZ;}
		Double_t   Phi() const {return TMath::ATan2(fY, fX);}
	private:
		Int_t     fIndex;  // index of cluster in its native container (ESD or TClonesArray)
		Int_t     fLabel;  // track label of assigned cluster
		Double_t  fX;      // global X position
		Double_t  fY;      // global Y position
		Double_t  fZ;      // global Z position
	};
	
	class  AliEMCALMatch : public TObject
	{
	public:
		AliEMCALMatch();
		AliEMCALMatch(const AliEMCALMatch& copy);
		virtual ~AliEMCALMatch() { }
		//----------------------------------------------------------------------------
		Bool_t&   CanBeSaved() {return fCanBeSaved;}
		Int_t     Compare(const TObject *obj) const;
		Double_t  GetDistance() const {return fDistance;}
		Double_t  GetPt() const {return fPt;}
		Int_t     GetIndexC() const {return fIndexC;}
		Int_t     GetIndexT() const {return fIndexT;}
		Bool_t    IsSortable() const {return kTRUE;}
		void      SetIndexC(Int_t icl) {fIndexC=icl;}
		void      SetIndexT(Int_t itr) {fIndexT=itr;}
		void      SetDistance(Double_t dist) {fDistance=dist;}
		void      SetPt(Double_t pt) {fPt=pt;}
	private:
		Bool_t     fCanBeSaved;  // when true, this match can be saved, otherwise it will not be
		Int_t      fIndexC;      // cluster index in 'fClusters' array
		Int_t      fIndexT;      // track index in 'fTracks' array
		Double_t   fDistance;    // track - cluster distance
		Double_t   fPt;          // track pt
	};

private:

	Double_t   AngleDiff(Double_t angle1, Double_t angle2);
	Double_t   CheckPair(AliEMCALTrack *tr, AliEMCALMatchCluster *cluster);
	Double_t   CheckPairV2(AliEMCALTrack *tr, AliEMCALMatchCluster *cluster);
	Double_t   CheckPairV3(AliEMCALTrack *tr, AliEMCALMatchCluster *cluster);
	Int_t      CreateMatches();
	Bool_t     PropagateToEMCAL(AliEMCALTrack *tr);
	Int_t      SolveCompetitions();
	
	enum ETrackCorr { 
		kTrackCorrNone  = 0, // do not correct for energy loss
		kTrackCorrMMB   = 1, // use MeanMaterialBudget() function to evaluate correction
		kTrackCorrFixed = 2  // use fixed "X0" and "rho" parameters to correct
	};
	
	Int_t       fNPropSteps;      // number of propagation steps (when correcting). If =0 no correction is done
	ETrackCorr  fTrackCorrMode;   // track correction mode
	
	Double_t    fCutX;		      // cut on X difference
	Double_t    fCutY;		      // cut on Y difference
	Double_t    fCutZ;		      // cut on Z difference
	Double_t    fCutAlphaMin;     // cut on difference between track 'alpha' and phi
	Double_t    fCutAlphaMax;     // cut on difference between track 'alpha' and phi
	Double_t    fCutAngle;        // cut on angle between track projection and cluster
	Double_t    fMaxDist;         // maximum allowed total distance between track proj an cluster
	Double_t fCutNITS;         // mimimum number of track hits in the ITS
	Double_t fCutNTPC;         // mimimum number of track hits in the TPC

	Double_t    fRho;             // energy correction: density
	Double_t    fX0;              // energy correction: radiation length

	TObjArray  *fTracks;          //! collection of tracks
	TObjArray  *fClusters;        //! collection of EMCAL clusters (ESDCaloCluster or EMCALRecPoint)
	TList      *fMatches;         //! collection of matches between tracks and clusters
	
	AliEMCALGeometry *fGeom;      //! EMCAL geometry
	
	ClassDef(AliEMCALTracker, 3)  // EMCAL "tracker"
};

#endif
Commit	Line	Data
fe17d4cb	1	//========================================================================
	2	// Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.
	3	// See cxx source for full Copyright notice
	4	//========================================================================
	5	//
	6	// Class AliEMCALTracker
	7	// -----------------------
	8	// Implementation of the track matching method between barrel tracks and
	9	// EMCAL clusters.
	10	// Besides algorithm implementation, some cuts are required to be set
	11	// in order to define, for each track, an acceptance window where clusters
	12	// are searched to find best match (if any).
	13	// The class accepts as input an ESD container, and works directly on it,
	14	// simply setting, for each of its tracks, the fEMCALindex flag, for each
	15	// track which is matched to a cluster.
	16	// In order to use method, one must launch PropagateBack().
	17	//
	18	// ------------------------------------------------------------------------
	19	// author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
	20	//=========================================================================
	21
	22	#ifndef ALIEMCALTRACKER_H
	23	#define ALIEMCALTRACKER_H
	24
	25	#include "AliTracker.h"
57fa24d9	26	#include <TMath.h>
57fa24d9	27	#include <TVector3.h>
fe17d4cb	28	class TList;
c61f0e70	29	class TTree;
fe17d4cb	30	class TObjArray;
af885e0f	31	class AliESDEvent;
fe17d4cb	32	class AliESDCaloCluster;
	33	class AliEMCALTrack;
	34	class AliEMCALRecPoint;
c61f0e70	35	class AliEMCALGeometry;
fe17d4cb	36
	37	class AliEMCALTracker : public AliTracker
	38	{
	39	public:
	40
	41	AliEMCALTracker();
	42	AliEMCALTracker(const AliEMCALTracker &t);
	43	AliEMCALTracker& operator=(const AliEMCALTracker &source);
	44
	45	virtual ~AliEMCALTracker() {Clear();}
	46
	47	virtual void Clear(Option_t *option="ALL");
af885e0f	48	virtual Int_t Clusters2Tracks(AliESDEvent*) {return -1;}
8ba062b1	49	void InitParameters();
fe17d4cb	50	virtual Int_t LoadClusters(TTree*);
af885e0f	51	Int_t LoadClusters(AliESDEvent* esd);
	52	Int_t LoadTracks(AliESDEvent* esd);
	53	virtual Int_t PropagateBack(AliESDEvent* esd);
	54	virtual Int_t RefitInward(AliESDEvent*) {return -1;}
fe17d4cb	55	virtual void UnloadClusters();
fe17d4cb	56	virtual AliCluster* GetCluster(Int_t) const {return NULL;};
c61f0e70	57	TTree* SearchTrueMatches();
fe17d4cb	58	void SetCorrection(Double_t rho, Double_t x0) {fRho=rho;fX0=x0;}
	59	void SetCutAlpha(Double_t min, Double_t max) {fCutAlphaMin=min;fCutAlphaMax=max;}
	60	void SetCutAngle(Double_t value) {fCutAngle=value;}
	61	void SetCutX(Double_t value) {fCutX=value;}
	62	void SetCutY(Double_t value) {fCutY=value;}
	63	void SetCutZ(Double_t value) {fCutZ=value;}
c61f0e70	64	void SetGeometry(AliEMCALGeometry *geom) {fGeom=geom;}
fe17d4cb	65	void SetMaxDistance(Double_t value) {fMaxDist=value;}
dcd86c5d	66	void SetCutNITS(Double_t value) {fCutNITS=value;}
dcd86c5d	67	void SetCutNTPC(Double_t value) {fCutNTPC=value;}
fe17d4cb	68	void SetNumberOfSteps(Int_t n) {fNPropSteps=n;if(!n)SetTrackCorrectionMode("NONE");}
fe17d4cb	69	void SetTrackCorrectionMode(Option_t *option);
04475328	70	TVector3 FindExtrapolationPoint(Double_t x, Double_t y, Double_t z, AliESDtrack *track);
04475328	71
c61f0e70	72	enum {
	73	kUnmatched = -99999
	74	};
	75
fe17d4cb	76	class AliEMCALMatchCluster : public TObject
	77	{
	78	public:
c61f0e70	79	AliEMCALMatchCluster(Int_t ID, AliEMCALRecPoint *recPoint);
	80	AliEMCALMatchCluster(Int_t ID, AliESDCaloCluster *caloCluster);
	81	virtual ~AliEMCALMatchCluster() { }
	82	//----------------------------------------------------------------------------
b9560ae2	83	Int_t Index() const {return fIndex;}
	84	Int_t Label() const {return fLabel;}
	85	Double_t X() const {return fX;}
	86	Double_t Y() const {return fY;}
	87	Double_t Z() const {return fZ;}
	88	Double_t Phi() const {return TMath::ATan2(fY, fX);}
fe17d4cb	89	private:
	90	Int_t fIndex; // index of cluster in its native container (ESD or TClonesArray)
	91	Int_t fLabel; // track label of assigned cluster
	92	Double_t fX; // global X position
	93	Double_t fY; // global Y position
	94	Double_t fZ; // global Z position
	95	};
	96
	97	class AliEMCALMatch : public TObject
	98	{
	99	public:
c61f0e70	100	AliEMCALMatch();
	101	AliEMCALMatch(const AliEMCALMatch& copy);
	102	virtual ~AliEMCALMatch() { }
	103	//----------------------------------------------------------------------------
fe17d4cb	104	Bool_t& CanBeSaved() {return fCanBeSaved;}
fe17d4cb	105	Int_t Compare(const TObject *obj) const;
b9560ae2	106	Double_t GetDistance() const {return fDistance;}
	107	Double_t GetPt() const {return fPt;}
	108	Int_t GetIndexC() const {return fIndexC;}
	109	Int_t GetIndexT() const {return fIndexT;}
fe17d4cb	110	Bool_t IsSortable() const {return kTRUE;}
	111	void SetIndexC(Int_t icl) {fIndexC=icl;}
	112	void SetIndexT(Int_t itr) {fIndexT=itr;}
	113	void SetDistance(Double_t dist) {fDistance=dist;}
c61f0e70	114	void SetPt(Double_t pt) {fPt=pt;}
fe17d4cb	115	private:
	116	Bool_t fCanBeSaved; // when true, this match can be saved, otherwise it will not be
	117	Int_t fIndexC; // cluster index in 'fClusters' array
	118	Int_t fIndexT; // track index in 'fTracks' array
	119	Double_t fDistance; // track - cluster distance
c61f0e70	120	Double_t fPt; // track pt
fe17d4cb	121	};
	122
	123	private:
	124
	125	Double_t AngleDiff(Double_t angle1, Double_t angle2);
	126	Double_t CheckPair(AliEMCALTrack tr, AliEMCALMatchCluster cluster);
	127	Double_t CheckPairV2(AliEMCALTrack tr, AliEMCALMatchCluster cluster);
c61f0e70	128	Double_t CheckPairV3(AliEMCALTrack tr, AliEMCALMatchCluster cluster);
fe17d4cb	129	Int_t CreateMatches();
c61f0e70	130	Bool_t PropagateToEMCAL(AliEMCALTrack *tr);
fe17d4cb	131	Int_t SolveCompetitions();
	132
	133	enum ETrackCorr {
	134	kTrackCorrNone = 0, // do not correct for energy loss
	135	kTrackCorrMMB = 1, // use MeanMaterialBudget() function to evaluate correction
	136	kTrackCorrFixed = 2 // use fixed "X0" and "rho" parameters to correct
	137	};
	138
	139	Int_t fNPropSteps; // number of propagation steps (when correcting). If =0 no correction is done
	140	ETrackCorr fTrackCorrMode; // track correction mode
	141
	142	Double_t fCutX; // cut on X difference
	143	Double_t fCutY; // cut on Y difference
	144	Double_t fCutZ; // cut on Z difference
	145	Double_t fCutAlphaMin; // cut on difference between track 'alpha' and phi
	146	Double_t fCutAlphaMax; // cut on difference between track 'alpha' and phi
	147	Double_t fCutAngle; // cut on angle between track projection and cluster
	148	Double_t fMaxDist; // maximum allowed total distance between track proj an cluster
dcd86c5d	149	Double_t fCutNITS; // mimimum number of track hits in the ITS
	150	Double_t fCutNTPC; // mimimum number of track hits in the TPC
	151
fe17d4cb	152	Double_t fRho; // energy correction: density
	153	Double_t fX0; // energy correction: radiation length
	154
c61f0e70	155	TObjArray *fTracks; //! collection of tracks
fe17d4cb	156	TObjArray *fClusters; //! collection of EMCAL clusters (ESDCaloCluster or EMCALRecPoint)
	157	TList *fMatches; //! collection of matches between tracks and clusters
	158
c61f0e70	159	AliEMCALGeometry *fGeom; //! EMCAL geometry
c61f0e70	160
ba6de5ea	161	ClassDef(AliEMCALTracker, 3) // EMCAL "tracker"
fe17d4cb	162	};
	163
	164	#endif