X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MUON%2FAliMUONDigit.cxx;h=d3e7f53c602719aacb08290f11268648b459465e;hb=ef0672a13bee60c63cfdbb49a87b11757a37c510;hp=c08778727c2945c441b6a118f340d22f252f2945;hpb=4b1670dcf59a6bdc98e9805e1049c85143099084;p=u%2Fmrichter%2FAliRoot.git

diff --git a/MUON/AliMUONDigit.cxx b/MUON/AliMUONDigit.cxx
index c08778727c2..d3e7f53c602 100644
--- a/MUON/AliMUONDigit.cxx
+++ b/MUON/AliMUONDigit.cxx
@@ -13,75 +13,448 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.5  2001/10/31 16:40:07  jchudoba
-change preprocessor constant to C++ constant
+/* $Id$ */
 
-Revision 1.4  2001/10/18 14:44:09  jchudoba
-Define constant MAXTRACKS for maximum number of tracks associated with 1 digit
+#include "AliMUONDigit.h"
 
-Revision 1.3  2001/01/26 21:26:58  morsch
-All data members private. Access functions provided.
+/// \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).
 
-Revision 1.2  2000/06/15 07:58:48  morsch
-Code from MUON-dev joined
+/// \cond CLASSIMP
+ClassImp(AliMUONDigit)
+/// \endcond
 
-Revision 1.1.2.1  2000/06/09 22:03:22  morsch
-Was before in DataStructures.cxx
+//_____________________________________________________________________________
+AliMUONDigit::AliMUONDigit()
+: 
+AliMUONVDigit(),
+fDetElemId(0),
+fManuId(0),
+fManuChannel(0),
+fSignal(0.0),
+fPadX(-1),
+fPadY(-1),
+fCathode(0),
+fADC(0),
+fFlags(0),
+fNtracks(0),
+fTcharges(0x0),
+fTracks(0x0),
+fHit(0),
+fStatusMap(0)
+{
+  /// Default constructor
+}
 
-*/
+//_____________________________________________________________________________
+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(cathode),
+fADC(0),
+fFlags(0),
+fNtracks(0),
+fTcharges(0x0),
+fTracks(0x0),
+fHit(0),
+fStatusMap(0)
+{
+  /// Normal constructor
+}
 
-#include "AliMUONDigit.h"
 
-#include <iostream.h>
+//_____________________________________________________________________________
+AliMUONDigit::AliMUONDigit(const AliMUONDigit& digit)
+: AliMUONVDigit(),
+fDetElemId(0),
+fManuId(0),
+fManuChannel(0),
+fSignal(0.0),
+fPadX(-1),
+fPadY(-1),
+fCathode(0),
+fADC(0),
+fFlags(0),
+fNtracks(0),
+fTcharges(0x0),
+fTracks(0x0),
+fHit(0),
+fStatusMap(0)
+{
+  /// Copy constructor
+
+   (static_cast<const AliMUONDigit&>(digit)).Copy(*this);
+}
 
-ClassImp(AliMUONDigit)
 //_____________________________________________________________________________
-AliMUONDigit::AliMUONDigit(Int_t *digits)
+AliMUONDigit::~AliMUONDigit()
 {
-  //
-  // Creates a MUON digit object to be updated
-  //
-    fPadX        = digits[0];
-    fPadY        = digits[1];
-    fCathode     = digits[2];
-    fSignal      = digits[3];
-    fPhysics     = digits[4];
-    fHit         = digits[5];
+  /// Destructor 
 
+  delete[] fTcharges;
+  delete[] fTracks;
 }
+
+//_____________________________________________________________________________
+void
+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 !
+  
+  // 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];
+  Float_t* newTcharges = new Float_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;
+}
+
 //_____________________________________________________________________________
-AliMUONDigit::AliMUONDigit(Int_t *tracks, Int_t *charges, Int_t *digits)
+void 
+AliMUONDigit::Clear(Option_t*)
 {
-    //
-    // Creates a MUON digit object
-    //
-    fPadX        = digits[0];
-    fPadY        = digits[1];
-    fCathode     = digits[2];
-    fSignal      = digits[3];
-    fPhysics     = digits[4];
-    fHit         = digits[5];
+  /// Reset this digit, in particular the internal arrays are deleted.
 
-    for(Int_t i=0; i<kMAXTRACKS; i++) {
-	fTcharges[i]  = charges[i];
-	fTracks[i]    = tracks[i];
+  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 ( Charge() > d->Charge() )
+    {
+      return 1;
+    }
+    else if ( Charge() < d->Charge() )
+    {
+      return -1;
     }
+    else
+    {
+      if ( ManuId() < d->ManuId() )
+      {
+        return 1;
+      }
+      else if ( ManuId() > d->ManuId() )
+      {
+        return -1;
+      }
+      else
+      {
+        return ( ManuChannel() < d->ManuChannel() ) ? 1 : -1;
+      }
+    }
+  }
 }
 
-AliMUONDigit::~AliMUONDigit()
+//______________________________________________________________________________
+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 Float_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.fHit = fHit;
+  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
+{
+  /// Whether this digit is saturated or not.
+
+  return (fFlags & fgkSaturatedMask );
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigit::IsCalibrated() const
+{
+  /// 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::Used(Bool_t value)
+{
+  /// Set the Used status of this digit.
+  
+  if ( value )
+  {
+    fFlags |= fgkUsedMask;
+  }
+  else
+  {
+    fFlags ^= fgkUsedMask;
+  }
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::Calibrated(Bool_t value)
+{
+  /// Set the Calibrated status of this digit.
+  
+  if ( value )
+  {
+    fFlags |= fgkCalibratedMask;
+  }
+  else
+  {
+    fFlags ^= fgkCalibratedMask;
+  }
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::EfficiencyApplied(Bool_t value)
 {
-    // Destructor 
+  /// Set the EfficiencyApplied status of this digit.
+  
+  if ( value )
+  {
+    fFlags |= fgkEfficiencyMask;
+  }
+  else
+  {
+    fFlags ^= fgkEfficiencyMask;
+  }
 }
 
-////////////////////////////////////////////////////////////////////////
-void AliMUONDigit::Print(Option_t *option) const 
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigit::MergeWith(const AliMUONVDigit& src)
 {
-  // print
-  cout<<"fPadX, fPadY, fCathode, fSignal, fPhysics, fHit: \n";
-  cout<<"   "<<fPadX<<" "<<fPadY<<" "<<fCathode<<" "
-      <<fSignal<<" "<<fPhysics<<" "<<fHit<<endl;
+  /// 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::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::Saturated(Bool_t value)
+{
+  /// 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.
+
+  if ( i >= 0 && i < fNtracks ) 
+  {
+    return fTracks[i];
+  }
+
+  return -1;
+}
+
+//_____________________________________________________________________________
+Float_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;
+}
+
+//_____________________________________________________________________________
+UInt_t
+AliMUONDigit::GetUniqueID() const
+{
+  /// Return a single integer with id information
+
+  return BuildUniqueID(DetElemId(),ManuId(),ManuChannel(),Cathode());
+}