Defines a pair of periodic walls that are angled around the origin. More...

#include <AngledPeriodicBoundary.h>

Inheritance diagram for AngledPeriodicBoundary:

Public Member Functions
virtual AngledPeriodicBoundary *	copy () const
	BaseBoundary copy method. More...

void	set (Vec3D normal_left_, Vec3D normal_right_, Vec3D origin_)
	Defines a periodic wall, given a normal vector s.t. More...

Mdouble	distance (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	shift_position (BaseParticle *P)
	shifts the particle (after distance set the left_wall value) More...

void	read (std::istream &is)
	reads wall More...

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

Vec3D &	get_normal ()

int	createPeriodicParticles (BaseParticle *P, ParticleHandler &pH)

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

Public Member Functions inherited from BaseBoundary
virtual	~BaseBoundary ()

virtual int	createPeriodicParticles (BaseParticle *P UNUSED, ParticleHandler &pH UNUSED)

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

virtual void	checkBoundaryActionsBeforeTimeStep (ParticleHandler &pH UNUSED, WallHandler &wH UNUSED, RNG &random UNUSED)

void	set_Index (int index)

void	set_Id (int id)

void	setHandler (BoundaryHandler *handler)

virtual void	read (std::istream &is UNUSED)=0
	reads boundary More...

virtual void	print (std::ostream &os UNUSED) const =0
	outputs boundary More...

virtual void	moveInHandler (int newPos)

Private Attributes
Vec3D	normal_left
	outward unit normal vector for left wall More...

Vec3D	normal_right
	outward unit normal vector for right wall More...

Vec3D	origin
	common point of both walls More...

bool	left_wall
	true if closest wall is the left wall More...

Vec3D	radialAxis_left
	outward unit normal vector for left wall More...

Vec3D	radialAxis_right
	outward unit normal vector for right wall More...

Vec3D	diff_radial

Vec3D	diff_normal

Vec3D	common_axis

Vec3D	angularShift

Detailed Description

Defines a pair of periodic walls that are angled around the origin.

The particles are in {x: normal_left*(x-origin)>0 && normal_right*(x-origin)<0, with normal* being the unit normal vector of the walls. If a particle moves outside these boundaries, it will be shifted.

Definition at line 38 of file AngledPeriodicBoundary.h.

Member Function Documentation

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

inline

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

Definition at line 247 of file AngledPeriodicBoundary.h.

References distance(), and shift_position().

     {
         //std::cout << "checkBoundaryAfterParticleMoved" << std::endl;
         if (distance(*P)<0)
             shift_position(P);
         return false;
     }

virtual AngledPeriodicBoundary* AngledPeriodicBoundary::copy ( ) const

inlinevirtual

BaseBoundary copy method.

It calls the copy constructor of this BaseBoundary, useful for polymorphism todo{Does this work correctly?}

Implements BaseBoundary.

Definition at line 41 of file AngledPeriodicBoundary.h.

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

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

inline

Todo:: {TW: shouldn't that return a boolean?}

Definition at line 194 of file AngledPeriodicBoundary.h.

References ParticleHandler::addObject(), BaseParticle::copy(), diff_normal, diff_radial, distance(), BaseParticle::get_InteractionRadius(), BaseParticle::get_PeriodicFromParticle(), TangentialSpringParticle::get_TangentialSprings(), ParticleHandler::getLargestParticle(), left_wall, normal_left, normal_right, radialAxis_left, radialAxis_right, TangentialSpringParticle::reverseTangentialSprings(), BaseParticle::set_periodicFromParticle(), and shift_position().

     {
         //std::cout << "createPeriodicParticles" << std::endl;
         if (distance(*P)<P->get_InteractionRadius()+pH.getLargestParticle()->get_InteractionRadius())
         {
             BaseParticle* F0=P->copy();
             shift_position(F0);
                         
             //If the Particle includes TangentalSprings reverse them
             TangentialSpringParticle* TSParticle=dynamic_cast<TangentialSpringParticle*>(F0);
             if(TSParticle) {
                 TSParticle->reverseTangentialSprings();
                 for(std::vector<CTangentialSpring>::iterator it = TSParticle->get_TangentialSprings().begin(); it!=TSParticle->get_TangentialSprings().end();it++)
                 {
                     //std::cout << it->delta << std::endl;
                     if (!left_wall) {
                         Mdouble normalDistance = Dot(it->delta,normal_left);
                         Mdouble radialDistance = Dot(it->delta,radialAxis_left);
                         it->delta += normalDistance*diff_normal+radialDistance*diff_radial;
                         normalDistance = Dot(it->RollingSpring,normal_left);
                         radialDistance = Dot(it->RollingSpring,radialAxis_left);
                         it->RollingSpring += normalDistance*diff_normal+radialDistance*diff_radial;
                         normalDistance = Dot(it->TorsionSpring,normal_left);
                         radialDistance = Dot(it->TorsionSpring,radialAxis_left);
                         it->TorsionSpring += normalDistance*diff_normal+radialDistance*diff_radial;
                     } else {
                         Mdouble normalDistance = Dot(it->delta,normal_right);
                         Mdouble radialDistance = Dot(it->delta,radialAxis_right);
                         it->delta -= normalDistance*diff_normal+radialDistance*diff_radial;
                         normalDistance = Dot(it->RollingSpring,normal_right);
                         radialDistance = Dot(it->RollingSpring,radialAxis_right);
                         it->RollingSpring -= normalDistance*diff_normal+radialDistance*diff_radial;
                         normalDistance = Dot(it->TorsionSpring,normal_right);
                         radialDistance = Dot(it->TorsionSpring,radialAxis_right);
                         it->TorsionSpring -= normalDistance*diff_normal+radialDistance*diff_radial;
                     }
                     //std::cout << it->delta << std::endl;
                 }        
             }
     
             //If Particle is Mdouble shifted, get correct original particle
             BaseParticle* From=P;
             while(From->get_PeriodicFromParticle()!=NULL)
                 From=From->get_PeriodicFromParticle();        
             F0->set_periodicFromParticle(From);
 
             pH.addObject(F0);
             return 1;
         }
         return 0;
     }        

Mdouble AngledPeriodicBoundary::distance ( BaseParticle & P )

inline

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 83 of file AngledPeriodicBoundary.h.

References BaseParticle::get_Position().

Referenced by checkBoundaryAfterParticleMoved(), and createPeriodicParticles().

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

Mdouble AngledPeriodicBoundary::distance ( const Vec3D & P )

inline

Definition at line 88 of file AngledPeriodicBoundary.h.

References left_wall, normal_left, normal_right, and origin.

                                      {
         Vec3D position = P-origin;
         Mdouble distance_left = Dot(position,normal_left);
         Mdouble distance_right = -Dot(position,normal_right);
 
         if (distance_left<distance_right) {
             left_wall = true;
             //std::cout << "left wall, " << position << ", distance " << distance_left << "<" << distance_right << std::endl;
             return distance_left;
         } else {
             left_wall = false;
             //std::cout << "right wall, " << position << ", distance " << distance_right << "<" << distance_left << std::endl;
             return distance_right;
         }
     }

Vec3D& AngledPeriodicBoundary::get_normal ( )

inline

Definition at line 188 of file AngledPeriodicBoundary.h.

References left_wall, normal_left, and normal_right.

                         {
         if (left_wall) return normal_left;
         else return normal_right;
     }

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

inline

outputs wall

Definition at line 182 of file AngledPeriodicBoundary.h.

References normal_left, normal_right, and origin.

                                      {
         os << "AngledPeriodicBoundary normal_left " << normal_left 
             << " normal_right " << normal_right 
             << " origin " << origin;
     }

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

inline

reads wall

Definition at line 176 of file AngledPeriodicBoundary.h.

References normal_left, normal_right, and origin.

                               { 
         std::string dummy;
         is >> dummy >> normal_left >> dummy >> normal_right >> dummy >> origin;
     }

void AngledPeriodicBoundary::set	(	Vec3D	normal_left_,
		Vec3D	normal_right_,
		Vec3D	origin_
	)

inline

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

Todo:: {I cannot calculate angular shift; right now this works only for quarter walls; maybe this has to wait till quaternions are implemented.}

Definition at line 58 of file AngledPeriodicBoundary.h.

References common_axis, Cross(), diff_normal, diff_radial, normal_left, normal_right, origin, radialAxis_left, and radialAxis_right.

                                                                       {
         origin=origin_;
         normal_left = normal_left_ / GetLength(normal_left_);
         normal_right = normal_right_ / GetLength(normal_right_);
         common_axis = Cross(normal_left, normal_right);
         common_axis /= GetLength(common_axis);
         radialAxis_left = Cross(normal_left, common_axis);
         radialAxis_right = Cross(normal_right, common_axis);
         diff_normal = normal_right-normal_left;
         diff_radial = radialAxis_right-radialAxis_left;
         //angularShift = 0;
         // std::cout << "common_axis " << common_axis
         // << ", radialAxis_left " << radialAxis_left
         // << ", radialAxis_right " << radialAxis_right
         // << ", angularShift " << angularShift
         // << std::endl; 
     }

void AngledPeriodicBoundary::shift_position ( BaseParticle * P )

inline

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}

Todo:: tangential spring

Definition at line 106 of file AngledPeriodicBoundary.h.

References BaseParticle::accelerate(), diff_normal, diff_radial, BaseParticle::get_Angle(), BaseParticle::get_Position(), BaseParticle::get_Velocity(), left_wall, BaseParticle::move(), normal_left, normal_right, origin, radialAxis_left, radialAxis_right, and BaseParticle::rotate().

Referenced by checkBoundaryAfterParticleMoved(), and createPeriodicParticles().

                                          {
         Vec3D position = P->get_Position()-origin;
         if (left_wall) {
             Mdouble normalDistance = Dot(position,normal_left);
             Mdouble radialDistance = Dot(position,radialAxis_left);
             P->move(normalDistance*diff_normal+radialDistance*diff_radial);
             Mdouble normalVelocity = Dot(P->get_Velocity(),normal_left);
             Mdouble radialVelocity = Dot(P->get_Velocity(),radialAxis_left);
             P->accelerate(normalVelocity*diff_normal+radialVelocity*diff_radial);
             Mdouble normalAngularDistance = Dot(P->get_Angle(),normal_left);
             Mdouble radialAngularDistance = Dot(P->get_Angle(),radialAxis_left);
             P->rotate(normalAngularDistance*diff_normal+radialAngularDistance*diff_radial);
             left_wall = false;
             //std::cout << "shift to right wall, " << P->get_Position() << std::endl;
         }
         else {
             Mdouble normalDistance = Dot(position,normal_right);
             Mdouble radialDistance = Dot(position,radialAxis_right);
             P->move(-normalDistance*diff_normal-radialDistance*diff_radial);
             Mdouble normalVelocity = Dot(P->get_Velocity(),normal_right);
             Mdouble radialVelocity = Dot(P->get_Velocity(),radialAxis_right);
             P->accelerate(-normalVelocity*diff_normal-radialVelocity*diff_radial);
             Mdouble normalAngularDistance = Dot(P->get_Angle(),normal_right);
             Mdouble radialAngularDistance = Dot(P->get_Angle(),radialAxis_right);
             P->rotate(-normalAngularDistance*diff_normal-radialAngularDistance*diff_radial);
             left_wall = true;
             //std::cout << "shift to left wall, " << P->get_Position() << std::endl;
         }
     }