The array for primaries and parents increments itself when needed
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALDigit.cxx
1 /**************************************************************************
2
3  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4
5  *                                                                        *
6
7  * Author: The ALICE Off-line Project.                                    *
8
9  * Contributors are mentioned in the code where appropriate.              *
10
11  *                                                                        *
12
13  * Permission to use, copy, modify and distribute this software and its   *
14
15  * documentation strictly for non-commercial purposes is hereby granted   *
16
17  * without fee, provided that the above copyright notice appears in all   *
18
19  * copies and that both the copyright notice and this permission notice   *
20
21  * appear in the supporting documentation. The authors make no claims     *
22
23  * about the suitability of this software for any purpose. It is          *
24
25  * provided "as is" without express or implied warranty.                  *
26
27  **************************************************************************/
28
29
30
31 /* $Id:  */
32
33
34
35 //_________________________________________________________________________
36
37 //  EMCAL digit: 
38
39 //      A Digit is the sum of the energy lost in an EMCAL Tower
40
41 //      It also stores information on Primary, and enterring particle
42
43 //      tracknumbers Digits are created using AliEMCALSDigitizer, followed
44
45 //      by AliEMCALDigitizer 
46
47 //
48
49 //*-- Author: Sahal Yacoob (LBL)
50
51 // based on : AliPHOSDigit
52
53 //__________________________________________________________________________
54
55
56
57 // --- ROOT system ---
58
59
60
61 // --- Standard library ---
62
63
64
65 #include <iostream.h>
66
67
68
69 // --- AliRoot header files ---
70
71
72
73 #include "AliEMCALDigit.h"
74
75 #include "AliEMCALGeometry.h"
76
77 #include "AliEMCALGetter.h"
78
79
80
81
82
83 ClassImp(AliEMCALDigit)
84
85
86
87 //____________________________________________________________________________
88
89   AliEMCALDigit::AliEMCALDigit()  
90
91 {
92
93   // default ctor 
94
95
96
97   fIndexInList = 0 ; 
98
99   fNprimary    = 0 ;  
100
101   fNMaxPrimary = 0 ; 
102
103   fNiparent     = 0 ;
104
105
106   fNMaxiparent = 0; 
107
108   fPrimary = 0 ;
109
110   fIparent = 0 ;
111
112   fMaxIter = 0;
113 }
114
115
116
117 //____________________________________________________________________________
118
119 AliEMCALDigit::AliEMCALDigit(Int_t primary, Int_t iparent, Int_t id, Int_t DigEnergy, Float_t time, Int_t index) 
120
121 {  
122
123   // ctor with all data 
124
125
126
127   fNMaxPrimary = 5 ; 
128
129   fNMaxiparent = 40 ; 
130
131   fPrimary = new Int_t[fNMaxPrimary] ;
132
133   fIparent = new Int_t[fNMaxiparent] ; 
134
135   fAmp         = DigEnergy ;
136
137   fTime        = time ;
138
139   fId          = id ;
140
141   fIndexInList = index ; 
142
143   fMaxIter     = 5;
144   if( primary != -1){
145
146     fNprimary    = 1 ; 
147
148     fPrimary[0]  = primary ;  
149
150     fNiparent   = 1 ;
151
152     fIparent[0] = iparent ;    
153
154 }
155
156   else{  //If the contribution of this primary smaller than fDigitThreshold (AliEMCALv1)
157
158     fNprimary    = 0 ; 
159
160     fPrimary[0]  = -1 ;
161
162     fNiparent   = 0 ;
163
164     fIparent[0] = -1 ;    
165
166
167
168   }
169
170   Int_t i ;
171
172   for ( i = 1; i < fNMaxPrimary ; i++)
173
174     fPrimary[i]  = -1 ; 
175
176
177
178   for ( i =1; i< fNMaxiparent ; i++)
179
180     fIparent[i] = -1 ;  
181
182 }
183
184
185
186 //____________________________________________________________________________
187
188 AliEMCALDigit::AliEMCALDigit(const AliEMCALDigit & digit) 
189
190 {
191
192   // copy ctor
193
194   
195
196
197
198   fNMaxPrimary = digit.fNMaxPrimary ;  
199
200   fNMaxiparent = digit.fNMaxiparent ;
201
202   fPrimary = new Int_t[fNMaxPrimary] ;
203
204   fIparent = new Int_t[fNMaxiparent] ; 
205
206   Int_t i ;
207
208   for ( i = 0; i < fNMaxPrimary ; i++)
209
210   fPrimary[i]  = digit.fPrimary[i] ;
211
212   Int_t j ;
213
214   for (j = 0; j< fNMaxiparent ; j++)
215
216   fIparent[j]  = digit.fIparent[j] ;
217
218   fAmp         = digit.fAmp ;
219
220   fTime        = digit.fTime ;
221
222   fId          = digit.fId;
223
224   fMaxIter     = digit.fMaxIter;
225   fIndexInList = digit.fIndexInList ; 
226
227   fNprimary    = digit.fNprimary ;
228
229   fNiparent    = digit.fNiparent ;
230
231 }
232
233
234
235 //____________________________________________________________________________
236
237 AliEMCALDigit::~AliEMCALDigit() 
238
239 {
240
241   // Delete array of primiries if any
242
243     delete [] fPrimary ;
244
245     delete [] fIparent ; 
246
247 }
248
249
250
251 //____________________________________________________________________________
252
253 Int_t AliEMCALDigit::Compare(const TObject * obj) const
254
255 {
256
257   // Compares two digits with respect to its Id
258
259   // to sort according increasing Id
260
261
262
263   Int_t rv ;
264
265
266
267   AliEMCALDigit * digit = (AliEMCALDigit *)obj ; 
268
269
270
271   Int_t iddiff = fId - digit->GetId() ; 
272
273
274
275   if ( iddiff > 0 ) 
276
277     rv = 1 ;
278
279   else if ( iddiff < 0 )
280
281     rv = -1 ; 
282
283   else
284
285     rv = 0 ;
286
287   
288
289   return rv ; 
290
291
292
293 }
294
295
296
297 //____________________________________________________________________________
298
299 const Float_t AliEMCALDigit::GetEta() const
300
301 {
302
303   Float_t eta=-10., phi=-10.;
304
305   Int_t id = GetId();
306
307   const AliEMCALGeometry *g = AliEMCALGetter::GetInstance()->EMCALGeometry();
308
309   g->EtaPhiFromIndex(id,eta,phi);
310
311   return eta ;
312
313 }
314
315
316
317 //____________________________________________________________________________
318
319 const Float_t AliEMCALDigit::GetPhi() const
320
321 {
322
323   Float_t eta=-10., phi=-10.;
324
325   Int_t id = GetId();
326
327   const AliEMCALGeometry *g = AliEMCALGetter::GetInstance()->EMCALGeometry();
328
329   g->EtaPhiFromIndex(id,eta,phi);
330
331   return phi ;
332
333 }
334
335
336
337 //____________________________________________________________________________
338
339 Int_t AliEMCALDigit::GetPrimary(Int_t index) const
340
341 {
342
343   // retrieves the primary particle number given its index in the list 
344
345   Int_t rv = -1 ;
346
347   if ( index <= fNprimary && index > 0){
348
349     rv = fPrimary[index-1] ;
350
351   } 
352
353
354
355   return rv ; 
356
357   
358
359 }
360
361
362
363 //____________________________________________________________________________
364
365 Int_t AliEMCALDigit::GetIparent(Int_t index) const
366
367 {
368
369   // retrieves the primary particle number given its index in the list 
370
371   Int_t rv = -1 ;
372
373   if ( index <= fNiparent ){
374
375     rv = fIparent[index-1] ;
376
377   } 
378
379
380
381   return rv ; 
382
383   
384
385 }
386
387
388
389 //______________________________________________________________________
390
391 const Bool_t AliEMCALDigit::IsInPreShower() const 
392
393 {
394
395   Bool_t rv = kFALSE ;
396
397   const AliEMCALGeometry * geom = AliEMCALGetter::GetInstance()->EMCALGeometry() ;
398
399   if( GetId() > (geom->GetNZ() * geom->GetNPhi() )) 
400
401     rv = kTRUE; 
402
403   return rv; 
404
405
406
407
408
409 //____________________________________________________________________________
410
411 void AliEMCALDigit::ShiftPrimary(Int_t shift){
412
413   //shifts primary nimber to BIG offset, to separate primary in different TreeK
414
415   Int_t index  ;
416
417   for(index = 0; index <fNprimary; index++ ){
418
419     fPrimary[index] = fPrimary[index]+ shift * 10000000   ;}
420
421   for(index =0; index <fNiparent; index++){
422
423     fIparent[index] = fIparent[index] + shift * 10000000 ;}
424
425 }
426
427 //____________________________________________________________________________
428
429 Bool_t AliEMCALDigit::operator==(AliEMCALDigit const & digit) const 
430
431 {
432
433   // Two digits are equal if they have the same Id
434
435   
436
437   if ( fId == digit.fId ) 
438
439     return kTRUE ;
440
441   else 
442
443     return kFALSE ;
444
445 }
446
447  
448
449 //____________________________________________________________________________
450
451 AliEMCALDigit& AliEMCALDigit::operator+(AliEMCALDigit const & digit) 
452
453 {
454
455   // Adds the amplitude of digits and completes the list of primary particles
456
457   // if amplitude is larger than 
458
459   
460
461   fAmp += digit.fAmp ;
462
463   if(fTime > digit.fTime)
464
465     fTime = digit.fTime ;
466
467
468
469   Int_t max1 = fNprimary ; 
470
471   Int_t max2 = fNiparent ;  
472
473   Int_t index ; 
474
475   for (index = 0 ; index < digit.fNprimary  ; index++){
476
477     Bool_t deja = kTRUE ;
478
479     Int_t old ;
480
481     for ( old = 0 ; (old < max1) && deja; old++) { //already have this primary?
482
483       if(fPrimary[old] == digit.fPrimary[index])
484
485         deja = kFALSE;
486
487     }
488
489     if(deja){
490
491       if(max1<fNMaxPrimary){ fPrimary[max1] = digit.fPrimary[index] ; 
492
493       fNprimary++ ;
494
495       max1++;}
496
497       if(fNprimary==fNMaxPrimary) {
498
499         fNMaxPrimary += fMaxIter ;
500         Int_t tempo[fNprimary] ;
501         Int_t i ;
502         for (i=0; i < fNprimary; i++)
503           tempo[i] = fPrimary[i] ;
504         delete [] fPrimary ;
505         fPrimary = new Int_t[fNMaxPrimary];
506           for (i=0; i < fNprimary; i++)
507             fPrimary[i] = tempo[i] ;
508           //delete [] tempo ;
509         for (i=fNprimary; i < fNMaxPrimary; i++)
510           fPrimary[i] = -1 ;
511 cout << "AliEMCALDigit >>  NMaxPrimary has been increased to "<<  fNMaxPrimary << endl ;
512
513         return *this ;
514
515       }
516
517     }
518
519   }
520
521   
522
523   for (index = 0 ; index < digit.fNiparent ; index++){
524
525     Bool_t dejavu = kTRUE ;
526
527     Int_t old ;
528
529     for ( old = 0 ; (old < max2) && dejavu; old++) { //already have this primary?
530
531       if(fIparent[old] == digit.fIparent[index])
532
533         dejavu = kFALSE;
534
535     }
536
537     if(dejavu){
538
539      if(max2<fNMaxiparent){ fIparent[max2] = digit.fIparent[index] ; 
540
541       fNiparent++ ;
542
543       max2++;}
544
545       if(fNiparent==fNMaxiparent) {
546
547         fNMaxiparent += fMaxIter ; 
548         Int_t tempo[fNiparent] ;
549         Int_t i ;
550         for (i=0; i < fNiparent; i++)
551           tempo[i] = fIparent[i] ;
552         delete [] fIparent ;
553         fIparent = new Int_t[fNMaxiparent];
554           for (i=0; i < fNiparent; i++)
555             fIparent[i] = tempo[i] ;
556           // delete [] tempo ;
557         for (i=fNiparent; i < fNMaxiparent; i++)
558           fIparent[i] = -1 ;
559         cout << "AliEMCALDigit >> Increasing fNMaxiparent to  " << fNMaxiparent << endl ;
560
561         return *this ;
562
563       }
564
565     }
566
567   }
568
569   
570
571   return *this ;
572
573 }
574
575
576
577 //____________________________________________________________________________
578
579 AliEMCALDigit& AliEMCALDigit::operator*(Float_t factor) 
580
581 {
582
583   // Multiplies the amplitude by a factor
584
585   
586
587   Float_t tempo = static_cast<Float_t>(fAmp) ; 
588
589   tempo *= factor ; 
590
591   fAmp = static_cast<Int_t>(TMath::Ceil(tempo)) ; 
592
593   return *this ;
594
595 }
596
597
598
599 //____________________________________________________________________________
600
601 ostream& operator << ( ostream& out , const AliEMCALDigit & digit)
602
603 {
604
605   // Prints the data of the digit
606
607   
608
609   out << "ID " << digit.fId << " Energy = " << digit.fAmp <<  " Time = " << digit.fTime << endl ; 
610
611   Int_t i,j ;
612
613   for(i=0;i<digit.fNprimary;i++)
614
615     out << "Primary " << i+1 << " = " << digit.fPrimary[i] << endl ;
616
617    
618
619   for(j=0;j<digit.fNiparent;j++)
620
621     out << "Iparent " << j+1 << " = " << digit.fIparent[j] << endl ;
622
623  out << "Position in list = " << digit.fIndexInList << endl ; 
624
625   return out ;
626
627 }
628
629
630
631
632