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

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

/* $Id$ */

//-------------------------------------------------------------------------
//     AOD calorimeter cluster class (for PHOS and EMCAL)
//     Author: Markus Oldenburg, CERN, 
//             Gustavo Conesa, INFN
//-------------------------------------------------------------------------

#include "AliAODCluster.h"

#include <TRefArray.h>
#include <TArrayS.h>

class TLorentzVector;

class AliAODCaloCluster : public AliAODCluster {

 public:
  
  AliAODCaloCluster();
  AliAODCaloCluster(Int_t id,
		    UInt_t nLabel,
		    Int_t *label,
		    Double_t energy,
		    Double_t x[3],
		    Double_t pid[13],
		    Char_t ttype=kUndef,
		    UInt_t selectInfo=0);
  
  AliAODCaloCluster(Int_t id,
		    UInt_t nLabel,
		    Int_t *label,
		    Float_t energy,
		    Float_t x[3],
		    Float_t pid[13],
		    Char_t ttype=kUndef,
		    UInt_t selectInfo=0);
  
  virtual ~AliAODCaloCluster();
  AliAODCaloCluster(const AliAODCaloCluster& clus); 
  AliAODCaloCluster& operator=(const AliAODCaloCluster& clus);

  
  // getters
  Double_t GetDistToBadChannel() const { return fDistToBadChannel; }
  Double_t GetDispersion() const { return fDispersion; }
  Double_t GetM20() const { return fM20; }
  Double_t GetM02() const { return fM02; }
  Double_t GetEmcCpvDistance() const { return fEmcCpvDistance; }
  UShort_t GetNExMax() const { return fNExMax; }
  Double_t GetTOF() const { return fTOF; }

  Int_t    GetNTracksMatched() const { return fTracksMatched.GetEntriesFast(); }
  TObject *GetTrackMatched(Int_t i) const { return fTracksMatched.At(i); }
 
  void  SetNCells(Int_t n) { fNCells = n;}
  Int_t GetNCells() const   { return fNCells;}
  
  void SetCellsAbsId(UShort_t *array);
  UShort_t *GetCellsAbsId() {return  fCellsAbsId;}
  
  void SetCellsAmplitudeFraction(Double32_t *array);
  Double32_t *GetCellsAmplitudeFraction() {return  fCellsAmpFraction;}
  
  Int_t GetCellAbsId(Int_t i) const {  
    if (fCellsAbsId && i >=0 && i < fNCells ) return fCellsAbsId[i];    
    else return -1;}
  
  Double_t GetCellAmplitudeFraction(Int_t i) const {  
    if (fCellsAmpFraction && i >=0 && i < fNCells ) return fCellsAmpFraction[i];    
    else return -1;}

  // setters
  void SetDistToBadChannel(Double_t dist) { fDistToBadChannel = dist; }
  void SetDispersion(Double_t disp) { fDispersion = disp; }
  void SetM20(Double_t m20) { fM20 = m20; }
  void SetM02(Double_t m02) { fM02 = m02; }
  void SetEmcCpvDistance(Double_t emcCpvDist) { fEmcCpvDistance = emcCpvDist; }
  void SetNExMax(UShort_t nExMax) { fNExMax = nExMax; }
  void SetTOF(Double_t tof) { fTOF = tof; }

  void SetCaloCluster(Double_t dist = -999., 
		      Double_t disp = -1., 
		      Double_t m20 = 0., 
		      Double_t m02 = 0., 
		      Double_t emcCpvDist = -999., 
		      UShort_t nExMax = 0, 
		      Double_t tof = 0.) 
  {
    fDistToBadChannel = dist;
    fDispersion = disp;
    fM20 = m20;
    fM02 = m02;
    fEmcCpvDistance = emcCpvDist;
    fNExMax = nExMax;
    fTOF = tof ;
  }
  
  void GetMomentum(TLorentzVector& p, Double_t * vertexPosition );

  void AddTrackMatched(TObject *trk) { fTracksMatched.Add(trk); }
  void RemoveTrackMatched(TObject *trk) { fTracksMatched.Remove(trk); }
  Bool_t HasTrackMatched(TObject *trk) const;

 private :

  Double32_t   fDistToBadChannel; // Distance to nearest bad channel
  Double32_t   fDispersion;       // cluster dispersion, for shape analysis
  Double32_t   fM20;              // 2-nd moment along the main eigen axis
  Double32_t   fM02;              // 2-nd moment along the second eigen axis
  Double32_t   fEmcCpvDistance;   // the distance from PHOS EMC rec.point to the closest CPV rec.point
  UShort_t     fNExMax;           // number of (Ex-)maxima before unfolding
  Double32_t fTOF;        ////[0,0,12] time-of-flight

  TRefArray    fTracksMatched;    // references to tracks close to cluster. First entry is the most likely match.

  Int_t       fNCells ;
  UShort_t   *fCellsAbsId;        //[fNCells] array of cell absId numbers
  Double32_t *fCellsAmpFraction;  //[fNCells][0.,1.,16] array with cell amplitudes fraction.

  ClassDef(AliAODCaloCluster,5);
};

#endif
Commit	Line	Data
fa86343a	1	#ifndef AliAODCaloCluster_H
	2	#define AliAODCaloCluster_H
	3	/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	//-------------------------------------------------------------------------
	9	// AOD calorimeter cluster class (for PHOS and EMCAL)
	10	// Author: Markus Oldenburg, CERN,
	11	// Gustavo Conesa, INFN
	12	//-------------------------------------------------------------------------
	13
	14	#include "AliAODCluster.h"
	15
	16	#include <TRefArray.h>
	17	#include <TArrayS.h>
	18
78902954	19	class TLorentzVector;
78902954	20
fa86343a	21	class AliAODCaloCluster : public AliAODCluster {
	22
	23	public:
	24
	25	AliAODCaloCluster();
	26	AliAODCaloCluster(Int_t id,
	27	UInt_t nLabel,
	28	Int_t *label,
	29	Double_t energy,
	30	Double_t x[3],
83dd7da3	31	Double_t pid[13],
fa86343a	32	Char_t ttype=kUndef,
	33	UInt_t selectInfo=0);
	34
	35	AliAODCaloCluster(Int_t id,
	36	UInt_t nLabel,
	37	Int_t *label,
	38	Float_t energy,
	39	Float_t x[3],
83dd7da3	40	Float_t pid[13],
fa86343a	41	Char_t ttype=kUndef,
	42	UInt_t selectInfo=0);
	43
	44	virtual ~AliAODCaloCluster();
	45	AliAODCaloCluster(const AliAODCaloCluster& clus);
	46	AliAODCaloCluster& operator=(const AliAODCaloCluster& clus);
	47
	48
	49	// getters
	50	Double_t GetDistToBadChannel() const { return fDistToBadChannel; }
	51	Double_t GetDispersion() const { return fDispersion; }
	52	Double_t GetM20() const { return fM20; }
fa86343a	53	Double_t GetM02() const { return fM02; }
fa86343a	54	Double_t GetEmcCpvDistance() const { return fEmcCpvDistance; }
fa86343a	55	UShort_t GetNExMax() const { return fNExMax; }
78902954	56	Double_t GetTOF() const { return fTOF; }
fa86343a	57
	58	Int_t GetNTracksMatched() const { return fTracksMatched.GetEntriesFast(); }
	59	TObject *GetTrackMatched(Int_t i) const { return fTracksMatched.At(i); }
e649177a	60
1f66a186	61	void SetNCells(Int_t n) { fNCells = n;}
1f66a186	62	Int_t GetNCells() const { return fNCells;}
e649177a	63
1b54b5a3	64	void SetCellsAbsId(UShort_t *array);
e649177a	65	UShort_t *GetCellsAbsId() {return fCellsAbsId;}
e649177a	66
1b54b5a3	67	void SetCellsAmplitudeFraction(Double32_t *array);
e649177a	68	Double32_t *GetCellsAmplitudeFraction() {return fCellsAmpFraction;}
	69
	70	Int_t GetCellAbsId(Int_t i) const {
	71	if (fCellsAbsId && i >=0 && i < fNCells ) return fCellsAbsId[i];
	72	else return -1;}
	73
	74	Double_t GetCellAmplitudeFraction(Int_t i) const {
	75	if (fCellsAmpFraction && i >=0 && i < fNCells ) return fCellsAmpFraction[i];
	76	else return -1;}
fa86343a	77
	78	// setters
	79	void SetDistToBadChannel(Double_t dist) { fDistToBadChannel = dist; }
	80	void SetDispersion(Double_t disp) { fDispersion = disp; }
	81	void SetM20(Double_t m20) { fM20 = m20; }
fa86343a	82	void SetM02(Double_t m02) { fM02 = m02; }
fa86343a	83	void SetEmcCpvDistance(Double_t emcCpvDist) { fEmcCpvDistance = emcCpvDist; }
fa86343a	84	void SetNExMax(UShort_t nExMax) { fNExMax = nExMax; }
78902954	85	void SetTOF(Double_t tof) { fTOF = tof; }
fa86343a	86
	87	void SetCaloCluster(Double_t dist = -999.,
	88	Double_t disp = -1.,
	89	Double_t m20 = 0.,
fa86343a	90	Double_t m02 = 0.,
fa86343a	91	Double_t emcCpvDist = -999.,
78902954	92	UShort_t nExMax = 0,
78902954	93	Double_t tof = 0.)
fa86343a	94	{
	95	fDistToBadChannel = dist;
	96	fDispersion = disp;
	97	fM20 = m20;
fa86343a	98	fM02 = m02;
fa86343a	99	fEmcCpvDistance = emcCpvDist;
fa86343a	100	fNExMax = nExMax;
78902954	101	fTOF = tof ;
fa86343a	102	}
78902954	103
78902954	104	void GetMomentum(TLorentzVector& p, Double_t * vertexPosition );
fa86343a	105
	106	void AddTrackMatched(TObject *trk) { fTracksMatched.Add(trk); }
	107	void RemoveTrackMatched(TObject *trk) { fTracksMatched.Remove(trk); }
	108	Bool_t HasTrackMatched(TObject *trk) const;
	109
	110	private :
	111
	112	Double32_t fDistToBadChannel; // Distance to nearest bad channel
	113	Double32_t fDispersion; // cluster dispersion, for shape analysis
	114	Double32_t fM20; // 2-nd moment along the main eigen axis
fa86343a	115	Double32_t fM02; // 2-nd moment along the second eigen axis
fa86343a	116	Double32_t fEmcCpvDistance; // the distance from PHOS EMC rec.point to the closest CPV rec.point
fa86343a	117	UShort_t fNExMax; // number of (Ex-)maxima before unfolding
78902954	118	Double32_t fTOF; ////[0,0,12] time-of-flight
fa86343a	119
fa86343a	120	TRefArray fTracksMatched; // references to tracks close to cluster. First entry is the most likely match.
e649177a	121
a89e9566	122	Int_t fNCells ;
	123	UShort_t *fCellsAbsId; //[fNCells] array of cell absId numbers
	124	Double32_t *fCellsAmpFraction; //[fNCells][0.,1.,16] array with cell amplitudes fraction.
fa86343a	125
78902954	126	ClassDef(AliAODCaloCluster,5);
fa86343a	127	};
	128
	129	#endif