SolverTester.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 DP3_DDECAL_TEST_UNIT_SOLVER_TESTER_H_
#define DP3_DDECAL_TEST_UNIT_SOLVER_TESTER_H_
 
#include <complex>
#include <memory>
#include <vector>
 
#include "base/DPBuffer.h"
#include "ddecal/gain_solvers/BdaSolverBuffer.h"
#include "ddecal/gain_solvers/SolverTools.h"
 
namespace dp3 {
namespace ddecal {
 
class SolverBase;
 
namespace test {
 
class SolverTester {
 public:
  SolverTester();
 
  std::vector<base::DPBuffer> FillDdIntervalData(bool leakage_only = false);
 
  const ddecal::BdaSolverBuffer& FillBDAData();
 
  void InitializeSolver(dp3::ddecal::SolverBase& solver) const;
 
  void SetScalarSolutions(bool use_dd_intervals);
  void SetDiagonalSolutions(bool use_dd_intervals);
  void SetLeakageSolutions(bool use_dd_intervals);
  std::vector<std::vector<std::complex<double>>>& GetSolverSolutions() {
    return solver_solutions_;
  }
 
  void CheckScalarResults(double tolerance);
  void CheckDualResults(double tolerance);
  void CheckPolarizationLeakageResults(double tolerance);
 
  const std::vector<int>& Antennas1() const { return antennas1_; }
 
  const std::vector<int>& Antennas2() const { return antennas2_; }
 
  size_t NSolutions() const { return n_solutions_; }
 
  const std::vector<size_t>& NSolutionsPerDirection() const {
    return n_solutions_per_direction_;
  }
 
  std::vector<uint32_t> NSolutionsPerDirection32() const {
    return std::vector<uint32_t>(n_solutions_per_direction_.begin(),
                                 n_solutions_per_direction_.end());
  }
 
  static std::vector<std::string> CreateDirectionNames();
 
  static constexpr size_t kNPolarizations = 4;
  static constexpr size_t kNAntennas = 50;
  static constexpr size_t kNDirections = 3;
  static constexpr size_t kNChannels = 16;
  static constexpr size_t kNChannelBlocks = 4;
  static const inline std::vector<double> kFrequencies{150e6, 160e6, 170e6,
                                                       180e6};
  static constexpr size_t kNRegularTimes = 50;
  // Use more times with BDA so the number of visibilities is similar to the
  // regular data.
  static constexpr size_t kNBDATimes = 128;
  static constexpr size_t kNBaselines = kNAntennas * (kNAntennas - 1) / 2;
  static constexpr std::array<size_t, 3> kShape{kNBaselines, kNChannels,
                                                kNPolarizations};
  static constexpr double kBdaUnitTimeInterval = 1.0;
 
  // Default solver settings:
  static constexpr size_t kMaxIterations = 100;
  static constexpr double kAccuracy = 1e-8;
  static constexpr double kStepSize = 0.2;
  static constexpr size_t kNThreads = 4;
  static constexpr bool kPhaseOnly = false;
  static constexpr size_t kDDSolutionsPerDirection[kNDirections] = {1, 2, 5};
 
  // Default LBFGS solver settings
  static constexpr size_t kBatchIterations = 2;
  static constexpr size_t kEpochs = 2;
  static constexpr size_t kMinibatches = 4;
  static constexpr double kRobustDOF = 200.0;
  static constexpr size_t kHistory = 10;
  static constexpr double kMinSolution = -1000.0;
  static constexpr double kMaxSolution = 1000.0;
 
 private:
  void InitializeSolverSettings(dp3::ddecal::SolverBase& solver) const;
  void InitializeNSolutions(bool use_dd_intervals);
  void SetUnitSolverSolutions(size_t solutions_per_matrix);
 
  std::vector<int> antennas1_;
  std::vector<int> antennas2_;
  std::vector<std::complex<float>> input_solutions_;
  std::vector<std::vector<std::complex<double>>> solver_solutions_;
  std::vector<size_t> n_solutions_per_direction_;
  size_t n_solutions_;
 
  BdaSolverBuffer bda_solver_buffer_;
};
 
}  // namespace test
}  // namespace ddecal
}  // namespace dp3
 
#endif  // DP3_DDECAL_SOLVER_TESTER_H