int main(int argc, char* argv[])
{
Hermes2D hermes_2D;
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain-excentric.mesh", &mesh);
//mloader.load("domain-concentric.mesh", &mesh);
// Initial mesh refinements.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary("Inner", INIT_BDY_REF_NUM_INNER, false); // true for anisotropic refinements
mesh.refine_towards_boundary("Outer", INIT_BDY_REF_NUM_OUTER, false); // false for isotropic refinements
// Initialize boundary conditions.
EssentialBCNonConstX bc_inner_vel_x(std::string("Inner"), VEL, STARTUP_TIME);
EssentialBCNonConstY bc_inner_vel_y(std::string("Inner"), VEL, STARTUP_TIME);
DefaultEssentialBCConst bc_outer_vel(std::string("Outer"), 0.0);
EssentialBCs bcs_vel_x(Hermes::vector<EssentialBoundaryCondition *>(&bc_inner_vel_x, &bc_outer_vel));
EssentialBCs bcs_vel_y(Hermes::vector<EssentialBoundaryCondition *>(&bc_inner_vel_y, &bc_outer_vel));
EssentialBCs bcs_pressure;
// Spaces for velocity components and pressure.
H1Space xvel_space(&mesh, &bcs_vel_x, P_INIT_VEL);
H1Space yvel_space(&mesh, &bcs_vel_y, P_INIT_VEL);
#ifdef PRESSURE_IN_L2
L2Space p_space(&mesh, &bcs_pressure, P_INIT_PRESSURE);
#else
H1Space p_space(&mesh, &bcs_pressure, P_INIT_PRESSURE);
#endif
Hermes::vector<Space *> spaces = Hermes::vector<Space *>(&xvel_space, &yvel_space, &p_space);
// Calculate and report the number of degrees of freedom.
int ndof = Space::get_num_dofs(spaces);
info("ndof = %d.", ndof);
// Define projection norms.
ProjNormType vel_proj_norm = HERMES_H1_NORM;
#ifdef PRESSURE_IN_L2
ProjNormType p_proj_norm = HERMES_L2_NORM;
#else
ProjNormType p_proj_norm = HERMES_H1_NORM;
#endif
// Solutions for the Newton's iteration and time stepping.
info("Setting initial conditions.");
Solution xvel_prev_time, yvel_prev_time, p_prev_time;
xvel_prev_time.set_zero(&mesh);
yvel_prev_time.set_zero(&mesh);
p_prev_time.set_zero(&mesh);
Hermes::vector<Solution*> slns = Hermes::vector<Solution*>(&xvel_prev_time, &yvel_prev_time,
&p_prev_time);
// Initialize weak formulation.
WeakForm* wf = new WeakFormNSNewton(STOKES, RE, TAU, &xvel_prev_time, &yvel_prev_time);
// Initialize the FE problem.
DiscreteProblem dp(wf, spaces);
// 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 views.
VectorView vview("velocity [m/s]", new WinGeom(0, 0, 600, 500));
ScalarView pview("pressure [Pa]", new WinGeom(610, 0, 600, 500));
//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);
pview.show_mesh(true);
// Project the initial condition on the FE space to obtain initial
// coefficient vector for the Newton's method.
scalar* coeff_vec = new scalar[Space::get_num_dofs(spaces)];
// Newton's vector is set to zero (no OG projection needed).
memset(coeff_vec, 0, ndof * sizeof(double));
/*
// This can be used for more complicated initial conditions.
info("Projecting initial condition to obtain initial vector for the Newton's method.");
OGProjection::project_global(spaces, slns, coeff_vec, matrix_solver,
Hermes::vector<ProjNormType>(vel_proj_norm, vel_proj_norm, p_proj_norm));
*/
// 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;
info("---- Time step %d, time = %g:", ts, current_time);
// Update time-dependent essential BCs.
info("Updating time-dependent essential BC.");
Space::update_essential_bc_values(Hermes::vector<Space *>(&xvel_space, &yvel_space, &p_space), current_time);
// Perform Newton's iteration.
info("Solving nonlinear problem:");
bool verbose = true;
bool jacobian_changed = true;
if (!hermes_2D.solve_newton(coeff_vec, &dp, solver, matrix, rhs, jacobian_changed,
NEWTON_TOL, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Update previous time level solutions.
Solution::vector_to_solutions(coeff_vec, spaces, slns);
// Show the solution at the end of time step.
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);
}
// Clean up.
delete [] coeff_vec;
delete matrix;
delete rhs;
delete solver;
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
Hermes2D hermes_2D;
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("../domain-excentric.mesh", &mesh);
//mloader.load("../domain-concentric.mesh", &mesh);
// Initial mesh refinements.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(BDY_INNER, INIT_BDY_REF_NUM_INNER, false); // true for anisotropic refinements
mesh.refine_towards_boundary(BDY_OUTER, INIT_BDY_REF_NUM_OUTER, false); // false for isotropic refinements
// Initialize boundary conditions.
EssentialBCNonConstX bc_inner_vel_x(BDY_INNER, VEL, STARTUP_TIME);
EssentialBCNonConstY bc_inner_vel_y(BDY_INNER, VEL, STARTUP_TIME);
DefaultEssentialBCConst bc_outer_vel(BDY_OUTER, 0.0);
EssentialBCs bcs_vel_x(Hermes::vector<EssentialBoundaryCondition *>(&bc_inner_vel_x, &bc_outer_vel));
EssentialBCs bcs_vel_y(Hermes::vector<EssentialBoundaryCondition *>(&bc_inner_vel_y, &bc_outer_vel));
EssentialBCs bcs_pressure;
// Spaces for velocity components and pressure.
H1Space xvel_space(&mesh, &bcs_vel_x, P_INIT_VEL);
H1Space yvel_space(&mesh, &bcs_vel_y, P_INIT_VEL);
#ifdef PRESSURE_IN_L2
L2Space p_space(&mesh, &bcs_pressure, P_INIT_PRESSURE);
#else
H1Space p_space(&mesh, &bcs_pressure, P_INIT_PRESSURE);
#endif
// Calculate and report the number of degrees of freedom.
int ndof = Space::get_num_dofs(Hermes::vector<Space *>(&xvel_space, &yvel_space, &p_space));
// Define projection norms.
ProjNormType vel_proj_norm = HERMES_H1_NORM;
#ifdef PRESSURE_IN_L2
ProjNormType p_proj_norm = HERMES_L2_NORM;
#else
ProjNormType p_proj_norm = HERMES_H1_NORM;
#endif
// Solutions for the Newton's iteration and time stepping.
Solution xvel_prev_time, yvel_prev_time, p_prev_time;
xvel_prev_time.set_zero(&mesh);
yvel_prev_time.set_zero(&mesh);
p_prev_time.set_zero(&mesh);
// Initialize weak formulation.
WeakForm* wf;
if (NEWTON)
wf = new WeakFormNSNewton(STOKES, RE, TAU, &xvel_prev_time, &yvel_prev_time);
else
wf = new WeakFormNSSimpleLinearization(STOKES, RE, TAU, &xvel_prev_time, &yvel_prev_time);
// Initialize the FE problem.
bool is_linear;
if (NEWTON) is_linear = false;
else is_linear = true;
DiscreteProblem dp(wf, Hermes::vector<Space *>(&xvel_space, &yvel_space, &p_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);
// Project the initial condition on the FE space to obtain initial
// coefficient vector for the Newton's method.
scalar* coeff_vec = new scalar[Space::get_num_dofs(Hermes::vector<Space *>(&xvel_space, &yvel_space, &p_space))];
if (NEWTON) {
OGProjection::project_global(Hermes::vector<Space *>(&xvel_space, &yvel_space, &p_space),
Hermes::vector<MeshFunction*>(&xvel_prev_time, &yvel_prev_time, &p_prev_time),
coeff_vec, matrix_solver,
Hermes::vector<ProjNormType>(vel_proj_norm, vel_proj_norm, p_proj_norm));
}
// 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;
// Update time-dependent essential BCs.
Space::update_essential_bc_values(Hermes::vector<Space *>(&xvel_space, &yvel_space, &p_space), current_time);
if (NEWTON)
{
// Perform Newton's iteration.
bool verbose = false;
if (!hermes_2D.solve_newton(coeff_vec, &dp, solver, matrix, rhs,
NEWTON_TOL, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
// Update previous time level solutions.
Solution::vector_to_solutions(coeff_vec, Hermes::vector<Space *>(&xvel_space, &yvel_space, &p_space),
Hermes::vector<Solution *>(&xvel_prev_time, &yvel_prev_time, &p_prev_time));
}
else {
// Linear solve.
dp.assemble(matrix, rhs, false);
if(solver->solve())
Solution::vector_to_solutions(solver->get_solution(),
Hermes::vector<Space *>(&xvel_space, &yvel_space, &p_space),
Hermes::vector<Solution *>(&xvel_prev_time, &yvel_prev_time, &p_prev_time));
else
error ("Matrix solver failed.\n");
}
}
// Clean up.
delete [] coeff_vec;
delete matrix;
delete rhs;
delete solver;
info("Coordinate ( -0.7, 0.0) xvel value = %lf", xvel_prev_time.get_pt_value(-0.7, 0.1));
info("Coordinate ( 0.65, 0.0) xvel value = %lf", xvel_prev_time.get_pt_value(0.65, 0.0));
info("Coordinate ( 0.7, 0.0) xvel value = %lf", xvel_prev_time.get_pt_value(0.7, 0.0));
info("Coordinate ( 0.9, 0.0) xvel value = %lf", xvel_prev_time.get_pt_value(0.9, 0.0));
info("Coordinate ( 1.1, 0.0) xvel value = %lf", xvel_prev_time.get_pt_value(1.1, 0.0));
info("Coordinate ( -0.7, 0.0) yvel value = %lf", yvel_prev_time.get_pt_value(-0.7, 0.1));
info("Coordinate ( 0.65, 0.0) yvel value = %lf", yvel_prev_time.get_pt_value(0.65, 0.0));
info("Coordinate ( 0.7, 0.0) yvel value = %lf", yvel_prev_time.get_pt_value(0.7, 0.0));
info("Coordinate ( 0.9, 0.0) yvel value = %lf", yvel_prev_time.get_pt_value(0.9, 0.0));
info("Coordinate ( 1.1, 0.0) yvel value = %lf", yvel_prev_time.get_pt_value(1.1, 0.0));
int success = 1;
double eps = 1e-5;
if (fabs(xvel_prev_time.get_pt_value(-0.7, 0.1) - (0.003199)) > eps) {
printf("Coordinate ( -0.7, 0.1) xvel value = %lf\n", xvel_prev_time.get_pt_value(-0.7, 0.1));
success = 0;
}
if (fabs(xvel_prev_time.get_pt_value(0.65, 0.0) - (-0.001314)) > eps) {
printf("Coordinate ( 0.65, 0.0) xvel value = %lf\n", xvel_prev_time.get_pt_value(0.65, 0.0));
success = 0;
}
if (fabs(xvel_prev_time.get_pt_value(0.7, 0.0) - (-0.001888)) > eps) {
printf("Coordinate ( 0.7, 0.0) xvel value = %lf\n", xvel_prev_time.get_pt_value(0.7, 0.0));
success = 0;
}
if (fabs(xvel_prev_time.get_pt_value(0.9, 0.0) - (-0.001262)) > eps) {
printf("Coordinate ( 0.9, 0.0) xvel value = %lf\n", xvel_prev_time.get_pt_value(0.9, 0.0));
success = 0;
}
if (fabs(xvel_prev_time.get_pt_value(1.1, 0.0) - (-0.000218)) > eps) {
printf("Coordinate ( 1.1, 0.0) xvel value = %lf\n", xvel_prev_time.get_pt_value(1.1, 0.0));
success = 0;
}
if (fabs(yvel_prev_time.get_pt_value(-0.7, 0.1) - (0.014744)) > eps) {
printf("Coordinate ( -0.7, 0.1) yvel value = %lf\n", yvel_prev_time.get_pt_value(-0.7, 0.1));
success = 0;
}
if (fabs(yvel_prev_time.get_pt_value(0.65, 0.0) - (-0.033332)) > eps) {
printf("Coordinate ( 0.65, 0.0) yvel value = %lf\n", yvel_prev_time.get_pt_value(0.65, 0.0));
success = 0;
}
if (fabs(yvel_prev_time.get_pt_value(0.7, 0.0) - (-0.012353)) > eps) {
printf("Coordinate ( 0.7, 0.0) yvel value = %lf\n", yvel_prev_time.get_pt_value(0.7, 0.0));
success = 0;
}
if (fabs(yvel_prev_time.get_pt_value(0.9, 0.0) - (-0.001691)) > eps) {
printf("Coordinate ( 0.9, 0.0) yvel value = %lf\n", yvel_prev_time.get_pt_value(0.9, 0.0));
success = 0;
}
if (fabs(yvel_prev_time.get_pt_value(1.1, 0.0) - (-0.000986)) > eps) {
printf("Coordinate ( 1.1, 0.0) yvel value = %lf\n", yvel_prev_time.get_pt_value(1.1, 0.0));
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.
MeshSharedPtr mesh(new Mesh);
MeshReaderH2D mloader;
mloader.load("domain-excentric.mesh", mesh);
//mloader.load("domain-concentric.mesh", mesh);
// Initial mesh refinements.
for (int i = 0; i < INIT_REF_NUM; i++)
mesh->refine_all_elements();
// Use 'true' for anisotropic refinements.
mesh->refine_towards_boundary("Inner", INIT_BDY_REF_NUM_INNER, false);
// Use 'false' for isotropic refinements.
mesh->refine_towards_boundary("Outer", INIT_BDY_REF_NUM_OUTER, false);
// Initialize boundary conditions.
EssentialBCNonConstX bc_inner_vel_x(std::string("Inner"), VEL, STARTUP_TIME);
EssentialBCNonConstY bc_inner_vel_y(std::string("Inner"), VEL, STARTUP_TIME);
DefaultEssentialBCConst<double> bc_outer_vel(std::string("Outer"), 0.0);
EssentialBCs<double> bcs_vel_x({ &bc_inner_vel_x, &bc_outer_vel });
EssentialBCs<double> bcs_vel_y({ &bc_inner_vel_y, &bc_outer_vel });
// 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, P_INIT_PRESSURE));
#endif
std::vector<SpaceSharedPtr<double> > spaces({ xvel_space, yvel_space, p_space });
// Calculate and report the number of degrees of freedom.
int ndof = Space<double>::get_num_dofs(spaces);
Hermes::Mixins::Loggable::Static::info("ndof = %d.", ndof);
// 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.
Hermes::Mixins::Loggable::Static::info("Setting initial conditions.");
MeshFunctionSharedPtr<double> xvel_prev_time(new ZeroSolution<double>(mesh));
MeshFunctionSharedPtr<double> yvel_prev_time(new ZeroSolution<double>(mesh));
MeshFunctionSharedPtr<double> p_prev_time(new ZeroSolution<double>(mesh));
// Initialize weak formulation.
WeakFormSharedPtr<double> wf(new WeakFormNSNewton(STOKES, RE, TAU, xvel_prev_time, yvel_prev_time));
// Initialize views.
VectorView vview("velocity [m/s]", new WinGeom(0, 0, 600, 500));
ScalarView pview("pressure [Pa]", new WinGeom(610, 0, 600, 500));
//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);
pview.show_mesh(true);
// Initialize the FE problem.
Hermes::Hermes2D::NewtonSolver<double> newton(wf, spaces);
newton.set_verbose_output(true);
newton.set_max_allowed_iterations(NEWTON_MAX_ITER);
newton.set_tolerance(NEWTON_TOL, Hermes::Solvers::ResidualNormAbsolute);
// 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 %d, time = %g:", ts, current_time);
// Update time-dependent essential BCs.
Hermes::Mixins::Loggable::Static::info("Updating time-dependent essential BC.");
Space<double>::update_essential_bc_values(spaces, current_time);
// Perform Newton's iteration.
Hermes::Mixins::Loggable::Static::info("Solving nonlinear problem:");
try
{
newton.solve();
}
catch (Hermes::Exceptions::Exception e)
{
e.print_msg();
throw Hermes::Exceptions::Exception("Newton's iteration failed.");
};
// Update previous time level solutions.
Solution<double>::vector_to_solutions(newton.get_sln_vector(), spaces, { xvel_prev_time, yvel_prev_time, p_prev_time });
// Show the solution at the end of time step.
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);
}
// Wait for all views to be closed.
View::wait();
return 0;
}
