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