Added 4 data members : manuId, manuChannel (to ease calibration data access),

ADC (to keep an uncalibrated version of the digit) and IsSaturated (to allow the
clustering to readily know if a digit is saturated or not)
(Laurent)

diff --git a/MUON/AliMUONDigit.cxx b/MUON/AliMUONDigit.cxx
index 46f1f8fbeb1aae196a41188ffa662df427a5dac3..9efe145a499ff358658c952973b43c0d7c7a8b66 100644 (file)
--- a/MUON/AliMUONDigit.cxx
+++ b/MUON/AliMUONDigit.cxx
@@ -17,46 +17,81 @@
 
 #include "AliMUONDigit.h"
 
+#include "Riostream.h"
+#include "TString.h"
 
 ClassImp(AliMUONDigit)
+
 //_____________________________________________________________________________
- AliMUONDigit::AliMUONDigit(const AliMUONDigit& digits):TObject(digits)
+AliMUONDigit::AliMUONDigit()
+: TObject(),
+fPadX(0),
+fPadY(0),
+fCathode(0),
+fSignal(0),
+fPhysics(0),
+fHit(0),
+fDetElemId(0),
+fManuId(-1),
+fManuChannel(-1),
+fADC(0),
+fIsSaturated(kFALSE)
 {
-// copy constructor
+  // Default 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] = 0;
+    fTracks[i] = 0;
+  }
+}
 
-    for(Int_t i=0; i<kMAXTRACKS; i++) {
-       fTcharges[i]  = digits.fTcharges[i];
-       fTracks[i]    = digits.fTracks[i];
-    }
+//_____________________________________________________________________________
+AliMUONDigit::AliMUONDigit(const AliMUONDigit& digit)
+  : TObject(digit)
+{
+  // copy constructor
+ 
+   (static_cast<const AliMUONDigit&>(digit)).Copy(*this);
 }
 
+
 //_____________________________________________________________________________
- AliMUONDigit::AliMUONDigit()
-   : TObject(),
-     fPadX(0),
-     fPadY(0),
-     fCathode(0),
-     fSignal(0),
-     fPhysics(0),
-     fHit(0),
-     fDetElemId(0)
-{
-// Default constructor
+AliMUONDigit::~AliMUONDigit()
+{
+  // Destructor 
+}
 
-    for(Int_t i=0; i<kMAXTRACKS; i++) {
-       fTcharges[i]  = 0;
-       fTracks[i]    = 0;
-    }
+//_____________________________________________________________________________
+AliMUONDigit& 
+AliMUONDigit::operator=(const AliMUONDigit& digit)
+{
+  AliMUONDigit a(digit);
+  a.Copy(*this);
+  return *this;
 }
 
+//______________________________________________________________________________
+void 
+AliMUONDigit::Copy(TObject& obj) const
+{
+  // Copy this line to line.
+  
+  TObject::Copy(obj);
+  AliMUONDigit& digit = static_cast<AliMUONDigit&>(obj);
+  digit.fPadX = fPadX;
+  digit.fPadY = fPadY;
+  digit.fCathode = fCathode;
+  digit.fSignal = fSignal;
+  digit.fHit = fHit;
+  digit.fDetElemId = fDetElemId;
+  digit.fManuId = fManuId;
+  digit.fManuChannel = fManuChannel;
+  digit.fADC = fADC;
+  digit.fIsSaturated = fIsSaturated;
+}
+
+
 //_____________________________________________________________________________
 AliMUONDigit::AliMUONDigit(Int_t *digits)
 {
@@ -70,6 +105,10 @@ AliMUONDigit::AliMUONDigit(Int_t *digits)
     fPhysics     = digits[4];
     fHit         = digits[5];
     fDetElemId   = digits[6];
+    fManuId = -1;
+    fManuChannel = -1;
+    fADC=0;
+    fIsSaturated = kFALSE;
 }
 //_____________________________________________________________________________
 AliMUONDigit::AliMUONDigit(Int_t *tracks, Int_t *charges, Int_t *digits)
@@ -84,46 +123,111 @@ AliMUONDigit::AliMUONDigit(Int_t *tracks, Int_t *charges, Int_t *digits)
     fPhysics     = digits[4];
     fHit         = digits[5];
     fDetElemId   = digits[6];
-
+    fManuId = -1;
+    fManuChannel = -1;
+    fADC=0;
     for(Int_t i=0; i<kMAXTRACKS; i++) {
-       fTcharges[i]  = charges[i];
-       fTracks[i]    = tracks[i];
+      fTcharges[i]  = charges[i];
+      fTracks[i]    = tracks[i];
     }
+    fIsSaturated=kFALSE;
 }
 
-AliMUONDigit::~AliMUONDigit()
+//_____________________________________________________________________________
+Int_t AliMUONDigit::Compare(const TObject *obj) const
 {
-    // Destructor 
+// sort by idDE
+
+ AliMUONDigit* d = (AliMUONDigit*) obj;
+
+ return ( fDetElemId > d->DetElemId()) ? 1 : -1;
+
 }
 
 //_____________________________________________________________________________
-AliMUONDigit& AliMUONDigit::operator=(const AliMUONDigit& digits)
+void
+AliMUONDigit::Print(Option_t* opt) 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;
+  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 ( fIsSaturated ) 
+  {
+    cout << "(S)";
+  }
+  else
+  {
+    cout << "   ";
+  }
+  cout << " ADC=" << setw(4) << ADC();
+  TString options(opt);
+  options.ToLower();
+  if ( options.Contains("tracks") )
+  {
+    cout << " Track0=" << setw(3) << Track(0) 
+    << " Charge0=" << setw(4) << TrackCharge(0)
+    << " Track1=" << setw(3) << Track(1) 
+    << " Charge1=" << setw(4) << TrackCharge(1);
+  }
+  cout << endl;  
+}
 
-    for(Int_t i=0; i<kMAXTRACKS; i++) {
-       fTcharges[i]  = digits.fTcharges[i];
-       fTracks[i]    = digits.fTracks[i];
-    }
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigit::IsSaturated() const
+{
+  return fIsSaturated;
+}
 
-    return *this;
+//_____________________________________________________________________________
+Int_t
+AliMUONDigit::ManuId() const
+{
+  return fManuId;
 }
+
 //_____________________________________________________________________________
-Int_t AliMUONDigit::Compare(const TObject *obj) const
+Int_t
+AliMUONDigit::ManuChannel() const
 {
-// sort by idDE
+  return fManuChannel;
+}
 
- AliMUONDigit* d = (AliMUONDigit*) obj;
+//_____________________________________________________________________________
+Int_t 
+AliMUONDigit::ADC() const
+{
+  return fADC;
+}
 
- return ( fDetElemId > d->DetElemId()) ? 1 : -1;
+//_____________________________________________________________________________
+void
+AliMUONDigit::SetADC(Int_t adc)
+{
+  fADC = adc;
+}
 
+//_____________________________________________________________________________
+void
+AliMUONDigit::SetElectronics(Int_t manuId, Int_t manuChannel)
+{
+  //
+  //FIXME: should we check that the values are ok here ??
+  //
+  fManuId=manuId;
+  fManuChannel=manuChannel;
 }
+
+//_____________________________________________________________________________
+void
+AliMUONDigit::Saturated(Bool_t saturated)
+{
+  fIsSaturated=saturated;
+}
+
+

diff --git a/MUON/AliMUONDigit.h b/MUON/AliMUONDigit.h
index e8af975c2c3393c72629163787075b7467a2c06b..4b94ea10c66320e8d9cf79968e75ec081a14e460 100644 (file)
--- a/MUON/AliMUONDigit.h
+++ b/MUON/AliMUONDigit.h
@@ -28,38 +28,58 @@ class AliMUONDigit : public TObject {
     virtual Bool_t IsSortable() const {return kTRUE;}
     virtual int Compare(const TObject *obj) const;
 
-    virtual Int_t    DetElemId()const     {return fDetElemId;}
-    virtual Int_t    PadX() const         {return fPadX;}
-    virtual Int_t    PadY() const         {return fPadY;}
-    virtual Int_t    Signal() const       {return fSignal;}
-    virtual Int_t    Physics() const      {return fPhysics;}
-    virtual Int_t    Hit() const          {return fHit;}    
-    virtual Int_t    Cathode() const      {return fCathode;}
-    virtual Int_t    Track(Int_t i) const {return fTracks[i];}
-    virtual Int_t    TrackCharge(Int_t i) const {return fTcharges[i];} 
-
-    virtual void     SetDetElemId(Int_t id)    {fDetElemId = id;}
-    virtual void     SetPadX(Int_t pad)        {fPadX = pad;}
-    virtual void     SetPadY(Int_t pad)        {fPadY = pad;}
-    virtual void     SetSignal(Int_t q)        {fSignal = q;}
-    virtual void     AddSignal(Int_t q)        {fSignal += q;}
-    virtual void     AddPhysicsSignal(Int_t q) {fPhysics += q;}
-    virtual void     SetHit(Int_t n)           {fHit = n;}    
-    virtual void     SetCathode(Int_t c)       {fCathode = c;}
-  
-           
+    virtual Int_t DetElemId()const     {return fDetElemId;}
+    virtual Int_t PadX() const         {return fPadX;}
+    virtual Int_t PadY() const         {return fPadY;}
+    virtual Int_t Cathode() const      {return fCathode;}
+    
+    virtual Int_t Signal() const       {return fSignal;}
+    
+    virtual Int_t Physics() const      {return fPhysics;}
+    
+    virtual Int_t Hit() const          {return fHit;}    
+    virtual Int_t Track(Int_t i) const {return fTracks[i];}
+    virtual Int_t TrackCharge(Int_t i) const {return fTcharges[i];} 
+    
+    virtual Int_t ADC() const;
+    virtual Int_t ManuId() const;
+    virtual Int_t ManuChannel() const;
+    virtual Bool_t IsSaturated() const;
+    
+    virtual void Saturated(Bool_t saturated=kTRUE);
+    virtual void SetElectronics(Int_t manuId, Int_t manuChannel);
+    virtual void SetADC(Int_t adc);
+    virtual void SetDetElemId(Int_t id)    {fDetElemId = id;}
+    virtual void SetPadX(Int_t pad)        {fPadX = pad;}
+    virtual void SetPadY(Int_t pad)        {fPadY = pad;}
+    virtual void SetSignal(Int_t q)        {fSignal = q;}
+    virtual void AddSignal(Int_t q)        {fSignal += q;}
+    virtual void AddPhysicsSignal(Int_t q) {fPhysics += q;}
+    virtual void SetHit(Int_t n)           {fHit = n;}    
+    virtual void SetCathode(Int_t c)       {fCathode = c;}
+    virtual void SetPhysicsSignal(Int_t q) {fPhysics = q; }
+    
+    virtual void Print(Option_t* opt="") const;
+    
+    virtual void Copy(TObject& digit) const;
+    
  private:
-    Int_t     fPadX;          // Pad number along x
-    Int_t     fPadY;          // Pad number along y
-    Int_t     fCathode;       // Cathode number
+    Int_t fPadX;          // Pad number along x
+    Int_t fPadY;          // Pad number along y
+    Int_t fCathode;       // Cathode number
     
-    Int_t     fSignal;        // Signal amplitude
-    Int_t     fTcharges[kMAXTRACKS];  // charge per track making this digit (up to 10)
-    Int_t     fTracks[kMAXTRACKS];    // primary tracks making this digit (up to 10)
-    Int_t     fPhysics;       // physics contribution to signal 
-    Int_t     fHit;           // hit number - temporary solution
-    Int_t     fDetElemId;     // Detection element ID
+    Int_t fSignal;        // Signal amplitude
+    Int_t fTcharges[kMAXTRACKS];  // charge per track making this digit (up to 10)
+    Int_t fTracks[kMAXTRACKS];    // primary tracks making this digit (up to 10)
+    Int_t fPhysics;       // physics contribution to signal 
+    Int_t fHit;           // hit number - temporary solution
+    Int_t fDetElemId;     // Detection element ID
 
-    ClassDef(AliMUONDigit,2)  //Digits for MUON
+    Int_t fManuId; // Id of the MANU chip.
+    Int_t fManuChannel; // Channel within the MANU chip.
+    Int_t fADC; // ADC value
+    Bool_t fIsSaturated; // Is the signal an overflow ? 
+    
+    ClassDef(AliMUONDigit,3)  //Digits for MUON
 };
 #endif