def test_subtract_mean_of_sinkx_plus_constant_equals_sinkx(): L = 2.0 N = 128 st = ScalarTool(N, L) sinkx = np.sin((2 * np.pi / L) * st.X[0]) th = sinkx + 10.0 assert np.allclose(st.subtract_mean(th), sinkx)
def test_st_ifft_of_function_is_real(): L = 10.5 N = 128 k = 2.0 * np.pi / L X = np.mgrid[:N, :N].astype(float) * (L / N) th = np.sin(k * X[0]) st = ScalarTool(N, L) assert np.all(np.isreal(st.ifft(st.fft(th))))
def test_integral_of_sinkx(): L = 10.5 N = 128 k = 2.0 * np.pi / L X = np.mgrid[:N, :N].astype(float) * (L / N) th = np.sin(k * X[0]) st = ScalarTool(N, L) assert np.isclose(st.sint(th), 0.0)
def test_h1norm_of_sinkx_is_sqrt_of_half_of_Lsq_multiplied_by_k(): L = 2.0 * np.pi N = 128 k = 10.0 * np.pi / L X = np.mgrid[:N, :N].astype(float) * (L / N) th = np.sin(k * X[0]) st = ScalarTool(N, L) assert math.isclose(st.h1norm(th), (0.5 * L**2)**0.5 * k)
def test_that_l2norm_of_sinx_on_domain_with_L_of_2pi_equals_sqrt_of_half_of_Lsq( ): L = 2.0 * np.pi N = 128 st = ScalarTool(N, L) X = np.mgrid[:N, :N].astype(float) * (L / N) th = np.sin(2.0 * np.pi * X[0] / L) assert math.isclose(st.l2norm(th), (0.5 * L**2)**0.5)
def test_lap_invlap_of_th_is_th_minus_mean_value(): L = 2.0 * np.pi N = 128 st = ScalarTool(N, L) th = np.random.random((N, N)) assert np.allclose(st.lap(st.invlap(th)), st.subtract_mean(th))
def test_ifft_of_fft_equals_original_scalar_function(): L = 10.5 N = 128 k = 2.0 * np.pi / L X = np.mgrid[:N, :N].astype(float) * (L / N) th = np.sin(k * X[0]) st = ScalarTool(N, L) assert np.allclose(st.ifft(st.fft(th)), th)
def test_get_spectrum_includes_Nyquist_mode(): L = 10.5 N = 128 k = int(N / 2) * 2.0 * np.pi / L st = ScalarTool(N, L) th = np.cos(k * st.X[0]) # SIN(K X) [klist, spectrum] = st.get_spectrum(th) spectrum_expected = np.zeros(len(klist)) spectrum_expected[int(N / 2)] = 2.0 assert np.allclose(spectrum, spectrum_expected)
def test_l2norm_of_a_scalar_should_be_nearly_invariant_of_discretization(): L = 10.0 Narray = np.array([64, 128, 256, 512]).astype('int') l2norm = np.zeros(len(Narray)) for i, N in enumerate(Narray): st = ScalarTool(N, L) X = np.mgrid[:N, :N].astype(float) * (L / N) th = np.sin(2.0 * np.pi * X[0] / L) l2norm[i] = st.l2norm(th) assert np.allclose(l2norm[-1], l2norm)
def test_get_spectrum_of_sinkx(): L = 10.5 N = 128 k = int(N / 4) * 2.0 * np.pi / L st = ScalarTool(N, L) th = np.sin(k * st.X[0]) # SIN(K X) [klist, spectrum] = st.get_spectrum(th) spectrum_expected = np.zeros(len(klist)) spectrum_expected[int(N / 4)] = 1.0 assert np.allclose(spectrum, spectrum_expected)
def test_dealias_of_sinkx_where_k_is_above_two_thirds_dealias_boundary_is_zero_y_direction( ): L = 2.0 * np.pi N = 128 st = ScalarTool(N, L) kabove = np.ceil(st.kmax_dealias) + 1 th = np.sin(2. * np.pi / L * kabove * st.X[1]) z = np.zeros(th.shape) assert np.allclose(st.dealias(th), z)
def test_dealias_of_sinkx_where_k_is_below_two_thirds_dealias_boundary_is_zero_y_direction( ): L = 2.0 * np.pi N = 128 st = ScalarTool(N, L) k = np.floor(st.kmax_dealias) - 1 th = np.sin(2. * np.pi / L * k * st.X[1]) z = np.zeros(th.shape) assert not np.allclose(st.dealias(th), z)
def test_laplacian_of_sinkx_is_neq_ksq_times_sinkx(): L = 10.5 N = 128 k = 2.0 * np.pi / L X = np.mgrid[:N, :N].astype(float) * (L / N) th = np.sin(k * X[0]) st = ScalarTool(N, L) lapth = st.lap(th) assert np.allclose(lapth, -k**2 * np.sin(k * X[0]))
def test_yderivative_of_sinky_is_kcosky(): L = 10.5 N = 128 k = 2.0 * np.pi / L X = np.mgrid[:N, :N].astype(float) * (L / N) th = np.sin(k * X[1]) st = ScalarTool(N, L) gradth = st.grad(th) assert np.allclose(gradth[1], k * np.cos(k * X[1]))
def test_curl_is_equal_to_curl_computed_with_grad_function(): N = 128 L = 2.0 kappa = 0.0 gamma = 1.0 v = np.random.random((2, N, N)) # print(np.shape(v)) st = ScalarTool(N, L) vt = VectorTool(N, L) v = vt.div_free_proj(v) v = vt.dealias(v) c = st.grad(v[1])[0] - st.grad(v[0])[1] assert np.allclose(c, vt.curl(v))
def test_that_sinx_on_domain_with_L_of_2pi_has_equal_norms(): L = 2.0 * np.pi N = 128 st = ScalarTool(N, L) X = np.mgrid[:N, :N].astype(float) * (L / N) th = np.sin(2.0 * np.pi * X[0] / L) l2norm = st.l2norm(th) h1norm = st.h1norm(th) hm1norm = st.hm1norm(th) print(l2norm) print(h1norm) print(hm1norm) assert (math.isclose(l2norm, h1norm) and math.isclose(l2norm, hm1norm))
def test_h1normsq_of_vector_is_spatial_integral_neg_lapvec_times_vec(): N = 128 L = 2.0 kappa = 0.0 gamma = 1.0 v = np.random.random((2, N, N)) st = ScalarTool(N, L) vt = VectorTool(N, L) v = vt.div_free_proj(v) v = vt.dealias(v) a = vt.h1norm(v)**2 b = st.sint(np.sum(-vt.lap(v) * v, 0)) assert np.allclose(a, b)
def test_l2norm_squared_of_curl_of_vector_is_spatial_integral_of_neg_vector_times_lap_vector( ): N = 128 L = 2.0 kappa = 0.0 gamma = 1.0 v = np.random.random((2, N, N)) # print(np.shape(v)) st = ScalarTool(N, L) vt = VectorTool(N, L) v = vt.div_free_proj(v) v = vt.dealias(v) curl = vt.curl(v) a = st.l2norm(curl)**2. b = st.sint(np.sum(-vt.lap(v) * v, 0)) assert np.allclose(a, b)
def test_validate_div_free_projector(): L = 2.0 * np.pi N = 128 st = ScalarTool(N, L) vt = VectorTool(N, L) u = np.zeros((2, N, N)) # Compressible flow u[0] = np.sin((2.0 * np.pi / L) * vt.X[0]) * \ np.sin((2.0 * np.pi / L) * vt.X[1]) u[1] = -np.cos((2.0 * np.pi / L) * vt.X[0]) * \ np.cos((2.0 * np.pi / L) * vt.X[1]) w = np.zeros((2, N, N)) w[0] = np.sin((2.0 * np.pi / L) * vt.X[0]) * \ np.sin((2.0 * np.pi / L) * vt.X[1]) w[1] = np.cos((2.0 * np.pi / L) * vt.X[0]) * \ np.cos((2.0 * np.pi / L) * vt.X[1]) u = u + 0.1 * w projection_alt = u - st.grad_invlap(vt.div(u)) print(np.amax(abs(projection_alt - vt.div_free_proj(u)))) assert np.allclose(projection_alt, vt.div_free_proj(u))
def test_spatial_integral_of_neg_invlap_th_time_th_equals_hm1_norm_sq(): L = 2.0 * np.pi N = 128 st = ScalarTool(N, L) th = np.random.random((N, N)) th = st.dealias(th) a = st.sint(-1.0 * st.invlap(th) * th) b = st.hm1norm(th)**2. print(a, b) assert np.allclose(a, b)
def test_integral_of_one(): L = 10.5 N = 128 integrand = np.ones((N, N)) st = ScalarTool(N, L) assert np.isclose(st.sint(integrand), L**2.0)
def test_check_no_spectral_blocking_positive_codition(): N = 64 L = 1.0 st = ScalarTool(N, L) th = np.sin((N / 2 - 2) * (2. * np.pi / L) * st.X[0]) assert st.isblocked(th)
def test_check_no_spectral_blocking_negative_codition(): N = 64 L = 1.0 st = ScalarTool(N, L) th = np.zeros((N, N)) assert (not st.isblocked(th))