Bug correction

[u/mrichter/AliRoot.git] / PHOS / AliPHOSDigit.cxx

diff --git a/PHOS/AliPHOSDigit.cxx b/PHOS/AliPHOSDigit.cxx
index 7808863b77f7bc7be135fac677f490f452c9ede4..c39203b062b873f034c2da256bcd738827ab8d6e 100644 (file)
--- a/PHOS/AliPHOSDigit.cxx
+++ b/PHOS/AliPHOSDigit.cxx
@@ -26,6 +26,8 @@
 
 // --- ROOT system ---
 
+#include "TMath.h"
+
 // --- Standard library ---
 
 // --- AliRoot header files ---
@@ -33,6 +35,8 @@
 #include "AliPHOSDigit.h"
 
 
+
+
 ClassImp(AliPHOSDigit)
 
 //____________________________________________________________________________
@@ -42,7 +46,9 @@ ClassImp(AliPHOSDigit)
 
   fIndexInList = -1 ; 
   fNprimary    = 0 ;  
-  fNMaxPrimary = 5 ; 
+  fPrimary = 0;
+  fTime = 0. ; 
+  fTimeR = 0. ; 
 }
 
 //____________________________________________________________________________
@@ -50,46 +56,48 @@ AliPHOSDigit::AliPHOSDigit(Int_t primary, Int_t id, Int_t digEnergy, Float_t tim
 {  
   // ctor with all data 
 
-  fNMaxPrimary = 5 ; 
   fAmp         = digEnergy ;
   fTime        = time ;
+  fTimeR       = fTime ;
   fId          = id ;
   fIndexInList = index ; 
   if( primary != -1){
     fNprimary    = 1 ; 
+    fPrimary = new Int_t[fNprimary] ;
     fPrimary[0]  = primary ;
   }
   else{  //If the contribution of this primary smaller than fDigitThreshold (AliPHOSv1)
-    fNprimary    = 0 ; 
-    fPrimary[0]  = -1 ;
+    fNprimary = 0 ; 
+    fPrimary  = 0 ;
   }
-  Int_t i ;
-  for ( i = 1; i < fNMaxPrimary ; i++)
-    fPrimary[i]  = -1 ; 
 }
 
 //____________________________________________________________________________
-AliPHOSDigit::AliPHOSDigit(const AliPHOSDigit & digit) 
+AliPHOSDigit::AliPHOSDigit(const AliPHOSDigit & digit) : AliDigitNew(digit)
 {
   // copy ctor
-  
 
-  fNMaxPrimary = digit.fNMaxPrimary ;  
-  Int_t i ;
-  for ( i = 0; i < fNMaxPrimary ; i++)
-    fPrimary[i]  = digit.fPrimary[i] ;
+  fNprimary = digit.fNprimary ;  
+  if(fNprimary){
+    fPrimary = new Int_t[fNprimary] ;
+    for (Int_t i = 0; i < fNprimary ; i++)
+       fPrimary[i]  = digit.fPrimary[i] ;
+  }
+  else
+    fPrimary = 0 ;
   fAmp         = digit.fAmp ;
   fTime        = digit.fTime ;
+  fTimeR       = digit.fTimeR ;
   fId          = digit.fId;
   fIndexInList = digit.fIndexInList ; 
-  fNprimary    = digit.fNprimary ;
 }
 
 //____________________________________________________________________________
 AliPHOSDigit::~AliPHOSDigit() 
 {
   // Delete array of primiries if any
-  
+  if(fPrimary)
+    delete [] fPrimary ;
 }
 
 //____________________________________________________________________________
@@ -128,17 +136,20 @@ Int_t AliPHOSDigit::GetPrimary(Int_t index) const
   
 }
 //____________________________________________________________________________
-void AliPHOSDigit::Print(Option_t *option) const
+void AliPHOSDigit::Print() const
 {
-  printf("PHOS digit: Amp=%d, Id=%d\n",fAmp,fId);
+  // Print the digit together with list of primaries
+  printf("PHOS digit: Amp=%d, Id=%d, Time=%e, TimeR=%e, NPrim=%d ",fAmp,fId,fTime,fTimeR,fNprimary);
+  for(Int_t index = 0; index <fNprimary; index ++ )
+    printf(" %d ",fPrimary[index]); 
+  printf("\n") ;
 }
 //____________________________________________________________________________
 void AliPHOSDigit::ShiftPrimary(Int_t shift)
 {
   //shifts primary number to BIG offset, to separate primary in different TreeK
-  Int_t index  ;
-  for(index = 0; index <fNprimary; index ++ ){
-    fPrimary[index] = fPrimary[index]+ shift ;
+  for(Int_t index = 0; index <fNprimary; index ++ ){
+    fPrimary[index]+= shift ;
   } 
 }
 //____________________________________________________________________________
@@ -155,62 +166,41 @@ Bool_t AliPHOSDigit::operator==(AliPHOSDigit const & digit) const
 //____________________________________________________________________________
 AliPHOSDigit& AliPHOSDigit::operator+(AliPHOSDigit const & digit) 
 {
+
   // Adds the amplitude of digits and completes the list of primary particles
-  // if amplitude is larger than 
-  
-  Int_t toAdd = fNprimary ;
   if(digit.fNprimary>0){
-    if(fAmp < digit.fAmp){//most energetic primary in digit => first primaries in list from second digit
-      for (Int_t index = 0 ; index < digit.fNprimary ; index++){
-       for (Int_t old = 0 ; old < fNprimary ; old++) { //already have this primary?
-         if(fPrimary[old] == (digit.fPrimary)[index]){
-           fPrimary[old] = -1 ; //removed
-           toAdd-- ;
-           break ;
-         }
-       }
-      }
-      if(digit.fNprimary+toAdd >fNMaxPrimary)  //Do not change primary list
-       Error("Operator +", "Increase NMaxPrimary") ;
-      else{
-       for(Int_t index = fNprimary-1 ; index >=0 ; index--){ //move old primaries      
-         if(fPrimary[index]>-1){
-           fPrimary[fNprimary+toAdd]=fPrimary[index] ;
-           toAdd-- ;
-         }
-       }
-       //copy new primaries
-       for(Int_t index = 0; index < digit.fNprimary ; index++){
-         fPrimary[index] = (digit.fPrimary)[index] ;   
-       }
-      }
-    }
-    else{ //add new primaries to the end
-      for(Int_t index = 0 ; index < digit.fNprimary ; index++){
-       Bool_t deja = kTRUE ;
-       for(Int_t old = 0 ; old < fNprimary; old++) { //already have this primary?
-         if(fPrimary[old] == (digit.fPrimary)[index]){
-           deja = kFALSE;
-           break ;
-         }      
-       }
-       if(deja){
-         fPrimary[fNprimary] = (digit.fPrimary)[index] ; 
-         fNprimary++ ;
-         if(fNprimary>fNMaxPrimary) {
-           Error("Operator +", "Increase NMaxPrimary") ;
-           break ;
-         }
-       }
-      }
-      
-    }
-  }
-  
-  fAmp += digit.fAmp ;
-  if(fTime > digit.fTime)
-    fTime = digit.fTime ;
+     Int_t *tmp = new Int_t[fNprimary+digit.fNprimary] ;
+     if(fAmp < digit.fAmp){//most energetic primary in second digit => first primaries in list from second digit
+        for (Int_t index = 0 ; index < digit.fNprimary ; index++)
+           tmp[index]=(digit.fPrimary)[index] ;
+        for (Int_t index = 0 ; index < fNprimary ; index++)
+           tmp[index+digit.fNprimary]=fPrimary[index] ;
+     }
+     else{ //add new primaries to the end
+        for (Int_t index = 0 ; index < fNprimary ; index++)
+           tmp[index]=fPrimary[index] ;
+        for (Int_t index = 0 ; index < digit.fNprimary ; index++)
+           tmp[index+fNprimary]=(digit.fPrimary)[index] ;
+     }
+     if(fPrimary)
+       delete []fPrimary ;
+     fPrimary = tmp ;
+   }
+   fNprimary+=digit.fNprimary ;
+   fAmp += digit.fAmp ;
+   if(fTime > digit.fTime)
+      fTime = digit.fTime ;
+   fTimeR = fTime ; 
+   return *this ;
+}
+//____________________________________________________________________________
+AliPHOSDigit& AliPHOSDigit::operator*(Float_t factor) 
+{
+  // Multiplies the amplitude by a factor
   
+  Float_t tempo = static_cast<Float_t>(fAmp) ; 
+  tempo *= factor ; 
+  fAmp = static_cast<Int_t>(TMath::Ceil(tempo)) ; 
   return *this ;
 }