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_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 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_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()
