SPHParticle.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstring>
#include <vector>
 
#include "autopas/particles/ParticleDefinitions.h"
 
namespace sphLib {
class SPHParticle : public autopas::ParticleBaseFP64 {
 public:
  SPHParticle()
      : autopas::ParticleBaseFP64(),
        _density(0.),
        _pressure(0.),
        _mass(0.),
        _smth(0.),
        _snds(0.),
        // temporaries / helpers
        _v_sig_max(0.),
        _acc{0., 0., 0.},
        _energy_dot(0.),
        _energy(0.),
        _dt(0.),
        _vel_half{0., 0., 0.},
        _eng_half(0.) {}
  SPHParticle(const std::array<double, 3> &r, const std::array<double, 3> &v, unsigned long id)
      : autopas::ParticleBaseFP64(r, v, id),
        _density(0.),
        _pressure(0.),
        _mass(0.),
        _smth(0.),
        _snds(0.),
        // temporaries / helpers
        _v_sig_max(0.),
        _acc{0., 0., 0.},
        _energy_dot(0.),
        _energy(0.),
        _dt(0.),
        _vel_half{0., 0., 0.},
        _eng_half(0.) {}
 
  SPHParticle(const std::array<double, 3> &r, const std::array<double, 3> &v, unsigned long id, double mass,
              double smth, double snds)
      : autopas::ParticleBaseFP64(r, v, id),
        _density(0.),
        _pressure(0.),
        _mass(mass),
        _smth(smth),
        _snds(snds),
        // temporaries / helpers
        _v_sig_max(0.),
        _acc{0., 0., 0.},
        _energy_dot(0.),
        _energy(0.),
        _dt(0.),
        _vel_half{0., 0., 0.},
        _eng_half(0.) {}
 
  ~SPHParticle() override = default;
 
  double getDensity() const { return _density; }
 
  void addDensity(double density) { _density += density; }
 
  void setDensity(double density) { _density = density; }
 
  double getPressure() const { return _pressure; }
 
  void calcPressure();
 
  void setPressure(double pressure) { _pressure = pressure; }
 
  double getMass() const { return _mass; }
 
  void setMass(double mass) { _mass = mass; }
 
  double getSmoothingLength() const { return _smth; }
 
  void setSmoothingLength(double smth) { _smth = smth; }
 
  double getSoundSpeed() const { return _snds; }
 
  void setSoundSpeed(double snds) { _snds = snds; }
 
  double getVSigMax() const { return _v_sig_max; }
 
  void checkAndSetVSigMax(double v_sig) { _v_sig_max = std::max(v_sig, _v_sig_max); }
 
  void setVSigMax(double v_sig_max) { _v_sig_max = v_sig_max; }
 
  const std::array<double, 3> &getAcceleration() const { return _acc; }
 
  void addAcceleration(const std::array<double, 3> &acc);
 
  void subAcceleration(const std::array<double, 3> &acc);
 
  void setAcceleration(const std::array<double, 3> &acc) { _acc = acc; }
 
  double getEngDot() const { return _energy_dot; }
 
  void addEngDot(double eng_dot) { _energy_dot += eng_dot; }
 
  void setEngDot(double eng_dot) { _energy_dot = eng_dot; }
 
  double getEnergy() const { return _energy; }
 
  void setEnergy(double energy) { _energy = energy; }
 
  void addEnergy(double energy) { _energy += energy; }
 
  double getDt() const { return _dt; }
 
  void setDt(double dt) { _dt = dt; }
 
  void calcDt() {
    const double C_CFL = 0.3;
    _dt = C_CFL * 2.0 * _smth / _v_sig_max;
  }
 
  const std::array<double, 3> &getVel_half() const { return _vel_half; }
 
  void setVel_half(const std::array<double, 3> &vel_half) { SPHParticle::_vel_half = vel_half; }
 
  double getEng_half() const { return _eng_half; }
 
  void setEng_half(double eng_half) { SPHParticle::_eng_half = eng_half; }
 
  std::vector<double> serialize() const {
    std::vector<double> stream;
    for (int i = 0; i < 3; i++) {
      stream.push_back(this->getR()[i]);
    }
    for (int i = 0; i < 3; i++) {
      stream.push_back(this->getV()[i]);
    }
 
    for (int i = 0; i < 3; i++) {
      // stream.push_back(this->getF()[i]);  // not actually needed
    }
    auto id = this->getID();
    double id_dbl;
    memcpy(&id_dbl, &id, sizeof(double));
    static_assert(sizeof(id) == sizeof(double), "sizes should be the same, otherwise the above will not work");
 
    stream.push_back(id_dbl);
    stream.push_back(_density);
    stream.push_back(_pressure);
    stream.push_back(_mass);
    stream.push_back(_smth);
    stream.push_back(_snds);
 
    for (int i = 0; i < 3; i++) {
      stream.push_back(this->getAcceleration()[i]);
    }
    stream.push_back(_energy_dot);
    stream.push_back(_energy);
    // stream.push_back(_dt); // not needed
    for (int i = 0; i < 3; i++) {
      stream.push_back(this->getVel_half()[i]);
    }
    stream.push_back(_eng_half);
    return stream;
  }
 
  static SPHParticle deserialize(const double *stream, size_t &index) {
    std::array<double, 3> r = {stream[index], stream[index + 1], stream[index + 2]};
    index += 3;
    std::array<double, 3> v = {stream[index], stream[index + 1], stream[index + 2]};
    index += 3;
    // std::array<double,3> F = {stream[index], stream[index+1],
    // stream[index+2]};  // not needed
    // index+=3  // not needed
    double id_dbl = stream[index++];
    unsigned long id;
    memcpy(&id, &id_dbl, sizeof(double));
    static_assert(sizeof(id) == sizeof(double), "sizes should be the same, otherwise the above will not work");
 
    double density = stream[index++];
    double pressure = stream[index++];
 
    double mass = stream[index++];
    double smth = stream[index++];
    double snds = stream[index++];
 
    std::array<double, 3> ac = {stream[index], stream[index + 1], stream[index + 2]};
    index += 3;
    double energy_dot = stream[index++];
    double energy = stream[index++];
    // double dt = stream[index++];  // not needed
    std::array<double, 3> vel_half = {stream[index], stream[index + 1], stream[index + 2]};
    index += 3;
    double eng_half = stream[index++];
 
    SPHParticle p = SPHParticle(r, v, id, mass, smth, snds);
    p.setDensity(density);
    p.setPressure(pressure);
    p.setAcceleration(ac);
    p.setEngDot(energy_dot);
    p.setEnergy(energy);
    p.setVel_half(vel_half);
    p.setEng_half(eng_half);
    return p;
  }
 
  enum AttributeNames : int {
    ptr,
    mass,
    posX,
    posY,
    posZ,
    smth,
    density,
    velX,
    velY,
    velZ,
    soundSpeed,
    pressure,
    vsigmax,
    accX,
    accY,
    accZ,
    engDot,
    ownershipState
  };
 
  using SoAArraysType = autopas::utils::SoAType<SPHParticle *,
                                                double,  // mass
                                                double,  // posX
                                                double,  // posY
                                                double,  // posZ
                                                double,  // smth
                                                double,  // density
                                                double,  // velX
                                                double,  // velY
                                                double,  // velZ
                                                double,  // soundSpeed
                                                double,  // pressure
                                                double,  // vsigmax
                                                double,  // accX
                                                double,  // accY
                                                double,  // accZ
                                                double,  // engDot
                                                autopas::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::mass) {
      return getMass();
    } 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::smth) {
      return getSmoothingLength();
    } else if constexpr (attribute == AttributeNames::density) {
      return getDensity();
    } else if constexpr (attribute == AttributeNames::velX) {
      return getV()[0];
    } else if constexpr (attribute == AttributeNames::velY) {
      return getV()[1];
    } else if constexpr (attribute == AttributeNames::velZ) {
      return getV()[2];
    } else if constexpr (attribute == AttributeNames::soundSpeed) {
      return getSoundSpeed();
    } else if constexpr (attribute == AttributeNames::pressure) {
      return getPressure();
    } else if constexpr (attribute == AttributeNames::vsigmax) {
      return getVSigMax();
    } else if constexpr (attribute == AttributeNames::accX) {
      return getAcceleration()[0];
    } else if constexpr (attribute == AttributeNames::accY) {
      return getAcceleration()[1];
    } else if constexpr (attribute == AttributeNames::accZ) {
      return getAcceleration()[2];
    } else if constexpr (attribute == AttributeNames::engDot) {
      return getEngDot();
    } else if constexpr (attribute == AttributeNames::ownershipState) {
      return this->_ownershipState;
    } else {
      autopas::utils::ExceptionHandler::exception("SPHParticle::get: unknown attribute");
    }
  }
 
  template <AttributeNames attribute>
  constexpr void set(typename std::tuple_element<attribute, SoAArraysType>::type::value_type value) {
    if constexpr (attribute == AttributeNames::mass) {
      setMass(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::smth) {
      setSmoothingLength(value);
    } else if constexpr (attribute == AttributeNames::density) {
      setDensity(value);
    } else if constexpr (attribute == AttributeNames::velX) {
      _v[0] = value;
    } else if constexpr (attribute == AttributeNames::velY) {
      _v[1] = value;
    } else if constexpr (attribute == AttributeNames::velZ) {
      _v[2] = value;
    } else if constexpr (attribute == AttributeNames::soundSpeed) {
      setSoundSpeed(value);
    } else if constexpr (attribute == AttributeNames::pressure) {
      setPressure(value);
    } else if constexpr (attribute == AttributeNames::vsigmax) {
      setVSigMax(value);
    } else if constexpr (attribute == AttributeNames::accX) {
      _acc[0] = value;
    } else if constexpr (attribute == AttributeNames::accY) {
      _acc[1] = value;
    } else if constexpr (attribute == AttributeNames::accZ) {
      _acc[2] = value;
    } else if constexpr (attribute == AttributeNames::engDot) {
      setEngDot(value);
    } else if constexpr (attribute == AttributeNames::ownershipState) {
      _ownershipState = value;
    } else {
      autopas::utils::ExceptionHandler::exception("SPHParticle::set: unknown attribute");
    }
  }
 
 private:
  double _density;   // density
  double _pressure;  // pressure
  double _mass;      // mass
  double _smth;      // smoothing length
  double _snds;      // speed of sound
 
  // temporaries / helpers
  double _v_sig_max;
 
  // integrator
  std::array<double, 3> _acc;  // acceleration
  double _energy_dot;          // time derivative of the energy
  double _energy;              // energy
  double _dt;                  // local timestep allowed by this particle
 
  // integrator
  std::array<double, 3> _vel_half;  // velocity at half time-step
  double _eng_half;                 // energy at half time-step
};
}  // namespace sphLib