HybridSolver.h

Go to the documentation of this file.

// Copyright (C) 2021 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef DDECAL_HYBRID_SOLVER_H
#define DDECAL_HYBRID_SOLVER_H
 
#include "SolverBase.h"
 
namespace dp3 {
namespace ddecal {
 
class HybridSolver final : public SolverBase {
 public:
  HybridSolver() : stop_on_convergence_(false) {}
 
  void Initialize(size_t n_antennas,
                  const std::vector<size_t>& n_solutions_per_direction,
                  size_t n_channel_blocks) override {
    SolverBase::Initialize(n_antennas, n_solutions_per_direction,
                           n_channel_blocks);
    for (const std::pair<std::unique_ptr<SolverBase>, size_t>& solver_info :
         solvers_) {
      solver_info.first->Initialize(n_antennas, n_solutions_per_direction,
                                    n_channel_blocks);
    }
  }
 
  size_t NSolutionPolarizations() const override {
    return solvers_.empty() ? 0
                            : solvers_.front().first->NSolutionPolarizations();
  }
 
  void AddSolver(std::unique_ptr<SolverBase> solver);
 
  std::vector<SolverBase*> ConstraintSolvers() override {
    std::vector<SolverBase*> solvers;
    for (const auto& solverinfo : solvers_)
      solvers.push_back(solverinfo.first.get());
    return solvers;
  }
 
  bool StopOnConvergence() const { return stop_on_convergence_; }
  void SetStopOnConvergence(bool stop_on_convergence) {
    stop_on_convergence_ = stop_on_convergence;
  }
  SolveResult Solve(const FullSolveData& solve_data,
                    std::vector<std::vector<DComplex>>& solutions,
                    double time) override;
 
 private:
  bool RunSolver(SolverBase& solver, size_t& available_iterations,
                 SolveResult& result, const FullSolveData& solve_data,
                 std::vector<std::vector<DComplex>>& solutions, double time);
 
  // List of solvers with their maximum number of iterations
  std::vector<std::pair<std::unique_ptr<SolverBase>, size_t>> solvers_;
  bool stop_on_convergence_;
};
 
}  // namespace ddecal
}  // namespace dp3
 
#endif  // DDECAL_HYBRID_SOLVER_H