BdaBuffer.h

Go to the documentation of this file.

// BdaBuffer.h: Buffer holding BDA data
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_BASE_BDABUFFER_H_
#define DP3_BASE_BDABUFFER_H_
 
#include <complex>
#include <map>
#include <string>
#include <vector>
 
#include <aocommon/uvector.h>
 
#include "common/Fields.h"
#include "common/Types.h"
 
namespace dp3 {
namespace base {
 
class BdaBuffer {
 public:
  struct Row {
    Row(double time, double interval, double exposure, common::rownr_t row_nr,
        std::size_t baseline_nr, std::size_t n_channels,
        std::size_t n_correlations, std::size_t offset, const double* uvw);
    std::size_t GetDataSize() const { return n_channels * n_correlations; }
    bool IsMetadataEqual(const BdaBuffer::Row& other) const;
    const double time;  
    const double interval;  
    const double exposure;  
    common::rownr_t row_nr;
    const std::size_t baseline_nr;
    const std::size_t n_channels;
    const std::size_t n_correlations;
    const std::size_t offset;  
    double uvw[3];
  };
 
  explicit BdaBuffer(std::size_t pool_size, const common::Fields& fields);
 
  BdaBuffer(const BdaBuffer& other) = delete;
  BdaBuffer& operator=(const BdaBuffer& other) = delete;
  BdaBuffer(const BdaBuffer& other, const common::Fields& fields);
 
  void AddData(const std::string& name = "") {
    aocommon::UVector<std::complex<float>>& new_data = data_[name];
    new_data.reserve(original_capacity_);
    new_data.resize(GetNumberOfElements());
  }
 
  void MoveData(BdaBuffer& source, const std::string& source_name = "",
                const std::string& target_name = "");
 
  void RemoveData(const std::string& name = "") { data_.erase(name); }
 
  bool HasData(const std::string& name = "") const {
    return data_.find(name) != data_.end();
  }
 
  std::vector<std::string> GetDataNames() const {
    std::vector<std::string> names;
    names.reserve(data_.size());
    for (const auto& name_vector : data_) {
      names.push_back(name_vector.first);
    }
    return names;
  }
 
  bool AddRow(double time, double interval, double exposure,
              std::size_t baseline_nr, std::size_t n_channels,
              std::size_t n_correlations, common::rownr_t row_nr,
              const std::complex<float>* data = nullptr,
              const bool* flags = nullptr, const float* weights = nullptr,
              const double* uvw = nullptr);
 
  void Clear();
 
  std::size_t GetNumberOfElements() const {
    return original_capacity_ - remaining_capacity_;
  }
 
  std::size_t GetRemainingCapacity() const { return remaining_capacity_; }
 
  const std::complex<float>* GetData(const std::string& name = "") const;
  std::complex<float>* GetData(const std::string& name = "");
 
  const std::complex<float>* GetData(std::size_t row,
                                     const std::string& name = "") const;
  std::complex<float>* GetData(std::size_t row, const std::string& name = "");
 
  const bool* GetFlags() const {
    return flags_.empty() ? nullptr : flags_.data();
  }
  bool* GetFlags() { return flags_.empty() ? nullptr : flags_.data(); }
 
  const bool* GetFlags(std::size_t row) const {
    return flags_.empty() ? nullptr : flags_.data() + rows_[row].offset;
  }
  bool* GetFlags(std::size_t row) {
    return flags_.empty() ? nullptr : flags_.data() + rows_[row].offset;
  }
 
  const float* GetWeights() const {
    return weights_.empty() ? nullptr : weights_.data();
  }
  float* GetWeights() { return weights_.empty() ? nullptr : weights_.data(); }
 
  const float* GetWeights(std::size_t row) const {
    return weights_.empty() ? nullptr : weights_.data() + rows_[row].offset;
  }
  float* GetWeights(std::size_t row) {
    return weights_.empty() ? nullptr : weights_.data() + rows_[row].offset;
  }
 
  std::vector<Row>& GetRows() { return rows_; }
  const std::vector<Row>& GetRows() const { return rows_; }
 
  static constexpr bool TimeIsLess(double x, double y) {
    return x < (y - kTimeTolerance);
  }
  static constexpr bool TimeIsLessEqual(double x, double y) {
    return x < (y + kTimeTolerance);
  }
  static constexpr bool TimeIsGreaterEqual(double x, double y) {
    return x > (y - kTimeTolerance);
  }
  static constexpr bool TimeIsEqual(double x, double y) {
    // Don't use std::abs, since it is not a constexpr.
    return ((x > y) ? (x - y) : (y - x)) < kTimeTolerance;
  }
 
  bool IsMetadataEqual(const BdaBuffer& other) const;
 
  // Tolerance value for comparing measurement timestamps. It should be larger
  // than the rounding errors that occur due to BDA averaging and expanding.
  static constexpr double kTimeTolerance = 2.0e-6;
 
 private:
  std::map<std::string, aocommon::UVector<std::complex<float>>> data_;
  aocommon::UVector<bool> flags_;
  aocommon::UVector<float> weights_;
  std::vector<Row> rows_;
  std::size_t original_capacity_;   
  std::size_t remaining_capacity_;  
};
 
}  // namespace base
}  // namespace dp3
 
#endif  // DP3_BASE_BDABUFFER_H_