Particle.h

Go to the documentation of this file.

 
#pragma once
 
#include "utils/OMPWrapper.h"
#include <array>
#include <string>
#include <vector>
 
#define TYPE_DEFAULT 0
#define SIGMA_DEFAULT 1
#define EPSILON_DEFAULT 1
#define K_DEFAULT 0
#define R0_DEFAULT 0
#define FZUP_DEFAULT 0
#define MASS_ERROR "The mass of a particle must be positive for the currently available simulations!"
 
// note: because these are macros, they could also be wrapped in such a way that compiles them out if not needed,
// similarly to what is done below with outflow condition checks; but, since this is not part of any
// performance evaluation environment (see older commit), these are left on by default...
#define DO_IF_NOT_WALL(_p, _expr)                                                                                      \
    if ((_p).getType() != 1) {                                                                                         \
        _expr;                                                                                                         \
    }
#define SKIP_IF_WALL(_p)                                                                                               \
    if ((_p).getType() == 1)                                                                                           \
        continue;
 
#ifdef NOUTFLOW
#define CONTINUE_IF_INACTIVE(p) (void)0
#else
#define CONTINUE_IF_INACTIVE(p)                                                                                        \
    if (!(p).isActive())                                                                                               \
        continue;
#endif
 
class Particle {
  private:
    std::array<double, 3> x;
 
    std::array<double, 3> v;
 
    std::array<double, 3> thermal_motion;
 
    std::array<double, 3> f;
 
    std::array<double, 3> old_f;
 
    std::vector<std::reference_wrapper<Particle>> direct_neighbours;
 
    std::vector<std::reference_wrapper<Particle>> diagonal_neighbours;
 
    double m;
 
    int type; // this could probably be made an enum now
 
    double epsilon;
 
    double sigma;
 
    double k;
 
    double r_0;
 
    double fzup;
 
    int cellIndex;
 
    omp_lock_t lock;
 
    bool active{true};
 
    int id;
 
  public:
    explicit Particle(int type = 0);
 
    Particle(const Particle &other);
 
    Particle(const std::array<double, 3> &x, const std::array<double, 3> &v, double m, int type = TYPE_DEFAULT,
             double eps = EPSILON_DEFAULT, double sigma = SIGMA_DEFAULT, double k = K_DEFAULT, double r_0 = R0_DEFAULT,
             double fzup = FZUP_DEFAULT);
 
    Particle(const std::array<double, 3> &x, const std::array<double, 3> &v, const std::array<double, 3> &f,
             const std::array<double, 3> &old_f, double m, int type, double eps, double sigma, double k, double r_0,
             double fzup, int cellIndex);
 
    virtual ~Particle();
 
    inline std::array<double, 3> &getX() { return x; }
 
    inline std::array<double, 3> &getV() { return v; }
 
    inline std::array<double, 3> &getF() { return f; }
 
    inline std::array<double, 3> &getOldF() { return old_f; }
 
    inline std::vector<std::reference_wrapper<Particle>> &getDirectNeighbours() { return direct_neighbours; }
 
    inline const std::vector<std::reference_wrapper<Particle>> &getDirectNeighbours() const {
        return direct_neighbours;
    }
 
    inline std::vector<std::reference_wrapper<Particle>> &getDiagonalNeighbours() { return diagonal_neighbours; }
 
    inline const std::vector<std::reference_wrapper<Particle>> &getDiagonalNeighbours() const {
        return diagonal_neighbours;
    }
 
    inline const std::array<double, 3> &getX() const { return x; }
 
    inline const std::array<double, 3> &getV() const { return v; }
 
    inline const std::array<double, 3> &getThermalMotion() const { return thermal_motion; }
 
    inline const std::array<double, 3> &getF() const { return f; }
 
    inline const std::array<double, 3> &getOldF() const { return old_f; }
 
    inline double getM() const { return m; }
 
    inline int getType() const { return type; }
 
    inline double getEpsilon() const { return epsilon; }
 
    inline double getSigma() const { return sigma; }
 
    inline double getK() const { return k; }
 
    inline double getR0() const { return r_0; }
 
    inline double getFZUP() const { return fzup; }
 
    inline int getCellIndex() const { return cellIndex; }
 
    inline bool isActive() const { return active; }
 
    inline int getId() const { return id; }
 
    inline omp_lock_t &getLock() { return lock; }
 
    void setX(const std::array<double, 3> &new_x);
 
    void setV(const std::array<double, 3> &new_v);
 
    void setDirectNeighbours(const std::vector<std::reference_wrapper<Particle>> &neighbours);
 
    void setDiagonalNeighbours(const std::vector<std::reference_wrapper<Particle>> &neighbours);
 
    void setThermalMotion(const std::array<double, 3> &new_thermal_motion);
 
    void setF(const std::array<double, 3> &new_f);
 
    void setOldF(const std::array<double, 3> &new_old_f);
 
    void setFToZero();
 
    void setM(double new_m);
 
    void setType(double new_type);
 
    void setEpsilon(double new_eps);
 
    void setSigma(double new_sigma);
 
    void setK(double new_k);
 
    void setFZUP(double new_fzup);
 
    void setR0(double new_r_0);
 
    void setCellIndex(int new_index);
 
    void markInactive();
 
    std::string toString() const;
 
    bool operator==(const Particle &other) const;
 
    bool operator!=(const Particle &other) const;
};
 
std::ostream &operator<<(std::ostream &stream, const Particle &p);