NeighborListsBuffer.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <unordered_map>
#include <vector>
 
#include "autopas/utils/ExceptionHandler.h"
 
namespace autopas {
template <class Key, class Value, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
class NeighborListsBuffer {
 public:
  template <bool throwIfIndexOutOfBounds = false>
  std::vector<Value> &getNeighborListRef(size_t index) {
    if constexpr (throwIfIndexOutOfBounds) {
      if (index > _lastValidListIndex) {
        autopas::utils::ExceptionHandler::exception(
            "NeighborListsBuffer::getNeighborListRef() index out of bounds: {} > {}", index, _lastValidListIndex);
      }
    }
    return _neighborLists[index];
  }
 
  template <bool throwIfKeyIsUnknown = false>
  std::vector<Value> &getNeighborListRef(const Key &key) {
    if constexpr (throwIfKeyIsUnknown) {
      if (_keyMap.find(key) == _keyMap.end()) {
        autopas::utils::ExceptionHandler::exception("NeighborListsBuffer::getNeighborListRef() unknown key: {}", key);
      }
    }
    return _neighborLists[_keyMap[key]];
  }
 
  size_t getNewNeighborList() {
    // if the buffer is saturated...
    if (_lastValidListIndex >= _neighborLists.size()) {
      // ...grow it and initialize all new lists. Make sure to grow to at least 10 lists.
      _neighborLists.resize(std::max(10ul, static_cast<size_t>(_neighborLists.size() * _growthFactor)),
                            std::vector<Value>(_defaultListLength));
    }
    ++_lastValidListIndex;
    _neighborLists[_lastValidListIndex].clear();
    return _lastValidListIndex;
  }
 
  size_t getNewNeighborList(const Key &key) {
    const auto newIndex = getNewNeighborList();
    _keyMap.emplace(key, newIndex);
    return newIndex;
  }
 
  void clear() {
    _keyMap.clear();
    _lastValidListIndex = std::numeric_limits<size_t>::max();
  }
 
  void reserveNeighborLists(size_t n) { _neighborLists.resize(n, std::vector<Value>(_defaultListLength)); }
 
  void setDefaultListLength(size_t defaultListLength) { NeighborListsBuffer::_defaultListLength = defaultListLength; }
 
  void setGrowthFactor(double growthFactor) { NeighborListsBuffer::_growthFactor = growthFactor; }
 
 private:
  std::unordered_map<Key, size_t, Hash, KeyEqual> _keyMap{};
  std::vector<std::vector<Value>> _neighborLists{};
  size_t _lastValidListIndex{std::numeric_limits<size_t>::max()};
  size_t _defaultListLength{10};
  double _growthFactor{2};
};
}  // namespace autopas