mx-bluesky 0.0.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

mx_bluesky/{I24 → i24}/serial/fixed_target/i24ssx_Chip_Mapping_py3v1.py

@@ -3,23 +3,24 @@ Chip mapping utilities for fixed target
 
 This version changed to python3 March2020 by RLO
 """
+
 import logging
 import time
 
 import numpy as np
 from matplotlib import pyplot as plt
 
-from mx_bluesky.I24.serial import log
-from mx_bluesky.I24.serial.fixed_target.ft_utils import ChipType
-from mx_bluesky.I24.serial.fixed_target.i24ssx_Chip_StartUp_py3v1 import (
+from mx_bluesky.i24.serial import log
+from mx_bluesky.i24.serial.fixed_target.ft_utils import ChipType
+from mx_bluesky.i24.serial.fixed_target.i24ssx_Chip_StartUp_py3v1 import (
     check_files,
-    get_format,
     get_shot_order,
     get_xy,
-    scrape_parameter_file,
+    read_parameter_file,
     write_file,
 )
-from mx_bluesky.I24.serial.parameters.constants import PARAM_FILE_PATH_FT
+from mx_bluesky.i24.serial.parameters import get_chip_format
+from mx_bluesky.i24.serial.parameters.constants import PARAM_FILE_PATH_FT
 
 logger = logging.getLogger("I24ssx.chip_mapping")
 
@@ -34,7 +35,7 @@ def setup_logging():
 def read_file_make_dict(fid, chip_type, switch=False):
     a_dict = {}
     b_dict = {}
-    with open(fid, "r") as f:
+    with open(fid) as f:
         for line in f.readlines():
             if line.startswith("#"):
                 continue
@@ -78,36 +79,36 @@ def plot_file(fid, chip_type):
     ax1.set_xlim(-1, 26)
     ax1.set_ylim(-1, 26)
     ax1.invert_yaxis()
-    check_files(["%s.png" % chip_type])
-    plt.savefig("%s.png" % fid[:-5], dpi=200, bbox_inches="tight", pad_inches=0.05)
+    check_files("i24", [f"{chip_type}.png"])
+    plt.savefig(f"{fid[:-5]}.png", dpi=200, bbox_inches="tight", pad_inches=0.05)
     return 1
 
 
 @log.log_on_entry
 def convert_chip_to_hex(fid, chip_type):
     chip_dict = read_file_make_dict(fid, chip_type, True)
-    chip_format = get_format(chip_type)
-    check_files(["%s.full" % chip_type])
-    with open("%s.full" % fid[:-5], "w") as g:
+    chip_format = get_chip_format(ChipType(chip_type))
+    check_files("i24", [f"{chip_type}.full"])
+    with open(f"{fid[:-5]}.full", "w") as g:
         # Normal
         if chip_type in [ChipType.Oxford, ChipType.OxfordInner]:
             shot_order_list = get_shot_order(chip_type)
             logger.info("Shot Order List: \n")
-            logger.info("%s" % shot_order_list[:14])
-            logger.info("%s" % shot_order_list[-14:])
+            logger.info(f"{shot_order_list[:14]}")
+            logger.info(f"{shot_order_list[-14:]}")
             for i, k in enumerate(shot_order_list):
                 if i % 20 == 0:
                     logger.info("\n")
                 else:
-                    logger.info("%s" % k)
+                    logger.info(f"{k}")
             sorted_pres_list = []
             for addr in shot_order_list:
                 sorted_pres_list.append(chip_dict[addr])
 
-            windows_per_block = chip_format[2]
-            number_of_lines = len(sorted_pres_list) / windows_per_block
+            windows_per_block = chip_format.x_num_steps
+            number_of_lines = int(len(sorted_pres_list) / windows_per_block)
             hex_length = windows_per_block / 4
-            pad = 7 - hex_length
+            pad = int(7 - hex_length)
             for i in range(number_of_lines):
                 sublist = sorted_pres_list[
                     i * windows_per_block : (i * windows_per_block) + windows_per_block
@@ -116,24 +117,24 @@ def convert_chip_to_hex(fid, chip_type):
                     right_list = sublist
                 else:
                     right_list = sublist[::-1]
-                hex_string = ("{0:0>%sX}" % hex_length).format(
+                hex_string = (f"{{0:0>{hex_length}X}}").format(
                     int("".join(str(x) for x in right_list), 2)
                 )
-                hex_string = hex_string + pad * "0"
+                hex_string = hex_string + (pad * "0")
                 pvar = 5001 + i
-                line = "P%s=$%s" % (pvar, hex_string)
+                line = f"P{pvar}=${hex_string}"
                 g.write(line + "\n")
                 logger.info("hex string: %s" % (hex_string + 4 * "0"))
-                logger.info("line number= %s" % i)
+                logger.info(f"line number= {i}")
                 logger.info(
-                    "right_list: \n%s\n" % ("".join(str(x) for x in right_list))
+                    "right_list: \n{}\n".format("".join(str(x) for x in right_list))
                 )
-                logger.info("PVAR: %s" % line)
+                logger.info(f"PVAR: {line}")
                 if (i + 1) % windows_per_block == 0:
                     logger.info(
                         "\n %s" % (40 * (" %i" % ((i / windows_per_block) + 2)))
                     )
-            logger.info("hex_length: %s" % hex_length)
+            logger.info(f"hex_length: {hex_length}")
         else:
             logger.warning("Chip type unknown, no conversion done.")
     return 0
@@ -141,24 +142,17 @@ def convert_chip_to_hex(fid, chip_type):
 
 def main():
     setup_logging()
-    (
-        chip_name,
-        visit,
-        sub_dir,
-        n_exposures,
-        chip_type,
-        map_type,
-    ) = scrape_parameter_file()
-
-    check_files([".spec"])
+    params = read_parameter_file()
+
+    check_files("i24", [".spec"])
     write_file(suffix=".spec", order="shot")
 
-    logger.info("PARAMETER PATH = %s" % PARAM_FILE_PATH_FT)
-    fid = PARAM_FILE_PATH_FT / f"{chip_name}.spec"
-    logger.info("FID = %s" % fid)
+    logger.info(f"PARAMETER PATH = {PARAM_FILE_PATH_FT}")
+    fid = PARAM_FILE_PATH_FT / f"{params.filename}.spec"
+    logger.info(f"FID = {fid}")
 
-    plot_file(fid, chip_type)
-    convert_chip_to_hex(fid, chip_type)
+    plot_file(fid, params.chip.chip_type.value)
+    convert_chip_to_hex(fid, params.chip.chip_type.value)
 
 
 if __name__ == "__main__":

mx_bluesky/i24/serial/fixed_target/i24ssx_Chip_StartUp_py3v1.py

@@ -0,0 +1,325 @@
+"""
+Startup utilities for chip
+"""
+
+import logging
+import os
+import string
+import time
+from pathlib import Path
+
+import numpy as np
+
+from mx_bluesky.i24.serial import log
+from mx_bluesky.i24.serial.fixed_target.ft_utils import ChipType
+from mx_bluesky.i24.serial.parameters import FixedTargetParameters, get_chip_format
+from mx_bluesky.i24.serial.parameters.constants import (
+    HEADER_FILES_PATH,
+    PARAM_FILE_NAME,
+    PARAM_FILE_PATH_FT,
+)
+
+logger = logging.getLogger("I24ssx.chip_startup")
+
+
+def setup_logging():
+    # Log should now change name daily.
+    logfile = time.strftime("i24fixedtarget_%d%B%y.log").lower()
+    log.config(logfile)
+
+
+def read_parameter_file(
+    param_path: Path | str = PARAM_FILE_PATH_FT,
+) -> FixedTargetParameters:
+    if not isinstance(param_path, Path):
+        param_path = Path(param_path)
+    params_file = param_path / PARAM_FILE_NAME
+    params = FixedTargetParameters.from_file(params_file)
+    return params
+
+
+@log.log_on_entry
+def fiducials(chip_type: int):
+    fiducial_list: list | None = None
+    if chip_type in [ChipType.Oxford, ChipType.OxfordInner, ChipType.Minichip]:
+        fiducial_list = []
+    elif chip_type == ChipType.Custom:
+        # No fiducial for custom
+        logger.warning("No fiducials for custom chip")
+    else:
+        logger.warning(f"Unknown chip_type, {chip_type}, in fiducials")
+    return fiducial_list
+
+
+def get_xy(addr: str, chip_type: ChipType):
+    entry = addr.split("_")[-2:]
+    R, C = entry[0][0], entry[0][1]
+    r2, c2 = entry[1][0], entry[1][1]
+    blockR = string.ascii_uppercase.index(R)
+    blockC = int(C) - 1
+    lowercase_list = list(string.ascii_lowercase + string.ascii_uppercase + "0")
+    windowR = lowercase_list.index(r2)
+    windowC = lowercase_list.index(c2)
+
+    chip_params = get_chip_format(chip_type)
+
+    x = (
+        (blockC * chip_params.b2b_horz)
+        + (blockC * (chip_params.x_num_steps - 1) * chip_params.x_step_size)
+        + (windowC * chip_params.x_step_size)
+    )
+    y = (
+        (blockR * chip_params.b2b_vert)
+        + (blockR * (chip_params.y_num_steps - 1) * chip_params.y_step_size)
+        + (windowR * chip_params.y_step_size)
+    )
+    return x, y
+
+
+def pathli(l_in=None, way="typewriter", reverse=False):
+    if l_in is None:
+        l_in = []
+    if reverse is True:
+        li = list(reversed(l_in))
+    else:
+        li = list(l_in)
+    long_list = []
+    if li:
+        if way == "typewriter":
+            for i in range(len(li) ** 2):
+                long_list.append(li[i % len(li)])
+        elif way == "snake":
+            lr = list(reversed(li))
+            for rep in range(len(li)):
+                if rep % 2 == 0:
+                    long_list += li
+                else:
+                    long_list += lr
+        elif way == "snake53":
+            lr = list(reversed(li))
+            for rep in range(53):
+                if rep % 2 == 0:
+                    long_list += li
+                else:
+                    long_list += lr
+        elif way == "expand":
+            for entry in li:
+                for _ in range(len(li)):
+                    long_list.append(entry)
+        elif way == "expand28":
+            for entry in li:
+                for _ in range(28):
+                    long_list.append(entry)
+        elif way == "expand25":
+            for entry in li:
+                for _ in range(25):
+                    long_list.append(entry)
+        else:
+            logger.warning(f"No known path, way =  {way}")
+    else:
+        logger.warning("No list written")
+    return long_list
+
+
+def zippum(list_1_args, list_2_args):
+    list_1, type_1, reverse_1 = list_1_args
+    list_2, type_2, reverse_2 = list_2_args
+    A_path = pathli(list_1, type_1, reverse_1)
+    B_path = pathli(list_2, type_2, reverse_2)
+    zipped_list = []
+    for a, b in zip(A_path, B_path, strict=False):
+        zipped_list.append(a + b)
+    return zipped_list
+
+
+def get_alphanumeric(chip_type: ChipType):
+    cell_format = get_chip_format(chip_type)
+    blk_num = cell_format.x_blocks
+    wnd_num = cell_format.x_num_steps
+    uppercase_list = list(string.ascii_uppercase)[:blk_num]
+    lowercase_list = list(string.ascii_lowercase + string.ascii_uppercase + "0")[
+        :wnd_num
+    ]
+    number_list = [str(x) for x in range(1, blk_num + 1)]
+
+    block_list = zippum([uppercase_list, "expand", 0], [number_list, "typewriter", 0])
+    window_list = zippum(
+        [lowercase_list, "expand", 0], [lowercase_list, "typewriter", 0]
+    )
+
+    alphanumeric_list = []
+    for block in block_list:
+        for window in window_list:
+            alphanumeric_list.append(block + "_" + window)
+    logger.info(f"Length of alphanumeric list = {len(alphanumeric_list)}")
+    return alphanumeric_list
+
+
+@log.log_on_entry
+def get_shot_order(chip_type: ChipType):
+    cell_format = get_chip_format(chip_type)
+    blk_num = cell_format.x_blocks
+    wnd_num = cell_format.x_num_steps
+    uppercase_list = list(string.ascii_uppercase)[:blk_num]
+    number_list = [str(x) for x in range(1, blk_num + 1)]
+    lowercase_list = list(string.ascii_lowercase + string.ascii_uppercase + "0")[
+        :wnd_num
+    ]
+
+    block_list = zippum([uppercase_list, "snake", 0], [number_list, "expand", 0])
+    window_dn = zippum([lowercase_list, "expand", 0], [lowercase_list, "snake", 0])
+    window_up = zippum([lowercase_list, "expand", 1], [lowercase_list, "snake", 0])
+
+    switch = 0
+    count = 0
+    collect_list = []
+    for block in block_list:
+        if switch == 0:
+            for window in window_dn:
+                collect_list.append(block + "_" + window)
+            count += 1
+            if count == blk_num:
+                count = 0
+                switch = 1
+        else:
+            for window in window_up:
+                collect_list.append(block + "_" + window)
+            count += 1
+            if count == blk_num:
+                count = 0
+                switch = 0
+
+    logger.info(f"Length of collect list = {len(collect_list)}")
+    return collect_list
+
+
+@log.log_on_entry
+def write_file(
+    location: str = "i24",
+    suffix: str = ".addr",
+    order: str = "alphanumeric",
+    param_file_path: Path = PARAM_FILE_PATH_FT,
+    save_path: Path = HEADER_FILES_PATH,
+):
+    if location == "i24":
+        params = read_parameter_file(param_file_path)
+    else:
+        msg = f"Unknown location, {location}"
+        logger.error(msg)
+        raise ValueError(msg)
+    chip_file_path = save_path / f"chips/{params.directory}/{params.filename}{suffix}"
+
+    fiducial_list = fiducials(params.chip.chip_type.value)
+
+    if order == "alphanumeric":
+        addr_list = get_alphanumeric(params.chip.chip_type)
+    elif order == "shot":
+        addr_list = get_shot_order(params.chip.chip_type)
+    else:
+        raise ValueError(f"{order=} unrecognised")
+
+    with open(chip_file_path, "a") as g:
+        for addr in addr_list:
+            xtal_name = "_".join([params.filename, addr])
+            (x, y) = get_xy(xtal_name, params.chip.chip_type)
+            if addr in fiducial_list:
+                pres = "0"
+            else:
+                if "rand" in suffix:
+                    pres = str(np.random.randint(2))
+                else:
+                    pres = "-1"
+            line = "\t".join([xtal_name, str(x), str(y), "0.0", pres]) + "\n"
+            g.write(line)
+
+    logger.info(f"Write {chip_file_path} completed")
+
+
+@log.log_on_entry
+def check_files(
+    location: str,
+    suffix_list: list[str],
+    param_file_path: Path | str = PARAM_FILE_PATH_FT,
+    save_path: Path = HEADER_FILES_PATH,
+):
+    if location == "i24":
+        params = read_parameter_file(param_file_path)
+    else:
+        msg = f"Unknown location, {location}"
+        logger.error(msg)
+        raise ValueError(msg)
+    chip_file_path = save_path / f"chips/{params.directory}/{params.filename}"
+
+    try:
+        os.stat(chip_file_path)
+    except Exception:
+        os.makedirs(chip_file_path)
+    for suffix in suffix_list:
+        full_fid = chip_file_path.with_suffix(suffix)
+        if full_fid.is_file():
+            time_str = time.strftime("%Y%m%d_%H%M%S_")
+            timestamp_fid = (  # noqa: F841
+                full_fid.parent / f"{time_str}_{params.filename}{full_fid.suffix}"
+            )
+            # FIXME hack / fix. Actually move the file
+            logger.info(f"File {full_fid} Already Exists")
+    logger.debug("Check files done")
+    return 1
+
+
+@log.log_on_entry
+def write_headers(
+    location: str,
+    suffix_list: list[str],
+    param_file_path: Path = PARAM_FILE_PATH_FT,
+    save_path: Path = HEADER_FILES_PATH,
+):
+    if location == "i24":
+        params = read_parameter_file(param_file_path)
+        chip_file_path = save_path / f"chips/{params.directory}/{params.filename}"
+
+        for suffix in suffix_list:
+            full_fid = chip_file_path.with_suffix(suffix)
+            with open(full_fid, "w") as g:
+                g.write(
+                    "#23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\n#\n"
+                )
+                g.write(f"#&i24\tchip_name    = {params.filename}\n")
+                g.write(f"#&i24\tvisit        = {params.visit}\n")
+                g.write(f"#&i24\tsub_dir      = {params.directory}\n")
+                g.write(f"#&i24\tn_exposures  = {params.num_exposures}\n")
+                g.write(f"#&i24\tchip_type    = {params.chip.chip_type.value}\n")
+                g.write(f"#&i24\tmap_type     = {params.map_type.value}\n")
+                g.write(f"#&i24\tpump_repeat  = {params.pump_repeat.value}\n")
+                g.write(f"#&i24\tpumpexptime  = {params.laser_dwell_s}\n")
+                g.write(f"#&i24\texptime      = {params.laser_delay_s}\n")
+                g.write(f"#&i24\tdcdetdist    = {params.detector_distance_mm}\n")
+                g.write(f"#&i24\tprepumpexptime  = {params.pre_pump_exposure_s}\n")
+                g.write(f"#&i24\tdet_Type     = {params.detector_name}\n")
+                g.write("#\n")
+                g.write(
+                    "#XtalAddr      XCoord  YCoord  ZCoord  Present Shot  Spare04 Spare03 Spare02 Spare01\n"
+                )
+    else:
+        msg = f"Unknown location, {location}"
+        logger.error(msg)
+        raise ValueError(msg)
+    logger.debug("Write headers done")
+
+
+def run():
+    logger.debug("Run Startup")
+    check_files("i24", [".addr", ".shot"])
+    logger.info("Checked Files")
+    write_headers("i24", [".addr", ".shot"])
+    logger.info("Written Headers")
+    logger.info("Writing to Files has been disabled. Headers Only")
+    # Makes a file with random crystal positions
+    check_files("i24", ["rando.spec"])
+    write_headers("i24", ["rando.spec"])
+    logger.debug("StartUp Done")
+
+
+if __name__ == "__main__":
+    setup_logging()
+    run()

mx_bluesky/{I24 → i24}/serial/fixed_target/i24ssx_moveonclick.py

@@ -2,14 +2,19 @@
 Move on click gui for fixed targets at I24
 Robin Owen 12 Jan 2021
 """
+
 import logging
 
+import bluesky.plan_stubs as bps
 import cv2 as cv
+from bluesky.run_engine import RunEngine
 from dodal.beamlines import i24
+from dodal.devices.i24.pmac import PMAC
 from dodal.devices.oav.oav_detector import OAV
 
-from mx_bluesky.I24.serial.fixed_target import i24ssx_Chip_Manager_py3v1 as manager
-from mx_bluesky.I24.serial.parameters.constants import OAV1_CAM
+from mx_bluesky.i24.serial.fixed_target import i24ssx_Chip_Manager_py3v1 as manager
+from mx_bluesky.i24.serial.fixed_target.ft_utils import Fiducials
+from mx_bluesky.i24.serial.parameters.constants import OAV1_CAM
 
 logger = logging.getLogger("I24ssx.moveonclick")
 
@@ -27,34 +32,25 @@ def _get_beam_centre(oav: OAV):
     return oav.parameters.beam_centre_i, oav.parameters.beam_centre_j
 
 
-# TODO In the future, this should be done automatically in the OAV device
-# See https://github.com/DiamondLightSource/dodal/issues/224
-def get_beam_centre():
-    # Get I24 oav device from dodal
-    oav = i24.oav()
-
-    beamX, beamY = _get_beam_centre(oav)
-    return beamX, beamY
-
-
 # Register clicks and move chip stages
 def onMouse(event, x, y, flags, param):
-    pmac = param
-    beamX, beamY = get_beam_centre()
     if event == cv.EVENT_LBUTTONUP:
-        logger.info("Clicked X and Y %s %s" % (x, y))
+        pmac = param[0]
+        oav = param[1]
+        beamX, beamY = _get_beam_centre(oav)
+        logger.info(f"Clicked X and Y {x} {y}")
         xmove = -1 * (beamX - x) * zoomcalibrator
         ymove = -1 * (beamY - y) * zoomcalibrator
-        logger.info("Moving X and Y %s %s" % (xmove, ymove))
+        logger.info(f"Moving X and Y {xmove} {ymove}")
         xmovepmacstring = "#1J:" + str(xmove)
         ymovepmacstring = "#2J:" + str(ymove)
-        pmac.pmac_string.set(xmovepmacstring)
-        pmac.pmac_string.set(ymovepmacstring)
+        yield from bps.abs_set(pmac.pmac_string, xmovepmacstring, wait=True)
+        yield from bps.abs_set(pmac.pmac_string, ymovepmacstring, wait=True)
 
 
-def update_ui(frame):
+def update_ui(oav, frame):
     # Get beam x and y values
-    beamX, beamY = get_beam_centre()
+    beamX, beamY = _get_beam_centre(oav)
 
     # Overlay text and beam centre
     cv.ellipse(
@@ -135,14 +131,15 @@ def update_ui(frame):
 
 
 def start_viewer(oav1: str = OAV1_CAM):
-    # Get PMAC device
-    pmac = i24.pmac()
+    # Get devices out of dodal
+    oav: OAV = i24.oav()
+    pmac: PMAC = i24.pmac()
     # Create a video caputure from OAV1
     cap = cv.VideoCapture(oav1)
 
     # Create window named OAV1view and set onmouse to this
     cv.namedWindow("OAV1view")
-    cv.setMouseCallback("OAV1view", onMouse, param=pmac)  # type: ignore
+    cv.setMouseCallback("OAV1view", onMouse, param=[pmac, oav])  # type: ignore
 
     logger.info("Showing camera feed. Press escape to close")
     # Read captured video and store them in success and frame
@@ -152,42 +149,42 @@ def start_viewer(oav1: str = OAV1_CAM):
     while success:
         success, frame = cap.read()
 
-        update_ui(frame)
+        update_ui(oav, frame)
 
         k = cv.waitKey(1)
         if k == 113:  # Q
-            manager.moveto("zero")
+            yield from manager.moveto(Fiducials.zero, pmac)
         if k == 119:  # W
-            manager.moveto("f1")
+            yield from manager.moveto(Fiducials.fid1, pmac)
         if k == 101:  # E
-            manager.moveto("f2")
+            yield from manager.moveto(Fiducials.fid2, pmac)
         if k == 97:  # A
-            pmac.pmac_string.set(r"\#1hmz\#2hmz\#3hmz")
+            yield from bps.trigger(pmac.home, wait=True)
             print("Current position set as origin")
         if k == 115:  # S
-            manager.fiducial(1)
+            yield from manager.fiducial(1)
         if k == 100:  # D
-            manager.fiducial(2)
+            yield from manager.fiducial(2)
         if k == 99:  # C
-            manager.cs_maker()
+            yield from manager.cs_maker(pmac)
         if k == 98:  # B
-            manager.block_check()  # doesn't work well for blockcheck as image doesn't update
+            yield from manager.block_check()  # doesn't work well for blockcheck as image doesn't update
         if k == 104:  # H
-            pmac.pmac_string.set("#2J:-10")
+            yield from bps.abs_set(pmac.pmac_string, "#2J:-10", wait=True)
         if k == 110:  # N
-            pmac.pmac_string.set("#2J:10")
+            yield from bps.abs_set(pmac.pmac_string, "#2J:10", wait=True)
         if k == 109:  # M
-            pmac.pmac_string.set("#1J:-10")
+            yield from bps.abs_set(pmac.pmac_string, "#1J:-10", wait=True)
         if k == 98:  # B
-            pmac.pmac_string.set("#1J:10")
+            yield from bps.abs_set(pmac.pmac_string, "#1J:10", wait=True)
         if k == 105:  # I
-            pmac.pmac_string.set("#3J:-150")
+            yield from bps.abs_set(pmac.pmac_string, "#3J:-150", wait=True)
         if k == 111:  # O
-            pmac.pmac_string.set("#3J:150")
+            yield from bps.abs_set(pmac.pmac_string, "#3J:150", wait=True)
         if k == 117:  # U
-            pmac.pmac_string.set("#3J:-1000")
+            yield from bps.abs_set(pmac.pmac_string, "#3J:-1000", wait=True)
         if k == 112:  # P
-            pmac.pmac_string.set("#3J:1000")
+            yield from bps.abs_set(pmac.pmac_string, "#3J:1000", wait=True)
         if k == 0x1B:  # esc
             cv.destroyWindow("OAV1view")
             print("Pressed escape. Closing window")
@@ -198,4 +195,5 @@ def start_viewer(oav1: str = OAV1_CAM):
 
 
 if __name__ == "__main__":
-    start_viewer()
+    RE = RunEngine()
+    RE(start_viewer())