fix(lamni): go-live audit tier 2 -- wrong numbers and missing flomni ports
CI for csaxs_bec / test (push) Successful in 3m1s
CI for csaxs_bec / test (push) Successful in 3m1s
- tomo_scan_projection() now adds the projection to the reconstruction queue itself (like flomni), so custom at_each_angle hooks and direct calls are reconstructed; _at_each_angle()/MagLamNI no longer do it (no double entry). tomo_alignment_scan() opts out (_reconstruct=False) to keep its previous behaviour -- flomni's alignment projections are queued, LamNI's never were. - write_pdf_report(): branch on tomo_type (a golden-ratio scan reported a stale type-1 count and a hardcoded '8 sub-tomograms'), e-account from bec.active_account, tolerate a missing detector_distance. - tomo_parameters_cli(): range guards (stitch 0-50, frames 1-100, >= 8 projections, type-3 >= 1, golden max 0-1e6, bunch size 20-100). - Webpage: projection count for tomo type 1 used flomni's 180-degree sub-tomograms (half the real count); TOMO_TYPES gets a base_angle. Also show the piezo range, manual shift and 0-degree reference rows. - Tomo-params GUI: manual shift is mm end to end (label/range said um, +-1000); golden bunch size floor 20 for LamNI (setter/CLI already required it, so a smaller GUI value broke tomo_queue_execute). flomni fields untouched. - lfzp_info() and the queue 'move Energy' entry used the legacy 'mokev' device (only in device_configs/legacy); now ccm_energy. - Special-angle UnboundLocalError fixed in flomni too (list consumed only after a successful projection, so retries still see the special angle). - Tomo type 3: exact integer sub-tomogram numbering (float truncation mislabelled the boundary projection for ~35 values of n < 400). - XrayEyeAlign.align(): always reset the GUI (DAP forwarding, crosshair) on any failure; xrayeye_update_frame() warns when beamline states are invalid. - Stale text / debug print; gap doc updated with the current status. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
1 parent
ade447ae58
commit
ea7ba7e129
22 files changed
+1243
-73
No files matched your search
+48
@@ -1,5 +1,53 @@
|
||||
# flomni → lamni feature gaps still open (2026-07 sweep)
|
||||
|
||||
> **Status update (2026-09-25 go-live audit).** The sections below are the
|
||||
> original July findings; several are done since. Current state:
|
||||
>
|
||||
> - **Done**: §1 timing log + `scilog_last_ptycho_scans()`, §2 account-change
|
||||
> reset, §4 `lfzp_in()` skip-if-in-position, §6 `tomo_alignment_scan()` (12
|
||||
> angles over 360°, `write_alignment_scan_numbers()`). §7 (OSA clearance in
|
||||
> `lfzp_info()`) is implemented but **inactive** until `loptz`'s
|
||||
> `collision_offset` userParameter is commissioned in `ptycho_lamni.yaml`.
|
||||
> - **Still open**: §3 `collect_empty_frames()` (needs a decision whether
|
||||
> lamni's reconstruction uses flat fields), §5 hard-stop button in the GUI
|
||||
> (see the caveat in the audit notes below), §9 status-page rows (zero-degree
|
||||
> reference toggle is now shown; golden damage-check shots already were).
|
||||
> - **Fixed by the September audit** (LamNI compared against the running
|
||||
> flomni; tests in `tests/tests_bec_ipython_client/test_lamni_golive_fixes.py`
|
||||
> and siblings): projections silently dropped on a TimeoutError alarm
|
||||
> (also in `tomo_alignment_scan`); `leye_out()` opened the shutter instead of
|
||||
> closing it; endless golden-ratio scan crashed on its first projection and
|
||||
> any GUI failure aborted the scan; scilog writes used the removed
|
||||
> `bec.logbook` API; `raise_window()` could hide the GUI; tomo_scan_projection
|
||||
> now reconstructs itself like flomni (custom hooks were never reconstructed);
|
||||
> PDF report ignored the tomo type; CLI range guards; special-angle
|
||||
> `UnboundLocalError` (also fixed in flomni); tomo-type-3 sub-tomogram
|
||||
> boundary float truncation; `lfzp_info()`/queue "move Energy" used the
|
||||
> legacy `mokev` device (now `ccm_energy`); webpage showed half the
|
||||
> type-1 projection count; GUI manual-shift unit label (mm, not µm) and a
|
||||
> bunch-size floor of 20; x-ray-eye `align()` cleanup on any failure;
|
||||
> `xrayeye_update_frame()` beam-state warning.
|
||||
> - **Open questions found by the audit** (need a hardware/design decision, not
|
||||
> changed): default `lopty.limits = [3.0, 3.6]` excludes the FZP-in position
|
||||
> 3.724 from `ptycho_lamni.yaml`; no OSA collision guard in `losa_in()` (needs
|
||||
> LamNI's own geometry constant); the hard-stop button must not blindly reuse
|
||||
> flomni's `hard_abort_and_restore_positioning_mode()` (it runs `XQ#POSMODE`,
|
||||
> a transfer routine LamNI's Galil program may not have; LamNI has one Galil,
|
||||
> a SmarAct controller for the OSA and the RT controller);
|
||||
> `_write_tomo_scan_number()` writes the literal `'lamni'` (flomni: sanitized
|
||||
> sample name, 0cadd85) and `.3f` angles (flomni `.5f`); `LamniFermatScan`
|
||||
> lacks flomni's `randomize_offset` switch and `MAX_CORRIDOR_SIZE` cap
|
||||
> (19cfee3, 53f246a); `tomo_alignment_scan()` always runs the full eye-out
|
||||
> sequence (flomni skips it when already out).
|
||||
> - **Behaviour to be aware of**: flomni's `tomo_alignment_scan()` queues its
|
||||
> projections for reconstruction (it goes through `tomo_scan_projection`);
|
||||
> LamNI's deliberately does not (`_reconstruct=False`).
|
||||
> - **Same latent issues remain in flomni** (running in production, not
|
||||
> touched here): tomo-type-3 sub-tomogram boundary float truncation
|
||||
> (`flomni.py` `_golden_equally_spaced`), and the queue "move Energy" device
|
||||
> name `mokev` (`_TOMO_QUEUE_MOVE_DEVICES`) which is only defined in
|
||||
> `device_configs/legacy/`.
|
||||
|
||||
Follow-up to `FLOMNI_TO_LAMNI_COMPARISON.md` (flomni's `AI_docs/`) and this
|
||||
folder's `TOMO_QUEUE_PORT.md`/`TOMO_PARAMS_GUI_PORT.md` — those covered the
|
||||
tomo-queue backend, the GUI, the webpage generator, and the angle-distribution
|
||||
|
||||
@@ -59,7 +59,11 @@ class LamniWebpageGenerator(WebpageGeneratorBase):
|
||||
# FlomniWebpageGenerator's TOMO_TYPES -- confirmed against lamni.py's
|
||||
# actual tomo_scan()/sub_tomo_scan() implementation, not a guess.
|
||||
TOMO_TYPES = {
|
||||
1: {"kind": "equally_spaced_grid", "n_subtomos": 8},
|
||||
# base_angle 360: each lamni sub-tomogram sweeps the full circle
|
||||
# (N = int(360 / step), LamNI._tomo_type1_actual_grid()), unlike
|
||||
# flomni's 180-degree sub-tomograms -- without it the page showed
|
||||
# half the real projection count (144 instead of 288 at 10 deg).
|
||||
1: {"kind": "equally_spaced_grid", "n_subtomos": 8, "base_angle": 360},
|
||||
2: {"kind": "golden_capped"},
|
||||
3: {"kind": "golden_capped"},
|
||||
}
|
||||
@@ -72,6 +76,11 @@ class LamniWebpageGenerator(WebpageGeneratorBase):
|
||||
("tomo_type", "Type"),
|
||||
("tomo_countingtime", "Exposure (s)"),
|
||||
("tomo_circfov", "Circular FOV (µm)"),
|
||||
# the piezo range is the FOV of each ptycho tile actually scanned
|
||||
("lamni_piezo_range_x", "Piezo range x (µm)"),
|
||||
("lamni_piezo_range_y", "Piezo range y (µm)"),
|
||||
("manual_shift_x", "Manual shift x (mm)"),
|
||||
("manual_shift_y", "Manual shift y (mm)"),
|
||||
("tomo_angle_stepsize", "Angle step (°)"),
|
||||
("tomo_shellstep", "Shell step (µm)"),
|
||||
("lamni_stitch_x", "Stitch x"),
|
||||
@@ -82,6 +91,7 @@ class LamniWebpageGenerator(WebpageGeneratorBase):
|
||||
("golden_ratio_bunch_size", "Golden bunch size"),
|
||||
("golden_max_number_of_projections", "Golden max projections"),
|
||||
("golden_projections_at_0_deg_for_damage_estimation", "0° damage-check shots"),
|
||||
("zero_deg_reference_at_each_subtomo", "0° reference per sub-tomo"),
|
||||
("ptycho_reconstruct_foldername", "Recon folder"),
|
||||
]
|
||||
|
||||
|
||||
@@ -61,8 +61,8 @@ class MagLamNI(LamNI):
|
||||
lamni_at_each_angle(self, angle)
|
||||
return
|
||||
|
||||
# tomo_scan_projection() adds the projection to the reconstruction queue
|
||||
self.tomo_scan_projection(angle, _internal=True)
|
||||
self.tomo_reconstruct()
|
||||
|
||||
|
||||
class DataDrivenLamNI(LamNI):
|
||||
|
||||
@@ -163,10 +163,14 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
)
|
||||
|
||||
# Curated allow-list for the "move" queue action -- same beamline-wide
|
||||
# devices as flomni's (mokev, idgap). Lamni has no equivalent of
|
||||
# devices as flomni's (energy, idgap). Lamni has no equivalent of
|
||||
# flomni's ftray (sample-transfer tray) sim-testable bonus target.
|
||||
# The energy device is "ccm_energy" (bl_optics_hutch.yaml; also what
|
||||
# write_pdf_report()/lfzp_info() read) -- the legacy "mokev" only exists
|
||||
# in device_configs/legacy/, so a queued "move Energy" job would have
|
||||
# failed with a KeyError in dev["mokev"] and paused the queue.
|
||||
_TOMO_QUEUE_MOVE_DEVICES = {
|
||||
"mokev": {"label": "Energy", "unit": "keV"},
|
||||
"ccm_energy": {"label": "Energy", "unit": "keV"},
|
||||
"idgap": {"label": "Undulator gap", "unit": "mm"},
|
||||
}
|
||||
|
||||
@@ -575,9 +579,48 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
Args:
|
||||
keep_shutter_open: If True the shutter is left open after the frame.
|
||||
"""
|
||||
all_valid, bad_states = self._check_beamline_states_valid()
|
||||
if not all_valid:
|
||||
print(
|
||||
"Attention: not all beamline states are valid:\n "
|
||||
+ "\n ".join(bad_states)
|
||||
+ "\nThe beam may be down, so the frame could come back empty."
|
||||
)
|
||||
if not self.OMNYTools.yesno("Take a frame anyway?", "n"):
|
||||
print("Stopping.")
|
||||
return
|
||||
aligner = XrayEyeAlignGUI(self.client, self)
|
||||
aligner.update_frame(keep_shutter_open=keep_shutter_open)
|
||||
|
||||
def _check_beamline_states_valid(self):
|
||||
"""Return (all_valid, invalid_labels).
|
||||
|
||||
Reads every configured beamline state (bec.beamline_states) and
|
||||
collects the ones whose status is not "valid" (i.e. "invalid",
|
||||
"warning" or "unknown"). Used to warn before taking a manual X-ray
|
||||
eye frame: if e.g. the beam is down, the frame would come back empty
|
||||
and the user is left confused about why they see nothing. Ported from
|
||||
Flomni._check_beamline_states_valid() (4fe8d02).
|
||||
|
||||
Returns all_valid=True (with an empty list) if the beamline-state
|
||||
machinery isn't available at all, so this never blocks on a session
|
||||
that doesn't use beamline states.
|
||||
"""
|
||||
bec = builtins.__dict__.get("bec")
|
||||
manager = getattr(bec, "beamline_states", None) if bec is not None else None
|
||||
if manager is None:
|
||||
return True, []
|
||||
|
||||
bad = []
|
||||
for name in list(getattr(manager, "_states", {})):
|
||||
try:
|
||||
status = manager.get_status_by_name(name)
|
||||
except Exception: # pylint: disable=broad-except
|
||||
continue
|
||||
if status is not None and status != "valid":
|
||||
bad.append(f"{name}: {status}")
|
||||
return (len(bad) == 0), bad
|
||||
|
||||
def xrayeye_rotation_center_calibration_isolated(self, keep_shutter_open: bool = False):
|
||||
"""Determine new lsamx/lsamy rotation-center values for a sparse/isolated
|
||||
particle, via the X-ray eye GUI.
|
||||
@@ -1275,8 +1318,18 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
# Scan projection
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def tomo_scan_projection(self, angle: float, _internal: bool = False):
|
||||
"""Acquire one fermat-scan projection at `angle`.
|
||||
def tomo_scan_projection(
|
||||
self, angle: float, _internal: bool = False, _reconstruct: bool = True
|
||||
):
|
||||
"""Acquire one fermat-scan projection at `angle` and add it to the
|
||||
reconstruction queue (tomo_reconstruct()), like
|
||||
Flomni.tomo_scan_projection().
|
||||
|
||||
Reconstruction lives here, not in _at_each_angle(), so that custom
|
||||
at_each_angle hooks -- which call ``setup.tomo_scan_projection(angle,
|
||||
_internal=True)`` (see tomo_queue_mixin's hook example) -- and direct
|
||||
calls also get their projection reconstructed; it used to be
|
||||
skipped for them.
|
||||
|
||||
_internal=True is passed by callers that already sit inside an
|
||||
already-checked flow (tomo_scan()'s/tomo_alignment_scan()'s own
|
||||
@@ -1284,6 +1337,10 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
below only runs once per tomogram/alignment run instead of once per
|
||||
projection. Direct/standalone calls (the default) are checked every
|
||||
time, mirroring Flomni.tomo_scan_projection()'s _internal convention.
|
||||
|
||||
_reconstruct=False skips the reconstruction-queue entry; used by
|
||||
tomo_alignment_scan(), whose quick projections were never queued for
|
||||
reconstruction on lamni.
|
||||
"""
|
||||
scans = builtins.__dict__.get("scans")
|
||||
|
||||
@@ -1345,6 +1402,9 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
corridor_size=corridor_size,
|
||||
)
|
||||
|
||||
if _reconstruct:
|
||||
self.tomo_reconstruct()
|
||||
|
||||
def write_alignment_scan_numbers(
|
||||
self, first_scan: int, scans: list[int] | None = None
|
||||
) -> None:
|
||||
@@ -1437,7 +1497,7 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
for attempt in range(1, max_attempts + 1):
|
||||
start_scan_number = bec.queue.next_scan_number
|
||||
try:
|
||||
self.tomo_scan_projection(angle, _internal=True)
|
||||
self.tomo_scan_projection(angle, _internal=True, _reconstruct=False)
|
||||
break
|
||||
except AlarmBase as exc:
|
||||
if exc.alarm_type != "TimeoutError" or attempt == max_attempts:
|
||||
@@ -1511,8 +1571,9 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
hook(self, angle)
|
||||
return
|
||||
|
||||
# tomo_scan_projection() itself adds the projection to the
|
||||
# reconstruction queue -- do not call tomo_reconstruct() again here.
|
||||
self.tomo_scan_projection(angle, _internal=True)
|
||||
self.tomo_reconstruct()
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Progress reporting
|
||||
@@ -1864,7 +1925,13 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
):
|
||||
"""Return angles for equally spaced tomography with golden ratio sub-tomogram starting angles."""
|
||||
angular_step = maxangle / number_of_projections_per_subtomo
|
||||
subtomo_number = int((ii * angular_step) / maxangle) + 1
|
||||
# Exact integer division. The equivalent float expression
|
||||
# int((ii * angular_step) / maxangle) + 1 truncates just below an
|
||||
# integer for ii == k * n for some n (e.g. n = 19, 33, 38, 39, 66,
|
||||
# ...): the first projection of a sub-tomogram was then labelled with
|
||||
# the previous sub-tomogram number and acquired as a duplicate of its
|
||||
# closing angle, and the next sub-tomogram skipped its first angle.
|
||||
subtomo_number = int(ii // number_of_projections_per_subtomo) + 1
|
||||
start_angle = self._golden(subtomo_number - 1, 1, angular_step)[0]
|
||||
projection_number_of_subtomo = ii - (subtomo_number - 1) * number_of_projections_per_subtomo
|
||||
|
||||
@@ -2321,8 +2388,14 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
self.lamni_piezo_range_y = self._get_val(
|
||||
"<piezo range Y (max 80)> um", self.lamni_piezo_range_y, float, min_=0.1, max_=79.9
|
||||
)
|
||||
self.lamni_stitch_x = self._get_val("<stitch X>", self.lamni_stitch_x, int)
|
||||
self.lamni_stitch_y = self._get_val("<stitch Y>", self.lamni_stitch_y, int)
|
||||
# min 0: a negative stitch makes range(-n, n + 1) empty, so a
|
||||
# projection would silently run zero scans. max 50 = the GUI's range.
|
||||
self.lamni_stitch_x = self._get_val(
|
||||
"<stitch X>", self.lamni_stitch_x, int, min_=0, max_=50
|
||||
)
|
||||
self.lamni_stitch_y = self._get_val(
|
||||
"<stitch Y>", self.lamni_stitch_y, int, min_=0, max_=50
|
||||
)
|
||||
self.tomo_stitch_overlap = self._get_val(
|
||||
"<stitch overlap> um", self.tomo_stitch_overlap, float, min_=0.0, max_=10.0
|
||||
)
|
||||
@@ -2333,7 +2406,7 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
"Reconstruction queue", self.ptycho_reconstruct_foldername, str
|
||||
)
|
||||
self.frames_per_trigger = self._get_val(
|
||||
"Frames per trigger (burst)", self.frames_per_trigger, int
|
||||
"Frames per trigger (burst)", self.frames_per_trigger, int, min_=1, max_=100
|
||||
)
|
||||
|
||||
print("Tomography type:")
|
||||
@@ -2344,7 +2417,11 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
|
||||
if self.tomo_type == 1:
|
||||
_, _, current_total = self._tomo_type1_actual_grid()
|
||||
tomo_numberofprojections = self._get_val("Number of projections", current_total, int)
|
||||
# min 8: fewer than one projection per sub-tomogram makes
|
||||
# N = int(360 / step) zero and divides by zero later.
|
||||
tomo_numberofprojections = self._get_val(
|
||||
"Number of projections", current_total, int, min_=8, max_=10000
|
||||
)
|
||||
self.tomo_angle_stepsize = 360 / tomo_numberofprojections * 8
|
||||
# Report what was ACTUALLY achieved, via the same helper
|
||||
# sub_tomo_scan() itself uses -- not the raw value just typed in,
|
||||
@@ -2370,20 +2447,19 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
)
|
||||
|
||||
elif self.tomo_type == 2:
|
||||
while True:
|
||||
bunch_size = self._get_val(
|
||||
"Number of projections sorted per bunch (minimum 20)",
|
||||
self.golden_ratio_bunch_size,
|
||||
int,
|
||||
)
|
||||
if bunch_size >= 20:
|
||||
self.golden_ratio_bunch_size = bunch_size
|
||||
break
|
||||
print("Bunch size must be at least 20. Please try again.")
|
||||
self.golden_ratio_bunch_size = self._get_val(
|
||||
"Number of projections sorted per bunch (minimum 20)",
|
||||
self.golden_ratio_bunch_size,
|
||||
int,
|
||||
min_=20,
|
||||
max_=100,
|
||||
)
|
||||
self.golden_max_number_of_projections = self._get_val(
|
||||
"Stop after number of projections (0 for endless)",
|
||||
self.golden_max_number_of_projections,
|
||||
int,
|
||||
min_=0,
|
||||
max_=1_000_000,
|
||||
)
|
||||
self.golden_projections_at_0_deg_for_damage_estimation = self._get_val(
|
||||
"Repeat projections at 0 deg every second subtomo 1/0?",
|
||||
@@ -2393,13 +2469,19 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
|
||||
elif self.tomo_type == 3:
|
||||
numprj = self._get_val(
|
||||
"Number of projections per sub-tomogram", int(360 / self.tomo_angle_stepsize), int
|
||||
"Number of projections per sub-tomogram",
|
||||
int(360 / self.tomo_angle_stepsize),
|
||||
int,
|
||||
min_=1,
|
||||
max_=10000,
|
||||
)
|
||||
self.tomo_angle_stepsize = 360 / numprj
|
||||
self.golden_max_number_of_projections = self._get_val(
|
||||
"Stop after number of projections (0 for endless)",
|
||||
self.golden_max_number_of_projections,
|
||||
int,
|
||||
min_=0,
|
||||
max_=1_000_000,
|
||||
)
|
||||
self.golden_projections_at_0_deg_for_damage_estimation = self._get_val(
|
||||
"Repeat projections at 0 deg every second subtomo 1/0?",
|
||||
@@ -2467,7 +2549,52 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
piezo_range = f"{self.lamni_piezo_range_x:.2f}/{self.lamni_piezo_range_y:.2f}"
|
||||
stitching = f"{self.lamni_stitch_x:.2f}/{self.lamni_stitch_y:.2f}"
|
||||
dataset_id = str(self.client.queue.next_dataset_number)
|
||||
_, _, report_total_projections = self._tomo_type1_actual_grid()
|
||||
# bec.active_account, not client.username: the e-account the data is
|
||||
# stored under (same as flomni, c1ad2fc).
|
||||
account = getattr(builtins.__dict__.get("bec"), "active_account", None) or "N/A"
|
||||
# The correct total-projections / sub-tomogram-count / angular-step
|
||||
# values depend on which tomography type is actually configured --
|
||||
# mirrors tomo_parameters()'s tomo_type 1/2/3 branching and flomni's
|
||||
# write_pdf_report() (5a22651). This used to always call
|
||||
# _tomo_type1_actual_grid(), which is only meaningful for type 1: a
|
||||
# golden-ratio scan (type 2/3) reported a stale, unrelated type-1
|
||||
# total left over in the persistent tomo_angle_stepsize global var
|
||||
# instead of golden_max_number_of_projections, plus a hardcoded "8
|
||||
# sub-tomograms".
|
||||
if self.tomo_type == 1:
|
||||
_, achievable_step, total_projections = self._tomo_type1_actual_grid()
|
||||
subtomo_count_label = "Number of individual sub-tomograms:"
|
||||
subtomo_count_value = "8"
|
||||
angle_step_value = f"{achievable_step:.2f}"
|
||||
elif self.tomo_type == 3:
|
||||
total_projections = (
|
||||
self.golden_max_number_of_projections
|
||||
if self.golden_max_number_of_projections > 0
|
||||
else 0
|
||||
)
|
||||
subtomo_count_label = "Number of projections per sub-tomogram:"
|
||||
subtomo_count_value = f"{360 / self.tomo_angle_stepsize:.1f}"
|
||||
angle_step_value = f"{self.tomo_angle_stepsize:.2f}"
|
||||
else:
|
||||
# tomo_type == 2: golden ratio tomography -- there is no fixed set
|
||||
# of sub-tomograms or a fixed angular step, so report the bunch
|
||||
# size instead (matches tomo_parameters()'s printout).
|
||||
total_projections = (
|
||||
self.golden_max_number_of_projections
|
||||
if self.golden_max_number_of_projections > 0
|
||||
else 0
|
||||
)
|
||||
subtomo_count_label = "Sorted in bunches of:"
|
||||
subtomo_count_value = f"{self.golden_ratio_bunch_size}"
|
||||
angle_step_value = "N/A (golden ratio)"
|
||||
total_projections_str = (
|
||||
f"{total_projections:.0f}" if total_projections else "N/A (manual stop)"
|
||||
)
|
||||
last_scan_number_str = (
|
||||
f"{self.client.queue.next_scan_number + total_projections + 10:.0f}"
|
||||
if total_projections
|
||||
else "N/A"
|
||||
)
|
||||
# The energy readback device is "ccm_energy", not "mokev" -- and may
|
||||
# not be configured/available in every session (e.g. some simulated
|
||||
# configs). Read it defensively so a missing/misbehaving device
|
||||
@@ -2509,7 +2636,13 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
fzp_sample_distance_str = "N/A"
|
||||
# Sample-to-detector distance: userParameter on loptx, defaults to
|
||||
# -1 (unknown) until someone measures and sets it.
|
||||
detector_distance = self._get_user_param_safe("loptx", "detector_distance")
|
||||
# Read defensively like the other device values above: a missing
|
||||
# parameter must not crash the report after add_sample_database()
|
||||
# already registered this tomogram.
|
||||
try:
|
||||
detector_distance = self._get_user_param_safe("loptx", "detector_distance")
|
||||
except Exception:
|
||||
detector_distance = None
|
||||
detector_distance_str = (
|
||||
f"{detector_distance:.1f}" if detector_distance and detector_distance > 0 else "N/A"
|
||||
)
|
||||
@@ -2518,19 +2651,18 @@ class LamNI(TomoQueueMixin, LamNIAlignmentMixin, LamNIOpticsMixin, LamniGuiTools
|
||||
f"{'Measurement ID:':<{padding}}{self.tomo_id}\n",
|
||||
f"{'Dataset ID:':<{padding}}{dataset_id}\n",
|
||||
f"{'Sample Info:':<{padding}}Sample Info\n",
|
||||
f"{'e-account:':<{padding}}{self.client.username}\n",
|
||||
f"{'Number of projections:':<{padding}}{report_total_projections}\n",
|
||||
f"{'e-account:':<{padding}}{account}\n",
|
||||
f"{'Number of projections:':<{padding}}{total_projections_str}\n",
|
||||
f"{'First scan number:':<{padding}}{self.client.queue.next_scan_number}\n",
|
||||
f"{'Last scan number approx.:':<{padding}}"
|
||||
f"{self.client.queue.next_scan_number + report_total_projections + 10}\n",
|
||||
f"{'Last scan number approx.:':<{padding}}{last_scan_number_str}\n",
|
||||
f"{'Current photon energy:':<{padding}}{energy_str}\n",
|
||||
f"{'Exposure time:':<{padding}}{self.tomo_countingtime:.2f}\n",
|
||||
f"{'Fermat spiral step size:':<{padding}}{self.tomo_shellstep:.2f}\n",
|
||||
f"{'Piezo range (FOV sample plane):':<{padding}}{piezo_range}\n",
|
||||
f"{'Restriction to circular FOV:':<{padding}}{self.tomo_circfov:.2f}\n",
|
||||
f"{'Stitching:':<{padding}}{stitching}\n",
|
||||
f"{'Number of individual sub-tomograms:':<{padding}}8\n",
|
||||
f"{'Angular step within sub-tomogram:':<{padding}}{self.tomo_angle_stepsize:.2f}\n",
|
||||
f"{subtomo_count_label:<{padding}}{subtomo_count_value}\n",
|
||||
f"{'Angular step within sub-tomogram:':<{padding}}{angle_step_value}\n",
|
||||
f"{'Tomo type:':<{padding}}{self.tomo_type}\n",
|
||||
f"{'FZP diameter:':<{padding}}{fzp_diameter_um} microns\n",
|
||||
f"{'FZP outermost zone width:':<{padding}}{fzp_zone_width_nm} nm\n",
|
||||
|
||||
@@ -202,8 +202,10 @@ class LamNIAlignmentMixin:
|
||||
.. important::
|
||||
This method reads from the live GUI widget. If the XRayEye GUI
|
||||
window has been closed since the alignment was performed the call
|
||||
will fail. In that case use :meth:`read_xray_eye_correction` to
|
||||
reload from the archived text files.
|
||||
will fail. (The former file-based fallback
|
||||
``read_xray_eye_correction()`` is disabled -- see the commented-out
|
||||
code above -- so re-open the X-ray eye GUI and let the fit converge
|
||||
again, or re-run the alignment.)
|
||||
"""
|
||||
_dev = builtins.__dict__.get("dev")
|
||||
tomo_fit_xray_eye = np.zeros((2, 3))
|
||||
@@ -223,9 +225,8 @@ class LamNIAlignmentMixin:
|
||||
f"{type(params).__name__ if not isinstance(params, dict) else 'a dict missing keys'}). "
|
||||
"This means the fit hasn't converged / DAP forwarding hasn't produced "
|
||||
"a result yet, not that the correction data is missing. Wait for the "
|
||||
"fit to converge in the XRayEye GUI's Fit tab, or use "
|
||||
"read_xray_eye_correction() to reload from the archived text files "
|
||||
"instead."
|
||||
"fit to converge in the XRayEye GUI's Fit tab (keep the XRayEye "
|
||||
"window open), or re-run the alignment."
|
||||
)
|
||||
|
||||
tomo_fit_xray_eye[0][0] = params_x["SineModel_0_amplitude"]
|
||||
@@ -314,7 +315,6 @@ class LamNIAlignmentMixin:
|
||||
with open(correction_file, "r") as f:
|
||||
num_elements = f.readline()
|
||||
int_num_elements = int(num_elements.split(" ")[2])
|
||||
print(int_num_elements)
|
||||
corr_pos_x = []
|
||||
corr_pos_y = []
|
||||
corr_angle = []
|
||||
|
||||
@@ -459,11 +459,15 @@ class LamNIOpticsMixin:
|
||||
|
||||
def lfzp_info(self, mokev_val=-1):
|
||||
if mokev_val == -1:
|
||||
# The energy readback device is "ccm_energy" (same as flomni's
|
||||
# ffzp_info() and LamNI.write_pdf_report()); the legacy "mokev"
|
||||
# device is not in the current configs, so this always bailed out.
|
||||
try:
|
||||
mokev_val = dev.mokev.readback.get()
|
||||
mokev_val = dev.ccm_energy.read(cached=True)[dev.ccm_energy.name]["value"]
|
||||
except Exception:
|
||||
print(
|
||||
"Device mokev does not exist. You can specify the energy in keV as an argument instead."
|
||||
"Could not read the photon energy from device ccm_energy. "
|
||||
"You can specify the energy in keV as an argument instead."
|
||||
)
|
||||
return
|
||||
loptz_val = dev.loptz.read()["loptz"]["value"]
|
||||
|
||||
@@ -273,6 +273,35 @@ class XrayEyeAlign:
|
||||
return False
|
||||
|
||||
def align(self, keep_shutter_open: bool = False):
|
||||
"""Run the full LamNI X-ray eye alignment (see _align_impl() for the
|
||||
procedure).
|
||||
|
||||
Whatever ends the run -- success, Ctrl-C or ANY other exception (a GUI
|
||||
RPC error, a missing GUI output key, ...) -- the GUI is put back into
|
||||
a clean state afterwards: DAP parameter forwarding off and the
|
||||
alignment crosshair hidden. Previously only KeyboardInterrupt (handled
|
||||
by the caller) did this, so any other failure left forwarding on and
|
||||
the crosshair drawn. Mirrors flomni's XrayEyeAlign.align() try/finally
|
||||
(LamNI has no skip button or ROI vertical lock to reset).
|
||||
"""
|
||||
try:
|
||||
self.gui.reset_zoom()
|
||||
except Exception as exc: # pylint: disable=broad-except
|
||||
logger.warning(f"Failed to reset the XRayEye zoom: {exc}")
|
||||
|
||||
try:
|
||||
self._align_impl(keep_shutter_open)
|
||||
finally:
|
||||
try:
|
||||
self.gui.set_dap_params_forwarding(False)
|
||||
except Exception as exc: # pylint: disable=broad-except
|
||||
logger.warning(f"Failed to disable XRayEye DAP parameter forwarding: {exc}")
|
||||
try:
|
||||
self.gui.hide_crosshair()
|
||||
except Exception as exc: # pylint: disable=broad-except
|
||||
logger.warning(f"Failed to hide XRayEye alignment crosshair: {exc}")
|
||||
|
||||
def _align_impl(self, keep_shutter_open: bool = False):
|
||||
"""Run the full LamNI X-ray eye alignment.
|
||||
|
||||
Args:
|
||||
@@ -556,7 +585,7 @@ class XrayEyeAlign:
|
||||
self.tomo_rotate(0)
|
||||
print(
|
||||
"Done. You are ready to remove the X-ray eye and start ptychography scans.\n"
|
||||
"Fine alignment: lamni.tomo_parameters() with offset 0, then lamni.sub_tomo_scan(1,0)"
|
||||
"Fine alignment: lamni.tomo_parameters(), then lamni.tomo_alignment_scan()"
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
@@ -404,14 +404,21 @@ class WebpageGeneratorBase:
|
||||
takes. Used by the UI to compute total-projection
|
||||
counts for queued jobs without hardcoding a
|
||||
per-instrument formula in JS. Recognised "kind"s:
|
||||
"equally_spaced_grid" (params: n_subtomos)
|
||||
total = floor(180 / angle_stepsize) * n_subtomos
|
||||
"equally_spaced_grid" (params: n_subtomos,
|
||||
optional base_angle,
|
||||
default 180)
|
||||
total = floor(base_angle / angle_stepsize)
|
||||
* n_subtomos
|
||||
(independent of angle_range - see
|
||||
Flomni._subtomo_angle_plan()'s docstring for
|
||||
why: in 360-degree mode, angle_range only
|
||||
splits the n_subtomos into complementary
|
||||
low/high halves, it does not change the
|
||||
total count)
|
||||
total count). base_angle is the angular span
|
||||
ONE sub-tomogram covers: 180 for flomni, 360
|
||||
for lamni (which always sweeps the full
|
||||
circle per sub-tomogram -- see
|
||||
LamNI._tomo_type1_actual_grid()).
|
||||
"golden_capped"
|
||||
total = golden_max_number_of_projections
|
||||
TQ_PARAM_DISPLAY -- list of (global_var_key, display_label) pairs, in
|
||||
@@ -2701,13 +2708,15 @@ function calcProjections(params){{
|
||||
return (gmax!=null&&gmax>0)?gmax:null;
|
||||
}}
|
||||
if(def.kind==='equally_spaced_grid'){{
|
||||
// Always floor(180/step), never floor(angle_range/step): in 360-degree
|
||||
// mode angle_range only splits the sub-tomograms into complementary
|
||||
// low/high halves, it does not change the total projection count -
|
||||
// see Flomni._subtomo_angle_plan()'s docstring.
|
||||
// Always floor(base_angle/step), never floor(angle_range/step): in
|
||||
// 360-degree mode angle_range only splits the sub-tomograms into
|
||||
// complementary low/high halves, it does not change the total
|
||||
// projection count - see Flomni._subtomo_angle_plan()'s docstring.
|
||||
// base_angle is the span of one sub-tomogram: 180 (default, flomni) or
|
||||
// 360 (lamni, which sweeps the full circle in every sub-tomogram).
|
||||
const step=params.tomo_angle_stepsize;
|
||||
if(step>0){{
|
||||
const N=Math.floor(180/step);
|
||||
const N=Math.floor((def.base_angle||180)/step);
|
||||
return N*(def.n_subtomos||1);
|
||||
}}
|
||||
}}
|
||||
|
||||
@@ -2600,18 +2600,26 @@ class Flomni(
|
||||
|
||||
if not self.special_angles:
|
||||
self._current_special_angles = []
|
||||
if self._current_special_angles:
|
||||
next_special_angle = self._current_special_angles[0]
|
||||
if np.isclose(angle, next_special_angle, atol=0.5):
|
||||
self._current_special_angles.pop(0)
|
||||
num_repeats = self.special_angle_repeats
|
||||
else:
|
||||
num_repeats = 1
|
||||
# num_repeats is always defined (it used to be unbound whenever
|
||||
# special_angles was set but this angle wasn't near the next one
|
||||
# -> UnboundLocalError, retried 10x by @scan_repeat) and the
|
||||
# special-angle list is consumed only after the projection
|
||||
# succeeded, so a retried attempt still sees the same special
|
||||
# angle and repeat count.
|
||||
num_repeats = 1
|
||||
is_special_angle = bool(
|
||||
self._current_special_angles
|
||||
and np.isclose(angle, self._current_special_angles[0], atol=0.5)
|
||||
)
|
||||
if is_special_angle:
|
||||
num_repeats = self.special_angle_repeats
|
||||
start_scan_number = bec.queue.next_scan_number
|
||||
projection_start = time.perf_counter()
|
||||
for i in range(num_repeats):
|
||||
self._at_each_angle(angle)
|
||||
projection_duration = time.perf_counter() - projection_start
|
||||
if is_special_angle:
|
||||
self._current_special_angles.pop(0)
|
||||
|
||||
end_scan_number = bec.queue.next_scan_number
|
||||
for scan_nr in range(start_scan_number, end_scan_number):
|
||||
|
||||
@@ -676,8 +676,16 @@ class OMNY_TomoParams(BECWidget, QWidget):
|
||||
self._add_int(
|
||||
form, "_numprj_type3", "Projections per sub-tomo (type 3)", min_=1, max_=10000
|
||||
)
|
||||
# per-setup floor (SETUP_PROFILES[...]["golden_bunch_size_min"]): lamni's
|
||||
# golden_ratio_bunch_size setter/CLI reject < 20, so a GUI-legal
|
||||
# smaller value would raise ValueError in tomo_queue_execute() (which
|
||||
# setattr()s every job param) and pause the queue.
|
||||
self._add_int(
|
||||
form, "golden_ratio_bunch_size", "Bunch size (type 2 only)", min_=1, max_=100
|
||||
form,
|
||||
"golden_ratio_bunch_size",
|
||||
"Bunch size (type 2 only)",
|
||||
min_=self._profile.get("golden_bunch_size_min", 1),
|
||||
max_=100,
|
||||
)
|
||||
self._add_double(
|
||||
form,
|
||||
@@ -2322,6 +2330,7 @@ SETUP_PROFILES: dict[str, dict[str, Any]] = {
|
||||
"has_180_mode": True,
|
||||
"has_single_point": True,
|
||||
"has_zero_deg_reference": True,
|
||||
"golden_bunch_size_min": 1,
|
||||
"fov_fields": [
|
||||
("fovx", "FOV x (µm)", 0.1, 220.0, 2),
|
||||
("fovy", "FOV y (µm)", 0.1, 99.9, 2),
|
||||
@@ -2362,14 +2371,23 @@ SETUP_PROFILES: dict[str, dict[str, Any]] = {
|
||||
"has_180_mode": False,
|
||||
"has_single_point": False,
|
||||
"has_zero_deg_reference": True,
|
||||
# lamni.golden_ratio_bunch_size setter/CLI require >= 20 (see
|
||||
# _build_params_panel's bunch-size spinbox)
|
||||
"golden_bunch_size_min": 20,
|
||||
"fov_fields": [("tomo_circfov", "Circular FOV (µm, 0 = disabled)", 0.0, 500.0, 2)],
|
||||
"stitch_fields": [
|
||||
("lamni_stitch_x", "Stitch x", 0, 50),
|
||||
("lamni_stitch_y", "Stitch y", 0, 50),
|
||||
],
|
||||
# lamni's manual_shift_x/y are in mm end to end (added to the mm scan
|
||||
# centre in tomo_scan_projection -> lamni_fermat_scan(shift_x=...,
|
||||
# Units.mm), applied to lsamx/lsamy in mm; the CLI prints <mm>). This
|
||||
# was labelled "(µm)" with a +-1000 range, copied from flomni's field
|
||||
# (which really is um): typing "5" as um would have shifted the
|
||||
# scan by 5 mm. +-1 mm is the span the old um label implied.
|
||||
"manual_shift_fields": [
|
||||
("manual_shift_x", "Manual shift x (µm)", -1000.0, 1000.0, 3),
|
||||
("manual_shift_y", "Manual shift y (µm)", -1000.0, 1000.0, 3),
|
||||
("manual_shift_x", "Manual shift x (mm)", -1.0, 1.0, 4),
|
||||
("manual_shift_y", "Manual shift y (mm)", -1.0, 1.0, 4),
|
||||
],
|
||||
"piezo_range_fields": [
|
||||
("lamni_piezo_range_x", "Piezo range x (µm)", 0.1, 79.9, 2),
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
"""Special-angle handling in Flomni._tomo_scan_at_angle().
|
||||
|
||||
num_repeats used to be unbound whenever ``special_angles`` was set but the
|
||||
current angle wasn't near the next special angle (UnboundLocalError, retried
|
||||
10x by @scan_repeat and then aborting the tomogram), and the special-angle
|
||||
list was consumed before the projection ran, so a retried attempt no longer
|
||||
saw its special angle. (Same fix as LamNI's, see test_lamni_golive_fixes.py.)
|
||||
"""
|
||||
|
||||
import builtins
|
||||
import types
|
||||
|
||||
import csaxs_bec.bec_ipython_client.plugins.flomni.flomni as flomni_module
|
||||
from csaxs_bec.bec_ipython_client.plugins.flomni.flomni import Flomni, _ProgressProxy
|
||||
|
||||
|
||||
class _FakeClient:
|
||||
def __init__(self):
|
||||
self._vars = {}
|
||||
|
||||
def get_global_var(self, key):
|
||||
return self._vars.get(key)
|
||||
|
||||
def set_global_var(self, key, value):
|
||||
self._vars[key] = value
|
||||
|
||||
|
||||
def _make_flomni(monkeypatch):
|
||||
obj = object.__new__(Flomni)
|
||||
obj.client = _FakeClient()
|
||||
obj._progress_proxy = _ProgressProxy(obj.client)
|
||||
obj.tomo_angle_range = 180
|
||||
obj.special_angles = []
|
||||
obj.special_angle_repeats = 3
|
||||
obj._current_special_angles = []
|
||||
obj._print_progress = lambda: None
|
||||
obj._format_duration = lambda seconds: "0s"
|
||||
obj._write_tomo_scan_number = lambda *a, **k: None
|
||||
obj._log_projection_timing = lambda **k: None
|
||||
fake_bec = types.SimpleNamespace(queue=types.SimpleNamespace(next_scan_number=1))
|
||||
monkeypatch.setitem(builtins.__dict__, "bec", fake_bec)
|
||||
monkeypatch.setattr(flomni_module, "bec", fake_bec, raising=False)
|
||||
return obj
|
||||
|
||||
|
||||
def test_non_special_angle_with_special_list_does_not_crash(monkeypatch):
|
||||
flomni = _make_flomni(monkeypatch)
|
||||
flomni.special_angles = [90.0]
|
||||
flomni._current_special_angles = [90.0]
|
||||
calls = []
|
||||
flomni._at_each_angle = lambda angle: calls.append(angle)
|
||||
|
||||
flomni._tomo_scan_at_angle(0.0, 1)
|
||||
|
||||
assert calls == [0.0]
|
||||
assert flomni._current_special_angles == [90.0]
|
||||
|
||||
|
||||
def test_special_angle_repeats_and_is_consumed_once(monkeypatch):
|
||||
flomni = _make_flomni(monkeypatch)
|
||||
flomni.special_angles = [90.0]
|
||||
flomni._current_special_angles = [90.0]
|
||||
calls = []
|
||||
flomni._at_each_angle = lambda angle: calls.append(angle)
|
||||
|
||||
flomni._tomo_scan_at_angle(90.0, 1)
|
||||
|
||||
assert calls == [90.0] * 3
|
||||
assert flomni._current_special_angles == []
|
||||
|
||||
|
||||
def test_special_angle_repeats_survive_a_retry(monkeypatch):
|
||||
flomni = _make_flomni(monkeypatch)
|
||||
flomni.special_angles = [90.0]
|
||||
flomni._current_special_angles = [90.0]
|
||||
calls = []
|
||||
|
||||
def _at_each_angle(angle):
|
||||
calls.append(angle)
|
||||
if len(calls) == 1:
|
||||
raise RuntimeError("transient failure")
|
||||
|
||||
flomni._at_each_angle = _at_each_angle
|
||||
|
||||
flomni._tomo_scan_at_angle(90.0, 1) # @scan_repeat retries once
|
||||
|
||||
assert len(calls) == 1 + 3, "the retry must still repeat the special angle"
|
||||
assert flomni._current_special_angles == []
|
||||
@@ -44,3 +44,125 @@ def test_get_val_boundary_values_are_accepted(monkeypatch):
|
||||
_fake_inputs(monkeypatch, ["0.025", "20.0"])
|
||||
assert LamNI._get_val("a", 0.0, float, min_=0.025, max_=20.0) == 0.025
|
||||
assert LamNI._get_val("b", 0.0, float, min_=0.025, max_=20.0) == 20.0
|
||||
|
||||
|
||||
# ── tomo_parameters_cli(): the prompts must enforce sane ranges ─────────────
|
||||
#
|
||||
# It only enforced ranges on some prompts: a negative stitch made
|
||||
# range(-n, n + 1) empty (a projection silently ran zero scans), fewer than 8
|
||||
# projections gave N = 0 sub-tomogram angles (ZeroDivisionError later), 0
|
||||
# projections per type-3 sub-tomogram divided by zero, and frames per trigger /
|
||||
# the golden-ratio stop count were unbounded. Ranges mirror flomni's (158dc80,
|
||||
# 1dd03d1) and the tomo-params GUI (stitch 0-50 is lamni's own GUI range).
|
||||
|
||||
|
||||
class _CliClient:
|
||||
def __init__(self):
|
||||
self._vars = {}
|
||||
|
||||
def get_global_var(self, key):
|
||||
return self._vars.get(key)
|
||||
|
||||
def set_global_var(self, key, value):
|
||||
self._vars[key] = value
|
||||
|
||||
|
||||
def _make_cli_lamni(monkeypatch, answers: dict):
|
||||
"""A bare LamNI whose tomo_parameters_cli() is answered by prompt keyword:
|
||||
answers maps a substring of the prompt to the list of replies given for
|
||||
it, in order; anything not listed accepts the default (empty reply)."""
|
||||
import types
|
||||
|
||||
from csaxs_bec.bec_ipython_client.plugins.LamNI.lamni import _ProgressProxy
|
||||
|
||||
lamni = object.__new__(LamNI)
|
||||
lamni.client = _CliClient()
|
||||
lamni._progress_proxy = _ProgressProxy(lamni.client)
|
||||
lamni._expected_fermat_position_count = lambda: 1000
|
||||
lamni._fermat_min_positions = lambda: 10
|
||||
lamni._describe_active_hook = lambda: ""
|
||||
lamni.at_each_angle_hook = None
|
||||
lamni.reconstructor = types.SimpleNamespace(folder_name=None)
|
||||
lamni.OMNYTools = types.SimpleNamespace(yesno=lambda *a, **k: False) # "not correct" -> edit
|
||||
|
||||
queues = {key: list(vals) for key, vals in answers.items()}
|
||||
|
||||
def _input(prompt=""):
|
||||
for key, vals in queues.items():
|
||||
if key in prompt and vals:
|
||||
return vals.pop(0)
|
||||
return ""
|
||||
|
||||
monkeypatch.setattr(builtins, "input", _input)
|
||||
# the piezo-range setters consult dev.rtx.user_parameter
|
||||
import csaxs_bec.bec_ipython_client.plugins.LamNI.lamni as lamni_module
|
||||
|
||||
fake_dev = types.SimpleNamespace(rtx=types.SimpleNamespace(user_parameter={}))
|
||||
monkeypatch.setattr(lamni_module, "dev", fake_dev, raising=False)
|
||||
return lamni
|
||||
|
||||
|
||||
def test_cli_rejects_negative_stitch(monkeypatch, capsys):
|
||||
lamni = _make_cli_lamni(monkeypatch, {"<stitch X>": ["-1", "2"], "<stitch Y>": ["-3", "0"]})
|
||||
|
||||
lamni.tomo_parameters_cli()
|
||||
|
||||
assert (lamni.lamni_stitch_x, lamni.lamni_stitch_y) == (2, 0)
|
||||
assert "must be >= 0" in capsys.readouterr().out
|
||||
|
||||
|
||||
def test_cli_rejects_out_of_range_frames_per_trigger(monkeypatch):
|
||||
lamni = _make_cli_lamni(monkeypatch, {"Frames per trigger": ["0", "500", "5"]})
|
||||
|
||||
lamni.tomo_parameters_cli()
|
||||
|
||||
assert lamni.frames_per_trigger == 5
|
||||
|
||||
|
||||
def test_cli_type1_rejects_fewer_than_8_projections(monkeypatch):
|
||||
lamni = _make_cli_lamni(
|
||||
monkeypatch, {"Tomography type": ["1"], "Number of projections": ["0", "4", "144"]}
|
||||
)
|
||||
|
||||
lamni.tomo_parameters_cli()
|
||||
|
||||
assert lamni.tomo_angle_stepsize == 20.0 # 360 / 144 * 8
|
||||
assert lamni._tomo_type1_actual_grid()[2] == 144
|
||||
|
||||
|
||||
def test_cli_type2_enforces_bunch_size_of_at_least_20(monkeypatch, capsys):
|
||||
lamni = _make_cli_lamni(
|
||||
monkeypatch,
|
||||
{
|
||||
"Tomography type": ["2"],
|
||||
"sorted per bunch": ["5", "19", "150", "25"],
|
||||
"Stop after": ["-1", "2000000", "800"],
|
||||
},
|
||||
)
|
||||
|
||||
lamni.tomo_parameters_cli()
|
||||
|
||||
assert lamni.golden_ratio_bunch_size == 25
|
||||
assert lamni.golden_max_number_of_projections == 800
|
||||
out = capsys.readouterr().out
|
||||
assert "must be >= 20" in out
|
||||
assert "must be <= 100" in out
|
||||
assert "must be <= 1000000" in out
|
||||
|
||||
|
||||
def test_cli_type2_zero_is_an_allowed_endless_stop_count(monkeypatch):
|
||||
lamni = _make_cli_lamni(monkeypatch, {"Tomography type": ["2"], "Stop after": ["0"]})
|
||||
|
||||
lamni.tomo_parameters_cli()
|
||||
|
||||
assert lamni.golden_max_number_of_projections == 0
|
||||
|
||||
|
||||
def test_cli_type3_rejects_zero_projections_per_subtomogram(monkeypatch):
|
||||
lamni = _make_cli_lamni(
|
||||
monkeypatch, {"Tomography type": ["3"], "per sub-tomogram": ["0", "-4", "36"]}
|
||||
)
|
||||
|
||||
lamni.tomo_parameters_cli()
|
||||
|
||||
assert lamni.tomo_angle_stepsize == 10.0 # 360 / 36
|
||||
@@ -364,3 +364,205 @@ def test_write_to_scilog_without_messaging_service(monkeypatch):
|
||||
obj.client = FakeClient()
|
||||
monkeypatch.setitem(builtins.__dict__, "bec", types.SimpleNamespace())
|
||||
assert obj.write_to_scilog("x", ["t"]) is False
|
||||
|
||||
|
||||
# ── tomo_scan_projection adds the projection to the reconstruction queue ────
|
||||
#
|
||||
# Like flomni, reconstruction is done by tomo_scan_projection() itself, so
|
||||
# custom at_each_angle hooks (which call tomo_scan_projection(_internal=True))
|
||||
# and direct calls are reconstructed too. It used to live in _at_each_angle(),
|
||||
# so hooks silently produced no reconstruction entries.
|
||||
|
||||
|
||||
def make_lamni_for_projection(fake_bec):
|
||||
obj = object.__new__(LamNI)
|
||||
obj.client = FakeClient()
|
||||
obj._progress_proxy = _ProgressProxy(obj.client)
|
||||
obj.compute_additional_correction = lambda angle: (0, 0)
|
||||
obj.compute_additional_correction_2 = lambda angle: (0, 0)
|
||||
obj.lamni_compute_additional_correction_xeye_mu = lambda angle, verbose=True: (0, 0)
|
||||
obj.reconstruct_calls = []
|
||||
obj.tomo_reconstruct = lambda: obj.reconstruct_calls.append(1)
|
||||
obj.fermat_calls = []
|
||||
fake_scans = types.SimpleNamespace(
|
||||
lamni_fermat_scan=lambda **kw: obj.fermat_calls.append(kw)
|
||||
)
|
||||
return obj, fake_scans
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def projection_env(monkeypatch, fake_bec):
|
||||
obj, fake_scans = make_lamni_for_projection(fake_bec)
|
||||
monkeypatch.setitem(builtins.__dict__, "scans", fake_scans)
|
||||
return obj
|
||||
|
||||
|
||||
def test_tomo_scan_projection_reconstructs_exactly_once(projection_env):
|
||||
projection_env.tomo_scan_projection(30.0, _internal=True)
|
||||
|
||||
assert len(projection_env.fermat_calls) == 1
|
||||
assert projection_env.reconstruct_calls == [1]
|
||||
|
||||
|
||||
def test_tomo_scan_projection_reconstructs_once_per_projection_not_per_tile(projection_env):
|
||||
"""With stitching several Fermat scans make up one projection; the
|
||||
reconstruction entry is written once, after all tiles."""
|
||||
projection_env.lamni_stitch_x = 1 # 3 x 1 tiles
|
||||
projection_env.tomo_scan_projection(30.0, _internal=True)
|
||||
|
||||
assert len(projection_env.fermat_calls) == 3
|
||||
assert projection_env.reconstruct_calls == [1]
|
||||
|
||||
|
||||
def test_tomo_scan_projection_can_skip_reconstruction(projection_env):
|
||||
projection_env.tomo_scan_projection(30.0, _internal=True, _reconstruct=False)
|
||||
|
||||
assert len(projection_env.fermat_calls) == 1
|
||||
assert projection_env.reconstruct_calls == []
|
||||
|
||||
|
||||
def test_custom_hook_using_tomo_scan_projection_gets_reconstructed(projection_env):
|
||||
"""The documented hook pattern (tomo_queue_mixin's example) is just
|
||||
setup.tomo_scan_projection(angle, _internal=True)."""
|
||||
|
||||
def hook(setup, angle):
|
||||
setup.tomo_scan_projection(angle, _internal=True)
|
||||
|
||||
projection_env.at_each_angle_hook = "my_hook"
|
||||
projection_env._resolve_at_each_angle_hook = lambda name, err: hook
|
||||
|
||||
projection_env._at_each_angle(45.0)
|
||||
|
||||
assert projection_env.reconstruct_calls == [1]
|
||||
|
||||
|
||||
def test_default_at_each_angle_reconstructs_only_once(projection_env):
|
||||
projection_env.at_each_angle_hook = None
|
||||
|
||||
projection_env._at_each_angle(45.0)
|
||||
|
||||
assert projection_env.reconstruct_calls == [1], "must not be reconstructed twice"
|
||||
|
||||
|
||||
# ── tomo_type 3: sub-tomogram boundaries must be exact ──────────────────────
|
||||
|
||||
|
||||
@pytest.mark.parametrize("n_per_subtomo", range(1, 401))
|
||||
def test_type3_subtomo_numbering_is_exact(n_per_subtomo):
|
||||
"""subtomo_number was int((ii * step) / 360) + 1, which truncates one
|
||||
below the integer for ii == k * n at ~35 values of n < 400 (e.g. 19, 33,
|
||||
38, 39, 66): the first projection of a sub-tomogram got the previous
|
||||
sub-tomogram's number and a duplicate of its closing angle."""
|
||||
lamni = object.__new__(LamNI)
|
||||
for ii in range(0, 6 * n_per_subtomo + 1):
|
||||
angle, subtomo = lamni._golden_equally_spaced(ii, n_per_subtomo, maxangle=360, reverse=True)
|
||||
assert subtomo == ii // n_per_subtomo + 1, (n_per_subtomo, ii)
|
||||
assert 0 <= angle < 720
|
||||
|
||||
|
||||
@pytest.mark.parametrize("n_per_subtomo", [19, 33, 38, 39, 66, 76, 78, 103, 161])
|
||||
def test_type3_each_subtomo_has_n_distinct_angles(n_per_subtomo):
|
||||
lamni = object.__new__(LamNI)
|
||||
for subtomo in range(1, 5):
|
||||
angles = [
|
||||
lamni._golden_equally_spaced(
|
||||
(subtomo - 1) * n_per_subtomo + p, n_per_subtomo, maxangle=360, reverse=True
|
||||
)[0]
|
||||
% 360
|
||||
for p in range(n_per_subtomo)
|
||||
]
|
||||
assert len({round(a, 6) for a in angles}) == n_per_subtomo, (n_per_subtomo, subtomo)
|
||||
|
||||
|
||||
# ── xrayeye_update_frame warns when the beamline states are not valid ───────
|
||||
|
||||
|
||||
class _FakeStates:
|
||||
def __init__(self, statuses):
|
||||
self._states = dict(statuses)
|
||||
|
||||
def get_status_by_name(self, name):
|
||||
status = self._states[name]
|
||||
if isinstance(status, Exception):
|
||||
raise status
|
||||
return status
|
||||
|
||||
|
||||
def _update_frame_lamni(monkeypatch, states, answer_yes):
|
||||
obj = object.__new__(LamNI)
|
||||
obj.client = FakeClient()
|
||||
fake_bec = (
|
||||
types.SimpleNamespace(beamline_states=states)
|
||||
if states is not None
|
||||
else types.SimpleNamespace()
|
||||
)
|
||||
monkeypatch.setitem(builtins.__dict__, "bec", fake_bec)
|
||||
asked = []
|
||||
obj.OMNYTools = types.SimpleNamespace(
|
||||
yesno=lambda question, default: asked.append((question, default)) or answer_yes
|
||||
)
|
||||
frames = []
|
||||
|
||||
class FakeAligner:
|
||||
def __init__(self, client, lamni):
|
||||
pass
|
||||
|
||||
def update_frame(self, keep_shutter_open=False):
|
||||
frames.append(keep_shutter_open)
|
||||
|
||||
monkeypatch.setattr(lamni_module, "XrayEyeAlignGUI", FakeAligner)
|
||||
return obj, frames, asked
|
||||
|
||||
|
||||
def test_update_frame_takes_a_frame_when_all_states_are_valid(monkeypatch):
|
||||
lamni, frames, asked = _update_frame_lamni(
|
||||
monkeypatch, _FakeStates({"beam": "valid", "shutter": "valid"}), answer_yes=False
|
||||
)
|
||||
|
||||
lamni.xrayeye_update_frame(keep_shutter_open=True)
|
||||
|
||||
assert frames == [True]
|
||||
assert asked == []
|
||||
|
||||
|
||||
def test_update_frame_warns_and_stops_when_a_state_is_invalid(monkeypatch, capsys):
|
||||
lamni, frames, asked = _update_frame_lamni(
|
||||
monkeypatch, _FakeStates({"beam": "invalid", "shutter": "valid"}), answer_yes=False
|
||||
)
|
||||
|
||||
lamni.xrayeye_update_frame()
|
||||
|
||||
assert frames == []
|
||||
assert asked == [("Take a frame anyway?", "n")]
|
||||
out = capsys.readouterr().out
|
||||
assert "beam: invalid" in out
|
||||
assert "shutter" not in out.split("Attention")[1]
|
||||
|
||||
|
||||
def test_update_frame_proceeds_if_the_user_insists(monkeypatch):
|
||||
lamni, frames, _ = _update_frame_lamni(
|
||||
monkeypatch, _FakeStates({"beam": "warning"}), answer_yes=True
|
||||
)
|
||||
|
||||
lamni.xrayeye_update_frame()
|
||||
|
||||
assert frames == [False]
|
||||
|
||||
|
||||
def test_update_frame_never_blocks_without_beamline_states(monkeypatch):
|
||||
lamni, frames, asked = _update_frame_lamni(monkeypatch, None, answer_yes=False)
|
||||
|
||||
lamni.xrayeye_update_frame()
|
||||
|
||||
assert frames == [False]
|
||||
assert asked == []
|
||||
|
||||
|
||||
def test_update_frame_ignores_states_that_cannot_be_read(monkeypatch):
|
||||
lamni, frames, _ = _update_frame_lamni(
|
||||
monkeypatch, _FakeStates({"flaky": RuntimeError("unreadable"), "beam": "valid"}), True
|
||||
)
|
||||
|
||||
lamni.xrayeye_update_frame()
|
||||
|
||||
assert frames == [False]
|
||||
@@ -144,3 +144,37 @@ def test_lfzp_info_notes_parked_out(fake_dev, capsys):
|
||||
out = capsys.readouterr().out
|
||||
assert "likely parked OUT" in out
|
||||
assert "Remaining space if OSA is moved to its IN position" in out
|
||||
|
||||
|
||||
class FakeCcmEnergy:
|
||||
"""ccm_energy is a PSISimplePositioner: read(cached=True) -> {name: {"value": ...}}."""
|
||||
|
||||
name = "ccm_energy"
|
||||
|
||||
def read(self, cached=False):
|
||||
return {"ccm_energy": {"value": 6.2}}
|
||||
|
||||
|
||||
def test_lfzp_info_reads_the_energy_from_ccm_energy(fake_dev, capsys):
|
||||
"""It used to read dev.mokev, which only exists in device_configs/legacy/,
|
||||
so lfzp_info() without an argument always bailed out."""
|
||||
dev = fake_dev(collision_offset=113.0)
|
||||
del dev.mokev # not in the current configs
|
||||
dev.ccm_energy = FakeCcmEnergy()
|
||||
|
||||
make_optics().lfzp_info()
|
||||
|
||||
out = capsys.readouterr().out
|
||||
assert "6.2000 keV" in out
|
||||
assert "Could not read" not in out
|
||||
|
||||
|
||||
def test_lfzp_info_without_energy_device_explains_and_returns(fake_dev, capsys):
|
||||
dev = fake_dev(collision_offset=113.0)
|
||||
del dev.mokev
|
||||
|
||||
make_optics().lfzp_info() # no ccm_energy either: must not raise
|
||||
|
||||
out = capsys.readouterr().out
|
||||
assert "ccm_energy" in out
|
||||
assert "keV" in out # tells the user to pass the energy explicitly
|
||||
@@ -0,0 +1,172 @@
|
||||
"""Tests for LamNI.write_pdf_report()'s report content.
|
||||
|
||||
It always used the tomo_type-1 grid (int(360/tomo_angle_stepsize) * 8), so a
|
||||
golden-ratio tomogram (tomo_type 2/3) reported a stale type-1 projection count
|
||||
left over in the persistent tomo_angle_stepsize global var, and a hardcoded
|
||||
"8 sub-tomograms" -- fixed like flomni's 5a22651. It also read the
|
||||
e-account from client.username (flomni: bec.active_account, c1ad2fc), and a
|
||||
missing detector_distance userParameter crashed the report after the
|
||||
tomogram had already been registered.
|
||||
|
||||
Drives the real method with a fake PDFWriter that captures the report text.
|
||||
"""
|
||||
|
||||
import builtins
|
||||
import types
|
||||
|
||||
import pytest
|
||||
|
||||
import csaxs_bec.bec_ipython_client.plugins.LamNI.lamni as lamni_module
|
||||
from csaxs_bec.bec_ipython_client.plugins.LamNI.lamni import LamNI, _ProgressProxy
|
||||
|
||||
|
||||
class FakeClient:
|
||||
def __init__(self):
|
||||
self._vars = {}
|
||||
self.queue = types.SimpleNamespace(next_dataset_number=7, next_scan_number=1000)
|
||||
self.username = "unix_user"
|
||||
|
||||
def get_global_var(self, key):
|
||||
return self._vars.get(key)
|
||||
|
||||
def set_global_var(self, key, value):
|
||||
self._vars[key] = value
|
||||
|
||||
|
||||
class FakePDFWriter:
|
||||
written: list[str] = []
|
||||
|
||||
def __init__(self, path):
|
||||
self._pdf = types.SimpleNamespace(image=lambda *a, **k: None, ln=lambda *a, **k: None)
|
||||
|
||||
def __enter__(self):
|
||||
return self
|
||||
|
||||
def __exit__(self, *exc):
|
||||
return False
|
||||
|
||||
def write(self, text):
|
||||
FakePDFWriter.written.append(text)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def report_lamni(monkeypatch, tmp_path):
|
||||
FakePDFWriter.written = []
|
||||
monkeypatch.setattr(lamni_module, "PDFWriter", FakePDFWriter)
|
||||
monkeypatch.setattr(
|
||||
"os.path.expanduser",
|
||||
lambda p: p.replace("~", str(tmp_path)) if p.startswith("~") else p,
|
||||
)
|
||||
monkeypatch.setitem(
|
||||
builtins.__dict__,
|
||||
"bec",
|
||||
types.SimpleNamespace(active_account="e12345", messaging=types.SimpleNamespace()),
|
||||
)
|
||||
monkeypatch.setitem(builtins.__dict__, "dev", types.SimpleNamespace())
|
||||
|
||||
obj = object.__new__(LamNI)
|
||||
obj.client = FakeClient()
|
||||
obj._progress_proxy = _ProgressProxy(obj.client)
|
||||
obj.tomo_id = 42
|
||||
obj.sample_name = "sample1"
|
||||
obj._add_psi_footer = lambda file: None
|
||||
obj._upload_pdf_report_to_samples = lambda path: None
|
||||
obj._describe_active_hook = lambda: ""
|
||||
obj._active_hook_source = lambda: None
|
||||
obj._get_user_param_safe = lambda device, var: {"detector_distance": 1500.0}.get(var, "x")
|
||||
return obj
|
||||
|
||||
|
||||
def _report(lamni) -> str:
|
||||
lamni.write_pdf_report()
|
||||
assert FakePDFWriter.written, "no report was written"
|
||||
return FakePDFWriter.written[0]
|
||||
|
||||
|
||||
def _line(report: str, label: str) -> str:
|
||||
for line in report.splitlines():
|
||||
if line.startswith(label):
|
||||
return line[len(label) :].strip()
|
||||
raise AssertionError(f"{label!r} not in report:\n{report}")
|
||||
|
||||
|
||||
def test_type1_report_uses_the_grid(report_lamni):
|
||||
report_lamni.tomo_type = 1
|
||||
report_lamni.tomo_angle_stepsize = 10.0
|
||||
|
||||
report = _report(report_lamni)
|
||||
|
||||
assert _line(report, "Number of projections:") == "288"
|
||||
assert _line(report, "Number of individual sub-tomograms:") == "8"
|
||||
assert _line(report, "Angular step within sub-tomogram:") == "10.00"
|
||||
assert _line(report, "Last scan number approx.:") == "1298" # 1000 + 288 + 10
|
||||
|
||||
|
||||
def test_type1_report_shows_the_achievable_step_not_the_configured_one(report_lamni):
|
||||
"""7 deg does not divide 360: N = 51, achievable step 360/51 = 7.06."""
|
||||
report_lamni.tomo_type = 1
|
||||
report_lamni.tomo_angle_stepsize = 7.0
|
||||
|
||||
report = _report(report_lamni)
|
||||
|
||||
assert _line(report, "Number of projections:") == str(51 * 8)
|
||||
assert _line(report, "Angular step within sub-tomogram:") == "7.06"
|
||||
|
||||
|
||||
def test_golden_ratio_report_does_not_use_the_stale_type1_grid(report_lamni):
|
||||
report_lamni.tomo_type = 2
|
||||
report_lamni.tomo_angle_stepsize = 10.0 # stale type-1 leftover: would give 288
|
||||
report_lamni.golden_max_number_of_projections = 500
|
||||
report_lamni.golden_ratio_bunch_size = 30
|
||||
|
||||
report = _report(report_lamni)
|
||||
|
||||
assert _line(report, "Number of projections:") == "500"
|
||||
assert _line(report, "Sorted in bunches of:") == "30"
|
||||
assert _line(report, "Angular step within sub-tomogram:") == "N/A (golden ratio)"
|
||||
assert "Number of individual sub-tomograms" not in report
|
||||
assert _line(report, "Last scan number approx.:") == "1510"
|
||||
|
||||
|
||||
def test_golden_ratio_endless_scan_reports_manual_stop(report_lamni):
|
||||
report_lamni.tomo_type = 2
|
||||
report_lamni.golden_max_number_of_projections = 0
|
||||
report_lamni.golden_ratio_bunch_size = 20
|
||||
|
||||
report = _report(report_lamni)
|
||||
|
||||
assert _line(report, "Number of projections:") == "N/A (manual stop)"
|
||||
assert _line(report, "Last scan number approx.:") == "N/A"
|
||||
|
||||
|
||||
def test_type3_report_uses_projections_per_full_circle_subtomo(report_lamni):
|
||||
report_lamni.tomo_type = 3
|
||||
report_lamni.tomo_angle_stepsize = 10.0
|
||||
report_lamni.golden_max_number_of_projections = 400
|
||||
|
||||
report = _report(report_lamni)
|
||||
|
||||
assert _line(report, "Number of projections:") == "400"
|
||||
# lamni sub-tomograms span 360 degrees (flomni: 180)
|
||||
assert _line(report, "Number of projections per sub-tomogram:") == "36.0"
|
||||
assert _line(report, "Angular step within sub-tomogram:") == "10.00"
|
||||
|
||||
|
||||
def test_report_uses_the_active_account(report_lamni):
|
||||
report_lamni.tomo_type = 1
|
||||
report = _report(report_lamni)
|
||||
assert _line(report, "e-account:") == "e12345"
|
||||
|
||||
|
||||
def test_report_survives_a_missing_detector_distance(report_lamni):
|
||||
def _get(device, var):
|
||||
if var == "detector_distance":
|
||||
raise ValueError("no user parameter definition")
|
||||
return "x"
|
||||
|
||||
report_lamni._get_user_param_safe = _get
|
||||
report_lamni.tomo_type = 1
|
||||
|
||||
report = _report(report_lamni)
|
||||
|
||||
assert _line(report, "Sample-to-detector distance:") == "N/A mm"
|
||||
@@ -85,7 +85,7 @@ def test_tomo_alignment_scan_aborts_without_xray_eye_fit(monkeypatch):
|
||||
lamni = make_lamni(monkeypatch, xray_eye_fit=None)
|
||||
lamni._confirm_sequence_override = lambda *a, **k: False
|
||||
calls = []
|
||||
lamni.tomo_scan_projection = lambda angle: calls.append(angle)
|
||||
lamni.tomo_scan_projection = lambda angle, **kw: calls.append(angle)
|
||||
|
||||
lamni.tomo_alignment_scan()
|
||||
|
||||
@@ -97,7 +97,7 @@ def test_tomo_alignment_scan_runs_12_projections_across_360(monkeypatch):
|
||||
lamni = make_lamni(monkeypatch, xray_eye_fit=[[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])
|
||||
calls = []
|
||||
|
||||
def _fake_projection(angle, _internal=False):
|
||||
def _fake_projection(angle, _internal=False, **kw):
|
||||
calls.append(angle)
|
||||
builtins.__dict__["bec"].queue.next_scan_number += 1
|
||||
|
||||
@@ -115,7 +115,7 @@ def test_tomo_alignment_scan_runs_12_projections_across_360(monkeypatch):
|
||||
|
||||
def test_tomo_alignment_scan_rotates_back_to_zero(monkeypatch):
|
||||
lamni = make_lamni(monkeypatch, xray_eye_fit=[[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])
|
||||
lamni.tomo_scan_projection = lambda angle, _internal=False: None
|
||||
lamni.tomo_scan_projection = lambda angle, _internal=False, **kw: None
|
||||
umv_calls = []
|
||||
monkeypatch.setattr(lamni_module, "umv", lambda *a: umv_calls.append(a), raising=False)
|
||||
|
||||
@@ -166,7 +166,7 @@ def test_tomo_alignment_scan_retries_timed_out_angle_and_records_real_scan_numbe
|
||||
monkeypatch.setattr(lamni_module.time, "sleep", lambda s: None)
|
||||
calls = []
|
||||
|
||||
def _projection(angle, _internal=False):
|
||||
def _projection(angle, _internal=False, **kw):
|
||||
calls.append(angle)
|
||||
builtins.__dict__["bec"].queue.next_scan_number += 1 # each attempt uses a scan number
|
||||
if len(calls) == 3: # 3rd call = first attempt at the 3rd angle
|
||||
@@ -189,3 +189,17 @@ def test_tomo_alignment_scan_retries_timed_out_angle_and_records_real_scan_numbe
|
||||
assert [float(a) for a in lines[1].split()] == expected_angles
|
||||
content, _tags = lamni._scilog_calls[0]
|
||||
assert "Number of alignment scans: 12" in content
|
||||
|
||||
|
||||
def test_tomo_alignment_scan_projections_are_not_queued_for_reconstruction(monkeypatch):
|
||||
"""Alignment projections were never added to the reconstruction queue on
|
||||
lamni; moving tomo_reconstruct() into tomo_scan_projection() must not
|
||||
change that."""
|
||||
lamni = make_lamni(monkeypatch, xray_eye_fit=[[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])
|
||||
kwargs_seen = []
|
||||
lamni.tomo_scan_projection = lambda angle, **kw: kwargs_seen.append(kw)
|
||||
|
||||
lamni.tomo_alignment_scan()
|
||||
|
||||
assert len(kwargs_seen) == 12
|
||||
assert all(kw.get("_reconstruct") is False for kw in kwargs_seen)
|
||||
@@ -249,3 +249,76 @@ def test_compute_fermat_positions_lamni_zero_step_is_safe():
|
||||
)
|
||||
assert count == 0
|
||||
assert min_positions == LamniFermatScan.MIN_POSITIONS
|
||||
|
||||
|
||||
# ── golden bunch-size floor + manual-shift units ────────────────────────────
|
||||
#
|
||||
# lamni's golden_ratio_bunch_size setter/CLI reject < 20, but the shared GUI
|
||||
# spinbox allowed 1..100: a GUI-queued job with a smaller value made
|
||||
# tomo_queue_execute()'s setattr() raise ValueError and pause the queue.
|
||||
# The manual-shift fields were labelled um (+-1000) but lamni's manual shift is
|
||||
# mm end to end (added to the mm scan centre, applied to lsamx/lsamy in mm).
|
||||
|
||||
|
||||
def _bare_widget_for(setup: str):
|
||||
from qtpy.QtWidgets import QApplication
|
||||
|
||||
from csaxs_bec.bec_widgets.widgets.tomo_params.tomo_params import OMNY_TomoParams
|
||||
|
||||
QApplication.instance() or QApplication([])
|
||||
widget = OMNY_TomoParams.__new__(OMNY_TomoParams)
|
||||
widget._profile = SETUP_PROFILES[setup]
|
||||
widget._pw = {}
|
||||
return widget
|
||||
|
||||
|
||||
def test_lamni_bunch_size_spinbox_floor_is_20():
|
||||
widget = _bare_widget_for("lamni")
|
||||
box = widget._build_type23_section() # keep a reference: it owns the spinboxes
|
||||
assert box is not None
|
||||
assert widget._pw["golden_ratio_bunch_size"].minimum() == 20
|
||||
assert widget._pw["golden_ratio_bunch_size"].maximum() == 100
|
||||
|
||||
|
||||
def test_flomni_bunch_size_spinbox_is_unchanged():
|
||||
widget = _bare_widget_for("flomni")
|
||||
box = widget._build_type23_section() # keep a reference: it owns the spinboxes
|
||||
assert box is not None
|
||||
assert widget._pw["golden_ratio_bunch_size"].minimum() == 1
|
||||
|
||||
|
||||
def test_lamni_gui_bunch_size_floor_matches_the_setter():
|
||||
"""Every value the GUI can produce must be accepted by lamni's setter."""
|
||||
|
||||
class FakeClient:
|
||||
def __init__(self):
|
||||
self._vars = {}
|
||||
|
||||
def get_global_var(self, key):
|
||||
return self._vars.get(key)
|
||||
|
||||
def set_global_var(self, key, value):
|
||||
self._vars[key] = value
|
||||
|
||||
lamni = object.__new__(LamNI)
|
||||
lamni.client = FakeClient()
|
||||
floor = SETUP_PROFILES["lamni"]["golden_bunch_size_min"]
|
||||
|
||||
lamni.golden_ratio_bunch_size = floor # must not raise
|
||||
with pytest.raises(ValueError):
|
||||
lamni.golden_ratio_bunch_size = floor - 1
|
||||
|
||||
|
||||
def test_lamni_manual_shift_fields_are_in_mm():
|
||||
fields = SETUP_PROFILES["lamni"]["manual_shift_fields"]
|
||||
assert [f[0] for f in fields] == ["manual_shift_x", "manual_shift_y"]
|
||||
for _key, label, min_, max_, _decimals in fields:
|
||||
assert "(mm)" in label and "µm" not in label
|
||||
assert (min_, max_) == (-1.0, 1.0)
|
||||
|
||||
|
||||
def test_flomni_manual_shift_field_is_still_um():
|
||||
"""flomni's own field really is um -- must not be touched."""
|
||||
(_key, label, min_, max_, _dec), = SETUP_PROFILES["flomni"]["manual_shift_fields"]
|
||||
assert "µm" in label
|
||||
assert (min_, max_) == (-50.0, 50.0)
|
||||
@@ -166,17 +166,19 @@ def test_tomo_queue_execute_resumes_incomplete_job():
|
||||
|
||||
def test_tomo_queue_add_command_move_action(monkeypatch):
|
||||
lamni = make_lamni()
|
||||
fake_dev = {"mokev": "mokev-device"}
|
||||
# lamni's energy device is ccm_energy (the legacy "mokev" is not in the
|
||||
# current configs)
|
||||
fake_dev = {"ccm_energy": "ccm_energy-device"}
|
||||
moved = []
|
||||
monkeypatch.setattr(tomo_queue_mixin, "dev", fake_dev, raising=False)
|
||||
monkeypatch.setattr(tomo_queue_mixin, "umv", lambda *a: moved.append(a), raising=False)
|
||||
|
||||
lamni.tomo_queue_add_command(
|
||||
{"action": "move", "kwargs": {"positions": {"mokev": 6.2}}}, label="reconfigure"
|
||||
{"action": "move", "kwargs": {"positions": {"ccm_energy": 6.2}}}, label="reconfigure"
|
||||
)
|
||||
lamni.tomo_queue_execute()
|
||||
|
||||
assert moved == [("mokev-device", 6.2)]
|
||||
assert moved == [("ccm_energy-device", 6.2)]
|
||||
job = lamni._tomo_queue_proxy.as_list()[0]
|
||||
assert job["kind"] == "command"
|
||||
assert job["status"] == "done"
|
||||
@@ -204,16 +206,19 @@ def test_register_at_each_angle_hook_dispatches_from_at_each_angle():
|
||||
|
||||
|
||||
def test_at_each_angle_default_path_unchanged_without_hook():
|
||||
"""No hook registered -- must fall through to the exact same default
|
||||
behaviour lamni had before this port: tomo_scan_projection + tomo_reconstruct."""
|
||||
"""No hook registered -- falls through to tomo_scan_projection(), which
|
||||
itself adds the projection to the reconstruction queue (like flomni), so
|
||||
_at_each_angle() must NOT call tomo_reconstruct() a second time."""
|
||||
lamni = make_lamni()
|
||||
calls = []
|
||||
lamni.tomo_scan_projection = lambda angle, _internal=False: calls.append(("projection", angle))
|
||||
lamni.tomo_scan_projection = lambda angle, _internal=False, **kw: calls.append(
|
||||
("projection", angle, _internal)
|
||||
)
|
||||
lamni.tomo_reconstruct = lambda: calls.append(("reconstruct",))
|
||||
|
||||
lamni._at_each_angle(30.0)
|
||||
|
||||
assert calls == [("projection", 30.0), ("reconstruct",)]
|
||||
assert calls == [("projection", 30.0, True)]
|
||||
|
||||
|
||||
def test_at_each_angle_raises_for_unregistered_hook_name():
|
||||
|
||||
@@ -191,7 +191,7 @@ def test_tomo_queue_reacquire_resets_later_jobs_to_pending_tomo_and_command():
|
||||
|
||||
i0 = lamni.tomo_queue_add(label="job0")
|
||||
i1 = lamni.tomo_queue_add(label="job1")
|
||||
lamni.tomo_queue_add_command({"action": "move", "kwargs": {"positions": {"mokev": 6.2}}})
|
||||
lamni.tomo_queue_add_command({"action": "move", "kwargs": {"positions": {"ccm_energy": 6.2}}})
|
||||
i3 = lamni.tomo_queue_add(label="job3")
|
||||
|
||||
for i in (i0, i1, i3):
|
||||
@@ -213,7 +213,7 @@ def test_tomo_queue_reacquire_rejects_out_of_range_job_index():
|
||||
|
||||
def test_tomo_queue_reacquire_rejects_command_job():
|
||||
lamni = make_lamni()
|
||||
lamni.tomo_queue_add_command({"action": "move", "kwargs": {"positions": {"mokev": 6.2}}})
|
||||
lamni.tomo_queue_add_command({"action": "move", "kwargs": {"positions": {"ccm_energy": 6.2}}})
|
||||
with pytest.raises(TomoQueueError):
|
||||
lamni.tomo_queue_reacquire(0, projection_number=0)
|
||||
|
||||
|
||||
@@ -0,0 +1,108 @@
|
||||
"""The status webpage computes a job's total projection count in JS
|
||||
(calcProjections) from a per-setup TOMO_TYPES table.
|
||||
|
||||
For lamni's equally-spaced tomo_type 1 it used to hardcode flomni's
|
||||
floor(180/step) * 8, so the page showed half of the real count (144 instead of
|
||||
288 at a 10 degree step): lamni sweeps the full 360 degrees in every
|
||||
sub-tomogram (N = int(360/step), see LamNI._tomo_type1_actual_grid()).
|
||||
|
||||
There is no JS engine in the test environment, so this checks the data the JS
|
||||
consumes (the TOMO_TYPES JSON rendered into the page) and that the JS uses
|
||||
it, and cross-checks the formula against the real LamNI grid.
|
||||
"""
|
||||
|
||||
import json
|
||||
import math
|
||||
import re
|
||||
|
||||
import pytest
|
||||
|
||||
from csaxs_bec.bec_ipython_client.plugins.flomni.flomni_webpage_generator import (
|
||||
FlomniWebpageGenerator,
|
||||
)
|
||||
from csaxs_bec.bec_ipython_client.plugins.LamNI.lamni import LamNI, _ProgressProxy
|
||||
from csaxs_bec.bec_ipython_client.plugins.LamNI.LamNI_webpage_generator import (
|
||||
LamniWebpageGenerator,
|
||||
)
|
||||
from csaxs_bec.bec_ipython_client.plugins.OMNY_shared.webpage_generator_base import _render_html
|
||||
|
||||
|
||||
class FakeClient:
|
||||
"""Minimal in-memory stand-in for BEC's global-var store."""
|
||||
|
||||
def __init__(self):
|
||||
self._vars = {}
|
||||
|
||||
def get_global_var(self, key):
|
||||
return self._vars.get(key)
|
||||
|
||||
def set_global_var(self, key, value):
|
||||
self._vars[key] = value
|
||||
|
||||
|
||||
def _rendered_tomo_types(generator_cls) -> dict:
|
||||
html = _render_html(
|
||||
[], generator_cls.HAS_TOMO_QUEUE, generator_cls.TOMO_TYPES, generator_cls.TQ_PARAM_DISPLAY
|
||||
)
|
||||
match = re.search(r"const TOMO_TYPES = (\{.*?\});", html, re.S)
|
||||
assert match, "TOMO_TYPES not found in the rendered page"
|
||||
# JSON object keys are strings once serialized
|
||||
return json.loads(match.group(1))
|
||||
|
||||
|
||||
def _js_expression_for_grid(generator_cls) -> str:
|
||||
html = _render_html(
|
||||
[], generator_cls.HAS_TOMO_QUEUE, generator_cls.TOMO_TYPES, generator_cls.TQ_PARAM_DISPLAY
|
||||
)
|
||||
match = re.search(r"const N=Math\.floor\((.*?)/step\);", html)
|
||||
assert match, "grid projection formula not found in the rendered page"
|
||||
return match.group(1)
|
||||
|
||||
|
||||
def test_page_js_uses_the_per_setup_base_angle():
|
||||
assert _js_expression_for_grid(LamniWebpageGenerator) == "(def.base_angle||180)"
|
||||
|
||||
|
||||
def test_lamni_grid_type_declares_360_degree_sub_tomograms():
|
||||
types = _rendered_tomo_types(LamniWebpageGenerator)
|
||||
assert types["1"] == {"kind": "equally_spaced_grid", "n_subtomos": 8, "base_angle": 360}
|
||||
|
||||
|
||||
def test_flomni_grid_type_is_unchanged():
|
||||
"""flomni's page must keep computing floor(180/step) * 8."""
|
||||
types = _rendered_tomo_types(FlomniWebpageGenerator)
|
||||
assert types["1"] == {"kind": "equally_spaced_grid", "n_subtomos": 8}
|
||||
assert "base_angle" not in types["1"]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("stepsize", [10.0, 7.0, 25.0, 12.5, 5.0])
|
||||
def test_page_projection_count_matches_the_real_lamni_grid(stepsize):
|
||||
grid = LamniWebpageGenerator.TOMO_TYPES[1]
|
||||
page_total = math.floor(grid.get("base_angle", 180) / stepsize) * grid["n_subtomos"]
|
||||
|
||||
lamni = object.__new__(LamNI)
|
||||
lamni.client = FakeClient()
|
||||
lamni._progress_proxy = _ProgressProxy(lamni.client)
|
||||
lamni.tomo_angle_stepsize = stepsize
|
||||
_n, _step, real_total = lamni._tomo_type1_actual_grid()
|
||||
|
||||
assert page_total == real_total
|
||||
|
||||
|
||||
def test_lamni_10_degree_step_shows_288_not_144():
|
||||
grid = LamniWebpageGenerator.TOMO_TYPES[1]
|
||||
assert math.floor(grid["base_angle"] / 10.0) * grid["n_subtomos"] == 288
|
||||
|
||||
|
||||
def test_lamni_param_table_only_shows_real_lamni_parameters():
|
||||
"""Every row of the page's parameter table must be a parameter the
|
||||
tomo queue actually stores for lamni (or the special hook row)."""
|
||||
known = set(LamNI._TOMO_SCAN_PARAM_NAMES) | {"tomo_type"}
|
||||
for key, _label in LamniWebpageGenerator.TQ_PARAM_DISPLAY:
|
||||
assert key in known, f"{key!r} is not a lamni tomo-queue parameter"
|
||||
|
||||
|
||||
def test_lamni_param_table_shows_the_scan_fov_and_manual_shift():
|
||||
keys = [key for key, _label in LamniWebpageGenerator.TQ_PARAM_DISPLAY]
|
||||
for wanted in ("lamni_piezo_range_x", "lamni_piezo_range_y", "manual_shift_x", "manual_shift_y"):
|
||||
assert wanted in keys
|
||||
@@ -586,4 +586,60 @@ def test_find_rotation_center_smear_experimental_saves_composites_and_clicks(bec
|
||||
save_mock.assert_called_once()
|
||||
_, kwargs = save_mock.call_args
|
||||
assert kwargs["fzp_xy"] == (0.0, 0.0)
|
||||
assert kwargs["sweep_deg"] == 45.0
|
||||
assert kwargs["sweep_deg"] == 45.0
|
||||
|
||||
# ── align() must always leave the GUI clean ─────────────────────────────────
|
||||
#
|
||||
# Only KeyboardInterrupt (handled by the caller) used to reset the GUI; any
|
||||
# other exception (a GUI RPC error, a missing GUI output key, ...) left DAP
|
||||
# parameter forwarding on and the alignment crosshair drawn. Mirrors flomni's
|
||||
# XrayEyeAlign.align() try/finally.
|
||||
|
||||
|
||||
def _bare_aligner():
|
||||
aligner = object.__new__(XrayEyeAlign)
|
||||
# .gui is a read-only property returning self.lamni.xeyegui
|
||||
aligner.lamni = mock.MagicMock()
|
||||
return aligner
|
||||
|
||||
|
||||
def test_align_cleans_up_gui_after_success():
|
||||
aligner = _bare_aligner()
|
||||
aligner._align_impl = mock.MagicMock()
|
||||
|
||||
aligner.align(keep_shutter_open=True)
|
||||
|
||||
aligner._align_impl.assert_called_once_with(True)
|
||||
aligner.lamni.xeyegui.set_dap_params_forwarding.assert_called_with(False)
|
||||
aligner.lamni.xeyegui.hide_crosshair.assert_called_once()
|
||||
|
||||
|
||||
def test_align_cleans_up_gui_after_any_exception_and_reraises():
|
||||
aligner = _bare_aligner()
|
||||
aligner._align_impl = mock.MagicMock(side_effect=KeyError("gui output key missing"))
|
||||
|
||||
with pytest.raises(KeyError):
|
||||
aligner.align()
|
||||
|
||||
aligner.lamni.xeyegui.set_dap_params_forwarding.assert_called_with(False)
|
||||
aligner.lamni.xeyegui.hide_crosshair.assert_called_once()
|
||||
|
||||
|
||||
def test_align_cleanup_failures_do_not_mask_the_original_error():
|
||||
aligner = _bare_aligner()
|
||||
aligner._align_impl = mock.MagicMock(side_effect=ValueError("real problem"))
|
||||
aligner.lamni.xeyegui.set_dap_params_forwarding.side_effect = RuntimeError("GUI gone")
|
||||
aligner.lamni.xeyegui.hide_crosshair.side_effect = RuntimeError("GUI gone")
|
||||
|
||||
with pytest.raises(ValueError, match="real problem"):
|
||||
aligner.align()
|
||||
|
||||
|
||||
def test_align_survives_a_gui_without_reset_zoom():
|
||||
aligner = _bare_aligner()
|
||||
aligner.lamni.xeyegui.reset_zoom.side_effect = AttributeError("no reset_zoom")
|
||||
aligner._align_impl = mock.MagicMock()
|
||||
|
||||
aligner.align()
|
||||
|
||||
aligner._align_impl.assert_called_once_with(False)
|
||||
@@ -1,5 +1,7 @@
|
||||
from unittest import mock
|
||||
|
||||
import numpy as np
|
||||
|
||||
from csaxs_bec.scans.lamni_fermat_scan import LamniFermatScan
|
||||
|
||||
|
||||
@@ -57,3 +59,39 @@ def test_lamni_fermat_spiral_reaches_elongated_fov_corners():
|
||||
-fovx / 2, fovx / 2, -fovy / 2, fovy / 2, step=1, fovx=fovx, fovy=fovy
|
||||
)
|
||||
assert len(pos) >= 60
|
||||
|
||||
|
||||
def _spiral(**overrides):
|
||||
kwargs = dict(
|
||||
m1_start=-40.0,
|
||||
m1_stop=40.0,
|
||||
m2_start=-40.0,
|
||||
m2_stop=40.0,
|
||||
step=10.0,
|
||||
angle=0.0,
|
||||
fovx=80.0,
|
||||
fovy=80.0,
|
||||
seed=0,
|
||||
)
|
||||
kwargs.update(overrides)
|
||||
return LamniFermatScan.get_lamni_fermat_spiral_pos(**kwargs)
|
||||
|
||||
|
||||
def test_shift_and_center_are_mm_and_positions_are_um():
|
||||
"""Unit contract of the LamNI scan: shift_x/shift_y (LamNI's manual shift)
|
||||
and center_x/center_y (the FOV offsets) are in mm, the generated scan
|
||||
positions handed to the RT controller are in um. A shift of 0.01 mm must
|
||||
therefore move every position by exactly 10 um.
|
||||
|
||||
(The tomo-parameters GUI used to label the manual shift "um" with a
|
||||
+-1000 range -- copied from flomni -- although it is mm end to end.)
|
||||
"""
|
||||
base = _spiral()
|
||||
shifted_x = _spiral(shift_x=0.01)
|
||||
shifted_y = _spiral(shift_y=0.005)
|
||||
centered_x = _spiral(center_x=0.01) # at angle 0, stitch 0: same physical shift
|
||||
|
||||
assert base.shape == shifted_x.shape == shifted_y.shape == centered_x.shape
|
||||
np.testing.assert_allclose(shifted_x - base, [[10.0, 0.0]] * len(base), atol=1e-9)
|
||||
np.testing.assert_allclose(shifted_y - base, [[0.0, 5.0]] * len(base), atol=1e-9)
|
||||
np.testing.assert_allclose(centered_x - base, [[10.0, 0.0]] * len(base), atol=1e-9)
|
||||
Reference in new issue
Block a user