DAQ\/AareDB: centralise message handling to the database

This commit is contained in:
appleb_m committed 2026-04-22 10:10:44 +02:00
1 parent a7b83e7a9d
commit 0d0953c74c
2 files changed
+154 -166

No files matched your search

+18 -92
View File
@@ -114,106 +114,32 @@ class AareWrapper:
except Exception as e:
logger.error(f"Error inserting sample: {e}")
def sample_mounted(self, s: Optional[SampleShortInfo]):
if s is not None:
try:
self.__sample_api.create_sample_event(
sample_id=s.db_id,
sample_event_create=SampleEventCreate(event_type=SampleEventType("Mounted")),
)
except Exception as e:
logger.error(e)
def sample_unmounted(self, s: Optional[SampleShortInfo]):
if s is not None:
try:
self.__sample_api.create_sample_event(
sample_id=s.db_id,
sample_event_create=SampleEventCreate(event_type=SampleEventType("Unmounted")),
)
except Exception as e:
logger.error(e)
def sample_centered(self, s: Optional[SampleShortInfo]):
if s is not None:
try:
self.__sample_api.create_sample_event(
sample_id=s.db_id,
sample_event_create=SampleEventCreate(event_type=SampleEventType("Centered")),
)
except Exception as e:
logger.error(e)
def sample_collected(self, s: Optional[SampleShortInfo]):
def send_sample_event(
self,
s: Optional[SampleShortInfo],
event_type: SampleEventType,
comment: Optional[str] = None,
) -> None:
if s is None:
logger.debug("Sample info is None, skipping sample event")
return
if s.db_id is None or s.db_id < 0:
logger.debug(
f"Sample db_id is invalid ({s.db_id}), skipping sample event {event_type!s}"
)
return
try:
self.__sample_api.create_sample_event(
sample_id=s.db_id,
sample_event_create=SampleEventCreate(event_type=SampleEventType("Collected")),
sample_event_create=SampleEventCreate(
event_type=event_type,
comment=comment,
),
)
except Exception as e:
logger.error(e)
logger.error(f"Error sending sample event {event_type!s} to db: {e}")
def sample_failed(self, s: Optional[SampleShortInfo], failed_comment: Optional[str] = None):
if s is None:
return
try:
self.__sample_api.create_sample_event(
sample_id=s.db_id,
sample_event_create=SampleEventCreate(event_type=SampleEventType("Failed"), comment=failed_comment),
)
except Exception as e:
logger.error(e)
def axc_failed(self, s: Optional[SampleShortInfo]):
if s is None:
return
try:
self.__sample_api.create_sample_event(
sample_id=s.db_id,
sample_event_create=SampleEventCreate(event_type=SampleEventType("AXCFailed")),
)
except Exception as e:
logger.error(e)
def alc_failed(self, s: Optional[SampleShortInfo], alc_comment: Optional[str] = None):
if s is None:
return
try:
self.__sample_api.create_sample_event(
sample_id=s.db_id,
sample_event_create=SampleEventCreate(event_type=SampleEventType("ALCFailed"), comment=alc_comment),
)
except Exception as e:
logger.error(e)
def sample_lost(self, s: Optional[SampleShortInfo]):
if s is None:
return
try:
self.__sample_api.create_sample_event(
sample_id=s.db_id,
sample_event_create=SampleEventCreate(event_type=SampleEventType("Lost")),
)
except Exception as e:
logger.error(f"Error sending message to db: {e}")
def send_msg_to_db(self, s: Optional[SampleShortInfo], event_type:Optional[SampleEventType | str], comment: str = ''):
if s is None or event_type is None:
logger.debug(f"sample info or event type is None, skipping message: {event_type} {comment}")
return
if isinstance(event_type, str):
event_type = SampleEventType(event_type)
try:
self.__sample_api.create_sample_event(
sample_id=s.db_id,
sample_event_create=SampleEventCreate(event_type=event_type, comment=comment)
)
except Exception as e:
logger.error(f"Error sending message to db: {e}")
def upload_image(self, sample_id: int, filename: str, bgr_image: np.ndarray, message: str | None = None):
def upload_image(self, sample_id: int, filename: str, bgr_image: np.ndarray, message: Optional[str] = None):
_, buffer = cv2.imencode('.jpg', bgr_image)
jpeg_bytes = io.BytesIO(buffer)
url = f"{self.__host}/protected_router/sample_runner/{sample_id}/upload-images"
+136 -74
View File
@@ -10,6 +10,7 @@ from typing import List, Tuple, Optional, Callable
import cv2
import numpy as np
from aareDB import SampleEventType
from jfjoch_client import ScanResult, ScanResultImagesInner
@@ -31,7 +32,7 @@ from aare.common.models import (
SampleShortInfoList, AutofocusSettings,
DAQStatusModel, BeamlineStatus, SessionStatus, SampleCameraSettings, ZoomModeEnum,
SimpleScanParameters, MLBoxModel, FluorescenceSpectrumParameterModel,
FluorescenceSpectrumOutputModel)
FluorescenceSpectrumOutputModel, DAQOperation, LoopCenteringResult)
from aare.common.raster_grid import RasterGridRequest, CompletedRasterGrid, CompletedRasterGridElem
from aare.common.rotation_scan import RotationScanRequest, CompletedRotationScan
from aare.common.sample_geometry import SampleGeometryModel
@@ -49,7 +50,7 @@ from aare.common.exception_handler import (
AXCFailed,
SmargonCommunicationError,
TellCommunicationError,
JFJochCommunicationError, AerotechCommunicationError, MagnetPositionSensorErorr
JFJochCommunicationError, AerotechCommunicationError, MagnetPositionSensorErorr, UnmountingFailed
)
logger = setup_logger("aareDAQ")
@@ -97,32 +98,37 @@ class AareDAQ:
)
#TODO make sure this is implemented currectly
def _handle_operation_error(self, operation_name: str, sample: SampleShortInfo | None, error: Exception,
error_type: str = "generic") -> None:
def _handle_operation_error(
self,
operation: DAQOperation,
sample: Optional[SampleShortInfo],
error: Exception,
event_type: SampleEventType = SampleEventType.FAILED,
additional_comment: Optional[str] = None,
) -> None:
"""
Centralized error handling for all operations.
Args:
operation_name: Name of the operation that failed (e.g., "mount", "alc", "raster")
operation: Name of the operation that failed (e.g., "mount", "alc", "raster")
sample: The sample being processed
error: The exception that occurred
error_type: Type of error - "mount", "alc", "axc", or "generic"
event_type: Type of event to send to database - "mount", "alc", "axc", or "generic"
"""
if sample is None:
logger.error(f"Error in {operation_name}: {error}")
logger.error(f"Error in {operation.value}: {error}")
return
comment = f"Error in {operation.value}: {error}"
if additional_comment is not None:
comment += f" Additional comment: {additional_comment}"
try:
if error_type == "mount":
self.__aare.sample_failed(sample, failed_comment=f"Mount failed: {error}")
elif error_type == "alc":
self.__aare.alc_failed(sample, alc_comment=f"Loop centering failed: {error}")
elif error_type == "axc":
self.__aare.axc_failed(sample)
else:
self.__aare.sample_failed(sample, failed_comment=f"Error in {operation_name}: {error}")
self.__aare.send_sample_event(
sample,
event_type,
comment=comment,
)
except Exception as db_error:
logger.error(f"Failed to report {operation_name} error to database: {db_error}")
logger.error(f"Failed to report {operation.value} error to database: {db_error}")
#todo make sure these functions are correctly implemented!
def _execute_mount_and_prepare(self, sample: SampleShortInfo) -> bool:
@@ -133,31 +139,65 @@ class AareDAQ:
True if successful, False otherwise
"""
try:
if sample.db_id is not None:
self.__aare.send_sample_event(sample, SampleEventType.MOUNTING)
self.__mount(sample)
if sample.db_id is not None:
self.__aare.sample_mounted(sample)
self.__aare.send_sample_event(sample, SampleEventType.MOUNTED)
self.save_screenshot_db(sample.db_id, f"{sample.db_id}_mounted")
return True
except Exception as e:
logger.error(f"Mount failed: {e}")
self._handle_operation_error("mount", sample, e, error_type="mount")
self._handle_operation_error(
operation=DAQOperation.MOUNT,
sample=sample,
error=e,
event_type=SampleEventType.MOUNTFAILED
)
return False
def _execute_loop_centering(self, sample_id: int | None) -> bool:
def _execute_loop_centering(self, sample: SampleShortInfo) -> bool:
"""
Execute loop centering sequence.
Returns:
True if successful, False otherwise
"""
result = None
additional_comment=None
if sample is None or sample.db_id is None or sample.db_id < 0:
logger.error("Loop centering failed: no sample provided")
return False
try:
if not self.__loop_center_sequence(sample_id):
self._handle_operation_error("loop_centering", self.sample, LoopCenteringFailed(), error_type="alc")
self.__aare.send_sample_event(sample, SampleEventType.CENTERING)
result = self.__loop_center_sequence(sample.db_id)
if not result.success:
self._handle_operation_error(
operation=DAQOperation.LOOP_CENTERING,
sample=sample,
error=result.error or Exception("Loop centering failed"),
event_type=SampleEventType.ALCFAILED,
additional_comment=result.comment if result.comment is not None else ""
)
return False
self.save_screenshot_db(sample.db_id, "loop_centering")
self.__aare.send_sample_event(sample, SampleEventType.CENTERED)
return True
except Exception as e:
logger.error(f"Loop centering failed: {e}")
self._handle_operation_error("loop_centering", self.sample, e, error_type="alc")
if result is not None and result.error is not None:
additional_comment = result.comment if result.comment is not None else ""
self._handle_operation_error(
operation=DAQOperation.LOOP_CENTERING,
sample=sample,
error=e,
event_type=SampleEventType.ALCFAILED,
additional_comment=additional_comment
)
return False
def _execute_raster_sequence(self, grid_request: RasterGridRequest,
@@ -181,7 +221,12 @@ class AareDAQ:
return result
except Exception as e:
logger.error(f"Raster sequence failed: {e}")
self._handle_operation_error("raster", self.sample, e, error_type="axc")
self._handle_operation_error(
operation=DAQOperation.RASTER,
sample=self.sample,
error=e,
event_type=SampleEventType.RASTERINGFAILED
)
return None
def _execute_rotation_sequence(self, rotation_request: RotationScanRequest) -> CompletedRotationScan | None:
@@ -195,17 +240,24 @@ class AareDAQ:
CompletedRotationScan result or None if failed
"""
try:
if self.sample is not None and self.sample.db_id is not None:
self.__aare.send_sample_event(self.sample, SampleEventType.COLLECTING)
result = self.__rotation(rotation_request)
self.__set_state(BeamlineStateEnum.SampleAlignment)
if self.sample is not None and self.sample.db_id is not None:
self.save_screenshot_db(self.sample.db_id, "scan_preview")
self.__aare.sample_collected(self.sample)
self.__aare.send_sample_event(self.sample, SampleEventType.COLLECTED)
self.__aare.ingest_scan(sample=self.sample, result=result.result,
geom=self.sample_geometry, beam_mark_pxl=self.__cfg.get_beam_mark(self.zoom))
return result
except Exception as e:
logger.error(f"Rotation sequence failed: {e}")
self._handle_operation_error("rotation", self.sample, e, error_type="generic")
self._handle_operation_error(
operation=DAQOperation.ROTATION,
sample=self.sample,
error=e,
event_type=SampleEventType.COLLECTIONFAILED
)
return None
def _append_smargon_trace(self, *, sample_id: int | None, event: str) -> None:
@@ -565,7 +617,8 @@ class AareDAQ:
raise Exception("Goniometer is not in position based on magnet position sensor readout")
def __mount_failure_handler(self, mount_error):
def __mount_failure_handler(self, value):
logger.debug(f"Mount response: {value}")
pass
def __mount(self, target: SampleShortInfo | None):
@@ -576,23 +629,28 @@ class AareDAQ:
self.__devs.tell.wait_not_busy()
self.__devs.tell.set_in_mount_position(True)
if target is None:
self.__devs.tell.unmount(wait=True, timeout=60.0)
self.__aare.sample_unmounted(self.__cfg.current_sample)
self.__cfg.current_sample = None
try:
self.__devs.tell.unmount(wait=True, timeout=60.0)
self.__aare.send_sample_event(self.__cfg.current_sample, SampleEventType.UNMOUNTED)
self.__cfg.current_sample = None
except Exception as e:
raise UnmountingFailed(f"Failed to unmount: {e}")
else:
try:
#TODO: how to differentiate between mounting and unmounting fails
# during a typucal mount call as this is handled by Tell?
value = self.__devs.tell.mount(address=target.tell_address(), force=True, auto_unmount=True, read_dm=False,
wait=True, timeout=360.0)
self.__mount_failure_handler(value)
if self.__cfg.current_sample is not None and self.__cfg.current_sample.db_id is not None:
self.__aare.sample_unmounted(self.__cfg.current_sample)
self.__aare.send_sample_event(self.__cfg.current_sample, SampleEventType.UNMOUNTED)
logger.info(f"Mount result: {value}")
self.__cfg.current_sample = target
except Exception as e:
logger.error(f"Mount failed: {e}")
if self.__cfg.current_sample is not None and self.__cfg.current_sample.db_id is not None:
self.__aare.sample_failed(self.__cfg.current_sample, failed_comment=f"Mount failed: {e}")
raise MountingFailed(f"Mount failed: {e}")
#self.__mount_failure_handler(value)
raise MountingFailed(f"Failed to mount: {e}")
def recovery_unmount_sample(self) -> None:
self.__cfg.try_set_busy(timeout=360)
@@ -611,29 +669,19 @@ class AareDAQ:
@sample.setter
def sample(self, target: SampleShortInfo | None):
self.__cfg.try_set_busy(timeout=360)
curr_sample_is_manual=False
try:
curr_sample = self.__cfg.current_sample
workflows.common_2rse(devs=self.__devs, cfg=self.__cfg)
#if curr_sample is not None and curr_sample.location is None:
# self.__cfg.current_sample = None
# curr_sample_is_manual = True
#if target is not None or not curr_sample_is_manual:
logger.debug(target)
if not self._execute_mount_and_prepare(target):
raise MountingFailed("Failed to mount sample")
logger.info(f"Sample mounted: {target}")
except Exception as e:
workflows.rse2sa(devs=self.__devs, cfg=self.__cfg)
self.__cfg.state_busy = False
logger.debug(f"Failed to mount sample: {e}")
# self.__aare.sample_failed(target, f"Mount failed due to {e}")
raise
workflows.rse2sa(devs=self.__devs, cfg=self.__cfg)
self.__cfg.state_busy = False
# if target is not None:
# if target.db_id is not None:
# self.__aare.sample_mounted(target)
# self.save_screenshot_db(target.db_id, f"{target.db_id}_mounted")
@property
@@ -934,6 +982,8 @@ class AareDAQ:
try:
if self.sample is not None and self.sample.db_id is not None:
self.__aare.send_sample_event(self.sample, SampleEventType.RASTERING,
comment=f"Raster at {request.omega_deg} deg")
self.__aare.create_gridscan_run(self.sample, request, status)
if not self.__cfg.simulated_detector:
@@ -1006,7 +1056,11 @@ class AareDAQ:
com=None,
beam_mark_pxl=self.__cfg.get_beam_mark(self.zoom),
)
self.__aare.send_sample_event(
self.sample,
event_type=SampleEventType.RASTERED,
comment=f"Raster completed at {request.omega_deg} deg"
)
return CompletedRasterGridElem(
request=copy.deepcopy(request),
result=scan_result,
@@ -1015,16 +1069,7 @@ class AareDAQ:
except Exception as e:
logger.exception(f"Failed during raster: {e}")
scan_result = self._build_fake_scan_result(
file_prefix=request.file_prefix,
image_count=request.n_x * request.n_y,
)
return CompletedRasterGridElem(
request=copy.deepcopy(request),
result=scan_result,
centre_of_mass=None,
)
#raise
raise
def measure_raster(self, r: RasterGridRequest, auto: bool) -> CompletedRasterGrid:
"""
@@ -1594,7 +1639,12 @@ class AareDAQ:
)
return calculated_target
def __loop_center_sequence(self, sample_id: int | None = None, trace_all_alc_moves: bool = False) -> bool:
def __loop_center_sequence(
self,
sample_id: Optional[int] = None,
trace_all_alc_moves: bool = False
) -> LoopCenteringResult:
self.__set_state(BeamlineStateEnum.SampleAlignment)
self.__devs.lamp_light = 2.5
@@ -1622,7 +1672,7 @@ class AareDAQ:
logger.debug(f"Moving to new omega: {angle}")
time_to_move_aerotech = time.perf_counter()
self.__devs.aerotech_omega = angle
logger.info(f"time to move: {time.perf_counter() - time_to_move_aerotech}")
logger.info(f"time to move AEROTECH: {time.perf_counter() - time_to_move_aerotech}")
filename = f"{sample_id}_{angle}_{zoom_value:.0f}" if sample_id is not None else None
@@ -1634,7 +1684,7 @@ class AareDAQ:
return_image=True,
return_bundle_meta=True
)
logger.info(f"time to move: {time.perf_counter() - time_to_get_pred}")
logger.info(f"time to PREDICT: {time.perf_counter() - time_to_get_pred}")
boxes = prediction_result.predictions
pred_target_point = prediction_result.target_point
@@ -1939,13 +1989,23 @@ class AareDAQ:
return default_params, "defaults"
def _end_operation(self, start) -> float:
def _end_operation(self, start, operation:Optional[DAQOperation]=DAQOperation.AUTOMATION, error: bool = False) -> float:
"""
End an operation and return elapsed time.
Returns:
(elapsed_seconds, end_time_perf_counter)
"""
if operation is DAQOperation.AUTOMATION:
msg = "Ended automation operation"
else:
msg = f"Ended automation operation after {operation.value}"
if error:
msg += f"with an error"
else:
msg += f"successfully"
logger.error(f"{msg}, time taken {time.perf_counter() - start} seconds.")
self.__cfg.state_busy = False
end = time.perf_counter()
return end - start
@@ -1976,22 +2036,20 @@ class AareDAQ:
logger.info(f"set busy at {time.perf_counter() - start}")
if not self._execute_mount_and_prepare(sample):
logger.error("Failed to mount sample")
return self._end_operation(start)
return self._end_operation(start, DAQOperation.MOUNT, error=True)
logger.info(f"mounting done at {time.perf_counter() - start}")
# Step 2: Loop centering
if not self._execute_loop_centering(sample.db_id):
logger.error("Loop Centering did not succeed")
return self._end_operation(start)
if not self._execute_loop_centering(sample):
return self._end_operation(start, DAQOperation.LOOP_CENTERING, error=True)
logger.info(f"alc done at {time.perf_counter() - start}")
logger.info(f"Loop Centering done at {time.perf_counter() - start}")
# Step 3: Face detection
result = self.__face_detection_sequence(steps=7, step_size=30)
self._emit_face_detection_progress(result)
logger.info(f"face_detection done at {time.perf_counter() - start}")
logger.info(f"Face Detection done at {time.perf_counter() - start}")
# Step 4: Auto-center and raster
hex_string = secrets.token_hex(3)
@@ -2013,9 +2071,9 @@ class AareDAQ:
raster_result = self._execute_raster_sequence(raster_grid, auto_center=True)
if raster_result is None:
logger.error("Raster result was None")
return self._end_operation(start)
return self._end_operation(start, DAQOperation.RASTER, error=True)
logger.info(f"raster scans done at {time.perf_counter() - start}")
logger.info(f"Raster scans completed at {time.perf_counter() - start}")
# Step 5: Data collection (rotation)
params, source = self.get_collection_params(prefer_smart=False)
@@ -2037,18 +2095,22 @@ class AareDAQ:
rotation_result = self._execute_rotation_sequence(rotation_request)
if rotation_result is None:
logger.error("Rotation result was None")
return self._end_operation(start)
return self._end_operation(start, DAQOperation.ROTATION, error=True)
logger.info(f"rotation done at {time.perf_counter() - start}")
logger.info(f"Rotation scan done at {time.perf_counter() - start}")
except Exception as e:
logger.error(f"Error in measure: {e}")
self._handle_operation_error("measure", sample, e, error_type="generic")
self._handle_operation_error(
operation=DAQOperation.AUTOMATION,
sample=sample,
error=e,
event_type=SampleEventType.FAILED)
#TODO under what circumstances should this raise an error?
finally:
logger.debug(f"finally at {time.perf_counter() - start}")
return self._end_operation(start)
return self._end_operation(start, DAQOperation.AUTOMATION, error=False)
def __set_state(self, target: BeamlineStateEnum):
"""__set_state assumes that beamline is already in busy state