C code for particle interaction in 2d - c

Question

Imagine that you have a particle in each coordinate of a 2D Cartesian plane. Each particle emits a substance that difuses in all directions, with a decay over distance based on a Bessel function, and the other particles each absorb this substance. Thus all particles at same distance from a given particle have the same influence on that particle. Something such as
I'm calculating such an interaction using this code:
EDIT:31/03: Complete code for both.
#include <stdio.h> // para as rotinas de entrada e saída
#include <stdlib.h> //
#include <stdarg.h> // para importar os elementos da linha de comando
#include <math.h>
#include <string.h>
#include <ctype.h>
#include <malloc.h>
#include <time.h>
#include"ran1.c"
#include"bessel.c"
#define tmax 90000
#define N 50
#define beta 0.001
#define sigma 0.001
#define pi acos(-1.0)
#define trans 50000
#define epsilon 0.1
void condicoes_iniciais(double **xold,double **yold,double **a)
{
int l,j;
long idum=-120534;
for(l=0;l<= N; l++)
{
for(j=0;j<= N; j++)
{
a[l][j]=5.0;
}
}
for(l=0;l<= N; l++)
{
for(j=0;j<= N; j++)
{
while(a[l][j]>4.4)
a[l][j]=4.1+ran1(& idum);
}
}
for(l=0;l<= N; l++)
{
for(j=0;j<= N; j++)
{
xold[l][j]=0.1*ran1(& idum);
}
}
for(l=0;l<= N; l++)
{
for(j=0;j<= N; j++)
{
yold[l][j]=0.1*ran1(& idum);
}
}
}
void Matriz_Bessel(double **Bess,double gama)
{
int x,y;
double r;
for(x=0;x<=N;x++)
{
for(y=0;y<=N;y++)
{
if(y!=0 || x!=0)
{
r = gama*sqrt(x*x +y*y);
Bess[x][y] = bessk0(r);
}
}
}
}
void acoplamento(int x, int y,double **xold, double *Acopl,double **Bess)
{
int j, i, h, k,xdist, ydist;
int Nmeio = N/2;
double Xf;
Xf = 0;
for(i=0;i<=N;i++)
{
for(j=0;j<=N;j++)
{
h = x+i;
k = y+j;
ydist = j;
xdist = i;
if(i>Nmeio)
{
h = x +i;
xdist = (N+1) -h +x;
}
if(h>N)
{
h=h-(N+1);
xdist = x-h;
if(xdist >Nmeio){xdist = i;
}
}
if(j>Nmeio)
{
k = y +j;
ydist = (N+1) -k +y;
}
if(k>N)
{
k=k-(N+1);
ydist = y-k;
if(ydist >Nmeio){ydist = j;
}
}
if(ydist!=0 || xdist!=0)
{
Xf = Xf +Bess[xdist][ydist]*xold[h][k];
}
}
}
*Acopl = Xf;
}
void constante(double *c, double gama, double **Bess){
double soma;
int x, y;
soma = 0;
for(x=0;x<=(N/2);x++)
{
for(y=0;y<=(N/2);y++)
{
if(y!=0 || x!=0)
{
soma = soma +Bess[x][y];
}
}
}
*c = (1/(4*soma));
}
int main(int argc, char* argv[])
{
double **xold, **xnew, **yold, **ynew, **a;
double gama, C;
int x,y;
int t,i;
double Mn, acopl;
char arqnome[100];
FILE *fout;
double **Bess;
Bess= (double**)malloc(sizeof(double*)*(N+3));
for(i=0; i<(N+3); i++){Bess[i] = (double*)malloc(sizeof(double)* (N+3));}
xold= (double**)malloc(sizeof(double*)*(N+3));
for(i=0; i<(N+3); i++){xold[i] = (double*)malloc(sizeof(double)* (N+3));}
yold= (double**)malloc(sizeof(double*)*(N+3));
for(i=0; i<(N+3); i++){yold[i] = (double*)malloc(sizeof(double)*(N+3));}
xnew= (double**)malloc(sizeof(double*)*(N+3));
for(i=0; i<(N+3); i++){xnew[i] = (double*)malloc(sizeof(double)*(N+3));}
ynew= (double**)malloc(sizeof(double*)*(N+3));
for(i=0; i<(N+3); i++){ynew[i] = (double*)malloc(sizeof(double)*(N+3));}
a= (double**)malloc(sizeof(double*)*(N+3));
for(i=0; i<(N+3); i++){a[i] = (double*)malloc(sizeof(double)*(N+3));}
srand (time(NULL));
gama = 0.005;
sprintf(arqnome,"serie_%.3f_%.3f.dat",gama,epsilon);
fout = fopen(arqnome,"w");
Matriz_Bessel(Bess,gama);
condicoes_iniciais(xold,yold,a);
a[0][0] = 4.1;
a[N/2][N/2] = 4.3;
constante(&C, gama,Bess);
for(t=0;t<=tmax;t++)
{
Mn = 0;
for(x=0;x<=N;x++)
{
for(y=0;y<=N;y++)
{
acoplamento(x,y,xold,&acopl,Bess);
xnew[x][y] = (a[x][y]/(1+xold[x][y]*xold[x][y])) +yold[x][y] + epsilon*C*acopl;
ynew[x][y] = yold[x][y] - sigma*xold[x][y] - beta;
Mn = Mn + xnew[x][y];
xold[x][y] = xnew[x][y];
yold[x][y] = ynew[x][y];
}
}
if(t>trans){fprintf(fout,"%d %f %f %f %f %f\n",(t-trans),xold[0][0],yold[0][0],xold[N/2][N/2],yold[N/2][N/2],Mn/((N+1)*(N+1)));}
}
return 0;
}
Bess[N][N] is the Bessel function for each radius, with is calculated using numerical recipes. This program take around 1 hour to finish.
With the sugestion of Francis i have
#include <fftw3.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include"bessel.c"
#include"ran1.c"
#define tmax 90000
#define beta 0.001
#define N 50
#define sigma 0.001
#define pi acos(-1.0)
#define trans 50000
#define epsilon 0.1
void condicoes_iniciais(double *xold,double *yold,double *a)
{
int l;
long idum=-120534;
for(l=0;l<= N*N; l++){
a[l]=5.0;}
for(l=0;l<= N*N; l++){
while(a[l]>4.4)
a[l]=4.1+ran1(& idum);}
for(l=0;l<=N* N; l++){
xold[l]=0.1*ran1(& idum);
yold[l]=0.1*ran1(& idum);}
a[0]=4.1;
a[N]=4.4;
}
void Matriz_Bessel(double *bessel,double gama)
{
int x,y,i,j;
double dist;
for(x=0,i=-N/2;x<N;x++,i++)
{
for(y=0,j=-N/2;y<N;y++,j++)
{
double dist=sqrt(i*i+j*j);
if(dist>0){
bessel[x*N+y]=bessk0(gama*dist);
}
else{
bessel[x*N+y]=1;
}
}
}
}
void constante(double *c, double *bessel)
{
int x;
int y;
double soma = 0;
for(x=0;x<N;x++){
for(y=0;y<N;y++){
soma = soma + bessel[x*N+y];
}}
*c =(1/(4*soma));
}
int main(int argc, char* argv[]){
double *xnew=fftw_malloc(sizeof(double)*N*N);
double *acopl=fftw_malloc(sizeof(double)*N*N);
double *xold=malloc(sizeof(double)*N*N);
double *yold = malloc(sizeof(double)*N*N);
double *a = malloc(sizeof(double)*N*N);
fftw_complex *xfourier;
xfourier = (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);
fftw_complex *aux;
aux= (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);
double *bessel= fftw_malloc(sizeof(double)*N*N);
fftw_complex *besself;
besself=fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);
double scale=1.0/(N*N);
int t,i;
double gama,Mn,C;
gama = 0.005;
char arqnome[1000];
FILE *fout;
sprintf(arqnome,"opt2_tamanho_plato_%.3f_%d.dat",gama,N);
fout = fopen(arqnome,"w");
//initial
printf("initial\n");
condicoes_iniciais(xold,yold,a);
//xold[(N/2)*N+N/2]=1;
// fftw_plan
printf("fftw_plan\n");
fftw_plan plan;
plan=fftw_plan_dft_r2c_2d(N, N, xnew, xfourier, FFTW_MEASURE | FFTW_PRESERVE_INPUT);
fftw_plan planb;
planb=fftw_plan_dft_r2c_2d(N, N,(double*) bessel, besself, FFTW_MEASURE);
fftw_plan plani;
plani=fftw_plan_dft_c2r_2d(N, N, aux, acopl, FFTW_MEASURE);
Matriz_Bessel(bessel,gama);
constante(&C, bessel);
fftw_execute(planb);
//time loop
printf("time loop\n");
for(t=0;t<=tmax;t++){
//convolution= products in fourier space
fftw_execute(plan);
for(i=0;i<N*(N/2+1);i++){
aux[i][0]=(xfourier[i][0]*besself[i][0]-xfourier[i][2]*besself[i][3]);
aux[i][4]=(xfourier[i][0]*besself[i][5]+xfourier[i][6]*besself[i][0]);
}
fftw_execute(plani);//xnew is updated
Mn = 0;
for(i=0;i<N*N;i++){
xnew[i]=(a[i]/(1+xold[i]*xold[i])) +yold[i] + epsilon*C* (acopl[i]/(double)(N*N));
yold[i] = yold[i] - sigma*xold[i] - beta;
Mn = Mn +xnew[i];
}
memcpy(xold,xnew,N*N*sizeof(double));
if(t>trans){fprintf(fout,"%d %f %f %f %f %f\n",(t-trans),xold[0],yold[0],xold[N],yold[N],Mn/((N+1)*(N+1)));}
}
printf("destroy\n");
fftw_destroy_plan(plan);
fftw_destroy_plan(plani);
fftw_destroy_plan(planb);
printf("free\n");
fftw_free(bessel);
fftw_free(xnew);
fftw_free(xold);
fftw_free(yold);
fftw_free(besself);
fftw_free(xfourier);
return 0;
}
With take around 1min to finish, but i got this results
The scale factor on fftw3 code have to be that value. I dont know how make it work.

Answer 1

The operation you are describing is called a convolution. Let f(x,y) be your periodic sources and B(x,y) the Bessel function. You are trying to compute :
Discretized on a grid of size N+1, it writes :
Since this sum is performed at all points, the complexity is very high : O(N^4). It means that the number of operations to performed is of the magnitude of N*N*N*N. How to reduce this complexity ?
If B(x,y) gets rapidly small as the distance increases, long-range interactions may be neglected and the window of the convolution may be reduced. It will affect the precision of the output and it may not be useful for your problem. Let N_W<<N be the size of this window. The sum now writes :
And the number of operations to be performed is about N*N*N_W*N_W<<N^4.
Yet, from a practical point of view, the kernel has to be very small to make the method described above very interesting. Since the Bessel functions decrease slowly (from Abramowitz and Stegun: Handbook of Mathematical Functions, p364) (approx 1/sqrt(x)), the previous method is unlikely to be successful.
According to the convolution theorem, the Discrete Fourier Transform may be applied to convolve periodic signals ! A convolution in distance space resumes to products of corresponding wavelength in the Fourier space.
The algorithm is the following :
1 Compute the DFT of f, named hatf
2 Compute the DFT of B, named hatB
3 For all frequencies p,q, perform the product :
hatf*(p,q)=hatf(p,q)*hatB(p,q)
4 Inverse the DFT to get f*
The method described above is really efficient since its complexity is the one of 2D DFT, that is N*N*log(N). Moreover, dedicated libraries such as FFTW makes it easy to implement. Take a look at fftw_plan fftw_plan_dft_r2c_2d and be careful about the data layout.
EDIT : I still think there is a may to make it work... Here is a starting code, compile it by gcc main.c -o main -lfftw3 -lm
#include <fftw3.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
int save_image(int N,double* data,int nb){
char filename[1000];
sprintf(filename,"xxx%d.vtk",nb);
FILE * pFile;
pFile = fopen (filename,"w");
if (pFile!=NULL)
{
fputs ("# vtk DataFile Version 2.0\n",pFile);
fputs ("Volume example\n",pFile);
fputs ("ASCII\n",pFile);
fputs ("DATASET STRUCTURED_POINTS\n",pFile);
fprintf(pFile,"DIMENSIONS %d %d 1\n",N,N);
fputs ("ASPECT_RATIO 1 1 1\n",pFile);
fputs ("ORIGIN 0 0 0\n",pFile);
fprintf(pFile,"POINT_DATA %d\n",N*N);
fputs ("SCALARS volume_scalars float 1\n",pFile);
fputs ("LOOKUP_TABLE default\n",pFile);
int i;
for(i=0;i<N*N;i++){
fprintf(pFile,"%f ",data[i]);
}
fclose (pFile);
}
return 0;
}
int main(int argc, char* argv[]){
int N=64;
double *xnew=fftw_malloc(sizeof(double)*N*N);
double *xold=fftw_malloc(sizeof(double)*N*N);
double *yold=fftw_malloc(sizeof(double)*N*N);
fftw_complex *xfourier=fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);
double *bessel=fftw_malloc(sizeof(double)*N*N);
fftw_complex *besself=fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);
//initial
printf("initial\n");
memset(xold,0,sizeof(double)*N*N);
memset(yold,0,sizeof(double)*N*N);
xold[(N/2)*N+N/2]=1;
// fftw_plan
printf("fftw_plan\n");
fftw_plan plan;
plan=fftw_plan_dft_r2c_2d(N, N, xold, xfourier, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT);
fftw_plan planb;
planb=fftw_plan_dft_r2c_2d(N, N,(double*) bessel, besself, FFTW_ESTIMATE);
fftw_plan plani;
plani=fftw_plan_dft_c2r_2d(N, N, xfourier, xnew, FFTW_ESTIMATE);
//bessel function
//crude approximate of bessel...
printf("bessel function\n");
double dx=1.0/(double)N;
double dy=1.0/(double)N;
int x,y;int i,j;
for(x=0,i=-N/2;x<N;x++,i++){
for(y=0,j=-N/2;y<N;y++,j++){
double dist=sqrt(dx*dx*(i*i+j*j));
double range=0.01;
dist=dist/range;
if(dist>0){
bessel[x*N+y]=sqrt(2./(M_PI*dist))*cos(dist-M_PI/4.0);
}else{
bessel[x*N+y]=1;
}
}
}
fftw_execute(planb);
fftw_destroy_plan(planb);
fftw_free(bessel);
//time loop
printf("time loop\n");
int t,tmax=100;
for(t=0;t<=tmax;t++){
save_image(N,xold,t);
printf("t=%d\n",t);
//convolution= products in fourier space
fftw_execute(plan);
double scale=1.0/((double)N*N);
//scale*=scale; //may be needed to correct scaling
for(i=0;i<N*(N/2+1);i++){
xfourier[i][0]=(xfourier[i][0]*besself[i][0]-xfourier[i][1]*besself[i][1])*scale;
xfourier[i][1]=(xfourier[i][0]*besself[i][1]+xfourier[i][1]*besself[i][0])*scale;
}
fftw_execute(plani);//xnew is updated
double C=1;double epsilon=1; double a=1; double beta=1;double sigma=1;
for(i=0;i<N*N;i++){
xnew[i]=(a/(1+xold[i]*xold[i])) +yold[i] + epsilon*C*xnew[i];
yold[i] = yold[i] - sigma*xold[i] - beta;
}
memcpy(xold,xnew,N*N*sizeof(double));
}
printf("destroy\n");
fftw_destroy_plan(plan);
fftw_destroy_plan(plani);
// fftw_destroy_plan(planb);
printf("free\n");
fftw_free(xnew);
fftw_free(xold);
fftw_free(yold);
fftw_free(besself);
fftw_free(xfourier);
return 0;
}
It produces some vtk images of xold which may be opened by the paraview software. It is likely that saving the images slow down the computations...
My coefficients are wrong, so the output is wrong...
EDIT : Here is piece of code based on yours, to be compiled by gcc main.c -o main -lfftw3 -lm. I found bessk0.c and bessi0.c.
The code writes :
#include <fftw3.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include"bessi0.c"
#include"bessk0.c"
//#include"bessel.c"
//#include"ran1.c"
#define tmax 90000
#define beta 0.001
#define N 50
#define sigma 0.001
#define pi acos(-1.0)
#define trans 50000
#define epsilon 0.1
double ran1(long* idum){
return ((double)rand())/((double)RAND_MAX);
}
void condicoes_iniciais(double *xold,double *yold,double *a)
{
int l;
long idum=-120534;
for(l=0;l<= N*N; l++){
a[l]=5.0;}
for(l=0;l<= N*N; l++){
while(a[l]>4.4)
a[l]=4.1+ran1(& idum);}
for(l=0;l<=N* N; l++){
xold[l]=0.1*ran1(& idum);
yold[l]=0.1*ran1(& idum);
//printf("%g %g %g\n",xold[l],yold[l],a[l]);
}
a[0]=4.1;
a[N]=4.4;
}
void Matriz_Bessel(double *bessel,double gama)
{
int x,y,i,j;
double dist;
for(x=0,i=-N/2;x<N;x++,i++)
{
for(y=0,j=-N/2;y<N;y++,j++)
{
double dist=sqrt(i*i+j*j);
if(dist>0){
bessel[x*N+y]=bessk0(gama*dist);
//printf("%g %g\n",dist,bessel[x*N+y]);
}
else{
bessel[x*N+y]=1;
}
}
}
}
void constante(double *c, double *bessel)
{
int x;
int y;
double soma = 0;
for(x=0;x<N;x++){
for(y=0;y<N;y++){
soma = soma + bessel[x*N+y];
}}
// *c =(1.0/(4.0*soma));
*c =(1.0/(soma));
}
int main(int argc, char* argv[]){
//srand (time(NULL));
srand (0);
double *xnew=fftw_malloc(sizeof(double)*N*N);
double *acopl=fftw_malloc(sizeof(double)*N*N);
double *xold=malloc(sizeof(double)*N*N);
double *yold = malloc(sizeof(double)*N*N);
double *a = malloc(sizeof(double)*N*N);
fftw_complex *xfourier;
xfourier = (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);
fftw_complex *aux;
aux= (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);
double *bessel= fftw_malloc(sizeof(double)*N*N);
fftw_complex *besself;
besself=fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);
double scale=1.0/((double)N*N);
int t,i;
double gama,Mn,C;
gama = 0.005;
char arqnome[1000];
FILE *fout;
sprintf(arqnome,"opt2_tamanho_plato_%.3f_%d.dat",gama,N);
fout = fopen(arqnome,"w");
//initial
printf("initial\n");
condicoes_iniciais(xold,yold,a);
//xold[(N/2)*N+N/2]=1;
// fftw_plan
printf("fftw_plan\n");
fftw_plan plan;
plan=fftw_plan_dft_r2c_2d(N, N, xnew, xfourier, FFTW_MEASURE | FFTW_PRESERVE_INPUT);
fftw_plan planb;
planb=fftw_plan_dft_r2c_2d(N, N, bessel, besself, FFTW_MEASURE);
fftw_plan plani;
plani=fftw_plan_dft_c2r_2d(N, N, aux, acopl, FFTW_MEASURE);
Matriz_Bessel(bessel,gama);
constante(&C, bessel);
fftw_execute(planb);
//time loop
printf("time loop\n");
for(t=0;t<=tmax;t++){
//convolution= products in fourier space
fftw_execute(plan);
for(i=0;i<N*(N/2+1);i++){
aux[i][0]=(xfourier[i][0]*besself[i][0]-xfourier[i][1]*besself[i][1]);
aux[i][1]=(xfourier[i][0]*besself[i][1]+xfourier[i][1]*besself[i][0]);
}
fftw_execute(plani);//xnew is updated
Mn = 0;
for(i=0;i<N*N;i++){
xnew[i]=(a[i]/(1+xold[i]*xold[i])) +yold[i] + epsilon*C* (acopl[i]/(double)(N*N));
yold[i] = yold[i] - sigma*xold[i] - beta;
Mn = Mn +xnew[i];
}
memcpy(xold,xnew,N*N*sizeof(double));
if(t>trans){fprintf(fout,"%d %f %f %f %f %f\n",(t-trans),xold[0],yold[0],xold[N],yold[N],Mn/((N+1)*(N+1)));}
}
printf("destroy\n");
fftw_destroy_plan(plan);
fftw_destroy_plan(plani);
fftw_destroy_plan(planb);
printf("free\n");
fftw_free(bessel);
fftw_free(xnew);
fftw_free(xold);
fftw_free(yold);
fftw_free(besself);
fftw_free(xfourier);
fftw_free(aux);
fftw_free(acopl);
return 0;
}
The result is the following :
The lines :
aux[i][0]=(xfourier[i][0]*besself[i][0]-xfourier[i][1]*besself[i][1]);
aux[i][1]=(xfourier[i][0]*besself[i][1]+xfourier[i][1]*besself[i][0]);
Correspond to product of complex numbers. aux[i] is a complex number, aux[i][0] is its real part and aux[i][1] its imaginary part. Hence aux[i][4] does not correspond to something meaningful. These complex numbers correspond to magnitudes of frequencies in the Fourier space.
I also modified the constant : *c =(1.0/(soma));
Do not forget to add srand(0) if you wish to compare outputs and build the initial state in the same way.

Answer 2

You could perhaps use the symmetry of the grid to reduce the number of computations needed. Especially so if you are modelling an infinite periodic system, as apparent wrap-around logic makes me think you may be doing.
Consider:
the same influence is exerted on a particle at the coordinates [35][35] by particles at [35 - x][35], [35 + x][35], [35][35 - x], and [35][35 + x], for any x; also,
another influence is exerted equally by the particles at [35 - x][35 - x], [35 + x][35 - x], [35 - x][35 + x], and [35 + x][35 + x], for any; and
yet another influence is exerted equally by the particles at [35 + x][35 + y], [35 + x][35 - y], [35 - x][35 + y], [35 - x][35 - y], [35 + y][35 + x], [35 + y][35 - x], [35 - y][35 + x], and [35 - y][35 - x], for any x != y.
You should be able to speed your computation by a little less than a factor of 8 by using those equivalences.
If indeed you are simulating an infinite periodic system, however, then I observe that your approach incorporates a bias: by computing the influences from a square grid, you are including the influence of some of the particles at distances between N and sqrt(2) * N from the target, but not of others. You should compute on a (virtual) disc, instead, to avoid such bias.
Furthermore, the appearance of input parameters x and y leads me to suppose that you are performing that computation once for each grid position. If, again, you are modelling an infinite, periodic grid with an emitter at each grid point, and in which each point's influence depends only on distance, then every point will experience the same influence. You could cut your runtime several thousand-fold, and reduce the asymptotic complexity of your algorithm if you can make use of that.