Particle.h

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Copyright (c) 2021-2025 MPM-Geomechanics Development Team
 
#ifndef PARTICLE_H_
#define PARTICLE_H_
 
#include "Eigen/Core"
using Eigen::Matrix3d;
using Eigen::Vector3d;
 
#include "Contribution.h"
#include "Mesh/Mesh.h"
#include "Model.h"
#include "Shape/Shape.h"
#include "Materials/Material.h"
 
#include <vector>
 
class Mesh;
 
class Particle {
 
public:
 
    Particle(const Vector3d& position, Material* material, const Vector3d& size);
    
    virtual ~Particle();
 
    void updateContributionNodes(Mesh* mesh);
 
    inline void updateStress() { material->updateStress(this); }
 
    virtual inline void updatePressure(double dt) 
    {   
        (void)dt; 
        return;
    }
 
    void updateDensity();
    
    virtual inline void updatePorosity() { return; }
 
    inline bool getActive() const { return this->active; }
 
    inline int getId() const { return this->id; }
 
    inline int getMaterialId() const { return this->material!=0?this->material->getId():-1; } 
 
    inline int getBodyId() const { return this->bodyId; }
 
    inline double getMass() const { return this->mass; }
 
    virtual inline double getMassFluid() const { return 0.0; }
 
    inline double getDensity() const { return this->density; }
 
    virtual inline double getDensityFluid() const { return 0.0; }
 
    virtual inline double getCurrentVolume() const { return this->mass/this->density; }
 
    inline double getInitialVolume() const { return this->size.x()*this->size.y()*this->size.z(); }
 
    inline const Vector3d& getPosition() const { return this->position; } 
 
    inline const Vector3d& getInitialPosition() const { return this->initialPosition; } 
 
    inline const Vector3d& getExternalForce() const { return this->externalForce; } 
 
    virtual inline const Vector3d* getExternalForceFluid() const { return NULL; }
 
    inline const Vector3d& getVelocity() const { return this->velocity; }
 
    virtual inline const Vector3d* getVelocityFluid() const { return NULL; }
 
    inline const Matrix3d& getStress() const { return this->stress; }
 
    inline const Matrix3d& getStrainIncrement() const { return this->strainIncrement; }
 
    virtual inline const Matrix3d* getStrainIncrementFluid() const { return NULL; }
 
    inline const Matrix3d& getStrain() const { return this->strain; }
 
    inline const Matrix3d& getVorticityIncrement() const { return this->vorticityIncrement; }
 
    inline vector<Contribution>* getContributionNodes() { return &(this->contributionNodes); }
 
    inline void setActive(bool particle_active) { this->active=particle_active; }
 
    inline void setId(int particle_id) { this->id=particle_id; }
 
    inline void setBodyId(int body_id) { this->bodyId=body_id; }
 
    inline void setMass(double particle_mass) { this->mass=particle_mass; } 
 
    inline void setDensity(double particle_density) { this->density=particle_density; } 
 
    inline void setPosition(const Vector3d& particle_position) { this->position=particle_position; } 
 
    inline void setInitialPosition(const Vector3d& particle_initial_position) { this->initialPosition=particle_initial_position; } 
 
    inline void setSize(const Vector3d& particle_size) { this->size=particle_size; } 
 
    inline const Vector3d& getSize( ) { return this->size; } 
 
    inline void setVelocity(const Vector3d& particle_velocity) { this->velocity = particle_velocity; }
 
    virtual inline void setVelocityFluid(const Vector3d& particle_velocity_fluid) 
    { 
        (void)particle_velocity_fluid;
        return;
    }
 
    inline void setStrainIncrement(const Matrix3d& strain_increment) { this->strainIncrement=strain_increment; this->strain+=strain_increment; }
 
    virtual inline void setStrainIncrementFluid(const Matrix3d& strain_increment_fluid) 
    {   
        (void)strain_increment_fluid; 
        return;
    }
 
    inline void setVorticityIncrement(const Matrix3d& vorticity_increment) { this->vorticityIncrement=vorticity_increment; }
 
    inline void setStress(const Matrix3d& particle_stress) { this->stress=particle_stress; } 
 
    virtual void setMaterial(Material* material);
 
    inline void setShape(Shape* shape) { this->shape=shape; }
 
    inline void addExternalForce(const Vector3d& delta_external_force) { this->externalForce+=delta_external_force; }
 
    virtual inline void addExternalForceFluid(const Vector3d& delta_external_fluid_force) 
    { 
        (void)delta_external_fluid_force;
        return;
    }
 
    static int getTotalParticles();
 
    inline void addPlasticStrain(double deltaPlasticStrain) { this->plasticStrain+=deltaPlasticStrain; }
 
    inline double getPlasticStrain() const { return this->plasticStrain; }
 
    virtual inline double getPressureFluid() const { return 0.0; }
 
    virtual inline void setPressureFluid(double pressure) { 
        (void)pressure;
        return; 
    }
 
    virtual inline double getPorosity() const { return 0.0; }
 
    virtual inline double getSaturation() const { return 0.0; }
 
    virtual inline Vector3d getDragForceFluid() const { return Vector3d::Zero(); }
 
    inline void setDeformationGradient(const Matrix3d& deformation_gradient) { this->deformationGradient=deformation_gradient; }
 
    inline const Matrix3d& getDeformationGradient() const { return this->deformationGradient; }
 
    inline void setDistanceLevelSet(double distance) { this->distanceLevelSet=distance; }
 
    inline double getDistanceLevelSet() { return this->distanceLevelSet; }
 
    void setPorePressure(double p) { porePressure = p; }
 
    double getPorePressure() const { return porePressure; }
 
protected:
 
    bool active; 
    int id; 
    int bodyId; 
 
    double mass; 
    double density; 
    double plasticStrain; 
    double distanceLevelSet; 
 
    Vector3d position; 
    Vector3d initialPosition; 
    Vector3d velocity; 
    Vector3d externalForce; 
    Vector3d size; 
    
    Matrix3d stress; 
    Matrix3d strain; 
    double porePressure = 0.0; 
 
    Matrix3d strainIncrement; 
    Matrix3d vorticityIncrement; 
    Matrix3d deformationGradient; 
 
    vector<Contribution> contributionNodes; 
    Shape* shape; 
    Material* material; 
 
    static int totalParticles; 
};
 
inline Particle::~Particle() {
    
    totalParticles--;
}
 
inline int Particle::getTotalParticles() {
 
    return totalParticles;
}
 
#endif /* PARTICLE_H_ */