def create_simple_mesh(Rint, Rout, resolution):
# Create circles as Circle(Center, Radius)
outer_circle = mshr.Circle(df.Point(0, 0), Rout)
inner_circle = mshr.Circle(df.Point(0, 0), Rint)
domain = outer_circle - inner_circle
mesh = mshr.generate_mesh(domain, resolution)
return mesh
def main():
"Generates the mesh"
import mshr as m
import dolfin as d
import matplotlib.pyplot as plt
d.set_log_level(13) # PROGRESS
r_1 = 0.5 # inner
r_2 = 2.0 # outer
res = 10 # resolution
circle_inner = m.Circle(d.Point(0.0, 0.0), r_1)
circle_outer = m.Circle(d.Point(0.0, 0.0), r_2)
domain = circle_outer - circle_inner
domain.set_subdomain(1, circle_inner)
domain.set_subdomain(2, circle_outer)
mesh = m.generate_mesh(domain, res)
print("max edge length:", mesh.hmax())
mesh_file_pvd = d.File("mesh.pvd")
mesh_file_pvd.write(mesh)
plt.figure()
d.plot(mesh, title="Mesh")
plt.show()
def build_mesh(self):
length = 60
height = 30
radius = 5
plate = mshr.Rectangle(fe.Point(0, 0), fe.Point(length, height))
circle1 = mshr.Circle(fe.Point(length/3, height/3), radius)
circle2 = mshr.Circle(fe.Point(length*2/3, height*2/3), radius)
material_domain = plate - circle1 - circle2
self.mesh = mshr.generate_mesh(material_domain, 50)
# Add dolfin-adjoint dependency
self.mesh = create_overloaded_object(self.mesh)
class Left(fe.SubDomain):
def inside(self, x, on_boundary):
return on_boundary and fe.near(x[0], 0)
class Right(fe.SubDomain):
def inside(self, x, on_boundary):
return on_boundary and fe.near(x[0], length)
class Corner(fe.SubDomain):
def inside(self, x, on_boundary):
return fe.near(x[0], 0) and fe.near(x[1], 0)
self.left = Left()
self.right = Right()
self.corner = Corner()
def create_mesh_with_holes(Rint, Rout, Rhole, resolution):
# Create circles as Circle(Center, Radius)
outer_circle = mshr.Circle(df.Point(0,0), Rout)
inner_circle = mshr.Circle(df.Point(0,0), Rint)
hole = mshr.Circle(df.Point(0, 0.5*(Rint+Rout)), Rhole)
domain = outer_circle - inner_circle - hole
mesh = mshr.generate_mesh(domain, resolution)
return mesh
def get_geometry(domain_part):
nx = 5
ny = 10
low_resolution = 5
high_resolution = 5
n_vertices = 20
if domain_part is DomainPart.LEFT:
nx = nx * 3
elif domain_part is DomainPart.RIGHT:
ny = ny * 2
elif domain_part is DomainPart.CIRCULAR:
n_vertices = n_vertices
elif domain_part is DomainPart.RECTANGLE:
n_vertices = n_vertices
else:
raise Exception("invalid domain_part: {}".format(domain_part))
if domain_part is DomainPart.LEFT or domain_part is DomainPart.RIGHT:
if domain_part is DomainPart.LEFT:
p0 = Point(x_left, y_bottom)
p1 = Point(x_coupling, y_top)
elif domain_part is DomainPart.RIGHT:
p0 = Point(x_coupling, y_bottom)
p1 = Point(x_right, y_top)
else:
raise Exception("invalid control flow!")
mesh = RectangleMesh(p0, p1, nx, ny)
coupling_boundary = StraightBoundary()
remaining_boundary = ExcludeStraightBoundary()
elif domain_part is DomainPart.CIRCULAR or domain_part is DomainPart.RECTANGLE:
p0 = Point(x_left, y_bottom)
p1 = Point(x_right, y_top)
whole_domain = mshr.Rectangle(p0, p1)
if domain_part is DomainPart.CIRCULAR:
circular_domain = mshr.Circle(midpoint, radius, n_vertices)
mesh = mshr.generate_mesh(circular_domain, high_resolution, "cgal")
elif domain_part is DomainPart.RECTANGLE:
circular_domain = mshr.Circle(midpoint, radius, n_vertices)
mesh = mshr.generate_mesh(whole_domain - circular_domain,
low_resolution, "cgal")
else:
raise Exception("invalid control flow!")
coupling_boundary = CircleBoundary()
remaining_boundary = ExcludeCircleBoundary()
else:
raise Exception("invalid control flow!")
return mesh, coupling_boundary, remaining_boundary
def mesh2d(inner, outer, *meshres, stefan=True):
origin = dolfin.Point(0., 0.)
if stefan:
geometry = mshr.Circle(origin, outer, 2 * meshres[0]) - mshr.Circle(
origin, inner, int(0.5 * meshres[0]))
mesh = mshr.generate_mesh(geometry, meshres[0])
mesh.init()
# Construct of the facet markers:
boundary = (dolfin.MeshFunction("size_t", mesh,
mesh.topology().dim() - 1, 0), {})
for f in dolfin.facets(mesh):
if f.midpoint().distance(origin) <= inner and f.exterior():
boundary[0][f] = 1 # inner radius
boundary[1]['inner'] = 1
elif f.midpoint().distance(origin) >= (inner +
outer) / 2 and f.exterior():
boundary[0][f] = 2 # outer radius
boundary[1]['outer'] = 2
# Definition of measures and normal vector:
n = dolfin.FacetNormal(mesh)
dx = dolfin.Measure("dx", mesh)
ds = dolfin.Measure("ds", domain=mesh, subdomain_data=boundary[0])
else:
width = inner
height = outer
mesh = dolfin.RectangleMesh(origin, Point(width, height), meshres[0],
meshres[1])
mesh.init()
boundary = (dolfin.MeshFunction("size_t", mesh,
mesh.topology().dim() - 1, 0), {})
for f in dolfin.facets(mesh):
if dolfin.near(f.midpoint()[1], 0.):
boundary[0][f] = 1 # bottom
boundary[1]['bottom'] = 1
elif dolfin.near(f.midpoint()[1], height):
boundary[0][f] = 2 # top
boundary[1]['top'] = 2
elif dolfin.near(f.midpoint()[0], 0.):
boundary[0][f] = 3 # left
boundary[1]['left'] = 3
elif dolfin.near(f.midpoint()[0], width):
boundary[0][f] = 4 # right
boundary[1]['right'] = 4
# Definition of measures and normal vector:
n = dolfin.FacetNormal(mesh)
dx = dolfin.Measure("dx", mesh)
ds = dolfin.Measure("ds", subdomain_data=boundary[0])
return (mesh, boundary, n, dx, ds)
def generate_mesh():
# Define domain
x_min = 0
x_max = 5
y_min = 0
y_max = 1.5
xc = 0.7
yc = 0.5 * (y_min + y_max)
r = 0.2
circle = mshr.Circle(Point(xc, yc), r)
domain = mshr.Rectangle(Point(x_min, y_min), Point(x_max, y_max)) - circle
# Create resolution
mesh_res = 64
# Create mesh
mesh = mshr.generate_mesh(domain, mesh_res)
# Save mesh
File(os.path.join(DATA_DIR, 'mesh.xml.gz')) << mesh
# Save dof coordinates
V = FunctionSpace(mesh, 'P', 1)
dof_coordinates = V.tabulate_dof_coordinates()
np.save(os.path.join(DATA_DIR, 'coordinates.npy'), dof_coordinates)
# Save dof triangles
vertex2dof = vertex_to_dof_map(V)
vertex2dof_vec = np.vectorize(lambda v: vertex2dof[v])
dof_triangles = vertex2dof_vec(mesh.cells())
np.save(os.path.join(DATA_DIR, 'triangles.npy'), dof_triangles)
def test_build_mesh():
"""
Create a few meshes, extract the vertices and cells from them and pass them
to build_mesh() to rebuild the mesh. Then check that the result is the same
as the original.
"""
def assert_mesh_builds_correctly(mesh):
coords = mesh.coordinates()
cells = mesh.cells()
mesh_new = build_mesh(coords, cells)
assert np.allclose(coords, mesh_new.coordinates())
assert np.allclose(cells, mesh_new.cells())
mesh1 = df.RectangleMesh(df.Point(0, 0), df.Point(20, 10), 12, 8)
assert_mesh_builds_correctly(mesh1)
mesh2_temp = mshr.Circle(df.Point(2.0, -3.0), 10)
mesh2 = mshr.generate_mesh(mesh2_temp, 10)
assert_mesh_builds_correctly(mesh2)
mesh3 = df.BoxMesh(df.Point(0, 0, 0), df.Point(20, 10, 5), 12, 8, 3)
assert_mesh_builds_correctly(mesh3)
mesh4_temp = mshr.Sphere(df.Point(2.0, 3.0, -4.0), 10)
mesh4 = mshr.generate_mesh(mesh4_temp, 10)
assert_mesh_builds_correctly(mesh4)
def generate_mesh(name, par=40, refinement=False):
info("Generating mesh {} ...".format(name))
# construct mesh
geometry = mshr.Rectangle(Point(0.0, 0.0), Point(gL, gW)) \
- mshr.Circle(Point(gX, gY), g_radius, 20) \
- mshr.Rectangle(Point(gX, gY - 0.5*gEH), Point(gX + g_radius + gEL, gY + 0.5*gEH))
mesh = mshr.generate_mesh(geometry, par)
if refinement:
parameters["refinement_algorithm"] = "plaza_with_parent_facets"
for k in range(2): # 2
cf = MeshFunction('bool', mesh, 2)
cf.set_all(False)
z = 0.2 #0.15 # 0.08
for c in cells(mesh):
if c.midpoint().distance(Point(gX, gY)) < (0.05 + k * z):
cf[c] = True
elif (c.midpoint()[0] <= gX + g_radius + gEL + k*z and c.midpoint()[0] >= gX - k*z\
and c.midpoint()[1] <= gY + 0.5*gEH + k*z and c.midpoint()[1] >= gY - 0.5*gEH - k*z):
cf[c] = True
mesh = refine(mesh, cf)
mesh.init()
# Save mesh
if __version__[:4] == '2018':
hdf5 = HDF5File(MPI.comm_world, name, 'w')
else:
hdf5 = HDF5File(mpi_comm_world(), name, 'w')
hdf5.write(mesh, "/mesh")
return mesh
def rectangle_mesh_with_hole(point1=Point(0, 0),
point2=Point(3, 1),
hole_cent=Point(1.5, 0.5),
hole_rad=0.25,
npts=15):
"""
generates a triangulated Rectangular domain with a circular hole
input
------
point1: Point coordinates in 3D corner_min of box
point2: Point coordinates in 3D corner_max of box
cyl_cent1: Point coordinates in 3D of center1 of Cylinder
cyl_cent2: Point coordinates in 3D of center1 of Cylinder
cyl_rad: Radius of cylinder
npts: number of discretization points
output:
------
mesh: 2D FEniCS mesh with circular hole
"""
Router = mshr.Rectangle(point1, point2)
Rinner = mshr.Circle(hole_cent, hole_rad)
domain = Router - Rinner
mesh = mshr.generate_mesh(domain, npts)
print_mesh_stats(mesh)
return mesh
def puncture_mesh(self):
for p in self.hole_coordinates:
circle = mesher.Circle(fe.Point(p), self.hole_radius)
self.geometry -= circle
self.mesh = mesher.generate_mesh(self.geometry, self.mesh_density)
print('Done with the mesh generation')
def irregular_channel():
radius = 0.35
resolution = 25
point_A = fa.Point(0, 0)
point_B = fa.Point(2, -1)
point_C = fa.Point(2, 2)
point_D = fa.Point(0, 1)
point_E = fa.Point(0.5, 0.5)
point_F = fa.Point(1.5, 1)
point_G = fa.Point(1.5, 0)
outline = mshr.Polygon([point_A, point_B, point_C, point_D])
circle_1 = mshr.Circle(point_E, radius)
circle_2 = mshr.Circle(point_F, radius)
circle_3 = mshr.Circle(point_G, radius)
mesh = mshr.generate_mesh(outline - circle_1 - circle_2 - circle_3,
resolution)
return mesh
def __init__(self, center, radius, *, maxh = 1., eps = csg_eps): segments = max(int(4*radius/maxh), 32) eps *= radius super().__init__(mshr.Circle(dolfin.Point(*center), radius, segments), csg_boundaries = [ dolfin.CompiledSubDomain( 'on_boundary && near((x[0]-c0)*(x[0]-c0) + (x[1]-c1)*(x[1]-c1), rr, eps)', c0 = center[0], c1 = center[1], rr = radius * radius, eps = eps ) ])
def geo_fun():
'''
Creates hollow circle.
'''
geo_params = {}
geo_params['R_in'] = 8e-3 #m
geo_params['R_ex'] = 16e-3 #m
geo_params['x_0'] = 0.
geo_params['y_0'] = 0.
geo_params['z_0'] = 0.
#number of faces on the side when generating a polyhedral approximation
#CGAL meshes the polyhedral approximation; hence, it is better to keep it high
#https://bitbucket.org/fenics-project/mshr/issues/26/creation-of-mesh-with-generate_mesh-most
fragments1 = 1000
fragments2 = 400
cyl_ho = ms.Circle(
do.Point(geo_params['x_0'], geo_params['y_0'], geo_params['z_0']),
geo_params['R_ex'], fragments2)
#x0_l = [-.5, 0., .5, 0.]
#y0_l = [0., -.5, 0., .5]
x0_l = [0.]
y0_l = [0.]
for itera in xrange(len(x0_l)):
geo_params['x_0_{}'.format(itera)] = x0_l[itera]
geo_params['y_0_{}'.format(itera)] = y0_l[itera]
geo_params['z_0_{}'.format(itera)] = 0.
#top, bottom, top radius, bottom radius, segments
cyl_in = ms.Circle(
do.Point(geo_params['x_0_{}'.format(itera)],
geo_params['y_0_{}'.format(itera)],
geo_params['z_0_{}'.format(itera)]), geo_params['R_in'],
fragments1)
#hollow cylinder
cyl_ho -= cyl_in
return cyl_ho, geo_params
def add_circle_obstacle(self, p, radius, mirror=False, accuracy=10):
points = [Point(p[0], p[1])]
# Replicate the circle on the other edge of the map.
if mirror:
points.append(
Point(self.dimension[0] + self.robot_radius - p[0], p[1]))
for point in points:
self._map -= mshr.Circle(point, radius + self.robot_radius,
accuracy)
def tensile_test_bar(numpts=60, plot_=True):
outer = mshr.Rectangle(Point(-100, -10), Point(100, 10))
barLo = mshr.Rectangle(Point(-30, 6.25), Point(30, 10))
barHi = mshr.Rectangle(Point(-30, -10), Point(30, -6.25))
c1 = mshr.Circle(Point(-30, -19.5), 13.4)
c2 = mshr.Circle(Point(30, -19.5), 13.4)
c3 = mshr.Circle(Point(-30, 19.5), 13.4)
c4 = mshr.Circle(Point(30, 19.5), 13.4)
domain = outer - barLo - barHi - c1 - c2 - c3 - c4
mm = mshr.generate_mesh(domain, numpts)
if plot_:
plt.figure()
plot(mm, color='k')
plt.xlim(-120, 120)
plt.ylim(-20, 20)
plt.show(block=False)
return mm
def method(L=3., H=1., R=0.3, n_segments=40, res=60, show=False, **kwargs):
"""
Generates mesh of Snausen/Snoevsen.
"""
info("Generating mesh of Snoevsen.")
# Define points:
pt_A = df.Point(0., 0.)
pt_B = df.Point(L, H)
pt_C = df.Point(L / 2 - 2 * R, 0.)
pt_D = df.Point(L / 2 + 2 * R, 0.)
pt_E = df.Point(L / 2 - 2 * R, -R)
pt_F = df.Point(L / 2 + 2 * R, -R)
pt_G = df.Point(L / 2, -R)
tube = mshr.Rectangle(pt_A, pt_B)
add_rect = mshr.Rectangle(pt_E, pt_D)
neg_circ_L = mshr.Circle(pt_E, R, segments=n_segments)
neg_circ_R = mshr.Circle(pt_F, R, segments=n_segments)
pos_circ = mshr.Circle(pt_G, R, segments=n_segments)
domain = tube + add_rect - neg_circ_L - neg_circ_R + pos_circ
mesh = mshr.generate_mesh(domain, res)
# check that mesh is periodic along x
boun = df.BoundaryMesh(mesh, "exterior")
y = boun.coordinates()[:, 1]
y = y[y < 1.]
y = y[y > 0.]
n_y = len(y)
n_y_unique = len(np.unique(y))
assert (n_y == 2 * n_y_unique)
mesh_path = os.path.join(MESHES_DIR, "snoevsen_res" + str(res))
store_mesh_HDF5(mesh, mesh_path)
if show:
df.plot(mesh, "Mesh")
plt.show()
def generate_polygonal_mesh(resolution,
ampothem,
nedges,
radius,
plot_mesh=False):
"""
Sometimes segault is thrown when mshr.generate_mesh() is
called. This is because resolution is to low to resolve
smaller inner-most circle.
"""
import mshr
vertices = get_vertices_of_polygon(ampothem, nedges)
domain_vertices = []
for vertex in vertices.T:
domain_vertices.append(dl.Point(vertex[0], vertex[1]))
domain = mshr.Polygon(domain_vertices)
cx1, cy1 = 0.0, 0.0
circle1 = mshr.Circle(dl.Point(cx1, cy1), radius)
domain.set_subdomain(1, circle1)
cx2, cy2 = cx1 - radius / np.sqrt(8), cy1 - radius / np.sqrt(8)
circle2 = mshr.Circle(dl.Point(cx2, cy2), radius / 2)
domain.set_subdomain(2, circle2)
mesh = mshr.generate_mesh(domain, resolution)
if plot_mesh:
subdomains = dl.MeshFunction('size_t', mesh, mesh.topology().dim(), 2)
subdomains.set_all(0)
subdomain1 = dl.AutoSubDomain(lambda x: np.sqrt(
(x[0] - cx1)**2 + (x[1] - cy1)**2) < radius + 1e-8)
subdomain1.mark(subdomains, 1)
subdomain2 = dl.AutoSubDomain(lambda x: np.sqrt(
(x[0] - cx2)**2 + (x[1] - cy2)**2) < radius / 2 + 1e-8)
subdomain2.mark(subdomains, 2)
dl.plot(mesh)
dl.plot(subdomains)
plt.show()
return mesh
def generate_mesh_with_cicular_subdomain(resolution, radius, plot_mesh=False):
cx1, cy1 = 0.5, 0.5
lx, ly = 1.0, 1.0
# Define 2D geometry
domain = mshr.Rectangle(dl.Point(0.0, 0.0), dl.Point(lx, ly))
domain.set_subdomain(1, mshr.Circle(dl.Point(cx1, cy1), radius))
cx2, cy2 = cx1 - radius / np.sqrt(8), cy1 - radius / np.sqrt(8)
domain.set_subdomain(2, mshr.Circle(dl.Point(cx2, cy2), radius / 2))
# Generate and plot mesh
mesh2d = mshr.generate_mesh(domain, resolution)
if plot_mesh:
dl.plot(mesh2d, "2D mesh")
class Circle1(dl.SubDomain):
def inside(self, x, on_boundary):
return pow(x[0] - cx1, 2) + pow(x[1] - cy1, 2) <= pow(
radius, 2)
class Circle2(dl.SubDomain):
def inside(self, x, on_boundary):
return pow(x[0] - cx2, 2) + pow(x[1] - cy2, 2) <= pow(
radius / 2, 2)
# Convert subdomains to mesh function for plotting
mf = dl.MeshFunction("size_t", mesh2d, 2)
mf.set_all(0)
circle1 = Circle1()
circle2 = Circle2()
for c in dl.cells(mesh2d):
if circle1.inside(c.midpoint(), True):
mf[c.index()] = 1
if circle2.inside(c.midpoint(), True):
mf[c.index()] = 2
dl.plot(mf, "Subdomains")
# show must be called here or plot gets messed up
# plt.show()
return mesh2d
def make_mesh(self, KindOfMesh, nCellsX, nCellsY):
"""generates the mesh and returns it"""
#KindOfMesh = 0 => UnitSquareMesh
#KindOfMesh = 1 => CircleMesh
if (KindOfMesh == 0):
mesh = UnitSquareMesh(nCellsX, nCellsY)
elif (KindOfMesh == 1):
circle = mshr.Circle(Point(0, 0), 1)
mesh = mshr.generate_mesh(circle, nCellsX)
else:
print("KindOfMesh has value", KindOfMesh, "which is not valid.")
exit(1)
self.mesh = mesh
def method(Lx=4.,
Ly=4.,
rad=0.2,
R=0.3,
N=24,
n_segments=40,
res=80,
do_plot=False,
**kwargs):
""" Porous mesh. Not really done or useful. """
info("Generating porous mesh")
# x = np.random.rand(N, 2)
diam2 = 4 * R**2
pts = np.zeros((N, 2))
for i in range(N):
while True:
pt = (np.random.rand(2) - 0.5) * np.array([Lx - 2 * R, Ly - 2 * R])
if i == 0:
break
dist = pts[:i, :] - np.outer(np.ones(i), pt)
dist2 = dist[:, 0]**2 + dist[:, 1]**2
if all(dist2 > diam2):
break
pts[i, :] = pt
rect = mshr.Rectangle(df.Point(-Lx / 2, -Ly / 2), df.Point(Lx / 2, Ly / 2))
domain = rect
for i in range(N):
domain -= mshr.Circle(df.Point(pts[i, 0], pts[i, 1]),
rad,
segments=n_segments)
mesh = mshr.generate_mesh(domain, res)
store_mesh_HDF5(
mesh,
os.path.join(
MESHES_DIR,
"porous_Lx{Lx}_Ly{Ly}_rad{rad}_R{R}_N{N}_res{res}.h5".format(
Lx=Lx, Ly=Ly, rad=rad, R=R, N=N, res=res)))
if do_plot:
df.plot(mesh)
df.interactive()
def build_space(N_circle, N_bulk, u_in):
"""Prepare data for DGF benchmark. Return function
space, list of boundary conditions and surface measure
on the cylinder."""
# Define domain
center = Point(0.2, 0.2)
radius = 0.05
L = 2.2
W = 0.41
geometry = mshr.Rectangle(Point(0.0, 0.0), Point(L, W)) \
- mshr.Circle(center, radius, N_circle)
# Build mesh
mesh = mshr.generate_mesh(geometry, N_bulk)
# Construct facet markers
bndry = MeshFunction("size_t", mesh, mesh.topology().dim() - 1)
for f in facets(mesh):
mp = f.midpoint()
if near(mp[0], 0.0): # inflow
bndry[f] = 1
elif near(mp[0], L): # outflow
bndry[f] = 2
elif near(mp[1], 0.0) or near(mp[1], W): # walls
bndry[f] = 3
elif mp.distance(center) <= radius: # cylinder
bndry[f] = 5
# Build function spaces (Taylor-Hood)
P2 = VectorElement("P", mesh.ufl_cell(), 2)
P1 = FiniteElement("P", mesh.ufl_cell(), 1)
TH = MixedElement([P2, P1])
W = FunctionSpace(mesh, TH)
# Prepare Dirichlet boundary conditions
bc_walls = DirichletBC(W.sub(0), (0, 0), bndry, 3)
bc_cylinder = DirichletBC(W.sub(0), (0, 0), bndry, 5)
bc_in = DirichletBC(W.sub(0), u_in, bndry, 1)
bcs = [bc_cylinder, bc_walls, bc_in]
# Prepare surface measure on cylinder
ds_circle = Measure("ds", subdomain_data=bndry, subdomain_id=5)
return W, bcs, ds_circle
def heat_equation(h, print_to_file=False):
N = 32
k = 401.
u_f = 280.
# Create mesh
domain = mshr.Rectangle(Point(-1, -1), Point(1, 1)) - mshr.Circle(
Point(0, 0), 0.25)
mesh = mshr.generate_mesh(domain, N)
# Set up function space
V = FunctionSpace(mesh, "Lagrange", 2)
# Set up functions
u = TrialFunction(V)
v = TestFunction(V)
# Set up boundary
[boundaries, ds] = set_boundary(mesh)
bc = DirichletBC(V, 1000., boundaries, 1)
# Set up boundary functions
g_N = Expression('0', degree=1)
g_R = h * u_f
# Set up variational problem
a = k * inner(grad(u), grad(v)) * dx + k * h * (u * v) * ds(3)
L = g_N * v * k * ds(2) + g_R * k * v * ds(3)
# Solve the system
usol = Function(V)
solve(a == L, usol, bc)
# Plot solution
plot(usol, interactive=True)
plt.title('h = %d' % h)
plt.show()
# Print total heat
print('h = %d ==> %f' % (h, assemble(usol * dx)))
if (print_to_file):
# Print to files readable by ParaView
file = File('hvalue%d.pvd' % h)
file << usol
def method(res=96, H=0.41, L=2.2, x=0.2, y=0.2, r=0.05,
segments=100, show=False, **kwargs):
'''
Generates mesh for the 'Flow around cylinder' benchmark:
http://www.featflow.de/en/benchmarks/cfdbenchmarking/flow.html
Note: The generated mesh is stored in "BERNAISE/meshes/".
'''
info("Generating mesh using the mshr tool.")
rect = mshr.Rectangle(df.Point(0, 0), df.Point(L, H))
cyl = mshr.Circle(df.Point(x, y), r, segments=segments)
domain = rect - cyl
mesh = mshr.generate_mesh(domain, res)
meshpath = os.path.join(
MESHES_DIR,
"cylinderinchannel_H{}_L{}_x{}_y{}_r{}_res{}".format(
H, L, x, y, r, res))
store_mesh_HDF5(mesh, meshpath)
if show:
df.plot(mesh)
plt.show()
def solve0(variant):
cur_var = int(variant)
alpha = 1
if (cur_var == 1):
u_D = Expression('3 + 2*x[0]*x[0] + 3*x[1]*x[1]', degree=2)
g = Expression(
'(4*sqrt(x[0]*x[0]+x[1]*x[1])*pow(cos(atan2(x[1],x[0])),2)+6*sqrt(x[0]*x[0] + x[1]*x[1])*pow(sin(atan2(x[1],x[0])),2))',
degree=2)
f = Expression('-10 + alpha*(3+2*x[0]*x[0]+3*x[1]*x[1])',
degree=2,
alpha=alpha)
elif (cur_var == 2):
u_D = Expression('(x[0]*x[0]+x[1]*x[1])*pow(cos(atan2(x[1],x[0])),2)',
degree=2)
g = Expression(
'2*sqrt(x[0]*x[0]+x[1]*x[1])*pow(cos(atan2(x[1],x[0])),2)',
degree=2)
f = Expression(
'-(4*pow(cos(atan2(x[1],x[0])),2)-2*cos(2*atan2(x[1],x[0]))) + alpha*(x[0]*x[0]+x[1]*x[1])*pow(cos(atan2(x[1],x[0])),2)',
degree=2,
alpha=alpha)
elif (cur_var == 3):
u_D = Expression('x[0]*x[0]+x[0]*x[1]', degree=2)
g = Expression(
'2*sqrt(x[0]*x[0]+x[1]*x[1])*pow(cos(atan2(x[1],x[0])),2)+sqrt(x[0]*x[0]+x[1]*x[1])*sin(2*atan2(x[1],x[0]))',
degree=2)
f = Expression('-2+alpha*(x[0]*x[0]+x[0]*x[1])', degree=2, alpha=alpha)
else:
return
domain = mshr.Circle(Point(0., 0.), 1.0, 60)
mesh = mshr.generate_mesh(domain, 60)
V = FunctionSpace(mesh, 'P', 1)
def boundary1(x, on_boundary):
if on_boundary:
if x[1] >= 0:
return True
else:
return False
else:
return False
bc = DirichletBC(V, u_D, boundary1)
u = TrialFunction(V)
v = TestFunction(V)
a = dot(grad(u), grad(v)) * dx + alpha * u * v * dx
L = f * v * dx + g * v * ds
u = Function(V)
solve(a == L, u, bc)
#errors
error_L2 = errornorm(u_D, u, 'L2')
vertex_values_u_D = u_D.compute_vertex_values(mesh)
vertex_values_u = u.compute_vertex_values(mesh)
error_C = np.max(np.abs(vertex_values_u - vertex_values_u_D))
print('norm_L2 = ' + str(error_L2))
print('error_C = ' + str(error_C))
#graph 1
n = mesh.num_vertices()
d = mesh.geometry().dim()
mesh_coordinates = mesh.coordinates().reshape((n, d))
triangles = np.asarray([cell.entities(0) for cell in cells(mesh)])
triangulation = tri.Triangulation(mesh_coordinates[:, 0],
mesh_coordinates[:, 1], triangles)
fig1 = plt.figure(1)
zfaces = np.asarray([u(cell.midpoint()) for cell in cells(mesh)])
plt.tripcolor(triangulation, facecolors=zfaces, edgecolors='k')
plt.savefig(str('u' + variant + '.png'))
#graph 2
fig2 = plt.figure(2)
zfaces2 = np.asarray([u_D(cell.midpoint()) for cell in cells(mesh)])
plt.tripcolor(triangulation, facecolors=zfaces2, edgecolors='k')
plt.savefig(str('u_D' + variant + '.png'))
#difference
fig3 = plt.figure(3)
zfaces3 = abs(zfaces - zfaces2)
plt.tripcolor(triangulation, facecolors=zfaces3, edgecolors='k')
plt.colorbar()
plt.savefig(str('difference' + variant + '.png'))
fig.tight_layout() # ## Circular geometry # In[98]: r_outer = 1 r_inner = 0.25 r_middle = 0.1 x0, y0 = 0.4, 0.4 # In[99]: domain = mshr.Circle(dolfin.Point(.0, .0), r_outer) - mshr.Circle(dolfin.Point(.0, .0), r_inner) - mshr.Circle(dolfin.Point( x0, y0), r_middle) - mshr.Circle(dolfin.Point( x0, -y0), r_middle) - mshr.Circle(dolfin.Point(-x0, y0), r_middle) - mshr.Circle(dolfin.Point(-x0, -y0), r_middle) # In[100]: mesh = mshr.generate_mesh(domain, 10) # In[101]: mesh # In[102]: V = dolfin.FunctionSpace(mesh, 'Lagrange', 1)
def Circle(self, center, rad):
"""
create a mesh on a circular domain with a radius equal to rad
"""
return mshr.Circle(center, rad)
from dolfin import *
T = 1000
num_steps = 5000
dt = T / num_steps
alpha = 0
beta = 1.2
sigma = 1000.0
# Create mesh and define function space
długość = 10.0
szerokość = 5.0
drzwi = 1.5
pomieszczenie = ms.Rectangle(Point(0.0, 0.0), Point(długość, szerokość))
przeszkoda_kolista = ms.Circle(Point(długość - szerokość / 2, szerokość / 2),
szerokość / 4)
mesh = ms.generate_mesh(pomieszczenie - przeszkoda_kolista, 100)
mesh2 = ms.generate_mesh(ms.Rectangle(Point(0.0, 0.0), Point(2.0, 2.0)), 200)
drzwi1 = 3.0
drzwi2 = 4.0
drzwi3 = 3.0
korytarz = 80.0
#mesh_lotnisko - hala przylotów
hala = ms.Rectangle(Point(0.0, 0.0), Point(100.0, 40.0))
stoisko1 = ms.Rectangle(Point(15.0, 18.0), Point(15.0 + 4.0, 18.0 + 5.0))
stoisko2 = ms.Rectangle(Point(80.0, 18.0), Point(80.0 + 4.0, 18.0 + 5.0))
ławka = ms.Rectangle(Point(48.0, 20.0), Point(48.0 + 4.0, 20.0 + 1.0))
mesh_lotnisko = ms.generate_mesh(hala - stoisko1 - stoisko2 - ławka, 100)
from finmag import Simulation as Sim from finmag.energies import Exchange, Demag, DMI, Zeeman from finmag.energies import UniaxialAnisotropy from finmag.util.consts import mu0 import os, shutil import dolfin as df # Geometries import mshr from finmag.util.mesh_templates import Nanodisk # MESH ------------------------------------------------------------------------ mesh_file = 'mesh/nanodisk.xml.gz' mesh = mshr.Circle(df.Point(0, 0), 50) mesh = mshr.generate_mesh(mesh, 40) mesh = df.Mesh(mesh) # Simulation and energies ----------------------------------------------------- # Interfacial A = 13e-12 D = 3e-3 Ms = 0.86e6 Ku = 0.4e6 sim = Sim(mesh, Ms=Ms, unit_length=1e-9, name="nanodisk_Cnv") def m_init(pos):
def solve_cell_problems(self, method='regularized', plot=False):
"""
Solve the cell problems for the given PDE by changing the geometry to exclude the zone in the middle
:return:
"""
class PeriodicBoundary(fe.SubDomain):
# Left boundary is "target domain" G
def inside(self, x, on_boundary):
par = MembraneSimulator.w / MembraneSimulator.length
tol = 1E-4
return on_boundary and x[1] >= -tol and x[1] <= tol
# Map right boundary (H) to left boundary (G)
def map(self, x, y):
y[1] = x[1] + 2 * self.eta / MembraneSimulator.length
y[0] = x[0]
mesh_size = 50
# Domain
if method == 'circle':
self.obstacle_radius = self.eta / MembraneSimulator.length / 2
box_begin_point = fe.Point(-self.w / MembraneSimulator.length, 0)
box_end_point = fe.Point(self.w / MembraneSimulator.length,
2 * self.eta / MembraneSimulator.length)
box = mshr.Rectangle(box_begin_point, box_end_point)
cell = box - mshr.Circle(
fe.Point(0, self.eta / MembraneSimulator.length),
self.obstacle_radius, mesh_size)
self.cell_mesh = mshr.generate_mesh(cell, mesh_size)
diff_coef = fe.Constant(
((0, 0), (0, self.D[1, 1]))) # limit for regularisation below.
# elif method == 'diff_coef':
# print("Haha this is going to crash. Also it is horrible in accuracy")
# self.cell_mesh = fe.RectangleMesh(fe.Point(-self.w / MembraneSimulator.length, 0),
# fe.Point(self.w / MembraneSimulator.length,
# 2 * self.eta / MembraneSimulator.length), mesh_size, mesh_size)
# diff_coef = fe.Expression(
# (('0', '0'), ('0', 'val * ((x[0] - c_x)*(x[0] - c_x) + (x[1] - c_y)*(x[1] - c_y) > r*r)')),
# val=(4 * self.ref_T * MembraneSimulator.d2 / MembraneSimulator.length ** 2), c_x=0,
# c_y=(self.eta / MembraneSimulator.length),
# r=self.obstacle_radius, degree=2, domain=self.cell_mesh)
elif method == 'regularized':
box_begin_point = fe.Point(-self.w / MembraneSimulator.length, 0)
box_end_point = fe.Point(self.w / MembraneSimulator.length,
2 * self.eta / MembraneSimulator.length)
box = mshr.Rectangle(box_begin_point, box_end_point)
obstacle_begin_point = fe.Point(
-self.w / MembraneSimulator.length * self.obs_length,
self.eta / MembraneSimulator.length * (1 - self.obs_height))
obstacle_end_point = fe.Point(
self.w / MembraneSimulator.length * self.obs_length,
self.eta / MembraneSimulator.length * (1 + self.obs_height))
obstacle = mshr.Rectangle(obstacle_begin_point, obstacle_end_point)
cell = box - obstacle
self.cell_mesh = mshr.generate_mesh(cell, mesh_size)
diff_coef = fe.Constant(((self.obs_ratio * self.D[0, 0], 0),
(0, self.D[1, 1]))) # defect matrix.
else:
raise ValueError("%s not a valid method to solve cell problem" %
method)
self.cell_fs = fe.FunctionSpace(self.cell_mesh, 'P', 2)
self.cell_solutions = [
fe.Function(self.cell_fs),
fe.Function(self.cell_fs)
]
w = fe.TrialFunction(self.cell_fs)
phi = fe.TestFunction(self.cell_fs)
scaled_unit_vectors = [
fe.Constant((1. / np.sqrt(self.obs_ratio), 0.)),
fe.Constant((0., 1.))
]
for i in range(2):
weak_form = fe.dot(
diff_coef *
(fe.grad(w) + scaled_unit_vectors[i]), fe.grad(phi)) * fe.dx
print("Solving cell problem")
bc = fe.DirichletBC(self.cell_fs, fe.Constant(0),
MembraneSimulator.cell_boundary)
if i == 0:
# Periodicity is applied automatically
bc = None
fe.solve(
fe.lhs(weak_form) == fe.rhs(weak_form), self.cell_solutions[i],
bc)
if plot:
plt.rc('text', usetex=True)
f = fe.plot(self.cell_solutions[i])
plt.colorbar(f)
plt.title(r'Solution to cell problem $w_%d$' % (i + 1))
plt.xlabel(r'$Y_1$')
plt.ylabel(r'$Y_2$')
print("Cell solution")
print(np.min(self.cell_solutions[i].vector().get_local()),
np.max(self.cell_solutions[i].vector().get_local()))
plt.show()
