wall.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 Particle;
class ContactPW;
 
class Cell;
class CellManager;
class Domain;
class DomainManager;
class MPIManager;
class DEMSolver;
 
class NeighPofW;
class NeighWofP;
 
class Wall {
public:
  friend class Particle;
  friend class Cell;
  friend class Domain;
  friend class MPIManager;
  friend class DEMSolver;
  friend class NeighPofW;
  friend class NeighWofP;
 
  int id{0};
 
  int id_in_list{0};
 
  std::string label{"default"};
 
  Shape *shape;
 
  int material_type{0};
 
  bool enable_rotation{false}, enable_bound_aabb{true};
 
  Vec3d bound_min, bound_max, bound_disp{0, 0, 0};
 
  Vec3d pos{0, 0, 0};
 
  Vec4d quaternion{1, 0, 0, 0};
 
  Vec3d force{0, 0, 0}, moment{0, 0, 0};
 
  Vec3d vel{0, 0, 0}, spin{0, 0, 0}, vel_spin{0, 0, 0};
 
  MiniMap<std::string, double> dynamic_properties;
 
  bool need_update_linked_list{true};
 
protected:
  VecXT<std::pair<Cell *, int>> linked_cell_list;
 
  VecXT<NeighPofW> linked_particle_list;
 
  VecXT<NeighPofW> contact_pw_ref_table;
 
public:
  bool need_update_stl_model{false};
 
protected:
  STLModel stl_model;
 
public:
  Wall();
 
  Wall(Shape *const shape);
 
  Wall *Clone() const;
 
  void Init();
 
  void SetShape(Shape *const shape);
 
  void SetPosition(double pos_x, double pos_y, double pos_z);
 
  void SetRodrigues(double angle, double axis_x, double axis_y, double axis_z);
 
  void SetQuaternion(double q_0, double q_1, double q_2, double q_3);
 
  void SetVelocity(double v_x, double v_y, double v_z);
 
  void SetSpin(double spin_x, double spin_y, double spin_z);
 
  void SetVelocitySpin(double spin_x, double spin_y, double spin_z);
 
  Vec3d GetVelocity(Vec3d const &cnt_pos);
 
  void SetDynamicProperty(std::string const &key, double value);
 
  double GetDynamicProperty(std::string const &key);
 
  void AddForce(const Vec3d &f);
 
  void AddMoment(const Vec3d &m);
 
  void AddForceAtomic(const Vec3d &f);
 
  void AddMomentAtomic(const Vec3d &m);
 
  void ClearForce();
 
  void ClearMoment();
 
  void ApplyContactForce(ContactPW const *cnt);
 
  void UpdateContactForce();
 
  void UpdateMotion(double timestep);
 
  void UpdateMotion(const Vec3d &v, const Vec3d &s, double timestep);
 
  void UpdateMotion(const Vec3d &dpos, const Vec4d &dquat);
 
  void UpdateBoundFast();
 
  void UpdateBound();
 
protected:
  void RemoveLinkedCell(int lookup_id);
 
  void RemoveLinkedParticle(int lookup_id);
 
  void RemoveContactRefPW(int lookup_id);
 
public:
  void ClearLinkedCells();
 
  void ClearLinkedNeighs();
 
  void BuildContactRefTable();
 
  void ClearContactRefTable();
 
  void UpdateLinkedCells(CellManager *const cm);
 
  void UpdateLinkedNeighs(Domain *const domain);
 
  VecXT<ContactPW *> GetContactPWs();
 
  VecXT<std::pair<Cell *, int>> const &GetLinkedCells();
 
  VecXT<NeighPofW> const &GetLinkedParticles();
 
  NeighPofW *const GetLinkedParticle(int lookup_id);
 
protected:
  NeighPofW *const GetLinkedContactRefPW(int lookup_id);
 
public:
  void UpdateSTLModel();
 
  STLModel GetSTLModel(int num_nodes = 200);
 
  STLModel *GetSTLModelInternal();
 
  void SaveAsVTK(std::string const &filename);
 
  void Print();
 
  ~Wall();
 
public:
  int FindLinkedParticle(Particle *const p);
 
protected:
  int FindContactRefPW(Particle *const p);
 
public:
  int LinkToCell(Cell *const cell);
 
  NeighPofW *LinkToParticle(Particle *const p);
};
 
} // namespace netdem