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; }