DPBuffer.h

Go to the documentation of this file.

// DPBuffer.h: Buffer holding the data of a timeslot/band
// Copyright (C) 2023 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_BASE_DPBUFFER_H_
#define DP3_BASE_DPBUFFER_H_
 
#include <array>
#include <map>
#include <vector>
 
#include <xtensor/containers/xtensor.hpp>
 
#include <casacore/casa/Arrays/Vector.h>
#include <aocommon/xt/utensor.h>
 
#include "common/Fields.h"
#include "common/Types.h"
 
namespace dp3 {
namespace base {
 
 
class DPBuffer {
 public:
  // Return types for Get* functions.
  using DataType = aocommon::xt::UTensor<std::complex<float>, 3>;
  using WeightsType = xt::xtensor<float, 3>;
  using FlagsType = xt::xtensor<bool, 3>;
  using UvwType = xt::xtensor<double, 2>;
  using SolutionType = std::vector<std::vector<std::complex<double>>>;
 
  explicit DPBuffer(double time = 0.0, double exposure = 0.0);
 
  DPBuffer(const DPBuffer&) = default;
 
  DPBuffer(DPBuffer&&);
 
  DPBuffer(const DPBuffer& that, const common::Fields& fields);
 
  DPBuffer& operator=(const DPBuffer&);
 
  DPBuffer& operator=(DPBuffer&&);
 
  void Copy(const DPBuffer& that, const common::Fields& fields,
            const bool extra_data = false);
 
  void AddData(const std::string& name);
 
  void RemoveData(const std::string& name = "");
 
  bool HasData(const std::string& name = "") const {
    return name.empty() || (extra_data_.find(name) != extra_data_.end());
  }
 
  std::vector<std::string> GetDataNames() const {
    std::vector<std::string> names;
    names.reserve(1 + extra_data_.size());
    names.push_back("");
    for (const auto& name_vector : extra_data_) {
      names.push_back(name_vector.first);
    }
    return names;
  }
 
  const DataType& GetData(const std::string& name = "") const {
    if (name.empty()) {
      return data_;
    } else {
      auto found = extra_data_.find(name);
      if (found == extra_data_.end()) {
        throw std::runtime_error("No data named '" + name +
                                 "' is found in the current DPBuffer");
      }
 
      return found->second;
    }
  }
  DataType& GetData(const std::string& name = "") {
    if (name.empty()) {
      return data_;
    } else {
      auto found = extra_data_.find(name);
      if (found == extra_data_.end()) {
        throw std::runtime_error("No data named '" + name +
                                 "' is found in the current DPBuffer");
      }
      return found->second;
    }
  }
 
  DataType TakeData() {
    DataType result;
    std::swap(result, data_);
    return result;
  }
 
  void CopyData(const DPBuffer& source, const std::string& source_name,
                const std::string& target_name);
 
  void MoveData(DPBuffer& source, const std::string& source_name,
                const std::string& target_name);
 
  const FlagsType& GetFlags() const { return flags_; }
  FlagsType& GetFlags() { return flags_; }
 
  const WeightsType& GetWeights() const { return weights_; }
  WeightsType& GetWeights() { return weights_; }
 
  WeightsType TakeWeights() {
    WeightsType result;
    std::swap(result, weights_);
    return result;
  }
 
  void SetTime(double time) { time_ = time; }
  double GetTime() const { return time_; }
 
  void SetExposure(double exposure) { exposure_ = exposure; }
  double GetExposure() const { return exposure_; }
 
  void SetRowNumbers(const casacore::Vector<common::rownr_t>& rownrs) {
    row_numbers_.reference(rownrs);
  }
  const casacore::Vector<common::rownr_t>& GetRowNumbers() const {
    return row_numbers_;
  }
 
  const UvwType& GetUvw() const { return uvw_; }
  UvwType& GetUvw() { return uvw_; }
 
  void SetSolution(const SolutionType& solution) { solution_ = solution; }
  const SolutionType& GetSolution() const { return solution_; }
 
 private:
  double time_;
  double exposure_;
  casacore::Vector<common::rownr_t> row_numbers_;
 
  DataType data_;
  std::map<std::string, DataType> extra_data_;
 
  FlagsType flags_;
  WeightsType weights_;
  UvwType uvw_;
 
  SolutionType solution_;
};
 
}  // namespace base
}  // namespace dp3
 
#endif  // DP3_BASE_DPBUFFER_H_