scene.hpp

Go to the documentation of this file.

#pragma once
 
#include "bonded_spheres.hpp"
#include "bonded_voronois.hpp"
#include "contact_model.hpp"
#include "contact_pp.hpp"
#include "contact_pw.hpp"
#include "particle.hpp"
#include "shape.hpp"
#include "wall.hpp"
#include <list>
#include <unordered_map>
#include <unordered_set>
 
namespace netdem {
 
class Simulation;
class DEMSolver;
class MPIManager;
 
class Scene {
  friend class DEMSolver;
  friend class MPIManager;
 
public:
  Vec3d gravity_coef{0, 0, -9.81};
 
  VecXT<Wall *> wall_list;
 
  MiniMap<int, ContactModel *> contact_model_map;
 
  VecXT<VecXT<ContactModel *>> bond_model_table;
  VecXT<VecXT<ContactModel *>> collision_model_table;
 
  VecXT<Particle *> particle_list;
 
protected:
  VecXT<Particle *> particle_ghost_list;
 
  VecXT<Particle *> particle_proxy_list;
 
  VecXT<Wall *> wall_ghost_list;
 
  std::unordered_map<int, Particle *> particle_map;
 
  std::unordered_map<int, Shape *> shape_map;
 
  VecXT<Shape *> local_shape_list;
 
public:
  Scene();
 
  void Init(Simulation *const sim);
 
  Shape *InsertShape(const Shape *const s_ptr);
 
  VecXT<Shape *> InsertShape(const VecXT<Shape *> &s_list);
 
  Particle *InsertParticleLocal(const Particle *const p_ptr);
 
  Particle *InsertParticle(const Particle *const p_ptr);
 
  Particle *InsertParticle(Particle const &p);
 
  VecXT<Particle *> InsertParticle(const VecXT<Particle *> &p_list);
 
  VecXT<Particle *> InsertParticle(const VecXT<Particle> &p_list);
 
  void InsertParticle(const BondedSpheres *const p_ptr);
 
  void InsertParticle(const VecXT<BondedSpheres *> &p_list);
 
  void InsertParticle(const VecXT<BondedSpheres> &p_list);
 
  void InsertParticle(const BondedVoronois *const p_ptr);
 
  void InsertParticle(const VecXT<BondedVoronois *> &p_list);
 
  void InsertParticle(const VecXT<BondedVoronois> &p_list);
 
  Particle *InsertDerivedParticle(Particle const *p_ptr);
 
  VecXT<Particle *> InsertDerivedParticle(const VecXT<Particle *> &p_list);
 
  Wall *InsertWall(const Wall *const w_ptr);
 
  Wall *InsertWall(Wall const &w);
 
  VecXT<Wall *> InsertWall(const VecXT<Wall *> &w_list);
 
  VecXT<Wall *> InsertWall(const VecXT<Wall> &w_list);
 
  void RemoveShape(Shape *s_ptr);
 
  void RemoveParticle(Particle *p_ptr);
 
  void RemoveParticle(int id);
 
  void RemoveWall(Wall *w_ptr);
 
  void RemoveWall(int id);
 
  ContactModel *InsertContactModel(const ContactModel *const cm_ptr);
 
  VecXT<ContactModel *>
  InsertContactModel(const VecXT<ContactModel *> &cm_list);
 
  VecXT<Shape *> GetShapes();
 
  bool InScene(const Shape *const s_ptr);
 
  bool InScene(const ContactModel *const cnt_ptr);
 
  void SetNumberOfMaterials(int num);
 
  void SetBondModel(int mat_type_1, int mat_type_2,
                    ContactModel *const cnt_model);
 
  void SetBondModel(int mat_type_1, int mat_type_2, std::string const &label);
 
  void SetCollisionModel(int mat_type_1, int mat_type_2,
                         ContactModel *const cnt_model);
 
  void SetCollisionModel(int mat_type_1, int mat_type_2,
                         std::string const &label);
 
  void SetGravity(double gx, double gy, double gz);
 
  ContactModel *GetBondModel(Particle *p1, Particle *p2);
 
  Domain *GetDomain() const;
 
  ContactModel *GetBondModel(Particle *p, Wall *w);
 
  ContactModel *GetCollisionModel(Particle *p1, Particle *p2);
 
  ContactModel *GetCollisionModel(Particle *p, Wall *w);
 
  void AutoReadRestart(std::string const &path, int mech_cyc,
                       int shape_info_case = 0, std::string filecase = "vtk");
 
  void ReadRestartShapesVTK(std::string const &file);
 
  void ReadRestartParticlesVTK(std::string const &file);
 
  void ReadRestartWallsVTK(std::string const &file);
 
  void ReadRestartContactsVTK(std::string const &file);
 
  void ReadRestartShapesJSON(std::string const &file);
 
  void ReadRestartParticlesJSON(std::string const &file);
 
  void ReadRestartWallsJSON(std::string const &file);
 
  void ReadRestartContactsJSON(std::string const &file);
 
  VecXT<Particle *> const &GetParticles();
 
  VecXT<Wall *> const &GetWalls();
 
  VecXT<ContactPP *> GetContactPPs();
 
  VecXT<ContactPW *> GetContactPWs();
 
  std::unordered_map<int, Shape *> const &GetShapeMap();
 
  VecXT<Particle *> GetParticlesWithProxy();
 
  void ClearShape();
 
  void ClearParticle();
 
  void ClearWall();
 
  void ClearContactModels();
 
  void ClearContacts();
 
  Particle *FindParticle(int id);
 
  Particle *FindParticleWithProxy(int id);
 
  Wall *FindWall(int id);
 
  ~Scene();
 
private:
  Simulation *sim{nullptr};
 
  static const int max_num_particles{2000000};
 
  static const int max_num_shapes{2000000};
 
  int max_id_particles{-1};
 
  int max_id_walls{-1};
 
  int max_id_shapes{-1};
};
 
} // namespace netdem