#include <time.h>
#include <math.h>
+#include <fpu_control.h>
+
+#ifdef PARALLEL
+#include <omp.h>
+#endif
+
#include "moldyn.h"
#include "report/report.h"
#include "potentials/tersoff.h"
#endif
-
-/*
- * global variables, pse and atom colors (only needed here)
- */
-
-static char *pse_name[]={
- "*",
- "H",
- "He",
- "Li",
- "Be",
- "B",
- "C",
- "N",
- "O",
- "F",
- "Ne",
- "Na",
- "Mg",
- "Al",
- "Si",
- "P",
- "S",
- "Cl",
- "Ar",
-};
-
-static char *pse_col[]={
- "*",
- "White",
- "He",
- "Li",
- "Be",
- "B",
- "Gray",
- "N",
- "Blue",
- "F",
- "Ne",
- "Na",
- "Mg",
- "Al",
- "Yellow",
- "P",
- "S",
- "Cl",
- "Ar",
-};
+/* pse */
+#define PSE_NAME
+#define PSE_COL
+#include "pse.h"
+#undef PSE_NAME
+#undef PSE_COL
/*
* the moldyn functions
printf("[moldyn] init\n");
+ /* only needed if compiled without -msse2 (float-store prob!) */
+ //fpu_set_rtd();
+
memset(moldyn,0,sizeof(t_moldyn));
moldyn->argc=argc;
int set_cutoff(t_moldyn *moldyn,double cutoff) {
moldyn->cutoff=cutoff;
+ moldyn->cutoff_square=cutoff*cutoff;
printf("[moldyn] cutoff [A]: %f\n",moldyn->cutoff);
return 0;
}
-int set_bondlen(t_moldyn *moldyn,double b0,double b1,double bm) {
-
- moldyn->bondlen[0]=b0*b0;
- moldyn->bondlen[1]=b1*b1;
- if(bm<0)
- moldyn->bondlen[2]=b0*b1;
- else
- moldyn->bondlen[2]=bm*bm;
-
- return 0;
-}
-
int set_temperature(t_moldyn *moldyn,double t_ref) {
moldyn->t_ref=t_ref;
return 0;
}
+int set_p_scale(t_moldyn *moldyn,u8 ptype,double ptc) {
+
+ moldyn->pt_scale&=(~(P_SCALE_MASK));
+ moldyn->pt_scale|=ptype;
+ moldyn->p_tc=ptc;
+
+ printf("[moldyn] p scaling:\n");
+
+ printf(" p: %s",ptype?"yes":"no ");
+ if(ptype)
+ printf(" | type: %02x | factor: %f",ptype,ptc);
+ printf("\n");
+
+ return 0;
+}
+
+int set_t_scale(t_moldyn *moldyn,u8 ttype,double ttc) {
+
+ moldyn->pt_scale&=(~(T_SCALE_MASK));
+ moldyn->pt_scale|=ttype;
+ moldyn->t_tc=ttc;
+
+ printf("[moldyn] t scaling:\n");
+
+ printf(" t: %s",ttype?"yes":"no ");
+ if(ttype)
+ printf(" | type: %02x | factor: %f",ttype,ttc);
+ printf("\n");
+
+ return 0;
+}
+
int set_pt_scale(t_moldyn *moldyn,u8 ptype,double ptc,u8 ttype,double ttc) {
moldyn->pt_scale=(ptype|ttype);
moldyn->func3b_k1=tersoff_mult_3bp_k1;
moldyn->func3b_j2=tersoff_mult_3bp_j2;
moldyn->func3b_k2=tersoff_mult_3bp_k2;
- // missing: check 2b bond func
+ moldyn->check_2b_bond=tersoff_mult_check_2b_bond;
break;
case MOLDYN_POTENTIAL_AM:
moldyn->func3b_j1=albe_mult_3bp_j1;
moldyn->func3b_k2=albe_mult_3bp_k2;
moldyn->check_2b_bond=albe_mult_check_2b_bond;
break;
+ case MOLDYN_POTENTIAL_HO:
+ moldyn->func2b=harmonic_oscillator;
+ moldyn->check_2b_bond=harmonic_oscillator_check_2b_bond;
+ break;
+ case MOLDYN_POTENTIAL_LJ:
+ moldyn->func2b=lennard_jones;
+ moldyn->check_2b_bond=lennard_jones_check_2b_bond;
+ break;
default:
printf("[moldyn] set potential: unknown type %02x\n",
type);
t_3dvec orig;
void *ptr;
t_atom *atom;
+ char name[16];
new=a*b*c;
count=moldyn->count;
/* how many atoms do we expect */
+ if(type==NONE) {
+ new*=1;
+ printf("[moldyn] WARNING: create 'none' lattice called");
+ }
if(type==CUBIC) new*=1;
if(type==FCC) new*=4;
if(type==DIAMOND) new*=8;
case CUBIC:
set_nn_dist(moldyn,lc);
ret=cubic_init(a,b,c,lc,atom,&orig);
+ strcpy(name,"cubic");
break;
case FCC:
if(!origin)
v3_scale(&orig,&orig,0.5);
set_nn_dist(moldyn,0.5*sqrt(2.0)*lc);
ret=fcc_init(a,b,c,lc,atom,&orig);
+ strcpy(name,"fcc");
break;
case DIAMOND:
if(!origin)
v3_scale(&orig,&orig,0.25);
set_nn_dist(moldyn,0.25*sqrt(3.0)*lc);
ret=diamond_init(a,b,c,lc,atom,&orig);
+ strcpy(name,"diamond");
break;
default:
printf("unknown lattice type (%02x)\n",type);
}
moldyn->count+=new;
- printf("[moldyn] created lattice with %d atoms\n",new);
+ printf("[moldyn] created %s lattice with %d atoms\n",name,new);
for(ret=0;ret<new;ret++) {
atom[ret].element=element;
}
moldyn->atom=ptr;
+#ifdef LOWMEM_LISTS
+ ptr=realloc(moldyn->lc.subcell->list,(count+1)*sizeof(int));
+ if(!ptr) {
+ perror("[moldyn] list realloc (add atom)");
+ return -1;
+ }
+ moldyn->lc.subcell->list=ptr;
+#endif
+
atom=moldyn->atom;
/* initialize new atom */
scale*=2.0;
else
if(moldyn->pt_scale&T_SCALE_BERENDSEN)
- scale=1.0+(scale-1.0)/moldyn->t_tc;
+ scale=1.0+(scale-1.0)*moldyn->tau/moldyn->t_tc;
scale=sqrt(scale);
/* velocity scaling */
/* scaling factor */
if(moldyn->pt_scale&P_SCALE_BERENDSEN) {
- scale=1.0-(moldyn->p_ref-moldyn->p)*moldyn->p_tc;
+ scale=1.0-(moldyn->p_ref-moldyn->p)*moldyn->p_tc*moldyn->tau;
scale=pow(scale,ONE_THIRD);
}
else {
int link_cell_init(t_moldyn *moldyn,u8 vol) {
t_linkcell *lc;
+#ifndef LOWMEM_LISTS
int i;
+#endif
lc=&(moldyn->lc);
#ifdef STATIC_LISTS
lc->subcell=malloc(lc->cells*sizeof(int*));
+#elif LOWMEM_LISTS
+ lc->subcell=malloc(sizeof(t_lowmem_list));
#else
lc->subcell=malloc(lc->cells*sizeof(t_list));
#endif
}
if(lc->cells<27)
- printf("[moldyn] FATAL: less then 27 subcells!\n");
+ printf("[moldyn] FATAL: less then 27 subcells! (%d)\n",
+ lc->cells);
if(vol) {
#ifdef STATIC_LISTS
printf("[moldyn] initializing 'static' linked cells (%d)\n",
lc->cells);
+#elif LOWMEM_LISTS
+ printf("[moldyn] initializing 'lowmem' linked cells (%d)\n",
+ lc->cells);
#else
printf("[moldyn] initializing 'dynamic' linked cells (%d)\n",
lc->cells);
i,lc->subcell[0],lc->subcell);
*/
}
+#elif LOWMEM_LISTS
+ lc->subcell->head=malloc(lc->cells*sizeof(int));
+ if(lc->subcell->head==NULL) {
+ perror("[moldyn] head init (malloc)");
+ return -1;
+ }
+ lc->subcell->list=malloc(moldyn->count*sizeof(int));
+ if(lc->subcell->list==NULL) {
+ perror("[moldyn] list init (malloc)");
+ return -1;
+ }
#else
for(i=0;i<lc->cells;i++)
list_init_f(&(lc->subcell[i]));
int link_cell_update(t_moldyn *moldyn) {
int count,i,j,k;
- int nx,ny;
+ int nx,nxy;
t_atom *atom;
t_linkcell *lc;
#ifdef STATIC_LISTS
int p;
+#elif LOWMEM_LISTS
+ int p;
#endif
atom=moldyn->atom;
lc=&(moldyn->lc);
nx=lc->nx;
- ny=lc->ny;
+ nxy=nx*lc->ny;
for(i=0;i<lc->cells;i++)
#ifdef STATIC_LISTS
- memset(lc->subcell[i],0,(MAX_ATOMS_PER_LIST+1)*sizeof(int));
+ memset(lc->subcell[i],-1,(MAX_ATOMS_PER_LIST+1)*sizeof(int));
+#elif LOWMEM_LISTS
+ lc->subcell->head[i]=-1;
#else
list_destroy_f(&(lc->subcell[i]));
#endif
#ifdef STATIC_LISTS
p=0;
- while(lc->subcell[i+j*nx+k*nx*ny][p]!=0)
+ while(lc->subcell[i+j*nx+k*nxy][p]!=-1)
p++;
if(p>=MAX_ATOMS_PER_LIST) {
return -1;
}
- lc->subcell[i+j*nx+k*nx*ny][p]=count;
+ lc->subcell[i+j*nx+k*nxy][p]=count;
+#elif LOWMEM_LISTS
+ p=i+j*nx+k*nxy;
+ lc->subcell->list[count]=lc->subcell->head[p];
+ lc->subcell->head[p]=count;
#else
- list_add_immediate_f(&(lc->subcell[i+j*nx+k*nx*ny]),
+ list_add_immediate_f(&(lc->subcell[i+j*nx+k*nxy]),
&(atom[count]));
/*
if(j==0&&k==0)
int link_cell_neighbour_index(t_moldyn *moldyn,int i,int j,int k,
#ifdef STATIC_LISTS
int **cell
+#elif LOWMEM_LISTS
+ int *cell
#else
t_list *cell
#endif
printf("[moldyn] WARNING: lcni %d/%d %d/%d %d/%d\n",
i,nx,j,ny,k,nz);
+#ifndef LOWMEM_LISTS
cell[0]=lc->subcell[i+j*nx+k*a];
+#else
+ cell[0]=lc->subcell->head[i+j*nx+k*a];
+#endif
for(ci=-1;ci<=1;ci++) {
bx=0;
x=i+ci;
}
if(!(ci|cj|ck)) continue;
if(bx|by|bz) {
+#ifndef LOWMEM_LISTS
cell[--count2]=lc->subcell[x+y*nx+z*a];
+#else
+ cell[--count2]=lc->subcell->head[x+y*nx+z*a];
+#endif
+
}
else {
+#ifndef LOWMEM_LISTS
cell[count1++]=lc->subcell[x+y*nx+z*a];
+#else
+ cell[count1++]=lc->subcell->head[x+y*nx+z*a];
+#endif
}
}
}
int link_cell_shutdown(t_moldyn *moldyn) {
+#ifndef LOWMEM_LISTS
int i;
+#endif
t_linkcell *lc;
lc=&(moldyn->lc);
+#if LOWMEM_LISTS
+ free(lc->subcell->head);
+ free(lc->subcell->list);
+
+#else
+
for(i=0;i<lc->cells;i++) {
#ifdef STATIC_LISTS
free(lc->subcell[i]);
list_destroy_f(&(lc->subcell[i]));
#endif
}
+#endif
free(lc->subcell);
/* sqaure of some variables */
moldyn->tau_square=moldyn->tau*moldyn->tau;
- moldyn->cutoff_square=moldyn->cutoff*moldyn->cutoff;
/* get current time */
gettimeofday(&t1,NULL);
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)
+ if(moldyn->count) {
+ 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;
+ // should have right values!
+ //moldyn->time=0.0;
+ //moldyn->total_steps=0;
/* debugging, ignore */
moldyn->debug=0;
temperature_calc(moldyn);
virial_sum(moldyn);
pressure_calc(moldyn);
- //thermodynamic_pressure_calc(moldyn);
+ /*
+ thermodynamic_pressure_calc(moldyn);
+ printf("\n\nDEBUG: numeric pressure calc: %f\n\n",
+ moldyn->tp/BAR);
+ */
/* calculate fluctuations + averages */
average_and_fluctuation_calc(moldyn);
sched->count,i,moldyn->total_steps,
moldyn->t,moldyn->t_avg,
moldyn->p/BAR,moldyn->p_avg/BAR,
+ //moldyn->p/BAR,(moldyn->p-2.0*moldyn->ekin/(3.0*moldyn->volume))/BAR,
moldyn->volume,
(int)(t2.tv_sec-t1.tv_sec));
link_cell_update(moldyn);
/* forces depending on chosen potential */
+#ifndef ALBE_FAST
potential_force_calc(moldyn);
+#else
+ albe_potential_force_calc(moldyn);
+#endif
for(i=0;i<count;i++) {
/* check whether fixed atom */
int *neighbour_i[27];
int p,q;
t_atom *atom;
+#elif LOWMEM_LISTS
+ int neighbour_i[27];
+ int p,q;
#else
t_list neighbour_i[27];
t_list neighbour_i2[27];
memset(&(moldyn->gvir),0,sizeof(t_virial));
/* reset force, site energy and virial of every atom */
+#ifdef PARALLEL
+ i=omp_get_thread_num();
+ #pragma omp parallel for private(virial)
+#endif
for(i=0;i<count;i++) {
/* reset force */
#ifdef STATIC_LISTS
p=0;
- while(neighbour_i[j][p]!=0) {
+ while(neighbour_i[j][p]!=-1) {
jtom=&(atom[neighbour_i[j][p]]);
p++;
+#elif LOWMEM_LISTS
+ p=neighbour_i[j];
- if(jtom==&(itom[i]))
- continue;
+ while(p!=-1) {
- if((jtom->attr&ATOM_ATTR_2BP)&
- (itom[i].attr&ATOM_ATTR_2BP)) {
- moldyn->func2b(moldyn,
- &(itom[i]),
- jtom,
- bc_ij);
- }
- }
+ jtom=&(itom[p]);
+ p=lc->subcell->list[p];
#else
this=&(neighbour_i[j]);
list_reset_f(this);
do {
jtom=this->current->data;
+#endif
if(jtom==&(itom[i]))
continue;
jtom,
bc_ij);
}
+#ifdef STATIC_LISTS
+ }
+#elif LOWMEM_LISTS
+ }
+#else
} while(list_next_f(this)!=L_NO_NEXT_ELEMENT);
#endif
/* copy the neighbour lists */
#ifdef STATIC_LISTS
/* no copy needed for static lists */
+#elif LOWMEM_LISTS
+ /* no copy needed for lowmem lists */
#else
memcpy(neighbour_i2,neighbour_i,27*sizeof(t_list));
#endif
#ifdef STATIC_LISTS
p=0;
- while(neighbour_i[j][p]!=0) {
+ while(neighbour_i[j][p]!=-1) {
jtom=&(atom[neighbour_i[j][p]]);
p++;
+#elif LOWMEM_LISTS
+ p=neighbour_i[j];
+
+ while(p!=-1) {
+
+ jtom=&(itom[p]);
+ p=lc->subcell->list[p];
#else
this=&(neighbour_i[j]);
list_reset_f(this);
#ifdef STATIC_LISTS
q=0;
- while(neighbour_i[j][q]!=0) {
+ while(neighbour_i[k][q]!=-1) {
ktom=&(atom[neighbour_i[k][q]]);
q++;
+#elif LOWMEM_LISTS
+ q=neighbour_i[k];
+
+ while(q!=-1) {
+
+ ktom=&(itom[q]);
+ q=lc->subcell->list[q];
#else
that=&(neighbour_i2[k]);
list_reset_f(that);
bc_ik|bc_ij);
#ifdef STATIC_LISTS
}
+#elif LOWMEM_LISTS
+ }
#else
} while(list_next_f(that)!=\
L_NO_NEXT_ELEMENT);
#ifdef STATIC_LISTS
q=0;
- while(neighbour_i[j][q]!=0) {
+ while(neighbour_i[k][q]!=-1) {
ktom=&(atom[neighbour_i[k][q]]);
q++;
+#elif LOWMEM_LISTS
+ q=neighbour_i[k];
+
+ while(q!=-1) {
+
+ ktom=&(itom[q]);
+ q=lc->subcell->list[q];
#else
that=&(neighbour_i2[k]);
list_reset_f(that);
#ifdef STATIC_LISTS
}
+#elif LOWMEM_LISTS
+ }
#else
} while(list_next_f(that)!=\
L_NO_NEXT_ELEMENT);
}
#ifdef STATIC_LISTS
}
+#elif LOWMEM_LISTS
+ }
#else
} while(list_next_f(this)!=L_NO_NEXT_ELEMENT);
#endif
#endif
/* some postprocessing */
+#ifdef PARALLEL
+ #pragma omp parallel for
+#endif
for(i=0;i<count;i++) {
/* calculate global virial */
moldyn->gvir.xx+=itom[i].r.x*itom[i].f.x;
/* check forces regarding the given timestep */
if(v3_norm(&(itom[i].f))>\
- 0.1*moldyn->nnd*itom[i].mass/moldyn->tau_square)
+ 0.1*moldyn->nnd*itom[i].mass/moldyn->tau_square)
printf("[moldyn] WARNING: pfc (high force: atom %d)\n",
i);
}
#ifdef STATIC_LISTS
int *neighbour[27];
int p;
+#elif LOWMEM_LISTS
+ int neighbour[27];
+ int p;
#else
t_list neighbour[27];
+ t_list *this;
#endif
u8 bc;
t_atom *itom,*jtom;
int i,j;
- t_list *this;
lc=&(moldyn->lc);
-
- link_cell_init(moldyn,VERBOSE);
-
itom=moldyn->atom;
for(i=0;i<moldyn->count;i++) {
#ifdef STATIC_LISTS
p=0;
- while(neighbour[j][p]!=0) {
+ while(neighbour[j][p]!=-1) {
jtom=&(moldyn->atom[neighbour[j][p]]);
p++;
+#elif LOWMEM_LISTS
+ p=neighbour[j];
+
+ while(p!=-1) {
+
+ jtom=&(itom[p]);
+ p=lc->subcell->list[p];
#else
this=&(neighbour[j]);
list_reset_f(this);
#ifdef STATIC_LISTS
}
+#elif LOWMEM_LISTS
+ }
#else
} while(list_next_f(this)!=L_NO_NEXT_ELEMENT);
#endif
ret=read(fd,line+count,1);
if(ret<=0) return ret;
if(line[count]=='\n') {
- line[count]='\0';
+ memset(line+count,0,max-count-1);
+ //line[count]='\0';
return count+1;
}
count+=1;
if(moldyn->check_2b_bond(moldyn,itom,jtom,bc)==FALSE)
return 0;
- d=sqrt(d);
-
/* now count this bonding ... */
ba=data;
return 0;
}
+int visual_bonds_process(t_moldyn *moldyn,t_atom *itom,t_atom *jtom,
+ void *data,u8 bc) {
+
+ t_vb *vb;
+
+ vb=data;
+
+ if(itom->tag>=jtom->tag)
+ return 0;
+
+ if(moldyn->check_2b_bond(moldyn,itom,jtom,bc)==FALSE)
+ return 0;
+
+ if((itom->attr&ATOM_ATTR_VB)|(jtom->attr&ATOM_ATTR_VB))
+ dprintf(vb->fd,"# [B] %f %f %f %f %f %f\n",
+ itom->r.x,itom->r.y,itom->r.z,
+ jtom->r.x,jtom->r.y,jtom->r.z);
+
+ return 0;
+}
+
int visual_atoms(t_moldyn *moldyn) {
- int i,j,fd;
+ int i;
char file[128+64];
t_3dvec dim;
double help;
t_visual *v;
t_atom *atom;
- t_atom *btom;
- t_linkcell *lc;
-#ifdef STATIC_LISTS
- int *neighbour[27];
- int p;
-#else
- t_list neighbour[27];
-#endif
- u8 bc;
- t_3dvec dist;
- double d2;
- u8 brand;
+ t_vb vb;
v=&(moldyn->vis);
dim.x=v->dim.x;
dim.y=v->dim.y;
dim.z=v->dim.z;
atom=moldyn->atom;
- lc=&(moldyn->lc);
help=(dim.x+dim.y);
sprintf(file,"%s/atomic_conf_%07.f.xyz",v->fb,moldyn->time);
- fd=open(file,O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR);
- if(fd<0) {
+ vb.fd=open(file,O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR);
+ if(vb.fd<0) {
perror("open visual save file fd");
return -1;
}
/* write the actual data file */
// povray header
- dprintf(fd,"# [P] %d %07.f <%f,%f,%f>\n",
+ dprintf(vb.fd,"# [P] %d %07.f <%f,%f,%f>\n",
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++)
// atom type, positions, color and kinetic energy
- dprintf(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);
-
- /*
- * bond detection should usually be done by potential
- * functions. brrrrr! EVIL!
- *
- * todo: potentials need to export a 'find_bonds' function!
- */
-
- // bonds between atoms
- if(!(atom[i].attr&ATOM_ATTR_VB))
- continue;
- link_cell_neighbour_index(moldyn,
- (atom[i].r.x+moldyn->dim.x/2)/lc->x,
- (atom[i].r.y+moldyn->dim.y/2)/lc->y,
- (atom[i].r.z+moldyn->dim.z/2)/lc->z,
- neighbour);
- for(j=0;j<27;j++) {
- bc=j<lc->dnlc?0:1;
-#ifdef STATIC_LISTS
- p=0;
- while(neighbour[j][p]!=0) {
- btom=&(atom[neighbour[j][p]]);
- p++;
-#else
- list_reset_f(&neighbour[j]);
- if(neighbour[j].start==NULL)
- continue;
- do {
- btom=neighbour[j].current->data;
-#endif
- if(btom==&atom[i]) // skip identical atoms
- continue;
- //if(btom<&atom[i]) // skip half of them
- // continue;
- v3_sub(&dist,&(atom[i].r),&(btom->r));
- if(bc) check_per_bound(moldyn,&dist);
- d2=v3_absolute_square(&dist);
- brand=atom[i].brand;
- if(brand==btom->brand) {
- if(d2>moldyn->bondlen[brand])
- continue;
- }
- else {
- if(d2>moldyn->bondlen[2])
- continue;
- }
- dprintf(fd,"# [B] %f %f %f %f %f %f\n",
- atom[i].r.x,atom[i].r.y,atom[i].r.z,
- btom->r.x,btom->r.y,btom->r.z);
-#ifdef STATIC_LISTS
- }
-#else
- } while(list_next_f(&neighbour[j])!=L_NO_NEXT_ELEMENT);
-#endif
- }
- }
-
+ 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);
+
+ // bonds between atoms
+ process_2b_bonds(moldyn,&vb,visual_bonds_process);
+
// boundaries
if(dim.x) {
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
-dim.x/2,-dim.y/2,-dim.z/2,
dim.x/2,-dim.y/2,-dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
-dim.x/2,-dim.y/2,-dim.z/2,
-dim.x/2,dim.y/2,-dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
dim.x/2,dim.y/2,-dim.z/2,
dim.x/2,-dim.y/2,-dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
-dim.x/2,dim.y/2,-dim.z/2,
dim.x/2,dim.y/2,-dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
-dim.x/2,-dim.y/2,dim.z/2,
dim.x/2,-dim.y/2,dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
-dim.x/2,-dim.y/2,dim.z/2,
-dim.x/2,dim.y/2,dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
dim.x/2,dim.y/2,dim.z/2,
dim.x/2,-dim.y/2,dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
-dim.x/2,dim.y/2,dim.z/2,
dim.x/2,dim.y/2,dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
-dim.x/2,-dim.y/2,dim.z/2,
-dim.x/2,-dim.y/2,-dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
-dim.x/2,dim.y/2,dim.z/2,
-dim.x/2,dim.y/2,-dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
dim.x/2,-dim.y/2,dim.z/2,
dim.x/2,-dim.y/2,-dim.z/2);
- dprintf(fd,"# [D] %f %f %f %f %f %f\n",
+ dprintf(vb.fd,"# [D] %f %f %f %f %f %f\n",
dim.x/2,dim.y/2,dim.z/2,
dim.x/2,dim.y/2,-dim.z/2);
}
- close(fd);
+ close(vb.fd);
+
+ return 0;
+}
+
+/*
+ * fpu cntrol functions
+ */
+
+// set rounding to double (eliminates -ffloat-store!)
+int fpu_set_rtd(void) {
+
+ fpu_control_t ctrl;
+
+ _FPU_GETCW(ctrl);
+
+ ctrl&=~_FPU_EXTENDED;
+ ctrl|=_FPU_DOUBLE;
+
+ _FPU_SETCW(ctrl);
return 0;
}