int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("square_2_elem.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < UNIFORM_REF_LEVEL; i++) mesh.refine_all_elements();
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_neumann(Hermes::vector<int>(BDY_LEFT_RIGHT, BDY_TOP_BOTTOM));
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d", ndof);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form_vol));
wf.add_vector_form(callback(linear_form_vol));
wf.add_vector_form_surf(callback(linear_form_surf_right), 2);
wf.add_vector_form_surf(callback(linear_form_surf_left), 2);
Solution sln;
// NON-ADAPTIVE VERSION
// Initialize the linear problem.
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, &space, is_linear);
// Select matrix solver.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Assemble stiffness matrix and rhs.
dp->assemble(matrix, rhs);
// Solve the linear system of the reference problem. If successful, obtain the solutions.
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), &space, &sln);
else error ("Matrix solver failed.\n");
// Visualize the solution.
ScalarView view("Solution", new WinGeom(0, 0, 440, 350));
view.show(&sln);
// Calculate error wrt. exact solution.
Solution sln_exact;
sln_exact.set_exact(&mesh, exact);
double err = calc_abs_error(&sln, &sln_exact, HERMES_H1_NORM);
printf("err = %g, err_squared = %g\n\n", err, err*err);
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial mesh refinements.
mesh.refine_towards_vertex(3, CORNER_REF_LEVEL);
// Create an H1 space with default shapeset.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
int ndof = get_num_dofs(&space);
info("ndof = %d", ndof);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form));
wf.add_vector_form(callback(linear_form));
wf.add_vector_form_surf(callback(linear_form_surf));
// Initialize the linear problem.
LinearProblem lp(&wf, &space);
// Select matrix solver.
Matrix* mat; Vector* rhs; CommonSolver* solver;
init_matrix_solver(matrix_solver, ndof, mat, rhs, solver);
// Assemble stiffness matrix and rhs.
lp.assemble(mat, rhs);
// Solve the matrix problem.
if (!solver->solve(mat, rhs)) error ("Matrix solver failed.\n");
// Convert coefficient vector into a Solution.
Solution* sln = new Solution(&space, rhs);
// Visualize the approximation.
ScalarView view("Solution", new WinGeom(0, 0, 440, 350));
view.show(sln);
// Compute and show gradient magnitude.
// (Note that the gradient at the re-entrant
// corner needs to be truncated for visualization purposes.)
ScalarView gradview("Gradient", new WinGeom(450, 0, 400, 350));
MagFilter grad(Tuple<MeshFunction *>(sln, sln),
Tuple<int>(H2D_FN_DX, H2D_FN_DY));
gradview.show(&grad);
// Wait for the views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
if (ALIGN_MESH) mloader.load("oven_load_circle.mesh", &mesh);
else mloader.load("oven_load_square.mesh", &mesh);
// Perform initial mesh refinemets.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Create an Hcurl space.
HcurlSpace space(&mesh, bc_types, essential_bc_values, P_INIT);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form));
wf.add_vector_form_surf(callback(linear_form_surf));
// Initialize refinements selector.
HcurlProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize adaptivity parameters.
double to_be_processed = 0;
AdaptivityParamType apt(ERR_STOP, NDOF_STOP, THRESHOLD, STRATEGY,
MESH_REGULARITY, to_be_processed, H2D_TOTAL_ERROR_REL,
H2D_ELEMENT_ERROR_REL);
// Geometry and position of visualization windows.
WinGeom* sln_win_geom = new WinGeom(0, 355, 900, 300);
WinGeom* mesh_win_geom = new WinGeom(0, 0, 900, 300);
// Adaptivity loop.
Solution *sln = new Solution();
Solution *ref_sln = new Solution();
bool verbose = true; // Print info during adaptivity.
bool is_complex = true;
solve_linear_adapt(&space, &wf, NULL, matrix_solver, H2D_HCURL_NORM, sln, ref_sln,
Tuple<WinGeom *>(sln_win_geom), Tuple<WinGeom *>(mesh_win_geom),
&selector, &apt, verbose, Tuple<ExactSolution *>(), is_complex);
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Choose a Butcher's table or define your own.
ButcherTable bt(butcher_table_type);
if (bt.is_explicit()) info("Using a %d-stage explicit R-K method.", bt.get_size());
if (bt.is_diagonally_implicit()) info("Using a %d-stage diagonally implicit R-K method.", bt.get_size());
if (bt.is_fully_implicit()) info("Using a %d-stage fully implicit R-K method.", bt.get_size());
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("cathedral.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(BDY_AIR, INIT_REF_NUM_BDY);
mesh.refine_towards_boundary(BDY_GROUND, INIT_REF_NUM_BDY);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(Hermes::vector<std::string>(BDY_GROUND));
bc_types.add_bc_newton(BDY_AIR);
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_const(BDY_GROUND, TEMP_INIT);
// Initialize an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d.", ndof);
// Previous and next time level solutions.
Solution* sln_time_prev = new Solution(&mesh, TEMP_INIT);
Solution* sln_time_new = new Solution(&mesh);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(stac_jacobian_vol));
wf.add_vector_form(callback(stac_residual_vol), HERMES_ANY, sln_time_prev);
wf.add_matrix_form_surf(callback(stac_jacobian_surf), BDY_AIR, sln_time_prev);
wf.add_vector_form_surf(callback(stac_residual_surf), BDY_AIR, sln_time_prev);
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem dp(&wf, &space, is_linear);
// Time stepping loop:
double current_time = time_step; int ts = 1;
do
{
// Perform one Runge-Kutta time step according to the selected Butcher's table.
info("Runge-Kutta time step (t = %g s, tau = %g s, stages: %d).",
current_time, time_step, bt.get_size());
bool verbose = true;
bool is_linear = true;
if (!rk_time_step(current_time, time_step, &bt, sln_time_prev, sln_time_new, &dp, matrix_solver,
verbose, is_linear)) {
error("Runge-Kutta time step failed, try to decrease time step size.");
}
// Convert coeff_vec into a new time level solution.
//Solution::vector_to_solution(coeff_vec, &space, &u_prev_time);
// Increase current time and time step counter.
current_time += time_step;
ts++;
}
while (current_time < T_FINAL);
info("Coordinate (-2.0, 2.0) value = %lf", sln_time_new->get_pt_value(-2.0, 2.0));
info("Coordinate (-1.0, 2.0) value = %lf", sln_time_new->get_pt_value(-1.0, 2.0));
info("Coordinate ( 0.0, 2.0) value = %lf", sln_time_new->get_pt_value(0.0, 2.0));
info("Coordinate ( 1.0, 2.0) value = %lf", sln_time_new->get_pt_value(1.0, 2.0));
info("Coordinate ( 2.0, 2.0) value = %lf", sln_time_new->get_pt_value(2.0, 2.0));
bool success = true;
if (fabs(sln_time_new->get_pt_value(-2.0, 2.0) - 9.999982) > 1E-6) success = false;
if (fabs(sln_time_new->get_pt_value(-1.0, 2.0) - 10.000002) > 1E-6) success = false;
if (fabs(sln_time_new->get_pt_value( 0.0, 2.0) - 9.999995) > 1E-6) success = false;
if (fabs(sln_time_new->get_pt_value( 1.0, 2.0) - 10.000002) > 1E-6) success = false;
if (fabs(sln_time_new->get_pt_value( 2.0, 2.0) - 9.999982) > 1E-6) success = false;
if (success) {
printf("Success!\n");
return ERR_SUCCESS;
}
else {
printf("Failure!\n");
return ERR_FAILURE;
}
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh, basemesh;
H2DReader mloader;
mloader.load("domain.mesh", &basemesh);
// Perform initial mesh refinements.
mesh.copy(&basemesh);
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(3, INIT_REF_NUM_BDY);
// Create an H1 space with default shapeset.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Solutions for the time stepping and the Newton's method.
Solution u_prev_time, u_prev_newton;
// Adapt mesh to represent initial condition with given accuracy.
int proj_norm = 1; // H1 norm.
bool verbose0 = true;
bool visualization = false;
double err_stop_init_cond = 0.1 * ERR_STOP;
adapt_to_exact_function(&space, init_cond, &selector, THRESHOLD, STRATEGY,
MESH_REGULARITY, ERR_STOP, NDOF_STOP, proj_norm,
verbose0, visualization, &u_prev_time);
// Initialize views.
ScalarView sview("Solution", 0, 0, 500, 350);
sview.set_min_max_range(-9.5, 2.2);
OrderView oview("Mesh", 510, 0, 500, 350);
// Initialize the weak formulation.
WeakForm wf;
if (TIME_INTEGRATION == 1) {
wf.add_matrix_form(jac_form_vol_euler, jac_form_vol_ord, H2D_UNSYM, H2D_ANY,
Tuple<MeshFunction*>(&u_prev_newton, &u_prev_time));
wf.add_matrix_form_surf(jac_form_surf_1_euler, jac_form_surf_1_ord, BDY_1,
&u_prev_newton);
wf.add_matrix_form_surf(jac_form_surf_4_euler, jac_form_surf_4_ord, BDY_4,
&u_prev_newton);
wf.add_matrix_form_surf(jac_form_surf_6_euler, jac_form_surf_6_ord, BDY_6,
&u_prev_newton);
wf.add_vector_form(res_form_vol_euler, res_form_vol_ord, H2D_ANY,
Tuple<MeshFunction*>(&u_prev_newton, &u_prev_time));
wf.add_vector_form_surf(res_form_surf_1_euler, res_form_surf_1_ord, BDY_1,
&u_prev_newton);
wf.add_vector_form_surf(res_form_surf_4_euler, res_form_surf_4_ord, BDY_4,
&u_prev_newton);
wf.add_vector_form_surf(res_form_surf_6_euler, res_form_surf_6_ord, BDY_6,
&u_prev_newton);
}
else {
wf.add_matrix_form(jac_form_vol_cranic, jac_form_vol_ord, H2D_UNSYM, H2D_ANY,
Tuple<MeshFunction*>(&u_prev_newton, &u_prev_time));
wf.add_matrix_form_surf(jac_form_surf_1_cranic, jac_form_surf_1_ord, BDY_1,
&u_prev_newton);
wf.add_matrix_form_surf(jac_form_surf_4_cranic, jac_form_surf_4_ord, BDY_4,
&u_prev_newton);
wf.add_matrix_form_surf(jac_form_surf_6_cranic, jac_form_surf_6_ord, BDY_6,
&u_prev_newton);
wf.add_vector_form(res_form_vol_cranic, res_form_vol_ord, H2D_ANY,
Tuple<MeshFunction*>(&u_prev_newton, &u_prev_time));
wf.add_vector_form_surf(res_form_surf_1_cranic, res_form_surf_1_ord, BDY_1,
Tuple<MeshFunction*>(&u_prev_newton, &u_prev_time));
wf.add_vector_form_surf(res_form_surf_4_cranic, res_form_surf_4_ord, BDY_4,
Tuple<MeshFunction*>(&u_prev_newton, &u_prev_time));
wf.add_vector_form_surf(res_form_surf_6_cranic, res_form_surf_6_ord, BDY_6,
Tuple<MeshFunction*>(&u_prev_newton, &u_prev_time));
}
// Initialize the nonlinear system.
NonlinSystem nls(&wf, &space);
// Error estimate and discrete problem size as a function of physical time.
SimpleGraph graph_time_err_est, graph_time_dof_est;
// Calculating initial vector for Newton.
info("Projecting initial condition to obtain coefficient vector for Newton on coarse mesh.");
nls.project_global(&u_prev_time, &u_prev_newton); // Initial vector calculated here.
// Newton's loop (one time step) on the coarse mesh.
info("Solving on coarse mesh.");
bool verbose = true; // Default is false.
if (!nls.solve_newton(&u_prev_newton, NEWTON_TOL_COARSE, NEWTON_MAX_ITER, verbose))
error("Newton's method did not converge.");
// Store the result in sln_coarse.
Solution sln_coarse, sln_fine;
sln_coarse.copy(&u_prev_newton);
// Time stepping loop.
int num_time_steps = (int)(T_FINAL/TAU + 0.5);
for(int ts = 1; ts <= num_time_steps; ts++)
{
// Update time-dependent Dirichlet BC values.
if (TIME <= STARTUP_TIME) space.update_essential_bc_values();
// Periodic global derefinements.
if (ts > 1 && ts % UNREF_FREQ == 0) {
info("Global mesh derefinement.");
mesh.copy(&basemesh);
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(3, INIT_REF_NUM_BDY);
// Project fine mesh solution on the globally derefined mesh.
info("---- Time step %d:", ts);
info("Projecting fine mesh solution on globally derefined mesh for error calculation.");
nls.project_global(&sln_fine, &u_prev_newton);
// Store the result in sln_coarse.
sln_coarse.copy(&u_prev_newton);
}
// Adaptivity loop (in space):
bool done = false;
double space_err_est;
int as = 1;
do
{
info("---- Time step %d, adaptivity step %d:", ts, as);
// Initialize reference nonlinear system.
RefSystem rnls(&nls);
// Set initial condition for the Newton's method on the fine mesh.
if (as == 1) {
info("Projecting coarse mesh solution to obtain initial vector on new fine mesh.");
rnls.project_global(&sln_coarse, &u_prev_newton);
}
else {
info("Projecting previous fine mesh solution to obtain initial vector on new fine mesh.");
rnls.project_global(&sln_fine, &u_prev_newton);
}
// Newton's method (one time step) on fine mesh
info("Solving on fine mesh.");
if (!rnls.solve_newton(&u_prev_newton, NEWTON_TOL_FINE, NEWTON_MAX_ITER, verbose))
error("Newton's method did not converge.");
// Store the result in sln_fine.
sln_fine.copy(&u_prev_newton);
// Calculate error estimate wrt. fine mesh solution.
info("Calculating error (est).");
H1Adapt hp(&nls);
hp.set_solutions(&sln_coarse, &sln_fine);
space_err_est = hp.calc_error() * 100;
info("ndof_coarse: %d, ndof_fine: %d, space_err_est: %g%%",
nls.get_num_dofs(), rnls.get_num_dofs(), space_err_est);
// If space_err_est too large, adapt the mesh.
if (space_err_est < ERR_STOP) done = true;
else {
info("Adapting coarse mesh.");
done = hp.adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
if (nls.get_num_dofs() >= NDOF_STOP) {
done = true;
break;
}
// Project the fine mesh solution on the new coarse mesh.
info("Projecting fine mesh solution on coarse mesh for error calculation.");
nls.project_global(&sln_fine, &u_prev_newton);
// Store the result in sln_coarse.
sln_coarse.copy(&u_prev_newton);
as++;
}
}
while (!done);
// Show the new time level solution.
char title[100];
sprintf(title, "Solution, t = %g", TIME);
sview.set_title(title);
sview.show(&sln_coarse);
sprintf(title, "Mesh, t = %g", TIME);
oview.set_title(title);
oview.show(&space);
/*
//Write solution data into file.
bool compress = false ;
char* filenamecoarse = new char[100];
sprintf(filenamecoarse, "coarse_%g.dat", TIME);
sln_coarse.save( filenamecoarse, compress );
//char* filenamefine = new char[100];
//sprintf(filenamefine, "fine_%g.dat", TIME);
//sln_fine.save(filenamefine , compress );
//char* filefinemesh = new char[100];
//sprintf(filefinemesh, "mesh_%g.dat", TIME);
//mesh.save( filefinemesh ) ;
*/
// Add entries to convergence graphs.
graph_time_err_est.add_values(ts*TAU, space_err_est);
graph_time_err_est.save("time_error_est.dat");
graph_time_dof_est.add_values(ts*TAU, nls.get_num_dofs());
graph_time_dof_est.save("time_dof_est.dat");
// Copy new time level solution into u_prev_time.
u_prev_time.copy(&sln_fine);
TIME += TAU;
}
// Wait for all views to be closed.
View::wait();
return 0;
}
int main()
{
// Create space, set Dirichlet BC, enumerate basis functions.
Space* space = new Space(A, B, NELEM, DIR_BC_LEFT, DIR_BC_RIGHT, P_INIT, NEQ);
int ndof = Space::get_num_dofs(space);
info("ndof: %d", ndof);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(jacobian_vol);
wf.add_vector_form(residual_vol);
wf.add_vector_form_surf(0, residual_surf_right, BOUNDARY_RIGHT);
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem *dp = new DiscreteProblem(&wf, space, is_linear);
// Newton's loop.
// Fill vector coeff_vec using dof and coeffs arrays in elements.
double *coeff_vec = new double[Space::get_num_dofs(space)];
get_coeff_vector(space, coeff_vec);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
int it = 1;
while (1) {
// Obtain the number of degrees of freedom.
int ndof = Space::get_num_dofs(space);
// Assemble the Jacobian matrix and residual vector.
dp->assemble(coeff_vec, matrix, rhs);
// Calculate the l2-norm of residual vector.
double res_l2_norm = get_l2_norm(rhs);
// Info for user.
info("---- Newton iter %d, ndof %d, res. l2 norm %g", it, Space::get_num_dofs(space), res_l2_norm);
// If l2 norm of the residual vector is within tolerance, then quit.
// NOTE: at least one full iteration forced
// here because sometimes the initial
// residual on fine mesh is too small.
if(res_l2_norm < NEWTON_TOL && it > 1) break;
// Multiply the residual vector with -1 since the matrix
// equation reads J(Y^n) \deltaY^{n+1} = -F(Y^n).
for(int i=0; i<ndof; i++) rhs->set(i, -rhs->get(i));
// Solve the linear system.
if(!solver->solve())
error ("Matrix solver failed.\n");
// Add \deltaY^{n+1} to Y^n.
for (int i = 0; i < ndof; i++) coeff_vec[i] += solver->get_solution()[i];
// If the maximum number of iteration has been reached, then quit.
if (it >= NEWTON_MAX_ITER) error ("Newton method did not converge.");
// Copy coefficients from vector y to elements.
set_coeff_vector(coeff_vec, space);
it++;
}
// Plot the solution.
Linearizer l(space);
l.plot_solution("solution.gp");
// Plot the resulting space.
space->plot("space.gp");
info("Done.");
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);
// Perform initial mesh refinemets.
for (int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_DIRICHLET);
bc_types.add_bc_neumann(BDY_NEUMANN);
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_zero(BDY_DIRICHLET);
// Create an Hcurl space.
HcurlSpace space(&mesh, &bc_types, &bc_values, P_INIT);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form));
wf.add_vector_form_surf(callback(linear_form_surf));
// Initialize coarse and reference mesh solution.
Solution sln, ref_sln;
// Initialize refinements selector.
HcurlProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
VectorView eview("Electric field", new WinGeom(0, 0, 580, 400));
OrderView oview("Polynomial orders", new WinGeom(590, 0, 550, 400));
// DOF and CPU convergence graphs initialization.
SimpleGraph graph_dof, graph_cpu;
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Space* ref_space = construct_refined_space(&space);
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, ref_space, is_linear);
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
dp->assemble(matrix, rhs);
// Time measurement.
cpu_time.tick();
// Solve the linear system of the reference problem.
// If successful, obtain the solution.
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), ref_space, &ref_sln);
else error ("Matrix solver failed.\n");
// Project the fine mesh solution onto the coarse mesh.
info("Projecting reference solution on coarse mesh.");
OGProjection::project_global(&space, &ref_sln, &sln, matrix_solver, HERMES_HCURL_NORM);
// Time measurement.
cpu_time.tick();
// Show real part of the solution.
AbsFilter abs(&sln);
eview.set_min_max_range(0, 4e3);
eview.show(&abs);
oview.show(&space);
// Skip visualization time.
cpu_time.tick(HERMES_SKIP);
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt* adaptivity = new Adapt(&space, HERMES_HCURL_NORM);
bool solutions_for_adapt = true;
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_REL) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%",
Space::get_num_dofs(&space), Space::get_num_dofs(ref_space), err_est_rel);
// Time measurement.
cpu_time.tick();
// Add entry to DOF and CPU convergence graphs.
graph_dof.add_values(Space::get_num_dofs(&space), err_est_rel);
graph_dof.save("conv_dof_est.dat");
graph_cpu.add_values(cpu_time.accumulated(), err_est_rel);
graph_cpu.save("conv_cpu_est.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
// Increase the counter of performed adaptivity steps.
if (done == false) as++;
}
if (Space::get_num_dofs(&space) >= NDOF_STOP) done = true;
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false) delete ref_space->get_mesh();
delete ref_space;
delete dp;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// Show the reference solution - the final result.
eview.set_title("Fine mesh solution");
eview.show(&ref_sln);
// Wait for all views to be closed.
View::wait();
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[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial mesh refinements.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Create an H1 space with default shapeset.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d", ndof);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form, bilinear_form_ord, HERMES_SYM);
wf.add_vector_form(linear_form, linear_form_ord);
wf.add_vector_form_surf(linear_form_surf, linear_form_surf_ord, BDY_VERTICAL);
// Initialize the FE problem.
bool is_linear = true;
DiscreteProblem dp(&wf, &space, is_linear);
initialize_solution_environment(matrix_solver, argc, argv);
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
if (matrix_solver == SOLVER_AZTECOO)
{
((AztecOOSolver*) solver)->set_solver(iterative_method);
((AztecOOSolver*) solver)->set_precond(preconditioner);
// Using default iteration parameters (see solver/aztecoo.h).
}
// Initialize the solution.
Solution sln;
// Assemble the stiffness matrix and right-hand side vector.
info("Assembling the stiffness matrix and right-hand side vector.");
dp.assemble(matrix, rhs);
// Solve the linear system and if successful, obtain the solution.
info("Solving the matrix problem.");
if(solver->solve())
Solution::vector_to_solution(solver->get_solution(), &space, &sln);
else
error ("Matrix solver failed.\n");
// Time measurement.
cpu_time.tick();
// Clean up.
delete solver;
delete matrix;
delete rhs;
finalize_solution_environment(matrix_solver);
// View the solution and mesh.
ScalarView sview("Solution", new WinGeom(0, 0, 440, 350));
sview.show(&sln);
OrderView oview("Polynomial orders", new WinGeom(450, 0, 400, 350));
oview.show(&space);
// Skip visualization time.
cpu_time.tick(HERMES_SKIP);
// Print timing information.
verbose("Total running time: %g s", cpu_time.accumulated());
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("cathedral.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(bdy_air, INIT_REF_NUM_BDY);
// Initialize an H1 space with default shepeset.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
int ndof = get_num_dofs(&space);
info("ndof = %d.", ndof);
// Set initial condition.
Solution tsln;
tsln.set_const(&mesh, T_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, double>, bilinear_form<Ord, Ord>);
wf.add_matrix_form_surf(bilinear_form_surf<double, double>, bilinear_form_surf<Ord, Ord>, bdy_air);
wf.add_vector_form(linear_form<double, double>, linear_form<Ord, Ord>, H2D_ANY, &tsln);
wf.add_vector_form_surf(linear_form_surf<double, double>, linear_form_surf<Ord, Ord>, bdy_air);
// Initialize the linear problem.
LinearProblem lp(&wf, &space);
// Initialize matrix solver.
Matrix* mat; Vector* rhs; CommonSolver* solver;
init_matrix_solver(matrix_solver, ndof, mat, rhs, solver);
// Initialize views.
ScalarView Tview("Temperature", new WinGeom(0, 0, 450, 600));
char title[100];
sprintf(title, "Time %3.5f, exterior temperature %3.5f", TIME, temp_ext(TIME));
Tview.set_min_max_range(0,20);
Tview.set_title(title);
Tview.fix_scale_width(3);
// Time stepping:
int nsteps = (int)(FINAL_TIME/TAU + 0.5);
bool rhsonly = false;
for(int ts = 1; ts <= nsteps; ts++)
{
info("---- Time step %d, time %3.5f, ext_temp %g", ts, TIME, temp_ext(TIME));
// Assemble stiffness matrix and rhs.
lp.assemble(mat, rhs, rhsonly);
rhsonly = true;
// Solve the matrix problem.
if (!solver->solve(mat, rhs)) error ("Matrix solver failed.\n");
// Update tsln.
tsln.set_fe_solution(&space, rhs);
// Update the time variable.
TIME += TAU;
// Visualize the solution.
sprintf(title, "Time %3.2f, exterior temperature %3.5f", TIME, temp_ext(TIME));
Tview.set_title(title);
Tview.show(&tsln);
}
// Wait for the view 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 mesh, basemesh;
H2DReader mloader;
mloader.load("domain.mesh", &basemesh);
// Perform initial mesh refinements.
mesh.copy(&basemesh);
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(3, INIT_REF_NUM_BDY);
// Create an H1 space with default shapeset.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d.", ndof);
// Create an H1 space for the initial coarse mesh solution.
H1Space init_space(&basemesh, bc_types, essential_bc_values, P_INIT);
// Create a selector which will select optimal candidate.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Solutions for the time stepping and the Newton's method.
Solution sln, ref_sln, sln_prev_time;
// Adapt mesh to represent initial condition with given accuracy.
info("Mesh adaptivity to an exact function:");
// Initialize views.
char title_init[200];
sprintf(title_init, "Projection of initial condition");
ScalarView* view_init = new ScalarView(title_init, new WinGeom(0, 0, 410, 300));
sprintf(title_init, "Initial mesh");
OrderView* ordview_init = new OrderView(title_init, new WinGeom(420, 0, 350, 300));
view_init->fix_scale_width(80);
int as = 1; bool done = false;
do
{
// Setup space for the reference solution.
Space *rspace = construct_refined_space(&init_space);
// Assign the function f() to the fine mesh.
ref_sln.set_exact(rspace->get_mesh(), init_cond);
// Project the function f() on the coarse mesh.
OGProjection::project_global(&init_space, &ref_sln, &sln_prev_time, matrix_solver);
// Calculate element errors and total error estimate.
Adapt adaptivity(&init_space, HERMES_H1_NORM);
bool solutions_for_adapt = true;
double err_est_rel = adaptivity.calc_err_est(&sln_prev_time, &ref_sln, solutions_for_adapt,
HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_REL) * 100;
info("Step %d, ndof %d, proj_error %g%%", as, Space::get_num_dofs(&init_space), err_est_rel);
// If err_est_rel too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else {
double to_be_processed = 0;
done = adaptivity.adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY, to_be_processed);
if (Space::get_num_dofs(&init_space) >= NDOF_STOP) done = true;
view_init->show(&sln_prev_time);
char title_init[100];
sprintf(title_init, "Initial mesh, step %d", as);
ordview_init->set_title(title_init);
ordview_init->show(&init_space);
}
as++;
}
while (done == false);
// Initialize the weak formulation.
WeakForm wf;
if (TIME_INTEGRATION == 1) {
wf.add_matrix_form(jac_form_vol_euler, jac_form_vol_ord, HERMES_UNSYM, HERMES_ANY,
&sln_prev_time);
wf.add_matrix_form_surf(jac_form_surf_1_euler, jac_form_surf_1_ord, BDY_1);
wf.add_matrix_form_surf(jac_form_surf_4_euler, jac_form_surf_4_ord, BDY_4);
wf.add_matrix_form_surf(jac_form_surf_6_euler, jac_form_surf_6_ord, BDY_6);
wf.add_vector_form(res_form_vol_euler, res_form_vol_ord, HERMES_ANY,
&sln_prev_time);
wf.add_vector_form_surf(res_form_surf_1_euler, res_form_surf_1_ord, BDY_1);
wf.add_vector_form_surf(res_form_surf_4_euler, res_form_surf_4_ord, BDY_4);
wf.add_vector_form_surf(res_form_surf_6_euler, res_form_surf_6_ord, BDY_6);
}
else {
wf.add_matrix_form(jac_form_vol_cranic, jac_form_vol_ord, HERMES_UNSYM, HERMES_ANY,
&sln_prev_time);
wf.add_matrix_form_surf(jac_form_surf_1_cranic, jac_form_surf_1_ord, BDY_1);
wf.add_matrix_form_surf(jac_form_surf_4_cranic, jac_form_surf_4_ord, BDY_4);
wf.add_matrix_form_surf(jac_form_surf_6_cranic, jac_form_surf_6_ord, BDY_6);
wf.add_vector_form(res_form_vol_cranic, res_form_vol_ord, HERMES_ANY,
&sln_prev_time);
wf.add_vector_form_surf(res_form_surf_1_cranic, res_form_surf_1_ord, BDY_1,
&sln_prev_time);
wf.add_vector_form_surf(res_form_surf_4_cranic, res_form_surf_4_ord, BDY_4,
&sln_prev_time);
wf.add_vector_form_surf(res_form_surf_6_cranic, res_form_surf_6_ord, BDY_6,
&sln_prev_time);
}
// Error estimate and discrete problem size as a function of physical time.
SimpleGraph graph_time_err_est, graph_time_err_exact, graph_time_dof, graph_time_cpu;
// Visualize the projection and mesh.
ScalarView view("Initial condition", new WinGeom(0, 0, 440, 350));
OrderView ordview("Initial mesh", new WinGeom(450, 0, 400, 350));
view.show(&sln_prev_time);
ordview.show(&space);
// Time stepping loop.
int num_time_steps = (int)(T_FINAL/TAU + 0.5);
for(int ts = 1; ts <= num_time_steps; ts++)
{
// Time measurement.
cpu_time.tick();
// Updating current time.
TIME = ts*TAU;
info("---- Time step %d:", ts);
// Periodic global derefinements.
if (ts > 1 && ts % UNREF_FREQ == 0) {
info("Global mesh derefinement.");
mesh.copy(&basemesh);
space.set_uniform_order(P_INIT);
}
// Adaptivity loop (in space):
bool done = false;
int as = 1;
do
{
info("---- Time step %d, adaptivity step %d:", ts, as);
// Construct globally refined reference mesh
// and setup reference space.
Space* ref_space = construct_refined_space(&space);
scalar* coeff_vec = new scalar[Space::get_num_dofs(ref_space)];
// Calculate initial coefficient vector for Newton on the fine mesh.
if (as == 1 && ts == 1) {
info("Projecting coarse mesh solution to obtain initial vector on new fine mesh.");
OGProjection::project_global(ref_space, &sln_prev_time, coeff_vec, matrix_solver);
}
else {
info("Projecting previous fine mesh solution to obtain initial vector on new fine mesh.");
OGProjection::project_global(ref_space, &ref_sln, coeff_vec, matrix_solver);
delete ref_sln.get_mesh();
}
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem dp(&wf, ref_space, is_linear);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Perform Newton's iteration.
info("Solving nonlinear problem:");
bool verbose = true;
if (!solve_newton(coeff_vec, &dp, solver, matrix, rhs,
NEWTON_TOL, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the actual solutions.
Solution::vector_to_solution(coeff_vec, ref_space, &ref_sln);
// Project the fine mesh solution on the coarse mesh.
info("Projecting fine mesh solution on coarse mesh for error calculation.");
OGProjection::project_global(&space, &ref_sln, &sln, matrix_solver);
// Calculate element errors.
info("Calculating error estimate.");
Adapt* adaptivity = new Adapt(&space, HERMES_H1_NORM);
bool solutions_for_adapt = true;
// Calculate error estimate wrt. fine mesh solution.
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln, solutions_for_adapt,
HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_ABS) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d, space_err_est_rel: %g%%",
Space::get_num_dofs(&space), Space::get_num_dofs(ref_space), err_est_rel);
// Add entries to convergence graphs.
graph_time_err_est.add_values(ts*TAU, err_est_rel);
graph_time_err_est.save("time_error_est.dat");
graph_time_dof.add_values(ts*TAU, Space::get_num_dofs(&space));
graph_time_dof.save("time_dof.dat");
graph_time_cpu.add_values(ts*TAU, cpu_time.accumulated());
graph_time_cpu.save("time_cpu.dat");
// If space_err_est too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else {
info("Adapting coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
if (Space::get_num_dofs(&space) >= NDOF_STOP) {
done = true;
break;
}
as++;
}
// Cleanup.
delete [] coeff_vec;
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
delete ref_space;
}
while (!done);
// Visualize the solution and mesh.
char title[100];
sprintf(title, "Solution, time level %d", ts);
view.set_title(title);
view.show(&sln);
sprintf(title, "Mesh, time level %d", ts);
ordview.set_title(title);
ordview.show(&space);
// Copy new time level solution into sln_prev_time.
sln_prev_time.copy(&ref_sln);
}
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
if (ALIGN_MESH) mloader.load("oven_load_circle.mesh", &mesh);
else mloader.load("oven_load_square.mesh", &mesh);
// Perform initial mesh refinemets.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Create an Hcurl space.
HcurlSpace space(&mesh, bc_types, essential_bc_values, P_INIT);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form));
wf.add_vector_form_surf(callback(linear_form_surf));
// Initialize coarse and reference mesh solution.
Solution sln, ref_sln;
// Initialize refinements selector.
HcurlProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// DOF and CPU convergence graphs initialization.
SimpleGraph graph_dof, graph_cpu;
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Space* ref_space = construct_refined_space(&space);
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, ref_space, is_linear);
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
dp->assemble(matrix, rhs);
// Time measurement.
cpu_time.tick();
// Solve the linear system of the reference problem.
// If successful, obtain the solution.
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), ref_space, &ref_sln);
else error ("Matrix solver failed.\n");
// Project the fine mesh solution onto the coarse mesh.
info("Projecting reference solution on coarse mesh.");
OGProjection::project_global(&space, &ref_sln, &sln, matrix_solver, HERMES_HCURL_NORM);
// Time measurement.
cpu_time.tick();
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt* adaptivity = new Adapt(&space, HERMES_HCURL_NORM);
bool solutions_for_adapt = true;
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_REL) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%",
Space::get_num_dofs(&space), Space::get_num_dofs(ref_space), err_est_rel);
// Time measurement.
cpu_time.tick();
// Add entry to DOF and CPU convergence graphs.
graph_dof.add_values(Space::get_num_dofs(&space), err_est_rel);
graph_dof.save("conv_dof_est.dat");
graph_cpu.add_values(cpu_time.accumulated(), err_est_rel);
graph_cpu.save("conv_cpu_est.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
// Increase the counter of performed adaptivity steps.
if (done == false) as++;
}
if (Space::get_num_dofs(&space) >= NDOF_STOP) done = true;
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false) delete ref_space->get_mesh();
delete ref_space;
delete dp;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
int ndof = Space::get_num_dofs(&space);
int n_dof_allowed = 1300;
printf("n_dof_actual = %d\n", ndof);
printf("n_dof_allowed = %d\n", n_dof_allowed);
if (ndof <= n_dof_allowed) {
printf("Success!\n");
return ERR_SUCCESS;
}
else {
printf("Failure!\n");
return ERR_FAILURE;
}
}
int main(int argc, char **args)
{
// Test variable.
int success_test = 1;
for (int i = 0; i < 48; i++) {
for (int j = 0; j < 48; j++) {
info("Config: %d, %d ", i, j);
Mesh mesh;
for (unsigned int k = 0; k < countof(vtcs); k++)
mesh.add_vertex(vtcs[k].x, vtcs[k].y, vtcs[k].z);
unsigned int h1[] = {
hexs[0][i][0] + 1, hexs[0][i][1] + 1, hexs[0][i][2] + 1, hexs[0][i][3] + 1,
hexs[0][i][4] + 1, hexs[0][i][5] + 1, hexs[0][i][6] + 1, hexs[0][i][7] + 1 };
mesh.add_hex(h1);
unsigned int h2[] = {
hexs[1][j][0] + 1, hexs[1][j][1] + 1, hexs[1][j][2] + 1, hexs[1][j][3] + 1,
hexs[1][j][4] + 1, hexs[1][j][5] + 1, hexs[1][j][6] + 1, hexs[1][j][7] + 1 };
mesh.add_hex(h2);
// bc
for (unsigned int k = 0; k < countof(bnd); k++) {
unsigned int facet_idxs[Quad::NUM_VERTICES] = { bnd[k][0] + 1, bnd[k][1] + 1, bnd[k][2] + 1, bnd[k][3] + 1 };
mesh.add_quad_boundary(facet_idxs, bnd[k][4]);
}
mesh.ugh();
// Initialize the space.
H1Space space(&mesh, bc_types, essential_bc_values);
#ifdef XM_YN_ZO
Ord3 ord(4, 4, 4);
#elif defined XM_YN_ZO_2
Ord3 ord(4, 4, 4);
#elif defined X2_Y2_Z2
Ord3 ord(2, 2, 2);
#endif
space.set_uniform_order(ord);
// Initialize the weak formulation.
WeakForm wf;
#ifdef DIRICHLET
wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, HERMES_SYM);
wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>);
#elif defined NEWTON
wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, HERMES_SYM);
wf.add_matrix_form_surf(bilinear_form_surf<double, scalar>, bilinear_form_surf<Ord, Ord>);
wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>);
wf.add_vector_form_surf(linear_form_surf<double, scalar>, linear_form_surf<Ord, Ord>);
#endif
// Initialize the FE problem.
bool is_linear = true;
DiscreteProblem dp(&wf, &space, is_linear);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Initialize the preconditioner in the case of SOLVER_AZTECOO.
if (matrix_solver == SOLVER_AZTECOO)
{
((AztecOOSolver*) solver)->set_solver(iterative_method);
((AztecOOSolver*) solver)->set_precond(preconditioner);
// Using default iteration parameters (see solver/aztecoo.h).
}
// Assemble the linear problem.
info("Assembling (ndof: %d).", Space::get_num_dofs(&space));
dp.assemble(matrix, rhs);
// Solve the linear system. If successful, obtain the solution.
info("Solving.");
Solution sln(space.get_mesh());
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), &space, &sln);
else error ("Matrix solver failed.\n");
ExactSolution ex_sln(&mesh, exact_solution);
// Calculate exact error.
info("Calculating exact error.");
Adapt *adaptivity = new Adapt(&space, HERMES_H1_NORM);
bool solutions_for_adapt = false;
double err_exact = adaptivity->calc_err_exact(&sln, &ex_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_ABS);
if (err_exact > EPS)
{
// Calculated solution is not precise enough.
success_test = 0;
info("failed, error:%g", err_exact);
}
else
info("passed");
// Clean up.
delete matrix;
delete rhs;
delete solver;
delete adaptivity;
}
}
if (success_test) {
info("Success!");
return ERR_SUCCESS;
}
else {
info("Failure!");
return ERR_FAILURE;
}
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_HORIZONTAL);
bc_types.add_bc_neumann(BDY_VERTICAL);
BCValues bc_values;
bc_values.add_function(BDY_HORIZONTAL, essential_bc_values);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d", ndof);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form, bilinear_form_ord, HERMES_SYM);
wf.add_vector_form(linear_form, linear_form_ord);
wf.add_vector_form_surf(linear_form_surf, linear_form_surf_ord, BDY_VERTICAL);
// Testing n_dof and correctness of solution vector
// for p_init = 1, 2, ..., 10
int success = 1;
Solution sln;
for (int p_init = 1; p_init <= 10; p_init++) {
printf("********* p_init = %d *********\n", p_init);
space.set_uniform_order(p_init);
// Initialize the FE problem.
bool is_linear = true;
DiscreteProblem dp(&wf, &space, is_linear);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Initialize the solution.
Solution sln;
// Assemble the stiffness matrix and right-hand side vector.
info("Assembling the stiffness matrix and right-hand side vector.");
bool rhsonly = false;
dp.assemble(matrix, rhs, rhsonly);
// Solve the linear system and if successful, obtain the solution.
info("Solving the matrix problem.");
if(solver->solve())
Solution::vector_to_solution(solver->get_solution(), &space, &sln);
else
error ("Matrix solver failed.\n");
int ndof = Space::get_num_dofs(&space);
printf("ndof = %d\n", ndof);
double sum = 0;
for (int i=0; i < ndof; i++) sum += solver->get_solution()[i];
printf("coefficient sum = %g\n", sum);
// Actual test. The values of 'sum' depend on the
// current shapeset. If you change the shapeset,
// you need to correct these numbers.
if (p_init == 1 && fabs(sum - 1.72173) > 1e-2) success = 0;
if (p_init == 2 && fabs(sum - 0.639908) > 1e-2) success = 0;
if (p_init == 3 && fabs(sum - 0.826367) > 1e-2) success = 0;
if (p_init == 4 && fabs(sum - 0.629395) > 1e-2) success = 0;
if (p_init == 5 && fabs(sum - 0.574235) > 1e-2) success = 0;
if (p_init == 6 && fabs(sum - 0.62792) > 1e-2) success = 0;
if (p_init == 7 && fabs(sum - 0.701982) > 1e-2) success = 0;
if (p_init == 8 && fabs(sum - 0.7982) > 1e-2) success = 0;
if (p_init == 9 && fabs(sum - 0.895069) > 1e-2) success = 0;
if (p_init == 10 && fabs(sum - 1.03031) > 1e-2) success = 0;
}
if (success == 1) {
printf("Success!\n");
return ERR_SUCCESS;
}
else {
printf("Failure!\n");
return ERR_FAILURE;
}
}
int main() {
// Three macroelements are defined above via the interfaces[] array.
// poly_orders[]... initial poly degrees of macroelements.
// material_markers[]... material markers of macroelements.
// subdivisions[]... equidistant subdivision of macroelements.
int poly_orders[N_MAT] = {P_init_inner, P_init_outer, P_init_reflector };
int material_markers[N_MAT] = {Marker_inner, Marker_outer, Marker_reflector };
int subdivisions[N_MAT] = {N_subdiv_inner, N_subdiv_outer, N_subdiv_reflector };
// Create space.
Space* space = new Space(N_MAT, interfaces, poly_orders, material_markers, subdivisions, N_GRP, N_SLN);
// Enumerate basis functions, info for user.
info("N_dof = %d", Space::get_num_dofs(space));
// Initial approximation: u = 1.
double K_EFF_old;
double init_val = 1.0;
set_vertex_dofs_constant(space, init_val, 0);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(jacobian_vol_inner, NULL, Marker_inner);
wf.add_matrix_form(jacobian_vol_outer, NULL, Marker_outer);
wf.add_matrix_form(jacobian_vol_reflector, NULL, Marker_reflector);
wf.add_vector_form(residual_vol_inner, NULL, Marker_inner);
wf.add_vector_form(residual_vol_outer, NULL, Marker_outer);
wf.add_vector_form(residual_vol_reflector, NULL, Marker_reflector);
wf.add_vector_form_surf(residual_surf_left, BOUNDARY_LEFT);
wf.add_matrix_form_surf(jacobian_surf_right, BOUNDARY_RIGHT);
wf.add_vector_form_surf(residual_surf_right, BOUNDARY_RIGHT);
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem *dp = new DiscreteProblem(&wf, space, is_linear);
// Source iteration (power method).
for (int i = 0; i < Max_SI; i++)
{
// Obtain fission source.
int current_solution = 0, previous_solution = 1;
copy_dofs(current_solution, previous_solution, space);
// Obtain the number of degrees of freedom.
int ndof = Space::get_num_dofs(space);
// Fill vector coeff_vec using dof and coeffs arrays in elements.
double *coeff_vec = new double[Space::get_num_dofs(space)];
solution_to_vector(space, coeff_vec);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
int it = 1;
while (1) {
// Obtain the number of degrees of freedom.
int ndof = Space::get_num_dofs(space);
// Assemble the Jacobian matrix and residual vector.
dp->assemble(matrix, rhs);
// Calculate the l2-norm of residual vector.
double res_norm = 0;
for(int i=0; i<ndof; i++) res_norm += rhs->get(i)*rhs->get(i);
res_norm = sqrt(res_norm);
// Info for user.
info("---- Newton iter %d, residual norm: %.15f", it, res_norm);
// If l2 norm of the residual vector is within tolerance, then quit.
// NOTE: at least one full iteration forced
// here because sometimes the initial
// residual on fine mesh is too small.
if(res_norm < NEWTON_TOL && it > 1) break;
// Multiply the residual vector with -1 since the matrix
// equation reads J(Y^n) \deltaY^{n+1} = -F(Y^n).
for(int i=0; i<ndof; i++) rhs->set(i, -rhs->get(i));
// Solve the linear system.
if(!solver->solve())
error ("Matrix solver failed.\n");
// Add \deltaY^{n+1} to Y^n.
for (int i = 0; i < ndof; i++) coeff_vec[i] += solver->get_solution()[i];
// If the maximum number of iteration has been reached, then quit.
if (it >= NEWTON_MAX_ITER) error ("Newton method did not converge.");
// Copy coefficients from vector y to elements.
vector_to_solution(coeff_vec, space);
it++;
}
// Cleanup.
delete matrix;
delete rhs;
delete solver;
delete [] coeff_vec;
// Update the eigenvalue.
K_EFF_old = K_EFF;
K_EFF = calc_fission_yield(space);
info("K_EFF_%d = %f", i, K_EFF);
if (fabs(K_EFF - K_EFF_old)/K_EFF < TOL_SI) break;
}
// Plot the critical (i.e. steady-state) neutron flux.
Linearizer l(space);
l.plot_solution("solution.gp");
// Normalize so that the absolute neutron flux generates 320 Watts of energy
// (note that, using the symmetry condition at the origin, we've solved for
// flux only in the right half of the reactor).
normalize_to_power(space, 320/2.);
// Plot the solution and space.
l.plot_solution("solution_320W.gp");
space->plot("space.gp");
info("K_EFF = %f", K_EFF);
info("Done.");
return 1;
}
int main(int argc, char* argv[])
{
// Choose a Butcher's table or define your own.
ButcherTable bt(butcher_table_type);
if (bt.is_explicit()) info("Using a %d-stage explicit R-K method.", bt.get_size());
if (bt.is_diagonally_implicit()) info("Using a %d-stage diagonally implicit R-K method.", bt.get_size());
if (bt.is_fully_implicit()) info("Using a %d-stage fully implicit R-K method.", bt.get_size());
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("cathedral.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(BDY_AIR, INIT_REF_NUM_BDY);
mesh.refine_towards_boundary(BDY_GROUND, INIT_REF_NUM_BDY);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(Hermes::vector<std::string>(BDY_GROUND));
bc_types.add_bc_newton(BDY_AIR);
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_const(BDY_GROUND, TEMP_INIT);
// Initialize an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d.", ndof);
// Previous time level solution (initialized by the external temperature).
Solution u_prev_time(&mesh, TEMP_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(stac_jacobian_vol));
wf.add_vector_form(callback(stac_residual_vol));
wf.add_matrix_form_surf(callback(stac_jacobian_surf), BDY_AIR);
wf.add_vector_form_surf(callback(stac_residual_surf), BDY_AIR);
// Project the initial condition on the FE space to obtain initial solution coefficient vector.
info("Projecting initial condition to translate initial condition into a vector.");
scalar* coeff_vec = new scalar[ndof];
OGProjection::project_global(&space, &u_prev_time, coeff_vec, matrix_solver);
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem dp(&wf, &space, is_linear);
// Initialize views.
ScalarView Tview("Temperature", new WinGeom(0, 0, 450, 600));
Tview.set_min_max_range(0,20);
Tview.fix_scale_width(30);
// Time stepping loop:
double current_time = 0.0; int ts = 1;
do
{
// Perform one Runge-Kutta time step according to the selected Butcher's table.
info("Runge-Kutta time step (t = %g, tau = %g, stages: %d).",
current_time, time_step, bt.get_size());
bool verbose = true;
bool is_linear = true;
if (!rk_time_step(current_time, time_step, &bt, coeff_vec, &dp, matrix_solver,
verbose, is_linear)) {
error("Runge-Kutta time step failed, try to decrease time step size.");
}
// Convert coeff_vec into a new time level solution.
Solution::vector_to_solution(coeff_vec, &space, &u_prev_time);
// Update time.
current_time += time_step;
// Show the new time level solution.
char title[100];
sprintf(title, "Time %3.2f, exterior temperature %3.5f", current_time, temp_ext(current_time));
Tview.set_title(title);
Tview.show(&u_prev_time);
// Increase counter of time steps.
ts++;
}
while (current_time < T_FINAL);
// Cleanup.
delete [] coeff_vec;
// Wait for the view to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Choose a Butcher's table or define your own.
ButcherTable* bt = new ButcherTable(butcher_table_type);
if (bt->is_explicit()) info("Using a %d-stage explicit R-K method.", bt->get_size());
if (bt->is_diagonally_implicit()) info("Using a %d-stage diagonally implicit R-K method.", bt->get_size());
if (bt->is_fully_implicit()) info("Using a %d-stage fully implicit R-K method.", bt->get_size());
// Turn off adaptive time stepping if R-K method is not embedded.
if (bt->is_embedded() == false && ADAPTIVE_TIME_STEP_ON == true) {
warn("R-K method not embedded, turning off adaptive time stepping.");
ADAPTIVE_TIME_STEP_ON = false;
}
// Load the mesh.
Mesh mesh, basemesh;
H2DReader mloader;
mloader.load("wall.mesh", &basemesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) basemesh.refine_all_elements();
basemesh.refine_towards_boundary(BDY_BOTTOM, INIT_REF_NUM_BDY);
mesh.copy(&basemesh);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_neumann(Hermes::vector<int>(BDY_RIGHT, BDY_LEFT));
bc_types.add_bc_newton(Hermes::vector<int>(BDY_BOTTOM, BDY_TOP));
// Initialize an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, NULL, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d.", ndof);
// Convert initial condition into a Solution.
Solution* sln_prev_time = new Solution(&mesh, TEMP_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(stac_jacobian_vol, stac_jacobian_vol_ord, HERMES_NONSYM, HERMES_ANY, sln_prev_time);
wf.add_vector_form(stac_residual_vol, stac_residual_vol_ord, HERMES_ANY, sln_prev_time);
wf.add_matrix_form_surf(stac_jacobian_bottom, stac_jacobian_bottom_ord, BDY_BOTTOM, sln_prev_time);
wf.add_vector_form_surf(stac_residual_bottom, stac_residual_bottom_ord, BDY_BOTTOM, sln_prev_time);
wf.add_matrix_form_surf(stac_jacobian_top, stac_jacobian_top_ord, BDY_TOP, sln_prev_time);
wf.add_vector_form_surf(stac_residual_top, stac_residual_top_ord, BDY_TOP, sln_prev_time);
// Initialize the FE problem.
bool is_linear = true;
DiscreteProblem dp(&wf, &space, is_linear);
// Create a refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Visualize initial condition.
char title[100];
ScalarView sln_view("Initial condition", new WinGeom(0, 0, 1500, 360));
OrderView ordview("Initial mesh", new WinGeom(0, 410, 1500, 360));
ScalarView time_error_view("Temporal error", new WinGeom(0, 800, 1500, 360));
time_error_view.fix_scale_width(40);
ScalarView space_error_view("Spatial error", new WinGeom(0, 1220, 1500, 360));
space_error_view.fix_scale_width(40);
sln_view.show(sln_prev_time, HERMES_EPS_VERYHIGH);
ordview.show(&space);
// Graph for time step history.
SimpleGraph time_step_graph;
if (ADAPTIVE_TIME_STEP_ON) info("Time step history will be saved to file time_step_history.dat.");
// Time stepping loop:
double current_time = 0; int ts = 1;
do
{
info("Begin time step %d.", ts);
// Periodic global derefinement.
if (ts > 1 && ts % UNREF_FREQ == 0)
{
info("Global mesh derefinement.");
if (UNREF_LEVEL == 1) mesh.unrefine_all_elements();
else mesh.copy(&basemesh);
space.set_uniform_order(P_INIT);
ndof = Space::get_num_dofs(&space);
}
// Spatial adaptivity loop. Note: sln_prev_time must not be
// changed during spatial adaptivity.
Solution ref_sln;
Solution* time_error_fn;
if (bt->is_embedded() == true) time_error_fn = new Solution(&mesh);
else time_error_fn = NULL;
bool done = false; int as = 1;
double err_est;
do {
// Construct globally refined reference mesh and setup reference space.
Space* ref_space = construct_refined_space(&space);
// Initialize discrete problem on reference mesh.
DiscreteProblem* ref_dp = new DiscreteProblem(&wf, ref_space);
// Runge-Kutta step on the fine mesh.
info("Runge-Kutta time step on fine mesh (t = %g s, tau = %g s, stages: %d).",
current_time, time_step, bt->get_size());
bool verbose = true;
bool is_linear = false;
if (!rk_time_step(current_time, time_step, bt, sln_prev_time, &ref_sln, time_error_fn,
ref_dp, matrix_solver, verbose, is_linear, NEWTON_TOL_FINE, NEWTON_MAX_ITER)) {
error("Runge-Kutta time step failed, try to decrease time step size.");
}
/* If ADAPTIVE_TIME_STEP_ON == true, estimate temporal error.
If too large or too small, then adjust it and restart the time step. */
double rel_err_time;
if (bt->is_embedded() == true) {
info("Calculating temporal error estimate.");
// Show temporal error.
char title[100];
sprintf(title, "Temporal error est, spatial adaptivity step %d", as);
time_error_view.set_title(title);
time_error_view.show_mesh(false);
time_error_view.show(time_error_fn, HERMES_EPS_VERYHIGH);
rel_err_time = calc_norm(time_error_fn, HERMES_H1_NORM) / calc_norm(&ref_sln, HERMES_H1_NORM) * 100;
if (ADAPTIVE_TIME_STEP_ON == false) info("rel_err_time: %g%%", rel_err_time);
}
if (ADAPTIVE_TIME_STEP_ON) {
if (rel_err_time > TIME_ERR_TOL_UPPER) {
info("rel_err_time %g%% is above upper limit %g%%", rel_err_time, TIME_ERR_TOL_UPPER);
info("Decreasing tau from %g to %g s and restarting time step.",
time_step, time_step * TIME_STEP_DEC_RATIO);
time_step *= TIME_STEP_DEC_RATIO;
delete ref_space;
delete ref_dp;
continue;
}
else if (rel_err_time < TIME_ERR_TOL_LOWER) {
info("rel_err_time = %g%% is below lower limit %g%%", rel_err_time, TIME_ERR_TOL_UPPER);
info("Increasing tau from %g to %g s.", time_step, time_step * TIME_STEP_INC_RATIO);
time_step *= TIME_STEP_INC_RATIO;
}
else {
info("rel_err_time = %g%% is in acceptable interval (%g%%, %g%%)",
rel_err_time, TIME_ERR_TOL_LOWER, TIME_ERR_TOL_UPPER);
}
// Add entry to time step history graph.
time_step_graph.add_values(current_time, time_step);
time_step_graph.save("time_step_history.dat");
}
/* Estimate spatial errors and perform mesh refinement */
info("Spatial adaptivity step %d.", as);
// Project the fine mesh solution onto the coarse mesh.
Solution sln;
info("Projecting fine mesh solution on coarse mesh for error estimation.");
OGProjection::project_global(&space, &ref_sln, &sln, matrix_solver);
// Show spatial error.
sprintf(title, "Spatial error est, spatial adaptivity step %d", as);
DiffFilter* space_error_fn = new DiffFilter(Hermes::vector<MeshFunction*>(&ref_sln, &sln));
space_error_view.set_title(title);
space_error_view.show_mesh(false);
AbsFilter abs_sef(space_error_fn);
space_error_view.show(&abs_sef, HERMES_EPS_VERYHIGH);
// Calculate element errors and spatial error estimate.
info("Calculating spatial error estimate.");
Adapt* adaptivity = new Adapt(&space);
double err_rel_space = adaptivity->calc_err_est(&sln, &ref_sln) * 100;
// Report results.
info("ndof: %d, ref_ndof: %d, err_rel_space: %g%%",
Space::get_num_dofs(&space), Space::get_num_dofs(ref_space), err_rel_space);
// If err_est too large, adapt the mesh.
if (err_rel_space < SPACE_ERR_TOL) done = true;
else
{
info("Adapting the coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
if (Space::get_num_dofs(&space) >= NDOF_STOP)
done = true;
else
// Increase the counter of performed adaptivity steps.
as++;
}
// Clean up.
delete adaptivity;
delete ref_space;
delete ref_dp;
delete space_error_fn;
}
while (done == false);
// Clean up.
if (time_error_fn != NULL) delete time_error_fn;
// Visualize the solution and mesh.
char title[100];
sprintf(title, "Solution, time %g s", current_time);
sln_view.set_title(title);
sln_view.show_mesh(false);
sln_view.show(&ref_sln, HERMES_EPS_VERYHIGH);
sprintf(title, "Mesh, time %g s", current_time);
ordview.set_title(title);
ordview.show(&space);
// Copy last reference solution into sln_prev_time.
sln_prev_time->copy(&ref_sln);
// Increase current time and counter of time steps.
current_time += time_step;
ts++;
}
while (current_time < T_FINAL);
// Clean up.
delete sln_prev_time;
delete bt;
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_BOTTOM);
bc_types.add_bc_neumann(Hermes::Tuple<int>(BDY_TOP_NE, BDY_TOP_NW));
bc_types.add_bc_neumann(Hermes::Tuple<std::string>(BDY_VERTICAL_SE, BDY_VERTICAL_NE, BDY_VERTICAL_NW, BDY_VERTICAL_SW));
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_zero(BDY_BOTTOM);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form_vol_SE), HERMES_UNSYM, SOUTH_EAST);
wf.add_matrix_form(callback(bilinear_form_vol_NE), HERMES_UNSYM, NORTH_EAST);
wf.add_matrix_form(callback(bilinear_form_vol_NW), HERMES_UNSYM, NORTH_WEST);
wf.add_matrix_form(callback(bilinear_form_vol_SW), HERMES_UNSYM, SOUTH_WEST);
wf.add_vector_form(callback(linear_form_vol));
wf.add_vector_form_surf(callback(linear_form_surf_VERTICAL_SE), BDY_VERTICAL_SE);
wf.add_vector_form_surf(callback(linear_form_surf_VERTICAL_NE), BDY_VERTICAL_NE);
wf.add_vector_form_surf(callback(linear_form_surf_VERTICAL_NW), BDY_VERTICAL_NW);
wf.add_vector_form_surf(callback(linear_form_surf_VERTICAL_SW), BDY_VERTICAL_SW);
wf.add_vector_form_surf(callback(linear_form_surf_TOP_NE), BDY_TOP_NE);
wf.add_vector_form_surf(callback(linear_form_surf_TOP_NW), BDY_TOP_NW);
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// DOF and CPU convergence graphs.
SimpleGraph graph_dof, graph_cpu;
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Space* ref_space = construct_refined_space(&space);
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, ref_space, is_linear);
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
dp->assemble(matrix, rhs);
// Time measurement.
cpu_time.tick();
// Solve the linear system of the reference problem. If successful, obtain the solution.
Solution ref_sln;
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), ref_space, &ref_sln);
else error ("Matrix solver failed.\n");
// Time measurement.
cpu_time.tick();
// Project the fine mesh solution onto the coarse mesh.
Solution sln;
info("Projecting reference solution on the coarse mesh.");
OGProjection::project_global(&space, &ref_sln, &sln, matrix_solver);
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt* adaptivity = new Adapt(&space, HERMES_H1_NORM);
bool solutions_for_adapt = true;
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_REL) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%",
Space::get_num_dofs(&space), Space::get_num_dofs(ref_space), err_est_rel);
// Time measurement.
cpu_time.tick();
// Add entry to DOF and CPU convergence graphs.
graph_dof.add_values(Space::get_num_dofs(&space), err_est_rel);
graph_dof.save("conv_dof_est.dat");
graph_cpu.add_values(cpu_time.accumulated(), err_est_rel);
graph_cpu.save("conv_cpu_est.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
// Increase the counter of performed adaptivity steps.
if (done == false) as++;
}
if (Space::get_num_dofs(&space) >= NDOF_STOP) done = true;
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false) delete ref_space->get_mesh();
delete ref_space;
delete dp;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
int ndof = Space::get_num_dofs(&space);
printf("ndof allowed = %d\n", 210);
printf("ndof actual = %d\n", ndof);
if (ndof < 210) { // ndofs was 208 at the time this test was created
printf("Success!\n");
return ERR_SUCCESS;
}
else {
printf("Failure!\n");
return ERR_FAILURE;
}
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh, basemesh;
H2DReader mloader;
mloader.load("domain.mesh", &basemesh);
// Perform initial mesh refinements.
mesh.copy(&basemesh);
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(3, INIT_REF_NUM_BDY);
// Create an H1 space with default shapeset.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
int ndof = get_num_dofs(&space);
info("ndof = %d.", ndof);
// Create a selector which will select optimal candidate.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Solutions for the time stepping and the Newton's method.
Solution sln, ref_sln, u_prev_time;
// Adapt mesh to represent initial condition with given accuracy.
int proj_norm = 1; // H1 norm.
bool verbose = false;
double err_stop_init_cond = 0.1 * ERR_STOP;
adapt_to_exact_function(&space, proj_norm, init_cond, &selector, THRESHOLD, STRATEGY,
MESH_REGULARITY, ERR_STOP, NDOF_STOP,
verbose, &u_prev_time);
// Assign initial condition to mesh.
u_prev_time.set_exact(&mesh, init_cond);
Vector *coeff_vec = new AVector(ndof);
// Calculating initial vector for Newton.
info("Projecting initial condition to obtain coefficient vector for Newton on coarse mesh.");
project_global(&space, H2D_H1_NORM, &u_prev_time, &u_prev_time, coeff_vec);
// Initialize the weak formulation.
WeakForm wf;
if (TIME_INTEGRATION == 1) {
wf.add_matrix_form(jac_form_vol_euler, jac_form_vol_ord, H2D_UNSYM, H2D_ANY,
Tuple<MeshFunction*>(&u_prev_time));
wf.add_matrix_form_surf(jac_form_surf_1_euler, jac_form_surf_1_ord, BDY_1);
wf.add_matrix_form_surf(jac_form_surf_4_euler, jac_form_surf_4_ord, BDY_4);
wf.add_matrix_form_surf(jac_form_surf_6_euler, jac_form_surf_6_ord, BDY_6);
wf.add_vector_form(res_form_vol_euler, res_form_vol_ord, H2D_ANY,
Tuple<MeshFunction*>(&u_prev_time));
wf.add_vector_form_surf(res_form_surf_1_euler, res_form_surf_1_ord, BDY_1);
wf.add_vector_form_surf(res_form_surf_4_euler, res_form_surf_4_ord, BDY_4);
wf.add_vector_form_surf(res_form_surf_6_euler, res_form_surf_6_ord, BDY_6);
}
else {
wf.add_matrix_form(jac_form_vol_cranic, jac_form_vol_ord, H2D_UNSYM, H2D_ANY,
Tuple<MeshFunction*>(&u_prev_time));
wf.add_matrix_form_surf(jac_form_surf_1_cranic, jac_form_surf_1_ord, BDY_1);
wf.add_matrix_form_surf(jac_form_surf_4_cranic, jac_form_surf_4_ord, BDY_4);
wf.add_matrix_form_surf(jac_form_surf_6_cranic, jac_form_surf_6_ord, BDY_6);
wf.add_vector_form(res_form_vol_cranic, res_form_vol_ord, H2D_ANY,
Tuple<MeshFunction*>(&u_prev_time));
wf.add_vector_form_surf(res_form_surf_1_cranic, res_form_surf_1_ord, BDY_1,
Tuple<MeshFunction*>( &u_prev_time));
wf.add_vector_form_surf(res_form_surf_4_cranic, res_form_surf_4_ord, BDY_4,
Tuple<MeshFunction*>(&u_prev_time));
wf.add_vector_form_surf(res_form_surf_6_cranic, res_form_surf_6_ord, BDY_6,
Tuple<MeshFunction*>(&u_prev_time));
}
// Initialize adaptivity parameters.
AdaptivityParamType apt(ERR_STOP, NDOF_STOP, THRESHOLD, STRATEGY, MESH_REGULARITY);
// Time stepping loop.
int num_time_steps = (int)(T_FINAL/TAU + 0.5);
for(int ts = 1; ts <= num_time_steps; ts++)
{
info("---- Time step %d:", ts);
// Periodic global derefinements.
if (ts > 1 && ts % UNREF_FREQ == 0) {
info("Global mesh derefinement.");
mesh.copy(&basemesh);
space.set_uniform_order(P_INIT);
}
// Update the coefficient vector and u_prev_time.
info("Projecting to obtain coefficient vector on coarse mesh.");
project_global(&space, H2D_H1_NORM, &u_prev_time, &u_prev_time, coeff_vec);
bool verbose = false; // Print info during adaptivity.
info("Projecting coarse mesh solution to obtain initial vector on new fine mesh.");
// The NULL pointers mean that we are not interested in visualization during the Newton's loop.
solve_newton_adapt(&space, &wf, coeff_vec, matrix_solver, H2D_H1_NORM, &sln, &ref_sln,
Tuple<WinGeom *>(), Tuple<WinGeom *>(), &selector, &apt,
NEWTON_TOL_COARSE, NEWTON_TOL_FINE, NEWTON_MAX_ITER, verbose);
// Copy new time level reference solution into u_prev_time.
u_prev_time.set_coeff_vector(&space, coeff_vec);
}
// Waiting for test.
}
int main(int argc, char* argv[])
{
// Choose a Butcher's table or define your own.
ButcherTable bt(butcher_table_type);
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("cathedral.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(BDY_AIR, INIT_REF_NUM_BDY);
mesh.refine_towards_boundary(BDY_GROUND, INIT_REF_NUM_BDY);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(Hermes::vector<std::string>(BDY_GROUND));
bc_types.add_bc_newton(BDY_AIR);
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_const(BDY_GROUND, TEMP_INIT);
// Initialize an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d.", ndof);
// Previous time level solution (initialized by the external temperature).
Solution u_prev_time(&mesh, TEMP_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(stac_jacobian));
wf.add_vector_form(callback(stac_residual));
wf.add_matrix_form_surf(callback(bilinear_form_surf), BDY_AIR);
wf.add_vector_form_surf(callback(linear_form_surf), BDY_AIR);
// Project the initial condition on the FE space to obtain initial solution coefficient vector.
info("Projecting initial condition to translate initial condition into a vector.");
scalar* coeff_vec = new scalar[ndof];
OGProjection::project_global(&space, &u_prev_time, coeff_vec, matrix_solver);
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem dp(&wf, &space, is_linear);
// Time stepping loop:
double current_time = 0.0; int ts = 1;
do
{
// Perform one Runge-Kutta time step according to the selected Butcher's table.
info("Runge-Kutta time step (t = %g, tau = %g, stages: %d).",
current_time, time_step, bt.get_size());
bool verbose = true;
if (!rk_time_step(current_time, time_step, &bt, coeff_vec, &dp, matrix_solver,
verbose, NEWTON_TOL, NEWTON_MAX_ITER)) {
error("Runge-Kutta time step failed, try to decrease time step size.");
}
// Convert coeff_vec into a new time level solution.
Solution::vector_to_solution(coeff_vec, &space, &u_prev_time);
// Update time.
current_time += time_step;
// Increase counter of time steps.
ts++;
}
while (current_time < time_step*5);
double sum = 0;
for (int i = 0; i < ndof; i++)
sum += coeff_vec[i];
printf("sum = %g\n", sum);
int success = 1;
if (fabs(sum - 3617.55) > 1e-1) success = 0;
// Cleanup.
delete [] coeff_vec;
if (success == 1) {
printf("Success!\n");
return ERR_SUCCESS;
}
else {
printf("Failure!\n");
return ERR_FAILURE;
}
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial mesh refinements.
for(int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_vertex(3, CORNER_REF_LEVEL);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_LEFT);
bc_types.add_bc_neumann(Hermes::vector<int>(BDY_OUTER, BDY_INNER));
bc_types.add_bc_newton(BDY_BOTTOM);
// Enter Dirichlet boudnary values.
BCValues bc_values;
bc_values.add_const(BDY_LEFT, T1);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d", ndof);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form));
wf.add_matrix_form_surf(callback(bilinear_form_surf), BDY_BOTTOM);
wf.add_vector_form_surf(callback(linear_form_surf), BDY_BOTTOM);
// Initialize the FE problem.
bool is_linear = true;
DiscreteProblem dp(&wf, &space, is_linear);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Initialize the solution.
Solution sln;
// Assemble the stiffness matrix and right-hand side vector.
info("Assembling the stiffness matrix and right-hand side vector.");
dp.assemble(matrix, rhs);
// Solve the linear system and if successful, obtain the solution.
info("Solving the matrix problem.");
if(solver->solve())
Solution::vector_to_solution(solver->get_solution(), &space, &sln);
else
error ("Matrix solver failed.\n");
// Visualize the solution.
ScalarView view("Solution", new WinGeom(0, 0, 440, 350));
view.show(&sln);
// Compute and show gradient magnitude.
// (Note that the gradient at the re-entrant
// corner needs to be truncated for visualization purposes.)
ScalarView gradview("Gradient", new WinGeom(450, 0, 400, 350));
MagFilter grad(Hermes::vector<MeshFunction *>(&sln, &sln),
Hermes::vector<int>(H2D_FN_DX, H2D_FN_DY));
gradview.show(&grad);
// Wait for all views to be closed.
View::wait();
// Clean up.
delete solver;
delete matrix;
delete rhs;
return 0;
}
int main(int argc, char **args)
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh mesh;
H3DReader mloader;
mloader.load("lshape_hex.mesh3d", &mesh);
// Perform initial mesh refinement.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ);
// Create an Hcurl space with default shapeset.
HcurlSpace space(&mesh, bc_types, essential_bc_values, Ord3(P_INIT_X, P_INIT_Y, P_INIT_Z));
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(biform<double, scalar>, biform<Ord, Ord>, HERMES_SYM);
wf.add_matrix_form_surf(biform_surf, biform_surf_ord);
wf.add_vector_form_surf(liform_surf, liform_surf_ord);
// Set exact solution.
ExactSolution exact_sol(&mesh, exact);
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est, 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.
Space* ref_space = construct_refined_space(&space, 1);
// Initialize discrete problem.
bool is_linear = true;
DiscreteProblem dp(&wf, ref_space, is_linear);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Initialize the preconditioner in the case of SOLVER_AZTECOO.
if (matrix_solver == SOLVER_AZTECOO)
{
((AztecOOSolver*) solver)->set_solver(iterative_method);
((AztecOOSolver*) solver)->set_precond(preconditioner);
// Using default iteration parameters (see solver/aztecoo.h).
}
// Assemble the reference problem.
info("Assembling on reference mesh (ndof: %d).", Space::get_num_dofs(ref_space));
dp.assemble(matrix, rhs);
// Time measurement.
cpu_time.tick();
// Solve the linear system on reference mesh. If successful, obtain the solution.
info("Solving on reference mesh.");
Solution ref_sln(ref_space->get_mesh());
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), ref_space, &ref_sln);
else error ("Matrix solver failed.\n");
// Time measurement.
cpu_time.tick();
// Project the reference solution on the coarse mesh.
Solution sln(space.get_mesh());
info("Projecting reference solution on coarse mesh.");
OGProjection::project_global(&space, &ref_sln, &sln, matrix_solver, HERMES_HCURL_NORM);
// Time measurement.
cpu_time.tick();
// Output solution and mesh with polynomial orders.
if (solution_output)
{
out_fn_vtk(&sln, "sln", as);
out_orders_vtk(&space, "order", as);
}
// Skip the visualization time.
cpu_time.tick(HERMES_SKIP);
// Calculate element errors and total error estimate.
info("Calculating error estimate and exact error.");
Adapt *adaptivity = new Adapt(&space, HERMES_HCURL_NORM);
bool solutions_for_adapt = true;
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln, solutions_for_adapt) * 100;
// Calculate exact error.
solutions_for_adapt = false;
double err_exact_rel = adaptivity->calc_err_exact(&sln, &exact_sol, solutions_for_adapt) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d.", Space::get_num_dofs(&space), Space::get_num_dofs(ref_space));
info("err_est_rel: %g%%, err_exact_rel: %g%%.", err_est_rel, err_exact_rel);
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space::get_num_dofs(&space), err_est_rel);
graph_dof_est.save("conv_dof_est.dat");
graph_cpu_est.add_values(cpu_time.accumulated(), err_est_rel);
graph_cpu_est.save("conv_cpu_est.dat");
graph_dof_exact.add_values(Space::get_num_dofs(&space), err_exact_rel);
graph_dof_exact.save("conv_dof_exact.dat");
graph_cpu_exact.add_values(cpu_time.accumulated(), err_exact_rel);
graph_cpu_exact.save("conv_cpu_exact.dat");
// If err_est_rel is too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else
{
info("Adapting coarse mesh.");
adaptivity->adapt(THRESHOLD);
}
if (Space::get_num_dofs(&space) >= NDOF_STOP) done = true;
// Clean up.
delete ref_space->get_mesh();
delete ref_space;
delete matrix;
delete rhs;
delete solver;
delete adaptivity;
// Increase the counter of performed adaptivity steps.
as++;
} while (!done);
return 0;
}
int main(int argc, char* argv[])
{
// Time measurement
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("lshape3q.mesh", &mesh); // quadrilaterals
//mloader.load("lshape3t.mesh", &mesh); // triangles
// Perform initial mesh refinemets.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(Hermes::Tuple<int>(BDY_1, BDY_6));
bc_types.add_bc_newton(Hermes::Tuple<int>(BDY_2, BDY_3, BDY_4, BDY_5));
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_zero(Hermes::Tuple<int>(BDY_1, BDY_6));
// Create an Hcurl space with default shapeset.
HcurlSpace space(&mesh, &bc_types, &bc_values, P_INIT);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form), HERMES_SYM);
wf.add_matrix_form_surf(callback(bilinear_form_surf));
wf.add_vector_form_surf(linear_form_surf, linear_form_surf_ord);
// Initialize coarse and reference mesh solutions.
Solution sln, ref_sln;
// Initialize exact solution.
ExactSolution sln_exact(&mesh, exact);
// Initialize refinement selector.
HcurlProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est,
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.
Space* ref_space = construct_refined_space(&space);
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, ref_space, is_linear);
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
dp->assemble(matrix, rhs);
// Time measurement.
cpu_time.tick();
// Solve the linear system of the reference problem. If successful, obtain the solution.
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), ref_space, &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::project_global(&space, &ref_sln, &sln, matrix_solver);
// Calculate element errors and total error estimate.
info("Calculating error estimate and exact error.");
Adapt* adaptivity = new Adapt(&space);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 100;
// Calculate exact error,
bool solutions_for_adapt = false;
double err_exact_rel = adaptivity->calc_err_exact(&sln, &sln_exact, solutions_for_adapt) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d",
Space::get_num_dofs(&space), Space::get_num_dofs(ref_space));
info("err_est_rel: %g%%, err_exact_rel: %g%%", err_est_rel, err_exact_rel);
// Time measurement.
cpu_time.tick();
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space::get_num_dofs(&space), err_est_rel);
graph_dof_est.save("conv_dof_est.dat");
graph_cpu_est.add_values(cpu_time.accumulated(), err_est_rel);
graph_cpu_est.save("conv_cpu_est.dat");
graph_dof_exact.add_values(Space::get_num_dofs(&space), err_exact_rel);
graph_dof_exact.save("conv_dof_exact.dat");
graph_cpu_exact.add_values(cpu_time.accumulated(), err_exact_rel);
graph_cpu_exact.save("conv_cpu_exact.dat");
// If err_est_rel too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
// Increase the counter of performed adaptivity steps.
if (done == false) as++;
}
if (Space::get_num_dofs(&space) >= NDOF_STOP) done = true;
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false) delete ref_space->get_mesh();
delete ref_space;
delete dp;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
int ndof = Space::get_num_dofs(&space);
printf("ndof allowed = %d\n", 1400);
printf("ndof actual = %d\n", ndof);
if (ndof < 1400) { // ndofs was 1384 atthe time this test was created
printf("Success!\n");
return ERR_SUCCESS;
}
else {
printf("Failure!\n");
return ERR_FAILURE;
}
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("cathedral.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(2, 5);
// Initialize an H1 space.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
// Set initial condition.
Solution tsln;
tsln.set_const(&mesh, T_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, double>, bilinear_form<Ord, Ord>);
wf.add_matrix_form_surf(bilinear_form_surf<double, double>, bilinear_form_surf<Ord, Ord>, marker_air);
wf.add_vector_form(linear_form<double, double>, linear_form<Ord, Ord>, H2D_ANY, &tsln);
wf.add_vector_form_surf(linear_form_surf<double, double>, linear_form_surf<Ord, Ord>, marker_air);
// Initialize linear system.
LinSystem ls(&wf, &space);
// time stepping
int nsteps = (int)(FINAL_TIME/TAU + 0.5);
bool rhsonly = false;
for(int n = 1; n <= nsteps; n++)
{
info("---- Time step %d, time %3.5f, ext_temp %g", ts, TIME, temp_ext(TIME));
// Assemble and solve.
ls.assemble(rhsonly);
rhsonly = true;
ls.solve(&tsln);
// Update the time variable.
TIME += TAU;
}
scalar *sol_vector;
int n_dof;
ls.get_solution_vector(sol_vector, n_dof);
printf("n_dof = %d\n", n_dof);
double sum = 0;
for (int i=0; i < n_dof; i++) sum += sol_vector[i];
printf("coefficient sum = %g\n", sum);
// Actual test. The value of 'sum' depend on the
// current shapeset. If you change the shapeset,
// you need to correct this number.
int success = 1;
if (fabs(sum - 8508.36) > 1e-1) success = 0;
#define ERROR_SUCCESS 0
#define ERROR_FAILURE -1
if (success == 1) {
printf("Success!\n");
return ERROR_SUCCESS;
}
else {
printf("Failure!\n");
return ERROR_FAILURE;
}
}
int main(int argc, char **args)
{
// Test variable.
int success_test = 1;
if (argc < 2) error("Not enough parameters.");
// Load the mesh.
Mesh mesh;
H3DReader mloader;
if (!mloader.load(args[1], &mesh)) error("Loading mesh file '%s'.", args[1]);
// Initialize the space.
int mx = 2;
Ord3 order(mx, mx, mx);
H1Space space(&mesh, bc_types, NULL, order);
#if defined LIN_DIRICHLET || defined NLN_DIRICHLET
space.set_essential_bc_values(essential_bc_values);
#endif
// Initialize the weak formulation.
WeakForm wf;
wf.add_vector_form(form_0<double, scalar>, form_0<Ord, Ord>);
#if defined LIN_NEUMANN || defined LIN_NEWTON
wf.add_vector_form_surf(form_0_surf<double, scalar>, form_0_surf<Ord, Ord>);
#endif
#if defined LIN_DIRICHLET || defined NLN_DIRICHLET
// preconditioner
wf.add_matrix_form(precond_0_0<double, scalar>, precond_0_0<Ord, Ord>, HERMES_SYM);
#endif
// Initialize the FE problem.
DiscreteProblem fep(&wf, &space);
#if defined LIN_DIRICHLET || defined NLN_DIRICHLET
// use ML preconditioner to speed-up things
MlPrecond pc("sa");
pc.set_param("max levels", 6);
pc.set_param("increasing or decreasing", "decreasing");
pc.set_param("aggregation: type", "MIS");
pc.set_param("coarse: type", "Amesos-KLU");
#endif
NoxSolver solver(&fep);
#if defined LIN_DIRICHLET || defined NLN_DIRICHLET
// solver.set_precond(&pc);
#endif
info("Solving.");
Solution sln(&mesh);
if(solver.solve()) Solution::vector_to_solution(solver.get_solution(), &space, &sln);
else error ("Matrix solver failed.\n");
Solution ex_sln(&mesh);
ex_sln.set_exact(exact_solution);
// Calculate exact error.
info("Calculating exact error.");
Adapt *adaptivity = new Adapt(&space, HERMES_H1_NORM);
bool solutions_for_adapt = false;
double err_exact = adaptivity->calc_err_exact(&sln, &ex_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_ABS);
if (err_exact > EPS)
// Calculated solution is not precise enough.
success_test = 0;
if (success_test) {
info("Success!");
return ERR_SUCCESS;
}
else {
info("Failure!");
return ERR_FAILURE;
}
}
int main(int argc, char **args) {
int res = ERR_SUCCESS;
#ifdef WITH_PETSC
PetscInitialize(&argc, &args, (char *) PETSC_NULL, PETSC_NULL);
#endif
set_verbose(false);
TRACE_START("trace.txt");
DEBUG_OUTPUT_ON;
SET_VERBOSE_LEVEL(0);
if (argc < 5) error("Not enough parameters");
sscanf(args[2], "%d", &m);
sscanf(args[3], "%d", &n);
sscanf(args[4], "%d", &o);
printf("* Loading mesh '%s'\n", args[1]);
Mesh mesh;
Mesh3DReader mloader;
if (!mloader.load(args[1], &mesh)) error("Loading mesh file '%s'\n", args[1]);
H1ShapesetLobattoHex shapeset;
printf("* Setting the space up\n");
H1Space space(&mesh, &shapeset);
space.set_bc_types(bc_types);
int mx = maxn(4, m, n, o, 4);
order3_t order(mx, mx, mx);
// order3_t order(1, 1, 1);
// order3_t order(m, n, o);
printf(" - Setting uniform order to (%d, %d, %d)\n", mx, mx, mx);
space.set_uniform_order(order);
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;
PardisoLinearSolver 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_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
printf(" - assembling...\n"); fflush(stdout);
Timer assemble_timer;
assemble_timer.start();
lp.assemble(&mat, &rhs);
assemble_timer.stop();
printf("%s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds());
// solve the stiffness matrix
printf(" - solving... "); fflush(stdout);
Timer solve_timer;
solve_timer.start();
bool solved = solver.solve();
solve_timer.stop();
printf("%s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds());
// mat.dump(stdout, "a");
// rhs.dump(stdout, "b");
if (solved) {
Solution sln(&mesh);
sln.set_coeff_vector(&space, solver.get_solution());
// printf("* Solution:\n");
// double *s = solver.get_solution();
// for (int i = 1; i <= ndofs; i++) {
// printf(" x[% 3d] = % lf\n", i, s[i]);
// }
ExactSolution ex_sln(&mesh, exact_solution);
// norm
double h1_sln_norm = h1_norm(&sln);
double h1_err_norm = h1_error(&sln, &ex_sln);
printf(" - H1 solution norm: % le\n", h1_sln_norm);
printf(" - H1 error norm: % le\n", h1_err_norm);
double l2_sln_norm = l2_norm(&sln);
double l2_err_norm = l2_error(&sln, &ex_sln);
printf(" - L2 solution norm: % le\n", l2_sln_norm);
printf(" - L2 error norm: % le\n", l2_err_norm);
if (h1_err_norm > EPS || l2_err_norm > EPS) {
// calculated solution is not enough precise
res = ERR_FAILURE;
}
#if 0 //def OUTPUT_DIR
printf("* Output\n");
// output
const char *of_name = OUTPUT_DIR "/solution.pos";
FILE *ofile = fopen(of_name, "w");
if (ofile != NULL) {
ExactSolution ex_sln(&mesh, exact_solution);
DiffFilter eh(&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);
output.out(&sln, "Uh");
// output.out(&sln, "Uh dx", FN_DX_0);
// output.out(&sln, "Uh dy", FN_DY_0);
// output.out(&sln, "Uh dz", FN_DZ_0);
output.out(&eh, "Eh");
// output.out(&eh_dx, "Eh dx");
// output.out(&eh_dy, "Eh dy");
// output.out(&eh_dz, "Eh dz");
output.out(&ex_sln, "U");
// output.out(&ex_sln, "U dx", FN_DX_0);
// output.out(&ex_sln, "U dy", FN_DY_0);
// output.out(&ex_sln, "U dz", FN_DZ_0);
fclose(ofile);
}
else {
warning("Can not open '%s' for writing.", of_name);
}
#endif
}
else
res = ERR_FAILURE;
#ifdef WITH_PETSC
mat.free();
rhs.free();
PetscFinalize();
#endif
TRACE_END;
return res;
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_BOTTOM);
bc_types.add_bc_neumann(Hermes::Tuple<int>(BDY_RIGHT, BDY_TOP, BDY_LEFT));
// Enter Dirichlet boudnary values.
BCValues bc_values;
bc_values.add_zero(BDY_BOTTOM);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form), HERMES_SYM);
wf.add_vector_form(callback(linear_form));
wf.add_vector_form_surf(callback(linear_form_surf), BDY_TOP);
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Set exact solution.
ExactSolution exact(&mesh, fndd);
// Initialize views.
ScalarView sview("Solution", new WinGeom(0, 0, 440, 350));
sview.show_mesh(false);
OrderView oview("Polynomial orders", new WinGeom(450, 0, 400, 350));
// DOF and CPU convergence graphs.
SimpleGraph graph_dof, graph_cpu, graph_dof_exact, graph_cpu_exact;
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Space* ref_space = construct_refined_space(&space);
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, ref_space, is_linear);
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
dp->assemble(matrix, rhs);
// Time measurement.
cpu_time.tick();
// Solve the linear system of the reference problem. If successful, obtain the solution.
Solution ref_sln;
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), ref_space, &ref_sln);
else error ("Matrix solver failed.\n");
// Time measurement.
cpu_time.tick();
// Project the fine mesh solution onto the coarse mesh.
Solution sln;
info("Projecting reference solution on coarse mesh.");
OGProjection::project_global(&space, &ref_sln, &sln, matrix_solver);
// View the coarse mesh solution and polynomial orders.
sview.show(&sln);
oview.show(&space);
// Calculate element errors and total error estimate.
info("Calculating error estimate and exact error.");
Adapt* adaptivity = new Adapt(&space, HERMES_H1_NORM);
bool solutions_for_adapt = true;
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_REL) * 100;
// Calculate exact error.
solutions_for_adapt = false;
double err_exact_rel = adaptivity->calc_err_exact(&sln, &exact, solutions_for_adapt, HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_REL) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d", Space::get_num_dofs(&space), Space::get_num_dofs(ref_space));
info("err_est_rel: %g%%, err_exact_rel: %g%%", err_est_rel, err_exact_rel);
// Time measurement.
cpu_time.tick();
// Add entry to DOF and CPU convergence graphs.
graph_dof.add_values(Space::get_num_dofs(&space), err_est_rel);
graph_dof.save("conv_dof_est.dat");
graph_cpu.add_values(cpu_time.accumulated(), err_est_rel);
graph_cpu.save("conv_cpu_est.dat");
graph_dof_exact.add_values(Space::get_num_dofs(&space), err_exact_rel);
graph_dof_exact.save("conv_dof_exact.dat");
graph_cpu_exact.add_values(cpu_time.accumulated(), err_exact_rel);
graph_cpu_exact.save("conv_cpu_exact.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
// Increase the counter of performed adaptivity steps.
if (done == false) as++;
}
if (Space::get_num_dofs(&space) >= NDOF_STOP) done = true;
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false) delete ref_space->get_mesh();
delete ref_space;
delete dp;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// Wait for all views to be closed.
View::wait();
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("square_quad.mesh", &mesh);
// Perform initial mesh refinement.
for (int i=0; i<INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(BOUNDARY_LAYER, INIT_BDY_REF_NUM);
//mesh.refine_towards_boundary(NONZERO_DIRICHLET, INIT_BDY_REF_NUM/2);
// Create a space and refinement selector appropriate for the selected discretization method.
Space *space;
ProjBasedSelector *selector;
ProjNormType norm;
if (method != DG)
{
space = new H1Space(&mesh, bc_types, essential_bc_values, P_INIT);
selector = new L2ProjBasedSelector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
norm = HERMES_L2_NORM; // WARNING: In order to compare the errors with DG, L2 norm should be here.
}
else
{
space = new L2Space(&mesh, bc_types, NULL, Ord2(P_INIT));
selector = new L2ProjBasedSelector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
norm = HERMES_L2_NORM;
// Disable weighting of refinement candidates.
selector->set_error_weights(1, 1, 1);
}
// Initialize the weak formulation.
info("Discretization method: %s", method_names[method].c_str());
if (method != CG && method != DG)
{
if (STRATEGY > -1 && CAND_LIST != H2D_H_ISO && CAND_LIST != H2D_H_ANISO)
error("The %s method may be used only with h-refinement.", method_names[method].c_str());
int eff_order = (STRATEGY == -1) ? P_INIT : P_INIT + ORDER_INCREASE;
if (method != CG_STAB_GLS)
{
if (eff_order > 1)
error("The %s method may be used only with at most 1st order elements.", method_names[method].c_str());
}
else
{
if (eff_order > 2)
error("The %s method may be used only with at most 2nd order elements.", method_names[method].c_str());
}
}
WeakForm wf;
switch(method)
{
case CG:
wf.add_matrix_form(callback(cg_biform));
break;
case CG_STAB_SUPG:
wf.add_matrix_form(callback(cg_biform));
wf.add_matrix_form(callback(stabilization_biform_supg));
break;
case CG_STAB_GLS:
wf.add_matrix_form(callback(cg_biform));
wf.add_matrix_form(callback(stabilization_biform_gls));
break;
case CG_STAB_SGS:
wf.add_matrix_form(callback(cg_biform));
wf.add_matrix_form(callback(stabilization_biform_sgs));
break;
case CG_STAB_SGS_ALT:
wf.add_matrix_form(callback(cg_biform));
wf.add_matrix_form(callback(stabilization_biform_sgs_alt));
break;
case DG:
wf.add_matrix_form(callback(dg_volumetric_biform_advection));
wf.add_matrix_form(callback(dg_volumetric_biform_diffusion));
wf.add_matrix_form_surf(callback(dg_interface_biform_advection), H2D_DG_INNER_EDGE);
wf.add_matrix_form_surf(callback(dg_interface_biform_diffusion), H2D_DG_INNER_EDGE);
wf.add_matrix_form_surf(callback(dg_boundary_biform_advection));
wf.add_matrix_form_surf(callback(dg_boundary_biform_diffusion));
wf.add_vector_form_surf(callback(dg_boundary_liform_advection));
wf.add_vector_form_surf(callback(dg_boundary_liform_diffusion));
break;
}
// Initialize coarse and reference mesh solution.
Solution sln, ref_sln;
// Set exact solution.
ExactSolution exact(&mesh, exact_sln);
// Initialize views.
ScalarView sview("Solution", new WinGeom(0, 0, 440, 350));
sview.fix_scale_width(50);
sview.show_mesh(false);
OrderView oview("Polynomial orders", new WinGeom(450, 0, 400, 350));
// DOF and CPU convergence graphs initialization.
SimpleGraph graph_dof, graph_cpu, graph_dof_exact, graph_cpu_exact;
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Adaptivity loop:
int as = 1;
bool done = false;
Space* actual_sln_space;
do
{
info("---- Adaptivity step %d:", as);
if (STRATEGY == -1)
actual_sln_space = space;
else
// Construct globally refined reference mesh and setup reference space.
actual_sln_space = Space::construct_refined_space(space, ORDER_INCREASE);
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, actual_sln_space, is_linear);
dp->assemble(matrix, rhs);
// Solve the linear system of the reference problem.
// If successful, obtain the solution.
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), actual_sln_space, &ref_sln);
else error ("Matrix solver failed.\n");
// Instantiate adaptivity and error calculation driver. Space is used only for adaptivity, it is ignored when
// STRATEGY == -1 and only the exact error is calculated by this object.
Adapt* adaptivity = new Adapt(space, norm);
// Calculate exact error.
bool solutions_for_adapt = false;
double err_exact_rel = calc_rel_error(&sln, &exact, HERMES_H1_NORM) * 100;
info("ndof_fine: %d, err_exact_rel: %g%%", Space::get_num_dofs(actual_sln_space), err_exact_rel);
// Time measurement.
cpu_time.tick();
// View the fine mesh solution and polynomial orders.
sview.show(&ref_sln);
oview.show(actual_sln_space);
// Skip visualization time.
cpu_time.tick(HERMES_SKIP);
if (STRATEGY == -1) done = true; // Do not adapt.
else
{
// Project the fine mesh solution onto the coarse mesh.
info("Projecting reference solution on coarse mesh.");
OGProjection::project_global(space, &ref_sln, &sln, matrix_solver, norm);
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
bool solutions_for_adapt = true;
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_REL) * 100;
// Report results.
info("ndof_coarse: %d, err_est_rel: %g%%", Space::get_num_dofs(space), err_est_rel);
// Time measurement.
cpu_time.tick();
// Add entry to DOF and CPU convergence graphs.
graph_dof.add_values(Space::get_num_dofs(space), err_est_rel);
graph_dof.save("conv_dof_est.dat");
graph_cpu.add_values(cpu_time.accumulated(), err_est_rel);
graph_cpu.save("conv_cpu_est.dat");
graph_dof_exact.add_values(Space::get_num_dofs(space), err_exact_rel);
graph_dof_exact.save("conv_dof_exact.dat");
graph_cpu_exact.add_values(cpu_time.accumulated(), err_exact_rel);
graph_cpu_exact.save("conv_cpu_exact.dat");
// Skip graphing time.
cpu_time.tick(HERMES_SKIP);
// If err_est too large, adapt the mesh.
if (err_exact_rel < ERR_STOP) done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
// Increase the counter of performed adaptivity steps.
if (done == false) as++;
}
if (Space::get_num_dofs(space) >= NDOF_STOP) done = true;
if(done == false)
{
delete actual_sln_space->get_mesh();
delete actual_sln_space;
}
}
// Clean up.
delete adaptivity;
delete dp;
}
while (done == false);
if (space != actual_sln_space)
{
delete space;
delete actual_sln_space->get_mesh();
}
delete actual_sln_space;
delete solver;
delete matrix;
delete rhs;
delete selector;
verbose("Total running time: %g s", cpu_time.accumulated());
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char **args)
{
// Test variable.
int success_test = 1;
if (argc < 3) error("Not enough parameters.");
// Load the mesh.
Mesh mesh;
H3DReader mloader;
if (!mloader.load(args[1], &mesh)) error("Loading mesh file '%s'.", args[1]);
// Initialize the space according to the
// command-line parameters passed.
int o = 4;
sscanf(args[2], "%d", &o);
H1Space space(&mesh, bc_types, NULL, o);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, HERMES_SYM);
wf.add_matrix_form_surf(bilinear_form_surf<double, scalar>, bilinear_form_surf<Ord, Ord>);
wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>);
wf.add_vector_form_surf(linear_form_surf<double, scalar>, linear_form_surf<Ord, Ord>);
// Initialize the FE problem.
bool is_linear = true;
DiscreteProblem dp(&wf, &space, is_linear);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Initialize the preconditioner in the case of SOLVER_AZTECOO.
if (matrix_solver == SOLVER_AZTECOO)
{
((AztecOOSolver*) solver)->set_solver(iterative_method);
((AztecOOSolver*) solver)->set_precond(preconditioner);
// Using default iteration parameters (see solver/aztecoo.h).
}
// Assemble the linear problem.
info("Assembling (ndof: %d).", Space::get_num_dofs(&space));
dp.assemble(matrix, rhs);
// Solve the linear system. If successful, obtain the solution.
info("Solving.");
Solution sln(&mesh);
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), &space, &sln);
else error ("Matrix solver failed.\n");
ExactSolution ex_sln(&mesh, exact_solution);
// Calculate exact error.
info("Calculating exact error.");
Adapt *adaptivity = new Adapt(&space, HERMES_H1_NORM);
bool solutions_for_adapt = false;
double err_exact = adaptivity->calc_err_exact(&sln, &ex_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_ABS);
if (err_exact > EPS)
// Calculated solution is not precise enough.
success_test = 0;
// Clean up.
delete matrix;
delete rhs;
delete solver;
delete adaptivity;
if (success_test) {
info("Success!");
return ERR_SUCCESS;
}
else {
info("Failure!");
return ERR_FAILURE;
}
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("cathedral.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(BDY_AIR, INIT_REF_NUM_BDY);
mesh.refine_towards_boundary(BDY_GROUND, INIT_REF_NUM_BDY);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(Hermes::vector<std::string>(BDY_GROUND));
bc_types.add_bc_newton(BDY_AIR);
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_const(BDY_GROUND, TEMP_INIT);
// Initialize an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d.", ndof);
// Previous time level solution (initialized by the external temperature).
Solution tsln(&mesh, TEMP_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form));
wf.add_matrix_form_surf(callback(bilinear_form_surf), BDY_AIR);
wf.add_vector_form(callback(linear_form), HERMES_ANY, &tsln);
wf.add_vector_form_surf(callback(linear_form_surf), BDY_AIR);
// Initialize the FE problem.
bool is_linear = true;
DiscreteProblem dp(&wf, &space, is_linear);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
solver->set_factorization_scheme(HERMES_REUSE_FACTORIZATION_COMPLETELY);
// Initialize views.
ScalarView Tview("Temperature", new WinGeom(0, 0, 450, 600));
Tview.set_min_max_range(0,20);
Tview.fix_scale_width(30);
// Time stepping:
int ts = 1; bool rhs_only = false;
do
{
info("---- Time step %d, time %3.5f s, ext_temp %g C", ts, current_time, temp_ext(current_time));
// First time assemble both the stiffness matrix and right-hand side vector,
// then just the right-hand side vector.
if (rhs_only == false) info("Assembling the stiffness matrix and right-hand side vector.");
else info("Assembling the right-hand side vector (only).");
dp.assemble(matrix, rhs, rhs_only);
rhs_only = true;
// Solve the linear system and if successful, obtain the solution.
info("Solving the matrix problem.");
if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), &space, &tsln);
else error ("Matrix solver failed.\n");
// Visualize the solution.
char title[100];
sprintf(title, "Time %3.2f s, exterior temperature %3.5f C", current_time, temp_ext(current_time));
Tview.set_title(title);
Tview.show(&tsln);
// Increase current time and time step counter.
current_time += time_step;
ts++;
}
while (current_time < T_FINAL);
// Wait for the view to be closed.
View::wait();
return 0;
}
