void fourier_coefficients(double *kz, double *ky, double *kx, grid_t fou, shape_t shape){
int i,j,k;
int kfac;
kx = fftw_alloc_real(fou.nx);
ky = fftw_alloc_real(fou.ny);
kz = fftw_alloc_real(fou.nz);
// kx
if (DEBUG) {printf("kx coefficients\n");}
for (i=0; i<fou.nx; i++){
kx[i] = (double)i*(2.0*M_PI)/shape.x;
if (DEBUG) {printf("%f ", kx[i]);}
}
// ky
if (DEBUG) {printf("\n ky coefficients\n");}
kfac = fou.ny/2-1;
for (j=0; j<fou.ny; j++){
ky[j] = (double)((fou.ny/2+j)%(fou.ny)-fou.ny/2) * (2.0*M_PI)/shape.y;
if (DEBUG) {printf("%f ", ky[j]);}
}
// kz
if (DEBUG) {printf("\n kz coefficients\n");}
kfac = fou.nz/2-1;
for (k=0; k<fou.nz; k++){
kz[k] = (double)((fou.nz/2+k)%(fou.nz)-fou.nz/2) * (2.0*M_PI)/shape.z;
if (DEBUG) {printf("%f ", kz[k]);}
}
if (DEBUG) {printf("\n");}
}
/*! This function allocates the memory neeed to compute the long-range PM
* force. Three fields are used, one to hold the density (and its FFT, and
* then the real-space potential), one to hold the force field obtained by
* finite differencing, and finally a workspace field, which is used both as
* workspace for the parallel FFT, and as buffer for the communication
* algorithm used in the force computation.
*/
void pm_init_periodic_allocate(int dimprod)
{
static int first_alloc = 1;
int dimprodmax;
double bytes_tot = 0;
size_t bytes;
MPI_Allreduce(&dimprod, &dimprodmax, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
/* allocate the memory to hold the FFT fields */
#ifdef FFTW3
if(!(rhogrid = fftw_alloc_real(bytes = fftsize_real)))
#else
if(!(rhogrid = (fftw_real *) malloc(bytes = fftsize * sizeof(fftw_real))))
#endif
{
printf("failed to allocate memory for `FFT-rhogrid' (%g MB).\n", bytes / (1024.0 * 1024.0));
endrun(1);
}
bytes_tot += bytes;
#ifdef FFTW3
if(!(forcegrid = fftw_alloc_real(bytes = imax(fftsize_real, dimprodmax) * 2)))
#else
if(!(forcegrid = (fftw_real *) malloc(bytes = imax(fftsize, dimprodmax) * sizeof(fftw_real))))
#endif
{
printf("failed to allocate memory for `FFT-forcegrid' (%g MB).\n", bytes / (1024.0 * 1024.0));
endrun(1);
}
bytes_tot += bytes;
#ifdef FFTW3
if(!(workspace = fftw_alloc_real(bytes = imax(maxfftsize, dimprodmax) * 2)))
#else
if(!(workspace = (fftw_real *) malloc(bytes = imax(maxfftsize, dimprodmax) * sizeof(fftw_real))))
#endif
{
printf("failed to allocate memory for `FFT-workspace' (%g MB).\n", bytes / (1024.0 * 1024.0));
endrun(1);
}
bytes_tot += bytes;
if(first_alloc == 1)
{
first_alloc = 0;
if(ThisTask == 0)
printf("\nAllocated %g MByte for FFT data.\n\n", bytes_tot / (1024.0 * 1024.0));
}
fft_of_rhogrid = (fftw_complex *) & rhogrid[0];
}
void acarFluid::allocate() {
vorticity = fftw_alloc_real(width*height);
velocityU = fftw_alloc_real(width*height);
velocityV = fftw_alloc_real(width*height);
levelset = fftw_alloc_real(width*height);
levelsetTemp = fftw_alloc_real(width*height);
levelsetF = fftw_alloc_real(width*height);
levelsetSmooth = fftw_alloc_real(width*height);
stream = fftw_alloc_real(width*height);
streamF = fftw_alloc_real(width*height);
}
void Convolve_t::create_plans(const long n1, const long n2, const bool meas)
{
if (n1 != N1 || n2 != N2) free_memory();
if (in1 != nullptr) return;
N1 = n1;
N2 = n2;
N = N1 + N2;
measure = meas;
auto flag = measure ? FFTW_MEASURE: FFTW_ESTIMATE;
in1 = fftw_alloc_real(N);
in2 = fftw_alloc_real(N);
p1 = fftw_plan_r2r_1d(N, in1, in1, FFTW_R2HC, flag);
p2 = fftw_plan_r2r_1d(N, in2, in2, FFTW_R2HC, flag);
pr = fftw_plan_r2r_1d(N, in1, in1, FFTW_HC2R, flag);
}
Field::Field(std::shared_ptr<const Plasma> plasma) :
_plasma(plasma), _size(plasma->get_grid_size())
/* constructor from Plasma */
{
_values = fftw_alloc_real(_size + 1);
_fft_forward = fftw_plan_r2r_1d(_size, _values, _values,
FFTW_R2HC, FFTW_MEASURE);
_fft_inverse = fftw_plan_r2r_1d(_size, _values, _values,
FFTW_HC2R, FFTW_MEASURE);
}
/*
* === FUNCTION ======================================================================
* Name: makeNewGrid
* Arguments: int gridDim - Dimensions dimXdim of new grid.
* Returns: Pointer to new grid object.
* Description: Makes new grid object and sets all data points to 0.
* =====================================================================================
*/
Grid * makeNewGrid(int gridDimX, int gridDimY) {
fftw_mpi_init() ;
Grid * newGrid = malloc(sizeof(Grid)) ;
ptrdiff_t localDimY, globalOffset, localDimX ;
newGrid->allocScheme = fftw_mpi_local_size_2d(gridDimY, gridDimX, MPI_COMM_WORLD, &localDimY, &globalOffset);
newGrid->localGridDimY = localDimY ;
newGrid->localGridDimX = gridDimX ;
newGrid->globalGridDimY = gridDimY ;
newGrid->globalGridDimX = gridDimX ;
newGrid->globalOffset = globalOffset ;
newGrid->gridPoints = fftw_alloc_real(newGrid->allocScheme) ;
return newGrid ;
} /* ----- end of function makeNewGrid ----- */
static void prepare_fftw(struct holder *holder)
{
unsigned int a;
// init buffer for samples
holder->samples = fftw_alloc_real(holder->samples_count);
if (!holder->samples)
errx(3, "cannot allocate input");
// init buffer for windowed samples
holder->windowed_samples = fftw_alloc_real(holder->samples_count);
if (!holder->samples)
errx(3, "cannot allocate window space");
// init fft output buffer
holder->output = fftw_alloc_complex(holder->fftout_count);
if (!holder->output)
errx(3, "cannot allocate output");
holder->max = (double *)malloc(holder->fftout_count * sizeof(double));
for(int i = 0; i<holder->fftout_count; i++) holder->max[i] = 0.000000000000001;//;// FLT_MIN;
// // null all
// for (a = 0; a < holder->samples_count; a++) {
// holder->samples[a] = 0;
// holder->windowed_samples[a] = 0;
// }
// for (int i = 0; i < holder->fftout_count; i++) {
// holder->output[i] = 0;
// }
// calculate a blackman window if not already done
holder->blackman_window = (double*)malloc(holder->samples_count * sizeof(double));
for(int i = 0; i < holder->samples_count; i++)
holder->blackman_window[i] = 0.53836 - 0.46164*cos( 2*M_PI * i / ( holder->samples_count-1) );
holder->plan = fftw_plan_dft_r2c_1d(holder->samples_count, holder->windowed_samples, holder->output, 0);
if (!holder->plan)
errx(3, "plan not created");
}
static void prepare_fftw(struct holder *holder)
{
unsigned int a;
holder->samples = fftw_alloc_real(holder->samples_count);
if (!holder->samples)
errx(3, "cannot allocate input");
holder->output = fftw_alloc_complex(holder->samples_count);
if (!holder->output)
errx(3, "cannot allocate output");
for (a = 0; a < holder->samples_count; a++) {
holder->samples[a] = 0;
holder->output[a] = 0;
}
holder->plan = fftw_plan_dft_r2c_1d(holder->samples_count,
holder->samples, holder->output, 0);
if (!holder->plan)
errx(3, "plan not created");
}
int main(int argc, char **argv){
int np[2];
ptrdiff_t n[3], ni[3], no[3], N[3];
ptrdiff_t alloc_local_forw, alloc_local_back, alloc_local, howmany;
ptrdiff_t local_ni[3], local_i_start[3];
ptrdiff_t local_n[3], local_start[3];
ptrdiff_t local_no[3], local_o_start[3];
double err, *in, *out;
pfft_plan plan_forw=NULL, plan_back=NULL;
MPI_Comm comm_cart_2d;
fftw_r2r_kind kinds_forw[3], kinds_back[3];
/* Set size of FFT and process mesh */
ni[0] = ni[1] = ni[2] = 16;
n[0] = 29; n[1] = 27; n[2] = 31;
for(int t=0; t<3; t++)
no[t] = ni[t];
np[0] = 2; np[1] = 2;
howmany = 1;
/* Set PFFT kinds of 1d R2R trafos */
kinds_forw[0] = PFFT_REDFT00; kinds_back[0] = PFFT_REDFT00;
kinds_forw[1] = PFFT_REDFT01; kinds_back[1] = PFFT_REDFT10;
kinds_forw[2] = PFFT_RODFT00; kinds_back[2] = PFFT_RODFT00;
/* Set logical DFT sizes corresponding to FFTW manual:
* for REDFT00 N=2*(n-1), for RODFT00 N=2*(n+1), otherwise N=2*n */
N[0] = 2*(n[0]-1);
N[1] = 2*n[1];
N[2] = 2*(n[2]+1);
/* Initialize MPI and PFFT */
MPI_Init(&argc, &argv);
pfft_init();
/* Create two-dimensional process grid of size np[0] x np[1], if possible */
if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){
pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]);
MPI_Finalize();
return 1;
}
/* Get parameters of data distribution */
alloc_local_forw = pfft_local_size_many_r2r(3, n, ni, n, howmany,
PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS,
comm_cart_2d, PFFT_TRANSPOSED_OUT,
local_ni, local_i_start, local_n, local_start);
alloc_local_back = pfft_local_size_many_r2r(3, n, n, no, howmany,
PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS,
comm_cart_2d, PFFT_TRANSPOSED_IN,
local_n, local_start, local_no, local_o_start);
/* Allocate enough memory for both trafos */
alloc_local = (alloc_local_forw > alloc_local_back) ?
alloc_local_forw : alloc_local_back;
in = fftw_alloc_real(alloc_local);
out = fftw_alloc_real(alloc_local);
/* Plan parallel forward FFT */
plan_forw = pfft_plan_many_r2r(
3, n, ni, n, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS,
in, out, comm_cart_2d, kinds_forw, PFFT_TRANSPOSED_OUT| PFFT_MEASURE| PFFT_DESTROY_INPUT);
/* Plan parallel backward FFT */
plan_back = pfft_plan_many_r2r(
3, n, n, no, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS,
out, in, comm_cart_2d, kinds_back, PFFT_TRANSPOSED_IN| PFFT_MEASURE| PFFT_DESTROY_INPUT);
/* Initialize input with random numbers */
pfft_init_input_real_3d(ni, local_ni, local_i_start,
in);
/* Execute parallel forward FFT */
pfft_execute(plan_forw);
/* clear the old input */
pfft_clear_input_real_3d(ni, local_ni, local_i_start,
in);
/* execute parallel backward FFT */
pfft_execute(plan_back);
/* Scale data */
for(ptrdiff_t l=0; l < local_ni[0] * local_ni[1] * local_ni[2]; l++)
in[l] /= (N[0]*N[1]*N[2]);
/* Print error of back transformed data */
MPI_Barrier(MPI_COMM_WORLD);
err = pfft_check_output_real_3d(ni, local_ni, local_i_start, in, comm_cart_2d);
pfft_printf(comm_cart_2d, "Error after one forward and backward trafo of size n=(%td, %td, %td):\n", n[0], n[1], n[2]);
pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err);
/* free mem and finalize MPI */
pfft_destroy_plan(plan_forw);
pfft_destroy_plan(plan_back);
MPI_Comm_free(&comm_cart_2d);
fftw_free(in); fftw_free(out);
MPI_Finalize();
return 0;
}
int uint16_1chan(struct core_param o, struct core_return *retstr) {
fftw_plan fftplan;
unsigned long int s_bytes, i_bytes, o_bytes, ret;
unsigned long int i, ffts, iavg, /* iphs,*/ nyq, seeksamp, bps;
long int bl_first, bl_last;
long int power, maxmag = 0, minmag = 0;
off_t dataend, bskip_avg = 0, bskip_fft = 0;
// double cur_mag[o.N], avg_mag[o.N], window[o.N], pow_adj;
double cur_mag[o.N], avg_mag[o.N], pow_adj;
double dataz;
// complex double avg_phs[o.N][N_PHASES];
// complex double nphs;
struct timeval now,then;
// unsigned flags = FFTW_PATIENT|FFTW_DESTROY_INPUT;
unsigned flags = FFTW_MEASURE|FFTW_DESTROY_INPUT;
// unsigned flags = FFTW_ESTIMATE|FFTW_DESTROY_INPUT;
double time, ratio;
struct timespec nsl;
FILE *istream, *ostream, *tstream = NULL;//, *phstream;
/* For timestamp conversion */
double tConv;
struct tm tm_initial;
struct tm tm_info;
int haveTimeStr;
double seconds;
char tBuf[255];
signal(SIGINT,do_depart);
/*
* Complex/Real Input
*/
unsigned short int *samples;
double *input, * window;
fftw_complex *output;
bps = sizeof(unsigned short int); // real, unsigned short int (2-byte) data
s_bytes = bps*o.N;
i_bytes = sizeof(double)*o.N;
o_bytes = sizeof(fftw_complex)*o.N;
nyq = o.N/2;
// complex double datai[nyq];
//printf("bps: %d\n",bps);
/* if there's a start string, use it! */
haveTimeStr = 0;
if( strncmp(o.tStartString,"",19) > 0) {
setenv("TZ", "UTC0", 1); //Set timezone to UTC
printf("startString: %s\n",o.tStartString);
printf("o.time_avg : %.04f\n",o.time_avg);
/* One to keep track of changing time, one to keep start time */
memset(&tm_initial, 0, sizeof(struct tm));
memset(&tm_info, 0, sizeof(struct tm));
strptime(o.tStartString,"%Y-%m-%d/%H:%M:%S",&tm_initial);
strptime(o.tStartString,"%Y-%m-%d/%H:%M:%S",&tm_info);
/* tm_initial.tm_sec = 0; */
/* tm_info.tm_sec = 0; */
/* strftime(tBuf,sizeof(tBuf), "%d %b %Y %H:%M",&tm_info); */
/* puts(tBuf); */
haveTimeStr = 1;
} else {
/* What about time units for x axis? */
tConv = 1;
if( strncmp(o.time_units,"m",1) == 0) {
tConv = 60;
} else if( strncmp(o.time_units,"h",1) == 0) {
tConv = 3600;
} else if( strncmp(o.time_units,"d",1) == 0) {
tConv = 86400;
}
printf("tConv: %.0f (units: %s)\n",tConv,o.time_units);
}
/*
* Memory allocation.
*/
printf("Memory allocation...");
samples = (unsigned short int *) malloc(s_bytes);
if (samples == NULL) fprintf(stderr,"Failed to allocate initial sample memory!\n");
// input = (double *) fftw_malloc(i_bytes);
input = (double *) fftw_alloc_real(i_bytes);
if (input == NULL) fprintf(stderr,"Failed to allocate fft input array!\n");
window = (double *) fftw_alloc_real(i_bytes);
if (input == NULL) fprintf(stderr,"Failed to allocate fft input array!\n");
// output = (fftw_complex *) fftw_malloc(o_bytes);
output = (fftw_complex *) fftw_alloc_complex(o_bytes);
if (output == NULL) fprintf(stderr,"Failed to allocate fft output array!\n");
printf("done. (%liKB)\n",(s_bytes + i_bytes + o_bytes)/1024);
/*
* FFTW Setup. Initialize threads, plan_many.
*/
printf("FFTW initialization and planning...");
gettimeofday(&then,NULL);
if (o.threads > 1) {
if (fftw_init_threads() == 0) {
fprintf(stderr,"Failed to initialize FFTW Threads!\n");
}
fftw_plan_with_nthreads(o.threads);
}
/*
* fftw_plan fftw_plan_dft_1d(int n,
fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
*/
/*
* fftw_plan fftw_plan_dft_r2c_1d(
* int n, double *in, fftw_complex *out, unsigned flags);
*/
fftplan = fftw_plan_dft_r2c_1d(o.N, input, output, flags);
gettimeofday(&now,NULL);
printf("wewt. (%fs elapsed)\n",(now.tv_sec-then.tv_sec)+(now.tv_usec-then.tv_usec)/1e6);
/*
* File setup
*/
printf("Opening files...");
istream = fopen(o.infile,"r");
if (istream == NULL) {
fprintf(stderr,"Failed to open %s for reading.\n",o.infile);
return(1);
}
if (strcmp(o.timefile,"") != 0) {
tstream = fopen(o.timefile,"r");
if (tstream == NULL) {
fprintf(stderr,"Failed to open %s for reading.\n",o.timefile);
return(1);
}
}
ostream = fopen(o.outfile,"w+");
if (ostream == NULL) {
fprintf(stderr,"Failed to open %s for writing.\n",o.outfile);
return(1);
}
printf("fiddling...");
fseek(istream,0,SEEK_END);
dataend = ftello(istream)-s_bytes;
if (o.newheader == COREH_TAIL) {
dataend -= 8192;
}
rewind(istream);
seeksamp = o.n_startsample*s_bytes;
if (fseeko(istream,seeksamp,SEEK_SET)){
fprintf(stderr,"Failed to seek to starting sample!\n");
}
/*
* Window selection, and setup to adjust for Coherent Gain,
* 2x for real input data, and hz/bin multiplier.
*/
window_sel(window,&o);
pow_adj = window_cog(&o)*2*(o.frequency/o.N);
nsl.tv_sec = 0; nsl.tv_nsec = CORE_RFP;
if (o.bl_last == -1) bl_last = nyq; else bl_last = o.bl_last;
if (o.bl_first == -1) bl_first = 1; else bl_first = o.bl_first;
if (o.skip_avg > 0) bskip_avg = bps*o.skip_avg;
if (o.skip_fft > 0) bskip_fft = bps*o.skip_fft;
ffts = 0;
iavg = 0;
time = o.time_start;
seconds = 0;
printf("done.\n"); fflush(stdout); fflush(stderr);
running = true;
while ((ftello(istream) < dataend) && (running == true)) {
nanosleep(&nsl,NULL);
/*
* Main loop: read in data while data is still readable.
*/
ret = fread(samples,bps,o.N,istream);
if (ret != o.N) {
printf("Failed to read from data file.\n");
}
/*
* Copy channels to input array, switching from row-major to
* column-major ordering to satisfy the (hopefully faster)
* plan_many data format, and casting to proper form as we go.
*/
for (i = 0; i < o.N; i++) {
dataz = (double) samples[i];
if (o.convert) {
dataz = apply_polynomial(&o.poly[0], dataz);
}
input[i] = dataz*window[i];
}
fftw_execute(fftplan); // FOR GLORY!!!
/*
* Get the squared magnitude, adjust powers
*/
for (i = 0; i < nyq; i++) {
// iphs = 0;
cur_mag[i] = pow_adj*pow(cabs(output[i]),2);
/* if (o.phases) {
for (k = j+1; k < o.n_chan; k++) {
if (iavg == 0) avg_phs[i][j][iphs] = 0;
avg_phs[i][j][iphs] += datai[i][j]*conj(datai[i][k]);
iphs++;
}
}*/
}
/*
* Find the AGC ratio, apply to all data,
* and sum into averaging array.
*/
if (o.agc_level != 0) {
ratio = o.agc_level/cur_mag[o.agc_bin-1];
for (i = 0; i < nyq; i++) {
if (iavg == 0) avg_mag[i] = 0; // First average, so initialize
avg_mag[i] += cur_mag[i]*ratio;
}
} else {
for (i = 0; i < nyq; i++) {
if (iavg == 0) avg_mag[i] = 0; // First average, so initialize
avg_mag[i] += cur_mag[i];
}
}
iavg++;
if (iavg == o.avg) {
/*
* We've averaged enough, output to files.
*/
if (tstream != NULL) {
fscanf(tstream,"%lf\n",&time);
}
if (o.verbose) printf("%f\n",time);
if(haveTimeStr > 0){
/* Need to update seconds? */
/* printf("time: %.5f, %8.5f\n",time,time*1000); */
if(seconds > 1){
tm_info.tm_sec += floor(seconds);
seconds -= floor(seconds);
mktime( &tm_info); // normalize tm_info
}
if(haveTimeStr == 1){
strftime(tBuf,sizeof(tBuf),"%m-%d/%H:%M:%S",&tm_info);
haveTimeStr++;
} else{
strftime(tBuf,sizeof(tBuf),"%H:%M:%S",&tm_info);
}
fprintf(ostream,"%*s.%03.0f\n",strlen(tBuf),tBuf,seconds*1000);
/* printf("%s. %3.0f\n",tBuf,roundl(seconds*((double) 1000))); */
/* printf("%*s.%03.0f\n",strlen(tBuf),tBuf,seconds*1000); */
/* printf("%s\n",tBuf); */
} else{
fprintf(ostream,"%8.03f\n",time/tConv); // Timestamps
}
/* if (o.phases) {
fprintf(phstream,"%.8f\n",time);
}
*/
for (i = bl_first-1; i < bl_last; i++) {
if (o.linear == true) {
return(1); //not working
power = avg_mag[i]/o.avg;
} else {
power = lround(10 * log10(avg_mag[i]/o.avg)); // log10(|x|^2)
}
//power &= 65535; // Trim to 16 bits.
if (!o.binary) {
fprintf(ostream,"%li\n", power);
} else {
// Blerg
}
/*
* Find global min & max.
*/
if (ffts == 0) {
minmag = maxmag = power;
} else {
minmag = fmin(power, minmag);
maxmag = fmax(power, maxmag);
}
/* if (o.phases) {
for (k = 0; k < N_PHASES; k++) {
nphs = avg_phs[i][j][k]/( \
avg_mag[i][n_phsmap[k][0]] * \
avg_mag[i][n_phsmap[k][1]] );
if (k > 0) fprintf(phstream," ");
fprintf(phstream,"%2.2f %2.2f",cabs(nphs),carg(nphs));
}
fprintf(phstream,"\n");
}*/
}
/* Add time per avg. */
if (o.time_avg > 0) {
time += o.time_avg;
seconds += o.time_avg;
}
if (o.skip_avg > 0) {
ret = fseeko(istream,bskip_avg,SEEK_CUR);
if (ret != 0) {
fprintf(stderr,"Failed to skip to next sample: %s\n",strerror(errno));
return(1);
}
}
iavg = 0;
}
ffts++;
if (ffts == o.n_ffts) break;
if ((o.time_stop != 0) && (time > o.time_stop)) break;
/*
* This will add o.time_nffts to the timestamp every o.time_fftmod ffts.
* Interaction with o.time_avg must be carefully considered to get
* the correct timestamp advancement. Also note that some programs that
* may end up processing this data (e.g. for ps making) do not like it
* when timestamps increase inconsistently.
*/
if ((o.time_nfft > 0) && (ffts % o.time_fftmod == 0)) {
printf("modding FFT time!\n");
time += o.time_nfft;
seconds += o.time_nfft;
}
if (o.skip_fft > 0) {
ret = fseeko(istream,bskip_fft,SEEK_CUR);
if (ret != 0) {
fprintf(stderr,"Failed to skip to next sample!\n");
return(1);
}
}
}
fclose(istream);
fclose(ostream);
if (tstream != NULL) {
fclose(tstream);
}
//fclose(phstream);
retstr->time_total = time-o.time_start;
retstr->nfft = ffts;
retstr->min[0] = minmag;
retstr->max[0] = maxmag;
return(0);
}
int main(int argc, char*argv[])
{
FILE *in, *out;
char filename[128], *dot;
int i, j, k, value[9], index, chan[3];
int numsamples, numgroups;
double *rawdata, *rawin, *endraw;
double *pass1, *passptr, *pass2;
double bcoef[8][3], acoef[8][3];
double stage[3][8][3]; // curve, harmonic, history (dimension meaning)
fftw_plan plan, invrs;
double *fftin, *mag, phase, *fftrvout, maxmag[32];
fftw_complex *fftout, *fftrvin;
in = fopen(argv[1], "r");
if(!in)
{
printf("can't find file %s\n", argv[1]);
exit(0);
}
strcpy(filename, argv[1]);
dot = strstr( filename, ".data");
strcpy( dot, ".raw");
printf("output filename: %s\n", filename);
out = fopen(filename, "w");
if(!out)
{
printf("can't create %s\n", filename);
exit(0);
}
/* assume we don't take more than 30 minutes worth of data */
rawdata = (double*) malloc(sizeof(double)*3*2000*30*60);
rawin = &rawdata[3*3]; // zero out first sample
/* Each channel uses 3 bytes. There are 3 channels. */
while(!feof(in))
{
for(i=0; i<9; i++) value[i] = fgetc(in);
chan[0] = (value[0] << 16) | (value[1] << 8) | value[2];
if(chan[0] & 0x800000) chan[0] |= 0xff000000;
chan[1] = (value[3] << 16) | (value[4] << 8) | value[5];
if(chan[1] & 0x800000) chan[1] |= 0xff000000;
chan[2] = (value[6] << 16) | (value[7] << 8) | value[8];
if(chan[2] & 0x800000) chan[2] |= 0xff000000;
*rawin = chan[0];
rawin++;
*rawin = chan[1];
rawin++;
*rawin = chan[2];
rawin++;
}
fclose(in);
for(i=0; i<9; i++) // zero fill initial data
rawdata[i] = 0.0;
endraw = rawin - 9; // ignore last values collected
for(i=0; i<9; i++)
endraw[i] = 0.0;
endraw += 9;
printf("data read in\n");
rawin = rawdata;
while (rawin < endraw)
{
fprintf(out, "%lf %lf %lf\n", rawin[0], rawin[1], rawin[2]);
rawin += 3;
}
fclose(out);
numsamples = (endraw - rawdata)/3;
printf("saving %d samples\n", numsamples);
/* compute IIR notch filter
one notch for each odd harmonic of 60 Hz out to 900 Hz */
dot = strstr( filename, ".raw");
strcpy( dot, ".plt_ntch");
printf("output filename: %s\n", filename);
out = fopen(filename, "w");
if(!out)
{
printf("can't create %s\n", filename);
exit(0);
}
pass1 = (double*)malloc(sizeof(double)*(3*numsamples + 6*FILTER_TAP_NUM));
rawin = rawdata + 3*3;
passptr = pass1 + 3*(FILTER_TAP_NUM - 3);
// notch filter
bcoef[0][0] = (1.0 + A12)/2.0;
bcoef[0][1] = A11;
bcoef[0][2] = (1.0 + A12)/2.0;
acoef[0][0] = 1.0;
acoef[0][1] = A11;
acoef[0][2] = A12;
bcoef[1][0] = (1.0 + A32)/2.0;
bcoef[1][1] = A31;
bcoef[1][2] = (1.0 + A32)/2.0;
acoef[1][0] = 1.0;
acoef[1][1] = A31;
acoef[1][2] = A32;
bcoef[2][0] = (1.0 + A52)/2.0;
bcoef[2][1] = A51;
bcoef[2][2] = (1.0 + A52)/2.0;
acoef[2][0] = 1.0;
acoef[2][1] = A51;
acoef[2][2] = A52;
bcoef[3][0] = (1.0 + A72)/2.0;
bcoef[3][1] = A71;
bcoef[3][2] = (1.0 + A72)/2.0;
acoef[3][0] = 1.0;
acoef[3][1] = A71;
acoef[3][2] = A72;
bcoef[4][0] = (1.0 + A92)/2.0;
bcoef[4][1] = A91;
bcoef[4][2] = (1.0 + A92)/2.0;
acoef[4][0] = 1.0;
acoef[4][1] = A91;
acoef[4][2] = A92;
bcoef[5][0] = (1.0 + A112)/2.0;
bcoef[5][1] = A111;
bcoef[5][2] = (1.0 + A112)/2.0;
acoef[5][0] = 1.0;
acoef[5][1] = A111;
acoef[5][2] = A12;
bcoef[6][0] = (1.0 + A132)/2.0;
bcoef[6][1] = A131;
bcoef[6][2] = (1.0 + A132)/2.0;
acoef[6][0] = 1.0;
acoef[6][1] = A131;
acoef[6][2] = A132;
bcoef[7][0] = (1.0 + A152)/2.0;
bcoef[7][1] = A151;
bcoef[7][2] = (1.0 + A152)/2.0;
acoef[7][0] = 1.0;
acoef[7][1] = A151;
acoef[7][2] = A152;
for(k=0; k<3; k++)
for(i=0; i<8; i++)
for(j=0; j<3; j++)
stage[k][i][j] = 0.0;
while(rawin < endraw)
{
for(j=0; j<3; j++) // loop over each curve
{
stage[j][0][2] = 0.0;
for(i=0; i<3; i++)
stage[j][0][2] += rawin[-3*i + j]*bcoef[0][i];
stage[j][0][2] -= acoef[0][1]*stage[j][0][1] + acoef[0][2]*stage[j][0][0];
for(k=1; k<7; k++) // loop over each harmonic
{
stage[j][k][2] = 0.0;
for(i=0; i<3; i++)
stage[j][k][2] += stage[j][k-1][2-i]*bcoef[k][i];
stage[j][k][2] -= acoef[k][1]*stage[j][k][1] + acoef[k][2]*stage[j][k][0];
}
passptr[j] = 0.0;
for(i=0; i<3; i++)
passptr[j] += stage[j][6][2-i]*bcoef[7][i];
passptr[j] -= acoef[7][1]*passptr[j-3] + acoef[7][2]*passptr[j-6];
for(k=0; k<7; k++)
{
stage[j][k][0] = stage[j][k][1];
stage[j][k][1] = stage[j][k][2];
}
/*
passptr[j] = 0.0;
for(i=0; i<3; i++)
passptr[j] += rawin[-3*i + j]*bcoef[0][i];
passptr[j] -= acoef[0][1]*passptr[j-3] + acoef[0][2]*passptr[j-6];
*/
}
passptr += 3;
rawin += 3;
}
printf("done with pass 1\n");
/* perform FIR low pass on remaining data */
endraw = passptr;
pass2 = (double*)malloc(sizeof(double)*(3*numsamples + 3*FILTER_TAP_NUM));
rawin = pass1;
passptr = pass2;
while(rawin < endraw + 3*FILTER_TAP_NUM)
{
for(j=0; j<3; j++)
{
passptr[j] = 0.0;
for(i=0; i<FILTER_TAP_NUM; i++)
passptr[j] += rawin[3*i + j]*filter_taps[i];
}
passptr += 3;
rawin += 3;
}
printf("done with pass 2\n");
/* save data for gnuplot */
rawin = pass2 + 6*FILTER_TAP_NUM;
for(i=0; i<numsamples - 3*FILTER_TAP_NUM; i++)
{
fprintf(out, "%lf %lf %lf\n", rawin[0] , rawin[1], rawin[2]);
rawin += 3;
}
fclose(out);
/* save data for further processing */
dot = strstr( filename, ".plt_ntch");
strcpy( dot, ".bin_ntch");
printf("output filename: %s\n", filename);
out = fopen(filename, "w");
if(!out)
{
printf("can't create %s\n", filename);
exit(0);
}
fwrite(pass2 + 6*FILTER_TAP_NUM, sizeof(double), (numsamples - FILTER_TAP_NUM)*3, out);
fclose(out);
exit(0); // skip FFT's for now
/* compute 1D FFT's on each wave form */
fftin = fftw_alloc_real(FFTSIZE);
fftout = fftw_alloc_complex(FFTSIZE/2);
mag = (double*)malloc(sizeof(double)*FFTSIZE/2);
plan = fftw_plan_dft_r2c_1d(FFTSIZE, fftin, fftout, FFTW_MEASURE);
rawin = pass1;
k = 0;
while(rawin < endraw - 3*FFTSIZE)
{
for(i=0; i<FFTSIZE; i++) fftin[i] = rawin[3*i + 2];
fftw_execute(plan);
strcpy(filename, argv[1]);
dot = strstr( filename, ".data");
sprintf( dot, "_%03d_fft.plt", k);
printf("output filename: %s\n", filename);
out = fopen(filename, "w");
if(!out)
{
printf("can't create %s\n", filename);
exit(0);
}
for(i=0; i<FFTSIZE/2; i++)
{
mag[i] = sqrt(fftout[i][0]*fftout[i][0] + fftout[i][1]*fftout[i][1]);
phase = atan2(fftout[i][1], fftout[i][0]);
fprintf(out, "%lg %lg\n", mag[i], phase);
}
fclose(out);
k++;
rawin += 3*FFTSIZE;
}
fftw_free(fftin);
fftw_free(fftout);
free(mag);
free(pass1);
free(pass2);
free(rawdata);
}
Buffer::Memory::Memory(int n)
{
memory = fftw_alloc_real(n);
}
/*****************
* Version DOUBLE
*****************/
void Chi2LibFFTW::conv2d_fft(MyMatrix<double> *img, MyMatrix<double> *kernel_img, MyMatrix<double> *output){
MyLogger::log()->debug("[Chi2LibFFTW][conv2d_fft] Generating Convolution using FFTW");
fftw_complex *fft_image, *fft_kernel;
fftw_plan plan_forward_image, plan_forward_kernel, plan_backward;
//auxiliary structures are necessary because fftw3 optimization plan will destroy it!
double *ifft_result, *data, *kernel;
int nwidth = (int)(img->sX()+kernel_img->sX()-1);
int nheight = (int)(img->sY()+kernel_img->sY()-1);
pthread_mutex_lock( &mutex1 );
// FFTW Allocs
size_t size = (size_t)(nwidth * nheight);
//the new size includes zero padding space
data = fftw_alloc_real(size);
kernel = fftw_alloc_real(size);
ifft_result = fftw_alloc_real(size);
//fftw handle real fft avoiding redundancy in the complex plane, therefore the nheight/2
size = (size_t)(nwidth*(floor(nheight/2) + 1));
fft_image = fftw_alloc_complex(size);
fft_kernel = fftw_alloc_complex(size);
plan_forward_image = fftw_plan_dft_r2c_2d( nwidth, nheight, data, fft_image, FFTW_ESTIMATE );
plan_forward_kernel = fftw_plan_dft_r2c_2d( nwidth, nheight, kernel, fft_kernel, FFTW_ESTIMATE );
plan_backward = fftw_plan_dft_c2r_2d( nwidth, nheight, fft_image, ifft_result, FFTW_ESTIMATE );
pthread_mutex_unlock( &mutex1 );
//populate kernel and shift input
for(unsigned int x = 0 ; x < (unsigned int)nwidth ; ++x ){
unsigned int xnw = x*nwidth;
for(unsigned int y=0; y < (unsigned int)nheight; ++y){
if(x < kernel_img->sX() && y < kernel_img->sY())
kernel[xnw+ y] = kernel_img->getValue(x,y);
else
kernel[xnw+ y] = 0;
}
}
for(unsigned int x = 0 ; x < (unsigned int)nwidth ; ++x ){
unsigned int xnw = x*nwidth;
for(unsigned int y=0; y < (unsigned int)nheight; ++y){
if(x < img->sX() && y < img->sY())
data[xnw+ y] = img->getValue(x,y);
else
data[xnw+ y] = 0;
}
}
MyLogger::log()->debug("[Chi2LibFFTW][conv2d_fft] Starting FFTW");
/** FFT Execute */
//fft of image
fftw_execute( plan_forward_image );
//fft of kernel
fftw_execute( plan_forward_kernel );
//convolution in fourier domain
double f1, f2;
double nwnh = (double)(nwidth*nheight);
unsigned int limit = (unsigned int)(nwidth * (floor(nheight/2) + 1));
for(unsigned int i=0; i< limit; ++i){
f1 = fft_image[i][0]*fft_kernel[i][0] - fft_image[i][1]*fft_kernel[i][1];
f2 = fft_image[i][0]*fft_kernel[i][1] + fft_image[i][1]*fft_kernel[i][0];
fft_image[i][0]=f1/nwnh;
fft_image[i][1]=f2/nwnh;
}
//ifft of the product
fftw_execute( plan_backward );
/** FFT Execute */
MyLogger::log()->debug("[Chi2LibFFTW][conv2d_fft] FFTW Finished");
if(output->sX() == (unsigned int)nwidth && output->sY() == (unsigned int)nheight)
for(unsigned int x = 0 ; x < output->sX() ; ++x ){
unsigned int xnw = x*nwidth;
for(unsigned int y = 0 ; y < output->sY() ; ++y ){
output->at(x,y) = ifft_result[xnw+y];
}
}
/* free memory */
fftw_destroy_plan( plan_forward_image );
fftw_destroy_plan( plan_forward_kernel );
fftw_destroy_plan( plan_backward );
fftw_free( data );
fftw_free( kernel );
fftw_free( ifft_result );
fftw_free( fft_image );
fftw_free( fft_kernel );
}
/* --------------------------------------------------------------------------- *
* This overloaded function is an implementation of your tone mapping operator *
* --------------------------------------------------------------------------- */
int TMOZhao10::Transform()
{
double* data;
int size = pSrc->GetHeight()*pSrc->GetWidth();
int spec_size = pSrc->GetHeight()*(pSrc->GetWidth()/2+1);
double *rgb[] = {fftw_alloc_real(size),fftw_alloc_real(size),fftw_alloc_real(size)};
double *lab[] = {fftw_alloc_real(size),fftw_alloc_real(size),fftw_alloc_real(size)};
fftw_complex *spec_rgb[] = {fftw_alloc_complex(spec_size),fftw_alloc_complex(spec_size),fftw_alloc_complex(spec_size)};
fftw_complex *spec_lab[] = {fftw_alloc_complex(spec_size),fftw_alloc_complex(spec_size),fftw_alloc_complex(spec_size)};
double *theta = fftw_alloc_real(spec_size);
double *phi = fftw_alloc_real(spec_size);
fftw_complex *spec_gray = fftw_alloc_complex(spec_size);
double *gray = fftw_alloc_real(size);
fftw_plan p = fftw_plan_dft_r2c_2d(pSrc->GetHeight(), pSrc->GetWidth(),rgb[0], spec_rgb[0], FFTW_ESTIMATE);
//copy data channels to r,g,b arrays
data=pSrc->GetData();
for(int i=0;i<size;++i){
rgb[0][i] = *data++;
rgb[1][i] = *data++;
rgb[2][i] = *data++;
}
//transform to Lab space
pSrc->Convert(TMO_LAB);
pDst->Convert(TMO_LAB);
//copy data channels to l,a,b array
data=pSrc->GetData();
for(int i=0;i<size;++i){
lab[0][i] = *data++/100;
lab[1][i] = *data++/100;
lab[2][i] = *data++/100;
//fprintf(stderr,"%f %f %f\n",lab[0][i],lab[1][i],lab[2][i]);
}
//compute fft of all channels
fftw_execute_dft_r2c(p,rgb[0], spec_rgb[0]);
fftw_execute_dft_r2c(p,rgb[1], spec_rgb[1]);
fftw_execute_dft_r2c(p,rgb[2], spec_rgb[2]);
fftw_execute_dft_r2c(p,lab[0], spec_lab[0]);
fftw_execute_dft_r2c(p,lab[1], spec_lab[1]);
fftw_execute_dft_r2c(p,lab[2], spec_lab[2]);
fftw_destroy_plan(p);
p = fftw_plan_dft_c2r_2d(pSrc->GetHeight(), pSrc->GetWidth(),spec_gray, gray, FFTW_ESTIMATE);
//compute phi and theta coefficient
double thetasum=0;
double phisum=0;
for(int i=0;i<spec_size;++i){
double a2 = spec_lab[1][i][0]*spec_lab[1][i][0]+spec_lab[1][i][1]*spec_lab[1][i][1];
double b2 = spec_lab[2][i][0]*spec_lab[2][i][0]+spec_lab[2][i][1]*spec_lab[2][i][1];
phi[i] = a2/(a2+b2);
phisum += phi[i];
double rr2 = spec_rgb[0][i][0]*spec_rgb[0][i][0]+spec_rgb[0][i][1]*spec_rgb[0][i][1];
double gg2 = spec_rgb[1][i][0]*spec_rgb[1][i][0]+spec_rgb[1][i][1]*spec_rgb[1][i][1];
double bb2 = spec_rgb[2][i][0]*spec_rgb[2][i][0]+spec_rgb[2][i][1]*spec_rgb[2][i][1];
double l2 = spec_lab[0][i][0]*spec_lab[0][i][0]+spec_lab[0][i][1]*spec_lab[0][i][1];
double rgb2 = rr2+gg2+bb2;
theta[i] = (rgb2-l2)/rgb2;
thetasum += theta[i];
}
thetasum=0.6*spec_size;
phisum=0.9*spec_size;
for(int i=0;i<spec_size;++i){
spec_gray[i][0] = ((1-thetasum/spec_size)*spec_lab[0][i][0]+thetasum/spec_size*(phisum/spec_size*spec_lab[1][i][0]+(1-phisum/spec_size)*spec_lab[2][i][0]))/size;
//spec_gray[i][0] = ((1-theta[i])*spec_lab[0][i][0]+theta[i]*(phi[i]*spec_lab[1][i][0]+(1-phi[i])*spec_lab[2][i][0]))/size;
spec_gray[i][1] = ((1-thetasum/spec_size)*spec_lab[0][i][1]+thetasum/spec_size*(phisum/spec_size*spec_lab[1][i][1]+(1-phisum/spec_size)*spec_lab[2][i][1]))/size;
//spec_gray[i][1] = ((1-theta[i])*spec_lab[0][i][1]+theta[i]*(phi[i]*spec_lab[1][i][1]+(1-phi[i])*spec_lab[2][i][1]))/size;
}
fftw_execute(p);
double minimum = 99999999999999999;
double maximum = -99999999999999999;
data=pDst->GetData();
for(int i=0;i<size;++i){
if(gray[i]>maximum) maximum=gray[i];
if(gray[i]<minimum) minimum=gray[i];
*data++ = gray[i]*100;
*data++ = 0;//gray[i];
*data++ = 0;//gray[i];
}
fprintf(stderr,"%f %f %d %d\n",minimum,maximum,size,spec_size);
data=pDst->GetData();
for(int i=0;i<size;++i){
*data = 100*(gray[i]-minimum)/(maximum-minimum);
data += 3;
}
fftw_destroy_plan(p);
fftw_free(gray); fftw_free(spec_gray);
fftw_free(phi); fftw_free(theta);
fftw_free(rgb[0]);fftw_free(rgb[1]);fftw_free(rgb[2]);
fftw_free(lab[0]);fftw_free(lab[1]);fftw_free(lab[2]);
fftw_free(spec_rgb[0]);fftw_free(spec_rgb[1]);fftw_free(spec_rgb[2]);
fftw_free(spec_lab[0]);fftw_free(spec_lab[1]);fftw_free(spec_lab[2]);
pDst->Convert(TMO_RGB);
return 0;
}
// Set up sync vector for search correlator
// Use current estimates of sample rate
void generate_sync(double symrate){
int ind,k;
unsigned char data[10];
unsigned char symbols[2*8*10];
// The last 5 bytes (40 bits) of each 1024-bit minor frame are constants given below
// Run them through the encoder and use the last 34 symbols as the sync vector
// Those are the only invariant symbols from the encoder, after the user data has been flushed
memset(data,0,sizeof(data));
data[0] = 0x12;
data[1] = 0xfc;
data[2] = 0x81;
data[3] = 0x9f;
data[4] = 0xbe;
encode(symbols,data,10,0);
#if 1
for(k=0;k<80;k++)
printf(" %d",symbols[k]);
printf("\n");
#endif
// Update numbers based on current sample rate
Symrate = symrate;
Synclen = SYNCBITS * Symbolsamples + 1; // Fudge to prevent off-by-one overrun
printf("Symbol rate: %'.3lf Hz; samples/sym: %'.3lf; samples/frame: %'.1lf; samples in sync: %'d\n",
symrate,Samprate/symrate,2*FRAMEBITS*Symbolsamples,Synclen);
if(Syncvector != NULL)
free(Syncvector);
if((Syncvector = malloc(sizeof(*Syncvector) * (int)Synclen)) == NULL){
fprintf(stderr,"Can't malloc sync vector\n");
exit(3);
}
// Manchester encode last 34 symbols in sequence
ind = 0;
for(k=0;k<SYNCBITS;k++){
// First half of manchester symbol
for(;ind < (k+0.5) * Symbolsamples;ind++)
Syncvector[ind] = symbols[k+80-SYNCBITS] ? -1 : 1;
// Second half
for(;ind < (k+1) * Symbolsamples;ind++)
Syncvector[ind] = symbols[k+80-SYNCBITS] ? 1 : -1;
}
assert(ind <= Synclen);
#if 0
for(k=0;k<Synclen;k++){
putchar(Syncvector[k] == 1 ? '+':'-');
}
putchar('\n');
printf("sync vector done\n");
#endif
// Set up FFT correlator
Corr_size = 2*Framesamples;
Corr_size = 1 << 20; // hack!! change to round Corr_size up to next power of 2
Corr_input = fftw_alloc_real(Corr_size);
assert(Corr_input != NULL);
Corr_vector = fftw_alloc_real(Corr_size);
assert(Corr_vector != NULL);
Corr_result = fftw_alloc_real(Corr_size);
assert(Corr_result != NULL);
Corr_vector_transform = fftw_alloc_complex(Corr_size);
assert(Corr_vector_transform != NULL);
Corr_data_transform = fftw_alloc_complex(Corr_size);
assert(Corr_data_transform != NULL);
fftw_import_system_wisdom();
Corr_ffr = fftw_plan_dft_c2r_1d(Corr_size,Corr_data_transform,Corr_result,FFTW_ESTIMATE);
assert(Corr_ffr != NULL);
Corr_ff2 = fftw_plan_dft_r2c_1d(Corr_size,Corr_input,Corr_data_transform,FFTW_ESTIMATE);
assert(Corr_ff2 != NULL);
Corr_ff1 = fftw_plan_dft_r2c_1d(Corr_size,Corr_vector,Corr_vector_transform,FFTW_ESTIMATE);
// Load up the sync vector
for(k=0;k<Synclen;k++)
Corr_vector[k] = Syncvector[k];
// Zero pad
for(;k<Corr_size;k++)
Corr_vector[k] = 0;
fftw_execute(Corr_ff1); // Compute transform of sync vector
// Take complex conjugate so we don't have to do it every time
for(k=0;k<Corr_size;k++)
Corr_vector_transform[k] = conj(Corr_vector_transform[k]);
}
void simulateGrid(Grid * grid, int numTimeSteps, double finalTime, int mutliFlag) {
int globalGridDimX = grid->globalGridDimX ;
int globalGridDimY = grid->globalGridDimY ;
int localDimX = grid->localGridDimX ;
int localDimY = grid->localGridDimY ;
int globalOffset = grid->globalOffset ;
double * gridPointsTrTime0 = fftw_alloc_real(grid->allocScheme) ;
double * gridPointsTrTimeT = fftw_alloc_real(grid->allocScheme) ;
ptrdiff_t y,x,kx,ky ;
fftw_plan planFor ;
fftw_plan planBack ;
planFor = fftw_mpi_plan_r2r_2d(globalGridDimY, globalGridDimX, grid->gridPoints, gridPointsTrTime0, MPI_COMM_WORLD, FFTW_REDFT10, FFTW_REDFT10, FFTW_ESTIMATE) ;
planBack = fftw_mpi_plan_r2r_2d(globalGridDimY, globalGridDimX, gridPointsTrTimeT, grid->gridPoints, MPI_COMM_WORLD, FFTW_REDFT01 , FFTW_REDFT01, FFTW_ESTIMATE) ;
// Transform phi_0
fftw_execute(planFor) ;
// If multiflag passed then every timestep is printed. //
if (mutliFlag) {
char filename[10] ;
sprintf(filename, "out%d.txt", rank) ;
FILE * out = fopen(filename, "w") ;
for (int i = 0 ; i < numTimeSteps ; ++i) {
double timeT = (i/(double)numTimeSteps)*finalTime ;
// Advance transformed F(phi_0) to F(phi_t_i)
for (kx = 0 ; kx < localDimX ; ++kx) {
for (ky = 0 ; ky < localDimY ; ++ky) {
ptrdiff_t globalky = ky+globalOffset ;
gridPointsTrTimeT[ky*localDimX+kx] = gridPointsTrTime0[ky*localDimX+kx]*exp(-PI*PI*timeT*(kx*kx + globalky*globalky)) ;
}
}
// Transform back from F(phi_t) to phi_t
fftw_execute(planBack) ;
// Multiply by normalisation constant 1/(2N) * (1/(2N)). //
for (x = 0 ; x < localDimX ; ++x) {
for (y = 0 ; y < localDimY ; ++y) {
grid->gridPoints[y*localDimX+x] /= (double)(4*globalGridDimX*globalGridDimY) ;
}
}
printSplotData(grid,out) ;
fprintf(out,"\n\n") ;
}
fclose(out) ;
}
// Else only evolve until final timestep. //
else {
char filename[10] ;
sprintf(filename, "out%d.txt", rank) ;
FILE * out = fopen(filename, "w") ;
// Advance transformed F(phi_0) to F(phi_t_final)
for (kx = 0 ; kx < localDimX ; ++kx) {
for (ky = 0 ; ky < localDimY ; ++ky) {
ptrdiff_t globalky = ky+globalOffset ;
gridPointsTrTimeT[ky*localDimX+kx] = gridPointsTrTime0[ky*localDimX+kx]*exp(-PI*PI*finalTime*(kx*kx + globalky*globalky)) ;
}
}
// Transform back from F(phi_t) to phi_t
fftw_execute(planBack) ;
// Multiply by normalisation constant 1/(2N) * (1/(2N)). //
for (x = 0 ; x < localDimX ; ++x) {
for (y = 0 ; y < localDimY ; ++y) {
grid->gridPoints[y*localDimX+x] /= (double)(4*globalGridDimX*globalGridDimY) ;
}
}
printSplotData(grid,out) ;
fclose(out) ;
}
// Clean up resources. //
fftw_destroy_plan(planFor);
fftw_destroy_plan(planBack);
fftw_free(gridPointsTrTime0) ;
fftw_free(gridPointsTrTimeT) ;
} /* ----- end of function simulateGrid ----- */
plggdn_float *_plggdn_float_alloc_fftw(int N) {
return fftw_alloc_real(N);
}
