Coverage for tests/test_pscattering.py: 0%

1 import typing

2

3 import numpy as np

4 import pytest

5

6 import swiift.lib.phase_shift as ps

7

8 random_handlers = (

9 ps.UniformScatteringHandler,

10 ps.PerturbationScatteringHandler,

11)

12

13 edge_amplitudes = (

14 np.array(1.5 + 1.8j),

15 np.array([0.11833799 + 0.63103069j, 0.78585931 + 0.84839417j]),

16)

17 c_wavenumbers = (

18 np.array(0.78032224 + 0.85889267j),

19 np.array([0.10716051 + 0.7798643j, 0.54648262 + 0.94570875j]),

20)

21 xfs = (

22 np.array([11.1]),

23 np.array([4.7, 8.3]),

24 np.array([2.2, 6.4, 9.3]),

25)

26

27

28@pytest.mark.parametrize(

29 "edge_amplitudes, c_wavenumbers", zip(edge_amplitudes, c_wavenumbers)

30)

31@pytest.mark.parametrize("xf", xfs)

32 def test_continuity(

33 edge_amplitudes: np.ndarray, c_wavenumbers: np.ndarray, xf: np.ndarray

34):

35 # Verify that when no scattering is used, the right edge of the left floe

36 # is in the same state as the left edge of the right floe. That is, the

37 # complex amplitude advected from the left edge of the left floe is equal to the

38 # amplitude at the left edge of the right floe.

39 post_amplitudes = ps.ContinuousScatteringHandler().compute_edge_amplitudes(

40 edge_amplitudes, c_wavenumbers, xf

41 )

42 for xl, xr, pl, pr in zip(

43 xf[:-1], xf[1:], post_amplitudes[:-1], post_amplitudes[1:]

44 ):

45 assert np.allclose(pl * np.exp(1j * c_wavenumbers * (xr - xl)) - pr, 0)

46

47

48@pytest.mark.parametrize("handler_type", random_handlers)

49@pytest.mark.parametrize(

50 "edge_amplitudes, c_wavenumbers", zip(edge_amplitudes, c_wavenumbers)

51)

52@pytest.mark.parametrize("xf", xfs)

53 def test_absolute_value_continuity(

54 handler_type: typing.Type[ps._RandomScatteringHandler],

55 edge_amplitudes: np.ndarray,

56 c_wavenumbers: np.ndarray,

57 xf: np.ndarray,

58):

59 # Verify that when scattering is used, the amplitude at the right edge of

60 # the left floe is equal, in amplitude, and different, in phase, from the

61 # amplitude at the left edge of the right floe.

62 seed = 3103

63 random_handler = handler_type.from_seed(seed)

64 pa_continuous = ps.ContinuousScatteringHandler().compute_edge_amplitudes(

65 edge_amplitudes, c_wavenumbers, xf

66 )

67 pa_random = random_handler.compute_edge_amplitudes(

68 edge_amplitudes, c_wavenumbers, xf

69 )

70 for pac, par in zip(pa_continuous[1:], pa_random[1:]):

71 assert not np.allclose(pac - par, 0)

72 assert np.allclose(np.abs(pac) - np.abs(par), 0)

73

74

75@pytest.mark.parametrize("random_handler", random_handlers)

76@pytest.mark.parametrize(

77 "edge_amplitudes, c_wavenumbers", zip(edge_amplitudes, c_wavenumbers)

78)

79@pytest.mark.parametrize("xf", xfs)

80 def test_repeatability(

81 random_handler: typing.Type[ps._RandomScatteringHandler],

82 edge_amplitudes,

83 c_wavenumbers,

84 xf,

85):

86 # Verify that two random scattering handlers return the same result when

87 # computing the amplitudes from a generator seeded with the same number.

88 seed = 83

89

90 handler1 = random_handler.from_seed(seed)

91 test1 = handler1.compute_edge_amplitudes(edge_amplitudes, c_wavenumbers, xf)

92

93 handler2 = random_handler.from_seed(seed)

94 test2 = handler2.compute_edge_amplitudes(edge_amplitudes, c_wavenumbers, xf)

95

96 assert np.allclose(test1 - test2, 0)