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_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_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_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 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 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_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_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 poisson_solver(mesh_tuple): """ Poisson solver. mesh_tuple ... a tuple of (nodes, elements, boundary, nurbs) """ set_verbose(False) mesh = Mesh() mesh.create(*mesh_tuple) 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) return sln
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)
#! /usr/bin/env python from hermes2d import Mesh, H1Shapeset, PrecalcShapeset, H1Space, \ BaseView from hermes2d.forms import set_forms from hermes2d.examples import get_example_mesh domain_mesh = get_example_mesh() 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(); bview = BaseView() bview.show(space) bview.wait()