void Grid::initialize(MPI_Comm comm, int nx_, int ny_, int nz_) { nx = nx_; ny = ny_; nz = nz_; fft_plan = rfftw3d_mpi_create_plan(comm, nx, ny, nz, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE); ifft_plan = rfftw3d_mpi_create_plan(comm, nx, ny, nz, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE); rfftwnd_mpi_local_sizes(fft_plan, &nxloc, &ixmin, &nyloc_t, &iymin_t, &local_size); #else void Grid::initialize(int nx_, int ny_, int nz_) { nx = nx_; ny = ny_; nz = nz_; rfftwnd_plan plan = rfftw3d_create_plan(nx, ny, nz, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE | FFTW_IN_PLACE); rfftwnd_plan iplan = rfftw3d_create_plan(nx, ny, nz, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE | FFTW_IN_PLACE); nxloc = nx; nyloc_t = ny; ixmin = iymin_t = 0; local_size = nx * ny * 2*(nz/2+1); #endif // HAVE_MPI /* Allocate extra storage so that each process can hold the boundary * layer from the adjacent process */ assert(local_size == nxloc*ny*2*(nz/2+1)); local_size = (nxloc+1)*ny*2*(nz/2+1); data = (fftw_real*) malloc(local_size*sizeof(fftw_real)); }
void F77_FUNC_(rfftw3d_f77_create_plan,RFFTW3D_F77_CREATE_PLAN) (fftwnd_plan *p, int *nx, int *ny, int *nz, int *idir, int *flags) { fftw_direction dir = *idir < 0 ? FFTW_FORWARD : FFTW_BACKWARD; *p = rfftw3d_create_plan(*nz,*ny,*nx,dir,*flags); }
sararfftnd_plan sararfft3d_create_plan( int nx, int ny, int nz, sarafft_direction dir ) { #ifdef USE_GPUS sararfftnd_plan plan; cufftResult result = cufftPlan3d( &plan, nx, ny, nz, dir ); if( CUFFT_SUCCESS != result ) exit(64); // TODO better error handling (but to do that, the caller must be rewritten) return plan; #else // #ifndef USE_GPUS return rfftw3d_create_plan( nx, ny, nz, dir, FFTW_MEASURE | FFTW_IN_PLACE ); #endif }
int gmx_fft_init_3d_real(gmx_fft_t * pfft, int nx, int ny, int nz, enum gmx_fft_flag flags) { int i,j; gmx_fft_t fft; int fftw_flags; /* FFTW2 is slow to measure, so we do not use it */ /* If you change this, add an #ifndef for GMX_DISABLE_FFTW_MEASURE around it! */ fftw_flags = FFTW_ESTIMATE; if(pfft==NULL) { gmx_fatal(FARGS,"Invalid opaque FFT datatype pointer."); return EINVAL; } *pfft = NULL; if( (fft = (gmx_fft_t)malloc(sizeof(struct gmx_fft))) == NULL) { return ENOMEM; } fft->single[0][0] = NULL; fft->single[0][1] = NULL; fft->single[1][0] = NULL; fft->single[1][1] = NULL; fft->multi[0][0] = rfftw3d_create_plan(nx,ny,nz,FFTW_COMPLEX_TO_REAL,FFTW_OUT_OF_PLACE|fftw_flags); fft->multi[0][1] = rfftw3d_create_plan(nx,ny,nz,FFTW_REAL_TO_COMPLEX,FFTW_OUT_OF_PLACE|fftw_flags); fft->multi[1][0] = rfftw3d_create_plan(nx,ny,nz,FFTW_COMPLEX_TO_REAL,FFTW_IN_PLACE|fftw_flags); fft->multi[1][1] = rfftw3d_create_plan(nx,ny,nz,FFTW_REAL_TO_COMPLEX,FFTW_IN_PLACE|fftw_flags); for(i=0;i<2;i++) { for(j=0;j<2;j++) { if(fft->multi[i][j] == NULL) { gmx_fatal(FARGS,"Error initializing FFTW2 plan."); gmx_fft_destroy(fft); return -1; } } } /* FFTW2 overwrites the input when doing out-of-place complex-to-real FFTs. * This is not acceptable for the Gromacs interface, so we define a * work array and copy the data there before doing complex-to-real FFTs. */ fft->work = (real *)malloc(sizeof(real)*( nx*ny*(nz/2 + 1)*2) ); if(fft->work == NULL) { gmx_fatal(FARGS,"Cannot allocate complex-to-real FFT workspace."); gmx_fft_destroy(fft); return ENOMEM; } fft->ndim = 3; fft->nx = nx; fft->ny = ny; fft->nz = nz; *pfft = fft; return 0; }
/*! This routines generates the FFTW-plans to carry out the parallel FFTs * later on. Some auxiliary variables are also initialized. */ void pm_init_periodic(void) { int i; int slab_to_task_local[PMGRID]; All.Asmth[0] = ASMTH * All.BoxSize / PMGRID; All.Rcut[0] = RCUT * All.Asmth[0]; /* Set up the FFTW plan files. */ #ifndef NOMPI fft_forward_plan = rfftw3d_mpi_create_plan(MPI_COMM_WORLD, PMGRID, PMGRID, PMGRID, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE | FFTW_IN_PLACE); fft_inverse_plan = rfftw3d_mpi_create_plan(MPI_COMM_WORLD, PMGRID, PMGRID, PMGRID, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE | FFTW_IN_PLACE); #else fft_forward_plan = rfftw3d_create_plan(PMGRID, PMGRID, PMGRID, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE | FFTW_IN_PLACE); fft_inverse_plan = rfftw3d_create_plan(PMGRID, PMGRID, PMGRID, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE | FFTW_IN_PLACE); #endif /* Workspace out the ranges on each processor. */ rfftwnd_mpi_local_sizes(fft_forward_plan, &nslab_x, &slabstart_x, &nslab_y, &slabstart_y, &fftsize); for(i = 0; i < PMGRID; i++) slab_to_task_local[i] = 0; for(i = 0; i < nslab_x; i++) slab_to_task_local[slabstart_x + i] = ThisTask; slabs_per_task = malloc(NTask * sizeof(int)); #ifndef NOMPI MPI_Allreduce(slab_to_task_local, slab_to_task, PMGRID, MPI_INT, MPI_SUM, MPI_COMM_WORLD); MPI_Allreduce(&nslab_x, &smallest_slab, 1, MPI_INT, MPI_MIN, MPI_COMM_WORLD); MPI_Allgather(&nslab_x, 1, MPI_INT, slabs_per_task, 1, MPI_INT, MPI_COMM_WORLD); #else slab_to_task = slab_to_task_local; smallest_slab = nslab_x; slabs_per_task[0] = nslab_x; #endif if(ThisTask == 0) { for(i = 0; i < NTask; i++) printf("Task=%d FFT-Slabs=%d\n", i, slabs_per_task[i]); } first_slab_of_task = malloc(NTask * sizeof(int)); MPI_Allgather(&slabstart_x, 1, MPI_INT, first_slab_of_task, 1, MPI_INT, MPI_COMM_WORLD); meshmin_list = malloc(3 * NTask * sizeof(int)); meshmax_list = malloc(3 * NTask * sizeof(int)); to_slab_fac = PMGRID / All.BoxSize; #ifndef NOMPI MPI_Allreduce(&fftsize, &maxfftsize, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD); #else maxfftsize = fftsize; #endif }
int main() { omp_set_num_threads(numCores); // Set the number of threads for OpenMP parallel sections fftw_threads_init(); // Initialize threaded FFTs rfftwnd_plan dp_c2r; // Inverse FFT plan rfftwnd_plan dp_r2c; // Forward FFT plan // Create the plans using FFTW_MEASURE to get fastest transforms, do this here so // that it is only done once and the plans reused. std::cout << "Creating FFTW plans...\n"; dp_c2r = rfftw3d_create_plan(N, N, N, FFTW_COMPLEX_TO_REAL, FFTW_MEASURE); dp_r2c = rfftw3d_create_plan(N, N, N, FFTW_REAL_TO_COMPLEX, FFTW_MEASURE); double *kvec = new double[N]; fftfreq(kvec); std::ofstream fout; std::ofstream tout; std::ifstream fin; fout.open("GalaxyNum.dat",std::ios::out); fout.close(); std::vector< Pk > InputPower; int numKModes = 0; std::cout << "Reading input power file: " << CAMBfile << "\n"; fin.open(CAMBfile.c_str(),std::ios::in); while (!fin.eof()) { Pk Input_temp; fin >> Input_temp.k >> Input_temp.P; if (!fin.eof()) { InputPower.push_back(Input_temp); ++numKModes; } } fin.close(); double *kvals = new double[numKModes]; double *InPow = new double[numKModes]; for (int i = 0; i < numKModes; ++i) { kvals[i] = InputPower[i].k; InPow[i] = InputPower[i].P; } gsl_spline *Power = gsl_spline_alloc(gsl_interp_cspline, numKModes); gsl_interp_accel *acc = gsl_interp_accel_alloc(); gsl_spline_init(Power, kvals, InPow, numKModes); fftw_complex *deltak3di = new fftw_complex[N_im]; fftw_real *deltar3di = new fftw_real[N_tot]; #pragma omp parallel for for (int i = 0; i < N_tot; ++i) { deltar3di[i] = 0.0; if (i < N_im) { deltak3di[i].re = 0.0; deltak3di[i].im = 0.0; } } std::cout << "Distributing power over volume...\n"; Gendk(kvec, Power, acc, deltak3di); // Call function to populate the power grid std::cout << "Performing initial one-time inverse FFT...\n"; rfftwnd_threads_one_complex_to_real(numCores,dp_c2r,deltak3di,deltar3di); // FFT std::cout << "Taking the natural log...\n"; #pragma omp parallel for for (int i = 0; i < N_tot; ++i) { deltar3di[i] = log(1.0 + deltar3di[i]); if (i < N_im) { deltak3di[i].re = 0.0; deltak3di[i].im = 0.0; } } std::cout << "Performing initial one-time forward FFT...\n"; rfftwnd_threads_one_real_to_complex(numCores,dp_r2c,deltar3di,deltak3di); std::cout << "Normalizing...\n"; #pragma omp parallel for for (int i = 0; i < N_im; ++i) { deltak3di[i].re /= N_tot; deltak3di[i].im /= N_tot; } delete[] deltar3di; tout.open("Timings.dat",std::ios::out); std::cout << "Starting to generate mocks...\n"; for (int mock = startNum-1; mock < numMocks; ++mock) { double start_time = omp_get_wtime(); std::string lrgfile = filename(base, mock+1, ext); std::cout << "Generating mock " << lrgfile << "\n"; fftw_complex *deltak3d = new fftw_complex[N_im]; fftw_real *deltar3d = new fftw_real[N_tot]; // Initialize power array. Do it in parallel to speed things up. #pragma omp parallel for for (int i = 0; i < N_tot; ++i) { deltar3d[i] = 0.0; if (i < N_im) { deltak3d[i].re = 0.0; deltak3d[i].im = 0.0; } } std::cout << " Setting up for the inverse FFT...\n"; Sampdk(kvec, deltak3di, deltak3d); if (powOut) { std::cout << " Outputting raw power array...\n"; std::string powerfile = filename(powbase, mock+1, extbin); fout.open(powerfile.c_str(),std::ios::out|std::ios::binary); fout.write((char *) deltak3d, N_im*sizeof(fftw_complex)); fout.close(); } std::cout << " Performing second inverse FFT...\n"; rfftwnd_threads_one_complex_to_real(numCores,dp_c2r,deltak3d,deltar3d); if (matOut) { std::cout << " Outputting matter field array...\n"; std::string matterfile = filename(matbase, mock+1, extbin); fout.open(matterfile.c_str(),std::ios::out|std::ios::binary); fout.write((char *) deltar3d, N_tot*sizeof(fftw_real)); fout.close(); } double mean = 0.0; double variance = 0.0; double dr_max = 0.0; double dr_min = 0.0; for (int i = 0; i < N_tot; ++i) { mean += deltar3d[i]/N_tot; if (deltar3d[i] > dr_max) dr_max = deltar3d[i]; if (deltar3d[i] < dr_min) dr_min = deltar3d[i]; } std::cout << " Max = " << dr_max << "\n"; std::cout << " Min = " << dr_min << "\n"; std::cout << " Mean = " << mean << "\n"; std::cout << " Calculating variance...\n"; for (int i = 0; i < N_tot; ++i) { deltar3d[i] -= mean; variance += (deltar3d[i])*(deltar3d[i])/(N_tot-1); } std::cout << " Poisson sampling...\n"; Gendr(lrgfile, variance, deltar3d); delete[] deltak3d; delete[] deltar3d; double totaltime = omp_get_wtime()-start_time; std::cout << " Time to generate mock: " << totaltime << " seconds\n"; tout << lrgfile << " " << totaltime << "\n"; } tout.close(); delete[] kvec; delete[] deltak3di; delete[] kvals; delete[] InPow; rfftwnd_destroy_plan(dp_r2c); rfftwnd_destroy_plan(dp_c2r); gsl_spline_free(Power); gsl_interp_accel_free(acc); return 0; }
main (int argc, char *argv[]) { struct em_file inputdata1; struct em_file inputdata2; struct em_file inputdata3; struct em_file inputdata4; struct em_file outputdata; fftw_real *Vol_tmpl_sort, *Volume, *e3, *PointCorr, *sqconv; fftw_complex *C3, *PointVolume, *PointSq; rfftwnd_plan p3, pi3, r3, ri3; fftw_real scale; struct tm *zeit; struct tm start; char name[200]; int Rx_max, Ry_max, Rz_max; int Rx_min, Ry_min, Rz_min; int Vx_min, Vy_min, Vz_min; int Vx_max, Vy_max, Vz_max; float Phi, Psi, Theta, winkel_lauf; float *Rot_tmpl, *Vol_tmpl; int i, j, k, tmpx, tmpy, tmpz,lauf_pe, ksub; int ijk; int lauf, n; float max, eps; time_t lt; float Ctmp, Ctmpim, Dtmp, Dtmpim; int dim_fft; int sub[3],range[3],range_sub[3],subc[3],offset[3],dimarray[3]; int FullVolume_dims[3]; int nr[3]; int area[3]; /* MPI Variablen */ int winkel_max, winkel_min; int winkel_max_pe, winkel_min_pe; int winkel_step_pe; int Phi_max, Psi_max, Theta_max; int Phi_min, Psi_min, Theta_min; int Phi_step, Psi_step, Theta_step; int Theta_winkel_start, Psi_winkel_start, Phi_winkel_start; int Theta_winkel_nr, Psi_winkel_nr, Phi_winkel_nr; int Theta_winkel_end, Psi_winkel_end, Phi_winkel_end; int Theta_steps, Psi_steps, Phi_steps; float Theta_winkel_rest_nr, Psi_winkel_rest_nr, Phi_winkel_rest_nr; int in_max; float rms_wedge, tempccf; float *Ergebnis, *conv; float cycles; int cycle; /* MPI Variablen Ende*/ if (argc < 15) { printf ("\n\n"); printf (" 'OSCAR' is an Optimized SCanning AlgoRithm for \n"); printf (" local correlation.\n"); printf (" All files in EM-V-int4 format !!!\n\n"); printf (" Input: Volume to be searched, Template mask for local \n "); printf (" correlation, pointspread function and angular search \n"); printf (" range. \n"); printf (" Output: locally normalized X-Correlation Function Out.ccf.norm, \n"); printf (" non-normalized X-Correlation Function Out.ccf, and Out.ang \n"); printf (" with the corresponding angles.\n\n"); printf (" usage: oscar Volume Template Out ...\n"); printf (" ... Phi_min Phi_max Phi_step Psi_min Psi_max Psi_step The_min The_max The_step\n"); printf (" ... Poinspread-function mask-file dim_of_fft\n\n"); printf (" with Message Passing Interface (MPI)\n"); printf (" the total number of angles must be modulo\n"); printf (" of used processors!\n\n"); printf (" Linux: 1.'lamboot' to start MPI\n"); printf (" 2.'mpirun -np 2 oscar Volume Templ Out 30 180 30 30 180 30 30 180 30 Poinspread-function mask-file 256'\n\n"); printf (" In this version asymmetric masks can be used ! \n"); printf (" last revision , 11.11.03, Friedrich Foerster"); printf (" \n\n"); exit (1); } MPI_Init (&argc, &argv); MPI_Comm_size (MPI_COMM_WORLD, &mysize); MPI_Comm_rank (MPI_COMM_WORLD, &myrank); /* Dimensionen auslesen */ // Dimension of fft dim_fft = atoi (argv[15]); nr[0]=1; nr[1]=1; nr[2]=1; area[0]=dim_fft; area[1]=dim_fft; area[2]=dim_fft; read_em_header(argv[1], &inputdata1); /* Searchvolume */ read_em (argv[2], &inputdata2); /* Template */ FullVolume_dims[0]=inputdata1.dims[0]; FullVolume_dims[1]=inputdata1.dims[1]; FullVolume_dims[2]=inputdata1.dims[2]; Rx_min = 1; Ry_min = 1; Rz_min = 1; Rx_max = (inputdata2.dims[0]); Ry_max = (inputdata2.dims[1]); Rz_max = (inputdata2.dims[2]); Vx_min = 1; Vy_min = 1; Vz_min = 1; Vx_max = dim_fft; Vy_max = dim_fft; Vz_max = dim_fft; p3 = rfftw3d_create_plan (Vx_max, Vy_max, Vz_max, FFTW_REAL_TO_COMPLEX, FFTW_MEASURE | FFTW_IN_PLACE); /*FFTW_ESTIMATE FFTW_MEASURE */ pi3 = rfftw3d_create_plan (Vx_max, Vy_max, Vz_max, FFTW_COMPLEX_TO_REAL, FFTW_MEASURE | FFTW_IN_PLACE); r3 = rfftw3d_create_plan (Rx_max, Rx_max, Rx_max, FFTW_REAL_TO_COMPLEX, FFTW_MEASURE | FFTW_IN_PLACE); /*FFTW_ESTIMATE FFTW_MEASURE */ ri3 = rfftw3d_create_plan (Rx_max, Rx_max, Rx_max, FFTW_COMPLEX_TO_REAL, FFTW_MEASURE | FFTW_IN_PLACE); if (myrank == 0) { printf("Plans for FFTW created \n");fflush(stdout); } Volume = (fftw_real *) calloc (Vx_max * Vx_max * 2 * (Vx_max / 2 + 1),sizeof (fftw_real) ); Rot_tmpl = (float *) malloc (sizeof (float) * Rx_max * Ry_max * Rz_max); Vol_tmpl = (float *) malloc (sizeof (float) * Vx_max * Vy_max * Vz_max); conv = (float *) malloc (sizeof (float) * Vx_max * Vy_max * Vz_max); sqconv = (fftw_real *) calloc(Vz_max * Vy_max * 2 * (Vx_max / 2 + 1), sizeof (fftw_real)); if (! (inputdata1.floatdata = (float *) malloc (sizeof (float) * Vx_max * Vy_max * Vz_max))) { printf ("Memory allocation failure in inputdata1.floatdata!!!"); fflush (stdout); exit (1); } if (! (outputdata.floatdata = (float *) malloc (sizeof (float) * Vx_max * Vy_max * Vz_max))) { printf ("Memory allocation failure in outputdata.floatdata!!!"); fflush (stdout); exit (1); } if (! (Vol_tmpl_sort = (fftw_real *) calloc (Vz_max*Vy_max*2*(Vx_max / 2 + 1), sizeof (fftw_real) ))) { printf ("Memory allocation failure in Volume_tmpl_sort!!!"); printf ("Nx = %i, Ny = %i, Nz = %i, bytes = %i \n",2 *(Vx_max / 2 + 1),Vy_max, Vz_max, sizeof (fftw_real)); fflush (stdout); exit (1); } Ergebnis = (float *) calloc (Vz_max * Vy_max * Vx_max, sizeof (float)); /* Winkelraum */ Phi_min = atof (argv[4]); Phi_max = atof (argv[5]); Phi_step = atof (argv[6]); Psi_min = atof (argv[7]); Psi_max = atof (argv[8]); Psi_step = atof (argv[9]); Theta_min = atof (argv[10]); Theta_max = atof (argv[11]); Theta_step = atof (argv[12]); /* Pointspread Function*/ read_em (argv[13], &inputdata3); /* mask function */ read_em (argv[14], &inputdata4); Phi_steps = (Phi_max - Phi_min) / Phi_step + 1; Psi_steps = (Psi_max - Psi_min) / Psi_step + 1; Theta_steps = (Theta_max - Theta_min) / Theta_step + 1; winkel_max = Phi_steps * Psi_steps * Theta_steps; winkel_min = 0; range[0]=dim_fft-1; range[1]=dim_fft-1; range[2]=dim_fft-1; range_sub[0]=range[0]-Rx_max; range_sub[1]=range[1]-Rx_max; range_sub[2]=range[2]-Rx_max; sub[0]=1; sub[1]=1; sub[2]=1; cycles=(int)(FullVolume_dims[2]/(dim_fft-Rx_max)+0.5); cycles=(int)(FullVolume_dims[1]/(dim_fft-Rx_max)+0.5)*cycles; cycles=(int)(FullVolume_dims[0]/(dim_fft-Rx_max)+0.5)*cycles; cycle=0; if (myrank == 0) { printf ("\n oscar starts to run ... ");tack (&start);fflush (stdout); /* prepare Output */ strcpy (name, argv[3]); strcat (name, ".ccf"); printf ("\nCreate outputfile: %s ... \n", name);fflush(stdout); create_em (name, FullVolume_dims); strcpy (name, argv[3]); strcat (name, ".ang"); printf ("Create outputfile: %s ... \n", name);fflush(stdout); create_em (name, FullVolume_dims); strcpy (name, argv[3]); strcat (name, ".ccf.norm"); printf ("Create outputfile: %s ... \n", name);fflush(stdout); create_em (name, FullVolume_dims); } for (sub[2]=1; sub[2] < FullVolume_dims[2]-Rz_max;sub[2]=sub[2]+dim_fft-Rz_max) { if (myrank == 0) { tack (&start); printf ("%f%%..", (float) (cycle / cycles * 100)); fflush (stdout); } for (sub[1]=1; sub[1] < FullVolume_dims[1]-Ry_max;sub[1]=sub[1]+dim_fft-Ry_max) { for (sub[0]=1; sub[0] < FullVolume_dims[0]-Rx_max;sub[0]=sub[0]+dim_fft-Rx_max) { cycle=cycle+1; subc[0]=sub[0]; subc[1]=sub[1]; subc[2]=sub[2]; if (sub[2] + range[2] > FullVolume_dims[2]) subc[2]=FullVolume_dims[2]-range[2]; /* we are at the corner ?!*/ if (sub[1] + range[1] > FullVolume_dims[1]) subc[1]=FullVolume_dims[1]-range[1]; /* we are at the corner ?!*/ if (sub[0] + range[0] > FullVolume_dims[0]) subc[0]=FullVolume_dims[0]-range[0]; /* we are at the corner ?!*/ read_em_subregion (argv[1], &inputdata1,subc,range); read_em_subregion (argv[1], &outputdata,subc,range); /* Umsortieren der Daten */ lauf = 0; for (k = 0; k < Vz_max; k++) { for (j = 0; j < Vy_max; j++) { for (i = 0; i < Vx_max; i++) { /* square - needed for normalization */ sqconv[i + 2 * (Vx_max / 2 + 1) * (j + Vy_max * k)] = inputdata1.floatdata[lauf]*inputdata1.floatdata[lauf]; Volume[i + 2 * (Vx_max / 2 + 1) * (j + Vy_max * k)] = inputdata1.floatdata[lauf]; inputdata1.floatdata[lauf] = -1.0; /* kleine Zahl wg Max-Op , hier kommen die CCFs rein*/ outputdata.floatdata[lauf] = -1.0; /* hier kommen die Winkel rein*/ lauf++; } } } rfftwnd_one_real_to_complex (p3, &Volume[0], NULL); /* einmalige fft von Suchvolumen */ rfftwnd_one_real_to_complex (p3, &sqconv[0], NULL); /* FFT of square*/ winkel_step_pe = (int) winkel_max / mysize; winkel_min_pe = myrank * winkel_step_pe; winkel_max_pe = winkel_min_pe + winkel_step_pe; Theta_winkel_nr = (int) winkel_min_pe / (Psi_steps * Phi_steps); Theta_winkel_rest_nr = winkel_min_pe - Theta_winkel_nr * (Psi_steps * Phi_steps); Psi_winkel_nr = (int) Theta_winkel_rest_nr / (Phi_steps); Psi_winkel_rest_nr = Theta_winkel_rest_nr - Psi_winkel_nr * (Phi_steps); Phi_winkel_nr = (int) Psi_winkel_rest_nr; Theta = Theta_winkel_nr * Theta_step + Theta_min; Phi = Phi_winkel_nr * Phi_step + Phi_min - Phi_step; Psi = Psi_winkel_nr * Psi_step + Psi_min; eps = 0.001; n = 0; //Friedrich -> Zaehlung der voxels n = countvoxel(inputdata4.dims[0], inputdata4.floatdata, eps); eps = 0.001; for (winkel_lauf = winkel_min_pe; winkel_lauf < winkel_max_pe;winkel_lauf++) { if (Phi < Phi_max) Phi = Phi + Phi_step; else { Phi = Phi_min; Psi = Psi + Psi_step; } if (Psi > Psi_max) { Psi = Psi_min; Theta = Theta + Theta_step; } tom_rotate3d (&Rot_tmpl[0], &inputdata2.floatdata[0], Phi, Psi, Theta, Rx_max, Ry_max, Rz_max); /*calculate Ref variance */ rms_wedge = energizer (Rx_min, Rx_max, n, &Rot_tmpl[0], &inputdata3.floatdata[0], &inputdata4.floatdata[0], r3, ri3); pastes (&Rot_tmpl[0], &Vol_tmpl[0], 1, 1, 1, Rx_max, Ry_max, Rz_max, Vx_max); scale = 1.0 / ((double)Vx_max * (double)Vy_max * (double)Vz_max * ((double) rms_wedge) ); //printf("hippo1: scale = %.10f \n",scale); sort4fftw(&Vol_tmpl_sort[0],&Vol_tmpl[0],Vx_max, Vy_max, Vz_max); rfftwnd_one_real_to_complex (p3, &Vol_tmpl_sort[0], NULL); PointVolume = (fftw_complex *) & Volume[0]; C3 = (fftw_complex *) & Vol_tmpl_sort[0]; /* Correlation */ correl(&PointVolume[0], &C3[0], Vx_max, Vy_max, Vz_max, scale); /* back to real space */ rfftwnd_one_complex_to_real (pi3, &C3[0], NULL); PointCorr = (fftw_real *) & C3[0]; /* Umsortieren der Daten */ sortback4fftw( &PointCorr[0], &Ergebnis[0], Vx_max, Vy_max, Vz_max); // crossen cross(&Ergebnis[0], Vx_max); /* 3rd: divide */ lauf = 0; for (k = 0 ; k < Vz_max ; k++) { for (j = 0; j < Vy_max; j++) { for (i = 0; i < Vx_max; i++) { if (inputdata1.floatdata[lauf] < Ergebnis[lauf] ) { inputdata1.floatdata[lauf] = Ergebnis[lauf]; outputdata.floatdata[lauf] = (int) winkel_lauf; } lauf++; } } } } /* Ende winkel_lauf */ //FF MPI_Barrier (MPI_COMM_WORLD); /* Ergebnisse einsammeln (myrank 0)*/ if (myrank == 0) { for (lauf_pe = 1; lauf_pe < mysize; lauf_pe++) { MPI_Recv (&Ergebnis[0], Vx_max * Vy_max * Vz_max, MPI_FLOAT, lauf_pe, 99, MPI_COMM_WORLD, &status); MPI_Recv (&conv[0], Vx_max * Vy_max * Vz_max, MPI_FLOAT, lauf_pe, 98, MPI_COMM_WORLD, &status); /* use conv as temporary memory for angles */ for (lauf = 0; lauf < Vx_max * Vy_max * Vz_max; lauf++) { if (inputdata1.floatdata[lauf] < Ergebnis[lauf]) { inputdata1.floatdata[lauf] = Ergebnis[lauf]; outputdata.floatdata[lauf] = conv[lauf]; } } } /*Ergebnisse eingesammelt */ } // myrank > 0: Ergebnisse senden else { MPI_Send (inputdata1.floatdata, Vx_max * Vy_max * Vz_max, MPI_FLOAT, 0, 99, MPI_COMM_WORLD); MPI_Send (outputdata.floatdata, Vx_max * Vy_max * Vz_max, MPI_FLOAT, 0, 98, MPI_COMM_WORLD); } MPI_Barrier (MPI_COMM_WORLD); // nicht normalisiertes Volumen und Winkel rausschreiben subc[0]=subc[0]+Rx_max/2; subc[1]=subc[1]+Rx_max/2; subc[2]=subc[2]+Rx_max/2; if (myrank==0) { offset[0]=Rx_max/2; offset[1]=Rx_max/2; offset[2]=Rx_max/2; dimarray[0]=dim_fft; dimarray[1]=dim_fft; dimarray[2]=dim_fft; strcpy (name, argv[3]); strcat (name, ".ccf"); write_em_subsubregion (name, &inputdata1,subc,range_sub,offset,dimarray); strcpy (name, argv[3]); strcat (name, ".ang"); write_em_subsubregion (name, &outputdata,subc,range_sub,offset,dimarray); /* ------------------- normalization - here only PE 0 ---------- */ pastes (&inputdata4.floatdata[0], &Vol_tmpl[0], 1, 1, 1, Rx_max, Ry_max, Rz_max, Vx_max); /* paste mask into zero volume*/ /* 1st local mean */ sort4fftw(&Vol_tmpl_sort[0], &Vol_tmpl[0], Vx_max, Vy_max, Vz_max); rfftwnd_one_real_to_complex (p3, &Vol_tmpl_sort[0], NULL); C3 = (fftw_complex *) & Vol_tmpl_sort[0]; /* Convolution of volume and mask */ scale = 1.0 / ((double)Vx_max * (double)Vy_max * (double)Vz_max ); convolve( &PointVolume[0], &C3[0], Vx_max, Vy_max, Vz_max, scale); rfftwnd_one_complex_to_real (pi3, &C3[0], NULL); PointCorr = (fftw_real *) & C3[0]; /* Umsortieren der Daten */ sortback4fftw( &PointCorr[0], &conv[0], Vx_max, Vy_max, Vz_max); /* 2nd : convolution of square and resorting*/ pastes (&inputdata4.floatdata[0], &Vol_tmpl[0], 1, 1, 1, Rx_max, Ry_max, Rz_max, Vx_max); /* paste mask into zero volume*/ sort4fftw( &Vol_tmpl_sort[0], &Vol_tmpl[0], Vx_max, Vy_max, Vz_max); rfftwnd_one_real_to_complex (p3, &Vol_tmpl_sort[0], NULL); C3 = (fftw_complex *) & Vol_tmpl_sort[0]; PointSq = (fftw_complex *) & sqconv[0];// set pointer to FFT of square convolve( &PointSq[0], &C3[0], Vx_max, Vy_max, Vz_max, scale); rfftwnd_one_complex_to_real (pi3, &C3[0], NULL); PointCorr = (fftw_real *) &C3[0]; //FF lauf = 0; for (k = 0; k < Vz_max; k++) { for (j = 0; j < Vy_max; j++) { for (i = 0; i < Vx_max; i++) { conv[lauf] = sqrt(PointCorr[i + 2 * (Vx_max / 2 + 1) * (j + Vy_max * k)] - conv[lauf]*conv[lauf]/((float) n) ) ;/*local variance*/ lauf++; } } } cross(&conv[0], Vx_max); /* perform division */ for (lauf = 0; k < Vz_max*Vy_max*Vz_max; lauf++) { if (conv[lauf] > eps) { inputdata1[lauf].floatdata = inputdata1[lauf].floatdata/conv[lauf]; } else { inputdata1[lauf].floatdata = 0; } } strcpy (name, argv[3]); strcat (name, ".ccf.norm"); write_em_subsubregion (name, &inputdata1,subc,range_sub,offset,dimarray); } MPI_Barrier (MPI_COMM_WORLD); } } /* these are the new brackets from the subregion_read , SN */ } free(Ergebnis); free(inputdata1.floatdata); free(inputdata2.floatdata); free(inputdata3.floatdata); free(inputdata4.floatdata); rfftwnd_destroy_plan(p3); rfftwnd_destroy_plan(pi3); rfftwnd_destroy_plan(r3); rfftwnd_destroy_plan(ri3); free(Volume); free(sqconv); free(conv); free(Rot_tmpl); free(Vol_tmpl_sort); free(outputdata.floatdata); if (myrank==0) { printf ("oscar finished. "); tack (&start); fflush(stdout); } MPI_Finalize(); /* end main */ }
void testnd_in_place(int rank, int *n, fftwnd_plan validated_plan, int alternate_api, int specific) { int istride, ostride, howmany; int N, dim, i, j, k; int nc, nhc, nr; fftw_real *in1, *out3; fftw_complex *in2, *out1, *out2; fftwnd_plan p, ip; int flags = measure_flag | wisdom_flag | FFTW_IN_PLACE; if (coinflip()) flags |= FFTW_THREADSAFE; N = nc = nr = nhc = 1; for (dim = 0; dim < rank; ++dim) N *= n[dim]; if (rank > 0) { nr = n[rank - 1]; nc = N / nr; nhc = nr / 2 + 1; } in1 = (fftw_real *) fftw_malloc(2 * nhc * nc * MAX_STRIDE * sizeof(fftw_real)); out3 = in1; out1 = (fftw_complex *) in1; in2 = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex)); out2 = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex)); if (alternate_api && specific && (rank == 2 || rank == 3)) { if (rank == 2) { p = rfftw2d_create_plan_specific(n[0], n[1], FFTW_REAL_TO_COMPLEX, flags, in1, MAX_STRIDE, 0, 0); ip = rfftw2d_create_plan_specific(n[0], n[1], FFTW_COMPLEX_TO_REAL, flags, in1, MAX_STRIDE, 0, 0); } else { p = rfftw3d_create_plan_specific(n[0], n[1], n[2], FFTW_REAL_TO_COMPLEX, flags, in1, MAX_STRIDE, 0, 0); ip = rfftw3d_create_plan_specific(n[0], n[1], n[2], FFTW_COMPLEX_TO_REAL, flags, in1, MAX_STRIDE, 0, 0); } } else if (specific) { p = rfftwnd_create_plan_specific(rank, n, FFTW_REAL_TO_COMPLEX, flags, in1, MAX_STRIDE, in1, MAX_STRIDE); ip = rfftwnd_create_plan_specific(rank, n, FFTW_COMPLEX_TO_REAL, flags, in1, MAX_STRIDE, in1, MAX_STRIDE); } else if (alternate_api && (rank == 2 || rank == 3)) { if (rank == 2) { p = rfftw2d_create_plan(n[0], n[1], FFTW_REAL_TO_COMPLEX, flags); ip = rfftw2d_create_plan(n[0], n[1], FFTW_COMPLEX_TO_REAL, flags); } else { p = rfftw3d_create_plan(n[0], n[1], n[2], FFTW_REAL_TO_COMPLEX, flags); ip = rfftw3d_create_plan(n[0], n[1], n[2], FFTW_COMPLEX_TO_REAL, flags); } } else { p = rfftwnd_create_plan(rank, n, FFTW_REAL_TO_COMPLEX, flags); ip = rfftwnd_create_plan(rank, n, FFTW_COMPLEX_TO_REAL, flags); } CHECK(p != NULL && ip != NULL, "can't create plan"); for (i = 0; i < nc * nhc * 2 * MAX_STRIDE; ++i) out3[i] = 0; for (istride = 1; istride <= MAX_STRIDE; ++istride) { /* generate random inputs */ for (i = 0; i < nc; ++i) for (j = 0; j < nr; ++j) { c_re(in2[i * nr + j]) = DRAND(); c_im(in2[i * nr + j]) = 0.0; for (k = 0; k < istride; ++k) in1[(i * nhc * 2 + j) * istride + k] = c_re(in2[i * nr + j]); } fftwnd(validated_plan, 1, in2, 1, 1, out2, 1, 1); howmany = ostride = istride; WHEN_VERBOSE(2, printf("\n testing in-place stride %d...", istride)); if (howmany != 1 || istride != 1 || ostride != 1 || coinflip()) rfftwnd_real_to_complex(p, howmany, in1, istride, 1, out1, ostride, 1); else rfftwnd_one_real_to_complex(p, in1, NULL); for (i = 0; i < nc; ++i) for (k = 0; k < howmany; ++k) CHECK(compute_error_complex(out1 + i * nhc * ostride + k, ostride, out2 + i * nr, 1, nhc) < TOLERANCE, "in-place (r2c): wrong answer"); if (howmany != 1 || istride != 1 || ostride != 1 || coinflip()) rfftwnd_complex_to_real(ip, howmany, out1, ostride, 1, out3, istride, 1); else rfftwnd_one_complex_to_real(ip, out1, NULL); for (i = 0; i < nc * nhc * 2 * istride; ++i) out3[i] *= 1.0 / N; for (i = 0; i < nc; ++i) for (k = 0; k < howmany; ++k) CHECK(compute_error(out3 + i * nhc * 2 * istride + k, istride, (fftw_real *) (in2 + i * nr), 2, nr) < TOLERANCE, "in-place (c2r): wrong answer (check 2)"); } rfftwnd_destroy_plan(p); rfftwnd_destroy_plan(ip); fftw_free(out2); fftw_free(in2); fftw_free(in1); }