X-Git-Url: https://hackdaworld.org/gitweb/?a=blobdiff_plain;f=moldyn.c;h=edda007d9290ff6cfe1001d4105c3f8a9ab12863;hb=e1080fc0dd66b0cf5b7715c5e99e7a34ac04a8cf;hp=e961ca23b45316fbf15b664b889e70dd1f9976bc;hpb=9f9a3d935831d0eefa1b67f94510c2956a78aed4;p=physik%2Fposic.git diff --git a/moldyn.c b/moldyn.c index e961ca2..edda007 100644 --- a/moldyn.c +++ b/moldyn.c @@ -13,11 +13,65 @@ #include #include #include +#include +#include #include #include "moldyn.h" #include "report/report.h" +/* + * 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", +}; + +/* + * the moldyn functions + */ + int moldyn_init(t_moldyn *moldyn,int argc,char **argv) { printf("[moldyn] init\n"); @@ -72,6 +126,18 @@ int set_cutoff(t_moldyn *moldyn,double 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; @@ -310,7 +376,7 @@ int moldyn_set_log(t_moldyn *moldyn,u8 type,int timer) { break; case VISUAL_STEP: moldyn->vwrite=timer; - ret=visual_init(&(moldyn->vis),moldyn->vlsdir); + ret=visual_init(moldyn,moldyn->vlsdir); if(ret<0) { printf("[moldyn] visual init failure\n"); return ret; @@ -425,7 +491,6 @@ int moldyn_log_shutdown(t_moldyn *moldyn) { moldyn->vlsdir); system(sc); } - if(&(moldyn->vis)) visual_tini(&(moldyn->vis)); return 0; } @@ -556,6 +621,35 @@ int add_atom(t_moldyn *moldyn,int element,double mass,u8 brand,u8 attr, return 0; } +int del_atom(t_moldyn *moldyn,int tag) { + + t_atom *new,*old; + int cnt; + + old=moldyn->atom; + + new=(t_atom *)malloc((moldyn->count-1)*sizeof(t_atom)); + if(!new) { + perror("[moldyn]malloc (del atom)"); + return -1; + } + + for(cnt=0;cntcount;cnt++) { + new[cnt-1]=old[cnt]; + new[cnt-1].tag=cnt-1; + } + + moldyn->count-=1; + moldyn->atom=new; + + free(old); + + return 0; +} + /* cubic init */ int cubic_init(int a,int b,int c,double lc,t_atom *atom,t_3dvec *origin) { @@ -862,10 +956,12 @@ double pressure_calc(t_moldyn *moldyn) { int average_and_fluctuation_calc(t_moldyn *moldyn) { + int denom; + if(moldyn->total_stepsavg_skip) return 0; - int denom=moldyn->total_steps+1-moldyn->avg_skip; + denom=moldyn->total_steps+1-moldyn->avg_skip; /* assume up to date energies, temperature, pressure etc */ @@ -937,7 +1033,8 @@ printf(" --> sim: %f experimental: %f\n",moldyn->dv2_avg,1.5*moldyn->coun double thermodynamic_pressure_calc(t_moldyn *moldyn) { - t_3dvec dim,*tp; + t_3dvec dim; + //t_3dvec *tp; double u_up,u_down,dv; double scale,p; t_atom *store; @@ -1164,25 +1261,57 @@ int link_cell_init(t_moldyn *moldyn,u8 vol) { lc->y=moldyn->dim.y/lc->ny; lc->nz=moldyn->dim.z/moldyn->cutoff; lc->z=moldyn->dim.z/lc->nz; - lc->cells=lc->nx*lc->ny*lc->nz; + +#ifdef STATIC_LISTS + lc->subcell=malloc(lc->cells*sizeof(int*)); +#else lc->subcell=malloc(lc->cells*sizeof(t_list)); +#endif + + if(lc->subcell==NULL) { + perror("[moldyn] cell init (malloc)"); + return -1; + } if(lc->cells<27) printf("[moldyn] FATAL: less then 27 subcells!\n"); if(vol) { - printf("[moldyn] initializing linked cells (%d)\n",lc->cells); +#ifdef STATIC_LISTS + printf("[moldyn] initializing 'static' linked cells (%d)\n", + lc->cells); +#else + printf("[moldyn] initializing 'dynamic' linked cells (%d)\n", + lc->cells); +#endif printf(" x: %d x %f A\n",lc->nx,lc->x); printf(" y: %d x %f A\n",lc->ny,lc->y); printf(" z: %d x %f A\n",lc->nz,lc->z); } +#ifdef STATIC_LISTS + /* list init */ + for(i=0;icells;i++) { + lc->subcell[i]=malloc((MAX_ATOMS_PER_LIST+1)*sizeof(int)); + if(lc->subcell[i]==NULL) { + perror("[moldyn] list init (malloc)"); + return -1; + } + /* + if(i==0) + printf(" ---> %d malloc %p (%p)\n", + i,lc->subcell[0],lc->subcell); + */ + } +#else for(i=0;icells;i++) list_init_f(&(lc->subcell[i])); +#endif + + /* update the list */ + link_cell_update(moldyn); - link_cell_update(moldyn); - return 0; } @@ -1192,7 +1321,9 @@ int link_cell_update(t_moldyn *moldyn) { int nx,ny; t_atom *atom; t_linkcell *lc; - double x,y,z; +#ifdef STATIC_LISTS + int p; +#endif atom=moldyn->atom; lc=&(moldyn->lc); @@ -1200,25 +1331,50 @@ int link_cell_update(t_moldyn *moldyn) { nx=lc->nx; ny=lc->ny; - x=moldyn->dim.x/2; - y=moldyn->dim.y/2; - z=moldyn->dim.z/2; - for(i=0;icells;i++) +#ifdef STATIC_LISTS + memset(lc->subcell[i],0,(MAX_ATOMS_PER_LIST+1)*sizeof(int)); +#else list_destroy_f(&(lc->subcell[i])); - +#endif + for(count=0;countcount;count++) { i=((atom[count].r.x+(moldyn->dim.x/2))/lc->x); j=((atom[count].r.y+(moldyn->dim.y/2))/lc->y); k=((atom[count].r.z+(moldyn->dim.z/2))/lc->z); + +#ifdef STATIC_LISTS + p=0; + while(lc->subcell[i+j*nx+k*nx*ny][p]!=0) + p++; + + if(p>=MAX_ATOMS_PER_LIST) { + printf("[moldyn] FATAL: amount of atoms too high!\n"); + return -1; + } + + lc->subcell[i+j*nx+k*nx*ny][p]=count; +#else list_add_immediate_f(&(lc->subcell[i+j*nx+k*nx*ny]), &(atom[count])); + /* + if(j==0&&k==0) + printf(" ---> %d %d malloc %p (%p)\n", + i,count,lc->subcell[i].current,lc->subcell); + */ +#endif } return 0; } -int link_cell_neighbour_index(t_moldyn *moldyn,int i,int j,int k,t_list *cell) { +int link_cell_neighbour_index(t_moldyn *moldyn,int i,int j,int k, +#ifdef STATIC_LISTS + int **cell +#else + t_list *cell +#endif + ) { t_linkcell *lc; int a; @@ -1281,8 +1437,14 @@ int link_cell_shutdown(t_moldyn *moldyn) { lc=&(moldyn->lc); - for(i=0;inx*lc->ny*lc->nz;i++) - list_destroy_f(&(moldyn->lc.subcell[i])); + for(i=0;icells;i++) { +#ifdef STATIC_LISTS + free(lc->subcell[i]); +#else + //printf(" ---> %d free %p\n",i,lc->subcell[i].start); + list_destroy_f(&(lc->subcell[i])); +#endif + } free(lc->subcell); @@ -1348,6 +1510,7 @@ int moldyn_integrate(t_moldyn *moldyn) { char dir[128]; double ds; double energy_scale; + struct timeval t1,t2; //double tp; sched=&(moldyn->schedule); @@ -1368,13 +1531,13 @@ int moldyn_integrate(t_moldyn *moldyn) { moldyn->tau_square=moldyn->tau*moldyn->tau; moldyn->cutoff_square=moldyn->cutoff*moldyn->cutoff; - /* energy scaling factor */ - energy_scale=moldyn->count*EV; + /* get current time */ + gettimeofday(&t1,NULL); /* calculate initial forces */ potential_force_calc(moldyn); #ifdef DEBUG -return 0; +//return 0; #endif /* some stupid checks before we actually start calculating bullshit */ @@ -1407,6 +1570,9 @@ return 0; moldyn->tau_square=moldyn->tau*moldyn->tau; moldyn->time_steps=sched->runs[sched->count]; + /* energy scaling factor (might change!) */ + energy_scale=moldyn->count*EV; + /* integration according to schedule */ for(i=0;itime_steps;i++) { @@ -1429,7 +1595,7 @@ return 0; /* check for log & visualization */ if(e) { - if(!(i%e)) + if(!(moldyn->total_steps%e)) dprintf(moldyn->efd, "%f %f %f %f\n", moldyn->time,moldyn->ekin/energy_scale, @@ -1437,7 +1603,7 @@ return 0; get_total_energy(moldyn)/energy_scale); } if(m) { - if(!(i%m)) { + if(!(moldyn->total_steps%m)) { momentum=get_total_p(moldyn); dprintf(moldyn->mfd, "%f %f %f %f %f\n",moldyn->time, @@ -1446,7 +1612,7 @@ return 0; } } if(p) { - if(!(i%p)) { + if(!(moldyn->total_steps%p)) { dprintf(moldyn->pfd, "%f %f %f %f %f\n",moldyn->time, moldyn->p/BAR,moldyn->p_avg/BAR, @@ -1454,14 +1620,14 @@ return 0; } } if(t) { - if(!(i%t)) { + if(!(moldyn->total_steps%t)) { dprintf(moldyn->tfd, "%f %f %f\n", moldyn->time,moldyn->t,moldyn->t_avg); } } if(s) { - if(!(i%s)) { + if(!(moldyn->total_steps%s)) { snprintf(dir,128,"%s/s-%07.f.save", moldyn->vlsdir,moldyn->time); fd=open(dir,O_WRONLY|O_TRUNC|O_CREAT, @@ -1476,21 +1642,28 @@ return 0; } } if(v) { - if(!(i%v)) { - visual_atoms(&(moldyn->vis),moldyn->time, - moldyn->atom,moldyn->count); + if(!(moldyn->total_steps%v)) { + visual_atoms(moldyn); } } /* 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); - } + //if(!(moldyn->total_steps%10)) { + /* get current time */ + gettimeofday(&t2,NULL); + +printf("\rsched:%d, steps:%d/%d, T:%3.1f/%3.1f P:%4.1f/%4.1f V:%6.1f (%d)", + sched->count,i,moldyn->total_steps, + moldyn->t,moldyn->t_avg, + moldyn->p_avg/BAR,moldyn->gp_avg/BAR, + moldyn->volume, + (int)(t2.tv_sec-t1.tv_sec)); + + fflush(stdout); + + /* copy over time */ + t1=t2; + //} /* increase absolute time */ moldyn->time+=moldyn->tau; @@ -1500,8 +1673,8 @@ return 0; /* check for hooks */ if(sched->hook) { - printf("\n ## schedule hook %d/%d start ##\n", - sched->count+1,sched->total_sched-1); + printf("\n ## schedule hook %d start ##\n", + sched->count); sched->hook(moldyn,sched->hook_params); printf(" ## schedule hook end ##\n"); } @@ -1572,15 +1745,24 @@ int potential_force_calc(t_moldyn *moldyn) { t_atom *itom,*jtom,*ktom; t_virial *virial; t_linkcell *lc; +#ifdef STATIC_LISTS + int *neighbour_i[27]; + int p,q; + t_atom *atom; +#else t_list neighbour_i[27]; t_list neighbour_i2[27]; t_list *this,*that; +#endif u8 bc_ij,bc_ik; int dnlc; count=moldyn->count; itom=moldyn->atom; lc=&(moldyn->lc); +#ifdef STATIC_LISTS + atom=moldyn->atom; +#endif /* reset energy */ moldyn->energy=0.0; @@ -1635,14 +1817,33 @@ int potential_force_calc(t_moldyn *moldyn) { if(moldyn->func2b) { for(j=0;j<27;j++) { + bc_ij=(jattr&ATOM_ATTR_2BP)& + (itom[i].attr&ATOM_ATTR_2BP)) { + moldyn->func2b(moldyn, + &(itom[i]), + jtom, + bc_ij); + } + } +#else this=&(neighbour_i[j]); list_reset_f(this); if(this->start==NULL) continue; - bc_ij=(jcurrent->data; @@ -1657,6 +1858,7 @@ int potential_force_calc(t_moldyn *moldyn) { bc_ij); } } while(list_next_f(this)!=L_NO_NEXT_ELEMENT); +#endif } } @@ -1667,21 +1869,34 @@ int potential_force_calc(t_moldyn *moldyn) { continue; /* copy the neighbour lists */ +#ifdef STATIC_LISTS + /* no copy needed for static lists */ +#else memcpy(neighbour_i2,neighbour_i,27*sizeof(t_list)); +#endif /* second loop over atoms j */ for(j=0;j<27;j++) { + bc_ij=(jstart==NULL) continue; - bc_ij=(jcurrent->data; +#endif if(jtom==&(itom[i])) continue; @@ -1707,17 +1922,24 @@ int potential_force_calc(t_moldyn *moldyn) { for(k=0;k<27;k++) { + bc_ik=(kstart==NULL) continue; - bc_ik=(kcurrent->data; +#endif if(!(ktom->attr&ATOM_ATTR_3BP)) continue; @@ -1733,9 +1955,12 @@ int potential_force_calc(t_moldyn *moldyn) { jtom, ktom, bc_ik|bc_ij); - +#ifdef STATIC_LISTS + } +#else } while(list_next_f(that)!=\ L_NO_NEXT_ELEMENT); +#endif } @@ -1752,17 +1977,24 @@ int potential_force_calc(t_moldyn *moldyn) { for(k=0;k<27;k++) { + bc_ik=(kstart==NULL) continue; - bc_ik=(kcurrent->data; +#endif if(!(ktom->attr&ATOM_ATTR_3BP)) continue; @@ -1779,8 +2011,12 @@ int potential_force_calc(t_moldyn *moldyn) { ktom, bc_ik|bc_ij); +#ifdef STATIC_LISTS + } +#else } while(list_next_f(that)!=\ L_NO_NEXT_ELEMENT); +#endif } @@ -1792,8 +2028,11 @@ int potential_force_calc(t_moldyn *moldyn) { &(itom[i]), jtom,bc_ij); } - +#ifdef STATIC_LISTS + } +#else } while(list_next_f(this)!=L_NO_NEXT_ELEMENT); +#endif } @@ -1807,7 +2046,13 @@ int potential_force_calc(t_moldyn *moldyn) { } #ifdef DEBUG - printf("\nATOM 0: %f %f %f\n\n",itom->f.x,itom->f.y,itom->f.z); + //printf("\nATOM 0: %f %f %f\n\n",itom->f.x,itom->f.y,itom->f.z); + if(moldyn->time>DSTART&&moldyn->timeatom[5832].f.x); + printf(" y: %0.40f\n",moldyn->atom[5832].f.y); + printf(" z: %0.40f\n",moldyn->atom[5832].f.z); + } #endif /* calculate global virial */ @@ -1928,6 +2173,50 @@ int moldyn_bc_check(t_moldyn *moldyn) { * restore function */ +int moldyn_read_save_file(t_moldyn *moldyn,char *file) { + + int fd; + int cnt,size; + + fd=open(file,O_RDONLY); + if(fd<0) { + perror("[moldyn] load save file open"); + return fd; + } + + size=sizeof(t_moldyn); + + while(size) { + cnt=read(fd,moldyn,size); + if(cnt<0) { + perror("[moldyn] load save file read (moldyn)"); + return cnt; + } + size-=cnt; + } + + size=moldyn->count*sizeof(t_atom); + + moldyn->atom=(t_atom *)malloc(size); + if(moldyn->atom==NULL) { + perror("[moldyn] load save file malloc (atoms)"); + return -1; + } + + while(size) { + cnt=read(fd,moldyn->atom,size); + if(cnt<0) { + perror("[moldyn] load save file read (atoms)"); + return cnt; + } + size-=cnt; + } + + // hooks etc ... + + return 0; +} + int moldyn_load(t_moldyn *moldyn) { // later ... @@ -1957,11 +2246,335 @@ int get_line(int fd,char *line,int max) { } } +int pair_correlation_init(t_moldyn *moldyn,double dr) { + + + return 0; +} + +int calculate_pair_correlation(t_moldyn *moldyn,double dr,void *ptr) { + + int slots; + double *stat; + int i,j; + t_linkcell *lc; +#ifdef STATIC_LISTS + int *neighbour[27]; + int p; +#else + t_list neighbour[27]; +#endif + t_atom *itom,*jtom; + t_list *this; + unsigned char bc; + t_3dvec dist; + double d; + //double norm; + int o,s; + unsigned char ibrand; + + lc=&(moldyn->lc); + + slots=moldyn->cutoff/dr; + o=2*slots; + + printf("[moldyn] pair correlation calc info:\n"); + printf(" time: %f\n",moldyn->time); + printf(" count: %d\n",moldyn->count); + printf(" cutoff: %f\n",moldyn->cutoff); + printf(" temperature: cur=%f avg=%f\n",moldyn->t,moldyn->t_avg); + + if(ptr!=NULL) { + stat=(double *)ptr; + } + else { + stat=(double *)malloc(3*slots*sizeof(double)); + if(stat==NULL) { + perror("[moldyn] pair correlation malloc"); + return -1; + } + } + + memset(stat,0,3*slots*sizeof(double)); + + link_cell_init(moldyn,VERBOSE); + + itom=moldyn->atom; + + for(i=0;icount;i++) { + /* neighbour indexing */ + link_cell_neighbour_index(moldyn, + (itom[i].r.x+moldyn->dim.x/2)/lc->x, + (itom[i].r.y+moldyn->dim.y/2)/lc->x, + (itom[i].r.z+moldyn->dim.z/2)/lc->x, + neighbour); + + /* brand of atom i */ + ibrand=itom[i].brand; + + for(j=0;j<27;j++) { + + bc=(jdnlc)?0:1; + +#ifdef STATIC_LISTS + p=0; + + while(neighbour[j][p]!=0) { + + jtom=&(moldyn->atom[neighbour[j][p]]); + p++; +#else + this=&(neighbour[j]); + list_reset_f(this); + + if(this->start==NULL) + continue; + + do { + + jtom=this->current->data; +#endif + /* only count pairs once, + * skip same atoms */ + if(itom[i].tag>=jtom->tag) + continue; + + /* + * pair correlation calc + */ + + /* distance */ + v3_sub(&dist,&(jtom->r),&(itom[i].r)); + if(bc) check_per_bound(moldyn,&dist); + d=v3_absolute_square(&dist); + + /* ignore if greater or equal cutoff */ + if(d>=moldyn->cutoff_square) + continue; + + /* fill the slots */ + d=sqrt(d); + s=(int)(d/dr); + + /* should never happen but it does 8) - + * related to -ffloat-store problem! */ + if(s>=slots) s=slots-1; + + if(ibrand!=jtom->brand) { + /* mixed */ + stat[s]+=1; + } + else { + /* type a - type a bonds */ + if(ibrand==0) + stat[s+slots]+=1; + else + /* type b - type b bonds */ + stat[s+o]+=1; + } +#ifdef STATIC_LISTS + } +#else + } while(list_next_f(this)!=L_NO_NEXT_ELEMENT); +#endif + } + } + + /* normalization + for(i=1;i 2 pi r r dr + norm=2*M_PI*moldyn->count*(i*dr*i*dr)*dr; + stat[i]/=norm; + stat[slots+i]/=norm; + stat[o+i]/=norm; + } + */ + + if(ptr==NULL) { + /* todo: store/print pair correlation function */ + free(stat); + } + + free(moldyn->atom); + + link_cell_shutdown(moldyn); + + return 0; +} + int analyze_bonds(t_moldyn *moldyn) { + return 0; +} + +/* + * visualization code + */ + +int visual_init(t_moldyn *moldyn,char *filebase) { + + strncpy(moldyn->vis.fb,filebase,128); + + return 0; +} + +int visual_atoms(t_moldyn *moldyn) { + + int i,j,fd; + 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; + + 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) { + 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", + moldyn->count,moldyn->time,help/40.0,help/40.0,-0.8*help); + + // atomic configuration + for(i=0;icount;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=jdnlc?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 + } + } + + // boundaries + if(dim.x) { + dprintf(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", + -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", + 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", + -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", + -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", + -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", + 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", + -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", + -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", + -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", + 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", + dim.x/2,dim.y/2,dim.z/2, + dim.x/2,dim.y/2,-dim.z/2); + } + + close(fd); + return 0; }