New class AliPHOSCpvRecPoint
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Nov 2000 18:00:05 +0000 (18:00 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Nov 2000 18:00:05 +0000 (18:00 +0000)
PHOS/AliPHOSCpvRecPoint.cxx [new file with mode: 0644]
PHOS/AliPHOSCpvRecPoint.h [new file with mode: 0644]

diff --git a/PHOS/AliPHOSCpvRecPoint.cxx b/PHOS/AliPHOSCpvRecPoint.cxx
new file mode 100644 (file)
index 0000000..acf5eef
--- /dev/null
@@ -0,0 +1,594 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+//_________________________________________________________________________
+//  RecPoint implementation for PHOS-CPV
+//  An CpvRecPoint is a cluster of digits   
+//           
+//*-- Author: Yuri Kharlov 30 October 2000 
+//          (after Dmitri Peressounko (RRC KI & SUBATECH))
+
+
+// --- ROOT system ---
+#include "TPad.h"
+#include "TH2.h"
+#include "TMath.h" 
+#include "TCanvas.h" 
+
+// --- Standard library ---
+
+#include <iostream.h> 
+
+// --- AliRoot header files ---
+
+#include "AliPHOSGeometry.h"
+#include "AliPHOSCpvRecPoint.h"
+#include "AliRun.h"
+#include "AliPHOSIndexToObject.h"
+
+ClassImp(AliPHOSCpvRecPoint)
+
+//____________________________________________________________________________
+AliPHOSCpvRecPoint::AliPHOSCpvRecPoint(Float_t W0, Float_t LocMaxCut)
+  : AliPHOSRecPoint()
+{
+  // ctor
+
+  fMulDigit   = 0 ;  
+  fAmp   = 0. ;   
+  fEnergyList = new Float_t[fMaxDigit]; 
+  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
+  fDelta     =  phosgeom->GetCrystalSize(0) ; 
+  fW0        = W0 ;          
+  fLocMaxCut = LocMaxCut ; 
+  fLocPos.SetX(1000000.)  ;      //Local position should be evaluated
+  fLengX = -1;
+  fLengZ = -1;
+}
+
+//____________________________________________________________________________
+AliPHOSCpvRecPoint::~AliPHOSCpvRecPoint()
+{
+  // dtor
+  if ( fEnergyList ) delete[] fEnergyList ; 
+}
+
+//____________________________________________________________________________
+void AliPHOSCpvRecPoint::AddDigit(AliPHOSDigit & digit, Float_t Energy)
+{
+  // Adds a digit to the RecPoint
+  //  and accumulates the total amplitude and the multiplicity 
+  
+  if ( fMulDigit >= fMaxDigit ) { // increase the size of the lists 
+    fMaxDigit*=2 ; 
+    Int_t * tempo = new ( Int_t[fMaxDigit] ) ; 
+    Float_t * tempoE =  new ( Float_t[fMaxDigit] ) ;
+
+    Int_t index ;     
+    for ( index = 0 ; index < fMulDigit ; index++ ){
+      tempo[index]  = fDigitsList[index] ;
+      tempoE[index] = fEnergyList[index] ; 
+    }
+    
+    delete [] fDigitsList ; 
+    fDigitsList =  new ( Int_t[fMaxDigit] ) ;
+    delete [] fEnergyList ;
+    fEnergyList =  new ( Float_t[fMaxDigit] ) ;
+
+    for ( index = 0 ; index < fMulDigit ; index++ ){
+      fDigitsList[index] = tempo[index] ;
+      fEnergyList[index] = tempoE[index] ; 
+    }
+    delete [] tempo ;
+    delete [] tempoE ; 
+  } // if
+  
+  fDigitsList[fMulDigit]   = digit.GetIndexInList()  ; 
+  fEnergyList[fMulDigit]   = Energy ;
+  fMulDigit++ ; 
+  fAmp += Energy ; 
+}
+
+//____________________________________________________________________________
+Bool_t AliPHOSCpvRecPoint::AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) 
+{
+  // Tells if (true) or not (false) two digits are neighbors)
+  
+  Bool_t aren = kFALSE ;
+  
+  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
+  Int_t relid1[4] ; 
+  phosgeom->AbsToRelNumbering(digit1->GetId(), relid1) ; 
+
+  Int_t relid2[4] ; 
+  phosgeom->AbsToRelNumbering(digit2->GetId(), relid2) ; 
+  
+  Int_t rowdiff = TMath::Abs( relid1[2] - relid2[2] ) ;  
+  Int_t coldiff = TMath::Abs( relid1[3] - relid2[3] ) ;  
+
+  if (( coldiff <= 1 )  && ( rowdiff <= 1 ) && (coldiff + rowdiff > 0)) 
+    aren = kTRUE ;
+  
+  return aren ;
+}
+
+//____________________________________________________________________________
+Int_t AliPHOSCpvRecPoint::Compare(TObject * obj)
+{
+  // Compares two RecPoints according to their position in the PHOS modules
+
+  Int_t rv ; 
+
+  AliPHOSCpvRecPoint * clu = (AliPHOSCpvRecPoint *)obj ; 
+
+  Int_t phosmod1 = this->GetPHOSMod() ;
+  Int_t phosmod2 = clu->GetPHOSMod() ;
+
+  TVector3 locpos1; 
+  this->GetLocalPosition(locpos1) ;
+  TVector3 locpos2;  
+  clu->GetLocalPosition(locpos2) ;  
+
+  if(phosmod1 == phosmod2 ) {
+    Int_t rowdif = (Int_t)TMath::Ceil(locpos1.X()/fDelta)-(Int_t)TMath::Ceil(locpos2.X()/fDelta) ;
+    if (rowdif> 0) 
+      rv = -1 ;
+     else if(rowdif < 0) 
+       rv = 1 ;
+    else if(locpos1.Z()>locpos2.Z()) 
+      rv = -1 ;
+    else 
+      rv = 1 ; 
+     }
+
+  else {
+    if(phosmod1 < phosmod2 ) 
+      rv = -1 ;
+    else 
+      rv = 1 ;
+  }
+
+  return rv ; 
+}
+
+//______________________________________________________________________________
+void AliPHOSCpvRecPoint::ExecuteEvent(Int_t event, Int_t px, Int_t py)
+{
+  // Execute action corresponding to one event
+  //  This member function is called when a AliPHOSRecPoint is clicked with the locator
+  //
+  //  If Left button is clicked on AliPHOSRecPoint, the digits are switched on    
+  //  and switched off when the mouse button is released.
+  //
+
+  //   static Int_t pxold, pyold;
+
+  AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
+  
+  static TGraph *  digitgraph = 0 ;
+  
+  if (!gPad->IsEditable()) return;
+  
+  TH2F * histo = 0 ;
+  TCanvas * histocanvas ; 
+  
+  switch (event) {
+    
+  case kButton1Down: {
+    AliPHOSDigit * digit ;
+    AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
+    Int_t iDigit;
+    Int_t relid[4] ;
+    
+    const Int_t kMulDigit = AliPHOSCpvRecPoint::GetDigitsMultiplicity() ; 
+    Float_t * xi = new Float_t[kMulDigit] ; 
+    Float_t * zi = new Float_t[kMulDigit] ; 
+    
+    // create the histogram for the single cluster 
+    // 1. gets histogram boundaries
+    Float_t ximax = -999. ; 
+    Float_t zimax = -999. ; 
+    Float_t ximin = 999. ; 
+    Float_t zimin = 999. ;
+    
+    for(iDigit=0; iDigit<kMulDigit; iDigit++) {
+      digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
+      phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
+      phosgeom->RelPosInModule(relid, xi[iDigit], zi[iDigit]);
+      if ( xi[iDigit] > ximax )
+       ximax = xi[iDigit] ; 
+      if ( xi[iDigit] < ximin )
+       ximin = xi[iDigit] ; 
+      if ( zi[iDigit] > zimax )
+       zimax = zi[iDigit] ; 
+      if ( zi[iDigit] < zimin )
+       zimin = zi[iDigit] ;     
+    }
+    ximax += phosgeom->GetCrystalSize(0) / 2. ;
+    zimax += phosgeom->GetCrystalSize(2) / 2. ;
+    ximin -= phosgeom->GetCrystalSize(0) / 2. ;
+    zimin -= phosgeom->GetCrystalSize(2) / 2. ;
+    Int_t xdim = (int)( (ximax - ximin ) / phosgeom->GetCrystalSize(0) + 0.5  ) ; 
+    Int_t zdim = (int)( (zimax - zimin ) / phosgeom->GetCrystalSize(2) + 0.5 ) ;
+    
+    // 2. gets the histogram title
+    
+    Text_t title[100] ; 
+    sprintf(title,"Energy=%1.2f GeV ; Digits ; %d ", GetEnergy(), GetDigitsMultiplicity()) ;
+    
+    if (!histo) {
+      delete histo ; 
+      histo = 0 ; 
+    }
+    histo = new TH2F("cluster3D", title,  xdim, ximin, ximax, zdim, zimin, zimax)  ;
+    
+    Float_t x, z ; 
+    for(iDigit=0; iDigit<kMulDigit; iDigit++) {
+      digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
+      phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
+      phosgeom->RelPosInModule(relid, x, z);
+      histo->Fill(x, z, fEnergyList[iDigit] ) ;
+    }
+    
+    if (!digitgraph) {
+      digitgraph = new TGraph(kMulDigit,xi,zi);
+      digitgraph-> SetMarkerStyle(5) ; 
+      digitgraph-> SetMarkerSize(1.) ;
+      digitgraph-> SetMarkerColor(1) ;
+      digitgraph-> Paint("P") ;
+    }
+    
+    Print() ;
+    histocanvas = new TCanvas("cluser", "a single cluster", 600, 500) ; 
+    histocanvas->Draw() ; 
+    histo->Draw("lego1") ; 
+    
+    delete[] xi ; 
+    delete[] zi ; 
+    
+    break;
+  }
+  
+  case kButton1Up: 
+    if (digitgraph) {
+      delete digitgraph  ;
+      digitgraph = 0 ;
+    }
+    break;
+  
+   }
+}
+
+//____________________________________________________________________________
+Float_t  AliPHOSCpvRecPoint::GetDispersion() 
+{
+  // Calculates the dispersion of the shower at the origine of the RecPoint
+
+  AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
+
+  Float_t d    = 0 ;
+  Float_t wtot = 0 ;
+
+  TVector3 locpos;
+  GetLocalPosition(locpos);
+  Float_t x = locpos.X() ;
+  Float_t z = locpos.Z() ;
+
+  AliPHOSDigit * digit ;
+  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
+  
+  Int_t iDigit;
+  for(iDigit=0; iDigit < fMulDigit; iDigit++) {
+    digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
+    Int_t relid[4] ;
+    Float_t xi ;
+    Float_t zi ;
+    phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
+    phosgeom->RelPosInModule(relid, xi, zi);
+    Float_t w = TMath::Max(0.,fW0+TMath::Log(fEnergyList[iDigit]/fAmp ) ) ;
+    d += w*((xi-x)*(xi-x) + (zi-z)*(zi-z) ) ; 
+    wtot+=w ;
+  }
+
+  d /= wtot ;
+
+  return TMath::Sqrt(d) ;
+}
+
+//____________________________________________________________________________
+void  AliPHOSCpvRecPoint::GetElipsAxis(Float_t * lambda)
+{
+  // Calculates the axis of the shower ellipsoid
+
+  AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
+
+  Float_t wtot = 0. ;
+  Float_t x    = 0.;
+  Float_t z    = 0.;
+  Float_t dxx  = 0.;
+  Float_t dzz  = 0.;
+  Float_t dxz  = 0.;
+
+  AliPHOSDigit * digit ;
+  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
+  Int_t iDigit;
+
+  for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+    digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
+    Int_t relid[4] ;
+    Float_t xi ;
+    Float_t zi ;
+    phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
+    phosgeom->RelPosInModule(relid, xi, zi);
+    Float_t w = TMath::Max(0.,fW0+TMath::Log(fEnergyList[iDigit]/fAmp ) ) ;
+    dxx  += w * xi * xi ;
+    x    += w * xi ;
+    dzz  += w * zi * zi ;
+    z    += w * zi ; 
+    dxz  += w * xi * zi ; 
+    wtot += w ;
+  }
+
+  dxx /= wtot ;
+  x   /= wtot ;
+  dxx -= x * x ;
+  dzz /= wtot ;
+  z   /= wtot ;
+  dzz -= z * z ;
+  dxz /= wtot ;
+  dxz -= x * z ;
+
+  Float_t tmp0 = 0.5 * (dxx + dzz) + TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz );
+  Float_t tmp1 = 0.5 * (dxx + dzz) - TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz );
+  if (tmp0>=0) lambda[0] = TMath::Sqrt(tmp0);
+  else lambda[0] = -TMath::Sqrt(-tmp0);
+  if (tmp1>=0) lambda[1] = TMath::Sqrt(tmp1);
+  else lambda[1] = -TMath::Sqrt(-tmp1);
+//    lambda[0] = TMath::Sqrt( 0.5 * (dxx + dzz) + TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz ) ) ;
+//    lambda[1] = TMath::Sqrt( 0.5 * (dxx + dzz) - TMath::Sqrt( 0.25 * (dxx - dzz) * (dxx - dzz) + dxz * dxz ) ) ;
+}
+
+//____________________________________________________________________________
+void AliPHOSCpvRecPoint::GetLocalPosition(TVector3 &LPos)
+{
+  // Calculates the center of gravity in the local PHOS-module coordinates 
+
+  AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
+
+  if( fLocPos.X() < 1000000.) { // already evaluated
+   LPos = fLocPos ;
+   return ;
+  }
+
+  Float_t wtot = 0. ;
+  Int_t relid[4] ;
+
+  Float_t x = 0. ;
+  Float_t z = 0. ;
+  
+  AliPHOSDigit * digit ;
+
+  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
+
+  Int_t iDigit;
+
+  for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+    digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) );
+
+    Float_t xi ;
+    Float_t zi ;
+    phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
+    phosgeom->RelPosInModule(relid, xi, zi);
+    Float_t w = TMath::Max( 0., fW0 + TMath::Log( fEnergyList[iDigit] / fAmp ) ) ;
+    x    += xi * w ;
+    z    += zi * w ;
+    wtot += w ;
+  }
+
+  if (wtot != 0) {
+    x /= wtot ;
+    z /= wtot ;
+  } else {
+    x = -1e6 ;
+    z = -1e6 ;
+    if (fMulDigit != 0) cout << "AliPHOSCpvRecPoint: too low log weight factor "
+                            << "to evaluate cluster's center\n";
+  }
+  fLocPos.SetX(x)  ;
+  fLocPos.SetY(0.) ;
+  fLocPos.SetZ(z)  ;
+
+  LPos = fLocPos ;
+}
+
+//____________________________________________________________________________
+void AliPHOSCpvRecPoint::GetClusterLengths(Int_t &lengX, Int_t &lengZ)
+{
+  // Calculates the cluster lengths along X and Z axes
+  // These characteristics are needed for CPV to tune
+  // digitization+reconstruction to experimental data
+  // Yuri Kharlov. 24 October 2000
+
+  if( fLengX != -1 && fLengZ != -1 ) { // already evaluated
+    lengX = fLengX ;
+    lengZ = fLengZ ;
+    return ;
+  }
+
+  AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
+
+  Int_t relid[4] ;
+
+  AliPHOSDigit * digit ;
+
+  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
+
+  const Int_t maxleng=20;
+  Int_t idX[maxleng], idZ[maxleng];
+  lengX = 0;
+  lengZ = 0;
+  Bool_t dejavu;
+
+  for(Int_t iDigit=0; iDigit<fMulDigit; iDigit++) {
+    digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) );
+    Int_t absId = digit->GetId();
+    phosgeom->AbsToRelNumbering(absId, relid) ;
+
+    dejavu=kFALSE;
+    for (Int_t i=0; i<lengX; i++) if (relid[2]==idX[i]) { dejavu=kTRUE; break; }
+    if (!dejavu) {
+      idX[lengX]=relid[2];
+      lengX++;
+      lengX = TMath::Min(lengX,maxleng);
+    }
+
+    dejavu=kFALSE;
+    for (Int_t i=0; i<lengZ; i++) if (relid[3]==idZ[i]) { dejavu=kTRUE; break; }
+    if (!dejavu) {
+      idZ[lengZ]=relid[3];
+      lengZ++;
+      lengZ = TMath::Min(lengZ,maxleng);
+    }
+  }
+  fLengX = lengX;
+  fLengZ = lengZ;
+}
+
+//____________________________________________________________________________
+Float_t AliPHOSCpvRecPoint::GetMaximalEnergy(void)
+{
+  // Finds the maximum energy in the cluster
+  
+  Float_t menergy = 0. ;
+
+  Int_t iDigit;
+
+  for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+    if(fEnergyList[iDigit] > menergy) 
+      menergy = fEnergyList[iDigit] ;
+  }
+  return menergy ;
+}
+
+//____________________________________________________________________________
+Int_t AliPHOSCpvRecPoint::GetMultiplicityAtLevel(const Float_t H) 
+{
+  // Calculates the multiplicity of digits with energy larger than H*energy 
+  
+  Int_t multipl   = 0 ;
+  Int_t iDigit ;
+  for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+
+    if(fEnergyList[iDigit] > H * fAmp) 
+      multipl++ ;
+  }
+  return multipl ;
+}
+
+//____________________________________________________________________________
+Int_t  AliPHOSCpvRecPoint::GetNumberOfLocalMax(Int_t *  maxAt, Float_t * maxAtEnergy) 
+{ 
+  // Calculates the number of local maxima in the cluster using fLocalMaxCut as the minimum
+  //  energy difference between two local maxima
+
+  AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
+
+  AliPHOSDigit * digit ;
+  AliPHOSDigit * digitN ;
+  
+
+  Int_t iDigitN ;
+  Int_t iDigit ;
+
+  for(iDigit = 0; iDigit < fMulDigit; iDigit++){
+    maxAt[iDigit] = (Int_t) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
+  }
+  
+  for(iDigit = 0 ; iDigit < fMulDigit; iDigit++) {   
+    if(maxAt[iDigit] != -1) {
+      digit = (AliPHOSDigit *) maxAt[iDigit] ;
+          
+      for(iDigitN = 0; iDigitN < fMulDigit; iDigitN++) {       
+       digitN = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigitN]) ) ; 
+       
+       if ( AreNeighbours(digit, digitN) ) {
+         if (fEnergyList[iDigit] > fEnergyList[iDigitN] ) {    
+           maxAt[iDigitN] = -1 ;
+           // but may be digit too is not local max ?
+           if(fEnergyList[iDigit] < fEnergyList[iDigitN] + fLocMaxCut) 
+             maxAt[iDigit] = -1 ;
+         }
+         else {
+           maxAt[iDigit] = -1 ;
+           // but may be digitN too is not local max ?
+           if(fEnergyList[iDigit] > fEnergyList[iDigitN] - fLocMaxCut) 
+             maxAt[iDigitN] = -1 ; 
+         } 
+       } // if Areneighbours
+      } // while digitN
+    } // slot not empty
+  } // while digit
+  
+  iDigitN = 0 ;
+  for(iDigit = 0; iDigit < fMulDigit; iDigit++) { 
+    if(maxAt[iDigit] != -1){
+      maxAt[iDigitN] = maxAt[iDigit] ;
+      maxAtEnergy[iDigitN] = fEnergyList[iDigit] ;
+      iDigitN++ ; 
+    }
+  }
+  return iDigitN ;
+}
+
+
+//____________________________________________________________________________
+void AliPHOSCpvRecPoint::Print(Option_t * option) 
+{
+  // Print the list of digits belonging to the cluster
+  
+  cout << "AliPHOSCpvRecPoint: " << endl ;
+
+  AliPHOSDigit * digit ; 
+  Int_t iDigit;
+  AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
+
+  Float_t xi ;
+  Float_t zi ;
+  Int_t relid[4] ; 
+  
+  AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ; 
+
+  for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+    digit = please->GimeDigit( fDigitsList[iDigit] ) ; 
+    phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
+    phosgeom->RelPosInModule(relid, xi, zi);
+    cout << " Id = " << digit->GetId() ;  
+    cout << "   module  = " << relid[0] ;  
+    cout << "   x  = " << xi ;  
+    cout << "   z  = " << zi ;  
+    cout << "   Energy = " << fEnergyList[iDigit] << endl ;
+  }
+  cout << "       Multiplicity    = " << fMulDigit  << endl ;
+  cout << "       Cluster Energy  = " << fAmp << endl ;
+  cout << "       Stored at position " << GetIndexInList() << endl ; 
+}
diff --git a/PHOS/AliPHOSCpvRecPoint.h b/PHOS/AliPHOSCpvRecPoint.h
new file mode 100644 (file)
index 0000000..0fb3c2b
--- /dev/null
@@ -0,0 +1,107 @@
+#ifndef ALIPHOSCPVRECPOINT_H
+#define ALIPHOSCPVRECPOINT_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+//_________________________________________________________________________
+//  RecPoint implementation for PHOS-CPV
+//  An CpvRecPoint is a cluster of digits   
+//           
+//*-- Author: Yuri Kharlov 30 October 2000 
+//          (after Dmitri Peressounko (RRC KI & SUBATECH))
+
+// --- ROOT system ---
+
+#include "TObject.h"
+#include "TArrayI.h"
+// --- Standard library ---
+
+// --- AliRoot header files ---
+
+#include "AliPHOSDigit.h"
+#include "AliPHOSRecPoint.h"
+
+class AliPHOSCpvRecPoint : public AliPHOSRecPoint  {
+
+public:
+
+  AliPHOSCpvRecPoint(){
+   // default ctor
+    fEnergyList = 0;  
+  } ;                    
+  AliPHOSCpvRecPoint(Float_t W0, Float_t LocMaxCut) ;
+  AliPHOSCpvRecPoint(const AliPHOSCpvRecPoint & rp) {
+    // cpy ctor requested by Coding Convention 
+    // but not yet needed
+    assert(0==1) ; 
+  } 
+  virtual ~AliPHOSCpvRecPoint() ;  
+
+  virtual void  AddDigit(AliPHOSDigit & digit, Float_t Energy) ;  // add a digit to the digits list  
+  Int_t       Compare(TObject * obj) ;                         // method for sorting  
+  
+  Float_t     GetDelta (){ 
+    // gets the fDelta data member 
+    return fDelta ; }    
+  Float_t     GetDispersion() ;                               // computes the dispersion of the shower
+  void        GetElipsAxis(Float_t * lambda) ;                // computes the axis of shower ellipsoide
+  Float_t *   GetEnergiesList(){
+    // gets the list of energies makink this recpoint
+    return fEnergyList ;} 
+  virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) ; 
+  Float_t     GetLocMaxCut () {
+    // gets the cut of the local maximum search 
+    return fLocMaxCut ; }
+  Float_t     GetLogWeightCut (){
+    // gets the logarythmic weight for the center of gravity calculation
+    return fW0 ; }
+  Float_t     GetMaximalEnergy(void) ;                        // get the highest energy in the cluster
+  Int_t       GetMaximumMultiplicity() { 
+    // gets the maximum number of digits allowed
+    return   fMaxDigit ; } 
+  Int_t       GetMultiplicity(void) const { 
+    // gets the number of digits making this recpoint
+    return fMulDigit ; } 
+  Int_t       GetMultiplicityAtLevel(const Float_t level) ;   // computes multiplicity of digits with energy above relative level
+  Int_t       GetNumberOfLocalMax(Int_t *  maxAt, Float_t * maxAtEnergy) ; // searches for the local maxima 
+  Float_t     GetTotalEnergy(void) const { 
+    // gets the total amplitude of this recpoint (in EMC RecPoint Amp = Energy)
+    return fAmp ; }    
+  void        GetLocalPosition(TVector3 &Lpos) ;  // computes the position in the PHOS module 
+  void        GetClusterLengths(Int_t &lengX, Int_t &lengZ); // cluster lengths along x and z
+  Bool_t      IsCPV(void) {
+    // true if the recpoint is in CPV
+    return kTRUE ; } 
+  Bool_t      IsSortable() const { 
+    // says that emcrecpoints are sortable objects 
+    return kTRUE ; } 
+  void        Print(Option_t * opt = "void") ; 
+
+  AliPHOSCpvRecPoint & operator = (const AliPHOSCpvRecPoint & rvalue)  {
+    // assignement operator requested by coding convention
+    // but not needed
+    assert(0==1) ;
+    return *this ; 
+  }
+
+ private:
+
+  Bool_t AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) ;
+
+  Float_t  fDelta ;          // parameter used to sort the clusters    
+  Float_t  *fEnergyList ;    //[fMulDigit] energy of digits
+  Float_t  fLocMaxCut ;      // minimum energy difference to distinguish two maxima 
+  Float_t  fW0 ;             // logarithmic weight factor for center of gravity calculation
+  Int_t    fLengX ;          // cluster length along x
+  Int_t    fLengZ ;          // cluster length along z
+  
+  ClassDef(AliPHOSCpvRecPoint,1)  // CPV RecPoint (cluster)
+
+};
+
+#endif // AliPHOSCPVRECPOINT_H