def nu_PWC_arit(phi, cc): A = df.conditional(df.gt(phi, 0.975), 1.0, 0.0) B = df.conditional(df.lt(phi, 0.025), 1.0, 0.0) nu = A * cc[r"\nu_1"]\ + B * cc[r"\nu_2"]\ + (1.0 - A - B) * 0.5 * (cc[r"\nu_1"] + cc[r"\nu_2"]) return nu
def nu_PWC_harm(phi, cc): A = df.conditional(df.gt(phi, 0.975), 1.0, 0.0) B = df.conditional(df.lt(phi, 0.025), 1.0, 0.0) nu = A * cc[r"\nu_1"]\ + B * cc[r"\nu_2"]\ + (1.0 - A - B) * 2.0 / (1.0 / cc[r"\nu_1"] + 1.0 / cc[r"\nu_2"]) return nu
def navier_stokes_stabilization_penalties( simulation, nu, velocity_continuity_factor_D12=0, pressure_continuity_factor=0, no_coeff=False, ): """ Calculate the stabilization parameters needed in the DG scheme """ ndim = simulation.ndim mpm = simulation.multi_phase_model mesh = simulation.data['mesh'] use_const = simulation.input.get_value( 'solver/spatially_constant_penalty', False, 'bool' ) if no_coeff: mu_min = mu_max = 1.0 else: mu_min, mu_max = mpm.get_laminar_dynamic_viscosity_range() P = simulation.data['Vu'].ufl_element().degree() if use_const: simulation.log.info(' Using spatially constant elliptic penalty') penalty_dS = define_penalty( mesh, P, mu_min, mu_max, boost_factor=3, exponent=1.0 ) penalty_ds = penalty_dS * 2 simulation.log.info( ' DG SIP penalty: dS %.1f ds %.1f' % (penalty_dS, penalty_ds) ) penalty_dS = Constant(penalty_dS) penalty_ds = Constant(penalty_ds) else: simulation.log.info(' Using spatially varying elliptic penalties') penalty_dS = define_spatially_varying_penalty( simulation, P, mu_min, mu_max, boost_factor=3, exponent=1.0 ) penalty_ds = penalty_dS * 2 penalty_dS = dolfin.conditional( dolfin.lt(penalty_dS('+'), penalty_dS('-')), penalty_dS('-'), penalty_dS('+'), ) if velocity_continuity_factor_D12: D12 = Constant([velocity_continuity_factor_D12] * ndim) else: D12 = Constant([0] * ndim) if pressure_continuity_factor: h = simulation.data['h'] h = Constant(1.0) D11 = avg(h / nu) * Constant(pressure_continuity_factor) else: D11 = None return penalty_dS, penalty_ds, D11, D12
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 test_scalar_conditions(R): c = Function(R) c.vector()[:] = 1.5 # Float conversion does not interfere with boolean ufl expressions assert isinstance(lt(c, 3), ufl.classes.LT) assert not isinstance(lt(c, 3), bool) # Float conversion is not implicit in boolean Python expressions assert isinstance(c < 3, ufl.classes.LT) assert not isinstance(c < 3, bool) # == is used in ufl to compare equivalent representations, # <,> result in LT/GT expressions, bool conversion is illegal # Note that 1.5 < 0 == False == 1.5 < 1, but that is not what we # compare here: assert not (c < 0) == (c < 1) # This protects from "if c < 0: ..." misuse: with pytest.raises(ufl.UFLException): bool(c < 0) with pytest.raises(ufl.UFLException): not c < 0
def _tree(base, length): if base >= N: return 0.0 if length == 1: return mapping[base][1] elif length > 1: l2 = length // 2 if base + l2 >= N: # no right side return _tree(base, l2) cut = (mapping[base + l2][0] + mapping[base + l2 - 1][0]) / 2 return dolfin.conditional(dolfin.lt(expr, cut), _tree(base, l2), _tree(base + l2, l2)) else: raise AssertionError()
a = dot(omega, grad(I)) w = v * omega n = facet_normal a_bc = S - beta * I return (dot(w, n) * a_bc, -a * div(w) + dot(w, grad(beta * I)) - dot(w, grad(S))) if really_squished_mesh: lower_boundary_value = dolfin.Constant(1.0) else: lower_boundary_value = dolfin.conditional( dolfin.lt((x[0] - 0.5)**2, 0.35**2), 1.0, 0.0) bcs = [dolfin.DirichletBC(space, lower_boundary_value, lower_boundary)] if not no_side_bc: def _side_bc(subdomain): bcs.append(dolfin.DirichletBC(space, dolfin.Constant(0.0), subdomain)) if theta < np.pi / 2: _side_bc(left_boundary) else: _side_bc(right_boundary) # alpha = dolfin.Constant(1.0) alpha = dolfin.conditional(
def Phi_pddproj_clipped(self): Phi = self.Phi_pddproj return dolfin.conditional(dolfin.lt(Phi.m, 0.0), 0.0, Phi.m) * Phi.u
def omega(k): k0 = Mat.ft / Mat.E beta = Mat.ft / Mat.Gf exponent = beta * (k0 - k) omega = 1.0 - k0 / k * (1.0 - Mat.alpha + Mat.alpha * df.exp(exponent)) return df.conditional(df.lt(k, k0), 0, omega)