Node.h

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Copyright (c) 2021-2025 MPM-Geomechanics Development Team
 
#ifndef NODE_H_
#define NODE_H_
 
#include "Eigen/Core"
using Eigen::Vector3d;
 
class Node {
 
public:
    
    virtual ~Node();
    
    Node();
 
    inline void setId(int node_id) { this->id=node_id; }
    
    inline void setActive(bool node_activate) { this->active=node_activate; }
    
    inline void setCoordinates(const Vector3d& nodal_coordinates) { this->coordinates=nodal_coordinates; }
    
    inline void setVelocity(const Vector3d& nodal_velocity) { this->velocity=nodal_velocity; }
    
    inline void setMomentum(const Vector3d& nodal_momentum) { this->momentum=nodal_momentum; }
    
    virtual inline void setMomentumFluid(const Vector3d& nodal_momentum_fluid) 
    { 
        (void)nodal_momentum_fluid;
        return;
    }
 
    inline void setTotalForce(const Vector3d& total_nodal_force) { this->totalForce=total_nodal_force; }
 
    virtual inline void setTotalForceFluid(const Vector3d& total_nodal_force_fluid) 
    { 
        (void)total_nodal_force_fluid;
        return;
    }
 
    inline int getId() const { return this->id; }
    
    inline bool getActive() const { return this->active; }
    
    inline double getMass() const { return this->mass; }
    
    virtual inline double getMassFluid() const { return 0.0; }
 
    inline const Vector3d& getCoordinates() const { return this->coordinates; }
    
    inline const Vector3d& getMomentum() const { return this->momentum; }
    
    inline Vector3d& getMomentumRef() { return this->momentum; }
 
    virtual inline const Vector3d* getMomentumFluid() const { return NULL; }
    
    inline const Vector3d& getInternalForce() const { return this->internalForce; }
    
    inline Vector3d& getInternalForceRef() { return this->internalForce; }
        
    inline const Vector3d& getExternalForce() const { return this->externalForce; }
    
    inline Vector3d& getExternalForceRef() { return this->externalForce; }
 
    inline const Vector3d& getTotalForce() const { return this->totalForce; }
        
    virtual inline const Vector3d* getTotalForceFluid() const { return NULL; }
 
    inline const Vector3d& getVelocity() const { return this->velocity; }
 
    virtual inline const Vector3d* getVelocityFluid() const { return NULL; }
 
    inline void addMass(double mass_increment) { this->mass+=mass_increment; }
 
    inline double& getMassRef() { return this->mass; }
 
    inline void addDensityLevelSet(double density_increment) { this->densityLevelSet+=density_increment; }
 
    inline double& getDensityLevelSetRef(){ return this->densityLevelSet; }
 
    virtual inline void addMassFluid(double fluid_mass_increment)
    { 
        (void)fluid_mass_increment;
        return;
    }
    inline void addMomentum(const Vector3d& momentum_increment) { this->momentum+=momentum_increment; }
 
    virtual inline void addMomentumFluid(const Vector3d& fluid_momentum_increment) 
    { 
        (void)fluid_momentum_increment;
        return;
    }
        
    inline void addInternalForce(const Vector3d& internal_force_increment) { this->internalForce+=internal_force_increment; }
    
    virtual inline void addInternalForceFluid(const Vector3d& internal_force_fluid_increment) { 
        (void)internal_force_fluid_increment;
        return;
    }
        
    inline void addExternalForce(const Vector3d& external_force_increment) { this->externalForce+=external_force_increment; }
 
    virtual inline void addExternalForceFluid(const Vector3d& external_force_fluid_increment) {
        (void)external_force_fluid_increment;
        return; 
    }
    
    virtual void resetValues();
 
    virtual inline void updateTotalForce() { this->totalForce = this->internalForce + this->externalForce + this->dampingForce; }
 
    virtual void updateDampingForce();
 
    inline void updateVelocity(){ this->velocity = this->momentum / this->mass; }
 
    virtual inline void integrateMomentum(double dt) { this->momentum +=  this->totalForce*dt; }
 
    void setDistanceLevelSet(double distance) { this->distanceLevelSet = distance; }
 
    double getDistanceLevelSet() { return this->distanceLevelSet; }
 
    double getDensityLevelSet() { return this->densityLevelSet; }
 
    void setVolume(double volume) { this->volume = volume; }
 
    double getVolume() { return this->volume; }
 
protected:
 
    bool active; 
 
    int id; 
 
    double mass; 
    double volume; 
    double distanceLevelSet; 
    double densityLevelSet; 
 
    Vector3d coordinates; 
    Vector3d momentum; 
    Vector3d velocity; 
    Vector3d externalForce; 
    Vector3d internalForce; 
    Vector3d dampingForce; 
    Vector3d totalForce; 
};
 
inline Node::Node() {
 
    active=false;
    id=0;
    mass=0.0;
    volume=0.0;
    distanceLevelSet=0.0;
    densityLevelSet=0.0;
    coordinates.setZero();
    momentum.setZero();
    velocity.setZero();
    externalForce.setZero();
    internalForce.setZero();
    totalForce.setZero();
    dampingForce.setZero();
}
 
inline void Node::resetValues()
{
    active=false;
    mass=0.0;
    momentum.setZero();
    externalForce.setZero();
    internalForce.setZero();
    densityLevelSet=0.0;
}
 
inline Node::~Node() { }
 
#endif /* NODE_H_ */