int main (int argc, char **argv)
{
// setup pointers to drawstuff callback functions
dsFunctions fn;
fn.version = DS_VERSION;
fn.start = &start;
fn.step = &simLoop;
fn.command = 0;
fn.stop = 0;
fn.path_to_textures = DRAWSTUFF_TEXTURE_PATH;
alloc_arrays();
dInitODE2(0);
dRandSetSeed (time(0));
createTest();
// run simulation
#pragma kaapi parallel
dsSimulationLoop (argc,argv,352,288,&fn);
dWorldDestroy (world);
dCloseODE();
return 0;
}
/*
** show_cap_results(index)
**
** Display the previous results
*/
static void
show_cap_results(
int x)
{
struct test_results *r; /* a result */
int delay;
alloc_arrays();
if ((r = pads[x])) {
sprintf(temp, "(%s)", strnames[x]);
ptext(temp);
while (r) {
sprintf(temp, "$<%d>", r->delay / 1000);
put_columns(temp, (int) strlen(temp), 10);
r = r->next;
}
r = pads[x];
while (r) {
if (r->reps > 1) {
delay = r->delay / (r->reps * 100);
sprintf(temp, "$<%d.%d*>", delay / 10, delay % 10);
put_columns(temp, (int) strlen(temp), 10);
}
r = r->next;
}
put_crlf();
}
}
/****************************************************************************
* Free all dynamic memory that depended on the size, and reallocate it to the
* new size.
****************************************************************************/
static int resize(int h, int w)
{
printk("LCD:resize h=%d, w=%d\n", h,w);
free_arrays();
iHeight = h;
iWidth = w;
return alloc_arrays();
}
/*
** pad_test_shutdown()
**
** Do the stuff needed to end a test.
*/
void
pad_test_shutdown(
struct test_list *t,
int crlf)
{
int i;
int counts; /* total counts */
int ss; /* Save string index */
int cpo; /* characters per operation */
long delta; /* difference in characters */
int bogus; /* Time is inaccurate */
struct test_results *r; /* Results of current test */
int ss_index[TT_MAX]; /* String index */
alloc_arrays();
if (tty_can_sync == SYNC_TESTED) {
bogus = tty_sync_error();
} else {
bogus = 1;
}
usec_run_time = (unsigned long) event_time(TIME_TEST);
tx_source = t;
tx_characters = raw_characters_sent;
tx_cps = (unsigned long) sliding_scale(tx_characters, 1000000, usec_run_time);
/* save the data base */
for (txp = ss = counts = 0; txp < ttp; txp++) {
tx_cap[txp] = tt_cap[txp];
tx_count[txp] = tt_count[txp];
tx_delay[txp] = tt_delay[txp];
tx_affected[txp] = tt_affected[txp];
tx_index[txp] = get_string_cap_byvalue(tt_cap[txp]);
if (tx_index[txp] >= 0) {
if (cap_match(t->caps_done, strnames[tx_index[txp]])) {
ss_index[ss++] = txp;
counts += tx_count[txp];
}
}
}
if (crlf) {
put_crlf();
}
if (counts == 0 || tty_cps == 0 || bogus) {
/* nothing to do */
return;
}
/* calculate the suggested pad times */
delta = (long) (usec_run_time - (unsigned long) sliding_scale(tx_characters, 1000000, tty_cps));
if (delta < 0) {
/* probably should bump tx_characters */
delta = 0;
}
cpo = delta / counts;
for (i = 0; i < ss; i++) {
if (!(r = get_next_block())) {
return;
}
r->next = pads[tx_index[ss_index[i]]];
pads[tx_index[ss_index[i]]] = r;
r->test = t;
r->reps = tx_affected[ss_index[i]];
r->delay = cpo;
}
}
int reciva_lcd_init(const struct reciva_lcd_driver *d, int height, int width)
{
int i, iErr;
int charmap_length = 50; //XXX this is a guess but shouldn't be too bad
driver = d;
iHeight = height;
iWidth = width;
init_timer (&bl_timer);
bl_timer.function = bl_timer_func;
/* Initialise LCD */
driver->init_hardware();
/* Register the device */
misc_register (&lcd_miscdev);
iErr = alloc_arrays();
if (iErr < 0)
return iErr;
/* Set up charmap hashtable */
utf8_to_char = rutl_new_hashtable(charmap_length);
if (!utf8_to_char)
{
free_arrays();
return -ENOMEM;
}
i = 0;
while (d->charmap[i].pcUTF8Rep) {
rutl_hashtable_put(utf8_to_char, d->charmap[i].pcUTF8Rep,
d->charmap[i].cLocalRep);
++i;
}
vDrawGreetingFrame(1);
#ifdef LCD_PROFILING
if (profiling)
do_profiling();
#endif
printk("RLCD:%s module: loaded\n", driver->name);
if (driver->get_max_backlight)
bl_level_max=driver->get_max_backlight();
else
bl_level_max = BL_DEFAULT_MAX_BACKLIGHT;
/* If backlight level is not specified as module param then set to max */
if (lcd_backlight_level < 0 || lcd_backlight_level > bl_level_max)
lcd_backlight_level = bl_level_max;
if (driver->set_backlight)
reciva_lcd_set_backlight (lcd_backlight_level);
#ifdef LCD_DEBUG
if (driver->test_pattern)
{
driver->test_pattern();
}
#endif
/* handle changing text during module startup */
if (strcmp(line1frame1, line1frame2) || strcmp(line2frame1, line2frame2)
|| strcmp(line3frame1, line3frame2) || strcmp(line4frame1, line4frame2))
{
init_MUTEX(&start_thread_sem);
i = kernel_thread(iGreetingFrameThread, (void *)0, 0);
if (i >= 0)
{
tGreetingFramePid = i;
/* Wait for thread to finish init */
down(&start_thread_sem);
}
}
return 0;
}
int main(void)
{
double inmon, tmon;
double mon, nxt, lst;
double *iyr;
double *nyr;
double dyr, day;
double ndyr;
double *dy;
double dmon[12];
double dbmon;
double yearday;
int imon, inxt, ilst;
# ifndef WRTTS
int itts; /* tracer time step counter */
# endif
int nmnfirst;
#ifdef SEPFILES
double smon, snxt;
int ismon, isnxt, ihnxt;
#endif
#ifndef WRTTS
size_t nrec = 0;
#endif
int err, i, j, k;
int cmon;
int nmn;
double frac;
static int m;
#ifndef WRTTS
int varmap[NOVARS];
FILE *fn;
char output_filename[200];
#endif
char run_name[200];
char restart_filename[200];
struct vardesc var_out[NOVARS];
#ifndef WRTTS
struct varcdfinfo varinfo[NOVARS];
int nvar = 0, cdfid, timeid[2];
#endif
extern int flags[NOVARS];
extern int rflags[NOVARS];
//BX-a for testing only
int status;
char message[144];
//BX-e
//BX allocate tracer fields
err = alloc_arrays();
if (err)
printf("Error allocating arrays.\n");
err = alloc_trac();
if (err)
printf("Error allocating tracer field.\n");
iyr = malloc(sizeof(double));
nyr = malloc(sizeof(double));
dy = malloc(sizeof(double));
mlen[0] = 31; /* January */
mlen[1] = 28; /* February */
mlen[2] = 31; /* March */
mlen[3] = 30; /* April */
mlen[4] = 31; /* May */
mlen[5] = 30; /* June */
mlen[6] = 31; /* July */
mlen[7] = 31; /* August */
mlen[8] = 30; /* September */
mlen[9] = 31; /* October */
mlen[10] = 30; /* November */
mlen[11] = 31; /* December */
dmon[0] = 0.0;
for (i = 1; i <= 11; i++)
{
dmon[i] = dmon[i - 1] + mlen[i - 1];
}
/*----------------------------------*
*
* get user input
*
*----------------------------------*/
{
char line[100];
int scan_count, done = 1;
printf("Enter directory to use to read.\n");
fgets(directory, sizeof(directory), stdin);
directory[strlen(directory) - 1] = '\0';
k = strlen(directory);
if (k > 0)
if (directory[k - 1] != '/')
{
directory[k] = '/';
directory[k + 1] = '\0';
printf("Using directory %s first.\n", directory);
}
strcat(directory, fname);
strcpy(fname, directory);
printf("file path = %s\n", fname);
while (done)
{
printf(
"\nEnter the starting month and the total months to integrate.\n");
fgets(line, sizeof(line), stdin);
line[strlen(line) - 1] = '\0';
scan_count = sscanf(line, "%lg, %lg,", &inmon, &tmon);
if (scan_count == 2)
{
if (inmon < 0 || tmon < 0)
printf("Negative values not allowed\n");
else
done = 0;
}
else
printf("Incorrect number of values, %d, read.\n", scan_count);
}
printf("\ninitial month = %g \n", inmon);
printf("final month = %g \n", inmon + tmon - 1);
printf("total months = %g \n\n", tmon);
/*-----------------------------------
*
* set output print flags to 0
*
* added restart flags as a restart bug fix until
* memory restriction problem is solved 31OCT07 BX
*
*----------------------------------*/
for (i = 0; i <= NOVARS - 1; i++)
flags[i] = 0;
for (i = 0; i <= NOVARS - 1; i++)
rflags[i] = 0;
flags[1] = 0;
flags[2] = 0; /* u,v */
rflags[1] = 0;
rflags[2] = 0; /* u,v */
flags[0] = 0;
flags[3] = 0; /* D, h */
rflags[0] = 0;
rflags[3] = 0; /* D, h */
flags[4] = 0;
flags[5] = 0; /* uhtm, vhtm */
rflags[4] = 0;
rflags[5] = 0; /* uhtm, vhtm */
flags[6] = 0;
flags[7] = 0;
flags[8] = 0; /* ea, eb, eaml */
flags[18] = 0; /* ML potential density */
rflags[18] = 0; /* ML potential density */
#ifdef AGE
flags[9] = 1;
rflags[9] = 1; /* ideal age tracer*/
#endif
printf("Enter base name for output\n");
fgets(run_name, sizeof(run_name), stdin);
run_name[strlen(run_name) - 1] = '\0';
sprintf(output_filename, "%s.%04g.nc", run_name, inmon + tmon - 1);
printf("Create NetCDF output file '%s'.\n", output_filename);
} // end of block "get user input"
//DT
lastsave = -1;
//DT
/*-----------------------------------
*
* allocate and initialize fields
*
*----------------------------------*/
read_grid();
printf("Done reading grid or metric file.\n");
set_metrics();
printf("Done setting metrics.\n");
/* Copy the variable descriptions to a list of the actual output variables. */
for (i = 0; i < NOVARS; i++)
if (flags[i] > 0)
{
var_out[nvar] = vars[i];
varmap[i] = nvar;
nvar++;
}
// force float precision output with last argument
printf("Making NETCDF %s file\n", output_filename);
create_file(output_filename, NETCDF_FILE, var_out, nvar, &fn, &cdfid,
timeid, varinfo, 1);
// don't force
// create_file(output_filename, NETCDF_FILE, var_out, nvar, &fn, &cdfid, timeid, varinfo, 0);
printf("Closing file \n");
close_file(&cdfid, &fn);
/* Allocate the memory for the fields to be calculated. */
alloc_fields();
/* initialize tracer pointers */
for (m = 0; m < NOVARS; m++)
{
if (flags[m])
for (k = 0; k < varsize[m]; k++)
var[m][k] = 0.0;
}
/********** set means to zero */
/* 2d variables */
if (flags[8])
set_fix_darray2d_zero(mn_eaml);
/* 3d variables */
if (flags[1])
set_darray3d_zero(mn_u, NZ, NXMEM, NYMEM);
if (flags[2])
set_darray3d_zero(mn_v, NZ, NXMEM, NYMEM);
if (flags[3])
set_darray3d_zero(mn_h, NZ, NXMEM, NYMEM);
if (flags[4])
set_darray3d_zero(mn_uhtm, NZ, NXMEM, NYMEM);
if (flags[5])
set_darray3d_zero(mn_vhtm, NZ, NXMEM, NYMEM);
if (flags[6])
set_darray3d_zero(mn_ea, NZ, NXMEM, NYMEM);
if (flags[7])
set_darray3d_zero(mn_eb, NZ, NXMEM, NYMEM);
#ifdef AGE
if (flags[9])
set_darray3d_zero(mn_age, NZ, NXMEM, NYMEM);
#endif
printf("Reading bathymetry, D.\n");
// initialize D to be all ocean first
for (i = 0; i <= NXMEM - 1; i++)
{
for (j = 0; j <= NYMEM - 1; j++)
{
D[i][j] = MINIMUM_DEPTH;
}
}
#ifndef USE_CALC_H
printf("calling read_D\n");
read_D();
for (i = 0; i <= NXMEM - 1; i++)
for (j = 0; j <= NYMEM - 1; j++)
if (D[i][j] < 10.0)
D[i][j] = MINIMUM_DEPTH;
#endif
read_grid();
set_metrics();
dyr = inmon / 12;
smon = (double) ((int) inmon % NMONTHS);
mon = 12 * modf(dyr, iyr);
printf("\n initial mon = %g - %g - %g \n\n", inmon, smon, mon);
imon = (int) (mon + 0.00001);
/* Begin edit DT */
int iyear = floor((inmon + imon) / 12);
theyear = iyear;
#ifdef RESTART
theyear++;
iyear++;
#endif
/* End edit DT */
inxt = imon + 1;
ismon = (int) (smon + 0.00001) % NMONTHS;
isnxt = (ismon+1) % NMONTHS;
ihnxt = (ismon+2) % NMONTHS;
dbmon = (double) inmon;
lst = 12 * modf((dbmon - 1 + 12) / 12, iyr);
ilst = (int) (lst + 0.00001);
// ashao: Read in next month's isopycnal thickness fields
// (will be copied at the beginning of the integration)
// Done this way so that if hindcasts are used the physical fields switch smoothly
// to/from climatological fields
//BX files are not in regular order (uvw are midmonth and h starts with last month)
currtime = BEGYEAR;
if (usehindcast) {
// Check to see if simulation started within the hindcast years
if ( (currtime >= BEGHIND) || (currtime < (ENDHIND+1) ) ) {
hindindex=inmon;
read_h(ismon,hend,"hind");
}
}
else {
read_h(ismon, hend,"clim");
}
// for files in regular order (h before uvw) use code here
//BX
// read_uvw(imon,1);
//BX
// read_h(imon,inxt);
#ifdef USE_CALC_H
z_sum(h, D);
#endif
printf("\nSetting up and initializing\n");
#ifdef RESTART
initialize(inmon,run_name);
#else
initialize(imon);
#endif
nmn = 0;
//HF the next line should be in init.h (and be optional!)
#undef OUTPUT_IC
#ifdef OUTPUT_IC
/*-----------------------------------
*
* write tracer initial conditions
*
*----------------------------------*/
printf("Writing initial condition variables out to netCDF\n\n",cmon);
// open netcdf file for each writing
status = nc_open(output_filename, NC_WRITE, &cdfid);
if (status != NC_NOERR)
{
strcpy(message,"Opening file"); strcat(message,output_filename);
handle_error(message,status);
}
err = write_time(cdfid,fn,timeid[0],nrec, dy);
if (err == -1) printf("Error writing day.\n");
if (flags[3])
{
for (k=0;k<NZ;k++)
for (i=0;i<NXMEM;i++)
for (j=0;j<NYMEM;j++)
mn_h[k][i][j] += h[k][i][j];
}
#ifdef AGE
if (flags[9]) add_darray3d(mn_age, age, NZ, NXMEM, NYMEM);
/*{
for (k=0;k<NZ;k++)
for (i=0;i<NXMEM;i++)
for (j=0;j<NYMEM;j++)
mn_age[k][i][j] += age[k][i][j];
}*/
#endif /* AGE */
for (m=0;m<NOVARS;m++) if (flags[m])
{
err = write_field(cdfid, fn, vars[m], varinfo[varmap[m]],
nrec,var[m]);
if (err == -1) printf("Error writing %s.\n",vars[m].name);
}
// close file after each writing
close_file(&cdfid, &fn);
printf("netcdf record = %d\n",nrec++);
#endif /* OUTPUT_IC */
/*-------------------------------------------------------------------*
*
* begin integration loop
*
*-------------------------------------------------------------------*/
mon = 0.0; /* reiniti */
nmnfirst = 1;
for (cmon = inmon; cmon < inmon + tmon; cmon++)
{
nmn++;
dyr = cmon / 12.0;
ndyr = (cmon + 1) / 12.0;
dbmon = (double) cmon;
lst = 12 * modf((dbmon - 1 + 12) / 12, iyr);
ilst = (int) (lst + 0.00001);
printf("double-mon=%g,lastmon=%g,ilst=%i\n", dbmon, lst, ilst);
smon = (double) ((int) cmon % NMONTHS);
snxt = (double) ((int) (cmon + 1) % NMONTHS);
mon = 12.0 * modf(dyr, iyr);
nxt = 12.0 * modf(ndyr, nyr);
printf("the current month is %i-%g-%g \n", cmon, smon, mon);
printf("the current year is %g \n", *iyr);
imon = (int) (mon + 0.00001);
inxt = (int) (nxt + 0.00001);
ismon = (int) (smon + 0.00001);
isnxt = (int) (snxt + 0.00001);
yearday = 0;
for (i=0;i<=imon;i++) yearday += dmon[imon];
currtime = *iyr + BEGYEAR + yearday/365.0;
day = (*iyr) * 365.0 + dmon[imon];
*dy = currtime;
printf("the current day is -%g- \n", *dy);
printf("the current ismon/smon is -%i-%g- \n", ismon, smon);
printf("the next smonth/mean index: -%i- \n", isnxt);
dt = ((double) mlen[imon]);
dt = dt * 86400 / (double) NTSTEP;
for (itts = 1; itts <= NTSTEP; itts++)
{
printf("\nSub time step number= %i \n", itts);
/*-----------------------------------
*
* get physical fields and bc's
*
*----------------------------------*/
printf("Month %d timestamp Start: %4.2f End: %4.2f\n",cmon,currtime,currtime+dt/31536000);
currtime += dt / 31536000; //ashao: advance currenttime
copy_2fix_darray3d(hstart,hend,NZ,NXMEM,NYMEM);
copy_2fix_darray3d(h,hstart,NZ,NXMEM,NYMEM);
if (usehindcast) {
if ( ( cmon >= starthindindex) && ( hindindex <= (numhindmonths-1) )) {
printf("Reading in UVW from hindcast\n");
read_uvw(hindindex,"hind");
read_h(hindindex,hend,"hind");
hindindex++;
}
else {
printf("Reading in UVW from climatology\n");
read_uvw(isnxt,"clim");
read_h(isnxt, hend,"clim");
}
}
else {
printf("Reading in UVW from climatology\n");
read_uvw(isnxt,"clim");
read_h(isnxt, hend,"clim");
}
printf("Month- hstart:%d hend:%d\n",ismon,isnxt);
/*-----------------------------------
*
* integrate 1 time step
*
*----------------------------------*/
printf("step fields - day = %g\n\n", day);
step_fields(iyear, itts, imon, iterno); // modified ashao
/*-------------------------------------------------------------------*
*
* end integration loop
*
*-------------------------------------------------------------------*/
/*-----------------------------------
*
* calculate tracer averages
*
*----------------------------------*/
printf("calculate tracer averages\n");
if (flags[8])
add_fix_darray2d(mn_eaml, eaml);
if (flags[1])
add_darray3d(mn_u, u, NZ, NXMEM, NYMEM);
if (flags[2])
add_darray3d(mn_v, v, NZ, NXMEM, NYMEM);
if (flags[3])
{
for (k = 0; k < NZ; k++)
for (i = 0; i < NXMEM; i++)
for (j = 0; j < NYMEM; j++)
{
mn_h[k][i][j] += h[k][i][j];
}
}
if (flags[4])
add_darray3d(mn_uhtm, uhtm, NZ, NXMEM, NYMEM);
if (flags[5])
add_darray3d(mn_vhtm, vhtm, NZ, NXMEM, NYMEM);
if (flags[6])
add_darray3d(mn_ea, ea, NZ, NXMEM, NYMEM);
if (flags[7])
add_darray3d(mn_eb, eb, NZ, NXMEM, NYMEM);
#ifdef AGE
//DT
// if (flags[9]) add_darray3d(mn_age, age, NZ, NXMEM, NYMEM);
if (flags[9])
{
for (k = 0; k < NZ; k++)
{
for (i = 0; i < NXMEM; i++)
{
for (j = 0; j < NYMEM; j++)
{
if (age[k][i][j] > 0.0)
{
{
mn_age[k][i][j] += age[k][i][j];
}
}}}}}
//DT
#endif
if (flags[18])
{
for (k = 0; k < 2; k++)
for (i = 0; i < NXMEM; i++)
for (j = 0; j < NYMEM; j++)
mn_rml[k][i][j] += rml[k][i][j];
}
/* calculate the mean */
if (nmn == WRINT && itts == 1)
{
printf("***nmn= %i, itts= %i, nmnfirst= %i\n", nmn, itts,
nmnfirst);
frac = 1.0 / ((double) nmn * (double) NTSTEP);
if (flags[8])
mult_fix_darray2d(mn_eaml, frac);
if (flags[1])
mult_darray3d(mn_u, NZ, NXMEM, NYMEM, frac);
if (flags[2])
mult_darray3d(mn_v, NZ, NXMEM, NYMEM, frac);
if (flags[3])
mult_darray3d(mn_h, NZ, NXMEM, NYMEM, frac);
if (flags[4])
mult_darray3d(mn_uhtm, NZ, NXMEM, NYMEM, frac);
if (flags[5])
mult_darray3d(mn_vhtm, NZ, NXMEM, NYMEM, frac);
if (flags[6])
mult_darray3d(mn_ea, NZ, NXMEM, NYMEM, frac);
if (flags[7])
mult_darray3d(mn_eb, NZ, NXMEM, NYMEM, frac);
#ifdef AGE
if (flags[9])
mult_darray3d(mn_age, NZ, NXMEM, NYMEM, frac);
#endif
if (flags[18])
mult_darray3d_mv(mn_rml, 2, NXMEM, NYMEM, frac, D, misval);
/*-----------------------------------
*
* write tracer averages and reset to 0
*
*----------------------------------*/
printf("Writing month %i variables out to netCDF\n\n", cmon);
status = nc_open(output_filename, NC_WRITE, &cdfid);
if (status != NC_NOERR)
{
strcpy(message, "Opening file");
strcat(message, output_filename);
handle_error(message, status);
}
err = write_time(cdfid, fn, timeid[0], nrec, dy);
if (err == -1)
printf("Error writing day.\n");
for (m = 0; m < NOVARS; m++)
if (flags[m]==1)
{
printf("m = %d\n",m);
err = write_field(cdfid, fn, vars[m],
varinfo[varmap[m]], nrec, var[m]);
if (err == -1)
printf("Error writing %s.\n", vars[m].name);
}
close_file(&cdfid, &fn);
/* reset all means to zero */
nmn = 0;
if (flags[8])
set_fix_darray2d_zero(mn_eaml);
if (flags[1])
set_darray3d_zero(mn_u, NZ, NXMEM, NYMEM);
if (flags[2])
set_darray3d_zero(mn_v, NZ, NXMEM, NYMEM);
if (flags[3])
set_darray3d_zero(mn_h, NZ, NXMEM, NYMEM);
if (flags[4])
set_darray3d_zero(mn_uhtm, NZ, NXMEM, NYMEM);
if (flags[5])
set_darray3d_zero(mn_vhtm, NZ, NXMEM, NYMEM);
if (flags[6])
set_darray3d_zero(mn_ea, NZ, NXMEM, NYMEM);
if (flags[7])
set_darray3d_zero(mn_eb, NZ, NXMEM, NYMEM);
if (flags[18])
set_darray3d_zero(mn_rml, 2, NXMEM, NYMEM);
#ifdef AGE
if (flags[9])
set_darray3d_zero(mn_age, NZ, NXMEM, NYMEM);
#endif
// begin ashao
// end ashao
printf("netcdf record = %d\n", nrec + 1);
nrec++;
} /* end if nmn==WRITEINT */
/*-------------------------------------------------------------------*
*
* end integration loop
*
*-------------------------------------------------------------------*/
} /* end itts loop over NTSTEP */
} /* end while */
//BX-a
/*-----------------------------------
*
* write restart file
*
*----------------------------------*/
// First write the up-to-date tracer values to the mean fields.
// In order to save memory the instantaneous values for the
// restart will be written on mean fields in the restart file.
printf("start of array copying\n");
//HF #ifdef SMOOTH_REST
copy_fix_darray3d(mn_h, h, NZ, NXMEM, NYMEM);
//HF #endif
#ifdef AGE
copy_darray3d(mn_age, age, NZ, NXMEM, NYMEM);
#endif
for (k = 0; k < NZ; k++)
{
for (i = 0; i < NXMEM; i++)
{
for (j = 0; j < NYMEM; j++)
{
} /* for j loop */
} /* for i loop */
} /* for k loop */
// Second, create restart file name and open file
sprintf(restart_filename, "restart.%s.%04d.nc", run_name, cmon);
printf("Writing NetCDF restart file '%s'.\n\n", restart_filename);
/* Copy the variable descriptions to a list of the actual restart variables. */
nvar = 0;
for (i = 0; i < NOVARS; i++)
if (rflags[i] > 0)
{
var_out[nvar] = vars[i];
varmap[i] = nvar;
nvar++;
}
// do NOT force float precision output with last argument
create_file(restart_filename, NETCDF_FILE, var_out, nvar, &fn, &cdfid,
timeid, varinfo, 0);
for (m = 0; m < NOVARS; m++)
if (rflags[m])
{
err = write_field(cdfid, &fn, vars[m], varinfo[varmap[m]], 0,
var[m]);
if (err == -1)
printf("Error writing %s.\n", vars[m].name);
}
close_file(&cdfid, &fn);
printf("\n programme termine normallement. \n");
return (0);
}
int main(int argc, char *argv[])
{
// Set up batch submission
#ifdef BATCH
SIM_ROOT_DIR = (char*) malloc(CHAR_BUF_SIZE * sizeof(char));
ROOT_DIR = (char*) malloc(CHAR_BUF_SIZE * sizeof(char));
// arg[0] = program name
// arg[1] = SIM_ROOT_DIR
if (argc == 2) {
sprintf(SIM_ROOT_DIR, "%s", argv[1]);
sprintf(ROOT_DIR, "%s/f-rec-part-3D", SIM_ROOT_DIR);
} else if (argc != 2) {
printf("usage: %s SIM_ROOT_DIR\n", argv[0]);
exit(EXIT_FAILURE);
}
printf("\n SIM_ROOT_DIR = %s\n", SIM_ROOT_DIR);
printf(" ROOT_DIR = %s\n\n", ROOT_DIR);
#else // prevent compiler warning
argc = argc;
argv = argv;
#endif
// Read input file
main_read_input();
// Read and sort output directory for finding files within our time limits
init_part_files();
// Get number of particles
nparts = cgns_read_nparts();
// Initialize partstruct and flow vars
parts_init();
// Initialize domain and flow arrays
domain_init();
// Allocate arrays
alloc_arrays();
// Create output directory
get_sigfigs();
create_output();
/* MAIN LOOP */
double kl, km, kn;
int ll, mm, nn, corder;
// Loop over time
for (tt = 0; tt < nFiles; tt++) {
// Fill parts with new info
cgns_fill_parts();
// Loop over all coefficients l,m,n (x,y,z)
for (ll = 0; ll <= orderL; ll++) {
kl = 2.*PI*ll/dom.xl;
for (mm = 0; mm <= orderM; mm++) {
km = 2.*PI*mm/dom.yl;
for (nn = 0; nn <= orderN; nn++) {
kn = 2.*PI*nn/dom.zl;
corder = nn + (orderN + 1)*mm + (orderN + 1)*(orderM + 1)*ll;
// Calculate coefficients n_lmn
// TODO: need diff for vfrac
calc_coeffs(n_lmn, ones, parts, kl, km, kn, corder);
//printf("n_lmn[%d] = %f + %fi\n", corder, creal(n_lmn[corder]), cimag(n_lmn[corder]));
// does it make sense to not even store n_lmn?
// evaluate series for n_lmn at x,y,z
// TODO: need diff for vfrac
// TODO: parallelize? probably not, is not TOO slow
// TODO: is n_rec always real?
eval_series(n_rec, n_lmn, kl, km, kn, corder);
}
}
}
// Normalize nq by n to find q
// make sure to divide by volume...
//normalize(nu_ces, n_ces);
// // write to file -- TODO take specific nq_rec as input
cgns_write_field();
}
// Free and exit
free_vars();
printf("... Done!\n");
return EXIT_SUCCESS;
}
