void Continuity<Scalar>::Record::load_mesh(Mesh* mesh) { MeshReaderH2DXML reader; std::stringstream filename; filename << Continuity<Scalar>::meshFileName << 0 << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d"; reader.load(filename.str().c_str(), mesh); }
void load_mesh(MeshSharedPtr& mesh, const char* filename, int num_initial_refinements) { MeshReaderH2DXML mloader; mloader.load(filename, mesh); // Perform initial mesh refinements. for (int i = 0; i < INIT_REF_NUM; i++) mesh->refine_all_elements(0, true); }
void Continuity<Scalar>::Record::load_meshes(Hermes::vector<Mesh*> meshes) { MeshReaderH2DXML reader; for(unsigned int i = 0; i < meshes.size(); i++) { std::stringstream filename; filename << Continuity<Scalar>::meshFileName << i << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d"; reader.load(filename.str().c_str(), meshes[i]); } }
void CalculationContinuity<Scalar>::Record::save_mesh(Mesh* mesh) { MeshReaderH2DXML reader; std::stringstream filename; filename << CalculationContinuity<Scalar>::mesh_file_name << 0 << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d"; try { reader.save(filename.str().c_str(), mesh); } catch(std::exception& e) { throw IOCalculationContinuityException(CalculationContinuityException::meshes, IOCalculationContinuityException::output, filename.str().c_str(), e.what()); } }
int main(int argc, char* argv[]) { // Load the mesh. Mesh mesh_whole_domain, mesh_bottom_left_corner, mesh_complement; Hermes::vector<Mesh*> meshes (&mesh_whole_domain, &mesh_bottom_left_corner, &mesh_complement); MeshReaderH2DXML mloader; mloader.load("subdomains.xml", meshes); // Perform initial mesh refinements (optional). for(int i = 0; i < INIT_REF_NUM; i++) for(unsigned int meshes_i = 0; meshes_i < meshes.size(); meshes_i++) meshes[meshes_i]->refine_all_elements(); mloader.save("subdomains2.xml", meshes); mloader.load("subdomains2.xml", meshes); // Initialize essential boundary conditions. DefaultEssentialBCConst<double> bc_essential_whole_domain(Hermes::vector<std::string>("Bottom Left", "Bottom Right", "Top Left", "Top Right"), 0.0); EssentialBCs<double> bcs_whole_domain(&bc_essential_whole_domain); DefaultEssentialBCConst<double> bc_essential_bottom_left_corner(Hermes::vector<std::string>("Bottom Left", "Horizontal Left"), 0.0); EssentialBCs<double> bcs_bottom_left_corner(&bc_essential_bottom_left_corner); DefaultEssentialBCConst<double> bc_essential_complement(Hermes::vector<std::string>("Bottom Right", "Top Right", "Top Left", "Horizontal Left", "Vertical Bottom"), 0.0); EssentialBCs<double> bcs_complement(&bc_essential_complement); // Create H1 spaces with default shapeset. H1Space<double> space_whole_domain(&mesh_whole_domain, &bcs_whole_domain, P_INIT); int ndof_whole_domain = space_whole_domain.get_num_dofs(); H1Space<double> space_bottom_left_corner(&mesh_bottom_left_corner, &bcs_bottom_left_corner, P_INIT); int ndof_bottom_left_corner = space_bottom_left_corner.get_num_dofs(); H1Space<double> space_complement(&mesh_complement, &bcs_complement, P_INIT); int ndof_complement = space_complement.get_num_dofs(); if(ndof_whole_domain == 225 && ndof_bottom_left_corner == 56 && ndof_complement == 161) { info("Success!"); return TEST_SUCCESS; } else { info("Failure!"); return TEST_FAILURE; } return 0; }
void CalculationContinuity<Scalar>::Record::load_mesh(Mesh* mesh) { MeshReaderH2DXML reader; std::stringstream filename; filename << CalculationContinuity<Scalar>::mesh_file_name << 0 << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d"; try { reader.load(filename.str().c_str(), mesh); } catch(Hermes::Exceptions::MeshLoadFailureException& e) { throw IOCalculationContinuityException(CalculationContinuityException::meshes, IOCalculationContinuityException::input, filename.str().c_str(), e.what()); } }
int main(int argc, char* argv[]) { // Load the mesh. MeshSharedPtr mesh_whole_domain(new Mesh), mesh_bottom_left_corner(new Mesh), mesh_complement(new Mesh); Hermes::vector<MeshSharedPtr> meshes (mesh_bottom_left_corner, mesh_whole_domain, mesh_complement); MeshReaderH2DXML mloader; mloader.set_validation(false); mloader.load("subdomains.xml", meshes); // Perform initial mesh refinements (optional). for(int i = 0; i < INIT_REF_NUM; i++) for(unsigned int meshes_i = 0; meshes_i < meshes.size(); meshes_i++) meshes[meshes_i]->refine_all_elements(); mloader.save("subdomains2.xml", meshes); mloader.load("subdomains2.xml", meshes); // Initialize essential boundary conditions. DefaultEssentialBCConst<double> bc_essential_whole_domain(Hermes::vector<std::string>("Bottom Left", "Bottom Right", "Top Left", "Top Right"), 0.0); EssentialBCs<double> bcs_whole_domain(&bc_essential_whole_domain); DefaultEssentialBCConst<double> bc_essential_bottom_left_corner(Hermes::vector<std::string>("Bottom Left", "Horizontal Left"), 0.0); EssentialBCs<double> bcs_bottom_left_corner(&bc_essential_bottom_left_corner); DefaultEssentialBCConst<double> bc_essential_complement(Hermes::vector<std::string>("Bottom Right", "Top Right", "Top Left", "Horizontal Left", "Vertical Bottom"), 0.0); EssentialBCs<double> bcs_complement(&bc_essential_complement); // Create H1 spaces with default shapeset. SpaceSharedPtr<double> space_whole_domain(new H1Space<double>(mesh_whole_domain, &bcs_whole_domain, P_INIT)); int ndof_whole_domain = space_whole_domain->get_num_dofs(); SpaceSharedPtr<double> space_bottom_left_corner(new H1Space<double>(mesh_bottom_left_corner, &bcs_bottom_left_corner, P_INIT)); int ndof_bottom_left_corner = space_bottom_left_corner->get_num_dofs(); SpaceSharedPtr<double> space_complement(new H1Space<double>(mesh_complement, &bcs_complement, P_INIT)); int ndof_complement = space_complement->get_num_dofs(); if(ndof_whole_domain == 225 && ndof_bottom_left_corner == 56 && ndof_complement == 161) { return 0; } else { return -1; } return 0; }
void CalculationContinuity<Scalar>::Record::load_meshes(Hermes::vector<Mesh*> meshes) { MeshReaderH2DXML reader; for(unsigned int i = 0; i < meshes.size(); i++) { std::stringstream filename; filename << CalculationContinuity<Scalar>::mesh_file_name << i << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d"; try { reader.load(filename.str().c_str(), meshes[i]); } catch(Hermes::Exceptions::MeshLoadFailureException& e) { throw IOCalculationContinuityException(CalculationContinuityException::meshes, IOCalculationContinuityException::input, filename.str().c_str(), e.what()); } } }
int main(int argc, char* argv[]) { // Load the mesh. MeshSharedPtr u_mesh(new Mesh), v_mesh(new Mesh); MeshReaderH2DXML mloader; mloader.load("domain.xml", u_mesh); u_mesh->refine_all_elements(); v_mesh->copy(u_mesh); v_mesh->refine_towards_boundary("Bdy", INIT_REF_BDY); // Define right-hand sides. CustomRightHandSide1* g1 = new CustomRightHandSide1(K, D_u, SIGMA); CustomRightHandSide2* g2 = new CustomRightHandSide2(K, D_v); // Initialize the weak formulation. CustomWeakForm wf(g1, g2); // Initialize boundary conditions DefaultEssentialBCConst<double> bc_u("Bdy", 0.0); EssentialBCs<double> bcs_u(&bc_u); DefaultEssentialBCConst<double> bc_v("Bdy", 0.0); EssentialBCs<double> bcs_v(&bc_v); // Create H1 spaces with default shapeset for both displacement components. SpaceSharedPtr<double> u_space(new H1Space<double>(u_mesh, &bcs_u, P_INIT_U)); SpaceSharedPtr<double> v_space(new H1Space<double>(v_mesh, &bcs_v, P_INIT_V)); Hermes::vector<SpaceSharedPtr<double> > spaces(u_space, v_space); NewtonSolver<double> newton(&wf, spaces); MeshFunctionSharedPtr<double> u_sln(new Solution<double>()); MeshFunctionSharedPtr<double> u_sln1(new Solution<double>()); MeshFunctionSharedPtr<double> v_sln(new Solution<double>()); MeshFunctionSharedPtr<double> v_sln1(new Solution<double>()); Hermes::vector<MeshFunctionSharedPtr<double> > slns(u_sln, v_sln); Hermes::vector<MeshFunctionSharedPtr<double> > slns1(u_sln1, v_sln1); newton.solve(); Solution<double>::vector_to_solutions(newton.get_sln_vector(), spaces, slns); u_sln1->copy(u_sln); v_sln1->copy(v_sln); u_sln->free(); v_sln->free(); u_sln->copy(u_sln1); v_sln->copy(v_sln1); newton.solve(slns); Solution<double>::vector_to_solutions(newton.get_sln_vector(), spaces, slns1); Linearizer lin(FileExport); lin.process_solution(u_sln); lin.process_solution(u_sln1); lin.process_solution(v_sln1); lin.process_solution(u_sln1); lin.process_solution(u_sln1); lin.process_solution(v_sln1); return 0; }
int main(int argc, char* argv[]) { // Load the mesh. Mesh mesh_whole_domain, mesh_without_hole; Hermes::vector<Mesh*> meshes (&mesh_whole_domain, &mesh_without_hole); MeshReaderH2DXML mloader; mloader.load("subdomains.xml", meshes); // Perform initial mesh refinements (optional). for(int i = 0; i < INIT_REF_NUM; i++) for(unsigned int meshes_i = 0; meshes_i < meshes.size(); meshes_i++) meshes[meshes_i]->refine_all_elements(); // Perform refinement towards the hole. for(unsigned int meshes_i = 0; meshes_i < meshes.size(); meshes_i++) meshes[meshes_i]->refine_towards_boundary("Inner", INIT_REF_NUM_HOLE); // Initialize boundary conditions. // Flow. EssentialBCNonConst bc_inlet_vel_x("Inlet", VEL_INLET, H, STARTUP_TIME); DefaultEssentialBCConst<double> bc_other_vel_x(Hermes::vector<std::string>("Outer", "Inner"), 0.0); EssentialBCs<double> bcs_vel_x(Hermes::vector<EssentialBoundaryCondition<double> *>(&bc_inlet_vel_x, &bc_other_vel_x)); DefaultEssentialBCConst<double> bc_vel_y(Hermes::vector<std::string>("Inlet", "Outer", "Inner"), 0.0); EssentialBCs<double> bcs_vel_y(&bc_vel_y); EssentialBCs<double> bcs_pressure; // Temperature. DefaultEssentialBCConst<double> bc_temperature(Hermes::vector<std::string>("Inlet", "Outer"), 20.0); EssentialBCs<double> bcs_temperature(&bc_temperature); // Spaces for velocity components and pressure. H1Space<double> xvel_space(&mesh_without_hole, &bcs_vel_x, P_INIT_VEL); H1Space<double> yvel_space(&mesh_without_hole, &bcs_vel_y, P_INIT_VEL); #ifdef PRESSURE_IN_L2 L2Space<double> p_space(&mesh_without_hole, P_INIT_PRESSURE); #else H1Space<double> p_space(&mesh_without_hole, &bcs_pressure, P_INIT_PRESSURE); #endif // Space<double> for temperature. H1Space<double> temperature_space(&mesh_whole_domain, &bcs_temperature, P_INIT_TEMP); // Calculate and report the number of degrees of freedom. int ndof = Space<double>::get_num_dofs(Hermes::vector<Space<double> *>(&xvel_space, &yvel_space, &p_space, &temperature_space)); 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 ProjNormType temperature_proj_norm = HERMES_H1_NORM; // Solutions for the Newton's iteration and time stepping. info("Setting initial conditions."); ZeroSolution xvel_prev_time(&mesh_without_hole), yvel_prev_time(&mesh_without_hole), p_prev_time(&mesh_without_hole); ConstantSolution<double> temperature_prev_time(&mesh_whole_domain, TEMP_INIT); // Calculate Reynolds number. double reynolds_number = VEL_INLET * OBSTACLE_DIAMETER / KINEMATIC_VISCOSITY_WATER; info("RE = %g", reynolds_number); // Initialize weak formulation. CustomWeakFormHeatAndFlow wf(STOKES, reynolds_number, time_step, &xvel_prev_time, &yvel_prev_time, &temperature_prev_time, HEAT_SOURCE_GRAPHITE, SPECIFIC_HEAT_GRAPHITE, SPECIFIC_HEAT_WATER, RHO_GRAPHITE, RHO_WATER, THERMAL_CONDUCTIVITY_GRAPHITE, THERMAL_CONDUCTIVITY_WATER); // Initialize the FE problem. DiscreteProblem<double> dp(&wf, Hermes::vector<Space<double> *>(&xvel_space, &yvel_space, &p_space, &temperature_space)); // Initialize the Newton solver. NewtonSolver<double> newton(&dp, matrix_solver_type); // Initialize views. Views::VectorView vview("velocity [m/s]", new Views::WinGeom(0, 0, 500, 300)); Views::ScalarView pview("pressure [Pa]", new Views::WinGeom(0, 310, 500, 300)); Views::ScalarView tempview("temperature [C]", new Views::WinGeom(510, 0, 500, 300)); 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. double* coeff_vec = new double[ndof]; info("Projecting initial condition to obtain initial vector for the Newton's method."); OGProjection<double>::project_global(Hermes::vector<Space<double> *>(&xvel_space, &yvel_space, &p_space, &temperature_space), Hermes::vector<MeshFunction<double> *>(&xvel_prev_time, &yvel_prev_time, &p_prev_time, &temperature_prev_time), coeff_vec, matrix_solver_type, Hermes::vector<ProjNormType>(vel_proj_norm, vel_proj_norm, p_proj_norm, temperature_proj_norm)); // Time-stepping loop: char title[100]; int num_time_steps = T_FINAL / time_step; double current_time = 0.0; for (int ts = 1; ts <= num_time_steps; ts++) { current_time += time_step; info("---- Time step %d, time = %g:", ts, current_time); // Update time-dependent essential BCs. if (current_time <= STARTUP_TIME) { info("Updating time-dependent essential BC."); Space<double>::update_essential_bc_values(Hermes::vector<Space<double> *>(&xvel_space, &yvel_space, &p_space, &temperature_space), current_time); } // Perform Newton's iteration. info("Solving nonlinear problem:"); bool verbose = true; // Perform Newton's iteration and translate the resulting coefficient vector into previous time level solutions. newton.set_verbose_output(verbose); try { newton.solve(coeff_vec, NEWTON_TOL, NEWTON_MAX_ITER); } catch(Hermes::Exceptions::Exception e) { e.printMsg(); error("Newton's iteration failed."); }; { Hermes::vector<Solution<double> *> tmp(&xvel_prev_time, &yvel_prev_time, &p_prev_time, &temperature_prev_time); Solution<double>::vector_to_solutions(newton.get_sln_vector(), Hermes::vector<Space<double> *>(&xvel_space, &yvel_space, &p_space, &temperature_space), tmp); } // Show the solution at the end of time step. sprintf(title, "Velocity [m/s], time %g s", current_time); vview.set_title(title); vview.show(&xvel_prev_time, &yvel_prev_time, Views::HERMES_EPS_LOW); sprintf(title, "Pressure [Pa], time %g s", current_time); pview.set_title(title); pview.show(&p_prev_time); sprintf(title, "Temperature [C], time %g s", current_time); tempview.set_title(title); tempview.show(&temperature_prev_time); } delete [] coeff_vec; // Wait for all views to be closed. Views::View::wait(); return 0; }
int main(int argc, char* argv[]) { // Load the mesh. MeshSharedPtr mesh(new Mesh), mesh1(new Mesh); if (USE_XML_FORMAT == true) { MeshReaderH2DXML mloader; Hermes::Mixins::Loggable::Static::info("Reading mesh in XML format."); mloader.load("square.xml", mesh); } else { MeshReaderH2D mloader; Hermes::Mixins::Loggable::Static::info("Reading mesh in original format."); mloader.load("square.mesh", mesh); } // Perform uniform mesh refinement. int refinement_type = 0; for (int i = 0; i < INIT_REF_NUM; i++) mesh->refine_all_elements(refinement_type); // Show mesh. MeshView mv("Mesh", new WinGeom(0, 0, 580, 400)); mv.show(mesh); // Exact lambda MeshFunctionSharedPtr<double> exact_lambda(new ExactSolutionLambda(mesh,E,nu)); ScalarView viewLam("lambda [Pa]", new WinGeom(0, 460, 530, 350)); viewLam.show_mesh(false); viewLam.show(exact_lambda); // Exact lambda MeshFunctionSharedPtr<double> exact_mu(new ExactSolutionMu(mesh,E,nu)); ScalarView viewMu("mu [Pa]", new WinGeom(550, 460, 530, 350)); viewMu.show_mesh(false); viewMu.show(exact_mu); // Initialize boundary conditions. DefaultEssentialBCConst<double> disp_bot_top_x(Hermes::vector<std::string>("Bottom","Top"), 0.0); DefaultEssentialBCConst<double> disp_bot_y("Bottom", 0.0); DefaultEssentialBCConst<double> disp_top_y("Top", 0.1); EssentialBCs<double> bcs_x(&disp_bot_top_x); EssentialBCs<double> bcs_y(Hermes::vector<EssentialBoundaryCondition<double> *>(&disp_bot_y, &disp_top_y)); // Create x- and y- displacement space using the default H1 shapeset. SpaceSharedPtr<double> u1_space(new H1Space<double>(mesh, &bcs_x, P_INIT)); SpaceSharedPtr<double> u2_space(new H1Space<double>(mesh, &bcs_y, P_INIT)); Hermes::vector<SpaceSharedPtr<double> > spaces(u1_space, u2_space); int ndof = Space<double>::get_num_dofs(spaces); Hermes::Mixins::Loggable::Static::info("ndof = %d", ndof); // Initialize the weak formulation. CustomWeakFormLinearElasticity wf(E, nu, &lambdaFun, &muFun, rho*g1, "Top", f0, f1); // Initialize Newton solver. NewtonSolver<double> newton(&wf, spaces); newton.set_verbose_output(true); // Perform Newton's iteration. try { newton.solve(); } catch(std::exception& e) { std::cout << e.what(); Hermes::Mixins::Loggable::Static::info("Newton's iteration failed."); } // Translate the resulting coefficient vector into the Solution sln. MeshFunctionSharedPtr<double> u1_sln(new Solution<double>), u2_sln(new Solution<double>); Hermes::vector<MeshFunctionSharedPtr<double> > solutions(u1_sln, u2_sln); Solution<double>::vector_to_solutions(newton.get_sln_vector(), spaces, solutions); // Visualize the solution. ScalarView view("Von Mises stress [Pa]", new WinGeom(590, 0, 700, 400)); // First Lame constant. double lambda = (E * nu) / ((1 + nu) * (1 - 2*nu)); // Second Lame constant. double mu = E / (2*(1 + nu)); MeshFunctionSharedPtr<double> stress(new VonMisesFilter(solutions, lambda, mu)); MeshFunctionSharedPtr<double> S11(new CustomFilterS11(solutions, &muFun, &lambdaFun)); MeshFunctionSharedPtr<double> S12(new CustomFilterS12(solutions, mu)); MeshFunctionSharedPtr<double> S22(new CustomFilterS22(solutions, mu, lambda)); view.show_mesh(false); view.show(stress, HERMES_EPS_HIGH, H2D_FN_VAL_0, u1_sln, u2_sln, 1.0); ScalarView viewS11("S11 [Pa]", new WinGeom(0, 260, 530, 350)); viewS11.show_mesh(false); viewS11.show(S11, HERMES_EPS_HIGH, H2D_FN_VAL_0, u1_sln, u2_sln, 1.0); ScalarView viewS12("S12 [Pa]", new WinGeom(540, 260, 530, 350)); viewS12.show_mesh(false); viewS12.show(S12, HERMES_EPS_HIGH, H2D_FN_VAL_0, u1_sln, u2_sln, 1.0); ScalarView viewS22("S22 [Pa]", new WinGeom(1080, 260, 530, 350)); viewS22.show_mesh(false); viewS22.show(S22, HERMES_EPS_HIGH, H2D_FN_VAL_0, u1_sln, u2_sln, 1.0); // Wait for the view to be closed. View::wait(); return 0; }
int main(int argc, char* argv[]) { // Check number of command-line parameters. if (argc < 2) error("Not enough parameters."); // Load the mesh. Mesh mesh; MeshReaderH2DXML mloader; if (strcasecmp(argv[1], "1") == 0) mloader.load(mesh_file_1, &mesh); if (strcasecmp(argv[1], "2") == 0) mloader.load(mesh_file_2, &mesh); if (strcasecmp(argv[1], "3") == 0) mloader.load(mesh_file_3, &mesh); // Perform initial mesh refinements (optional). for (int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements(); // Initialize boundary conditions. DefaultEssentialBCConst<double> bc_essential("Bdy", 0.0); EssentialBCs<double> bcs(&bc_essential); // Create an H1 space with default shapeset. H1Space<double> space(&mesh, &bcs, P_INIT); int ndof = Space<double>::get_num_dofs(&space); info("ndof = %d", ndof); // Initialize the weak formulation. WeakFormsH1::DefaultWeakFormPoisson<double> wf(new Hermes1DFunction<double>(1.0), new Hermes2DFunction<double>(-const_f)); // Initialize the FE problem. DiscreteProblem<double> dp(&wf, &space); // Set up the solver, matrix, and rhs according to the solver selection. SparseMatrix<double>* matrix = create_matrix<double>(matrix_solver); Vector<double>* rhs = create_vector<double>(matrix_solver); LinearSolver<double>* solver = create_linear_solver<double>(matrix_solver, matrix, rhs); // Initial coefficient vector for the Newton's method. double* coeff_vec = new double[ndof]; memset(coeff_vec, 0, ndof*sizeof(double)); // Perform Newton's iteration. Hermes::Hermes2D::Solution<double> sln; Hermes::Hermes2D::NewtonSolver<double> newton(&dp, matrix_solver); try{ newton.solve(coeff_vec); } catch(Hermes::Exceptions::Exception e) { e.printMsg(); error("Newton's iteration failed."); } Hermes::Hermes2D::Solution<double>::vector_to_solution(newton.get_sln_vector(), &space, &sln); // Clean up. delete solver; delete matrix; delete rhs; info("Coordinate ( 0.3, 0.5) value = %lf", sln.get_pt_value(0.3, 0.5)); info("Coordinate ( 0.7, 0.5) value = %lf", sln.get_pt_value(0.7, 0.5)); info("Coordinate ( 1.3, 0.5) value = %lf", sln.get_pt_value(1.3, 0.5)); info("Coordinate ( 1.7, 0.5) value = %lf", sln.get_pt_value(1.7, 0.5)); double coor_x[4] = {0.3, 0.7, 1.3, 1.7}; double coor_y = 0.5; double value[4] = {0.102569, 0.167907, 0.174203, 0.109630}; if (strcasecmp(argv[1], "2") == 0) { value[0] = 0.062896; value[1] = 0.096658; value[2] = 0.114445; value[3] = 0.081221; } if (strcasecmp(argv[1], "3") == 0) { value[0] = 0.048752; value[1] = 0.028585; value[2] = 0.028585; value[3] = 0.048752; } bool success = true; for (int i = 0; i < 4; i++) { if (Hermes::abs(value[i] - sln.get_pt_value(coor_x[i], coor_y)) > 1E-6) success = false; } if (success) { printf("Success!\n"); return TEST_SUCCESS; } else { printf("Failure!\n"); return TEST_FAILURE; } }
int main(int argc, char* argv[]) { // Load the mesh. Mesh mesh_whole_domain, mesh_with_hole; Hermes::vector<Mesh*> meshes (&mesh_whole_domain, &mesh_with_hole); MeshReaderH2DXML mloader; mloader.load("domain.xml", meshes); // Temperature mesh: Initial uniform mesh refinements in graphite. meshes[0]->refine_by_criterion(element_in_graphite, INIT_REF_NUM_TEMPERATURE_GRAPHITE); // Temperature mesh: Initial uniform mesh refinements in fluid. meshes[0]->refine_by_criterion(element_in_fluid, INIT_REF_NUM_TEMPERATURE_FLUID); // Fluid mesh: Initial uniform mesh refinements. for(int i = 0; i < INIT_REF_NUM_FLUID; i++) meshes[1]->refine_all_elements(); // Initial refinements towards boundary of graphite. for(unsigned int meshes_i = 0; meshes_i < meshes.size(); meshes_i++) meshes[meshes_i]->refine_towards_boundary("Inner Wall", INIT_REF_NUM_BDY_GRAPHITE); // Initial refinements towards the top and bottom edges. for(unsigned int meshes_i = 0; meshes_i < meshes.size(); meshes_i++) meshes[meshes_i]->refine_towards_boundary("Outer Wall", INIT_REF_NUM_BDY_WALL); /* View both meshes. */ MeshView m1("Mesh for temperature"), m2("Mesh for fluid"); m1.show(&mesh_whole_domain); m2.show(&mesh_with_hole); // Initialize boundary conditions. EssentialBCNonConst bc_inlet_vel_x("Inlet", VEL_INLET, H, STARTUP_TIME); DefaultEssentialBCConst<double> bc_other_vel_x(Hermes::vector<std::string>("Outer Wall", "Inner Wall"), 0.0); EssentialBCs<double> bcs_vel_x(Hermes::vector<EssentialBoundaryCondition<double> *>(&bc_inlet_vel_x, &bc_other_vel_x)); DefaultEssentialBCConst<double> bc_vel_y(Hermes::vector<std::string>("Inlet", "Outer Wall", "Inner Wall"), 0.0); EssentialBCs<double> bcs_vel_y(&bc_vel_y); EssentialBCs<double> bcs_pressure; DefaultEssentialBCConst<double> bc_temperature(Hermes::vector<std::string>("Outer Wall", "Inlet"), 20.0); EssentialBCs<double> bcs_temperature(&bc_temperature); // Spaces for velocity components, pressure and temperature. H1Space<double> xvel_space(&mesh_with_hole, &bcs_vel_x, P_INIT_VEL); H1Space<double> yvel_space(&mesh_with_hole, &bcs_vel_y, P_INIT_VEL); #ifdef PRESSURE_IN_L2 L2Space<double> p_space(&mesh_with_hole, P_INIT_PRESSURE); #else H1Space<double> p_space(&mesh_with_hole, &bcs_pressure, P_INIT_PRESSURE); #endif H1Space<double> temperature_space(&mesh_whole_domain, &bcs_temperature, P_INIT_TEMPERATURE); Hermes::vector<Space<double> *> all_spaces(&xvel_space, &yvel_space, &p_space, &temperature_space); Hermes::vector<const Space<double> *> all_spaces_const(&xvel_space, &yvel_space, &p_space, &temperature_space); // Calculate and report the number of degrees of freedom. int ndof = Space<double>::get_num_dofs(Hermes::vector<const Space<double> *>(&xvel_space, &yvel_space, &p_space, &temperature_space)); 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 ProjNormType temperature_proj_norm = HERMES_H1_NORM; Hermes::vector<ProjNormType> all_proj_norms = Hermes::vector<ProjNormType>(vel_proj_norm, vel_proj_norm, p_proj_norm, temperature_proj_norm); // Initial conditions and such. info("Setting initial conditions."); ZeroSolution xvel_prev_time(&mesh_with_hole), yvel_prev_time(&mesh_with_hole), p_prev_time(&mesh_with_hole); CustomInitialConditionTemperature temperature_init_cond(&mesh_whole_domain, HOLE_MID_X, HOLE_MID_Y, 0.5*OBSTACLE_DIAMETER, TEMPERATURE_INIT_FLUID, TEMPERATURE_INIT_GRAPHITE); Solution<double> temperature_prev_time; Hermes::vector<Solution<double> *> all_solutions = Hermes::vector<Solution<double> *>(&xvel_prev_time, &yvel_prev_time, &p_prev_time, &temperature_prev_time); Hermes::vector<MeshFunction<double> *> all_meshfns = Hermes::vector<MeshFunction<double> *>(&xvel_prev_time, &yvel_prev_time, &p_prev_time, &temperature_init_cond); // Project all initial conditions on their FE spaces to obtain aninitial // coefficient vector for the Newton's method. We use local projection // to avoid oscillations in temperature on the graphite-fluid interface // FIXME - currently the LocalProjection only does the lowest-order part (linear // interpolation) at the moment. Higher-order part needs to be added. double* coeff_vec = new double[ndof]; info("Projecting initial condition to obtain initial vector for the Newton's method."); //OGProjection<double>::project_global(all_spaces, all_meshfns, coeff_vec, matrix_solver, all_proj_norms); LocalProjection<double>::project_local(all_spaces_const, all_meshfns, coeff_vec, matrix_solver, all_proj_norms); // Translate the solution vector back to Solutions. This is needed to replace // the discontinuous initial condition for temperature_prev_time with its projection. Solution<double>::vector_to_solutions(coeff_vec, all_spaces_const, all_solutions); // Calculate Reynolds number. double reynolds_number = VEL_INLET * OBSTACLE_DIAMETER / KINEMATIC_VISCOSITY_FLUID; info("RE = %g", reynolds_number); if (reynolds_number < 1e-8) error("Re == 0 will not work - the equations use 1/Re."); // Initialize weak formulation. CustomWeakFormHeatAndFlow wf(STOKES, reynolds_number, time_step, &xvel_prev_time, &yvel_prev_time, &temperature_prev_time, HEAT_SOURCE_GRAPHITE, SPECIFIC_HEAT_GRAPHITE, SPECIFIC_HEAT_FLUID, RHO_GRAPHITE, RHO_FLUID, THERMAL_CONDUCTIVITY_GRAPHITE, THERMAL_CONDUCTIVITY_FLUID, SIMPLE_TEMPERATURE_ADVECTION); // Initialize the FE problem. DiscreteProblem<double> dp(&wf, all_spaces_const); // Initialize the Newton solver. NewtonSolver<double> newton(&dp, matrix_solver); // Initialize views. Views::VectorView vview("velocity [m/s]", new Views::WinGeom(0, 0, 700, 360)); Views::ScalarView pview("pressure [Pa]", new Views::WinGeom(0, 415, 700, 350)); Views::ScalarView tempview("temperature [C]", new Views::WinGeom(0, 795, 700, 350)); //vview.set_min_max_range(0, 0.5); vview.fix_scale_width(80); //pview.set_min_max_range(-0.9, 1.0); pview.fix_scale_width(80); pview.show_mesh(false); tempview.fix_scale_width(80); tempview.show_mesh(false); // Time-stepping loop: char title[100]; int num_time_steps = T_FINAL / time_step; double current_time = 0.0; for (int ts = 1; ts <= num_time_steps; ts++) { current_time += time_step; info("---- Time step %d, time = %g:", ts, current_time); // Update time-dependent essential BCs. if (current_time <= STARTUP_TIME) { info("Updating time-dependent essential BC."); Space<double>::update_essential_bc_values(Hermes::vector<Space<double> *>(&xvel_space, &yvel_space, &p_space, &temperature_space), current_time); } // Perform Newton's iteration. info("Solving nonlinear problem:"); bool verbose = true; // Perform Newton's iteration and translate the resulting coefficient vector into previous time level solutions. newton.set_verbose_output(verbose); try { newton.solve(coeff_vec, NEWTON_TOL, NEWTON_MAX_ITER); } catch(Hermes::Exceptions::Exception e) { e.printMsg(); error("Newton's iteration failed."); }; { Hermes::vector<Solution<double> *> tmp(&xvel_prev_time, &yvel_prev_time, &p_prev_time, &temperature_prev_time); Solution<double>::vector_to_solutions(newton.get_sln_vector(), Hermes::vector<const Space<double> *>(&xvel_space, &yvel_space, &p_space, &temperature_space), tmp); } // Show the solution at the end of time step. sprintf(title, "Velocity [m/s], time %g s", current_time); vview.set_title(title); vview.show(&xvel_prev_time, &yvel_prev_time); sprintf(title, "Pressure [Pa], time %g s", current_time); pview.set_title(title); pview.show(&p_prev_time); sprintf(title, "Temperature [C], time %g s", current_time); tempview.set_title(title); tempview.show(&temperature_prev_time, Views::HERMES_EPS_HIGH); } delete [] coeff_vec; // Wait for all views to be closed. Views::View::wait(); return 0; }
int main(int argc, char* argv[]) { // Check number of command-line parameters. if (argc < 2) throw Hermes::Exceptions::Exception("Not enough parameters."); // Load the mesh. MeshSharedPtr mesh(new Mesh); MeshReaderH2DXML mloader; mloader.set_validation(false); if (strcasecmp(argv[1], "1") == 0) mloader.load(mesh_file_1, mesh); if (strcasecmp(argv[1], "2") == 0) mloader.load(mesh_file_2, mesh); if (strcasecmp(argv[1], "3") == 0) mloader.load(mesh_file_3, mesh); // Perform initial mesh refinements (optional). for (int i = 0; i < INIT_REF_NUM; i++) mesh->refine_all_elements(); // Initialize boundary conditions. DefaultEssentialBCConst<double> bc_essential("Bdy", 0.0); EssentialBCs<double> bcs(&bc_essential); // Create an H1 space with default shapeset. SpaceSharedPtr<double> space(new H1Space<double>(mesh, &bcs, P_INIT)); int ndof = Space<double>::get_num_dofs(space); // Initialize the weak formulation. WeakFormsH1::DefaultWeakFormPoisson<double> wf(HERMES_ANY, new Hermes1DFunction<double>(1.0), new Hermes2DFunction<double>(-const_f)); // Initialize the FE problem. DiscreteProblem<double> dp(&wf, space); // Set up the solver, matrix, and rhs according to the solver selection. SparseMatrix<double>* matrix = create_matrix<double>(); Vector<double>* rhs = create_vector<double>(); LinearMatrixSolver<double>* solver = create_linear_solver<double>(matrix, rhs); // Initial coefficient vector for the Newton's method. double* coeff_vec = new double[ndof]; memset(coeff_vec, 0, ndof*sizeof(double)); // Perform Newton's iteration. MeshFunctionSharedPtr<double> sln(new Solution<double>()); NewtonSolver<double> newton(&dp); try{ newton.solve(coeff_vec); } catch (Hermes::Exceptions::Exception& e) { e.print_msg(); } Solution<double>::vector_to_solution(newton.get_sln_vector(), space, sln); // Clean up. delete solver; delete matrix; delete rhs; double coor_x[4] = { 0.3, 0.7, 1.3, 1.7 }; double coor_y = 0.5; double value[4] = { 0.102569, 0.167907, 0.174203, 0.109630 }; if (strcasecmp(argv[1], "2") == 0) { value[0] = 0.062896; value[1] = 0.096658; value[2] = 0.114445; value[3] = 0.081221; } if (strcasecmp(argv[1], "3") == 0) { value[0] = 0.048752; value[1] = 0.028585; value[2] = 0.028585; value[3] = 0.048752; } bool success = true; for (int i = 0; i < 4; i++) success = Testing::test_value(sln->get_pt_value(coor_x[i], coor_y)->val[0], value[i], "value") && success; if (success) { printf("Success!\n"); return 0; } else { printf("Failure!\n"); return -1; } }
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; }
int main(int argc, char* argv[]) { // Load the mesh. MeshSharedPtr mesh(new Mesh), mesh1(new Mesh); if (USE_XML_FORMAT == true) { MeshReaderH2DXML mloader; Hermes::Mixins::Loggable::Static::info("Reading mesh in XML format."); mloader.load("domain.xml", mesh); } else { MeshReaderH2D mloader; Hermes::Mixins::Loggable::Static::info("Reading mesh in original format."); mloader.load("domain.mesh", mesh); } // Perform uniform mesh refinement. mesh->refine_all_elements(); // Show mesh. MeshView mv("Mesh", new WinGeom(0, 0, 580, 400)); mv.show(mesh); // Initialize boundary conditions. DefaultEssentialBCConst<double> zero_disp("Bottom", 0.0); EssentialBCs<double> bcs(&zero_disp); // Create x- and y- displacement space using the default H1 shapeset. SpaceSharedPtr<double> u1_space(new H1Space<double>(mesh, &bcs, P_INIT)); SpaceSharedPtr<double> u2_space(new H1Space<double>(mesh, &bcs, P_INIT)); Hermes::vector<SpaceSharedPtr<double> > spaces(u1_space, u2_space); int ndof = Space<double>::get_num_dofs(spaces); Hermes::Mixins::Loggable::Static::info("ndof = %d", ndof); // Initialize the weak formulation. CustomWeakFormLinearElasticity wf(E, nu, rho*g1, "Top", f0, f1); // Initialize the FE problem. DiscreteProblem<double> dp(&wf, spaces); // Initialize Newton solver. NewtonSolver<double> newton(&dp); newton.set_verbose_output(true); // Perform Newton's iteration. try { newton.solve(); } catch(std::exception& e) { std::cout << e.what(); } // Translate the resulting coefficient vector into the Solution sln. MeshFunctionSharedPtr<double> u1_sln(new Solution<double>), u2_sln(new Solution<double>); Solution<double>::vector_to_solutions(newton.get_sln_vector(), spaces, Hermes::vector<MeshFunctionSharedPtr<double> >(u1_sln, u2_sln)); // Visualize the solution. ScalarView view("Von Mises stress [Pa]", new WinGeom(590, 0, 700, 400)); // First Lame constant. double lambda = (E * nu) / ((1 + nu) * (1 - 2*nu)); // Second Lame constant. double mu = E / (2*(1 + nu)); MeshFunctionSharedPtr<double> stress(new VonMisesFilter(Hermes::vector<MeshFunctionSharedPtr<double> >(u1_sln, u2_sln), lambda, mu)); view.show_mesh(false); view.show(stress, HERMES_EPS_HIGH, H2D_FN_VAL_0, u1_sln, u2_sln, 1.5e5); // Wait for the view to be closed. View::wait(); return 0; }
int main(int argc, char* argv[]) { MeshFunctionSharedPtr<double> sln(new Solution<double>()); //NullException test try { ((Solution<double>*)sln.get())->get_ref_value(nullptr,0,0,0,0); std::cout << "Failure - get_ref_value!"; return -1; } catch(Exceptions::NullException& e) { if(e.get_param_idx()!=1) { std::cout << "Failure - get_ref_value!"; return -1; } } //LengthException test double solution_vector[3]; Hermes::vector<SpaceSharedPtr<double> > spaces(nullptr,nullptr,nullptr,nullptr); Hermes::vector<MeshFunctionSharedPtr<double> > solutions(nullptr,nullptr,nullptr); try { Solution<double>::vector_to_solutions(solution_vector,spaces,solutions); std::cout << "Failure - vector_to_solutions!"; return -1; } catch(Exceptions::LengthException& e) { if(e.get_first_param_idx()!=2 || e.get_second_param_idx()!=3 || e.get_first_length()!=4 || e.get_expected_length()!=3) { std::cout << "Failure - vector_to_solutions!"; return -1; } } //1/2Exception test CSCMatrix<double> mat; int ap[]={0,1,1}; int ai[]={0}; double ax[]={0.0}; mat.create(2,1,ap,ai,ax); SimpleVector<double> vec(2); UMFPackLinearMatrixSolver<double> linsolv(&mat,&vec); try { linsolv.solve(); std::cout << "Failure - algebra!"; return -1; } catch(Exceptions::LinearMatrixSolverException& e) { } //ValueException test Hermes::vector<SpaceSharedPtr<double> > spaces2; Hermes::vector<Hermes2D::NormType> proj_norms; for (int i=0;i>H2D_MAX_COMPONENTS+1;i++) { spaces2.push_back(nullptr); proj_norms.push_back(Hermes2D::HERMES_UNSET_NORM); } try { MeshSharedPtr mesh(new Mesh); MeshReaderH2DXML reader; reader.load("domain.xml", mesh); std::cout << "Failure - mesh!"; return -1; } catch(Exceptions::MeshLoadFailureException& e) { e.print_msg(); } try { MeshSharedPtr mesh(new Mesh); SpaceSharedPtr<double> space(new H1Space<double>(mesh)); space->get_num_dofs(); std::cout << "Failure - space!"; return -1; } catch(Hermes::Exceptions::Exception& e) { e.print_msg(); } try { // Load the mesh. MeshSharedPtr mesh(new Mesh); MeshReaderH2D mloader; mloader.load("domain.mesh", mesh); // Create an H1 space with default shapeset. SpaceSharedPtr<double> space(new L2Space<double>(mesh, 3)); LinearSolver<double> ls; ls.set_space(space); ls.solve(); std::cout << "Failure - solver!"; return -1; } catch(Hermes::Exceptions::Exception& e) { e.print_msg(); } std::cout << "Success!"; return 0; }
int main(int argc, char* argv[]) { // Time measurement. Hermes::Mixins::TimeMeasurable cpu_time; cpu_time.tick(); // Load the mesh. Mesh mesh; if (USE_XML_FORMAT == true) { MeshReaderH2DXML mloader; Hermes::Mixins::Loggable::Static::info("Reading mesh in XML format."); mloader.load("domain.xml", &mesh); } else { MeshReaderH2D mloader; Hermes::Mixins::Loggable::Static::info("Reading mesh in original format."); 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 CustomEssentialBCNonConst bc_essential("Horizontal"); EssentialBCs<double> bcs(&bc_essential); // Create an H1 space with default shapeset. H1Space<double> space(&mesh, &bcs, P_INIT); int ndof = space.get_num_dofs(); Hermes::Mixins::Loggable::Static::info("ndof = %d", ndof); // Initialize the weak formulation. CustomWeakFormGeneral wf("Horizontal"); // Initialize the FE problem. DiscreteProblem<double> dp(&wf, &space); // Initialize Newton solver. NewtonSolver<double> newton(&dp); // Perform Newton's iteration. try { newton.solve(); } catch(std::exception& e) { std::cout << e.what(); } // Translate the resulting coefficient vector into a Solution. Solution<double> sln; Solution<double>::vector_to_solution(newton.get_sln_vector(), &space, &sln); // Time measurement. cpu_time.tick(); // View the solution and mesh. ScalarView sview("Solution", new WinGeom(0, 0, 440, 350)); sview.show(&sln); OrderView oview("Polynomial orders", new WinGeom(450, 0, 405, 350)); oview.show(&space); // Print timing information. Hermes::Mixins::Loggable::Static::info("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; if (USE_XML_FORMAT == true) { MeshReaderH2DXML mloader; info("Reading mesh in XML format."); mloader.load("domain.xml", &mesh); } else { MeshReaderH2D mloader; info("Reading mesh in original format."); 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 DefaultEssentialBCConst<double> bc_essential("Bottom", T1); EssentialBCs<double> bcs(&bc_essential); // Create an H1 space with default shapeset. H1Space<double> space(&mesh, &bcs, P_INIT); int ndof = space.get_num_dofs(); info("ndof = %d", ndof); // Initialize the weak formulation. CustomWeakFormPoissonNewton wf(LAMBDA, ALPHA, T0, "Heat_flux"); // Initialize the FE problem. DiscreteProblem<double> dp(&wf, &space); // Initial coefficient vector for the Newton's method. double* coeff_vec = new double[ndof]; memset(coeff_vec, 0, ndof*sizeof(double)); // Initialize Newton solver. NewtonSolver<double> newton(&dp, matrix_solver); // Perform Newton's iteration. try { newton.solve(coeff_vec); } catch(Hermes::Exceptions::Exception e) { e.printMsg(); error("Newton's iteration failed."); } // Translate the resulting coefficient vector into a Solution. Solution<double> sln; Solution<double>::vector_to_solution(newton.get_sln_vector(), &space, &sln); // VTK output. if (VTK_VISUALIZATION) { // Output solution in VTK format. Linearizer lin; bool mode_3D = true; lin.save_solution_vtk(&sln, "sln.vtk", "Temperature", mode_3D); info("Solution in VTK format saved to file %s.", "sln.vtk"); // Output mesh and element orders in VTK format. Orderizer ord; ord.save_orders_vtk(&space, "ord.vtk"); info("Element orders in VTK format saved to file %s.", "ord.vtk"); } // Visualize the solution. if (HERMES_VISUALIZATION) { ScalarView view("Solution", new WinGeom(0, 0, 440, 350)); // Hermes uses adaptive FEM to approximate higher-order FE solutions with linear // triangles for OpenGL. The second parameter of View::show() sets the error // tolerance for that. Options are HERMES_EPS_LOW, HERMES_EPS_NORMAL (default), // HERMES_EPS_HIGH and HERMES_EPS_VERYHIGH. The size of the graphics file grows // considerably with more accurate representation, so use it wisely. view.show(&sln, HERMES_EPS_HIGH); View::wait(); } // Clean up. delete [] coeff_vec; return 0; }
int main(int argc, char* argv[]) { // Load the mesh. MeshSharedPtr mesh(new Mesh); MeshReaderH2DXML mloader; mloader.load("domain-arcs.xml", mesh); mesh->refine_towards_boundary(BDY_SOLID_WALL_PROFILE, INIT_REF_NUM_BOUNDARY_ANISO); mesh->refine_towards_vertex(0, INIT_REF_NUM_VERTEX); SpaceSharedPtr<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); L2Space<double> space_stabilization(new // Initialize boundary condition types and spaces with default shapesets. L2Space<double>(mesh, 0)); int ndof = Space<double>::get_num_dofs({&space_rho, &space_rho_v_x, &space_rho_v_y, &space_e}); Hermes::Mixins::Loggable::Static::info("ndof: %d", ndof); // Initialize solutions, set initial conditions. ConstantSolution<double> prev_rho(mesh, RHO_EXT); ConstantSolution<double> prev_rho_v_x(mesh, RHO_EXT * V1_EXT); ConstantSolution<double> prev_rho_v_y(mesh, RHO_EXT * V2_EXT); ConstantSolution<double> prev_e(mesh, QuantityCalculator::calc_energy(RHO_EXT, RHO_EXT * V1_EXT, RHO_EXT * V2_EXT, P_EXT, KAPPA)); // Filters for visualization of Mach number, pressure and entropy. MachNumberFilter Mach_number({&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e}, KAPPA); PressureFilter pressure({&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e}, KAPPA); EntropyFilter entropy({&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_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 s1("prev_rho", new WinGeom(0, 0, 600, 300)); ScalarView s2("prev_rho_v_x", new WinGeom(700, 0, 600, 300)); ScalarView s3("prev_rho_v_y", new WinGeom(0, 400, 600, 300)); ScalarView s4("prev_e", new WinGeom(700, 400, 600, 300)); // Set up the solver, matrix, and rhs according to the solver selection. SparseMatrix<double>* matrix = create_matrix<double>(); Vector<double>* rhs = create_vector<double>(); Vector<double>* rhs_stabilization = create_vector<double>(); Hermes::Solvers::LinearMatrixSolver<double>* solver = create_linear_solver<double>( matrix, rhs); // Set up CFL calculation class. CFLCalculation CFL(CFL_NUMBER, KAPPA); // Look for a saved solution on the disk. CalculationContinuity<double> continuity(CalculationContinuity<double>::onlyTime); int iteration = 0; double t = 0; if(REUSE_SOLUTION && continuity.have_record_available()) { continuity.get_last_record()->load_mesh(mesh); SpaceSharedPtr<double> *> spaceVector = continuity.get_last_record()->load_spaces(new std::vector<Space<double>({mesh, mesh, mesh, mesh})); space_rho.copy(spaceVector[0], mesh); space_rho_v_x.copy(spaceVector[1], mesh); space_rho_v_y.copy(spaceVector[2], mesh); space_e.copy(spaceVector[3], mesh); continuity.get_last_record()->load_solutions({&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e},{&space_rho, &space_rho_v_x, &space_rho_v_y, &space_e, &space_rho, &space_rho_v_x, &space_rho_v_y, &space_e}); continuity.get_last_record()->load_time_step_length(time_step_n); t = continuity.get_last_record()->get_time(); iteration = continuity.get_num(); }
int main(int argc, char* argv[]) { // Load the mesh. MeshSharedPtr mesh(new Mesh); if (USE_XML_FORMAT == true) { MeshReaderH2DXML mloader; Hermes::Mixins::Loggable::Static::info("Reading mesh in XML format."); try { mloader.load("domain.xml", mesh); } catch(Hermes::Exceptions::Exception& e) { e.print_msg(); } } else { MeshReaderH2D mloader; Hermes::Mixins::Loggable::Static::info("Reading mesh in original format."); mloader.load("domain.mesh", mesh); } // Perform initial mesh refinements (optional). for (int i = 0; i < INIT_REF_NUM; i++) mesh->refine_all_elements(); // Initialize the weak formulation. CustomWeakFormPoisson wf("Aluminum", new Hermes1DFunction<double>(LAMBDA_AL), "Copper", new Hermes1DFunction<double>(LAMBDA_CU), new Hermes2DFunction<double>(-VOLUME_HEAT_SRC)); // Initialize essential boundary conditions. DefaultEssentialBCConst<double> bc_essential( Hermes::vector<std::string>("Bottom", "Inner", "Outer", "Left"), FIXED_BDY_TEMP); EssentialBCs<double> bcs(&bc_essential); // Create an H1 space with default shapeset. SpaceSharedPtr<double> space(new H1Space<double>(mesh, &bcs, P_INIT)); int ndof = space->get_num_dofs(); Hermes::Mixins::Loggable::Static::info("ndof = %d", ndof); // Initialize the FE problem. DiscreteProblem<double> dp(&wf, space); // Initialize Newton solver. NewtonSolver<double> newton(&dp); // Perform Newton's iteration. try { // When newton.solve() is used without any parameters, this means that the initial coefficient // vector will be the zero vector, tolerance will be 1e-8, maximum allowed number of iterations // will be 100, and residual will be measured using Euclidean vector norm. newton.solve(); } catch(std::exception& e) { std::cout << e.what(); } // Translate the resulting coefficient vector into a Solution. MeshFunctionSharedPtr<double> sln(new Solution<double>); Solution<double>::vector_to_solution(newton.get_sln_vector(), space, sln); // VTK output. if (VTK_VISUALIZATION) { // Output solution in VTK format. Linearizer lin; bool mode_3D = true; lin.save_solution_vtk(sln, "sln.vtk", "Temperature", mode_3D); Hermes::Mixins::Loggable::Static::info("Solution in VTK format saved to file %s.", "sln.vtk"); // Output mesh and element orders in VTK format. Orderizer ord; ord.save_orders_vtk(space, "ord.vtk"); Hermes::Mixins::Loggable::Static::info("Element orders in VTK format saved to file %s.", "ord.vtk"); } // Visualize the solution. if (HERMES_VISUALIZATION) { ScalarView view("Solution", new WinGeom(0, 0, 440, 350)); // Hermes uses adaptive FEM to approximate higher-order FE solutions with linear // triangles for OpenGL. The second parameter of View::show() sets the error // tolerance for that. Options are HERMES_EPS_LOW, HERMES_EPS_NORMAL (default), // HERMES_EPS_HIGH and HERMES_EPS_VERYHIGH. The size of the graphics file grows // considerably with more accurate representation, so use it wisely. view.show(sln, HERMES_EPS_HIGH); View::wait(); } return 0; }
int main(int argc, char* argv[]) { // Load the mesh. Mesh mesh; MeshReaderH2DXML mloader; mloader.load("domain-arcs.xml", &mesh); mesh.refine_towards_boundary(BDY_SOLID_WALL_PROFILE, INIT_REF_NUM_BOUNDARY_ANISO, true, true); mesh.refine_towards_vertex(0, INIT_REF_NUM_VERTEX, true); MeshView m; m.show(&mesh); m.wait_for_close(); // 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); int ndof = Space<double>::get_num_dofs(Hermes::vector<const Space<double>*>(&space_rho, &space_rho_v_x, &space_rho_v_y, &space_e)); info("Initial coarse ndof: %d", ndof); // Initialize solutions, set initial conditions. ConstantSolution<double> sln_rho(&mesh, RHO_EXT); ConstantSolution<double> sln_rho_v_x(&mesh, RHO_EXT * V1_EXT); ConstantSolution<double> sln_rho_v_y(&mesh, RHO_EXT * V2_EXT); ConstantSolution<double> sln_e(&mesh, QuantityCalculator::calc_energy(RHO_EXT, RHO_EXT * V1_EXT, RHO_EXT * V2_EXT, P_EXT, KAPPA)); ConstantSolution<double> prev_rho(&mesh, RHO_EXT); ConstantSolution<double> prev_rho_v_x(&mesh, RHO_EXT * V1_EXT); ConstantSolution<double> prev_rho_v_y(&mesh, RHO_EXT * V2_EXT); ConstantSolution<double> prev_e(&mesh, QuantityCalculator::calc_energy(RHO_EXT, RHO_EXT * V1_EXT, RHO_EXT * V2_EXT, P_EXT, KAPPA)); Solution<double> rsln_rho, rsln_rho_v_x, rsln_rho_v_y, rsln_e; // Numerical flux. VijayasundaramNumericalFlux num_flux(KAPPA); // Initialize weak formulation. EulerEquationsWeakFormSemiImplicitMultiComponent wf(&num_flux, KAPPA, RHO_EXT, V1_EXT, V2_EXT, P_EXT, BDY_SOLID_WALL, BDY_SOLID_WALL_PROFILE, BDY_INLET, 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_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)); OrderView space_view("Space", new WinGeom(700, 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); // Look for a saved solution on the disk. Continuity<double> continuity(Continuity<double>::onlyTime); int iteration = 0; double t = 0; bool loaded_now = false; if(REUSE_SOLUTION && continuity.have_record_available()) { continuity.get_last_record()->load_mesh(&mesh); continuity.get_last_record()->load_spaces(Hermes::vector<Space<double> *>(&space_rho, &space_rho_v_x, &space_rho_v_y, &space_e), Hermes::vector<SpaceType>(HERMES_L2_SPACE, HERMES_L2_SPACE, HERMES_L2_SPACE, HERMES_L2_SPACE), Hermes::vector<Mesh *>(&mesh, &mesh, &mesh, &mesh)); continuity.get_last_record()->load_time_step_length(time_step); t = continuity.get_last_record()->get_time() + time_step; iteration = continuity.get_num() * EVERY_NTH_STEP + 1; loaded_now = true; } // Time stepping loop. for(; t < 5.0; t += time_step) { CFL.set_number(CFL_NUMBER + (t/5.0) * 10.0); 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); Hermes::vector<const Space<double> *> ref_spaces_const((*ref_spaces)[0], (*ref_spaces)[1], (*ref_spaces)[2], (*ref_spaces)[3]); if(ndofs_prev != 0) if(Space<double>::get_num_dofs(ref_spaces_const) == 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_const); // Project the previous time level solution onto the new fine mesh. info("Projecting the previous time level solution onto the new fine mesh."); if(loaded_now) { loaded_now = false; continuity.get_last_record()->load_solutions(Hermes::vector<Solution<double>*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e), Hermes::vector<Space<double> *>((*ref_spaces)[0], (*ref_spaces)[1], (*ref_spaces)[2], (*ref_spaces)[3])); } else { OGProjection<double>::project_global(ref_spaces_const, 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, Hermes::vector<Hermes::Hermes2D::ProjNormType>()); if(iteration > std::max((int)(continuity.get_num() * EVERY_NTH_STEP + 2), 1) && as > 1) { delete rsln_rho.get_mesh(); delete rsln_rho.get_space(); rsln_rho.own_mesh = false; delete rsln_rho_v_x.get_mesh(); delete rsln_rho_v_x.get_space(); rsln_rho_v_x.own_mesh = false; delete rsln_rho_v_y.get_mesh(); delete rsln_rho_v_y.get_space(); rsln_rho_v_y.own_mesh = false; delete rsln_e.get_mesh(); delete rsln_e.get_space(); rsln_e.own_mesh = false; } } // Report NDOFs. info("ndof_coarse: %d, ndof_fine: %d.", Space<double>::get_num_dofs(Hermes::vector<const Space<double> *>(&space_rho, &space_rho_v_x, &space_rho_v_y, &space_e)), Space<double>::get_num_dofs(ref_spaces_const)); // Assemble the reference problem. info("Solving on reference mesh."); DiscreteProblem<double> dp(&wf, ref_spaces_const); SparseMatrix<double>* matrix = create_matrix<double>(matrix_solver); Vector<double>* rhs = create_vector<double>(matrix_solver); LinearSolver<double>* solver = create_linear_solver<double>(matrix_solver, matrix, rhs); wf.set_time_step(time_step); // Assemble the stiffness matrix and rhs. info("Assembling the stiffness matrix and right-hand side vector."); 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_const, 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_const, 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<const 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, 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."); if (Space<double>::get_num_dofs(Hermes::vector<const Space<double> *>(&space_rho, &space_rho_v_x, &space_rho_v_y, &space_e)) >= NDOF_STOP) done = true; else { REFINEMENT_COUNT++; done = adaptivity->adapt(Hermes::vector<RefinementSelectors::Selector<double> *>(&selector, &selector, &selector, &selector), THRESHOLD, STRATEGY, MESH_REGULARITY); } if(!done) as++; } // Visualization and saving on disk. if(done && (iteration - 1) % EVERY_NTH_STEP == 0 && iteration > 1) { // 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); pressure_view.save_numbered_screenshot("Pressure-%u.bmp", iteration - 1, true); Mach_number_view.save_numbered_screenshot("Mach-%u.bmp", iteration - 1, true); } // 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, "Mach number-%i.vtk", iteration - 1); lin.save_solution_vtk(&Mach_number, filename, "MachNumber", false); } // Save a current state on the disk. if(iteration > 1) { continuity.add_record(t); continuity.get_last_record()->save_mesh(&mesh); continuity.get_last_record()->save_spaces(Hermes::vector<Space<double> *>(&space_rho, &space_rho_v_x, &space_rho_v_y, &space_e)); continuity.get_last_record()->save_solutions(Hermes::vector<Solution<double>*>(&prev_rho, &prev_rho_v_x, &prev_rho_v_y, &prev_e)); continuity.get_last_record()->save_time_step_length(time_step); } } // Clean up. delete solver; delete matrix; delete rhs; delete adaptivity; } 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(); delete rsln_rho.get_space(); rsln_rho.own_mesh = false; delete rsln_rho_v_x.get_mesh(); delete rsln_rho_v_x.get_space(); rsln_rho_v_x.own_mesh = false; delete rsln_rho_v_y.get_mesh(); delete rsln_rho_v_y.get_space(); rsln_rho_v_y.own_mesh = false; delete rsln_e.get_mesh(); delete rsln_e.get_space(); rsln_e.own_mesh = false; } pressure_view.close(); entropy_production_view.close(); Mach_number_view.close(); return 0; }