RawDigit.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \brief   Definition of basic raw digits
///          TDC and ADC vectors are no longer unsigned.  The DAQ may very well
///          write out negative numbers (especially for the ADC values, which
///          are actually outputs of an algorithm applied to the digitizations.)
/// \author  denis@fnal.gov
/// \date
////////////////////////////////////////////////////////////////////////
#ifndef RAWDIGIT_H
#define RAWDIGIT_H

#ifndef __GCCXML__
#include <iosfwd>
#endif

#include <vector>
#include <stdint.h>

namespace rawdata {
  

#ifndef __GCCXML__

  enum ChanMasks {
    DETECTOR_MASK  = 0XF0000000,
    PLANE_MASK     = 0x0FFFFC00,
    CELL_MASK      = 0X000003FF,
    
    DETECTOR_SHIFT = 28,
    PLANE_SHIFT    = 10,
    CELL_SHIFT     = 0
  };

#endif

  class RawDigit {
  public:
    RawDigit(); // Default constructor
    virtual ~RawDigit() {}; //Destructor

    // Nanoslice parameters
    uint8_t  fFrameSequenceNumber;
    uint8_t  fFEBStatus;
    bool     fDebugMode;
    bool     fDataPresent;
    bool     fLinkStatus;
    uint16_t fReserved;               ///< Should be 0xCAFE
    
    std::vector<int16_t> fADC;        ///< list of ADC(-like) charge values
    std::vector<int32_t> fTDC;        ///< TDC(-like) time value. Event time is subtracted. Vector structure is a historical artifact.
    
    uint8_t   fVersion;               ///< NanoSlice version
    

  private:
    
    uint32_t fChannel;    ///< channel ID
    uint32_t fDaqChannel; ///< DAQ readout channel
    
    // Structure of the fMCBits field:
    //
    // The highest (32nd) bit indicates if this hit originates in data or
    // Monte Carlo. 1 for MC, 0 for data. We set it and read it by masking
    // with (1<<31). It's done this way for historical reasons. One day we
    // should just have a bool, or at least a proper bitfield.
    //
    // Initialization: safest to initialize the field to "0", and then set the
    // MC bit as necessary with the relevant function.

    uint32_t fMCBits;     ///< status bits for MC information

#ifndef __GCCXML__

  public:
    RawDigit(uint32_t channel,
             uint32_t daqchannel,
             std::vector<int16_t> adclist,
             int32_t tdc);

    // Getters (although data members are public)    
    uint32_t   NADC()          const { return fADC.size();       }
    int16_t    ADC(uint32_t i) const; 

    uint32_t   Channel()       const { return fChannel;          }
    uint32_t   DaqChannel()    const { return fDaqChannel;       }

    uint8_t    Version()       const { return fVersion;          }

    /// \brief Best estimator of the hit charge
    ///
    /// The DCS value appropriate for this readout version
    int16_t    ADC()           const;
    /// The time of the last baseline sample
    int32_t    TDC()           const { return fTDC[0];           }

    // Setters
    void       SetADC(uint32_t i, int16_t iADC);
    void       SetTDC(int32_t iTDC);
    void       SetChannel(uint32_t    iChan) { fChannel    = iChan;      }
    void       SetDaqChannel(uint32_t iChan) { fDaqChannel = iChan;      }
    void       SetVersion(uint8_t v) { fVersion = v; }

    // Below here is stuff related to MC hits.
    // Unpack some of the information from fMCBits

    void     SetMC(bool isMC=true) { if(isMC) fMCBits |= (1<<31); else fMCBits = 0; }
    bool     IsRealData() const    { return !this->IsMC();     }
    bool     IsMC()       const    { return fMCBits & (1<<31); }

    friend std::ostream& operator << (std::ostream& o, const RawDigit& r);
#endif // __GCCXML__

  };

}

/* #ifndef __GCCXML__ */

/* uint32_t   rawdata::RawDigit::NADC()                        const { return fADC.size();       } */
/* uint32_t   rawdata::RawDigit::NTDC()                             const { return fTDC.size();       } */
/* uint32_t   rawdata::RawDigit::Channel()                          const { return fChannel;          } */
/* uint32_t   rawdata::RawDigit::DaqChannel()                  const { return fDaqChannel;       } */
/* bool       rawdata::RawDigit::IsRealData()                  const { return !this->IsMC();     } */
/* bool       rawdata::RawDigit::IsMC()                        const { return fMCBits & (1<<31); } */
/* void       rawdata::RawDigit::SetMC()                             { fMCBits |= (1<<31);       } */
/* void       rawdata::RawDigit::SetChannel(uint32_t    iChan)       { fChannel    = iChan;      } */
/* void       rawdata::RawDigit::SetDaqChannel(uint32_t iChan)       { fDaqChannel = iChan;      } */

/* #endif   */


#endif // RAWDIGIT_H