remoe duplicate QA initialisation and do ESD QA for same detectors as RecPoint QA
[u/mrichter/AliRoot.git] / MUON / AliMUONCluster.cxx
CommitLineData
99ccb7f7 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
9edefa04 18#include <Riostream.h>
19#include <TMath.h>
20#include <TObjArray.h>
21#include <TVirtualPad.h>
22#include <TVirtualX.h>
23
99ccb7f7 24#include "AliMUONCluster.h"
25
26#include "AliLog.h"
27#include "AliMUONPad.h"
99ccb7f7 28
3d1463c8 29//-----------------------------------------------------------------------------
99ccb7f7 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///
3d1463c8 39//-----------------------------------------------------------------------------
99ccb7f7 40
41/// \cond CLASSIMP
42ClassImp(AliMUONCluster)
43/// \endcond
44
45namespace
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//_____________________________________________________________________________
97AliMUONCluster::AliMUONCluster()
98: TObject(),
99fPads(0x0),
100fHasPosition(kFALSE),
101fPosition(1E9,1E9),
102fPositionError(1E9,1E9),
103fHasCharge(kFALSE),
00de388f 104fChi2(0)
99ccb7f7 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//_____________________________________________________________________________
114AliMUONCluster::AliMUONCluster(const AliMUONCluster& src)
115: TObject(src),
116fPads(0x0),
117fHasPosition(kFALSE),
118fPosition(1E9,1E9),
119fPositionError(1E9,1E9),
120fHasCharge(kFALSE),
00de388f 121fChi2(0)
99ccb7f7 122{
123 /// copy ctor
124 src.Copy(*this);
125}
126
127//_____________________________________________________________________________
128AliMUONCluster&
129AliMUONCluster::operator=(const AliMUONCluster& src)
130{
131 /// assignement operator
0c8556b9 132 if ( this != &src )
133 {
134 src.Copy(*this);
135 }
99ccb7f7 136 return *this;
137}
138
139//_____________________________________________________________________________
140AliMUONCluster::~AliMUONCluster()
141{
142 /// dtor : note that we're owner of our pads
143 delete fPads;
144}
145
146//_____________________________________________________________________________
147void
00de388f 148AliMUONCluster::Clear(Option_t*)
149{
150 /// Clear our pad array
151 if (fPads) fPads->Clear("C");
152}
153
154//_____________________________________________________________________________
155Bool_t
156AliMUONCluster::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//_____________________________________________________________________________
169void
170AliMUONCluster::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//_____________________________________________________________________________
188AliMUONPad*
99ccb7f7 189AliMUONCluster::AddPad(const AliMUONPad& pad)
190{
191 /// Add a pad to our pad array, and update some internal information
192 /// accordingly.
99ccb7f7 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 }
00de388f 209 return p;
210}
211
212//___________________________________________________________________________
213TString
214AliMUONCluster::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//___________________________________________________________________________
229Bool_t
230AliMUONCluster::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;
99ccb7f7 256}
257
258//_____________________________________________________________________________
259AliMpArea
260AliMUONCluster::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//_____________________________________________________________________________
00de388f 285AliMpArea
286AliMUONCluster::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
cd1f0e79 295 for ( Int_t i = 0; i < Multiplicity(); ++i )
00de388f 296 {
297 AliMUONPad* pad = Pad(i);
cd1f0e79 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 }
00de388f 307 }
308
309 // then construct the area from those limits
310 return AliMpArea((lowerLeft+upperRight)/2,
311 (upperRight-lowerLeft)/2);
312}
313
314//_____________________________________________________________________________
315Int_t
316AliMUONCluster::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//_____________________________________________________________________________
99ccb7f7 341void
342AliMUONCluster::Copy(TObject& obj) const
343{
71a2d3aa 344 ///
345 /// Copy this cluster to (cluster&)obj
346 ///
99ccb7f7 347 TObject::Copy(obj);
348 AliMUONCluster& dest = static_cast<AliMUONCluster&>(obj);
9bf6860b 349 delete dest.fPads;
76305a4a 350 dest.fPads = 0x0;
351 if ( fPads )
352 {
353 dest.fPads = static_cast<TObjArray*>(fPads->Clone());
354 }
99ccb7f7 355 dest.fHasPosition = fHasPosition;
356 dest.fPosition = fPosition;
357 dest.fPositionError = fPositionError;
358 dest.fHasCharge = fHasCharge;
99ccb7f7 359 dest.fChi2 = fChi2;
360 for ( Int_t i = 0; i < 2; ++i )
361 {
362 dest.fRawCharge[i] = fRawCharge[i];
363 dest.fCharge[i] = fCharge[i];
364 dest.fMultiplicity[i] = fMultiplicity[i];
365 dest.fIsSaturated[i] = fIsSaturated[i];
366 }
367}
368
369//_____________________________________________________________________________
370Float_t
371AliMUONCluster::Charge() const
372{
373 /// Return the average charge over both cathodes
530acd78 374
375 if ( Multiplicity(0) && Multiplicity(1) )
376 {
377 return (Charge(0)+Charge(1))/2.0;
378 }
379 else if ( Multiplicity(0) )
380 {
381 return Charge(0);
382 }
383 else if ( Multiplicity(1) )
384 {
385 return Charge(1);
386 }
387 AliError("Should not be here ?!");
388 return -1.0;
99ccb7f7 389}
390
391//_____________________________________________________________________________
392Float_t
393AliMUONCluster::Charge(Int_t cathode) const
394{
395 /// Returns the charge of a given cathode
396 if ( !fHasCharge ) return RawCharge(cathode);
397
398 if ( cathode == 0 || cathode == 1 )
399 {
400 return fCharge[cathode];
401 }
402 return 0;
403}
404
405//_____________________________________________________________________________
406Float_t
407AliMUONCluster::ChargeAsymmetry() const
408{
409 /// Returns the charge asymmetry
410 if ( Charge() > 0 )
411 {
412 return TMath::Abs(Charge(0)-Charge(1))/Charge();
413 }
414 return 0;
415}
416
417//_____________________________________________________________________________
418TVector2
00de388f 419AliMUONCluster::MaxPadDimensions(Int_t statusMask, Bool_t matchMask) const
420{
421 /// Returns the maximum pad dimensions (half sizes), only considering
422 /// pads matching (or not, depending matchMask) a given mask
423
424 TVector2 cath0(MaxPadDimensions(0,statusMask,matchMask));
425 TVector2 cath1(MaxPadDimensions(1,statusMask,matchMask));
426
427 return TVector2( TMath::Max(cath0.X(),cath1.X()),
428 TMath::Max(cath0.Y(),cath1.Y()) );
429}
430
431//_____________________________________________________________________________
432TVector2
433AliMUONCluster::MaxPadDimensions(Int_t cathode,
434 Int_t statusMask, Bool_t matchMask) const
435{
436 /// Returns the maximum pad dimensions (half sizes), only considering
437 /// pads matching (or not, depending matchMask) a given mask, within a
438 /// given cathode
439
440 Double_t xmax(0);
441 Double_t ymax(0);
442
443 for ( Int_t i = 0; i < Multiplicity(); ++i )
444 {
445 AliMUONPad* pad = Pad(i);
446 if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
447 {
448 xmax = TMath::Max(xmax,pad->DX());
449 ymax = TMath::Max(ymax,pad->DY());
450 }
451 }
452 return TVector2(xmax,ymax);
453}
454
455//_____________________________________________________________________________
456TVector2
99ccb7f7 457AliMUONCluster::MinPadDimensions(Int_t statusMask, Bool_t matchMask) const
458{
459 /// Returns the minimum pad dimensions (half sizes), only considering
460 /// pads matching (or not, depending matchMask) a given mask
461
462 TVector2 cath0(MinPadDimensions(0,statusMask,matchMask));
463 TVector2 cath1(MinPadDimensions(1,statusMask,matchMask));
464
465 return TVector2( TMath::Min(cath0.X(),cath1.X()),
466 TMath::Min(cath0.Y(),cath1.Y()) );
467}
468
469//_____________________________________________________________________________
470TVector2
471AliMUONCluster::MinPadDimensions(Int_t cathode,
472 Int_t statusMask, Bool_t matchMask) const
473{
474 /// Returns the minimum pad dimensions (half sizes), only considering
475 /// pads matching (or not, depending matchMask) a given mask, within a
476 /// given cathode
477
478 Double_t xmin(1E9);
479 Double_t ymin(1E9);
480
481 for ( Int_t i = 0; i < Multiplicity(); ++i )
482 {
483 AliMUONPad* pad = Pad(i);
484 if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
485 {
486 xmin = TMath::Min(xmin,pad->DX());
487 ymin = TMath::Min(ymin,pad->DY());
488 }
489 }
490 return TVector2(xmin,ymin);
491}
492
493//_____________________________________________________________________________
494Int_t
495AliMUONCluster::Multiplicity() const
496{
497 /// Returns the total number of pads in this cluster
498 return Multiplicity(0)+Multiplicity(1);
499}
500
501//_____________________________________________________________________________
502Int_t
503AliMUONCluster::Multiplicity(Int_t cathode) const
504{
505 /// Returns the number of pads in this cluster, in the given cathode
506 if ( cathode == 0 || cathode == 1 )
507 {
508 return fMultiplicity[cathode];
509 }
510 return 0;
511}
512
513//_____________________________________________________________________________
514AliMpIntPair
515AliMUONCluster::NofPads(Int_t statusMask, Bool_t matchMask) const
516{
517 /// Number of pads satisfying (or not, depending matchMask) a
518 /// given mask
519
520 Int_t nx, ny;
521
522 TVector2 dim0(MinPadDimensions(0,statusMask,matchMask));
523 TVector2 dim1(MinPadDimensions(1,statusMask,matchMask));
524
525 AliMpIntPair npad0(NofPads(0,statusMask,matchMask));
526 AliMpIntPair npad1(NofPads(1,statusMask,matchMask));
527
528 if ( TMath::Abs( (dim0-dim1).X() ) < 1E-3 )
529 {
530 nx = TMath::Max( npad0.GetFirst(), npad1.GetFirst() );
531 }
532 else
533 {
534 nx = dim0.X() < dim1.X() ? npad0.GetFirst() : npad1.GetFirst();
535 }
536
537 if ( TMath::Abs( (dim0-dim1).Y() ) < 1E-3 )
538 {
539 ny = TMath::Max( npad0.GetSecond(), npad1.GetSecond() );
540 }
541 else
542 {
543 ny = dim0.Y() < dim1.Y() ? npad0.GetSecond() : npad1.GetSecond();
544 }
545
546 return AliMpIntPair(nx,ny);
547}
548
549//_____________________________________________________________________________
550AliMpIntPair
551AliMUONCluster::NofPads(Int_t cathode,
552 Int_t statusMask, Bool_t matchMask) const
553{
554 /// Number of pads of a given cathode, satisfying (or not,
555 /// depending matchMask) a given mask
556
557 Int_t n = Multiplicity(cathode);
558 if (!n)
559 {
560 return AliMpIntPair(0,0);
561 }
562 Double_t* x = new Double_t[n];
563 Double_t* y = new Double_t[n];
564 Int_t np(0);
565
566 for ( Int_t i = 0; i < Multiplicity(); ++i )
567 {
568 AliMUONPad* pad = Pad(i);
569 if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
570 {
571 x[np] = pad->X();
572 y[np] = pad->Y();
573 ++np;
574 }
575 }
576
577 Int_t cx = Unique(np,x,0.01);
578 Int_t cy = Unique(np,y,0.01);
579
580 delete[] x;
581 delete[] y;
582
583 return AliMpIntPair(cx,cy);
584}
585
586//_____________________________________________________________________________
587AliMUONPad*
588AliMUONCluster::Pad(Int_t index) const
589{
590 /// Returns the index-th pad
591
592 if (!fPads) return 0x0;
593 if ( index < fPads->GetLast()+1 )
594 {
595 return static_cast<AliMUONPad*>(fPads->At(index));
596 }
597 else
598 {
00de388f 599 AliError(Form("Requested index %d out of bounds (%d) Mult is %d",index,
600 fPads->GetLast(),Multiplicity()));
601 DumpMe();
99ccb7f7 602 }
603 return 0x0;
604}
605
606
607//_____________________________________________________________________________
608void
609AliMUONCluster::Paint(Option_t*)
610{
611 /// Paint this cluster
612 if (!Multiplicity()) return;
613
614 AliMpArea area(Area());
615
616 gPad->Range(area.LeftBorder(),area.DownBorder(),area.RightBorder(),area.UpBorder());
617
618 gVirtualX->SetFillStyle(0);
619
620 gVirtualX->SetLineColor(2);
621 gVirtualX->SetLineWidth(4);
622 for ( Int_t i = 0; i < Multiplicity(); ++i)
623 {
624 AliMUONPad* pad = Pad(i);
625 if ( pad->Cathode() == 0 ) pad->Paint();
626 }
627
628 gVirtualX->SetLineColor(4);
629 gVirtualX->SetLineWidth(2);
630 for ( Int_t i = 0; i < Multiplicity(); ++i)
631 {
632 AliMUONPad* pad = Pad(i);
633 if ( pad->Cathode() == 1 ) pad->Paint();
634 }
635
636}
637
638//_____________________________________________________________________________
639void
00de388f 640AliMUONCluster::DumpMe() const
641{
642 /// printout
643 cout << "Cluster Id " << GetUniqueID() << " npads=" << Multiplicity()
644 << "(" << Multiplicity(0) << "," << Multiplicity(1) << ") RawCharge="
645 << RawCharge() << " (" << RawCharge(0) << "," << RawCharge(1)
646 << ") Charge=(" << Charge(0) << "," << Charge(1) <<")";
647 if ( HasPosition() )
648 {
649 cout << " (x,y)=(" << Position().X() << "," << Position().Y() << ")";
650 cout << " (errX,errY)=(" << PositionError().X() << "," << PositionError().Y() << ")";
651 }
652 cout << endl;
653// cout << " " << Area() << endl;
654 if (fPads)
655 {
656 for (Int_t i = 0; i < fPads->GetSize(); ++i)
657 {
658 cout << Form("fPads[%d]=%x",i,fPads->At(i)) << endl;
659 if ( fPads->At(i) ) fPads->At(i)->Print();
660 }
661 }
662}
663
664
665//_____________________________________________________________________________
666void
99ccb7f7 667AliMUONCluster::Print(Option_t* opt) const
668{
669 /// printout
670 cout << "Cluster Id " << GetUniqueID() << " npads=" << Multiplicity()
671 << "(" << Multiplicity(0) << "," << Multiplicity(1) << ") RawCharge="
672 << RawCharge() << " (" << RawCharge(0) << "," << RawCharge(1)
97d5019e 673 << ") Charge=(" << Charge(0) << "," << Charge(1) <<")";
99ccb7f7 674 if ( HasPosition() )
675 {
676 cout << " (x,y)=(" << Position().X() << "," << Position().Y() << ")";
677 cout << " (errX,errY)=(" << PositionError().X() << "," << PositionError().Y() << ")";
678 }
00de388f 679 cout << " " << Area();
99ccb7f7 680 if (fPads)
681 {
00de388f 682 TObjArray* a = static_cast<TObjArray*>(fPads->Clone());
683 a->Sort();
684 a->Print("",opt);
685 delete a;
99ccb7f7 686 }
687}
688
689//_____________________________________________________________________________
00de388f 690//Bool_t
691//AliMUONCluster::IsEqual(const TObject* obj) const
692//{
693// const AliMUONCluster* c = static_cast<const AliMUONCluster*>(obj);
694// if ( c->Multiplicity() != Multiplicity() ) return kFALSE;
695//
696// for ( Int_t i = 0; i < c->Multiplicity(); ++i )
697// {
698// AliMUONPad* p = c->Pad(i);
699// if ( p->Compare(Pad(i)) ) return kFALSE;
700// }
701// return kTRUE;
702//}
703
704//_____________________________________________________________________________
705Int_t
706AliMUONCluster::Compare(const TObject* obj) const
99ccb7f7 707{
00de388f 708 /// Compare two clusters. Comparison is made on position and rawcharge only.
709
710 const AliMUONCluster* cluster = static_cast<const AliMUONCluster*>(obj);
711
712 AliMpArea carea(cluster->Area());
713 AliMpArea area(Area());
714
715 if ( carea.Position().X() > area.Position().X() )
716 {
717 return 1;
718 }
719 else if ( carea.Position().X() < area.Position().X() )
720 {
721 return -1;
722 }
723 else
724 {
725 if ( carea.Position().Y() > area.Position().Y() )
726 {
727 return 1;
728 }
729 else if ( carea.Position().Y() < area.Position().Y() )
730 {
731 return -1;
732 }
733 else
734 {
735 if ( cluster->RawCharge() > RawCharge() )
736 {
737 return 1;
738 }
739 else if ( cluster->RawCharge() < RawCharge() )
740 {
741 return -1;
742 }
743 }
744 }
745 return 0;
99ccb7f7 746}
747
748//_____________________________________________________________________________
749void
750AliMUONCluster::RemovePad(AliMUONPad* pad)
751{
752 /// Remove a pad.
753 /// As a consequence, some internal information must be updated
754
755 fPads->Remove(pad);
756 fPads->Compress();
757 // update cluster's data
758 fIsSaturated[0]=fIsSaturated[1]=kFALSE;
759 fMultiplicity[0]=fMultiplicity[1]=0;
760 fRawCharge[0]=fRawCharge[1]=0;
761 for ( Int_t i = 0; i <= fPads->GetLast(); ++i )
762 {
763 AliMUONPad* p = Pad(i);
764 if ( p->IsSaturated() )
765 {
766 fIsSaturated[p->Cathode()] = kTRUE;
767 }
768 ++fMultiplicity[p->Cathode()];
769 fRawCharge[p->Cathode()] += p->Charge();
770 }
99ccb7f7 771}
772
773//_____________________________________________________________________________
774Float_t
775AliMUONCluster::RawCharge() const
776{
777 /// Returns the raw average charge
778 return (RawCharge(0)+RawCharge(1))/2.0;
779}
780
781//_____________________________________________________________________________
782Float_t
783AliMUONCluster::RawCharge(Int_t cathode) const
784{
785 /// Returns the average charge of a given cathode
786 if ( cathode == 0 || cathode == 1 )
787 {
788 return fRawCharge[cathode];
789 }
790 return 0;
791}
792
793//_____________________________________________________________________________
794Float_t
795AliMUONCluster::RawChargeAsymmetry() const
796{
797 /// Returns the raw charge asymmetry
798 if ( RawCharge() > 0 )
799 {
800 return TMath::Abs(RawCharge(0)-RawCharge(1))/RawCharge();
801 }
802 return 0;
803}