TimeDependentPeriodicBoundary Class Reference

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

#include <TimeDependentPeriodicBoundary.h>

Inheritance diagram for TimeDependentPeriodicBoundary:

Public Member Functions
	TimeDependentPeriodicBoundary ()
	default constructor More...
	~TimeDependentPeriodicBoundary ()
	destructor More...
TimeDependentPeriodicBoundary *	copy () const override
	copy method More...
	TimeDependentPeriodicBoundary (const TimeDependentPeriodicBoundary &other)
	copy constructor More...
void	set (Vec3D normal, Mdouble distanceLeft, Mdouble distanceRight, std::function< Vec3D(Mdouble)> planewiseShift, std::function< Vec3D(Mdouble)> boost)
	Defines a TimeDependentPeriodicBoundary by its normal and positions, and by the shifting and boosting that it does (projected onto the planewise direction) More...
void	set (Vec3D normal, Vec3D positionLeft, Vec3D positionRight, std::function< Vec3D(Mdouble)> shift, std::function< Vec3D(Mdouble)> boost)
	As above, but by specifying two positions that the boundaries go through instead of distanceLeft and distanceRight. More...
void	setPlanewiseShiftAndBoost (std::function< Vec3D(Mdouble)> shift, std::function< Vec3D(Mdouble)> boost)
	Set the planewise shift and boost (projected onto the planewise direction) as functions of time. (Boost should be the derivative of shift) More...
void	setMaxShift (Mdouble maxShift)
	Set the maximum shift (will take fmod w.r.t. this) More...
Vec3D	getNormal () const
	returns the vector normal to the periodic boundary More...
Mdouble	getDistanceLeft () const
	Returns the distance of the left wall to the origin, in normal direction. More...
Mdouble	getDistanceRight () const
	Returns the distance of the right wall to the origin, in normal direction. More...
Vec3D	getShift (Mdouble time) const
	Returns the vector going from the left to the right side of the periodic boundary. More...
Vec3D	getPlanewiseShift (Mdouble time) const
	Returns the planewise shift as a function of time. More...
Vec3D	getBoost (Mdouble time) const
	Returns the planewise boost as a function of time. More...
void	moveLeft (Mdouble distanceLeft)
	Sets the distance from the origin of the 'left' periodic wall. More...
void	moveRight (Mdouble distanceRight)
	Sets the distance from the origin of the 'right' periodic wall. More...
Mdouble	getDistance (const BaseParticle &p) const override
	Returns the distance of the edge to the particle. More...
Mdouble	getDistance (const Vec3D &position) const override
	Returns the distance of the edge to the position. More...
virtual void	shiftPosition (BaseParticle *p) const override
	shifts and boosts the particle More...
virtual void	shiftAndBoostParticle (BaseParticle *p, Mdouble time) const
virtual void	shiftPositions (Vec3D &position1, Vec3D &position2) const
	shifts two positions (JMFT: Why, what is this for?) More...
virtual bool	isClosestToLeftBoundary (const BaseParticle &p) const
	Returns true if particle checked is closer to the 'left' edge, and false if it is closer to the 'right' edge. More...
virtual bool	isClosestToLeftBoundary (const Vec3D &p) const override
	Returns true if position checked is closer to the 'left' edge, and false if it is closer to the 'right' edge. More...
virtual void	createPeriodicParticles (ParticleHandler &pH) override
	Checks distance of particle to closer edge and creates a periodic copy if necessary. More...
void	createGhostParticle (BaseParticle *pReal)
	Creates and adds a ghost particle from a given real particle. More...
void	createPeriodicParticle (BaseParticle *p, ParticleHandler &pH) override
	Creates a single periodic particle if required from a given particle. More...
virtual void	checkBoundaryAfterParticlesMove (ParticleHandler &pH) override
	Loops over particles, checks if each particle has crossed either boundary edge, and applies a shift if that is the case. More...
virtual void	read (std::istream &is) override
	reads boundary properties from istream More...
virtual void	write (std::ostream &os) const override
	writes boundary properties to ostream More...
virtual std::string	getName () const override
	Returns the name of the object. More...
Public Member Functions inherited from BasePeriodicBoundary
	BasePeriodicBoundary ()
	default constructor. More...
	BasePeriodicBoundary (const BasePeriodicBoundary &b)
	copy constructor More...
	~BasePeriodicBoundary () override
	destructor More...
void	setPeriodicHandler (PeriodicBoundaryHandler *periodicHandler)
	Sets the periodicBoundaryHandler, required for parallel periodic boundaries. More...
PeriodicBoundaryHandler *	getPeriodicHandler () const
	Returns the periodic boundary handler. More...
void	createPeriodicParticles (ParticleHandler &pH) override
	Creates periodic ocpies of given particle in case of periodic boundaries in serial build. More...
virtual void	modifyPeriodicComplexity (std::vector< int > &complexity, int &totalPeriodicComplexity, BaseParticle *particle, int i) const
	Modifies periodic complexity of a particle if necessary (i.e. maser boundary) More...
virtual void	performActionsBeforeAddingParticles ()
	Actions that need to be performed before adding new ghost particles. More...
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

Protected Attributes
Vec3D	normal_
	outward unit normal vector for right edge More...
Mdouble	distanceLeft_
	position of left edge, s.t. normal*x = distanceLeft_ More...
Mdouble	distanceRight_
	position of right edge, s.t. normal*x = distanceRight_ More...
std::function< Vec3D(Mdouble)>	planewiseShift_
	shift from left to right boundary in the planewise direction (Note: total shift = planewiseShift_(time) + normal * (distanceRight_ - distanceLeft_) More...
std::function< Vec3D(Mdouble)>	boost_
	boost from the left to right boundary More...
Mdouble	maxShift_
	Maximum shifting (will take fmod(shift, maxshift) ) More...

Detailed Description

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

A TimeDependentPeriodicBoundary is like a PeriodicBoundary, but, when a particle crosses an edge,

• it is shifted as well as being copied
• it is given a boost

In general, the shift and the boost may depend on time in an arbitrary way. They are to be specified as std::function<Mdouble (Mdouble)>.

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

TimeDependentPeriodicBoundary() [1/2]

TimeDependentPeriodicBoundary::TimeDependentPeriodicBoundary

(

)

default constructor

constructor

        : BasePeriodicBoundary()
{
    distanceLeft_ = std::numeric_limits<double>::quiet_NaN();
    distanceRight_ = std::numeric_limits<double>::quiet_NaN();
    maxShift_ = 0;
 
 
#ifdef MERCURYDPM_USE_MPI
    MPIContainer& communicator = MPIContainer::Instance();
    if (communicator.getNumberOfProcessors() > 1)
    {
        logger(WARN,"LeesEdwardsBoundaries are currently not implemented in parallel MercuryDPM");
    }
#endif
    logger(DEBUG, "TimeDependentPeriodicBoundary::TimeDependentPeriodicBoundary() finished");
}

References DEBUG, distanceLeft_, distanceRight_, MPIContainer::getNumberOfProcessors(), MPIContainer::Instance(), logger, maxShift_, and WARN.

Referenced by copy().

~TimeDependentPeriodicBoundary()

TimeDependentPeriodicBoundary::~TimeDependentPeriodicBoundary

(

)

destructor

destructor

{
    logger(DEBUG, "TimeDependentPeriodicBoundary::~TimeDependentPeriodicBoundary() finished");
}

References DEBUG, and logger.

TimeDependentPeriodicBoundary() [2/2]

TimeDependentPeriodicBoundary::TimeDependentPeriodicBoundary

(

const TimeDependentPeriodicBoundary &

other

)

copy constructor

Copy constructor

{
    normal_ = other.normal_;
    distanceLeft_ = other.distanceLeft_;
    distanceRight_ = other.distanceRight_;
    planewiseShift_ = other.planewiseShift_;
    boost_ = other.boost_;
    maxShift_ = other.maxShift_;
 
}

References boost_, distanceLeft_, distanceRight_, maxShift_, normal_, and planewiseShift_.

Member Function Documentation

checkBoundaryAfterParticlesMove()

void TimeDependentPeriodicBoundary::checkBoundaryAfterParticlesMove ( ParticleHandler &  pH )

overridevirtual

Loops over particles, checks if each particle has crossed either boundary edge, and applies a shift if that is the case.

Loops through all particles to see if they have become ghosts. If that is the case their position is shifted. Note: This is only for a serial build - periodic particles work different in paralle

Parameters

[in]

Reimplemented from BasePeriodicBoundary.

{
#ifdef MERCURYDPM_USE_MPI
    if (NUMBER_OF_PROCESSORS == 1)
    {
#endif
        for (auto p = pH.begin(); p != pH.end(); ++p)
        {
            if (getDistance((*p)->getPosition()) < 0)
            {
                shiftAndBoostParticle(*p, pH.getDPMBase()->getTime());
            }
        }
#ifdef MERCURYDPM_USE_MPI
    }
#endif
}

References BaseHandler< T >::begin(), BaseHandler< T >::end(), getDistance(), BaseHandler< T >::getDPMBase(), DPMBase::getTime(), NUMBER_OF_PROCESSORS, p, and shiftAndBoostParticle().

copy()

TimeDependentPeriodicBoundary * TimeDependentPeriodicBoundary::copy ( ) const

overridevirtual

copy method

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

Implements BasePeriodicBoundary.

{
    return new TimeDependentPeriodicBoundary(*this);
}

References TimeDependentPeriodicBoundary().

createGhostParticle()

void TimeDependentPeriodicBoundary::createGhostParticle

(

BaseParticle *

pReal

)

Creates and adds a ghost particle from a given real particle.

Todo:

{JMFT: The time comes from p->getHandler()->getDPMBase()->getTime(), which will be undefined if p does not belong to a handler.}

{
    ParticleHandler& pH = getHandler()->getDPMBase()->particleHandler;
 
    //Step 1: Copy the particle to new ghost particle.
    BaseParticle* pGhost = pReal->copy();
 
    //Step 2: Copy the interactions of the ghost particle.
    pGhost->copyInteractionsForPeriodicParticles(*pReal);
 
    //Step 3: Shift the ghost to the 'reflected' location.
    shiftAndBoostParticle(pGhost, pH.getDPMBase()->getTime());
 
    //Step 4: If Particle is double shifted, get correct original particle
    BaseParticle* from = pReal;
    while (from->getPeriodicFromParticle() != nullptr)
        from = from->getPeriodicFromParticle();
    pGhost->setPeriodicFromParticle(from);
 
    pH.addObject(pGhost);
}

References ParticleHandler::addObject(), BaseParticle::copy(), BaseInteractable::copyInteractionsForPeriodicParticles(), BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), BaseParticle::getPeriodicFromParticle(), DPMBase::getTime(), DPMBase::particleHandler, BaseParticle::setPeriodicFromParticle(), and shiftAndBoostParticle().

Referenced by createPeriodicParticle().

createPeriodicParticle()

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

override

Creates a single periodic particle if required from a given particle.

{
    //note that getDistance sets closestToLeftBoundary_ to true or false depending on which side is closest
    if (getDistance(*p) < p->getMaxInteractionRadius() + pH.getLargestParticle()->getMaxInteractionRadius())
    {
        createGhostParticle(p);
    }
}

References createGhostParticle(), getDistance(), ParticleHandler::getLargestParticle(), BaseParticle::getMaxInteractionRadius(), and p.

Referenced by createPeriodicParticles().

createPeriodicParticles()

void TimeDependentPeriodicBoundary::createPeriodicParticles ( ParticleHandler &  pH )

overridevirtual

Checks distance of particle to closer edge and creates a periodic copy if necessary.

{
#ifdef MERCURYDPM_USE_MPI
    if (NUMBER_OF_PROCESSORS == 1)
    {
#endif
        unsigned numberOfParticles = pH.getSize();
 
        for(unsigned i = 0; i < numberOfParticles; i++)
        {
            createPeriodicParticle(pH.getObject(i),pH);
        }
#ifdef MERCURYDPM_USE_MPI
    }
#endif
}

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

getBoost()

Vec3D TimeDependentPeriodicBoundary::getBoost

(

Mdouble

time

)

const

Returns the planewise boost as a function of time.

{
    return boost_(time);
}

References boost_.

Referenced by shiftAndBoostParticle().

getDistance() [1/2]

Mdouble TimeDependentPeriodicBoundary::getDistance ( const BaseParticle &  p ) const

overridevirtual

Returns the distance of the edge to the particle.

Implements BasePeriodicBoundary.

{
    return getDistance(p.getPosition());
}

References p.

Referenced by checkBoundaryAfterParticlesMove(), and createPeriodicParticle().

getDistance() [2/2]

Mdouble TimeDependentPeriodicBoundary::getDistance ( const Vec3D &  position ) const

overridevirtual

Returns the distance of the edge to the position.

Returns the distance to the edge closest to the position

Parameters

[in]

position

A reference to the position which distance to the periodic boundary is to be calculated

Implements BasePeriodicBoundary.

{
    Mdouble distanceFromPlaneThroughOrigin = Vec3D::dot(position, normal_);
    return std::min(distanceFromPlaneThroughOrigin - distanceLeft_, 
                    distanceRight_ - distanceFromPlaneThroughOrigin);
}

References distanceLeft_, distanceRight_, Vec3D::dot(), min, and normal_.

getDistanceLeft()

Mdouble TimeDependentPeriodicBoundary::getDistanceLeft

(

)

const

Returns the distance of the left wall to the origin, in normal direction.

Returns

The distance of the left wall to the origin, in normal direction

{
    return distanceLeft_;
}

References distanceLeft_.

getDistanceRight()

Mdouble TimeDependentPeriodicBoundary::getDistanceRight

(

)

const

Returns the distance of the right wall to the origin, in normal direction.

Returns

The distance of the left wall to the origin, in normal direction

{
    return distanceRight_;
}

References distanceRight_.

getName()

std::string TimeDependentPeriodicBoundary::getName ( ) const

overridevirtual

Returns the name of the object.

Returns the name of the object class

Returns

the object's class' name, i.e. 'CubeInsertionBoundary'

Implements BaseObject.

{
    return "TimeDependentPeriodicBoundary";
}

getNormal()

Vec3D TimeDependentPeriodicBoundary::getNormal

(

)

const

returns the vector normal to the periodic boundary

Returns

The vector perpendicular to the periodic boundary

{
    return normal_;
}

References normal_.

getPlanewiseShift()

Vec3D TimeDependentPeriodicBoundary::getPlanewiseShift

(

Mdouble

time

)

const

Returns the planewise shift as a function of time.

{
    if (maxShift_ == 0)
        return planewiseShift_(time);
    if (maxShift_ > 0)
    {
        Vec3D p = planewiseShift_(time);
        Mdouble m = p.getLength();
        Vec3D n = p / m;
        return fmod(m, maxShift_) * n;
    }
    if (maxShift_ < 0)
        logger(ERROR, "[TimeDependentPeriodicBoundary::getPlanewiseShift] maxShift_ = % is negative", maxShift_);
    return {0,0,0};
}

References ERROR, Eigen::bfloat16_impl::fmod(), logger, m, maxShift_, n, p, and planewiseShift_.

Referenced by getShift().

getShift()

Vec3D TimeDependentPeriodicBoundary::getShift

(

Mdouble

time

)

const

Returns the vector going from the left to the right side of the periodic boundary.

{
    return getPlanewiseShift(time) + normal_ * (distanceRight_ - distanceLeft_);
}

References distanceLeft_, distanceRight_, getPlanewiseShift(), and normal_.

Referenced by shiftAndBoostParticle(), and shiftPositions().

isClosestToLeftBoundary() [1/2]

bool TimeDependentPeriodicBoundary::isClosestToLeftBoundary ( const BaseParticle &  p ) const

virtual

Returns true if particle checked is closer to the 'left' edge, and false if it is closer to the 'right' edge.

{
    return isClosestToLeftBoundary(p.getPosition());
}

References p.

Referenced by shiftAndBoostParticle(), and shiftPositions().

isClosestToLeftBoundary() [2/2]

bool TimeDependentPeriodicBoundary::isClosestToLeftBoundary ( const Vec3D &  p ) const

overridevirtual

Returns true if position checked is closer to the 'left' edge, and false if it is closer to the 'right' edge.

Implements BasePeriodicBoundary.

{
    const Mdouble distance = Vec3D::dot(p, normal_);
    return (distanceRight_ - distance > distance - distanceLeft_);
}

References distanceLeft_, distanceRight_, Vec3D::dot(), normal_, and p.

moveLeft()

void TimeDependentPeriodicBoundary::moveLeft

(

Mdouble

distanceLeft

)

Sets the distance from the origin of the 'left' periodic wall.

Allows the left periodic boundary to be moved to a new position and automatically changes its shift value

Parameters

[in]

distanceLeft

The distance (from the origin) to which the left boundary is moved

{
    distanceLeft_ = distanceLeft;
}

References distanceLeft_.

moveRight()

void TimeDependentPeriodicBoundary::moveRight

(

Mdouble

distanceRight

)

Sets the distance from the origin of the 'right' periodic wall.

Allows the right periodic wall to be moved to a new position and automatically changes its shift value

Parameters

[in]

distanceRight

The distance (from the origin) to which the right boundary is moved

{
    distanceRight_ = distanceRight;
}

References distanceRight_.

read()

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

overridevirtual

reads boundary properties from istream

Reads the boundary properties from an istream

Parameters

[in]

is

the istream

Reimplemented from BasePeriodicBoundary.

{
    BasePeriodicBoundary::read(is);
    std::string dummy;
    is >> dummy >> normal_
       >> dummy >> distanceLeft_
       >> dummy >> distanceRight_
      // >> dummy >> planewiseShift_
      // >> dummy >> boost_
      ;
}

References distanceLeft_, distanceRight_, normal_, BasePeriodicBoundary::read(), and oomph::Global_string_for_annotation::string().

set() [1/2]

void TimeDependentPeriodicBoundary::set	(	Vec3D	normal,
		Mdouble	distanceLeft,
		Mdouble	distanceRight,
		std::function< Vec3D(Mdouble)>	planewiseShift,
		std::function< Vec3D(Mdouble)>	boost
	)

Defines a TimeDependentPeriodicBoundary by its normal and positions, and by the shifting and boosting that it does (projected onto the planewise direction)

Parameters

[in]	normal	Vector specifying the normal direction of the edges
[in]	distanceLeft	Position of the first edge
[in]	distanceRight	Position of the second edge
[in]	shift	Vector (projected to remove normal component) by which particles crossing an edge are to be shifted, as a function of time.
[in]	boost	Vector (projected to remove normal component) by which particles crossing an edge are to be boosted, as a function of time.

{
    normal_ = normal;
    distanceLeft_ = distanceLeft, 
    distanceRight_ = distanceRight, 
    planewiseShift_ = planewiseShift;
    boost_ = boost;
    maxShift_ = constants::inf;
}

References boost_, distanceLeft_, distanceRight_, constants::inf, maxShift_, WallFunction::normal(), normal_, and planewiseShift_.

set() [2/2]

void TimeDependentPeriodicBoundary::set	(	Vec3D	normal,
		Vec3D	positionLeft,
		Vec3D	positionRight,
		std::function< Vec3D(Mdouble)>	shift,
		std::function< Vec3D(Mdouble)>	boost
	)

As above, but by specifying two positions that the boundaries go through instead of distanceLeft and distanceRight.

{
    set(normal, Vec3D::dot(positionLeft,normal), Vec3D::dot(positionRight,normal), 
            planewiseShift, boost);
}

References Vec3D::dot(), WallFunction::normal(), and set().

Referenced by set().

setMaxShift()

void TimeDependentPeriodicBoundary::setMaxShift

(

Mdouble

maxShift

)

Set the maximum shift (will take fmod w.r.t. this)

{
    maxShift_ = maxShift;
}

References maxShift_.

setPlanewiseShiftAndBoost()

void TimeDependentPeriodicBoundary::setPlanewiseShiftAndBoost	(	std::function< Vec3D(Mdouble)>	shift,
		std::function< Vec3D(Mdouble)>	boost
	)

Set the planewise shift and boost (projected onto the planewise direction) as functions of time. (Boost should be the derivative of shift)

{
    planewiseShift_ = planewiseShift;
    boost_ = boost;
}

References boost_, and planewiseShift_.

shiftAndBoostParticle()

void TimeDependentPeriodicBoundary::shiftAndBoostParticle ( BaseParticle *  p, Mdouble  time  ) const

virtual

{
    if (isClosestToLeftBoundary(*p))
    {
        p->move(getShift(time));
        p->addVelocity(getBoost(time));
    }
    else
    {
        p->move(-getShift(time));
        p->addVelocity(-getBoost(time));
    }
}

References getBoost(), getShift(), isClosestToLeftBoundary(), and p.

Referenced by checkBoundaryAfterParticlesMove(), and createGhostParticle().

shiftPosition()

void TimeDependentPeriodicBoundary::shiftPosition ( BaseParticle *  p ) const

overridevirtual

shifts and boosts the particle

Parameters

[in]

p

A pointer to the particle which will be shifted and boosted.

Todo:

{JMFT: The time comes from p->getHandler()->getDPMBase()->getTime(), which will be undefined if p does not belong to a handler.}

Shouldn't be used for TimeDependentPeriodicBoundary. Instead, use TimeDependentPeriodicBoundary::shiftandBoostParticle.

Implements BasePeriodicBoundary.

{
}

shiftPositions()

void TimeDependentPeriodicBoundary::shiftPositions ( Vec3D &  position1, Vec3D &  position2  ) const

virtual

shifts two positions (JMFT: Why, what is this for?)

{
    if (isClosestToLeftBoundary(position1))
    {
        position1 += getShift(0); // TODO JMFT: ?!?!?!
        position2 += getShift(0); 
    }
    else
    {
        position1 -= getShift(0);
        position2 -= getShift(0);
    }
}

References getShift(), and isClosestToLeftBoundary().

write()

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

overridevirtual

writes boundary properties to ostream

Writes boundary's properties to an ostream

Parameters

[in]

os

the ostream

Reimplemented from BasePeriodicBoundary.

{
    BasePeriodicBoundary::write(os);
    os << " normal " << normal_
       << " distanceLeft " << distanceLeft_
       << " distanceRight " << distanceRight_
       // << " planewiseShift " << planewiseShift_ 
       // << " boost " << boost_
       ;
}

References distanceLeft_, distanceRight_, normal_, and BasePeriodicBoundary::write().

Member Data Documentation

boost_

std::function<Vec3D (Mdouble)> TimeDependentPeriodicBoundary::boost_

protected

boost from the left to right boundary

Referenced by getBoost(), set(), setPlanewiseShiftAndBoost(), and TimeDependentPeriodicBoundary().

distanceLeft_

Mdouble TimeDependentPeriodicBoundary::distanceLeft_

protected

position of left edge, s.t. normal*x = distanceLeft_

Referenced by getDistance(), getDistanceLeft(), getShift(), isClosestToLeftBoundary(), moveLeft(), read(), set(), TimeDependentPeriodicBoundary(), and write().

distanceRight_

Mdouble TimeDependentPeriodicBoundary::distanceRight_

protected

position of right edge, s.t. normal*x = distanceRight_

Referenced by getDistance(), getDistanceRight(), getShift(), isClosestToLeftBoundary(), moveRight(), read(), set(), TimeDependentPeriodicBoundary(), and write().

maxShift_

Mdouble TimeDependentPeriodicBoundary::maxShift_

protected

Maximum shifting (will take fmod(shift, maxshift) )

Referenced by getPlanewiseShift(), set(), setMaxShift(), and TimeDependentPeriodicBoundary().

normal_

Vec3D TimeDependentPeriodicBoundary::normal_

protected

outward unit normal vector for right edge

Referenced by getDistance(), getNormal(), getShift(), isClosestToLeftBoundary(), read(), set(), TimeDependentPeriodicBoundary(), and write().

planewiseShift_

std::function<Vec3D (Mdouble)> TimeDependentPeriodicBoundary::planewiseShift_

protected

shift from left to right boundary in the planewise direction (Note: total shift = planewiseShift_(time) + normal * (distanceRight_ - distanceLeft_)

Referenced by getPlanewiseShift(), set(), setPlanewiseShiftAndBoost(), and TimeDependentPeriodicBoundary().

---

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

• TimeDependentPeriodicBoundary.h
• TimeDependentPeriodicBoundary.cc