fixes in contrast and audio confirm logif

csaxs_bec/bec_ipython_client/plugins/LamNI/LamNI_webpage_generator.py

@@ -0,0 +1,89 @@
+"""
+LamNI/webpage_generator.py
+===========================
+LamNI-specific webpage generator subclass.
+
+Integration (inside the LamNI __init__ / startup):
+---------------------------------------------------
+    from csaxs_bec.bec_ipython_client.plugins.LamNI.webpage_generator import (
+        LamniWebpageGenerator,
+    )
+    self._webpage_gen = LamniWebpageGenerator(
+        bec_client=client,
+        output_dir="~/data/raw/webpage/",
+    )
+    self._webpage_gen.start()
+
+Or use the factory (auto-selects by session name "lamni"):
+----------------------------------------------------------
+    from csaxs_bec.bec_ipython_client.plugins.flomni.webpage_generator import (
+        make_webpage_generator,
+    )
+    self._webpage_gen = make_webpage_generator(bec, output_dir="~/data/raw/webpage/")
+    self._webpage_gen.start()
+
+Interactive helpers:
+--------------------
+    lamni._webpage_gen.status()
+    lamni._webpage_gen.verbosity = 2
+    lamni._webpage_gen.stop()
+    lamni._webpage_gen.start()
+"""
+
+from pathlib import Path
+
+from csaxs_bec.bec_ipython_client.plugins.flomni.webpage_generator import (
+    WebpageGeneratorBase,
+    _safe_get,
+    _safe_float,
+    _gvar,
+)
+
+
+class LamniWebpageGenerator(WebpageGeneratorBase):
+    """
+    LamNI-specific webpage generator.
+    Logo: LamNI.png from the same directory as this file.
+
+    Override _collect_setup_data() to add LamNI-specific temperatures,
+    sample name, and measurement settings.
+    """
+
+    # TODO: fill in LamNI-specific device paths
+    # label -> dotpath under device_manager.devices
+    _TEMP_MAP = {
+        # "Sample":  "lamni_temphum.temperature_sample",
+        # "OSA":     "lamni_temphum.temperature_osa",
+    }
+
+    def _logo_path(self):
+        return Path(__file__).parent / "LamNI.png"
+
+    def _collect_setup_data(self) -> dict:
+        # ── LamNI-specific data goes here ─────────────────────────────
+        # Uncomment and adapt when device names are known:
+        #
+        # dm = self._bec.device_manager
+        # sample_name = _safe_get(dm, "lamni_samples.sample_names.sample0") or "N/A"
+        # temperatures = {
+        #     label: _safe_float(_safe_get(dm, path))
+        #     for label, path in self._TEMP_MAP.items()
+        # }
+        # settings = {
+        #     "Sample name":   sample_name,
+        #     "FOV x / y":     ...,
+        #     "Exposure time": _gvar(self._bec, "tomo_countingtime", ".3f", " s"),
+        #     "Angle step":    _gvar(self._bec, "tomo_angle_stepsize", ".2f", "\u00b0"),
+        # }
+        # return {
+        #     "type":         "lamni",
+        #     "sample_name":  sample_name,
+        #     "temperatures": temperatures,
+        #     "settings":     settings,
+        # }
+
+        # Placeholder — returns minimal info until implemented
+        return {
+            "type": "lamni",
+            # LamNI-specific data here
+        }

csaxs_bec/bec_ipython_client/plugins/flomni/flomni.py

@@ -21,6 +21,14 @@ from csaxs_bec.bec_ipython_client.plugins.omny.omny_general_tools import (
     TomoIDManager,
 )
 
+# from csaxs_bec.bec_ipython_client.plugins.flomni.webpage_generator import (
+#        FlomniWebpageGenerator,
+#       VERBOSITY_SILENT,   # 0 — no output
+#       VERBOSITY_NORMAL,   # 1 — startup / stop messages only  (default)
+#       VERBOSITY_VERBOSE,  # 2 — one-line summary per cycle
+#       VERBOSITY_DEBUG,    # 3 — full JSON payload per cycle
+#    )
+
 logger = bec_logger.logger
 
 if builtins.__dict__.get("bec") is not None:
@@ -969,8 +977,6 @@ class FlomniSampleTransferMixin:
 
 class FlomniAlignmentMixin:
     import csaxs_bec
-    import os
-    from pathlib import Path
 
     # Ensure this is a Path object, not a string
     csaxs_bec_basepath = Path(csaxs_bec.__file__)
@@ -1211,6 +1217,76 @@ class FlomniAlignmentMixin:
         return additional_correction_shift
 
 
+class _ProgressProxy:
+    """Dict-like proxy that persists the flOMNI progress dict as a BEC global variable.
+
+    Every read (`proxy["key"]`) fetches the current dict from the global var store,
+    and every write (`proxy["key"] = val`) fetches, updates, and saves it back.
+    This makes the progress state visible to all BEC client sessions via
+    ``client.get_global_var("tomo_progress")``.
+    """
+
+    _GLOBAL_VAR_KEY = "tomo_progress"
+    _DEFAULTS: dict = {
+        "subtomo": 0,
+        "subtomo_projection": 0,
+        "subtomo_total_projections": 1,
+        "projection": 0,
+        "total_projections": 1,
+        "angle": 0,
+        "tomo_type": 0,
+        "tomo_start_time": None,
+        "estimated_remaining_time": None,
+        "heartbeat": None,
+    }
+
+    def __init__(self, client):
+        self._client = client
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+    def _load(self) -> dict:
+        val = self._client.get_global_var(self._GLOBAL_VAR_KEY)
+        if val is None:
+            return dict(self._DEFAULTS)
+        return val
+
+    def _save(self, data: dict) -> None:
+        self._client.set_global_var(self._GLOBAL_VAR_KEY, data)
+
+    # ------------------------------------------------------------------
+    # Dict-like interface
+    # ------------------------------------------------------------------
+    def __getitem__(self, key):
+        return self._load()[key]
+
+    def __setitem__(self, key, value) -> None:
+        data = self._load()
+        data[key] = value
+        self._save(data)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self._load()!r})"
+
+    def get(self, key, default=None):
+        return self._load().get(key, default)
+
+    def update(self, *args, **kwargs) -> None:
+        """Update multiple fields in a single round-trip."""
+        data = self._load()
+        data.update(*args, **kwargs)
+        self._save(data)
+
+    def reset(self) -> None:
+        """Reset all progress fields to their default values."""
+        self._save(dict(self._DEFAULTS))
+
+    def as_dict(self) -> dict:
+        """Return a plain copy of the current progress state."""
+        return self._load()
+
+
 class Flomni(
     FlomniInitStagesMixin,
     FlomniSampleTransferMixin,
@@ -1233,14 +1309,17 @@ class Flomni(
         self.corr_angle_y = []
         self.corr_pos_y_2 = []
         self.corr_angle_y_2 = []
-        self.progress = {}
-        self.progress["subtomo"] = 0
-        self.progress["subtomo_projection"] = 0
-        self.progress["subtomo_total_projections"] = 1
-        self.progress["projection"] = 0
-        self.progress["total_projections"] = 1
-        self.progress["angle"] = 0
-        self.progress["tomo_type"] = 0
+        self._progress_proxy = _ProgressProxy(self.client)
+        self._progress_proxy.reset()
+        from csaxs_bec.bec_ipython_client.plugins.flomni.flomni_webpage_generator import (
+            FlomniWebpageGenerator,
+        )
+        self._webpage_gen = FlomniWebpageGenerator(
+            bec_client=client,
+            output_dir="~/data/raw/webpage/",
+        )
+        self._webpage_gen.start()
+
         self.OMNYTools = OMNYTools(self.client)
         self.reconstructor = PtychoReconstructor(self.ptycho_reconstruct_foldername)
         self.tomo_id_manager = TomoIDManager()
@@ -1296,6 +1375,42 @@ class Flomni(
         self.special_angles = []
         self.special_angle_repeats = 1
 
+    @property
+    def progress(self) -> _ProgressProxy:
+        """Proxy dict backed by the BEC global variable ``tomo_progress``.
+
+        Readable from any BEC client session via::
+
+            client.get_global_var("tomo_progress")
+
+        Individual fields can be read and written just like a regular dict::
+
+            flomni.progress["projection"]          # read
+            flomni.progress["projection"] = 42     # write (persists immediately)
+
+        To update multiple fields atomically use :py:meth:`_ProgressProxy.update`::
+
+            flomni.progress.update(projection=42, angle=90.0)
+
+        To reset all fields to their defaults::
+
+            flomni.progress.reset()
+        """
+        return self._progress_proxy
+
+    @progress.setter
+    def progress(self, val: dict) -> None:
+        """Replace the entire progress dict.
+
+        Accepts a plain :class:`dict` and persists it to the global var store.
+        Example::
+
+            flomni.progress = {"projection": 0, "total_projections": 100, ...}
+        """
+        if not isinstance(val, dict):
+            raise TypeError(f"progress must be a dict, got {type(val).__name__!r}")
+        self._progress_proxy._save(val)
+
     @property
     def tomo_shellstep(self):
         val = self.client.get_global_var("tomo_shellstep")
@@ -1482,21 +1597,11 @@ class Flomni(
     def sample_name(self):
         return self.sample_get_name(0)
 
-    def write_to_scilog(self, content, tags: list = None):
-        try:
-            if tags is not None:
-                tags.append("BEC")
-            else:
-                tags = ["BEC"]
-            msg = bec.logbook.LogbookMessage()
-            msg.add_text(content).add_tag(tags)
-            self.client.logbook.send_logbook_message(msg)
-        except Exception:
-            logger.warning("Failed to write to scilog.")
-
     def tomo_alignment_scan(self):
         """
         Performs a tomogram alignment scan.
+        Collects all scan numbers acquired during the alignment, prints them at the end,
+        and creates a BEC scilog text entry summarising the alignment scan numbers.
         """
         if self.get_alignment_offset(0) == (0, 0, 0):
             print("It appears that the xrayeye alignemtn was not performend or loaded. Aborting.")
@@ -1506,11 +1611,9 @@ class Flomni(
 
         self.feye_out()
         tags = ["BEC_alignment_tomo", self.sample_name]
-        self.write_to_scilog(
-            f"Starting alignment scan. First scan number: {bec.queue.next_scan_number}.", tags
-        )
 
         start_angle = 0
+        alignment_scan_numbers = []
 
         angle_end = start_angle + 180
         for angle in np.linspace(start_angle, angle_end, num=int(180 / 45) + 1, endpoint=True):
@@ -1522,7 +1625,6 @@ class Flomni(
                     try:
                         start_scan_number = bec.queue.next_scan_number
                         self.tomo_scan_projection(angle)
-                        self.tomo_reconstruct()
                         error_caught = False
                     except AlarmBase as exc:
                         if exc.alarm_type == "TimeoutError":
@@ -1536,24 +1638,27 @@ class Flomni(
 
                 end_scan_number = bec.queue.next_scan_number
                 for scan_nr in range(start_scan_number, end_scan_number):
-                    self._write_tomo_scan_number(scan_nr, angle, 0)
+                    #self._write_tomo_scan_number(scan_nr, angle, 0)
+                    alignment_scan_numbers.append(scan_nr)
 
         umv(dev.fsamroy, 0)
         self.OMNYTools.printgreenbold(
             "\n\nAlignment scan finished. Please run SPEC_ptycho_align and load the new fit by flomni.read_alignment_offset() ."
         )
 
-    def _write_subtomo_to_scilog(self, subtomo_number):
-        dev = builtins.__dict__.get("dev")
-        bec = builtins.__dict__.get("bec")
-        if self.tomo_id > 0:
-            tags = ["BEC_subtomo", self.sample_name, f"tomo_id_{self.tomo_id}"]
-        else:
-            tags = ["BEC_subtomo", self.sample_name]
-        self.write_to_scilog(
-            f"Starting subtomo: {subtomo_number}. First scan number: {bec.queue.next_scan_number}.",
-            tags,
+        # summary of alignment scan numbers
+        scan_list_str = ", ".join(str(s) for s in alignment_scan_numbers)
+        #print(f"\nAlignment scan numbers ({len(alignment_scan_numbers)} total): {scan_list_str}")
+
+        # BEC scilog entry (no logo)
+        scilog_content = (
+            f"Alignment scan finished.\n"
+            f"Sample: {self.sample_name}\n"
+            f"Number of alignment scans: {len(alignment_scan_numbers)}\n"
+            f"Alignment scan numbers: {scan_list_str}\n"
         )
+        print(scliog_content)
+        bec.messaging.scilog.new().add_text(scilog_content.replace("\n", "<br>")).add_tags("alignmentscan").send()
 
     def sub_tomo_scan(self, subtomo_number, start_angle=None):
         """
@@ -1562,18 +1667,6 @@ class Flomni(
             subtomo_number (int): The sub tomogram number.
             start_angle (float, optional): The start angle of the scan. Defaults to None.
         """
-        #        dev = builtins.__dict__.get("dev")
-        #        bec = builtins.__dict__.get("bec")
-        #        if self.tomo_id > 0:
-        #            tags = ["BEC_subtomo", self.sample_name, f"tomo_id_{self.tomo_id}"]
-        #        else:
-        #            tags = ["BEC_subtomo", self.sample_name]
-        #        self.write_to_scilog(
-        #            f"Starting subtomo: {subtomo_number}. First scan number: {bec.queue.next_scan_number}.",
-        #            tags,
-        #        )
-
-        self._write_subtomo_to_scilog(subtomo_number)
 
         if start_angle is not None:
             print(f"Sub tomo scan with start angle {start_angle} requested.")
@@ -1673,6 +1766,7 @@ class Flomni(
         successful = False
         error_caught = False
         if 0 <= angle < 180.05:
+            self.progress["heartbeat"] = datetime.datetime.now().isoformat()
             print(f"Starting flOMNI scan for angle {angle} in subtomo {subtomo_number}")
             self._print_progress()
             while not successful:
@@ -1747,6 +1841,7 @@ class Flomni(
             # else:
             self.tomo_id = 0
             self.write_pdf_report()
+            self.progress["tomo_start_time"] = datetime.datetime.now().isoformat()
 
         with scans.dataset_id_on_hold:
             if self.tomo_type == 1:
@@ -1766,7 +1861,6 @@ class Flomni(
                 while True:
                     angle, subtomo_number = self._golden(ii, self.golden_ratio_bunch_size, 180, 1)
                     if previous_subtomo_number != subtomo_number:
-                        self._write_subtomo_to_scilog(subtomo_number)
                         if (
                             subtomo_number % 2 == 1
                             and ii > 10
@@ -1814,7 +1908,6 @@ class Flomni(
                         ii, int(180 / self.tomo_angle_stepsize), 180, 1, 0
                     )
                     if previous_subtomo_number != subtomo_number:
-                        self._write_subtomo_to_scilog(subtomo_number)
                         if (
                             subtomo_number % 2 == 1
                             and ii > 10
@@ -1856,14 +1949,42 @@ class Flomni(
         self._print_progress()
         self.OMNYTools.printgreenbold("Tomoscan finished")
 
+    @staticmethod
+    def _format_duration(seconds: float) -> str:
+        """Format a duration in seconds as a human-readable string, e.g. '2h 03m 15s'."""
+        seconds = int(seconds)
+        h, remainder = divmod(seconds, 3600)
+        m, s = divmod(remainder, 60)
+        if h > 0:
+            return f"{h}h {m:02d}m {s:02d}s"
+        if m > 0:
+            return f"{m}m {s:02d}s"
+        return f"{s}s"
+
     def _print_progress(self):
+        # --- compute and store estimated remaining time -----------------------
+        start_str = self.progress.get("tomo_start_time")
+        projection = self.progress["projection"]
+        total = self.progress["total_projections"]
+        if start_str is not None and total > 0 and projection > 9:
+            elapsed = (
+                datetime.datetime.now() - datetime.datetime.fromisoformat(start_str)
+            ).total_seconds()
+            rate = projection / elapsed  # projections per second
+            remaining_s = (total - projection) / rate
+            self.progress["estimated_remaining_time"] = remaining_s
+            eta_str = self._format_duration(remaining_s)
+        else:
+            eta_str = "N/A"
+        # ----------------------------------------------------------------------
         print("\x1b[95mProgress report:")
         print(f"Tomo type: ....................... {self.progress['tomo_type']}")
         print(f"Projection: ...................... {self.progress['projection']:.0f}")
         print(f"Total projections expected ....... {self.progress['total_projections']}")
         print(f"Angle: ........................... {self.progress['angle']}")
         print(f"Current subtomo: ................. {self.progress['subtomo']}")
-        print(f"Current projection within subtomo: {self.progress['subtomo_projection']}\x1b[0m")
+        print(f"Current projection within subtomo: {self.progress['subtomo_projection']}")
+        print(f"Estimated remaining time: ........ {eta_str}\x1b[0m")
         self._flomnigui_update_progress()
 
     def add_sample_database(
@@ -1887,7 +2008,6 @@ class Flomni(
             return
 
         self.tomo_scan_projection(angle)
-        self.tomo_reconstruct()
 
     def _golden(self, ii, howmany_sorted, maxangle, reverse=False):
         """returns the iis golden ratio angle of sorted bunches of howmany_sorted and its subtomo number"""
@@ -1992,7 +2112,7 @@ class Flomni(
                     f"{str(datetime.datetime.now())}: flomni scan projection at angle {angle}, scan"
                     f" number {bec.queue.next_scan_number}.\n"
                 )
-                # self.write_to_scilog(log_message, ["BEC_scans", self.sample_name])
+
                 scans.flomni_fermat_scan(
                     fovx=self.fovx,
                     fovy=self.fovy,
@@ -2005,6 +2125,9 @@ class Flomni(
                     corridor_size=corridor_size,
                 )
 
+        self.tomo_reconstruct()
+
+
     def tomo_parameters(self):
         """print and update the tomo parameters"""
         print("Current settings:")
@@ -2143,8 +2266,8 @@ class Flomni(
             + ' 888    888  "Y88888P"  888       888 888    Y888 8888888 \n'
         )
         padding = 20
-        fovxy = f"{self.fovx:.2f}/{self.fovy:.2f}"
-        stitching = f"{self.stitch_x:.2f}/{self.stitch_y:.2f}"
+        fovxy = f"{self.fovx:.1f}/{self.fovy:.1f}"
+        stitching = f"{self.stitch_x:.0f}/{self.stitch_y:.0f}"
         dataset_id = str(self.client.queue.next_dataset_number)
         account = bec.active_account
         content = [
@@ -2174,12 +2297,30 @@ class Flomni(
         #     "xterm /work/sls/spec/local/XOMNY/bin/upload/upload_last_pon.sh &", shell=True
         # )
         # status = subprocess.run(f"cp /tmp/spec-e20131-specES1.pdf {user_target}", shell=True)
-        msg = bec.logbook.LogbookMessage()
-        logo_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "LamNI_logo.png")
-        msg.add_file(logo_path).add_text("".join(content).replace("\n", "</p><p>")).add_tag(
-            ["BEC", "tomo_parameters", f"dataset_id_{dataset_id}", "flOMNI", self.sample_name]
-        )
-        self.client.logbook.send_logbook_message(msg)
+        # msg = bec.tomo_progress.tomo_progressMessage()
+        # logo_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "LamNI_logo.png")
+        # msg.add_file(logo_path).add_text("".join(content).replace("\n", "</p><p>")).add_tag(
+        #     ["BEC", "tomo_parameters", f"dataset_id_{dataset_id}", "flOMNI", self.sample_name]
+        # )
+        # self.client.tomo_progress.send_tomo_progress_message("~/data/raw/documentation/tomo_scan_ID_{self.tomo_id}.pdf").send()
+        import csaxs_bec
+
+
+        # Ensure this is a Path object, not a string
+        csaxs_bec_basepath = Path(csaxs_bec.__file__)
+
+        logo_file_rel = "flOMNI.png"
+
+        # Build the absolute path correctly
+        logo_file = (
+            csaxs_bec_basepath.parent
+            / "bec_ipython_client"
+            / "plugins"
+            / "flomni"
+            / logo_file_rel
+        ).resolve()
+        print(logo_file)
+        bec.messaging.scilog.new().add_attachment(logo_file).add_text(content.replace("\n", "<br>")).add_tags("tomoscan").send()
 
 
 if __name__ == "__main__":

csaxs_bec/bec_ipython_client/plugins/flomni/gui_tools.py

@@ -223,6 +223,14 @@ class flomniGuiTools:
         self._flomnigui_update_progress()
 
     def _flomnigui_update_progress(self):
+        """Update the progress ring bar and center label from the current progress state.
+
+        ``self.progress`` is backed by the BEC global variable ``tomo_progress``
+        (see :class:`_ProgressProxy` in ``flomni.py``), so this method reflects
+        the live state that is also accessible from other BEC client sessions via::
+
+            client.get_global_var("tomo_progress")
+        """
         main_progress_ring = self.progressbar.rings[0]
         subtomo_progress_ring = self.progressbar.rings[1]
         if self.progressbar is not None:
@@ -235,6 +243,31 @@ class flomniGuiTools:
             main_progress_ring.set_value(progress)
             subtomo_progress_ring.set_value(subtomo_progress)
 
+            # --- format start time for display --------------------------------
+            start_str = self.progress.get("tomo_start_time")
+            if start_str is not None:
+                import datetime as _dt
+                start_display = _dt.datetime.fromisoformat(start_str).strftime("%Y-%m-%d %H:%M:%S")
+            else:
+                start_display = "N/A"
+
+            # --- format estimated remaining time ------------------------------
+            remaining_s = self.progress.get("estimated_remaining_time")
+            if remaining_s is not None and remaining_s >= 0:
+                import datetime as _dt
+                remaining_s = int(remaining_s)
+                h, rem = divmod(remaining_s, 3600)
+                m, s = divmod(rem, 60)
+                if h > 0:
+                    eta_display = f"{h}h {m:02d}m {s:02d}s"
+                elif m > 0:
+                    eta_display = f"{m}m {s:02d}s"
+                else:
+                    eta_display = f"{s}s"
+            else:
+                eta_display = "N/A"
+            # ------------------------------------------------------------------
+
             text = (
                 f"Progress report:\n"
                 f" Tomo type:  {self.progress['tomo_type']}\n"
@@ -243,7 +276,9 @@ class flomniGuiTools:
                 f" Angle:  {self.progress['angle']:.1f}\n"
                 f" Current subtomo:  {self.progress['subtomo']}\n"
                 f" Current projection within subtomo: {self.progress['subtomo_projection']}\n"
-                f" Total projections per subtomo:  {int(self.progress['subtomo_total_projections'])}"
+                f" Total projections per subtomo:  {int(self.progress['subtomo_total_projections'])}\n"
+                f" Scan started:  {start_display}\n"
+                f" Est. remaining:  {eta_display}"
             )
             self.progressbar.set_center_label(text)
 

csaxs_bec/bec_ipython_client/plugins/omny/omny_webpage_generator.py

@@ -0,0 +1,96 @@
+"""
+omny/webpage_generator.py
+==========================
+OMNY-specific webpage generator subclass.
+
+Integration (inside the OMNY __init__ / startup):
+--------------------------------------------------
+    from csaxs_bec.bec_ipython_client.plugins.omny.webpage_generator import (
+        OmnyWebpageGenerator,
+    )
+    self._webpage_gen = OmnyWebpageGenerator(
+        bec_client=client,
+        output_dir="~/data/raw/webpage/",
+    )
+    self._webpage_gen.start()
+
+Or use the factory (auto-selects by session name "omny"):
+---------------------------------------------------------
+    from csaxs_bec.bec_ipython_client.plugins.flomni.webpage_generator import (
+        make_webpage_generator,
+    )
+    self._webpage_gen = make_webpage_generator(bec, output_dir="~/data/raw/webpage/")
+    self._webpage_gen.start()
+
+Interactive helpers:
+--------------------
+    omny._webpage_gen.status()
+    omny._webpage_gen.verbosity = 2
+    omny._webpage_gen.stop()
+    omny._webpage_gen.start()
+"""
+
+from pathlib import Path
+
+from csaxs_bec.bec_ipython_client.plugins.flomni.webpage_generator import (
+    WebpageGeneratorBase,
+    _safe_get,
+    _safe_float,
+    _gvar,
+)
+
+
+class OmnyWebpageGenerator(WebpageGeneratorBase):
+    """
+    OMNY-specific webpage generator.
+    Logo: OMNY.png from the same directory as this file.
+
+    Override _collect_setup_data() to add OMNY-specific temperatures,
+    sample name, and measurement settings.
+
+    The old OMNY spec webpage showed:
+        - Cryo temperatures (XOMNY-TEMP-CRYO-A/B)
+        - Per-channel temperatures (XOMNY-TEMP1..48)
+        - Dewar pressure / LN2 flow
+        - Interferometer strengths (OINTERF)
+    Map these to BEC device paths below once available.
+    """
+
+    # TODO: fill in OMNY-specific device paths
+    # label -> dotpath under device_manager.devices
+    _TEMP_MAP = {
+        # "Sample (cryo A)": "omny_temp.cryo_a",
+        # "Cryo head (B)":   "omny_temp.cryo_b",
+    }
+
+    def _logo_path(self):
+        return Path(__file__).parent / "OMNY.png"
+
+    def _collect_setup_data(self) -> dict:
+        # ── OMNY-specific data goes here ──────────────────────────────
+        # Uncomment and adapt when device names are known:
+        #
+        # dm = self._bec.device_manager
+        # sample_name = _safe_get(dm, "omny_samples.sample_names.sample0") or "N/A"
+        # temperatures = {
+        #     label: _safe_float(_safe_get(dm, path))
+        #     for label, path in self._TEMP_MAP.items()
+        # }
+        # settings = {
+        #     "Sample name":   sample_name,
+        #     "FOV x / y":     ...,
+        #     "Exposure time": _gvar(self._bec, "tomo_countingtime", ".3f", " s"),
+        #     "Angle step":    _gvar(self._bec, "tomo_angle_stepsize", ".2f", "\u00b0"),
+        # }
+        # return {
+        #     "type":         "omny",
+        #     "sample_name":  sample_name,
+        #     "temperatures": temperatures,
+        #     "settings":     settings,
+        # }
+
+        # Placeholder — returns minimal info until implemented
+        return {
+            "type": "omny",
+            # OMNY-specific data here
+        }