2022-05-18 07:57:06 +00:00
|
|
|
#define VERSION "0.1"
|
2018-01-11 22:48:14 +00:00
|
|
|
|
|
|
|
#include <math.h>
|
|
|
|
#include <complex.h>
|
|
|
|
#include <fftw3.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
2022-05-18 07:57:06 +00:00
|
|
|
#include <stdbool.h>
|
2018-01-11 22:48:14 +00:00
|
|
|
#include "navier-stokes.h"
|
2022-05-18 07:57:06 +00:00
|
|
|
#include "driving.h"
|
2018-01-11 22:48:14 +00:00
|
|
|
|
|
|
|
// usage message
|
|
|
|
int print_usage();
|
2022-05-18 07:57:06 +00:00
|
|
|
|
2018-01-11 22:48:14 +00:00
|
|
|
// read command line arguments
|
2022-05-18 21:52:01 +00:00
|
|
|
int read_args(int argc, const char* argv[], char** params, unsigned int* driving_force, unsigned int* command, unsigned int* nthreads);
|
2022-05-25 15:12:02 +00:00
|
|
|
int read_params(char* params, int* K1, int* K2, int* N1, int* N2, unsigned int* nsteps, double* nu, double* delta, double* L, unsigned int* print_freq);
|
|
|
|
int set_parameter(char* lhs, char* rhs, int* K1, int* K2, int* N1, int* N2, unsigned int* nsteps, double* nu, double* delta, double* L, unsigned int* print_freq, bool* setN1, bool* setN2);
|
2022-05-18 07:57:06 +00:00
|
|
|
|
|
|
|
|
|
|
|
#define COMMAND_UK 1
|
|
|
|
#define COMMAND_ENSTROPHY 2
|
2022-05-18 20:22:42 +00:00
|
|
|
#define COMMAND_QUIET 3
|
2022-05-19 16:35:33 +00:00
|
|
|
#define COMMAND_ENERGY 4
|
2018-01-11 22:48:14 +00:00
|
|
|
|
2022-05-19 15:51:45 +00:00
|
|
|
#define DRIVING_ZERO 1
|
|
|
|
#define DRIVING_TEST 2
|
2018-01-11 22:48:14 +00:00
|
|
|
|
|
|
|
|
2022-05-18 07:57:06 +00:00
|
|
|
int main (
|
|
|
|
int argc,
|
|
|
|
const char* argv[]
|
|
|
|
){
|
|
|
|
char* params=NULL;
|
|
|
|
int K1,K2;
|
|
|
|
int N1,N2;
|
2018-01-11 22:48:14 +00:00
|
|
|
unsigned int nsteps;
|
2022-05-25 15:12:02 +00:00
|
|
|
double nu,delta,L;
|
2022-05-18 07:57:06 +00:00
|
|
|
_Complex double (*g)(int,int);
|
2018-01-11 22:48:14 +00:00
|
|
|
int ret;
|
2022-05-18 07:57:06 +00:00
|
|
|
unsigned int driving,command;
|
|
|
|
unsigned int print_freq;
|
2022-05-18 21:52:01 +00:00
|
|
|
unsigned int nthreads=1;
|
2018-01-11 22:48:14 +00:00
|
|
|
|
2022-05-18 07:57:06 +00:00
|
|
|
command=0;
|
|
|
|
driving=0;
|
2018-01-11 22:48:14 +00:00
|
|
|
|
|
|
|
// read command line arguments
|
2022-05-18 21:52:01 +00:00
|
|
|
ret=read_args(argc, argv, ¶ms, &driving, &command, &nthreads);
|
2022-05-18 07:57:06 +00:00
|
|
|
if(ret<0){
|
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
// read params
|
2022-05-25 15:12:02 +00:00
|
|
|
ret=read_params(params, &K1, &K2, &N1, &N2, &nsteps, &nu, &delta, &L, &print_freq);
|
2018-01-11 22:48:14 +00:00
|
|
|
if(ret<0){
|
|
|
|
return(-1);
|
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
// set driving force
|
|
|
|
switch(driving){
|
2022-05-19 15:51:45 +00:00
|
|
|
case DRIVING_ZERO:
|
|
|
|
g=g_zero;
|
|
|
|
break;
|
2022-05-18 07:57:06 +00:00
|
|
|
case DRIVING_TEST:
|
|
|
|
g=g_test;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2022-05-19 15:51:45 +00:00
|
|
|
g=g_zero;
|
2022-05-18 07:57:06 +00:00
|
|
|
break;
|
2018-01-11 22:48:14 +00:00
|
|
|
}
|
|
|
|
|
2022-05-18 07:57:06 +00:00
|
|
|
// run command
|
|
|
|
if (command==COMMAND_UK){
|
2022-05-25 15:12:02 +00:00
|
|
|
uk(K1, K2, N1, N2, nsteps, nu, delta, L, g, print_freq, nthreads);
|
2022-05-18 07:57:06 +00:00
|
|
|
}
|
2022-05-19 16:35:33 +00:00
|
|
|
else if (command==COMMAND_ENERGY){
|
2022-05-25 15:12:02 +00:00
|
|
|
energy(K1, K2, N1, N2, nsteps, nu, delta, L, g, print_freq, nthreads);
|
2022-05-19 16:35:33 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else if(command==COMMAND_ENSTROPHY){
|
2022-05-26 02:32:03 +00:00
|
|
|
enstrophy(K1, K2, N1, N2, nsteps, nu, delta, L, g, print_freq, nthreads);
|
2022-05-18 07:57:06 +00:00
|
|
|
}
|
2022-05-18 20:22:42 +00:00
|
|
|
else if(command==COMMAND_QUIET){
|
2022-05-25 15:12:02 +00:00
|
|
|
quiet(K1, K2, N1, N2, nsteps, nu, delta, L, g, nthreads);
|
2022-05-18 20:22:42 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else if(command==0){
|
|
|
|
fprintf(stderr, "error: no command specified\n");
|
|
|
|
print_usage();
|
2018-01-11 22:48:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// usage message
|
|
|
|
int print_usage(){
|
2022-05-18 07:57:06 +00:00
|
|
|
fprintf(stderr, "usage:\n nstrophy [-p parameters] [-g driving_force] <command>\n\n");
|
2018-01-11 22:48:14 +00:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// read command line arguments
|
2022-05-18 07:57:06 +00:00
|
|
|
#define CP_FLAG_PARAMS 1
|
|
|
|
#define CP_FLAG_DRIVING 2
|
2022-05-18 21:52:01 +00:00
|
|
|
#define CP_FLAG_NTHREADS 3
|
2022-05-18 07:57:06 +00:00
|
|
|
int read_args(
|
|
|
|
int argc,
|
|
|
|
const char* argv[],
|
|
|
|
char** params,
|
|
|
|
unsigned int* driving_force,
|
2022-05-18 21:52:01 +00:00
|
|
|
unsigned int* command,
|
|
|
|
unsigned int* nthreads
|
2022-05-18 07:57:06 +00:00
|
|
|
){
|
2018-01-11 22:48:14 +00:00
|
|
|
int i;
|
2022-05-18 21:52:01 +00:00
|
|
|
int ret;
|
2018-01-11 22:48:14 +00:00
|
|
|
// pointers
|
|
|
|
char* ptr;
|
|
|
|
// flag that indicates what argument is being read
|
|
|
|
int flag=0;
|
|
|
|
|
|
|
|
// loop over arguments
|
|
|
|
for(i=1;i<argc;i++){
|
|
|
|
// flag
|
|
|
|
if(argv[i][0]=='-'){
|
|
|
|
for(ptr=((char*)argv[i])+1;*ptr!='\0';ptr++){
|
|
|
|
switch(*ptr){
|
2022-05-18 07:57:06 +00:00
|
|
|
case 'p':
|
|
|
|
flag=CP_FLAG_PARAMS;
|
2018-01-11 22:48:14 +00:00
|
|
|
break;
|
2022-05-18 07:57:06 +00:00
|
|
|
case 'g':
|
|
|
|
flag=CP_FLAG_DRIVING;
|
2018-01-11 22:48:14 +00:00
|
|
|
break;
|
2022-05-18 21:52:01 +00:00
|
|
|
case 't':
|
|
|
|
flag=CP_FLAG_NTHREADS;
|
|
|
|
break;
|
2018-01-11 22:48:14 +00:00
|
|
|
default:
|
|
|
|
fprintf(stderr, "unrecognized option '-%c'\n", *ptr);
|
|
|
|
print_usage();
|
|
|
|
return(-1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
// params
|
|
|
|
else if(flag==CP_FLAG_PARAMS){
|
|
|
|
*params=(char*)argv[i];
|
2018-01-11 22:48:14 +00:00
|
|
|
flag=0;
|
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
// driving force
|
|
|
|
else if(flag==CP_FLAG_DRIVING){
|
2022-05-19 15:51:45 +00:00
|
|
|
if (strcmp(argv[i],"zero")==0){
|
|
|
|
*driving_force=DRIVING_ZERO;
|
|
|
|
}
|
|
|
|
else if (strcmp(argv[i],"test")==0){
|
2022-05-18 07:57:06 +00:00
|
|
|
*driving_force=DRIVING_TEST;
|
2018-01-11 22:48:14 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else{
|
|
|
|
fprintf(stderr, "error: unrecognized driving force '%s'\n",argv[i]);
|
2018-01-11 22:48:14 +00:00
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
flag=0;
|
|
|
|
}
|
2022-05-18 21:52:01 +00:00
|
|
|
// nthreads
|
|
|
|
else if(flag==CP_FLAG_NTHREADS){
|
|
|
|
ret=sscanf(argv[i],"%u",nthreads);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: '-t' should be followed by an unsigned integer\n got '%s'\n",argv[i]);
|
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
flag=0;
|
|
|
|
}
|
2018-01-11 22:48:14 +00:00
|
|
|
// computation to run
|
|
|
|
else{
|
2022-05-18 07:57:06 +00:00
|
|
|
if(strcmp(argv[i], "uk")==0){
|
|
|
|
*command=COMMAND_UK;
|
|
|
|
}
|
|
|
|
else if(strcmp(argv[i], "enstrophy")==0){
|
|
|
|
*command=COMMAND_ENSTROPHY;
|
2018-01-11 22:48:14 +00:00
|
|
|
}
|
2022-05-18 20:22:42 +00:00
|
|
|
else if(strcmp(argv[i], "quiet")==0){
|
|
|
|
*command=COMMAND_QUIET;
|
|
|
|
}
|
2022-05-19 16:35:33 +00:00
|
|
|
else if(strcmp(argv[i], "energy")==0){
|
|
|
|
*command=COMMAND_ENERGY;
|
|
|
|
}
|
2018-01-11 22:48:14 +00:00
|
|
|
else{
|
2022-05-18 07:57:06 +00:00
|
|
|
fprintf(stderr, "error: unrecognized command: '%s'\n",argv[i]);
|
2018-01-11 22:48:14 +00:00
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
flag=0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2022-05-18 07:57:06 +00:00
|
|
|
// read parameters string
|
|
|
|
int read_params(
|
|
|
|
char* params,
|
|
|
|
int* K1,
|
|
|
|
int* K2,
|
|
|
|
int* N1,
|
|
|
|
int* N2,
|
|
|
|
unsigned int* nsteps,
|
|
|
|
double* nu,
|
|
|
|
double* delta,
|
2022-05-25 15:12:02 +00:00
|
|
|
double* L,
|
2022-05-18 07:57:06 +00:00
|
|
|
unsigned int* print_freq
|
|
|
|
){
|
|
|
|
int ret;
|
|
|
|
// pointer in params
|
|
|
|
char* ptr;
|
|
|
|
// buffer and associated pointer
|
|
|
|
char *buffer_lhs, *lhs_ptr;
|
|
|
|
char *buffer_rhs, *rhs_ptr;
|
|
|
|
// whether N was set explicitly
|
|
|
|
bool setN1=false;
|
|
|
|
bool setN2=false;
|
|
|
|
// whether lhs (false is rhs)
|
|
|
|
bool lhs=true;
|
|
|
|
|
|
|
|
// defaults
|
|
|
|
*K1=16;
|
|
|
|
*K2=*K1;
|
|
|
|
//delta=2^-13
|
|
|
|
*delta=0.0001220703125;
|
|
|
|
//nu=2^-11
|
|
|
|
*nu=0.00048828125;
|
2022-05-25 15:12:02 +00:00
|
|
|
*L=2*M_PI;
|
2022-05-18 07:57:06 +00:00
|
|
|
*nsteps=10000000;
|
|
|
|
*print_freq=1000;
|
|
|
|
|
|
|
|
if (params!=NULL){
|
|
|
|
// init
|
|
|
|
buffer_lhs=calloc(sizeof(char),strlen(params));
|
|
|
|
lhs_ptr=buffer_lhs;
|
|
|
|
*lhs_ptr='\0';
|
|
|
|
buffer_rhs=calloc(sizeof(char),strlen(params));
|
|
|
|
rhs_ptr=buffer_rhs;
|
|
|
|
*rhs_ptr='\0';
|
2018-01-11 22:48:14 +00:00
|
|
|
|
2022-05-18 07:57:06 +00:00
|
|
|
for(ptr=params;*ptr!='\0';ptr++){
|
|
|
|
switch(*ptr){
|
|
|
|
case '=':
|
|
|
|
// reset buffer
|
|
|
|
rhs_ptr=buffer_rhs;
|
|
|
|
*rhs_ptr='\0';
|
|
|
|
lhs=false;
|
|
|
|
break;
|
|
|
|
case ';':
|
|
|
|
//set parameter
|
2022-05-25 15:12:02 +00:00
|
|
|
ret=set_parameter(buffer_lhs,buffer_rhs,K1,K2,N1,N2,nsteps,nu,delta,L,print_freq,&setN1,&setN2);
|
2022-05-18 07:57:06 +00:00
|
|
|
if(ret<0){
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
// reset buffer
|
|
|
|
lhs_ptr=buffer_lhs;
|
|
|
|
*lhs_ptr='\0';
|
|
|
|
lhs=true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// add to buffer
|
|
|
|
if (lhs){
|
|
|
|
*lhs_ptr=*ptr;
|
|
|
|
lhs_ptr++;
|
|
|
|
*lhs_ptr='\0';
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
*rhs_ptr=*ptr;
|
|
|
|
rhs_ptr++;
|
|
|
|
*rhs_ptr='\0';
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2018-01-11 22:48:14 +00:00
|
|
|
|
2022-05-18 07:57:06 +00:00
|
|
|
// set last param
|
|
|
|
if (*params!='\0'){
|
2022-05-25 15:12:02 +00:00
|
|
|
ret=set_parameter(buffer_lhs,buffer_rhs,K1,K2,N1,N2,nsteps,nu,delta,L,print_freq,&setN1,&setN2);
|
2022-05-18 07:57:06 +00:00
|
|
|
if(ret<0){
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2018-01-11 22:48:14 +00:00
|
|
|
|
2022-05-18 07:57:06 +00:00
|
|
|
// free vects
|
|
|
|
free(buffer_lhs);
|
|
|
|
free(buffer_rhs);
|
|
|
|
}
|
2018-02-19 16:00:07 +00:00
|
|
|
|
2022-05-18 07:57:06 +00:00
|
|
|
// if N not set explicitly, set it
|
|
|
|
if (!setN1){
|
|
|
|
*N1=4*(*K1)+1;
|
2018-02-19 16:00:07 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
if (!setN2){
|
|
|
|
*N2=4*(*K2)+1;
|
2018-02-19 16:00:07 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// set a parameter from the parameter string
|
|
|
|
int set_parameter(
|
|
|
|
char* lhs,
|
|
|
|
char* rhs,
|
|
|
|
int* K1,
|
|
|
|
int* K2,
|
|
|
|
int* N1,
|
|
|
|
int* N2,
|
|
|
|
unsigned int* nsteps,
|
|
|
|
double* nu,
|
|
|
|
double* delta,
|
2022-05-25 15:12:02 +00:00
|
|
|
double* L,
|
2022-05-18 07:57:06 +00:00
|
|
|
unsigned int* print_freq,
|
|
|
|
bool* setN1,
|
|
|
|
bool* setN2
|
|
|
|
){
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (strcmp(lhs,"K1")==0){
|
|
|
|
ret=sscanf(rhs,"%d",K1);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'K1' should be an integer\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
|
|
|
}
|
2018-02-19 16:00:07 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else if (strcmp(lhs,"K2")==0){
|
|
|
|
ret=sscanf(rhs,"%d",K2);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'K2' should be an integer\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
2018-02-19 16:00:07 +00:00
|
|
|
}
|
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else if (strcmp(lhs,"K")==0){
|
|
|
|
ret=sscanf(rhs,"%d",K1);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'K' should be an integer\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
2018-02-19 16:00:07 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
*K2=*K1;
|
2018-02-19 16:00:07 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else if (strcmp(lhs,"N1")==0){
|
|
|
|
ret=sscanf(rhs,"%d",N1);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'N1' should be an integer\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
2018-02-19 16:00:07 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
*setN1=true;
|
2018-02-19 16:00:07 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else if (strcmp(lhs,"N2")==0){
|
|
|
|
ret=sscanf(rhs,"%d",N2);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'N2' should be an integer\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
2018-01-11 22:48:14 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
*setN2=true;
|
2018-01-11 22:48:14 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else if (strcmp(lhs,"N")==0){
|
|
|
|
ret=sscanf(rhs,"%d",N1);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'N' should be an integer\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
2022-05-17 12:31:22 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
*N2=*N1;
|
|
|
|
*setN1=true;
|
|
|
|
*setN2=true;
|
2022-05-17 12:31:22 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else if (strcmp(lhs,"nsteps")==0){
|
|
|
|
ret=sscanf(rhs,"%u",nsteps);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'nsteps' should be an unsigned integer\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
2018-01-11 22:48:14 +00:00
|
|
|
}
|
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else if (strcmp(lhs,"nu")==0){
|
|
|
|
ret=sscanf(rhs,"%lf",nu);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'nu' should be a double\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
2018-01-11 22:48:14 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
}
|
|
|
|
else if (strcmp(lhs,"delta")==0){
|
|
|
|
ret=sscanf(rhs,"%lf",delta);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'delta' should be a double\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
2018-01-11 22:48:14 +00:00
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
}
|
2022-05-25 15:12:02 +00:00
|
|
|
else if (strcmp(lhs,"L")==0){
|
|
|
|
ret=sscanf(rhs,"%lf",L);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'L' should be a double\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else if (strcmp(lhs,"print_freq")==0){
|
|
|
|
ret=sscanf(rhs,"%u",print_freq);
|
|
|
|
if(ret!=1){
|
|
|
|
fprintf(stderr, "error: parameter 'print_freq' should be an unsigned integer\n got '%s'\n",rhs);
|
|
|
|
return(-1);
|
2018-01-11 22:48:14 +00:00
|
|
|
}
|
|
|
|
}
|
2022-05-18 07:57:06 +00:00
|
|
|
else{
|
|
|
|
fprintf(stderr, "error: unrecognized parameter '%s'\n",lhs);
|
|
|
|
return(-1);
|
|
|
|
}
|
2018-01-11 22:48:14 +00:00
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|