ApplyBeam.h

Go to the documentation of this file.

// ApplyBeam.h: DP3 step class to ApplyBeam visibilities from a source model
// Copyright (C) 2022 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_STEPS_APPLYBEAM_H_
#define DP3_STEPS_APPLYBEAM_H_
 
#include "InputStep.h"
 
#include "base/DPBuffer.h"
 
#include <barrier>
 
#include <EveryBeam/telescope/telescope.h>
 
#include <aocommon/matrix2x2.h>
#include <aocommon/xt/utensor.h>
 
#include <casacore/casa/Arrays/Cube.h>
#include <casacore/measures/Measures/MDirection.h>
 
#include "common/ParameterSet.h"
 
namespace dp3 {
namespace steps {
 
size_t ComputeBeam(const base::DPInfo& info, double time,
                   const everybeam::vector3r_t& srcdir,
                   const everybeam::telescope::Telescope* telescope,
                   aocommon::MC2x2* beam_values, bool invert,
                   everybeam::BeamMode mode, std::mutex* mutex,
                   const std::vector<size_t>& skip_station_indices);
 
size_t ComputeArrayFactor(const base::DPInfo& info, double time,
                          const everybeam::vector3r_t& srcdir,
                          const everybeam::telescope::Telescope* telescope,
                          std::complex<double>* beam_values, bool invert,
                          std::mutex* mutex,
                          const std::vector<size_t>& skip_station_indices);
 
void ApplyBeamToDataAndAdd(
    const base::DPInfo& info, size_t n_stations,
    const aocommon::xt::UTensor<std::complex<double>, 3>& data,
    aocommon::xt::UTensor<std::complex<double>, 3>& model_data,
    const aocommon::MC2x2* beam_values);
 
void ApplyArrayFactorAndAdd(
    const base::DPInfo& info, size_t n_stations,
    const aocommon::xt::UTensor<std::complex<double>, 3>& data,
    aocommon::xt::UTensor<std::complex<double>, 3>& model_data,
    const std::complex<double>* beam_values);
 
 
 
class ApplyBeam final : public Step {
 public:
  ApplyBeam(const common::ParameterSet&, const std::string& prefix,
            bool substep = false);
 
  common::Fields getRequiredFields() const override {
    common::Fields fields = kDataField;
    if (itsUpdateWeights) fields |= kWeightsField;
    return fields;
  }
 
  common::Fields getProvidedFields() const override {
    common::Fields fields = kDataField;
    if (itsUpdateWeights) fields |= kWeightsField;
    return fields;
  }
 
  bool process(std::unique_ptr<base::DPBuffer> buffer) override {
    if (use_model_data_) {
      return ProcessModelData(std::move(buffer));
    } else {
      return ProcessData(std::move(buffer));
    }
  }
 
  void finish() override;
 
  void updateInfo(const base::DPInfo&) override;
 
  void show(std::ostream&) const override;
 
  void showTimings(std::ostream&, double duration) const override;
 
  bool invert() { return itsInvert; }
 
  static void ApplyBaselineBasedBeam(
      const base::DPInfo& info, double time, std::complex<double>* data0,
      float* weight0, const everybeam::vector3r_t& srcdir,
      const everybeam::telescope::Telescope* telescope,
      aocommon::MC2x2* beam_values,
      const std::pair<size_t, size_t>& baseline_range,
      const std::pair<size_t, size_t>& station_range, std::barrier<>& barrier,
      bool invert, everybeam::BeamMode mode, bool do_update_weights = false,
      std::mutex* mutex = nullptr,
      const std::vector<size_t>& skip_station_indices = std::vector<size_t>());
 
  static void ApplyBaselineBasedArrayFactor(
      const base::DPInfo& info, double time, std::complex<double>* data0,
      const everybeam::vector3r_t& srcdir,
      const everybeam::telescope::Telescope* telescope,
      std::complex<double>* beam_values,
      const std::pair<size_t, size_t>& baseline_range,
      const std::pair<size_t, size_t>& station_range, std::barrier<>& barrier,
      bool invert, everybeam::BeamMode mode, std::mutex* mutex = nullptr,
      const std::vector<size_t>& skip_station_indices = std::vector<size_t>());
 
 private:
  everybeam::vector3r_t dir2Itrf(const casacore::MDirection& dir,
                                 casacore::MDirection::Convert& measConverter);
  bool ProcessData(std::unique_ptr<base::DPBuffer> buffer);
  bool ProcessModelData(std::unique_ptr<base::DPBuffer> buffer);
 
  string itsName;
  bool itsInvert;
  bool itsUpdateWeights;
  std::vector<std::string> itsDirectionStr;
  casacore::MDirection itsDirection;
  bool itsUseChannelFreq;
  std::vector<std::string> itsSkipStationNames;
  std::vector<size_t> itsSkipStationIndices;
  everybeam::BeamMode itsMode;
  everybeam::ElementResponseModel itsElementResponseModel;
  std::string coefficients_path_;
 
  casacore::MDirection itsDirectionAtStart;
  everybeam::BeamMode itsModeAtStart = everybeam::BeamMode::kNone;
 
  unsigned int itsDebugLevel;
 
  std::unique_ptr<everybeam::telescope::Telescope> telescope_;
  casacore::MeasFrame measure_frame_;
  casacore::MDirection::Convert measure_converter_;
  std::vector<aocommon::MC2x2> beam_values_;
  std::vector<size_t> ant_to_msindex_;
  bool use_model_data_;
 
  common::NSTimer itsTimer;
};
 
}  // namespace steps
}  // namespace dp3
 
#endif