Beispiel #1
0
def test_except():
    grid = Grid()

    with pytest.raises(ValueError):
        grid.bins = 1, 1, 1

    with pytest.raises(ValueError):
        grid.bins = 2, 3, 4, 5

    with pytest.raises(ValueError):
        grid.ll = 1, 2

    with pytest.raises(ValueError):
        grid.lr = 1, 2, 3, 4

    with pytest.raises(ValueError):
        grid.ul = 1,

    with pytest.raises(ValueError):
        grid.tl = 1, 2, 3, 4, 5

    with pytest.raises(ValueError):
        grid.ul = 1, 0, 0

    with pytest.raises(ValueError):
        grid.lr = 0, 0, 0
Beispiel #2
0
def test_init_1D():
    grid = Grid()

    # Set to 1D
    grid.bins = 101
    assert_array_equal(grid.bins, [101, 1, 1])
    assert_array_equal(grid.ll, [0, 0, 0])
    assert_array_equal(grid.lr, [1, 0, 0])
    assert_array_equal(grid.ul, [0, 1, 0])
    assert_array_equal(grid.tl, [0, 0, 1])
    assert_array_equal(grid.v1, [1, 0, 0])
    assert_array_equal(grid.v2, [0, 1, 0])
    assert_array_equal(grid.v3, [0, 0, 1])
    assert_array_equal(grid.r1, np.linspace(0, 1, 101))
    assert_array_equal(grid.r2, [0])
    assert_array_equal(grid.r3, [0])
    assert_array_equal(grid.get_axes_names(), ['[1 0 0]',
                                               '[0 1 0]',
                                               '[0 0 1]'])
    qx, qy, qz = grid.get_q_meshgrid()
    assert_array_equal(qx, np.linspace(0, 1, 101).reshape((101, 1, 1)))
    assert_array_equal(qy, np.zeros((101, 1, 1)))
    assert_array_equal(qz, np.zeros((101, 1, 1)))
    qx, qy, qz = grid.get_squashed_q_meshgrid()
    assert_array_equal(qx, np.reshape(np.linspace(0, 1, 101), (101, 1, 1)))
    assert_array_equal(qy, [[[0]]])
    assert_array_equal(qz, [[[0]]])
Beispiel #3
0
def test_complete_3D():
    grid = Grid()

    grid.set_corners(ll=[-2, -3, -4],
                     lr=[2, -3, -4],
                     ul=[-2, 3, -4],
                     tl=[-2, -3, 4])
    grid.bins = 3, 4, 5

    assert_array_equal(grid.bins, [3, 4, 5])
    assert_array_equal(grid.ll, [-2, -3, -4])
    assert_array_equal(grid.lr, [2, -3, -4])
    assert_array_equal(grid.ul, [-2, 3, -4])
    assert_array_equal(grid.tl, [-2, -3, 4])
    assert_array_equal(grid.v1, [1, 0, 0])
    assert_array_equal(grid.v2, [0, 1, 0])
    assert_array_equal(grid.v3, [0, 0, 1])
    assert_array_equal(grid.r1, [-2, 0, 2])
    assert_array_equal(grid.r2, [-3, -1, 1, 3])
    assert_array_equal(grid.r3, [-4, -2, 0, 2, 4])
    assert_array_equal(grid.get_axes_names(), ['[ 1.  0.  0.]',
                                               '[ 0.  1.  0.]',
                                               '[ 0.  0.  1.]'])
    qx, qy, qz = grid.get_q_meshgrid()
    assert_array_equal(qx, np.transpose(np.tile([-2, 0, 2], (5, 4, 1))))
    assert_array_equal(qy, np.transpose(np.tile([-3, -1, 1, 3], (3, 5, 1)), axes=(0, 2, 1)))
    assert_array_almost_equal(qz, np.tile([-4, -2, 0, 2, 4], (3, 4, 1)))
    qx, qy, qz = grid.get_squashed_q_meshgrid()
    assert_array_equal(qx, [[[-2.]], [[0.]], [[2.]]])
    assert_array_equal(qy, [[[-3.], [-1.], [1.], [3.]]])
    assert_array_equal(qz, [[[-4., -2., 0., 2., 4.]]])
Beispiel #4
0
def test_complete_1D():
    grid = Grid()

    grid.set_corners(lr=(2, 2, 0))
    grid.bins = 3

    assert_array_equal(grid.bins, [3, 1, 1])
    assert_array_equal(grid.ll, [0, 0, 0])
    assert_array_equal(grid.lr, [2, 2, 0])
    assert_array_equal(grid.ul, [0, 0, 0])
    assert_array_equal(grid.tl, [0, 0, 0])
    assert_array_equal(grid.v1, [1, 1, 0])
    assert_array_almost_equal(grid.v2, [1, 0, 0])
    assert_array_equal(grid.v3, [0, 0, 1])
    assert_array_almost_equal(grid.r1, np.linspace(0, 2, 3))
    assert_array_almost_equal(grid.r2, [0])
    assert_array_equal(grid.r3, [0])
    assert_array_equal(grid.get_axes_names(), ['[ 1.  1.  0.]',
                                               '[ 1.  0.  0.]',
                                               '[ 0.  0.  1.]'])
    qx, qy, qz = grid.get_q_meshgrid()
    assert_array_almost_equal(qx, [[[0]], [[1]], [[2]]])
    assert_array_almost_equal(qy, [[[0]], [[1]], [[2]]])
    assert_array_equal(qz, np.zeros((3, 1, 1)))
    qx, qy, qz = grid.get_squashed_q_meshgrid()
    assert_array_almost_equal(qx, [[[0]], [[1]], [[2]]])
    assert_array_almost_equal(qy, [[[0]], [[1]], [[2]]])
    assert_array_equal(qz, [[[0]]])
Beispiel #5
0
def test_complete_3D():
    grid = Grid()

    grid.ll = -2, -3, -4
    grid.lr = 2, -3, -4
    grid.ul = -2, 3, -4
    grid.tl = -2, -3, 4
    grid.bins = 3, 4, 5

    assert_array_equal(grid.bins, [3, 4, 5])
    assert not grid.twoD
    assert_array_equal(grid.ll, [-2, -3, -4])
    assert_array_equal(grid.lr, [2, -3, -4])
    assert_array_equal(grid.ul, [-2, 3, -4])
    assert_array_equal(grid.tl, [-2, -3, 4])
    assert_array_equal(grid.v1, [1, 0, 0])
    assert_array_equal(grid.v2, [0, 1, 0])
    assert_array_equal(grid.v3, [0, 0, 1])
    assert_array_equal(grid.r1, [0., 2., 4.])
    assert_array_equal(grid.r2, [0., 2., 4., 6.])
    assert_array_equal(grid.r3, [0., 2., 4., 6., 8.])
    assert_array_equal(grid.get_axis_names(), [
        '[-2 -3 -4] + x[ 1.  0.  0.]', '[-2 -3 -4] + y[ 0.  1.  0.]',
        '[-2 -3 -4] + z[ 0.  0.  1.]'
    ])
    qx, qy, qz = grid.get_q_meshgrid()
    assert_array_equal(qx, np.transpose(np.tile([-2, 0, 2], (5, 4, 1))))
    assert_array_equal(
        qy, np.transpose(np.tile([-3, -1, 1, 3], (3, 5, 1)), axes=(0, 2, 1)))
    assert_array_almost_equal(qz, np.tile([-4, -2, 0, 2, 4], (3, 4, 1)))
    qx, qy, qz = grid.get_squashed_q_meshgrid()
    assert_array_equal(qx, [[[-2.]], [[0.]], [[2.]]])
    assert_array_equal(qy, [[[-3.], [-1.], [1.], [3.]]])
    assert_array_equal(qz, [[[-4., -2., 0., 2., 4.]]])
Beispiel #6
0
def test_init_3D():
    grid = Grid()

    # Set to 3D
    grid.bins = 101, 101, 101
    assert_array_equal(grid.r1, np.linspace(0, 1, 101))
    assert_array_equal(grid.r2, np.linspace(0, 1, 101))
    assert_array_equal(grid.r3, np.linspace(0, 1, 101))
    qx, qy, qz = grid.get_q_meshgrid()
    q = np.tile(np.linspace(0, 1, 101), (101, 101, 1))
    assert_array_equal(qx, np.transpose(q))
    assert_array_equal(qy, np.transpose(q, axes=(0, 2, 1)))
    assert_array_equal(qz, q)
    qx, qy, qz = grid.get_squashed_q_meshgrid()
    assert_array_equal(qx, np.reshape(np.linspace(0, 1, 101), (101, 1, 1)))
    assert_array_equal(qy, np.reshape(np.linspace(0, 1, 101), (1, 101, 1)))
    assert_array_equal(qz, np.reshape(np.linspace(0, 1, 101), (1, 1, 101)))
Beispiel #7
0
def test_init_3D():
    grid = Grid()

    # Set to 3D
    grid.bins = 101, 101, 101
    assert not grid.twoD
    assert_array_equal(grid.r1, np.linspace(0, 1, 101))
    assert_array_equal(grid.r2, np.linspace(0, 1, 101))
    assert_array_equal(grid.r3, np.linspace(0, 1, 101))
    qx, qy, qz = grid.get_q_meshgrid()
    q = np.tile(np.linspace(0, 1, 101), (101, 101, 1))
    assert_array_equal(qx, np.transpose(q))
    assert_array_equal(qy, np.transpose(q, axes=(0, 2, 1)))
    assert_array_equal(qz, q)
    qx, qy, qz = grid.get_squashed_q_meshgrid()
    assert_array_equal(qx, np.reshape(np.linspace(0, 1, 101), (101, 1, 1)))
    assert_array_equal(qy, np.reshape(np.linspace(0, 1, 101), (1, 101, 1)))
    assert_array_equal(qz, np.reshape(np.linspace(0, 1, 101), (1, 1, 101)))
Beispiel #8
0
def test_except():
    grid = Grid()

    with pytest.raises(ValueError):
        grid.bins = 2, 3, 4, 5

    with pytest.raises(ValueError):
        grid.set_corners(ll=(1, 2))

    with pytest.raises(ValueError):
        grid.set_corners(lr=(1, 2, 3, 4))

    with pytest.raises(ValueError):
        grid.set_corners(lr=(1, 1, 0), ul=(1,))

    with pytest.raises(ValueError):
        grid.set_corners(lr=(1, 0, 1), ul=(0, 1, 0), tl=(1, 2, 3, 4, 5))

    with pytest.raises(ValueError):
        grid.set_corners(lr=(1, 0, 0), ul=(1, 0, 0))

    with pytest.raises(ValueError):
        grid.set_corners(lr=(0, 0, 0))

    with pytest.raises(ValueError):
        grid.set_corners(lr=(1, 0, 0), ul=(0, 1, 0), tl=(0, 1, 0))

    with pytest.raises(ValueError):
        grid.v1 = 1,

    with pytest.raises(ValueError):
        grid.v2 = 1, 2

    with pytest.raises(ValueError):
        grid.v3 = 1, 2, 3, 4

    with pytest.raises(ValueError):
        grid.r1 = 1,

    with pytest.raises(ValueError):
        grid.r2 = 1, 2, 3

    with pytest.raises(ValueError):
        grid.r3 = 1, 2, 3, 4
Beispiel #9
0
def test_complete():
    grid = Grid()

    grid.ll = 0, 0, 0
    grid.lr = 2, 2, 0
    grid.ul = 3, -3, 0
    grid.bins = 3, 4

    assert_array_equal(grid.bins, [3, 4])
    assert grid.twoD
    assert_array_equal(grid.ll, [0, 0, 0])
    assert_array_equal(grid.lr, [2, 2, 0])
    assert_array_equal(grid.ul, [3, -3, 0])
    assert_array_equal(grid.tl, [0, 0, 1])
    assert_array_equal(grid.v1, [1 / np.sqrt(2), 1 / np.sqrt(2), 0])
    assert_array_almost_equal(grid.v2, [1 / np.sqrt(2), -1 / np.sqrt(2), 0])
    assert_array_equal(grid.v3, [0, 0, 1])
    assert_array_almost_equal(grid.r1, np.linspace(0, 2 * np.sqrt(2), 3))
    assert_array_almost_equal(grid.r2, np.linspace(0, 3 * np.sqrt(2), 4))
    assert_array_equal(grid.r3, [0])
    assert_array_equal(grid.get_axis_names(), [
        '[0 0 0] + x[ 0.70710678  0.70710678  0.        ]',
        '[0 0 0] + y[ 0.70710678 -0.70710678  0.        ]',
        '[0 0 0] + z[0 0 1]'
    ])
    qx, qy, qz = grid.get_q_meshgrid()
    assert_array_equal(qx,
                       [[0., 1., 2., 3.], [1., 2., 3., 4.], [2., 3., 4., 5.]])
    assert_array_equal(
        qy, [[0., -1., -2., -3.], [1., 0., -1., -2.], [2., 1., 0., -1.]])
    assert_array_equal(qz, np.zeros((3, 4)))
    qx, qy, qz = grid.get_squashed_q_meshgrid()
    assert_array_equal(qx,
                       [[0., 1., 2., 3.], [1., 2., 3., 4.], [2., 3., 4., 5.]])
    assert_array_equal(
        qy, [[0., -1., -2., -3.], [1., 0., -1., -2.], [2., 1., 0., -1.]])
    assert_array_equal(qz, [[0]])
Beispiel #10
0
def test_complete():
    grid = Grid()

    grid.set_corners(lr=(2, 2, 0), ul=(3, -3, 0))
    grid.bins = 3, 4

    assert_array_equal(grid.bins, [3, 4, 1])
    assert_array_equal(grid.ll, [0, 0, 0])
    assert_array_equal(grid.lr, [2, 2, 0])
    assert_array_equal(grid.ul, [3, -3, 0])
    assert_array_equal(grid.tl, [0, 0, 0])
    assert_array_equal(grid.v1, [1, 1, 0])
    assert_array_almost_equal(grid.v2, [1, -1, 0])
    assert_array_equal(grid.v3, [0, 0, -1])
    assert_array_almost_equal(grid.r1, np.linspace(0, 2, 3))
    assert_array_almost_equal(grid.r2, np.linspace(0, 3, 4))
    assert_array_equal(grid.r3, [0])
    assert_array_equal(grid.get_axes_names(), ['[ 1.  1.  0.]',
                                               '[ 1. -1.  0.]',
                                               '[ 0.  0. -1.]'])
    qx, qy, qz = grid.get_q_meshgrid()
    assert_array_almost_equal(qx, [[[0.],  [1.],  [2.],  [3.]],
                                   [[1.],  [2.],  [3.],  [4.]],
                                   [[2.],  [3.],  [4.],  [5.]]])
    assert_array_almost_equal(qy, [[[0.], [-1.], [-2.], [-3.]],
                                   [[1.],  [0.], [-1.], [-2.]],
                                   [[2.],  [1.],  [0.], [-1.]]])
    assert_array_equal(qz, np.zeros((3, 4, 1)))
    qx, qy, qz = grid.get_squashed_q_meshgrid()
    assert_array_almost_equal(qx, [[[0.],  [1.],  [2.],  [3.]],
                                   [[1.],  [2.],  [3.],  [4.]],
                                   [[2.],  [3.],  [4.],  [5.]]])
    assert_array_almost_equal(qy, [[[0.], [-1.], [-2.], [-3.]],
                                   [[1.],  [0.], [-1.], [-2.]],
                                   [[2.],  [1.],  [0.], [-1.]]])
    assert_array_equal(qz, [[[0]]])