Settings.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_SETTINGS_H_
#define DP3_DDECAL_SETTINGS_H_
 
#include <map>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
#include "linear_solvers/LLSSolver.h"
#include "base/CalType.h"
#include "base/Direction.h"
#include "common/ParameterSet.h"
 
namespace dp3::ddecal {
 
enum class SolverAlgorithm {
  kLowRank,
  kDirectionSolve,
  kDirectionIterative,
  kHybrid,
  kLBFGS
};
 
enum class SolverDataUse { kSingle, kDual, kFull };
 
std::string ToString(SolverAlgorithm algorithm);
 
struct Settings {
 public:
  Settings(const common::ParameterSet& parset, const std::string& prefix);
 
  void PrepareSubSolutionsPerDirection(size_t n_directions);
 
  size_t GetNSolutions() const;
 
  std::vector<double> GetExpandedSmoothnessDdFactors() const;
 
  std::vector<std::pair<std::string, std::string>> GetReusedDirections(
      const std::map<std::string, dp3::base::Direction>& directions) const;
 
 private:
  bool GetBool(const std::string& key, bool default_value) const;
 
  unsigned int GetUint(const std::string& key,
                       unsigned int default_value) const;
 
  std::vector<size_t> GetSizeTVector(
      const std::string& key, const std::vector<size_t>& default_value) const;
 
  std::vector<double> GetDoubleVector(const std::string& key) const;
 
  double GetDouble(const std::string& key, double default_value) const;
 
  std::optional<double> GetOptionalDouble(const std::string& key,
                                          double default_value) const {
    const double value = GetDouble(key, default_value);
    if (value == default_value)
      return {};
    else
      return std::optional<double>(value);
  }
 
  std::string GetString(const std::string& key) const;
 
  std::string GetString(const std::string& key,
                        const std::string default_value) const;
 
  std::vector<std::string> GetStringVector(const std::string& key) const;
 
  std::vector<std::set<std::string>> ReadAntennaConstraint() const;
 
  std::vector<std::string> ReadModelDataColumns() const;
 
 private:
  const common::ParameterSet* parset;  // Only valid during construction!
 
 public:
  const std::string name;
  const std::string h5parm_name;
  const std::string stat_filename;
  const std::string parset_string;
 
  const base::CalType mode;
  const bool propagate_solutions;
  const bool propagate_converged_only;
  const bool flag_unconverged;
  const bool flag_diverged_only;
  const bool only_predict;
  const bool subtract;
  const bool keep_model_data;
  const SolverAlgorithm solver_algorithm;
 
  const size_t solution_interval;
  const double min_vis_ratio;
  const size_t n_channels;
  std::vector<size_t> sub_solutions_per_direction;
  std::vector<std::string> antenna_averaging_factors;
 
  // Constraint settings.
  bool model_weighted_constraints;
  const double core_constraint;
  const std::vector<std::set<std::string>> antenna_constraint;
  const double smoothness_constraint;
  const double smoothness_ref_frequency;
  const double smoothness_ref_distance;
  const std::string smoothness_ref_antenna;
  const double smoothness_spectral_exponent;
  bool smoothness_kernel_truncation;
  std::vector<double> smoothness_dd_factors;
  std::vector<std::string> antenna_smoothness_factors;
  const double screen_core_constraint;
 
  // Solver settings.
  const ddecal::LLSSolverType lls_solver_type;
  const size_t max_iterations;
  const double tolerance;
  const double step_size;
  const SolverDataUse solver_data_use;
  const bool detect_stalling;
  const double step_diff_sigma;
  const bool approximate_tec;
  const bool phase_reference;
  const double approx_tolerance;
  const size_t max_approx_iterations;
  const size_t approx_chunk_size;
  const bool rotation_reference;
  const base::CalType rotation_diagonal_mode;
  const base::CalType faraday_diagonal_mode;
  const size_t max_tec_delay_wraps;
  std::optional<double> faraday_limit;
  // LBFGS robust parameter (aka degrees of freedom)
  const double lbfgs_robust_nu;
  // LBFGS max iterations per mini-batch
  const size_t lbfgs_max_iter;
  // LBFGS history size
  const size_t lbfgs_history_size;
  // LBFGS minibatches
  const size_t lbfgs_minibatches;
  // LBFGS solution lower limit
  const double lbfgs_min_solution;
  // LBFGS solution upper limit
  const double lbfgs_max_solution;
  const bool use_gpu;
  // keep host buffers between solve iteration
  // for the GPU solver
  const bool keep_host_buffers;
  // Number of iterations for the low-rank approximation (LRA) method
  const size_t n_lra_iterations;
  // In each lra iteration, the number of power-method iterations to take
  const size_t n_lra_power_iterations;
 
  const std::vector<std::string> model_data_columns;
  const std::vector<std::string> reuse_model_data;
 
  const std::string idg_region_filename;
  const std::vector<std::string> idg_image_filenames;
 
  const bool use_sagecal_predict;
 
  const std::vector<std::string> directions;
  const std::string source_db;
};
 
void ShowConstraintSettings(std::ostream& output, const Settings& settings);
 
std::vector<size_t> GetSolutionToDirectionVector(
    const std::vector<uint32_t>& sub_solutions_per_direction);
 
}  // namespace dp3::ddecal
 
#endif