// Needed for code to compile correctly on the Mac

int mype=0;

int numpe=-1;

// Process command-line arguments, if any.

parseInput(argc, argv);

struct timeval tstart_setup;

cpu_timer_start(&tstart_setup);

numpe = 16;

double circ_radius = 6.0;

// Scale the circle appropriately for the mesh size.

circ_radius = circ_radius * (double) nx / 128.0;

int boundary = 1;

int parallel_in = 0;

mesh = new Mesh(nx, ny, levmx, ndim, boundary, parallel_in, do_gpu_calc);

if (DEBUG) {

//if (mype == 0) mesh->print();

char filename[10];

sprintf(filename,"out%1d",mype);

mesh->fp=fopen(filename,"w");

//mesh->print_local();

}

mesh->init(nx, ny, circ_radius, initial_order, do_gpu_calc);

size_t &ncells = mesh->ncells;

state = new State(mesh);

state->init(do_gpu_calc);

mesh->proc.resize(ncells);

mesh->calc_distribution(numpe);

state->fill_circle(circ_radius, 100.0, 5.0);

mesh->nlft = NULL;

mesh->nrht = NULL;

mesh->nbot = NULL;

mesh->ntop = NULL;

// Kahan-type enhanced precision sum implementation.

double H_sum = state->mass_sum(enhanced_precision_sum);

printf ("Mass of initialized cells equal to %14.12lg\n", H_sum);

H_sum_initial = H_sum;

double cpu_time_main_setup = cpu_timer_stop(tstart_setup);

state->parallel_timer_output(numpe,mype,"CPU: setup time time was",cpu_time_main_setup);

long long mem_used = memstats_memused();

if (mem_used > 0) {

printf("Memory used in startup %lld kB\n",mem_used);

printf("Memory peak in startup %lld kB\n",memstats_mempeak());

printf("Memory free at startup %lld kB\n",memstats_memfree());

printf("Memory available at startup %lld kB\n",memstats_memtotal());

}

printf("Iteration 0 timestep n/a Sim Time 0.0 cells %ld Mass Sum %14.12lg\n", ncells, H_sum);

mesh->cpu_calc_neigh_counter=0;

mesh->cpu_time_calc_neighbors=0.0;

mesh->cpu_rezone_counter=0;

mesh->cpu_time_rezone_all=0.0;

mesh->cpu_refine_smooth_counter=0;

// Set up grid.

#ifdef GRAPHICS_OUTPUT

mesh->write_grid(n);

#endif

#ifdef HAVE_GRAPHICS

set_mysize(ncells);

set_viewmode(view_mode);

set_window(mesh->xmin, mesh->xmax, mesh->ymin, mesh->ymax);

set_outline((int)outline);

init_display(&argc, argv, "Shallow Water", mype);

set_cell_coordinates(&mesh->x[0], &mesh->dx[0], &mesh->y[0], &mesh->dy[0]);

set_cell_data(&state->H[0]);

set_cell_proc(&mesh->proc[0]);

set_circle_radius(circle_radius);

draw_scene();

//if (verbose) sleep(5);

sleep(2);

// Set flag to show mesh results rather than domain decomposition.

view_mode = 1;

// Clear superposition of circle on grid output.

circle_radius = -1.0;

cpu_timer_start(&tstart);

set_idle_function(&do_calc);

start_main_loop();

#else

cpu_timer_start(&tstart);

for (int it = 0; it < 10000000; it++) {

do_calc();

}

#endif

return 0;

{ double g = 9.80;

double sigma = 0.95;

int icount, jcount;

// Initialize state variables for GPU calculation.

size_t &ncells = mesh->ncells;

vector<int> mpot;

size_t old_ncells = ncells;

size_t new_ncells = 0;

double H_sum = -1.0;

double deltaT = 0.0;

// Main loop.

for (int nburst = 0; nburst < outputInterval && ncycle < niter; nburst++, ncycle++) {

old_ncells = ncells;

// Calculate the real time step for the current discrete time step.

deltaT = state->set_timestep(g, sigma);

simTime += deltaT;

if (mesh->nlft == NULL) mesh->calc_neighbors();

mesh->partition_measure();

// Currently not working -- may need to be earlier?

//if (do_cpu_calc && ! mesh->have_boundary) {

// state->add_boundary_cells(mesh);

//}

// Apply BCs is currently done as first part of gpu_finite_difference and so comparison won't work here

// Execute main kernel

state->calc_finite_difference(deltaT);

// Size of arrays gets reduced to just the real cells in this call for have_boundary = 0

state->remove_boundary_cells();

mpot.resize(ncells);

new_ncells = state->calc_refine_potential(mpot, icount, jcount);

// Resize the mesh, inserting cells where refinement is necessary.

state->rezone_all(icount, jcount, mpot);

mpot.clear();

mesh->ncells = new_ncells;

ncells = new_ncells;

mesh->proc.resize(ncells);

if (icount)

{ vector<int> index(ncells);

mesh->partition_cells(numpe, index, cycle_reorder);

state->state_reorder(index);

state->memory_reset_ptrs();

}

mesh->ncells = ncells;

}

H_sum = state->mass_sum(enhanced_precision_sum);

if (isnan(H_sum)) {

printf("Got a NAN on cycle %d\n",ncycle);

exit(-1);

}

printf("Iteration %3d timestep %lf Sim Time %lf cells %ld Mass Sum %14.12lg Mass Change %12.6lg\n",

ncycle, deltaT, simTime, ncells, H_sum, H_sum - H_sum_initial);

struct timeval tstart_cpu;

cpu_timer_start(&tstart_cpu);

#ifdef HAVE_GRAPHICS

mesh->calc_spatial_coordinates(0);

set_mysize(ncells);

set_viewmode(view_mode);

set_cell_coordinates(&mesh->x[0], &mesh->dx[0], &mesh->y[0], &mesh->dy[0]);

set_cell_data(&state->H[0]);

set_cell_proc(&mesh->proc[0]);

set_circle_radius(circle_radius);

draw_scene();

#endif

cpu_time_graphics += cpu_timer_stop(tstart_cpu);

// Output final results and timing information.

if (ncycle >= niter) {

//free_display();

// Get overall program timing.

double elapsed_time = cpu_timer_stop(tstart);

long long mem_used = memstats_memused();

//if (mem_used > 0) {

printf("Memory used %lld kB\n",mem_used);

printf("Memory peak %lld kB\n",memstats_mempeak());

printf("Memory free %lld kB\n",memstats_memfree());

printf("Memory available %lld kB\n",memstats_memtotal());

//}

state->output_timing_info(do_cpu_calc, do_gpu_calc, elapsed_time);

printf("CPU: graphics time was\t %8.4f\ts\n", cpu_time_graphics );

mesh->print_partition_measure();

mesh->print_calc_neighbor_type();

mesh->print_partition_type();

printf("CPU: rezone frequency \t %8.4f\tpercent\n", (double)mesh->get_cpu_rezone_count()/(double)ncycle*100.0 );

printf("CPU: calc neigh frequency \t %8.4f\tpercent\n", (double)mesh->get_cpu_calc_neigh_count()/(double)ncycle*100.0 );

printf("CPU: refine_smooth_iter per rezone \t %8.4f\t\n", (double)mesh->get_cpu_refine_smooth_count()/(double)mesh->get_cpu_rezone_count() );

mesh->terminate();

state->terminate();

delete mesh;

delete state;

exit(0);

} // Complete final output.