Node.h

Go to the documentation of this file.

/*
 * Node.h
 *
 *  Created on: 14 de abr de 2021
 *      Author: Fabricio Fernandez <fabricio.hmf@gmail.com>
 */
 
#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) { return; }
 
    inline void setTotalForce(const Vector3d& total_nodal_force) { this->totalForce=total_nodal_force; }
 
    virtual inline void setTotalForceFluid(const Vector3d& 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; }
    
    virtual inline const Vector3d* getMomentumFluid() const { return NULL; }
 
    inline const Vector3d& getInternalForce() const { return this->internalForce; }
        
    inline const Vector3d& getExternalForce() const { 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; }
 
    virtual inline void addMassFluid(double fluid_mass_increment) { return; }
 
    inline void addMomentum(const Vector3d& momentum_increment) { this->momentum+=momentum_increment; }
 
    virtual inline void addMomentumFluid(const Vector3d& 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) { return; }
        
    inline void addExternalForce(const Vector3d& external_force_increment) { this->externalForce+=external_force_increment; }
 
    virtual inline void addExternalForceFluid(const Vector3d& 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; }
 
protected:
 
    bool active; 
 
    int id; 
 
    double mass; 
 
    Vector3d coordinates; 
    Vector3d momentum; 
    Vector3d velocity; 
    Vector3d externalForce; 
    Vector3d internalForce; 
    Vector3d dampingForce; 
    Vector3d totalForce; 
};
 
inline Node::Node() {
 
    active=false;
    id=0;
    mass=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();
}
 
inline Node::~Node() { }
 
#endif /* NODE_H_ */