Adding include path to allow compilation of CleanGeom task
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALDigit.cxx
index 9856a69..aac4743 100644 (file)
 
 #include "AliEMCALDigit.h"
 #include "AliEMCALGeometry.h"
+#include "AliLog.h" 
 
+using std::cout;
+using std::endl;
 ClassImp(AliEMCALDigit)
 
 //____________________________________________________________________________
@@ -60,8 +63,8 @@ AliDigitNew(),
   fTimeR(0.),
   fChi2(0.),
   fNDF(0),
-  fDigitType(kUnknown)
-
+  fDigitType(kUnknown),
+  fAmpCalib(-1)
 {
   // default ctor 
 
@@ -82,7 +85,7 @@ AliDigitNew(),
 }
 
 //____________________________________________________________________________
-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 dE) 
+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) 
   : AliDigitNew(),
     fAmpFloat(digEnergy),
     fNSamples(0),
@@ -100,9 +103,10 @@ AliEMCALDigit::AliEMCALDigit(Int_t primary, Int_t iparent, Int_t id, Float_t dig
     fMaxIter(5),
     fTime(time),
     fTimeR(time),
-    fChi2(0.),
-    fNDF(0),
-    fDigitType(type)
+    fChi2(chi2),
+    fNDF(ndf),
+    fDigitType(type),
+    fAmpCalib(-1)
 {  
   // ctor with all data 
 
@@ -149,63 +153,95 @@ AliEMCALDigit::AliEMCALDigit(const AliEMCALDigit & digit)
   : AliDigitNew(digit),
     fAmpFloat(digit.fAmpFloat),        
     fNSamples(digit.fNSamples),
-    fSamples(0x0),
+    fSamples(),
     fNSamplesHG(digit.fNSamplesHG),
-    fSamplesHG(0x0),
+    fSamplesHG(),
     fNprimary(digit.fNprimary),
     fNMaxPrimary(digit.fNMaxPrimary),
-    fPrimary(0x0),
-    fDEPrimary(0x0),
+    fPrimary(),
+    fDEPrimary(),
     fNiparent(digit.fNiparent),
     fNMaxiparent(digit.fNMaxiparent),
-    fIparent(0x0),
-    fDEParent(0x0),
+    fIparent(),
+    fDEParent(),
     fMaxIter(digit.fMaxIter),
     fTime(digit.fTime),
     fTimeR(digit.fTimeR), 
     fChi2(digit.fChi2), 
     fNDF(digit.fNDF),
-    fDigitType(digit.fDigitType)
+    fDigitType(digit.fDigitType),
+    fAmpCalib(digit.fAmpCalib)
 {
   // copy ctor
-  
   // data memebrs of the base class (AliNewDigit)
   fAmp         = digit.fAmp ;
   fId          = digit.fId;
   fIndexInList = digit.fIndexInList ; 
 
   // data members  
-  fSamples     = new Int_t[fNSamples]; 
-  for (Int_t i=0; i < digit.fNSamples; i++) fSamples[i] = digit.fSamples[i];
-  fSamplesHG   = new Int_t[fNSamplesHG]; 
-  for (Int_t i=0; i < digit.fNSamplesHG; i++) fSamplesHG[i] = digit.fSamplesHG[i];
-       
-  fPrimary = new Int_t[fNMaxPrimary] ;  
-  fDEPrimary = new Float_t[fNMaxPrimary] ;
-  fIparent = new Int_t[fNMaxiparent] ;
-  fDEParent = new Float_t[fNMaxiparent] ;
-  Int_t i ;
-  for ( i = 0; i < fNMaxPrimary ; i++) {
-    fPrimary[i]  = digit.fPrimary[i] ;
-    fDEPrimary[i]  = digit.fDEPrimary[i] ;
+  if (fSamples )   delete [] fSamples ;   fSamples   = NULL ;
+  if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
+  if (fPrimary  )  delete [] fPrimary ;   fPrimary   = NULL ;
+  if (fDEPrimary)  delete [] fDEPrimary ; fDEPrimary = NULL ;
+  if (fIparent )   delete [] fIparent ;   fIparent   = NULL ;
+  if (fDEParent)   delete [] fDEParent ;  fDEParent  = NULL ;
+
+  if (fNSamples){
+    fSamples     = new Int_t[fNSamples]; 
+    for (Int_t i=0; i < digit.fNSamples; i++) fSamples[i] = digit.fSamples[i];
   }
-  Int_t j ;
-  for (j = 0; j< fNMaxiparent ; j++) {
-    fIparent[j]  = digit.fIparent[j] ;
-    fDEParent[j]  = digit.fDEParent[j] ;
+  
+  if (fNSamplesHG){
+    fSamplesHG   = new Int_t[fNSamplesHG]; 
+    for (Int_t i=0; i < digit.fNSamplesHG; i++) fSamplesHG[i] = digit.fSamplesHG[i];
   }
+  
+  if (fNMaxPrimary){
+    fPrimary   = new Int_t  [fNMaxPrimary] ;  
+    fDEPrimary = new Float_t[fNMaxPrimary] ;
+    for ( Int_t i = 0; i < fNMaxPrimary ; i++) {
+      fPrimary[i]   = digit.fPrimary[i] ;
+      fDEPrimary[i] = digit.fDEPrimary[i] ;
+    }
+  }
+  
+  if (fNMaxiparent){
+    fIparent  = new Int_t  [fNMaxiparent] ;
+    fDEParent = new Float_t[fNMaxiparent] ;
+    for (Int_t j = 0; j< fNMaxiparent ; j++) {
+    fIparent[j]  = digit.fIparent[j] ;
+    fDEParent[j] = digit.fDEParent[j] ;
+    }
+  }  
 }
 
 //____________________________________________________________________________
 AliEMCALDigit::~AliEMCALDigit() 
 {
-  // Delete array of primiries if any
-    delete [] fPrimary ;
-    delete [] fDEPrimary ;
-    delete [] fIparent ; 
-    delete [] fDEParent ;
-       delete [] fSamples;
-       delete [] fSamplesHG;
+  // Delete array of primaries if any
+
+  if (fSamples )   delete [] fSamples ;   fSamples   = NULL ;
+  if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
+  if (fPrimary  )  delete [] fPrimary ;   fPrimary   = NULL ;
+  if (fDEPrimary)  delete [] fDEPrimary ; fDEPrimary = NULL ;
+  if (fIparent )   delete [] fIparent ;   fIparent   = NULL ;
+  if (fDEParent)   delete [] fDEParent ;  fDEParent  = NULL ;
+
+}
+
+
+//____________________________________________________________________________
+void AliEMCALDigit::Clear(const Option_t*) 
+{
+  // Delete array of primaries if any
+  if (fSamples )   delete [] fSamples ;   fSamples   = NULL ;
+  if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
+  if (fPrimary  )  delete [] fPrimary ;   fPrimary   = NULL ;
+  if (fDEPrimary)  delete [] fDEPrimary ; fDEPrimary = NULL ;
+  if (fIparent )   delete [] fIparent ;   fIparent   = NULL ;
+  if (fDEParent)   delete [] fDEParent ;  fDEParent  = NULL ;
 
 }
 
@@ -215,7 +251,7 @@ Int_t AliEMCALDigit::Compare(const TObject * obj) const
   // Compares two digits with respect to its Id
   // to sort according increasing Id
 
-  Int_t rv ;
+  Int_t rv = 2 ;
 
   AliEMCALDigit * digit = (AliEMCALDigit *)obj ; 
 
@@ -368,6 +404,74 @@ void AliEMCALDigit::ShiftPrimary(Int_t shift){
   for(index =0; index <fNiparent; index++){
     fIparent[index] = fIparent[index] + shift * 10000000 ;}
 }
+
+
+//____________________________________________________________________________
+AliEMCALDigit& AliEMCALDigit::operator= (const AliEMCALDigit &digit)
+{
+  // assignment operator
+  
+  if(&digit == this) return *this;
+  
+  fAmpFloat    = digit.fAmpFloat;      
+  fNSamples    = digit.fNSamples;
+  fNSamplesHG  = digit.fNSamplesHG;
+  fNprimary    = digit.fNprimary;
+  fNMaxPrimary = digit.fNMaxPrimary;
+  fNiparent    = digit.fNiparent;
+  fNMaxiparent = digit.fNMaxiparent;
+  fMaxIter     = digit.fMaxIter;
+  fTime        = digit.fTime;
+  fTimeR       = digit.fTimeR; 
+  fChi2        = digit.fChi2; 
+  fNDF         = digit.fNDF;
+  fDigitType   = digit.fDigitType;
+  fAmpCalib    = digit.fAmpCalib;
+  fAmp         = digit.fAmp ;
+  fId          = digit.fId;
+  fIndexInList = digit.fIndexInList ; 
+  
+  // data members  
+  if (fSamples )   delete [] fSamples ;   fSamples   = NULL ;
+  if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
+  if (fPrimary  )  delete [] fPrimary ;   fPrimary   = NULL ;
+  if (fDEPrimary)  delete [] fDEPrimary ; fDEPrimary = NULL ;
+  if (fIparent )   delete [] fIparent ;   fIparent   = NULL ;
+  if (fDEParent)   delete [] fDEParent ;  fDEParent  = NULL ;
+  
+  if (fNSamples){
+    fSamples     = new Int_t[fNSamples]; 
+    for (Int_t i=0; i < digit.fNSamples; i++) fSamples[i] = digit.fSamples[i];
+  }
+  
+  if (fNSamplesHG){
+    fSamplesHG   = new Int_t[fNSamplesHG]; 
+    for (Int_t i=0; i < digit.fNSamplesHG; i++) fSamplesHG[i] = digit.fSamplesHG[i];
+  }
+  
+  
+  if (fNMaxPrimary){
+    fPrimary   = new Int_t  [fNMaxPrimary] ;  
+    fDEPrimary = new Float_t[fNMaxPrimary] ;
+    for ( Int_t i = 0; i < fNMaxPrimary ; i++) {
+      fPrimary[i]   = digit.fPrimary[i] ;
+      fDEPrimary[i] = digit.fDEPrimary[i] ;
+    }
+  }
+  
+  if (fNMaxiparent){
+    fIparent  = new Int_t  [fNMaxiparent] ;
+    fDEParent = new Float_t[fNMaxiparent] ;
+    for (Int_t j = 0; j< fNMaxiparent ; j++) {
+      fIparent[j]  = digit.fIparent[j] ;
+      fDEParent[j] = digit.fDEParent[j] ;
+    }
+  }  
+  
+  return *this;
+  
+}  
+
 //____________________________________________________________________________
 Bool_t AliEMCALDigit::operator==(AliEMCALDigit const & digit) const 
 {
@@ -388,13 +492,13 @@ AliEMCALDigit AliEMCALDigit::operator+(const AliEMCALDigit &digit)
   fAmpFloat += digit.fAmpFloat ;
   for (Int_t i=0; i < fNSamples  ; i++) fSamples[i]   += digit.fSamples[i];
   for (Int_t i=0; i < fNSamplesHG; i++) fSamplesHG[i] += digit.fSamplesHG[i];
-
+  
   fAmp    += digit.fAmp ;
   if(fTime > digit.fTime)
     fTime = digit.fTime ;
   if (digit.fTimeR < fTimeR)
     fTimeR = digit.fTimeR ; 
-
+  
   Int_t max1 = fNprimary ; 
   Int_t max2 = fNiparent ;  
   Int_t index ; 
@@ -403,24 +507,24 @@ AliEMCALDigit AliEMCALDigit::operator+(const AliEMCALDigit &digit)
     Int_t old ;
     for ( old = 0 ; (old < max1) && newPrim; old++) { //already have this primary?
       if(fPrimary[old] == digit.fPrimary[index]) {
-       newPrim = kFALSE;
-       fDEPrimary[old] += digit.fDEPrimary[index];
+        newPrim = kFALSE;
+        fDEPrimary[old] += digit.fDEPrimary[index];
       }
     }
     if (newPrim) {
       if(max1<fNMaxPrimary){ 
-       fPrimary[max1] = digit.fPrimary[index] ; 
-       fDEPrimary[max1] = digit.fDEPrimary[index] ; 
-       fNprimary++ ;
-       max1++;
+        fPrimary[max1] = digit.fPrimary[index] ; 
+        fDEPrimary[max1] = digit.fDEPrimary[index] ; 
+        fNprimary++ ;
+        max1++;
       }
       if(fNprimary==fNMaxPrimary) {
-       
-       TString mess = " NMaxPrimary  =  " ; 
-       mess += fNMaxPrimary ; 
-       mess += " is too small" ; 
-       Fatal("AliEMCALDigit::Operator+ -->" , mess.Data()) ; 
-
+        
+        TString mess = " NMaxPrimary  =  " ; 
+        mess += fNMaxPrimary ; 
+        mess += " is too small" ; 
+        AliFatal(mess.Data()) ; 
+        
       }
     }
   }
@@ -430,24 +534,24 @@ AliEMCALDigit AliEMCALDigit::operator+(const AliEMCALDigit &digit)
     Int_t old ;
     for ( old = 0 ; (old < max2) && newParent; old++) { //already have this primary?
       if(fIparent[old] == digit.fIparent[index]) {
-       newParent = kFALSE;
-       fDEParent[old] += digit.fDEParent[index];
+        newParent = kFALSE;
+        fDEParent[old] += digit.fDEParent[index];
       }
     }
     if(newParent){
       if(max2<fNMaxiparent) { 
-       fIparent[max2] = digit.fIparent[index] ; 
-       fDEParent[max2] = digit.fDEParent[index] ; 
-       fNiparent++ ;
-       max2++;
+        fIparent[max2] = digit.fIparent[index] ; 
+        fDEParent[max2] = digit.fDEParent[index] ; 
+        fNiparent++ ;
+        max2++;
       }
       if(fNiparent==fNMaxiparent) {
-       
-       TString mess = " NMaxiparent  =  " ; 
-       mess += fNMaxiparent ; 
-       mess += " is too small" ; 
-       Fatal("AliEMCALDigit::Operator+ -->", mess.Data()) ; 
-
+        
+        TString mess = " NMaxiparent  =  " ; 
+        mess += fNMaxiparent ; 
+        mess += " is too small" ; 
+        AliFatal(mess.Data()) ; 
+        
       }
     }
   }
@@ -482,12 +586,11 @@ ostream& operator << ( ostream& out , const AliEMCALDigit & digit)
   // Prints the data of the digit
   
   out << "ID " << digit.fId << " Energy = " << digit.fAmp <<  " Time = " << digit.fTime << endl ; 
-  Int_t i,j ;
-  for(i=0;i<digit.fNprimary;i++) 
+  for(Int_t i=0;i<digit.fNprimary;i++) 
     out << "Primary " << i+1 << " = " << digit.fPrimary[i] 
        << " : DE " << digit.fDEPrimary[i] << endl ;
    
-  for(j=0;j<digit.fNiparent;j++)
+  for(Int_t j=0;j<digit.fNiparent;j++)
     out << "Iparent " << j+1 << " = " << digit.fIparent[j] 
        << " : DE " << digit.fDEParent[j] << endl ;
   out << "Position in list = " << digit.fIndexInList << endl ;