int main(int argc, char* argv[])
{
// Choose a Butcher's table or define your own.
ButcherTable bt(butcher_table_type);
if (bt.is_explicit()) info("Using a %d-stage explicit R-K method.", bt.get_size());
if (bt.is_diagonally_implicit()) info("Using a %d-stage diagonally implicit R-K method.", bt.get_size());
if (bt.is_fully_implicit()) info("Using a %d-stage fully implicit R-K method.", bt.get_size());
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("wall.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(BDY_BOTTOM, INIT_REF_NUM_BDY);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_neumann(Hermes::vector<int>(BDY_RIGHT, BDY_LEFT));
bc_types.add_bc_newton(Hermes::vector<int>(BDY_BOTTOM, BDY_TOP));
// Initialize an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, NULL, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d.", ndof);
// Previous and next time level solutions.
Solution* sln_time_prev = new Solution(&mesh, TEMP_INIT);
Solution* sln_time_new = new Solution(&mesh);
Solution* time_error_fn = new Solution(&mesh, 0.0);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(stac_jacobian_vol, stac_jacobian_vol_ord, HERMES_NONSYM, HERMES_ANY, sln_time_prev);
wf.add_vector_form(stac_residual_vol, stac_residual_vol_ord, HERMES_ANY, sln_time_prev);
wf.add_matrix_form_surf(stac_jacobian_bottom, stac_jacobian_bottom_ord, BDY_BOTTOM, sln_time_prev);
wf.add_vector_form_surf(stac_residual_bottom, stac_residual_bottom_ord, BDY_BOTTOM, sln_time_prev);
wf.add_matrix_form_surf(stac_jacobian_top, stac_jacobian_top_ord, BDY_TOP, sln_time_prev);
wf.add_vector_form_surf(stac_residual_top, stac_residual_top_ord, BDY_TOP, sln_time_prev);
// Initialize the FE problem.
bool is_linear = true;
DiscreteProblem dp(&wf, &space, is_linear);
// Initialize views.
ScalarView Tview("Temperature", new WinGeom(0, 0, 1500, 400));
Tview.fix_scale_width(40);
ScalarView eview("Temporal error", new WinGeom(0, 450, 1500, 400));
eview.fix_scale_width(40);
// Graph for time step history.
SimpleGraph time_step_graph;
info("Time step history will be saved to file time_step_history.dat.");
// Time stepping loop:
double current_time = 0; int ts = 1;
do
{
// Perform one Runge-Kutta time step according to the selected Butcher's table.
info("Runge-Kutta time step (t = %g s, tau = %g s, stages: %d).",
current_time, time_step, bt.get_size());
bool verbose = true;
bool is_linear = true;
if (!rk_time_step(current_time, time_step, &bt, sln_time_prev, sln_time_new, time_error_fn, &dp, matrix_solver,
verbose, is_linear)) {
error("Runge-Kutta time step failed, try to decrease time step size.");
}
// Plot error function.
char title[100];
sprintf(title, "Temporal error, t = %g", current_time);
eview.set_title(title);
AbsFilter abs_tef(time_error_fn);
eview.show(&abs_tef, HERMES_EPS_VERYHIGH);
// Calculate relative time stepping error and decide whether the
// time step can be accepted. If not, then the time step size is
// reduced and the entire time step repeated. If yes, then another
// check is run, and if the relative error is very low, time step
// is increased.
double rel_err_time = calc_norm(time_error_fn, HERMES_H1_NORM) / calc_norm(sln_time_new, HERMES_H1_NORM) * 100;
info("rel_err_time = %g%%", rel_err_time);
if (rel_err_time > TIME_TOL_UPPER) {
info("rel_err_time above upper limit %g%% -> decreasing time step from %g to %g and restarting time step.",
TIME_TOL_UPPER, time_step, time_step * TIME_STEP_DEC_RATIO);
time_step *= TIME_STEP_DEC_RATIO;
continue;
}
if (rel_err_time < TIME_TOL_LOWER) {
info("rel_err_time = below lower limit %g%% -> increasing time step from %g to %g",
TIME_TOL_UPPER, time_step, time_step * TIME_STEP_INC_RATIO);
time_step *= TIME_STEP_INC_RATIO;
}
// Add entry to the timestep graph.
time_step_graph.add_values(current_time, time_step);
time_step_graph.save("time_step_history.dat");
// Update time.
current_time += time_step;
// Show the new time level solution.
sprintf(title, "Time %3.2f s", current_time);
Tview.set_title(title);
Tview.show(sln_time_new);
// Copy solution for the new time step.
sln_time_prev->copy(sln_time_new);
// Increase counter of time steps.
ts++;
}
while (current_time < T_FINAL);
// Cleanup.
delete sln_time_prev;
delete sln_time_new;
delete time_error_fn;
// Wait for the view to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Initialize refinement selector.
MySelector selector(hORpSelectionBasedOnDOFs);
HermesCommonApi.set_integral_param_value(Hermes::showInternalWarnings, false);
// Time measurement.
Hermes::Mixins::TimeMeasurable cpu_time;
cpu_time.tick();
// Load the mesh.
MeshSharedPtr mesh(new Mesh);
MeshReaderH2D mloader;
mloader.load("domain.mesh", mesh);
// Error calculation & adaptivity.
DefaultErrorCalculator<complex, HERMES_H1_NORM> errorCalculator(RelativeErrorToGlobalNorm, 1);
// Stopping criterion for an adaptivity step.
AdaptStoppingCriterionSingleElement<complex> stoppingCriterion(THRESHOLD);
// Adaptivity processor class.
Adapt<complex> adaptivity(&errorCalculator, &stoppingCriterion);
// Perform initial mesh refinements.
for (int i = 0; i < INIT_REF_NUM; i++) mesh->refine_all_elements();
// Initialize boundary conditions.
DefaultEssentialBCConst<complex> bc_essential("Source", P_SOURCE);
EssentialBCs<complex> bcs(&bc_essential);
// Create an H1 space with default shapeset.
SpaceSharedPtr<complex> space(new H1Space<complex> (mesh, &bcs, P_INIT));
int ndof = Space<complex>::get_num_dofs(space);
//Hermes::Mixins::Loggable::Static::info("ndof = %d", ndof);
// Initialize the weak formulation.
CustomWeakFormAcoustics wf("Wall", RHO, SOUND_SPEED, OMEGA);
// Initialize coarse and reference mesh solution.
MeshFunctionSharedPtr<complex> sln(new Solution<complex>), ref_sln(new Solution<complex>);
// Initialize views.
ScalarView sview("Acoustic pressure", new WinGeom(600, 0, 600, 350));
sview.show_contours(.2);
ScalarView eview("Error", new WinGeom(600, 377, 600, 350));
sview.show_mesh(false);
sview.fix_scale_width(50);
OrderView oview("Polynomial orders", new WinGeom(1208, 0, 600, 350));
ScalarView ref_view("Refined elements", new WinGeom(1208, 377, 600, 350));
ref_view.show_scale(false);
ref_view.set_min_max_range(0, 2);
// DOF and CPU convergence graphs initialization.
SimpleGraph graph_dof, graph_cpu;
//Hermes::Mixins::Loggable::Static::info("Solving on reference mesh.");
// Time measurement.
cpu_time.tick();
// Perform Newton's iteration.
Hermes::Hermes2D::NewtonSolver<complex> newton(&wf, space);
newton.set_verbose_output(false);
// Adaptivity loop:
int as = 1;
adaptivity.set_space(space);
bool done = false;
do
{
//Hermes::Mixins::Loggable::Static::info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Mesh::ReferenceMeshCreator refMeshCreator(mesh);
MeshSharedPtr ref_mesh = refMeshCreator.create_ref_mesh();
Space<complex>::ReferenceSpaceCreator refSpaceCreator(space, ref_mesh);
SpaceSharedPtr<complex> ref_space = refSpaceCreator.create_ref_space();
int ndof_ref = Space<complex>::get_num_dofs(ref_space);
wf.set_verbose_output(false);
newton.set_space(ref_space);
// Assemble the reference problem.
try
{
newton.solve();
}
catch(Hermes::Exceptions::Exception e)
{
e.print_msg();
throw Hermes::Exceptions::Exception("Newton's iteration failed.");
};
// Translate the resulting coefficient vector into the Solution<complex> sln->
Hermes::Hermes2D::Solution<complex>::vector_to_solution(newton.get_sln_vector(), ref_space, ref_sln);
// Project the fine mesh solution onto the coarse mesh.
//Hermes::Mixins::Loggable::Static::info("Projecting reference solution on coarse mesh.");
OGProjection<complex> ogProjection; ogProjection.project_global(space, ref_sln, sln);
// Time measurement.
cpu_time.tick();
// View the coarse mesh solution and polynomial orders.
MeshFunctionSharedPtr<double> acoustic_pressure(new RealFilter(sln));
sview.show(acoustic_pressure);
oview.show(space);
// Calculate element errors and total error estimate.
//Hermes::Mixins::Loggable::Static::info("Calculating error estimate.");
errorCalculator.calculate_errors(sln, ref_sln);
double err_est_rel = errorCalculator.get_total_error_squared() * 100;
eview.show(errorCalculator.get_errorMeshFunction());
// Report results.
//Hermes::Mixins::Loggable::Static::info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%", Space<complex>::get_num_dofs(space), Space<complex>::get_num_dofs(ref_space), err_est_rel);
// Time measurement.
cpu_time.tick();
// Add entry to DOF and CPU convergence graphs.
graph_dof.add_values(Space<complex>::get_num_dofs(space), err_est_rel);
graph_dof.save("conv_dof_est.dat");
graph_cpu.add_values(cpu_time.accumulated(), err_est_rel);
graph_cpu.save("conv_cpu_est.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else
{
//Hermes::Mixins::Loggable::Static::info("Adapting coarse mesh.");
done = adaptivity.adapt(&selector);
ref_view.show(adaptivity.get_refinementInfoMeshFunction());
cpu_time.tick();
std::cout << "Adaptivity step: " << as << ", running CPU time: " << cpu_time.accumulated_str() << std::endl;
}
// Increase counter.
as++;
}
while (done == false);
//Hermes::Mixins::Loggable::Static::info("Total running time: %g s", cpu_time.accumulated());
// Show the reference solution - the final result.
sview.set_title("Fine mesh solution magnitude");
MeshFunctionSharedPtr<double> ref_mag(new RealFilter(ref_sln));
sview.show(ref_mag);
// Output solution in VTK format.
Linearizer lin(FileExport);
bool mode_3D = true;
lin.save_solution_vtk(ref_mag, "sln.vtk", "Acoustic pressure", mode_3D);
//Hermes::Mixins::Loggable::Static::info("Solution in VTK format saved to file %s.", "sln.vtk");
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// load the mesh
Mesh mesh;
if (ALIGN_MESH) mesh.load("oven_load_circle.mesh");
else mesh.load("oven_load_square.mesh");
// initialize the shapeset and the cache
HcurlShapeset shapeset;
PrecalcShapeset pss(&shapeset);
// create finite element space
HcurlSpace space(&mesh, &shapeset);
space.set_bc_types(e_bc_types);
space.set_uniform_order(P_INIT);
// enumerate basis functions
space.assign_dofs();
// initialize the weak formulation
WeakForm wf(1);
wf.add_biform(0, 0, bilinear_form);
wf.add_liform_surf(0, linear_form_surf);
// visualize solution and mesh
VectorView eview("Electric field",0,0,800, 590);
OrderView ord("Order", 800, 0, 700, 590);
// matrix solver
UmfpackSolver solver;
// convergence graph wrt. the number of degrees of freedom
GnuplotGraph graph;
graph.set_captions("Error Convergence for the Waveguide Problem", "Degrees of Freedom", "Error Estimate [%]");
graph.add_row("error estimate", "-", "o");
graph.set_log_y();
// convergence graph wrt. CPU time
GnuplotGraph graph_cpu;
graph_cpu.set_captions("Error Convergence for the Waveguide Problem", "CPU Time", "Error Estimate [%]");
graph_cpu.add_row("error estimate", "-", "o");
graph_cpu.set_log_y();
// adaptivity loop
int it = 1, ndofs;
bool done = false;
double cpu = 0.0;
Solution sln_coarse, sln_fine;
do
{
info("\n---- Adaptivity step %d ---------------------------------------------\n", it++);
// time measurement
begin_time();
// coarse problem
LinSystem sys(&wf, &solver);
sys.set_spaces(1, &space);
sys.set_pss(1, &pss);
sys.assemble();
sys.solve(1, &sln_coarse);
// time measurement
cpu += end_time();
// show real part of the solution
AbsFilter abs(&sln_coarse);
eview.set_min_max_range(0, 4e3);
eview.show(&abs);
ord.show(&space);
// time measurement
begin_time();
// solve the fine mesh problem
RefSystem ref(&sys);
ref.assemble();
ref.solve(1, &sln_fine);
// calculate error estimate wrt. fine mesh solution
HcurlOrthoHP hp(1, &space);
hp.set_kappa(sqr(kappa));
double err_est = hp.calc_error(&sln_coarse, &sln_fine) * 100;
info("Hcurl error estimate: %g%%", hcurl_error(&sln_coarse, &sln_fine) * 100);
info("Adapt error estimate: %g%%", err_est);
// add entry to DOF convergence graph
graph.add_values(0, space.get_num_dofs(), err_est);
graph.save("conv_dof.gp");
// add entry to CPU convergence graph
graph_cpu.add_values(0, cpu, err_est);
graph_cpu.save("conv_cpu.gp");
// if err_est too large, adapt the mesh
if (err_est < ERR_STOP) done = true;
else {
hp.adapt(THRESHOLD, STRATEGY, ADAPT_TYPE, ISO_ONLY, MESH_REGULARITY);
ndofs = space.assign_dofs();
if (ndofs >= NDOF_STOP) done = true;
}
// time measurement
cpu += end_time();
}
while (done == false);
verbose("Total running time: %g sec", cpu);
// wait for keyboard or mouse input
printf("Waiting for keyboard or mouse input.\n");
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
MeshReaderH2D mloader;
if (ALIGN_MESH)
mloader.load("oven_load_circle.mesh", &mesh);
else
mloader.load("oven_load_square.mesh", &mesh);
// Perform initial mesh refinemets.
for (int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Initialize boundary conditions
DefaultEssentialBCConst<std::complex<double> > bc_essential(BDY_PERFECT_CONDUCTOR, std::complex<double>(0.0, 0.0));
EssentialBCs<std::complex<double> > bcs(&bc_essential);
// Create an Hcurl space with default shapeset.
HcurlSpace<std::complex<double> > space(&mesh, &bcs, P_INIT);
int ndof = space.get_num_dofs();
Hermes::Mixins::Loggable::Static::info("ndof = %d", ndof);
// Initialize the weak formulation.
CustomWeakForm wf(e_0, mu_0, mu_r, kappa, omega, J, ALIGN_MESH, &mesh, BDY_CURRENT);
// Initialize coarse and reference mesh solution.
Solution<std::complex<double> > sln, ref_sln;
// Initialize refinements selector.
HcurlProjBasedSelector<std::complex<double> > selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
ScalarView eview("Electric field", new WinGeom(0, 0, 580, 400));
OrderView oview("Polynomial orders", new WinGeom(590, 0, 550, 400));
// DOF and CPU convergence graphs initialization.
SimpleGraph graph_dof, graph_cpu;
// Time measurement.
Hermes::Mixins::TimeMeasurable cpu_time;
cpu_time.tick();
// Adaptivity loop:
int as = 1; bool done = false;
do
{
Hermes::Mixins::Loggable::Static::info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Mesh::ReferenceMeshCreator refMeshCreator(&mesh);
Mesh* ref_mesh = refMeshCreator.create_ref_mesh();
Space<std::complex<double> >::ReferenceSpaceCreator refSpaceCreator(&space, ref_mesh);
Space<std::complex<double> >* ref_space = refSpaceCreator.create_ref_space();
int ndof_ref = Space<std::complex<double> >::get_num_dofs(ref_space);
// Initialize reference problem.
Hermes::Mixins::Loggable::Static::info("Solving on reference mesh.");
DiscreteProblem<std::complex<double> > dp(&wf, ref_space);
// Time measurement.
cpu_time.tick();
// Perform Newton's iteration.
Hermes::Hermes2D::NewtonSolver<std::complex<double> > newton(&dp);
try
{
newton.set_newton_max_iter(NEWTON_MAX_ITER);
newton.set_newton_tol(NEWTON_TOL);
newton.solve();
}
catch(Hermes::Exceptions::Exception e)
{
e.print_msg();
throw Hermes::Exceptions::Exception("Newton's iteration failed.");
};
// Translate the resulting coefficient vector into the Solution<std::complex<double> > sln.
Hermes::Hermes2D::Solution<std::complex<double> >::vector_to_solution(newton.get_sln_vector(), ref_space, &ref_sln);
// Project the fine mesh solution onto the coarse mesh.
Hermes::Mixins::Loggable::Static::info("Projecting reference solution on coarse mesh.");
OGProjection<std::complex<double> > ogProjection; ogProjection.project_global(&space, &ref_sln, &sln);
// View the coarse mesh solution and polynomial orders.
RealFilter real(&sln);
MagFilter<double> magn(&real);
ValFilter limited_magn(&magn, 0.0, 4e3);
char title[100];
sprintf(title, "Electric field, adaptivity step %d", as);
eview.set_title(title);
//eview.set_min_max_range(0.0, 4e3);
eview.show(&limited_magn);
sprintf(title, "Polynomial orders, adaptivity step %d", as);
oview.set_title(title);
oview.show(&space);
// Calculate element errors and total error estimate.
Hermes::Mixins::Loggable::Static::info("Calculating error estimate.");
Adapt<std::complex<double> >* adaptivity = new Adapt<std::complex<double> >(&space);
// Set custom error form and calculate error estimate.
CustomErrorForm cef(kappa);
adaptivity->set_error_form(0, 0, &cef);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 100;
// Report results.
Hermes::Mixins::Loggable::Static::info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%",
Space<std::complex<double> >::get_num_dofs(&space),
Space<std::complex<double> >::get_num_dofs(ref_space), err_est_rel);
// Time measurement.
cpu_time.tick();
// Add entry to DOF and CPU convergence graphs.
graph_dof.add_values(Space<std::complex<double> >::get_num_dofs(&space), err_est_rel);
graph_dof.save("conv_dof_est.dat");
graph_cpu.add_values(cpu_time.accumulated(), err_est_rel);
graph_cpu.save("conv_cpu_est.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else
{
Hermes::Mixins::Loggable::Static::info("Adapting coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
}
if (space.get_num_dofs() >= NDOF_STOP) done = true;
delete adaptivity;
if(!done)
{
delete ref_space->get_mesh();
delete ref_space;
}
// Increase counter.
as++;
}
while (done == false);
Hermes::Mixins::Loggable::Static::info("Total running time: %g s", cpu_time.accumulated());
RealFilter ref_real(&sln);
MagFilter<double> ref_magn(&ref_real);
ValFilter ref_limited_magn(&ref_magn, 0.0, 4e3);
eview.set_title("Fine mesh solution - magnitude");
eview.show(&ref_limited_magn);
// Output solution in VTK format.
Linearizer lin;
bool mode_3D = true;
lin.save_solution_vtk(&ref_limited_magn, "sln.vtk", "Magnitude of E", mode_3D);
Hermes::Mixins::Loggable::Static::info("Solution in VTK format saved to file %s.", "sln.vtk");
// Wait for all views to be closed.
View::wait();
return 0;
}
// Main function.
int main(int argc, char* argv[])
{
ConstitutiveRelationsGenuchtenWithLayer constitutive_relations(CONSTITUTIVE_TABLE_METHOD, NUM_OF_INSIDE_PTS, LOW_LIMIT, TABLE_PRECISION, TABLE_LIMIT, K_S_vals, ALPHA_vals, N_vals, M_vals, THETA_R_vals, THETA_S_vals, STORATIVITY_vals);
// Either use exact constitutive relations (slow) (method 0) or precalculate
// their linear approximations (faster) (method 1) or
// precalculate their quintic polynomial approximations (method 2) -- managed by
// the following loop "Initializing polynomial approximation".
if (CONSTITUTIVE_TABLE_METHOD == 1)
constitutive_relations.constitutive_tables_ready = get_constitutive_tables(1, &constitutive_relations, MATERIAL_COUNT); // 1 stands for the Newton's method.
// The van Genuchten + Mualem K(h) function is approximated by polynomials close
// to zero in case of CONSTITUTIVE_TABLE_METHOD==1.
// In case of CONSTITUTIVE_TABLE_METHOD==2, all constitutive functions are approximated by polynomials.
info("Initializing polynomial approximations.");
for (int i=0; i < MATERIAL_COUNT; i++)
{
// Points to be used for polynomial approximation of K(h).
double* points = new double[NUM_OF_INSIDE_PTS];
init_polynomials(6 + NUM_OF_INSIDE_PTS, LOW_LIMIT, points, NUM_OF_INSIDE_PTS, i, &constitutive_relations, MATERIAL_COUNT, NUM_OF_INTERVALS, INTERVALS_4_APPROX);
}
constitutive_relations.polynomials_ready = true;
if (CONSTITUTIVE_TABLE_METHOD == 2)
{
constitutive_relations.constitutive_tables_ready = true;
//Assign table limit to global definition.
constitutive_relations.table_limit = INTERVALS_4_APPROX[NUM_OF_INTERVALS-1];
}
// Choose a Butcher's table or define your own.
ButcherTable bt(butcher_table_type);
if (bt.is_explicit()) info("Using a %d-stage explicit R-K method.", bt.get_size());
if (bt.is_diagonally_implicit()) info("Using a %d-stage diagonally implicit R-K method.", bt.get_size());
if (bt.is_fully_implicit()) info("Using a %d-stage fully implicit R-K method.", bt.get_size());
// Load the mesh.
Mesh mesh, basemesh;
MeshReaderH2D mloader;
mloader.load(mesh_file, &basemesh);
// Perform initial mesh refinements.
mesh.copy(&basemesh);
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary("Top", INIT_REF_NUM_BDY_TOP);
// Initialize boundary conditions.
RichardsEssentialBC bc_essential("Top", H_ELEVATION, PULSE_END_TIME, H_INIT, STARTUP_TIME);
EssentialBCs<double> bcs(&bc_essential);
// Create an H1 space with default shapeset.
H1Space<double> space(&mesh, &bcs, P_INIT);
int ndof = space.get_num_dofs();
info("ndof = %d.", ndof);
// Convert initial condition into a Solution.
ZeroSolution h_time_prev(&mesh), h_time_new(&mesh), time_error_fn(&mesh);
// Initialize views.
ScalarView view("Initial condition", new WinGeom(0, 0, 600, 500));
view.fix_scale_width(80);
// Visualize the initial condition.
view.show(&h_time_prev);
// Initialize the weak formulation.
CustomWeakFormRichardsRK wf(&constitutive_relations);
// Visualize the projection and mesh.
ScalarView sview("Initial condition", new WinGeom(0, 0, 400, 350));
sview.fix_scale_width(50);
sview.show(&h_time_prev, HERMES_EPS_VERYHIGH);
ScalarView eview("Temporal error", new WinGeom(405, 0, 400, 350));
eview.fix_scale_width(50);
eview.show(&time_error_fn, HERMES_EPS_VERYHIGH);
OrderView oview("Initial mesh", new WinGeom(810, 0, 350, 350));
oview.show(&space);
// Graph for time step history.
SimpleGraph time_step_graph;
info("Time step history will be saved to file time_step_history.dat.");
// Initialize Runge-Kutta time stepping.
RungeKutta<double> runge_kutta(&wf, &space, &bt, matrix_solver);
// Time stepping:
double current_time = 0;
int ts = 1;
do
{
info("---- Time step %d, time %3.5f s", ts, current_time);
Space<double>::update_essential_bc_values(&space, current_time);
// Perform one Runge-Kutta time step according to the selected Butcher's table.
info("Runge-Kutta time step (t = %g s, time step = %g s, stages: %d).",
current_time, time_step, bt.get_size());
bool freeze_jacobian = false;
bool block_diagonal_jacobian = false;
bool verbose = true;
double damping_coeff = 1.0;
double max_allowed_residual_norm = 1e10;
try
{
runge_kutta.rk_time_step_newton(current_time, time_step, &h_time_prev,
&h_time_new, &time_error_fn, freeze_jacobian, block_diagonal_jacobian, verbose,
NEWTON_TOL, NEWTON_MAX_ITER, damping_coeff, max_allowed_residual_norm);
}
catch(Exceptions::Exception& e)
{
info("Runge-Kutta time step failed, decreasing time step size from %g to %g days.",
time_step, time_step * time_step_dec);
time_step *= time_step_dec;
if (time_step < time_step_min)
error("Time step became too small.");
continue;
}
// Copy solution for the new time step.
h_time_prev.copy(&h_time_new);
// Show error function.
char title[100];
sprintf(title, "Temporal error, t = %g", current_time);
eview.set_title(title);
eview.show(&time_error_fn, HERMES_EPS_VERYHIGH);
// Calculate relative time stepping error and decide whether the
// time step can be accepted. If not, then the time step size is
// reduced and the entire time step repeated. If yes, then another
// check is run, and if the relative error is very low, time step
// is increased.
double rel_err_time = Global<double>::calc_norm(&time_error_fn, HERMES_H1_NORM) / Global<double>::calc_norm(&h_time_new, HERMES_H1_NORM) * 100;
info("rel_err_time = %g%%", rel_err_time);
if (rel_err_time > time_tol_upper) {
info("rel_err_time above upper limit %g%% -> decreasing time step from %g to %g days and repeating time step.",
time_tol_upper, time_step, time_step * time_step_dec);
time_step *= time_step_dec;
continue;
}
if (rel_err_time < time_tol_lower) {
info("rel_err_time = below lower limit %g%% -> increasing time step from %g to %g days",
time_tol_lower, time_step, time_step * time_step_inc);
time_step *= time_step_inc;
}
// Add entry to the timestep graph.
time_step_graph.add_values(current_time, time_step);
time_step_graph.save("time_step_history.dat");
// Update time.
current_time += time_step;
// Show the new time level solution.
sprintf(title, "Solution, t = %g", current_time);
sview.set_title(title);
sview.show(&h_time_new, HERMES_EPS_VERYHIGH);
oview.show(&space);
// Save complete Solution.
char filename[100];
sprintf(filename, "outputs/tsln_%f.dat", current_time);
h_time_new.save(filename);
info("Solution at time %g saved to file %s.", current_time, filename);
// Save solution for the next time step.
h_time_prev.copy(&h_time_new);
// Increase time step counter.
ts++;
}
while (current_time < T_FINAL);
// Wait for the view to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// load the mesh
Mesh mesh;
H2DReader mloader;
if (ALIGN_MESH) mloader.load("oven_load_circle.mesh", &mesh);
else mloader.load("oven_load_square.mesh", &mesh);
//mesh.refine_all_elements();
// initialize the shapeset and the cache
HcurlShapeset shapeset;
PrecalcShapeset pss(&shapeset);
// create finite element space
HcurlSpace space(&mesh, &shapeset);
space.set_bc_types(e_bc_types);
space.set_uniform_order(P_INIT);
// enumerate basis functions
space.assign_dofs();
// initialize the weak formulation
WeakForm wf(1);
wf.add_biform(0, 0, callback(bilinear_form));
wf.add_liform_surf(0, callback(linear_form_surf));
// visualize solution and mesh
VectorView eview("Electric field",0,0,800, 590);
OrderView ord("Order", 800, 0, 700, 590);
/*
// view the basis functions
VectorBaseView bview;
vbview.show(&space);
vbview.wait_for_keypress();
*/
// matrix solver
UmfpackSolver solver;
// DOF and CPU convergence graphs
SimpleGraph graph_dof_est, graph_cpu_est;
// adaptivity loop
int it = 1, ndofs;
bool done = false;
double cpu = 0.0;
Solution sln_coarse, sln_fine;
do
{
info("\n---- Adaptivity step %d ---------------------------------------------\n", it++);
// time measurement
begin_time();
// coarse problem
LinSystem sys(&wf, &solver);
sys.set_spaces(1, &space);
sys.set_pss(1, &pss);
sys.assemble();
sys.solve(1, &sln_coarse);
// time measurement
cpu += end_time();
// show real part of the solution
AbsFilter abs(&sln_coarse);
eview.set_min_max_range(0, 4e3);
eview.show(&abs);
ord.show(&space);
// time measurement
begin_time();
// solve the fine mesh problem
RefSystem ref(&sys);
ref.assemble();
ref.solve(1, &sln_fine);
// calculate error estimate wrt. fine mesh solution
HcurlOrthoHP hp(1, &space);
hp.set_biform(0, 0, callback(hcurl_form_kappa));
double err_est_adapt = hp.calc_error(&sln_coarse, &sln_fine) * 100;
double err_est_hcurl = hcurl_error(&sln_coarse, &sln_fine) * 100;
info("Error estimate (adapt): %g%%", err_est_adapt);
info("Error estimate (hcurl): %g%%", err_est_hcurl);
// add entries to DOF convergence graphs
graph_dof_est.add_values(space.get_num_dofs(), err_est_hcurl);
graph_dof_est.save("conv_dof_est.dat");
// add entries to CPU convergence graphs
graph_cpu_est.add_values(cpu, err_est_hcurl);
graph_cpu_est.save("conv_cpu_est.dat");
// if err_est_adapt too large, adapt the mesh
if (err_est_adapt < ERR_STOP) done = true;
else {
hp.adapt(THRESHOLD, STRATEGY, ADAPT_TYPE, ISO_ONLY, MESH_REGULARITY);
ndofs = space.assign_dofs();
if (ndofs >= NDOF_STOP) done = true;
}
// time measurement
cpu += end_time();
}
while (done == false);
verbose("Total running time: %g sec", cpu);
// wait for keyboard or mouse input
View::wait("Waiting for all views to be closed.");
return 0;
}
int main(int argc, char* argv[])
{
// Choose a Butcher's table or define your own.
ButcherTable bt(butcher_table_type);
if (bt.is_explicit()) info("Using a %d-stage explicit R-K method.", bt.get_size());
if (bt.is_diagonally_implicit()) info("Using a %d-stage diagonally implicit R-K method.", bt.get_size());
if (bt.is_fully_implicit()) info("Using a %d-stage fully implicit R-K method.", bt.get_size());
// Load the mesh.
Mesh mesh;
MeshReaderH2D mloader;
mloader.load("wall.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(BDY_RIGHT, 2);
mesh.refine_towards_boundary(BDY_FIRE, INIT_REF_NUM_BDY);
// Initialize essential boundary conditions (none).
EssentialBCs<double> bcs;
// Initialize an H1 space with default shapeset.
H1Space<double> space(&mesh, &bcs, P_INIT);
int ndof = Space<double>::get_num_dofs(&space);
info("ndof = %d.", ndof);
// Previous and next time level solutions.
ConstantSolution<double> sln_time_prev(&mesh, TEMP_INIT);
ZeroSolution sln_time_new(&mesh);
ConstantSolution<double> time_error_fn(&mesh, 0.0);
// Initialize the weak formulation.
double current_time = 0;
CustomWeakFormHeatRK wf(BDY_FIRE, BDY_AIR, ALPHA_FIRE, ALPHA_AIR,
RHO, HEATCAP, TEMP_EXT_AIR, TEMP_INIT, ¤t_time);
// Initialize the FE problem.
DiscreteProblem<double> dp(&wf, &space);
// Initialize views.
ScalarView Tview("Temperature", new WinGeom(0, 0, 1500, 400));
Tview.fix_scale_width(40);
ScalarView eview("Temporal error", new WinGeom(0, 450, 1500, 400));
eview.fix_scale_width(40);
// Graph for time step history.
SimpleGraph time_step_graph;
info("Time step history will be saved to file time_step_history.dat.");
// Initialize Runge-Kutta time stepping.
RungeKutta<double> runge_kutta(&dp, &bt, matrix_solver_type);
// Time stepping loop:
int ts = 1;
do
{
// Perform one Runge-Kutta time step according to the selected Butcher's table.
info("Runge-Kutta time step (t = %g s, tau = %g s, stages: %d).",
current_time, time_step, bt.get_size());
bool jacobian_changed = false;
bool verbose = true;
try
{
runge_kutta.rk_time_step_newton(current_time, time_step, &sln_time_prev, &sln_time_new,
&time_error_fn, !jacobian_changed, false, verbose);
}
catch(Exceptions::Exception& e)
{
e.printMsg();
error("Runge-Kutta time step failed");
}
// Plot error function.
char title[100];
sprintf(title, "Temporal error, t = %g", current_time);
eview.set_title(title);
AbsFilter abs_tef(&time_error_fn);
eview.show(&abs_tef, HERMES_EPS_VERYHIGH);
// Calculate relative time stepping error and decide whether the
// time step can be accepted. If not, then the time step size is
// reduced and the entire time step repeated. If yes, then another
// check is run, and if the relative error is very low, time step
// is increased.
double rel_err_time = Global<double>::calc_norm(&time_error_fn, HERMES_H1_NORM)
/ Global<double>::calc_norm(&sln_time_new, HERMES_H1_NORM) * 100;
info("rel_err_time = %g%%", rel_err_time);
if (rel_err_time > TIME_TOL_UPPER) {
info("rel_err_time above upper limit %g%% -> decreasing time step from %g to %g and restarting time step.",
TIME_TOL_UPPER, time_step, time_step * TIME_STEP_DEC_RATIO);
time_step *= TIME_STEP_DEC_RATIO;
continue;
}
if (rel_err_time < TIME_TOL_LOWER) {
info("rel_err_time = below lower limit %g%% -> increasing time step from %g to %g",
TIME_TOL_UPPER, time_step, time_step * TIME_STEP_INC_RATIO);
time_step *= TIME_STEP_INC_RATIO;
}
// Add entry to the timestep graph.
time_step_graph.add_values(current_time, time_step);
time_step_graph.save("time_step_history.dat");
// Update time.
current_time += time_step;
// Show the new time level solution.
sprintf(title, "Time %3.2f s", current_time);
Tview.set_title(title);
Tview.show(&sln_time_new);
// Copy solution for the new time step.
sln_time_prev.copy(&sln_time_new);
// Increase counter of time steps.
ts++;
}
while (current_time < T_FINAL);
// Wait for the view to be closed.
View::wait();
return 0;
}
