Esempio n. 1
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.]]])
Esempio n. 2
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]]])
Esempio n. 3
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]]])
Esempio n. 4
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