def test_ScalarView_mpl_unknown(): mesh = Mesh() mesh.load(domain_mesh) mesh.refine_element(0) shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # create an H1 space space = H1Space(mesh, shapeset) space.set_uniform_order(5) space.assign_dofs() # initialize the discrete problem wf = WeakForm(1) set_forms(wf) solver = DummySolver() sys = LinSystem(wf, solver) sys.set_spaces(space) sys.set_pss(pss) # assemble the stiffness matrix and solve the system sys.assemble() A = sys.get_matrix() b = sys.get_rhs() from scipy.sparse.linalg import cg x, res = cg(A, b) sln = Solution() sln.set_fe_solution(space, pss, x) view = ScalarView("Solution")
def test_matrix(): set_verbose(False) mesh = Mesh() mesh.load(domain_mesh) mesh.refine_element(0) shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # create an H1 space space = H1Space(mesh, shapeset) space.set_uniform_order(5) space.assign_dofs() # initialize the discrete problem wf = WeakForm(1) set_forms(wf) solver = DummySolver() sys = LinSystem(wf, solver) sys.set_spaces(space) sys.set_pss(pss) # assemble the stiffness matrix and solve the system sln = Solution() sys.assemble() A = sys.get_matrix()
def test_plot_mesh3e(): mesh = Mesh() mesh.load(domain_mesh) mesh.refine_all_elements() mesh.refine_all_elements() plot_mesh_mpl(mesh.nodes_dict, mesh.elements)
def test_plot_mesh3c(): mesh = Mesh() mesh.load(domain_mesh) mesh.refine_all_elements() mesh.refine_all_elements() plot_mesh_mpl_simple(mesh.nodes_dict, mesh.elements, plot_nodes=False)
def test_example_03(): from hermes2d.examples.c03 import set_bc set_verbose(False) P_INIT = 5 # Uniform polynomial degree of mesh elements. # Problem parameters. CONST_F = 2.0 # Load the mesh file mesh = Mesh() mesh.load(get_example_mesh()) # Sample "manual" mesh refinement mesh.refine_all_elements() # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Initialize the weak formulation wf = WeakForm(1) set_forms(wf) # Initialize the linear system ls = LinSystem(wf) ls.set_spaces(space) # Assemble and solve the matrix problem. sln = Solution() ls.assemble() ls.solve_system(sln)
def test_example_08(): from hermes2d.examples.c08 import set_bc, set_forms set_verbose(False) # The following parameter can be changed: P_INIT = 4 # Load the mesh file mesh = Mesh() mesh.load(get_sample_mesh()) # Perform uniform mesh refinement mesh.refine_all_elements() # Create the x- and y- displacement space using the default H1 shapeset xdisp = H1Space(mesh, P_INIT) ydisp = H1Space(mesh, P_INIT) set_bc(xdisp, ydisp) # Initialize the weak formulation wf = WeakForm(2) set_forms(wf) # Initialize the linear system. ls = LinSystem(wf) ls.set_spaces(xdisp, ydisp) # Assemble and solve the matrix problem xsln = Solution() ysln = Solution() ls.assemble() ls.solve_system(xsln, ysln, lib="scipy")
def test_example_03(): set_verbose(False) mesh = Mesh() mesh.load(domain_mesh) mesh.refine_element(0) shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # create an H1 space space = H1Space(mesh, shapeset) space.set_uniform_order(5) from hermes2d.examples.c03 import set_bc set_bc(space) space.assign_dofs() # initialize the discrete problem wf = WeakForm(1) set_forms(wf) solver = DummySolver() sys = LinSystem(wf, solver) sys.set_spaces(space) sys.set_pss(pss) # assemble the stiffness matrix and solve the system sln = Solution() sys.assemble() sys.solve_system(sln) assert abs(sln.l2_norm() - 0.25493) < 1e-4 assert abs(sln.h1_norm() - 0.89534) < 1e-4
def test_example_07(): from hermes2d.examples.c07 import set_bc, set_forms set_verbose(False) # The following parameters can be changed: P_INIT = 2 # Initial polynomial degree of all mesh elements. INIT_REF_NUM = 4 # Number of initial uniform refinements # Load the mesh mesh = Mesh() mesh.load(get_07_mesh()) # Perform initial mesh refinements. for i in range(INIT_REF_NUM): mesh.refine_all_elements() # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize the linear system. ls = LinSystem(wf) ls.set_spaces(space) # Assemble and solve the matrix problem sln = Solution() ls.assemble() ls.solve_system(sln)
def test_example_04(): from hermes2d.examples.c04 import set_bc set_verbose(False) # Below you can play with the parameters CONST_F, P_INIT, and UNIFORM_REF_LEVEL. INIT_REF_NUM = 2 # number of initial uniform mesh refinements P_INIT = 2 # initial polynomial degree in all elements # Load the mesh file mesh = Mesh() mesh.load(get_example_mesh()) # Perform initial mesh refinements for i in range(INIT_REF_NUM): mesh.refine_all_elements() # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize the linear system ls = LinSystem(wf) ls.set_spaces(space) # Assemble and solve the matrix problem sln = Solution() ls.assemble() ls.solve_system(sln)
def test_example_05(): from hermes2d.examples.c05 import set_bc from hermes2d.examples.c05 import set_forms as set_forms_surf set_verbose(False) P_INIT = 4 # initial polynomial degree in all elements CORNER_REF_LEVEL = 12 # number of mesh refinements towards the re-entrant corner # Load the mesh file mesh = Mesh() mesh.load(get_example_mesh()) # Perform initial mesh refinements. mesh.refine_towards_vertex(3, CORNER_REF_LEVEL) # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize the linear system. ls = LinSystem(wf) ls.set_spaces(space) # Assemble and solve the matrix problem sln = Solution() ls.assemble() ls.solve_system(sln)
def test_plot_mesh3d(): mesh = Mesh() mesh.load(domain_mesh) mesh.refine_all_elements() mesh.refine_all_elements() view = MeshView("Solution") view.show(mesh, lib="mpl", method="orders", show=False)
def test_plot_mesh1b(): mesh = Mesh() mesh.load(domain_mesh) view = MeshView("Solution") view.show(mesh, lib="mpl", method="orders", show=False) plot_mesh_mpl(mesh.nodes, mesh.elements) plot_mesh_mpl(mesh.nodes_dict, mesh.elements)
def test_plot_mesh1c(): mesh = Mesh() mesh.load(domain_mesh) view = MeshView("Solution") assert raises( ValueError, 'view.show(mesh, lib="mpl", method="something_unknown_123")')
def test_plot_mesh1a(): mesh = Mesh() mesh.load(domain_mesh) view = MeshView("Solution") view.show(mesh, lib="mpl", method="simple", show=False) plot_mesh_mpl_simple(mesh.nodes, mesh.elements) plot_mesh_mpl_simple(mesh.nodes_dict, mesh.elements) plot_mesh_mpl_simple(mesh.nodes, mesh.elements, plot_nodes=False) plot_mesh_mpl_simple(mesh.nodes_dict, mesh.elements, plot_nodes=False)
def test_plot_mesh2(): mesh = Mesh() mesh.load(domain_mesh) mesh.refine_element(0) view = MeshView("Solution") view.show(mesh, lib="mpl", method="simple", show=False) plot_mesh_mpl(mesh.nodes_dict, mesh.elements) plot_mesh_mpl(mesh.nodes_dict, mesh.elements, plot_nodes=False) view.show(mesh, lib="mpl", method="orders", show=False) plot_mesh_mpl(mesh.nodes_dict, mesh.elements)
def test_fe_solutions(): mesh = Mesh() mesh.load(domain_mesh) space = H1Space(mesh, 1) space.set_uniform_order(2) space.assign_dofs() a = array([1, 2, 3, 8, 0.1]) sln = Solution()
def test_example_09(): from hermes2d.examples.c09 import set_bc, temp_ext, set_forms # The following parameters can be changed: INIT_REF_NUM = 4 # number of initial uniform mesh refinements INIT_REF_NUM_BDY = 1 # number of initial uniform mesh refinements towards the boundary P_INIT = 4 # polynomial degree of all mesh elements TAU = 300.0 # time step in seconds # Problem constants T_INIT = 10 # temperature of the ground (also initial temperature) FINAL_TIME = 86400 # length of time interval (24 hours) in seconds # Global variable TIME = 0; # Boundary markers. bdy_ground = 1 bdy_air = 2 # Load the mesh mesh = Mesh() mesh.load(get_cathedral_mesh()) # Perform initial mesh refinements for i in range(INIT_REF_NUM): mesh.refine_all_elements() mesh.refine_towards_boundary(bdy_air, INIT_REF_NUM_BDY) # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Set initial condition tsln = Solution() tsln.set_const(mesh, T_INIT) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize the linear system. ls = LinSystem(wf) ls.set_spaces(space) # Time stepping nsteps = int(FINAL_TIME/TAU + 0.5) rhsonly = False; # Assemble and solve ls.assemble() rhsonly = True ls.solve_system(tsln, lib="scipy")
def test_example_09(): from hermes2d.examples.c09 import set_bc, temp_ext, set_forms # The following parameters can be changed: INIT_REF_NUM = 4 # number of initial uniform mesh refinements INIT_REF_NUM_BDY = 1 # number of initial uniform mesh refinements towards the boundary P_INIT = 4 # polynomial degree of all mesh elements TAU = 300.0 # time step in seconds # Problem constants T_INIT = 10 # temperature of the ground (also initial temperature) FINAL_TIME = 86400 # length of time interval (24 hours) in seconds # Global variable TIME = 0 # Boundary markers. bdy_ground = 1 bdy_air = 2 # Load the mesh mesh = Mesh() mesh.load(get_cathedral_mesh()) # Perform initial mesh refinements for i in range(INIT_REF_NUM): mesh.refine_all_elements() mesh.refine_towards_boundary(bdy_air, INIT_REF_NUM_BDY) # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Set initial condition tsln = Solution() tsln.set_const(mesh, T_INIT) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize the linear system. ls = LinSystem(wf) ls.set_spaces(space) # Time stepping nsteps = int(FINAL_TIME / TAU + 0.5) rhsonly = False # Assemble and solve ls.assemble() rhsonly = True ls.solve_system(tsln, lib="scipy")
def test_example_08(): from hermes2d.examples.c08 import set_bc, set_forms set_verbose(False) mesh = Mesh() mesh.load(cylinder_mesh) #mesh.refine_element(0) #mesh.refine_all_elements() mesh.refine_towards_boundary(5, 3) shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # create an H1 space xvel = H1Space(mesh, shapeset) yvel = H1Space(mesh, shapeset) press = H1Space(mesh, shapeset) xvel.set_uniform_order(2) yvel.set_uniform_order(2) press.set_uniform_order(1) set_bc(xvel, yvel, press) ndofs = 0 ndofs += xvel.assign_dofs(ndofs) ndofs += yvel.assign_dofs(ndofs) ndofs += press.assign_dofs(ndofs) xprev = Solution() yprev = Solution() xprev.set_zero(mesh) yprev.set_zero(mesh) # initialize the discrete problem wf = WeakForm(3) set_forms(wf, xprev, yprev) solver = DummySolver() sys = LinSystem(wf, solver) sys.set_spaces(xvel, yvel, press) sys.set_pss(pss) #dp.set_external_fns(xprev, yprev) # visualize the solution EPS_LOW = 0.0014 for i in range(3): psln = Solution() sys.assemble() sys.solve_system(xprev, yprev, psln)
def poisson_solver(rho, prec=0.1): """ Solves the Poisson equation \Nabla^2\phi = \rho. prec ... the precision of the solution in percents Returns the solution. """ mesh = Mesh() mesh.load("square.mesh") mesh.refine_element(0) shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # create an H1 space space = H1Space(mesh, shapeset) space.set_uniform_order(5) space.assign_dofs() # initialize the discrete problem wf = WeakForm(1) set_forms_poisson(wf, rho) solver = DummySolver() # assemble the stiffness matrix and solve the system for i in range(10): sys = LinSystem(wf, solver) sys.set_spaces(space) sys.set_pss(pss) sln = Solution() print "poisson: assembly coarse" sys.assemble() print "poisson: done" sys.solve_system(sln) rp = RefSystem(sys) rsln = Solution() print "poisson: assembly reference" rp.assemble() print "poisson: done" rp.solve_system(rsln) hp = H1OrthoHP(space) error = hp.calc_error(sln, rsln) * 100 print "iteration: %d, error: %f" % (i, error) if error < prec: print "Error less than %f%%, we are done." % prec break hp.adapt(0.3) space.assign_dofs() return sln
def test_fe_solutions(): mesh = Mesh() mesh.load(domain_mesh) shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) space = H1Space(mesh, shapeset) space.set_uniform_order(2) space.assign_dofs() a = array([1, 2, 3, 8, 0.1]) sln = Solution() sln.set_fe_solution(space, pss, a)
def test_example_02(): set_verbose(False) P_INIT = 3 # Load the mesh file domain_mesh = get_example_mesh() # Original L-shape domain mesh = Mesh() mesh.load(domain_mesh) # Refine all elements (optional) mesh.refine_all_elements() # Create a shapeset and an H1 space space = H1Space(mesh) # Assign element orders and initialize the space space.set_uniform_order(P_INIT) # Set uniform polynomial order
def main(): set_verbose(False) mesh = Mesh() print "Loading mesh..." mesh.load(get_GAMM_channel_mesh()) #mesh.load("domain-quad.mesh") #mesh.refine_element(0, 2) mesh.refine_element(1, 2) mesh.refine_all_elements() mesh.refine_all_elements() mesh.refine_all_elements() mesh.refine_all_elements() print "Constructing edges..." nodes = mesh.nodes_dict edges = Edges(mesh) elements = mesh.elements print "Done." print "Solving..." state_on_elements = {} for e in mesh.active_elements: state_on_elements[e.id] = array([1., 50., 0., 1.e5]) #print "initial state" #print state_on_elements tau = 1e-3 t = 0. for i in range(100): A, rhs, dof_map = assembly(edges, state_on_elements, tau) #print "A:" #print A #print "rhs:" #print rhs #stop #print "x:" x = spsolve(A, rhs) #print x #print state_on_elements state_on_elements = set_fvm_solution(x, dof_map) #print state_on_elements t += tau print "t = ", t plot_state(state_on_elements, mesh) #print "state_on_elements:" #print state_on_elements print "Done."
def test_example_07(): from hermes2d.examples.c07 import set_bc, set_forms set_verbose(False) mesh = Mesh() mesh.load(sample_mesh) #mesh.refine_element(0) #mesh.refine_all_elements() #mesh.refine_towards_boundary(5, 3) shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # create an H1 space xdisp = H1Space(mesh, shapeset) ydisp = H1Space(mesh, shapeset) xdisp.set_uniform_order(8) ydisp.set_uniform_order(8) set_bc(xdisp, ydisp) ndofs = xdisp.assign_dofs(0) ndofs += ydisp.assign_dofs(ndofs) # initialize the discrete problem wf = WeakForm(2) set_forms(wf) solver = DummySolver() sys = LinSystem(wf, solver) sys.set_spaces(xdisp, ydisp) sys.set_pss(pss) xsln = Solution() ysln = Solution() old_flag = set_warn_integration(False) sys.assemble() set_warn_integration(old_flag) sys.solve_system(xsln, ysln) E = float(200e9) nu = 0.3 stress = VonMisesFilter(xsln, ysln, E / (2*(1 + nu)), (E * nu) / ((1 + nu) * (1 - 2*nu)))
def test_example_06(): from hermes2d.examples.c06 import set_bc, set_forms set_verbose(False) # The following parameters can be changed: UNIFORM_REF_LEVEL = 2 # Number of initial uniform mesh refinements. CORNER_REF_LEVEL = 12 # Number of mesh refinements towards the re-entrant corner. P_INIT = 6 # Uniform polynomial degree of all mesh elements. # Boundary markers NEWTON_BDY = 1 # Load the mesh file mesh = Mesh() mesh.load(get_example_mesh()) # Perform initial mesh refinements. for i in range(UNIFORM_REF_LEVEL): mesh.refine_all_elements() mesh.refine_towards_vertex(3, CORNER_REF_LEVEL) # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize the linear system. ls = LinSystem(wf) ls.set_spaces(space) # Assemble and solve the matrix problem sln = Solution() ls.assemble() ls.solve_system(sln)
def test_matrix(): set_verbose(False) mesh = Mesh() mesh.load(domain_mesh) mesh.refine_element_id(0) # create an H1 space with default shapeset space = H1Space(mesh, 1) # initialize the discrete problem wf = WeakForm(1) set_forms(wf) sys = LinSystem(wf) sys.set_spaces(space) # assemble the stiffness matrix and solve the system sln = Solution() sys.assemble() A = sys.get_matrix()
def test_matrix(): set_verbose(False) mesh = Mesh() mesh.load(domain_mesh) mesh.refine_element(0) # create an H1 space with default shapeset space = H1Space(mesh, 1) # initialize the discrete problem wf = WeakForm(1) set_forms(wf) sys = LinSystem(wf) sys.set_spaces(space) # assemble the stiffness matrix and solve the system sln = Solution() sys.assemble() A = sys.get_matrix()
def test_example_04(): from hermes2d.examples.c04 import set_bc set_verbose(False) mesh = Mesh() mesh.load(domain_mesh) # mesh.refine_element(0) # mesh.refine_all_elements() mesh.refine_towards_boundary(5, 3) shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # create an H1 space space = H1Space(mesh, shapeset) space.set_uniform_order(5) set_bc(space) space.assign_dofs() xprev = Solution() yprev = Solution() # initialize the discrete problem wf = WeakForm() set_forms(wf, -4) solver = DummySolver() sys = LinSystem(wf, solver) sys.set_spaces(space) sys.set_pss(pss) # assemble the stiffness matrix and solve the system sys.assemble() sln = Solution() sys.solve_system(sln) assert abs(sln.l2_norm() - 1.22729) < 1e-4 assert abs(sln.h1_norm() - 2.90006) < 1e-4
def test_example_02(): set_verbose(False) mesh = Mesh() mesh.load(domain_mesh) mesh.refine_element(0) shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # create an H1 space space = H1Space(mesh, shapeset) space.set_uniform_order(5) space.assign_dofs() # initialize the discrete problem wf = WeakForm(1) set_forms(wf) solver = DummySolver() sys = LinSystem(wf, solver) sys.set_spaces(space) sys.set_pss(pss)
def test_example_06(): from hermes2d.examples.c06 import set_bc, set_forms set_verbose(False) # The following parameters can be changed: UNIFORM_REF_LEVEL = 2; # Number of initial uniform mesh refinements. CORNER_REF_LEVEL = 12; # Number of mesh refinements towards the re-entrant corner. P_INIT = 6; # Uniform polynomial degree of all mesh elements. # Boundary markers NEWTON_BDY = 1 # Load the mesh file mesh = Mesh() mesh.load(get_example_mesh()) # Perform initial mesh refinements. for i in range(UNIFORM_REF_LEVEL): mesh.refine_all_elements() mesh.refine_towards_vertex(3, CORNER_REF_LEVEL) # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize the linear system. ls = LinSystem(wf) ls.set_spaces(space) # Assemble and solve the matrix problem sln = Solution() ls.assemble() ls.solve_system(sln)
def test_example_05(): from hermes2d.examples.c05 import set_bc from hermes2d.examples.c05 import set_forms as set_forms_surf set_verbose(False) mesh = Mesh() mesh.load(domain_mesh) mesh.refine_towards_vertex(3, 12) shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # create an H1 space space = H1Space(mesh, shapeset) space.set_uniform_order(4) set_bc(space) space.assign_dofs() xprev = Solution() yprev = Solution() # initialize the discrete problem wf = WeakForm(1) set_forms(wf, -1) set_forms_surf(wf) sln = Solution() solver = DummySolver() sys = LinSystem(wf, solver) sys.set_spaces(space) sys.set_pss(pss) sys.assemble() sys.solve_system(sln) assert abs(sln.l2_norm() - 0.535833) < 1e-4 assert abs(sln.h1_norm() - 1.332908) < 1e-4
def test_example_07(): from hermes2d.examples.c07 import set_bc, set_forms set_verbose(False) P_INIT = 2 # Initial polynomial degree of all mesh elements. mesh = Mesh() mesh.load(get_07_mesh()) # Initialize the shapeset and the cache shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # create finite element space space = H1Space(mesh, shapeset) space.set_uniform_order(P_INIT) set_bc(space) # Enumerate basis functions space.assign_dofs() # weak formulation wf = WeakForm(1) set_forms(wf) # matrix solver solver = DummySolver() # Solve the problem sln = Solution() ls = LinSystem(wf, solver) ls.set_spaces(space) ls.set_pss(pss) ls.assemble() ls.solve_system(sln)
#! /usr/bin/env python # This example shows how to load a mesh, perform various types # of "manual" element refinements. # Import modules from hermes2d import Mesh, MeshView from hermes2d.examples import get_example_mesh # Load the mesh file domain_mesh = get_example_mesh() mesh = Mesh() mesh.load(domain_mesh) # Perform some sample initial refinements mesh.refine_all_elements(); # Refines all elements. #mesh.refine_towards_vertex(3, 4); # Refines mesh towards vertex #3 (4x). #mesh.refine_towards_boundary(2, 4); # Refines all elements along boundary 2 (4x). # Display the mesh mesh.plot()
TAU = 300.0 # time step in seconds # Problem constants T_INIT = 10 # temperature of the ground (also initial temperature) FINAL_TIME = 86400 # length of time interval (24 hours) in seconds # Global variable TIME = 0 # Boundary markers. bdy_ground = 1 bdy_air = 2 # Load the mesh mesh = Mesh() mesh.load(get_cathedral_mesh()) # Perform initial mesh refinements for i in range(INIT_REF_NUM): mesh.refine_all_elements() mesh.refine_towards_boundary(bdy_air, INIT_REF_NUM_BDY) # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Set initial condition tsln = Solution() tsln.set_const(mesh, T_INIT) # Initialize the weak formulation
def test_plot_mesh4(): mesh = Mesh() mesh.load(domain_mesh) view = MeshView("Solution") view.show(mesh, lib="mpl", show=False, method="orders")
def test_example_12(): from hermes2d.examples.c12 import set_bc, set_forms from hermes2d.examples import get_example_mesh # The following parameters can be changed: P_INIT = 1 # Initial polynomial degree of all mesh elements. THRESHOLD = 0.6 # This is a quantitative parameter of the adapt(...) function and # it has different meanings for various adaptive strategies (see below). STRATEGY = 0 # Adaptive strategy: # STRATEGY = 0 ... refine elements until sqrt(THRESHOLD) times total # error is processed. If more elements have similar errors, refine # all to keep the mesh symmetric. # STRATEGY = 1 ... refine all elements whose error is larger # than THRESHOLD times maximum element error. # STRATEGY = 2 ... refine all elements whose error is larger # than THRESHOLD. # More adaptive strategies can be created in adapt_ortho_h1.cpp. ADAPT_TYPE = 0 # Type of automatic adaptivity: # ADAPT_TYPE = 0 ... adaptive hp-FEM (default), # ADAPT_TYPE = 1 ... adaptive h-FEM, # ADAPT_TYPE = 2 ... adaptive p-FEM. ISO_ONLY = False # Isotropic refinement flag (concerns quadrilateral elements only). # ISO_ONLY = false ... anisotropic refinement of quad elements # is allowed (default), # ISO_ONLY = true ... only isotropic refinements of quad elements # are allowed. MESH_REGULARITY = -1 # Maximum allowed level of hanging nodes: # MESH_REGULARITY = -1 ... arbitrary level hangning nodes (default), # MESH_REGULARITY = 1 ... at most one-level hanging nodes, # MESH_REGULARITY = 2 ... at most two-level hanging nodes, etc. # Note that regular meshes are not supported, this is due to # their notoriously bad performance. ERR_STOP = 0.01 # Stopping criterion for adaptivity (rel. error tolerance between the # fine mesh and coarse mesh solution in percent). NDOF_STOP = 40000 # Adaptivity process stops when the number of degrees of freedom grows # over this limit. This is to prevent h-adaptivity to go on forever. # Load the mesh mesh = Mesh() mesh.load(get_example_mesh()) # mesh.load("hermes2d/examples/12.mesh") # Initialize the shapeset and the cache shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) # Create finite element space space = H1Space(mesh, shapeset) set_bc(space) space.set_uniform_order(P_INIT) # Enumerate basis functions space.assign_dofs() # Initialize the weak formulation wf = WeakForm(1) set_forms(wf) # Matrix solver solver = DummySolver() # Adaptivity loop it = 0 ndofs = 0 done = False sln_coarse = Solution() sln_fine = Solution() # Solve the coarse mesh problem ls = LinSystem(wf, solver) ls.set_spaces(space) ls.set_pss(pss) ls.assemble() ls.solve_system(sln_coarse) # Solve the fine mesh problem rs = RefSystem(ls) rs.assemble() rs.solve_system(sln_fine) # Calculate element errors and total error estimate hp = H1OrthoHP(space) err_est = hp.calc_error(sln_coarse, sln_fine) * 100
def test_example_01(): mesh = Mesh() mesh.load(domain_mesh) mesh.refine_all_elements() mesh.refine_all_elements() mesh.refine_all_elements()
# du_2/dn = f_1 on Gamma_3 and du_2/dn = 0 on Gamma_2, Gamma_4, Gamma_5 # u_1 = 0 and u_2 = 0 on Gamma_1 # Import modules from hermes2d import Mesh, MeshView, H1Shapeset, PrecalcShapeset, H1Space, \ LinSystem, WeakForm, DummySolver, Solution, ScalarView, VonMisesFilter from hermes2d.examples.c08 import set_bc, set_forms from hermes2d.examples import get_sample_mesh # The following parameter can be changed: P_INIT = 4 # Load the mesh file mesh = Mesh() mesh.load(get_sample_mesh()) # Perform uniform mesh refinement mesh.refine_all_elements() # Create the x- and y- displacement space using the default H1 shapeset xdisp = H1Space(mesh, P_INIT) ydisp = H1Space(mesh, P_INIT) set_bc(xdisp, ydisp) # Initialize the weak formulation wf = WeakForm(2) set_forms(wf) # Initialize the linear system. ls = LinSystem(wf)
def test_example_11(): from hermes2d.examples.c11 import set_bc, set_wf_forms, set_hp_forms SOLVE_ON_COARSE_MESH = True # If true, coarse mesh FE problem is solved in every adaptivity step. P_INIT_U = 2 # Initial polynomial degree for u P_INIT_V = 2 # Initial polynomial degree for v INIT_REF_BDY = 3 # Number of initial boundary refinements MULTI = True # MULTI = true ... use multi-mesh, # MULTI = false ... use single-mesh. # Note: In the single mesh option, the meshes are # forced to be geometrically the same but the # polynomial degrees can still vary. THRESHOLD = 0.3 # This is a quantitative parameter of the adapt(...) function and # it has different meanings for various adaptive strategies (see below). STRATEGY = 1 # Adaptive strategy: # STRATEGY = 0 ... refine elements until sqrt(THRESHOLD) times total # error is processed. If more elements have similar errors, refine # all to keep the mesh symmetric. # STRATEGY = 1 ... refine all elements whose error is larger # than THRESHOLD times maximum element error. # STRATEGY = 2 ... refine all elements whose error is larger # than THRESHOLD. # More adaptive strategies can be created in adapt_ortho_h1.cpp. CAND_LIST = CandList.H2D_HP_ANISO # Predefined list of element refinement candidates. # Possible values are are attributes of the class CandList: # P_ISO, P_ANISO, H_ISO, H_ANISO, HP_ISO, HP_ANISO_H, HP_ANISO_P, HP_ANISO # See the Sphinx tutorial (http://hpfem.org/hermes2d/doc/src/tutorial-2.html#adaptive-h-fem-and-hp-fem) for details. MESH_REGULARITY = -1 # Maximum allowed level of hanging nodes: # MESH_REGULARITY = -1 ... arbitrary level hangning nodes (default), # MESH_REGULARITY = 1 ... at most one-level hanging nodes, # MESH_REGULARITY = 2 ... at most two-level hanging nodes, etc. # Note that regular meshes are not supported, this is due to # their notoriously bad performance. CONV_EXP = 1 # Default value is 1.0. This parameter influences the selection of # cancidates in hp-adaptivity. See get_optimal_refinement() for details. MAX_ORDER = 10 # Maximum allowed element degree ERR_STOP = 0.5 # Stopping criterion for adaptivity (rel. error tolerance between the # fine mesh and coarse mesh solution in percent). NDOF_STOP = 60000 # Adaptivity process stops when the number of degrees of freedom grows over # this limit. This is mainly to prevent h-adaptivity to go on forever. H2DRS_DEFAULT_ORDER = -1 # A default order. Used to indicate an unkonwn order or a maximum support order # Load the mesh umesh = Mesh() vmesh = Mesh() umesh.load(get_bracket_mesh()) if MULTI == False: umesh.refine_towards_boundary(1, INIT_REF_BDY) # Create initial mesh (master mesh). vmesh.copy(umesh) # Initial mesh refinements in the vmesh towards the boundary if MULTI == True: vmesh.refine_towards_boundary(1, INIT_REF_BDY) # Create the x displacement space uspace = H1Space(umesh, P_INIT_U) vspace = H1Space(vmesh, P_INIT_V) # Initialize the weak formulation wf = WeakForm(2) set_wf_forms(wf) # Initialize refinement selector selector = H1ProjBasedSelector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER) # Initialize the coarse mesh problem ls = LinSystem(wf) ls.set_spaces(uspace, vspace) u_sln_coarse = Solution() v_sln_coarse = Solution() u_sln_fine = Solution() v_sln_fine = Solution() # Assemble and Solve the fine mesh problem rs = RefSystem(ls) rs.assemble() rs.solve_system(u_sln_fine, v_sln_fine, lib="scipy") # Either solve on coarse mesh or project the fine mesh solution # on the coarse mesh. if SOLVE_ON_COARSE_MESH: ls.assemble() ls.solve_system(u_sln_coarse, v_sln_coarse, lib="scipy") # Calculate element errors and total error estimate hp = H1Adapt(ls) hp.set_solutions([u_sln_coarse, v_sln_coarse], [u_sln_fine, v_sln_fine]) set_hp_forms(hp) err_est = hp.calc_error() * 100
# their notoriously bad performance. CONV_EXP = 1.0 ERR_STOP = 0.1 # Stopping criterion for adaptivity (rel. error tolerance between the # fine mesh and coarse mesh solution in percent). NDOF_STOP = 60000 # Adaptivity process stops when the number of degrees of freedom grows # over this limit. This is to prevent h-adaptivity to go on forever. H2DRS_DEFAULT_ORDER = -1 # A default order. Used to indicate an unkonwn order or a maximum support order # Boundary markers BDY_DIRICHLET = 1 BDY_NEUMANN = 2 # Load the mesh mesh = Mesh() mesh.load(get_12_mesh()) # Perform initial mesh refinements mesh.refine_all_elements() # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize views sview = ScalarView("Coarse solution", 0, 0, 600, 1000) oview = OrderView("Polynomial orders", 1220, 0, 600, 1000)
# Note that regular meshes are not supported, this is due to # their notoriously bad performance. CONV_EXP = 1 # Default value is 1.0. This parameter influences the selection of # cancidates in hp-adaptivity. See get_optimal_refinement() for details. MAX_ORDER = 10 # Maximum allowed element degree ERR_STOP = 0.5 # Stopping criterion for adaptivity (rel. error tolerance between the # fine mesh and coarse mesh solution in percent). NDOF_STOP = 60000 # Adaptivity process stops when the number of degrees of freedom grows over # this limit. This is mainly to prevent h-adaptivity to go on forever. H2DRS_DEFAULT_ORDER = -1 # A default order. Used to indicate an unkonwn order or a maximum support order # Load the mesh umesh = Mesh() vmesh = Mesh() umesh.load(get_bracket_mesh()) if MULTI == False: umesh.refine_towards_boundary(1, INIT_REF_BDY) # Create initial mesh (master mesh). vmesh.copy(umesh) # Initial mesh refinements in the vmesh towards the boundary if MULTI == True: vmesh.refine_towards_boundary(1, INIT_REF_BDY) # Create the x displacement space uspace = H1Space(umesh, P_INIT_U) vspace = H1Space(vmesh, P_INIT_V) # Initialize the weak formulation
# The following parameters can be changed: UNIFORM_REF_LEVEL = 2 # Number of initial uniform mesh refinements. CORNER_REF_LEVEL = 12 # Number of mesh refinements towards the re-entrant corner. P_INIT = 6 # Uniform polynomial degree of all mesh elements. # Boundary markers NEWTON_BDY = 1 # Load the mesh file mesh = Mesh() mesh.load(get_example_mesh()) # Perform initial mesh refinements. for i in range(UNIFORM_REF_LEVEL): mesh.refine_all_elements() mesh.refine_towards_vertex(3, CORNER_REF_LEVEL) # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize the linear system.
# Import modules from hermes2d import Mesh, MeshView, OrderView, H1Shapeset, PrecalcShapeset, H1Space, \ LinSystem, WeakForm, DummySolver, Solution, ScalarView, VonMisesFilter, \ OrderView from hermes2d.examples.c07 import set_bc, set_forms from hermes2d.examples import get_07_mesh # The following parameters can be changed: P_INIT = 2 # Initial polynomial degree of all mesh elements. INIT_REF_NUM = 4 # Number of initial uniform refinements # Load the mesh mesh = Mesh() mesh.load(get_07_mesh()) # Perform initial mesh refinements. for i in range(INIT_REF_NUM): mesh.refine_all_elements() # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize views sview = ScalarView("Coarse solution", 0, 100, 798, 700)
def test_example_11(): from hermes2d.examples.c11 import set_bc, set_wf_forms, set_hp_forms # The following parameters can be changed: In particular, compare hp- and # h-adaptivity via the ADAPT_TYPE option, and compare the multi-mesh vs. single-mesh # using the MULTI parameter. P_INIT = 1 # Initial polynomial degree of all mesh elements. MULTI = True # MULTI = true ... use multi-mesh, # MULTI = false ... use single-mesh. # Note: In the single mesh option, the meshes are # forced to be geometrically the same but the # polynomial degrees can still vary. SAME_ORDERS = True # SAME_ORDERS = true ... when single-mesh is used, # this forces the meshes for all components to be # identical, including the polynomial degrees of # corresponding elements. When multi-mesh is used, # this parameter is ignored. THRESHOLD = 0.3 # This is a quantitative parameter of the adapt(...) function and # it has different meanings for various adaptive strategies (see below). STRATEGY = 1 # Adaptive strategy: # STRATEGY = 0 ... refine elements until sqrt(THRESHOLD) times total # error is processed. If more elements have similar errors, refine # all to keep the mesh symmetric. # STRATEGY = 1 ... refine all elements whose error is larger # than THRESHOLD times maximum element error. # STRATEGY = 2 ... refine all elements whose error is larger # than THRESHOLD. # More adaptive strategies can be created in adapt_ortho_h1.cpp. ADAPT_TYPE = 0 # Type of automatic adaptivity: # ADAPT_TYPE = 0 ... adaptive hp-FEM (default), # ADAPT_TYPE = 1 ... adaptive h-FEM, # ADAPT_TYPE = 2 ... adaptive p-FEM. ISO_ONLY = False # Isotropic refinement flag (concerns quadrilateral elements only). # ISO_ONLY = false ... anisotropic refinement of quad elements # is allowed (default), # ISO_ONLY = true ... only isotropic refinements of quad elements # are allowed. MESH_REGULARITY = -1 # Maximum allowed level of hanging nodes: # MESH_REGULARITY = -1 ... arbitrary level hangning nodes (default), # MESH_REGULARITY = 1 ... at most one-level hanging nodes, # MESH_REGULARITY = 2 ... at most two-level hanging nodes, etc. # Note that regular meshes are not supported, this is due to # their notoriously bad performance. MAX_ORDER = 10 # Maximum allowed element degree ERR_STOP = 0.5 # Stopping criterion for adaptivity (rel. error tolerance between the # fine mesh and coarse mesh solution in percent). NDOF_STOP = 40000 # Adaptivity process stops when the number of degrees of freedom grows over # this limit. This is mainly to prevent h-adaptivity to go on forever. # Problem constants E = 200e9 # Young modulus for steel: 200 GPa nu = 0.3 # Poisson ratio lamda = (E * nu) / ((1 + nu) * (1 - 2 * nu)) mu = E / (2 * (1 + nu)) # Load the mesh xmesh = Mesh() ymesh = Mesh() xmesh.load(get_bracket_mesh()) # initial mesh refinements xmesh.refine_element(1) xmesh.refine_element(4) # Create initial mesh for the vertical displacement component, # identical to the mesh for the horizontal displacement # (bracket.mesh becomes a master mesh) ymesh.copy(xmesh) # Initialize the shapeset and the cache shapeset = H1Shapeset() xpss = PrecalcShapeset(shapeset) ypss = PrecalcShapeset(shapeset) # Create the x displacement space xdisp = H1Space(xmesh, shapeset) set_bc(xdisp) xdisp.set_uniform_order(P_INIT) # Create the x displacement space ydisp = H1Space(ymesh, shapeset) set_bc(ydisp) ydisp.set_uniform_order(P_INIT) # Enumerate basis functions ndofs = xdisp.assign_dofs() ydisp.assign_dofs(ndofs) # Initialize the weak formulation wf = WeakForm(2) set_wf_forms(wf) # Matrix solver solver = DummySolver() # adaptivity loop it = 1 done = False cpu = 0.0 x_sln_coarse = Solution() y_sln_coarse = Solution() x_sln_fine = Solution() y_sln_fine = Solution() # Calculating the number of degrees of freedom ndofs = xdisp.assign_dofs() ndofs += ydisp.assign_dofs(ndofs) # Solve the coarse mesh problem ls = LinSystem(wf, solver) ls.set_spaces(xdisp, ydisp) ls.set_pss(xpss, ypss) ls.assemble() ls.solve_system(x_sln_coarse, y_sln_coarse) # View the solution -- this can be slow; for illustration only stress_coarse = VonMisesFilter(x_sln_coarse, y_sln_coarse, mu, lamda) # Solve the fine mesh problem rs = RefSystem(ls) rs.assemble() rs.solve_system(x_sln_fine, y_sln_fine) # Calculate element errors and total error estimate hp = H1OrthoHP(xdisp, ydisp) set_hp_forms(hp) err_est = hp.calc_error_2(x_sln_coarse, y_sln_coarse, x_sln_fine, y_sln_fine) * 100 # Show the fine solution - this is the final result stress_fine = VonMisesFilter(x_sln_fine, y_sln_fine, mu, lamda)
def test_example_12(): from hermes2d.examples.c12 import set_bc, set_forms from hermes2d.examples import get_12_mesh # The following parameters can be changed: SOLVE_ON_COARSE_MESH = True # if true, coarse mesh FE problem is solved in every adaptivity step P_INIT = 2 # Initial polynomial degree of all mesh elements. THRESHOLD = 0.6 # This is a quantitative parameter of the adapt(...) function and # it has different meanings for various adaptive strategies (see below). STRATEGY = 0 # Adaptive strategy: # STRATEGY = 0 ... refine elements until sqrt(THRESHOLD) times total # error is processed. If more elements have similar errors, refine # all to keep the mesh symmetric. # STRATEGY = 1 ... refine all elements whose error is larger # than THRESHOLD times maximum element error. # STRATEGY = 2 ... refine all elements whose error is larger # than THRESHOLD. # More adaptive strategies can be created in adapt_ortho_h1.cpp. CAND_LIST = CandList.H2D_HP_ANISO # Predefined list of element refinement candidates. # Possible values are are attributes of the class CandList: # P_ISO, P_ANISO, H_ISO, H_ANISO, HP_ISO, HP_ANISO_H, HP_ANISO_P, HP_ANISO # See the Sphinx tutorial (http://hpfem.org/hermes2d/doc/src/tutorial-2.html#adaptive-h-fem-and-hp-fem) for details. MESH_REGULARITY = -1 # Maximum allowed level of hanging nodes: # MESH_REGULARITY = -1 ... arbitrary level hangning nodes (default), # MESH_REGULARITY = 1 ... at most one-level hanging nodes, # MESH_REGULARITY = 2 ... at most two-level hanging nodes, etc. # Note that regular meshes are not supported, this is due to # their notoriously bad performance. CONV_EXP = 1.0 ERR_STOP = 0.1 # Stopping criterion for adaptivity (rel. error tolerance between the # fine mesh and coarse mesh solution in percent). NDOF_STOP = 60000 # Adaptivity process stops when the number of degrees of freedom grows # over this limit. This is to prevent h-adaptivity to go on forever. H2DRS_DEFAULT_ORDER = -1 # A default order. Used to indicate an unkonwn order or a maximum support order # Boundary markers BDY_DIRICHLET = 1 BDY_NEUMANN = 2 # Load the mesh mesh = Mesh() mesh.load(get_12_mesh()) # Perform initial mesh refinements mesh.refine_all_elements() # Create an H1 space with default shapeset space = H1Space(mesh, P_INIT) set_bc(space) # Initialize the weak formulation wf = WeakForm() set_forms(wf) # Initialize refinement selector selector = H1ProjBasedSelector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER) # Initialize the linear system. ls = LinSystem(wf) ls.set_spaces(space) sln_coarse = Solution() sln_fine = Solution() # Assemble and solve the fine mesh problem rs = RefSystem(ls) rs.assemble() rs.solve_system(sln_fine) # Either solve on coarse mesh or project the fine mesh solution # on the coarse mesh. if SOLVE_ON_COARSE_MESH: ls.assemble() ls.solve_system(sln_coarse) # Calculate error estimate wrt. fine mesh solution hp = H1Adapt(ls) hp.set_solutions([sln_coarse], [sln_fine]) err_est = hp.calc_error() * 100
#! /usr/bin/env python """ Displays a mesh file. Usage: ./show_mesh.py file.mesh """ from hermes2d import Mesh, MeshView import sys filename = sys.argv[1] mesh = Mesh() mesh.load(filename) mview = MeshView(filename, 100, 100, 500, 500) mview.show(mesh, lib="mpl", method="orders")
#! /usr/bin/env python import sys from hermes2d import Mesh m = Mesh() m.load(sys.argv[1]) m.plot(lib="mpl", method="simple")