Bug corrected.
[u/mrichter/AliRoot.git] / STEER / AliESDCaloCluster.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17 /* $Log $ */
18
19 //-----------------------------------------------------------------
20 //           Implementation of the ESD Calorimeter cluster class
21 //   ESD = Event Summary Data
22 //   This is the class to deal with during the phisics analysis of data
23 //
24 //   J.L. Klay (LLNL)
25 //-----------------------------------------------------------------
26
27 #include <TLorentzVector.h>
28 #include "AliESDCaloCluster.h"
29
30 ClassImp(AliESDCaloCluster)
31
32 //_______________________________________________________________________
33 AliESDCaloCluster::AliESDCaloCluster() : 
34   AliVCluster(),
35   fTracksMatched(0x0),
36   fLabels(0x0),
37   fNCells(0),
38   fCellsAbsId(0x0),
39   fCellsAmpFraction(0x0),
40   fEnergy(0),
41   fDispersion(0),
42   fChi2(0),
43   fM20(0),
44   fM02(0),
45   fEmcCpvDistance(1024),
46   fTrackDx(1024),fTrackDz(1024),
47   fDistToBadChannel(1024),
48   fID(0),
49   fNExMax(0),
50   fClusterType(kUndef), fTOF(0.)
51 {
52   //
53   // The default ESD constructor 
54   //
55   fGlobalPos[0] = fGlobalPos[1] = fGlobalPos[2] = 0.;
56   for(Int_t i=0; i<AliPID::kSPECIESN; i++) fPID[i] = 0.;
57 }
58
59 //_______________________________________________________________________
60 AliESDCaloCluster::AliESDCaloCluster(const AliESDCaloCluster& clus) : 
61   AliVCluster(clus),
62   fTracksMatched(clus.fTracksMatched?new TArrayI(*clus.fTracksMatched):0x0),
63   fLabels(clus.fLabels?new TArrayI(*clus.fLabels):0x0),
64   fNCells(clus.fNCells),
65   fCellsAbsId(),
66   fCellsAmpFraction(),
67   fEnergy(clus.fEnergy),
68   fDispersion(clus.fDispersion),
69   fChi2(clus.fChi2),
70   fM20(clus.fM20),
71   fM02(clus.fM02),
72   fEmcCpvDistance(clus.fEmcCpvDistance),
73   fTrackDx(clus.fTrackDx),
74   fTrackDz(clus.fTrackDz),
75   fDistToBadChannel(clus.fDistToBadChannel),
76   fID(clus.fID),
77   fNExMax(clus.fNExMax),
78   fClusterType(clus.fClusterType),
79   fTOF(clus.fTOF)
80 {
81   //
82   // The copy constructor 
83   //
84   fGlobalPos[0] = clus.fGlobalPos[0];
85   fGlobalPos[1] = clus.fGlobalPos[1];
86   fGlobalPos[2] = clus.fGlobalPos[2];
87
88   for(Int_t i=0; i<AliPID::kSPECIESN; i++) fPID[i] = clus.fPID[i];
89
90   if (clus.fNCells > 0) {
91
92     if(clus.fCellsAbsId){
93       fCellsAbsId = new UShort_t[clus.fNCells];
94       for (Int_t i=0; i<clus.fNCells; i++)
95         fCellsAbsId[i]=clus.fCellsAbsId[i];
96     }
97     
98     if(clus.fCellsAmpFraction){
99       fCellsAmpFraction = new Double32_t[clus.fNCells];
100       for (Int_t i=0; i<clus.fNCells; i++)
101         fCellsAmpFraction[i]=clus.fCellsAmpFraction[i];
102     }
103     
104   }
105
106 }
107
108 //_______________________________________________________________________
109 AliESDCaloCluster &AliESDCaloCluster::operator=(const AliESDCaloCluster& source)
110 {
111   // assignment operator
112
113   if(&source == this) return *this;
114   AliVCluster::operator=(source);
115   fGlobalPos[0] = source.fGlobalPos[0];
116   fGlobalPos[1] = source.fGlobalPos[1];
117   fGlobalPos[2] = source.fGlobalPos[2];
118
119   fEnergy = source.fEnergy;
120   fDispersion = source.fDispersion;
121   fChi2 = source.fChi2;
122   fM20 = source.fM20;
123   fM02 = source.fM02;
124   fEmcCpvDistance = source.fEmcCpvDistance;
125   fTrackDx= source.fTrackDx ;
126   fTrackDz= source.fTrackDz ;
127   fDistToBadChannel = source.fDistToBadChannel ;
128   for(Int_t i=0; i<AliPID::kSPECIESN; i++) fPID[i] = source.fPID[i];
129   fID = source.fID;
130
131   fNCells= source.fNCells;
132
133   if (source.fNCells > 0) {
134     if(source.fCellsAbsId){
135       if(fNCells != source.fNCells||!fCellsAbsId){
136         if(fCellsAbsId)delete [] fCellsAbsId;
137         fCellsAbsId = new UShort_t[source.fNCells];
138       }
139       for (Int_t i=0; i<source.fNCells; i++){
140         fCellsAbsId[i]=source.fCellsAbsId[i];
141       }
142     }
143     
144     if(source.fCellsAmpFraction){
145       if(fNCells != source.fNCells||!fCellsAmpFraction){
146         if(fCellsAmpFraction) delete [] fCellsAmpFraction;
147         fCellsAmpFraction = new Double32_t[source.fNCells];
148       }
149       for (Int_t i=0; i<source.fNCells; i++)
150         fCellsAmpFraction[i]=source.fCellsAmpFraction[i];
151     }  
152   }
153
154   fNExMax = source.fNExMax;
155   fClusterType = source.fClusterType;
156   fTOF = source.fTOF;
157
158   //not in use
159   if(source.fTracksMatched){
160     // assign or copy construct
161     if(fTracksMatched){
162       *fTracksMatched = *source.fTracksMatched;
163     }
164     else fTracksMatched = new TArrayI(*source.fTracksMatched);
165   }
166   else{
167     if(fTracksMatched)delete fTracksMatched;
168     fTracksMatched = 0;
169   }
170
171   if(source.fLabels){
172     // assign or copy construct
173     if(fLabels){ 
174       *fLabels = *source.fLabels;
175     }
176     else fLabels = new TArrayI(*source.fLabels);
177   }
178   else{
179     if(fLabels)delete fLabels;
180     fLabels = 0;
181   }
182
183   
184   return *this;
185
186 }
187
188 //_______________________________________________________________________
189 void AliESDCaloCluster::Copy(TObject &obj) const {
190   
191   // this overwrites the virtual TOBject::Copy()
192   // to allow run time copying without casting
193   // in AliESDEvent
194
195   if(this==&obj)return;
196   AliESDCaloCluster *robj = dynamic_cast<AliESDCaloCluster*>(&obj);
197   if(!robj)return; // not an AliESDCluster
198   *robj = *this;
199
200 }
201
202 //_______________________________________________________________________
203 AliESDCaloCluster::~AliESDCaloCluster(){ 
204   //
205   // This is destructor according Coding Conventions 
206   //
207   if(fTracksMatched)delete fTracksMatched;fTracksMatched = 0;
208   if(fLabels) delete fLabels; fLabels = 0;
209   if(fCellsAmpFraction){ delete[] fCellsAmpFraction; fCellsAmpFraction=0;}
210   if(fCellsAbsId){ delete[] fCellsAbsId;  fCellsAbsId = 0;}
211 }
212
213 //_______________________________________________________________________
214 void AliESDCaloCluster::SetPID(const Float_t *p) {
215   // Sets the probability of each particle type
216   // Copied from AliESDtrack SetPIDValues
217   // This function copies "n" PID weights from "scr" to "dest"
218   // and normalizes their sum to 1 thus producing conditional
219   // probabilities.
220   // The negative weights are set to 0.
221   // In case all the weights are non-positive they are replaced by
222   // uniform probabilities
223
224   Int_t n = AliPID::kSPECIESN;
225
226   Float_t uniform = 1./(Float_t)n;
227
228   Float_t sum = 0;
229   for (Int_t i=0; i<n; i++)
230     if (p[i]>=0) {
231       sum+=p[i];
232       fPID[i] = p[i];
233     }
234     else {
235       fPID[i] = 0;
236     }
237
238   if(sum>0)
239     for (Int_t i=0; i<n; i++) fPID[i] /= sum;
240   else
241     for (Int_t i=0; i<n; i++) fPID[i] = uniform;
242
243 }
244
245 //_______________________________________________________________________
246 void AliESDCaloCluster::GetMomentum(TLorentzVector& p, Double_t *vertex ) {
247   // Returns TLorentzVector with momentum of the cluster. Only valid for clusters 
248   // identified as photons or pi0 (overlapped gamma) produced on the vertex
249   //Vertex can be recovered with esd pointer doing:  
250   //" Double_t vertex[3] ; esd->GetVertex()->GetXYZ(vertex) ; "
251
252   Double32_t pos[3]={ fGlobalPos[0], fGlobalPos[1], fGlobalPos[2]};
253   if(vertex){//calculate direction from vertex
254     pos[0]-=vertex[0];
255     pos[1]-=vertex[1];
256     pos[2]-=vertex[2];
257   }
258   
259   Double_t r = TMath::Sqrt(pos[0]*pos[0]+pos[1]*pos[1]+pos[2]*pos[2]   ) ; 
260   
261   p.SetPxPyPzE( fEnergy*pos[0]/r,  fEnergy*pos[1]/r,  fEnergy*pos[2]/r,  fEnergy) ;   
262 }
263
264 //_______________________________________________________________________
265 void  AliESDCaloCluster::SetCellsAbsId(UShort_t *array)
266 {
267     //  Set the array of cell absId numbers 
268   if (fNCells) {
269     fCellsAbsId = new  UShort_t[fNCells];
270     for (Int_t i = 0; i < fNCells; i++) fCellsAbsId[i] = array[i];
271   }
272 }
273
274 //_______________________________________________________________________
275 void  AliESDCaloCluster::SetCellsAmplitudeFraction(Double32_t *array)
276 {
277   //  Set the array of cell amplitude fraction
278   if (fNCells) {
279     fCellsAmpFraction = new  Double32_t[fNCells];
280     for (Int_t i = 0; i < fNCells; i++) fCellsAmpFraction[i] = array[i];
281   }
282 }
283
284 //______________________________________________________________________________
285 void AliESDCaloCluster::SetPosition(Float_t *x) 
286 {
287   // set the position
288   
289   if (x) {
290     fGlobalPos[0] = x[0];
291     fGlobalPos[1] = x[1];
292     fGlobalPos[2] = x[2];
293   } else {
294     
295     fGlobalPos[0] = -999.;
296     fGlobalPos[1] = -999.;
297     fGlobalPos[2] = -999.;
298   }
299 }
300
301