SKAParallelUnpacker.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2023 by Willem van Straten and Andrew Jameson
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __dsp_Kernel_Formats_ska1_SKAParallelUnpacker
#define __dsp_Kernel_Formats_ska1_SKAParallelUnpacker
 
#include "dsp/ParallelUnpacker.h"
#include <assert.h>
 
namespace dsp {
 
  class SKAParallelUnpacker : public ParallelUnpacker
  {
  public:
 
    SKAParallelUnpacker ();
 
    ~SKAParallelUnpacker ();
 
    void configure (const Observation* observation);
 
    bool matches (const Observation* observation) const override;
 
    void match (const Observation* observation);
 
  protected:
 
    void unpack ();
 
  private:
 
    float get_scale_factor(const unsigned char * weights, uint32_t packet_number);
 
    template <typename T>
    void unpack_samples(const T* in, const unsigned char * weights, uint32_t nheaps)
    {
      const uint32_t nval_per_packet = nsamp_per_packet * ndim;
      const uint32_t nsamp = nheaps * nsamp_per_packet;
 
      assert (output->get_ndat() == nsamp);
      assert (output->get_nchan() == nchan);
      assert (output->get_ndim() == ndim);
      assert (nchan == npackets_per_heap * nchan_per_packet);
 
      // Unpack quantised data store in heap, packet, pol, chan_block, samp_block ordering used in CBF/PSR formats
      uint32_t packet_number = 0;
      for (uint32_t iheap=0; iheap<nheaps; iheap++)
      {
        // number of values that are offset for the heap
        const uint32_t heap_val_offset = (iheap * nsamp_per_packet) * ndim;
 
        for (uint32_t ipacket=0; ipacket<npackets_per_heap; ipacket++)
        {
          const float scale_factor = get_scale_factor(weights, packet_number);
          const float multiplier = (std::isnan(scale_factor) || scale_factor<=0.0) ? 0.0 : 1.0 / scale_factor;
 
          if (std::isnan(scale_factor))
          {
            invalid_packets++;
          }
 
          for (uint32_t ichan=0; ichan<nchan_per_packet; ichan++)
          {
            const uint32_t ochan = (ipacket * nchan_per_packet) + ichan;
            for (uint32_t ipol=0; ipol<npol; ipol++)
            {
              float * into = output->get_datptr (ochan, ipol) + heap_val_offset;
              for (uint32_t ival=0; ival<nval_per_packet; ival++)
              {
                into[ival] = static_cast<float>(in[0]) * multiplier;
                in++;
              }
            }
          }
          packet_number++;
        }
      }
    }
 
    bool configured{false};
 
    uint32_t nchan_per_packet{0};
 
    uint32_t nsamp_per_packet{0};
 
    uint32_t nsamp_per_weight{0};
 
    uint32_t npackets_per_heap{0};
 
    uint32_t weights_packet_stride{0};
 
    uint32_t scale_nbyte{4};
 
    uint32_t weight_nbyte{2};
 
    unsigned ndim{0};
 
    unsigned npol{0};
 
    unsigned nbit{0};
 
    unsigned nchan{0};
 
    std::string machine;
 
    uint64_t invalid_packets{0};
 
  };
 
} // namespace dsp
 
#endif // __dsp_Kernel_Formats_ska1_SKAParallelUnpacker