def compute_line_position(self, stage_height, stage_angle, stage_extension,
line_offset_height, line_offset_angle):
#print "compute_line_position() called ---------------------"
#print "stage_height", stage_height
#print "sage_angle", stage_angle
#print "stage_extension", stage_extension
#print "line_offset_angle", line_offset_angle
#print "line_offset_height", line_offset_height
angle1 = to_rad(to_float(stage_angle))
angle2 = to_rad(to_float(line_offset_angle))
angle3 = angle1 + angle2
# Point 0 co-ordinates
p0_z = to_float(settings.Z_MM_WHITE_BEAM) + to_float(stage_height)
p0_x = to_float(settings.X_MM_CP_CENTER)
# Point 1 co-ordinates
p1_z = p0_z + math.cos(angle1) * to_float(line_offset_height)
p1_x = p0_x - math.sin(angle1) * to_float(line_offset_height)
# Point 2 co-ordinates
p2_z = p1_z - math.sin(angle1) * to_float(stage_extension)
p2_x = p1_x - math.cos(angle1) * to_float(stage_extension)
# Point 3 co-ordinates
p3_z = p2_z - math.sin(angle3) * to_float(CAM_POS_RENDER_LENGTH)
p3_x = p2_x - math.cos(angle3) * to_float(CAM_POS_RENDER_LENGTH)
return p2_x, p2_z, p3_x, p3_z
def compute_positions(self, pv_name):
# print "Compute positions called from", pv_name
# Get the actual position
height = self.monitor.get_value(PV.ACT_HEIGHT)
angle = self.monitor.get_value(PV.ACT_ANGLE)
a_rad = to_rad(angle)
fis_height = self.monitor.get_value(VAR.CFG_HEIGHT_OFFSET)
# print "The height is:", repr(height)
# print "The angle is", repr(angle)
# print "The fis height is:", repr(fis_height)
# First, compute the actual tabletop render line
pivot = settings.X_MM_OPTICS_TABLE_UPSTREAM_EDGE
start = settings.OPTICS_TABLE_RENDER_START
stop = settings.OPTICS_TABLE_RENDER_STOP
try:
diff = pivot - start
start_x = pivot - diff * math.cos(a_rad)
start_z = height - diff * math.sin(a_rad)
diff = stop - pivot
stop_x = pivot + diff * math.cos(a_rad)
stop_z = height + diff * math.sin(a_rad)
position = (start_x, start_z, stop_x, stop_z)
except Exception, e:
print "Exception computing OT position", str(e)
position = (None, None, None, None)
def action_align_fis(self):
pivot = settings.X_MM_OPTICS_TABLE_UPSTREAM_EDGE
fis_height = self.monitor.get_value(VAR.CFG_HEIGHT_OFFSET)
angle = self.monitor.get_value(CORE_VAR.BEAM_ANGLE_PROPOSED)
beam_disp = self.monitor.get_value(CORE_VAR.BEAM_VDISP_PROPOSED)
a_rad = to_rad(angle)
sx = settings.BEAM_ORIGIN_X
sz = settings.BEAM_ORIGIN_Z + beam_disp
fx = sx + math.cos(a_rad)
fz = sz + math.sin(a_rad)
beam_line = LineGeneric(sx, sz, fx, fz)
beam_height_at_pivot = beam_line.get_height(pivot)
# Compute table to FIS height
try:
fis_height = float(fis_height)
height_diff = fis_height / math.cos(a_rad)
target_height = beam_height_at_pivot - height_diff
self.monitor.put(VAR.PROPOSED_ANGLE, angle)
self.monitor.put(VAR.PROPOSED_HEIGHT, target_height)
except Exception, e:
print "Error"
def compute_id_ct_thickness(self, pv_bragg, pv_lattice, nominal, pv_result):
mid_dist = nominal / 2.0
try:
bragg = to_rad(float(self.monitor.get_value(pv_bragg)))
lattice = to_rad(float(self.monitor.get_value(pv_lattice)))
dist_a = mid_dist / math.cos(abs(lattice) + abs(bragg))
dist_b = mid_dist / math.cos(abs(lattice) - abs(bragg))
result = dist_a + dist_b
except Exception, e:
print "Exception computing CT thickness: %s" % str(e)
result = nominal
def handle_pv_id_mono_kes(self, pv_name):
"""
Compute nominal distance through the crystal
"""
mid_dist = ID_KES_MONO_THICKNESS_MM / 2.0
try:
bragg = to_rad(float(self.monitor.get_value(PV.ID_MONO_KES_BRAGG_ANGLE)))
lattice = to_rad(float(self.monitor.get_value(PV.ID_MONO_KES_LATTICE_ANGLE)))
dist_a = mid_dist / math.cos(abs(lattice) + abs(bragg))
dist_b = mid_dist / math.cos(abs(lattice) - abs(bragg))
result = dist_a + dist_b
except Exception, e:
print "Exception computing KES thickness: %s" % str(e)
result = ID_KES_MONO_THICKNESS_MM
def action_align_target_to_beam(self, target_angle_pv, target_height_pv):
"""
Align the "target" (beam or detector line of sight) to the beam
"""
# First get angle of the beam
beam_angle = self.monitor.get_value(CORE_VAR.BEAM_ANGLE_PROPOSED)
beam_disp = self.monitor.get_value(CORE_VAR.BEAM_VDISP_PROPOSED)
if None in [beam_angle, beam_disp]:
raise ValueError(
"Cannot align camera positioner.<br>Beam position unknown.")
# What is the laser angle"
target_angle = to_float(self.monitor.get_value(target_angle_pv))
stage_angle = beam_angle - target_angle
self.monitor.put(VAR.CUR_ANGLE, stage_angle)
# Next we must set extension
extension = to_float(self.monitor.get_value(VAR.CFG_EXTENSION))
self.monitor.put(VAR.CUR_EXTENSION, extension)
stage_height = self.monitor.get_value(VAR.CUR_HEIGHT)
target_height = self.monitor.get_value(target_height_pv)
# Now get the line start/stop coordinates
sx, sz, fx, fz = self.compute_line_position(stage_height, stage_angle,
extension, target_height,
target_angle)
target_line = LineGeneric(sx, sz, fx, fz)
target_height_at_mrt = target_line.get_height(settings.X_MM_MRT)
sx = settings.BEAM_ORIGIN_X
sz = settings.BEAM_ORIGIN_Z + beam_disp
fx = sx + math.cos(to_rad(beam_angle))
fz = sz + math.sin(to_rad(beam_angle))
beam_line = LineGeneric(sx, sz, fx, fz)
beam_height_at_mrt = beam_line.get_height(settings.X_MM_MRT)
height_diff = beam_height_at_mrt - target_height_at_mrt
stage_height += height_diff
self.monitor.put(VAR.CUR_HEIGHT, stage_height)
fis_stop_x = stop_x - fis_height * math.sin(a_rad)
fis_stop_z = stop_z + fis_height * math.cos(a_rad)
position = (fis_start_x, fis_start_z, fis_stop_x, fis_stop_z)
except Exception, e:
print "Exception computing OT position", str(e)
position = (start_x, start_z, stop_x, stop_z)
self.monitor.put(VAR.FIS_ACTUAL, position)
# Repeat but for proposed position
try:
height = float(self.monitor.get_value(VAR.PROPOSED_HEIGHT))
angle = float(self.monitor.get_value(VAR.PROPOSED_ANGLE))
a_rad = to_rad(angle)
diff = pivot - start
start_x = pivot - diff * math.cos(a_rad)
start_z = height - diff * math.sin(a_rad)
diff = stop - pivot
stop_x = pivot + diff * math.cos(a_rad)
stop_z = height + diff * math.sin(a_rad)
position = (start_x, start_z, stop_x, stop_z)
except Exception, e:
print "Exception computing OT position", str(e)
position = (None, None, None, None)
self.monitor.put(VAR.TABLE_PROPOSED, position)
print "Got None: Cant render %s" % var_name
return
data = LINE_DATA.get(var_name)
if color is None:
color = data.get(KEY.COLOR)
width = data.get(KEY.LINE_WIDTH)
style = data.get(KEY.LINE_STYLE)
qt_layer = data.get(KEY.QT_LAYER, 10)
start_z = origin_z_mm + float(vert_disp_mm)
start_x = origin_x_mm
stop_x = settings.X_MM_BEAM_END
z_diff = math.tan(to_rad(angle_deg)) * (stop_x - start_x)
# print "angle: %f adjacent: %f z_diff: %f" % (angle_deg, (stop_x_mm - start_x_mm), z_diff)
stop_z = start_z + z_diff
item = self.draw_line_mm(start_x,
start_z,
stop_x,
stop_z,
color=color,
width=width,
style=style,
qt_layer=qt_layer)
if not item: