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_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_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_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_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_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_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_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_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_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_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_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_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_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_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 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_mesh_create1(): mesh = Mesh() mesh.create([ [0, 0], [1, 0], [1, 1], [0, 1], ], [ [2, 3, 0, 1, 0], ], [ [0, 1, 1], [1, 2, 1], [2, 3, 1], [3, 0, 1], ], []) assert compare(mesh.nodes, [[0, 0], [1, 0], [1, 1], [0, 1]]) assert mesh.elements_markers == [[2, 3, 0, 1, 0]] assert mesh.elements == [[2, 3, 0, 1]] # not yet implemented: #assert mesh.boundaries == [[0, 1, 1], [1, 2, 1], [2, 3, 1], [3, 0, 1]] #assert mesh.nurbs is None mesh.refine_all_elements() assert compare(mesh.nodes, [(0, 0), (1, 0), (1, 1), (0, 1), (1, 0.5), (0.5, 0), (0, 0.5), (0.5, 1), (0.5, 0.5)]) assert mesh.elements == [[2, 7, 8, 4], [7, 3, 6, 8], [8, 6, 0, 5], [4, 8, 5, 1]] mesh.refine_all_elements() assert mesh.nodes_dict == {0: (0.0, 0.0), 1: (1.0, 0.0), 2: (1.0, 1.0), 3: (0.0, 1.0), 4: (1.0, 0.5), 5: (0.5, 0.0), 6: (0.0, 0.5), 7: (0.5, 1.0), 8: (0.5, 0.5), 9: (0.5, 0.75), 10: (0.25, 1.0), 12: (0.75, 1.0), 13: (0.25, 0.5), 14: (0.0, 0.75), 15: (0.5, 0.25), 16: (0.25, 0.0), 17: (0.0, 0.25), 18: (0.75, 0.25), 19: (1.0, 0.25), 20: (0.75, 0.0), 21: (0.75, 0.5), 22: (1.0, 0.75), 23: (0.75, 0.75), 36: (0.25, 0.75), 47: (0.25, 0.25)} assert mesh.elements == [[2, 12, 23, 22], [12, 7, 9, 23], [23, 9, 8, 21], [22, 23, 21, 4], [7, 10, 36, 9], [10, 3, 14, 36], [36, 14, 6, 13], [9, 36, 13, 8], [8, 13, 47, 15], [13, 6, 17, 47], [47, 17, 0, 16], [15, 47, 16, 5], [4, 21, 18, 19], [21, 8, 15, 18], [18, 15, 5, 20], [19, 18, 20, 1]]
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_mesh_create2(): m = Mesh() m.create([ [0, -1], [1, -1], [-1, 0], [0, 0], [1, 0], [-1, 1], [0, 1], [0.707106781, 0.707106781], ], [ [0, 1, 4, 3, 0], [3, 4, 7, 0], [3, 7, 6, 0], [2, 3, 6, 5, 0], ], [ [0, 1, 1], [1, 4, 2], [3, 0, 4], [4, 7, 2], [7, 6, 2], [2, 3, 4], [6, 5, 2], [5, 2, 3], ], [ [4, 7, 45], [7, 6, 45], ]) assert compare(m.nodes, [ [0, -1], [1, -1], [-1, 0], [0, 0], [1, 0], [-1, 1], [0, 1], [0.707106781, 0.707106781], ], eps=1e-4) assert m.elements_markers == [ [0, 1, 4, 3, 0], [3, 4, 7, 0], [3, 7, 6, 0], [2, 3, 6, 5, 0], ] assert m.elements == [ [0, 1, 4, 3], [3, 4, 7], [3, 7, 6], [2, 3, 6, 5], ] # This is not yet implemented: #assert m.boundaries == [ # [0, 1, 1], # [1, 4, 2], # [3, 0, 4], # [4, 7, 2], # [7, 6, 2], # [2, 3, 4], # [6, 5, 2], # [5, 2, 3], # ] #assert mesh.nurbs == ... m.refine_all_elements() assert m.elements == [ [0, 11, 20, 19], [11, 1, 9, 20], [20, 9, 4, 8], [19, 20, 8, 3], [3, 8, 34], [8, 4, 33], [34, 33, 7], [33, 34, 8], [3, 34, 10], [34, 7, 12], [10, 12, 6], [12, 10, 34], [2, 18, 16, 15], [18, 3, 10, 16], [16, 10, 6, 17], [15, 16, 17, 5] ]
def calc(threshold=0.3, strategy=0, h_only=False, error_tol=1, interactive_plotting=False, show_mesh=False, show_graph=True): mesh = Mesh() mesh.create([ [0, 0], [1, 0], [1, 1], [0, 1], ], [ [2, 3, 0, 1, 0], ], [ [0, 1, 1], [1, 2, 1], [2, 3, 1], [3, 0, 1], ], []) mesh.refine_all_elements() shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) space = H1Space(mesh, shapeset) set_bc(space) space.set_uniform_order(1) wf = WeakForm(1) set_forms(wf) sln = Solution() rsln = Solution() solver = DummySolver() selector = H1ProjBasedSelector(CandList.HP_ANISO, 1.0, -1, shapeset) view = ScalarView("Solution") iter = 0 graph = [] while 1: space.assign_dofs() sys = LinSystem(wf, solver) sys.set_spaces(space) sys.set_pss(pss) sys.assemble() sys.solve_system(sln) dofs = sys.get_matrix().shape[0] if interactive_plotting: view.show(sln, lib=lib, notebook=True, filename="a%02d.png" % iter) rsys = RefSystem(sys) rsys.assemble() rsys.solve_system(rsln) hp = H1Adapt([space]) hp.set_solutions([sln], [rsln]) err_est = hp.calc_error() * 100 err_est = hp.calc_error(sln, rsln) * 100 print "iter=%02d, err_est=%5.2f%%, DOFS=%d" % (iter, err_est, dofs) graph.append([dofs, err_est]) if err_est < error_tol: break hp.adapt(selector, threshold, strategy) iter += 1 if not interactive_plotting: view.show(sln, lib=lib, notebook=True) if show_mesh: mview = MeshView("Mesh") mview.show(mesh, lib="mpl", notebook=True, filename="b.png") if show_graph: from numpy import array graph = array(graph) import pylab pylab.clf() pylab.plot(graph[:, 0], graph[:, 1], "ko", label="error estimate") pylab.plot(graph[:, 0], graph[:, 1], "k-") pylab.title("Error Convergence for the Inner Layer Problem") pylab.legend() pylab.xlabel("Degrees of Freedom") pylab.ylabel("Error [%]") pylab.yscale("log") pylab.grid() pylab.savefig("graph.png")
def test_example_22(): from hermes2d.examples.c22 import set_bc, set_forms # The following parameters can be changed: SOLVE_ON_COARSE_MESH = True # if true, coarse mesh FE problem is solved in every adaptivity step INIT_REF_NUM = 1 # Number of initial uniform mesh refinements P_INIT = 2 # Initial polynomial degree of all mesh elements. THRESHOLD = 0.3 # 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 = 0.5 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 # Problem parameters. SLOPE = 60 # Slope of the layer. # Load the mesh mesh = Mesh() mesh.create([ [0, 0], [1, 0], [1, 1], [0, 1], ], [ [2, 3, 0, 1, 0], ], [ [0, 1, 1], [1, 2, 1], [2, 3, 1], [3, 0, 1], ], []) # 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 coarse mesh problem ls = LinSystem(wf) ls.set_spaces(space) # Adaptivity loop iter = 0 done = False 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
def test_example_01(): mesh = Mesh() mesh.load(domain_mesh) mesh.refine_all_elements() mesh.refine_all_elements() mesh.refine_all_elements()
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.
def test_example_22(): from hermes2d.examples.c22 import set_bc, set_forms # The following parameters can be changed: SOLVE_ON_COARSE_MESH = True # if true, coarse mesh FE problem is solved in every adaptivity step INIT_REF_NUM = 1 # Number of initial uniform mesh refinements P_INIT = 2 # Initial polynomial degree of all mesh elements. THRESHOLD = 0.3 # 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 = 0.5 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 # Problem parameters. SLOPE = 60 # Slope of the layer. # Load the mesh mesh = Mesh() mesh.create([ [0, 0], [1, 0], [1, 1], [0, 1], ], [ [2, 3, 0, 1, 0], ], [ [0, 1, 1], [1, 2, 1], [2, 3, 1], [3, 0, 1], ], []) # 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 coarse mesh problem ls = LinSystem(wf) ls.set_spaces(space) # Adaptivity loop iter = 0 done = False 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
# 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) # Initialize refinement selector selector = H1ProjBasedSelector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER)
#! /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()
def calc( threshold=0.3, strategy=0, h_only=False, error_tol=1, interactive_plotting=False, show_mesh=False, show_graph=True, ): mesh = Mesh() mesh.create( [[0, 0], [1, 0], [1, 1], [0, 1]], [[2, 3, 0, 1, 0]], [[0, 1, 1], [1, 2, 1], [2, 3, 1], [3, 0, 1]], [] ) mesh.refine_all_elements() shapeset = H1Shapeset() pss = PrecalcShapeset(shapeset) space = H1Space(mesh, shapeset) set_bc(space) space.set_uniform_order(1) wf = WeakForm(1) set_forms(wf) sln = Solution() rsln = Solution() solver = DummySolver() selector = H1ProjBasedSelector(CandList.HP_ANISO, 1.0, -1, shapeset) view = ScalarView("Solution") iter = 0 graph = [] while 1: space.assign_dofs() sys = LinSystem(wf, solver) sys.set_spaces(space) sys.set_pss(pss) sys.assemble() sys.solve_system(sln) dofs = sys.get_matrix().shape[0] if interactive_plotting: view.show(sln, lib=lib, notebook=True, filename="a%02d.png" % iter) rsys = RefSystem(sys) rsys.assemble() rsys.solve_system(rsln) hp = H1Adapt([space]) hp.set_solutions([sln], [rsln]) err_est = hp.calc_error() * 100 err_est = hp.calc_error(sln, rsln) * 100 print "iter=%02d, err_est=%5.2f%%, DOFS=%d" % (iter, err_est, dofs) graph.append([dofs, err_est]) if err_est < error_tol: break hp.adapt(selector, threshold, strategy) iter += 1 if not interactive_plotting: view.show(sln, lib=lib, notebook=True) if show_mesh: mview = MeshView("Mesh") mview.show(mesh, lib="mpl", notebook=True, filename="b.png") if show_graph: from numpy import array graph = array(graph) import pylab pylab.clf() pylab.plot(graph[:, 0], graph[:, 1], "ko", label="error estimate") pylab.plot(graph[:, 0], graph[:, 1], "k-") pylab.title("Error Convergence for the Inner Layer Problem") pylab.legend() pylab.xlabel("Degrees of Freedom") pylab.ylabel("Error [%]") pylab.yscale("log") pylab.grid() pylab.savefig("graph.png")
def test_example_01(): mesh = Mesh() mesh.load(domain_mesh) mesh.refine_all_elements() mesh.refine_all_elements() mesh.refine_all_elements()
def schroedinger_solver(n_eigs=4, iter=2, verbose_level=1, plot=False, potential="hydrogen", report=False, report_filename="report.h5", force=False, sim_name="sim", potential2=None): """ One particle Schroedinger equation solver. n_eigs ... the number of the lowest eigenvectors to calculate iter ... the number of adaptive iterations to do verbose_level ... 0 ... quiet 1 ... only moderate output (default) 2 ... lot's of output plot ........ plot the progress (solutions, refined solutions, errors) potential ... the V(x) for which to solve, one of: well, oscillator, hydrogen potential2 .. other terms that should be added to potential report ...... it will save raw data to a file, useful for creating graphs etc. Returns the eigenvalues and eigenvectors. """ set_verbose(verbose_level == 2) set_warn_integration(False) pot = {"well": 0, "oscillator": 1, "hydrogen": 2, "three-points": 3} pot_type = pot[potential] if report: from timeit import default_timer as clock from tables import IsDescription, UInt32Col, Float32Col, openFile, \ Float64Col, Float64Atom, Col, ObjectAtom class Iteration(IsDescription): n = UInt32Col() DOF = UInt32Col() DOF_reference = UInt32Col() cpu_solve = Float32Col() cpu_solve_reference = Float32Col() eig_errors = Float64Col(shape=(n_eigs,)) eigenvalues = Float64Col(shape=(n_eigs,)) eigenvalues_reference = Float64Col(shape=(n_eigs,)) h5file = openFile(report_filename, mode = "a", title = "Simulation data") if hasattr(h5file.root, sim_name): if force: h5file.removeNode(getattr(h5file.root, sim_name), recursive=True) else: print "The group '%s' already exists. Use -f to overwrite it." \ % sim_name return group = h5file.createGroup("/", sim_name, 'Simulation run') table = h5file.createTable(group, "iterations", Iteration, "Iterations info") h5eigs = h5file.createVLArray(group, 'eigenvectors', ObjectAtom()) h5eigs_ref = h5file.createVLArray(group, 'eigenvectors_reference', ObjectAtom()) iteration = table.row mesh = Mesh() mesh.load("square.mesh") if potential == "well": # Read the width of the mesh automatically. This assumes there is just # one square element: a = sqrt(mesh.get_element(0).get_area()) # set N high enough, so that we get enough analytical eigenvalues: N = 10 levels = [] for n1 in range(1, N): for n2 in range(1, N): levels.append(n1**2 + n2**2) levels.sort() E_exact = [pi**2/(2.*a**2) * m for m in levels] elif potential == "oscillator": E_exact = [1] + [2]*2 + [3]*3 + [4]*4 + [5]*5 + [6]*6 elif potential == "hydrogen": Z = 1 # atom number E_exact = [-float(Z)**2/2/(n-0.5)**2/4 for n in [1]+[2]*3+[3]*5 +\ [4]*8 + [5]*15] else: E_exact = [1.]*50 if len(E_exact) < n_eigs: print n_eigs print E_exact raise Exception("We don't have enough analytical eigenvalues.") #mesh.refine_element(0) mesh.refine_all_elements() #mesh.refine_all_elements() #mesh.refine_all_elements() #mesh.refine_all_elements() #mview = MeshView() #mview.show(mesh) shapeset = H1Shapeset() space = H1Space(mesh, shapeset) space.set_uniform_order(2) space.assign_dofs() pss = PrecalcShapeset(shapeset) #bview = BaseView() #bview.show(space) wf1 = WeakForm(1) # this is induced by set_verbose(): #dp1.set_quiet(not verbose) set_forms8(wf1, pot_type, potential2) wf2 = WeakForm(1) # this is induced by set_verbose(): #dp2.set_quiet(not verbose) set_forms7(wf2) solver = DummySolver() w = 320 h = 320 views = [ScalarView("", i*w, 0, w, h) for i in range(4)] viewsm = [ScalarView("", i*w, h, w, h) for i in range(4)] viewse = [ScalarView("", i*w, 2*h, w, h) for i in range(4)] #for v in viewse: # v.set_min_max_range(0, 10**-4) ord = OrderView("Polynomial Orders", 0, 2*h, w, h) rs = None precision = 30.0 if verbose_level >= 1: print "Problem initialized. Starting calculation." for it in range(iter): if verbose_level >= 1: print "-"*80 print "Starting iteration %d." % it if report: iteration["n"] = it #mesh.save("refined2.mesh") sys1 = LinSystem(wf1, solver) sys1.set_spaces(space) sys1.set_pss(pss) sys2 = LinSystem(wf2, solver) sys2.set_spaces(space) sys2.set_pss(pss) if verbose_level >= 1: print "Assembling the matrices A, B." sys1.assemble() sys2.assemble() if verbose_level == 2: print "converting matrices A, B" A = sys1.get_matrix() B = sys2.get_matrix() if verbose_level >= 1: n = A.shape[0] print "Solving the problem Ax=EBx (%d x %d)." % (n, n) if report: n = A.shape[0] iteration["DOF"] = n if report: t = clock() eigs, sols = solve(A, B, n_eigs, verbose_level == 2) if report: t = clock() - t iteration["cpu_solve"] = t iteration["eigenvalues"] = array(eigs) #h5eigs.append(sols) if verbose_level >= 1: print " \-Done." print_eigs(eigs, E_exact) s = [] n = sols.shape[1] for i in range(n): sln = Solution() vec = sols[:, i] sln.set_fe_solution(space, pss, vec) s.append(sln) if verbose_level >= 1: print "Matching solutions." if rs is not None: def minus2(sols, i): sln = Solution() vec = sols[:, i] sln.set_fe_solution(space, pss, -vec) return sln pairs, flips = make_pairs(rs, s, d1, d2) #print "_"*40 #print pairs, flips #print len(rs), len(s) #from time import sleep #sleep(3) #stop s2 = [] for j, flip in zip(pairs, flips): if flip: s2.append(minus2(sols,j)) else: s2.append(s[j]) s = s2 if plot: if verbose_level >= 1: print "plotting: solution" ord.show(space) for i in range(min(len(s), 4)): views[i].show(s[i]) views[i].set_title("Iter: %d, eig: %d" % (it, i)) #mat1.show(dp1) if verbose_level >= 1: print "reference: initializing mesh." rsys1 = RefSystem(sys1) rsys2 = RefSystem(sys2) if verbose_level >= 1: print "reference: assembling the matrices A, B." rsys1.assemble() rsys2.assemble() if verbose_level == 2: print "converting matrices A, B" A = rsys1.get_matrix() B = rsys2.get_matrix() if verbose_level >= 1: n = A.shape[0] print "reference: solving the problem Ax=EBx (%d x %d)." % (n, n) if report: n = A.shape[0] iteration["DOF_reference"] = n if report: t = clock() eigs, sols = solve(A, B, n_eigs, verbose_level == 2) if report: t = clock() - t iteration["cpu_solve_reference"] = t iteration["eigenvalues_reference"] = array(eigs) #h5eigs_ref.append(sols) if verbose_level >= 1: print " \-Done." print_eigs(eigs, E_exact) rs = [] rspace = rsys1.get_ref_space(0) n = sols.shape[1] for i in range(n): sln = Solution() vec = sols[:, i] sln.set_fe_solution(rspace, pss, vec) rs.append(sln) if verbose_level >= 1: print "reference: matching solutions." def minus(sols, i): sln = Solution() vec = sols[:, i] sln.set_fe_solution(rspace, pss, -vec) return sln # segfaults #mat2.show(rp1) def d1(x, y): return (x-y).l2_norm() def d2(x, y): return (x+y).l2_norm() from pairs import make_pairs pairs, flips = make_pairs(s, rs, d1, d2) rs2 = [] for j, flip in zip(pairs, flips): if flip: rs2.append(minus(sols,j)) else: rs2.append(rs[j]) rs = rs2 if plot: if verbose_level >= 1: print "plotting: solution, reference solution, errors" for i in range(min(len(s), len(rs), 4)): #views[i].show(s[i]) #views[i].set_title("Iter: %d, eig: %d" % (it, i)) viewsm[i].show(rs[i]) viewsm[i].set_title("Ref. Iter: %d, eig: %d" % (it, i)) viewse[i].show((s[i]-rs[i])**2) viewse[i].set_title("Error plot Iter: %d, eig: %d" % (it, i)) if verbose_level >= 1: print "Calculating errors." hp = H1OrthoHP(space) if verbose_level == 2: print "-"*60 print "calc error (iter=%d):" % it eig_converging = 0 errors = [] for i in range(min(len(s), len(rs))): error = hp.calc_error(s[i], rs[i]) * 100 errors.append(error) prec = precision if verbose_level >= 1: print "eig %d: %g%% precision goal: %g%%" % (i, error, prec) if report: iteration["eig_errors"] = array(errors) if errors[0] > precision: eig_converging = 0 elif errors[3] > precision: eig_converging = 3 elif errors[1] > precision: eig_converging = 1 elif errors[2] > precision: eig_converging = 2 else: precision /= 2 # uncomment the following line to only converge to some eigenvalue: #eig_converging = 3 if verbose_level >= 1: print "picked: %d" % eig_converging error = hp.calc_error(s[eig_converging], rs[eig_converging]) * 100 if verbose_level >= 1: print "Adapting the mesh." hp.adapt(0.3) space.assign_dofs() if report: iteration.append() table.flush() if report: h5file.close() return s