Covalent use-case: Clarification on what is needed and what not (asyncroscopy relevant details)

[utkarshp1161]

• No .h5 support (DataWriter.py): https://github.com/pycroscopy/asyncroscopy/blob/main/asyncroscopy/software/DataWriter.py

  • Client requires .tiff output directly from AS:

    adorned.save("filename.tiff")

• No stack handling for this use case.

• Tiled integration is not a preference but doesn't hurt

• Code developed for Talos should ideally run on JEOL as well.

  • This aligns with Asyncroscopy's microscope-agnostic design.

• Background logging of instrument state (e.g., every 3 seconds) without interrupting user operation.

  • Stage position (X, Y, Z, tilt/rotation angles)
  • FOV
  • Camera angle
  • Scan rotation
  • Defocus
  • Camera length
  • Accelerating voltage
  • Exclude parameters that are not always available or require user interaction (e.g., screen current, as the screen may be retracted).

• Will update as additional requirements as they emerge.

[utkarshp1161]

1> * Client requires .tiff output directly from AS:

This can be handled as:

• Currently, we get images through:

  • data_key = microscope.acquire_scanned_image(["haadf"])
  • key = microscope.acquire_scanned_image(["HAADF", "BF-S", "DF-S"]) - Which uses:
    

    asyncroscopy/asyncroscopy/software/DataWriter.py

    Line 59 in fba0de9

    def save_acquisition_hdf5(path: str | Path, datasets: list[dict], file_attrs: dict | None = None) -> None:

    
    Can write a save_acquisition_tiff

• For now, we can get the image and save it externally as .tiff.

  • Benefit: Thermo Fisher .tiff output is Velox-compatible( Example it allows for users to annotate and metadata is used to display scalebars and other information of acquisiton - which is good to have for this use-case).

• Add file format as a scan option:

  • scan.file_format
  • default: .h5
  • optional: .tiff

• .tiff does not need a Tiled-side adapter as it is native in Tiled.

• For multiple images, Thermo Fisher returns a list of AdornedImage objects, so each image can be saved individually.

  • Need to confirm in AutoScript reference manual:

    • C:\Program Files\Thermo Scientific AutoScript TEM\ReferenceManual

  • Relevant API:

    • AdornedImage.save

2> Background logging of instrument state (e.g., every 3 seconds) without interrupting user operation.

• Stage position (X, Y, Z, tilt/rotation angles)
• FOV
• Camera angle
• Scan rotation
• Defocus
• Camera length
• Accelerating voltage
• Exclude parameters that are not always available or require user interaction, e.g. screen current since the screen may be retracted.

This can be handled as:

• Add these as Device attributes in ThermoMicroscope.py.

• The Thermo Fisher device proxy can expose these values.

• For now, logging can be done from a script or notebook into a .csv.

  • No need to add a dedicated logging module yet, since that may add unnecessary complexity.

[AustinHouston]

1. there may be a problem for stacks. The output of the function is a string for hdf5 and a list of strings for tiff

2. I agree- some will be seamless. ex: set_fov and get_fov. easily to collapse these two into an attribute.
   But there are some conflicts, like the stage setting are stored in the stage device but are called with AutoScript commands, ex:
   def _get_stage(self):
   """Get the current stage position as a list of floats [x, y, z, alpha, beta]."""
   # set proxy attributes with current stage position
   stage = self._detector_proxies["stage"]

    position = self._microscope.specimen.stage.position
    position = np.array(position)
   
    stage.x = float(position[1])
    stage.y = float(position[0])
    stage.z = float(position[2])
    stage.alpha = float(math.degrees(position[3]))
   
    if position[4] is not None:
        return position
    else:
        return position[:4]
   

   def _move_stage(self, position) -> None:
   """Move stage to specified position [x, y, z, alpha, beta]."""
   x = float(position[0])
   y = float(position[1])
   z = float(position[2])
   alpha = float(math.radians(position[3]))

    if len(position) > 4 and position[4] is not None:
        beta = float(math.radians(position[4]))
    else:
        beta = None
   
    self._microscope.specimen.stage.absolute_move((x, y, z, alpha, beta))
    self._get_stage()  # link the proxy with real state
   

see how the link happens at the end? we have to update the proxy attributes each time. we coul make the x,y,z postion an attribute in ThermoMicroscope, but then we should really delete the stage.py

[utkarshp1161]

Thanks for the comments.

1. there may be a problem for stacks. The output of the function is a string for hdf5 and a list of strings for tiff

I see your point. I handled it this way so that on the client side a key(common string across all the detectors) is returned, and based on the detector used, that key is modified to retrieve the image. Of course, the default mode is .h5, which doesn't need this treatment. The key is mainly for the stack case.

scan.dwell_time = 1e-6
scan.imsize = 512
scan.scan_region = [0, 0, 1, 1]
scan.output_format = ".tiff"

detector_list = ["HAADF", "BF-S", "DF-S"]
key = microscope.acquire_scanned_image(detector_list)

images = []
names = []
for det in detector_list:
    node = client[f"{key}_{det.upper()}.tiff"]
    images.append(node.read())
    names.append(det)

2. I agree - some will be seamless. ex: set_fov and get_fov. easily to collapse these two into an attribute.

see how the link happens at the end? we have to update the proxy attributes each time. we could make the x,y,z position an attribute in ThermoMicroscope, but then we should really delete the stage.py

Yes, I still agree. If we go this route, we can remove stage.py.

For now, I created another block in ThermoMicroscope.py:

# ------------------------------------------------------------------
# Commands pertaining to setting child attributes, e.g. stage position,
# scan parameters, EDS settings, etc. User accesses these in a Jupyter
# notebook through the device proxy.
# ------------------------------------------------------------------

@command
def register_stage(self):
    """Read the live stage position from hardware and publish it onto
    the STAGE child device.

    Call this from the notebook before reading the STAGE device so its
    x/y/z/alpha attributes reflect the current hardware position.
    """
    self._get_stage()

Once we execute above we can get access to the stage attributes from the stage device on thee client side.

[Darel-Pates]

There are other attributes in autoscript that also follow this pattern, such as the C1, C2, C3 lenses that I am working on right now

[AustinHouston]

This is a problem for some attributes (like stage and optics), which require reading from instrument hardware.
Not a problem for scan, etc, because we only set these, we don't read them.

To solve, two options:

1. move the attributes into VendorMicroscope.py
2. we can make a mic_proxy inside STAGE, the read/write methods call this proxy

I'm leaning towards 2
Each VendorMicroscpe will need to be coupled with some standard read/write satege methods

[AustinHouston]

Darel and I wen through in detail how to do 2

He is going to solve stage this way, then make an optics module to do the same thing with lenses