def verify_michalek2003_natural_convection_water(w, mesh):
"""Verify directly against steady-state data from michalek2003 published in
@article{michalek2003simulations,
title={Simulations of the water freezing process--numerical benchmarks},
author={MICHA{\L}EK, TOMASZ and KOWALEWSKI, TOMASZ A},
journal={Task Quarterly},
volume={7},
number={3},
pages={389--408},
year={2003}
}
"""
verified_solution = {
'y': 0.5,
'x': [0.00, 0.05, 0.12, 0.23, 0.40, 0.59, 0.80, 0.88, 1.00],
'theta': [1.00, 0.66, 0.56, 0.58, 0.59, 0.62, 0.20, 0.22, 0.00]
}
bbt = mesh.bounding_box_tree()
for i, true_theta in enumerate(verified_solution['theta']):
p = fenics.Point(
fenics.Point(verified_solution['x'][i], verified_solution['y']))
if bbt.collides_entity(p):
wval = w(p)
theta = wval[3]
assert (abs(theta - true_theta) < 2.e-2)
def problem(f, nx=8, ny=8, degrees=[1, 2]):
"""
Plot u along x=const or y=const for Lagrange elements,
of given degrees, on a nx times ny mesh. f is a SymPy expression.
"""
f = sym.printing.ccode(f)
f = fe.Expression(f, degree=2)
mesh = fe.RectangleMesh(fe.Point(-1, 0), fe.Point(1, 2), 2, 2)
for degree in degrees:
if degree == 0:
# The P0 element is specified like this in FEniCS
V = fe.FunctionSpace(mesh, 'DG', 0)
else:
# The Lagrange Pd family of elements, d=1,2,3,...
V = fe.FunctionSpace(mesh, 'P', degree)
u = fe.project(f, V)
u_error = fe.errornorm(f, u, 'L2')
print('||u-f||=%g' % u_error, degree)
comparison_plot2D(u,
f,
n=50,
value=0.4,
variation='x',
plottitle='Approximation by P%d elements' % degree,
filename='approx_fenics_by_P%d' % degree,
tol=1E-3)
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_cocontinuous_mesh(self):
if self.use_previously_stored_mesh:
self.mesh = fe.Mesh(self.mesh_fname)
print('Mesh has been loaded from file')
return
p = self.L * np.ones(3)
geo = mesher.Box(fe.Point(0,0,0), fe.Point(p))
net = self.extrude_base_net()
columns = self.create_cylindrical_columns()
net += columns
if self.keep_only_network:
geo = net
else:
geo -= net
print('Finished creating the geometry')
self.mesh = mesher.generate_mesh(geo, self.mesh_density);
print('Writing mesh to file')
mesh_file = fe.File(self.mesh_fname)
mesh_file << self.mesh
print('Finished writing mesh to file')
def verify(self):
""" Test regression based on a previous solution from Phaseflow.
In Paraview, the $T = 0.01$ (i.e. the regularization_central_temperature) contour was drawn
at time $t = 30.$ (i.e. the end_time).
A point from this contour in the upper portion of the domain,
where the PCI has advanced more quickly, was recorded to be (0.278, 0.875).
This was checked for commit a8a8a039e5b89d71b6cceaef519dfbf136322639.
Here we verify that the temperature is above the melting temperature left of the expected PCI,
which is advancing to the right, and is below the melting temperature right of the expected PCI.
"""
pci_y_position_to_check = 0.88
reference_pci_x_position = 0.28
position_offset = 0.01
left_temperature = self.state.solution.leaf_node()(
fenics.Point(reference_pci_x_position - position_offset, pci_y_position_to_check))[3]
right_temperature = self.state.solution.leaf_node()(
fenics.Point(reference_pci_x_position + position_offset, pci_y_position_to_check))[3]
assert((left_temperature > self.regularization_central_temperature)
and (self.regularization_central_temperature > right_temperature))
def square(self, length, origin=None):
if origin is None:
x, y = 0, 0
else:
x, y = origin[0], origin[1]
return mshr.Rectangle(FEN.Point(0 + x, 0 + y),
FEN.Point(length + x, length + y))
def build_mesh(self):
self.length = 1.
self.height = 1.
self.mesh = fe.Mesh()
editor = fe.MeshEditor()
editor.open(self.mesh, 'triangle', 2, 2)
editor.init_vertices(10)
editor.init_cells(8)
editor.add_vertex(0, fe.Point(0.5, 0.5))
editor.add_vertex(1, fe.Point(1., 0.5))
editor.add_vertex(2, fe.Point(1., 1.))
editor.add_vertex(3, fe.Point(0.5, 1.))
editor.add_vertex(4, fe.Point(0., 1.))
editor.add_vertex(5, fe.Point(0., 0.5))
editor.add_vertex(6, fe.Point(0., 0.))
editor.add_vertex(7, fe.Point(0.5, 0.))
editor.add_vertex(8, fe.Point(1., 0.))
editor.add_vertex(9, fe.Point(0., 0.5))
editor.add_cell(0, [0, 1, 3])
editor.add_cell(1, [1, 2, 3])
editor.add_cell(2, [0, 3, 4])
editor.add_cell(3, [0, 4, 5])
editor.add_cell(4, [0, 9, 7])
editor.add_cell(5, [6, 7, 9])
editor.add_cell(6, [0, 7, 8])
editor.add_cell(7, [0, 8, 1])
editor.close()
base_refinement = 4
self.total_refinement = base_refinement + self.local_refinement_iteration
for i in range(self.total_refinement):
self.mesh = fe.refine(self.mesh)
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):
args = self.args
self.width = 0.5
# mesh = fa.Mesh(args.root_path + '/' + args.solutions_path + '/saved_mesh/mesh_robot.xml')
mesh = fa.RectangleMesh(fa.Point(0, 0), fa.Point(
self.width, 10), 2, 20, 'crossed')
self.mesh = mesh
def calc_system_variables(*, coords, advect_params, flags, pert_params):
dx = (coords.we[1] - coords.we[0]) * 1000
dy = (coords.sn[1] - coords.sn[0]) * 1000 # dx, dy in m not km
max_horizon = pd.Timedelta(advect_params['max_horizon'])
ci_crop_shape = np.array([coords.sn_crop.size, coords.we_crop.size],
dtype='int')
U_crop_shape = np.array([coords.sn_crop.size, coords.we_stag_crop.size],
dtype='int')
V_crop_shape = np.array([coords.sn_stag_crop.size, coords.we_crop.size],
dtype='int')
U_crop_size = U_crop_shape[0] * U_crop_shape[1]
V_crop_size = V_crop_shape[0] * V_crop_shape[1]
wind_size = U_crop_size + V_crop_size
num_of_horizons = int((max_horizon / 15).seconds / 60)
sys_vars = {
'dx': dx,
'dy': dy,
'num_of_horizons': num_of_horizons,
'max_horizon': max_horizon,
'ci_crop_shape': ci_crop_shape,
'U_crop_shape': U_crop_shape,
'V_crop_shape': V_crop_shape,
'U_crop_size': U_crop_size,
'V_crop_size': V_crop_size,
'wind_size': wind_size
}
if flags['div']:
mesh = fe.RectangleMesh(
fe.Point(0, 0),
fe.Point(int(V_crop_shape[1] - 1), int(U_crop_shape[0] - 1)),
int(V_crop_shape[1] - 1), int(U_crop_shape[0] - 1))
FunctionSpace_wind = fe.FunctionSpace(mesh, 'P', 1)
sys_vars['FunctionSpace_wind'] = FunctionSpace_wind
if flags['perturbation']:
rf_eig, rf_vectors = eig_2d_covariance(x=coords.we_crop,
y=coords.sn_crop,
Lx=pert_params['Lx'],
Ly=pert_params['Ly'],
tol=pert_params['tol'])
rf_approx_var = (rf_vectors * rf_eig[None, :] *
rf_vectors).sum(-1).mean()
sys_vars['rf_eig'] = rf_eig
sys_vars['rf_vectors'] = rf_vectors
sys_vars['rf_approx_var'] = rf_approx_var
if flags['perturb_winds']:
rf_eig, rf_vectors = eig_2d_covariance(coords.we_crop,
coords.sn_crop,
Lx=pert_params['Lx_wind'],
Ly=pert_params['Ly_wind'],
tol=pert_params['tol_wind'])
rf_approx_var = (rf_vectors * rf_eig[None, :] *
rf_vectors).sum(-1).mean()
rf_eig = rf_eig * pert_params['Lx_wind']**2
sys_vars['rf_eig_wind'] = rf_eig
sys_vars['rf_vectors_wind'] = rf_vectors
sys_vars['rf_approx_var_wind'] = rf_approx_var
sys_vars = dict2nt(sys_vars, 'sys_vars')
return sys_vars
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 mfem():
files = glob.glob('data/pvd/mfem/*')
for f in files:
try:
os.remove(f)
except Exception as e:
print('Failed to delete {}, reason: {}' % (f, e))
plate = mshr.Rectangle(fe.Point(0, 0), fe.Point(100, 100))
mesh = mshr.generate_mesh(plate, 50)
# mesh = fe.RectangleMesh(fe.Point(-2, -2), fe.Point(2, 2), 50, 50)
x_hat = fe.SpatialCoordinate(mesh)
U = fe.VectorFunctionSpace(mesh, 'CG', 2)
V = fe.FunctionSpace(mesh, "CG", 1)
W = fe.FunctionSpace(mesh, "DG", 0)
# n = 21
# control_points = np.stack((np.linspace(0, 1, n), np.linspace(0, 1, n)), axis=1)
# impact_radii = np.linspace(0., 0.5, n)
rho_default = 25. / np.sqrt(5) * 2
control_points = np.array([[50., 50.], [62.5, 25.]])
impact_radii = np.array([rho_default, rho_default])
mid_point = np.array([75., 0.])
mid_point1 = np.array([100., 0.])
mid_point2 = np.array([50., 0.])
points = [mid_point, mid_point1, mid_point2]
direct_vec = np.array([1., -2])
rotated_vec = np.array([2., 1.])
direct_vec /= np.linalg.norm(direct_vec)
rotated_vec /= np.linalg.norm(rotated_vec)
directions = [direct_vec, rotated_vec]
boundary_info = [points, directions, rho_default]
# df, xi = distance_function_segments_ufl(x_hat, control_points, impact_radii)
# d = fe.project(df, V)
delta_x = map_function_ufl(x_hat, control_points, impact_radii,
boundary_info) - x_hat
u = fe.project(delta_x, U)
# e = fe.Function(U)
# int_exp = InterpolateExpression(u, control_points, impact_radii)
# e = fe.interpolate(int_exp, U)
# int_exp = InterpolateExpression(e, control_points, impact_radii)
# e = fe.project(int_exp, U)
vtkfile_u = fe.File('data/pvd/mfem/u.pvd')
u.rename("u", "u")
vtkfile_u << u
def make_mesh(num_cells: int) -> fenics.Mesh:
"""Generate mesh for FEM solver.
"""
mesh = fenics.RectangleMesh(fenics.Point(0, 0),
fenics.Point(2 * np.pi, np.pi), num_cells,
num_cells)
pbcs = lbe.periodic_boundary_conditions([0, 0], [2 * np.pi, np.pi],
[True, False])
return mesh, pbcs
def __init__(self, left, bottom, right, top, mesh_pts=0):
self.left = left
self.bottom = bottom
self.right = right
self.top = top
self.seg_coords = (left, bottom, right, top)
self.mesh_pts = mesh_pts
self.rect = Rect(fe.Point(left, bottom), fe.Point(right, top))
if self.mesh_pts > 0:
self.mesh = generate_mesh(self.rect, self.mesh_pts)
def solve_point_source(me, point, point_type='ind', atol=0.0, rtol=1e-10, maxiter=100, verbose=False):
me.b.zero()
if point_type == 'coords':
point_fenics = fenics.Point(point)
elif point_type == 'ind':
point_fenics = fenics.Point(me.dof_coords[point, :])
elif point_type == 'fenics':
point_fenics = point
else:
raise RuntimeError('invalid point_type')
ps = fenics.PointSource(me.V, point_fenics, 1.0)
ps.apply(me.b)
return me.solve(me.b, atol=atol, rtol=rtol, maxiter=maxiter, verbose=verbose)
def _create_e_domain(self):
box = Rect(fe.Point(0, 0), fe.Point(BOX_SIZE, BOX_SIZE))
left, bottom, right, top = self.active_seg_coords
# self.active_seg = Segment(0.3, 0.3, 0.7, 0.35)
self.active_seg = Segment(left, bottom, right, top, mesh_pts=0)
left, bottom, right, top = self.passive_seg_coords
# self.passive_seg = Segment(0.3, 0.5, 0.7, 0.55)
self.passive_seg = Segment(left, bottom, right, top)
self.domain = box - self.active_seg.rect - self.passive_seg.rect
return self.domain
def xest_second_tutorial(self):
T = 2.0 # final time
num_steps = 50 # number of time steps
dt = T / num_steps # time step size
# Create mesh and define function space
nx = ny = 30
mesh = fenics.RectangleMesh(fenics.Point(-2, -2), fenics.Point(2, 2),
nx, ny)
V = fenics.FunctionSpace(mesh, 'P', 1)
# Define boundary condition
def boundary(x, on_boundary):
return on_boundary
bc = fenics.DirichletBC(V, fenics.Constant(0), boundary)
# Define initial value
u_0 = fenics.Expression('exp(-a*pow(x[0], 2) - a*pow(x[1], 2))',
degree=2,
a=5)
u_n = fenics.interpolate(u_0, V)
# Define variational problem
u = fenics.TrialFunction(V)
v = fenics.TestFunction(V)
f = fenics.Constant(0)
F = u * v * fenics.dx + dt * fenics.dot(fenics.grad(u), fenics.grad(
v)) * fenics.dx - (u_n + dt * f) * v * fenics.dx
a, L = fenics.lhs(F), fenics.rhs(F)
# Create VTK file for saving solution
vtkfile = fenics.File(
os.path.join(os.path.dirname(__file__), 'output', 'heat_gaussian',
'solution.pvd'))
# Time-stepping
u = fenics.Function(V)
t = 0
not_initialised = True
for n in range(num_steps):
# Update current time
t += dt
# Compute solution
fenics.solve(a == L, u, bc)
# Save to file and plot solution
vtkfile << (u, t)
# Here we'll need to call tripcolor ourselves to get access to the color range
fenics.plot(u)
animation_camera.snap()
u_n.assign(u)
animation = animation_camera.animate()
animation.save(
os.path.join(os.path.dirname(__file__), 'output',
'heat_gaussian.mp4'))
def setup_coarse_mesh(self):
""" This creates the rectangular mesh, or rectangular prism in 3D. """
if len(self.mesh_size) == 2:
self.mesh = fenics.RectangleMesh(
fenics.mpi_comm_world(), fenics.Point(self.xmin, self.ymin),
fenics.Point(self.xmax, self.ymax), self.mesh_size[0],
self.mesh_size[1], "crossed")
elif len(self.mesh_size) == 3:
self.mesh = fenics.BoxMesh(
fenics.mpi_comm_world(),
fenics.Point(self.xmin, self.ymin, self.zmin),
fenics.Point(self.xmax, self.ymax, self.zmax),
self.mesh_size[0], self.mesh_size[1], self.mesh_size[2])
def get_mesh(length, nx, ny, nz=None):
"""获得 mesh
"""
if nz is None:
mesh = fs.RectangleMesh(fs.Point(0.0, 0.0), fs.Point(length, length),
nx, ny)
else:
mesh = fs.BoxMesh(
fs.Point(0.0, 0.0, 0.0),
fs.Point(length, length, length),
nx,
ny,
nz,
)
return mesh
def __init__(self, left, bottom, right, top):
self.left = left
self.bottom = bottom
self.right = right
self.top = top
self.seg_coords = (left, bottom, right, top)
self.rect = Rect(fe.Point(left, bottom), fe.Point(right, top))
def is_near(self, pt):
x, y = x
if (fe.near(y, self.bottom) or fe.near(y, self.top)) \
and (x > self.left and x < self.right):
return True
else:
return False
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 verify_against_ghia1982(w, mesh):
data = {
'Re':
100,
'x':
0.5,
'y': [
1.0000, 0.9766, 0.9688, 0.9609, 0.9531, 0.8516, 0.7344, 0.6172,
0.5000, 0.4531, 0.2813, 0.1719, 0.1016, 0.0703, 0.0625, 0.0547,
0.0000
],
'ux': [
1.0000, 0.8412, 0.7887, 0.7372, 0.6872, 0.2315, 0.0033, -0.1364,
-0.2058, -0.2109, -0.1566, -0.1015, -0.0643, -0.0478, -0.0419,
-0.0372, 0.0000
]
}
bbt = mesh.bounding_box_tree()
for i, true_ux in enumerate(data['ux']):
p = fenics.Point(data['x'], data['y'][i])
if bbt.collides_entity(p):
wval = w(p)
ux = wval[0]
assert (abs(ux - true_ux) < 2.e-2)
def eval(self, values, x_hat):
x = inverse_map_function_normal(
map_function_normal(x_hat, self.control_points, self.impact_radii),
self.control_points, self.impact_radii)
point = fe.Point(x)
# values[0] = self.e(point)
# delta_x_hat = x - x_hat
values = x - x_hat
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 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 __init__(self):
self.h = .4
# Cell properties
self.obs_length = 0.9
self.obs_height = 0.001
self.obs_ratio = self.obs_height / self.obs_length
if self.h < self.eta:
raise ValueError("Eta must be smaller than h")
self.ref_T = 0.1
self.eps = 2 * self.eta / MembraneSimulator.length
self.mesh = fe.RectangleMesh(
fe.Point(-1, 0),
fe.Point(1, 2 * self.h / MembraneSimulator.length), 50, 50)
self.cell_mesh = None
self.D = np.matrix(((4 * self.ref_T * MembraneSimulator.d1 /
MembraneSimulator.length**2, -0.05),
(+0.05, 4 * self.ref_T * MembraneSimulator.d2 /
MembraneSimulator.length**2)))
# Dirichlet boundary conditions
self.u_l = 6E-5
self.u_r = 0
self.u_boundary = fe.Expression(
'(u_l*(x[0] < - par) + u_r*(x[0] >= par))',
u_l=self.u_l,
u_r=self.u_r,
par=MembraneSimulator.w / MembraneSimulator.length,
degree=2)
self.u_0 = self.u_boundary / 2
# self.rhs = fe.Expression('(x[1]>par)*u',u=self.u_l*4,par=MembraneSimulator.eta/MembraneSimulator.length, degree=2)
self.rhs = fe.Constant(0)
self.time = 0
self.T = 1
self.dt = 0.01
self.tol = 1E-4
self.function_space = fe.FunctionSpace(self.mesh, 'P', 2)
self.solution = fe.Function(self.function_space)
self.cell_solutions = self.cell_fs = None
self.unit_vectors = [fe.Constant((1., 0.)), fe.Constant((0., 1.))]
self.eff_diff = np.zeros((2, 2))
self.file = fe.File('results/solution.pvd')
def __init__(self, d, h, ell=1., degree=1, nu=0.3, E=1.0):
self.d = d
self.ell = ell
self.degree = degree
mesh = fenics.RectangleMesh(fenics.Point(0., -0.5 * d),
fenics.Point(ell, 0.5 * d), int(ell / h),
int(d / h))
self.left = dolfin.CompiledSubDomain('on_boundary && x[0] <= atol',
atol=1e-5 * h)
self.right = dolfin.CompiledSubDomain(
'on_boundary && x[0] >= ell-atol', ell=ell, atol=1e-5 * h)
element = dolfin.VectorElement('P',
cell=mesh.ufl_cell(),
degree=degree,
dim=DIM)
self.V = dolfin.FunctionSpace(mesh, element)
self.lambda_ = dolfin.Constant(E * nu / (1. + nu) / (1. - 2. * nu))
self.mu = dolfin.Constant(E / 2. / (1. + nu))
def __call__(me, f_vec, points_pp):
me.f.vector()[:] = f_vec.copy()
if len(points_pp.shape) == 1:
N = 1
else: # len(points_pp.shape) == 2
N, _ = points_pp.shape
points_pp = points_pp.reshape((N, me.d))
inds_of_points_in_mesh = []
for k in range(N):
pk = fenics.Point(points_pp[k, :])
if me.bbt.compute_collisions(pk):
inds_of_points_in_mesh.append(k)
ff = np.zeros(N)
for k in inds_of_points_in_mesh:
pk = fenics.Point(points_pp[k, :])
ff[k] = me.f(pk)
return ff
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 getNoReflectionBC(self):
(AR0, QR0) = self.getBoundaryAQ("right")
c = self.getWavespeed(AR0)
(lamR0, tmp) = self.getEigenvalues(AR0, QR0)
xW1R = fe.Point(self.L - lamR0 * self.dt, 0, 0)
(AR, QR) = self.U0.split()
AR = AR(xW1R)
QR = QR(xW1R)
(W1R, tmp) = self.getCharacteristics(AR, QR)
(ARBC, QRBC) = self.getAQfromChar(W1R, self.W2_initial)
return (ARBC, QRBC)
