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);
}