Line data    Source code

       1             : #ifndef ALIITSCHANNELDASSD_H
       2             : #define ALIITSCHANNELDASSD_H
       3             : 
       4             : /* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
       5             :  * See cxx source for full Copyright notice                               */
       6             : /*                                                                        */
       7             : /* $Id$ */
       8             : 
       9             : ///////////////////////////////////////////////////////////////////////////////
      10             : ///
      11             : /// This class provides storage container ITS SSD channel callibration data
      12             : /// used by DA. 
      13             : ///
      14             : ///////////////////////////////////////////////////////////////////////////////
      15             : 
      16             : #include "TObject.h"
      17             : 
      18             : 
      19             : class AliITSChannelDaSSD : public TObject {
      20             :   public :
      21             :     AliITSChannelDaSSD();
      22             :     explicit AliITSChannelDaSSD(const UShort_t stripId);
      23             :     AliITSChannelDaSSD(const UShort_t stripId, const Long_t eventsnumber);
      24             :     AliITSChannelDaSSD(const AliITSChannelDaSSD& strip);
      25             :     AliITSChannelDaSSD& operator = (const AliITSChannelDaSSD& strip);
      26             :     virtual ~AliITSChannelDaSSD();
      27             :     
      28           0 :     UShort_t  GetStripId() const { return fStripId; }
      29           0 :     Long_t    GetEventsNumber() const { return fEventsNumber; }
      30           0 :     Short_t*  GetSignal()  const { return fSignal; }
      31             :     Short_t   GetSignal(const Long_t eventnumber)  const 
      32           0 :                            { return (eventnumber < fEventsNumber && fSignal) ? *(fSignal+eventnumber) : fgkDefaultSignal; }
      33             :     
      34           0 :     Float_t  GetPedestal() const { return fPedestal; }
      35           0 :     Float_t  GetNoise()    const { return fNoise;    }
      36           0 :     Float_t  GetNoiseCM()  const { return fNoiseCM;  }
      37           0 :     Long_t   GetOverflowNumber() const { return fNOverflowEv; }
      38           0 :     Bool_t   CheckNoise()   const { return (fNoise < fgkUndefinedValue) ? kTRUE : kFALSE; }
      39           0 :     Bool_t   CheckNoiseCM() const { return (fNoiseCM < fgkUndefinedValue) ? kTRUE : kFALSE; }
      40             : 
      41             :     Bool_t    SetEvenetsNumber(const Long_t eventsnumber);
      42             :     Bool_t    SetSignal(const Long_t eventnumber, const Short_t signal);
      43           0 :     void      SetStripId(const UShort_t stripId) { fStripId = stripId; }
      44             : 
      45           0 :     void      SetPedestal(Float_t pedestal) { fPedestal = pedestal; }
      46           0 :     void      SetNoise(Float_t noise)   { fNoise = noise; }
      47           0 :     void      SetNoiseCM(Float_t noise) { fNoiseCM = noise; }
      48           0 :     void      SetOverflowNumber(Long_t ovn) {fNOverflowEv = ovn; }
      49           0 :     void      ClearNoise() { if (fNoise < fgkUndefinedValue) fNoise = fgkUndefinedValue; }
      50           0 :     void      ClearNoiseCM() { if (fNoiseCM < fgkUndefinedValue) fNoiseCM = fgkUndefinedValue; }
      51           0 :     void      ClearPedestal() { if (fPedestal < fgkUndefinedValue) fPedestal = fgkUndefinedValue; }
      52           0 :     void      ClearSignal() { if (fSignal) for (Int_t i = 0; i < fEventsNumber; i++) 
      53           0 :                                              fSignal[i] = 0x100 * fgkDefaultSignal + fgkDefaultSignal; }
      54           0 :     void      DeleteSignal() { if (fSignal) { delete [] fSignal; fSignal = NULL; fEventsNumber = 0;} }
      55             : 
      56           0 :     static  Short_t  GetOverflowConst()  { return fgkSignalOverflow;  }
      57           0 :     static  Short_t  GetUnderflowConst() { return fgkSignalUnderflow; }
      58           0 :     static  Float_t  GetUndefinedValue() { return fgkUndefinedValue;  }
      59           0 :     static  Short_t  GetMaxStripIdConst(){ return fgkMaxStripId;      }
      60             : 
      61             :   protected :
      62             :     static const Short_t fgkMinStripId;         // minimum strip id
      63             :     static const Short_t fgkMaxStripId;         // maximum strip id
      64             : 
      65             :     static const Short_t  fgkSignalOverflow;     // ADC overflow value
      66             :     static const Short_t  fgkSignalUnderflow;    // ADC underflow value
      67             :     static const UShort_t fgkDefaultSignal;      // initialization value for fNoise, fPedestal, fSignal[i]
      68             :     static const Float_t  fgkUndefinedValue;     // constant value which indicates that fNoise, fPedestal is undefined
      69             :   
      70             :     UShort_t          fStripId;             //  channel = strip number within SSD module 0-1535
      71             :     Long_t            fEventsNumber;        //  number of events for fSignal memory allocation
      72             :     Short_t          *fSignal;              //! array of signal data
      73             :     
      74             :     Float_t           fPedestal;            //  pedestal
      75             :     Float_t           fNoise;               //  noise
      76             :     Float_t           fNoiseCM;             //  noise with CM correction
      77             :     Long_t            fNOverflowEv;         //  Number of events which exceed the pedestal calculation threshold
      78             :                       
      79         118 :     ClassDef(AliITSChannelDaSSD, 3)
      80             : };
      81             : 
      82             : #endif