fftw_complex* RockPhysicsInversion4D::MakeSmoothingFilter(double posteriorVariance,double df) { int cnfp = nfp_/2 + 1; int rnfp = 2*cnfp; fftw_real * gaussKernel = static_cast<fftw_real*>(fftw_malloc(sizeof(float)*rnfp)); fftw_complex* smoothingFilter = reinterpret_cast<fftw_complex*>(gaussKernel ); for(int i=0;i<cnfp;i++) gaussKernel[i] = float(exp(-0.5*(double(i)*df)*(double(i)*df)/ posteriorVariance)) ; for(int i=1;i<cnfp;i++) // note 1 is intentional gaussKernel[nfp_-i] = float(exp(-0.5*(double(i)*df)*(double(i)*df)/ posteriorVariance)) ; double sum=0.0; for(int i=0;i<nfp_;i++) sum+=gaussKernel[i]; for(int i=0;i<nfp_;i++) gaussKernel[i]/=float(sum); rfftwnd_one_real_to_complex(fftplan1_,gaussKernel, smoothingFilter); return smoothingFilter; }
void compute_FFT(field_info *FFT) { // Add the FFTW padding if we need to. The log message // is only needed if we do add a buffer. int flag_log_message = GBP_FALSE; if(add_buffer_FFT_R(FFT)) { SID_log("Performing FFT...", SID_LOG_OPEN | SID_LOG_TIMER); flag_log_message = GBP_TRUE; } // Perform the FFT #if FFTW_V2 #if USE_MPI rfftwnd_mpi(FFT->plan, 1, FFT->field_local, NULL, FFTW_TRANSPOSED_ORDER); #else rfftwnd_one_real_to_complex(FFT->plan, FFT->field_local, NULL); #endif #else #ifdef USE_DOUBLE fftw_execute((const fftw_plan)FFT->plan); #else fftwf_execute((const fftwf_plan)FFT->plan); #endif #endif if(flag_log_message) SID_log("Done.", SID_LOG_CLOSE); }
void sararfftnd_one_real_to_complex( sararfftnd_plan p, sarafft_real *data ) { #ifdef USE_GPUS // TODO: GPU implementation #else // #ifndef USE_GPUS rfftwnd_one_real_to_complex( p, data, 0 ); #endif }
void Wavelet::fft1DInPlace() { // use the operator version of the fourier transform if(isReal_) { int flag; rfftwnd_plan plan; flag = FFTW_ESTIMATE | FFTW_IN_PLACE; plan = rfftwnd_create_plan(1, &nzp_ ,FFTW_REAL_TO_COMPLEX,flag); // // NBNB-PAL: The call rfftwnd_on_real_to_complex is causing UMRs in Purify. // rfftwnd_one_real_to_complex(plan,rAmp_,cAmp_); fftwnd_destroy_plan(plan); isReal_ = false; } }
int gmx_fft_3d_real(gmx_fft_t fft, enum gmx_fft_direction dir, void * in_data, void * out_data) { int inplace = (in_data == out_data); int isforward = (dir == GMX_FFT_REAL_TO_COMPLEX); int sz; if((fft->ndim != 3) || ((dir != GMX_FFT_REAL_TO_COMPLEX) && (dir != GMX_FFT_COMPLEX_TO_REAL))) { gmx_fatal(FARGS,"FFT plan mismatch - bad plan or direction."); return EINVAL; } if(inplace == 0) { /* Copy data to avoid overwriting input, and redirect input ptr to work array */ sz = fft->nx*fft->ny*(fft->nz/2 + 1)*2; memcpy(fft->work,in_data,sz*sizeof(real)); in_data = fft->work; } if(isforward) { rfftwnd_one_real_to_complex(fft->multi[inplace][isforward],(fftw_real *)in_data,(fftw_complex *)out_data); } else { rfftwnd_one_complex_to_real(fft->multi[inplace][isforward],(fftw_complex *)in_data,(fftw_real *)out_data); } return 0; }
/* Call rfftw for a 1 band real image. */ static int rfwfft1( IMAGE *dummy, IMAGE *in, IMAGE *out ) { const int size = in->Xsize * in->Ysize; const int half_width = in->Xsize / 2 + 1; /* Pack to double real here. */ IMAGE *real = im_open_local( dummy, "fwfft1:1", "t" ); /* Transform to halfcomplex here. */ double *half_complex = IM_ARRAY( dummy, in->Ysize * half_width * 2, double ); rfftwnd_plan plan; double *buf, *q, *p; int x, y; if( !real || !half_complex || im_pincheck( in ) || im_outcheck( out ) ) return( -1 ); if( in->Coding != IM_CODING_NONE || in->Bands != 1 ) { im_error( "im_fwfft", _( "one band uncoded only" ) ); return( -1 ); } if( im_clip2d( in, real ) ) return( -1 ); /* Make the plan for the transform. Yes, they really do use nx for * height and ny for width. */ if( !(plan = rfftw2d_create_plan( in->Ysize, in->Xsize, FFTW_FORWARD, FFTW_MEASURE | FFTW_USE_WISDOM )) ) { im_error( "im_fwfft", _( "unable to create transform plan" ) ); return( -1 ); } rfftwnd_one_real_to_complex( plan, (fftw_real *) real->data, (fftw_complex *) half_complex ); rfftwnd_destroy_plan( plan ); /* WIO to out. */ if( im_cp_desc( out, in ) ) return( -1 ); out->Bbits = IM_BBITS_DPCOMPLEX; out->BandFmt = IM_BANDFMT_DPCOMPLEX; if( im_setupout( out ) ) return( -1 ); if( !(buf = (double *) IM_ARRAY( dummy, IM_IMAGE_SIZEOF_LINE( out ), PEL )) ) return( -1 ); /* Copy to out and normalise. The right half is the up/down and * left/right flip of the left, but conjugated. Do the first * row separately, then mirror around the centre row. */ p = half_complex; q = buf; for( x = 0; x < half_width; x++ ) { q[0] = p[0] / size; q[1] = p[1] / size; p += 2; q += 2; } p = half_complex + ((in->Xsize + 1) / 2 - 1) * 2; for( x = half_width; x < out->Xsize; x++ ) { q[0] = p[0] / size; q[1] = -1.0 * p[1] / size; p -= 2; q += 2; } if( im_writeline( 0, out, (PEL *) buf ) ) return( -1 ); for( y = 1; y < out->Ysize; y++ ) { p = half_complex + y * half_width * 2; q = buf; for( x = 0; x < half_width; x++ ) { q[0] = p[0] / size; q[1] = p[1] / size; p += 2; q += 2; } /* Good grief. */ p = half_complex + 2 * ((out->Ysize - y + 1) * half_width - 2 + (in->Xsize & 1)); for( x = half_width; x < out->Xsize; x++ ) { q[0] = p[0] / size; q[1] = -1.0 * p[1] / size; p -= 2; q += 2; } if( im_writeline( y, out, (PEL *) buf ) ) return( -1 ); } return( 0 ); }
/* * Class: jfftw_real_nd_Plan * Method: transform * Signature: ([D)[D */ JNIEXPORT jdoubleArray JNICALL Java_jfftw_real_nd_Plan_transform___3D( JNIEnv* env, jobject obj, jdoubleArray in ) { jdouble *cin, *cout; jdoubleArray out; int i; jclass clazz = (*env)->GetObjectClass( env, obj ); jfieldID id = (*env)->GetFieldID( env, clazz, "plan", "[B" ); jbyteArray arr = (jbyteArray)(*env)->GetObjectField( env, obj, id ); unsigned char* carr = (*env)->GetByteArrayElements( env, arr, 0 ); rfftwnd_plan plan = *(rfftwnd_plan*)carr; int length = 1; int clength = 2; for( i = 0; i < plan->rank; ++i ) length *= plan->plans[i]->n; for( i = 0; i < plan->rank; ++i ) clength *= plan->n[i]; if( (plan->dir==FFTW_REAL_TO_COMPLEX?length:clength) != (*env)->GetArrayLength( env, in ) ) { (*env)->ThrowNew( env, (*env)->FindClass( env, "java/lang/IndexOutOfBoundsException" ), "the Plan was created for a different length" ); (*env)->ReleaseByteArrayElements( env, arr, carr, 0 ); return NULL; } cin = (*env)->GetDoubleArrayElements( env, in, 0 ); if( plan->is_in_place ) { out = in; cout = NULL; } else { out = (*env)->NewDoubleArray( env, (plan->dir==FFTW_REAL_TO_COMPLEX?clength:length) ); cout = (*env)->GetDoubleArrayElements( env, out, 0 ); } if( plan->rank > 0 && ! plan->plans[0]->flags & FFTW_THREADSAFE ) { // synchronization (*env)->MonitorEnter( env, obj ); } if( plan->dir == FFTW_REAL_TO_COMPLEX ) { rfftwnd_one_real_to_complex( plan, cin, (fftw_complex*)cout ); } else { rfftwnd_one_complex_to_real( plan, (fftw_complex*)cin, cout ); } if( plan->rank > 0 && ! plan->plans[0]->flags & FFTW_THREADSAFE ) { // synchronization (*env)->MonitorExit( env, obj ); } (*env)->ReleaseByteArrayElements( env, arr, carr, 0 ); (*env)->ReleaseDoubleArrayElements( env, in, cin, 0 ); if( plan->is_in_place ) { (*env)->ReleaseDoubleArrayElements( env, out, cout, 0 ); } return out; }
void F77_FUNC_(rfftwnd_f77_one_real_to_complex,RFFTWND_F77_ONE_REAL_TO_COMPLEX) (fftwnd_plan *p, fftw_real *in, fftw_complex *out) { rfftwnd_one_real_to_complex(*p,in,out); }
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); }
void testnd_out_of_place(int rank, int *n, fftwnd_plan validated_plan) { int istride, ostride; 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; 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(N * MAX_STRIDE * sizeof(fftw_real)); out3 = (fftw_real *) fftw_malloc(N * MAX_STRIDE * sizeof(fftw_real)); out1 = (fftw_complex *) fftw_malloc(nhc * nc * MAX_STRIDE * sizeof(fftw_complex)); in2 = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex)); out2 = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex)); 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 (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 * nr + j) * istride + k] = c_re(in2[i * nr + j]); } for (i = 0; i < N * istride; ++i) out3[i] = 0.0; fftwnd(validated_plan, 1, in2, 1, 1, out2, 1, 1); for (ostride = 1; ostride <= MAX_STRIDE; ++ostride) { int howmany = (istride < ostride) ? istride : ostride; WHEN_VERBOSE(2, printf("\n testing stride %d/%d...", istride, ostride)); 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, out1); 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, "out-of-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, out3); for (i = 0; i < N * istride; ++i) out3[i] *= 1.0 / N; if (istride == howmany) CHECK(compute_error(out3, 1, in1, 1, N * istride) < TOLERANCE, "out-of-place (c2r): wrong answer"); for (i = 0; i < nc; ++i) for (k = 0; k < howmany; ++k) CHECK(compute_error(out3 + i * nr * istride + k, istride, (fftw_real *) (in2 + i * nr), 2, nr) < TOLERANCE, "out-of-place (c2r): wrong answer (check 2)"); } } rfftwnd_destroy_plan(p); rfftwnd_destroy_plan(ip); fftw_free(out3); fftw_free(out2); fftw_free(in2); fftw_free(out1); fftw_free(in1); }
void Grid::fft(bool) { rfftwnd_one_real_to_complex(fft_plan, data, NULL); }
void RockPhysicsInversion4D::DivideAndSmoothTable(int tableInd,std::vector<std::vector<double> > priorDistribution, std::vector<fftw_complex*> smoothingFilter) { for (int j=0; j<nf_[0]; j++){ meanRockPrediction_(tableInd,j)->setAccessMode(FFTGrid::RANDOMACCESS); } int cnfp=nfp_/2+1; int rnfp=2*cnfp; fftw_real* rTemp = static_cast<fftw_real*>(fftw_malloc(sizeof(float)*rnfp)); fftw_complex* cTemp = reinterpret_cast<fftw_complex*>(rTemp); double minDivisor = 1e-3; LogKit::LogFormatted(LogKit::Low,"\n Smoothing direction 1 of 4\n"); float monitorSize = std::max(1.0f, static_cast<float>(nf_[0]*nf_[1]*nf_[2]*nf_[3])*0.02f); float nextMonitor = monitorSize; std::cout << "\n 0% 20% 40% 60% 80% 100%" << "\n | | | | | | | | | | | " << "\n ^"; // divide and smooth direction1 for(int i1=0;i1<nf_[1];i1++) for(int i2=0;i2<nf_[2];i2++) for(int i3=0;i3<nf_[3];i3++) { for(int i0=0;i0<nf_[0];i0++) { double divisor=std::max(minDivisor,priorDistribution_[0][i0]); rTemp[i0]=float(GetGridValue(tableInd,i0,i1,i2,i3)/ divisor); } for(int i0=nf_[0];i0<nfp_;i0++) rTemp[i0]=0.0f; rfftwnd_one_real_to_complex(fftplan1_,rTemp,cTemp); for(int i0=0;i0<cnfp;i0++) { cTemp[i0].re=cTemp[i0].re*smoothingFilter[0][i0].re; cTemp[i0].im=cTemp[i0].im*smoothingFilter[0][i0].re; } rfftwnd_one_complex_to_real(fftplan2_,cTemp,rTemp); for(int i0=0;i0<nf_[0];i0++) { SetGridValue(tableInd,i0,i1,i2,i3, rTemp[i0]); if ( i1*nf_[2]*nf_[3]*nf_[0] +i2*nf_[3]*nf_[0]+ i3*nf_[0] + i0 + 1 >= static_cast<int>(nextMonitor)) { nextMonitor += monitorSize; std::cout << "^"; } } } LogKit::LogFormatted(LogKit::Low,"\n\n Smoothing direction 2 of 4\n"); monitorSize = std::max(1.0f, static_cast<float>(nf_[0]*nf_[1]*nf_[2]*nf_[3])*0.02f); nextMonitor = monitorSize; std::cout << "\n 0% 20% 40% 60% 80% 100%" << "\n | | | | | | | | | | | " << "\n ^"; // divide and smoothdirection2 for(int i0=0;i0<nf_[0];i0++) for(int i2=0;i2<nf_[2];i2++) for(int i3=0;i3<nf_[3];i3++) { for(int i1=0;i1<nf_[1];i1++) { double divisor=std::max(minDivisor,priorDistribution_[1][i1]); rTemp[i1]=float(GetGridValue(tableInd,i0,i1,i2,i3)/divisor); } for(int i1=nf_[1];i1<nfp_;i1++) rTemp[i1]=0.0f; rfftwnd_one_real_to_complex(fftplan1_,rTemp,cTemp); for(int i1=0;i1<cnfp;i1++) { cTemp[i1].re=cTemp[i1].re*smoothingFilter[1][i1].re; cTemp[i1].im=cTemp[i1].im*smoothingFilter[1][i1].re; } rfftwnd_one_complex_to_real(fftplan2_,cTemp,rTemp); for(int i1=0;i1<nf_[1];i1++) { SetGridValue(tableInd,i0,i1,i2,i3, rTemp[i1]); if ( i0*nf_[2]*nf_[3]*nf_[1] +i2*nf_[3]*nf_[1]+ i3*nf_[1] + i1 + 1 >= static_cast<int>(nextMonitor)) { nextMonitor += monitorSize; std::cout << "^"; } } } LogKit::LogFormatted(LogKit::Low,"\n\n Smoothing direction 3 of 4\n"); monitorSize = std::max(1.0f, static_cast<float>(nf_[0]*nf_[1]*nf_[2]*nf_[3])*0.02f); nextMonitor = monitorSize; std::cout << "\n 0% 20% 40% 60% 80% 100%" << "\n | | | | | | | | | | | " << "\n ^"; // divide and smoothdirection 3 for(int i0=0;i0<nf_[0];i0++) for(int i1=0;i1<nf_[1];i1++) for(int i3=0;i3<nf_[3];i3++) { for(int i2=0;i2<nf_[2];i2++) { double divisor=std::max(minDivisor,priorDistribution_[2][i2]); rTemp[i2]=float(GetGridValue(tableInd,i0,i1,i2,i3)/divisor); } for(int i2=nf_[2];i2<nfp_;i2++) rTemp[i2]=0.0f; rfftwnd_one_real_to_complex(fftplan1_,rTemp,cTemp); for(int i2=0;i2<cnfp;i2++) { cTemp[i2].re=cTemp[i2].re*smoothingFilter[2][i2].re; cTemp[i2].im=cTemp[i2].im*smoothingFilter[2][i2].re; } rfftwnd_one_complex_to_real(fftplan2_,cTemp,rTemp); for(int i2=0;i2<nf_[2];i2++) { SetGridValue(tableInd,i0,i1,i2,i3, rTemp[i2]); if ( i0*nf_[1]*nf_[3]*nf_[2] +i1*nf_[3]*nf_[2]+ i3*nf_[2] + i2 + 1 >= static_cast<int>(nextMonitor)) { nextMonitor += monitorSize; std::cout << "^"; } } } LogKit::LogFormatted(LogKit::Low,"\n Smoothing last direction \n"); monitorSize = std::max(1.0f, static_cast<float>(nf_[0]*nf_[1]*nf_[2]*nf_[3])*0.02f); nextMonitor = monitorSize; std::cout << "\n 0% 20% 40% 60% 80% 100%" << "\n | | | | | | | | | | | " << "\n ^"; // divide and smoothdirection 4 for(int i0=0;i0<nf_[0];i0++) for(int i1=0;i1<nf_[1];i1++) for(int i2=0;i2<nf_[2];i2++) { for(int i3=0;i3<nf_[3];i3++) { double divisor=std::max(minDivisor,priorDistribution_[3][i3]); rTemp[i3]=float(GetGridValue(tableInd,i0,i1,i2,i3)/divisor); } for(int i3=nf_[3];i3<nfp_;i3++) rTemp[i3]=0.0f; rfftwnd_one_real_to_complex(fftplan1_,rTemp,cTemp); for(int i3=0;i3<cnfp;i3++) { cTemp[i3].re=cTemp[i3].re*smoothingFilter[3][i3].re; cTemp[i3].im=cTemp[i3].im*smoothingFilter[3][i3].re; } rfftwnd_one_complex_to_real(fftplan2_,cTemp,rTemp); for(int i3=0;i3<nf_[3];i3++) { SetGridValue(tableInd,i0,i1,i2,i3, rTemp[i3]); if ( i0*nf_[1]*nf_[2]*nf_[3] +i1*nf_[2]*nf_[3]+ i2*nf_[3] + i3 + 1 >= static_cast<int>(nextMonitor)) { nextMonitor += monitorSize; std::cout << "^"; } } } for (int j=0; j<nf_[0]; j++){ meanRockPrediction_(tableInd,j)->endAccess(); } fftw_free(rTemp); }