ParticleBase.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <sstream>
#include <tuple>
 
#include "autopas/particles/OwnershipState.h"
#include "autopas/utils/ArrayMath.h"
#include "autopas/utils/ArrayUtils.h"
#include "autopas/utils/ExceptionHandler.h"
#include "autopas/utils/SoAStorage.h"
#include "autopas/utils/SoAType.h"
#include "autopas/utils/markParticleAsDeleted.h"
 
namespace autopas {
 
template <typename floatType, typename idType>
class ParticleBase {
 public:
  ParticleBase()
      : _r({0.0, 0.0, 0.0}),
        _v({0., 0., 0.}),
        _f({0.0, 0.0, 0.0}),
        _id(0),
        _ownershipState(OwnershipState::owned)
#ifdef AUTOPAS_ENABLE_DYNAMIC_CONTAINERS
        ,
        _rAtRebuild({0.0, 0.0, 0.0})
#endif
  {
  }
 
  ParticleBase(const std::array<double, 3> &r, const std::array<double, 3> &v, idType id,
               OwnershipState ownershipState = OwnershipState::owned)
      : _r(r),
        _v(v),
        _f({0.0, 0.0, 0.0}),
        _id(id),
        _ownershipState(ownershipState)
#ifdef AUTOPAS_ENABLE_DYNAMIC_CONTAINERS
        ,
        _rAtRebuild(r)
#endif
  {
  }
 
  virtual ~ParticleBase() = default;
 
 protected:
  std::array<floatType, 3> _r;
 
#ifdef AUTOPAS_ENABLE_DYNAMIC_CONTAINERS
  std::array<floatType, 3> _rAtRebuild;
#endif
 
  std::array<floatType, 3> _v;
 
  std::array<floatType, 3> _f;
 
  idType _id;
 
  OwnershipState _ownershipState;
 
 public:
  template <typename T, typename P>
  friend std::ostream &operator<<(std::ostream &os, const autopas::ParticleBase<T, P> &D);
 
  bool operator==(const ParticleBase &rhs) const {
    return std::tie(_r, _v, _f, _id) == std::tie(rhs._r, rhs._v, rhs._f, rhs._id);
  }
 
  bool operator!=(const ParticleBase &rhs) const { return not(rhs == *this); }
 
  [[nodiscard]] const std::array<double, 3> &getF() const { return _f; }
 
  void setF(const std::array<double, 3> &f) { _f = f; }
 
  void addF(const std::array<double, 3> &f) {
    using namespace autopas::utils::ArrayMath::literals;
    _f += f;
  }
 
  void subF(const std::array<double, 3> &f) {
    using namespace autopas::utils::ArrayMath::literals;
    _f -= f;
  }
 
  idType getID() const { return _id; }
 
  void setID(idType id) { _id = id; }
 
  [[nodiscard]] const std::array<double, 3> &getR() const { return _r; }
 
  void setR(const std::array<double, 3> &r) { _r = r; }
 
#ifdef AUTOPAS_ENABLE_DYNAMIC_CONTAINERS
  [[nodiscard]] const std::array<double, 3> &getRAtRebuild() const { return _rAtRebuild; }
  void setRAtRebuild(const std::array<double, 3> &r) { _rAtRebuild = r; }
 
  void resetRAtRebuild() { this->setRAtRebuild(_r); }
 
  const std::array<double, 3> calculateDisplacementSinceRebuild() const {
    return utils::ArrayMath::sub(_rAtRebuild, _r);
  }
#endif
 
  bool setRDistanceCheck(const std::array<double, 3> &r, double maxDistSquared) {
    using namespace autopas::utils::ArrayMath::literals;
    const auto distanceVec = r - _r;
    const double distanceSquared = utils::ArrayMath::dot(distanceVec, distanceVec);
    setR(r);
    const bool distanceIsFine =
        distanceSquared < maxDistSquared or autopas::utils::Math::isNearAbs(maxDistSquared, 0., 1e-12);
    if (not distanceIsFine) {
      AutoPasLog(WARN, "Particle {}: Distance between old and new position is larger than expected: {} > {}", _id,
                 distanceSquared, maxDistSquared);
    }
    return distanceIsFine;
  }
 
  void addR(const std::array<double, 3> &r) {
    using namespace autopas::utils::ArrayMath::literals;
    _r += r;
  }
 
  bool addRDistanceCheck(const std::array<double, 3> &r, double maxDistSquared) {
    using namespace autopas::utils::ArrayMath::literals;
    const auto newR = _r + r;
    return setRDistanceCheck(newR, maxDistSquared);
  }
 
  [[nodiscard]] const std::array<double, 3> &getV() const { return _v; }
 
  void setV(const std::array<double, 3> &v) { _v = v; }
 
  void addV(const std::array<double, 3> &v) {
    using namespace autopas::utils::ArrayMath::literals;
    _v += v;
  }
 
  [[nodiscard]] virtual std::string toString() const {
    std::ostringstream text;
    // clang-format off
    text << "Particle"
         << "\nID      : " << _id
         << "\nPosition: "
         << autopas::utils::ArrayUtils::to_string(_r)
         << "\nVelocity: "
         << autopas::utils::ArrayUtils::to_string(_v)
         << "\nForce   : "
         << autopas::utils::ArrayUtils::to_string(_f)
         << "\nOwnershipState : "
         << _ownershipState;
    // clang-format on
    return text.str();
  }
  [[nodiscard]] bool isOwned() const { return _ownershipState == OwnershipState::owned; }
 
  [[nodiscard]] bool isHalo() const { return _ownershipState == OwnershipState::halo; }
 
  [[nodiscard]] bool isDummy() const { return _ownershipState == OwnershipState::dummy; }
 
  [[nodiscard]] OwnershipState getOwnershipState() const { return _ownershipState; }
 
  void setOwnershipState(OwnershipState ownershipState) { _ownershipState = ownershipState; }
 
  enum AttributeNames : int { ptr, id, posX, posY, posZ, forceX, forceY, forceZ, ownershipState };
 
  using ParticleSoAFloatPrecision = floatType;
 
  using ParticleIdType = idType;
 
  using SoAArraysType =
      typename autopas::utils::SoAType<ParticleBase<floatType, idType> *, idType /*id*/, floatType /*x*/,
                                       floatType /*y*/, floatType /*z*/, floatType /*fx*/, floatType /*fy*/,
                                       floatType /*fz*/, OwnershipState /*ownershipState*/>::Type;
 
  template <AttributeNames attribute, std::enable_if_t<attribute == AttributeNames::ptr, bool> = true>
  constexpr typename std::tuple_element<attribute, SoAArraysType>::type::value_type get() {
    return this;
  }
 
  template <AttributeNames attribute, std::enable_if_t<attribute != AttributeNames::ptr, bool> = true>
  constexpr typename std::tuple_element<attribute, SoAArraysType>::type::value_type get() const {
    if constexpr (attribute == AttributeNames::id) {
      return getID();
    } else if constexpr (attribute == AttributeNames::posX) {
      return getR()[0];
    } else if constexpr (attribute == AttributeNames::posY) {
      return getR()[1];
    } else if constexpr (attribute == AttributeNames::posZ) {
      return getR()[2];
    } else if constexpr (attribute == AttributeNames::forceX) {
      return getF()[0];
    } else if constexpr (attribute == AttributeNames::forceY) {
      return getF()[1];
    } else if constexpr (attribute == AttributeNames::forceZ) {
      return getF()[2];
    } else if constexpr (attribute == AttributeNames::ownershipState) {
      return this->_ownershipState;
    } else {
      utils::ExceptionHandler::exception("ParticleBase::get() unknown attribute {}", attribute);
    }
  }
 
  template <AttributeNames attribute>
  constexpr void set(typename std::tuple_element<attribute, SoAArraysType>::type::value_type value) {
    if constexpr (attribute == AttributeNames::id) {
      setID(value);
    } else if constexpr (attribute == AttributeNames::posX) {
      _r[0] = value;
    } else if constexpr (attribute == AttributeNames::posY) {
      _r[1] = value;
    } else if constexpr (attribute == AttributeNames::posZ) {
      _r[2] = value;
    } else if constexpr (attribute == AttributeNames::forceX) {
      _f[0] = value;
    } else if constexpr (attribute == AttributeNames::forceY) {
      _f[1] = value;
    } else if constexpr (attribute == AttributeNames::forceZ) {
      _f[2] = value;
    } else if constexpr (attribute == AttributeNames::ownershipState) {
      this->_ownershipState = value;
    } else {
      utils::ExceptionHandler::exception("MoleculeLJ::set() unknown attribute {}", attribute);
    }
  }
 
 private:
  void markAsDeleted() {
    // Set ownership as dummy.
    setOwnershipState(OwnershipState::dummy);
  }
 
  template <class T>
  friend void internal::markParticleAsDeleted(T &);
};
 
template <typename floatType, typename idType>
std::ostream &operator<<(std::ostream &os, const ParticleBase<floatType, idType> &particle) {
  using utils::ArrayUtils::operator<<;
  os << "Particle"
     << "\nID      : " << particle._id << "\nPosition: " << particle._r << "\nVelocity: " << particle._v
     << "\nForce   : " << particle._f << "\nOwnershipState : " << particle._ownershipState;
  // clang-format on
  return os;
}
 
}  // namespace autopas