def delta_dg(mesh, expr):
V = df.FunctionSpace(mesh, "DG", 0)
m = df.interpolate(expr, V)
n = df.FacetNormal(mesh)
h = df.CellSize(mesh)
h_avg = (h('+') + h('-')) / 2
alpha = 1.0
gamma = 0.0
u = df.TrialFunction(V)
v = df.TestFunction(V)
# for DG 0 case, only term contain alpha is nonzero
a = df.dot(df.grad(v), df.grad(u))*df.dx \
- df.dot(df.avg(df.grad(v)), df.jump(u, n))*df.dS \
- df.dot(df.jump(v, n), df.avg(df.grad(u)))*df.dS \
+ alpha/h_avg*df.dot(df.jump(v, n), df.jump(u, n))*df.dS \
- df.dot(df.grad(v), u*n)*df.ds \
- df.dot(v*n, df.grad(u))*df.ds \
+ gamma/h*v*u*df.ds
K = df.assemble(a).array()
L = df.assemble(v * df.dx).array()
h = -np.dot(K, m.vector().array()) / (L)
xs = []
for cell in df.cells(mesh):
xs.append(cell.midpoint().x())
print len(xs), len(h)
return xs, h
def setUp(self):
self.mesh = mesh = dolfin.UnitSquareMesh(20, 2, "left")
self.DG0_element = DG0e = dolfin.FiniteElement("DG", mesh.ufl_cell(),
0)
self.DG0v_element = DG0ve = dolfin.VectorElement(
"DG", mesh.ufl_cell(), 0)
self.DG0 = DG0 = dolfin.FunctionSpace(mesh, DG0e)
self.DG0v = DG0v = dolfin.FunctionSpace(mesh, DG0ve)
self.fsr = fsr = FunctionSubspaceRegistry()
fsr.register(DG0)
fsr.register(DG0v)
self.cellmid = cm = CellMidpointExpression(mesh, element=DG0ve)
self.n = n = dolfin.FacetNormal(mesh)
self.u = u = dolfin.Function(DG0)
self.v = v = dolfin.TestFunction(DG0)
u_bc = dolfin.Expression('x[0]', degree=2)
x = dolfin.SpatialCoordinate(mesh)
self.rho = rho = dolfin.conditional(
dolfin.lt((x[0] - 0.5)**2 + (x[1] - 0.5)**2, 0.2**2), 0.0, 0.0)
dot = dolfin.dot
cellsize = dolfin.CellSize(mesh)
self.h = h = cm('+') - cm('-')
self.h_boundary = h_boundary = 2 * n * dot(x - cm, n)
self.E = E = h / dot(h, h) * (u('-') - u('+'))
self.E_boundary = E_boundary = h_boundary / dot(
h_boundary, h_boundary) * (u - u_bc)
dS = dolfin.dS
eps = 1e-8
class BL(dolfin.SubDomain):
def inside(self, x, on_boundary):
return abs(x[0]) < eps
class BR(dolfin.SubDomain):
def inside(self, x, on_boundary):
return abs(x[0] - 1) < eps
ff = dolfin.FacetFunction('size_t', mesh, 0)
BL().mark(ff, 1)
BR().mark(ff, 1)
ds = dolfin.Measure('ds', domain=mesh, subdomain_data=ff)
self.F = (dot(E, n('+')) * v('+') * dS + dot(E, n('-')) * v('-') * dS -
v * rho * dolfin.dx + dot(E_boundary, n) * v * ds(1))
def assemble_1d(mesh):
DG = df.FunctionSpace(mesh, "DG", 0)
n = df.FacetNormal(mesh)
h = df.CellSize(mesh)
h_avg = (h('+') + h('-')) / 2
u = df.TrialFunction(DG)
v = df.TestFunction(DG)
a = 1.0 / h_avg * df.dot(df.jump(v, n), df.jump(u, n)) * df.dS
K = df.assemble(a)
L = df.assemble(v * df.dx).array()
return copy_petsc_to_csr(K), L
def __init__(self, mesh, Vh, t_init, t_final, t_1, dt, wind_velocity,
gls_stab, Prior):
self.mesh = mesh
self.Vh = Vh
self.t_init = t_init
self.t_final = t_final
self.t_1 = t_1
self.dt = dt
self.sim_times = np.arange(self.t_init, self.t_final + .5 * self.dt,
self.dt)
u = dl.TrialFunction(Vh[STATE])
v = dl.TestFunction(Vh[STATE])
kappa = dl.Constant(.001)
dt_expr = dl.Constant(self.dt)
r_trial = u + dt_expr * (-dl.div(kappa * dl.nabla_grad(u)) +
dl.inner(wind_velocity, dl.nabla_grad(u)))
r_test = v + dt_expr * (-dl.div(kappa * dl.nabla_grad(v)) +
dl.inner(wind_velocity, dl.nabla_grad(v)))
h = dl.CellSize(mesh)
vnorm = dl.sqrt(dl.inner(wind_velocity, wind_velocity))
if gls_stab:
tau = dl.Min((h * h) / (dl.Constant(2.) * kappa), h / vnorm)
else:
tau = dl.Constant(0.)
self.M = dl.assemble(dl.inner(u, v) * dl.dx)
self.M_stab = dl.assemble(dl.inner(u, v + tau * r_test) * dl.dx)
self.Mt_stab = dl.assemble(dl.inner(u + tau * r_trial, v) * dl.dx)
Nvarf = (dl.inner(kappa * dl.nabla_grad(u), dl.nabla_grad(v)) +
dl.inner(wind_velocity, dl.nabla_grad(u)) * v) * dl.dx
Ntvarf = (dl.inner(kappa * dl.nabla_grad(v), dl.nabla_grad(u)) +
dl.inner(wind_velocity, dl.nabla_grad(v)) * u) * dl.dx
self.N = dl.assemble(Nvarf)
self.Nt = dl.assemble(Ntvarf)
stab = dl.assemble(tau * dl.inner(r_trial, r_test) * dl.dx)
self.L = self.M + dt * self.N + stab
self.Lt = self.M + dt * self.Nt + stab
boundaries = dl.FacetFunction("size_t", mesh)
boundaries.set_all(0)
class InsideBoundary(dl.SubDomain):
def inside(self, x, on_boundary):
x_in = x[0] > dl.DOLFIN_EPS and x[0] < 1 - dl.DOLFIN_EPS
y_in = x[1] > dl.DOLFIN_EPS and x[1] < 1 - dl.DOLFIN_EPS
return on_boundary and x_in and y_in
Gamma_M = InsideBoundary()
Gamma_M.mark(boundaries, 1)
ds_marked = dl.Measure("ds")[boundaries]
self.Q = dl.assemble(self.dt * dl.inner(u, v) * ds_marked(1))
self.Prior = Prior
self.solver = dl.PETScKrylovSolver("gmres", "ilu")
self.solver.set_operator(self.L)
self.solvert = dl.PETScKrylovSolver("gmres", "ilu")
self.solvert.set_operator(self.Lt)
self.ud = self.generate_vector(STATE)
self.noise_variance = 0
def __init__(self, fileName, timeEnd, timeStep, average=False):
fc.set_log_active(False)
self.times = []
self.BB = []
self.HH = []
self.TD = []
self.TB = []
self.TX = []
self.TY = []
self.TZ = []
self.us = []
self.ub = []
##########################################################
################ MESH #################
##########################################################
# TODO: Probably do not have to save then open mesh
self.mesh = df.Mesh()
self.inFile = fc.HDF5File(self.mesh.mpi_comm(), fileName, "r")
self.inFile.read(self.mesh, "/mesh", False)
#########################################################
################# FUNCTION SPACES #####################
#########################################################
self.E_Q = df.FiniteElement("CG", self.mesh.ufl_cell(), 1)
self.Q = df.FunctionSpace(self.mesh, self.E_Q)
self.E_V = df.MixedElement(self.E_Q, self.E_Q, self.E_Q)
self.V = df.FunctionSpace(self.mesh, self.E_V)
self.assigner_inv = fc.FunctionAssigner([self.Q, self.Q, self.Q], self.V)
self.assigner = fc.FunctionAssigner(self.V, [self.Q, self.Q, self.Q])
self.U = df.Function(self.V)
self.dU = df.TrialFunction(self.V)
self.Phi = df.TestFunction(self.V)
self.u, self.u2, self.H = df.split(self.U)
self.phi, self.phi1, self.xsi = df.split(self.Phi)
self.un = df.Function(self.Q)
self.u2n = df.Function(self.Q)
self.zero_sol = df.Function(self.Q)
self.Bhat = df.Function(self.Q)
self.H0 = df.Function(self.Q)
self.A = df.Function(self.Q)
if average:
self.inFile.read(self.Bhat.vector(), "/bedAvg", True)
self.inFile.read(self.A.vector(), "/smbAvg", True)
self.inFile.read(self.H0.vector(), "/thicknessAvg", True)
else:
self.inFile.read(self.Bhat.vector(), "/bed", True)
self.inFile.read(self.A.vector(), "/smb", True)
self.inFile.read(self.H0.vector(), "/thickness", True)
self.Hmid = theta * self.H + (1 - theta) * self.H0
self.B = softplus(self.Bhat, -rho / rho_w * self.Hmid, alpha=0.2) # Is not the bed, it is the lower surface
self.S = self.B + self.Hmid
self.width = df.interpolate(Width(degree=2), self.Q)
self.strs = Stresses(self.U, self.Hmid, self.H0, self.H, self.width, self.B, self.S, self.Phi)
self.R = -(self.strs.tau_xx + self.strs.tau_xz + self.strs.tau_b + self.strs.tau_d + self.strs.tau_xy) * df.dx
#############################################################################
######################## MASS CONSERVATION ################################
#############################################################################
self.h = df.CellSize(self.mesh)
self.D = self.h * abs(self.U[0]) / 2.
self.area = self.Hmid * self.width
self.mesh_min = self.mesh.coordinates().min()
self.mesh_max = self.mesh.coordinates().max()
# Define boundaries
self.ocean = df.FacetFunctionSizet(self.mesh, 0)
self.ds = fc.ds(subdomain_data=self.ocean) # THIS DS IS FROM FENICS! border integral
for f in df.facets(self.mesh):
if df.near(f.midpoint().x(), self.mesh_max):
self.ocean[f] = 1
if df.near(f.midpoint().x(), self.mesh_min):
self.ocean[f] = 2
self.R += ((self.H - self.H0) / dt * self.xsi \
- self.xsi.dx(0) * self.U[0] * self.Hmid \
+ self.D * self.xsi.dx(0) * self.Hmid.dx(0) \
- (self.A - self.U[0] * self.H / self.width * self.width.dx(0)) \
* self.xsi) * df.dx + self.U[0] * self.area * self.xsi * self.ds(1) \
- self.U[0] * self.area * self.xsi * self.ds(0)
#####################################################################
######################### SOLVER SETUP ###########################
#####################################################################
# Bounds
self.l_thick_bound = df.project(Constant(thklim), self.Q)
self.u_thick_bound = df.project(Constant(1e4), self.Q)
self.l_v_bound = df.project(-10000.0, self.Q)
self.u_v_bound = df.project(10000.0, self.Q)
self.l_bound = df.Function(self.V)
self.u_bound = df.Function(self.V)
self.assigner.assign(self.l_bound, [self.l_v_bound] * 2 + [self.l_thick_bound])
self.assigner.assign(self.u_bound, [self.u_v_bound] * 2 + [self.u_thick_bound])
# This should set the velocity at the divide (left) to zero
self.dbc0 = df.DirichletBC(self.V.sub(0), 0, lambda x, o: df.near(x[0], self.mesh_min) and o)
# Set the velocity on the right terminus to zero
self.dbc1 = df.DirichletBC(self.V.sub(0), 0, lambda x, o: df.near(x[0], self.mesh_max) and o)
# overkill?
self.dbc2 = df.DirichletBC(self.V.sub(1), 0, lambda x, o: df.near(x[0], self.mesh_max) and o)
# set the thickness on the right edge to thklim
self.dbc3 = df.DirichletBC(self.V.sub(2), thklim, lambda x, o: df.near(x[0], self.mesh_max) and o)
# Define variational solver for the mass-momentum coupled problem
self.J = df.derivative(self.R, self.U, self.dU)
self.coupled_problem = df.NonlinearVariationalProblem(self.R, self.U, bcs=[self.dbc0, self.dbc1, self.dbc3], \
J=self.J)
self.coupled_problem.set_bounds(self.l_bound, self.u_bound)
self.coupled_solver = df.NonlinearVariationalSolver(self.coupled_problem)
# Acquire the optimizations in fenics_optimizations
set_solver_options(self.coupled_solver)
self.t = 0
self.timeEnd = float(timeEnd)
self.dtFloat = float(timeStep)
self.inFile.close()
##########################################################
######################## MESH ##########################
##########################################################
# Define a unit interval mesh with equal cell size
N_cells = 300
mesh = df.IntervalMesh(N_cells, 0, 1)
# Shift vertices such that they are concentrated towards the
# terminus following a polynomial curve.
mesh_exp = 1.5
mesh.coordinates()[:] = (1 - mesh.coordinates()**mesh_exp)[::-1]
# Mesh Functions
h = df.CellSize(mesh) # Cell size
x_spatial = df.SpatialCoordinate(mesh) # spatial coordinate
nhat = df.FacetNormal(mesh) # facet normal vector
ocean = df.FacetFunctionSizet(mesh, 0) # boundary subdomain function
# ocean=1 -> terminus
# ocean=2 -> ice divide
df.ds = df.ds(subdomain_data=ocean)
for f in df.facets(mesh):
if df.near(f.midpoint().x(), 1):
ocean[f] = 1
if df.near(f.midpoint().x(), 0):
ocean[f] = 2
#########################################################
################# FUNCTION SPACES #####################
def delta_dg(mesh,expr):
V = df.FunctionSpace(mesh, "DG", 1)
m = df.interpolate(expr, V)
n = df.FacetNormal(mesh)
h = df.CellSize(mesh)
h_avg = (h('+') + h('-'))/2.0
alpha = 1.0
gamma = 0
u = df.TrialFunction(V)
v = df.TestFunction(V)
a = df.dot(df.grad(v), df.grad(u))*df.dx \
- df.dot(df.avg(df.grad(v)), df.jump(u, n))*df.dS \
- df.dot(df.jump(v, n), df.avg(df.grad(u)))*df.dS \
+ alpha/h_avg*df.dot(df.jump(v, n), df.jump(u, n))*df.dS
#- df.dot(df.grad(v), u*n)*df.ds \
#- df.dot(v*n, df.grad(u))*df.ds \
#+ gamma/h*v*u*df.ds
#a = 1.0/h_avg*df.dot(df.jump(v, n), df.jump(u, n))*df.dS
#- df.dot(df.grad(v), u*n)*df.ds \
#- df.dot(v*n, df.grad(u))*df.ds \
#+ gamma/h*v*u*df.ds
"""
a1 = df.dot(df.grad(v), df.grad(u))*df.dx
a2 = df.dot(df.avg(df.grad(v)), df.jump(u, n))*df.dS
a3 = df.dot(df.jump(v, n), df.avg(df.grad(u)))*df.dS
a4 = alpha/h_avg*df.dot(df.jump(v, n), df.jump(u, n))*df.dS
a5 = df.dot(df.grad(v), u*n)*df.ds
a6 = df.dot(v*n, df.grad(u))*df.ds
a7 = alpha/h*v*u*df.ds
printaa(a1,'a1')
printaa(a2,'a2')
printaa(a3,'a3')
printaa(a4,'a4')
printaa(a5,'a5')
printaa(a6,'a6')
printaa(a7,'a7')
"""
K = df.assemble(a).array()
L = df.assemble(v * df.dx).array()
h = -np.dot(K,m.vector().array())/L
fun = df.Function(V)
fun.vector().set_local(h)
DG1 = df.FunctionSpace(mesh, "DG", 1)
CG1 = df.FunctionSpace(mesh, "CG", 1)
#fun = df.interpolate(fun, DG1)
fun = df.project(fun, CG1)
dim = mesh.topology().dim()
res = []
if dim == 1:
for x in xs:
res.append(fun(x))
elif dim == 2:
df.plot(fun)
df.interactive()
for x in xs:
res.append(fun(x,0.5))
elif dim == 3:
for x in xs:
res.append(fun(x,0.5,0.5))
return res
