int main(int argc, char* argv[])
{
// load the mesh
Mesh mesh;
H2DReader mloader;
mloader.load("square_quad.mesh", &mesh);
// mloader.load("square_tri.mesh", &mesh);
for (int i=0; i<INIT_REF_NUM; i++) mesh.refine_all_elements();
// initialize the shapeset and the cache
H1Shapeset shapeset;
PrecalcShapeset pss(&shapeset);
// create finite element space
H1Space 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);
wf.add_liform(0, callback(linear_form));
// matrix solver
UmfpackSolver solver;
// prepare selector
RefinementSelectors::H1NonUniformHP selector(ISO_ONLY, ADAPT_TYPE, CONV_EXP, H2DRS_DEFAULT_ORDER, &shapeset);
// convergence graph wrt. the number of degrees of freedom
GnuplotGraph graph;
graph.set_log_y();
graph.set_captions("Error Convergence for the Inner Layer Problem", "Degrees of Freedom", "Error [%]");
graph.add_row("exact error", "k", "-", "o");
graph.add_row("error estimate", "k", "--");
// convergence graph wrt. CPU time
GnuplotGraph graph_cpu;
graph_cpu.set_captions("Error Convergence for the Inner Layer Problem", "CPU Time", "Error Estimate [%]");
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 ls(&wf, &solver);
ls.set_spaces(1, &space);
ls.set_pss(1, &pss);
ls.assemble();
ls.solve(1, &sln_coarse);
// time measurement
cpu += end_time();
// calculate error wrt. exact solution
ExactSolution exact(&mesh, fndd);
double error = h1_error(&sln_coarse, &exact) * 100;
// time measurement
begin_time();
// solve the fine mesh problem
RefSystem rs(&ls);
rs.assemble();
rs.solve(1, &sln_fine);
// calculate error estimate wrt. fine mesh solution
H1AdaptHP hp(1, &space);
double err_est = hp.calc_error(&sln_coarse, &sln_fine) * 100;
info("Exact solution error: %g%%", error);
info("Estimate of error: %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, &selector, 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);
#define ERROR_SUCCESS 0
#define ERROR_FAILURE -1
int n_dof_allowed = 4000;
printf("n_dof_actual = %d\n", ndofs);
printf("n_dof_allowed = %d\n", n_dof_allowed);
if (ndofs <= n_dof_allowed) {
printf("Success!\n");
return ERROR_SUCCESS;
}
else {
printf("Failure!\n");
return ERROR_FAILURE;
}
}
// ********************************************************************
int main() {
// Create coarse mesh, set Dirichlet BC, enumerate basis functions
Mesh *mesh = new Mesh(A, B, N_elem, P_init, N_eq);
mesh->set_bc_left_dirichlet(0, Val_dir_left_0);
mesh->set_bc_left_dirichlet(1, Val_dir_left_1);
printf("N_dof = %d\n", mesh->assign_dofs());
// Create discrete problem on coarse mesh
DiscreteProblem *dp = new DiscreteProblem();
dp->add_matrix_form(0, 0, jacobian_0_0);
dp->add_matrix_form(0, 1, jacobian_0_1);
dp->add_matrix_form(1, 0, jacobian_1_0);
dp->add_matrix_form(1, 1, jacobian_1_1);
dp->add_vector_form(0, residual_0);
dp->add_vector_form(1, residual_1);
// scipy umfpack solver
CommonSolverSciPyUmfpack solver;
// Initial Newton's loop on coarse mesh
newton(dp, mesh, &solver, NEWTON_TOL_COARSE, NEWTON_MAXITER);
// Replicate coarse mesh including dof arrays
Mesh *mesh_ref = mesh->replicate();
// Refine entire mesh_ref uniformly in 'h' and 'p'
int start_elem_id = 0;
int num_to_ref = mesh_ref->get_n_active_elem();
mesh_ref->reference_refinement(start_elem_id, num_to_ref);
printf("Fine mesh created (%d DOF).\n", mesh_ref->get_n_dof());
// Convergence graph wrt. the number of degrees of freedom
GnuplotGraph graph;
graph.set_log_y();
graph.set_captions("Convergence History", "Degrees of Freedom", "Error [%]");
graph.add_row("exact error", "k", "-", "o");
graph.add_row("error estimate", "k", "--");
// Main adaptivity loop
int adapt_iterations = 1;
while(1) {
printf("============ Adaptivity step %d ============\n", adapt_iterations);
// Newton's loop on fine mesh
newton(dp, mesh_ref, &solver, NEWTON_TOL_REF, NEWTON_MAXITER);
// Starting with second adaptivity step, obtain new coarse
// mesh solution via Newton's method. Initial condition is
// the last coarse mesh solution.
if (adapt_iterations > 1) {
// Newton's loop on coarse mesh
newton(dp, mesh, &solver, NEWTON_TOL_COARSE, NEWTON_MAXITER);
}
// In the next step, estimate element errors based on
// the difference between the fine mesh and coarse mesh solutions.
double err_est_array[MAX_ELEM_NUM];
double err_est_total = calc_error_estimate(NORM, mesh, mesh_ref,
err_est_array);
// Calculate the norm of the fine mesh solution
double ref_sol_norm = calc_solution_norm(NORM, mesh_ref);
// Calculate an estimate of the global relative error
double err_est_rel = err_est_total/ref_sol_norm;
printf("Relative error (est) = %g %%\n", 100.*err_est_rel);
// If exact solution available, also calculate exact error
double err_exact_rel;
if (EXACT_SOL_PROVIDED) {
// Calculate element errors wrt. exact solution
double err_exact_total = calc_error_exact(NORM, mesh, exact_sol);
// Calculate the norm of the exact solution
// (using a fine subdivision and high-order quadrature)
int subdivision = 500; // heuristic parameter
int order = 20; // heuristic parameter
double exact_sol_norm = calc_solution_norm(NORM, exact_sol, N_eq, A, B,
subdivision, order);
// Calculate an estimate of the global relative error
err_exact_rel = err_exact_total/exact_sol_norm;
printf("Relative error (exact) = %g %%\n", 100.*err_exact_rel);
graph.add_values(0, mesh->get_n_dof(), 100 * err_exact_rel);
}
// add entry to DOF convergence graph
graph.add_values(1, mesh->get_n_dof(), 100 * err_est_rel);
// Decide whether the relative error is sufficiently small
if(err_est_rel*100 < TOL_ERR_REL) break;
// debug
// (adapt_iterations == 2) break;
// Returns updated coarse and fine meshes, with the last
// coarse and fine mesh solutions on them, respectively.
// The coefficient vectors and numbers of degrees of freedom
// on both meshes are also updated.
adapt(NORM, ADAPT_TYPE, THRESHOLD, err_est_array,
mesh, mesh_ref);
adapt_iterations++;
}
// Plot meshes, results, and errors
adapt_plotting(mesh, mesh_ref,
NORM, EXACT_SOL_PROVIDED, exact_sol);
// Save convergence graph
graph.save("conv_dof.gp");
int success_test = 1;
printf("N_dof = %d\n", mesh->get_n_dof());
if (mesh->get_n_dof() > 70) success_test = 0;
if (success_test) {
printf("Success!\n");
return ERROR_SUCCESS;
}
else {
printf("Failure!\n");
return ERROR_FAILURE;
}
}
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() {
// Create coarse mesh, set Dirichlet BC, enumerate
// basis functions
Mesh *mesh = new Mesh(A, B, N_elem, P_init, N_eq);
mesh->set_bc_left_dirichlet(0, Val_dir_left);
mesh->set_bc_right_dirichlet(0, Val_dir_right);
mesh->assign_dofs();
// Create discrete problem on coarse mesh
DiscreteProblem *dp = new DiscreteProblem();
dp->add_matrix_form(0, 0, jacobian);
dp->add_vector_form(0, residual);
// Convergence graph wrt. the number of degrees of freedom
GnuplotGraph graph;
graph.set_log_y();
graph.set_captions("Convergence History", "Degrees of Freedom", "Error");
graph.add_row("exact error [%]", "k", "-", "o");
graph.add_row("max FTR error", "k", "--");
// Main adaptivity loop
int adapt_iterations = 1;
double ftr_errors[MAX_ELEM_NUM]; // This array decides what
// elements will be refined.
ElemPtr2 ref_ftr_pairs[MAX_ELEM_NUM]; // To store element pairs from the
// FTR solution. Decides how
// elements will be hp-refined.
for (int i=0; i < MAX_ELEM_NUM; i++) {
ref_ftr_pairs[i][0] = new Element();
ref_ftr_pairs[i][1] = new Element();
}
while(1) {
printf("============ Adaptivity step %d ============\n", adapt_iterations);
printf("N_dof = %d\n", mesh->get_n_dof());
// Newton's loop on coarse mesh
newton(dp, mesh, NULL, NEWTON_TOL_COARSE, NEWTON_MAXITER);
// For every element perform its fast trial refinement (FTR),
// calculate the norm of the difference between the FTR
// solution and the coarse mesh solution, and store the
// error in the ftr_errors[] array.
int n_elem = mesh->get_n_active_elem();
for (int i=0; i < n_elem; i++) {
printf("=== Starting FTR of Elem [%d]\n", i);
// Replicate coarse mesh including solution.
Mesh *mesh_ref_local = mesh->replicate();
// Perform FTR of element 'i'
mesh_ref_local->reference_refinement(i, 1);
printf("Elem [%d]: fine mesh created (%d DOF).\n",
i, mesh_ref_local->assign_dofs());
// Newton's loop on the FTR mesh
newton(dp, mesh_ref_local, NULL, NEWTON_TOL_REF, NEWTON_MAXITER);
// Print FTR solution (enumerated)
Linearizer *lxx = new Linearizer(mesh_ref_local);
char out_filename[255];
sprintf(out_filename, "solution_ref_%d.gp", i);
lxx->plot_solution(out_filename);
delete lxx;
// Calculate norm of the difference between the coarse mesh
// and FTR solutions.
// NOTE: later we want to look at the difference in some quantity
// of interest rather than error in global norm.
double err_est_array[MAX_ELEM_NUM];
ftr_errors[i] = calc_error_estimate(NORM, mesh, mesh_ref_local,
err_est_array);
//printf("Elem [%d]: absolute error (est) = %g\n", i, ftr_errors[i]);
// Copy the reference element pair for element 'i'
// into the ref_ftr_pairs[i][] array
Iterator *I = new Iterator(mesh);
Iterator *I_ref = new Iterator(mesh_ref_local);
Element *e, *e_ref;
while (1) {
e = I->next_active_element();
e_ref = I_ref->next_active_element();
if (e->id == i) {
e_ref->copy_into(ref_ftr_pairs[e->id][0]);
// coarse element 'e' was split in space
if (e->level != e_ref->level) {
e_ref = I_ref->next_active_element();
e_ref->copy_into(ref_ftr_pairs[e->id][1]);
}
break;
}
}
delete I;
delete I_ref;
delete mesh_ref_local;
}
// If exact solution available, also calculate exact error
if (EXACT_SOL_PROVIDED) {
// Calculate element errors wrt. exact solution
double err_exact_total = calc_error_exact(NORM, mesh, exact_sol);
// Calculate the norm of the exact solution
// (using a fine subdivision and high-order quadrature)
int subdivision = 500; // heuristic parameter
int order = 20; // heuristic parameter
double exact_sol_norm = calc_solution_norm(NORM, exact_sol, N_eq, A, B,
subdivision, order);
// Calculate an estimate of the global relative error
double err_exact_rel = err_exact_total/exact_sol_norm;
//printf("Relative error (exact) = %g %%\n", 100.*err_exact_rel);
graph.add_values(0, mesh->get_n_dof(), 100 * err_exact_rel);
}
// Calculate max FTR error
double max_ftr_error = 0;
for (int i=0; i < mesh->get_n_active_elem(); i++) {
if (ftr_errors[i] > max_ftr_error) max_ftr_error = ftr_errors[i];
}
printf("Max FTR error = %g\n", max_ftr_error);
// Add entry to DOF convergence graph
graph.add_values(1, mesh->get_n_dof(), max_ftr_error);
// Decide whether the max. FTR error is sufficiently small
if(max_ftr_error < TOL_ERR_FTR) break;
// debug
if (adapt_iterations >= 1) break;
// Returns updated coarse mesh with the last solution on it.
adapt(NORM, ADAPT_TYPE, THRESHOLD, ftr_errors,
mesh, ref_ftr_pairs);
adapt_iterations++;
}
// Plot meshes, results, and errors
adapt_plotting(mesh, ref_ftr_pairs,
NORM, EXACT_SOL_PROVIDED, exact_sol);
// Save convergence graph
graph.save("conv_dof.gp");
printf("Done.\n");
return 1;
}
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;
}
/***********************************************************************************
* main program *
************************************************************************************/
int main(int argc, char **args)
{
#ifdef WITH_PETSC
PetscInitialize(NULL, NULL, PETSC_NULL, PETSC_NULL);
PetscPushErrorHandler(PetscIgnoreErrorHandler, PETSC_NULL); // Disable PETSc error handler.
#endif
// Load the inital mesh.
Mesh mesh;
Mesh3DReader mesh_loader;
mesh_loader.load("hexahedron.mesh3d", &mesh);
// Initial uniform mesh refinements.
printf("Performing %d initial mesh refinements.\n", INIT_REF_NUM);
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ);
Word_t (nelem) = mesh.get_num_elements();
printf("New number of elements is %d.\n", nelem);
//Initialize the shapeset and the cache.
H1ShapesetLobattoHex shapeset;
//Matrix solver.
#if defined WITH_UMFPACK
UMFPackMatrix mat;
UMFPackVector rhs;
UMFPackLinearSolver 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
// Graphs of DOF convergence.
GnuplotGraph graph;
graph.set_captions("", "Degrees of Freedom", "Error [%]");
graph.set_log_y();
graph.add_row("Total error", "k", "-", "O");
// Create H1 space to setup the problem.
H1Space space(&mesh, &shapeset);
space.set_bc_types(bc_types);
space.set_essential_bc_values(essential_bc_values);
space.set_uniform_order(order3_t(P_INIT, P_INIT, P_INIT));
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(biform<double, double>, biform<ord_t, ord_t>, SYM, ANY);
wf.add_vector_form(liform<double, double>, liform<ord_t, ord_t>, ANY);
// Initialize the coarse mesh problem.
LinProblem lp(&wf);
lp.set_space(&space);
// Adaptivity loop.
int as = 0;
bool done = false;
do {
printf("\n---- Adaptivity step %d:\n", as);
printf("\nSolving on coarse mesh:\n");
// Procedures for coarse mesh problem.
// Assign DOF.
int ndof = space.assign_dofs();
printf(" - Number of DOF: %d\n", ndof);
// Assemble stiffness matrix and rhs.
printf(" - Assembling... ");
fflush(stdout);
if (lp.assemble(&mat, &rhs))
printf("done in %lf secs.\n", lp.get_time());
else
error("failed!");
// Solve the system.
printf(" - Solving... ");
fflush(stdout);
bool solved = solver.solve();
if (solved)
printf("done in %lf secs.\n", solver.get_time());
else
{
printf("Failed.\n");
break;
}
// Construct a solution.
Solution sln(&mesh);
sln.set_fe_solution(&space, solver.get_solution());
// Output the orders and the solution.
if (do_output)
{
out_orders(&space, "order", as);
out_fn(&sln, "sln", as);
}
// Solving fine mesh problem.
printf("Solving on fine mesh:\n");
// Matrix solver.
#if defined WITH_UMFPACK
UMFPackLinearSolver rsolver(&mat, &rhs);
#elif defined WITH_PETSC
PetscLinearSolver rsolver(&mat, &rhs);
#elif defined WITH_MUMPS
MumpsSolver rsolver(&mat, &rhs);
#endif
// Construct the refined mesh for reference(refined) solution.
Mesh rmesh;
rmesh.copy(mesh);
rmesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ);
// Setup space for the reference (globally refined) solution.
Space *rspace = space.dup(&rmesh);
rspace->copy_orders(space, 1);
// Initialize the mesh problem for reference solution.
LinProblem rlp(&wf);
rlp.set_space(rspace);
// Assign DOF.
int rndof = rspace->assign_dofs();
printf(" - Number of DOF: %d\n", rndof);
// Assemble stiffness matric and rhs.
printf(" - Assembling... ");
fflush(stdout);
if (rlp.assemble(&mat, &rhs))
printf("done in %lf secs.\n", rlp.get_time());
else
error("failed!");
// Solve the system.
printf(" - Solving... ");
fflush(stdout);
bool rsolved = rsolver.solve();
if (rsolved)
printf("done in %lf secs.\n", rsolver.get_time());
else
{
printf("failed.\n");
break;
}
// Construct the reference(refined) solution.
Solution rsln(&rmesh);
rsln.set_fe_solution(rspace, rsolver.get_solution());
// Compare coarse and fine mesh.
// Calculate the error estimate wrt. refined mesh solution.
double err = h1_error(&sln, &rsln);
printf(" - H1 error: % lf\n", err * 100);
// Save it to the graph.
graph.add_value(0, ndof, err * 100);
if (do_output)
graph.save("conv.gp");
// Calculate error estimates for adaptivity.
printf("Adaptivity\n");
printf(" - calculating error: ");
fflush(stdout);
H1Adapt hp(&space);
double err_est = hp.calc_error(&sln, &rsln) * 100;
printf("% lf %%\n", err_est);
// If error is too large, adapt the mesh.
if (err_est < ERR_STOP)
{
printf("\nDone\n");
break;
}
printf(" - adapting... ");
fflush(stdout);
hp.adapt(THRESHOLD);
printf("done in %lf secs (refined %d element(s)).\n", hp.get_adapt_time(), hp.get_num_refined_elements());
if (rndof >= NDOF_STOP)
{
printf("\nDone.\n");
break;
}
// Clean up.
delete rspace;
// Next adaptivity step.
as++;
mat.free();
rhs.free();
} while (!done);
#ifdef WITH_PETSC
PetscFinalize();
#endif
return 1;
}
int main(int argc, char* argv[])
{
// load the mesh
Mesh mesh;
mesh.load("square_quad.mesh");
if(P_INIT == 1) mesh.refine_all_elements(); // this is because there are no degrees of freedom
// on the coarse mesh lshape.mesh if P_INIT == 1
// initialize the shapeset and the cache
H1ShapesetOrtho shapeset;
PrecalcShapeset pss(&shapeset);
// create finite element space
H1Space space(&mesh, &shapeset);
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, bilinear_form, SYM);
wf.add_liform(0, linear_form);
// visualize solution and mesh
ScalarView sview("Coarse solution", 0, 100, 798, 700);
OrderView oview("Polynomial orders", 800, 100, 798, 700);
// matrix solver
UmfpackSolver solver;
// convergence graph wrt. the number of degrees of freedom
GnuplotGraph graph;
graph.set_log_y();
graph.set_captions("Error Convergence for the Inner Layer Problem", "Degrees of Freedom", "Error [%]");
graph.add_row("exact error", "k", "-", "o");
graph.add_row("error estimate", "k", "--");
// convergence graph wrt. CPU time
GnuplotGraph graph_cpu;
graph_cpu.set_captions("Error Convergence for the Inner Layer Problem", "CPU Time", "Error Estimate [%]");
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 ls(&wf, &solver);
ls.set_spaces(1, &space);
ls.set_pss(1, &pss);
ls.assemble();
ls.solve(1, &sln_coarse);
// time measurement
cpu += end_time();
// calculate error wrt. exact solution
ExactSolution exact(&mesh, fndd);
double error = h1_error(&sln_coarse, &exact) * 100;
info("\nExact solution error: %g%%", error);
// view the solution and mesh
sview.show(&sln_coarse);
oview.show(&space);
// time measurement
begin_time();
// solve the fine mesh problem
RefSystem rs(&ls);
rs.assemble();
rs.solve(1, &sln_fine);
// calculate error estimate wrt. fine mesh solution
H1OrthoHP hp(1, &space);
double err_est = hp.calc_error(&sln_coarse, &sln_fine) * 100;
info("Estimate of error: %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 == false);
verbose("Total running time: %g sec", cpu);
// show the fine solution - this is the final result
sview.set_title("Final solution");
sview.show(&sln_fine);
// 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;
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;
mesh.load("motor.mesh");
// initialize the shapeset and the cache
H1Shapeset shapeset;
PrecalcShapeset pss(&shapeset);
// create finite element space
H1Space 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(biform1), SYM, 1);
wf.add_biform(0, 0, callback(biform2), SYM, 2);
// visualize solution, gradient, and mesh
ScalarView sview("Coarse solution", 0, 0, 600, 1000);
VectorView gview("Gradient", 610, 0, 600, 1000);
OrderView oview("Polynomial orders", 1220, 0, 600, 1000);
//gview.set_min_max_range(0.0, 400.0);
// matrix solver
UmfpackSolver solver;
// convergence graph wrt. the number of degrees of freedom
GnuplotGraph graph;
graph.set_captions("Error Convergence for the Micromotor 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 Micromotor 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();
// solve the coarse mesh problem
LinSystem ls(&wf, &solver);
ls.set_spaces(1, &space);
ls.set_pss(1, &pss);
ls.assemble();
ls.solve(1, &sln_coarse);
// time measurement
cpu += end_time();
// view the solution -- this can be slow; for illustration only
sview.show(&sln_coarse);
gview.show(&sln_coarse, &sln_coarse, EPS_NORMAL, FN_DX_0, FN_DY_0);
oview.show(&space);
// time measurement
begin_time();
// solve the fine mesh problem
RefSystem rs(&ls);
rs.assemble();
rs.solve(1, &sln_fine);
// calculate element errors and total error estimate
H1OrthoHP hp(1, &space);
double err_est = hp.calc_error(&sln_coarse, &sln_fine) * 100;
info("Error estimate: %g%%", err_est);
// time measurement
cpu += end_time();
// 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;
}
}
while (done == false);
verbose("Total running time: %g sec", cpu);
// show the fine solution - this is the final result
sview.set_title("Final solution");
sview.show(&sln_fine);
gview.show(&sln_fine, &sln_fine, EPS_HIGH, FN_DX_0, FN_DY_0);
// wait for keyboard or mouse input
View::wait("Waiting for keyboard or mouse input.");
return 0;
}
