def build_mesh(self):
self.length = 100
self.height = 100
plate = mshr.Rectangle(fe.Point(0, 0),
fe.Point(self.length, self.height))
notch = mshr.Polygon([
fe.Point(0, self.height / 2 + 1),
fe.Point(0, self.height / 2 - 1),
fe.Point(6, self.height / 2)
])
notch = mshr.Polygon([
fe.Point(0, self.height / 2 + 1e-10),
fe.Point(0, self.height / 2 - 1e-10),
fe.Point(self.length / 2, self.height / 2)
])
# notch = mshr.Polygon([fe.Point(self.length / 4, self.height / 2), fe.Point(self.length / 2, self.height / 2 - 1e-10), \
# fe.Point(self.length * 3 / 4, self.height / 2), fe.Point(self.length / 2, self.height / 2 + 1e-10)])
self.mesh = mshr.generate_mesh(plate - notch, 50)
# self.mesh = da.RectangleMesh(fe.Point(0, 0), fe.Point(self.length, self.height), 40, 40, diagonal="crossed")
length = self.length
height = self.height
class Lower(fe.SubDomain):
def inside(self, x, on_boundary):
return on_boundary and fe.near(x[1], 0)
class Upper(fe.SubDomain):
def inside(self, x, on_boundary):
return on_boundary and fe.near(x[1], height)
class Corner(fe.SubDomain):
def inside(self, x, on_boundary):
return fe.near(x[0], 0) and fe.near(x[1], 0)
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 Notch(fe.SubDomain):
def inside(self, x, on_boundary):
return fe.near(x[1], height / 2) and x[0] < length / 20
self.lower = Lower()
self.upper = Upper()
self.corner = Corner()
self.left = Left()
self.right = Right()
self.notch = Notch()
def mesh_Triangle(n=10):
dom = mshr.Polygon(
[Point(0., -1.),
Point(sqrt(3) / 2, 1. / 2),
Point(-sqrt(3) / 2, 1. / 2)])
mesh = mshr.generate_mesh(dom, n, "cgal")
return mesh
def create_coronal_section_mesh(self, model_z_n=0):
brain_slice = self.image_manipulation_obj.\
get_brain_slice_from_model_z_n(model_z_n)
x_size = 65
self.boundary_points = brain_slice.\
generate_boundary_points_ccw(x_size)
domain_vertices = []
for x, y in zip(self.boundary_points[0], self.boundary_points[1]):
domain_vertices.append(fe.Point(x, y))
self.geometry = mesher.Polygon(domain_vertices)
self.mesh = mesher.generate_mesh(self.geometry, 16)
self.compute_mesh_volume()
self.original_volume = self.mesh_volume
print('Original volume', self.original_volume)
self.generate_holes()
#self.compute_hole_fractional_volume()
self.puncture_mesh()
self.compute_mesh_volume()
domain_volume = self.mesh_volume
print('New volume', domain_volume)
self.hole_fractional_volume = 1 - domain_volume / self.original_volume
print('Hole fractional volume:', self.hole_fractional_volume)
print('# holes:', self.n_holes)
print('Estimated hole fractional volume:',\
self.compute_hole_fractional_volume())
def build_mesh(self):
self.length = 100
self.height = 100
plate = mshr.Rectangle(fe.Point(0, 0),
fe.Point(self.length, self.height))
notch = mshr.Polygon([
fe.Point(0, self.height / 2 + 1),
fe.Point(0, self.height / 2 - 1),
fe.Point(6, self.height / 2)
])
self.mesh = mshr.generate_mesh(plate - notch, 30)
length = self.length
height = self.height
class Lower(fe.SubDomain):
def inside(self, x, on_boundary):
return on_boundary and fe.near(x[1], 0)
class Upper(fe.SubDomain):
def inside(self, x, on_boundary):
return on_boundary and fe.near(x[1], height)
class Corner(fe.SubDomain):
def inside(self, x, on_boundary):
return fe.near(x[0], 0) and fe.near(x[1], 0)
self.lower = Lower()
self.upper = Upper()
self.corner = Corner()
def build_mesh(self):
self.length = 8.
self.height = 2.
self.notch_length = 0.2
self.notch_height = 0.4
domain = mshr.Polygon([fe.Point(0., 0.),
fe.Point(self.length/2. - self.notch_length/2., 0.),
fe.Point(self.length/2., self.notch_height),
fe.Point(self.length/2. + self.notch_length/2., 0.),
fe.Point(self.length, 0.),
fe.Point(self.length, self.height),
fe.Point(self.length/2. + self.notch_length/2., self.height),
fe.Point(self.length/2., self.height),
fe.Point(self.length/2. - self.notch_length/2., self.height),
fe.Point(0., self.height)])
# resolution = 100 if self.local_refinement_iteration == 0 else 200
# self.mesh = mshr.generate_mesh(domain, resolution)
self.mesh = mshr.generate_mesh(domain, 100)
for i in range(self.local_refinement_iteration):
cell_markers = fe.MeshFunction('bool', self.mesh, self.mesh.topology().dim())
cell_markers.set_all(False)
for cell in fe.cells(self.mesh):
p = cell.midpoint()
if p[0] > 14./32.*self.length and p[0] < 18./32.*self.length and p[1] < self.height - self.notch_height:
cell_markers[cell] = True
self.mesh = fe.refine(self.mesh, cell_markers)
length = self.length
height = self.height
notch_length = self.notch_length
class Upper(fe.SubDomain):
def inside(self, x, on_boundary):
# return on_boundary
return on_boundary and fe.near(x[1], height)
class LeftCorner(fe.SubDomain):
def inside(self, x, on_boundary):
return fe.near(x[0], 0.) and fe.near(x[1], 0.)
class RightCorner(fe.SubDomain):
def inside(self, x, on_boundary):
return fe.near(x[0], length) and fe.near(x[1], 0.)
class MiddlePoint(fe.SubDomain):
def inside(self, x, on_boundary):
# return fe.near(x[0], length/2.) and fe.near(x[1], height)
return x[0] > length/2. - notch_length/2. and x[0] < length/2. + notch_length/2. and fe.near(x[1], height)
self.upper = Upper()
self.left = LeftCorner()
self.right = RightCorner()
self.middle = MiddlePoint()
def generate_blade_domain():
path = os.path.abspath(os.path.dirname(__file__))
data = io.loadmat(os.path.join(path, 'data', 'blade_geometry.mat'))
bedge = data['bedge']
xy = data['xy']
points, bndry = [], []
for ii in range(bedge.shape[1]):
kn1 = bedge[0, ii] - 1
kn2 = bedge[1, ii] - 1
points.append(xy[:, kn1])
points.append(xy[:, kn2])
bndry.append(bedge[2, ii])
bndry.append(bedge[2, ii])
points = np.asarray(points).T
bndry = np.asarray(bndry)
coords = points[:, bndry == 0]
sorted_coords, center = sort_points_in_anti_clockwise_order(coords)
vertices = numpy_to_dolfin_points(sorted_coords)
airfoil_domain = mshr.Polygon(vertices)
cooling_domains = []
domain = airfoil_domain
for ii in range(1, 3):
coords = points[:, bndry == ii]
sorted_coords, center = sort_points_in_anti_clockwise_order(coords)
vertices = numpy_to_dolfin_points(sorted_coords)
cooling_domains.append(mshr.Polygon(vertices))
domain -= cooling_domains[-1]
# last cooling domain requires special treatment
coords = points[:, bndry == 3]
coords = coords[:, (coords[0] >= 0.45) & (coords[0] <= 0.7)]
sorted_coords, center = sort_points_in_anti_clockwise_order(coords)
vertices = numpy_to_dolfin_points(sorted_coords)
cooling_domains.append(mshr.Polygon(vertices))
domain -= cooling_domains[-1]
coords = points[:, bndry == 3]
coords = coords[:, (np.absolute(coords[1]) <= 0.01) & (coords[0] >= 0.7)]
sorted_coords, center = sort_points_in_anti_clockwise_order(coords)
vertices = numpy_to_dolfin_points(sorted_coords)
cooling_domains.append(mshr.Polygon(vertices))
domain -= cooling_domains[-1]
return domain
def create_coronal_section_mesh(self, model_z_n = 0):
brain_slice = self.image_manipulation_obj.\
get_brain_slice_from_model_z_n(model_z_n)
x_size = 65
self.boundary_points = brain_slice.\
generate_boundary_points_ccw(x_size)
domain_vertices = []
for x,y in zip(self.boundary_points[0], self.boundary_points[1]):
domain_vertices.append(fe.Point(x,y))
geo = mesher.Polygon(domain_vertices)
self.mesh = mesher.generate_mesh(geo, self.mesh_density);
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 create_coronal_section_mesh(self, experimental_z_n=0):
brain_slice = self.image_manipulation_obj.\
get_brain_slice_from_experimental_z_n(experimental_z_n)
#get_brain_slice_from_experimental_z_mm(0)
x_size = 65
points = brain_slice.\
generate_boundary_points_ccw(x_size)
domain_vertices = []
for x, y in zip(points[0], points[1]):
domain_vertices.append(fe.Point(x, y))
geo = mesher.Polygon(domain_vertices)
self.mesh = mesher.generate_mesh(geo, 64)
def create_toy_mesh():
box = mshr.Box(dolfin.Point(-3, -1, -0.5), dolfin.Point(3, 1, 0.5))
c1 = mshr.Cylinder(dolfin.Point(0, 0, -2), dolfin.Point(0, 0, 2), 0.6, 0.6)
b1 = mshr.Box(dolfin.Point(-2.5, -0.5, -2), dolfin.Point(-1.5, 0.5, 2))
# "triangle"
t1 = mshr.Polygon([
dolfin.Point(2.5, -0.5, 0),
dolfin.Point(2.5, 0.5, 0),
dolfin.Point(1.5, -0.5, 0),
])
g3d = mshr.Extrude2D(t1, -2)
g3d = mshr.CSGTranslation(g3d, dolfin.Point(0, 0, 1))
m = mshr.generate_mesh(box - c1 - b1 - g3d, 40, "cgal")
return m.coordinates(), m.cells()
def build_mesh(self):
self.length = 1.
self.height = 1.
plate = mshr.Rectangle(fe.Point(0, 0),
fe.Point(self.length, self.height))
notch = mshr.Polygon([
fe.Point(0, self.height / 2 + 1e-10),
fe.Point(0, self.height / 2 - 1e-10),
fe.Point(self.length / 2, self.height / 2)
])
resolution = 50 * np.power(2, self.local_refinement_iteration)
self.mesh = mshr.generate_mesh(plate - notch, resolution)
length = self.length
height = self.height
class Lower(fe.SubDomain):
def inside(self, x, on_boundary):
return on_boundary and fe.near(x[1], 0)
class Upper(fe.SubDomain):
def inside(self, x, on_boundary):
return on_boundary and fe.near(x[1], height)
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.lower = Lower()
self.upper = Upper()
self.corner = Corner()
self.left = Left()
self.right = Right()
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 __init__(self, mesh_resolution, polynomial_degree, adjust, L1, L2, h1,
h2, b):
self.L1 = L1
self.L2 = L2
self.h1 = h1
self.h2 = h2
self.b = b
p1 = Point(0., 0.)
p2 = Point(L1, h1)
p3 = Point(L1 + b, h1)
p4 = Point(L1, 0.)
domain1 = mshr.Rectangle(p1, p2) + mshr.Polygon([p4, p3, p2])
p5 = Point(L1, -(h2 - h1))
p6 = Point(L1 + L2, h1)
domain2 = mshr.Rectangle(p5, p6)
domain = domain1 + domain2
self.insides = LShapedOverlap(self.L1, self.h1, self.b)
self.outsides = OnBoundary()
self.left_dirichlet = LShapedLeftDirichlet(self.h1)
self.left_robin = LShapedLeftRobin(self.L1, self.h1, self.b)
self.right_dirichlet = LShapedRightDirichlet(self.L1, self.L2, self.h1,
self.h2)
self.right_robin = LShapedRightRobin(self.L1, self.h1, self.b)
boundaries = list([
self.insides, self.outsides, self.left_dirichlet, self.left_robin,
self.right_dirichlet, self.right_robin
])
Membrane.__init__(self, domain, domain1, domain2, mesh_resolution,
boundaries, polynomial_degree, adjust)
def method(L=6., H=2., R=0.3, n_segments=40, res=120, **kwargs):
"""
Generates barbell capilar with rounded edges.
"""
info("Generating mesh of rounded barbell capilar")
pt_1 = df.Point(0., 0.)
pt_1star = df.Point(1., 0.)
pt_1starstar = df.Point(L/(2*res), 0.)
pt_2 = df.Point(L, H)
pt_2star = df.Point(L-1., H)
pt_2starstar = df.Point(L-L/(2*res), H)
pt_3 = df.Point(1., H)
pt_3star = df.Point(0, H)
pt_3starstar = df.Point(L/(2*res), H)
pt_4 = df.Point(L-1., 0)
pt_4star = df.Point(L, 0)
pt_4starstar = df.Point(L-L/(2*res), 0)
pt_5 = df.Point(1., R)
pt_6 = df.Point(1., H-R)
pt_7 = df.Point(L-1., R)
pt_8 = df.Point(L-1., H-R)
pt_9 = df.Point(1.+2*R, R)
pt_10 = df.Point(1.+2*R, H-R)
pt_11 = df.Point(L-2*R-1, R)
pt_12 = df.Point(L-2*R-1, H-R)
pt_13 = df.Point(1.+2*R, H-2*R)
pt_14 = df.Point(L-2*R-1, 2*R)
inlet_polygon = [pt_1]
inlet_polygon.append(pt_1starstar)
add_vertical_boundary_vertices(inlet_polygon, L/res, H, res, 1)
inlet_polygon.append(pt_3starstar)
inlet_polygon.append(pt_3star)
add_vertical_boundary_vertices(inlet_polygon, 0.0, H, res, -1)
inlet_polygon.append(pt_1)
outlet_polygon = [pt_4starstar]
outlet_polygon.append(pt_4star)
add_vertical_boundary_vertices(outlet_polygon, L, H, res, 1)
outlet_polygon.append(pt_2)
outlet_polygon.append(pt_2starstar)
add_vertical_boundary_vertices(outlet_polygon, L-L/res, H, res, -1)
outlet_polygon.append(pt_4starstar)
inlet1 = mshr.Polygon(inlet_polygon)
inlet2 = mshr.Rectangle(pt_1starstar, pt_3)
outlet1 = mshr.Polygon(outlet_polygon)
outlet2 = mshr.Rectangle(pt_4, pt_2starstar)
channel = mshr.Rectangle(pt_5, pt_8)
pos_cir_1 = mshr.Circle(pt_5, R, segments=n_segments)
pos_cir_2 = mshr.Circle(pt_6, R, segments=n_segments)
pos_cir_3 = mshr.Circle(pt_7, R, segments=n_segments)
pos_cir_4 = mshr.Circle(pt_8, R, segments=n_segments)
neg_cir_1 = mshr.Circle(pt_9, R, segments=n_segments)
neg_cir_2 = mshr.Circle(pt_10, R, segments=n_segments)
neg_cir_3 = mshr.Circle(pt_11, R, segments=n_segments)
neg_cir_4 = mshr.Circle(pt_12, R, segments=n_segments)
neg_reg_1 = mshr.Rectangle(pt_13, pt_12)
neg_reg_2 = mshr.Rectangle(pt_9, pt_14)
domain = inlet1 + inlet2 + outlet1 + outlet2 + \
channel + pos_cir_1 + pos_cir_2 + pos_cir_3 + \
pos_cir_4 - neg_cir_1 - neg_cir_2 - neg_cir_3 - \
neg_cir_4 - neg_reg_1 - neg_reg_2
mesh = mshr.generate_mesh(domain, res)
mesh_path = os.path.join(MESHES_DIR,
"roundet_barbell_res" + str(res))
store_mesh_HDF5(mesh, mesh_path)
df.plot(mesh)
df.interactive()
def method(L=6., H=2., R=0.3, n_segments=40, res=180, show=False, **kwargs):
"""
Generates hourglass.
"""
info("Generating mesh of an hourglass")
pt_1 = df.Point(0., 0.)
pt_1star = df.Point(2., 0.)
pt_1starstar = df.Point(L/(2*res), 0.)
pt_2 = df.Point(L, H)
pt_2star = df.Point(L-2., H)
pt_2starstar = df.Point(L-L/(2*res), H)
pt_3 = df.Point(2., H)
pt_3star = df.Point(0, H)
pt_3starstar = df.Point(L/(2*res), H)
pt_4 = df.Point(L-2., 0)
pt_4star = df.Point(L, 0)
pt_4starstar = df.Point(L-L/(2*res), 0)
pt_5 = df.Point(2., R)
pt_6 = df.Point(2., H-R)
pt_7 = df.Point(L-2., R)
pt_8 = df.Point(L-2., H-R)
pt_9 = df.Point(2.+2*R, R)
pt_10 = df.Point(2.+2*R, H-R)
pt_11 = df.Point(L-2*R-2, R)
pt_12 = df.Point(L-2*R-2, H-R)
pt_13 = df.Point(2.+2*R, H-2*R)
pt_14 = df.Point(L-2*R-2, 2*R)
inlet_polygon = [pt_1]
inlet_polygon.append(pt_1starstar)
add_vertical_boundary_vertices(inlet_polygon, L/res, H, res, 1)
inlet_polygon.append(pt_3starstar)
inlet_polygon.append(pt_3star)
add_vertical_boundary_vertices(inlet_polygon, 0.0, H, res, -1)
inlet_polygon.append(pt_1)
outlet_polygon = [pt_4starstar]
outlet_polygon.append(pt_4star)
add_vertical_boundary_vertices(outlet_polygon, L, H, res, 1)
outlet_polygon.append(pt_2)
outlet_polygon.append(pt_2starstar)
add_vertical_boundary_vertices(outlet_polygon, L-L/res, H, res, -1)
outlet_polygon.append(pt_4starstar)
inlet1 = mshr.Polygon(inlet_polygon)
inlet2 = mshr.Rectangle(pt_1starstar, pt_3)
outlet1 = mshr.Polygon(outlet_polygon)
outlet2 = mshr.Rectangle(pt_4, pt_2starstar)
channel = mshr.Rectangle(pt_5, pt_8)
pos_cir_1 = mshr.Circle(pt_5, R, segments=n_segments)
pos_cir_2 = mshr.Circle(pt_6, R, segments=n_segments)
pos_cir_3 = mshr.Circle(pt_7, R, segments=n_segments)
pos_cir_4 = mshr.Circle(pt_8, R, segments=n_segments)
neg_cir_1 = mshr.Circle(pt_9, R, segments=n_segments)
neg_cir_2 = mshr.Circle(pt_10, R, segments=n_segments)
neg_cir_3 = mshr.Circle(pt_11, R, segments=n_segments)
neg_cir_4 = mshr.Circle(pt_12, R, segments=n_segments)
neg_reg_1 = mshr.Rectangle(pt_13, pt_12)
neg_reg_2 = mshr.Rectangle(pt_9, pt_14)
domain = inlet1 + inlet2 + outlet1 + outlet2 + channel + \
pos_cir_1 + pos_cir_2 + pos_cir_3 + pos_cir_4 - neg_cir_1 - \
neg_cir_2 - neg_cir_3 - neg_cir_4 - neg_reg_1 - neg_reg_2
mesh = mshr.generate_mesh(domain, res)
mesh_path = os.path.join(MESHES_DIR,
"hourglass_res" + str(res))
store_mesh_HDF5(mesh, mesh_path)
if show:
df.plot(mesh)
plt.show()
def generate_tower_mesh(quality=20):
otri = mshr.Polygon([Point(0, 0), Point(1, 0), Point(0.5, 1)])
itri = mshr.Polygon([Point(0.2, 0.0), Point(0.8, 0.0), Point(0.5, 0.75)])
domain = otri - itri
return mshr.generate_mesh(domain, quality)
#Geometric Dimensions
t_sleeve = 0.188
t_wall = t_sleeve
t_gap = 0.02
L_sleeve = 10.0 * t_wall
L_wall = 1.5 * L_sleeve
#Build Geometry
domain_vertices = [
Point(0, 0),
Point(L_wall, 0),
Point(L_wall, t_wall),
Point(0, t_wall)
]
domain = mshr.Polygon(domain_vertices)
domain_vertices = [
Point(L_wall - L_sleeve, t_wall),
Point(L_wall - L_sleeve, t_wall + t_gap),
Point(L_wall, t_wall + t_gap),
Point(L_wall, t_wall + t_gap + t_sleeve),
Point(L_wall - L_sleeve, t_wall + t_gap + t_sleeve),
Point(L_wall - L_sleeve - t_gap - t_sleeve, t_wall)
]
domain = domain + mshr.Polygon(domain_vertices)
# Build Mesh, mesh resolution=higher numbers give more elements
mesh_resolution = 60
mesh = mshr.generate_mesh(domain, mesh_resolution)
#Build Function Space (FEM Space)
def build_pore_polygon(base_pore_points, offset):
points = [
fa.Point(p[0] + offset[0], p[1] + offset[1]) for p in base_pore_points
]
pore = mshr.Polygon(points)
return pore
width, height, tol = self.width, self.height, self.tol
class PointLoad(SubDomain):
""" Add a point load to the top center. """
def inside(self, x, on_boundary):
return near(x[0], width, tol) and near(x[1], height / 3., tol)
return [PointLoad()], [Constant((0.0, -3e-1))]
if __name__ == "__main__":
bc = LBracketBoundaryConditions(1, 1, 5e-2)
# Create the mesh to solve linear elasticity on.
large_quad = mshr.Polygon(
[Point(0, 0), Point(1, 0),
Point(1, 1), Point(0, 1)])
small_quad = mshr.Polygon([
Point(1 / 3., 1 / 3.),
Point(1, 1 / 3.),
Point(1, 1),
Point(1 / 3., 1)
])
domain = large_quad - small_quad
mesh = mshr.generate_mesh(domain, 30)
run_simulation(mesh, bc, "L-bracket/v100-")
mesh = Mesh("meshes/L-bracket-v20.xml")
scale_mesh(mesh, 1, 1)
run_simulation(mesh, bc, "L-bracket/v20-")
