DAQ: now use config/redis to save smart_params and better choose when to use smart_params. filename connected for automation

daq/src/aaredaq/daq.py

@@ -63,10 +63,6 @@ class AareDAQ:
         self.__bl = bl.value.upper()
         self.__aare = AareWrapper(bl)
         self.__saved_box = None
-        self.crystal_size = CrystalSize(x=0,y=0,z=0)
-        self.last_best_b_factor = None
-        self.last_best_res = None
-        self.auto_params = SimpleScanParameters()
 
     @property
     def state(self) -> BeamlineStateEnum:
@@ -91,22 +87,23 @@ class AareDAQ:
 
         self.last_time = end - start
 
-    @property
-    def smart_params(self) -> SimpleScanParameters:
-        return self.auto_params
+    def spreadsheet_params(self) -> tuple[Optional[SimpleScanParameters], None]:
+        file_prefix = None
 
-    @smart_params.setter
-    def smart_params(self, params: SimpleScanParameters):
-        self.auto_params = params
-
-    def spreadsheet_params(self) -> Optional[SimpleScanParameters]:
         if self.status.sample is None:
-            return None
-        logger.debug(f"generate params for sample: {self.status.sample}")
-        aaredb_params = self.status.sample.aaredb_params if hasattr(self.status.sample, "aaredb_params") else None
-        if aaredb_params is None:
-            return None
+            return None, file_prefix
 
+        logger.debug(f"generate params for sample: {self.status.sample}")
+
+        aaredb_params = self.status.sample.aaredb_params if hasattr(self.status.sample, "aaredb_params") else None
+
+        if aaredb_params is None:
+            return None, file_prefix
+
+        if aaredb_params.directory:
+            file_prefix = aaredb_params.directory
+
+        logger.debug(f"aaredb_params.directory: {aaredb_params.directory}, file_prefix: {file_prefix}")
         if (
             getattr(aaredb_params, 'exposure', None) is None
             and getattr(aaredb_params, 'transmission', None) is None
@@ -114,7 +111,7 @@ class AareDAQ:
             and getattr(aaredb_params, 'totalrange', None) is None
             and getattr(aaredb_params, 'targetresolution', None) is None
         ):
-            return None
+            return None, file_prefix
 
         params = SimpleScanParameters()
 
@@ -133,8 +130,6 @@ class AareDAQ:
         osc = getattr(aaredb_params, 'oscillation', None)
         total = getattr(aaredb_params, 'totalrange', None)
 
-        default_osc = SimpleScanParameters().incr_omega_deg
-
         if osc is not None:
             osc = abs(osc)
             if osc > 0:
@@ -144,10 +139,14 @@ class AareDAQ:
                 else:
                     params.steps = round(360.0 / osc)
         elif total is not None and abs(total) > 0:
+            default_osc = SimpleScanParameters().incr_omega_deg
             params.incr_omega_deg = default_osc
             params.steps = round(abs(total) / default_osc)
 
-        return params
+        if file_prefix:
+            params.file_prefix = file_prefix
+
+        return params, file_prefix
 
 
     @property
@@ -393,9 +392,9 @@ class AareDAQ:
             curr_sample_is_manual = False
             logger.info(f"current sample: {curr_sample}")
             logger.info(f"new target is: {target}")
-            self.crystal_size = CrystalSize(x=0, y=0, z=0)
-            self.last_best_b_factor = None
-            self.last_best_res = None
+            self.__cfg.crystal_size = CrystalSize(x=0, y=0, z=0)
+            self.__cfg.last_best_b_factor = None
+            self.__cfg.last_best_res = None
             self.__cfg.xrf = None
 
             if curr_sample is not None and curr_sample.location is None:
@@ -535,8 +534,11 @@ class AareDAQ:
         self.__devs.abr_pos = self.__cfg.abr_meas_pos
         result = self.__jfjoch.wait_till_done(60)
 
-        #if self.sample is not None and self.sample.db_id is not None:
-        #    self.__aare.ingest_gridscan(self.sample, result, r)
+        if self.sample is not None and self.sample.db_id is not None and result is not None:
+            try:
+                self.__aare.ingest_gridscan(self.sample, result, r)
+            except Exception as e:
+                logger.error(f"Error ingesting grid scan to database: {e}")
 
         images = result.images
         output_data = {
@@ -544,6 +546,7 @@ class AareDAQ:
             'scan_results': [image.model_dump() for image in images],
             'total_results': len([image for image in images])
         }
+
         if self.sample is not None and self.sample.db_id is not None:
             if r.n_x == 1:
                 filename=f'{self.sample.db_id}_scan_results_vertical.json'
@@ -557,7 +560,7 @@ class AareDAQ:
 
         result_array = create_quality_filtered_array(images, 'spots_low_res', min_spots=None,
                                                           min_efficiency=1.0, min_background=None, min_low_res_spots=10.0)
-        self.crystal_size = get_xtal_size(self.crystal_size, result_array, r)
+        self.__cfg.crystal_size = get_xtal_size(self.__cfg.crystal_size, result_array, r)
         grid_mm_x, grid_mm_y, com = raster_centre_of_mass(result_array, r)
 
         if grid_mm_x is None or grid_mm_y is None:
@@ -572,22 +575,22 @@ class AareDAQ:
             else:
                 result_list = get_result_list_from_com(images, com)
                 print(result_list)
-                self.last_best_b_factor = get_best_b_factor(result_list)
-                self.last_best_res = get_best_res(result_list)
-                print("b_factor: ", self.last_best_b_factor, " best_res: ", self.last_best_res)
+                self.__cfg.last_best_b_factor = get_best_b_factor(result_list)
+                self.__cfg.last_best_res = get_best_res(result_list)
+                logger.debug("b_factor: ", self.__cfg.last_best_b_factor, " best_res: ", self.__cfg.last_best_res)
                 new_delta_mm = self.sample_geometry.smargon_nudge(Coordinate(x=grid_mm_x, y=grid_mm_y))
 
         else:
             new_delta_mm = None
 
-        print('after centre_of_mass')
+        logger.debug('after centre_of_mass')
         if new_delta_mm is not None:
-            print(f'{time.ctime()}, moving SMARGON to target new delta mm {r.smargon.sh_mm + new_delta_mm} mm')
+            logger.debug(f'{time.ctime()}, moving SMARGON to target new delta mm {r.smargon.sh_mm + new_delta_mm} mm')
             self.__devs.smargon.target = SmargonCoordinate(sh_mm=r.smargon.sh_mm + new_delta_mm,
                                                            phi_deg=r.smargon.phi_deg,
                                                            chi_deg=r.smargon.chi_deg)
         else:
-            print("Auto finding optimal image failed due to no images found. Using previous position.")
+            logger.debug("Auto finding optimal image failed due to no images found. Using previous position.")
             self.__devs.smargon.target = save_smargon_position
 
         return CompletedRasterGridElem(request=copy.deepcopy(r), result=result)
@@ -601,6 +604,8 @@ class AareDAQ:
                 raster_result = self.__raster(r)
                 result = CompletedRasterGrid(r=[raster_result])
             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, f"after_raster_{r.omega_deg}deg")
             self.__cfg.state_busy = False
             return result
         except Exception as e:
@@ -612,7 +617,8 @@ class AareDAQ:
         if request.dtz is not None:
             logger.info(f'requesting dtz to move to {request.dtz}')
             self.__cfg.dtz = request.dtz
-        self.save_screenshot_db(self.sample.db_id, f"pre_rotation{self.sample.db_id}_{self.__devs.zoom}")
+        if self.sample is not None and self.sample.db_id is not None:
+            self.save_screenshot_db(self.sample.db_id, f"pre_rotation{self.sample.db_id}_{self.__devs.zoom}")
         self.__set_state(BeamlineStateEnum.DataCollection)
 
         if request.transmission is not None:
@@ -1260,22 +1266,25 @@ class AareDAQ:
         return params
 
     def get_collection_params(self, prefer_smart: bool = False) -> tuple[SimpleScanParameters, str]:
-        spreadsheet_params = self.spreadsheet_params()
+        spreadsheet_params, file_prefix = self.spreadsheet_params()
         logger.debug(f"spreadsheet_params: {spreadsheet_params}")
+        smart_params = self.__cfg.auto_params
+        #self.__aare.send_msg_to_db(self.sample,event_type=SampleEventType(''), comment=f'smart_params: {smart_params}')
         if prefer_smart:
-            # Smart params priority
-            if self.smart_params:
-                return self.smart_params, "smart_params"
+            if smart_params:
+                if file_prefix:
+                    smart_params.file_prefix = file_prefix
+                return smart_params, "smart_params"
             if spreadsheet_params:
                 return spreadsheet_params, "spreadsheet_params"
         else:
-            # Spreadsheet params priority (current default)
             if spreadsheet_params:
                 return spreadsheet_params, "spreadsheet_params"
-            if self.smart_params:
-                return self.smart_params, "smart_params"
+            if smart_params:
+                if file_prefix:
+                    smart_params.file_prefix = file_prefix
+                return smart_params, "smart_params"
 
-        # Fallback to defaults
         return SimpleScanParameters(exp_time_s=0.04, dtz=110, incr_omega_deg=0.2), "defaults"
 
     def measure(self, sample: SampleShortInfo) -> float:
@@ -1313,7 +1322,7 @@ class AareDAQ:
 
             hex_string = secrets.token_hex(3)  # 3 bytes = 6 hex characters
             print(hex_string.upper())
-            #self.__ml_bounding_box(sample.db_id, f"ml_{geom.omega_deg:.2f}deg")
+
             raster_params = self.get_auto_raster_params()
             if self.__auto_center(RasterGridRequest(
                 exp_time_s=raster_params.exp_time_s,
@@ -1330,7 +1339,7 @@ class AareDAQ:
                 params, source = self.get_collection_params(prefer_smart=False)
                 logger.info(f"Using {source} for data collection: {params}")
 
-                self.__cfg.zoom_mode = ZoomModeEnum.User
+                #self.__cfg.zoom_mode = ZoomModeEnum.User
                 self.__devs.samcam_settings = self.__cfg.zoom_settings.get_camera_settings(self.zoom)
                 self.__devs.dtz.move(params.dtz, wait=True)
                 if self.omega + 180 < 720:
@@ -1508,9 +1517,9 @@ class AareDAQ:
             session=SessionStatus(),
             diffraction=self.diffraction_geometry,
             box=self.__saved_box,
-            last_best_res = self.last_best_res,
-            last_best_b_factor = self.last_best_b_factor,
-            crystal_size = self.crystal_size
+            last_best_res = self.__cfg.last_best_res,
+            last_best_b_factor = self.__cfg.last_best_b_factor,
+            crystal_size = self.__cfg.crystal_size
         )
 
     def cancel(self):