int main(int i_argc, char *i_argv[])
{
const char *bogus_var_names[] = {
"velocity-u",
"velocity-v",
nullptr
};
if (!simVars.setupFromMainParameters(i_argc, i_argv, bogus_var_names))
{
std::cout << std::endl;
std::cout << "Program-specific options:" << std::endl;
std::cout << " --velocity-u [advection velocity u]" << std::endl;
std::cout << " --velocity-v [advection velocity v]" << std::endl;
return -1;
}
if (std::isinf(simVars.bogus.var[0]) || std::isinf(simVars.bogus.var[1]))
{
std::cout << "Both velocities have to be set, see parameters --velocity-u, --velocity-v" << std::endl;
return -1;
}
param_velocity_u = simVars.bogus.var[0];
param_velocity_v = simVars.bogus.var[1];
SimulationSWE *simulationSWE = new SimulationSWE;
#if SWEET_GUI
if (simVars.misc.gui_enabled)
{
VisSweet<SimulationSWE> visSweet(simulationSWE);
}
else
#endif
{
simulationSWE->reset();
while (!simulationSWE->should_quit())
{
simulationSWE->run_timestep();
if (simVars.misc.verbosity > 2)
std::cout << simVars.timecontrol.current_simulation_time << std::endl;
if (simVars.timecontrol.max_simulation_time != -1)
if (simVars.timecontrol.current_simulation_time > simVars.timecontrol.max_simulation_time)
break;
if (simVars.timecontrol.max_timesteps_nr != -1)
if (simVars.timecontrol.current_timestep_nr > simVars.timecontrol.max_timesteps_nr)
break;
}
}
delete simulationSWE;
return 0;
}
int main(int i_argc, char *i_argv[])
{
const char *bogus_var_names[] = {
"velocity-u",
"velocity-v",
nullptr
};
if (!simVars.setupFromMainParameters(i_argc, i_argv, bogus_var_names))
{
std::cout << std::endl;
std::cout << "Program-specific options:" << std::endl;
std::cout << " --velocity-u [advection velocity u]" << std::endl;
std::cout << " --velocity-v [advection velocity v]" << std::endl;
return -1;
}
if (std::isinf(simVars.bogus.var[0]) != 0 || std::isinf(simVars.bogus.var[1]) != 0)
{
std::cout << "Both velocities have to be set, see parameters --velocity-u, --velocity-v" << std::endl;
return -1;
}
planeDataConfigInstance.setupAuto(simVars.disc.res_physical, simVars.disc.res_spectral);
SimulationSWE *simulationSWE = new SimulationSWE;
#if SWEET_GUI
VisSweet<SimulationSWE> visSweet(simulationSWE);
#else
simulationSWE->reset();
while (!simulationSWE->should_quit())
{
simulationSWE->run_timestep();
if (simVars.misc.verbosity > 2)
std::cout << simVars.timecontrol.current_simulation_time << std::endl;
if (simVars.timecontrol.current_simulation_time > simVars.timecontrol.max_simulation_time)
break;
}
#endif
delete simulationSWE;
return 0;
}
int main(int i_argc, char *i_argv[])
{
if (!simVars.setupFromMainParameters(i_argc, i_argv))
{
return -1;
}
planeDataConfigInstance.setupAuto(simVars.disc.res_physical, simVars.disc.res_spectral);
SimulationSWE *simulationSWE = new SimulationSWE;
std::ostringstream buf;
#if SWEET_GUI
if (simVars.misc.gui_enabled)
{
VisSweet<SimulationSWE> visSweet(simulationSWE);
}
else
#endif
{
simulationSWE->reset();
Stopwatch time;
time.reset();
double diagnostics_energy_start, diagnostics_mass_start, diagnostics_potential_entrophy_start;
if (simVars.misc.verbosity > 1)
{
simulationSWE->update_diagnostics();
diagnostics_energy_start = simVars.diag.total_energy;
diagnostics_mass_start = simVars.diag.total_mass;
diagnostics_potential_entrophy_start = simVars.diag.total_potential_enstrophy;
}
while (true)
{
if (simVars.misc.verbosity > 1)
{
simulationSWE->timestep_output(buf);
std::string output = buf.str();
buf.str("");
std::cout << output << std::flush;
}
if (simulationSWE->should_quit())
break;
simulationSWE->run_timestep();
if (simulationSWE->instability_detected())
{
std::cout << "INSTABILITY DETECTED" << std::endl;
break;
}
}
time.stop();
double seconds = time();
std::cout << "Simulation time: " << seconds << " seconds" << std::endl;
std::cout << "Time per time step: " << seconds/(double)simVars.timecontrol.current_timestep_nr << " sec/ts" << std::endl;
std::cout << "Timesteps: " << simVars.timecontrol.current_timestep_nr << std::endl;
if (simVars.misc.verbosity > 1)
{
std::cout << "DIAGNOSTICS ENERGY DIFF:\t" << std::abs((simVars.diag.total_energy-diagnostics_energy_start)/diagnostics_energy_start) << std::endl;
std::cout << "DIAGNOSTICS MASS DIFF:\t" << std::abs((simVars.diag.total_mass-diagnostics_mass_start)/diagnostics_mass_start) << std::endl;
std::cout << "DIAGNOSTICS POTENTIAL ENSTROPHY DIFF:\t" << std::abs((simVars.diag.total_potential_enstrophy-diagnostics_potential_entrophy_start)/diagnostics_potential_entrophy_start) << std::endl;
if (simVars.setup.benchmark_scenario_id == 2 || simVars.setup.benchmark_scenario_id == 3 || simVars.setup.benchmark_scenario_id == 4)
{
std::cout << "DIAGNOSTICS BENCHMARK DIFF H:\t" << simulationSWE->benchmark_diff_h << std::endl;
std::cout << "DIAGNOSTICS BENCHMARK DIFF U:\t" << simulationSWE->benchmark_diff_u << std::endl;
std::cout << "DIAGNOSTICS BENCHMARK DIFF V:\t" << simulationSWE->benchmark_diff_v << std::endl;
}
}
}
delete simulationSWE;
return 0;
}
void reset()
{
next_timestep_output = 0;
last_timestep_nr_update_diagnostics = -1;
benchmark_diff_h = 0;
benchmark_diff_u = 0;
benchmark_diff_v = 0;
simVars.reset();
prog_P.physical_update_lambda_array_indices(
[&](int i, int j, double &io_data)
{
double x = (((double)i+0.5)/(double)simVars.disc.res_physical[0])*simVars.sim.domain_size[0];
double y = (((double)j+0.5)/(double)simVars.disc.res_physical[1])*simVars.sim.domain_size[1];
io_data = SWEPlaneBenchmarks::return_h(simVars, x, y);
}
);
prog_u.physical_update_lambda_array_indices(
[&](int i, int j, double &io_data)
{
double x = (((double)i)/(double)simVars.disc.res_physical[0])*simVars.sim.domain_size[0];
double y = (((double)j+0.5)/(double)simVars.disc.res_physical[1])*simVars.sim.domain_size[1];
io_data = SWEPlaneBenchmarks::return_u(simVars, x, y);
}
);
prog_v.physical_update_lambda_array_indices(
[&](int i, int j, double &io_data)
{
double x = (((double)i+0.5)/(double)simVars.disc.res_physical[0])*simVars.sim.domain_size[0];
double y = (((double)j)/(double)simVars.disc.res_physical[1])*simVars.sim.domain_size[1];
io_data = SWEPlaneBenchmarks::return_v(simVars, x, y);
}
);
beta_plane.physical_update_lambda_array_indices(
[&](int i, int j, double &io_data)
{
double y_beta = (((double)j+0.5)/(double)simVars.disc.res_physical[1]);
io_data = simVars.sim.f0+simVars.sim.beta*y_beta;
}
);
if (simVars.setup.input_data_filenames.size() > 0)
prog_P.file_physical_loadData(simVars.setup.input_data_filenames[0].c_str(), simVars.setup.input_data_binary);
if (simVars.setup.input_data_filenames.size() > 1)
prog_u.file_physical_loadData(simVars.setup.input_data_filenames[1].c_str(), simVars.setup.input_data_binary);
if (simVars.setup.input_data_filenames.size() > 2)
prog_v.file_physical_loadData(simVars.setup.input_data_filenames[2].c_str(), simVars.setup.input_data_binary);
if (simVars.misc.gui_enabled)
timestep_output();
}
int main(int i_argc, char *i_argv[])
{
MemBlockAlloc::setup();
//input parameter names (specific ones for this program)
const char *bogus_var_names[] = {
"rexi-use-coriolis-formulation",
"compute-error",
nullptr
};
// default values for specific input (for general input see SimulationVariables.hpp)
simVars.bogus.var[0] = 0;
simVars.bogus.var[1] = 0;
// Help menu
if (!simVars.setupFromMainParameters(i_argc, i_argv, bogus_var_names))
{
#if SWEET_PARAREAL
simVars.parareal.setup_printOptions();
#endif
return -1;
}
param_rexi_use_coriolis_formulation = simVars.bogus.var[0];
assert (param_rexi_use_coriolis_formulation == 0 || param_rexi_use_coriolis_formulation == 1);
param_compute_error = simVars.bogus.var[1];
sphereDataConfigInstance.setupAutoPhysicalSpace(
simVars.disc.res_spectral[0],
simVars.disc.res_spectral[1],
&simVars.disc.res_physical[0],
&simVars.disc.res_physical[1]
);
#if SWEET_GUI
planeDataConfigInstance.setupAutoSpectralSpace(simVars.disc.res_physical);
#endif
std::ostringstream buf;
buf << std::setprecision(14);
#if 0
SimulationInstance test_swe(sphereDataConfig);
test_swe.run();
#else
#if SWEET_MPI
int rank;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
// only start simulation and time stepping for first rank
if (rank == 0)
#endif
{
#if SWEET_PARAREAL
if (simVars.parareal.enabled)
{
/*
* Allocate parareal controller and provide class
* which implement the parareal features
*/
Parareal_Controller_Serial<SimulationInstance> parareal_Controller_Serial;
// setup controller. This initializes several simulation instances
parareal_Controller_Serial.setup(&simVars.parareal);
// execute the simulation
parareal_Controller_Serial.run();
}
else
#endif
#if SWEET_GUI // The VisSweet directly calls simulationSWE->reset() and output stuff
if (simVars.misc.gui_enabled)
{
SimulationInstance *simulationSWE = new SimulationInstance;
VisSweet<SimulationInstance> visSweet(simulationSWE);
delete simulationSWE;
}
else
#endif
{
SimulationInstance *simulationSWE = new SimulationInstance;
//Setting initial conditions and workspace - in case there is no GUI
simulationSWE->reset();
//Time counter
Stopwatch time;
//Diagnostic measures at initial stage
//double diagnostics_energy_start, diagnostics_mass_start, diagnostics_potential_entrophy_start;
// Initialize diagnostics
if (simVars.misc.verbosity > 0)
{
simulationSWE->update_diagnostics();
#if 0
diagnostics_energy_start = simVars.diag.total_energy;
diagnostics_mass_start = simVars.diag.total_mass;
diagnostics_potential_entrophy_start = simVars.diag.total_potential_enstrophy;
#endif
}
#if SWEET_MPI
MPI_Barrier(MPI_COMM_WORLD);
#endif
//Start counting time
time.reset();
// Main time loop
while(true)
{
if (simulationSWE->timestep_output(buf))
{
// string output data
std::string output = buf.str();
buf.str("");
// This is an output printed on screen or buffered to files if > used
std::cout << output;
}
// Stop simulation if requested
if (simulationSWE->should_quit())
break;
// Main call for timestep run
simulationSWE->run_timestep();
// Instability
if (simulationSWE->instability_detected())
{
std::cout << "INSTABILITY DETECTED" << std::endl;
break;
}
}
// Always write or overwrite final time step output!
simulationSWE->write_file_output();
// Stop counting time
time.stop();
double seconds = time();
// End of run output results
std::cout << "Simulation time (seconds): " << seconds << std::endl;
std::cout << "Number of time steps: " << simVars.timecontrol.current_timestep_nr << std::endl;
std::cout << "Time per time step: " << seconds/(double)simVars.timecontrol.current_timestep_nr << " sec/ts" << std::endl;
std::cout << "Last time step size: " << simVars.timecontrol.current_timestep_size << std::endl;
if (param_compute_error && simVars.misc.use_nonlinear_equations == 0)
{
SphereData backup_h = simulationSWE->prog_h;
SphereData backup_u = simulationSWE->prog_u;
SphereData backup_v = simulationSWE->prog_v;
simulationSWE->reset();
std::cout << "DIAGNOSTICS ANALYTICAL RMS H:\t" << (backup_h-simulationSWE->prog_h).physical_reduce_rms() << std::endl;
std::cout << "DIAGNOSTICS ANALYTICAL RMS U:\t" << (backup_u-simulationSWE->prog_u).physical_reduce_rms() << std::endl;
std::cout << "DIAGNOSTICS ANALYTICAL RMS V:\t" << (backup_v-simulationSWE->prog_v).physical_reduce_rms() << std::endl;
std::cout << "DIAGNOSTICS ANALYTICAL MAXABS H:\t" << (backup_h-simulationSWE->prog_h).physical_reduce_max_abs() << std::endl;
std::cout << "DIAGNOSTICS ANALYTICAL MAXABS U:\t" << (backup_u-simulationSWE->prog_u).physical_reduce_max_abs() << std::endl;
std::cout << "DIAGNOSTICS ANALYTICAL MAXABS V:\t" << (backup_v-simulationSWE->prog_v).physical_reduce_max_abs() << std::endl;
}
delete simulationSWE;
}
}
#if SWEET_MPI
else
{
if (param_timestepping_mode == 1)
{
SWE_Plane_REXI rexiSWE;
/*
* Setup our little dog REXI
*/
rexiSWE.setup(
simVars.rexi.rexi_h,
simVars.rexi.rexi_m,
simVars.rexi.rexi_l,
simVars.disc.res_physical,
simVars.sim.domain_size,
simVars.rexi.rexi_half,
simVars.rexi.rexi_use_spectral_differences_for_complex_array,
simVars.rexi.rexi_helmholtz_solver_id,
simVars.rexi.rexi_helmholtz_solver_eps
);
bool run = true;
PlaneData prog_h(planeDataConfig);
PlaneData prog_u(planeDataConfig);
PlaneData prog_v(planeDataConfig);
PlaneOperators op(simVars.disc.res_physical, simVars.sim.domain_size, simVars.disc.use_spectral_basis_diffs);
MPI_Barrier(MPI_COMM_WORLD);
while (run)
{
// REXI time stepping
run = rexiSWE.run_timestep_rexi(
prog_h, prog_u, prog_v,
-simVars.sim.CFL,
op,
simVars
);
}
}
}
#endif
#if SWEET_MPI
if (param_timestepping_mode > 0)
{
// synchronize REXI
if (rank == 0)
SWE_Plane_REXI::MPI_quitWorkers(planeDataConfig);
}
MPI_Finalize();
#endif
#endif
return 0;
}
int main(
int i_argc,
char *const i_argv[]
)
{
const char *bogus_var_names[] = {
"function-order",
nullptr
};
if (!simVars.setupFromMainParameters(i_argc, i_argv, bogus_var_names))
{
std::cout << std::endl;
std::cout << "Program-specific options:" << std::endl;
std::cout << " --function-order [order of function to test]" << std::endl;
std::cout << std::endl;
return -1;
}
planeDataConfigInstance.setupAuto(simVars.disc.res_physical, simVars.disc.res_spectral);
#if SWEET_GUI
if (simVars.misc.gui_enabled)
{
SimulationTestRK *simulationTestRK = new SimulationTestRK;
VisSweet<SimulationTestRK> visSweet(simulationTestRK);
delete simulationTestRK;
return 0;
}
#endif
if (simVars.timecontrol.max_simulation_time == -1)
{
std::cerr << "Max. simulation time is unlimited, please specify e.g. -t 6" << std::endl;
return -1;
}
if (!std::isinf(simVars.bogus.var[0]))
time_test_function_order = simVars.bogus.var[0];
for (int fun_order = 0; fun_order <= 4; fun_order++)
{
time_test_function_order = fun_order;
for (int ts_order = 1; ts_order <= 4; ts_order++)
{
timestepping_runge_kutta_order = ts_order;
/*
* iterate over resolutions, starting by res[0] given e.g. by program parameter -n
*/
simVars.reset();
SimulationTestRK *simulationTestRK = new SimulationTestRK;
while(true)
{
if (simVars.misc.verbosity > 2)
std::cout << simVars.timecontrol.current_simulation_time << ": " << simulationTestRK->prog_h.physical_get(0,0) << std::endl;
simulationTestRK->run_timestep();
if (simulationTestRK->instability_detected())
{
std::cout << "INSTABILITY DETECTED" << std::endl;
break;
}
if (simVars.timecontrol.max_simulation_time < simVars.timecontrol.current_simulation_time)
{
PlaneData benchmark_h(planeDataConfig);
benchmark_h.physical_set_all(simulationTestRK->test_function(time_test_function_order, simVars.timecontrol.current_simulation_time));
double error = (simulationTestRK->prog_h-benchmark_h).reduce_rms_quad();
std::cout << "with function order " << fun_order << " with RK timestepping " << ts_order << " resulted in RMS error " << error << std::endl;
if (fun_order <= ts_order)
{
if (error > 0.0000001)
{
std::cout << "ERROR threshold exceeded!" << std::endl;
return 1;
}
}
else
{
if (error < 0.0000001)
{
std::cout << "ERROR threshold is expected to be larger, can still be valid!" << std::endl;
return 1;
}
}
std::cout << "OK" << std::endl;
break;
}
}
delete simulationTestRK;
}
}
return 0;
}
