RawDigit.h

Go to the documentation of this file.

#ifndef RAWDATA_RAWDIGIT_H
#define RAWDATA_RAWDIGIT_H

// C/C++ standard libraries
#include <cstdlib> // size_t
#include <vector>

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

// ROOT includes
#include "RtypesCore.h"

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,
             ULong64_t samples,
             ADCvector_t const& adclist,
             raw::Compress_t compression = raw::kNone /*,
             const Flags_t&     flags = DefaultFlags */
    );

    RawDigit(ChannelID_t channel,
             ULong64_t 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;

    ULong64_t 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; 
    ULong64_t 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 ULong64_t 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