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; 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(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); 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); dp->add_vector_form(0, residual); // Initial Newton's loop on coarse mesh newton(dp, mesh, NULL, 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, NULL, 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, NULL, 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; // 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() > 40) 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; 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; }