Membrane.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
#ifndef MEMBRANE_H
#define MEMBRANE_H
 
#include <Mercury3D.h>
#include <vector>
#include <Math/Vector.h>
#include <array>
 
#include <Particles/BaseParticle.h>
#include <Walls/MeshTriangle.h>
 
 
class Membrane : public BaseObject
{
public:
    
    struct Edge
    {
        // 3 and 4
        std::array<unsigned int, 2> vertexId;
        
        std::array<BaseParticle*, 2> vertex = {{nullptr}};
 
        // 1 and 2
        std::array<unsigned int, 2> faceVertexId;
        
        std::array<BaseParticle*, 2> faceVertex = {{nullptr}};
        
        std::array<MeshTriangle*, 2> face = {{nullptr}};
 
        std::array<Mdouble, 2> faceInitialArea;
        
        std::array<Mdouble, 8> uPre;
 
        Vec3D initialState;
        
        Mdouble initialLength;
        
        Mdouble initialSineHalfTheta;
        
        Mdouble effectiveMass;
        
        bool isStretchActive;
        
        bool isBendActive;
 
        void applyForce(Mdouble Kn, Mdouble critDampCoeff, Mdouble Ke, Mdouble Kd, bool bendingAreaConstant);
        
        void applyStretchForce(Mdouble Kn, Mdouble critDampCoeff);
        
        void applyBendForce(Mdouble Kn, Mdouble Kd, bool bendingAreaConstant);
        
        void calculateUPre(Vec3D& state, Mdouble& length, std::array<Mdouble, 2>& faceArea);
        
        Mdouble getSineHalfTheta();
        
        void handleParticleRemoval(unsigned int id);
        
        void handleParticleAddition(unsigned int id, BaseParticle* p);
        
        void checkActive();
    };
 
    Membrane();
 
    /*
     * \brief Constructor to create a membrane with two species
    */
    Membrane(ParticleSpecies* membraneSpecies, ParticleSpecies* membraneParticleSpecies);
 
    // Membrane(const Membrane& other);
 
 
    ~Membrane() override;
 
    // Membrane& operator=(const Membrane& other);
 
    Membrane* copy() const;
 
    void read(std::istream& is) override;
 
    void write(std::ostream& os) const override;
 
    std::string getName() const override;
 
    void setKnAndCrittDampCoeff(Mdouble Kn, Mdouble critDampCoeff);
    
    void setElasticModulusAndThickness(Mdouble E, Mdouble thickness);
    
    void setSpringConstant(Mdouble k);
    
    void setCriticalDampingCoefficient(Mdouble coeff);
    
    void setKeAndKd(Mdouble Ke, Mdouble Kd);
    
    void setBendingAreaConstant(bool areaConstant);
    
    void setThickness(Mdouble thickness);
    
    
    Mdouble getKn() { return Kn_; }
    Mdouble getCriticalDampingCoefficient() { return critDampCoeff_; }
    Mdouble getKe() { return Ke_; }
    Mdouble getKd() { return Kd_; }
    Mdouble getThickness() { return thickness_; }
    Mdouble getBendingAreaConstant() { return bendingAreaConstant_; }
    
    void setParticleRadius(Mdouble radius);
    
    Mdouble getParticleRadius() { return particleRadius_; }
    
    void setDPMBase(DPMBase* dpm) { DPMBase_ = dpm; }
    
    DPMBase* getDPMBase() { return DPMBase_; }
    
    std::vector<BaseParticle*> getVertexParticles(){ return vertexParticle_; };
    
    std::vector<MeshTriangle*> getFaces(){ return face_; };    
    
    void saveVertexPositions(std::ostream& os);
    
    void loadVertexPositions(std::istream& is);
    
    void saveAsOFF(unsigned int d);
    
    void saveAsSTL(std::string fileName);
    
    void loadFromSTL(BaseParticle& p0, std::string fileName);
    
    void loadFromSTL(BaseParticle& p0, std::string fileName, Mdouble eps);
    
    void buildMesh(BaseParticle& p0, std::vector<Vec3D> vertexPositions, std::vector<unsigned int> edgeVertices, std::vector<unsigned int> faceVertices);
    
    void adjustVertexParticleSize();
    
    void updateEdgeMass();
    
    void computeAdditionalForces();
    
    void applyPressure(Mdouble pressure);
    
    void handleParticleRemoval(unsigned int id);
    
    void handleParticleAddition(unsigned int id, BaseParticle* p);
 
    Mdouble getVolume();
 
private:
    
    void createVertexParticles(BaseParticle& p0, std::vector<Vec3D> vertexPositions);
    
    void initializeEdgeBendingQuantities();
    
    void updateFaceNeighbors();
    
    unsigned int addVertex(std::vector<Vec3D>& vertices, Vec3D pos, Mdouble eps);
    
    bool addEdge(std::vector<unsigned int>& edges, std::map<std::pair<unsigned int, unsigned int>, int>& map, unsigned int v0, unsigned int v1);
    
    std::vector<BaseParticle*> vertexParticle_;
    
    std::vector<unsigned int> vertexParticleId_;
    
    unsigned int vertexInitId_;
 
    std::vector<MeshTriangle*> face_;
    
    std::vector<unsigned int> faceVertices_;
 
    std::vector<Edge> edge_;
 
    Mdouble particleRadius_;
 
    Mdouble Kn_;
    
    Mdouble critDampCoeff_;
    
    Mdouble Ke_;
    
    Mdouble Kd_;
    
    Mdouble thickness_;
    
    bool bendingAreaConstant_;
    
    ParticleSpecies* membraneSpecies_ = nullptr;
    
    ParticleSpecies* membraneParticleSpecies_ = nullptr;
    
    DPMBase* DPMBase_ = nullptr;
};
 
 
#endif