#include "AliMUONDigit.h"
-#include "Riostream.h"
-#include "TString.h"
+//-----------------------------------------------------------------------------
+/// \class AliMUONDigit
+/// A class representing a digit (with MC information if possible)
+/// 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 (simulated ones but
+/// including electronic noise and de-calibration, to closely ressemble real ones).
+//-----------------------------------------------------------------------------
+/// \cond CLASSIMP
ClassImp(AliMUONDigit)
-
-namespace
-{
- const UInt_t SATURATEDFLAG = 0x1;
-}
+/// \endcond
//_____________________________________________________________________________
AliMUONDigit::AliMUONDigit()
:
-TObject(),
-fDetElemId(-1),
-fManuId(-1),
-fManuChannel(-1),
-fSignal(0),
+AliMUONVDigit(),
+fDetElemId(0),
+fManuId(0),
+fManuChannel(0),
+fSignal(0.0),
fPadX(-1),
fPadY(-1),
-fCathode(-1),
+fCathode(0),
fADC(0),
fFlags(0),
fNtracks(0),
fTcharges(0x0),
fTracks(0x0),
-fPhysics(0),
-fHit(0)
+fHit(0),
+fTime(0),
+fStatusMap(0)
{
- //
- // Default constructor
- //
+ /// Default constructor
}
//_____________________________________________________________________________
-AliMUONDigit::AliMUONDigit(const AliMUONDigit& digit)
-: TObject(digit),
-fDetElemId(-1),
-fManuId(-1),
-fManuChannel(-1),
-fSignal(0),
+AliMUONDigit::AliMUONDigit(Int_t detElemId, Int_t manuId,
+ Int_t manuChannel, Int_t cathode)
+:
+AliMUONVDigit(detElemId,manuId,manuChannel,cathode),
+fDetElemId(detElemId),
+fManuId(manuId),
+fManuChannel(manuChannel),
+fSignal(0.0),
fPadX(-1),
fPadY(-1),
-fCathode(-1),
+fCathode(cathode),
fADC(0),
fFlags(0),
fNtracks(0),
fTcharges(0x0),
fTracks(0x0),
-fPhysics(0),
-fHit(0)
+fHit(0),
+fTime(0),
+fStatusMap(0)
{
- //
- // copy constructor
- //
- (static_cast<const AliMUONDigit&>(digit)).Copy(*this);
+ /// Normal constructor
}
//_____________________________________________________________________________
-AliMUONDigit::AliMUONDigit(Int_t *digits)
-: TObject(),
-fDetElemId(-1),
-fManuId(-1),
-fManuChannel(-1),
-fSignal(0),
+AliMUONDigit::AliMUONDigit(const AliMUONDigit& digit)
+: AliMUONVDigit(),
+fDetElemId(0),
+fManuId(0),
+fManuChannel(0),
+fSignal(0.0),
fPadX(-1),
fPadY(-1),
-fCathode(-1),
+fCathode(0),
fADC(0),
fFlags(0),
fNtracks(0),
fTcharges(0x0),
fTracks(0x0),
-fPhysics(0),
-fHit(0)
-
+fHit(0),
+fTime(0),
+fStatusMap(0)
{
- //
- // 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;
-}
+ /// Copy constructor
-//_____________________________________________________________________________
-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
- //
- // \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;
-
- // 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;
+ (static_cast<const AliMUONDigit&>(digit)).Copy(*this);
}
//_____________________________________________________________________________
AliMUONDigit::~AliMUONDigit()
{
- //
- // Destructor
- //
+ /// Destructor
+
delete[] fTcharges;
delete[] fTracks;
}
//_____________________________________________________________________________
void
-AliMUONDigit::AddTrack(Int_t trackNumber, Int_t trackCharge)
+AliMUONDigit::AddTrack(Int_t trackNumber, Float_t trackCharge)
{
- //
- // Add 1 track information to the track list we keep.
- // The implementation below is dumb, you've been warned !
- //
+ /// 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.
// 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];
+ Float_t* newTcharges = new Float_t[fNtracks+1];
for ( Int_t i = 0; i < fNtracks; ++i )
{
void
AliMUONDigit::Clear(Option_t*)
{
- //
- // Reset this digit, in particular the internal arrays are deleted.
- //
+ /// Reset this digit, in particular the internal arrays are deleted.
+
delete[] fTracks;
delete[] fTcharges;
fTracks=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.
- //
+ /// Copy this line to line.
+
TObject::Copy(obj);
AliMUONDigit& digit = static_cast<AliMUONDigit&>(obj);
if ( fNtracks )
{
- digit.fTcharges = new Int_t[fNtracks];
+ digit.fTcharges = new Float_t[fNtracks];
digit.fTracks = new Int_t[fNtracks];
}
digit.fTracks[i] = fTracks[i];
}
- digit.fPhysics = fPhysics;
digit.fHit = fHit;
+ digit.fTime = fTime;
+ digit.fStatusMap = fStatusMap;
+}
+
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigit::IsNoiseOnly() const
+{
+ /// Whether this (simulated only) digit is only due to noise.
+
+ return (fFlags & fgkNoiseOnlyMask );
}
//_____________________________________________________________________________
Bool_t
AliMUONDigit::IsSaturated() const
{
- return (fFlags & SATURATEDFLAG );
+ /// Whether this digit is saturated or not.
+
+ return (fFlags & fgkSaturatedMask );
}
//_____________________________________________________________________________
-AliMUONDigit&
-AliMUONDigit::operator=(const AliMUONDigit& digit)
+Bool_t
+AliMUONDigit::IsCalibrated() const
{
- //
- // Assignement operator.
- //
- AliMUONDigit a(digit);
- a.Copy(*this);
- return *this;
+ /// Whether this digit is calibrated or not
+
+ return (fFlags & fgkCalibratedMask );
+}
+
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigit::IsUsed() const
+{
+ /// Whether this digit is used or not (in a cluster, for instance)
+
+ return (fFlags & fgkUsedMask );
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigit::IsEfficiencyApplied() const
+{
+ /// Whether this digit had efficiency applied or not
+
+ return (fFlags & fgkEfficiencyMask );
}
//_____________________________________________________________________________
void
-AliMUONDigit::PatchTracks(Int_t mask)
+AliMUONDigit::Used(Bool_t value)
{
- //
- // Add mask to each track number.
- //
- for ( Int_t i = 0; i < Ntracks(); ++i )
+ /// Set the Used status of this digit.
+
+ if ( value )
{
- fTracks[i] += mask;
+ fFlags |= fgkUsedMask;
+ }
+ else
+ {
+ fFlags &= ~fgkUsedMask;
}
}
//_____________________________________________________________________________
void
-AliMUONDigit::Print(Option_t* opt) const
+AliMUONDigit::Calibrated(Bool_t value)
{
- //
- // Dump to screen.
- // If opt=="tracks", info on tracks are printed too.
- //
- cout << "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() )
+ /// Set the Calibrated status of this digit.
+
+ if ( value )
{
- cout << "(S)";
+ fFlags |= fgkCalibratedMask;
}
else
{
- cout << " ";
+ fFlags &= ~fgkCalibratedMask;
}
- cout << " ADC=" << setw(4) << ADC();
- TString options(opt);
- options.ToLower();
- if ( options.Contains("tracks") )
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::EfficiencyApplied(Bool_t value)
+{
+ /// Set the EfficiencyApplied status of this digit.
+
+ if ( value )
{
- 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.";
- }
+ fFlags |= fgkEfficiencyMask;
+ }
+ else
+ {
+ fFlags &= ~fgkEfficiencyMask;
}
- cout << endl;
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigit::MergeWith(const AliMUONVDigit& src)
+{
+ /// Merge with src.
+
+ Bool_t check = ( src.DetElemId() == DetElemId() &&
+ src.PadX() == PadX() &&
+ src.PadY() == PadY() &&
+ src.Cathode() == Cathode() );
+ if (!check)
+ {
+ return kFALSE;
+ }
+
+ AddCharge(src.Charge());
+ for ( Int_t i = 0; i < src.Ntracks(); ++i )
+ {
+ AddTrack(src.Track(i),src.TrackCharge(i));
+ }
+ return kTRUE;
}
//_____________________________________________________________________________
void
-AliMUONDigit::Saturated(Bool_t value)
+AliMUONDigit::NoiseOnly(Bool_t value)
{
+ /// Set the NoiseOnly status of this digit.
+
if ( value )
{
- fFlags |= SATURATEDFLAG;
+ fFlags |= fgkNoiseOnlyMask;
}
else
{
- fFlags ^= SATURATEDFLAG;
+ fFlags &= ~fgkNoiseOnlyMask;
+ }
+}
+
+//_____________________________________________________________________________
+AliMUONDigit&
+AliMUONDigit::operator=(const AliMUONDigit& digit)
+{
+ /// Assignement operator.
+
+ if ( this != &digit )
+ {
+ digit.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::SetElectronics(Int_t manuId, Int_t manuChannel)
+AliMUONDigit::Saturated(Bool_t value)
{
- //
- //FIXME: should we check that the values are ok here ??
- //
- fManuId=manuId;
- fManuChannel=manuChannel;
+ /// Set the saturation status of this digit.
+
+ if ( value )
+ {
+ fFlags |= fgkSaturatedMask;
+ }
+ else
+ {
+ fFlags &= ~fgkSaturatedMask;
+ }
}
//_____________________________________________________________________________
Int_t
AliMUONDigit::Track(Int_t i) const
{
- //
- // Return the i-th track number (if i is >=0 and < Ntracks()) or -1.
- //
+ /// Return the i-th track number (if i is >=0 and < Ntracks()) or -1.
+
if ( i >= 0 && i < fNtracks )
{
return fTracks[i];
}
//_____________________________________________________________________________
-Int_t
+Float_t
AliMUONDigit::TrackCharge(Int_t i) const
{
- //
- // Return the i-th track charge (if i is >=0 and < Ntracjs()) or -1.
- //
+ /// Return the i-th track charge (if i is >=0 and < Ntracjs()) or -1.
+
if ( i >= 0 && i < fNtracks )
{
return fTcharges[i];
return -1;
}
+
+//_____________________________________________________________________________
+UInt_t
+AliMUONDigit::GetUniqueID() const
+{
+ /// Return a single integer with id information
+
+ return BuildUniqueID(DetElemId(),ManuId(),ManuChannel(),Cathode());
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff