SmoothnessConstraint.h

Go to the documentation of this file.

// Copyright (C) 2023 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef DP3_DDECAL_SMOOTHNESS_CONSTRAINT_H_
#define DP3_DDECAL_SMOOTHNESS_CONSTRAINT_H_
 
#include <vector>
 
#include "Constraint.h"
#include "KernelSmoother.h"
 
namespace dp3 {
namespace ddecal {
 
class SmoothnessConstraint final : public Constraint {
 public:
  SmoothnessConstraint(double bandwidth_hz, double bandwidth_ref_frequency_hz,
                       double spectral_exponent, bool kernel_truncation);
 
  void Apply(SolutionSpan& solutions, double time) override;
 
  void SetWeights(const std::vector<double>& weights) override {
    weights_ = weights;
  }
 
  void SetSubSolutionWeights(
      const std::vector<std::vector<double>>& sub_solution_weights) override {
    sub_solution_weights_ = sub_solution_weights;
  }
 
  void Initialize(size_t nAntennas,
                  const std::vector<uint32_t>& solutions_per_direction,
                  const std::vector<double>& frequencies) override;
 
  void SetAntennaFactors(std::vector<double>&& antenna_factors) {
    antenna_factors_ = std::move(antenna_factors);
  }
 
  const std::vector<double>& GetAntennaFactors() const {
    return antenna_factors_;
  }
 
  void SetDdSmoothingFactors(std::vector<double> dd_smoothing_factors);
 
  const std::vector<double>& GetDdSmoothingFactors() const {
    return dd_smoothing_factors_;
  }
 
 private:
  using Smoother = KernelSmoother<std::complex<double>, double>;
 
  struct FitData {
    FitData(const std::vector<double>& frequencies,
            Smoother::KernelType kernel_type, double kernel_bandwidth,
            double bandwidth_ref_frequency_hz, double spectral_exponent,
            bool kernel_truncation)
        : smoother(frequencies, kernel_type, kernel_bandwidth,
                   bandwidth_ref_frequency_hz, spectral_exponent,
                   kernel_truncation),
          data(frequencies.size()),
          weight(frequencies.size()) {}
 
    Smoother smoother;
    std::vector<std::complex<double>> data;
    std::vector<double> weight;
  };
  std::vector<FitData> fit_data_;
  std::vector<double> frequencies_;
  std::vector<double> antenna_factors_;
  std::vector<double> dd_smoothing_factors_;
  std::vector<double> weights_;
  std::vector<std::vector<double>> sub_solution_weights_;
  Smoother::KernelType kernel_type_;
  double bandwidth_;
  double bandwidth_ref_frequency_;
  double spectral_exponent_;
  bool kernel_truncation_;
};
 
}  // namespace ddecal
}  // namespace dp3
 
#endif