X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MUON%2FAliMUONDigit.cxx;h=59aa9f2928fb4c5d5b38ce21bb2fa279d72d1ad9;hb=d95fe39e812f958bb6bc36cee9b0b22ed7ef4f90;hp=c8d8432bf33c9df60ed098f5a75ba61a5c58f124;hpb=a713db22a500de8b3ba697a788794540da4df231;p=u%2Fmrichter%2FAliRoot.git

diff --git a/MUON/AliMUONDigit.cxx b/MUON/AliMUONDigit.cxx
index c8d8432bf33..59aa9f2928f 100644
--- a/MUON/AliMUONDigit.cxx
+++ b/MUON/AliMUONDigit.cxx
@@ -17,39 +17,95 @@
 
 #include "AliMUONDigit.h"
 
+#include "Riostream.h"
+#include "TString.h"
+
+///
+/// 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).
+///
 
 ClassImp(AliMUONDigit)
+
 //_____________________________________________________________________________
- AliMUONDigit::AliMUONDigit(const AliMUONDigit& digits):TObject(digits)
+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)
 {
-// copy constructor
-  
-    fPadX        = digits.fPadX;
-    fPadY        = digits.fPadY;
-    fCathode     = digits.fCathode;
-    fSignal      = digits.fSignal;
-    fPhysics     = digits.fPhysics;
-    fHit         = digits.fHit;
-    fDetElemId   = digits.fDetElemId;
-
-    for(Int_t i=0; i<kMAXTRACKS; i++) {
-	fTcharges[i]  = digits.fTcharges[i];
-	fTracks[i]    = digits.fTracks[i];
-    }
+  //
+  // Default constructor
+  //
 }
 
 //_____________________________________________________________________________
- AliMUONDigit::AliMUONDigit()
-   : TObject()
+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)
 {
-// Default constructor
+  //
+  // 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
+  // \deprecated
   //
     fPadX        = digits[0];
     fPadY        = digits[1];
@@ -58,13 +114,34 @@ AliMUONDigit::AliMUONDigit(Int_t *digits)
     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];
@@ -72,46 +149,340 @@ AliMUONDigit::AliMUONDigit(Int_t *tracks, Int_t *charges, Int_t *digits)
     fPhysics     = digits[4];
     fHit         = digits[5];
     fDetElemId   = digits[6];
-
-    for(Int_t i=0; i<kMAXTRACKS; i++) {
-	fTcharges[i]  = charges[i];
-	fTracks[i]    = tracks[i];
+    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;
 }
 
 //_____________________________________________________________________________
-AliMUONDigit& AliMUONDigit::operator=(const AliMUONDigit& digits)
+Int_t AliMUONDigit::Compare(const TObject *obj) const
 {
-    if (this == &digits)
-      return *this;
- 
-    fPadX        = digits.fPadX;
-    fPadY        = digits.fPadY;
-    fCathode     = digits.fCathode;
-    fSignal      = digits.fSignal;
-    fPhysics     = digits.fPhysics;
-    fHit         = digits.fHit;
-    fDetElemId   = digits.fDetElemId;
+  // 
+  // The order defined below is first by DE, then Signal, then 
+  // manuId, and then manuChannel, i.e. it should be a total ordering...
+  //
 
-    for(Int_t i=0; i<kMAXTRACKS; i++) {
-	fTcharges[i]  = digits.fTcharges[i];
-	fTracks[i]    = digits.fTracks[i];
+  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;
+      }
     }
+  }
+}
 
-    return *this;
+//______________________________________________________________________________
+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;
 }
+
 //_____________________________________________________________________________
-Int_t AliMUONDigit::Compare(const TObject *obj) const
+Bool_t
+AliMUONDigit::IsNoiseOnly() const
 {
-// sort by idDE
+  // Whether this (simulated only) digit is only due to noise.
+  return (fFlags & fgkNoiseOnlyMask );
+}
 
- AliMUONDigit* d = (AliMUONDigit*) obj;
+//_____________________________________________________________________________
+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;
+  }
+}
 
- return ( fDetElemId > d->DetElemId()) ? 1 : -1;
+//_____________________________________________________________________________
+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 << "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;
 }