Constraint.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 DP3_DDECAL_CONSTRAINT_H_
#define DP3_DDECAL_CONSTRAINT_H_
 
#include <complex>
#include <numeric>
#include <ostream>
#include <vector>
 
#include <xtensor/containers/xtensor.hpp>
 
#include "ConstraintResult.h"
 
#include "../Solutions.h"
 
namespace dp3::ddecal {
 
class Constraint {
 public:
  typedef std::complex<double> dcomplex;
  virtual ~Constraint() = default;
 
  virtual void PrepareIteration([[maybe_unused]] bool hasReachedPrecision,
                                [[maybe_unused]] size_t iteration,
                                [[maybe_unused]] bool finalIter) {}
 
  virtual bool Satisfied() const { return true; }
 
  virtual void Apply(SolutionSpan& solutions, double time) = 0;
 
  virtual std::vector<ConstraintResult> GetResult() const { return {}; }
 
  virtual void Initialize(size_t n_antennas,
                          const std::vector<uint32_t>& solutions_per_direction,
                          const std::vector<double>& frequencies) {
    assert(n_antennas != 0);
    assert(!solutions_per_direction.empty());
    assert(!frequencies.empty());
    n_antennas_ = n_antennas;
    solutions_per_direction_ = solutions_per_direction;
    n_channel_blocks_ = frequencies.size();
    n_sub_solutions_ = std::accumulate(solutions_per_direction.begin(),
                                       solutions_per_direction.end(), 0u);
    assert(n_sub_solutions_ != 0);
  }
 
  virtual void SetWeights([[maybe_unused]] const std::vector<double>& weights) {
  }
 
  virtual void SetSubSolutionWeights(
      const std::vector<std::vector<double>>& solution_weights) {}
 
  virtual void GetTimings([[maybe_unused]] std::ostream& os,
                          [[maybe_unused]] double duration) const {}
 
  size_t NAntennas() const { return n_antennas_; }
  size_t NDirections() const { return solutions_per_direction_.size(); }
  size_t NSubSolutions() const { return n_sub_solutions_; }
  size_t NChannelBlocks() const { return n_channel_blocks_; }
  uint32_t GetSubSolutions(size_t direction) const {
    return solutions_per_direction_[direction];
  }
 
  static bool isfinite(const dcomplex& value) {
    return std::isfinite(value.real()) && std::isfinite(value.imag());
  }
 
  void ApplyReferenceAntenna(SolutionSpan& solutions);
 
 private:
  size_t n_antennas_ = 0;
  size_t n_channel_blocks_ = 0;
  size_t n_sub_solutions_ = 0;
  std::vector<uint32_t> solutions_per_direction_;
};
 
}  // namespace dp3::ddecal
 
#endif