voro%2B%2B-0.4.6/src/wall.cc

// Voro++, a 3D cell-based Voronoi library
//
// Author   : Chris H. Rycroft (LBL / UC Berkeley)
// Email    : chr@alum.mit.edu
// Date     : August 30th 2011

/** \file wall.cc
 * \brief Function implementations for the derived wall classes. */

#include "wall.hh"

namespace voro {

/** Tests to see whether a point is inside the sphere wall object.
 * \param[in,out] (x,y,z) the vector to test.
 * \return True if the point is inside, false if the point is outside. */
bool wall_sphere::point_inside(double x,double y,double z) {
        return (x-xc)*(x-xc)+(y-yc)*(y-yc)+(z-zc)*(z-zc)<rc*rc;
}

/** Cuts a cell by the sphere wall object. The spherical wall is approximated by
 * a single plane applied at the point on the sphere which is closest to the center
 * of the cell. This works well for particle arrangements that are packed against
 * the wall, but loses accuracy for sparse particle distributions.
 * \param[in,out] c the Voronoi cell to be cut.
 * \param[in] (x,y,z) the location of the Voronoi cell.
 * \return True if the cell still exists, false if the cell is deleted. */
template<class v_cell>
bool wall_sphere::cut_cell_base(v_cell &c,double x,double y,double z) {
        double xd=x-xc,yd=y-yc,zd=z-zc,dq=xd*xd+yd*yd+zd*zd;
        if (dq>1e-5) {
                dq=2*(sqrt(dq)*rc-dq);
                return c.nplane(xd,yd,zd,dq,w_id);
        }
        return true;
}

/** Tests to see whether a point is inside the plane wall object.
 * \param[in] (x,y,z) the vector to test.
 * \return True if the point is inside, false if the point is outside. */
bool wall_plane::point_inside(double x,double y,double z) {
        return x*xc+y*yc+z*zc<ac;
}

/** Cuts a cell by the plane wall object.
 * \param[in,out] c the Voronoi cell to be cut.
 * \param[in] (x,y,z) the location of the Voronoi cell.
 * \return True if the cell still exists, false if the cell is deleted. */
template<class v_cell>
bool wall_plane::cut_cell_base(v_cell &c,double x,double y,double z) {
        double dq=2*(ac-x*xc-y*yc-z*zc);
        return c.nplane(xc,yc,zc,dq,w_id);
}

/** Tests to see whether a point is inside the cylindrical wall object.
 * \param[in] (x,y,z) the vector to test.
 * \return True if the point is inside, false if the point is outside. */
bool wall_cylinder::point_inside(double x,double y,double z) {
        double xd=x-xc,yd=y-yc,zd=z-zc;
        double pa=(xd*xa+yd*ya+zd*za)*asi;
        xd-=xa*pa;yd-=ya*pa;zd-=za*pa;
        return xd*xd+yd*yd+zd*zd<rc*rc;
}

/** Cuts a cell by the cylindrical wall object. The cylindrical wall is
 * approximated by a single plane applied at the point on the cylinder which is
 * closest to the center of the cell. This works well for particle arrangements
 * that are packed against the wall, but loses accuracy for sparse particle
 * distributions.
 * \param[in,out] c the Voronoi cell to be cut.
 * \param[in] (x,y,z) the location of the Voronoi cell.
 * \return True if the cell still exists, false if the cell is deleted. */
template<class v_cell>
bool wall_cylinder::cut_cell_base(v_cell &c,double x,double y,double z) {
        double xd=x-xc,yd=y-yc,zd=z-zc,pa=(xd*xa+yd*ya+zd*za)*asi;
        xd-=xa*pa;yd-=ya*pa;zd-=za*pa;
        pa=xd*xd+yd*yd+zd*zd;
        if(pa>1e-5) {
                pa=2*(sqrt(pa)*rc-pa);
                return c.nplane(xd,yd,zd,pa,w_id);
        }
        return true;
}

/** Tests to see whether a point is inside the cone wall object.
 * \param[in] (x,y,z) the vector to test.
 * \return True if the point is inside, false if the point is outside. */
bool wall_cone::point_inside(double x,double y,double z) {
        double xd=x-xc,yd=y-yc,zd=z-zc,pa=(xd*xa+yd*ya+zd*za)*asi;
        xd-=xa*pa;yd-=ya*pa;zd-=za*pa;
        pa*=gra;
        if (pa<0) return false;
        pa*=pa;
        return xd*xd+yd*yd+zd*zd<pa;
}

/** Cuts a cell by the cone wall object. The conical wall is
 * approximated by a single plane applied at the point on the cone which is
 * closest to the center of the cell. This works well for particle arrangements
 * that are packed against the wall, but loses accuracy for sparse particle
 * distributions.
 * \param[in,out] c the Voronoi cell to be cut.
 * \param[in] (x,y,z) the location of the Voronoi cell.
 * \return True if the cell still exists, false if the cell is deleted. */
template<class v_cell>
bool wall_cone::cut_cell_base(v_cell &c,double x,double y,double z) {
        double xd=x-xc,yd=y-yc,zd=z-zc,xf,yf,zf,q,pa=(xd*xa+yd*ya+zd*za)*asi;
        xd-=xa*pa;yd-=ya*pa;zd-=za*pa;
        pa=xd*xd+yd*yd+zd*zd;
        if(pa>1e-5) {
                pa=1/sqrt(pa);
                q=sqrt(asi);
                xf=-sang*q*xa+cang*pa*xd;
                yf=-sang*q*ya+cang*pa*yd;
                zf=-sang*q*za+cang*pa*zd;
                pa=2*(xf*(xc-x)+yf*(yc-y)+zf*(zc-z));
                return c.nplane(xf,yf,zf,pa,w_id);
        }
        return true;
}

// Explicit instantiation
template bool wall_sphere::cut_cell_base(voronoicell&,double,double,double);
template bool wall_sphere::cut_cell_base(voronoicell_neighbor&,double,double,double);
template bool wall_plane::cut_cell_base(voronoicell&,double,double,double);
template bool wall_plane::cut_cell_base(voronoicell_neighbor&,double,double,double);
template bool wall_cylinder::cut_cell_base(voronoicell&,double,double,double);
template bool wall_cylinder::cut_cell_base(voronoicell_neighbor&,double,double,double);
template bool wall_cone::cut_cell_base(voronoicell&,double,double,double);
template bool wall_cone::cut_cell_base(voronoicell_neighbor&,double,double,double);

}
Revision:	979
Committed:	Thu Oct 18 23:40:32 2018 UTC (6 years, 7 months ago) by francois
File size:	5220 byte(s)
Log Message:	creation de polycristaux avec OCC
#	User	Rev	Content
1	francois	979	// Voro++, a 3D cell-based Voronoi library
2			//
3			// Author : Chris H. Rycroft (LBL / UC Berkeley)
4			// Email : chr@alum.mit.edu
5			// Date : August 30th 2011
6
7			/** \file wall.cc
8			* \brief Function implementations for the derived wall classes. */
9
10			#include "wall.hh"
11
12			namespace voro {
13
14			/** Tests to see whether a point is inside the sphere wall object.
15			* \param[in,out] (x,y,z) the vector to test.
16			* \return True if the point is inside, false if the point is outside. */
17			bool wall_sphere::point_inside(double x,double y,double z) {
18			return (x-xc)(x-xc)+(y-yc)(y-yc)+(z-zc)(z-zc)<rcrc;
19			}
20
21			/** Cuts a cell by the sphere wall object. The spherical wall is approximated by
22			* a single plane applied at the point on the sphere which is closest to the center
23			* of the cell. This works well for particle arrangements that are packed against
24			* the wall, but loses accuracy for sparse particle distributions.
25			* \param[in,out] c the Voronoi cell to be cut.
26			* \param[in] (x,y,z) the location of the Voronoi cell.
27			* \return True if the cell still exists, false if the cell is deleted. */
28			template<class v_cell>
29			bool wall_sphere::cut_cell_base(v_cell &c,double x,double y,double z) {
30			double xd=x-xc,yd=y-yc,zd=z-zc,dq=xdxd+ydyd+zd*zd;
31			if (dq>1e-5) {
32			dq=2(sqrt(dq)rc-dq);
33			return c.nplane(xd,yd,zd,dq,w_id);
34			}
35			return true;
36			}
37
38			/** Tests to see whether a point is inside the plane wall object.
39			* \param[in] (x,y,z) the vector to test.
40			* \return True if the point is inside, false if the point is outside. */
41			bool wall_plane::point_inside(double x,double y,double z) {
42			return xxc+yyc+z*zc<ac;
43			}
44
45			/** Cuts a cell by the plane wall object.
46			* \param[in,out] c the Voronoi cell to be cut.
47			* \param[in] (x,y,z) the location of the Voronoi cell.
48			* \return True if the cell still exists, false if the cell is deleted. */
49			template<class v_cell>
50			bool wall_plane::cut_cell_base(v_cell &c,double x,double y,double z) {
51			double dq=2(ac-xxc-yyc-zzc);
52			return c.nplane(xc,yc,zc,dq,w_id);
53			}
54
55			/** Tests to see whether a point is inside the cylindrical wall object.
56			* \param[in] (x,y,z) the vector to test.
57			* \return True if the point is inside, false if the point is outside. */
58			bool wall_cylinder::point_inside(double x,double y,double z) {
59			double xd=x-xc,yd=y-yc,zd=z-zc;
60			double pa=(xdxa+ydya+zdza)asi;
61			xd-=xapa;yd-=yapa;zd-=za*pa;
62			return xdxd+ydyd+zdzd<rcrc;
63			}
64
65			/** Cuts a cell by the cylindrical wall object. The cylindrical wall is
66			* approximated by a single plane applied at the point on the cylinder which is
67			* closest to the center of the cell. This works well for particle arrangements
68			* that are packed against the wall, but loses accuracy for sparse particle
69			* distributions.
70			* \param[in,out] c the Voronoi cell to be cut.
71			* \param[in] (x,y,z) the location of the Voronoi cell.
72			* \return True if the cell still exists, false if the cell is deleted. */
73			template<class v_cell>
74			bool wall_cylinder::cut_cell_base(v_cell &c,double x,double y,double z) {
75			double xd=x-xc,yd=y-yc,zd=z-zc,pa=(xdxa+ydya+zdza)asi;
76			xd-=xapa;yd-=yapa;zd-=za*pa;
77			pa=xdxd+ydyd+zd*zd;
78			if(pa>1e-5) {
79			pa=2(sqrt(pa)rc-pa);
80			return c.nplane(xd,yd,zd,pa,w_id);
81			}
82			return true;
83			}
84
85			/** Tests to see whether a point is inside the cone wall object.
86			* \param[in] (x,y,z) the vector to test.
87			* \return True if the point is inside, false if the point is outside. */
88			bool wall_cone::point_inside(double x,double y,double z) {
89			double xd=x-xc,yd=y-yc,zd=z-zc,pa=(xdxa+ydya+zdza)asi;
90			xd-=xapa;yd-=yapa;zd-=za*pa;
91			pa*=gra;
92			if (pa<0) return false;
93			pa*=pa;
94			return xdxd+ydyd+zd*zd<pa;
95			}
96
97			/** Cuts a cell by the cone wall object. The conical wall is
98			* approximated by a single plane applied at the point on the cone which is
99			* closest to the center of the cell. This works well for particle arrangements
100			* that are packed against the wall, but loses accuracy for sparse particle
101			* distributions.
102			* \param[in,out] c the Voronoi cell to be cut.
103			* \param[in] (x,y,z) the location of the Voronoi cell.
104			* \return True if the cell still exists, false if the cell is deleted. */
105			template<class v_cell>
106			bool wall_cone::cut_cell_base(v_cell &c,double x,double y,double z) {
107			double xd=x-xc,yd=y-yc,zd=z-zc,xf,yf,zf,q,pa=(xdxa+ydya+zdza)asi;
108			xd-=xapa;yd-=yapa;zd-=za*pa;
109			pa=xdxd+ydyd+zd*zd;
110			if(pa>1e-5) {
111			pa=1/sqrt(pa);
112			q=sqrt(asi);
113			xf=-sangqxa+cangpaxd;
114			yf=-sangqya+cangpayd;
115			zf=-sangqza+cangpazd;
116			pa=2(xf(xc-x)+yf(yc-y)+zf(zc-z));
117			return c.nplane(xf,yf,zf,pa,w_id);
118			}
119			return true;
120			}
121
122			// Explicit instantiation
123			template bool wall_sphere::cut_cell_base(voronoicell&,double,double,double);
124			template bool wall_sphere::cut_cell_base(voronoicell_neighbor&,double,double,double);
125			template bool wall_plane::cut_cell_base(voronoicell&,double,double,double);
126			template bool wall_plane::cut_cell_base(voronoicell_neighbor&,double,double,double);
127			template bool wall_cylinder::cut_cell_base(voronoicell&,double,double,double);
128			template bool wall_cylinder::cut_cell_base(voronoicell_neighbor&,double,double,double);
129			template bool wall_cone::cut_cell_base(voronoicell&,double,double,double);
130			template bool wall_cone::cut_cell_base(voronoicell_neighbor&,double,double,double);
131
132			}