Computational fluid dynamics class#

struct grid_type#

#include <openfdem_MPM.h>

Public Functions

grid_type() = default#

Public Members

std::vector<std::vector<gridpoint>> Map#

Eigen::Vector2i size#

Eigen::Vector2d start#

Eigen::Vector2d end#

Eigen::Vector2d cellsize#

Eigen::Vector2d gravity = Eigen::Vector2d(0.0, 0.0)#

class GridModule#

#include <MPM_grid_module.h>

Subclassed by ns_MPM::MPMModule

Public Functions

inline GridModule()#

inline ~GridModule()#

Public Static Functions

static void createGrid(MPM mpm, Eigen::Vector2d Start, Eigen::Vector2d End, Eigen::Vector2i Size)#

static double N(double x)#

static double dN(double x)#

static void pushPoint2Grid(General general, MPM mpm)#

static void Set_Force_Zero(General general, MPM mpm)#

static void pushPointForce2Grid(General general, MPM mpm, Nodal nodal)#

static void getGridTotalForce(General general, MPM mpm)#

static void Determine_Collision(General general, MPM mpm)#

static void updatePointVelocity(General general, MPM mpm)#

static void updatePointPosition(General general, MPM mpm)#

static void updatePointDeformationGradient(General general, MPM mpm, Solidmat solidmat)#

static Eigen::Matrix2d Project(point_type &P, Eigen::Matrix2d S, Solidmat solidmat)#

static void initializeGridpoint(General general, MPM mpm)#

struct gridpoint#

#include <openfdem_MPM.h>

Public Functions

gridpoint() = default#

Public Members

Real mass = 0.0#

bool active = false#

Eigen::Vector2d velocity = {0, 0}#

Eigen::Vector2d force = {0, 0}#

struct MaterialPoint_structure#

#include <openfdem_MPM.h>

Public Functions

void resize(Int size, Int initialsize = 0)#

void clear()#

Public Members

std::vector<point_type> points#

std::vector<mpmcontact_type> contact#

std::vector<MPMparticleContact_type> pcontact#

grid_type grid#

Real max_velocity = 0.0#

Real contact_buffer = 1.0#

Real contact_trigger = 200.0#

Int detection_count = 0#

Real pointRadius = 0.0#

Int contact_count = 0#

Int pcontact_count = 0#

Int maxparticles = 0#

struct mpmcontact_type#

#include <openfdem_MPM.h>

Public Functions

mpmcontact_type() = default#

void resize(UInt ielem, UInt jelem, MaterialPoint_structure *mpm, Element_structure *element, Solid_mat_structure *solidmat)#

void clear()#

Public Members

UInt con_n = 0#

Int head = -2#

std::vector<Int> hold#

std::vector<Vector3> dis[POLYGON_NODE_SIZE]#

std::vector<Vector3> vel[POLYGON_NODE_SIZE]#

std::vector<Vector2> norm[POLYGON_NODE_SIZE]#

std::vector<Int> target#

std::vector<short> mat#

std::vector<Real> ratio[POLYGON_NODE_SIZE]#

class MPMFEMcontactModule : public OpenFdemAbstract, public OpenFDEMmessage, public Contact_utils#

#include <MPMFEMcontact_module.h>

Public Functions

inline MPMFEMcontactModule()#

inline ~MPMFEMcontactModule()#

Public Static Functions

static void MPMcontact_detection(MPM mpm, General general, Element element, Particle particle, Contact contact, Nodal nodal, Solidmat solidmat)#

static void MPMcontactForceupdate(General general, MPM mpm, Element element, Nodal nodal, Solidmat solidmat)#

static void MPMparticleContactForceupdate(General general, MPM mpm, Particle particle, Solidmat solidmat)#

static inline Vector3 p2wContactforce(const Int point, const Int ele, const Int edge, const Int con, const UInt umat, MPM mpm, Element element, Solidmat solidmat)#

static inline Real getP2WNormal(const Int point, const Int ele, const Int con, const Int edge, Element element, Nodal nodal, MPM mpm)#

static inline void getP2Wdis(const Int point, const Int ele, const Int con, const Int edge, MPM mpm, Element element, General general)#

static inline void getP2Wvel(const Int point, const Int ele, const Int con, const Int edge, Real rot, MPM mpm, Nodal nodal, Element element)#

static inline void getP2PNormal(const Int point, const Int ball, const Int con, Particle particle, MPM mpm)#

static inline void getP2Pvel(const Int point, const Int ball, const Int con, Particle particle, MPM mpm)#

static inline void getP2Pdis(const Int point, const Int ball, const Int con, Particle particle, MPM mpm, General general)#

static inline Vector3 p2pStandardContactforce(const Int point, const Int ball, const Int con, const UInt umat, Particle particle, MPM mpm, Solidmat solidmat)#

static inline void updateNodeContactForce(Nodal nodal, const Int in, Vector3 wAforce)#

static inline void updatePointContactForce(MPM mpm, const Int iparticle, Vector3 pforce)#

class MPMModule : public OpenFdemAbstract, public ns_MPM::GridModule, public ns_MPM::PointsModule #

#include <openfdem_MPM_module.h>

Public Functions

inline MPMModule()#

inline ~MPMModule()#

Public Static Functions

static inline void runMPM(Openfdem openfdem)#

static Real vituralMass(Nodal nodal, Element element)#

static void removeMPMpoints(General general, MPM mpm)#

static void outletMPMpoints(General general, MPM mpm, Boudary boudary)#

static void inletMPMpoints(General general, MPM mpm, Solidmat solidmat, Boudary boudary)#

static void createMPM(General general, Group group, MPM mpm)#

static void createPointsfromMesh(MPM mpm, Nodal nodal, Element element, Group group)#

static void createGrid(General general, MPM mpm)#

struct MPMparticleContact_type#

#include <openfdem_MPM.h>

Public Functions

MPMparticleContact_type() = default#

void resize(UInt ielem, UInt jelem, MaterialPoint_structure *mpm, Particle_structure *particle, Solid_mat_structure *solidmat)#

void clear()#

Public Members

UInt con_n = 0#

Int head = -2#

std::vector<Int> hold#

std::vector<Vector3> dis#

std::vector<Vector3> vel#

std::vector<Vector2> norm#

std::vector<Int> target#

std::vector<short> state#

std::vector<short> mat#

struct point_type#

#include <openfdem_MPM.h>

Public Functions

point_type() = default#

Public Members

Real mass = 0.0#

Real volume = 0.0#

Real J = 0.0#

Real omega = 0.0#

Int matid = 0#

bool isfluid = false#

Eigen::Vector2d pseudo_position = {0, 0}#

Eigen::Vector2i int_position = {0, 0}#

Eigen::Vector2d position = {0, 0}#

Eigen::Vector2d initialposition = {0, 0}#

Eigen::Vector2d velocity = {0, 0}#

Eigen::Vector2d contactforce = {0, 0}#

Eigen::Vector2d momentum = {0, 0}#

Eigen::Matrix2d Deformation_Gradient#

Eigen::Matrix2d plasticDeformation_Gradient#

Eigen::Matrix4d weight#

Eigen::Matrix2d Energy_Derivative#

Eigen::Matrix2d Velocity_Gradient#

Eigen::Vector2d Weight_Gradient[4][4]#

Eigen::Matrix2d B#

class PointsModule#

#include <MPM_point_module.h>

Subclassed by ns_MPM::MPMModule

Public Functions

inline PointsModule()#

inline ~PointsModule()#

Public Static Functions

static void Init_Volume(MPM mpm)#

static void getPointWeightGradient(General general, MPM mpm)#

static point_type createPoints(Eigen::Vector2d Pos, Eigen::Vector2d Vel, double Mass, Int mat)#

static void getPointEnergyDerivative(General general, MPM mpm, Solidmat solidmat)#

static void updateMPMboundary(General general, MPM mpm, Boudary boudary)#

namespace ns_common

namespace ns_contact

namespace ns_io

namespace ns_MPM#

file MPM_grid_module.h: #include <Eigen/Dense>

#include <vector>

#include “common/openfdem_common.h”

#include “solver/openfdem.h”

file MPM_point_module.h: #include <eigen3/Eigen/Dense>

#include <vector>

#include “common/openfdem_common.h”

#include “solver/openfdem.h”

file MPMFEMcontact_module.h: #include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “contact/contact_utils/contact_utils.h”

#include “external/gsl/gsl_randist.h”

#include “external/gsl/gsl_rng.h”

#include “solver/openfdem.h”

file openfdem_MPM.h

#include <eigen3/Eigen/Dense>

#include <vector>

#include “common/openfdem_common.h”

Typedefs

typedef struct MaterialPoint_structure *MPM#

file openfdem_MPM_module.h: #include <iohelper/parser/parser_utils.h>

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “mpm/MPMFEMcontact_module.h”

#include “mpm/MPM_grid_module.h”

#include “mpm/MPM_point_module.h”

#include “solver/openfdem.h”

dir mpm

dir src