Defines a pair of periodic walls. The particles are in {x: position_left<=normal*x <position_right}, with normal being the outward unit normal vector of the right wall. If a particle moves outside these boundaries, it will be shifted. More...

#include <PeriodicBoundary.h>

Inheritance diagram for PeriodicBoundary:

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

void	set (Vec3D normal_, Mdouble position_left_, Mdouble position_right_)
	Defines a periodic wall, given a normal vector s.t. More...

void	set (Vec3D normal_, Mdouble position_left_, Mdouble position_right_, Vec3D shift_direction)
	For general parallelogramic domains, the direction of the shift vector has to be set manually. More...

void	move_left (Mdouble position_)
	Allows the left periodic wall to be moved to a new position and automatically changes its shift value. More...

void	move_right (Mdouble position_)
	Allows the right periodic wall to be moved to a new position and automatically changes its shift value. 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 *F0)
	shifts the particle (after distance set the left_wall value) More...

Vec3D	get_shifted_position (Vec3D &Position)
	returns the shifted particle w/o actually shifting More...

void	shift_positions (Vec3D &PI, Vec3D &PJ)
	shifts two particles More...

void	get_close_together (Vec3D &P, Vec3D &Q)
	shift P such that it is closest to Q 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
bool	left_wall
	true if closest wall is the left wall More...

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

Mdouble	position_left
	position of left wall, s.t. normal*x=position_left More...

Mdouble	position_right
	position of right wall, s.t. normal*x=position_right More...

Mdouble	factor
	This is the normal to rescale to unit vectoers. More...

Vec3D	shift
	shift from left to right boundary More...

Detailed Description

Defines a pair of periodic walls. The particles are in {x: position_left<=normal*x <position_right}, with normal being the outward unit normal vector of the right wall. If a particle moves outside these boundaries, it will be shifted.

Definition at line 35 of file PeriodicBoundary.h.

Member Function Documentation

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

inline

Definition at line 201 of file PeriodicBoundary.h.

References distance(), and shift_position().

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

virtual PeriodicBoundary* PeriodicBoundary::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 38 of file PeriodicBoundary.h.

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

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

inline

Definition at line 177 of file PeriodicBoundary.h.

References ParticleHandler::addObject(), BaseParticle::copy(), distance(), BaseParticle::get_InteractionRadius(), BaseParticle::get_PeriodicFromParticle(), ParticleHandler::getLargestParticle(), TangentialSpringParticle::reverseTangentialSprings(), BaseParticle::set_periodicFromParticle(), and shift_position().

     {
         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();
             
             //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 PeriodicBoundary::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 96 of file PeriodicBoundary.h.

References BaseParticle::get_Position().

Referenced by checkBoundaryAfterParticleMoved(), createPeriodicParticles(), MD::do_integration_after_force_computation(), StatisticsVector< T >::evaluate_force_statistics(), StatisticsVector< T >::evaluate_particle_statistics(), and StatisticsVector< T >::evaluate_wall_force_statistics().

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

Mdouble PeriodicBoundary::distance ( const Vec3D & P )

inline

Definition at line 100 of file PeriodicBoundary.h.

References left_wall, normal, position_left, and position_right.

                                    {
     Mdouble position = Dot(P, normal);
 
     if (position - position_left < position_right - position) {
       left_wall = true;
       return position - position_left;
     } else {
       left_wall = false;
       return position_right - position;
     }
   }

void PeriodicBoundary::get_close_together	(	Vec3D &	P,
		Vec3D &	Q
	)

inline

shift P such that it is closest to Q

Definition at line 149 of file PeriodicBoundary.h.

References Vec3D::GetLength2, normal, shift, and sqr.

                                                {
         Mdouble PQdotn = Dot(P-Q, normal);
         Mdouble shift_norm2 = shift.GetLength2();
         //Check if P is so far from Q that a shift would move it closer
         if (sqr(PQdotn) > .25 * shift_norm2) {
             //Now determine the direction of the shift
             if (PQdotn>0.0) P -= shift;
             else P += shift;
         }
     }

Vec3D& PeriodicBoundary::get_normal ( )

inline

Definition at line 175 of file PeriodicBoundary.h.

References normal.

175 {return normal;}

PeriodicBoundary::normal

Vec3D normal

outward unit normal vector for right wall

Definition: PeriodicBoundary.h:212

Vec3D PeriodicBoundary::get_shifted_position ( Vec3D & Position )

inline

returns the shifted particle w/o actually shifting

Definition at line 125 of file PeriodicBoundary.h.

References left_wall, and shift.

                                                 {
         if (left_wall) {
             return Position + shift;
         }
         else {
             return Position - shift;
         }
     }

void PeriodicBoundary::move_left ( Mdouble position_ )

inline

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

Definition at line 75 of file PeriodicBoundary.h.

References factor, normal, position_left, position_right, and shift.

   {
       position_left=position_*factor;
       shift = normal * (position_right - position_left);
   }

void PeriodicBoundary::move_right ( Mdouble position_ )

inline

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

Definition at line 82 of file PeriodicBoundary.h.

References factor, normal, position_left, position_right, and shift.

   {
       position_right=position_*factor;
       shift = normal * (position_right - position_left);
   }

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

inline

outputs wall

Definition at line 168 of file PeriodicBoundary.h.

References normal, position_left, position_right, and shift.

                                      {
         os << "PeriodicBoundary normal " << normal 
             << " position_left " << position_left 
             << " position_right " << position_right
             << " shift " << shift;
     }

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

inline

reads wall

Definition at line 162 of file PeriodicBoundary.h.

References normal, position_left, position_right, and shift.

                               { 
     std::string dummy;
         is >> dummy >> normal >> dummy >> position_left >> dummy >> position_right >> dummy >> shift;
     }

void PeriodicBoundary::set	(	Vec3D	normal_,
		Mdouble	position_left_,
		Mdouble	position_right_
	)

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

Definition at line 52 of file PeriodicBoundary.h.

References factor, normal, position_left, position_right, and shift.

Referenced by MD::load_par_ini_file(), Chute::setup_particles_initial_conditions(), and ChuteBottom::setup_particles_initial_conditions().

                                                                            {
     // factor is used to set normal to unit length
     factor = 1. / sqrt(Dot(normal_, normal_));
     normal = normal_ * factor;
     position_left = position_left_ * factor;
     position_right = position_right_ * factor;
     shift = normal * (position_right - position_left);
   }

void PeriodicBoundary::set	(	Vec3D	normal_,
		Mdouble	position_left_,
		Mdouble	position_right_,
		Vec3D	shift_direction
	)

inline

For general parallelogramic domains, the direction of the shift vector has to be set manually.

Definition at line 63 of file PeriodicBoundary.h.

References factor, normal, position_left, position_right, and shift.

                                                                                                   {
     // factor is used to set normal to unit length
     factor = 1. / sqrt(Dot(normal_, normal_));
     normal = normal_ * factor;
     position_left = position_left_ * factor;
     position_right = position_right_ * factor;
     // factor is used to set shift vector to correct length
     factor = (position_right - position_left) * Dot(shift_direction, normal);
     shift = shift_direction * factor;
   }

void PeriodicBoundary::shift_position ( BaseParticle * F0 )

inline

shifts the particle (after distance set the left_wall value)

Definition at line 113 of file PeriodicBoundary.h.

References left_wall, BaseParticle::move(), and shift.

Referenced by checkBoundaryAfterParticleMoved(), createPeriodicParticles(), MD::do_integration_after_force_computation(), and StatisticsVector< T >::evaluate_particle_statistics().

                                           {
         if (left_wall) {
             F0->move(shift);
             left_wall = false;
         }
         else {
             F0->move(-shift);
             left_wall = true;
         }
     }

void PeriodicBoundary::shift_positions	(	Vec3D &	PI,
		Vec3D &	PJ
	)

inline

shifts two particles

Definition at line 135 of file PeriodicBoundary.h.

References left_wall, and shift.

Referenced by StatisticsVector< T >::evaluate_force_statistics(), and StatisticsVector< T >::evaluate_wall_force_statistics().

                                                {
         if (left_wall) {
             PI += shift;
             PJ += shift;
             left_wall = false;
         }
         else {
             PI -= shift;
             PJ -= shift;
             left_wall = true;
         }
     }