1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 #include "AliMUONPad.h"
21 #include "AliMpArea.h"
23 #include "Riostream.h"
24 #include "TVirtualPad.h"
25 #include "TVirtualX.h"
31 /// Object gathering information about a hit pad.
33 /// Can be seen as a combination of a Digit (which brings the charge)
34 /// and an MpPad (which brings location and position)
36 /// Also provided are some static functions to compute overlap and
37 /// get neighboring information.
39 /// \author Laurent Aphecetche
48 Intersect(const AliMpArea& a, const AliMpArea& b)
51 // Returns the common part of a and b.
53 Double_t xmin = TMath::Max(a.LeftBorder(),b.LeftBorder());
54 Double_t xmax = TMath::Min(a.RightBorder(),b.RightBorder());
55 Double_t ymin = TMath::Max(a.DownBorder(),b.DownBorder());
56 Double_t ymax = TMath::Min(a.UpBorder(),b.UpBorder());
57 AliMpArea c( TVector2( (xmin+xmax)/2.0, (ymin+ymax)/2.0 ),
58 TVector2( (xmax-xmin)/2.0, (ymax-ymin)/2.0 ) );
64 //_____________________________________________________________________________
65 AliMUONPad::AliMUONPad()
83 Init(-1,-1,-1,-1,TVector2(0,0),TVector2(0,0),0);
86 //_____________________________________________________________________________
87 AliMUONPad::AliMUONPad(Int_t detElemId, Int_t cathode,
88 Int_t ix, Int_t iy, Double_t x, Double_t y,
89 Double_t dx, Double_t dy, Double_t charge)
107 /// Normal ctor, using full information
108 Init(detElemId,cathode,ix,iy,TVector2(x,y),TVector2(dx,dy),charge);
111 //_____________________________________________________________________________
112 AliMUONPad::AliMUONPad(Double_t x, Double_t y,
113 Double_t dx, Double_t dy, Double_t charge)
115 fIsSaturated(kFALSE),
129 /// Truncated constructor (w/o DE, cath, ix, iy)
130 Init(-1,-1,-1,-1,TVector2(x,y),TVector2(dx,dy),charge);
133 //_____________________________________________________________________________
134 AliMUONPad::AliMUONPad(const TVector2& position, const TVector2& dimensions,
137 fIsSaturated(kFALSE),
152 Init(-1,-1,-1,-1,position,dimensions,charge);
155 //_____________________________________________________________________________
157 AliMUONPad::AreNeighbours(const AliMUONPad& d1, const AliMUONPad& d2)
159 /// Whether 2 pads are neighbours or not
160 if ( d1.DetElemId() != d2.DetElemId() ||
161 d1.Cathode() != d2.Cathode() )
167 static Double_t precision = 1E-4; // cm
168 static TVector2 precisionAdjustment(-precision,-precision);
169 return AreOverlapping(d1,d2,precisionAdjustment);
173 //_____________________________________________________________________________
175 AliMUONPad::AreOverlapping(const AliMUONPad& d1, const AliMUONPad& d2,
176 const TVector2& precision)
178 /// Checks the overlap between 2 pads.
179 /// The actual overlap is computed not on d1 and d2, but on d1 and d2
180 /// "re-scaled" using the precision vector (conceptually equivalent to
181 /// d.Dimensions() += precision)
183 /// So, if the elements (x,y) of precision are :
185 /// - positive, the overlap is "computed" from smaller d1 and d2
186 /// which is, modulo the precision, what you would think as a normal
187 /// overlap calculation
188 /// - negative, overlap is from "bigger" d1 and d2, which is usefull to "tweek"
189 /// what we call an overlap, e.g. to consider 2 pads touching only by their
190 /// corners to be overlapping.
192 AliMpArea a1(d1.Position(),d1.Dimensions());
193 AliMpArea a2(d2.Position(),d2.Dimensions());
195 if ( a1.LeftBorder() > a2.RightBorder() - precision.X() ||
196 a1.RightBorder() < a2.LeftBorder() + precision.X() )
201 if ( a1.DownBorder() > a2.UpBorder() - precision.Y() ||
202 a1.UpBorder() < a2.DownBorder() + precision.Y() )
209 //_____________________________________________________________________________
211 AliMUONPad::AreOverlapping(const AliMUONPad& d1, const AliMUONPad& d2,
212 const TVector2& precision,
213 AliMpArea& overlapRegion)
215 /// Checks the overlap between 2 pads, and returns the overlap area
217 /// See comments on the other AreOverlapping method, too : in this
218 /// method, the overlapRegion does *not* depend on the precision parameter,
219 /// which is only used to decide whether the pads are overlapping, while
220 /// the actual overlap region is computed w/o reference to precision.
222 if ( AreOverlapping(d1,d2,precision) )
224 overlapRegion = Overlap(d1,d2);
225 if ( !overlapRegion.IsValid() )
227 cerr << "Something is wrong : the 2 pads below are flagged as overlapping"
228 << ", but the overlapRegion is not valid"
238 //_____________________________________________________________________________
240 AliMUONPad::Compare(const TObject* obj) const
243 /// Ordering is as complete as possible.
245 const AliMUONPad* pad = static_cast<const AliMUONPad*>(obj);
247 if ( DetElemId() > pad->DetElemId() )
251 else if ( DetElemId() > pad->DetElemId() )
258 if ( Cathode() > pad->Cathode() )
262 else if ( Cathode() < pad->Cathode() )
269 if ( Ix() > pad->Ix() )
273 else if ( Ix() < pad->Ix() )
280 if ( Iy() > pad->Iy() )
284 else if ( Iy() < pad->Iy() )
291 if ( X() > pad->X() )
295 else if ( X() < pad->X() )
302 if ( Y() > pad->Y() )
306 else if ( Y() < pad->Y() )
313 return ( Charge() < pad->Charge() ) ? -1:1;
322 //_____________________________________________________________________________
324 AliMUONPad::Coord(Int_t ixy) const
326 /// To be friendly and backward compatible with AZ code, which
327 /// used that kind of coordinate accessing.
337 AliError(Form("Incorrect coordinates index %d (only 0,1 are valid)",ixy));
341 //_____________________________________________________________________________
343 AliMUONPad::Init(Int_t detElemId, Int_t cathode,
345 const TVector2& position,
346 const TVector2& dimensions,
349 /// Called by all the ctors
350 fIsSaturated = kFALSE;
352 fDetElemId = detElemId;
356 fPosition = position;
357 fDimensions = dimensions;
359 fChargeBackup = fCharge;
367 //_____________________________________________________________________________
369 AliMUONPad::Overlap(const AliMUONPad& d1, const AliMUONPad& d2)
371 /// Return the overlap region between two pads
372 AliMpArea a1(d1.Position(),d1.Dimensions());
373 AliMpArea a2(d2.Position(),d2.Dimensions());
374 return Intersect(a1,a2);
378 //_____________________________________________________________________________
380 AliMUONPad::Paint(Option_t*)
382 /// Paint pad on screen
383 TVector2 ll = Position() - Dimensions();
384 TVector2 ur = Position() + Dimensions();
386 gPad->PaintBox(ll.X(),ll.Y(),ur.X(),ur.Y());
389 //_____________________________________________________________________________
391 AliMUONPad::Print(Option_t* opt) const
397 ios_base::fmtflags oldflags = cout.flags();
398 if ( Cathode() >= 0 )
400 cout << "DetEle " << setw(5) << DetElemId()
401 << " Cath " << setw(2) << Cathode()
402 << " (Ix,Iy)=(" << setw(3) << Ix() << "," << setw(3) << Iy() << ") ";
404 cout.setf(ios::fixed);
406 cout << " (x,y)=(" << setw(9) << X() << "," << setw(9) << Y() << ") "
407 << " (dx,dy)=(" << setw(9) << DX() << "," << setw(9) << DY() << ") "
410 cout << setw(7) << Charge();
411 if ( sopt.Contains("full") )
414 << " Used=" << (IsUsed()?Form("YES (ClusterId %d)",fClusterId):"NO")
415 << (IsSaturated()?"(S)":" ")
416 << (IsReal()?" ":"(V)")
417 << " Status=" << setw(4) << Status()
418 << " ChargeBackup=" << ChargeBackup();
420 if ( sopt.Contains("corners") )
422 cout << Form(" (xmin,xmax)=(%e,%e) (ymin,ymax)=(%e,%e)",
424 Y()-DY(),Y()+DY()) << endl;
427 cout.flags(oldflags);
430 //_____________________________________________________________________________
432 AliMUONPad::SetCoord(Int_t ixy, Double_t coord)
434 /// Set the pad coordinate (ixy=0 means x, ixy=1 means y)
437 fPosition.Set(coord,Y());
441 fPosition.Set(X(),coord);
445 AliError(Form("Incorrect coordinates index %d (only 0,1 are valid)",ixy));
449 //_____________________________________________________________________________
451 AliMUONPad::SetSize(Int_t ixy, Double_t size)
453 /// Set the pad half size (ixy=0 means x half size, ixy=1 means y half size)
456 fDimensions.Set(size,DY());
460 fDimensions.Set(DX(),size);
464 AliError(Form("Incorrect coordinates index %d (only 0,1 are valid)",ixy));
468 //_____________________________________________________________________________
470 AliMUONPad::Shift(Int_t ixy, Double_t shift)
472 /// Shift the position by "shift"
473 SetCoord(ixy,Coord(ixy)+shift);
476 //_____________________________________________________________________________
478 AliMUONPad::Size(Int_t ixy) const
480 /// Returns the half size along a direction, given by ixy
481 /// (see SetSize for ixy meaning)
491 AliError(Form("Incorrect coordinates index %d (only 0,1 are valid)",ixy));