BdaDdeCal.h

Go to the documentation of this file.

// Copyright (C) 2022 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef DP3_BDADDECAL_H_
#define DP3_BDADDECAL_H_
 
#include "common/ParameterSet.h"
#include "common/Timer.h"
 
#include "ddecal/Settings.h"
#include "ddecal/SolutionWriter.h"
#include "ddecal/gain_solvers/BdaSolverBuffer.h"
#include "ddecal/gain_solvers/SolverBase.h"
 
#include "steps/Step.h"
 
#include "BDAResultStep.h"
#include "UVWFlagger.h"
 
namespace dp3 {
namespace steps {
 
class BdaDdeCal : public Step {
 public:
  BdaDdeCal(const common::ParameterSet& parset, const std::string& prefix);
 
  common::Fields getRequiredFields() const override;
 
  common::Fields getProvidedFields() const override {
    return (settings_.subtract ||
            (settings_.only_predict && !settings_.keep_model_data))
               ? kDataField
               : common::Fields();
  }
 
  bool process(std::unique_ptr<base::BdaBuffer>) override;
 
  void finish() override;
 
  void show(std::ostream&) const override;
 
  void showTimings(std::ostream&, double duration) const override;
 
  void updateInfo(const base::DPInfo&) override;
 
  bool accepts(MsType dt) const override { return dt == MsType::kBda; }
 
  MsType outputs() const override { return MsType::kBda; };
 
  size_t GetChanBlockIndex(size_t channel, size_t n_channels,
                           size_t n_channel_blocks) const;
 
 private:
  void InitializeModelReuse();
 
  void InitializeColumnReaders(const common::ParameterSet& parset,
                               const std::string& prefix);
 
  void InitializePredictSteps(const common::ParameterSet& parset,
                              const std::string& prefix);
 
  void DetermineChannelBlocks();
 
  void SetSourceDirections();
 
  std::vector<double> GetChannelBlockFrequencies() const;
 
  void ExtractResults();
 
  bool HasAllDirections(const base::BdaBuffer& buffer) const;
 
  void SumModels(base::BdaBuffer& buffer) const;
 
  void ProcessCompleteDirections();
 
  void SolveCurrentInterval();
 
  void InitializeCurrentSolutions();
 
  void ProcessDone();
 
  void WriteSolutions();
 
 private:
  ddecal::Settings settings_;
  std::unique_ptr<ddecal::SolutionWriter> solution_writer_;
 
  std::vector<base::Direction> source_directions_;
 
  std::vector<std::shared_ptr<ModelDataStep>> steps_;
  std::vector<std::shared_ptr<BDAResultStep>> result_steps_;
 
  std::unique_ptr<UVWFlagger> uvw_flagger_step_;
  std::shared_ptr<BDAResultStep> uvw_flagger_result_step_;
 
  std::vector<std::vector<std::string>> patches_per_direction_;
 
  std::vector<std::string> direction_names_;
 
  std::deque<std::unique_ptr<base::BdaBuffer>> input_buffers_;
 
  std::unique_ptr<ddecal::BdaSolverBuffer> solver_buffer_;
 
  std::unique_ptr<ddecal::SolverBase> solver_;
 
  double solution_interval_duration_;
 
  std::vector<double> chan_block_start_freqs_;
 
  std::vector<int> antennas1_;
  std::vector<int> antennas2_;
  std::vector<std::vector<std::vector<casacore::DComplex>>> solutions_;
 
  std::vector<size_t> iterations_;
  std::vector<size_t> approx_iterations_;
 
  std::vector<std::vector<std::vector<ddecal::ConstraintResult>>>
      constraint_solutions_;
 
  common::NSTimer timer_;
  common::NSTimer predict_timer_;
  common::NSTimer solve_timer_;
  common::NSTimer write_timer_;
};
 
}  // namespace steps
}  // namespace dp3
 
#endif