def test_spin_to_ecliptic():
result = np.empty(4)
lbs.spin_to_ecliptic(
result=result,
sun_earth_angle_rad=0.0,
spin_sun_angle_rad=0.0,
precession_rate_hz=0.0,
spin_rate_hz=0.0,
time_s=0.0,
)
assert np.allclose(result, np.array(lbs.quat_rotation_y(np.pi / 2)))
for sun_earth_angle_rad in (0.1, np.pi / 2, -0.1):
lbs.spin_to_ecliptic(
result=result,
sun_earth_angle_rad=sun_earth_angle_rad,
spin_sun_angle_rad=0.0,
precession_rate_hz=0.0,
spin_rate_hz=0.0,
time_s=0.0,
)
expected = np.array(lbs.quat_rotation_y(np.pi / 2))
lbs.quat_left_multiply(expected,
*lbs.quat_rotation_z(sun_earth_angle_rad))
assert np.allclose(result, expected)
def test_rotation_handedness():
result = np.empty(3)
lbs.rotate_vector(result, *lbs.quat_rotation_x(np.pi / 2), y)
assert np.allclose(result, z)
lbs.rotate_vector(result, *lbs.quat_rotation_x(np.pi / 2), z)
assert np.allclose(result, -y)
lbs.rotate_vector(result, *lbs.quat_rotation_y(np.pi / 2), x)
assert np.allclose(result, -z)
lbs.rotate_vector(result, *lbs.quat_rotation_y(np.pi / 2), z)
assert np.allclose(result, x)
lbs.rotate_vector(result, *lbs.quat_rotation_z(np.pi / 2), x)
assert np.allclose(result, y)
lbs.rotate_vector(result, *lbs.quat_rotation_z(np.pi / 2), y)
assert np.allclose(result, -x)
def test_quick_rotations():
vec = np.empty(3)
quat = np.array(lbs.quat_rotation_z(np.pi / 2))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_y(np.pi / 2))
lbs.rotate_z_vector(vec, *quat)
assert np.allclose(vec, y)
quat = np.array(lbs.quat_rotation_x(np.pi / 2))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_y(np.pi / 2))
lbs.rotate_x_vector(vec, *quat)
assert np.allclose(vec, y)
quat = np.array(lbs.quat_rotation_y(np.pi / 2))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_x(np.pi / 2))
lbs.rotate_y_vector(vec, *quat)
assert np.allclose(vec, x)
def test_collective_quick_rotations():
vec = np.empty((1, 3))
quat = np.array(lbs.quat_rotation_z(np.pi / 2))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_y(np.pi / 2))
lbs.all_rotate_z_vectors(vec, quat.reshape(1, 4))
assert np.allclose(vec, y)
quat = np.array(lbs.quat_rotation_x(np.pi / 2))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_y(np.pi / 2))
lbs.all_rotate_x_vectors(vec, quat.reshape(1, 4))
assert np.allclose(vec, y)
quat = np.array(lbs.quat_rotation_y(np.pi / 2))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_x(np.pi / 2))
lbs.all_rotate_y_vectors(vec, quat.reshape(1, 4))
assert np.allclose(vec, x)
def test_compute_pointing_and_polangle():
quat = np.array(lbs.quat_rotation_y(np.pi / 2))
result = np.empty(3)
lbs.compute_pointing_and_polangle(result, quat)
assert np.allclose(result, [np.pi / 2, 0.0, -np.pi / 2])
# We stay along the same pointing, but we're rotating the detector
# by 90°, so the polarization angle is the only number that
# changes
lbs.quat_left_multiply(quat, *lbs.quat_rotation_x(np.pi / 4))
lbs.compute_pointing_and_polangle(result, quat)
assert np.allclose(result, [np.pi / 2, 0.0, -np.pi / 4])
def test_quat_multiply_and_rotations():
# Simple composition of rotations
quat = np.array(lbs.quat_rotation_x(np.pi / 3))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_x(np.pi / 3))
assert np.allclose(quat, np.array(lbs.quat_rotation_x(2 * np.pi / 3)))
quat = np.array(lbs.quat_rotation_y(np.pi / 3))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_y(np.pi / 3))
assert np.allclose(quat, np.array(lbs.quat_rotation_y(2 * np.pi / 3)))
quat = np.array(lbs.quat_rotation_z(np.pi / 3))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_z(np.pi / 3))
assert np.allclose(quat, np.array(lbs.quat_rotation_z(2 * np.pi / 3)))
quat = np.array(lbs.quat_rotation_x(np.pi / 3))
lbs.quat_left_multiply(quat, *lbs.quat_rotation_x(np.pi / 3))
assert np.allclose(quat, np.array(lbs.quat_rotation_x(2 * np.pi / 3)))
quat = np.array(lbs.quat_rotation_y(np.pi / 3))
lbs.quat_left_multiply(quat, *lbs.quat_rotation_y(np.pi / 3))
assert np.allclose(quat, np.array(lbs.quat_rotation_y(2 * np.pi / 3)))
quat = np.array(lbs.quat_rotation_z(np.pi / 3))
lbs.quat_left_multiply(quat, *lbs.quat_rotation_z(np.pi / 3))
assert np.allclose(quat, np.array(lbs.quat_rotation_z(2 * np.pi / 3)))
# Now we test more complex compositions
vec = np.empty(3)
# Right multiplication
quat = np.array(lbs.quat_rotation_y(np.pi / 2))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_x(np.pi / 2))
lbs.rotate_vector(vec, *quat, y)
assert np.allclose(vec, x)
quat = np.array(lbs.quat_rotation_z(np.pi / 2))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_y(np.pi / 2))
lbs.rotate_vector(vec, *quat, z)
assert np.allclose(vec, y)
quat = np.array(lbs.quat_rotation_x(np.pi / 2))
lbs.quat_right_multiply(quat, *lbs.quat_rotation_y(np.pi / 2))
lbs.rotate_vector(vec, *quat, x)
assert np.allclose(vec, y)
# Left multiplication
quat = np.array(lbs.quat_rotation_y(np.pi / 2))
lbs.quat_left_multiply(quat, *lbs.quat_rotation_z(np.pi / 2))
lbs.rotate_vector(vec, *quat, z)
assert np.allclose(vec, y)
quat = np.array(lbs.quat_rotation_z(np.pi / 2))
lbs.quat_left_multiply(quat, *lbs.quat_rotation_y(np.pi / 2))
lbs.rotate_vector(vec, *quat, y)
assert np.allclose(vec, z)
quat = np.array(lbs.quat_rotation_z(np.pi / 2))
lbs.quat_left_multiply(quat, *lbs.quat_rotation_x(np.pi / 2))
lbs.rotate_vector(vec, *quat, x)
assert np.allclose(vec, z)