[u/mrichter/AliRoot.git] / ITS / AliITSVertexerTracks.h

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


//-------------------------------------------------------
// Class for primary vertex determination with ITS tracks
//
//   Origin: A.Dainese, Padova, andrea.dainese@pd.infn.it
//           M.Masera,  Torino, massimo.masera@to.infn.it 
//-------------------------------------------------------

/*****************************************************************************
 *                                                                           *
 * This class determines the primary vertex position using ITS tracks.       *
 * This is done in two steps:                                                *
 * 1) Vertex Finding: a reasonable estimate of the vertex position is        *
 *    obtained from a mean of "points of closest approach" between all       *
 *    possible pairs of tracks.                                              *
 * 2) Vertex Fitting: once tracks are propagated to the position given by    *
 *    first step, the optimal estimate of the position of vertex is obtained *
 *    from a weighted average of the track positions. A covariance           *
 *    matrix and a chi2 for the vertex are given.                            *
 *                                                                           *
 *****************************************************************************/
#include "AliITSVertexer.h"

#include <TObjArray.h>

class TTree; 
class AliESDVertex; 
class AliVertex; 
class AliESD;
class AliITStrackV2;

class AliITSVertexerTracks : public AliITSVertexer {
  
 public:
  // default constructor
  AliITSVertexerTracks(); 
  // standard constructor     
  AliITSVertexerTracks(TFile *inFile,TFile *outFile,
	               Int_t fEv=0,Int_t lEv=0,
		       Double_t xStart=0.,Double_t yStart=0.);
  // alternative constructor
  AliITSVertexerTracks(TString fn,Double_t xStart=0,Double_t yStart=0); 
  // destructor
  virtual ~AliITSVertexerTracks();
  // return vertex from the set of tracks in the tree
  AliESDVertex* VertexOnTheFly(TTree &trkTree);
  AliVertex* VertexForSelectedTracks(AliESD *esdEvent,Int_t nofCand, Int_t *trkPos, Int_t opt);
  // computes the vertex for the current event
  virtual AliESDVertex* FindPrimaryVertexForCurrentEvent(Int_t evnumb);
  virtual AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb){
    Warning(" FindVertexForCurrentEvent","Deprecated method use FindPrimaryVertexForCurrentEvent instead");
    return FindPrimaryVertexForCurrentEvent(evnumb);
  }
  // computes the vertex for the current event using the ESD
  AliESDVertex*         FindPrimaryVertexForCurrentEvent(AliESD *esdEvent);
  AliESDVertex*         FindVertexForCurrentEvent(AliESD *esdEvent){
    Warning(" FindVertexForCurrentEvent","Deprecated method use FindPrimaryVertexForCurrentEvent instead");
    return FindPrimaryVertexForCurrentEvent(esdEvent);
  }
  // computes the vertex for each event and stores it on file
  virtual void  FindVertices();
  // computes the vertex for each event and stores it in the ESD
  void FindVerticesESD();


  virtual void  PrintStatus() const;
  void  SetMinTracks(Int_t n=2) { fMinTracks = n; return; }
  void  SetSkipTracks(Int_t n,Int_t *skipped); 
  void  SetVtxStart(Double_t x=0,Double_t y=0) 
    { fNominalPos[0]=x; fNominalPos[1]=y; return; }
  
 private:
    // copy constructor (NO copy allowed: the constructor is protected
    // to avoid misuse)
    AliITSVertexerTracks(const AliITSVertexerTracks& vtxr);
    // assignment operator (NO assignment allowed)
    AliITSVertexerTracks& operator=(const AliITSVertexerTracks& /* vtxr */);
  TFile    *fInFile;          // input file (with tracks)
  TFile    *fOutFile;         // output file for vertices
  Double_t  fNominalPos[2];   // initial knowledge on vertex position
  Int_t     fMinTracks;       // minimum number of tracks
  Double_t  fMaxChi2PerTrack; // maximum contribition to the chi2 
  TObjArray fTrkArray;        // array with tracks to be processed
  Int_t     *fTrksToSkip;     // tracks to be skipped for find and fit 
  Int_t     fNTrksToSkip;     // number of tracks to be skipped 

  Bool_t   CheckField() const; 
  void     ComputeMaxChi2PerTrack(Int_t nTracks);
  Int_t    PrepareTracks(TTree &trkTree);
  Int_t    PrepareTracks(AliESD* esdEvent,Int_t NofCand, Int_t *TrkPos);
  Double_t Prepare(AliITStrackV2* itstrack);
  void     TooFewTracks();
  //  void     VertexFinder(Int_t OptUseWeights=0);
  void     VertexFitter();

  ClassDef(AliITSVertexerTracks,3) // 3D Vertexing with ITS tracks 
};

#endif
Commit	Line	Data
	1	#ifndef ALIITSVERTEXERTRACKS_H
	2	#define ALIITSVERTEXERTRACKS_H
	3	/* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6
	7	//-------------------------------------------------------
	8	// Class for primary vertex determination with ITS tracks
	9	//
	10	// Origin: A.Dainese, Padova, andrea.dainese@pd.infn.it
	11	// M.Masera, Torino, massimo.masera@to.infn.it
	12	//-------------------------------------------------------
	13
	14	/*****************************************************************************
	15	* *
	16	* This class determines the primary vertex position using ITS tracks. *
	17	* This is done in two steps: *
	18	* 1) Vertex Finding: a reasonable estimate of the vertex position is *
	19	* obtained from a mean of "points of closest approach" between all *
	20	* possible pairs of tracks. *
	21	* 2) Vertex Fitting: once tracks are propagated to the position given by *
	22	* first step, the optimal estimate of the position of vertex is obtained *
	23	* from a weighted average of the track positions. A covariance *
	24	* matrix and a chi2 for the vertex are given. *
	25	* *
	26	*****************************************************************************/
	27	#include "AliITSVertexer.h"
	28
	29	#include <TObjArray.h>
	30
	31	class TTree;
	32	class AliESDVertex;
	33	class AliVertex;
	34	class AliESD;
	35	class AliITStrackV2;
	36
	37	class AliITSVertexerTracks : public AliITSVertexer {
	38
	39	public:
	40	// default constructor
	41	AliITSVertexerTracks();
	42	// standard constructor
	43	AliITSVertexerTracks(TFile inFile,TFile outFile,
	44	Int_t fEv=0,Int_t lEv=0,
	45	Double_t xStart=0.,Double_t yStart=0.);
	46	// alternative constructor
	47	AliITSVertexerTracks(TString fn,Double_t xStart=0,Double_t yStart=0);
	48	// destructor
	49	virtual ~AliITSVertexerTracks();
	50	// return vertex from the set of tracks in the tree
	51	AliESDVertex* VertexOnTheFly(TTree &trkTree);
	52	AliVertex* VertexForSelectedTracks(AliESD esdEvent,Int_t nofCand, Int_t trkPos, Int_t opt);
	53	// computes the vertex for the current event
	54	virtual AliESDVertex* FindPrimaryVertexForCurrentEvent(Int_t evnumb);
	55	virtual AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb){
	56	Warning(" FindVertexForCurrentEvent","Deprecated method use FindPrimaryVertexForCurrentEvent instead");
	57	return FindPrimaryVertexForCurrentEvent(evnumb);
	58	}
	59	// computes the vertex for the current event using the ESD
	60	AliESDVertex* FindPrimaryVertexForCurrentEvent(AliESD *esdEvent);
	61	AliESDVertex* FindVertexForCurrentEvent(AliESD *esdEvent){
	62	Warning(" FindVertexForCurrentEvent","Deprecated method use FindPrimaryVertexForCurrentEvent instead");
	63	return FindPrimaryVertexForCurrentEvent(esdEvent);
	64	}
	65	// computes the vertex for each event and stores it on file
	66	virtual void FindVertices();
	67	// computes the vertex for each event and stores it in the ESD
	68	void FindVerticesESD();
	69
	70
	71	virtual void PrintStatus() const;
	72	void SetMinTracks(Int_t n=2) { fMinTracks = n; return; }
	73	void SetSkipTracks(Int_t n,Int_t *skipped);
	74	void SetVtxStart(Double_t x=0,Double_t y=0)
	75	{ fNominalPos[0]=x; fNominalPos[1]=y; return; }
	76
	77	private:
	78	// copy constructor (NO copy allowed: the constructor is protected
	79	// to avoid misuse)
	80	AliITSVertexerTracks(const AliITSVertexerTracks& vtxr);
	81	// assignment operator (NO assignment allowed)
	82	AliITSVertexerTracks& operator=(const AliITSVertexerTracks& /* vtxr */);
	83	TFile *fInFile; // input file (with tracks)
	84	TFile *fOutFile; // output file for vertices
	85	Double_t fNominalPos[2]; // initial knowledge on vertex position
	86	Int_t fMinTracks; // minimum number of tracks
	87	Double_t fMaxChi2PerTrack; // maximum contribition to the chi2
	88	TObjArray fTrkArray; // array with tracks to be processed
	89	Int_t *fTrksToSkip; // tracks to be skipped for find and fit
	90	Int_t fNTrksToSkip; // number of tracks to be skipped
	91
	92	Bool_t CheckField() const;
	93	void ComputeMaxChi2PerTrack(Int_t nTracks);
	94	Int_t PrepareTracks(TTree &trkTree);
	95	Int_t PrepareTracks(AliESD* esdEvent,Int_t NofCand, Int_t *TrkPos);
	96	Double_t Prepare(AliITStrackV2* itstrack);
	97	void TooFewTracks();
	98	// void VertexFinder(Int_t OptUseWeights=0);
	99	void VertexFitter();
	100
	101	ClassDef(AliITSVertexerTracks,3) // 3D Vertexing with ITS tracks
	102	};
	103
	104	#endif
	105
	106
	107