* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.2 2000/06/15 07:58:48 morsch
-Code from MUON-dev joined
+/* $Id$ */
-Revision 1.1.2.1 2000/06/09 22:03:22 morsch
-Was before in DataStructures.cxx
+#include "AliMUONDigit.h"
-*/
+#include "Riostream.h"
+#include "TString.h"
-#include "AliMUONDigit.h"
+/// \class AliMUONDigit
+/// A class representing a digit in the MUON spectrometer
+/// either in tracking or trigger chambers.
+///
+/// A digit holds the signal (proportional to a charge) on a pad
+/// (or strip).
+///
+/// This class is used to represent either sdigits (purely simulated digit,
+/// with no electronic noise whatsoever) or digits (either real digits or
+/// simulated ones but including electronic noise and de-calibration, to
+/// closely ressemble real ones).
+/// \cond CLASSIMP
ClassImp(AliMUONDigit)
+/// \endcond
+
+//_____________________________________________________________________________
+AliMUONDigit::AliMUONDigit()
+:
+TObject(),
+fDetElemId(-1),
+fManuId(-1),
+fManuChannel(-1),
+fSignal(0),
+fPadX(-1),
+fPadY(-1),
+fCathode(-1),
+fADC(0),
+fFlags(0),
+fNtracks(0),
+fTcharges(0x0),
+fTracks(0x0),
+fPhysics(0),
+fHit(0)
+{
+ /// Default constructor
+}
+
+//_____________________________________________________________________________
+AliMUONDigit::AliMUONDigit(const AliMUONDigit& digit)
+: TObject(digit),
+fDetElemId(-1),
+fManuId(-1),
+fManuChannel(-1),
+fSignal(0),
+fPadX(-1),
+fPadY(-1),
+fCathode(-1),
+fADC(0),
+fFlags(0),
+fNtracks(0),
+fTcharges(0x0),
+fTracks(0x0),
+fPhysics(0),
+fHit(0)
+{
+ /// Copy constructor
+
+ (static_cast<const AliMUONDigit&>(digit)).Copy(*this);
+}
+
+
//_____________________________________________________________________________
AliMUONDigit::AliMUONDigit(Int_t *digits)
+: TObject(),
+fDetElemId(-1),
+fManuId(-1),
+fManuChannel(-1),
+fSignal(0),
+fPadX(-1),
+fPadY(-1),
+fCathode(-1),
+fADC(0),
+fFlags(0),
+fNtracks(0),
+fTcharges(0x0),
+fTracks(0x0),
+fPhysics(0),
+fHit(0)
+
{
- //
- // Creates a MUON digit object to be updated
- //
+ /// Creates a MUON digit object to be updated
+ /// \deprecated
+
fPadX = digits[0];
fPadY = digits[1];
fCathode = digits[2];
fSignal = digits[3];
fPhysics = digits[4];
fHit = digits[5];
-
+ fDetElemId = digits[6];
+ fManuId = -1;
+ fManuChannel = -1;
+ fADC=0;
+ fFlags = 0;
}
+
//_____________________________________________________________________________
AliMUONDigit::AliMUONDigit(Int_t *tracks, Int_t *charges, Int_t *digits)
+: TObject(),
+fDetElemId(-1),
+fManuId(-1),
+fManuChannel(-1),
+fSignal(0),
+fPadX(-1),
+fPadY(-1),
+fCathode(-1),
+fADC(0),
+fFlags(0),
+fNtracks(0),
+fTcharges(0x0),
+fTracks(0x0),
+fPhysics(0),
+fHit(0)
{
- //
- // Creates a MUON digit object
- //
+ /// Creates a MUON digit object
+ /// \deprecated
+
fPadX = digits[0];
fPadY = digits[1];
fCathode = digits[2];
fSignal = digits[3];
fPhysics = digits[4];
fHit = digits[5];
-
- for(Int_t i=0; i<10; i++) {
- fTcharges[i] = charges[i];
- fTracks[i] = tracks[i];
+ fDetElemId = digits[6];
+ fManuId = -1;
+ fManuChannel = -1;
+ fADC=0;
+
+ // For backward compatibility, which assumed 10 tracks.
+ fNtracks = 10;
+ fTcharges = new Int_t[fNtracks];
+ fTracks = new Int_t[fNtracks];
+
+ for ( Int_t i=0; i<fNtracks; ++i )
+ {
+ fTcharges[i] = charges[i];
+ fTracks[i] = tracks[i];
}
+ fFlags=0;
}
+//_____________________________________________________________________________
AliMUONDigit::~AliMUONDigit()
{
- // Destructor
+ /// Destructor
+
+ delete[] fTcharges;
+ delete[] fTracks;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::AddTrack(Int_t trackNumber, Int_t trackCharge)
+{
+ /// Add 1 track information to the track list we keep.
+ /// The implementation below is dumb, you've been warned !
+
+ // First check if track is already there, in which
+ // case we simply increment its charge.
+ for ( Int_t i = 0; i < Ntracks(); ++i )
+ {
+ if ( Track(i) == trackNumber )
+ {
+ fTcharges[i] += trackCharge;
+ return;
+ }
+ }
+
+ // Nope. It's a brand new track. Make a new array to get space
+ // for it, copy the old array into new one, and add the track.
+ Int_t* newTracks = new Int_t[fNtracks+1];
+ Int_t* newTcharges = new Int_t[fNtracks+1];
+
+ for ( Int_t i = 0; i < fNtracks; ++i )
+ {
+ newTracks[i] = fTracks[i];
+ newTcharges[i] = fTcharges[i];
+ }
+
+ newTracks[fNtracks] = trackNumber;
+ newTcharges[fNtracks] = trackCharge;
+
+ delete[] fTracks;
+ delete[] fTcharges;
+
+ fTracks = newTracks;
+ fTcharges = newTcharges;
+
+ ++fNtracks;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::Clear(Option_t*)
+{
+ /// Reset this digit, in particular the internal arrays are deleted.
+
+ delete[] fTracks;
+ delete[] fTcharges;
+ fTracks=0x0;
+ fTcharges=0x0;
+ fNtracks=0;
+}
+
+//_____________________________________________________________________________
+Int_t AliMUONDigit::Compare(const TObject *obj) const
+{
+ /// The order defined below is first by DE, then Signal, then
+ /// manuId, and then manuChannel, i.e. it should be a total ordering...
+
+ const AliMUONDigit* d = static_cast<const AliMUONDigit*>(obj);
+
+ if ( DetElemId() > d->DetElemId() )
+ {
+ return 1;
+ }
+ else if ( DetElemId() < d->DetElemId() )
+ {
+ return -1;
+ }
+ else
+ {
+ if ( Signal() > d->Signal() )
+ {
+ return 1;
+ }
+ else if ( Signal() < d->Signal() )
+ {
+ return -1;
+ }
+ else
+ {
+ if ( ManuId() < d->ManuId() )
+ {
+ return 1;
+ }
+ else if ( ManuId() > d->ManuId() )
+ {
+ return -1;
+ }
+ else
+ {
+ return ( ManuChannel() < d->ManuChannel() ) ? 1 : -1;
+ }
+ }
+ }
+}
+
+//______________________________________________________________________________
+void
+AliMUONDigit::Copy(TObject& obj) const
+{
+ /// Copy this line to line.
+
+ TObject::Copy(obj);
+ AliMUONDigit& digit = static_cast<AliMUONDigit&>(obj);
+
+ digit.fDetElemId = fDetElemId;
+ digit.fManuId = fManuId;
+ digit.fManuChannel = fManuChannel;
+ digit.fSignal = fSignal;
+
+ digit.fPadX = fPadX;
+ digit.fPadY = fPadY;
+ digit.fCathode = fCathode;
+ digit.fADC = fADC;
+ digit.fFlags = fFlags;
+
+ digit.fNtracks = fNtracks;
+
+ delete[] digit.fTcharges;
+ delete[] digit.fTracks;
+
+ if ( fNtracks )
+ {
+ digit.fTcharges = new Int_t[fNtracks];
+ digit.fTracks = new Int_t[fNtracks];
+ }
+
+ for ( Int_t i=0; i<fNtracks; ++i )
+ {
+ digit.fTcharges[i] = fTcharges[i];
+ digit.fTracks[i] = fTracks[i];
+ }
+
+ digit.fPhysics = fPhysics;
+ digit.fHit = fHit;
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigit::IsNoiseOnly() const
+{
+ /// Whether this (simulated only) digit is only due to noise.
+
+ return (fFlags & fgkNoiseOnlyMask );
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigit::IsSaturated() const
+{
+ /// Whether this digit is saturated or not.
+
+ return (fFlags & fgkSaturatedMask );
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::NoiseOnly(Bool_t value)
+{
+ /// Set the NoiseOnly status of this digit.
+
+ if ( value )
+ {
+ fFlags |= fgkNoiseOnlyMask;
+ }
+ else
+ {
+ fFlags ^= fgkNoiseOnlyMask;
+ }
+}
+
+//_____________________________________________________________________________
+AliMUONDigit&
+AliMUONDigit::operator=(const AliMUONDigit& digit)
+{
+ /// Assignement operator.
+
+ AliMUONDigit a(digit);
+ a.Copy(*this);
+ return *this;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::PatchTracks(Int_t mask)
+{
+ /// Add mask to each track number.
+
+ for ( Int_t i = 0; i < Ntracks(); ++i )
+ {
+ fTracks[i] += mask;
+ }
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::Print(Option_t* opt) const
+{
+ /// Dump to screen.
+ /// If opt=="tracks", info on tracks are printed too.
+
+ cout << "<AliMUONDigit>: DetEle " << setw(5) << DetElemId()
+ << " Cath " << setw(2) << Cathode()
+ << " (Ix,Iy)=(" << setw(3) << PadX() << "," << setw(3) << PadY()
+ << ") "
+ << " (Manu,Channel)=(" << setw(4) << ManuId()
+ << "," << setw(3) << ManuChannel() << ")"
+ << " Signal=" << setw(6) << Signal()
+ << " Physics=" << setw(4) << Physics();
+ if ( IsSaturated() )
+ {
+ cout << "(S)";
+ }
+ else
+ {
+ cout << " ";
+ }
+ cout << " ADC=" << setw(4) << ADC();
+ cout << " Flags=0x" << setw(4) << hex << setfill('0') << fFlags << dec
+ << setfill(' ');
+ TString options(opt);
+ options.ToLower();
+ if ( options.Contains("tracks") )
+ {
+ cout << " Hit " << setw(3) << Hit();
+ Int_t ntracks = Ntracks();
+ if (ntracks)
+ {
+ cout << " Tracks : " << setw(2) << ntracks;
+ for ( Int_t i = 0; i < ntracks; ++i )
+ {
+ cout << " Track(" << i << ")=" << setw(3) << Track(i)
+ << " Charge(" << i << ")=" << setw(5) << TrackCharge(i);
+ }
+ }
+ else
+ {
+ cout << " no track info.";
+ }
+ }
+ cout << endl;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::Saturated(Bool_t value)
+{
+ /// Set the saturation status of this digit.
+
+ if ( value )
+ {
+ fFlags |= fgkSaturatedMask;
+ }
+ else
+ {
+ fFlags ^= fgkSaturatedMask;
+ }
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::SetElectronics(Int_t manuId, Int_t manuChannel)
+{
+ //
+ //FIXME: should we check that the values are ok here ??
+ //
+ fManuId=manuId;
+ fManuChannel=manuChannel;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONDigit::Track(Int_t i) const
+{
+ /// Return the i-th track number (if i is >=0 and < Ntracks()) or -1.
+
+ if ( i >= 0 && i < fNtracks )
+ {
+ return fTracks[i];
+ }
+
+ return -1;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONDigit::TrackCharge(Int_t i) const
+{
+ /// Return the i-th track charge (if i is >=0 and < Ntracjs()) or -1.
+
+ if ( i >= 0 && i < fNtracks )
+ {
+ return fTcharges[i];
+ }
+
+ return -1;
}