RawDigit.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \brief   RawDigit class
/// \author  jpaley@indiana.edu
/// \date
////////////////////////////////////////////////////////////////////////
#include "RawData/RawDigit.h"

#include "DAQDataFormats/NanoSliceVersionConvention.h"

#include <iomanip>
#include <iostream>
#include <cassert>

namespace rawdata{
  
  //----------------------------------------------------------------------
  
  RawDigit::RawDigit() :   
    fFrameSequenceNumber(1),
    fFEBStatus(1),
    fDebugMode(false),
    fDataPresent(false),
    fLinkStatus(false),
    fReserved(1),
    fADC(0),
    fTDC(1, 0),
    fVersion(0),  
    fChannel(0),
    fDaqChannel(0),
    fMCBits(0)
  {
  }
  
  //----------------------------------------------------------------------
  
  RawDigit::RawDigit(uint32_t channel,
                     uint32_t daqchannel,
                     std::vector<int16_t> adclist,
                     int32_t tdc) :
    fFrameSequenceNumber(1),
    fFEBStatus(1),
    fDebugMode(false),
    fDataPresent(false),
    fLinkStatus(false),
    fReserved(1),
    fADC(adclist), 
    fTDC(tdc),
    fVersion(0),  
    fChannel(channel),
    fDaqChannel(daqchannel),
    fMCBits(0)
  {
  }
  
  //----------------------------------------------------------------------
  
  //--------------------------------------------------
  int16_t RawDigit::ADC(uint32_t i) const
  {
    if(i > fADC.size()){
      printf("RawDigit::ADC(%d) out of range!\n", i);
    }
    return fADC[i];
  }

  //--------------------------------------------------
  int16_t RawDigit::ADC() const
  {
    if(IsMC() && fVersion == 0 && fADC.size() == 3){
      // This is the old-style MC version of fast timing. ADC(0) is the DCS
      // value.
      return fADC[0];
    }

    static daqdataformats::NanoSliceVersionConvention conv;

    const unsigned int nSamples = conv.getNSamples(fVersion);
    const unsigned int nPretrig = conv.getNPretriggeredSamples(fVersion);

    assert(fADC.size() == nSamples);

    if(fVersion == 0){
      // Version zero is a single DCS value. But I don't see anywhere that
      // tells us it's DCS, so hardcode it. Check all the sizes make sense.
      assert(nSamples == 1);
      assert(nPretrig == 0);

      return fADC[0];
    }

    // Otherwise it's raw and we need to calculate the DCS value for ourselves

    // Otherwise we don't have the peak value in our dataset
    assert(nSamples > nPretrig);

    // Look back 3 samples (1.5us in the FD)
    const unsigned int kDCSDistance = 3;

    // Otherwise we don't have the baseline point in our dataset
    assert(nPretrig >= kDCSDistance);

    // The DCS value is the peak value minus the baseline value
    return fADC[nPretrig]-fADC[nPretrig-kDCSDistance];
  }

  //--------------------------------------------------
  
  void RawDigit::SetADC(uint32_t i, int16_t iADC) {
    if (fADC.size()<i+1) fADC.resize(i+1);
    fADC[i]=iADC;
    return;
  }
  
  //--------------------------------------------------
  
  void RawDigit::SetTDC(int32_t iTDC) {
    assert(fTDC.size() == 1);
    fTDC[0] = iTDC;
  }

  //------------------------------------------------------------
  std::ostream& operator<< (std::ostream& o, const RawDigit& r)
  {
    if(r.IsMC()){
      o << std::setiosflags(std::ios::fixed) << std::setprecision(2);
      o << " Version = "     << std::setw(5) << std::right << (int)r.Version()
        << " NADC = "        << std::setw(5) << std::right << r.NADC();
    }    
    else if (r.IsRealData()){
      o << std::setiosflags(std::ios::fixed) << std::setprecision(2);
      o << " Channel = "     << std::setw(5) << std::right << r.Channel()
        << " Version = "     << std::setw(5) << std::right << (int)r.Version()
        << " NADC = "        << std::setw(5) << std::right << r.NADC();
    }     
    return o;
  }
  
} // end namespace rawdata
//////////////////////////////////////////////////////////////////////////////