#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)
	reads wall More...

void	oldRead (std::istream &is)

void	write (std::ostream &os) const
	outputs wall More...

virtual std::string	getName () const
	Returns the name of the object. More...

Vec3D &	getNormal ()

Mdouble	getOpeningAngle ()
	angle between walls in radians More...

void	createPeriodicParticles (BaseParticle *P, ParticleHandler &pH)

bool	checkBoundaryAfterParticleMoved (BaseParticle *P, ParticleHandler &pH UNUSED)

Public Member Functions inherited from BaseBoundary
	BaseBoundary ()
	default constructor. More...

	BaseBoundary (const BaseBoundary &b)
	copy constructor More...

virtual	~BaseBoundary ()
	destructor More...

virtual void	createPeriodicParticles (BaseParticle *P UNUSED, ParticleHandler &pH UNUSED)
	Creates periodic copies of given particle in case of periodic boundaries. More...

virtual bool	checkBoundaryAfterParticleMoved (BaseParticle *P UNUSED, ParticleHandler &pH UNUSED)
	Checks if given particle passed the boundary. More...

virtual void	checkBoundaryBeforeTimeStep (DPMBase *md UNUSED)
	Fills a (3D) boundary with particles. More...

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 constructor. More...

	BaseObject (const BaseObject &p)
	Copy constructor, copies all the objects BaseObject contains. More...

virtual	~BaseObject ()
	virtual destructor More...

virtual void	moveInHandler (const unsigned int index)
	Except that it is virtual, it does the same thing as setIndex() does. More...

void	setIndex (const unsigned int index)
	Allows one to assign an index to an object in the handler/container. More...

void	setId (const unsigned int 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...

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...

Detailed Description

Definition at line 45 of file AngledPeriodicBoundary.h.

Member Function Documentation

bool AngledPeriodicBoundary::checkBoundaryAfterParticleMoved	(	BaseParticle *	P,
		ParticleHandler &pH	UNUSED
	)

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

Definition at line 297 of file AngledPeriodicBoundary.cc.

References distance(), and shiftPosition().

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

AngledPeriodicBoundary * AngledPeriodicBoundary::copy ( ) const

finalvirtual

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

Implements BaseBoundary.

Definition at line 34 of file AngledPeriodicBoundary.cc.

 {
 #ifdef DEBUG_CONSTRUCTOR
     std::cout << "AngledPeriodicBoundary::copy() const finished" << std::endl;
 #endif                
     return new AngledPeriodicBoundary(*this);
 }

void AngledPeriodicBoundary::createPeriodicParticles	(	BaseParticle *	P,
		ParticleHandler &	pH
	)

Definition at line 263 of file AngledPeriodicBoundary.cc.

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

 {
     if (distance(*p) < p->getInteractionRadius() + pH.getLargestParticle()->getInteractionRadius())
     {
         //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);
     }
 }

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.

Definition at line 84 of file AngledPeriodicBoundary.cc.

References BaseInteractable::getPosition().

Referenced by checkBoundaryAfterParticleMoved(), and createPeriodicParticles().

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

Mdouble AngledPeriodicBoundary::distance ( const Vec3D & P )

Definition at line 92 of file AngledPeriodicBoundary.cc.

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

 {
     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;
     }
 }

std::string AngledPeriodicBoundary::getName ( ) const

virtual

Returns the name of the object.

Implements BaseObject.

Definition at line 236 of file AngledPeriodicBoundary.cc.

 {
     return "AngledPeriodicBoundary";
 }

Vec3D & AngledPeriodicBoundary::getNormal ( )

Definition at line 244 of file AngledPeriodicBoundary.cc.

References leftNormal_, leftWall_, and rightNormal_.

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

Mdouble AngledPeriodicBoundary::getOpeningAngle ( )

angle between walls in radians

Definition at line 255 of file AngledPeriodicBoundary.cc.

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

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

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

Definition at line 215 of file AngledPeriodicBoundary.cc.

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

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

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

virtual

reads wall

Implements BaseBoundary.

Definition at line 204 of file AngledPeriodicBoundary.cc.

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

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

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

Definition at line 50 of file AngledPeriodicBoundary.cc.

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 oldRead(), and read().

 {
     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; 
 }

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

Definition at line 115 of file AngledPeriodicBoundary.cc.

References BaseParticle::accelerate(), BaseParticle::angularAccelerate(), differenceNormal_, differenceRadialAxis_, Vec3D::dot(), BaseInteractable::getAngularVelocity(), BaseObject::getIndex(), BaseInteractable::getInteractions(), BaseInteractable::getOrientation(), BaseInteractable::getPosition(), BaseInteractable::getVelocity(), leftNormal_, leftRadialAxis_, leftWall_, BaseInteractable::move(), origin_, rightNormal_, rightRadialAxis_, BaseInteractable::rotate(), rotateLeft, and rotateRight.

Referenced by checkBoundaryAfterParticleMoved(), and createPeriodicParticles().

 {
     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(), leftNormal_);
         Mdouble radialAngularDistance = Vec3D::dot(P->getOrientation(), 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 normalAngularDistance = Vec3D::dot(P->getOrientation(), rightNormal_);
         Mdouble radialAngularDistance = Vec3D::dot(P->getOrientation(), rightRadialAxis_);
         P->rotate(-normalAngularDistance * differenceNormal_ - radialAngularDistance * 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);
             }
         }
     }
 }

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

only needed in StatisticsVector

Todo:: TW: this still doesn't shift all data

Definition at line 172 of file AngledPeriodicBoundary.cc.

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

 {
     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;
     }
 }

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

virtual

outputs wall

Implements BaseBoundary.

Definition at line 225 of file AngledPeriodicBoundary.cc.

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

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

Member Data Documentation

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.

Definition at line 179 of file AngledPeriodicBoundary.h.

Referenced by set().

Vec3D AngledPeriodicBoundary::differenceNormal_

private

Definition at line 166 of file AngledPeriodicBoundary.h.

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

Vec3D AngledPeriodicBoundary::differenceRadialAxis_

private

Definition at line 162 of file AngledPeriodicBoundary.h.

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

Vec3D AngledPeriodicBoundary::leftNormal_

private