BDAAverager.h

Go to the documentation of this file.

// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_STEPS_BDAAVERAGER_H_
#define DP3_STEPS_BDAAVERAGER_H_
 
#include "Step.h"
#include "common/Timer.h"
 
#include <vector>
#include <queue>
 
namespace dp3 {
namespace common {
class ParameterSet;
}
}  // namespace dp3
 
namespace dp3 {
namespace steps {
 
class BdaAverager : public Step {
 public:
  BdaAverager(const common::ParameterSet& parset, const std::string& prefix,
              const bool use_weights_and_flags = true);
 
  ~BdaAverager() override;
 
  common::Fields getRequiredFields() const override {
    common::Fields fields = kDataField | kUvwField;
    if (use_weights_and_flags_) fields |= kFlagsField | kWeightsField;
    return fields;
  }
 
  common::Fields getProvidedFields() const override {
    // BdaAverager always creates BdaBuffers with all fields.
    return kDataField | kFlagsField | kWeightsField | kUvwField;
  }
 
  bool process(std::unique_ptr<base::DPBuffer> buffer) override;
 
  void finish() override;
 
  void show(std::ostream&) const override;
 
  void updateInfo(const base::DPInfo&) override;
 
  bool accepts(MsType t) const override { return t == MsType::kRegular; }
 
  MsType outputs() const override { return MsType::kBda; };
 
  void SetAveragingParameters(const base::DPInfo& info);
 
  void PushBufferSizeRequest(size_t buffersize);
 
  float TotalAveragingFactor() const;
 
 private:
  struct BaselineBuffer {
    BaselineBuffer(std::size_t time_factor, std::size_t n_input_channels,
                   std::size_t n_output_channels, std::size_t n_correlations);
    void Clear();
 
    std::size_t times_added;        
    const std::size_t time_factor;  
    std::vector<std::size_t> input_channel_indices;
    double starttime;
    double interval;
    double exposure;
    std::map<std::string, std::vector<std::complex<float>>> data;
    std::vector<float> weights;
    double uvw[3];
  };
 
  void AddBaseline(std::size_t baseline_nr);
 
  void InitializeBdaBuffer(const std::vector<std::string>& data_names);
 
  common::NSTimer timer_;
 
  const double bl_threshold_time_;
  const double bl_threshold_channel_;
  const double max_interval_;
  std::size_t min_channels_;
  std::string name_;
 
  std::size_t maxfreqfactor_;
  std::size_t maxtimefactor_;
 
  common::rownr_t next_rownr_;
  std::size_t bda_pool_size_;
  std::unique_ptr<base::BdaBuffer> bda_buffer_;
  std::vector<BaselineBuffer> baseline_buffers_;
 
  std::array<std::size_t, 3> expected_input_shape_;
 
  std::vector<unsigned int> baseline_factors_;
  std::vector<std::vector<double>> freqs_;
  std::vector<std::vector<double>> widths_;
 
  const bool use_weights_and_flags_;
 
  std::queue<size_t> size_requests_;
  std::vector<std::string> data_names_;
  common::rownr_t row_counter_ = 0;
};
 
}  // namespace steps
}  // namespace dp3
 
#endif  // DP3_STEPS_BDAAVERAGER_H_