daviddoji/YouTube-simulations
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
1259de740f
YouTube-simulations/sub_lj.c
Nils Berglund 8a20ab883a
Add files via upload
2025-01-11 19:25:51 +01:00

16655 lines
599 KiB
C
Raw Blame History

/*********************/
/* Graphics routines */
/*********************/
#include "colors_waves.c"
// #define HUE_TYPE0 260.0 /* hue of particles of type 0 */
// #define HUE_TYPE0 300.0 /* hue of particles of type 0 */
// #define HUE_TYPE1 90.0 /* hue of particles of type 1 */
int writetiff(char *filename, char *description, int x, int y, int width, int height, int compression)
{
TIFF *file;
GLubyte *image, *p;
int i;
file = TIFFOpen(filename, "w");
if (file == NULL)
{
return 1;
}
image = (GLubyte *) malloc(width * height * sizeof(GLubyte) * 3);
/* OpenGL's default 4 byte pack alignment would leave extra bytes at the
end of each image row so that each full row contained a number of bytes
divisible by 4. Ie, an RGB row with 3 pixels and 8-bit componets would
be laid out like "RGBRGBRGBxxx" where the last three "xxx" bytes exist
just to pad the row out to 12 bytes (12 is divisible by 4). To make sure
the rows are packed as tight as possible (no row padding), set the pack
alignment to 1. */
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadPixels(x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, image);
TIFFSetField(file, TIFFTAG_IMAGEWIDTH, (uint32_t) width);
TIFFSetField(file, TIFFTAG_IMAGELENGTH, (uint32_t) height);
TIFFSetField(file, TIFFTAG_BITSPERSAMPLE, 8);
TIFFSetField(file, TIFFTAG_COMPRESSION, compression);
TIFFSetField(file, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
TIFFSetField(file, TIFFTAG_ORIENTATION, ORIENTATION_BOTLEFT);
TIFFSetField(file, TIFFTAG_SAMPLESPERPIXEL, 3);
TIFFSetField(file, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(file, TIFFTAG_ROWSPERSTRIP, 1);
TIFFSetField(file, TIFFTAG_IMAGEDESCRIPTION, description);
p = image;
for (i = height - 1; i >= 0; i--)
{
// if (TIFFWriteScanline(file, p, height - i - 1, 0) < 0)
if (TIFFWriteScanline(file, p, i, 0) < 0)
{
free(image);
TIFFClose(file);
return 1;
}
p += width * sizeof(GLubyte) * 3;
}
TIFFClose(file);
if (SAVE_MEMORY) free(image);
return 0;
}
void init() /* initialisation of window */
{
glLineWidth(3);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glOrtho(XMIN, XMAX, YMIN, YMAX , -1.0, 1.0);
// glOrtho(0.0, NX, 0.0, NY, -1.0, 1.0);
}
void blank()
{
if (BLACK) glClearColor(0.0, 0.0, 0.0, 1.0);
else glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
}
void save_frame_lj()
{
static int counter = 0;
char *name="lj.", n2[100];
char format[6]=".%05i";
counter++;
// printf (" p2 counter = %d \n",counter);
strcpy(n2, name);
sprintf(strstr(n2,"."), format, counter);
strcat(n2, ".tif");
printf(" saving frame %s \n",n2);
writetiff(n2, "Particles with Lennard-Jones interaction in a planar domain", 0, 0,
WINWIDTH, WINHEIGHT, COMPRESSION_LZW);
}
void save_frame_lj_counter(int counter)
{
char *name="lj.", n2[100];
char format[6]=".%05i";
strcpy(n2, name);
sprintf(strstr(n2,"."), format, counter);
strcat(n2, ".tif");
printf(" saving frame %s \n",n2);
writetiff(n2, "Particles with Lennard-Jones interaction in a planar domain", 0, 0,
WINWIDTH, WINHEIGHT, COMPRESSION_LZW);
}
void write_text_fixedwidth( double x, double y, char *st)
{
int l, i;
l=strlen( st ); // see how many characters are in text string.
glRasterPos2d( x, y); // location to start printing text
for( i=0; i < l; i++) // loop until i is greater then l
{
// glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, st[i]); // Print a character on the screen
// glutBitmapCharacter(GLUT_BITMAP_8_BY_13, st[i]); // Print a character on the screen
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, st[i]); // Print a character on the screen
}
}
void write_text( double x, double y, char *st)
{
int l,i;
l=strlen( st ); // see how many characters are in text string.
glRasterPos2d( x, y); // location to start printing text
for( i=0; i < l; i++) // loop until i is greater then l
{
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, st[i]); // Print a character on the screen
// glutBitmapCharacter(GLUT_BITMAP_8_BY_13, st[i]); // Print a character on the screen
}
}
/*********************/
/* some basic math */
/*********************/
double vabs(double x) /* absolute value */
{
double res;
if (x<0.0) res = -x;
else res = x;
return(res);
}
double argument(double x, double y)
{
double alph;
if (x!=0.0)
{
alph = atan(y/x);
if (x<0.0)
alph += PI;
}
else
{
alph = PID;
if (y<0.0)
alph = PI*1.5;
}
return(alph);
}
double ipow(double x, int n)
{
double y;
int i;
y = x;
for (i=1; i<n; i++) y *= x;
return(y);
}
double gaussian()
/* returns standard normal random variable, using Box-Mueller algorithm */
{
static double V1, V2, S;
static int phase = 0;
double X;
if (phase == 0)
{
do
{
double U1 = (double)rand() / RAND_MAX;
double U2 = (double)rand() / RAND_MAX;
V1 = 2 * U1 - 1;
V2 = 2 * U2 - 1;
S = V1 * V1 + V2 * V2;
}
while(S >= 1 || S == 0);
X = V1 * sqrt(-2 * log(S) / S);
}
else X = V2 * sqrt(-2 * log(S) / S);
phase = 1 - phase;
return X;
}
/*********************/
/* drawing routines */
/*********************/
void erase_area(double x, double y, double dx, double dy)
{
double pos[2], rgb[3];
hsl_to_rgb(220.0, 0.8, 0.7, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_QUADS);
glVertex2d(x - dx, y - dy);
glVertex2d(x + dx, y - dy);
glVertex2d(x + dx, y + dy);
glVertex2d(x - dx, y + dy);
glEnd();
}
void erase_area_rgb(double x, double y, double dx, double dy, double rgb[3])
{
double pos[2];
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_QUADS);
glVertex2d(x - dx, y - dy);
glVertex2d(x + dx, y - dy);
glVertex2d(x + dx, y + dy);
glVertex2d(x - dx, y + dy);
glEnd();
}
void erase_rect_rgb(double xmin, double ymin, double xmax, double ymax, double rgb[3])
{
double pos[2];
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_QUADS);
glVertex2d(xmin, ymin);
glVertex2d(xmax, ymin);
glVertex2d(xmax, ymax);
glVertex2d(xmin, ymax);
glEnd();
}
void erase_area_hsl(double x, double y, double dx, double dy, double h, double s, double l)
{
double pos[2], rgb[3];
hsl_to_rgb(h, s, l, rgb);
erase_area_rgb(x, y, dx, dy, rgb);
}
void erase_area_hsl_turbo(double x, double y, double dx, double dy, double h, double s, double l)
{
double pos[2], rgb[3];
hsl_to_rgb_turbo(h, s, l, rgb);
erase_area_rgb(x, y, dx, dy, rgb);
}
void erase_rectangle_hsl_turbo(double xmin, double ymin, double xmax, double ymax, double h, double s, double l)
{
double pos[2], rgb[3];
hsl_to_rgb_turbo(h, s, l, rgb);
erase_rect_rgb(xmin, ymin, xmax, ymax, rgb);
}
void draw_line(double x1, double y1, double x2, double y2)
{
glBegin(GL_LINE_STRIP);
glVertex2d(x1, y1);
glVertex2d(x2, y2);
glEnd();
}
void draw_arrow(double x1, double y1, double x2, double y2, double angle, double length)
{
double alpha, beta, x3, y3, x4, y4, x5, y5;
alpha = argument(x2 - x1, y2 - y1);
beta = angle*PI/180.0;
x3 = x2 - length*cos(alpha - beta);
y3 = y2 - length*sin(alpha - beta);
x4 = x2 - length*cos(alpha + beta);
y4 = y2 - length*sin(alpha + beta);
x5 = x2 - 0.5*length*cos(alpha);
y5 = y2 - 0.5*length*sin(alpha);
glBegin(GL_LINE_STRIP);
glVertex2d(x1, y1);
glVertex2d(x5, y5);
glEnd();
glBegin(GL_TRIANGLE_FAN);
glVertex2d(x2, y2);
glVertex2d(x3, y3);
glVertex2d(x4, y4);
glEnd();
}
void draw_rectangle(double x1, double y1, double x2, double y2)
{
glBegin(GL_LINE_LOOP);
glVertex2d(x1, y1);
glVertex2d(x2, y1);
glVertex2d(x2, y2);
glVertex2d(x1, y2);
glEnd();
}
void draw_colored_rectangle(double x1, double y1, double x2, double y2, double rgb[3])
{
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_TRIANGLE_FAN);
glVertex2d(x1, y1);
glVertex2d(x2, y1);
glVertex2d(x2, y2);
glVertex2d(x1, y2);
glEnd();
}
void draw_triangle(double x1, double y1, double x2, double y2, double x3, double y3)
{
glBegin(GL_LINE_LOOP);
glVertex2d(x1, y1);
glVertex2d(x2, y2);
glVertex2d(x3, y3);
glEnd();
}
void draw_colored_triangle(double x1, double y1, double x2, double y2, double x3, double y3, double rgb[3])
{
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_TRIANGLE_FAN);
glVertex2d(x1, y1);
glVertex2d(x2, y2);
glVertex2d(x3, y3);
glEnd();
}
double triangle_area(double x1, double y1, double x2, double y2, double x3, double y3)
{
return((x2-x1)*(y3-y1)-(y2-y1)*(x3-x1));
}
void draw_colored_triangle_turbo(double x1, double y1, double x2, double y2, double x3, double y3, double h, double s, double l)
{
double rgb[3];
hsl_to_rgb_turbo(h, s, l, rgb);
draw_colored_triangle(x1, y1, x2, y2, x3, y3, rgb);
}
void draw_circle(double x, double y, double r, int nseg)
{
int i;
double pos[2], alpha, dalpha;
dalpha = DPI/(double)nseg;
glBegin(GL_LINE_LOOP);
for (i=0; i<=nseg; i++)
{
alpha = (double)i*dalpha;
glVertex2d(x + r*cos(alpha), y + r*sin(alpha));
}
glEnd();
}
void draw_colored_circle(double x, double y, double r, int nseg, double rgb[3])
{
int i;
double pos[2], alpha, dalpha;
dalpha = DPI/(double)nseg;
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_TRIANGLE_FAN);
glVertex2d(x, y);
for (i=0; i<=nseg; i++)
{
alpha = (double)i*dalpha;
glVertex2d(x + r*cos(alpha), y + r*sin(alpha));
}
glEnd();
}
void draw_circle_precomp(double x, double y, double r)
{
int i;
glBegin(GL_LINE_LOOP);
for (i=0; i<=NSEG; i++) glVertex2d(x + r*cosangle[i], y + r*sinangle[i]);
glEnd();
}
void draw_colored_circle_precomp(double x, double y, double r, double rgb[3])
{
int i;
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_TRIANGLE_FAN);
glVertex2d(x, y);
for (i=0; i<=NSEG; i++) glVertex2d(x + r*cosangle[i], y + r*sinangle[i]);
glEnd();
}
void draw_polygon(double x, double y, double r, int nsides, double angle)
{
int i;
double pos[2], alpha, dalpha;
dalpha = DPI/(double)nsides;
glColor3f(1.0, 1.0, 1.0);
glBegin(GL_LINE_LOOP);
for (i=0; i<=nsides; i++)
{
alpha = angle + (double)i*dalpha;
glVertex2d(x + r*cos(alpha), y + r*sin(alpha));
}
glEnd();
}
void draw_colored_polygon(double x, double y, double r, int nsides, double angle, double rgb[3])
{
int i;
double pos[2], alpha, dalpha;
dalpha = DPI/(double)nsides;
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_TRIANGLE_FAN);
glVertex2d(x, y);
for (i=0; i<=nsides; i++)
{
alpha = angle + (double)i*dalpha;
glVertex2d(x + r*cos(alpha), y + r*sin(alpha));
}
glEnd();
}
void draw_rhombus(double x, double y, double r, double angle)
{
int i;
static int first = 1;
static double ratio;
if (first)
{
ratio = tan(0.1*PI);
first = 0;
}
glBegin(GL_LINE_LOOP);
glVertex2d(x + r*cos(angle), y + r*sin(angle));
glVertex2d(x - ratio*r*sin(angle), y + ratio*r*cos(angle));
glVertex2d(x - r*cos(angle), y - r*sin(angle));
glVertex2d(x + ratio*r*sin(angle), y - ratio*r*cos(angle));
glEnd();
}
void draw_colored_rhombus(double x, double y, double r, double angle, double rgb[3])
{
int i;
static int first = 1;
static double ratio;
if (first)
{
ratio = tan(0.1*PI);
first = 0;
}
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_TRIANGLE_FAN);
glVertex2d(x, y);
glVertex2d(x + r*cos(angle), y + r*sin(angle));
glVertex2d(x - ratio*r*sin(angle), y + ratio*r*cos(angle));
glVertex2d(x - r*cos(angle), y - r*sin(angle));
glVertex2d(x + ratio*r*sin(angle), y - ratio*r*cos(angle));
glVertex2d(x + r*cos(angle), y + r*sin(angle));
glEnd();
}
void draw_rotated_rect(double x, double y, double l, double w, double angle)
{
int i;
double ca, sa, lca, lsa, wca, wsa;
ca = cos(angle);
sa = sin(angle);
lca = l*ca;
lsa = l*sa;
wca = w*ca;
wsa = w*sa;
glBegin(GL_LINE_LOOP);
glVertex2d(x + lca - wsa, y + lsa + wca);
glVertex2d(x - lca - wsa, y - lsa + wca);
glVertex2d(x - lca + wsa, y - lsa - wca);
glVertex2d(x + lca + wsa, y + lsa - wca);
glEnd();
}
void draw_colored_rotated_rect(double x, double y, double l, double w, double angle, double rgb[3])
{
int i;
double ca, sa, lca, lsa, wca, wsa;
ca = cos(angle);
sa = sin(angle);
lca = l*ca;
lsa = l*sa;
wca = w*ca;
wsa = w*sa;
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_TRIANGLE_FAN);
glVertex2d(x, y);
glVertex2d(x + lca - wsa, y + lsa + wca);
glVertex2d(x - lca - wsa, y - lsa + wca);
glVertex2d(x - lca + wsa, y - lsa - wca);
glVertex2d(x + lca + wsa, y + lsa - wca);
glVertex2d(x + lca - wsa, y + lsa + wca);
glEnd();
}
void draw_colored_sector(double xc, double yc, double r1, double r2, double angle1, double angle2, double rgb[3], int nsides)
{
int i;
double angle, dangle;
dangle = (angle2 - angle1)/(double)nsides;
glColor3f(rgb[0], rgb[1], rgb[2]);
glBegin(GL_TRIANGLE_FAN);
glVertex2d(xc + r1*cos(angle1), yc + r1*sin(angle1));
for (i = 0; i < nsides+1; i++)
{
angle = angle1 + dangle*(double)i;
glVertex2d(xc + r2*cos(angle), yc + r2*sin(angle));
}
glEnd();
glBegin(GL_TRIANGLE_FAN);
glVertex2d(xc + r2*cos(angle2), yc + r2*sin(angle2));
for (i = 0; i < nsides+1; i++)
{
angle = angle1 + dangle*(double)i;
glVertex2d(xc + r1*cos(angle), yc + r1*sin(angle));
}
glEnd();
}
double neighbour_color(int nnbg)
{
if (nnbg > 7) nnbg = 7;
switch(nnbg){
case (7): return(340.0);
case (6): return(310.0);
case (5): return(260.0);
case (4): return(200.0);
case (3): return(140.0);
case (2): return(100.0);
case (1): return(70.0);
default: return(30.0);
}
}
double partner_color(int np)
{
switch(np){
case (0): return(340.0);
case (1): return(260.0);
case (2): return(210.0);
case (3): return(140.0);
case (4): return(70.0);
default: return(20.0);
// case (0): return(70.0);
// case (1): return(200.0);
// case (2): return(280.0);
// case (3): return(140.0);
// case (4): return(320.0);
// default: return(20.0);
}
}
double type_hue(int type)
{
int hue;
double t2;
static double b, hmax;
static int first = 1;
if (first)
{
hmax = 360.0;
b = 16.0*(hmax - HUE_TYPE3);
first = 0;
}
if ((RD_REACTION == CHEM_CATALYTIC_A2D)&&(type == 4)) return(HUE_TYPE3);
if ((RD_REACTION == CHEM_ABDACBE)&&(type == 4)) return(HUE_TYPE3);
if ((RD_REACTION == CHEM_ABDACBE)&&(type == 5)) return(280.0);
switch (type) {
case (0): return(HUE_TYPE0);
case (1): return(HUE_TYPE1);
case (2): return(HUE_TYPE2);
case (3): return(HUE_TYPE3);
case (4): return(HUE_TYPE4);
case (5): return(HUE_TYPE5);
case (6): return(HUE_TYPE6);
case (7):
{
if (RD_REACTION == CHEM_BZ) return(HUE_TYPE2);
else return(HUE_TYPE7);
}
default:
{
if (RD_REACTION == CHEM_BZ)
{
if (type == 7) return(HUE_TYPE2);
if (type == 8) type = 5;
}
else if ((RD_REACTION == CHEM_BRUSSELATOR)&&(type >= 5)) return(70.0);
t2 = (double)(type*type);
hue = (hmax*t2 - b)/t2;
return(hue);
}
}
}
void set_type_color(int type, double lum, double rgb[3])
{
int hue;
if (COUNT_PARTNER_TYPE) hue = partner_color(type-1);
else hue = type_hue(type);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE);
glColor3f(lum*rgb[0], lum*rgb[1], lum*rgb[2]);
}
double distance_to_segment(double x, double y, double x1, double y1, double x2, double y2)
/* distance of (x,y) to segment from (x1,y1) to (x2,y2) */
{
double xp, yp, angle, length, ca, sa;
angle = argument(x2 - x1, y2 - y1);
length = module2(x2 - x1, y2 - y1);
ca = cos(angle);
sa = sin(angle);
xp = ca*(x - x1) + sa*(y - y1);
yp = -sa*(x - x1) + ca*(y - y1);
if ((xp >= 0)&&(xp <= length)) return(vabs(yp));
else if (xp < 0) return(module2(xp, yp));
else return(module2(xp-length, yp));
}
int in_polygon(double x, double y, double r, int npoly, double apoly)
/* test whether (x,y) is in regular polygon of npoly sides inscribed in circle of radius r, turned by apoly Pi/2 */
{
int condition = 1, k;
double omega, cw, angle;
omega = DPI/((double)npoly);
cw = cos(omega*0.5);
for (k=0; k<npoly; k++)
{
angle = -apoly*PID + ((double)k+0.5)*omega;
condition = condition*(x*cos(angle) + y*sin(angle) < r*cw);
}
return(condition);
}
void init_angles()
/* initialise cos and sin of angles to save computing time */
{
int i;
double alpha, dalpha;
dalpha = DPI/(double)NSEG;
for (i=0; i<=NSEG; i++)
{
alpha = (double)i*dalpha;
cosangle[i] = cos(alpha);
sinangle[i] = sin(alpha);
}
}
int generate_poisson_discs(t_point *point, int nmax, double xmin, double xmax, double ymin, double ymax, double dpoisson)
/* generate a Poisson disc sample in a given rectangle */
{
int i, j, k, n_p_active, ncandidates=PDISC_CANDIDATES, naccepted, npoints;
double r, phi, x, y;
short int active_poisson[nmax], far;
printf("Generating Poisson disc sample\n");
/* generate first circle */
point[0].xc = (xmax - xmin)*(double)rand()/RAND_MAX + xmin;
point[0].yc = (ymax - ymin)*(double)rand()/RAND_MAX + ymin;
active_poisson[0] = 1;
n_p_active = 1;
npoints = 1;
while ((n_p_active > 0)&&(npoints < nmax))
{
/* randomly select an active circle */
i = rand()%(npoints);
while (!active_poisson[i]) i = rand()%(npoints);
/* generate new candidates */
naccepted = 0;
for (j=0; j<ncandidates; j++)
{
r = dpoisson*(2.0*(double)rand()/RAND_MAX + 1.0);
phi = DPI*(double)rand()/RAND_MAX;
x = point[i].xc + r*cos(phi);
y = point[i].yc + r*sin(phi);
far = 1;
for (k=0; k<npoints; k++) if ((k!=i))
{
/* new circle is far away from circle k */
far = far*((x - point[k].xc)*(x - point[k].xc) + (y - point[k].yc)*(y - point[k].yc) >= dpoisson*dpoisson);
/* new circle is in domain */
far = far*(x < xmax)*(x > xmin)*(y < ymax)*(y > ymin);
}
if (far) /* accept new circle */
{
printf("New npoint at (%.3f,%.3f) accepted\n", x, y);
point[npoints].xc = x;
point[npoints].yc = y;
active_poisson[npoints] = 1;
npoints++;
n_p_active++;
naccepted++;
}
}
if (naccepted == 0) /* inactivate circle i */
{
active_poisson[i] = 0;
n_p_active--;
}
printf("%i active npoints\n", n_p_active);
}
printf("Generated %i points\n", npoints);
return(npoints);
}
void init_particle_config(t_particle particles[NMAXCIRCLES])
/* initialise particle configuration */
{
int i, j, k, n, ncirc0, n_p_active, ncandidates = PDISC_CANDIDATES, naccepted;
double dx, dy, p, phi, r, r0, ra[5], sa[5], height, x, y = 0.0, gamma, dpoisson = PDISC_DISTANCE*MU, xx[4], yy[4];
short int active_poisson[NMAXCIRCLES], far;
switch (CIRCLE_PATTERN) {
case (C_SQUARE):
{
ncircles = NGRIDX*NGRIDY;
dx = (INITXMAX - INITXMIN)/((double)NGRIDX);
dy = (INITYMAX - INITYMIN)/((double)NGRIDY);
for (i = 0; i < NGRIDX; i++)
for (j = 0; j < NGRIDY; j++)
{
n = NGRIDY*i + j;
particles[n].xc = INITXMIN + ((double)i - 0.5)*dx;
particles[n].yc = INITYMIN + ((double)j - 0.5)*dy;
particles[n].radius = MU;
/* activate only circles that intersect the domain */
if ((particles[n].yc < INITYMAX + MU)&&(particles[n].yc > INITYMIN - MU)&&(particles[n].xc < INITXMAX + MU)&&(particles[n].xc > INITXMIN - MU)) particles[n].active = 1;
else particles[n].active = 0;
}
break;
}
case (C_HEX):
{
ncircles = NGRIDX*(NGRIDY+1);
dx = (INITXMAX - INITXMIN)/((double)NGRIDX);
dy = (INITYMAX - INITYMIN)/((double)NGRIDY);
// dx = dy*0.5*sqrt(3.0);
for (i = 0; i < NGRIDX; i++)
for (j = 0; j < NGRIDY+1; j++)
{
n = (NGRIDY+1)*i + j;
// particles[n].xc = ((double)(i-NGRIDX/2) + 0.5)*dx; /* is +0.5 needed? */
particles[n].xc = INITXMIN + ((double)i - 0.5)*dx;
particles[n].yc = INITYMIN + ((double)j - 0.5)*dy;
if ((i+NGRIDX)%2 == 1) particles[n].yc += 0.5*dy;
if (particles[n].yc > INITYMAX) particles[n].yc += INITYMIN - INITYMAX;
// else if (particles[n].yc < YMIN) particles[n].yc += YMAX - YMIN;
particles[n].radius = MU;
/* activate only circles that intersect the domain */
if ((particles[n].yc < INITYMAX + MU)&&(particles[n].yc > INITYMIN - MU)&&(particles[n].xc < INITXMAX + MU)&&(particles[n].xc > INITXMIN - MU)) particles[n].active = 1;
else particles[n].active = 0;
}
break;
}
case (C_RAND_DISPLACED):
{
ncircles = NGRIDX*NGRIDY;
dy = (YMAX - YMIN)/((double)NGRIDY);
for (i = 0; i < NGRIDX; i++)
for (j = 0; j < NGRIDY; j++)
{
n = NGRIDY*i + j;
particles[n].xc = ((double)(i-NGRIDX/2) + 0.5*((double)rand()/RAND_MAX - 0.5))*dy;
particles[n].yc = YMIN + ((double)j + 0.5 + 0.5*((double)rand()/RAND_MAX - 0.5))*dy;
particles[n].radius = MU;
// particles[n].radius = MU*sqrt(1.0 + 0.8*((double)rand()/RAND_MAX - 0.5));
particles[n].active = 1;
}
break;
}
case (C_RAND_PERCOL):
{
ncircles = NGRIDX*NGRIDY;
dy = (YMAX - YMIN)/((double)NGRIDY);
for (i = 0; i < NGRIDX; i++)
for (j = 0; j < NGRIDY; j++)
{
n = NGRIDY*i + j;
particles[n].xc = ((double)(i-NGRIDX/2) + 0.5)*dy;
particles[n].yc = YMIN + ((double)j + 0.5)*dy;
particles[n].radius = MU;
p = (double)rand()/RAND_MAX;
if (p < P_PERCOL) particles[n].active = 1;
else particles[n].active = 0;
}
break;
}
case (C_RAND_POISSON):
{
ncircles = NPOISSON;
for (n = 0; n < NPOISSON; n++)
{
// particles[n].xc = LAMBDA*(2.0*(double)rand()/RAND_MAX - 1.0);
particles[n].xc = (XMAX - XMIN)*(double)rand()/RAND_MAX + XMIN;
particles[n].yc = (YMAX - YMIN)*(double)rand()/RAND_MAX + YMIN;
particles[n].radius = MU;
particles[n].active = 1;
}
break;
}
case (C_CLOAK):
{
ncircles = 200;
for (i = 0; i < 40; i++)
for (j = 0; j < 5; j++)
{
n = 5*i + j;
phi = (double)i*DPI/40.0;
r = LAMBDA*0.5*(1.0 + (double)j/5.0);
particles[n].xc = r*cos(phi);
particles[n].yc = r*sin(phi);
particles[n].radius = MU;
particles[n].active = 1;
}
break;
}
case (C_CLOAK_A): /* optimized model A1 by C. Jo et al */
{
ncircles = 200;
ra[0] = 0.0731; sa[0] = 1.115;
ra[1] = 0.0768; sa[1] = 1.292;
ra[2] = 0.0652; sa[2] = 1.464;
ra[3] = 0.056; sa[3] = 1.633;
ra[4] = 0.0375; sa[4] = 1.794;
for (i = 0; i < 40; i++)
for (j = 0; j < 5; j++)
{
n = 5*i + j;
phi = (double)i*DPI/40.0;
r = LAMBDA*sa[j];
particles[n].xc = r*cos(phi);
particles[n].yc = r*sin(phi);
particles[n].radius = LAMBDA*ra[j];
particles[n].active = 1;
}
break;
}
case (C_LASER):
{
ncircles = 17;
xx[0] = 0.5*(X_SHOOTER + X_TARGET);
xx[1] = LAMBDA - 0.5*(X_TARGET - X_SHOOTER);
xx[2] = -xx[0];
xx[3] = -xx[1];
yy[0] = 0.5*(Y_SHOOTER + Y_TARGET);
yy[1] = 1.0 - 0.5*(Y_TARGET - Y_SHOOTER);
yy[2] = -yy[0];
yy[3] = -yy[1];
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++)
{
particles[4*i + j].xc = xx[i];
particles[4*i + j].yc = yy[j];
}
particles[ncircles - 1].xc = X_TARGET;
particles[ncircles - 1].yc = Y_TARGET;
for (i=0; i<ncircles - 1; i++)
{
particles[i].radius = MU;
particles[i].active = 1;
}
particles[ncircles - 1].radius = 0.5*MU;
particles[ncircles - 1].active = 2;
break;
}
case (C_POISSON_DISC):
{
/* TODO: use generate_poisson_discs */
printf("Generating Poisson disc sample\n");
/* generate first circle */
// particles[0].xc = LAMBDA*(2.0*(double)rand()/RAND_MAX - 1.0);
particles[0].xc = (INITXMAX - INITXMIN)*(double)rand()/RAND_MAX + INITXMIN;
particles[0].yc = (INITYMAX - INITYMIN)*(double)rand()/RAND_MAX + INITYMIN;
active_poisson[0] = 1;
// particles[0].active = 1;
n_p_active = 1;
ncircles = 1;
while ((n_p_active > 0)&&(ncircles < NMAXCIRCLES))
{
/* randomly select an active circle */
i = rand()%(ncircles);
while (!active_poisson[i]) i = rand()%(ncircles);
// printf("Starting from circle %i at (%.3f,%.3f)\n", i, particles[i].xc, particles[i].yc);
/* generate new candidates */
naccepted = 0;
for (j=0; j<ncandidates; j++)
{
r = dpoisson*(2.0*(double)rand()/RAND_MAX + 1.0);
phi = DPI*(double)rand()/RAND_MAX;
x = particles[i].xc + r*cos(phi);
y = particles[i].yc + r*sin(phi);
// printf("Testing new circle at (%.3f,%.3f)\t", x, y);
far = 1;
for (k=0; k<ncircles; k++) if ((k!=i))
{
/* new circle is far away from circle k */
far = far*((x - particles[k].xc)*(x - particles[k].xc) + (y - particles[k].yc)*(y - particles[k].yc) >= dpoisson*dpoisson);
/* new circle is in domain */
far = far*(x < INITXMAX)*(x > INITXMIN)*(y < INITYMAX)*(y > INITYMIN);
// far = far*(vabs(x) < LAMBDA)*(y < INITYMAX)*(y > INITYMIN);
}
if (far) /* accept new circle */
{
printf("New circle at (%.3f,%.3f) accepted\n", x, y);
particles[ncircles].xc = x;
particles[ncircles].yc = y;
particles[ncircles].radius = MU;
particles[ncircles].active = 1;
active_poisson[ncircles] = 1;
ncircles++;
n_p_active++;
naccepted++;
}
// else printf("Rejected\n");
}
if (naccepted == 0) /* inactivate circle i */
{
// printf("No candidates work, inactivate circle %i\n", i);
active_poisson[i] = 0;
n_p_active--;
}
printf("%i active circles\n", n_p_active);
}
printf("Generated %i circles\n", ncircles);
break;
}
case (C_GOLDEN_MEAN):
{
ncircles = 300;
gamma = (sqrt(5.0) - 1.0)*0.5; /* golden mean */
height = YMAX - YMIN;
dx = 2.0*LAMBDA/((double)ncircles);
for (n = 0; n < ncircles; n++)
{
particles[n].xc = -LAMBDA + n*dx;
particles[n].yc = y;
y += height*gamma;
if (y > YMAX) y -= height;
particles[n].radius = MU;
particles[n].active = 1;
}
/* test for circles that overlap top or bottom boundary */
ncirc0 = ncircles;
for (n=0; n < ncirc0; n++)
{
if (particles[n].yc + particles[n].radius > YMAX)
{
particles[ncircles].xc = particles[n].xc;
particles[ncircles].yc = particles[n].yc - height;
particles[ncircles].radius = MU;
particles[ncircles].active = 1;
ncircles ++;
}
else if (particles[n].yc - particles[n].radius < YMIN)
{
particles[ncircles].xc = particles[n].xc;
particles[ncircles].yc = particles[n].yc + height;
particles[ncircles].radius = MU;
particles[ncircles].active = 1;
ncircles ++;
}
}
break;
}
case (C_GOLDEN_SPIRAL):
{
ncircles = 1;
particles[0].xc = 0.0;
particles[0].yc = 0.0;
gamma = (sqrt(5.0) - 1.0)*PI; /* golden mean times 2Pi */
phi = 0.0;
r0 = 2.0*MU;
r = r0 + MU;
for (i=0; i<1000; i++)
{
x = r*cos(phi);
y = r*sin(phi);
phi += gamma;
r += MU*r0/r;
if ((vabs(x) < LAMBDA)&&(vabs(y) < YMAX + MU))
{
particles[ncircles].xc = x;
particles[ncircles].yc = y;
ncircles++;
}
}
for (i=0; i<ncircles; i++)
{
particles[i].radius = MU;
/* inactivate circles outside the domain */
if ((particles[i].yc < YMAX + MU)&&(particles[i].yc > YMIN - MU)) particles[i].active = 1;
// printf("i = %i, circlex = %.3lg, circley = %.3lg\n", i, particles[i].xc, particles[i].yc);
}
break;
}
case (C_SQUARE_HEX):
{
ncircles = NGRIDX*(NGRIDY+1);
dy = (YMAX - YMIN)/((double)NGRIDY);
dx = dy*0.5*sqrt(3.0);
for (i = 0; i < NGRIDX; i++)
for (j = 0; j < NGRIDY+1; j++)
{
n = (NGRIDY+1)*i + j;
particles[n].xc = ((double)(i-NGRIDX/2) + 0.5)*dy; /* is +0.5 needed? */
particles[n].yc = YMIN + ((double)j - 0.5)*dy;
if (((i+NGRIDX)%4 == 2)||((i+NGRIDX)%4 == 3)) particles[n].yc += 0.5*dy;
particles[n].radius = MU;
/* activate only circles that intersect the domain */
if ((particles[n].yc < YMAX + MU)&&(particles[n].yc > YMIN - MU)) particles[n].active = 1;
else particles[n].active = 0;
}
break;
}
case (C_POOL_TABLE):
{
for (i=1; i<6; i++) for (j=0; j<i; j++)
{
particles[ncircles].xc = INITXMIN + (double)i*0.25*(INITXMAX - INITXMIN);
particles[ncircles].yc = 0.5*(INITYMIN + INITYMAX) + ((double)j - 0.5*(double)(i-1))*0.25*(INITYMAX - INITYMIN);
particles[ncircles].radius = MU;
particles[ncircles].active = 1;
ncircles += 1;
}
break;
}
case (C_ONE):
{
particles[ncircles].xc = 0.0;
particles[ncircles].yc = 0.0;
particles[ncircles].radius = MU;
particles[ncircles].active = 1;
ncircles += 1;
break;
}
case (C_TWO): /* used for comparison with cloak */
{
particles[ncircles].xc = 0.0;
particles[ncircles].yc = 0.0;
particles[ncircles].radius = MU;
particles[ncircles].active = 2;
ncircles += 1;
particles[ncircles].xc = 0.0;
particles[ncircles].yc = 0.0;
particles[ncircles].radius = 2.0*MU;
particles[ncircles].active = 1;
ncircles += 1;
break;
}
case (C_NOTHING):
{
ncircles += 0;
break;
}
default:
{
printf("Function init_circle_config not defined for this pattern \n");
}
}
for (i=0; i<ncircles; i++)
{
particles[i].coulomb = 1;
particles[i].reactive = 1;
}
}
void add_particle_config(t_particle particles[NMAXCIRCLES], double xmin, double xmax, double ymin, double ymax, int nx, int ny, short int reactive, double radius)
/* add particles to configuration */
{
int i, j, k, n, ncirc0, n_p_active, ncandidates = PDISC_CANDIDATES, naccepted, newcircles;
double dx, dy, p, phi, r, r0, ra[5], sa[5], height, x, y = 0.0, gamma, dpoisson, xx[4], yy[4];
short int active_poisson[NMAXCIRCLES], far;
dpoisson = PDISC_DISTANCE*radius;
switch (CIRCLE_PATTERN_B) {
case (C_SQUARE):
{
n = ncircles;
dx = (xmax - xmin)/((double)nx);
dy = (ymax - ymin)/((double)ny);
for (i = 0; i < nx; i++)
for (j = 0; j < NGRIDY; j++)
{
particles[n].xc = xmin + ((double)i + 0.5)*dx;
particles[n].yc = ymin + ((double)j + 0.5)*dy;
particles[n].radius = MU;
particles[n].active = 1;
particles[n].added = 1;
particles[n].coulomb = 1;
particles[n].reactive = reactive;
n++;
ncircles++;
}
break;
}
case (C_HEX):
{
dx = (xmax - xmin)/((double)NGRIDX);
dy = (ymax - ymin)/((double)NGRIDY);
// dx = dy*0.5*sqrt(3.0);
for (i = 0; i < NGRIDX; i++)
for (j = 0; j < NGRIDY+1; j++)
{
n = ncircles + (NGRIDY+1)*i + j;
// particles[n].xc = ((double)(i-NGRIDX/2) + 0.5)*dx; /* is +0.5 needed? */
particles[n].xc = xmin + ((double)i - 0.5)*dx;
particles[n].yc = ymin + ((double)j - 0.5)*dy;
if ((i+NGRIDX)%2 == 1) particles[n].yc += 0.5*dy;
particles[n].radius = radius;
/* activate only circles that intersect the domain */
if ((particles[n].yc < ymax + radius)&&(particles[n].yc > ymin - radius)&&(particles[n].xc < xmax + radius)&&(particles[n].xc > xmin - radius)) particles[n].active = 1;
else particles[n].active = 0;
}
ncircles += NGRIDX*(NGRIDY+1);
break;
}
case (C_POISSON_DISC):
{
ncirc0 = ncircles;
printf("Generating new Poisson disc sample\n");
/* generate first circle */
particles[ncirc0].xc = (xmax - xmin)*(double)rand()/RAND_MAX + xmin;
particles[ncirc0].yc = (ymax - ymin)*(double)rand()/RAND_MAX + ymin;
active_poisson[0] = 1;
// // particles[0].active = 1;
n_p_active = 1;
newcircles = 1;
while ((n_p_active > 0)&&(ncircles < NMAXCIRCLES))
{
/* randomly select an active circle */
i = rand()%(newcircles);
while (!active_poisson[i]) i = rand()%(ncircles);
// printf("Starting from circle %i at (%.3f,%.3f)\n", i, particles[i].xc, particles[i].yc);
/* generate new candidates */
naccepted = 0;
for (j=0; j<ncandidates; j++)
{
r = dpoisson*(2.0*(double)rand()/RAND_MAX + 1.0);
phi = DPI*(double)rand()/RAND_MAX;
x = particles[ncirc0 + i].xc + r*cos(phi);
y = particles[ncirc0 + i].yc + r*sin(phi);
// printf("Testing new circle at (%.3f,%.3f)\t", x, y);
far = 1;
for (k=0; k<ncircles; k++) if ((k!=i))
{
/* new circle is far away from circle k */
far = far*((x - particles[k].xc)*(x - particles[k].xc) + (y - particles[k].yc)*(y - particles[k].yc) >= dpoisson*dpoisson);
/* new circle is in domain */
far = far*(x < xmax)*(x > xmin)*(y < ymax)*(y > ymin);
// far = far*(vabs(x) < LAMBDA)*(y < INITYMAX)*(y > INITYMIN);
}
if (far) /* accept new circle */
{
printf("New circle at (%.3f,%.3f) accepted\n", x, y);
particles[ncircles].xc = x;
particles[ncircles].yc = y;
particles[ncircles].radius = radius;
particles[ncircles].active = 1;
particles[ncircles].added = 1;
particles[ncircles].coulomb = 1;
particles[ncircles].reactive = reactive;
active_poisson[ncircles] = 1;
ncircles++;
ncirc0++;
n_p_active++;
naccepted++;
}
// else printf("Rejected\n");
}
if (naccepted == 0) /* inactivate circle i */
{
// printf("No candidates work, inactivate circle %i\n", i);
active_poisson[i] = 0;
n_p_active--;
}
printf("%i active circles\n", n_p_active);
}
printf("Generated %i circles\n", ncircles);
break;
}
default:
{
printf("Function init_circle_config not defined for this pattern \n");
}
}
}
void init_people_config(t_person people[NMAXCIRCLES])
/* initialise particle configuration */
{
t_particle particles[NMAXCIRCLES];
int n;
init_particle_config(particles);
for (n=0; n<ncircles; n++)
{
people[n].xc = particles[n].xc;
people[n].yc = particles[n].yc;
people[n].radius = particles[n].radius;
people[n].active = particles[n].active;
}
}
void add_obstacle(double x, double y, double radius, t_obstacle obstacle[NMAXOBSTACLES])
/* add a circular obstacle to obstacle configuration */
{
if (nobstacles + 1 < NMAXOBSTACLES)
{
obstacle[nobstacles].xc = x;
obstacle[nobstacles].yc = y;
obstacle[nobstacles].radius = radius;
obstacle[nobstacles].active = 1;
nobstacles++;
}
else printf("Warning: NMAXOBSTACLES should be increased\n");
}
void sort_angles(double *angle, int n, int *table)
/* writes to table positions of angles in increasing order */
{
int i, j, temp;
double min, temp_angle[NMAX_OBSTACLE_NEIGHBOURS];
for (i=0; i<n; i++) table[i] = i;
/* bubble sort */
for (i = 0; i < n - 1; i++)
{
for (j = 0; j < n - i - 1; j++)
{
if (angle[table[j]] > angle[table[j+1]])
{
temp = table[j];
table[j] = table[j+1];
table[j+1] = temp;
}
}
}
/* TEST */
for (i=0; i<n; i++) temp_angle[i] = angle[i];
for (i=0; i<n; i++) angle[i] = temp_angle[table[i]];
}
int triangle_vertex_overlap(int s1, int t1, int u1, int s2, int t2, int u2, t_otriangle triangle1, t_otriangle triangle2, t_obstacle obstacle[NMAXOBSTACLES])
/* returns 1 if triangles with specified common vertices overlap */
{
int i1, j1, k1, i2, j2, k2;
double x1, y1, x2, y2, x3, y3, xp3, yp3, a, b, q1, q2;
i1 = triangle1.i[s1];
j1 = triangle1.i[t1];
k1 = triangle1.i[u1];
i2 = triangle2.i[s2];
j2 = triangle2.i[t2];
k2 = triangle2.i[u2];
x1 = obstacle[i1].xc;
y1 = obstacle[i1].yc;
x2 = obstacle[j1].xc;
y2 = obstacle[j1].yc;
x3 = obstacle[k1].xc;
y3 = obstacle[k1].yc;
xp3 = obstacle[k2].xc;
yp3 = obstacle[k2].yc;
a =y2 - y1;
b = x2 - x1;
q1 = a*(x3-x1) - b*(y3-y1);
q2 = a*(xp3-x1) - b*(yp3-y1);
return(q1*q2 > 0.0);
}
int old_triangle_overlap(t_otriangle triangle1, t_otriangle triangle2, t_obstacle obstacle[NMAXOBSTACLES])
/* returns 1 if triangles overlap */
{
int j, jplus, jminus;
/* find first vertex equal to triangle1.i[0] */
j = 0;
while (triangle2.i[j] != triangle1.i[0]) j++;
if (j < 3)
{
jplus = (j+1)%3;
jminus = (j+5)%3;
if (triangle1.i[1] == triangle2.i[jplus])
return(triangle_vertex_overlap(0, 1, 2, j, jplus, jminus, triangle1, triangle2, obstacle));
else if (triangle1.i[2] == triangle2.i[jminus])
return(triangle_vertex_overlap(2, 0, 1, j, jminus, jplus, triangle1, triangle2, obstacle));
else return(0);
}
else
{
if ((triangle1.i[1] == triangle2.i[1])&&(triangle1.i[2] == triangle2.i[2]))
return(triangle_vertex_overlap(1, 2, 0, 1, 2, 0, triangle1, triangle2, obstacle));
else return(0);
}
}
int triangle_overlap(t_otriangle triangle1, t_otriangle triangle2)
/* returns 1 if triangles overlap */
{
int j, jplus, jminus;
// printf("Testing triangles (%i, %i, %i) and (%i, %i, %i)\n", triangle1.i[0], triangle1.i[1], triangle1.i[2], triangle2.i[0], triangle2.i[1], triangle2.i[2]);
/* find first vertex equal to triangle1.i[0] */
j = 0;
while ((j<3)&&(triangle2.i[j] != triangle1.i[0])) j++;
if (j < 3)
{
jplus = (j+1)%3;
jminus = (j+5)%3;
if (triangle1.i[1] == triangle2.i[jplus])
return(1);
else if (triangle1.i[2] == triangle2.i[jminus])
return(1);
else return(0);
}
else
{
if ((triangle1.i[1] == triangle2.i[1])&&(triangle1.i[2] == triangle2.i[2]))
return(1);
else return(0);
}
}
int init_obstacle_facets(t_otriangle otriangle[NMAX_TRIANGLES_PER_OBSTACLE*NMAXOBSTACLES], t_ofacet ofacet[NMAXOBSTACLES])
/* group triangles into facets, for option COUPLE_OBSTACLES */
{
int i, j, k, n, ik, f, nt;
printf("Initializing obstacle facets from %i triangles\n", n_otriangles);
// printf("1\n");
// printf("2\n");
for (i=0; i<n_otriangles; i++) otriangle[i].infacet = 0;
for (i=0; i<NMAXOBSTACLES; i++) ofacet[i].ntriangles = 0;
// printf("3\n");
n_ofacets = 0;
i = 0;
while (i < n_otriangles)
{
// printf("Triangle %i\t", i);
if (!otriangle[i].infacet)
{
otriangle[i].infacet = 1;
ofacet[n_ofacets].ntriangles = 1;
ofacet[n_ofacets].triangle[0] = i;
j = i + 1;
while ((j < n_otriangles)&&(ofacet[n_ofacets].ntriangles < NMAX_TRIANGLES_PER_FACET))
{
n = ofacet[n_ofacets].ntriangles;
for (k=0; k<n; k++)
{
ik = ofacet[n_ofacets].triangle[k];
if ((!otriangle[j].infacet)&&(triangle_overlap(otriangle[ik], otriangle[j])))
{
ofacet[n_ofacets].ntriangles++;
ofacet[n_ofacets].triangle[n] = j;
otriangle[j].infacet = 1;
}
}
j++;
}
nt = ofacet[n_ofacets].ntriangles;
// printf("Facet %i contains %i triangles: ", n_ofacets, nt);
// for (f=0; f<nt; f++) printf("%i ", ofacet[n_ofacets].triangle[f]);
// printf("\n");
n_ofacets++;
}
i++;
}
if (n_ofacets > NMAXOBSTACLES)
{
printf("NMAXOBSTACLES should be at least %i\n", n_ofacets);
exit(1);
}
return(n_ofacets);
}
double otriangle_area(t_obstacle obstacle[NMAXOBSTACLES], t_otriangle triangle)
{
int s1, s2, s3;
s1 = triangle.i[0];
s2 = triangle.i[1];
s3 = triangle.i[2];
return(vabs(triangle_area(obstacle[s1].xc, obstacle[s1].yc, obstacle[s2].xc, obstacle[s2].yc, obstacle[s3].xc, obstacle[s3].yc)));
}
int init_obstacle_coupling(t_obstacle obstacle[NMAXOBSTACLES], t_otriangle otriangle[NMAX_TRIANGLES_PER_OBSTACLE*NMAXOBSTACLES], t_ofacet ofacet[NMAXOBSTACLES])
/* initialize list of neighbours, for option COUPLE_OBSTACLES */
{
int i, j, n, m, table[NMAX_OBSTACLE_NEIGHBOURS], neigh_table[NMAX_OBSTACLE_NEIGHBOURS];
double dist, bdistx, bdisty, angle[NMAX_OBSTACLE_NEIGHBOURS], dist_table[NMAX_OBSTACLE_NEIGHBOURS];
short int near_boundary;
printf("Initializing obstacle neighbours\n");
n_otriangles = 0;
for (i=0; i<nobstacles; i++) obstacle[i].nneighb = 0;
for (i=0; i<nobstacles; i++)
{
for (j=i+1; j<nobstacles; j++) if (j != i)
{
dist = module2(obstacle[i].xc - obstacle[j].xc, obstacle[i].yc - obstacle[j].yc);
if ((dist < OBSTACLE_COUPLING_DIST)&&(obstacle[i].nneighb < NMAX_OBSTACLE_NEIGHBOURS))
{
n = obstacle[i].nneighb;
obstacle[i].neighb[n] = j;
obstacle[i].eqdist[n] = dist;
obstacle[i].nneighb++;
n = obstacle[j].nneighb;
obstacle[j].neighb[n] = i;
obstacle[j].eqdist[n] = dist;
obstacle[j].nneighb++;
}
}
// for (i=0; i<nobstacles; i++)
// {
// obstacle[i].nneighb = 0;
// for (j=0; j<nobstacles; j++) if (j != i)
// {
// dist = module2(obstacle[i].xc - obstacle[j].xc, obstacle[i].yc - obstacle[j].yc);
// if ((dist < OBSTACLE_COUPLING_DIST)&&(obstacle[i].nneighb < NMAX_OBSTACLE_NEIGHBOURS))
// {
// n = obstacle[i].nneighb;
// obstacle[i].neighb[n] = j;
// obstacle[i].eqdist[n] = dist;
// obstacle[i].nneighb++;
// }
// }
// printf("Obstacle %i has %i neighbours\t", i, obstacle[i].nneighb);
/* sort neighbours by angle */
n = obstacle[i].nneighb;
for (j=0; j<n; j++)
{
m = obstacle[i].neighb[j];
angle[j] = argument(obstacle[m].xc - obstacle[i].xc, obstacle[m].yc - obstacle[i].yc);
if (angle[j] < 0.0) angle[j] += DPI;
}
sort_angles(angle, n, table);
// for (j=0; j<n; j++) printf("angle %i = %.3lg\t", j, angle[j]*180.0/PI);
// printf("\n");
/* update neighbour list */
for (j=0; j<n; j++)
{
neigh_table[j] = obstacle[i].neighb[j];
dist_table[j] = obstacle[i].eqdist[j];
}
for (j=0; j<n; j++)
{
obstacle[i].neighb[j] = neigh_table[table[j]];
obstacle[i].eqdist[j] = dist_table[table[j]];
}
/* build list of triangles */
if (FILL_OBSTACLE_TRIANGLES)
{
// printf("Building triangle %i\n", n_otriangles);
for (j=0; j<n-1; j++) if (angle[j+1] - angle[j] < PI)
{
otriangle[n_otriangles].i[0] = i;
otriangle[n_otriangles].i[1] = obstacle[i].neighb[j];
otriangle[n_otriangles].i[2] = obstacle[i].neighb[j+1];
n_otriangles++;
}
if (angle[0] - angle[n-1] + DPI < PI)
{
otriangle[n_otriangles].i[0] = i;
otriangle[n_otriangles].i[1] = obstacle[i].neighb[n-1];
otriangle[n_otriangles].i[2] = obstacle[i].neighb[0];
n_otriangles++;
}
}
}
/* initialize triangle areas */
for (i=0; i<n_otriangles; i++)
otriangle[i].area0 = otriangle_area(obstacle, otriangle[i]);
/* build facet table */
printf("Initializing facets from %i triangles\n", n_otriangles);
if (FILL_OBSTACLE_TRIANGLES) n_ofacets = init_obstacle_facets(otriangle, ofacet);
/* pin obstacles that have less than NMAX_OBSTACLE_PINNED neighbours */
bdistx = (BCXMAX - BCXMIN)/(double)NOBSX;
bdisty = (BCYMAX - BCYMIN)/(double)NOBSY;
for (i=0; i<nobstacles; i++)
{
near_boundary = ((obstacle[i].xc <= BCXMIN + bdistx)||(obstacle[i].xc >= BCXMAX - bdistx)||(obstacle[i].yc <= BCYMIN + bdisty)||(obstacle[i].yc >= BCYMAX - bdisty));
switch (OBSTACLE_PINNING_TYPE) {
case (OP_NPINNED):
{
obstacle[i].pinned = (obstacle[i].nneighb <= NMAX_OBSTACLE_PINNED);
break;
}
case (OP_LEFT):
{
obstacle[i].pinned = (obstacle[i].xc <= BCXMIN + bdistx);
break;
}
case (OP_LEFTTOPBOT):
{
obstacle[i].pinned = near_boundary;
break;
}
case (OP_CORNERS):
{
obstacle[i].pinned = (((obstacle[i].xc <= BCXMIN + bdistx)||(obstacle[i].xc >= BCXMAX - bdistx))&&((obstacle[i].yc <= BCYMIN + bdisty)||(obstacle[i].yc >= BCYMAX - bdisty)));
break;
}
case (OP_LEFTCORNERS):
{
obstacle[i].pinned = ((near_boundary)&&((obstacle[i].xc < 0.0)||(obstacle[i].xc > BCXMAX - bdistx)));
break;
}
case (OP_BNDRY_STEP):
{
obstacle[i].pinned = ((near_boundary)&&(obstacle[i].chessboard == 0));
}
}
}
printf("Found %i facets\n", n_ofacets);
// for (i=0; i<n_ofacets; i++)
// {
// printf("Facet %i has %i triangles: ", i, ofacet[i].ntriangles);
// for (j=0; j<ofacet[i].ntriangles; j++)
// {
// n = ofacet[i].triangle[j];
// printf("%i (%i, %i, %i)", n, otriangle[n].i[0], otriangle[n].i[1], otriangle[n].i[2]);
// }
// printf("\n");
// }
// for (i=0; i<n_otriangles; i++)
// {
// printf("Triangle %i has vertices (%i, %i, %i)\n", i, otriangle[i].i[0], otriangle[i].i[1], otriangle[i].i[2]);
// }
//
// exit(0);
printf("Facets initialized\n");
return(n_ofacets);
}
int reset_obstacle_coupling(t_obstacle obstacle[NMAXOBSTACLES], t_otriangle otriangle[NMAX_TRIANGLES_PER_OBSTACLE*NMAXOBSTACLES], t_ofacet ofacet[NMAXOBSTACLES])
/* initialize list of neighbours, for option COUPLE_OBSTACLES */
{
int i, j, n, m, table[NMAX_OBSTACLE_NEIGHBOURS], neigh_table[NMAX_OBSTACLE_NEIGHBOURS];
double dist, dist1, bdistx, bdisty, angle[NMAX_OBSTACLE_NEIGHBOURS], dist_table[NMAX_OBSTACLE_NEIGHBOURS];
short int *connected;
connected = (short int *)malloc(nobstacles*sizeof(short int));
printf("Resetting obstacle neighbours\n");
n_otriangles = 0;
// for (i=0; i<nobstacles; i++) obstacle[i].nneighb = 0;
for (i=0; i<nobstacles; i++)
{
for (j=0; j<nobstacles; j++) connected[j] = 0;
n = obstacle[i].nneighb;
for (j=0; j<n; j++)
{
m = obstacle[i].neighb[j];
connected[m] = 1;
// printf("Obstacle %i is connected to obstacle %i\n", m, i);
}
obstacle[i].nneighb = 0;
for (j=0; j<nobstacles; j++) if (j!=i)
{
dist = module2(obstacle[i].xc - obstacle[j].xc, obstacle[i].yc - obstacle[j].yc);
if (connected[j])
{
if ((dist < UNCOUPLE_MAXLENGTH*OBSTACLE_COUPLING_DIST)&&(obstacle[i].nneighb < NMAX_OBSTACLE_NEIGHBOURS))
{
n = obstacle[i].nneighb;
obstacle[i].neighb[n] = j;
dist1 = obstacle[i].eqdist[n];
obstacle[i].eqdist[n] = dist;
// obstacle[i].eqdist[n] = 0.99*dist + 0.01*dist1;
obstacle[i].nneighb++;
}
}
else
{
if ((dist < COUPLE_MINLENGTH*OBSTACLE_COUPLING_DIST)&&(obstacle[i].nneighb < NMAX_OBSTACLE_NEIGHBOURS))
{
n = obstacle[i].nneighb;
obstacle[i].neighb[n] = j;
obstacle[i].eqdist[n] = dist;
obstacle[i].nneighb++;
}
}
}
// for (j=i+1; j<nobstacles; j++)
// {
// dist = module2(obstacle[i].xc - obstacle[j].xc, obstacle[i].yc - obstacle[j].yc);
// if ((dist < OBSTACLE_COUPLING_DIST)&&(obstacle[i].nneighb < NMAX_OBSTACLE_NEIGHBOURS))
// {
// n = obstacle[i].nneighb;
// obstacle[i].neighb[n] = j;
// obstacle[i].eqdist[n] = dist;
// obstacle[i].nneighb++;
//
// n = obstacle[j].nneighb;
// obstacle[j].neighb[n] = i;
// obstacle[j].eqdist[n] = dist;
// obstacle[j].nneighb++;
// }
// }
// printf("Obstacle %i has %i neighbours\t", i, obstacle[i].nneighb);
// }
// for (i=0; i<nobstacles; i++)
// {
/* sort neighbours by angle */
n = obstacle[i].nneighb;
for (j=0; j<n; j++)
{
m = obstacle[i].neighb[j];
angle[j] = argument(obstacle[m].xc - obstacle[i].xc, obstacle[m].yc - obstacle[i].yc);
if (angle[j] < 0.0) angle[j] += DPI;
}
sort_angles(angle, n, table);
// for (j=0; j<n; j++) printf("angle %i = %.3lg\t", j, angle[j]*180.0/PI);
// printf("\n");
/* update neighbour list */
for (j=0; j<n; j++)
{
neigh_table[j] = obstacle[i].neighb[j];
dist_table[j] = obstacle[i].eqdist[j];
}
for (j=0; j<n; j++)
{
obstacle[i].neighb[j] = neigh_table[table[j]];
obstacle[i].eqdist[j] = dist_table[table[j]];
}
/* build list of triangles */
if (FILL_OBSTACLE_TRIANGLES)
{
// printf("Building triangle %i\n", n_otriangles);
for (j=0; j<n-1; j++) if (angle[j+1] - angle[j] < PI)
{
otriangle[n_otriangles].i[0] = i;
otriangle[n_otriangles].i[1] = obstacle[i].neighb[j];
otriangle[n_otriangles].i[2] = obstacle[i].neighb[j+1];
n_otriangles++;
}
if (angle[0] - angle[n-1] + DPI < PI)
{
otriangle[n_otriangles].i[0] = i;
otriangle[n_otriangles].i[1] = obstacle[i].neighb[n-1];
otriangle[n_otriangles].i[2] = obstacle[i].neighb[0];
n_otriangles++;
}
}
}
/* initialize triangle areas */
for (i=0; i<n_otriangles; i++)
otriangle[i].area0 = otriangle_area(obstacle, otriangle[i]);
/* build facet table */
printf("Initializing facets from %i triangles\n", n_otriangles);
if (FILL_OBSTACLE_TRIANGLES) n_ofacets = init_obstacle_facets(otriangle, ofacet);
free(connected);
printf("Facets initialized\n");
return(n_ofacets);
}
void init_obstacle_config(t_obstacle obstacle[NMAXOBSTACLES], t_otriangle otriangle[NMAX_TRIANGLES_PER_OBSTACLE*NMAXOBSTACLES], t_ofacet ofacet[NMAXOBSTACLES])
/* initialise circular obstacle configuration */
{
int i, j, n, jmin, jmax, nx, ny, ntot;
double x, y, dx, dy, width, lpocket, xmid = 0.5*(BCXMIN + BCXMAX), radius, c;
t_point *point;
/* set default rotation to 0 */
for (i=0; i<NMAXOBSTACLES; i++)
{
obstacle[i].omega = 0.0;
obstacle[i].angle = 0.0;
obstacle[i].oscillate = 0;
obstacle[i].vx = 0.0;
obstacle[i].vy = 0.0;
obstacle[i].mass = OBSTACLE_MASS;
}
switch (OBSTACLE_PATTERN) {
case (O_CORNERS):
{
n = 0;
for (i = 0; i < 2; i++)
for (j = 0; j < 2; j++)
{
obstacle[n].xc = BCXMIN + ((double)i)*(BCXMAX - BCXMIN);
obstacle[n].yc = BCYMIN + ((double)j)*(BCYMAX - BCYMIN);
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
}
nobstacles = n;
break;
}
case (O_GALTON_BOARD):
{
dy = (YMAX - YMIN)/((double)NGRIDX + 3);
dx = dy/cos(PI/6.0);
n = 0;
for (i = 0; i < NGRIDX + 1; i++)
for (j = 0; j < i; j++)
{
obstacle[n].yc = YMAX - ((double)i)*dy;
obstacle[n].xc = ((double)j - 0.5*(double)i + 0.5)*dx;
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
}
nobstacles = n;
break;
}
case (O_GALTON_BOARD_WIDE):
{
dy = (YMAX - YMIN)/((double)NGRIDX + 3);
dx = dy/cos(PI/6.0);
n = 0;
for (i = 1; i < NGRIDX + 1; i++)
for (j = -5; j < i+5; j++)
{
obstacle[n].yc = YMAX - ((double)i)*dy;
obstacle[n].xc = ((double)j - 0.5*(double)i + 0.5)*dx;
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
}
nobstacles = n;
break;
}
case (O_GENUS_TWO):
{
n = 0;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
{
obstacle[n].xc = BCXMIN + 0.5*((double)i)*(BCXMAX - BCXMIN);
obstacle[n].yc = BCYMIN + 0.5*((double)j)*(BCYMAX - BCYMIN);
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
}
nobstacles = n;
break;
}
case (O_POOL_TABLE):
{
lpocket = 0.1;
width = 0.5*MU;
radius = 2.0*width;
add_obstacle(BCXMIN + lpocket, BCYMIN - width, radius, obstacle);
add_obstacle(xmid - lpocket, BCYMIN - width, radius, obstacle);
add_obstacle(xmid + lpocket, BCYMIN - width, radius, obstacle);
add_obstacle(BCXMAX - lpocket, BCYMIN - width, radius, obstacle);
add_obstacle(BCXMAX + width, BCYMIN + lpocket, radius, obstacle);
add_obstacle(BCXMAX + width, BCYMAX - lpocket, radius, obstacle);
add_obstacle(BCXMIN + lpocket, BCYMAX + width, radius, obstacle);
add_obstacle(xmid - lpocket, BCYMAX + width, radius, obstacle);
add_obstacle(xmid + lpocket, BCYMAX + width, radius, obstacle);
add_obstacle(BCXMAX - lpocket, BCYMAX + width, radius, obstacle);
add_obstacle(BCXMIN - width, BCYMIN + lpocket, radius, obstacle);
add_obstacle(BCXMIN - width, BCYMAX - lpocket, radius, obstacle);
break;
}
case (O_HLINE_HOLE_SPOKES):
{
radius = 2.0*MU;
for (i=-3; i<4; i+=2)
add_obstacle(0.5*(double)i, YMIN + 0.3, radius, obstacle);
break;
}
case (O_CIRCLE):
{
n = 0;
obstacle[n].xc = 0.0;
obstacle[n].yc = 0.0;
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
nobstacles = 1;
break;
}
case (O_FOUR_CIRCLES):
{
n = 0;
obstacle[n].xc = -1.5;
obstacle[n].yc = -0.5;
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
obstacle[n].xc = -0.5;
obstacle[n].yc = 0.5;
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
obstacle[n].xc = 0.5;
obstacle[n].yc = -0.5;
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
obstacle[n].xc = 1.5;
obstacle[n].yc = 0.5;
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
nobstacles = 4;
break;
}
case (O_HEX):
{
dx = (OBSXMAX - OBSXMIN)/(double)NOBSX;
dy = (OBSYMAX - OBSYMIN)/(double)NOBSY;
n = 0;
if ((ADD_FIXED_SEGMENTS)&&(SEGMENT_PATTERN == S_CYLINDER))
/* pseudo-cylindrical boundary conditions (e.g. for Hall effect) */
{
jmin = 1;
jmax = NOBSY-1;
}
else
{
jmin = 0;
jmax = NOBSY;
}
for (i=0; i<NOBSX; i++)
for (j=jmin; j<jmax; j++)
{
obstacle[n].xc = OBSXMIN + ((double)i + 0.25)*dx;
obstacle[n].yc = OBSYMIN + ((double)j + 0.5)*dy;
if (j%2 == 1) obstacle[n].xc += 0.5*dx;
if (obstacle[n].xc > OBSXMAX) obstacle[n].xc += (OBSXMAX - OBSXMIN);
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
}
nobstacles = n;
break;
}
case (O_SQUARE):
{
dx = (OBSXMAX - OBSXMIN)/(double)NOBSX;
dy = (OBSYMAX - OBSYMIN)/(double)NOBSY;
n = 0;
if ((ADD_FIXED_SEGMENTS)&&(SEGMENT_PATTERN == S_CYLINDER))
/* pseudo-cylindrical boundary conditions (e.g. for Hall effect) */
{
jmin = 1;
jmax = NOBSY-1;
}
else
{
jmin = 0;
jmax = NOBSY;
}
for (i=0; i<NOBSX; i++)
for (j=jmin; j<jmax; j++)
{
obstacle[n].xc = OBSXMIN + ((double)i + 0.25)*dx;
obstacle[n].yc = OBSYMIN + ((double)j + 0.5)*dy;
if (obstacle[n].xc > OBSXMAX) obstacle[n].xc += (OBSXMAX - OBSXMIN);
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
obstacle[n].chessboard = (i+j)%BDRY_PINNING_STEP;
n++;
}
nobstacles = n;
break;
}
case (O_SQUARE_TWOMASSES):
{
dx = (XMAX - XMIN)/(double)NOBSX;
dy = (YMAX - YMIN)/(double)NOBSY;
n = 0;
if ((ADD_FIXED_SEGMENTS)&&(SEGMENT_PATTERN == S_CYLINDER))
/* pseudo-cylindrical boundary conditions (e.g. for Hall effect) */
{
jmin = 1;
jmax = NOBSY-1;
}
else
{
jmin = 0;
jmax = NOBSY;
}
for (i=0; i<NOBSX; i++)
for (j=jmin; j<jmax; j++)
{
obstacle[n].xc = XMIN + ((double)i + 0.25)*dx;
obstacle[n].yc = YMIN + ((double)j + 0.5)*dy;
if (obstacle[n].xc > XMAX) obstacle[n].xc += (XMAX - XMIN);
obstacle[n].radius = OBSTACLE_RADIUS;
if ((i+j)%2 == 0)
{
obstacle[n].radius *= sqrt(2.0);
obstacle[n].mass *= 2.0;
}
obstacle[n].active = 1;
obstacle[n].chessboard = (i+j)%BDRY_PINNING_STEP;
n++;
}
nobstacles = n;
break;
}
case (O_SIDES):
{
n = 0;
for (i = 0; i < 9; i++)
for (j = 0; j < 5; j++)
if ((i == 0)||(i == 8)||(j == 0)||(j == 4))
{
obstacle[n].xc = BCXMIN + 0.125*((double)i)*(BCXMAX - BCXMIN);
obstacle[n].yc = BCYMIN + 0.25*((double)j)*(BCYMAX - BCYMIN);
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
}
nobstacles = n;
break;
}
case (O_SIDES_B):
{
n = 0;
nx = 16;
ny = 8;
dx = (BCXMAX - BCXMIN)/(double)nx;
dy = (BCYMAX - BCYMIN)/(double)ny;
for (i = 0; i < nx+1; i++)
for (j = 0; j < ny+1; j++)
if ((i == 0)||(i == nx)||(j == 0)||(j == ny))
{
obstacle[n].xc = BCXMIN + (double)i*dx;
obstacle[n].yc = BCYMIN + (double)j*dy;
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
n++;
}
nobstacles = n;
break;
}
case (O_SIEVE):
{
n = 0;
width = 1.0;
dx = width/12.0;
dy = dx*0.6;
for (i = 0; i < 13; i++)
{
obstacle[n].xc = -1.0 + (double)i*dx;
obstacle[n].yc = 0.7 - (double)i*dy;
obstacle[n].radius = 0.95*OBSTACLE_RADIUS;
obstacle[n].omega = 1.25*OBSTACLE_OMEGA;
obstacle[n].active = 1;
n++;
}
for (i = 0; i < 13; i++)
{
obstacle[n].xc = -1.0 + (double)i*dx;
obstacle[n].yc = 0.2 - (double)i*dy;
obstacle[n].radius = 1.2*OBSTACLE_RADIUS;
obstacle[n].omega = OBSTACLE_OMEGA;
obstacle[n].active = 1;
n++;
}
for (i = 0; i < 13; i++)
{
obstacle[n].xc = -1.0 + (double)i*dx;
obstacle[n].yc = -0.3 - (double)i*dy;
obstacle[n].radius = 1.6*OBSTACLE_RADIUS;
obstacle[n].omega = 0.75*OBSTACLE_OMEGA;
obstacle[n].active = 1;
n++;
}
nobstacles = n;
break;
}
case (O_SIEVE_B):
{
n = 0;
width = 1.2;
dx = width/14.0;
dy = dx*0.6;
for (i = 0; i < 15; i++)
{
obstacle[n].xc = -1.2 + (double)i*dx;
obstacle[n].yc = 0.85 - (double)i*dy;
obstacle[n].radius = 0.9*OBSTACLE_RADIUS;
obstacle[n].omega = 1.25*OBSTACLE_OMEGA;
obstacle[n].active = 1;
n++;
}
for (i = 0; i < 15; i++)
{
obstacle[n].xc = -1.2 + (double)i*dx;
obstacle[n].yc = 0.35 - (double)i*dy;
obstacle[n].radius = 1.2*OBSTACLE_RADIUS;
obstacle[n].omega = OBSTACLE_OMEGA;
obstacle[n].active = 1;
n++;
}
for (i = 0; i < 15; i++)
{
obstacle[n].xc = -1.2 + (double)i*dx;
obstacle[n].yc = -0.15 - (double)i*dy;
obstacle[n].radius = 1.6*OBSTACLE_RADIUS;
obstacle[n].omega = 0.75*OBSTACLE_OMEGA;
obstacle[n].active = 1;
n++;
}
if (RATTLE_OBSTACLES) for (i = 0; i < n; i++)
{
obstacle[i].oscillate = 1;
obstacle[i].period = 8;
obstacle[i].amplitude = 0.0015;
obstacle[i].phase = (double)i*DPI/10.0;
}
nobstacles = n;
break;
}
case (O_SIEVE_LONG):
{
n = 0;
ntot = 36;
width = 1.2;
dx = (XMAX - XMIN)/(double)ntot;
dy = dx*0.3;
for (i = 0; i < ntot + 1; i++)
{
obstacle[n].xc = XMIN + (double)i*dx;
obstacle[n].yc = 0.6 - (double)i*dy;
obstacle[n].radius = OBSTACLE_RADIUS*(2.4 - 1.6*(double)i/(double)ntot);
obstacle[n].omega = OBSTACLE_OMEGA;
obstacle[n].active = 1;
n++;
}
if (RATTLE_OBSTACLES) for (i = 0; i < n; i++)
{
obstacle[i].oscillate = 1;
obstacle[i].period = 8;
obstacle[i].amplitude = 0.0018;
obstacle[i].phase = (double)i*DPI/10.0;
}
nobstacles = n;
break;
}
case (O_SIEVE_LONG_B):
{
n = 0;
ntot = 45;
width = 1.2;
dx = (XMAX - XMIN)/(double)ntot;
dy = dx*0.2;
x = XMIN;
y = 0.4;
c = 0.019;
while (x < XMAX)
{
obstacle[n].xc = x;
obstacle[n].yc = y;
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].omega = OBSTACLE_OMEGA;
obstacle[n].active = 1;
x += dx;
y -= dy;
dx += c*dx;
dy += c*dy;
n++;
}
if (RATTLE_OBSTACLES) for (i = 0; i < n; i++)
{
obstacle[i].oscillate = 1;
obstacle[i].period = 8;
obstacle[i].amplitude = 0.0018;
obstacle[i].phase = (double)i*DPI/10.0;
}
nobstacles = n;
break;
}
case (O_SIEVE_VIDEO1400):
{
n = 0;
ntot = 28;
width = 1.2;
dx = 2.9/(double)ntot;
dy = dx*0.3;
for (i = 0; i < ntot + 1; i++)
{
obstacle[n].xc = 2.5 + (double)i*dx;
obstacle[n].yc = 0.6 - (double)i*dy;
obstacle[n].radius = OBSTACLE_RADIUS*(2.4 - 1.6*(double)i/(double)ntot);
obstacle[n].omega = OBSTACLE_OMEGA;
obstacle[n].active = 1;
n++;
}
if (RATTLE_OBSTACLES) for (i = 0; i < n; i++)
{
obstacle[i].oscillate = 1;
obstacle[i].period = 8;
obstacle[i].amplitude = 0.0018;
obstacle[i].phase = (double)i*DPI/10.0;
}
nobstacles = n;
break;
}
case (O_POISSON_DISC):
{
point = (t_point *)malloc(NMAXOBSTACLES*sizeof(t_point));
nobstacles = generate_poisson_discs(point, NMAXOBSTACLES, OBSXMIN, OBSXMAX, OBSYMIN, OBSYMAX, OBSTACLE_PISC_DISTANCE);
printf("Generated %i obstacles\n", nobstacles);
for (n=0; n<nobstacles; n++)
{
// printf("Obstacle %i at (%.3lg, %.3lg)\n", n, point[n].xc, point[n].yc);
obstacle[n].xc = point[n].xc;
obstacle[n].yc = point[n].yc;
if (obstacle[n].xc > XMAX) obstacle[n].xc += (XMAX - XMIN);
obstacle[n].radius = OBSTACLE_RADIUS;
obstacle[n].active = 1;
}
free(point);
break;
}
default:
{
printf("Function init_obstacle_config not defined for this pattern \n");
}
}
if (CHARGE_OBSTACLES)
for (n=0; n<nobstacles; n++) obstacle[n].charge = OBSTACLE_CHARGE;
for (n=0; n<nobstacles; n++)
{
obstacle[n].omega0 = obstacle[n].omega;
obstacle[n].xc0 = obstacle[n].xc;
obstacle[n].yc0 = obstacle[n].yc;
obstacle[n].nneighb = 0;
}
if (COUPLE_OBSTACLES) init_obstacle_coupling(obstacle, otriangle, ofacet);
}
void add_rotated_angle_to_segments(double x1, double y1, double x2, double y2, double width, int center, t_segment segment[NMAXSEGMENTS], int group)
/* add four segments forming a rectangle, specified by two adjacent corners and width */
{
double tx, ty, ux, uy, norm, x3, y3, x4, y4, angle;
int i, n = nsegments;
tx = x2 - x1;
ty = y2 - y1;
norm = module2(tx, ty);
tx = tx/norm;
ty = ty/norm;
if (center)
{
x2 -= 0.5*width*ty;
y2 += 0.5*width*tx;
x1 -= 0.5*width*ty;
y1 += 0.5*width*tx;
}
x3 = x2 + width*ty;
y3 = y2 - width*tx;
x4 = x1 + width*ty;
y4 = y1 - width*tx;
if (nsegments + 4 < NMAXSEGMENTS)
{
segment[n].x1 = x1;
segment[n].y1 = y1;
segment[n].x2 = x2;
segment[n].y2 = y2;
segment[n+1].x1 = x2;
segment[n+1].y1 = y2;
segment[n+1].x2 = x3;
segment[n+1].y2 = y3;
segment[n+2].x1 = x3;
segment[n+2].y1 = y3;
segment[n+2].x2 = x4;
segment[n+2].y2 = y4;
segment[n+3].x1 = x4;
segment[n+3].y1 = y4;
segment[n+3].x2 = x1;
segment[n+3].y2 = y1;
segment[n].angle1 = -PID;
segment[n].angle2 = 0.0;
segment[n+1].angle1 = PI;
segment[n+1].angle2 = 1.5*PI;
segment[n+2].angle1 = PID;
segment[n+2].angle2 = PI;
segment[n+3].angle1 = 0.0;
segment[n+3].angle2 = PID;
angle = argument(tx, ty) + PI;
for (i=0; i<4; i++)
{
segment[n+i].angle1 += angle;
segment[n+i].angle2 += angle;
segment[n+i].concave = 1;
segment[n+i].group = group;
}
nsegments += 4;
}
else printf("Warning: NMAXSEGMENTS too small\n");
}
void add_rectangle_to_segments(double x1, double y1, double x2, double y2, t_segment segment[NMAXSEGMENTS], int group)
/* add four segements forming a rectangle to linear obstacle configuration */
{
int i, n = nsegments, nplus, nminus;
if (nsegments + 4 < NMAXSEGMENTS)
{
segment[n].x1 = x1;
segment[n].y1 = y1;
segment[n].x2 = x2;
segment[n].y2 = y1;
segment[n+1].x1 = x2;
segment[n+1].y1 = y1;
segment[n+1].x2 = x2;
segment[n+1].y2 = y2;
segment[n+2].x1 = x2;
segment[n+2].y1 = y2;
segment[n+2].x2 = x1;
segment[n+2].y2 = y2;
segment[n+3].x1 = x1;
segment[n+3].y1 = y2;
segment[n+3].x2 = x1;
segment[n+3].y2 = y1;
segment[n].angle1 = -PID;
segment[n].angle2 = 0.0;
segment[n+1].angle1 = PI;
segment[n+1].angle2 = 1.5*PI;
segment[n+2].angle1 = PID;
segment[n+2].angle2 = PI;
segment[n+3].angle1 = 0.0;
segment[n+3].angle2 = PID;
for (i=0; i<4; i++)
{
segment[n+i].concave = 1;
segment[n+i].group = group;
}
nsegments += 4;
}
else printf("Warning: NMAXSEGMENTS too small\n");
}
void add_circle_to_segments(double x, double y, double r, int nsegs, double angle0, t_segment segment[NMAXSEGMENTS], int group)
/* add segments forming a circle/polygon to linear obstacle configuration */
{
int i, n = nsegments, nplus, nminus;
double angle;
angle = DPI/(double)nsegs;
if (nsegments + nsegs < NMAXSEGMENTS)
{
for (i=0; i<nsegs; i++)
{
segment[n+i].x1 = x + r*cos(((double)i)*angle + angle0*PID);
segment[n+i].y1 = y - r*sin(((double)i)*angle + angle0*PID);
segment[n+i].x2 = x + r*cos(((double)(i+1))*angle + angle0*PID);
segment[n+i].y2 = y - r*sin(((double)(i+1))*angle + angle0*PID);
segment[n+i].angle1 = -((double)i + 0.5)*angle - angle0*PID;
segment[n+i].angle2 = -((double)i - 0.5)*angle - angle0*PID;
while (segment[n+i].angle1 < 0.0) segment[n+i].angle1 += DPI;
while (segment[n+i].angle2 < segment[n+i].angle1) segment[n+i].angle2 += DPI;
segment[n+i].concave = 1;
segment[n+i].group = group;
}
nsegments += nsegs;
}
else printf("Warning: NMAXSEGMENTS too small\n");
}
void add_tree_to_segments(double x, double y, double r, double lfoot[2], double rfoot[2], t_segment segment[NMAXSEGMENTS], int group)
/* add segments forming a tree to linear obstacle configuration */
{
int i, n = nsegments, nplus, nminus, nadd;
double angle, h, h1, h2, h3, x1, x2, xp1, xp2, dx1, dx2, xt, yt;
angle = PI/3.0;
h = r*tan(angle);
h1 = 0.56*h;
h2 = h1;
dx1 = h1/tan(angle);
dx2 = 0.5*dx1;
x1 = r - dx1;
xp1 = x1 + dx2;
x2 = xp1 - dx1;
xp2 = x2 + dx2;
h3 = xp2*tan(angle);
xt = 0.5*dx2;
yt = dx1;
nadd = 15;
if (nsegments + nadd < NMAXSEGMENTS)
{
/* bottom left */
segment[n].x1 = x - r;
segment[n].y1 = y;
segment[n].angle1 = PID + angle;
segment[n].angle2 = PI + PID;
segment[n].concave = 1;
n++;
/* level 1 */
segment[n].x1 = x - x1;
segment[n].y1 = y + h1;
segment[n].concave = 0;
n++;
segment[n].x1 = x - xp1;
segment[n].y1 = y + h1;
segment[n].angle1 = PID + angle;
segment[n].angle2 = PI + PID;
segment[n].concave = 1;
n++;
/* level 2 */
segment[n].x1 = x - x2;
segment[n].y1 = y + h1 + h2;
segment[n].concave = 0;
n++;
segment[n].x1 = x - xp2;
segment[n].y1 = y + h1 + h2;
segment[n].angle1 = PID + angle;
segment[n].angle2 = PI + PID;
segment[n].concave = 1;
n++;
/* top */
segment[n].x1 = x;
segment[n].y1 = y + h1 + h2 + h3;
segment[n].angle1 = PID - angle;
segment[n].angle2 = PID + angle;
segment[n].concave = 1;
n++;
/* level 2 */
segment[n].x1 = x + xp2;
segment[n].y1 = y + h1 + h2;
segment[n].angle1 = -PID;
segment[n].angle2 = angle;
segment[n].concave = 1;
n++;
segment[n].x1 = x + x2;
segment[n].y1 = y + h1 + h2;
segment[n].concave = 0;
n++;
/* level 1 */
segment[n].x1 = x + xp1;
segment[n].y1 = y + h1;
segment[n].angle1 = -PID;
segment[n].angle2 = angle;
segment[n].concave = 1;
n++;
segment[n].x1 = x + x1;
segment[n].y1 = y + h1;
segment[n].concave = 0;
n++;
/* bottom right */
segment[n].x1 = x + r;
segment[n].y1 = y;
segment[n].angle1 = -PID;
segment[n].angle2 = angle;
segment[n].concave = 1;
n++;
/*stem */
segment[n].x1 = x + xt;
segment[n].y1 = y;
segment[n].concave = 0;
n++;
segment[n].x1 = x + xt;
segment[n].y1 = y - yt;
segment[n].angle1 = -PID;
segment[n].angle2 = 0.0;
segment[n].concave = 1;
n++;
segment[n].x1 = x - xt;
segment[n].y1 = y - yt;
segment[n].angle1 = PI;
segment[n].angle2 = 3.0*PID;
segment[n].concave = 1;
n++;
segment[n].x1 = x - xt;
segment[n].y1 = y;
segment[n].concave = 0;
n++;
rfoot[0] = x + xt;
rfoot[1] = y - yt;
lfoot[0] = x - xt;
lfoot[1] = y - yt;
for (i=0; i<nadd-1; i++)
{
segment[nsegments+i].x2 = segment[nsegments+i+1].x1;
segment[nsegments+i].y2 = segment[nsegments+i+1].y1;
}
segment[nsegments+nadd-1].x2 = segment[nsegments].x1;
segment[nsegments+nadd-1].y2 = segment[nsegments].y1;
for (i=0; i<nadd; i++)
{
// segment[nsegments+i].concave = 1;
segment[nsegments+i].group = group;
}
nsegments += nadd;
}
else printf("Warning: NMAXSEGMENTS too small\n");
}
double nozzle_width(double x, double width, int nozzle_shape)
/* width of bell-shaped nozzle */
{
double lam = 0.5*LAMBDA, a, b;
if (x >= 0.0) return(width);
else switch (nozzle_shape) {
case (NZ_STRAIGHT): return(width);
case (NZ_BELL): return(sqrt(width*width - 0.5*x));
case (NZ_GLAS): return(sqrt(width*width - 1.2*x) + 1.0*x);
case (NZ_CONE): return(width - (sqrt(width*width + 0.5) - width)*x);
case (NZ_TRUMPET): return(width + (sqrt(width*width + LAMBDA)-width)*x*x);
case (NZ_BROAD):
{
if (-x < 0.1) return(width - (0.5 - width)*x/0.1);
else return(0.5);
}
case (NZ_DELAVAL):
{
a = 1.5;
b = 0.05;
return(sqrt(width*width - 0.5*x) + a*b*x*(1.0 + x)/(b + x*x));
// a = (sqrt(width*width+0.5) - width)/sqrt(0.5);
// c = (a*sqrt(0.5*h) - width)/(h*h);
// if (-x < h) return(width + c*x*x);
// else return(width + a * sqrt(-0.5*x));
}
default: return(0.0);
}
}
void add_rocket_to_segments(t_segment segment[NMAXSEGMENTS], double x0, double y0, int rocket_shape, int nozzle_shape, int nsides, int group)
/* add one or several rocket_shaped set of segments */
{
int i, j, cycle = 0, nsegments0;
double angle, dx, x1, y1, x2, y2, nozx, nozy, a, b, c, w;
nsegments0 = nsegments;
/* compute intersection point of nozzle and ellipse */
angle = -PID + DPI/(double)NPOLY;
nozx = 0.7*LAMBDA*cos(angle);
nozy = y0 + YMIN + LAMBDA*(1.7 + 0.7*sin(angle));
/* form of combustion chamber */
switch (rocket_shape) {
case (RCK_DISC): /* circular chamber */
{
for (i=1; i<NPOLY-1; i++)
{
angle = -PID + (double)i*DPI/(double)NPOLY;
x1 = x0 + 0.7*LAMBDA*cos(angle);
y1 = y0 + YMIN + LAMBDA*(1.7 + 0.7*sin(angle));
angle = -PID + (double)(i+1)*DPI/(double)NPOLY;
x2 = x0 + 0.7*LAMBDA*cos(angle);
y2 = y0 + YMIN + LAMBDA*(1.7 + 0.7*sin(angle));
add_rotated_angle_to_segments(x1, y1, x2, y2, 0.02, 0, segment, 0);
}
break;
}
case (RCK_RECT): /* rectangular chamber */
{
/* dimensions chosen to have same area as circular chamber */
a = 0.5*LAMBDA;
b = 0.49*PI*LAMBDA;
add_rotated_angle_to_segments(x0+nozx, nozy, x0+a, nozy, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0+a, nozy, x0+a, nozy+b, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0+a, nozy+b, x0-a, nozy+b, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0-a, nozy+b, x0-a, nozy, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0-a, nozy, x0-nozx, nozy, 0.02, 0, segment, 0);
break;
}
case (RCK_RECT_HAT): /* rectangular chamber with a hat */
{
a = 0.5*LAMBDA;
b = (0.49*PI-0.25)*LAMBDA;
add_rotated_angle_to_segments(x0+nozx, nozy, x0+a, nozy, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0+a, nozy, x0+a, nozy+b, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0+a, nozy+b, x0, nozy+b+a, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0, nozy+b+a, x0-a, nozy+b, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0-a, nozy+b, x0-a, nozy, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0-a, nozy, x0-nozx, nozy, 0.02, 0, segment, 0);
break;
}
case (RCK_RECT_BAR): /* rectangular chamber with a hat and separating bar */
{
a = 0.5*LAMBDA;
b = (0.49*PI-0.25)*LAMBDA;
c = 0.5*a;
w = 0.025;
add_rotated_angle_to_segments(x0+nozx, nozy, x0+nozx, nozy+0.5*c, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0+nozx, nozy+0.5*c, x0+nozx+0.5*c, nozy+c, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0+nozx+0.5*c, nozy+c, x0+a, nozy+c, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0+a, nozy+c, x0+a, nozy+b+c, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0+a, nozy+b+c, x0, nozy+b+a+c, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0-w, nozy+a+c, x0-w, nozy+b+a+c, 2.0*w, 0, segment, 0);
add_rotated_angle_to_segments(x0, nozy+b+a+c, x0-a, nozy+b+c, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0-a, nozy+b+c, x0-a, nozy+c, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0-a, nozy+c, x0-nozx-0.5*c, nozy+c, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0-nozx-0.5*c, nozy+c, x0-nozx+w, nozy+0.5*c, 0.02, 0, segment, 0);
add_rotated_angle_to_segments(x0-nozx+w, nozy+0.5*c, x0-nozx+w, nozy, 0.02, 0, segment, 0);
break;
}
}
dx = LAMBDA/(double)(nsides);
/* nozzle */
if (nozzle_shape != NZ_NONE)
{
for (i=0; i<nsides; i++)
{
y1 = y0 - LAMBDA + dx*(double)(i-1);
x1 = x0 + nozzle_width(y1 - y0, nozx, nozzle_shape);
y2 = y1 + dx;
x2 = x0 + nozzle_width(y2 - y0, nozx, nozzle_shape);
add_rotated_angle_to_segments(x1, y1 + YMIN + LAMBDA, x2, y2 + YMIN + LAMBDA, 0.02, 0, segment, 0);
}
add_rotated_angle_to_segments(x2, y2 + YMIN + LAMBDA, x0 + nozx, nozy, 0.02, 0, segment, 0);
for (i=0; i<nsides; i++)
{
y1 = y0 - LAMBDA + dx*(double)(i-1);
x1 = x0 - nozzle_width(y1 - y0, nozx, nozzle_shape);
y2 = y1 + dx;
x2 = x0 - nozzle_width(y2 - y0, nozx, nozzle_shape);
add_rotated_angle_to_segments(x1, y1 + YMIN + LAMBDA, x2, y2 + YMIN + LAMBDA, 0.02, 0, segment, 0);
}
add_rotated_angle_to_segments(x2, y2 + YMIN + LAMBDA, x0 - nozx, nozy, 0.02, 0, segment, 0);
}
for (i=nsegments0; i<nsegments; i++) segment[i].inactivate = 0;
/* closing segment */
segment[nsegments].x1 = x0 - nozx;
segment[nsegments].y1 = nozy;
segment[nsegments].x2 = x0 + nozx;
segment[nsegments].y2 = nozy;
segment[nsegments].inactivate = 1;
nsegments++;
/* set group of segments */
for (i=nsegments0; i<nsegments; i++) segment[i].group = group;
}
int init_maze_segments(t_segment segment[NMAXSEGMENTS], int diag)
/* init segments forming a maze */
{
t_maze* maze;
int i, j, n;
double x1, y1, x2, y2, dx, dy, padding = 0.02, width = MAZE_WIDTH;
maze = (t_maze *)malloc(NXMAZE*NYMAZE*sizeof(t_maze));
init_maze(maze);
/* build walls of maze */
dx = (YMAX - YMIN - 2.0*padding)/(double)(NXMAZE);
dy = (YMAX - YMIN - 2.0*padding)/(double)(NYMAZE);
for (i=0; i<NXMAZE; i++)
for (j=0; j<NYMAZE; j++)
{
n = nmaze(i, j);
x1 = YMIN + padding + (double)i*dx + MAZE_XSHIFT;
y1 = YMIN + padding + (double)j*dy;
if (diag)
{
if (((i>0)||(j<NYMAZE-1))&&(maze[n].west)) add_rectangle_to_segments(x1, y1, x1 - width, y1 + dy, segment, 0);
}
else if (((i>0)||(j!=NYMAZE/2))&&(maze[n].west)) add_rectangle_to_segments(x1, y1, x1 - width, y1 + dy, segment, 0);
if (maze[n].south) add_rectangle_to_segments(x1, y1, x1 + dx, y1 - width, segment, 0);
}
/* top side of maze */
add_rectangle_to_segments(YMIN + padding + MAZE_XSHIFT, YMAX - padding, YMAX - padding + MAZE_XSHIFT, YMAX - padding - width, segment, 0);
/* right side of maze */
x1 = YMAX - padding + MAZE_XSHIFT;
if (diag)
{
y1 = YMIN + padding + dy;
add_rectangle_to_segments(x1, y1, x1 - width, YMAX + 10.0, segment, 0);
}
else
{
y1 = YMIN + padding + dy*((double)NYMAZE/2);
add_rectangle_to_segments(x1, YMIN - 1.0, x1 - width, y1 - dy, segment, 0);
add_rectangle_to_segments(x1, y1, x1 - width, YMAX + 1.0, segment, 0);
}
/* left side of maze */
x1 = YMIN + padding + MAZE_XSHIFT;
add_rectangle_to_segments(x1, YMIN - 1.0, x1 - width, YMIN + padding, segment, 0);
add_rectangle_to_segments(x1, YMAX - padding, x1 - width, YMAX + 10.0, segment, 0);
if (diag)
{
add_rotated_angle_to_segments(XMIN, YMAX - 0.5*dy, x1, YMAX - dy - 2.0*width, width, 0, segment, 0);
add_rectangle_to_segments(XMIN, YMAX - 0.5*dy, XMIN - width, YMAX + 10.0, segment, 0);
}
free(maze);
}
void translate_segments(t_segment segment[NMAXSEGMENTS], double deltax[2], double deltay[2])
/* rotates the repelling segments by given angle */
{
int i, group;
for (i=0; i<nsegments; i++)
{
group = segment[i].group;
if (group == 0)
{
segment[i].x1 = segment[i].x01 + deltax[group] - SEGMENTS_X0;
segment[i].x2 = segment[i].x02 + deltax[group] - SEGMENTS_X0;
}
else
{
segment[i].x1 = segment[i].x01 + deltax[group] + SEGMENTS_X0;
segment[i].x2 = segment[i].x02 + deltax[group] + SEGMENTS_X0;
}
segment[i].y1 = segment[i].y01 + deltay[group] - SEGMENTS_Y0;
segment[i].y2 = segment[i].y02 + deltay[group] - SEGMENTS_Y0;
segment[i].c = segment[i].nx*segment[i].x1 + segment[i].ny*segment[i].y1;
}
}
void translate_one_segment(t_segment segment[NMAXSEGMENTS], int i, double deltax, double deltay)
/* translates the repelling segment by given vector */
{
segment[i].x1 += deltax;
segment[i].x2 += deltax;
segment[i].y1 += deltay;
segment[i].y2 += deltay;
segment[i].c = segment[i].nx*segment[i].x1 + segment[i].ny*segment[i].y1;
segment[i].xc += deltax;
segment[i].yc += deltay;
}
void rotate_one_segment(t_segment segment[NMAXSEGMENTS], int i, double dalpha, double xc, double yc)
/* rotates the repelling segment by given angle around (xc, yc) */
{
double ca, sa, x, y, nx, ny;
ca = cos(dalpha);
sa = sin(dalpha);
x = segment[i].x1 - xc;
y = segment[i].y1 - yc;
segment[i].x1 = xc + x*ca - y*sa;
segment[i].y1 = yc + x*sa + y*ca;
x = segment[i].x2 - xc;
y = segment[i].y2 - yc;
segment[i].x2 = xc + x*ca - y*sa;
segment[i].y2 = yc + x*sa + y*ca;
segment[i].xc = 0.5*(segment[i].x1 + segment[i].x2);
segment[i].yc = 0.5*(segment[i].y1 + segment[i].y2);
nx = segment[i].nx;
ny = segment[i].ny;
segment[i].nx = ca*nx - sa*ny;
segment[i].ny = sa*nx + ca*ny;
segment[i].c = segment[i].nx*segment[i].x1 + segment[i].ny*segment[i].y1;
if (segment[i].concave)
{
segment[i].angle1 += dalpha;
segment[i].angle2 += dalpha;
while (segment[i].angle1 > DPI)
{
segment[i].angle1 -= DPI;
segment[i].angle2 -= DPI;
}
while (segment[i].angle2 < 0.0)
{
segment[i].angle1 += DPI;
segment[i].angle2 += DPI;
}
}
}
int add_shovel_to_belt(double x, double y, double angle, double size, double width, t_segment segment[NMAXSEGMENTS], t_belt belt)
/* add showver to conveyor belt */
{
int i, n, iminus, iplus;
double sq2, angle1, angle2, cg, sg, t;
if (nsegments + 6 > NMAXSEGMENTS)
{
printf("NMAXSEGMENTS too small");
return(0);
}
n = nsegments;
// sq2 = sqrt(2.0)/2.0;
cg = cos(PI/6.0);
sg = sin(PI/6.0);
t = size + width*(cg - 1.0)/sg;
segment[n].x1 = 0.0;
segment[n].y1 = 0.0;
segment[n+1].x1 = 0.0;
segment[n+1].y1 = size;
segment[n+2].x1 = size*sg;
segment[n+2].y1 = size*(1.0+cg);
segment[n+3].x1 = size*sg + width*cg;
segment[n+3].y1 = size*(1.0+cg) - width*sg;
segment[n+4].x1 = width;
segment[n+4].y1 = size*(1.0 + cg) - width*sg - t*cg;
// segment[n+2].x1 = size*sq2;
// segment[n+2].y1 = size*(1.0+sq2);
//
// segment[n+3].x1 = size*sq2 + width*sq2;
// segment[n+3].y1 = size*(1.0+sq2) - width*sq2;
//
// segment[n+4].x1 = width;
// segment[n+4].y1 = size + width*(1.0 - sqrt(2.0));
segment[n+5].x1 = width;
segment[n+5].y1 = 0.0;
for (i=0; i<6; i++)
{
segment[n+i].x2 = segment[n+i+1].x1;
segment[n+i].y2 = segment[n+i+1].y1;
}
segment[n+6].x2 = segment[n].x1;
segment[n+6].y2 = segment[n].y1;
for (i=n; i<n+6; i++)
{
segment[i].inactivate = 0;
segment[i].conveyor = 0;
segment[i].concave = 1;
}
/* deal with concave corners */
for (i=n; i<n+6; i++)
{
iminus = i-1;
iplus = i+1;
if (iminus < n) iminus = n + 5;
if (iplus > n + 5) iplus = n;
angle1 = argument(segment[iplus].x1 - segment[i].x1, segment[iplus].y1 - segment[i].y1) + PID;
angle2 = argument(segment[i].x1 - segment[iminus].x1, segment[i].y1 - segment[iminus].y1) + PID;
if (angle2 < angle1) angle2 += DPI;
segment[i].angle1 = angle1;
segment[i].angle2 = angle2;
}
for (i=n; i<n+6; i++)
{
translate_one_segment(segment, i, x, y);
rotate_one_segment(segment, i, angle, x, y);
}
nsegments += 6;
return(1);
}
int add_conveyor_belt(double x1, double y1, double x2, double y2, double width, double speed, int nshovels, t_segment segment[NMAXSEGMENTS], t_belt conveyor_belt[NMAXBELTS])
/* add segments forming a conveyor belt */
{
double length, tx, ty, angle, angle1, angle2, beltlength, shovel_dist, shovel_pos, x, y, beta;
int i, n, iplus, iminus, shovel;
length = module2(x2 - x1, y2 - y1);
angle = argument(x2 - x1, y2 - y1);
if (angle < 0.0) angle += DPI;
tx = (x2 - x1)/length;
ty = (y2 - y1)/length;
n = nsegments;
if (nsegments + 14 > NMAXSEGMENTS)
{
printf("NMAXSEGMENTS too small");
return(0);
}
if (nbelts + 1 > NMAXBELTS)
{
printf("NMAXBELTS too small");
return(0);
}
segment[n].x1 = x1 - ty*width;
segment[n].y1 = y1 + tx*width;
for (i=0; i<7; i++)
{
segment[n+1+i].x1 = x2 + width*sin(-angle + (double)i*PI/6.0);
segment[n+1+i].y1 = y2 + width*cos(-angle + (double)i*PI/6.0);
}
for (i=7; i<14; i++)
{
segment[n+1+i].x1 = x1 + width*sin(-angle + (double)(i-1)*PI/6.0);
segment[n+1+i].y1 = y1 + width*cos(-angle + (double)(i-1)*PI/6.0);
}
for (i=0; i<13; i++)
{
segment[n+i].x2 = segment[n+i+1].x1;
segment[n+i].y2 = segment[n+i+1].y1;
}
segment[n+13].x2 = segment[n].x1;
segment[n+13].y2 = segment[n].y1;
for (i=n; i<n+14; i++)
{
segment[i].concave = 1;
segment[i].inactivate = 0;
segment[i].conveyor = 1;
segment[i].conveyor_speed = speed;
segment[i].align_torque = 1;
}
/* deal with concave corners */
for (i=n; i<n+14; i++)
{
iminus = i-1;
iplus = i+1;
if (iminus < n) iminus = n + 13;
if (iplus > n + 13) iplus = n;
angle1 = argument(segment[iplus].x1 - segment[i].x1, segment[iplus].y1 - segment[i].y1) + PID;
angle2 = argument(segment[i].x1 - segment[iminus].x1, segment[i].y1 - segment[iminus].y1) + PID;
if (angle2 < angle1) angle2 += DPI;
segment[i].angle1 = angle1;
segment[i].angle2 = angle2;
}
nsegments += 14;
conveyor_belt[nbelts].x1 = x1;
conveyor_belt[nbelts].x2 = x2;
conveyor_belt[nbelts].y1 = y1;
conveyor_belt[nbelts].y2 = y2;
conveyor_belt[nbelts].speed = speed;
conveyor_belt[nbelts].width = width;
conveyor_belt[nbelts].position = 0.0;
conveyor_belt[nbelts].length = length;
conveyor_belt[nbelts].angle = angle;
conveyor_belt[nbelts].tx = tx;
conveyor_belt[nbelts].ty = ty;
conveyor_belt[nbelts].nshovels = nshovels;
nbelts++;
if (nshovels > NMAXSHOVELS)
{
printf("NMAXSHOVELS too small");
conveyor_belt[nbelts].nshovels = 0;
return(0);
}
if (nshovels > 0)
{
beltlength = 2.0*length + DPI*width;
shovel_dist = beltlength/(double)nshovels;
shovel_pos = 0.0;
shovel = 0;
while (shovel_pos < length)
{
x = x1 - width*ty + shovel_pos*tx;
y = y1 + width*tx + shovel_pos*ty;
conveyor_belt[nbelts-1].shovel_segment[shovel] = nsegments;
add_shovel_to_belt(x, y, angle, width, 0.3*width, segment, conveyor_belt[nbelts-1]);
conveyor_belt[nbelts-1].shovel_pos[shovel] = shovel_pos;
shovel_pos += shovel_dist;
shovel++;
}
while (shovel_pos < length + width*PI)
{
beta = (shovel_pos - length)/width;
x = x2 + width*cos(angle + PID - beta);
y = y2 + width*sin(angle + PID - beta);
conveyor_belt[nbelts-1].shovel_segment[shovel] = nsegments;
add_shovel_to_belt(x, y, angle - beta, width, 0.3*width, segment, conveyor_belt[nbelts-1]);
conveyor_belt[nbelts-1].shovel_pos[shovel] = shovel_pos;
shovel_pos += shovel_dist;
shovel++;
}
while (shovel_pos < 2.0*length + width*PI)
{
x = x2 + width*ty - (shovel_pos - length - width*PI)*tx;
y = y2 - width*tx - (shovel_pos - length - width*PI)*ty;
conveyor_belt[nbelts-1].shovel_segment[shovel] = nsegments;
add_shovel_to_belt(x, y, angle - PI, width, 0.3*width, segment, conveyor_belt[nbelts-1]);
conveyor_belt[nbelts-1].shovel_pos[shovel] = shovel_pos;
shovel_pos += shovel_dist;
shovel++;
}
while (shovel_pos < beltlength)
{
beta = (shovel_pos - 2.0*length - width*PI)/width;
x = x1 + width*cos(angle - PID - beta);
y = y1 + width*sin(angle - PID - beta);
conveyor_belt[nbelts-1].shovel_segment[shovel] = nsegments;
add_shovel_to_belt(x, y, angle - PI - beta, width, 0.3*width, segment, conveyor_belt[nbelts-1]);
conveyor_belt[nbelts-1].shovel_pos[shovel] = shovel_pos;
shovel_pos += shovel_dist;
shovel++;
}
}
return(1);
}
void init_segment_config(t_segment segment[NMAXSEGMENTS], t_belt conveyor_belt[NMAXBELTS])
/* initialise linear obstacle configuration */
{
int i, j, cycle = 0, iminus, iplus, nsides, n, concave = 1;
double angle, angle2, dangle, dx, width, height, a, b, length, xmid = 0.5*(BCXMIN + BCXMAX), lpocket, r, x, x1, y1, x2, y2, nozx, nozy, y, yy, dy, ca, sa, padding;
double lfoot[NTREES][2], rfoot[NTREES][2];
/* set default to no conveyor, no torque */
for (i=0; i<NMAXSEGMENTS; i++)
{
segment[i].conveyor = 0;
segment[i].align_torque = 0;
}
switch (SEGMENT_PATTERN) {
case (S_RECTANGLE):
{
segment[0].x1 = BCXMIN;
segment[0].y1 = BCYMAX;
segment[1].x1 = BCXMIN;
segment[1].y1 = BCYMIN;
segment[2].x1 = BCXMAX;
segment[2].y1 = BCYMIN;
segment[3].x1 = BCXMAX;
segment[3].y1 = BCYMAX;
cycle = 1;
nsegments = 4;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 0;
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_CUP):
{
angle = APOLY*PID;
dx = (BCYMAX - BCYMIN)/tan(angle);
segment[0].x1 = BCXMIN;
segment[0].y1 = BCYMAX;
segment[1].x1 = BCXMIN + dx;
segment[1].y1 = BCYMIN;
segment[2].x1 = BCXMAX - dx;
segment[2].y1 = BCYMIN;
segment[3].x1 = BCXMAX;
segment[3].y1 = BCYMAX;
cycle = 1;
nsegments = 4;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 0;
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_HOURGLASS):
{
angle = APOLY*PID;
width = 2.5*MU;
height = 2.5*MU;
segment[0].x1 = BCXMIN;
segment[0].y1 = BCYMAX;
segment[0].concave = 0;
segment[1].x1 = -width;
segment[1].y1 = height;
segment[1].concave = 1;
segment[2].x1 = -width;
segment[2].y1 = -height;
segment[2].concave = 1;
segment[3].x1 = BCXMIN;
segment[3].y1 = BCYMIN;
segment[3].concave = 0;
segment[4].x1 = BCXMAX;
segment[4].y1 = BCYMIN;
segment[4].concave = 0;
segment[5].x1 = width;
segment[5].y1 = -height;
segment[5].concave = 1;
segment[6].x1 = width;
segment[6].y1 = height;
segment[6].concave = 1;
segment[7].x1 = BCXMAX;
segment[7].y1 = BCYMAX;
segment[7].concave = 0;
cycle = 1;
nsegments = 8;
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_PENTA):
{
height = 0.5*(BCYMAX - BCYMIN);
width = height/sqrt(3.0);
segment[0].x1 = BCXMIN;
segment[0].y1 = 0.5*(BCYMIN + BCYMAX);
segment[1].x1 = BCXMIN + width;
segment[1].y1 = BCYMIN;
segment[2].x1 = BCXMAX;
segment[2].y1 = BCYMIN;
segment[3].x1 = BCXMAX;
segment[3].y1 = BCYMAX;
segment[4].x1 = BCXMIN + width;
segment[4].y1 = BCYMAX;
cycle = 1;
nsegments = 5;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 0;
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_CENTRIFUGE):
{
angle = DPI/(double)NPOLY;
for (i=0; i<NPOLY; i++)
{
segment[i*4].x1 = LAMBDA*cos(((double)i + 0.02)*angle);
segment[i*4].y1 = LAMBDA*sin(((double)i + 0.02)*angle);
segment[i*4].concave = 1;
segment[i*4 + 1].x1 = cos(((double)i + 0.05)*angle);
segment[i*4 + 1].y1 = sin(((double)i + 0.05)*angle);
segment[i*4 + 1].concave = 0;
segment[i*4 + 2].x1 = cos(((double)i + 0.95)*angle);
segment[i*4 + 2].y1 = sin(((double)i + 0.95)*angle);
segment[i*4 + 2].concave = 0;
segment[i*4 + 3].x1 = LAMBDA*cos(((double)i + 0.98)*angle);
segment[i*4 + 3].y1 = LAMBDA*sin(((double)i + 0.98)*angle);
segment[i*4 + 3].concave = 1;
}
cycle = 1;
nsegments = 4*NPOLY;
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_POLY_ELLIPSE):
{
angle = DPI/(double)NPOLY;
for (i=0; i<NPOLY; i++)
{
segment[i].x1 = -cos(((double)i + 0.5)*angle);
segment[i].y1 = -LAMBDA*sin(((double)i + 0.5)*angle);
segment[i].concave = 0;
}
segment[0].concave = 1;
segment[NPOLY-1].concave = 1;
for (i=0; i<NPOLY; i++)
{
segment[NPOLY+i].x1 = 1.05*segment[NPOLY-1-i].x1;
segment[NPOLY+i].y1 = 1.05*segment[NPOLY-1-i].y1;
segment[NPOLY+i].concave = 1;
}
cycle = 1;
nsegments = 2*NPOLY;
for (i=0; i<nsegments; i++) segment[i].inactivate = 0;
break;
}
case (S_POOL_TABLE):
{
width = MU;
lpocket = 0.1;
add_rectangle_to_segments(BCXMIN + lpocket, BCYMIN, xmid - lpocket, BCYMIN - width, segment, 0);
add_rectangle_to_segments(xmid + lpocket, BCYMIN, BCXMAX - lpocket, BCYMIN - width, segment, 0);
add_rectangle_to_segments(BCXMAX + width, BCYMIN + lpocket, BCXMAX, BCYMAX - lpocket, segment, 0);
add_rectangle_to_segments(BCXMAX - lpocket, BCYMAX, xmid + lpocket, BCYMAX + width, segment, 0);
add_rectangle_to_segments(xmid - lpocket, BCYMAX, BCXMIN + lpocket, BCYMAX + width, segment, 0);
add_rectangle_to_segments(BCXMIN - width, BCYMAX - lpocket, BCXMIN, BCYMIN + lpocket, segment, 0);
cycle = 0;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 0;
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_CENTRIFUGE_RND):
{
angle = DPI/(double)NPOLY;
nsides = 24;
if ((nsides+2)*NPOLY > NMAXSEGMENTS)
{
printf("Error: NMAXSEGMENTS is too small\n");
exit(1);
}
for (i=0; i<NPOLY; i++)
{
segment[i*(nsides+2)].x1 = LAMBDA*cos(((double)i + 0.02)*angle);
segment[i*(nsides+2)].y1 = LAMBDA*sin(((double)i + 0.02)*angle);
segment[i*(nsides+2)].concave = 1;
for (j=1; j<=nsides; j++)
{
x = (double)j/(double)(nsides+1);
r = 0.5 + sqrt(x*(1.0-x));
angle2 = (double)i*angle + angle*(double)j/(double)(nsides+1);
segment[i*(nsides+2) + j].x1 = r*cos(angle2);
segment[i*(nsides+2) + j].y1 = r*sin(angle2);
segment[i*(nsides+2) + j].concave = 0;
}
segment[i*(nsides+2) + nsides + 1].x1 = LAMBDA*cos(((double)i + 0.98)*angle);
segment[i*(nsides+2) + nsides + 1].y1 = LAMBDA*sin(((double)i + 0.98)*angle);
segment[i*(nsides+2) + nsides + 1].concave = 1;
}
cycle = 1;
nsegments = (nsides+2)*NPOLY;
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_CENTRIFUGE_LEAKY):
{
angle = DPI/(double)NPOLY;
nsides = 20;
if (2*(nsides+2)*NPOLY > NMAXSEGMENTS)
{
printf("Error: NMAXSEGMENTS is too small\n");
exit(1);
}
for (i=0; i<NPOLY; i++)
{
angle2 = (double)i*angle;
x1 = LAMBDA*cos(angle2);
y1 = LAMBDA*sin(angle2);
x2 = 0.7*cos(angle2);
y2 = 0.7*sin(angle2);
add_rotated_angle_to_segments(x1, y1, x2, y2, MU, 0, segment, 0);
for (j=0; j<nsides; j++) if (j!=nsides/2)
{
x = (double)j/(double)(nsides);
r = 0.5 + sqrt(x*(1.0-x) + 0.04);
if (j < nsides/2) angle2 = (double)i*angle + angle*(double)j/((double)(nsides) - 0.15);
else angle2 = (double)i*angle + angle*(double)j/((double)(nsides) + 0.15);
x1 = r*cos(angle2);
y1 = r*sin(angle2);
x = (double)(j+1)/(double)(nsides);
r = 0.5 + sqrt(x*(1.0-x) + 0.04);
if (j < nsides/2) angle2 = (double)i*angle + angle*(double)(j+1)/((double)(nsides) - 0.15);
else angle2 = (double)i*angle + angle*(double)(j+1)/((double)(nsides) + 0.15);
x2 = r*cos(angle2);
y2 = r*sin(angle2);
add_rotated_angle_to_segments(x1, y1, x2, y2, 0.5*MU, 0, segment, 0);
}
}
cycle = 0;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 0;
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_CIRCLE_EXT):
{
angle = DPI/(double)NPOLY;
for (i=0; i<NPOLY; i++)
{
segment[i].x1 = SEGMENTS_X0 + LAMBDA*cos(((double)i)*angle);
segment[i].y1 = SEGMENTS_Y0 - LAMBDA*sin(((double)i)*angle);
segment[i].concave = 1;
}
cycle = 1;
nsegments = NPOLY;
ngroups = 2;
for (i=0; i<nsegments; i++)
{
segment[i].group = 1;
segment[i].inactivate = 0;
}
break;
}
case (S_ROCKET_NOZZLE):
{
/* ellipse */
for (i=1; i<NPOLY-1; i++)
{
angle = -PI + (double)i*DPI/(double)NPOLY;
x1 = 0.7*LAMBDA*(1.0 + cos(angle));
y1 = 0.5*LAMBDA*sin(angle);
angle = -PI + (double)(i+1)*DPI/(double)NPOLY;
x2 = 0.7*LAMBDA*(1.0 + cos(angle));
y2 = 0.5*LAMBDA*sin(angle);
add_rotated_angle_to_segments(x1, y1, x2, y2, 0.02, 0, segment, 0);
}
/* compute intersection point of nozzle and ellipse */
angle = PI - DPI/(double)NPOLY;
nozx = 0.7*LAMBDA*(1.0 + cos(angle));
nozy = 0.5*LAMBDA*sin(angle);
nsides = 10;
dx = LAMBDA/(double)(nsides);
/* nozzle */
for (i=0; i<nsides; i++)
{
x1 = -LAMBDA + dx*(double)(i-1);
y1 = nozzle_width(x1, nozy, NOZZLE_SHAPE);
x2 = x1 + dx;
y2 = nozzle_width(x2, nozy, NOZZLE_SHAPE);
add_rotated_angle_to_segments(x1, y1, x2, y2, 0.02, 0, segment, 0);
}
add_rotated_angle_to_segments(x2, y2, nozx, nozy, 0.02, 0, segment, 0);
for (i=0; i<nsides; i++)
{
x1 = -LAMBDA + dx*(double)(i-1);
y1 = -nozzle_width(x1, nozy, NOZZLE_SHAPE);
x2 = x1 + dx;
y2 = -nozzle_width(x2, nozy, NOZZLE_SHAPE);
add_rotated_angle_to_segments(x1, y1, x2, y2, 0.02, 0, segment, 0);
}
add_rotated_angle_to_segments(x2, y2, nozx, -nozy, 0.02, 0, segment, 0);
/* closing segment */
segment[nsegments].x1 = nozx;
segment[nsegments].y1 = nozy;
segment[nsegments].x2 = nozx;
segment[nsegments].y2 = -nozy;
nsegments++;
cycle = 0;
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 0;
}
segment[nsegments-1].inactivate = 1;
break;
}
case (S_ROCKET_NOZZLE_ROTATED):
{
add_rocket_to_segments(segment, 0.0, SEGMENTS_Y0, ROCKET_SHAPE, NOZZLE_SHAPE, 10, 1);
/* segments from group 0 are immobile by convention */
ngroups = 2;
cycle = 0;
// for (i=0; i<nsegments; i++) segment[i].group = 1;
break;
}
case (S_TWO_ROCKETS):
{
add_rocket_to_segments(segment, -SEGMENTS_X0, SEGMENTS_Y0, ROCKET_SHAPE, NOZZLE_SHAPE, 10, 1);
add_rocket_to_segments(segment, SEGMENTS_X0, SEGMENTS_Y0, ROCKET_SHAPE_B, NOZZLE_SHAPE_B, 10, 2);
ngroups = 3;
cycle = 0;
break;
}
case (S_TWO_CIRCLES_EXT):
{
angle = DPI/(double)NPOLY;
for (i=0; i<NPOLY; i++)
{
segment[i].x1 = SEGMENTS_X0 + LAMBDA*cos(((double)i)*angle);
segment[i].y1 = SEGMENTS_Y0 - LAMBDA*sin(((double)i)*angle);
segment[i].x2 = SEGMENTS_X0 + LAMBDA*cos(((double)(i+1))*angle);
segment[i].y2 = SEGMENTS_Y0 - LAMBDA*sin(((double)(i+1))*angle);
segment[i].concave = 1;
segment[i].group = 0;
segment[i].inactivate = 0;
}
for (i=NPOLY; i<2*NPOLY; i++)
{
segment[i].x1 = -SEGMENTS_X0 + TWO_CIRCLES_RADIUS_RATIO*LAMBDA*cos(((double)i)*angle);
segment[i].y1 = SEGMENTS_Y0 - TWO_CIRCLES_RADIUS_RATIO*LAMBDA*sin(((double)i)*angle);
segment[i].x2 = -SEGMENTS_X0 + TWO_CIRCLES_RADIUS_RATIO*LAMBDA*cos(((double)(i+1))*angle);
segment[i].y2 = SEGMENTS_Y0 - TWO_CIRCLES_RADIUS_RATIO*LAMBDA*sin(((double)(i+1))*angle);
segment[i].concave = 1;
segment[i].group = 1;
segment[i].inactivate = 0;
}
cycle = 0;
nsegments = 2*NPOLY;
break;
}
case (S_DAM):
{
add_rectangle_to_segments(DAM_WIDTH, BCYMIN - 0.5, -DAM_WIDTH, LAMBDA, segment, 0);
cycle = 0;
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 1;
}
break;
}
case (S_DAM_WITH_HOLE):
{
add_rectangle_to_segments(DAM_WIDTH, BCYMIN - 0.5, -DAM_WIDTH, BCYMIN + 0.1, segment, 0);
add_rectangle_to_segments(DAM_WIDTH, BCYMIN + 0.3, -DAM_WIDTH, LAMBDA, segment, 0);
add_rectangle_to_segments(DAM_WIDTH, BCYMIN + 0.1, -DAM_WIDTH, BCYMIN + 0.3, segment, 0);
cycle = 0;
concave = 0; /* add_rectangle_to_segments already deals with concave corners */
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
if (i > 7) segment[i].inactivate = 1;
else segment[i].inactivate = 0;
}
break;
}
case (S_DAM_WITH_HOLE_AND_RAMP):
{
add_rectangle_to_segments(DAM_WIDTH, BCYMIN - 0.5, -DAM_WIDTH, BCYMIN + 0.2, segment, 0);
add_rectangle_to_segments(DAM_WIDTH, BCYMIN + 0.3, -DAM_WIDTH, LAMBDA, segment, 0);
add_rectangle_to_segments(DAM_WIDTH, BCYMIN + 0.2, -DAM_WIDTH, BCYMIN + 0.3, segment, 0);
r = 1.0;
for (i=0; i<10; i++)
{
angle = 0.1*PID*(double)i;
dangle = 0.1*PID;
x1 = XMAX - r + (r + MU)*cos(angle);
y1 = YMIN + r - (r + MU)*sin(angle);
x2 = XMAX - r + (r + MU)*cos(angle + dangle);
y2 = YMIN + r - (r + MU)*sin(angle + dangle);
add_rotated_angle_to_segments(x1, y1, x2, y2, MU, 0, segment, 0);
}
cycle = 0;
concave = 0; /* add_rectangle_to_segments already deals with concave corners */
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
if ((i > 7)&&(i < 12)) segment[i].inactivate = 1;
else segment[i].inactivate = 0;
}
break;
}
case (S_MAZE):
{
init_maze_segments(segment, 0);
cycle = 0;
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_MAZE_DIAG):
{
init_maze_segments(segment, 1);
cycle = 0;
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_EXT_RECTANGLE):
{
width = 0.1*LAMBDA;
segment[0].x1 = SEGMENTS_X0 - LAMBDA;
segment[0].y1 = SEGMENTS_Y0 - width;
segment[1].x1 = SEGMENTS_X0 - LAMBDA;
segment[1].y1 = SEGMENTS_Y0 + width;
segment[2].x1 = SEGMENTS_X0 + LAMBDA;
segment[2].y1 = SEGMENTS_Y0 + width;
segment[3].x1 = SEGMENTS_X0 + LAMBDA;
segment[3].y1 = SEGMENTS_Y0 - width;
cycle = 1;
nsegments = 4;
ngroups = 2;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 1;
segment[i].group = 1;
segment[i].inactivate = 0;
}
break;
}
case (S_DAM_BRICKS):
{
add_rectangle_to_segments(DAM_WIDTH, BCYMIN - 0.5, -DAM_WIDTH, BCYMIN, segment, 0);
dy = 0.1*(LAMBDA - BCYMIN);
for (i=1; i<11; i++)
{
y = BCYMIN + (double)i*dy;
add_rectangle_to_segments(DAM_WIDTH, y-dy+MU, -DAM_WIDTH, y, segment, i);
}
ngroups = 11;
cycle = 0;
concave = 0; /* add_rectangle_to_segments already deals with concave corners */
for (i=0; i<nsegments; i++)
{
segment[i].inactivate = 0;
}
break;
}
case (S_HLINE_HOLE):
{
x = 0.15;
x1 = XMAX + 1.0;
y1 = 0.0;
width = 0.05;
add_rectangle_to_segments(x1, y1 - width, x, y1, segment, 0);
add_rectangle_to_segments(-x, y1 - width, -x1, y1, segment, 0);
/* closing segment */
segment[nsegments].x1 = -x;
segment[nsegments].y1 = y1;
segment[nsegments].x2 = x;
segment[nsegments].y2 = y1;
nsegments++;
cycle = 0;
concave = 0; /* add_rectangle_to_segments already deals with concave corners */
for (i=0; i<nsegments; i++)
{
segment[i].inactivate = 0;
}
segment[nsegments-1].inactivate = 1;
break;
}
case (S_HLINE_HOLE_SPOKES):
{
x = 0.15;
x1 = XMAX + 1.0;
y1 = 0.0;
width = 0.05;
add_rectangle_to_segments(x1, y1 - width, x, y1, segment, 0);
add_rectangle_to_segments(-x, y1 - width, -x1, y1, segment, 0);
/* closing segment */
segment[nsegments].x1 = -x;
segment[nsegments].y1 = y1 - 0.5*width;
segment[nsegments].x2 = x;
segment[nsegments].y2 = y1 - 0.5*width;
nsegments++;
/* spokes */
for (i=-3; i<4; i+=2)
{
x = 0.5*(double)i;
segment[nsegments].x1 = x - 0.1;
segment[nsegments].y1 = BCYMIN - 0.1;
segment[nsegments].x2 = x;
segment[nsegments].y2 = YMIN + 0.3;
nsegments++;
segment[nsegments].x1 = x;
segment[nsegments].y1 = YMIN + 0.3;
segment[nsegments].x2 = x + 0.1;
segment[nsegments].y2 = BCYMIN - 0.1;
nsegments++;
}
cycle = 0;
concave = 0; /* add_rectangle_to_segments already deals with concave corners */
for (i=0; i<nsegments; i++)
{
segment[i].inactivate = 0;
}
segment[8].inactivate = 1;
break;
}
case (S_HLINE_HOLE_SLOPED):
{
x = 0.15;
x1 = XMAX + 1.0;
width = 0.05;
angle = APOLY*DPI;
y1 = (x1 - x)*tan(angle);
segment[0].x1 = x1;
segment[0].y1 = y1;
segment[1].x1 = x1 + width*sin(angle);
segment[1].y1 = y1 - width*cos(angle);
segment[2].x1 = x + width*sin(angle);
segment[2].y1 = -width*cos(angle);
segment[3].x1 = x;
segment[3].y1 = 0.0;
for (i=0; i<3; i++)
{
segment[i].x2 = segment[i+1].x1;
segment[i].y2 = segment[i+1].y1;
}
segment[3].x2 = segment[0].x1;
segment[3].y2 = segment[0].y1;
segment[4].x1 = -x1;
segment[4].y1 = y1;
segment[5].x1 = -x;
segment[5].y1 = 0.0;
segment[6].x1 = -x - width*sin(angle);
segment[6].y1 = -width*cos(angle);
segment[7].x1 = -x1 - width*sin(angle);
segment[7].y1 = y1 - width*cos(angle);
for (i=4; i<7; i++)
{
segment[i].x2 = segment[i+1].x1;
segment[i].y2 = segment[i+1].y1;
}
segment[7].x2 = segment[4].x1;
segment[7].y2 = segment[4].y1;
nsegments = 8;
for (i=0; i<nsegments; i++) segment[i].concave = 1;
/* closing segment */
segment[nsegments].x1 = -x;
segment[nsegments].y1 = 0.0;
segment[nsegments].x2 = x;
segment[nsegments].y2 = 0.0;
nsegments++;
cycle = 0;
concave = 1;
for (i=0; i<nsegments; i++)
{
segment[i].inactivate = 0;
}
segment[nsegments-1].inactivate = 1;
break;
}
case (S_EXT_CIRCLE_RECT):
{
width = 0.1*LAMBDA;
add_rectangle_to_segments(SEGMENTS_X0 + LAMBDA, SEGMENTS_Y0 - width, SEGMENTS_X0 - LAMBDA, SEGMENTS_Y0 + width, segment, 1);
add_circle_to_segments(-SEGMENTS_X0, SEGMENTS_Y0, 0.5*LAMBDA, NPOLY, APOLY, segment, 2);
cycle = 0;
concave = 0;
nsegments = NPOLY + 4;
ngroups = 3;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 1;
segment[i].inactivate = 0;
}
break;
}
case (S_BIN_OPENING):
{
add_rectangle_to_segments(LAMBDA, 1.0 - LAMBDA, LAMBDA - MU, YMAX + 1.0, segment, 0);
add_rectangle_to_segments(-LAMBDA + MU, 1.0 - LAMBDA, -LAMBDA, YMAX + 1.0, segment, 0);
add_rectangle_to_segments(LAMBDA, 1.0 - LAMBDA, -LAMBDA, 1.0 - LAMBDA + MU, segment, 0);
cycle = 0;
concave = 0; /* add_rectangle_to_segments already deals with concave corners */
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 1;
}
break;
}
case (S_BIN_LARGE):
{
add_rectangle_to_segments(LAMBDA, -MU, -LAMBDA, 0.0, segment, 0);
add_rectangle_to_segments(LAMBDA, -MU, LAMBDA - MU, 0.25, segment, 0);
add_rectangle_to_segments(-LAMBDA + MU, -MU, -LAMBDA, 0.25, segment, 0);
cycle = 0;
concave = 0; /* add_rectangle_to_segments already deals with concave corners */
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_POLYGON_EXT):
{
add_circle_to_segments(0.0, 0.0, LAMBDA, NPOLY, APOLY, segment, 0);
cycle = 0;
concave = 0;
nsegments = NPOLY;
ngroups = 1;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 1;
segment[i].inactivate = 0;
}
break;
}
case (S_WEDGE_EXT):
{
angle = AWEDGE*PID;
segment[0].x1 = LAMBDA;
segment[0].y1 = 0.0;
segment[1].x1 = -LAMBDA*cos(angle);
segment[1].y1 = -LAMBDA*sin(angle);
segment[2].x1 = 0.0;
segment[2].y1 = 0.0;
segment[3].x1 = -LAMBDA*cos(angle);
segment[3].y1 = LAMBDA*sin(angle);
cycle = 1;
nsegments = 4;
ngroups = 2;
ca = cos(APOLY*PID);
sa = sin(APOLY*PID);
for (i=0; i<nsegments; i++)
{
x = segment[i].x1;
y = segment[i].y1;
segment[i].x1 = x*ca + y*sa;
segment[i].y1 = -x*sa + y*ca;
segment[i].concave = 1;
segment[i].group = 1;
segment[i].inactivate = 0;
}
break;
}
case (S_MIXER):
{
for (i=0; i<NPOLY; i++)
{
angle = (double)i*DPI/(double)NPOLY;
add_rotated_angle_to_segments(0.0, 0.0, LAMBDA*cos(angle), LAMBDA*sin(angle), 0.05, 1, segment, 0);
}
cycle = 0;
concave = 1; /* add_rectangle_to_segments already deals with concave corners */
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_AIRFOIL):
{
dangle = DPI/(double)NPOLY;
angle = APOLY*PID;
ca = cos(angle);
sa = sin(angle);
for (i=0; i<NPOLY; i++)
{
angle = (double)i*dangle;
x = LAMBDA*cos(angle);
y1 = -0.2*LAMBDA*sin(angle);
y1 -= 0.5*x*x;
segment[i].x1 = x*ca + y1*sa;
segment[i].y1 = -x*sa + y1*ca;
}
cycle = 1;
concave = 1;
nsegments = NPOLY;
ngroups = 1;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 1;
segment[i].inactivate = 0;
}
break;
}
case (S_COANDA):
{
y1 = SEGMENTS_Y0;
width = 0.05;
padding = 0.01;
height = 0.25;
dx = (XMAX - XMIN + 2.0*padding)/(double)(NPOLY-1);
for (i=0; i<NPOLY; i++)
{
x = XMIN - padding + (double)i*dx;
y = y1 + height*cos(PI*x/XMAX);
segment[i].x1 = x;
segment[i].y1 = y + width;
segment[i].x2 = x + dx;
segment[i].x2 = y1 + height*cos(PI*(x+dx)/XMAX) + width;
segment[i].concave = 1;
}
for (i=0; i<NPOLY; i++)
{
x = XMAX + padding - (double)i*dx;
y = y1 + height*cos(PI*x/XMAX);
segment[NPOLY+i].x1 = x;
segment[NPOLY+i].y1 = y - width;
segment[NPOLY+i].x2 = x - dx;
segment[NPOLY+i].x2 = y1 + height*cos(PI*(x-dx)/XMAX) - width;
segment[NPOLY+i].concave = 1;
}
nsegments = 2*NPOLY;
cycle = 1;
concave = 1;
for (i=0; i<nsegments; i++)
{
segment[i].inactivate = 0;
}
break;
}
case (S_COANDA_SHORT):
{
y1 = SEGMENTS_Y0;
width = 0.05;
padding = 0.1;
x1 = XMIN + padding;
height = 0.2;
length = 0.85*(XMAX - XMIN - 2.0*padding);
dx = length/(double)(NPOLY-1);
for (i=0; i<NPOLY; i++)
{
x = x1 + (double)i*dx;
y = y1 - height*cos(DPI*(x-x1)/length);
yy = y1 - height*cos(DPI*(x+dx-x1)/length);
add_rotated_angle_to_segments(x, y, x+dx, yy, width, 1, segment, 0);
}
cycle = 0;
concave = 1;
for (i=0; i<nsegments; i++)
{
segment[i].inactivate = 0;
}
break;
}
case (S_CYLINDER):
{
add_rectangle_to_segments(XMAX + 0.1, YMAX - 0.05, XMIN - 0.1, YMAX + 1.0, segment, 0);
add_rectangle_to_segments(XMAX + 0.1, YMIN - 1.0, XMIN - 0.1, YMIN + 0.05, segment, 0);
cycle = 0;
concave = 1;
for (i=0; i<nsegments; i++)
{
segment[i].inactivate = 0;
}
break;
}
case (S_TREE):
{
for (i=0; i<NTREES; i++)
{
x = XMIN + ((double)i - 0.5 + 0.1*(double)rand()/(double)RAND_MAX)*(XMAX-XMIN)*1.1/(double)NTREES;
y = YMIN + 0.1 + 0.014*(double)i*(YMAX - YMIN);
add_tree_to_segments(x, y, LAMBDA*(1.0 + 0.4*(double)rand()/(double)RAND_MAX), lfoot[i], rfoot[i], segment, 0);
}
/* add ground */
for (i=0; i<NTREES-1; i++)
{
segment[nsegments].x1 = rfoot[i][0];
segment[nsegments].y1 = rfoot[i][1];
segment[nsegments].x2 = lfoot[i+1][0];
segment[nsegments].y2 = lfoot[i+1][1];
segment[nsegments].concave = 0;
nsegments++;
}
cycle = 0;
concave = 0;
ngroups = 1;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 1;
segment[i].inactivate = 0;
}
break;
}
case (S_TREES_B):
{
for (i=0; i<NTREES; i++)
{
x = XMIN + ((double)i - 0.5 + 0.1*(double)rand()/(double)RAND_MAX)*(XMAX-XMIN)*1.1/(double)NTREES;
if (i<NTREES/2) y = YMIN + 0.03*(double)i*(YMAX - YMIN);
else y = YMIN + 0.03*(double)(NTREES/2)*(YMAX - YMIN) - 0.025*(double)(i - NTREES/2)*(YMAX - YMIN);
add_tree_to_segments(x, y, LAMBDA*(1.0 + 0.4*(double)rand()/(double)RAND_MAX), lfoot[i], rfoot[i], segment, i+1);
}
/* add ground */
for (i=0; i<NTREES-1; i++)
{
segment[nsegments].x1 = rfoot[i][0];
segment[nsegments].y1 = rfoot[i][1];
segment[nsegments].x2 = lfoot[i+1][0];
segment[nsegments].y2 = lfoot[i+1][1];
segment[nsegments].concave = 0;
nsegments++;
segment[nsegments].x1 = lfoot[i+1][0];
segment[nsegments].y1 = lfoot[i+1][1];
segment[nsegments].x2 = rfoot[i+1][0];
segment[nsegments].y2 = rfoot[i+1][1];
segment[nsegments].concave = 0;
nsegments++;
}
cycle = 0;
concave = 0;
ngroups = 1;
for (i=0; i<nsegments; i++)
{
segment[i].concave = 1;
segment[i].inactivate = 0;
}
break;
}
case (S_CONE):
{
add_rotated_angle_to_segments(LAMBDA, LAMBDA, 0.05, -0.2, WALL_WIDTH, 0, segment, 0);
add_rotated_angle_to_segments(-0.05, -0.2, -LAMBDA, LAMBDA, WALL_WIDTH, 0, segment, 0);
cycle = 0;
concave = 1;
for (i=0; i<nsegments; i++)
{
segment[i].group = 0;
segment[i].inactivate = 0;
}
break;
}
case (S_CONVEYOR_BELT):
{
add_conveyor_belt(XMIN + 0.05, 0.0, 0.5, 0.0, 0.05, BELT_SPEED1, 0, segment, conveyor_belt);
cycle = 0;
concave = 0;
break;
}
case (S_TWO_CONVEYOR_BELTS):
{
add_conveyor_belt(XMIN + 0.05, 0.2, 0.8, 0.5, 0.05, BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(-0.5, -0.3, XMAX - 0.05, -0.8, 0.05, BELT_SPEED2, 0, segment, conveyor_belt);
cycle = 0;
concave = 0;
break;
}
case (S_PERIODIC_CONVEYORS):
{
add_conveyor_belt(0.05, -0.3, XMAX - XMIN - 0.125, 0.4, 0.05, BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(XMIN - XMAX + 0.05, -0.3, -0.125, 0.4, 0.05, BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(-1.0, -0.6, 0.2, -0.6, 0.05, BELT_SPEED2, 0, segment, conveyor_belt);
cycle = 0;
concave = 0;
break;
}
case (S_CONVEYOR_SHOVELS):
{
add_conveyor_belt(-1.0, -0.97, 1.0, 0.8, 0.05, BELT_SPEED1, 25, segment, conveyor_belt);
add_rectangle_to_segments(WALL_WIDTH, YMIN - 0.05, -WALL_WIDTH, -0.5, segment, 0);
cycle = 0;
concave = 0;
break;
}
case (S_CONVEYOR_MIXED):
{
add_conveyor_belt(XMIN - 0.32, 0.65, -0.2, 0.65, 0.05, BELT_SPEED2, 0, segment, conveyor_belt);
add_conveyor_belt(XMAX - 0.32, 0.65, XMAX - XMIN - 0.2, 0.65, 0.05, BELT_SPEED2, 0, segment, conveyor_belt);
add_conveyor_belt(XMIN + 0.3, 0.3, 0.0, 0.3, 0.05, -BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(XMIN + 0.1, -0.05, -0.2, -0.05, 0.05, BELT_SPEED2, 0, segment, conveyor_belt);
add_conveyor_belt(XMIN - 0.5, -0.4, 0.0, -0.4, 0.05, -BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(XMAX - 0.5, -0.4, XMAX - XMIN, -0.4, 0.05, -BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(XMIN - 0.3, -0.75, -0.25, -0.75, 0.05, BELT_SPEED2, 0, segment, conveyor_belt);
add_conveyor_belt(XMAX - 0.7, -0.75, XMAX - XMIN - 0.25, -0.75, 0.05, BELT_SPEED2, 0, segment, conveyor_belt);
add_conveyor_belt(-0.13, -0.97, 1.67, 0.95, 0.05, BELT_SPEED3, 24, segment, conveyor_belt);
cycle = 0;
concave = 0;
break;
}
case (S_CONVEYOR_SIEVE):
{
add_conveyor_belt(XMIN, 0.8, -0.4, 0.8, 0.05, BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(0.05, 0.0, XMAX - 0.3, 0.0, 0.05, BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(0.05, -0.5, XMAX - 1.0, -0.5, 0.05, BELT_SPEED1, 0, segment, conveyor_belt);
add_rectangle_to_segments(1.3, YMIN - 0.05, 1.3 - WALL_WIDTH, -0.3, segment, 0);
add_rectangle_to_segments(0.6, YMIN - 0.05, 0.6 - WALL_WIDTH, -0.75, segment, 0);
add_rectangle_to_segments(0.0, YMIN - 0.05, - WALL_WIDTH, -0.95, segment, 0);
cycle = 0;
concave = 0;
break;
}
case (S_CONVEYOR_SIEVE_B):
{
add_conveyor_belt(-0.7, 0.8, XMAX + 0.1, 0.8, 0.05, -BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(0.05, 0.0, XMAX - 0.3, 0.0, 0.05, BELT_SPEED2, 0, segment, conveyor_belt);
add_conveyor_belt(0.05, -0.5, XMAX - 1.0, -0.5, 0.05, BELT_SPEED2, 0, segment, conveyor_belt);
add_rectangle_to_segments(1.5, YMIN - 0.05, 1.5 - WALL_WIDTH, -0.15, segment, 0);
add_rectangle_to_segments(0.75, YMIN - 0.05, 0.75 - WALL_WIDTH, -0.75, segment, 0);
add_rectangle_to_segments(0.0, YMIN - 0.05, 0.0 - WALL_WIDTH, -0.95, segment, 0);
add_rectangle_to_segments(-1.0, YMIN - 0.05, -1.0 - WALL_WIDTH, -0.95, segment, 0);
cycle = 0;
concave = 0;
break;
}
case (S_CONVEYOR_SIEVE_LONG):
{
add_conveyor_belt(-1.4, 0.8, XMAX + 0.1, 0.8, 0.05, -BELT_SPEED1, 0, segment, conveyor_belt);
for (i=0; i<7; i++)
{
x = XMIN + (double)i*(XMAX-XMIN)/7.0;
add_rectangle_to_segments(x, YMIN - 0.05, x - WALL_WIDTH, -0.75, segment, 0);
}
cycle = 0;
concave = 0;
break;
}
case (S_CONVEYORS_1400):
{
add_conveyor_belt(-2.0 + 0.07, 0.7, 0.5, 0.7, 0.05, BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(-2.0 + 0.25, 0.2, 0.7, 0.2, 0.05, -BELT_SPEED2, 0, segment, conveyor_belt);
add_conveyor_belt(-2.0 + 0.07, -0.3, 0.5, -0.3, 0.05, BELT_SPEED1, 0, segment, conveyor_belt);
add_conveyor_belt(0.3, -0.97, 3.0, 1.5, 0.05, BELT_SPEED1, 35, segment, conveyor_belt);
// add_rotated_angle_to_segments(4.0, 0.6, 2.9, 0.4, WALL_WIDTH, 1, segment, 0);
// add_conveyor_belt(1.5, -0.5, 4.5, -0.5, 0.05, -BELT_SPEED2, 0, segment, conveyor_belt);
add_rectangle_to_segments(2.0, -0.5, 2.0 - WALL_WIDTH, -0.15, segment, 0);
add_rectangle_to_segments(3.5, -0.5, 2.0, -0.5 + WALL_WIDTH, segment, 0);
add_rectangle_to_segments(3.5, -0.5, 3.5 - WALL_WIDTH, -0.15, segment, 0);
add_conveyor_belt(1.5, -1.4, 5.5, -1.4, 0.05, -BELT_SPEED2, 0, segment, conveyor_belt);
add_conveyor_belt(-1.4, -1.4, 2.0, -1.8, 0.05, -BELT_SPEED2, 0, segment, conveyor_belt);
add_rotated_angle_to_segments(-1.0, -1.6, -2.5, -2.6, WALL_WIDTH, 1, segment, 0);
add_rotated_angle_to_segments(-1.9, -2.6, -3.4, -1.6, WALL_WIDTH, 1, segment, 0);
add_conveyor_belt(-2.2, -2.13, -2.2, 1.45, 0.07, 1.5*BELT_SPEED2, 36, segment, conveyor_belt);
cycle = 0;
concave = 0;
break;
}
case (S_MASS_SPECTROMETER):
{
for (i=0; i<7; i++)
{
y = YMIN + (double)i*(YMAX-YMIN)/7.0;
add_rectangle_to_segments(XMAX + 0.2, y, XMAX - 0.6, y + WALL_WIDTH, segment, 0);
}
cycle = 0;
concave = 0;
break;
}
case (S_WIND_FORCE):
{
for (i=0; i<10; i++)
{
x = XMIN + (double)i*(XMAX-XMIN)/10.0;
add_rectangle_to_segments(x, YMIN - 0.05, x - WALL_WIDTH, WIND_YMIN - 0.1, segment, 0);
}
cycle = 0;
concave = 0;
break;
}
case (S_BINS_GALTON):
{
dy = (YMAX - YMIN)/((double)(NGRIDX + 3));
dx = dy/cos(PI/6.0);
for (i=-1; i<=NGRIDX; i++)
{
x = ((double)i - 0.5*(double)NGRIDX + 0.5)*dx;
add_rectangle_to_segments(x + 0.5*WALL_WIDTH, YMIN - 0.05, x - 0.5*WALL_WIDTH, YMIN + 2.75*dy, segment, 0);
}
cycle = 0;
concave = 0;
break;
}
case (S_BINS_GALTON_WIDE):
{
dy = (YMAX - YMIN)/((double)(NGRIDX + 3));
dx = dy/cos(PI/6.0);
for (i=-5; i<=NGRIDX+4; i++)
{
x = ((double)i - 0.5*(double)NGRIDX + 0.5)*dx;
add_rectangle_to_segments(x + 0.5*WALL_WIDTH, YMIN - 0.05, x - 0.5*WALL_WIDTH, YMIN + 2.75*dy, segment, 0);
}
cycle = 0;
concave = 0;
break;
}
case (S_TEST_CONVEYORS):
{
add_conveyor_belt(-1.0, -0.7, 1.0, 0.7, 0.05, BELT_SPEED1, 25, segment, conveyor_belt);
// add_conveyor_belt(-0.5, -0.3, 0.5, 0.3, 0.05, BELT_SPEED1, 100, segment, conveyor_belt);
cycle = 0;
concave = 0;
break;
}
default:
{
printf("Function init_segment_config not defined for this pattern \n");
}
}
if (cycle) for (i=0; i<nsegments; i++)
{
segment[i].x2 = segment[(i+1)%(nsegments)].x1;
segment[i].y2 = segment[(i+1)%(nsegments)].y1;
}
else if (SEGMENT_PATTERN != S_TWO_CIRCLES_EXT) for (i=0; i<nsegments; i++) if (segment[i].cycle)
{
segment[i].x2 = segment[(i+1)%(nsegments)].x1;
segment[i].y2 = segment[(i+1)%(nsegments)].y1;
}
/* add one segment for S_POLY_ELLIPSE configuration */
if (SEGMENT_PATTERN == S_POLY_ELLIPSE)
{
segment[nsegments].x1 = -cos(((double)i + 0.5)*angle);
segment[nsegments].y1 = LAMBDA*sin(((double)i + 0.5)*angle);
segment[nsegments].x2 = -cos(((double)i + 0.5)*angle);
segment[nsegments].y2 = -LAMBDA*sin(((double)i + 0.5)*angle);
segment[nsegments].inactivate = 1;
nsegments++;
}
/* activate all segments */
for (i=0; i<nsegments; i++) segment[i].active = 1;
/* inactivate some segments of leaky centrifuge */
// if (SEGMENT_PATTERN == S_CENTRIFUGE_LEAKY)
// for (i=0; i<NPOLY; i++) segment[(nsides+2)*i + nsides/2].active = 0;
/* compute parameters for slope and normal of segments */
for (i=0; i<nsegments; i++)
{
a = segment[i].y1 - segment[i].y2;
b = segment[i].x2 - segment[i].x1;
length = module2(a, b);
segment[i].nx = a/length;
segment[i].ny = b/length;
segment[i].nangle = argument(segment[i].nx, segment[i].ny);
segment[i].c = segment[i].nx*segment[i].x1 + segment[i].ny*segment[i].y1;
segment[i].length = length;
segment[i].fx = 0.0;
segment[i].fy = 0.0;
segment[i].torque = 0.0;
segment[i].xc = 0.5*(segment[i].x1 + segment[i].x2);
segment[i].yc = 0.5*(segment[i].y1 + segment[i].y2);
}
/* deal with concave corners */
if (concave) for (i=0; i<nsegments; i++) if (segment[i].concave)
{
iminus = i-1;
iplus = i+1;
if (SEGMENT_PATTERN == S_TWO_CIRCLES_EXT)
{
if (iminus == -1) iminus += nsegments/2;
else if (iminus == nsegments/2 - 1) iminus += nsegments/2;
if (iplus == nsegments/2) iplus = 0;
else if (iplus == nsegments) iplus = nsegments/2;
}
else
{
if (iminus < 0) iminus = nsegments - 1;
if (iplus > nsegments - 1) iplus = 0;
}
angle = argument(segment[iplus].x1 - segment[i].x1, segment[iplus].y1 - segment[i].y1) + PID;
angle2 = argument(segment[i].x1 - segment[iminus].x1, segment[i].y1 - segment[iminus].y1) + PID;
if (angle2 < angle) angle2 += DPI;
segment[i].angle1 = angle;
segment[i].angle2 = angle2;
printf("i = %i, iplus = %i, iminus = %i, angle1 = %.0f, angle2 = %.0f\n", i, iplus, iminus, angle*360.0/DPI, angle2*360.0/DPI);
}
/* make copy of initial values in case of rotation/translation */
if ((ROTATE_BOUNDARY)||(MOVE_BOUNDARY)||(MOVE_SEGMENT_GROUPS)) for (i=0; i<nsegments; i++)
{
segment[i].x01 = segment[i].x1;
segment[i].x02 = segment[i].x2;
segment[i].y01 = segment[i].y1;
segment[i].y02 = segment[i].y2;
segment[i].nx0 = segment[i].nx;
segment[i].ny0 = segment[i].ny;
segment[i].angle01 = segment[i].angle1;
segment[i].angle02 = segment[i].angle2;
}
/* initialize averaged pressure */
if (SHOW_SEGMENTS_PRESSURE) for (i=0; i<nsegments; i++)
segment[i].avrg_pressure = 0.0;
// for (i=0; i<nsegments; i++)
// {
// printf("Segment %i: (x1, y1) = (%.3lg,%.3lg), (x2, y2) = (%.3lg,%.3lg)\n (nx, ny) = (%.3lg,%.3lg), c = %.3lg, length = %.3lg\n", i, segment[i].x1, segment[i].y1, segment[i].x2, segment[i].y2, segment[i].nx, segment[i].ny, segment[i].c, segment[i].length);
// if (segment[i].concave) printf("Concave with angles %.3lg Pi, %.3lg Pi\n", segment[i].angle1/PI, segment[i].angle2/PI);
// }
// sleep(4);
}
int in_rocket(double x, double y, int rocket_shape)
/* returns 1 if (x,y) is in rocket chamber, with translated coordinates */
{
double l, y1, a, b, c;
switch (rocket_shape) {
case (RCK_DISC) :
{
l = 0.7*LAMBDA;
y1 = y - YMIN - 1.7*LAMBDA;
return ((x*x + y1*y1)/(l*l) + MU*MU < 0.875);
// return ((x*x + y1*y1)/(l*l) + MU*MU < 0.925*LAMBDA*LAMBDA);
}
case (RCK_RECT) :
{
a = 0.5*LAMBDA;
b = 0.49*PI*LAMBDA;
y1 = y - YMIN - LAMBDA;
return ((vabs(x) < 0.95*a)&&(y1 > 0.05)&&(y1 < b - 0.05));
}
case (RCK_RECT_HAT) :
{
// printf("(%.2lg,%.2lg) in rocket?\n", x, y);
a = 0.5*LAMBDA;
b = (0.49*PI-0.25)*LAMBDA;
y1 = y - YMIN - LAMBDA;
if (vabs(x) > 0.95*a) return(0);
if (y1 < 0.05) return(0);
if (y1 < b - 0.05) return(1);
return(y1 < a + b - 0.05 - vabs(x));
// return(1);
}
case (RCK_RECT_BAR) :
{
a = 0.5*LAMBDA;
b = (0.49*PI-0.25)*LAMBDA;
c = 0.5*a;
y1 = y - YMIN - LAMBDA;
if (vabs(x) > 0.95*a) return(0);
if (vabs(x) < 0.1*a) return(0);
if (y1 < 0.05 + c) return(0);
if (y1 < b - 0.05 + c) return(1);
return(y1 < a + b - 0.05 + c - vabs(x));
}
}
}
int in_segment_region(double x, double y, t_segment segment[NMAXSEGMENTS])
/* returns 1 if (x,y) is inside region delimited by obstacle segments */
{
int i;
double angle, dx, height, width, length, theta, lx, ly, x1, y1, x2, y2, padding, ca, sa, r;
if (x >= BCXMAX) return(0);
if (x <= BCXMIN) return(0);
if (y >= BCYMAX) return(0);
if (y <= BCYMIN) return(0);
switch (SEGMENT_PATTERN) {
case (S_CUP):
{
angle = APOLY*PID;
dx = (BCYMAX - BCYMIN)/tan(angle);
if (y < BCYMAX - (BCYMAX - BCYMIN)*(x - BCXMIN)/dx) return(0);
if (y < BCYMAX - (BCYMAX - BCYMIN)*(BCXMAX - x)/dx) return(0);
}
case (S_HOURGLASS):
{
angle = APOLY*PID;
width = 2.5*MU;
height = 2.5*MU;
x = vabs(x);
y = vabs(y);
if ((x >= width)&&(x - width >= (y - height)*(BCXMAX - width)/(BCYMAX - height))) return(0);
return(1);
}
case (S_PENTA):
{
height = 0.5*(BCYMAX - BCYMIN);
width = height/sqrt(3.0);
if (y < BCYMIN + height*(1.0 - (x - BCXMIN)/width)) return(0);
if (y > BCYMAX - height*(1.0 - (x - BCXMIN)/width)) return(0);
return(1);
}
case (S_CENTRIFUGE):
{
angle = argument(x,y);
theta = DPI/(double)NPOLY;
while (angle > theta) angle -= theta;
while (angle < 0.0) angle += theta;
if (angle < 0.1) return(0);
if (angle > 0.9) return(0);
return(1);
}
case (S_POLY_ELLIPSE):
{
if (x*x + y*y/(LAMBDA*LAMBDA) < 0.95) return(1);
else return(0);
}
case (S_CENTRIFUGE_RND):
{
if (module2(x,y) > 0.75) return(0);
angle = argument(x,y);
theta = DPI/(double)NPOLY;
while (angle > theta) angle -= theta;
while (angle < 0.0) angle += theta;
if (angle < 0.1) return(0);
if (angle > 0.9) return(0);
return(1);
}
case (S_CENTRIFUGE_LEAKY):
{
if (module2(x,y) > 0.75) return(0);
angle = argument(x,y);
theta = DPI/(double)NPOLY;
while (angle > theta) angle -= theta;
while (angle < 0.0) angle += theta;
if (angle < 0.1) return(0);
if (angle > 0.9) return(0);
return(1);
}
case (S_CIRCLE_EXT):
{
if (module2(x - SEGMENTS_X0, y - SEGMENTS_Y0) > LAMBDA + 2.0*MU) return(1);
else return(0);
}
case (S_TWO_CIRCLES_EXT):
{
if ((module2(x - SEGMENTS_X0, y - SEGMENTS_Y0) > LAMBDA + 2.0*MU)&&(module2(x + SEGMENTS_X0, y - SEGMENTS_Y0) > TWO_CIRCLES_RADIUS_RATIO*LAMBDA + 2.0*MU)) return(1);
else return(0);
}
case (S_ROCKET_NOZZLE):
{
if (x < 0.0) return(0);
else if (x > 1.4*LAMBDA) return(0);
else
{
lx = 0.7*LAMBDA;
ly = 0.7*LAMBDA;
x -= lx;
if (x*x/(lx*lx) + y*y/(ly*ly) < 0.95) return(1);
}
return(0);
}
case (S_ROCKET_NOZZLE_ROTATED):
{
y1 = y - ysegments[0];
if (y1 < YMIN + LAMBDA) return(0);
else if (y1 > YMIN + 2.4*LAMBDA) return(0);
else if (in_rocket(x - xsegments[0], y1, ROCKET_SHAPE)) return(1);
// {
// ly = 0.7*LAMBDA;
// lx = 0.7*LAMBDA;
// x1 = x - xsegments[0];
// y1 -= YMIN + 1.7*LAMBDA;
// if (x1*x1/(lx*lx) + y1*y1/(ly*ly) + MU*MU < 0.925) return(1);
// }
return(0);
}
case (S_TWO_ROCKETS):
{
y1 = y - ysegments[0];
y2 = y - ysegments[1];
if ((y1 < YMIN + LAMBDA)&&(y2 < YMIN + LAMBDA)) return(0);
else if ((y1 > YMIN + 3.5*LAMBDA)&&(y2 > YMIN + 3.5*LAMBDA)) return(0);
else
{
if (in_rocket(x - xsegments[0], y1, ROCKET_SHAPE_B)) return(1);
if (in_rocket(x - xsegments[1], y2, ROCKET_SHAPE)) return(1);
}
return(0);
}
case (S_DAM):
{
if (vabs(x) > DAM_WIDTH) return(1);
else if (y > LAMBDA) return(1);
else return(0);
}
case (S_EXT_RECTANGLE):
{
padding = 0.1;
if (vabs(x) > LAMBDA + padding) return(1);
else if (vabs(y) > 0.1*LAMBDA + padding) return(1);
else return(0);
}
case (S_EXT_CIRCLE_RECT):
{
padding = 0.1;
if ((vabs(x - SEGMENTS_X0) < LAMBDA + padding)&&(vabs(y - SEGMENTS_Y0) < 0.1*LAMBDA + padding)) return(0);
else if (module2(x + SEGMENTS_X0, y - SEGMENTS_Y0) < 0.5*LAMBDA + padding) return(0);
else return(1);
}
case (S_BIN_OPENING):
{
padding = 3.0*MU;
if (y < 0.0) return(1);
if ((y > 1.0 - LAMBDA + padding)&&(vabs(x) < LAMBDA - padding)) return(1);
return(0);
}
case (S_POLYGON_EXT):
{
padding = 3.0*MU;
if (in_polygon(x, y, LAMBDA + padding, NPOLY, APOLY)) return(0);
else return(1);
}
case (S_WEDGE_EXT):
{
padding = 3.0*MU;
angle = AWEDGE*PID;
ca = cos(APOLY*PID);
sa = sin(APOLY*PID);
x1 = x*ca - y*sa;
y1 = x*sa + y*ca;
if (vabs(y1) - padding > (LAMBDA-x1)*sin(angle)/(1.0+cos(angle))) return(1);
if (vabs(y1) + padding < -x1*tan(angle)) return(1);
return(0);
}
case (S_MIXER):
{
padding = 1.5*MU;
r = module2(x,y);
if (r > LAMBDA + padding) return(1);
if (r < 2.0*padding) return(0);
for (i=0; i<NPOLY; i++)
{
angle = (double)i*DPI/(double)NPOLY;
ca = cos(angle);
sa = sin(angle);
x1 = x*ca - y*sa;
y1 = x*sa + y*ca;
if ((x1 > 0.0)&&(vabs(y1) < 0.025 + padding)) return(0);
}
return(1);
}
case (S_AIRFOIL):
{
if (vabs(x) > LAMBDA + 4.0*MU) return(1);
padding = 0.35;
angle = APOLY*PID;
ca = cos(angle);
sa = sin(angle);
x1 = x*ca - y*sa;
y1 = x*sa + y*ca;
y1 += 0.5*x1*x1;
return(x1*x1 + 25.0*y1*y1 > LAMBDA*LAMBDA*(1.0 + padding));
}
case (S_COANDA):
{
return(vabs(y - SEGMENTS_Y0 - 0.25*cos(PI*x/XMAX)) > 0.1);
}
case (S_COANDA_SHORT):
{
x1 = XMIN + 0.1;
length = 0.85*(XMAX - XMIN - 0.2);
if (x > x1 + length + 0.1) return(1);
return(vabs(y - SEGMENTS_Y0 + 0.2*cos(DPI*(x-x1)/length)) > 0.05);
}
case (S_CYLINDER):
{
if (y > YMAX - 0.05 - MU) return(0);
if (y < YMIN + 0.05 + MU) return(0);
return(1);
}
case (S_MAZE):
{
for (i=0; i<nsegments; i++)
{
if (distance_to_segment(x, y, segment[i].x1, segment[i].y1, segment[i].x2, segment[i].y2) < 5.0*MAZE_WIDTH) return(0);
}
return(1);
}
case (S_MAZE_DIAG):
{
for (i=0; i<nsegments; i++)
{
if (distance_to_segment(x, y, segment[i].x1, segment[i].y1, segment[i].x2, segment[i].y2) < 5.0*MAZE_WIDTH) return(0);
}
return(1);
}
default: return(1);
}
}
void rotate_segments(t_segment segment[NMAXSEGMENTS], double angle)
/* rotates the repelling segments by given angle */
{
int i;
double ca, sa;
ca = cos(angle);
sa = sin(angle);
for (i=0; i<nsegments; i++)
{
segment[i].x1 = ca*segment[i].x01 - sa*segment[i].y01;
segment[i].y1 = sa*segment[i].x01 + ca*segment[i].y01;
segment[i].x2 = ca*segment[i].x02 - sa*segment[i].y02;
segment[i].y2 = sa*segment[i].x02 + ca*segment[i].y02;
segment[i].nx = ca*segment[i].nx0 - sa*segment[i].ny0;
segment[i].ny = sa*segment[i].nx0 + ca*segment[i].ny0;
if (segment[i].concave)
{
segment[i].angle1 = segment[i].angle01 + angle;
segment[i].angle2 = segment[i].angle02 + angle;
while (segment[i].angle1 > DPI)
{
segment[i].angle1 -= DPI;
segment[i].angle2 -= DPI;
}
}
}
}
/* Computation of interaction force */
double lennard_jones_force(double r, t_particle particle)
{
int i;
double rmin = 0.01, rplus, ratio = 1.0;
if (r > REPEL_RADIUS*particle.radius) return(0.0);
else
{
if (r > rmin) rplus = r;
else rplus = rmin;
// ratio = ipow(particle.eq_dist*particle.radius/rplus, 6);
ratio = ipow(particle.eq_dist*particle.radius/rplus, 3);
ratio = ratio*ratio;
return((ratio - 2.0*ratio*ratio)/rplus);
}
}
double harmonic_force(double r, t_particle particle)
{
int i;
double rmin = 0.01, rplus, ratio = 1.0;
if (r > REPEL_RADIUS*particle.radius) return(0.0);
else
{
// if (r > rmin) rplus = r;
// else rplus = rmin;
// ratio = rplus/particle.eq_dist*particle.radius;
ratio = r/particle.eq_dist*particle.radius;
if (ratio < 1.0) return(ratio - 1.0);
else return(0.0);
}
}
double coulomb_force(double r, t_particle particle)
{
int i;
double rmin = 0.01, rplus, ratio = 1.0;
if (r > REPEL_RADIUS*particle.radius) return(0.0);
else
{
// if (r > rmin) rplus = r;
// else rplus = rmin;
// ratio = rplus/particle.eq_dist*particle.radius;
ratio = r/particle.eq_dist*particle.radius;
return(-1.0/(ratio*ratio + rmin*rmin));
// if (ratio < 1.0) return(ratio - 1.0);
// else return(0.0);
}
}
void aniso_lj_force(double r, double ca, double sa, double ca_rel, double sa_rel, double force[2], t_particle particle)
{
int i;
double rmin = 0.01, rplus, ratio = 1.0, c2, s2, c4, s4, a, aprime, f1, f2;
if (r > REPEL_RADIUS*particle.radius)
{
force[0] = 0.0;
force[1] = 0.0;
}
else
{
if (r > rmin) rplus = r;
else rplus = rmin;
// ratio = ipow(particle.eq_dist*particle.radius/rplus, 6);
ratio = ipow(particle.eq_dist*particle.radius/rplus, 3);
ratio = ratio*ratio;
/* cos(2phi) and sin(2phi) */
c2 = ca_rel*ca_rel - sa_rel*sa_rel;
s2 = 2.0*ca_rel*sa_rel;
/* cos(4phi) and sin(4phi) */
c4 = c2*c2 - s2*s2;
s4 = 2.0*c2*s2;
a = 0.5*(9.0 - 7.0*c4);
aprime = 14.0*s4;
f1 = ratio*(a - ratio)/rplus;
f2 = ratio*aprime/rplus;
force[0] = f1*ca - f2*sa;
force[1] = f1*sa + f2*ca;
}
}
void penta_lj_force(double r, double ca, double sa, double ca_rel, double sa_rel, double force[2], t_particle particle)
{
int i;
double rmin = 0.01, rplus, ratio = 1.0, c2, s2, c4, s4, c5, s5, a, aprime, f1, f2;
static double a0, b0;
static int first = 1;
if (first)
{
a0 = cos(0.1*PI) + 0.5;
b0 = a0 - 1.0;
first = 0;
}
if (r > REPEL_RADIUS*particle.radius)
{
force[0] = 0.0;
force[1] = 0.0;
}
else
{
if (r > rmin) rplus = r;
else rplus = rmin;
// ratio = ipow(particle.eq_dist*particle.radius/rplus, 6);
ratio = ipow(particle.eq_dist*particle.radius/rplus, 3);
ratio = ratio*ratio;
/* cos(2phi) and sin(2phi) */
c2 = ca_rel*ca_rel - sa_rel*sa_rel;
s2 = 2.0*ca_rel*sa_rel;
/* cos(4phi) and sin(4phi) */
c4 = c2*c2 - s2*s2;
s4 = 2.0*c2*s2;
/* cos(5phi) and sin(5phi) */
c5 = ca_rel*c4 - sa_rel*s4;
s5 = sa_rel*c4 + ca_rel*s4;
a = a0 - b0*c5;
aprime = 5.0*b0*s5;
f1 = ratio*(a - ratio)/rplus;
f2 = ratio*aprime/rplus;
force[0] = f1*ca - f2*sa;
force[1] = f1*sa + f2*ca;
}
}
double old_golden_ratio_force(double r, t_particle particle)
/* potential with two minima at distances whose ratio is the golden ratio Phi */
/* old version that does not work very well */
{
int i;
double x, y, z, rplus, ratio = 1.0, phi, a, phi3;
static int first = 1;
static double rmin, b, c, d;
if (first)
{
rmin = 0.5*particle.radius;
phi = 0.5*(1.0 + sqrt(5.0));
phi3 = 1.0/(phi*phi*phi);
a = 0.66;
b = 1.0 + phi3 + a;
d = phi3*a;
c = phi3 + a + d;
// b = 7.04;
// c = 13.66;
// d = 6.7;
first = 0;
printf("a = %.4lg, b = %.4lg, c = %.4lg, d = %.4lg\n", a, b, c, d);
}
if (r > REPEL_RADIUS*particle.radius) return(0.0);
else
{
if (r > rmin) rplus = r;
else rplus = rmin;
x = particle.eq_dist*particle.radius/rplus;
y = x*x*x;
z = d - c*y + b*y*y - y*y*y;
return(x*z/rplus);
}
}
double golden_ratio_force(double r, t_particle particle)
/* potential with two minima at distances whose ratio is the golden ratio Phi */
/* piecewise polynomial/LJ version */
{
int i;
double x, rplus, xm6, y1;
static int first = 1;
static double rmin, phi, a, h1, h2, phi6;
if (first)
{
rmin = 0.5*particle.radius;
phi = 0.5*(1.0 + sqrt(5.0));
a = 1.2;
h1 = 1.0; /* inner potential well depth */
h2 = 10.0; /* outer potential well depth */
phi6 = ipow(phi, 6);
first = 0;
}
if (r > REPEL_RADIUS*particle.radius) return(0.0);
else
{
if (r > rmin) rplus = r;
else rplus = rmin;
x = rplus/(particle.eq_dist*particle.radius);
// xm6 = 1.0/ipow(x, 6);
xm6 = 1.0/ipow(x, 3);
xm6 = xm6*xm6;
if (x <= 1.0) return(12.0*h1*xm6*(1.0 - xm6)/x);
else if (x <= a)
{
y1 = ipow(a - 1.0, 3);
return(6.0*h1*(x - 1.0)*(a - x)/y1);
}
else if (x <= phi)
{
y1 = ipow(phi - a, 3);
return(6.0*h2*(x - a)*(x - phi)/y1);
}
else return(12.0*h2*phi6*(1.0 - phi6*xm6)*xm6/x);
}
}
void dipole_lj_force(double r, double ca, double sa, double ca_rel, double sa_rel, double force[2], t_particle particle)
{
int i;
double rmin = 0.01, rplus, ratio = 1.0, a, aprime, f1, f2;
if (r > REPEL_RADIUS*MU)
{
force[0] = 0.0;
force[1] = 0.0;
}
else
{
if (r > rmin) rplus = r;
else rplus = rmin;
// ratio = ipow(particle.eq_dist*particle.radius/rplus, 6);
ratio = ipow(particle.eq_dist*particle.radius/rplus, 3);
ratio = ratio*ratio;
a = 1.0 + 0.25*ca_rel;
aprime = -0.25*sa_rel;
f1 = ratio*(a - ratio)/rplus;
f2 = ratio*aprime/rplus;
force[0] = f1*ca - f2*sa;
force[1] = f1*sa + f2*ca;
}
}
void quadrupole_lj_force(double r, double ca, double sa, double ca_rel, double sa_rel, double force[2], t_particle particle)
{
int i;
double rmin = 0.01, rplus, ratio = 1.0, a, aprime, f1, f2, ca2, sa2, x, y, dplus, dminus;
static int first = 1;
static double a0, b0, aplus, aminus;
if (first)
{
dplus = cos(0.2*PI)*cos(0.1*PI);
// dminus = 0.8*dplus;
dminus = QUADRUPOLE_RATIO*dplus;
aplus = ipow(1.0/dplus, 6);
aminus = ipow(1.0/dminus, 6);
// aminus = ipow(cos(0.2*PI)*(0.25 + 0.5*sin(0.1*PI)), 6);
a0 = 0.5*(aplus + aminus);
b0 = 0.5*(aplus - aminus);
first = 0;
}
if (r > REPEL_RADIUS*particle.radius)
{
force[0] = 0.0;
force[1] = 0.0;
}
else
{
if (r > rmin) rplus = r;
else rplus = rmin;
// ratio = ipow(particle.eq_dist*particle.radius/rplus, 6);
ratio = ipow(particle.eq_dist*particle.radius/rplus, 3);
ratio = ratio*ratio;
/* cos(2*phi) and sin(2*phi) */
ca2 = ca_rel*ca_rel - sa_rel*sa_rel;
sa2 = 2.0*ca_rel*sa_rel;
a = a0 + b0*ca2;
// if (a == 0.0) a = 1.0e-10;
aprime = -2.0*b0*sa2;
f1 = ratio*(a - ratio)/rplus;
f2 = ratio*aprime/rplus;
force[0] = f1*ca - f2*sa;
force[1] = f1*sa + f2*ca;
}
}
void quadrupole_lj_force2(double r, double ca, double sa, double ca_rel, double sa_rel, double force[2], t_particle particle)
{
int i;
double rmin = 0.01, rplus, ratio = 1.0, a, aprime, f1, f2, ca2, sa2, x, y, eqdist;
static int first = 1;
static double aplus, aminus, a0, b0;
if (first)
{
aplus = ipow(cos(0.2*PI)*cos(0.1*PI), 6);
aminus = 0.1*aplus;
// aminus = 0.0;
// aminus = -2.0*ipow(cos(0.2*PI)*(0.5*sin(0.1*PI)), 6);
// aminus = ipow(cos(0.2*PI)*(0.25 + 0.5*sin(0.1*PI)), 6);
a0 = 0.5*(aplus + aminus);
b0 = 0.5*(aplus - aminus);
first = 0;
}
if (r > REPEL_RADIUS*particle.radius)
{
force[0] = 0.0;
force[1] = 0.0;
}
else
{
if (r > rmin) rplus = r;
else rplus = rmin;
/* correct distance */
// ratio = ipow(particle.eq_dist*particle.radius/rplus, 6);
ratio = ipow(particle.eq_dist*particle.radius/rplus, 3);
ratio = ratio*ratio;
/* cos(2*phi) and sin(2*phi) */
ca2 = ca_rel*ca_rel - sa_rel*sa_rel;
sa2 = 2.0*ca_rel*sa_rel;
a = a0 + b0*ca2;
if (a == 0.0) a = 1.0e-10;
aprime = -2.0*b0*sa2;
// f1 = ratio*(a - ratio)/rplus;
// f2 = ratio*aprime/rplus;
f1 = ratio*(aplus - ratio)/(rplus);
f2 = ratio*(aminus - ratio)/(rplus);
// force[0] = f1*ca_rel - f2*sa_rel;
// force[1] = f1*sa_rel + f2*ca_rel;
force[0] = f1*ca - f2*sa;
force[1] = f1*sa + f2*ca;
}
}
double water_torque(double r, double ca, double sa, double ca_rel, double sa_rel, double ck_rel, double sk_rel)
/* compute torque of water molecule #k on water molecule #j (for interaction I_LJ_WATER) - OLD VERSION */
{
double c1p, c1m, c2p, c2m, s2p, s2m, s21, s21p, s21m, c21, c21p, c21m, torque;
double r2, rd, rd2, rr[3][3];
static double cw = -0.5, sw = 0.866025404, delta = 1.5*MU, d2 = 2.25*MU*MU;
int i, j;
c1p = ck_rel*cw - sk_rel*sw;
c1m = ck_rel*cw + sk_rel*sw;
c2p = ca_rel*cw - sa_rel*sw;
c2m = ca_rel*cw + sa_rel*sw;
s2p = sa_rel*cw + ca_rel*sw;
s2m = sa_rel*cw - ca_rel*sw;
s21 = sa_rel*ck_rel - ca_rel*sk_rel;
c21 = ca_rel*ck_rel + sa_rel*sk_rel;
s21p = s21*cw - c21*sw;
s21m = s21*cw + c21*sw;
c21p = c21*cw + s21*sw;
c21m = c21*cw - s21*sw;
r2 = r*r;
rd = 2.0*r*delta;
rd2 = r2 + d2;
rr[0][0] = r;
rr[0][1] = sqrt(rd2 + rd*c2p);
rr[0][2] = sqrt(rd2 + rd*c2m);
rr[1][0] = sqrt(rd2 - rd*c1p);
rr[2][0] = sqrt(rd2 - rd*c1m);
rr[1][1] = sqrt(r2 + rd*(c2p - c1p) + 2.0*d2*(1.0 - c21));
rr[1][2] = sqrt(r2 + rd*(c2m - c1p) + 2.0*d2*(1.0 - c21m));
rr[2][1] = sqrt(r2 + rd*(c2p - c1m) + 2.0*d2*(1.0 - c21p));
rr[2][2] = sqrt(r2 + rd*(c2m - c1m) + 2.0*d2*(1.0 - c21));
for (i=0; i<3; i++) for (j=0; j<3; j++)
{
if (rr[i][j] < 1.0e-4) rr[i][j] = 1.0e-4;
rr[i][j] = rr[i][j]*rr[i][j]*rr[i][j];
}
torque = rd*(s2p/rr[0][1] + s2m/rr[0][2]);
torque += -0.5*rd*(s2p/rr[1][1] + s2p/rr[2][1] + s2m/rr[1][2] + s2m/rr[2][2]);
torque += d2*(s21/rr[1][1] + s21/rr[2][2] + s21m/rr[1][2] + s21p/rr[2][1]);
return(torque);
}
double water_force(double r, double ca, double sa, double ca_rel, double sa_rel, double ck_rel, double sk_rel, double f[2])
/* compute force and torque of water molecule #k on water molecule #j (for interaction I_LJ_WATER) */
{
double x1[3], y1[3], x2[3], y2[3], rr[3][3], dx[3][3], dy[3][3], fx[3][3], fy[3][3], m[3][3], torque = 0.0;
static double cw[3], sw[3], q[3], d[3], delta = 1.25*MU, dmin = 0.5*MU, fscale = 1.0;
int i, j;
static int first = 1;
if (first)
{
cw[0] = 1.0; cw[1] = -0.5; cw[2] = -0.5;
sw[0] = 0.0; sw[1] = 866025404; sw[2] = -866025404; /* sines and cosines of angles */
q[0] = -2.0; q[1] = 1.0; q[2] = 1.0; /* charges */
d[0] = 0.5*delta; d[1] = delta; d[2] = delta; /* distances to center */
first = 0;
}
/* positions of O and H atoms */
for (i=0; i<3; i++)
{
x1[i] = d[i]*(ca_rel*cw[i] - sa_rel*sw[i]);
y1[i] = d[i]*(ca_rel*sw[i] + sa_rel*cw[i]);
x2[i] = r + d[i]*(ck_rel*cw[i] - sk_rel*sw[i]);
y2[i] = d[i]*(ck_rel*sw[i] + sk_rel*cw[i]);
}
/* relative positions */
for (i=0; i<3; i++) for (j=0; j<3; j++)
{
dx[i][j] = x2[j] - x1[i];
dy[i][j] = y2[j] - y1[i];
rr[i][j] = module2(dx[i][j], dy[i][j]);
if (rr[i][j] < dmin) rr[i][j] = dmin;
rr[i][j] = ipow(rr[i][j],3);
// rr[i][j] = rr[i][j]*rr[i][j]*rr[i][j];
}
/* forces between particles */
for (i=0; i<3; i++) for (j=0; j<3; j++)
{
fx[i][j] = -q[i]*q[j]*dx[i][j]/rr[i][j];
fy[i][j] = -q[i]*q[j]*dy[i][j]/rr[i][j];
}
/* torques between particles */
for (i=0; i<3; i++) for (j=0; j<3; j++)
{
m[i][j] = x1[i]*fy[i][j] - y1[i]*fx[i][j];
}
/* total force */
f[0] = 0.0;
f[1] = 0.0;
for (i=0; i<3; i++) for (j=0; j<3; j++)
{
f[0] += fscale*fx[i][j];
f[1] += fscale*fy[i][j];
torque += fscale*m[i][j];
}
return(torque);
}
void segment_interaction(t_particle part_i, t_particle part_k, double ca, double sa, double distance, double ffm[3], int charge)
/* compute interaction for I_SEGMENT interaction */
/* computes force and torque of particle k on particle i */
{
int s;
double x0, y0, x, y, fx, fy, cb, sb, cc, sc, cab, sab, ccb, scb, r;
double width, torque, mu_i, mu_k, r3, endfact, cfact;
fx = 0.0;
fy = 0.0;
torque = 0.0;
mu_i = part_i.radius;
mu_k = part_k.radius;
width = 0.2*mu_i;
cb = cos(part_i.angle);
sb = sin(part_i.angle);
cc = cos(part_k.angle);
sc = sin(part_k.angle);
cab = ca*cb + sa*sb;
sab = sa*cb - ca*sb;
ccb = cc*cb + sc*sb;
scb = sc*cb - cc*sb;
/* relative coordinates of particle k in basis where particle i is horizontal */
x0 = distance*cab;
y0 = distance*sab;
for (s=-1; s<=1; s+=2)
{
x = x0 + (double)s*mu_k*ccb;
y = y0 + (double)s*mu_k*scb;
if (vabs(y) < width)
{
if (vabs(x) < mu_i)
{
// if (((double)s*scb < 0.0)&&(y > 0.0)) fy += y - width;
if (y > 0.0) fy += y - width;
else fy += y + width;
}
else if ((x >= mu_i)&&(x < mu_i+width))
{
r = module2(x-mu_i, y) + 1.0e-10;
if (r < width)
{
fx -= (width - r)*(x-mu_i)/r;
fy -= (width - r)*y/r;
}
}
else if ((x <= -mu_i)&&(x > -mu_i-width))
{
r = module2(x+mu_i, y) + 1.0e-10;
if (r < width)
{
fx -= (width - r)*(x+mu_i)/r;
fy -= (width - r)*y/r;
}
}
torque += x*fy - y*fx;
}
if (charge) /* add Coulomb force between ends */
{
cfact = CHARGE*KREPEL/KSPRING_OBSTACLE;
r = module2(x-mu_i,y) + 1.0e-2;
r3 = r*r*r;
fx += cfact*(double)s*(x+mu_i)/r3;
fy += cfact*(double)s*y/r3;
torque += mu_i*fx;
r = module2(x+mu_i,y) + 1.0e-2;
r3 = r*r*r;
fx -= cfact*(double)s*(x+mu_i)/r3;
fy -= cfact*(double)s*y/r3;
torque -= mu_i*fy;
}
}
ffm[0] = cb*fx - sb*fy;
ffm[1] = sb*fx + cb*fy;
ffm[2] = torque;
}
void polygon_interaction(t_particle part_i, t_particle part_k, double ca, double sa, double distance, double ffm[3], int charge)
/* compute interaction for I_POLYGON interaction */
/* computes force and torque of particle k on particle i */
{
int s, k, s0, s1;
double x0, y0, x, y, f, fx, fy, cb, sb, cab, sab, r, r0, z2, phi, ckt, skt, d, fx1, fy1, dmax2;
double torque, mu_i, mu_k, r3, width, gamma_beta, rot, cr, sr, xx[NPOLY], yy[NPOLY], dd[NPOLY], z, z0, z02, d1, dmin;
static double theta, twotheta, ctheta, stheta, cornerx[NPOLY+1], cornery[NPOLY+1], nx[NPOLY], ny[NPOLY];
static int first = 1;
if (first)
{
theta = PI/(double)NPOLY;
twotheta = 2.0*theta;
ctheta = cos(theta);
stheta = sin(theta);
for (s=0; s<NPOLY+1; s++)
{
cornerx[s] = cos((double)s*twotheta);
cornery[s] = sin((double)s*twotheta);
}
for (s=0; s<NPOLY; s++)
{
nx[s] = cos((double)(2*s+1)*theta);
ny[s] = sin((double)(2*s+1)*theta);
}
first = 0;
}
fx = 0.0;
fy = 0.0;
torque = 0.0;
mu_i = part_i.radius;
mu_k = part_k.radius;
dmax2 = 4.0*mu_i*mu_i;
width = 0.1*mu_i;
mu_i -= width;
gamma_beta = part_k.angle - part_i.angle;
r0 = mu_i*ctheta;
z0 = mu_i*stheta;
z02 = z0*z0;
cb = cos(part_i.angle);
sb = sin(part_i.angle);
cab = ca*cb + sa*sb;
sab = sa*cb - ca*sb;
/* relative coordinates of particle k in basis where particle i is horizontal */
x0 = distance*cab;
y0 = distance*sab;
/* find vertex distances */
for (s = 0; s<NPOLY; s++)
{
rot = gamma_beta + (double)s*twotheta;
cr = cos(rot);
sr = sin(rot);
xx[s] = x0 + cr*mu_k;
yy[s] = y0 + sr*mu_k;
dd[s] = xx[s]*xx[s] + yy[s]*yy[s];
}
/* compute force from vertices */
for (s = 0; s<NPOLY; s++) if (dd[s] < dmax2)
{
x = xx[s];
y = yy[s];
phi = argument(x, y);
if (phi < 0.0) phi += DPI;
k = (int)(phi/twotheta);
d = x*nx[k] + y*ny[k];
if (d < r0 + width)
{
z = -x*ny[k] + y*nx[k];
if (z*z < z02)
{
f = r0 + width - d;
if (f > width) f = width;
fx1 = f*nx[k];
fy1 = f*ny[k];
fx -= fx1;
fy -= fy1;
torque += x*fy1 - y*fx1;
// fx -= f*nx[k];
// fy -= f*ny[k];
// torque += x*fy - y*fx;
}
else for (s1=0; s1<NPOLY; s1++) /* corners */
{
d1 = module2(x - mu_i*cornerx[s1], y - mu_i*cornery[s1]) + 1.0e-8;
fx1 = 0.0;
fy1 = 0.0;
if (d1 < width)
{
f = width - d1;
if (f > width) f = width;
fx1 -= f*(x - mu_i*cornerx[s1])/d1;
fy1 -= f*(y - mu_i*cornery[s1])/d1;
}
fx += fx1;
fy += fy1;
torque += x*fy1 - y*fx1;
}
}
}
ffm[0] = cb*fx - sb*fy;
ffm[1] = sb*fx + cb*fy;
ffm[2] = torque;
}
int dna_charge(int type1, int type2, int coulomb)
/* returns -1 for matching nucleotide ends, 1 for non-matching, and 0 else */
{
int min, max;
// if (coulomb == 0) return(0);
if (type1 == 0) return(0);
if (type2 == 0) return(0);
if ((type1 == 7)&&(type2 == 7)) return(2);
if (type1 == type2) return(1);
if (type1 > type2)
{
max = type1;
min = type2;
}
else
{
max = type2;
min = type1;
}
/* enzymes */
if ((min >= 3)&&(max == 7)) return(-10);
if (max - min >= 2) return(1);
if (min == 1) return(-4*coulomb);
if (min%2 == 1) return(-10*coulomb);
return(1);
}
int compute_particle_interaction(int i, int k, double force[2], double *torque, t_particle* particle, double distance, double krepel, double ca, double sa, double ca_rel, double sa_rel)
/* compute repelling force and torque of particle #k on particle #i */
/* returns 1 if distance between particles is smaller than NBH_DIST_FACTOR*MU */
{
double x1, y1, x2, y2, r, f, angle, aniso, fx, fy, ff[2], dist_scaled, spin_f, ck, sk, ck_rel, sk_rel, alpha, amp, charge, f1, ffm[3];
static double dxhalf = 0.5*(BCXMAX - BCXMIN), dyhalf = 0.5*(BCYMAX - BCYMIN);
int wwrapx, wwrapy, twrapx, twrapy;
if (BOUNDARY_COND == BC_GENUS_TWO)
{
dxhalf *= 0.75;
dyhalf *= 0.75;
}
x1 = particle[i].xc;
y1 = particle[i].yc;
x2 = particle[k].xc;
y2 = particle[k].yc;
wwrapx = ((BOUNDARY_COND == BC_KLEIN)||(BOUNDARY_COND == BC_BOY)||(BOUNDARY_COND == BC_GENUS_TWO))&&(vabs(x2 - x1) > dxhalf);
wwrapy = ((BOUNDARY_COND == BC_BOY)||(BOUNDARY_COND == BC_GENUS_TWO))&&(vabs(y2 - y1) > dyhalf);
twrapx = ((BOUNDARY_COND == BC_KLEIN)||(BOUNDARY_COND == BC_BOY))&&(vabs(x2 - x1) > dxhalf);
twrapy = (BOUNDARY_COND == BC_BOY)&&(vabs(y2 - y1) > dyhalf);
switch (particle[k].interaction) {
case (I_COULOMB):
{
f = -krepel/(1.0e-8 + distance*distance);
force[0] = f*ca;
force[1] = f*sa;
break;
}
case (I_LENNARD_JONES):
{
f = krepel*lennard_jones_force(distance, particle[k]);
force[0] = f*ca;
force[1] = f*sa;
break;
}
case (I_LJ_DIRECTIONAL):
{
aniso_lj_force(distance, ca, sa, ca_rel, sa_rel, ff, particle[k]);
force[0] = krepel*ff[0];
force[1] = krepel*ff[1];
break;
}
case (I_LJ_PENTA):
{
penta_lj_force(distance, ca, sa, ca_rel, sa_rel, ff, particle[k]);
force[0] = krepel*ff[0];
force[1] = krepel*ff[1];
break;
}
case (I_GOLDENRATIO):
{
f = krepel*golden_ratio_force(distance, particle[k]);
force[0] = f*ca;
force[1] = f*sa;
break;
}
case (I_LJ_DIPOLE):
{
dipole_lj_force(distance, ca, sa, ca_rel, sa_rel, ff, particle[k]);
force[0] = krepel*ff[0];
force[1] = krepel*ff[1];
break;
}
case (I_LJ_QUADRUPOLE):
{
quadrupole_lj_force(distance, ca, sa, ca_rel, sa_rel, ff, particle[k]);
force[0] = krepel*ff[0];
force[1] = krepel*ff[1];
break;
}
case (I_LJ_WATER):
{
f = krepel*lennard_jones_force(distance, particle[k]);
force[0] = f*ca;
force[1] = f*sa;
break;
}
case (I_VICSEK):
{
force[0] = 0.0;
force[1] = 0.0;
break;
}
case (I_VICSEK_REPULSIVE):
{
f = krepel*coulomb_force(distance, particle[k]);
// f = krepel*harmonic_force(distance, particle[k]);
// f = krepel*lennard_jones_force(distance, particle[k]);
force[0] = f*ca;
force[1] = f*sa;
break;
}
case (I_VICSEK_SPEED):
{
f = cos(0.5*(particle[k].angle - particle[i].angle));
force[0] = f*KSPRING_VICSEK*(particle[k].vx - particle[i].vx);
force[1] = f*KSPRING_VICSEK*(particle[k].vy - particle[i].vy);
break;
}
case (I_VICSEK_SHARK):
{
if (particle[k].type == particle[i].type)
{
f = cos(0.5*(particle[k].angle - particle[i].angle));
force[0] = f*KSPRING_VICSEK*(particle[k].vx - particle[i].vx);
force[1] = f*KSPRING_VICSEK*(particle[k].vy - particle[i].vy);
}
else if (particle[i].type != 2)
{
f = krepel*coulomb_force(distance, particle[k]);
force[0] = f*ca;
force[1] = f*sa;
}
else
{
if (VICSEK_REPULSION > 0.0)
{
// f = VICSEK_REPULSION*harmonic_force(distance, particle[k]);
f = VICSEK_REPULSION*coulomb_force(distance, particle[k]);
force[0] = f*ca;
force[1] = f*sa;
}
else
{
force[0] = 0.0;
force[1] = 0.0;
}
}
break;
}
case (I_COULOMB_LJ):
{
charge = particle[i].charge*particle[k].charge;
f = -100.0*krepel*charge/(1.0e-12 + distance*distance);
if (charge <= 0.0)
f += COULOMB_LJ_FACTOR*krepel*lennard_jones_force(distance, particle[k]);
force[0] = f*ca;
force[1] = f*sa;
break;
}
case (I_COULOMB_PENTA):
{
charge = particle[i].charge*particle[k].charge;
if (charge < 0.0)
{
penta_lj_force(distance, ca, sa, ca_rel, sa_rel, ff, particle[k]);
force[0] = -charge*krepel*ff[0];
force[1] = -charge*krepel*ff[1];
}
else
{
f = krepel*lennard_jones_force(distance, particle[k]);
force[0] = f*ca;
force[1] = f*sa;
}
break;
}
case (I_COULOMB_IMAGINARY):
{
charge = particle[i].charge*particle[k].charge;
f = -100.0*krepel*charge/(1.0e-12 + distance*distance);
if (charge <= 0.0)
f1 = 0.01*krepel*lennard_jones_force(distance, particle[k]);
else f1 = 0.0;
force[0] = f1*ca - f*sa;
force[1] = f1*sa + f*ca;
break;
}
case (I_DNA_CHARGED):
{
f = 0.2*krepel*lennard_jones_force(distance, particle[k]);
charge = CHARGE*(double)dna_charge(particle[i].type, particle[k].type, particle[i].coulomb);
if ((RD_REACTION == CHEM_DNA_ENZYME)||(RD_REACTION == CHEM_DNA_ENZYME_REPAIR))
{
/* make some interactions repulsive */
if ((particle[i].reactive == 0)&&(particle[k].reactive == 0)&&(particle[i].added == particle[k].added))
charge = vabs(charge);
/* TEST */
/* make interactions repulsive between base-paired and other molecules */
// else if (particle[i].paired != particle[k].paired)
// charge = vabs(charge);
}
f -= krepel*charge/(1.0e-12 + distance*distance);
force[0] = f*ca;
force[1] = f*sa;
break;
}
case (I_DNA_CHARGED_B):
{
f = 0.2*krepel*lennard_jones_force(distance, particle[k]);
charge = CHARGE*(double)dna_charge(particle[i].type, particle[k].type, particle[i].coulomb);
if (particle[i].added != particle[k].added) charge *= 1.5;
if ((RD_REACTION == CHEM_DNA_ENZYME)||(RD_REACTION == CHEM_DNA_ENZYME_REPAIR))
{
/* make some interactions repulsive */
if ((particle[i].reactive == 0)&&(particle[k].reactive == 0)&&(particle[i].added == particle[k].added))
charge = vabs(charge);
/* TEST */
/* make interactions repulsive between base-paired and other molecules */
// else if (particle[i].paired != particle[k].paired)
// charge = vabs(charge);
}
f -= krepel*charge/(1.0e-12 + distance*distance);
force[0] = f*ca;
force[1] = f*sa;
break;
}
case (I_SEGMENT):
{
segment_interaction(particle[i], particle[k], ca, sa, distance, ffm, 0);
force[0] = KSPRING_OBSTACLE*ffm[0];
force[1] = KSPRING_OBSTACLE*ffm[1];
*torque = KTORQUE*ffm[2];
f = 0.1*krepel*lennard_jones_force(distance, particle[k]);
force[0] += f*ca;
force[1] += f*sa;
break;
}
case (I_SEGMENT_CHARGED):
{
segment_interaction(particle[i], particle[k], ca, sa, distance, ffm, 1);
force[0] = KSPRING_OBSTACLE*ffm[0];
force[1] = KSPRING_OBSTACLE*ffm[1];
*torque = KTORQUE*ffm[2];
// printf("Force between particles %i and %i: (%.3lg, %.3lg)\n", i, k, force[0], force[1]);
// f = 0.1*krepel*lennard_jones_force(distance, particle[k]);
// force[0] += f*ca;
// force[1] += f*sa;
break;
}
case (I_POLYGON):
{
polygon_interaction(particle[i], particle[k], ca, sa, distance, ffm, 0);
force[0] = KSPRING_OBSTACLE*ffm[0];
force[1] = KSPRING_OBSTACLE*ffm[1];
*torque = KTORQUE*ffm[2];
f = 0.1*krepel*lennard_jones_force(distance, particle[k]);
force[0] += f*ca;
force[1] += f*sa;
break;
}
case (I_POLYGON_ALIGN):
{
polygon_interaction(particle[i], particle[k], ca, sa, distance, ffm, 0);
force[0] = KSPRING_OBSTACLE*ffm[0];
force[1] = KSPRING_OBSTACLE*ffm[1];
*torque = KTORQUE*ffm[2];
f = 0.1*krepel*lennard_jones_force(distance, particle[k]);
force[0] += f*ca;
force[1] += f*sa;
break;
}
}
if (ROTATION)
{
dist_scaled = distance/(particle[i].spin_range*particle[i].radius);
switch (particle[k].interaction) {
case (I_LJ_WATER):
{
ck = cos(particle[k].angle);
sk = sin(particle[k].angle);
ck_rel = ca*ck + sa*sk;
sk_rel = sa*ck - ca*sk;
// *torque = (-3.0*ca_rel*sk_rel + 2.0*sa_rel*ck_rel)/(1.0e-12 + dist_scaled*dist_scaled*dist_scaled);
// *torque = water_torque(distance, ca, sa, ca_rel, sa_rel, ck_rel, sk_rel);
// *torque = (0.5*sin(angle) + 0.5*sin(2.0*angle) - 0.45*sin(3.0*angle))/(1.0e-12 + dist_scaled*dist_scaled*dist_scaled);
*torque = water_force(distance, ca, sa, ca_rel, sa_rel, ck_rel, sk_rel, ff);
force[0] += ff[0];
force[1] += ff[1];
// printf("force = (%.3lg, %.3lg)\n", ff[0], ff[1]);
break;
}
case (I_VICSEK):
{
if (dist_scaled > 1.0) *torque = 0.0;
else if (twrapx||twrapy) *torque = sin(-particle[k].angle - particle[i].angle);
else *torque = sin(particle[k].angle - particle[i].angle);
break;
}
case (I_VICSEK_REPULSIVE):
{
if (dist_scaled > 1.0) *torque = 0.0;
else if (twrapx||twrapy) *torque = sin(-particle[k].angle - particle[i].angle);
else *torque = sin(particle[k].angle - particle[i].angle);
break;
}
case (I_VICSEK_SPEED):
{
if (dist_scaled > 1.0) *torque = 0.0;
else if (twrapx||twrapy) *torque = sin(-particle[k].angle - particle[i].angle);
else *torque = sin(particle[k].angle - particle[i].angle);
break;
}
case (I_VICSEK_SHARK):
{
if (dist_scaled > 10.0) *torque = 0.0;
else if (particle[k].type == particle[i].type) /* fish adjusting direction */
{
if (twrapx||twrapy) *torque = sin(-particle[k].angle - particle[i].angle);
else *torque = sin(particle[k].angle - particle[i].angle);
}
else if (particle[k].type == 2) /* fish fleeing a shark */
{
alpha = argument(ca,sa);
particle[i].angle = alpha + PI;
*torque = 0.0;
}
else /* shark tracking fish */
{
*torque = cos(particle[k].angle)*sa - sin(particle[k].angle)*ca;
}
break;
}
case (I_SEGMENT):
{
/* Do nothing, torque already computed */
break;
}
case (I_SEGMENT_CHARGED):
{
/* Do nothing, torque already computed */
break;
}
case (I_POLYGON):
{
/* Do nothing, torque already computed */
break;
}
case (I_POLYGON_ALIGN):
{
spin_f = particle[i].spin_freq;
if (twrapx||twrapy)
*torque += sin(spin_f*(-particle[k].angle - particle[i].angle))/(1.0e-8 + dist_scaled*dist_scaled);
else
{
if (NPOLY%2 == 0)
*torque += sin(spin_f*(particle[k].angle - particle[i].angle))/(1.0e-8 + dist_scaled*dist_scaled);
else
*torque -= sin(spin_f*(particle[k].angle - particle[i].angle))/(1.0e-8 + dist_scaled*dist_scaled);
}
break;
}
default:
{
spin_f = particle[i].spin_freq;
if (twrapx||twrapy) *torque = sin(spin_f*(-particle[k].angle - particle[i].angle))/(1.0e-8 + dist_scaled*dist_scaled);
else
*torque = sin(spin_f*(particle[k].angle - particle[i].angle))/(1.0e-8 + dist_scaled*dist_scaled);
}
}
if (particle[i].type == particle[k].type)
{
if (particle[i].type == 0) *torque *= KTORQUE;
else *torque *= KTORQUE_B;
}
else *torque *= KTORQUE_DIFF;
}
else *torque = 0.0;
if ((distance < NBH_DIST_FACTOR*particle[i].radius)&&(k != i)) return(1);
// if ((distance < NBH_DIST_FACTOR*particle[i].radius)) return(1);
else return(0);
}
int compute_repelling_force(int i, int j, double force[2], double *torque, t_particle* particle, double krepel)
/* compute repelling force of neighbour #j on particle #i */
/* returns 1 if distance between particles is smaller than NBH_DIST_FACTOR*MU */
{
double distance, ca, sa, cj, sj, ca_rel, sa_rel, f[2], ff[2], torque1, ck, sk, ck_rel, sk_rel;
static double distmin = 10.0*((XMAX - XMIN)/HASHX + (YMAX - YMIN)/HASHY);
int interact, k;
if (BOUNDARY_COND == BC_GENUS_TWO) distmin *= 2.0;
k = particle[i].hashneighbour[j];
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
/* for monitoring purposes */
// if (distance > distmin)
// {
// printf("i = %i, hashcell %i, j = %i, hashcell %i\n", i, particle[i].hashcell, k, particle[k].hashcell);
// printf("X = (%.3lg, %.3lg)\n", particle[i].xc, particle[i].yc);
// printf("Y = (%.3lg, %.3lg) d = %.3lg\n", particle[k].xc, particle[k].yc, distance);
// }
if ((distance == 0.0)||(i == k))
{
force[0] = 0.0;
force[1] = 0.0;
*torque = 0.0;
return(1);
}
else if (distance > REPEL_RADIUS*particle[i].radius)
{
force[0] = 0.0;
force[1] = 0.0;
*torque = 0.0;
return(0);
}
else
{
/* to avoid numerical problems, assign minimal value to distance */
if (distance < 0.1*particle[i].radius) distance = 0.1*particle[i].radius;
ca = (particle[i].deltax[j])/distance;
sa = (particle[i].deltay[j])/distance;
/* compute relative angle in case particles can rotate */
if (ROTATION)
{
cj = cos(particle[j].angle);
sj = sin(particle[j].angle);
ca_rel = ca*cj + sa*sj;
sa_rel = sa*cj - ca*sj;
}
else
{
ca_rel = ca;
sa_rel = sa;
}
interact = compute_particle_interaction(i, k, f, torque, particle, distance, krepel, ca, sa, ca_rel, sa_rel);
if (SYMMETRIZE_FORCE)
{
torque1 = *torque;
// compute_particle_interaction(k, i, ff, torque, particle, distance, krepel, ca, sa, ca_rel, sa_rel);
ck = cos(particle[j].angle);
sk = sin(particle[j].angle);
ck_rel = ca*ck + sa*sk;
sk_rel = sa*ck - ca*sk;
compute_particle_interaction(k, i, ff, torque, particle, distance, krepel, -ca, -sa, -ck_rel, -sk_rel);
force[0] = 0.5*(f[0] - ff[0]);
force[1] = 0.5*(f[1] - ff[1]);
*torque = 0.5*(torque1 - *torque);
// *torque = 0.5*(*torque + torque1);
}
else
{
force[0] = f[0];
force[1] = f[1];
}
// printf("force = (%.3lg, %.3lg), torque = %.3lg\n", f[0], f[1], *torque);
return(interact);
}
}
int resample_particle(int n, int maxtrials, t_particle particle[NMAXCIRCLES])
/* resample y coordinate of particle n, returns 1 if no collision is created */
{
double x, y, dist, dmin = 10.0;
int i, j, closeby = 0, success = 0, trials = 0;
while ((!success)&&(trials < maxtrials))
{
success = 1;
x = particle[n].xc - MU*(double)rand()/RAND_MAX;
y = 0.95*(BCYMIN + (BCYMAX - BCYMIN)*(double)rand()/RAND_MAX);
i = 0;
while ((success)&&(i<ncircles))
{
if ((i!=n)&&(particle[i].active))
{
// dist = module2(x - particle[i].xc, y - particle[i].yc);
for (j=-1; j<2; j++)
{
dist = module2(x - particle[i].xc - (double)j*(BCXMAX - BCXMIN), y - particle[i].yc);
if (dist < dmin) dmin = dist;
}
if (dmin < SAFETY_FACTOR*MU) success = 0;
}
i++;
}
trials++;
// printf("Trial no %i - (%.3lg, %.3lg)\t", trials, x, y);
}
if (success)
{
printf("\nTrial %i succesful\n", trials);
printf("Moving particle %i from (%.3lg, %.3lg) to (%.3lg, %.3lg)\n\n", n, particle[n].xc, particle[n].yc, x, y);
particle[n].xc = x;
particle[n].yc = y;
particle[n].vx = V_INITIAL*gaussian();
particle[n].vy = V_INITIAL*gaussian();
// particle[n].vy = V_INITIAL*(double)rand()/RAND_MAX;
return(1);
}
else
{
printf("\nCannot move particle %i\n\n", n);
return(0);
}
}
void print_partners(int i, t_particle particle[NMAXCIRCLES])
/* print partner list and properties, for debugging */
{
int p;
if (particle[i].active)
{
// printf("Particle %i, type %i, charge %.3lg\n", i, particle[i].type, particle[i].charge);
fprintf(lj_log, "Particle %i, type %i, charge %.3lg\n", i, particle[i].type, particle[i].charge);
// printf("(x, y) = (%.3lg, %.3lg), radius = %.3lg\n", particle[i].xc, particle[i].yc, particle[i].radius);
printf("%i partners: ", particle[i].npartners);
fprintf(lj_log, "%i partners: ", particle[i].npartners);
for (p=0; p<particle[i].npartners; p++)
{
printf("%i ", particle[i].partner[p]);
fprintf(lj_log, "%i ", particle[i].partner[p]);
}
printf("\n\n");
fprintf(lj_log, "\n\n");
}
}
void add_particle_inpair(int i, int nlist[NMAXPARTNERS], double angle0, int pairing_type, int npartners, int newtype, int rtype, double newr, double newmass, double newcharge, int narms, t_particle particle[NMAXCIRCLES])
/* add new particles in list nlist to old particle i, for paired particles */
{
int n, k, l, p, p1, q, counter, oldtype, closeby = 0, different = 1, armlen, arm, kplus, kminus, kpplus, kmminus;
short int no_change = 0;
double angle, dist, oldr, oldmass_inv, oldcharge, x, y, alpha, beta, beta2, r;
oldtype = particle[i].type;
oldr = particle[i].radius;
oldmass_inv = particle[i].mass_inv;
oldcharge = particle[i].charge;
if (pairing_type == POLY_SOAP_NMIX)
{
if ((double)rand()/RAND_MAX < THIRD_TYPE_PROPORTION) no_change = 1;
}
armlen = npartners/narms;
if (rtype == 0) rtype = 3 + rand()%4;
particle[i].npartners = npartners;
particle[i].p0 = i;
particle[i].p1 = nlist[0];
/* shift center of polymer for long chains */
if ((pairing_type == POLY_SOAP_B)||(pairing_type == POLY_SOAP_N)||(pairing_type == POLY_SOAP_NMIX)||(pairing_type == POLY_PLUSMINUS))
{
dist = 0.5*PAIR_DRATIO*oldr*(double)(npartners);
particle[i].xc -= dist*cos(angle);
particle[i].yc -= dist*cos(angle);
}
/* set some common values for POLY_SEG_POLYGON pairing */
else if (pairing_type == POLY_SEG_POLYGON)
{
// alpha = PI/(double)(npartners+1);
alpha = PI/(double)npartners;
r = MU/tan(alpha);
particle[i].angle = 0.0;
// particle[i].radius *= 0.75;
}
if (pairing_type == POLY_PLUSMINUS)
{
particle[i].type = newtype;
particle[i].radius = newr;
}
if (pairing_type == POLY_DNA_ALT) particle[i].angle = angle0;
/* randomize sign of charge */
if ((pairing_type == POLY_STAR_CHARGED)||(pairing_type == POLY_POLYGON))
if (rand()%2 == 1) newcharge *= -1.0;
for (k=0; k<npartners; k++)
{
n = nlist[k];
particle[n].type = newtype;
particle[n].thermostat = 1;
particle[n].charge = newcharge;
particle[n].active = 1;
particle[n].cluster = particle[i].cluster;
particle[n].p0 = i;
particle[n].p1 = nlist[0];
/* set first partner */
/* TODO; adapt mol_angle to other pairing types? */
// particle[i].mol_angle = 1;
if ((pairing_type == POLY_SOAP_B)||(pairing_type == POLY_SOAP_N)||(pairing_type == POLY_SOAP_NMIX)||(pairing_type == POLY_PLUSMINUS))
{
particle[i].npartners = 1;
particle[i].partner[0] = nlist[0];
}
else if ((pairing_type == POLY_HYDRA)||(pairing_type == POLY_HYDRA_RIGID))
{
particle[i].radius = newr;
particle[i].npartners = narms;
for (l=0; l<narms; l++) particle[i].partner[l] = nlist[l*armlen];
// particle[i].mol_angle = narms;
}
else particle[i].partner[k] = n;
// particle[k].mol_angle = particle[i].mol_angle;
// printf("Particle %i mol_angle = %i\n", i, particle[k].mol_angle);
/* compute positions of new particles */
switch (pairing_type) {
case (POLY_STAR_CHARGED):
{
particle[i].radius = 2.0*MU;
angle = angle0 + DPI*(double)k/(double)npartners;
dist = (oldr + newr)*PAIR_DRATIO;
particle[n].radius = newr;
particle[n].mass_inv = 1.0/newmass;
if (k%2 == 1) particle[n].charge *= -1.0;
break;
}
case (POLY_POLYGON):
{
particle[i].radius = 2.0*MU;
particle[n].mass_inv = 1.0/newmass;
if (k < npartners/2)
{
angle = angle0 + DPI*(double)(2*k+1)/(double)npartners;
dist = (oldr + newr)*PAIR_DRATIO*cos(DPI/(double)npartners)*1.2;
particle[n].radius = newr*0.75;
particle[n].charge = 0.0;
}
else
{
angle = angle0 + DPI*(double)(2*k)/(double)npartners;
dist = (oldr + newr)*PAIR_DRATIO;
particle[n].radius = newr;
if (k%2 == 1) particle[n].charge *= -1.0;
}
break;
}
case (POLY_KITE):
{
particle[i].radius = 1.25*MU*sin(PI/5.0);
particle[i].charge = 0.0;
particle[n].mass_inv = 1.0/newmass;
switch (k){
case (0):
{
angle = PI;
dist = 0.5*MU;
particle[n].radius = 0.4*MU;
particle[n].charge = 0.0;
break;
}
case (1):
{
angle = 0.0;
dist = 2.0*MU*cos(DPI/5.0);
particle[n].radius = 0.3*MU;
break;
}
case (2):
{
angle = DPI/5.0;
dist = MU;
particle[n].radius = 0.3*MU;
particle[n].charge *= -1.0;
break;
}
case (3):
{
angle = PI;
dist = MU;
particle[n].radius = 0.3*MU;
break;
}
case (4):
{
angle = -DPI/5.0;
dist = MU;
particle[n].radius = 0.3*MU;
particle[n].charge *= -1.0;
break;
}
}
break;
}
case (POLY_DART):
{
particle[i].radius = 0.3*MU;
particle[i].charge = -newcharge;
particle[n].mass_inv = 1.0/newmass;
switch (k){
case (0):
{
angle = 3.0*PI/10.0;
dist = MU*sin(PI/5.0);
particle[n].radius = 0.3*MU;
particle[n].charge = 0.0;
break;
}
case (1):
{
angle = -3.0*PI/10.0;
dist = MU*sin(PI/5.0);
particle[n].radius = 0.3*MU;
particle[n].charge = 0.0;
break;
}
case (2):
{
angle = 0.0;
dist = MU;
particle[n].radius = 0.3*MU;
particle[n].charge *= -1.0;
break;
}
case (3):
{
angle = 3.0*PI/5.0;
dist = MU;
particle[n].radius = 0.3*MU;
break;
}
case (4):
{
angle = -3.0*PI/5.0;
dist = MU;
particle[n].radius = 0.3*MU;
break;
}
}
break;
}
case (POLY_SEG_POLYGON):
{
dist = r;
angle = (double)(2*k)*alpha;
particle[n].angle = angle + PID;
particle[n].radius = MU;
particle[n].charge = 0.0;
fprintf(lj_log, "k = %i, angle = %.3lg, orientation = %.3lg\n", k, angle, particle[n].angle);
break;
}
case (POLY_WATER):
{
angle = angle0 + (double)(k+1)*PARTNER_ANGLE*PI/180.0;
dist = oldr + newr;
particle[n].radius = newr;
particle[n].mass_inv = 1.0/newmass;
break;
}
case (POLY_SOAP):
{
if (k%2 == 0) angle = angle0;
else angle = angle0 + PI;
dist = 2.0*PAIR_DRATIO*oldr*(double)(k/2+1);
particle[i].charge = 0.0;
if (k==npartners-1)
{
particle[n].charge = oldcharge;
particle[n].type = newtype;
}
else
{
particle[n].charge = 0.0;
particle[n].type = oldtype;
}
if (k == npartners-1) particle[n].radius = newr;
else particle[n].radius = oldr;
particle[n].mass_inv = oldmass_inv;
break;
}
case (POLY_SOAP_B):
{
angle = angle0;
dist = 2.0*PAIR_DRATIO*oldr*(double)(k+1);
particle[i].charge = 0.0;
if (k==npartners-1)
{
particle[n].charge = oldcharge;
particle[n].type = newtype;
}
else
{
particle[n].charge = 0.0;
particle[n].type = oldtype;
}
if (k == npartners-1) particle[n].radius = newr;
else particle[n].radius = oldr;
particle[n].mass_inv = oldmass_inv;
break;
}
case (POLY_SOAP_N):
{
angle = angle0;
dist = 2.0*PAIR_DRATIO*oldr*(double)(k+1);
particle[i].charge = 0.0;
if (k==npartners-1)
{
particle[n].charge = oldcharge;
particle[n].type = newtype;
dist += 2.0*PAIR_DRATIO*oldr;
}
else if (k==npartners-2)
{
particle[n].charge = -oldcharge;
particle[n].type = newtype;
dist += PAIR_DRATIO*oldr;
}
else
{
particle[n].charge = 0.0;
particle[n].type = oldtype;
}
if ((k == npartners-1)||(k == npartners-2)) particle[n].radius = newr;
else particle[n].radius = oldr;
particle[n].mass_inv = oldmass_inv;
break;
}
case (POLY_SOAP_NMIX):
{
angle = angle0;
dist = 2.0*PAIR_DRATIO*oldr*(double)(k+1);
particle[i].charge = 0.0;
if (no_change) /* only modify ends with probability 1/2 */
{
particle[n].charge = 0.0;
particle[n].type = oldtype + 3;
particle[n].radius = oldr;
particle[i].charge = 0.0;
particle[i].type = oldtype + 3;
particle[i].radius = oldr;
}
else
{
if (k==npartners-1)
{
particle[n].charge = oldcharge;
particle[n].type = newtype;
dist += 2.0*PAIR_DRATIO*oldr;
}
else if (k==npartners-2)
{
particle[n].charge = -oldcharge;
particle[n].type = newtype;
dist += PAIR_DRATIO*oldr;
}
else
{
particle[n].charge = 0.0;
particle[n].type = oldtype;
}
if ((k == npartners-1)||(k == npartners-2)) particle[n].radius = newr;
else particle[n].radius = oldr;
}
particle[n].mass_inv = oldmass_inv;
break;
}
case (POLY_PLUSMINUS):
{
angle = angle0;
dist = 2.0*PAIR_DRATIO*oldr*(double)(k+1);
if (k==npartners-1)
{
particle[n].charge = oldcharge;
particle[n].type = newtype;
}
else
{
particle[n].charge = 0.0;
particle[n].type = oldtype;
}
if (k == npartners-1) particle[n].radius = newr;
else particle[n].radius = oldr;
particle[n].mass_inv = oldmass_inv;
break;
}
case (POLY_HYDRA):
{
arm = k/armlen;
p = k%armlen;
angle = angle0 + DPI*(double)arm/(double)narms;
dist = PAIR_DRATIO*(newr + oldr + 2.0*oldr*(double)p);
if (p == armlen-1)
{
particle[n].charge = newcharge;
if ((ALTERNATE_POLY_CHARGE)||(arm%2 == 1)) particle[n].charge *= -1.0;
particle[n].type = newtype;
particle[n].radius = newr;
particle[n].mass_inv = 1.0/newmass;
}
else
{
particle[n].charge = 0.0;
particle[n].type = oldtype;
particle[n].radius = oldr;
particle[n].mass_inv = oldmass_inv;
}
break;
}
case (POLY_HYDRA_RIGID): /* same as POLY_HYDRA */
{
arm = k/armlen;
p = k%armlen;
angle = angle0 + DPI*(double)arm/(double)narms;
dist = PAIR_DRATIO*(newr + oldr + 2.0*oldr*(double)p);
if (p == armlen-1)
{
particle[n].charge = newcharge;
if ((ALTERNATE_POLY_CHARGE)&&(arm%2 == 0)) particle[n].charge *= -1.0;
particle[n].type = newtype;
particle[n].radius = newr;
particle[n].mass_inv = 1.0/newmass;
}
else
{
particle[n].charge = 0.0;
particle[n].type = oldtype;
particle[n].radius = oldr;
particle[n].mass_inv = oldmass_inv;
}
break;
}
case (POLY_DNA):
{
angle = angle0;
dist = PAIR_DRATIO*(newr + oldr);
particle[n].radius = newr;
particle[n].mass_inv = 1.0/newmass;
particle[n].type = 0;
switch (k) {
case (0):
{
angle -= PID;
particle[n].type = 2;
break;
}
case (1):
{
angle += PID;
particle[n].type = 2;
break;
}
default:
{
dist += (double)(k-2)*2.0*PAIR_DRATIO*newr;
if (k == npartners - 1) particle[n].type = 3 + rand()%4;
}
}
break;
}
case (POLY_DNA_ALT):
{
angle = angle0;
dist = PAIR_DRATIO*(newr + oldr);
particle[n].radius = newr;
particle[n].mass_inv = 1.0/newmass;
particle[n].type = 0;
particle[n].angle = angle0;
switch (k) {
case (0):
{
angle -= PID;
break;
}
case (1):
{
angle -= PID;
dist += 2.0*PAIR_DRATIO*newr;
particle[n].type = 1;
break;
}
case (2):
{
angle += PID;
break;
}
case (3):
{
angle += PID;
dist += 2.0*PAIR_DRATIO*newr;
particle[n].type = 2;
break;
}
default:
{
dist += (double)(k-4)*2.0*PAIR_DRATIO*newr;
if (k == npartners - 1) particle[n].type = 3 + rand()%4;
}
}
break;
}
case (POLY_DNA_DOUBLE):
{
angle = angle0;
dist = PAIR_DRATIO*(newr + oldr);
particle[n].radius = newr;
particle[n].mass_inv = 1.0/newmass;
particle[n].type = 0;
particle[n].angle = angle0;
beta = atan(newr/(dist + 2.0*PAIR_DRATIO*newr));
beta2 = atan(1.5/((double)(NPARTNERS_DNA-8)*2.0*PAIR_DRATIO));
switch (k) {
case (0):
{
angle -= PID;
break;
}
case (1):
{
angle -= (PID + DNA_RIGIDITY*beta);
dist += 2.0*PAIR_DRATIO*newr;
particle[n].type = 1;
// particle[n].type = 2;
break;
}
case (2):
{
angle -= (PID - DNA_RIGIDITY*beta);
dist += 2.0*PAIR_DRATIO*newr;
particle[n].type = 1;
// particle[n].type = 2;
break;
}
case (3):
{
angle += PID;
break;
}
case (4):
{
angle += PID + DNA_RIGIDITY*beta;
dist += 2.0*PAIR_DRATIO*newr;
particle[n].type = 2;
break;
}
case (5):
{
angle += PID - DNA_RIGIDITY*beta;
dist += 2.0*PAIR_DRATIO*newr;
particle[n].type = 2;
break;
}
case (NPARTNERS_DNA-2):
{
dist += (double)(NPARTNERS_DNA-8)*2.0*PAIR_DRATIO*newr;
angle += 0.5*beta2;
particle[n].type = rtype;
break;
}
case (NPARTNERS_DNA-1):
{
dist += (double)(NPARTNERS_DNA-8)*2.0*PAIR_DRATIO*newr;
angle -= 0.5*beta2;
particle[n].type = rtype;
break;
}
default:
{
dist += (double)(k-6)*2.0*PAIR_DRATIO*newr;
}
}
break;
}
case (POLY_DNA_FLEX):
{
angle = angle0;
dist = PAIR_DRATIO*(newr + oldr);
particle[n].radius = newr;
particle[n].mass_inv = 1.0/newmass;
particle[n].type = 0;
particle[n].angle = angle0;
beta = atan(newr/(dist + 2.0*PAIR_DRATIO*newr));
beta2 = atan(1.5/((double)(NPARTNERS_DNA-6)*2.0*PAIR_DRATIO));
switch (k) {
case (0):
{
angle -= PID;
break;
}
case (1):
{
angle -= PID;
dist += 2.0*PAIR_DRATIO*newr;
particle[n].type = 1;
break;
}
case (2):
{
angle += PID;
break;
}
case (3):
{
angle += PID;
dist += 2.0*PAIR_DRATIO*newr;
particle[n].type = 2;
break;
}
case (NPARTNERS_DNA-2):
{
dist += (double)(NPARTNERS_DNA-6)*2.0*PAIR_DRATIO*newr;
angle += 0.5*beta2;
particle[n].type = rtype;
break;
}
case (NPARTNERS_DNA-1):
{
dist += (double)(NPARTNERS_DNA-6)*2.0*PAIR_DRATIO*newr;
angle -= 0.5*beta2;
particle[n].type = rtype;
break;
}
default:
{
dist += (double)(k-4)*2.0*PAIR_DRATIO*newr;
}
}
break;
}
default:
{
angle = angle0 + DPI*(double)k/(double)npartners;
dist = oldr + newr;
particle[n].radius = newr;
particle[n].mass_inv = 1.0/newmass;
// particle[n].partner_eqd[0] = (MU + MU_B)*PAIR_DRATIO;
// particle[i].partner_eqd[k] = (MU + MU_B)*PAIR_DRATIO;
}
}
particle[n].xc = particle[i].xc + dist*cos(angle);
particle[n].yc = particle[i].yc + dist*sin(angle);
// printf("Distance %.3lg, (xi,yi) = (%.3lg, %.3lg), (xn,yn) = (%.3lg, %.3lg)\n",
// dist, particle[i].xc, particle[i].yc, particle[n].xc, particle[n].yc);
/* adjust list of partners */
switch (pairing_type) {
case (POLY_STAR):
{
particle[n].npartners = 1;
particle[n].partner[0] = i;
break;
}
case (POLY_STAR_CHARGED):
{
particle[n].npartners = 3;
particle[n].partner[0] = i;
if (k == 0) particle[n].partner[1] = nlist[npartners-1];
else particle[n].partner[1] = nlist[k-1];
if (k == npartners-1) particle[n].partner[2] = nlist[0];
else particle[n].partner[2] = nlist[k+1];
break;
}
case (POLY_POLYGON):
{
particle[n].npartners = npartners;
particle[n].partner[0] = i;
p = 0;
p1 = 1;
while (p < npartners)
{
q = nlist[p];
if (q != n)
{
particle[n].partner[p1] = q;
p1++;
}
p++;
}
particle[n].npartners = p1;
break;
}
case (POLY_KITE):
{
particle[n].npartners = npartners;
particle[n].partner[0] = i;
p = 0;
p1 = 1;
while (p < npartners)
{
q = nlist[p];
if (q != n)
{
particle[n].partner[p1] = q;
p1++;
}
p++;
}
particle[n].npartners = p1;
break;
}
case (POLY_SEG_POLYGON):
{
particle[n].npartners = 3;
particle[n].partner[0] = i;
if (k == 0) particle[n].partner[1] = nlist[npartners-1];
else particle[n].partner[1] = nlist[k-1];
if (k == npartners-1) particle[n].partner[2] = nlist[0];
else particle[n].partner[2] = nlist[k+1];
break;
}
case (POLY_SOAP_B):
{
if (k==npartners-1)
{
particle[n].npartners = 1;
particle[n].partner[0] = nlist[npartners-2];
}
else if (k==0)
{
particle[n].npartners = 2;
particle[n].partner[0] = i;
particle[n].partner[1] = nlist[1];
}
else
{
particle[n].npartners = 2;
particle[n].partner[0] = nlist[k-1];
particle[n].partner[1] = nlist[k+1];
}
break;
}
case (POLY_SOAP_N):
{
if (k==npartners-1)
{
particle[n].npartners = 1;
particle[n].partner[0] = nlist[npartners-2];
}
else if (k==0)
{
particle[n].npartners = 2;
particle[n].partner[0] = i;
particle[n].partner[1] = nlist[1];
}
else
{
particle[n].npartners = 2;
particle[n].partner[0] = nlist[k-1];
particle[n].partner[1] = nlist[k+1];
}
break;
}
case (POLY_SOAP_NMIX):
{
if (k==npartners-1)
{
particle[n].npartners = 1;
particle[n].partner[0] = nlist[npartners-2];
}
else if (k==0)
{
particle[n].npartners = 2;
particle[n].partner[0] = i;
particle[n].partner[1] = nlist[1];
}
else
{
particle[n].npartners = 2;
particle[n].partner[0] = nlist[k-1];
particle[n].partner[1] = nlist[k+1];
}
break;
}
case (POLY_PLUSMINUS):
{
if (k==npartners-1)
{
particle[n].npartners = 1;
particle[n].partner[0] = nlist[npartners-2];
}
else if (k==0)
{
particle[n].npartners = 2;
particle[n].partner[0] = i;
particle[n].partner[1] = nlist[1];
}
else
{
particle[n].npartners = 2;
particle[n].partner[0] = nlist[k-1];
particle[n].partner[1] = nlist[k+1];
}
break;
}
case (POLY_HYDRA):
{
p = k%armlen;
if (p == armlen-1)
{
particle[n].npartners = 1;
particle[n].partner[0] = nlist[k-1];
}
else if (p == 0)
{
particle[n].npartners = 2;
particle[n].partner[0] = i;
particle[n].partner[1] = nlist[k+1];
}
else
{
particle[n].npartners = 2;
particle[n].partner[0] = nlist[k-1];
particle[n].partner[1] = nlist[k+1];
}
break;
}
case (POLY_HYDRA_RIGID):
{
p = k%armlen;
if (p == armlen-1)
{
particle[n].npartners = 4;
particle[n].partner[0] = nlist[k-1];
particle[n].partner[1] = i;
particle[n].partner[2] = nlist[(k+armlen)%NPARTNERS];
q = k-armlen;
if (q < 0) q += NPARTNERS;
particle[n].partner[3] = nlist[q];
}
else if (p == 0)
{
particle[n].npartners = 4;
particle[n].partner[0] = i;
particle[n].partner[1] = nlist[k+1];
particle[n].partner[2] = nlist[(k+armlen)%NPARTNERS];
q = k-armlen;
if (q < 0) q += NPARTNERS;
particle[n].partner[3] = nlist[q];
}
else
{
particle[n].npartners = 2;
particle[n].partner[0] = nlist[k-1];
particle[n].partner[1] = nlist[k+1];
}
break;
}
default:
{
particle[n].npartners = npartners;
particle[n].partner[0] = i;
counter = 1;
for (l=0; l<npartners; l++) if (l != k)
{
particle[n].partner[counter] = nlist[l];
counter++;
}
}
}
}
/* adjust equilibrium distances */
if ((pairing_type == POLY_ALL))
{
for (l=0; l<particle[i].npartners; l++)
particle[i].partner_eqd[l] = (oldr + newr)*PAIR_DRATIO;
for (k=0; k<npartners; k++)
{
n = nlist[k];
for (l=0; l<particle[n].npartners; l++)
particle[n].partner_eqd[l] = (oldr + newr)*PAIR_DRATIO;
}
}
else
{
for (l=0; l<particle[i].npartners; l++)
{
p = particle[i].partner[l];
dist = module2(particle[i].xc - particle[p].xc, particle[i].yc - particle[p].yc);
particle[i].partner_eqd[l] = dist;
particle[i].partner_eqa[l] = particle[p].angle - particle[i].angle;
}
for (k=0; k<npartners; k++)
{
n = nlist[k];
for (l=0; l<particle[n].npartners; l++)
{
p = particle[n].partner[l];
dist = module2(particle[n].xc - particle[p].xc, particle[n].yc - particle[p].yc);
particle[n].partner_eqd[l] = dist;
particle[n].partner_eqa[l] = particle[p].angle - particle[n].angle;
}
}
}
/* set molecule numbers */
particle[i].molecule = i;
for (k=0; k<npartners; k++)
{
n = particle[i].partner[k];
particle[n].molecule = i;
particle[n].added = particle[i].added;
particle[n].coulomb = particle[i].coulomb;
particle[n].reactive = particle[i].reactive;
// printf("i = %i, added = %i, coulomb = %i\t nb = %i, added = %i, coulomb = %i\n", i, particle[i].added, particle[i].coulomb, n, particle[n].added, particle[n].coulomb);
}
/* test for presence of other molecules that are too close */
if (DEACIVATE_CLOSE_PAIRS)
{
closeby = 0;
for (k=0; k<NMAXCIRCLES; k++) if (particle[k].active)
{
different = (k!=i);
for (l=0; l<npartners; l++) different *= (k!=nlist[l]);
if (different) for (l=0; l<npartners; l++)
{
n = nlist[l];
for (p=-1; p<2; p++) for (q=-1; q<2; q++)
{
x = particle[k].xc + p*(BCXMAX - BCXMIN);
y = particle[k].yc + q*(BCYMAX - BCYMIN);
dist = module2(x - particle[n].xc, y - particle[n].yc);
closeby += (dist < PAIR_SAFETY_FACTOR*(particle[l].radius + particle[k].radius));
}
}
}
if (closeby > 0)
{
printf("Deactivating particle cluster %i\n", i);
particle[i].active = 0;
for (l=0; l<npartners; l++) particle[nlist[l]].active = 0;
}
}
}
void update_single_molecule_data(int mol, t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES])
/* update connection data for a single molecule */
{
int np, p, pp, nq, q, qq, molq, npartners = 0, new, connection;
// molecule[mol].npartners = 0;
printf("Resetting partner list of molecule %i\n", mol);
fprintf(lj_log, "[update_single_molecule_data] Resetting partner list of molecule %i\n", mol);
fprintf(lj_log, "[update_single_molecule_data] Before reset, molecule %i has %i partners: ", mol, molecule[mol].npartners);
for (p=0; p<molecule[mol].npartners; p++)
{
printf("%i(%i) ", molecule[mol].partner[p], molecule[mol].connection_type[p]);
fprintf(lj_log, "%i(%i) ", molecule[mol].partner[p], molecule[mol].connection_type[p]);
}
printf("\n");
fprintf(lj_log, "\n");
np = molecule[mol].nparticles;
for (p=0; p<np; p++)
{
pp = molecule[mol].particle[p];
nq = particle[pp].npartners;
for (q=0; q<nq; q++)
{
qq = particle[pp].partner[q];
molq = particle[qq].molecule;
if (molq != mol)
{
new = 1;
fprintf(lj_log, "Testing molecule %i\n", molq);
/* test if connection has already been found */
for (connection = 0; connection < npartners; connection++)
if (molecule[mol].partner[connection] == molq) new = 0;
if (new)
{
molecule[mol].partner[npartners] = molq;
molecule[mol].connection_type[npartners] = particle[pp].type;
npartners++;
fprintf(lj_log, "Added molecule %i(%i) as partner %i\n", molq, particle[pp].type, npartners);
}
else fprintf(lj_log, "Molecule %i not added\n", molq);
}
}
}
molecule[mol].npartners = npartners;
printf("Molecule %i has %i partners: ", mol, npartners);
fprintf(lj_log, "[update_single_molecule_data] After reset, molecule %i has %i partners: ", mol, npartners);
for (p=0; p<npartners; p++)
{
printf("%i(%i) ", molecule[mol].partner[p], molecule[mol].connection_type[p]);
fprintf(lj_log, "%i(%i) ", molecule[mol].partner[p], molecule[mol].connection_type[p]);
}
printf("\n");
fprintf(lj_log, "\n");
}
void init_molecule_data(t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES])
/* initialize date in molecule structure */
{
int i, m, np;
printf("Initializing molecule structure\n");
#pragma omp parallel for private(m)
for (m=0; m<NMAXCIRCLES; m++)
{
molecule[m].nparticles = 0;
molecule[m].npartners = 0;
molecule[m].added = 0;
}
// printf("1\n");
for (i=0; i<ncircles; i++)
{
// printf("i = %i\n", i);
m = particle[i].molecule;
if (m + 1 > nmolecules) nmolecules = m + 1;
np = molecule[m].nparticles;
// printf("np = %i\n", np);
if (np < NPARTNERS+1)
{
molecule[m].particle[np] = i;
molecule[m].nparticles++;
}
molecule[m].added = particle[i].added;
}
printf("Found %i molecules\n", nmolecules);
fprintf(lj_log, "Found %i molecules\n", nmolecules);
/* for debugging */
for (m=0; m<nmolecules; m++)
{
printf("Molecule %i has %i particles: \n", m, molecule[m].nparticles);
fprintf(lj_log, "Molecule %i has %i particles: \n", m, molecule[m].nparticles);
for (i=0; i<molecule[m].nparticles; i++)
{
printf(" %i-%i |" , molecule[m].particle[i], particle[molecule[m].particle[i]].molecule);
fprintf(lj_log, " %i-%i |" , molecule[m].particle[i], particle[molecule[m].particle[i]].molecule);
}
printf("\n");
fprintf(lj_log, "\n");
printf("Molecule %i.added = %i\n", m, molecule[m].added);
}
}
void init_particle_pairs(t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES])
/* initialize data structure for paired particles */
{
int i, k, l, n, p, q, counter, nlist[NMAXPARTNERS], rtype = 0, newrtype;
double angle, dist;
if (ncircles*NMAXPARTNERS > NMAXCIRCLES)
{
printf("Error: NMAXCIRCLES is too small\n");
exit(1);
}
nmolecules = ncircles;
for (i=0; i<ncircles; i++)
{
if ((particle[i].active)&&(particle[i].type == 0))
{
if (RANDOMIZE_ANGLE) angle = DPI*(double)rand()/(double)RAND_MAX;
else if ((RD_INITIAL_COND == IC_DNA_POLYMERASE)||(RD_INITIAL_COND == IC_DNA_POLYMERASE_REC))
{
if (i%NGRIDY == NGRIDY-2)
{
angle = PID;
rtype = 3 + rand()%4;
}
else if (i%NGRIDY == NGRIDY-1)
{
angle = -PID;
// printf("old type = %i\n", rtype);
switch (rtype) {
case (3):
{
newrtype = 4;
break;
}
case (4):
{
newrtype = 3;
break;
}
case (5):
{
newrtype = 6;
break;
}
case (6):
{
newrtype = 5;
break;
}
}
// printf("new type = %i\n", newrtype);
rtype = newrtype;
}
printf("i = %i, type = %i\n", i, rtype);
}
else angle = 0.0;
for (k=0; k<NPARTNERS; k++) nlist[k] = ncircles*(k+1) + i;
if (PAIR_TYPEB_PARTICLES) add_particle_inpair(i, nlist, angle, PAIRING_TYPE, NPARTNERS, 2, rtype, MU_C, PARTICLE_MASS_C, CHARGE_C, NARMS, particle);
else add_particle_inpair(i, nlist, angle, PAIRING_TYPE, NPARTNERS, 2, rtype, MU_B, PARTICLE_MASS_B, CHARGE_B, NARMS, particle);
}
}
ncircles += ncircles*NPARTNERS;
if (PAIR_TYPEB_PARTICLES)
{
for (i=0; i<ncircles; i++)
{
if ((particle[i].active)&&(particle[i].type == 1))
{
if (RANDOMIZE_ANGLE) angle = DPI*(double)rand()/(double)RAND_MAX;
else angle = 0.0;
for (k=0; k<NPARTNERS_B; k++) nlist[k] = ncircles*(k+1) + i;
add_particle_inpair(i, nlist, angle, PAIRING_TYPE_B, NPARTNERS_B, 3, rtype, MU_D, PARTICLE_MASS_D, CHARGE_D, NARMS_B, particle);
}
}
ncircles += ncircles*NPARTNERS;
}
init_molecule_data(particle, molecule);
printf("Done\n");
/* find first two partner numbers, for P_MOL_ANGLE color scheme */
// for (i=0; i<ncircles; i++)
// {
// p = i;
// for (k=0; k<particle[i].npartners; k++)
// if (particle[i].partner[k] < p) p = particle[i].partner[k];
// particle[i].p0 = p;
// particle[i].p1 = particle[p].partner[0];
// for (k=0; k<particle[i].npartners; k++)
// {
// q = particle[i].partner[k];
// if (q > p)
// {
// particle[q].p0 = p;
// particle[q].p1 = particle[p].partner[0];
// }
// }
// }
printf("ncircles = %i\n", ncircles);
for (i=0; i<ncircles; i++) print_partners(i, particle);
}
int add_particle(double x, double y, double vx, double vy, double mass, short int type, t_particle particle[NMAXCIRCLES])
{
int i, k, l, n, closeby = 0, nlist[NMAXPARTNERS];
double dist, angle;
/* test distance to other particles */
for (i=0; i<ncircles; i++)
{
dist = module2(x - particle[i].xc, y - particle[i].yc);
if ((particle[i].active)&&(dist < SAFETY_FACTOR*MU)) closeby = 1;
}
if ((closeby)||(ncircles >= NMAXCIRCLES))
{
printf("Cannot add particle at (%.3lg, %.3lg)\n", x, y);
return(0);
}
else
{
i = ncircles;
particle[i].type = type;
particle[i].xc = x;
particle[i].yc = y;
particle[i].radius = MU;
// particle[i].radius = MU*sqrt(mass);
particle[i].active = 1;
particle[i].neighb = 0;
particle[i].diff_neighb = 0;
particle[i].thermostat = 1;
particle[i].charge = CHARGE;
particle[i].energy = 0.0;
particle[i].emean = 0.0;
particle[i].dirmean = 0.0;
if (RANDOM_RADIUS) particle[i].radius = particle[i].radius*(RANDOM_RADIUS_MIN + RANDOM_RADIUS_RANGE*((double)rand()/RAND_MAX));
particle[i].mass_inv = 1.0/mass;
if (particle[i].type == 0) particle[i].inertia_moment_inv = 1.0/PARTICLE_INERTIA_MOMENT;
else particle[i].inertia_moment_inv = 1.0/PARTICLE_INERTIA_MOMENT;
if ((RANDOM_RADIUS)&&(ADAPT_MASS_TO_RADIUS > 0.0))
particle[i].mass_inv *= 1.0/(1.0 + pow(particle[i].radius/MU, ADAPT_MASS_TO_RADIUS));
if ((RANDOM_RADIUS)&&(ADAPT_DAMPING_TO_RADIUS > 0.0))
particle[i].damping = 1.0 + ADAPT_DAMPING_FACTOR*pow(particle[i].radius/MU, ADAPT_DAMPING_TO_RADIUS);
particle[i].vx = vx;
particle[i].vy = vy;
particle[i].energy = (particle[i].vx*particle[i].vx + particle[i].vy*particle[i].vy)*particle[i].mass_inv;
particle[i].angle = DPI*(double)rand()/RAND_MAX;
particle[i].omega = OMEGA_INITIAL*gaussian();
// printf("Particle[%i].omega = %.4lg\n", i, particle[i].omega);
// if (particle[i].type == 1)
// {
// particle[i].interaction = INTERACTION_B;
// particle[i].eq_dist = EQUILIBRIUM_DIST_B;
// particle[i].spin_range = SPIN_RANGE_B;
// particle[i].spin_freq = SPIN_INTER_FREQUENCY_B;
// }
if ((PLOT == P_INITIAL_POS)||(PLOT_B == P_INITIAL_POS))
{
switch (INITIAL_POS_TYPE) {
case (IP_X):
{
particle[i].color_hue = 360.0*(particle[i].xc - INITXMIN)/(INITXMAX - INITXMIN);
break;
}
case (IP_Y):
{
particle[i].color_hue = 360.0*(particle[i].yc - INITYMIN)/(INITYMAX - INITYMIN);
break;
}
}
}
else if ((PLOT == P_NUMBER)||(PLOT_B == P_NUMBER))
particle[i].color_hue = 360.0*(double)(i%N_PARTICLE_COLORS)/(double)N_PARTICLE_COLORS;
if ((PAIR_PARTICLES)&&(type == 0))
{
angle = DPI*(double)rand()/(double)RAND_MAX;
for (k=0; k<NPARTNERS; k++) nlist[k] = ncircles + k + 1;
if (PAIR_TYPEB_PARTICLES) add_particle_inpair(i, nlist, angle, PAIRING_TYPE, NPARTNERS, 2, 0, MU_C, PARTICLE_MASS_C, CHARGE_C, NARMS, particle);
else add_particle_inpair(ncircles, nlist, angle, PAIRING_TYPE, NPARTNERS, 2, 0, MU_B, PARTICLE_MASS_B, CHARGE_B, NARMS, particle);
ncircles += NPARTNERS+1;
}
else ncircles++;
printf("Added particle at (%.3lg, %.3lg)\n", x, y);
printf("Number of particles: %i\n", ncircles);
return(1);
}
}
void compute_entropy(t_particle particle[NMAXCIRCLES], double entropy[2])
{
int i, nleft1 = 0, nleft2 = 0;
double p1, p2, x;
static int first = 1, ntot1 = 0, ntot2 = 0;
static double log2;
if (first)
{
log2 = log(2.0);
for (i=0; i<ncircles; i++) if (particle[i].type == 0) ntot1++;
else ntot2++;
first = 0;
}
for (i=0; i<ncircles; i++)
{
if (POSITION_Y_DEPENDENCE) x = particle[i].yc;
else x = particle[i].xc;
if (particle[i].type == 0)
{
if (x < 0.0) nleft1++;
}
else
{
if (x < 0.0) nleft2++;
}
}
p1 = (double)nleft1/(double)ntot1;
p2 = (double)nleft2/(double)ntot2;
printf("Type 1: nleft = %i, ntot = %i, p = %.3lg\n", nleft1, ntot1, p1);
printf("Type 2: nleft = %i, ntot = %i, p = %.3lg\n", nleft2, ntot2, p2);
if ((p1==0.0)||(p1==1.0)) entropy[0] = 0.0;
else entropy[0] = -(p1*log(p1) + (1.0-p1)*log(1.0-p1)/log2);
if ((p2==0.0)||(p2==1.0)) entropy[1] = 0.0;
else entropy[1] = -(p2*log(p2) + (1.0-p2)*log(1.0-p2)/log2);
}
void compute_particle_colors(t_particle particle, t_cluster cluster[NMAXCIRCLES], int plot, double rgb[3], double rgbx[3], double rgby[3], double *radius, int *width, t_particle other_particle[NMAXCIRCLES])
{
double ej, angle, hue, huex, huey, lum, x, y, ccluster;
int i, k, p, q, cl;
switch (plot) {
case (P_KINETIC):
{
ej = particle.energy;
if (ej > 0.0)
{
hue = ENERGY_HUE_MIN + (ENERGY_HUE_MAX - ENERGY_HUE_MIN)*ej/PARTICLE_EMAX;
if (hue > ENERGY_HUE_MIN) hue = ENERGY_HUE_MIN;
if (hue < ENERGY_HUE_MAX) hue = ENERGY_HUE_MAX;
}
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_NEIGHBOURS):
{
hue = neighbour_color(particle.neighb);
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_BONDS):
{
hue = neighbour_color(particle.neighb);
*radius = particle.radius;
*width = 1;
break;
}
case (P_ANGLE):
{
angle = particle.angle;
hue = angle*particle.spin_freq/DPI;
hue -= (double)((int)hue);
huex = (DPI - angle)*particle.spin_freq/DPI;
huex -= (double)((int)huex);
angle = PI - angle;
if (angle < 0.0) angle += DPI;
huey = angle*particle.spin_freq/DPI;
huey -= (double)((int)huey);
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*(hue);
huex = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*(huex);
huey = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*(huey);
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_TYPE):
{
hue = type_hue(particle.type);
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_DIRECTION):
{
hue = argument(particle.vx, particle.vy);
if (hue > DPI) hue -= DPI;
if (hue < 0.0) hue += DPI;
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*(hue)/DPI;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_DIRECT_ENERGY):
{
hue = argument(particle.vx, particle.vy);
if (hue > DPI) hue -= DPI;
if (hue < 0.0) hue += DPI;
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*(hue)/DPI;
if (particle.energy < 0.1*PARTICLE_EMAX) lum = 10.0*particle.energy/PARTICLE_EMAX;
else lum = 1.0;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_ANGULAR_SPEED):
{
hue = 160.0*(1.0 + tanh(SLOPE*particle.omega));
// printf("omega = %.3lg, hue = %.3lg\n", particle[j].omega, hue);
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_DIFF_NEIGHB):
{
hue = (double)(particle.diff_neighb+1)/(double)(particle.neighb+1);
// hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*hue;
// hue = 180.0*(1.0 + hue);
hue = 20.0 + 320.0*hue;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_THERMOSTAT):
{
if (particle.thermostat) hue = 30.0;
else hue = 270.0;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_INITIAL_POS):
{
hue = particle.color_hue;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_NUMBER):
{
hue = particle.color_hue;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_EMEAN):
{
ej = particle.emean;
if (ej > 0.0)
{
hue = ENERGY_HUE_MIN + (ENERGY_HUE_MAX - ENERGY_HUE_MIN)*ej/PARTICLE_EMAX;
if (hue > ENERGY_HUE_MIN) hue = ENERGY_HUE_MIN;
if (hue < ENERGY_HUE_MAX) hue = ENERGY_HUE_MAX;
}
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_EMEAN_DENSITY):
{
ej = particle.emean;
cl = particle.cluster;
ej *= PARTICLE_MASS/cluster[cl].mass;
if (ej > 0.0)
{
hue = ENERGY_HUE_MIN + (ENERGY_HUE_MAX - ENERGY_HUE_MIN)*ej/PARTICLE_EMAX;
if (hue > ENERGY_HUE_MIN) hue = ENERGY_HUE_MIN;
if (hue < ENERGY_HUE_MAX) hue = ENERGY_HUE_MAX;
}
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_LOG_EMEAN):
{
ej = particle.emean;
if (ej > 0.0)
{
ej = log(ej/PARTICLE_EMIN)/log(PARTICLE_EMAX/PARTICLE_EMIN);
if (ej < 0.0) ej = 0.0;
else if (ej > 1.0) ej = 1.0;
hue = ENERGY_HUE_MIN + (ENERGY_HUE_MAX - ENERGY_HUE_MIN)*ej;
// if (hue > ENERGY_HUE_MIN) hue = ENERGY_HUE_MIN;
// if (hue < ENERGY_HUE_MAX) hue = ENERGY_HUE_MAX;
}
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_DIRECT_EMEAN):
{
hue = particle.dirmean + COLOR_HUESHIFT*PI;
// printf("dirmean = %.3lg\n", particle.dirmean);
if (hue > DPI) hue -= DPI;
if (hue < 0.0) hue += DPI;
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*(hue)/DPI;
ej = particle.emean;
if (ej < 0.5*PARTICLE_EMAX) lum = 2.0*ej/PARTICLE_EMAX;
else lum = 1.0;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_NOPARTICLE):
{
hue = 0.0;
lum = 1.0;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_NPARTNERS):
{
hue = partner_color(particle.npartners);
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_CHARGE):
{
hue = (-tanh(0.5*particle.charge)+1.0)*180.0;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_MOL_ANGLE):
{
p = particle.p0;
q = particle.p1;
x = other_particle[q].xc - other_particle[p].xc;
y = other_particle[q].yc - other_particle[p].yc;
/* deal with periodic boundary conditions */
if (x > 0.5*(XMAX - XMIN)) x -= (XMAX - XMIN);
else if (x < 0.5*(XMIN - XMAX)) x += (XMAX - XMIN);
if (y > 0.5*(YMAX - YMIN)) y -= (YMAX - YMIN);
else if (y < 0.5*(YMIN - YMAX)) y += (YMAX - YMIN);
angle = argument(x, y)*MOL_ANGLE_FACTOR;
// printf("Particle p = %i, mol_angle = %i\n", p, particle.mol_angle);
// angle = argument(x, y)*(double)particle.mol_angle;
// angle = argument(x, y)*(double)(other_particle[particle.p0].npartners);
while (angle > DPI) angle -= DPI;
while (angle < 0.0) angle += DPI;
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*(angle)/DPI;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_CLUSTER):
{
// cluster = (double)(particle.cluster)/(double)(ncircles);
ccluster = (double)(particle.cluster_color)/(double)(ncircles);
ccluster -= (double)((int)ccluster);
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*ccluster;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_CLUSTER_SIZE):
{
// cluster = (double)(particle.cluster)/(double)(ncircles);
ccluster = 1.0 - 5.0/((double)particle.cluster_size + 4.0);
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*ccluster;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_CLUSTER_SELECTED):
{
cl = particle.cluster;
if (cluster[cl].selected) hue = COLOR_HUE_CLUSTER_SELECTED;
else hue = COLOR_HUE_CLUSTER_NOT_SELECTED;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_COLLISION):
{
hue = (double)particle.collision;
if (hue > 0.0) hue = atan(0.25*(0.03*hue + 1.0))/PID;
// {
// hue += 10.0;
// hue *= 1.0/(40.0 + hue);
// }
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*hue;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
case (P_RADIUS):
{
// hue = atan(5.0*(particle.radius/MU - 0.75))/PID;
hue = (particle.radius/MU - RANDOM_RADIUS_MIN)/RANDOM_RADIUS_RANGE;
// hue = 0.5*(hue + 1.0);
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*hue;
*radius = particle.radius;
*width = BOUNDARY_WIDTH;
break;
}
}
switch (plot) {
case (P_KINETIC):
{
// hsl_to_rgb_turbo(hue, 0.9, 0.5, rgb);
// hsl_to_rgb_turbo(hue, 0.9, 0.5, rgbx);
// hsl_to_rgb_turbo(hue, 0.9, 0.5, rgby);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_EKIN);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_EKIN);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_EKIN);
break;
}
case (P_BONDS):
{
hsl_to_rgb_turbo(hue, 0.9, 0.5, rgb);
hsl_to_rgb_turbo(hue, 0.9, 0.5, rgbx);
hsl_to_rgb_turbo(hue, 0.9, 0.5, rgby);
break;
}
case (P_DIRECTION):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_DIRECTION);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_DIRECTION);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_DIRECTION);
break;
}
case (P_ANGLE):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_ANGLE);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_ANGLE);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_ANGLE);
break;
}
case (P_DIRECT_ENERGY):
{
hsl_to_rgb_twilight(hue, 0.9, 0.5, rgb);
hsl_to_rgb_twilight(hue, 0.9, 0.5, rgbx);
hsl_to_rgb_twilight(hue, 0.9, 0.5, rgby);
for (i=0; i<3; i++)
{
rgb[i] *= lum;
rgbx[i] *= lum;
rgby[i] *= lum;
}
break;
}
case (P_DIFF_NEIGHB):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_DIFFNEIGH);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_DIFFNEIGH);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_DIFFNEIGH);
// hsl_to_rgb_twilight(hue, 0.9, 0.5, rgb);
// hsl_to_rgb_twilight(hue, 0.9, 0.5, rgbx);
// hsl_to_rgb_twilight(hue, 0.9, 0.5, rgby);
break;
}
case (P_INITIAL_POS):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_INITIAL_POS);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_INITIAL_POS);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_INITIAL_POS);
break;
}
case (P_EMEAN):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_EKIN);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_EKIN);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_EKIN);
break;
}
case (P_LOG_EMEAN):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_EKIN);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_EKIN);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_EKIN);
break;
}
case (P_DIRECT_EMEAN):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_DIRECTION);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_DIRECTION);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_DIRECTION);
for (i=0; i<3; i++)
{
rgb[i] *= lum;
rgbx[i] *= lum;
rgby[i] *= lum;
}
break;
}
case (P_CHARGE):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_CHARGE);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_CHARGE);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_CHARGE);
break;
}
case (P_MOL_ANGLE):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_ANGLE);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_ANGLE);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_ANGLE);
break;
}
case (P_CLUSTER):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_CLUSTER);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_CLUSTER);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_CLUSTER);
break;
}
case (P_CLUSTER_SIZE):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_CLUSTER_SIZE);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_CLUSTER_SIZE);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_CLUSTER_SIZE);
break;
}
case (P_CLUSTER_SELECTED):
{
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_CLUSTER_SELECTED);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgbx, COLOR_PALETTE_CLUSTER_SELECTED);
hsl_to_rgb_palette(hue, 0.9, 0.5, rgby, COLOR_PALETTE_CLUSTER_SELECTED);
break;
}
default:
{
hsl_to_rgb(hue, 0.9, 0.5, rgb);
hsl_to_rgb(hue, 0.9, 0.5, rgbx);
hsl_to_rgb(hue, 0.9, 0.5, rgby);
}
}
}
void set_segment_group_color(int group, double lum, double rgb[3])
{
switch (group) {
case (1):
{
hsl_to_rgb_palette(270.0, 0.9, 0.5, rgb, COLOR_PALETTE);
break;
}
case (2):
{
hsl_to_rgb_palette(90.0, 0.9, 0.5, rgb, COLOR_PALETTE);
break;
}
default:
{
rgb[0] = 1.0;
rgb[1] = 1.0;
rgb[2] = 1.0;
}
}
glColor3f(lum*rgb[0], lum*rgb[1], lum*rgb[2]);
}
void set_segment_pressure_color(double pressure, double lum, double rgb[3])
{
double hue;
// if (pressure < 0.0) pressure = 0.0;
hue = SEGMENT_HUE_MIN + (SEGMENT_HUE_MAX - SEGMENT_HUE_MIN)*pressure/SEGMENT_PMAX;
if (hue > SEGMENT_HUE_MIN) hue = SEGMENT_HUE_MIN;
else if (hue < SEGMENT_HUE_MAX) hue = SEGMENT_HUE_MAX;
// hsl_to_rgb_turbo(hue, 0.9, lum, rgb);
hsl_to_rgb_palette(hue, 0.9, lum, rgb, COLOR_PALETTE_PRESSURE);
glColor3f(rgb[0], rgb[1], rgb[2]);
}
void draw_altitude_lines()
{
int i, i1, i2;
double x, y;
glColor3f(0.5, 0.5, 0.5);
glLineWidth(1);
i1 = (int)(YMIN + ytrack) - 1.0;
i2 = (int)(YMAX + ytrack) + 1.0;
for (i = i1; i < i2; i++)
{
y = (double)i - ytrack;
draw_line(BCXMIN, y, XMAX - 1.8, y);
}
i1 = (int)(XMIN + xtrack) - 1.0;
i2 = (int)(XMAX - 1.8 + xtrack) + 1.0;
for (i = i1; i < i2; i++)
{
x = (double)i - xtrack;
if (x < XMAX - 1.8) draw_line(x, YMIN, x, YMAX);
}
}
void draw_one_triangle(t_particle particle, int same_table[9*HASHMAX], int p, int q, int nsame)
{
double x, y, dx, dy;
int k;
x = particle.xc + (double)p*(BCXMAX - BCXMIN);
y = particle.yc + (double)q*(BCYMAX - BCYMIN);
if (TRACK)
{
x -= xtrack;
y -= ytrack;
}
glBegin(GL_TRIANGLE_FAN);
glVertex2d(x, y);
for (k=0; k<nsame; k++)
{
dx = particle.deltax[same_table[k]];
dy = particle.deltay[same_table[k]];
if (module2(dx, dy) < particle.radius*NBH_DIST_FACTOR)
glVertex2d(x + dx, y + dy);
}
glEnd();
}
void draw_triangles(t_particle particle[NMAXCIRCLES], t_cluster cluster[NMAXCIRCLES], int plot)
/* fill triangles between neighboring particles */
{
int i, j, k, p, q, t0, tj, tmax, nsame = 0, same_table[9*HASHMAX], width;
double rgb[3], hue, dx, dy, x, y, radius, rgbx[3], rgby[3];
// printf("Number of nbs: ");
for (i=0; i<ncircles; i++) if (particle[i].active)
{
nsame = 0;
t0 = particle[i].type;
/* find neighbours of same type */
for (j=0; j<particle[i].hash_nneighb; j++)
{
k = particle[i].hashneighbour[j];
if ((k!=i)&&((plot != P_TYPE)||(particle[k].type == t0)))
{
same_table[nsame] = j;
nsame++;
}
}
/* draw the triangles */
if (nsame > 1)
{
if (plot == P_TYPE)
{
hue = type_hue(t0);
hsl_to_rgb(hue, 0.9, 0.3, rgb);
}
else
{
compute_particle_colors(particle[i], cluster, plot, rgb, rgbx, rgby, &radius, &width, particle);
}
glColor3f(rgb[0], rgb[1], rgb[2]);
if (PERIODIC_BC) for (p=-1; p<2; p++) for (q=-1; q<2; q++)
draw_one_triangle(particle[i], same_table, p, q, nsame);
else draw_one_triangle(particle[i], same_table, 0, 0, nsame);
}
}
printf("\n");
}
void draw_one_particle_links(t_particle particle)
/* draw links of one particle */
{
int i, j, k;
double x1, x2, y1, y2, length, linkcolor,periodx, periody, xt1, yt1, xt2, yt2;
glLineWidth(LINK_WIDTH);
// if (particle.active)
// {
// radius = particle[j].radius;
for (k = 0; k < particle.hash_nneighb; k++)
{
x1 = particle.xc;
if (CENTER_VIEW_ON_OBSTACLE) x1 -= xshift;
y1 = particle.yc;
x2 = x1 + particle.deltax[k];
y2 = y1 + particle.deltay[k];
length = module2(particle.deltax[k], particle.deltay[k])/particle.radius;
if (COLOR_BONDS)
{
if (length < 1.5) linkcolor = 1.0;
else linkcolor = 1.0 - 0.75*(length - 1.5)/(NBH_DIST_FACTOR - 1.5);
glColor3f(linkcolor, linkcolor, linkcolor);
}
if (length < 1.0*NBH_DIST_FACTOR) draw_line(x1, y1, x2, y2);
}
}
int draw_special_particle(t_particle particle, double xc1, double yc1, double radius, double angle, int nsides, double rgb[3], short int fill)
/* draw special particles shapes, for chemical reactions */
{
double x1, y1, x2, y2, omega, r;
int wsign, i, j;
switch(RD_REACTION)
{
case (CHEM_AAB):
{
if (particle.type == 2)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*0.7*radius*cos(particle.angle);
y1 = yc1 + (double)wsign*0.7*radius*sin(particle.angle);
if (fill) draw_colored_polygon(x1, y1, 0.7*radius, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 0.7*radius, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_ABC):
{
if (particle.type == 3)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*0.7*radius*cos(particle.angle);
y1 = yc1 + (double)wsign*0.7*radius*sin(particle.angle);
if (wsign == 1)
{
if (fill) draw_colored_polygon(x1, y1, 1.2*MU_B, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 1.2*MU_B, nsides, angle + APOLY*PID);
}
else
{
if (fill) draw_colored_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID);
}
}
return(0);
}
break;
}
case (CHEM_A2BC):
{
if (particle.type == 3)
{
draw_colored_polygon(xc1, yc1, 1.2*MU_B, nsides, angle + APOLY*PID, rgb);
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + 1.5*radius*cos(particle.angle + 0.6*(double)wsign*PI);
y1 = yc1 + 1.5*radius*sin(particle.angle + 0.6*(double)wsign*PI);
if (fill) draw_colored_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_CATALYSIS):
{
if (particle.type == 3)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*0.7*radius*cos(particle.angle);
y1 = yc1 + (double)wsign*0.7*radius*sin(particle.angle);
if (fill) draw_colored_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_AUTOCATALYSIS):
{
if (particle.type == 2)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*MU*0.7*cos(particle.angle);
y1 = yc1 + (double)wsign*MU*0.7*sin(particle.angle);
if (fill) draw_colored_polygon(x1, y1, MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_BAA):
{
if (particle.type == 2)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*1.2*radius*cos(particle.angle);
y1 = yc1 + (double)wsign*1.2*radius*sin(particle.angle);
if (fill) draw_colored_polygon(x1, y1, 0.9*radius, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 0.9*radius, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_AABAA):
{
if (particle.type == 2)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*0.7*radius*cos(particle.angle);
y1 = yc1 + (double)wsign*0.7*radius*sin(particle.angle);
if (fill) draw_colored_polygon(x1, y1, 0.9*radius, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 0.9*radius, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_POLYMER):
{
if (particle.type >= 3)
{
omega = DPI/(double)(particle.type - 2);
draw_colored_polygon(xc1, yc1, 1.2*MU_B, nsides, angle + APOLY*PID, rgb);
for (i=0; i<particle.type-2; i++)
{
x1 = xc1 + 1.5*MU_B*cos(particle.angle + (double)i*omega);
y1 = yc1 + 1.5*MU_B*sin(particle.angle + (double)i*omega);
if (fill) draw_colored_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_POLYMER_DISS):
{
if (particle.type >= 3)
{
omega = DPI/(double)(particle.type - 2);
draw_colored_polygon(xc1, yc1, 1.2*MU_B, nsides, angle + APOLY*PID, rgb);
for (i=0; i<particle.type-2; i++)
{
x1 = xc1 + 1.5*MU_B*cos(particle.angle + (double)i*omega);
y1 = yc1 + 1.5*MU_B*sin(particle.angle + (double)i*omega);
if (fill) draw_colored_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_POLYMER_STEP):
{
if (particle.type >= 2)
{
omega = DPI/(double)(particle.type - 1);
draw_colored_polygon(xc1, yc1, MU, nsides, angle + APOLY*PID, rgb);
for (i=0; i<particle.type-1; i++)
{
x1 = xc1 + 1.5*MU*cos(particle.angle + (double)i*omega);
y1 = yc1 + 1.5*MU*sin(particle.angle + (double)i*omega);
if (fill) draw_colored_polygon(x1, y1, MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_CATALYTIC_A2D):
{
if (particle.type == 3)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*MU*0.7*cos(particle.angle);
y1 = yc1 + (double)wsign*MU*0.7*sin(particle.angle);
if (wsign == -1) r = MU;
else r = MU_B;
if (fill) draw_colored_polygon(x1, y1, r, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, r, nsides, angle + APOLY*PID);
}
return(0);
}
else if (particle.type == 4)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*MU*0.7*cos(particle.angle);
y1 = yc1 + (double)wsign*MU*0.7*sin(particle.angle);
if (fill) draw_colored_polygon(x1, y1, MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_ABCAB):
{
if (particle.type == 3)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*0.7*radius*cos(particle.angle);
y1 = yc1 + (double)wsign*0.7*radius*sin(particle.angle);
if (wsign == 1)
{
if (fill) draw_colored_polygon(x1, y1, 1.2*MU_B, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 1.2*MU_B, nsides, angle + APOLY*PID);
}
else
{
if (fill) draw_colored_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID);
}
}
return(0);
}
break;
}
case (CHEM_ABCDABC):
{
if (particle.type == 3)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*0.7*radius*cos(particle.angle);
y1 = yc1 + (double)wsign*0.7*radius*sin(particle.angle);
if (wsign == 1)
{
if (fill) draw_colored_polygon(x1, y1, MU_B, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU_B, nsides, angle + APOLY*PID);
}
else
{
if (fill) draw_colored_polygon(x1, y1, MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU, nsides, angle + APOLY*PID);
}
}
return(0);
}
else if (particle.type == 4)
{
draw_colored_polygon(xc1, yc1, 1.2*MU_B, nsides, angle + APOLY*PID, rgb);
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + 0.7*radius*cos(particle.angle + 0.6*(double)wsign*PI);
y1 = yc1 + 0.7*radius*sin(particle.angle + 0.6*(double)wsign*PI);
if (fill) draw_colored_polygon(x1, y1, MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU, nsides, angle + APOLY*PID);
}
return(0);
}
break;
}
case (CHEM_BZ):
{
if ((particle.type >= 2)&&(particle.type <= 4))
{
omega = DPI/(double)(particle.type - 1);
if (fill) draw_colored_polygon(xc1, yc1, MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(xc1, yc1, MU, nsides, angle + APOLY*PID);
for (i=0; i<particle.type-1; i++)
{
x1 = xc1 + 1.5*MU*cos(particle.angle + (double)i*omega);
y1 = yc1 + 1.5*MU*sin(particle.angle + (double)i*omega);
if (fill) draw_colored_polygon(x1, y1, MU_B, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU_B, nsides, angle + APOLY*PID);
}
return(0);
}
else if (particle.type == 5)
{
if (fill) draw_colored_polygon(xc1, yc1, MU_B, 4, angle + APOLY*PID, rgb);
else draw_polygon(xc1, yc1, MU_B, 4, angle + APOLY*PID);
return(0);
}
else if (particle.type == 6)
{
if (fill) draw_colored_polygon(xc1, yc1, 1.5*MU_B, 6, angle + APOLY*PID, rgb);
else draw_polygon(xc1, yc1, 1.5*MU_B, 6, angle + APOLY*PID);
return(0);
}
else if (particle.type == 7)
{
for (i=-1; i<2; i+=2)
{
x1 = xc1 + (double)i*1.5*MU*cos(particle.angle);
y1 = yc1 + (double)i*1.5*MU*sin(particle.angle);
if (fill) draw_colored_polygon(x1, y1, MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU, nsides, angle + APOLY*PID);
for (j=-1; j<2; j++)
{
x2 = x1 + 1.5*MU*cos(particle.angle + (double)j*PID);
y2 = y1 + 1.5*MU*sin(particle.angle + (double)j*PID);
if (fill) draw_colored_polygon(x2, y2, MU_B, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x2, y2, MU_B, nsides, angle + APOLY*PID);
}
}
return(0);
}
else if (particle.type == 8)
{
x1 = xc1 + 1.5*MU*cos(particle.angle);
y1 = yc1 + 1.5*MU*sin(particle.angle);
if (fill) draw_colored_polygon(x1, y1, MU_B, 4, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU_B, 4, angle + APOLY*PID);
x1 = xc1 - 1.5*MU*cos(particle.angle);
y1 = yc1 - 1.5*MU*sin(particle.angle);
if (fill) draw_colored_polygon(x1, y1, MU_B, 4, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU_B, 4, angle + APOLY*PID);
return(0);
}
break;
}
case (CHEM_BRUSSELATOR):
{
if (particle.type == 4)
{
if (fill) draw_colored_polygon(xc1, yc1, MU_B, nsides, angle + APOLY*PID, rgb);
else draw_polygon(xc1, yc1, MU_B, nsides, angle + APOLY*PID);
x1 = xc1 + 1.2*MU_B*cos(particle.angle);
y1 = yc1 + 1.2*MU_B*sin(particle.angle);
if (fill) draw_colored_polygon(x1, y1, MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, MU, nsides, angle + APOLY*PID);
return(0);
}
break;
}
case (CHEM_ABDACBE):
{
if (particle.type == 4)
{
for (wsign = -1; wsign <= 1; wsign+=2)
{
x1 = xc1 + (double)wsign*0.7*radius*cos(particle.angle);
y1 = yc1 + (double)wsign*0.7*radius*sin(particle.angle);
if (wsign == 1)
{
if (fill) draw_colored_polygon(x1, y1, 1.2*MU_B, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 1.2*MU_B, nsides, angle + APOLY*PID);
}
else
{
if (fill) draw_colored_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID, rgb);
else draw_polygon(x1, y1, 1.2*MU, nsides, angle + APOLY*PID);
}
}
return(0);
}
break;
}
// case (CHEM_DNA_ENZYME):
// {
// if (particle.type == 7)
// {
// /* TODO */
// }
// return(0);
// break;
// }
}
return(1);
}
void draw_one_particle(t_particle particle, double xc, double yc, double radius, double angle, int nsides, double width, double rgb[3])
/* draw one of the particles */
{
double x1, x2, y1, y2, xc1, yc1, wangle, newradius = radius, pradius;
int wsign, cont = 1, draw = 1;
static double ca, sa;
static int first = 1;
if (first)
{
angle = APOLY*PID;
ca = cos(angle);
sa = sin(angle);
first = 0;
}
if (CENTER_VIEW_ON_OBSTACLE) xc1 = xc - xshift;
else xc1 = xc;
if (TRACK)
{
xc1 -= xtrack;
yc1 = yc - ytrack;
}
else yc1 = yc;
glColor3f(rgb[0], rgb[1], rgb[2]);
/* specific shapes for chemical reactions */
if (REACTION_DIFFUSION) cont = draw_special_particle(particle, xc1, yc1, radius, angle, nsides, rgb, 1);
if ((particle.interaction == I_LJ_QUADRUPOLE)||(particle.interaction == I_LJ_DIPOLE)||(particle.interaction == I_VICSEK)||(particle.interaction == I_VICSEK_REPULSIVE)||(particle.interaction == I_VICSEK_SPEED)||(particle.interaction == I_VICSEK_SHARK))
draw_colored_rhombus(xc1, yc1, radius, angle + APOLY*PID, rgb);
else if (particle.interaction == I_SEGMENT)
draw_colored_rotated_rect(xc1, yc1, particle.radius, 0.1*particle.radius, angle + APOLY*PID, rgb);
else if (particle.interaction == I_SEGMENT_CHARGED)
{
draw_colored_rotated_rect(xc1, yc1, particle.radius, 0.1*particle.radius, angle + APOLY*PID, rgb);
/* TODO: draw ends */
}
else if (cont)
{
if (nsides == NSEG) draw_colored_circle_precomp(xc1, yc1, radius, rgb);
else draw_colored_polygon(xc1, yc1, radius, nsides, angle + APOLY*PID, rgb);
}
/* draw crosses/bars on charged particles */
if (TWO_TYPES)
{
if ((DRAW_CROSS)&&(particle.charge > 0.0))
{
pradius = particle.radius;
if (ROTATION)
{
angle = angle + APOLY*PID;
ca = cos(angle);
sa = sin(angle);
}
glLineWidth(2);
glColor3f(1.0, 1.0, 1.0);
x1 = xc1 - pradius*ca;
y1 = yc1 - pradius*sa;
x2 = xc1 + pradius*ca;
y2 = yc1 + pradius*sa;
draw_line(x1, y1, x2, y2);
x1 = xc1 - pradius*sa;
y1 = yc1 + pradius*ca;
x2 = xc1 + pradius*sa;
y2 = yc1 - pradius*ca;
draw_line(x1, y1, x2, y2);
}
if ((DRAW_MINUS)&&(particle.charge < 0.0))
{
pradius = particle.radius;
if (ROTATION)
{
angle = angle + APOLY*PID;
ca = cos(angle);
sa = sin(angle);
}
glLineWidth(2);
glColor3f(1.0, 1.0, 1.0);
x1 = xc1 - pradius*ca;
y1 = yc1 - pradius*sa;
x2 = xc1 + pradius*ca;
y2 = yc1 + pradius*sa;
draw_line(x1, y1, x2, y2);
}
}
glLineWidth(width);
glColor3f(1.0, 1.0, 1.0);
if (REACTION_DIFFUSION) cont = draw_special_particle(particle, xc1, yc1, radius, angle, nsides, rgb, 0);
if ((particle.interaction == I_LJ_QUADRUPOLE)||(particle.interaction == I_LJ_DIPOLE)||(particle.interaction == I_VICSEK)||(particle.interaction == I_VICSEK_REPULSIVE)||(particle.interaction == I_VICSEK_SPEED)||(particle.interaction == I_VICSEK_SHARK))
draw_rhombus(xc1, yc1, radius, angle + APOLY*PID);
else if (particle.interaction == I_SEGMENT)
draw_rotated_rect(xc1, yc1, particle.radius, 0.1*particle.radius, angle + APOLY*PID);
else if (particle.interaction == I_SEGMENT_CHARGED)
{
draw_rotated_rect(xc1, yc1, particle.radius, 0.1*particle.radius, angle + APOLY*PID);
/* TODO: draw ends */
}
else if (cont)
{
if (nsides == NSEG) draw_circle_precomp(xc1, yc1, radius);
else draw_polygon(xc1, yc1, radius, nsides, angle + APOLY*PID);
}
if (particle.interaction == I_LJ_WATER) for (wsign = -1; wsign <= 1; wsign+=2)
{
wangle = particle.angle + (double)wsign*DPI/3.0;
x1 = xc1 + particle.radius*cos(wangle);
y1 = yc1 + particle.radius*sin(wangle);
draw_colored_polygon(x1, y1, 0.5*radius, nsides, angle + APOLY*PID, rgb);
glColor3f(1.0, 1.0, 1.0);
draw_polygon(x1, y1, 0.5*radius, nsides, angle + APOLY*PID);
}
// printf("Particle radius %.3f, pradius %.3f, mass %.3f\n", radius, particle.radius, 1.0/particle.mass_inv);
// sleep(1);
}
void draw_collisions(t_collision *collisions, int ncollisions)
/* draw discs where collisions happen */
{
int i, j;
double rgb[3], lum, x, y, x1, y1;
for (i=0; i<ncollisions; i++) if (collisions[i].time > 0)
{
lum = (double)collisions[i].time/(double)COLLISION_TIME;
if (collisions[i].color == 0.0) for (j=0; j<3; j++) rgb[j] = lum;
else hsl_to_rgb_palette(collisions[i].color, 0.9, lum, rgb, COLOR_PALETTE);
x = collisions[i].x;
y = collisions[i].y;
if (CENTER_VIEW_ON_OBSTACLE) x1 = x - xshift;
else x1 = x;
if (TRACK)
{
x1 -= xtrack;
y1 = y - ytrack;
}
else y1 = y;
draw_colored_polygon(x1, y1, COLLISION_RADIUS*MU, NSEG, 0.0, rgb);
collisions[i].time--;
}
}
void draw_trajectory(t_tracer trajectory[TRAJECTORY_LENGTH*N_TRACER_PARTICLES], int traj_position, int traj_length, t_particle *particle, t_cluster *cluster, int *tracer_n, int plot)
/* draw tracer particle trajectory */
{
int i, j, time, p, width;
double x1, x2, y1, y2, rgb[3], rgbx[3], rgby[3], radius, lum;
// blank();
glLineWidth(TRAJECTORY_WIDTH);
printf("drawing trajectory\n");
if (traj_length < TRAJECTORY_LENGTH*TRACER_STEPS)
for (i=0; i < traj_length-1; i++)
// for (i=traj_length-2; i >= 0; i--)
for (j=0; j<n_tracers; j++)
{
compute_particle_colors(particle[tracer_n[j]], cluster, plot, rgb, rgbx, rgby, &radius, &width, particle);
glColor3f(rgb[0], rgb[1], rgb[2]);
x1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].xc;
x2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].xc;
y1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].yc;
y2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].yc;
time = traj_length - i;
lum = 0.9 - TRACER_LUM_FACTOR*(double)time/(double)(TRAJECTORY_LENGTH*TRACER_STEPS);
if (lum < 0.0) lum = 0.0;
glColor3f(lum*rgb[0], lum*rgb[1], lum*rgb[2]);
if ((lum > 0.1)&&(module2(x2 - x1, y2 - y1) < 0.25*(YMAX - YMIN)))
draw_line(x1, y1, x2, y2);
}
else
{
// for (i = traj_length-2; i >= traj_position + 1; i--)
for (i = traj_position + 1; i < traj_length-1; i++)
for (j=0; j<n_tracers; j++)
{
compute_particle_colors(particle[tracer_n[j]], cluster, plot, rgb, rgbx, rgby, &radius, &width, particle);
glColor3f(rgb[0], rgb[1], rgb[2]);
x1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].xc;
x2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].xc;
y1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].yc;
y2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].yc;
time = traj_position + traj_length - i;
lum = 0.9 - TRACER_LUM_FACTOR*(double)time/(double)(TRAJECTORY_LENGTH*TRACER_STEPS);
if (lum < 0.0) lum = 0.0;
glColor3f(lum*rgb[0], lum*rgb[1], lum*rgb[2]);
if ((lum > 0.1)&&(module2(x2 - x1, y2 - y1) < 0.25*(YMAX - YMIN)))
draw_line(x1, y1, x2, y2);
}
for (i=0; i < traj_position-1; i++)
// for (i = traj_position-2; i >= 0; i--)
for (j=0; j<n_tracers; j++)
{
compute_particle_colors(particle[tracer_n[j]], cluster, plot, rgb, rgbx, rgby, &radius, &width, particle);
glColor3f(rgb[0], rgb[1], rgb[2]);
x1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].xc;
x2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].xc;
y1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].yc;
y2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].yc;
time = traj_position - i;
lum = 0.9 - TRACER_LUM_FACTOR*(double)time/(double)(TRAJECTORY_LENGTH*TRACER_STEPS);
if (lum < 0.0) lum = 0.0;
glColor3f(lum*rgb[0], lum*rgb[1], lum*rgb[2]);
if ((lum > 0.1)&&(module2(x2 - x1, y2 - y1) < 0.25*(YMAX - YMIN)))
draw_line(x1, y1, x2, y2);
}
}
}
void old_draw_trajectory(t_tracer trajectory[TRAJECTORY_LENGTH*N_TRACER_PARTICLES], int traj_position, int traj_length, t_particle *particle, t_cluster *cluster, int *tracer_n, int plot)
/* draw tracer particle trajectory */
{
int i, j, time, p, width;
double x1, x2, y1, y2, rgb[3], rgbx[3], rgby[3], radius, lum;
// blank();
glLineWidth(TRAJECTORY_WIDTH);
printf("drawing trajectory\n");
for (j=0; j<n_tracers; j++)
{
compute_particle_colors(particle[tracer_n[j]], cluster, plot, rgb, rgbx, rgby, &radius, &width, particle);
glColor3f(rgb[0], rgb[1], rgb[2]);
if (traj_length < TRAJECTORY_LENGTH*TRACER_STEPS)
// for (i=0; i < traj_length-1; i++)
for (i=traj_length-2; i >= 0; i--)
{
x1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].xc;
x2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].xc;
y1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].yc;
y2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].yc;
time = traj_length - i;
lum = 0.9 - TRACER_LUM_FACTOR*(double)time/(double)(TRAJECTORY_LENGTH*TRACER_STEPS);
if (lum < 0.0) lum = 0.0;
glColor3f(lum*rgb[0], lum*rgb[1], lum*rgb[2]);
if ((lum > 0.1)&&(module2(x2 - x1, y2 - y1) < 0.25*(YMAX - YMIN)))
draw_line(x1, y1, x2, y2);
// printf("tracer = %i, (x1, y1) = (%.3lg, %.3lg), (x2, y2) = (%.3lg, %.3lg)\n", j, x1, y1, x2, y2);
}
else
{
// for (i = traj_position + 1; i < traj_length-1; i++)
for (i = traj_length-2; i >= traj_position + 1; i--)
{
x1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].xc;
x2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].xc;
y1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].yc;
y2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].yc;
time = traj_position + traj_length - i;
lum = 0.9 - TRACER_LUM_FACTOR*(double)time/(double)(TRAJECTORY_LENGTH*TRACER_STEPS);
if (lum < 0.0) lum = 0.0;
glColor3f(lum*rgb[0], lum*rgb[1], lum*rgb[2]);
if ((lum > 0.1)&&(module2(x2 - x1, y2 - y1) < 0.25*(YMAX - YMIN)))
draw_line(x1, y1, x2, y2);
}
// for (i=0; i < traj_position-1; i++)
for (i = traj_position-2; i >= 0; i--)
{
x1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].xc;
x2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].xc;
y1 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i].yc;
y2 = trajectory[j*TRAJECTORY_LENGTH*TRACER_STEPS + i+1].yc;
time = traj_position - i;
lum = 0.9 - TRACER_LUM_FACTOR*(double)time/(double)(TRAJECTORY_LENGTH*TRACER_STEPS);
if (lum < 0.0) lum = 0.0;
glColor3f(lum*rgb[0], lum*rgb[1], lum*rgb[2]);
if ((lum > 0.1)&&(module2(x2 - x1, y2 - y1) < 0.25*(YMAX - YMIN)))
draw_line(x1, y1, x2, y2);
}
}
}
}
void color_background(t_particle particle[NMAXCIRCLES], t_obstacle obstacle[NMAXOBSTACLES], int bg_color, t_hashgrid hashgrid[HASHX*HASHY])
/* color background according to particle properties */
{
int i, j, k, n, p, q, m, nnb, number, avrg_fact, obs;
double rgb[3], hue, value, p1, p2, pp1, pp2, oldhue, valx, valy, lum;
static int first = 1, counter = 0;
p1 = 0.75;
p2 = 1.0 - p1;
pp1 = 0.95;
pp2 = 1.0 - pp1;
glBegin(GL_QUADS);
for (i=0; i<HASHX; i++)
for (j=0; j<HASHY; j++)
{
n = mhash(i, j);
if (first)
{
hashgrid[n].hue1 = 180.0;
hashgrid[n].hue2 = 180.0;
}
/* set two old values for option DOUBLE_MOVIE */
if (DOUBLE_MOVIE)
{
if (counter) oldhue = hashgrid[n].hue1;
else oldhue = hashgrid[n].hue2;
}
else oldhue = hashgrid[n].hue1;
switch (bg_color) {
case (BG_DENSITY):
{
nnb = hashgrid[n].nneighb;
number = 0;
for (q=0; q<nnb; q++)
{
m = hashgrid[n].neighbour[q];
number += hashgrid[m].number;
}
number += hashgrid[n].number;
// hue = 50.0*(double)hashgrid[n].number;
hue = 75.0*(double)number/(double)(nnb + 1);
hue = p1*oldhue + p2*hue;
rgb[0] = hue/360.0;
rgb[1] = hue/360.0;
rgb[2] = hue/360.0;
break;
}
case (BG_CHARGE):
{
avrg_fact = 3; /* weight of central cell in hashgrid average */
value = 0.0;
nnb = hashgrid[n].nneighb;
for (q=0; q<nnb; q++)
{
m = hashgrid[n].neighbour[q];
for (k=0; k<hashgrid[m].number; k++)
{
p = hashgrid[m].particles[k];
value += particle[p].charge;
}
}
/* hashcell n counts double */
for (k=0; k<hashgrid[n].number; k++)
{
p = hashgrid[n].particles[k];
value += (double)(avrg_fact-1)*particle[p].charge;
}
value *= 1.0/(double)(nnb + avrg_fact);
if (CHARGE_OBSTACLES) value += hashgrid[n].charge;
hue = (-tanh(0.5*value)+1.0)*180.0;
hue = p1*oldhue + p2*hue;
hsl_to_rgb_twilight(hue, 0.9, 0.5, rgb);
break;
}
case (BG_EKIN):
{
value = 0.0;
nnb = hashgrid[n].nneighb;
for (q=0; q<nnb; q++)
{
m = hashgrid[n].neighbour[q];
for (k=0; k<hashgrid[m].number; k++)
{
p = hashgrid[m].particles[k];
value += particle[p].energy;
}
}
/* hashcell n counts double */
for (k=0; k<hashgrid[n].number; k++)
{
p = hashgrid[n].particles[k];
value += particle[p].energy;
}
value *= 1.0/(double)(nnb + 1);
hue = ENERGY_HUE_MIN + (ENERGY_HUE_MAX - ENERGY_HUE_MIN)*value/PARTICLE_EMAX;
if (hue > ENERGY_HUE_MIN) hue = ENERGY_HUE_MIN;
if (hue < ENERGY_HUE_MAX) hue = ENERGY_HUE_MAX;
hue = p1*oldhue + p2*hue;
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_EKIN);
break;
}
case (BG_EOBSTACLES):
{
value = 0.0;
nnb = hashgrid[n].nneighb;
for (q=0; q<nnb; q++)
{
m = hashgrid[n].neighbour[q];
if (hashgrid[m].nobs) value += obstacle[hashgrid[m].obstacle].energy;
}
/* hashcell n counts four times */
if (hashgrid[n].nobs) value += 3.0*obstacle[hashgrid[n].obstacle].energy;
value *= 1.0/(double)(nnb + 4);
// if (hashgrid[n].nobs) value += obstacle[hashgrid[n].obstacle].energy;
hue = ENERGY_HUE_MIN + (ENERGY_HUE_MAX - ENERGY_HUE_MIN)*value/OBSTACLE_EMAX;
if (hue > ENERGY_HUE_MIN) hue = ENERGY_HUE_MIN;
if (hue < ENERGY_HUE_MAX) hue = ENERGY_HUE_MAX;
hue = p1*oldhue + p2*hue;
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_EKIN);
break;
}
case (BG_EKIN_OBSTACLES):
{
value = 0.0;
nnb = hashgrid[n].nneighb;
for (q=0; q<nnb; q++)
{
m = hashgrid[n].neighbour[q];
for (k=0; k<hashgrid[m].number; k++)
{
p = hashgrid[m].particles[k];
value += particle[p].energy;
}
}
/* hashcell n counts double */
for (k=0; k<hashgrid[n].number; k++)
{
p = hashgrid[n].particles[k];
value += particle[p].energy;
}
value *= 1.0/(double)(nnb + 1);
if (hashgrid[n].nobs) value += obstacle[hashgrid[n].obstacle].energy;
hue = ENERGY_HUE_MIN + (ENERGY_HUE_MAX - ENERGY_HUE_MIN)*value/OBSTACLE_EMAX;
if (hue > ENERGY_HUE_MIN) hue = ENERGY_HUE_MIN;
if (hue < ENERGY_HUE_MAX) hue = ENERGY_HUE_MAX;
hue = p1*oldhue + p2*hue;
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_EKIN);
break;
}
case (BG_DIR_OBSTACLES):
{
valx = 0.0;
valy = 0.0;
nnb = hashgrid[n].nneighb;
for (q=0; q<nnb; q++)
{
m = hashgrid[n].neighbour[q];
if (hashgrid[m].nobs)
{
valx += obstacle[hashgrid[m].obstacle].vx;
valy += obstacle[hashgrid[m].obstacle].vy;
}
}
/* hashcell n counts more */
if (hashgrid[n].nobs)
{
valx += 4.0*obstacle[hashgrid[n].obstacle].vx;
valy += 4.0*obstacle[hashgrid[n].obstacle].vy;
}
valx *= 1.0/(double)(nnb + 4);
valy *= 1.0/(double)(nnb + 4);
hue = argument(valx, valy);
if (hue > DPI) hue -= DPI;
if (hue < 0.0) hue += DPI;
hue = pp1*oldhue + pp2*hue;
lum = module2(valx, valy)/OBSTACLE_VMAX;
if (lum > 1.0) lum = 1.0;
hsl_to_rgb_palette(hue*360.0/DPI, 0.9, 0.5*lum, rgb, COLOR_PALETTE_DIRECTION);
break;
}
case (BG_POS_OBSTACLES):
{
valx = 0.0;
valy = 0.0;
nnb = hashgrid[n].nneighb;
// for (q=0; q<nnb; q++)
// {
// m = hashgrid[n].neighbour[q];
// if (hashgrid[m].nobs)
// {
// valx += obstacle[hashgrid[m].obstacle].xc;
// valy += obstacle[hashgrid[m].obstacle].yc;
// }
// }
/* hashcell n counts double */
if (hashgrid[n].nobs)
{
obs = hashgrid[n].obstacle;
valx += obstacle[obs].xc - obstacle[obs].xc0;
valy += obstacle[obs].yc - obstacle[obs].yc0;
}
// valx *= 1.0/(double)(nnb + 1);
// valy *= 1.0/(double)(nnb + 1);
hue = argument(valx, valy);
if (hue > DPI) hue -= DPI;
if (hue < 0.0) hue += DPI;
hue = pp1*oldhue + pp2*hue;
lum = module2(valx, valy);
if (lum > 1.0) lum = 1.0;
// lum = 1.0;
hsl_to_rgb_palette(hue*360.0/DPI, 0.9, 0.5*lum, rgb, COLOR_PALETTE_DIRECTION);
break;
}
case (BG_FORCE):
{
value = 0.0;
nnb = hashgrid[n].nneighb;
for (q=0; q<nnb; q++)
{
m = hashgrid[n].neighbour[q];
for (k=0; k<hashgrid[m].number; k++)
{
p = hashgrid[m].particles[k];
value += module2(particle[p].fx, particle[p].fy);
}
}
/* hashcell n counts double */
for (k=0; k<hashgrid[n].number; k++)
{
p = hashgrid[n].particles[k];
value += module2(particle[p].fx, particle[p].fy);
}
value *= BG_FORCE_SLOPE/(double)(nnb + 1);
hue = (1.0 - tanh(value))*360.0;
hue = pp1*oldhue + pp2*hue;
hsl_to_rgb_turbo(hue, 0.9, 0.5, rgb);
break;
}
}
if (DOUBLE_MOVIE)
{
if (counter) hashgrid[n].hue1 = hue;
else hashgrid[n].hue2 = hue;
}
else hashgrid[n].hue1 = hue;
glColor3f(rgb[0], rgb[1], rgb[2]);
glVertex2d(hashgrid[n].x1, hashgrid[n].y1);
glVertex2d(hashgrid[n].x2, hashgrid[n].y1);
glVertex2d(hashgrid[n].x2, hashgrid[n].y2);
glVertex2d(hashgrid[n].x1, hashgrid[n].y2);
}
glEnd();
first = 0;
counter = 1 - counter;
}
void draw_particles(t_particle particle[NMAXCIRCLES], t_cluster cluster[NMAXCIRCLES], int plot, double beta, t_collision *collisions, int ncollisions, int bg_color, t_hashgrid hashgrid[HASHX*HASHY], t_lj_parameters params)
{
int i, j, k, m, width, nnbg, nsides, cl, p, q;
double ej, hue, huex, huey, rgb[3], rgbx[3], rgby[3], radius, x1, y1, x2, y2, angle, ca, sa, length, linkcolor, sign = 1.0, angle1, signy = 1.0, periodx, periody, x, y, lum, logratio;
char message[100];
printf("Drawing particles\n");
// if (!TRACER_PARTICLE) blank();
if (plot == P_NOPARTICLE) blank();
// if ((COLOR_BACKGROUND)&&(bg_color > 0)) color_background(particle, bg_color, hashgrid);
// else
if ((!TRACER_PARTICLE)&&(!COLOR_BACKGROUND)&&(!DRAW_OBSTACLE_LINKS)&&(!FILL_OBSTACLE_TRIANGLES)) blank();
// printf("Drawing particles 1\n");
glColor3f(1.0, 1.0, 1.0);
/* show region of partial thermostat */
if (PARTIAL_THERMO_COUPLING)
{
switch (PARTIAL_THERMO_REGION) {
case (TH_INBOX):
{
if (INCREASE_BETA)
{
logratio = log(beta/BETA)/log(0.5*BETA_FACTOR);
if (logratio > 1.0) logratio = 1.0;
else if (logratio < 0.0) logratio = 0.0;
if (BETA_FACTOR > 1.0) hue = PARTICLE_HUE_MAX - (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*logratio;
else hue = PARTICLE_HUE_MIN - (PARTICLE_HUE_MIN - PARTICLE_HUE_MAX)*logratio;
}
else hue = 0.25*PARTICLE_HUE_MIN + 0.75*PARTICLE_HUE_MAX;
erase_area_hsl_turbo(0.0, YMIN, 2.0*PARTIAL_THERMO_WIDTH, PARTIAL_THERMO_HEIGHT*(YMAX - YMIN), hue, 0.9, 0.15);
break;
}
case(TH_LAYER):
{
hue = 0.75*PARTICLE_HUE_MIN + 0.25*PARTICLE_HUE_MAX;
erase_area_hsl_turbo(0.0, YMIN, XMAX, PARTIAL_THERMO_HEIGHT - YMIN, hue, 0.9, 0.15);
break;
}
case (TH_RING):
{
hue = 0.75*PARTICLE_HUE_MIN + 0.25*PARTICLE_HUE_MAX;
hsl_to_rgb_turbo(hue, 0.9, 0.15, rgb);
draw_colored_circle(0.0, 0.0, PARTIAL_THERMO_WIDTH, 180, rgb);
break;
}
case (TH_RING_EXPAND):
{
hue = 0.75*PARTICLE_HUE_MIN + 0.25*PARTICLE_HUE_MAX;
hsl_to_rgb_turbo(hue, 0.9, 0.15, rgb);
draw_colored_circle(0.0, 0.0, params.thermo_radius, 180, rgb);
break;
}
case(TH_INIT):
{
hue = 0.75*PARTICLE_HUE_MIN + 0.25*PARTICLE_HUE_MAX;
erase_rectangle_hsl_turbo(INITXMIN, INITYMIN, INITXMAX, INITYMAX, hue, 0.9, 0.15);
break;
}
case(TH_THERMO):
{
if (INCREASE_BETA)
{
logratio = log(beta/BETA)/log(0.5*BETA_FACTOR);
if (logratio > 1.0) logratio = 1.0;
else if (logratio < 0.0) logratio = 0.0;
if (BETA_FACTOR > 1.0) hue = PARTICLE_HUE_MAX - (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*logratio;
else hue = PARTICLE_HUE_MIN - (PARTICLE_HUE_MIN - PARTICLE_HUE_MAX)*logratio;
}
else hue = 0.25*PARTICLE_HUE_MIN + 0.75*PARTICLE_HUE_MAX;
erase_rectangle_hsl_turbo(THERMOXMIN, THERMOYMIN, THERMOXMAX, THERMOYMAX, hue, 0.9, 0.15);
break;
}
case (TH_CONE):
{
if (INCREASE_BETA)
{
logratio = log(beta/BETA)/log(0.5*BETA_FACTOR);
if (logratio > 1.0) logratio = 1.0;
else if (logratio < 0.0) logratio = 0.0;
if (BETA_FACTOR > 1.0) hue = PARTICLE_HUE_MAX - (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*logratio;
else hue = PARTICLE_HUE_MIN - (PARTICLE_HUE_MIN - PARTICLE_HUE_MAX)*logratio;
}
else hue = 0.25*PARTICLE_HUE_MIN + 0.75*PARTICLE_HUE_MAX;
draw_colored_triangle_turbo(0.05, -0.2, LAMBDA, LAMBDA, -LAMBDA, LAMBDA, hue, 0.9, 0.15);
draw_colored_triangle_turbo(0.05, -0.2, -LAMBDA, LAMBDA, -0.04, -0.2, hue, 0.9, 0.15);
break;
}
}
}
// printf("Drawing particles 2\n");
/* draw "altitude lines" */
if (ALTITUDE_LINES) draw_altitude_lines();
/* draw the bonds first */
if ((DRAW_BONDS)||(plot == P_BONDS))
{
glLineWidth(LINK_WIDTH);
for (j=0; j<ncircles; j++) if (particle[j].active) draw_one_particle_links(particle[j]);
}
/* fill triangles between particles */
if (FILL_TRIANGLES) draw_triangles(particle, cluster, plot);
/* draw collision discs */
if ((REACTION_DIFFUSION)&&(ncollisions > 0)) draw_collisions(collisions, ncollisions);
/* determine particle color and size */
for (j=0; j<ncircles; j++) if (particle[j].active)
{
compute_particle_colors(particle[j], cluster, plot, rgb, rgbx, rgby, &radius, &width, particle);
switch (particle[j].interaction) {
case (I_LJ_DIRECTIONAL):
{
nsides = 4;
break;
}
case (I_LJ_PENTA):
{
nsides = 5;
break;
}
case (I_LJ_QUADRUPOLE):
{
nsides = 4;
break;
}
case (I_LJ_WATER):
{
nsides = NSEG;
radius *= 0.75;
break;
}
case (I_COULOMB_PENTA):
{
nsides = 5;
break;
}
case (I_DNA_CHARGED):
{
if (particle[j].type == 7) nsides = 3;
else nsides = NSEG;
break;
}
case (I_SEGMENT):
{
nsides = 2;
break;
}
case (I_SEGMENT_CHARGED):
{
nsides = 2;
break;
}
case (I_POLYGON):
{
nsides = NPOLY;
break;
}
case (I_POLYGON_ALIGN):
{
nsides = NPOLY;
break;
}
default: nsides = NSEG;
}
angle = particle[j].angle + APOLY*DPI;
/* in case of periodic b.c., draw translates of particles */
if ((PERIODIC_BC)&&(plot != P_NOPARTICLE))
{
x1 = particle[j].xc;
y1 = particle[j].yc;
for (i=-1; i<2; i++)
for (k=-1; k<2; k++)
draw_one_particle(particle[j], x1 + (double)i*(BCXMAX - BCXMIN), y1 + (double)k*(BCYMAX - BCYMIN), radius, angle, nsides, width, rgb);
}
else if ((BOUNDARY_COND == BC_KLEIN)&&(plot != P_NOPARTICLE))
{
x1 = particle[j].xc;
y1 = particle[j].yc;
for (i=-2; i<3; i++)
{
if (vabs(i) == 1) sign = -1.0;
else sign = 1.0;
angle1 = angle*sign;
for (k=-1; k<2; k++)
draw_one_particle(particle[j], x1 + (double)i*(BCXMAX - BCXMIN), sign*(y1 + (double)k*(BCYMAX - BCYMIN)),
radius, angle1, nsides, width, rgb);
}
}
else if ((BOUNDARY_COND == BC_BOY)&&(plot != P_NOPARTICLE))
{
x1 = particle[j].xc;
y1 = particle[j].yc;
for (i=-1; i<2; i++) for (k=-1; k<2; k++)
{
if (vabs(i) == 1) sign = -1.0;
else sign = 1.0;
if (vabs(k) == 1) signy = -1.0;
else signy = 1.0;
if (signy == 1.0) angle1 = angle*sign;
else angle1 = PI - angle;
if (sign == -1.0) draw_one_particle(particle[j], signy*(x1 + (double)i*(BCXMAX - BCXMIN)),
sign*(y1 + (double)k*(BCYMAX - BCYMIN)), radius, angle1, nsides, width, rgbx);
else if (signy == -1.0) draw_one_particle(particle[j], signy*(x1 + (double)i*(BCXMAX - BCXMIN)),
sign*(y1 + (double)k*(BCYMAX - BCYMIN)), radius, angle1, nsides, width, rgby);
else draw_one_particle(particle[j], signy*(x1 + (double)i*(BCXMAX - BCXMIN)),
sign*(y1 + (double)k*(BCYMAX - BCYMIN)), radius, angle1, nsides, width, rgb);
}
}
else if ((BOUNDARY_COND == BC_GENUS_TWO)&&(plot != P_NOPARTICLE))
{
x1 = particle[j].xc;
y1 = particle[j].yc;
if (x1 < 0.0) periody = BCYMAX - BCYMIN;
else periody = 0.5*(BCYMAX - BCYMIN);
if (y1 < 0.0) periodx = BCXMAX - BCXMIN;
else periodx = 0.5*(BCXMAX - BCXMIN);
if ((x1 < 0.0)&&(y1 < 0.0))
for (i=-1; i<2; i++)
for (k=-1; k<2; k++)
{
x = x1 + (double)i*periodx;
y = y1 + (double)k*periody;
draw_one_particle(particle[j], x, y, radius, angle, nsides, width, rgb);
}
else if ((x1 < 0.0)&&(y1 >= 0.0))
for (i=-1; i<2; i++)
for (k=-1; k<2; k++)
{
x = x1 + (double)i*periodx;
y = y1 + (double)k*periody;
if (x < 1.2*particle[j].radius)
draw_one_particle(particle[j], x, y, radius, angle, nsides, width, rgb);
}
else if ((x1 >= 0.0)&&(y1 < 0.0))
for (i=-1; i<2; i++)
for (k=-1; k<2; k++)
{
x = x1 + (double)i*periodx;
y = y1 + (double)k*periody;
if (y < 1.2*particle[j].radius)
draw_one_particle(particle[j], x, y, radius, angle, nsides, width, rgb);
}
}
else if (plot != P_NOPARTICLE)
draw_one_particle(particle[j], particle[j].xc, particle[j].yc, radius, angle, nsides, width, rgb);
}
// /* draw spin vectors */
if ((DRAW_SPIN)||(DRAW_SPIN_B))
{
glLineWidth(width);
for (j=0; j<ncircles; j++)
if ((particle[j].active)&&(((DRAW_SPIN)&&(particle[j].type == 0))||((DRAW_SPIN_B)&&(particle[j].type == 1))))
{
// x1 = particle[j].xc - 2.0*MU*cos(particle[j].angle);
// y1 = particle[j].yc - 2.0*MU*sin(particle[j].angle);
x1 = particle[j].xc;
// if (CENTER_VIEW_ON_OBSTACLE) x1 -= xshift;
y1 = particle[j].yc;
x2 = particle[j].xc + 2.0*MU*cos(particle[j].angle);
// if (CENTER_VIEW_ON_OBSTACLE) x2 -= xshift;
y2 = particle[j].yc + 2.0*MU*sin(particle[j].angle);
draw_line(x1, y1, x2, y2);
}
}
/* draw links between particles in cluster */
if (DRAW_CLUSTER_LINKS)
{
glLineWidth(LINK_WIDTH);
for (j=0; j<ncircles; j++) if (particle[j].active)
{
cl = particle[j].cluster;
x1 = particle[j].xc;
y1 = particle[j].yc;
for (p=0; p<cluster[cl].nparticles; p++)
{
q = cluster[cl].particle[p];
x2 = particle[q].xc;
y2 = particle[q].yc;
draw_line(x1, y1, x2, y2);
}
}
}
}
void obstacle_hue(t_obstacle obstacle, double rgb[3])
/* compute obstacle color hue */
{
int k;
double etot, angle, hue, lum;
switch (OBSTACLE_COLOR) {
case (OC_ENERGY):
{
etot = obstacle.energy;
hue = ENERGY_HUE_MIN + (ENERGY_HUE_MAX - ENERGY_HUE_MIN)*etot/OBSTACLE_EMAX;
if (hue > ENERGY_HUE_MIN) hue = ENERGY_HUE_MIN;
if (hue < ENERGY_HUE_MAX) hue = ENERGY_HUE_MAX;
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_EKIN);
break;
}
case (OC_DIRECTION):
{
hue = argument(obstacle.vx, obstacle.vy);
if (hue < 0.0) hue += DPI;
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*(hue)/DPI;
hsl_to_rgb_palette(hue, 0.9, 0.5, rgb, COLOR_PALETTE_DIRECTION);
break;
}
case (OC_DIRECTION_ENERGY):
{
hue = argument(obstacle.vx, obstacle.vy);
etot = obstacle.energy;
if (hue < 0.0) hue += DPI;
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*(hue)/DPI;
lum = etot/OBSTACLE_EMAX;
if (lum > 0.5) lum = 0.5;
hsl_to_rgb_palette(hue, 0.9, lum, rgb, COLOR_PALETTE_DIRECTION);
break;
}
}
}
int area_to_rgb(t_obstacle obstacle[NMAXOBSTACLES], int i, int n1, int n2, double rgb[3])
/* computes rgb code of triangle according to area */
/* returns 1 if angle of triangle is less than PI/2 */
/* OLD VERSION */
{
int p, q, k, n, counter;
double area, angle1, angle2;
static int first;
static double mean_area;
if (first)
{
/* compute mean area of triangles */
if (FILL_OBSTACLE_TRIANGLES)
{
counter = 0;
mean_area = 0.0;
for (p = 0; p < nobstacles; p++)
{
n = obstacle[p].nneighb;
for (q = 0; q < n - 1; q++)
{
n1 = obstacle[p].neighb[q];
n2 = obstacle[p].neighb[q+1];
mean_area += vabs(triangle_area(obstacle[p].xc, obstacle[p].yc, obstacle[n1].xc, obstacle[n1].yc, obstacle[n2].xc, obstacle[n2].yc));
counter++;
}
n1 = obstacle[p].neighb[n-1];
n2 = obstacle[p].neighb[0];
mean_area += vabs(triangle_area(obstacle[p].xc, obstacle[p].yc, obstacle[n1].xc, obstacle[n1].yc, obstacle[n2].xc, obstacle[n2].yc));
counter++;
}
mean_area *= 1.0/(double)counter;
}
first = 0;
}
area = vabs(triangle_area(obstacle[i].xc, obstacle[i].yc, obstacle[n1].xc, obstacle[n1].yc, obstacle[n2].xc, obstacle[n2].yc));
area = OBSTACLE_AREA_SHADE_FACTOR*(area - mean_area);
if (area > 1.0) area = 1.0;
if (area < 0.0) area = 0.0;
for (k=0; k<3; k++) rgb[k] = area;
angle1 = argument(obstacle[n1].xc - obstacle[i].xc, obstacle[n1].yc - obstacle[i].yc);
angle2 = argument(obstacle[n2].xc - obstacle[i].xc, obstacle[n2].yc - obstacle[i].yc);
if (angle2 < angle1) angle2 += DPI;
return(angle2 - angle1 < 1.5*PID);
}
void old_draw_obstacle_triangles(t_obstacle obstacle[NMAXOBSTACLES])
/* draw the triangles between obstacles, for option FILL_OBSTACLE_TRIANGLES */
{
int i, j, k, n, n1, n2, neigh;
short int acute;
double rgb[3], angle1, angle2;
if (FILL_OBSTACLE_TRIANGLES) for (i = 0; i < nobstacles; i++)
{
n = obstacle[i].nneighb;
for (j = 0; j < n - 1; j++)
{
n1 = obstacle[i].neighb[j];
n2 = obstacle[i].neighb[j+1];
acute = area_to_rgb(obstacle, i, n1, n2, rgb);
if (acute) draw_colored_triangle(obstacle[i].xc, obstacle[i].yc, obstacle[n1].xc, obstacle[n1].yc, obstacle[n2].xc, obstacle[n2].yc, rgb);
}
n1 = obstacle[i].neighb[n-1];
n2 = obstacle[i].neighb[0];
acute = area_to_rgb(obstacle, i, n1, n2, rgb);
if (acute) draw_colored_triangle(obstacle[i].xc, obstacle[i].yc, obstacle[n1].xc, obstacle[n1].yc, obstacle[n2].xc, obstacle[n2].yc, rgb);
}
glColor3f(1.0, 1.0, 1.0);
for (i = 0; i < nobstacles; i++)
for (j = 0; j < obstacle[i].nneighb; j++)
{
neigh = obstacle[i].neighb[j];
draw_line(obstacle[i].xc, obstacle[i].yc, obstacle[neigh].xc, obstacle[neigh].yc);
}
}
void facet_area_to_rgb(t_obstacle obstacle[NMAXOBSTACLES], t_otriangle triangle[NMAX_TRIANGLES_PER_OBSTACLE*NMAXOBSTACLES], t_ofacet facet[NMAXOBSTACLES], int nfacet, double rgb[3])
/* computes rgb code of triangle according to area */
/* returns 1 if angle of triangle is less than PI/2 */
{
int p, q, k, n, counter;
double area, area0;
static int first;
static double mean_area;
if (first)
{
/* compute mean area of triangles */
if (FILL_OBSTACLE_TRIANGLES)
{
counter = 0;
mean_area = 0.0;
for (p = 0; p < n_otriangles; p++)
{
mean_area += otriangle_area(obstacle, triangle[p]);
counter++;
}
mean_area *= 1.0/(double)counter;
for (p = 0; p < n_ofacets; p++)
{
area0 = 0.0;
for (k = 0; k < facet[p].ntriangles; k++)
area0 += triangle[facet[p].triangle[k]].area0;
facet[p].area0 = area0/(double)facet[p].ntriangles;
}
}
first = 0;
}
area = 0.0;
for (k = 0; k < facet[nfacet].ntriangles; k++)
{
p = facet[nfacet].triangle[k];
area += otriangle_area(obstacle, triangle[p]);
}
area *= 1.0/(double)facet[nfacet].ntriangles;
area = OBSTACLE_AREA_SHADE_FACTOR*(area - facet[nfacet].area0);
if (area > 1.0) area = 1.0;
if (area < 0.0) area = 0.0;
for (k=0; k<3; k++) rgb[k] = area;
}
double triangle_area_to_rgb(t_obstacle obstacle[NMAXOBSTACLES], t_otriangle otriangle[NMAX_TRIANGLES_PER_OBSTACLE*NMAXOBSTACLES], int triangle, double rgb[3])
{
double area;
int k, p;
area = otriangle_area(obstacle, otriangle[triangle]);
area = 0.6 + OBSTACLE_AREA_SHADE_FACTOR*(area - otriangle[triangle].area0);
if (area > 0.9) area = 0.9;
if (area < 0.1) area = 0.1;
for (k=0; k<3; k++) rgb[k] = area;
return(area);
}
void draw_obstacle_triangles(t_obstacle obstacle[NMAXOBSTACLES],
t_otriangle otriangle[NMAX_TRIANGLES_PER_OBSTACLE*NMAXOBSTACLES],
t_ofacet ofacet[NMAXOBSTACLES])
/* draw the triangles between obstacles, for option FILL_OBSTACLE_TRIANGLES */
{
int i, j, k, n, n1, n2, neigh, nf, f, t, s1, s2, s3;
short int acute;
double rgb[3], pvect;
printf("drawing %i facets with %i triangles\n", n_ofacets, n_otriangles);
if (FILL_OBSTACLE_TRIANGLES)
{
/* determine acute angles */
for (t = 0; t < n_otriangles; t++)
{
s1 = otriangle[t].i[0];
s2 = otriangle[t].i[1];
s3 = otriangle[t].i[2];
pvect = (obstacle[s2].xc - obstacle[s1].xc)*(obstacle[s3].yc - obstacle[s1].yc);
pvect -= (obstacle[s2].yc - obstacle[s1].yc)*(obstacle[s3].xc - obstacle[s1].xc);
otriangle[t].acute = (pvect > 0.0);
}
if (SHADE_OBSTACLE_FACETS) for (i = 0; i < n_ofacets; i++)
{
facet_area_to_rgb(obstacle, otriangle, ofacet, i, rgb);
nf = ofacet[i].ntriangles;
for (f = 0; f < nf; f++)
{
t = ofacet[i].triangle[f];
if (otriangle[t].acute)
{
s1 = otriangle[t].i[0];
s2 = otriangle[t].i[1];
s3 = otriangle[t].i[2];
draw_colored_triangle(obstacle[s1].xc, obstacle[s1].yc, obstacle[s2].xc, obstacle[s2].yc, obstacle[s3].xc, obstacle[s3].yc, rgb);
}
}
}
else for (t = 0; t < n_otriangles; t++) if (otriangle[t].acute)
{
triangle_area_to_rgb(obstacle, otriangle, t, rgb);
s1 = otriangle[t].i[0];
s2 = otriangle[t].i[1];
s3 = otriangle[t].i[2];
draw_colored_triangle(obstacle[s1].xc, obstacle[s1].yc, obstacle[s2].xc, obstacle[s2].yc, obstacle[s3].xc, obstacle[s3].yc, rgb);
}
}
glColor3f(1.0, 1.0, 1.0);
for (i = 0; i < nobstacles; i++)
for (j = 0; j < obstacle[i].nneighb; j++)
{
neigh = obstacle[i].neighb[j];
draw_line(obstacle[i].xc, obstacle[i].yc, obstacle[neigh].xc, obstacle[neigh].yc);
}
}
void draw_container(double xmin, double xmax, t_obstacle obstacle[NMAXOBSTACLES], t_segment segment[NMAXSEGMENTS], t_belt *conveyor_belt, int wall)
/* draw the container, for certain boundary conditions */
{
int i, j, k, n, n1, n2, neigh;
double rgb[3], x, y, r, phi, angle, dx, dy, ybin, x1, x2, y1, y2, h, bangle, blength, pos0, pos, bsegment, tx, ty, bwidth, ca, sa, ekin, epot, etot, hue, area;
char message[100];
/* draw fixed obstacles */
if (ADD_FIXED_OBSTACLES)
{
glLineWidth(CONTAINER_WIDTH);
if (CHARGE_OBSTACLES) hsl_to_rgb(30.0, 0.1, 0.5, rgb);
else if (!OSCILLATE_OBSTACLES) hsl_to_rgb(300.0, 0.1, 0.5, rgb);
for (i = 0; i < nobstacles; i++)
{
if (OSCILLATE_OBSTACLES)
{
obstacle_hue(obstacle[i], rgb);
}
draw_colored_circle_precomp(obstacle[i].xc - xtrack, obstacle[i].yc - ytrack, obstacle[i].radius, rgb);
}
glColor3f(1.0, 1.0, 1.0);
for (i = 0; i < nobstacles; i++)
{
x = obstacle[i].xc - xtrack;
y = obstacle[i].yc - ytrack;
r = obstacle[i].radius;
draw_circle_precomp(x, y, r);
if (CHARGE_OBSTACLES)
{
draw_line(x - r, y, x + r, y);
draw_line(x, y - r, x, y + r);
}
if (ROTATE_OBSTACLES)
{
ca = cos(obstacle[i].angle);
sa = sin(obstacle[i].angle);
// printf("Obstacle %i angle = %.5lg\n", i, obstacle[i].angle);
draw_line(x - r*ca, y - r*sa, x + r*ca, y + r*sa);
draw_line(x + r*sa, y - r*ca, x - r*sa, y + r*ca);
}
}
}
if (ADD_FIXED_SEGMENTS)
{
glLineWidth(CONTAINER_WIDTH);
glColor3f(1.0, 1.0, 1.0);
for (i = 0; i < nsegments; i++) if (segment[i].active)
{
if (COLOR_SEG_GROUPS) set_segment_group_color(segment[i].group, 1.0, rgb);
else if (SHOW_SEGMENTS_PRESSURE) set_segment_pressure_color(segment[i].avrg_pressure, 1.0, rgb);
draw_line(segment[i].x1 - xtrack, segment[i].y1 - ytrack, segment[i].x2 - xtrack, segment[i].y2 - ytrack);
}
/* draw conveyor belt */
if (ADD_CONVEYOR_FORCE) for (i=0; i<nbelts;i++)
{
bwidth = conveyor_belt[i].width;
r = 0.7*bwidth;
tx = conveyor_belt[i].tx;
ty = conveyor_belt[i].ty;
bangle = -conveyor_belt[i].position/(bwidth);
blength = 2.0*conveyor_belt[i].length + DPI*conveyor_belt[i].width;
dx = r*cos(bangle);
dy = r*sin(bangle);
x1 = conveyor_belt[i].x1 - xtrack;
y1 = conveyor_belt[i].y1 - ytrack;
draw_line(x1-dx, y1-dy, x1+dx, y1+dy);
draw_line(x1+dy, y1-dx, x1-dy, y1+dx);
draw_circle_precomp(x1, y1, r);
x2 = conveyor_belt[i].x2 - xtrack;
y2 = conveyor_belt[i].y2 - ytrack;
draw_line(x2-dx, y2-dy, x2+dx, y2+dy);
draw_line(x2+dy, y2-dx, x2-dy, y2+dx);
draw_circle_precomp(x2, y2, r);
draw_line(x1-r*ty, y1+r*tx, x2-r*ty, y2+r*tx);
draw_line(x1+r*ty, y1-r*tx, x2+r*ty, y2-r*tx);
bsegment = 10.0*blength;
bsegment = blength/(double)((int)bsegment);
if (conveyor_belt[i].position > 0.0)
pos0 = conveyor_belt[i].position - bsegment*(double)((int)(conveyor_belt[i].position/bsegment));
else
{
pos = -conveyor_belt[i].position;
pos0 = pos - bsegment*(double)((int)(pos/bsegment));
pos0 = bsegment - pos0;
}
while (pos0 < conveyor_belt[i].length)
{
x = x1 + tx*pos0;
y = y1 + ty*pos0;
draw_line(x - r*ty, y + r*tx, x - bwidth*ty, y + bwidth*tx);
pos0 += bsegment;
}
while (pos0 < conveyor_belt[i].length + PI*bwidth)
{
pos = (pos0 - conveyor_belt[i].length)/bwidth;
angle = PID + conveyor_belt[i].angle - pos;
ca = cos(angle);
sa = sin(angle);
draw_line(x2 + r*ca, y2 + r*sa, x2 + bwidth*ca, y2 + bwidth*sa);
pos0 += bsegment;
}
while (pos0 < 2.0*conveyor_belt[i].length + PI*bwidth)
{
pos = pos0 - conveyor_belt[i].length - PI*bwidth;
x = x2 - tx*pos;
y = y2 - ty*pos;
draw_line(x + r*ty, y - r*tx, x + bwidth*ty, y - bwidth*tx);
pos0 += bsegment;
}
while (pos0 < 2.0*conveyor_belt[i].length + DPI*bwidth)
{
pos = (pos0 - 2.0*conveyor_belt[i].length - PI*bwidth)/bwidth;
angle = -PID + conveyor_belt[i].angle - pos;
ca = cos(angle);
sa = sin(angle);
draw_line(x1 + r*ca, y1 + r*sa, x1 + bwidth*ca, y1 + bwidth*sa);
pos0 += bsegment;
}
}
}
switch (BOUNDARY_COND) {
case (BC_SCREEN):
{
/* do nothing */
break;
}
case (BC_RECTANGLE):
{
glColor3f(1.0, 1.0, 1.0);
glLineWidth(CONTAINER_WIDTH);
draw_line(BCXMIN, BCYMIN, BCXMAX, BCYMIN);
draw_line(BCXMIN, BCYMAX, BCXMAX, BCYMAX);
if (!SYMMETRIC_DECREASE) draw_line(BCXMAX, BCYMIN, BCXMAX, BCYMAX);
draw_line(xmin, BCYMIN, xmin, BCYMAX);
// draw_line(XMIN, 0.5*(BCYMIN + BCYMAX), xmin, 0.5*(BCYMIN + BCYMAX));
if (SYMMETRIC_DECREASE)
{
draw_line(xmax, BCYMIN, xmax, BCYMAX);
draw_line(XMAX, 0.5*(BCYMIN + BCYMAX), xmax, 0.5*(BCYMIN + BCYMAX));
}
break;
}
case (BC_CIRCLE):
{
glLineWidth(CONTAINER_WIDTH);
hsl_to_rgb(300.0, 0.1, 0.5, rgb);
for (i=-1; i<2; i++)
{
if (CENTER_VIEW_ON_OBSTACLE) x = 0.0;
else x = xmin + (double)i*(OBSXMAX - OBSXMIN);
draw_colored_circle_precomp(x, 0.0, OBSTACLE_RADIUS, rgb);
glColor3f(1.0, 1.0, 1.0);
draw_circle_precomp(x, 0.0, OBSTACLE_RADIUS);
glColor3f(0.0, 0.0, 0.0);
sprintf(message, "Mach %.3f", xspeed/20.0);
// sprintf(message, "Speed %.2f", xspeed);
write_text(x-0.17, -0.025, message);
}
break;
}
case (BC_PERIODIC_CIRCLE):
{
glLineWidth(CONTAINER_WIDTH);
hsl_to_rgb(300.0, 0.1, 0.5, rgb);
for (i=-1; i<2; i++)
{
if (CENTER_VIEW_ON_OBSTACLE) x = 0.0;
else x = xmin + (double)i*(OBSXMAX - OBSXMIN);
draw_colored_circle_precomp(x, 0.0, OBSTACLE_RADIUS, rgb);
glColor3f(1.0, 1.0, 1.0);
draw_circle_precomp(x, 0.0, OBSTACLE_RADIUS);
glColor3f(0.0, 0.0, 0.0);
sprintf(message, "Mach %.2f", xspeed/20.0);
// sprintf(message, "Speed %.2f", xspeed);
write_text(x-0.17, -0.025, message);
}
break;
}
case (BC_PERIODIC_TRIANGLE):
{
glLineWidth(CONTAINER_WIDTH);
hsl_to_rgb(300.0, 0.1, 0.5, rgb);
for (i=-1; i<2; i++)
{
if (CENTER_VIEW_ON_OBSTACLE) x = 0.0;
else x = xmin + (double)i*(OBSXMAX - OBSXMIN);
x1 = x + OBSTACLE_RADIUS;
x2 = x - OBSTACLE_RADIUS;
h = 2.0*OBSTACLE_RADIUS*tan(APOLY*PID);
draw_colored_triangle(x1, 0.0, x2, h, x2, -h, rgb);
glColor3f(1.0, 1.0, 1.0);
draw_triangle(x1, 0.0, x2, h, x2, -h);
glColor3f(0.0, 0.0, 0.0);
sprintf(message, "Mach %.2f", xspeed*3.0/40.0);
write_text(x-0.25, -0.025, message);
}
break;
}
case (BC_PERIODIC_FUNNEL):
{
glLineWidth(CONTAINER_WIDTH);
hsl_to_rgb(300.0, 0.1, 0.5, rgb);
for (i=-1; i<2; i++)
{
if (CENTER_VIEW_ON_OBSTACLE) x = 0.0;
else x = xmin + (double)i*(OBSXMAX - OBSXMIN);
for (j=-1; j<2; j+=2)
{
draw_colored_circle_precomp(x, (double)j*(FUNNEL_WIDTH + OBSTACLE_RADIUS), OBSTACLE_RADIUS, rgb);
glColor3f(1.0, 1.0, 1.0);
draw_circle_precomp(x, (double)j*(FUNNEL_WIDTH + OBSTACLE_RADIUS), OBSTACLE_RADIUS);
}
glColor3f(0.0, 0.0, 0.0);
sprintf(message, "Mach %.2f", xspeed/20.0);
write_text(x-0.17, 0.75, message);
}
break;
}
case (BC_RECTANGLE_LID):
{
glColor3f(1.0, 1.0, 1.0);
glLineWidth(CONTAINER_WIDTH);
draw_line(BCXMIN, BCYMIN, BCXMAX, BCYMIN);
draw_line(BCXMIN, BCYMIN, BCXMIN, BCYMAX);
draw_line(BCXMAX, BCYMIN, BCXMAX, BCYMAX);
hsl_to_rgb(300.0, 0.1, 0.5, rgb);
draw_colored_rectangle(BCXMIN + 0.05, ylid, BCXMAX - 0.05, ylid + LID_WIDTH, rgb);
glColor3f(1.0, 1.0, 1.0);
draw_rectangle(BCXMIN + 0.05, ylid, BCXMAX - 0.05, ylid + LID_WIDTH);
break;
}
case (BC_RECTANGLE_WALL):
{
glColor3f(1.0, 1.0, 1.0);
glLineWidth(CONTAINER_WIDTH);
draw_rectangle(BCXMIN, BCYMIN, BCXMAX, BCYMAX);
draw_line(0.5*(BCXMIN+BCXMAX), BCYMAX, 0.5*(BCXMIN+BCXMAX), BCYMAX + 0.5*WALL_WIDTH);
draw_line(0.5*(BCXMIN+BCXMAX), BCYMIN, 0.5*(BCXMIN+BCXMAX), BCYMIN - 0.5*WALL_WIDTH);
if (wall)
{
hsl_to_rgb(300.0, 0.1, 0.5, rgb);
draw_colored_rectangle(xwall - 0.5*WALL_WIDTH, BCYMIN + 0.025, xwall + 0.5*WALL_WIDTH, BCYMAX - 0.025, rgb);
glColor3f(1.0, 1.0, 1.0);
draw_rectangle(xwall - 0.5*WALL_WIDTH, BCYMIN + 0.025, xwall + 0.5*WALL_WIDTH, BCYMAX - 0.025);
}
break;
}
case (BC_EHRENFEST):
{
glLineWidth(CONTAINER_WIDTH);
glColor3f(1.0, 1.0, 1.0);
phi = asin(EHRENFEST_WIDTH/EHRENFEST_RADIUS);
glBegin(GL_LINE_LOOP);
for (i=0; i<=NSEG; i++)
{
angle = -PI + phi + (double)i*2.0*(PI - phi)/(double)NSEG;
glVertex2d(1.0 + EHRENFEST_RADIUS*cos(angle), EHRENFEST_RADIUS*sin(angle));
}
for (i=0; i<=NSEG; i++)
{
angle = phi + (double)i*2.0*(PI - phi)/(double)NSEG;
glVertex2d(-1.0 + EHRENFEST_RADIUS*cos(angle), EHRENFEST_RADIUS*sin(angle));
}
glEnd();
break;
}
case (BC_SCREEN_BINS):
{
glLineWidth(CONTAINER_WIDTH);
glColor3f(1.0, 1.0, 1.0);
dy = (YMAX - YMIN)/((double)NGRIDX + 3);
dx = dy/cos(PI/6.0);
ybin = 2.75*dy;
for (i=-1; i<=NGRIDX; i++)
{
x = ((double)i - 0.5*(double)NGRIDX + 0.5)*dx;
draw_line(x, YMIN, x, YMIN + ybin);
}
break;
}
case (BC_GENUS_TWO):
{
hsl_to_rgb(300.0, 0.1, 0.5, rgb);
draw_colored_rectangle(0.0, 0.0, BCXMAX, BCYMAX, rgb);
break;
}
default:
{
/* do nothing */
}
}
}
void print_omega(double angle, double angular_speed, double fx, double fy)
{
char message[100];
double rgb[3], y1, frac, absa;
static double xleftbox, xlefttext, xrightbox, xrighttext, y = YMAX - 0.1, ymin = YMIN + 0.05;
static int first = 1;
if (first)
{
xrightbox = XMAX - 0.54;
xrighttext = xrightbox - 0.48;
first = 0;
}
y1 = y;
if (PRINT_ANGLE)
{
erase_area_hsl(xrightbox, y + 0.025, 0.42, 0.05, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
angle = angle*360.0/DPI;
absa = vabs(angle);
frac = absa - (double)((int)absa);
sprintf(message, "Angle = %3d.%d degrees", (int)absa, (int)(10.0*frac));
write_text(xrighttext + 0.1, y, message);
y1 -= 0.1;
}
if (PRINT_OMEGA)
{
erase_area_hsl(xrightbox, y1 + 0.025, 0.42, 0.05, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Angular speed = %.4f", angular_speed);
write_text(xrighttext + 0.1, y1, message);
y1 -= 0.1;
}
if (PRINT_SEGMENTS_FORCE)
{
erase_area_hsl(xrightbox, y1 + 0.025, 0.42, 0.05, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Fx = %.4f", fx);
write_text(xrighttext + 0.1, y1, message);
y1 -= 0.1;
erase_area_hsl(xrightbox, y1 + 0.025, 0.42, 0.05, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Fy = %.4f", fy);
write_text(xrighttext + 0.1, y1, message);
y1 -= 0.1;
erase_area_hsl(xrightbox, y1 + 0.025, 0.42, 0.05, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Fy/Fx = %.4f", fy/fx);
write_text(xrighttext + 0.1, y1, message);
}
}
void compute_segments_force(t_lj_parameters *params, t_segment segment[NMAXSEGMENTS])
{
int i;
double fx = 0.0, fy = 0.0;
for (i=0; i<nsegments; i++) if (segment[i].active)
{
fx += segment[i].fx;
fy += segment[i].fy;
}
params->bdry_fx = fx;
params->bdry_fy = fy;
}
void print_parameters(t_lj_parameters params, short int left, double pressure[N_PRESSURES], short int refresh)
{
char message[100];
int i, j, k;
double density, hue, rgb[3], logratio, x, y, meanpress[N_PRESSURES], phi, sphi, dphi, pprint, mean_temp, lengthcontainer, boundary_force, fx, fy, r1, r2;
static double xbox, xtext, xmid, xmidtext, xxbox, xxtext, pressures[N_P_AVERAGE], meanpressure = 0.0, maxpressure = 0.0, mean_fx, mean_fy;
static double press[N_PRESSURES][N_P_AVERAGE], temp[N_T_AVERAGE], scale;
static int first = 1, i_pressure, i_temp;
if (first)
{
// scale = (XMAX - XMIN)/4.0;
scale = (YMAX - YMIN)/2.5;
if (left)
{
xbox = XMIN + 0.45*scale;
xtext = XMIN + 0.12*scale;
xxbox = XMAX - 0.39*scale;
xxtext = XMAX - 0.73*scale;
}
else
{
xbox = XMAX - 0.41*scale;
xtext = XMAX - 0.73*scale;
xxbox = XMIN + 0.4*scale;
xxtext = XMIN + 0.08*scale;
}
xmid = 0.5*(XMIN + XMAX) - 0.1*scale;
// xmid = 0.5*(XMIN + XMAX) + 0.05*scale;
xmidtext = xmid - 0.2*scale;
for (i=0; i<N_P_AVERAGE; i++) pressures[i] = 0.0;
if (RECORD_PRESSURES) for (j=0; j<N_PRESSURES; j++)
{
meanpress[j] = 0.0;
for (i=0; i<N_P_AVERAGE; i++) press[j][i] = 0.0;
}
i_pressure = 0;
i_temp = 0;
for (i=0; i<N_T_AVERAGE; i++) temp[i] = 0.0;
mean_fx = 0.0;
mean_fy = 0.0;
r1 = 0.005;
r2 = 1.0 - r1;
first = 0;
}
lengthcontainer = params.xmaxcontainer - params.xmincontainer;
boundary_force = params.fboundary/(double)(ncircles*NVID);
/* table of pressures */
pressures[i_pressure] = boundary_force/(lengthcontainer + INITYMAX - INITYMIN);
if (RECORD_PRESSURES)
{
for (j=0; j<N_PRESSURES; j++) press[j][i_pressure] = pressure[j];
}
i_pressure++;
if (i_pressure == N_P_AVERAGE) i_pressure = 0;
for (i=0; i<N_P_AVERAGE; i++) meanpressure += pressures[i];
meanpressure = meanpressure/(double)N_P_AVERAGE;
if (RECORD_PRESSURES) for (j=0; j<N_PRESSURES; j++)
{
meanpress[j] = 0.0;
for (i=0; i<N_P_AVERAGE; i++) meanpress[j] += press[j][i];
meanpress[j] = meanpress[j]/(double)N_P_AVERAGE;
}
// if (RECORD_PRESSURES)
// for (j=0; j<N_PRESSURES; j++) meanpress[j] =
//
// for (j=0; j<N_PRESSURES; j++) printf("Mean pressure[%i] = %.5lg\n", j, meanpress[j]);
if (RECORD_PRESSURES)
{
for (j=0; j<N_PRESSURES; j++) if (meanpress[j] > maxpressure) maxpressure = meanpress[j];
printf("Max pressure = %.5lg\n\n", maxpressure);
}
y = YMAX - 0.1*scale;
if ((INCREASE_BETA)||(PRINT_TEMPERATURE)) /* print temperature */
{
logratio = log(params.beta/BETA)/log(0.5*BETA_FACTOR);
if (logratio > 1.0) logratio = 1.0;
else if (logratio < 0.0) logratio = 0.0;
if (BETA_FACTOR > 1.0) hue = PARTICLE_HUE_MAX - (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*logratio;
else hue = PARTICLE_HUE_MIN - (PARTICLE_HUE_MIN - PARTICLE_HUE_MAX)*logratio;
if (PRINT_LEFT) erase_area_hsl_turbo(xbox, y + 0.025*scale, 0.5*scale, 0.05*scale, hue, 0.9, 0.5);
else erase_area_hsl_turbo(xmid + 0.1, y + 0.025*scale, 0.45*scale, 0.05*scale, hue, 0.9, 0.5);
if ((hue < 90)||(hue > 270)) glColor3f(1.0, 1.0, 1.0);
else glColor3f(0.0, 0.0, 0.0);
sprintf(message, "Temperature %.2f", 1.0/params.beta);
if (PRINT_LEFT) write_text(xtext, y, message);
else write_text(xmidtext, y, message);
// y -= 0.1;
// erase_area_hsl(xxbox, y + 0.025, 0.37, 0.05, 0.0, 0.9, 0.0);
// glColor3f(1.0, 1.0, 1.0);
// sprintf(message, "Pressure %.3f", meanpressure);
// write_text(xxtext, y, message);
}
if (DECREASE_CONTAINER_SIZE) /* print density */
{
density = (double)ncircles/((lengthcontainer)*(INITYMAX - INITYMIN));
erase_area_hsl(xbox, y + 0.025*scale, 0.37*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Density %.3f", density);
write_text(xtext + 0.1, y, message);
erase_area_hsl(xmid, y + 0.025*scale, 0.37*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Temperature %.2f", params.mean_energy);
write_text(xmidtext - 0.1, y, message);
erase_area_hsl(xxbox, y + 0.025*scale, 0.37*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Pressure %.3f", meanpressure);
write_text(xxtext, y, message);
}
else if (INCREASE_KREPEL) /* print force constant */
{
erase_area_hsl(xbox, y + 0.025*scale, 0.35*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Force constant %.2f", params.krepel);
write_text(xtext + 0.03, y, message);
}
else if (INCREASE_E) /* print electric field */
{
erase_area_hsl(xbox, y + 0.025*scale, 0.27*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "E field = %.2f", 25.0*NVID*DT_PARTICLE*params.efield);
write_text(xtext + 0.08, y, message);
}
else if (INCREASE_B) /* print magnetic field */
{
erase_area_hsl(xbox, y + 0.025*scale, 0.27*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "B field = %.2f", 25.0*NVID*DT_PARTICLE*params.bfield);
write_text(xtext + 0.08, y, message);
}
if (PRINT_NPARTICLES) /* print number of particles */
{
erase_area_hsl(xbox, y + 0.025*scale, 0.27*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "%i electrons", params.nactive);
write_text(xtext + 0.08, y, message);
}
if (PRINT_TYPE_PROP) /* print proportion of types */
{
erase_area_hsl(xbox, y + 0.025*scale, 0.27*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "%.1f %% anions", 100.0*params.prop);
write_text(xtext + 0.08, y, message);
}
if (RECORD_PRESSURES)
{
y = FUNNEL_WIDTH + OBSTACLE_RADIUS;
for (i=0; i<N_PRESSURES; i++)
{
phi = DPI*(double)i/(double)N_PRESSURES;
hue = PARTICLE_HUE_MIN + (PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*meanpress[i]/MAX_PRESSURE;
if (hue > PARTICLE_HUE_MIN) hue = PARTICLE_HUE_MIN;
if (hue < PARTICLE_HUE_MAX) hue = PARTICLE_HUE_MAX;
hsl_to_rgb_turbo(hue, 0.9, 0.5, rgb);
dphi = DPI/(double)N_PRESSURES;
// x = 0.95*OBSTACLE_RADIUS*cos(phi);
sphi = sin(phi);
if (sphi < 0.0) draw_colored_sector(0.0, y, 0.95*OBSTACLE_RADIUS, OBSTACLE_RADIUS, phi, phi + dphi, rgb, 10);
else draw_colored_sector(0.0, -y, 0.95*OBSTACLE_RADIUS, OBSTACLE_RADIUS, phi, phi + dphi, rgb, 10);
}
glColor3f(1.0, 1.0, 1.0);
for (i=-1; i<2; i++)
{
k = N_PRESSURES/4 + i*N_PRESSURES/9;
phi = DPI*(double)k/(double)N_PRESSURES;
pprint = 0.0;
for (j=-2; j<3; j++) pprint += meanpress[k + j];
sprintf(message, "p = %.0f", pprint*200.0/MAX_PRESSURE);
write_text(0.85*OBSTACLE_RADIUS*cos(phi) - 0.1, -y + 0.85*OBSTACLE_RADIUS*sin(phi), message);
}
}
if ((PARTIAL_THERMO_COUPLING)&&(!INCREASE_BETA)&&(!EXOTHERMIC))
{
printf("Temperature %i in average: %.3lg\n", i_temp, params.mean_energy);
temp[i_temp] = params.mean_energy;
i_temp++;
if (i_temp >= N_T_AVERAGE) i_temp = 0;
mean_temp = 0.0;
for (i=0; i<N_T_AVERAGE; i++) mean_temp += temp[i];
mean_temp = mean_temp/N_T_AVERAGE;
hue = PARTICLE_HUE_MIN + 0.5*(PARTICLE_HUE_MAX - PARTICLE_HUE_MIN)*mean_temp/PARTICLE_EMAX;
if (hue < PARTICLE_HUE_MAX) hue = PARTICLE_HUE_MAX;
erase_area_hsl_turbo(xbox, y + 0.025*scale, 0.37*scale, 0.05*scale, hue, 0.9, 0.5);
if ((hue < 90)||(hue > 270)) glColor3f(1.0, 1.0, 1.0);
else glColor3f(0.0, 0.0, 0.0);
sprintf(message, "Temperature %.2f", mean_temp);
write_text(xtext, y, message);
}
if (INCREASE_GRAVITY)
{
erase_area_hsl(xmid, y + 0.025*scale, 0.22*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Gravity %.2f", params.gravity/GRAVITY);
// write_text(xmidtext + 0.1, y, message);
write_text(xmidtext, y, message);
}
if (CHANGE_RADIUS)
{
erase_area_hsl(xmid, y + 0.025*scale, 0.3*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Radius %.4f", params.radius);
write_text(xmidtext + 0.05, y, message);
}
if (PRINT_SEGMENTS_FORCE)
{
glColor3f(1.0, 1.0, 1.0);
if (refresh)
{
fx = 0.01*params.bdry_fx/(double)params.nactive;
fy = 0.01*params.bdry_fy/(double)params.nactive;
/* average boundary force */
mean_fx = r2*mean_fx + r1*fx;
mean_fy = r2*mean_fy + r1*fy;
}
if ((PRINT_ANGLE)||(PRINT_OMEGA))
draw_arrow(0.0, 0.0, FORCE_FACTOR*mean_fx, FORCE_FACTOR*mean_fy, 15.0, 0.1);
else
{
erase_area_hsl(xmid, 0.0, 0.2*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Fy = %.2f", mean_fy);
write_text(xmidtext + 0.15*scale, -0.02*scale, message);
if (mean_fx*mean_fx + mean_fy*mean_fy > 5.0*FORCE_FACTOR)
draw_arrow(0.0, 0.0, FORCE_FACTOR*mean_fx, FORCE_FACTOR*mean_fy, 15.0, 0.1);
}
}
if ((PRINT_ANGLE)||(PRINT_OMEGA)) print_omega(params.angle, params.omega, mean_fx, mean_fy);
}
void print_ehrenfest_parameters(t_particle particle[NMAXCIRCLES], double pleft, double pright)
{
char message[100];
int i, j, nleft1 = 0, nleft2 = 0, nright1 = 0, nright2 = 0;
double density, hue, rgb[3], logratio, y, shiftx = 0.3, xmidplus, xmidminus;
static double xleftbox, xlefttext, xmidbox, xmidtext, xrightbox, xrighttext, pressures[500][2], meanpressure[2];
static int first = 1, i_pressure, naverage = 500, n_pressure;
if (first)
{
xleftbox = -0.85;
xlefttext = xleftbox - 0.5;
xrightbox = 1.0;
xrighttext = xrightbox - 0.45;
// xmid = 0.5*(XMIN + XMAX) - 0.1;
// xmidtext = xmid - 0.24;
meanpressure[0] = 0.0;
meanpressure[1] = 0.0;
for (i=0; i<naverage; i++)
{
pressures[i][0] = 0.0;
pressures[i][1] = 0.0;
}
i_pressure = 0;
n_pressure = 0;
first = 0;
}
if (BOUNDARY_COND == BC_EHRENFEST)
{
xmidplus = 1.0 - EHRENFEST_RADIUS;
xmidminus = -1.0 + EHRENFEST_RADIUS;
}
else
{
xmidplus = xwall;
xmidminus = xwall;
}
/* table of pressures */
pressures[i_pressure][0] = pleft;
pressures[i_pressure][1] = pright;
i_pressure++;
if (i_pressure == naverage) i_pressure = 0;
if (n_pressure < naverage - 1) n_pressure++;
for (i=0; i<n_pressure; i++)
for (j=0; j<2; j++)
meanpressure[j] += pressures[i][j];
for (j=0; j<2; j++) meanpressure[j] = meanpressure[j]/(double)n_pressure;
for (i = 0; i < ncircles; i++) if (particle[i].active)
{
if (particle[i].xc < xmidminus)
{
if (particle[i].type == 0) nleft1++;
else nleft2++;
}
else if (particle[i].xc > xmidplus)
{
if (particle[i].type == 0) nright1++;
else nright2++;
}
}
y = YMIN + 0.05;
erase_area_hsl(xleftbox - shiftx, y + 0.025, 0.22, 0.05, 0.0, 0.9, 0.0);
hsl_to_rgb(HUE_TYPE0, 0.9, 0.5, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
sprintf(message, "%i particles", nleft1);
write_text(xlefttext + 0.28 - shiftx, y, message);
erase_area_hsl(xleftbox + shiftx, y + 0.025, 0.22, 0.05, 0.0, 0.9, 0.0);
hsl_to_rgb(HUE_TYPE1, 0.9, 0.5, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
sprintf(message, "%i particles", nleft2);
write_text(xlefttext + 0.28 + shiftx, y, message);
erase_area_hsl(xrightbox - shiftx, y + 0.025, 0.22, 0.05, 0.0, 0.9, 0.0);
hsl_to_rgb(HUE_TYPE0, 0.9, 0.5, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
sprintf(message, "%i particles", nright1);
write_text(xrighttext + 0.28 - shiftx, y, message);
erase_area_hsl(xrightbox + shiftx, y + 0.025, 0.22, 0.05, 0.0, 0.9, 0.0);
hsl_to_rgb(HUE_TYPE1, 0.9, 0.5, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
sprintf(message, "%i particles", nright2);
write_text(xrighttext + 0.28 + shiftx, y, message);
y = YMAX - 0.1;
erase_area_hsl(xleftbox - 0.1, y + 0.025, 0.22, 0.05, 0.0, 0.9, 0.0);
hsl_to_rgb_turbo(HUE_TYPE1, 0.9, 0.5, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
sprintf(message, "Pressure %.2f", 0.001*meanpressure[0]/(double)ncircles);
write_text(xlefttext + 0.25, y, message);
erase_area_hsl(xrightbox - 0.1, y + 0.025, 0.22, 0.05, 0.0, 0.9, 0.0);
hsl_to_rgb_turbo(HUE_TYPE0, 0.9, 0.5, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
sprintf(message, "Pressure %.2f", 0.001*meanpressure[1]/(double)ncircles);
write_text(xrighttext + 0.2, y, message);
}
void count_particle_number(t_particle *particle, int *particle_numbers, int time)
{
int type, i, n;
n = time*(RD_TYPES+1);
for (type = 0; type < RD_TYPES+1; type++)
particle_numbers[n + type] = 0;
if (COUNT_PARTNER_TYPE)
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].type == 0)
particle_numbers[n + particle[i].npartners + 1]++;
else if ((particle[i].type == 2)&&(particle[i].npartners == 0))
particle_numbers[n + 1]++;
}
// for (type = 0; type < RD_TYPES+1; type++) printf("type = %i, %i particles\n", type, particle_numbers[n + type]);
}
else for (i=0; i<ncircles; i++)
if (particle[i].active)
particle_numbers[n + particle[i].type]++;
}
void print_particle_number(int npart)
{
char message[100];
double y = YMAX - 0.1;
static double xleftbox, xlefttext;
static int first = 1;
if (first)
{
xleftbox = XMIN + 0.5;
xlefttext = xleftbox - 0.5;
first = 0;
}
erase_area_hsl(xleftbox, y + 0.025, 0.22, 0.05, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
if (npart > 1) sprintf(message, "%i particles", npart);
else sprintf(message, "%i particle", npart);
write_text(xlefttext + 0.28, y, message);
}
void print_particle_types_number(t_particle *particle, int ntypes)
{
int i, ntype[10];
char message[100];
double y = YMAX - 0.1, rgb[3];
static double xleftbox, xlefttext;
static int first = 1;
if (first)
{
xleftbox = XMAX - 0.5;
xlefttext = xleftbox - 0.45;
first = 0;
}
for (i=0; i<10; i++) ntype[i] = 0;
for (i=0; i<ncircles; i++)
if (particle[i].active) ntype[particle[i].type]++;
for (i=1; i<ntypes+1; i++)
{
erase_area_hsl(xleftbox, y + 0.025, 0.22, 0.05, 0.0, 0.9, 0.0);
set_type_color(i, 0.5, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
sprintf(message, "%i particles", ntype[i]);
write_text(xlefttext + 0.28, y, message);
y -= 0.12;
}
}
void print_entropy(double entropy[2])
{
char message[100];
double rgb[3];
static double xleftbox, xlefttext, xrightbox, xrighttext, y = YMAX - 0.1, ymin = YMIN + 0.05;
static int first = 1;
if (first)
{
xleftbox = XMIN + 0.4;
xlefttext = xleftbox - 0.55;
xrightbox = XMAX - 0.39;
xrighttext = xrightbox - 0.55;
first = 0;
}
if (POSITION_Y_DEPENDENCE)
{
erase_area_hsl(xrightbox, ymin + 0.025, 0.35, 0.05, 0.0, 0.9, 0.0);
hsl_to_rgb_turbo(HUE_TYPE1, 0.9, 0.5, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
sprintf(message, "Entropy = %.4f", entropy[1]);
write_text(xrighttext + 0.28, ymin, message);
}
else
{
erase_area_hsl(xleftbox, y + 0.025, 0.35, 0.05, 0.0, 0.9, 0.0);
hsl_to_rgb_turbo(HUE_TYPE1, 0.9, 0.5, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
sprintf(message, "Entropy = %.4f", entropy[1]);
write_text(xlefttext + 0.28, y, message);
}
erase_area_hsl(xrightbox, y + 0.025, 0.35, 0.05, 0.0, 0.9, 0.0);
hsl_to_rgb_turbo(HUE_TYPE0, 0.9, 0.5, rgb);
glColor3f(rgb[0], rgb[1], rgb[2]);
sprintf(message, "Entropy = %.4f", entropy[0]);
write_text(xrighttext + 0.28, y, message);
}
void print_segments_speeds(double vx[2], double vy[2])
{
char message[100];
double rgb[3], y;
static double xleftbox, xlefttext, xrightbox, xrighttext, ymin = YMIN + 0.05, scale;
static int first = 1;
if (first)
{
scale = (XMAX - XMIN)/4.0;
xleftbox = XMIN + 0.3*scale;
xlefttext = xleftbox - 0.22*scale;
xrightbox = XMAX - 0.39*scale;
xrighttext = xrightbox - 0.3*scale;
first = 0;
}
y = YMAX - 0.1*scale;
erase_area_hsl(xrightbox, y + 0.025*scale, 0.25*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Vx = %.2f", vx[0]);
write_text(xrighttext + 0.1, y, message);
y -= 0.1*scale;
erase_area_hsl(xrightbox, y + 0.025*scale, 0.25*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Vy = %.2f", vy[0]);
write_text(xrighttext + 0.1, y, message);
if (TWO_OBSTACLES)
{
y = YMAX - 0.1*scale;
erase_area_hsl(xleftbox, y + 0.025*scale, 0.2*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Vx = %.2f", vx[1]);
write_text(xlefttext + 0.1, y, message);
y -= 0.1*scale;
erase_area_hsl(xleftbox, y + 0.025*scale, 0.2*scale, 0.05*scale, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Vy = %.2f", vy[1]);
write_text(xlefttext + 0.1, y, message);
}
}
void print_segment_group_speeds(t_group_segments *segment_group)
{
char message[100];
double rgb[3], y, av_vx = 0.0, av_vy = 0.0, av_omega = 0.0, xbox, xtext;
int i, group, groupshift;
static double xleftbox, xlefttext, xrightbox, xrighttext, ymin = YMIN + 0.05, scale;
static double vx[100*NMAXGROUPS], vy[100*NMAXGROUPS], omega[100*NMAXGROUPS], inv_t_window, speed_ratio;
static int first = 1, position[NMAXGROUPS], t_window = 50;
if (first)
{
scale = (XMAX - XMIN)/4.0;
xleftbox = XMIN + 0.3*scale;
xlefttext = xleftbox - 0.22*scale;
xrightbox = XMAX - 0.39*scale;
xrighttext = xrightbox - 0.3*scale;
speed_ratio = (double)(25*NVID)*DT_PARTICLE;
inv_t_window = 1.0/(double)t_window;
for (group=1; group<NMAXGROUPS; group++) position[group] = 0;
first = 0;
}
/* compute time averages */
for (group = 1; group < ngroups; group++)
{
groupshift = (group-1)*100;
vx[groupshift + position[group]] = segment_group[group].vx*speed_ratio;
vy[groupshift + position[group]] = segment_group[group].vy*speed_ratio;
omega[groupshift + position[group]] = segment_group[group].omega*speed_ratio;
position[group]++;
if (position[group] >=t_window) position[group] = 0;
for (i=0; i<t_window; i++)
{
av_vx += vx[groupshift + i];
av_vy += vy[groupshift + i];
av_omega += omega[groupshift + i];
}
av_vx *= inv_t_window;
av_vy *= inv_t_window;
av_omega *= inv_t_window;
if (ngroups > 2)
{
xbox = xleftbox + (xrightbox - xleftbox)*(group-1)/(ngroups-2);
xtext = xlefttext + (xrighttext - xlefttext)*(group-1)/(ngroups-2);
}
else
{
xbox = xrightbox - 0.2;
xtext = xrighttext - 0.2;
}
// printf("xbox = %.2f, xtext = %.2f, av_vy = %.2f\n", xbox, xtext, av_vy);
y = YMAX - 0.1*scale;
erase_area_hsl(xbox, y + 0.025*scale, 0.25*scale, 0.05*scale, 0.0, 0.9, 0.0);
set_segment_group_color(group, 1.0, rgb);
sprintf(message, "Vx = %.4f", av_vx);
write_text(xtext + 0.1, y, message);
y -= 0.1*scale;
erase_area_hsl(xbox, y + 0.025*scale, 0.25*scale, 0.05*scale, 0.0, 0.9, 0.0);
set_segment_group_color(group, 1.0, rgb);
sprintf(message, "Vy = %.4f", av_vy);
write_text(xtext + 0.1, y, message);
y -= 0.1*scale;
erase_area_hsl(xbox, y + 0.025*scale, 0.3*scale, 0.05*scale, 0.0, 0.9, 0.0);
set_segment_group_color(group, 1.0, rgb);
sprintf(message, "V = %.4f", module2(av_vx, av_vy));
write_text(xtext + 0.1, y, message);
y -= 0.1*scale;
erase_area_hsl(xbox, y + 0.025*scale, 0.3*scale, 0.05*scale, 0.0, 0.9, 0.0);
set_segment_group_color(group, 1.0, rgb);
sprintf(message, "Omega = %.4f", av_omega);
write_text(xtext + 0.1, y, message);
}
}
void print_particles_speeds(t_particle particle[NMAXCIRCLES])
{
char message[100];
double y = YMAX - 0.1, vx = 0.0, vy = 0.0;
int i, nactive = 0;
static double xleftbox, xlefttext, xrightbox, xrighttext, ymin = YMIN + 0.05;
static int first = 1;
if (first)
{
xrightbox = XMAX - 0.39;
xrighttext = xrightbox - 0.55;
first = 0;
}
for (i=0; i<NMAXCIRCLES; i++) if (particle[i].active)
{
nactive++;
vx += particle[i].vx;
vy += particle[i].vy;
}
vx = vx/(double)nactive;
vy = vy/(double)nactive;
erase_area_hsl(xrightbox, y + 0.025, 0.35, 0.05, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Average vx = %.4f", vx);
write_text(xrighttext + 0.1, y, message);
y -= 0.1;
erase_area_hsl(xrightbox, y + 0.025, 0.35, 0.05, 0.0, 0.9, 0.0);
glColor3f(1.0, 1.0, 1.0);
sprintf(message, "Average vy = %.4f", vy);
write_text(xrighttext + 0.1, y, message);
}
double compute_boundary_force(int j, t_particle particle[NMAXCIRCLES], t_obstacle obstacle[NMAXOBSTACLES], t_segment segment[NMAXSEGMENTS], double xleft, double xright, double *pleft, double *pright, double pressure[N_PRESSURES], int wall, double krepel, int reset)
{
int i, s, k, corner, group, ngroups;
double xmin, xmax, ymin, ymax, padding, r, rp, r2, cphi, sphi, f, fperp = 0.0, x, y, xtube, distance, dx, dy, width, ybin, angle, x1, y1, x2, h, ytop, norm, dleft, dplus, dminus, tmp_pleft = 0.0, tmp_pright = 0.0, proj, pscal, pvect, pvmin, charge, d2, speed, pangle, distance1, sangle;
double group_pressure[NMAXGROUPS];
int segments_per_group[NMAXGROUPS];
short int inactivate_group[NMAXGROUPS], inactivate_segment;
static int first = 1;
static double seqangle;
if (first)
{
seqangle = PI/(double)NPOLY;
first = 0;
}
if ((OSCILLATE_OBSTACLES)&&(reset)) for (i=0; i<nobstacles; i++)
{
obstacle[i].fx = 0.0;
obstacle[i].fy = 0.0;
}
/* compute force from fixed circular obstacles */
if (ADD_FIXED_OBSTACLES) for (i=0; i<nobstacles; i++)
{
x = particle[j].xc - obstacle[i].xc;
y = particle[j].yc - obstacle[i].yc;
distance = module2(x, y);
if (distance < 1.0e-7) distance = 1.0e-7;
cphi = x/distance;
sphi = y/distance;
r2 = obstacle[i].radius + particle[j].radius;
if (distance < r2)
{
f = KSPRING_OBSTACLE*(r2 - distance);
particle[j].fx += f*cphi;
particle[j].fy += f*sphi;
if (OSCILLATE_OBSTACLES)
{
obstacle[i].fx -= f*cphi;
obstacle[i].fy -= f*sphi;
}
if (ROTATE_OBSTACLES)
{
speed = particle[j].vx*sphi - particle[j].vy*cphi;
f = KSPRING_BELT*(obstacle[i].omega*obstacle[i].radius/particle[j].mass_inv - speed);
particle[j].fx += f*sphi;
particle[j].fy -= f*cphi;
}
}
if (CHARGE_OBSTACLES)
{
charge = obstacle[i].charge*particle[k].charge;
d2 = distance*distance;
f = KCOULOMB_OBSTACLE*charge/(1.0e-12 + d2);
particle[j].fx += f*cphi;
particle[j].fy += f*sphi;
}
}
/* compute force from fixed linear obstacles */
particle[j].close_to_boundary = 0;
if (ADD_FIXED_SEGMENTS) for (i=0; i<nsegments; i++) if (segment[i].active)
{
x = particle[j].xc;
y = particle[j].yc;
proj = (segment[i].ny*(x - segment[i].x1) - segment[i].nx*(y - segment[i].y1))/segment[i].length;
if ((proj > 0.0)&&(proj < 1.0))
{
// distance = segment[i].nx*x + segment[i].ny*y - segment[i].c;
distance = segment[i].nx*x + segment[i].ny*y - segment[i].c;
/* case of interacting polygons */
// if (POLYGON_INTERACTION)
// {
// // distance = segment[i].nx*x + segment[i].ny*y - segment[i].c;
// pangle = DPI/(double)NPOLY;
// dx = 0.0;
// dy = 0.0;
// for (corner=0; corner<NPOLY; corner++)
// {
// angle = particle[j].angle + pangle*(double)corner;
// x1 = x + particle[j].radius*cos(angle);
// y1 = y + particle[j].radius*sin(angle);
// distance1 = segment[i].nx*x1 + segment[i].ny*y1 - segment[i].c;
// if (distance1 < distance)
// {
// x = x1;
// y = y1;
// distance = distance1;
// dx = x1 - particle[j].xc;
// dy = y1 - particle[j].yc;
// }
// }
// // printf("(dx, dy) = (%.3lg, %.3lg)\n", dx, dy);
// }
r = SEGMENT_FORCE_EQR*particle[j].radius;
if (vabs(distance) < r)
{
particle[j].close_to_boundary = 1;
f = KSPRING_OBSTACLE*(r - distance);
particle[j].fx += f*segment[i].nx;
particle[j].fy += f*segment[i].ny;
if ((MOVE_BOUNDARY)||(MOVE_SEGMENT_GROUPS)||(PRINT_SEGMENTS_FORCE))
{
segment[i].fx -= f*segment[i].nx;
segment[i].fy -= f*segment[i].ny;
segment[i].torque -= (x - segment[i].xc)*f*segment[i].ny - (y - segment[i].yc)*f*segment[i].nx;
}
if (SHOW_SEGMENTS_PRESSURE)
{
segment[i].pressure = f/segment[i].length;
segment[i].avrg_pressure *= (1.0 - P_AVRG_FACTOR);
segment[i].avrg_pressure += P_AVRG_FACTOR*segment[i].pressure;
// printf("Segment %i: pressure = %.3lg\n", i, segment[i].avrg_pressure);
}
if (ADD_CONVEYOR_FORCE)
{
speed = particle[j].vx*segment[i].ny - particle[j].vy*segment[i].nx;
f = KSPRING_BELT*(segment[i].conveyor_speed/particle[j].mass_inv - speed);
particle[j].fx += f*segment[i].ny;
particle[j].fy -= f*segment[i].nx;
// printf("Belt force (%.5lg, %.5lg)\n", f*segment[i].ny, -f*segment[i].nx);
}
if ((POLYGON_INTERACTION)&&(segment[i].align_torque))
{
sangle = segment[i].nangle;
particle[j].torque -= KTORQUE_BOUNDARY*sin(particle[j].spin_freq*(particle[j].angle - sangle) - seqangle);
// particle[j].torque -= KTORQUE_BOUNDARY*(dx*f*segment[i].ny - dy*f*segment[i].nx);
// printf("Torque on particle %i = %.3lg\n", j, particle[j].torque);
}
}
if ((VICSEK_INT)&&(vabs(distance) < SEGMENT_FORCE_EQR*r))
{
pvmin = 2.0;
pvect = cos(particle[j].angle)*segment[i].ny - sin(particle[j].angle)*segment[i].nx;
if ((pvect > 0.0)&&(pvect < pvmin)) pvect = pvmin;
else if ((pvect < 0.0)&&(pvect > -pvmin)) pvect = -pvmin;
// particle[j].torque += KTORQUE_BOUNDARY*pvect;
particle[j].torque += KTORQUE_BOUNDARY*pvect*(SEGMENT_FORCE_EQR*r - vabs(distance));
}
}
/* compute force from concave corners */
if (segment[i].concave)
{
distance = module2(x - segment[i].x1, y - segment[i].y1);
angle = argument(x - segment[i].x1, y - segment[i].y1);
if (angle < segment[i].angle1) angle += DPI;
/* added 24/9/22 */
else if (angle > segment[i].angle2) angle -= DPI;
r = SEGMENT_FORCE_EQR*particle[j].radius;
if ((distance < r)&&(angle > segment[i].angle1)&&(angle < segment[i].angle2))
{
f = KSPRING_OBSTACLE*(r - distance);
particle[j].fx += f*cos(angle);
particle[j].fy += f*sin(angle);
if ((MOVE_BOUNDARY)||(MOVE_SEGMENT_GROUPS))
{
segment[i].fx -= f*cos(angle);
segment[i].fy -= f*sin(angle);
segment[i].torque -= (x - segment[i].xc)*f*sin(angle) - (y - segment[i].yc)*f*cos(angle);
}
}
}
}
if (INACTIVATE_SEGMENTS_UNDER_PRESSURE)
{
ngroups = 0;
for (group=0; group<NMAXGROUPS; group++)
{
segments_per_group[group] = 0;
group_pressure[group] = 0.0;
}
for (i=0; i<nsegments; i++)
{
group = segment[i].group;
segments_per_group[group]++;
group_pressure[group] += segment[i].avrg_pressure;
if (group > ngroups) ngroups = group;
}
for (group=1; group<ngroups; group++) if (segments_per_group[group] > 0)
{
// group_pressure[group] *= 1.0/(double)segments_per_group[group];
if (group_pressure[group] > SEGMENT_P_INACTIVATE*(double)segments_per_group[group]) inactivate_group[group] = 1;
else inactivate_group[group] = 0;
}
for (i=0; i<nsegments; i++)
{
group = segment[i].group;
if ((group > 0)&&(inactivate_group[group])) segment[i].active = 0;
}
}
switch(BOUNDARY_COND){
case (BC_SCREEN):
{
/* add harmonic force outside screen */
if (particle[j].xc > XMAX) particle[j].fx -= KSPRING_BOUNDARY*(particle[j].xc - XMAX);
else if (particle[j].xc < XMIN) particle[j].fx += KSPRING_BOUNDARY*(XMIN - particle[j].xc);
if (particle[j].yc > YMAX) particle[j].fy -= KSPRING_BOUNDARY*(particle[j].yc - YMAX);
else if (particle[j].yc < YMIN) particle[j].fy += KSPRING_BOUNDARY*(YMIN - particle[j].yc);
// if (particle[j].xc > BCXMAX) particle[j].fx -= KSPRING_BOUNDARY*(particle[j].xc - BCXMAX);
// else if (particle[j].xc < BCXMIN) particle[j].fx += KSPRING_BOUNDARY*(BCXMIN - particle[j].xc);
// if (particle[j].yc > BCYMAX) particle[j].fy -= KSPRING_BOUNDARY*(particle[j].yc - BCYMAX);
// else if (particle[j].yc < BCYMIN) particle[j].fy += KSPRING_BOUNDARY*(BCYMIN - particle[j].yc);
return(fperp);
}
case (BC_RECTANGLE):
{
/* add harmonic force outside rectangular box */
padding = particle[j].radius + 0.01;
xmin = xleft + padding;
xmax = xright - padding;
ymin = BCYMIN + padding;
ymax = BCYMAX - padding;
if (particle[j].xc > xmax)
{
fperp = KSPRING_BOUNDARY*(particle[j].xc - xmax);
particle[j].fx -= fperp;
}
else if (particle[j].xc < xmin)
{
fperp = KSPRING_BOUNDARY*(xmin - particle[j].xc);
particle[j].fx += fperp;
}
if (particle[j].yc > ymax)
{
fperp = KSPRING_BOUNDARY*(particle[j].yc - ymax);
particle[j].fy -= fperp;
}
else if (particle[j].yc < ymin)
{
fperp = KSPRING_BOUNDARY*(ymin - particle[j].yc);
particle[j].fy += fperp;
}
// if (particle[j].xc > xmax) particle[j].fx -= KSPRING_BOUNDARY*(particle[j].xc - xmax);
// else if (particle[j].xc < xmin) particle[j].fx += KSPRING_BOUNDARY*(xmin - particle[j].xc);
// if (particle[j].yc > ymax) particle[j].fy -= KSPRING_BOUNDARY*(particle[j].yc - ymax);
// else if (particle[j].yc < ymin) particle[j].fy += KSPRING_BOUNDARY*(ymin - particle[j].yc);
return(fperp);
}
case (BC_CIRCLE):
{
/* add harmonic force outside screen */
if (particle[j].xc > BCXMAX) particle[j].fx -= KSPRING_BOUNDARY*(particle[j].xc - BCXMAX);
else if (particle[j].xc < BCXMIN) particle[j].fx += KSPRING_BOUNDARY*(BCXMIN - particle[j].xc);
if (particle[j].yc > BCYMAX) particle[j].fy -= KSPRING_BOUNDARY*(particle[j].yc - BCYMAX);
else if (particle[j].yc < BCYMIN) particle[j].fy += KSPRING_BOUNDARY*(BCYMIN - particle[j].yc);
/* add harmonic force from obstacle */
for (i=-2; i<2; i++)
{
x = xleft + (double)i*(OBSXMAX - OBSXMIN);
if (vabs(particle[j].xc - x) < 1.1*OBSTACLE_RADIUS)
{
r = module2(particle[j].xc - x, particle[j].yc);
if (r < 1.0e-5) r = 1.0e-05;
cphi = (particle[j].xc - x)/r;
sphi = particle[j].yc/r;
padding = MU + 0.03;
if (r < OBSTACLE_RADIUS + padding)
{
f = KSPRING_OBSTACLE*(OBSTACLE_RADIUS + padding - r);
particle[j].fx += f*cphi;
particle[j].fy += f*sphi;
}
}
}
return(fperp);
}
case (BC_PERIODIC_CIRCLE):
{
x = xleft;
if (vabs(particle[j].xc - x) < 1.1*OBSTACLE_RADIUS)
{
r = module2(particle[j].xc - x, particle[j].yc);
if (r < 1.0e-5) r = 1.0e-05;
cphi = (particle[j].xc - x)/r;
sphi = particle[j].yc/r;
padding = MU + 0.03;
if (r < OBSTACLE_RADIUS + padding)
{
f = KSPRING_OBSTACLE*(OBSTACLE_RADIUS + padding - r);
particle[j].fx += f*cphi;
particle[j].fy += f*sphi;
}
}
return(f);
}
case (BC_PERIODIC_TRIANGLE):
{
x = xleft;
x1 = x + OBSTACLE_RADIUS;
x2 = x - OBSTACLE_RADIUS;
h = 2.0*OBSTACLE_RADIUS*tanh(APOLY*PID);
padding = MU + 0.03;
// ytop = 0.5*h*(1.0 - (particle[j].xc - x)/OBSTACLE_RADIUS);
if ((vabs(particle[j].xc - x) < OBSTACLE_RADIUS + padding)&&(vabs(particle[j].yc < h + padding)))
{
/* signed distances to side of triangle */
dleft = x2 - particle[j].xc;
norm = module2(h, 2.0*OBSTACLE_RADIUS);
if (particle[j].yc >= 0.0)
{
dplus = (h*particle[j].xc + 2.0*OBSTACLE_RADIUS*particle[j].yc - h*(x+OBSTACLE_RADIUS))/norm;
if ((dleft < padding)&&(dleft > dplus)) /* left side is closer */
{
f = KSPRING_OBSTACLE*(padding - dleft);
particle[j].fx -= f;
}
else if (dplus < padding) /* top side is closer */
{
f = KSPRING_OBSTACLE*(padding - dplus);
particle[j].fx += f*h/norm;
particle[j].fy += 2.0*f*OBSTACLE_RADIUS/norm;
}
}
else
{
dminus = (h*particle[j].xc - 2.0*OBSTACLE_RADIUS*particle[j].yc - h*(x+OBSTACLE_RADIUS))/norm;
if ((dleft < padding)&&(dleft > dminus)) /* left side is closer */
{
f = KSPRING_OBSTACLE*(padding - dleft);
particle[j].fx -= f;
}
else if (dminus < padding) /* bottom side is closer */
{
f = KSPRING_OBSTACLE*(padding - dminus);
particle[j].fx += f*h/norm;
particle[j].fy += -2.0*f*OBSTACLE_RADIUS/norm;
}
}
/* force from tip of triangle */
r = module2(particle[j].xc - x1, particle[j].yc);
if (r < 0.5*padding)
{
if (r < 1.0e-5) r = 1.0e-05;
cphi = (particle[j].xc - x1)/r;
sphi = particle[j].yc/r;
f = KSPRING_OBSTACLE*(0.5*padding - r);
particle[j].fx += f*cphi;
particle[j].fy += f*sphi;
}
}
return(f);
}
case (BC_PERIODIC_FUNNEL):
{
x = xleft;
padding = MU + 0.02;
if (vabs(particle[j].yc) > FUNNEL_WIDTH - padding) for (i=-1; i<2; i+=2)
{
r = module2(particle[j].xc - x, particle[j].yc - (double)i*(FUNNEL_WIDTH + OBSTACLE_RADIUS));
if (r < 1.0e-5) r = 1.0e-05;
cphi = (particle[j].xc - x)/r;
sphi = (particle[j].yc - (double)i*(FUNNEL_WIDTH + OBSTACLE_RADIUS))/r;
if (r < OBSTACLE_RADIUS + padding)
{
f = KSPRING_OBSTACLE*(OBSTACLE_RADIUS + padding - r);
particle[j].fx += f*cphi;
particle[j].fy += f*sphi;
if (RECORD_PRESSURES)
{
angle = argument(cphi, sphi);
if (angle < 0.0) angle += DPI;
k = (int)((double)N_PRESSURES*angle/DPI);
if (k >= N_PRESSURES) k = N_PRESSURES - 1;
pressure[k] += f;
}
}
}
return(f);
}
case (BC_RECTANGLE_LID):
{
r = particle[j].radius;
if (particle[j].yc < BCYMIN + r) particle[j].fy += KSPRING_BOUNDARY*(BCYMIN + r - particle[j].yc);
else if (particle[j].yc > ylid - r)
{
fperp = KSPRING_BOUNDARY*(particle[j].yc - ylid + r);
particle[j].fy -= fperp;
}
if (particle[j].yc < BCYMAX + r)
{
if (particle[j].xc > BCXMAX - r) particle[j].fx -= KSPRING_BOUNDARY*(particle[j].xc - BCXMAX + r);
else if (particle[j].xc < BCXMIN + r) particle[j].fx += KSPRING_BOUNDARY*(BCXMIN + r - particle[j].xc);
}
return(fperp);
}
case (BC_RECTANGLE_WALL):
{
padding = particle[j].radius + 0.01;
xmin = BCXMIN + padding;
xmax = BCXMAX - padding;
ymin = BCYMIN + padding;
ymax = BCYMAX - padding;
if (particle[j].xc > xmax)
{
fperp = KSPRING_BOUNDARY*(particle[j].xc - xmax);
particle[j].fx -= fperp;
tmp_pright += fperp;
}
else if (particle[j].xc < xmin)
{
fperp = KSPRING_BOUNDARY*(xmin - particle[j].xc);
particle[j].fx += fperp;
tmp_pleft += fperp;
}
if (particle[j].yc > ymax)
{
fperp = KSPRING_BOUNDARY*(particle[j].yc - ymax);
particle[j].fy -= fperp;
if (particle[j].xc > xwall) tmp_pright += fperp;
else tmp_pleft += fperp;
}
else if (particle[j].yc < ymin)
{
fperp = KSPRING_BOUNDARY*(ymin - particle[j].yc);
particle[j].fy += fperp;
if (particle[j].xc > xwall) tmp_pright += fperp;
else tmp_pleft += fperp;
}
if (wall)
{
*pleft += tmp_pleft/(2.0*(BCYMAX - BCYMIN) + 2.0*(xwall - BCXMIN));
*pright += tmp_pright/(2.0*(BCYMAX - BCYMIN) + 2.0*(BCXMAX - xwall));
}
else
{
*pleft += tmp_pleft/(2.0*(BCYMAX - BCYMIN + BCXMAX - BCXMIN));
*pright += tmp_pright/(2.0*(BCYMAX - BCYMIN + BCXMAX - BCXMIN));
}
if ((wall)&&(vabs(particle[j].xc - xwall) < 0.5*WALL_WIDTH + padding))
{
if (particle[j].xc > xwall)
{
fperp = -KSPRING_BOUNDARY*(xwall + 0.5*WALL_WIDTH + padding - particle[j].xc);
particle[j].fx -= fperp;
*pright -= fperp/(BCYMAX - BCYMIN);
}
else
{
fperp = KSPRING_BOUNDARY*(particle[j].xc - xwall + 0.5*WALL_WIDTH + padding);
particle[j].fx -= fperp;
*pleft += fperp/(BCYMAX - BCYMIN);
}
return(fperp);
}
return(0.0);
}
case (BC_EHRENFEST):
{
rp = particle[j].radius;
xtube = 1.0 - sqrt(EHRENFEST_RADIUS*EHRENFEST_RADIUS - EHRENFEST_WIDTH*EHRENFEST_WIDTH);
distance = 0.0;
/* middle tube */
if (vabs(particle[j].xc) <= xtube)
{
if (particle[j].yc > EHRENFEST_WIDTH - rp)
{
distance = particle[j].yc - EHRENFEST_WIDTH;
particle[j].fy -= KSPRING_BOUNDARY*(distance + rp);
}
else if (particle[j].yc < -EHRENFEST_WIDTH + rp)
{
distance = - EHRENFEST_WIDTH - particle[j].yc;
particle[j].fy += KSPRING_BOUNDARY*(distance + rp);
}
}
/* right container */
else if (particle[j].xc > 0.0)
{
r = module2(particle[j].xc - 1.0, particle[j].yc);
if ((r > EHRENFEST_RADIUS - rp)&&((particle[j].xc > 1.0)||(vabs(particle[j].yc) > EHRENFEST_WIDTH)))
{
cphi = (particle[j].xc - 1.0)/r;
sphi = particle[j].yc/r;
f = KSPRING_BOUNDARY*(EHRENFEST_RADIUS - r - rp);
particle[j].fx += f*cphi;
particle[j].fy += f*sphi;
*pright -= f;
}
}
/* left container */
else
{
r = module2(particle[j].xc + 1.0, particle[j].yc);
if ((r > EHRENFEST_RADIUS - rp)&&((particle[j].xc < -1.0)||(vabs(particle[j].yc) > EHRENFEST_WIDTH)))
{
cphi = (particle[j].xc + 1.0)/r;
sphi = particle[j].yc/r;
f = KSPRING_BOUNDARY*(EHRENFEST_RADIUS - r - rp);
particle[j].fx += f*cphi;
particle[j].fy += f*sphi;
*pleft -= f;
}
}
/* add force from "corners" */
if ((vabs(particle[j].xc) - xtube < rp)&&(vabs(particle[j].yc) - EHRENFEST_WIDTH < rp))
{
for (i=-1; i<=1; i+=2)
for (k=-1; k<=1; k+=2)
{
distance = module2(particle[j].xc - (double)i*xtube, particle[j].yc - (double)k*EHRENFEST_WIDTH);
if (distance < rp)
{
cphi = (particle[j].xc - (double)i*xtube)/distance;
sphi = (particle[j].yc - (double)k*EHRENFEST_WIDTH)/distance;
f = KSPRING_BOUNDARY*(rp - distance);
particle[j].fx += f*cphi;
particle[j].fy += f*sphi;
}
}
}
return(fperp);
}
case (BC_SCREEN_BINS):
{
/* add harmonic force outside screen */
if (particle[j].xc > XMAX) particle[j].fx -= KSPRING_BOUNDARY*(particle[j].xc - XMAX);
else if (particle[j].xc < XMIN) particle[j].fx += KSPRING_BOUNDARY*(XMIN - particle[j].xc);
if (particle[j].yc > YMAX + 10.0*MU) particle[j].fy -= KSPRING_BOUNDARY*(particle[j].yc - YMAX - 10.0*MU);
else if (particle[j].yc < YMIN) particle[j].fy += KSPRING_BOUNDARY*(YMIN - particle[j].yc);
/* force from the bins */
dy = (YMAX - YMIN)/((double)NGRIDX + 3);
dx = dy/cos(PI/6.0);
rp = particle[j].radius;
width = rp + 0.05*dx;
ybin = 2.75*dy;
if (particle[j].yc < YMIN + ybin) for (i=-1; i<=NGRIDX; i++)
{
x = ((double)i - 0.5*(double)NGRIDX + 0.5)*dx;
distance = vabs(particle[j].xc - x);
if (distance < width)
{
if (particle[j].xc > x) particle[j].fx += KSPRING_BOUNDARY*(width - distance);
else particle[j].fx -= KSPRING_BOUNDARY*(width - distance);
}
}
else if (particle[j].yc < YMIN + ybin + particle[j].radius) for (i=-1; i<=NGRIDX; i++)
{
x = ((double)i - 0.5*(double)NGRIDX + 0.5)*dx;
distance = module2(particle[j].xc - x, particle[j].yc - YMIN - ybin);
if (distance < rp)
{
if (distance < 1.0e-8) distance = 1.0e-8;
cphi = (particle[j].xc - x)/distance;
sphi = (particle[j].yc - YMIN - ybin)/distance;
f = KSPRING_BOUNDARY*(rp - distance);
particle[j].fx += f*cphi;
particle[j].fy += f*sphi;
}
}
return(fperp);
}
case (BC_ABSORBING):
{
/* add harmonic force outside screen */
padding = 0.1;
x = particle[j].xc;
y = particle[j].yc;
if ((x > BCXMAX + padding)||(x < BCXMIN - padding)||(y > BCYMAX + padding)||(y < BCYMIN - padding))
{
particle[j].active = 0;
particle[j].vx = 0.0;
particle[j].vy = 0.0;
particle[j].xc = BCXMAX + 2.0*padding;
particle[j].yc = BCYMAX + 2.0*padding;
}
return(fperp);
}
case (BC_REFLECT_ABS):
{
/* add harmonic force outside screen */
padding = 0.1;
x = particle[j].xc;
y = particle[j].yc;
if ((x > BCXMAX + padding)||(y > BCYMAX + padding)||(y < BCYMIN - padding))
{
particle[j].active = 0;
particle[j].vx = 0.0;
particle[j].vy = 0.0;
particle[j].xc = BCXMAX + 2.0*padding;
particle[j].yc = BCYMAX + 2.0*padding;
}
else if (particle[j].yc < BCYMIN) particle[j].fy += KSPRING_BOUNDARY*(BCYMIN - particle[j].yc);
return(fperp);
}
case (BC_REFLECT_ABS_BOTTOM):
{
/* add harmonic force outside screen */
padding = MU;
x = particle[j].xc;
y = particle[j].yc;
if (y < BCYMIN)
{
particle[j].active = 0;
particle[j].vx = 0.0;
particle[j].vy = 0.0;
particle[j].xc = BCXMAX + 2.0*padding;
particle[j].yc = BCYMIN - 2.0*padding;
}
else
{
if (y > BCYMAX + padding) particle[j].fy -= KSPRING_BOUNDARY*(y - BCYMAX - padding);
if (x > BCXMAX - padding) particle[j].fx -= KSPRING_BOUNDARY*(x - BCXMAX + padding);
else if (x < BCXMIN + padding) particle[j].fx += KSPRING_BOUNDARY*(BCXMIN - x + padding);
}
return(0.0);
}
case (BC_REFLECT_ABS_RIGHT):
{
/* add harmonic force outside screen */
padding = MU;
x = particle[j].xc;
y = particle[j].yc;
if (x > BCXMAX + padding)
{
particle[j].active = 0;
particle[j].vx = 0.0;
particle[j].vy = 0.0;
particle[j].xc = BCXMAX + 2.0*padding;
particle[j].yc = BCYMIN - 2.0*padding;
}
else
{
if (y > BCYMAX - padding) particle[j].fy -= KSPRING_BOUNDARY*(y - BCYMAX + padding);
else if (y < BCYMIN + padding) particle[j].fy += KSPRING_BOUNDARY*(BCYMIN - y + padding);
if (x < BCXMIN + padding) particle[j].fx += KSPRING_BOUNDARY*(BCXMIN - x + padding);
}
return(0.0);
}
}
}
void dissociate_particles_findp(int i, int j, t_particle particle[NMAXCIRCLES])
/* dissociate partnered particles i and j */
{
int np, nq, r, p, q;
np = particle[i].npartners;
nq = particle[j].npartners;
/* find which partner of j is particle i */
p = 0;
while ((particle[i].partner[p] != j)&&(p < np)) p++;
/* remove partner p from partner list */
for (q=p; q<np-1; q++)
particle[i].partner[q] = particle[i].partner[q+1];
particle[i].npartners--;
/* find which partner of j is particle i */
q = 0;
while ((particle[j].partner[q] != i)&&(q < nq)) q++;
/* remove partner q from partner list */
for (r=q; r<nq-1; r++)
particle[j].partner[r] = particle[j].partner[r+1];
particle[j].npartners--;
}
void dissociate_particles(int i, int j, int p, t_particle particle[NMAXCIRCLES])
/* dissociate partnered particles i and j */
/* assuming j is pth partner of i */
{
int np, nq, r, q;
np = particle[i].npartners;
nq = particle[j].npartners;
/* remove partner p from partner list */
for (q=p; q<np-1; q++)
particle[i].partner[q] = particle[i].partner[q+1];
particle[i].npartners--;
/* find which partner of j is particle i */
q = 0;
while ((particle[j].partner[q] != i)&&(q < nq)) q++;
/* remove partner q from partner list */
for (r=q; r<nq-1; r++)
particle[j].partner[r] = particle[j].partner[r+1];
particle[j].npartners--;
}
void dissociate_molecule(int i, int j, t_particle particle[NMAXCIRCLES])
/* dissociate all particles in molecule containing particles i and j */
{
int np, nq, p, q, n;
np = particle[i].npartners;
nq = particle[j].npartners;
particle[i].npartners = 0;
particle[j].npartners = 0;
particle[i].vx = 0.0;
particle[i].vy = 0.0;
particle[i].thermostat = 1;
particle[j].vx = 0.0;
particle[j].vy = 0.0;
particle[j].thermostat = 1;
for (p=0; p<np; p++)
{
n = particle[i].partner[p];
particle[n].npartners = 0;
particle[n].vx = 0.0;
particle[n].vy = 0.0;
particle[n].thermostat = 1;
}
for (q=0; q<nq; q++)
{
n = particle[j].partner[q];
particle[n].npartners = 0;
particle[n].vx = 0.0;
particle[n].vy = 0.0;
particle[n].thermostat = 1;
}
}
void compute_partner_force(int j, int n, double eq_distance, double eq_angle, double f[2], double *torque, t_particle particle[NMAXCIRCLES])
/* compute force of partner particle n on particle j */
{
double dx, dy, r, ca, sa, force, sangle, torque2;
double x1, x2, y1, y2, rmax, alpha, cosa, rj, rn, phi;
int p, q;
dx = particle[n].xc - particle[j].xc;
dy = particle[n].yc - particle[j].yc;
if (dx > 0.5*(BCXMAX - BCXMIN)) dx -= (BCXMAX-BCXMIN);
else if (dx < -0.5*(BCXMAX - BCXMIN)) dx += (BCXMAX-BCXMIN);
if (dy > 0.5*(BCYMAX - BCYMIN)) dy -= (BCYMAX-BCYMIN);
else if (dy < -0.5*(BCYMAX - BCYMIN)) dy += (BCYMAX-BCYMIN);
if ((PAIR_PARTICLES)&&(PAIRING_TYPE == POLY_SEG_POLYGON))
{
rmax = 1.0*particle[j].radius;
for (p=-1; p<=1; p+=2)
for (q=-1; q<=1; q+=2)
{
x1 = particle[n].xc + (double)p*particle[n].radius*cos(particle[n].angle);
y1 = particle[n].yc + (double)p*particle[n].radius*sin(particle[n].angle);
x2 = particle[j].xc + (double)q*particle[n].radius*cos(particle[j].angle);
y2 = particle[j].yc + (double)q*particle[n].radius*sin(particle[j].angle);
r = module2(x2-x1, y2-y1);
if ((r>0.0)&&(r < rmax))
{
// f[0] += KSPRING_PAIRS*(x1-x2)/r;
// f[1] += KSPRING_PAIRS*(y1-y2)/r;
f[0] = 1.0e8*(x1-x2)/r;
f[1] = 1.0e8*(y1-y2)/r;
}
}
}
// else
{
r = module2(dx, dy);
if (r < 1.0e-10) r = 1.0e-10;
if (r > 2.0*eq_distance) r = 2.0*eq_distance;
// if (r > 1.5*eq_distance) r = 1.5*eq_distance;
ca = dx/r;
sa = dy/r;
/* TODO: adjust max distance */
if (r < 1.5*eq_distance) force = KSPRING_PAIRS*(r - eq_distance);
else
{
// printf("Dissociating partners %i and %i because max distance exceeded\n", j, n);
force = 0.0;
// dissociate_particles_findp(j, n, particle);
// dissociate_molecule(j, n, particle);
}
f[0] = force*ca;
f[1] = force*sa;
/* TEST */
f[0] -= particle[j].vx*DAMPING;
f[1] -= particle[j].vy*DAMPING;
}
if (ROTATION)
{
*torque = 0.0;
if ((REACTION_DIFFUSION)&&(RD_REACTION == CHEM_POLYGON_AGGREGATION))
{
// r = module2(dx, dy);
// if (r < 2.0*MU)
// {
// if (NPOLY%2 == 0)
// sangle = sin((double)NPOLY*(particle[n].angle - particle[j].angle));
// else sangle = sin((double)NPOLY*(particle[n].angle - particle[j].angle) - PI);
// sangle = sin((double)NPOLY*(particle[n].angle - particle[j].angle - eq_angle));
// *torque += KTORQUE_PAIRS*sangle;
/* stabilize relative angle */
q = particle[j].partner[0];
if ((particle[j].npartners == 1)&&(particle[q].npartners == 1))
{
sangle = sin((double)NPOLY*(particle[n].angle - particle[j].angle - eq_angle));
*torque += KTORQUE_PAIRS*sangle;
phi = argument(dx, dy);
sangle = sin((double)NPOLY*(phi - particle[j].angle) - PI);
*torque += KTORQUE_PAIRS*sangle;
}
/* TEST: add some damping to rotation */
*torque -= particle[j].omega*DAMPING_ROT;
// sangle = sin((double)NPOLY*(phi - particle[j].angle) - PI);
// *torque += KTORQUE_PAIRS*sangle;
// }
}
else if ((PAIR_PARTICLES)&&(PAIRING_TYPE == POLY_SEG_POLYGON))
{
/* TODO */
sangle = sin(particle[n].angle - particle[j].angle - eq_angle);
// if (sangle > 0.0) *torque = KTORQUE_PAIRS*(1.0 + sangle);
// else *torque = KTORQUE_PAIRS*(-1.0 + sangle);
*torque = KTORQUE_PAIRS*sangle;
// *torque = 0.0;
// if (COMPUTE_PAIR_TORQUE)
// {
// torque2 = KTORQUE_PAIR_ANGLE*sangle;
// f[0] -= torque2*sa;
// f[1] += torque2*ca;
// }
}
else
{
sangle = sin(SPIN_INTER_FREQUENCY*(particle[n].angle - particle[j].angle));
if (sangle > 0.0) *torque = KTORQUE_PAIRS*(1.0 + sangle);
else *torque = KTORQUE_PAIRS*(-1.0 + sangle);
if (COMPUTE_PAIR_TORQUE)
{
torque2 = KTORQUE_PAIR_ANGLE*sangle;
f[0] -= torque2*sa;
f[1] += torque2*ca;
}
}
}
}
void compute_particle_force(int j, double krepel, t_particle particle[NMAXCIRCLES], t_hashgrid hashgrid[HASHX*HASHY])
/* compute force from other particles on particle j */
{
int i0, j0, m0, k, l, m, q, close, n, test, different_cluster = 1;
double fx = 0.0, fy = 0.0, force[2], torque = 0.0, torque_ij, x, y;
particle[j].neighb = 0;
if (REACTION_DIFFUSION) particle[j].diff_neighb = 0;
for (k=0; k<particle[j].hash_nneighb; k++)
{
n = particle[j].hashneighbour[k];
if (CLUSTER_PARTICLES) /* test whether n is not in the same cluster */
different_cluster = (particle[n].cluster != particle[j].cluster);
else different_cluster = 1;
if ((particle[n].active)&&(different_cluster))
{
if (PAIR_FORCE)
{
/* test whether n is not a partner particle */
test = 1;
for (l=0; l<particle[n].npartners; l++)
if (particle[n].partner[l] == j) test = 0;
if (test)
{
close = compute_repelling_force(j, k, force, &torque_ij, particle, krepel);
fx += force[0];
fy += force[1];
torque += torque_ij;
if (close)
{
particle[j].neighb++;
if (REACTION_DIFFUSION&&(particle[j].type != particle[particle[j].hashneighbour[k]].type))
particle[j].diff_neighb++;
}
}
}
else
{
close = compute_repelling_force(j, k, force, &torque_ij, particle, krepel);
fx += force[0];
fy += force[1];
torque += torque_ij;
if (close)
{
particle[j].neighb++;
if (REACTION_DIFFUSION&&(particle[j].type != particle[particle[j].hashneighbour[k]].type))
particle[j].diff_neighb++;
}
}
}
}
if (PAIR_FORCE) for (l=0; l<particle[j].npartners; l++)
{
n = particle[j].partner[l];
if ((!CLUSTER_PARTICLES)||(particle[n].cluster != particle[j].cluster))
{
compute_partner_force(j, n, particle[j].partner_eqd[l], particle[j].partner_eqa[l], force, &torque_ij, particle);
fx += force[0];
fy += force[1];
torque += torque_ij;
}
}
particle[j].fx += fx;
particle[j].fy += fy;
particle[j].torque += torque;
}
int reorder_particles(t_particle particle[NMAXCIRCLES], double py[NMAXCIRCLES], double pangle[NMAXCIRCLES])
/* keep only active particles, beta */
{
int i, k, new = 0, nactive = 0;
for (i=0; i<ncircles; i++) if (particle[i].active)
{
particle[new].xc = particle[i].xc;
particle[new].yc = particle[i].yc;
particle[new].radius = particle[i].radius;
particle[new].angle = particle[i].angle;
particle[new].active = particle[i].active;
particle[new].energy = particle[i].energy;
particle[new].vx = particle[i].vx;
particle[new].vy = particle[i].vy;
particle[new].omega = particle[i].omega;
particle[new].mass_inv = particle[i].mass_inv;
particle[new].inertia_moment_inv = particle[i].inertia_moment_inv;
particle[new].fx = particle[i].fx;
particle[new].fy = particle[i].fy;
particle[new].thermostat = particle[i].thermostat;
particle[new].hashcell = particle[i].hashcell;
particle[new].neighb = particle[i].neighb;
particle[new].diff_neighb = particle[i].diff_neighb;
particle[new].hash_nneighb = particle[i].hash_nneighb;
particle[new].type = particle[i].type;
particle[new].interaction = particle[i].interaction;
particle[new].eq_dist = particle[i].eq_dist;
particle[new].spin_range = particle[i].spin_range;
particle[new].spin_freq = particle[i].spin_freq;
py[new] = py[i];
pangle[new] = pangle[i];
for (k=0; k<9*HASHMAX; k++)
{
particle[new].hashneighbour[k] = particle[i].hashneighbour[k];
particle[new].deltax[k] = particle[i].deltax[k];
particle[new].deltay[k] = particle[i].deltay[k];
}
new++;
nactive++;
}
return(nactive);
}
int twotype_config(int i, t_particle particle[NMAXCIRCLES])
/* assign different particle types */
{
switch (TWOTYPE_CONFIG) {
case (TTC_RANDOM): return((double)rand()/RAND_MAX > TYPE_PROPORTION);
case (TTC_CHESSBOARD):
{
switch (CIRCLE_PATTERN) {
case (C_SQUARE): return((i%NGRIDY + i/NGRIDY)%2 == 0);
case (C_HEX): return(i%2 == 0);
default: return(i%2 == 0);
}
}
case (TTC_COANDA):
{
if (vabs(particle[i].yc) < LAMBDA) return(1);
if (vabs(particle[i].yc) < LAMBDA + MU) return(-1);
return(0);
}
default: return(0);
}
}
int initialize_configuration(t_particle particle[NMAXCIRCLES], t_hashgrid hashgrid[HASHX*HASHY], t_obstacle obstacle[NMAXOBSTACLES], double px[NMAXCIRCLES], double py[NMAXCIRCLES], double pangle[NMAXCIRCLES], int tracer_n[N_TRACER_PARTICLES],
t_segment segment[NMAXSEGMENTS], t_molecule molecule[NMAXCIRCLES])
/* initialize all particles, obstacles, and the hashgrid */
{
int i, j, k, n, type, nactive = 0, hashcell;
double x, y, h, xx, yy, rnd, angle;
for (i=0; i < ncircles; i++)
{
/* set particle type */
particle[i].type = 0;
// if ((TWO_TYPES)&&((double)rand()/RAND_MAX > TYPE_PROPORTION))
// if ((TWO_TYPES)&&(twotype_config(i, particle)))
if (TWO_TYPES)
{
type = twotype_config(i, particle);
if (type == 1)
{
particle[i].type = 1;
// particle[i].type = 2;
particle[i].radius = MU_B;
}
else if (type == -1) particle[i].active = 0;
}
if ((INTERACTION == I_VICSEK_SHARK)&&(i==1))
{
particle[i].type = 2;
particle[i].radius = MU_B;
}
particle[i].neighb = 0;
particle[i].diff_neighb = 0;
particle[i].thermostat = 1;
particle[i].close_to_boundary = 0;
particle[i].emean = 0.0;
particle[i].damping = 1.0;
particle[i].dirmean = 0.0;
particle[i].paired = 0;
particle[i].collision = 0;
// particle[i].added = 0;
// particle[i].coulomb = 1;
// particle[i].energy = 0.0;
// y = particle[i].yc;
// if (y >= YMAX) y -= particle[i].radius;
// if (y <= YMIN) y += particle[i].radius;
if (RANDOM_RADIUS) particle[i].radius = particle[i].radius*(RANDOM_RADIUS_MIN + RANDOM_RADIUS_RANGE*((double)rand()/RAND_MAX));
if (particle[i].type == 0)
{
particle[i].interaction = INTERACTION;
particle[i].eq_dist = EQUILIBRIUM_DIST;
particle[i].spin_range = SPIN_RANGE;
particle[i].spin_freq = SPIN_INTER_FREQUENCY;
particle[i].mass_inv = 1.0/PARTICLE_MASS;
if ((RANDOM_RADIUS)&&(ADAPT_MASS_TO_RADIUS > 0.0))
particle[i].mass_inv *= 1.0/(1.0 + pow(particle[i].radius/MU, ADAPT_MASS_TO_RADIUS));
if ((RANDOM_RADIUS)&&(ADAPT_DAMPING_TO_RADIUS > 0.0))
particle[i].damping = 1.0 + ADAPT_DAMPING_FACTOR*pow(particle[i].radius/MU, ADAPT_DAMPING_TO_RADIUS);
particle[i].inertia_moment_inv = 1.0/PARTICLE_INERTIA_MOMENT;
particle[i].charge = CHARGE;
}
else
{
particle[i].interaction = INTERACTION_B;
particle[i].eq_dist = EQUILIBRIUM_DIST_B;
particle[i].spin_range = SPIN_RANGE_B;
particle[i].spin_freq = SPIN_INTER_FREQUENCY_B;
particle[i].mass_inv = 1.0/PARTICLE_MASS_B;
particle[i].inertia_moment_inv = 1.0/PARTICLE_INERTIA_MOMENT_B;
particle[i].charge = CHARGE_B;
}
switch (V_INITIAL_TYPE)
{
case (VI_RANDOM):
{
particle[i].vx = V_INITIAL*gaussian();
particle[i].vy = V_INITIAL*gaussian();
break;
}
case (VI_COANDA):
{
if (vabs(particle[i].yc) < LAMBDA) particle[i].vx = V_INITIAL;
else particle[i].vx = 0.0;
particle[i].vy = 0.0;
break;
}
}
if ((INTERACTION == I_VICSEK_SHARK)&&(i==1))
{
particle[i].vx *= 1000.0;
particle[i].vy *= 1000.0;
}
particle[i].energy = (particle[i].vx*particle[i].vx + particle[i].vy*particle[i].vy)*particle[i].mass_inv;
particle[i].emean = particle[i].energy;
particle[i].dirmean = 0.0;
px[i] = particle[i].vx;
py[i] = particle[i].vy;
if (ROTATION)
{
particle[i].angle = DPI*(double)rand()/RAND_MAX;
particle[i].omega = OMEGA_INITIAL*gaussian();
if (COUPLE_ANGLE_TO_THERMOSTAT)
particle[i].energy += particle[i].omega*particle[i].omega*particle[i].inertia_moment_inv;
}
else
{
particle[i].angle = 0.0;
particle[i].omega = 0.0;
}
pangle[i] = particle[i].omega;
if ((PLOT == P_INITIAL_POS)||(PLOT_B == P_INITIAL_POS))
{
switch (INITIAL_POS_TYPE) {
case (IP_X):
{
particle[i].color_hue = 360.0*(particle[i].xc - INITXMIN)/(INITXMAX - INITXMIN);
break;
}
case (IP_Y):
{
particle[i].color_hue = 360.0*(particle[i].yc - INITYMIN)/(INITYMAX - INITYMIN);
break;
}
}
}
if ((PLOT == P_NUMBER)||(PLOT_B == P_NUMBER))
particle[i].color_hue = 360.0*(double)(i%N_PARTICLE_COLORS)/(double)N_PARTICLE_COLORS;
// if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
{
if (PAIR_PARTICLES) particle[i].cluster = rand()%(ncircles*CLUSTER_COLOR_FACTOR);
else particle[i].cluster = rand()%ncircles;
}
}
/* initialize dummy values in case particles are added */
for (i=ncircles; i < NMAXCIRCLES; i++)
{
particle[i].type = 0;
particle[i].active = 0;
particle[i].neighb = 0;
particle[i].thermostat = 0;
particle[i].energy = 0.0;
particle[i].emean = 0.0;
particle[i].damping = 1.0;
particle[i].dirmean = 0.0;
particle[i].mass_inv = 1.0/PARTICLE_MASS;
particle[i].inertia_moment_inv = 1.0/PARTICLE_INERTIA_MOMENT;
particle[i].charge = 0.0;
particle[i].vx = 0.0;
particle[i].vy = 0.0;
px[i] = 0.0;
py[i] = 0.0;
particle[i].angle = DPI*(double)rand()/RAND_MAX;
particle[i].omega = 0.0;
pangle[i] = 0.0;
particle[i].interaction = INTERACTION;
particle[i].eq_dist = EQUILIBRIUM_DIST;
particle[i].spin_range = SPIN_RANGE;
particle[i].spin_freq = SPIN_INTER_FREQUENCY;
particle[i].close_to_boundary = 0;
particle[i].coulomb = 1;
particle[i].added = 1;
particle[i].reactive = 1;
particle[i].paired = 0;
particle[i].collision = 0;
}
/* add particles at the bottom as seed */
if (PART_AT_BOTTOM) for (i=0; i<=NPART_BOTTOM; i++)
{
x = XMIN + (double)i*(XMAX - XMIN)/(double)NPART_BOTTOM;
y = YMIN + 2.0*MU;
add_particle(x, y, 0.0, 0.0, MASS_PART_BOTTOM, 0, particle);
}
if (PART_AT_BOTTOM) for (i=0; i<=NPART_BOTTOM; i++)
{
x = XMIN + (double)i*(XMAX - XMIN)/(double)NPART_BOTTOM;
y = YMIN + 4.0*MU;
add_particle(x, y, 0.0, 0.0, MASS_PART_BOTTOM, 0, particle);
}
/* add larger copies of particles (for Ehrenfest model)*/
if (EHRENFEST_COPY)
{
for (i=0; i < ncircles; i++)
{
n = ncircles + i;
particle[n].xc = -particle[i].xc;
particle[n].yc = particle[i].yc;
particle[n].vx = -0.5*particle[i].vx;
particle[n].vy = 0.5*particle[i].vy;
px[n] = -0.5*px[i];
py[n] = 0.5*py[i];
particle[n].energy = particle[i].energy;
particle[n].radius = 2.0*particle[i].radius;
particle[n].type = 2;
particle[n].mass_inv = 1.25*particle[i].mass_inv;
particle[n].thermostat = 1;
particle[n].interaction = particle[i].interaction;
particle[n].eq_dist = 0.45*particle[i].eq_dist;
if ((double)rand()/RAND_MAX > 0.6) particle[n].active = 1;
}
ncircles *= 2;
}
/* change type of tracer particle */
if (TRACER_PARTICLE) for (j=0; j<n_tracers; j++)
{
i = 0;
if (j%2==0) xx = 1.0;
else xx = -1.0;
if (j/2 == 0) yy = -0.5;
else yy = 0.5;
// if (j%2 == 1) yy = -yy;
// while ((!particle[i].active)||(module2(particle[i].xc, particle[i].yc) > 0.5)) i++;
while ((!particle[i].active)||(module2(particle[i].xc + xx, particle[i].yc - yy) > 0.4)) i++;
tracer_n[j] = i;
particle[i].type = 2 + j;
particle[i].radius *= 1.5;
particle[i].mass_inv *= 1.0/TRACER_PARTICLE_MASS;
particle[i].vx *= 0.1;
particle[i].vy *= 0.1;
particle[i].thermostat = 0;
px[i] *= 0.1;
py[i] *= 0.1;
n_tracers++;
}
/* position-dependent particle type */
if (POSITION_DEPENDENT_TYPE) for (i=0; i<ncircles; i++)
if (((!POSITION_Y_DEPENDENCE)&&((particle[i].xc - POSITION_DEP_X)*POSITION_DEP_SIGN < 0.0))||((POSITION_Y_DEPENDENCE)&&(particle[i].yc*POSITION_DEP_SIGN < 0.0)))
{
particle[i].type = 2;
particle[i].mass_inv = 1.0/PARTICLE_MASS_B;
particle[i].radius = MU_B;
}
/* add copies in case of particle pairing */
if (PAIR_PARTICLES) init_particle_pairs(particle, molecule);
/* inactivate particles in obstacle */
printf("Inactivating particles inside obstacles\n");
if ((BOUNDARY_COND == BC_CIRCLE)||(BOUNDARY_COND == BC_PERIODIC_CIRCLE))
{
for (i=0; i< ncircles; i++)
if ((module2(particle[i].xc - OBSTACLE_XMIN, particle[i].yc) < 1.2*OBSTACLE_RADIUS))
particle[i].active = 0;
}
else if (BOUNDARY_COND == BC_PERIODIC_FUNNEL)
{
for (i=0; i< ncircles; i++)
for (k=-1; k<2; k+=2)
if ((module2(particle[i].xc, particle[i].yc - (double)k*(FUNNEL_WIDTH + OBSTACLE_RADIUS)) < OBSTACLE_RADIUS + 2.0*MU))
{
printf("Inactivating particle at (%.3lg, %.3lg)\n", particle[i].xc, particle[i].yc);
particle[i].active = 0;
}
}
else if (BOUNDARY_COND == BC_PERIODIC_TRIANGLE)
{
h = 2.0*OBSTACLE_RADIUS*tan(APOLY*PID);
for (i=0; i< ncircles; i++)
if ((vabs(particle[i].xc) < 1.1*OBSTACLE_RADIUS + 2.0*MU)
&&(2.0*OBSTACLE_RADIUS*vabs(particle[i].yc) < h*(OBSTACLE_RADIUS + 2.0*MU - particle[i].xc)))
{
printf("Inactivating particle at (%.3lg, %.3lg)\n", particle[i].xc, particle[i].yc);
particle[i].active = 0;
}
}
else if (BOUNDARY_COND == BC_EHRENFEST)
{
for (i=0; i< ncircles; i++)
if (module2(vabs(particle[i].xc) -1.0, particle[i].yc) > EHRENFEST_RADIUS)
particle[i].active = 0;
}
else if (BOUNDARY_COND == BC_RECTANGLE_WALL)
{
for (i=0; i< ncircles; i++)
if (vabs(particle[i].xc - xwall) < WALL_WIDTH)
particle[i].active = 0;
}
else if (BOUNDARY_COND == BC_GENUS_TWO)
{
for (i=0; i< ncircles; i++)
if ((particle[i].xc > 0.0)&&(particle[i].yc > 0.0))
particle[i].active = 0;
}
if (ADD_FIXED_OBSTACLES)
{
for (i=0; i< ncircles; i++) for (j=0; j < nobstacles; j++)
{
if (module2(particle[i].xc - obstacle[j].xc, particle[i].yc - obstacle[j].yc) < OBSTACLE_RADIUS + particle[i].radius)
particle[i].active = 0;
hashcell = hash_cell(obstacle[j].xc, obstacle[j].yc);
hashgrid[hashcell].charge = OBSTACLE_CHARGE;
}
}
/* case of segment obstacles */
if (ADD_FIXED_SEGMENTS) for (i=0; i< ncircles; i++)
if (!in_segment_region(particle[i].xc, particle[i].yc, segment))
particle[i].active = 0;
/* case of reaction-diffusion equation/chemical reactions */
if (REACTION_DIFFUSION) for (i=0; i< ncircles; i++)
{
switch (RD_INITIAL_COND) {
case (IC_UNIFORM):
{
particle[i].type = 1;
break;
}
case (IC_UNIFORM2):
{
particle[i].type = 2;
particle[i].radius = MU_B;
particle[i].omega = OMEGA_INITIAL*gaussian();
break;
}
case (IC_RANDOM_UNIF):
{
particle[i].type = 1 + (int)(RD_TYPES*(double)rand()/(double)RAND_MAX);
break;
}
case (IC_RANDOM_TWO):
{
if ((double)rand()/(double)RAND_MAX < TYPE_PROPORTION) particle[i].type = 1;
else
{
particle[i].type = 2;
particle[i].radius = MU_B;
particle[i].mass_inv = 1.0/PARTICLE_MASS_B;
}
break;
}
case (IC_CIRCLE):
{
if (module2(particle[i].xc,particle[i].yc) < LAMBDA) particle[i].type = 1;
else
{
particle[i].type = 2;
particle[i].radius = MU_B;
particle[i].mass_inv = 1.0/PARTICLE_MASS_B;
}
break;
}
case (IC_CATALYSIS):
{
if ((particle[i].xc > 0.0)||((double)rand()/(double)RAND_MAX < TYPE_PROPORTION))
{
particle[i].type = 1;
particle[i].radius = MU;
particle[i].mass_inv = 1.0/PARTICLE_MASS;
}
else
{
particle[i].type = 2;
particle[i].radius = MU_B;
particle[i].mass_inv = 1.0/PARTICLE_MASS_B;
}
break;
}
case (IC_LAYERS):
{
if (particle[i].yc > 0.0)
{
particle[i].type = 1;
particle[i].radius = MU;
particle[i].eq_dist = EQUILIBRIUM_DIST;
particle[i].mass_inv = 1.0/PARTICLE_MASS;
}
else if (particle[i].yc < -LAMBDA)
{
particle[i].type = 2;
particle[i].radius = MU_B;
particle[i].eq_dist = EQUILIBRIUM_DIST_B;
particle[i].mass_inv = 1.0/PARTICLE_MASS_B;
}
else particle[i].active = 0;
break;
}
case (IC_BZ):
{
rnd = (double)rand()/(double)RAND_MAX;
if (rnd < 60.0/180.0)
{
particle[i].type = 4;
particle[i].radius = MU;
particle[i].eq_dist = EQUILIBRIUM_DIST;
particle[i].mass_inv = 1.0/(PARTICLE_MASS + 3.0*PARTICLE_MASS_B);
}
else if (rnd < 100.0/180.0)
{
particle[i].type = 5;
particle[i].radius = MU_B;
particle[i].eq_dist = EQUILIBRIUM_DIST;
particle[i].mass_inv = 1.0/(3.5*PARTICLE_MASS);
}
else
{
particle[i].type = 6;
particle[i].radius = 1.5*MU_B;
particle[i].eq_dist = EQUILIBRIUM_DIST;
particle[i].mass_inv = 0.2/(PARTICLE_MASS);
}
break;
}
case (IC_SIGNX):
{
if (particle[i].xc < 0.0) particle[i].type = 1;
else
{
particle[i].type = 2;
particle[i].radius = MU_B;
particle[i].mass_inv = 1.0/PARTICLE_MASS_B;
}
break;
}
case (IC_TWOROCKETS):
{
if (vabs(particle[i].xc) < SEGMENTS_X0) particle[i].type = 1;
else
{
particle[i].type = 2;
particle[i].radius = MU_B;
particle[i].mass_inv = 1.0/PARTICLE_MASS_B;
}
break;
}
case (IC_TWOROCKETS_TWOFUELS):
{
if (vabs(particle[i].xc) < SEGMENTS_X0) particle[i].type = 1;
else
{
if (particle[i].xc < 0) particle[i].type = 2;
else particle[i].type = 3;
particle[i].radius = MU_B;
particle[i].mass_inv = 1.0/PARTICLE_MASS_B;
}
break;
}
case (IC_DNA_POLYMERASE):
{
/* do nothing? */
break;
}
case (IC_DNA_POLYMERASE_REC):
{
/* do nothing? */
break;
}
default:
{
/* do nothing */
}
}
}
/* keep only active particles */
// ncircles = reorder_particles(particle, py, pangle);
/* count number of active particles */
for (i=0; i< ncircles; i++) nactive += particle[i].active;
printf("%i active particles\n", nactive);
// for (i=0; i<ncircles; i++) printf("particle %i of type %i\n", i, particle[i].type);
return(nactive);
}
int add_particles(t_particle particle[NMAXCIRCLES], double px[NMAXCIRCLES], double py[NMAXCIRCLES], int nadd_particle, int type, t_molecule molecule[NMAXCIRCLES],
int tracer_n[N_TRACER_PARTICLES])
/* add several particles to the system */
{
static int i = 0;
double x, y, r, phi;
printf("Adding a particle\n\n");
switch (ADD_REGION) {
case (ADD_RECTANGLE) :
{
x = ADDXMIN + (ADDXMAX - ADDXMIN)*(double)rand()/(double)RAND_MAX;
y = ADDYMIN + (ADDYMAX - ADDYMIN)*(double)rand()/(double)RAND_MAX;
break;
}
case (ADD_RING) :
{
r = ADDRMIN + (ADDRMAX - ADDRMIN)*(double)rand()/(double)RAND_MAX;
phi = DPI*(double)rand()/(double)RAND_MAX;
x = r*cos(phi);
y = r*sin(phi);
break;
}
}
printf("Added a particle at (%.5lg, %.5lg)\n\n\n", x, y);
fprintf(lj_log, "Added a particle at (%.5lg, %.5lg)\n\n\n", x, y);
add_particle(x, y, V_INITIAL, 0.05*V_INITIAL*(double)rand()/RAND_MAX, PARTICLE_MASS, type, particle);
printf("Particle number %i\n", ncircles-1);
// add_particle(x, y, V_INITIAL, 0.25*V_INITIAL*(double)rand()/RAND_MAX, PARTICLE_MASS, type, particle);
// add_particle(x, y, V_INITIAL*(double)rand()/RAND_MAX, 0.0, PARTICLE_MASS, type, particle);
// if (y > 0.0)
// add_particle(x, y, 5.0*V_INITIAL*(double)rand()/RAND_MAX, -10.0*V_INITIAL, PARTICLE_MASS, type, particle);
// else
// add_particle(x, y, 5.0*V_INITIAL*(double)rand()/RAND_MAX, 10.0*V_INITIAL, PARTICLE_MASS, type, particle);
particle[ncircles - 1].eq_dist = EQUILIBRIUM_DIST;
particle[ncircles - 1].thermostat = 1;
px[ncircles - 1] = particle[ncircles - 1].vx;
py[ncircles - 1] = particle[ncircles - 1].vy;
if ((TRACER_PARTICLE)&&(n_tracers < N_TRACER_PARTICLES))
{
tracer_n[n_tracers] = ncircles - 1;
n_tracers++;
printf("%i tracer particles\n", n_tracers);
}
// init_molecule_data(particle, molecule);
return (ncircles);
// add_particle(XMIN + 0.1, 0.0, 50.0, 0.0, 3.0, 0, particle);
// px[ncircles - 1] = particle[ncircles - 1].vx;
// py[ncircles - 1] = particle[ncircles - 1].vy;
// particle[ncircles - 1].radius = 1.5*MU;
// j = 0;
// while (module2(particle[j].xc,particle[j].yc) > 0.7) j = rand()%ncircles;
// x = particle[j].xc + 2.5*MU;
// y = particle[j].yc;
// x = XMIN + (XMAX - XMIN)*rand()/RAND_MAX;
// y = YMAX + 0.01*rand()/RAND_MAX;
// add_particle(x, y, 0.0, 0.0, 1.0, 0, particle);
// x = XMIN + 0.25*(XMAX - XMIN);
// y = YMAX + 0.01;
// prop = 1.0 - (double)nadd_particle/5.0;
// vx = 100.0*prop;
// add_particle(x, y, vx, -10.0, 5.0*prop, 0, particle);
// particle[ncircles - 1].radius = 10.0*MU*prop;
// particle[ncircles - 1].eq_dist = 2.0;
// particle[ncircles - 1].thermostat = 0;
// px[ncircles - 1] = particle[ncircles - 1].vx;
// py[ncircles - 1] = particle[ncircles - 1].vy;
// add_particle(MU*(2.0*rand()/RAND_MAX - 1.0), YMAX + 2.0*MU, 0.0, 0.0, PARTICLE_MASS, 0, particle);
// add_particle(XMIN - 0.5*MU, 0.0, 50.0 + 5.0*(double)i, 0.0, 2.0*PARTICLE_MASS, 0, particle);
// x = INITXMIN + (INITXMAX - INITXMIN)*(double)rand()/(double)RAND_MAX;
// y = INITYMIN + (INITYMAX - INITYMIN)*(double)rand()/(double)RAND_MAX;
// x = BCXMIN + (BCXMAX - BCXMIN)*(double)rand()/(double)RAND_MAX;
// y = YMAX + 0.5*(BCYMAX - YMAX)*(double)rand()/(double)RAND_MAX;
}
void center_momentum(double p[NMAXCIRCLES])
{
int i;
double ptot = 0.0, pmean;
for (i=0; i<ncircles; i++) ptot += p[i];
pmean = ptot/(double)ncircles;
for (i=0; i<ncircles; i++) p[i] -= pmean;
}
int floor_momentum(double p[NMAXCIRCLES])
{
int i, floor = 0;
double ptot = 0.0, pmean;
for (i=0; i<ncircles; i++)
{
if (p[i] > PMAX)
{
p[i] = PMAX;
floor = 1;
}
else if (p[i] < -PMAX)
{
p[i] = -PMAX;
floor = 1;
}
}
if (floor) printf("Flooring momentum\n");
return (floor);
}
int partial_thermostat_coupling(t_particle particle[NMAXCIRCLES], double xmin, t_segment segment[NMAXSEGMENTS], t_lj_parameters params)
/* only couple particles satisfying condition PARTIAL_THERMO_REGION to thermostat */
{
int condition, i, nthermo = 0;
double x, y, height, a, b;
static double maxheight;
static int first = 1;
if (first)
{
maxheight = YMIN + PARTIAL_THERMO_HEIGHT*(YMAX - YMIN);
first = 0;
}
if (PARTIAL_THERMO_REGION == TH_LAYER_TYPE2)
{
height = YMIN;
for (i=0; i<ncircles; i++)
{
y = particle[i].yc;
if ((particle[i].active)&&(particle[i].type == 2)&&(y > height)&&(y <= maxheight))
height = y;
}
if (height > maxheight) height = maxheight;
printf("Thermostat region y > %.3lg, max height = %.3lg\n", height, maxheight);
}
for (i=0; i<ncircles; i++)
{
switch (PARTIAL_THERMO_REGION) {
case (TH_VERTICAL):
{
condition = (particle[i].xc > xmin);
break;
}
case (TH_INSEGMENT):
{
condition = (in_segment_region(particle[i].xc, particle[i].yc, segment));
// condition = (in_segment_region(particle[i].xc - xsegments[0], particle[i].yc - ysegments[0]));
// // condition = (in_segment_region(particle[i].xc - xsegments[0], particle[i].yc - ysegments[0]));
// if (TWO_OBSTACLES)
// condition = condition||(in_segment_region(particle[i].xc - xsegments[1], particle[i].yc - ysegments[1]));
break;
}
case (TH_INBOX):
{
x = particle[i].xc;
y = particle[i].yc;
condition = ((y < YMIN + PARTIAL_THERMO_HEIGHT*(YMAX - YMIN))&&(vabs(x) < PARTIAL_THERMO_WIDTH*XMAX));
break;
}
case (TH_LAYER):
{
y = particle[i].yc;
condition = (y > PARTIAL_THERMO_HEIGHT);
break;
}
case (TH_LAYER_TYPE2):
{
y = particle[i].yc;
condition = (y > height);
break;
}
case (TH_RING):
{
x = particle[i].xc;
y = particle[i].yc;
condition = x*x + y*y > PARTIAL_THERMO_WIDTH*PARTIAL_THERMO_WIDTH;
break;
}
case (TH_RING_EXPAND):
{
x = particle[i].xc;
y = particle[i].yc;
condition = x*x + y*y > params.thermo_radius*params.thermo_radius;
break;
}
case (TH_INIT):
{
x = particle[i].xc;
y = particle[i].yc;
condition = ((x > INITXMIN)&&(x < INITXMAX)&&(y > INITYMIN)&&(y < INITYMAX));
break;
}
case (TH_THERMO):
{
x = particle[i].xc;
y = particle[i].yc;
condition = ((x > THERMOXMIN)&&(x < THERMOXMAX)&&(y > THERMOYMIN)&&(y < THERMOYMAX));
break;
}
case (TH_CONE):
{
x = particle[i].xc;
y = particle[i].yc;
a = (LAMBDA + 0.2)/(LAMBDA - 0.05);
b = LAMBDA*(1.0 - a);
condition = ((y < LAMBDA)&&(y > 0.0)&&(y > a*vabs(x) + b));
break;
}
default: condition = 1;
}
if (condition)
{
particle[i].thermostat = 1;
nthermo++;
}
else particle[i].thermostat = 0;
}
return(nthermo);
}
int partial_efield(double x, double y)
/* */
{
switch (EFIELD_REGION) {
case (EF_CONST): return(1);
case (EF_SQUARE): return(vabs(x) < YMAX);
case (EF_LEFT): return(x < YMIN);
}
}
int partial_bfield(double x, double y)
/* */
{
switch (BFIELD_REGION) {
case (BF_CONST): return(1);
case (BF_SQUARE): return(vabs(x) < YMAX);
}
}
double compute_mean_energy(t_particle particle[NMAXCIRCLES])
{
int i, nactive = 0;
double total_energy = 0.0;
for (i=0; i<ncircles; i++) if (particle[i].active)
{
total_energy += particle[i].energy;
nactive++;
}
return(total_energy/(double)nactive);
}
void compute_inverse_masses(double inv_masses[RD_TYPES+1])
/* compute inverse masses of molecules in chemical reactions */
{
int type;
double mass;
/* default values that apply in most cases */
inv_masses[1] = 1.0/PARTICLE_MASS;
inv_masses[2] = 1.0/PARTICLE_MASS_B;
switch (RD_REACTION) {
case (CHEM_AAB):
{
inv_masses[2] = 0.5/PARTICLE_MASS;
break;
}
case (CHEM_ABC):
{
inv_masses[3] = 1.0/(PARTICLE_MASS + PARTICLE_MASS_B);
break;
}
case (CHEM_A2BC):
{
inv_masses[3] = 1.0/(2.0*PARTICLE_MASS + PARTICLE_MASS_B);
break;
}
case (CHEM_CATALYSIS):
{
inv_masses[3] = 0.5/PARTICLE_MASS;
break;
}
case (CHEM_BAA):
{
inv_masses[1] = 2.0/PARTICLE_MASS_B;
break;
}
case (CHEM_AABAA):
{
inv_masses[2] = 0.5/PARTICLE_MASS;
break;
}
case (CHEM_POLYMER):
{
for (type = 3; type < RD_TYPES+1; type++)
{
mass = PARTICLE_MASS_B + (double)(type-2)*PARTICLE_MASS;
inv_masses[type] = 1.0/(PARTICLE_MASS + mass);
}
break;
}
case (CHEM_POLYMER_DISS):
{
for (type = 3; type < RD_TYPES+1; type++)
{
mass = PARTICLE_MASS_B + (double)(type-2)*PARTICLE_MASS;
inv_masses[type] = 1.0/(PARTICLE_MASS + mass);
}
break;
}
case (CHEM_POLYMER_STEP):
{
for (type = 2; type < RD_TYPES+1; type++)
inv_masses[type] = 1.0/((double)type*PARTICLE_MASS);
break;
}
case (CHEM_CATALYTIC_A2D):
{
inv_masses[3] = 1.0/(1.0/PARTICLE_MASS + 1.0/PARTICLE_MASS_B);
inv_masses[4] = 0.5/PARTICLE_MASS;
break;
}
case (CHEM_ABCAB):
{
inv_masses[3] = 1.0/(PARTICLE_MASS + PARTICLE_MASS_B);
break;
}
case (CHEM_ABCDABC):
{
inv_masses[3] = 1.0/(PARTICLE_MASS + PARTICLE_MASS_B);
inv_masses[4] = 1.0/(2.0*PARTICLE_MASS + PARTICLE_MASS_B);
break;
}
case (CHEM_BZ):
{
for (type = 2; type <= 4; type++)
{
mass = PARTICLE_MASS + (double)(type-2)*PARTICLE_MASS_B;
inv_masses[type] = 1.0/(mass);
}
// inv_masses[5] = 1.0/(3.5*PARTICLE_MASS);
// inv_masses[6] = 0.2/PARTICLE_MASS;
inv_masses[5] = 0.5/(PARTICLE_MASS);
inv_masses[6] = 0.5/PARTICLE_MASS;
inv_masses[7] = 0.5*inv_masses[3];
inv_masses[8] = 0.5*inv_masses[5];
break;
}
case (CHEM_BRUSSELATOR):
{
inv_masses[3] = inv_masses[1];
inv_masses[4] = 1.0/(PARTICLE_MASS + PARTICLE_MASS_B);
inv_masses[5] = inv_masses[1];
inv_masses[6] = inv_masses[1];
break;
}
case (CHEM_ABDACBE):
{
inv_masses[3] = inv_masses[1];
inv_masses[4] = 1.0/(PARTICLE_MASS + PARTICLE_MASS_B);
inv_masses[5] = inv_masses[1];
break;
}
}
}
void compute_radii(double radii[RD_TYPES+1])
/* compute radii of molecules in chemical reactions */
{
int type;
/* default values that apply in most cases */
radii[1] = MU;
radii[2] = MU_B;
switch (RD_REACTION) {
case (CHEM_ABC):
{
radii[3] = 1.5*MU;
break;
}
case (CHEM_A2BC):
{
radii[3] = 1.5*MU;
break;
}
case (CHEM_CATALYSIS):
{
radii[3] = MU_B;
break;
}
case (CHEM_POLYMER):
{
for (type = 3; type < RD_TYPES+1; type++) radii[type] = 1.5*MU;
break;
}
case (CHEM_POLYMER_DISS):
{
for (type = 3; type < RD_TYPES+1; type++) radii[type] = 1.5*MU;
break;
}
case (CHEM_POLYMER_STEP):
{
for (type = 2; type < RD_TYPES+1; type++) radii[type] = 1.2*MU;
break;
}
case (CHEM_CATALYTIC_A2D):
{
radii[3] = MU_B;
radii[4] = MU*1.2;
break;
}
case (CHEM_ABCAB):
{
radii[3] = 1.5*MU;
break;
}
case (CHEM_ABCDABC):
{
radii[3] = 1.5*MU;
radii[4] = 1.5*MU;
break;
}
case (CHEM_BZ):
{
// for (type = 2; type <= 8; type++) radii[type] = MU;
for (type = 2; type <= 4; type++) radii[type] = MU;
radii[5] = MU_B;
radii[6] = 1.5*MU_B;
radii[7] = 1.2*radii[3];
radii[8] = 1.2*radii[5];
break;
}
case (CHEM_BRUSSELATOR):
{
radii[3] = MU;
radii[4] = 1.2*MU_B;
radii[5] = MU;
radii[6] = MU;
break;
}
case (CHEM_ABDACBE):
{
radii[3] = MU;
radii[4] = 1.2*MU_B;
radii[5] = MU;
break;
}
}
}
void adapt_speed_exothermic(t_particle *particle, double delta_ekin)
/* change the particle speed in case of exothermic reaction */
{
double old_energy, e_ratio;
old_energy = (particle->vx*(particle->vx) + particle->vy*(particle->vy))*(particle->mass_inv);
if (old_energy + delta_ekin > 0.0) e_ratio = sqrt((old_energy + delta_ekin)/old_energy);
else e_ratio = 0.0;
particle->vx *= e_ratio;
particle->vy *= e_ratio;
}
int chem_merge_AAB(int i, int newtype, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double inv_masses[RD_TYPES+1], double radii[RD_TYPES+1])
/* merging particle i with a particle of same type into a particle of type newtype */
/* particular case of chem_merge */
{
int j, k, type1;
short int search = 1;
double distance, rx, ry, mr, newmass_inv;
type1 = particle[i].type;
newmass_inv = inv_masses[newtype];
mr = inv_masses[newtype]/inv_masses[type1];
for (j=0; j<particle[i].hash_nneighb; j++)
{
search = 1;
k = particle[i].hashneighbour[j];
if ((search)&&(particle[k].active)&&(particle[k].type == type1))
{
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
if ((distance < REACTION_DIST*MU)&&((double)rand()/RAND_MAX < REACTION_PROB))
{
particle[i].type = newtype;
particle[i].radius = radii[newtype];
rx = particle[i].xc - particle[k].xc;
ry = particle[i].yc - particle[k].yc;
particle[i].angle = argument(rx, ry);
particle[i].omega = rx*particle[i].vy - ry*particle[i].vx;
particle[i].omega -= rx*particle[k].vy - ry*particle[k].vx;
if (CENTER_COLLIDED_PARTICLES)
{
particle[i].xc = 0.5*(particle[i].xc + particle[k].xc);
particle[i].yc = 0.5*(particle[i].yc + particle[k].yc);
}
particle[i].vx = mr*(particle[i].vx + particle[k].vx);
particle[i].vy = mr*(particle[i].vy + particle[k].vy);
particle[i].mass_inv = newmass_inv;
particle[k].active = 0;
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = 0.0;
if (ncollisions < NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
search = 0;
}
}
}
return(ncollisions);
}
int chem_merge(int i, int type2, int newtype, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double inv_masses[RD_TYPES+1], double radii[RD_TYPES+1])
/* merging of particle i and a particle of type type2 into a particle of type newtype */
{
int j, k, type1;
short int search = 1;
double distance, rx, ry, m2, mr1, mr2, newmass_inv, old_energy, e_ratio;
type1 = particle[i].type;
newmass_inv = inv_masses[newtype];
mr1 = newmass_inv/inv_masses[type1];
mr2 = newmass_inv/inv_masses[type2];
for (j=0; j<particle[i].hash_nneighb; j++)
{
k = particle[i].hashneighbour[j];
if ((particle[k].active)&&(particle[k].type == type2))
{
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
if ((distance < REACTION_DIST*MU)&&((double)rand()/RAND_MAX < REACTION_PROB))
{
particle[i].type = newtype;
particle[i].radius = radii[newtype];
rx = particle[i].xc - particle[k].xc;
ry = particle[i].yc - particle[k].yc;
particle[i].angle = argument(rx, ry);
particle[i].omega = rx*particle[i].vy - ry*particle[i].vx;
particle[i].omega -= rx*particle[k].vy - ry*particle[k].vx;
if (CENTER_COLLIDED_PARTICLES)
{
particle[i].xc = 0.5*(particle[i].xc + particle[k].xc);
particle[i].yc = 0.5*(particle[i].yc + particle[k].yc);
}
particle[i].vx = mr1*particle[i].vx + mr2*particle[k].vx;
particle[i].vy = mr1*particle[i].vy + mr2*particle[k].vy;
particle[i].mass_inv = newmass_inv;
if (EXOTHERMIC) adapt_speed_exothermic(&particle[i], DELTA_EKIN);
particle[k].active = 0;
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = 0.0;
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
}
}
return(ncollisions);
}
int chem_multi_merge(int i, int ni, int type2, int newtype, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double inv_masses[RD_TYPES+1], double radii[RD_TYPES+1])
/* merging of ni particles of the same type as particle i (including particle i) */
/* and one particle of type type2 into a particle of type newtype */
{
int j, k, type1, n1, n2, k1[10], k2;
short int search = 1;
double distance, xg, yg, rx, ry, rx1[10], ry1[10], rx2, ry2, mr1, mr2, newmass_inv;
if (ni > 10)
{
printf("Error: need to increase size of k1 table in chem_multi_merge()\n");
exit(1);
}
type1 = particle[i].type;
newmass_inv = inv_masses[newtype];
mr1 = newmass_inv/inv_masses[type1];
mr2 = newmass_inv/inv_masses[type2];
n1 = 0;
n2 = 0;
for (j=0; j<particle[i].hash_nneighb; j++)
{
k = particle[i].hashneighbour[j];
if ((particle[k].active)&&(particle[k].type == type1))
{
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
if ((distance < REACTION_DIST*MU)&&((double)rand()/RAND_MAX < REACTION_PROB))
{
k1[n1] = k;
n1++;
}
}
else if ((particle[k].active)&&(particle[k].type == type2))
{
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
if ((distance < REACTION_DIST*MU)&&((double)rand()/RAND_MAX < REACTION_PROB))
{
k2 = k;
n2 = 1;
}
}
}
if ((n1 == ni-1)&&(n2 == 1))
{
particle[i].type = radii[newtype];
particle[i].radius *= 1.5;
xg = particle[i].xc;
yg = particle[i].yc;
for (n1 = 0; n1 < ni-1; n1++)
{
xg += particle[k1[n1]].xc;
yg += particle[k1[n1]].yc;
}
xg = xg*mr1 + particle[k2].xc*mr2;
yg = yg*mr1 + particle[k2].yc*mr2;
rx = particle[i].xc - xg;
ry = particle[i].yc - yg;
for (n1 = 0; n1 < ni-1; n1++)
{
rx1[n1] = particle[k1[n1]].xc - xg;
ry1[n1] = particle[k1[n1]].yc - yg;
}
rx2 = particle[k2].xc - xg;
ry2 = particle[k2].yc - yg;
particle[i].angle = argument(rx2, ry2);
for (n1 = 0; n1 < ni-1; n1++) particle[i].angle += argument(rx1[n1], ry1[n1]);
if (CENTER_COLLIDED_PARTICLES)
{
particle[i].xc = xg;
particle[i].yc = yg;
}
particle[i].vx = mr1*particle[i].vx + mr2*particle[k2].vx;
particle[i].vy = mr1*particle[i].vy + mr2*particle[k2].vy;
for (n1 = 0; n1 < ni-1; n1++)
{
particle[i].vx += mr1*particle[k1[n1]].vx;
particle[i].vy += mr1*particle[k1[n1]].vx;
}
particle[i].omega = mr1*(rx*particle[i].vy - ry*particle[i].vx);
for (n1 = 0; n1 < ni-1; n1++)
particle[i].omega += mr1*(rx1[n1]*particle[k1[n1]].vy - ry1[n1]*particle[k1[n1]].vx);
particle[i].omega += mr2*(rx2*particle[k2].vy - ry2*particle[k2].vx);
particle[i].mass_inv = newmass_inv;
for (k==0; k<ni; k++) particle[k1[k]].active = 0;
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = 0.0;
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
return(ncollisions);
}
int chem_catalytic_merge(int i, int type_catalyst, int newtype, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double inv_masses[RD_TYPES+1], double radii[RD_TYPES+1])
/* merging of 2 particles of the same type as particle i (including particle i) */
/* into a particle of type newtype, provided a particle of type type_catalyst is present */
{
int j, k, type1, n1, n2, k1, k2;
short int search = 1;
double distance, xg, yg, rx, rx1, ry, ry1, mr, newmass_inv;
type1 = particle[i].type;
newmass_inv = inv_masses[newtype];
mr = inv_masses[newtype]/inv_masses[type1];
n1 = 0;
n2 = 0;
for (j=0; j<particle[i].hash_nneighb; j++)
{
k = particle[i].hashneighbour[j];
if ((particle[k].active)&&(particle[k].type == type1))
{
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
if ((distance < REACTION_DIST*MU)&&((double)rand()/RAND_MAX < REACTION_PROB))
{
k1 = k;
n1 = 1;
}
}
else if ((particle[k].active)&&(particle[k].type == type_catalyst))
{
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
if ((distance < REACTION_DIST*MU)&&((double)rand()/RAND_MAX < REACTION_PROB))
{
k2 = k;
n2 = 1;
}
}
}
if ((n1 == 1)&&(n2 == 1))
{
particle[i].type = newtype;
particle[i].radius = radii[newtype];
xg = 0.5*(particle[i].xc + particle[k1].xc + particle[k2].xc);
yg = 0.5*(particle[i].yc + particle[k1].yc + particle[k2].yc);
rx = particle[i].xc - xg;
ry = particle[i].yc - yg;
rx1 = particle[k1].xc - xg;
ry1 = particle[k1].yc - yg;
particle[i].angle = argument(rx1, ry1);
if (CENTER_COLLIDED_PARTICLES)
{
particle[i].xc = xg;
particle[i].yc = yg;
}
particle[i].vx = mr*(particle[i].vx + particle[k1].vx);
particle[i].vy = mr*(particle[i].vy + particle[k1].vy);
particle[i].omega = mr*(rx*particle[i].vy - ry*particle[i].vx);
particle[i].omega += mr*(rx1*particle[k1].vy - ry1*particle[k1].vx);
particle[i].mass_inv = newmass_inv;
particle[k1].active = 0;
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = 0.0;
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
return(ncollisions);
}
int chem_split(int i, int newtype1, int newtype2, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double inv_masses[RD_TYPES+1], double radii[RD_TYPES+1])
/* split particle i into particles of type newtype1 and newtype2 */
{
int j, k, oldtype;
short int success;
double distance, rx, ry, xg, yg, normv;
normv = module2(particle[i].vx, particle[i].vy);
rx = -MU*particle[i].vy/normv;
ry = MU*particle[i].vx/normv;
xg = particle[i].xc;
yg = particle[i].yc;
particle[i].xc += rx;
particle[i].yc += ry;
oldtype = particle[i].type;
/* test whether there is room to put two particles */
success = add_particle(xg - rx, yg - ry, particle[i].vx, particle[i].vy, 1.0/inv_masses[newtype1], newtype1, particle);
if (success)
{
particle[i].type = newtype2;
particle[i].mass_inv = inv_masses[newtype2];
particle[i].radius = radii[newtype2];
particle[ncircles-1].type = newtype1;
particle[ncircles-1].mass_inv = inv_masses[newtype1];
particle[ncircles-1].radius = radii[newtype1];
if (EXOTHERMIC)
{
adapt_speed_exothermic(&particle[i], -0.5*DELTA_EKIN);
adapt_speed_exothermic(&particle[ncircles-1], -0.5*DELTA_EKIN);
}
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = type_hue(oldtype);
if (ncollisions < NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
else
{
particle[i].xc -= rx;
particle[i].yc -= ry;
}
return(ncollisions);
}
int chem_transfer(int i, int type2, int newtype1, int newtype2, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double inv_masses[RD_TYPES+1], double radii[RD_TYPES+1], double reac_dist)
/* reaction of particle i and a particle of type type2 into a particles of types newtype1 and newtype2 */
{
int j, k, type1;
short int search = 1;
double distance, rx, ry, mass_inv1, mass_inv2, newmass_inv1, newmass_inv2, old_energy, e_ratio, omega;
type1 = particle[i].type;
mass_inv1 = inv_masses[type1];
mass_inv2 = inv_masses[type2];
newmass_inv1 = inv_masses[newtype1];
newmass_inv2 = inv_masses[newtype2];
for (j=0; j<particle[i].hash_nneighb; j++)
{
k = particle[i].hashneighbour[j];
if ((particle[k].active)&&(particle[k].type == type2))
{
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
if ((distance < reac_dist*MU)&&((double)rand()/RAND_MAX < REACTION_PROB))
{
particle[i].type = newtype1;
particle[i].radius = radii[newtype1];
particle[k].type = newtype2;
particle[k].radius = radii[newtype2];
/* momentum conservation does not determine outgoing velocities completely */
/* so make some arbitrary/random choices here */
rx = particle[i].xc - particle[k].xc;
ry = particle[i].yc - particle[k].yc;
particle[i].angle = argument(rx, ry);
particle[k].angle = argument(rx, ry) + PI;
omega = gaussian()*OMEGA_INITIAL;
particle[i].omega = omega;
particle[k].omega = -omega;
particle[i].vx *= newmass_inv1/mass_inv1;
particle[i].vy *= newmass_inv1/mass_inv1;
particle[i].mass_inv = newmass_inv1;
particle[k].vx *= newmass_inv2/mass_inv2;
particle[k].vy *= newmass_inv2/mass_inv2;
particle[k].mass_inv = newmass_inv2;
if (EXOTHERMIC)
{
adapt_speed_exothermic(&particle[i], DELTA_EKIN);
adapt_speed_exothermic(&particle[k], DELTA_EKIN);
}
collisions[ncollisions].x = 0.5*(particle[i].xc + particle[k].xc);
collisions[ncollisions].y = 0.5*(particle[i].yc + particle[k].yc);
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = 0.0;
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
}
}
return(ncollisions);
}
int chem_convert(int i, int newtype, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double inv_masses[RD_TYPES+1], double radii[RD_TYPES+1], double reac_prob)
/* convert particle i into new type with probability reac_prob */
{
int oldtype;
oldtype = particle[i].type;
// if (oldtype == 5) printf("Converting type %i to type %i\n", oldtype, newtype);
if ((double)rand()/RAND_MAX < reac_prob)
{
particle[i].type = newtype;
particle[i].radius = radii[newtype];
particle[i].mass_inv = inv_masses[newtype];
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = type_hue(oldtype);
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
return(ncollisions);
}
int chem_catalytic_convert(int i, int type2, int newtype, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double inv_masses[RD_TYPES+1], double radii[RD_TYPES+1], double reaction_dist, double reaction_prob)
/* if 2 particles of the same type as particle i (including particle i) are close */
/* to a particle of type type2, convert particle type from type2 to newtype */
{
int j, k, type1, n1, n2, k1, k2, oldtype;
short int search = 1;
double distance;
type1 = particle[i].type;
oldtype = particle[i].type;
n1 = 0;
n2 = 0;
for (j=0; j<particle[i].hash_nneighb; j++)
{
k = particle[i].hashneighbour[j];
if ((particle[k].active)&&(particle[k].type == type1))
{
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
if ((distance < reaction_dist*MU)&&((double)rand()/RAND_MAX < reaction_prob))
{
k1 = k;
n1 = 1;
}
}
else if ((particle[k].active)&&(particle[k].type == type2))
{
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
if ((distance < reaction_dist*MU)&&((double)rand()/RAND_MAX < reaction_prob))
{
k2 = k;
n2 = 1;
}
}
}
if ((n1 == 1)&&(n2 == 1))
{
particle[k2].type = newtype;
particle[k2].radius = radii[newtype];
particle[k2].mass_inv = inv_masses[newtype];
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = type_hue(oldtype);
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
return(ncollisions);
}
// int chem_dissociate_water_old(int i, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double reaction_prob)
// /* dissociation of water molecule i into a pair H+, OH- */
// {
// int j, k, p, q, closeby = 0, reaction = 0;
// double distance, move_factor, xnew, ynew, vxnew, vynew, mr1, mr2;
//
// if ((particle[i].npartners == 2)&&((double)rand()/RAND_MAX < reaction_prob))
// {
// /* choose particle k to dissociate */
// if (rand()%2 == 0)
// {
// j = particle[i].partner[0];
// k = particle[i].partner[1];
// }
// else
// {
// j = particle[i].partner[1];
// k = particle[i].partner[0];
// }
//
// /* propose moving dissociated particles further away */
// move_factor = 2.0;
// xnew = particle[i].xc + move_factor*(particle[k].xc - particle[i].xc);
// ynew = particle[i].yc + move_factor*(particle[k].yc - particle[i].yc);
//
// /* test distance to other particles */
// closeby = 0;
// for (p=0; p<particle[k].hash_nneighb; p++)
// {
// q = particle[k].hashneighbour[p];
// if ((q!=i)&&(q!=j)&&(q!=k)&&(particle[q].active))
// {
// distance = module2(xnew - particle[q].xc, ynew - particle[q].yc);
// if (distance < SAFETY_FACTOR*MU_B) closeby = 1;
// }
// }
//
// if (closeby) printf("Cannot split molecule %i\n", i);
// else
// {
// printf("Splitting molecule %i\n", i);
//
// particle[i].npartners = 1;
// particle[i].partner[0] = j;
//
// particle[j].npartners = 1;
// particle[j].partner[0] = i;
//
// particle[k].npartners = 0;
// particle[k].xc = xnew;
// particle[k].yc = ynew;
//
// collisions[ncollisions].x = particle[i].xc;
// collisions[ncollisions].y = particle[i].yc;
// collisions[ncollisions].time = COLLISION_TIME;
// collisions[ncollisions].color = type_hue(1);
//
// if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
// else printf("Too many collisions\n");
// }
// }
// else if (particle[i].npartners == 1)
// {
// mr1 = PARTICLE_MASS/(PARTICLE_MASS + 2.0*PARTICLE_MASS_B);
// mr2 = 1.0 - mr1;
//
// // for (p=0; p<particle[i].hash_nneighb; p++)
//
// p = 0;
// while ((p<particle[i].hash_nneighb)&&(!reaction))
// {
// k = particle[i].hashneighbour[p];
// if ((particle[k].active)&&(particle[k].type == 2)&&(particle[k].npartners == 0))
// {
// distance = module2(particle[i].deltax[p], particle[i].deltay[p]);
// if ((distance < REACTION_DIST*MU)&&((double)rand()/RAND_MAX < REACTION_PROB))
// {
// reaction = 1;
// printf("Merging molecule %i with particle %i\n", i, k);
//
// j = particle[i].partner[0];
// particle[i].npartners = 2;
// particle[i].partner[1] = k;
//
// particle[j].npartners = 2;
// particle[j].partner[0] = i; /* needed? */
// particle[j].partner[1] = k;
//
// particle[k].npartners = 2;
// particle[k].partner[0] = i;
// particle[k].partner[1] = j;
//
// distance = 2.0*sin(PARTNER_ANGLE*PI/360.0)*(MU + MU_B)*PAIR_DRATIO;
// particle[k].partner_eqd[1] = distance;
// particle[j].partner_eqd[1] = distance;
//
// /* equalize speeds */
// vxnew = mr1*particle[i].vx + mr2*particle[j].vx + mr2*particle[k].vx;
// vynew = mr1*particle[i].vy + mr2*particle[j].vy + mr2*particle[k].vy;
//
// particle[i].vx = vxnew;
// particle[i].vy = vynew;
// particle[j].vx = vxnew;
// particle[j].vy = vynew;
// particle[k].vx = vxnew;
// particle[k].vy = vynew;
//
// collisions[ncollisions].x = particle[i].xc;
// collisions[ncollisions].y = particle[i].yc;
// collisions[ncollisions].time = COLLISION_TIME;
// collisions[ncollisions].color = 0.0;
// // collisions[ncollisions].color = type_hue(2);
//
// if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
// else printf("Too many collisions\n");
// }
// }
// p++;
// }
// }
//
// return(ncollisions);
// }
int chem_dissociate_molecule(int i, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double reaction_prob)
/* dissociation of water molecule i into a pair H+, OH- */
{
int k, p, q, r, ndiss, closeby = 0, reaction = 0, diff, np, j[NMAXPARTNERS];
double distance, move_factor, xnew, ynew, vxnew, vynew, mr1, mr2;
if ((double)rand()/RAND_MAX < reaction_prob)
{
np = particle[i].npartners;
/* choose particle k to dissociate */
ndiss = rand()%np;
k = particle[i].partner[ndiss];
/* new list of partners of i */
for (p=0; p<ndiss; p++) j[p] = particle[i].partner[p];
for (p=ndiss+1; p<np; p++) j[p-1] = particle[i].partner[p];
/* propose moving dissociated particle further away */
move_factor = 2.0 + (double)(np-2);
xnew = particle[i].xc + move_factor*(particle[k].xc - particle[i].xc);
ynew = particle[i].yc + move_factor*(particle[k].yc - particle[i].yc);
/* test distance to other particles */
closeby = 0;
for (p=0; p<particle[k].hash_nneighb; p++)
{
q = particle[k].hashneighbour[p];
diff = ((q!=i)&&(q!=k)&&(particle[q].active));
for (r=0; r<np-1; r++) if (q=j[r]) diff = 0;
if (diff)
{
distance = module2(xnew - particle[q].xc, ynew - particle[q].yc);
if (distance < SAFETY_FACTOR*MU_B) closeby = 1;
}
}
if (closeby) printf("Cannot split molecule %i\n", i);
else
{
printf("Splitting molecule %i\n", i);
particle[i].npartners = np-1;
for (p=0; p<np-1; p++) particle[i].partner[p] = j[p];
for (p=0; p<np-1; p++)
{
particle[j[p]].npartners = np-1;
particle[j[p]].partner[0] = i;
for (q=0; q<p; q++) particle[j[p]].partner[q+1] = j[q];
for (q=p+1; q<np-1; q++) particle[j[p]].partner[q] = j[q];
}
particle[k].npartners = 0;
particle[k].xc = xnew;
particle[k].yc = ynew;
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = partner_color(np);
// collisions[ncollisions].color = type_hue(1);
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
}
return(ncollisions);
}
int chem_merge_molecule(int i, int type2, int maxpartners, t_particle particle[NMAXCIRCLES], t_collision *collisions, int ncollisions, double reaction_prob)
/* merging of molecule i with another molecule of type type 2 */
/* having at most nmaxpartners partners already */
{
int k, p, q, np, n, m, closeby = 0, reaction = 0, j[NMAXPARTNERS], r, kk;
double distance, angle, move_factor, xnew, ynew, vxnew, vynew, mr1, mr2;
np = particle[i].npartners;
mr1 = PARTICLE_MASS/(PARTICLE_MASS + (double)(np+1)*PARTICLE_MASS_B);
mr2 = 1.0 - mr1;
p = 0;
while ((p<particle[i].hash_nneighb)&&(!reaction))
{
k = particle[i].hashneighbour[p];
if ((particle[k].active)&&(particle[k].type == type2)&&(particle[k].npartners <= maxpartners))
{
distance = module2(particle[i].deltax[p], particle[i].deltay[p]);
if ((distance < REACTION_DIST*MU)&&((double)rand()/RAND_MAX < reaction_prob))
{
reaction = 1;
printf("Merging molecule %i with particle %i\n", i, k);
for (r=0; r<np; r++) j[r] = particle[i].partner[r];
particle[i].npartners++;
particle[i].partner[np] = k;
for (r=0; r<np; r++)
{
particle[j[r]].npartners = np+1;
particle[j[r]].partner[np] = k;
}
particle[k].npartners = np+1;
particle[k].partner[0] = i;
particle[k].partner_eqd[0] = (MU + MU_B)*PAIR_DRATIO;
for (kk=0; kk<np; kk++) particle[k].partner[kk+1] = j[kk];
if (np == 1)
{
distance = 2.0*sin(PARTNER_ANGLE*PI/360.0)*(MU + MU_B)*PAIR_DRATIO;
particle[k].partner_eqd[1] = distance;
particle[j[0]].partner_eqd[1] = distance;
}
else /* distribute particles uniformly around i */
{
j[np] = k;
print_partners(i, particle);
for (q=0; q<np+1; q++)
{
angle = (double)q*DPI/(double)(np+1);
particle[j[q]].npartners = np+1;
particle[j[q]].partner[0] = i;
particle[j[q]].partner_eqd[0] = (MU + MU_B)*PAIR_DRATIO;
particle[i].partner_eqd[q] = (MU + MU_B)*PAIR_DRATIO;
particle[j[q]].xc = particle[i].xc + (MU + MU_B)*PAIR_DRATIO*cos(angle);
particle[j[q]].yc = particle[i].yc + (MU + MU_B)*PAIR_DRATIO*sin(angle);
}
for (q=0; q<np+1; q++)
for (r=0; r<np+1; r++)
{
m = particle[j[q]].partner[r];
particle[j[q]].partner_eqd[r] = module2(particle[j[q]].xc - particle[m].xc, particle[j[q]].yc - particle[m].yc);
}
// for (q=0; q<np+1; q++) print_partners(j[q], particle);
}
/* equalize speeds */
vxnew = mr1*particle[i].vx + mr2*particle[k].vx;
vynew = mr1*particle[i].vy + mr2*particle[k].vy;
for (r=0; r<np; r++)
{
vxnew += mr2*particle[j[r]].vx;
vynew += mr2*particle[j[r]].vy;
}
particle[i].vx = vxnew;
particle[i].vy = vynew;
for (r=0; r<np; r++)
{
particle[j[r]].vx = vxnew;
particle[j[r]].vy = vynew;
}
particle[k].vx = vxnew;
particle[k].vy = vynew;
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = 0.0;
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
}
p++;
}
return(ncollisions);
}
int chem_multi_glue_molecule(int i, int type2, int maxpartners, int no_triangles, int no_cluster, int require_charge, int equalize_charge, t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES], t_collision *collisions, int ncollisions, double reaction_prob)
/* glue molecule containing particle i with another molecule of type type 2 */
/* having at most nmaxpartners partners already */
/* if no_triangles >= 1, particles that have a common partner are not paired */
/* if no_cluster = 1, particles are not paired if they belong to the same cluster */
{
int k, p, q, p1, q1, p2, np, nq, n, m, closeby = 0, reaction = 0, jp[NMAXPARTNERS], jq[NMAXPARTNERS], r, kk, different, np2, moli, molk, mp, newpartner, pp, type1;
double distance, angle, move_factor, xnew, ynew, vxnew, vynew, m1, m2, mr1, mr2, deltav, x, y;
short int charge_condition, triangle_condition;
type1 = particle[i].type;
np = particle[i].npartners;
moli = particle[i].molecule;
if (np > maxpartners) return(ncollisions);
m1 = 1.0/particle[i].mass_inv;
for (p=0; p<np; p++)
{
jp[p] = particle[i].partner[p];
m1 += 1.0/particle[jp[p]].mass_inv;
}
p = 0;
while ((p<particle[i].hash_nneighb)&&(!reaction))
{
k = particle[i].hashneighbour[p];
nq = particle[k].npartners;
molk = particle[k].molecule;
charge_condition = (!require_charge)||(particle[i].charge*particle[k].charge < 0.0);
triangle_condition = 1;
/* exclude mergers between added particles */
if (particle[i].added == particle[k].added)
{
triangle_condition = particle[i].reactive*particle[k].reactive;
/* allow mergers if molecules are paired to same DNA strand */
if ((particle[i].paired)&&(particle[k].paired)&&(particle[i].partner_molecule % NGRIDY == particle[k].partner_molecule % NGRIDY)) triangle_condition = 1;
}
if ((RD_REACTION == CHEM_DNA_ENZYME)||(RD_REACTION == CHEM_DNA_ENZYME_REPAIR))
{
/* exclude mergers of added molecules to original ones via backbone */
if ((particle[i].added != particle[k].added)&&(type2 <= 2)&&(type1 <= 2))
triangle_condition = 0;
/* NEW TEST */
// if (molk == moli) triangle_condition = 0;
/* NEW TEST */
/* avoid original backbones to form a loop */
if ((!particle[i].added)&&(!particle[k].added)&&((molk-moli > NGRIDX/2)||(moli-molk > NGRIDX/2))) triangle_condition = 0;
}
if (no_triangles == 1) /* do not pair i and k if they have a common partner */
{
for (q=0; q<nq; q++)
for (p1=0; p1<np; p1++)
if (particle[k].partner[q] == particle[i].partner[p1]) triangle_condition = 0;
}
if (no_triangles == 2) /* also exclude i or k being a partner of k or i */
{
for (q=0; q<nq; q++) if (particle[k].partner[q] == i) triangle_condition = 0;
for (p1=0; p1<np; p1++) if (particle[i].partner[p1] == k) triangle_condition = 0;
}
if (no_triangles >= 3) /* exclude connections of different type between the same molecules */
{
if (molk != moli) for (p1=0; p1<np; p1++)
{
n = particle[i].partner[p1];
for (q=0; q<particle[n].npartners; q++)
{
m = particle[n].partner[q];
if (particle[m].molecule == molk)
if (particle[n].type != particle[i].type)
triangle_condition = 0;
}
if ((particle[n].molecule != moli)&&(particle[n].molecule != molk))
triangle_condition = 0;
if (particle[n].molecule == moli) if (particle[n].type == particle[i].type)
{
for (q=0; q<particle[n].npartners; q++)
{
m = particle[n].partner[q];
if ((particle[m].molecule != moli)&&(particle[m].molecule != molk))
triangle_condition = 0;
}
}
}
if (molk != moli) for (q=0; q<nq; q++)
{
n = particle[k].partner[q];
if ((particle[n].molecule != molk)&&(particle[n].molecule != moli))
triangle_condition = 0;
}
}
if (no_triangles >= 4) /* also exclude second-order partners */
{
for (q=0; q<nq; q++)
for (p1=0; p1<np; p1++)
{
n = particle[k].partner[q];
for (q1 = 0; q1 < particle[n].npartners; q1++)
if (particle[n].partner[q1] == particle[i].partner[p1])
triangle_condition = 0;
n = particle[i].partner[p1];
for (p2 = 0; p2 < particle[n].npartners; p2++)
if (particle[n].partner[p2] == particle[k].partner[q])
triangle_condition = 0;
}
}
if ((no_cluster)&&(particle[k].cluster = particle[i].cluster)) triangle_condition = 0;
if ((particle[k].active)&&(charge_condition)&&(triangle_condition)&&(particle[k].type == type2)&&(nq <= maxpartners))
{
distance = module2(particle[i].deltax[p], particle[i].deltay[p]);
if ((distance < REACTION_DIST*MU)&&((double)rand()/RAND_MAX < reaction_prob))
{
m2 = 1.0/particle[k].mass_inv;
for (q=0; q<nq; q++)
{
jq[q] = particle[k].partner[q];
m2 += 1.0/particle[jq[q]].mass_inv;
}
mr1 = m1/(m1 + m2);
mr2 = 1.0 - mr1;
if ((np == 0)&&(nq == 0))
{
reaction = 1;
printf("Merging molecule %i with particle %i\n", i, k);
distance = (particle[i].radius + particle[k].radius)*PAIR_DRATIO;
particle[i].npartners++;
particle[i].partner[0] = k;
particle[i].partner_eqd[0] = distance;
particle[k].npartners++;
particle[k].partner[0] = i;
particle[k].partner_eqd[0] = distance;
/* equalize speeds */
vxnew = mr1*particle[i].vx + mr2*particle[k].vx;
vynew = mr1*particle[i].vy + mr2*particle[k].vy;
particle[i].vx = vxnew;
particle[i].vy = vynew;
particle[k].vx = vxnew;
particle[k].vy = vynew;
/* equalize charges */
if (equalize_charge == 1) particle[k].charge = particle[i].charge;
else if (equalize_charge == 2)
{
particle[i].coulomb = 0;
particle[k].coulomb = 0;
}
/* update molecule data */
mp = molecule[moli].npartners;
if (mp < NMAXPARTNERMOLECULES)
{
newpartner = 1;
for (pp=0; pp<mp; pp++)
if (molecule[moli].partner[pp] == molk) newpartner = 0;
if (newpartner)
{
printf("adding molecule %i as %ith partner of molecule %i\n", molk, mp, moli);
molecule[moli].partner[mp] = molk;
molecule[moli].connection_type[mp] = particle[i].type;
molecule[moli].npartners++;
}
}
mp = molecule[molk].npartners;
if (mp < NMAXPARTNERMOLECULES)
{
newpartner = 1;
for (pp=0; pp<mp; pp++)
if (molecule[molk].partner[pp] == moli) newpartner = 0;
if (newpartner)
{
printf("adding molecule %i as %ith partner of molecule %i\n", moli, mp, molk);
molecule[molk].partner[mp] = moli;
molecule[molk].connection_type[mp] = type2;
molecule[molk].npartners++;
}
}
}
else
{
/* check if i and k belong to different molecules */
// different = 1;
// for (p1=0; p1<np; p1++)
// if (k == jp[p1]) different = 0;
// for (q1=0; q1<nq; q1++)
// if (i == jq[q1]) different = 0;
/* TODO: replace by moli != molk ? */
different = (moli != molk);
if (different)
{
deltav = module2(particle[i].vx - particle[k].vx, particle[i].vy - particle[k].vy);
// printf("Delta v is %.3lg\n", deltav);
if (deltav < DELTAVMAX)
{
reaction = 1;
printf("Pairing molecules %i and %i containing particles %i and %i\n", moli, molk, i, k);
distance = (particle[i].radius + particle[k].radius)*PAIR_DRATIO;
particle[i].npartners++;
particle[i].partner[np] = k;
particle[i].partner_eqd[np] = distance;
particle[k].npartners++;
particle[k].partner[nq] = i;
particle[k].partner_eqd[nq] = distance;
/* equalize speeds */
vxnew = mr1*particle[i].vx + mr2*particle[k].vx;
vynew = mr1*particle[i].vy + mr2*particle[k].vy;
particle[i].vx = vxnew;
particle[i].vy = vynew;
particle[k].vx = vxnew;
particle[k].vy = vynew;
if (equalize_charge) particle[k].charge = particle[i].charge;
for (p1=0; p1<np; p1++) for (q1=0; q1<nq; q1++)
{
particle[jp[p1]].vx = vxnew;
particle[jp[p1]].vy = vynew;
particle[jq[q1]].vx = vxnew;
particle[jq[q1]].vy = vynew;
if (equalize_charge == 1)
{
particle[jp[p1]].charge = particle[i].charge;
particle[jq[q1]].charge = particle[i].charge;
}
else if (equalize_charge == 2)
{
particle[jp[p1]].coulomb = 0;
particle[jq[q1]].coulomb = 0;
}
}
/* update molecule data */
mp = molecule[moli].npartners;
if (mp < NMAXPARTNERMOLECULES)
{
newpartner = 1;
for (pp=0; pp<mp; pp++)
if (molecule[moli].partner[pp] == molk) newpartner = 0;
if (newpartner)
{
// printf("adding molecule %i as %ith partner of molecule %i\n", molk, mp, moli);
molecule[moli].partner[mp] = molk;
molecule[moli].connection_type[mp] = particle[i].type;
molecule[moli].npartners++;
}
}
mp = molecule[molk].npartners;
if (mp < NMAXPARTNERMOLECULES)
{
newpartner = 1;
for (pp=0; pp<mp; pp++)
if (molecule[molk].partner[pp] == moli) newpartner = 0;
if (newpartner)
{
// printf("adding molecule %i as %ith partner of molecule %i\n", moli, mp, molk);
molecule[molk].partner[mp] = moli;
molecule[molk].connection_type[mp] = particle[k].type;
molecule[molk].npartners++;
}
}
/* merge secondary partners, experimental */
if (SECONDARY_PAIRING)
{
np2 = particle[k].npartners;
for (p1 = 0; p1 < np2; p1++)
// if (np2 > 1)
{
n = particle[k].partner[p1];
x = particle[i].xc - particle[n].xc;
y = particle[i].yc - particle[n].yc;
/* deal with periodic boundary conditions */
if (x > 0.5*(XMAX - XMIN)) x -= (XMAX - XMIN);
else if (x < 0.5*(XMIN - XMAX)) x += (XMAX - XMIN);
if (y > 0.5*(YMAX - YMIN)) y -= (YMAX - YMIN);
else if (y < 0.5*(YMIN - YMAX)) y += (YMAX - YMIN);
distance = module2(x, y);
if (distance > particle[i].radius)
{
np = particle[i].npartners;
particle[i].npartners++;
particle[i].partner[np] = n;
particle[i].partner_eqd[np] = distance;
nq = particle[n].npartners;
particle[n].npartners++;
particle[n].partner[nq] = i;
particle[n].partner_eqd[nq] = distance;
}
}
}
}
}
}
if (reaction)
{
/* TEST */
if ((RD_REACTION == CHEM_DNA_ENZYME)||(RD_REACTION == CHEM_DNA_ENZYME_REPAIR))
{
/* consider merged marticles as reactive */
if ((particle[i].added == 1)&&(particle[i].type >= 3)&&(particle[i].type <= 6))
{
particle[i].paired = 1;
particle[i].partner_molecule = molk;
for (p1 = 0; p1<particle[i].npartners; p1++)
{
n = particle[i].partner[p1];
particle[n].paired = 1;
particle[n].partner_molecule = molk;
}
}
if ((particle[k].added == 1)&&(type2 >= 3)&&(type2 <= 6))
{
particle[k].paired = 1;
particle[k].partner_molecule = moli;
for (p1 = 0; p1<particle[k].npartners; p1++)
{
n = particle[k].partner[p1];
particle[n].paired = 1;
particle[n].partner_molecule = moli;
}
}
}
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = 0.0;
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
}
}
p++;
}
return(ncollisions);
}
void translate_cluster(int j, t_cluster cluster[NMAXCIRCLES], t_particle particle[NMAXCIRCLES], double dx, double dy)
/* translate a cluster and all partcles it contains */
{
int k, p, np;
np = cluster[j].nparticles;
if (np == 1)
{
p = cluster[j].particle[0];
particle[p].xc += dx;
particle[p].yc += dy;
cluster[j].xg = particle[p].xc;
cluster[j].yg = particle[p].yc;
}
else
{
for (k=0; k<np; k++)
{
p = cluster[j].particle[k];
particle[p].xc += dx;
particle[p].yc += dy;
}
cluster[j].xg += dx;
cluster[j].yg += dy;
}
}
void rotate_cluster(int j, t_cluster cluster[NMAXCIRCLES], t_particle particle[NMAXCIRCLES], double angle)
/* translate a cluster and all partcles it contains */
{
int k, p, np;
double ca, sa, x, y;
np = cluster[j].nparticles;
if (np == 1)
{
p = cluster[j].particle[0];
particle[p].angle += angle;
cluster[j].angle = particle[p].angle;
}
else
{
ca = cos(angle);
sa = sin(angle);
for (k=0; k<np; k++)
{
p = cluster[j].particle[k];
particle[p].angle += angle;
x = particle[p].xc - cluster[j].xg;
y = particle[p].yc - cluster[j].yg;
particle[p].xc = cluster[j].xg + ca*x - sa*y;
particle[p].yc = cluster[j].yg + sa*x + ca*y;
}
cluster[j].angle += angle;
}
}
void rotate_cluster_around_particle(int j, int i, t_cluster cluster[NMAXCIRCLES], t_particle particle[NMAXCIRCLES], double angle)
/* translate a cluster and all partcles it contains around center of particle i */
{
int k, p, np;
double ca, sa, x, y;
np = cluster[j].nparticles;
if (np == 1)
{
p = cluster[j].particle[0];
particle[p].angle += angle;
cluster[j].angle = particle[p].angle;
}
else
{
ca = cos(angle);
sa = sin(angle);
for (k=0; k<np; k++)
{
p = cluster[j].particle[k];
particle[p].angle += angle;
x = particle[p].xc - particle[i].xc;
y = particle[p].yc - particle[i].yc;
particle[p].xc = particle[i].xc + ca*x - sa*y;
particle[p].yc = particle[i].yc + sa*x + ca*y;
}
cluster[j].angle += angle;
}
}
void translate_and_rotate_cluster(int j, t_cluster cluster[NMAXCIRCLES], t_particle particle[NMAXCIRCLES], double dx, double dy, double angle)
/* translate and rotate a cluster and all partcles it contains */
{
int k, p, np;
double ca, sa, x, y;
np = cluster[j].nparticles;
if (np == 1)
{
p = cluster[j].particle[0];
particle[p].xc += dx;
particle[p].yc += dy;
particle[p].angle += angle;
cluster[j].xg = particle[p].xc;
cluster[j].yg = particle[p].yc;
cluster[j].angle = particle[p].angle;
}
else
{
ca = cos(angle);
sa = sin(angle);
for (k=0; k<np; k++)
{
p = cluster[j].particle[k];
x = particle[p].xc - cluster[j].xg;
y = particle[p].yc - cluster[j].yg;
particle[p].xc = cluster[j].xg + ca*x - sa*y + dx;
particle[p].yc = cluster[j].yg + sa*x + ca*y + dy;
}
cluster[j].xg += dx;
cluster[j].yg += dy;
cluster[j].angle += angle;
}
}
int merge_clusters(int i, int j, int pi, int pj, t_particle particle[NMAXCIRCLES], t_cluster cluster[NMAXCIRCLES], int adjust_angles, short int flip)
/* merge clusters i and j to form new cluster il */
/* il is number of largest cluster aming i and j */
/* pi and pj are the numbers of the contact particles */
/* returns number of new (largest) cluster il */
{
int p, q, q0, c0, is, il, ns, nl, ps, pl;
double mtot, dangle, d2, newangle;
static double alpha, alpha2;
static int first = 1, nmergers = 0;
if (first)
{
alpha = PI/(double)NPOLY;
alpha2 = 2.0*alpha;
first = 0;
}
if (i == j) return(i);
nmergers++;
/* find largest cluster */
if (cluster[i].nparticles >= cluster[j].nparticles)
{
il = i;
is = j;
pl = pi;
ps = pj;
}
else
{
il = j;
is = i;
pl = pj;
ps = pi;
}
ns = cluster[is].nparticles;
nl = cluster[il].nparticles;
if (ns + nl >= NMAXPARTINCLUSTER)
{
printf("Warning: NMAXPARTINCLUSTER is too small\n");
printf("Try increasing to %i\n", cluster[i].nparticles + cluster[j].nparticles);
return(0);
}
printf("Merging clusters %i and %i, having %i and %i particles\n", il, is, nl, ns);
fprintf(lj_log, "Merging clusters %i and %i, having %i and %i particles\n", il, is, nl, ns);
fprintf(lj_log, "Large cluster %i:\n", il);
for (p=0; p<nl; p++)
{
q = cluster[il].particle[p];
fprintf(lj_log, "Particle %i (%i), angle %.3lg, flip %i\n", p, q, particle[q].angle*180.0/PI, particle[q].flip);
}
fprintf(lj_log, "Reacting particle %i\n\n", pl);
// fprintf(lj_log, "Cluster %i:\n", is);
// for (p=0; p<ns; p++)
// {
// q = cluster[is].particle[p];
// fprintf(lj_log, "Particle %i (%i), angle %.3lg, flip %i\n", p, q, particle[q].angle*180.0/PI, particle[q].flip);
// }
// fprintf(lj_log, "Reacting particle %i\n", ps);
cluster[is].active = 0;
/* update list of particles */
cluster[il].nparticles = ns + nl;
c0 = particle[cluster[il].particle[0]].cluster_color;
for (p=0; p<ns; p++)
{
q = cluster[is].particle[p];
cluster[il].particle[nl+p] = q;
particle[q].cluster = il;
particle[q].cluster_color = c0;
particle[q].collision = nmergers + 1;
}
/* update cluster size for P_CLUSTER_SIZE color scheme */
for (p=0; p<ns+nl; p++)
{
q = cluster[il].particle[p];
particle[q].cluster_size = ns + nl;
}
if ((NPOLY%2 == 1)&&(flip)) for (p=0; p<ns; p++)
{
q = cluster[il].particle[nl + p];
particle[q].flip = 1 - particle[q].flip;
}
fprintf(lj_log, "Small cluster %i:\n", is);
for (p=0; p<ns; p++)
{
q = cluster[is].particle[p];
fprintf(lj_log, "Particle %i (%i), angle %.3lg, flip %i\n", p, q, particle[q].angle*180.0/PI, particle[q].flip);
}
fprintf(lj_log, "Reacting particle %i\n\n", ps);
/* adjust angles */
/* use rotate_cluster ? */
if (adjust_angles)
{
for (p=0; p<nl; p++)
{
q = cluster[il].particle[p];
// printf("p = %i, angle = %.5lg\n", p, particle[q].angle*180.0/PI);
while (particle[q].angle >= alpha2) particle[q].angle -= alpha2;
while (particle[q].angle < 0.0) particle[q].angle += alpha2;
}
q = cluster[il].particle[0];
newangle = particle[q].angle;
cluster[il].angle = newangle;
// if (NPOLY%2==1) newangle += alpha;
for (p=nl; p<ns+nl; p++)
{
q = cluster[il].particle[p];
particle[q].angle = newangle;
// if ((NPOLY%2==1)&&(particle[q].flip != particle[ps].flip)) particle[q].angle += PI;
}
// if (NPOLY%2==1) for (p=nl; p<ns+nl; p++)
// {
// q = cluster[il].particle[p];
// if (particle[q].flip != particle[ps].flip) particle[q].angle += alpha;
// }
if (NPOLY%2==1) for (p=0; p<ns+nl; p++)
{
q = cluster[il].particle[p];
if (particle[q].flip == particle[0].flip) particle[q].angle = newangle;
else particle[q].angle = newangle + alpha;
}
}
/* total mass */
mtot = cluster[is].mass + cluster[il].mass;
/* distance between centers of gravity squared */
d2 = (cluster[i].xg - cluster[j].xg)*(cluster[i].xg - cluster[j].xg);
d2 += (cluster[i].yg - cluster[j].yg)*(cluster[i].yg - cluster[j].yg);
/* update center of gravity */
cluster[il].xg = (cluster[is].xg + cluster[il].xg)/mtot;
cluster[il].yg = (cluster[is].yg + cluster[il].yg)/mtot;
/* update moment of intertia (using parallel axis thm) */
cluster[il].inertia_moment += cluster[is].inertia_moment;
cluster[il].inertia_moment += d2*cluster[il].mass*cluster[is].mass/mtot;
cluster[il].inertia_moment_inv = 1.0/cluster[il].inertia_moment;
/* update total mass */
cluster[il].mass = mtot;
cluster[il].mass_inv = 1.0/mtot;
fprintf(lj_log, "Merged cluster %i:\n", is);
for (p=0; p<ns+nl; p++)
{
q = cluster[il].particle[p];
fprintf(lj_log, "Particle %i (%i), angle %.3lg, flip %i\n", p, q, particle[q].angle*180.0/PI, particle[q].flip);
}
fprintf(lj_log, "Reacting particle %i\n\n", ps);
// short int active; /* has value 1 if cluster is active */
// short int thermostat; /* has value 1 if cluster is coupled to thermostat */
// double xg, yg; /* center of gravity */
// double vx, vy; /* velocity of center of gravity */
// double angle; /* orientation of cluster */
// double omega; /* angular velocity of cluster */
// double mass, mass_inv; /* mass of cluster and its inverse */
// double inertia_moment, inertia_moment_inv; /* moment of inertia */
// double fx, fy, torque; /* force and torque */
// double energy, emean; /* energy and averaged energy */
// double dirmean; /* time-averaged direction */
// int nparticles; /* number of particles in cluster */
// int particle[NMAXPARTINCLUSTER]; /* list of particles in cluster */
return(il);
}
int chem_multi_glue_polygon(int i, int type2, int maxpartners, t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES], t_cluster cluster[NMAXCIRCLES], t_collision *collisions, int ncollisions, double reaction_prob, int mergeclusters)
/* simplified version of chem_multi_glue_molecule without triangle and similar */
/* conditions, but taking polygon geometry into account */
{
int k, p, q, p1, q1, p2, np, nq, n, m, closeby = 0, reaction = 0, jp[NMAXPARTNERS], jq[NMAXPARTNERS], jtot[NMAXPARTNERS], r, kk, different, np2, moli, molk, mp, newpartner, pp, type1, poly_condition, nangle, norient;
double distance, angle, move_factor, xnew, ynew, vxnew, vynew, m1, m2, mr1, mr2, deltav, x, y, ri, rk, alpha, alpha2, ca, rel_angle, rorient, delta, rorient_new, anglei_new, deltax, deltay, x1, y1;
type1 = particle[i].type;
np = particle[i].npartners;
moli = particle[i].molecule;
if (np > maxpartners) return(ncollisions);
m1 = 1.0/particle[i].mass_inv;
for (p=0; p<np; p++)
{
jp[p] = particle[i].partner[p];
m1 += 1.0/particle[jp[p]].mass_inv;
}
alpha = PI/(double)NPOLY;
alpha2 = 2.0*alpha;
ca = cos(alpha);
ri = particle[i].radius*ca;
rk = particle[k].radius*ca;
p = 0;
while ((p<particle[i].hash_nneighb)&&(!reaction))
{
k = particle[i].hashneighbour[p];
nq = particle[k].npartners;
molk = particle[k].molecule;
if (np + nq > maxpartners) return(0);
if ((particle[k].active)&&(particle[k].type == type2)&&(nq <= maxpartners))
{
distance = module2(particle[i].deltax[p], particle[i].deltay[p]);
rel_angle = argument(particle[i].deltax[p], particle[i].deltay[p]);
poly_condition = (distance < REACTION_DIST*(ri+rk));
rorient = particle[k].angle - particle[i].angle;
if (NPOLY%2 == 1) rorient -= alpha;
norient = (int)(rorient/alpha2 + 0.5);
delta = rorient - norient*alpha2;
poly_condition *= (vabs(delta) < DELTAMAX);
if ((poly_condition)&&((double)rand()/RAND_MAX < reaction_prob))
{
/* find nearest orientation facing particle k */
rorient_new = norient*alpha2;
nangle = (int)((particle[i].angle - rel_angle)/alpha2);
anglei_new = rel_angle + (double)(2*nangle+1)*alpha;
m2 = 1.0/particle[k].mass_inv;
for (q=0; q<nq; q++)
{
jq[q] = particle[k].partner[q];
m2 += 1.0/particle[jq[q]].mass_inv;
}
mr1 = m1/(m1 + m2);
mr2 = 1.0 - mr1;
if ((np == 0)&&(nq == 0))
{
reaction = 1;
printf("Merging molecule %i with particle %i\n", i, k);
distance = (ri+rk)*PAIR_DRATIO;
// particle[i].angle = rel_angle - PI/(double)NPOLY;
particle[i].angle = anglei_new;
particle[k].angle = particle[i].angle + rorient_new;
if (NPOLY%2 == 1) particle[k].angle += alpha;
particle[k].xc = particle[i].xc + distance*cos(rel_angle);
particle[k].yc = particle[i].yc + distance*sin(rel_angle);
particle[i].npartners++;
particle[i].partner[0] = k;
particle[i].partner_eqd[0] = distance;
particle[i].partner_eqa[0] = rorient_new;
if (NPOLY%2 == 1) particle[i].partner_eqa[0] += alpha;
particle[k].npartners++;
particle[k].partner[0] = i;
particle[k].partner_eqd[0] = distance;
particle[k].partner_eqa[0] = -rorient_new;
if (NPOLY%2 == 1) particle[k].partner_eqa[0] -= alpha;
/* equalize speeds */
vxnew = mr1*particle[i].vx + mr2*particle[k].vx;
vynew = mr1*particle[i].vy + mr2*particle[k].vy;
particle[i].vx = vxnew;
particle[i].vy = vynew;
particle[k].vx = vxnew;
particle[k].vy = vynew;
if (mergeclusters)
merge_clusters(particle[i].cluster, particle[k].cluster, i, k, particle, cluster, 0, 0);
}
else if (np+nq+2 < NMAXPARTNERS)
{
/* check if i and k belong to different molecules */
different = 1;
for (p1=0; p1<np; p1++)
if (k == jp[p1]) different = 0;
for (q1=0; q1<nq; q1++)
if (i == jq[q1]) different = 0;
if (different)
{
deltav = module2(particle[i].vx - particle[k].vx, particle[i].vy - particle[k].vy);
// printf("Delta v is %.3lg\n", deltav);
if (deltav < DELTAVMAX)
{
reaction = 1;
printf("Pairing clusters containing particles %i and %i\n", i, k);
printf("np = %i, nq = %i\n", np, nq);
fprintf(lj_log, "Pairing clusters containing particles %i and %i\n", i, k);
fprintf(lj_log, "np = %i, nq = %i\n", np, nq);
/* TODO: fix angles */
distance = (ri+rk)*PAIR_DRATIO;
particle[i].angle = anglei_new;
for (p1=0; p1<np; p1++) particle[jp[p1]].angle = anglei_new;
particle[k].angle = particle[i].angle + rorient_new;
if (NPOLY%2 == 1) particle[k].angle += alpha;
/* translate/rotate molecule containing particle k */
deltax = -particle[k].xc + particle[i].xc + distance*cos(rel_angle);
deltay = -particle[k].yc + particle[i].yc + distance*sin(rel_angle);
particle[k].xc += deltax;
particle[k].yc += deltay;
for (q1=0; q1<nq; q1++)
{
particle[jq[q1]].xc += deltax;
particle[jq[q1]].yc += deltay;
particle[jq[q1]].angle = particle[i].angle + rorient_new;
if (NPOLY%2 == 1) particle[jq[q1]].angle += alpha;
}
particle[i].npartners++;
particle[i].partner[np] = k;
particle[i].partner_eqd[np] = distance;
particle[i].partner_eqa[np] = rorient_new;
if (NPOLY%2 == 1) particle[i].partner_eqa[np] += alpha;
for (p1=0; p1<np; p1++)
{
particle[jp[p1]].partner_eqa[p1] = rorient_new;
if (NPOLY%2 == 1) particle[i].partner_eqa[np] += alpha;
}
particle[k].npartners++;
particle[k].partner[nq] = i;
particle[k].partner_eqd[nq] = distance;
particle[k].partner_eqa[nq] = -rorient_new;
if (NPOLY%2 == 1) particle[k].partner_eqa[nq] -= alpha;
/* equalize speeds */
vxnew = mr1*particle[i].vx + mr2*particle[k].vx;
vynew = mr1*particle[i].vy + mr2*particle[k].vy;
particle[i].vx = vxnew;
particle[i].vy = vynew;
particle[k].vx = vxnew;
particle[k].vy = vynew;
/* TODO: fix angles */
for (p1=0; p1<np; p1++) for (q1=0; q1<nq; q1++)
{
particle[jp[p1]].vx = vxnew;
particle[jp[p1]].vy = vynew;
particle[jq[q1]].vx = vxnew;
particle[jq[q1]].vy = vynew;
}
if (mergeclusters)
merge_clusters(particle[i].cluster, particle[k].cluster, i, k, particle, cluster, 0, 0);
}
}
}
if (reaction)
{
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = 0.0;
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
}
}
p++;
}
return(ncollisions);
}
void repair_cluster(int cl, t_particle particle[NMAXCIRCLES], t_cluster cluster[NMAXCIRCLES], int nsteps, int kill_overlays)
/* repair cluster by letting positions converge to equilibrium position */
{
int t, j, k, p, q, np, nq, m;
double dist, eqdist, fx, fy, dx, dy, r, phi, newphi, newx, newy, eqdist2;
static double alpha, alpha2, ca, sa, kspring;
static int first = 1;
if (first)
{
alpha = PI/(double)NPOLY;
alpha2 = 2.0*alpha;
ca = cos(alpha);
sa = sin(alpha);
kspring = 5000.0;
first = 0;
}
for (t=0; t<nsteps; t++)
{
for (p=0; p<cluster[cl].nparticles; p++)
{
q = cluster[cl].particle[p];
fx = 0.0;
fy = 0.0;
for (j=0; j<particle[q].hash_nneighb; j++)
{
k = particle[q].hashneighbour[j];
if (particle[k].cluster == cl)
{
dx = particle[q].deltax[j];
dy = particle[q].deltay[j];
dist = module2(dx, dy);
eqdist = (particle[k].radius + particle[q].radius)*ca;
if (dist < 1.2*eqdist)
{
if ((NPOLY%2==0)||(particle[q].flip != particle[k].flip))
{
phi = argument(dx, dy);
// printf("phi = %.3lg, angle = %.3lg\t", phi*180.0/PI, particle[q].angle*180.0/PI);
m = (int)(0.5 + (double)NPOLY + (phi - particle[q].angle + alpha)/alpha2) - NPOLY;
newphi = particle[q].angle - alpha + (double)m*alpha2;
// printf("m = %i, newphi = %.3lg\n", m, newphi*180.0/PI);
newx = particle[k].xc - eqdist*cos(newphi);
newy = particle[k].yc - eqdist*sin(newphi);
// printf("(x,y) = (%.3lg, %.3lg) -> (%.3lg, %.3lg)\n", particle[q].xc, particle[q].yc, newx, newy);
dx = newx - particle[q].xc;
dy = newy - particle[q].yc;
r = module2(dx, dy);
// printf("Particle %i distance to target = %.3lg\n", k, r);
// if ((t == nsteps-1)&&(q == 470)&&(k == 472)) fprintf(lj_log, "Particle %i relative distance to target %i = %.5lg\n", q, k, r/eqdist);
fx += r*dx;
fy += r*dy;
}
else
{
eqdist2 = 1.0*(particle[k].radius + particle[q].radius)*sa;
if (dist < eqdist2)
{
fx -= 0.1*(eqdist2 - dist)*dx/dist;
fy -= 0.1*(eqdist2 - dist)*dy/dist;
}
}
}
if ((kill_overlays)&&(dist < REPAIR_MIN_DIST*eqdist))
{
nq = particle[q].npartners;
np = particle[k].npartners;
if (nq == 1) particle[q].active = 0;
if (np == 1) particle[k].active = 0;
// if (np > nq) particle[q].active = 0;
// else particle[k].active = 0;
}
}
}
particle[q].xc += kspring*fx*DT_PARTICLE;
particle[q].yc += kspring*fy*DT_PARTICLE;
}
}
}
int chem_multi_glue_polygon2(int i, int maxpartners, t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES], t_cluster cluster[NMAXCIRCLES], t_collision *collisions, int ncollisions, double reaction_prob, int mergeclusters, int singlecluster)
/* simplified version of chem_multi_glue_molecule without triangle and similar */
/* conditions, but taking polygon geometry into account */
/* version 2, for CHEM_POLYGON_CLUSTER interaction */
{
int k, p, q, p1, q1, p2, np, nq, n, m, closeby = 0, reaction = 0, jp[NMAXPARTNERS], jq[NMAXPARTNERS], jtot[NMAXPARTNERS], r, kk, different, np2, moli, molk, mp, newpartner, pp, type1, poly_condition, nangle, norient, cl1, cl2, cp, cq, newcluster, nmin, clmin, clmax, newreaction;
double distance, angle, move_factor, xnew, ynew, vxnew, vynew, m1, m2, mr1, mr2, deltav, x, y, ri, rk, alpha, alpha2, ca, rel_angle, rorient, delta, rorient_new, anglei_new, deltax, deltay, x1, y1, aratio, delta2, eqdistance, dx, dy, dalpha1, dalpha2, ssize1, ssize2;
static short int first = 1;
static int scluster;
if ((singlecluster)&&(first))
{
scluster = 0;
while (cluster[scluster].active == 0) scluster = rand()%ncircles;
cluster[scluster].selected = 1;
particle[scluster].collision = 1;
printf("Selected cluster %i as single cluster\n", scluster);
first = 0;
}
type1 = particle[i].type;
np = particle[i].npartners;
if (np > maxpartners) return(ncollisions);
cl1 = particle[i].cluster;
cp = cluster[cl1].nparticles;
m1 = cluster[cl1].mass;
alpha = PI/(double)NPOLY;
alpha2 = 2.0*alpha;
ca = cos(alpha);
ri = particle[i].radius*ca;
rk = particle[k].radius*ca;
p = 0;
while ((p<particle[i].hash_nneighb)&&(!reaction))
{
k = particle[i].hashneighbour[p];
nq = particle[k].npartners;
cl2 = particle[k].cluster;
if (cluster[cl1].nparticles < cluster[cl2].nparticles)
{
nmin = np;
clmin = cluster[cl1].nparticles;
clmax = cluster[cl2].nparticles;
}
else
{
nmin = nq;
clmin = cluster[cl2].nparticles;
clmax = cluster[cl1].nparticles;
}
// if (np + nq + 2 > maxpartners) return(ncollisions);
if ((!reaction)&&(particle[k].active)&&(np+nq+1 < maxpartners)&&(cl2!=cl1)&&(nmin <= SMALL_NP_MAXSIZE)&&(clmin <= SMALL_CLUSTER_MAXSIZE))
{
cq = cluster[cl2].nparticles;
// poly_condition = (cl1!=cl2);
/* test distance */
distance = module2(particle[i].deltax[p], particle[i].deltay[p]);
rel_angle = argument(particle[i].deltax[p], particle[i].deltay[p]);
poly_condition = (distance < REACTION_DIST*(ri+rk));
/* test relative angle */
rorient = particle[k].angle - particle[i].angle;
if (NPOLY%2 == 1) rorient -= alpha;
while (rorient > alpha) rorient -= alpha2;
while (rorient < -alpha) rorient += alpha2;
poly_condition *= (vabs(rorient) < DELTAMAX);
// norient = (int)(rorient/alpha2 + 0.5 + 2.0*(double)NPOLY);
// delta = rorient - (double)(norient-2*NPOLY)*alpha2;
// poly_condition *= (vabs(delta) < DELTAMAX);
/* test orientation */
aratio = 0.5*vabs(rel_angle)/alpha;
delta2 = aratio - (double)((int)aratio);
poly_condition *= (vabs(delta2 - 0.5) < 0.5*DELTAMAX*alpha);
/* option singlecluster: only allow merger if one of the clusters is selected cluster */
if (singlecluster) poly_condition *= ((cluster[cl1].selected)||(cluster[cl2].selected)||(clmax <= NOTSELECTED_CLUSTER_MAXSIZE));
newreaction = 0;
if ((poly_condition)&&((double)rand()/RAND_MAX < reaction_prob))
{
/* find nearest orientation facing particle k */
rorient_new = norient*alpha2;
nangle = (int)((particle[i].angle - rel_angle)/alpha2);
anglei_new = rel_angle + (double)(2*nangle+1)*alpha;
m2 = cluster[cl2].mass;
mr1 = m1/(m1 + m2);
mr2 = 1.0 - mr1;
if ((np == 0)&&(nq == 0))
{
reaction = 1;
newreaction = 1;
printf("Merging molecule %i with particle %i\n", i, k);
eqdistance = ri + rk;
particle[i].angle = anglei_new;
particle[k].angle = particle[i].angle + rorient_new;
if (NPOLY%2 == 1) particle[k].angle += alpha;
dx = 0.5*(distance - eqdistance)*cos(rel_angle);
dy = 0.5*(distance - eqdistance)*sin(rel_angle);
translate_cluster(cl1, cluster, particle, dx, dy);
translate_cluster(cl2, cluster, particle, -dx, -dy);
particle[i].npartners++;
particle[i].partner[0] = k;
particle[k].npartners++;
particle[k].partner[0] = i;
/* equalize speeds */
vxnew = mr1*particle[i].vx + mr2*particle[k].vx;
vynew = mr1*particle[i].vy + mr2*particle[k].vy;
particle[i].vx = vxnew;
particle[i].vy = vynew;
particle[k].vx = vxnew;
particle[k].vy = vynew;
if (mergeclusters)
newcluster = merge_clusters(particle[i].cluster, particle[k].cluster, i, k, particle, cluster, 0, (particle[i].flip == particle[k].flip));
}
// else if ((np+nq+2 < NMAXPARTNERS)&&(vabs(delta) < 0.5*DELTAMAX))
else if ((np+nq+2 < NMAXPARTNERS)&&(cp+cq <= CLUSTER_MAXSIZE))
{
deltav = module2(particle[i].vx - particle[k].vx, particle[i].vy - particle[k].vy);
// printf("Delta v is %.3lg\n", deltav);
if (deltav < DELTAVMAX)
{
reaction = 1;
newreaction = 1;
printf("Pairing clusters containing particles %i and %i\n", i, k);
printf("np = %i, nq = %i\n", np, nq);
fprintf(lj_log, "Pairing clusters containing particles %i and %i\n", i, k);
fprintf(lj_log, "np = %i, nq = %i\n", np, nq);
eqdistance = ri + rk;
dx = 0.5*(distance - eqdistance)*cos(rel_angle);
dy = 0.5*(distance - eqdistance)*sin(rel_angle);
dalpha1 = anglei_new - particle[i].angle;
dalpha2 = anglei_new + rorient_new - particle[k].angle;
if (NPOLY%2 == 1) dalpha2 += alpha;
/* round to closest multiple of alpha2 */
while (dalpha1 > 0.5*DELTAMAX) dalpha1 -= alpha2;
while (dalpha1 < -0.5*DELTAMAX) dalpha1 += alpha2;
while (dalpha2 > 0.5*DELTAMAX) dalpha2 -= alpha2;
while (dalpha2 < -0.5*DELTAMAX) dalpha2 += alpha2;
translate_cluster(cl1, cluster, particle, dx, dy);
translate_cluster(cl2, cluster, particle, -dx, -dy);
ssize1 = 0.02*sqrt((double)cluster[cl1].nparticles);
ssize2 = 0.02*sqrt((double)cluster[cl2].nparticles);
if (vabs(dalpha1) + ssize1 < 0.5*DELTAMAX)
rotate_cluster_around_particle(cl1, i, cluster, particle, dalpha1);
else printf("Did not rotate cluster of size %.3lg\n", ssize1);
if (vabs(dalpha2) + ssize2 < 0.5*DELTAMAX)
rotate_cluster_around_particle(cl2, k, cluster, particle, dalpha2);
else printf("Did not rotate cluster of size %.3lg\n", ssize2);
particle[i].npartners++;
particle[i].partner[np] = k;
particle[k].npartners++;
particle[k].partner[nq] = i;
/* equalize speeds */
vxnew = mr1*particle[i].vx + mr2*particle[k].vx;
vynew = mr1*particle[i].vy + mr2*particle[k].vy;
for (p1=0; p1<cluster[cl1].nparticles; p1++)
{
q = cluster[cl1].particle[p1];
particle[q].vx = vxnew;
particle[q].vy = vynew;
}
for (p1=0; p1<cluster[cl2].nparticles; p1++)
{
q = cluster[cl2].particle[p1];
particle[q].vx = vxnew;
particle[q].vy = vynew;
}
if (mergeclusters)
{
newcluster = merge_clusters(particle[i].cluster, particle[k].cluster, i, k, particle, cluster, 1, (particle[i].flip == particle[k].flip));
}
}
}
if ((newreaction)&&(singlecluster)&&((cluster[cl1].selected)||(cluster[cl2].selected)))
{
scluster = newcluster;
printf("[chem_multi_glue_polygon2] cluster 1 = %i, cluster 2 = %i, newcluster = %i\n", cl1, cl2, newcluster);
cluster[cl1].selected = 1;
cluster[cl2].selected = 1;
// cluster[newcluster].selected = 1;
printf("[chem_multi_glue_polygon2] Selected cluster: %i\n", scluster);
}
if (reaction)
{
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = 0.0;
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
}
}
// else if ((nmin > SMALL_NP_MAXSIZE)||(clmin > SMALL_CLUSTER_MAXSIZE))
// {
// printf("No merger - Parameters: nmin = %i, clmin = %i\n", nmin, clmin);
// }
p++;
}
return(ncollisions);
}
int chem_split_molecule(int i, t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES], t_collision *collisions, int ncollisions)
/* split molecule containing particle i from all other molecules */
{
int np, nmolp, mol, n, m, p, q, r, mm;
int m_table[NMAXPARTNERMOLECULES];
short int reaction = 0;
np = particle[i].npartners;
if (np==0) return(ncollisions);
mol = particle[i].molecule;
nmolp = molecule[mol].npartners;
printf("Molecule %i has %i partners: ", mol, nmolp);
fprintf(lj_log, "[chem_split_molecule] Molecule %i has %i partners: ", mol, nmolp);
for (mm=0; mm<nmolp; mm++)
{
m_table[mm] = molecule[mol].partner[mm];
printf("%i ", m_table[mm]);
fprintf(lj_log, "%i ", m_table[mm]);
}
printf("\n");
fprintf(lj_log, "\n");
for (p=0; p<np; p++)
{
n = particle[i].partner[p];
if (particle[n].molecule != mol)
{
dissociate_particles(i, n, p, particle);
reaction = 1;
}
}
np = particle[i].npartners;
for (p=0; p<np; p++)
{
for (q=0; q<np; q++)
{
n = particle[i].partner[p];
for (r=0; r<particle[n].npartners; r++)
{
m = particle[n].partner[r];
if (particle[m].molecule != mol)
{
dissociate_particles(n, m, r, particle);
reaction = 1;
}
}
}
}
if (reaction)
{
update_single_molecule_data(mol, particle, molecule);
for (mm=0; mm<nmolp; mm++)
update_single_molecule_data(m_table[mm], particle, molecule);
printf("[chem_split_molecule] - dissociating molecule %i\n", mol);
fprintf(lj_log, "[chem_split_molecule] - dissociating molecule %i\n", mol);
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = type_hue(particle[i].type);
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
return(ncollisions);
}
int chem_split_molecule_if_nearby(int i, int type, t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES], t_collision *collisions, int ncollisions, double reaction_dist, double reaction_prob)
/* split molecules containing i if i is close to particle of type type */
{
int p, k, mol;
double distance;
short int reaction = 0;
mol = particle[i].molecule;
p = 0;
while ((p<particle[i].hash_nneighb)&&(!reaction))
{
k = particle[i].hashneighbour[p];
if ((particle[k].type == type)&&(particle[k].molecule != mol))
{
distance = module2(particle[i].xc - particle[k].xc, particle[i].yc - particle[k].yc);
if ((distance < reaction_dist)&&((double)rand()/RAND_MAX < reaction_prob))
{
chem_split_molecule(i, particle, molecule, collisions, ncollisions);
reaction = 1;
}
}
p++;
}
if (reaction)
{
printf("dissociating molecule %i\n", mol);
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = type_hue(particle[i].type);
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
return(ncollisions);
}
int chem_local_split_molecule_if_nearby(int i, int type, int enzyme_type, t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES], t_collision *collisions, int ncollisions, double reaction_dist, double reaction_prob)
/* split atoms in molecule containing i from type type, if i is close to particle of type enzyme_type */
{
int p, k, moli, molk, mol_diss, q, n, q1, m, added, mp, pp;
double distance;
short int reaction = 0, reaction1 = 0;
moli = particle[i].molecule;
p = 0;
while ((p<particle[i].hash_nneighb)&&(!reaction))
{
reaction1 = 0;
k = particle[i].hashneighbour[p];
molk = particle[k].molecule;
added = particle[i].added;
// added = 0;
if ((added == 0)&&(particle[k].type == enzyme_type)&&(molk != moli))
{
distance = module2(particle[i].xc - particle[k].xc, particle[i].yc - particle[k].yc);
if ((distance < reaction_dist)&&((double)rand()/RAND_MAX < reaction_prob))
{
if (particle[i].coulomb < 5) particle[i].coulomb = 5;
particle[i].reactive = 0;
for (q=0; q<particle[i].npartners; q++)
{
n = particle[i].partner[q];
if (particle[n].added == 0)
{
if (particle[n].type == type)
{
mol_diss = particle[n].molecule;
dissociate_particles(i, n, q, particle);
if (particle[n].coulomb < 5) particle[n].coulomb = 5;
reaction = 1;
reaction1 = 1;
}
else if (particle[n].type == particle[i].type)
{
for (q1=0; q1<particle[n].npartners; q1++)
{
m = particle[n].partner[q1];
if ((particle[m].type == type)&&(particle[m].added == 0))
{
mol_diss = particle[m].molecule;
dissociate_particles(n, m, q1, particle);
if (particle[n].coulomb < 5) particle[n].coulomb = 5;
if (particle[m].coulomb < 5) particle[m].coulomb = 5;
particle[n].reactive = 0;
particle[m].reactive = 0;
reaction = 1;
reaction1 = 1;
}
}
}
}
}
/* TEST */
if ((RD_REACTION == CHEM_DNA_ENZYME)||(RD_REACTION == CHEM_DNA_ENZYME_REPAIR))
{
if ((particle[i].type >= 3)&&(particle[i].type <= 6))
{
particle[i].paired = 0;
for (q1 = 0; q1 <= particle[i].npartners; q1++)
{
n = particle[i].partner[q1];
particle[n].paired = 0;
}
particle[k].paired = 0;
for (q1 = 0; q1 <= particle[k].npartners; q1++)
{
n = particle[k].partner[q1];
particle[n].paired = 0;
}
}
}
}
/* update molecule data */
if ((reaction1)&&(moli != mol_diss))
{
printf("Splitting molecules %i and %i\n", moli, mol_diss);
mp = molecule[moli].npartners;
pp = 0;
while (molecule[moli].partner[pp] != mol_diss) pp++;
if (pp < mp)
{
while (pp < mp-1)
{
molecule[moli].partner[pp] = molecule[moli].partner[pp+1];
molecule[moli].connection_type[pp] = molecule[moli].connection_type[pp+1];
pp++;
}
molecule[moli].npartners--;
}
mp = molecule[mol_diss].npartners;
pp = 0;
while (molecule[mol_diss].partner[pp] != moli) pp++;
if (pp < mp)
{
while (pp < mp-1)
{
molecule[mol_diss].partner[pp] = molecule[mol_diss].partner[pp+1];
molecule[mol_diss].connection_type[pp] = molecule[mol_diss].connection_type[pp+1];
pp++;
}
molecule[mol_diss].npartners--;
}
// sleep(3);
}
}
p++;
}
if (reaction)
{
printf("dissociating molecule %i\n", moli);
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = type_hue(particle[i].type);
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
return(ncollisions);
}
void change_type_proportion(t_particle particle[NMAXCIRCLES], double prop)
/* change proportion of particles of types 1 or 2 */
{
int i, n0=0, n1=0, n2=0, ntot, nc=0, nmod, counter=0, cmax=1000;
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].type == 0) n0++;
if (particle[i].type == 1) n1++;
if (particle[i].type == 2) n2++;
}
ntot = n0 + n1 + n2;
n0 += n1;
if ((double)(n0+1) < prop*(double)ntot)
{
nmod = (int)((double)ntot*prop - (double)n0);
if (nmod > 0) while ((nc<nmod)&&(counter<cmax))
{
i = rand()%ncircles;
if ((particle[i].type == 2)&&(particle[i].active))
{
particle[i].type = 1;
particle[i].radius = MU;
particle[i].interaction = INTERACTION;
particle[i].eq_dist = EQUILIBRIUM_DIST;
particle[i].spin_range = SPIN_RANGE;
particle[i].spin_freq = SPIN_INTER_FREQUENCY;
particle[i].mass_inv = 1.0/PARTICLE_MASS;
particle[i].inertia_moment_inv = 1.0/PARTICLE_INERTIA_MOMENT;
particle[i].charge = CHARGE;
nc++;
}
counter++;
}
}
else if ((double)(n0-1) > prop*(double)ntot)
{
nmod = (int)((double)n0 - (double)ntot*prop);
if (nmod > 0) while ((nc<nmod)&&(counter<cmax))
{
i = rand()%ncircles;
if ((particle[i].type <= 1)&&(particle[i].active))
{
particle[i].type = 2;
particle[i].radius = MU_B;
particle[i].interaction = INTERACTION_B;
particle[i].eq_dist = EQUILIBRIUM_DIST_B;
particle[i].spin_range = SPIN_RANGE_B;
particle[i].spin_freq = SPIN_INTER_FREQUENCY_B;
particle[i].mass_inv = 1.0/PARTICLE_MASS_B;
particle[i].inertia_moment_inv = 1.0/PARTICLE_INERTIA_MOMENT_B;
particle[i].charge = CHARGE_B;
nc++;
}
counter++;
}
}
}
int find_partners(t_particle *particle, int position, t_particle* *pstack, int *stacksize, int cluster)
/* look for active partners of particle[position], returns difference in partners */
{
int k, nopen = 0, n;
if (!pstack[position]->active) return(-1);
pstack[position]->cluster = cluster;
for (k=0; k<pstack[position]->npartners; k++)
{
n = pstack[position]->partner[k];
if ((particle[n].active)&&(particle[n].cluster != cluster))
{
particle[n].tested = 1;
particle[n].cluster = cluster;
particle[n].cactive = 1;
nopen++;
if (*stacksize < ncircles)
{
(*stacksize)++;
pstack[*stacksize-1] = &particle[n];
}
}
}
if (nopen == 0)
{
pstack[position]->cactive = 0;
return(-1);
}
else return(nopen);
}
int update_cluster_color(t_particle particle[NMAXCIRCLES])
/* update the colors of clusters */
{
int i, k, p, position, nactive, stacksize, nclusters = 0;
t_particle **cstack;
cstack = (t_particle* *)malloc(ncircles*sizeof(struct t_particle *));
#pragma omp parallel for private(i)
for (i=0; i<ncircles; i++) particle[i].tested = 0;
for (i=0; i<ncircles; i++) if ((particle[i].active)&&(!particle[i].tested))
{
position = 0;
stacksize = 1;
nactive = 1;
cstack[0] = &particle[i];
particle[i].cactive = 1;
particle[i].tested = 1;
/* do a depth first search starting in i */
while (nactive > 0)
{
while (!cstack[position]->cactive) position++;
if (position == stacksize) position = 0;
/* find an active partner in stack */
nactive += find_partners(particle, position, cstack, &stacksize, particle[i].cluster);
}
nclusters++;
}
free(cstack);
return(nclusters);
}
int repair_dna(t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES], t_collision *collisions, int ncollisions)
/* repair unwanted connections in DNA, for CHEM_DNA_ENZYME_REPAIR reaction type */
{
int i, mol, moli, j, molj, p, q, p1, q1, molp, molpp, molq, molqq, r, type, type1, type2, type3, type4, np, nq, pp, qq, mp, split, common_partner, smol1, smol2, npartners;
int p_table[NMAXPARTNERMOLECULES], q_table[NMAXPARTNERMOLECULES];
double dist;
printf("Repairing DNA\n");
/* Prevent single base from connecting to two different molecules */
for (moli=0; moli<nmolecules; moli++) if (molecule[moli].added)
{
split = 0;
/* search for double connections */
for (j=0; j<molecule[moli].npartners; j++)
{
molj = molecule[moli].partner[j];
type1 = molecule[moli].connection_type[j];
if (type1 >= 3)
{
for (p=0; p<molecule[moli].npartners; p++)
{
molp = molecule[moli].partner[p];
type2 = molecule[moli].connection_type[p];
if ((type2 >= 3)&&(molp != molj))
{
smol1 = molj;
smol2 = molp;
split = 1;
}
}
}
}
if (split)
{
printf("Splitting molecule %i from molecules %i and %i\n\n\n", moli, smol1, smol2);
for (p=0; p<molecule[moli].nparticles; p++)
{
p1 = molecule[moli].particle[p];
type = particle[p1].type;
if (type >= 3)
{
i = p1;
for (q=0; q<particle[p1].npartners; q++)
{
q1 = particle[p1].partner[q];
if (particle[q1].molecule == molj)
dissociate_particles(p1, q1, q, particle);
}
}
}
for (q=0; q<molecule[smol1].nparticles; q++)
{
q1 = molecule[smol1].particle[q];
type = particle[q1].type;
if (type >= 3)
for (p=0; p<particle[q1].npartners; p++)
{
p1 = particle[q1].partner[p];
if (particle[p1].molecule == moli)
dissociate_particles(q1, p1, p, particle);
}
}
for (q=0; q<molecule[smol2].nparticles; q++)
{
q1 = molecule[smol2].particle[q];
type = particle[q1].type;
if (type >= 3)
for (p=0; p<particle[q1].npartners; p++)
{
p1 = particle[q1].partner[p];
if (particle[p1].molecule == moli)
dissociate_particles(q1, p1, p, particle);
}
}
/* update molecule data */
mp = molecule[moli].npartners;
pp = 0;
while (molecule[moli].partner[pp] != smol1) pp++;
if (pp < mp)
{
while (pp < mp-1)
{
molecule[moli].partner[pp] = molecule[moli].partner[pp+1];
molecule[moli].connection_type[pp] = molecule[moli].connection_type[pp+1];
pp++;
}
molecule[moli].npartners--;
}
pp = 0;
while (molecule[moli].partner[pp] != smol2) pp++;
if (pp < mp)
{
while (pp < mp-1)
{
molecule[moli].partner[pp] = molecule[moli].partner[pp+1];
molecule[moli].connection_type[pp] = molecule[moli].connection_type[pp+1];
pp++;
}
molecule[moli].npartners--;
}
mp = molecule[smol1].npartners;
pp = 0;
while (molecule[smol1].partner[pp] != moli) pp++;
if (pp < mp)
{
while (pp < mp-1)
{
molecule[smol1].partner[pp] = molecule[smol1].partner[pp+1];
molecule[smol1].connection_type[pp] = molecule[smol1].connection_type[pp+1];
pp++;
}
molecule[smol1].npartners--;
}
mp = molecule[smol2].npartners;
pp = 0;
while (molecule[smol2].partner[pp] != moli) pp++;
if (pp < mp)
{
while (pp < mp-1)
{
molecule[smol2].partner[pp] = molecule[smol2].partner[pp+1];
molecule[smol2].connection_type[pp] = molecule[smol2].connection_type[pp+1];
pp++;
}
molecule[smol2].npartners--;
}
printf("dissociating molecule %i\n", moli);
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = type_hue(particle[i].type);
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
}
/* Test for skipped bases */
/* if moli and molj are paired molecules, check whether they form a "square" */
/* i.e. a partner of a partner of moli is a partner of molj */
/* taking the connection types into account */
for (moli=0; moli<nmolecules; moli++) if (molecule[moli].added)
for (j=0; j<molecule[moli].npartners; j++)
{
molj = molecule[moli].partner[j];
type1 = molecule[moli].connection_type[j];
type2 = 3 - type1;
if ((molecule[molj].added)&&((type1 == 1)||(type1 == 2))) /* i-j connection is a backbone */
{
/* find base-neighbours for moli (normally there should be at most one) */
np = 0;
for (p=0; p<molecule[moli].npartners; p++)
{
molp = molecule[moli].partner[p];
type3 = molecule[moli].connection_type[p];
if (type3 >= 3)
{
p_table[np] = molp;
np++;
}
}
/* find base-neighbours for molj (normally there should be at most one) */
nq = 0;
for (q=0; q<molecule[molj].npartners; q++)
{
molq = molecule[molj].partner[q];
type3 = molecule[molj].connection_type[q];
// if ((molq != molj)&&(type3 >= 3))
if (type3 >= 3)
{
q_table[nq] = molq;
nq++;
}
}
/* test for split, split occurs if each molecule has a base-neighbour,
and they are not neighbours */
if ((np == 0)||(nq == 0)) split = 0;
else
{
split = 1;
printf("Base partners of molecule %i(%i): ", moli, type1);
for (p=0; p<np; p++) printf("%i ", p_table[p]);
printf("\n");
printf("Base partners of molecule %i(%i): ", molj, type2);
for (q=0; q<nq; q++) printf("%i ", q_table[q]);
printf("\n");
for (p=0; p<np; p++)
{
molp = p_table[p];
for (q=0; q<nq; q++)
{
molq = q_table[q];
printf("Checking base partners %i and %i\n", molp, molq);
printf("type1 = %i, type2 = %i\n", type1, type2);
printf("Molecule %i has %i partners: ", molp, molecule[molp].npartners);
for (pp = 0; pp < molecule[molp].npartners; pp++)
printf("%i(%i) ", molecule[molp].partner[pp], molecule[molp].connection_type[pp]);
printf("\n");
printf("Molecule %i has %i partners: ", molq, molecule[molq].npartners);
for (pp = 0; pp < molecule[molq].npartners; pp++)
printf("%i(%i) ", molecule[molq].partner[pp], molecule[molq].connection_type[pp]);
printf("\n");
for (pp = 0; pp < molecule[molp].npartners; pp++)
{
molpp = molecule[molp].partner[pp];
type4 = molecule[molp].connection_type[pp];
printf("Testing molecule %i(%i)\n", molpp, type4);
if ((type4 == type2)&&(molpp == molq))
split = 0;
}
}
}
}
if (split) /* break backbone link between i and j */
{
printf("Splitting molecules %i and %i\n\n\n", moli, molj);
for (p=0; p<molecule[moli].nparticles; p++)
{
p1 = molecule[moli].particle[p];
type = particle[p1].type;
if (type == type1)
i = p1;
for (q=0; q<particle[p1].npartners; q++)
{
q1 = particle[p1].partner[q];
if (particle[q1].molecule == molj)
dissociate_particles(p1, q1, q, particle);
}
}
for (q=0; q<molecule[molj].nparticles; q++)
{
q1 = molecule[molj].particle[q];
type = particle[q1].type;
if (type == type2)
for (p=0; p<particle[q1].npartners; p++)
{
p1 = particle[q1].partner[p];
if (particle[p1].molecule == moli)
dissociate_particles(q1, p1, p, particle);
}
}
// printf("Splitting molecules %i and %i\n", moli, mol_diss);
/* update molecule data */
mp = molecule[moli].npartners;
pp = 0;
while (molecule[moli].partner[pp] != molj) pp++;
if (pp < mp)
{
while (pp < mp-1)
{
molecule[moli].partner[pp] = molecule[moli].partner[pp+1];
molecule[moli].connection_type[pp] = molecule[moli].connection_type[pp+1];
pp++;
}
molecule[moli].npartners--;
}
mp = molecule[molj].npartners;
pp = 0;
while (molecule[molj].partner[pp] != moli) pp++;
if (pp < mp)
{
while (pp < mp-1)
{
molecule[molj].partner[pp] = molecule[molj].partner[pp+1];
molecule[molj].connection_type[pp] = molecule[molj].connection_type[pp+1];
pp++;
}
molecule[molj].npartners--;
}
printf("dissociating molecule %i\n", moli);
collisions[ncollisions].x = particle[i].xc;
collisions[ncollisions].y = particle[i].yc;
collisions[ncollisions].time = COLLISION_TIME;
collisions[ncollisions].color = type_hue(particle[i].type);
if (ncollisions < 2*NMAXCOLLISIONS - 1) ncollisions++;
else printf("Too many collisions\n");
}
}
}
return(ncollisions);
}
int check_dna_pairing(t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES], t_collision *collisions, int ncollisions)
/* repair unwanted connections in DNA, for CHEM_DNA_ENZYME_REPAIR reaction type */
{
int i, moli, j, type1, molj, p, pp, q, qq, deltatype;
short int split;
double dist;
printf("Checking DNA pairing\n");
// fprintf(lj_log, "Checking DNA pairing\n");
/* Test for wrong connections */
/* On rare occasions, it happens that a base pair tries to connect, but the connection fails */
/* However, the nucleotides are still recorded as connected */
/* This part tests for such falsely recorded connections based on the distance, and removes them */
for (moli=0; moli<nmolecules; moli++) if (molecule[moli].added)
{
for (j=0; j<molecule[moli].npartners; j++)
{
split = 0;
molj = molecule[moli].partner[j];
type1 = molecule[moli].connection_type[j];
/* search for wrongly recorded connections */
for (p=0; p<molecule[moli].nparticles; p++)
{
pp = molecule[moli].particle[p];
if (particle[pp].type == type1)
{
for (q=0; q<particle[p].npartners; q++)
{
qq = particle[p].partner[q];
deltatype = particle[qq].type - type1;
if (deltatype < 0) deltatype *= -1;
// if ((particle[qq].molecule == molj)&&(particle[qq].type >= 1))
if ((particle[qq].molecule == molj)&&(deltatype == 1))
{
dist = module2(particle[pp].xc - particle[qq].xc, particle[pp].yc - particle[qq].yc);
// if (dist > 10.0*MU)
// if (dist > 15.0*MU)
if (dist > 20.0*MU)
{
split = 1;
i = pp;
fprintf(lj_log, "\n\n\n Time = %i\n", frame_time);
fprintf(lj_log, "Particles %i(%i) in molecule %i and %i(%i) in molecule %i are at distance %.3lg\n", pp, particle[pp].type, moli, qq, particle[qq].type, molj, dist);
}
}
}
}
}
if (split)
{
printf("Splitting molecule %i from molecule %i because of wrong connection\n", moli, molj);
fprintf(lj_log, "Splitting molecule %i from molecule %i because of wrong connection\n", moli, molj);
ncollisions = chem_split_molecule(i, particle, molecule, collisions, ncollisions);
}
}
}
return(ncollisions);
}
int update_types(t_particle particle[NMAXCIRCLES], t_molecule molecule[NMAXCIRCLES], t_cluster cluster[NMAXCIRCLES], t_collision *collisions, int ncollisions, int *particle_numbers, int time, double *delta_e)
/* update the types in case of reaction-diffusion equation */
{
int i, j, k, n, n3, n4, p, type, atype, btype, oldncollisions, delta_n;
short int reacted;
double distance, rnd, p1, p2, reac_dist;
static double inv_masses[RD_TYPES+1], radii[RD_TYPES+1];
static int first = 1, repair_counter = 0;
if (first) /* compute total mass and mass ratios */
{
compute_inverse_masses(inv_masses);
compute_radii(radii);
first = 0;
}
if (EXOTHERMIC) oldncollisions = ncollisions;
switch (RD_REACTION) {
case (CHEM_RPS):
{
for (i=0; i<ncircles; i++)
for (j=0; j<particle[i].hash_nneighb; j++)
{
k = particle[i].hashneighbour[j];
if ((particle[k].type == particle[i].type + 1)||((particle[i].type == RD_TYPES)&&(particle[k].type == 1)))
{
distance = module2(particle[i].deltax[j], particle[i].deltay[j]);
if ((distance < EQUILIBRIUM_DIST)&&((double)rand()/RAND_MAX < REACTION_PROB))
particle[k].type = particle[i].type;
}
}
return(0);
}
case (CHEM_AAB):
{
for (i=0; i<ncircles; i++)
if ((particle[i].active)&&(particle[i].type == 1))
ncollisions = chem_merge_AAB(i, 2, particle, collisions, ncollisions, inv_masses, radii);
return(ncollisions);
}
case (CHEM_ABC):
{
for (i=0; i<ncircles; i++) if ((particle[i].active)&&(particle[i].type == 1))
ncollisions = chem_merge(i, 2, 3, particle, collisions, ncollisions, inv_masses, radii);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
if (EXOTHERMIC) *delta_e = (double)(delta_n)*DELTA_EKIN;
return(ncollisions);
}
case (CHEM_A2BC):
{
for (i=0; i<ncircles; i++) if ((particle[i].active)&&(particle[i].type == 1))
ncollisions = chem_multi_merge(i, 2, 2, 3, particle, collisions, ncollisions, inv_masses, radii);
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_CATALYSIS):
{
for (i=0; i<ncircles; i++) if ((particle[i].active)&&(particle[i].type == 1))
ncollisions = chem_catalytic_merge(i, 2, 3, particle, collisions, ncollisions, inv_masses, radii);
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_AUTOCATALYSIS):
{
for (i=0; i<ncircles; i++) if ((particle[i].active)&&(particle[i].type == 1))
ncollisions = chem_catalytic_merge(i, 2, 2, particle, collisions, ncollisions, inv_masses, radii);
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_BAA):
{
for (i=0; i<ncircles; i++)
if ((particle[i].active)&&(particle[i].type == 2)&&((double)rand()/RAND_MAX < DISSOCIATION_PROB))
ncollisions = chem_split(i, 1, 1, particle, collisions, ncollisions, inv_masses, radii);
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_AABAA):
{
*delta_e = 0.0;
for (i=0; i<ncircles; i++)
{
oldncollisions = ncollisions;
if ((particle[i].active)&&(particle[i].type == 1))
{
ncollisions = chem_merge_AAB(i, 2, particle, collisions, ncollisions, inv_masses, radii);
if (EXOTHERMIC) *delta_e += (double)(ncollisions - oldncollisions)*DELTA_EKIN;
}
else if ((particle[i].active)&&(particle[i].type == 2)&&((double)rand()/RAND_MAX < DISSOCIATION_PROB))
{
ncollisions = chem_split(i, 1, 1, particle, collisions, ncollisions, inv_masses, radii);
if (EXOTHERMIC) *delta_e -= (double)(ncollisions - oldncollisions)*DELTA_EKIN;
}
}
printf("Delta_E = %.3lg\n", *delta_e);
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_POLYMER):
{
for (i=0; i<ncircles; i++) if ((particle[i].active)&&(particle[i].type == 1))
for (k=2; k<RD_TYPES; k++)
ncollisions = chem_merge(i, k, k+1, particle, collisions, ncollisions, inv_masses, radii);
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_POLYMER_DISS):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].type == 1) for (k=2; k<RD_TYPES; k++)
ncollisions = chem_merge(i, k, k+1, particle, collisions, ncollisions, inv_masses, radii);
else if ((particle[i].type > 2)&&((double)rand()/RAND_MAX < DISSOCIATION_PROB))
ncollisions = chem_split(i, 1, particle[i].type - 1, particle, collisions, ncollisions, inv_masses, radii);
}
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_POLYMER_STEP):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
type = particle[i].type;
for (k=1; k<RD_TYPES+1-type; k++)
ncollisions = chem_merge(i, k, k+type, particle, collisions, ncollisions, inv_masses, radii);
if ((type > 1)&&((double)rand()/RAND_MAX < DISSOCIATION_PROB))
{
k = rand()%(type-1) + 1;
// printf("Splitting type %i into type %i and type %i\n", type, k, type - k);
ncollisions = chem_split(i, k, type - k, particle, collisions, ncollisions, inv_masses, radii);
}
}
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_CATALYTIC_A2D):
{
for (i=0; i<ncircles; i++) if ((particle[i].active)&&(particle[i].type == 1))
{
ncollisions = chem_merge(i, 2, 3, particle, collisions, ncollisions, inv_masses, radii);
ncollisions = chem_transfer(i, 3, 4, 2, particle, collisions, ncollisions, inv_masses, radii, 1.05*REACTION_DIST);
}
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_ABCAB):
{
*delta_e = 0.0;
for (i=0; i<ncircles; i++)
{
oldncollisions = ncollisions;
if ((particle[i].active)&&(particle[i].type == 1))
{
ncollisions = chem_merge(i, 2, 3, particle, collisions, ncollisions, inv_masses, radii);
if (EXOTHERMIC) *delta_e += (double)(ncollisions - oldncollisions)*DELTA_EKIN;
}
else if ((particle[i].active)&&(particle[i].type == 3)&&((double)rand()/RAND_MAX < DISSOCIATION_PROB))
{
ncollisions = chem_split(i, 1, 2, particle, collisions, ncollisions, inv_masses, radii);
if (EXOTHERMIC) *delta_e -= (double)(ncollisions - oldncollisions)*DELTA_EKIN;
}
}
printf("Delta_E = %.3lg\n", *delta_e);
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_ABCDABC):
{
*delta_e = 0.0;
for (i=0; i<ncircles; i++)
{
oldncollisions = ncollisions;
if ((particle[i].active)&&(particle[i].type == 1))
{
ncollisions = chem_merge(i, 2, 3, particle, collisions, ncollisions, inv_masses, radii);
if (EXOTHERMIC) *delta_e += (double)(ncollisions - oldncollisions)*DELTA_EKIN;
ncollisions = chem_merge(i, 3, 4, particle, collisions, ncollisions, inv_masses, radii);
if (EXOTHERMIC) *delta_e += (double)(ncollisions - oldncollisions)*DELTA_EKIN;
}
else if ((particle[i].active)&&(particle[i].type == 3)&&((double)rand()/RAND_MAX < DISSOCIATION_PROB))
{
ncollisions = chem_split(i, 1, 2, particle, collisions, ncollisions, inv_masses, radii);
if (EXOTHERMIC) *delta_e -= (double)(ncollisions - oldncollisions)*DELTA_EKIN;
}
else if ((particle[i].active)&&(particle[i].type == 4)&&((double)rand()/RAND_MAX < DISSOCIATION_PROB))
{
ncollisions = chem_split(i, 1, 3, particle, collisions, ncollisions, inv_masses, radii);
if (EXOTHERMIC) *delta_e -= (double)(ncollisions - oldncollisions)*DELTA_EKIN;
}
}
printf("Delta_E = %.3lg\n", *delta_e);
printf("%i collisions\n", ncollisions);
return(ncollisions);
}
case (CHEM_BZ):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
oldncollisions = ncollisions;
switch (particle[i].type) {
case (1):
{
ncollisions = chem_transfer(i, 4, 2, 3, particle, collisions, ncollisions, inv_masses, radii, REACTION_DIST);
ncollisions = chem_transfer(i, 3, 2, 2, particle, collisions, ncollisions, inv_masses, radii, REACTION_DIST);
break;
}
case (2):
{
// particle[i].active = 0;
ncollisions = chem_transfer(i, 2, 1, 3, particle, collisions, ncollisions, inv_masses, radii, 0.95*REACTION_DIST);
break;
}
case (3):
{
ncollisions = chem_transfer(i, 3, 2, 4, particle, collisions, ncollisions, inv_masses, radii, REACTION_DIST);
ncollisions = chem_transfer(i, 4, 7, 8, particle, collisions, ncollisions, inv_masses, radii, REACTION_DIST);
break;
}
case (5):
{
rnd = (double)rand()/RAND_MAX;
if (rnd < 0.2)
ncollisions = chem_merge(i, 6, 1, particle, collisions, ncollisions, inv_masses, radii);
else /*if (rnd < 0.9)*/
ncollisions = chem_merge(i, 6, 6, particle, collisions, ncollisions, inv_masses, radii);
// else if (rnd < 0.6)
// ncollisions = chem_transfer(i, 6, 1, 1, particle, collisions, ncollisions, inv_masses, radii, REACTION_DIST);
break;
}
case (7):
{
ncollisions = chem_split(i, 3, 3, particle, collisions, ncollisions, inv_masses, radii);
break;
}
case (8):
{
ncollisions = chem_split(i, 5, 5, particle, collisions, ncollisions, inv_masses, radii);
break;
}
}
}
return(ncollisions);
}
case (CHEM_BRUSSELATOR):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
oldncollisions = ncollisions;
switch (particle[i].type) {
case (1): /* A -> X */
{
ncollisions = chem_convert(i, 3, particle, collisions, ncollisions, inv_masses, radii, DISSOCIATION_PROB);
break;
}
case (2): /* B + X -> Y + D */
{
ncollisions = chem_transfer(i, 3, 4, 5, particle, collisions, ncollisions, inv_masses, radii, REACTION_DIST);
break;
}
case (3):
{
/* X -> B, modified from Brusselator */
ncollisions = chem_convert(i, 2, particle, collisions, ncollisions, inv_masses, radii, 0.5*DISSOCIATION_PROB);
/* 2X + Y -> 3X */
ncollisions = chem_catalytic_convert(i, 4, 3, particle, collisions, ncollisions, inv_masses, radii, 3.0*REACTION_DIST, 1.0);
break;
}
case (5): /* D -> A or B if concentration of X or Y is small */
{
n = time*(RD_TYPES+1);
n3 = particle_numbers[n+3];
n4 = particle_numbers[n+4];
p1 = 1.0/((double)(n3*n3/10+1));
p2 = 5.0*DISSOCIATION_PROB + 1.0/((double)(n4*n4/200+1));
rnd = (double)rand()/RAND_MAX;
if (rnd < p1/(p1+p2))
ncollisions = chem_convert(i, 1, particle, collisions, ncollisions, inv_masses, radii, p1);
else /*if (n4 < 1000)*/
ncollisions = chem_convert(i, 2, particle, collisions, ncollisions, inv_masses, radii, p2);
}
}
}
return(ncollisions);
}
case (CHEM_ABDACBE):
{
for (i=0; i<ncircles; i++)
{
// oldncollisions = ncollisions;
if ((particle[i].active)&&(particle[i].type == 1))
{
ncollisions = chem_merge(i, 2, 4, particle, collisions, ncollisions, inv_masses, radii);
// if (EXOTHERMIC) *delta_e += (double)(ncollisions - oldncollisions)*DELTA_EKIN;
ncollisions = chem_transfer(i, 3, 2, 5, particle, collisions, ncollisions, inv_masses, radii, REACTION_DIST);
// if (EXOTHERMIC) *delta_e += (double)(ncollisions - oldncollisions)*DELTA_EKIN;
}
}
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
if (EXOTHERMIC) *delta_e = (double)(delta_n)*DELTA_EKIN;
return(ncollisions);
}
case (CHEM_H2O_H_OH):
{
for (i=0; i<ncircles; i++)
{
if ((particle[i].active)&&(particle[i].type <= 1))
{
if (particle[i].npartners == 2)
ncollisions = chem_dissociate_molecule(i, particle, collisions, ncollisions, DISSOCIATION_PROB);
else if (particle[i].npartners == 1)
ncollisions = chem_merge_molecule(i, 2, 0, particle, collisions, ncollisions, REACTION_PROB);
}
}
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_2H2O_H3O_OH):
{
for (i=0; i<ncircles; i++)
{
if ((particle[i].active)&&(particle[i].type <= 1))
{
if (particle[i].npartners == 2)
{
oldncollisions = ncollisions;
ncollisions = chem_dissociate_molecule(i, particle, collisions, ncollisions, DISSOCIATION_PROB);
if (ncollisions == oldncollisions)
ncollisions = chem_merge_molecule(i, 2, 0, particle, collisions, ncollisions, REACTION_PROB);
}
else if (particle[i].npartners == 1)
ncollisions = chem_merge_molecule(i, 2, 0, particle, collisions, ncollisions, REACTION_PROB);
else if (particle[i].npartners == 3)
ncollisions = chem_dissociate_molecule(i, particle, collisions, ncollisions, 2.0*DISSOCIATION_PROB);
}
}
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_AGGREGATION):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX) for (k=0; k<3; k++)
{
ncollisions = chem_multi_glue_molecule(i, k, AGREGMAX, 0, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* update cluster color scheme */
if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_AGGREGATION_CHARGE):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX) for (k=0; k<3; k++)
{
ncollisions = chem_multi_glue_molecule(i, k, AGREGMAX, 0, 0, 1, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* update cluster color scheme */
if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_AGGREGATION_NNEIGH):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX) for (k=0; k<3; k++)
{
ncollisions = chem_multi_glue_molecule(i, k, AGREGMAX, 1, 0, 1, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* update cluster color scheme */
if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_DNA):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX) switch (particle[i].type)
{
case (2):
{
ncollisions = chem_multi_glue_molecule(i, 2, AGREGMAX, 0, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
break;
}
case (3):
{
ncollisions = chem_multi_glue_molecule(i, 4, AGREGMAX, 0, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
break;
}
case (4):
{
ncollisions = chem_multi_glue_molecule(i, 3, AGREGMAX, 0, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
break;
}
case (5):
{
ncollisions = chem_multi_glue_molecule(i, 6, AGREGMAX, 0, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
break;
}
case (6):
{
ncollisions = chem_multi_glue_molecule(i, 5, AGREGMAX, 0, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
break;
}
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* update cluster color scheme */
if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_DNA_ALT):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX)
{
atype = particle[i].type;
if (atype%2 == 1) btype = atype+1;
else btype = atype-1;
if (atype > 0)
ncollisions = chem_multi_glue_molecule(i, btype, AGREGMAX, 0, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* update cluster color scheme */
// if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_DNA_DOUBLE):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX)
{
atype = particle[i].type;
if (atype%2 == 1) btype = atype+1;
else btype = atype-1;
if (atype > 0)
ncollisions = chem_multi_glue_molecule(i, btype, AGREGMAX, 0, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* update cluster color scheme */
if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_DNA_DSPLIT):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX)
{
atype = particle[i].type;
if (atype%2 == 1) btype = atype+1;
else btype = atype-1;
if (atype > 0)
ncollisions = chem_multi_glue_molecule(i, btype, AGREGMAX, 3, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
}
/* split molecule with a certain probability */
if ((double)rand()/RAND_MAX < DISSOCIATION_PROB)
ncollisions = chem_split_molecule(i, particle, molecule, collisions, ncollisions);
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* update cluster color scheme */
if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_DNA_BASE_SPLIT):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX)
{
atype = particle[i].type;
if (atype%2 == 1) btype = atype+1;
else btype = atype-1;
if (atype > 0)
ncollisions = chem_multi_glue_molecule(i, btype, AGREGMAX, 3, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
}
/* split molecule with a certain probability */
if ((double)rand()/RAND_MAX < DISSOCIATION_PROB)
ncollisions = chem_split_molecule(i, particle, molecule, collisions, ncollisions);
reac_dist = 2.5*MU;
switch (particle[i].type) {
case (3):
{
ncollisions = chem_split_molecule_if_nearby(i, 3, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
ncollisions = chem_split_molecule_if_nearby(i, 5, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
ncollisions = chem_split_molecule_if_nearby(i, 6, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (4):
{
ncollisions = chem_split_molecule_if_nearby(i, 4, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
ncollisions = chem_split_molecule_if_nearby(i, 5, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
ncollisions = chem_split_molecule_if_nearby(i, 6, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (5):
{
ncollisions = chem_split_molecule_if_nearby(i, 3, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
ncollisions = chem_split_molecule_if_nearby(i, 3, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
ncollisions = chem_split_molecule_if_nearby(i, 5, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (6):
{
ncollisions = chem_split_molecule_if_nearby(i, 3, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
ncollisions = chem_split_molecule_if_nearby(i, 4, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
ncollisions = chem_split_molecule_if_nearby(i, 6, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* update cluster color scheme */
if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_DNA_ENZYME):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX)
{
atype = particle[i].type;
if (atype%2 == 1) btype = atype+1;
else btype = atype-1;
if (atype > 0)
ncollisions = chem_multi_glue_molecule(i, btype, AGREGMAX, 3, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
}
/* split molecule with a certain probability */
/* TODO update molecules after split */
if ((double)rand()/RAND_MAX < DISSOCIATION_PROB)
ncollisions = chem_split_molecule(i, particle, molecule, collisions, ncollisions);
reac_dist = 2.5*MU;
switch (particle[i].type) {
case (3):
{
ncollisions = chem_local_split_molecule_if_nearby(i, 4, 7, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (4):
{
ncollisions = chem_local_split_molecule_if_nearby(i, 3, 7, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (5):
{
ncollisions = chem_local_split_molecule_if_nearby(i, 6, 7, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (6):
{
ncollisions = chem_local_split_molecule_if_nearby(i, 5, 7, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (7):
{
if ((double)rand()/RAND_MAX < KILLING_PROB) particle[i].active = 0;
break;
}
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* update cluster color scheme */
if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
/* for debugging */
// for (i=0; i<nmolecules; i++)
// if (molecule[i].npartners > 0)
// {
// printf("Molecule %i has %i partners: ", i, molecule[i].npartners);
// for (j=0; j<molecule[i].npartners; j++)
// printf("%i ", molecule[i].partner[j]);
// printf("\n");
// }
// sleep(3);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_DNA_ENZYME_REPAIR):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX)
{
atype = particle[i].type;
if (atype%2 == 1) btype = atype+1;
else btype = atype-1;
if (atype > 0) /* TEST */
ncollisions = chem_multi_glue_molecule(i, btype, AGREGMAX, 3, 0, 0, 0, particle, molecule, collisions, ncollisions, REACTION_PROB);
// ncollisions = chem_multi_glue_molecule(i, btype, AGREGMAX, 3, 0, 0, 2, particle, molecule, collisions, ncollisions, REACTION_PROB);
}
/* split molecule with a certain probability */
/* TODO update molecules after split */
if ((double)rand()/RAND_MAX < DISSOCIATION_PROB)
ncollisions = chem_split_molecule(i, particle, molecule, collisions, ncollisions);
reac_dist = 2.5*MU;
switch (particle[i].type) {
case (3):
{
ncollisions = chem_local_split_molecule_if_nearby(i, 4, 7, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (4):
{
ncollisions = chem_local_split_molecule_if_nearby(i, 3, 7, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (5):
{
ncollisions = chem_local_split_molecule_if_nearby(i, 6, 7, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (6):
{
ncollisions = chem_local_split_molecule_if_nearby(i, 5, 7, particle, molecule, collisions, ncollisions, reac_dist, REACTION_PROB);
break;
}
case (7):
{
if ((double)rand()/RAND_MAX < KILLING_PROB) particle[i].active = 0;
break;
}
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
// ncollisions = repair_dna(particle, molecule, collisions, ncollisions);
repair_counter++;
if (repair_counter >= 2)
{
ncollisions = repair_dna(particle, molecule, collisions, ncollisions);
// ncollisions = check_dna_pairing(particle, molecule, collisions, ncollisions);
repair_counter = 0;
}
/* update cluster color scheme */
if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
/* for debugging */
// for (i=0; i<nmolecules; i++)
// if (molecule[i].npartners > 0)
// {
// printf("Molecule %i has %i partners: ", i, molecule[i].npartners);
// for (j=0; j<molecule[i].npartners; j++)
// printf("%i[%i] ", molecule[i].partner[j], molecule[i].connection_type[j]);
// printf("\n");
// }
// sleep(3);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_POLYGON_AGGREGATION):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < AGREGMAX) for (k=0; k<3; k++)
{
ncollisions = chem_multi_glue_polygon(i, k, AGREGMAX, particle, molecule, cluster, collisions, ncollisions, REACTION_PROB, 0);
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* update cluster color scheme */
if ((PLOT == P_CLUSTER)||(PLOT_B == P_CLUSTER))
update_cluster_color(particle);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
case (CHEM_POLYGON_CLUSTER):
{
for (i=0; i<ncircles; i++) if (particle[i].active)
{
if (particle[i].npartners < NPOLY)
{
ncollisions = chem_multi_glue_polygon2(i, NPOLY, particle, molecule, cluster, collisions, ncollisions, REACTION_PROB, 1, 0);
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
/* repair clusters */
if (!REPAIR_CLUSTERS) for (i=0; i<ncircles; i++)
if ((cluster[i].active)&&(cluster[i].nparticles >= 2))
repair_cluster(i, particle, cluster, 1000, 0);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}case (CHEM_POLYGON_ONECLUSTER):
{
i = 0;
reacted = 0;
while ((i<ncircles)&&(!reacted))
{
if (particle[i].active)
{
if (particle[i].npartners < NPOLY)
{
oldncollisions = ncollisions;
ncollisions = chem_multi_glue_polygon2(i, NPOLY, particle, molecule, cluster, collisions, ncollisions, REACTION_PROB, 1, 1);
if (ncollisions > oldncollisions) reacted = 1;
}
/* decouple particles with several partners from thermostat */
if (particle[i].npartners >= AGREG_DECOUPLE) particle[i].thermostat = 0;
}
i++;
}
/* repair clusters */
if (!REPAIR_CLUSTERS) for (i=0; i<ncircles; i++)
if ((cluster[i].active)&&(cluster[i].nparticles >= 2))
repair_cluster(i, particle, cluster, 1000, 1);
printf("%i collisions\n", ncollisions);
delta_n = ncollisions - oldncollisions;
printf("delta_n = %i\n", delta_n);
return(ncollisions);
}
}
}
double plot_coord(double x, double xmin, double xmax)
{
return(xmin + x*(xmax - xmin));
}
void draw_speed_plot(t_group_data *group_speeds, int i)
/* draw plot of obstacle speeds as a function of time */
{
int j, group;
char message[100];
static double xmin, xmax, ymin, ymax, xmid, ymid, dx, dy, plotxmin, plotxmax, plotymin, plotymax;
double pos[2], x1, y1, x2, y2, rgb[3];
static int first = 1, gshift = INITIAL_TIME + NSTEPS;
if (first)
{
// xmin = XMAX - 1.35;
// xmax = XMAX - 0.05;
// ymin = YMAX - 1.8;
// ymax = YMAX - 0.5;
xmin = XMAX - 1.8;
xmax = XMAX - 0.066;
ymin = YMAX - 2.5;
ymax = YMAX - 0.76;
xmid = 0.5*(xmin + xmax);
ymid = 0.5*(ymin + ymax);
dx = 0.5*(xmax - xmin);
dy = 0.5*(ymax - ymin);
plotxmin = xmin + 0.05;
plotxmax = xmax - 0.1;
plotymin = ymin + 0.07;
plotymax = ymax - 0.15;
first = 0;
}
// rgb[0] = 1.0; rgb[1] = 1.0; rgb[2] = 1.0;
glLineWidth(2);
/* plot angular speed */
for (group=1; group<ngroups; group++)
{
set_segment_group_color(group, 0.5, rgb);
x1 = plotxmin;
y1 = plotymin;
for (j=0; j<i; j++)
{
x2 = plot_coord((double)j/(double)NSTEPS, plotxmin, plotxmax);
y2 = plot_coord(group_speeds[(group-1)*gshift + j].omega/VMAX_PLOT_SPEEDS, plotymin, plotymax);
draw_line(x1, y1, x2, y2);
x1 = x2;
y1 = y2;
}
sprintf(message, "omega");
write_text_fixedwidth(plotxmin - 0.22 + (double)(group-1)*0.3, plotymax + 0.16, message);
}
/* plot speed of obstacles */
for (group=1; group<ngroups; group++)
{
set_segment_group_color(group, 1.0, rgb);
x1 = plotxmin;
y1 = plotymin;
for (j=0; j<i; j++)
{
x2 = plot_coord((double)j/(double)NSTEPS, plotxmin, plotxmax);
y2 = plot_coord(group_speeds[(group-1)*gshift + j].vy/VMAX_PLOT_SPEEDS, plotymin, plotymax);
draw_line(x1, y1, x2, y2);
x1 = x2;
y1 = y2;
}
sprintf(message, "vy");
write_text_fixedwidth(plotxmin - 0.22 + (double)(group-1)*0.3, plotymax + 0.25, message);
}
glColor3f(1.0, 1.0, 1.0);
/* axes and labels */
draw_line(plotxmin, plotymin, plotxmax + 0.05, plotymin);
draw_line(plotxmin, plotymin, plotxmin, plotymax + 0.1);
for (j=1; j<=(int)(10.0*VMAX_PLOT_SPEEDS); j++)
{
y1 = plot_coord((double)j/(10.0*VMAX_PLOT_SPEEDS), plotymin, plotymax);
draw_line(plotxmin - 0.02, y1, plotxmin + 0.02, y1);
}
sprintf(message, "%.1f", VMAX_PLOT_SPEEDS);
write_text_fixedwidth(plotxmin - 0.28, y1 - 0.025, message);
// write_text_fixedwidth(plotxmin - 0.22, y1 - 0.025, message);
sprintf(message, "time");
write_text_fixedwidth(plotxmax - 0.13, plotymin - 0.12, message);
// write_text_fixedwidth(plotxmax - 0.1, plotymin - 0.08, message);
}
void draw_trajectory_plot(t_group_data *group_speeds, int i)
/* draw plot of obstacle speeds as a function of time */
{
int j, group;
char message[100];
static double xmin, xmax, ymin, ymax, xmid, ymid, dx, dy, plotxmin, plotxmax, plotymin, plotymax, scalex, scaley, yinitial[NMAXGROUPS];
double pos[2], x0, y0, x1, y1, x2, y2, rgb[3];
static int first = 1, gshift = INITIAL_TIME + NSTEPS;
if (first)
{
xmin = XMAX - 1.8;
xmax = XMAX - 0.066;
ymin = YMIN + 0.1;
ymax = YMIN + 1.9;
xmid = 0.5*(xmin + xmax);
ymid = 0.5*(ymin + ymax);
dx = 0.5*(xmax - xmin);
dy = 0.5*(ymax - ymin);
plotxmin = xmin + 0.05;
plotxmax = xmax - 0.1;
plotymin = ymin + 0.07;
plotymax = ymax - 0.15;
scalex = 6.0;
scaley = 3.0;
for (group = 1; group < ngroups; group++)
yinitial[group] = group_speeds[(group-1)*gshift].yc;
first = 0;
}
if (ALTITUDE_LINES)
{
glLineWidth(1);
glColor3f(0.5, 0.5, 0.5);
for (j=1; j<(int)scaley + 1; j++)
{
y1 = plot_coord((double)j/scaley, plotymin, plotymax);
if (y1 < plotymax) draw_line(plotxmin, y1, plotxmax + 0.05, y1);
}
}
glLineWidth(2);
printf("ngroups = %i\n", ngroups);
/* plot trajectories */
for (group=1; group<ngroups; group++)
{
set_segment_group_color(group, 0.75, rgb);
x1 = group_speeds[(group-1)*gshift].xc;
y1 = group_speeds[(group-1)*gshift].yc - yinitial[group];
for (j=0; j<i-1; j++)
{
x0 = group_speeds[(group-1)*gshift + j].xc;
y0 = group_speeds[(group-1)*gshift + j].yc - yinitial[group];
if (y0 > scaley) scaley = y0;
x2 = plot_coord(0.5 + x0/scalex, plotxmin, plotxmax);
y2 = plot_coord(y0/scaley + 0.05, plotymin, plotymax);
// printf("yinitial = %.3lg, (x0, y0) = (%.3lg, %.3lg), (x2, y2) = (%.3lg, %.3lg)\n", yinitial, x0, y0, x2, y2);
if ((j>0)&&(module2(x2-x1, y2-y1) < 0.1)) draw_line(x1, y1, x2, y2);
x1 = x2;
y1 = y2;
}
if (i>0) draw_colored_circle_precomp(x1, y1, 0.015, rgb);
}
glColor3f(1.0, 1.0, 1.0);
/* axes and labels */
draw_line(plotxmin, plotymin, plotxmax + 0.05, plotymin);
draw_line(plotxmin, plotymin, plotxmin, plotymax + 0.1);
for (j=1; j<(int)scaley; j++)
{
y1 = plot_coord((double)j/scaley, plotymin, plotymax);
draw_line(plotxmin - 0.02, y1, plotxmin + 0.02, y1);
}
sprintf(message, "%i", (int)scaley - 1);
write_text_fixedwidth(plotxmin - 0.15, y1 - 0.025, message);
// sprintf(message, "%.1f", VMAX_PLOT_SPEEDS);
sprintf(message, "y");
write_text_fixedwidth(plotxmin - 0.1, plotymax - 0.005, message);
sprintf(message, "x");
write_text_fixedwidth(plotxmax - 0.1, plotymin - 0.1, message);
}
void write_size_text(double x, double y, char *message, int largewin)
{
if (largewin) write_text(x, y, message);
else write_text_fixedwidth(x, y, message);
}
void draw_particle_nb_plot(int *particle_numbers, int i)
/* draw plot of number of particles as a function of time */
{
int j, type, power;
char message[100];
static double xmin, xmax, ymin, ymax, xmid, ymid, dx, dy, plotxmin, plotxmax, plotymin, plotymax;
double pos[2], x1, y1, x2, y2, rgb[3];
static int second = 2, gshift = INITIAL_TIME + NSTEPS, nmax, ygrad, largewin;
if (second > 0)
{
xmin = XMAX - 1.05;
xmax = XMAX - 0.05;
ymin = YMAX - 1.0;
ymax = YMAX - 0.05;
xmid = 0.5*(xmin + xmax);
ymid = 0.5*(ymin + ymax);
dx = 0.5*(xmax - xmin);
dy = 0.5*(ymax - ymin);
plotxmin = xmin + 0.18;
plotxmax = xmax - 0.1;
plotymin = ymin + 0.07;
plotymax = ymax - 0.15;
nmax = 0;
for (j=1; j<RD_TYPES+1; j++)
if (particle_numbers[RD_TYPES+1+j] > nmax) nmax = particle_numbers[RD_TYPES+1+j];
nmax *= PARTICLE_NB_PLOT_FACTOR;
power = (int)(log((double)nmax)/log(10.0)) - 1.0;
ygrad = (int)ipow(10.0, power);
largewin = (WINWIDTH > 1280);
second--;
}
erase_area_hsl(xmid, ymid, dx, dy, 0.0, 0.9, 0.0);
glLineWidth(2);
/* plot particle number */
for (type=1; type<RD_TYPES+1; type++)
{
set_type_color(type, 1.0, rgb);
x1 = plotxmin;
y1 = plotymin;
glBegin(GL_LINE_STRIP);
for (j=1; j<i; j++)
{
x2 = plot_coord((double)j/(double)NSTEPS, plotxmin, plotxmax);
y2 = plot_coord(particle_numbers[(RD_TYPES+1)*j+type]/(double)nmax, plotymin, plotymax);
glVertex2d(x2, y2);
// draw_line(x1, y1, x2, y2);
// x1 = x2;
// y1 = y2;
}
glEnd();
sprintf(message, "%5d molecules", particle_numbers[(RD_TYPES+1)*i+type]);
// write_size_text(xmax - 0.5, ymax - 0.04 - 0.06*(double)type, message, largewin);
// if (largewin) write_text(xmax - 0.5, ymax - 0.1 - 0.1*(double)type, message);
// else
write_text_fixedwidth(xmax - 0.5, ymax - 0.06*(double)type, message);
}
glColor3f(1.0, 1.0, 1.0);
/* axes and labels */
draw_line(plotxmin, plotymin, plotxmax + 0.05, plotymin);
draw_line(plotxmin, plotymin, plotxmin, plotymax + 0.1);
glLineWidth(1);
j = 1;
while (j*ygrad <= nmax + 5)
{
y1 = plot_coord((double)(j*ygrad)/(double)nmax, plotymin, plotymax);
draw_line(plotxmin - 0.015, y1, plotxmin + 0.015, y1);
if (j%10 == 0)
{
draw_line(plotxmin - 0.025, y1, plotxmin + 0.025, y1);
sprintf(message, "%i", j*ygrad);
// write_size_text(plotxmin - 0.15, y1 - 0.015, message, largewin);
// if (largewin) write_text(plotxmin - 0.17, y1 - 0.015, message);
// else
write_text_fixedwidth(plotxmin - 0.15, y1 - 0.015, message);
}
else if ((j%5 == 0)&&(nmax<5*ygrad))
{
sprintf(message, "%i", j*ygrad);
// if (j*ygrad >= 1000) write_size_text(plotxmin - 0.15, y1 - 0.015, message, largewin);
// else write_size_text(plotxmin - 0.12, y1 - 0.015, message, largewin);
if (j*ygrad >= 1000) write_text_fixedwidth(plotxmin - 0.15, y1 - 0.015, message);
else write_text_fixedwidth(plotxmin - 0.12, y1 - 0.015, message);
}
j++;
}
sprintf(message, "time");
// write_size_text(plotxmax - 0.1, plotymin - 0.05, message, largewin);
write_text_fixedwidth(plotxmax - 0.1, plotymin - 0.05, message);
}
void init_segment_group(t_segment segment[NMAXSEGMENTS], int group, t_group_segments segment_group[NMAXGROUPS])
/* initialize center of mass and similar data of grouped segments */
{
int i, nseg_group = 0;
double xc = 0.0, yc = 0.0;
for (i=0; i<nsegments; i++) if (segment[i].group == group)
{
xc += 0.5*(segment[i].x1 + segment[i].x2);
yc += 0.5*(segment[i].y1 + segment[i].y2);
// printf("Segment group data %i: z1 = (%.3lg, %.3lg)\n z2 = (%.3lg, %.3lg)\n zc = (%.3lg, %.3lg)\n\n", group,
// segment[i].x1, segment[i].y1, segment[i].x2, segment[i].y2, xc, yc);
nseg_group++;
}
if (nseg_group == 0) nseg_group = 1;
segment_group[group].xc = xc/(double)nseg_group;
segment_group[group].yc = yc/(double)nseg_group;
segment_group[group].angle = 0.0;
segment_group[group].vx = 0.0;
segment_group[group].vy = 0.0;
segment_group[group].omega = 0.0;
segment_group[group].mass = SEGMENT_GROUP_MASS;
segment_group[group].moment_inertia = SEGMENT_GROUP_I;
printf("Segment group data %i: (%.3lg, %.3lg)\n", group, segment_group[group].xc, segment_group[group].yc);
}
void reset_energy(t_particle particle[NMAXCIRCLES], double px[NMAXCIRCLES], double py[NMAXCIRCLES], double totalenergy, double emean)
/* decrease energy in case of blow-up */
{
int i;
double vratio, emax;
emax = 10.0*emean/(double)ncircles;
// printf("Warning: blow-up, resetting energy from %.5lg to %.5lg\n\n", totalenergy, emean);
printf("Warning: blow-up, resetting energy of some particles\n");
// vratio = sqrt(emean/totalenergy);
for (i=0; i < ncircles; i++) if (particle[i].energy > emax)
{
printf("Particle %i at (%.3lg, %.3lg) has energy %.5lg, resetting to 0\n", i, particle[i].xc, particle[i].yc, particle[i].energy);
particle[i].vx = 0.0;
particle[i].vy = 0.0;
px[i] = 0.0;
py[i] = 0.0;
particle[i].energy = 0.0;
}
printf("\n\n");
}
int init_cluster_config(t_particle particle[NMAXCIRCLES], t_cluster cluster[NMAXCIRCLES])
/* initialize the clusters for option CLUSTER_PARTICLES */
/* returns number of active clusters */
{
int i, j, tmp, nclusters = 0;
for (i=0; i<ncircles; i++) /*if (particle[i].active)*/
{
nclusters++;
cluster[i].active = particle[i].active;
cluster[i].thermostat = 1;
cluster[i].selected = 0;
cluster[i].xg = particle[i].xc;
cluster[i].yg = particle[i].yc;
cluster[i].angle = particle[i].angle;
cluster[i].vx = particle[i].vx;
cluster[i].vy = particle[i].vy;
cluster[i].omega = particle[i].omega;
cluster[i].mass_inv = particle[i].mass_inv;
cluster[i].mass = 1.0/particle[i].mass_inv;
cluster[i].inertia_moment_inv = particle[i].inertia_moment_inv;
cluster[i].inertia_moment = 1.0/particle[i].inertia_moment_inv;
cluster[i].fx = particle[i].fx;
cluster[i].fy = particle[i].fy;
cluster[i].torque = particle[i].torque;
cluster[i].energy = particle[i].energy;
cluster[i].emean = particle[i].emean;
cluster[i].nparticles = 1;
cluster[i].particle[0] = i;
// cluster[i].angle_ref = 0;
particle[i].cluster = i;
particle[i].cluster_color = i;
particle[i].cluster_size = 1;
particle[i].flip = 0;
}
/* randomize cluster number using Fisher-Yates algorithm */
for (i=0; i<ncircles-1; i++)
{
j = i + rand()%(ncircles-i);
tmp = particle[i].cluster_color;
particle[i].cluster_color = particle[j].cluster_color;
particle[j].cluster_color = tmp;
}
// for (i=0; i<ncircles; i++)
// {
// j = cluster[i].particle[0];
// particle[j].cluster = i;
// }
//
// for (i=0; i<ncircles; i++)
// {
// fprintf(lj_log, "Particle %i -> cluster %i -> particle %i\n", i, particle[i].cluster, cluster[particle[i].cluster].particle[0]);
// }
return(nclusters);
}
void compute_cluster_force(t_cluster cluster[NMAXCIRCLES], t_particle particle[NMAXCIRCLES])
/* compute force and torque on clusters from force and torque on their particles */
{
int i, p, j;
double fx, fy, torque, energy;
for (i=0; i<ncircles; i++) if (cluster[i].active)
{
fx = 0.0;
fy = 0.0;
torque = 0.0;
for (p=0; p<cluster[i].nparticles; p++)
{
j = cluster[i].particle[p];
fx += particle[j].fx;
fy += particle[j].fy;
torque += particle[j].torque;
torque += (particle[j].xc - cluster[i].xg)*particle[j].fy;
torque -= (particle[j].yc - cluster[i].yg)*particle[j].fx;
}
cluster[i].fx = fx;
cluster[i].fy = fy;
cluster[i].torque = torque;
}
}
void update_conveyor_belts(t_segment segment[NMAXSEGMENTS], t_belt belt[NMAXBELTS])
/* move shovels of conveyor belt */
{
int b, shovel, firstseg, seg;
double position, length, width, angle, newpos, deltapos, beltlength, shift, beta;
for (b = 0; b < nbelts; b++)
{
length = belt[b].length;
width = belt[b].width;
angle = belt[b].angle;
beltlength = 2.0*length + DPI*width;
for (shovel = 0; shovel < belt[b].nshovels; shovel++)
{
position = belt[b].shovel_pos[shovel];
deltapos = belt[b].speed*DT_PARTICLE;
newpos = position + deltapos;
firstseg = belt[b].shovel_segment[shovel];
if (newpos < length)
{
shift = deltapos;
for (seg = firstseg; seg < firstseg+6; seg++)
translate_one_segment(segment, seg, shift*belt[b].tx, shift*belt[b].ty);
}
else if (newpos < length + deltapos)
{
shift = length - position;
beta = (newpos - length)/width;
for (seg = firstseg; seg < firstseg+6; seg++)
{
translate_one_segment(segment, seg, shift*belt[b].tx, shift*belt[b].ty);
rotate_one_segment(segment, seg, -beta, belt[b].x2, belt[b].y2);
}
}
else if (newpos < length + PI*width)
{
beta = deltapos/width;
for (seg = firstseg; seg < firstseg+6; seg++)
{
rotate_one_segment(segment, seg, -beta, belt[b].x2, belt[b].y2);
}
}
else if (newpos < length + PI*width + deltapos)
{
beta = (length + PI*width - position)/width;
shift = newpos - length - PI*width;
for (seg = firstseg; seg < firstseg+6; seg++)
{
rotate_one_segment(segment, seg, -beta, belt[b].x2, belt[b].y2);
translate_one_segment(segment, seg, -shift*belt[b].tx, -shift*belt[b].ty);
}
}
else if (newpos < 2.0*length + PI*width)
{
shift = deltapos;
for (seg = firstseg; seg < firstseg+6; seg++)
translate_one_segment(segment, seg, -shift*belt[b].tx, -shift*belt[b].ty);
}
else if (newpos < 2.0*length + PI*width + deltapos)
{
shift = 2.0*length + PI*width - position;
beta = (newpos - 2.0*length - PI*width)/width;
for (seg = firstseg; seg < firstseg+6; seg++)
{
translate_one_segment(segment, seg, -shift*belt[b].tx, -shift*belt[b].ty);
rotate_one_segment(segment, seg, -beta, belt[b].x2, belt[b].y2);
}
}
else if (newpos < beltlength)
{
beta = deltapos/width;
for (seg = firstseg; seg < firstseg+6; seg++)
{
rotate_one_segment(segment, seg, -beta, belt[b].x1, belt[b].y1);
}
}
else
{
beta = (beltlength - position)/width;
shift = newpos - beltlength;
for (seg = firstseg; seg < firstseg+6; seg++)
{
rotate_one_segment(segment, seg, -beta, belt[b].x1, belt[b].y1);
translate_one_segment(segment, seg, shift*belt[b].tx, shift*belt[b].ty);
}
}
if (newpos > beltlength) newpos -= beltlength;
belt[b].shovel_pos[shovel] = newpos;
}
}
}
void draw_frame(int i, int plot, int bg_color, int ncollisions, int traj_position,
int traj_length,
int wall, double pressure[N_PRESSURES], double pleft, double pright,
int *particle_numbers, short int refresh,
t_lj_parameters params, t_particle particle[NMAXCIRCLES],
t_cluster cluster[NMAXCIRCLES],
t_collision *collisions, t_hashgrid hashgrid[HASHX*HASHY],
t_tracer trajectory[TRAJECTORY_LENGTH*N_TRACER_PARTICLES],
t_obstacle obstacle[NMAXOBSTACLES], t_segment segment[NMAXSEGMENTS],
t_group_data *group_speeds, t_group_segments *segment_group,
t_belt *conveyor_belt, int *tracer_n,
t_otriangle otriangle[NMAX_TRIANGLES_PER_OBSTACLE*NMAXOBSTACLES], t_ofacet ofacet[NMAXOBSTACLES])
/* draw a movie frame */
{
printf("Drawing frame\n");
if ((COLOR_BACKGROUND)&&(bg_color > 0)) color_background(particle, obstacle, bg_color, hashgrid);
// else if (!TRACER_PARTICLE) blank();
if (DRAW_OBSTACLE_LINKS) draw_obstacle_triangles(obstacle, otriangle, ofacet);
// if (DRAW_OBSTACLE_LINKS) old_draw_obstacle_triangles(obstacle);
if (TRACER_PARTICLE) draw_trajectory(trajectory, traj_position, traj_length, particle, cluster, tracer_n, plot);
draw_particles(particle, cluster, plot, params.beta, collisions, ncollisions, bg_color, hashgrid, params);
draw_container(params.xmincontainer, params.xmaxcontainer, obstacle, segment, conveyor_belt, wall);
if (PRINT_PARAMETERS) print_parameters(params, PRINT_LEFT, pressure, refresh);
if (PLOT_SPEEDS) draw_speed_plot(group_speeds, i);
if (PLOT_TRAJECTORIES) draw_trajectory_plot(group_speeds, i);
if ((i > INITIAL_TIME)&&(PLOT_PARTICLE_NUMBER)) draw_particle_nb_plot(particle_numbers, i - INITIAL_TIME);
// if (PLOT_PARTICLE_NUMBER) draw_particle_nb_plot(particle_numbers, i - INITIAL_TIME);
if (BOUNDARY_COND == BC_EHRENFEST) print_ehrenfest_parameters(particle, pleft, pright);
else if (PRINT_PARTICLE_NUMBER)
{
if (REACTION_DIFFUSION) print_particle_types_number(particle, RD_TYPES);
else print_particle_number(ncircles);
}
else if (PRINT_PARTICLE_SPEEDS) print_particles_speeds(particle);
else if (PRINT_SEGMENTS_SPEEDS) print_segment_group_speeds(segment_group);
// printf("5\n");
}
Reference in New Issue View Git Blame Copy Permalink