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