me,
ne,
vthe,
vd,
npc,
ext_bnd,
pdf=pdf,
pdf_max=1 + A)
# species.append_raw(e, mp, ne, vthi, vd, npc, ext_bnd)
pop = Population(mesh, bnd)
load_particles(pop, species)
V1 = df.FunctionSpace(mesh,
'CG',
1,
constrained_domain=PeriodicBoundary(
Ld, periodic))
dv_inv = voronoi_volume_approx(V1)
rho1 = distribute(V1, pop, dv_inv)
# rhoe = df.project(df.Expression('-0.5*sin(2*PI*x[0]/6.28)',degree=3,PI=np.pi),V1)
rhoe = df.Expression('-1.0-0.5*sin(2*PI*x[0]/6.28)',
degree=3,
PI=np.pi)
errors1.append(df.errornorm(rhoe, rho1))
V2 = df.FunctionSpace(mesh,
'DG',
0,
constrained_domain=PeriodicBoundary(
Ld, periodic))
def _discretize_fenics():
# assemble system matrices - FEniCS code
########################################
import dolfin as df
mesh = df.UnitSquareMesh(GRID_INTERVALS, GRID_INTERVALS, 'crossed')
V = df.FunctionSpace(mesh, 'Lagrange', FENICS_ORDER)
u = df.TrialFunction(V)
v = df.TestFunction(V)
diffusion = df.Expression(
'(lower0 <= x[0]) * (open0 ? (x[0] < upper0) : (x[0] <= upper0)) *'
'(lower1 <= x[1]) * (open1 ? (x[1] < upper1) : (x[1] <= upper1))',
lower0=0.,
upper0=0.,
open0=0,
lower1=0.,
upper1=0.,
open1=0,
element=df.FunctionSpace(mesh, 'DG', 0).ufl_element())
def assemble_matrix(x, y, nx, ny):
diffusion.user_parameters['lower0'] = x / nx
diffusion.user_parameters['lower1'] = y / ny
diffusion.user_parameters['upper0'] = (x + 1) / nx
diffusion.user_parameters['upper1'] = (y + 1) / ny
diffusion.user_parameters['open0'] = (x + 1 == nx)
diffusion.user_parameters['open1'] = (y + 1 == ny)
return df.assemble(
df.inner(diffusion * df.nabla_grad(u), df.nabla_grad(v)) * df.dx)
mats = [
assemble_matrix(x, y, XBLOCKS, YBLOCKS) for x in range(XBLOCKS)
for y in range(YBLOCKS)
]
mat0 = mats[0].copy()
mat0.zero()
h1_mat = df.assemble(df.inner(df.nabla_grad(u), df.nabla_grad(v)) * df.dx)
f = df.Constant(1.) * v * df.dx
F = df.assemble(f)
bc = df.DirichletBC(V, 0., df.DomainBoundary())
for m in mats:
bc.zero(m)
bc.apply(mat0)
bc.apply(h1_mat)
bc.apply(F)
# wrap everything as a pyMOR model
##################################
# FEniCS wrappers
from pymor.bindings.fenics import FenicsVectorSpace, FenicsMatrixOperator, FenicsVisualizer
# define parameter functionals (same as in pymor.analyticalproblems.thermalblock)
parameter_functionals = [
ProjectionParameterFunctional(component_name='diffusion',
component_shape=(YBLOCKS, XBLOCKS),
index=(YBLOCKS - y - 1, x))
for x in range(XBLOCKS) for y in range(YBLOCKS)
]
# wrap operators
ops = [FenicsMatrixOperator(mat0, V, V)
] + [FenicsMatrixOperator(m, V, V) for m in mats]
op = LincombOperator(ops, [1.] + parameter_functionals)
rhs = VectorOperator(FenicsVectorSpace(V).make_array([F]))
h1_product = FenicsMatrixOperator(h1_mat, V, V, name='h1_0_semi')
# build model
visualizer = FenicsVisualizer(FenicsVectorSpace(V))
parameter_space = CubicParameterSpace(op.parameter_type, 0.1, 1.)
fom = StationaryModel(op,
rhs,
products={'h1_0_semi': h1_product},
parameter_space=parameter_space,
visualizer=visualizer)
return fom
def __init__(self,
problem_params,
dtype_u=fenics_mesh,
dtype_f=fenics_mesh):
"""
Initialization routine
Args:
problem_params: custom parameters for the example
dtype_u: FEniCS mesh data type (will be passed to parent class)
dtype_f: FEniCS mesh data data type (will be passed to parent class)
"""
# define the Dirichlet boundary
def Boundary(x, on_boundary):
return on_boundary
# these parameters will be used later, so assert their existence
essential_keys = [
'c_nvars', 't0', 'family', 'order', 'refinements', 'Du', 'Dv', 'A',
'B'
]
for key in essential_keys:
if key not in problem_params:
msg = 'need %s to instantiate problem, only got %s' % (
key, str(problem_params.keys()))
raise ParameterError(msg)
# set logger level for FFC and dolfin
df.set_log_level(df.WARNING)
logging.getLogger('FFC').setLevel(logging.WARNING)
# set solver and form parameters
df.parameters["form_compiler"]["optimize"] = True
df.parameters["form_compiler"]["cpp_optimize"] = True
# set mesh and refinement (for multilevel)
mesh = df.IntervalMesh(problem_params['c_nvars'], 0, 100)
for i in range(problem_params['refinements']):
mesh = df.refine(mesh)
# define function space for future reference
V = df.FunctionSpace(mesh, problem_params['family'],
problem_params['order'])
self.V = V * V
# invoke super init, passing number of dofs, dtype_u and dtype_f
super(fenics_grayscott, self).__init__(self.V, dtype_u, dtype_f,
problem_params)
# rhs in weak form
self.w = df.Function(self.V)
q1, q2 = df.TestFunctions(self.V)
self.w1, self.w2 = df.split(self.w)
self.F1 = (-self.params.Du * df.inner(df.nabla_grad(self.w1),
df.nabla_grad(q1)) - self.w1 *
(self.w2**2) * q1 + self.params.A *
(1 - self.w1) * q1) * df.dx
self.F2 = (-self.params.Dv * df.inner(df.nabla_grad(self.w2),
df.nabla_grad(q2)) + self.w1 *
(self.w2**2) * q2 - self.params.B * self.w2 * q2) * df.dx
self.F = self.F1 + self.F2
# mass matrix
u1, u2 = df.TrialFunctions(self.V)
a_M = u1 * q1 * df.dx
M1 = df.assemble(a_M)
a_M = u2 * q2 * df.dx
M2 = df.assemble(a_M)
self.M = M1 + M2
def test_superposition(self):
radius = 0.125
mesh_resolution = 101
mesh = generate_mesh_with_cicular_subdomain(mesh_resolution, radius,
False)
degree = 1
P1 = dl.FiniteElement('Lagrange', mesh.ufl_cell(), degree)
element = dl.MixedElement([P1, P1])
function_space = dl.FunctionSpace(mesh, element)
frequency = 400 * 3
omega = 2. * np.pi * frequency
sound_speed = np.array([343.4, 6320, 60])
gamma = 8.4e-4
speaker_amplitude = .1
kappas = omega / sound_speed
cr1, cr2 = 0.5, 0.5 - radius / np.sqrt(8)
kappa = dl.Expression(
'((x[0]-c1)*(x[0]-c1)+(x[1]-c1)*(x[1]-c1) >= r*r + tol) ? k_0 : ((x[0]-c2)*(x[0]-c2)+(x[1]-c2)*(x[1]-c2)>=r*r/4+tol ? k_1 : k_2)',
degree=0,
tol=1e-14,
k_0=kappas[0],
k_1=kappas[1],
k_2=kappas[2],
r=radius,
c1=cr1,
c2=cr2)
forcing = [dl.Constant(0), dl.Constant(0)]
alpha = kappa * dl.Constant(gamma)
beta = dl.Constant(1.204 * omega * speaker_amplitude)
bndry_obj = get_2d_square_mesh_boundary_segments()
def get_boundary_conditions():
boundary_conditions = [[
'neumann', bndry_obj[ii], [dl.Constant(0), beta]
] for ii in [1, 4, 7, 10]]
boundary_conditions += [[
'robin', bndry_obj[ii], [dl.Constant(0),
dl.Constant(0)],
[dl.Constant(0), alpha]
] for ii in [0, 2, 3, 5, 6, 8, 9, 11]]
tmp = [None for ii in range(len(boundary_conditions))]
for ii, jj in enumerate([1, 4, 7, 10]):
tmp[jj] = boundary_conditions[ii]
for ii, jj in enumerate([0, 2, 3, 5, 6, 8, 9, 11]):
tmp[jj] = boundary_conditions[ii + 4]
boundary_conditions = tmp
return boundary_conditions
boundary_conditions = get_boundary_conditions()
sol = run_model(kappa, forcing, function_space, boundary_conditions)
sols = []
for jj in [1, 4, 7, 10]:
boundary_conditions = get_boundary_conditions()
for kk in range(12):
if jj != kk:
boundary_conditions[kk][2][1] = dl.Constant(0)
pii = run_model(kappa, forcing, function_space,
boundary_conditions)
sols.append(pii)
# for jj in [0,2,3,5,6,8,9,11]:
# boundary_conditions = get_boundary_conditions()
# for kk in range(12):
# if jj!=kk:
# boundary_conditions[kk][2][1]=dl.Constant(0)
# pii=run_model(kappa,forcing,function_space,boundary_conditions)
# sols.append(pii)
boundary_conditions = get_boundary_conditions()
for kk in range(12):
if kk not in [0, 2, 3, 5, 6, 8, 9, 11]:
boundary_conditions[kk][2][1] = dl.Constant(0)
pii = run_model(kappa, forcing, function_space, boundary_conditions)
sols.append(pii)
superposition_sol = sols[0]
for ii in range(1, len(sols)):
superposition_sol += sols[ii]
superposition_sol = dl.project(superposition_sol, function_space)
pr, pi = sol.split()
pr_super, pi_super = superposition_sol.split()
# print('error',dl.errornorm(pr_super,pr))
# print('error',dl.errornorm(pi_super,pi))
assert dl.errornorm(pr_super, pr) < 1e-10
assert dl.errornorm(pi_super, pi) < 1e-10
def __init__(
self,
time: df.Constant,
mesh: df.Mesh,
intracellular_conductivity: Dict[int, df.Expression],
extracellular_conductivity: Dict[int, df.Expression],
cell_function: df.MeshFunction,
cell_tags: CellTags,
interface_function: df.MeshFunction,
interface_tags: InterfaceTags,
parameters: CoupledBidomainParameters,
neumann_boundary_condition: Dict[int, df.Expression] = None,
v_prev: df.Function = None,
surface_to_volume_factor: Union[float, df.Constant] = None,
membrane_capacitance: Union[float, df.Constant] = None,
) -> None:
self._time = time
self._mesh = mesh
self._parameters = parameters
# Strip none from cell tags
cell_tags = set(cell_tags) - {None}
if surface_to_volume_factor is None:
surface_to_volume_factor = df.constant(1)
if membrane_capacitance is None:
membrane_capacitance = df.constant(1)
# Set Chi*Cm
self._chi_cm = df.Constant(surface_to_volume_factor)*df.Constant(membrane_capacitance)
if not set(intracellular_conductivity.keys()) == {*tuple(extracellular_conductivity.keys())}:
raise ValueError("intracellular conductivity and lambda does not havemnatching keys.")
if not set(cell_tags) == set(intracellular_conductivity.keys()):
raise ValueError("Cell tags does not match conductivity keys")
self._intracellular_conductivity = intracellular_conductivity
self._extracellular_conductivity = extracellular_conductivity
# Check cell tags
_cell_function_tags = set(cell_function.array())
if set(cell_tags)!= _cell_function_tags: # If not equal
msg = "Mismatching cell tags. Expected {}, got {}"
raise ValueError(msg.format(set(cell_tags), _cell_function_tags))
self._cell_tags = set(cell_tags)
self._cell_function = cell_function
restrict_tags = self._parameters.restrict_tags
if set(restrict_tags) >= self._cell_tags:
msg = "restrict tags ({})is not a subset of cell tags ({})"
raise ValueError(msg.format(set(restrict_tags), self._cell_tags))
self._restrict_tags = set(restrict_tags)
# Check interface tags
_interface_function_tags = {*set(interface_function.array()), None}
if not set(interface_tags) <= _interface_function_tags: # if not subset of
msg = "Mismatching interface tags. Expected {}, got {}"
raise ValueError(msg.format(set(interface_tags), _interface_function_tags))
self._interface_function = interface_function
self._interface_tags = interface_tags
# Set up function spaces
self._transmembrane_function_space = df.FunctionSpace(self._mesh, "CG", 1)
transmembrane_element = df.FiniteElement("CG", self._mesh.ufl_cell(), 1)
extracellular_element = df.FiniteElement("CG", self._mesh.ufl_cell(), 1)
if neumann_boundary_condition is None:
self._neumann_bc: Dict[int, df.Expression] = dict()
else:
self._neumann_bc = neumann_boundary_condition
if self._parameters.linear_solver_type == "direct":
lagrange_element = df.FiniteElement("R", self._mesh.ufl_cell(), 0)
mixed_element = df.MixedElement((transmembrane_element, extracellular_element, lagrange_element))
else:
mixed_element = df.MixedElement((transmembrane_element, extracellular_element))
self._VUR = df.FunctionSpace(mesh, mixed_element) # TODO: rename to something sensible
# Set-up solution fields:
if v_prev is None:
self._merger = df.FunctionAssigner(self._transmembrane_function_space, self._VUR.sub(0))
self._v_prev = df.Function(self._transmembrane_function_space, name="v_prev")
else:
self._merger = None
self._v_prev = v_prev
self._vur = df.Function(self._VUR, name="vur") # TODO: Give sensible name
# For normlising rhs_vector. TODO: Unsure about this. Check the nullspace from cbcbeat
self._extracellular_dofs = np.asarray(self._VUR.sub(1).dofmap().dofs())
# Mark first timestep
self._timestep: df.Constant = None
def setUp(self):
self.mesh = dolfin.UnitCube(3, 3, 3)
self.V = dolfin.FunctionSpace(self.mesh, "Nedelec 1st kind H(curl)", 2)
self.u = dolfin.interpolate(dolfin.Expression(('0', '0', '2*x[2]')),
self.V)
self.DUT = VoltageAlongLine(self.u)
def _inputsort(obj):
u = None
mesh = None
if not utils.isSequence(obj):
obj = [obj]
for ob in obj:
inputtype = str(type(ob))
#printc('inputtype is', inputtype, c=2)
if "vtk" in inputtype: # skip vtk objects, will be added later
continue
if "dolfin" in inputtype:
if "MeshFunction" in inputtype:
mesh = ob.mesh()
import dolfin
V = dolfin.FunctionSpace(mesh, "CG", 1)
u = dolfin.Function(V)
#print(mesh.cells())
#print(len(mesh.cells()), len(mesh.coordinates()), len(ob.array()))
#print(mesh.num_cells())
#print(u.vector()[:])
v2d = dolfin.vertex_to_dof_map(V)
u.vector()[v2d] = ob.array()
# r = ob.dim()
# if r == 0:
# V = dolfin.FunctionSpace(mesh, "CG", 1)
# elif r == 1:
# V = dolfin.VectorFunctionSpace(mesh, "CG", 1, dim=r)
# else:
# V = dolfin.TensorFunctionSpace(mesh, "CG", 1, shape=(r,r))
# except:
# printc('~times Sorry could not deal with your MeshFunction', c=1)
# return None
# tdim = mesh.topology().dim()
# d = ob.dim()
# if tdim == 2 and d == 2:
# import matplotlib.tri as tri
# xy = mesh.coordinates()
# mh = buildPolyData(xy, mesh.cells())
# show(mh)
# print( tri.Triangulation(xy[:, 0], xy[:, 1], mesh.cells()) )
# exit()
elif "Function" in inputtype or "Expression" in inputtype:
u = ob
elif "Mesh" in inputtype:
mesh = ob
if "str" in inputtype:
import dolfin
mesh = dolfin.Mesh(ob)
if u and not mesh and hasattr(u, "function_space"):
V = u.function_space()
if V:
mesh = V.mesh()
if u and not mesh and hasattr(u, "mesh"):
mesh = u.mesh()
if not mesh:
printc("~times Error: dolfin mesh is not defined.", c=1)
raise RuntimeError()
#printc('------------------------------------')
#printc('mesh.topology dim=', mesh.topology().dim())
#printc('mesh.geometry dim=', mesh.geometry().dim())
#if u: printc('u.value_rank()', u.value_rank())
return (mesh, u)
def test_material(unitcube_geometry, Material, active_model, isochoric):
compressible_model = "incompressible"
if active_model == "active_stress":
active_value = 20.0
activation = dolfin.Constant(1.0)
T_ref = active_value
def dirichlet_bc(W):
V = W if W.sub(0).num_sub_spaces() == 0 else W.sub(0)
return dolfin.DirichletBC(V, dolfin.Constant((0.0, 0.0, 0.0)),
fixed)
else:
activation = dolfin.Constant(0.0)
active_value = 0.0
T_ref = 1.0
def dirichlet_bc(W):
V = W if W.sub(0).num_sub_spaces() == 0 else W.sub(0)
return dolfin.DirichletBC(V.sub(0), dolfin.Constant(0.0), fixed,
'pointwise')
neumann_bc = NeumannBC(traction=dolfin.Constant(-active_value),
marker=free_marker)
bcs = BoundaryConditions(dirichlet=(dirichlet_bc, ),
neumann=(neumann_bc, ))
matparams = Material.default_parameters()
material = Material(activation=activation,
parameters=matparams,
T_ref=T_ref,
isochoric=isochoric,
compressible_model=compressible_model,
active_model=active_model)
assert material.is_isochoric == isochoric
problem = MechanicsProblem(unitcube_geometry, material, bcs)
problem.solve()
u, p = problem.state.split(deepcopy=True)
print(material.name)
if active_model == 'active_strain':
tol = 1e-4
if not isochoric:
if material.name in [
"guccione", "linear_elastic", "saint_venant_kirchhoff"
]:
assert all(abs(p.vector().get_local()) < tol)
elif material.name == "holzapfel_ogden":
assert all(
abs(p.vector().get_local() -
material.parameters["a"]) < tol)
elif material.name == "neo_hookean":
assert all(
abs(p.vector().get_local() -
material.parameters["mu"]) < tol)
else:
raise TypeError("Unkown material {}".format(material.name))
else:
assert all(abs(p.vector().get_local()) < tol)
else:
F = kinematics.DeformationGradient(u)
T = material.CauchyStress(F, p)
V_dg = dolfin.FunctionSpace(unitcube_geometry.mesh, "DG", 1)
# Fiber on current geometry
f = F * unitcube_geometry.f0
# Fiber stress
Tf = dolfin.inner(T * f / f**2, f)
Tf_dg = dolfin.project(Tf, V_dg)
tol = 1e-10
assert all(abs(Tf_dg.vector().get_local() - active_value) < tol)
assert all(abs(u.vector().get_local()) < tol)
if not isochoric:
if material.name in [
"guccione", "linear_elastic", "saint_venant_kirchhoff"
]:
assert all(abs(p.vector().get_local()) < tol)
elif material.name == "holzapfel_ogden":
assert all(
abs(p.vector().get_local() -
material.parameters["a"]) < tol)
elif material.name == "neo_hookean":
assert all(
abs(p.vector().get_local() -
material.parameters["mu"]) < tol)
else:
raise TypeError("Unkown material {}".format(material.name))
else:
assert all(abs(p.vector().get_local()) < tol)
def Rsolver(self):
return self.prior.Rsolver
def applyRaa(self, da, out):
self.Raa.mult(da, out)
if __name__ == "__main__":
dl.set_log_active(False)
sep = "\n" + "#" * 80 + "\n"
print sep, "Set up the mesh and finite element spaces", sep
ndim = 2
nx = 64
ny = 64
mesh = dl.UnitSquareMesh(nx, ny)
Vh2 = dl.FunctionSpace(mesh, 'Lagrange', 2)
Vh1 = dl.FunctionSpace(mesh, 'Lagrange', 1)
Vh = [Vh2, Vh1, Vh2]
print "Number of dofs: STATE={0}, PARAMETER={1}, ADJOINT={2}".format(
Vh[STATE].dim(), Vh[PARAMETER].dim(), Vh[ADJOINT].dim())
print sep, "Set up the location of observation, Prior Information, and model", sep
ntargets = 300
np.random.seed(seed=1)
targets = np.random.uniform(0.1, 0.9, [ntargets, ndim])
print "Number of observation points: {0}".format(ntargets)
gamma = .1
delta = .5
anis_diff = dl.Expression(code_AnisTensor2D)
def visualize(self,
U,
m,
title='',
legend=None,
filename=None,
block=True,
separate_colorbars=True):
"""Visualize the provided data.
Parameters
----------
U
|VectorArray| of the data to visualize (length must be 1). Alternatively,
a tuple of |VectorArrays| which will be visualized in separate windows.
If `filename` is specified, only one |VectorArray| may be provided which,
however, is allowed to contain multipled vectors that will be interpreted
as a time series.
m
Filled in by :meth:`pymor.models.interface.Model.visualize` (ignored).
title
Title of the plot.
legend
Description of the data that is plotted. If `U` is a tuple of |VectorArrays|,
`legend` has to be a tuple of the same length.
filename
If specified, write the data to that file. `filename` needs to have an extension
supported by FEniCS (e.g. `.pvd`).
separate_colorbars
If `True`, use separate colorbars for each subplot.
block
If `True`, block execution until the plot window is closed.
"""
if filename:
assert not isinstance(U, tuple)
assert U in self.space
f = df.File(filename)
coarse_function = df.Function(self.space.V)
if self.mesh_refinements:
mesh = self.space.V.mesh()
for _ in range(self.mesh_refinements):
mesh = df.refine(mesh)
V_fine = df.FunctionSpace(mesh, self.space.V.ufl_element())
function = df.Function(V_fine)
else:
function = coarse_function
if legend:
function.rename(legend, legend)
for u in U._list:
if u.imag_part is not None:
raise NotImplementedError
coarse_function.vector()[:] = u.real_part.impl
if self.mesh_refinements:
function.vector()[:] = df.interpolate(
coarse_function, V_fine).vector()
f << function
else:
from matplotlib import pyplot as plt
assert U in self.space and len(U) == 1 \
or (isinstance(U, tuple) and all(u in self.space for u in U) and all(len(u) == 1 for u in U))
if not isinstance(U, tuple):
U = (U, )
if isinstance(legend, str):
legend = (legend, )
assert legend is None or len(legend) == len(U)
if not separate_colorbars:
vmin = np.inf
vmax = -np.inf
for u in U:
vec = u._list[0].real_part.impl
vmin = min(vmin, vec.min())
vmax = max(vmax, vec.max())
for i, u in enumerate(U):
if u._list[0].imag_part is not None:
raise NotImplementedError
function = df.Function(self.space.V)
function.vector()[:] = u._list[0].real_part.impl
if legend:
tit = title + ' -- ' if title else ''
tit += legend[i]
else:
tit = title
if separate_colorbars:
plt.figure()
df.plot(function, title=tit)
else:
plt.figure()
df.plot(function,
title=tit,
range_min=vmin,
range_max=vmax)
plt.show(block=block)
def _discretize_fenics():
# assemble system matrices - FEniCS code
########################################
import dolfin as df
# discrete function space
mesh = df.UnitSquareMesh(GRID_INTERVALS, GRID_INTERVALS, 'crossed')
V = df.FunctionSpace(mesh, 'Lagrange', FENICS_ORDER)
u = df.TrialFunction(V)
v = df.TestFunction(V)
# data functions
bottom_diffusion = df.Expression(
'(x[0] > 0.45) * (x[0] < 0.55) * (x[1] < 0.7) * 1.',
element=df.FunctionSpace(mesh, 'DG', 0).ufl_element())
top_diffusion = df.Expression(
'(x[0] > 0.35) * (x[0] < 0.40) * (x[1] > 0.3) * 1. +' +
'(x[0] > 0.60) * (x[0] < 0.65) * (x[1] > 0.3) * 1.',
element=df.FunctionSpace(mesh, 'DG', 0).ufl_element())
initial_data = df.Expression(
'(x[0] > 0.45) * (x[0] < 0.55) * (x[1] < 0.7) * 10.',
element=df.FunctionSpace(mesh, 'DG', 0).ufl_element())
neumann_data = df.Expression('(x[0] > 0.45) * (x[0] < 0.55) * 1000.',
element=df.FunctionSpace(mesh, 'DG',
0).ufl_element())
# assemble matrices and vectors
l2_mat = df.assemble(df.inner(u, v) * df.dx)
l2_0_mat = l2_mat.copy()
h1_mat = df.assemble(df.inner(df.nabla_grad(u), df.nabla_grad(v)) * df.dx)
h1_0_mat = h1_mat.copy()
mat0 = h1_mat.copy()
mat0.zero()
bottom_mat = df.assemble(bottom_diffusion *
df.inner(df.nabla_grad(u), df.nabla_grad(v)) *
df.dx)
top_mat = df.assemble(top_diffusion *
df.inner(df.nabla_grad(u), df.nabla_grad(v)) * df.dx)
u0 = df.project(initial_data, V).vector()
f = df.assemble(neumann_data * v * df.ds)
# boundary treatment
def dirichlet_boundary(x, on_boundary):
tol = 1e-14
return on_boundary and (abs(x[0]) < tol or abs(x[0] - 1) < tol
or abs(x[1] - 1) < tol)
bc = df.DirichletBC(V, df.Constant(0.), dirichlet_boundary)
bc.apply(l2_0_mat)
bc.apply(h1_0_mat)
bc.apply(mat0)
bc.zero(bottom_mat)
bc.zero(top_mat)
bc.apply(f)
bc.apply(u0)
# wrap everything as a pyMOR discretization
###########################################
from pymor.bindings.fenics import FenicsVectorSpace, FenicsMatrixOperator, FenicsVisualizer
d = InstationaryDiscretization(
T=1.,
initial_data=FenicsVectorSpace(V).make_array([u0]),
operator=LincombOperator([
FenicsMatrixOperator(mat0, V, V),
FenicsMatrixOperator(h1_0_mat, V, V),
FenicsMatrixOperator(bottom_mat, V, V),
FenicsMatrixOperator(top_mat, V, V)
], [
1., 1., 100. - 1.,
ExpressionParameterFunctional('top - 1.', {'top': 0})
]),
rhs=VectorFunctional(FenicsVectorSpace(V).make_array([f])),
mass=FenicsMatrixOperator(l2_0_mat, V, V, name='l2'),
products={
'l2': FenicsMatrixOperator(l2_mat, V, V, name='l2'),
'l2_0': FenicsMatrixOperator(l2_0_mat, V, V, name='l2_0'),
'h1': FenicsMatrixOperator(h1_mat, V, V, name='h1'),
'h1_0_semi': FenicsMatrixOperator(h1_0_mat, V, V, name='h1_0_semi')
},
time_stepper=ImplicitEulerTimeStepper(nt=NT),
parameter_space=CubicParameterSpace({'top': 0},
minimum=1,
maximum=100.),
visualizer=FenicsVisualizer(FenicsVectorSpace(V)))
return d
# Define the traction boundary
sub_domains = df.MeshFunction('size_t', mesh, mesh.topology().dim() - 1)
upper_edge = TractionBoundary()
upper_edge.mark(sub_domains, 6)
dss = df.Measure('ds')(subdomain_data=sub_domains)
f = df.Constant((0, -1. / 4 ))
'''
3. Setup the PDE problem
'''
# PDE problem
pde_problem = PDEProblem(mesh)
# Add input to the PDE problem:
# name = 'density', function = density_function (function is the solution vector here)
density_function_space = df.FunctionSpace(mesh, 'DG', 0)
density_function = df.Function(density_function_space)
pde_problem.add_input('density', density_function)
# Add states to the PDE problem (line 58):
# name = 'displacements', function = displacements_function (function is the solution vector here)
# residual_form = get_residual_form(u, v, rho_e) from atomics.pdes.thermo_mechanical_uniform_temp
# *inputs = density (can be multiple, here 'density' is the only input)
displacements_function_space = df.VectorFunctionSpace(mesh, 'Lagrange', 1)
displacements_function = df.Function(displacements_function_space)
v = df.TestFunction(displacements_function_space)
method='SIMP'
residual_form = get_residual_form(
displacements_function,
v,
ocean[f] = 2
#########################################################
################# FUNCTION SPACES #####################
#########################################################
# Define finite element function spaces. Here we use CG1 for
# velocity computations, DG0 (aka finite volume) for mass cons,
# and "Real" (aka constant) elements for the length ODE
E_Q = df.FiniteElement("CG", mesh.ufl_cell(), 1)
E_dg = df.FiniteElement("DG", mesh.ufl_cell(), 0)
E_R = df.FiniteElement("R", mesh.ufl_cell(), 0)
E_V = df.MixedElement(E_Q, E_Q, E_Q, E_Q, E_dg, E_R)
Q = df.FunctionSpace(mesh, E_Q)
Q_dg = df.FunctionSpace(mesh, E_dg)
Q_R = df.FunctionSpace(mesh, E_R)
V = df.FunctionSpace(mesh, E_V)
# For moving data between vector functions and scalar functions
assigner_inv = df.FunctionAssigner([Q, Q, Q, Q, Q_dg, Q_R], V)
assigner = df.FunctionAssigner(V, [Q, Q, Q, Q, Q_dg, Q_R])
#########################################################
################# FUNCTIONS ###########################
#########################################################
# The zero function
ze = df.Function(Q)
# test
adif.test(1e-8)
# obtain MAP
map_v = adif.get_MAP(rand_init=False)
fig=dl.plot(vector2Function(map_v,adif.pde.Vh[PARAMETER]))
plt.colorbar(fig)
# plt.show()
plt.savefig(os.path.join(os.getcwd(),'properties/map.png'),bbox_inches='tight')
# conversion
v = adif.prior.sample()
im = adif.vec2img(v)
v1 = adif.img2vec(im)
fig,axes = plt.subplots(nrows=1,ncols=3,sharex=True,sharey=False,figsize=(16,5))
sub_figs=[None]*3
plt.axes(axes.flat[0])
sub_figs[0]=dl.plot(vector2Function(v,adif.pde.Vh[STATE]))
axes.flat[0].axis('equal')
axes.flat[0].set_title(r'Original Image')
plt.axes(axes.flat[1])
sub_figs[1]=plt.imshow(im,origin='lower',extent=[0,1,0,1])
axes.flat[1].axis('equal')
axes.flat[1].set_title(r'Transformed Image')
plt.axes(axes.flat[2])
# sub_figs[2]=dl.plot(vector2Function(v1,adif.pde.Vh[STATE]))
sub_figs[2]=dl.plot(vector2Function(v1,dl.FunctionSpace(adif.mesh,'Lagrange',1)))
axes.flat[2].axis('equal')
axes.flat[2].set_title(r'Reconstructed Image')
from util.common_colorbar import common_colorbar
fig=common_colorbar(fig,axes,sub_figs)
# plt.show()
plt.savefig(os.path.join(os.getcwd(),'properties/conversion.png'),bbox_inches='tight')
lam = c0 / freq
l = lam / 4 # Dipole length
# l = 2.3*lam # Dipole length
I = 1.0 # Dipole current
source_direction = np.array([0, 0, 1.]) # Source orientation
source_centre = np.array([0, 0, 0.]) # Position of the source
source_endpoints = np.array(
[-source_direction * l / 2, source_direction * l / 2]) + source_centre
## Discretisation settings
order = 2
domain_size = np.array([lam] * 3) / 2
max_edge_len = lam / 3
mesh = get_centred_cube(domain_size, max_edge_len)
## Implementation
V = dolfin.FunctionSpace(mesh, "Nedelec 1st kind H(curl)", order)
dipole_source = FillamentCurrentSource()
dipole_source.no_integration_points = 20
dipole_source.set_function_space(V)
dipole_source.set_source_endpoints(source_endpoints)
dipole_source.set_value(I)
dofnos, rhs_contribs = dipole_source.get_contribution()
sortind = np.argsort(dofnos)
dofnos = dofnos[sortind].copy()
rhs_contribs = rhs_contribs[sortind].copy()
pickle.dump(
dict(order=order,
I=I,
source_endpoints=source_endpoints,
domain_size=domain_size,
def test_onstrained_newton_energy_solver(self):
L, nelem = 1, 201
mesh = dl.IntervalMesh(nelem, -L, L)
Vh = dl.FunctionSpace(mesh, "CG", 2)
forcing = dl.Constant(1)
dirichlet_bcs = [dl.DirichletBC(Vh, dl.Constant(0.0), on_any_boundary)]
bc0 = dl.DirichletBC(Vh, dl.Constant(0.0), on_any_boundary)
uh = dl.TrialFunction(Vh)
vh = dl.TestFunction(Vh)
F = dl.inner((1 + uh**2) * dl.grad(uh),
dl.grad(vh)) * dl.dx - forcing * vh * dl.dx
F += uh * vh * dl.inner(dl.nabla_grad(uh), dl.nabla_grad(uh)) * dl.dx
u = dl.Function(Vh)
F = dl.action(F, u)
parameters={"symmetric": True, "newton_solver": {
"relative_tolerance": 1e-12, "report": True, \
"linear_solver": "cg", "preconditioner": "petsc_amg"}}
dl.solve(F == 0, u, dirichlet_bcs, solver_parameters=parameters)
#dl.plot(uh)
#plt.show()
F = 0.5*(1+uh**2)*dl.inner(dl.nabla_grad(uh),dl.nabla_grad(uh))*dl.dx-\
forcing*uh*dl.dx
#F = dl.inner((1+uh**2)*dl.grad(uh),dl.grad(vh))*dl.dx-forcing*vh*dl.dx
u_newton = dl.Function(Vh)
F = dl.action(F, u_newton)
constrained_newton_energy_solve(F,
u_newton,
dirichlet_bcs=dirichlet_bcs,
bc0=bc0,
linear_solver='PETScLU',
opts=dict())
F = 0.5*(1+uh**2)*dl.inner(dl.nabla_grad(uh),dl.nabla_grad(uh))*dl.dx-\
forcing*uh*dl.dx
u_grad = dl.Function(Vh)
F = dl.action(F, u_grad)
grad = dl.derivative(F, u_grad)
print(F)
print(grad)
parameters={"symmetric": True, "newton_solver": {
"relative_tolerance": 1e-12, "report": True, \
"linear_solver": "cg", "preconditioner": "petsc_amg"}}
dl.solve(grad == 0,
u_grad,
dirichlet_bcs,
solver_parameters=parameters)
error1 = dl.errornorm(u_grad, u_newton, mesh=mesh)
#print(error)
error2 = dl.errornorm(u, u_newton, mesh=mesh)
#print(error)
#dl.plot(u)
#dl.plot(u_newton)
#dl.plot(u_grad)
#plt.show()
assert error1 < 1e-15
assert error2 < 1e-15
try:
dl.set_log_active(False)
except:
pass
# set initial day of simulation
date = "2020-07-15"
# load mesh
mesh_path = args.mesh_path
mesh_fname = args.mesh_file
mesh = dl.Mesh(mesh_path + mesh_fname + ".xml")
# FE space
FE_polynomial = 1
Vu = dl.FunctionSpace(mesh, "Lagrange", FE_polynomial)
# read COVID-19 data
data_path = args.data_path
infected_total_state = np.loadtxt(
data_path + 'covid_11August2020/infected_total_state.txt')
deceased_state = np.loadtxt(data_path +
'covid_11August2020/deceased_state.txt')
# save data
d0 = datetime.strptime("2020-07-15", "%Y-%m-%d")
d1 = datetime.strptime(date, "%Y-%m-%d")
day_index = abs((d1 - d0)).days
# Define elements: P1 and real number
P1 = dl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
def simulate_FEM():
import dolfin as df
df.parameters['allow_extrapolation'] = False
# Define mesh
mesh = df.Mesh(join(mesh_folder, "{}.xml".format(mesh_name)))
subdomains = df.MeshFunction("size_t", mesh, join(mesh_folder,
"{}_physical_region.xml".format(mesh_name)))
boundaries = df.MeshFunction("size_t", mesh, join(mesh_folder,
"{}_facet_region.xml".format(mesh_name)))
print("Number of cells in mesh: ", mesh.num_cells())
np.save(join(out_folder, "mesh_coordinates.npy"), mesh.coordinates())
sigma_vec = df.Constant(sigma)
V = df.FunctionSpace(mesh, "CG", 2)
v = df.TestFunction(V)
u = df.TrialFunction(V)
ds = df.Measure("ds", domain=mesh, subdomain_data=boundaries)
dx = df.Measure("dx", domain=mesh, subdomain_data=subdomains)
a = df.inner(sigma_vec * df.grad(u), df.grad(v)) * dx(1)
# This corresponds to Neumann boundary conditions zero, i.e.
# all outer boundaries are insulating.
L = df.Constant(0) * v * dx
# Define Dirichlet boundary conditions outer cylinder boundaries (ground)
bcs = [df.DirichletBC(V, 0.0, boundaries, 1)]
for t_idx in range(num_tsteps):
f_name = join(out_folder, "phi_xz_t_vec_{}.npy".format(t_idx))
# if os.path.isfile(f_name):
# print("skipping ", f_name)
# continue
print("Time step {} of {}".format(t_idx, num_tsteps))
phi = df.Function(V)
A = df.assemble(a)
b = df.assemble(L)
[bc.apply(A, b) for bc in bcs]
# Adding point sources from neural simulation
for s_idx, s_pos in enumerate(source_pos):
point = df.Point(s_pos[0], s_pos[1], s_pos[2])
delta = df.PointSource(V, point, imem[s_idx, t_idx])
delta.apply(b)
df.solve(A, phi.vector(), b, 'cg', "ilu")
# df.File(join(out_folder, "phi_t_vec_{}.xml".format(t_idx))) << phi
# np.save(join(out_folder, "phi_t_vec_{}.npy".format(t_idx)), phi.vector())
plot_and_save_simulation_results(phi, t_idx)
# availability see https://hippylib.github.io.
#
# hIPPYlib is free software; you can redistribute it and/or modify it under the
# terms of the GNU General Public License (as published by the Free
# Software Foundation) version 3.0 dated June 2007.
import dolfin as dl
import sys
sys.path.append( "../../" )
from hippylib import *
import numpy as np
nx = 32
ny = 32
mesh = dl.UnitSquareMesh(nx, ny)
Vh = dl.FunctionSpace(mesh, 'Lagrange', 1)
Prior = LaplacianPrior(Vh, 1.,100.)
nsamples = 1000
s = dl.Function(Vh, name = "sample")
noise = dl.Vector()
Prior.init_vector(noise,"noise")
size = len(noise.array())
fid = dl.File("results_cg/samples.pvd")
for i in range(0, nsamples ):
noise.set_local( np.random.randn( size ) )
Prior.sample(noise, s.vector())
fid << s
def test_assembly_solve_taylor_hood(mesh):
"""Assemble Stokes problem with Taylor-Hood elements and solve."""
P2 = dolfin.VectorFunctionSpace(mesh, ("Lagrange", 2))
P1 = dolfin.FunctionSpace(mesh, ("Lagrange", 1))
def boundary0(x):
"""Define boundary x = 0"""
return x[:, 0] < 10 * numpy.finfo(float).eps
def boundary1(x):
"""Define boundary x = 1"""
return x[:, 0] > (1.0 - 10 * numpy.finfo(float).eps)
u0 = dolfin.Function(P2)
u0.vector().set(1.0)
u0.vector().ghostUpdate(
addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD)
bc0 = dolfin.DirichletBC(P2, u0, boundary0)
bc1 = dolfin.DirichletBC(P2, u0, boundary1)
u, p = dolfin.TrialFunction(P2), dolfin.TrialFunction(P1)
v, q = dolfin.TestFunction(P2), dolfin.TestFunction(P1)
a00 = inner(ufl.grad(u), ufl.grad(v)) * dx
a01 = ufl.inner(p, ufl.div(v)) * dx
a10 = ufl.inner(ufl.div(u), q) * dx
a11 = None
p00 = a00
p01, p10 = None, None
p11 = inner(p, q) * dx
# FIXME
# We need zero function for the 'zero' part of L
p_zero = dolfin.Function(P1)
f = dolfin.Function(P2)
L0 = ufl.inner(f, v) * dx
L1 = ufl.inner(p_zero, q) * dx
# -- Blocked and nested
A0 = dolfin.fem.assemble_matrix_nest([[a00, a01], [a10, a11]], [bc0, bc1])
A0norm = nest_matrix_norm(A0)
P0 = dolfin.fem.assemble_matrix_nest([[p00, p01], [p10, p11]], [bc0, bc1])
P0norm = nest_matrix_norm(P0)
b0 = dolfin.fem.assemble_vector_nest([L0, L1], [[a00, a01], [a10, a11]],
[bc0, bc1])
b0norm = b0.norm()
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A0, P0)
nested_IS = P0.getNestISs()
ksp.setType("minres")
pc = ksp.getPC()
pc.setType("fieldsplit")
pc.setFieldSplitIS(["u", nested_IS[0][0]], ["p", nested_IS[1][1]])
ksp_u, ksp_p = pc.getFieldSplitSubKSP()
ksp_u.setType("preonly")
ksp_u.getPC().setType('lu')
ksp_u.getPC().setFactorSolverType('mumps')
ksp_p.setType("preonly")
def monitor(ksp, its, rnorm):
# print("Num it, rnorm:", its, rnorm)
pass
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setMonitor(monitor)
ksp.setFromOptions()
x0 = b0.copy()
ksp.solve(b0, x0)
assert ksp.getConvergedReason() > 0
# -- Blocked and monolithic
A1 = dolfin.fem.assemble_matrix_block([[a00, a01], [a10, a11]], [bc0, bc1])
assert A1.norm() == pytest.approx(A0norm, 1.0e-12)
P1 = dolfin.fem.assemble_matrix_block([[p00, p01], [p10, p11]], [bc0, bc1])
assert P1.norm() == pytest.approx(P0norm, 1.0e-12)
b1 = dolfin.fem.assemble_vector_block([L0, L1], [[a00, a01], [a10, a11]],
[bc0, bc1])
assert b1.norm() == pytest.approx(b0norm, 1.0e-12)
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A1, P1)
ksp.setType("minres")
pc = ksp.getPC()
pc.setType('lu')
pc.setFactorSolverType('mumps')
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setFromOptions()
x1 = A1.createVecRight()
ksp.solve(b1, x1)
assert ksp.getConvergedReason() > 0
assert x1.norm() == pytest.approx(x0.norm(), 1e-8)
# -- Monolithic
P2 = ufl.VectorElement("Lagrange", mesh.ufl_cell(), 2)
P1 = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
TH = P2 * P1
W = dolfin.FunctionSpace(mesh, TH)
(u, p) = dolfin.TrialFunctions(W)
(v, q) = dolfin.TestFunctions(W)
a00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
a01 = ufl.inner(p, ufl.div(v)) * dx
a10 = ufl.inner(ufl.div(u), q) * dx
a = a00 + a01 + a10
p00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
p11 = ufl.inner(p, q) * dx
p_form = p00 + p11
f = dolfin.Function(W.sub(0).collapse())
p_zero = dolfin.Function(W.sub(1).collapse())
L0 = inner(f, v) * dx
L1 = inner(p_zero, q) * dx
L = L0 + L1
bc0 = dolfin.DirichletBC(W.sub(0), u0, boundary0)
bc1 = dolfin.DirichletBC(W.sub(0), u0, boundary1)
A2 = dolfin.fem.assemble_matrix(a, [bc0, bc1])
A2.assemble()
assert A2.norm() == pytest.approx(A0norm, 1.0e-12)
P2 = dolfin.fem.assemble_matrix(p_form, [bc0, bc1])
P2.assemble()
assert P2.norm() == pytest.approx(P0norm, 1.0e-12)
b2 = dolfin.fem.assemble_vector(L)
dolfin.fem.apply_lifting(b2, [a], [[bc0, bc1]])
b2.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
dolfin.fem.set_bc(b2, [bc0, bc1])
b2norm = b2.norm()
assert b2norm == pytest.approx(b0norm, 1.0e-12)
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A2, P2)
ksp.setType("minres")
pc = ksp.getPC()
pc.setType('lu')
pc.setFactorSolverType('mumps')
def monitor(ksp, its, rnorm):
# print("Num it, rnorm:", its, rnorm)
pass
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setMonitor(monitor)
ksp.setFromOptions()
x2 = A2.createVecRight()
ksp.solve(b2, x2)
assert ksp.getConvergedReason() > 0
assert x0.norm() == pytest.approx(x2.norm(), 1e-8)
# This is to test setting Function values in parallel
# https://fenicsproject.org/qa/10005/setting-function-values-in-parallel-repeated-question/
import dolfin as df
import sys
import numpy as np
n_cells = 10
#int(sys.argv[1])
mesh = df.UnitSquareMesh(n_cells, n_cells)
V = df.FunctionSpace(mesh, 'CG', 2)
u = df.Function(V)
vec = u.vector()
values = vec.get_local()
dofmap = V.dofmap()
my_first, my_last = dofmap.ownership_range() # global
# 'Handle' API change of tabulate coordinates
if df.__version__ >= '1.6.0':
x = V.tabulate_dof_coordinates().reshape((-1, 2))
else:
x = V.dofmap().tabulate_all_coordinates(mesh)
unowned = dofmap.local_to_global_unowned()
dofs = filter(lambda dof: dofmap.local_to_global_index(dof) not in unowned,
range(my_last - my_first))
dof_local = np.array(list(dofs))
def _inputsort(obj):
import dolfin
u = None
mesh = None
if not utils.isSequence(obj):
obj = [obj]
for ob in obj:
inputtype = str(type(ob))
#printc('inputtype is', inputtype, c=2)
if "vtk" in inputtype: # skip vtk objects, will be added later
continue
if "dolfin" in inputtype or "ufl" in inputtype:
if "MeshFunction" in inputtype:
mesh = ob.mesh()
if ob.dim() > 0:
printc('MeshFunction of dim>0 not supported.', c=1)
printc('Try e.g.: MeshFunction("size_t", mesh, 0)',
c=1,
italic=1)
printc('instead of MeshFunction("size_t", mesh, 1)',
c=1,
strike=1)
else:
#printc(ob.dim(), mesh.num_cells(), len(mesh.coordinates()), len(ob.array()))
V = dolfin.FunctionSpace(mesh, "CG", 1)
u = dolfin.Function(V)
v2d = dolfin.vertex_to_dof_map(V)
u.vector()[v2d] = ob.array()
elif "Function" in inputtype or "Expression" in inputtype:
u = ob
elif "ufl.mathfunctions" in inputtype: # not working
u = ob
elif "Mesh" in inputtype:
mesh = ob
elif "algebra" in inputtype:
mesh = ob.ufl_domain()
#print('algebra', ob.ufl_domain())
if "str" in inputtype:
mesh = dolfin.Mesh(ob)
if u and not mesh and hasattr(u, "function_space"):
V = u.function_space()
if V:
mesh = V.mesh()
if u and not mesh and hasattr(u, "mesh"):
mesh = u.mesh()
#printc('------------------------------------')
#printc('mesh.topology dim=', mesh.topology().dim())
#printc('mesh.geometry dim=', mesh.geometry().dim())
#if u: printc('u.value_rank()', u.value_rank())
#if u and u.value_rank(): printc('u.value_dimension()', u.value_dimension(0)) # axis=0
##if u: printc('u.value_shape()', u.value_shape())
return (mesh, u)
def run(active_model, material_model, matparams_space):
params = setup_adjoint_contraction_parameters(material_model)
if active_model == "active_strain":
params["T_ref"] = 0.2
else:
params["T_ref"] = 100.0
params["phase"] == "all"
# params["material_model"] = material_model
params["active_model"] = active_model
params["matparams_space"] = matparams_space
solver_parameters, pressure, paramvec= make_solver_params(params, patient)
Material = get_material_model(material_model)
msg = "Should be {}, got {}".format(Material,
type(solver_parameters["material"]))
assert isinstance(solver_parameters["material"], Material), msg
pressure
V_real = df.FunctionSpace(solver_parameters["mesh"], "R", 0)
gamma = df.Function(V_real, name = "gamma")
matparams = setup_material_parameters(material_model)
args = (patient.fiber,
gamma,
matparams,
active_model,
patient.sheet,
patient.sheet_normal,
params["T_ref"])
material = Material(*args)
solver_parameters["material"] = material
solver = LVSolver(solver_parameters)
solver.parameters["solve"]["newton_solver"]["report"] = True
from pulse_adjoint.iterate import iterate
pressures, volumes = [],[]
# Increase pressure
for plv in [0.0, 0.5, 1.0, 1.6]:
iterate("pressure", solver, plv, pressure)
u,p = solver.get_state().split(deepcopy=True)
pressures.append(plv)
vol = get_volume(patient, u = u)
volumes.append(vol)
# Increase gamma
iterate("gamma", solver, 1.0, gamma)
u_b = df.Constant(1e-6 * spy)
alpha = df.Constant(5. / 4.)
beta = df.Constant(3. / 2.)
k = df.Constant(.005 * spy)
e_v = df.Constant(1e-3)
dt_float = 1e-1
dt = df.Constant(dt_float)
mesh = df.Mesh('data/isunnguata_sermia.xml')
nhat = df.FacetNormal(mesh)
E_cg = df.FiniteElement("CG", mesh.ufl_cell(), 1)
Q_cg = df.FunctionSpace(mesh, E_cg)
E_dg = df.FiniteElement("DG", mesh.ufl_cell(), 0)
Q_dg = df.FunctionSpace(mesh, E_dg)
E = df.MixedElement([E_cg, E_cg, E_dg])
V = df.FunctionSpace(mesh, E)
B_dg = df.Function(Q_dg, 'data/Bed/B_d.xml')
B = df.Function(Q_cg, 'data/Bed/B_c.xml')
H0 = df.Function(Q_dg, 'data/Thk/H_d.xml')
H0_c = df.Function(Q_cg, 'data/Thk/H_c.xml')
edgefunction = df.MeshFunction('size_t', mesh, 1)
def _set_function_space(self):
self.V = d.FunctionSpace(self.mesh.mesh, self.element)
self.logger.info("Number of DOFs : {}".format(self.V.dim()))
mesh = df.RectangleMesh(0, z_dom_min, r_dom, z_dom_max, nr, nz)
# Define interior of quantum dot r^2+z^2<1 and z>0
class QuantumDot(df.SubDomain):
def inside(self, x, on_boundary):
return df.between(x[0]**2 + x[1]**2,
(0, 1)) and df.between(x[1], (0, 1))
quantumDot = QuantumDot()
domains = df.CellFunction("size_t", mesh)
domains.set_all(0)
quantumDot.mark(domains, 1)
V = df.FunctionSpace(mesh, "CG", 1)
u = df.TrialFunction(V)
v = df.TestFunction(V)
drdz = df.Measure("dx")[domains]
r = df.Expression("x[0]")
# Confining potential
potential = df.Constant(100)
# Partial derivatives of trial and test functions
u_r = u.dx(0)
v_r = v.dx(0)
u_z = u.dx(1)
v_z = v.dx(1)
plt.ion()
n_dif = 100
dif = np.zeros((n_dif, 2))
loaded = np.load(file=os.path.join(
folder, algs[alg_no] + '_ensbl' + str(ensbl_sz) + '_training_XimgY' +
'.npz'))
prng = np.random.RandomState(2020)
sel4eval = prng.choice(num_samp, size=n_dif, replace=False)
X = loaded['X'][sel4eval]
Y = loaded['Y'][sel4eval]
sel4print = prng.choice(n_dif, size=10, replace=False)
prog = np.ceil(n_dif * (.1 + np.arange(0, 1, .1)))
u_f = df.Function(adif.prior.V)
eldeg = adif.prior.V.ufl_element().degree()
if eldeg > 1:
V_P1 = df.FunctionSpace(adif.mesh, 'Lagrange', 1)
d2v = df.dof_to_vertex_map(V_P1)
u_f1 = df.Function(V_P1)
else:
u_f1 = u_f
for n in range(n_dif):
u = X[n]
# calculate gradient
t_start = timeit.default_timer()
ll_xact, dll_xact = adif.get_geom(
adif.img2vec(u, adif.prior.V if eldeg > 1 else None), [0, 1])[:2]
t_used[0] += timeit.default_timer() - t_start
# emulate gradient
t_start = timeit.default_timer()
ll_emul = logLik(u[None, :, :, None]).numpy()[0]
dll_emul = adif.img2vec(cnn.gradient(u[None, :, :, None], logLik))
def apex_to_base(mesh, base_marker, ffun=None):
"""
Find the apex coordinate and compute the laplace
equation to find the apex to base solution
Arguments
---------
mesh : dolfin.Mesh
The mesh
base_marker : int
The marker value for the basal facets
ffun : dolfin.MeshFunctionSizet (optional)
A facet function containing markers for the boundaries.
If not provided, the markers stored within the mesh will
be used.
"""
# Find apex by solving a laplacian with base solution = 0
# Create Base variational problem
V = df.FunctionSpace(mesh, "CG", 1)
u = df.TrialFunction(V)
v = df.TestFunction(V)
a = df.dot(df.grad(u), df.grad(v)) * df.dx
L = v * df.Constant(1) * df.dx
apex = df.Function(V)
base_bc = df.DirichletBC(V, 1, ffun, base_marker, "topological")
def solve(solver_parameters):
df.solve(a == L, apex, base_bc, solver_parameters=solver_parameters)
solver_parameters = {"linear_solver": "cg", "preconditioner": "amg"}
pcs = (pc for pc in ['petsc_amg', 'default'])
while 1:
try:
solve(solver_parameters)
except RuntimeError:
solver_parameters["preconditioner"] = next(pcs)
else:
break
if utils.DOLFIN_VERSION_MAJOR < 2018:
dof_x = utils.gather_broadcast(V.tabulate_dof_coordinates()).reshape(
(-1, 3))
apex_values = utils.gather_broadcast(apex.vector().get_local())
ind = apex_values.argmax()
apex_coord = dof_x[ind]
else:
dof_x = V.tabulate_dof_coordinates()
apex_values = apex.vector().get_local()
local_max_val = apex_values.max()
local_apex_coord = dof_x[apex_values.argmax()]
comm = utils.mpi_comm_world()
from mpi4py import MPI
global_max, apex_coord = comm.allreduce(sendobj=(local_max_val,
local_apex_coord),
op=MPI.MAXLOC)
df.info(" Apex coord: ({0:.2f}, {1:.2f}, {2:.2f})".format(*apex_coord))
# Update rhs
L = v * df.Constant(0) * df.dx
apex_domain = df.CompiledSubDomain(
"near(x[0], {0}) && near(x[1], {1}) && near(x[2], {2})".format(
*apex_coord))
apex_bc = df.DirichletBC(V, 0, apex_domain, "pointwise")
# Solve the poisson equation
df.solve(a == L,
apex, [base_bc, apex_bc],
solver_parameters={"linear_solver": "gmres"})
return apex
def gen_bccont_fems_3D(scheme='TH', bccontrol=True, verbose=False,
strtomeshfile='', strtophysicalregions='',
inflowvel=1., inflowprofile='parabola',
movingwallcntrl=False,
strtobcsobs=''):
"""
dictionary for the fem items for a general 3D flow setup
with
* inflow/outflow
* boundary control
Parameters
----------
scheme : {None, 'CR', 'TH'}
the finite element scheme to be applied, 'CR' for Crouzieux-Raviart,\
'TH' for Taylor-Hood, overrides `pdgree`, `vdgree`, defaults to `None`
bccontrol : boolean, optional
whether to consider boundary control via penalized Robin \
defaults to `True`
movingwallcntrl : boolean, optional
whether control is via moving boundaries
Returns
-------
femp : a dictionary with the keys:
* `V`: FEM space of the velocity
* `Q`: FEM space of the pressure
* `diribcs`: list of the (Dirichlet) boundary conditions
* `dbcsinds`: list vortex indices with (Dirichlet) boundary conditions
* `dbcsvals`: list of values of the (Dirichlet) boundary conditions
* `dirip`: list of the (Dirichlet) boundary conditions \
for the pressure
* `fv`: right hand side of the momentum equation
* `fp`: right hand side of the continuity equation
* `charlen`: characteristic length of the setup
* `odcoo`: dictionary with the coordinates of the \
domain of observation
"""
# Load mesh
mesh = dolfin.Mesh(strtomeshfile)
if scheme == 'CR':
V = dolfin.VectorFunctionSpace(mesh, "CR", 1)
Q = dolfin.FunctionSpace(mesh, "DG", 0)
elif scheme == 'TH':
V = dolfin.VectorFunctionSpace(mesh, "CG", 2)
Q = dolfin.FunctionSpace(mesh, "CG", 1)
boundaries = dolfin.MeshFunction('size_t', mesh, strtophysicalregions)
with open(strtobcsobs) as f:
cntbcsdata = json.load(f)
inflowgeodata = cntbcsdata['inflow']
inflwpe = inflowgeodata['physical entity']
inflwin = np.array(inflowgeodata['inward normal'])
inflwxi = np.array(inflowgeodata['xone'])
inflwxii = np.array(inflowgeodata['xtwo'])
# inflwxiii = np.array(inflowgeodata['xthree'])
inflwxiv = np.array(inflowgeodata['xfour'])
if inflowprofile == 'block':
raise NotImplementedError()
inflwprfl = dolfin.\
Expression(('cv*no', 'cv*nt'), cv=inflowvel,
no=inflwin[0], nt=inflwin[1],
element=V.ufl_element())
elif inflowprofile == 'parabola':
inflwprfl = InflowParabola3D(degree=2, xone=inflwxi, xtwo=inflwxii,
xfour=inflwxiv,
normalvec=inflwin, inflowvel=inflowvel)
bcin = dolfin.DirichletBC(V, inflwprfl, boundaries, inflwpe)
diribcu = [bcin]
# ## THE WALLS
wallspel = cntbcsdata['walls']['physical entity']
gzero = dolfin.Constant((0, 0, 0))
for wpe in wallspel:
diribcu.append(dolfin.DirichletBC(V, gzero, boundaries, wpe))
# bcdict = diribcu[-1].get_boundary_values()
if not bccontrol: # treat the control boundaries as walls
try:
for cntbc in cntbcsdata['controlbcs']:
diribcu.append(dolfin.DirichletBC(V, gzero, boundaries,
cntbc['physical entity']))
except KeyError:
pass # no control boundaries
# yes-slip walls
try:
slipwallspel = cntbcsdata['slipwalls']['physical entity']
slipwallsnvs = cntbcsdata['slipwalls']['inward normals']
gscalzero = dolfin.Constant(0)
for kk, swpe in enumerate(slipwallspel):
cinwnrml = np.array(slipwallsnvs[kk])
if np.abs(np.inner(cinwnrml, np.array([0, 0, 1.]))) == 1:
cbcsw = dolfin.DirichletBC(V.sub(2), gscalzero,
boundaries, swpe)
diribcu.append(cbcsw)
else:
raise NotImplementedError()
except KeyError:
pass # no control boundaries
mvwdbcs = []
mvwtvs = []
try:
for cntbc in cntbcsdata['moving walls']:
raise NotImplementedError()
center = np.array(cntbc['geometry']['center'])
radius = cntbc['geometry']['radius']
if cntbc['type'] == 'circle':
omega = 1. if movingwallcntrl else 0.
rotcyl = RotatingCircle(degree=2, radius=radius,
xcenter=center, omega=omega)
else:
raise NotImplementedError()
mvwdbcs.append(dolfin.DirichletBC(V, rotcyl, boundaries,
cntbc['physical entity']))
except KeyError:
pass # no moving walls defined
if not movingwallcntrl:
diribcu.extend(mvwdbcs) # add the moving walls to the diri bcs
mvwdbcs = []
# Create outflow boundary condition for pressure
# TODO XXX why zero pressure?? is this do-nothing???
# outflwpe = cntbcsdata['outflow']['physical entity']
# g2 = dolfin.Constant(0)
# bc2 = dolfin.DirichletBC(Q, g2, boundaries, outflwpe)
# Collect boundary conditions
# bcp = [bc2]
# Create right-hand side function
fv = dolfin.Constant((0, 0, 0))
fp = dolfin.Constant(0)
def initial_conditions(self, V, Q):
u0 = dolfin.Constant((0, 0, 0))
p0 = dolfin.Constant(0)
return u0, p0
dbcinds, dbcvals = [], []
for bc in diribcu:
bcdict = bc.get_boundary_values()
dbcvals.extend(list(bcdict.values()))
dbcinds.extend(list(bcdict.keys()))
mvwbcinds, mvwbcvals = [], []
for bc in mvwdbcs:
bcdict = bc.get_boundary_values()
mvwbcvals.extend(list(bcdict.values()))
mvwbcinds.extend(list(bcdict.keys()))
# ## Control boundaries
bcpes, bcshapefuns, bcds = [], [], []
if bccontrol:
raise NotImplementedError()
for cbc in cntbcsdata['controlbcs']:
cpe = cbc['physical entity']
cxi, cxii = np.array(cbc['xone']), np.array(cbc['xtwo'])
csf = _get_cont_shape_fun2D(xi=cxi, xii=cxii,
element=V.ufl_element())
bcshapefuns.append(csf)
bcpes.append(cpe)
bcds.append(dolfin.Measure("ds", subdomain_data=boundaries)(cpe))
# ## Lift Drag Computation
try:
ldsurfpe = cntbcsdata['lift drag surface']['physical entity']
raise NotImplementedError()
liftdragds = dolfin.Measure("ds", subdomain_data=boundaries)(ldsurfpe)
bclds = dolfin.DirichletBC(V, gzero, boundaries, ldsurfpe)
bcldsdict = bclds.get_boundary_values()
ldsbcinds = list(bcldsdict.keys())
except KeyError:
liftdragds = None # no domain specified for lift/drag
ldsbcinds = None
try:
outflwpe = cntbcsdata['outflow']['physical entity']
outflowds = dolfin.Measure("ds", subdomain_data=boundaries)(outflwpe)
except KeyError:
outflowds = None # no domain specified for outflow
try:
odcoo = cntbcsdata['observation-domain-coordinates']
raise NotImplementedError()
except KeyError:
odcoo = None
gbcfems = dict(V=V,
Q=Q,
dbcinds=dbcinds,
dbcvals=dbcvals,
mvwbcinds=mvwbcinds,
mvwbcvals=mvwbcvals,
mvwtvs=mvwtvs,
# dirip=bcp,
outflowds=outflowds,
# contrbcssubdomains=bcsubdoms,
liftdragds=liftdragds,
ldsbcinds=ldsbcinds,
contrbcmeshfunc=boundaries,
contrbcspes=bcpes,
contrbcsshapefuns=bcshapefuns,
cntrbcsds=bcds,
odcoo=odcoo,
fv=fv,
fp=fp,
charlen=cntbcsdata['characteristic length'],
mesh=mesh)
return gbcfems
return sum(wq*f(*xq) for xq, wq in zip(pts, weights))/l
# Get the MEAN
mesh = df.BoxMesh(df.Point(-1, -1, -1), df.Point(1, 1, 1), 16, 16, 16)
# Make 1d
f = df.MeshFunction('size_t', mesh, 1, 0)
# df.CompiledSubDomain('near(x[0], x[1]) && near(x[1], x[2])').mark(f, 1)
df.CompiledSubDomain('near(x[0], 0.) && near(x[1], 0.)').mark(f, 1)
line_mesh = EmbeddedMesh(f, 1)
# Circle ---------------------------------------------------------
size = 0.125
ci = Circle(radius=lambda x0: size, degree=12)
u = df.Function(df.FunctionSpace(mesh, 'CG', 1))
op = Average(u, line_mesh, ci)
surface = render_avg_surface(op)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x0 = np.array([0, 0, 0.5])
n = np.array([0, 0, 1])
ci_integrate = lambda f, shape=ci, n=n, x0=x0: shape_integrate(f, shape, x0, n)
# Sanity
f = lambda x, y, z: 1
value = ci_integrate(f)
assert is_close(value, 1)
