]>
Commit | Line | Data |
---|---|---|
d15a28e7 | 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 | ||
b2a60966 | 16 | /* $Id$ */ |
17 | ||
d15a28e7 | 18 | //_________________________________________________________________________ |
b2a60966 | 19 | // RecPoint implementation for PHOS-EMC |
20 | // An EmcRecPoint is a cluster of digits | |
baef0810 | 21 | //*-- |
b2a60966 | 22 | //*-- Author: Dmitri Peressounko (RRC KI & SUBATECH) |
23 | ||
d15a28e7 | 24 | |
25 | // --- ROOT system --- | |
9f616d61 | 26 | #include "TPad.h" |
27 | #include "TH2.h" | |
d15a28e7 | 28 | #include "TMath.h" |
9f616d61 | 29 | #include "TCanvas.h" |
d15a28e7 | 30 | |
31 | // --- Standard library --- | |
32 | ||
de9ec31b | 33 | #include <iostream.h> |
d15a28e7 | 34 | |
35 | // --- AliRoot header files --- | |
36 | ||
4d3bb36b | 37 | #include "AliGenerator.h" |
d15a28e7 | 38 | #include "AliPHOSGeometry.h" |
39 | #include "AliPHOSEmcRecPoint.h" | |
40 | #include "AliRun.h" | |
7b7c1533 | 41 | #include "AliPHOSGetter.h" |
d15a28e7 | 42 | |
43 | ClassImp(AliPHOSEmcRecPoint) | |
44 | ||
45 | //____________________________________________________________________________ | |
7932f811 | 46 | AliPHOSEmcRecPoint::AliPHOSEmcRecPoint() : AliPHOSRecPoint() |
d15a28e7 | 47 | { |
48 | // ctor | |
49 | ||
50 | fMulDigit = 0 ; | |
51 | fAmp = 0. ; | |
7932f811 | 52 | fCoreEnergy = 0 ; |
53 | fEnergyList = 0 ; | |
9688c1dd | 54 | fTime = -1. ; |
7b7c1533 | 55 | |
83974468 | 56 | } |
57 | ||
58 | //____________________________________________________________________________ | |
59 | AliPHOSEmcRecPoint::~AliPHOSEmcRecPoint() | |
60 | { | |
88714635 | 61 | // dtor |
a4e98857 | 62 | |
83974468 | 63 | if ( fEnergyList ) |
64 | delete[] fEnergyList ; | |
d15a28e7 | 65 | } |
66 | ||
d15a28e7 | 67 | //____________________________________________________________________________ |
83974468 | 68 | void AliPHOSEmcRecPoint::AddDigit(AliPHOSDigit & digit, Float_t Energy) |
d15a28e7 | 69 | { |
b2a60966 | 70 | // Adds a digit to the RecPoint |
a4e98857 | 71 | // and accumulates the total amplitude and the multiplicity |
d15a28e7 | 72 | |
7932f811 | 73 | if(fEnergyList == 0) |
74 | fEnergyList = new Float_t[fMaxDigit]; | |
75 | ||
d15a28e7 | 76 | if ( fMulDigit >= fMaxDigit ) { // increase the size of the lists |
9f616d61 | 77 | fMaxDigit*=2 ; |
83974468 | 78 | Int_t * tempo = new ( Int_t[fMaxDigit] ) ; |
9f616d61 | 79 | Float_t * tempoE = new ( Float_t[fMaxDigit] ) ; |
80 | ||
81 | Int_t index ; | |
d15a28e7 | 82 | for ( index = 0 ; index < fMulDigit ; index++ ){ |
83974468 | 83 | tempo[index] = fDigitsList[index] ; |
d15a28e7 | 84 | tempoE[index] = fEnergyList[index] ; |
85 | } | |
86 | ||
9f616d61 | 87 | delete [] fDigitsList ; |
83974468 | 88 | fDigitsList = new ( Int_t[fMaxDigit] ) ; |
9f616d61 | 89 | |
90 | delete [] fEnergyList ; | |
91 | fEnergyList = new ( Float_t[fMaxDigit] ) ; | |
92 | ||
93 | for ( index = 0 ; index < fMulDigit ; index++ ){ | |
94 | fDigitsList[index] = tempo[index] ; | |
95 | fEnergyList[index] = tempoE[index] ; | |
96 | } | |
97 | ||
98 | delete [] tempo ; | |
99 | delete [] tempoE ; | |
100 | } // if | |
d15a28e7 | 101 | |
83974468 | 102 | fDigitsList[fMulDigit] = digit.GetIndexInList() ; |
103 | fEnergyList[fMulDigit] = Energy ; | |
104 | fMulDigit++ ; | |
d15a28e7 | 105 | fAmp += Energy ; |
7932f811 | 106 | |
107 | EvalPHOSMod(&digit) ; | |
d15a28e7 | 108 | } |
109 | ||
110 | //____________________________________________________________________________ | |
ad8cfaf4 | 111 | Bool_t AliPHOSEmcRecPoint::AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) const |
d15a28e7 | 112 | { |
a4e98857 | 113 | // Tells if (true) or not (false) two digits are neighbors |
d15a28e7 | 114 | |
115 | Bool_t aren = kFALSE ; | |
116 | ||
7b7c1533 | 117 | AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; |
118 | AliPHOSGeometry * phosgeom = (AliPHOSGeometry*)gime->PHOSGeometry(); | |
119 | ||
d15a28e7 | 120 | Int_t relid1[4] ; |
92862013 | 121 | phosgeom->AbsToRelNumbering(digit1->GetId(), relid1) ; |
d15a28e7 | 122 | |
123 | Int_t relid2[4] ; | |
92862013 | 124 | phosgeom->AbsToRelNumbering(digit2->GetId(), relid2) ; |
d15a28e7 | 125 | |
92862013 | 126 | Int_t rowdiff = TMath::Abs( relid1[2] - relid2[2] ) ; |
127 | Int_t coldiff = TMath::Abs( relid1[3] - relid2[3] ) ; | |
d15a28e7 | 128 | |
92862013 | 129 | if (( coldiff <= 1 ) && ( rowdiff <= 1 ) && (coldiff + rowdiff > 0)) |
d15a28e7 | 130 | aren = kTRUE ; |
131 | ||
132 | return aren ; | |
133 | } | |
134 | ||
135 | //____________________________________________________________________________ | |
2a941f4e | 136 | Int_t AliPHOSEmcRecPoint::Compare(const TObject * obj) const |
d15a28e7 | 137 | { |
b2a60966 | 138 | // Compares two RecPoints according to their position in the PHOS modules |
139 | ||
7932f811 | 140 | Float_t delta = 1 ; //Width of "Sorting row". If you changibg this |
141 | //value (what is senseless) change as vell delta in | |
142 | //AliPHOSTrackSegmentMakerv* and other RecPoints... | |
d15a28e7 | 143 | Int_t rv ; |
144 | ||
145 | AliPHOSEmcRecPoint * clu = (AliPHOSEmcRecPoint *)obj ; | |
146 | ||
147 | ||
ad8cfaf4 | 148 | Int_t phosmod1 = GetPHOSMod() ; |
92862013 | 149 | Int_t phosmod2 = clu->GetPHOSMod() ; |
d15a28e7 | 150 | |
92862013 | 151 | TVector3 locpos1; |
7932f811 | 152 | GetLocalPosition(locpos1) ; |
92862013 | 153 | TVector3 locpos2; |
154 | clu->GetLocalPosition(locpos2) ; | |
d15a28e7 | 155 | |
92862013 | 156 | if(phosmod1 == phosmod2 ) { |
7932f811 | 157 | Int_t rowdif = (Int_t)TMath::Ceil(locpos1.X()/delta)-(Int_t)TMath::Ceil(locpos2.X()/delta) ; |
d15a28e7 | 158 | if (rowdif> 0) |
7932f811 | 159 | rv = 1 ; |
d15a28e7 | 160 | else if(rowdif < 0) |
7932f811 | 161 | rv = -1 ; |
92862013 | 162 | else if(locpos1.Z()>locpos2.Z()) |
d15a28e7 | 163 | rv = -1 ; |
164 | else | |
165 | rv = 1 ; | |
166 | } | |
167 | ||
168 | else { | |
92862013 | 169 | if(phosmod1 < phosmod2 ) |
d15a28e7 | 170 | rv = -1 ; |
171 | else | |
172 | rv = 1 ; | |
173 | } | |
174 | ||
175 | return rv ; | |
176 | } | |
9f616d61 | 177 | //______________________________________________________________________________ |
baef0810 | 178 | void AliPHOSEmcRecPoint::ExecuteEvent(Int_t event, Int_t px, Int_t py) const |
9f616d61 | 179 | { |
9f616d61 | 180 | |
9688c1dd | 181 | // Execute action corresponding to one event |
182 | // This member function is called when a AliPHOSRecPoint is clicked with the locator | |
183 | // | |
184 | // If Left button is clicked on AliPHOSRecPoint, the digits are switched on | |
185 | // and switched off when the mouse button is released. | |
186 | ||
187 | ||
188 | AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; | |
189 | if(!gime) return ; | |
190 | AliPHOSGeometry * phosgeom = (AliPHOSGeometry*)gime->PHOSGeometry(); | |
83974468 | 191 | |
9688c1dd | 192 | static TGraph * digitgraph = 0 ; |
83974468 | 193 | |
9688c1dd | 194 | if (!gPad->IsEditable()) return; |
83974468 | 195 | |
9688c1dd | 196 | TH2F * histo = 0 ; |
197 | TCanvas * histocanvas ; | |
198 | ||
199 | TClonesArray * digits = gime->Digits() ; | |
200 | ||
201 | switch (event) { | |
83974468 | 202 | |
9688c1dd | 203 | case kButton1Down: { |
204 | AliPHOSDigit * digit ; | |
205 | Int_t iDigit; | |
206 | Int_t relid[4] ; | |
83974468 | 207 | |
9688c1dd | 208 | const Int_t kMulDigit = AliPHOSEmcRecPoint::GetDigitsMultiplicity() ; |
209 | Float_t * xi = new Float_t[kMulDigit] ; | |
210 | Float_t * zi = new Float_t[kMulDigit] ; | |
83974468 | 211 | |
9688c1dd | 212 | // create the histogram for the single cluster |
213 | // 1. gets histogram boundaries | |
214 | Float_t ximax = -999. ; | |
215 | Float_t zimax = -999. ; | |
216 | Float_t ximin = 999. ; | |
217 | Float_t zimin = 999. ; | |
83974468 | 218 | |
9688c1dd | 219 | for(iDigit=0; iDigit<kMulDigit; iDigit++) { |
220 | digit = (AliPHOSDigit *) digits->At(fDigitsList[iDigit]) ; | |
221 | phosgeom->AbsToRelNumbering(digit->GetId(), relid) ; | |
222 | phosgeom->RelPosInModule(relid, xi[iDigit], zi[iDigit]); | |
223 | if ( xi[iDigit] > ximax ) | |
224 | ximax = xi[iDigit] ; | |
225 | if ( xi[iDigit] < ximin ) | |
226 | ximin = xi[iDigit] ; | |
227 | if ( zi[iDigit] > zimax ) | |
228 | zimax = zi[iDigit] ; | |
229 | if ( zi[iDigit] < zimin ) | |
230 | zimin = zi[iDigit] ; | |
231 | } | |
232 | ximax += phosgeom->GetCrystalSize(0) / 2. ; | |
233 | zimax += phosgeom->GetCrystalSize(2) / 2. ; | |
234 | ximin -= phosgeom->GetCrystalSize(0) / 2. ; | |
235 | zimin -= phosgeom->GetCrystalSize(2) / 2. ; | |
236 | Int_t xdim = (int)( (ximax - ximin ) / phosgeom->GetCrystalSize(0) + 0.5 ) ; | |
237 | Int_t zdim = (int)( (zimax - zimin ) / phosgeom->GetCrystalSize(2) + 0.5 ) ; | |
83974468 | 238 | |
9688c1dd | 239 | // 2. gets the histogram title |
83974468 | 240 | |
9688c1dd | 241 | Text_t title[100] ; |
242 | sprintf(title,"Energy=%1.2f GeV ; Digits ; %d ", GetEnergy(), GetDigitsMultiplicity()) ; | |
83974468 | 243 | |
9688c1dd | 244 | if (!histo) { |
245 | delete histo ; | |
246 | histo = 0 ; | |
247 | } | |
248 | histo = new TH2F("cluster3D", title, xdim, ximin, ximax, zdim, zimin, zimax) ; | |
83974468 | 249 | |
9688c1dd | 250 | Float_t x, z ; |
251 | for(iDigit=0; iDigit<kMulDigit; iDigit++) { | |
252 | digit = (AliPHOSDigit *) digits->At(fDigitsList[iDigit]) ; | |
253 | phosgeom->AbsToRelNumbering(digit->GetId(), relid) ; | |
254 | phosgeom->RelPosInModule(relid, x, z); | |
255 | histo->Fill(x, z, fEnergyList[iDigit] ) ; | |
256 | } | |
83974468 | 257 | |
9688c1dd | 258 | if (!digitgraph) { |
259 | digitgraph = new TGraph(kMulDigit,xi,zi); | |
260 | digitgraph-> SetMarkerStyle(5) ; | |
261 | digitgraph-> SetMarkerSize(1.) ; | |
262 | digitgraph-> SetMarkerColor(1) ; | |
263 | digitgraph-> Paint("P") ; | |
264 | } | |
83974468 | 265 | |
9688c1dd | 266 | // Print() ; |
267 | histocanvas = new TCanvas("cluster", "a single cluster", 600, 500) ; | |
268 | histocanvas->Draw() ; | |
269 | histo->Draw("lego1") ; | |
83974468 | 270 | |
9688c1dd | 271 | delete[] xi ; |
272 | delete[] zi ; | |
83974468 | 273 | |
9688c1dd | 274 | break; |
275 | } | |
83974468 | 276 | |
9688c1dd | 277 | case kButton1Up: |
278 | if (digitgraph) { | |
279 | delete digitgraph ; | |
280 | digitgraph = 0 ; | |
281 | } | |
282 | break; | |
9f616d61 | 283 | |
9688c1dd | 284 | } |
9f616d61 | 285 | } |
286 | ||
d15a28e7 | 287 | //____________________________________________________________________________ |
7932f811 | 288 | void AliPHOSEmcRecPoint::EvalDispersion(Float_t logWeight,TClonesArray * digits) |
d15a28e7 | 289 | { |
b2a60966 | 290 | // Calculates the dispersion of the shower at the origine of the RecPoint |
291 | ||
e5b16749 | 292 | Float_t d = 0. ; |
293 | Float_t wtot = 0. ; | |
d15a28e7 | 294 | |
d084d50d | 295 | Float_t x = 0.; |
296 | Float_t z = 0.; | |
d15a28e7 | 297 | |
298 | AliPHOSDigit * digit ; | |
7b7c1533 | 299 | |
300 | AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; | |
301 | AliPHOSGeometry * phosgeom = (AliPHOSGeometry*)gime->PHOSGeometry(); | |
d15a28e7 | 302 | |
e5b16749 | 303 | |
304 | // Calculates the center of gravity in the local PHOS-module coordinates | |
305 | ||
d15a28e7 | 306 | Int_t iDigit; |
e5b16749 | 307 | |
308 | for(iDigit=0; iDigit<fMulDigit; iDigit++) { | |
309 | digit = (AliPHOSDigit *) digits->At(fDigitsList[iDigit]) ; | |
310 | Int_t relid[4] ; | |
311 | Float_t xi ; | |
312 | Float_t zi ; | |
313 | phosgeom->AbsToRelNumbering(digit->GetId(), relid) ; | |
314 | phosgeom->RelPosInModule(relid, xi, zi); | |
315 | Float_t w = TMath::Max( 0., logWeight + TMath::Log( fEnergyList[iDigit] / fAmp ) ) ; | |
316 | x += xi * w ; | |
317 | z += zi * w ; | |
318 | wtot += w ; | |
319 | } | |
320 | x /= wtot ; | |
321 | z /= wtot ; | |
322 | ||
323 | ||
324 | // Calculates the dispersion in coordinates | |
325 | wtot = 0.; | |
88714635 | 326 | for(iDigit=0; iDigit < fMulDigit; iDigit++) { |
7932f811 | 327 | digit = (AliPHOSDigit *) digits->At(fDigitsList[iDigit]) ; |
d15a28e7 | 328 | Int_t relid[4] ; |
329 | Float_t xi ; | |
330 | Float_t zi ; | |
92862013 | 331 | phosgeom->AbsToRelNumbering(digit->GetId(), relid) ; |
332 | phosgeom->RelPosInModule(relid, xi, zi); | |
7932f811 | 333 | Float_t w = TMath::Max(0.,logWeight+TMath::Log(fEnergyList[iDigit]/fAmp ) ) ; |
92862013 | 334 | d += w*((xi-x)*(xi-x) + (zi-z)*(zi-z) ) ; |
d15a28e7 | 335 | wtot+=w ; |
d084d50d | 336 | |
337 | ||
d15a28e7 | 338 | } |
e5b16749 | 339 | |
7932f811 | 340 | |
92862013 | 341 | d /= wtot ; |
d15a28e7 | 342 | |
7932f811 | 343 | fDispersion = TMath::Sqrt(d) ; |
c63c49e9 | 344 | |
d15a28e7 | 345 | } |
fad3e5b9 | 346 | //______________________________________________________________________________ |
e5b16749 | 347 | void AliPHOSEmcRecPoint::EvalCoreEnergy(Float_t logWeight, TClonesArray * digits) |
fad3e5b9 | 348 | { |
a4e98857 | 349 | // This function calculates energy in the core, |
350 | // i.e. within a radius rad = 3cm around the center. Beyond this radius | |
351 | // in accordance with shower profile the energy deposition | |
fad3e5b9 | 352 | // should be less than 2% |
353 | ||
fad3e5b9 | 354 | Float_t coreRadius = 3 ; |
355 | ||
e5b16749 | 356 | Float_t x = 0 ; |
357 | Float_t z = 0 ; | |
fad3e5b9 | 358 | |
359 | AliPHOSDigit * digit ; | |
7b7c1533 | 360 | |
361 | AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; | |
362 | AliPHOSGeometry * phosgeom = (AliPHOSGeometry*)gime->PHOSGeometry(); | |
363 | ||
fad3e5b9 | 364 | Int_t iDigit; |
e5b16749 | 365 | |
366 | // Calculates the center of gravity in the local PHOS-module coordinates | |
367 | Float_t wtot = 0; | |
368 | for(iDigit=0; iDigit<fMulDigit; iDigit++) { | |
369 | digit = (AliPHOSDigit *) digits->At(fDigitsList[iDigit]) ; | |
370 | Int_t relid[4] ; | |
371 | Float_t xi ; | |
372 | Float_t zi ; | |
373 | phosgeom->AbsToRelNumbering(digit->GetId(), relid) ; | |
374 | phosgeom->RelPosInModule(relid, xi, zi); | |
375 | Float_t w = TMath::Max( 0., logWeight + TMath::Log( fEnergyList[iDigit] / fAmp ) ) ; | |
376 | x += xi * w ; | |
377 | z += zi * w ; | |
378 | wtot += w ; | |
379 | } | |
380 | x /= wtot ; | |
381 | z /= wtot ; | |
382 | ||
383 | ||
fad3e5b9 | 384 | for(iDigit=0; iDigit < fMulDigit; iDigit++) { |
7932f811 | 385 | digit = (AliPHOSDigit *) ( digits->At(fDigitsList[iDigit]) ) ; |
fad3e5b9 | 386 | Int_t relid[4] ; |
387 | Float_t xi ; | |
388 | Float_t zi ; | |
389 | phosgeom->AbsToRelNumbering(digit->GetId(), relid) ; | |
390 | phosgeom->RelPosInModule(relid, xi, zi); | |
391 | Float_t distance = TMath::Sqrt((xi-x)*(xi-x)+(zi-z)*(zi-z)) ; | |
392 | if(distance < coreRadius) | |
7932f811 | 393 | fCoreEnergy += fEnergyList[iDigit] ; |
fad3e5b9 | 394 | } |
395 | ||
fad3e5b9 | 396 | } |
d15a28e7 | 397 | |
398 | //____________________________________________________________________________ | |
7932f811 | 399 | void AliPHOSEmcRecPoint::EvalElipsAxis(Float_t logWeight,TClonesArray * digits) |
d15a28e7 | 400 | { |
b2a60966 | 401 | // Calculates the axis of the shower ellipsoid |
83974468 | 402 | |
e8dbb96e | 403 | Double_t wtot = 0. ; |
404 | Double_t x = 0.; | |
405 | Double_t z = 0.; | |
406 | Double_t dxx = 0.; | |
407 | Double_t dzz = 0.; | |
408 | Double_t dxz = 0.; | |
d15a28e7 | 409 | |
410 | AliPHOSDigit * digit ; | |
7b7c1533 | 411 | |
412 | AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; | |
413 | AliPHOSGeometry * phosgeom = (AliPHOSGeometry*)gime->PHOSGeometry(); | |
414 | ||
d15a28e7 | 415 | Int_t iDigit; |
416 | ||
e5b16749 | 417 | |
d15a28e7 | 418 | for(iDigit=0; iDigit<fMulDigit; iDigit++) { |
7932f811 | 419 | digit = (AliPHOSDigit *) digits->At(fDigitsList[iDigit]) ; |
d15a28e7 | 420 | Int_t relid[4] ; |
421 | Float_t xi ; | |
422 | Float_t zi ; | |
92862013 | 423 | phosgeom->AbsToRelNumbering(digit->GetId(), relid) ; |
424 | phosgeom->RelPosInModule(relid, xi, zi); | |
7932f811 | 425 | Double_t w = TMath::Max(0.,logWeight+TMath::Log(fEnergyList[iDigit]/fAmp ) ) ; |
92862013 | 426 | dxx += w * xi * xi ; |
d15a28e7 | 427 | x += w * xi ; |
92862013 | 428 | dzz += w * zi * zi ; |
d15a28e7 | 429 | z += w * zi ; |
92862013 | 430 | dxz += w * xi * zi ; |
d15a28e7 | 431 | wtot += w ; |
432 | } | |
92862013 | 433 | dxx /= wtot ; |
d15a28e7 | 434 | x /= wtot ; |
92862013 | 435 | dxx -= x * x ; |
436 | dzz /= wtot ; | |
d15a28e7 | 437 | z /= wtot ; |
92862013 | 438 | dzz -= z * z ; |
439 | dxz /= wtot ; | |
440 | dxz -= x * z ; | |
d15a28e7 | 441 | |
69183710 | 442 | // //Apply correction due to non-perpendicular incidence |
443 | // Double_t CosX ; | |
444 | // Double_t CosZ ; | |
7b7c1533 | 445 | // AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; |
446 | // AliPHOSGeometry * phosgeom = (AliPHOSGeometry*)gime->PHOSGeometry(); | |
447 | // Double_t DistanceToIP= (Double_t ) phosgeom->GetIPtoCrystalSurface() ; | |
69183710 | 448 | |
449 | // CosX = DistanceToIP/TMath::Sqrt(DistanceToIP*DistanceToIP+x*x) ; | |
450 | // CosZ = DistanceToIP/TMath::Sqrt(DistanceToIP*DistanceToIP+z*z) ; | |
451 | ||
452 | // dxx = dxx/(CosX*CosX) ; | |
453 | // dzz = dzz/(CosZ*CosZ) ; | |
454 | // dxz = dxz/(CosX*CosZ) ; | |
455 | ||
456 | ||
7932f811 | 457 | fLambda[0] = 0.5 * (dxx + dzz) + TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz ) ; |
458 | if(fLambda[0] > 0) | |
459 | fLambda[0] = TMath::Sqrt(fLambda[0]) ; | |
e8dbb96e | 460 | |
7932f811 | 461 | fLambda[1] = 0.5 * (dxx + dzz) - TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz ) ; |
462 | if(fLambda[1] > 0) //To avoid exception if numerical errors lead to negative lambda. | |
463 | fLambda[1] = TMath::Sqrt(fLambda[1]) ; | |
e8dbb96e | 464 | else |
7932f811 | 465 | fLambda[1]= 0. ; |
d15a28e7 | 466 | } |
467 | ||
b2a60966 | 468 | //____________________________________________________________________________ |
7932f811 | 469 | void AliPHOSEmcRecPoint::EvalAll(Float_t logWeight, TClonesArray * digits ) |
ad8cfaf4 | 470 | { |
baef0810 | 471 | // Evaluates all shower parameters |
472 | ||
7932f811 | 473 | AliPHOSRecPoint::EvalAll(logWeight,digits) ; |
474 | EvalLocalPosition(logWeight, digits) ; | |
475 | EvalElipsAxis(logWeight, digits) ; | |
476 | EvalDispersion(logWeight, digits) ; | |
e5b16749 | 477 | EvalCoreEnergy(logWeight, digits); |
ad8cfaf4 | 478 | } |
479 | //____________________________________________________________________________ | |
7932f811 | 480 | void AliPHOSEmcRecPoint::EvalLocalPosition(Float_t logWeight, TClonesArray * digits) |
b2a60966 | 481 | { |
482 | // Calculates the center of gravity in the local PHOS-module coordinates | |
b2a60966 | 483 | Float_t wtot = 0. ; |
484 | ||
485 | Int_t relid[4] ; | |
486 | ||
487 | Float_t x = 0. ; | |
488 | Float_t z = 0. ; | |
489 | ||
490 | AliPHOSDigit * digit ; | |
491 | ||
7b7c1533 | 492 | AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; |
493 | AliPHOSGeometry * phosgeom = (AliPHOSGeometry*)gime->PHOSGeometry(); | |
b2a60966 | 494 | |
495 | Int_t iDigit; | |
496 | ||
b2a60966 | 497 | for(iDigit=0; iDigit<fMulDigit; iDigit++) { |
7932f811 | 498 | digit = (AliPHOSDigit *) digits->At(fDigitsList[iDigit]) ; |
b2a60966 | 499 | |
500 | Float_t xi ; | |
501 | Float_t zi ; | |
502 | phosgeom->AbsToRelNumbering(digit->GetId(), relid) ; | |
503 | phosgeom->RelPosInModule(relid, xi, zi); | |
7932f811 | 504 | Float_t w = TMath::Max( 0., logWeight + TMath::Log( fEnergyList[iDigit] / fAmp ) ) ; |
b2a60966 | 505 | x += xi * w ; |
506 | z += zi * w ; | |
507 | wtot += w ; | |
b2a60966 | 508 | |
9ce1a8d9 | 509 | } |
69183710 | 510 | |
511 | x /= wtot ; | |
512 | z /= wtot ; | |
ad8cfaf4 | 513 | |
514 | // Correction for the depth of the shower starting point (TDR p 127) | |
515 | Float_t para = 0.925 ; | |
516 | Float_t parb = 6.52 ; | |
517 | ||
1b799736 | 518 | Float_t xo,yo,zo ; //Coordinates of the origin |
519 | gAlice->Generator()->GetOrigin(xo,yo,zo) ; | |
520 | ||
5830e1d9 | 521 | Float_t phi = phosgeom->GetPHOSAngle(relid[0]) ; |
1b799736 | 522 | |
523 | //Transform to the local ref.frame | |
524 | Float_t xoL,yoL ; | |
525 | xoL = xo*TMath::Cos(phi)-yo*TMath::Sin(phi) ; | |
526 | yoL = xo*TMath::Sin(phi)+yo*TMath::Cos(phi) ; | |
527 | ||
528 | Float_t radius = TMath::Sqrt((xoL-x)*(xoL-x)+ | |
5830e1d9 | 529 | (phosgeom->GetIPtoCrystalSurface()-yoL)*(phosgeom->GetIPtoCrystalSurface()-yoL)+ |
530 | (zo-z)*(zo-z)); | |
1b799736 | 531 | |
532 | Float_t incidencephi = TMath::ATan((x-xoL ) / radius) ; | |
533 | Float_t incidencetheta = TMath::ATan((z-zo) / radius) ; | |
ad8cfaf4 | 534 | |
535 | Float_t depthx = ( para * TMath::Log(fAmp) + parb ) * TMath::Sin(incidencephi) ; | |
536 | Float_t depthz = ( para * TMath::Log(fAmp) + parb ) * TMath::Sin(incidencetheta) ; | |
537 | ||
538 | ||
539 | fLocPos.SetX(x - depthx) ; | |
b2a60966 | 540 | fLocPos.SetY(0.) ; |
ad8cfaf4 | 541 | fLocPos.SetZ(z - depthz) ; |
b2a60966 | 542 | |
b2a60966 | 543 | } |
544 | ||
d15a28e7 | 545 | //____________________________________________________________________________ |
ad8cfaf4 | 546 | Float_t AliPHOSEmcRecPoint::GetMaximalEnergy(void) const |
d15a28e7 | 547 | { |
b2a60966 | 548 | // Finds the maximum energy in the cluster |
549 | ||
d15a28e7 | 550 | Float_t menergy = 0. ; |
551 | ||
552 | Int_t iDigit; | |
553 | ||
554 | for(iDigit=0; iDigit<fMulDigit; iDigit++) { | |
555 | ||
556 | if(fEnergyList[iDigit] > menergy) | |
557 | menergy = fEnergyList[iDigit] ; | |
558 | } | |
559 | return menergy ; | |
560 | } | |
561 | ||
562 | //____________________________________________________________________________ | |
ad8cfaf4 | 563 | Int_t AliPHOSEmcRecPoint::GetMultiplicityAtLevel(const Float_t H) const |
d15a28e7 | 564 | { |
b2a60966 | 565 | // Calculates the multiplicity of digits with energy larger than H*energy |
566 | ||
d15a28e7 | 567 | Int_t multipl = 0 ; |
568 | Int_t iDigit ; | |
569 | for(iDigit=0; iDigit<fMulDigit; iDigit++) { | |
570 | ||
571 | if(fEnergyList[iDigit] > H * fAmp) | |
572 | multipl++ ; | |
573 | } | |
574 | return multipl ; | |
575 | } | |
576 | ||
577 | //____________________________________________________________________________ | |
7932f811 | 578 | Int_t AliPHOSEmcRecPoint::GetNumberOfLocalMax(Int_t * maxAt, Float_t * maxAtEnergy, |
579 | Float_t locMaxCut,TClonesArray * digits) const | |
d15a28e7 | 580 | { |
b2a60966 | 581 | // Calculates the number of local maxima in the cluster using fLocalMaxCut as the minimum |
a4e98857 | 582 | // energy difference between two local maxima |
b2a60966 | 583 | |
d15a28e7 | 584 | AliPHOSDigit * digit ; |
585 | AliPHOSDigit * digitN ; | |
586 | ||
587 | ||
588 | Int_t iDigitN ; | |
589 | Int_t iDigit ; | |
590 | ||
7932f811 | 591 | for(iDigit = 0; iDigit < fMulDigit; iDigit++) |
592 | maxAt[iDigit] = (Int_t) digits->At(fDigitsList[iDigit]) ; | |
593 | ||
d15a28e7 | 594 | |
6ad0bfa0 | 595 | for(iDigit = 0 ; iDigit < fMulDigit; iDigit++) { |
9f616d61 | 596 | if(maxAt[iDigit] != -1) { |
597 | digit = (AliPHOSDigit *) maxAt[iDigit] ; | |
83974468 | 598 | |
6ad0bfa0 | 599 | for(iDigitN = 0; iDigitN < fMulDigit; iDigitN++) { |
7932f811 | 600 | digitN = (AliPHOSDigit *) digits->At(fDigitsList[iDigitN]) ; |
d15a28e7 | 601 | |
9f616d61 | 602 | if ( AreNeighbours(digit, digitN) ) { |
d15a28e7 | 603 | if (fEnergyList[iDigit] > fEnergyList[iDigitN] ) { |
604 | maxAt[iDigitN] = -1 ; | |
6ad0bfa0 | 605 | // but may be digit too is not local max ? |
7932f811 | 606 | if(fEnergyList[iDigit] < fEnergyList[iDigitN] + locMaxCut) |
d15a28e7 | 607 | maxAt[iDigit] = -1 ; |
608 | } | |
609 | else { | |
610 | maxAt[iDigit] = -1 ; | |
6ad0bfa0 | 611 | // but may be digitN too is not local max ? |
7932f811 | 612 | if(fEnergyList[iDigit] > fEnergyList[iDigitN] - locMaxCut) |
d15a28e7 | 613 | maxAt[iDigitN] = -1 ; |
614 | } | |
615 | } // if Areneighbours | |
616 | } // while digitN | |
617 | } // slot not empty | |
618 | } // while digit | |
619 | ||
620 | iDigitN = 0 ; | |
6ad0bfa0 | 621 | for(iDigit = 0; iDigit < fMulDigit; iDigit++) { |
d15a28e7 | 622 | if(maxAt[iDigit] != -1){ |
623 | maxAt[iDigitN] = maxAt[iDigit] ; | |
9f616d61 | 624 | maxAtEnergy[iDigitN] = fEnergyList[iDigit] ; |
625 | iDigitN++ ; | |
d15a28e7 | 626 | } |
627 | } | |
628 | return iDigitN ; | |
629 | } | |
9688c1dd | 630 | //____________________________________________________________________________ |
631 | void AliPHOSEmcRecPoint::EvalTime(TClonesArray * digits){ | |
632 | ||
633 | Float_t maxE = 0; | |
634 | Int_t maxAt = 0; | |
635 | for(Int_t idig=0; idig < fMulDigit; idig++){ | |
636 | if(fEnergyList[idig] > maxE){ | |
637 | maxE = fEnergyList[idig] ; | |
638 | maxAt = idig; | |
639 | } | |
640 | } | |
641 | fTime = ((AliPHOSDigit*) digits->At(fDigitsList[maxAt]))->GetTime() ; | |
642 | ||
643 | } | |
d15a28e7 | 644 | //____________________________________________________________________________ |
645 | void AliPHOSEmcRecPoint::Print(Option_t * option) | |
646 | { | |
b2a60966 | 647 | // Print the list of digits belonging to the cluster |
648 | ||
d15a28e7 | 649 | cout << "AliPHOSEmcRecPoint: " << endl ; |
650 | ||
d15a28e7 | 651 | Int_t iDigit; |
7932f811 | 652 | cout << " digits # = " ; |
653 | for(iDigit=0; iDigit<fMulDigit; iDigit++) | |
654 | cout << fDigitsList[iDigit] << " " ; | |
655 | cout << endl ; | |
656 | ||
657 | cout << " Energies = " ; | |
658 | for(iDigit=0; iDigit<fMulDigit; iDigit++) | |
659 | cout << fEnergyList[iDigit] << " "; | |
660 | cout << endl ; | |
83974468 | 661 | |
bc68d12c | 662 | cout << " Primaries " ; |
663 | for(iDigit = 0;iDigit < fMulTrack; iDigit++) | |
664 | cout << fTracksList[iDigit] << " " << endl ; | |
665 | ||
d15a28e7 | 666 | cout << " Multiplicity = " << fMulDigit << endl ; |
667 | cout << " Cluster Energy = " << fAmp << endl ; | |
bc68d12c | 668 | cout << " Number of primaries " << fMulTrack << endl ; |
83974468 | 669 | cout << " Stored at position " << GetIndexInList() << endl ; |
670 | ||
d15a28e7 | 671 | } |
88714635 | 672 | |
7932f811 | 673 |