SoA.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <initializer_list>
#include <map>
#include <tuple>
#include <vector>
 
#include "autopas/utils/AlignedAllocator.h"
#include "autopas/utils/ExceptionHandler.h"
#include "autopas/utils/SoAStorage.h"
#include "autopas/utils/SoAType.h"
#include "autopas/utils/SoAView.h"
 
namespace autopas {
 
template <class SoAArraysType>
class SoA {
 public:
  SoA() = default;
 
  SoA(const SoA &soa) = default;
 
  void resizeArrays(size_t length) {
    soaStorage.apply([=](auto &list) { list.resize(length); });
  }
 
  template <std::size_t attribute>
  void push(const double value) {
    soaStorage.template get<attribute>().push_back(value);
  }
 
  template <int attribute, class ValueType>
  void write(size_t particleId, const ValueType &value) {
    soaStorage.template get<attribute>().at(particleId) = value;
  }
 
  void append(const SoA<SoAArraysType> &other) {
    if (other.size() > 0) {
      append_impl(other.soaStorage, std::make_index_sequence<std::tuple_size<SoAArraysType>::value>{});
    }
  }
 
  void append(const SoAView<SoAArraysType> &other) {
    if (other.size() > 0) {
      append_impl(other, std::make_index_sequence<std::tuple_size<SoAArraysType>::value>{});
    }
  }
 
  template <int... attributes>
  void append(const SoA<SoAArraysType> &other) {
    if (other.size() > 0) {
      const auto newSize = size() + other.size();
      append_impl(other.soaStorage, std::index_sequence<attributes...>{});
      resizeArrays(newSize);
    }
  }
 
  template <int... attributes, class ValueArrayType>
  void writeMultiple(size_t particleId, const ValueArrayType &values) {
    write_impl<attributes...>(particleId, values);
  }
 
  template <int... attributes, size_t N = sizeof...(attributes)>
  inline void writeMultiple(size_t particleId, const std::array<double, N> &values) {
    write_impl<attributes...>(particleId, values);
  }
 
  template <int... attributes>
  std::array<double, sizeof...(attributes)> readMultiple(size_t particleId) const {
    std::array<double, sizeof...(attributes)> retArray;
    if (particleId >= size()) {
      autopas::utils::ExceptionHandler::exception(
          "SoA::read: requested particle id ({}) is bigger than number of particles ({})", particleId, size());
      return retArray;
    }
    read_impl<attributes...>(particleId, retArray);
    return retArray;
  }
 
  template <std::size_t attribute>
  auto read(size_t particleId) const {
    return soaStorage.template get<attribute>().at(particleId);
  }
 
  template <std::size_t attribute>
  auto begin() {
    return soaStorage.template get<attribute>().data();
  }
 
  template <std::size_t attribute>
  auto begin() const {
    return soaStorage.template get<attribute>().data();
  }
 
  inline size_t size() const {
    size_t maxLength = 0;
    utils::TupleUtils::for_each(soaStorage.getTuple(), [&](auto &v) { maxLength = std::max(maxLength, v.size()); });
    return maxLength;
  }
 
  void clear() {
    soaStorage.apply([](auto &list) { list.clear(); });
  }
 
  void swap(std::size_t a, std::size_t b) {
    soaStorage.apply([=](auto &list) { std::swap(list[a], list[b]); });
  }
 
  void pop_back() {
    soaStorage.apply([](auto &list) { list.pop_back(); });
  }
 
  SoAView<SoAArraysType> constructView() { return {this, 0, size()}; }
 
  SoAView<SoAArraysType> constructView(size_t startIndex, size_t endIndex) { return {this, startIndex, endIndex}; }
 
 private:
  // actual implementation of read
  template <int attribute, int... attributes, class ValueArrayType>
  void read_impl(size_t particleId, ValueArrayType &values, int _current = 0) const {
    values[_current] = soaStorage.template get<attribute>().at(particleId);
    read_impl<attributes...>(particleId, values, _current + 1);
  }
 
  // stop of recursive read call
  template <class ValueArrayType>
  void read_impl(size_t particleId, ValueArrayType &values, int _current = 0) const {}
 
  // actual implementation of the write function.
  // uses a recursive call.
  template <int attribute, int... attributes, class ValueArrayType>
  void write_impl(size_t particleId, const ValueArrayType &values, int _current = 0) {
    soaStorage.template get<attribute>().at(particleId) = values[_current];
    write_impl<attributes...>(particleId, values, _current + 1);
  }
 
  // Stop of the recursive write_impl call
  template <class ValueArrayType>
  void write_impl(size_t particleId, const ValueArrayType &values, int _current = 0) {}
 
  // helper function to append a single array
  template <std::size_t attribute>
  void appendSingleArray(const utils::SoAStorage<SoAArraysType> &valArrays) {
    auto &currentVector = soaStorage.template get<attribute>();
    auto &otherVector = valArrays.template get<attribute>();
    currentVector.insert(currentVector.end(), otherVector.begin(), otherVector.end());
  }
 
  // helper function to append a single array
  template <std::size_t attribute>
  void appendSingleArray(const SoAView<SoAArraysType> &valArrays) {
    auto &currentVector = soaStorage.template get<attribute>();
    auto otherVectorIterator = valArrays.template begin<attribute>();
    currentVector.insert(currentVector.end(), otherVectorIterator, otherVectorIterator + valArrays.size());
  }
 
  // actual implementation of append
  template <std::size_t... Is>
  void append_impl(const utils::SoAStorage<SoAArraysType> &valArrays, std::index_sequence<Is...>) {
    // fold expression
    (appendSingleArray<Is>(valArrays), ...);
  }
 
  // actual implementation of append
  template <std::size_t... Is>
  void append_impl(const SoAView<SoAArraysType> &valArrays, std::index_sequence<Is...>) {
    // fold expression
    (appendSingleArray<Is>(valArrays), ...);
  }
 
  // ------------- members ---------------
 
  // storage container for the SoA's
  utils::SoAStorage<SoAArraysType> soaStorage;
};
}  // namespace autopas