def test_axis(n, width, left_position, right_position):
left = triangle(n, width, left_position)
right = triangle(n, width, right_position, left=False)
center = compute_rotation_axis(left, right)
truth = (left_position + right_position + width) / 2 * q.px
assert_almost_equal(center, truth)
def test_axis(n, width, left_position, right_position):
left = triangle(n, width, left_position)
right = triangle(n, width, right_position, left=False)
center = compute_rotation_axis(left, right)
truth = (left_position + right_position + width) / 2.0 * q.px
assert_almost_equal(center, truth)
def test_focusing():
motor = Motor(hard_limits=(MIN_POSITION.magnitude,
MAX_POSITION.magnitude))
motor.position = 85. * q.mm
camera = BlurringCamera(motor)
focus(camera, motor).wait()
assert_almost_equal(motor.position, FOCUS_POSITION, 1e-2)
def test_maximum_out_of_soft_limits_left(self):
feedback = DummyGradientMeasure(self.motor['position'], 20 * q.mm)
optimize_parameter(self.motor["position"],
lambda: -feedback(),
self.motor.position,
optimization.halver,
alg_kwargs=self.halver_kwargs).wait()
assert_almost_equal(self.motor.position, 25 * q.mm)
def test_maximum_out_of_soft_limits_left(self):
feedback = DummyGradientMeasure(self.motor["position"], 20 * q.mm)
optimize_parameter(
self.motor["position"],
lambda: -feedback(),
self.motor.position,
optimization.halver,
alg_kwargs=self.halver_kwargs,
).join()
assert_almost_equal(self.motor.position, 25 * q.mm)
async def test_maximum_out_of_soft_limits_left(self):
feedback = DummyGradientMeasure(self.motor['position'],
20 * q.mm,
negative=True)
await optimize_parameter(self.motor["position"],
feedback,
await self.motor.get_position(),
optimization.halver,
alg_kwargs=self.halver_kwargs)
assert_almost_equal(await self.motor.get_position(), 25 * q.mm)
def test_move(self):
pixel_width = self.positioner.detector.pixel_width.to(q.m).magnitude
pixel_height = self.positioner.detector.pixel_height.to(q.m).magnitude
self.positioner.move((100.0, 200.0, 0.0) * q.pixel).join()
position = (100.0 * pixel_width, 200.0 * pixel_height, 0.0) * q.m
assert_almost_equal(position, self.positioner.position)
# Cannot move in z-direction by pixel size
with self.assertRaises(PositionerError):
self.positioner.move((1.0, 2.0, 3.0) * q.pixel).join()
async def test_move(self):
pixel_width = (await self.positioner.detector.get_pixel_width()).to(q.m).magnitude
pixel_height = (await self.positioner.detector.get_pixel_height()).to(q.m).magnitude
await self.positioner.move((100.0, 200.0, 0.0) * q.pixel)
position = (100.0 * pixel_width, 200.0 * pixel_height, 0.0) * q.m
assert_almost_equal(position, await self.positioner.get_position())
# Cannot move in z-direction by pixel size
with self.assertRaises(PositionerError):
await self.positioner.move((1.0, 2.0, 3.0) * q.pixel)
def test_orientation(self):
orientation = (1.0, 2.0, 3.0) * q.rad
self.positioner.orientation = orientation
assert_almost_equal(orientation, self.positioner.orientation)
# Degrees must be accepted
self.positioner.orientation = (2.0, 3.0, 4.0) * q.deg
# Test non-existent axis
del self.positioner.rotators['x']
with self.assertRaises(PositionerError):
self.positioner.orientation = orientation
# Also nan must work
orientation = (np.nan, 1.0, 2.0) * q.rad
self.positioner.orientation = orientation
# assert_almost_equal(orientation[1:], self.positioner.orientation[1:])
# Also 0 in the place of no axis must work
self.positioner.orientation = (0.0, 1.0, 2.0) * q.rad
def test_position(self):
position = (1.0, 2.0, 3.0) * q.um
self.positioner.position = position
assert_almost_equal(position, self.positioner.position)
# Test non-existent axis
del self.positioner.translators['x']
with self.assertRaises(PositionerError):
self.positioner.set_position(position).join()
# The remaining axes must work
position = (0.0, 1.0, 2.0) * q.mm
self.positioner.position = position
assert_almost_equal(position[1:], self.positioner.position[1:])
# Also nan must work
position = (np.nan, 1.0, 2.0) * q.mm
self.positioner.position = position
assert_almost_equal(position, self.positioner.position)
# Also 0 in the place of no axis must work
self.positioner.position = (0.0, 1.0, 2.0) * q.mm
assert_almost_equal(position, self.positioner.position)
def test_position(self):
position = (1.0, 2.0, 3.0) * q.um
self.positioner.position = position
assert_almost_equal(position, self.positioner.position)
# Test non-existent axis
del self.positioner.translators['x']
with self.assertRaises(PositionerError):
self.positioner.position = position
# The remaining axes must work
position = (0.0, 1.0, 2.0) * q.mm
self.positioner.position = position
assert_almost_equal(position[1:], self.positioner.position[1:])
# Also nan must work
position = (np.nan, 1.0, 2.0) * q.mm
self.positioner.position = position
assert_almost_equal(position[1:], self.positioner.position[1:])
# Also 0 in the place of no axis must work
self.positioner.position = (0.0, 1.0, 2.0) * q.mm
assert_almost_equal(position[1:], self.positioner.position[1:])
def test_orientation(self):
orientation = (1.0, 2.0, 3.0) * q.rad
self.positioner.orientation = orientation
assert_almost_equal(orientation, self.positioner.orientation)
# Degrees must be accepted
self.positioner.orientation = (2.0, 3.0, 4.0) * q.deg
# Test non-existent axis
del self.positioner.rotators['x']
with self.assertRaises(PositionerError):
self.positioner.set_orientation(orientation).join()
# Also nan must work
orientation = (np.nan, 1.0, 2.0) * q.rad
self.positioner.orientation = orientation
assert_almost_equal(orientation, self.positioner.orientation)
# Also 0 in the place of no axis must work
self.positioner.orientation = (0.0, 1.0, 2.0) * q.rad
assert_almost_equal(orientation, self.positioner.orientation)
async def test_multiscan(self):
"""A 2D scan."""
values_0 = np.arange(0, 10, 5) * q.mm
values_1 = np.arange(20, 30, 5) * q.mm
async def run():
other = LinearMotor()
scanned = []
async for pair in scan((self.motor['position'], other['position']),
(values_0, values_1),
self.feedback):
vec, res = pair
scanned.append((vec[0], vec[1], res))
return scanned
scanned = await run()
expected = list(product(values_0, values_1, [1 * q.dimensionless]))
x, y, z = list(zip(*scanned))
x_gt, y_gt, z_gt = list(zip(*expected))
assert_almost_equal(x, x_gt)
assert_almost_equal(y, y_gt)
assert_almost_equal(z, z_gt)
def test_duration(self):
"""Test the sum of durations."""
assert_almost_equal(self.timer.duration, sum(self.timer.durations))
async def test_back(self):
await self.positioner.back(1 * q.mm)
assert_almost_equal((0.0, 0.0, -1.0) * q.mm, await self.positioner.get_position())
def test_tomo_angular_step():
truth = np.arctan(2.0 / 100) * q.rad
assert_almost_equal(truth, tomo_angular_step(100 * q.px))
def check(self):
assert_almost_equal(self.motor.position.to(q.mm),
self.center.to(q.mm), 1e-2)
async def check(self):
assert_almost_equal((await self.motor.get_position()).to(q.mm),
self.center.to(q.mm), 1e-2)
def test_duration(self):
"""Test the sum of durations."""
assert_almost_equal(self.timer.duration, sum(self.timer.durations))
def test_energy_mono_wavelength(self):
self.mono.wavelength = self.wavelength
assert_almost_equal(self.mono.wavelength, self.wavelength)
assert_almost_equal(base.wavelength_to_energy(self.wavelength),
self.mono.energy)
async def test_down(self):
await self.positioner.down(1 * q.px)
assert_almost_equal((0.0, - self._pixel_height_position, 0.0) * q.m,
await self.positioner.get_position())
def test_move(self):
position = (1.0, 2.0, 3.0) * q.mm
self.positioner.move(position).join()
assert_almost_equal(position, self.positioner.position)
def test_right(self):
self.positioner.right(1 * q.mm).join()
assert_almost_equal((1.0, 0.0, 0.0) * q.mm, self.positioner.position)
async def test_right(self):
await self.positioner.right(1 * q.mm)
assert_almost_equal((1.0, 0.0, 0.0) * q.mm, await self.positioner.get_position())
async def test_rotate(self):
orientation = (1.0, 2.0, 3.0) * q.rad
await self.positioner.rotate(orientation)
assert_almost_equal(orientation, await self.positioner.get_orientation())
async def test_move(self):
position = (1.0, 2.0, 3.0) * q.mm
await self.positioner.move(position)
assert_almost_equal(position, await self.positioner.get_position())
async def test_left(self):
await self.positioner.left(1 * q.px)
assert_almost_equal((- self._pixel_width_position, 0.0, 0.0) * q.m,
await self.positioner.get_position())
def test_wavelength_mono_wavelength(self):
# Wavelength-based monochromator.
self.wave_mono.wavelength = self.wavelength
assert_almost_equal(self.wave_mono.wavelength, self.wavelength)
assert_almost_equal(base.wavelength_to_energy(self.wavelength),
self.wave_mono.energy)
def check(self):
assert_almost_equal(self.motor.position.to(q.mm),
self.center.to(q.mm), 1e-2)
async def test_negative_direction(self):
# Test positive direction
axis = Axis('x', self.motor, direction=-1)
await axis.set_position(-1 * q.mm)
assert_almost_equal(await self.motor.get_position(), - (await axis.get_position()))
def test_rotate(self):
orientation = (1.0, 2.0, 3.0) * q.rad
self.positioner.rotate(orientation).join()
assert_almost_equal(orientation, self.positioner.orientation)
def test_tomo_max_speed():
width = 100
frame_rate = 100 / q.s
truth = np.arctan(2 / width) * q.rad * frame_rate
assert_almost_equal(truth, tomo_max_speed(width * q.px, frame_rate))
async def test_focusing(self):
await self.motor.set_position(40. * q.mm)
camera = BlurringCamera(self.motor)
await focus(camera, self.motor)
assert_almost_equal(await self.motor.get_position(), FOCUS_POSITION,
1e-2)
def test_left(self):
self.positioner.left(1 * q.mm).join()
assert_almost_equal((-1.0, 0.0, 0.0) * q.mm, self.positioner.position)
def test_wavelength_mono_energy(self):
self.wave_mono.energy = self.energy
assert_almost_equal(self.wave_mono.energy, self.energy)
assert_almost_equal(self.wave_mono.wavelength,
base.energy_to_wavelength(self.wave_mono.energy))
def test_up(self):
self.positioner.up(1 * q.mm).join()
assert_almost_equal((0.0, 1.0, 0.0) * q.mm, self.positioner.position)
async def test_set_velocity(self):
velocity = 1 * q.deg / q.s
await self.motor.set_velocity(velocity)
assert_almost_equal(velocity, await self.motor.get_velocity(), 0.1)
self.assertEqual(await self.motor.get_state(), 'moving')
await self.motor.stop()
def test_forward(self):
self.positioner.forward(1 * q.mm).join()
assert_almost_equal((0.0, 0.0, 1.0) * q.mm, self.positioner.position)
def check(self, other):
assert_almost_equal(self.motor.position, other, 0.1)
def test_back(self):
self.positioner.back(1 * q.mm).join()
assert_almost_equal((0.0, 0.0, -1.0) * q.mm, self.positioner.position)
def test_mean(self):
assert_almost_equal(self.timer.mean, self.timer.duration / len(self.timer.durations))
def test_tomo_angular_step():
truth = np.arctan(2 / 100) * q.rad
assert_almost_equal(truth, tomo_angular_step(100 * q.px))
def test_tomo_max_speed():
width = 100
frame_rate = 100 / q.s
truth = np.arctan(2.0 / width) * q.rad * frame_rate
assert_almost_equal(truth, tomo_max_speed(width * q.px, frame_rate))
def test_energy_mono_wavelength(self):
self.mono.wavelength = self.wavelength
assert_almost_equal(self.mono.wavelength, self.wavelength)
assert_almost_equal(base.wavelength_to_energy(self.wavelength), self.mono.energy)
def test_wavelength_mono_wavelength(self):
# Wavelength-based monochromator.
self.wave_mono.wavelength = self.wavelength
assert_almost_equal(self.wave_mono.wavelength, self.wavelength)
assert_almost_equal(base.wavelength_to_energy(self.wavelength), self.wave_mono.energy)
async def check(self, other):
assert_almost_equal(await self.motor.get_position(), other, 0.1)
def test_mean(self):
assert_almost_equal(self.timer.mean,
self.timer.duration / len(self.timer.durations))
async def test_forward(self):
await self.positioner.forward(1 * q.mm)
assert_almost_equal((0.0, 0.0, 1.0) * q.mm, await self.positioner.get_position())
def check(self, other):
assert_almost_equal(self.motor.position, other, 0.1)
def test_left(self):
self.positioner.left(1 * q.px).join()
assert_almost_equal((- self._pixel_width_position, 0.0, 0.0) * q.m,
self.positioner.position)
def test_wavelength_mono_energy(self):
self.wave_mono.energy = self.energy
assert_almost_equal(self.wave_mono.energy, self.energy)
assert_almost_equal(self.wave_mono.wavelength, base.energy_to_wavelength(self.wave_mono.energy))
def test_down(self):
self.positioner.down(1 * q.px).join()
assert_almost_equal((0.0, - self._pixel_height_position, 0.0) * q.m,
self.positioner.position)
def test_focusing(self):
self.motor.position = 40. * q.mm
camera = BlurringCamera(self.motor)
focus(camera, self.motor).join()
assert_almost_equal(self.motor.position, FOCUS_POSITION, 1e-2)
def test_negative_direction(self):
# Test positive direction
axis = Axis('x', self.motor, direction=-1)
axis.set_position(-1 * q.mm).join()
assert_almost_equal(self.motor.position, - axis.get_position().result())
