Skip to content

GitLab

Commit 82c718f2 authored by David Rohr's avatar David Rohr
Browse files
Options

use improved FFTs for real and hermitian input

parent da3cdbbc
Hide whitespace changes
Inline Side-by-side
Showing with 76 additions and 68 deletions
bioem.cpp
View file @ 82c718f2
......@@ -240,9 +240,8 @@ int bioem::run()
myfloat_t sumCONV,sumsquareCONV;
//allocating fftw_complex vector
proj_mapFFT= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) *param.param_device.NumberPixels*param.param_device.NumberPixels);
conv_mapFFT= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t)*param.param_device.NumberPixels*param.param_device.NumberPixels);
proj_mapFFT= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param.param_device.NumberPixels*param.param_device.NumberFFTPixels1D);
conv_mapFFT= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param.param_device.NumberPixels*param.param_device.NumberFFTPixels1D);
HighResTimer timer;
......@@ -378,9 +377,10 @@ int bioem::compareRefMaps2(int iOrient, int iConv, mycomplex_t* localConvFFT,myf
{
#pragma omp parallel
{
mycomplex_t *localCCT, *lCC;
localCCT= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) *param.param_device.NumberPixels*param.param_device.NumberPixels);
lCC= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) *param.param_device.NumberPixels*param.param_device.NumberPixels);
mycomplex_t *localCCT;
myfloat_t *lCC;
localCCT= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) *param.param_device.NumberPixels*param.param_device.NumberFFTPixels1D);
lCC= (myfloat_t *) myfftw_malloc(sizeof(myfloat_t) *param.param_device.NumberPixels*param.param_device.NumberPixels);
const int num_threads = omp_get_num_threads();
const int thread_id = omp_get_thread_num();
......@@ -400,40 +400,40 @@ int bioem::compareRefMaps2(int iOrient, int iConv, mycomplex_t* localConvFFT,myf
}
/////////////NEW ROUTINE ////////////////
inline int bioem::calculateCCFFT(int iRefMap, int iOrient, int iConv, myfloat_t sumC,myfloat_t sumsquareC, mycomplex_t* localConvFFT,mycomplex_t* localCCT,mycomplex_t* lCC)
inline int bioem::calculateCCFFT(int iRefMap, int iOrient, int iConv, myfloat_t sumC,myfloat_t sumsquareC, mycomplex_t* localConvFFT,mycomplex_t* localCCT,myfloat_t* lCC)
{
for(int i=0; i < param.param_device.NumberPixels ; i++ )
{
for(int j=0; j < param.param_device.NumberPixels ; j++ )
for(int j=0; j < param.param_device.NumberFFTPixels1D ; j++ )
{
localCCT[i*param.param_device.NumberPixels+j][0]=localConvFFT[i*param.param_device.NumberPixels+j][0]*RefMap.RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberPixels+j][0]+localConvFFT[i*param.param_device.NumberPixels+j][1]*RefMap.RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberPixels+j][1];
localCCT[i*param.param_device.NumberPixels+j][1]=localConvFFT[i*param.param_device.NumberPixels+j][1]*RefMap.RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberPixels+j][0]-localConvFFT[i*param.param_device.NumberPixels+j][0]*RefMap.RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberPixels+j][1];
localCCT[i*param.param_device.NumberFFTPixels1D+j][0]=localConvFFT[i*param.param_device.NumberFFTPixels1D+j][0]*RefMap.RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberFFTPixels1D+j][0]+localConvFFT[i*param.param_device.NumberFFTPixels1D+j][1]*RefMap.RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberFFTPixels1D+j][1];
localCCT[i*param.param_device.NumberFFTPixels1D+j][1]=localConvFFT[i*param.param_device.NumberFFTPixels1D+j][1]*RefMap.RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberFFTPixels1D+j][0]-localConvFFT[i*param.param_device.NumberFFTPixels1D+j][0]*RefMap.RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberFFTPixels1D+j][1];
}
}
myfftw_execute_dft(param.fft_plan_c2c_backward,localCCT,lCC);
myfftw_execute_dft_c2r(param.fft_plan_c2r_backward,localCCT,lCC);
// Storing CORRELATIONS FOR CORRESPONDING DISPLACEMENTS & Normalizing after Backward FFT
for (int cent_x = 0; cent_x <= param.param_device.maxDisplaceCenter; cent_x=cent_x+param.param_device.GridSpaceCenter)
{
for (int cent_y = 0; cent_y <= param.param_device.maxDisplaceCenter; cent_y=cent_y+param.param_device.GridSpaceCenter)
{
calProb(iRefMap, iOrient, iConv, sumC, sumsquareC, (myfloat_t) lCC[cent_x*param.param_device.NumberPixels+cent_y][0]/ (myfloat_t) (param.param_device.NumberPixels * param.param_device.NumberPixels), cent_x, cent_y);
calProb(iRefMap, iOrient, iConv, sumC, sumsquareC, (myfloat_t) lCC[cent_x*param.param_device.NumberPixels+cent_y]/ (myfloat_t) (param.param_device.NumberPixels * param.param_device.NumberPixels), cent_x, cent_y);
}
for (int cent_y = param.param_device.NumberPixels-param.param_device.maxDisplaceCenter; cent_y < param.param_device.NumberPixels; cent_y=cent_y+param.param_device.GridSpaceCenter)
{
calProb(iRefMap, iOrient, iConv, sumC, sumsquareC, (myfloat_t) lCC[cent_x*param.param_device.NumberPixels+cent_y][0]/ (myfloat_t) (param.param_device.NumberPixels*param.param_device.NumberPixels), cent_x, param.param_device.NumberPixels-cent_y);
calProb(iRefMap, iOrient, iConv, sumC, sumsquareC, (myfloat_t) lCC[cent_x*param.param_device.NumberPixels+cent_y]/ (myfloat_t) (param.param_device.NumberPixels*param.param_device.NumberPixels), cent_x, param.param_device.NumberPixels-cent_y);
}
}
for (int cent_x = param.param_device.NumberPixels-param.param_device.maxDisplaceCenter; cent_x < param.param_device.NumberPixels; cent_x=cent_x+param.param_device.GridSpaceCenter)
{
for (int cent_y = 0; cent_y < param.param_device.maxDisplaceCenter; cent_y=cent_y+param.param_device.GridSpaceCenter)
{
calProb(iRefMap, iOrient, iConv, sumC, sumsquareC, (myfloat_t) lCC[cent_x*param.param_device.NumberPixels+cent_y][0]/ (myfloat_t) (param.param_device.NumberPixels*param.param_device.NumberPixels), param.param_device.NumberPixels-cent_x, cent_y);
calProb(iRefMap, iOrient, iConv, sumC, sumsquareC, (myfloat_t) lCC[cent_x*param.param_device.NumberPixels+cent_y]/ (myfloat_t) (param.param_device.NumberPixels*param.param_device.NumberPixels), param.param_device.NumberPixels-cent_x, cent_y);
}
for (int cent_y = param.param_device.NumberPixels-param.param_device.maxDisplaceCenter; cent_y <= param.param_device.NumberPixels; cent_y=cent_y+param.param_device.GridSpaceCenter)
{
calProb(iRefMap, iOrient, iConv, sumC, sumsquareC, (myfloat_t) lCC[cent_x*param.param_device.NumberPixels+cent_y][0]/ (myfloat_t) (param.param_device.NumberPixels*param.param_device.NumberPixels), param.param_device.NumberPixels-cent_x, param.param_device.NumberPixels-cent_y);
calProb(iRefMap, iOrient, iConv, sumC, sumsquareC, (myfloat_t) lCC[cent_x*param.param_device.NumberPixels+cent_y]/ (myfloat_t) (param.param_device.NumberPixels*param.param_device.NumberPixels), param.param_device.NumberPixels-cent_x, param.param_device.NumberPixels-cent_y);
}
}
......@@ -499,9 +499,9 @@ int bioem::createProjection(int iMap,mycomplex_t* mapFFT)
myfloat3_t RotatedPointsModel[Model.nPointsModel];
myfloat_t rotmat[3][3];
myfloat_t alpha, gam,beta;
mycomplex_t* localproj;
myfloat_t* localproj;
localproj= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) *param.param_device.NumberPixels*param.param_device.NumberPixels);
localproj= (myfloat_t *) myfftw_malloc(sizeof(myfloat_t) *param.param_device.NumberPixels*param.param_device.NumberPixels);
memset(localproj,0,param.param_device.NumberPixels*param.param_device.NumberPixels*sizeof(*localproj));
alpha=param.angles[iMap].pos[0];
......@@ -549,7 +549,7 @@ int bioem::createProjection(int iMap,mycomplex_t* mapFFT)
i=floor(RotatedPointsModel[n].pos[0]/param.pixelSize+ (myfloat_t) param.param_device.NumberPixels / 2.0f + 0.5f);
j=floor(RotatedPointsModel[n].pos[1]/param.pixelSize+ (myfloat_t) param.param_device.NumberPixels / 2.0f + 0.5f);
localproj[i*param.param_device.NumberPixels+j][0]+=Model.densityPointsModel[n]/Model.NormDen;
localproj[i*param.param_device.NumberPixels+j]+=Model.densityPointsModel[n]/Model.NormDen;
}
/**** Output Just to check****/
......@@ -562,7 +562,7 @@ int bioem::createProjection(int iMap,mycomplex_t* mapFFT)
myexamplemap << "ANGLES " << alpha << " " << beta << " " << gam << "\n";
for(int k=0; k<param.param_device.NumberPixels; k++)
{
for(int j=0; j<param.param_device.NumberPixels; j++) myexamplemap << "\nMAP " << k << " " << j<< " " <<localproj[k*param.param_device.NumberPixels+j][0];
for(int j=0; j<param.param_device.NumberPixels; j++) myexamplemap << "\nMAP " << k << " " << j<< " " <<localproj[k*param.param_device.NumberPixels+j];
}
myexamplemap << " \n";
for(int n=0; n< Model.nPointsModel; n++)myexampleRot << "\nCOOR " << RotatedPointsModel[n].pos[0] << " " << RotatedPointsModel[n].pos[1] << " " << RotatedPointsModel[n].pos[2];
......@@ -572,12 +572,12 @@ int bioem::createProjection(int iMap,mycomplex_t* mapFFT)
/***** Converting projection to Fourier Space for Convolution later with kernel****/
/********** Omp Critical is necessary with FFTW*******/
myfftw_execute_dft(param.fft_plan_c2c_forward,localproj,mapFFT);
myfftw_execute_dft_r2c(param.fft_plan_r2c_forward,localproj,mapFFT);
return(0);
}
int bioem::createConvolutedProjectionMap(int iMap,int iConv,mycomplex_t* lproj,bioem_map& Mapconv,mycomplex_t* localmultFFT,myfloat_t& sumC,myfloat_t& sumsquareC)
int bioem::createConvolutedProjectionMap(int iMap,int iConv,mycomplex_t* lproj,bioem_map& Mapconv, mycomplex_t* localmultFFT, myfloat_t& sumC, myfloat_t& sumsquareC)
{
/**************************************************************************************/
/**** BioEM Create Convoluted Projection Map routine, multiplies in Fourier **********
......@@ -585,31 +585,35 @@ int bioem::createConvolutedProjectionMap(int iMap,int iConv,mycomplex_t* lproj,b
*************** and Backtransforming it to real Space ******************************/
/**************************************************************************************/
mycomplex_t* localconvFFT;
localconvFFT= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t)*param.param_device.NumberPixels*param.param_device.NumberPixels);
myfloat_t* localconvFFT;
localconvFFT= (myfloat_t *) myfftw_malloc(sizeof(myfloat_t)*param.param_device.NumberPixels*param.param_device.NumberPixels);
mycomplex_t* tmp;
tmp = (mycomplex_t*) myfftw_malloc(sizeof(mycomplex_t) * param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D);
/**** Multiplying FFTmap with corresponding kernel ****/
for(int i=0; i < param.param_device.NumberPixels ; i++ )
{
for(int j=0; j < param.param_device.NumberPixels ; j++ )
for(int j=0; j < param.param_device.NumberFFTPixels1D ; j++ )
{ //Projection*CONJ(KERNEL)
localmultFFT[i*param.param_device.NumberPixels+j][0]=lproj[i*param.param_device.NumberPixels+j][0]*param.refCTF[iConv].cpoints[i*param.param_device.NumberPixels+j][0]+lproj[i*param.param_device.NumberPixels+j][1]*param.refCTF[iConv].cpoints[i*param.param_device.NumberPixels+j][1];
localmultFFT[i*param.param_device.NumberPixels+j][1]=lproj[i*param.param_device.NumberPixels+j][1]*param.refCTF[iConv].cpoints[i*param.param_device.NumberPixels+j][0]-lproj[i*param.param_device.NumberPixels+j][0]*param.refCTF[iConv].cpoints[i*param.param_device.NumberPixels+j][1];
// cout << "GG " << i << " " << j << " " << param.refCTF[iConv].cpoints[i*param.param_device.NumberPixels+j][0] << " " <<param.refCTF[iConv].cpoints[i*param.param_device.NumberPixels+j][1] <<" " <<lproj[i*param.param_device.NumberPixels+j][0] <<" " <<lproj[i*param.param_device.NumberPixels+j][1] << "\n";
localmultFFT[i*param.param_device.NumberFFTPixels1D+j][0]=lproj[i*param.param_device.NumberFFTPixels1D+j][0]*param.refCTF[iConv].cpoints[i*param.param_device.NumberFFTPixels1D+j][0]+lproj[i*param.param_device.NumberFFTPixels1D+j][1]*param.refCTF[iConv].cpoints[i*param.param_device.NumberFFTPixels1D+j][1];
localmultFFT[i*param.param_device.NumberFFTPixels1D+j][1]=lproj[i*param.param_device.NumberFFTPixels1D+j][1]*param.refCTF[iConv].cpoints[i*param.param_device.NumberFFTPixels1D+j][0]-lproj[i*param.param_device.NumberFFTPixels1D+j][0]*param.refCTF[iConv].cpoints[i*param.param_device.NumberFFTPixels1D+j][1];
// cout << "GG " << i << " " << j << " " << param.refCTF[iConv].cpoints[i*param.param_device.NumberFFTPixels1D+j][0] << " " <<param.refCTF[iConv].cpoints[i*param.param_device.NumberFFTPixels1D+j][1] <<" " <<lproj[i*param.param_device.NumberFFTPixels1D+j][0] <<" " <<lproj[i*param.param_device.NumberFFTPixels1D+j][1] << "\n";
}
}
//FFTW_C2R will destroy the input array, so we have to work on a copy here
memcpy(tmp, localmultFFT, sizeof(mycomplex_t) * param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D);
/**** Bringing convoluted Map to real Space ****/
myfftw_execute_dft(param.fft_plan_c2c_backward,localmultFFT,localconvFFT);
myfftw_execute_dft_c2r(param.fft_plan_c2r_backward,tmp,localconvFFT);
/****Asigning convolution fftw_complex to bioem_map ****/
for(int i=0; i < param.param_device.NumberPixels ; i++ )
{
for(int j=0; j < param.param_device.NumberPixels ; j++ )
{
Mapconv.points[i][j]=localconvFFT[i*param.param_device.NumberPixels+j][0];
Mapconv.points[i][j]=localconvFFT[i*param.param_device.NumberPixels+j];
}
}
......@@ -620,8 +624,8 @@ int bioem::createConvolutedProjectionMap(int iMap,int iConv,mycomplex_t* lproj,b
{
for(int j=0; j < param.param_device.NumberPixels ; j++ )
{
sumC+=localconvFFT[i*param.param_device.NumberPixels+j][0];
sumsquareC+=localconvFFT[i*param.param_device.NumberPixels+j][0]*localconvFFT[i*param.param_device.NumberPixels+j][0];
sumC+=localconvFFT[i*param.param_device.NumberPixels+j];
sumsquareC+=localconvFFT[i*param.param_device.NumberPixels+j]*localconvFFT[i*param.param_device.NumberPixels+j];
}
}
/*** The DTF gives an unnormalized value so have to divded by the total number of pixels in Fourier ***/
......@@ -631,6 +635,7 @@ int bioem::createConvolutedProjectionMap(int iMap,int iConv,mycomplex_t* lproj,b
/**** Freeing fftw_complex created (dont know if omp critical is necessary) ****/
myfftw_free(localconvFFT);
myfftw_free(tmp);
return(0);
}
......
include/bioem.h
View file @ 82c718f2
......@@ -30,7 +30,7 @@ public:
int createProjection(int iMap, mycomplex_t* map);
int calcross_cor(bioem_map& localmap,myfloat_t& sum,myfloat_t& sumsquare);
int calProb(int iRefMap,int iOrient, int iConv,myfloat_t sumC,myfloat_t sumsquareC, int value, int disx, int disy);
int calculateCCFFT(int iMap, int iOrient, int iConv, myfloat_t sumC,myfloat_t sumsquareC, mycomplex_t* localConvFFT,mycomplex_t* localCCT,mycomplex_t* lCC);
int calculateCCFFT(int iMap, int iOrient, int iConv, myfloat_t sumC,myfloat_t sumsquareC, mycomplex_t* localConvFFT,mycomplex_t* localCCT,myfloat_t* lCC);
bioem_Probability* pProb;
......
include/defs.h
View file @ 82c718f2
......@@ -10,7 +10,11 @@ typedef float myfloat_t;
#define myfftw_destroy_plan fftwf_destroy_plan
#define myfftw_execute fftwf_execute
#define myfftw_execute_dft fftwf_execute_dft
#define myfftw_execute_dft_r2c fftwf_execute_dft_r2c
#define myfftw_execute_dft_c2r fftwf_execute_dft_c2r
#define myfftw_plan_dft_2d fftwf_plan_dft_2d
#define myfftw_plan_dft_r2c_2d fftwf_plan_dft_r2c_2d
#define myfftw_plan_dft_c2r_2d fftwf_plan_dft_c2r_2d
#define myfftw_plan fftwf_plan
#else
typedef double myfloat_t;
......@@ -19,7 +23,11 @@ typedef double myfloat_t;
#define myfftw_destroy_plan fftw_destroy_plan
#define myfftw_execute fftw_execute
#define myfftw_execute_dft fftw_execute_dft
#define myfftw_execute_dft_r2c fftw_execute_dft_r2c
#define myfftw_execute_dft_c2r fftw_execute_dft_c2r
#define myfftw_plan_dft_2d fftw_plan_dft_2d
#define myfftw_plan_dft_r2c_2d fftw_plan_dft_r2c_2d
#define myfftw_plan_dft_c2r_2d fftw_plan_dft_c2r_2d
#define myfftw_plan fftw_plan
#endif
typedef myfloat_t mycomplex_t[2];
......
include/map.h
View file @ 82c718f2
......@@ -17,7 +17,6 @@ class bioem_map_forFFT
{
public:
mycomplex_t cpoints[BIOEM_MAP_SIZE_X*BIOEM_MAP_SIZE_Y];
};
class bioem_convolutedMap
......@@ -49,7 +48,6 @@ public:
__host__ __device__ inline const myfloat_t* getp(int map, int x, int y) const {return(&Ref[map].points[x][y]);}
};
class bioem_RefMap_Mod
{
public:
......
include/param.h
View file @ 82c718f2
......@@ -15,6 +15,7 @@ public:
int maxDisplaceCenter;
int GridSpaceCenter;
int NumberPixels;
int NumberFFTPixels1D;
int NtotDist;
myfloat_t Ntotpi;
myfloat_t volu;
......
map.cpp
View file @ 82c718f2
......@@ -9,7 +9,6 @@
#include "map.h"
#include "param.h"
using namespace std;
int bioem_RefMap::readRefMaps(bioem_param& param)
......@@ -134,12 +133,14 @@ int bioem_RefMap::PreCalculateMapsFFT(bioem_param& param)
/********** Routine that pre-calculates Kernels for Convolution **********************/
/************************************************************************************/
mycomplex_t* localMap;
myfloat_t* localMap;
localMap= (myfloat_t *) myfftw_malloc(sizeof(myfloat_t) *param.param_device.NumberPixels*param.param_device.NumberPixels);
localMap= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) *param.param_device.NumberPixels*param.param_device.NumberPixels);
RefMapFFT = new bioem_map_forFFT[ntotRefMap];
mycomplex_t* localout;
localout= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) *param.param_device.NumberPixels*param.param_device.NumberPixels);
localout= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) *param.param_device.NumberPixels*param.param_device.NumberFFTPixels1D);
for (int iRefMap = 0; iRefMap < ntotRefMap ; iRefMap++)
{
......@@ -148,21 +149,20 @@ int bioem_RefMap::PreCalculateMapsFFT(bioem_param& param)
{
for(int j=0; j< param.param_device.NumberPixels; j++)
{
localMap[i*param.param_device.NumberPixels+j][0]=Ref[iRefMap].points[i][j];
localMap[i*param.param_device.NumberPixels+j][1]=0.0;
localMap[i*param.param_device.NumberPixels+j]=Ref[iRefMap].points[i][j];
}
}
//Calling FFT_Forward
myfftw_execute_dft(param.fft_plan_c2c_forward,localMap,localout);
myfftw_execute_dft_r2c(param.fft_plan_r2c_forward,localMap,localout);
// Normalizing and saving the Reference CTFs
for(int i=0; i < param.param_device.NumberPixels ; i++ )
{
for(int j=0; j < param.param_device.NumberPixels ; j++ )
for(int j=0; j < param.param_device.NumberFFTPixels1D ; j++ )
{
RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberPixels+j][0]=localout[i*param.param_device.NumberPixels+j][0];
RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberPixels+j][1]=localout[i*param.param_device.NumberPixels+j][1];
RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberFFTPixels1D+j][0]=localout[i*param.param_device.NumberFFTPixels1D+j][0];
RefMapFFT[iRefMap].cpoints[i*param.param_device.NumberFFTPixels1D+j][1]=localout[i*param.param_device.NumberFFTPixels1D+j][1];
}
}
......@@ -172,6 +172,5 @@ int bioem_RefMap::PreCalculateMapsFFT(bioem_param& param)
myfftw_free(localMap);
myfftw_free(localout);
return(0);
}
model.cpp
View file @ 82c718f2
......@@ -65,7 +65,6 @@ int bioem_model::readModel()
float z = 0.0;
char tmp[6] = {' '};
// parse name
strncpy(tmp,line+12,4);
sscanf (tmp,"%s",name);
......@@ -172,8 +171,6 @@ int bioem_model::readModel()
return(0);
}
myfloat_t bioem_model::getAminoAcidRad(char *name)
{
/*************** Function that gets the radius for each amino acid ****************/
......@@ -209,7 +206,6 @@ myfloat_t bioem_model::getAminoAcidRad(char *name)
}
myfloat_t bioem_model::getAminoAcidDensity(char *name)
{
/*************** Function that gets the number of electrons for each amino acid ****************/
......@@ -242,6 +238,5 @@ myfloat_t bioem_model::getAminoAcidDensity(char *name)
exit(0);
}
return iaa;
}
param.cpp
View file @ 82c718f2
......@@ -15,6 +15,7 @@ bioem_param::bioem_param()
{
//Number of Pixels
param_device.NumberPixels=0;
param_device.NumberFFTPixels1D = 0;
// Euler angle grid spacing
angleGridPointsAlpha = 0;
angleGridPointsBeta = 0;
......@@ -175,6 +176,7 @@ int bioem_param::readParameters()
}
input.close();
param_device.NumberFFTPixels1D = param_device.NumberPixels / 2 + 1;
cout << " +++++++++++++++++++++++++++++++++++++++++ \n";
cout << "Preparing FFTs\n";
......@@ -183,10 +185,12 @@ int bioem_param::readParameters()
tmp_map = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param_device.NumberPixels * param_device.NumberPixels);
tmp_map2 = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param_device.NumberPixels * param_device.NumberPixels);
fft_plan_c2c_forward = myfftw_plan_dft_2d(param_device.NumberPixels, param_device.NumberPixels, tmp_map, tmp_map2, FFTW_FORWARD, FFTW_MEASURE);
fft_plan_c2c_backward = myfftw_plan_dft_2d(param_device.NumberPixels, param_device.NumberPixels, tmp_map, tmp_map2, FFTW_BACKWARD, FFTW_MEASURE);
fft_plan_c2c_forward = myfftw_plan_dft_2d(param_device.NumberPixels, param_device.NumberPixels, tmp_map, tmp_map2, FFTW_FORWARD, FFTW_MEASURE | FFTW_DESTROY_INPUT);
fft_plan_c2c_backward = myfftw_plan_dft_2d(param_device.NumberPixels, param_device.NumberPixels, tmp_map, tmp_map2, FFTW_BACKWARD, FFTW_MEASURE | FFTW_DESTROY_INPUT);
fft_plan_r2c_forward = myfftw_plan_dft_r2c_2d(param_device.NumberPixels, param_device.NumberPixels, (myfloat_t*) tmp_map, tmp_map2, FFTW_MEASURE | FFTW_DESTROY_INPUT);
fft_plan_c2r_backward = myfftw_plan_dft_c2r_2d(param_device.NumberPixels, param_device.NumberPixels, tmp_map, (myfloat_t*) tmp_map2, FFTW_MEASURE | FFTW_DESTROY_INPUT);
if (fft_plan_c2c_forward == 0 || fft_plan_c2c_backward == 0)
if (fft_plan_c2c_forward == 0 || fft_plan_c2c_backward == 0 || fft_plan_r2c_forward == 0 || fft_plan_c2r_backward == 0)
{
cout << "Error planing FFTs\n";
exit(1);
......@@ -255,7 +259,6 @@ int bioem_param::CalculateGridsParam() //TO DO FOR QUATERNIONS
}
int bioem_param::CalculateRefCTF()
{
/**************************************************************************************/
......@@ -263,14 +266,13 @@ int bioem_param::CalculateRefCTF()
/************************************************************************************/
myfloat_t amp,env,phase,ctf,radsq;
mycomplex_t* localCTF;
myfloat_t* localCTF;
int nctfmax= param_device.NumberPixels / 2;
int n=0;
localCTF= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param_device.NumberPixels*param_device.NumberPixels);
localCTF= (myfloat_t *) myfftw_malloc(sizeof(myfloat_t) * param_device.NumberPixels*param_device.NumberPixels);
refCTF = new bioem_map_forFFT[MAX_REF_CTF];
for (int iamp = 0; iamp < numberGridPointsCTF_amp ; iamp++) //Loop over amplitud
{
amp = (myfloat_t) iamp * gridCTF_amp + startGridCTF_amp;
......@@ -283,7 +285,7 @@ int bioem_param::CalculateRefCTF()
{
env= (myfloat_t) ienv * gridEnvelop + startGridEnvelop;
memset(localCTF,0,param_device.NumberPixels*param_device.NumberPixels*sizeof(mycomplex_t));
memset(localCTF,0,param_device.NumberPixels*param_device.NumberPixels*sizeof(myfloat_t));
//Assigning CTF values
for(int i=0; i< nctfmax; i++)
......@@ -293,25 +295,25 @@ int bioem_param::CalculateRefCTF()
radsq=(myfloat_t) (i*i+j*j) * pixelSize * pixelSize;
ctf=exp(-radsq*env/2.0)*(amp*cos(radsq*phase/2.0)-sqrt((1-amp*amp))*sin(radsq*phase/2.0));
localCTF[i*param_device.NumberPixels+j][0]=(myfloat_t) ctf;
localCTF[i*param_device.NumberPixels+param_device.NumberPixels-j-1][0]=(myfloat_t) ctf;
localCTF[(param_device.NumberPixels-i-1)*param_device.NumberPixels+j][0]=(myfloat_t) ctf;
localCTF[(param_device.NumberPixels-i-1)*param_device.NumberPixels+param_device.NumberPixels-j-1][0]=(myfloat_t) ctf;
localCTF[i*param_device.NumberPixels+j]=(myfloat_t) ctf;
localCTF[i*param_device.NumberPixels+param_device.NumberPixels-j-1]=(myfloat_t) ctf;
localCTF[(param_device.NumberPixels-i-1)*param_device.NumberPixels+j]=(myfloat_t) ctf;
localCTF[(param_device.NumberPixels-i-1)*param_device.NumberPixels+param_device.NumberPixels-j-1]=(myfloat_t) ctf;
}
}
//Creatting FFT_Forward of Kernel to store
mycomplex_t* localout;
localout= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) *param_device.NumberPixels*param_device.NumberPixels);
localout= (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) *param_device.NumberPixels*param_device.NumberFFTPixels1D);
//Calling FFT_Forward
myfftw_execute_dft(fft_plan_c2c_forward,localCTF,localout);
myfftw_execute_dft_r2c(fft_plan_r2c_forward,localCTF,localout);
// Normalizing and saving the Reference CTFs
for(int i=0; i < param_device.NumberPixels ; i++ )
{
for(int j=0; j < param_device.NumberPixels ; j++ )
for(int j=0; j < param_device.NumberFFTPixels1D ; j++ )
{
refCTF[n].cpoints[i*param_device.NumberPixels+j][0]=localout[i*param_device.NumberPixels+j][0];
refCTF[n].cpoints[i*param_device.NumberPixels+j][1]=localout[i*param_device.NumberPixels+j][1];
refCTF[n].cpoints[i*param_device.NumberFFTPixels1D+j][0]=localout[i*param_device.NumberFFTPixels1D+j][0];
refCTF[n].cpoints[i*param_device.NumberFFTPixels1D+j][1]=localout[i*param_device.NumberFFTPixels1D+j][1];
}
}
CtfParam[n].pos[0]=amp;
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment