Mesh.h

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Copyright (c) 2021-2025 MPM-Geomechanics Development Team
 
#ifndef MESH_H_
#define MESH_H_
 
#include <vector>
using std::vector;
 
#include "../inc/Eigen/Core"
using Eigen::Vector3d;
using Eigen::Vector3i;
 
#include <unordered_map>
using std::unordered_map;
 
#include "Node.h"
#include "Boundary.h"
#include "Cell.h"
 
class Particle;
 
class Mesh {
 
public:
 
    Mesh();
    
    virtual ~Mesh();
 
    void createGrid( bool is_two_phase_simulation=false );
 
    void setCellDimension(double cell_dimension_x, double cell_dimension_y, double cell_dimension_z);
    
    void setCellDimension(const Vector3d& cell_dimension);
    
    void setNumCells(int number_cells_x, int number_cells_y, int number_cells_z);
    
    void setNumCells(const Vector3i& number_cells);
    
    void setNumGhosts(int ghosts); 
    
    inline void setOrigin(double x, double y, double z) { this->minLimit=Vector3d(x,y,z); }
    
    inline void setOrigin(const Vector3d& origin_coordinate) { this->minLimit=origin_coordinate; }
    
    void activateNodes(const vector<int>& id_list, bool active_value=true);
 
    void setBoundaryRestrictionsSeismic();
 
    void activateNode(int id, bool active_value=true);
 
    inline unsigned int getNumNodes() const { return (unsigned int) this->gridNodes.size(); }
    
    inline vector<Node*>* getNodes() { return &(this->gridNodes); }
 
    inline vector<Cell*>* getCells() { return &(this->gridCells); }
 
    inline const Vector3d& getCellDimension() const { return this->cellDim; }
    
    inline const Vector3i& getNumCells() const { return this->nCells; }
    
    Vector3i getTotalCells() const;
    
    inline int getNumGhosts() const { return this->nGhosts; }
 
    inline const Vector3d& getMinLimits() const { return this->minLimit;}
 
    inline const Vector3d& getMaxLimits() const { return this->maxLimit; }
 
    vector<int> getNodesInCell(const Vector3d& point) const;
 
    void getContributionNodes(const Vector3d& point, vector<int>& contributionIds) const;
 
    inline Boundary* getBoundary() { return &(this->boundary); }
 
    unordered_map<int, Node::ContactNodeData>& getContactNodes() { return contactNodes; }
 
    void setBoundaryRestrictions(vector<Boundary::BoundaryType> restrictions);
 
    void setRestriction(Boundary::BoundaryPlane plane, Boundary::BoundaryType restriction);
 
    void setBoundaryRestrictionsFluid(vector<Boundary::BoundaryType> restrictions);
 
    bool getIsInsideMesh(const Vector3d& point) const;
 
    void computeNodeVolumes();
 
    void clearContactNodes() { contactNodes.clear(); };
 
 
private:
    
    int nGhosts; 
    
    Vector3i nCells; 
 
    Vector3i nRows; 
    
    Vector3d cellDim; 
 
    Vector3d minLimit; 
    
    Vector3d maxLimit; 
    
    std::vector<Node*> gridNodes; 
    
    std::vector<Cell*> gridCells; 
 
    Boundary boundary; 
 
    unordered_map<int, Node::ContactNodeData> contactNodes; 
    
    int getCellIdbyPosition(const Vector3d& point) const;
    
    Vector3d getGridCoordinates(const Vector3d& point) const;
    
    Vector3i getParentNodeCoordinates(const Vector3d& point) const;
    
    int getParentCellIdConstribution(const Vector3d& point) const;
    
    void configureBoundaries();
};
 
inline void Mesh::activateNode(int nodeId, const bool activeValue) {
 
    gridNodes.at(nodeId)->setActive(activeValue);
}
 
#endif /* MESH_H_ */