LeesEdwardsBoundary Class Reference

Class which creates a boundary with Lees-Edwards type periodic boundary conditions. More...

#include <LeesEdwardsBoundary.h>

Inheritance diagram for LeesEdwardsBoundary:

Public Member Functions
	LeesEdwardsBoundary ()
	LeesEdwardsBoundary (const LeesEdwardsBoundary &other)
	Copy constructor. More...
void	set (std::function< Mdouble(Mdouble)> shift, std::function< Mdouble(Mdouble)> velocity, Mdouble left, Mdouble right, Mdouble down, Mdouble up)
	Sets all boundary properties. More...
void	updateBoundaries (Mdouble left, Mdouble right, Mdouble down, Mdouble up)
void	read (std::istream &is) override
	Reads all boundary properties from a stream. More...
void	write (std::ostream &os) const override
	Writes all boundary properties to a stream. More...
std::string	getName () const override
	Returns the name of the object. More...
LeesEdwardsBoundary *	copy () const override
	Creates a copy of the object. More...
Mdouble	getHorizontalDistance (BaseParticle &p, bool &positive)
	Returns distance from given particle to the closest horizontal wall. More...
Mdouble	getVerticalDistance (BaseParticle &p, bool &positive)
	Returns distance from given particle to the closest vertical wall. More...
void	shiftHorizontalPosition (BaseParticle *p, bool positive)
	Applies a horizontal shift to the given particle. More...
void	shiftVerticalPosition (BaseParticle *p, bool positive)
	Applies a vertical shift to the given particle. More...
void	checkBoundaryAfterParticleMoved (BaseParticle *p)
	Checks if particle crossed a boundary wall and if so, applies periodic shift. More...
void	checkBoundaryAfterParticlesMove (ParticleHandler &pH) override
	Checks if particles need to be adjusted after their position has been updated. More...
void	createPeriodicParticle (BaseParticle *p, ParticleHandler &pH) override
void	createPeriodicParticles (ParticleHandler &pH) override
	Creates horizontal and vertical periodic copies of given particle, if needed. More...
void	createHorizontalPeriodicParticle (BaseParticle *p, ParticleHandler &pH)
	Creates horizontal periodic copies of given particle, if needed. More...
void	createVerticalPeriodicParticle (BaseParticle *p, ParticleHandler &pH)
	Creates vertical periodic copies of given particle, if needed. More...
Mdouble	getCurrentShift ()
Mdouble	getCurrentVelocity ()
void	setShift (std::function< Mdouble(Mdouble)>)
void	setVelocity (std::function< Mdouble(Mdouble)>)
Public Member Functions inherited from BaseBoundary
	BaseBoundary ()
	default constructor. More...
	BaseBoundary (const BaseBoundary &b)
	copy constructor More...
	~BaseBoundary () override
	destructor More...
virtual void	createPeriodicParticle (BaseParticle *p UNUSED, ParticleHandler &pH UNUSED)
	Creates a periodic particle in case of periodic boundaries in serial build. More...
virtual void	createPeriodicParticles (ParticleHandler &pH UNUSED)
	Creates periodic copies of given particle in case of periodic boundaries. More...
virtual void	checkBoundaryBeforeTimeStep (DPMBase *md)
	Virtual function that does things before each time step. More...
virtual void	actionsBeforeTimeLoop ()
	Virtual function that does something after DPMBase::setupInitialConditions but before the first time step. More...
virtual void	modifyGhostAfterCreation (BaseParticle *particle, int i)
virtual void	writeVTK (std::fstream &file)
void	setHandler (BoundaryHandler *handler)
	Sets the boundary's BoundaryHandler. More...
BoundaryHandler *	getHandler () const
	Returns the boundary's BoundaryHandler. 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 Attributes
Mdouble	left_
Mdouble	right_
	(signed) Horizontal distance between the left wall and the origin More...
Mdouble	down_
	(signed) Horizontal distance between the right wall and the origin More...
Mdouble	up_
	(signed) Vertical distance between the bottom wall and the origin More...
std::function< Mdouble(Mdouble)>	shift_
	(signed) Vertical distance between the top wall and the origin More...
std::function< Mdouble(Mdouble)>	velocity_

Detailed Description

Class which creates a boundary with Lees-Edwards type periodic boundary conditions.

A LeesEdwardsBoundary is like a PeriodicBoundary, but when a particle crosses one edge and is copied to the other side then the particle is also shifted. This sort of boundary is useful for studying shear flows.

See also Lees and Edwards (J. Phys. C 1921, doi:1088/0022-3719/5/15/006). Inherits from BaseBoundary.

Todo:

Add link to paper by Lees-Edwards in the documentation of this class.

Is implemented for 2D only now. Needs extension to 3D.

Constructor & Destructor Documentation

LeesEdwardsBoundary() [1/2]

LeesEdwardsBoundary::LeesEdwardsBoundary ( )

inline

    {
#ifdef MERCURYDPM_USE_MPI
        MPIContainer& communicator = MPIContainer::Instance();
        if (communicator.getNumberOfProcessors() > 1)
        {
            logger(WARN,"LeesEdwardsBoundaries are currently not implemented in parallel MercuryDPM");
        }
#endif
    }

References MPIContainer::getNumberOfProcessors(), MPIContainer::Instance(), logger, and WARN.

Referenced by copy().

LeesEdwardsBoundary() [2/2]

LeesEdwardsBoundary::LeesEdwardsBoundary

(

const LeesEdwardsBoundary &

other

)

Copy constructor.

                                                                         : BaseBoundary(other)
{
    shift_      = other.shift_;
    velocity_   = other.velocity_;
    left_       = other.left_;
    right_      = other.right_;
    down_       = other.down_;
    up_         = other.up_;
}

References down_, left_, right_, shift_, up_, and velocity_.

Member Function Documentation

checkBoundaryAfterParticleMoved()

void LeesEdwardsBoundary::checkBoundaryAfterParticleMoved

(

BaseParticle *

p

)

Checks if particle crossed a boundary wall and if so, applies periodic shift.

Checks if the particle has to be shifted into the main domain (i.e., if the particle has crossed any of the boundary walls) and if so performs the shift

Parameters

[in]

p

A pointer to the BaseParticle that is checked

{
    bool positive;
    while (getVerticalDistance(*p, positive) < 0)
    {
        shiftVerticalPosition(p, positive);
    }
    while (getHorizontalDistance(*p, positive) < 0)
    {
        shiftHorizontalPosition(p, positive);
    }
}

References getHorizontalDistance(), getVerticalDistance(), p, shiftHorizontalPosition(), and shiftVerticalPosition().

Referenced by checkBoundaryAfterParticlesMove().

checkBoundaryAfterParticlesMove()

void LeesEdwardsBoundary::checkBoundaryAfterParticlesMove ( ParticleHandler &  pH )

overridevirtual

Checks if particles need to be adjusted after their position has been updated.

Reimplemented from BaseBoundary.

{
    for (auto p = pH.begin(); p != pH.end(); ++p)
    {
        checkBoundaryAfterParticleMoved(*p);
    }
}

References BaseHandler< T >::begin(), checkBoundaryAfterParticleMoved(), BaseHandler< T >::end(), and p.

copy()

LeesEdwardsBoundary * LeesEdwardsBoundary::copy ( ) const

overridevirtual

Creates a copy of the object.

Copy method; creates a copy on the heap and returns its pointer.

Returns

pointer to the copy on the heap

Implements BaseBoundary.

{
    return new LeesEdwardsBoundary(*this);
}

References LeesEdwardsBoundary().

createHorizontalPeriodicParticle()

void LeesEdwardsBoundary::createHorizontalPeriodicParticle	(	BaseParticle *	p,
		ParticleHandler &	pH
	)

Creates horizontal periodic copies of given particle, if needed.

Check if periodic copies of the particle in horizontal direction have to be made (i.e., if the distance of the particle to either of the horizontal boundary walls is smaller than its radius plus the radius of the largest particle in the system), and if so makes them

Parameters

[in]	p	A pointer to the BaseParticle that is checked
[out]	pH	A reference to the ParticleHandler where periodic copies will be added

{
    bool positive;      // TRUE if the particle is closest to the left boundary 
    // wall (set by getVerticalDistance in the following if-statement)
                        //
                        // Note, 'positive' is passed by reference to getHorizontalDistance
    // check if particle is close enough to either of the walls
    const Mdouble maxDistance = p->getMaxInteractionRadius() + pH.getLargestParticle()->getMaxInteractionRadius();
    if (getHorizontalDistance(*p, positive) < maxDistance)
    {
        // create a periodic copy of the particle
        BaseParticle* F0 = p->copy();
        pH.addObject(F0);
        F0->copyInteractionsForPeriodicParticles(*p);
        
        // If Particle is doubly shifted, get correct original particle
        BaseParticle* From = p;
        while (From->getPeriodicFromParticle() != nullptr)
            From = From->getPeriodicFromParticle();
        F0->setPeriodicFromParticle(From);
        
        // shift the copy to the 'periodic' position
        shiftHorizontalPosition(F0, positive);
        
        // NB: No extra creation of possible vertical copies of the horizontal copy 
        // here (as compared to createVerticalPeriodicParticle), because these would
        // overlap with the extra creation of horizontal copies in createVerticalPeriodicParticle.
    }
}

References ParticleHandler::addObject(), BaseInteractable::copyInteractionsForPeriodicParticles(), getHorizontalDistance(), ParticleHandler::getLargestParticle(), BaseParticle::getMaxInteractionRadius(), BaseParticle::getPeriodicFromParticle(), p, BaseParticle::setPeriodicFromParticle(), and shiftHorizontalPosition().

Referenced by createPeriodicParticle(), and createVerticalPeriodicParticle().

createPeriodicParticle()

void LeesEdwardsBoundary::createPeriodicParticle ( BaseParticle *  p, ParticleHandler &  pH  )

override

Check if periodic copies of the particle have to be made for the contact detection and if so makes them

Parameters

[in]	p	A pointer to the BaseParticle that is checked
[out]	pH	A reference to the ParticleHandler where periodic copies will be added

{
    createVerticalPeriodicParticle(p, pH);
    createHorizontalPeriodicParticle(p, pH);
}

References createHorizontalPeriodicParticle(), createVerticalPeriodicParticle(), and p.

Referenced by createPeriodicParticles().

createPeriodicParticles()

void LeesEdwardsBoundary::createPeriodicParticles ( ParticleHandler &  pH )

override

Creates horizontal and vertical periodic copies of given particle, if needed.

{
    unsigned numberOfParticles = pH.getSize();
    for (unsigned i = 0; i < numberOfParticles; i++)
    {
        createPeriodicParticle(pH.getObject(i), pH);
    }
}

References createPeriodicParticle(), BaseHandler< T >::getObject(), BaseHandler< T >::getSize(), and i.

createVerticalPeriodicParticle()

void LeesEdwardsBoundary::createVerticalPeriodicParticle	(	BaseParticle *	p,
		ParticleHandler &	pH
	)

Creates vertical periodic copies of given particle, if needed.

Check if periodic copies of the particle in vertical direction have to be made (i.e., if the distance of the particle to either of the vertical boundary walls is smaller than its radius plus the radius of the largest particle in the system), and if so makes them

Parameters

[in]	p	A pointer to the BaseParticle that is checked
[out]	pH	A reference to the ParticleHandler where periodic copies will be added

{
    bool positive;      // TRUE if the particle is closest to the bottom boundary 
    // wall (set by getVerticalDistance in the following if-statement)
    // check if particle is close enough to either of the walls
    const Mdouble maxDistance = p->getMaxInteractionRadius() + pH.getLargestParticle()->getMaxInteractionRadius();
    if (getVerticalDistance(*p, positive) < maxDistance)
    {
        // create a periodic copy of the particle
        BaseParticle* F0 = p->copy();
        pH.addObject(F0);
        F0->copyInteractionsForPeriodicParticles(*p);
        
        // If Particle is doubly shifted, get correct original particle
        BaseParticle* From = p;
        while (From->getPeriodicFromParticle() != nullptr)
            From = From->getPeriodicFromParticle();
        F0->setPeriodicFromParticle(From);
        
        // shift the copy to the 'periodic' position
        shiftVerticalPosition(F0, positive);
        while (getHorizontalDistance(*F0, positive) < 0)
        {
            shiftHorizontalPosition(F0, positive);
        }
        
        // Create horizontal periodic copies of the copy particle, if needed (i.e.,
        // if the original particle is in one of the boundary corners).
        createHorizontalPeriodicParticle(pH.getLastObject(), pH);
    }
}

References ParticleHandler::addObject(), BaseInteractable::copyInteractionsForPeriodicParticles(), createHorizontalPeriodicParticle(), getHorizontalDistance(), ParticleHandler::getLargestParticle(), BaseHandler< T >::getLastObject(), BaseParticle::getMaxInteractionRadius(), BaseParticle::getPeriodicFromParticle(), getVerticalDistance(), p, BaseParticle::setPeriodicFromParticle(), shiftHorizontalPosition(), and shiftVerticalPosition().

Referenced by createPeriodicParticle().

getCurrentShift()

Mdouble LeesEdwardsBoundary::getCurrentShift

(

)

{
    Mdouble time = getHandler()->getDPMBase()->getTime();
    return shift_(time);
}

References BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getTime(), and shift_.

getCurrentVelocity()

Mdouble LeesEdwardsBoundary::getCurrentVelocity

(

)

{
    Mdouble time = getHandler()->getDPMBase()->getTime();
    return velocity_(time);
}

References BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getTime(), and velocity_.

getHorizontalDistance()

Mdouble LeesEdwardsBoundary::getHorizontalDistance	(	BaseParticle &	p,
		bool &	positive
	)

Returns distance from given particle to the closest horizontal wall.

Returns the distance between BaseParticle p and the closest boundary wall in horizontal direction

Parameters

[in]	p	A reference to the BaseParticle
[out]	positive	A boolean which is true when the left wall is closest

Returns

The distance to the closes wall in horizontal direction

{
    Mdouble left = p.getPosition().X - left_;
    Mdouble right = right_ - p.getPosition().X;
    if (left < right)
    {
        positive = true;
        return left;
    }
    else
    {
        positive = false;
        return right;
    }
}

References left_, p, and right_.

Referenced by checkBoundaryAfterParticleMoved(), createHorizontalPeriodicParticle(), and createVerticalPeriodicParticle().

getName()

std::string LeesEdwardsBoundary::getName ( ) const

overridevirtual

Returns the name of the object.

Returns

The name of this object (i.e. "LeesEdwardsBoundary")

Implements BaseObject.

{
    return "LeesEdwardsBoundary";
}

getVerticalDistance()

Mdouble LeesEdwardsBoundary::getVerticalDistance	(	BaseParticle &	p,
		bool &	positive
	)

Returns distance from given particle to the closest vertical wall.

Returns the distance between BaseParticle p and the closest wall in vertical direction

Parameters

[in]	p	A reference to the BaseParticle
[out]	positive	A boolean which is true when the bottom wall is closest

Returns

The distance to the closes wall in vertical direction

{
    Mdouble down = p.getPosition().Y - down_;
    Mdouble up = up_ - p.getPosition().Y;
    if (down < up)
    {
        positive = true;
        return down;
    }
    else
    {
        positive = false;
        return up;
    }
}

References down_, p, and up_.

Referenced by checkBoundaryAfterParticleMoved(), and createVerticalPeriodicParticle().

read()

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

overridevirtual

Reads all boundary properties from a stream.

Reads all the properties of the LeesEdwardsBoundary from an std::istream

Parameters

[in,out]

is

The stream from which the parameters are read

Implements BaseBoundary.

{
    std::string dummy;
    BaseBoundary::read(is);
    Mdouble shift;
    Mdouble velocity;
    is >> dummy >> left_ >> dummy >> right_ >> dummy >> down_ >> dummy >> up_ >> dummy >> shift >> dummy >> velocity;
    shift_ = [shift, velocity](Mdouble time UNUSED) { return shift + velocity * time; };
    velocity_ = [velocity](Mdouble time UNUSED) { return velocity; };
}

References down_, left_, BaseBoundary::read(), right_, shift_, oomph::Global_string_for_annotation::string(), UNUSED, up_, Jeffery_Solution::velocity(), and velocity_.

set()

void LeesEdwardsBoundary::set	(	std::function< Mdouble(Mdouble)>	shift,
		std::function< Mdouble(Mdouble)>	velocity,
		Mdouble	left,
		Mdouble	right,
		Mdouble	down,
		Mdouble	up
	)

Sets all boundary properties.

Allows the user to set all the properties of the LeesEdwardsBoundary at once.

Parameters

[in]	velocity	The difference in velocities at which the bottom and to wall move
[in]	left	The (signed) distance between the origin and the left wall
[in]	right	The (signed) distance between the origin and the right wall
[in]	down	The (signed) distance between the origin and the top wall
[in]	up	The (signed) distance between the origin and the bottom wall

{
    shift_ = shift;
    velocity_ = velocity;
    left_ = left;
    right_ = right;
    down_ = down;
    up_ = up;
}

References down_, left_, right_, shift_, up_, Jeffery_Solution::velocity(), and velocity_.

Referenced by LeesEdwardsSelfTest::LeesEdwardsSelfTest(), StressStrainControlBoundary::set(), LeesEdwardsDemo::setupInitialConditions(), and FullRestartTest::setupInitialConditions().

setShift()

void LeesEdwardsBoundary::setShift

(

std::function< Mdouble(Mdouble)>

shift

)

{
    shift_ = shift;
}

References shift_.

setVelocity()

void LeesEdwardsBoundary::setVelocity

(

std::function< Mdouble(Mdouble)>

velocity

)

{
    velocity_ = velocity;
}

References Jeffery_Solution::velocity(), and velocity_.

shiftHorizontalPosition()

void LeesEdwardsBoundary::shiftHorizontalPosition	(	BaseParticle *	p,
		bool	positive
	)

Applies a horizontal shift to the given particle.

Shifts the BaseParticle p in horizontal direction to its 'periodic' position, i.e. over the horizontal length of the boundary.

Parameters

[in]	p	A reference to the BaseParticle that has to be shifted
[in]	positive	A boolean which determines the direction of the shift NB: TRUE if particle is closest to the left boundary wall

{
    if (positive)
    {
        p->move(Vec3D(right_ - left_, 0.0, 0.0));
    }
    else
    {
        p->move(Vec3D(left_ - right_, 0.0, 0.0));
    }
}

References left_, p, and right_.

Referenced by checkBoundaryAfterParticleMoved(), createHorizontalPeriodicParticle(), and createVerticalPeriodicParticle().

shiftVerticalPosition()

void LeesEdwardsBoundary::shiftVerticalPosition	(	BaseParticle *	p,
		bool	positive
	)

Applies a vertical shift to the given particle.

Shifts the BaseParticle p in vertical direction to its 'periodic' position, i.e. over the vertical length of the boundary.

Parameters

[in]	p	A reference to the BaseParticle that has to be shifted
[in]	positive	A boolean which determines the direction of the shift NB: TRUE if particle is closest to the bottom boundary wall

{
    Mdouble time = getHandler()->getDPMBase()->getTime();
    if (positive)
    {
        p->move(Vec3D(shift_(time), up_ - down_, 0.0));
        p->addVelocity(Vec3D(velocity_(time), 0.0, 0.0));
    }
    else
    {
        p->move(Vec3D(-shift_(time), down_ - up_, 0.0));
        p->addVelocity(Vec3D(-velocity_(time), 0.0, 0.0));
    }
}

References down_, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getTime(), p, shift_, up_, and velocity_.

Referenced by checkBoundaryAfterParticleMoved(), and createVerticalPeriodicParticle().

updateBoundaries()

void LeesEdwardsBoundary::updateBoundaries	(	Mdouble	left,
		Mdouble	right,
		Mdouble	down,
		Mdouble	up
	)

{
    left_ = left;
    right_ = right;
    down_ = down;
    up_ = up;
}

References down_, left_, right_, and up_.

write()

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

overridevirtual

Writes all boundary properties to a stream.

Writes all the properties of the LeesEdwardsBoundary to an std::ostream

Parameters

[out]

os

The stream to which the parameters are written

Implements BaseBoundary.

{
    BaseBoundary::write(os);
    Mdouble time = getHandler()->getDPMBase()->getTime();
    os << " left " << left_ << " right " << right_ << " down " << down_ << " up " << up_ << " shift " << shift_(time)
       << " vel " << velocity_(time);
}

References down_, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getTime(), left_, right_, shift_, up_, velocity_, and BaseBoundary::write().

Member Data Documentation

down_

Mdouble LeesEdwardsBoundary::down_

private

(signed) Horizontal distance between the right wall and the origin

Referenced by getVerticalDistance(), LeesEdwardsBoundary(), read(), set(), shiftVerticalPosition(), updateBoundaries(), and write().

left_

Mdouble LeesEdwardsBoundary::left_

private

Referenced by getHorizontalDistance(), LeesEdwardsBoundary(), read(), set(), shiftHorizontalPosition(), updateBoundaries(), and write().

right_

Mdouble LeesEdwardsBoundary::right_

private

(signed) Horizontal distance between the left wall and the origin

Referenced by getHorizontalDistance(), LeesEdwardsBoundary(), read(), set(), shiftHorizontalPosition(), updateBoundaries(), and write().

shift_

std::function<Mdouble(Mdouble)> LeesEdwardsBoundary::shift_

private

(signed) Vertical distance between the top wall and the origin

Referenced by getCurrentShift(), LeesEdwardsBoundary(), read(), set(), setShift(), shiftVerticalPosition(), and write().

up_

Mdouble LeesEdwardsBoundary::up_

private

(signed) Vertical distance between the bottom wall and the origin

Referenced by getVerticalDistance(), LeesEdwardsBoundary(), read(), set(), shiftVerticalPosition(), updateBoundaries(), and write().

velocity_

std::function<Mdouble(Mdouble)> LeesEdwardsBoundary::velocity_

private

Referenced by getCurrentVelocity(), LeesEdwardsBoundary(), read(), set(), setVelocity(), shiftVerticalPosition(), and write().

---

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

• LeesEdwardsBoundary.h
• LeesEdwardsBoundary.cc