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

#ifndef ALIESDCALOCLUSTER_H
#define ALIESDCALOCLUSTER_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */
/* $Id$ */
/* $Log $ */

//-------------------------------------------------------------------------
//                          Class AliESDCaloCluster
//   This is the class to deal with during the physics analysis of data
//
//   New container for calorimeter clusters, which are the effective 
//   "tracks" for calorimeter detectors.  Can be used by PHOS and EMCAL
//
//     J.L. Klay (LLNL)
//-------------------------------------------------------------------------

#include <AliVCluster.h>
#include "AliPID.h"
#include "TArrayS.h"
#include "TArrayI.h"
#include "AliLog.h"

class TLorentzVector;

class AliESDCaloCluster : public AliVCluster 
{
  
 public:
  
  AliESDCaloCluster();
  AliESDCaloCluster(const AliESDCaloCluster& clus);
  AliESDCaloCluster & operator=(const AliESDCaloCluster& source);
  virtual ~AliESDCaloCluster();
  virtual void Copy(TObject &) const;
  
  void  SetID(Int_t id) {fID = id;}
  Int_t GetID() const {return fID;}
  
  void   SetType(Char_t type) { fClusterType = type; }
  Char_t GetType() const {return fClusterType; }
  
  Bool_t IsEMCAL() const {if(fClusterType == kEMCALClusterv1) return kTRUE; else return kFALSE;}
  Bool_t IsPHOS()  const {if(fClusterType == kPHOSNeutral || fClusterType == kPHOSCharged) return kTRUE;
    else return kFALSE;}
  
  void GetPosition  (Float_t *x) const {
    x[0]=fGlobalPos[0]; x[1]=fGlobalPos[1]; x[2]=fGlobalPos[2];}
  void SetPosition  (Float_t *x);
  void SetPositionAt(Float_t pos, Int_t ipos) {if(ipos>=0 && ipos<3) fGlobalPos[ipos] = pos ; 
    else AliInfo(Form("Bad index for position array, i = %d\n",ipos));}
  
  void  SetE(Double_t ene) { fEnergy = ene;}
  Double_t E() const       { return fEnergy;}
  
  void     SetDispersion(Double_t disp)  { fDispersion = disp; }
  Double_t GetDispersion() const         { return fDispersion; }
  
  void  SetChi2(Double_t chi2)  { fChi2 = chi2; }
  Double_t Chi2() const         { return fChi2; }
  
  const Double_t *GetPID() const { return fPID; }
  //for(Int_t i=0; i<AliPID::kSPECIESN; ++i) pid[i]=fPID[i];}
  void SetPID  (const Float_t *pid) ;
  void SetPIDAt(Float_t p, Int_t i) {if(i>=0 && i<AliPID::kSPECIESN) fPID[i] = p ; 
    else AliInfo(Form("Bad index for PID array, i = %d \n",i));}
  
  void     SetM20(Double_t m20) { fM20 = m20; }
  Double_t GetM20() const       { return fM20; }
  
  void     SetM02(Double_t m02) { fM02 = m02; }
  Double_t GetM02() const       { return fM02; }
  
  void    SetNExMax(UChar_t nExMax) { fNExMax = nExMax; }
  UChar_t GetNExMax() const         { return fNExMax; }
  
  void SetEmcCpvDistance(Double_t dEmcCpv) { fEmcCpvDistance = dEmcCpv; }
  Double_t GetEmcCpvDistance() const       { return fEmcCpvDistance; }
  void SetTrackDistance(Double_t dx, Double_t dz){fTrackDx=dx; fTrackDz=dz;}
  Double_t GetTrackDx(void)const {return fTrackDx;}
  Double_t GetTrackDz(void)const {return fTrackDz;}
  
  void     SetDistanceToBadChannel(Double_t dist) {fDistToBadChannel=dist;}
  Double_t GetDistanceToBadChannel() const        {return fDistToBadChannel;}
  
  void     SetTOF(Double_t tof) { fTOF = tof; }
  Double_t GetTOF() const       { return fTOF; }
  
  void AddTracksMatched(TArrayI & array)  { 
    if(!fTracksMatched)fTracksMatched   = new TArrayI(array);
    else *fTracksMatched = array;
  }
  void AddLabels(TArrayI & array)         { 
    if(!fLabels)fLabels = new TArrayI(array) ; 
    else *fLabels = array;
  }
  
  TArrayI * GetTracksMatched() const  {return  fTracksMatched;}
  TArrayI * GetLabelsArray() const    {return  fLabels;}
  Int_t   * GetLabels() const         {return  fLabels->GetArray();}

  Int_t GetTrackMatchedIndex() const   
  {if( fTracksMatched &&  fTracksMatched->GetSize() >0)  return  fTracksMatched->At(0); 
    else return -1;} //Most likely the track associated to the cluster
  
  Int_t GetLabel() const   {
    if( fLabels &&  fLabels->GetSize() >0)  return  fLabels->At(0); 
    else return -1;} //Most likely the track associated to the cluster
  Int_t GetLabelAt(UInt_t i) const {
    if (fLabels && i < (UInt_t)fLabels->GetSize()) return fLabels->At(i);
    else return -999; }
  
  Int_t GetNTracksMatched() const { if (fTracksMatched) return  fTracksMatched->GetSize(); 
    else return -1;}
  UInt_t GetNLabels() const       { if (fLabels) return  fLabels->GetSize(); 
    else return -1;}
  
  void GetMomentum(TLorentzVector& p, Double_t * vertexPosition );
  
  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;}
  
 protected:
  
  TArrayI * fTracksMatched; //Index of tracks close to cluster. First entry is the most likely match.
  TArrayI * fLabels;        //list of primaries that generated the cluster, ordered in deposited energy.
  
  Int_t        fNCells ;
  UShort_t   * fCellsAbsId;       //[fNCells] array of cell absId numbers
  Double32_t * fCellsAmpFraction; //[fNCells][0.,1.,16] array with cell amplitudes fraction.
  
  Double32_t   fGlobalPos[3];     // position in global coordinate systemD
  Double32_t   fEnergy;           // energy measured by calorimeter
  Double32_t   fDispersion;       // cluster dispersion, for shape analysis
  Double32_t   fChi2;             // chi2 of cluster fi
  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
  Double32_t   fTrackDx ;         // Distance to closest track in phi
  Double32_t   fTrackDz ;         // Distance to closest track in z
  
  Double32_t   fDistToBadChannel; // Distance to nearest bad channel
  Double32_t   fPID[AliPID::kSPECIESN]; //[0,1,8]"detector response  probabilities" (for the PID)
  Int_t        fID;                // Unique Id of the cluster
  UChar_t      fNExMax ;           // number of (Ex-)maxima before unfolding  
  Char_t       fClusterType;       // Flag for different cluster type/versions
  Double_t     fTOF;               //[0,0,12] time-of-flight
  
  
  ClassDef(AliESDCaloCluster,11)  //ESDCaloCluster 

    };

#endif
Commit	Line	Data
85c60a8e	1	#ifndef ALIESDCALOCLUSTER_H
	2	#define ALIESDCALOCLUSTER_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
85c60a8e	5	/* $Id$ */
	6	/* $Log $ */
	7
	8	//-------------------------------------------------------------------------
	9	// Class AliESDCaloCluster
	10	// This is the class to deal with during the physics analysis of data
	11	//
	12	// New container for calorimeter clusters, which are the effective
	13	// "tracks" for calorimeter detectors. Can be used by PHOS and EMCAL
	14	//
	15	// J.L. Klay (LLNL)
	16	//-------------------------------------------------------------------------
	17
c8fe2783	18	#include <AliVCluster.h>
85c60a8e	19	#include "AliPID.h"
5efdec54	20	#include "TArrayS.h"
4dd59c4a	21	#include "TArrayI.h"
c8fe2783	22	#include "AliLog.h"
85c60a8e	23
bab0b5f0	24	class TLorentzVector;
85c60a8e	25
c8fe2783	26	class AliESDCaloCluster : public AliVCluster
e649177a	27	{
c8fe2783	28
	29	public:
	30
85c60a8e	31	AliESDCaloCluster();
85c60a8e	32	AliESDCaloCluster(const AliESDCaloCluster& clus);
fe12e09c	33	AliESDCaloCluster & operator=(const AliESDCaloCluster& source);
85c60a8e	34	virtual ~AliESDCaloCluster();
732a24fe	35	virtual void Copy(TObject &) const;
c8fe2783	36
c8fe2783	37	void SetID(Int_t id) {fID = id;}
85c60a8e	38	Int_t GetID() const {return fID;}
c8fe2783	39
	40	void SetType(Char_t type) { fClusterType = type; }
	41	Char_t GetType() const {return fClusterType; }
	42
	43	Bool_t IsEMCAL() const {if(fClusterType == kEMCALClusterv1) return kTRUE; else return kFALSE;}
	44	Bool_t IsPHOS() const {if(fClusterType == kPHOSNeutral \|\| fClusterType == kPHOSCharged) return kTRUE;
	45	else return kFALSE;}
	46
	47	void GetPosition (Float_t *x) const {
	48	x[0]=fGlobalPos[0]; x[1]=fGlobalPos[1]; x[2]=fGlobalPos[2];}
	49	void SetPosition (Float_t *x);
	50	void SetPositionAt(Float_t pos, Int_t ipos) {if(ipos>=0 && ipos<3) fGlobalPos[ipos] = pos ;
	51	else AliInfo(Form("Bad index for position array, i = %d\n",ipos));}
	52
	53	void SetE(Double_t ene) { fEnergy = ene;}
	54	Double_t E() const { return fEnergy;}
	55
	56	void SetDispersion(Double_t disp) { fDispersion = disp; }
	57	Double_t GetDispersion() const { return fDispersion; }
	58
	59	void SetChi2(Double_t chi2) { fChi2 = chi2; }
	60	Double_t Chi2() const { return fChi2; }
	61
	62	const Double_t *GetPID() const { return fPID; }
	63	//for(Int_t i=0; i<AliPID::kSPECIESN; ++i) pid[i]=fPID[i];}
	64	void SetPID (const Float_t *pid) ;
	65	void SetPIDAt(Float_t p, Int_t i) {if(i>=0 && i<AliPID::kSPECIESN) fPID[i] = p ;
	66	else AliInfo(Form("Bad index for PID array, i = %d \n",i));}
	67
	68	void SetM20(Double_t m20) { fM20 = m20; }
	69	Double_t GetM20() const { return fM20; }
	70
	71	void SetM02(Double_t m02) { fM02 = m02; }
	72	Double_t GetM02() const { return fM02; }
	73
	74	void SetNExMax(UChar_t nExMax) { fNExMax = nExMax; }
	75	UChar_t GetNExMax() const { return fNExMax; }
	76
	77	void SetEmcCpvDistance(Double_t dEmcCpv) { fEmcCpvDistance = dEmcCpv; }
8ada0ffe	78	Double_t GetEmcCpvDistance() const { return fEmcCpvDistance; }
f1cedef3	79	void SetTrackDistance(Double_t dx, Double_t dz){fTrackDx=dx; fTrackDz=dz;}
	80	Double_t GetTrackDx(void)const {return fTrackDx;}
	81	Double_t GetTrackDz(void)const {return fTrackDz;}
c8fe2783	82
	83	void SetDistanceToBadChannel(Double_t dist) {fDistToBadChannel=dist;}
	84	Double_t GetDistanceToBadChannel() const {return fDistToBadChannel;}
	85
	86	void SetTOF(Double_t tof) { fTOF = tof; }
	87	Double_t GetTOF() const { return fTOF; }
78902954	88
85005d58	89	void AddTracksMatched(TArrayI & array) {
	90	if(!fTracksMatched)fTracksMatched = new TArrayI(array);
	91	else *fTracksMatched = array;
	92	}
	93	void AddLabels(TArrayI & array) {
	94	if(!fLabels)fLabels = new TArrayI(array) ;
	95	else *fLabels = array;
c8fe2783	96	}
78902954	97
4dd59c4a	98	TArrayI * GetTracksMatched() const {return fTracksMatched;}
c8fe2783	99	TArrayI * GetLabelsArray() const {return fLabels;}
	100	Int_t * GetLabels() const {return fLabels->GetArray();}
	101
	102	Int_t GetTrackMatchedIndex() const
5efdec54	103	{if( fTracksMatched && fTracksMatched->GetSize() >0) return fTracksMatched->At(0);
5efdec54	104	else return -1;} //Most likely the track associated to the cluster
c8fe2783	105
	106	Int_t GetLabel() const {
	107	if( fLabels && fLabels->GetSize() >0) return fLabels->At(0);
5efdec54	108	else return -1;} //Most likely the track associated to the cluster
c8fe2783	109	Int_t GetLabelAt(UInt_t i) const {
	110	if (fLabels && i < (UInt_t)fLabels->GetSize()) return fLabels->At(i);
	111	else return -999; }
78902954	112
c8fe2783	113	Int_t GetNTracksMatched() const { if (fTracksMatched) return fTracksMatched->GetSize();
5efdec54	114	else return -1;}
c8fe2783	115	UInt_t GetNLabels() const { if (fLabels) return fLabels->GetSize();
5efdec54	116	else return -1;}
c8fe2783	117
5efdec54	118	void GetMomentum(TLorentzVector& p, Double_t * vertexPosition );
c8fe2783	119
c8fe2783	120	void SetNCells(Int_t n) { fNCells = n;}
0fdeb120	121	Int_t GetNCells() const { return fNCells;}
e649177a	122
c8fe2783	123	void SetCellsAbsId(UShort_t *array) ;
e649177a	124	UShort_t *GetCellsAbsId() {return fCellsAbsId;}
e649177a	125
c8fe2783	126	void SetCellsAmplitudeFraction(Double32_t *array) ;
e649177a	127	Double32_t *GetCellsAmplitudeFraction() {return fCellsAmpFraction;}
	128
	129	Int_t GetCellAbsId(Int_t i) const {
	130	if (fCellsAbsId && i >=0 && i < fNCells ) return fCellsAbsId[i];
	131	else return -1;}
	132
	133	Double_t GetCellAmplitudeFraction(Int_t i) const {
	134	if (fCellsAmpFraction && i >=0 && i < fNCells ) return fCellsAmpFraction[i];
	135	else return -1;}
c8fe2783	136
	137	protected:
	138
4dd59c4a	139	TArrayI * fTracksMatched; //Index of tracks close to cluster. First entry is the most likely match.
c8fe2783	140	TArrayI * fLabels; //list of primaries that generated the cluster, ordered in deposited energy.
	141
	142	Int_t fNCells ;
	143	UShort_t * fCellsAbsId; //[fNCells] array of cell absId numbers
	144	Double32_t * fCellsAmpFraction; //[fNCells][0.,1.,16] array with cell amplitudes fraction.
	145
8ada0ffe	146	Double32_t fGlobalPos[3]; // position in global coordinate systemD
	147	Double32_t fEnergy; // energy measured by calorimeter
	148	Double32_t fDispersion; // cluster dispersion, for shape analysis
	149	Double32_t fChi2; // chi2 of cluster fi
	150	Double32_t fM20; // 2-nd moment along the main eigen axis
	151	Double32_t fM02; // 2-nd moment along the second eigen axis
c8fe2783	152
8ada0ffe	153	Double32_t fEmcCpvDistance; // the distance from PHOS EMC rec.point to the closest CPV rec.point
f1cedef3	154	Double32_t fTrackDx ; // Distance to closest track in phi
f1cedef3	155	Double32_t fTrackDz ; // Distance to closest track in z
c8fe2783	156
8ada0ffe	157	Double32_t fDistToBadChannel; // Distance to nearest bad channel
8ada0ffe	158	Double32_t fPID[AliPID::kSPECIESN]; //[0,1,8]"detector response probabilities" (for the PID)
c8fe2783	159	Int_t fID; // Unique Id of the cluster
	160	UChar_t fNExMax ; // number of (Ex-)maxima before unfolding
	161	Char_t fClusterType; // Flag for different cluster type/versions
	162	Double_t fTOF; //[0,0,12] time-of-flight
	163
	164
	165	ClassDef(AliESDCaloCluster,11) //ESDCaloCluster
8ada0ffe	166
c8fe2783	167	};
85c60a8e	168
	169	#endif
	170
c8fe2783	171