Membrane Class Reference

A Membrane consists of masses connected by springs. More...

#include <Membrane.h>

Inheritance diagram for Membrane:

Classes
struct	Edge

Public Member Functions
	Membrane ()
	Default constructor. More...
	Membrane (ParticleSpecies *membraneSpecies, ParticleSpecies *membraneParticleSpecies)
	~Membrane () override
	Copy constructor. More...
Membrane *	copy () const
	Copy method. It calls the copy constructor of this Object. More...
void	read (std::istream &is) override
	Reads a Membrane from an input stream, for example a restart file. More...
void	write (std::ostream &os) const override
	Writes a Membrane to an output stream, for example a restart file. More...
std::string	getName () const override
	Returns the name of the object, here the string "Membrane". More...
void	setKnAndCrittDampCoeff (Mdouble Kn, Mdouble critDampCoeff)
	Set the parameters needed for the stretching forces. More...
void	setElasticModulusAndThickness (Mdouble E, Mdouble thickness)
	Set the elastic modulus and thickness of the membrane. More...
void	setSpringConstant (Mdouble k)
	Set the spring constant of the membrane. More...
void	setCriticalDampingCoefficient (Mdouble coeff)
	Set damping coefficient for the distance springs. More...
void	setKeAndKd (Mdouble Ke, Mdouble Kd)
	Set the parameters needed for the bending forces. More...
void	setBendingAreaConstant (bool areaConstant)
void	setThickness (Mdouble thickness)
	Set the thickness of the membrane. More...
Mdouble	getKn ()
Mdouble	getCriticalDampingCoefficient ()
Mdouble	getKe ()
Mdouble	getKd ()
Mdouble	getThickness ()
Mdouble	getBendingAreaConstant ()
void	setParticleRadius (Mdouble radius)
	Set the radius of the vertex particles. More...
Mdouble	getParticleRadius ()
	Returns the radius of the vertex particles. More...
void	setDPMBase (DPMBase *dpm)
	Set a pointer to DPMBase. More...
DPMBase *	getDPMBase ()
	Get the stored pointer to DPMBase. More...
std::vector< BaseParticle * >	getVertexParticles ()
	Returns a vector with pointers to the vertex particles. More...
std::vector< MeshTriangle * >	getFaces ()
	Returns a vecter with pointers to the mesh triangles. More...
void	saveVertexPositions (std::ostream &os)
	save the current positions of the vertex particles to a stream More...
void	loadVertexPositions (std::istream &is)
	Load the positions of the vertex particles from a stream and apply them to existing particles. More...
void	saveAsOFF (unsigned int d)
	Save the Membrane as a .off file. More...
void	saveAsSTL (std::string fileName)
	Save the Membrane as a .stl file. More...
void	loadFromSTL (BaseParticle &p0, std::string fileName)
	Load the Membrane geometry from a .stl file. More...
void	loadFromSTL (BaseParticle &p0, std::string fileName, Mdouble eps)
	Load the Membrane geometry from a .stl file. More...
void	buildMesh (BaseParticle &p0, std::vector< Vec3D > vertexPositions, std::vector< unsigned int > edgeVertices, std::vector< unsigned int > faceVertices)
	Build the geometry from specified positions and their connectivity. More...
void	adjustVertexParticleSize ()
	Calculates an updated radius for every vertex particle in order to account for the correct mass. More...
void	updateEdgeMass ()
	Set the correct edge mass by taking the mass from the conencted vertices. More...
void	computeAdditionalForces ()
	Compute the forces due to the mass spring system. More...
void	applyPressure (Mdouble pressure)
	Apply a surface pressure to the membrane. More...
void	handleParticleRemoval (unsigned int id)
	Handles the removal of vertex particles from the particle handler. More...
void	handleParticleAddition (unsigned int id, BaseParticle *p)
	Handles the addition of vertex particles to the particle handler. More...
Mdouble	getVolume ()
	Calculate the volume of the membrane. More...
Public Member Functions inherited from BaseObject
	BaseObject ()=default
	Default constructor. More...
	BaseObject (const BaseObject &p)=default
	Copy constructor, copies all the objects BaseObject contains. More...
virtual	~BaseObject ()=default
	virtual destructor More...
virtual void	moveInHandler (unsigned int index)
	Except that it is virtual, it does the same thing as setIndex() does. More...
void	setIndex (unsigned int index)
	Allows one to assign an index to an object in the handler/container. More...
void	setId (unsigned long id)
	Assigns a unique identifier to each object in the handler (container) which remains constant even after the object is deleted from the container/handler. More...
unsigned int	getIndex () const
	Returns the index of the object in the handler. More...
unsigned int	getId () const
	Returns the unique identifier of any particular object. More...
void	setGroupId (unsigned groupId)
unsigned	getGroupId () const

Private Member Functions
void	createVertexParticles (BaseParticle &p0, std::vector< Vec3D > vertexPositions)
	Handles the actual creation of vertex particles. More...
void	initializeEdgeBendingQuantities ()
	Compute the forces due to the mass spring system. More...
void	updateFaceNeighbors ()
	Update the faces to have the correct neighbors. More...
unsigned int	addVertex (std::vector< Vec3D > &vertices, Vec3D pos, Mdouble eps)
	Helper function to check if a given vertex already exists. More...
bool	addEdge (std::vector< unsigned int > &edges, std::map< std::pair< unsigned int, unsigned int >, int > &map, unsigned int v0, unsigned int v1)
	Helper function to check if a given edge already exists. More...

Private Attributes
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

Detailed Description

A Membrane consists of masses connected by springs.

This class assumes, that the masses are connected in a triangular mesh. Additionally, for correct calculation of the spring constant for the distance spring, a hexagonal unit cell is assumed.

This class creates the particles required for the mass spring system. For contact detections, further triangular wall elements are created

Please make sure to provide appropriate a species for the particles as well as the wall elements (e.g giving the particles a species so that they do not interact with other particles in the simulation).

An instance of the membrane may be initialized with the following lines, e.g. by using a STL file:

// Initialize the membrane and set neccesary quantities
Membrane membrane = Membrane(membraneSpecies_, membraneParticleSpecies_);
membrane.setDPMBase(this);
membrane.setKnAndCrittDampCoeff(Kn_, critDampCoeff_);
membrane.setKeAndKd(Ke_, Kd_);
 
// Set the (approximate) radius of the vertex particles
membrane.setParticleRadius(membraneParticleRadius_);
 
// Create an initial particle for the vertex particles
SphericalParticle p0;
p0.setSpecies(membraneParticleSpecies_);
p0.setRadius(membrane.getParticleRadius());
p0.setVelocity(Vec3D(0.0, 0.0, 0.0));
 
// Create the system using the specified particle and stl file
membrane_.readFromSTL(p0, "geometry.stl");

Note that the method computeAdditionalForces needs to be called from the overridden DPMBase::computeAdditionalForces every timestep for the Membrane to work.

As an example please also have a look at the Driver code MembraneDemo

Constructor & Destructor Documentation

Membrane() [1/2]

Membrane::Membrane

(

)

Default constructor.

{
    logger(DEBUG, "Membrane() constructed.");
    vertexInitId_ = 0;
    particleRadius_ = 0;
    Kn_ = 0;
    critDampCoeff_ = 0;
    Ke_ = 0;
    Kd_ = 0;
    thickness_ = 0;
    bendingAreaConstant_ = 0;
}

References bendingAreaConstant_, critDampCoeff_, DEBUG, Kd_, Ke_, Kn_, logger, particleRadius_, thickness_, and vertexInitId_.

Referenced by copy().

Membrane() [2/2]

Membrane::Membrane	(	ParticleSpecies *	membraneSpecies,
		ParticleSpecies *	membraneParticleSpecies
	)

                                                                                             : Membrane()
{
    membraneSpecies_ = membraneSpecies;
    membraneParticleSpecies_ = membraneParticleSpecies;
}

References membraneParticleSpecies_, and membraneSpecies_.

~Membrane()

Membrane::~Membrane ( )

override

Copy constructor.

Destructor.

Member Function Documentation

addEdge()

bool Membrane::addEdge ( std::vector< unsigned int > &  edges, std::map< std::pair< unsigned int, unsigned int >, int > &  map, unsigned int  v0, unsigned int  v1  )

private

Helper function to check if a given edge already exists.

Parameters

[in]	edges	The vector, where the new edge should be added
[in]	map	A map used to dtermin, if the edge already exists
[in]	v0	The index of the first point of the edge
[in]	v0	The index of the second point of the edge

Returns

True if a new edge was added, false if not.

This function adds a given edge to the vector edges, if it is not already contained.

{
    if ( map.find(std::make_pair(v0, v1)) == map.end() ){
        map[std::make_pair(v0,v1)] = 1;
        map[std::make_pair(v1,v0)] = 1;
 
        edges.push_back(v0);
        edges.push_back(v1);
        return true;
    }
    return false;
}

References v1().

Referenced by loadFromSTL().

addVertex()

unsigned int Membrane::addVertex ( std::vector< Vec3D > &  vertices, Vec3D  pos, Mdouble  eps  )

private

Helper function to check if a given vertex already exists.

Parameters

[in]	vertices	The vector, where the new position should be added
[in]	pos	The new position to add to the vector
[in]	eps	The distance between two points below which they are assumed to be the same.

Returns

the index of the position in the vector vertices.

This function adds a given position pos to the vector vertices, if it is not already contained.

{
    unsigned int i;
    for (i=0; i<vertices.size(); i++)
    {
        if ((vertices[i]-pos).getLength() < eps)
        {
            return i;
        }
    }
    
    vertices.push_back(pos);
    
    return vertices.size() - 1;
}

References CRBond_Bessel::eps, and i.

Referenced by loadFromSTL().

adjustVertexParticleSize()

void Membrane::adjustVertexParticleSize

(

)

Calculates an updated radius for every vertex particle in order to account for the correct mass.

Calculates an updated radius for every vertex particle in order to account for the correct mass.

{
    std::vector<unsigned int> numberTriangles(vertexParticle_.size(), 0);
    std::vector<Mdouble> massParticle(vertexParticle_.size(), 0.0);
    
    Mdouble mass;
    for (auto f: face_)
    {
        // 3 Nodes per triangle
        mass = 1/f->getInvMass()/3;
        for (auto id: f->getVertexIds())
        {
            numberTriangles[id-vertexInitId_] += 1;
            massParticle[id-vertexInitId_] += mass;
        }
    }
    
    unsigned int i;
    Mdouble volume;
    Mdouble radius;
    Mdouble density = membraneParticleSpecies_->getDensity();
    for (i=0; i<vertexParticle_.size(); i++)
    {
        mass = massParticle[i]/numberTriangles[i];
        volume = mass / density;
        radius = std::cbrt(3.0/4.0 * volume/constants::pi);
        
        vertexParticle_[i]->setRadius(radius);
    }
}

References Eigen::numext::cbrt(), UniformPSDSelfTest::density, f(), face_, ParticleSpecies::getDensity(), i, membraneParticleSpecies_, constants::pi, UniformPSDSelfTest::radius, vertexInitId_, and vertexParticle_.

applyPressure()

void Membrane::applyPressure

(

Mdouble

pressure

)

Apply a surface pressure to the membrane.

Parameters

[in]

pressure

Value of the surface pressure acing on the membrane [Pa]

This function applies a given pressure to the surface by calling the function applyPressure of a MeshTriangle.

                                            {
    // Set the pressureforce to 0
    logger(DEBUG,"Calculating pressure force.");
 
    // #pragma omp parallel num_threads(getNumberOfOMPThreads())
    {
    // This should also be OMP parralelizable, because addForce pays attention
    // to OMP
        // #pragma omp for
        for (unsigned int i=0; i < face_.size(); i++ ){
            face_[i]->applyPressure(pressure);
        }
    }
}

References DEBUG, face_, i, and logger.

buildMesh()

void Membrane::buildMesh	(	BaseParticle &	p0,
		std::vector< Vec3D >	vertexPositions,
		std::vector< unsigned int >	edgeVertices,
		std::vector< unsigned int >	faceVertices
	)

Build the geometry from specified positions and their connectivity.

Parameters

[in]	p0	BaseParticle that will be used for the vertex particles
[in]	vertexPositions	The position of the vertices
[in]	edgeVertices	A vector of indices, where two consecutive values define the vertex particles connected by the edge
[in]	faceVertices	A vector of indices, where three consecutive values define the vertex particles making up the triangle face

This function creates the actual mesh including the vertex particles and wall elements. The mass of the triangles is set to match the actual weight of the cooresponding triangle. The density of the particle species is set, so that the mass of a vertex particle is equal to 5/3 times the mass of a triangle.

{    
    unsigned int triangleCount = faceVertices.size() / 3;
    unsigned int edgeCount = edgeVertices.size() / 2;
    // #ifdef MERCURYDPM_USE_MPI
    // if (PROCESSOR_ID==0)
    // #endif
    // logger(INFO, "Creating membrane with % vertices and % faces.", vertexPositions.size(), triangleCount);
 
    // Some helper variables
    unsigned int i;
    Vec3D v;
 
    // Calculate the density of the Membrane particles to approximately get the membrane weight
    // Note this should be changed. But for the beginning it is a way of setting an approx. okej density for the particles.
    i = 0;
    Mdouble membraneDensity = membraneSpecies_->getDensity();
    
 
    // Create particles corresponding to the Vertex Positions
    createVertexParticles(p0, vertexPositions);
    
    Mdouble averageTriangleMass = 0;
    Mdouble triangleMass = 0;
    // Create all faces with their initial positions
    face_.reserve(triangleCount);
    for (i = 0; i < triangleCount; i++)
    {
        // It seems copyAndAddObject does not actually copy in MPI mode
        MeshTriangle f;
        f.setVertices(vertexPositions[faceVertices[3*i]],
                      vertexPositions[faceVertices[3*i+1]],
                      vertexPositions[faceVertices[3*i+2]]);
        f.setVertexIds(vertexParticleId_[faceVertices[3*i]],
                       vertexParticleId_[faceVertices[3*i+1]],
                       vertexParticleId_[faceVertices[3*i+2]]);
        f.setSpecies(membraneSpecies_);
        
        triangleMass = f.getArea()*thickness_*membraneDensity;
        averageTriangleMass += triangleMass;
        f.setMass(triangleMass);
        
        f.actionsAfterParticleGhostUpdate();
        
        face_.push_back(getDPMBase()->wallHandler.copyAndAddObject(f));
        
    }
    
    averageTriangleMass /=  triangleCount;
    Mdouble particleDensity = 5.0/3.0 * averageTriangleMass/(particleRadius_*particleRadius_*particleRadius_*4/3.0*constants::pi);
    membraneParticleSpecies_->setDensity(particleDensity);
 
    // Create the edges
    Mdouble invMass1, invMass2;
    
    Mdouble vertexInvMass = 1.0 / ( membraneParticleSpecies_->getDensity() * 4.0 / 3.0 * constants::pi * particleRadius_ * particleRadius_ * particleRadius_ );
    for (i=0; i<edgeCount; i++){
        Edge e;
        e.vertexId[0] = vertexParticleId_[edgeVertices[2*i+0]];
        e.vertexId[1] = vertexParticleId_[edgeVertices[2*i+1]];
        
        invMass1 = vertexInvMass;
        invMass2 = vertexInvMass;
        
        e.vertex[0] = getDPMBase()->particleHandler.getObjectById(e.vertexId[0]);
        e.vertex[1] = getDPMBase()->particleHandler.getObjectById(e.vertexId[1]);
        
        // e.vertex[1] = vertexParticle_[edgeVertices[2*i+1]];
        e.initialState = vertexPositions[edgeVertices[2*i+1]]-vertexPositions[edgeVertices[2*i+0]];
        e.initialLength = e.initialState.getLength();
        e.effectiveMass = 1/(invMass1 + invMass2);
        
        // e.checkActive();
        edge_.push_back(e);
    }
    
    initializeEdgeBendingQuantities();
    
    for (i=0; i<edge_.size(); i++){
        edge_[i].checkActive();
    }
    updateFaceNeighbors();
    for (i=0; i<edge_.size(); i++)
    {
        edge_[i].calculateUPre(edge_[i].initialState, edge_[i].initialLength, edge_[i].faceInitialArea);
    }
}

References createVertexParticles(), e(), edge_, f(), face_, ParticleSpecies::getDensity(), getDPMBase(), BaseHandler< T >::getObjectById(), i, initializeEdgeBendingQuantities(), membraneParticleSpecies_, membraneSpecies_, p0, DPMBase::particleHandler, particleRadius_, constants::pi, ParticleSpecies::setDensity(), thickness_, updateFaceNeighbors(), v, and vertexParticleId_.

Referenced by loadFromSTL().

computeAdditionalForces()

void Membrane::computeAdditionalForces

(

)

Compute the forces due to the mass spring system.

This function iterates through all edges to calculate the forces due to the mass spring system. Ideally this function is called from the computeAllForces function of DPMBase.

                                      {    
    #pragma omp parallel for schedule(static) num_threads(getDPMBase()->getNumberOfOMPThreads())
    for (int i=0; i < edge_.size(); i++){
        edge_[i].applyForce(Kn_, critDampCoeff_, Ke_, Kd_, bendingAreaConstant_);
    }
}

References bendingAreaConstant_, critDampCoeff_, edge_, i, Kd_, Ke_, and Kn_.

Referenced by MembraneDemo::computeAdditionalForces(), and MembraneSelfTest::computeAdditionalForces().

copy()

Membrane * Membrane::copy

(

)

const

Copy method. It calls the copy constructor of this Object.

Copy assignment operator.

  \param[in] other The Membrane that must be copied.
 ‍/

Membrane::Membrane(const Membrane& other) : BaseObject(other) { face_ = other.face_; membraneSpecies_ = other.membraneSpecies_; DPMBase_ = other.DPMBase_;

logger(DEBUG, "Membrane(Membrane&) constructed."); }

Membrane::~Membrane() { logger(DEBUG, "~Membrane() has been called."); }

/*!

Returns

pointer to a Membrane object allocated using new.

{
    return new Membrane(*this);
}

References Membrane().

createVertexParticles()

void Membrane::createVertexParticles ( BaseParticle &  p0, std::vector< Vec3D >  vertexPositions  )

private

Handles the actual creation of vertex particles.

Parameters

[in]

p0

The template particle used to create the vertex particles

This function creates a particle for every position in the vector vertexPositions

{
    
    vertexInitId_ = getDPMBase()->particleHandler.getNumberOfRealObjects();
    
    Vec3D pos;
    for (unsigned int i = 0; i < vertexPositions.size(); i++){
        pos = vertexPositions[i];
        // Set the position
        p0.setPosition(pos);
 
        // Add the particle and save a reference
        getDPMBase()->particleHandler.copyAndAddObject(p0);
        vertexParticleId_.push_back(vertexInitId_+i);
        vertexParticle_.push_back(getDPMBase()->particleHandler.getObjectById(vertexInitId_+i));
    }
 
}

References BaseHandler< T >::copyAndAddObject(), getDPMBase(), ParticleHandler::getNumberOfRealObjects(), i, p0, DPMBase::particleHandler, vertexInitId_, vertexParticle_, and vertexParticleId_.

Referenced by buildMesh().

getBendingAreaConstant()

Mdouble Membrane::getBendingAreaConstant ( )

inline

{ return bendingAreaConstant_; }

References bendingAreaConstant_.

getCriticalDampingCoefficient()

Mdouble Membrane::getCriticalDampingCoefficient ( )

inline

{ return critDampCoeff_; }

References critDampCoeff_.

Referenced by MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

getDPMBase()

DPMBase* Membrane::getDPMBase ( )

inline

Get the stored pointer to DPMBase.

{ return DPMBase_; }

References DPMBase_.

Referenced by buildMesh(), createVertexParticles(), initializeEdgeBendingQuantities(), read(), and saveVertexPositions().

getFaces()

std::vector<MeshTriangle*> Membrane::getFaces ( )

inline

Returns a vecter with pointers to the mesh triangles.

{ return face_; };    

References face_.

getKd()

Mdouble Membrane::getKd ( )

inline

{ return Kd_; }

References Kd_.

Referenced by MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

getKe()

Mdouble Membrane::getKe ( )

inline

{ return Ke_; }

References Ke_.

Referenced by MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

getKn()

Mdouble Membrane::getKn ( )

inline

{ return Kn_; }

References Kn_.

Referenced by MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

getName()

std::string Membrane::getName ( ) const

overridevirtual

Returns the name of the object, here the string "Membrane".

Returns

The string "Membrane".

Implements BaseObject.

{
    return "Membrane";
}

getParticleRadius()

Mdouble Membrane::getParticleRadius ( )

inline

Returns the radius of the vertex particles.

{ return particleRadius_; }

References particleRadius_.

Referenced by MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

getThickness()

Mdouble Membrane::getThickness ( )

inline

{ return thickness_; }

References thickness_.

getVertexParticles()

std::vector<BaseParticle*> Membrane::getVertexParticles ( )

inline

Returns a vector with pointers to the vertex particles.

{ return vertexParticle_; };

References vertexParticle_.

Referenced by MembraneDemo::fixMembraneEdges(), and MembraneSelfTest::fixMembraneEdges().

getVolume()

Mdouble Membrane::getVolume

(

)

Calculate the volume of the membrane.

Returns

volume The enclosed volume of the membrane

This function computes the current volume enclosed by the membrane. Note: This function uses the Divergence theorem to integrate along the surface. The volume is therefore only accurate, if the surface is closed.

{
    Mdouble volume = 0;
 
    for (auto f: face_)
    {
        volume += Vec3D::dot(f->getPosition(), f->getFaceNormal()) * f->getArea();
    }
    
    return volume/3;
}

References Vec3D::dot(), f(), and face_.

handleParticleAddition()

void Membrane::handleParticleAddition	(	unsigned int	id,
		BaseParticle *	p
	)

Handles the addition of vertex particles to the particle handler.

Parameters

[in]	id	The id of the added particle
[in]	p	Pointer to the added particle

This function handles the addition of a particle with the given id to the particle handler. If the particle is contained in an edge, the edge is potentially. reactivated. This function is potentially usable for MPI parallelization

{
    for (auto& e: edge_)
    {
        e.handleParticleAddition(id, p);
    }
    
    // Now find the corresponding vertexParticle_
    unsigned i = id - vertexInitId_;
    if (vertexParticleId_.size() > i && vertexParticleId_[i] == id)
    {
        vertexParticle_[i] = p;
    } else
    {
        // Need to search for it
        for (i = 0; i < vertexParticleId_.size(); i++)
        {
            if (vertexParticleId_[i]==id)
            {
                // now i is the correct index
                vertexParticle_[i] = p;
                break;
            }
        }
    }
}

References e(), edge_, i, p, vertexInitId_, vertexParticle_, and vertexParticleId_.

handleParticleRemoval()

void Membrane::handleParticleRemoval

(

unsigned int

id

)

Handles the removal of vertex particles from the particle handler.

Parameters

[in]

id

The id of the removed particle

This function handles the removal of a particle with the given id from the particle handler. If the particle was contained in an edge, the edge is disabled. This function is potentially usable for MPI parallelization

{
    for (auto& e: edge_)
    {
        e.handleParticleRemoval(id);
    }
    
    // Now find the corresponding vertexParticle_
    unsigned i = id - vertexInitId_;
    if (vertexParticleId_[i] == id)
    {
        vertexParticle_[i] = nullptr;
    } else
    {
        // Need to search for it
        for (i = 0; i < vertexParticleId_.size(); i++)
        {
            if (vertexParticleId_[i]==id)
            {
                // now i is the coorect index
                vertexParticle_[i] = nullptr;
                break;
            }
        }
    }
}

References e(), edge_, i, vertexInitId_, vertexParticle_, and vertexParticleId_.

initializeEdgeBendingQuantities()

void Membrane::initializeEdgeBendingQuantities ( )

private

Compute the forces due to the mass spring system.

This function initializes the quantities and pointer needed on the edges for calculating the forces due to the mass spring system.

{
    //set neighbours
    unsigned int i, j;
    
    for (auto& e: edge_)
    {
        e.face[0] = nullptr;
        e.face[1] = nullptr;
        e.faceVertexId[0] = UINT_MAX;
        e.faceVertexId[1] = UINT_MAX;
        e.faceVertex[0] = nullptr;
        e.faceVertex[1] = nullptr;
        e.faceInitialArea[0] = 0;
        e.faceInitialArea[1] = 0;
        e.initialSineHalfTheta = 0;
        i = 0;
 
        unsigned int edgeId0 = e.vertexId[0];
        unsigned int edgeId1 = e.vertexId[1];
 
        for (unsigned int f=0; f<face_.size(); f++)
        {
            MeshTriangle* face0 = face_[f];
            std::array<unsigned int, 3> particleIds = face0->getVertexIds();
            j = UINT_MAX;
 
            if ( particleIds[0] == edgeId0)
            {
                if (particleIds[1] == edgeId1) j = particleIds[2];
                if (particleIds[2] == edgeId1) j = particleIds[1];
            }
            else if ( particleIds[0] == edgeId1)
            {
                if (particleIds[1] == edgeId0) j = particleIds[2];
                if (particleIds[2] == edgeId0) j = particleIds[1];
            }
            else if (   (particleIds[1] == edgeId1 && particleIds[2] == edgeId0)
                      ||(particleIds[1] == edgeId0 && particleIds[2] == edgeId1))
            {
                j = particleIds[0];
            }
 
            if (j!=UINT_MAX)
            {
                e.faceVertexId[i] = j;
                e.faceVertex[i] = getDPMBase()->particleHandler.getObjectById(j);
                e.face[i] = face0;
                e.faceInitialArea[i] = face0->getArea();
                if (i==1)
                {
                    e.initialSineHalfTheta = e.getSineHalfTheta();
                }
                i += 1;
            }
        }
    }
}

References e(), edge_, f(), oomph::QElement1FaceToBulkCoordinates::face0(), face_, getDPMBase(), BaseHandler< T >::getObjectById(), i, j, and DPMBase::particleHandler.

Referenced by buildMesh().

loadFromSTL() [1/2]

void Membrane::loadFromSTL	(	BaseParticle &	p0,
		std::string	fileName
	)

Load the Membrane geometry from a .stl file.

Parameters

[in]	p0	BaseParticle that will be used for the vertex particles
[in]	fileName	The name of the file to load.

This function loads the geometry from the STL file and calls the function buildMesh.

{
    loadFromSTL(p0, fileName, 1e-8);
}

References e(), UniformPSDSelfTest::fileName, and p0.

Referenced by MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

loadFromSTL() [2/2]

void Membrane::loadFromSTL	(	BaseParticle &	p0,
		std::string	fileName,
		Mdouble	eps
	)

Load the Membrane geometry from a .stl file.

Parameters

[in]	p0	BaseParticle that will be used for the vertex particles
[in]	fileName	The name of the file to load.
[in]	eps	The distance between two points below which they are assumed to be the same.

This function loads the geometry from the STL file and calls the function buildMesh.

{
    std::vector<Vec3D> vertexPositions;
    std::vector<unsigned int> edgeVertices;
    std::vector<unsigned int> faceVertices;
    
    
    std::ifstream is;
    is.open(fileName, std::ios_base::in);
    
    if (!is.is_open())
        logger(ERROR, "Membrane::loadFromSTL Cannot open file %.", fileName);
        
    std::string dummy;
    unsigned int i;
    Vec3D pos;
    
    // solid name
    is >> dummy >> dummy;
    // endsolid or facet
    is >> dummy;
    while ( dummy.compare("endsolid") )
    {
        // normal Vec3D
        is >> dummy >> pos;
        // outer loop
        is >> dummy >> dummy;
        for (i=0; i<3; i++)
        {
            // vertex pos
            is >> dummy >> pos;
            faceVertices.push_back(addVertex(vertexPositions, pos, eps));
        }
        // endloop
        is >> dummy;
        // endfacet
        is >> dummy;
        // endsolid or facet
        is >> dummy;
    }
    is.close();
    
    // Create the neccesary edges;
    std::map<std::pair<unsigned int, unsigned int>, int> existingEdges;
    for (i=0; i<faceVertices.size()/3; i++)
    {
        addEdge(edgeVertices, existingEdges, faceVertices[3*i+0], faceVertices[3*i+1]);
        addEdge(edgeVertices, existingEdges, faceVertices[3*i+1], faceVertices[3*i+2]);
        addEdge(edgeVertices, existingEdges, faceVertices[3*i+2], faceVertices[3*i+0]);
    }
    
    // logger(INFO, "Got % vertices, % edges % faces", vertexPositions.size(), edgeVertices.size()/2, faceVertices.size()/3);
    buildMesh(p0, vertexPositions, edgeVertices, faceVertices);
}

References addEdge(), addVertex(), buildMesh(), CRBond_Bessel::eps, ERROR, UniformPSDSelfTest::fileName, i, logger, p0, and oomph::Global_string_for_annotation::string().

loadVertexPositions()

void Membrane::loadVertexPositions

(

std::istream &

is

)

Load the positions of the vertex particles from a stream and apply them to existing particles.

{
    unsigned int nVertices, i;
    std::string dummy;
    Vec3D pos;
    is >> dummy >> nVertices;
    is >> dummy;
 
    #ifdef MERCURYDPM_USE_MPI
    if (PROCESSOR_ID==0)
    #endif
    logger.assert_always(nVertices==vertexParticleId_.size(),
                  "Error in Membrane::loadVertexPositions: The number of saved Particles differs from the number of actual particles");
    for (i=0; i<nVertices; i++)
    {
        is >> pos;
        if (vertexParticle_[i]) 
        {
            vertexParticle_[i]->setPosition(pos);
        }
    }
 
    // #ifdef MERCURYDPM_USE_MPI
    // if (PROCESSOR_ID==0)
    // #endif
    // logger(INFO, "Loaded % membrane particles", nVertices);
}

References i, logger, PROCESSOR_ID, oomph::Global_string_for_annotation::string(), vertexParticle_, and vertexParticleId_.

read()

void Membrane::read ( std::istream &  is )

overridevirtual

Reads a Membrane from an input stream, for example a restart file.

Parameters

[in]

is

The input stream from which the Membrane is read, usually a restart file.

Implements BaseObject.

{
    
    logger.assert_debug(DPMBase_, "Error in Membrane::read: DPMBase is not knwon.");
    
    std::string dummy;
    unsigned int i, n, Id;
 
    // Reading in the Ids of all the vertex particles
    is >> dummy >> n;
    vertexParticle_.reserve(n);
    for (i=0; i<n; i++)
    {
        is >> Id;
        vertexParticleId_.push_back(Id);
        // this might retrieve a nullptr
        vertexParticle_.push_back(getDPMBase()->particleHandler.getObjectById(Id));
    }
    is >> dummy >> vertexInitId_;
 
    // Reading in the Ids of the faces
    is >> dummy >> n;
    face_.reserve(n);
    MeshTriangle* f;
    for (i=0; i<n; i++)
    {
        is >> Id;
        f = dynamic_cast<MeshTriangle*>(getDPMBase()->wallHandler.getObjectById(Id));
        face_.push_back(f);
    }
 
    // Reading in the edge information
    is >> dummy >> n;
    edge_.reserve(n);
    for (i=0; i<n; i++)
    {
        Edge e;
        // the vertex ids
        is >> dummy >> e.vertexId[0];
        e.vertex[0] = getDPMBase()->particleHandler.getObjectById(e.vertexId[0]);
        is >> dummy >> e.vertexId[1];
        e.vertex[1] = getDPMBase()->particleHandler.getObjectById(e.vertexId[1]);
 
        is >> dummy >> e.faceVertexId[0];
        if (e.faceVertexId[0] != UINT_MAX) {
            e.faceVertex[0] = getDPMBase()->particleHandler.getObjectById(e.faceVertexId[0]);
        } else {
            e.faceVertex[0] = nullptr;
        }
        is >> dummy >> e.faceVertexId[1];
        if (e.faceVertexId[1] != UINT_MAX) {
 
            e.faceVertex[1] = getDPMBase()->particleHandler.getObjectById(e.faceVertexId[1]);
        } else {
            e.faceVertex[1] = nullptr;
        }
        is >> dummy >> Id;
        if (Id != UINT_MAX) {
            e.face[0] = dynamic_cast<MeshTriangle*>(getDPMBase()->wallHandler.getObjectById(Id));
        } else {
            e.face[0] = nullptr;
        }
        is >> dummy >> Id;
        if (Id != UINT_MAX) {
            e.face[1] = dynamic_cast<MeshTriangle*>(getDPMBase()->wallHandler.getObjectById(Id));
        } else {
            e.face[1] = nullptr;
        }
 
        is >> dummy >> e.faceInitialArea[0];
        is >> dummy >> e.faceInitialArea[1];
        for (unsigned int i=0; i<8; i++){
            is >> dummy >> e.uPre[i];
        }
 
        // initial state
        is >> dummy >> e.initialState;
        is >> dummy >> e.initialLength;
 
        is >> dummy >> e.initialSineHalfTheta;
 
        is >> dummy >> e.effectiveMass;
 
        e.checkActive();
        edge_.push_back(e);
    }
    
    // Reading in some general attributes
    is >> dummy >> particleRadius_; // Mdouble
 
    is >> dummy >> Kn_; // Mdouble
    is >> dummy >> critDampCoeff_; //Mdouble
 
    is >> dummy >> Ke_; // Mdouble
    is >> dummy >> Kd_; // Mdouble
    
    is >> dummy >> thickness_;
    
    is >> dummy >> bendingAreaConstant_;
    
    is >> dummy >> Id;
    membraneSpecies_ = getDPMBase()->speciesHandler.getObjectById(Id);
    is >> dummy >> Id;
    membraneParticleSpecies_ = getDPMBase()->speciesHandler.getObjectById(Id);
    
    for (auto& e: edge_)
    {
        e.checkActive();
    }
}

References bendingAreaConstant_, critDampCoeff_, DPMBase_, e(), edge_, f(), face_, getDPMBase(), BaseHandler< T >::getObjectById(), i, Kd_, Ke_, Kn_, logger, membraneParticleSpecies_, membraneSpecies_, n, DPMBase::particleHandler, particleRadius_, DPMBase::speciesHandler, oomph::Global_string_for_annotation::string(), thickness_, vertexInitId_, vertexParticle_, vertexParticleId_, and DPMBase::wallHandler.

saveAsOFF()

void Membrane::saveAsOFF

(

unsigned int

d

)

Save the Membrane as a .off file.

Parameters

[in]

unsigned

int d

This function saves the current geometry of the membrane to a file named membrane.$d.off.

{
    std::stringstream lastName("");
    lastName << "membrane." << d << ".off";
    
    std::ofstream membraneOFF;
    membraneOFF.open(lastName.str(), std::ios_base::out);
    
    membraneOFF << "OFF\n";
    membraneOFF << "# membrane.off\n";
    
    // Number of  Vertices Faces and Edges (edges are optional)
    membraneOFF << vertexParticle_.size() << " " << face_.size() << " 0" << std::endl;
    
    // Print the coordinates of all vertices
    for (auto p: vertexParticle_)
    {
        membraneOFF << p->getPosition() << std::endl;
    }
    
    // Print all faces
    for (auto f: face_)
    {
        membraneOFF << "3 ";
        for (auto id: f->getVertexIds())
        {
            membraneOFF << id - vertexInitId_ << " ";
        } 
        membraneOFF <<  std::endl;
    }
}

References f(), face_, out(), p, vertexInitId_, and vertexParticle_.

saveAsSTL()

void Membrane::saveAsSTL

(

std::string

fileName

)

Save the Membrane as a .stl file.

Parameters

[in]

fileName

The name of the file where the data is written to.

This function writes the current geometry of the Membrane to a STL file.

{
    std::ofstream os;
    os.open(fileName, std::ios_base::out);
    
    if (!os.is_open())
        logger(ERROR, "Membrane::saveAsSTL Cannot open file %.", fileName);
        
    os << "solid Membrane" << std::endl;
    
    std::array<Vec3D,3> vertexPositions;
    for (auto face: face_)
    {
        os << "  facet normal " << face->getFaceNormal() << std::endl;
        os << "    outer loop" << std::endl;
        vertexPositions = face->getVertices();
        for (auto pos: vertexPositions)
        {
            os << "      vertex " << pos << std::endl;
        }
        os << "    endloop" << std::endl;
        os << "  endfacet" << std::endl;
    }
    
    os << "endsolid Membrane" << std::endl;
}

References ERROR, face_, UniformPSDSelfTest::fileName, logger, and out().

saveVertexPositions()

void Membrane::saveVertexPositions

(

std::ostream &

os

)

save the current positions of the vertex particles to a stream

{
    #ifdef MERCURYDPM_USE_MPI
    if (PROCESSOR_ID==0)
    {
        os << " nMembraneParticles " << vertexParticleId_.size();
        os << " membraneParticlePositions ";
    }
    
    Vec3D pos, pos1;
    Mdouble active;
    BaseParticle* p0;
    for (unsigned int i=0; i < vertexParticleId_.size(); i++)
    {
        pos = Vec3D(0,0,0);
        p0 = getDPMBase()->particleHandler.getObjectById(vertexParticleId_[i]);
        if (p0 && !p0->isMPIParticle())
        {
            pos = p0->getPosition();
            active = getMPISum(1.0);
        }
        else
        {
            active = getMPISum(0.0);
        }
        
        pos1 = getMPISum(pos);
        if (PROCESSOR_ID==0 && active > 0.1)
        {
            os << pos1 << " ";
        }
    }    
    if (PROCESSOR_ID==0)
    {
        os << "\n";
    }
    #else
    os << " nMembraneParticles " << vertexParticleId_.size();
    os << " membraneParticlePositions ";
    BaseParticle* p0;
    for (unsigned int i=0; i < vertexParticleId_.size(); i++)
    {
        p0 = getDPMBase()->particleHandler.getObjectById(vertexParticleId_[i]);
        os << p0->getPosition() << " ";
    }
    #endif
}

References getDPMBase(), getMPISum(), BaseHandler< T >::getObjectById(), i, p0, DPMBase::particleHandler, PROCESSOR_ID, and vertexParticleId_.

setBendingAreaConstant()

void Membrane::setBendingAreaConstant

(

bool

areaConstant

)

If set to true, the bending penalty is calulated using the initial triangle area instead of the current one.

{ 
    bendingAreaConstant_ = areaConstant; 
}

References bendingAreaConstant_.

setCriticalDampingCoefficient()

void Membrane::setCriticalDampingCoefficient

(

Mdouble

coeff

)

Set damping coefficient for the distance springs.

{ 
    critDampCoeff_ = coeff; 
}

References critDampCoeff_.

Referenced by MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

setDPMBase()

void Membrane::setDPMBase ( DPMBase *  dpm )

inline

Set a pointer to DPMBase.

{ DPMBase_ = dpm; }

References DPMBase_.

Referenced by MembraneDemo::read(), MembraneSelfTest::read(), MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

setElasticModulusAndThickness()

void Membrane::setElasticModulusAndThickness	(	Mdouble	E,
		Mdouble	thickness
	)

Set the elastic modulus and thickness of the membrane.

The supplied values are used to calculate the spring constant of the membrane.

{
    setThickness(thickness);
    Kn_ = E * thickness_/(sqrt(3)*(1-1/3.0));
}

References Global_Physical_Variables::E, Kn_, setThickness(), sqrt(), and thickness_.

Referenced by MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

setKeAndKd()

void Membrane::setKeAndKd	(	Mdouble	Ke,
		Mdouble	Kd
	)

Set the parameters needed for the bending forces.

{ 
    Ke_ = Ke; 
    Kd_ = Kd;
}

References Kd_, and Ke_.

Referenced by MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

setKnAndCrittDampCoeff()

void Membrane::setKnAndCrittDampCoeff	(	Mdouble	Kn,
		Mdouble	critDampCoeff
	)

Set the parameters needed for the stretching forces.

                                                                       { 
    Kn_ = Kn; 
    critDampCoeff_ = critDampCoeff;
}

References critDampCoeff_, and Kn_.

setParticleRadius()

void Membrane::setParticleRadius

(

Mdouble

radius

)

Set the radius of the vertex particles.

{
    logger.assert_debug(radius > 0, "Error in Membrane::setParticleRadius: Radius has to be greater than 0.");
    particleRadius_ = radius;
}

References logger, particleRadius_, and UniformPSDSelfTest::radius.

Referenced by MembraneDemo::setUpMembrane(), and MembraneSelfTest::setUpMembrane().

setSpringConstant()

void Membrane::setSpringConstant

(

Mdouble

k

)

Set the spring constant of the membrane.

{
    logger.assert_debug(k >= 0, "Error in Membrane::setSpringConstant: The constant has to be greater than or equal to 0.");
    Kn_ = k;
}

References k, Kn_, and logger.

setThickness()

void Membrane::setThickness

(

Mdouble

thickness

)

Set the thickness of the membrane.

{ 
    logger.assert_debug(thickness > 0, "Error in Membrane::setThickness: The thickness has to be greater than 0.");
    thickness_ = thickness; 
}

References logger, and thickness_.

Referenced by setElasticModulusAndThickness().

updateEdgeMass()

void Membrane::updateEdgeMass

(

)

Set the correct edge mass by taking the mass from the conencted vertices.

Set the correct edge mass by taking the mass from the conencted vertices.

{
    Mdouble invMass;
    for (auto e: edge_)
    {
        invMass = vertexParticle_[e.vertexId[0]-vertexInitId_]->getInvMass()
                + vertexParticle_[e.vertexId[1]-vertexInitId_]->getInvMass();
        
        if (invMass > 0)
        {
            e.effectiveMass = 1/invMass;
        }
        else
        {
            e.effectiveMass = 0;
        }
        
        e.checkActive();
    }
}

References e(), edge_, vertexInitId_, and vertexParticle_.

Referenced by MembraneDemo::fixMembraneEdges().

updateFaceNeighbors()

void Membrane::updateFaceNeighbors ( )

private

Update the faces to have the correct neighbors.

This function assigns the coorect neighbors to the wall elements.

{
    //set neighbours
    unsigned int i, j, k, l;
 
    for (i =0 ; i<face_.size(); i++)
    {
        face_[i]->vertexNeighbors = std::vector<std::vector<unsigned int>>();
        for (j=0; j<3; j++)
        {
            face_[i]->neighbor[j] = nullptr;
            std::vector<unsigned int> a;
            face_[i]->vertexNeighbors.push_back(a);
        }
    }
    for (i =0 ; i<face_.size(); i++)
    {
        MeshTriangle* face0 = face_[i];
        std::array<unsigned int, 3> particleIds0 = face0->getVertexIds();
        for (j=i+1 ; j<face_.size(); j++)
        {
            MeshTriangle* face1 = face_[j];
            std::array<unsigned int, 3> particleIds1 = face1->getVertexIds();
            if (particleIds0[0] == particleIds1[0])
            {
                if (particleIds0[1] == particleIds1[2])
                { //edge 0=2
                    face0->neighbor[0] = &*face1;
                    face1->neighbor[2] = &*face0;
                }
                else if (particleIds0[2] == particleIds1[1])
                { //edge 2=0
                    face0->neighbor[2] = &*face1;
                    face1->neighbor[0] = &*face0;
                }
            }
            else if (particleIds0[0] == particleIds1[1])
            {
                if (particleIds0[1] == particleIds1[0])
                { //edge 0=0
                    face0->neighbor[0] = &*face1;
                    face1->neighbor[0] = &*face0;
                }
                else if (particleIds0[2] == particleIds1[2])
                { //edge 2=1
                    face0->neighbor[2] = &*face1;
                    face1->neighbor[1] = &*face0;
                }
            }
            else if (particleIds0[0] == particleIds1[2])
            {
                if (particleIds0[1] == particleIds1[1])
                { //edge 0=1
                    face0->neighbor[0] = &*face1;
                    face1->neighbor[1] = &*face0;
                }
                else if (particleIds0[2] == particleIds1[0])
                { //edge 2=2
                    face0->neighbor[2] = &*face1;
                    face1->neighbor[2] = &*face0;
                }
            }
            else if (particleIds0[1] == particleIds1[0])
            {
                if (particleIds0[2] == particleIds1[2])
                { //edge 1=2
                    face0->neighbor[1] = &*face1;
                    face1->neighbor[2] = &*face0;
                }
            }
            else if (particleIds0[1] == particleIds1[1])
            {
                if (particleIds0[2] == particleIds1[0])
                { //edge 1=0
                    face0->neighbor[1] = &*face1;
                    face1->neighbor[0] = &*face0;
                }
            }
            else if (particleIds0[1] == particleIds1[2])
            {
                if (particleIds0[2] == particleIds1[1])
                { //edge 1=1
                    face0->neighbor[1] = &*face1;
                    face1->neighbor[1] = &*face0;
                }
            }
 
        }
    }
 
    for (i =0 ; i<face_.size(); i++)
    {
        MeshTriangle* face0 = face_[i];
        std::array<unsigned int, 3> particleIds0 = face0->getVertexIds();
        for (j=i+1 ; j<face_.size(); j++)
        {
            MeshTriangle* face1 = face_[j];
            std::array<unsigned int, 3> particleIds1 = face1->getVertexIds();
            for (k=0; k<3; k++)
            {
                for (l=0; l<3; l++)
                {
                    if( particleIds0[k] == particleIds1[l])
                    {
                        face0->vertexNeighbors[k].push_back(face1->getId());
                        face1->vertexNeighbors[l].push_back(face0->getId());
                    }
                }
            }
        }
    }
}

References a, oomph::QElement1FaceToBulkCoordinates::face0(), oomph::QElement1FaceToBulkCoordinates::face1(), face_, i, j, and k.

Referenced by buildMesh().

write()

void Membrane::write ( std::ostream &  os ) const

overridevirtual

Writes a Membrane to an output stream, for example a restart file.

Parameters

[in]

os

The output stream where the Membrane must be written to, usually a restart file.

Implements BaseObject.

{
 
    // Write out the vertex-Particle Ids
    os << " vertexParticle " << vertexParticleId_.size();
    for (unsigned int i: vertexParticleId_)
    {
        os << " " << i;
    }
    
    os << " vertexInitId_ " << vertexInitId_;
    os << "\n";
 
    // Write out the face-wall Ids
    os << " face " << face_.size();
    for (auto f: face_)
    {
        os << " " << f->getId();
    }
    os << "\n";
 
    // Write out edge information
    os << " edge " << edge_.size();
    for (auto e: edge_)
    {
        // the vertex ids
        os << " v3 " << e.vertexId[0];
        os << " v4 " << e.vertexId[1];
 
        
        os << " v1 " << e.faceVertexId[0];    
        os << " v2 " << e.faceVertexId[1];
 
        if (e.face[1] != nullptr){
            os << " f1 " << e.face[0]->getId();
        } else {
            os << " f1 " << UINT_MAX;
        }
        if (e.face[1] != nullptr){
            os << " f2 " << e.face[1]->getId();
        } else {
            os << " f2 " << UINT_MAX;
        }
 
        os << " area1 " << e.faceInitialArea[0];
        os << " area2 " << e.faceInitialArea[1];
        for (unsigned int i=0; i<8; i++){
            os << " uPre " << e.uPre[i];
        }
        // initial state
        os << " initState " << e.initialState;
        os << " initDist " << e.initialLength;
        os << " initialSineHalfTheta " << e.initialSineHalfTheta;
        os << " effectiveMass " << e.effectiveMass;
        os << "\n";
    }
 
    // Write out general properties
    os << " particleRadius " << particleRadius_; // Mdouble
 
    os << " Kn " << Kn_; // Mdouble
    os << " critDampCoeff " << critDampCoeff_; //Mdouble
    
    os << " Ke " << Ke_; // Mdouble
    os << " Kd " << Kd_; // Mdouble
    
    os << " thickness " << thickness_;
    
    os << " bendingAreaConstant " << bendingAreaConstant_;
    
    os << " membraneSpecies " << membraneSpecies_->getId();
    os << " membraneParticleSpecies " << membraneParticleSpecies_->getId();
}

References bendingAreaConstant_, critDampCoeff_, e(), edge_, f(), face_, BaseObject::getId(), i, Kd_, Ke_, Kn_, membraneParticleSpecies_, membraneSpecies_, particleRadius_, thickness_, vertexInitId_, and vertexParticleId_.

Member Data Documentation

bendingAreaConstant_

bool Membrane::bendingAreaConstant_

private

Stores a pointer to DPMBase

Referenced by computeAdditionalForces(), getBendingAreaConstant(), Membrane(), read(), setBendingAreaConstant(), and write().

critDampCoeff_

Mdouble Membrane::critDampCoeff_

private

Stores damping coefficient for the normal springs

Referenced by computeAdditionalForces(), getCriticalDampingCoefficient(), Membrane(), read(), setCriticalDampingCoefficient(), setKnAndCrittDampCoeff(), and write().

DPMBase_

DPMBase* Membrane::DPMBase_ = nullptr

private

Stores a pointer to DPMBase

Referenced by getDPMBase(), read(), and setDPMBase().

edge_

std::vector<Edge> Membrane::edge_

private

Stores the edges

Referenced by buildMesh(), computeAdditionalForces(), handleParticleAddition(), handleParticleRemoval(), initializeEdgeBendingQuantities(), read(), updateEdgeMass(), and write().

face_

std::vector<MeshTriangle*> Membrane::face_

private

Stores pointers to the MeshTriangle objects

Referenced by adjustVertexParticleSize(), applyPressure(), buildMesh(), getFaces(), getVolume(), initializeEdgeBendingQuantities(), read(), saveAsOFF(), saveAsSTL(), updateFaceNeighbors(), and write().

faceVertices_

std::vector<unsigned int> Membrane::faceVertices_

private

Stores the 3 indices per face which can be used to get the ids from vertexParticleId_ // Todo: remove this

Kd_

Mdouble Membrane::Kd_

private

Stores dissipation constant for the bending

Referenced by computeAdditionalForces(), getKd(), Membrane(), read(), setKeAndKd(), and write().

Ke_

Mdouble Membrane::Ke_

private

Stores spring constant for the bending

Referenced by computeAdditionalForces(), getKe(), Membrane(), read(), setKeAndKd(), and write().

Kn_

Mdouble Membrane::Kn_

private

Stores the spring constant for stretching

Referenced by computeAdditionalForces(), getKn(), Membrane(), read(), setElasticModulusAndThickness(), setKnAndCrittDampCoeff(), setSpringConstant(), and write().

membraneParticleSpecies_

ParticleSpecies* Membrane::membraneParticleSpecies_ = nullptr

private

Stores a pointer to the membrane particle species

Referenced by adjustVertexParticleSize(), buildMesh(), Membrane(), read(), and write().

membraneSpecies_

ParticleSpecies* Membrane::membraneSpecies_ = nullptr

private

Stores a pointer to the membrane species

Referenced by buildMesh(), Membrane(), read(), and write().

particleRadius_

Mdouble Membrane::particleRadius_

private

Stores the radius of membrane particles

Referenced by buildMesh(), getParticleRadius(), Membrane(), read(), setParticleRadius(), and write().

thickness_

Mdouble Membrane::thickness_

private

Stores thickness of the Membrane

Referenced by buildMesh(), getThickness(), Membrane(), read(), setElasticModulusAndThickness(), setThickness(), and write().

vertexInitId_

unsigned int Membrane::vertexInitId_

private

Sores the id of the first particle created for the membrane. This value helps for the eventual MPI parallelization.

Referenced by adjustVertexParticleSize(), createVertexParticles(), handleParticleAddition(), handleParticleRemoval(), Membrane(), read(), saveAsOFF(), updateEdgeMass(), and write().

vertexParticle_

std::vector<BaseParticle*> Membrane::vertexParticle_

private

Stores the pointers to the vertex particles

Referenced by adjustVertexParticleSize(), createVertexParticles(), getVertexParticles(), handleParticleAddition(), handleParticleRemoval(), loadVertexPositions(), read(), saveAsOFF(), and updateEdgeMass().

vertexParticleId_

std::vector<unsigned int> Membrane::vertexParticleId_

private

Stores the ids of the vertex particles

Referenced by buildMesh(), createVertexParticles(), handleParticleAddition(), handleParticleRemoval(), loadVertexPositions(), read(), saveVertexPositions(), and write().

---

The documentation for this class was generated from the following files:

• Membrane.h
• Membrane.cc