RawDigit.h

Go to the documentation of this file.

#ifndef RAWDATA_RAWDIGIT_H
#define RAWDATA_RAWDIGIT_H

// C/C++ standard libraries
#include <stdint.h> // uint32_t
#include <cstdlib> // size_t
#include <vector>
// #include <bitset>

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h" // raw::Compress_t, raw::Channel_t


namespace raw {
  
  class RawDigit {

  public:
    typedef std::vector<short> ADCvector_t;
    
/*
// removed waiting for a real use for flags
    typedef std::bitset<16> Flags_t;
*/
    
    RawDigit();
    
  public:
    
  /*
    // removed waiting for a real use for flags
    typedef enum {
      fiSaturation,       ///< saturation flag: set if saturated at any time
      NLArSoftFlags = 8,  ///< LArSoft reserves flags up to here (this excluded)
      NFlagIndices = NLArSoftFlags ///< number of flags
    } FlagIndices_t; ///< type of index of flags
  */
    
    RawDigit(ChannelID_t        channel,
             unsigned short     samples,
             ADCvector_t const& adclist,
             raw::Compress_t    compression = raw::kNone /*,
             const Flags_t&     flags = DefaultFlags */
             );
    
    RawDigit(ChannelID_t        channel,
             unsigned short     samples,
             ADCvector_t&&      adclist,
             raw::Compress_t    compression = raw::kNone /*,
             const Flags_t&     flags = DefaultFlags */
             );
    
    void            SetPedestal(float ped, float sigma = 1.);
    
    
    const ADCvector_t& ADCs()     const;
    
    size_t          NADC()        const;
    
    short           ADC(int i)    const;
    
    ChannelID_t     Channel()     const;
    
    unsigned short  Samples()     const;
    
    float           GetPedestal() const;
    
    float           GetSigma()    const;
    
    raw::Compress_t Compression() const;
    
  /*
    // removed waiting for a real use for flags
    const Flags_t&  Flags() const;
    
    bool            isSaturated() const;
    
    // the unsigned long long thing is from std::bitset<> constructors
    static const unsigned long long SaturationBit = 1ULL << fiSaturation;
    
    static const unsigned long long DefaultFlags  = 0ULL;
    
  */
    
    
  private:
    std::vector<short> fADC;      
    
    ChannelID_t     fChannel;     
    unsigned short  fSamples;     
    
    float           fPedestal;    
    float           fSigma;       
    
    Compress_t      fCompression; 
    

    // removed waiting for a real use for flags
    // Flags_t         fFlags;       ///< set of digit flags
    
  }; // class RawDigit
  
  
} // namespace raw


//------------------------------------------------------------------------------
//--- inline implementation
//---

inline size_t          raw::RawDigit::NADC()        const { return fADC.size();  }
inline short           raw::RawDigit::ADC(int i)    const { return fADC.at(i);   }
inline const raw::RawDigit::ADCvector_t&
                       raw::RawDigit::ADCs()        const { return fADC;         }
inline raw::ChannelID_t
                       raw::RawDigit::Channel()     const { return fChannel;     }
inline unsigned short  raw::RawDigit::Samples()     const { return fSamples;     }
inline float           raw::RawDigit::GetPedestal() const { return fPedestal;    }
inline float           raw::RawDigit::GetSigma()    const { return fSigma;       }
inline raw::Compress_t raw::RawDigit::Compression() const { return fCompression; }
/*
// removed waiting for a real use for flags
inline const raw::RawDigit::Flags_t&
                       raw::RawDigit::Flags()       const { return fFlags;       }
inline bool            raw::RawDigit::isSaturated() const { return fFlags.test(fiSaturation); }
*/


#endif // RAWDATA_RAWDIGIT_H