int main(int argc, char* argv[])
{
// Load the mesh.
MeshSharedPtr mesh(new 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<complex> bc_essential("Dirichlet", complex(0.0, 0.0));
EssentialBCs<complex> bcs(&bc_essential);
// Create an H1 space with default shapeset.
SpaceSharedPtr<complex> space(new H1Space<complex>(mesh, &bcs, P_INIT));
// Initialize the weak formulation.
CustomWeakForm wf("Air", MU_0, "Iron", MU_IRON, GAMMA_IRON,
"Wire", MU_0, complex(J_EXT, 0.0), OMEGA);
// Initialize coarse and reference mesh solution.
MeshFunctionSharedPtr<complex> sln(new Hermes::Hermes2D::Solution<complex>());
MeshFunctionSharedPtr<complex> ref_sln(new Hermes::Hermes2D::Solution<complex>());
// Initialize refinement selector.
H1ProjBasedSelector<complex> selector(CAND_LIST);
// DOF and CPU convergence graphs initialization.
SimpleGraph graph_dof, graph_cpu;
DiscreteProblem<complex> dp(&wf, space);
// Perform Newton's iteration and translate the resulting coefficient vector into a Solution.
Hermes::Hermes2D::NewtonSolver<complex> newton(&dp);
// Adaptivity loop:
int as = 1;
bool done = false;
adaptivity.set_space(space);
do
{
// Construct globally refined reference mesh and setup reference space->
Mesh::ReferenceMeshCreator ref_mesh_creator(mesh);
MeshSharedPtr ref_mesh = ref_mesh_creator.create_ref_mesh();
Space<complex>::ReferenceSpaceCreator ref_space_creator(space, ref_mesh);
SpaceSharedPtr<complex> ref_space = ref_space_creator.create_ref_space();
newton.set_space(ref_space);
int ndof_ref = ref_space->get_num_dofs();
// Initialize reference problem.
// Initial coefficient vector for the Newton's method.
complex* coeff_vec = new complex[ndof_ref];
memset(coeff_vec, 0, ndof_ref * sizeof(complex));
// Perform Newton's iteration and translate the resulting coefficient vector into a Solution.
try
{
newton.solve(coeff_vec);
}
catch(Hermes::Exceptions::Exception& e)
{
e.print_msg();
}
Hermes::Hermes2D::Solution<complex>::vector_to_solution(newton.get_sln_vector(), ref_space, ref_sln);
// Project the fine mesh solution onto the coarse mesh.
OGProjection<complex> ogProjection;
ogProjection.project_global(space, ref_sln, sln);
// Calculate element errors and total error estimate.
errorCalculator.calculate_errors(sln, ref_sln);
// If err_est too large, adapt the mesh->
if(errorCalculator.get_total_error_squared() * 100. < ERR_STOP)
done = true;
else
{
adaptivity.adapt(&selector);
}
// Clean up.
delete [] coeff_vec;
// Increase counter.
as++;
}
while (done == false);
complex sum = 0;
for (int i = 0; i < space->get_num_dofs(); i++)
sum += newton.get_sln_vector()[i];
printf("coefficient sum = %f\n", sum);
complex expected_sum;
expected_sum.real(1.4685364e-005);
expected_sum.imag(-5.45632171e-007);
bool success = true;
if(std::abs(sum - expected_sum) > 1e-6)
success = false;
int ndof = space->get_num_dofs();
if(ndof != 82) // Tested value as of May 2013.
success = false;
if(success)
{
printf("Success!\n");
return 0;
}
else
{
printf("Failure!\n");
return -1;
}
}
int main(int argc, char* args[])
{
// Load the mesh.
MeshSharedPtr mesh(new Mesh);
MeshReaderH2D mloader;
mloader.load("square.mesh", mesh);
// Perform initial mesh refinement.
for (int i=0; i<INIT_REF; i++)
mesh->refine_all_elements();
// Create an L2 space->
SpaceSharedPtr<double> space(new L2Space<double>(mesh, P_INIT));
// Initialize refinement selector.
L2ProjBasedSelector<double> selector(CAND_LIST);
// Display the mesh.
#ifdef SHOW_OUTPUT
OrderView oview("Coarse mesh", new WinGeom(0, 0, 440, 350));
oview.show(space);
#endif
MeshFunctionSharedPtr<double> sln(new Solution<double>);
MeshFunctionSharedPtr<double> ref_sln(new Solution<double>);
// Initialize the weak formulation.
CustomWeakForm wf("Bdy_bottom_left", mesh);
#ifdef SHOW_OUTPUT
ScalarView view1("Solution", new WinGeom(900, 0, 450, 350));
view1.fix_scale_width(60);
#endif
// Initialize linear solver.
Hermes::Hermes2D::LinearSolver<double> linear_solver(&wf, space);
int as = 1; bool done = false;
do
{
// Construct globally refined reference mesh
// and setup reference space->
Mesh::ReferenceMeshCreator ref_mesh_creator(mesh);
MeshSharedPtr ref_mesh = ref_mesh_creator.create_ref_mesh();
Space<double>::ReferenceSpaceCreator ref_space_creator(space, ref_mesh);
SpaceSharedPtr<double> ref_space = ref_space_creator.create_ref_space();
ref_space->save("space-real.xml");
ref_space->free();
ref_space->load("space-real.xml");
#ifdef WITH_BSON
ref_space->save_bson("space-real.bson");
ref_space->free();
ref_space->load_bson("space-real.bson");
#endif
linear_solver.set_space(ref_space);
// Solve the linear system. If successful, obtain the solution.
linear_solver.solve();
Solution<double>::vector_to_solution(linear_solver.get_sln_vector(), ref_space, ref_sln);
// Project the fine mesh solution onto the coarse mesh.
OGProjection<double> ogProjection;
ogProjection.project_global(space, ref_sln, sln, HERMES_L2_NORM);
#ifdef SHOW_OUTPUT
MeshFunctionSharedPtr<double> val_filter(new ValFilter(ref_sln, 0.0, 1.0));
// View the coarse mesh solution.
view1.show(val_filter);
oview.show(space);
#endif
// Calculate element errors and total error estimate.
errorCalculator.calculate_errors(sln, ref_sln);
double err_est_rel = errorCalculator.get_total_error_squared() * 100;
adaptivity.set_space(space);
#ifdef SHOW_OUTPUT
std::cout << "Error: " << err_est_rel << "%." << std::endl;
#endif
// If err_est_rel too large, adapt the mesh->
if(err_est_rel < ERR_STOP)
done = true;
else
done = adaptivity.adapt(&selector);
as++;
}
while (done == false);
// Wait for keyboard or mouse input.
#ifdef SHOW_OUTPUT
View::wait();
#endif
return as;
}
int main(int argc, char* args[])
{
// Load the mesh->
HermesSharedPtr mesh;
MeshReaderH2D mloader;
mloader.load("../square.mesh", mesh);
// Perform initial mesh refinement.
for (int i=0; i<INIT_REF; i++)
mesh->refine_all_elements();
// Create an L2 space->
L2Space<double> space(mesh, P_INIT);
// Initialize refinement selector.
L2ProjBasedSelector<double> selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER);
// Disable weighting of refinement candidates.
selector.set_error_weights(1, 1, 1);
Solution<double> sln;
Solution<double> ref_sln;
// Initialize the weak formulation.
CustomWeakForm wf("Bdy_bottom_left", mesh);
// Initialize the FE problem.
DiscreteProblemLinear<double> dp(&wf, space);
// Initialize linear solver.
Hermes::Hermes2D::LinearSolver<double> linear_solver(&dp);
int as = 1; bool done = false;
do
{
// Construct globally refined reference mesh
// and setup reference space->
Mesh::ReferenceMeshCreator ref_mesh_creator(mesh);
Mesh* ref_mesh = ref_mesh_creator.create_ref_mesh();
Space<double>::ReferenceSpaceCreator ref_space_creator(space, ref_mesh);
Space<double>* ref_space = ref_space_creator.create_ref_space();
dp.set_space(ref_space);
// Solve the linear system. If successful, obtain the solution.
try
{
linear_solver.solve();
Solution<double>::vector_to_solution(linear_solver.get_sln_vector(), ref_space, &ref_sln);
}
catch(std::exception& e)
{
std::cout << e.what();
}
// Project the fine mesh solution onto the coarse mesh->
OGProjection<double> ogProjection;
ogProjection.project_global(space, &ref_sln, &sln, HERMES_L2_NORM);
// Calculate element errors and total error estimate.
Adapt<double>* adaptivity = new Adapt<double>(space);
double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 100;
// If err_est_rel too large, adapt the mesh->
if(err_est_rel < ERR_STOP) done = true;
else
{
done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY);
if(Space<double>::get_num_dofs(space) >= NDOF_STOP)
{
done = true;
break;
}
}
// Clean up.
delete adaptivity;
if(done == false)
delete ref_space->get_mesh();
delete ref_space;
as++;
}
while (done == false);
if(done)
{
printf("Success!\n");
return 0;
}
else
{
printf("Failure!\n");
return -1;
}
}
int main(int argc, char* argv[])
{
// Load the mesh.
MeshSharedPtr mesh(new 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<complex> bc_essential("Dirichlet", complex(0.0, 0.0));
EssentialBCs<complex> bcs(&bc_essential);
// Create an H1 space with default shapeset.
SpaceSharedPtr<complex> space(new H1Space<complex>(mesh, &bcs, P_INIT));
int ndof = space->get_num_dofs();
// Initialize the weak formulation.
CustomWeakForm wf("Air", MU_0, "Iron", MU_IRON, GAMMA_IRON,
"Wire", MU_0, complex(J_EXT, 0.0), OMEGA);
// Initialize coarse and reference mesh solution.
MeshFunctionSharedPtr<complex> sln(new Hermes::Hermes2D::Solution<complex>());
MeshFunctionSharedPtr<complex> ref_sln(new Hermes::Hermes2D::Solution<complex>());
// Initialize refinement selector.
H1ProjBasedSelector<complex> selector(CAND_LIST);
// Initialize views.
#ifdef SHOW_OUTPUT
Views::ScalarView sview("Solution", new Views::WinGeom(0, 0, 600, 350));
Views::ScalarView sview2("Ref. Solution", new Views::WinGeom(0, 0, 600, 350));
Views::OrderView oview("Polynomial orders", new Views::WinGeom(610, 0, 520, 350));
#endif
DiscreteProblem<complex> dp(&wf, space);
// Perform Newton's iteration and translate the resulting coefficient vector into a Solution.
Hermes::Hermes2D::NewtonSolver<complex> newton(&dp);
// Adaptivity loop:
int as = 1; bool done = false;
adaptivity.set_space(space);
do
{
// Construct globally refined reference mesh and setup reference space->
Mesh::ReferenceMeshCreator ref_mesh_creator(mesh);
MeshSharedPtr ref_mesh = ref_mesh_creator.create_ref_mesh();
Space<complex>::ReferenceSpaceCreator ref_space_creator(space, ref_mesh);
SpaceSharedPtr<complex> ref_space = ref_space_creator.create_ref_space();
newton.set_space(ref_space);
ref_space->save("space-complex.xml");
ref_space->free();
ref_space->load("space-complex.xml");
#ifdef WITH_BSON
ref_space->save_bson("space-complex.bson");
ref_space->free();
ref_space->load_bson("space-complex.bson");
#endif
int ndof_ref = ref_space->get_num_dofs();
// Initialize reference problem.
// Initial coefficient vector for the Newton's method.
complex* coeff_vec = new complex[ndof_ref];
memset(coeff_vec, 0, ndof_ref * sizeof(complex));
// Perform Newton's iteration and translate the resulting coefficient vector into a Solution.
SpaceSharedPtr<complex> space_test = Space<complex>::load("space-complex.xml", ref_mesh, false, &bcs);
newton.set_space(space_test);
newton.solve(coeff_vec);
Hermes::Hermes2D::Solution<complex>::vector_to_solution(newton.get_sln_vector(), ref_space, ref_sln);
// Project the fine mesh solution onto the coarse mesh.
OGProjection<complex> ogProjection;
#ifdef WITH_BSON
space->save_bson("space-complex-coarse.bson");
SpaceSharedPtr<complex> space_test2 = Space<complex>::load_bson("space-complex-coarse.bson", mesh, &bcs);
ogProjection.project_global(space_test2, ref_sln, sln);
#else
space->save("space-complex-coarse.xml2");
SpaceSharedPtr<complex> space_test2 = Space<complex>::load("space-complex-coarse.xml2", mesh, false, &bcs);
ogProjection.project_global(space_test2, ref_sln, sln);
#endif
// View the coarse mesh solution and polynomial orders.
#ifdef SHOW_OUTPUT
MeshFunctionSharedPtr<double> real_filter(new RealFilter(sln));
MeshFunctionSharedPtr<double> rreal_filter(new RealFilter(ref_sln));
sview2.show(rreal_filter);
oview.show(space);
#endif
// Calculate element errors and total error estimate.
errorCalculator.calculate_errors(sln, ref_sln);
#ifdef SHOW_OUTPUT
std::cout << "Relative error: " << errorCalculator.get_total_error_squared() * 100. << '%' << std::endl;
#endif
// Add entry to DOF and CPU convergence graphs.
#ifdef SHOW_OUTPUT
sview.show(errorCalculator.get_errorMeshFunction());
#endif
// If err_est too large, adapt the mesh->
if(errorCalculator.get_total_error_squared() * 100. < ERR_STOP)
done = true;
else
{
std::cout << "Adapting..." << std::endl << std::endl;
adaptivity.adapt(&selector);
}
// Clean up.
delete [] coeff_vec;
// Increase counter.
as++;
}
while (done == false);
#ifdef SHOW_OUTPUT
// Show the reference solution - the final result.
sview.set_title("Fine mesh solution");
MeshFunctionSharedPtr<double> real_filter(new RealFilter(ref_sln));
sview.show(real_filter);
// Wait for all views to be closed.
Views::View::wait();
#endif
return as;
}