Science on Tech Explorer

圆形坠落模拟算法设计

Wed, 25 Jul 2012 00:00:00 +0000

目标：实现一个算法，模拟在一个封闭二维区域，圆形小球朝给定方向坠落的过程，实现二维区域的紧密填充。

像下面这样：

难点，及其简单解决：

1.如何把粒子移动尽可能远？

图中的粒子i，能往下移动多远？一般情况,碰撞？边界？

一个简单解法：

注意如下事实：判断两个粒子是否重叠，判断粒子是否和边界线重叠，都是十分容易的。

据此定义函数 f (r) 如下

考虑把粒子往前推的过程，最开始 f (r) = 1，当推进到一个临界值后，f (r) = 0,

因此，f (r) 的函数图像是：

代码如下：

//找出一个点，在一个方向上最远可以前进多远，限于一步之内，该点可以不属于这个mesh，如果不能前进，返回false
bool most_advance(Point* p,double direc_x,double direc_y,Mesh *mesh,double &x,double &y,double &best){
 //二分法求根。
 if(!(p->can_move))
 return false;
 double low_radio=0.0;
 double high_radio=1.0;//mesh->x_num + mesh->y_num;
 best=low_radio;
 bool at_least_one_success=false;
 double mid;
 double step=mesh->get_step();
 Point new_point;
 while(fabs(low_radio-high_radio)>0.000001){
 mid=(low_radio+high_radio)/2;
 new_point.x=p->x + direc_x * step * mid;
 new_point.y=p->y + direc_y * step * mid;
 bool result=mesh->can_move_point(p,new_point);
 if(result){
 low_radio=mid;
 best=max(best,mid);
 at_least_one_success=true;
 }else{
 high_radio=mid;
 }
 //cout<<"mid="<<mid<<" best="<<best<<" result="<<result<<endl;
 }
 
 if(!at_least_one_success)
 return false;
 
 x=p->x + direc_x * step * best;
 y=p->y + direc_y * step * best;
 return true;
}

【旧代码】2010年用matlab做的几张理想流场的图

Tue, 15 Nov 2011 00:00:00 +0000

就不贴matlab代码了，图比较大。

分别是：

无环量流动
有环量流动,两个滞止点
有环量流动,一个滞止点
有环量流动,柱面外一个滞止点

【旧代码】fortran中的指针实现链表的代码

Tue, 15 Nov 2011 00:00:00 +0000

我不喜欢fortran，

奇怪的词法规则（竟然不用空格分开token），

io操作竟然是语言的一部分（这种非本质的东西像C那样用库来扩展多好）

。。。

program link
implicit none
type node
 character(20) name
 integer id
 integer score
 type(node),pointer ::next
end type

integer,parameter::num=3
type(node),pointer ::students

call init_all(students,num)
call show_all(students)
print*,"now,we add a student"
call add_node(students)
call show_all(students)
print*,"now,we delete the student"
call del_node(students)
call show_all(students)

contains 
subroutine add_node(pos)
type(node),pointer ::pos,tmp
allocate(tmp)
tmp%name="abc"
tmp%id=1
tmp%score=100
print*,"please input name,id,end score of one students"
read*,tmp%name,tmp%id,tmp%score
if(associated(pos%next)) then
tmp%next=>pos%next
pos%next=>tmp
else 
nullify(tmp%next)
pos%next=>tmp
end if
end subroutine

subroutine del_node(pos)
type(node),pointer ::pos,next
next=>pos%next
if(associated(next%next)) then
pos%next=>next%next
deallocate(next)
else
nullify(pos%next)
deallocate(next)
end if
end subroutine

subroutine show_all(pos)
type(node),pointer ::pos,tmp
integer ::cnt
cnt=1
print*,"all students are:"
tmp=>pos
do while(associated(tmp))
print*,cnt,"th ",tmp%name,tmp%id,tmp%score
tmp=>tmp%next
cnt=cnt+1
end do
end subroutine

subroutine init_all(pos,num)
type(node),pointer ::pos,tmp,walk
integer num
integer i

allocate(tmp)
nullify(tmp%next)
call add_node(tmp)
pos=>tmp%next
deallocate(tmp)
walk=>pos
do i=1,num-1
call add_node(walk)
walk=>walk%next
end do
end subroutine

end program link

【旧代码】传热过程数值模拟

Tue, 15 Nov 2011 00:00:00 +0000

传热过程数值模拟（《传热学》实验指导书第四部分第一题，第一，第二类边界条件）

问题背景
#

2010年十月写的旧代码。

第一类边界条件是给定边界温度。

第二类是对流边界。

区域都是如下形状的:

 --------------------------------
| |
| |
| |
| ----------------------
| | 
| | 
| | 
| |
| | 
| |
| | 
| |
 ---------

用C++纯属蛋疼。

第一类边界条件
#

第一类边界条件：

/*
 * 等温边界
 */
#include<iostream>
#include<cmath>
using namespace std;
const double out_temp=30.0;//外边界温度
const double in_temp=0.0;//内边界温度
const double accuracy=0.00000001;//精度
const double lambda=0.53;//导热系数

const int width=15;//上部点阵宽度
const int width_bottom=4;//下部点阵宽度
const int height=4;//上部点阵高度
const int height_bottom=7;//下部点阵高度
/*
//另一组参数
const int width=16;
const int width_bottom=6;
const int height=6;
const int height_bottom=6;
*/
//总共点数
const int num_of_points=width*height+width_bottom*height_bottom;
//单个点
class point
{
 public:
 double temp;//温度
 int up;//数组下标
 int down;
 int left;
 int right;

 point(){
 temp=0.0;//初始化成0摄氏度
 up=down=right=left=0;
 }
};

ostream & operator<<(ostream & src_stream,const point & src){
 src_stream<<"temp="<<src.temp;
 src_stream<<" up="<<src.up<<" down="<<src.down;
 src_stream<<" left="<<src.left<<" right="<<src.right;
 return src_stream;
}

void print_grid(point * points){//输出网格各点的温度
 cout<<endl;
 for(int position=0;position>=0;position=points[position].down){
 for(int tmp=position;tmp>=0;tmp=points[tmp].right){
 cout.width(10);
 cout<<points[tmp].temp;
 }
 cout<<endl<<endl<<endl<<endl;
 }
}

double calc_direction(point * points,int direction,double &opposit_weight){
 //计算给定方向邻点的温度和反方向的权重。
 switch (direction) {
 case -1:
 return out_temp;
 break;
 case -2:
 return in_temp;
 break;
 case -3:
 opposit_weight*=2;
 return 0.0;
 break;
 default:
 return points[direction].temp;
 }
}

void compu_point(point * points,int now){
 //根据周围四个点算出指定点的温度
 double left_temp;
 double right_temp;
 double up_temp;
 double down_temp;
 double up_wight=0.25;//上方权重,默认0.25
 double down_wight=0.25;
 double left_wight=0.25;
 double right_wight=0.25;
 left_temp=calc_direction(points,points[now].left,right_wight);
 right_temp=calc_direction(points,points[now].right,left_wight);
 up_temp=calc_direction(points,points[now].up,down_wight);
 down_temp=calc_direction(points,points[now].down,up_wight);
 points[now].temp=left_temp*left_wight+right_temp*right_wight+up_temp*up_wight+down_temp*down_wight;
}

void rec_walk(point * points){
 // "左=>右"里嵌"上=>下"遍历计算
 for(int position=0;position>=0;position=points[position].right)
 for(int tmp=position;tmp>=0;tmp=points[tmp].down)
 compu_point(points,tmp);
}

void heat_rate(point * points){
 //计算导热量
 double out_sum=0.0;
 double in_sum=0.0;
 //外边界
 int pos=0;
 double tmp=0.0;
 for(;points[pos].right>=0;pos=points[pos].right){
 tmp=out_temp - points[pos].temp ;
 if(points[pos].right<=0)
 out_sum += 0.5*tmp;
 else
 out_sum+=tmp;
 }
 for(pos=points[0].down;points[pos].down>=0;pos=points[pos].down){
 tmp=out_temp - points[pos].temp ;
 if(points[pos].down<=0)
 out_sum += 0.5*tmp;
 else
 out_sum+=tmp;
 }
 //内边界
 for(pos=num_of_points-1;points[pos].right<0;pos=points[pos].up){
 tmp = points[pos].temp - in_temp ;
 if(points[pos].down<=0)
 in_sum += 0.5*tmp;
 else
 in_sum +=tmp;
 }
 for(pos=points[pos].right;points[pos].right>=0;pos=points[pos].right){
 tmp = points[pos].temp - in_temp;
 if(points[pos].right<=0)
 in_sum += 0.5*tmp;
 else
 in_sum += tmp;
 }
 out_sum*=lambda;
 in_sum*=lambda;
 cout<<"外边界导热量="<<out_sum;
 cout<<"\n内边界导热量="<<in_sum;
 cout<<"\n误差="<<(in_sum-out_sum)/in_sum*100<<"%"<<endl;
}

void init_grid(point * points){
 //初始化网格
 int position=0;
 //初始化最上面的边
 for(int i=0;i<width;i++){
 points[i].up=-1;//-1表示外边界，-2内边界,-3表示绝热
 points[i].left=i-1;
 points[i].right=i+1;
 points[i].down=i+width;
 position=i;
 }
 points[0].left=-1;//等温
 points[width-1].right=-3;//绝热

 //上面区域
 for(int i=1;i<height;i++){
 for(int j=0;j<width;j++){
 points[i*width+j].up =i*width+j-width;
 points[i*width+j].left =i*width+j-1;
 points[i*width+j].right=i*width+j+1;
 points[i*width+j].down =i*width+j+width;
 position=i*width+j;
 }
 points[i*width+0].left=-1;
 points[i*width+width-1].right=-3;
 }

 position-=width;
 position++;
 for(int j=width_bottom;j<width;j++){
 points[position+j].down =-2;//内边界
 }
 position+=width;

 //下面区域
 for(int i=0;i<height_bottom;i++){
 for(int j=0;j<width_bottom;j++){
 if(i)
 points[position+i*width_bottom+j].up=position+i*width_bottom+j-width_bottom;
 else
 points[position+i*width_bottom+j].up=position+i*width_bottom+j-width;

 points[position+i*width_bottom+j].left=position+i*width_bottom+j-1;
 points[position+i*width_bottom+j].right=position+i*width_bottom+j+1;
 points[position+i*width_bottom+j].down=position+i*width_bottom+j+width_bottom;
 }
 points[position+i*width_bottom+0].left=-1;
 points[position+i*width_bottom+width_bottom-1].right=-2;
 }

 //下边界
 position+=width_bottom*height_bottom;
 position-=width_bottom;
 for(int j=0;j<width_bottom;j++){
 points[position+j].down=-3;
 }
 position+=width_bottom;
}

int main(){
 point * points=new point[num_of_points];
 init_grid(points);
 //初始化完。输出看看。
 //for(int i=0;i<num_of_points;i++)
 // cout<<i<<" => "<<points[i]<<'\n';
 cout<<"初始温度分布（最外层和最内层没有显示）：\n";
 print_grid(points);
 //开始迭代计算
 double diff=out_temp;
 int times=0;
 for(;diff>out_temp*accuracy;times++){
 //"上=>下" 里嵌 "左=>右"遍历计算
 diff=0.0;
 for(int now=0;now<num_of_points;now++){
 double tmp=points[now].temp;
 compu_point(points,now);
 tmp=abs(tmp-points[now].temp);
 diff = diff>tmp?diff:tmp;
 }
 }
 cout<<"\n迭代计算"<<times<<"次得到的温度分布（最外层和最内层没有显示）：\n";
 print_grid(points);
 heat_rate(points);
 delete [] points;
 return 0;
}

第二类边界条件
#

第二类边界条件：

/*
 * 对流边界
 */
#include<iostream>
#include<cmath>
using namespace std;
const double out_temp=30.0;//外边界温度
const double out_h=10.0;//外边界对流换热系数
const double in_temp=10.0;//内边界温度
const double in_h=4
.0;//内边界对流换热系数
const double accuracy=0.00000001;//精度
const double lambda=0.53;//导热系数

const int width=15;//上部点阵宽度
const int width_bottom=4;//下部点阵宽度
const int height=4;//上部点阵高度
const int height_bottom=7;//下部点阵高度

const double delta_x=3.0/(2*width+1);
const double out_Bi=out_h*delta_x/lambda;//外表面网格Bi数
const double in_Bi = in_h*delta_x/lambda;//内表面网格Bi数
/*
//另一组参数
const int width=150;
const int width_bottom=40;
const int height=40;
const int height_bottom=70;
*/
//总共点数
const int num_of_points=width*height+width_bottom*height_bottom;
//单个点
class point
{
 public:
 double temp;//温度
 int up;//数组下标
 int down;
 int left;
 int right;

 point(){
 temp=0.0;//初始化成0摄氏度
 up=down=right=left=0;
 }
};

ostream & operator<<(ostream & src_stream,const point & src){
 src_stream<<"temp="<<src.temp;
 src_stream<<" up="<<src.up<<" down="<<src.down;
 src_stream<<" left="<<src.left<<" right="<<src.right;
 return src_stream;
}

void print_grid(point * points){//输出网格各点的温度
 cout<<endl;
 for(int position=0;position>=0;position=points[position].down){
 for(int tmp=position;tmp>=0;tmp=points[tmp].right){
 cout.width(10);
 cout<<points[tmp].temp;
 }
 cout<<endl<<endl<<endl<<endl;
 }
}

void dump_all(point * points){//便于调试
 for(int i=0;i<num_of_points;i++)
 cout<<i<<" => "<<points[i]<<'\n';
}

double calc_direction(point * points,int direction,double &opposit_weight,double &this_weight){
 //计算给定方向邻点的温度和反方向的权重。
 switch (direction) {
 case -1://外边界
 this_weight*=out_Bi;
 return out_temp;
 break;
 case -2://内边界
 this_weight*=in_Bi;
 return in_temp;
 break;
 case -3://绝热
 this_weight=0.0;
 opposit_weight*=2;
 return 0.0;
 break;
 default:
 return points[direction].temp;
 }
}

void compu_point(point * points,int now){
 //根据周围四个点算出指定点的温度
 double left_temp;
 double right_temp;
 double up_temp;
 double down_temp;
 double up_wight=1;//上方权重
 double down_wight=1;
 double left_wight=1;
 double right_wight=1;
 left_temp=calc_direction(points,points[now].left,right_wight,left_wight);
 right_temp=calc_direction(points,points[now].right,left_wight,right_wight);
 up_temp=calc_direction(points,points[now].up,down_wight,up_wight);
 down_temp=calc_direction(points,points[now].down,up_wight,down_wight);
 double Bi_sum=up_wight+down_wight+right_wight+left_wight;
 points[now].temp=(left_temp*left_wight+right_temp*right_wight+up_temp*up_wight+down_temp*down_wight)/Bi_sum;
}

void rec_walk(point * points){
 // "左=>右"里嵌"上=>下"遍历计算
 for(int position=0;position>=0;position=points[position].right)
 for(int tmp=position;tmp>=0;tmp=points[tmp].down)
 compu_point(points,tmp);
}

void heat_rate(point * points){
 //计算导热量
 double out_sum=0.0;
 double in_sum=0.0;
 //外边界
 int pos=0;
 double tmp=0.0;
 for(;points[pos].right>=0;pos=points[pos].right){
 tmp=out_temp - points[pos].temp ;
 if(points[pos].right<=0)
 out_sum += 0.5*tmp;
 else
 out_sum+=tmp;
 }
 for(pos=points[0].down;points[pos].down>=0;pos=points[pos].down){
 tmp=out_temp - points[pos].temp ;
 if(points[pos].down<=0)
 out_sum += 0.5*tmp;
 else
 out_sum+=tmp;
 }
 //内边界
 for(pos=num_of_points-1;points[pos].right<0;pos=points[pos].up){
 tmp = points[pos].temp - in_temp ;
 if(points[pos].down<=0)
 in_sum += 0.5*tmp;
 else
 in_sum +=tmp;
 }
 for(pos=points[pos].right;points[pos].right>=0;pos=points[pos].right){
 tmp = points[pos].temp - in_temp;
 if(points[pos].right<=0)
 in_sum += 0.5*tmp;
 else
 in_sum += tmp;
 }
 out_sum*=out_h*delta_x;
 in_sum *=in_h *delta_x;
 cout<<"外边界导热量="<<out_sum;
 cout<<"\n内边界导热量="<<in_sum;
 cout<<"\n误差="<<(in_sum-out_sum)/in_sum*100<<"%"<<endl;
}

void init_grid(point * points){
 //初始化网格
 int position=0;
 //初始化最上面的边
 for(int i=0;i<width;i++){
 points[i].up=-1;//-1表示外边界，-2内边界,-3表示绝热
 points[i].left=i-1;
 points[i].right=i+1;
 points[i].down=i+width;
 position=i;
 }
 points[0].left=-1;//对流
 points[width-1].right=-3;//绝热

 //上面区域
 for(int i=1;i<height;i++){
 for(int j=0;j<width;j++){
 points[i*width+j].up =i*width+j-width;
 points[i*width+j].left =i*width+j-1;
 points[i*width+j].right=i*width+j+1;
 points[i*width+j].down =i*width+j+width;
 position=i*width+j;
 }
 points[i*width+0].left=-1;
 points[i*width+width-1].right=-3;
 }

 position-=width;
 position++;
 for(int j=width_bottom;j<width;j++){
 points[position+j].down =-2;//内边界
 }
 position+=width;

 //下面区域
 for(int i=0;i<height_bottom;i++){
 for(int j=0;j<width_bottom;j++){
 if(i)
 points[position+i*width_bottom+j].up=position+i*width_bottom+j-width_bottom;
 else
 points[position+i*width_bottom+j].up=position+i*width_bottom+j-width;

 points[position+i*width_bottom+j].left=position+i*width_bottom+j-1;
 points[position+i*width_bottom+j].right=position+i*width_bottom+j+1;
 points[position+i*width_bottom+j].down=position+i*width_bottom+j+width_bottom;
 }
 points[position+i*width_bottom+0].left=-1;
 points[position+i*width_bottom+width_bottom-1].right=-2;
 }

 //下边界
 position+=width_bottom*height_bottom;
 position-=width_bottom;
 for(int j=0;j<width_bottom;j++){
 points[position+j].down=-3;
 }
 position+=width_bottom;
}

int main(){
 point * points=new point[num_of_points];
 init_grid(points);
 //dump_all(points);
 cout<<"初始温度分布（最外层和最内层没有显示）：\n";
 print_grid(points);
 //开始迭代计算
 double diff=out_temp;
 int times=0;
 for(;diff>out_temp*accuracy;times++){
 //"上=>下" 里嵌 "左=>右"遍历计算
 diff=0.0;
 for(int now=0;now<num_of_points;now++){
 double tmp=points[now].temp;
 compu_point(points,now);
 tmp=abs(tmp-points[now].temp);
 diff = diff>tmp?diff:tmp;
 }
 }
 cout<<"\n迭代计算"<<times<<"次得到的温度分布（最外层和最内层没有显示）：\n";
 print_grid(points);
 heat_rate(points);
 delete [] points;
 return 0;
}

找出平面上的特殊无向图中的所有三角形的算法

Mon, 22 Aug 2011 00:00:00 +0000

问题提出背景：在非结构化三角形网格生成过程中，若采用前沿推进法，在推进过程中是不好构造三角形的（而且也没有要），最好在把所有的边都连好以后再找出所有三角形，于是提出了问题：在由三角形构成的平面无向图中如何找出所有三角形？

网格如图：

要注意的是，这个无向图很特殊，

1.这个图在平面上。

2.这个图是由三角形构成的（如果不是由三角行构成，那这个网格就没有用处了）。

我的算法如下，伪代码表示:

foreach(点 p in所有的点){
 foreach(点 np in p的所有邻居点){
 foreach(点 nnpin np的所有邻居点){
 if( p,np,nnp三点两两不重合
 && p,np,nnp三点两两相连
 && p==uniqPointOfTriangle(p,np,nnp)
 && uniqPointOf2Points(np,nnp)==np)  ){
 输出p,np,nnp构成的三角形。
 }
 }
 }
}

算法的关键在于uniqPointOfTriangle( )和uniqPointOf2Points( )这两个函数。

这两个函数的原理相同， uniqPointOfTriangle( )uniqPointOf2Points（）唯一的作用是

它的一个性质：输出和输入参数的顺序无关。

如果没有这两个函数的判断，每个三角形会被输出6次，而有了这两个函数的限制后，强制在3个元素的6中排列中指定1种，

就消除了重复。

uniqPointOfTriangle的实现我想了一个邪恶的办法:

struct point * uniqPointOfTriangle(struct point * a,struct point * b ,struct point * c){
 /*返回一个3个点的特征点，即不管a,b,c的次序，这个函数返回结果唯一*/
 struct point * p=NULL;

 //我直接比较指针大小，O(∩_∩)O哈哈~
 p=(a > b?a:b);
 return p > c?p:c;
}

还有一种正常一点的办法：

思路是：对三个点，先在x方向找出最小的点，若有一个，直接返回；若有两个，找出y方向小的那个返回。

另外，这样输出的三角形中其内部可能有其他的点，若要消除，再加上一层过滤，去除掉那些”p有邻点在p,np,nnp三角形中的”情况即可，

这是因为这个图由三角形构成的特殊性质，如果有在p–np–nnp中有点，假设这些点都不和p相连，那么，

这些点和p-np, p-nnp构成的区域必然不是三角形！所以可以这样干。

Science on Tech Explorer

圆形坠落模拟算法设计

【旧代码】2010年用matlab做的几张理想流场的图

【旧代码】fortran中的指针实现链表的代码

【旧代码】传热过程数值模拟

问题背景 #

第一类边界条件 #

第二类边界条件 #

找出平面上的特殊无向图中的所有三角形的算法

问题背景
#

第一类边界条件
#

第二类边界条件
#