Particle.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
#include "utils/ArrayUtils.h"
#include "utils/Enums.h"
 
class Particle {
   private:
    std::array<double, 3> x{};
 
    std::array<double, 3> v{};
 
    std::array<double, 3> f{};
 
    std::array<double, 3> old_f{};
 
    double m;
 
    int type;
 
    double epsilon;
 
    double sigma;
 
    LockState lock_state;
 
#if PARALLEL_V2
    mutable std::mutex mutex_f;
#endif
 
    std::vector<std::tuple<long, double, double>> connected_particles;
 
   public:
    Particle(const Particle& other);
 
    Particle(std::array<double, 3> x_arg, std::array<double, 3> v_arg, double m_arg, int type = 0, double epsilon_arg = 1.0,
             double sigma_arg = 1.2, LockState lock_state = LockState::UNLOCKED);
 
    Particle(std::array<double, 3> x_arg, std::array<double, 3> v_arg, std::array<double, 3> f_arg, std::array<double, 3> old_f_arg,
             double m_arg, int type = 0, double epsilon_arg = 1.0, double sigma_arg = 1.2, LockState lock_state = LockState::UNLOCKED);
 
    virtual ~Particle();
 
    Particle& operator=(const Particle& other);
 
    inline void setX(const std::array<double, 3>& x) { this->x = x; }
 
    inline void setV(const std::array<double, 3>& v) { this->v = v; }
 
    inline void setF(const std::array<double, 3>& f) { this->f = f; }
 
    inline void addF(const std::array<double, 3>& force) {
#if PARALLEL_V2
        std::lock_guard lock(mutex_f);
#endif
        f = f + force;
    }
 
    inline void subF(const std::array<double, 3>& force) {
#if PARALLEL_V2
        std::lock_guard lock(mutex_f);
#endif
        f = f - force;
    }
 
    inline void setOldF(const std::array<double, 3>& oldF) { old_f = oldF; }
 
    [[nodiscard]] inline const std::array<double, 3>& getX() const { return x; }
 
    [[nodiscard]] inline const std::array<double, 3>& getV() const { return v; }
 
    [[nodiscard]] inline const std::array<double, 3>& getF() const { return f; }
 
    [[nodiscard]] inline const std::array<double, 3>& getOldF() const { return old_f; }
 
    [[nodiscard]] inline double getM() const { return m; }
 
    [[nodiscard]] inline int getType() const { return type; }
 
    [[nodiscard]] inline double getEpsilon() const { return epsilon; }
 
    [[nodiscard]] inline double getSigma() const { return sigma; }
 
    inline void setLocked(LockState new_lock_state) { lock_state = new_lock_state; }
 
    [[nodiscard]] inline bool isLocked() const { return lock_state == LockState::LOCKED; }
 
    [[nodiscard]] inline const std::vector<std::tuple<long, double, double>>& getConnectedParticles() const { return connected_particles; }
 
    void addConnectedParticle(long ptr_diff, double l_0, double k);
 
    bool operator==(Particle& other);
 
    bool operator==(const Particle& other) const;
 
    [[nodiscard]] std::string toString() const;
};
 
std::ostream& operator<<(std::ostream& stream, Particle& p);