Step.h

Go to the documentation of this file.

// Step.h: Abstract base class for a DP3 step
// Copyright (C) 2023 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_STEPS_STEP_H_
#define DP3_STEPS_STEP_H_
 
#include <iosfwd>
#include <memory>
#include <string>
 
#include "base/DPBuffer.h"
#include "base/BdaBuffer.h"
#include "base/DPInfo.h"
#include "base/Direction.h"
 
#include "common/Fields.h"
 
namespace dp3 {
namespace steps {
 
 
 
class Step {
 public:
  typedef std::shared_ptr<Step> ShPtr;
 
  enum class MsType { kRegular, kBda };
 
  // Predefined fields values, that can be OR'd together:
  static constexpr dp3::common::Fields kDataField{
      dp3::common::Fields::Single::kData};
  static constexpr dp3::common::Fields kFlagsField{
      dp3::common::Fields::Single::kFlags};
  static constexpr dp3::common::Fields kWeightsField{
      dp3::common::Fields::Single::kWeights};
  static constexpr dp3::common::Fields kUvwField{
      dp3::common::Fields::Single::kUvw};
 
  Step();
  virtual ~Step();
 
  virtual bool process(std::unique_ptr<base::DPBuffer> buffer) {
    throw std::runtime_error("Step does not support regular data processing.");
  }
 
  virtual bool process(std::unique_ptr<base::BdaBuffer>) {
    throw std::runtime_error("Step does not support BDA data processing.");
  }
 
  virtual void finish() = 0;
 
  virtual dp3::common::Fields getRequiredFields() const = 0;
 
  virtual dp3::common::Fields getProvidedFields() const = 0;
 
  void setInfo(const base::DPInfo&);
 
  virtual void updateInfo(const base::DPInfo&);
 
  const base::DPInfo& getInfoIn() const { return input_info_; }
 
  const base::DPInfo& getInfoOut() const { return output_info_; }
 
  virtual void show(std::ostream&) const = 0;
 
  virtual void showCounts(std::ostream&) const;
 
  virtual void showTimings(std::ostream&, double duration) const;
 
  void setPrevStep(Step* prevStep) { previous_step_ = prevStep; }
 
  Step* getPrevStep() const { return previous_step_; }
 
  virtual void setNextStep(Step::ShPtr nextStep) {
    next_step_ = std::move(nextStep);
    next_step_->setPrevStep(this);
  }
 
  const Step::ShPtr& getNextStep() const { return next_step_; }
 
  virtual MsType outputs() const { return MsType::kRegular; }
 
  virtual bool accepts(MsType dt) const { return dt == MsType::kRegular; }
 
  static void SetThreadingIsInitialized() { threading_is_initialized_ = true; }
 
 protected:
  base::DPInfo& GetWritableInfoOut() { return output_info_; }
 
  virtual void addToMS(const std::string& msName);
 
 private:
  std::shared_ptr<Step> next_step_;
  Step* previous_step_ = nullptr;  
  base::DPInfo input_info_;
  base::DPInfo output_info_;
  inline static bool threading_is_initialized_ = false;
};
 
class ModelDataStep : public Step {
 public:
  common::Fields getProvidedFields() const override { return kDataField; }
 
  virtual base::Direction GetFirstDirection() const = 0;
};
 
}  // namespace steps
}  // namespace dp3
 
#endif  // DP3_STEPS_STEP_H_