baseParticle.h

Go to the documentation of this file.

/*
 * -------------------------------------------
 * Copyright (c) 2021 - 2026 Prashant K. Jha
 * -------------------------------------------
 * PeriDEM https://github.com/prashjha/PeriDEM
 *
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE)
 */
 
#ifndef PARTICLE_BASEPARTICLE_H
#define PARTICLE_BASEPARTICLE_H
 
#include "refParticle.h"
#include "material/mparticle/material.h"
#include "data/modelData.h"
#include "geom/particleTransform.h"
 
#include <cstdint> // uint8_t type
#include <cstring> // string and size_t type
#include <vector>
 
namespace particle {
 
class BaseParticle {
 
public:
  BaseParticle(size_t id = 0);
 
  BaseParticle(size_t id,
               bool isWall,
               size_t dim,
               std::map<std::string, size_t> groups,
               bool are_all_dofs_constrained,
               size_t num_nodes,
               double h,
               std::shared_ptr<data::ModelData> model_data,
               std::shared_ptr<particle::RefParticle> ref_particle,
               std::shared_ptr<geom::GeomObject> geom,
               geom::ParticleTransform &transform,
               std::shared_ptr<mesh::Mesh> mesh,
               inp::MaterialDeck &material_deck,
               bool populate_data = true);
 
  size_t getId() const { return d_id; };
 
  bool isWall() const { return d_isWall; };
 
  size_t getGroupId(const std::string &key) const { return d_groups.at(key); };
 
  size_t getDimension() const { return d_dim; };
 
  std::shared_ptr<mesh::Mesh> &getMeshP() { return d_mesh_p; };
 
  const std::shared_ptr<mesh::Mesh> &getMeshP() const { return d_mesh_p; };
 
  mesh::Mesh &getMesh() { return *d_mesh_p; };
 
  const mesh::Mesh &getMesh() const { return *d_mesh_p; };
 
  double getMeshSize() const { return d_h; };
 
  double getDensity() const { return d_density; };
 
  double getHorizon() const { return d_horizon; };
 
  material::Material * getMaterial() { return d_material_p.get(); };
  const material::Material * getMaterial() const { return d_material_p.get(); };
 
  size_t getNumNodes() const { return d_numNodes; };
 
  size_t getNodeId(size_t i_loc) const { return i_loc + d_globStart; };
 
  util::Point &getXRef(size_t i) { return d_modelData_p->getXRef(i); };
  const util::Point &getXRef(size_t i) const { return d_modelData_p->getXRef(i); };
 
  void setXRef(size_t i, const util::Point &x) { d_modelData_p->setXRef(i, x); };
 
  void addXRef(size_t i, const util::Point &x) { d_modelData_p->addXRef(i, x); };
 
  void setXRef(size_t i, int dof, double x) {
    d_modelData_p->setXRef(i, dof, x);
  };
 
  void addXRef(size_t i, int dof, double x) {
    d_modelData_p->addXRef(i, dof, x);
  };
 
  util::Point &getXRefLocal(size_t i) { return d_modelData_p->getXRef(i+d_globStart); };
  const util::Point &getXRefLocal(size_t i) const { return d_modelData_p->getXRef(i+d_globStart); };
 
  void setXRefLocal(size_t i, const util::Point &x) { d_modelData_p->setXRef(i+d_globStart, x); };
 
  void addXRefLocal(size_t i, const util::Point &x) { d_modelData_p->addXRef(i+d_globStart, x); };
 
  void setXRefLocal(size_t i, int dof, double x) { d_modelData_p->setXRef
        (i+d_globStart, dof, x); };
 
  void addXRefLocal(size_t i, int dof, double x) { d_modelData_p->addXRef
        (i+d_globStart, dof, x); };
 
  util::Point &getX(size_t i) { return d_modelData_p->getX(i); };
  const util::Point &getX(size_t i) const { return d_modelData_p->getX(i); };
 
  void setX(size_t i, const util::Point &x) { d_modelData_p->setX(i, x); };
 
  void addX(size_t i, const util::Point &x) { d_modelData_p->addX(i, x); };
 
  void setX(size_t i, int dof, double x) { d_modelData_p->setX(i, dof, x); };
 
  void addX(size_t i, int dof, double x) { d_modelData_p->addX(i, dof, x); };
 
  util::Point &getXLocal(size_t i) { return d_modelData_p->getX(i+d_globStart); };
  const util::Point &getXLocal(size_t i) const { return d_modelData_p->getX(i+d_globStart); };
 
  void setXLocal(size_t i, const util::Point &x) { d_modelData_p->setX(i+d_globStart, x); };
 
  void addXLocal(size_t i, const util::Point &x) { d_modelData_p->addX(i+d_globStart, x); };
 
  void setXLocal(size_t i, int dof, double x) { d_modelData_p->setX
                                                (i+d_globStart, dof, x); };
 
  void addXLocal(size_t i, int dof, double x) { d_modelData_p->addX
                                                (i+d_globStart, dof, x); };
 
  util::Point &getU(size_t i) { return d_modelData_p->getU(i); };
  const util::Point &getU(size_t i) const { return d_modelData_p->getU(i); };
 
  void setU(size_t i, const util::Point &u) { d_modelData_p->setU(i, u); };
 
  void addU(size_t i, const util::Point &u) { d_modelData_p->addU(i, u); };
 
  void setU(size_t i, int dof, double u) { d_modelData_p->setU(i, dof, u); };
 
  void addU(size_t i, int dof, double u) { d_modelData_p->addU(i, dof, u); };
 
  util::Point &getULocal(size_t i) { return d_modelData_p->getU(i+d_globStart); };
 
  const util::Point &getULocal(size_t i) const { return d_modelData_p->getU(i+d_globStart); };
 
  void setULocal(size_t i, const util::Point &u) { d_modelData_p->setU(i+d_globStart, u); };
 
  void addULocal(size_t i, const util::Point &u) { d_modelData_p->addU(i+d_globStart, u); };
 
  void setULocal(size_t i, int dof, double u) { d_modelData_p->setU
                                                (i+d_globStart, dof, u); };
 
  void addULocal(size_t i, int dof, double u) { d_modelData_p->addU
                                                (i+d_globStart, dof, u); };
 
  util::Point &getV(size_t i) { return d_modelData_p->getV(i); };
  const util::Point &getV(size_t i) const { return d_modelData_p->getV(i); };
 
  void setV(size_t i, const util::Point &v) { d_modelData_p->setV(i, v); };
 
  void addV(size_t i, const util::Point &v) { d_modelData_p->addV(i, v); };
 
  void setV(size_t i, int dof, double v) { d_modelData_p->setV(i, dof, v); };
 
  void addV(size_t i, int dof, double v) { d_modelData_p->addV(i, dof, v); };
 
  util::Point &getVLocal(size_t i) { return d_modelData_p->getV(i+d_globStart); };
  const util::Point &getVLocal(size_t i) const { return d_modelData_p->getV(i+d_globStart); };
 
  void setVLocal(size_t i, const util::Point &v) { d_modelData_p->setV(i+d_globStart, v); };
 
  void addVLocal(size_t i, const util::Point &v) { d_modelData_p->addV(i+d_globStart, v); };
 
  void setVLocal(size_t i, int dof, double v) { d_modelData_p->setV
                                                (i+d_globStart, dof, v); };
 
  void addVLocal(size_t i, int dof, double v) { d_modelData_p->addV
                                                (i+d_globStart, dof, v); };
 
  util::Point &getF(size_t i) { return d_modelData_p->getF(i); };
  const util::Point &getF(size_t i) const { return d_modelData_p->getF(i); };
 
  void setF(size_t i, const util::Point &f) { d_modelData_p->setF(i, f); };
 
  void addF(size_t i, const util::Point &f) { d_modelData_p->addF(i, f); };
 
  void setF(size_t i, int dof, double f) { d_modelData_p->setF(i, dof, f); };
 
  void addF(size_t i, int dof, double f) { d_modelData_p->addF(i, dof, f); };
 
  util::Point &getFLocal(size_t i) { return d_modelData_p->getF(i+d_globStart); };
  const util::Point &getFLocal(size_t i) const { return d_modelData_p->getF(i+d_globStart); };
 
  void setFLocal(size_t i, const util::Point &f) { d_modelData_p->setF(i+d_globStart, f); };
 
  void addFLocal(size_t i, const util::Point &f) { d_modelData_p->addF(i+d_globStart, f); };
 
  void setFLocal(size_t i, int dof, double f) { d_modelData_p->setF
                                                (i+d_globStart, dof, f); };
 
  void addFLocal(size_t i, int dof, double f) { d_modelData_p->addF
                                                (i+d_globStart, dof, f); };
 
  double &getVol(size_t i) { return d_modelData_p->getVol(i); };
  const double &getVol(size_t i) const { return d_modelData_p->getVol(i); };
 
  void setVol(size_t i, const double &vol) { d_modelData_p->setVol(i, vol); };
 
  void addVol(size_t i, const double &vol) { d_modelData_p->addVol(i, vol); };
 
  double &getVolLocal(size_t i) { return d_modelData_p->getVol(i+d_globStart); };
  const double &getVolLocal(size_t i) const { return d_modelData_p->getVol(i+d_globStart); };
 
  void setVolLocal(size_t i, const double &vol) { d_modelData_p->setVol(i+d_globStart, vol); };
 
  void addVolLocal(size_t i, const double &vol) { d_modelData_p->addVol(i+d_globStart, vol); };
 
  uint8_t &getFix(size_t i) { return d_modelData_p->getFix(i); };
  const uint8_t &getFix(size_t i) const { return d_modelData_p->getFix(i); };
 
  void setFix(size_t i, const unsigned int &dof, const bool &flag) {
    d_modelData_p->setFix(i, dof, flag);
  };
 
  uint8_t &getFixLocal(size_t i) { return d_modelData_p->getFix(i+d_globStart); };
  const uint8_t &getFixLocal(size_t i) const { return d_modelData_p->getFix(i+d_globStart); };
 
  void setFixLocal(size_t i, const unsigned int &dof, const bool &flag) {
    d_modelData_p->setFix(i+d_globStart, dof, flag);
  };
 
  double &getMx(size_t i) { return d_modelData_p->getMx(i); };
  const double &getMx(size_t i) const { return d_modelData_p->getMx(i); };
 
  void setMx(size_t i, const double &mx) { d_modelData_p->setMx(i, mx); };
 
  void addMx(size_t i, const double &mx) { d_modelData_p->addMx(i, mx); };
 
  double &getMxLocal(size_t i) { return d_modelData_p->getMx(i+d_globStart); };
  const double &getMxLocal(size_t i) const { return d_modelData_p->getMx(i+d_globStart); };
 
  void setMxLocal(size_t i, const double &mx) { d_modelData_p->setMx(i+d_globStart, mx); };
 
  void addMxLocal(size_t i, const double &mx) { d_modelData_p->addMx(i+d_globStart, mx); };
 
  double &getThetax(size_t i) { return d_modelData_p->getThetax(i); };
  const double &getThetax(size_t i) const { return d_modelData_p->getThetax(i)
                                                ; };
 
  void setThetax(size_t i, const double &thetax) { d_modelData_p->setThetax
                                                   (i, thetax); };
 
  void addThetax(size_t i, const double &thetax) { d_modelData_p->addThetax
                                                   (i, thetax); };
 
  double &getThetaxLocal(size_t i) { return d_modelData_p->getThetax(i+d_globStart); };
  const double &getThetaxLocal(size_t i) const { return d_modelData_p->getThetax(i+d_globStart)
        ; };
 
  void setThetaxLocal(size_t i, const double &thetax) { d_modelData_p->setThetax
        (i+d_globStart, thetax); };
 
  void addThetaxLocal(size_t i, const double &thetax) { d_modelData_p->addThetax
        (i+d_globStart, thetax); };
 
  size_t getCenterNodeId() const { return d_rp_p->getCenterNodeId(); };
 
  double getParticleRadius() const { return d_pRadius; };
 
  util::Point &getXCenter() {
    return d_modelData_p->getX(d_globStart + d_rp_p->getCenterNodeId());
  };
 
  const util::Point &getXCenter() const {
    return d_modelData_p->getX(d_globStart + d_rp_p->getCenterNodeId());
  };
 
  util::Point &getUCenter() {
    return d_modelData_p->getU(d_globStart + d_rp_p->getCenterNodeId());
  };
 
  const util::Point &getUCenter() const {
    return d_modelData_p->getU(d_globStart + d_rp_p->getCenterNodeId());
  };
 
  util::Point &getVCenter() {
    return d_modelData_p->getV(d_globStart + d_rp_p->getCenterNodeId());
  };
 
  const util::Point &getVCenter() const {
    return d_modelData_p->getV(d_globStart + d_rp_p->getCenterNodeId());
  };
  std::string printStr(int nt = 0, int lvl = 0) const;
 
  void print(int nt = 0, int lvl = 0) const { std::cout << printStr(nt, lvl); }
 
public:
  bool d_isWall;
 
  size_t d_id;
 
  std::map<std::string, size_t> d_groups;
 
  size_t d_dim;
 
  size_t d_numNodes;
 
  double d_pRadius;
 
  double d_h;
 
  bool d_allDofsConstrained;
 
  bool d_computeForce;
 
  int d_mpiOwner;
 
  double d_horizon;
 
  double d_density;
 
  std::unique_ptr<material::Material> d_material_p;
 
  double d_Rc;
 
  double d_Kn;
 
  size_t d_globStart;
 
  size_t d_globEnd;
 
  size_t d_globQuadStart;
 
  size_t d_globQuadEnd;
 
  std::shared_ptr<data::ModelData> d_modelData_p;
 
  std::shared_ptr<particle::RefParticle> d_rp_p;
 
  std::shared_ptr<geom::GeomObject> d_geom_p;
 
  geom::ParticleTransform d_tform;
 
  std::shared_ptr<mesh::Mesh> d_mesh_p;
};
 
} // namespace particle
 
#endif // PARTICLE_BASEPARTICLE_H