int main(int argc, char* argv[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh u1_mesh, u2_mesh;
MeshReaderH2D mloader;
mloader.load("bracket.mesh", &u1_mesh);
// Initial mesh refinements.
u1_mesh.refine_element_id(1);
u1_mesh.refine_element_id(4);
// Create initial mesh for the vertical displacement component.
// This also initializes the multimesh hp-FEM.
u2_mesh.copy(&u1_mesh);
// Initialize boundary conditions.
DefaultEssentialBCConst<double> zero_disp(BDY_RIGHT, 0.0);
EssentialBCs<double> bcs(&zero_disp);
// Create x- and y- displacement space using the default H1 shapeset.
H1Space<double> u1_space(&u1_mesh, &bcs, P_INIT);
H1Space<double> u2_space(&u2_mesh, &bcs, P_INIT);
info("ndof = %d.", Space<double>::get_num_dofs(Hermes::vector<Space<double> *>(&u1_space, &u2_space)));
// Initialize the weak formulation.
// NOTE; These weak forms are identical to those in example P01-linear/08-system.
CustomWeakForm wf(E, nu, rho*g1, BDY_TOP, f0, f1);
// Initialize the FE problem.
DiscreteProblem<double> dp(&wf, Hermes::vector<Space<double> *>(&u1_space, &u2_space));
// Initialize coarse and reference mesh solutions.
Solution<double> u1_sln, u2_sln, u1_ref_sln, u2_ref_sln;
// Initialize refinement selector.
H1ProjBasedSelector<double> selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
ScalarView s_view_0("Solution (x-displacement)", new WinGeom(0, 0, 400, 350));
s_view_0.show_mesh(false);
ScalarView s_view_1("Solution (y-displacement)", new WinGeom(760, 0, 400, 350));
s_view_1.show_mesh(false);
OrderView o_view_0("Mesh (x-displacement)", new WinGeom(410, 0, 340, 350));
OrderView o_view_1("Mesh (y-displacement)", new WinGeom(1170, 0, 340, 350));
ScalarView mises_view("Von Mises stress [Pa]", new WinGeom(0, 405, 400, 350));
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est;
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Hermes::vector<Space<double> *>* ref_spaces = Space<double>::construct_refined_spaces(Hermes::vector<Space<double> *>(&u1_space, &u2_space));
// Initialize matrix solver.
SparseMatrix<double>* matrix = create_matrix<double>(matrix_solver_type);
Vector<double>* rhs = create_vector<double>(matrix_solver_type);
LinearSolver<double>* solver = create_linear_solver<double>(matrix_solver_type, matrix, rhs);
// Assemble the reference problem.
info("Solving on reference mesh.");
DiscreteProblem<double> dp(&wf, *ref_spaces);
dp.assemble(matrix, rhs);
// Time measurement.
cpu_time.tick();
// Solve the linear system of the reference problem. If successful, obtain the solutions.
if(solver->solve()) Solution<double>::vector_to_solutions(solver->get_sln_vector(), *ref_spaces,
Hermes::vector<Solution *>(&u1_ref_sln, &u2_ref_sln));
else error ("Matrix solver failed.\n");
// Time measurement.
cpu_time.tick();
// Project the fine mesh solution onto the coarse mesh.
info("Projecting reference solution on coarse mesh.");
OGProjection<double>::project_global(Hermes::vector<Space<double> *>(&u1_space, &u2_space),
Hermes::vector<Solution<double> *>(&u1_ref_sln, &u2_ref_sln),
Hermes::vector<Solution<double> *>(&u1_sln, &u2_sln), matrix_solver_type);
// View the coarse mesh solution and polynomial orders.
s_view_0.show(&u1_sln);
o_view_0.show(&u1_space);
s_view_1.show(&u2_sln);
o_view_1.show(&u2_space);
// For von Mises stress Filter.
double lambda = (E * nu) / ((1 + nu) * (1 - 2*nu));
double mu = E / (2*(1 + nu));
VonMisesFilter stress(Hermes::vector<MeshFunction<double> *>(&u1_sln, &u2_sln), lambda, mu);
mises_view.show(&stress, HERMES_EPS_HIGH, H2D_FN_VAL_0, &u1_sln, &u2_sln, 1e4);
// Skip visualization time.
cpu_time.tick(HERMES_SKIP);
// Initialize adaptivity.
Adapt<double>* adaptivity = new Adapt<double>(Hermes::vector<Space<double> *>(&u1_space, &u2_space));
/*
// Register custom forms for error calculation.
adaptivity->set_error_form(0, 0, bilinear_form_0_0<double, double>, bilinear_form_0_0<Ord, Ord>);
adaptivity->set_error_form(0, 1, bilinear_form_0_1<double, double>, bilinear_form_0_1<Ord, Ord>);
adaptivity->set_error_form(1, 0, bilinear_form_1_0<double, double>, bilinear_form_1_0<Ord, Ord>);
adaptivity->set_error_form(1, 1, bilinear_form_1_1<double, double>, bilinear_form_1_1<Ord, Ord>);
*/
// Calculate error estimate for each solution component and the total error estimate.
info("Calculating error estimate and exact error.");
Hermes::vector<double> err_est_rel;
double err_est_rel_total = adaptivity->calc_err_est(Hermes::vector<Solution<double> *>(&u1_sln, &u2_sln),
Hermes::vector<Solution<double> *>(&u1_ref_sln, &u2_ref_sln), &err_est_rel) * 100;
// Time measurement.
cpu_time.tick();
// Report results.
info("ndof_coarse[0]: %d, ndof_fine[0]: %d, err_est_rel[0]: %g%%",
u1_space.Space<double>::get_num_dofs(), Space<double>::get_num_dofs((*ref_spaces)[0]), err_est_rel[0]*100);
info("ndof_coarse[1]: %d, ndof_fine[1]: %d, err_est_rel[1]: %g%%",
u2_space.Space<double>::get_num_dofs(), Space<double>::get_num_dofs((*ref_spaces)[1]), err_est_rel[1]*100);
info("ndof_coarse_total: %d, ndof_fine_total: %d, err_est_rel_total: %g%%",
Space<double>::get_num_dofs(Hermes::vector<Space<double> *>(&u1_space, &u2_space)),
Space<double>::get_num_dofs(*ref_spaces), err_est_rel_total);
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space<double>::get_num_dofs(Hermes::vector<Space<double> *>(&u1_space, &u2_space)),
err_est_rel_total);
graph_dof_est.save("conv_dof_est.dat");
graph_cpu_est.add_values(cpu_time.accumulated(), err_est_rel_total);
graph_cpu_est.save("conv_cpu_est.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP)
done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(Hermes::vector<RefinementSelectors::Selector<double> *>(&selector, &selector),
THRESHOLD, STRATEGY, MESH_REGULARITY);
}
if (Space<double>::get_num_dofs(Hermes::vector<Space<double> *>(&u1_space, &u2_space)) >= NDOF_STOP) done = true;
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false)
for(unsigned int i = 0; i < ref_spaces->size(); i++)
delete (*ref_spaces)[i]->get_mesh();
delete ref_spaces;
// Increase counter.
as++;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// Show the reference solution - the final result.
s_view_0.set_title("Fine mesh solution (x-displacement)");
s_view_0.show(&u1_ref_sln);
s_view_1.set_title("Fine mesh solution (y-displacement)");
s_view_1.show(&u2_ref_sln);
// For von Mises stress Filter.
double lambda = (E * nu) / ((1 + nu) * (1 - 2*nu));
double mu = E / (2*(1 + nu));
VonMisesFilter stress(Hermes::vector<MeshFunction<double> *>(&u1_ref_sln, &u2_ref_sln), lambda, mu);
mises_view.show(&stress, HERMES_EPS_HIGH, H2D_FN_VAL_0, &u1_ref_sln, &u2_ref_sln, 1e4);
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Time measurement.
Hermes::Mixins::TimeMeasurable cpu_time;
cpu_time.tick();
// Load the mesh.
MeshSharedPtr u_mesh(new Mesh), v_mesh(new Mesh);
MeshReaderH2D mloader;
mloader.load("domain.mesh", u_mesh);
if (MULTI == false)
u_mesh->refine_towards_boundary("Bdy", INIT_REF_BDY);
// Create initial mesh (master mesh).
v_mesh->copy(u_mesh);
// Initial mesh refinements in the v_mesh towards the boundary.
if (MULTI == true)
v_mesh->refine_towards_boundary("Bdy", INIT_REF_BDY);
// Set exact solutions.
MeshFunctionSharedPtr<double> exact_u(new ExactSolutionFitzHughNagumo1(u_mesh));
MeshFunctionSharedPtr<double> exact_v(new ExactSolutionFitzHughNagumo2(MULTI ? v_mesh : u_mesh, K));
// Define right-hand sides.
CustomRightHandSide1 g1(K, D_u, SIGMA);
CustomRightHandSide2 g2(K, D_v);
// Initialize the weak formulation.
CustomWeakForm wf(&g1, &g2);
// Initialize boundary conditions
DefaultEssentialBCConst<double> bc_u("Bdy", 0.0);
EssentialBCs<double> bcs_u(&bc_u);
DefaultEssentialBCConst<double> bc_v("Bdy", 0.0);
EssentialBCs<double> bcs_v(&bc_v);
// Create H1 spaces with default shapeset for both displacement components.
SpaceSharedPtr<double> u_space(new H1Space<double>(u_mesh, &bcs_u, P_INIT_U));
SpaceSharedPtr<double> v_space(new H1Space<double>(MULTI ? v_mesh : u_mesh, &bcs_v, P_INIT_V));
// Initialize coarse and reference mesh solutions.
MeshFunctionSharedPtr<double> u_sln(new Solution<double>()), v_sln(new Solution<double>()), u_ref_sln(new Solution<double>()), v_ref_sln(new Solution<double>());
Hermes::vector<MeshFunctionSharedPtr<double> > slns(u_sln, v_sln);
Hermes::vector<MeshFunctionSharedPtr<double> > ref_slns(u_ref_sln, v_ref_sln);
Hermes::vector<MeshFunctionSharedPtr<double> > exact_slns(exact_u, exact_v);
// Initialize refinement selector.
H1ProjBasedSelector<double> selector(CAND_LIST);
//HOnlySelector<double> selector;
// Initialize views.
Views::ScalarView s_view_0("Solution[0]", new Views::WinGeom(0, 0, 440, 350));
s_view_0.show_mesh(false);
Views::OrderView o_view_0("Mesh[0]", new Views::WinGeom(450, 0, 420, 350));
Views::ScalarView s_view_1("Solution[1]", new Views::WinGeom(880, 0, 440, 350));
s_view_1.show_mesh(false);
Views::OrderView o_view_1("Mesh[1]", new Views::WinGeom(1330, 0, 420, 350));
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est;
SimpleGraph graph_dof_exact, graph_cpu_exact;
NewtonSolver<double> newton;
newton.set_weak_formulation(&wf);
// 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 u_ref_mesh_creator(u_mesh);
MeshSharedPtr u_ref_mesh = u_ref_mesh_creator.create_ref_mesh();
Mesh::ReferenceMeshCreator v_ref_mesh_creator(v_mesh);
MeshSharedPtr v_ref_mesh = v_ref_mesh_creator.create_ref_mesh();
Space<double>::ReferenceSpaceCreator u_ref_space_creator(u_space, u_ref_mesh);
SpaceSharedPtr<double> u_ref_space = u_ref_space_creator.create_ref_space();
Space<double>::ReferenceSpaceCreator v_ref_space_creator(v_space, MULTI ? v_ref_mesh : u_ref_mesh);
SpaceSharedPtr<double> v_ref_space = v_ref_space_creator.create_ref_space();
Hermes::vector<SpaceSharedPtr<double> > ref_spaces_const(u_ref_space, v_ref_space);
newton.set_spaces(ref_spaces_const);
int ndof_ref = Space<double>::get_num_dofs(ref_spaces_const);
// Initialize reference problem.
Hermes::Mixins::Loggable::Static::info("Solving on reference mesh.");
// Time measurement.
cpu_time.tick();
// Perform Newton's iteration.
try
{
newton.solve();
}
catch (Hermes::Exceptions::Exception& e)
{
std::cout << e.info();
}
catch (std::exception& e)
{
std::cout << e.what();
}
// Translate the resulting coefficient vector into the instance of Solution.
Solution<double>::vector_to_solutions(newton.get_sln_vector(), ref_spaces_const, Hermes::vector<MeshFunctionSharedPtr<double> >(u_ref_sln, v_ref_sln));
// Project the fine mesh solution onto the coarse mesh.
Hermes::Mixins::Loggable::Static::info("Projecting reference solution on coarse mesh.");
OGProjection<double> ogProjection; ogProjection.project_global(Hermes::vector<SpaceSharedPtr<double> >(u_space, v_space), ref_slns, slns);
cpu_time.tick();
// View the coarse mesh solution and polynomial orders.
s_view_0.show(u_sln);
o_view_0.show(u_space);
s_view_1.show(v_sln);
o_view_1.show(v_space);
// Calculate element errors.
Hermes::Mixins::Loggable::Static::info("Calculating error estimate and exact error.");
errorCalculator.calculate_errors(slns, exact_slns, false);
double err_exact_rel_total = errorCalculator.get_total_error_squared() * 100;
Hermes::vector<double> err_exact_rel;
err_exact_rel.push_back(errorCalculator.get_error_squared(0) * 100);
err_exact_rel.push_back(errorCalculator.get_error_squared(1) * 100);
errorCalculator.calculate_errors(slns, ref_slns, true);
double err_est_rel_total = errorCalculator.get_total_error_squared() * 100;
Hermes::vector<double> err_est_rel;
err_est_rel.push_back(errorCalculator.get_error_squared(0) * 100);
err_est_rel.push_back(errorCalculator.get_error_squared(1) * 100);
adaptivity.set_spaces(Hermes::vector<SpaceSharedPtr<double> >(u_space, v_space));
// Time measurement.
cpu_time.tick();
// Report results.
Hermes::Mixins::Loggable::Static::info("ndof_coarse[0]: %d, ndof_fine[0]: %d",
u_space->get_num_dofs(), u_ref_space->get_num_dofs());
Hermes::Mixins::Loggable::Static::info("err_est_rel[0]: %g%%, err_exact_rel[0]: %g%%", err_est_rel[0], err_exact_rel[0]);
Hermes::Mixins::Loggable::Static::info("ndof_coarse[1]: %d, ndof_fine[1]: %d",
v_space->get_num_dofs(), v_ref_space->get_num_dofs());
Hermes::Mixins::Loggable::Static::info("err_est_rel[1]: %g%%, err_exact_rel[1]: %g%%", err_est_rel[1], err_exact_rel[1]);
Hermes::Mixins::Loggable::Static::info("ndof_coarse_total: %d, ndof_fine_total: %d",
Space<double>::get_num_dofs(Hermes::vector<SpaceSharedPtr<double> >(u_space, v_space)),
Space<double>::get_num_dofs(ref_spaces_const));
Hermes::Mixins::Loggable::Static::info("err_est_rel_total: %g%%, err_est_exact_total: %g%%", err_est_rel_total, err_exact_rel_total);
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space<double>::get_num_dofs(Hermes::vector<SpaceSharedPtr<double> >(u_space, v_space)),
err_est_rel_total);
graph_dof_est.save("conv_dof_est.dat");
graph_cpu_est.add_values(cpu_time.accumulated(), err_est_rel_total);
graph_cpu_est.save("conv_cpu_est.dat");
graph_dof_exact.add_values(Space<double>::get_num_dofs(Hermes::vector<SpaceSharedPtr<double> >(u_space, v_space)),
err_exact_rel_total);
graph_dof_exact.save("conv_dof_exact.dat");
graph_cpu_exact.add_values(cpu_time.accumulated(), err_exact_rel_total);
graph_cpu_exact.save("conv_cpu_exact.dat");
// If err_est too large, adapt the mesh->
if (err_est_rel_total < ERR_STOP)
done = true;
else
{
Hermes::Mixins::Loggable::Static::info("Adapting coarse mesh.");
Hermes::vector<RefinementSelectors::Selector<double> *> selectors(&selector, &selector);
done = adaptivity.adapt(selectors);
}
// Increase counter.
as++;
} while (done == false);
Hermes::Mixins::Loggable::Static::info("Total running time: %g s", cpu_time.accumulated());
// Wait for all views to be closed.
Views::View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh xmesh, ymesh, tmesh;
MeshReaderH2D mloader;
mloader.load("domain.mesh", &xmesh); // Master mesh.
// Initialize multimesh hp-FEM.
ymesh.copy(&xmesh); // Ydisp will share master mesh with xdisp.
tmesh.copy(&xmesh); // Temp will share master mesh with xdisp.
// Initialize boundary conditions.
BCTypes bc_types_x_y;
bc_types_x_y.add_bc_dirichlet(BDY_BOTTOM);
bc_types_x_y.add_bc_neumann(Hermes::vector<int>(BDY_SIDES, BDY_TOP, BDY_HOLES));
BCTypes bc_types_t;
bc_types_t.add_bc_dirichlet(BDY_HOLES);
bc_types_t.add_bc_neumann(Hermes::vector<int>(BDY_SIDES, BDY_TOP, BDY_BOTTOM));
// Enter Dirichlet boundary values.
BCValues bc_values_x_y;
bc_values_x_y.add_zero(BDY_BOTTOM);
BCValues bc_values_t;
bc_values_t.add_const(BDY_HOLES, TEMP_INNER);
// Create H1 spaces with default shapesets.
H1Space<double> xdisp(&xmesh, &bc_types_x_y, &bc_values_x_y, P_INIT_DISP);
H1Space<double> ydisp(MULTI ? &ymesh : &xmesh, &bc_types_x_y, &bc_values_x_y, P_INIT_DISP);
H1Space<double> temp(MULTI ? &tmesh : &xmesh, &bc_types_t, &bc_values_t, P_INIT_TEMP);
// Initialize the weak formulation.
WeakForm wf(3);
wf.add_matrix_form(0, 0, callback(bilinear_form_0_0));
wf.add_matrix_form(0, 1, callback(bilinear_form_0_1), HERMES_SYM);
wf.add_matrix_form(0, 2, callback(bilinear_form_0_2));
wf.add_matrix_form(1, 1, callback(bilinear_form_1_1));
wf.add_matrix_form(1, 2, callback(bilinear_form_1_2));
wf.add_matrix_form(2, 2, callback(bilinear_form_2_2));
wf.add_vector_form(1, callback(linear_form_1));
wf.add_vector_form(2, callback(linear_form_2));
wf.add_vector_form_surf(2, callback(linear_form_surf_2));
// Initialize coarse and reference mesh solutions.
Solution<double> xdisp_sln, ydisp_sln, temp_sln, ref_xdisp_sln, ref_ydisp_sln, ref_temp_sln;
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
ScalarView s_view_0("Solution[xdisp]", new WinGeom(0, 0, 450, 350));
s_view_0.show_mesh(false);
ScalarView s_view_1("Solution[ydisp]", new WinGeom(460, 0, 450, 350));
s_view_1.show_mesh(false);
ScalarView s_view_2("Solution[temp]", new WinGeom(920, 0, 450, 350));
s_view_1.show_mesh(false);
OrderView o_view_0("Mesh[xdisp]", new WinGeom(0, 360, 450, 350));
OrderView o_view_1("Mesh[ydisp]", new WinGeom(460, 360, 450, 350));
OrderView o_view_2("Mesh[temp]", new WinGeom(920, 360, 450, 350));
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est;
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Hermes::vector<Space<double> *>* ref_spaces = Space<double>::construct_refined_spaces(Hermes::vector<Space<double> *>(&xdisp, &ydisp, &temp));
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, *ref_spaces, is_linear);
SparseMatrix<double>* matrix = create_matrix<double>(matrix_solver_type);
Vector<double>* rhs = create_vector<double>(matrix_solver_type);
LinearSolver<double>* solver = create_linear_solver<double>(matrix_solver_type, matrix, rhs);
dp->assemble(matrix, rhs);
// Time measurement.
cpu_time.tick();
// Solve the linear system of the reference problem. If successful, obtain the solutions.
if(solver->solve()) Solution::vector_to_solutions(solver->get_solution(), *ref_spaces,
Hermes::vector<Solution *>(&ref_xdisp_sln, &ref_ydisp_sln, &ref_temp_sln));
else error ("Matrix solver failed.\n");
// Time measurement.
cpu_time.tick();
// Project the fine mesh solution onto the coarse mesh.
info("Projecting reference solution on coarse mesh.");
OGProjection::project_global(Hermes::vector<Space<double> *>(&xdisp, &ydisp, &temp), Hermes::vector<Solution *>(&ref_xdisp_sln, &ref_ydisp_sln, &ref_temp_sln),
Hermes::vector<Solution *>(&xdisp_sln, &ydisp_sln, &temp_sln), matrix_solver_type);
// View the coarse mesh solution and polynomial orders.
s_view_0.show(&xdisp_sln);
o_view_0.show(&xdisp);
s_view_1.show(&ydisp_sln);
o_view_1.show(&ydisp);
s_view_2.show(&temp_sln);
o_view_2.show(&temp);
// Skip visualization time.
cpu_time.tick(HERMES_SKIP);
// Calculate element errors.
info("Calculating error estimate and exact error.");
Adapt* adaptivity = new Adapt(Hermes::vector<Space<double> *>(&xdisp, &ydisp, &temp));
adaptivity->set_error_form(0, 0, bilinear_form_0_0<double, double>, bilinear_form_0_0<Ord, Ord>);
adaptivity->set_error_form(0, 1, bilinear_form_0_1<double, double>, bilinear_form_0_1<Ord, Ord>);
adaptivity->set_error_form(0, 2, bilinear_form_0_2<double, double>, bilinear_form_0_2<Ord, Ord>);
adaptivity->set_error_form(1, 0, bilinear_form_1_0<double, double>, bilinear_form_1_0<Ord, Ord>);
adaptivity->set_error_form(1, 1, bilinear_form_1_1<double, double>, bilinear_form_1_1<Ord, Ord>);
adaptivity->set_error_form(1, 2, bilinear_form_1_2<double, double>, bilinear_form_1_2<Ord, Ord>);
adaptivity->set_error_form(2, 2, bilinear_form_2_2<double, double>, bilinear_form_2_2<Ord, Ord>);
// Calculate error estimate for each solution component and the total error estimate.
Hermes::vector<double> err_est_rel;
double err_est_rel_total = adaptivity->calc_err_est(Hermes::vector<Solution *>(&xdisp_sln, &ydisp_sln, &temp_sln),
Hermes::vector<Solution *>(&ref_xdisp_sln, &ref_ydisp_sln, &ref_temp_sln), &err_est_rel) * 100;
// Time measurement.
cpu_time.tick();
// Report results.
info("ndof_coarse[xdisp]: %d, ndof_fine[xdisp]: %d, err_est_rel[xdisp]: %g%%",
xdisp.Space<double>::get_num_dofs(), Space<double>::get_num_dofs((*ref_spaces)[0]), err_est_rel[0]*100);
info("ndof_coarse[ydisp]: %d, ndof_fine[ydisp]: %d, err_est_rel[ydisp]: %g%%",
ydisp.Space<double>::get_num_dofs(), Space<double>::get_num_dofs((*ref_spaces)[1]), err_est_rel[1]*100);
info("ndof_coarse[temp]: %d, ndof_fine[temp]: %d, err_est_rel[temp]: %g%%",
temp.Space<double>::get_num_dofs(), Space<double>::get_num_dofs((*ref_spaces)[2]), err_est_rel[2]*100);
info("ndof_coarse_total: %d, ndof_fine_total: %d, err_est_rel_total: %g%%",
Space<double>::get_num_dofs(Hermes::vector<Space<double> *>(&xdisp, &ydisp, &temp)), Space<double>::get_num_dofs(*ref_spaces), err_est_rel_total);
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space<double>::get_num_dofs(Hermes::vector<Space<double> *>(&xdisp, &ydisp, &temp)), err_est_rel_total);
graph_dof_est.save("conv_dof_est.dat");
graph_cpu_est.add_values(cpu_time.accumulated(), err_est_rel_total);
graph_cpu_est.save("conv_cpu_est.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP)
done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(Hermes::vector<RefinementSelectors::Selector *>(&selector, &selector, &selector),
THRESHOLD, STRATEGY, MESH_REGULARITY);
}
if (Space<double>::get_num_dofs(Hermes::vector<Space<double> *>(&xdisp, &ydisp, &temp)) >= NDOF_STOP) done = true;
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false)
for(unsigned int i = 0; i < ref_spaces->size(); i++)
delete (*ref_spaces)[i]->get_mesh();
delete ref_spaces;
delete dp;
// Increase counter.
as++;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// Show the reference solution - the final result.
s_view_0.set_title("Fine mesh Solution[xdisp]");
s_view_0.show(&ref_xdisp_sln);
s_view_1.set_title("Fine mesh Solution[ydisp]");
s_view_1.show(&ref_ydisp_sln);
s_view_1.set_title("Fine mesh Solution[temp]");
s_view_1.show(&ref_temp_sln);
// Wait for all views to be closed.
View::wait();
return 0;
};
int main(int argc, char* argv[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh u_mesh, v_mesh;
MeshReaderH2D mloader;
mloader.load("domain.mesh", &u_mesh);
if (MULTI == false) u_mesh.refine_towards_boundary("Bdy", INIT_REF_BDY);
// Create initial mesh (master mesh).
v_mesh.copy(&u_mesh);
// Initial mesh refinements in the v_mesh towards the boundary.
if (MULTI == true) v_mesh.refine_towards_boundary("Bdy", INIT_REF_BDY);
// Set exact solutions.
ExactSolutionFitzHughNagumo1 exact_u(&u_mesh);
ExactSolutionFitzHughNagumo2 exact_v(&v_mesh, K);
// Define right-hand sides.
CustomRightHandSide1 g1(K, D_u, SIGMA);
CustomRightHandSide2 g2(K, D_v);
// Initialize the weak formulation.
CustomWeakForm wf(&g1, &g2);
// Initialize boundary conditions
DefaultEssentialBCConst<double> bc_u("Bdy", 0.0);
EssentialBCs<double> bcs_u(&bc_u);
DefaultEssentialBCConst<double> bc_v("Bdy", 0.0);
EssentialBCs<double> bcs_v(&bc_v);
// Create H1 spaces with default shapeset for both displacement components.
H1Space<double> u_space(&u_mesh, &bcs_u, P_INIT_U);
H1Space<double> v_space(MULTI ? &v_mesh : &u_mesh, &bcs_v, P_INIT_V);
// Initialize coarse and reference mesh solutions.
Solution<double> u_sln, v_sln, u_ref_sln, v_ref_sln;
// Initialize refinement selector.
H1ProjBasedSelector<double> selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
Views::ScalarView s_view_0("Solution[0]", new Views::WinGeom(0, 0, 440, 350));
s_view_0.show_mesh(false);
Views::OrderView o_view_0("Mesh[0]", new Views::WinGeom(450, 0, 420, 350));
Views::ScalarView s_view_1("Solution[1]", new Views::WinGeom(880, 0, 440, 350));
s_view_1.show_mesh(false);
Views::OrderView o_view_1("Mesh[1]", new Views::WinGeom(1330, 0, 420, 350));
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est;
SimpleGraph graph_dof_exact, graph_cpu_exact;
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Hermes::vector<Space<double> *>* ref_spaces =
Space<double>::construct_refined_spaces(Hermes::vector<Space<double> *>(&u_space, &v_space));
Space<double>* u_ref_space = (*ref_spaces)[0];
Space<double>* v_ref_space = (*ref_spaces)[1];
Hermes::vector<const Space<double> *> ref_spaces_const((*ref_spaces)[0], (*ref_spaces)[1]);
int ndof_ref = Space<double>::get_num_dofs(ref_spaces_const);
// Initialize reference problem.
info("Solving on reference mesh.");
DiscreteProblem<double> dp(&wf, ref_spaces_const);
NewtonSolver<double> newton(&dp, matrix_solver);
//newton.set_verbose_output(false);
// Time measurement.
cpu_time.tick();
// Perform Newton's iteration.
try
{
newton.solve();
}
catch(Hermes::Exceptions::Exception e)
{
e.printMsg();
error("Newton's iteration failed.");
}
// Translate the resulting coefficient vector into the instance of Solution.
Solution<double>::vector_to_solutions(newton.get_sln_vector(), ref_spaces_const,
Hermes::vector<Solution<double> *>(&u_ref_sln, &v_ref_sln));
// Project the fine mesh solution onto the coarse mesh.
info("Projecting reference solution on coarse mesh.");
OGProjection<double>::project_global(Hermes::vector<const Space<double> *>(&u_space, &v_space),
Hermes::vector<Solution<double> *>(&u_ref_sln, &v_ref_sln),
Hermes::vector<Solution<double> *>(&u_sln, &v_sln), matrix_solver);
cpu_time.tick();
// View the coarse mesh solution and polynomial orders.
s_view_0.show(&u_sln);
o_view_0.show(&u_space);
s_view_1.show(&v_sln);
o_view_1.show(&v_space);
// Calculate element errors.
info("Calculating error estimate and exact error.");
Adapt<double>* adaptivity = new Adapt<double>(Hermes::vector<Space<double> *>(&u_space, &v_space));
// Calculate error estimate for each solution component and the total error estimate.
Hermes::vector<double> err_est_rel;
double err_est_rel_total = adaptivity->calc_err_est(Hermes::vector<Solution<double> *>(&u_sln, &v_sln),
Hermes::vector<Solution<double> *>(&u_ref_sln, &v_ref_sln),
&err_est_rel) * 100;
// Calculate exact error for each solution component and the total exact error.
Hermes::vector<double> err_exact_rel;
bool solutions_for_adapt = false;
double err_exact_rel_total = adaptivity->calc_err_exact(Hermes::vector<Solution<double> *>(&u_sln, &v_sln),
Hermes::vector<Solution<double> *>(&exact_u, &exact_v),
&err_exact_rel, solutions_for_adapt) * 100;
// Time measurement.
cpu_time.tick();
// Report results.
info("ndof_coarse[0]: %d, ndof_fine[0]: %d",
u_space.get_num_dofs(), u_ref_space->get_num_dofs());
info("err_est_rel[0]: %g%%, err_exact_rel[0]: %g%%", err_est_rel[0]*100, err_exact_rel[0]*100);
info("ndof_coarse[1]: %d, ndof_fine[1]: %d",
v_space.get_num_dofs(), v_ref_space->get_num_dofs());
info("err_est_rel[1]: %g%%, err_exact_rel[1]: %g%%", err_est_rel[1]*100, err_exact_rel[1]*100);
info("ndof_coarse_total: %d, ndof_fine_total: %d",
Space<double>::get_num_dofs(Hermes::vector<const Space<double> *>(&u_space, &v_space)),
Space<double>::get_num_dofs(ref_spaces_const));
info("err_est_rel_total: %g%%, err_est_exact_total: %g%%", err_est_rel_total, err_exact_rel_total);
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space<double>::get_num_dofs(Hermes::vector<const Space<double> *>(&u_space, &v_space)),
err_est_rel_total);
graph_dof_est.save("conv_dof_est.dat");
graph_cpu_est.add_values(cpu_time.accumulated(), err_est_rel_total);
graph_cpu_est.save("conv_cpu_est.dat");
graph_dof_exact.add_values(Space<double>::get_num_dofs(Hermes::vector<const Space<double> *>(&u_space, &v_space)),
err_exact_rel_total);
graph_dof_exact.save("conv_dof_exact.dat");
graph_cpu_exact.add_values(cpu_time.accumulated(), err_exact_rel_total);
graph_cpu_exact.save("conv_cpu_exact.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP)
done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(Hermes::vector<RefinementSelectors::Selector<double> *>(&selector, &selector),
THRESHOLD, STRATEGY, MESH_REGULARITY);
}
if (Space<double>::get_num_dofs(Hermes::vector<const Space<double> *>(&u_space, &v_space)) >= NDOF_STOP) done = true;
// Clean up.
delete adaptivity;
for(unsigned int i = 0; i < ref_spaces->size(); i++)
delete (*ref_spaces)[i]->get_mesh();
delete ref_spaces;
// Increase counter.
as++;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// Wait for all views to be closed.
Views::View::wait();
return 0;
}
