From 0d0953c74c771c18028bb61e348175c14c5b1598 Mon Sep 17 00:00:00 2001 From: appleb_m Date: Wed, 22 Apr 2026 10:10:44 +0200 Subject: [PATCH] DAQ\/AareDB: centralise message handling to the database --- src/aare/daq/aaredb.py | 110 ++++----------------- src/aare/daq/daq.py | 210 ++++++++++++++++++++++++++--------------- 2 files changed, 154 insertions(+), 166 deletions(-) diff --git a/src/aare/daq/aaredb.py b/src/aare/daq/aaredb.py index 56cfde95..6a524cc6 100644 --- a/src/aare/daq/aaredb.py +++ b/src/aare/daq/aaredb.py @@ -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" diff --git a/src/aare/daq/daq.py b/src/aare/daq/daq.py index 7cd5881e..6f7f9da9 100644 --- a/src/aare/daq/daq.py +++ b/src/aare/daq/daq.py @@ -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