OpenCLStatus opencl_initPlatform()
{
OpenCLStatus status = opencl_failure;
numPlatforms = getPlatformNum();
platformIds = malloc(numPlatforms * sizeof(*platformIds));
numDevices = malloc(numPlatforms * sizeof(*numDevices));
deviceIds = malloc(numPlatforms * sizeof(*deviceIds));
/* fprintf(stdout, "%i OpenCL Platforms are available\n", getPlatformNum()); */
ERROR_HANDLER(clGetPlatformIDs(numPlatforms, platformIds, NULL));
for (unsigned int platform = 0; platform < numPlatforms; ++platform)
{
numDevices[platform] = getDeviceNum(platformIds[platform],
CL_DEVICE_TYPE_ALL);
deviceIds[platform]
= malloc(numDevices[platform] * sizeof(**deviceIds));
ERROR_HANDLER(clGetDeviceIDs(platformIds[platform], CL_DEVICE_TYPE_ALL,
numDevices[platform], deviceIds[platform], NULL));
/*
printPlatformInformation(platformIds[platform], stdout, "");
for (unsigned int device = 0; device < numDevices[platform]; ++device)
{
printDeviceInformation(deviceIds[platform][device]);
}
*/
}
status = opencl_success;
FINISH: return status;
}
void init_gfft() {
int n_size2D_ZXY[] = {NX,NY};
#ifdef _OPENMP
fftw_plan_with_nthreads( nthreads );
#endif
r2cfft_mpi_t = fftw_mpi_plan_dft_r2c_3d( NY, NX, NZ, wr1, w1, MPI_COMM_WORLD, FFT_PLANNING | FFTW_MPI_TRANSPOSED_OUT);
if (r2cfft_mpi_t == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW R2C_T plan creation failed");
r2cfft_mpi = fftw_mpi_plan_dft_r2c_3d( NX, NY, NZ, wr1, w1, MPI_COMM_WORLD, FFT_PLANNING);
if (r2cfft_mpi == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW R2C plan creation failed");
c2rfft_mpi_t = fftw_mpi_plan_dft_c2r_3d( NY, NX, NZ, w1, wr1, MPI_COMM_WORLD, FFT_PLANNING | FFTW_MPI_TRANSPOSED_IN);
if (c2rfft_mpi_t == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW C2R_T plan creation failed");
c2rfft_mpi = fftw_mpi_plan_dft_c2r_3d( NX, NY, NZ, w1, wr1, MPI_COMM_WORLD, FFT_PLANNING);
if (c2rfft_mpi == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW C2R plan creation failed");
r2cfft_2Dslice = fftw_plan_dft_r2c_2d(NX,NY,wrh3,wh3,FFT_PLANNING);
if (r2cfft_2Dslice == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW r2c slice plan creation failed");
// init transpose routines (These are used by remap routines)
init_transpose();
fft_timer=0.0;
return;
}
void
socket_close (int fd)
{
if (shutdown (fd, SHUT_RDWR) < 0)
ERROR_HANDLER ("Shutdown");
if (close (fd) < 0)
ERROR_HANDLER ("Close");
}
void init_output_vtk() {
double complex *w2d;
const int n_size1D[1] = {NY};
#ifdef WITH_SHEAR
w2d = (double complex *) fftw_malloc( sizeof(double complex) * (NY/2+1) * NZ );
if (w2d == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w2d allocation");
// FFT plans (we use dummy arrays since we use the "guru" interface of fft3 in the code)
// The in place/ out of place will be set automatically at this stage
// The Following Fourier transforms takes an array of size ( NX+1, NY+1, NZ+1) but consider only the "included" array
// of size ( NX+1, NY, NZ+1) and transforms it in y, in an array of size (NX+1, NY/2+1, NZ+1). The j=NY plane is therefore
// not modified by these calls
#ifdef _OPENMP
fftw_plan_with_nthreads( 1 );
#endif
#ifdef WITH_2D
fft_1d_forward = fftw_plan_many_dft_r2c(1, n_size1D, 1,
wr1, NULL, 1, 1,
w2d, NULL, 1, 1,
FFT_PLANNING || FFTW_UNALIGNED);
#else
fft_1d_forward = fftw_plan_many_dft_r2c(1, n_size1D, NZ,
wr1, NULL, NZ+2, 1,
w2d, NULL, NZ, 1,
FFT_PLANNING || FFTW_UNALIGNED);
#endif
if (fft_1d_forward == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW 1D forward plan creation failed");
#ifdef WITH_2D
fft_1d_backward = fftw_plan_many_dft_c2r(1, n_size1D, 1,
w2d, NULL, 1, 1,
wr1, NULL, 1, 1,
FFT_PLANNING || FFTW_UNALIGNED);
#else
fft_1d_backward = fftw_plan_many_dft_c2r(1, n_size1D, NZ,
w2d, NULL, NZ, 1,
wr1, NULL, NZ+2, 1,
FFT_PLANNING || FFTW_UNALIGNED);
#endif
if (fft_1d_backward == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW 1D backward plan creation failed");
fftw_free(w2d);
#endif
}
/*
* Function used by sons of the main process in order to deal with clients :
* receiving data, sending back data... and, finally, closing all opened sockets
* and exiting properly.
*/
static void
handle_client (int sock)
{
/* The message sent by the client might be longer than BUFFSIZE */
char *message;
/* Number of chars written in message */
int ptr = 0;
char buffer[BUFFSIZE];
int n_received;
/* BUFFSIZE + 1, so the terminating null byte ('\0') can be stored */
if ((message = calloc (BUFFSIZE + 1, sizeof (char))) == NULL)
ERROR_HANDLER ("Allocating memory for message");
while ((n_received = recv (sock, buffer, BUFFSIZE, 0)) != 0)
{
if (n_received < 0)
ERROR_HANDLER ("recv");
/*
* Seems necessary, unless we can guarantee that we will only receive
* well-formed strings...
*/
buffer[n_received] = '\0';
/* Sending back the data */
if (send (sock, buffer, n_received, 0) != n_received)
ERROR_HANDLER ("send");
strcpy (message+ptr, buffer);
message = realloc (message, ptr+2*BUFFSIZE+1);
ptr+=BUFFSIZE;
message[ptr] = '\0';
/*
* Upon receiving end of transmission, treating data
*/
if (strstr (buffer, "\n") != NULL)
{
fprintf (stdout, "Server has just received : %s\n", message);
if ((message = realloc (message, BUFFSIZE+1)) == NULL)
ERROR_HANDLER ("Allocating memory for message");
ptr = 0;
}
}
free (message);
socket_close (sock);
exit (EXIT_SUCCESS);
}
void BlackScholes::prep_memory()
{
/* Initialization */
t_mem.start();
srand(time(NULL));
/* Allocate host memory */
call = new float[optNum];
put = new float[optNum];
stockPrice = new float[optNum];
optionStrike = new float[optNum];
optionYears = new float[optNum];
ERROR_HANDLER((optionYears != NULL || optionStrike != NULL
|| stockPrice != NULL || put != NULL
|| call != NULL),
"Error in allocation memory for parameters");
/* Initialize variables */
for (int i = 0; i < optNum; i++) {
call[i] = 0.0f;
put[i] = 0.0f;
stockPrice[i] = rand_float(10.0f, 100.0f);
optionStrike[i] = rand_float(1.0f, 100.0f);
optionYears[i] = rand_float(0.25f, 5.0f);
}
t_mem.stop();
}
int main(int argc, char **argv){
ERROR_HANDLER(flag(), "Invalid argument '" + std::string(cad) + "'");
std::cout << "error right" << std::endl;
return 0;
}
void remap_output( double wri[],
const double t) {
int i,j,k;
double tvelocity;
double tremap;
complex double wexp;
complex double phase;
double complex *w2d;
DEBUG_START_FUNC;
w2d = (double complex *) fftw_malloc( sizeof(double complex) * (NY/2+1) * NZ );
if (w2d == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w2d allocation");
#ifdef TIME_DEPENDANT_SHEAR
tremap = time_shift(t);
tvelocity = 0.0;
#else
tremap = time_shift(t);
tvelocity = fmod(t, 2.0 * param.ly / (param.shear * param.lx));
#endif
for( i = 0 ; i < NX/NPROC ; i++) {
#ifdef WITH_2D
fftw_execute_dft_r2c(fft_1d_forward, wri + i*(NY+2), w2d);
#else
fftw_execute_dft_r2c(fft_1d_forward, wri + i*(NZ+2)*NY, w2d);
#endif
for( j = 0 ; j < NY/2+1 ; j++) {
phase = (double complex) ((2.0 * M_PI) / param.ly * ((double) j ) *
( ((double) (i + rank * (NX/NPROC)) / (double) NX ) * tremap - tvelocity / 2.0 ) * param.lx * param.shear);
//printf("phase=%g + I %g\n",creal(phase), cimag(phase));
wexp = cexp( I * phase)/NY;
//printf("wexp=%g + I %g\n",creal(wexp), cimag(wexp));
for( k = 0 ; k < NZ; k++) {
w2d[ k + j * NZ ] = wexp * w2d[ k + j * NZ ];
}
}
#ifdef WITH_2D
fftw_execute_dft_c2r(fft_1d_backward, w2d, wri + i*(NY+2));
#else
fftw_execute_dft_c2r(fft_1d_backward, w2d, wri + i*(NZ+2)*NY);
#endif
}
fftw_free(w2d);
DEBUG_END_FUNC;
return;
}
void write_field(FILE *handler, double complex *fldwrite) {
#ifdef MPI_SUPPORT
MPI_Status status;
// Write in rank order using the file opened if handler
int current_rank;
#endif
int i;
DEBUG_START_FUNC;
#ifdef MPI_SUPPORT
if(rank==0) {
for(current_rank=0; current_rank < NPROC; current_rank++) {
if(current_rank==0) {
// Copy the dump in the rank=0 process
#endif
for(i=0; i< NTOTAL_COMPLEX; i++) {
w1[i]=fldwrite[i];
}
#ifdef MPI_SUPPORT
}
else {
MPI_Recv( w1, NTOTAL_COMPLEX * 2, MPI_DOUBLE, current_rank, 2, MPI_COMM_WORLD, &status);
}
#endif
fwrite(w1, sizeof(double complex), NTOTAL_COMPLEX, handler);
if(ferror(handler)) ERROR_HANDLER( ERROR_CRITICAL, "Error writing dump file");
#ifdef MPI_SUPPORT
}
MPI_Barrier(MPI_COMM_WORLD);
}
else {
MPI_Send(fldwrite, NTOTAL_COMPLEX * 2, MPI_DOUBLE, 0, 2, MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
}
#endif
DEBUG_END_FUNC;
return;
}
void init_gfft() {
double complex *wi1;
double *wir1;
DEBUG_START_FUNC;
wi1 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (wi1 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for wi1 allocation");
wir1 = (double *) wi1;
#ifdef _OPENMP
fftw_plan_with_nthreads( nthreads );
#endif
#ifdef WITH_2D
r2cfft = fftw_plan_dft_r2c_2d( NX, NY, wr1, w1, FFT_PLANNING);
if (r2cfft == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW R2C plan creation failed");
c2rfft = fftw_plan_dft_c2r_2d( NX, NY, w1, wr1, FFT_PLANNING);
if (c2rfft == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW C2R plan creation failed");
#else
r2cfft = fftw_plan_dft_r2c_3d( NX, NY, NZ, wr1, w1, FFT_PLANNING);
if (r2cfft == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW R2C plan creation failed");
c2rfft = fftw_plan_dft_c2r_3d( NX, NY, NZ, w1, wr1, FFT_PLANNING);
if (c2rfft == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW C2R plan creation failed");
r2cfft_2Dslice = fftw_plan_dft_r2c_2d(NX,NY,wrh3,wh3,FFT_PLANNING);
if (r2cfft_2Dslice == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW r2c slice plan creation failed");
#endif
fftw_free(wi1);
fft_timer=0.0;
DEBUG_END_FUNC;
return;
}
void allocate_field(struct Field *fldi) {
int current_field, i;
DEBUG_START_FUNC;
// We want to allocate a field structure
fldi->nfield = 3;
#ifdef BOUSSINESQ
fldi->nfield++;
#endif
#ifdef MHD
fldi->nfield=fldi->nfield+3;
#endif
// Now we want to initialize the pointers of the field structure
// farray will point to each of the array previously allocated
fldi->farray = (double complex **) fftw_malloc( sizeof(double complex *) * fldi->nfield);
if (fldi->farray == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for fldi->farray allocation");
// fname will point to the name of each field
fldi->fname = (char **) fftw_malloc(sizeof(char *) * fldi->nfield);
if (fldi->fname == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for fldi->fname allocation");
// Initialise the pointers
for(i=0 ; i < fldi->nfield ; i++) {
fldi->fname[i] = (char *) fftw_malloc(sizeof(char) * 10); // 10 character to describe each field
if (fldi->fname[i] == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for fldi->fname[i] allocation");
}
// Allocate the arrays and put the right value in each pointer
current_field = 0;
fldi->vx = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (fldi->vx == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for fldi->vx allocation");
fldi->farray[current_field] = fldi->vx;
sprintf(fldi->fname[current_field],"vx");
current_field++;
fldi->vy = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (fldi->vy == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for fldi->vy allocation");
fldi->farray[current_field] = fldi->vy;
sprintf(fldi->fname[current_field],"vy");
current_field++;
fldi->vz = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (fldi->vz == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for fldi->vz allocation");
fldi->farray[current_field] = fldi->vz;
sprintf(fldi->fname[current_field],"vz");
current_field++;
#ifdef BOUSSINESQ
fldi->th = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (fldi->th == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for fldi->th allocation");
fldi->farray[current_field] = fldi->th;
sprintf(fldi->fname[current_field],"th");
current_field++;
#endif
#ifdef MHD
fldi->bx = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (fldi->bx == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for fldi->bx allocation");
fldi->farray[current_field] = fldi->bx;
sprintf(fldi->fname[current_field],"bx");
current_field++;
fldi->by = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (fldi->by == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for fldi->by allocation");
fldi->farray[current_field] = fldi->by;
sprintf(fldi->fname[current_field],"by");
current_field++;
fldi->bz = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (fldi->bz == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for fldi->bz allocation");
fldi->farray[current_field] = fldi->bz;
sprintf(fldi->fname[current_field],"bz");
current_field++;
#endif
// Add a field here if you need one... (don't forget to ajust fldi.nfield accordingly)
// *
// Ok, all done...
DEBUG_END_FUNC;
return;
}
void init_common(void) {
/* This routine will initialize everything */
int i,j,k;
DEBUG_START_FUNC;
#ifdef MPI_SUPPORT
#ifdef FFTW3_MPI_SUPPORT
fftw_mpi_init();
#endif
#endif
#ifdef _OPENMP
if( !(fftw_init_threads()) ) ERROR_HANDLER( ERROR_CRITICAL, "Threads initialisation failed");
#endif
/* We start with the coordinate system */
kx = (double *) fftw_malloc( sizeof(double) * NTOTAL_COMPLEX );
if (kx == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for kx allocation");
ky = (double *) fftw_malloc( sizeof(double) * NTOTAL_COMPLEX );
if (ky == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for ky allocation");
kz = (double *) fftw_malloc( sizeof(double) * NTOTAL_COMPLEX );
if (kz == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for kz allocation");
kxt = (double *) fftw_malloc( sizeof(double) * NTOTAL_COMPLEX );
if (kxt == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for kxt allocation");
kyt = (double *) fftw_malloc( sizeof(double) * NTOTAL_COMPLEX );
if (kyt == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for kyt allocation");
kzt = (double *) fftw_malloc( sizeof(double) * NTOTAL_COMPLEX );
if (kzt == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for kzt allocation");
k2t = (double *) fftw_malloc( sizeof(double) * NTOTAL_COMPLEX );
if (k2t == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for k2t allocation");
ik2t = (double *) fftw_malloc( sizeof(double) * NTOTAL_COMPLEX );
if (ik2t == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for ik2t allocation");
for( i = 0; i < NX_COMPLEX / NPROC; i++) {
for( j = 0; j < NY_COMPLEX; j++) {
for( k = 0; k < NZ_COMPLEX; k++) {
kx[ IDX3D ] = (2.0 * M_PI) / param.lx *
(fmod( NX_COMPLEX * rank / NPROC + i + (NX_COMPLEX / 2) , NX_COMPLEX ) - NX_COMPLEX / 2 );
#ifdef WITH_2D
ky[ IDX3D ] = (2.0 * M_PI) / param.ly * j;
kz[ IDX3D ] = 0.0;
#else
ky[ IDX3D ] = (2.0 * M_PI) / param.ly *
(fmod( j + (NY_COMPLEX / 2) , NY_COMPLEX ) - NY_COMPLEX / 2 );
kz[ IDX3D ] = (2.0 * M_PI) / param.lz * k;
#endif
kxt[ IDX3D ]= kx[IDX3D];
kyt[ IDX3D ]= ky[IDX3D];
kzt[ IDX3D ]= kz[IDX3D];
k2t[ IDX3D ] = kxt[IDX3D] * kxt[IDX3D] +
kyt[IDX3D] * kyt[IDX3D] +
kzt[IDX3D] * kzt[IDX3D];
if ( k2t[IDX3D] == 0.0 ) ik2t[IDX3D] = 1.0;
else ik2t[IDX3D] = 1.0 / k2t[IDX3D];
}
}
}
kxmax = 2.0 * M_PI/ param.lx * ( (NX / 2) - 1);
kymax = 2.0 * M_PI/ param.ly * ( (NY / 2) - 1);
kzmax = 2.0 * M_PI/ param.lz * ( (NZ / 2) - 1);
#ifdef WITH_2D
kzmax = 0.0;
#endif
kmax=pow(kxmax*kxmax+kymax*kymax+kzmax*kzmax,0.5);
/* Initialize the dealiazing mask Or the nyquist frequency mask (in case dealiasing is not required) */
mask = (double *) fftw_malloc( sizeof(double) * NTOTAL_COMPLEX );
if (mask == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for mask allocation");
for( i = 0; i < NX_COMPLEX/NPROC; i++) {
for( j = 0; j < NY_COMPLEX; j++) {
for( k = 0; k < NZ_COMPLEX; k++) {
mask[ IDX3D ] = 1.0;
if(param.antialiasing) {
if( fabs( kx[ IDX3D ] ) > 2.0/3.0 * kxmax)
mask[ IDX3D ] = 0.0;
if( fabs( ky[ IDX3D ] ) > 2.0/3.0 * kymax)
mask[ IDX3D ] = 0.0;
#ifndef WITH_2D
if( fabs( kz[ IDX3D ] ) > 2.0/3.0 * kzmax)
mask[ IDX3D ] = 0.0;
#endif
}
else {
if ( NX_COMPLEX / NPROC * rank + i == NX_COMPLEX / 2 )
mask[ IDX3D ] = 0.0;
if ( j == NY_COMPLEX / 2 )
mask[ IDX3D ] = 0.0;
#ifndef WITH_2D
if ( k == NZ_COMPLEX )
mask[ IDX3D ] = 0.0;
#endif
}
}
}
}
if(param.antialiasing) {
kxmax = kxmax * 2.0 / 3.0;
kymax = kymax * 2.0 / 3.0;
kzmax = kzmax * 2.0 / 3.0;
kmax = kmax * 2.0 / 3.0;
}
// Allocate fields
// Complex fields
w1 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w1 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w1 allocation");
w2 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w2 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w2 allocation");
w3 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w3 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w3 allocation");
w4 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w4 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w4 allocation");
w5 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w5 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w5 allocation");
w6 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w6 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w6 allocation");
w7 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w7 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w7 allocation");
w8 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w8 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w8 allocation");
w9 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w9 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w9 allocation");
w10 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w10 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w10 allocation");
w11 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w11 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w11 allocation");
w12 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w12 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w12 allocation");
w13 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w13 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w13 allocation");
w14 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w14 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w14 allocation");
w15 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w15 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w15 allocation");
w16 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w16 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w15 allocation");
w17 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w17 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w15 allocation");
w18 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (w18 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for w15 allocation");
wh1 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (wh1 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for wh1 allocation");
wh2 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (wh2 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for wh2 allocation");
wh3 = (double complex *) fftw_malloc( sizeof(double complex) * NX*(NY/2+1));
if (wh3 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for wh3 allocation");
wh4 = (double complex *) fftw_malloc( sizeof(double complex) * NX*(NY/2+1)*NZ);
if (wh4 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for wh4 allocation");
wh5 = (double complex *) fftw_malloc( sizeof(double complex) * NX*(NY/2+1)*NZ);
if (wh5 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for wh5 allocation");
// Initialize wh1,wh2,wh3;
for(i=0;i<NX*(NY/2+1);i++) {wh1[i]=0; wh2[i]=0; wh3[i]=0;}
/* Will use the same memory space for real and complex fields */
wr1 = (double *) w1;
wr2 = (double *) w2;
wr3 = (double *) w3;
wr4 = (double *) w4;
wr5 = (double *) w5;
wr6 = (double *) w6;
wr7 = (double *) w7;
wr8 = (double *) w8;
wr9 = (double *) w9;
wr10 = (double *) w10;
wr11 = (double *) w11;
wr12 = (double *) w12;
wr13 = (double *) w13;
wr14 = (double *) w14;
wr15 = (double *) w15;
wr16 = (double *) w16;
wr17 = (double *) w17;
wr18 = (double *) w18;
wrh1 = (double *) wh1;
wrh2 = (double *) wh2;
wrh3 = (double *) wh3;
wrh4 = (double *) wh4;
wrh5 = (double *) wh5;
// Physic initialisation
// init_real_mask();
//set Reynolds numbers using input powers AJB 08/03/12
param.reynolds = pow(10.0,param.reynolds);
nu = 1.0 / param.reynolds;
#ifdef BOUSSINESQ
param.reynolds_th = pow(10.0,param.reynolds_th);
nu_th = 1.0 / param.reynolds_th;
#endif
#ifdef MHD
param.reynolds_m = pow(10.0,param.reynolds_m);
eta = 1.0 / param.reynolds_m;
#endif
DEBUG_END_FUNC;
return;
}
void init_SpatialStructure(struct Field fldi) {
double *x,*y,*z;
int i,j,k;
/*******************************************************************
** This part does not need to be modified **************************
********************************************************************/
// Allocate coordinate arrays
x = (double *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (x == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for x allocation");
y = (double *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (y == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for y allocation");
z = (double *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (z == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for z allocation");
// Initialize the arrays
for(i = 0 ; i < NX/NPROC ; i++) {
for(j = 0 ; j < NY ; j++) {
for(k = 0 ; k < NZ ; k++) {
x[k + (NZ + 2) * j + (NZ + 2) * NY * i] = - param.lx / 2 + (param.lx * (i + rank * NX / NPROC)) / NX;
y[k + (NZ + 2) * j + (NZ + 2) * NY * i] = - param.ly / 2 + (param.ly * j ) / NY;
z[k + (NZ + 2) * j + (NZ + 2) * NY * i] = - param.lz / 2 + (param.lz * k ) / NZ;
}
}
}
// Initialize the extra points (k=NZ and k=NZ+1) to zero to prevent stupid things from happening...
for(i = 0 ; i < NX/NPROC ; i++) {
for(j = 0 ; j < NY ; j++) {
for(k = NZ ; k < NZ + 2 ; k++) {
x[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
y[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
z[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
}
}
}
// Init work array to zero
for(i = 0 ; i < NX/NPROC ; i++) {
for(j = 0 ; j < NY ; j++) {
for(k = 0 ; k < NZ + 2 ; k++) {
wr1[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
wr2[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
wr3[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
wr4[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
wr5[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
wr6[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
}
}
}
/*******************************************************************
** This part can be modified **************************
********************************************************************/
// The velocity field vx,vy,vz is stored in wr1,wr2,wr3
// The magnetic field bx,by,bz is stored in wr4,wr5,wr6 (ignored if MHD is not set)
for(i = 0 ; i < 2*NTOTAL_COMPLEX ; i++) {
// Example: init a flux tube in the x direction+a vertical displacement
// wr4[i] = exp(-(y[i]*y[i]+z[i]*z[i])*20.0);
// wr3[i] = 0.5*cos(x[i] * 2.0 * M_PI);
// Example: twisted flux tube + vertical displacement
wr4[i] = exp(-(y[i]*y[i]+z[i]*z[i])/(0.2*0.2));
wr5[i] = fabs(z[i])*1.0*wr4[i];
wr6[i] = -fabs(y[i])*1.0*wr4[i];
wr3[i] = 0.5*cos(x[i] * 2.0 * M_PI);
if (i==3*NY*(NZ+2)) fprintf(stderr," %d %e",i,x[i]);
}
/*******************************************************************
** This part does not need to be modified **************************
********************************************************************/
// Fourier transform everything
gfft_r2c(wr1);
gfft_r2c(wr2);
gfft_r2c(wr3);
gfft_r2c(wr4);
gfft_r2c(wr5);
gfft_r2c(wr6);
// Transfer data in the relevant array (including dealiasing mask)
for(i = 0 ; i < NTOTAL_COMPLEX ; i++) {
fldi.vx[i] += w1[i] * mask[i];
fldi.vy[i] += w2[i] * mask[i];
fldi.vz[i] += w3[i] * mask[i];
#ifdef MHD
fldi.bx[i] += w4[i] * mask[i];
fldi.by[i] += w5[i] * mask[i];
fldi.bz[i] += w6[i] * mask[i];
#endif
}
// free memory
fftw_free(x);
fftw_free(y);
fftw_free(z);
//done
return;
}
void write_vtk(FILE * ht, double complex wi[], const double t) {
// Write the data in the file handler *ht
int i,j,k;
float q0;
DEBUG_START_FUNC;
#ifdef MPI_SUPPORT
double * chunk = NULL;
if(rank==0) {
chunk = (double *) malloc( NX * sizeof(double));
if (chunk == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for chunk allocation");
}
#endif
for( i = 0 ; i < NTOTAL_COMPLEX ; i++) {
w1[i] = wi[i];
}
gfft_c2r(w1);
for( i = 0 ; i < 2 * NTOTAL_COMPLEX ; i++) {
wr1[i] = wr1[i] / ((double) NTOTAL );
}
#ifdef WITH_SHEAR
remap_output(wr1,t);
#endif
#ifdef BOUNDARY_C
for( k = 0 ; k < NZ / 2 ; k++) {
#else
for( k = 0 ; k < NZ; k++) {
#endif
for( j = 0; j < NY; j++) {
#ifdef MPI_SUPPORT
// We have to transpose manually to be Fortran compliant
for(i = 0; i < NX/NPROC; i++) {
wr2[i] = wr1[k + j * (NZ + 2) + i * NY * (NZ + 2) ]; // Transfer the chunk of data to wr2
}
MPI_Gather(wr2, NX/NPROC, MPI_DOUBLE,
chunk, NX/NPROC, MPI_DOUBLE, 0, MPI_COMM_WORLD); // Put the full chunk in chunk in the root process
#endif
for( i = 0; i < NX; i++) {
#ifdef MPI_SUPPORT
if(rank==0) {
q0 = big_endian( (float) chunk[ i ] );
fwrite(&q0, sizeof(float), 1, ht);
}
#else
#ifdef WITH_2D
q0 = big_endian( (float) wr1[j + i * (NY + 2)] );
#else
q0 = big_endian( (float) wr1[k + j * (NZ + 2) + i * NY * (NZ + 2) ] );
#endif
fwrite(&q0, sizeof(float), 1, ht);
if(ferror(ht)) ERROR_HANDLER( ERROR_CRITICAL, "Error writing VTK file");
#endif
}
#ifdef MPI_SUPPORT
MPI_Barrier(MPI_COMM_WORLD);
#endif
}
}
#ifdef MPI_SUPPORT
if(rank==0) free(chunk);
#endif
DEBUG_END_FUNC;
return;
}
// Geo's personnal VTK writer, using structured data points
/***********************************************************/
/**
Output a legacy VTK file readable by Paraview. This routine
will output all the variables in files data/v****.vtk.
@param n Number of the file in which the output will done.
@param t Current time of the simulation.
*/
/***********************************************************/
void output_vtk(struct Field fldi, const int n, double t) {
FILE *ht = NULL;
char filename[50];
int num_remain_field;
int array_size, i;
DEBUG_START_FUNC;
sprintf(filename,"data/v%04i.vtk",n);
#ifdef BOUNDARY_C
array_size=NX*NY*NZ/2; // Remove half of the vertical direction for symmetry reason when using walls in z
#else
array_size=NX*NY*NZ;
#endif
if(rank==0) {
ht=fopen(filename,"w");
fprintf(ht, "# vtk DataFile Version 2.0\n");
fprintf(ht, "t= %015.15e Snoopy Code v5.0\n",t);
fprintf(ht, "BINARY\n");
fprintf(ht, "DATASET STRUCTURED_POINTS\n");
#ifdef BOUNDARY_C
fprintf(ht, "DIMENSIONS %d %d %d\n", NX, NY, NZ / 2);
#else
fprintf(ht, "DIMENSIONS %d %d %d\n", NX, NY, NZ);
#endif
fprintf(ht, "ORIGIN %g %g %g\n", -param.lx/2.0, -param.ly/2.0, -param.lz/2.0);
fprintf(ht, "SPACING %g %g %g\n", param.lx/NX, param.ly/NY, param.lz/NZ);
// Write the primary scalar (f***ing VTK legacy format...)
fprintf(ht, "POINT_DATA %d\n",array_size);
fprintf(ht, "SCALARS %s float\n",fldi.fname[0]);
fprintf(ht, "LOOKUP_TABLE default\n");
}
write_vtk(ht,fldi.farray[0],t);
num_remain_field = fldi.nfield - 1; // we have already written the first one
if(param.output_vorticity)
num_remain_field +=3;
#ifndef MPI_SUPPORT
#ifdef WITH_PARTICLES
num_remain_field++;
#endif
#endif
if(rank==0) fprintf(ht, "FIELD FieldData %d\n",num_remain_field);
// Write all the remaining fields
for(i = 1 ; i < fldi.nfield ; i++) {
if(rank==0) fprintf(ht, "%s 1 %d float\n",fldi.fname[i],array_size);
write_vtk(ht,fldi.farray[i],t);
}
if(param.output_vorticity) {
// Compute the vorticity field
for( i = 0 ; i < NTOTAL_COMPLEX ; i++) {
w4[i] = I * (ky[i] * fldi.vz[i] - kz[i] * fldi.vy[i]);
w5[i] = I * (kz[i] * fldi.vx[i] - kxt[i] * fldi.vz[i]);
w6[i] = I * (kxt[i] * fldi.vy[i] - ky[i] * fldi.vx[i]);
}
if(rank==0) fprintf(ht, "wx 1 %d float\n",array_size);
write_vtk(ht,w4,t);
if(rank==0) fprintf(ht, "wy 1 %d float\n",array_size);
write_vtk(ht,w5,t);
if(rank==0) fprintf(ht, "wz 1 %d float\n",array_size);
write_vtk(ht,w6,t);
}
#ifndef MPI_SUPPORT
#ifdef WITH_PARTICLES
if(rank==0) fprintf(ht, "particules 1 %d float\n",array_size);
write_vtk_particles(fldi, ht, t);
#endif
#endif
if(rank==0) {
if(ferror(ht)) ERROR_HANDLER( ERROR_CRITICAL, "Error writing VTK file");
fclose(ht);
}
DEBUG_END_FUNC;
return;
}
/******************************************
** init the real mask to introduce some
** object in the flow
******************************************/
void init_real_mask() {
double *x,*y,*z;
int i,j,k;
mask_real = (double *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (mask_real == NULL) ERROR_HANDLER( ERROR_CRITICAL, "no memory for mask_real profile allocation");
/*******************************************************************
** This part does not need to be modified **************************
********************************************************************/
// Allocate coordinate arrays
x = (double *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (x == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for x allocation");
y = (double *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (y == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for y allocation");
z = (double *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (z == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for z allocation");
// Initialize the (transposed!) arrays
for(i = 0 ; i < NX ; i++) {
for(j = 0 ; j < NY/NPROC ; j++) {
for(k = 0 ; k < NZ ; k++) {
x[k + (NZ + 2) * i + (NZ + 2) * NX * j] = - param.lx / 2 + (param.lx * i ) / NX;
y[k + (NZ + 2) * i + (NZ + 2) * NX * j] = - param.ly / 2 + (param.ly * (j + rank * NY / NPROC)) / NY;
z[k + (NZ + 2) * i + (NZ + 2) * NX * j] = - param.lz / 2 + (param.lz * k ) / NZ;
}
}
}
// Initialize the extra points (k=NZ and k=NZ+1) to zero to prevent stupid things from happening...
for(i = 0 ; i < NX ; i++) {
for(j = 0 ; j < NY/NPROC ; j++) {
for(k = NZ ; k < NZ + 2 ; k++) {
x[k + (NZ + 2) * i + (NZ + 2) * NX * j] = 0.0;
y[k + (NZ + 2) * i + (NZ + 2) * NX * j] = 0.0;
z[k + (NZ + 2) * i + (NZ + 2) * NX * j] = 0.0;
}
}
}
// Init array to zero
for(i = 0 ; i < NX ; i++) {
for(j = 0 ; j < NY/NPROC ; j++) {
for(k = 0 ; k < NZ + 2 ; k++) {
mask_real[ k + (NZ + 2) * i + (NZ + 2) * NX * j ] = 1.0;
}
}
}
// Insert a radius=1 object in the system
for(i = 0 ; i < 2*NTOTAL_COMPLEX ; i++) {
if((x[i]*x[i]+y[i]*y[i])<1.0) {
mask_real[i] = 0.0;
}
}
free(x);
free(y);
free(z);
}
void u_iii_forcing(struct Field fldi, double dt) {
double *x, *y, *z;
int i,j,k;
x = (double *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (x == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for x allocation");
y = (double *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (y == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for y allocation");
z = (double *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (z == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for z allocation");
// Initialize the arrays
for(i = 0 ; i < NX/NPROC ; i++) {
for(j = 0 ; j < NY ; j++) {
for(k = 0 ; k < NZ ; k++) {
x[k + (NZ + 2) * j + (NZ + 2) * NY * i] = - param.lx / 2 + (param.lx * (i + rank * NX / NPROC)) / NX;
y[k + (NZ + 2) * j + (NZ + 2) * NY * i] = - param.ly / 2 + (param.ly * j ) / NY;
z[k + (NZ + 2) * j + (NZ + 2) * NY * i] = - param.lz / 2 + (param.lz * k ) / NZ;
}
}
}
// Initialize the extra points (k=NZ and k=NZ+1) to zero to prevent stupid things from happening...
for(i = 0 ; i < NX/NPROC ; i++) {
for(j = 0 ; j < NY ; j++) {
for(k = NZ ; k < NZ + 2 ; k++) {
x[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
y[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
z[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
}
}
}
// Init work array to zero
for(i = 0 ; i < NX/NPROC ; i++) {
for(j = 0 ; j < NY ; j++) {
for(k = 0 ; k < NZ + 2 ; k++) {
wr4[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
wr5[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
wr6[k + (NZ + 2) * j + (NZ + 2) * NY * i] = 0.0;
}
}
}
/*******************************************************************
** This part can be modified **************************
********************************************************************/
// The velocity field vx,vy,vz is stored in wr1,wr2,wr3
for(i = 0 ; i < 2*NTOTAL_COMPLEX ; i++) {
wr4[i] = param.modified_ABC_flow_D*(
cos(x[i]/param.modified_ABC_flow_m)*(
param.modified_ABC_flow_A*param.modified_ABC_flow_kz*sin(z[i] /(double) param.modified_ABC_flow_kz ) +
param.modified_ABC_flow_C*param.modified_ABC_flow_ky*cos(y[i] /(double) param.modified_ABC_flow_ky)
) +
sin(x[i]/param.modified_ABC_flow_m)/param.modified_ABC_flow_m*(
0
)
);
wr5[i] = param.modified_ABC_flow_D*(
cos(x[i]/param.modified_ABC_flow_m)*(
param.modified_ABC_flow_B*param.modified_ABC_flow_kx*sin(x[i] /(double) param.modified_ABC_flow_kx ) +
param.modified_ABC_flow_A*param.modified_ABC_flow_kz*cos(z[i] /(double) param.modified_ABC_flow_kz)
) +
sin(x[i]/param.modified_ABC_flow_m)/param.modified_ABC_flow_m*(
param.modified_ABC_flow_B*cos(x[i] /(double) param.modified_ABC_flow_kx) +
param.modified_ABC_flow_C*sin(y[i] /(double) param.modified_ABC_flow_ky)
)
);
wr6[i] = param.modified_ABC_flow_D*(
cos(x[i]/param.modified_ABC_flow_m)*(
param.modified_ABC_flow_C*param.modified_ABC_flow_ky*sin(y[i] /(double) param.modified_ABC_flow_ky ) +
param.modified_ABC_flow_B*param.modified_ABC_flow_kx*cos(x[i] /(double) param.modified_ABC_flow_kx)
) +
sin(x[i]/param.modified_ABC_flow_m)/param.modified_ABC_flow_m*(
-param.modified_ABC_flow_A*cos(z[i] /(double) param.modified_ABC_flow_kz) +
-param.modified_ABC_flow_B*sin(x[i] /(double) param.modified_ABC_flow_kx)
)
);
}
gfft_r2c(wr4);
gfft_r2c(wr5);
gfft_r2c(wr6);
for(i = 0 ; i < NTOTAL_COMPLEX ; i++) {
w4[i] = w4[i] * mask[i];
w5[i] = w5[i] * mask[i];
w6[i] = w6[i] * mask[i];
}
for( i = 0; i < NX_COMPLEX/NPROC; i++) {
for( j = 0; j < NY_COMPLEX; j++) {
for( k = 0; k < NZ_COMPLEX; k++) {
fldi.vx[ IDX3D ] += w4[ IDX3D ] * (1 - exp(-nu*k2t[IDX3D]*dt)) ;
fldi.vy[ IDX3D ] += w5[ IDX3D ] * (1 - exp(-nu*k2t[IDX3D]*dt)) ;
fldi.vz[ IDX3D ] += w6[ IDX3D ] * (1 - exp(-nu*k2t[IDX3D]*dt)) ;
}
}
}
#ifdef U_III_FORCING_EXTRA
gfft_c2r_t(w4);
gfft_c2r_t(w5);
gfft_c2r_t(w6);
#ifdef _OPENMP
#pragma omp parallel for private(i) schedule(static)
#endif
for( i = 0 ; i < 2*NTOTAL_COMPLEX ; i++) {
wr10[i] = wr4[i] * wr4[i] / ((double) NTOTAL*NTOTAL);
wr11[i] = wr5[i] * wr5[i] / ((double) NTOTAL*NTOTAL);
#ifndef WITH_2D
wr12[i] = wr6[i] * wr6[i] / ((double) NTOTAL*NTOTAL);
#endif
wr7[i] = wr4[i] * wr5[i] / ((double) NTOTAL*NTOTAL);
wr8[i] = wr4[i] * wr6[i] / ((double) NTOTAL*NTOTAL);
wr9[i] = wr5[i] * wr6[i] / ((double) NTOTAL*NTOTAL);
}
gfft_r2c_t(wr10);
gfft_r2c_t(wr11);
#ifndef WITH_2D
gfft_r2c_t(wr12);
#endif
gfft_r2c_t(wr7);
gfft_r2c_t(wr8);
gfft_r2c_t(wr9);
#ifdef _OPENMP
#pragma omp parallel for private(i) schedule(static)
#endif
for( i = 0 ; i < NTOTAL_COMPLEX ; i++) {
fldi.vx[i] += I * mask[i] / (nu * k2t) * (1 - exp(-nu*k2t[IDX3D]*dt)) * (
kxt[i] * w10[i] + ky[i] * w7[i] + kz[i] * w8[i] );
fldi.vy[i] += I * mask[i] / (nu * k2t) * (1 - exp(-nu*k2t[IDX3D]*dt)) * (
kxt[i] * w7[i] + ky[i] * w11[i] + kz[i] * w9[i] );
fldi.vz[i] += I * mask[i] / (nu * k2t) * (1 - exp(-nu*k2t[IDX3D]*dt)) * (
kxt[i] * w8[i] + ky[i] * w9[i] + kz[i] * w12[i] ); // since kz=0 in 2D, kz*w6 gives 0, even if w6 is some random array
}
#endif
projector(fldi.vx,fldi.vy,fldi.vz);
return;
}
virtual cl_context createContext( icontext::device_type type ) const
{
cl_context result;
ERROR_HANDLER( result = ::clCreateContextFromType( 0, type, NULL, NULL, &ERROR ) );
return result;
}
int
main (void)
{
int client_socket;
struct sockaddr_in server_echo, client_echo;
int yes = 1;
if ((server_socket = socket (AF_INET, SOCK_STREAM, 0)) < 0)
ERROR_HANDLER ("socket");
/* In case the server is killed using ^C */
signal (SIGINT, kill_server);
server_echo.sin_family = AF_INET;
server_echo.sin_addr.s_addr = INADDR_ANY;
server_echo.sin_port = htons (PORT);
/*
* FIXME : is that the truly beautiful way to avoid getting "Address already
* used" errors from bind ? Even Cedric Augonnet does not know... We iz
* doomed.
*/
if (setsockopt (server_socket,
SOL_SOCKET,
SO_REUSEADDR,
&yes,
sizeof (int)) < 0)
ERROR_HANDLER ("setsockopt");
if (bind (server_socket,
(struct sockaddr *) &server_echo,
sizeof (server_echo)) < 0)
ERROR_HANDLER ("bind");
if (listen (server_socket, MAX_CONN) < 0)
ERROR_HANDLER ("listen");
for (;;)
{
unsigned int len = sizeof (client_echo);
/* Is that really useful to fill in the client_echo variable ?*/
if ((client_socket = accept (server_socket,
(struct sockaddr *) &client_echo,
&len)) < 0)
ERROR_HANDLER ("accept");
fprintf (stderr, "Connection accepted\n");
switch (fork ())
{
case -1:
ERROR_HANDLER ("fork");
break;
case 0:
handle_client (client_socket);
break;
default:
break;
}
}
/* FIXME : is there anyway that we actually get here ? */
socket_close (server_socket);
return EXIT_SUCCESS;
}
void init_gfft() {
// This will init the plans needed by gfft
// Transform of NY/NPROC arrays of (logical) size [NX, NZ]
// The physical size is [NX, NZ+2]
// We use in-place transforms
int i;
double complex *wi1, *whi1;
double *wir1, *whir1;
const int n_size2D[2] = {NX, NZ};
const int n_size1D[1] = {NY_COMPLEX};
wi1 = (double complex *) fftw_malloc( sizeof(double complex) * NTOTAL_COMPLEX);
if (wi1 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for wi1 allocation");
whi1 = (double complex *) fftw_malloc( sizeof(double complex) * NX*(NY/2+1));
if (whi1 == NULL) ERROR_HANDLER( ERROR_CRITICAL, "No memory for wi1 allocation");
wir1 = (double *) wi1;
whir1= (double *) whi1;
for(i = 0 ; i < NTOTAL_COMPLEX; i++) {
wi1[i]=1.0;
}
#ifdef _OPENMP
fftw_plan_with_nthreads( nthreads );
#endif
r2c_2d = fftw_plan_many_dft_r2c(2, n_size2D, NY / NPROC, wir1, NULL, 1, (NZ+2)*NX,
wi1, NULL, 1, (NZ+2)*NX/2, FFT_PLANNING);
if (r2c_2d == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW R2C_2D plan creation failed");
c2r_2d = fftw_plan_many_dft_c2r(2, n_size2D, NY / NPROC, wi1, NULL, 1, (NZ+2)*NX/2,
wir1, NULL, 1, (NZ+2)*NX , FFT_PLANNING);
if (c2r_2d == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW C2R_2D plan creation failed");
r2cfft_2Dslice = fftw_plan_dft_r2c_2d(NX,NY,wrh3,wh3,FFT_PLANNING); //,whir1,whi1
if (r2cfft_2Dslice == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW r2c slice plan creation failed");
// 1D transforms: This are actually c2c transforms, but are used for global 3D transforms.
// We will transform forward and backward an array of logical size [NX/NPROC, NY, (NZ+2)/2] along the 2nd dimension
// We will do NZ_COMPLEX transforms along Y. Will need a loop on NX/NPROC
// We use &w1[NZ_COMPLEX] so that alignement check is done properly (see SIMD in fftw Documentation)
#ifdef _OPENMP
fftw_plan_with_nthreads( 1 );
#endif
r2c_1d = fftw_plan_many_dft(1, n_size1D, NZ_COMPLEX, &wi1[NZ_COMPLEX], NULL, NZ_COMPLEX, 1,
&wi1[NZ_COMPLEX], NULL, NZ_COMPLEX, 1, FFTW_FORWARD, FFT_PLANNING);
if (r2c_1d == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW R2C_1D plan creation failed");
c2r_1d = fftw_plan_many_dft(1, n_size1D, NZ_COMPLEX, &wi1[NZ_COMPLEX], NULL, NZ_COMPLEX, 1,
&wi1[NZ_COMPLEX], NULL, NZ_COMPLEX, 1, FFTW_BACKWARD, FFT_PLANNING);
if (c2r_1d == NULL) ERROR_HANDLER( ERROR_CRITICAL, "FFTW C2R_1D plan creation failed");
// init transpose routines
init_transpose();
// Let's see which method is faster (with our without threads)
fftw_free(wi1); fftw_free(whi1);
fft_timer=0.0;
return;
}
void read_dump( struct Field fldo,
double *t,
char dump_file[]) {
FILE *ht;
int dump_version,i;
int size_x, size_y, size_z, included_field;
int marker;
DEBUG_START_FUNC;
if( !file_exist(dump_file) ) {
// The file cannot be opened
MPI_Printf("File %s not found\n",dump_file);
ERROR_HANDLER(ERROR_CRITICAL, "Cannot open dump file.");
}
ht=fopen(dump_file,"r");
// The file has been opened by process 0
if(rank==0) {
fread(&dump_version, sizeof(int), 1, ht);
if( dump_version != OUTPUT_DUMP_VERSION) ERROR_HANDLER( ERROR_CRITICAL, "Incorrect dump file version.");
fread(&size_x , sizeof(int), 1, ht);
fread(&size_y , sizeof(int), 1, ht);
fread(&size_z , sizeof(int), 1, ht);
if(size_x != NX) ERROR_HANDLER( ERROR_CRITICAL, "Incorrect X grid size in dump file.");
if(size_y != NY) ERROR_HANDLER( ERROR_CRITICAL, "Incorrect Y grid size in dump file.");
if(size_z != NZ) ERROR_HANDLER( ERROR_CRITICAL, "Incorrect Y grid size in dump file.");
fread(&included_field, sizeof(int), 1, ht);
}
#ifdef MPI_SUPPORT
MPI_Bcast( &included_field, 1, MPI_INT, 0, MPI_COMM_WORLD);
#endif
MPI_Printf("Reading velocity field\n");
read_field(ht, fldo.vx);
read_field(ht, fldo.vy);
read_field(ht, fldo.vz);
#ifdef BOUSSINESQ
// Do we have Boussinesq Field in the dump?
if(included_field & 1) {
// Yes
MPI_Printf("Reading Boussinesq field\n");
read_field(ht, fldo.th);
}
else {
// No
ERROR_HANDLER( ERROR_WARNING, "No Boussinesq field in the dump, using initial conditions.");
}
#endif
#ifdef MHD
// Do we have MHD field in the dump?
if(included_field & 2) {
// Yes
MPI_Printf("Reading MHD field\n");
read_field(ht, fldo.bx);
read_field(ht, fldo.by);
read_field(ht, fldo.bz);
}
else {
//No
ERROR_HANDLER( ERROR_WARNING, "No MHD field in the dump, using initial conditions.");
}
#endif
if(param.restart) { // If the dump is used to restart, we need these extra variables
if(rank==0) {
fread(t , sizeof(double) , 1 , ht);
fread(&noutput_flow , sizeof(int) , 1 , ht);
fread(&lastoutput_time , sizeof(double) , 1 , ht);
fread(&lastoutput_flow , sizeof(double) , 1 , ht);
fread(&lastoutput_dump , sizeof(double) , 1 , ht);
if(param.numericalkevol){//AJB 09/03/12
for(i=0;i<9;i++){ fread(&kbasis[i],sizeof(double),1,ht); }
}
fread(&marker , sizeof(int) , 1, ht);
if(marker != DUMP_MARKER) ERROR_HANDLER( ERROR_CRITICAL, "Incorrect marker. Probably an incorrect dump file!");
}
// Transmit the values to all processes
#ifdef MPI_SUPPORT
MPI_Bcast( t, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast( &noutput_flow, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast( &lastoutput_time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast( &lastoutput_flow, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast( &lastoutput_dump, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
if(param.numericalkevol){//AJB 09/03/12
MPI_Bcast( kbasis, 9 , MPI_DOUBLE, 0, MPI_COMM_WORLD);
}
#endif
MPI_Printf("Restarting at t=%e...\n",*t);
}
if(rank==0) {
if(ferror(ht)) ERROR_HANDLER( ERROR_CRITICAL, "Error reading dump file");
fclose(ht);
}
DEBUG_END_FUNC;
return;
}
void output_dump( const struct Field fldi,
const double t) {
FILE *ht;
int dump_version,i;
int size_x, size_y, size_z;
int marker, included_field;
int nfield;
long int filesize;
ht=NULL;
DEBUG_START_FUNC;
size_x = NX;
size_y = NY;
size_z = NZ;
// This is a check when we try to read a dump file
dump_version = OUTPUT_DUMP_VERSION;
// This is a hard coded marker to check that we have correctly read the file
marker = DUMP_MARKER;
if(rank==0) {
ht=fopen(OUTPUT_DUMP_WRITE,"w");
if(ht==NULL) ERROR_HANDLER( ERROR_CRITICAL, "Error opening dump file.");
fwrite(&dump_version, sizeof(int), 1, ht);
fwrite(&size_x , sizeof(int), 1, ht);
fwrite(&size_y , sizeof(int), 1, ht);
fwrite(&size_z , sizeof(int), 1, ht);
// Included fields
// First bit is Boussinesq fields
// Second bit is MHD fields
// Other fields can be added from that stage...
included_field=0;
#ifdef BOUSSINESQ
included_field+=1;
#endif
#ifdef MHD
included_field+=2;
#endif
fwrite(&included_field, sizeof(int), 1, ht);
}
write_field(ht, fldi.vx);
write_field(ht, fldi.vy);
write_field(ht, fldi.vz);
#ifdef BOUSSINESQ
write_field(ht, fldi.th);
#endif
#ifdef MHD
write_field(ht, fldi.bx);
write_field(ht, fldi.by);
write_field(ht, fldi.bz);
#endif
if(rank==0) {
fwrite(&t , sizeof(double) , 1 , ht);
fwrite(&noutput_flow , sizeof(int) , 1 , ht);
fwrite(&lastoutput_time , sizeof(double) , 1 , ht);
fwrite(&lastoutput_flow , sizeof(double) , 1 , ht);
fwrite(&lastoutput_dump , sizeof(double) , 1 , ht);
// Any extra information should be put here.
if(param.numericalkevol){//AJB 09/03/12
for(i=0;i<9;i++){ fwrite(&kbasis[i],sizeof(double),1,ht); }
}
fwrite(&marker , sizeof(int) , 1 , ht);
// Check everything was fine with the file
if(ferror(ht)) ERROR_HANDLER( ERROR_CRITICAL, "Error writing dump file");
fclose(ht);
}
// predict the file size:
nfield = 3; // Velocity fields
#ifdef BOUSSINESQ
nfield += 1;
#endif
#ifdef MHD
nfield += 3;
#endif
filesize = nfield * sizeof(double complex) * NTOTAL_COMPLEX * NPROC + 4 * sizeof( double) + 7 * sizeof( int );
if(param.numericalkevol) {//AJB 09/03/12
filesize = nfield * sizeof(double complex) * NTOTAL_COMPLEX * NPROC + 13 * sizeof( double) + 7 * sizeof( int );
}
if( check_file_size( OUTPUT_DUMP_WRITE, filesize ) ) {
MPI_Printf("Error checking the dump size, got %d instead of %d\n", (int) check_file_size( OUTPUT_DUMP_WRITE, filesize), (int) filesize);
ERROR_HANDLER( ERROR_CRITICAL, "Error writing dump file, check your quotas");
}
// This bit prevents the code from losing all the dump files (this kind of thing happens sometimes...)
// With this routine, one will always have a valid restart dump, either in OUTPUT_DUMP_WRITE, OUTPUT_DUMP or OUTPUT_DUMP_SAV
// (it should normally be in OUTPUT_DUMP)
if(rank==0) {
remove(OUTPUT_DUMP_SAV); // Delete the previously saved output dump
rename(OUTPUT_DUMP, OUTPUT_DUMP_SAV); // Save the current dump file
rename(OUTPUT_DUMP_WRITE, OUTPUT_DUMP); // Move the new dump file to its final location
}
if( check_file_size( OUTPUT_DUMP, filesize ) ) {
MPI_Printf("Error checking the dump size, got %d instead of %d\n", (int) check_file_size( OUTPUT_DUMP, filesize), (int) filesize);
ERROR_HANDLER( ERROR_CRITICAL, "Error writing dump file, check your quotas");
}
#ifdef MPI_SUPPORT
MPI_Barrier(MPI_COMM_WORLD);
#endif
DEBUG_END_FUNC;
return;
}
