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$

#include <Riostream.h>
#include <TMath.h>
#include <TObjArray.h>
#include <TVirtualPad.h>
#include <TVirtualX.h>

#include "AliMUONCluster.h"
#include "AliMUONPad.h"

#include "AliMpEncodePair.h"

#include "AliLog.h"

//-----------------------------------------------------------------------------
/// \class AliMUONCluster
///
/// A group of adjacent pads
///
/// Besides holding an internal array of AliMUONPads, this object
/// also computes some global characteristics for that pad sets.
///
/// \author Laurent Aphecetche
///
//-----------------------------------------------------------------------------

using std::cout;
using std::endl;
/// \cond CLASSIMP
ClassImp(AliMUONCluster)
/// \endcond

namespace
{
  //___________________________________________________________________________
  Bool_t
  ShouldUsePad(const AliMUONPad& pad, 
               Int_t cathode, Int_t statusMask, Bool_t matchMask)
  {

      // FIXME : we should only use >=0 status, so we can fully
      // use masking possibility ?
    if ( pad.Status() < 0 ) return kFALSE;
    
    if ( pad.Cathode() == cathode && pad.IsReal() && !pad.IsSaturated() )
    {
      Bool_t test = ( ( pad.Status() & statusMask ) != 0 );
      if ( !statusMask ) 
      {
        test = ( pad.Status() == 0 );
      }
      if ( ( test && matchMask ) || ( !test && !matchMask ) )
      {
        return kTRUE;
      }
    }
    return kFALSE;
  }

  //___________________________________________________________________________
  Int_t Unique(Int_t n, Double_t* array, Double_t precision)
  {
    /// Return the number of *different* elements in array 
    /// where different is up to precision
    /// Note that we assume that n is >= 1
    
    Int_t count(1);
    
    Int_t* index = new Int_t[n];
    
    TMath::Sort(n,array,index);
        
    for ( Int_t i = 1; i < n; ++i )
    {
      if ( array[index[i]] - array[index[i-1]] < -precision ) ++count;
    }
    
    delete[] index;
        
    return count;
  }
}

//_____________________________________________________________________________
AliMUONCluster::AliMUONCluster() 
: TObject(), 
fPads(),
fHasPosition(kFALSE),
fPosition(1E9,1E9),
fPositionError(1E9,1E9),
fHasCharge(kFALSE),
fChi2(0)
{
  /// ctor
  fMultiplicity[0]=fMultiplicity[1]=0;
  fRawCharge[0]=fRawCharge[1]=0;
  fCharge[0]=fCharge[1]=0;
  fIsSaturated[0]=fIsSaturated[1]=kFALSE;
  fPads.SetOwner(kTRUE);
}

//_____________________________________________________________________________
AliMUONCluster::AliMUONCluster(const AliMUONCluster& src)
: TObject(src),
fPads(),
fHasPosition(kFALSE),
fPosition(1E9,1E9),
fPositionError(1E9,1E9),
fHasCharge(kFALSE),
fChi2(0)
{
  /// copy ctor
  fPads.SetOwner(kTRUE);
  src.Copy(*this);
}

//_____________________________________________________________________________
AliMUONCluster&
AliMUONCluster::operator=(const AliMUONCluster& src)
{
  /// assignement operator
  if ( this != &src ) 
  {
    src.Copy(*this);
  }
  return *this;
}

//_____________________________________________________________________________
AliMUONCluster::~AliMUONCluster()
{
  /// dtor : note that we're owner of our pads
//   fPads.Delete();
}

//_____________________________________________________________________________
void
AliMUONCluster::Clear(Option_t*)
{
  /// Clear our pad array
  fPads.Clear();
//  fPads.Delete();
}

//_____________________________________________________________________________
Bool_t
AliMUONCluster::Contains(const AliMUONPad& pad) const
{
  /// Whether this cluster contains the pad
  if (fPads.IsEmpty()) return kFALSE;
  
  for ( Int_t i = 0; i < Multiplicity(); ++i ) 
  {
    AliMUONPad* p = Pad(i);
    if ( pad.Compare(p) == 0 ) return kTRUE;
  }
  return kFALSE;
}

//_____________________________________________________________________________
void
AliMUONCluster::AddCluster(const AliMUONCluster& cluster)
{
  /// Add all the pads for cluster to this one
  for ( Int_t i = 0; i < cluster.Multiplicity(); ++i )
  {
    AliMUONPad* p = cluster.Pad(i);
    if ( Contains(*p) ) 
    {
      AliError("I already got this pad : ");
      StdoutToAliError(p->Print(););
      AliFatal("");
    }
    AddPad(*p);
  }
  
}

//_____________________________________________________________________________
AliMUONPad*
AliMUONCluster::AddPad(const AliMUONPad& pad)
{
  /// Add a pad to our pad array, and update some internal information
  /// accordingly.

  AliMUONPad* p = new AliMUONPad(pad);
  fPads.AddLast(p);
  p->SetClusterId(GetUniqueID());
  Int_t cathode = p->Cathode();
  ++(fMultiplicity[cathode]);
  fRawCharge[cathode] += p->Charge();
  if ( p->IsSaturated() )
  {
    fIsSaturated[p->Cathode()]=kTRUE;
  }
  return p;
}

//___________________________________________________________________________
TString
AliMUONCluster::AsString() const
{
  /// Return a string containing a compact form of the pad list
  TString s(Form("NPADS(%d,%d)",Multiplicity(0),Multiplicity(1)));
  
  for (Int_t i = 0; i < Multiplicity(); ++i ) 
  {
    AliMUONPad* p = Pad(i);
    s += Form(" (%d,%d,%d) ",p->Cathode(),p->Ix(),p->Iy());
  }
  return s;
}


//___________________________________________________________________________
Bool_t
AliMUONCluster::AreOverlapping(const AliMUONCluster& c1, const AliMUONCluster& c2)
{
  /// Whether the two clusters overlap
  
  static Double_t precision = 1E-4; // cm
  static TVector2 precisionAdjustment(precision,precision);
    
  for ( Int_t i1 = 0; i1 < c1.Multiplicity(); ++i1 )
  {
    AliMUONPad* p1 = c1.Pad(i1);
    
    for ( Int_t i2 = 0; i2 < c2.Multiplicity(); ++i2 )
    {
      AliMUONPad* p2 = c2.Pad(i2);
      // Note: we use negative precision numbers, meaning
      // the area of the pads will be *increased* by these small numbers
      // prior to check the overlap by the AreOverlapping method,
      // so pads touching only by the corners will be considered as
      // overlapping.    
      if ( AliMUONPad::AreOverlapping(*p1,*p2,precisionAdjustment) )
      {
        return kTRUE;
      }
    }
  }
  return kFALSE;
}

//_____________________________________________________________________________
AliMpArea
AliMUONCluster::Area() const
{
  /// Return the geometrical area covered by this cluster
  
  // Start by finding the (x,y) limits of this cluster
  TVector2 lowerLeft(1E9,1E9);
  TVector2 upperRight(-1E9,-1E9);
  
  for ( Int_t i = 0; i < Multiplicity(); ++i )
  {
    AliMUONPad* pad = Pad(i);
    TVector2 ll = pad->Position() - pad->Dimensions();
    TVector2 ur = pad->Position() + pad->Dimensions();
    lowerLeft.Set( TMath::Min(ll.X(),lowerLeft.X()),
                   TMath::Min(ll.Y(),lowerLeft.Y()) );
    upperRight.Set( TMath::Max(ur.X(),upperRight.X()),
                    TMath::Max(ur.Y(),upperRight.Y()) );
  }

  // then construct the area from those limits
  return AliMpArea((lowerLeft+upperRight).X()/2,(lowerLeft+upperRight).Y()/2, 
                   (upperRight-lowerLeft).X()/2, (upperRight-lowerLeft).Y()/2);
}

//_____________________________________________________________________________
AliMpArea
AliMUONCluster::Area(Int_t cathode) const
{
  /// Return the geometrical area covered by this cluster's pads on 
  /// a given cathode
  
  // Start by finding the (x,y) limits of this cluster
  TVector2 lowerLeft(1E9,1E9);
  TVector2 upperRight(-1E9,-1E9);
  
  for ( Int_t i = 0; i < Multiplicity(); ++i )
  {
    AliMUONPad* pad = Pad(i);
    if ( pad->Cathode() == cathode ) 
    {
      TVector2 ll = pad->Position() - pad->Dimensions();
      TVector2 ur = pad->Position() + pad->Dimensions();
      lowerLeft.Set( TMath::Min(ll.X(),lowerLeft.X()),
                     TMath::Min(ll.Y(),lowerLeft.Y()) );
      upperRight.Set( TMath::Max(ur.X(),upperRight.X()),
                      TMath::Max(ur.Y(),upperRight.Y()) );
    }
  }
  
  // then construct the area from those limits
  return AliMpArea((lowerLeft+upperRight).X()/2,(lowerLeft+upperRight).Y()/2,
                   (upperRight-lowerLeft).X()/2, (upperRight-lowerLeft).Y()/2);
}

//_____________________________________________________________________________
Bool_t
AliMUONCluster::IsMonoCathode() const
{
  /// Whether we have signals only in one of the two cathodes
  return (Cathode()<2);
}

//_____________________________________________________________________________
Int_t
AliMUONCluster::Cathode() const
{
  /// Return the cathode "number" of this cluster : 
  /// 0 if all its pads are on cathode 0
  /// 1 if all its pads are on cathode 1
  /// 2 if some pads on cath 0 and some on cath 1
  
  Int_t cathode(-1);
  if (Multiplicity(0)>0 && Multiplicity(1)>0) 
  {
    cathode=2;
  }
  else if (Multiplicity(0)>0) 
  {
    cathode=0;
  }
  else if (Multiplicity(1)>0) 
  {
    cathode=1;
  }
  
  return cathode;
}

//_____________________________________________________________________________
void
AliMUONCluster::Copy(TObject& obj) const
{
  ///
  /// Copy this cluster to (cluster&)obj
  ///
  TObject::Copy(obj);
  AliMUONCluster& dest = static_cast<AliMUONCluster&>(obj);

//  dest.fPads.Delete();
  dest.fPads.Clear();
  
  for ( Int_t i = 0; i <= fPads.GetLast(); ++i ) 
  {
    AliMUONPad* p = static_cast<AliMUONPad*>(fPads.UncheckedAt(i));
    dest.fPads.AddLast(new AliMUONPad(*p));
  }
  dest.fHasPosition = fHasPosition;
  dest.fPosition = fPosition;
  dest.fPositionError = fPositionError;
  dest.fHasCharge = fHasCharge;
  dest.fChi2 = fChi2;
  for ( Int_t i = 0; i < 2; ++i )
  {
    dest.fRawCharge[i] = fRawCharge[i];
    dest.fCharge[i] = fCharge[i];
    dest.fMultiplicity[i] = fMultiplicity[i];
    dest.fIsSaturated[i] = fIsSaturated[i];
  }
}

//_____________________________________________________________________________
Float_t 
AliMUONCluster::Charge() const
{
  /// Return the average charge over both cathodes
  
  if ( Multiplicity(0) && Multiplicity(1) )
  {
    return (Charge(0)+Charge(1))/2.0;
  }
  else if ( Multiplicity(0) ) 
  {
    return Charge(0);
  }
  else if ( Multiplicity(1) ) 
  {
    return Charge(1);
  }
  AliError("Should not be here ?!");
  return -1.0;
}

//_____________________________________________________________________________
Float_t
AliMUONCluster::Charge(Int_t cathode) const
{
  /// Returns the charge of a given cathode
  if ( !fHasCharge ) return RawCharge(cathode);
  
  if ( cathode == 0 || cathode == 1 )
  {
    return fCharge[cathode];
  }
  return 0;
}

//_____________________________________________________________________________
Float_t
AliMUONCluster::ChargeAsymmetry() const
{
  /// Returns the charge asymmetry
  if ( Charge() > 0 )
  {
    return TMath::Abs(Charge(0)-Charge(1))/Charge();
  }
  return 0;
}

//_____________________________________________________________________________
TVector2
AliMUONCluster::MaxPadDimensions(Int_t statusMask, Bool_t matchMask) const
{
  /// Returns the maximum pad dimensions (half sizes), only considering
  /// pads matching (or not, depending matchMask) a given mask
  
  TVector2 cath0(MaxPadDimensions(0,statusMask,matchMask)); 
  TVector2 cath1(MaxPadDimensions(1,statusMask,matchMask)); 
  
  return TVector2( TMath::Max(cath0.X(),cath1.X()),
                   TMath::Max(cath0.Y(),cath1.Y()) );
}

//_____________________________________________________________________________
TVector2
AliMUONCluster::MaxPadDimensions(Int_t cathode, 
                                 Int_t statusMask, Bool_t matchMask) const
{
  /// Returns the maximum pad dimensions (half sizes), only considering
  /// pads matching (or not, depending matchMask) a given mask, within a
  /// given cathode
  
  Double_t xmax(0);
  Double_t ymax(0);
  
  for ( Int_t i = 0; i < Multiplicity(); ++i )
  {
    AliMUONPad* pad = Pad(i);
    if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
    {
      xmax = TMath::Max(xmax,pad->DX());
      ymax = TMath::Max(ymax,pad->DY());
    }
  }
  return TVector2(xmax,ymax);
}

//_____________________________________________________________________________
TVector2
AliMUONCluster::MinPadDimensions(Int_t statusMask, Bool_t matchMask) const
{
  /// Returns the minimum pad dimensions (half sizes), only considering
  /// pads matching (or not, depending matchMask) a given mask
  
  TVector2 cath0(MinPadDimensions(0,statusMask,matchMask)); 
  TVector2 cath1(MinPadDimensions(1,statusMask,matchMask)); 
  
  return TVector2( TMath::Min(cath0.X(),cath1.X()),
                   TMath::Min(cath0.Y(),cath1.Y()) );
}

//_____________________________________________________________________________
TVector2
AliMUONCluster::MinPadDimensions(Int_t cathode, 
                                 Int_t statusMask, Bool_t matchMask) const
{
  /// Returns the minimum pad dimensions (half sizes), only considering
  /// pads matching (or not, depending matchMask) a given mask, within a
  /// given cathode
  
  Double_t xmin(1E9);
  Double_t ymin(1E9);
    
  for ( Int_t i = 0; i < Multiplicity(); ++i )
  {
    AliMUONPad* pad = Pad(i);
    if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
    {
      xmin = TMath::Min(xmin,pad->DX());
      ymin = TMath::Min(ymin,pad->DY());
    }
  }
  return TVector2(xmin,ymin);
}

//_____________________________________________________________________________
Int_t 
AliMUONCluster::Multiplicity() const
{
  /// Returns the total number of pads in this cluster
  return Multiplicity(0)+Multiplicity(1);
}

//_____________________________________________________________________________
Int_t
AliMUONCluster::Multiplicity(Int_t cathode) const
{
  /// Returns the number of pads in this cluster, in the given cathode
  if ( cathode == 0 || cathode == 1 )
  {
    return fMultiplicity[cathode];
  }
  return 0;
}

//_____________________________________________________________________________
Long_t
AliMUONCluster::NofPads(Int_t statusMask, Bool_t matchMask) const
{
  /// Number of pads satisfying (or not, depending matchMask) a
  /// given mask 
  
  Int_t nx, ny;
  
  TVector2 dim0(MinPadDimensions(0,statusMask,matchMask));
  TVector2 dim1(MinPadDimensions(1,statusMask,matchMask));
  
  Long_t npad0(NofPads(0,statusMask,matchMask));
  Long_t npad1(NofPads(1,statusMask,matchMask));
  
  if ( TMath::Abs( (dim0-dim1).X() ) < 1E-3 )
  {
    nx = TMath::Max( AliMp::PairFirst(npad0), AliMp::PairFirst(npad1) );
  }
  else
  {
    nx = dim0.X() < dim1.X() ? AliMp::PairFirst(npad0) : AliMp::PairFirst(npad1);
  }
  
  if ( TMath::Abs( (dim0-dim1).Y() ) < 1E-3 )
  {
    ny = TMath::Max( AliMp::PairSecond(npad0), AliMp::PairSecond(npad1) );
  }
  else
  {
    ny = dim0.Y() < dim1.Y() ? AliMp::PairSecond(npad0) : AliMp::PairSecond(npad1);
  }
  
  return AliMp::Pair(nx,ny);
}

//_____________________________________________________________________________
Long_t
AliMUONCluster::NofPads(Int_t cathode,
                        Int_t statusMask, Bool_t matchMask) const
{
  /// Number of pads of a given cathode, satisfying (or not, 
  /// depending matchMask) a given mask

  Int_t n = Multiplicity(cathode);
  if (!n) 
  {
    return 0;
  }
  Double_t* x = new Double_t[n];
  Double_t* y = new Double_t[n];
  Int_t np(0);
  
  for ( Int_t i = 0; i < Multiplicity(); ++i )
  {
    AliMUONPad* pad = Pad(i);
    if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
    {
      x[np] = pad->X();
      y[np] = pad->Y();
      ++np;
    }
  }
  
  Int_t cx = Unique(np,x,0.01);
  Int_t cy = Unique(np,y,0.01);
  
  delete[] x;
  delete[] y;
  
  return AliMp::Pair(cx,cy);
}

//_____________________________________________________________________________
AliMUONPad*
AliMUONCluster::Pad(Int_t index) const
{
  /// Returns the index-th pad
  
  if (fPads.IsEmpty()) return 0x0;
  if ( index < fPads.GetLast()+1 )
  {
    return static_cast<AliMUONPad*>(fPads.At(index));
  }
  else
  {
    AliError(Form("Requested index %d out of bounds (%d) Mult is %d",index,
                  fPads.GetLast(),Multiplicity()));
    DumpMe();
  }
  return 0x0;
}


//_____________________________________________________________________________
void
AliMUONCluster::Paint(Option_t*)
{
  /// Paint this cluster   
  if (!Multiplicity()) return;
  
  AliMpArea area(Area());
  
  gPad->Range(area.LeftBorder(),area.DownBorder(),area.RightBorder(),area.UpBorder());
      
  gVirtualX->SetFillStyle(0);
  
  gVirtualX->SetLineColor(2);
  gVirtualX->SetLineWidth(4);  
  for ( Int_t i = 0; i < Multiplicity(); ++i)
  {
    AliMUONPad* pad = Pad(i);
    if ( pad->Cathode() == 0 ) pad->Paint();
  }

  gVirtualX->SetLineColor(4);
  gVirtualX->SetLineWidth(2);  
  for ( Int_t i = 0; i < Multiplicity(); ++i)
  {
    AliMUONPad* pad = Pad(i);
    if ( pad->Cathode() == 1 ) pad->Paint();
  }
  
}

//_____________________________________________________________________________
void
AliMUONCluster::DumpMe() const
{
  /// printout
  cout << "Cluster Id " << GetUniqueID() << " npads=" << Multiplicity() 
  << "(" << Multiplicity(0) << "," << Multiplicity(1) << ") RawCharge=" 
  << RawCharge() << " (" << RawCharge(0) << "," << RawCharge(1)
  << ") Charge=(" << Charge(0) << "," << Charge(1) <<")";
  if ( HasPosition() )
  {
    cout << " (x,y)=(" << Position().X() << "," << Position().Y() << ")";
    cout << " (errX,errY)=(" << PositionError().X() << "," << PositionError().Y() << ")";
  }
  cout << endl;
//  cout << " " << Area() << endl;
  for (Int_t i = 0; i < fPads.GetSize(); ++i) 
  {
    cout << Form("fPads[%d]=%p",i,fPads.At(i)) << endl;
    if ( fPads.At(i) ) fPads.At(i)->Print();
  }
}


//_____________________________________________________________________________
void
AliMUONCluster::Print(Option_t* opt) const
{
  /// printout
  cout << "Cluster Id " << GetUniqueID() << " npads=" << Multiplicity() 
  << "(" << Multiplicity(0) << "," << Multiplicity(1) << ") RawCharge=" 
  << RawCharge() << " (" << RawCharge(0) << "," << RawCharge(1)
  << ") Charge=(" << Charge(0) << "," << Charge(1) <<")";
  if ( HasPosition() )
  {
    cout << " (x,y)=(" << Position().X() << "," << Position().Y() << ")";
    cout << " (errX,errY)=(" << PositionError().X() << "," << PositionError().Y() << ")";
  }
  cout << " " << Area();

  TObjArray* a = static_cast<TObjArray*>(fPads.Clone());
  a->Sort();
  a->Print("",opt);
  delete a;
}

//_____________________________________________________________________________
//Bool_t
//AliMUONCluster::IsEqual(const TObject* obj) const
//{
//  const AliMUONCluster* c = static_cast<const AliMUONCluster*>(obj);
//  if ( c->Multiplicity() != Multiplicity() ) return kFALSE;
//  
//  for ( Int_t i = 0; i < c->Multiplicity(); ++i ) 
//  {
//    AliMUONPad* p = c->Pad(i);
//    if ( p->Compare(Pad(i)) ) return kFALSE;
//  }
//  return kTRUE;
//}

//_____________________________________________________________________________
Int_t 
AliMUONCluster::Compare(const TObject* obj) const
{
  /// Compare two clusters. Comparison is made on position and rawcharge only.
  
  const AliMUONCluster* cluster = static_cast<const AliMUONCluster*>(obj);
  
  AliMpArea carea(cluster->Area());
  AliMpArea area(Area());

  if ( carea.GetPositionX() > area.GetPositionX() ) 
  {
    return 1;
  }
  else if ( carea.GetPositionX() < area.GetPositionX() ) 
  {
    return -1;
  }
  else 
  {
    if ( carea.GetPositionY() > area.GetPositionY() ) 
    {
      return 1;
    }
    else if ( carea.GetPositionY() < area.GetPositionY() ) 
    {
      return -1;
    }
    else
    {
      if ( cluster->RawCharge() > RawCharge() ) 
      {
        return 1;
      }
      else if ( cluster->RawCharge() < RawCharge() )
      {
        return -1;
      }
    }
  }
  return 0;
}

//_____________________________________________________________________________
void
AliMUONCluster::RemovePad(AliMUONPad* pad)
{
  /// Remove a pad. 
  /// As a consequence, some internal information must be updated
  
  fPads.Remove(pad);
  fPads.Compress();
  delete pad;
  // update cluster's data
  fIsSaturated[0]=fIsSaturated[1]=kFALSE;
  fMultiplicity[0]=fMultiplicity[1]=0;
  fRawCharge[0]=fRawCharge[1]=0;
  for ( Int_t i = 0; i <= fPads.GetLast(); ++i )
  {
    AliMUONPad* p = Pad(i);
    if ( p->IsSaturated() ) 
    {
      fIsSaturated[p->Cathode()] = kTRUE;
    }
    ++fMultiplicity[p->Cathode()];
    fRawCharge[p->Cathode()] += p->Charge();
  }
}

//_____________________________________________________________________________
Float_t 
AliMUONCluster::RawCharge() const
{
  /// Returns the raw average charge
  return (RawCharge(0)+RawCharge(1))/2.0;
}

//_____________________________________________________________________________
Float_t
AliMUONCluster::RawCharge(Int_t cathode) const
{
  /// Returns the average charge of a given cathode
  if ( cathode == 0 || cathode == 1 )
  {
    return fRawCharge[cathode];
  }
  return 0;
}

//_____________________________________________________________________________
Float_t
AliMUONCluster::RawChargeAsymmetry() const
{
  /// Returns the raw charge asymmetry
   if ( RawCharge() > 0 )
   {
     return TMath::Abs(RawCharge(0)-RawCharge(1))/RawCharge();
   }
  return 0;
}
 AliMUONCluster.cxx:1
 AliMUONCluster.cxx:2
 AliMUONCluster.cxx:3
 AliMUONCluster.cxx:4
 AliMUONCluster.cxx:5
 AliMUONCluster.cxx:6
 AliMUONCluster.cxx:7
 AliMUONCluster.cxx:8
 AliMUONCluster.cxx:9
 AliMUONCluster.cxx:10
 AliMUONCluster.cxx:11
 AliMUONCluster.cxx:12
 AliMUONCluster.cxx:13
 AliMUONCluster.cxx:14
 AliMUONCluster.cxx:15
 AliMUONCluster.cxx:16
 AliMUONCluster.cxx:17
 AliMUONCluster.cxx:18
 AliMUONCluster.cxx:19
 AliMUONCluster.cxx:20
 AliMUONCluster.cxx:21
 AliMUONCluster.cxx:22
 AliMUONCluster.cxx:23
 AliMUONCluster.cxx:24
 AliMUONCluster.cxx:25
 AliMUONCluster.cxx:26
 AliMUONCluster.cxx:27
 AliMUONCluster.cxx:28
 AliMUONCluster.cxx:29
 AliMUONCluster.cxx:30
 AliMUONCluster.cxx:31
 AliMUONCluster.cxx:32
 AliMUONCluster.cxx:33
 AliMUONCluster.cxx:34
 AliMUONCluster.cxx:35
 AliMUONCluster.cxx:36
 AliMUONCluster.cxx:37
 AliMUONCluster.cxx:38
 AliMUONCluster.cxx:39
 AliMUONCluster.cxx:40
 AliMUONCluster.cxx:41
 AliMUONCluster.cxx:42
 AliMUONCluster.cxx:43
 AliMUONCluster.cxx:44
 AliMUONCluster.cxx:45
 AliMUONCluster.cxx:46
 AliMUONCluster.cxx:47
 AliMUONCluster.cxx:48
 AliMUONCluster.cxx:49
 AliMUONCluster.cxx:50
 AliMUONCluster.cxx:51
 AliMUONCluster.cxx:52
 AliMUONCluster.cxx:53
 AliMUONCluster.cxx:54
 AliMUONCluster.cxx:55
 AliMUONCluster.cxx:56
 AliMUONCluster.cxx:57
 AliMUONCluster.cxx:58
 AliMUONCluster.cxx:59
 AliMUONCluster.cxx:60
 AliMUONCluster.cxx:61
 AliMUONCluster.cxx:62
 AliMUONCluster.cxx:63
 AliMUONCluster.cxx:64
 AliMUONCluster.cxx:65
 AliMUONCluster.cxx:66
 AliMUONCluster.cxx:67
 AliMUONCluster.cxx:68
 AliMUONCluster.cxx:69
 AliMUONCluster.cxx:70
 AliMUONCluster.cxx:71
 AliMUONCluster.cxx:72
 AliMUONCluster.cxx:73
 AliMUONCluster.cxx:74
 AliMUONCluster.cxx:75
 AliMUONCluster.cxx:76
 AliMUONCluster.cxx:77
 AliMUONCluster.cxx:78
 AliMUONCluster.cxx:79
 AliMUONCluster.cxx:80
 AliMUONCluster.cxx:81
 AliMUONCluster.cxx:82
 AliMUONCluster.cxx:83
 AliMUONCluster.cxx:84
 AliMUONCluster.cxx:85
 AliMUONCluster.cxx:86
 AliMUONCluster.cxx:87
 AliMUONCluster.cxx:88
 AliMUONCluster.cxx:89
 AliMUONCluster.cxx:90
 AliMUONCluster.cxx:91
 AliMUONCluster.cxx:92
 AliMUONCluster.cxx:93
 AliMUONCluster.cxx:94
 AliMUONCluster.cxx:95
 AliMUONCluster.cxx:96
 AliMUONCluster.cxx:97
 AliMUONCluster.cxx:98
 AliMUONCluster.cxx:99
 AliMUONCluster.cxx:100
 AliMUONCluster.cxx:101
 AliMUONCluster.cxx:102
 AliMUONCluster.cxx:103
 AliMUONCluster.cxx:104
 AliMUONCluster.cxx:105
 AliMUONCluster.cxx:106
 AliMUONCluster.cxx:107
 AliMUONCluster.cxx:108
 AliMUONCluster.cxx:109
 AliMUONCluster.cxx:110
 AliMUONCluster.cxx:111
 AliMUONCluster.cxx:112
 AliMUONCluster.cxx:113
 AliMUONCluster.cxx:114
 AliMUONCluster.cxx:115
 AliMUONCluster.cxx:116
 AliMUONCluster.cxx:117
 AliMUONCluster.cxx:118
 AliMUONCluster.cxx:119
 AliMUONCluster.cxx:120
 AliMUONCluster.cxx:121
 AliMUONCluster.cxx:122
 AliMUONCluster.cxx:123
 AliMUONCluster.cxx:124
 AliMUONCluster.cxx:125
 AliMUONCluster.cxx:126
 AliMUONCluster.cxx:127
 AliMUONCluster.cxx:128
 AliMUONCluster.cxx:129
 AliMUONCluster.cxx:130
 AliMUONCluster.cxx:131
 AliMUONCluster.cxx:132
 AliMUONCluster.cxx:133
 AliMUONCluster.cxx:134
 AliMUONCluster.cxx:135
 AliMUONCluster.cxx:136
 AliMUONCluster.cxx:137
 AliMUONCluster.cxx:138
 AliMUONCluster.cxx:139
 AliMUONCluster.cxx:140
 AliMUONCluster.cxx:141
 AliMUONCluster.cxx:142
 AliMUONCluster.cxx:143
 AliMUONCluster.cxx:144
 AliMUONCluster.cxx:145
 AliMUONCluster.cxx:146
 AliMUONCluster.cxx:147
 AliMUONCluster.cxx:148
 AliMUONCluster.cxx:149
 AliMUONCluster.cxx:150
 AliMUONCluster.cxx:151
 AliMUONCluster.cxx:152
 AliMUONCluster.cxx:153
 AliMUONCluster.cxx:154
 AliMUONCluster.cxx:155
 AliMUONCluster.cxx:156
 AliMUONCluster.cxx:157
 AliMUONCluster.cxx:158
 AliMUONCluster.cxx:159
 AliMUONCluster.cxx:160
 AliMUONCluster.cxx:161
 AliMUONCluster.cxx:162
 AliMUONCluster.cxx:163
 AliMUONCluster.cxx:164
 AliMUONCluster.cxx:165
 AliMUONCluster.cxx:166
 AliMUONCluster.cxx:167
 AliMUONCluster.cxx:168
 AliMUONCluster.cxx:169
 AliMUONCluster.cxx:170
 AliMUONCluster.cxx:171
 AliMUONCluster.cxx:172
 AliMUONCluster.cxx:173
 AliMUONCluster.cxx:174
 AliMUONCluster.cxx:175
 AliMUONCluster.cxx:176
 AliMUONCluster.cxx:177
 AliMUONCluster.cxx:178
 AliMUONCluster.cxx:179
 AliMUONCluster.cxx:180
 AliMUONCluster.cxx:181
 AliMUONCluster.cxx:182
 AliMUONCluster.cxx:183
 AliMUONCluster.cxx:184
 AliMUONCluster.cxx:185
 AliMUONCluster.cxx:186
 AliMUONCluster.cxx:187
 AliMUONCluster.cxx:188
 AliMUONCluster.cxx:189
 AliMUONCluster.cxx:190
 AliMUONCluster.cxx:191
 AliMUONCluster.cxx:192
 AliMUONCluster.cxx:193
 AliMUONCluster.cxx:194
 AliMUONCluster.cxx:195
 AliMUONCluster.cxx:196
 AliMUONCluster.cxx:197
 AliMUONCluster.cxx:198
 AliMUONCluster.cxx:199
 AliMUONCluster.cxx:200
 AliMUONCluster.cxx:201
 AliMUONCluster.cxx:202
 AliMUONCluster.cxx:203
 AliMUONCluster.cxx:204
 AliMUONCluster.cxx:205
 AliMUONCluster.cxx:206
 AliMUONCluster.cxx:207
 AliMUONCluster.cxx:208
 AliMUONCluster.cxx:209
 AliMUONCluster.cxx:210
 AliMUONCluster.cxx:211
 AliMUONCluster.cxx:212
 AliMUONCluster.cxx:213
 AliMUONCluster.cxx:214
 AliMUONCluster.cxx:215
 AliMUONCluster.cxx:216
 AliMUONCluster.cxx:217
 AliMUONCluster.cxx:218
 AliMUONCluster.cxx:219
 AliMUONCluster.cxx:220
 AliMUONCluster.cxx:221
 AliMUONCluster.cxx:222
 AliMUONCluster.cxx:223
 AliMUONCluster.cxx:224
 AliMUONCluster.cxx:225
 AliMUONCluster.cxx:226
 AliMUONCluster.cxx:227
 AliMUONCluster.cxx:228
 AliMUONCluster.cxx:229
 AliMUONCluster.cxx:230
 AliMUONCluster.cxx:231
 AliMUONCluster.cxx:232
 AliMUONCluster.cxx:233
 AliMUONCluster.cxx:234
 AliMUONCluster.cxx:235
 AliMUONCluster.cxx:236
 AliMUONCluster.cxx:237
 AliMUONCluster.cxx:238
 AliMUONCluster.cxx:239
 AliMUONCluster.cxx:240
 AliMUONCluster.cxx:241
 AliMUONCluster.cxx:242
 AliMUONCluster.cxx:243
 AliMUONCluster.cxx:244
 AliMUONCluster.cxx:245
 AliMUONCluster.cxx:246
 AliMUONCluster.cxx:247
 AliMUONCluster.cxx:248
 AliMUONCluster.cxx:249
 AliMUONCluster.cxx:250
 AliMUONCluster.cxx:251
 AliMUONCluster.cxx:252
 AliMUONCluster.cxx:253
 AliMUONCluster.cxx:254
 AliMUONCluster.cxx:255
 AliMUONCluster.cxx:256
 AliMUONCluster.cxx:257
 AliMUONCluster.cxx:258
 AliMUONCluster.cxx:259
 AliMUONCluster.cxx:260
 AliMUONCluster.cxx:261
 AliMUONCluster.cxx:262
 AliMUONCluster.cxx:263
 AliMUONCluster.cxx:264
 AliMUONCluster.cxx:265
 AliMUONCluster.cxx:266
 AliMUONCluster.cxx:267
 AliMUONCluster.cxx:268
 AliMUONCluster.cxx:269
 AliMUONCluster.cxx:270
 AliMUONCluster.cxx:271
 AliMUONCluster.cxx:272
 AliMUONCluster.cxx:273
 AliMUONCluster.cxx:274
 AliMUONCluster.cxx:275
 AliMUONCluster.cxx:276
 AliMUONCluster.cxx:277
 AliMUONCluster.cxx:278
 AliMUONCluster.cxx:279
 AliMUONCluster.cxx:280
 AliMUONCluster.cxx:281
 AliMUONCluster.cxx:282
 AliMUONCluster.cxx:283
 AliMUONCluster.cxx:284
 AliMUONCluster.cxx:285
 AliMUONCluster.cxx:286
 AliMUONCluster.cxx:287
 AliMUONCluster.cxx:288
 AliMUONCluster.cxx:289
 AliMUONCluster.cxx:290
 AliMUONCluster.cxx:291
 AliMUONCluster.cxx:292
 AliMUONCluster.cxx:293
 AliMUONCluster.cxx:294
 AliMUONCluster.cxx:295
 AliMUONCluster.cxx:296
 AliMUONCluster.cxx:297
 AliMUONCluster.cxx:298
 AliMUONCluster.cxx:299
 AliMUONCluster.cxx:300
 AliMUONCluster.cxx:301
 AliMUONCluster.cxx:302
 AliMUONCluster.cxx:303
 AliMUONCluster.cxx:304
 AliMUONCluster.cxx:305
 AliMUONCluster.cxx:306
 AliMUONCluster.cxx:307
 AliMUONCluster.cxx:308
 AliMUONCluster.cxx:309
 AliMUONCluster.cxx:310
 AliMUONCluster.cxx:311
 AliMUONCluster.cxx:312
 AliMUONCluster.cxx:313
 AliMUONCluster.cxx:314
 AliMUONCluster.cxx:315
 AliMUONCluster.cxx:316
 AliMUONCluster.cxx:317
 AliMUONCluster.cxx:318
 AliMUONCluster.cxx:319
 AliMUONCluster.cxx:320
 AliMUONCluster.cxx:321
 AliMUONCluster.cxx:322
 AliMUONCluster.cxx:323
 AliMUONCluster.cxx:324
 AliMUONCluster.cxx:325
 AliMUONCluster.cxx:326
 AliMUONCluster.cxx:327
 AliMUONCluster.cxx:328
 AliMUONCluster.cxx:329
 AliMUONCluster.cxx:330
 AliMUONCluster.cxx:331
 AliMUONCluster.cxx:332
 AliMUONCluster.cxx:333
 AliMUONCluster.cxx:334
 AliMUONCluster.cxx:335
 AliMUONCluster.cxx:336
 AliMUONCluster.cxx:337
 AliMUONCluster.cxx:338
 AliMUONCluster.cxx:339
 AliMUONCluster.cxx:340
 AliMUONCluster.cxx:341
 AliMUONCluster.cxx:342
 AliMUONCluster.cxx:343
 AliMUONCluster.cxx:344
 AliMUONCluster.cxx:345
 AliMUONCluster.cxx:346
 AliMUONCluster.cxx:347
 AliMUONCluster.cxx:348
 AliMUONCluster.cxx:349
 AliMUONCluster.cxx:350
 AliMUONCluster.cxx:351
 AliMUONCluster.cxx:352
 AliMUONCluster.cxx:353
 AliMUONCluster.cxx:354
 AliMUONCluster.cxx:355
 AliMUONCluster.cxx:356
 AliMUONCluster.cxx:357
 AliMUONCluster.cxx:358
 AliMUONCluster.cxx:359
 AliMUONCluster.cxx:360
 AliMUONCluster.cxx:361
 AliMUONCluster.cxx:362
 AliMUONCluster.cxx:363
 AliMUONCluster.cxx:364
 AliMUONCluster.cxx:365
 AliMUONCluster.cxx:366
 AliMUONCluster.cxx:367
 AliMUONCluster.cxx:368
 AliMUONCluster.cxx:369
 AliMUONCluster.cxx:370
 AliMUONCluster.cxx:371
 AliMUONCluster.cxx:372
 AliMUONCluster.cxx:373
 AliMUONCluster.cxx:374
 AliMUONCluster.cxx:375
 AliMUONCluster.cxx:376
 AliMUONCluster.cxx:377
 AliMUONCluster.cxx:378
 AliMUONCluster.cxx:379
 AliMUONCluster.cxx:380
 AliMUONCluster.cxx:381
 AliMUONCluster.cxx:382
 AliMUONCluster.cxx:383
 AliMUONCluster.cxx:384
 AliMUONCluster.cxx:385
 AliMUONCluster.cxx:386
 AliMUONCluster.cxx:387
 AliMUONCluster.cxx:388
 AliMUONCluster.cxx:389
 AliMUONCluster.cxx:390
 AliMUONCluster.cxx:391
 AliMUONCluster.cxx:392
 AliMUONCluster.cxx:393
 AliMUONCluster.cxx:394
 AliMUONCluster.cxx:395
 AliMUONCluster.cxx:396
 AliMUONCluster.cxx:397
 AliMUONCluster.cxx:398
 AliMUONCluster.cxx:399
 AliMUONCluster.cxx:400
 AliMUONCluster.cxx:401
 AliMUONCluster.cxx:402
 AliMUONCluster.cxx:403
 AliMUONCluster.cxx:404
 AliMUONCluster.cxx:405
 AliMUONCluster.cxx:406
 AliMUONCluster.cxx:407
 AliMUONCluster.cxx:408
 AliMUONCluster.cxx:409
 AliMUONCluster.cxx:410
 AliMUONCluster.cxx:411
 AliMUONCluster.cxx:412
 AliMUONCluster.cxx:413
 AliMUONCluster.cxx:414
 AliMUONCluster.cxx:415
 AliMUONCluster.cxx:416
 AliMUONCluster.cxx:417
 AliMUONCluster.cxx:418
 AliMUONCluster.cxx:419
 AliMUONCluster.cxx:420
 AliMUONCluster.cxx:421
 AliMUONCluster.cxx:422
 AliMUONCluster.cxx:423
 AliMUONCluster.cxx:424
 AliMUONCluster.cxx:425
 AliMUONCluster.cxx:426
 AliMUONCluster.cxx:427
 AliMUONCluster.cxx:428
 AliMUONCluster.cxx:429
 AliMUONCluster.cxx:430
 AliMUONCluster.cxx:431
 AliMUONCluster.cxx:432
 AliMUONCluster.cxx:433
 AliMUONCluster.cxx:434
 AliMUONCluster.cxx:435
 AliMUONCluster.cxx:436
 AliMUONCluster.cxx:437
 AliMUONCluster.cxx:438
 AliMUONCluster.cxx:439
 AliMUONCluster.cxx:440
 AliMUONCluster.cxx:441
 AliMUONCluster.cxx:442
 AliMUONCluster.cxx:443
 AliMUONCluster.cxx:444
 AliMUONCluster.cxx:445
 AliMUONCluster.cxx:446
 AliMUONCluster.cxx:447
 AliMUONCluster.cxx:448
 AliMUONCluster.cxx:449
 AliMUONCluster.cxx:450
 AliMUONCluster.cxx:451
 AliMUONCluster.cxx:452
 AliMUONCluster.cxx:453
 AliMUONCluster.cxx:454
 AliMUONCluster.cxx:455
 AliMUONCluster.cxx:456
 AliMUONCluster.cxx:457
 AliMUONCluster.cxx:458
 AliMUONCluster.cxx:459
 AliMUONCluster.cxx:460
 AliMUONCluster.cxx:461
 AliMUONCluster.cxx:462
 AliMUONCluster.cxx:463
 AliMUONCluster.cxx:464
 AliMUONCluster.cxx:465
 AliMUONCluster.cxx:466
 AliMUONCluster.cxx:467
 AliMUONCluster.cxx:468
 AliMUONCluster.cxx:469
 AliMUONCluster.cxx:470
 AliMUONCluster.cxx:471
 AliMUONCluster.cxx:472
 AliMUONCluster.cxx:473
 AliMUONCluster.cxx:474
 AliMUONCluster.cxx:475
 AliMUONCluster.cxx:476
 AliMUONCluster.cxx:477
 AliMUONCluster.cxx:478
 AliMUONCluster.cxx:479
 AliMUONCluster.cxx:480
 AliMUONCluster.cxx:481
 AliMUONCluster.cxx:482
 AliMUONCluster.cxx:483
 AliMUONCluster.cxx:484
 AliMUONCluster.cxx:485
 AliMUONCluster.cxx:486
 AliMUONCluster.cxx:487
 AliMUONCluster.cxx:488
 AliMUONCluster.cxx:489
 AliMUONCluster.cxx:490
 AliMUONCluster.cxx:491
 AliMUONCluster.cxx:492
 AliMUONCluster.cxx:493
 AliMUONCluster.cxx:494
 AliMUONCluster.cxx:495
 AliMUONCluster.cxx:496
 AliMUONCluster.cxx:497
 AliMUONCluster.cxx:498
 AliMUONCluster.cxx:499
 AliMUONCluster.cxx:500
 AliMUONCluster.cxx:501
 AliMUONCluster.cxx:502
 AliMUONCluster.cxx:503
 AliMUONCluster.cxx:504
 AliMUONCluster.cxx:505
 AliMUONCluster.cxx:506
 AliMUONCluster.cxx:507
 AliMUONCluster.cxx:508
 AliMUONCluster.cxx:509
 AliMUONCluster.cxx:510
 AliMUONCluster.cxx:511
 AliMUONCluster.cxx:512
 AliMUONCluster.cxx:513
 AliMUONCluster.cxx:514
 AliMUONCluster.cxx:515
 AliMUONCluster.cxx:516
 AliMUONCluster.cxx:517
 AliMUONCluster.cxx:518
 AliMUONCluster.cxx:519
 AliMUONCluster.cxx:520
 AliMUONCluster.cxx:521
 AliMUONCluster.cxx:522
 AliMUONCluster.cxx:523
 AliMUONCluster.cxx:524
 AliMUONCluster.cxx:525
 AliMUONCluster.cxx:526
 AliMUONCluster.cxx:527
 AliMUONCluster.cxx:528
 AliMUONCluster.cxx:529
 AliMUONCluster.cxx:530
 AliMUONCluster.cxx:531
 AliMUONCluster.cxx:532
 AliMUONCluster.cxx:533
 AliMUONCluster.cxx:534
 AliMUONCluster.cxx:535
 AliMUONCluster.cxx:536
 AliMUONCluster.cxx:537
 AliMUONCluster.cxx:538
 AliMUONCluster.cxx:539
 AliMUONCluster.cxx:540
 AliMUONCluster.cxx:541
 AliMUONCluster.cxx:542
 AliMUONCluster.cxx:543
 AliMUONCluster.cxx:544
 AliMUONCluster.cxx:545
 AliMUONCluster.cxx:546
 AliMUONCluster.cxx:547
 AliMUONCluster.cxx:548
 AliMUONCluster.cxx:549
 AliMUONCluster.cxx:550
 AliMUONCluster.cxx:551
 AliMUONCluster.cxx:552
 AliMUONCluster.cxx:553
 AliMUONCluster.cxx:554
 AliMUONCluster.cxx:555
 AliMUONCluster.cxx:556
 AliMUONCluster.cxx:557
 AliMUONCluster.cxx:558
 AliMUONCluster.cxx:559
 AliMUONCluster.cxx:560
 AliMUONCluster.cxx:561
 AliMUONCluster.cxx:562
 AliMUONCluster.cxx:563
 AliMUONCluster.cxx:564
 AliMUONCluster.cxx:565
 AliMUONCluster.cxx:566
 AliMUONCluster.cxx:567
 AliMUONCluster.cxx:568
 AliMUONCluster.cxx:569
 AliMUONCluster.cxx:570
 AliMUONCluster.cxx:571
 AliMUONCluster.cxx:572
 AliMUONCluster.cxx:573
 AliMUONCluster.cxx:574
 AliMUONCluster.cxx:575
 AliMUONCluster.cxx:576
 AliMUONCluster.cxx:577
 AliMUONCluster.cxx:578
 AliMUONCluster.cxx:579
 AliMUONCluster.cxx:580
 AliMUONCluster.cxx:581
 AliMUONCluster.cxx:582
 AliMUONCluster.cxx:583
 AliMUONCluster.cxx:584
 AliMUONCluster.cxx:585
 AliMUONCluster.cxx:586
 AliMUONCluster.cxx:587
 AliMUONCluster.cxx:588
 AliMUONCluster.cxx:589
 AliMUONCluster.cxx:590
 AliMUONCluster.cxx:591
 AliMUONCluster.cxx:592
 AliMUONCluster.cxx:593
 AliMUONCluster.cxx:594
 AliMUONCluster.cxx:595
 AliMUONCluster.cxx:596
 AliMUONCluster.cxx:597
 AliMUONCluster.cxx:598
 AliMUONCluster.cxx:599
 AliMUONCluster.cxx:600
 AliMUONCluster.cxx:601
 AliMUONCluster.cxx:602
 AliMUONCluster.cxx:603
 AliMUONCluster.cxx:604
 AliMUONCluster.cxx:605
 AliMUONCluster.cxx:606
 AliMUONCluster.cxx:607
 AliMUONCluster.cxx:608
 AliMUONCluster.cxx:609
 AliMUONCluster.cxx:610
 AliMUONCluster.cxx:611
 AliMUONCluster.cxx:612
 AliMUONCluster.cxx:613
 AliMUONCluster.cxx:614
 AliMUONCluster.cxx:615
 AliMUONCluster.cxx:616
 AliMUONCluster.cxx:617
 AliMUONCluster.cxx:618
 AliMUONCluster.cxx:619
 AliMUONCluster.cxx:620
 AliMUONCluster.cxx:621
 AliMUONCluster.cxx:622
 AliMUONCluster.cxx:623
 AliMUONCluster.cxx:624
 AliMUONCluster.cxx:625
 AliMUONCluster.cxx:626
 AliMUONCluster.cxx:627
 AliMUONCluster.cxx:628
 AliMUONCluster.cxx:629
 AliMUONCluster.cxx:630
 AliMUONCluster.cxx:631
 AliMUONCluster.cxx:632
 AliMUONCluster.cxx:633
 AliMUONCluster.cxx:634
 AliMUONCluster.cxx:635
 AliMUONCluster.cxx:636
 AliMUONCluster.cxx:637
 AliMUONCluster.cxx:638
 AliMUONCluster.cxx:639
 AliMUONCluster.cxx:640
 AliMUONCluster.cxx:641
 AliMUONCluster.cxx:642
 AliMUONCluster.cxx:643
 AliMUONCluster.cxx:644
 AliMUONCluster.cxx:645
 AliMUONCluster.cxx:646
 AliMUONCluster.cxx:647
 AliMUONCluster.cxx:648
 AliMUONCluster.cxx:649
 AliMUONCluster.cxx:650
 AliMUONCluster.cxx:651
 AliMUONCluster.cxx:652
 AliMUONCluster.cxx:653
 AliMUONCluster.cxx:654
 AliMUONCluster.cxx:655
 AliMUONCluster.cxx:656
 AliMUONCluster.cxx:657
 AliMUONCluster.cxx:658
 AliMUONCluster.cxx:659
 AliMUONCluster.cxx:660
 AliMUONCluster.cxx:661
 AliMUONCluster.cxx:662
 AliMUONCluster.cxx:663
 AliMUONCluster.cxx:664
 AliMUONCluster.cxx:665
 AliMUONCluster.cxx:666
 AliMUONCluster.cxx:667
 AliMUONCluster.cxx:668
 AliMUONCluster.cxx:669
 AliMUONCluster.cxx:670
 AliMUONCluster.cxx:671
 AliMUONCluster.cxx:672
 AliMUONCluster.cxx:673
 AliMUONCluster.cxx:674
 AliMUONCluster.cxx:675
 AliMUONCluster.cxx:676
 AliMUONCluster.cxx:677
 AliMUONCluster.cxx:678
 AliMUONCluster.cxx:679
 AliMUONCluster.cxx:680
 AliMUONCluster.cxx:681
 AliMUONCluster.cxx:682
 AliMUONCluster.cxx:683
 AliMUONCluster.cxx:684
 AliMUONCluster.cxx:685
 AliMUONCluster.cxx:686
 AliMUONCluster.cxx:687
 AliMUONCluster.cxx:688
 AliMUONCluster.cxx:689
 AliMUONCluster.cxx:690
 AliMUONCluster.cxx:691
 AliMUONCluster.cxx:692
 AliMUONCluster.cxx:693
 AliMUONCluster.cxx:694
 AliMUONCluster.cxx:695
 AliMUONCluster.cxx:696
 AliMUONCluster.cxx:697
 AliMUONCluster.cxx:698
 AliMUONCluster.cxx:699
 AliMUONCluster.cxx:700
 AliMUONCluster.cxx:701
 AliMUONCluster.cxx:702
 AliMUONCluster.cxx:703
 AliMUONCluster.cxx:704
 AliMUONCluster.cxx:705
 AliMUONCluster.cxx:706
 AliMUONCluster.cxx:707
 AliMUONCluster.cxx:708
 AliMUONCluster.cxx:709
 AliMUONCluster.cxx:710
 AliMUONCluster.cxx:711
 AliMUONCluster.cxx:712
 AliMUONCluster.cxx:713
 AliMUONCluster.cxx:714
 AliMUONCluster.cxx:715
 AliMUONCluster.cxx:716
 AliMUONCluster.cxx:717
 AliMUONCluster.cxx:718
 AliMUONCluster.cxx:719
 AliMUONCluster.cxx:720
 AliMUONCluster.cxx:721
 AliMUONCluster.cxx:722
 AliMUONCluster.cxx:723
 AliMUONCluster.cxx:724
 AliMUONCluster.cxx:725
 AliMUONCluster.cxx:726
 AliMUONCluster.cxx:727
 AliMUONCluster.cxx:728
 AliMUONCluster.cxx:729
 AliMUONCluster.cxx:730
 AliMUONCluster.cxx:731
 AliMUONCluster.cxx:732
 AliMUONCluster.cxx:733
 AliMUONCluster.cxx:734
 AliMUONCluster.cxx:735
 AliMUONCluster.cxx:736
 AliMUONCluster.cxx:737
 AliMUONCluster.cxx:738
 AliMUONCluster.cxx:739
 AliMUONCluster.cxx:740
 AliMUONCluster.cxx:741
 AliMUONCluster.cxx:742
 AliMUONCluster.cxx:743
 AliMUONCluster.cxx:744
 AliMUONCluster.cxx:745
 AliMUONCluster.cxx:746
 AliMUONCluster.cxx:747
 AliMUONCluster.cxx:748
 AliMUONCluster.cxx:749
 AliMUONCluster.cxx:750
 AliMUONCluster.cxx:751
 AliMUONCluster.cxx:752
 AliMUONCluster.cxx:753
 AliMUONCluster.cxx:754
 AliMUONCluster.cxx:755
 AliMUONCluster.cxx:756
 AliMUONCluster.cxx:757
 AliMUONCluster.cxx:758
 AliMUONCluster.cxx:759
 AliMUONCluster.cxx:760
 AliMUONCluster.cxx:761
 AliMUONCluster.cxx:762
 AliMUONCluster.cxx:763
 AliMUONCluster.cxx:764
 AliMUONCluster.cxx:765
 AliMUONCluster.cxx:766
 AliMUONCluster.cxx:767
 AliMUONCluster.cxx:768
 AliMUONCluster.cxx:769
 AliMUONCluster.cxx:770
 AliMUONCluster.cxx:771
 AliMUONCluster.cxx:772
 AliMUONCluster.cxx:773
 AliMUONCluster.cxx:774
 AliMUONCluster.cxx:775
 AliMUONCluster.cxx:776
 AliMUONCluster.cxx:777
 AliMUONCluster.cxx:778
 AliMUONCluster.cxx:779
 AliMUONCluster.cxx:780
 AliMUONCluster.cxx:781
 AliMUONCluster.cxx:782
 AliMUONCluster.cxx:783
 AliMUONCluster.cxx:784
 AliMUONCluster.cxx:785
 AliMUONCluster.cxx:786
 AliMUONCluster.cxx:787
 AliMUONCluster.cxx:788
 AliMUONCluster.cxx:789
 AliMUONCluster.cxx:790
 AliMUONCluster.cxx:791
 AliMUONCluster.cxx:792
 AliMUONCluster.cxx:793
 AliMUONCluster.cxx:794
 AliMUONCluster.cxx:795
 AliMUONCluster.cxx:796
 AliMUONCluster.cxx:797
 AliMUONCluster.cxx:798
 AliMUONCluster.cxx:799
 AliMUONCluster.cxx:800
 AliMUONCluster.cxx:801
 AliMUONCluster.cxx:802
 AliMUONCluster.cxx:803
 AliMUONCluster.cxx:804
 AliMUONCluster.cxx:805
 AliMUONCluster.cxx:806
 AliMUONCluster.cxx:807
 AliMUONCluster.cxx:808
 AliMUONCluster.cxx:809
 AliMUONCluster.cxx:810
 AliMUONCluster.cxx:811
 AliMUONCluster.cxx:812
 AliMUONCluster.cxx:813