int main(int argc, char* argv[])
{
// Load the mesh.
MeshSharedPtr mesh(new Mesh);
MeshReaderH2D mloader;
mloader.load("domain.mesh", mesh);
// Initial mesh refinements.
mesh->refine_towards_boundary(BDY_OBSTACLE, 2, false);
mesh->refine_towards_boundary(BDY_TOP, 2, true); // '4' is the number of levels,
mesh->refine_towards_boundary(BDY_BOTTOM, 2, true); // 'true' stands for anisotropic refinements.
mesh->refine_all_elements();
// Initialize boundary conditions.
EssentialBCNonConst bc_left_vel_x(BDY_LEFT, VEL_INLET, H, STARTUP_TIME);
Hermes::Hermes2D::DefaultEssentialBCConst<double> bc_other_vel_x(Hermes::vector<std::string>(BDY_BOTTOM, BDY_TOP, BDY_OBSTACLE), 0.0);
Hermes::Hermes2D::EssentialBCs<double> bcs_vel_x(Hermes::vector<EssentialBoundaryCondition<double> *>(&bc_left_vel_x, &bc_other_vel_x));
Hermes::Hermes2D::DefaultEssentialBCConst<double> bc_vel_y(Hermes::vector<std::string>(BDY_LEFT, BDY_BOTTOM, BDY_TOP, BDY_OBSTACLE), 0.0);
Hermes::Hermes2D::EssentialBCs<double> bcs_vel_y(&bc_vel_y);
Hermes::Hermes2D::EssentialBCs<double> bcs_pressure;
// Spaces for velocity components and pressure.
SpaceSharedPtr<double> xvel_space(new H1Space<double>(mesh, &bcs_vel_x, P_INIT_VEL));
SpaceSharedPtr<double> yvel_space(new H1Space<double>(mesh, &bcs_vel_y, P_INIT_VEL));
#ifdef PRESSURE_IN_L2
SpaceSharedPtr<double> p_space(new L2Space<double> (mesh, P_INIT_PRESSURE));
#else
SpaceSharedPtr<double> p_space(new H1Space<double> (mesh, &bcs_pressure, P_INIT_PRESSURE));
#endif
// Calculate and report the number of degrees of freedom.
int ndof = Space<double>::get_num_dofs(Hermes::vector<SpaceSharedPtr<double> >(xvel_space, yvel_space, p_space));
// Define projection norms.
NormType vel_proj_norm = HERMES_H1_NORM;
#ifdef PRESSURE_IN_L2
NormType p_proj_norm = HERMES_L2_NORM;
#else
NormType p_proj_norm = HERMES_H1_NORM;
#endif
// Solutions for the Newton's iteration and time stepping.
MeshFunctionSharedPtr<double> xvel_prev_time(new ConstantSolution<double> (mesh, 0.0));
MeshFunctionSharedPtr<double> yvel_prev_time(new ConstantSolution<double> (mesh, 0.0));
MeshFunctionSharedPtr<double> p_prev_time(new ConstantSolution<double> (mesh, 0.0));
// Initialize weak formulation.
WeakFormNSNewton wf(STOKES, RE, TAU, xvel_prev_time, yvel_prev_time);
UExtFunctionSharedPtr<double> fn_0(new CustomUExtFunction(0));
UExtFunctionSharedPtr<double> fn_1(new CustomUExtFunction(1));
wf.set_ext(Hermes::vector<MeshFunctionSharedPtr<double> >(xvel_prev_time, yvel_prev_time));
wf.set_u_ext_fn(Hermes::vector<UExtFunctionSharedPtr<double> >(fn_0, fn_1));
// Initialize the Newton solver.
Hermes::Hermes2D::NewtonSolver<double> newton;
newton.set_weak_formulation(&wf);
Hermes::vector<SpaceSharedPtr<double> > spaces(xvel_space, yvel_space, p_space);
newton.set_spaces(spaces);
// Initialize views.
Views::VectorView vview("velocity[m/s]", new Views::WinGeom(0, 0, 750, 240));
Views::ScalarView pview("pressure[Pa]", new Views::WinGeom(0, 290, 750, 240));
vview.set_min_max_range(0, 1.6);
vview.fix_scale_width(80);
//pview.set_min_max_range(-0.9, 1.0);
pview.fix_scale_width(80);
if(HERMES_VISUALIZATION)
pview.show_mesh(true);
// Project the initial condition on the FE space to obtain initial
// coefficient vector for the Newton's method.
double* coeff_vec = new double[Space<double>::get_num_dofs(Hermes::vector<SpaceSharedPtr<double> >(xvel_space, yvel_space, p_space))];
OGProjection<double> ogProjection;
ogProjection.project_global(Hermes::vector<SpaceSharedPtr<double> >(xvel_space, yvel_space, p_space),
Hermes::vector<MeshFunctionSharedPtr<double> >(xvel_prev_time, yvel_prev_time, p_prev_time),
coeff_vec, Hermes::vector<NormType>(vel_proj_norm, vel_proj_norm, p_proj_norm));
newton.set_max_allowed_iterations(max_allowed_iterations);
newton.set_tolerance(NEWTON_TOL, Hermes::Solvers::ResidualNormAbsolute);
newton.set_sufficient_improvement_factor_jacobian(1e-2);
//newton.set_jacobian_constant();
// Time-stepping loop:
char title[100];
int num_time_steps = T_FINAL / TAU;
for (int ts = 1; ts <= num_time_steps; ts++)
{
current_time += TAU;
Hermes::Mixins::Loggable::Static::info("Time step %i, time %f.", ts, current_time);
// Update time-dependent essential BCs.
newton.set_time(current_time);
// Perform Newton's iteration and translate the resulting coefficient vector into previous time level solutions.
try
{
newton.solve(coeff_vec);
}
catch(Hermes::Exceptions::Exception& e)
{
e.print_msg();
}
Hermes::vector<MeshFunctionSharedPtr<double> > tmp(xvel_prev_time, yvel_prev_time, p_prev_time);
Hermes::Hermes2D::Solution<double>::vector_to_solutions(newton.get_sln_vector(),
Hermes::vector<SpaceSharedPtr<double> >(xvel_space, yvel_space, p_space), tmp);
// Show the solution at the end of time step.
if(HERMES_VISUALIZATION)
{
sprintf(title, "Velocity, time %g", current_time);
vview.set_title(title);
vview.show(xvel_prev_time, yvel_prev_time);
sprintf(title, "Pressure, time %g", current_time);
pview.set_title(title);
pview.show(p_prev_time);
}
}
delete [] coeff_vec;
return 0;
}
int main(int argc, char* argv[])
{
#ifdef THREAD_TESTING
HermesCommonApi.set_integral_param_value(numThreads, 8);
#endif
// Load the mesh.
MeshSharedPtr mesh(new Mesh);
Hermes::vector<MeshSharedPtr> meshes;
meshes.push_back(mesh);
MeshReaderH2DXML mloader;
mloader.load("agrosMesh.msh", meshes);
// Perform initial mesh refinements.
for (int i = 0; i < INIT_REF_NUM; i++)
mesh->refine_all_elements();
// Initialize boundary conditions.
DefaultEssentialBCConst<complex> bc_essential("4", P_SOURCE);
EssentialBCs<complex> bcs(&bc_essential);
// Create an H1 space with default shapeset.
SpaceSharedPtr<complex> space(new H1Space<complex> (mesh, &bcs, P_INIT));
adaptivity.set_space(space);
// Initialize the weak formulation.
CustomWeakFormAcoustics wf("0", RHO, SOUND_SPEED, OMEGA);
// Initialize coarse and reference mesh solution.
MeshFunctionSharedPtr<complex> sln(new Solution<complex>), ref_sln(new Solution<complex>);
// Initialize refinement selector.
H1ProjBasedSelector<complex> selector(CAND_LIST);
Hermes::Hermes2D::NewtonSolver<complex> newton;
newton.set_weak_formulation(&wf);
// 2 Adaptivity steps:
int as = 1;
bool done = false;
do
{
// Construct globally refined reference mesh and setup reference space.
Mesh::ReferenceMeshCreator refMeshCreator(mesh);
MeshSharedPtr ref_mesh = refMeshCreator.create_ref_mesh();
Space<complex>::ReferenceSpaceCreator refSpaceCreator(space, ref_mesh);
SpaceSharedPtr<complex> ref_space = refSpaceCreator.create_ref_space();
// Perform Newton's iteration.
try
{
newton.set_space(ref_space);
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<complex> sln->
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);
adaptivity.adapt(&selector);
}
while (as++ < 2);
return 0;
}