int main(int argc, char* argv[])
{
// load the mesh
Mesh mesh;
H2DReader mloader;
mloader.load("screen-quad.mesh", &mesh);
// mloader.load("screen-tri.mesh", &mesh);
// initialize the shapeset and the cache
HcurlShapeset shapeset;
PrecalcShapeset pss(&shapeset);
// create finite element space
HcurlSpace space(&mesh, &shapeset);
space.set_bc_types(bc_types);
space.set_bc_values(bc_values);
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), SYM);
// visualize solution and mesh
ScalarView Xview_r("Electric field X - real", 0, 0, 450, 420);
ScalarView Yview_r("Electric field Y - real", 460, 0, 450, 420);
ScalarView Xview_i("Electric field X - imag", 920, 0, 450, 420);
ScalarView Yview_i("Electric field Y - imag", 1380, 0, 450, 420);
OrderView ord("Polynomial Orders", 0, 460, 450, 420);
/*
// 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_dof_exact, graph_cpu_est, graph_cpu_exact;
// 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();
// solve the coarse mesh 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();
// calculating error wrt. exact solution
Solution ex;
ex.set_exact(&mesh, exact);
double err_exact = 100 * hcurl_error(&sln_coarse, &ex);
info("Exact solution error: %g%%", err_exact);
// visualization
RealFilter real(&sln_coarse);
ImagFilter imag(&sln_coarse);
Xview_r.set_min_max_range(-3.0, 1.0);
//Xview_r.show_scale(false);
Xview_r.show(&real, EPS_NORMAL, FN_VAL_0);
Yview_r.set_min_max_range(-4.0, 4.0);
//Yview_r.show_scale(false);
Yview_r.show(&real, EPS_NORMAL, FN_VAL_1);
Xview_i.set_min_max_range(-1.0, 4.0);
//Xview_i.show_scale(false);
Xview_i.show(&imag, EPS_NORMAL, FN_VAL_0);
Yview_i.set_min_max_range(-4.0, 4.0);
//Yview_i.show_scale(false);
Yview_i.show(&imag, EPS_NORMAL, FN_VAL_1);
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);
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_exact.add_values(space.get_num_dofs(), err_exact);
graph_dof_exact.save("conv_dof_exact.dat");
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_exact.add_values(cpu, err_exact);
graph_cpu_exact.save("conv_cpu_exact.dat");
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);
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) {
int res = ERR_SUCCESS;
#ifdef WITH_PETSC
PetscInitialize(&argc, &argv, (char *) PETSC_NULL, PETSC_NULL);
#endif
set_verbose(false);
if (argc < 3) error("Not enough parameters");
HcurlShapesetLobattoHex shapeset;
printf("* Loading mesh '%s'\n", argv[1]);
Mesh mesh;
Mesh3DReader mesh_loader;
if (!mesh_loader.load(argv[1], &mesh)) error("Loading mesh file '%s'\n", argv[1]);
printf("* Setting the space up\n");
HcurlSpace space(&mesh, &shapeset);
space.set_bc_types(bc_types);
int order;
sscanf(argv[2], "%d", &order);
int dir_x = order, dir_y = order, dir_z = order;
order3_t o(dir_x, dir_y, dir_z);
printf(" - Setting uniform order to (%d, %d, %d)\n", o.x, o.y ,o.z);
space.set_uniform_order(o);
int ndofs = space.assign_dofs();
printf(" - Number of DOFs: %d\n", ndofs);
printf("* Calculating a solution\n");
#if defined WITH_UMFPACK
UMFPackMatrix mat;
UMFPackVector rhs;
UMFPackLinearSolver solver(&mat, &rhs);
#elif defined WITH_PARDISO
PardisoMatrix mat;
PardisoVector rhs;
PardisoSolver solver(&mat, &rhs);
#elif defined WITH_PETSC
PetscMatrix mat;
PetscVector rhs;
PetscLinearSolver solver(&mat, &rhs);
#elif defined WITH_MUMPS
MumpsMatrix mat;
MumpsVector rhs;
MumpsSolver solver(&mat, &rhs);
#endif
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<ord_t, ord_t>, SYM);
wf.add_matrix_form_surf(bilinear_form_surf<double, scalar>, bilinear_form_surf<ord_t, ord_t>);
wf.add_vector_form(linear_form<double, scalar>, linear_form<ord_t, ord_t>);
wf.add_vector_form_surf(linear_form_surf<double, scalar>, linear_form_surf<ord_t, ord_t>);
LinearProblem lp(&wf, &space);
// assemble stiffness matrix
Timer assemble_timer("Assembling stiffness matrix");
assemble_timer.start();
lp.assemble(&mat, &rhs);
assemble_timer.stop();
// solve the stiffness matrix
Timer solve_timer("Solving stiffness matrix");
solve_timer.start();
bool solved = solver.solve();
solve_timer.stop();
//#ifdef OUTPUT_DIR
mat.dump(stdout, "a");
rhs.dump(stdout, "b");
//#endif
if (solved) {
scalar *s = solver.get_solution();
Solution sln(&mesh);
sln.set_coeff_vector(&space, s);
printf("* Solution:\n");
for (int i = 1; i <= ndofs; i++) {
printf(" x[% 3d] = " SCALAR_FMT "\n", i, SCALAR(s[i]));
}
// output the measured values
printf("%s: %s (%lf secs)\n", assemble_timer.get_name(), assemble_timer.get_human_time(), assemble_timer.get_seconds());
printf("%s: %s (%lf secs)\n", solve_timer.get_name(), solve_timer.get_human_time(), solve_timer.get_seconds());
// norm
ExactSolution ex_sln(&mesh, exact_solution);
double hcurl_sln_norm = hcurl_norm(&sln);
double hcurl_err_norm = hcurl_error(&sln, &ex_sln);
printf(" - Hcurl solution norm: % le\n", hcurl_sln_norm);
printf(" - Hcurl error norm: % le\n", hcurl_err_norm);
double l2_sln_norm = l2_norm_hcurl(&sln);
double l2_err_norm = l2_error_hcurl(&sln, &ex_sln);
printf(" - L2 solution norm: % le\n", l2_sln_norm);
printf(" - L2 error norm: % le\n", l2_err_norm);
if (hcurl_err_norm > EPS || l2_err_norm > EPS) {
// calculated solution is not enough precise
res = ERR_FAILURE;
}
#if 0 //def OUTPUT_DIR
// output
printf("starting output\n");
const char *of_name = OUTPUT_DIR "/solution.vtk";
FILE *ofile = fopen(of_name, "w");
if (ofile != NULL) {
ExactSolution ex_sln(&mesh, exact_solution_0, exact_solution_1, exact_solution_2);
RealPartFilter real_sln(&mesh, &sln, FN_VAL);
ImagPartFilter imag_sln(&mesh, &sln, FN_VAL);
DiffFilter eh(&mesh, &sln, &ex_sln);
DiffFilter eh_dx(&mesh, &sln, &ex_sln, FN_DX, FN_DX);
// DiffFilter eh_dy(&mesh, &sln, &ex_sln, FN_DY, FN_DY);
// DiffFilter eh_dz(&mesh, &sln, &ex_sln, FN_DZ, FN_DZ);
// GmshOutputEngine output(ofile);
VtkOutputEngine output(ofile);
output.out(&real_sln, "real_Uh", FN_VAL);
output.out(&imag_sln, "imag_Uh", FN_VAL);
output.out(&real_sln, "real_Uh_0", FN_VAL_0);
output.out(&real_sln, "real_Uh_1", FN_VAL_1);
output.out(&real_sln, "real_Uh_2", FN_VAL_2);
output.out(&imag_sln, "imag_Uh_0", FN_VAL_0);
output.out(&imag_sln, "imag_Uh_1", FN_VAL_1);
output.out(&imag_sln, "imag_Uh_2", FN_VAL_2);
fclose(ofile);
}
else {
warning("Can not open '%s' for writing.", of_name);
}
#endif
}
#ifdef WITH_PETSC
mat.free();
rhs.free();
PetscFinalize();
#endif
return res;
}
int main(int argc, char* argv[])
{
// load the mesh
Mesh mesh;
H2DReader mloader;
mloader.load("lshape3q.mesh", &mesh);
// mloader.load("lshape3t.mesh", &mesh);
// initialize the shapeset and the cache
HcurlShapeset shapeset;
PrecalcShapeset pss(&shapeset);
// create finite element space
HcurlSpace space(&mesh, &shapeset);
space.set_bc_types(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), SYM);
wf.add_biform_surf(0, 0, callback(bilinear_form_surf));
wf.add_liform_surf(0, linear_form_surf, linear_form_surf_ord);
// matrix solver
UmfpackSolver solver;
// convergence graph wrt. the number of degrees of freedom
GnuplotGraph graph;
graph.set_captions("Error Convergence for the Bessel Problem in H(curl)", "Degrees of Freedom", "Error [%]");
graph.add_row("exact error", "k", "-", "o");
graph.add_row("error estimate", "k", "--");
graph.set_log_y();
// convergence graph wrt. CPU time
GnuplotGraph graph_cpu;
graph_cpu.set_captions("Error Convergence for the Bessel Problem in H(curl)", "CPU Time", "Error [%]");
graph_cpu.add_row("exact error", "k", "-", "o");
graph_cpu.add_row("error estimate", "k", "--");
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();
// solve the coarse mesh 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();
// calculating error wrt. exact solution
ExactSolution ex(&mesh, exact);
double err = 100 * hcurl_error(&sln_coarse, &ex);
info("Exact solution error: %g%%", err);
// time measurement
begin_time();
// solve the fine mesh problem
RefSystem rs(&sys);
rs.assemble();
rs.solve(1, &sln_fine);
// calculate error estimate wrt. fine mesh solution
HcurlOrthoHP hp(1, &space);
double err_est = hp.calc_error(&sln_coarse, &sln_fine) * 100;
info("Error estimate: %g%%", err_est);
// add entry to DOF convergence graph
graph.add_values(0, space.get_num_dofs(), err);
graph.add_values(1, space.get_num_dofs(), err_est);
graph.save("conv_dof.gp");
// add entry to CPU convergence graph
graph_cpu.add_values(0, cpu, err);
graph_cpu.add_values(1, 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);
verbose("Total running time: %g sec", cpu);
#define ERROR_SUCCESS 0
#define ERROR_FAILURE -1
int n_dof_allowed = 3000;
printf("n_dof_actual = %d\n", ndofs);
printf("n_dof_allowed = %d\n", n_dof_allowed);// ndofs was 2680 at the time this test was created
if (ndofs <= n_dof_allowed) {
printf("Success!\n");
return ERROR_SUCCESS;
}
else {
printf("Failure!\n");
return ERROR_FAILURE;
}
}
int main(int argc, char* argv[])
{
// load the mesh
Mesh mesh;
mesh.load("screen-quad.mesh");
// mesh.load("screen-tri.mesh");
// initialize the shapeset and the cache
HcurlShapeset shapeset;
PrecalcShapeset pss(&shapeset);
// create finite element space
HcurlSpace space(&mesh, &shapeset);
space.set_bc_types(bc_types);
space.set_bc_values(bc_values);
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), SYM);
// visualize solution and mesh
ScalarView Xview_r("Electric field X - real", 0, 0, 320, 320);
ScalarView Yview_r("Electric field Y - real", 325, 0, 320, 320);
ScalarView Xview_i("Electric field X - imag", 650, 0, 320, 320);
ScalarView Yview_i("Electric field Y - imag", 975, 0, 320, 320);
OrderView ord("Polynomial Orders", 325, 400, 600, 600);
// matrix solver
UmfpackSolver solver;
// convergence graph wrt. the number of degrees of freedom
GnuplotGraph graph;
graph.set_captions("Error Convergence for the Screen Problem in H(curl)", "Degrees of Freedom", "Error [%]");
graph.add_row("exact error", "k", "-", "o");
graph.add_row("error estimate", "k", "--");
graph.set_log_y();
// convergence graph wrt. CPU time
GnuplotGraph graph_cpu;
graph_cpu.set_captions("Error Convergence for the Screen Problem in H(curl)", "CPU Time", "Error [%]");
graph_cpu.add_row("exact error", "k", "-", "o");
graph_cpu.add_row("error estimate", "k", "--");
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();
// solve the coarse mesh 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();
// calculating error wrt. exact solution
Solution ex;
ex.set_exact(&mesh, exact);
double error = 100 * hcurl_error(&sln_coarse, &ex);
info("Exact solution error: %g%%", error);
// visualization
RealFilter real(&sln_coarse);
ImagFilter imag(&sln_coarse);
Xview_r.set_min_max_range(-3.0, 1.0);
Xview_r.show_scale(false);
Xview_r.show(&real, EPS_NORMAL, FN_VAL_0);
Yview_r.set_min_max_range(-4.0, 4.0);
Yview_r.show_scale(false);
Yview_r.show(&real, EPS_NORMAL, FN_VAL_1);
Xview_i.set_min_max_range(-1.0, 4.0);
Xview_i.show_scale(false);
Xview_i.show(&imag, EPS_NORMAL, FN_VAL_0);
Yview_i.set_min_max_range(-4.0, 4.0);
Yview_i.show_scale(false);
Yview_i.show(&imag, EPS_NORMAL, FN_VAL_1);
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);
double err_est = hp.calc_error(&sln_coarse, &sln_fine) * 100;
info("Error estimate: %g%%", err_est);
// add entry to DOF convergence graph
graph.add_values(0, space.get_num_dofs(), error);
graph.add_values(1, space.get_num_dofs(), err_est);
graph.save("conv_dof.gp");
// add entry to CPU convergence graph
graph_cpu.add_values(0, cpu, error);
graph_cpu.add_values(1, 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);
verbose("Total running time: %g sec", cpu);
// wait for keyboard or mouse input
View::wait("Waiting for keyboard or mouse input.");
return 0;
}
int main(int argc, char* argv[])
{
// load the mesh
Mesh mesh;
H2DReader mloader;
mloader.load("lshape3q.mesh", &mesh);
// mloader.load("lshape3t.mesh", &mesh);
// initialize the shapeset and the cache
HcurlShapeset shapeset;
PrecalcShapeset pss(&shapeset);
// create finite element space
HcurlSpace space(&mesh, &shapeset);
space.set_bc_types(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), SYM);
wf.add_biform_surf(0, 0, callback(bilinear_form_surf));
wf.add_liform_surf(0, linear_form_surf, linear_form_surf_ord);
// visualize solution and mesh
OrderView ordview("Polynomial Orders", 600, 0, 600, 500);
VectorView vecview("Real part of Electric Field - VectorView", 0, 0, 600, 500);
/*
// 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_dof_exact, graph_cpu_est, graph_cpu_exact;
// 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();
// solve the coarse mesh 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();
// calculating error wrt. exact solution
ExactSolution ex(&mesh, exact);
double err_exact = 100 * hcurl_error(&sln_coarse, &ex);
info("Exact solution error: %g%%", err_exact);
// show real part of the solution and mesh
ordview.show(&space);
RealFilter real(&sln_coarse);
vecview.set_min_max_range(0, 1);
vecview.show(&real, EPS_HIGH);
// time measurement
begin_time();
// solve the fine mesh problem
RefSystem rs(&sys);
rs.assemble();
rs.solve(1, &sln_fine);
// calculate error estimate wrt. fine mesh solution
HcurlOrthoHP hp(1, &space);
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_exact.add_values(space.get_num_dofs(), err_exact);
graph_dof_exact.save("conv_dof_exact.dat");
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_exact.add_values(cpu, err_exact);
graph_cpu_exact.save("conv_cpu_exact.dat");
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);
verbose("Total running time: %g sec", cpu);
// show the fine solution - this is the final result
vecview.set_title("Final solution");
vecview.show(&sln_fine);
// wait for keyboard or mouse input
View::wait("Waiting for all views to be closed.");
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;
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;
}