def test_vector_heat_disk_dirichlet(Nr, Nphi, dtype): # Bases dealias = 1 c, d, b, phi, r, x, y = build_disk(Nphi, Nr, dealias=dealias, dtype=dtype) # Fields u = field.Field(name='u', dist=d, bases=(b, ), tensorsig=(c, ), dtype=dtype) τu = field.Field(name='u', dist=d, bases=(b.S1_basis(), ), tensorsig=(c, ), dtype=dtype) v = field.Field(name='u', dist=d, bases=(b, ), tensorsig=(c, ), dtype=dtype) ex = np.array([-np.sin(phi), np.cos(phi)]) ey = np.array([np.cos(phi), np.sin(phi)]) v['g'] = (x + 4 * y) * ex vr = operators.RadialComponent(v(r=radius_disk)) vph = operators.AzimuthalComponent(v(r=radius_disk)) # Problem Lap = lambda A: operators.Laplacian(A, c) Lift = lambda A: operators.Lift(A, b, -1) problem = problems.LBVP([u, τu]) problem.add_equation((Lap(u) + Lift(τu), 0)) problem.add_equation((u(r=radius_disk), v(r=radius_disk))) # Solver solver = solvers.LinearBoundaryValueSolver(problem) solver.solve() assert np.allclose(u['g'], v['g'])
def test_radial_component_tensor(Nphi, Ntheta, Nr, k, dealias, dtype, basis, radius): c, d, b, phi, theta, r, x, y, z = basis(Nphi, Ntheta, Nr, k, dealias, dtype) T = field.Field(dist=d, bases=(b, ), tensorsig=(c, c), dtype=dtype) T.preset_scales(b.domain.dealias) T['g'][2, 2] = (6 * x**2 + 4 * y * z) / r**2 T['g'][2, 1] = T['g'][1, 2] = -2 * (y**3 + x**2 * (y - 3 * z) - y * z**2) / (r**3 * np.sin(theta)) T['g'][2, 0] = T['g'][0, 2] = 2 * x * (z - 3 * y) / (r**2 * np.sin(theta)) T['g'][1, 1] = 6 * x**2 / (r**2 * np.sin(theta)**2) - (6 * x**2 + 4 * y * z) / r**2 T['g'][1, 0] = T['g'][0, 1] = -2 * x * (x**2 + y**2 + 3 * y * z) / (r**3 * np.sin(theta)**2) T['g'][0, 0] = 6 * y**2 / (x**2 + y**2) A = operators.RadialComponent(operators.interpolate(T, r=radius)).evaluate() Ag = 0 * A['g'] Ag[2] = 2 * np.sin(theta) * (3 * np.cos(phi)**2 * np.sin(theta) + 2 * np.cos(theta) * np.sin(phi)) Ag[1] = 6 * np.cos(theta) * np.cos(phi)**2 * np.sin(theta) + 2 * np.cos( 2 * theta) * np.sin(phi) Ag[0] = 2 * np.cos(phi) * (np.cos(theta) - 3 * np.sin(theta) * np.sin(phi)) assert np.allclose(A['g'], Ag)
def test_ball_diffusion(Lmax, Nmax, Leig, radius, bc, dtype): # Bases c = coords.SphericalCoordinates('phi', 'theta', 'r') d = distributor.Distributor((c, )) b = basis.BallBasis(c, (2 * (Lmax + 1), Lmax + 1, Nmax + 1), radius=radius, dtype=dtype) b_S2 = b.S2_basis() phi, theta, r = b.local_grids((1, 1, 1)) # Fields A = field.Field(dist=d, bases=(b, ), tensorsig=(c, ), dtype=dtype) φ = field.Field(dist=d, bases=(b, ), dtype=dtype) τ_A = field.Field(dist=d, bases=(b_S2, ), tensorsig=(c, ), dtype=dtype) λ = field.Field(name='λ', dist=d, dtype=dtype) # Parameters and operators div = lambda A: operators.Divergence(A) grad = lambda A: operators.Gradient(A, c) curl = lambda A: operators.Curl(A) lap = lambda A: operators.Laplacian(A, c) trans = lambda A: operators.TransposeComponents(A) radial = lambda A, index: operators.RadialComponent(A, index=index) angular = lambda A, index: operators.AngularComponent(A, index=index) Lift = lambda A: operators.Lift(A, b, -1) # Problem problem = problems.EVP([φ, A, τ_A], λ) problem.add_equation((div(A), 0)) problem.add_equation((-λ * A + grad(φ) - lap(A) + Lift(τ_A), 0)) if bc == 'no-slip': problem.add_equation((A(r=radius), 0)) elif bc == 'stress-free': E = 1 / 2 * (grad(A) + trans(grad(A))) problem.add_equation((radial(A(r=radius), 0), 0)) problem.add_equation((radial(angular(E(r=radius), 0), 1), 0)) elif bc == 'potential': ell_func = lambda ell: ell + 1 ell_1 = lambda A: operators.SphericalEllProduct(A, c, ell_func) problem.add_equation( (radial(grad(A)(r=radius), 0) + ell_1(A)(r=radius) / radius, 0)) elif bc == 'conducting': problem.add_equation((φ(r=radius), 0)) problem.add_equation((angular(A(r=radius), 0), 0)) elif bc == 'pseudo': problem.add_equation((radial(A(r=radius), 0), 0)) problem.add_equation((angular(curl(A)(r=radius), 0), 0)) # Solver solver = solvers.EigenvalueSolver(problem) if not solver.subproblems[Leig].group[1] == Leig: raise ValueError("subproblems indexed in a strange way") solver.solve_dense(solver.subproblems[Leig]) i_sort = np.argsort(solver.eigenvalues) solver.eigenvalues = solver.eigenvalues[i_sort] λ_analytic = analytic_eigenvalues(Leig, Nmax + 1, bc, r0=radius) if (bc == 'stress-free' and Leig == 1): # add null space solution λ_analytic = np.append(0, λ_analytic) assert np.allclose(solver.eigenvalues[:Nmax // 4], λ_analytic[:Nmax // 4])
def test_radial_component_vector(Nphi, Nr, k, dealias, dtype, basis, radius): c, d, b, phi, r, x, y = basis(Nphi, Nr, k, dealias, dtype) cp, sp = np.cos(phi), np.sin(phi) u = field.Field(dist=d, bases=(b, ), tensorsig=(c, ), dtype=dtype) u.preset_scales(b.domain.dealias) ex = np.array([-np.sin(phi), np.cos(phi)]) ey = np.array([np.cos(phi), np.sin(phi)]) u['g'] = (x**2 * y - 2 * x * y**5) * ex + (x**2 * y + 7 * x**3 * y**2) * ey v = operators.RadialComponent(operators.interpolate(u, r=radius)).evaluate() vg = (radius**3 * cp**2 * sp - 2 * radius**6 * cp * sp**5) * cp + ( radius**3 * cp**2 * sp + 7 * radius**5 * cp**3 * sp**2) * sp assert np.allclose(v['g'], vg)
def test_radial_component_tensor(Nphi, Nr, k, dealias, dtype, basis, radius): c, d, b, phi, r, x, y = basis(Nphi, Nr, k, dealias, dtype) cp, sp = np.cos(phi), np.sin(phi) T = field.Field(dist=d, bases=(b, ), tensorsig=(c, c), dtype=dtype) T.preset_scales(b.domain.dealias) ex = np.array([-np.sin(phi), np.cos(phi)]) ey = np.array([np.cos(phi), np.sin(phi)]) exex = ex[:, None, ...] * ex[None, ...] exey = ex[:, None, ...] * ey[None, ...] eyex = ey[:, None, ...] * ex[None, ...] eyey = ey[:, None, ...] * ey[None, ...] T['g'] = (3 * x**2 + y) * exex + y**3 * exey + x**2 * y**2 * eyex + ( y**5 - 2 * x * y) * eyey A = operators.RadialComponent(operators.interpolate(T, r=radius)).evaluate() Ag = ( 3 * radius**2 * cp**2 + radius * sp ) * cp * ex + radius**3 * sp**3 * cp * ey + radius**4 * cp**2 * sp**2 * sp * ex + ( radius**5 * sp**5 - 2 * radius**2 * cp * sp) * sp * ey assert np.allclose(A['g'], Ag)
def test_radial_component_vector(Nphi, Ntheta, Nr, k, dealias, dtype, basis, radius): c, d, b, phi, theta, r, x, y, z = basis(Nphi, Ntheta, Nr, k, dealias, dtype) ct, st, cp, sp = np.cos(theta), np.sin(theta), np.cos(phi), np.sin(phi) u = field.Field(dist=d, bases=(b, ), tensorsig=(c, ), dtype=dtype) u.preset_scales(b.domain.dealias) u['g'][2] = r**2 * st * (2 * ct**2 * cp - r * ct**3 * sp + r**3 * cp**3 * st**5 * sp**3 + r * ct * st**2 * (cp**3 + sp**3)) u['g'][1] = r**2 * (2 * ct**3 * cp - r * cp**3 * st**4 + r**3 * ct * cp**3 * st**5 * sp**3 - 1 / 16 * r * np.sin(2 * theta)**2 * (-7 * sp + np.sin(3 * phi))) u['g'][0] = r**2 * sp * (-2 * ct**2 + r * ct * cp * st**2 * sp - r**3 * cp**2 * st**5 * sp**3) v = operators.RadialComponent(operators.interpolate(u, r=radius)).evaluate() vg = radius**2 * st * (2 * ct**2 * cp - radius * ct**3 * sp + radius**3 * cp**3 * st**5 * sp**3 + radius * ct * st**2 * (cp**3 + sp**3)) assert np.allclose(v['g'], vg)
B['g'][1] = -3. / 2. * r * (-1 + 4 * r**2 - 6 * r**4 + 3 * r**6) * (np.cos(phi) + np.sin(phi)) B['g'][0] = -3./4.*r*(-1+r**2)*np.cos(theta)* \ ( 3*r*(2-5*r**2+4*r**4)*np.sin(theta) +2*(1-3*r**2+3*r**4)*(np.cos(phi)-np.sin(phi))) # Potential BC on A ell_func = lambda ell: ell + 1 # Parameters and operators div = lambda A: operators.Divergence(A) grad = lambda A: operators.Gradient(A, c) curl = lambda A: operators.Curl(A) LiftTau = lambda A: operators.LiftTau(A, b, -1) ellp1 = lambda A: operators.SphericalEllProduct(A, c, ell_func) radial = lambda A: operators.RadialComponent(A) angular = lambda A: operators.AngularComponent(A, index=1) # BVP for initial A BVP = problems.LBVP([φ, A, τ_A, τ_φ]) #BVP.add_equation((angular(τ_A),0)) BVP.add_equation((div(A) + LiftTau(τ_φ), 0)) BVP.add_equation((curl(A) + grad(φ) + LiftTau(τ_A), B)) BVP.add_equation((radial(grad(A)(r=radius)) + ellp1(A)(r=radius) / radius, 0)) #, condition = "ntheta != 0") BVP.add_equation((φ(r=radius), 0)) #, condition = "ntheta == 0") solver = solvers.LinearBoundaryValueSolver(BVP) solver.solve() plot_matrices = False
(147 - 343 * r**2 + 217 * r**4 - 29 * r**6) * np.sin(phi))) u['g'][1] = -10 * r**2 / 7 / np.sqrt(3) * np.cos(theta) * ( 3 * (-147 + 343 * r**2 - 217 * r**4 + 29 * r**6) * np.cos(phi) + 14 * (-9 - 125 * r**2 + 39 * r**4 + 27 * r**6) * np.sin(phi)) T_source = field.Field(dist=d, bases=(b, ), dtype=dtype) T_source['g'] = Source # initial toroidal magnetic field # B['g'][0] = -3./4.*r*(-1+r**2)*np.cos(theta)* \ # ( 3*r*(2-5*r**2+4*r**4)*np.sin(theta) # +2*(1-3*r**2+3*r**4)*(np.cos(phi)-np.sin(phi))) # B['g'][1] = -3./2.*r*(-1+4*r**2-6*r**4+3*r**6)*(np.cos(phi)+np.sin(phi)) # Boundary conditions u_r_bc = operators.RadialComponent(operators.interpolate(u, r=1)) stress = operators.Gradient(u, c) + operators.TransposeComponents( operators.Gradient(u, c)) u_perp_bc = operators.RadialComponent( operators.AngularComponent(operators.interpolate(stress, r=1), index=1)) # Potential BC on B r_out = 1 ell_func = lambda ell: ell + 1 A_potential_bc = operators.RadialComponent( operators.interpolate(operators.Gradient( A, c), r=1)) + operators.interpolate( operators.SphericalEllProduct(A, c, ell_func), r=1) / r_out # Parameters and operators
tau_T = field.Field(dist=d, bases=(b_S2, ), dtype=np.complex128) r_vec = field.Field(dist=d, bases=(b, ), tensorsig=(c, ), dtype=np.complex128) r_vec['g'][2] = r T['g'] = 0.5 * (1 - r**2) + 0.1 / 8 * np.sqrt(35 / np.pi) * r**3 * ( 1 - r**2) * (np.cos(3 * phi) + np.sin(3 * phi)) * np.sin(theta)**3 T_source = field.Field(dist=d, bases=(b, ), dtype=np.complex128) T_source['g'] = 3 # Potential BC on u r_out = 1 ell_func = lambda ell: ell + 1 u_potential_bc = operators.RadialComponent( operators.interpolate(operators.Gradient( u, c), r=1)) + operators.interpolate( operators.SphericalEllProduct(u, c, ell_func), r=1) / r_out # Parameters and operators ez = field.Field(dist=d, bases=(b, ), tensorsig=(c, ), dtype=np.complex128) ez['g'][1] = -np.sin(theta) ez['g'][2] = np.cos(theta) div = lambda A: operators.Divergence(A, index=0) lap = lambda A: operators.Laplacian(A, c) grad = lambda A: operators.Gradient(A, c) dot = lambda A, B: arithmetic.DotProduct(A, B) cross = lambda A, B: arithmetic.CrossProduct(A, B) ddt = lambda A: operators.TimeDerivative(A) LiftTau = lambda A: operators.LiftTau(A, b, -1)
B['g'][1] = 5 / 8 * (9 * r - 8 * r_outer - r_inner**4 / r**3) * np.sin(theta) B['g'][2] = 5 / 8 * (8 * r_outer - 6 * r - 2 * r_inner**4 / r**3) * np.cos(theta) # Parameters and operators div = lambda A: operators.Divergence(A, index=0) lap = lambda A: operators.Laplacian(A, c) grad = lambda A: operators.Gradient(A, c) dot = lambda A, B: arithmetic.DotProduct(A, B) cross = lambda A, B: arithmetic.CrossProduct(A, B) ddt = lambda A: operators.TimeDerivative(A) curl = lambda A: operators.Curl(A) ell_func = lambda ell: ell + 1 A_potential_bc_outer = operators.RadialComponent( operators.interpolate(operators.Gradient( A, c), r=r_outer)) + operators.interpolate( operators.SphericalEllProduct(A, c, ell_func), r=r_outer) / r_outer A_potential_bc_inner = operators.RadialComponent( operators.interpolate(operators.Gradient( A, c), r=r_inner)) + operators.interpolate( operators.SphericalEllProduct(A, c, ell_func), r=r_inner) / r_inner # Problem def eq_eval(eq_str): return [eval(expr) for expr in split_equation(eq_str)] V = de.field.Field(dist=d, bases=(b, ), dtype=np.complex128)