BdaSolverBuffer.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 DDECAL_BDA_SOLVER_BUFFER_H
#define DDECAL_BDA_SOLVER_BUFFER_H
 
#include <cmath>
#include <complex>
#include <memory>
#include <vector>
 
#include <aocommon/queue.h>
 
#include "base/BdaBuffer.h"
 
namespace dp3 {
namespace ddecal {
 
class BdaSolverBuffer {
 public:
  struct IntervalRow {
    double time;
    std::size_t baseline_nr;
    std::size_t n_channels;
    std::size_t n_correlations;
    const std::complex<float>* unweighted_data;
    const std::complex<float>* weighted_data;
    const bool* flags;
    const float* weights;
    std::vector<std::complex<float>*> unweighted_model_data;
    std::vector<const std::complex<float>*> weighted_model_data;
  };
 
  BdaSolverBuffer(double start, double interval, size_t n_baselines)
      : data_(),
        time_start_(start),
        time_interval_(interval),
        current_interval_(0),
        last_complete_interval_per_baseline_(n_baselines, -1),
        data_rows_() {
    assert(interval > 0.0);
    // Ensure that the current solution interval is valid.
    data_rows_.PushBack(std::vector<IntervalRow>());
  }
 
  void AppendAndWeight(std::unique_ptr<base::BdaBuffer> buffer,
                       const std::vector<std::string>& direction_names,
                       bool keep_unweighted_model_data);
 
  void Clear();
 
  bool IntervalIsComplete() const {
    return *std::min_element(last_complete_interval_per_baseline_.begin(),
                             last_complete_interval_per_baseline_.end()) >= 0;
  }
 
  void AdvanceInterval();
 
  size_t BufferCount() const { return data_.Size(); }
 
  const std::vector<IntervalRow>& GetIntervalRows() const {
    return data_rows_[0];
  }
 
  int GetCurrentInterval() const { return current_interval_; }
 
  void ApplySolutions(
      const std::vector<std::vector<std::complex<double>>>& solutions,
      const std::vector<double>& channel_block_start_frequencies,
      size_t n_polarizations, const std::vector<int>& antenna1,
      const std::vector<int>& antenna2,
      const std::vector<std::vector<double>>& channel_frequencies);
 
  std::vector<std::unique_ptr<base::BdaBuffer>> GetDone() {
    std::vector<std::unique_ptr<base::BdaBuffer>> result;
    result.swap(done_);
    return result;
  }
 
  double CurrentIntervalStart() const {
    return time_start_ + current_interval_ * time_interval_;
  }
 
  double IntervalDuration() const { return time_interval_; }
 
 private:
  int RelativeIndex(double time_center) const {
    return int(std::floor((time_center - time_start_) / time_interval_)) -
           current_interval_;
  }
 
  struct InputData {
    std::unique_ptr<base::BdaBuffer> unweighted;
    std::unique_ptr<base::BdaBuffer> weighted;
  };
 
  aocommon::Queue<InputData> data_;
 
  std::vector<std::unique_ptr<base::BdaBuffer>> done_;
 
  const double time_start_;
  const double time_interval_;  
  int current_interval_;  
 
  std::vector<int> last_complete_interval_per_baseline_;
 
  aocommon::Queue<std::vector<IntervalRow>> data_rows_;
};
 
}  // namespace ddecal
}  // namespace dp3
 
#endif  // DDECAL_BDA_SOLVER_BUFFER_H