+ printf("[moldyn] schedule added:\n");
+ printf(" number: %d | runs: %d | tau: %f\n",count-1,runs,tau);
+
+
+ return 0;
+}
+
+int moldyn_set_schedule_hook(t_moldyn *moldyn,set_hook hook,void *hook_params) {
+
+ moldyn->schedule.hook=hook;
+ moldyn->schedule.hook_params=hook_params;
+
+ return 0;
+}
+
+/*
+ *
+ * 'integration of newtons equation' - algorithms
+ *
+ */
+
+/* start the integration */
+
+int moldyn_integrate(t_moldyn *moldyn) {
+
+ int i;
+ unsigned int e,m,s,v,p,t;
+ t_3dvec momentum;
+ t_moldyn_schedule *sched;
+ t_atom *atom;
+ int fd;
+ char dir[128];
+ double ds;
+ double energy_scale;
+ //double tp;
+
+ sched=&(moldyn->schedule);
+ atom=moldyn->atom;
+
+ /* initialize linked cell method */
+ link_cell_init(moldyn,VERBOSE);
+
+ /* logging & visualization */
+ e=moldyn->ewrite;
+ m=moldyn->mwrite;
+ s=moldyn->swrite;
+ v=moldyn->vwrite;
+ p=moldyn->pwrite;
+ t=moldyn->twrite;
+
+ /* sqaure of some variables */
+ moldyn->tau_square=moldyn->tau*moldyn->tau;
+ moldyn->cutoff_square=moldyn->cutoff*moldyn->cutoff;
+
+ /* energy scaling factor */
+ energy_scale=moldyn->count*EV;
+
+ /* calculate initial forces */
+ potential_force_calc(moldyn);
+#ifdef DEBUG
+return 0;
+#endif
+
+ /* some stupid checks before we actually start calculating bullshit */
+ if(moldyn->cutoff>0.5*moldyn->dim.x)
+ printf("[moldyn] warning: cutoff > 0.5 x dim.x\n");
+ if(moldyn->cutoff>0.5*moldyn->dim.y)
+ printf("[moldyn] warning: cutoff > 0.5 x dim.y\n");
+ if(moldyn->cutoff>0.5*moldyn->dim.z)
+ printf("[moldyn] warning: cutoff > 0.5 x dim.z\n");
+ ds=0.5*atom[0].f.x*moldyn->tau_square/atom[0].mass;
+ if(ds>0.05*moldyn->nnd)
+ printf("[moldyn] warning: forces too high / tau too small!\n");
+
+ /* zero absolute time */
+ moldyn->time=0.0;
+ moldyn->total_steps=0;
+
+ /* debugging, ignore */
+ moldyn->debug=0;
+
+ /* tell the world */
+ printf("[moldyn] integration start, go get a coffee ...\n");
+
+ /* executing the schedule */
+ sched->count=0;
+ while(sched->count<sched->total_sched) {
+
+ /* setting amount of runs and finite time step size */
+ moldyn->tau=sched->tau[sched->count];
+ moldyn->tau_square=moldyn->tau*moldyn->tau;
+ moldyn->time_steps=sched->runs[sched->count];
+
+ /* integration according to schedule */
+
+ for(i=0;i<moldyn->time_steps;i++) {
+
+ /* integration step */
+ moldyn->integrate(moldyn);
+
+ /* calculate kinetic energy, temperature and pressure */
+ e_kin_calc(moldyn);
+ temperature_calc(moldyn);
+ virial_sum(moldyn);
+ pressure_calc(moldyn);
+ average_and_fluctuation_calc(moldyn);
+
+ /* p/t scaling */
+ if(moldyn->pt_scale&(T_SCALE_BERENDSEN|T_SCALE_DIRECT))
+ scale_velocity(moldyn,FALSE);
+ if(moldyn->pt_scale&(P_SCALE_BERENDSEN|P_SCALE_DIRECT))
+ scale_volume(moldyn);
+
+ /* check for log & visualization */
+ if(e) {
+ if(!(i%e))
+ dprintf(moldyn->efd,
+ "%f %f %f %f\n",
+ moldyn->time,moldyn->ekin/energy_scale,
+ moldyn->energy/energy_scale,
+ get_total_energy(moldyn)/energy_scale);
+ }
+ if(m) {
+ if(!(i%m)) {
+ momentum=get_total_p(moldyn);
+ dprintf(moldyn->mfd,
+ "%f %f %f %f %f\n",moldyn->time,
+ momentum.x,momentum.y,momentum.z,
+ v3_norm(&momentum));
+ }
+ }
+ if(p) {
+ if(!(i%p)) {
+ dprintf(moldyn->pfd,
+ "%f %f %f %f %f\n",moldyn->time,
+ moldyn->p/BAR,moldyn->p_avg/BAR,
+ moldyn->gp/BAR,moldyn->gp_avg/BAR);
+ }
+ }
+ if(t) {
+ if(!(i%t)) {
+ dprintf(moldyn->tfd,
+ "%f %f %f\n",
+ moldyn->time,moldyn->t,moldyn->t_avg);
+ }
+ }
+ if(s) {
+ if(!(i%s)) {
+ snprintf(dir,128,"%s/s-%07.f.save",
+ moldyn->vlsdir,moldyn->time);
+ fd=open(dir,O_WRONLY|O_TRUNC|O_CREAT);
+ 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);
+ }
+ }
+ if(v) {
+ if(!(i%v)) {
+ visual_atoms(&(moldyn->vis),moldyn->time,
+ moldyn->atom,moldyn->count);
+ }
+ }
+
+ /* display progress */
+ if(!(i%10)) {
+ printf("\rsched:%d, steps:%d, T:%3.1f/%3.1f P:%4.1f/%4.1f V:%6.1f",
+ sched->count,i,
+ moldyn->t,moldyn->t_avg,
+ moldyn->p_avg/BAR,moldyn->gp_avg/BAR,
+ moldyn->volume);
+ fflush(stdout);
+ }
+
+ /* increase absolute time */
+ moldyn->time+=moldyn->tau;
+ moldyn->total_steps+=1;
+
+ }
+
+ /* check for hooks */
+ if(sched->hook) {
+ printf("\n ## schedule hook %d/%d start ##\n",
+ sched->count+1,sched->total_sched-1);
+ sched->hook(moldyn,sched->hook_params);
+ printf(" ## schedule hook end ##\n");
+ }
+
+ /* increase the schedule counter */
+ sched->count+=1;
+
+ }
+
+ return 0;
+}
+
+/* velocity verlet */
+
+int velocity_verlet(t_moldyn *moldyn) {
+
+ int i,count;
+ double tau,tau_square,h;
+ t_3dvec delta;
+ t_atom *atom;
+
+ atom=moldyn->atom;
+ count=moldyn->count;
+ tau=moldyn->tau;
+ tau_square=moldyn->tau_square;
+
+ for(i=0;i<count;i++) {
+ /* new positions */
+ h=0.5/atom[i].mass;
+ v3_scale(&delta,&(atom[i].v),tau);
+ v3_add(&(atom[i].r),&(atom[i].r),&delta);
+ v3_scale(&delta,&(atom[i].f),h*tau_square);
+ v3_add(&(atom[i].r),&(atom[i].r),&delta);
+ check_per_bound(moldyn,&(atom[i].r));
+
+ /* velocities [actually v(t+tau/2)] */
+ v3_scale(&delta,&(atom[i].f),h*tau);
+ v3_add(&(atom[i].v),&(atom[i].v),&delta);
+ }
+
+ /* neighbour list update */
+ link_cell_update(moldyn);
+
+ /* forces depending on chosen potential */
+ potential_force_calc(moldyn);
+
+ for(i=0;i<count;i++) {
+ /* again velocities [actually v(t+tau)] */
+ v3_scale(&delta,&(atom[i].f),0.5*tau/atom[i].mass);
+ v3_add(&(atom[i].v),&(atom[i].v),&delta);
+ }
+
+ return 0;
+}
+
+
+/*
+ *
+ * potentials & corresponding forces & virial routine
+ *
+ */
+
+/* generic potential and force calculation */
+
+int potential_force_calc(t_moldyn *moldyn) {
+
+ int i,j,k,count;
+ t_atom *itom,*jtom,*ktom;
+ t_virial *virial;
+ t_linkcell *lc;
+ t_list neighbour_i[27];
+ t_list neighbour_i2[27];
+ t_list *this,*that;
+ u8 bc_ij,bc_ik;
+ int dnlc;
+
+ count=moldyn->count;
+ itom=moldyn->atom;
+ lc=&(moldyn->lc);
+
+ /* reset energy */
+ moldyn->energy=0.0;
+
+ /* reset global virial */
+ memset(&(moldyn->gvir),0,sizeof(t_virial));
+
+ /* reset force, site energy and virial of every atom */
+ for(i=0;i<count;i++) {
+
+ /* reset force */
+ v3_zero(&(itom[i].f));
+
+ /* reset virial */
+ virial=(&(itom[i].virial));
+ virial->xx=0.0;
+ virial->yy=0.0;
+ virial->zz=0.0;
+ virial->xy=0.0;
+ virial->xz=0.0;
+ virial->yz=0.0;
+
+ /* reset site energy */
+ itom[i].e=0.0;
+
+ }
+
+ /* get energy, force and virial of every atom */
+
+ /* first (and only) loop over atoms i */
+ for(i=0;i<count;i++) {
+
+ /* single particle potential/force */
+ if(itom[i].attr&ATOM_ATTR_1BP)
+ if(moldyn->func1b)
+ moldyn->func1b(moldyn,&(itom[i]));
+
+ if(!(itom[i].attr&(ATOM_ATTR_2BP|ATOM_ATTR_3BP)))
+ continue;
+
+ /* 2 body pair potential/force */
+
+ link_cell_neighbour_index(moldyn,
+ (itom[i].r.x+moldyn->dim.x/2)/lc->x,
+ (itom[i].r.y+moldyn->dim.y/2)/lc->y,
+ (itom[i].r.z+moldyn->dim.z/2)/lc->z,
+ neighbour_i);
+
+ dnlc=lc->dnlc;
+
+ /* first loop over atoms j */
+ if(moldyn->func2b) {
+ for(j=0;j<27;j++) {
+
+ this=&(neighbour_i[j]);
+ list_reset_f(this);
+
+ if(this->start==NULL)
+ continue;
+
+ bc_ij=(j<dnlc)?0:1;
+
+ do {
+ jtom=this->current->data;
+
+ if(jtom==&(itom[i]))
+ continue;
+
+ if((jtom->attr&ATOM_ATTR_2BP)&
+ (itom[i].attr&ATOM_ATTR_2BP)) {
+ moldyn->func2b(moldyn,
+ &(itom[i]),
+ jtom,
+ bc_ij);
+ }
+ } while(list_next_f(this)!=L_NO_NEXT_ELEMENT);
+
+ }
+ }
+
+ /* 3 body potential/force */
+
+ if(!(itom[i].attr&ATOM_ATTR_3BP))
+ continue;
+
+ /* copy the neighbour lists */
+ memcpy(neighbour_i2,neighbour_i,27*sizeof(t_list));
+
+ /* second loop over atoms j */
+ for(j=0;j<27;j++) {
+
+ this=&(neighbour_i[j]);
+ list_reset_f(this);
+
+ if(this->start==NULL)
+ continue;
+
+ bc_ij=(j<dnlc)?0:1;
+
+ do {
+ jtom=this->current->data;
+
+ if(jtom==&(itom[i]))
+ continue;
+
+ if(!(jtom->attr&ATOM_ATTR_3BP))
+ continue;
+
+ /* reset 3bp run */
+ moldyn->run3bp=1;
+
+ if(moldyn->func3b_j1)
+ moldyn->func3b_j1(moldyn,
+ &(itom[i]),
+ jtom,
+ bc_ij);
+
+ /* in first j loop, 3bp run can be skipped */
+ if(!(moldyn->run3bp))
+ continue;
+
+ /* first loop over atoms k */
+ if(moldyn->func3b_k1) {
+
+ for(k=0;k<27;k++) {
+
+ that=&(neighbour_i2[k]);
+ list_reset_f(that);
+
+ if(that->start==NULL)
+ continue;
+
+ bc_ik=(k<dnlc)?0:1;
+
+ do {
+
+ ktom=that->current->data;
+
+ if(!(ktom->attr&ATOM_ATTR_3BP))
+ continue;
+
+ if(ktom==jtom)
+ continue;
+
+ if(ktom==&(itom[i]))
+ continue;
+
+ moldyn->func3b_k1(moldyn,
+ &(itom[i]),
+ jtom,
+ ktom,
+ bc_ik|bc_ij);
+
+ } while(list_next_f(that)!=\
+ L_NO_NEXT_ELEMENT);
+
+ }
+
+ }
+
+ if(moldyn->func3b_j2)
+ moldyn->func3b_j2(moldyn,
+ &(itom[i]),
+ jtom,
+ bc_ij);
+
+ /* second loop over atoms k */
+ if(moldyn->func3b_k2) {
+
+ for(k=0;k<27;k++) {
+
+ that=&(neighbour_i2[k]);
+ list_reset_f(that);
+
+ if(that->start==NULL)
+ continue;
+
+ bc_ik=(k<dnlc)?0:1;
+
+ do {
+
+ ktom=that->current->data;
+
+ if(!(ktom->attr&ATOM_ATTR_3BP))
+ continue;
+
+ if(ktom==jtom)
+ continue;
+
+ if(ktom==&(itom[i]))
+ continue;
+
+ moldyn->func3b_k2(moldyn,
+ &(itom[i]),
+ jtom,
+ ktom,
+ bc_ik|bc_ij);
+
+ } while(list_next_f(that)!=\
+ L_NO_NEXT_ELEMENT);
+
+ }
+
+ }
+
+ /* 2bp post function */
+ if(moldyn->func3b_j3) {
+ moldyn->func3b_j3(moldyn,
+ &(itom[i]),
+ jtom,bc_ij);
+ }
+
+ } while(list_next_f(this)!=L_NO_NEXT_ELEMENT);
+
+ }
+
+#ifdef DEBUG
+ //printf("\n\n");
+#endif
+#ifdef VDEBUG
+ printf("\n\n");
+#endif
+
+ }
+
+#ifdef DEBUG
+ printf("\nATOM 0: %f %f %f\n\n",itom->f.x,itom->f.y,itom->f.z);
+#endif
+
+ /* calculate global virial */
+ for(i=0;i<count;i++) {
+ moldyn->gvir.xx+=moldyn->atom[i].r.x*moldyn->atom[i].f.x;
+ moldyn->gvir.yy+=moldyn->atom[i].r.y*moldyn->atom[i].f.y;
+ moldyn->gvir.zz+=moldyn->atom[i].r.z*moldyn->atom[i].f.z;
+ moldyn->gvir.xy+=moldyn->atom[i].r.y*moldyn->atom[i].f.x;
+ moldyn->gvir.xz+=moldyn->atom[i].r.z*moldyn->atom[i].f.x;
+ moldyn->gvir.yz+=moldyn->atom[i].r.z*moldyn->atom[i].f.y;
+ }
+
+ return 0;
+}
+
+/*
+ * virial calculation
+ */
+
+//inline int virial_calc(t_atom *a,t_3dvec *f,t_3dvec *d) {
+int virial_calc(t_atom *a,t_3dvec *f,t_3dvec *d) {
+
+ a->virial.xx+=f->x*d->x;
+ a->virial.yy+=f->y*d->y;
+ a->virial.zz+=f->z*d->z;
+ a->virial.xy+=f->x*d->y;
+ a->virial.xz+=f->x*d->z;
+ a->virial.yz+=f->y*d->z;
+
+ return 0;
+}
+
+/*
+ * periodic boundary checking
+ */
+
+//inline int check_per_bound(t_moldyn *moldyn,t_3dvec *a) {
+int check_per_bound(t_moldyn *moldyn,t_3dvec *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->x>=x) a->x-=dim->x;
+ else if(-a->x>x) a->x+=dim->x;
+ }
+ if(moldyn->status&MOLDYN_STAT_PBY) {
+ if(a->y>=y) a->y-=dim->y;
+ else if(-a->y>y) a->y+=dim->y;
+ }
+ if(moldyn->status&MOLDYN_STAT_PBZ) {
+ if(a->z>=z) a->z-=dim->z;
+ else if(-a->z>z) a->z+=dim->z;
+ }
+
+ return 0;
+}
+
+/*
+ * debugging / critical check functions
+ */
+
+int moldyn_bc_check(t_moldyn *moldyn) {
+
+ t_atom *atom;
+ t_3dvec *dim;
+ int i;
+ double x;
+ u8 byte;
+ int j,k;
+
+ atom=moldyn->atom;
+ dim=&(moldyn->dim);
+ x=dim->x/2;
+
+ for(i=0;i<moldyn->count;i++) {
+ if(atom[i].r.x>=dim->x/2||-atom[i].r.x>dim->x/2) {
+ printf("FATAL: atom %d: x: %.20f (%.20f)\n",
+ i,atom[i].r.x,dim->x/2);
+ printf("diagnostic:\n");
+ printf("-----------\natom.r.x:\n");
+ for(j=0;j<8;j++) {
+ memcpy(&byte,(u8 *)(&(atom[i].r.x))+j,1);
+ for(k=0;k<8;k++)
+ printf("%d%c",
+ ((byte)&(1<<k))?1:0,
+ (k==7)?'\n':'|');
+ }
+ printf("---------------\nx=dim.x/2:\n");
+ for(j=0;j<8;j++) {
+ memcpy(&byte,(u8 *)(&x)+j,1);
+ for(k=0;k<8;k++)
+ printf("%d%c",
+ ((byte)&(1<<k))?1:0,
+ (k==7)?'\n':'|');
+ }
+ if(atom[i].r.x==x) printf("the same!\n");
+ else printf("different!\n");
+ }
+ if(atom[i].r.y>=dim->y/2||-atom[i].r.y>dim->y/2)
+ printf("FATAL: atom %d: y: %.20f (%.20f)\n",
+ i,atom[i].r.y,dim->y/2);
+ if(atom[i].r.z>=dim->z/2||-atom[i].r.z>dim->z/2)
+ printf("FATAL: atom %d: z: %.20f (%.20f)\n",
+ i,atom[i].r.z,dim->z/2);
+ }
+
+ return 0;
+}
+
+/*
+ * post processing functions
+ */
+
+int get_line(int fd,char *line,int max) {
+
+ int count,ret;
+
+ count=0;
+
+ while(1) {
+ if(count==max) return count;
+ ret=read(fd,line+count,1);
+ if(ret<=0) return ret;
+ if(line[count]=='\n') {
+ line[count]='\0';
+ return count+1;
+ }
+ count+=1;
+ }
+}