ROOT logo
/**************************************************************************
 * 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$ */

//-----------------------------------------------------------------------------
/// \class AliMUONClusterFinderPeakFit
/// 
/// Clusterizer class based on simple peak finder
///
/// Pre-clustering is handled by AliMUONPreClusterFinder
/// From a precluster a pixel array is built, and its local maxima are used
/// to get pads and make the fit with up to 3 hit candidates or compute pad 
/// centers of gravity for larger number of peaks.
///
/// \author Laurent Aphecetche (for the "new" C++ structure) and 
/// Alexander Zinchenko, JINR Dubna, for the hardcore of it ;-)
//-----------------------------------------------------------------------------

#include "AliMUONClusterFinderPeakFit.h"
#include "AliMUONCluster.h"
#include "AliMUONConstants.h"
#include "AliMUONPad.h"
#include "AliMUONMathieson.h"

#include "AliMpDEManager.h"
#include "AliMpPad.h"
#include "AliMpVSegmentation.h"
#include "AliMpEncodePair.h"

#include "AliLog.h"
#include "AliRunLoader.h"
//#include "AliCodeTimer.h"

#include <Riostream.h>
#include <TH2.h>
#include <TVirtualFitter.h>
#include <TMath.h>
//#include <TCanvas.h>

using std::endl;
using std::cout;
/// \cond CLASSIMP
ClassImp(AliMUONClusterFinderPeakFit)
/// \endcond
 
const Double_t AliMUONClusterFinderPeakFit::fgkZeroSuppression = 6; // average zero suppression value
//const Double_t AliMUONClusterFinderMLEM::fgkDistancePrecision = 1e-6; // (cm) used to check overlaps and so on
const Double_t AliMUONClusterFinderPeakFit::fgkDistancePrecision = 1e-3; // (cm) used to check overlaps and so on
const TVector2 AliMUONClusterFinderPeakFit::fgkIncreaseSize(-AliMUONClusterFinderPeakFit::fgkDistancePrecision,-AliMUONClusterFinderPeakFit::fgkDistancePrecision);
const TVector2 AliMUONClusterFinderPeakFit::fgkDecreaseSize(AliMUONClusterFinderPeakFit::fgkDistancePrecision,AliMUONClusterFinderPeakFit::fgkDistancePrecision);

// Status flags for pads
const Int_t AliMUONClusterFinderPeakFit::fgkZero = 0x0; ///< pad "basic" state
const Int_t AliMUONClusterFinderPeakFit::fgkMustKeep = 0x1; ///< do not kill (for pixels)
const Int_t AliMUONClusterFinderPeakFit::fgkUseForFit = 0x10; ///< should be used for fit
const Int_t AliMUONClusterFinderPeakFit::fgkOver = 0x100; ///< processing is over
const Int_t AliMUONClusterFinderPeakFit::fgkModified = 0x1000; ///< modified pad charge 
const Int_t AliMUONClusterFinderPeakFit::fgkCoupled = 0x10000; ///< coupled pad  

namespace
{
  //_____________________________________________________________________________
  Double_t Param2Coef(Int_t icand, Double_t coef, Double_t *par, Int_t nHits)
  {
    /// Extract hit contribution scale factor from fit parameters
  
    //Int_t nHits = TMath::Nint(par[8]);
    if (nHits == 1) return 1.;
    if (nHits == 2) return icand==0 ? par[2] : TMath::Max(1.-par[2],0.);
    if (icand == 0) return par[2];
    if (icand == 1) return TMath::Max((1.-par[2])*par[5], 0.);
    return TMath::Max(1.-par[2]-coef,0.);
  }

  //___________________________________________________________________________
  void 
  FitFunction(Int_t& /*notused*/, Double_t* /*notused*/, 
              Double_t& f, Double_t* par, 
              Int_t /*notused*/)
  {
    /// Chi2 Function to minimize: Mathieson charge distribution in 2 dimensions
    
    TObjArray* userObjects = static_cast<TObjArray*>(TVirtualFitter::GetFitter()->GetObjectFit());
    
    AliMUONCluster* cluster = static_cast<AliMUONCluster*>(userObjects->At(0));
    AliMUONMathieson* mathieson = static_cast<AliMUONMathieson*>(userObjects->At(1));
    AliMUONClusterFinderPeakFit* finder = 
      static_cast<AliMUONClusterFinderPeakFit*>(userObjects->At(2));
    
    f = 0.0;
    Int_t nHits = finder->GetNMax(), npads = cluster->Multiplicity();
    Double_t qTot = cluster->Charge(), coef = 0;
    //if (cluster->Multiplicity(0) == 0 || cluster->Multiplicity(1) == 0) qTot *= 2.;
    
    for ( Int_t i = 0 ; i < npads; ++i )
    {
      AliMUONPad* pad = cluster->Pad(i);
      // skip pads w/ saturation or other problem(s)
      //if ( pad->Status() ) continue; 
      if ( pad->IsSaturated() ) continue; 
      Double_t charge = 0.;
      for (Int_t j = 0; j < nHits; ++j) {
	// Sum over hits
	Int_t indx = 3 * j;
	TVector2 lowerLeft = TVector2(par[indx],par[indx+1]) - pad->Position() - pad->Dimensions();
	TVector2 upperRight(lowerLeft + pad->Dimensions()*2.0);
	Double_t estimatedCharge = mathieson->IntXY(lowerLeft.X(),lowerLeft.Y(),
						    upperRight.X(),upperRight.Y());
	coef = Param2Coef(j, coef, par, nHits);
	charge += estimatedCharge * coef;
      }
      charge *= qTot;
      
      Double_t delta = charge - pad->Charge();
      delta *= delta;
      delta /= pad->Charge();    
      f += delta;
    }
    f /= (qTot/npads);
    //cout << qTot << " " << par[0] << " " << par[1] << " " << f << endl;
  }
}

//_____________________________________________________________________________
AliMUONClusterFinderPeakFit::AliMUONClusterFinderPeakFit(Bool_t plot, AliMUONVClusterFinder* clusterFinder)
  : AliMUONVClusterFinder(),
fPreClusterFinder(clusterFinder),
fPreCluster(0x0),
fClusterList(),
fMathieson(0x0),
fEventNumber(0),
fDetElemId(-1),
fClusterNumber(0),
fNMax(0),
fHistAnode(0x0),
fPixArray(new TObjArray(20)),
fDebug(0),
fPlot(plot),
fNClusters(0),
fNAddVirtualPads(0)
{
  /// Constructor
 
  fkSegmentation[1] = fkSegmentation[0] = 0x0; 

  if (fPlot) fDebug = 1;
}

//_____________________________________________________________________________
AliMUONClusterFinderPeakFit::~AliMUONClusterFinderPeakFit()
{
/// Destructor
  delete fPixArray; fPixArray = 0;
  delete fPreClusterFinder;
  AliInfo(Form("Total clusters %d AddVirtualPad needed %d",
               fNClusters,fNAddVirtualPads));
  delete fMathieson;
}

//_____________________________________________________________________________
Bool_t 
AliMUONClusterFinderPeakFit::Prepare(Int_t detElemId, TObjArray* pads[2],
                                     const AliMpArea& area, 
                                     const AliMpVSegmentation* seg[2])
{
  /// Prepare for clustering
//  AliCodeTimerAuto("",0)
  
  for ( Int_t i = 0; i < 2; ++i )
  {
    fkSegmentation[i] = seg[i];
  }
  
  // Find out the DetElemId
  fDetElemId = detElemId;
  
  // find out current event number, and reset the cluster number
  AliRunLoader *runLoader = AliRunLoader::Instance();
  fEventNumber = runLoader ? runLoader->GetEventNumber() : 0;
  fClusterNumber = -1;
  fClusterList.Delete();
  
  AliDebug(3,Form("EVT %d DE %d",fEventNumber,fDetElemId));
  
  AliMq::Station12Type stationType = AliMpDEManager::GetStation12Type(fDetElemId);
  
  Float_t kx3 = AliMUONConstants::SqrtKx3();
  Float_t ky3 = AliMUONConstants::SqrtKy3();
  Float_t pitch = AliMUONConstants::Pitch();
  
  if ( stationType == AliMq::kStation1 )
  {
    kx3 = AliMUONConstants::SqrtKx3St1();
    ky3 = AliMUONConstants::SqrtKy3St1();
    pitch = AliMUONConstants::PitchSt1();
  }
  
  delete fMathieson;
  fMathieson = new AliMUONMathieson;
  
  fMathieson->SetPitch(pitch);
  fMathieson->SetSqrtKx3AndDeriveKx2Kx4(kx3);
  fMathieson->SetSqrtKy3AndDeriveKy2Ky4(ky3);

  if ( fPreClusterFinder->NeedSegmentation() )
  {
    return fPreClusterFinder->Prepare(detElemId,pads,area,seg);
  }
  else
  {
    return fPreClusterFinder->Prepare(detElemId,pads,area);
  }
}

//_____________________________________________________________________________
AliMUONCluster* 
AliMUONClusterFinderPeakFit::NextCluster()
{
  /// Return next cluster
//  AliCodeTimerAuto("",0)
  
  // if the list of clusters is not void, pick one from there
  TObject* o = fClusterList.At(++fClusterNumber);
  if ( o != 0x0 ) return static_cast<AliMUONCluster*>(o);
  
  //FIXME : at this point, must check whether we've used all the digits
  //from precluster : if not, let the preclustering know about those unused
  //digits, so it can reuse them
  
  // if the cluster list is exhausted, we need to go to the next
  // pre-cluster and treat it

  fClusterList.Delete(); // reset the list of clusters for this pre-cluster
  fClusterNumber = -1; 
    
  fPreCluster = fPreClusterFinder->NextCluster();
  
  if (!fPreCluster)
  {
    // we are done
    return 0x0;
  }
    
  WorkOnPreCluster();

  // WorkOnPreCluster may have used only part of the pads, so we check that
  // now, and let the unused pads be reused by the preclustering...
  
  Int_t mult = fPreCluster->Multiplicity();
  for ( Int_t i = 0; i < mult; ++i )
  {
    AliMUONPad* pad = fPreCluster->Pad(i);
    if ( !pad->IsUsed() )
    {
      fPreClusterFinder->UsePad(*pad);
    }
  }
  
  return NextCluster();
}

//_____________________________________________________________________________
Bool_t
AliMUONClusterFinderPeakFit::WorkOnPreCluster()
{
  /// Starting from a precluster, builds a pixel array, and then
  /// extract clusters from this array
  
  //  AliCodeTimerAuto("",0)	

  if (fDebug) {
    cout << " *** Event # " << fEventNumber
	 << " det. elem.: " << fDetElemId << endl;
    for (Int_t j = 0; j < fPreCluster->Multiplicity(); ++j) {
      AliMUONPad* pad = fPreCluster->Pad(j);
      printf(" bbb %3d %1d %8.4f %8.4f %8.4f %8.4f %6.1f %3d %3d %2d %1d %1d \n",
	     j, pad->Cathode(), pad->Coord(0), pad->Coord(1), pad->DX()*2, pad->DY()*2,
             pad->Charge(), pad->Ix(), pad->Iy(), pad->Status(), pad->IsReal(), pad->IsSaturated());
    }
  }

  AliMUONCluster* cluster = CheckPrecluster(*fPreCluster);
  if (!cluster) return kFALSE;

  BuildPixArray(*cluster);
  
  if ( fPixArray->GetLast() < 0 )
  {
    AliDebug(1,"No pixel for the above cluster");
    delete cluster;
    return kFALSE;
  }
  
  Int_t nMax = 1, localMax[100], maxPos[100] = {0};
  Double_t maxVal[100];
  
  nMax = FindLocalMaxima(fPixArray, localMax, maxVal); // find local maxima

  if (nMax > 1) TMath::Sort(nMax, maxVal, maxPos, kTRUE); // in descending order
  
  if (nMax <= 3) {
    FindClusterFit(*cluster, localMax, maxPos, nMax);
  } else {
    for (Int_t i = 0; i < nMax; ++i) 
      {
	FindClusterCOG(*cluster, localMax, maxPos[i]);
      }
  }

  delete cluster;
  if (fPlot == 0) {
    delete fHistAnode;
    fHistAnode = 0x0;
  }
  return kTRUE;
}

//_____________________________________________________________________________
Bool_t 
AliMUONClusterFinderPeakFit::Overlap(const AliMUONPad& pad, const AliMUONPad& pixel)
{
  /// Check if the pad and the pixel overlaps

  // make a fake pad from the pixel
  AliMUONPad tmp(pad.DetElemId(),pad.Cathode(),pad.Ix(),pad.Iy(),
                 pixel.Coord(0),pixel.Coord(1),
                 pixel.Size(0),pixel.Size(1),0);
  
  return AliMUONPad::AreOverlapping(pad,tmp,fgkDecreaseSize);
}

//_____________________________________________________________________________
AliMUONCluster* 
AliMUONClusterFinderPeakFit::CheckPrecluster(const AliMUONCluster& origCluster)
{
  /// Check precluster in order to attempt to simplify it (mostly for
  /// two-cathode preclusters)
    
  //  AliCodeTimerAuto("",0)

  // Disregard small clusters (leftovers from splitting or noise)
  if ((origCluster.Multiplicity()==1 || origCluster.Multiplicity()==2) &&
      origCluster.Charge(0)+origCluster.Charge(1) < 1.525) // JC: adc -> fc
  { 
    return 0x0;
  }

  AliMUONCluster* cluster = new AliMUONCluster(origCluster);

  AliDebug(2,"Start of CheckPreCluster=");
  //StdoutToAliDebug(2,cluster->Print("full"));

  AliMUONCluster* rv(0x0);
  
  if (cluster->Multiplicity(0) && cluster->Multiplicity(1))
  { 
    rv = CheckPreclusterTwoCathodes(cluster);
  }
  else
  {
    rv = cluster;
  }
  return rv;
}

//_____________________________________________________________________________
AliMUONCluster*
AliMUONClusterFinderPeakFit::CheckPreclusterTwoCathodes(AliMUONCluster* cluster)
{
  /// Check two-cathode cluster
  
  Int_t npad = cluster->Multiplicity();
  Int_t* flags = new Int_t[npad];
  for (Int_t j = 0; j < npad; ++j) flags[j] = 0;
  
  // Check pad overlaps
  for ( Int_t i = 0; i < npad; ++i) 
  {
    AliMUONPad* padi = cluster->Pad(i);
    if ( padi->Cathode() != 0 ) continue;
    for (Int_t j = i+1; j < npad; ++j) 
    {
      AliMUONPad* padj = cluster->Pad(j);
      if ( padj->Cathode() != 1 ) continue;
      if ( !AliMUONPad::AreOverlapping(*padi,*padj,fgkDecreaseSize) ) continue;
      flags[i] = flags[j] = 1; // mark overlapped pads
    } 
  } 
  
  // Check if all pads overlap
  Int_t nFlags=0;
  for (Int_t i = 0; i < npad; ++i) 
  {
    if (!flags[i]) ++nFlags;
  }
  
  if (nFlags > 0) 
  {
    // not all pads overlap.
    if (fDebug) cout << " nFlags: " << nFlags << endl;
    TObjArray toBeRemoved;
    for (Int_t i = 0; i < npad; ++i) 
    {
      AliMUONPad* pad = cluster->Pad(i);
      if (flags[i]) continue;
      Int_t cath = pad->Cathode();
      Int_t cath1 = TMath::Even(cath);
      // Check for edge effect (missing pads on the _other_ cathode)
      AliMpPad mpPad 
        = fkSegmentation[cath1]->PadByPosition(pad->Position().X(),pad->Position().Y(),kFALSE);
      if (!mpPad.IsValid()) continue;
      //if (nFlags == 1 && pad->Charge() < fgkZeroSuppression * 3) continue;
      if (nFlags == 1 && pad->Charge() < 3.05) continue;  // JC: adc -> fc
      AliDebug(2,Form("Releasing the following pad : de,cath,ix,iy %d,%d,%d,%d charge %e",
                      fDetElemId,pad->Cathode(),pad->Ix(),pad->Iy(),pad->Charge()));
      toBeRemoved.AddLast(pad);
      fPreCluster->Pad(i)->Release();
    }
    Int_t nRemove = toBeRemoved.GetEntriesFast();
    for ( Int_t i = 0; i < nRemove; ++i )
    {
      cluster->RemovePad(static_cast<AliMUONPad*>(toBeRemoved.UncheckedAt(i)));
    }
  } 
  
  // Check correlations of cathode charges
  if ( !cluster->IsSaturated() && cluster->ChargeAsymmetry() > 1 )
  {
    // big difference
    Int_t cathode = cluster->MaxRawChargeCathode();
    Int_t imin(-1);
    Int_t imax(-1);
    Double_t cmax(0);
    Double_t cmin(1E9);
    
    // get min and max pad charges on the cathode opposite to the 
    // max pad (given by MaxRawChargeCathode())
    //
    Int_t mult = cluster->Multiplicity();
    for ( Int_t i = 0; i < mult; ++i )
    {
      AliMUONPad* pad = cluster->Pad(i);
      if ( pad->Cathode() != cathode || !pad->IsReal() )
      {
        // only consider pads in the opposite cathode, and
        // only consider real pads (i.e. exclude the virtual ones)
        continue;
      }
      if ( pad->Charge() < cmin )
      {
        cmin = pad->Charge();
        imin = i;
	if (imax < 0) {
	  imax = imin;
	  cmax = cmin;
	}
      }
      else if ( pad->Charge() > cmax )
      {
        cmax = pad->Charge();
        imax = i;
      }      
    }
    AliDebug(2,Form("Pad imin,imax %d,%d cmin,cmax %e,%e",
                    imin,imax,cmin,cmax));
    //
    // arrange pads according to their distance to the max, normalized
    // to the pad size
    Double_t* dist = new Double_t[mult];
    Double_t dxMin(1E9);
    Double_t dyMin(1E9);
    Double_t dmin(0);
    
    AliMUONPad* padmax = cluster->Pad(imax);
    
    for ( Int_t i = 0; i < mult; ++i )
    {
      dist[i] = 0.0;
      if ( i == imax) continue;
      AliMUONPad* pad = cluster->Pad(i);
      if ( pad->Cathode() != cathode || !pad->IsReal() ) continue;
      Double_t dx = (pad->X()-padmax->X())/padmax->DX()/2.0;
      Double_t dy = (pad->Y()-padmax->Y())/padmax->DY()/2.0;
      dist[i] = TMath::Sqrt(dx*dx+dy*dy);
      if ( i == imin )
      {
        dmin = dist[i] + 1E-3; // distance to the pad with minimum charge
        dxMin = dx;
        dyMin = dy;
      }      
    }
    
    TMath::Sort(mult,dist,flags,kFALSE); // in ascending order
    Double_t xmax(-1), distPrev(999);
    TObjArray toBeRemoved;
    
    for ( Int_t i = 0; i < mult; ++i )
    {
      Int_t indx = flags[i];
      AliMUONPad* pad = cluster->Pad(indx);
      if ( pad->Cathode() != cathode || !pad->IsReal() ) continue;
      if ( dist[indx] > dmin )
      {
        // farther than the minimum pad
        Double_t dx = (pad->X()-padmax->X())/padmax->DX()/2.0;
        Double_t dy = (pad->Y()-padmax->Y())/padmax->DY()/2.0;
        dx *= dxMin;
        dy *= dyMin;
        if (dx >= 0 && dy >= 0) continue;
        if (TMath::Abs(dx) > TMath::Abs(dy) && dx >= 0) continue;
        if (TMath::Abs(dy) > TMath::Abs(dx) && dy >= 0) continue;        
      }
      if (dist[indx] > distPrev + 1) break; // overstepping empty pads
      if ( pad->Charge() <= cmax || TMath::Abs(dist[indx]-xmax) < 1E-3 )
      {
        // release pad
        if (TMath::Abs(dist[indx]-xmax) < 1.e-3) 
        {
          cmax = TMath::Max(pad->Charge(),cmax);
        }
        else
        {
          cmax = pad->Charge();
        }
        xmax = dist[indx];
	distPrev = dist[indx];
        AliDebug(2,Form("Releasing the following pad : de,cath,ix,iy %d,%d,%d,%d charge %e",
                        fDetElemId,pad->Cathode(),pad->Ix(),pad->Iy(),
                        pad->Charge()));
  
        toBeRemoved.AddLast(pad);
        fPreCluster->Pad(indx)->Release();
      }
    }
    Int_t nRemove = toBeRemoved.GetEntriesFast();
    for ( Int_t i = 0; i < nRemove; ++i )
    {
      cluster->RemovePad(static_cast<AliMUONPad*>(toBeRemoved.UncheckedAt(i)));
    }    
    delete[] dist;
  } // if ( !cluster->IsSaturated() && 
  
  delete[] flags;
  
  AliDebug(2,"End of CheckPreClusterTwoCathodes=");
  //StdoutToAliDebug(2,cluster->Print("full"));

  return cluster;    
}

//_____________________________________________________________________________
void
AliMUONClusterFinderPeakFit::CheckOverlaps()
{
  /// For debug only : check if some pixels overlap...
  
  Int_t nPix = fPixArray->GetLast()+1;
  Int_t dummy(0);
  
  for ( Int_t i = 0; i < nPix; ++i )
  {
    AliMUONPad* pixelI = Pixel(i);
    AliMUONPad pi(dummy,dummy,dummy,dummy,
                  pixelI->Coord(0),pixelI->Coord(1),
                  pixelI->Size(0),pixelI->Size(1),0.0);
    
    for ( Int_t j = i+1; j < nPix; ++j )
    {
      AliMUONPad* pixelJ = Pixel(j);
      AliMUONPad pj(dummy,dummy,dummy,dummy,
                    pixelJ->Coord(0),pixelJ->Coord(1),
                    pixelJ->Size(0),pixelJ->Size(1),0.0);  
      AliMpArea area;
      
      if ( AliMUONPad::AreOverlapping(pi,pj,fgkDecreaseSize,area) )
      {
        AliInfo(Form("The following 2 pixels (%d and %d) overlap !",i,j));
	/*
        StdoutToAliInfo(pixelI->Print();
                        cout << " Surface = " << pixelI->Size(0)*pixelI->Size(1)*4 << endl;
                        pixelJ->Print();
                        cout << " Surface = " << pixelJ->Size(0)*pixelJ->Size(1)*4 << endl;
                        cout << " Area surface = " << area.Dimensions().X()*area.Dimensions().Y()*4 << endl;
                        cout << "-------" << endl;
                        );
	*/        
      }
    }    
  }
}

//_____________________________________________________________________________
void AliMUONClusterFinderPeakFit::BuildPixArray(AliMUONCluster& cluster)
{
  /// Build pixel array 
  
  Int_t npad = cluster.Multiplicity();
  if (npad<=0) 
  {
    AliWarning("Got no pad at all ?!");
  }
  
  fPixArray->Delete();
  BuildPixArrayOneCathode(cluster);
  
//  StdoutToAliDebug(2,cout << "End of BuildPixelArray:" << endl;
//                   fPixArray->Print(););
  //CheckOverlaps();//FIXME : this is for debug only. Remove it.
}

//_____________________________________________________________________________
void AliMUONClusterFinderPeakFit::BuildPixArrayOneCathode(AliMUONCluster& cluster)
{
  /// Build the pixel array

//  AliDebug(2,Form("cluster.Multiplicity=%d",cluster.Multiplicity()));

  TVector2 dim = cluster.MinPadDimensions (-1, kFALSE);
  Double_t width[2] = {dim.X(), dim.Y()}, xy0[2] = { 0.0, 0.0 };
  Int_t found[2] = {0}, mult = cluster.Multiplicity();

  for ( Int_t i = 0; i < mult; ++i) {
    AliMUONPad* pad = cluster.Pad(i);
    for (Int_t j = 0; j < 2; ++j) {
      if (found[j] == 0 && TMath::Abs(pad->Size(j)-width[j]) < fgkDistancePrecision) { 
	xy0[j] = pad->Coord(j);
	found[j] = 1;
      }
    }
    if (found[0] && found[1]) break;
  }

  Double_t min[2], max[2];
  Int_t cath0 = 0, cath1 = 1;
  if (cluster.Multiplicity(0) == 0) cath0 = 1;
  else if (cluster.Multiplicity(1) == 0) cath1 = 0;

  Double_t leftDownX, leftDownY;
  cluster.Area(cath0).LeftDownCorner(leftDownX, leftDownY);
  Double_t rightUpX, rightUpY; 
  cluster.Area(cath0).RightUpCorner(rightUpX, rightUpY);
  min[0] = leftDownX;
  min[1] = leftDownY;
  max[0] = rightUpX;
  max[1] = rightUpY;
  if (cath1 != cath0) {
    cluster.Area(cath1).LeftDownCorner(leftDownX, leftDownY);
    cluster.Area(cath1).RightUpCorner(rightUpX, rightUpY);
    min[0] = TMath::Max (min[0], leftDownX);
    min[1] = TMath::Max (min[1], leftDownY);
    max[0] = TMath::Min (max[0], rightUpX);
    max[1] = TMath::Min (max[1], rightUpY);
  }

  // Adjust limits
  if (cath0 != cath1) {
    TVector2 dim0 = cluster.MinPadDimensions (0, -1, kFALSE);
    TVector2 dim1 = cluster.MinPadDimensions (1, -1, kFALSE);
    if (TMath::Abs(dim0.Y()-dim1.Y()) < fgkDistancePrecision) {
      // The same size of pads on both cathodes - check position
      AliMUONPad* pad0 = cluster.Pad(0);
      for ( Int_t i = 1; i < mult; ++i) {
	AliMUONPad* pad = cluster.Pad(i);
	if (pad->Cathode() == pad0->Cathode()) continue;
	Double_t dist = TMath::Abs (pad0->Coord(1) - pad->Coord(1));
	Double_t dd = dist - Int_t(dist/width[1]/2.) * width[1] * 2.;
	if (TMath::Abs(dd/width[1]/2.-0.5) < fgkDistancePrecision) { 
	  // Half pad shift between cathodes
	  width[0] /= 2.; 
	  width[1] /= 2.;
	}
	break;
      }
    }
  }

  Int_t nbins[2];
  for (Int_t i = 0; i < 2; ++i) {
    Double_t dist = (min[i] - xy0[i]) / width[i] / 2;
    if (TMath::Abs(dist) < 1.e-6) dist = -1.e-6;
    min[i] = xy0[i] + (TMath::Nint(dist-TMath::Sign(1.e-6,dist)) 
		       + TMath::Sign(0.5,dist)) * width[i] * 2;
    nbins[i] = TMath::Nint ((max[i] - min[i]) / width[i] / 2);
    if (nbins[i] == 0) ++nbins[i];
    max[i] = min[i] + nbins[i] * width[i] * 2;
    //cout << dist << " " << min[i] << " " << max[i] << " " << nbins[i] << endl;
  }

  // Book histogram
  TH2D *hist1 = new TH2D ("Grid", "", nbins[0], min[0], max[0], nbins[1], min[1], max[1]);
  TH2D *hist2 = new TH2D ("Entries", "", nbins[0], min[0], max[0], nbins[1], min[1], max[1]);
  TAxis *xaxis = hist1->GetXaxis();
  TAxis *yaxis = hist1->GetYaxis();

  // Fill histogram
  for ( Int_t i = 0; i < mult; ++i) {
    AliMUONPad* pad = cluster.Pad(i);
    Int_t ix0 = xaxis->FindBin(pad->X());
    Int_t iy0 = yaxis->FindBin(pad->Y());
    PadOverHist(0, ix0, iy0, pad, hist1, hist2);
  }

  // Store pixels
  for (Int_t i = 1; i <= nbins[0]; ++i) {
    Double_t x = xaxis->GetBinCenter(i);
    for (Int_t j = 1; j <= nbins[1]; ++j) {
      if (hist2->GetBinContent(hist2->GetBin(i,j)) < 0.01525) continue; // JC: adc -> fc
      if (cath0 != cath1) {
	// Two-sided cluster
	Double_t cont = hist2->GetBinContent(hist2->GetBin(i,j));
	if (cont < 999.) continue;
	if (cont-Int_t(cont/1000.)*1000. < 0.07625) continue; // JC: adc -> fc
      }
      //if (hist2->GetBinContent(hist2->GetBin(i,j)) < 1.1 && cluster.Multiplicity(0) && 
      //  cluster.Multiplicity(1)) continue;
      Double_t y = yaxis->GetBinCenter(j);
      Double_t charge = hist1->GetBinContent(hist1->GetBin(i,j));
      AliMUONPad* pixPtr = new AliMUONPad(x, y, width[0], width[1], charge);
      fPixArray->Add(pixPtr);
    }  
  }
  /*
  if (fPixArray->GetEntriesFast() == 1) {
    // Split pixel into 2
    AliMUONPad* pixPtr = static_cast<AliMUONPad*> (fPixArray->UncheckedAt(0));
    pixPtr->SetSize(0,width[0]/2.);
    pixPtr->Shift(0,-width[0]/4.);
    pixPtr = new AliMUONPad(pixPtr->X()+width[0], pixPtr->Y(), width[0]/2., width[1], pixPtr->Charge());
    fPixArray->Add(pixPtr);
  }
  */
  //fPixArray->Print();
  delete hist1;
  delete hist2;
}

//_____________________________________________________________________________
void AliMUONClusterFinderPeakFit::PadOverHist(Int_t idir, Int_t ix0, Int_t iy0, AliMUONPad *pad,
					      TH2D *hist1, TH2D *hist2)
{
  /// "Span" pad over histogram in the direction idir

  TAxis *axis = idir == 0 ? hist1->GetXaxis() : hist1->GetYaxis();
  Int_t nbins = axis->GetNbins(), cath = pad->Cathode();
  Double_t bin = axis->GetBinWidth(1), amask = TMath::Power(1000.,cath*1.);

  Int_t nbinPad = (Int_t)(pad->Size(idir)/bin*2+fgkDistancePrecision) + 1; // number of bins covered by pad

  for (Int_t i = 0; i < nbinPad; ++i) {
    Int_t ixy = idir == 0 ? ix0 + i : iy0 + i;
    if (ixy > nbins) break;
    Double_t lowEdge = axis->GetBinLowEdge(ixy);
    if (lowEdge + fgkDistancePrecision > pad->Coord(idir) + pad->Size(idir)) break;
    if (idir == 0) PadOverHist(1, ixy, iy0, pad, hist1, hist2); // span in the other direction
    else {
      // Fill histogram
      Double_t cont = pad->Charge();
      if (hist2->GetBinContent(hist2->GetBin(ix0, ixy)) > 0.01525) // JC: adc -> fc
	cont = TMath::Min (hist1->GetBinContent(hist1->GetBin(ix0, ixy)), cont) 
	  + TMath::Min (TMath::Max(hist1->GetBinContent(hist1->GetBin(ix0, ixy)),cont)*0.1, 1.525); // JC: adc -> fc
      hist1->SetBinContent(hist1->GetBin(ix0, ixy), cont);
      hist2->SetBinContent(hist2->GetBin(ix0, ixy), hist2->GetBinContent( hist2->GetBin(ix0, ixy))+amask);
    }
  }

  for (Int_t i = -1; i > -nbinPad; --i) {
    Int_t ixy = idir == 0 ? ix0 + i : iy0 + i;
    if (ixy < 1) break;
    Double_t upEdge = axis->GetBinUpEdge(ixy);
    if (upEdge - fgkDistancePrecision < pad->Coord(idir) - pad->Size(idir)) break;
    if (idir == 0) PadOverHist(1, ixy, iy0, pad, hist1, hist2); // span in the other direction
    else {
      // Fill histogram
      Double_t cont = pad->Charge();
      if (hist2->GetBinContent(hist2->GetBin(ix0, ixy)) > 0.01525) // JC: adc -> fc 
	cont = TMath::Min (hist1->GetBinContent(hist1->GetBin(ix0, ixy)), cont)
	  + TMath::Min (TMath::Max(hist1->GetBinContent(hist1->GetBin(ix0, ixy)),cont)*0.1,1.525); // JC: adc -> fc
      hist1->SetBinContent(hist1->GetBin(ix0, ixy), cont);
      hist2->SetBinContent(hist2->GetBin(ix0, ixy), hist2->GetBinContent( hist2->GetBin(ix0, ixy))+amask);
    }
  }
}

//_____________________________________________________________________________
Int_t AliMUONClusterFinderPeakFit::FindLocalMaxima(TObjArray *pixArray, Int_t *localMax, Double_t *maxVal)
{
/// Find local maxima in pixel space 

  AliDebug(1,Form("nPix=%d",pixArray->GetLast()+1));

  //TH2D *hist = NULL;
  //delete ((TH2D*) gROOT->FindObject("anode"));
  //if (pixArray == fPixArray) hist = (TH2D*) gROOT->FindObject("anode");
  //else { hist = (TH2D*) gROOT->FindObject("anode1"); cout << hist << endl; }
  //if (hist) hist->Delete();
  delete fHistAnode;
 
  Double_t xylim[4] = {999, 999, 999, 999};

  Int_t nPix = pixArray->GetEntriesFast();
  
  if ( nPix <= 0 ) return 0;

  AliMUONPad *pixPtr = 0;
  for (Int_t ipix = 0; ipix < nPix; ++ipix) {
    pixPtr = (AliMUONPad*) pixArray->UncheckedAt(ipix);
    for (Int_t i = 0; i < 4; ++i) 
         xylim[i] = TMath::Min (xylim[i], (i%2 ? -1 : 1)*pixPtr->Coord(i/2));
  }
  for (Int_t i = 0; i < 4; ++i) xylim[i] -= pixPtr->Size(i/2); 

  Int_t nx = TMath::Nint ((-xylim[1]-xylim[0])/pixPtr->Size(0)/2);
  Int_t ny = TMath::Nint ((-xylim[3]-xylim[2])/pixPtr->Size(1)/2);
  if (pixArray == fPixArray) fHistAnode = new TH2D("anode","anode",nx,xylim[0],-xylim[1],ny,xylim[2],-xylim[3]);
  else fHistAnode = new TH2D("anode1","anode1",nx,xylim[0],-xylim[1],ny,xylim[2],-xylim[3]);
  for (Int_t ipix = 0; ipix < nPix; ++ipix) {
    pixPtr = (AliMUONPad*) pixArray->UncheckedAt(ipix);
    fHistAnode->Fill(pixPtr->Coord(0), pixPtr->Coord(1), pixPtr->Charge());
  }
//  if (fDraw && pixArray == fPixArray) fDraw->DrawHist("c2", hist);

  Int_t nMax = 0, indx, nxy = ny * nx;
  Int_t *isLocalMax = new Int_t[nxy];
  for (Int_t i = 0; i < nxy; ++i) isLocalMax[i] = 0; 

  for (Int_t i = 1; i <= ny; ++i) {
    indx = (i-1) * nx;
    for (Int_t j = 1; j <= nx; ++j) {
      if (fHistAnode->GetBinContent(fHistAnode->GetBin(j,i)) < 0.07625) continue;  // JC: adc -> fc
      //if (isLocalMax[indx+j-1] < 0) continue;
      if (isLocalMax[indx+j-1] != 0) continue;
      FlagLocalMax(fHistAnode, i, j, isLocalMax);
    }
  }

  for (Int_t i = 1; i <= ny; ++i) {
    indx = (i-1) * nx;
    for (Int_t j = 1; j <= nx; ++j) {
      if (isLocalMax[indx+j-1] > 0) { 
	localMax[nMax] = indx + j - 1; 
	maxVal[nMax++] = fHistAnode->GetBinContent(fHistAnode->GetBin(j,i));
	if (nMax > 99) break;
      }
    }
    if (nMax > 99) {
      AliError(" Too many local maxima !!!");
      break;
    }
  }
  if (fDebug) cout << " Local max: " << nMax << endl;
  delete [] isLocalMax; 
  return nMax;
}

//_____________________________________________________________________________
void AliMUONClusterFinderPeakFit::FlagLocalMax(TH2D *hist, Int_t i, Int_t j, Int_t *isLocalMax)
{
/// Flag pixels (whether or not local maxima)

  Int_t nx = hist->GetNbinsX();
  Int_t ny = hist->GetNbinsY();
  Int_t cont = TMath::Nint (hist->GetBinContent(hist->GetBin(j,i)));
  Int_t cont1 = 0, indx = (i-1)*nx+j-1, indx1 = 0, indx2 = 0;

  Int_t ie = i + 2, je = j + 2;
  for (Int_t i1 = i-1; i1 < ie; ++i1) {
    if (i1 < 1 || i1 > ny) continue;
    indx1 = (i1 - 1) * nx;
    for (Int_t j1 = j-1; j1 < je; ++j1) {
      if (j1 < 1 || j1 > nx) continue;
      if (i == i1 && j == j1) continue;
      indx2 = indx1 + j1 - 1;
      cont1 = TMath::Nint (hist->GetBinContent(hist->GetBin(j1,i1)));
      if (cont < cont1) { isLocalMax[indx] = -1; return; }
      else if (cont > cont1) isLocalMax[indx2] = -1;
      else { // the same charge
	isLocalMax[indx] = 1; 
	if (isLocalMax[indx2] == 0) {
	  FlagLocalMax(hist, i1, j1, isLocalMax);
	  if (isLocalMax[indx2] < 0) { isLocalMax[indx] = -1; return; }
	  else isLocalMax[indx2] = -1;
	}
      } 
    }
  }
  isLocalMax[indx] = 1; // local maximum
}

//_____________________________________________________________________________
void AliMUONClusterFinderPeakFit::FindClusterFit(AliMUONCluster& cluster, const Int_t *localMax, 
                                                 const Int_t *maxPos, Int_t nMax)
{
/// Fit pad charge distribution with nMax hit hypothesis

  //if (cluster.Multiplicity(0) == 0 || cluster.Multiplicity(1) == 0) cout << cluster.Multiplicity(0) << " " << cluster.Multiplicity(1) << " " << cluster.Charge() << " " << cluster.Charge(0) << " " << cluster.Charge(1) << " " << endl;

  //TH2D *hist = (TH2D*) gROOT->FindObject("anode");
  Int_t nx = fHistAnode->GetNbinsX();
  //Int_t ny = hist->GetNbinsY();
  Double_t xmin = fHistAnode->GetXaxis()->GetXmin(); //- hist->GetXaxis()->GetBinWidth(1);
  Double_t xmax = fHistAnode->GetXaxis()->GetXmax(); //+ hist->GetXaxis()->GetBinWidth(1);
  Double_t ymin = fHistAnode->GetYaxis()->GetXmin(); //- hist->GetYaxis()->GetBinWidth(1);
  Double_t ymax = fHistAnode->GetYaxis()->GetXmax(); //+ hist->GetYaxis()->GetBinWidth(1);

  TVirtualFitter* fitter = TVirtualFitter::Fitter(0,nMax*3);
  fitter->Clear("");
  fitter->SetFCN(FitFunction);

  Float_t stepX = 0.01; // cm
  Float_t stepY = 0.01; // cm
  Float_t stepQ = 0.01; // 
  
  Double_t args[10] = {-1.}; // disable printout
  
  fitter->ExecuteCommand("SET PRINT",args,1);
  fitter->ExecuteCommand("SET NOW",args,0); // no warnings
  
  Int_t indx = 0;
  fNMax = nMax;
  for (Int_t i = 0; i < nMax; ++i) {
    Int_t ic = localMax[maxPos[i]] / nx + 1;
    Int_t jc = localMax[maxPos[i]] % nx + 1;
    Double_t yc = fHistAnode->GetYaxis()->GetBinCenter(ic);
    Double_t xc = fHistAnode->GetXaxis()->GetBinCenter(jc);
    indx = 3 * i;
    fitter->SetParameter(indx,"Hit X position",xc,stepX,xmin,xmax);
    fitter->SetParameter(indx+1,"Hit Y position",yc,stepY,ymin,ymax);
    fitter->SetParameter(indx+2,"Hit contribution",0.6,stepQ,0.,1.);
  }
  fitter->SetParameter(indx+2,"Hit contribution",0.,0.,0,0);
  //fitter->SetParameter(8,"Number of hits",nMax,0.,0,0);

  TObjArray userObjects;
  
  userObjects.Add(&cluster);
  userObjects.Add(fMathieson);
  userObjects.Add(this);
  
  fitter->SetObjectFit(&userObjects);
  
  args[0] = 500.;
  args[1] = 1.;
  /*Int_t stat =*/ fitter->ExecuteCommand("MIGRAD",args,2);
  //if (stat) { cout << " stat = " << stat << " " << fDetElemId << endl; /*exit(0);*/ }
  //Int_t nvpar, nparx;
  //Double_t amin, edm, errdef; 
  //fitter->GetStats(amin, edm, errdef, nvpar, nparx);
  //cout << amin << endl;

  Double_t qTot = cluster.Charge(), par[9] = {0.}, err[9] = {0.}, coef = 0.;
  //par[8] = nMax;
  for (Int_t j = 0; j < nMax; ++j) {
    indx = 3 * j;
    par[indx+2] = fitter->GetParameter(indx+2);
    coef = Param2Coef(j, coef, par, nMax);
    par[indx] = fitter->GetParameter(indx);
    par[indx+1] = fitter->GetParameter(indx+1);
    err[indx] = fitter->GetParError(indx);
    err[indx+1] = fitter->GetParError(indx+1);
      
    if ( coef*qTot >= 2.135 ) // JC: adc -> fc
    {
      AliMUONCluster* cluster1 = new AliMUONCluster(cluster);
      
      cluster1->SetCharge(coef*qTot,coef*qTot);
      
      cluster1->SetPosition(TVector2(par[indx],par[indx+1]),TVector2(err[indx],err[indx+1]));
      cluster1->SetChi2(0.);
      
      // FIXME: we miss some information in this cluster, as compared to 
      // the original AddRawCluster code.
      
      AliDebug(2,Form("Adding RawCluster detElemId %4d mult %2d charge %5d (xl,yl)=(%9.6g,%9.6g)",
		      fDetElemId,cluster1->Multiplicity(),(Int_t)cluster1->Charge(),
		      cluster1->Position().X(),cluster1->Position().Y()));
        
      fClusterList.Add(cluster1);
    }
  }
}

//_____________________________________________________________________________
void AliMUONClusterFinderPeakFit::FindClusterCOG(AliMUONCluster& cluster, 
                                                 const Int_t *localMax, Int_t iMax)
{
/// Find COG of pad charge distribution around local maximum \a iMax 

  //TH2D *hist = (TH2D*) gROOT->FindObject("anode");
  /* Just for check
  TCanvas* c = new TCanvas("Anode","Anode",800,600);
  c->cd();
  hist->Draw("lego1Fb"); // debug
  c->Update();
  Int_t tmp;
  cin >> tmp;
  */
  Int_t nx = fHistAnode->GetNbinsX();
  //Int_t ny = hist->GetNbinsY();
  Int_t ic = localMax[iMax] / nx + 1;
  Int_t jc = localMax[iMax] % nx + 1;

  // Get min pad dimensions for the precluster
  Int_t nSides = 2;
  if (cluster.Multiplicity(0) == 0 || cluster.Multiplicity(1) == 0) nSides = 1;
  TVector2 dim0 = cluster.MinPadDimensions(0, -1, kFALSE);
  TVector2 dim1 = cluster.MinPadDimensions(1, -1, kFALSE);
  //Double_t width[2][2] = {{dim0.X(), dim0.Y()},{dim1.X(),dim1.Y()}};
  Int_t nonb[2] = {1, 0}; // coordinate index vs cathode
  if (nSides == 1 || dim0.X() < dim1.X() - fgkDistancePrecision) {
    nonb[0] = 0;
    nonb[1] = 1;
  }

  // Drop all pixels from the array - pick up only the ones from the cluster
  //fPixArray->Delete();

  Double_t wx = fHistAnode->GetXaxis()->GetBinWidth(1)/2; 
  Double_t wy = fHistAnode->GetYaxis()->GetBinWidth(1)/2;  
  Double_t yc = fHistAnode->GetYaxis()->GetBinCenter(ic);
  Double_t xc = fHistAnode->GetXaxis()->GetBinCenter(jc);
  Double_t cont = fHistAnode->GetBinContent(fHistAnode->GetBin(jc,ic));
  AliMUONPad pixel(xc, yc, wx, wy, cont);
  if (fDebug) pixel.Print("full"); 

  Int_t npad = cluster.Multiplicity();
  
  // Pick up pads which overlap with the maximum pixel and find pads with the max signal
  Double_t qMax[2] = {0}; 
  AliMUONPad *matrix[2][3] = {{0x0,0x0,0x0},{0x0,0x0,0x0}};
  for (Int_t j = 0; j < npad; ++j) 
  {
    AliMUONPad* pad = cluster.Pad(j);
    if ( Overlap(*pad,pixel) )
    {
      if (fDebug) { cout << j << " "; pad->Print("full"); }
      if (pad->Charge() > qMax[pad->Cathode()]) {
	qMax[pad->Cathode()] = pad->Charge();
	matrix[pad->Cathode()][1] = pad;
	if (nSides == 1) matrix[!pad->Cathode()][1] = pad;
      }
    }
  }
  //if (nSides == 2 && (matrix[0][1] == 0x0 || matrix[1][1] == 0x0)) return; // ???

  // Find neighbours of maxima to have 3 pads per direction (if possible)
  for (Int_t j = 0; j < npad; ++j) 
  {
    AliMUONPad* pad = cluster.Pad(j);
    Int_t cath = pad->Cathode();
    if (pad == matrix[cath][1]) continue;
    Int_t nLoops = 3 - nSides;

    for (Int_t k = 0; k < nLoops; ++k) {
      Int_t cath1 = cath;
      if (k) cath1 = !cath;

      // Check the coordinate corresponding to the cathode (bending or non-bending case)
      Double_t dist = pad->Coord(nonb[cath1]) - matrix[cath][1]->Coord(nonb[cath1]);
      Double_t dir = TMath::Sign (1., dist);
      dist = TMath::Abs(dist) - pad->Size(nonb[cath1]) - matrix[cath][1]->Size(nonb[cath1]);

      if (TMath::Abs(dist) < fgkDistancePrecision) {
	// Check the other coordinate
	dist = pad->Coord(!nonb[cath1]) - matrix[cath1][1]->Coord(!nonb[cath1]);
	if (TMath::Abs(dist) > 
	    TMath::Max(pad->Size(!nonb[cath1]), matrix[cath1][1]->Size(!nonb[cath1])) - fgkDistancePrecision) break;
	Int_t idir = TMath::Nint (dir);
	if (matrix[cath1][1+idir] == 0x0) matrix[cath1][1+idir] = pad;
	else if (pad->Charge() > matrix[cath1][1+idir]->Charge()) matrix[cath1][1+idir] = pad; // diff. segmentation
	//cout << pad->Coord(nonb[cath1]) << " " << pad->Coord(!nonb[cath1]) << " " << pad->Size(nonb[cath1]) << " " << pad->Size(!nonb[cath1]) << " " << pad->Charge() << endl ;
	break;
      }
    }
  }

  Double_t coord[2] = {0.}, qAver = 0.;
  for (Int_t i = 0; i < 2; ++i) {
    Double_t q = 0.;
    Double_t coordQ = 0.;
    Int_t cath = matrix[i][1]->Cathode();
    if (i && nSides == 1) cath = !cath;
    for (Int_t j = 0; j < 3; ++j) {
      if (matrix[i][j] == 0x0) continue;
      Double_t dq = matrix[i][j]->Charge();
      q += dq;
      coordQ += dq * matrix[i][j]->Coord(nonb[cath]);
      //coordQ += (matrix[i][j]->Charge() * matrix[i][j]->Coord(nonb[cath]));
    }
    coord[cath] = coordQ / q;
    qAver = TMath::Max (qAver, q);
  }

  //qAver = TMath::Sqrt(qAver);
  if ( qAver >= 2.135 ) // JC: adc -> fc
  {
    
    AliMUONCluster* cluster1 = new AliMUONCluster(cluster);
      
    cluster1->SetCharge(qAver,qAver);
    if (nonb[0] == 1) 
      cluster1->SetPosition(TVector2(coord[1],coord[0]),TVector2(0.,0.));
    else 
      cluster1->SetPosition(TVector2(coord[0],coord[1]),TVector2(0.,0.));

    cluster1->SetChi2(0.);
      
    // FIXME: we miss some information in this cluster, as compared to 
    // the original AddRawCluster code.
      
    AliDebug(2,Form("Adding RawCluster detElemId %4d mult %2d charge %5d (xl,yl)=(%9.6g,%9.6g)",
		    fDetElemId,cluster1->Multiplicity(),(Int_t)cluster1->Charge(),
		    cluster1->Position().X(),cluster1->Position().Y()));
        
    fClusterList.Add(cluster1);
  }
}

//_____________________________________________________________________________
AliMUONClusterFinderPeakFit&  
AliMUONClusterFinderPeakFit::operator=(const AliMUONClusterFinderPeakFit& rhs)
{
/// Protected assignement operator

  if (this == &rhs) return *this;

  AliFatal("Not implemented.");
    
  return *this;  
}    

//_____________________________________________________________________________
void AliMUONClusterFinderPeakFit::PadsInXandY(AliMUONCluster& cluster,
                                           Int_t &nInX, Int_t &nInY) const
{
  /// Find number of pads in X and Y-directions (excluding virtual ones and
  /// overflows)

  //Int_t statusToTest = 1;
  Int_t statusToTest = fgkUseForFit;
  
  //if ( nInX < 0 ) statusToTest = 0;
  if ( nInX < 0 ) statusToTest = fgkZero;
       
  Bool_t mustMatch(kTRUE);

  Long_t cn = cluster.NofPads(statusToTest,mustMatch);
  
  nInX = AliMp::PairFirst(cn);
  nInY = AliMp::PairSecond(cn);
}

//_____________________________________________________________________________
void AliMUONClusterFinderPeakFit::RemovePixel(Int_t i)
{
  /// Remove pixel at index i
  AliMUONPad* pixPtr = Pixel(i);
  fPixArray->RemoveAt(i); 
  delete pixPtr;
}

//_____________________________________________________________________________
AliMUONPad* 
AliMUONClusterFinderPeakFit::Pixel(Int_t i) const
{
  /// Returns pixel at index i
  return static_cast<AliMUONPad*>(fPixArray->UncheckedAt(i));
}

//_____________________________________________________________________________
void 
AliMUONClusterFinderPeakFit::Print(Option_t* what) const
{
  /// printout
  TString swhat(what);
  swhat.ToLower();
  if ( swhat.Contains("precluster") )
  {
    if ( fPreCluster) fPreCluster->Print();
  }
}


 AliMUONClusterFinderPeakFit.cxx:1
 AliMUONClusterFinderPeakFit.cxx:2
 AliMUONClusterFinderPeakFit.cxx:3
 AliMUONClusterFinderPeakFit.cxx:4
 AliMUONClusterFinderPeakFit.cxx:5
 AliMUONClusterFinderPeakFit.cxx:6
 AliMUONClusterFinderPeakFit.cxx:7
 AliMUONClusterFinderPeakFit.cxx:8
 AliMUONClusterFinderPeakFit.cxx:9
 AliMUONClusterFinderPeakFit.cxx:10
 AliMUONClusterFinderPeakFit.cxx:11
 AliMUONClusterFinderPeakFit.cxx:12
 AliMUONClusterFinderPeakFit.cxx:13
 AliMUONClusterFinderPeakFit.cxx:14
 AliMUONClusterFinderPeakFit.cxx:15
 AliMUONClusterFinderPeakFit.cxx:16
 AliMUONClusterFinderPeakFit.cxx:17
 AliMUONClusterFinderPeakFit.cxx:18
 AliMUONClusterFinderPeakFit.cxx:19
 AliMUONClusterFinderPeakFit.cxx:20
 AliMUONClusterFinderPeakFit.cxx:21
 AliMUONClusterFinderPeakFit.cxx:22
 AliMUONClusterFinderPeakFit.cxx:23
 AliMUONClusterFinderPeakFit.cxx:24
 AliMUONClusterFinderPeakFit.cxx:25
 AliMUONClusterFinderPeakFit.cxx:26
 AliMUONClusterFinderPeakFit.cxx:27
 AliMUONClusterFinderPeakFit.cxx:28
 AliMUONClusterFinderPeakFit.cxx:29
 AliMUONClusterFinderPeakFit.cxx:30
 AliMUONClusterFinderPeakFit.cxx:31
 AliMUONClusterFinderPeakFit.cxx:32
 AliMUONClusterFinderPeakFit.cxx:33
 AliMUONClusterFinderPeakFit.cxx:34
 AliMUONClusterFinderPeakFit.cxx:35
 AliMUONClusterFinderPeakFit.cxx:36
 AliMUONClusterFinderPeakFit.cxx:37
 AliMUONClusterFinderPeakFit.cxx:38
 AliMUONClusterFinderPeakFit.cxx:39
 AliMUONClusterFinderPeakFit.cxx:40
 AliMUONClusterFinderPeakFit.cxx:41
 AliMUONClusterFinderPeakFit.cxx:42
 AliMUONClusterFinderPeakFit.cxx:43
 AliMUONClusterFinderPeakFit.cxx:44
 AliMUONClusterFinderPeakFit.cxx:45
 AliMUONClusterFinderPeakFit.cxx:46
 AliMUONClusterFinderPeakFit.cxx:47
 AliMUONClusterFinderPeakFit.cxx:48
 AliMUONClusterFinderPeakFit.cxx:49
 AliMUONClusterFinderPeakFit.cxx:50
 AliMUONClusterFinderPeakFit.cxx:51
 AliMUONClusterFinderPeakFit.cxx:52
 AliMUONClusterFinderPeakFit.cxx:53
 AliMUONClusterFinderPeakFit.cxx:54
 AliMUONClusterFinderPeakFit.cxx:55
 AliMUONClusterFinderPeakFit.cxx:56
 AliMUONClusterFinderPeakFit.cxx:57
 AliMUONClusterFinderPeakFit.cxx:58
 AliMUONClusterFinderPeakFit.cxx:59
 AliMUONClusterFinderPeakFit.cxx:60
 AliMUONClusterFinderPeakFit.cxx:61
 AliMUONClusterFinderPeakFit.cxx:62
 AliMUONClusterFinderPeakFit.cxx:63
 AliMUONClusterFinderPeakFit.cxx:64
 AliMUONClusterFinderPeakFit.cxx:65
 AliMUONClusterFinderPeakFit.cxx:66
 AliMUONClusterFinderPeakFit.cxx:67
 AliMUONClusterFinderPeakFit.cxx:68
 AliMUONClusterFinderPeakFit.cxx:69
 AliMUONClusterFinderPeakFit.cxx:70
 AliMUONClusterFinderPeakFit.cxx:71
 AliMUONClusterFinderPeakFit.cxx:72
 AliMUONClusterFinderPeakFit.cxx:73
 AliMUONClusterFinderPeakFit.cxx:74
 AliMUONClusterFinderPeakFit.cxx:75
 AliMUONClusterFinderPeakFit.cxx:76
 AliMUONClusterFinderPeakFit.cxx:77
 AliMUONClusterFinderPeakFit.cxx:78
 AliMUONClusterFinderPeakFit.cxx:79
 AliMUONClusterFinderPeakFit.cxx:80
 AliMUONClusterFinderPeakFit.cxx:81
 AliMUONClusterFinderPeakFit.cxx:82
 AliMUONClusterFinderPeakFit.cxx:83
 AliMUONClusterFinderPeakFit.cxx:84
 AliMUONClusterFinderPeakFit.cxx:85
 AliMUONClusterFinderPeakFit.cxx:86
 AliMUONClusterFinderPeakFit.cxx:87
 AliMUONClusterFinderPeakFit.cxx:88
 AliMUONClusterFinderPeakFit.cxx:89
 AliMUONClusterFinderPeakFit.cxx:90
 AliMUONClusterFinderPeakFit.cxx:91
 AliMUONClusterFinderPeakFit.cxx:92
 AliMUONClusterFinderPeakFit.cxx:93
 AliMUONClusterFinderPeakFit.cxx:94
 AliMUONClusterFinderPeakFit.cxx:95
 AliMUONClusterFinderPeakFit.cxx:96
 AliMUONClusterFinderPeakFit.cxx:97
 AliMUONClusterFinderPeakFit.cxx:98
 AliMUONClusterFinderPeakFit.cxx:99
 AliMUONClusterFinderPeakFit.cxx:100
 AliMUONClusterFinderPeakFit.cxx:101
 AliMUONClusterFinderPeakFit.cxx:102
 AliMUONClusterFinderPeakFit.cxx:103
 AliMUONClusterFinderPeakFit.cxx:104
 AliMUONClusterFinderPeakFit.cxx:105
 AliMUONClusterFinderPeakFit.cxx:106
 AliMUONClusterFinderPeakFit.cxx:107
 AliMUONClusterFinderPeakFit.cxx:108
 AliMUONClusterFinderPeakFit.cxx:109
 AliMUONClusterFinderPeakFit.cxx:110
 AliMUONClusterFinderPeakFit.cxx:111
 AliMUONClusterFinderPeakFit.cxx:112
 AliMUONClusterFinderPeakFit.cxx:113
 AliMUONClusterFinderPeakFit.cxx:114
 AliMUONClusterFinderPeakFit.cxx:115
 AliMUONClusterFinderPeakFit.cxx:116
 AliMUONClusterFinderPeakFit.cxx:117
 AliMUONClusterFinderPeakFit.cxx:118
 AliMUONClusterFinderPeakFit.cxx:119
 AliMUONClusterFinderPeakFit.cxx:120
 AliMUONClusterFinderPeakFit.cxx:121
 AliMUONClusterFinderPeakFit.cxx:122
 AliMUONClusterFinderPeakFit.cxx:123
 AliMUONClusterFinderPeakFit.cxx:124
 AliMUONClusterFinderPeakFit.cxx:125
 AliMUONClusterFinderPeakFit.cxx:126
 AliMUONClusterFinderPeakFit.cxx:127
 AliMUONClusterFinderPeakFit.cxx:128
 AliMUONClusterFinderPeakFit.cxx:129
 AliMUONClusterFinderPeakFit.cxx:130
 AliMUONClusterFinderPeakFit.cxx:131
 AliMUONClusterFinderPeakFit.cxx:132
 AliMUONClusterFinderPeakFit.cxx:133
 AliMUONClusterFinderPeakFit.cxx:134
 AliMUONClusterFinderPeakFit.cxx:135
 AliMUONClusterFinderPeakFit.cxx:136
 AliMUONClusterFinderPeakFit.cxx:137
 AliMUONClusterFinderPeakFit.cxx:138
 AliMUONClusterFinderPeakFit.cxx:139
 AliMUONClusterFinderPeakFit.cxx:140
 AliMUONClusterFinderPeakFit.cxx:141
 AliMUONClusterFinderPeakFit.cxx:142
 AliMUONClusterFinderPeakFit.cxx:143
 AliMUONClusterFinderPeakFit.cxx:144
 AliMUONClusterFinderPeakFit.cxx:145
 AliMUONClusterFinderPeakFit.cxx:146
 AliMUONClusterFinderPeakFit.cxx:147
 AliMUONClusterFinderPeakFit.cxx:148
 AliMUONClusterFinderPeakFit.cxx:149
 AliMUONClusterFinderPeakFit.cxx:150
 AliMUONClusterFinderPeakFit.cxx:151
 AliMUONClusterFinderPeakFit.cxx:152
 AliMUONClusterFinderPeakFit.cxx:153
 AliMUONClusterFinderPeakFit.cxx:154
 AliMUONClusterFinderPeakFit.cxx:155
 AliMUONClusterFinderPeakFit.cxx:156
 AliMUONClusterFinderPeakFit.cxx:157
 AliMUONClusterFinderPeakFit.cxx:158
 AliMUONClusterFinderPeakFit.cxx:159
 AliMUONClusterFinderPeakFit.cxx:160
 AliMUONClusterFinderPeakFit.cxx:161
 AliMUONClusterFinderPeakFit.cxx:162
 AliMUONClusterFinderPeakFit.cxx:163
 AliMUONClusterFinderPeakFit.cxx:164
 AliMUONClusterFinderPeakFit.cxx:165
 AliMUONClusterFinderPeakFit.cxx:166
 AliMUONClusterFinderPeakFit.cxx:167
 AliMUONClusterFinderPeakFit.cxx:168
 AliMUONClusterFinderPeakFit.cxx:169
 AliMUONClusterFinderPeakFit.cxx:170
 AliMUONClusterFinderPeakFit.cxx:171
 AliMUONClusterFinderPeakFit.cxx:172
 AliMUONClusterFinderPeakFit.cxx:173
 AliMUONClusterFinderPeakFit.cxx:174
 AliMUONClusterFinderPeakFit.cxx:175
 AliMUONClusterFinderPeakFit.cxx:176
 AliMUONClusterFinderPeakFit.cxx:177
 AliMUONClusterFinderPeakFit.cxx:178
 AliMUONClusterFinderPeakFit.cxx:179
 AliMUONClusterFinderPeakFit.cxx:180
 AliMUONClusterFinderPeakFit.cxx:181
 AliMUONClusterFinderPeakFit.cxx:182
 AliMUONClusterFinderPeakFit.cxx:183
 AliMUONClusterFinderPeakFit.cxx:184
 AliMUONClusterFinderPeakFit.cxx:185
 AliMUONClusterFinderPeakFit.cxx:186
 AliMUONClusterFinderPeakFit.cxx:187
 AliMUONClusterFinderPeakFit.cxx:188
 AliMUONClusterFinderPeakFit.cxx:189
 AliMUONClusterFinderPeakFit.cxx:190
 AliMUONClusterFinderPeakFit.cxx:191
 AliMUONClusterFinderPeakFit.cxx:192
 AliMUONClusterFinderPeakFit.cxx:193
 AliMUONClusterFinderPeakFit.cxx:194
 AliMUONClusterFinderPeakFit.cxx:195
 AliMUONClusterFinderPeakFit.cxx:196
 AliMUONClusterFinderPeakFit.cxx:197
 AliMUONClusterFinderPeakFit.cxx:198
 AliMUONClusterFinderPeakFit.cxx:199
 AliMUONClusterFinderPeakFit.cxx:200
 AliMUONClusterFinderPeakFit.cxx:201
 AliMUONClusterFinderPeakFit.cxx:202
 AliMUONClusterFinderPeakFit.cxx:203
 AliMUONClusterFinderPeakFit.cxx:204
 AliMUONClusterFinderPeakFit.cxx:205
 AliMUONClusterFinderPeakFit.cxx:206
 AliMUONClusterFinderPeakFit.cxx:207
 AliMUONClusterFinderPeakFit.cxx:208
 AliMUONClusterFinderPeakFit.cxx:209
 AliMUONClusterFinderPeakFit.cxx:210
 AliMUONClusterFinderPeakFit.cxx:211
 AliMUONClusterFinderPeakFit.cxx:212
 AliMUONClusterFinderPeakFit.cxx:213
 AliMUONClusterFinderPeakFit.cxx:214
 AliMUONClusterFinderPeakFit.cxx:215
 AliMUONClusterFinderPeakFit.cxx:216
 AliMUONClusterFinderPeakFit.cxx:217
 AliMUONClusterFinderPeakFit.cxx:218
 AliMUONClusterFinderPeakFit.cxx:219
 AliMUONClusterFinderPeakFit.cxx:220
 AliMUONClusterFinderPeakFit.cxx:221
 AliMUONClusterFinderPeakFit.cxx:222
 AliMUONClusterFinderPeakFit.cxx:223
 AliMUONClusterFinderPeakFit.cxx:224
 AliMUONClusterFinderPeakFit.cxx:225
 AliMUONClusterFinderPeakFit.cxx:226
 AliMUONClusterFinderPeakFit.cxx:227
 AliMUONClusterFinderPeakFit.cxx:228
 AliMUONClusterFinderPeakFit.cxx:229
 AliMUONClusterFinderPeakFit.cxx:230
 AliMUONClusterFinderPeakFit.cxx:231
 AliMUONClusterFinderPeakFit.cxx:232
 AliMUONClusterFinderPeakFit.cxx:233
 AliMUONClusterFinderPeakFit.cxx:234
 AliMUONClusterFinderPeakFit.cxx:235
 AliMUONClusterFinderPeakFit.cxx:236
 AliMUONClusterFinderPeakFit.cxx:237
 AliMUONClusterFinderPeakFit.cxx:238
 AliMUONClusterFinderPeakFit.cxx:239
 AliMUONClusterFinderPeakFit.cxx:240
 AliMUONClusterFinderPeakFit.cxx:241
 AliMUONClusterFinderPeakFit.cxx:242
 AliMUONClusterFinderPeakFit.cxx:243
 AliMUONClusterFinderPeakFit.cxx:244
 AliMUONClusterFinderPeakFit.cxx:245
 AliMUONClusterFinderPeakFit.cxx:246
 AliMUONClusterFinderPeakFit.cxx:247
 AliMUONClusterFinderPeakFit.cxx:248
 AliMUONClusterFinderPeakFit.cxx:249
 AliMUONClusterFinderPeakFit.cxx:250
 AliMUONClusterFinderPeakFit.cxx:251
 AliMUONClusterFinderPeakFit.cxx:252
 AliMUONClusterFinderPeakFit.cxx:253
 AliMUONClusterFinderPeakFit.cxx:254
 AliMUONClusterFinderPeakFit.cxx:255
 AliMUONClusterFinderPeakFit.cxx:256
 AliMUONClusterFinderPeakFit.cxx:257
 AliMUONClusterFinderPeakFit.cxx:258
 AliMUONClusterFinderPeakFit.cxx:259
 AliMUONClusterFinderPeakFit.cxx:260
 AliMUONClusterFinderPeakFit.cxx:261
 AliMUONClusterFinderPeakFit.cxx:262
 AliMUONClusterFinderPeakFit.cxx:263
 AliMUONClusterFinderPeakFit.cxx:264
 AliMUONClusterFinderPeakFit.cxx:265
 AliMUONClusterFinderPeakFit.cxx:266
 AliMUONClusterFinderPeakFit.cxx:267
 AliMUONClusterFinderPeakFit.cxx:268
 AliMUONClusterFinderPeakFit.cxx:269
 AliMUONClusterFinderPeakFit.cxx:270
 AliMUONClusterFinderPeakFit.cxx:271
 AliMUONClusterFinderPeakFit.cxx:272
 AliMUONClusterFinderPeakFit.cxx:273
 AliMUONClusterFinderPeakFit.cxx:274
 AliMUONClusterFinderPeakFit.cxx:275
 AliMUONClusterFinderPeakFit.cxx:276
 AliMUONClusterFinderPeakFit.cxx:277
 AliMUONClusterFinderPeakFit.cxx:278
 AliMUONClusterFinderPeakFit.cxx:279
 AliMUONClusterFinderPeakFit.cxx:280
 AliMUONClusterFinderPeakFit.cxx:281
 AliMUONClusterFinderPeakFit.cxx:282
 AliMUONClusterFinderPeakFit.cxx:283
 AliMUONClusterFinderPeakFit.cxx:284
 AliMUONClusterFinderPeakFit.cxx:285
 AliMUONClusterFinderPeakFit.cxx:286
 AliMUONClusterFinderPeakFit.cxx:287
 AliMUONClusterFinderPeakFit.cxx:288
 AliMUONClusterFinderPeakFit.cxx:289
 AliMUONClusterFinderPeakFit.cxx:290
 AliMUONClusterFinderPeakFit.cxx:291
 AliMUONClusterFinderPeakFit.cxx:292
 AliMUONClusterFinderPeakFit.cxx:293
 AliMUONClusterFinderPeakFit.cxx:294
 AliMUONClusterFinderPeakFit.cxx:295
 AliMUONClusterFinderPeakFit.cxx:296
 AliMUONClusterFinderPeakFit.cxx:297
 AliMUONClusterFinderPeakFit.cxx:298
 AliMUONClusterFinderPeakFit.cxx:299
 AliMUONClusterFinderPeakFit.cxx:300
 AliMUONClusterFinderPeakFit.cxx:301
 AliMUONClusterFinderPeakFit.cxx:302
 AliMUONClusterFinderPeakFit.cxx:303
 AliMUONClusterFinderPeakFit.cxx:304
 AliMUONClusterFinderPeakFit.cxx:305
 AliMUONClusterFinderPeakFit.cxx:306
 AliMUONClusterFinderPeakFit.cxx:307
 AliMUONClusterFinderPeakFit.cxx:308
 AliMUONClusterFinderPeakFit.cxx:309
 AliMUONClusterFinderPeakFit.cxx:310
 AliMUONClusterFinderPeakFit.cxx:311
 AliMUONClusterFinderPeakFit.cxx:312
 AliMUONClusterFinderPeakFit.cxx:313
 AliMUONClusterFinderPeakFit.cxx:314
 AliMUONClusterFinderPeakFit.cxx:315
 AliMUONClusterFinderPeakFit.cxx:316
 AliMUONClusterFinderPeakFit.cxx:317
 AliMUONClusterFinderPeakFit.cxx:318
 AliMUONClusterFinderPeakFit.cxx:319
 AliMUONClusterFinderPeakFit.cxx:320
 AliMUONClusterFinderPeakFit.cxx:321
 AliMUONClusterFinderPeakFit.cxx:322
 AliMUONClusterFinderPeakFit.cxx:323
 AliMUONClusterFinderPeakFit.cxx:324
 AliMUONClusterFinderPeakFit.cxx:325
 AliMUONClusterFinderPeakFit.cxx:326
 AliMUONClusterFinderPeakFit.cxx:327
 AliMUONClusterFinderPeakFit.cxx:328
 AliMUONClusterFinderPeakFit.cxx:329
 AliMUONClusterFinderPeakFit.cxx:330
 AliMUONClusterFinderPeakFit.cxx:331
 AliMUONClusterFinderPeakFit.cxx:332
 AliMUONClusterFinderPeakFit.cxx:333
 AliMUONClusterFinderPeakFit.cxx:334
 AliMUONClusterFinderPeakFit.cxx:335
 AliMUONClusterFinderPeakFit.cxx:336
 AliMUONClusterFinderPeakFit.cxx:337
 AliMUONClusterFinderPeakFit.cxx:338
 AliMUONClusterFinderPeakFit.cxx:339
 AliMUONClusterFinderPeakFit.cxx:340
 AliMUONClusterFinderPeakFit.cxx:341
 AliMUONClusterFinderPeakFit.cxx:342
 AliMUONClusterFinderPeakFit.cxx:343
 AliMUONClusterFinderPeakFit.cxx:344
 AliMUONClusterFinderPeakFit.cxx:345
 AliMUONClusterFinderPeakFit.cxx:346
 AliMUONClusterFinderPeakFit.cxx:347
 AliMUONClusterFinderPeakFit.cxx:348
 AliMUONClusterFinderPeakFit.cxx:349
 AliMUONClusterFinderPeakFit.cxx:350
 AliMUONClusterFinderPeakFit.cxx:351
 AliMUONClusterFinderPeakFit.cxx:352
 AliMUONClusterFinderPeakFit.cxx:353
 AliMUONClusterFinderPeakFit.cxx:354
 AliMUONClusterFinderPeakFit.cxx:355
 AliMUONClusterFinderPeakFit.cxx:356
 AliMUONClusterFinderPeakFit.cxx:357
 AliMUONClusterFinderPeakFit.cxx:358
 AliMUONClusterFinderPeakFit.cxx:359
 AliMUONClusterFinderPeakFit.cxx:360
 AliMUONClusterFinderPeakFit.cxx:361
 AliMUONClusterFinderPeakFit.cxx:362
 AliMUONClusterFinderPeakFit.cxx:363
 AliMUONClusterFinderPeakFit.cxx:364
 AliMUONClusterFinderPeakFit.cxx:365
 AliMUONClusterFinderPeakFit.cxx:366
 AliMUONClusterFinderPeakFit.cxx:367
 AliMUONClusterFinderPeakFit.cxx:368
 AliMUONClusterFinderPeakFit.cxx:369
 AliMUONClusterFinderPeakFit.cxx:370
 AliMUONClusterFinderPeakFit.cxx:371
 AliMUONClusterFinderPeakFit.cxx:372
 AliMUONClusterFinderPeakFit.cxx:373
 AliMUONClusterFinderPeakFit.cxx:374
 AliMUONClusterFinderPeakFit.cxx:375
 AliMUONClusterFinderPeakFit.cxx:376
 AliMUONClusterFinderPeakFit.cxx:377
 AliMUONClusterFinderPeakFit.cxx:378
 AliMUONClusterFinderPeakFit.cxx:379
 AliMUONClusterFinderPeakFit.cxx:380
 AliMUONClusterFinderPeakFit.cxx:381
 AliMUONClusterFinderPeakFit.cxx:382
 AliMUONClusterFinderPeakFit.cxx:383
 AliMUONClusterFinderPeakFit.cxx:384
 AliMUONClusterFinderPeakFit.cxx:385
 AliMUONClusterFinderPeakFit.cxx:386
 AliMUONClusterFinderPeakFit.cxx:387
 AliMUONClusterFinderPeakFit.cxx:388
 AliMUONClusterFinderPeakFit.cxx:389
 AliMUONClusterFinderPeakFit.cxx:390
 AliMUONClusterFinderPeakFit.cxx:391
 AliMUONClusterFinderPeakFit.cxx:392
 AliMUONClusterFinderPeakFit.cxx:393
 AliMUONClusterFinderPeakFit.cxx:394
 AliMUONClusterFinderPeakFit.cxx:395
 AliMUONClusterFinderPeakFit.cxx:396
 AliMUONClusterFinderPeakFit.cxx:397
 AliMUONClusterFinderPeakFit.cxx:398
 AliMUONClusterFinderPeakFit.cxx:399
 AliMUONClusterFinderPeakFit.cxx:400
 AliMUONClusterFinderPeakFit.cxx:401
 AliMUONClusterFinderPeakFit.cxx:402
 AliMUONClusterFinderPeakFit.cxx:403
 AliMUONClusterFinderPeakFit.cxx:404
 AliMUONClusterFinderPeakFit.cxx:405
 AliMUONClusterFinderPeakFit.cxx:406
 AliMUONClusterFinderPeakFit.cxx:407
 AliMUONClusterFinderPeakFit.cxx:408
 AliMUONClusterFinderPeakFit.cxx:409
 AliMUONClusterFinderPeakFit.cxx:410
 AliMUONClusterFinderPeakFit.cxx:411
 AliMUONClusterFinderPeakFit.cxx:412
 AliMUONClusterFinderPeakFit.cxx:413
 AliMUONClusterFinderPeakFit.cxx:414
 AliMUONClusterFinderPeakFit.cxx:415
 AliMUONClusterFinderPeakFit.cxx:416
 AliMUONClusterFinderPeakFit.cxx:417
 AliMUONClusterFinderPeakFit.cxx:418
 AliMUONClusterFinderPeakFit.cxx:419
 AliMUONClusterFinderPeakFit.cxx:420
 AliMUONClusterFinderPeakFit.cxx:421
 AliMUONClusterFinderPeakFit.cxx:422
 AliMUONClusterFinderPeakFit.cxx:423
 AliMUONClusterFinderPeakFit.cxx:424
 AliMUONClusterFinderPeakFit.cxx:425
 AliMUONClusterFinderPeakFit.cxx:426
 AliMUONClusterFinderPeakFit.cxx:427
 AliMUONClusterFinderPeakFit.cxx:428
 AliMUONClusterFinderPeakFit.cxx:429
 AliMUONClusterFinderPeakFit.cxx:430
 AliMUONClusterFinderPeakFit.cxx:431
 AliMUONClusterFinderPeakFit.cxx:432
 AliMUONClusterFinderPeakFit.cxx:433
 AliMUONClusterFinderPeakFit.cxx:434
 AliMUONClusterFinderPeakFit.cxx:435
 AliMUONClusterFinderPeakFit.cxx:436
 AliMUONClusterFinderPeakFit.cxx:437
 AliMUONClusterFinderPeakFit.cxx:438
 AliMUONClusterFinderPeakFit.cxx:439
 AliMUONClusterFinderPeakFit.cxx:440
 AliMUONClusterFinderPeakFit.cxx:441
 AliMUONClusterFinderPeakFit.cxx:442
 AliMUONClusterFinderPeakFit.cxx:443
 AliMUONClusterFinderPeakFit.cxx:444
 AliMUONClusterFinderPeakFit.cxx:445
 AliMUONClusterFinderPeakFit.cxx:446
 AliMUONClusterFinderPeakFit.cxx:447
 AliMUONClusterFinderPeakFit.cxx:448
 AliMUONClusterFinderPeakFit.cxx:449
 AliMUONClusterFinderPeakFit.cxx:450
 AliMUONClusterFinderPeakFit.cxx:451
 AliMUONClusterFinderPeakFit.cxx:452
 AliMUONClusterFinderPeakFit.cxx:453
 AliMUONClusterFinderPeakFit.cxx:454
 AliMUONClusterFinderPeakFit.cxx:455
 AliMUONClusterFinderPeakFit.cxx:456
 AliMUONClusterFinderPeakFit.cxx:457
 AliMUONClusterFinderPeakFit.cxx:458
 AliMUONClusterFinderPeakFit.cxx:459
 AliMUONClusterFinderPeakFit.cxx:460
 AliMUONClusterFinderPeakFit.cxx:461
 AliMUONClusterFinderPeakFit.cxx:462
 AliMUONClusterFinderPeakFit.cxx:463
 AliMUONClusterFinderPeakFit.cxx:464
 AliMUONClusterFinderPeakFit.cxx:465
 AliMUONClusterFinderPeakFit.cxx:466
 AliMUONClusterFinderPeakFit.cxx:467
 AliMUONClusterFinderPeakFit.cxx:468
 AliMUONClusterFinderPeakFit.cxx:469
 AliMUONClusterFinderPeakFit.cxx:470
 AliMUONClusterFinderPeakFit.cxx:471
 AliMUONClusterFinderPeakFit.cxx:472
 AliMUONClusterFinderPeakFit.cxx:473
 AliMUONClusterFinderPeakFit.cxx:474
 AliMUONClusterFinderPeakFit.cxx:475
 AliMUONClusterFinderPeakFit.cxx:476
 AliMUONClusterFinderPeakFit.cxx:477
 AliMUONClusterFinderPeakFit.cxx:478
 AliMUONClusterFinderPeakFit.cxx:479
 AliMUONClusterFinderPeakFit.cxx:480
 AliMUONClusterFinderPeakFit.cxx:481
 AliMUONClusterFinderPeakFit.cxx:482
 AliMUONClusterFinderPeakFit.cxx:483
 AliMUONClusterFinderPeakFit.cxx:484
 AliMUONClusterFinderPeakFit.cxx:485
 AliMUONClusterFinderPeakFit.cxx:486
 AliMUONClusterFinderPeakFit.cxx:487
 AliMUONClusterFinderPeakFit.cxx:488
 AliMUONClusterFinderPeakFit.cxx:489
 AliMUONClusterFinderPeakFit.cxx:490
 AliMUONClusterFinderPeakFit.cxx:491
 AliMUONClusterFinderPeakFit.cxx:492
 AliMUONClusterFinderPeakFit.cxx:493
 AliMUONClusterFinderPeakFit.cxx:494
 AliMUONClusterFinderPeakFit.cxx:495
 AliMUONClusterFinderPeakFit.cxx:496
 AliMUONClusterFinderPeakFit.cxx:497
 AliMUONClusterFinderPeakFit.cxx:498
 AliMUONClusterFinderPeakFit.cxx:499
 AliMUONClusterFinderPeakFit.cxx:500
 AliMUONClusterFinderPeakFit.cxx:501
 AliMUONClusterFinderPeakFit.cxx:502
 AliMUONClusterFinderPeakFit.cxx:503
 AliMUONClusterFinderPeakFit.cxx:504
 AliMUONClusterFinderPeakFit.cxx:505
 AliMUONClusterFinderPeakFit.cxx:506
 AliMUONClusterFinderPeakFit.cxx:507
 AliMUONClusterFinderPeakFit.cxx:508
 AliMUONClusterFinderPeakFit.cxx:509
 AliMUONClusterFinderPeakFit.cxx:510
 AliMUONClusterFinderPeakFit.cxx:511
 AliMUONClusterFinderPeakFit.cxx:512
 AliMUONClusterFinderPeakFit.cxx:513
 AliMUONClusterFinderPeakFit.cxx:514
 AliMUONClusterFinderPeakFit.cxx:515
 AliMUONClusterFinderPeakFit.cxx:516
 AliMUONClusterFinderPeakFit.cxx:517
 AliMUONClusterFinderPeakFit.cxx:518
 AliMUONClusterFinderPeakFit.cxx:519
 AliMUONClusterFinderPeakFit.cxx:520
 AliMUONClusterFinderPeakFit.cxx:521
 AliMUONClusterFinderPeakFit.cxx:522
 AliMUONClusterFinderPeakFit.cxx:523
 AliMUONClusterFinderPeakFit.cxx:524
 AliMUONClusterFinderPeakFit.cxx:525
 AliMUONClusterFinderPeakFit.cxx:526
 AliMUONClusterFinderPeakFit.cxx:527
 AliMUONClusterFinderPeakFit.cxx:528
 AliMUONClusterFinderPeakFit.cxx:529
 AliMUONClusterFinderPeakFit.cxx:530
 AliMUONClusterFinderPeakFit.cxx:531
 AliMUONClusterFinderPeakFit.cxx:532
 AliMUONClusterFinderPeakFit.cxx:533
 AliMUONClusterFinderPeakFit.cxx:534
 AliMUONClusterFinderPeakFit.cxx:535
 AliMUONClusterFinderPeakFit.cxx:536
 AliMUONClusterFinderPeakFit.cxx:537
 AliMUONClusterFinderPeakFit.cxx:538
 AliMUONClusterFinderPeakFit.cxx:539
 AliMUONClusterFinderPeakFit.cxx:540
 AliMUONClusterFinderPeakFit.cxx:541
 AliMUONClusterFinderPeakFit.cxx:542
 AliMUONClusterFinderPeakFit.cxx:543
 AliMUONClusterFinderPeakFit.cxx:544
 AliMUONClusterFinderPeakFit.cxx:545
 AliMUONClusterFinderPeakFit.cxx:546
 AliMUONClusterFinderPeakFit.cxx:547
 AliMUONClusterFinderPeakFit.cxx:548
 AliMUONClusterFinderPeakFit.cxx:549
 AliMUONClusterFinderPeakFit.cxx:550
 AliMUONClusterFinderPeakFit.cxx:551
 AliMUONClusterFinderPeakFit.cxx:552
 AliMUONClusterFinderPeakFit.cxx:553
 AliMUONClusterFinderPeakFit.cxx:554
 AliMUONClusterFinderPeakFit.cxx:555
 AliMUONClusterFinderPeakFit.cxx:556
 AliMUONClusterFinderPeakFit.cxx:557
 AliMUONClusterFinderPeakFit.cxx:558
 AliMUONClusterFinderPeakFit.cxx:559
 AliMUONClusterFinderPeakFit.cxx:560
 AliMUONClusterFinderPeakFit.cxx:561
 AliMUONClusterFinderPeakFit.cxx:562
 AliMUONClusterFinderPeakFit.cxx:563
 AliMUONClusterFinderPeakFit.cxx:564
 AliMUONClusterFinderPeakFit.cxx:565
 AliMUONClusterFinderPeakFit.cxx:566
 AliMUONClusterFinderPeakFit.cxx:567
 AliMUONClusterFinderPeakFit.cxx:568
 AliMUONClusterFinderPeakFit.cxx:569
 AliMUONClusterFinderPeakFit.cxx:570
 AliMUONClusterFinderPeakFit.cxx:571
 AliMUONClusterFinderPeakFit.cxx:572
 AliMUONClusterFinderPeakFit.cxx:573
 AliMUONClusterFinderPeakFit.cxx:574
 AliMUONClusterFinderPeakFit.cxx:575
 AliMUONClusterFinderPeakFit.cxx:576
 AliMUONClusterFinderPeakFit.cxx:577
 AliMUONClusterFinderPeakFit.cxx:578
 AliMUONClusterFinderPeakFit.cxx:579
 AliMUONClusterFinderPeakFit.cxx:580
 AliMUONClusterFinderPeakFit.cxx:581
 AliMUONClusterFinderPeakFit.cxx:582
 AliMUONClusterFinderPeakFit.cxx:583
 AliMUONClusterFinderPeakFit.cxx:584
 AliMUONClusterFinderPeakFit.cxx:585
 AliMUONClusterFinderPeakFit.cxx:586
 AliMUONClusterFinderPeakFit.cxx:587
 AliMUONClusterFinderPeakFit.cxx:588
 AliMUONClusterFinderPeakFit.cxx:589
 AliMUONClusterFinderPeakFit.cxx:590
 AliMUONClusterFinderPeakFit.cxx:591
 AliMUONClusterFinderPeakFit.cxx:592
 AliMUONClusterFinderPeakFit.cxx:593
 AliMUONClusterFinderPeakFit.cxx:594
 AliMUONClusterFinderPeakFit.cxx:595
 AliMUONClusterFinderPeakFit.cxx:596
 AliMUONClusterFinderPeakFit.cxx:597
 AliMUONClusterFinderPeakFit.cxx:598
 AliMUONClusterFinderPeakFit.cxx:599
 AliMUONClusterFinderPeakFit.cxx:600
 AliMUONClusterFinderPeakFit.cxx:601
 AliMUONClusterFinderPeakFit.cxx:602
 AliMUONClusterFinderPeakFit.cxx:603
 AliMUONClusterFinderPeakFit.cxx:604
 AliMUONClusterFinderPeakFit.cxx:605
 AliMUONClusterFinderPeakFit.cxx:606
 AliMUONClusterFinderPeakFit.cxx:607
 AliMUONClusterFinderPeakFit.cxx:608
 AliMUONClusterFinderPeakFit.cxx:609
 AliMUONClusterFinderPeakFit.cxx:610
 AliMUONClusterFinderPeakFit.cxx:611
 AliMUONClusterFinderPeakFit.cxx:612
 AliMUONClusterFinderPeakFit.cxx:613
 AliMUONClusterFinderPeakFit.cxx:614
 AliMUONClusterFinderPeakFit.cxx:615
 AliMUONClusterFinderPeakFit.cxx:616
 AliMUONClusterFinderPeakFit.cxx:617
 AliMUONClusterFinderPeakFit.cxx:618
 AliMUONClusterFinderPeakFit.cxx:619
 AliMUONClusterFinderPeakFit.cxx:620
 AliMUONClusterFinderPeakFit.cxx:621
 AliMUONClusterFinderPeakFit.cxx:622
 AliMUONClusterFinderPeakFit.cxx:623
 AliMUONClusterFinderPeakFit.cxx:624
 AliMUONClusterFinderPeakFit.cxx:625
 AliMUONClusterFinderPeakFit.cxx:626
 AliMUONClusterFinderPeakFit.cxx:627
 AliMUONClusterFinderPeakFit.cxx:628
 AliMUONClusterFinderPeakFit.cxx:629
 AliMUONClusterFinderPeakFit.cxx:630
 AliMUONClusterFinderPeakFit.cxx:631
 AliMUONClusterFinderPeakFit.cxx:632
 AliMUONClusterFinderPeakFit.cxx:633
 AliMUONClusterFinderPeakFit.cxx:634
 AliMUONClusterFinderPeakFit.cxx:635
 AliMUONClusterFinderPeakFit.cxx:636
 AliMUONClusterFinderPeakFit.cxx:637
 AliMUONClusterFinderPeakFit.cxx:638
 AliMUONClusterFinderPeakFit.cxx:639
 AliMUONClusterFinderPeakFit.cxx:640
 AliMUONClusterFinderPeakFit.cxx:641
 AliMUONClusterFinderPeakFit.cxx:642
 AliMUONClusterFinderPeakFit.cxx:643
 AliMUONClusterFinderPeakFit.cxx:644
 AliMUONClusterFinderPeakFit.cxx:645
 AliMUONClusterFinderPeakFit.cxx:646
 AliMUONClusterFinderPeakFit.cxx:647
 AliMUONClusterFinderPeakFit.cxx:648
 AliMUONClusterFinderPeakFit.cxx:649
 AliMUONClusterFinderPeakFit.cxx:650
 AliMUONClusterFinderPeakFit.cxx:651
 AliMUONClusterFinderPeakFit.cxx:652
 AliMUONClusterFinderPeakFit.cxx:653
 AliMUONClusterFinderPeakFit.cxx:654
 AliMUONClusterFinderPeakFit.cxx:655
 AliMUONClusterFinderPeakFit.cxx:656
 AliMUONClusterFinderPeakFit.cxx:657
 AliMUONClusterFinderPeakFit.cxx:658
 AliMUONClusterFinderPeakFit.cxx:659
 AliMUONClusterFinderPeakFit.cxx:660
 AliMUONClusterFinderPeakFit.cxx:661
 AliMUONClusterFinderPeakFit.cxx:662
 AliMUONClusterFinderPeakFit.cxx:663
 AliMUONClusterFinderPeakFit.cxx:664
 AliMUONClusterFinderPeakFit.cxx:665
 AliMUONClusterFinderPeakFit.cxx:666
 AliMUONClusterFinderPeakFit.cxx:667
 AliMUONClusterFinderPeakFit.cxx:668
 AliMUONClusterFinderPeakFit.cxx:669
 AliMUONClusterFinderPeakFit.cxx:670
 AliMUONClusterFinderPeakFit.cxx:671
 AliMUONClusterFinderPeakFit.cxx:672
 AliMUONClusterFinderPeakFit.cxx:673
 AliMUONClusterFinderPeakFit.cxx:674
 AliMUONClusterFinderPeakFit.cxx:675
 AliMUONClusterFinderPeakFit.cxx:676
 AliMUONClusterFinderPeakFit.cxx:677
 AliMUONClusterFinderPeakFit.cxx:678
 AliMUONClusterFinderPeakFit.cxx:679
 AliMUONClusterFinderPeakFit.cxx:680
 AliMUONClusterFinderPeakFit.cxx:681
 AliMUONClusterFinderPeakFit.cxx:682
 AliMUONClusterFinderPeakFit.cxx:683
 AliMUONClusterFinderPeakFit.cxx:684
 AliMUONClusterFinderPeakFit.cxx:685
 AliMUONClusterFinderPeakFit.cxx:686
 AliMUONClusterFinderPeakFit.cxx:687
 AliMUONClusterFinderPeakFit.cxx:688
 AliMUONClusterFinderPeakFit.cxx:689
 AliMUONClusterFinderPeakFit.cxx:690
 AliMUONClusterFinderPeakFit.cxx:691
 AliMUONClusterFinderPeakFit.cxx:692
 AliMUONClusterFinderPeakFit.cxx:693
 AliMUONClusterFinderPeakFit.cxx:694
 AliMUONClusterFinderPeakFit.cxx:695
 AliMUONClusterFinderPeakFit.cxx:696
 AliMUONClusterFinderPeakFit.cxx:697
 AliMUONClusterFinderPeakFit.cxx:698
 AliMUONClusterFinderPeakFit.cxx:699
 AliMUONClusterFinderPeakFit.cxx:700
 AliMUONClusterFinderPeakFit.cxx:701
 AliMUONClusterFinderPeakFit.cxx:702
 AliMUONClusterFinderPeakFit.cxx:703
 AliMUONClusterFinderPeakFit.cxx:704
 AliMUONClusterFinderPeakFit.cxx:705
 AliMUONClusterFinderPeakFit.cxx:706
 AliMUONClusterFinderPeakFit.cxx:707
 AliMUONClusterFinderPeakFit.cxx:708
 AliMUONClusterFinderPeakFit.cxx:709
 AliMUONClusterFinderPeakFit.cxx:710
 AliMUONClusterFinderPeakFit.cxx:711
 AliMUONClusterFinderPeakFit.cxx:712
 AliMUONClusterFinderPeakFit.cxx:713
 AliMUONClusterFinderPeakFit.cxx:714
 AliMUONClusterFinderPeakFit.cxx:715
 AliMUONClusterFinderPeakFit.cxx:716
 AliMUONClusterFinderPeakFit.cxx:717
 AliMUONClusterFinderPeakFit.cxx:718
 AliMUONClusterFinderPeakFit.cxx:719
 AliMUONClusterFinderPeakFit.cxx:720
 AliMUONClusterFinderPeakFit.cxx:721
 AliMUONClusterFinderPeakFit.cxx:722
 AliMUONClusterFinderPeakFit.cxx:723
 AliMUONClusterFinderPeakFit.cxx:724
 AliMUONClusterFinderPeakFit.cxx:725
 AliMUONClusterFinderPeakFit.cxx:726
 AliMUONClusterFinderPeakFit.cxx:727
 AliMUONClusterFinderPeakFit.cxx:728
 AliMUONClusterFinderPeakFit.cxx:729
 AliMUONClusterFinderPeakFit.cxx:730
 AliMUONClusterFinderPeakFit.cxx:731
 AliMUONClusterFinderPeakFit.cxx:732
 AliMUONClusterFinderPeakFit.cxx:733
 AliMUONClusterFinderPeakFit.cxx:734
 AliMUONClusterFinderPeakFit.cxx:735
 AliMUONClusterFinderPeakFit.cxx:736
 AliMUONClusterFinderPeakFit.cxx:737
 AliMUONClusterFinderPeakFit.cxx:738
 AliMUONClusterFinderPeakFit.cxx:739
 AliMUONClusterFinderPeakFit.cxx:740
 AliMUONClusterFinderPeakFit.cxx:741
 AliMUONClusterFinderPeakFit.cxx:742
 AliMUONClusterFinderPeakFit.cxx:743
 AliMUONClusterFinderPeakFit.cxx:744
 AliMUONClusterFinderPeakFit.cxx:745
 AliMUONClusterFinderPeakFit.cxx:746
 AliMUONClusterFinderPeakFit.cxx:747
 AliMUONClusterFinderPeakFit.cxx:748
 AliMUONClusterFinderPeakFit.cxx:749
 AliMUONClusterFinderPeakFit.cxx:750
 AliMUONClusterFinderPeakFit.cxx:751
 AliMUONClusterFinderPeakFit.cxx:752
 AliMUONClusterFinderPeakFit.cxx:753
 AliMUONClusterFinderPeakFit.cxx:754
 AliMUONClusterFinderPeakFit.cxx:755
 AliMUONClusterFinderPeakFit.cxx:756
 AliMUONClusterFinderPeakFit.cxx:757
 AliMUONClusterFinderPeakFit.cxx:758
 AliMUONClusterFinderPeakFit.cxx:759
 AliMUONClusterFinderPeakFit.cxx:760
 AliMUONClusterFinderPeakFit.cxx:761
 AliMUONClusterFinderPeakFit.cxx:762
 AliMUONClusterFinderPeakFit.cxx:763
 AliMUONClusterFinderPeakFit.cxx:764
 AliMUONClusterFinderPeakFit.cxx:765
 AliMUONClusterFinderPeakFit.cxx:766
 AliMUONClusterFinderPeakFit.cxx:767
 AliMUONClusterFinderPeakFit.cxx:768
 AliMUONClusterFinderPeakFit.cxx:769
 AliMUONClusterFinderPeakFit.cxx:770
 AliMUONClusterFinderPeakFit.cxx:771
 AliMUONClusterFinderPeakFit.cxx:772
 AliMUONClusterFinderPeakFit.cxx:773
 AliMUONClusterFinderPeakFit.cxx:774
 AliMUONClusterFinderPeakFit.cxx:775
 AliMUONClusterFinderPeakFit.cxx:776
 AliMUONClusterFinderPeakFit.cxx:777
 AliMUONClusterFinderPeakFit.cxx:778
 AliMUONClusterFinderPeakFit.cxx:779
 AliMUONClusterFinderPeakFit.cxx:780
 AliMUONClusterFinderPeakFit.cxx:781
 AliMUONClusterFinderPeakFit.cxx:782
 AliMUONClusterFinderPeakFit.cxx:783
 AliMUONClusterFinderPeakFit.cxx:784
 AliMUONClusterFinderPeakFit.cxx:785
 AliMUONClusterFinderPeakFit.cxx:786
 AliMUONClusterFinderPeakFit.cxx:787
 AliMUONClusterFinderPeakFit.cxx:788
 AliMUONClusterFinderPeakFit.cxx:789
 AliMUONClusterFinderPeakFit.cxx:790
 AliMUONClusterFinderPeakFit.cxx:791
 AliMUONClusterFinderPeakFit.cxx:792
 AliMUONClusterFinderPeakFit.cxx:793
 AliMUONClusterFinderPeakFit.cxx:794
 AliMUONClusterFinderPeakFit.cxx:795
 AliMUONClusterFinderPeakFit.cxx:796
 AliMUONClusterFinderPeakFit.cxx:797
 AliMUONClusterFinderPeakFit.cxx:798
 AliMUONClusterFinderPeakFit.cxx:799
 AliMUONClusterFinderPeakFit.cxx:800
 AliMUONClusterFinderPeakFit.cxx:801
 AliMUONClusterFinderPeakFit.cxx:802
 AliMUONClusterFinderPeakFit.cxx:803
 AliMUONClusterFinderPeakFit.cxx:804
 AliMUONClusterFinderPeakFit.cxx:805
 AliMUONClusterFinderPeakFit.cxx:806
 AliMUONClusterFinderPeakFit.cxx:807
 AliMUONClusterFinderPeakFit.cxx:808
 AliMUONClusterFinderPeakFit.cxx:809
 AliMUONClusterFinderPeakFit.cxx:810
 AliMUONClusterFinderPeakFit.cxx:811
 AliMUONClusterFinderPeakFit.cxx:812
 AliMUONClusterFinderPeakFit.cxx:813
 AliMUONClusterFinderPeakFit.cxx:814
 AliMUONClusterFinderPeakFit.cxx:815
 AliMUONClusterFinderPeakFit.cxx:816
 AliMUONClusterFinderPeakFit.cxx:817
 AliMUONClusterFinderPeakFit.cxx:818
 AliMUONClusterFinderPeakFit.cxx:819
 AliMUONClusterFinderPeakFit.cxx:820
 AliMUONClusterFinderPeakFit.cxx:821
 AliMUONClusterFinderPeakFit.cxx:822
 AliMUONClusterFinderPeakFit.cxx:823
 AliMUONClusterFinderPeakFit.cxx:824
 AliMUONClusterFinderPeakFit.cxx:825
 AliMUONClusterFinderPeakFit.cxx:826
 AliMUONClusterFinderPeakFit.cxx:827
 AliMUONClusterFinderPeakFit.cxx:828
 AliMUONClusterFinderPeakFit.cxx:829
 AliMUONClusterFinderPeakFit.cxx:830
 AliMUONClusterFinderPeakFit.cxx:831
 AliMUONClusterFinderPeakFit.cxx:832
 AliMUONClusterFinderPeakFit.cxx:833
 AliMUONClusterFinderPeakFit.cxx:834
 AliMUONClusterFinderPeakFit.cxx:835
 AliMUONClusterFinderPeakFit.cxx:836
 AliMUONClusterFinderPeakFit.cxx:837
 AliMUONClusterFinderPeakFit.cxx:838
 AliMUONClusterFinderPeakFit.cxx:839
 AliMUONClusterFinderPeakFit.cxx:840
 AliMUONClusterFinderPeakFit.cxx:841
 AliMUONClusterFinderPeakFit.cxx:842
 AliMUONClusterFinderPeakFit.cxx:843
 AliMUONClusterFinderPeakFit.cxx:844
 AliMUONClusterFinderPeakFit.cxx:845
 AliMUONClusterFinderPeakFit.cxx:846
 AliMUONClusterFinderPeakFit.cxx:847
 AliMUONClusterFinderPeakFit.cxx:848
 AliMUONClusterFinderPeakFit.cxx:849
 AliMUONClusterFinderPeakFit.cxx:850
 AliMUONClusterFinderPeakFit.cxx:851
 AliMUONClusterFinderPeakFit.cxx:852
 AliMUONClusterFinderPeakFit.cxx:853
 AliMUONClusterFinderPeakFit.cxx:854
 AliMUONClusterFinderPeakFit.cxx:855
 AliMUONClusterFinderPeakFit.cxx:856
 AliMUONClusterFinderPeakFit.cxx:857
 AliMUONClusterFinderPeakFit.cxx:858
 AliMUONClusterFinderPeakFit.cxx:859
 AliMUONClusterFinderPeakFit.cxx:860
 AliMUONClusterFinderPeakFit.cxx:861
 AliMUONClusterFinderPeakFit.cxx:862
 AliMUONClusterFinderPeakFit.cxx:863
 AliMUONClusterFinderPeakFit.cxx:864
 AliMUONClusterFinderPeakFit.cxx:865
 AliMUONClusterFinderPeakFit.cxx:866
 AliMUONClusterFinderPeakFit.cxx:867
 AliMUONClusterFinderPeakFit.cxx:868
 AliMUONClusterFinderPeakFit.cxx:869
 AliMUONClusterFinderPeakFit.cxx:870
 AliMUONClusterFinderPeakFit.cxx:871
 AliMUONClusterFinderPeakFit.cxx:872
 AliMUONClusterFinderPeakFit.cxx:873
 AliMUONClusterFinderPeakFit.cxx:874
 AliMUONClusterFinderPeakFit.cxx:875
 AliMUONClusterFinderPeakFit.cxx:876
 AliMUONClusterFinderPeakFit.cxx:877
 AliMUONClusterFinderPeakFit.cxx:878
 AliMUONClusterFinderPeakFit.cxx:879
 AliMUONClusterFinderPeakFit.cxx:880
 AliMUONClusterFinderPeakFit.cxx:881
 AliMUONClusterFinderPeakFit.cxx:882
 AliMUONClusterFinderPeakFit.cxx:883
 AliMUONClusterFinderPeakFit.cxx:884
 AliMUONClusterFinderPeakFit.cxx:885
 AliMUONClusterFinderPeakFit.cxx:886
 AliMUONClusterFinderPeakFit.cxx:887
 AliMUONClusterFinderPeakFit.cxx:888
 AliMUONClusterFinderPeakFit.cxx:889
 AliMUONClusterFinderPeakFit.cxx:890
 AliMUONClusterFinderPeakFit.cxx:891
 AliMUONClusterFinderPeakFit.cxx:892
 AliMUONClusterFinderPeakFit.cxx:893
 AliMUONClusterFinderPeakFit.cxx:894
 AliMUONClusterFinderPeakFit.cxx:895
 AliMUONClusterFinderPeakFit.cxx:896
 AliMUONClusterFinderPeakFit.cxx:897
 AliMUONClusterFinderPeakFit.cxx:898
 AliMUONClusterFinderPeakFit.cxx:899
 AliMUONClusterFinderPeakFit.cxx:900
 AliMUONClusterFinderPeakFit.cxx:901
 AliMUONClusterFinderPeakFit.cxx:902
 AliMUONClusterFinderPeakFit.cxx:903
 AliMUONClusterFinderPeakFit.cxx:904
 AliMUONClusterFinderPeakFit.cxx:905
 AliMUONClusterFinderPeakFit.cxx:906
 AliMUONClusterFinderPeakFit.cxx:907
 AliMUONClusterFinderPeakFit.cxx:908
 AliMUONClusterFinderPeakFit.cxx:909
 AliMUONClusterFinderPeakFit.cxx:910
 AliMUONClusterFinderPeakFit.cxx:911
 AliMUONClusterFinderPeakFit.cxx:912
 AliMUONClusterFinderPeakFit.cxx:913
 AliMUONClusterFinderPeakFit.cxx:914
 AliMUONClusterFinderPeakFit.cxx:915
 AliMUONClusterFinderPeakFit.cxx:916
 AliMUONClusterFinderPeakFit.cxx:917
 AliMUONClusterFinderPeakFit.cxx:918
 AliMUONClusterFinderPeakFit.cxx:919
 AliMUONClusterFinderPeakFit.cxx:920
 AliMUONClusterFinderPeakFit.cxx:921
 AliMUONClusterFinderPeakFit.cxx:922
 AliMUONClusterFinderPeakFit.cxx:923
 AliMUONClusterFinderPeakFit.cxx:924
 AliMUONClusterFinderPeakFit.cxx:925
 AliMUONClusterFinderPeakFit.cxx:926
 AliMUONClusterFinderPeakFit.cxx:927
 AliMUONClusterFinderPeakFit.cxx:928
 AliMUONClusterFinderPeakFit.cxx:929
 AliMUONClusterFinderPeakFit.cxx:930
 AliMUONClusterFinderPeakFit.cxx:931
 AliMUONClusterFinderPeakFit.cxx:932
 AliMUONClusterFinderPeakFit.cxx:933
 AliMUONClusterFinderPeakFit.cxx:934
 AliMUONClusterFinderPeakFit.cxx:935
 AliMUONClusterFinderPeakFit.cxx:936
 AliMUONClusterFinderPeakFit.cxx:937
 AliMUONClusterFinderPeakFit.cxx:938
 AliMUONClusterFinderPeakFit.cxx:939
 AliMUONClusterFinderPeakFit.cxx:940
 AliMUONClusterFinderPeakFit.cxx:941
 AliMUONClusterFinderPeakFit.cxx:942
 AliMUONClusterFinderPeakFit.cxx:943
 AliMUONClusterFinderPeakFit.cxx:944
 AliMUONClusterFinderPeakFit.cxx:945
 AliMUONClusterFinderPeakFit.cxx:946
 AliMUONClusterFinderPeakFit.cxx:947
 AliMUONClusterFinderPeakFit.cxx:948
 AliMUONClusterFinderPeakFit.cxx:949
 AliMUONClusterFinderPeakFit.cxx:950
 AliMUONClusterFinderPeakFit.cxx:951
 AliMUONClusterFinderPeakFit.cxx:952
 AliMUONClusterFinderPeakFit.cxx:953
 AliMUONClusterFinderPeakFit.cxx:954
 AliMUONClusterFinderPeakFit.cxx:955
 AliMUONClusterFinderPeakFit.cxx:956
 AliMUONClusterFinderPeakFit.cxx:957
 AliMUONClusterFinderPeakFit.cxx:958
 AliMUONClusterFinderPeakFit.cxx:959
 AliMUONClusterFinderPeakFit.cxx:960
 AliMUONClusterFinderPeakFit.cxx:961
 AliMUONClusterFinderPeakFit.cxx:962
 AliMUONClusterFinderPeakFit.cxx:963
 AliMUONClusterFinderPeakFit.cxx:964
 AliMUONClusterFinderPeakFit.cxx:965
 AliMUONClusterFinderPeakFit.cxx:966
 AliMUONClusterFinderPeakFit.cxx:967
 AliMUONClusterFinderPeakFit.cxx:968
 AliMUONClusterFinderPeakFit.cxx:969
 AliMUONClusterFinderPeakFit.cxx:970
 AliMUONClusterFinderPeakFit.cxx:971
 AliMUONClusterFinderPeakFit.cxx:972
 AliMUONClusterFinderPeakFit.cxx:973
 AliMUONClusterFinderPeakFit.cxx:974
 AliMUONClusterFinderPeakFit.cxx:975
 AliMUONClusterFinderPeakFit.cxx:976
 AliMUONClusterFinderPeakFit.cxx:977
 AliMUONClusterFinderPeakFit.cxx:978
 AliMUONClusterFinderPeakFit.cxx:979
 AliMUONClusterFinderPeakFit.cxx:980
 AliMUONClusterFinderPeakFit.cxx:981
 AliMUONClusterFinderPeakFit.cxx:982
 AliMUONClusterFinderPeakFit.cxx:983
 AliMUONClusterFinderPeakFit.cxx:984
 AliMUONClusterFinderPeakFit.cxx:985
 AliMUONClusterFinderPeakFit.cxx:986
 AliMUONClusterFinderPeakFit.cxx:987
 AliMUONClusterFinderPeakFit.cxx:988
 AliMUONClusterFinderPeakFit.cxx:989
 AliMUONClusterFinderPeakFit.cxx:990
 AliMUONClusterFinderPeakFit.cxx:991
 AliMUONClusterFinderPeakFit.cxx:992
 AliMUONClusterFinderPeakFit.cxx:993
 AliMUONClusterFinderPeakFit.cxx:994
 AliMUONClusterFinderPeakFit.cxx:995
 AliMUONClusterFinderPeakFit.cxx:996
 AliMUONClusterFinderPeakFit.cxx:997
 AliMUONClusterFinderPeakFit.cxx:998
 AliMUONClusterFinderPeakFit.cxx:999
 AliMUONClusterFinderPeakFit.cxx:1000
 AliMUONClusterFinderPeakFit.cxx:1001
 AliMUONClusterFinderPeakFit.cxx:1002
 AliMUONClusterFinderPeakFit.cxx:1003
 AliMUONClusterFinderPeakFit.cxx:1004
 AliMUONClusterFinderPeakFit.cxx:1005
 AliMUONClusterFinderPeakFit.cxx:1006
 AliMUONClusterFinderPeakFit.cxx:1007
 AliMUONClusterFinderPeakFit.cxx:1008
 AliMUONClusterFinderPeakFit.cxx:1009
 AliMUONClusterFinderPeakFit.cxx:1010
 AliMUONClusterFinderPeakFit.cxx:1011
 AliMUONClusterFinderPeakFit.cxx:1012
 AliMUONClusterFinderPeakFit.cxx:1013
 AliMUONClusterFinderPeakFit.cxx:1014
 AliMUONClusterFinderPeakFit.cxx:1015
 AliMUONClusterFinderPeakFit.cxx:1016
 AliMUONClusterFinderPeakFit.cxx:1017
 AliMUONClusterFinderPeakFit.cxx:1018
 AliMUONClusterFinderPeakFit.cxx:1019
 AliMUONClusterFinderPeakFit.cxx:1020
 AliMUONClusterFinderPeakFit.cxx:1021
 AliMUONClusterFinderPeakFit.cxx:1022
 AliMUONClusterFinderPeakFit.cxx:1023
 AliMUONClusterFinderPeakFit.cxx:1024
 AliMUONClusterFinderPeakFit.cxx:1025
 AliMUONClusterFinderPeakFit.cxx:1026
 AliMUONClusterFinderPeakFit.cxx:1027
 AliMUONClusterFinderPeakFit.cxx:1028
 AliMUONClusterFinderPeakFit.cxx:1029
 AliMUONClusterFinderPeakFit.cxx:1030
 AliMUONClusterFinderPeakFit.cxx:1031
 AliMUONClusterFinderPeakFit.cxx:1032
 AliMUONClusterFinderPeakFit.cxx:1033
 AliMUONClusterFinderPeakFit.cxx:1034
 AliMUONClusterFinderPeakFit.cxx:1035
 AliMUONClusterFinderPeakFit.cxx:1036
 AliMUONClusterFinderPeakFit.cxx:1037
 AliMUONClusterFinderPeakFit.cxx:1038
 AliMUONClusterFinderPeakFit.cxx:1039
 AliMUONClusterFinderPeakFit.cxx:1040
 AliMUONClusterFinderPeakFit.cxx:1041
 AliMUONClusterFinderPeakFit.cxx:1042
 AliMUONClusterFinderPeakFit.cxx:1043
 AliMUONClusterFinderPeakFit.cxx:1044
 AliMUONClusterFinderPeakFit.cxx:1045
 AliMUONClusterFinderPeakFit.cxx:1046
 AliMUONClusterFinderPeakFit.cxx:1047
 AliMUONClusterFinderPeakFit.cxx:1048
 AliMUONClusterFinderPeakFit.cxx:1049
 AliMUONClusterFinderPeakFit.cxx:1050
 AliMUONClusterFinderPeakFit.cxx:1051
 AliMUONClusterFinderPeakFit.cxx:1052
 AliMUONClusterFinderPeakFit.cxx:1053
 AliMUONClusterFinderPeakFit.cxx:1054
 AliMUONClusterFinderPeakFit.cxx:1055
 AliMUONClusterFinderPeakFit.cxx:1056
 AliMUONClusterFinderPeakFit.cxx:1057
 AliMUONClusterFinderPeakFit.cxx:1058
 AliMUONClusterFinderPeakFit.cxx:1059
 AliMUONClusterFinderPeakFit.cxx:1060
 AliMUONClusterFinderPeakFit.cxx:1061
 AliMUONClusterFinderPeakFit.cxx:1062
 AliMUONClusterFinderPeakFit.cxx:1063
 AliMUONClusterFinderPeakFit.cxx:1064
 AliMUONClusterFinderPeakFit.cxx:1065
 AliMUONClusterFinderPeakFit.cxx:1066
 AliMUONClusterFinderPeakFit.cxx:1067
 AliMUONClusterFinderPeakFit.cxx:1068
 AliMUONClusterFinderPeakFit.cxx:1069
 AliMUONClusterFinderPeakFit.cxx:1070
 AliMUONClusterFinderPeakFit.cxx:1071
 AliMUONClusterFinderPeakFit.cxx:1072
 AliMUONClusterFinderPeakFit.cxx:1073
 AliMUONClusterFinderPeakFit.cxx:1074
 AliMUONClusterFinderPeakFit.cxx:1075
 AliMUONClusterFinderPeakFit.cxx:1076
 AliMUONClusterFinderPeakFit.cxx:1077
 AliMUONClusterFinderPeakFit.cxx:1078
 AliMUONClusterFinderPeakFit.cxx:1079
 AliMUONClusterFinderPeakFit.cxx:1080
 AliMUONClusterFinderPeakFit.cxx:1081
 AliMUONClusterFinderPeakFit.cxx:1082
 AliMUONClusterFinderPeakFit.cxx:1083
 AliMUONClusterFinderPeakFit.cxx:1084
 AliMUONClusterFinderPeakFit.cxx:1085
 AliMUONClusterFinderPeakFit.cxx:1086
 AliMUONClusterFinderPeakFit.cxx:1087
 AliMUONClusterFinderPeakFit.cxx:1088
 AliMUONClusterFinderPeakFit.cxx:1089
 AliMUONClusterFinderPeakFit.cxx:1090
 AliMUONClusterFinderPeakFit.cxx:1091
 AliMUONClusterFinderPeakFit.cxx:1092
 AliMUONClusterFinderPeakFit.cxx:1093
 AliMUONClusterFinderPeakFit.cxx:1094
 AliMUONClusterFinderPeakFit.cxx:1095
 AliMUONClusterFinderPeakFit.cxx:1096
 AliMUONClusterFinderPeakFit.cxx:1097
 AliMUONClusterFinderPeakFit.cxx:1098
 AliMUONClusterFinderPeakFit.cxx:1099
 AliMUONClusterFinderPeakFit.cxx:1100
 AliMUONClusterFinderPeakFit.cxx:1101
 AliMUONClusterFinderPeakFit.cxx:1102
 AliMUONClusterFinderPeakFit.cxx:1103
 AliMUONClusterFinderPeakFit.cxx:1104
 AliMUONClusterFinderPeakFit.cxx:1105
 AliMUONClusterFinderPeakFit.cxx:1106
 AliMUONClusterFinderPeakFit.cxx:1107
 AliMUONClusterFinderPeakFit.cxx:1108
 AliMUONClusterFinderPeakFit.cxx:1109
 AliMUONClusterFinderPeakFit.cxx:1110
 AliMUONClusterFinderPeakFit.cxx:1111
 AliMUONClusterFinderPeakFit.cxx:1112
 AliMUONClusterFinderPeakFit.cxx:1113
 AliMUONClusterFinderPeakFit.cxx:1114
 AliMUONClusterFinderPeakFit.cxx:1115
 AliMUONClusterFinderPeakFit.cxx:1116
 AliMUONClusterFinderPeakFit.cxx:1117
 AliMUONClusterFinderPeakFit.cxx:1118
 AliMUONClusterFinderPeakFit.cxx:1119
 AliMUONClusterFinderPeakFit.cxx:1120
 AliMUONClusterFinderPeakFit.cxx:1121
 AliMUONClusterFinderPeakFit.cxx:1122
 AliMUONClusterFinderPeakFit.cxx:1123
 AliMUONClusterFinderPeakFit.cxx:1124
 AliMUONClusterFinderPeakFit.cxx:1125
 AliMUONClusterFinderPeakFit.cxx:1126
 AliMUONClusterFinderPeakFit.cxx:1127
 AliMUONClusterFinderPeakFit.cxx:1128
 AliMUONClusterFinderPeakFit.cxx:1129
 AliMUONClusterFinderPeakFit.cxx:1130
 AliMUONClusterFinderPeakFit.cxx:1131
 AliMUONClusterFinderPeakFit.cxx:1132
 AliMUONClusterFinderPeakFit.cxx:1133
 AliMUONClusterFinderPeakFit.cxx:1134
 AliMUONClusterFinderPeakFit.cxx:1135
 AliMUONClusterFinderPeakFit.cxx:1136
 AliMUONClusterFinderPeakFit.cxx:1137
 AliMUONClusterFinderPeakFit.cxx:1138
 AliMUONClusterFinderPeakFit.cxx:1139
 AliMUONClusterFinderPeakFit.cxx:1140
 AliMUONClusterFinderPeakFit.cxx:1141
 AliMUONClusterFinderPeakFit.cxx:1142
 AliMUONClusterFinderPeakFit.cxx:1143
 AliMUONClusterFinderPeakFit.cxx:1144
 AliMUONClusterFinderPeakFit.cxx:1145
 AliMUONClusterFinderPeakFit.cxx:1146
 AliMUONClusterFinderPeakFit.cxx:1147
 AliMUONClusterFinderPeakFit.cxx:1148
 AliMUONClusterFinderPeakFit.cxx:1149
 AliMUONClusterFinderPeakFit.cxx:1150
 AliMUONClusterFinderPeakFit.cxx:1151
 AliMUONClusterFinderPeakFit.cxx:1152
 AliMUONClusterFinderPeakFit.cxx:1153
 AliMUONClusterFinderPeakFit.cxx:1154
 AliMUONClusterFinderPeakFit.cxx:1155
 AliMUONClusterFinderPeakFit.cxx:1156
 AliMUONClusterFinderPeakFit.cxx:1157
 AliMUONClusterFinderPeakFit.cxx:1158
 AliMUONClusterFinderPeakFit.cxx:1159
 AliMUONClusterFinderPeakFit.cxx:1160
 AliMUONClusterFinderPeakFit.cxx:1161
 AliMUONClusterFinderPeakFit.cxx:1162
 AliMUONClusterFinderPeakFit.cxx:1163
 AliMUONClusterFinderPeakFit.cxx:1164
 AliMUONClusterFinderPeakFit.cxx:1165
 AliMUONClusterFinderPeakFit.cxx:1166
 AliMUONClusterFinderPeakFit.cxx:1167
 AliMUONClusterFinderPeakFit.cxx:1168
 AliMUONClusterFinderPeakFit.cxx:1169
 AliMUONClusterFinderPeakFit.cxx:1170
 AliMUONClusterFinderPeakFit.cxx:1171
 AliMUONClusterFinderPeakFit.cxx:1172
 AliMUONClusterFinderPeakFit.cxx:1173
 AliMUONClusterFinderPeakFit.cxx:1174
 AliMUONClusterFinderPeakFit.cxx:1175
 AliMUONClusterFinderPeakFit.cxx:1176
 AliMUONClusterFinderPeakFit.cxx:1177
 AliMUONClusterFinderPeakFit.cxx:1178
 AliMUONClusterFinderPeakFit.cxx:1179
 AliMUONClusterFinderPeakFit.cxx:1180
 AliMUONClusterFinderPeakFit.cxx:1181
 AliMUONClusterFinderPeakFit.cxx:1182
 AliMUONClusterFinderPeakFit.cxx:1183
 AliMUONClusterFinderPeakFit.cxx:1184
 AliMUONClusterFinderPeakFit.cxx:1185
 AliMUONClusterFinderPeakFit.cxx:1186
 AliMUONClusterFinderPeakFit.cxx:1187
 AliMUONClusterFinderPeakFit.cxx:1188
 AliMUONClusterFinderPeakFit.cxx:1189
 AliMUONClusterFinderPeakFit.cxx:1190
 AliMUONClusterFinderPeakFit.cxx:1191
 AliMUONClusterFinderPeakFit.cxx:1192
 AliMUONClusterFinderPeakFit.cxx:1193
 AliMUONClusterFinderPeakFit.cxx:1194
 AliMUONClusterFinderPeakFit.cxx:1195