Boundary.h

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Copyright (c) 2021-2025 MPM-Geomechanics Development Team
 
#ifndef BOUNDARY_H_
#define BOUNDARY_H_
 
#include <vector>
using std::vector;
 
class Boundary {
 
public:
 
    enum BoundaryType{ FREE, FIXED, SLIDING, EARTHQUAKE };
 
    enum BoundaryPlane{ X0, Y0, Z0, Xn, Yn, Zn };
 
    struct planeBoundary
    {
        BoundaryType restriction; 
        BoundaryType restrictionFluid; 
        vector<int> nodes; 
        
        planeBoundary() : restriction(BoundaryType::FIXED), restrictionFluid(BoundaryType::FIXED) {};
    };
 
    Boundary();
 
    virtual ~Boundary();
 
    inline const planeBoundary* getPlaneX0() const { return &(this->planeX0); }
 
    inline const planeBoundary* getPlaneY0() const { return &(this->planeY0); }
 
    inline const planeBoundary* getPlaneZ0() const { return &(this->planeZ0); }
    
    inline const planeBoundary* getPlaneXn() const { return &(this->planeXn); }
    
    inline const planeBoundary* getPlaneYn() const { return &(this->planeYn); }
    
    inline const planeBoundary* getPlaneZn() const { return &(this->planeZn); }
 
    inline void setNodesPlaneX0(const vector<int>& nodes_id) { this->planeX0.nodes=nodes_id; }
    
    inline void setNodesPlaneY0(const vector<int>& nodes_id) { this->planeY0.nodes=nodes_id; }
    
    inline void setNodesPlaneZ0(const vector<int>& nodes_id) { this->planeZ0.nodes=nodes_id; }
    
    inline void setNodesPlaneXn(const vector<int>& nodes_id) { this->planeXn.nodes=nodes_id; }
    
    inline void setNodesPlaneYn(const vector<int>& nodes_id) { this->planeYn.nodes=nodes_id; }
    
    inline void setNodesPlaneZn(const vector<int>& nodes_id) { this->planeZn.nodes=nodes_id; }
 
    inline void setRestrictions(Boundary::BoundaryType restriction);
 
    inline void setRestrictionsFluid(Boundary::BoundaryType restriction);
 
    inline void setRestrictions(Boundary::BoundaryPlane plane, Boundary::BoundaryType restriction);
 
    inline void setRestrictionsFluid(Boundary::BoundaryPlane plane, Boundary::BoundaryType restriction);
 
private:
 
    Boundary::planeBoundary planeX0; 
 
    Boundary::planeBoundary planeY0; 
 
    Boundary::planeBoundary planeZ0; 
 
    Boundary::planeBoundary planeXn; 
 
    Boundary::planeBoundary planeYn; 
    
    Boundary::planeBoundary planeZn; 
};
 
inline Boundary::Boundary(){
 
    setRestrictions(Boundary::BoundaryType::SLIDING);
    setRestrictionsFluid(Boundary::BoundaryType::SLIDING);
}
 
inline Boundary::~Boundary() { }
 
inline void Boundary::setRestrictions(Boundary::BoundaryType restriction) {
    
    planeX0.restriction=restriction;
    planeY0.restriction=restriction;
    planeZ0.restriction=restriction;
    planeXn.restriction=restriction;
    planeYn.restriction=restriction;
    planeZn.restriction=restriction;
}
 
inline void Boundary::setRestrictionsFluid(Boundary::BoundaryType restriction) {
    
    planeX0.restrictionFluid=restriction;
    planeY0.restrictionFluid=restriction;
    planeZ0.restrictionFluid=restriction;
    planeXn.restrictionFluid=restriction;
    planeYn.restrictionFluid=restriction;
    planeZn.restrictionFluid=restriction;
}
 
inline void Boundary::setRestrictions(Boundary::BoundaryPlane plane, Boundary::BoundaryType restriction) {
    
    switch (plane)
    {
        case BoundaryPlane::X0:
            planeX0.restriction=restriction;
            break;
        
        case BoundaryPlane::Y0:
            planeY0.restriction=restriction;
            break;
 
        case BoundaryPlane::Z0:
            planeZ0.restriction=restriction;
            break;
 
        case BoundaryPlane::Xn:
            planeXn.restriction=restriction;
            break;
        
        case BoundaryPlane::Yn:
            planeYn.restriction=restriction;
            break;
 
        case BoundaryPlane::Zn:
            planeZn.restriction=restriction;
            break;
    }
}
 
inline void Boundary::setRestrictionsFluid(Boundary::BoundaryPlane plane, Boundary::BoundaryType restriction) {
    
    switch (plane)
    {
        case BoundaryPlane::X0:
            planeX0.restrictionFluid=restriction;
            break;
        
        case BoundaryPlane::Y0:
            planeY0.restrictionFluid=restriction;
            break;
 
        case BoundaryPlane::Z0:
            planeZ0.restrictionFluid=restriction;
            break;
 
        case BoundaryPlane::Xn:
            planeXn.restrictionFluid=restriction;
            break;
        
        case BoundaryPlane::Yn:
            planeYn.restrictionFluid=restriction;
            break;
 
        case BoundaryPlane::Zn:
            planeZn.restrictionFluid=restriction;
            break;
    }
}
#endif /* BOUNDARY_H_ */