particle.hpp

Go to the documentation of this file.

#pragma once
 
#include "mini_map.hpp"
#include "neigh_tuple.hpp"
#include "shape.hpp"
#include "shape_trimesh.hpp"
#include <unordered_map>
 
namespace netdem {
 
class Wall;
class ContactPP;
class ContactPW;
 
class Cell;
class CellManager;
class Domain;
class DomainManager;
class MPIManager;
class DEMSolver;
 
class NeighPofP;
class NeighWofP;
class NeighPofW;
 
class Particle {
public:
  friend class Wall;
  friend class Cell;
  friend class Domain;
  friend class MPIManager;
  friend class DEMSolver;
  friend class NeighPofP;
  friend class NeighWofP;
  friend class NeighPofW;
 
  int id{0};
 
  Shape *shape{nullptr};
 
  Vec3d bound_min{0, 0, 0};
 
  Vec3d bound_max{0, 0, 0};
 
  double margin{0};
 
  Vec3d bound_disp{0, 0, 0};
 
  int material_type{0};
 
protected:
  double density{2650};
 
public:
  double mass{0.0};
 
  Vec3d moi_principal{0, 0, 0};
 
  double damp_viscous{0};
 
  double damp_numerical{0};
 
  Vec3d pos{0, 0, 0};
 
  Vec4d quaternion{1, 0, 0, 0};
 
  Vec3d vel{0, 0, 0};
 
  Vec3d spin{0, 0, 0};
 
  Vec3d vel_m0p5{0, 0, 0};
 
  Vec3d spin_principal{0, 0, 0};
 
  Vec3d force{0, 0, 0};
 
  Vec3d moment{0, 0, 0};
 
  MiniMap<std::string, double> dynamic_properties;
 
  bool enable_bound_aabb{false};
 
  bool need_update_linked_list{true};
 
protected:
  VecXT<std::pair<Cell *, int>> linked_cell_list;
 
  VecXT<NeighPofP> linked_particle_list;
 
  VecXT<NeighWofP> linked_wall_list;
 
  VecXT<NeighPofP> contact_pp_ref_table;
 
  VecXT<NeighWofP> contact_pw_ref_table;
 
  bool is_on_edge{false};
 
  bool need_send_out{false};
 
  VecXT<std::pair<Domain *, int>> linked_domain_list;
 
public:
  bool need_update_stl_model{false};
 
protected:
  STLModel stl_model;
 
public:
  Particle();
 
  Particle(Shape *const shape);
 
  virtual Particle *Clone() const;
 
  virtual void Init();
 
  virtual void SetShape(Shape *const shape);
 
  virtual void SetDensity(double dens);
 
  virtual double GetDensity() const;
 
  virtual void SetMargin(double m);
 
  virtual double GetMargin() const;
 
  virtual void SetForce(double fx, double fy, double fz);
 
  virtual void SetMoment(double mx, double my, double mz);
 
  virtual void SetPosition(double pos_x, double pos_y, double pos_z);
 
  virtual void SetRodrigues(double angle, double axis_x, double axis_y,
                            double axis_z);
 
  virtual void SetQuaternion(double q_0, double q_1, double q_2, double q_3);
 
  virtual void SetVelocity(double v_x, double v_y, double v_z);
 
  virtual void SetSpin(double spin_x, double spin_y, double spin_z);
 
  virtual Vec3d GetVelocity(Vec3d const &cnt_pos);
 
  virtual void SetDynamicProperty(std::string const &key, double value);
 
  virtual double GetDynamicProperty(std::string const &key);
 
  virtual void AddForce(const Vec3d &force);
 
  virtual void AddMoment(const Vec3d &moment);
 
  virtual void AddForceAtomic(const Vec3d &f);
 
  virtual void AddMomentAtomic(const Vec3d &m);
 
  virtual void ClearForce();
 
  virtual void ClearMoment();
 
  virtual void ApplyContactForce(ContactPP const *cnt);
 
  virtual void ApplyContactForce(ContactPW const *cnt);
 
  virtual void UpdateContactForce();
 
  virtual void UpdateMotion(double timestep);
 
  virtual void UpdateBoundFast();
 
  virtual void UpdateBound();
 
protected:
  void RemoveLinkedCell(int lookup_id);
 
  void RemoveLinkedDomain(int lookup_id);
 
  void RemoveLinkedParticle(int lookup_id);
 
  void RemoveLinkedWall(int lookup_id);
 
  void RemoveContactRefPP(int lookup_id);
 
  void RemoveContactRefPW(int lookup_id);
 
public:
  void ClearLinkedCells();
 
  void ClearLinkedDomains();
 
  void ClearLinkedNeighs();
 
  void BuildContactRefTable();
 
  void ClearContactRefTable();
 
  void UpdateLinkedDomains(DomainManager *const dm);
 
  void UpdateLinkedCells(CellManager *const cm);
 
  void UpdateLinkedNeighs(Domain *const domain);
 
  VecXT<ContactPP *> GetContactPPs();
 
  VecXT<ContactPW *> GetContactPWs();
 
  VecXT<std::pair<Domain *, int>> const &GetLinkedDomains();
 
  VecXT<std::pair<Cell *, int>> const &GetLinkedCells();
 
  VecXT<NeighPofP> const &GetLinkedParticles();
 
  VecXT<NeighWofP> const &GetLinkedWalls();
 
  NeighPofP *const GetLinkedParticle(int lookup_id);
 
  NeighWofP *const GetLinkedWall(int lookup_id);
 
protected:
  NeighPofP *const GetLinkedContactRefPP(int lookup_id);
 
  NeighWofP *const GetLinkedContactRefPW(int lookup_id);
 
public:
  virtual void UpdateSTLModel();
 
  virtual STLModel GetSTLModel(int num_nodes = 200);
 
  virtual STLModel *GetSTLModelInternal();
 
  virtual void SaveAsVTK(std::string const &filename);
 
  virtual void Print() const;
 
  virtual ~Particle();
 
public:
  NeighPofP *LinkToParticle(Particle *const q);
 
  NeighWofP *LinkToWall(Wall *const w);
 
  int LinkToCell(Cell *const cell);
 
  int LinkToDomain(Domain *const domain);
 
protected:
  NeighPofP *BuildContactRefPP(Particle *const q, ContactPP *const cnt);
 
  NeighWofP *BuildContactRefPW(Wall *const w, ContactPW *const cnt);
 
public:
  int FindLinkedParticle(Particle *const q);
 
  int FindLinkedWall(Wall *const w);
 
protected:
  int FindContactRefPP(Particle *const q);
 
  int FindContactRefPW(Wall *const w);
};
 
} // namespace netdem