ApplyCal.h

Go to the documentation of this file.

// ApplyCal.h: DP3 step class to ApplyCal visibilities from a source model
// Copyright (C) 2023 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_STEPS_APPLYCAL_H_
#define DP3_STEPS_APPLYCAL_H_
 
#include <utility>
 
#include <aocommon/matrix2x2.h>
#include <aocommon/matrix2x2diag.h>
 
#include "base/DPBuffer.h"
#include "OneApplyCal.h"
 
namespace dp3 {
namespace common {
class ParameterSet;
}
 
namespace steps {
 
 
 
class ApplyCal : public Step {
 public:
  ApplyCal(const common::ParameterSet&, const std::string& prefix,
           bool substep = false, std::string predictDirection = "");
 
  ApplyCal() = default;
 
  ~ApplyCal() override = default;
 
  common::Fields getRequiredFields() const override {
    // ApplyCal is a dummy step, which is followed by OneApplyCal steps.
    return {};
  }
 
  common::Fields getProvidedFields() const override {
    // ApplyCal is a dummy step, which is followed by OneApplyCal steps.
    return {};
  }
 
  bool process(std::unique_ptr<base::DPBuffer> buffer) override;
 
  void finish() override;
 
  void setNextStep(Step::ShPtr nextStep) override;
 
  void show(std::ostream&) const override;
 
  void showTimings(std::ostream&, double duration) const override;
 
  template <typename NumType>
  static void invert(std::complex<NumType>* v);
 
  static void ApplyDiag(const aocommon::MC2x2FDiag& gain_a,
                        const aocommon::MC2x2FDiag& gain_b,
                        base::DPBuffer& buffer, unsigned int baseline,
                        unsigned int channel, bool update_weights,
                        base::FlagCounter& flag_counter,
                        const std::string& direction = "");
 
  static void ApplyScalar(const std::complex<float>& gain_a,
                          const std::complex<float>& gain_b,
                          base::DPBuffer& buffer, unsigned int baseline,
                          unsigned int channel, bool update_weights,
                          base::FlagCounter& flag_counter);
 
  static void ApplyFull(const aocommon::MC2x2F& gain_a,
                        const aocommon::MC2x2F& gain_b, base::DPBuffer& buffer,
                        unsigned int baseline, unsigned int channel,
                        bool update_weights, base::FlagCounter& flag_counter,
                        const std::string& direction = "");
 
  static void ApplyWeights(const aocommon::MC2x2F& gain_a,
                           const aocommon::MC2x2F& gain_b, float* weight);
 
 private:
  bool is_sub_step_{false};
  std::vector<std::shared_ptr<OneApplyCal>> apply_cals_;
};
 
}  // namespace steps
}  // namespace dp3
 
#endif