the MIXT geometry (IHEP+GPS2) has been introduced
[u/mrichter/AliRoot.git] / PHOS / AliPHOSClusterizerv1.cxx
index 89160c8..156b57c 100644 (file)
 
 /* $Id$ */
 
+/* $Log:
+   1 October 2000. Yuri Kharlov:
+     AreNeighbours()
+     PPSD upper layer is considered if number of layers>1
+
+   18 October 2000. Yuri Kharlov:
+     AliPHOSClusterizerv1()
+     CPV clusterizing parameters added
+
+     MakeClusters()
+     After first PPSD digit remove EMC digits only once
+*/
+
 //_________________________________________________________________________
 //  Implementation version 1 of the clusterization algorithm 
 // 
 //*-- Author: Yves Schutz (SUBATECH) 
 //////////////////////////////////////////////////////////////////////////////
 
+#include <assert.h>
+
 // --- ROOT system ---
 
 #include "TMath.h" 
@@ -35,6 +50,7 @@
 #include "AliPHOSDigit.h"
 #include "AliPHOSEmcRecPoint.h"
 #include "AliPHOSPpsdRecPoint.h"
+#include "AliPHOSCpvRecPoint.h"
 #include "AliPHOSv0.h" 
 #include "AliRun.h" 
 
@@ -52,10 +68,14 @@ AliPHOSClusterizerv1::AliPHOSClusterizerv1()
   fNumberOfPpsdClusters    = 0 ; 
   fEmcClusteringThreshold  = 0.1;   
   fEmcEnergyThreshold      = 0.01;    
-  fPpsdClusteringThreshold = 0.00000015; 
-  fPpsdEnergyThreshold     = 0.0000001;  
+  fPpsdClusteringThreshold = 0.0;
+  fPpsdEnergyThreshold     = 0.1;  
+  fCpvClusteringThreshold  = 0.0;
+  fCpvEnergyThreshold      = 0.1;  
   fW0                      = 4.5 ;
   fLocMaxCut               = 0.06 ;
+  fW0CPV                   = 4.5 ;
+  fLocMaxCutCPV            = 0.06 ;
 }
 
 //____________________________________________________________________________
@@ -95,7 +115,12 @@ Int_t AliPHOSClusterizerv1::AreNeighbours(AliPHOSDigit * d1, AliPHOSDigit * d2)
       rv=2 ;
 
   }
-  
+
+  //Do NOT clusterize upper PPSD  
+  if( IsInPpsd(d1) && IsInPpsd(d2) &&
+     relid1[1] > 0                 &&
+     relid1[1] < fGeom->GetNumberOfPadsPhi()*fGeom->GetNumberOfPadsPhi() ) rv = 2 ;
+
   return rv ; 
 }
 
@@ -110,9 +135,6 @@ void AliPHOSClusterizerv1::FillandSort(const DigitsList * dl, TObjArray * tl)
   TIter next(dl) ; 
   AliPHOSDigit * digit ;
   
-
   while ( (digit = (AliPHOSDigit *)next()) ) { 
 
 //     cout << " clusterizerv1 " << endl ;
@@ -158,8 +180,37 @@ Bool_t AliPHOSClusterizerv1::IsInEmc(AliPHOSDigit * digit)
   Int_t relid[4] ; 
   fGeom->AbsToRelNumbering(digit->GetId(), relid) ; 
 
-  if ( relid[1] == 0  )
-    rv = kTRUE; 
+  if ( relid[1] == 0  ) rv = kTRUE; 
+
+  return rv ; 
+}
+
+//____________________________________________________________________________
+Bool_t AliPHOSClusterizerv1::IsInPpsd(AliPHOSDigit * digit) 
+{
+  // Tells if (true) or not (false) the digit is in a PHOS-EMC module
+  Bool_t rv = kFALSE ; 
+
+  Int_t relid[4] ; 
+  fGeom->AbsToRelNumbering(digit->GetId(), relid) ; 
+
+  if ( relid[1] > 0 && relid[0] > fGeom->GetNCPVModules() ) rv = kTRUE; 
+
+  return rv ; 
+}
+
+//____________________________________________________________________________
+Bool_t AliPHOSClusterizerv1::IsInCpv(AliPHOSDigit * digit) 
+{
+  // Tells if (true) or not (false) the digit is in a PHOS-EMC module
+  Bool_t rv = kFALSE ; 
+
+  Int_t relid[4] ; 
+  fGeom->AbsToRelNumbering(digit->GetId(), relid) ; 
+
+  if ( relid[1] > 0 && relid[0] <= fGeom->GetNCPVModules() ) rv = kTRUE; 
 
   return rv ; 
 }
@@ -167,11 +218,16 @@ Bool_t AliPHOSClusterizerv1::IsInEmc(AliPHOSDigit * digit)
 //____________________________________________________________________________
 void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl, 
                                        AliPHOSRecPoint::RecPointsList * emcl, 
-                                       AliPHOSRecPoint::RecPointsList * ppsdl)
+                                       AliPHOSRecPoint::RecPointsList * ppsdl, 
+                                       AliPHOSRecPoint::RecPointsList * cpvl)
 {
   // Steering method to construct the clusters stored in a list of Reconstructed Points
   // A cluster is defined as a list of neighbour digits
-  
+
+  fNumberOfEmcClusters  = 0 ;
+  fNumberOfPpsdClusters = 0 ;
+  fNumberOfCpvClusters  = 0 ;
+
   // Fill and sort the working digits list
   TObjArray tempodigitslist( dl->GetEntries() ) ;
   FillandSort(dl, &tempodigitslist) ; 
@@ -183,18 +239,18 @@ void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
 
   while ( (digit = (AliPHOSDigit *)nextdigit()) ) { // scan over the list of digits
     AliPHOSRecPoint * clu ; 
-   
+
     AliPHOSDigit ** clusterdigitslist = new AliPHOSDigit*[dl->GetEntries()] ;   
     Int_t index ;
-    if (( ( IsInEmc(digit) ) && ( Calibrate(digit->GetAmp() ) > fEmcClusteringThreshold ) ) || 
-        ( ( !IsInEmc(digit) ) && ( Calibrate(digit->GetAmp() ) > fPpsdClusteringThreshold ) ) ) {
+    if (( IsInEmc (digit) && Calibrate(digit->GetAmp()) > fEmcClusteringThreshold  ) || 
+        ( IsInPpsd(digit) && Calibrate(digit->GetAmp()) > fPpsdClusteringThreshold ) ||
+        ( IsInCpv (digit) && Calibrate(digit->GetAmp()) > fCpvClusteringThreshold  ) ) {
   
       Int_t iDigitInCluster = 0 ; 
 
       if  ( IsInEmc(digit) ) {   
        // start a new EMC RecPoint
-       //        new ((*emcl)[fNumberOfEmcClusters]) AliPHOSEmcRecPoint(fW0, fLocMaxCut) ; if TClonesArray
-       fNumberOfEmcClusters = emcl->GetEntries() ;
+       if(fNumberOfEmcClusters >= emcl->GetSize()) emcl->Expand(2*fNumberOfEmcClusters+1) ;
        (*emcl)[fNumberOfEmcClusters] = new  AliPHOSEmcRecPoint(fW0, fLocMaxCut) ;
        clu = (AliPHOSEmcRecPoint *) emcl->At(fNumberOfEmcClusters) ; 
        fNumberOfEmcClusters++ ; 
@@ -203,17 +259,25 @@ void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
        iDigitInCluster++ ; 
        tempodigitslist.Remove(digit) ; 
 
-      }
-
-      else { 
+      } else { 
        
        // start a new PPSD cluster
-       // new ((*ppsdl)[fNumberOfPpsdClusters]) AliPHOSPpsdRecPoint() ;  if TClonesArray
-       fNumberOfPpsdClusters = ppsdl->GetEntries() ; 
-       (*ppsdl)[fNumberOfPpsdClusters] = new AliPHOSPpsdRecPoint() ;
-       
-       clu =  (AliPHOSPpsdRecPoint *) ppsdl->At(fNumberOfPpsdClusters)  ;  
-       fNumberOfPpsdClusters++ ; 
+       if(fNumberOfPpsdClusters >= ppsdl->GetSize()) ppsdl->Expand(2*fNumberOfPpsdClusters+1);
+       if(fNumberOfCpvClusters  >= cpvl ->GetSize()) cpvl ->Expand(2*fNumberOfCpvClusters +1);
+       if      (IsInPpsd(digit)) {
+         (*ppsdl)[fNumberOfPpsdClusters] = new AliPHOSPpsdRecPoint() ;
+         clu =  (AliPHOSPpsdRecPoint *) ppsdl->At(fNumberOfPpsdClusters)  ;  
+         fNumberOfPpsdClusters++ ; 
+       }
+       else if (IsInCpv(digit) ) {
+         (*cpvl) [fNumberOfCpvClusters]  = new AliPHOSCpvRecPoint(fW0CPV, fLocMaxCutCPV) ;
+         clu =  (AliPHOSCpvRecPoint  *) cpvl ->At(fNumberOfCpvClusters)  ;  
+         fNumberOfCpvClusters++ ; 
+       }
+       else {
+         cout << "AliPHOSClusterizerv1::MakeClusters: unknown configuration " << fGeom->GetName() << endl;
+         assert(0==1);
+       }
        clu->AddDigit(*digit, Calibrate(digit->GetAmp()) ) ;    
        clusterdigitslist[iDigitInCluster] = digit  ;   
        iDigitInCluster++ ; 
@@ -223,17 +287,14 @@ void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
        // Here we remove resting EMC digits, which cannot make cluster
 
         if( notremoved ) { 
-         
          while( ( digit = (AliPHOSDigit *)nextdigit() ) ) {
-           
             if( IsInEmc(digit) ) 
              tempodigitslist.Remove(digit) ;
             else 
              break ;
-         
-         } // while digit  
-         
-       } // if notremoved 
+         }
+         notremoved = kFALSE ;
+       }
        
       } // else        
       
@@ -245,10 +306,10 @@ void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
        digit =  clusterdigitslist[index]  ;      
        index++ ; 
         while ( (digitN = (AliPHOSDigit *)nextdigit()) ) { // scan over the reduced list of digits 
-         Int_t ineb = AreNeighbours(digit, digitN);   //  call (digit,digitN) in THAT oder !!!!!
+         Int_t ineb = AreNeighbours(digit, digitN);       // call (digit,digitN) in THAT oder !!!!!
           switch (ineb ) {
           case 0 :   // not a neighbour
-           break ;      
+           break ;
          case 1 :   // are neighbours 
            clu->AddDigit(*digitN, Calibrate( digitN->GetAmp() ) ) ;
            clusterdigitslist[iDigitInCluster] = digitN ; 
@@ -265,15 +326,18 @@ void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl,
        nextdigit.Reset() ; 
        
       } // loop over cluster     
-   }  //below energy theshold  
-  
+    }  //below energy theshold  
+    
     delete[] clusterdigitslist ; 
     
   } // while digit
 
   tempodigitslist.Clear() ; 
 
+  ppsdl->Sort() ;
+  Int_t index ;
+  for(index = 0; index < ppsdl->GetEntries(); index++)
+    ((AliPHOSPpsdRecPoint *)ppsdl->At(index))->SetIndexInList(index) ;
 }
 
 //____________________________________________________________________________
@@ -285,5 +349,7 @@ void AliPHOSClusterizerv1::PrintParameters()
        << "                       EMC  Clustering threshold = " << fEmcClusteringThreshold << endl
        << "                       EMC  Energy threshold     = " << fEmcEnergyThreshold << endl                  
        << "                      PPSD  Clustering threshold = " << fPpsdClusteringThreshold << endl
-       << "                      PPSD  Energy threshold     = " << fPpsdEnergyThreshold << endl ;                
+       << "                      PPSD  Energy threshold     = " << fPpsdEnergyThreshold << endl
+       << "                       CPV  Clustering threshold = " << fCpvClusteringThreshold << endl
+       << "                       CPV  Energy threshold     = " << fCpvEnergyThreshold << endl ;                
 }