MUON/AliMUONCluster.cxx

   1 /**************************************************************************
   2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3 *                                                                        *
   4 * Author: The ALICE Off-line Project.                                    *
   5 * Contributors are mentioned in the code where appropriate.              *
   6 *                                                                        *
   7 * Permission to use, copy, modify and distribute this software and its   *
   8 * documentation strictly for non-commercial purposes is hereby granted   *
   9 * without fee, provided that the above copyright notice appears in all   *
  10 * copies and that both the copyright notice and this permission notice   *
  11 * appear in the supporting documentation. The authors make no claims     *
  12 * about the suitability of this software for any purpose. It is          *
  13 * provided "as is" without express or implied warranty.                  *
  14 **************************************************************************/
  15
  16 // $Id$
  17
  18 #include <Riostream.h>
  19 #include <TMath.h>
  20 #include <TObjArray.h>
  21 #include <TVirtualPad.h>
  22 #include <TVirtualX.h>
  23
  24 #include "AliMUONCluster.h"
  25
  26 #include "AliLog.h"
  27 #include "AliMUONPad.h"
  28
  29 //-----------------------------------------------------------------------------
  30 /// \class AliMUONCluster
  31 ///
  32 /// A group of adjacent pads
  33 ///
  34 /// Besides holding an internal array of AliMUONPads, this object
  35 /// also computes some global characteristics for that pad sets.
  36 ///
  37 /// \author Laurent Aphecetche
  38 ///
  39 //-----------------------------------------------------------------------------
  40
  41 /// \cond CLASSIMP
  42 ClassImp(AliMUONCluster)
  43 /// \endcond
  44
  45 namespace
  46 {
  47   //___________________________________________________________________________
  48   Bool_t
  49   ShouldUsePad(const AliMUONPad& pad,
  50                Int_t cathode, Int_t statusMask, Bool_t matchMask)
  51   {
  52
  53       // FIXME : we should only use >=0 status, so we can fully
  54       // use masking possibility ?
  55     if ( pad.Status() < 0 ) return kFALSE;
  56
  57     if ( pad.Cathode() == cathode && pad.IsReal() && !pad.IsSaturated() )
  58     {
  59       Bool_t test = ( ( pad.Status() & statusMask ) != 0 );
  60       if ( !statusMask )
  61       {
  62         test = ( pad.Status() == 0 );
  63       }
  64       if ( ( test && matchMask ) || ( !test && !matchMask ) )
  65       {
  66         return kTRUE;
  67       }
  68     }
  69     return kFALSE;
  70   }
  71
  72   //___________________________________________________________________________
  73   Int_t Unique(Int_t n, Double_t* array, Double_t precision)
  74   {
  75     /// Return the number of *different* elements in array
  76     /// where different is up to precision
  77     /// Note that we assume that n is >= 1
  78
  79     Int_t count(1);
  80
  81     Int_t* index = new Int_t[n];
  82
  83     TMath::Sort(n,array,index);
  84
  85     for ( Int_t i = 1; i < n; ++i )
  86     {
  87       if ( array[index[i]] - array[index[i-1]] < -precision ) ++count;
  88     }
  89
  90     delete[] index;
  91
  92     return count;
  93   }
  94 }
  95
  96 //_____________________________________________________________________________
  97 AliMUONCluster::AliMUONCluster()
  98 : TObject(),
  99 fPads(0x0),
 100 fHasPosition(kFALSE),
 101 fPosition(1E9,1E9),
 102 fPositionError(1E9,1E9),
 103 fHasCharge(kFALSE),
 104 fChi2(0)
 105 {
 106   /// ctor
 107   fMultiplicity[0]=fMultiplicity[1]=0;
 108   fRawCharge[0]=fRawCharge[1]=0;
 109   fCharge[0]=fCharge[1]=0;
 110   fIsSaturated[0]=fIsSaturated[1]=kFALSE;
 111 }
 112
 113 //_____________________________________________________________________________
 114 AliMUONCluster::AliMUONCluster(const AliMUONCluster& src)
 115 : TObject(src),
 116 fPads(0x0),
 117 fHasPosition(kFALSE),
 118 fPosition(1E9,1E9),
 119 fPositionError(1E9,1E9),
 120 fHasCharge(kFALSE),
 121 fChi2(0)
 122 {
 123   /// copy ctor
 124   src.Copy(*this);
 125 }
 126
 127 //_____________________________________________________________________________
 128 AliMUONCluster&
 129 AliMUONCluster::operator=(const AliMUONCluster& src)
 130 {
 131   /// assignement operator
 132   if ( this != &src )
 133   {
 134     src.Copy(*this);
 135   }
 136   return *this;
 137 }
 138
 139 //_____________________________________________________________________________
 140 AliMUONCluster::~AliMUONCluster()
 141 {
 142   /// dtor : note that we're owner of our pads
 143   delete fPads;
 144 }
 145
 146 //_____________________________________________________________________________
 147 void
 148 AliMUONCluster::Clear(Option_t*)
 149 {
 150   /// Clear our pad array
 151   if (fPads) fPads->Clear("C");
 152 }
 153
 154 //_____________________________________________________________________________
 155 Bool_t
 156 AliMUONCluster::Contains(const AliMUONPad& pad) const
 157 {
 158   /// Whether this cluster contains the pad
 159   if (!fPads) return kFALSE;
 160   for ( Int_t i = 0; i < Multiplicity(); ++i )
 161   {
 162     AliMUONPad* p = Pad(i);
 163     if ( pad.Compare(p) == 0 ) return kTRUE;
 164   }
 165   return kFALSE;
 166 }
 167
 168 //_____________________________________________________________________________
 169 void
 170 AliMUONCluster::AddCluster(const AliMUONCluster& cluster)
 171 {
 172   /// Add all the pads for cluster to this one
 173   for ( Int_t i = 0; i < cluster.Multiplicity(); ++i )
 174   {
 175     AliMUONPad* p = cluster.Pad(i);
 176     if ( Contains(*p) )
 177     {
 178       AliError("I already got this pad : ");
 179       StdoutToAliError(p->Print(););
 180       AliFatal("");
 181     }
 182     AddPad(*p);
 183   }
 184
 185 }
 186
 187 //_____________________________________________________________________________
 188 AliMUONPad*
 189 AliMUONCluster::AddPad(const AliMUONPad& pad)
 190 {
 191   /// Add a pad to our pad array, and update some internal information
 192   /// accordingly.
 193
 194   if (!fPads)
 195   {
 196     fPads = new TObjArray(10);
 197     fPads->SetOwner(kTRUE);
 198   }
 199   AliMUONPad* p = new AliMUONPad(pad);
 200   fPads->AddLast(p);
 201   p->SetClusterId(GetUniqueID());
 202   Int_t cathode = p->Cathode();
 203   ++(fMultiplicity[cathode]);
 204   fRawCharge[cathode] += p->Charge();
 205   if ( p->IsSaturated() )
 206   {
 207     fIsSaturated[p->Cathode()]=kTRUE;
 208   }
 209   return p;
 210 }
 211
 212 //___________________________________________________________________________
 213 TString
 214 AliMUONCluster::AsString() const
 215 {
 216   /// Return a string containing a compact form of the pad list
 217   TString s(Form("NPADS(%d,%d)",Multiplicity(0),Multiplicity(1)));
 218
 219   for (Int_t i = 0; i < Multiplicity(); ++i )
 220   {
 221     AliMUONPad* p = Pad(i);
 222     s += Form(" (%d,%d,%d) ",p->Cathode(),p->Ix(),p->Iy());
 223   }
 224   return s;
 225 }
 226
 227
 228 //___________________________________________________________________________
 229 Bool_t
 230 AliMUONCluster::AreOverlapping(const AliMUONCluster& c1, const AliMUONCluster& c2)
 231 {
 232   /// Whether the two clusters overlap
 233
 234   static Double_t precision = 1E-4; // cm
 235   static TVector2 precisionAdjustment(precision,precision);
 236
 237   for ( Int_t i1 = 0; i1 < c1.Multiplicity(); ++i1 )
 238   {
 239     AliMUONPad* p1 = c1.Pad(i1);
 240
 241     for ( Int_t i2 = 0; i2 < c2.Multiplicity(); ++i2 )
 242     {
 243       AliMUONPad* p2 = c2.Pad(i2);
 244       // Note: we use negative precision numbers, meaning
 245       // the area of the pads will be *increased* by these small numbers
 246       // prior to check the overlap by the AreOverlapping method,
 247       // so pads touching only by the corners will be considered as
 248       // overlapping.
 249       if ( AliMUONPad::AreOverlapping(*p1,*p2,precisionAdjustment) )
 250       {
 251         return kTRUE;
 252       }
 253     }
 254   }
 255   return kFALSE;
 256 }
 257
 258 //_____________________________________________________________________________
 259 AliMpArea
 260 AliMUONCluster::Area() const
 261 {
 262   /// Return the geometrical area covered by this cluster
 263
 264   // Start by finding the (x,y) limits of this cluster
 265   TVector2 lowerLeft(1E9,1E9);
 266   TVector2 upperRight(-1E9,-1E9);
 267
 268   for ( Int_t i = 0; i < Multiplicity(); ++i )
 269   {
 270     AliMUONPad* pad = Pad(i);
 271     TVector2 ll = pad->Position() - pad->Dimensions();
 272     TVector2 ur = pad->Position() + pad->Dimensions();
 273     lowerLeft.Set( TMath::Min(ll.X(),lowerLeft.X()),
 274                    TMath::Min(ll.Y(),lowerLeft.Y()) );
 275     upperRight.Set( TMath::Max(ur.X(),upperRight.X()),
 276                     TMath::Max(ur.Y(),upperRight.Y()) );
 277   }
 278
 279   // then construct the area from those limits
 280   return AliMpArea((lowerLeft+upperRight)/2,
 281                    (upperRight-lowerLeft)/2);
 282 }
 283
 284 //_____________________________________________________________________________
 285 AliMpArea
 286 AliMUONCluster::Area(Int_t cathode) const
 287 {
 288   /// Return the geometrical area covered by this cluster's pads on
 289   /// a given cathode
 290
 291   // Start by finding the (x,y) limits of this cluster
 292   TVector2 lowerLeft(1E9,1E9);
 293   TVector2 upperRight(-1E9,-1E9);
 294
 295   for ( Int_t i = 0; i < Multiplicity(); ++i )
 296   {
 297     AliMUONPad* pad = Pad(i);
 298     if ( pad->Cathode() == cathode )
 299     {
 300       TVector2 ll = pad->Position() - pad->Dimensions();
 301       TVector2 ur = pad->Position() + pad->Dimensions();
 302       lowerLeft.Set( TMath::Min(ll.X(),lowerLeft.X()),
 303                      TMath::Min(ll.Y(),lowerLeft.Y()) );
 304       upperRight.Set( TMath::Max(ur.X(),upperRight.X()),
 305                       TMath::Max(ur.Y(),upperRight.Y()) );
 306     }
 307   }
 308
 309   // then construct the area from those limits
 310   return AliMpArea((lowerLeft+upperRight)/2,
 311                    (upperRight-lowerLeft)/2);
 312 }
 313
 314 //_____________________________________________________________________________
 315 Int_t
 316 AliMUONCluster::Cathode() const
 317 {
 318   /// Return the cathode "number" of this cluster :
 319   /// 0 if all its pads are on cathode 0
 320   /// 1 if all its pads are on cathode 1
 321   /// 2 if some pads on cath 0 and some on cath 1
 322
 323   Int_t cathode(-1);
 324   if (Multiplicity(0)>0 && Multiplicity(1)>0)
 325   {
 326     cathode=2;
 327   }
 328   else if (Multiplicity(0)>0)
 329   {
 330     cathode=0;
 331   }
 332   else if (Multiplicity(1)>0)
 333   {
 334     cathode=1;
 335   }
 336
 337   return cathode;
 338 }
 339
 340 //_____________________________________________________________________________
 341 void
 342 AliMUONCluster::Copy(TObject& obj) const
 343 {
 344   ///
 345   /// Copy this cluster to (cluster&)obj
 346   ///
 347   TObject::Copy(obj);
 348   AliMUONCluster& dest = static_cast<AliMUONCluster&>(obj);
 349   dest.fPads = 0x0;
 350   if ( fPads )
 351   {
 352     dest.fPads = static_cast<TObjArray*>(fPads->Clone());
 353   }
 354   dest.fHasPosition = fHasPosition;
 355   dest.fPosition = fPosition;
 356   dest.fPositionError = fPositionError;
 357   dest.fHasCharge = fHasCharge;
 358   dest.fChi2 = fChi2;
 359   for ( Int_t i = 0; i < 2; ++i )
 360   {
 361     dest.fRawCharge[i] = fRawCharge[i];
 362     dest.fCharge[i] = fCharge[i];
 363     dest.fMultiplicity[i] = fMultiplicity[i];
 364     dest.fIsSaturated[i] = fIsSaturated[i];
 365   }
 366 }
 367
 368 //_____________________________________________________________________________
 369 Float_t
 370 AliMUONCluster::Charge() const
 371 {
 372   /// Return the average charge over both cathodes
 373
 374   if ( Multiplicity(0) && Multiplicity(1) )
 375   {
 376     return (Charge(0)+Charge(1))/2.0;
 377   }
 378   else if ( Multiplicity(0) )
 379   {
 380     return Charge(0);
 381   }
 382   else if ( Multiplicity(1) )
 383   {
 384     return Charge(1);
 385   }
 386   AliError("Should not be here ?!");
 387   return -1.0;
 388 }
 389
 390 //_____________________________________________________________________________
 391 Float_t
 392 AliMUONCluster::Charge(Int_t cathode) const
 393 {
 394   /// Returns the charge of a given cathode
 395   if ( !fHasCharge ) return RawCharge(cathode);
 396
 397   if ( cathode == 0 || cathode == 1 )
 398   {
 399     return fCharge[cathode];
 400   }
 401   return 0;
 402 }
 403
 404 //_____________________________________________________________________________
 405 Float_t
 406 AliMUONCluster::ChargeAsymmetry() const
 407 {
 408   /// Returns the charge asymmetry
 409   if ( Charge() > 0 )
 410   {
 411     return TMath::Abs(Charge(0)-Charge(1))/Charge();
 412   }
 413   return 0;
 414 }
 415
 416 //_____________________________________________________________________________
 417 TVector2
 418 AliMUONCluster::MaxPadDimensions(Int_t statusMask, Bool_t matchMask) const
 419 {
 420   /// Returns the maximum pad dimensions (half sizes), only considering
 421   /// pads matching (or not, depending matchMask) a given mask
 422
 423   TVector2 cath0(MaxPadDimensions(0,statusMask,matchMask));
 424   TVector2 cath1(MaxPadDimensions(1,statusMask,matchMask));
 425
 426   return TVector2( TMath::Max(cath0.X(),cath1.X()),
 427                    TMath::Max(cath0.Y(),cath1.Y()) );
 428 }
 429
 430 //_____________________________________________________________________________
 431 TVector2
 432 AliMUONCluster::MaxPadDimensions(Int_t cathode,
 433                                  Int_t statusMask, Bool_t matchMask) const
 434 {
 435   /// Returns the maximum pad dimensions (half sizes), only considering
 436   /// pads matching (or not, depending matchMask) a given mask, within a
 437   /// given cathode
 438
 439   Double_t xmax(0);
 440   Double_t ymax(0);
 441
 442   for ( Int_t i = 0; i < Multiplicity(); ++i )
 443   {
 444     AliMUONPad* pad = Pad(i);
 445     if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
 446     {
 447       xmax = TMath::Max(xmax,pad->DX());
 448       ymax = TMath::Max(ymax,pad->DY());
 449     }
 450   }
 451   return TVector2(xmax,ymax);
 452 }
 453
 454 //_____________________________________________________________________________
 455 TVector2
 456 AliMUONCluster::MinPadDimensions(Int_t statusMask, Bool_t matchMask) const
 457 {
 458   /// Returns the minimum pad dimensions (half sizes), only considering
 459   /// pads matching (or not, depending matchMask) a given mask
 460
 461   TVector2 cath0(MinPadDimensions(0,statusMask,matchMask));
 462   TVector2 cath1(MinPadDimensions(1,statusMask,matchMask));
 463
 464   return TVector2( TMath::Min(cath0.X(),cath1.X()),
 465                    TMath::Min(cath0.Y(),cath1.Y()) );
 466 }
 467
 468 //_____________________________________________________________________________
 469 TVector2
 470 AliMUONCluster::MinPadDimensions(Int_t cathode,
 471                                  Int_t statusMask, Bool_t matchMask) const
 472 {
 473   /// Returns the minimum pad dimensions (half sizes), only considering
 474   /// pads matching (or not, depending matchMask) a given mask, within a
 475   /// given cathode
 476
 477   Double_t xmin(1E9);
 478   Double_t ymin(1E9);
 479
 480   for ( Int_t i = 0; i < Multiplicity(); ++i )
 481   {
 482     AliMUONPad* pad = Pad(i);
 483     if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
 484     {
 485       xmin = TMath::Min(xmin,pad->DX());
 486       ymin = TMath::Min(ymin,pad->DY());
 487     }
 488   }
 489   return TVector2(xmin,ymin);
 490 }
 491
 492 //_____________________________________________________________________________
 493 Int_t
 494 AliMUONCluster::Multiplicity() const
 495 {
 496   /// Returns the total number of pads in this cluster
 497   return Multiplicity(0)+Multiplicity(1);
 498 }
 499
 500 //_____________________________________________________________________________
 501 Int_t
 502 AliMUONCluster::Multiplicity(Int_t cathode) const
 503 {
 504   /// Returns the number of pads in this cluster, in the given cathode
 505   if ( cathode == 0 || cathode == 1 )
 506   {
 507     return fMultiplicity[cathode];
 508   }
 509   return 0;
 510 }
 511
 512 //_____________________________________________________________________________
 513 AliMpIntPair
 514 AliMUONCluster::NofPads(Int_t statusMask, Bool_t matchMask) const
 515 {
 516   /// Number of pads satisfying (or not, depending matchMask) a
 517   /// given mask
 518
 519   Int_t nx, ny;
 520
 521   TVector2 dim0(MinPadDimensions(0,statusMask,matchMask));
 522   TVector2 dim1(MinPadDimensions(1,statusMask,matchMask));
 523
 524   AliMpIntPair npad0(NofPads(0,statusMask,matchMask));
 525   AliMpIntPair npad1(NofPads(1,statusMask,matchMask));
 526
 527   if ( TMath::Abs( (dim0-dim1).X() ) < 1E-3 )
 528   {
 529     nx = TMath::Max( npad0.GetFirst(), npad1.GetFirst() );
 530   }
 531   else
 532   {
 533     nx = dim0.X() < dim1.X() ? npad0.GetFirst() : npad1.GetFirst();
 534   }
 535
 536   if ( TMath::Abs( (dim0-dim1).Y() ) < 1E-3 )
 537   {
 538     ny = TMath::Max( npad0.GetSecond(), npad1.GetSecond() );
 539   }
 540   else
 541   {
 542     ny = dim0.Y() < dim1.Y() ? npad0.GetSecond() : npad1.GetSecond();
 543   }
 544
 545   return AliMpIntPair(nx,ny);
 546 }
 547
 548 //_____________________________________________________________________________
 549 AliMpIntPair
 550 AliMUONCluster::NofPads(Int_t cathode,
 551                         Int_t statusMask, Bool_t matchMask) const
 552 {
 553   /// Number of pads of a given cathode, satisfying (or not,
 554   /// depending matchMask) a given mask
 555
 556   Int_t n = Multiplicity(cathode);
 557   if (!n)
 558   {
 559     return AliMpIntPair(0,0);
 560   }
 561   Double_t* x = new Double_t[n];
 562   Double_t* y = new Double_t[n];
 563   Int_t np(0);
 564
 565   for ( Int_t i = 0; i < Multiplicity(); ++i )
 566   {
 567     AliMUONPad* pad = Pad(i);
 568     if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
 569     {
 570       x[np] = pad->X();
 571       y[np] = pad->Y();
 572       ++np;
 573     }
 574   }
 575
 576   Int_t cx = Unique(np,x,0.01);
 577   Int_t cy = Unique(np,y,0.01);
 578
 579   delete[] x;
 580   delete[] y;
 581
 582   return AliMpIntPair(cx,cy);
 583 }
 584
 585 //_____________________________________________________________________________
 586 AliMUONPad*
 587 AliMUONCluster::Pad(Int_t index) const
 588 {
 589   /// Returns the index-th pad
 590
 591   if (!fPads) return 0x0;
 592   if ( index < fPads->GetLast()+1 )
 593   {
 594     return static_cast<AliMUONPad*>(fPads->At(index));
 595   }
 596   else
 597   {
 598     AliError(Form("Requested index %d out of bounds (%d) Mult is %d",index,
 599                   fPads->GetLast(),Multiplicity()));
 600     DumpMe();
 601   }
 602   return 0x0;
 603 }
 604
 605
 606 //_____________________________________________________________________________
 607 void
 608 AliMUONCluster::Paint(Option_t*)
 609 {
 610   /// Paint this cluster
 611   if (!Multiplicity()) return;
 612
 613   AliMpArea area(Area());
 614
 615   gPad->Range(area.LeftBorder(),area.DownBorder(),area.RightBorder(),area.UpBorder());
 616
 617   gVirtualX->SetFillStyle(0);
 618
 619   gVirtualX->SetLineColor(2);
 620   gVirtualX->SetLineWidth(4);
 621   for ( Int_t i = 0; i < Multiplicity(); ++i)
 622   {
 623     AliMUONPad* pad = Pad(i);
 624     if ( pad->Cathode() == 0 ) pad->Paint();
 625   }
 626
 627   gVirtualX->SetLineColor(4);
 628   gVirtualX->SetLineWidth(2);
 629   for ( Int_t i = 0; i < Multiplicity(); ++i)
 630   {
 631     AliMUONPad* pad = Pad(i);
 632     if ( pad->Cathode() == 1 ) pad->Paint();
 633   }
 634
 635 }
 636
 637 //_____________________________________________________________________________
 638 void
 639 AliMUONCluster::DumpMe() const
 640 {
 641   /// printout
 642   cout << "Cluster Id " << GetUniqueID() << " npads=" << Multiplicity()
 643   << "(" << Multiplicity(0) << "," << Multiplicity(1) << ") RawCharge="
 644   << RawCharge() << " (" << RawCharge(0) << "," << RawCharge(1)
 645   << ") Charge=(" << Charge(0) << "," << Charge(1) <<")";
 646   if ( HasPosition() )
 647   {
 648     cout << " (x,y)=(" << Position().X() << "," << Position().Y() << ")";
 649     cout << " (errX,errY)=(" << PositionError().X() << "," << PositionError().Y() << ")";
 650   }
 651   cout << endl;
 652 //  cout << " " << Area() << endl;
 653   if (fPads)
 654   {
 655     for (Int_t i = 0; i < fPads->GetSize(); ++i)
 656     {
 657       cout << Form("fPads[%d]=%x",i,fPads->At(i)) << endl;
 658       if ( fPads->At(i) ) fPads->At(i)->Print();
 659     }
 660   }
 661 }
 662
 663
 664 //_____________________________________________________________________________
 665 void
 666 AliMUONCluster::Print(Option_t* opt) const
 667 {
 668   /// printout
 669   cout << "Cluster Id " << GetUniqueID() << " npads=" << Multiplicity()
 670   << "(" << Multiplicity(0) << "," << Multiplicity(1) << ") RawCharge="
 671   << RawCharge() << " (" << RawCharge(0) << "," << RawCharge(1)
 672   << ") Charge=(" << Charge(0) << "," << Charge(1) <<")";
 673   if ( HasPosition() )
 674   {
 675     cout << " (x,y)=(" << Position().X() << "," << Position().Y() << ")";
 676     cout << " (errX,errY)=(" << PositionError().X() << "," << PositionError().Y() << ")";
 677   }
 678   cout << " " << Area();
 679   if (fPads)
 680   {
 681     TObjArray* a = static_cast<TObjArray*>(fPads->Clone());
 682     a->Sort();
 683     a->Print("",opt);
 684     delete a;
 685   }
 686 }
 687
 688 //_____________________________________________________________________________
 689 //Bool_t
 690 //AliMUONCluster::IsEqual(const TObject* obj) const
 691 //{
 692 //  const AliMUONCluster* c = static_cast<const AliMUONCluster*>(obj);
 693 //  if ( c->Multiplicity() != Multiplicity() ) return kFALSE;
 694 //
 695 //  for ( Int_t i = 0; i < c->Multiplicity(); ++i )
 696 //  {
 697 //    AliMUONPad* p = c->Pad(i);
 698 //    if ( p->Compare(Pad(i)) ) return kFALSE;
 699 //  }
 700 //  return kTRUE;
 701 //}
 702
 703 //_____________________________________________________________________________
 704 Int_t
 705 AliMUONCluster::Compare(const TObject* obj) const
 706 {
 707   /// Compare two clusters. Comparison is made on position and rawcharge only.
 708
 709   const AliMUONCluster* cluster = static_cast<const AliMUONCluster*>(obj);
 710
 711   AliMpArea carea(cluster->Area());
 712   AliMpArea area(Area());
 713
 714   if ( carea.Position().X() > area.Position().X() )
 715   {
 716     return 1;
 717   }
 718   else if ( carea.Position().X() < area.Position().X() )
 719   {
 720     return -1;
 721   }
 722   else
 723   {
 724     if ( carea.Position().Y() > area.Position().Y() )
 725     {
 726       return 1;
 727     }
 728     else if ( carea.Position().Y() < area.Position().Y() )
 729     {
 730       return -1;
 731     }
 732     else
 733     {
 734       if ( cluster->RawCharge() > RawCharge() )
 735       {
 736         return 1;
 737       }
 738       else if ( cluster->RawCharge() < RawCharge() )
 739       {
 740         return -1;
 741       }
 742     }
 743   }
 744   return 0;
 745 }
 746
 747 //_____________________________________________________________________________
 748 void
 749 AliMUONCluster::RemovePad(AliMUONPad* pad)
 750 {
 751   /// Remove a pad.
 752   /// As a consequence, some internal information must be updated
 753
 754   fPads->Remove(pad);
 755   fPads->Compress();
 756   // update cluster's data
 757   fIsSaturated[0]=fIsSaturated[1]=kFALSE;
 758   fMultiplicity[0]=fMultiplicity[1]=0;
 759   fRawCharge[0]=fRawCharge[1]=0;
 760   for ( Int_t i = 0; i <= fPads->GetLast(); ++i )
 761   {
 762     AliMUONPad* p = Pad(i);
 763     if ( p->IsSaturated() )
 764     {
 765       fIsSaturated[p->Cathode()] = kTRUE;
 766     }
 767     ++fMultiplicity[p->Cathode()];
 768     fRawCharge[p->Cathode()] += p->Charge();
 769   }
 770 }
 771
 772 //_____________________________________________________________________________
 773 Float_t
 774 AliMUONCluster::RawCharge() const
 775 {
 776   /// Returns the raw average charge
 777   return (RawCharge(0)+RawCharge(1))/2.0;
 778 }
 779
 780 //_____________________________________________________________________________
 781 Float_t
 782 AliMUONCluster::RawCharge(Int_t cathode) const
 783 {
 784   /// Returns the average charge of a given cathode
 785   if ( cathode == 0 || cathode == 1 )
 786   {
 787     return fRawCharge[cathode];
 788   }
 789   return 0;
 790 }
 791
 792 //_____________________________________________________________________________
 793 Float_t
 794 AliMUONCluster::RawChargeAsymmetry() const
 795 {
 796   /// Returns the raw charge asymmetry
 797    if ( RawCharge() > 0 )
 798    {
 799      return TMath::Abs(RawCharge(0)-RawCharge(1))/RawCharge();
 800    }
 801   return 0;
 802 }