def __init__(self, translation=None, rotation=None, scale=None):
self.translation = translation if translation is not None \
else np.array([0, 0, 0, 1])
self.rotation = rotation if rotation is not None \
else np.array([0, 0, 0])
self.scale = scale if scale is not None \
else np.ones(4)
Component.__init__(self)
def setup_beamline(self, initial_mirror_angle, mirror_position,
beam_start):
jaws = Component("jaws", movement_strategy=LinearMovement(0, 0, 90))
mirror = ReflectingComponent("mirror",
movement_strategy=LinearMovement(
0, mirror_position, 90))
mirror.angle = initial_mirror_angle
jaws3 = Component("jaws3", movement_strategy=LinearMovement(0, 20, 90))
beamline = Beamline([jaws, mirror, jaws3], [], [], [])
beamline.set_incoming_beam(beam_start)
return beamline, mirror
def test_GIVEN_jaw_input_beam_is_at_0_deg_and_z0_y0_WHEN_get_beam_out_THEN_beam_output_is_same_as_beam_input(
self):
jaws_z_position = 10
beam_start = PositionAndAngle(y=0, z=0, angle=0)
jaws = Component("component",
movement_strategy=LinearMovement(
0, jaws_z_position, 90))
jaws.set_incoming_beam(beam_start)
result = jaws.get_outgoing_beam()
assert_that(result, is_(position_and_angle(beam_start)))
def setUp(self):
start_position = 0.0
max_velocity = 10.0
self.height_axis = create_mock_axis("JAWS:HEIGHT", start_position,
max_velocity)
self.jaws = Component("component",
movement_strategy=LinearMovement(
0.0, 10.0, 90.0))
self.jaws.set_incoming_beam(PositionAndAngle(0.0, 0.0, 0.0))
self.jaws_driver = HeightDriver(self.jaws, self.height_axis)
def test_GIVEN_jaw_at_10_input_beam_is_at_0_deg_and_z0_y0_WHEN_get_position_THEN_z_is_jaw_position_y_is_0(
self):
jaws_z_position = 10
beam_start = PositionAndAngle(y=0, z=0, angle=0)
expected_position = Position(y=0, z=jaws_z_position)
jaws = Component("component",
movement_strategy=LinearMovement(
0, jaws_z_position, 90))
jaws.set_incoming_beam(beam_start)
result = jaws.calculate_beam_interception()
assert_that(result, is_(position(expected_position)))
def test_GIVEN_jaw_height_WHEN_set_set_point_and_move_THEN_readback_is_as_set_and_jaws_are_at_setpoint_postion(self):
height_set = 10.0
beam_height = 5
expected_height = beam_height + height_set
jaws_z = 5.0
jaws = Component("jaws", movement_strategy=LinearMovement(0, jaws_z, 90))
jaws.set_incoming_beam(PositionAndAngle(beam_height, 0, 0))
tracking_height = TrackingPosition("theta",jaws)
tracking_height.sp_no_move = height_set
tracking_height.move = 1
result = tracking_height.sp_rbv
assert_that(result, is_(height_set))
assert_that(jaws.sp_position().y, is_(expected_height))
assert_that(jaws.sp_position().z, is_(close_to(jaws_z, DEFAULT_TEST_TOLERANCE)))
def test_GIVEN_parameter_in_mode_and_not_changed_and_no_previous_parameter_changed_WHEN_moving_beamline_THEN_parameter_unchanged(self):
initial_s2_height = 0.0
super_mirror = ReflectingComponent("sm", LinearMovement(0.0, 10, 90.0))
s2 = Component("s2", LinearMovement(initial_s2_height, 20, 90.0))
sm_angle = ReflectionAngle("smangle", super_mirror, True)
slit2_pos = TrackingPosition("slit2pos", s2, True)
mode = BeamlineMode("both_params", [sm_angle.name, slit2_pos.name])
beamline = Beamline([super_mirror, s2], [sm_angle, slit2_pos], [], [mode])
beamline.set_incoming_beam(PositionAndAngle(0, 0, 0))
beamline.active_mode = mode
beamline.move = 1
assert_that(s2.sp_position().y, is_(initial_s2_height))
def setUp(self):
start_position_height = 0.0
max_velocity_height = 10.0
self.height_axis = create_mock_axis("SM:HEIGHT", start_position_height,
max_velocity_height)
start_position_angle = 0.0
max_velocity_angle = 10.0
self.angle_axis = create_mock_axis("SM:ANGLE", start_position_angle,
max_velocity_angle)
self.supermirror = Component("component",
movement_strategy=LinearMovement(
0.0, 10.0, 90.0))
self.supermirror.set_incoming_beam(PositionAndAngle(0.0, 0.0, 0.0))
self.supermirror_driver = HeightAndAngleDriver(self.supermirror,
self.height_axis,
self.angle_axis)
def test_GIVEN_beam_line_contains_one_passive_component_WHEN_beam_set_THEN_component_has_beam_out_same_as_beam_in(
self):
beam_start = PositionAndAngle(y=0, z=0, angle=0)
jaws = Component("jaws", movement_strategy=LinearMovement(0, 2, 90))
beamline = Beamline([jaws], [], [], [])
beamline.set_incoming_beam(beam_start)
result = beamline[0].get_outgoing_beam()
assert_that(result, is_(position_and_angle(beam_start)))
def test_GIVEN_parameter_changed_and_not_in_mode_and_no_previous_parameter_changed_WHEN_moving_beamline_THEN_parameter_moved_to_sp(self):
initial_s2_height = 0.0
target_s2_height = 1.0
super_mirror = ReflectingComponent("sm", LinearMovement(0.0, 10, 90.0))
s2 = Component("s2", LinearMovement(initial_s2_height, 20, 90.0))
sm_angle = ReflectionAngle("smangle", super_mirror)
slit2_pos = TrackingPosition("slit2pos", s2)
empty_mode = BeamlineMode("empty", [])
beamline = Beamline([super_mirror, s2], [sm_angle, slit2_pos], [], [empty_mode])
beamline.set_incoming_beam(PositionAndAngle(0, 0, 0))
beamline.active_mode = empty_mode
slit2_pos.sp_no_move = target_s2_height
beamline.move = 1
assert_that(s2.sp_position().y, is_(target_s2_height))
def test_GIVEN_jaw_at_10_input_beam_is_at_60_deg_and_z5_y30_WHEN_get_position_THEN_z_is_jaw_position_y_is_at_tan_minus_60_times_distance_between_input_beam_and_component_plus_original_beam_y(
self):
distance_between = 5.0
start_z = 5.0
start_y = 30
beam_angle = 60.0
jaws_z_position = distance_between + start_z
beam_start = PositionAndAngle(y=start_y, z=start_z, angle=beam_angle)
expected_position = Position(
y=tan(radians(beam_angle)) * distance_between + start_y,
z=jaws_z_position)
jaws = Component("component",
movement_strategy=LinearMovement(
0, jaws_z_position, 90))
jaws.set_incoming_beam(beam_start)
result = jaws.calculate_beam_interception()
assert_that(result, is_(position(expected_position)))
def test_GIVEN_unpolarised_mode_and_beamline_parameters_are_set_WHEN_move_THEN_components_move_onto_beam_line(self):
slit2 = Component("s2", LinearMovement(0, z_position=10, angle=90))
ideal_sample_point = ReflectingComponent("ideal_sample_point", LinearMovement(0, z_position=20, angle=90))
detector = Component("detector", LinearMovement(0, z_position=30, angle=90))
components = [slit2, ideal_sample_point, detector]
parameters = [
TrackingPosition("slit2height", slit2),
TrackingPosition("height", ideal_sample_point),
Theta("theta", ideal_sample_point),
TrackingPosition("detectorheight", detector)]
#parameters["detectorAngle": TrackingAngle(detector)
beam = PositionAndAngle(0, 0, -45)
beamline = Beamline(components, parameters, [], [DataMother.BEAMLINE_MODE_NEUTRON_REFLECTION])
beamline.set_incoming_beam(beam)
beamline.active_mode = DataMother.BEAMLINE_MODE_NEUTRON_REFLECTION
beamline.parameter("theta").sp_no_move = 45
beamline.parameter("height").sp_no_move = 0
beamline.parameter("slit2height").sp_no_move = 0
beamline.parameter("detectorheight").sp_no_move = 0
beamline.move = 1
assert_that(slit2.sp_position(), is_(position(Position(-10, 10))))
assert_that(ideal_sample_point.sp_position(), is_(position(Position(-20, 20))))
assert_that(detector.sp_position(), is_(position(Position(-10, 30))))
def create_beamline():
perp_to_floor = 90.0
beam_start = PositionAndAngle(y=0, z=0, angle=-2.5)
s0 = Component("s0", movement_strategy=LinearMovement(0, 0, perp_to_floor))
s1 = Component("s1", movement_strategy=LinearMovement(0, 1, perp_to_floor))
frame_overlap_mirror = ReflectingComponent(
"FOM", movement_strategy=LinearMovement(0, 2, perp_to_floor))
frame_overlap_mirror.enabled = False
polarising_mirror = ReflectingComponent("Polarising mirror",
movement_strategy=LinearMovement(
0, 3, perp_to_floor))
polarising_mirror.enabled = False
s2 = Component("s2", movement_strategy=LinearMovement(0, 4, perp_to_floor))
ideal_sample_point = ReflectingComponent("Ideal Sample Point",
movement_strategy=LinearMovement(
0, 5, perp_to_floor))
s3 = Component("s3", movement_strategy=LinearMovement(0, 6, perp_to_floor))
analyser = ReflectingComponent("analyser",
movement_strategy=LinearMovement(
0, 7, perp_to_floor))
analyser.enabled = False
s4 = Component("s4", movement_strategy=LinearMovement(0, 8, perp_to_floor))
detector = Component("detector",
movement_strategy=LinearMovement(
0, 10, perp_to_floor))
theta = Theta("theta", ideal_sample_point)
beamline = Beamline([
s0, s1, frame_overlap_mirror, polarising_mirror, s2,
ideal_sample_point, s3, analyser, s4, detector
], [theta], [])
beamline.set_incoming_beam(beam_start)
beamline.active_mode = BeamlineMode("NR", ["theta"])
return beamline
class TestHeightAndAngleDriver(unittest.TestCase):
def setUp(self):
start_position_height = 0.0
max_velocity_height = 10.0
self.height_axis = create_mock_axis("SM:HEIGHT", start_position_height,
max_velocity_height)
start_position_angle = 0.0
max_velocity_angle = 10.0
self.angle_axis = create_mock_axis("SM:ANGLE", start_position_angle,
max_velocity_angle)
self.supermirror = Component("component",
movement_strategy=LinearMovement(
0.0, 10.0, 90.0))
self.supermirror.set_incoming_beam(PositionAndAngle(0.0, 0.0, 0.0))
self.supermirror_driver = HeightAndAngleDriver(self.supermirror,
self.height_axis,
self.angle_axis)
def test_GIVEN_multiple_axes_need_to_move_WHEN_computing_move_duration_THEN_maximum_duration_is_returned(
self):
target_angle = 30.0
expected = 3.0
self.supermirror.angle = target_angle
self.supermirror.set_position_relative_to_beam(10.0)
result = self.supermirror_driver.get_max_move_duration()
assert_that(result, is_(expected))
def test_GIVEN_move_duration_and_target_position_set_WHEN_moving_multiple_axes_THEN_computed_axis_velocity_is_correct_and_setpoint_set_for_all_axes(
self):
target_duration = 10.0
expected_velocity_height = 1.0
target_position_height = 10.0
expected_velocity_angle = 3.0
target_position_angle = 30.0
self.supermirror.angle = 30.0
self.supermirror.set_position_relative_to_beam(
10.0) # move component into beam
self.supermirror_driver.perform_move(target_duration)
assert_that(
fabs(self.height_axis.velocity -
expected_velocity_height) <= FLOAT_TOLERANCE)
assert_that(
fabs(self.height_axis.value -
target_position_height) <= FLOAT_TOLERANCE)
assert_that(
fabs(self.angle_axis.velocity -
expected_velocity_angle) <= FLOAT_TOLERANCE)
assert_that(
fabs(self.angle_axis.value -
target_position_angle) <= FLOAT_TOLERANCE)
class TestHeightDriver(unittest.TestCase):
def setUp(self):
start_position = 0.0
max_velocity = 10.0
self.height_axis = create_mock_axis("JAWS:HEIGHT", start_position,
max_velocity)
self.jaws = Component("component",
movement_strategy=LinearMovement(
0.0, 10.0, 90.0))
self.jaws.set_incoming_beam(PositionAndAngle(0.0, 0.0, 0.0))
self.jaws_driver = HeightDriver(self.jaws, self.height_axis)
def test_GIVEN_component_with_height_setpoint_above_current_position_WHEN_calculating_move_duration_THEN_returned_duration_is_correct(
self):
target_position = 20.0
expected = 2.0
self.jaws.set_position_relative_to_beam(target_position)
result = self.jaws_driver.get_max_move_duration()
assert_that(result, is_(expected))
def test_GIVEN_component_with_height_setpoint_below_current_position_WHEN_calculating_move_duration_THEN_returned_duration_is_correct(
self):
target_position = -20.0
expected = 2.0
self.jaws.set_position_relative_to_beam(target_position)
result = self.jaws_driver.get_max_move_duration()
assert_that(result, is_(expected))
def test_GIVEN_move_duration_and_target_position_set_WHEN_moving_axis_THEN_computed_axis_velocity_is_correct_and_setpoint_set(
self):
target_position = 20.0
target_duration = 4.0
expected_velocity = 5.0
self.jaws.set_position_relative_to_beam(target_position)
self.jaws_driver.perform_move(target_duration)
assert_that(self.height_axis.velocity, is_(expected_velocity))
assert_that(self.height_axis.value, is_(target_position))
def setUp(self):
beam_start = PositionAndAngle(y=0, z=0, angle=2.5)
s0 = Component("s0", movement_strategy=LinearMovement(0, 0, 90))
s1 = Component("s1", movement_strategy=LinearMovement(0, 1, 90))
frame_overlap_mirror = ReflectingComponent(
"FOM", movement_strategy=LinearMovement(0, 2, 90))
frame_overlap_mirror.enabled = False
self.polarising_mirror = ReflectingComponent(
"Polariser", movement_strategy=LinearMovement(0, 3, 90))
self.polarising_mirror.enabled = False
self.polarising_mirror.angle = 0
s2 = Component("s2", movement_strategy=LinearMovement(0, 4, 90))
self.ideal_sample_point = ReflectingComponent(
"ideal sample point", movement_strategy=LinearMovement(0, 5, 90))
s3 = Component("s3", movement_strategy=LinearMovement(0, 6, 90))
analyser = ReflectingComponent("analyser",
movement_strategy=LinearMovement(
0, 7, 90))
analyser.enabled = False
s4 = Component("s4", movement_strategy=LinearMovement(0, 8, 90))
detector = Component("detector",
movement_strategy=LinearMovement(0, 10, 90))
theta = Theta("theta", self.ideal_sample_point)
theta.sp_no_move = 0
smangle = ReflectionAngle("smangle", self.polarising_mirror)
smangle.sp_no_move = 0
self.nr_mode = BeamlineMode("NR Mode", [theta.name])
self.polarised_mode = BeamlineMode("NR Mode",
[smangle.name, theta.name])
self.beamline = Beamline([
s0, s1, frame_overlap_mirror, self.polarising_mirror, s2,
self.ideal_sample_point, s3, analyser, s4, detector
], [smangle, theta], [], [self.nr_mode, self.polarised_mode])
self.beamline.set_incoming_beam(beam_start)
def test_GIVEN_multiple_components_in_beamline_WHEN_triggering_move_THEN_components_move_at_speed_of_slowest_axis(
self):
sm_angle = 0.0
sm_angle_to_set = 22.5
supermirror = ReflectingComponent("supermirror",
movement_strategy=LinearMovement(
y_position=0.0,
z_position=10.0,
angle=90.0))
sm_height_axis = create_mock_axis("SM:HEIGHT", 0.0, 10.0)
sm_angle_axis = create_mock_axis("SM:ANGLE", sm_angle, 10.0)
supermirror.angle = sm_angle
supermirror_driver = HeightAndAngleDriver(supermirror, sm_height_axis,
sm_angle_axis)
slit_2 = Component("slit_2",
movement_strategy=LinearMovement(y_position=0.0,
z_position=20.0,
angle=90.0))
slit_2_height_axis = create_mock_axis("SLIT2:HEIGHT", 0.0, 10.0)
slit_2_driver = HeightDriver(slit_2, slit_2_height_axis)
slit_3 = Component("slit_3",
movement_strategy=LinearMovement(y_position=0.0,
z_position=30.0,
angle=90.0))
slit_3_height_axis = create_mock_axis("SLIT3:HEIGHT", 0.0, 10.0)
slit_3_driver = HeightDriver(slit_3, slit_3_height_axis)
detector = TiltingJaws(
"jaws",
movement_strategy=LinearMovement(y_position=0.0,
z_position=40.0,
angle=90.0))
detector_height_axis = create_mock_axis("DETECTOR:HEIGHT", 0.0, 10.0)
detector_tilt_axis = create_mock_axis("DETECTOR:TILT", 0.0, 10.0)
detector_driver = HeightAndTiltDriver(detector, detector_height_axis,
detector_tilt_axis)
smangle = ReflectionAngle("smangle", supermirror)
slit_2_pos = TrackingPosition("s2_pos", slit_2)
slit_3_pos = TrackingPosition("s3_pos", slit_3)
det_pos = TrackingPosition("det_pos", detector)
components = [supermirror, slit_2, slit_3, detector]
beamline_parameters = [smangle, slit_2_pos, slit_3_pos, det_pos]
drivers = [
supermirror_driver, slit_2_driver, slit_3_driver, detector_driver
]
mode = BeamlineMode(
"mode name",
[smangle.name, slit_2_pos.name, slit_3_pos.name, det_pos.name])
beamline = Beamline(components, beamline_parameters, drivers, [mode])
beamline.active_mode = mode
beam_start = PositionAndAngle(0.0, 0.0, 0.0)
beamline.set_incoming_beam(beam_start)
slit_2_pos.sp_no_move = 0.0
slit_3_pos.sp_no_move = 0.0
det_pos.sp_no_move = 0.0
# detector angle axis takes longest
expected_max_duration = 4.5
smangle.sp_no_move = sm_angle_to_set
with patch.object(beamline, '_move_drivers') as mock:
beamline.move = 1
mock.assert_called_with(expected_max_duration)
def __init__(self, vertices, triangles):
self.vertices = vertices
self.triangles = triangles
Component.__init__(self)
