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