[u/mrichter/AliRoot.git] / MUON / AliMUONCluster.cxx

/**************************************************************************
* 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 "AliLog.h"
#include "AliMUONPad.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
///

/// \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(0x0),
fHasPosition(kFALSE),
fPosition(1E9,1E9),
fPositionError(1E9,1E9),
fHasCharge(kFALSE),
fChi2(0),
fIsSorted(kFALSE)
{
  /// ctor
  fMultiplicity[0]=fMultiplicity[1]=0;
  fRawCharge[0]=fRawCharge[1]=0;
  fCharge[0]=fCharge[1]=0;
  fIsSaturated[0]=fIsSaturated[1]=kFALSE;
}

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

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

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

//_____________________________________________________________________________
void
AliMUONCluster::AddPad(const AliMUONPad& pad)
{
  /// Add a pad to our pad array, and update some internal information
  /// accordingly.
  /// If pad array was sorted prior to this call, we re-sort it after
  /// actual addition.
  
  if (!fPads) 
  {
    fPads = new TObjArray(10);
    fPads->SetOwner(kTRUE);
  }
  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;
  }
  if ( fIsSorted ) Sort();
}

//_____________________________________________________________________________
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)/2,
                   (upperRight-lowerLeft)/2);
}

//_____________________________________________________________________________
void
AliMUONCluster::Copy(TObject& obj) const
{
  ///
  /// Copy this cluster to (cluster&)obj
  ///
  TObject::Copy(obj);
  AliMUONCluster& dest = static_cast<AliMUONCluster&>(obj);
  dest.fPads = static_cast<TObjArray*>(fPads->Clone());
  dest.fHasPosition = fHasPosition;
  dest.fPosition = fPosition;
  dest.fPositionError = fPositionError;
  dest.fHasCharge = fHasCharge;
  dest.fIsSorted = fIsSorted;
  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
  return (Charge(0)+Charge(1))/2.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::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;
}

//_____________________________________________________________________________
AliMpIntPair
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));
  
  AliMpIntPair npad0(NofPads(0,statusMask,matchMask));
  AliMpIntPair npad1(NofPads(1,statusMask,matchMask));
  
  if ( TMath::Abs( (dim0-dim1).X() ) < 1E-3 )
  {
    nx = TMath::Max( npad0.GetFirst(), npad1.GetFirst() );
  }
  else
  {
    nx = dim0.X() < dim1.X() ? npad0.GetFirst() : npad1.GetFirst();
  }
  
  if ( TMath::Abs( (dim0-dim1).Y() ) < 1E-3 )
  {
    ny = TMath::Max( npad0.GetSecond(), npad1.GetSecond() );
  }
  else
  {
    ny = dim0.Y() < dim1.Y() ? npad0.GetSecond() : npad1.GetSecond();
  }
  
  return AliMpIntPair(nx,ny);
}

//_____________________________________________________________________________
AliMpIntPair
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 AliMpIntPair(0,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 AliMpIntPair(cx,cy);
}

//_____________________________________________________________________________
AliMUONPad*
AliMUONCluster::Pad(Int_t index) const
{
  /// Returns the index-th pad
  
  if (!fPads) return 0x0;
  if ( index < fPads->GetLast()+1 )
  {
    return static_cast<AliMUONPad*>(fPads->At(index));
  }
  else
  {
    AliError(Form("Requesting index %d out of bounds (%d)",index,fPads->GetLast()));
  }
  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::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() << endl;
  if (fPads) 
  {
    fPads->Print("",opt);
  }
}

//_____________________________________________________________________________
void
AliMUONCluster::Sort()
{
  /// Sort the pad array
  fPads->Sort();
  fIsSorted = kTRUE;
}

//_____________________________________________________________________________
void
AliMUONCluster::RemovePad(AliMUONPad* pad)
{
  /// Remove a pad. 
  /// As a consequence, some internal information must be updated
  
  fPads->Remove(pad);
  fPads->Compress();
  // 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();
  }
  if (fIsSorted) Sort();
}

//_____________________________________________________________________________
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;
}
Commit	Line	Data
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
	29	/// \class AliMUONCluster
	30	///
	31	/// A group of adjacent pads
	32	///
	33	/// Besides holding an internal array of AliMUONPads, this object
	34	/// also computes some global characteristics for that pad sets.
	35	///
	36	/// \author Laurent Aphecetche
	37	///
	38
	39	/// \cond CLASSIMP
	40	ClassImp(AliMUONCluster)
	41	/// \endcond
	42
	43	namespace
	44	{
	45	//___________________________________________________________________________
	46	Bool_t
	47	ShouldUsePad(const AliMUONPad& pad,
	48	Int_t cathode, Int_t statusMask, Bool_t matchMask)
	49	{
	50
	51	// FIXME : we should only use >=0 status, so we can fully
	52	// use masking possibility ?
	53	if ( pad.Status() < 0 ) return kFALSE;
	54
	55	if ( pad.Cathode() == cathode && pad.IsReal() && !pad.IsSaturated() )
	56	{
	57	Bool_t test = ( ( pad.Status() & statusMask ) != 0 );
	58	if ( !statusMask )
	59	{
	60	test = ( pad.Status() == 0 );
	61	}
	62	if ( ( test && matchMask ) \|\| ( !test && !matchMask ) )
	63	{
	64	return kTRUE;
	65	}
	66	}
	67	return kFALSE;
	68	}
	69
	70	//___________________________________________________________________________
	71	Int_t Unique(Int_t n, Double_t* array, Double_t precision)
	72	{
	73	/// Return the number of different elements in array
	74	/// where different is up to precision
	75	/// Note that we assume that n is >= 1
	76
	77	Int_t count(1);
	78
	79	Int_t* index = new Int_t[n];
	80
	81	TMath::Sort(n,array,index);
	82
	83	for ( Int_t i = 1; i < n; ++i )
	84	{
	85	if ( array[index[i]] - array[index[i-1]] < -precision ) ++count;
	86	}
	87
	88	delete[] index;
	89
	90	return count;
	91	}
92	}
93
94	//_____________________________________________________________________________
95	AliMUONCluster::AliMUONCluster()
96	: TObject(),
97	fPads(0x0),
98	fHasPosition(kFALSE),
99	fPosition(1E9,1E9),
100	fPositionError(1E9,1E9),
101	fHasCharge(kFALSE),
102	fChi2(0),
103	fIsSorted(kFALSE)
104	{
105	/// ctor
106	fMultiplicity[0]=fMultiplicity[1]=0;
107	fRawCharge[0]=fRawCharge[1]=0;
108	fCharge[0]=fCharge[1]=0;
109	fIsSaturated[0]=fIsSaturated[1]=kFALSE;
110	}
111
112	//_____________________________________________________________________________
113	AliMUONCluster::AliMUONCluster(const AliMUONCluster& src)
114	: TObject(src),
115	fPads(0x0),
116	fHasPosition(kFALSE),
117	fPosition(1E9,1E9),
118	fPositionError(1E9,1E9),
119	fHasCharge(kFALSE),
120	fChi2(0),
121	fIsSorted(kFALSE)
122	{
123	/// copy ctor
124	src.Copy(*this);
125	}
126
127	//_____________________________________________________________________________
128	AliMUONCluster&
129	AliMUONCluster::operator=(const AliMUONCluster& src)
130	{
131	/// assignement operator
132	AliMUONCluster c(src);
133	c.Copy(*this);
134	return *this;
135	}
136
137	//_____________________________________________________________________________
138	AliMUONCluster::~AliMUONCluster()
139	{
140	/// dtor : note that we're owner of our pads
141	delete fPads;
142	}
143
144	//_____________________________________________________________________________
145	void
146	AliMUONCluster::AddPad(const AliMUONPad& pad)
147	{
148	/// Add a pad to our pad array, and update some internal information
149	/// accordingly.
150	/// If pad array was sorted prior to this call, we re-sort it after
151	/// actual addition.
152
153	if (!fPads)
154	{
155	fPads = new TObjArray(10);
156	fPads->SetOwner(kTRUE);
157	}
158	AliMUONPad* p = new AliMUONPad(pad);
159	fPads->AddLast(p);
160	p->SetClusterId(GetUniqueID());
161	Int_t cathode = p->Cathode();
162	++(fMultiplicity[cathode]);
163	fRawCharge[cathode] += p->Charge();
164	if ( p->IsSaturated() )
165	{
166	fIsSaturated[p->Cathode()]=kTRUE;
167	}
168	if ( fIsSorted ) Sort();
169	}
170
171	//_____________________________________________________________________________
172	AliMpArea
173	AliMUONCluster::Area() const
174	{
175	/// Return the geometrical area covered by this cluster
176
177	// Start by finding the (x,y) limits of this cluster
178	TVector2 lowerLeft(1E9,1E9);
179	TVector2 upperRight(-1E9,-1E9);
180
181	for ( Int_t i = 0; i < Multiplicity(); ++i )
182	{
183	AliMUONPad* pad = Pad(i);
184	TVector2 ll = pad->Position() - pad->Dimensions();
185	TVector2 ur = pad->Position() + pad->Dimensions();
186	lowerLeft.Set( TMath::Min(ll.X(),lowerLeft.X()),
187	TMath::Min(ll.Y(),lowerLeft.Y()) );
188	upperRight.Set( TMath::Max(ur.X(),upperRight.X()),
189	TMath::Max(ur.Y(),upperRight.Y()) );
190	}
191
192	// then construct the area from those limits
193	return AliMpArea((lowerLeft+upperRight)/2,
194	(upperRight-lowerLeft)/2);
195	}
196
197	//_____________________________________________________________________________
198	void
199	AliMUONCluster::Copy(TObject& obj) const
200	{
71a2d3aa	201	///
	202	/// Copy this cluster to (cluster&)obj
	203	///
99ccb7f7	204	TObject::Copy(obj);
	205	AliMUONCluster& dest = static_cast<AliMUONCluster&>(obj);
	206	dest.fPads = static_cast<TObjArray*>(fPads->Clone());
	207	dest.fHasPosition = fHasPosition;
	208	dest.fPosition = fPosition;
	209	dest.fPositionError = fPositionError;
	210	dest.fHasCharge = fHasCharge;
	211	dest.fIsSorted = fIsSorted;
	212	dest.fChi2 = fChi2;
	213	for ( Int_t i = 0; i < 2; ++i )
	214	{
	215	dest.fRawCharge[i] = fRawCharge[i];
	216	dest.fCharge[i] = fCharge[i];
	217	dest.fMultiplicity[i] = fMultiplicity[i];
	218	dest.fIsSaturated[i] = fIsSaturated[i];
	219	}
	220	}
	221
	222	//_____________________________________________________________________________
	223	Float_t
	224	AliMUONCluster::Charge() const
	225	{
	226	/// Return the average charge over both cathodes
	227	return (Charge(0)+Charge(1))/2.0;
	228	}
	229
	230	//_____________________________________________________________________________
	231	Float_t
	232	AliMUONCluster::Charge(Int_t cathode) const
	233	{
	234	/// Returns the charge of a given cathode
	235	if ( !fHasCharge ) return RawCharge(cathode);
	236
	237	if ( cathode == 0 \|\| cathode == 1 )
	238	{
	239	return fCharge[cathode];
	240	}
	241	return 0;
	242	}
	243
	244	//_____________________________________________________________________________
	245	Float_t
	246	AliMUONCluster::ChargeAsymmetry() const
	247	{
	248	/// Returns the charge asymmetry
	249	if ( Charge() > 0 )
	250	{
	251	return TMath::Abs(Charge(0)-Charge(1))/Charge();
	252	}
	253	return 0;
	254	}
	255
	256	//_____________________________________________________________________________
	257	TVector2
	258	AliMUONCluster::MinPadDimensions(Int_t statusMask, Bool_t matchMask) const
	259	{
	260	/// Returns the minimum pad dimensions (half sizes), only considering
	261	/// pads matching (or not, depending matchMask) a given mask
	262
	263	TVector2 cath0(MinPadDimensions(0,statusMask,matchMask));
	264	TVector2 cath1(MinPadDimensions(1,statusMask,matchMask));
	265
	266	return TVector2( TMath::Min(cath0.X(),cath1.X()),
	267	TMath::Min(cath0.Y(),cath1.Y()) );
268	}
269
270	//_____________________________________________________________________________
271	TVector2
272	AliMUONCluster::MinPadDimensions(Int_t cathode,
273	Int_t statusMask, Bool_t matchMask) const
274	{
275	/// Returns the minimum pad dimensions (half sizes), only considering
276	/// pads matching (or not, depending matchMask) a given mask, within a
277	/// given cathode
278
279	Double_t xmin(1E9);
280	Double_t ymin(1E9);
281
282	for ( Int_t i = 0; i < Multiplicity(); ++i )
283	{
284	AliMUONPad* pad = Pad(i);
285	if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
286	{
287	xmin = TMath::Min(xmin,pad->DX());
288	ymin = TMath::Min(ymin,pad->DY());
289	}
290	}
291	return TVector2(xmin,ymin);
292	}
293
294	//_____________________________________________________________________________
295	Int_t
296	AliMUONCluster::Multiplicity() const
297	{
298	/// Returns the total number of pads in this cluster
299	return Multiplicity(0)+Multiplicity(1);
300	}
301
302	//_____________________________________________________________________________
303	Int_t
304	AliMUONCluster::Multiplicity(Int_t cathode) const
305	{
306	/// Returns the number of pads in this cluster, in the given cathode
307	if ( cathode == 0 \|\| cathode == 1 )
308	{
309	return fMultiplicity[cathode];
310	}
311	return 0;
312	}
313
314	//_____________________________________________________________________________
315	AliMpIntPair
316	AliMUONCluster::NofPads(Int_t statusMask, Bool_t matchMask) const
317	{
318	/// Number of pads satisfying (or not, depending matchMask) a
319	/// given mask
320
321	Int_t nx, ny;
322
323	TVector2 dim0(MinPadDimensions(0,statusMask,matchMask));
324	TVector2 dim1(MinPadDimensions(1,statusMask,matchMask));
325
326	AliMpIntPair npad0(NofPads(0,statusMask,matchMask));
327	AliMpIntPair npad1(NofPads(1,statusMask,matchMask));
328
329	if ( TMath::Abs( (dim0-dim1).X() ) < 1E-3 )
330	{
331	nx = TMath::Max( npad0.GetFirst(), npad1.GetFirst() );
332	}
333	else
334	{
335	nx = dim0.X() < dim1.X() ? npad0.GetFirst() : npad1.GetFirst();
336	}
337
338	if ( TMath::Abs( (dim0-dim1).Y() ) < 1E-3 )
339	{
340	ny = TMath::Max( npad0.GetSecond(), npad1.GetSecond() );
341	}
342	else
343	{
344	ny = dim0.Y() < dim1.Y() ? npad0.GetSecond() : npad1.GetSecond();
345	}
346
347	return AliMpIntPair(nx,ny);
348	}
349
350	//_____________________________________________________________________________
351	AliMpIntPair
352	AliMUONCluster::NofPads(Int_t cathode,
353	Int_t statusMask, Bool_t matchMask) const
354	{
355	/// Number of pads of a given cathode, satisfying (or not,
356	/// depending matchMask) a given mask
357
358	Int_t n = Multiplicity(cathode);
359	if (!n)
360	{
361	return AliMpIntPair(0,0);
362	}
363	Double_t* x = new Double_t[n];
364	Double_t* y = new Double_t[n];
365	Int_t np(0);
366
367	for ( Int_t i = 0; i < Multiplicity(); ++i )
368	{
369	AliMUONPad* pad = Pad(i);
370	if ( ShouldUsePad(*pad,cathode,statusMask,matchMask) )
371	{
372	x[np] = pad->X();
373	y[np] = pad->Y();
374	++np;
375	}
376	}
377
378	Int_t cx = Unique(np,x,0.01);
379	Int_t cy = Unique(np,y,0.01);
380
381	delete[] x;
382	delete[] y;
383
384	return AliMpIntPair(cx,cy);
385	}
386
387	//_____________________________________________________________________________
388	AliMUONPad*
389	AliMUONCluster::Pad(Int_t index) const
390	{
391	/// Returns the index-th pad
392
393	if (!fPads) return 0x0;
394	if ( index < fPads->GetLast()+1 )
395	{
396	return static_cast<AliMUONPad*>(fPads->At(index));
397	}
398	else
399	{
400	AliError(Form("Requesting index %d out of bounds (%d)",index,fPads->GetLast()));
401	}
402	return 0x0;
403	}
404
405
406	//_____________________________________________________________________________
407	void
408	AliMUONCluster::Paint(Option_t*)
409	{
410	/// Paint this cluster
411	if (!Multiplicity()) return;
412
413	AliMpArea area(Area());
414
415	gPad->Range(area.LeftBorder(),area.DownBorder(),area.RightBorder(),area.UpBorder());
416
417	gVirtualX->SetFillStyle(0);
418
419	gVirtualX->SetLineColor(2);
420	gVirtualX->SetLineWidth(4);
421	for ( Int_t i = 0; i < Multiplicity(); ++i)
422	{
423	AliMUONPad* pad = Pad(i);
424	if ( pad->Cathode() == 0 ) pad->Paint();
425	}
426
427	gVirtualX->SetLineColor(4);
428	gVirtualX->SetLineWidth(2);
429	for ( Int_t i = 0; i < Multiplicity(); ++i)
430	{
431	AliMUONPad* pad = Pad(i);
432	if ( pad->Cathode() == 1 ) pad->Paint();
433	}
434
435	}
436
437	//_____________________________________________________________________________
438	void
439	AliMUONCluster::Print(Option_t* opt) const
440	{
441	/// printout
442	cout << "Cluster Id " << GetUniqueID() << " npads=" << Multiplicity()
443	<< "(" << Multiplicity(0) << "," << Multiplicity(1) << ") RawCharge="
444	<< RawCharge() << " (" << RawCharge(0) << "," << RawCharge(1)
97d5019e	445	<< ") Charge=(" << Charge(0) << "," << Charge(1) <<")";
99ccb7f7	446	if ( HasPosition() )
	447	{
	448	cout << " (x,y)=(" << Position().X() << "," << Position().Y() << ")";
	449	cout << " (errX,errY)=(" << PositionError().X() << "," << PositionError().Y() << ")";
	450	}
97d5019e	451	cout << " " << Area() << endl;
99ccb7f7	452	if (fPads)
	453	{
	454	fPads->Print("",opt);
	455	}
	456	}
	457
	458	//_____________________________________________________________________________
	459	void
	460	AliMUONCluster::Sort()
	461	{
	462	/// Sort the pad array
	463	fPads->Sort();
	464	fIsSorted = kTRUE;
	465	}
	466
	467	//_____________________________________________________________________________
	468	void
	469	AliMUONCluster::RemovePad(AliMUONPad* pad)
	470	{
	471	/// Remove a pad.
	472	/// As a consequence, some internal information must be updated
	473
	474	fPads->Remove(pad);
	475	fPads->Compress();
	476	// update cluster's data
	477	fIsSaturated[0]=fIsSaturated[1]=kFALSE;
	478	fMultiplicity[0]=fMultiplicity[1]=0;
	479	fRawCharge[0]=fRawCharge[1]=0;
	480	for ( Int_t i = 0; i <= fPads->GetLast(); ++i )
	481	{
	482	AliMUONPad* p = Pad(i);
	483	if ( p->IsSaturated() )
	484	{
	485	fIsSaturated[p->Cathode()] = kTRUE;
	486	}
	487	++fMultiplicity[p->Cathode()];
	488	fRawCharge[p->Cathode()] += p->Charge();
	489	}
	490	if (fIsSorted) Sort();
	491	}
	492
	493	//_____________________________________________________________________________
	494	Float_t
	495	AliMUONCluster::RawCharge() const
	496	{
	497	/// Returns the raw average charge
	498	return (RawCharge(0)+RawCharge(1))/2.0;
	499	}
	500
	501	//_____________________________________________________________________________
	502	Float_t
	503	AliMUONCluster::RawCharge(Int_t cathode) const
	504	{
	505	/// Returns the average charge of a given cathode
	506	if ( cathode == 0 \|\| cathode == 1 )
	507	{
	508	return fRawCharge[cathode];
	509	}
	510	return 0;
	511	}
	512
	513	//_____________________________________________________________________________
	514	Float_t
	515	AliMUONCluster::RawChargeAsymmetry() const
516	{
517	/// Returns the raw charge asymmetry
518	if ( RawCharge() > 0 )
519	{
520	return TMath::Abs(RawCharge(0)-RawCharge(1))/RawCharge();
521	}
522	return 0;
523	}