adjust settings for cluster cuts

[u/mrichter/AliRoot.git] / EMCAL / AliEMCALRecPoint.cxx

diff --git a/EMCAL/AliEMCALRecPoint.cxx b/EMCAL/AliEMCALRecPoint.cxx
index aff07003d5803a4c78c3fb13b8a7fae7d7d4f8a1..0b452642fc1f7f350c8ea51166eac5e299434988 100644 (file)
--- a/EMCAL/AliEMCALRecPoint.cxx
+++ b/EMCAL/AliEMCALRecPoint.cxx
@@ -161,36 +161,59 @@ AliEMCALRecPoint& AliEMCALRecPoint::operator= (const AliEMCALRecPoint &rp)
 
   if(&rp == this) return *this;
 
-  fGeomPtr = rp.fGeomPtr;
-  fAmp = rp.fAmp;
+  fGeomPtr     = rp.fGeomPtr;
+  fAmp         = rp.fAmp;
   fIndexInList = rp.fIndexInList;
-  fGlobPos = rp.fGlobPos;
-  fLocPos  = rp.fLocPos;
-  fMaxDigit = rp.fMaxDigit;
-  fMulDigit = rp.fMulDigit;
-  fMaxTrack = rp.fMaxTrack;
-  fMulTrack = rp.fMaxTrack;
+  fGlobPos     = rp.fGlobPos;
+  fLocPos      = rp.fLocPos;
+  fMaxDigit    = rp.fMaxDigit;
+  fMulDigit    = rp.fMulDigit;
+  fMaxTrack    = rp.fMaxTrack;
+  fMulTrack    = rp.fMulTrack;
+  
+  if(fDigitsList) delete [] fDigitsList;
+  fDigitsList = new Int_t[rp.fMaxDigit];
+  if(fTracksList) delete [] fTracksList;
+  fTracksList = new Int_t[rp.fMaxTrack];
   for(Int_t i = 0; i<fMaxDigit; i++) fDigitsList[i] = rp.fDigitsList[i];
   for(Int_t i = 0; i<fMaxTrack; i++) fTracksList[i] = rp.fTracksList[i];
+  
   fClusterType = rp.fClusterType;
   fCoreEnergy  = rp.fCoreEnergy; 
   fDispersion  = rp.fDispersion;
+  
+  
+  if(fEnergyList) delete [] fEnergyList;
+  fEnergyList = new Float_t[rp.fMaxDigit];
+  if(fAbsIdList) delete [] fAbsIdList;
+  fAbsIdList = new Int_t[rp.fMaxDigit];  
   for(Int_t i = 0; i<fMaxDigit; i++) {
     fEnergyList[i] = rp.fEnergyList[i];
     fAbsIdList[i]  = rp.fAbsIdList[i];
   }
-  fTime = rp.fTime;
-  fNExMax = rp.fNExMax;
+  
+  fTime       = rp.fTime;
+  fNExMax     = rp.fNExMax;
   fCoreRadius = rp.fCoreRadius;
+  
+  if(fDETracksList) delete [] fDETracksList;
+  fDETracksList = new Float_t[rp.fMaxTrack];
   for(Int_t i = 0; i < fMaxTrack; i++) fDETracksList[i] = rp.fDETracksList[i];
+
   fMulParent = rp.fMulParent;
   fMaxParent = rp.fMaxParent;
+  
+  if(fParentsList) delete [] fParentsList;
+  fParentsList = new Int_t[rp.fMaxParent];
+  if(fDEParentsList) delete [] fDEParentsList;
+  fDEParentsList = new Float_t[rp.fMaxParent];
   for(Int_t i = 0; i < fMaxParent; i++) {
-    fParentsList[i] = rp.fParentsList[i]; 
+    fParentsList[i]   = rp.fParentsList[i]; 
     fDEParentsList[i] = rp.fDEParentsList[i];
   }
+  
   fSuperModuleNumber = rp.fSuperModuleNumber;
-  fDigitIndMax = rp.fDigitIndMax;
+  fDigitIndMax       = rp.fDigitIndMax;
 
   fLambda[0] = rp.fLambda[0];
   fLambda[1] = rp.fLambda[1];
@@ -269,15 +292,20 @@ Bool_t AliEMCALRecPoint::AreNeighbours(AliEMCALDigit * digit1, AliEMCALDigit * d
   // In case of a shared cluster, index of SM in C side, columns start at 48 and ends at 48*2-1
   // C Side impair SM, nSupMod%2=1; A side pair SM nSupMod%2=0
   if(fSharedCluster){
-    if(nSupMod1%2) relid1[1]+=AliEMCALGeoParams::fgkEMCALCols;
-    else           relid2[1]+=AliEMCALGeoParams::fgkEMCALCols;
+    //printf("Shared cluster in 2 SMs!\n");
+
+    //    if(nSupMod1%2) relid1[1]+=AliEMCALGeoParams::fgkEMCALCols;//bad
+    //    else           relid2[1]+=AliEMCALGeoParams::fgkEMCALCols;//bad
+    if(nSupMod1%2) relid2[1]+=AliEMCALGeoParams::fgkEMCALCols;
+    else           relid1[1]+=AliEMCALGeoParams::fgkEMCALCols;
   }
        
   rowdiff = TMath::Abs( relid1[0] - relid2[0] ) ;  
   coldiff = TMath::Abs( relid1[1] - relid2[1] ) ;  
 
-  if (( coldiff <= 1 )  && ( rowdiff <= 1 ) && (coldiff + rowdiff > 0)) 
-  areNeighbours = kTRUE ;
+  //if (( coldiff <= 1 )  && ( rowdiff <= 1 ) && (coldiff + rowdiff > 0)) 
+  if ((coldiff + rowdiff == 1 )) 
+    areNeighbours = kTRUE ;
   
   return areNeighbours;
 }
@@ -1211,6 +1239,7 @@ Int_t  AliEMCALRecPoint::GetNumberOfLocalMax(AliEMCALDigit **  maxAt, Float_t *
       digit = maxAt[iDigit] ;
           
       for(iDigitN = 0; iDigitN < fMulDigit; iDigitN++) {       
+       if(iDigitN == iDigit) continue;//the same digit
         digitN = (AliEMCALDigit *) digits->At(fDigitsList[iDigitN]) ; 
        
        if ( AreNeighbours(digit, digitN) ) {
@@ -1219,8 +1248,7 @@ Int_t  AliEMCALRecPoint::GetNumberOfLocalMax(AliEMCALDigit **  maxAt, Float_t *
            // but may be digit too is not local max ?
            if(fEnergyList[iDigit] < fEnergyList[iDigitN] + locMaxCut) 
              maxAt[iDigit] = 0 ;
-         }
-         else {
+         } else {
            maxAt[iDigit] = 0 ;
            // but may be digitN too is not local max ?
            if(fEnergyList[iDigit] > fEnergyList[iDigitN] - locMaxCut) 
@@ -1239,6 +1267,7 @@ Int_t  AliEMCALRecPoint::GetNumberOfLocalMax(AliEMCALDigit **  maxAt, Float_t *
       iDigitN++ ; 
     }
   }
+
   return iDigitN ;
 }