def get_cell_function(mesh: df.Mesh) -> df.MeshFunction:
"""Return a cell function intended for multi cell model."""
mesh_function = df.MeshFunction("size_t", mesh, mesh.geometry().dim())
mesh_function.set_all(1)
# df.CompiledSubDomain("x[0] < 0.05").mark(mesh_function, 12)
df.CompiledSubDomain("x[0] > 5.0").mark(mesh_function, 12)
return mesh_function
def read_fenics_solution(filepath):
from dolfin import (Mesh, XDMFFile, MeshValueCollection, cpp,
FunctionSpace, Function, HDF5File, MPI)
mesh = Mesh()
with XDMFFile("%s_triangle.xdmf" % filepath.split('.')[0]) as infile:
infile.read(mesh) # read the complete mesh
#mvc_subdo = MeshValueCollection("size_t", mesh, mesh.geometric_dimension() - 1)
#with XDMFFile("%s_triangle.xdmf" % filepath.split('.')[0]) as infile:
# infile.read(mvc_subdo, "subdomains") # read the diferent subdomians
#subdomains = cpp.mesh.MeshFunctionSizet(mesh, mvc_subdo)
#mvc = MeshValueCollection("size_t", mesh, mesh.geometric_dimension() - 2)
#with XDMFFile("%s_line.xdmf" % filepath.split('.')[0]) as infile:
# infile.read(mvc, "boundary_conditions") # read the boundary conditions
#boundary = cpp.mesh.MeshFunctionSizet(mesh, mvc)
# Define function space and basis functions
V = FunctionSpace(mesh, "CG", 1)
U = Function(V)
input_file = HDF5File(MPI.comm_world,
filepath.split('.')[0] + "_solution_field.h5", "r")
input_file.read(U, "solution")
input_file.close()
dofs = V.tabulate_dof_coordinates().reshape(
V.dim(),
mesh.geometry().dim()) # coordinates of nodes
U.set_allow_extrapolation(True)
return U, mesh, dofs.shape[0]
def mesh_around_1d(mesh, size=1, scale=10, padding=0.05):
'''
From a 1d in xd (X > 1) mesh (in XML format) produce a Xd mesh where
the 1d structure is embedded. Mesh size close to strucure should
be size(given as multiple of hmin(), elsewhere scale * size. Padding
controls size of the bounding box.
'''
dot = mesh.find('.')
root, ext = mesh[:dot], mesh[dot:]
assert ext == '.xml' or ext == '.xml.gz', ext
mesh = Mesh(mesh)
gdim = mesh.geometry().dim()
assert gdim > 1 and mesh.topology().dim() == 1
x = mesh.coordinates()
mesh.init(1, 0)
# Compute fall back mesh size:
assert size > 0
size = mesh.hmin() * size
# Don't allow zero padding - collision of lines with bdry segfaults
# too ofter so we prevent it
assert padding > 0
# Finally scale better be positive
assert scale > 0
point = (lambda xi: tuple(xi) + (0, ))\
if gdim == 2 else (lambda xi: tuple(xi))
geo = '.'.join([root, 'geo'])
with open(geo, 'w') as outfile:
# Setup
outfile.write('SetFactory("OpenCASCADE");\n')
outfile.write('size = %g;\n' % size)
outfile.write('SIZE = %g;\n' % (size * scale))
# Points
fmt = 'Point(%d) = {%.16f, %.16f, %.16f, size};\n'
for i, xi in enumerate(x, 1):
outfile.write(fmt % ((i, ) + point(xi)))
# Lines
fmt = 'Line(%d) = {%d, %d};\n'
for i, cell in enumerate(cells(mesh), 1):
outfile.write(fmt % ((i, ) + tuple(cell.entities(0) + 1)))
# BBox
xmin, xmax = x.min(0), x.max(0)
padding = (xmax - xmin) * padding / 2.
xmin -= padding
xmax += padding
dx = xmax - xmin
if gdim == 2 or dx[-1] < 1E-14: # All points are on a plane
rect = 'Rectangle(1) = {%g, %g, %g, %g, %g};\n' % (
xmin[0], xmin[1], 0 if gdim == 2 else xmin[2], dx[0], dx[1])
outfile.write(rect)
bbox = 'Surface'
else:
box = 'Box(1) = {%g, %g, %g, %g, %g, %g};\n' % (
xmin[0], xmin[1], xmin[2], dx[0], dx[1], dx[2])
outfile.write(box)
bbox = 'Volume'
# Crack
for line in xrange(1, mesh.num_cells() + 1):
outfile.write('Line{%d} In %s{1};\n' % (line, bbox))
# Add Physical volume/surface
outfile.write('Physical %s(1) = {1};\n' % bbox)
# Add Physical surface/line
lines = ', '.join(
map(lambda v: '%d' % v, xrange(1,
mesh.num_cells() + 1)))
outfile.write('Physical Line(1) = {%s};\n' % lines)
return geo, gdim
def run_simulation(
filepath,
topology_info: int = None,
top_bc: int = None,
bot_bc: int = None,
left_bc: int = None,
right_bc: int = None,
geometry: dict = None,
kappa=3, #only if geometry is None
show=True,
save_solution=False):
from dolfin import (Mesh, XDMFFile, MeshValueCollection, cpp,
FunctionSpace, TrialFunction, TestFunction,
DirichletBC, Constant, Measure, inner, nabla_grad,
Function, solve, plot, File)
mesh = Mesh()
with XDMFFile("%s_triangle.xdmf" % filepath.split('.')[0]) as infile:
infile.read(mesh) # read the complete mesh
mvc_subdo = MeshValueCollection("size_t", mesh,
mesh.geometric_dimension() - 1)
with XDMFFile("%s_triangle.xdmf" % filepath.split('.')[0]) as infile:
infile.read(mvc_subdo, "subdomains") # read the diferent subdomians
subdomains = cpp.mesh.MeshFunctionSizet(mesh, mvc_subdo)
mvc = MeshValueCollection("size_t", mesh, mesh.geometric_dimension() - 2)
with XDMFFile("%s_line.xdmf" % filepath.split('.')[0]) as infile:
infile.read(mvc, "boundary_conditions") #read the boundary conditions
boundary = cpp.mesh.MeshFunctionSizet(mesh, mvc)
# Define function space and basis functions
V = FunctionSpace(mesh, "CG", 1)
u = TrialFunction(V)
v = TestFunction(V)
# Boundary conditions
bcs = []
for bc_id in topology_info.keys():
if bc_id[-2:] == "bc":
if bot_bc is not None and bc_id[:3] == "bot":
bcs.append(
DirichletBC(V, Constant(bot_bc), boundary,
topology_info[bc_id]))
elif left_bc is not None and bc_id[:4] == "left":
bcs.append(
DirichletBC(V, Constant(left_bc), boundary,
topology_info[bc_id]))
elif top_bc is not None and bc_id[:3] == "top":
bcs.append(
DirichletBC(V, Constant(top_bc), boundary,
topology_info[bc_id]))
elif right_bc is not None and bc_id[:5] == "right":
bcs.append(
DirichletBC(V, Constant(right_bc), boundary,
topology_info[bc_id]))
else:
print(bc_id + " Not assigned as boundary condition ")
# raise NotImplementedError
# Define new measures associated with the interior domains and
# exterior boundaries
dx = Measure("dx", subdomain_data=subdomains)
ds = Measure("ds", subdomain_data=boundary)
f = Constant(0)
g = Constant(0)
if geometry is not None: # run multipatch implementation (Multiple domains)
a = []
L = []
for patch_id in geometry.keys():
kappa = geometry[patch_id].get("kappa")
a.append(
inner(Constant(kappa) * nabla_grad(u), nabla_grad(v)) *
dx(topology_info[patch_id]))
L.append(f * v * dx(topology_info[patch_id]))
a = sum(a)
L = sum(L)
else:
a = inner(Constant(kappa) * nabla_grad(u), nabla_grad(v)) * dx
L = f * v * dx
## Redefine u as a function in function space V for the solution
u = Function(V)
# Solve
solve(a == L, u, bcs)
u.rename('u', 'Temperature')
# Save solution to file in VTK format
print(' [+] Output to %s_solution.pvd' % filepath.split('.')[0])
vtkfile = File('%s_solution.pvd' % filepath.split('.')[0])
vtkfile << u
if show:
import matplotlib
matplotlib.use("Qt5Agg")
# Plot solution and gradient
plot(u, title="Temperature")
plt.gca().view_init(azim=-90, elev=90)
plt.show()
dofs = V.tabulate_dof_coordinates().reshape(
V.dim(),
mesh.geometry().dim()) #coordinates of nodes
vals = u.vector().get_local() #temperature at nodes
if save_solution:
from dolfin import HDF5File, MPI
output_file = HDF5File(MPI.comm_world,
filepath.split('.')[0] + "_solution_field.h5",
"w")
output_file.write(u, "solution")
output_file.close()
u.set_allow_extrapolation(True)
return dofs, vals, mesh, u
