int main(int argc, char* argv[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh basemesh, mesh_T, mesh_phi;
H2DReader mloader;
mloader.load("domain.mesh", &basemesh);
// Perform initial mesh refinements.
for (int i=0; i < INIT_GLOB_REF_NUM; i++)
basemesh.refine_all_elements();
basemesh.refine_towards_boundary(1, INIT_BDY_REF_NUM);
// Create a special mesh for each physical field.
mesh_T.copy(&basemesh);
mesh_phi.copy(&basemesh);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_DIRICHLET);
// Enter Dirichlet boudnary values.
BCValues bc_values;
bc_values.add_zero(BDY_DIRICHLET);
// Create H1 spaces with default shapesets.
H1Space space_T(&mesh_T, &bc_types, &bc_values, P_INIT);
H1Space space_phi(&mesh_phi, &bc_types, &bc_values, P_INIT);
Hermes::vector<Space*> spaces(&space_T, &space_phi);
int ndof = Space::get_num_dofs(spaces);
// Solutions in the previous time step (converging within the time stepping loop).
Solution T_prev_time, phi_prev_time;
Hermes::vector<Solution*> prev_time_solutions(&T_prev_time, &phi_prev_time);
// Solutions on the coarse and refined meshes in current time step (converging within the Newton's loop).
Solution T_coarse, phi_coarse, T_fine, phi_fine;
Hermes::vector<Solution*> coarse_mesh_solutions(&T_coarse, &phi_coarse);
Hermes::vector<Solution*> fine_mesh_solutions(&T_fine, &phi_fine);
// Initialize the weak formulation.
WeakForm wf(2);
wf.add_matrix_form(0, 0, jac_TT, jac_TT_ord);
wf.add_matrix_form(0, 1, jac_Tphi, jac_Tphi_ord);
wf.add_vector_form(0, res_T, res_T_ord, HERMES_ANY, &T_prev_time);
wf.add_matrix_form(1, 0, jac_phiT, jac_phiT_ord);
wf.add_matrix_form(1, 1, jac_phiphi, jac_phiphi_ord);
wf.add_vector_form(1, res_phi, res_phi_ord, HERMES_ANY, &phi_prev_time);
// Initialize solution views (their titles will be updated in each time step).
ScalarView view_T("", new WinGeom(460, 0, 450, 350));
view_T.fix_scale_width(80);
ScalarView view_T_exact("", new WinGeom(0, 0, 450, 350));
view_T_exact.fix_scale_width(80);
view_T_exact.show_mesh(false);
ScalarView view_phi("", new WinGeom(460, 400, 450, 350));
view_phi.fix_scale_width(80);
ScalarView view_phi_exact("", new WinGeom(0, 400, 450, 350));
view_phi_exact.fix_scale_width(80);
view_phi_exact.show_mesh(false);
// Initialize mesh views (their titles will be updated in each time step).
OrderView ordview_T_coarse("", new WinGeom(920, 0, 450, 350));
ordview_T_coarse.fix_scale_width(80);
OrderView ordview_phi_coarse("", new WinGeom(920, 400, 450, 350));
ordview_phi_coarse.fix_scale_width(80);
char title[100]; // Character array to store the title for an actual view and time step.
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est_T, graph_dof_exact_T, graph_cpu_est_T, graph_cpu_exact_T;
SimpleGraph graph_dof_est_phi, graph_dof_exact_phi, graph_cpu_est_phi, graph_cpu_exact_phi;
// Exact solutions for error evaluation.
ExactSolution T_exact_solution(&mesh_T, T_exact);
ExactSolution phi_exact_solution(&mesh_phi, phi_exact);
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize the nonlinear system.
bool is_linear = false;
DiscreteProblem dp(&wf, spaces, is_linear);
// Set initial conditions.
T_prev_time.set_exact(&mesh_T, T_exact);
phi_prev_time.set_exact(&mesh_phi, phi_exact);
// Newton's loop on the initial coarse meshes.
info("Solving on coarse meshes.");
scalar* coeff_vec_coarse = new scalar[Space::get_num_dofs(spaces)];
OGProjection::project_global(spaces, Hermes::vector<MeshFunction*>((MeshFunction*)&T_prev_time, (MeshFunction*)&phi_prev_time),
coeff_vec_coarse, matrix_solver_coarse);
// Initialize the discrete problem on coarse mesh.
DiscreteProblem dp_coarse(&wf, spaces, is_linear);
// Setup the solvers for the coarse and fine mesh calculations, respectively.
SparseMatrix* matrix_coarse = create_matrix(matrix_solver_coarse);
Vector* rhs_coarse = create_vector(matrix_solver_coarse);
Solver* solver_coarse = create_linear_solver(matrix_solver_coarse, matrix_coarse, rhs_coarse);
SparseMatrix* matrix_fine = create_matrix(matrix_solver_fine);
Vector* rhs_fine = create_vector(matrix_solver_fine);
Solver* solver_fine = create_linear_solver(matrix_solver_fine, matrix_fine, rhs_fine);
// Perform Newton's iteration.
info("Newton's solve on the initial coarse meshes.");
bool verbose = true;
if (!solve_newton(coeff_vec_coarse, &dp_coarse, solver_coarse, matrix_coarse, rhs_coarse, NEWTON_TOL_COARSE, NEWTON_MAX_ITER, verbose))
error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the actual solutions.
Solution::vector_to_solutions(coeff_vec_coarse, spaces, coarse_mesh_solutions);
delete [] coeff_vec_coarse;
// Time stepping loop:
int nstep = (int)(T_FINAL/TAU + 0.5);
for(int ts = 1; ts <= nstep; ts++)
{
// Update global time.
TIME = ts*TAU;
// Update time-dependent exact solutions.
T_exact_solution.update(&mesh_T, T_exact);
phi_exact_solution.update(&mesh_phi, phi_exact);
// Show exact solution.
view_T_exact.show(&T_exact_solution);
sprintf(title, "T (exact), t = %g s", TIME);
view_T_exact.set_title(title);
view_phi_exact.show(&phi_exact_solution);
sprintf(title, "phi (exact), t = %g s", TIME);
view_phi_exact.set_title(title);
// Periodic global derefinement.
if (ts > 1) {
if (ts % UNREF_FREQ == 0) {
info("---- Time step %d - prior to adaptivity:", ts);
info("Global mesh derefinement.");
mesh_T.copy(&basemesh);
mesh_phi.copy(&basemesh);
space_T.set_uniform_order(P_INIT);
space_phi.set_uniform_order(P_INIT);
if (SOLVE_ON_COARSE_MESH) {
// Newton's loop on the globally derefined meshes.
scalar* coeff_vec_coarse = new scalar[Space::get_num_dofs(spaces)];
info("Projecting previous fine mesh solution to obtain initial vector for Newton's iteration on globally derefined meshes.");
OGProjection::project_global(spaces, Hermes::vector<MeshFunction*>((MeshFunction*)&T_fine, (MeshFunction*)&phi_fine),
coeff_vec_coarse, matrix_solver_coarse);
// Initialize the FE problem.
DiscreteProblem dp_coarse(&wf, spaces, is_linear);
// Perform Newton's iteration.
info("Newton's solve on globally derefined meshes.");
bool verbose = true;
if (!solve_newton(coeff_vec_coarse, &dp_coarse, solver_coarse, matrix_coarse, rhs_coarse, NEWTON_TOL_COARSE, NEWTON_MAX_ITER, verbose))
error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the actual solutions.
Solution::vector_to_solutions(coeff_vec_coarse, spaces, coarse_mesh_solutions);
delete [] coeff_vec_coarse;
}
else {
// Projection onto the globally derefined meshes.
info("Projecting fine mesh solutions from previous time step onto globally derefined meshes.");
OGProjection::project_global(spaces, fine_mesh_solutions, coarse_mesh_solutions, matrix_solver_coarse);
}
}
delete T_fine.get_mesh();
delete phi_fine.get_mesh();
}
// Adaptivity loop:
bool done = false;
int as = 0;
do {
as++;
info("---- Time step %d, adaptivity step %d:", ts, as);
// Visualize intermediate solutions and mesh during adaptivity.
view_T.show(&T_coarse);
sprintf(title, "T (coarse mesh), t = %g s, adapt step %d", TIME, as);
view_T.set_title(title);
view_phi.show(&phi_coarse);
sprintf(title, "phi (coarse mesh), t = %g s, adapt step %d", TIME, as);
view_phi.set_title(title);
ordview_T_coarse.show(&space_T);
sprintf(title, "T mesh (coarse), t = %g, adapt step %d", TIME, as);
ordview_T_coarse.set_title(title);
ordview_phi_coarse.show(&space_phi);
sprintf(title, "phi mesh (coarse), t = %g, adapt step %d", TIME, as);
ordview_phi_coarse.set_title(title);
// Construct globally refined reference mesh
// and setup reference space.
Hermes::vector<Space *>* ref_spaces = construct_refined_spaces(spaces, ORDER_INCREASE);
// Newton's loop on the refined meshes.
scalar* coeff_vec = new scalar[Space::get_num_dofs(*ref_spaces)];
if (as == 1) {
info("Projecting coarse mesh solution to obtain coefficients vector on new fine mesh.");
OGProjection::project_global(*ref_spaces, Hermes::vector<MeshFunction*>((MeshFunction*)&T_coarse, (MeshFunction*)&phi_coarse),
coeff_vec, matrix_solver_fine);
} else {
info("Projecting previous fine mesh solution to obtain coefficients vector on new fine mesh.");
OGProjection::project_global(*ref_spaces, Hermes::vector<MeshFunction*>((MeshFunction*)&T_fine, (MeshFunction*)&phi_fine),
coeff_vec, matrix_solver_fine);
// Deallocate the previous fine mesh.
// FIXME: This is terribly non-transparent. Solution::vector_to_solutions (called few lines below) deletes the solution's mesh
// (and makes Solution::own_mesh = false), so phi_fine.get_mesh() actually points to memory originally allocated by phi's ref_space
// (which however does not exist any more at this point as it gets deallocated at the end of the loop).
delete T_fine.get_mesh();
delete phi_fine.get_mesh();
}
// Initialize the FE problem.
DiscreteProblem dp(&wf, *ref_spaces, is_linear);
// Perform Newton's iteration.
info("Newton's solve on fine meshes.");
bool verbose = true;
if (!solve_newton(coeff_vec, &dp, solver_fine, matrix_fine, rhs_fine, NEWTON_TOL_FINE, NEWTON_MAX_ITER, verbose))
error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the actual solutions.
Solution::vector_to_solutions(coeff_vec, *ref_spaces, fine_mesh_solutions);
delete [] coeff_vec;
if (SOLVE_ON_COARSE_MESH) {
// Newton's loop on the new coarse meshes.
scalar* coeff_vec_coarse = new scalar[Space::get_num_dofs(spaces)];
info("Projecting fine mesh solutions back onto coarse mesh to obtain initial vector for following Newton's iteration.");
OGProjection::project_global(spaces, Hermes::vector<MeshFunction*>((MeshFunction*)&T_fine, (MeshFunction*)&phi_fine),
coeff_vec_coarse, matrix_solver_coarse);
// Initialize the FE problem.
DiscreteProblem dp_coarse(&wf, spaces, is_linear);
// Perform Newton's iteration.
info("Newton's solve on coarse meshes.");
bool verbose = true;
if (!solve_newton(coeff_vec_coarse, &dp_coarse, solver_coarse, matrix_coarse, rhs_coarse, NEWTON_TOL_COARSE, NEWTON_MAX_ITER, verbose))
error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the actual solutions.
Solution::vector_to_solutions(coeff_vec_coarse, spaces, coarse_mesh_solutions);
delete [] coeff_vec_coarse;
}
else {
// Projection onto the new coarse meshes.
info("Projecting fine mesh solutions back onto coarse meshes.");
OGProjection::project_global(spaces, fine_mesh_solutions, coarse_mesh_solutions, matrix_solver_coarse);
}
// Calculate element errors.
info("Calculating error estimate and exact error.");
Adapt* adaptivity = new Adapt(spaces);
// Calculate error estimate for each solution component and the total error estimate.
Hermes::vector<double> err_est_rel;
double err_est_rel_total = adaptivity->calc_err_est(coarse_mesh_solutions, fine_mesh_solutions, &err_est_rel) * 100;
// Calculate exact error for each solution component and the total exact error.
bool solutions_for_adapt = false;
Hermes::vector<double> err_exact_rel;
double err_exact_rel_total = adaptivity->calc_err_exact(coarse_mesh_solutions,
Hermes::vector<Solution *>(&T_exact_solution, &phi_exact_solution),
&err_exact_rel, solutions_for_adapt) * 100;
info("T: ndof_coarse: %d, ndof_fine: %d, err_est: %g %%, err_exact: %g %%",
space_T.get_num_dofs(), (*ref_spaces)[0]->get_num_dofs(), err_est_rel[0]*100, err_exact_rel[0]*100);
info("phi: ndof_coarse: %d, ndof_fine: %d, err_est: %g %%, err_exact: %g %%",
space_phi.get_num_dofs(), (*ref_spaces)[1]->get_num_dofs(), err_est_rel[1]*100, err_exact_rel[1]*100);
/*
if (ts==1) {
// Add entries to DOF convergence graph.
graph_dof_exact_T.add_values(space_T.Space::get_num_dofs(), T_err_exact);
graph_dof_exact_T.save("conv_dof_exact_T.dat");
graph_dof_est_T.add_values(space_T.Space::get_num_dofs(), T_err_est);
graph_dof_est_T.save("conv_dof_est_T.dat");
graph_dof_exact_phi.add_values(space_phi.Space::get_num_dofs(), phi_err_exact);
graph_dof_exact_phi.save("conv_dof_exact_phi.dat");
graph_dof_est_phi.add_values(space_phi.Space::get_num_dofs(), phi_err_est);
graph_dof_est_phi.save("conv_dof_est_phi.dat");
// Add entries to CPU convergence graph.
graph_cpu_exact_T.add_values(cpu_time.accumulated(), T_err_exact);
graph_cpu_exact_T.save("conv_cpu_exact_T.dat");
graph_cpu_est_T.add_values(cpu_time.accumulated(), T_err_est);
graph_cpu_est_T.save("conv_cpu_est_T.dat");
graph_cpu_exact_phi.add_values(cpu_time.accumulated(), phi_err_exact);
graph_cpu_exact_phi.save("conv_cpu_exact_phi.dat");
graph_cpu_est_phi.add_values(cpu_time.accumulated(), phi_err_est);
graph_cpu_est_phi.save("conv_cpu_est_phi.dat");
}
*/
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP) done = true;
else {
info("Adapting the coarse meshes.");
done = adaptivity->adapt(Hermes::vector<RefinementSelectors::Selector*> (&selector, &selector), THRESHOLD, STRATEGY, MESH_REGULARITY);
if (Space::get_num_dofs(spaces) >= NDOF_STOP) done = true;
}
delete adaptivity;
for (unsigned int i = 0; i < ref_spaces->size(); i++)
delete ref_spaces->at(i); // Mesh dynamically allocated for each space is held by the corresponding reference solution.
delete ref_spaces;
}
while (!done);
// Visualize final adapted mesh and solutions in current time step.
view_T.show(&T_coarse);
sprintf(title, "T (coarse mesh), t = %g s, final mesh", TIME);
view_T.set_title(title);
view_phi.show(&phi_coarse);
sprintf(title, "phi (coarse mesh), t = %g s, final mesh", TIME);
view_phi.set_title(title);
ordview_T_coarse.show(&space_T);
sprintf(title, "T mesh (coarse), t = %g, final mesh", TIME);
ordview_T_coarse.set_title(title);
ordview_phi_coarse.show(&space_phi);
sprintf(title, "phi mesh (coarse), t = %g, final mesh", TIME);
ordview_phi_coarse.set_title(title);
// Make the fine mesh solution at current time level the previous time level solution in the following time step.
T_prev_time.copy(&T_fine);
phi_prev_time.copy(&phi_fine);
}
delete T_fine.get_mesh();
delete phi_fine.get_mesh();
delete rhs_coarse;
delete matrix_coarse;
delete solver_coarse;
delete rhs_fine;
delete matrix_fine;
delete solver_fine;
// Wait for all views to be closed.
View::wait();
return 0;
}
// Main function.
int main(int argc, char* argv[])
{
info("Desired eigenfunction to calculate: %d.", TARGET_EIGENFUNCTION);
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial mesh refinements (optional).
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::vector<int>(BDY_MARKER));
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_zero(Hermes::vector<int>(BDY_MARKER));
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
// Initialize the weak formulation for the left hand side, i.e., H.
WeakForm wf_S, wf_M;
wf_S.add_matrix_form(bilinear_form_S, bilinear_form_S_ord);
wf_M.add_matrix_form(callback(bilinear_form_M));
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
ScalarView sview("", new WinGeom(0, 0, 440, 350));
sview.fix_scale_width(50);
OrderView oview("", new WinGeom(450, 0, 410, 350));
// DOF convergence graph.
SimpleGraph graph_dof;
// Initialize matrices and matrix solver.
SparseMatrix* matrix_S = create_matrix(matrix_solver);
SparseMatrix* matrix_M = create_matrix(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix_S);
// Assemble matrices S and M on coarse mesh.
info("Assembling matrices S and M on coarse mesh.");
bool is_linear = true;
DiscreteProblem dp_S(&wf_S, &space, is_linear);
dp_S.assemble(matrix_S);
DiscreteProblem dp_M(&wf_M, &space, is_linear);
dp_M.assemble(matrix_M);
// Write matrix_S in MatrixMarket format.
write_matrix_mm("mat_S.mtx", matrix_S);
// Write matrix_M in MatrixMarket format.
write_matrix_mm("mat_M.mtx", matrix_M);
// Call Python eigensolver. Solution will be written to "eivecs.dat".
info("Calling Pysparse.");
char call_cmd[255];
sprintf(call_cmd, "python solveGenEigenFromMtx.py mat_S.mtx mat_M.mtx %g %d %g %d",
PYSPARSE_TARGET_VALUE, TARGET_EIGENFUNCTION, PYSPARSE_TOL, PYSPARSE_MAX_ITER);
system(call_cmd);
info("Pysparse finished.");
// Initialize eigenvector.
double* coeff_vec = new double[ndof];
// Read solution vectors from file and visualize it.
double* eigenval =new double[TARGET_EIGENFUNCTION];
FILE *file = fopen("eivecs.dat", "r");
char line [64]; // Maximum line size.
fgets(line, sizeof line, file); // ndof
int n = atoi(line);
if (n != ndof) error("Mismatched ndof in the eigensolver output file.");
fgets(line, sizeof line, file); // Number of eigenvectors in the file.
int neig = atoi(line);
if (neig != TARGET_EIGENFUNCTION) error("Mismatched number of eigenvectors in the eigensolver output file.");
for (int ieig = 0; ieig < neig; ieig++) {
// Get next eigenvalue from the file
fgets(line, sizeof line, file); // eigenval
eigenval[ieig] = atof(line);
// Get the corresponding eigenvector.
for (int i = 0; i < ndof; i++) {
fgets(line, sizeof line, file);
coeff_vec[i] = atof(line);
}
// Normalize the eigenvector.
normalize((UMFPackMatrix*)matrix_M, coeff_vec, ndof);
}
fclose(file);
// Eigenvalue.
double lambda = eigenval[neig-1];
info("Eigenvalue on coarse mesh: %g", lambda);
info("Once more just to check: %g", calc_mass_product((UMFPackMatrix*)matrix_S, coeff_vec, ndof)
/ calc_mass_product((UMFPackMatrix*)matrix_M, coeff_vec, ndof));
// Convert eigenvector into eigenfunction. After this, the
// eigenvector on the coarse mesh will not be needed anymore.
Solution sln;
Solution::vector_to_solution(coeff_vec, &space, &sln);
delete [] coeff_vec;
// Visualize the eigenfunction.
info("Plotting initial eigenfunction on coarse mesh.");
char title[100];
sprintf(title, "Eigenfunction %d on initial mesh", neig);
sview.set_title(title);
sview.show_mesh(false);
sview.show(&sln);
sprintf(title, "Initial mesh");
oview.set_title(title);
oview.show(&space);
View::wait(HERMES_WAIT_KEYPRESS);
/*** Begin adaptivity ***/
// Adaptivity loop:
Solution ref_sln;
Space* ref_space = NULL;
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
ref_space = construct_refined_space(&space);
int ndof_ref = Space::get_num_dofs(ref_space);
info("ndof: %d, ndof_ref: %d", ndof, ndof_ref);
// Obtain initial approximation on new reference mesh.
double* coeff_vec_ref = new double[ndof_ref];
if (as == 1) {
// Project the coarse mesh eigenfunction to the reference mesh.
info("Projecting coarse mesh solution to reference mesh.");
OGProjection::project_global(ref_space, &sln, coeff_vec_ref, matrix_solver);
}
else {
// Project the last reference mesh solution to the reference mesh.
info("Projecting last reference mesh solution to new reference mesh.");
OGProjection::project_global(ref_space, &ref_sln, coeff_vec_ref, matrix_solver);
}
Solution::vector_to_solution(coeff_vec_ref, ref_space, &ref_sln);
// Initialize matrices and matrix solver on reference mesh.
SparseMatrix* matrix_S_ref = create_matrix(matrix_solver);
SparseMatrix* matrix_M_ref = create_matrix(matrix_solver);
// Assemble matrices S and M on reference mesh.
info("Assembling matrices S and M on reference mesh.");
is_linear = true;
DiscreteProblem dp_S_ref(&wf_S, ref_space, is_linear);
matrix_S_ref->zero();
dp_S_ref.assemble(matrix_S_ref);
DiscreteProblem dp_M_ref(&wf_M, ref_space, is_linear);
matrix_M_ref->zero();
dp_M_ref.assemble(matrix_M_ref);
// Calculate eigenvalue corresponding to the new reference solution.
lambda = calc_mass_product((UMFPackMatrix*)matrix_S_ref, coeff_vec_ref, ndof_ref)
/ calc_mass_product((UMFPackMatrix*)matrix_M_ref, coeff_vec_ref, ndof_ref);
info("Initial guess for eigenvalue on reference mesh: %.12f", lambda);
if (ITERATIVE_METHOD == 1) {
// Newton's method on the reference mesh.
if(!solve_newton_eigen(ref_space, (UMFPackMatrix*)matrix_S_ref, (UMFPackMatrix*)matrix_M_ref,
coeff_vec_ref, lambda, matrix_solver, NEWTON_TOL, NEWTON_MAX_ITER))
error("Newton's method failed.");
}
else {
// Picard's method on the reference mesh.
if(!solve_picard_eigen(ref_space, (UMFPackMatrix*)matrix_S_ref, (UMFPackMatrix*)matrix_M_ref,
coeff_vec_ref, lambda, matrix_solver, PICARD_TOL, PICARD_MAX_ITER))
error("Picard's method failed.");
}
Solution::vector_to_solution(coeff_vec_ref, ref_space, &ref_sln);
// Clean up.
delete matrix_S_ref;
delete matrix_M_ref;
delete [] coeff_vec_ref;
// Project reference solution to coarse mesh for error estimation.
if (as > 1) {
// Project reference solution to coarse mesh.
info("Projecting reference solution to coarse mesh for error calculation.");
OGProjection::project_global(&space, &ref_sln, &sln, matrix_solver);
// Visualize the projection.
info("Plotting projection of reference solution to new coarse mesh.");
char title[100];
sprintf(title, "Coarse mesh projection");
sview.set_title(title);
sview.show_mesh(false);
sview.show(&sln);
sprintf(title, "Coarse mesh, step %d", as);
oview.set_title(title);
oview.show(&space);
// Wait for keypress.
View::wait(HERMES_WAIT_KEYPRESS);
}
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt* adaptivity = new Adapt(&space);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 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);
// 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");
// 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++;
}
ndof = Space::get_num_dofs(&space);
if (ndof >= NDOF_STOP) done = true;
// Clean up.
delete adaptivity;
//delete ref_space->get_mesh();
delete ref_space;
}
while (done == false);
// Wait for all views to be closed.
info("Computation finished.");
View::wait();
return 0;
};
int main(int argc, char* argv[])
{
// Instantiate a class with global functions.
Hermes2D hermes2d;
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("square_quad.mesh", &mesh);
// Avoid zero ndof situation.
if (P_INIT == 1) {
if (is_hp(CAND_LIST)) P_INIT++;
else mesh.refine_element_id(0, 0);
}
// Define exact solution.
CustomExactSolution exact_sln(&mesh);
// Define right side vector.
CustomRightHandSide rsv;
// Initialize the weak formulation.
CustomWeakFormPoisson wf(&rsv);
// Initialize boundary conditions.
DefaultEssentialBCConst bc_essential(BDY_DIRICHLET, 0.0);
EssentialBCs bcs(&bc_essential);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bcs, P_INIT);
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// 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 = Space::construct_refined_space(&space);
// 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);
// Assemble the reference problem.
info("Solving on reference mesh.");
DiscreteProblem* dp = new DiscreteProblem(&wf, ref_space);
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);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 100;
// Calculate exact error.
double err_exact_rel = hermes2d.calc_rel_error(&sln, &exact_sln, HERMES_H1_NORM) * 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 **args)
{
// Test variable.
int success_test = 1;
if (argc < 5) 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.
sscanf(args[2], "%d", &P_INIT_X);
sscanf(args[3], "%d", &P_INIT_Y);
sscanf(args[4], "%d", &P_INIT_Z);
Ord3 order(P_INIT_X, P_INIT_Y, P_INIT_Z);
H1Space space(&mesh, bc_types, essential_bc_values, order);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, HERMES_SYM, HERMES_ANY);
wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>, HERMES_ANY);
// 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, 1);
out_orders_vtk(ref_space, "space", as);
// Initialize the FE problem.
bool is_linear = true;
DiscreteProblem lp(&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));
lp.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 {
info("Matrix solver failed.");
success_test = 0;
}
// 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);
// Time measurement.
cpu_time.tick();
// 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) * 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_est_rel);
// If err_est_rel is too large, adapt the mesh.
if (err_est_rel < ERR_STOP) {
done = true;
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;
break;
}
else {
info("Adapting coarse mesh.");
adaptivity->adapt(THRESHOLD);
}
// If we reached the maximum allowed number of degrees of freedom, set the return flag to failure.
if (Space::get_num_dofs(&space) >= NDOF_STOP)
{
done = true;
success_test = 0;
}
// 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);
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, basemesh;
H2DReader mloader;
mloader.load("square.mesh", &basemesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) basemesh.refine_all_elements();
mesh.copy(&basemesh);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(Hermes::vector<int>(BDY_BOTTOM, BDY_RIGHT, BDY_TOP, BDY_LEFT));
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_zero(Hermes::vector<int>(BDY_BOTTOM, BDY_RIGHT, BDY_TOP, BDY_LEFT));
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
// Initialize coarse and reference mesh solution.
Solution sln, ref_sln;
// Convert initial condition into a Solution.
Solution sln_prev_time;
sln_prev_time.set_exact(&mesh, init_cond);
// Initialize the weak formulation.
WeakForm wf;
if(TIME_DISCR == 1) {
wf.add_matrix_form(callback(J_euler), HERMES_NONSYM, HERMES_ANY);
wf.add_vector_form(callback(F_euler), HERMES_ANY, &sln_prev_time);
}
else {
wf.add_matrix_form(callback(J_cranic), HERMES_NONSYM, HERMES_ANY);
wf.add_vector_form(callback(F_cranic), HERMES_ANY, &sln_prev_time);
}
// Initialize the discrete problem.
bool is_linear = false;
DiscreteProblem dp_coarse(&wf, &space, is_linear);
// Create a refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Visualize initial condition.
char title[100];
ScalarView view("Initial condition", new WinGeom(0, 0, 450, 350));
view.fix_scale_width(70);
view.show(&sln_prev_time);
OrderView ordview("Initial mesh", new WinGeom(455, 0, 410, 350));
ordview.fix_scale_width(10);
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++)
{
// 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);
}
// The following is done only in the first time step,
// when the nonlinear problem was never solved before.
if (ts == 1) {
// Set up the solver, matrix, and rhs for the coarse mesh according to the solver selection.
SparseMatrix* matrix_coarse = create_matrix(matrix_solver);
Vector* rhs_coarse = create_vector(matrix_solver);
Solver* solver_coarse = create_linear_solver(matrix_solver, matrix_coarse, rhs_coarse);
scalar* coeff_vec_coarse = new scalar[ndof];
// Calculate initial coefficient vector for Newton on the coarse mesh.
info("Projecting initial condition to obtain coefficient vector on coarse mesh.");
OGProjection::project_global(&space, &sln_prev_time, coeff_vec_coarse, matrix_solver);
// Newton's loop on the coarse mesh.
info("Solving on coarse mesh:");
bool verbose = true;
if (!solve_newton(coeff_vec_coarse, &dp_coarse, solver_coarse, matrix_coarse, rhs_coarse,
NEWTON_TOL_COARSE, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
Solution::vector_to_solution(coeff_vec_coarse, &space, &sln);
// Cleanup after the Newton loop on the coarse mesh.
delete matrix_coarse;
delete rhs_coarse;
delete solver_coarse;
delete [] coeff_vec_coarse;
}
// Adaptivity loop. Note: sln_prev_time must not be changed during spatial adaptivity.
bool done = false; int as = 1;
double err_est;
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);
// Initialize matrix solver.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
scalar* coeff_vec = new scalar[Space::get_num_dofs(ref_space)];
// Initialize discrete problem on reference mesh.
DiscreteProblem* dp = new DiscreteProblem(&wf, ref_space, is_linear);
// Calculate initial coefficient vector for Newton on the fine mesh.
if (ts == 1 && as == 1) {
info("Projecting coarse mesh solution to obtain coefficient vector on fine mesh.");
OGProjection::project_global(ref_space, &sln, coeff_vec, matrix_solver);
}
else {
info("Projecting last fine mesh solution to obtain coefficient vector on new fine mesh.");
OGProjection::project_global(ref_space, &ref_sln, coeff_vec, matrix_solver);
}
// Now we can deallocate the previous fine mesh.
if(as > 1) delete ref_sln.get_mesh();
// Newton's loop on the fine mesh.
info("Solving on fine mesh:");
bool verbose = true;
if (!solve_newton(coeff_vec, dp, solver, matrix, rhs,
NEWTON_TOL_FINE, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Store the result in ref_sln.
Solution::vector_to_solution(coeff_vec, ref_space, &ref_sln);
// Project the fine mesh solution onto the coarse mesh.
info("Projecting fine mesh solution on coarse mesh for error estimation.");
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);
double err_est_rel_total = adaptivity->calc_err_est(&sln, &ref_sln) * 100;
// Report results.
info("ndof: %d, ref_ndof: %d, err_est_rel: %g%%",
Space::get_num_dofs(&space), Space::get_num_dofs(ref_space), err_est_rel_total);
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP) 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 solver;
delete matrix;
delete rhs;
delete adaptivity;
delete ref_space;
delete dp;
delete [] coeff_vec;
}
while (done == false);
// Visualize the solution and mesh.
char title[100];
sprintf(title, "Solution, time %g", ts*TAU);
view.set_title(title);
view.show_mesh(false);
view.show(&sln);
sprintf(title, "Mesh, time %g", ts*TAU);
ordview.set_title(title);
ordview.show(&space);
// Copy last reference 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[])
{
// Instantiate a class with global functions.
Hermes2D hermes2d;
// 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();
// Set exact solution.
CustomExactSolution exact(&mesh, EPSILON);
// Define right-hand side.
CustomRightHandSide rhs(EPSILON);
// Initialize the weak formulation.
CustomWeakForm wf(&rhs);
// Initialize boundary conditions
DefaultEssentialBCNonConst bc_esssential("Bdy", &exact);
EssentialBCs bcs(&bc_esssential);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bcs, P_INIT);
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// 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 = Space::construct_refined_space(&space);
int ndof_ref = Space::get_num_dofs(ref_space);
// Initialize matrix solver.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Initialize reference problem.
info("Solving on reference mesh.");
DiscreteProblem dp(&wf, ref_space);
// Time measurement.
cpu_time.tick();
// Initial coefficient vector for the Newton's method.
scalar* coeff_vec = new scalar[ndof_ref];
memset(coeff_vec, 0, ndof_ref * sizeof(scalar));
// Perform Newton's iteration.
if (!hermes2d.solve_newton(coeff_vec, &dp, solver, matrix, rhs)) error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the Solution sln.
Solution ref_sln;
Solution::vector_to_solution(coeff_vec, ref_space, &ref_sln);
delete [] coeff_vec;
// 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);
// 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 for each solution component.
double err_exact_rel = hermes2d.calc_rel_error(&sln, &exact, HERMES_H1_NORM) * 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;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
int ndof = Space::get_num_dofs(&space);
int n_dof_allowed = 135;
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* argv[])
{
// Instantiate a class with global functions.
Hermes2D hermes2d;
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial uniform mesh refinement.
for (int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Set essential boundary conditions.
DefaultEssentialBCConst bc_essential(Hermes::vector<std::string>("right", "top"), 0.0);
EssentialBCs bcs(&bc_essential);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bcs, P_INIT);
// Associate element markers (corresponding to physical regions)
// with material properties (diffusion coefficient, absorption
// cross-section, external sources).
Hermes::vector<std::string> regions("1", "2", "3", "4", "5");
Hermes::vector<double> D_map(D_1, D_2, D_3, D_4, D_5);
Hermes::vector<double> Sigma_a_map(SIGMA_A_1, SIGMA_A_2, SIGMA_A_3, SIGMA_A_4, SIGMA_A_5);
Hermes::vector<double> Sources_map(Q_EXT_1, 0.0, Q_EXT_3, 0.0, 0.0);
// Initialize the weak formulation.
WeakFormsNeutronDiffusion::DefaultWeakFormSimpleMonoenergetic
wf(regions, D_map, Sigma_a_map, Sources_map);
// Initialize coarse and reference mesh solution.
Solution sln, ref_sln;
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// 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;
// 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 = Space::construct_refined_space(&space);
int ndof_ref = Space::get_num_dofs(ref_space);
// Initialize the FE problem.
DiscreteProblem dp(&wf, ref_space);
// Initialize the FE problem.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Initial coefficient vector for the Newton's method.
scalar* coeff_vec = new scalar[ndof_ref];
memset(coeff_vec, 0, ndof_ref*sizeof(scalar));
// Perform Newton's iteration on reference emesh.
info("Solving on reference mesh.");
if (!hermes2d.solve_newton(coeff_vec, &dp, solver, matrix, rhs)) error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the Solution sln.
Solution::vector_to_solution(coeff_vec, ref_space, &ref_sln);
// 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);
// Time measurement.
cpu_time.tick();
// View the coarse mesh solution and polynomial orders.
sview.show(&sln);
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);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 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 [] coeff_vec;
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false) delete ref_space->get_mesh();
delete ref_space;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// Show the reference solution - the final result.
sview.set_title("Fine mesh solution");
sview.show_mesh(false);
sview.show(&ref_sln);
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
MeshReaderH2D mloader;
mloader.load("channel.mesh", &mesh);
// Perform initial mesh refinements.
for (int i = 0; i < INIT_REF_NUM; i++)
mesh.refine_all_elements(0, true);
// Initialize boundary condition types and spaces with default shapesets.
L2Space<double> space_rho(&mesh, P_INIT);
L2Space<double> space_rho_v_x(&mesh, P_INIT);
L2Space<double> space_rho_v_y(&mesh, P_INIT);
L2Space<double> space_e(&mesh, P_INIT);
// Initialize solutions, set initial conditions.
ConstantSolution<double> sln_rho(&mesh, RHO_INIT);
ConstantSolution<double> sln_rho_v_x(&mesh, RHO_INIT * V1_INIT);
ConstantSolution<double> sln_rho_v_y(&mesh, RHO_INIT * V2_INIT);
ConstantSolution<double> sln_e(&mesh, QuantityCalculator::calc_energy(RHO_INIT, RHO_INIT * V1_INIT, RHO_INIT * V2_INIT, PRESSURE_INIT, KAPPA));
ConstantSolution<double> prev_rho(&mesh, RHO_INIT);
ConstantSolution<double> prev_rho_v_x(&mesh, RHO_INIT * V1_INIT);
ConstantSolution<double> prev_rho_v_y(&mesh, RHO_INIT * V2_INIT);
ConstantSolution<double> prev_e(&mesh, QuantityCalculator::calc_energy(RHO_INIT, RHO_INIT * V1_INIT, RHO_INIT * V2_INIT, PRESSURE_INIT, KAPPA));
Solution<double> rsln_rho, rsln_rho_v_x, rsln_rho_v_y, rsln_e;
// Numerical flux.
OsherSolomonNumericalFlux num_flux(KAPPA);
// For saving to the disk.
Continuity<double> continuity(Continuity<double>::onlyNumber);
// Initialize weak formulation.
EulerEquationsWeakFormSemiImplicitMultiComponentTwoInflows wf(&num_flux, KAPPA, RHO_LEFT, V1_LEFT, V2_LEFT, PRESSURE_LEFT, RHO_TOP, V1_TOP, V2_TOP, PRESSURE_TOP, BDY_SOLID_WALL, BDY_INLET_LEFT, BDY_INLET_TOP, BDY_OUTLET,
&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e);
// Filters for visualization of Mach number, pressure and entropy.
MachNumberFilter Mach_number(Hermes::vector<MeshFunction<double>*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e), KAPPA);
PressureFilter pressure(Hermes::vector<MeshFunction<double>*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e), KAPPA);
EntropyFilter entropy(Hermes::vector<MeshFunction<double>*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e), KAPPA, RHO_INIT, P_INIT);
ScalarView pressure_view("Pressure", new WinGeom(0, 0, 600, 300));
ScalarView Mach_number_view("Mach number", new WinGeom(700, 0, 600, 300));
ScalarView entropy_production_view("Entropy estimate", new WinGeom(0, 400, 600, 300));
// Initialize refinement selector.
L2ProjBasedSelector<double> selector(CAND_LIST, CONV_EXP, MAX_P_ORDER);
selector.set_error_weights(1.0, 1.0, 1.0);
// Set up CFL calculation class.
CFLCalculation CFL(CFL_NUMBER, KAPPA);
// Time stepping loop.
int iteration = 0; double t = 0;
for(; t < 5.0; t += time_step)
{
info("---- Time step %d, time %3.5f.", iteration++, t);
// Periodic global derefinements.
if (iteration > 1 && iteration % UNREF_FREQ == 0 && REFINEMENT_COUNT > 0)
{
info("Global mesh derefinement.");
REFINEMENT_COUNT = 0;
space_rho.unrefine_all_mesh_elements(true);
space_rho.adjust_element_order(-1, P_INIT);
space_rho_v_x.copy_orders(&space_rho);
space_rho_v_y.copy_orders(&space_rho);
space_e.copy_orders(&space_rho);
}
// Adaptivity loop:
int as = 1;
int ndofs_prev = 0;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
int order_increase = 1;
Hermes::vector<Space<double> *>* ref_spaces = Space<double>::construct_refined_spaces(Hermes::vector<Space<double> *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e), order_increase);
if(ndofs_prev != 0)
if(Space<double>::get_num_dofs(*ref_spaces) == ndofs_prev)
selector.set_error_weights(2.0 * selector.get_error_weight_h(), 1.0, 1.0);
else
selector.set_error_weights(1.0, 1.0, 1.0);
ndofs_prev = Space<double>::get_num_dofs(*ref_spaces);
// Project the previous time level solution onto the new fine mesh.
info("Projecting the previous time level solution onto the new fine mesh.");
OGProjection<double>::project_global(*ref_spaces, Hermes::vector<Solution<double>*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e),
Hermes::vector<Solution<double>*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e), matrix_solver_type, Hermes::vector<Hermes::Hermes2D::ProjNormType>(), iteration > 1);
// Report NDOFs.
info("ndof_coarse: %d, ndof_fine: %d.",
Space<double>::get_num_dofs(Hermes::vector<Space<double> *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e)), Space<double>::get_num_dofs(*ref_spaces));
// Assemble the reference problem.
info("Solving on reference mesh.");
DiscreteProblem<double> dp(&wf, *ref_spaces);
SparseMatrix<double>* matrix = create_matrix<double>(matrix_solver_type);
Vector<double>* rhs = create_vector<double>(matrix_solver_type);
LinearSolver<double>* solver = create_linear_solver<double>(matrix_solver_type, matrix, rhs);
wf.set_time_step(time_step);
dp.assemble(matrix, rhs);
// Solve the matrix problem.
info("Solving the matrix problem.");
if(solver->solve())
if(!SHOCK_CAPTURING)
Solution<double>::vector_to_solutions(solver->get_sln_vector(), *ref_spaces,
Hermes::vector<Solution<double>*>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e));
else
{
FluxLimiter flux_limiter(FluxLimiter::Kuzmin, solver->get_sln_vector(), *ref_spaces, true);
flux_limiter.limit_second_orders_according_to_detector(Hermes::vector<Space<double> *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e));
flux_limiter.limit_according_to_detector(Hermes::vector<Space<double> *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e));
flux_limiter.get_limited_solutions(Hermes::vector<Solution<double>*>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e));
}
else
error ("Matrix solver failed.\n");
// Project the fine mesh solution onto the coarse mesh.
info("Projecting reference solution on coarse mesh.");
OGProjection<double>::project_global(Hermes::vector<Space<double> *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e), Hermes::vector<Solution<double>*>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e),
Hermes::vector<Solution<double>*>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e), matrix_solver_type,
Hermes::vector<ProjNormType>(HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM));
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt<double>* adaptivity = new Adapt<double>(Hermes::vector<Space<double> *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e), Hermes::vector<ProjNormType>(HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM));
double err_est_rel_total = adaptivity->calc_err_est(Hermes::vector<Solution<double>*>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e),
Hermes::vector<Solution<double>*>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e)) * 100;
CFL.calculate_semi_implicit(Hermes::vector<Solution<double> *>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e), (*ref_spaces)[0]->get_mesh(), time_step);
// Report results.
info("err_est_rel: %g%%", err_est_rel_total);
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP)
done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(Hermes::vector<RefinementSelectors::Selector<double> *>(&selector, &selector, &selector, &selector),
THRESHOLD, STRATEGY, MESH_REGULARITY);
REFINEMENT_COUNT++;
if (Space<double>::get_num_dofs(Hermes::vector<Space<double> *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e)) >= NDOF_STOP)
done = true;
else
as++;
}
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(!done)
for(unsigned int i = 0; i < ref_spaces->size(); i++)
delete (*ref_spaces)[i];
}
while (done == false);
// Copy the solutions into the previous time level ones.
prev_rho.copy(&rsln_rho);
prev_rho_v_x.copy(&rsln_rho_v_x);
prev_rho_v_y.copy(&rsln_rho_v_y);
prev_e.copy(&rsln_e);
delete rsln_rho.get_mesh();
rsln_rho.own_mesh = false;
delete rsln_rho_v_x.get_mesh();
rsln_rho_v_x.own_mesh = false;
delete rsln_rho_v_y.get_mesh();
rsln_rho_v_y.own_mesh = false;
delete rsln_e.get_mesh();
rsln_e.own_mesh = false;
// Visualization and saving on disk.
if((iteration - 1) % EVERY_NTH_STEP == 0)
{
continuity.add_record((unsigned int)(iteration - 1));
continuity.get_last_record()->save_mesh(prev_rho.get_mesh());
continuity.get_last_record()->save_space(prev_rho.get_space());
continuity.get_last_record()->save_time_step_length(time_step);
// Hermes visualization.
if(HERMES_VISUALIZATION)
{
Mach_number.reinit();
pressure.reinit();
entropy.reinit();
pressure_view.show(&pressure, 1);
entropy_production_view.show(&entropy, 1);
Mach_number_view.show(&Mach_number, 1);
pressure_view.save_numbered_screenshot("pressure %i.bmp", iteration);
Mach_number_view.save_numbered_screenshot("Mach no %i.bmp", iteration);
}
// Output solution in VTK format.
if(VTK_VISUALIZATION)
{
pressure.reinit();
Mach_number.reinit();
entropy.reinit();
Linearizer lin;
char filename[40];
sprintf(filename, "Pressure-%i.vtk", iteration - 1);
lin.save_solution_vtk(&pressure, filename, "Pressure");
sprintf(filename, "Mach number-%i.vtk", iteration - 1);
lin.save_solution_vtk(&Mach_number, filename, "MachNumber");
if((iteration - 1) % (EVERY_NTH_STEP * EVERY_NTH_STEP) == 0)
{
sprintf(filename, "Entropy-%i.vtk", iteration - 1);
lin.save_solution_vtk(&entropy, filename, "Entropy");
}
}
}
}
pressure_view.close();
entropy_production_view.close();
Mach_number_view.close();
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::vector<int>(BDY_1, BDY_6));
bc_types.add_bc_newton(Hermes::vector<int>(BDY_2, BDY_3, BDY_4, BDY_5));
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_zero(Hermes::vector<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);
// Initialize views.
VectorView v_view("Solution (magnitude)", new WinGeom(0, 0, 460, 350));
v_view.set_min_max_range(0, 1.5);
OrderView o_view("Polynomial orders", new WinGeom(470, 0, 400, 350));
// 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);
// Initialize matrix solver.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, ref_space, is_linear);
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);
// View the coarse mesh solution and polynomial orders.
v_view.show(&sln);
o_view.show(&space);
// 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());
// Show the reference solution - the final result.
v_view.set_title("Fine mesh solution (magnitude)");
v_view.show(&ref_sln);
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh 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 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:");
int as = 1; bool done = false;
do
{
// Setup space for the reference solution.
Space *rspace = construct_refined_space(&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(&space, &ref_sln, &sln_prev_time, matrix_solver);
// Calculate element errors and total error estimate.
Adapt adaptivity(&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(&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(&space) >= NDOF_STOP) done = true;
}
as++;
}
while (done == false);
// Project the initial condition on the FE space
// to obtain initial coefficient vector for the Newton's method.
info("Projecting initial condition to obtain coefficient vector for Newton on coarse mesh.");
scalar* coeff_vec_coarse = new scalar[Space::get_num_dofs(&space)];
OGProjection::project_global(&space, init_cond, coeff_vec_coarse, matrix_solver);
OGProjection::project_global(&space, &sln_prev_time, &sln, matrix_solver);
// 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;
// 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);
// Project fine mesh solution on the globally derefined mesh.
info("Projecting fine mesh solution on globally derefined mesh.");
OGProjection::project_global(&space, &ref_sln, &sln, matrix_solver);
}
// 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, 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);
}
// 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.
int it = 1;
while (1)
{
// Obtain the number of degrees of freedom.
int ndof = Space::get_num_dofs(ref_space);
// Assemble the Jacobian matrix and residual vector.
dp.assemble(coeff_vec, matrix, rhs, false);
// 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));
// 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(ref_space), res_l2_norm);
// If l2 norm of the residual vector is within tolerance, or the maximum number
// of iteration has been reached, then quit.
if (res_l2_norm < NEWTON_TOL_FINE || it > NEWTON_MAX_ITER) break;
// 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 (it >= NEWTON_MAX_ITER)
error ("Newton method did not converge.");
it++;
}
// Translate the resulting coefficient vector into the actual solutions.
Solution::vector_to_solutions(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->get_mesh();
delete ref_space;
}
while (!done);
// Copy new time level solution into sln_prev_time.
sln_prev_time.copy(&ref_sln);
}
info("Coordinate ( 2, -2.0) value = %lf", sln_prev_time.get_pt_value( 2, -2.0));
info("Coordinate ( 2, -4.0) value = %lf", sln_prev_time.get_pt_value( 2, -4.0));
info("Coordinate ( 6, -2.0) value = %lf", sln_prev_time.get_pt_value( 6, -2.0));
info("Coordinate ( 6, -4.0) value = %lf", sln_prev_time.get_pt_value( 6, -4.0));
info("Coordinate ( 4, -3.0) value = %lf", sln_prev_time.get_pt_value( 4, -3.0));
#define ERROR_SUCCESS 0
#define ERROR_FAILURE -1
double coor_x[5] = {2.0, 2.0, 6.0, 6.0, 4.0};
double coor_y[5] = {-2.0, -4.0, -2.0, -4.0, -3.0};
double value[5] = {-4.821844, -2.462673, -4.000754, -1.705534, -3.257146};
for (int i = 0; i < 5; i++)
{
if ((value[i] - sln_prev_time.get_pt_value(coor_x[i], coor_y[i])) < 1E-6)
{
}
else
{
printf("Failure!\n");
return ERROR_FAILURE;
}
}
printf("Success!\n");
return ERROR_SUCCESS;
}
int main(int argc, char* argv[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh mesh;
MeshReaderH2D mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial mesh refinements.
for (int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Initialize boundary conditions.
Hermes::Hermes2D::DefaultEssentialBCConst<std::complex<double> > bc_essential("Dirichlet", std::complex<double>(0.0, 0.0));
EssentialBCs<std::complex<double> > bcs(&bc_essential);
// Create an H1 space with default shapeset.
H1Space<std::complex<double> > space(&mesh, &bcs, P_INIT);
int ndof = space.get_num_dofs();
info("ndof = %d", ndof);
// Initialize the weak formulation.
CustomWeakForm wf("Air", MU_0, "Iron", MU_IRON, GAMMA_IRON,
"Wire", MU_0, std::complex<double>(J_EXT, 0.0), OMEGA);
// Initialize coarse and reference mesh solution.
Solution<std::complex<double> > sln, ref_sln;
// Initialize refinement selector.
H1ProjBasedSelector<std::complex<double> > selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
Views::VectorView sview("Solution", new Views::WinGeom(0, 0, 600, 350));
Views::OrderView oview("Polynomial orders", new Views::WinGeom(610, 0, 520, 350));
// DOF and CPU convergence graphs initialization.
SimpleGraph graph_dof, graph_cpu;
Space<std::complex<double> >* ref_space = Space<std::complex<double> >::construct_refined_space(&space);
DiscreteProblem<std::complex<double> > dp(&wf, ref_space);
dp.set_adaptivity_cache();
// Perform Newton's iteration and translate the resulting coefficient vector into a Solution.
Hermes::Hermes2D::NewtonSolver<std::complex<double> > newton(&dp, matrix_solver_type);
// Adaptivity loop:
int as = 1; bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
ref_space = Space<std::complex<double> >::construct_refined_space(&space);
dp.set_spaces(ref_space);
int ndof_ref = ref_space->get_num_dofs();
// Initialize reference problem.
info("Solving on reference mesh.");
// Time measurement.
cpu_time.tick();
// Initial coefficient vector for the Newton's method.
std::complex<double>* coeff_vec = new std::complex<double>[ndof_ref];
memset(coeff_vec, 0, ndof_ref * sizeof(std::complex<double>));
// Perform Newton's iteration and translate the resulting coefficient vector into a Solution.
// For iterative solver.
if (matrix_solver_type == SOLVER_AZTECOO)
{
newton.set_iterative_method(iterative_method);
newton.set_preconditioner(preconditioner);
}
try{
newton.solve(coeff_vec);
}
catch(Hermes::Exceptions::Exception e)
{
e.printMsg();
error("Newton's iteration failed.");
}
Hermes::Hermes2D::Solution<std::complex<double> >::vector_to_solution(newton.get_sln_vector(), ref_space, &ref_sln);
// Project the fine mesh solution onto the coarse mesh.
info("Projecting reference solution on coarse mesh.");
OGProjection<std::complex<double> >::project_global(&space, &ref_sln, &sln, matrix_solver_type);
// View the coarse mesh solution and polynomial orders.
RealFilter real_filter(&sln);
sview.show(&real_filter, &real_filter);
oview.show(&space);
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt<std::complex<double> >* adaptivity = new Adapt<std::complex<double> >(&space);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%",
space.get_num_dofs(), ref_space->get_num_dofs(), err_est_rel);
// Time measurement.
cpu_time.tick();
// Add entry to DOF and CPU convergence graphs.
graph_dof.add_values(space.get_num_dofs(), 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);
}
if (space.get_num_dofs() >= NDOF_STOP) done = true;
// Clean up.
delete [] coeff_vec;
delete adaptivity;
// Increase counter.
as++;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// Show the reference solution - the final result.
sview.set_title("Fine mesh solution");
RealFilter real_filter(&ref_sln);
sview.show(&real_filter);
// Wait for all views to be closed.
Views::View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Instantiate a class with global functions.
Hermes2D hermes2d;
// 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();
// Set exact solution.
CustomExactSolution exact(&mesh, K, alpha);
// Define custom function f.
CustomFunction f(K, alpha);
// Initialize boundary conditions
DefaultEssentialBCNonConst bc_essential("Bdy_dirichlet_rest", &exact);
EssentialBCs bcs(&bc_essential);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bcs, P_INIT);
// Initialize the weak formulation.
HermesFunction lambda(1.0);
WeakFormsH1::DefaultWeakFormPoisson wf(HERMES_ANY, &lambda, &f);
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
ScalarView sview("Solution", new WinGeom(0, 0, 440, 350));
sview.show_mesh(false);
OrderView oview("Polynomial orders", new WinGeom(450, 0, 420, 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 = Space::construct_refined_space(&space);
int ndof_ref = Space::get_num_dofs(ref_space);
// Initialize matrix solver.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Initialize reference problem.
info("Solving on reference mesh.");
DiscreteProblem dp(&wf, ref_space);
// Time measurement.
cpu_time.tick();
// Initial coefficient vector for the Newton's method.
scalar* coeff_vec = new scalar[ndof_ref];
memset(coeff_vec, 0, ndof_ref * sizeof(scalar));
// Perform Newton's iteration.
if (!hermes2d.solve_newton(coeff_vec, &dp, solver, matrix, rhs)) error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the Solution sln.
Solution ref_sln;
Solution::vector_to_solution(coeff_vec, ref_space, &ref_sln);
// 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);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 100;
// Calculate exact error.
double err_exact_rel = hermes2d.calc_rel_error(&sln, &exact, HERMES_H1_NORM) * 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 adaptivity steps.
if (done == false) as++;
}
if (Space::get_num_dofs(&space) >= NDOF_STOP) done = true;
// Clean up.
delete [] coeff_vec;
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false) delete ref_space->get_mesh();
delete ref_space;
}
while (done == false);
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 u_mesh, v_mesh;
H2DReader mloader;
mloader.load("crack.mesh", &u_mesh);
// Perform initial uniform mesh refinement.
for (int i=0; i < INIT_REF_NUM; i++) u_mesh.refine_all_elements();
// Create initial mesh for the vertical displacement component.
// This also initializes the multimesh hp-FEM.
v_mesh.copy(&u_mesh);
// Create H1 spaces with default shapesets.
H1Space u_space(&u_mesh, bc_types_xy, essential_bc_values, P_INIT);
H1Space v_space(MULTI ? &v_mesh : &u_mesh, bc_types_xy, essential_bc_values, P_INIT);
// Initialize the weak formulation.
WeakForm wf(2);
wf.add_matrix_form(0, 0, callback(bilinear_form_0_0), HERMES_SYM);
wf.add_matrix_form(0, 1, callback(bilinear_form_0_1), HERMES_SYM);
wf.add_matrix_form(1, 1, callback(bilinear_form_1_1), HERMES_SYM);
wf.add_vector_form_surf(1, linear_form_surf_1, linear_form_surf_1_ord, BDY_TOP);
// Initialize coarse and reference mesh solutions.
Solution u_sln, v_sln, u_ref_sln, v_ref_sln;
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est;
// 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.
Tuple<Space *>* ref_spaces = construct_refined_spaces(Tuple<Space *>(&u_space, &v_space));
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, *ref_spaces, 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 solutions.
if(solver->solve()) Solution::vector_to_solutions(solver->get_solution(), *ref_spaces,
Tuple<Solution *>(&u_ref_sln, &v_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(Tuple<Space *>(&u_space, &v_space), Tuple<Solution *>(&u_ref_sln, &v_ref_sln),
Tuple<Solution *>(&u_sln, &v_sln), matrix_solver);
// Calculate element errors.
info("Calculating error estimate and exact error.");
Adapt* adaptivity = new Adapt(Tuple<Space *>(&u_space, &v_space), Tuple<ProjNormType>(HERMES_H1_NORM, HERMES_H1_NORM));
adaptivity->set_error_form(0, 0, bilinear_form_0_0<scalar, scalar>, bilinear_form_0_0<Ord, Ord>);
adaptivity->set_error_form(0, 1, bilinear_form_0_1<scalar, scalar>, bilinear_form_0_1<Ord, Ord>);
adaptivity->set_error_form(1, 0, bilinear_form_1_0<scalar, scalar>, bilinear_form_1_0<Ord, Ord>);
adaptivity->set_error_form(1, 1, bilinear_form_1_1<scalar, scalar>, bilinear_form_1_1<Ord, Ord>);
// Calculate error estimate for each solution component and the total error estimate.
Tuple<double> err_est_rel;
bool solutions_for_adapt = true;
double err_est_rel_total = adaptivity->calc_err_est(Tuple<Solution *>(&u_sln, &v_sln), Tuple<Solution *>(&u_ref_sln, &v_ref_sln), solutions_for_adapt,
HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_ABS, &err_est_rel) * 100;
// Time measurement.
cpu_time.tick();
// Report results.
info("ndof_coarse[0]: %d, ndof_fine[0]: %d, err_est_rel[0]: %g%%",
u_space.Space::get_num_dofs(), (*ref_spaces)[0]->Space::get_num_dofs(), err_est_rel[0]*100);
info("ndof_coarse[1]: %d, ndof_fine[1]: %d, err_est_rel[1]: %g%%",
v_space.Space::get_num_dofs(), (*ref_spaces)[1]->Space::get_num_dofs(), err_est_rel[1]*100);
info("ndof_coarse_total: %d, ndof_fine_total: %d, err_est_rel_total: %g%%",
Space::get_num_dofs(Tuple<Space *>(&u_space, &v_space)), Space::get_num_dofs(*ref_spaces), err_est_rel_total);
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space::get_num_dofs(Tuple<Space *>(&u_space, &v_space)), err_est_rel_total);
graph_dof_est.save("conv_dof_est.dat");
graph_cpu_est.add_values(cpu_time.accumulated(), err_est_rel_total);
graph_cpu_est.save("conv_cpu_est.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP)
done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(Tuple<RefinementSelectors::Selector *>(&selector, &selector),
MULTI ? THRESHOLD_MULTI:THRESHOLD_SINGLE, STRATEGY, MESH_REGULARITY);
}
if (Space::get_num_dofs(Tuple<Space *>(&u_space, &v_space)) >= NDOF_STOP) done = true;
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false)
for(int i = 0; i < ref_spaces->size(); i++)
delete (*ref_spaces)[i]->get_mesh();
delete ref_spaces;
delete dp;
// Increase counter.
as++;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
int ndof = Space::get_num_dofs(Tuple<Space *>(&u_space, &v_space));
int ndof_allowed = 920;
printf("ndof actual = %d\n", ndof);
printf("ndof allowed = %d\n", ndof_allowed);
if (ndof <= ndof_allowed) { // ndofs was 908 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[])
{
// 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, basemesh;
MeshReaderH2D mloader;
mloader.load("square.mesh", &basemesh);
mesh.copy(&basemesh);
// Initial mesh refinements.
for(int i = 0; i < INIT_GLOB_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary("Top", INIT_REF_NUM_BDY);
// Initialize boundary conditions.
CustomEssentialBCNonConst bc_essential(Hermes::vector<std::string>("Bottom", "Right", "Top", "Left"));
EssentialBCs<double> bcs(&bc_essential);
// Create an H1 space with default shapeset.
H1Space<double> space(&mesh, &bcs, P_INIT);
int ndof_coarse = Space<double>::get_num_dofs(&space);
info("ndof_coarse = %d.", ndof_coarse);
// Initial condition vector is the zero vector. This is why we
// use the H_OFFSET.
double* coeff_vec = new double[ndof_coarse];
memset(coeff_vec, 0, ndof_coarse*sizeof(double));
// Convert initial condition into a Solution.
Solution<double> h_time_prev, h_time_new;
Solution<double>::vector_to_solution(coeff_vec, &space, &h_time_prev);
delete [] coeff_vec;
// Initialize the weak formulation.
CustomWeakFormRichardsRK wf;
// Initialize the FE problem.
DiscreteProblem<double> dp(&wf, &space);
// Create a refinement selector.
H1ProjBasedSelector<double> selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Visualize initial condition.
char title[100];
ScalarView view("Initial condition", new WinGeom(0, 0, 440, 350));
OrderView ordview("Initial mesh", new WinGeom(445, 0, 440, 350));
view.show(&h_time_prev);
ordview.show(&space);
// DOF and CPU convergence graphs initialization.
SimpleGraph graph_dof, graph_cpu;
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Time stepping loop.
double current_time = 0; int ts = 1;
do
{
// Periodic global derefinement.
if (ts > 1 && ts % UNREF_FREQ == 0)
{
info("Global mesh derefinement.");
switch (UNREF_METHOD) {
case 1: mesh.copy(&basemesh);
space.set_uniform_order(P_INIT);
break;
case 2: mesh.unrefine_all_elements();
space.set_uniform_order(P_INIT);
break;
case 3: mesh.unrefine_all_elements();
space.adjust_element_order(-1, -1, P_INIT, P_INIT);
break;
default: error("Wrong global derefinement method.");
}
ndof_coarse = Space<double>::get_num_dofs(&space);
}
// Spatial adaptivity loop. Note: h_time_prev must not be changed
// during spatial adaptivity.
bool done = false; int as = 1;
double err_est;
do {
info("Time step %d, adaptivity step %d:", ts, as);
// Construct globally refined reference mesh and setup reference space.
Space<double>* ref_space = Space<double>::construct_refined_space(&space);
int ndof_ref = Space<double>::get_num_dofs(ref_space);
// Initialize discrete problem on reference mesh.
DiscreteProblem<double> dp(&wf, ref_space);
// Time measurement.
cpu_time.tick();
// Initialize Runge-Kutta time stepping.
RungeKutta<double> runge_kutta(&dp, &bt, matrix_solver_type);
// 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 freeze_jacobian = false;
bool block_diagonal_jacobian = false;
bool verbose = true;
double damping_coeff = 1.0;
double max_allowed_residual_norm = 1e10;
try
{
runge_kutta.rk_time_step_newton(current_time, time_step, &h_time_prev,
&h_time_new, freeze_jacobian, block_diagonal_jacobian, verbose,
NEWTON_TOL, NEWTON_MAX_ITER, damping_coeff, max_allowed_residual_norm);
}
catch(Exceptions::Exception& e)
{
e.printMsg();
error("Runge-Kutta time step failed");
}
// Project the fine mesh solution onto the coarse mesh.
Solution<double> sln_coarse;
info("Projecting fine mesh solution on coarse mesh for error estimation.");
OGProjection<double>::project_global(&space, &h_time_new, &sln_coarse, matrix_solver_type);
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt<double>* adaptivity = new Adapt<double>(&space);
double err_est_rel_total = adaptivity->calc_err_est(&sln_coarse, &h_time_new) * 100;
// Report results.
info("ndof_coarse: %d, ndof_ref: %d, err_est_rel: %g%%",
Space<double>::get_num_dofs(&space), Space<double>::get_num_dofs(ref_space), err_est_rel_total);
// Time measurement.
cpu_time.tick();
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP) done = true;
else
{
info("Adapting the coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
if (Space<double>::get_num_dofs(&space) >= NDOF_STOP)
done = true;
else
// Increase the counter of performed adaptivity steps.
as++;
}
// Clean up.
delete adaptivity;
if(!done)
{
delete h_time_new.get_space();
delete h_time_new.get_mesh();
}
}
while (done == false);
// Add entry to DOF and CPU convergence graphs.
graph_dof.add_values(current_time, Space<double>::get_num_dofs(&space));
graph_dof.save("conv_dof_est.dat");
graph_cpu.add_values(current_time, cpu_time.accumulated());
graph_cpu.save("conv_cpu_est.dat");
// Visualize the solution and mesh.
char title[100];
sprintf(title, "Solution, time %g", current_time);
view.set_title(title);
view.show_mesh(false);
view.show(&h_time_new);
sprintf(title, "Mesh, time %g", current_time);
ordview.set_title(title);
ordview.show(&space);
// Copy last reference solution into h_time_prev.
h_time_prev.copy(&h_time_new);
delete h_time_new.get_mesh();
// Increase current time and counter of time steps.
current_time += time_step;
ts++;
}
while (current_time < T_FINAL);
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Define nonlinear thermal conductivity lambda(u) via a cubic spline.
// Step 1: Fill the x values and use lambda_macro(u) = 1 + u^4 for the y values.
#define lambda_macro(x) (1 + std::pow(x, 4))
Hermes::vector<double> lambda_pts(-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0);
Hermes::vector<double> lambda_val;
for (unsigned int i = 0; i < lambda_pts.size(); i++) lambda_val.push_back(lambda_macro(lambda_pts[i]));
// Step 2: Create the cubic spline (and plot it for visual control).
double bc_left = 0.0;
double bc_right = 0.0;
bool first_der_left = false;
bool first_der_right = false;
bool extrapolate_der_left = true;
bool extrapolate_der_right = true;
CubicSpline lambda(lambda_pts, lambda_val, bc_left, bc_right, first_der_left, first_der_right,
extrapolate_der_left, extrapolate_der_right);
info("Saving cubic spline into a Pylab file spline.dat.");
// The interval of definition of the spline will be
// extended by "interval_extension" on both sides.
double interval_extension = 3.0;
lambda.plot("spline.dat", interval_extension);
// Load the mesh.
Mesh mesh;
MeshReaderH2D mloader;
mloader.load("square.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_GLOB_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary("Bdy", INIT_BDY_REF_NUM);
// Initialize boundary conditions.
CustomEssentialBCNonConst bc_essential("Bdy");
EssentialBCs<double> bcs(&bc_essential);
// Create an H1 space with default shapeset.
H1Space<double> space(&mesh, &bcs, P_INIT);
// Initialize the weak formulation
Hermes2DFunction<double> f(-heat_src);
WeakFormsH1::DefaultWeakFormPoisson<double> wf(HERMES_ANY, &lambda, &f);
// Initialize the FE problem.
DiscreteProblem<double> dp_coarse(&wf, &space);
// Create a selector which will select optimal candidate.
H1ProjBasedSelector<double> selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize coarse and reference mesh solution.
Solution<double> sln, ref_sln;
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Initialize views.
ScalarView sview("Solution", new WinGeom(0, 0, 440, 350));
sview.show_mesh(false);
OrderView oview("Mesh", new WinGeom(450, 0, 400, 350));
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est;
// Project the initial condition on the FE space to obtain initial
// coefficient vector for the Newton's method.
info("Projecting initial condition to obtain initial vector on the coarse mesh.");
double* coeff_vec_coarse = new double[space.get_num_dofs()];
InitialSolutionHeatTransfer init_sln(&mesh);
OGProjection<double>::project_global(&space, &init_sln, coeff_vec_coarse, matrix_solver);
// Initialize Newton solver on coarse mesh.
info("Solving on coarse mesh:");
bool verbose = true;
NewtonSolver<double> newton_coarse(&dp_coarse, matrix_solver);
newton_coarse.set_verbose_output(verbose);
// Perform initial Newton's iteration on coarse mesh, to obtain
// good initial guess for the Newton's method on the fine mesh.
try
{
newton_coarse.solve(coeff_vec_coarse, NEWTON_TOL_COARSE, NEWTON_MAX_ITER);
}
catch(Hermes::Exceptions::Exception e)
{
e.printMsg();
error("Newton's iteration failed.");
}
// Translate the resulting coefficient vector into the Solution<double> sln.
Solution<double>::vector_to_solution(newton_coarse.get_sln_vector(), &space, &sln);
// Cleanup after the Newton loop on the coarse mesh.
delete [] coeff_vec_coarse;
// Adaptivity loop.
int as = 1; bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Space<double>* ref_space = Space<double>::construct_refined_space(&space);
// Initialize discrete problem on the reference mesh.
DiscreteProblem<double> dp(&wf, ref_space);
// Calculate initial coefficient vector on the reference mesh.
double* coeff_vec = new double[ref_space->get_num_dofs()];
if (as == 1)
{
// In the first step, project the coarse mesh solution.
info("Projecting coarse mesh solution to obtain initial vector on new fine mesh.");
OGProjection<double>::project_global(ref_space, &sln, coeff_vec, matrix_solver);
}
else
{
// In all other steps, project the previous fine mesh solution.
info("Projecting previous fine mesh solution to obtain initial vector on new fine mesh.");
OGProjection<double>::project_global(ref_space, &ref_sln, coeff_vec, matrix_solver);
delete ref_sln.get_space();
delete ref_sln.get_mesh();
}
// Initialize Newton solver on fine mesh.
info("Solving on fine mesh:");
bool verbose = true;
NewtonSolver<double> newton(&dp, matrix_solver);
newton.set_verbose_output(verbose);
// Perform Newton's iteration.
try
{
newton.solve(coeff_vec, NEWTON_TOL_FINE, NEWTON_MAX_ITER);
}
catch(Hermes::Exceptions::Exception e)
{
e.printMsg();
error("Newton's iteration failed.");
}
// Translate the resulting coefficient vector into the Solution<double> ref_sln.
Solution<double>::vector_to_solution(newton.get_sln_vector(), ref_space, &ref_sln);
// Project the fine mesh solution on the coarse mesh.
info("Projecting reference solution on new coarse mesh for error calculation.");
OGProjection<double>::project_global(&space, &ref_sln, &sln, matrix_solver);
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt<double>* adaptivity = new Adapt<double>(&space);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%",
Space<double>::get_num_dofs(&space), Space<double>::get_num_dofs(ref_space), err_est_rel);
// Time measurement.
cpu_time.tick();
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space<double>::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");
// View the coarse mesh solution.
sview.show(&sln);
oview.show(&space);
// If err_est_rel too large, adapt the mesh.
if (err_est_rel < ERR_STOP) done = true;
else
{
info("Adapting the coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
if (Space<double>::get_num_dofs(&space) >= NDOF_STOP)
{
done = true;
break;
}
}
// Clean up.
delete [] coeff_vec;
delete adaptivity;
as++;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// Show the reference solution - the final result.
sview.set_title("Fine mesh solution");
sview.show_mesh(false);
sview.show(&ref_sln);
// Wait for keyboard or mouse input.
View::wait();
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("domain.mesh", &mesh);
// Perform initial mesh refinements.
mesh.refine_all_elements();
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_HORIZONTAL);
bc_types.add_bc_neumann(BDY_VERTICAL);
// Enter Dirichlet boundary values.
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);
// 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 coarse and reference mesh solution.
Solution sln, ref_sln;
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// DOF and CPU convergence graphs initialization.
SimpleGraph graph_dof, graph_cpu;
// 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.");
Adapt* adaptivity = new Adapt(&space);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 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_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);
}
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;
// Increase counter.
as++;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
int ndof = Space::get_num_dofs(&space);
printf("ndof allowed = %d\n", 430);
printf("ndof actual = %d\n", ndof);
if (ndof < 430) { // ndofs was 414 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[])
{
info("Desired number of eigenvalues: %d.", NUMBER_OF_EIGENVALUES);
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial mesh refinements (optional).
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);
// Initialize the weak formulation for the left hand side i.e. H
WeakForm wf_left, wf_right;
wf_left.add_matrix_form(callback(bilinear_form_left));
wf_right.add_matrix_form(callback(bilinear_form_right));
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est;
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
info("Solving on reference mesh.");
// Construct globally refined reference mesh and setup reference space.
Space* ref_space = construct_refined_space(&space);
int ref_ndof = Space::get_num_dofs(ref_space);
info("ref_ndof: %d.", ref_ndof);
// Initialize matrices and matrix solver on referenc emesh.
SparseMatrix* matrix_left = create_matrix(matrix_solver);
SparseMatrix* matrix_right = create_matrix(matrix_solver);
Vector* eivec = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix_left, eivec);
// Assemble the matrices on reference mesh.
bool is_linear = true;
DiscreteProblem* dp_left = new DiscreteProblem(&wf_left, ref_space, is_linear);
dp_left->assemble(matrix_left, eivec);
DiscreteProblem* dp_right = new DiscreteProblem(&wf_right, ref_space, is_linear);
dp_right->assemble(matrix_right, eivec);
// Time measurement.
cpu_time.tick();
// Write matrix_left in MatrixMarket format.
write_matrix_mm("mat_left.mtx", matrix_left);
// Write matrix_left in MatrixMarket format.
write_matrix_mm("mat_right.mtx", matrix_right);
// Time measurement.
cpu_time.tick(HERMES_SKIP);
// Calling Python eigensolver. Solution will be written to "eivecs.dat".
char call_cmd[255];
sprintf(call_cmd, "python solveGenEigenFromMtx.py mat_left.mtx mat_right.mtx %g %d %g %d",
TARGET_VALUE, NUMBER_OF_EIGENVALUES, TOL, MAX_ITER);
system(call_cmd);
// Initializing solution vector, solution and ScalarView.
double* ref_coeff_vec = new double[ref_ndof];
Solution sln[NUMBER_OF_EIGENVALUES], ref_sln[NUMBER_OF_EIGENVALUES];
// Reading solution vectors from file and visualizing.
FILE *file = fopen("eivecs.dat", "r");
char line [64]; // Maximum line size.
fgets(line, sizeof line, file); // ref_ndof
int n = atoi(line);
if (n != ref_ndof) error("Mismatched ndof in the eigensolver output file.");
fgets(line, sizeof line, file); // Number of eigenvectors in the file.
int neig = atoi(line);
if (neig != NUMBER_OF_EIGENVALUES) error("Mismatched number of eigenvectors in the eigensolver output file.");
for (int ieig = 0; ieig < NUMBER_OF_EIGENVALUES; ieig++) {
// Get next eigenvector from the file.
for (int i = 0; i < ref_ndof; i++) {
fgets(line, sizeof line, file);
ref_coeff_vec[i] = atof(line);
}
// Convert coefficient vector into a Solution.
Solution::vector_to_solution(ref_coeff_vec, ref_space, &(ref_sln[ieig]));
// Project the fine mesh solution onto the coarse mesh.
info("Projecting reference solution on coarse mesh.");
OGProjection::project_global(&space, &(ref_sln[ieig]), &(sln[ieig]), matrix_solver);
}
fclose(file);
delete [] ref_coeff_vec;
// FIXME: Below, the adaptivity is done for the last eigenvector only,
// this needs to be changed to take into account all eigenvectors.
// 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[NUMBER_OF_EIGENVALUES-1]),
&(ref_sln[NUMBER_OF_EIGENVALUES-1]), 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_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");
// 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_left;
delete matrix_right;
delete eivec;
delete adaptivity;
if(done == false) delete ref_space->get_mesh();
delete ref_space;
delete dp_left;
delete dp_right;
}
while (done == false);
// Wait for test functions.
};
int main (int argc, char* argv[]) {
// Initialize the library's global functions.
Hermes2D hermes2D;
// Load the mesh file.
Mesh C_mesh, phi_mesh, u1_mesh, u2_mesh, basemesh;
H2DReader mloader;
mloader.load("small.mesh", &basemesh);
#ifdef TWO_BASE_MESH
Mesh basemesh_electrochem; // Base mesh to hold C and phi
Mesh basemesh_deformation; // Base mesh for deformation displacements u1 and u2
basemesh_electrochem.copy(&basemesh);
basemesh_deformation.copy(&basemesh);
basemesh_electrochem.refine_towards_boundary(BDY_BOT, REF_INIT - 1);
basemesh_electrochem.refine_all_elements(1);
C_mesh.copy(&basemesh_electrochem);
phi_mesh.copy(&basemesh_electrochem);
for (int i = 0; i < REF_INIT - 1; i++) {
basemesh_deformation.refine_all_elements(1); //horizontal
basemesh_deformation.refine_all_elements(2); //vertical
}
u1_mesh.copy(&basemesh_deformation);
u2_mesh.copy(&basemesh_deformation);
#else
basemesh.refine_towards_boundary(BDY_BOT, REF_INIT);
basemesh.refine_towards_boundary(BDY_SIDE_FIXED, REF_INIT);
basemesh.refine_towards_boundary(BDY_SIDE_FREE, REF_INIT - 1);
basemesh.refine_all_elements(1);
C_mesh.copy(&basemesh);
phi_mesh.copy(&basemesh);
u1_mesh.copy(&basemesh);
u2_mesh.copy(&basemesh);
#endif
// Enter Dirichlet and Neumann boundary markers for Poisson.
DefaultEssentialBCConst bc_phi_voltage(BDY_TOP, VOLTAGE);
DefaultEssentialBCConst bc_phi_zero(BDY_BOT, 0.0);
EssentialBCs bcs_phi(Hermes::vector<EssentialBC*>(&bc_phi_voltage, &bc_phi_zero));
DefaultEssentialBCConst bc_u1(BDY_SIDE_FIXED, 0.0);
EssentialBCs bcs_u1(&bc_u1);
DefaultEssentialBCConst bc_u2(BDY_SIDE_FIXED, 0.0);
EssentialBCs bcs_u2(&bc_u2);
// Spaces for concentration and the voltage.
H1Space C_space(&C_mesh, P_INIT);
H1Space phi_space(MULTIMESH ? &phi_mesh : &C_mesh, &bcs_phi, P_INIT);
H1Space u1_space(MULTIMESH ? &u1_mesh : &C_mesh, &bcs_u1, P_INIT);
H1Space u2_space(MULTIMESH ? &u2_mesh : &C_mesh, &bcs_u2, P_INIT);
int ndof = Space::get_num_dofs(Hermes::vector<Space*>(&C_space, &phi_space, &u1_space, &u2_space));
Solution C_sln, C_ref_sln;
Solution phi_sln, phi_ref_sln;
Solution u1_sln, u1_ref_sln;
Solution u2_sln, u2_ref_sln;
// Assign initial condition to mesh.
InitialSolutionConcentration C_prev_time(&C_mesh, C0);
InitialSolutionVoltage phi_prev_time(MULTIMESH ? &phi_mesh : &C_mesh);
InitialSolutionU1 u1_prev_time(MULTIMESH ? &u1_mesh : &C_mesh);
InitialSolutionU2 u2_prev_time(MULTIMESH ? &u2_mesh : &C_mesh);
// The weak form for 2 equations.
CustomWeakFormNernstPlanckEuler wf(TAU, C0, lin_force_coup, mech_lambda, mech_mu, K, L, D, &C_prev_time);
// Add the bilinear and linear forms.
if (TIME_DISCR == 2)
error("Crank-Nicholson forms are not implemented yet");
// Project the initial condition on the FE space to obtain initial
// coefficient vector for the Newton's method.
info("Projecting initial condition to obtain initial vector for the Newton's method.");
scalar* coeff_vec_coarse = new scalar[ndof];
OGProjection::project_global(Hermes::vector<Space *>(&C_space, &phi_space, &u1_space, &u2_space),
Hermes::vector<MeshFunction *>(&C_prev_time, &phi_prev_time, &u1_prev_time, &u2_prev_time),
coeff_vec_coarse, matrix_solver);
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem dp_coarse(&wf, Hermes::vector<Space *>(&C_space, &phi_space, &u1_space, &u2_space), is_linear);
// Set up the solver, matrix, and rhs for the coarse mesh according to the solver selection.
SparseMatrix* matrix_coarse = create_matrix(matrix_solver);
Vector* rhs_coarse = create_vector(matrix_solver);
Solver* solver_coarse = create_linear_solver(matrix_solver, matrix_coarse, rhs_coarse);
// Create a selector which will select optimal candidate.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Visualization windows.
char title[1000];
ScalarView Cview("Concentration [mol/m3]", new WinGeom(0, 0, 400, 300));
ScalarView phiview("Voltage [V]", new WinGeom(10, 0, 400, 300));
ScalarView u1view("X displacement [m]", new WinGeom(320, 0, 600, 400));
ScalarView u2view("Y displacement [m]", new WinGeom(830, 0, 600, 400));
OrderView Cordview("C order", new WinGeom(0, 470, 400, 300));
OrderView phiordview("Phi order", new WinGeom(10, 470, 400, 300));
OrderView u1ordview("u1 order", new WinGeom(320, 470, 600, 400));
OrderView u2ordview("u2 order", new WinGeom(830, 470, 600, 400));
// Visualize the solution.
ScalarView deformationview("Von Mises stress [Pa]", new WinGeom(1240, 0, 300, 300));
Cview.show(&C_prev_time);
Cordview.show(&C_space);
phiview.show(&phi_prev_time);
phiordview.show(&phi_space);
u1view.show(&u1_prev_time);
u1ordview.show(&u1_space);
u2view.show(&u2_prev_time);
u2ordview.show(&u2_space);
// Newton's loop on the coarse mesh.
info("Solving on coarse mesh:");
bool verbose = true;
if (!hermes2D.solve_newton(coeff_vec_coarse, &dp_coarse, solver_coarse, matrix_coarse, rhs_coarse,
NEWTON_TOL_COARSE, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the Solution sln.
Solution::vector_to_solutions(coeff_vec_coarse, Hermes::vector<Space *>(&C_space, &phi_space, &u1_space, &u2_space),
Hermes::vector<Solution *>(&C_sln, &phi_sln, &u1_sln, &u2_sln));
Cview.show(&C_sln);
phiview.show(&phi_sln);
u1view.show(&u1_sln);
u2view.show(&u2_sln);
// Cleanup after the Newton loop on the coarse mesh.
delete matrix_coarse;
delete rhs_coarse;
delete solver_coarse;
delete[] coeff_vec_coarse;
// Time stepping loop.
PidTimestepController pid(T_FINAL, true, INIT_TAU);
TAU = pid.timestep;
info("Starting time iteration with the step %g", *TAU);
do {
pid.begin_step();
// Periodic global derefinements.
if (pid.get_timestep_number() > 1 && pid.get_timestep_number() % UNREF_FREQ == 0) {
info("Global mesh derefinement.");
#ifdef TWO_BASE_MESH
C_mesh.copy(&basemesh_electrochem);
#else
C_mesh.copy(&basemesh);
#endif
if (MULTIMESH) {
#ifdef TWO_BASE_MESH
phi_mesh.copy(&basemesh_electrochem);
u1_mesh.copy(&basemesh_deformation);
u2_mesh.copy(&basemesh_deformation);
#else
phi_mesh.copy(&basemesh);
u1_mesh.copy(&basemesh);
u2_mesh.copy(&basemesh);
#endif
}
C_space.set_uniform_order(P_INIT);
phi_space.set_uniform_order(P_INIT);
u1_space.set_uniform_order(P_INIT);
u2_space.set_uniform_order(P_INIT);
// Project on globally derefined mesh.
//info("Projecting previous fine mesh solution on derefined mesh.");
//OGProjection::project_global(Hermes::vector<Space *>(&C, &phi), Hermes::vector<Solution *>(&C_ref_sln, &phi_ref_sln),
// Hermes::vector<Solution *>(&C_sln, &phi_sln));
}
// Adaptivity loop. Note: C_prev_time and Phi_prev_time must not be changed during spatial adaptivity.
bool done = false; int as = 1;
double err_est;
do {
info("Time step %d, adaptivity step %d:", pid.get_timestep_number(), as);
// Construct globally refined reference mesh
// and setup reference space.
Hermes::vector<Space *>* ref_spaces = Space::construct_refined_spaces(
Hermes::vector<Space *>(&C_space, &phi_space, &u1_space, &u2_space));
scalar* coeff_vec = new scalar[Space::get_num_dofs(*ref_spaces)];
DiscreteProblem dp(&wf, *ref_spaces, is_linear);
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Calculate initial coefficient vector for Newton on the fine mesh.
if (as == 1 && pid.get_timestep_number() == 1) {
info("Projecting coarse mesh solution to obtain coefficient vector on new fine mesh.");
OGProjection::project_global(*ref_spaces, Hermes::vector<MeshFunction *>(&C_sln, &phi_sln, &u1_sln, &u2_sln),
coeff_vec, matrix_solver);
}
else {
info("Projecting previous fine mesh solution to obtain coefficient vector on new fine mesh.");
OGProjection::project_global(*ref_spaces,
Hermes::vector<MeshFunction *>(&C_ref_sln, &phi_ref_sln, &u1_ref_sln, &u2_ref_sln),
coeff_vec, matrix_solver);
}
if (as > 1) {
// Now deallocate the previous mesh
info("Delallocating the previous mesh");
delete C_ref_sln.get_mesh();
delete phi_ref_sln.get_mesh();
delete u1_ref_sln.get_mesh();
delete u2_ref_sln.get_mesh();
}
// Newton's loop on the fine mesh.
info("Solving on fine mesh:");
if (!hermes2D.solve_newton(coeff_vec, &dp, solver, matrix, rhs,
NEWTON_TOL_FINE, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Store the result in ref_sln.
Solution::vector_to_solutions(coeff_vec, *ref_spaces,
Hermes::vector<Solution *>(&C_ref_sln, &phi_ref_sln, &u1_ref_sln, &u2_ref_sln));
// Projecting reference solution onto the coarse mesh
info("Projecting fine mesh solution on coarse mesh.");
OGProjection::project_global(Hermes::vector<Space *>(&C_space, &phi_space, &u1_space, &u2_space),
Hermes::vector<Solution *>(&C_ref_sln, &phi_ref_sln, &u1_ref_sln, &u2_ref_sln),
Hermes::vector<Solution *>(&C_sln, &phi_sln, &u1_sln, &u2_sln),
matrix_solver);
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt adaptivity (Hermes::vector<Space *>(&C_space, &phi_space, &u1_space, &u2_space));
Hermes::vector<double> err_est_rel;
double err_est_rel_total = adaptivity.calc_err_est(Hermes::vector<Solution *>(&C_sln, &phi_sln, &u1_sln, &u2_sln),
Hermes::vector<Solution *>(&C_ref_sln, &phi_ref_sln, &u1_ref_sln, &u2_ref_sln),
&err_est_rel) * 100;
// Report results.
info("ndof_coarse[0]: %d, ndof_fine[0]: %d",
C_space.get_num_dofs(), (*ref_spaces)[0]->get_num_dofs());
info("err_est_rel[0]: %g%%", err_est_rel[0]*100);
info("ndof_coarse[1]: %d, ndof_fine[1]: %d",
phi_space.get_num_dofs(), (*ref_spaces)[1]->get_num_dofs());
info("err_est_rel[1]: %g%%", err_est_rel[1]*100);
info("ndof_coarse[2]: %d, ndof_fine[2]: %d",
u1_space.get_num_dofs(), (*ref_spaces)[2]->get_num_dofs());
info("err_est_rel[2]: %g%%", err_est_rel[3]*100);
info("ndof_coarse[3]: %d, ndof_fine[3]: %d",
u2_space.get_num_dofs(), (*ref_spaces)[3]->get_num_dofs());
info("err_est_rel[3]: %g%%", err_est_rel[3]*100);
// Report results.
info("ndof_coarse_total: %d, ndof_fine_total: %d, err_est_rel: %g%%",
Space::get_num_dofs(Hermes::vector<Space *>(&C_space, &phi_space, &u1_space, &u2_space)),
Space::get_num_dofs(*ref_spaces), err_est_rel_total);
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP) done = true;
else {
info("Adapting the coarse mesh.");
done = adaptivity.adapt(Hermes::vector<RefinementSelectors::Selector *>(&selector, &selector, &selector, &selector),
THRESHOLD, STRATEGY, MESH_REGULARITY);
info("Adapted...");
if (Space::get_num_dofs(Hermes::vector<Space *>(&C_space, &phi_space, &u1_space, &u2_space)) >= NDOF_STOP)
done = true;
else
// Increase the counter of performed adaptivity steps.
as++;
}
// Visualize the solution and mesh.
info("Visualization procedures: C");
char title[100];
sprintf(title, "Solution[C], time step# %d, step size %g, time %g",
pid.get_timestep_number(), *TAU, pid.get_time());
Cview.set_title(title);
Cview.show(&C_ref_sln);
sprintf(title, "Mesh[C], time step# %d, step size %g, time %g",
pid.get_timestep_number(), *TAU, pid.get_time());
Cordview.set_title(title);
Cordview.show(&C_space);
info("Visualization procedures: phi");
sprintf(title, "Solution[phi], time step# %d, step size %g, time %g",
pid.get_timestep_number(), *TAU, pid.get_time());
phiview.set_title(title);
phiview.show(&phi_ref_sln);
sprintf(title, "Mesh[phi], time step# %d, step size %g, time %g",
pid.get_timestep_number(), *TAU, pid.get_time());
phiordview.set_title(title);
phiordview.show(&phi_space);
info("Visualization procedures: u1");
sprintf(title, "Solution[u1], time step# %d, step size %g, time %g",
pid.get_timestep_number(), *TAU, pid.get_time());
u1view.set_title(title);
u1view.show(&u1_ref_sln);
sprintf(title, "Mesh[u1], time step# %d, step size %g, time %g",
pid.get_timestep_number(), *TAU, pid.get_time());
u1ordview.set_title(title);
u1ordview.show(&u1_space);
info("Visualization procedures: u2");
sprintf(title, "Solution[u2], time step# %d, step size %g, time %g",
pid.get_timestep_number(), *TAU, pid.get_time());
u2view.set_title(title);
u2view.show(&u2_ref_sln);
sprintf(title, "Mesh[u2], time step# %d, step size %g, time %g",
pid.get_timestep_number(), *TAU, pid.get_time());
u2ordview.set_title(title);
u2ordview.show(&u2_space);
/*
info("Von Mises filter");
VonMisesFilter stress(Hermes::vector<MeshFunction *>(&u1_prev_time, &u2_prev_time), mech_lambda, mech_mu);
deformationview.show_mesh(false);
deformationview.show(&stress, HERMES_EPS_HIGH, H2D_FN_VAL_0, &u1_prev_time, &u2_prev_time, 1.5e10);
*/
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete ref_spaces;
delete[] coeff_vec;
}
while (done == false);
pid.end_step(Hermes::vector<Solution*> (&C_ref_sln, &phi_ref_sln, &u1_ref_sln, &u2_ref_sln),
Hermes::vector<Solution*> (&C_prev_time, &phi_prev_time, &u1_prev_time, &u2_prev_time));
// TODO! Time step reduction when necessary.
// Copy last reference solution into sln_prev_time.
C_prev_time.copy(&C_ref_sln);
phi_prev_time.copy(&phi_ref_sln);
u1_prev_time.copy(&u1_ref_sln);
u2_prev_time.copy(&u2_ref_sln);
} while (pid.has_next());
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh u_mesh, v_mesh;
H2DReader mloader;
mloader.load("elasticity.mesh", &u_mesh);
// Create initial mesh (master mesh).
v_mesh.copy(&u_mesh);
// Perform initial mesh refinements.
for (int i = 0; i < INIT_REF_NUM; i++) u_mesh.refine_all_elements();
for (int i = 0; i < INIT_REF_NUM; i++) v_mesh.refine_all_elements();
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_DIRICHLET);
// Enter Dirichlet boundary values.
BCValues bc_values_u, bc_values_v;
bc_values_u.add_function(BDY_DIRICHLET, essential_bc_values_u);
bc_values_v.add_function(BDY_DIRICHLET, essential_bc_values_v);
// Create H1 spaces with default shapeset for both displacement components.
H1Space u_space(&u_mesh, &bc_types, &bc_values_u, P_INIT_U);
H1Space v_space(&v_mesh, &bc_types, &bc_values_v, P_INIT_V);
// Initialize the weak formulation.
WeakForm wf(2);
wf.add_matrix_form(0, 0, callback(bilinear_form_0_0), HERMES_SYM);
wf.add_matrix_form(0, 1, callback(bilinear_form_0_1), HERMES_SYM);
wf.add_matrix_form(1, 1, callback(bilinear_form_1_1), HERMES_SYM);
//wf.add_vector_form(0, linear_form_u, linear_form_0_ord, HERMES_SYM);
//wf.add_vector_form(1, linear_form_v, linear_form_1_ord, HERMES_SYM);
Solution u_sln, v_sln, u_ref_sln, v_ref_sln;
// Initialize exact solutions.
ExactSolution u_exact(&u_mesh, u_fndd);
ExactSolution v_exact(&v_mesh, v_fndd);
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
ScalarView s_view_u("Solution for u", new WinGeom(0, 0, 440, 350));
s_view_u.show_mesh(false);
OrderView o_view_u("Mesh for u", new WinGeom(450, 0, 420, 350));
ScalarView s_view_v("Solution for v", new WinGeom(880, 0, 440, 350));
s_view_v.show_mesh(false);
OrderView o_view_v("Mesh for v", new WinGeom(1330, 0, 420, 350));
/*
ScalarView sview_u_exact("", new WinGeom(550, 0, 500, 400));
sview_u_exact.fix_scale_width(50);
ScalarView sview_v_exact("", new WinGeom(550, 500, 500, 400));
sview_v_exact.fix_scale_width(50);
char title[100];
*/
// 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.
Hermes::vector<Space *>* ref_spaces = construct_refined_spaces(Hermes::vector<Space *>(&u_space, &v_space));
// Initialize matrix solver.
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_MATRIX_REORDERING);
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, *ref_spaces, is_linear);
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_solutions(solver->get_solution(), *ref_spaces,
Hermes::vector<Solution *>(&u_ref_sln, &v_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(Hermes::vector<Space *>(&u_space, &v_space),
Hermes::vector<Solution *>(&u_ref_sln, &v_ref_sln),
Hermes::vector<Solution *>(&u_sln, &v_sln), matrix_solver);
// View the coarse mesh solution and polynomial orders.
s_view_u.show(&u_sln);
o_view_u.show(&u_space);
s_view_v.show(&v_sln);
o_view_v.show(&v_space);
/*
// Exact solution for comparison with computational results.
u_exact.update(&u_mesh, u_fndd);
v_exact.update(&v_mesh, v_fndd);
// Show exact solution.
sview_u_exact.show(&u_exact);
sprintf(title, "Exact solution for u.");
sview_u_exact.set_title(title);
sview_v_exact.show(&v_exact);
sprintf(title, "Exact solution for v.");
sview_v_exact.set_title(title);
*/
// Calculate element errors.
info("Calculating error estimate and exact error.");
Adapt* adaptivity = new Adapt(Hermes::vector<Space *>(&u_space, &v_space));
// Calculate error estimate for each solution component and the total error estimate.
Hermes::vector<double> err_est_rel;
double err_est_rel_total = adaptivity->calc_err_est(Hermes::vector<Solution *>(&u_sln, &v_sln),
Hermes::vector<Solution *>(&u_ref_sln, &v_ref_sln), &err_est_rel) * 100;
// Calculate exact error for each solution component and the total exact error.
Hermes::vector<double> err_exact_rel;
bool solutions_for_adapt = false;
double err_exact_rel_total = adaptivity->calc_err_exact(Hermes::vector<Solution *>(&u_sln, &v_sln),
Hermes::vector<Solution *>(&u_exact, &v_exact),
&err_exact_rel, solutions_for_adapt) * 100;
// Time measurement.
cpu_time.tick();
// Report results.
info("ndof_coarse[u]: %d, ndof_fine[u]: %d",
u_space.Space::get_num_dofs(), Space::get_num_dofs((*ref_spaces)[0]));
info("err_est_rel[u]: %g%%, err_exact_rel[u]: %g%%", err_est_rel[0]*100, err_exact_rel[0]*100);
info("ndof_coarse[v]: %d, ndof_fine[v]: %d",
v_space.Space::get_num_dofs(), Space::get_num_dofs((*ref_spaces)[1]));
info("err_est_rel[v]: %g%%, err_exact_rel[v]: %g%%", err_est_rel[1]*100, err_exact_rel[1]*100);
info("ndof_coarse_total: %d, ndof_fine_total: %d",
Space::get_num_dofs(Hermes::vector<Space *>(&u_space, &v_space)), Space::get_num_dofs(*ref_spaces));
info("err_est_rel_total: %g%%, err_est_exact_total: %g%%", err_est_rel_total, err_exact_rel_total);
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space::get_num_dofs(Hermes::vector<Space *>(&u_space, &v_space)), err_est_rel_total);
graph_dof_est.save("conv_dof_est.dat");
graph_cpu_est.add_values(cpu_time.accumulated(), err_est_rel_total);
graph_cpu_est.save("conv_cpu_est.dat");
graph_dof_exact.add_values(Space::get_num_dofs(Hermes::vector<Space *>(&u_space, &v_space)), err_exact_rel_total);
graph_dof_exact.save("conv_dof_exact.dat");
graph_cpu_exact.add_values(cpu_time.accumulated(), err_exact_rel_total);
graph_cpu_exact.save("conv_cpu_exact.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP)
done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(Hermes::vector<RefinementSelectors::Selector *>(&selector, &selector),
THRESHOLD, STRATEGY, MESH_REGULARITY);
}
if (Space::get_num_dofs(Hermes::vector<Space *>(&u_space, &v_space)) >= NDOF_STOP) done = true;
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false)
for(unsigned int i = 0; i < ref_spaces->size(); i++)
delete (*ref_spaces)[i]->get_mesh();
delete ref_spaces;
// Increase counter.
as++;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// 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);
// Initialize boundary conditions.
DefaultEssentialBCConst essential_bc(BDY_BOTTOM, 0.0);
EssentialBCs bcs(&essential_bc);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bcs, P_INIT);
// Initialize the weak formulation.
CustomWeakForm wf(A_SE, A_NE, A_SW, A_NW, RHS);
// 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 = 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);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 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[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh u_mesh, v_mesh;
H2DReader mloader;
mloader.load("bracket.mesh", &u_mesh);
// Initial mesh refinements.
u_mesh.refine_element(1);
u_mesh.refine_element(4);
// Create initial mesh for the vertical displacement component.
// This also initializes the multimesh hp-FEM.
v_mesh.copy(&u_mesh);
// Create H1 spaces with default shapesets.
H1Space u_space(&u_mesh, bc_types, essential_bc_values, P_INIT);
H1Space v_space(MULTI ? &v_mesh : &u_mesh, bc_types, essential_bc_values, P_INIT);
// Initialize the weak formulation.
WeakForm wf(2);
wf.add_matrix_form(0, 0, callback(bilinear_form_0_0), HERMES_SYM); // note that only one symmetric part is
wf.add_matrix_form(0, 1, callback(bilinear_form_0_1), HERMES_SYM); // added in the case of symmetric bilinear
wf.add_matrix_form(1, 1, callback(bilinear_form_1_1), HERMES_SYM); // forms
wf.add_vector_form_surf(1, linear_form_surf_1, linear_form_surf_1_ord, BDY_TOP);
// Initialize coarse and reference mesh solutions.
Solution u_sln, v_sln, u_ref_sln, v_ref_sln;
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
ScalarView s_view_0("Solution[0]", new WinGeom(0, 0, 400, 300));
s_view_0.show_mesh(false);
ScalarView s_view_1("Solution[1]", new WinGeom(780, 0, 400, 300));
s_view_1.show_mesh(false);
OrderView o_view_0("Mesh[0]", new WinGeom(410, 0, 360, 300));
OrderView o_view_1("Mesh[1]", new WinGeom(1190, 0, 400, 300));
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est;
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Tuple<Space *>* ref_spaces = construct_refined_spaces(Tuple<Space *>(&u_space, &v_space));
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, *ref_spaces, 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 solutions.
if(solver->solve()) Solution::vector_to_solutions(solver->get_solution(), *ref_spaces,
Tuple<Solution *>(&u_ref_sln, &v_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(Tuple<Space *>(&u_space, &v_space), Tuple<Solution *>(&u_ref_sln, &v_ref_sln),
Tuple<Solution *>(&u_sln, &v_sln), matrix_solver);
// View the coarse mesh solution and polynomial orders.
s_view_0.show(&u_sln);
o_view_0.show(&u_space);
s_view_1.show(&v_sln);
o_view_1.show(&v_space);
// Skip visualization time.
cpu_time.tick(HERMES_SKIP);
// Calculate element errors.
info("Calculating error estimate and exact error.");
Adapt* adaptivity = new Adapt(Tuple<Space *>(&u_space, &v_space), Tuple<ProjNormType>(HERMES_H1_NORM, HERMES_H1_NORM));
adaptivity->set_error_form(0, 0, bilinear_form_0_0<scalar, scalar>, bilinear_form_0_0<Ord, Ord>);
adaptivity->set_error_form(0, 1, bilinear_form_0_1<scalar, scalar>, bilinear_form_0_1<Ord, Ord>);
adaptivity->set_error_form(1, 0, bilinear_form_1_0<scalar, scalar>, bilinear_form_1_0<Ord, Ord>);
adaptivity->set_error_form(1, 1, bilinear_form_1_1<scalar, scalar>, bilinear_form_1_1<Ord, Ord>);
// Calculate error estimate for each solution component and the total error estimate.
Tuple<double> err_est_rel;
bool solutions_for_adapt = true;
double err_est_rel_total = adaptivity->calc_err_est(Tuple<Solution *>(&u_sln, &v_sln), Tuple<Solution *>(&u_ref_sln, &v_ref_sln), solutions_for_adapt,
HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_ABS, &err_est_rel) * 100;
// Time measurement.
cpu_time.tick();
// Report results.
info("ndof_coarse[0]: %d, ndof_fine[0]: %d, err_est_rel[0]: %g%%",
u_space.Space::get_num_dofs(), Space::get_num_dofs((*ref_spaces)[0]), err_est_rel[0]*100);
info("ndof_coarse[1]: %d, ndof_fine[1]: %d, err_est_rel[1]: %g%%",
v_space.Space::get_num_dofs(), Space::get_num_dofs((*ref_spaces)[1]), err_est_rel[1]*100);
info("ndof_coarse_total: %d, ndof_fine_total: %d, err_est_rel_total: %g%%",
Space::get_num_dofs(Tuple<Space *>(&u_space, &v_space)), Space::get_num_dofs(*ref_spaces), err_est_rel_total);
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space::get_num_dofs(Tuple<Space *>(&u_space, &v_space)), err_est_rel_total);
graph_dof_est.save("conv_dof_est.dat");
graph_cpu_est.add_values(cpu_time.accumulated(), err_est_rel_total);
graph_cpu_est.save("conv_cpu_est.dat");
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP)
done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(Tuple<RefinementSelectors::Selector *>(&selector, &selector),
THRESHOLD, STRATEGY, MESH_REGULARITY);
}
if (Space::get_num_dofs(Tuple<Space *>(&u_space, &v_space)) >= NDOF_STOP) done = true;
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
if(done == false)
for(int i = 0; i < ref_spaces->size(); i++)
delete (*ref_spaces)[i]->get_mesh();
delete ref_spaces;
delete dp;
// Increase counter.
as++;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// Show the reference solution - the final result.
s_view_0.set_title("Fine mesh Solution[0]");
s_view_0.show(&u_ref_sln);
s_view_1.set_title("Fine mesh Solution[1]");
s_view_1.show(&v_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();
// Initialize the weak formulation.
CustomWeakForm wf(e_0, mu_0, mu_r, kappa, omega, J, ALIGN_MESH);
// Initialize boundary conditions
DefaultEssentialBCConst bc_essential(BDY_PERFECT_CONDUCTOR, std::complex<double>(0.0, 0.0));
EssentialBCs bcs(&bc_essential);
// Create an Hcurl space with default shapeset.
HcurlSpace space(&mesh, &bcs, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d", ndof);
// 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 = Space::construct_refined_space(&space);
// Initialize matrix solver.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, ref_space, is_linear);
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);
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt* adaptivity = new Adapt(&space);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 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);
ndof = Space::get_num_dofs(&space);
int n_dof_allowed = 1230;
printf("n_dof_actual = %d\n", ndof); // was 1218 at the time this test was last revisited
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* argv[])
{
// Load the mesh.
Mesh mesh, basemesh;
H2DReader mloader;
mloader.load("square.mesh", &basemesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) basemesh.refine_all_elements();
mesh.copy(&basemesh);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(Hermes::Tuple<int>(BDY_BOTTOM, BDY_RIGHT, BDY_TOP, BDY_LEFT));
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_zero(Hermes::Tuple<int>(BDY_BOTTOM, BDY_RIGHT, BDY_TOP, BDY_LEFT));
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
// Initialize coarse and reference mesh solution.
Solution sln, ref_sln;
// Convert initial condition into a Solution.
Solution sln_prev_time;
sln_prev_time.set_exact(&mesh, init_cond);
// Initialize the weak formulation.
WeakForm wf;
if(TIME_DISCR == 1) {
wf.add_matrix_form(callback(J_euler), HERMES_UNSYM, HERMES_ANY);
wf.add_vector_form(callback(F_euler), HERMES_ANY, &sln_prev_time);
}
else {
wf.add_matrix_form(callback(J_cranic), HERMES_UNSYM, HERMES_ANY);
wf.add_vector_form(callback(F_cranic), HERMES_ANY, &sln_prev_time);
}
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem dp_coarse(&wf, &space, is_linear);
// Set up the solver, matrix, and rhs for the coarse mesh according to the solver selection.
SparseMatrix* matrix_coarse = create_matrix(matrix_solver);
Vector* rhs_coarse = create_vector(matrix_solver);
Solver* solver_coarse = create_linear_solver(matrix_solver, matrix_coarse, rhs_coarse);
// Create a selector which will select optimal candidate.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Project the initial condition on the FE space to obtain initial
// coefficient vector for the Newton's method.
info("Projecting initial condition to obtain initial vector for the Newton's method.");
scalar* coeff_vec_coarse = new scalar[ndof];
OGProjection::project_global(&space, &sln_prev_time, coeff_vec_coarse, matrix_solver);
Solution init_proj;
Solution::vector_to_solution(coeff_vec_coarse, &space, &init_proj);
// Newton's loop on the coarse mesh.
info("Solving on coarse mesh:");
bool verbose = true;
if (!solve_newton(coeff_vec_coarse, &dp_coarse, solver_coarse, matrix_coarse, rhs_coarse,
NEWTON_TOL_COARSE, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the Solution sln.
Solution::vector_to_solution(coeff_vec_coarse, &space, &sln);
// Cleanup after the Newton loop on the coarse mesh.
delete matrix_coarse;
delete rhs_coarse;
delete solver_coarse;
delete [] coeff_vec_coarse;
// Time stepping loop.
int num_time_steps = (int)(T_FINAL/TAU + 0.5);
for(int ts = 1; ts <= num_time_steps; ts++)
{
// Periodic global derefinements.
if (ts > 1 && ts % UNREF_FREQ == 0)
{
info("Global mesh derefinement.");
mesh.copy(&basemesh);
space.set_uniform_order(P_INIT);
// Project on globally derefined mesh.
info("Projecting previous fine mesh solution on derefined mesh.");
OGProjection::project_global(&space, &sln_prev_time, &sln);
}
// Adaptivity loop:
bool done = false; int as = 1;
double err_est;
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)];
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);
// Calculate initial coefficient vector for Newton on the fine mesh.
if (as == 1) {
info("Projecting coarse mesh solution to obtain coefficient vector on new fine mesh.");
OGProjection::project_global(ref_space, &sln, coeff_vec, matrix_solver);
}
else {
info("Projecting previous fine mesh solution to obtain coefficient vector on new fine mesh.");
OGProjection::project_global(ref_space, &ref_sln, coeff_vec, matrix_solver);
}
// Now we can deallocate the previous fine mesh.
if(as > 1) delete ref_sln.get_mesh();
// Newton's loop on the fine mesh.
info("Solving on fine mesh:");
if (!solve_newton(coeff_vec, dp, solver, matrix, rhs,
NEWTON_TOL_FINE, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Store the result in ref_sln.
Solution::vector_to_solution(coeff_vec, ref_space, &ref_sln);
// 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.");
Adapt* adaptivity = new Adapt(&space, HERMES_H1_NORM);
bool solutions_for_adapt = true;
double err_est_rel_total = adaptivity->calc_err_est(&sln, &ref_sln, solutions_for_adapt,
HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_REL) * 100;
// Report results.
info("ndof: %d, ref_ndof: %d, err_est_rel: %g%%",
Space::get_num_dofs(&space), Space::get_num_dofs(ref_space), err_est_rel_total);
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP) 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 solver;
delete matrix;
delete rhs;
delete adaptivity;
delete ref_space;
delete dp;
delete [] coeff_vec;
}
while (done == false);
// Copy last reference solution into sln_prev_time.
sln_prev_time.copy(&ref_sln);
}
AbsFilter mag2(&sln);
int success = 1;
double eps = 1e-5;
double val = std::abs(mag2.get_pt_value(0.1, 0.1));
info("Coordinate ( 0.1, 0.1) xvel value = %lf", val);
if (fabs(val - (0.65773)) > eps) {
printf("Coordinate ( 0.1, 0.1) xvel value = %lf\n", val);
success = 0;
}
val = std::abs(mag2.get_pt_value(0.1, -0.1));
info("Coordinate ( 0.1, -0.1) xvel value = %lf", val);
if (fabs(val - (0.65773)) > eps) {
printf("Coordinate ( 0.1, -0.1) xvel value = %lf\n", val);
success = 0;
}
val = std::abs(mag2.get_pt_value(0.2, 0.1));
info("Coordinate ( 0.2, 0.1) xvel value = %lf", val);
if (fabs(val - (0.39062)) > eps) {
printf("Coordinate ( 0.2, 0.1) xvel value = %lf\n", val);
success = 0;
}
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;
MeshReaderH2D 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();
// Initialize boundary conditions
DefaultEssentialBCConst<std::complex<double> > bc_essential(BDY_PERFECT_CONDUCTOR, std::complex<double>(0.0, 0.0));
EssentialBCs<std::complex<double> > bcs(&bc_essential);
// Create an Hcurl space with default shapeset.
HcurlSpace<std::complex<double> > space(&mesh, &bcs, P_INIT);
int ndof = space.get_num_dofs();
Hermes::Mixins::Loggable::Static::info("ndof = %d", ndof);
// Initialize the weak formulation.
CustomWeakForm wf(e_0, mu_0, mu_r, kappa, omega, J, ALIGN_MESH, &mesh, BDY_CURRENT);
// Initialize coarse and reference mesh solution.
Solution<std::complex<double> > sln, ref_sln;
// Initialize refinements selector.
HcurlProjBasedSelector<std::complex<double> > selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize views.
ScalarView 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.
Hermes::Mixins::TimeMeasurable cpu_time;
cpu_time.tick();
// Adaptivity loop:
int as = 1; bool done = false;
do
{
Hermes::Mixins::Loggable::Static::info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Mesh::ReferenceMeshCreator refMeshCreator(&mesh);
Mesh* ref_mesh = refMeshCreator.create_ref_mesh();
Space<std::complex<double> >::ReferenceSpaceCreator refSpaceCreator(&space, ref_mesh);
Space<std::complex<double> >* ref_space = refSpaceCreator.create_ref_space();
int ndof_ref = Space<std::complex<double> >::get_num_dofs(ref_space);
// Initialize reference problem.
Hermes::Mixins::Loggable::Static::info("Solving on reference mesh.");
DiscreteProblem<std::complex<double> > dp(&wf, ref_space);
// Time measurement.
cpu_time.tick();
// Perform Newton's iteration.
Hermes::Hermes2D::NewtonSolver<std::complex<double> > newton(&dp);
try
{
newton.set_newton_max_iter(NEWTON_MAX_ITER);
newton.set_newton_tol(NEWTON_TOL);
newton.solve();
}
catch(Hermes::Exceptions::Exception e)
{
e.print_msg();
throw Hermes::Exceptions::Exception("Newton's iteration failed.");
};
// Translate the resulting coefficient vector into the Solution<std::complex<double> > sln.
Hermes::Hermes2D::Solution<std::complex<double> >::vector_to_solution(newton.get_sln_vector(), ref_space, &ref_sln);
// Project the fine mesh solution onto the coarse mesh.
Hermes::Mixins::Loggable::Static::info("Projecting reference solution on coarse mesh.");
OGProjection<std::complex<double> > ogProjection; ogProjection.project_global(&space, &ref_sln, &sln);
// View the coarse mesh solution and polynomial orders.
RealFilter real(&sln);
MagFilter<double> magn(&real);
ValFilter limited_magn(&magn, 0.0, 4e3);
char title[100];
sprintf(title, "Electric field, adaptivity step %d", as);
eview.set_title(title);
//eview.set_min_max_range(0.0, 4e3);
eview.show(&limited_magn);
sprintf(title, "Polynomial orders, adaptivity step %d", as);
oview.set_title(title);
oview.show(&space);
// Calculate element errors and total error estimate.
Hermes::Mixins::Loggable::Static::info("Calculating error estimate.");
Adapt<std::complex<double> >* adaptivity = new Adapt<std::complex<double> >(&space);
// Set custom error form and calculate error estimate.
CustomErrorForm cef(kappa);
adaptivity->set_error_form(0, 0, &cef);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 100;
// Report results.
Hermes::Mixins::Loggable::Static::info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%",
Space<std::complex<double> >::get_num_dofs(&space),
Space<std::complex<double> >::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<std::complex<double> >::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
{
Hermes::Mixins::Loggable::Static::info("Adapting coarse mesh.");
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
}
if (space.get_num_dofs() >= NDOF_STOP) done = true;
delete adaptivity;
if(!done)
{
delete ref_space->get_mesh();
delete ref_space;
}
// Increase counter.
as++;
}
while (done == false);
Hermes::Mixins::Loggable::Static::info("Total running time: %g s", cpu_time.accumulated());
RealFilter ref_real(&sln);
MagFilter<double> ref_magn(&ref_real);
ValFilter ref_limited_magn(&ref_magn, 0.0, 4e3);
eview.set_title("Fine mesh solution - magnitude");
eview.show(&ref_limited_magn);
// Output solution in VTK format.
Linearizer lin;
bool mode_3D = true;
lin.save_solution_vtk(&ref_limited_magn, "sln.vtk", "Magnitude of E", mode_3D);
Hermes::Mixins::Loggable::Static::info("Solution in VTK format saved to file %s.", "sln.vtk");
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh basemesh;
H2DReader mloader;
mloader.load("domain.mesh", &basemesh);
// Initialize the meshes.
Mesh mesh_flow, mesh_concentration;
mesh_flow.copy(&basemesh);
mesh_concentration.copy(&basemesh);
for(unsigned int i = 0; i < INIT_REF_NUM_CONCENTRATION; i++)
mesh_concentration.refine_all_elements();
mesh_concentration.refine_towards_boundary(BDY_DIRICHLET_CONCENTRATION, INIT_REF_NUM_CONCENTRATION_BDY);
for(unsigned int i = 0; i < INIT_REF_NUM_FLOW; i++)
mesh_flow.refine_all_elements();
// Initialize boundary condition types and spaces with default shapesets.
// For the concentration.
EssentialBCs bcs_concentration;
bcs_concentration.add_boundary_condition(new DefaultEssentialBCConst(BDY_DIRICHLET_CONCENTRATION, CONCENTRATION_EXT));
L2Space space_rho(&mesh_flow, P_INIT_FLOW);
L2Space space_rho_v_x(&mesh_flow, P_INIT_FLOW);
L2Space space_rho_v_y(&mesh_flow, P_INIT_FLOW);
L2Space space_e(&mesh_flow, P_INIT_FLOW);
// Space for concentration.
H1Space space_c(&mesh_concentration, &bcs_concentration, P_INIT_CONCENTRATION);
int ndof = Space::get_num_dofs(Hermes::vector<Space*>(&space_rho, &space_rho_v_x, &space_rho_v_y, &space_e, &space_c));
info("ndof: %d", ndof);
// Initialize solutions, set initial conditions.
InitialSolutionEulerDensity sln_rho(&mesh_flow, RHO_EXT);
InitialSolutionEulerDensityVelX sln_rho_v_x(&mesh_flow, RHO_EXT * V1_EXT);
InitialSolutionEulerDensityVelY sln_rho_v_y(&mesh_flow, RHO_EXT * V2_EXT);
InitialSolutionEulerDensityEnergy sln_e(&mesh_flow, QuantityCalculator::calc_energy(RHO_EXT, RHO_EXT * V1_EXT, RHO_EXT * V2_EXT, P_EXT, KAPPA));
InitialSolutionConcentration sln_c(&mesh_concentration, 0.0);
InitialSolutionEulerDensity prev_rho(&mesh_flow, RHO_EXT);
InitialSolutionEulerDensityVelX prev_rho_v_x(&mesh_flow, RHO_EXT * V1_EXT);
InitialSolutionEulerDensityVelY prev_rho_v_y(&mesh_flow, RHO_EXT * V2_EXT);
InitialSolutionEulerDensityEnergy prev_e(&mesh_flow, QuantityCalculator::calc_energy(RHO_EXT, RHO_EXT * V1_EXT, RHO_EXT * V2_EXT, P_EXT, KAPPA));
InitialSolutionConcentration prev_c(&mesh_concentration, 0.0);
Solution rsln_rho, rsln_rho_v_x, rsln_rho_v_y, rsln_e, rsln_c;
// Numerical flux.
OsherSolomonNumericalFlux num_flux(KAPPA);
// Initialize weak formulation.
EulerEquationsWeakFormImplicitCoupled wf(&num_flux, KAPPA, RHO_EXT, V1_EXT, V2_EXT, P_EXT, BDY_SOLID_WALL,
BDY_INLET, BDY_OUTLET, BDY_NATURAL_CONCENTRATION, &prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e, &prev_c, PRECONDITIONING, EPSILON);
wf.set_time_step(time_step);
// Filters for visualization of Mach number, pressure and entropy.
MachNumberFilter Mach_number(Hermes::vector<MeshFunction*>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e), KAPPA);
PressureFilter pressure(Hermes::vector<MeshFunction*>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e), KAPPA);
EntropyFilter entropy(Hermes::vector<MeshFunction*>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e), KAPPA, RHO_EXT, P_EXT);
ScalarView pressure_view("Pressure", new WinGeom(0, 0, 600, 300));
ScalarView Mach_number_view("Mach number", new WinGeom(700, 0, 600, 300));
ScalarView entropy_production_view("Entropy estimate", new WinGeom(0, 400, 600, 300));
ScalarView s5("Concentration", new WinGeom(700, 400, 600, 300));
/*
ScalarView s1("1", new WinGeom(0, 0, 600, 300));
ScalarView s2("2", new WinGeom(700, 0, 600, 300));
ScalarView s3("3", new WinGeom(0, 400, 600, 300));
ScalarView s4("4", new WinGeom(700, 400, 600, 300));
ScalarView s5("Concentration", new WinGeom(350, 200, 600, 300));
*/
// Initialize refinement selector.
L2ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Select preconditioner.
RCP<Precond> pc = rcp(new IfpackPrecond("point-relax"));
int iteration = 0; double t = 0;
for(t = 0.0; t < 3.0; t += time_step) {
info("---- Time step %d, time %3.5f.", iteration++, t);
// Periodic global derefinements.
if (iteration > 1 && iteration % UNREF_FREQ == 0 && REFINEMENT_COUNT > 0) {
REFINEMENT_COUNT = 0;
info("Global mesh derefinement.");
mesh_flow.unrefine_all_elements();
mesh_concentration.unrefine_all_elements();
space_rho.adjust_element_order(-1, P_INIT_FLOW);
space_rho_v_x.adjust_element_order(-1, P_INIT_FLOW);
space_rho_v_y.adjust_element_order(-1, P_INIT_FLOW);
space_e.adjust_element_order(-1, P_INIT_FLOW);
space_c.adjust_element_order(-1, P_INIT_CONCENTRATION);
}
// Adaptivity loop:
int as = 1;
bool done = false;
do {
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
int order_increase = 0;
Hermes::vector<Space *>* ref_spaces = Space::construct_refined_spaces(Hermes::vector<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e, &space_c), order_increase);
// Report NDOFs.
info("ndof_coarse: %d, ndof_fine: %d.",
Space::get_num_dofs(Hermes::vector<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e, &space_c)), Space::get_num_dofs(*ref_spaces));
// Very imporant, set the meshes for the flow as the same.
(*ref_spaces)[1]->get_mesh()->set_seq((*ref_spaces)[0]->get_mesh()->get_seq());
(*ref_spaces)[2]->get_mesh()->set_seq((*ref_spaces)[0]->get_mesh()->get_seq());
(*ref_spaces)[3]->get_mesh()->set_seq((*ref_spaces)[0]->get_mesh()->get_seq());
// Project the previous time level solution onto the new fine mesh
// in order to obtain initial vector for NOX.
info("Projecting initial solution on the FE mesh.");
scalar* coeff_vec = new scalar[Space::get_num_dofs(*ref_spaces)];
OGProjection::project_global(*ref_spaces, Hermes::vector<MeshFunction *>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e, &prev_c), coeff_vec);
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem dp(&wf, *ref_spaces, is_linear);
// Initialize NOX solver.
NoxSolver solver(&dp, NOX_MESSAGE_TYPE, "GMRES", "Newton", NOX_LINEAR_TOLERANCE, "None", 0, 0, 1, NOX_NONLINEAR_TOLERANCE);
solver.set_init_sln(coeff_vec);
if(PRECONDITIONING)
solver.set_precond(pc);
info("Assembling by DiscreteProblem, solving by NOX.");
if (solver.solve())
Solution::vector_to_solutions(solver.get_solution(), *ref_spaces,
Hermes::vector<Solution *>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e, &rsln_c));
else
error("NOX failed.");
info("Number of nonlin iterations: %d (norm of residual: %g)",
solver.get_num_iters(), solver.get_residual());
info("Total number of iterations in linsolver: %d (achieved tolerance in the last step: %g)",
solver.get_num_lin_iters(), solver.get_achieved_tol());
if(SHOCK_CAPTURING) {
Hermes::vector<Space*> flow_spaces((*ref_spaces)[0], (*ref_spaces)[1], (*ref_spaces)[2], (*ref_spaces)[3]);
scalar* flow_solution_vector = new scalar[Space::get_num_dofs(flow_spaces)];
OGProjection::project_global(flow_spaces, Hermes::vector<MeshFunction *>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e), flow_solution_vector);
DiscontinuityDetector discontinuity_detector(flow_spaces, Hermes::vector<Solution *>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e));
std::set<int> discontinuous_elements = discontinuity_detector.get_discontinuous_element_ids(DISCONTINUITY_DETECTOR_PARAM);
FluxLimiter flux_limiter(flow_solution_vector, flow_spaces, Hermes::vector<Solution *>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e));
flux_limiter.limit_according_to_detector(discontinuous_elements);
}
// Project the fine mesh solution onto the coarse mesh.
info("Projecting reference solution on coarse mesh.");
OGProjection::project_global(Hermes::vector<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e, &space_c), Hermes::vector<Solution *>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e, &rsln_c),
Hermes::vector<Solution *>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e, &sln_c), matrix_solver,
Hermes::vector<ProjNormType>(HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM, HERMES_H1_NORM));
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt* adaptivity = new Adapt(Hermes::vector<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e, &space_c), Hermes::vector<ProjNormType>(HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM, HERMES_H1_NORM));
double err_est_rel_total = adaptivity->calc_err_est(Hermes::vector<Solution *>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e, &sln_c),
Hermes::vector<Solution *>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e, &rsln_c)) * 100;
// Report results.
info("err_est_rel: %g%%", err_est_rel_total);
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP)
done = true;
else {
info("Adapting coarse mesh.");
done = adaptivity->adapt(Hermes::vector<RefinementSelectors::Selector *>(&selector, &selector, &selector, &selector, &selector),
THRESHOLD, STRATEGY, MESH_REGULARITY);
REFINEMENT_COUNT++;
if (Space::get_num_dofs(Hermes::vector<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e, &space_c)) >= NDOF_STOP)
done = true;
else
// Increase the counter of performed adaptivity steps.
as++;
}
// Save orders.
Orderizer ord;
char filename[40];
sprintf(filename, "Flow-mesh-%i-%i.vtk", iteration - 1, as - 1);
ord.save_orders_vtk((*ref_spaces)[0], filename);
sprintf(filename, "Concentration-mesh-%i-%i.vtk", iteration - 1, as - 1);
ord.save_orders_vtk((*ref_spaces)[4], filename);
// Clean up.
delete adaptivity;
if(!done)
for(unsigned int i = 0; i < ref_spaces->size(); i++)
delete (*ref_spaces)[i]->get_mesh();
for(unsigned int i = 0; i < ref_spaces->size(); i++)
delete (*ref_spaces)[i];
}
while (done == false);
// Copy the solutions into previous time level ones.
prev_rho.copy(&rsln_rho);
prev_rho_v_x.copy(&rsln_rho_v_x);
prev_rho_v_y.copy(&rsln_rho_v_y);
prev_e.copy(&rsln_e);
prev_c.copy(&rsln_c);
// Visualization.
if((iteration - 1) % EVERY_NTH_STEP == 0) {
// Hermes visualization.
if(HERMES_VISUALIZATION) {
Mach_number.reinit();
pressure.reinit();
entropy.reinit();
pressure_view.show(&pressure);
entropy_production_view.show(&entropy);
Mach_number_view.show(&Mach_number);
s5.show(&prev_c);
/*
s1.show(&prev_rho);
s2.show(&prev_rho_v_x);
s3.show(&prev_rho_v_y);
s4.show(&prev_e);
s5.show(&prev_c);
*/
}
// Output solution in VTK format.
if(VTK_VISUALIZATION) {
pressure.reinit();
Mach_number.reinit();
Linearizer lin;
char filename[40];
sprintf(filename, "pressure-%i.vtk", iteration - 1);
lin.save_solution_vtk(&pressure, filename, "Pressure", false);
sprintf(filename, "pressure-3D-%i.vtk", iteration - 1);
lin.save_solution_vtk(&pressure, filename, "Pressure", true);
sprintf(filename, "Mach number-%i.vtk", iteration - 1);
lin.save_solution_vtk(&Mach_number, filename, "MachNumber", false);
sprintf(filename, "Mach number-3D-%i.vtk", iteration - 1);
lin.save_solution_vtk(&Mach_number, filename, "MachNumber", true);
sprintf(filename, "Concentration-%i.vtk", iteration - 1);
lin.save_solution_vtk(&prev_c, filename, "Concentration", true);
sprintf(filename, "Concentration-3D-%i.vtk", iteration - 1);
lin.save_solution_vtk(&prev_c, filename, "Concentration", true);
}
}
}
pressure_view.close();
entropy_production_view.close();
Mach_number_view.close();
s5.close();
/*
s1.close();
s2.close();
s3.close();
s4.close();
*/
return 0;
}
int main(int argc, char **args)
{
// Load the mesh.
Mesh mesh;
H3DReader mesh_loader;
mesh_loader.load("fichera-corner.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 H1 space with default shapeset.
H1Space 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(bilinear_form<double, double>, bilinear_form<Ord, Ord>, HERMES_SYM, HERMES_ANY);
wf.add_vector_form(linear_form<double, double>, linear_form<Ord, Ord>, HERMES_ANY);
// Set exact solution.
ExactSolution exact(&mesh, fndd);
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est, graph_dof_exact, graph_cpu_exact;
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Initialize the solver in the case of SOLVER_PETSC or SOLVER_MUMPS.
initialize_solution_environment(matrix_solver, argc, args);
// 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 , H3D_H3D_H3D_REFT_HEX_XYZ);
// 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);
// 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_H1_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, 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);
// Properly terminate the solver in the case of SOLVER_PETSC or SOLVER_MUMPS.
finalize_solution_environment(matrix_solver);
return 1;
}
int main(int argc, char* argv[])
{
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("square.mesh", &mesh);
// Perform initial mesh refinement.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(BDY_DIRICHLET, INIT_REF_NUM_BDY);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_DIRICHLET);
// Enter Dirichlet boudnary values.
BCValues bc_values;
bc_values.add_zero(BDY_DIRICHLET);
// 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(linear_form, linear_form_ord);
// Initialize refinement selector.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Set exact solution.
ExactSolution exact(&mesh, sol_exact);
// 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);
// 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());
int ndof = Space::get_num_dofs(&space);
int n_dof_allowed = 550;
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* argv[])
{
// Load the mesh.
Mesh mesh, basemesh;
H2DReader mloader;
mloader.load("GAMM-channel.mesh", &basemesh);
// Perform initial mesh refinements.
for (int i = 0; i < INIT_REF_NUM; i++) basemesh.refine_all_elements();
basemesh.refine_by_criterion(criterion, 4);
mesh.copy(&basemesh);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_neumann(Hermes::Tuple<int>(BDY_SOLID_WALL, BDY_INLET_OUTLET));
// Create L2 spaces with default shapesets.
L2Space space_rho(&mesh, &bc_types, P_INIT);
L2Space space_rho_v_x(&mesh, &bc_types, P_INIT);
L2Space space_rho_v_y(&mesh, &bc_types, P_INIT);
L2Space space_e(&mesh, &bc_types, P_INIT);
// Initialize solutions, set initial conditions.
Solution sln_rho, sln_rho_v_x, sln_rho_v_y, sln_e, prev_rho, prev_rho_v_x, prev_rho_v_y, prev_e;
Solution rsln_rho, rsln_rho_v_x, rsln_rho_v_y, rsln_e;
sln_rho.set_exact(&mesh, ic_density);
sln_rho_v_x.set_exact(&mesh, ic_density_vel_x);
sln_rho_v_y.set_exact(&mesh, ic_density_vel_y);
sln_e.set_exact(&mesh, ic_energy);
prev_rho.set_exact(&mesh, ic_density);
prev_rho_v_x.set_exact(&mesh, ic_density_vel_x);
prev_rho_v_y.set_exact(&mesh, ic_density_vel_y);
prev_e.set_exact(&mesh, ic_energy);
// Initialize weak formulation.
WeakForm wf(4);
// Bilinear forms coming from time discretization by explicit Euler's method.
wf.add_matrix_form(0,0,callback(bilinear_form_0_0_time));
wf.add_matrix_form(1,1,callback(bilinear_form_1_1_time));
wf.add_matrix_form(2,2,callback(bilinear_form_2_2_time));
wf.add_matrix_form(3,3,callback(bilinear_form_3_3_time));
// Volumetric linear forms.
// Linear forms coming from the linearization by taking the Eulerian fluxes' Jacobian matrices from the previous time step.
// First flux.
/*
wf.add_vector_form(0,callback(linear_form_0_1), HERMES_ANY, Hermes::Tuple<MeshFunction*>(&prev_rho_v_x));
wf.add_vector_form(1, callback(linear_form_1_0_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(1, callback(linear_form_1_1_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(1, callback(linear_form_1_2_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(1, callback(linear_form_1_3_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(2, callback(linear_form_2_0_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(2, callback(linear_form_2_1_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(2, callback(linear_form_2_2_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(2, callback(linear_form_2_3_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(3, callback(linear_form_3_0_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(3, callback(linear_form_3_1_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(3, callback(linear_form_3_2_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(3, callback(linear_form_3_3_first_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
// Second flux.
wf.add_vector_form(0,callback(linear_form_0_2),HERMES_ANY, Hermes::Tuple<MeshFunction*>(&prev_rho_v_y));
wf.add_vector_form(1, callback(linear_form_1_0_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(1, callback(linear_form_1_1_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(1, callback(linear_form_1_2_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(1, callback(linear_form_1_3_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(2, callback(linear_form_2_0_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(2, callback(linear_form_2_1_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(2, callback(linear_form_2_2_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y));
wf.add_vector_form(2, callback(linear_form_2_3_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(3, callback(linear_form_3_0_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(3, callback(linear_form_3_1_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(3, callback(linear_form_3_2_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(3, callback(linear_form_3_3_second_flux), HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
*/
// Volumetric linear forms coming from the time discretization.
#ifdef HERMES_USE_VECTOR_VALUED_FORMS
wf.add_vector_form(0, linear_form_vector, linear_form_order, HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(1, linear_form_vector, linear_form_order, HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(2, linear_form_vector, linear_form_order, HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form(3, linear_form_vector, linear_form_order, HERMES_ANY,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
#else
wf.add_vector_form(0,linear_form, linear_form_order, HERMES_ANY, &prev_rho);
wf.add_vector_form(1,linear_form, linear_form_order, HERMES_ANY, &prev_rho_v_x);
wf.add_vector_form(2,linear_form, linear_form_order, HERMES_ANY, &prev_rho_v_y);
wf.add_vector_form(3,linear_form, linear_form_order, HERMES_ANY, &prev_e);
#endif
// Surface linear forms - inner edges coming from the DG formulation.
#ifdef HERMES_USE_VECTOR_VALUED_FORMS
wf.add_vector_form_surf(0, linear_form_interface_vector, linear_form_order, H2D_DG_INNER_EDGE,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(1, linear_form_interface_vector, linear_form_order, H2D_DG_INNER_EDGE,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(2, linear_form_interface_vector, linear_form_order, H2D_DG_INNER_EDGE,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(3, linear_form_interface_vector, linear_form_order, H2D_DG_INNER_EDGE,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
#else
wf.add_vector_form_surf(0, linear_form_interface_0, linear_form_order, H2D_DG_INNER_EDGE,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(1, linear_form_interface_1, linear_form_order, H2D_DG_INNER_EDGE,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(2, linear_form_interface_2, linear_form_order, H2D_DG_INNER_EDGE,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(3, linear_form_interface_3, linear_form_order, H2D_DG_INNER_EDGE,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
#endif
// Surface linear forms - inlet / outlet edges.
#ifdef HERMES_USE_VECTOR_VALUED_FORMS
wf.add_vector_form_surf(0, bdy_flux_inlet_outlet_comp_vector, linear_form_order, BDY_INLET_OUTLET,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(1, bdy_flux_inlet_outlet_comp_vector, linear_form_order, BDY_INLET_OUTLET,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(2, bdy_flux_inlet_outlet_comp_vector, linear_form_order, BDY_INLET_OUTLET,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(3, bdy_flux_inlet_outlet_comp_vector, linear_form_order, BDY_INLET_OUTLET,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
#else
wf.add_vector_form_surf(0, bdy_flux_inlet_outlet_comp_0, linear_form_order, BDY_INLET_OUTLET,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(1, bdy_flux_inlet_outlet_comp_1, linear_form_order, BDY_INLET_OUTLET,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(2, bdy_flux_inlet_outlet_comp_2, linear_form_order, BDY_INLET_OUTLET,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(3, bdy_flux_inlet_outlet_comp_3, linear_form_order, BDY_INLET_OUTLET,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
#endif
// Surface linear forms - Solid wall edges.
#ifdef HERMES_USE_VECTOR_VALUED_FORMS
wf.add_vector_form_surf(0, bdy_flux_solid_wall_comp_vector, linear_form_order, BDY_SOLID_WALL,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(1, bdy_flux_solid_wall_comp_vector, linear_form_order, BDY_SOLID_WALL,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(2, bdy_flux_solid_wall_comp_vector, linear_form_order, BDY_SOLID_WALL,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(3, bdy_flux_solid_wall_comp_vector, linear_form_order, BDY_SOLID_WALL,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
#else
wf.add_vector_form_surf(0, bdy_flux_solid_wall_comp_0, linear_form_order, BDY_SOLID_WALL,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(1, bdy_flux_solid_wall_comp_1, linear_form_order, BDY_SOLID_WALL,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(2, bdy_flux_solid_wall_comp_2, linear_form_order, BDY_SOLID_WALL,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
wf.add_vector_form_surf(3, bdy_flux_solid_wall_comp_3, linear_form_order, BDY_SOLID_WALL,
Hermes::Tuple<MeshFunction*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e));
#endif
// Filters for visualization of pressure and the two components of velocity.
SimpleFilter pressure(calc_pressure_func, Hermes::Tuple<MeshFunction*>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e));
SimpleFilter u(calc_u_func, Hermes::Tuple<MeshFunction*>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e));
SimpleFilter w(calc_w_func, Hermes::Tuple<MeshFunction*>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e));
// Initialize refinement selector.
L2ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Disable weighting of refinement candidates.
selector.set_error_weights(1, 1, 1);
//VectorView vview("Velocity", new WinGeom(0, 0, 600, 300));
//ScalarView sview("Pressure", new WinGeom(700, 0, 600, 300));
ScalarView s1("w1", new WinGeom(0, 0, 620, 300));
s1.fix_scale_width(80);
ScalarView s2("w2", new WinGeom(625, 0, 600, 300));
s2.fix_scale_width(50);
ScalarView s3("w3", new WinGeom(0, 350, 620, 300));
s3.fix_scale_width(80);
ScalarView s4("w4", new WinGeom(625, 350, 600, 300));
s4.fix_scale_width(50);
// Iteration number.
int iteration = 0;
// For calculation of the time derivative of the norm of the solution approximation.
// Not used yet in the adaptive version.
double difference;
double *difference_values = new double[Space::get_num_dofs(Hermes::Tuple<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e))];
double *last_values = new double[Space::get_num_dofs(Hermes::Tuple<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e))];
for(int i = 0; i < Space::get_num_dofs(Hermes::Tuple<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e)); i++)
last_values[i] = 0.;
// Output of the approximate time derivative.
// Not used yet in the adaptive version.
std::ofstream time_der_out("time_der");
for(t = 0.0; t < 10; t += TAU)
{
info("---- Time step %d, time %3.5f.", iteration, t);
iteration++;
// Periodic global derefinements.
if (iteration > 1 && iteration % UNREF_FREQ == 0 && REFINEMENT_COUNT > 0) {
REFINEMENT_COUNT = 0;
info("Global mesh derefinement.");
mesh.unrefine_all_elements();
space_rho.set_uniform_order(P_INIT);
space_rho_v_x.set_uniform_order(P_INIT);
space_rho_v_y.set_uniform_order(P_INIT);
space_e.set_uniform_order(P_INIT);
}
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
// Global polynomial order increase = 0;
int order_increase = 0;
Hermes::Tuple<Space *>* ref_spaces = construct_refined_spaces(Hermes::Tuple<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e), order_increase);
// Project the previous time level solution onto the new fine mesh.
info("Projecting the previous time level solution onto the new fine mesh.");
OGProjection::project_global(*ref_spaces, Hermes::Tuple<Solution *>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e),
Hermes::Tuple<Solution *>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e), matrix_solver);
if(as > 1) {
delete rsln_rho.get_mesh();
delete rsln_rho_v_x.get_mesh();
delete rsln_rho_v_y.get_mesh();
delete rsln_e.get_mesh();
}
// Assemble the reference problem.
info("Solving on reference mesh.");
bool is_linear = true;
DiscreteProblem* dp = new DiscreteProblem(&wf, *ref_spaces, is_linear);
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// The FE problem is in fact a FV problem.
dp->set_fvm();
#ifdef HERMES_USE_VECTOR_VALUED_FORMS
dp->use_vector_valued_forms();
#endif
dp->assemble(matrix, rhs);
// Solve the linear system of the reference problem. If successful, obtain the solutions.
if(solver->solve()) Solution::vector_to_solutions(solver->get_solution(), *ref_spaces,
Hermes::Tuple<Solution *>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e));
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(Hermes::Tuple<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e), Hermes::Tuple<Solution *>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e),
Hermes::Tuple<Solution *>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e), matrix_solver,
Hermes::Tuple<ProjNormType>(HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM));
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt* adaptivity = new Adapt(Hermes::Tuple<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e), Hermes::Tuple<ProjNormType>(HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM));
// Error components.
Hermes::Tuple<double> *error_components = new Hermes::Tuple<double>(4);
double err_est_rel_total = adaptivity->calc_err_est(Hermes::Tuple<Solution *>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e),
Hermes::Tuple<Solution *>(&rsln_rho, &rsln_rho_v_x, &rsln_rho_v_y, &rsln_e),
error_components, HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_ABS) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%",
Space::get_num_dofs(Hermes::Tuple<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e)), Space::get_num_dofs(*ref_spaces), err_est_rel_total);
// Determine the time step.
double *solution_vector = new double[Space::get_num_dofs(Hermes::Tuple<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e))];
OGProjection::project_global(Hermes::Tuple<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e), Hermes::Tuple<MeshFunction *>(&sln_rho, &sln_rho_v_x, &sln_rho_v_y, &sln_e), solution_vector, matrix_solver,
Hermes::Tuple<ProjNormType>(HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM, HERMES_L2_NORM));
double min_condition = 0;
Element *e;
for (int _id = 0, _max = mesh.get_max_element_id(); _id < _max; _id++) \
if (((e) = mesh.get_element_fast(_id))->used) \
if ((e)->active)
{
AsmList al;
space_rho.get_element_assembly_list(e, &al);
double rho = solution_vector[al.dof[0]];
space_rho_v_x.get_element_assembly_list(e, &al);
double v1 = solution_vector[al.dof[0]] / rho;
space_rho_v_y.get_element_assembly_list(e, &al);
double v2 = solution_vector[al.dof[0]] / rho;
space_e.get_element_assembly_list(e, &al);
double energy = solution_vector[al.dof[0]];
double condition = e->get_area() / (std::sqrt(v1*v1 + v2*v2) + calc_sound_speed(rho, rho*v1, rho*v2, energy));
if(condition < min_condition || min_condition == 0.)
min_condition = condition;
}
if(TAU > min_condition)
TAU = min_condition;
if(TAU < min_condition * 0.9)
TAU = min_condition;
delete [] solution_vector;
// Visualization.
s1.show(&sln_rho);
s2.show(&sln_rho_v_x);
s3.show(&sln_rho_v_y);
s4.show(&sln_e);
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP && (*error_components)[1] * 100 < ERR_STOP_VEL_X)
done = true;
else
{
info("Adapting coarse mesh.");
done = adaptivity->adapt(Hermes::Tuple<RefinementSelectors::Selector *>(&selector, &selector, &selector, &selector),
THRESHOLD, STRATEGY, MESH_REGULARITY);
REFINEMENT_COUNT++;
if (Space::get_num_dofs(Hermes::Tuple<Space *>(&space_rho, &space_rho_v_x,
&space_rho_v_y, &space_e)) >= NDOF_STOP)
done = true;
else
// Increase the counter of performed adaptivity steps.
as++;
}
// We have to empty the cache of NeighborSearch class instances.
NeighborSearch::empty_main_caches();
// If used, we need to clean the vector valued form caches.
#ifdef HERMES_USE_VECTOR_VALUED_FORMS
DiscreteProblem::empty_form_caches();
#endif
// Clean up.
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
for(unsigned int i = 0; i < ref_spaces->size(); i++)
delete (*ref_spaces)[i];
delete dp;
}
while (done == false);
// Debugging.
/*
std::ofstream out("matrix");
for(int i = 0; i < matrix->get_size(); i++)
for(int j = 0; j < matrix->get_size(); j++)
if(std::abs(matrix->get(i,j)) != 0)
out << '(' << i << ',' << j << ')' << ':' << matrix->get(i,j) << std::endl;
out.close();
out.open("rhs");
for(int j = 0; j < matrix->get_size(); j++)
if(std::abs(rhs->get(j)) != 0)
out << '(' << j << ')' << ':' << rhs->get(j) << std::endl;
out.close();
out.open("sol");
for(int j = 0; j < matrix->get_size(); j++)
out << '(' << j << ')' << ':' << solver->get_solution()[j] << std::endl;
out.close();
*/
// Copy the solutions into the previous time level ones.
prev_rho.copy(&rsln_rho);
prev_rho_v_x.copy(&rsln_rho_v_x);
prev_rho_v_y.copy(&rsln_rho_v_y);
prev_e.copy(&rsln_e);
delete rsln_rho.get_mesh();
delete rsln_rho_v_x.get_mesh();
delete rsln_rho_v_y.get_mesh();
delete rsln_e.get_mesh();
// Visualization.
/*
pressure.reinit();
u.reinit();
w.reinit();
sview.show(&pressure);
vview.show(&u,&w);
*/
}
time_der_out.close();
return 0;
}
int main (int argc, char* argv[]) {
// Load the mesh file.
Mesh Cmesh, phimesh, basemesh;
H2DReader mloader;
mloader.load("small.mesh", &basemesh);
// When nonadaptive solution, refine the mesh.
basemesh.refine_towards_boundary(BYD_TOP, REF_INIT);
basemesh.refine_towards_boundary(BYD_BOT, REF_INIT - 1);
basemesh.refine_all_elements(1);
basemesh.refine_all_elements(1);
Cmesh.copy(&basemesh);
phimesh.copy(&basemesh);
// Enter Neumann boundary markers for Nernst-Planck.
BCTypes C_bc_types;
C_bc_types.add_bc_neumann(Hermes::Tuple<int>(BYD_SIDE, BYD_TOP, BYD_BOT));
// Enter Dirichlet and Neumann boundary markers for Poisson.
BCTypes phi_bc_types;
phi_bc_types.add_bc_neumann(BYD_SIDE);
phi_bc_types.add_bc_dirichlet(Hermes::Tuple<int>(BYD_TOP, BYD_BOT));
// Enter Dirichlet boundary values.
BCValues phi_bc_values;
phi_bc_values.add_const(BYD_TOP, VOLTAGE);
phi_bc_values.add_zero(BYD_BOT);
BCValues C_bc_values;
C_bc_values.add_zero(Hermes::Tuple<int>(BYD_SIDE, BYD_TOP, BYD_BOT));
// Spaces for concentration and the voltage.
H1Space C(&Cmesh, &C_bc_types, &C_bc_values, P_INIT);
H1Space phi(MULTIMESH ? &phimesh : &Cmesh, &phi_bc_types, &phi_bc_values, P_INIT);
int ndof = Space::get_num_dofs(Hermes::Tuple<Space*>(&C, &phi));
Solution C_sln, C_ref_sln;
Solution phi_sln, phi_ref_sln;
// Assign initial condition to mesh.
Solution C_prev_time(&Cmesh, concentration_ic);
Solution phi_prev_time(MULTIMESH ? &phimesh : &Cmesh, voltage_ic);
// The weak form for 2 equations.
WeakForm wf(2);
// Add the bilinear and linear forms.
if (TIME_DISCR == 1) { // Implicit Euler.
wf.add_matrix_form(0, 0, callback(J_euler_DFcDYc), HERMES_UNSYM, HERMES_ANY, &phi_prev_time);
wf.add_matrix_form(0, 1, callback(J_euler_DFcDYphi), HERMES_UNSYM, HERMES_ANY, &C_prev_time);
wf.add_matrix_form(1, 0, callback(J_euler_DFphiDYc), HERMES_UNSYM);
wf.add_matrix_form(1, 1, callback(J_euler_DFphiDYphi), HERMES_UNSYM);
wf.add_vector_form(0, callback(Fc_euler), HERMES_ANY, Hermes::Tuple<MeshFunction*>(&C_prev_time, &phi_prev_time));
wf.add_vector_form(1, callback(Fphi_euler), HERMES_ANY, Hermes::Tuple<MeshFunction*>(&C_prev_time, &phi_prev_time));
} else {
wf.add_matrix_form(0, 0, callback(J_cranic_DFcDYc), HERMES_UNSYM, HERMES_ANY, Hermes::Tuple<MeshFunction*>(&phi_prev_time));
wf.add_matrix_form(0, 1, callback(J_cranic_DFcDYphi), HERMES_UNSYM, HERMES_ANY, Hermes::Tuple<MeshFunction*>(&C_prev_time));
wf.add_matrix_form(1, 0, callback(J_cranic_DFphiDYc), HERMES_UNSYM);
wf.add_matrix_form(1, 1, callback(J_cranic_DFphiDYphi), HERMES_UNSYM);
wf.add_vector_form(0, callback(Fc_cranic), HERMES_ANY, Hermes::Tuple<MeshFunction*>(&C_prev_time, &phi_prev_time));
wf.add_vector_form(1, callback(Fphi_cranic), HERMES_ANY);
}
// Project the initial condition on the FE space to obtain initial
// coefficient vector for the Newton's method.
info("Projecting initial condition to obtain initial vector for the Newton's method.");
scalar* coeff_vec_coarse = new scalar[ndof];
OGProjection::project_global(Hermes::Tuple<Space *>(&C, &phi), Hermes::Tuple<MeshFunction *>(&C_prev_time, &phi_prev_time), coeff_vec_coarse, matrix_solver);
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem dp_coarse(&wf, Hermes::Tuple<Space *>(&C, &phi), is_linear);
// Set up the solver, matrix, and rhs for the coarse mesh according to the solver selection.
SparseMatrix* matrix_coarse = create_matrix(matrix_solver);
Vector* rhs_coarse = create_vector(matrix_solver);
Solver* solver_coarse = create_linear_solver(matrix_solver, matrix_coarse, rhs_coarse);
// Create a selector which will select optimal candidate.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Visualization windows.
char title[1000];
ScalarView Cview("Concentration [mol/m3]", new WinGeom(0, 0, 800, 800));
ScalarView phiview("Voltage [V]", new WinGeom(650, 0, 600, 600));
OrderView Cordview("C order", new WinGeom(0, 300, 600, 600));
OrderView phiordview("Phi order", new WinGeom(600, 300, 600, 600));
Cview.show(&C_prev_time);
Cordview.show(&C);
phiview.show(&phi_prev_time);
phiordview.show(&phi);
// Newton's loop on the coarse mesh.
info("Solving on coarse mesh:");
bool verbose = true;
if (!solve_newton(coeff_vec_coarse, &dp_coarse, solver_coarse, matrix_coarse, rhs_coarse,
NEWTON_TOL_COARSE, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the Solution sln.
Solution::vector_to_solutions(coeff_vec_coarse, Hermes::Tuple<Space *>(&C, &phi), Hermes::Tuple<Solution *>(&C_sln, &phi_sln));
Cview.show(&C_sln);
phiview.show(&phi_sln);
// Cleanup after the Newton loop on the coarse mesh.
delete matrix_coarse;
delete rhs_coarse;
delete solver_coarse;
delete[] coeff_vec_coarse;
// Time stepping loop.
int num_time_steps = (int)(T_FINAL/TAU + 0.5);
for(int ts = 1; ts <= num_time_steps; ts++)
{
// Periodic global derefinements.
if (ts > 1 && ts % UNREF_FREQ == 0)
{
info("Global mesh derefinement.");
Cmesh.copy(&basemesh);
if (MULTIMESH)
{
phimesh.copy(&basemesh);
}
C.set_uniform_order(P_INIT);
phi.set_uniform_order(P_INIT);
// Project on globally derefined mesh.
//info("Projecting previous fine mesh solution on derefined mesh.");
//OGProjection::project_global(Hermes::Tuple<Space *>(&C, &phi), Hermes::Tuple<Solution *>(&C_ref_sln, &phi_ref_sln),
// Hermes::Tuple<Solution *>(&C_sln, &phi_sln));
}
// Adaptivity loop:
bool done = false; int as = 1;
double err_est;
do {
info("Time step %d, adaptivity step %d:", ts, as);
// Construct globally refined reference mesh
// and setup reference space.
Hermes::Tuple<Space *>* ref_spaces = construct_refined_spaces(Hermes::Tuple<Space *>(&C, &phi));
scalar* coeff_vec = new scalar[Space::get_num_dofs(*ref_spaces)];
DiscreteProblem* dp = new DiscreteProblem(&wf, *ref_spaces, is_linear);
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Calculate initial coefficient vector for Newton on the fine mesh.
if (as == 1) {
info("Projecting coarse mesh solution to obtain coefficient vector on new fine mesh.");
OGProjection::project_global(*ref_spaces, Hermes::Tuple<MeshFunction *>(&C_sln, &phi_sln), coeff_vec, matrix_solver);
}
else {
info("Projecting previous fine mesh solution to obtain coefficient vector on new fine mesh.");
OGProjection::project_global(*ref_spaces, Hermes::Tuple<MeshFunction *>(&C_ref_sln, &phi_ref_sln), coeff_vec, matrix_solver);
// Now deallocate the previous mesh
info("Delallocating the previous mesh");
delete C_ref_sln.get_mesh();
delete phi_ref_sln.get_mesh();
}
// Newton's loop on the fine mesh.
info("Solving on fine mesh:");
if (!solve_newton(coeff_vec, dp, solver, matrix, rhs,
NEWTON_TOL_FINE, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Store the result in ref_sln.
Solution::vector_to_solutions(coeff_vec, *ref_spaces, Hermes::Tuple<Solution *>(&C_ref_sln, &phi_ref_sln));
// Projecting reference solution onto the coarse mesh
info("Projecting fine mesh solution on coarse mesh.");
OGProjection::project_global(Hermes::Tuple<Space *>(&C, &phi), Hermes::Tuple<Solution *>(&C_ref_sln, &phi_ref_sln), Hermes::Tuple<Solution *>(&C_sln, &phi_sln),
matrix_solver);
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
Adapt* adaptivity = new Adapt(Hermes::Tuple<Space *>(&C, &phi), Hermes::Tuple<ProjNormType>(HERMES_H1_NORM, HERMES_H1_NORM));
bool solutions_for_adapt = true;
Hermes::Tuple<double> err_est_rel;
double err_est_rel_total = adaptivity->calc_err_est(Hermes::Tuple<Solution *>(&C_sln, &phi_sln),
Hermes::Tuple<Solution *>(&C_ref_sln, &phi_ref_sln), solutions_for_adapt,
HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_REL, &err_est_rel) * 100;
// Report results.
info("ndof_coarse[0]: %d, ndof_fine[0]: %d",
C.get_num_dofs(), (*ref_spaces)[0]->get_num_dofs());
info("err_est_rel[0]: %g%%", err_est_rel[0]*100);
info("ndof_coarse[1]: %d, ndof_fine[1]: %d",
phi.get_num_dofs(), (*ref_spaces)[1]->get_num_dofs());
info("err_est_rel[1]: %g%%", err_est_rel[1]*100);
// Report results.
info("ndof_coarse_total: %d, ndof_fine_total: %d, err_est_rel: %g%%",
Space::get_num_dofs(Hermes::Tuple<Space *>(&C, &phi)), Space::get_num_dofs(*ref_spaces), err_est_rel_total);
// If err_est too large, adapt the mesh.
if (err_est_rel_total < ERR_STOP) done = true;
else
{
info("Adapting the coarse mesh.");
done = adaptivity->adapt(Hermes::Tuple<RefinementSelectors::Selector *>(&selector, &selector),
THRESHOLD, STRATEGY, MESH_REGULARITY);
info("Adapted...");
if (Space::get_num_dofs(Hermes::Tuple<Space *>(&C, &phi)) >= NDOF_STOP)
done = true;
else
// Increase the counter of performed adaptivity steps.
as++;
}
// Visualize the solution and mesh.
info("Visualization procedures: C");
char title[100];
sprintf(title, "Solution[C], time level %d", ts);
Cview.set_title(title);
Cview.show(&C_ref_sln);
sprintf(title, "Mesh[C], time level %d", ts);
Cordview.set_title(title);
Cordview.show(&C);
info("Visualization procedures: phi");
sprintf(title, "Solution[phi], time level %d", ts);
phiview.set_title(title);
phiview.show(&phi_ref_sln);
sprintf(title, "Mesh[phi], time level %d", ts);
phiordview.set_title(title);
phiordview.show(&phi);
// Clean up.
info("delete solver");
delete solver;
info("delete matrix");
delete matrix;
info("delete rhs");
delete rhs;
info("delete adaptivity");
delete adaptivity;
info("delete[] ref_spaces");
delete ref_spaces;
info("delete dp");
delete dp;
info("delete[] coeff_vec");
delete[] coeff_vec;
}
while (done == false);
// Copy last reference solution into sln_prev_time.
C_prev_time.copy(&C_ref_sln);
phi_prev_time.copy(&phi_ref_sln);
}
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Instantiate a class with global functions.
Hermes2D hermes2d;
// Define nonlinear thermal conductivity lambda(u) via a cubic spline.
// Step 1: Fill the x values and use lambda(u) = 1 + u^4 for the y values.
#define lambda(x) (1 + pow(x, 4))
Hermes::vector<double> lambda_pts(-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0);
Hermes::vector<double> lambda_val;
for (unsigned int i = 0; i < lambda_pts.size(); i++) lambda_val.push_back(lambda(lambda_pts[i]));
// Step 2: Create the cubic spline (and plot it for visual control).
double bc_left = 0.0;
double bc_right = 0.0;
bool first_der_left = false;
bool first_der_right = false;
bool extrapolate_der_left = true;
bool extrapolate_der_right = true;
CubicSpline spline_coeff(lambda_pts, lambda_val, bc_left, bc_right, first_der_left, first_der_right,
extrapolate_der_left, extrapolate_der_right);
info("Saving cubic spline into a Pylab file spline.dat.");
double interval_extension = 3.0; // The interval of definition of the spline will be
// extended by "interval_extension" on both sides.
spline_coeff.plot("spline.dat", interval_extension);
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("square.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_GLOB_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary("Bdy", INIT_BDY_REF_NUM);
// Initialize boundary conditions.
CustomEssentialBCNonConst bc_essential("Bdy");
EssentialBCs bcs(&bc_essential);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bcs, P_INIT);
// Initialize the weak formulation
ConstFunctionXY heat_src(HEAT_SRC);
double const_coeff = 1.0;
DefaultWeakFormPoisson wf(&heat_src, HERMES_ANY, const_coeff, &spline_coeff);
// Initialize the FE problem.
DiscreteProblem dp_coarse(&wf, &space);
// Set up the solver, matrix, and rhs for the coarse mesh according to the solver selection.
SparseMatrix* matrix_coarse = create_matrix(matrix_solver);
Vector* rhs_coarse = create_vector(matrix_solver);
Solver* solver_coarse = create_linear_solver(matrix_solver, matrix_coarse, rhs_coarse);
// Create a selector which will select optimal candidate.
H1ProjBasedSelector selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Initialize coarse and reference mesh solution.
Solution sln, ref_sln;
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Initialize views.
ScalarView sview("Solution", new WinGeom(0, 0, 440, 350));
sview.show_mesh(false);
OrderView oview("Mesh", new WinGeom(450, 0, 400, 350));
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est;
// Project the initial condition on the FE space to obtain initial
// coefficient vector for the Newton's method.
info("Projecting initial condition to obtain initial vector on the coarse mesh.");
scalar* coeff_vec_coarse = new scalar[Space::get_num_dofs(&space)] ;
InitialSolutionHeatTransfer init_sln(&mesh);
OGProjection::project_global(&space, &init_sln, coeff_vec_coarse, matrix_solver);
// Newton's loop on the coarse mesh. This is needed to obtain a good
// starting point for the Newton's method on the reference mesh.
info("Solving on coarse mesh:");
bool verbose = true;
bool jacobian_changed = true;
if (!hermes2d.solve_newton(coeff_vec_coarse, &dp_coarse, solver_coarse, matrix_coarse, rhs_coarse,
jacobian_changed, NEWTON_TOL_COARSE, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the Solution sln.
Solution::vector_to_solution(coeff_vec_coarse, &space, &sln);
// Cleanup after the Newton loop on the coarse mesh.
delete matrix_coarse;
delete rhs_coarse;
delete solver_coarse;
delete [] coeff_vec_coarse;
// 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 = Space::construct_refined_space(&space);
// Initialize discrete problem on the reference mesh.
DiscreteProblem dp(&wf, ref_space);
// Initialize matrix solver.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Calculate initial coefficient vector on the reference mesh.
scalar* coeff_vec = new scalar[Space::get_num_dofs(ref_space)];
if (as == 1)
{
// In the first step, project the coarse mesh solution.
info("Projecting coarse mesh solution to obtain initial vector on new fine mesh.");
OGProjection::project_global(ref_space, &sln, coeff_vec, matrix_solver);
}
else
{
// In all other steps, project the previous fine mesh solution.
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);
}
// Now we can deallocate the previous fine mesh.
if(as > 1) delete ref_sln.get_mesh();
// Newton's loop on the fine mesh.
info("Solving on fine mesh:");
if (!hermes2d.solve_newton(coeff_vec, &dp, solver, matrix, rhs,
jacobian_changed, NEWTON_TOL_FINE, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Translate the resulting coefficient vector into the Solution ref_sln.
Solution::vector_to_solution(coeff_vec, ref_space, &ref_sln);
// Project the fine mesh solution on the coarse mesh.
if (as > 1) {
info("Projecting reference solution on new coarse mesh for error calculation.");
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);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 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_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");
// View the coarse mesh solution.
sview.show(&sln);
oview.show(&space);
// If err_est_rel too large, adapt the mesh.
if (err_est_rel < ERR_STOP) 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;
break;
}
}
// Clean up.
delete [] coeff_vec;
delete solver;
delete matrix;
delete rhs;
delete adaptivity;
delete ref_space;
as++;
}
while (done == false);
verbose("Total running time: %g s", cpu_time.accumulated());
// Show the reference solution - the final result.
sview.set_title("Fine mesh solution");
sview.show_mesh(false);
sview.show(&ref_sln);
// Wait for keyboard or mouse input.
View::wait();
return 0;
}
