#endif
/* pse */
+#define PSE_MASS
#define PSE_NAME
#define PSE_COL
#include "pse.h"
+#undef PSE_MASS
#undef PSE_NAME
#undef PSE_COL
pthread_mutex_init(&emutex,NULL);
#endif
+#ifdef CONSTRAINT_110_5832
+ printf("\n\n\nWARNING! WARNING! WARNING!\n\n\n");
+ printf("\n\n\n!! -- constraints enabled -- !!\n\n\n");
+#endif
+#ifdef CONSTRAINT_11X_5832
+ printf("\n\n\nWARNING! WARNING! WARNING!\n\n\n");
+ printf("\n\n\n!! -- constraints enabled -- !!\n\n\n");
+#endif
return 0;
}
switch(type) {
case MOLDYN_POTENTIAL_TM:
- moldyn->func1b=tersoff_mult_1bp;
+ //moldyn->func1b=tersoff_mult_1bp;
moldyn->func3b_j1=tersoff_mult_3bp_j1;
moldyn->func3b_k1=tersoff_mult_3bp_k1;
moldyn->func3b_j2=tersoff_mult_3bp_j2;
* creating lattice functions
*/
-int create_lattice(t_moldyn *moldyn,u8 type,double lc,int element,double mass,
+int create_lattice(t_moldyn *moldyn,u8 type,double lc,int element,
u8 attr,u8 brand,int a,int b,int c,t_3dvec *origin,
- u8 p_type,t_part_vals *p_vals) {
+ t_part_params *p_params,t_defect_params *d_params,
+ t_offset_params *o_params) {
int new,count;
int ret;
if(type==FCC) new*=4;
if(type==DIAMOND) new*=8;
+ /* defects */
+ if(d_params->type) {
+ switch(d_params->stype) {
+ case DEFECT_STYPE_DB_X:
+ case DEFECT_STYPE_DB_Y:
+ case DEFECT_STYPE_DB_Z:
+ case DEFECT_STYPE_DB_R:
+ new*=2;
+ break;
+ default:
+ printf("[moldyn] WARNING: cl unknown defect\n");
+ break;
+ }
+ }
+
/* allocate space for atoms */
ptr=realloc(moldyn->atom,(count+new)*sizeof(t_atom));
if(!ptr) {
switch(type) {
case CUBIC:
+ if(o_params->use)
+ v3_add(&orig,&orig,&(o_params->o));
set_nn_dist(moldyn,lc);
- ret=cubic_init(a,b,c,lc,atom,&orig,p_type,p_vals);
+ ret=cubic_init(a,b,c,lc,atom,&orig,p_params,d_params);
strcpy(name,"cubic");
break;
case FCC:
if(!origin)
v3_scale(&orig,&orig,0.5);
+ if(o_params->use)
+ v3_add(&orig,&orig,&(o_params->o));
set_nn_dist(moldyn,0.5*sqrt(2.0)*lc);
- ret=fcc_init(a,b,c,lc,atom,&orig,p_type,p_vals);
+ ret=fcc_init(a,b,c,lc,atom,&orig,p_params,d_params);
strcpy(name,"fcc");
break;
case DIAMOND:
if(!origin)
v3_scale(&orig,&orig,0.25);
+ if(o_params->use)
+ v3_add(&orig,&orig,&(o_params->o));
set_nn_dist(moldyn,0.25*sqrt(3.0)*lc);
- ret=diamond_init(a,b,c,lc,atom,&orig,p_type,p_vals);
+ ret=diamond_init(a,b,c,lc,atom,&orig,p_params,d_params);
strcpy(name,"diamond");
break;
default:
/* debug */
if(ret!=new) {
- printf("[moldyn] creating lattice failed\n");
+ printf("[moldyn] creating %s lattice (lc=%f) incomplete\n",
+ name,lc);
+ printf(" (ignore for partial lattice creation)\n");
printf(" amount of atoms\n");
printf(" - expected: %d\n",new);
printf(" - created: %d\n",ret);
- return -1;
}
- moldyn->count+=new;
- printf("[moldyn] created %s lattice with %d atoms\n",name,new);
+ moldyn->count+=ret;
+ if(ret==new)
+ printf("[moldyn] created %s lattice with %d atoms\n",name,ret);
- for(ret=0;ret<new;ret++) {
- atom[ret].element=element;
- atom[ret].mass=mass;
- atom[ret].attr=attr;
- atom[ret].brand=brand;
- atom[ret].tag=count+ret;
- check_per_bound(moldyn,&(atom[ret].r));
- atom[ret].r_0=atom[ret].r;
+ for(new=0;new<ret;new++) {
+ atom[new].element=element;
+ atom[new].mass=pse_mass[element];
+ atom[new].attr=attr;
+ atom[new].brand=brand;
+ atom[new].tag=count+new;
+ check_per_bound(moldyn,&(atom[new].r));
+ atom[new].r_0=atom[new].r;
#ifdef PTHREADS
- pthread_mutex_init(&(mutex[ret]),NULL);
+ pthread_mutex_init(&(mutex[new]),NULL);
#endif
+ if(d_params->type) {
+ new+=1;
+ atom[new].element=d_params->element;
+ atom[new].mass=pse_mass[d_params->element];
+ atom[new].attr=d_params->attr;
+ atom[new].brand=d_params->brand;
+ atom[new].tag=count+new;
+ check_per_bound(moldyn,&(atom[new].r));
+ atom[new].r_0=atom[new].r;
+#ifdef PTHREADS
+ pthread_mutex_init(&(mutex[new]),NULL);
+#endif
+ }
}
+ /* fix allocation */
+ ptr=realloc(moldyn->atom,moldyn->count*sizeof(t_atom));
+ if(!ptr) {
+ perror("[moldyn] realloc (create lattice - alloc fix)");
+ return -1;
+ }
+ moldyn->atom=ptr;
+
+// WHAT ABOUT AMUTEX !!!!
+
+#ifdef LOWMEM_LISTS
+ ptr=realloc(moldyn->lc.subcell->list,moldyn->count*sizeof(int));
+ if(!ptr) {
+ perror("[moldyn] list realloc (create lattice)");
+ return -1;
+ }
+ moldyn->lc.subcell->list=ptr;
+#endif
+
/* update total system mass */
total_mass_calc(moldyn);
return ret;
}
-int add_atom(t_moldyn *moldyn,int element,double mass,u8 brand,u8 attr,
+int add_atom(t_moldyn *moldyn,int element,u8 brand,u8 attr,
t_3dvec *r,t_3dvec *v) {
t_atom *atom;
atom[count].r=*r;
atom[count].v=*v;
atom[count].element=element;
- atom[count].mass=mass;
+ atom[count].mass=pse_mass[element];
atom[count].brand=brand;
atom[count].tag=count;
atom[count].attr=attr;
t_atom *new,*old;
int cnt;
+#if defined LOWMEM_LISTS || defined PTHREADS
+ void *ptr;
+#endif
old=moldyn->atom;
free(old);
+#ifdef LOWMEM_LISTS
+ ptr=realloc(moldyn->lc.subcell->list,moldyn->count*sizeof(int));
+ if(!ptr) {
+ perror("[moldyn] list realloc (del atom)");
+ return -1;
+ }
+ moldyn->lc.subcell->list=ptr;
+ // update lists
+ link_cell_update(moldyn);
+#endif
+
+#ifdef PTHREADS
+ ptr=realloc(amutex,moldyn->count*sizeof(pthread_mutex_t));
+ if(!ptr) {
+ perror("[moldyn] mutex realloc (add atom)");
+ return -1;
+ }
+ amutex=ptr;
+ pthread_mutex_destroy(&(amutex[moldyn->count+1]));
+#endif
+
+
return 0;
}
+#define set_atom_positions(pos) \
+ if(d_params->type) {\
+ d_o.x=0; d_o.y=0; d_o.z=0;\
+ d_d.x=0; d_d.y=0; d_d.z=0;\
+ switch(d_params->stype) {\
+ case DEFECT_STYPE_DB_X:\
+ d_o.x=d_params->od;\
+ d_d.x=d_params->dd;\
+ break;\
+ case DEFECT_STYPE_DB_Y:\
+ d_o.y=d_params->od;\
+ d_d.y=d_params->dd;\
+ break;\
+ case DEFECT_STYPE_DB_Z:\
+ d_o.z=d_params->od;\
+ d_d.z=d_params->dd;\
+ break;\
+ case DEFECT_STYPE_DB_R:\
+ break;\
+ default:\
+ printf("[moldyn] WARNING: unknown defect\n");\
+ break;\
+ }\
+ v3_add(&dr,&pos,&d_o);\
+ v3_copy(&(atom[count].r),&dr);\
+ count+=1;\
+ v3_add(&dr,&pos,&d_d);\
+ v3_copy(&(atom[count].r),&dr);\
+ count+=1;\
+ }\
+ else {\
+ v3_copy(&(atom[count].r),&pos);\
+ count+=1;\
+ }
+
/* cubic init */
int cubic_init(int a,int b,int c,double lc,t_atom *atom,t_3dvec *origin,
- u8 p_type,t_part_vals *p_vals) {
+ t_part_params *p_params,t_defect_params *d_params) {
int count;
t_3dvec r;
int i,j,k;
t_3dvec o;
t_3dvec dist;
+ t_3dvec p;
+ t_3dvec d_o;
+ t_3dvec d_d;
+ t_3dvec dr;
+
+ p.x=0; p.y=0; p.z=0;
count=0;
if(origin)
v3_zero(&o);
/* shift partition values */
- if(p_type) {
- p_vals->p.x+=(a*lc)/2.0;
- p_vals->p.y+=(b*lc)/2.0;
- p_vals->p.z+=(c*lc)/2.0;
+ if(p_params->type) {
+ p.x=p_params->p.x+(a*lc)/2.0;
+ p.y=p_params->p.y+(b*lc)/2.0;
+ p.z=p_params->p.z+(c*lc)/2.0;
}
r.x=o.x;
for(j=0;j<b;j++) {
r.z=o.z;
for(k=0;k<c;k++) {
- switch(p_type) {
+ switch(p_params->type) {
case PART_INSIDE_R:
- v3_sub(&dist,&r,&(p_vals->p));
- if(v3_absolute_square(&dist)<(p_vals->r*p_vals->r)) {
- v3_copy(&(atom[count].r),&r);
- count+=1;
+ v3_sub(&dist,&r,&p);
+ if(v3_absolute_square(&dist)<
+ (p_params->r*p_params->r)) {
+ set_atom_positions(r);
}
break;
case PART_OUTSIDE_R:
- v3_sub(&dist,&r,&(p_vals->p));
- if(v3_absolute_square(&dist)>=(p_vals->r*p_vals->r)) {
- v3_copy(&(atom[count].r),&r);
- count+=1;
+ v3_sub(&dist,&r,&p);
+ if(v3_absolute_square(&dist)>=
+ (p_params->r*p_params->r)) {
+ set_atom_positions(r);
+ }
+ break;
+ case PART_INSIDE_D:
+ v3_sub(&dist,&r,&p);
+ if((fabs(dist.x)<p_params->d.x)&&
+ (fabs(dist.y)<p_params->d.y)&&
+ (fabs(dist.z)<p_params->d.z)) {
+ set_atom_positions(r);
+ }
+ break;
+ case PART_OUTSIDE_D:
+ v3_sub(&dist,&r,&p);
+ if((fabs(dist.x)>=p_params->d.x)||
+ (fabs(dist.y)>=p_params->d.y)||
+ (fabs(dist.z)>=p_params->d.z)) {
+ set_atom_positions(r);
}
break;
default:
- v3_copy(&(atom[count].r),&r);
- count+=1;
+ set_atom_positions(r);
break;
}
r.z+=lc;
/* fcc lattice init */
int fcc_init(int a,int b,int c,double lc,t_atom *atom,t_3dvec *origin,
- u8 p_type,t_part_vals *p_vals) {
+ t_part_params *p_params,t_defect_params *d_params) {
int count;
int i,j,k,l;
t_3dvec o,r,n;
t_3dvec basis[3];
t_3dvec dist;
+ t_3dvec p;
+ t_3dvec d_d,d_o,dr;
+
+ p.x=0; p.y=0; p.z=0;
count=0;
if(origin)
basis[2].z=0.5*lc;
/* shift partition values */
- if(p_type) {
- p_vals->p.x+=(a*lc)/2.0;
- p_vals->p.y+=(b*lc)/2.0;
- p_vals->p.z+=(c*lc)/2.0;
+ if(p_params->type) {
+ p.x=p_params->p.x+(a*lc)/2.0;
+ p.y=p_params->p.y+(b*lc)/2.0;
+ p.z=p_params->p.z+(c*lc)/2.0;
}
/* fill up the room */
r.z=o.z;
for(k=0;k<c;k++) {
/* first atom */
- switch(p_type) {
+ switch(p_params->type) {
case PART_INSIDE_R:
- v3_sub(&dist,&r,&(p_vals->p));
- if(v3_absolute_square(&dist)<(p_vals->r*p_vals->r)) {
- v3_copy(&(atom[count].r),&r);
- count+=1;
+ v3_sub(&dist,&r,&p);
+ if(v3_absolute_square(&dist)<
+ (p_params->r*p_params->r)) {
+ set_atom_positions(r);
}
break;
case PART_OUTSIDE_R:
- v3_sub(&dist,&r,&(p_vals->p));
- if(v3_absolute_square(&dist)>=(p_vals->r*p_vals->r)) {
- v3_copy(&(atom[count].r),&r);
- count+=1;
+ v3_sub(&dist,&r,&p);
+ if(v3_absolute_square(&dist)>=
+ (p_params->r*p_params->r)) {
+ set_atom_positions(r);
+ }
+ break;
+ case PART_INSIDE_D:
+ v3_sub(&dist,&r,&p);
+ if((fabs(dist.x)<p_params->d.x)&&
+ (fabs(dist.y)<p_params->d.y)&&
+ (fabs(dist.z)<p_params->d.z)) {
+ set_atom_positions(r);
+ }
+ break;
+ case PART_OUTSIDE_D:
+ v3_sub(&dist,&r,&p);
+ if((fabs(dist.x)>=p_params->d.x)||
+ (fabs(dist.y)>=p_params->d.y)||
+ (fabs(dist.z)>=p_params->d.z)) {
+ set_atom_positions(r);
}
break;
default:
- v3_copy(&(atom[count].r),&r);
- count+=1;
+ set_atom_positions(r);
break;
}
/* the three face centered atoms */
for(l=0;l<3;l++) {
v3_add(&n,&r,&basis[l]);
- switch(p_type) {
+ switch(p_params->type) {
case PART_INSIDE_R:
- v3_sub(&dist,&n,&(p_vals->p));
- if(v3_absolute_square(&dist)<(p_vals->r*p_vals->r)) {
- v3_copy(&(atom[count].r),&r);
- count+=1;
+ v3_sub(&dist,&n,&p);
+ if(v3_absolute_square(&dist)<
+ (p_params->r*p_params->r)) {
+ set_atom_positions(n);
}
break;
case PART_OUTSIDE_R:
- v3_sub(&dist,&n,&(p_vals->p));
- if(v3_absolute_square(&dist)>=(p_vals->r*p_vals->r)) {
- v3_copy(&(atom[count].r),&r);
- count+=1;
+ v3_sub(&dist,&n,&p);
+ if(v3_absolute_square(&dist)>=
+ (p_params->r*p_params->r)) {
+ set_atom_positions(n);
}
break;
+ case PART_INSIDE_D:
+ v3_sub(&dist,&n,&p);
+ if((fabs(dist.x)<p_params->d.x)&&
+ (fabs(dist.y)<p_params->d.y)&&
+ (fabs(dist.z)<p_params->d.z)) {
+ set_atom_positions(n);
+ }
+ break;
+ case PART_OUTSIDE_D:
+ v3_sub(&dist,&n,&p);
+ if((fabs(dist.x)>=p_params->d.x)||
+ (fabs(dist.y)>=p_params->d.y)||
+ (fabs(dist.z)>=p_params->d.z)) {
+ set_atom_positions(n);
+ }
+ break;
default:
- v3_copy(&(atom[count].r),&n);
- count+=1;
+ set_atom_positions(n);
break;
}
}
}
int diamond_init(int a,int b,int c,double lc,t_atom *atom,t_3dvec *origin,
- u8 p_type,t_part_vals *p_vals) {
+ t_part_params *p_params,t_defect_params *d_params) {
int count;
t_3dvec o;
- count=fcc_init(a,b,c,lc,atom,origin,p_type,p_vals);
+ count=fcc_init(a,b,c,lc,atom,origin,p_params,d_params);
o.x=0.25*lc;
o.y=0.25*lc;
if(origin) v3_add(&o,&o,origin);
- count+=fcc_init(a,b,c,lc,&atom[count],&o,p_type,p_vals);
+ count+=fcc_init(a,b,c,lc,&atom[count],&o,p_params,d_params);
return count;
}
/* assume up to date kinetic energy, which is 3/2 N k_B T */
- moldyn->t=(2.0*moldyn->ekin)/(3.0*K_BOLTZMANN*moldyn->count);
+ if(moldyn->count)
+ moldyn->t=(2.0*moldyn->ekin)/(3.0*K_BOLTZMANN*moldyn->count);
+ else moldyn->t=0.0;
return moldyn->t;
}
}
/* global virial (absolute coordinates) */
- virial=&(moldyn->gvir);
- moldyn->gv=virial->xx+virial->yy+virial->zz;
+ //virial=&(moldyn->gvir);
+ //moldyn->gv=virial->xx+virial->yy+virial->zz;
return moldyn->virial;
}
moldyn->p=2.0*moldyn->ekin+moldyn->virial;
moldyn->p/=(3.0*moldyn->volume);
+ //moldyn->px=2.0*moldyn->ekinx+moldyn->vir.xx;
+ //moldyn->px/=moldyn->volume;
+ //moldyn->py=2.0*moldyn->ekiny+moldyn->vir.yy;
+ //moldyn->py/=moldyn->volume;
+ //moldyn->pz=2.0*moldyn->ekinz+moldyn->vir.zz;
+ //moldyn->pz/=moldyn->volume;
+
/* pressure (absolute coordinates) */
- moldyn->gp=2.0*moldyn->ekin+moldyn->gv;
- moldyn->gp/=(3.0*moldyn->volume);
+ //moldyn->gp=2.0*moldyn->ekin+moldyn->gv;
+ //moldyn->gp/=(3.0*moldyn->volume);
return moldyn->p;
}
/* virial */
moldyn->virial_sum=0.0;
- moldyn->gv_sum=0.0;
+ //moldyn->gv_sum=0.0;
/* pressure */
moldyn->p_sum=0.0;
- moldyn->gp_sum=0.0;
+ //moldyn->gp_sum=0.0;
moldyn->tp_sum=0.0;
return 0;
/* virial */
moldyn->virial_sum+=moldyn->virial;
moldyn->virial_avg=moldyn->virial_sum/denom;
- moldyn->gv_sum+=moldyn->gv;
- moldyn->gv_avg=moldyn->gv_sum/denom;
+ //moldyn->gv_sum+=moldyn->gv;
+ //moldyn->gv_avg=moldyn->gv_sum/denom;
/* pressure */
moldyn->p_sum+=moldyn->p;
moldyn->p_avg=moldyn->p_sum/denom;
- moldyn->gp_sum+=moldyn->gp;
- moldyn->gp_avg=moldyn->gp_sum/denom;
+ //moldyn->gp_sum+=moldyn->gp;
+ //moldyn->gp_avg=moldyn->gp_sum/denom;
moldyn->tp_sum+=moldyn->tp;
moldyn->tp_avg=moldyn->tp_sum/denom;
return 0;
}
+int scale_atoms_ind(t_moldyn *moldyn,double x,double y,double z) {
+
+ int i;
+ t_3dvec *r;
+
+ for(i=0;i<moldyn->count;i++) {
+ r=&(moldyn->atom[i].r);
+ r->x*=x;
+ r->y*=y;
+ r->z*=z;
+ }
+
+ return 0;
+}
+
+int scale_dim_ind(t_moldyn *moldyn,double x,double y,double z) {
+
+ t_3dvec *dim;
+
+ dim=&(moldyn->dim);
+
+ dim->x*=x;
+ dim->y*=y;
+ dim->z*=z;
+
+ return 0;
+}
+
int scale_volume(t_moldyn *moldyn) {
t_3dvec *dim,*vdim;
double scale;
t_linkcell *lc;
+ //double sx,sy,sz;
vdim=&(moldyn->vis.dim);
dim=&(moldyn->dim);
scale=pow(moldyn->p/moldyn->p_ref,ONE_THIRD);
}
+
+ /*
+ sx=1.0-(moldyn->p_ref-moldyn->px)*moldyn->p_tc*moldyn->tau;
+ sy=1.0-(moldyn->p_ref-moldyn->py)*moldyn->p_tc*moldyn->tau;
+ sz=1.0-(moldyn->p_ref-moldyn->pz)*moldyn->p_tc*moldyn->tau;
+ sx=pow(sx,ONE_THIRD);
+ sy=pow(sy,ONE_THIRD);
+ sz=pow(sz,ONE_THIRD);
+ */
+
/* scale the atoms and dimensions */
scale_atoms(moldyn,SCALE_DIRECT,scale,TRUE,TRUE,TRUE);
scale_dim(moldyn,SCALE_DIRECT,scale,TRUE,TRUE,TRUE);
+ //scale_atoms_ind(moldyn,sx,sy,sz);
+ //scale_dim_ind(moldyn,sx,sy,sz);
/* visualize dimensions */
if(vdim->x!=0) {
lc->x*=scale;
lc->y*=scale;
lc->z*=scale;
+ //lc->x*=sx;
+ //lc->y*=sx;
+ //lc->z*=sy;
}
return 0;
atom=moldyn->atom;
moldyn->ekin=0.0;
+ //moldyn->ekinx=0.0;
+ //moldyn->ekiny=0.0;
+ //moldyn->ekinz=0.0;
for(i=0;i<moldyn->count;i++) {
atom[i].ekin=0.5*atom[i].mass*v3_absolute_square(&(atom[i].v));
moldyn->ekin+=atom[i].ekin;
+ //moldyn->ekinx+=0.5*atom[i].mass*atom[i].v.x*atom[i].v.x;
+ //moldyn->ekiny+=0.5*atom[i].mass*atom[i].v.y*atom[i].v.y;
+ //moldyn->ekinz+=0.5*atom[i].mass*atom[i].v.z*atom[i].v.z;
}
return moldyn->ekin;
temperature_calc(moldyn);
virial_sum(moldyn);
pressure_calc(moldyn);
- /*
+#ifdef PDEBUG
thermodynamic_pressure_calc(moldyn);
printf("\n\nDEBUG: numeric pressure calc: %f\n\n",
moldyn->tp/BAR);
- */
+#endif
/* calculate fluctuations + averages */
average_and_fluctuation_calc(moldyn);
if(e) {
if(!(moldyn->total_steps%e))
dprintf(moldyn->efd,
- "%f %f %f %f\n",
+ "%f %f %f %f %f %f\n",
moldyn->time,moldyn->ekin/energy_scale,
moldyn->energy/energy_scale,
- get_total_energy(moldyn)/energy_scale);
+ get_total_energy(moldyn)/energy_scale,
+ moldyn->ekin/EV,moldyn->energy/EV);
}
if(m) {
if(!(moldyn->total_steps%m)) {
dprintf(moldyn->pfd,
"%f %f %f %f %f %f %f\n",moldyn->time,
moldyn->p/BAR,moldyn->p_avg/BAR,
- moldyn->gp/BAR,moldyn->gp_avg/BAR,
+ moldyn->p/BAR,moldyn->p_avg/BAR,
moldyn->tp/BAR,moldyn->tp_avg/BAR);
}
}
if(v) {
if(!(moldyn->total_steps%v)) {
dprintf(moldyn->vfd,
- "%f %f\n",moldyn->time,moldyn->volume);
+ "%f %f %f %f %f\n",moldyn->time,
+ moldyn->volume,
+ moldyn->dim.x,
+ moldyn->dim.y,
+ moldyn->dim.z);
}
}
if(s) {
}
/* display progress */
+#ifndef PDEBUG
if(!(i%10)) {
+#endif
/* get current time */
gettimeofday(&t2,NULL);
printf("sched:%d, steps:%d/%d, T:%4.1f/%4.1f P:%4.1f/%4.1f V:%6.1f (%d)\n",
sched->count,i,moldyn->total_steps,
moldyn->t,moldyn->t_avg,
+#ifndef PDEBUG
moldyn->p/BAR,moldyn->p_avg/BAR,
- //moldyn->p/BAR,(moldyn->p-2.0*moldyn->ekin/(3.0*moldyn->volume))/BAR,
+#else
+ moldyn->p/BAR,(moldyn->p-2.0*moldyn->ekin/(3.0*moldyn->volume))/BAR,
+#endif
moldyn->volume,
(int)(t2.tv_sec-t1.tv_sec));
/* copy over time */
t1=t2;
+#ifndef PDEBUG
}
+#endif
/* increase absolute time */
moldyn->time+=moldyn->tau;
}
+ /* writing a final save file! */
+ if(s) {
+ snprintf(dir,128,"%s/s-final.save",moldyn->vlsdir);
+ fd=open(dir,O_WRONLY|O_TRUNC|O_CREAT,S_IRUSR|S_IWUSR);
+ if(fd<0) perror("[moldyn] save fd open");
+ else {
+ write(fd,moldyn,sizeof(t_moldyn));
+ write(fd,moldyn->atom,
+ moldyn->count*sizeof(t_atom));
+ }
+ close(fd);
+ }
+ /* writing a final visual file! */
+ if(a)
+ visual_atoms(moldyn);
+
return 0;
}
double tau,tau_square,h;
t_3dvec delta;
t_atom *atom;
+#ifdef CONSTRAINT_11X_5832
+ double xt,yt,zt;
+ double xtt,ytt,ztt;
+#endif
atom=moldyn->atom;
count=moldyn->count;
tau=moldyn->tau;
tau_square=moldyn->tau_square;
+#ifdef CONSTRAINT_110_5832
+ if(count==5833) {
+ atom[5832].f.x=0.5*(atom[5832].f.x-atom[5832].f.y);
+ atom[5832].f.y=-atom[5832].f.x;
+ }
+#endif
+#ifdef CONSTRAINT_11X_5832
+ if(count==5833) {
+ // second trafo
+ xt=atom[5832].f.x;
+ yt=atom[5832].f.y*cos(-0.16935129)-atom[5832].f.z*sin(-0.16935129);
+ zt=atom[5832].f.y*sin(-0.16935129)+atom[5832].f.z*cos(-0.16935129);
+ // first trafo
+ xtt=xt*cos(M_PI/4.0)-yt*sin(M_PI/4.0);
+ ytt=xt*sin(M_PI/4.0)+yt*sin(M_PI/4.0);
+ ztt=zt;
+ // apply constraints
+ ytt=0.0;
+ // first trafo backwards
+ xt=xtt*cos(M_PI/4.0)+ytt*sin(M_PI/4.0);
+ yt=-xtt*sin(M_PI/4.0)+ytt*sin(M_PI/4.0);
+ zt=ztt;
+ // second trafo backwards
+ atom[5832].f.x=xt;
+ atom[5832].f.y=yt*cos(-0.16935129)+zt*sin(-0.16935129);
+ atom[5832].f.z=-yt*sin(-0.16935129)+zt*cos(-0.16935129);
+ }
+#endif
for(i=0;i<count;i++) {
/* check whether fixed atom */
if(atom[i].attr&ATOM_ATTR_FP)
/* new positions */
h=0.5/atom[i].mass;
v3_scale(&delta,&(atom[i].v),tau);
+#ifdef CONSTRAINT_110_5832
+ if(i==5832) {
+ delta.y=-delta.x;
+ }
+#endif
+#ifdef JHDVHJDV
+#ifdef CONSTRAINT_11X_5832
+ if(i==5833) {
+ // second trafo
+ xt=delta.x;
+ yt=delta.y*cos(-0.16935129)-delta.z*sin(-0.16935129);
+ zt=delta.y*sin(-0.16935129)+delta.z*cos(-0.16935129);
+ // first trafo
+ xtt=xt*cos(M_PI/4.0)-yt*sin(M_PI/4.0);
+ ytt=xt*sin(M_PI/4.0)+yt*sin(M_PI/4.0);
+ ztt=zt;
+ // apply constraints
+ ytt=0.0;
+ // first trafo backwards
+ xt=xtt*cos(M_PI/4.0)+ytt*sin(M_PI/4.0);
+ yt=-xtt*sin(M_PI/4.0)+ytt*sin(M_PI/4.0);
+ zt=ztt;
+ // second trafo backwards
+ delta.x=xt;
+ delta.y=yt*cos(-0.16935129)+zt*sin(-0.16935129);
+ delta.z=-yt*sin(-0.16935129)+zt*cos(-0.16935129);
+ }
+#endif
+#endif
+#ifndef QUENCH
v3_add(&(atom[i].r),&(atom[i].r),&delta);
+#endif
v3_scale(&delta,&(atom[i].f),h*tau_square);
+#ifdef CONSTRAINT_110_5832
+ if(i==5832) {
+ delta.y=-delta.x;
+ }
+#endif
+#ifdef GHDJHBSJBSD
+#ifdef CONSTRAINT_11X_5832
+ if(i==5833) {
+ // second trafo
+ xt=delta.x;
+ yt=delta.y*cos(-0.16935129)-delta.z*sin(-0.16935129);
+ zt=delta.y*sin(-0.16935129)+delta.z*cos(-0.16935129);
+ // first trafo
+ xtt=xt*cos(M_PI/4.0)-yt*sin(M_PI/4.0);
+ ytt=xt*sin(M_PI/4.0)+yt*sin(M_PI/4.0);
+ ztt=zt;
+ // apply constraints
+ ytt=0.0;
+ // first trafo backwards
+ xt=xtt*cos(M_PI/4.0)+ytt*sin(M_PI/4.0);
+ yt=-xtt*sin(M_PI/4.0)+ytt*sin(M_PI/4.0);
+ zt=ztt;
+ // second trafo backwards
+ delta.x=xt;
+ delta.y=yt*cos(-0.16935129)+zt*sin(-0.16935129);
+ delta.z=-yt*sin(-0.16935129)+zt*cos(-0.16935129);
+ }
+#endif
+#endif
v3_add(&(atom[i].r),&(atom[i].r),&delta);
+ //check_per_bound_and_care_for_pbc(moldyn,&(atom[i]));
check_per_bound(moldyn,&(atom[i].r));
/* velocities [actually v(t+tau/2)] */
/* forces depending on chosen potential */
#ifndef ALBE_FAST
- potential_force_calc(moldyn);
+ // if albe, use albe force calc routine
+ //if(moldyn->func3b_j1==albe_mult_3bp_j1)
+ // albe_potential_force_calc(moldyn);
+ //else
+ potential_force_calc(moldyn);
#else
albe_potential_force_calc(moldyn);
#endif
+#ifdef CONSTRAINT_110_5832
+ if(count==5833) {
+ atom[5832].f.x=0.5*(atom[5832].f.x-atom[5832].f.y);
+ atom[5832].f.y=-atom[5832].f.x;
+ }
+#endif
+#ifdef CONSTRAINT_11X_5832
+ if(count==5833) {
+ // second trafo
+ xt=atom[5832].f.x;
+ yt=atom[5832].f.y*cos(-0.16935129)-atom[5832].f.z*sin(-0.16935129);
+ zt=atom[5832].f.y*sin(-0.16935129)+atom[5832].f.z*cos(-0.16935129);
+ // first trafo
+ xtt=xt*cos(M_PI/4.0)-yt*sin(M_PI/4.0);
+ ytt=xt*sin(M_PI/4.0)+yt*sin(M_PI/4.0);
+ ztt=zt;
+ // apply constraints
+ ytt=0.0;
+ // first trafo backwards
+ xt=xtt*cos(M_PI/4.0)+ytt*sin(M_PI/4.0);
+ yt=-xtt*sin(M_PI/4.0)+ytt*sin(M_PI/4.0);
+ zt=ztt;
+ // second trafo backwards
+ atom[5832].f.x=xt;
+ atom[5832].f.y=yt*cos(-0.16935129)+zt*sin(-0.16935129);
+ atom[5832].f.z=-yt*sin(-0.16935129)+zt*cos(-0.16935129);
+ }
+#endif
for(i=0;i<count;i++) {
/* check whether fixed atom */
if(atom[i].attr&ATOM_ATTR_FP)
return 0;
}
+int check_per_bound_and_care_for_pbc(t_moldyn *moldyn,t_atom *a) {
+
+ double x,y,z;
+ t_3dvec *dim;
+
+ dim=&(moldyn->dim);
+
+ x=dim->x/2;
+ y=dim->y/2;
+ z=dim->z/2;
+
+ if(moldyn->status&MOLDYN_STAT_PBX) {
+ if(a->r.x>=x) {
+ a->pbc[0]+=1;
+ a->r.x-=dim->x;
+ }
+ else if(-a->r.x>x) {
+ a->pbc[0]-=1;
+ a->r.x+=dim->x;
+ }
+ }
+ if(moldyn->status&MOLDYN_STAT_PBY) {
+ if(a->r.y>=y) {
+ a->pbc[1]+=1;
+ a->r.y-=dim->y;
+ }
+ else if(-a->r.y>y) {
+ a->pbc[1]-=1;
+ a->r.y+=dim->y;
+ }
+ }
+ if(moldyn->status&MOLDYN_STAT_PBZ) {
+ if(a->r.z>=z) {
+ a->pbc[2]+=1;
+ a->r.z-=dim->z;
+ }
+ else if(-a->r.z>z) {
+ a->pbc[2]-=1;
+ a->r.z+=dim->z;
+ }
+ }
+
+ return 0;
+}
+
/*
* debugging / critical check functions
*/
if(fsize!=sizeof(t_moldyn)+size) {
corr=fsize-sizeof(t_moldyn)-size;
printf("[moldyn] WARNING: lsf (illegal file size)\n");
- printf(" moifying offset:\n");
+ printf(" modifying offset:\n");
printf(" - current pos: %d\n",sizeof(t_moldyn));
printf(" - atom size: %d\n",size);
printf(" - file size: %d\n",fsize);
size-=cnt;
}
+#ifdef PTHREADS
+ amutex=malloc(moldyn->count*sizeof(pthread_mutex_t));
+ if(amutex==NULL) {
+ perror("[moldyn] load save file (mutexes)");
+ return -1;
+ }
+ for(cnt=0;cnt<moldyn->count;cnt++)
+ pthread_mutex_init(&(amutex[cnt]),NULL);
+#endif
+
// hooks etc ...
return 0;
int i;
t_atom *atom;
t_3dvec dist;
+ t_3dvec final_r;
double d2;
int a_cnt;
int b_cnt;
for(i=0;i<moldyn->count;i++) {
- v3_sub(&dist,&(atom[i].r),&(atom[i].r_0));
- check_per_bound(moldyn,&dist);
+ /* care for pb crossing */
+ final_r.x=atom[i].r.x+atom[i].pbc[0]*moldyn->dim.x;
+ final_r.y=atom[i].r.y+atom[i].pbc[1]*moldyn->dim.y;
+ final_r.z=atom[i].r.z+atom[i].pbc[2]*moldyn->dim.z;
+ /* calculate distance */
+ v3_sub(&dist,&final_r,&(atom[i].r_0));
d2=v3_absolute_square(&dist);
if(atom[i].brand) {
return 0;
}
+int calculate_msd(t_moldyn *moldyn,double *msd) {
+
+ int i;
+ t_atom *atom;
+ t_3dvec dist;
+ t_3dvec final_r;
+ double d2;
+ int a_cnt;
+ int b_cnt;
+
+ atom=moldyn->atom;
+ msd[0]=0;
+ msd[1]=0;
+ msd[2]=0;
+ a_cnt=0;
+ b_cnt=0;
+
+ for(i=0;i<moldyn->count;i++) {
+
+ /* care for pb crossing */
+ if(atom[i].pbc[0]|atom[i].pbc[1]|atom[i].pbc[2]) {
+ printf("[moldyn] msd pb crossings for atom %d\n",i);
+ printf(" x: %d y: %d z: %d\n",
+ atom[i].pbc[0],atom[i].pbc[1],atom[i].pbc[2]);
+ }
+ final_r.x=atom[i].r.x+atom[i].pbc[0]*moldyn->dim.x;
+ final_r.y=atom[i].r.y+atom[i].pbc[1]*moldyn->dim.y;
+ final_r.z=atom[i].r.z+atom[i].pbc[2]*moldyn->dim.z;
+ /* calculate distance */
+ v3_sub(&dist,&final_r,&(atom[i].r_0));
+ d2=v3_absolute_square(&dist);
+
+ if(atom[i].brand) {
+ b_cnt+=1;
+ msd[1]+=d2;
+ }
+ else {
+ a_cnt+=1;
+ msd[0]+=d2;
+ }
+
+ msd[2]+=d2;
+ }
+
+ msd[0]/=a_cnt;
+ msd[1]/=b_cnt;
+ msd[2]/=moldyn->count;
+
+ return 0;
+}
+
int bonding_analyze(t_moldyn *moldyn,double *cnt) {
return 0;
ba=data;
/* increase total bond counter
- * ... double counting!
*/
- ba->tcnt+=2;
+ ba->tcnt+=1;
if(itom->brand==0)
ba->acnt[jtom->tag]+=1;
int bond_analyze(t_moldyn *moldyn,double *quality) {
- // by now: # bonds of type 'a-4b' and 'b-4a' / # bonds total
-
- int qcnt;
- int ccnt,cset;
+ int qcnt4;
+ int qcnt3;
+ int ccnt4;
+ int ccnt3;
+ int bcnt;
t_ba ba;
int i;
t_atom *atom;
memset(ba.bcnt,0,moldyn->count*sizeof(int));
ba.tcnt=0;
- qcnt=0;
- ccnt=0;
- cset=0;
+ qcnt4=0; qcnt3=0;
+ ccnt4=0; ccnt3=0;
+ bcnt=0;
atom=moldyn->atom;
for(i=0;i<moldyn->count;i++) {
if(atom[i].brand==0) {
if((ba.acnt[i]==0)&(ba.bcnt[i]==4))
- qcnt+=4;
+ qcnt4+=4;
+ if((ba.acnt[i]==0)&(ba.bcnt[i]==3))
+ qcnt3+=3;
}
else {
if((ba.acnt[i]==4)&(ba.bcnt[i]==0)) {
- qcnt+=4;
- ccnt+=1;
+ qcnt4+=4;
+ ccnt4+=1;
}
- cset+=1;
+ if((ba.acnt[i]==3)&(ba.bcnt[i]==0)) {
+ qcnt3+=4;
+ ccnt3+=1;
+ }
+ bcnt+=1;
}
}
- printf("[moldyn] bond analyze: c_cnt=%d | set=%d\n",ccnt,cset);
- printf("[moldyn] bond analyze: q_cnt=%d | tot=%d\n",qcnt,ba.tcnt);
-
if(quality) {
- quality[0]=1.0*ccnt/cset;
- quality[1]=1.0*qcnt/ba.tcnt;
+ quality[0]=1.0*ccnt4/bcnt;
+ quality[1]=1.0*ccnt3/bcnt;
}
else {
- printf("[moldyn] bond analyze: c_bnd_q=%f\n",1.0*qcnt/ba.tcnt);
- printf("[moldyn] bond analyze: tot_q=%f\n",1.0*qcnt/ba.tcnt);
+ printf("[moldyn] bond analyze: %f %f\n",
+ 1.0*ccnt4/bcnt,1.0*ccnt3/bcnt);
}
return 0;
t_visual *v;
t_atom *atom;
t_vb vb;
+ t_3dvec strain;
#ifdef VISUAL_THREAD
t_moldyn *moldyn;
moldyn->count,moldyn->time,help/40.0,help/40.0,-0.8*help);
// atomic configuration
- for(i=0;i<moldyn->count;i++)
+ for(i=0;i<moldyn->count;i++) {
+ v3_sub(&strain,&(atom[i].r),&(atom[i].r_0));
+ check_per_bound(moldyn,&strain);
// atom type, positions, color and kinetic energy
dprintf(vb.fd,"%s %f %f %f %s %f\n",pse_name[atom[i].element],
atom[i].r.x,
atom[i].r.y,
atom[i].r.z,
pse_col[atom[i].element],
- atom[i].ekin);
+ //atom[i].ekin);
+ sqrt(v3_absolute_square(&strain)));
+ }
// bonds between atoms
#ifndef VISUAL_THREAD