testing foo
[physik/posic.git] / moldyn.c
index c25fed3..db91859 100644 (file)
--- a/moldyn.c
+++ b/moldyn.c
@@ -230,33 +230,38 @@ int moldyn_log_shutdown(t_moldyn *moldyn) {
  */
 
 int create_lattice(t_moldyn *moldyn,u8 type,double lc,int element,double mass,
-                   u8 attr,u8 bnum,int a,int b,int c) {
+                   u8 attr,u8 brand,int a,int b,int c) {
 
-       int count;
+       int new,count;
        int ret;
        t_3dvec origin;
+       void *ptr;
+       t_atom *atom;
 
-       count=a*b*c;
+       new=a*b*c;
+       count=moldyn->count;
 
        /* how many atoms do we expect */
-       if(type==FCC) count*=4;
-       if(type==DIAMOND) count*=8;
+       if(type==FCC) new*=4;
+       if(type==DIAMOND) new*=8;
 
        /* allocate space for atoms */
-       moldyn->atom=malloc(count*sizeof(t_atom));
-       if(moldyn->atom==NULL) {
-               perror("malloc (atoms)");
+       ptr=realloc(moldyn->atom,(count+new)*sizeof(t_atom));
+       if(!ptr) {
+               perror("[moldyn] realloc (create lattice)");
                return -1;
        }
-
+       moldyn->atom=ptr;
+       atom=&(moldyn->atom[count]);
+               
        v3_zero(&origin);
 
        switch(type) {
                case FCC:
-                       ret=fcc_init(a,b,c,lc,moldyn->atom,&origin);
+                       ret=fcc_init(a,b,c,lc,atom,&origin);
                        break;
                case DIAMOND:
-                       ret=diamond_init(a,b,c,lc,moldyn->atom,&origin);
+                       ret=diamond_init(a,b,c,lc,atom,&origin);
                        break;
                default:
                        printf("unknown lattice type (%02x)\n",type);
@@ -264,24 +269,24 @@ int create_lattice(t_moldyn *moldyn,u8 type,double lc,int element,double mass,
        }
 
        /* debug */
-       if(ret!=count) {
+       if(ret!=new) {
                printf("[moldyn] creating lattice failed\n");
                printf("  amount of atoms\n");
-               printf("  - expected: %d\n",count);
+               printf("  - expected: %d\n",new);
                printf("  - created: %d\n",ret);
                return -1;
        }
 
-       moldyn->count=count;
-       printf("[moldyn] created lattice with %d atoms\n",count);
+       moldyn->count+=new;
+       printf("[moldyn] created lattice with %d atoms\n",new);
 
-       while(count) {
-               count-=1;
-               moldyn->atom[count].element=element;
-               moldyn->atom[count].mass=mass;
-               moldyn->atom[count].attr=attr;
-               moldyn->atom[count].bnum=bnum;
-               check_per_bound(moldyn,&(moldyn->atom[count].r));
+       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));
        }
 
        return ret;
@@ -371,7 +376,7 @@ int diamond_init(int a,int b,int c,double lc,t_atom *atom,t_3dvec *origin) {
        return count;
 }
 
-int add_atom(t_moldyn *moldyn,int element,double mass,u8 bnum,u8 attr,
+int add_atom(t_moldyn *moldyn,int element,double mass,u8 brand,u8 attr,
              t_3dvec *r,t_3dvec *v) {
 
        t_atom *atom;
@@ -379,9 +384,9 @@ int add_atom(t_moldyn *moldyn,int element,double mass,u8 bnum,u8 attr,
        int count;
        
        atom=moldyn->atom;
-       count=++(moldyn->count);
+       count=(moldyn->count)++;
 
-       ptr=realloc(atom,count*sizeof(t_atom));
+       ptr=realloc(atom,(count+1)*sizeof(t_atom));
        if(!ptr) {
                perror("[moldyn] realloc (add atom)");
                return -1;
@@ -389,12 +394,13 @@ int add_atom(t_moldyn *moldyn,int element,double mass,u8 bnum,u8 attr,
        moldyn->atom=ptr;
 
        atom=moldyn->atom;
-       atom[count-1].r=*r;
-       atom[count-1].v=*v;
-       atom[count-1].element=element;
-       atom[count-1].mass=mass;
-       atom[count-1].bnum=bnum;
-       atom[count-1].attr=attr;
+       atom[count].r=*r;
+       atom[count].v=*v;
+       atom[count].element=element;
+       atom[count].mass=mass;
+       atom[count].brand=brand;
+       atom[count].tag=count;
+       atom[count].attr=attr;
 
        return 0;
 }
@@ -513,7 +519,8 @@ int scale_volume(t_moldyn *moldyn) {
 
        t_atom *atom;
        t_3dvec *dim,*vdim;
-       double virial,scale;
+       double scale,v;
+       t_virial virial;
        t_linkcell *lc;
        int i;
 
@@ -522,12 +529,23 @@ int scale_volume(t_moldyn *moldyn) {
        vdim=&(moldyn->vis.dim);
        lc=&(moldyn->lc);
 
-       for(i=0;i<moldyn->count;i++)
-               virial+=v3_norm(&(atom[i].virial));
+       memset(&virial,0,sizeof(t_virial));
+
+       for(i=0;i<moldyn->count;i++) {
+               virial.xx+=atom[i].virial.xx;
+               virial.yy+=atom[i].virial.yy;
+               virial.zz+=atom[i].virial.zz;
+               virial.xy+=atom[i].virial.xy;
+               virial.xz+=atom[i].virial.xz;
+               virial.yz+=atom[i].virial.yz;
+       }
+
+       /* just a guess so far ... */
+       v=sqrt(virial.xx*virial.xx+virial.yy*virial.yy+virial.zz+virial.zz);
 
-printf("%f\n",virial);
+printf("%f\n",v);
        /* get pressure from virial */
-       moldyn->p=moldyn->count*K_BOLTZMANN*moldyn->t-ONE_THIRD*virial;
+       moldyn->p=moldyn->count*K_BOLTZMANN*moldyn->t-ONE_THIRD*v;
        moldyn->p/=moldyn->volume;
 printf("%f\n",moldyn->p/(ATM));
 
@@ -761,23 +779,23 @@ int moldyn_add_schedule(t_moldyn *moldyn,int runs,double tau) {
        t_moldyn_schedule *schedule;
 
        schedule=&(moldyn->schedule);
-       count=++(schedule->content_count);
+       count=++(schedule->total_sched);
 
-       ptr=realloc(moldyn->schedule.runs,count*sizeof(int));
+       ptr=realloc(schedule->runs,count*sizeof(int));
        if(!ptr) {
                perror("[moldyn] realloc (runs)");
                return -1;
        }
-       moldyn->schedule.runs=ptr;
-       moldyn->schedule.runs[count-1]=runs;
+       schedule->runs=ptr;
+       schedule->runs[count-1]=runs;
 
        ptr=realloc(schedule->tau,count*sizeof(double));
        if(!ptr) {
                perror("[moldyn] realloc (tau)");
                return -1;
        }
-       moldyn->schedule.tau=ptr;
-       moldyn->schedule.tau[count-1]=tau;
+       schedule->tau=ptr;
+       schedule->tau[count-1]=tau;
 
        return 0;
 }
@@ -800,16 +818,16 @@ int moldyn_set_schedule_hook(t_moldyn *moldyn,void *hook,void *hook_params) {
 
 int moldyn_integrate(t_moldyn *moldyn) {
 
-       int i,sched;
+       int i;
        unsigned int e,m,s,v;
        t_3dvec p;
-       t_moldyn_schedule *schedule;
+       t_moldyn_schedule *sched;
        t_atom *atom;
        int fd;
        char dir[128];
        double ds;
 
-       schedule=&(moldyn->schedule);
+       sched=&(moldyn->schedule);
        atom=moldyn->atom;
 
        /* initialize linked cell method */
@@ -846,12 +864,12 @@ int moldyn_integrate(t_moldyn *moldyn) {
        moldyn->debug=0;
 
        /* executing the schedule */
-       for(sched=0;sched<moldyn->schedule.content_count;sched++) {
+       for(sched->count=0;sched->count<sched->total_sched;sched->count++) {
 
                /* setting amount of runs and finite time step size */
-               moldyn->tau=schedule->tau[sched];
+               moldyn->tau=sched->tau[sched->count];
                moldyn->tau_square=moldyn->tau*moldyn->tau;
-               moldyn->time_steps=schedule->runs[sched];
+               moldyn->time_steps=sched->runs[sched->count];
 
        /* integration according to schedule */
 
@@ -901,7 +919,7 @@ int moldyn_integrate(t_moldyn *moldyn) {
                                visual_atoms(&(moldyn->vis),moldyn->time,
                                             moldyn->atom,moldyn->count);
                                printf("\rsched: %d, steps: %d, debug: %d",
-                                      sched,i,moldyn->debug);
+                                      sched->count,i,moldyn->debug);
                                fflush(stdout);
                        }
                }
@@ -912,8 +930,8 @@ int moldyn_integrate(t_moldyn *moldyn) {
        }
 
                /* check for hooks */
-               if(schedule->hook)
-                       schedule->hook(moldyn,schedule->hook_params);
+               if(sched->hook)
+                       sched->hook(moldyn,sched->hook_params);
 
                /* get a new info line */
                printf("\n");
@@ -978,6 +996,7 @@ 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];
@@ -999,7 +1018,16 @@ int potential_force_calc(t_moldyn *moldyn) {
                v3_zero(&(itom[i].f));
 
                /* reset viral of atom i */
-               v3_zero(&(itom[i].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;
 
                /* single particle potential/force */
                if(itom[i].attr&ATOM_ATTR_1BP)
@@ -1099,6 +1127,9 @@ int potential_force_calc(t_moldyn *moldyn) {
                }
 
        }
+#ifdef DEBUG
+printf("\n\n");
+#endif
 
        return 0;
 }
@@ -1212,7 +1243,10 @@ int lennard_jones(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
 int tersoff_mult_complete_params(t_tersoff_mult_params *p) {
 
        printf("[moldyn] tersoff parameter completion\n");
+       p->S2[0]=p->S[0]*p->S[0];
+       p->S2[1]=p->S[1]*p->S[1];
        p->Smixed=sqrt(p->S[0]*p->S[1]);
+       p->S2mixed=p->Smixed*p->Smixed;
        p->Rmixed=sqrt(p->R[0]*p->R[1]);
        p->Amixed=sqrt(p->A[0]*p->A[1]);
        p->Bmixed=sqrt(p->B[0]*p->B[1]);
@@ -1240,11 +1274,11 @@ int tersoff_mult_complete_params(t_tersoff_mult_params *p) {
 /* tersoff 1 body part */
 int tersoff_mult_1bp(t_moldyn *moldyn,t_atom *ai) {
 
-       int num;
+       int brand;
        t_tersoff_mult_params *params;
        t_tersoff_exchange *exchange;
        
-       num=ai->bnum;
+       brand=ai->brand;
        params=moldyn->pot1b_params;
        exchange=&(params->exchange);
 
@@ -1253,15 +1287,15 @@ int tersoff_mult_1bp(t_moldyn *moldyn,t_atom *ai) {
         *         their right values
         */
 
-       exchange->beta_i=&(params->beta[num]);
-       exchange->n_i=&(params->n[num]);
-       exchange->c_i=&(params->c[num]);
-       exchange->d_i=&(params->d[num]);
-       exchange->h_i=&(params->h[num]);
+       exchange->beta_i=&(params->beta[brand]);
+       exchange->n_i=&(params->n[brand]);
+       exchange->c_i=&(params->c[brand]);
+       exchange->d_i=&(params->d[brand]);
+       exchange->h_i=&(params->h[brand]);
 
        exchange->betaini=pow(*(exchange->beta_i),*(exchange->n_i));
-       exchange->ci2=params->c[num]*params->c[num];
-       exchange->di2=params->d[num]*params->d[num];
+       exchange->ci2=params->c[brand]*params->c[brand];
+       exchange->di2=params->d[brand]*params->d[brand];
        exchange->ci2di2=exchange->ci2/exchange->di2;
 
        return 0;
@@ -1273,16 +1307,16 @@ int tersoff_mult_2bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
        t_tersoff_mult_params *params;
        t_tersoff_exchange *exchange;
        t_3dvec dist_ij,force;
-       double d_ij;
-       double A,B,R,S,lambda,mu;
+       double d_ij,d_ij2;
+       double A,B,R,S,S2,lambda,mu;
        double f_r,df_r;
        double f_c,df_c;
-       int num;
+       int brand;
        double s_r;
        double arg;
 
        params=moldyn->pot2b_params;
-       num=aj->bnum;
+       brand=aj->brand;
        exchange=&(params->exchange);
 
        /* clear 3bp and 2bp post run */
@@ -1305,27 +1339,20 @@ int tersoff_mult_2bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
         *
         */
 
-       /* dist_ij, d_ij */
-       v3_sub(&dist_ij,&(aj->r),&(ai->r));
-       if(bc) check_per_bound(moldyn,&dist_ij);
-       d_ij=v3_norm(&dist_ij);
-
-       /* save for use in 3bp */
-       exchange->d_ij=d_ij;
-       exchange->dist_ij=dist_ij;
-
        /* constants */
-       if(num==ai->bnum) {
-               S=params->S[num];
-               R=params->R[num];
-               A=params->A[num];
-               B=params->B[num];
-               lambda=params->lambda[num];
-               mu=params->mu[num];
+       if(brand==ai->brand) {
+               S=params->S[brand];
+               S2=params->S2[brand];
+               R=params->R[brand];
+               A=params->A[brand];
+               B=params->B[brand];
+               lambda=params->lambda[brand];
+               mu=params->mu[brand];
                exchange->chi=1.0;
        }
        else {
                S=params->Smixed;
+               S2=params->S2mixed;
                R=params->Rmixed;
                A=params->Amixed;
                B=params->Bmixed;
@@ -1334,17 +1361,30 @@ int tersoff_mult_2bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
                params->exchange.chi=params->chi;
        }
 
-       /* if d_ij > S => no force & potential energy contribution */
-       if(d_ij>S)
+       /* dist_ij, d_ij */
+       v3_sub(&dist_ij,&(aj->r),&(ai->r));
+       if(bc) check_per_bound(moldyn,&dist_ij);
+       d_ij2=v3_absolute_square(&dist_ij);
+
+       /* if d_ij2 > S2 => no force & potential energy contribution */
+       if(d_ij2>S2)
                return 0;
 
+       /* now we will need the distance */
+       //d_ij=v3_norm(&dist_ij);
+       d_ij=sqrt(d_ij2);
+
+       /* save for use in 3bp */
+       exchange->d_ij=d_ij;
+       exchange->dist_ij=dist_ij;
+
        /* more constants */
-       exchange->beta_j=&(params->beta[num]);
-       exchange->n_j=&(params->n[num]);
-       exchange->c_j=&(params->c[num]);
-       exchange->d_j=&(params->d[num]);
-       exchange->h_j=&(params->h[num]);
-       if(num==ai->bnum) {
+       exchange->beta_j=&(params->beta[brand]);
+       exchange->n_j=&(params->n[brand]);
+       exchange->c_j=&(params->c[brand]);
+       exchange->d_j=&(params->d[brand]);
+       exchange->h_j=&(params->h[brand]);
+       if(brand==ai->brand) {
                exchange->betajnj=exchange->betaini;
                exchange->cj2=exchange->ci2;
                exchange->dj2=exchange->di2;
@@ -1352,8 +1392,8 @@ int tersoff_mult_2bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
        }
        else {
                exchange->betajnj=pow(*(exchange->beta_j),*(exchange->n_j));
-               exchange->cj2=params->c[num]*params->c[num];
-               exchange->dj2=params->d[num]*params->d[num];
+               exchange->cj2=params->c[brand]*params->c[brand];
+               exchange->dj2=params->d[brand]*params->d[brand];
                exchange->cj2dj2=exchange->cj2/exchange->dj2;
        }
 
@@ -1377,7 +1417,6 @@ int tersoff_mult_2bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
                s_r=S-R;
                arg=M_PI*(d_ij-R)/s_r;
                f_c=0.5+0.5*cos(arg);
-               //df_c=-0.5*sin(arg)*(M_PI/(s_r*d_ij)); /* MARK! */
                df_c=0.5*sin(arg)*(M_PI/(s_r*d_ij));
                /* two body contribution (ij, ji) */
                v3_scale(&force,&dist_ij,-df_c*f_r-df_r*f_c);
@@ -1388,6 +1427,14 @@ int tersoff_mult_2bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
        /* add forces of 2bp (ij, ji) contribution
         * dVij = dVji and we sum up both: no 1/2) */
        v3_add(&(ai->f),&(ai->f),&force);
+#ifdef DEBUG
+if(ai==&(moldyn->atom[0])) {
+       printf("dVij, dVji (2bp) contrib:\n");
+       printf("%f | %f\n",force.x,ai->f.x);
+       printf("%f | %f\n",force.y,ai->f.y);
+       printf("%f | %f\n",force.z,ai->f.z);
+}
+#endif
 
        /* energy 2bp contribution (ij, ji) is 0.5 f_r f_c ... */
        moldyn->energy+=(0.5*f_r*f_c);
@@ -1479,6 +1526,14 @@ int tersoff_mult_post_2bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
 
        /* add force */
        v3_add(&(ai->f),&(ai->f),&force);
+#ifdef DEBUG
+if(ai==&(moldyn->atom[0])) {
+       printf("dVij (3bp) contrib:\n");
+       printf("%f | %f\n",force.x,ai->f.x);
+       printf("%f | %f\n",force.y,ai->f.y);
+       printf("%f | %f\n",force.z,ai->f.z);
+}
+#endif
 
        /* add energy of 3bp sum */
        moldyn->energy+=(0.5*f_c*b*f_a);
@@ -1507,6 +1562,14 @@ int tersoff_mult_post_2bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
 
        /* add force */
        v3_add(&(ai->f),&(ai->f),&force);
+#ifdef DEBUG
+if(ai==&(moldyn->atom[0])) {
+       printf("dVji (3bp) contrib:\n");
+       printf("%f | %f\n",force.x,ai->f.x);
+       printf("%f | %f\n",force.y,ai->f.y);
+       printf("%f | %f\n",force.z,ai->f.z);
+}
+#endif
 
        return 0;
 }
@@ -1533,7 +1596,7 @@ int tersoff_mult_3bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,t_atom *ak,u8 bc) {
        double h_cos,d2_h_cos2;
        double frac,g,zeta,chi;
        double tmp;
-       int num;
+       int brand;
 
        params=moldyn->pot3b_params;
        exchange=&(params->exchange);
@@ -1585,10 +1648,10 @@ int tersoff_mult_3bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,t_atom *ak,u8 bc) {
        d_ik=v3_norm(&dist_ik);
 
        /* ik constants */
-       num=ai->bnum;
-       if(num==ak->bnum) {
-               R=params->R[num];
-               S=params->S[num];
+       brand=ai->brand;
+       if(brand==ak->brand) {
+               R=params->R[brand];
+               S=params->S[brand];
        }
        else {
                R=params->Rmixed;
@@ -1649,7 +1712,6 @@ int tersoff_mult_3bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,t_atom *ak,u8 bc) {
                        s_r=S-R;
                        arg=M_PI*(d_ik-R)/s_r;
                        f_c_ik=0.5+0.5*cos(arg);
-                       //df_c_ik=-0.5*sin(arg)*(M_PI/(s_r*d_ik)); /* MARK */
                        df_c_ik=0.5*sin(arg)*(M_PI/(s_r*d_ik));
 
                        /* zeta_ij */
@@ -1671,12 +1733,12 @@ int tersoff_mult_3bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,t_atom *ak,u8 bc) {
        d_jk=v3_norm(&dist_jk);
 
        /* jk constants */
-       num=aj->bnum;
-       if(num==ak->bnum) {
-               R=params->R[num];
-               S=params->S[num];
-               B=params->B[num];
-               mu=params->mu[num];
+       brand=aj->brand;
+       if(brand==ak->brand) {
+               R=params->R[brand];
+               S=params->S[brand];
+               B=params->B[brand];
+               mu=params->mu[brand];
                chi=1.0;
        }
        else {
@@ -1768,6 +1830,14 @@ int tersoff_mult_3bp(t_moldyn *moldyn,t_atom *ai,t_atom *aj,t_atom *ak,u8 bc) {
                v3_scale(&temp2,&temp2,tmp*B*exp(-mu*d_jk)*f_c_jk*0.5);
                v3_add(&(ai->f),&(ai->f),&temp2); /* -1 skipped in f_a calc ^ */
                                                  /* scaled with 0.5 ^ */
+#ifdef DEBUG
+if(ai==&(moldyn->atom[0])) {
+       printf("dVjk (3bp) contrib:\n");
+       printf("%f | %f\n",temp2.x,ai->f.x);
+       printf("%f | %f\n",temp2.y,ai->f.y);
+       printf("%f | %f\n",temp2.z,ai->f.z);
+}
+#endif
 
        }
 
@@ -1784,13 +1854,13 @@ int moldyn_bc_check(t_moldyn *moldyn) {
        t_atom *atom;
        t_3dvec *dim;
        int i;
-double x;
-u8 byte;
-int j,k;
+       double x;
+       u8 byte;
+       int j,k;
 
        atom=moldyn->atom;
        dim=&(moldyn->dim);
-x=dim->x/2;
+       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) {