int main(){ int nthreads = 4; omp_set_num_threads(nthreads); #pragma omp parallel fprintf(stderr,"nthreads %d \n", omp_get_num_threads()); int n3 = 128; int n2 = 128; int n1 = 128; // float ***array = sf_floatalloc3(n1,n2,n3); float *array = fftwf_alloc_real(n3*n2*n1); fftwf_complex* cout = fftwf_alloc_complex(n3*n2*n1); int err = fftwf_init_threads(); if (err == 0) { fprintf(stderr,"something went wrong with fftw\n"); } fprintf(stderr,"Got here\n"); double start,end; start = omp_get_wtime()*omp_get_wtick(); fftwf_plan_with_nthreads(nthreads); fftwf_plan plan = fftwf_plan_dft_r2c_3d( n1,n2,n3, array,cout, FFTW_MEASURE); end = omp_get_wtime()*omp_get_wtick(); fprintf(stderr,"elapsed time: %f %f %f\n",end,start,end-start); for(int i = 0; i < n3*n2*n1; ++i) array[i] = rand()/RAND_MAX; //float start = clock()/CLOCKS_PER_SEC; start = omp_get_wtime(); for(int i=0; i < 1001; ++i) fftwf_execute(plan); //float end = clock()/CLOCKS_PER_SEC; end = omp_get_wtime(); fprintf(stderr,"elapsed time: %f time/calc %f\n", end-start,(end-start)/100.0); fftwf_cleanup_threads(); fftwf_cleanup(); fftwf_destroy_plan(plan); fftwf_free(cout); fftwf_free(array); //free(**array); free(*array); free(array); return 0; }
void fft3(float *inp /* [n1*n2*n3] */, sf_complex *out /* [nk*n2*n3] */) /*< 3-D FFT >*/ { int i1, i2, i3; float f; #ifdef SF_HAS_FFTW if (NULL==cfg) { cfg = cmplx? fftwf_plan_dft_3d(n3,n2,n1, (fftwf_complex *) cc[0][0], (fftwf_complex *) out, FFTW_FORWARD, FFTW_MEASURE): fftwf_plan_dft_r2c_3d(n3,n2,n1, ff[0][0], (fftwf_complex *) out, FFTW_MEASURE); if (NULL == cfg) sf_error("FFTW failure."); } #endif /* FFT centering */ for (i3=0; i3<n3; i3++) { for (i2=0; i2<n2; i2++) { for (i1=0; i1<n1; i1++) { f = inp[(i3*n2+i2)*n1+i1]; if (cmplx) { cc[i3][i2][i1] = sf_cmplx((((i3%2==0)==(i2%2==0))==(i1%2==0))? f:-f,0.); } else { ff[i3][i2][i1] = ((i3%2==0)==(i2%2==0))? f:-f; } } } } #ifdef SF_HAS_FFTW fftwf_execute(cfg); #else /* FFT over first axis */ for (i3=0; i3 < n3; i3++) { for (i2=0; i2 < n2; i2++) { if (cmplx) { kiss_fft_stride(cfg1,(kiss_fft_cpx *) cc[i3][i2],tmp[i3][i2],1); } else { kiss_fftr (cfg,ff[i3][i2],tmp[i3][i2]); } } } /* FFT over second axis */ for (i3=0; i3 < n3; i3++) { for (i1=0; i1 < nk; i1++) { kiss_fft_stride(cfg2,tmp[i3][0]+i1,ctrace2,nk); for (i2=0; i2 < n2; i2++) { tmp[i3][i2][i1]=ctrace2[i2]; } } } /* FFT over third axis */ for (i2=0; i2 < n2; i2++) { for (i1=0; i1 < nk; i1++) { kiss_fft_stride(cfg3,tmp[0][0]+i2*nk+i1,ctrace3,nk*n2); for (i3=0; i3<n3; i3++) { out[(i3*n2+i2)*nk+i1] = trace3[i3]; } } } #endif }
int main(int argc, char *argv[]) { char fname[300]; FILE *fid; DIR* dir; size_t elem; long int ii,ij,ik, ii_c, ij_c, ik_c, a, b, c; long int ncells_1D; long int i,j,p,indi,indj,ind; int flag_bub,iz; double redshift,tmp; double kk; double bfactor; /* value by which to divide bubble size R */ double neutral,*xHI; float *halo_map, *top_hat_r, *density_map,*bubblef, *bubble; fftwf_complex *halo_map_c, *top_hat_c, *collapsed_mass_c, *density_map_c, *total_mass_c, *bubble_c; fftwf_plan pr2c1,pr2c2,pr2c3,pr2c4,pc2r1,pc2r2,pc2r3; double zmin,zmax,dz; double R; if(argc != 2) { printf("Generates boxes with ionization fraction for a range of redshifts\n"); printf("usage: get_HIIbubbles base_dir\n"); printf("base_dir contains simfast21.ini and directory structure\n"); exit(1); } get_Simfast21_params(argv[1]); zmin=global_Zminsim; zmax=global_Zmaxsim; dz=global_Dzsim; bfactor=pow(10.0,log10(global_bubble_Rmax/global_dx_smooth)/global_bubble_Nbins); printf("Bubble radius ratio (bfactor): %f\n", bfactor); fflush(0); #ifdef _OMPTHREAD_ omp_set_num_threads(global_nthreads); fftwf_init_threads(); fftwf_plan_with_nthreads(global_nthreads); printf("Using %d threads\n",global_nthreads);fflush(0); #endif /* Create directory Ionization */ sprintf(fname,"%s/Ionization",argv[1]); if((dir=opendir(fname))==NULL) { printf("Creating Ionization directory\n"); if(mkdir(fname,(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))!=0) { printf("Error creating directory!\n"); exit(1); } } sprintf(fname,"%s/Output_text_files",argv[1]); if((dir=opendir(fname))==NULL) { printf("Creating Output_text_files directory\n"); if(mkdir(fname,(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))!=0) { printf("Error creating directory!\n"); exit(1); } } /* Memory allocation - we could do some of the FFTs inline... */ /*************************************************************/ /* density_map mass */ if(!(density_map=(float *) fftwf_malloc(global_N3_smooth*sizeof(float)))) { printf("Problem1...\n"); exit(1); } if(!(density_map_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) { printf("Problem2...\n"); exit(1); } if(!(pr2c1=fftwf_plan_dft_r2c_3d(global_N_smooth, global_N_smooth, global_N_smooth, density_map, density_map_c, FFTWflag))) { printf("Problem3...\n"); exit(1); } /* halo_map mass */ if(!(halo_map=(float *) fftwf_malloc(global_N3_smooth*sizeof(float)))) { printf("Problem4...\n"); exit(1); } if(!(halo_map_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) { printf("Problem5...\n"); exit(1); } if(!(pr2c2=fftwf_plan_dft_r2c_3d(global_N_smooth, global_N_smooth, global_N_smooth, halo_map, halo_map_c, FFTWflag))) { printf("Problem6...\n"); exit(1); } /* total mass */ if(!(total_mass_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) { printf("Problem7...\n"); exit(1); } if(!(pc2r1=fftwf_plan_dft_c2r_3d(global_N_smooth, global_N_smooth, global_N_smooth, total_mass_c, density_map, FFTWflag))) { printf("Problem8...\n"); exit(1); } /* collapsed mass */ if(!(collapsed_mass_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) { printf("Problem9...\n"); exit(1); } if(!(pc2r2=fftwf_plan_dft_c2r_3d(global_N_smooth, global_N_smooth, global_N_smooth, collapsed_mass_c, halo_map, FFTWflag))) { printf("Problem10...\n"); exit(1); } /* top hat window */ if(!(top_hat_r=(float *) fftwf_malloc(global_N3_smooth*sizeof(float)))) { printf("Problem11...\n"); exit(1); } if(!(top_hat_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) { printf("Problem12...\n"); exit(1); } if(!(pr2c3=fftwf_plan_dft_r2c_3d(global_N_smooth, global_N_smooth, global_N_smooth, top_hat_r, top_hat_c, FFTWflag))) { printf("Problem13...\n"); exit(1); } /* bubble boxes */ if(!(bubble=(float *) fftwf_malloc(global_N3_smooth*sizeof(float)))) { printf("Problem14...\n"); exit(1); } if(!(bubble_c=(fftwf_complex *) fftwf_malloc(global_N_smooth*global_N_smooth*(global_N_smooth/2+1)*sizeof(fftwf_complex)))) { printf("Problem15...\n"); exit(1); } if(!(bubblef=(float *) malloc(global_N3_smooth*sizeof(float)))) { printf("Problem16...\n"); exit(1); } if(!(pr2c4=fftwf_plan_dft_r2c_3d(global_N_smooth, global_N_smooth, global_N_smooth, bubble, bubble_c, FFTWflag))) { printf("Problem17...\n"); exit(1); } if(!(pc2r3=fftwf_plan_dft_c2r_3d(global_N_smooth, global_N_smooth, global_N_smooth, bubble_c, bubble, FFTWflag))) { printf("Problem18...\n"); exit(1); } if(!(xHI=(double *) malloc((int)((zmax-zmin)/dz+2)*sizeof(double)))) { printf("Problem19...\n"); exit(1); } /****************************************************/ /***************** Redshift cycle *******************/ printf("Number of bubble sizes: %d\n",(int)((log(global_bubble_Rmax)-log(2.*global_dx_smooth))/log(bfactor))); printf("Redshift cycle...\n");fflush(0); iz=0; neutral=0.; for(redshift=zmin;redshift<(zmax+dz/10) && (neutral < xHlim);redshift+=dz){ printf("z = %f\n",redshift);fflush(0); sprintf(fname, "%s/delta/deltanl_z%.3f_N%ld_L%.1f.dat",argv[1],redshift,global_N_smooth,global_L/global_hubble); fid=fopen(fname,"rb"); if (fid==NULL) {printf("\nError reading deltanl file... Check path or if the file exists..."); exit (1);} elem=fread(density_map,sizeof(float),global_N3_smooth,fid); fclose(fid); #ifdef _OMPTHREAD_ #pragma omp parallel for shared(global_N3_smooth, density_map,global_rho_m, global_dx_smooth,bubblef) private(i) #endif for(i=0;i<(global_N3_smooth);i++){ density_map[i]=(1.0+density_map[i])*global_rho_m*global_dx_smooth*global_dx_smooth*global_dx_smooth; /* total mass in 1 cell */ bubblef[i]=0.0; } sprintf(fname, "%s/Halos/masscoll_z%.3f_N%ld_L%.1f.dat",argv[1],redshift,global_N_smooth,global_L/global_hubble); fid=fopen(fname,"rb"); if (fid==NULL) {printf("\nError reading %s file... Check path or if the file exists...",fname); exit (1);} elem=fread(halo_map,sizeof(float),global_N3_smooth,fid); fclose(fid); /* Quick fill of single cells before going to bubble cycle */ #ifdef _OMPTHREAD_ #pragma omp parallel for shared(global_N3_smooth,halo_map,density_map,global_eff,bubblef) private(i,tmp) #endif for(i=0;i<global_N3_smooth;i++) { if(halo_map[i]>0.) { if(density_map[i]>0.) tmp=(double)halo_map[i]*global_eff/density_map[i]; else tmp=1.0; }else tmp=0.; if(tmp>=1.0) bubblef[i]=1.0; else bubblef[i]=tmp; } /* FFT density and halos */ fftwf_execute(pr2c1); fftwf_execute(pr2c2); /************** going over the bubble sizes ****************/ R=global_bubble_Rmax; /* Maximum bubble size...*/ while(R>=2*global_dx_smooth){ printf("bubble radius R= %lf\n", R);fflush(0); // printf("Filtering halo and density boxes...\n");fflush(0); #ifdef _OMPTHREAD_ #pragma omp parallel for shared(collapsed_mass_c,halo_map_c,total_mass_c,density_map_c,global_N_smooth,global_dk,R) private(i,j,p,indi,indj,kk) #endif for(i=0;i<global_N_smooth;i++) { if(i>global_N_smooth/2) { indi=-(global_N_smooth-i); }else indi=i; for(j=0;j<global_N_smooth;j++) { if(j>global_N_smooth/2) { indj=-(global_N_smooth-j); }else indj=j; for(p=0;p<=global_N_smooth/2;p++) { kk=global_dk*sqrt(indi*indi+indj*indj+p*p); total_mass_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]=density_map_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]*W_filter(kk*R); collapsed_mass_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]=halo_map_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]*W_filter(kk*R); } } } fftwf_execute(pc2r1); fftwf_execute(pc2r2); flag_bub=0; // printf("Starting to find and fill bubbles...\n");fflush(0); /* signal center of bubbles */ #ifdef _OMPTHREAD_ #pragma omp parallel for shared(halo_map,density_map,bubble,global_N_smooth,global_eff,flag_bub) private(ii,ij,ik,ind) #endif for(ii=0;ii<global_N_smooth;ii++){ for(ij=0;ij<global_N_smooth;ij++){ for(ik=0;ik<global_N_smooth;ik++){ ind=ii*global_N_smooth*global_N_smooth+ij*global_N_smooth+ik; if(halo_map[ind]>0.) { if(density_map[ind]>0.) { if((double)halo_map[ind]/density_map[ind]>=1.0/global_eff) { flag_bub=1; bubble[ind]=1.0; }else bubble[ind]=0; }else { flag_bub=1; bubble[ind]=1.0; } }else bubble[ind]=0; } } } /* generate spherical window in real space for a given R */ if(flag_bub>0){ printf("Found bubble...\n");fflush(0); #ifdef _OMPTHREAD_ #pragma omp parallel for shared(top_hat_r,R,global_dx_smooth,global_N_smooth) private(i,j,p) #endif for(i=0;i<global_N_smooth;i++){ for(j=0;j<global_N_smooth;j++){ for(p=0;p<global_N_smooth;p++){ if(sqrt(i*i+j*j+p*p)*global_dx_smooth<=R || sqrt(i*i+(j-global_N_smooth)*(j-global_N_smooth)+p*p)*global_dx_smooth<=R || sqrt(i*i+(j-global_N_smooth)*(j-global_N_smooth)+(p-global_N_smooth)*(p-global_N_smooth))*global_dx_smooth <=R || sqrt(i*i+(p-global_N_smooth)*(p-global_N_smooth)+j*j)*global_dx_smooth<=R || sqrt((i-global_N_smooth)*(i-global_N_smooth)+j*j+p*p)*global_dx_smooth<=R || sqrt((i-global_N_smooth)*(i-global_N_smooth)+(j-global_N_smooth)*(j-global_N_smooth)+p*p)*global_dx_smooth<=R || sqrt((i-global_N_smooth)*(i-global_N_smooth)+(j-global_N_smooth)*(j-global_N_smooth)+(p-global_N_smooth)*(p-global_N_smooth))*global_dx_smooth<=R || sqrt((i-global_N_smooth)*(i-global_N_smooth)+j*j+(p-global_N_smooth)*(p-global_N_smooth))*global_dx_smooth<=R ) { top_hat_r[i*global_N_smooth*global_N_smooth+j*global_N_smooth+p]=1.0; }else top_hat_r[i*global_N_smooth*global_N_smooth+j*global_N_smooth+p]=0.0; } } } /* FFT bubble centers and window */ fftwf_execute(pr2c3); fftwf_execute(pr2c4); /* Make convolution */ #ifdef _OMPTHREAD_ #pragma omp parallel for shared(bubble_c,top_hat_c,global_N_smooth) private(i) #endif for(i=0;i<global_N_smooth*global_N_smooth*(global_N_smooth/2+1);i++) { bubble_c[i]*=top_hat_c[i]; } fftwf_execute(pc2r3); /* after dividing by global_N3_smooth, values in bubble are between 0 (neutral)and global_N3_smooth */ #ifdef _OMPTHREAD_ #pragma omp parallel for shared(bubble,bubblef,global_N3_smooth) private(i) #endif for (i=0; i<global_N3_smooth; i++){ bubble[i]/=global_N3_smooth; if (bubble[i]>0.2) bubblef[i]=1.0; /* neutral should be zero */ } } /* ends filling out bubbles in box for R */ R/=bfactor; } /* ends R cycle */ /* just to check smallest bubbles through older method */ printf("Going to smaller R cycle...\n"); fflush(0); while(R>=global_dx_smooth){ printf("bubble radius R= %lf\n", R);fflush(0); flag_bub=0; #ifdef _OMPTHREAD_ #pragma omp parallel for shared(collapsed_mass_c,halo_map_c,total_mass_c,density_map_c,global_N_smooth,global_dx_smooth,global_dk,R) private(i,j,p,indi,indj,kk) #endif for(i=0;i<global_N_smooth;i++) { if(i>global_N_smooth/2) { indi=-(global_N_smooth-i); }else indi=i; for(j=0;j<global_N_smooth;j++) { if(j>global_N_smooth/2) { indj=-(global_N_smooth-j); }else indj=j; for(p=0;p<=global_N_smooth/2;p++) { kk=global_dk*sqrt(indi*indi+indj*indj+p*p); total_mass_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]=density_map_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]*W_filter(kk*R); collapsed_mass_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]=halo_map_c[i*global_N_smooth*(global_N_smooth/2+1)+j*(global_N_smooth/2+1)+p]*W_filter(kk*R); } } } fftwf_execute(pc2r1); fftwf_execute(pc2r2); /* fill smaller bubbles in box */ ncells_1D=(long int)(R/global_dx_smooth); // printf("Starting to find and fill bubbles...\n");fflush(0); #ifdef _OMPTHREAD_ #pragma omp parallel for shared(halo_map,density_map,global_eff,global_N_smooth,global_dx_smooth,R,ncells_1D,bubblef,flag_bub) private(ii_c,ij_c,ik_c,ii,ij,ik,a,b,c,ind) #endif for(ii_c=0;ii_c<global_N_smooth;ii_c++){ for(ij_c=0;ij_c<global_N_smooth;ij_c++){ for(ik_c=0;ik_c<global_N_smooth;ik_c++){ ind=ii_c*global_N_smooth*global_N_smooth+ij_c*global_N_smooth+ik_c; if(halo_map[ind]>0.) { if(!(density_map[ind]>0.) || ((double)halo_map[ind]/density_map[ind]>=1.0/global_eff)) { flag_bub=1; for(ii=-(ncells_1D+1);ii<=ncells_1D+1;ii++){ a=check_borders(ii_c+ii,global_N_smooth); for(ij=-(ncells_1D+1);ij<=ncells_1D+1;ij++){ if(sqrt(ii*ii+ij*ij)*global_dx_smooth <= R){ b=check_borders(ij_c+ij,global_N_smooth); for(ik=-(ncells_1D+1);ik<=ncells_1D+1;ik++){ c=check_borders(ik_c+ik,global_N_smooth); if(sqrt(ii*ii+ij*ij+ik*ik)*global_dx_smooth <= R){ bubblef[a*global_N_smooth*global_N_smooth+b*global_N_smooth+c]=1.0; } } } } } } } } } } if(flag_bub>0){printf("Found bubble...\n");fflush(0);} R/=bfactor; } /* ends small bubbles R cycle */ neutral=0.; for (i=0; i<global_N3_smooth; i++){ neutral+=1.0-bubblef[i]; } neutral/=global_N3_smooth; printf("neutral fraction=%lf\n",neutral);fflush(0); xHI[iz]=neutral; sprintf(fname, "%s/Ionization/xHII_z%.3f_eff%.2lf_N%ld_L%.1f.dat",argv[1],redshift,global_eff,global_N_smooth,global_L/global_hubble); if((fid = fopen(fname,"wb"))==NULL) { printf("Error opening file:%s\n",fname); exit(1); } elem=fwrite(bubblef,sizeof(float),global_N3_smooth,fid); fclose(fid); iz++; } /* ends redshift cycle */ /* z cycle for neutral>=xHlim */ while(redshift<(zmax+dz/10)) { printf("z(>%f) = %f\n",xHlim,redshift);fflush(0); xHI[iz]=1.0; sprintf(fname, "%s/Ionization/xHII_z%.3f_eff%.2lf_N%ld_L%.1f.dat",argv[1],redshift,global_eff,global_N_smooth,global_L/global_hubble); if((fid = fopen(fname,"wb"))==NULL) { printf("Error opening file:%s\n",fname); exit(1); } #ifdef _OMPTHREAD_ #pragma omp parallel for shared(bubblef,global_N3_smooth) private(i) #endif for(i=0;i<global_N3_smooth;i++) bubblef[i]=0.0; elem=fwrite(bubblef,sizeof(float),global_N3_smooth,fid); fclose(fid); iz++; redshift+=dz; } sprintf(fname, "%s/Output_text_files/zsim.txt",argv[1]); if((fid = fopen(fname,"a"))==NULL) { printf("Error opening file:%s\n",fname); exit(1); } for(redshift=zmax;redshift>(zmin-dz/10);redshift-=dz) fprintf(fid,"%f\n",redshift); /* first line should be highest redshift */ fclose(fid); sprintf(fname, "%s/Output_text_files/x_HI_eff%.2lf_N%ld_L%.1f.dat",argv[1],global_eff,global_N_smooth,global_L/global_hubble); if((fid = fopen(fname,"a"))==NULL) { printf("Error opening file:%s\n",fname); exit(1); } for(i=iz-1;i>=0;i--) fprintf(fid,"%lf\n",xHI[i]); /* first line should be highest redshift */ fclose(fid); free(xHI); free(bubblef); fftwf_free(top_hat_r); fftwf_free(top_hat_c); fftwf_free(collapsed_mass_c); fftwf_free(density_map); fftwf_free(density_map_c); fftwf_free(halo_map); fftwf_free(halo_map_c); fftwf_free(total_mass_c); fftwf_free(bubble); fftwf_free(bubble_c); exit(0); }
int main(int argc, char **argv){ FILE *fid; size_t elem; long int i,j,p; long int indi, indj; double kk; fftwf_complex *map_vel_c; float *map; fftwf_complex *map_in_c; fftwf_plan pc2r; fftwf_plan pr2c; char fname[256]; DIR* dir; if(argc != 2) { printf("Usage: get_velocityfield work_dir\n"); printf("work_dir - directory containing simfast21.ini \n"); exit(1); } get_Simfast21_params(argv[1]); #ifdef _OMPTHREAD_ omp_set_num_threads(global_nthreads); fftwf_init_threads(); fftwf_plan_with_nthreads(global_nthreads); printf("Using %d threads\n",global_nthreads); #endif if(!(map=(float *) fftwf_malloc(global_N_halo*global_N_halo*global_N_halo*sizeof(float)))) { printf("Problem...\n"); exit(1); } if(!(map_in_c = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * global_N_halo*global_N_halo*(global_N_halo/2+1)))) { printf(" Out of memory...\n"); exit(1); } if(!(map_vel_c = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * global_N_halo*global_N_halo*(global_N_halo/2+1)))) { printf("Problem allocating memory for x velocity field in k-space...\n"); exit(1); } /* Tansformacoes de fourier para calcular as caixas vx(x) vx(y) e vx(z) */ if(!(pc2r=fftwf_plan_dft_c2r_3d(global_N_halo, global_N_halo, global_N_halo, map_vel_c, map, FFTW_ESTIMATE))) { printf("Problem...\n"); exit(1); } /* FFT para map */ if(!(pr2c=fftwf_plan_dft_r2c_3d(global_N_halo, global_N_halo, global_N_halo, map , map_in_c, FFTW_ESTIMATE))) { printf("Problem...\n"); exit(1); } sprintf(fname, "%s/delta/delta_z0_N%ld_L%d.dat", argv[1],global_N_halo,(int)(global_L)); /*Leitura do campo de densidades no espaco real*/ fid=fopen(fname,"rb"); /* second argument contains name of input file */ if (fid==NULL) { printf("\n Density file path is not correct or the file does not exit...\n"); exit (1); } elem=fread(map,sizeof(float),global_N_halo*global_N_halo*global_N_halo,fid); fclose(fid); /***********************************************************************************/ // Conversao do mapa de densidades de real para complexo fftwf_execute(pr2c); /********************************************************************/ /********************************************************************/ /********************************************************************/ /* Computing velocity fields */ /* Create directory Velocity */ sprintf(fname,"%s/Velocity",argv[1]); if((dir=opendir(fname))==NULL) { printf("Creating Velocity directory\n"); if(mkdir(fname,(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))!=0) { printf("Error creating directory!\n"); exit(1); } } /********************************************************************/ printf("\nComputing v_x field...\n");fflush(0); #ifdef _OMPTHREAD_ #pragma omp parallel for shared(global_N_halo,global_dk,map_vel_c,map_in_c,global_dx_halo) private(i,indi,j,indj,p,kk) #endif for(i=0;i<global_N_halo;i++) { if(i>global_N_halo/2) { /* Large frequencies are equivalent to smaller negative ones */ indi=-(global_N_halo-i); }else indi=i; for(j=0;j<global_N_halo;j++) { if(j>global_N_halo/2) { indj=-(global_N_halo-j); }else indj=j; for(p=0;p<=global_N_halo/2;p++) { kk=global_dk*sqrt(indi*indi+indj*indj+p*p); if(kk>0){ //Normalizacao pois a biblioteca fftw3 não tem dx nem global_dk nos integrais map_in_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=I*(global_dk)*(1/(kk*kk))*map_in_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]*global_dx_halo*global_dx_halo*global_dx_halo/global_L3; map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=indi*map_in_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]; }else{ map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=0; } } } } box_symmetriesf(map_vel_c,global_N_halo); /* Executes FFT */ fftwf_execute(pc2r); printf("\nWriting v_x field to file...\n");fflush(0); sprintf(fname, "%s/Velocity/vel_x_z0_N%ld_L%d.dat", argv[1],global_N_halo,(int)(global_L)); if((fid=fopen(fname,"wb"))==NULL){ printf("\nThe file cannot be open\n"); return 0; } elem=fwrite(map,sizeof(float),global_N_halo*global_N_halo*global_N_halo,fid); fclose(fid); /********************************************************************/ printf("\nComputing v_y field...\n");fflush(0); #ifdef _OMPTHREAD_ #pragma omp parallel for shared(global_N_halo,global_dk,map_vel_c,map_in_c,global_dx_halo) private(i,indi,j,indj,p,kk) #endif for(i=0;i<global_N_halo;i++) { if(i>global_N_halo/2) { /* Large frequencies are equivalent to smaller negative ones */ indi=-(global_N_halo-i); }else indi=i; for(j=0;j<global_N_halo;j++) { if(j>global_N_halo/2) { indj=-(global_N_halo-j); }else indj=j; for(p=0;p<=global_N_halo/2;p++) { kk=global_dk*sqrt(indi*indi+indj*indj+p*p); if(kk>0){ //Normalizacao pois a biblioteca fftw3 não tem dx nem global_dk nos integrais map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=indj*map_in_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]; }else{ map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=0; } } } } box_symmetriesf(map_vel_c,global_N_halo); /* Executes FFT */ fftwf_execute(pc2r); printf("\nWriting v_y field to file...\n");fflush(0); sprintf(fname, "%s/Velocity/vel_y_z0_N%ld_L%d.dat", argv[1],global_N_halo,(int)(global_L)); if((fid=fopen(fname,"wb"))==NULL){ printf("\nThe file cannot be open\n"); return 0; } elem=fwrite(map,sizeof(float),global_N_halo*global_N_halo*global_N_halo,fid); fclose(fid); /********************************************************************/ printf("\nComputing v_z field...\n");fflush(0); #ifdef _OMPTHREAD_ #pragma omp parallel for shared(global_N_halo,global_dk,map_vel_c,map_in_c,global_dx_halo) private(i,indi,j,indj,p,kk) #endif for(i=0;i<global_N_halo;i++) { if(i>global_N_halo/2) { /* Large frequencies are equivalent to smaller negative ones */ indi=-(global_N_halo-i); }else indi=i; for(j=0;j<global_N_halo;j++) { if(j>global_N_halo/2) { indj=-(global_N_halo-j); }else indj=j; for(p=0;p<=global_N_halo/2;p++) { kk=global_dk*sqrt(indi*indi+indj*indj+p*p); if(kk>0){ //Normalizacao pois a biblioteca fftw3 não tem dx nem global_dk nos integrais map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=p*map_in_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]; }else{ map_vel_c[i*global_N_halo*(global_N_halo/2+1)+j*(global_N_halo/2+1)+p]=0; } } } } box_symmetriesf(map_vel_c,global_N_halo); /* Executes FFT */ fftwf_execute(pc2r); printf("\nWriting v_z field to file...\n");fflush(0); sprintf(fname, "%s/Velocity/vel_z_z0_N%ld_L%d.dat", argv[1],global_N_halo,(int)(global_L)); if((fid=fopen(fname,"wb"))==NULL){ printf("\nThe file cannot be open\n"); return 0; } elem=fwrite(map,sizeof(float),global_N_halo*global_N_halo*global_N_halo,fid); fclose(fid); fftwf_free(map); fftwf_free(map_in_c); fftwf_free(map_vel_c); fftwf_destroy_plan(pc2r); fftwf_destroy_plan(pr2c); exit(0); }
int main( int argc , char *argv[] ) { /* index counters */ int i ; /* Command line options */ char *output_file_name ; char *static_file_name ; char *mobile_file_name ; int global_grid_size ; int angle_step ; float surface ; float internal_value ; int electrostatics ; int keep_per_rotation ; int kept_scores ; int rescue ; int calculate ; float reverse_calculated_one_span ; char *default_global_grid_size ; char *default_angle_step ; char *default_surface ; char *default_internal_value ; char *default_electrostatics ; char *default_keep_per_rotation ; /* File stuff */ FILE *ftdock_file ; char line_buffer[100] ; int id , id2 , SCscore ; float RPscore ; int x , y , z , z_twist , theta , phi ; /* Angles stuff */ struct Angle Angles ; int first_rotation , rotation ; /* Structures */ struct Structure Static_Structure , Mobile_Structure ; struct Structure Origin_Static_Structure , Origin_Mobile_Structure ; struct Structure Rotated_at_Origin_Mobile_Structure ; /* Co-ordinates */ int xyz , fx , fy , fz , fxyz ; /* Grid stuff */ float grid_span , one_span ; float *static_grid ; float *mobile_grid ; float *convoluted_grid ; float *static_elec_grid = ( void * ) 0 ; float *mobile_elec_grid = ( void * ) 0 ; float *convoluted_elec_grid = ( void * ) 0 ; /* FFTW stuff */ fftwf_plan ps, pse, pm, pme, pinvs, pinvse; fftwf_complex *static_fsg ; fftwf_complex *mobile_fsg ; fftwf_complex *multiple_fsg ; fftwf_complex *static_elec_fsg = ( void * ) 0 ; fftwf_complex *mobile_elec_fsg = ( void * ) 0 ; fftwf_complex *multiple_elec_fsg = ( void * ) 0 ; /* Scores */ struct Score *Scores ; float max_es_value ; /* Timing */ unsigned long tb, ta; struct rusage rb, ra; struct timeval tvb, tva; /************/ /* Its nice to tell people what going on straight away */ setvbuf( stdout , (char *)NULL , _IONBF , 0 ) ; printf( "\n 3D-Dock Suite (March 2001)\n" ) ; printf( " Copyright (C) 1997-2000 Gidon Moont\n" ) ; printf( " This program comes with ABSOLUTELY NO WARRANTY\n" ) ; printf( " for details see license. This program is free software,\n"); printf( " and you may redistribute it under certain conditions.\n\n"); printf( " Biomolecular Modelling Laboratory\n" ) ; printf( " Imperial Cancer Research Fund\n" ) ; printf( " 44 Lincoln's Inn Fields\n" ) ; printf( " London WC2A 3PX\n" ) ; printf( " +44 (0)20 7269 3348\n" ) ; printf( " http://www.bmm.icnet.uk/\n\n" ) ; printf( "Starting FTDock (v2.0) global search program\n" ) ; /************/ /* Memory allocation */ if( ( ( output_file_name = ( char * ) malloc ( 500 * sizeof( char ) ) ) == NULL ) || ( ( static_file_name = ( char * ) malloc ( 500 * sizeof( char ) ) ) == NULL ) || ( ( mobile_file_name = ( char * ) malloc ( 500 * sizeof( char ) ) ) == NULL ) ) { GENERAL_MEMORY_PROBLEM } /************/ /* Command Line defaults */ strcpy( output_file_name , "ftdock_global.dat" ) ; strcpy( static_file_name , " --static file name was not provided--" ) ; strcpy( mobile_file_name , " --mobile file name was not provided--" ) ; global_grid_size = 128 ; angle_step = 12 ; surface = 1.3 ; internal_value = -15 ; electrostatics = 1 ; keep_per_rotation = 3 ; rescue = 0 ; calculate = 1 ; reverse_calculated_one_span = 0.7 ; default_global_grid_size = "(default calculated)" ; default_angle_step = "(default)" ; default_surface = "(default)" ; default_internal_value = "(default)" ; default_electrostatics = "(default)" ; default_keep_per_rotation = "(default)" ; /* Command Line parse */ for( i = 1 ; i < argc ; i ++ ) { if( strcmp( argv[i] , "-out" ) == 0 ) { i ++ ; if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) { printf( "Bad command line\n" ) ; exit( EXIT_FAILURE ) ; } strcpy( output_file_name , argv[i] ) ; } else { if( strcmp( argv[i] , "-static" ) == 0 ) { i ++ ; if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) { printf( "Bad command line\n" ) ; exit( EXIT_FAILURE ) ; } strcpy( static_file_name , argv[i] ) ; } else { if( strcmp( argv[i] , "-mobile" ) == 0 ) { i ++ ; if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) { printf( "Bad command line\n" ) ; exit( EXIT_FAILURE ) ; } strcpy( mobile_file_name , argv[i] ) ; } else { if( strcmp( argv[i] , "-grid" ) == 0 ) { i ++ ; if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) { printf( "Bad command line\n" ) ; exit( EXIT_FAILURE ) ; } sscanf( argv[i] , "%d" , &global_grid_size ) ; if( ( global_grid_size % 2 ) != 0 ) { printf( "Grid size must be even\n" ) ; exit( EXIT_FAILURE ) ; } default_global_grid_size = "(user defined)" ; calculate = 0 ; } else { if( strcmp( argv[i] , "-angle_step" ) == 0 ) { i ++ ; if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) { printf( "Bad command line\n" ) ; exit( EXIT_FAILURE ) ; } sscanf( argv[i] , "%d" , &angle_step ) ; default_angle_step = "(user defined)" ; } else { if( strcmp( argv[i] , "-surface" ) == 0 ) { i ++ ; if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) { printf( "Bad command line\n" ) ; exit( EXIT_FAILURE ) ; } sscanf( argv[i] , "%f" , &surface ) ; default_surface = "(user defined)" ; } else { if( strcmp( argv[i] , "-internal" ) == 0 ) { i ++ ; if( i == argc ) { printf( "Bad command line\n" ) ; exit( EXIT_FAILURE ) ; } sscanf( argv[i] , "%f" , &internal_value ) ; default_internal_value = "(user defined)" ; } else { if( strcmp( argv[i] , "-noelec" ) == 0 ) { electrostatics = 0 ; default_electrostatics = "(user defined)" ; } else { if( strcmp( argv[i] , "-keep" ) == 0 ) { i ++ ; if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) { printf( "Bad command line\n" ) ; exit( EXIT_FAILURE ) ; } sscanf( argv[i] , "%d" , &keep_per_rotation ) ; default_keep_per_rotation = "(user defined)" ; } else { if( strcmp( argv[i] , "-rescue" ) == 0 ) { rescue = 1 ; } else { if( strcmp( argv[i] , "-calculate_grid" ) == 0 ) { i ++ ; if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) { printf( "Bad command line\n" ) ; exit( EXIT_FAILURE ) ; } calculate = 1 ; default_global_grid_size = "(user defined calculated)" ; sscanf( argv[i] , "%f" , &reverse_calculated_one_span ) ; } else { printf( "Bad command line\n" ) ; exit( EXIT_FAILURE ) ; } } } } } } } } } } } } /************/ /* Rescue option */ if( rescue == 1 ) { printf( "RESCUE mode\n" ) ; if( ( ftdock_file = fopen( "scratch_parameters.dat" , "r" ) ) == NULL ) { printf( "Could not open scratch_parameters.dat for reading.\nDying\n\n" ) ; exit( EXIT_FAILURE ) ; } calculate = 0 ; default_global_grid_size = "(read from rescue file)" ; default_angle_step = "(read from rescue file)" ; default_surface = "(read from rescue file)" ; default_internal_value = "(read from rescue file)" ; default_electrostatics = "(read from rescue file)" ; while( fgets( line_buffer , 99 , ftdock_file ) ) { if( strncmp( line_buffer , "Static molecule" , 15 ) == 0 ) sscanf( line_buffer , "Static molecule :: %s" , static_file_name ) ; if( strncmp( line_buffer , "Mobile molecule" , 15 ) == 0 ) sscanf( line_buffer , "Mobile molecule :: %s" , mobile_file_name ) ; if( strncmp( line_buffer , "Output file name" , 16 ) == 0 ) sscanf( line_buffer , "Output file name :: %s" , output_file_name ) ; if( strncmp( line_buffer , "Global grid size" , 16 ) == 0 ) sscanf( line_buffer , "Global grid size :: %d" , &global_grid_size ) ; if( strncmp( line_buffer , "Global search angle step" , 24 ) == 0 ) sscanf( line_buffer , "Global search angle step :: %d" , &angle_step ) ; if( strncmp( line_buffer , "Global surface thickness" , 24 ) == 0 ) sscanf( line_buffer , "Global surface thickness :: %f" , &surface ) ; if( strncmp( line_buffer , "Global internal deterrent value" , 31 ) == 0 ) sscanf( line_buffer , "Global internal deterrent value :: %f" , &internal_value ) ; if( strncmp( line_buffer , "Electrostatics :: on" , 44 ) == 0 ) electrostatics = 1 ; if( strncmp( line_buffer , "Electrostatics :: off" , 44 ) == 0 ) electrostatics = 0 ; if( strncmp( line_buffer , "Global keep per rotation" , 25 ) == 0 ) sscanf( line_buffer , "Global keep per rotation :: %d" , &keep_per_rotation ) ; } fclose( ftdock_file ) ; if( ( ftdock_file = fopen( "scratch_scores.dat" , "r" ) ) == NULL ) { printf( "Could not open scratch_scores.dat for reading.\nDying\n\n" ) ; exit( EXIT_FAILURE ) ; } char* r = fgets( line_buffer , 99 , ftdock_file ) ; while( fgets( line_buffer , 99 , ftdock_file ) ) { sscanf( line_buffer , "G_DATA %d " , &first_rotation ) ; } fclose( ftdock_file ) ; first_rotation ++ ; printf( "Will be starting from rotation %d\n" , first_rotation ) ; /************/ } else { first_rotation = 1 ; } /************/ /* Do these things first so that bad inputs will be caught soonest */ /* Read in Structures from pdb files */ Static_Structure = read_pdb_to_structure( static_file_name ) ; Mobile_Structure = read_pdb_to_structure( mobile_file_name ) ; if( Mobile_Structure.length > Static_Structure.length ) { printf( "WARNING\n" ) ; printf( "The mobile molecule has more residues than the static\n" ) ; printf( "Are you sure you have the correct molecules?\n" ) ; printf( "Continuing anyway\n" ) ; } /************/ /* Get angles */ Angles = generate_global_angles( angle_step ) ; printf( "Total number of rotations is %d\n" , Angles.n ) ; /************/ /* Assign charges */ if( electrostatics == 1 ) { printf( "Assigning charges\n" ) ; assign_charges( Static_Structure ) ; assign_charges( Mobile_Structure ) ; } /************/ /* Store new structures centered on Origin */ Origin_Static_Structure = translate_structure_onto_origin( Static_Structure ) ; Origin_Mobile_Structure = translate_structure_onto_origin( Mobile_Structure ) ; /* Free some memory */ for( i = 1 ; i <= Static_Structure.length ; i ++ ) { free( Static_Structure.Residue[i].Atom ) ; } free( Static_Structure.Residue ) ; for( i = 1 ; i <= Mobile_Structure.length ; i ++ ) { free( Mobile_Structure.Residue[i].Atom ) ; } free( Mobile_Structure.Residue ) ; /************/ /* Calculate Grid stuff */ grid_span = total_span_of_structures( Origin_Static_Structure , Origin_Mobile_Structure ) ; if( calculate == 1 ) { printf( "Using automatic calculation for grid size\n" ) ; global_grid_size = (int)( grid_span / reverse_calculated_one_span ) ; if( ( global_grid_size % 2 ) != 0 ) global_grid_size ++ ; } one_span = grid_span / (float)global_grid_size ; printf( "Span = %.3f angstroms\n" , grid_span ) ; printf( "Grid size = %d\n" , global_grid_size ) ; printf( "Each Grid cube = %.5f angstroms\n" , one_span ) ; /************/ /* Memory Allocation */ if( ( Scores = ( struct Score * ) malloc ( ( keep_per_rotation + 2 ) * sizeof( struct Score ) ) ) == NULL ) { GENERAL_MEMORY_PROBLEM } if( ( ( static_grid = ( float * ) malloc ( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL ) || ( ( mobile_grid = ( float * ) malloc ( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL ) || ( ( convoluted_grid = ( float * ) malloc ( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL ) ) { printf( "Not enough memory for surface grids\nUse (sensible) smaller grid size\nDying\n\n" ) ; exit( EXIT_FAILURE ) ; } static_fsg = ( fftwf_complex * ) static_grid ; mobile_fsg = ( fftwf_complex * ) mobile_grid ; multiple_fsg = ( fftwf_complex * ) convoluted_grid ; if( electrostatics == 1 ) { if( ( ( static_elec_grid = ( float * ) malloc ( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL ) || ( ( mobile_elec_grid = ( float * ) malloc ( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL ) || ( ( convoluted_elec_grid = ( float * ) malloc ( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL ) ) { printf( "Not enough memory for electrostatic grids\nSwitch off electrostatics or use (sensible) smaller grid size\nDying\n\n" ) ; exit( EXIT_FAILURE ) ; } else { /* all ok */ printf( "Electrostatics are on\n" ) ; } static_elec_fsg = ( fftwf_complex * ) static_elec_grid ; mobile_elec_fsg = ( fftwf_complex * ) mobile_elec_grid ; multiple_elec_fsg = ( fftwf_complex * ) convoluted_elec_grid ; } /************/ /* Create FFTW plans */ printf( "Creating plans\n" ) ; ps = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , static_grid, (fftwf_complex*)static_grid, FFTW_MEASURE) ; if( electrostatics == 1 ) { pse = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , static_elec_grid, (fftwf_complex*)static_elec_grid, FFTW_MEASURE ) ; } pm = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , mobile_grid, (fftwf_complex*)mobile_grid, FFTW_MEASURE ) ; if (electrostatics == 1) { pme = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , mobile_elec_grid, (fftwf_complex*)mobile_elec_grid, FFTW_MEASURE) ; } pinvs = fftwf_plan_dft_c2r_3d( global_grid_size , global_grid_size , global_grid_size , multiple_fsg, (float*)multiple_fsg, FFTW_MEASURE ) ; if (electrostatics == 1) { pinvse = fftwf_plan_dft_c2r_3d( global_grid_size , global_grid_size , global_grid_size , multiple_elec_fsg, (float*)multiple_elec_fsg, FFTW_MEASURE ) ; } /************/ getrusage(RUSAGE_SELF, &rb); gettimeofday(&tvb, NULL); printf( "Setting up Static Structure\n" ) ; /* Discretise and surface the Static Structure (need do only once) */ discretise_structure( Origin_Static_Structure , grid_span , global_grid_size , static_grid ) ; printf( " surfacing grid\n" ) ; surface_grid( grid_span , global_grid_size , static_grid , surface , internal_value ) ; /* Calculate electic field at all grid nodes (need do only once) */ if( electrostatics == 1 ) { electric_field( Origin_Static_Structure , grid_span , global_grid_size , static_elec_grid ) ; electric_field_zero_core( global_grid_size , static_elec_grid , static_grid , internal_value ) ; } /* Fourier Transform the static grids (need do only once) */ printf( " one time forward FFT calculations\n" ) ; fftwf_execute(ps); if( electrostatics == 1 ) { fftwf_execute(pse); } printf( " done\n" ) ; /************/ /* Store paramaters in case of rescue */ if( ( ftdock_file = fopen( "scratch_parameters.dat" , "w" ) ) == NULL ) { printf( "Could not open scratch_parameters.dat for writing.\nDying\n\n" ) ; exit( EXIT_FAILURE ) ; } fprintf( ftdock_file, "\nGlobal Scan\n" ) ; fprintf( ftdock_file, "\nCommand line controllable values\n" ) ; fprintf( ftdock_file, "Static molecule :: %s\n" , static_file_name ) ; fprintf( ftdock_file, "Mobile molecule :: %s\n" , mobile_file_name ) ; fprintf( ftdock_file, "Output file name :: %s\n" , output_file_name ) ; fprintf( ftdock_file, "\n" ) ; fprintf( ftdock_file, "Global grid size :: %6d %s\n" , global_grid_size , default_global_grid_size ) ; fprintf( ftdock_file, "Global search angle step :: %6d %s\n" , angle_step , default_angle_step ) ; fprintf( ftdock_file, "Global surface thickness :: %9.2f %s\n" , surface , default_surface ) ; fprintf( ftdock_file, "Global internal deterrent value :: %9.2f %s\n" , internal_value , default_internal_value ) ; if( electrostatics == 1 ) { fprintf( ftdock_file, "Electrostatics :: on %s\n" , default_electrostatics ) ; } else { fprintf( ftdock_file, "Electrostatics :: off %s\n" , default_electrostatics ) ; } fprintf( ftdock_file, "Global keep per rotation :: %6d %s\n" , keep_per_rotation , default_keep_per_rotation ) ; fprintf( ftdock_file, "\nCalculated values\n" ) ; fprintf( ftdock_file, "Global rotations :: %6d\n" , Angles.n ) ; fprintf( ftdock_file, "Global total span (angstroms) :: %10.3f\n" , grid_span ) ; fprintf( ftdock_file, "Global grid cell span (angstroms) :: %10.3f\n" , one_span ) ; fclose( ftdock_file ) ; /************/ /* Main program loop */ max_es_value = 0 ; printf( "Starting main loop through the rotations\n" ) ; /* PCA: start comment for( rotation = first_rotation ; rotation <= Angles.n ; rotation ++ ) { * PCA: end comment */ for( rotation = first_rotation ; rotation <= 10/*Angles.n*/ ; rotation ++ ) { printf( "." ) ; if( ( rotation % 50 ) == 0 ) printf( "\nRotation number %5d\n" , rotation ) ; /* Rotate Mobile Structure */ Rotated_at_Origin_Mobile_Structure = rotate_structure( Origin_Mobile_Structure , (int)Angles.z_twist[rotation] , (int)Angles.theta[rotation] , (int)Angles.phi[rotation] ) ; /* Discretise the rotated Mobile Structure */ discretise_structure( Rotated_at_Origin_Mobile_Structure , grid_span , global_grid_size , mobile_grid ) ; /* Electic point charge approximation onto grid calculations ( quicker than filed calculations by a long way! ) */ if( electrostatics == 1 ) { electric_point_charge( Rotated_at_Origin_Mobile_Structure , grid_span , global_grid_size , mobile_elec_grid ) ; } /* Forward Fourier Transforms */ fftwf_execute(pm); if( electrostatics == 1 ) { fftwf_execute(pme); } /************/ /* Do convolution of the two sets of grids convolution is equivalent to multiplication of the complex conjugate of one fourier grid with other (raw) one hence the sign changes from a normal complex number multiplication */ for( fx = 0 ; fx < global_grid_size ; fx ++ ) { for( fy = 0 ; fy < global_grid_size ; fy ++ ) { for( fz = 0 ; fz < global_grid_size/2 + 1 ; fz ++ ) { fxyz = fz + ( global_grid_size/2 + 1 ) * ( fy + global_grid_size * fx ) ; multiple_fsg[fxyz][0] = c_re(static_fsg[fxyz]) * c_re(mobile_fsg[fxyz]) + c_im(static_fsg[fxyz]) * c_im(mobile_fsg[fxyz]) ; multiple_fsg[fxyz][1] = c_im(static_fsg[fxyz]) * c_re(mobile_fsg[fxyz]) - c_re(static_fsg[fxyz]) * c_im(mobile_fsg[fxyz]) ; if( electrostatics == 1 ) { multiple_elec_fsg[fxyz][0] = c_re(static_elec_fsg[fxyz]) * c_re(mobile_elec_fsg[fxyz]) + c_im(static_elec_fsg[fxyz]) * c_im(mobile_elec_fsg[fxyz]) ; multiple_elec_fsg[fxyz][1] = c_im(static_elec_fsg[fxyz]) * c_re(mobile_elec_fsg[fxyz]) - c_re(static_elec_fsg[fxyz]) * c_im(mobile_elec_fsg[fxyz]) ; } } } } /* Reverse Fourier Transform */ fftwf_execute(pinvs); if( electrostatics == 1 ) { fftwf_execute(pinvse); } /************/ /* Get best scores */ for( i = 0 ; i < keep_per_rotation ; i ++ ) { Scores[i].score = 0 ; Scores[i].rpscore = 0.0 ; Scores[i].coord[1] = 0 ; Scores[i].coord[2] = 0 ; Scores[i].coord[3] = 0 ; } for( x = 0 ; x < global_grid_size ; x ++ ) { fx = x ; if( fx > ( global_grid_size / 2 ) ) fx -= global_grid_size ; for( y = 0 ; y < global_grid_size ; y ++ ) { fy = y ; if( fy > ( global_grid_size / 2 ) ) fy -= global_grid_size ; for( z = 0 ; z < global_grid_size ; z ++ ) { fz = z ; if( fz > ( global_grid_size / 2 ) ) fz -= global_grid_size ; xyz = z + ( 2 * ( global_grid_size / 2 + 1 ) ) * ( y + global_grid_size * x ) ; if( ( electrostatics == 0 ) || ( convoluted_elec_grid[xyz] < 0 ) ) { /* Scale factor from FFTs */ if( (int)convoluted_grid[xyz] != 0 ) { convoluted_grid[xyz] /= ( global_grid_size * global_grid_size * global_grid_size ) ; } if( (int)convoluted_grid[xyz] > Scores[keep_per_rotation-1].score ) { i = keep_per_rotation - 2 ; while( ( (int)convoluted_grid[xyz] > Scores[i].score ) && ( i >= 0 ) ) { Scores[i+1].score = Scores[i].score ; Scores[i+1].rpscore = Scores[i].rpscore ; Scores[i+1].coord[1] = Scores[i].coord[1] ; Scores[i+1].coord[2] = Scores[i].coord[2] ; Scores[i+1].coord[3] = Scores[i].coord[3] ; i -- ; } Scores[i+1].score = (int)convoluted_grid[xyz] ; if( ( electrostatics != 0 ) && ( convoluted_elec_grid[xyz] < 0.1 ) ) { Scores[i+1].rpscore = (float)convoluted_elec_grid[xyz] ; } else { Scores[i+1].rpscore = (float)0 ; } Scores[i+1].coord[1] = fx ; Scores[i+1].coord[2] = fy ; Scores[i+1].coord[3] = fz ; } } } } } if( rotation == 1 ) { if( ( ftdock_file = fopen( "scratch_scores.dat" , "w" ) ) == NULL ) { printf( "Could not open scratch_scores.dat for writing.\nDying\n\n" ) ; exit( EXIT_FAILURE ) ; } } else { if( ( ftdock_file = fopen( "scratch_scores.dat" , "a" ) ) == NULL ) { printf( "Could not open scratch_scores.dat for writing.\nDying\n\n" ) ; exit( EXIT_FAILURE ) ; } } for( i = 0 ; i < keep_per_rotation ; i ++ ) { max_es_value = min( max_es_value , Scores[i].rpscore ) ; /* PCA: start comment fprintf( ftdock_file, "G_DATA %6d %6d %7d %.0f %4d %4d %4d %4d%4d%4d\n" , rotation , 0 , Scores[i].score , (float)Scores[i].rpscore , Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3 ] , Angles.z_twist[rotation] , Angles.theta[rotation] , Angles.phi[rotation] ) ; * PCA: Stop comment */ fprintf( stdout, "G_DATA %6d %6d %7d %4d %4d %4d %4d%4d%4d\n" , rotation , 0 , Scores[i].score , Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3 ] , Angles.z_twist[rotation] , Angles.theta[rotation] , Angles.phi[rotation] ) ; } fclose( ftdock_file ) ; /* Free some memory */ for( i = 1 ; i <= Rotated_at_Origin_Mobile_Structure.length ; i ++ ) { free( Rotated_at_Origin_Mobile_Structure.Residue[i].Atom ) ; } free( Rotated_at_Origin_Mobile_Structure.Residue ) ; } /* Finished main loop */ /************/ /* Free the memory */ fftwf_destroy_plan( ps ) ; fftwf_destroy_plan( pse ) ; fftwf_destroy_plan( pm ) ; fftwf_destroy_plan( pme ) ; fftwf_destroy_plan( pinvs ) ; fftwf_destroy_plan( pinvse ) ; free( static_grid ) ; free( mobile_grid ) ; free( convoluted_grid ) ; if( electrostatics == 1 ) { free( static_elec_grid ) ; free( mobile_elec_grid ) ; free( convoluted_elec_grid ) ; } for( i = 1 ; i <= Origin_Static_Structure.length ; i ++ ) { free( Origin_Static_Structure.Residue[i].Atom ) ; } free( Origin_Static_Structure.Residue ) ; for( i = 1 ; i <= Origin_Mobile_Structure.length ; i ++ ) { free( Origin_Mobile_Structure.Residue[i].Atom ) ; } free( Origin_Mobile_Structure.Residue ) ; /* PCA: Finishing programm here*/ getrusage(RUSAGE_SELF, &ra); gettimeofday(&tva, NULL); struct timeval usertimea = ra.ru_utime; struct timeval systimea = ra.ru_stime; unsigned long long usera = usertimea.tv_sec*1e6 + usertimea.tv_usec; unsigned long long sysa = systimea.tv_sec*1e6 + systimea.tv_usec; struct timeval usertimeb = rb.ru_utime; struct timeval systimeb = rb.ru_stime; unsigned long long userb = usertimeb.tv_sec*1e6 + usertimeb.tv_usec; unsigned long long sysb = systimeb.tv_sec*1e6 + systimeb.tv_usec; unsigned long long user = usera - userb; unsigned long long sys = sysa - sysb; unsigned long long mem_max = ra.ru_maxrss; unsigned long long elapsed = (tva.tv_sec - tvb.tv_sec)*1e6 + (tva.tv_usec - tvb.tv_usec); fprintf(stderr, "{ \"elapsed\": %llu, \"user\": %llu, \"sys\": %llu, \"mem_max\": %llu }", elapsed, user, sys, mem_max); return 0; /* PCA: */ /************/ /* Read in all the scores */ printf( "\nReloading all the scores\n" ) ; if( ( ftdock_file = fopen( "scratch_scores.dat" , "r" ) ) == NULL ) { printf( "Could not open scratch_scores.dat for reading.\nDying\n\n" ) ; exit( EXIT_FAILURE ) ; } if( ( Scores = ( struct Score * ) realloc ( Scores , ( 1 + keep_per_rotation ) * Angles.n * sizeof( struct Score ) ) ) == NULL ) { printf( "Not enough memory left for storing scores\nProbably keeping too many per rotation\nDying\n\n" ) ; exit( EXIT_FAILURE ) ; } kept_scores = 0 ; while( fgets( line_buffer , 99 , ftdock_file ) ) { sscanf( line_buffer , "G_DATA %d %d %d %f %d %d %d %d %d %d" , &id , &id2 , &SCscore , &RPscore , &x , &y , &z , &z_twist , &theta , &phi ) ; Scores[kept_scores].score = SCscore ; Scores[kept_scores].rpscore = RPscore ; Scores[kept_scores].coord[1] = x ; Scores[kept_scores].coord[2] = y ; Scores[kept_scores].coord[3] = z ; Scores[kept_scores].angle[1] = z_twist ; Scores[kept_scores].angle[2] = theta ; Scores[kept_scores].angle[3] = phi ; kept_scores ++ ; } fclose( ftdock_file ) ; kept_scores -- ; qsort_scores( Scores , 0 , kept_scores ) ; /************/ /* Writing data file */ if( ( ftdock_file = fopen( output_file_name , "w" ) ) == NULL ) { printf( "Could not open %s for writing.\nDying\n\n" , output_file_name ) ; exit( EXIT_FAILURE ) ; } fprintf( ftdock_file, "FTDOCK data file\n" ) ; fprintf( ftdock_file, "\nGlobal Scan\n" ) ; fprintf( ftdock_file, "\nCommand line controllable values\n" ) ; fprintf( ftdock_file, "Static molecule :: %s\n" , static_file_name ) ; fprintf( ftdock_file, "Mobile molecule :: %s\n" , mobile_file_name ) ; fprintf( ftdock_file, "\n" ) ; fprintf( ftdock_file, "Global grid size :: %6d %s\n" , global_grid_size , default_global_grid_size ) ; fprintf( ftdock_file, "Global search angle step :: %6d %s\n" , angle_step , default_angle_step ) ; fprintf( ftdock_file, "Global surface thickness :: %9.2f %s\n" , surface , default_surface ) ; fprintf( ftdock_file, "Global internal deterrent value :: %9.2f %s\n" , internal_value , default_internal_value ) ; if( electrostatics == 1 ) { fprintf( ftdock_file, "Electrostatics :: on %s\n" , default_electrostatics ) ; } else { fprintf( ftdock_file, "Electrostatics :: off %s\n" , default_electrostatics ) ; } fprintf( ftdock_file, "Global keep per rotation :: %6d %s\n" , keep_per_rotation , default_keep_per_rotation ) ; fprintf( ftdock_file, "\nCalculated values\n" ) ; fprintf( ftdock_file, "Global rotations :: %6d\n" , Angles.n ) ; fprintf( ftdock_file, "Global total span (angstroms) :: %10.3f\n" , grid_span ) ; fprintf( ftdock_file, "Global grid cell span (angstroms) :: %10.3f\n" , one_span ) ; fprintf( ftdock_file, "\nData\n" ) ; fprintf( ftdock_file , "Type ID prvID SCscore ESratio Coordinates Angles\n\n" ) ; if( electrostatics == 1 ) { for( i = 0 ; i <= min( kept_scores , ( NUMBER_TO_KEEP - 1 ) ) ; i ++ ) { fprintf( ftdock_file, "G_DATA %6d %6d %7d %8.3f %4d %4d %4d %4d%4d%4d\n" , i + 1 , 0 , Scores[i].score , 100 * ( Scores[i].rpscore / max_es_value ) , Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3] , Scores[i].angle[1] , Scores[i].angle[2] , Scores[i].angle[3] ) ; } } else { for( i = 0 ; i <= min( kept_scores , ( NUMBER_TO_KEEP - 1 ) ) ; i ++ ) { fprintf( ftdock_file, "G_DATA %6d %6d %7d %8.3f %4d %4d %4d %4d%4d%4d\n" , i + 1 , 0 , Scores[i].score , 0.0 , Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3] , Scores[i].angle[1] , Scores[i].angle[2] , Scores[i].angle[3] ) ; } } fclose( ftdock_file ) ; /************/ printf( "\n\nFinished\n\n" ) ; return( 0 ) ; } /* end main */