[u/mrichter/AliRoot.git] / STEER / AliVertexer.h

#ifndef ALIVERTEXER_H
#define ALIVERTEXER_H

///////////////////////////////////////////////////////////////////
//                                                               //
// Base class for primary vertex reconstruction                  //
//                                                               //
///////////////////////////////////////////////////////////////////

#include<TObject.h>

class TTree;
class AliESDVertex;
class AliMultiplicity;


class AliVertexer : public TObject {

 public:
    // default constructor
    AliVertexer();  
 
    // destructor
    virtual ~AliVertexer();
    // computes the vertex for the current event
    virtual AliESDVertex* FindVertexForCurrentEvent(TTree *clustersTree)=0; 
    // computes the vertex for each event and stores it on file
    AliMultiplicity* GetMultiplicity() const {return fMult;}
    virtual void PrintStatus() const = 0;
    void SetVtxStart(Double_t x,Double_t y,Double_t z) 
      { fNominalPos[0]=x; fNominalPos[1]=y; fNominalPos[2]=z; }
    void SetVtxStartSigma(Double_t sx,Double_t sy,Double_t sz) 
      { fNominalCov[0]=sx*sx; fNominalCov[2]=sy*sy; fNominalCov[5]=sz*sz;
      fNominalCov[1]=0.; fNominalCov[3]=0.; fNominalCov[4]=0.; }
    void SetVtxStart(AliESDVertex *vtx);
    // the following method can be implemented in daughter classes 
    // (e.g. in AliITSVertexer3D). It is intended to tag pile-up events
    // novertices is the total number of vertices (1 means no pileup)
    // The returned pointer points to an array of AliESDVertx opbjects
    // with size=novertices
    virtual  AliESDVertex* GetAllVertices(Int_t &novertices) const {novertices = 0; return NULL;}
    const Double_t* GetNominalPos() const {return fNominalPos;}

 protected:
    AliESDVertex *fCurrentVertex; //! pointer to the current vertex
    AliMultiplicity *fMult;     //! Multiplicity object
 
 private:
    // copy constructor (NO copy allowed: the constructor is protected
    // to avoid misuse)
    AliVertexer(const AliVertexer& vtxr);
    // assignment operator (NO assignment allowed)
    AliVertexer& operator=(const AliVertexer& /* vtxr */);

    Double_t  fNominalPos[3];   // initial knowledge on vertex position
    Double_t  fNominalCov[6];   // initial knowledge on vertex position

  ClassDef(AliVertexer,4);
};

#endif
Commit	Line	Data
	1	#ifndef ALIVERTEXER_H
	2	#define ALIVERTEXER_H
	3
	4	///////////////////////////////////////////////////////////////////
	5	// //
	6	// Base class for primary vertex reconstruction //
	7	// //
	8	///////////////////////////////////////////////////////////////////
	9
	10	#include<TObject.h>
	11
	12	class TTree;
	13	class AliESDVertex;
	14	class AliMultiplicity;
	15
	16
	17	class AliVertexer : public TObject {
	18
	19	public:
	20	// default constructor
	21	AliVertexer();
	22
	23	// destructor
	24	virtual ~AliVertexer();
	25	// computes the vertex for the current event
	26	virtual AliESDVertex* FindVertexForCurrentEvent(TTree *clustersTree)=0;
	27	// computes the vertex for each event and stores it on file
	28	AliMultiplicity* GetMultiplicity() const {return fMult;}
	29	virtual void PrintStatus() const = 0;
	30	void SetVtxStart(Double_t x,Double_t y,Double_t z)
	31	{ fNominalPos[0]=x; fNominalPos[1]=y; fNominalPos[2]=z; }
	32	void SetVtxStartSigma(Double_t sx,Double_t sy,Double_t sz)
	33	{ fNominalCov[0]=sxsx; fNominalCov[2]=sysy; fNominalCov[5]=sz*sz;
	34	fNominalCov[1]=0.; fNominalCov[3]=0.; fNominalCov[4]=0.; }
	35	void SetVtxStart(AliESDVertex *vtx);
	36	// the following method can be implemented in daughter classes
	37	// (e.g. in AliITSVertexer3D). It is intended to tag pile-up events
	38	// novertices is the total number of vertices (1 means no pileup)
	39	// The returned pointer points to an array of AliESDVertx opbjects
	40	// with size=novertices
	41	virtual AliESDVertex* GetAllVertices(Int_t &novertices) const {novertices = 0; return NULL;}
	42	const Double_t* GetNominalPos() const {return fNominalPos;}
	43
	44	protected:
	45	AliESDVertex *fCurrentVertex; //! pointer to the current vertex
	46	AliMultiplicity *fMult; //! Multiplicity object
	47
	48	private:
	49	// copy constructor (NO copy allowed: the constructor is protected
	50	// to avoid misuse)
	51	AliVertexer(const AliVertexer& vtxr);
	52	// assignment operator (NO assignment allowed)
	53	AliVertexer& operator=(const AliVertexer& /* vtxr */);
	54
	55	Double_t fNominalPos[3]; // initial knowledge on vertex position
	56	Double_t fNominalCov[6]; // initial knowledge on vertex position
	57
	58	ClassDef(AliVertexer,4);
	59	};
	60
	61	#endif