AngledPeriodicBoundary Class Reference

#include <AngledPeriodicBoundary.h>

Inheritance diagram for AngledPeriodicBoundary:

Public Member Functions
AngledPeriodicBoundary *	copy () const final
	Used to create a copy of the object NB: purely virtual function. More...
void	set (Vec3D normalLeft, Vec3D normalRight, Vec3D origin)
	Defines a periodic wall. More...
Mdouble	distance (const BaseParticle &P)
	Returns the distance of the wall to the particle and sets left_wall = true, if the left wall is the wall closest to the particle. More...
Mdouble	distance (const Vec3D &P)
void	shiftPosition (BaseParticle *P)
	shifts the particle (after distance set the left_wall value) More...
void	shiftPositions (Vec3D &P1, Vec3D &P2)
	only needed in StatisticsVector More...
void	read (std::istream &is) override
	reads wall More...
void	oldRead (std::istream &is)
void	write (std::ostream &os) const override
	outputs wall More...
std::string	getName () const override
	Returns the name of the object. More...
Vec3D &	getNormal ()
Mdouble	getOpeningAngle ()
	angle between walls in radians More...
void	createPeriodicParticle (BaseParticle *p, ParticleHandler &pH) override
void	createPeriodicParticles (ParticleHandler &pH) override
void	checkBoundaryAfterParticleMoved (BaseParticle *P)
void	checkBoundaryAfterParticlesMove (ParticleHandler &pH) override
	Virtual function that does things to particles, each time step after particles have moved. 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

Private Attributes
Vec3D	leftNormal_
Vec3D	rightNormal_
	outward unit normal vector for right wall More...
Vec3D	origin_
	common point of both walls More...
bool	leftWall_
	true if closest wall is the left wall More...
Vec3D	leftRadialAxis_
	outward unit normal vector for left wall More...
Vec3D	rightRadialAxis_
	outward unit normal vector for right wall More...
Vec3D	differenceRadialAxis_
Vec3D	differenceNormal_
Matrix3D	rotateLeft
Matrix3D	rotateRight
Vec3D	commonAxis_
	The normalized cross product of the left and right normal vector. This vector points in the direction around which the particle is rotated when it is moved from one boundary to the other. This is an internal variable set in the constructor, thus cannot be changed directly by the user. More...

Member Function Documentation

checkBoundaryAfterParticleMoved()

void AngledPeriodicBoundary::checkBoundaryAfterParticleMoved

(

BaseParticle *

P

)

Todo:

TW: can't we do the shift in the createPeriodicParticles function only? We are checking the distance three times!

{
    if (distance(*P) < 0)
    {
        shiftPosition(P);
    }
}

References distance(), Global_Physical_Variables::P, and shiftPosition().

Referenced by checkBoundaryAfterParticlesMove().

checkBoundaryAfterParticlesMove()

void AngledPeriodicBoundary::checkBoundaryAfterParticlesMove ( ParticleHandler &  pH )

overridevirtual

Virtual function that does things to particles, each time step after particles have moved.

checks whether given particle passed the boundary, and if so, does something special with it. This is called after the particles moved, but before the force-computation. NB: virtual function

Parameters

[in]	P	Particle checked
[out]	pH	the particle handler.

Returns

returns TRUE if given particle actually did pass the boundary

Reimplemented from BaseBoundary.

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

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

copy()

AngledPeriodicBoundary * AngledPeriodicBoundary::copy ( ) const

finalvirtual

Used to create a copy of the object NB: purely virtual function.

Implements BaseBoundary.

{
#ifdef DEBUG_CONSTRUCTOR
    std::cout << "AngledPeriodicBoundary::copy() const finished" << std::endl;
#endif
    return new AngledPeriodicBoundary(*this);
#ifdef MERCURYDPM_USE_MPI
    MPIContainer& communicator = MPIContainer::Instance();
    if (communicator.getNumberOfProcessors() > 1)
    {
        logger(WARN,"AngledPeriodicBoundaries are currently not implemented in parallel MercuryDPM");
    }
#endif
    
}

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

createPeriodicParticle()

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

override

{
    const Mdouble maxDistance = p->getMaxInteractionRadius() + pH.getLargestParticle()->getMaxInteractionRadius();
    if (distance(*p) < maxDistance)
    {
        //std::cout << "Copy particle " << p->getIndex() << " to new ghost particle" << std::endl;
        //Step 1: Copy the particle to new ghost particle.
        BaseParticle* pGhost = p->copy();
        
        //std::cout << "pGhostInteractions " << pGhost->getInteractions().size();
        //Step 2: Copy the interactions to the ghost particle.
        pGhost->copyInteractionsForPeriodicParticles(*p);
        //std::cout << "-> " << pGhost->getInteractions().size() << std::endl;
        
        //Step 3: Shift the ghost to the 'reflected' location.
        shiftPosition(pGhost);
        //rotateHistory
        //std::cout << "pGhostPosition " << pGhost->getPosition() << std::endl;
        
        //        BaseParticle* F0 = P->copy();
        //        shiftPosition(F0);
        
        //Step 4: If Particle is double shifted, get correct original particle
        BaseParticle* from = p;
        while (from->getPeriodicFromParticle() != nullptr)
            from = from->getPeriodicFromParticle();
        pGhost->setPeriodicFromParticle(from);
        
        pH.addObject(pGhost);
    }
}

References ParticleHandler::addObject(), BaseParticle::copy(), BaseInteractable::copyInteractionsForPeriodicParticles(), distance(), ParticleHandler::getLargestParticle(), BaseParticle::getMaxInteractionRadius(), BaseParticle::getPeriodicFromParticle(), BaseParticle::setPeriodicFromParticle(), and shiftPosition().

Referenced by createPeriodicParticles().

createPeriodicParticles()

void AngledPeriodicBoundary::createPeriodicParticles ( ParticleHandler &  pH )

override

{
    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 constants::i.

distance() [1/2]

Mdouble AngledPeriodicBoundary::distance

(

const BaseParticle &

P

)

Returns the distance of the wall to the particle and sets left_wall = true, if the left wall is the wall closest to the particle.

Since this function should be called before calculating any Particle-Wall interactions, it can also be used to set the shift vector in case of curved walls.

{
    return distance(P.getPosition());
}

References Global_Physical_Variables::P.

Referenced by checkBoundaryAfterParticleMoved(), and createPeriodicParticle().

distance() [2/2]

Mdouble AngledPeriodicBoundary::distance

(

const Vec3D &

P

)

{
    Vec3D position = P - origin_;
    Mdouble distance_left = Vec3D::dot(position, leftNormal_);
    Mdouble distance_right = -Vec3D::dot(position, rightNormal_);
    
    if (distance_left < distance_right)
    {
        leftWall_ = true;
        //std::cout << "left wall, " << position << ", distance " << distance_left << "<" << distance_right << std::endl;
        return distance_left;
    }
    else
    {
        leftWall_ = false;
        //std::cout << "right wall, " << position << ", distance " << distance_right << "<" << distance_left << std::endl;
        return distance_right;
    }
}

References Vec3D::dot(), leftNormal_, leftWall_, origin_, Global_Physical_Variables::P, and rightNormal_.

getName()

std::string AngledPeriodicBoundary::getName ( ) const

overridevirtual

Returns the name of the object.

Implements BaseObject.

{
    return "AngledPeriodicBoundary";
}

getNormal()

Vec3D & AngledPeriodicBoundary::getNormal

(

)

{
    if (leftWall_)
        return leftNormal_;
    else
        return rightNormal_;
}

References leftNormal_, leftWall_, and rightNormal_.

getOpeningAngle()

Mdouble AngledPeriodicBoundary::getOpeningAngle

(

)

angle between walls in radians

{
    return acos(Vec3D::dot(leftNormal_, rightNormal_));
}

References Vec3D::dot(), leftNormal_, and rightNormal_.

oldRead()

void AngledPeriodicBoundary::oldRead

(

std::istream &

is

)

{
    std::string dummy;
    is >> dummy >> leftNormal_ >> dummy >> rightNormal_ >> dummy >> origin_;
    set(leftNormal_, rightNormal_, origin_);
}

References leftNormal_, origin_, rightNormal_, and set().

read()

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

overridevirtual

reads wall

Implements BaseBoundary.

{
    BaseBoundary::read(is);
    std::string dummy;
    is >> dummy >> leftNormal_ >> dummy >> rightNormal_ >> dummy >> origin_;
    set(leftNormal_, rightNormal_, origin_);
}

References leftNormal_, origin_, BaseBoundary::read(), rightNormal_, and set().

set()

void AngledPeriodicBoundary::set	(	Vec3D	normalLeft,
		Vec3D	normalRight,
		Vec3D	origin
	)

Defines a periodic wall.

given a normal vector s.t. all particles are within {x: position_left<=normal*x<position_right}. The shift vector is set assuming that the domain is rectangular (shift parallel to normal).

Parameters

[in]	normalLeft
[in]	normalRight
[in]	origin

Todo:

TW: Note, I cannot calculate angular shift; this needs to be revisited when we complete quaternion implementation

{
    origin_ = origin;
    leftNormal_ = normalLeft / Vec3D::getLength(normalLeft);
    rightNormal_ = normalRight / Vec3D::getLength(normalRight);
    //http://math.stackexchange.com/questions/180418/calculate-rotation-matrix-to-align-vector-a-to-vector-b-in-3d
    Vec3D v = Vec3D::cross(leftNormal_, rightNormal_);
    Mdouble s = Vec3D::getLength(v);
    Mdouble c = Vec3D::dot(leftNormal_, rightNormal_);
    Matrix3D vx = {0, -v.Z, v.Y,
                   v.Z, 0, -v.X,
                   -v.Y, v.X, 0};
    Matrix3D eye = {1, 0, 0, 0, 1, 0, 0, 0, 1};
    rotateLeft = eye - vx + vx * vx * ((1 - c) / s / s);
    rotateRight = eye + vx + vx * vx * ((1 - c) / s / s);
    //std::cout << "rotationMatrix" << rotationMatrix << std::endl; 
    commonAxis_ = v / s;
    leftRadialAxis_ = Vec3D::cross(leftNormal_, commonAxis_);
    rightRadialAxis_ = Vec3D::cross(rightNormal_, commonAxis_);
    differenceNormal_ = rightNormal_ - leftNormal_;
    differenceRadialAxis_ = rightRadialAxis_ - leftRadialAxis_;
    // walls; maybe this has to wait till quaternions are implemented.}
    //angularShift = 0;
    // std::cout << "common_axis " << common_axis
    // << ", radialAxis_left " << radialAxis_left
    // << ", radialAxis_right " << radialAxis_right
    // << ", angularShift " << angularShift
    // << std::endl; 
}

References commonAxis_, Vec3D::cross(), differenceNormal_, differenceRadialAxis_, Vec3D::dot(), Vec3D::getLength(), leftNormal_, leftRadialAxis_, origin_, rightNormal_, rightRadialAxis_, rotateLeft, rotateRight, Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by AngledPeriodicBoundarySecondUnitTest::AngledPeriodicBoundarySecondUnitTest(), AngledPeriodicBoundaryUnitTest::AngledPeriodicBoundaryUnitTest(), oldRead(), read(), and FullRestartTest::setupInitialConditions().

shiftPosition()

void AngledPeriodicBoundary::shiftPosition

(

BaseParticle *

P

)

shifts the particle (after distance set the left_wall value)

Todo:

add velocity, angular, springs shift

Todo:

TW: not sure how to calculate the angular position in common_axis direction; this needs to be revisited when we complete quaternion implementation

Todo:

TW: recalculate the orientation here

{
    Vec3D position = P->getPosition() - origin_;
    if (leftWall_)
    {
        Mdouble normalDistance = Vec3D::dot(position, leftNormal_);
        Mdouble radialDistance = Vec3D::dot(position, leftRadialAxis_);
        P->move(normalDistance * differenceNormal_ + radialDistance * differenceRadialAxis_);
        Mdouble normalVelocity = Vec3D::dot(P->getVelocity(), leftNormal_);
        Mdouble radialVelocity = Vec3D::dot(P->getVelocity(), leftRadialAxis_);
        P->accelerate(normalVelocity * differenceNormal_ + radialVelocity * differenceRadialAxis_);
        Mdouble normalAngularDistance = Vec3D::dot(P->getOrientation().getAxis(), leftNormal_);
        Mdouble radialAngularDistance = Vec3D::dot(P->getOrientation().getAxis(), leftRadialAxis_);
        P->rotate(normalAngularDistance * differenceNormal_ + radialAngularDistance * differenceRadialAxis_);
        Mdouble normalAngularVelocity = Vec3D::dot(P->getAngularVelocity(), leftNormal_);
        Mdouble radialAngularVelocity = Vec3D::dot(P->getAngularVelocity(), leftRadialAxis_);
        P->angularAccelerate(normalAngularVelocity * differenceNormal_ + radialAngularVelocity * differenceRadialAxis_);
        leftWall_ = false;
        //std::cout << "shift to right wall, " << P->getInteractions().size() << std::endl;
        for (BaseInteraction* i : P->getInteractions())
        {
            if (i->getP()->getIndex() >= P->getIndex())
            {
                i->rotateHistory(rotateRight);
            }
        }
    }
    else
    {
        Mdouble normalDistance = Vec3D::dot(position, rightNormal_);
        Mdouble radialDistance = Vec3D::dot(position, rightRadialAxis_);
        P->move(-normalDistance * differenceNormal_ - radialDistance * differenceRadialAxis_);
        Mdouble normalVelocity = Vec3D::dot(P->getVelocity(), rightNormal_);
        Mdouble radialVelocity = Vec3D::dot(P->getVelocity(), rightRadialAxis_);
        P->accelerate(-normalVelocity * differenceNormal_ - radialVelocity * differenceRadialAxis_);
        
        
        Mdouble normalAngularVelocity = Vec3D::dot(P->getAngularVelocity(), rightNormal_);
        Mdouble radialAngularVelocity = Vec3D::dot(P->getAngularVelocity(), rightRadialAxis_);
        P->angularAccelerate(
                -normalAngularVelocity * differenceNormal_ - radialAngularVelocity * differenceRadialAxis_);
        leftWall_ = true;
        //std::cout << "shift to left wall, " << P->getPosition() << std::endl;
        for (BaseInteraction* i : P->getInteractions())
        {
            if (i->getP()->getIndex() >= P->getIndex()) //if it is the deleted interaction
            {
                i->rotateHistory(rotateLeft);
            }
        }
    }
}

References differenceNormal_, differenceRadialAxis_, Vec3D::dot(), constants::i, leftNormal_, leftRadialAxis_, leftWall_, origin_, Global_Physical_Variables::P, rightNormal_, rightRadialAxis_, rotateLeft, and rotateRight.

Referenced by checkBoundaryAfterParticleMoved(), and createPeriodicParticle().

shiftPositions()

void AngledPeriodicBoundary::shiftPositions	(	Vec3D &	P1,
		Vec3D &	P2
	)

only needed in StatisticsVector

Todo:

TW: this still doesn't shift all data

{
    Vec3D position1 = P1 - origin_;
    Vec3D position2 = P2 - origin_;
    Mdouble normalDistance;
    Mdouble radialDistance;
    if (leftWall_)
    {
        normalDistance = Vec3D::dot(position1, leftNormal_);
        radialDistance = Vec3D::dot(position1, leftRadialAxis_);
        P1 += (normalDistance * differenceNormal_ + radialDistance * differenceRadialAxis_);
        normalDistance = Vec3D::dot(position2, leftNormal_);
        radialDistance = Vec3D::dot(position2, leftRadialAxis_);
        P2 += (normalDistance * differenceNormal_ + radialDistance * differenceRadialAxis_);
        leftWall_ = false;
    }
    else
    {
        normalDistance = Vec3D::dot(position1, rightNormal_);
        radialDistance = Vec3D::dot(position1, rightRadialAxis_);
        P1 += (-normalDistance * differenceNormal_ - radialDistance * differenceRadialAxis_);
        normalDistance = Vec3D::dot(position2, rightNormal_);
        radialDistance = Vec3D::dot(position2, rightRadialAxis_);
        P2 += (-normalDistance * differenceNormal_ - radialDistance * differenceRadialAxis_);
        leftWall_ = true;
    }
}

References differenceNormal_, differenceRadialAxis_, Vec3D::dot(), leftNormal_, leftRadialAxis_, leftWall_, origin_, rightNormal_, and rightRadialAxis_.

write()

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

overridevirtual

outputs wall

Implements BaseBoundary.

{
    BaseBoundary::write(os);
    os << " normal_left " << leftNormal_
       << " normal_right " << rightNormal_
       << " origin " << origin_;
}

References leftNormal_, origin_, rightNormal_, and BaseBoundary::write().

Member Data Documentation

commonAxis_

Vec3D AngledPeriodicBoundary::commonAxis_

private

The normalized cross product of the left and right normal vector. This vector points in the direction around which the particle is rotated when it is moved from one boundary to the other. This is an internal variable set in the constructor, thus cannot be changed directly by the user.

Referenced by set().

differenceNormal_

Vec3D AngledPeriodicBoundary::differenceNormal_

private

Referenced by set(), shiftPosition(), and shiftPositions().

differenceRadialAxis_

Vec3D AngledPeriodicBoundary::differenceRadialAxis_

private

Referenced by set(), shiftPosition(), and shiftPositions().

leftNormal_

Vec3D AngledPeriodicBoundary::leftNormal_

private

outward unit normal vector for left wall

Referenced by distance(), getNormal(), getOpeningAngle(), oldRead(), read(), set(), shiftPosition(), shiftPositions(), and write().

leftRadialAxis_

Vec3D AngledPeriodicBoundary::leftRadialAxis_

private

outward unit normal vector for left wall

Referenced by set(), shiftPosition(), and shiftPositions().

leftWall_

bool AngledPeriodicBoundary::leftWall_

private

true if closest wall is the left wall

Referenced by distance(), getNormal(), shiftPosition(), and shiftPositions().

origin_

Vec3D AngledPeriodicBoundary::origin_

private

common point of both walls

Referenced by distance(), oldRead(), read(), set(), shiftPosition(), shiftPositions(), and write().

rightNormal_

Vec3D AngledPeriodicBoundary::rightNormal_

private

outward unit normal vector for right wall

Referenced by distance(), getNormal(), getOpeningAngle(), oldRead(), read(), set(), shiftPosition(), shiftPositions(), and write().

rightRadialAxis_

Vec3D AngledPeriodicBoundary::rightRadialAxis_

private

outward unit normal vector for right wall

Referenced by set(), shiftPosition(), and shiftPositions().

rotateLeft

Matrix3D AngledPeriodicBoundary::rotateLeft

private

Referenced by set(), and shiftPosition().

rotateRight

Matrix3D AngledPeriodicBoundary::rotateRight

private

Referenced by set(), and shiftPosition().

---

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

• AngledPeriodicBoundary.h
• AngledPeriodicBoundary.cc