FiniteWall Class Reference

#include <FiniteWall.h>

Inheritance diagram for FiniteWall:

Public Member Functions
	FiniteWall ()
virtual FiniteWall *	copy () const
	Wall copy method. It calls the copy contrustor of this Wall, usefull for polymorfism. More...
void	clear ()
void	add_finite_wall (Vec3D normal, Vec3D point)
	Adds a wall to the set of finite walls, given an outward normal vector s.t. normal*x=normal*point. More...
void	add_finite_wall (Vec3D normal_, Mdouble position_)
	Adds a wall to the set of finite walls, given an outward normal vector s. t. normal*x=position. More...
void	create_open_prism_wall (std::vector< Vec3D > Points, Vec3D PrismAxis)
void	create_prism_wall (std::vector< Vec3D > Points, Vec3D PrismAxis)
void	create_open_prism_wall (std::vector< Vec3D > Points)
void	create_prism_wall (std::vector< Vec3D > Points)
bool	get_distance_and_normal (BaseParticle &P, Mdouble &distance, Vec3D &normal_return)
	Since this function should be called before calculating any Particle-Wall interactions, it can also be used to set the normal vector in case of curved walls. More...
void	read (std::istream &is)
	reads wall More...
void	print (std::ostream &os) const
	outputs wall More...
Vec3D	get_Velocity () const
	access function for velocity More...
Public Member Functions inherited from BaseWall
	BaseWall ()
	BaseWall (const BaseWall &p)
virtual	~BaseWall ()
virtual void	move (Mdouble position_ UNUSED)
	Allows the wall to be moved to a new position. More...
virtual void	move (Vec3D velocity_ UNUSED, Mdouble dt UNUSED)
	Allows the wall to be moved to a new position (also orthogonal to the normal), and setting the velocity. More...
virtual void	move_time (Mdouble dt UNUSED)
	Allows the wall to be moved to a new position (also orthogonal to the normal), and setting the velocity. More...
virtual bool	get_distance_and_normal (BaseParticle &P UNUSED, Mdouble &distance UNUSED, Vec3D &normal_return UNUSED)=0
void	set_Velocity (Vec3D new_)
	access function for velocity More...
virtual void	read (std::istream &is UNUSED)=0
virtual void	print (std::ostream &os UNUSED) const =0
virtual void	moveInHandler (int newPos)
int	getIndSpecies () const
void	setIndSpecies (const int _new)
const Vec3D &	get_Force () const
const Vec3D &	get_Torque () const
void	set_Force (Vec3D _new)
void	set_Torque (Vec3D _new)
void	set_Index (int index)
void	set_Id (int id)
void	add_Force (Vec3D _new)
void	add_Torque (Vec3D _new)

Private Attributes
std::vector< InfiniteWall >	finite_walls
std::vector< Vec3D >	A
std::vector< Vec3D >	AB
std::vector< Vec3D >	C

Additional Inherited Members
Public Attributes inherited from BaseWall
int	indSpecies
Protected Attributes inherited from BaseWall
Vec3D	velocity
	velocity of the wall (used to calculate the relative velocity in the force calculation) More...

Detailed Description

Definition at line 33 of file FiniteWall.h.

Constructor & Destructor Documentation

FiniteWall::FiniteWall ( )

inline

Definition at line 36 of file FiniteWall.h.

Referenced by copy().

                 : BaseWall()
    {
        #ifdef CONSTUCTOR_OUTPUT
        std::cout<<"InfiniteWall () finished"<<std::endl;
        #endif  
    }

Member Function Documentation

void FiniteWall::add_finite_wall ( Vec3D  normal, Vec3D  point  )

inline

Adds a wall to the set of finite walls, given an outward normal vector s.t. normal*x=normal*point.

Definition at line 57 of file FiniteWall.h.

Referenced by ChuteWithHopper::add_hopper(), create_open_prism_wall(), create_prism_wall(), and read().

                                                    {
        add_finite_wall(normal,Dot(normal,point));
    }

void FiniteWall::add_finite_wall ( Vec3D  normal_, Mdouble  position_  )

inline

Adds a wall to the set of finite walls, given an outward normal vector s. t. normal*x=position.

Definition at line 61 of file FiniteWall.h.

References A, AB, C, Cross(), finite_walls, X, Y, and Z.

    {
        //n is the index of the new wall
        int n = finite_walls.size();
        finite_walls.resize(n+1);
        finite_walls[n].set(normal_,position_);

        // AB[n*(n-1)/2+m] is the direction of the intersecting line between walls m and n, m<n
        // A[n*(n-1)/2+m] is a point on the intersecting line between walls m and n, m<n
        // See http://www.netcomuk.co.uk/~jenolive/vect18d.html for finding the line where two planes meet
        AB.resize(n*(n+1)/2);
        A.resize (n*(n+1)/2);
        for(int m=0; m<n; m++) 
        {
            int id = (n-1)*n/2+m;
            //first we cross the wall normals and normalize to obtain AB
            AB[id] = Cross(finite_walls[m].get_Normal(), finite_walls[n].get_Normal());
            AB[id] /= sqrt(AB[id].GetLength2());
            //then we find a point A (using AB*x=0 as a third plane)
            Mdouble invdet = 1.0/(  +finite_walls[n].get_Normal().X*(finite_walls[m].get_Normal().Y*AB[id].Z-AB[id].Y*finite_walls[m].get_Normal().Z)
                                    -finite_walls[n].get_Normal().Y*(finite_walls[m].get_Normal().X*AB[id].Z-finite_walls[m].get_Normal().Z*AB[id].X)
                                    +finite_walls[n].get_Normal().Z*(finite_walls[m].get_Normal().X*AB[id].Y-finite_walls[m].get_Normal().Y*AB[id].X));
            A[id] = Vec3D(  +(finite_walls[m].get_Normal().Y*AB[id].Z-AB[id].Y*finite_walls[m].get_Normal().Z)*finite_walls[n].get_Position()
                            -(finite_walls[n].get_Normal().Y*AB[id].Z-finite_walls[n].get_Normal().Z*AB[id].Y)*finite_walls[m].get_Position()
                            +(finite_walls[n].get_Normal().Y*finite_walls[m].get_Normal().Z-finite_walls[n].get_Normal().Z*finite_walls[m].get_Normal().Y)*0.0,
                            -(finite_walls[m].get_Normal().X*AB[id].Z-finite_walls[m].get_Normal().Z*AB[id].X)*finite_walls[n].get_Position()
                            +(finite_walls[n].get_Normal().X*AB[id].Z-finite_walls[n].get_Normal().Z*AB[id].X)*finite_walls[m].get_Position()
                            -(finite_walls[n].get_Normal().X*finite_walls[m].get_Normal().Z-finite_walls[m].get_Normal().X*finite_walls[n].get_Normal().Z)*0.0,
                            +(finite_walls[m].get_Normal().X*AB[id].Y-AB[id].X*finite_walls[m].get_Normal().Y)*finite_walls[n].get_Position()
                            -(finite_walls[n].get_Normal().X*AB[id].Y-AB[id].X*finite_walls[n].get_Normal().Y)*finite_walls[m].get_Position()
                            +(finite_walls[n].get_Normal().X*finite_walls[m].get_Normal().Y-finite_walls[m].get_Normal().X*finite_walls[n].get_Normal().Y)*0.0 ) * invdet;
        }

        // C[(n-2)*(n-1)*n/6+(m-1)*m/2+l] is a point intersecting walls l, m and n, l<m<n
        C.resize((n-1)*n*(n+1)/6);
        for(int m=0; m<n; m++) 
        {
            for(int l=0; l<m; l++) 
            {
                int id = (n-2)*(n-1)*n/6+(m-1)*m/2+l;
                Mdouble invdet = 1.0/(  +finite_walls[n].get_Normal().X*(finite_walls[m].get_Normal().Y*finite_walls[l].get_Normal().Z-finite_walls[l].get_Normal().Y*finite_walls[m].get_Normal().Z)
                                        -finite_walls[n].get_Normal().Y*(finite_walls[m].get_Normal().X*finite_walls[l].get_Normal().Z-finite_walls[m].get_Normal().Z*finite_walls[l].get_Normal().X)
                                        +finite_walls[n].get_Normal().Z*(finite_walls[m].get_Normal().X*finite_walls[l].get_Normal().Y-finite_walls[m].get_Normal().Y*finite_walls[l].get_Normal().X));
                C[id] = Vec3D(  +(finite_walls[m].get_Normal().Y*finite_walls[l].get_Normal().Z-finite_walls[l].get_Normal().Y*finite_walls[m].get_Normal().Z)*finite_walls[n].get_Position()
                                -(finite_walls[n].get_Normal().Y*finite_walls[l].get_Normal().Z-finite_walls[n].get_Normal().Z*finite_walls[l].get_Normal().Y)*finite_walls[m].get_Position()
                                +(finite_walls[n].get_Normal().Y*finite_walls[m].get_Normal().Z-finite_walls[n].get_Normal().Z*finite_walls[m].get_Normal().Y)*finite_walls[l].get_Position(),
                                -(finite_walls[m].get_Normal().X*finite_walls[l].get_Normal().Z-finite_walls[m].get_Normal().Z*finite_walls[l].get_Normal().X)*finite_walls[n].get_Position()
                                +(finite_walls[n].get_Normal().X*finite_walls[l].get_Normal().Z-finite_walls[n].get_Normal().Z*finite_walls[l].get_Normal().X)*finite_walls[m].get_Position()
                                -(finite_walls[n].get_Normal().X*finite_walls[m].get_Normal().Z-finite_walls[m].get_Normal().X*finite_walls[n].get_Normal().Z)*finite_walls[l].get_Position(),
                                +(finite_walls[m].get_Normal().X*finite_walls[l].get_Normal().Y-finite_walls[l].get_Normal().X*finite_walls[m].get_Normal().Y)*finite_walls[n].get_Position()
                                -(finite_walls[n].get_Normal().X*finite_walls[l].get_Normal().Y-finite_walls[l].get_Normal().X*finite_walls[n].get_Normal().Y)*finite_walls[m].get_Position()
                                +(finite_walls[n].get_Normal().X*finite_walls[m].get_Normal().Y-finite_walls[m].get_Normal().X*finite_walls[n].get_Normal().Y)*finite_walls[l].get_Position() ) * invdet;
            }
        }
    }

void FiniteWall::clear ( )

inlinevirtual

Reimplemented from BaseWall.

Definition at line 49 of file FiniteWall.h.

References finite_walls, BaseWall::indSpecies, Vec3D::set_zero(), and BaseWall::velocity.

    {
        indSpecies = 0;
        velocity.set_zero();
        finite_walls.clear();
    }     

virtual FiniteWall* FiniteWall::copy ( ) const

inlinevirtual

Wall copy method. It calls the copy contrustor of this Wall, usefull for polymorfism.

Implements BaseWall.

Reimplemented in FiniteAxisSymmetricWall.

Definition at line 44 of file FiniteWall.h.

References FiniteWall().

    {
        return new FiniteWall(*this);
    } 

void FiniteWall::create_open_prism_wall ( std::vector< Vec3D >  Points, Vec3D  PrismAxis  )

inline

Definition at line 117 of file FiniteWall.h.

References add_finite_wall(), Cross(), and finite_walls.

Referenced by create_prism_wall().

    {
        finite_walls.clear();
        for(unsigned int i=0; i<Points.size()-1; i++)
            add_finite_wall(Cross(Points[i]-Points[i+1],PrismAxis),Points[i]);
    }

void FiniteWall::create_open_prism_wall ( std::vector< Vec3D >  Points )

inline

Definition at line 130 of file FiniteWall.h.

References add_finite_wall(), Cross(), and finite_walls.

    {
        Vec3D PrismAxis = Cross(
            GetUnitVector(Points[1]-Points[0]),
            GetUnitVector(Points[2]-Points[1]));
        finite_walls.clear();
        for(unsigned int i=0; i<Points.size()-1; i++)
            add_finite_wall(Cross(Points[i]-Points[i+1],PrismAxis),Points[i]);
    }

void FiniteWall::create_prism_wall ( std::vector< Vec3D >  Points, Vec3D  PrismAxis  )

inline

Definition at line 124 of file FiniteWall.h.

References add_finite_wall(), create_open_prism_wall(), and Cross().

    {
        create_open_prism_wall(Points, PrismAxis);
        add_finite_wall(Cross(Points.back()-Points.front(),PrismAxis),Points.front());
    }

void FiniteWall::create_prism_wall ( std::vector< Vec3D >  Points )

inline

Definition at line 140 of file FiniteWall.h.

References add_finite_wall(), create_open_prism_wall(), and Cross().

    {
        Vec3D PrismAxis = Cross(
            GetUnitVector(Points[2]-Points[0]),
            GetUnitVector(Points[1]-Points[0]));
        create_open_prism_wall(Points, PrismAxis);
        add_finite_wall(Cross(Points.back()-Points.front(),PrismAxis),Points.front());
    }

bool FiniteWall::get_distance_and_normal ( BaseParticle &  P, Mdouble &  distance, Vec3D &  normal_return  )

inline

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

Definition at line 150 of file FiniteWall.h.

References A, AB, C, finite_walls, BaseParticle::get_Position(), BaseParticle::get_WallInteractionRadius(), and Vec3D::GetLength2.

Referenced by FiniteAxisSymmetricWall::get_distance_and_normal().

    {
        static Mdouble distance_new;
        static Mdouble distance2;  
        static Mdouble distance3;
        static int id;  
        static int id2;  
        static int id3;  

        //if we are here, this is a finite wall
        distance = -1e20;
        distance2 = -1e20;
        distance3 = -1e20;
        //for all finite walls
        for (unsigned int i=0; i<finite_walls.size(); i++)
        {
            //calculate the distance to the particle
            distance_new = finite_walls[i].get_distance(P.get_Position());
            //return false if the distance to any one wall is too large (i.e. no contact)
            if (distance_new>=P.get_WallInteractionRadius()) return false;
            //store the minimum distance and the respective wall in "distance" and "id"
            //and store up to two walls (id2, id3) and their distances (distance2, distance3), if the possible contact point is near the intersection between id and id2 (and id3)
            if (distance_new>distance)
            {
                if (distance>-P.get_WallInteractionRadius())
                {
                    if (distance2>-P.get_WallInteractionRadius()) {distance3 = distance; id3 = id;}
                    else {distance2 = distance; id2 = id;}
                } 
                distance = distance_new; id = i;
            } else if (distance_new>-P.get_WallInteractionRadius())
            {
                if (distance2>-P.get_WallInteractionRadius()) {distance3 = distance_new; id3 = i;}
                else {distance2 = distance_new; id2 = i;}
            }
        }

        //if we are here, the closest wall is id; 
        //if distance2>-P.Radius (and distance3>-P.Radius), the possible contact point is near the intersection between id and id2 (and id3)
        if (distance2>-P.get_WallInteractionRadius())
        {
            //D is the point on wall id closest to P
            Vec3D D = P.get_Position() + finite_walls[id].get_Normal() * distance;
            //If the distance of D to id2 is positive, the contact is with the intersection
            bool intersection_with_id2 = (finite_walls[id2].get_distance(D)>0.0);

            if (distance3>-P.get_WallInteractionRadius()&&(finite_walls[id3].get_distance(D)>0.0))
            {
                if (intersection_with_id2)
                {
                        //possible contact is with intersection of id,id2,id3
                    //we know id2<id3
                    int index = 
                    (id<id2)?( (id3-2)*(id3-1)*id3/6+(id2-1)*id2/2+id  ):
                    (id<id3)?( (id3-2)*(id3-1)*id3/6+(id -1)*id /2+id2 ):
                    ( (id -2)*(id -1)*id /6+(id3-1)*id3/2+id2 );
                    normal_return = P.get_Position() - C[index];
                    distance = sqrt(normal_return.GetLength2());
                    if (distance>=P.get_WallInteractionRadius()) return false; //no contact
                    normal_return /= -distance; 
                    return true; //contact with id,id2,id3
                } else { intersection_with_id2 = true; distance2 = distance3; id2 = id3; }
            }

            if (intersection_with_id2)
            { //possible contact is with intersection of id,id2
                int index = (id>id2)?((id-1)*id/2+id2):((id2-1)*id2/2+id);
                Vec3D AC = P.get_Position() - A[index];
                normal_return = AC - AB[index] * Dot(AC,AB[index]);
                distance = sqrt(normal_return.GetLength2());
                if (distance>=P.get_WallInteractionRadius()) return false; //no contact
                normal_return /= -distance; 
                return true; //contact with two walls
            }
        }
        //contact is with id
        normal_return = finite_walls[id].get_Normal(); 
        return true;

    }

Vec3D FiniteWall::get_Velocity ( ) const

inlinevirtual

access function for velocity

Implements BaseWall.

Definition at line 261 of file FiniteWall.h.

References BaseWall::velocity.

{return velocity;}

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

inline

outputs wall

Definition at line 250 of file FiniteWall.h.

References finite_walls, Vec3D::GetLength2, and BaseWall::velocity.

Referenced by FiniteAxisSymmetricWall::print().

    {
        os << "FiniteWall numFiniteWalls " << finite_walls.size(); 
        for (std::vector<InfiniteWall>::const_iterator it = finite_walls.begin(); it!=finite_walls.end(); ++it)
        {
            os << " normal " << it->get_Normal() << " position " << it->get_Position();
        }
        if (velocity.GetLength2()) os << " velocity " << velocity;
    }

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

inline

reads wall

Definition at line 233 of file FiniteWall.h.

References add_finite_wall(), and BaseWall::velocity.

Referenced by FiniteAxisSymmetricWall::read().

    { 
        std::string dummy;
        int n;
        is >> dummy >> n;

        Vec3D normal;
        Mdouble position;
        for (int i=0; i<n; i++)
        {
            is >> dummy >> normal >> dummy >> position;
            add_finite_wall(normal,position);
        }       
        is >> dummy >> velocity;
    }

Member Data Documentation

std::vector<Vec3D> FiniteWall::A

private

Definition at line 265 of file FiniteWall.h.

Referenced by add_finite_wall(), and get_distance_and_normal().

std::vector<Vec3D> FiniteWall::AB

private

Definition at line 266 of file FiniteWall.h.

Referenced by add_finite_wall(), and get_distance_and_normal().

std::vector<Vec3D> FiniteWall::C

private

Definition at line 267 of file FiniteWall.h.

Referenced by add_finite_wall(), and get_distance_and_normal().

std::vector<InfiniteWall> FiniteWall::finite_walls

private

Definition at line 264 of file FiniteWall.h.

Referenced by add_finite_wall(), clear(), create_open_prism_wall(), get_distance_and_normal(), and print().

---

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

• FiniteWall.h