diff --git a/.gitignore b/.gitignore index 7f3db4f..72f71af 100644 --- a/.gitignore +++ b/.gitignore @@ -212,3 +212,6 @@ PythonPackages-AS-1.15/ llm-context/ # MyST build outputs _build + +extra-notebooks-debug/ +tango_database.db diff --git a/asyncroscopy/Microscope.py b/asyncroscopy/Microscope.py index 4961b88..8690a0b 100644 --- a/asyncroscopy/Microscope.py +++ b/asyncroscopy/Microscope.py @@ -22,6 +22,7 @@ import time from typing import Optional + from abc import abstractmethod, ABC, ABCMeta import numpy as np @@ -50,6 +51,13 @@ class Microscope(Device, metaclass=CombinedMeta): "DB mode: 'test/detector/scan' " "No-DB mode: 'tango://127.0.0.1:8888/test/nodb/scan#dbase=no'", ) + + corrector_device_address = device_property( + dtype=str, + doc="Tango device address for the aberration corrector settings device. " + "DB mode: 'test/hardware/corrector' " + "No-DB mode: 'tango://127.0.0.1:8888/test/nodb/corrector#dbase=no'", + ) eds_device_address = device_property( dtype=str, diff --git a/asyncroscopy/ThermoDigitalTwin.py b/asyncroscopy/ThermoDigitalTwin.py index 3faaf9f..97b5ecd 100644 --- a/asyncroscopy/ThermoDigitalTwin.py +++ b/asyncroscopy/ThermoDigitalTwin.py @@ -5,17 +5,25 @@ """ import json +from pathlib import Path +import time import numpy as np import pyTEMlib.image_tools as it import pyTEMlib.probe_tools as pt import tango +from ase.io import read from ase import Atoms from ase.build import bulk -from tango import AttrWriteType, DevState -from tango.server import Device, attribute, device_property +from tango import AttrWriteType, DevState, DevEncoded +from tango.server import Device, attribute, device_property, command from asyncroscopy.Microscope import Microscope +from asyncroscopy.simulation import StemSim as dg # dg means datagenerator --> needs better naming -> using directly as used in twisted version for now + + +HERE = Path(__file__).resolve().parent +PROJECT_ROOT = HERE.parent # removes "servers" class ThermoDigitalTwin(Microscope): @@ -23,6 +31,10 @@ class ThermoDigitalTwin(Microscope): Persistent ASE-backed sample simulation with stage-coupled viewport rendering. """ + # ------------------------------------------------------------------ + # Device properties — configure in Tango DB per deployment + # ------------------------------------------------------------------ + sample_seed = device_property( dtype=int, default_value=12345, @@ -109,6 +121,7 @@ def _connect_detector_proxies(self) -> None: "eds": self.eds_device_address, "stage": self.stage_device_address, "scan": self.scan_device_address, + "corrector": self.corrector_device_address } for name, address in addresses.items(): if not address: @@ -178,7 +191,9 @@ def _sub_pix_gaussian(size: int = 11, sigma: float = 0.8, dx: float = 0.0, dy: f g = np.exp(-(((xx + dx) ** 2 + (yy + dy) ** 2) / (2 * sigma**2))) m = np.max(g) return g / m if m > 0 else g - + # ------------------------------------------------------------------ + # simulation helpers ----> Should be put in asyncroscopy/simulation later + # ------------------------------------------------------------------ def _create_pseudo_potential( self, xtal: Atoms, @@ -397,6 +412,9 @@ def _generate_sample(self, seed: int) -> None: self._cached_pose_key = None self._update_view_cache(force=True) + # ------------------------------------------------------------------ + # Attribute read methods + # ------------------------------------------------------------------ def read_manufacturer(self) -> str: """Read method for the manufacturer attribute.""" return self._manufacturer @@ -413,6 +431,57 @@ def write_beam_pos(self, value): self._beam_pos_x = float(x) self._beam_pos_y = float(y) + + # ------------------------------------------------------------------ + # Commands + # ------------------------------------------------------------------ + + @command(dtype_out=DevEncoded)#In PyTango, DevEncoded is a special Tango data type designed to send binary data + a small description string together as a single return value. + def get_scanned_image_with_aberrations(self) -> tuple[str, bytes]: + """ + Acquire a single STEM image from the named detector. + + Parameters + ---------- + detector_name: + Name of the detector, e.g. "haadf". Must match a key in + self._detector_proxies. + + Returns + ------- + DevEncoded = (json_metadata, raw_bytes) + json_metadata includes: shape, dtype, dwell_time, detector, + timestamp, and any other relevant metadata. + raw_bytes is the flat numpy array bytes; reshape using shape from metadata. + """ + # check active detectors + scan = self._detector_proxies.get("scan") + corrector = self._detector_proxies.get("corrector") + + + # Read scan settings from the detector device + dwell_time=scan.dwell_time + imsize=scan.imsize + + # Read aberration setting from the corrector + ab = corrector.get_aberrations_coeff_sim()# is a json string + self.ab = json.loads(ab) + + adorned_image = self._acquire_stem_image_aberrations(imsize, dwell_time, ['haadf']) + + metadata = { + "detector": 'haadf', + "shape": [imsize, imsize], + "dtype": str(adorned_image.dtype), + "dwell_time": dwell_time, + "timestamp": time.time(), + # TODO: add metadata from adorned_image.metadata when using real AutoScript + } + + return json.dumps(metadata), adorned_image.tobytes() + # ------------------------------------------------------------------ + # Internal acquisition helpers + # ------------------------------------------------------------------ def _acquire_stem_image(self, imsize: int, dwell_time: float, detector_list: list) -> np.ndarray: """Simulate STEM image acquisition using convolutions of the pseudo-potential and electron probe.""" self._sync_stage_from_proxy() @@ -457,6 +526,46 @@ def _acquire_stem_image(self, imsize: int, dwell_time: float, detector_list: lis noisy_image += self._lowfreq_noise(noisy_image, noise_level=0.1, freq_scale=0.1, rng=rng) * blur_noise_level return np.clip(noisy_image, 0.0, 1.0).astype(np.float32) + + def _acquire_stem_image_aberrations(self, imsize: int, dwell_time: float, detector_list: list) -> np.ndarray: + """ + """ + size = imsize + beam_current = 100 # pA + ab = self.ab + ab['acceleration_voltage'] = 60e3 # eV + fov = 96 # angstroms + ab['FOV'] = fov /12 # Angstroms + ab['convergence_angle'] = 30 # mrad + ab['wavelength'] = it.get_wavelength(ab['acceleration_voltage']) + cif_path = ( + PROJECT_ROOT + / "data" + / "cif_files" + / "WS2_ortho.cif" + ) + print("Reading CIF from:", cif_path) + xtal = read(cif_path) + xtal = xtal * (30, 20, 1) + positions = xtal.get_positions()[:, :2] + pixel_size = 0.106 # angstrom/pixel + frame = (0,fov,0,fov) # limits of the image in angstroms + potential = dg.create_pseudo_potential(xtal, pixel_size, sigma=1, bounds=frame, atom_frame=11) + probe = dg.get_probe(ab, potential) + image = dg.convolve_kernel(potential, probe) + noisy_image = dg.lowfreq_noise(image, noise_level=0.5, freq_scale=.04) + + scan_time = dwell_time * size * size + counts = scan_time * (beam_current * 1e-12) / (1.602e-19) + sim_im = dg.poisson_noise(noisy_image, counts=counts) + # convert args dict + + # time.sleep(1) + image = np.array(image, dtype=np.float32) + sim_im = np.array(sim_im, dtype=np.float32) + print(sim_im.shape) # TODO: the simulation is independent of size and always returns - (905, 905) image -> need to check + return sim_im + def _acquire_stem_image_advanced( self, detector_names: list[str], @@ -588,4 +697,4 @@ def get_viewport_metadata(self) -> str: return json.dumps(metadata) if __name__ == "__main__": - ThermoDigitalTwin.run_server() + ThermoDigitalTwin.run_server() \ No newline at end of file diff --git a/asyncroscopy/hardware/CORRECTOR.py b/asyncroscopy/hardware/CORRECTOR.py index 5b48b53..dfa05a0 100644 --- a/asyncroscopy/hardware/CORRECTOR.py +++ b/asyncroscopy/hardware/CORRECTOR.py @@ -176,6 +176,22 @@ def reconnect(self) -> None: """Re-attempt the TCP connection to the CEOS server.""" self._connect() + + # ------------------------------------------------------------------ + # Public commands pertaining to simulation + # ------------------------------------------------------------------ + + @command(dtype_in=str) + def set_aberrations_coeff_sim(self, json_aberrations_string: str): + self.ab = json.loads(json_aberrations_string) + pass + + @command(dtype_out=str) + def get_aberrations_coeff_sim(self): + if self.ab == None: + return + return json.dumps(self.ab) + # ------------------------------------------------------------------ # Internal helpers # ------------------------------------------------------------------ diff --git a/asyncroscopy/simulation/StemSim.py b/asyncroscopy/simulation/StemSim.py new file mode 100644 index 0000000..f4fbcf1 --- /dev/null +++ b/asyncroscopy/simulation/StemSim.py @@ -0,0 +1,405 @@ +# Description: This file contains the functions to generate synthetic data for the neural network training. +# By Austin Houston +# Date: 02/28/2024 +# Updated: 05/10/2024 + +import dask +import numpy as np +import random +import sidpy +import dask.array as da +import scipy.special as sp +from scipy.ndimage import zoom, gaussian_filter +from skimage.draw import disk +from ase import Atoms +from ase.neighborlist import NeighborList +from scipy.fft import fft2, ifft2 +import pyTEMlib.probe_tools as pt + + +def make_holes(atoms, n_holes=1, hole_size=3.0): + """ + Remove atoms in random holes from the structure. + + Args: + atoms: ASE Atoms object + n_holes: Number of holes to create + hole_size: Radius of each hole in Angstroms + + Returns: + Modified Atoms object with holes created + """ + import random + from ase.geometry import get_distances + + atoms = atoms.copy() + + if n_holes == 0 or len(atoms) == 0: + return atoms + + # Randomly select hole centers + n_holes = min(n_holes, len(atoms)) + hole_centers_indices = random.sample(range(len(atoms)), n_holes) + hole_centers = atoms.positions[hole_centers_indices] + + # Collect atoms to remove (work backwards to avoid index shifting) + atoms_to_remove = [] + for i, pos in enumerate(atoms.positions): + for center in hole_centers: + distance = np.linalg.norm(pos - center) + if distance < hole_size and i not in hole_centers_indices: + atoms_to_remove.append(i) + break + + # Remove in reverse order to maintain valid indices + for idx in sorted(atoms_to_remove, reverse=True): + del atoms[idx] + + return atoms + +def rotate_xtal(xtal, angle): + # pad for worst case and rotate + padded = xtal * (2, 2, 1) + padded.rotate('z', angle, 'com') + + # crop to original cell + cell = xtal.cell + positions = padded.get_positions()[:, :2] + inv_cell = np.linalg.inv(cell[:2, :2]) + frac = positions @ inv_cell - 0.5 + mask = np.all((frac >= 0) & (frac < 1), axis=1) + + # creat the new xtal object + xtal_cropped = padded[mask].copy() + xtal_cropped.set_cell(cell, scale_atoms=False) + xtal_cropped.set_scaled_positions(np.hstack([frac[mask], padded.get_scaled_positions()[mask, 2:3]])) + + return xtal_cropped + +def sub_pix_gaussian(size=10, sigma=0.2, dx=0.0, dy=0.0): + # returns sub-pix shifted gaussian + coords = np.arange(size) - (size - 1) / 2.0 + x, y = np.meshgrid(coords, coords) + g = np.exp(-(((x + dx) ** 2 + (y + dy) ** 2) / (2 * sigma**2))) + g /= g.max() + return g + +def create_pseudo_potential(xtal, pixel_size, sigma, bounds, atom_frame=11): + # Create empty image + x_min, x_max = bounds[0], bounds[1] + y_min, y_max = bounds[2], bounds[3] + pixels_x = int((x_max - x_min) / pixel_size) + pixels_y = int((y_max - y_min) / pixel_size) + potential_map = np.zeros((pixels_x, pixels_y)) + padding = atom_frame # to avoid edge effects + potential_map = np.pad(potential_map, padding, mode='constant', constant_values=0.0) + + # Map of atomic numbers - i.e. scattering intensity + atomic_numbers = xtal.get_atomic_numbers() + positions = xtal.get_positions()[:, :2] + + mask = ((positions[:, 0] >= x_min) & (positions[:, 0] < x_max) & (positions[:, 1] >= y_min) & (positions[:, 1] < y_max)) + positions = positions[mask] + atomic_numbers = atomic_numbers[mask] + + for pos, atomic_number in zip(positions, atomic_numbers): + x,y = np.round(pos/pixel_size) + dx,dy = pos - np.round(pos) + + single_atom = sub_pix_gaussian(size=atom_frame, sigma=sigma, dx=dx, dy=dy) * atomic_number + potential_map[int(x+padding+dx-padding//2-1):int(x+padding+dx+padding//2),int(y+padding+dy-padding//2-1):int(y+padding+dy+padding//2)] += single_atom + potential_map = potential_map[padding:-padding, padding:-padding] + normalized_map = potential_map / np.max(potential_map) + + # make a sidpy dataset + dset = sidpy.Dataset.from_array(normalized_map, name = 'Scattering Potential') + dset.data_type = 'image' + dset.units = 'A.U.' + dset.quantity = 'Scattering cross-section' + dset.set_dimension(0, sidpy.Dimension(pixel_size * np.arange(pixels_x), + name='x', units='Å', quantity='Length',dimension_type='spatial')) + dset.set_dimension(1, sidpy.Dimension(pixel_size * np.arange(pixels_y), + name='y', units='Å', quantity='Length',dimension_type='spatial')) + + return dset + + +def get_masks(xtal, pixel_size=0.1, radius=3, axis_extent=None, mode='one_hot'): + positions = xtal.get_positions()[:, :2] + atomic_numbers = xtal.get_atomic_numbers() + _, inverse_indices = np.unique(atomic_numbers, return_inverse=True) + atom_ids = inverse_indices + 1 # the background pixels will be labeled as 0 + unique_atom_ids = np.unique(atom_ids) + + # Determine image size + if axis_extent is not None: + xmin, xmax, ymin, ymax = axis_extent + else: + xmin, xmax = np.min(positions[:, 0]), np.max(positions[:, 0]) + ymin, ymax = np.min(positions[:, 1]), np.max(positions[:, 1]) + img_height = int((ymax - ymin) / pixel_size) + img_width = int((xmax - xmin) / pixel_size) + + master_mask = np.zeros((len(unique_atom_ids), img_height, img_width), dtype=np.uint8) + + def create_mask_for_atom(atom_id): + mask = np.zeros((img_height, img_width), dtype=np.uint8) + atom_mask = (atom_ids == atom_id) + atom_positions = positions[atom_mask] + + # Make mask 1 in radius around each atom + for x, y in atom_positions: + x_pixel = int((x - xmin) / pixel_size) + y_pixel = int((y - ymin) / pixel_size) + rr, cc = disk((y_pixel, x_pixel), radius, shape=mask.shape) + mask[rr, cc] = 1 + master_mask[atom_id - 1, mask == 1] = 1 + + # Parallelize the mask creation + tasks = [dask.delayed(create_mask_for_atom)(atom_id) for atom_id in unique_atom_ids] + dask.compute(*tasks) + + if mode.lower() == 'one_hot': + num_masks = unique_atom_ids.size + 1 # include background + background_mask = np.zeros((img_height, img_width), dtype=np.uint8) + background_mask[(np.sum(master_mask, axis=0) == 0)] = 1 + masks = np.stack([background_mask] + [master_mask[i] for i in range(len(unique_atom_ids))], axis=0) + return masks + + elif mode.lower() == 'binary': + sum_masks = np.sum(master_mask, axis=0) + final_mask = np.where(sum_masks > 0, 1, 0) + return final_mask + + elif mode.lower() == 'integer': + final_mask = np.zeros((img_height, img_width), dtype=np.uint8) + for i, mask in enumerate(master_mask): + final_mask[mask == 1] = i + 1 + return final_mask + + else: + raise ValueError("Invalid mode. Choose from 'one_hot', 'binary', or 'integer'") + + +def airy_disk(potential, resolution = 1.1): + # make grid + size_x = potential.shape[0] + size_y = potential.shape[1] + x = np.arange(size_x) - size_x//2 + 1 + y = np.arange(size_y) - size_y//2 + 1 + xx, yy = np.meshgrid(x, y) + rr = np.sqrt(xx**2 + yy**2) + + pixel_size = potential.x.slope # Angstrom/pixel + + disk_radius = pixel_size / resolution * 2.5 # Airy disk radius in pixels + # not sure why this 2.5 belonggs in here, but it works + + # Calculate the Airy pattern (PSF) + with np.errstate(divide='ignore', invalid='ignore'): + psf = (2 * sp.j1(disk_radius * rr) / (disk_radius * rr))**2 + psf[rr == 0] = 1 # Handling the division by zero at the center + + # Normalize the PSF + psf /= np.sum(psf) + + dset = sidpy.Dataset.from_array(psf, name = 'Probe PSF') + dset.data_type = 'image' + dset.units = 'A.U.' + dset.quantity = 'Probability' + dset.set_dimension(0, sidpy.Dimension(pixel_size * np.arange(size_x), + name='x', units='Å', quantity='Length',dimension_type='spatial')) + dset.set_dimension(1, sidpy.Dimension(pixel_size * np.arange(size_y), + name='y', units='Å', quantity='Length',dimension_type='spatial')) + + return dset + +def get_probe(ab, potential, pixel_size=0.106): + # pixel_size = potential.x.slope # Angstrom/pixel + size_x, size_y = potential.shape + + probe, A_k, chi = pt.get_probe(ab, size_x, size_y, verbose= True) + + dset = sidpy.Dataset.from_array(probe, name = 'Probe PSF') + dset.data_type = 'image' + dset.units = 'A.U.' + dset.quantity = 'Probability' + dset.set_dimension(0, sidpy.Dimension(pixel_size * np.arange(size_x), + name='x', units='Å', quantity='Length',dimension_type='spatial')) + dset.set_dimension(1, sidpy.Dimension(pixel_size * np.arange(size_y), + name='y', units='Å', quantity='Length',dimension_type='spatial')) + + return dset + + +def convolve_kernel(potential, psf): + # Convolve using FFT + psf_shifted = da.fft.ifftshift(psf) + image = da.fft.ifft2(da.fft.fft2(potential) * da.fft.fft2(psf_shifted)) + image = da.absolute(image) + image = image - image.min() + image = image / image.max() + + size_x, size_y = potential.shape + pixel_size = potential.x.slope # Angstrom/pixel + + dset = potential.like_data(image) + dset.units = 'A.U.' + dset.quantity = 'Intensity' + + return dset + + +def poisson_noise(image, counts = 1e9): + # Normalize the image + image = image - image.min() + image = image / image.sum() + noisy_image = np.random.poisson(image * counts) + + noisy_image = noisy_image - noisy_image.min() + noisy_image = noisy_image / noisy_image.max() + noisy_image = image.like_data(noisy_image) + + return noisy_image + + +def lowfreq_noise(image, noise_level=0.1, freq_scale=0.1): + size_x, size_y = image.shape + + noise = np.random.normal(0, noise_level, (size_x, size_y)) + noise_fft = np.fft.fft2(noise) + + # Create a frequency filter that emphasizes low frequencies + x_freqs = np.fft.fftfreq(size_x) + y_freqs = np.fft.fftfreq(size_y) + freq_filter = np.outer(np.exp(-np.square(x_freqs) / (2 * freq_scale**2)), + np.exp(-np.square(y_freqs) / (2 * freq_scale**2))) + + # Apply the frequency filter to the noise in the frequency domain + filtered_noise_fft = noise_fft * freq_filter + low_freq_noise = np.fft.ifft2(filtered_noise_fft).real + noisy_image = image + low_freq_noise + noisy_image = image.like_data(noisy_image) + + return noisy_image + + +def grid_crop(image_master, crop_size=512, crop_glide=128): + ''' + Slices an image into smaller, overlapping square crops. + + This function takes a larger image and divides it into smaller, overlapping square segments. + It's useful for processing large images in smaller batches, especially in machine learning applications + where input size is fixed. + + Parameters: + - image_master: A NumPy array representing the image to be cropped. + It should be a 2D array if the image is grayscale, or a 3D array for RGB images. + - crop_size (int, optional): The size of each square crop. Default is 256 pixels. + - crop_glide (int, optional): The stride or glide size for cropping. + Determines the overlap between consecutive crops. Default is 128 pixels. + + Returns: + - cropped_ims: A NumPy array containing the cropped images. + The array is 3D, where the first dimension represents the index of the crop, + and the next two dimensions represent the height and width of the crops. + + Note: + - The function assumes the input image is square. Non-square images might lead to unexpected results. + - The return array is of type 'float16' to reduce memory usage, which might affect the precision of pixel values. + ''' + + n_crops = int((len(image_master) - crop_size)/crop_glide + 1) + cropped_ims = np.zeros((n_crops,n_crops,crop_size,crop_size)) + + for x in np.arange(n_crops): + for y in np.arange(n_crops): + xx,yy = int(x*crop_glide), int(y*crop_glide) + cropped_ims[int(x),int(y)] = image_master[xx:xx+crop_size,yy:yy+crop_size] + cropped_ims = cropped_ims.reshape((-1,crop_size,crop_size)).astype('float16') + + return cropped_ims + + +def resize_image(array, n, order = 3): + """ + Resize a numpy array to n x n using interpolation. + + Parameters: + array (numpy.ndarray): The input array. + n (int): The size of the new square array. + + Returns: + numpy.ndarray: The resized square array. + """ + # Get the current shape of the array + height, width = array.shape[-2:] + + # Calculate zoom factors + zoom_factor = n / max(height, width) + array = array.astype(np.float32) + + if len(array.shape) == 2: + return zoom(array, [zoom_factor, zoom_factor], order = order) + elif len(array.shape) == 3: + return zoom(array, [1,zoom_factor, zoom_factor], order = order) + + +def shotgun_crop(image, crop_size=512, magnification_var = None, n_crops=10, seed=42, return_binary = False, roi = 'middle'): + """ + Randomly crops a specified number of sub-images from a given image with variable magnification, supporting images with any number of channels. + + Parameters: + image (numpy.ndarray): The input image as a NumPy array. + crop_size (int, optional): The default size for each square crop. Defaults to 512. + magnification_var (float, optional): The range of magnification variability as a fraction of the crop size. + If specified, each crop will be randomly sized within [crop_size * (1 - magnification_var), crop_size * (1 + magnification_var)]. Defaults to None. + n_crops (int, optional): The number of crops to generate. Defaults to 10. + seed (int, optional): Seed for the random number generator for reproducibility. Uses random package. + + Returns: + numpy.ndarray: An array containing the cropped (and potentially resized) images as NumPy arrays. + + Important: + If using this funciton on an image and mask together, make sure to use the same seed for both. + """ + + if return_binary == True: + order = 0 + else: + order = 3 + + # Set seed for reproducibility + # Seed should be a very large integer for good results + crop_rng = np.random.default_rng(seed) + + # Get crop sizes for changing magnification later + if magnification_var is not None: + crop_sizes = crop_rng.integers(crop_size * ( 1 - magnification_var), crop_size * (1 + magnification_var), n_crops) + crop_sizes = crop_sizes.astype(int) + else: + crop_sizes = np.full(n_crops, crop_size) + + # Randomly crop images (position and size) + h, w = image.shape[-2:] + crops = [] + for size in crop_sizes: + if roi == 'middle': + edge_cutoff = crop_size//4 + top = crop_rng.integers(edge_cutoff, h - size - edge_cutoff) + left = crop_rng.integers(edge_cutoff, w - size - edge_cutoff) + else: + top = crop_rng.integers(0, h - size) + left = crop_rng.integers(0, w - size) + if len(image.shape) > 2: + crop = image[:, top:top+size, left:left+size] + crop = resize_image(crop, crop_size, order) + else: + crop = image[top:top+size, left:left+size] + crop = resize_image(crop, crop_size, order) + crops.append(crop) + + crops = np.array(crops) + batch_crops = np.stack(crops, axis=0) + + return batch_crops \ No newline at end of file diff --git a/asyncroscopy/simulation/__init__.py b/asyncroscopy/simulation/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/data/cif_files/MoS2_ortho.cif b/data/cif_files/MoS2_ortho.cif new file mode 100644 index 0000000..5e608d8 --- /dev/null +++ b/data/cif_files/MoS2_ortho.cif @@ -0,0 +1,31 @@ +data_image0 +_chemical_formula_structural S2Mo2S2 +_chemical_formula_sum "S4 Mo2" +_cell_length_a 3.19073 +_cell_length_b 5.52651 +_cell_length_c 14.2024 +_cell_angle_alpha 90 +_cell_angle_beta 90 +_cell_angle_gamma 90 + +_space_group_name_H-M_alt "P 1" +_space_group_IT_number 1 + +loop_ + _space_group_symop_operation_xyz + 'x, y, z' + +loop_ + _atom_site_type_symbol + _atom_site_label + _atom_site_symmetry_multiplicity + _atom_site_fract_x + _atom_site_fract_y + _atom_site_fract_z + _atom_site_occupancy + S S1 1.0 1.00000 0.33333 0.63924 1.0000 + S S2 1.0 1.00000 0.33333 0.86076 1.0000 + Mo Mo1 1.0 0.50000 0.16667 0.75000 1.0000 + Mo Mo2 1.0 0.00000 0.66667 0.75000 1.0000 + S S3 1.0 0.50000 0.83333 0.63924 1.0000 + S S4 1.0 0.50000 0.83333 0.86076 1.0000 diff --git a/data/cif_files/WS2_ortho.cif b/data/cif_files/WS2_ortho.cif new file mode 100644 index 0000000..4addedd --- /dev/null +++ b/data/cif_files/WS2_ortho.cif @@ -0,0 +1,31 @@ +data_image0 +_chemical_formula_structural S2W2S2 +_chemical_formula_sum "S4 W2" +_cell_length_a 3.19073 +_cell_length_b 5.52651 +_cell_length_c 14.2024 +_cell_angle_alpha 90 +_cell_angle_beta 90 +_cell_angle_gamma 90 + +_space_group_name_H-M_alt "P 1" +_space_group_IT_number 1 + +loop_ + _space_group_symop_operation_xyz + 'x, y, z' + +loop_ + _atom_site_type_symbol + _atom_site_label + _atom_site_symmetry_multiplicity + _atom_site_fract_x + _atom_site_fract_y + _atom_site_fract_z + _atom_site_occupancy + S S1 1.0 1.00000 0.33333 0.63924 1.0000 + S S2 1.0 1.00000 0.33333 0.86076 1.0000 + W W1 1.0 0.50000 0.16667 0.75000 1.0000 + W W2 1.0 0.00000 0.66667 0.75000 1.0000 + S S3 1.0 0.50000 0.83333 0.63924 1.0000 + S S4 1.0 0.50000 0.83333 0.86076 1.0000 diff --git a/docs/Operation/tango_db_mode.md b/docs/Operation/tango_db_mode.md index 16e46ae..6e1fcc9 100644 --- a/docs/Operation/tango_db_mode.md +++ b/docs/Operation/tango_db_mode.md @@ -21,7 +21,7 @@ Connect using DeviceProxy 2) in another terminal export TANGO_HOST=localhost:11000 -uv run scripts/register_devices.py +uv run scripts/2_register_devices.py - returns: - Connected: MacBook-Pro-649.local:11000 - registered: test/haadf/1 @@ -32,13 +32,14 @@ uv run scripts/register_devices.py 3) in another terminal export TANGO_HOST=localhost:11000 -uv run python -m asyncroscopy.detectors.HAADF haadf_instance +uv run python -m asyncroscopy.hardware.SCAN scan_instance - returns: - Ready to accept request 4) in another terminal export TANGO_HOST=localhost:11000 uv run python -m asyncroscopy.ThermoMicroscope microscope_instance +# uv run python -m asyncroscopy.ThermoDigitalTwin microscope_instance - returns: - True Client connecting to [localhost:9090]... diff --git a/notebooks/2_Aberrations.ipynb b/notebooks/2_a_Aberrations.ipynb similarity index 64% rename from notebooks/2_Aberrations.ipynb rename to notebooks/2_a_Aberrations.ipynb index 8925fb6..b57f396 100644 --- a/notebooks/2_Aberrations.ipynb +++ b/notebooks/2_a_Aberrations.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 17, "id": "bec67830", "metadata": {}, "outputs": [], @@ -40,7 +40,20 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 18, + "id": "9e8fca17", + "metadata": {}, + "outputs": [], + "source": [ + "# local debugging\n", + "DB_HOST = \"localhost\"\n", + "DB_PORT = 11000\n", + "os.environ[\"TANGO_HOST\"] = f\"{DB_HOST}:{DB_PORT}\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "ef85256e", "metadata": {}, "outputs": [ @@ -85,7 +98,7 @@ "# ─────────────────────────────────────────────────────────────────────────────\n", "\n", "PROJECT_DIR = os.path.dirname(os.getcwd())\n", - "os.environ[\"TANGO_HOST\"] = f\"{DB_HOST}:{DB_PORT}\"\n", + "\n", "env = {**os.environ, \"TANGO_HOST\": f\"{DB_HOST}:{DB_PORT}\"}\n", "processes = {}\n", "\n", @@ -169,17 +182,17 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 14, "id": "e7a1f3f0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "DbDevFullInfo(class_name = 'CORRECTOR', ds_full_name = 'CORRECTOR/corrector_instance', exported = 1, host = 'stingray-zm68g.device.utk.edu', ior = 'IOR:010000001700000049444c3a54616e676f2f4465766963655f363a312e3000000100000000000000de000000010102000e0000003231362e39362e3137392e3232008bd40e000000fec769ea690000bd06000000000000000400000000000000080000000100000000545441010000001c000000010000000100010001000000010001050901010001000000090101000300000018000000010000000d00000031302e36352e31342e32313100008bd40254544152000000010000001e0000007374696e677261792d7a6d3638672e6465766963652e75746b2e656475000000260000002f746d702f6f6d6e692d61757374696e2f3030303034383339302d3137373639373031383300', name = 'test/corrector/1', pid = 48390, started_date = '23-04-2026 at 14:49:43', stopped_date = '', version = '6')" + "DbDevFullInfo(class_name = 'CORRECTOR', ds_full_name = 'CORRECTOR/corrector_instance', exported = 1, host = 'macbook-pro-649.local', ior = 'IOR:010000001700000049444c3a54616e676f2f4465766963655f363a312e3000000100000000000000df000000010102000b0000003130302e36342e312e320000cde400000e000000fe3b52f6690000609f000000000000000400000000000000080000000100000000545441010000001c000000010000000100010001000000010001050901010001000000090101000300000018000000010000000e0000003137322e33302e31352e31373200cde4025454415300000001000000160000004d6163426f6f6b2d50726f2d3634392e6c6f63616c0000002f0000002f746d702f6f6d6e692d75746b6172736870726174697573682f3030303032343733352d3137373737353035383700', name = 'test/corrector/1', pid = 24735, started_date = '02-05-2026 at 15:37:42', stopped_date = '02-05-2026 at 15:36:19', version = '6')" ] }, - "execution_count": 17, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -193,10 +206,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "021ade07", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pinged CORRECTOR/corrector_instance\n", + "pinged DataBaseds/2\n" + ] + } + ], "source": [ "db = tango.Database()\n", "active_servers = db.get_server_list(\"*\").value_string\n", @@ -222,7 +244,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "0dfec932", "metadata": {}, "outputs": [ @@ -242,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "id": "6971fcba", "metadata": {}, "outputs": [ @@ -257,9 +279,11 @@ " Status\n", " acquire_tableau\n", " correct_aberration\n", + " get_aberrations_coeff_sim\n", " get_info\n", " measure_c1a1\n", - " reconnect\n" + " reconnect\n", + " set_aberrations_coeff_sim\n" ] } ], @@ -271,7 +295,80 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 28, + "id": "4900df47", + "metadata": {}, + "outputs": [], + "source": [ + "ab_msg = corrector_proxy.acquire_tableau('Fast 18')\n", + "ab = json.loads(ab_msg)['result']['aberrations']" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "d662e8c6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Acceleration voltage 60.0kV => wavelength 4.87pm\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "372a3b1a47324c98969eaa973638948e", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ab['acceleration_voltage'] = 60e3 # eV\n", + "ab['FOV'] = 100 /10 # nm\n", + "ab['convergence_angle'] = 3 # mrad\n", + "ab['wavelength'] = it.get_wavelength(ab['acceleration_voltage'])\n", + "\n", + "probe, A_k, chi = pt.get_probe(ab, 512, 512, verbose= True)\n", + "\n", + "plt.figure()\n", + "plt.imshow(probe)\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, "id": "52a7398c", "metadata": {}, "outputs": [ @@ -282,7 +379,7 @@ "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mKeyError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[7]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m ab_msg = corrector_proxy.acquire_tableau(\u001b[33m'Enhanced 40'\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m ab = json.loads(ab_msg)[\u001b[33m'result'\u001b[39m][\u001b[33m'aberrations'\u001b[39m]\n\u001b[32m 3\u001b[39m \n\u001b[32m 4\u001b[39m ab[\u001b[33m'acceleration_voltage'\u001b[39m] = \u001b[32m60e3\u001b[39m \u001b[38;5;66;03m# eV\u001b[39;00m\n\u001b[32m 5\u001b[39m ab[\u001b[33m'FOV'\u001b[39m] = \u001b[32m100\u001b[39m /\u001b[32m10\u001b[39m \u001b[38;5;66;03m# nm\u001b[39;00m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[22]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m ab_msg = corrector_proxy.acquire_tableau(\u001b[33m'Enhanced 40'\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m ab = json.loads(ab_msg)[\u001b[33m'result'\u001b[39m][\u001b[33m'aberrations'\u001b[39m]\n\u001b[32m 3\u001b[39m \n\u001b[32m 4\u001b[39m ab[\u001b[33m'acceleration_voltage'\u001b[39m] = \u001b[32m60e3\u001b[39m \u001b[38;5;66;03m# eV\u001b[39;00m\n\u001b[32m 5\u001b[39m ab[\u001b[33m'FOV'\u001b[39m] = \u001b[32m100\u001b[39m /\u001b[32m10\u001b[39m \u001b[38;5;66;03m# nm\u001b[39;00m\n", "\u001b[31mKeyError\u001b[39m: 'result'" ] } @@ -313,14 +410,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 23, "id": "a8e3fd71", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d477638d42884f9ba34af0c76e2515f9", + "model_id": "d9f2feeec9654f10b2e6398c290f8a51", "version_major": 2, "version_minor": 0 }, @@ -334,7 +431,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1c4f2cbc34664eb4866772e25b608760", + "model_id": "1658679c42554782a20edd097cc37cb6", "version_major": 2, "version_minor": 0 }, @@ -912,7 +1009,7 @@ ], "metadata": { "kernelspec": { - "display_name": "asyncroscopy", + "display_name": "asyncroscopy (3.12.9)", "language": "python", "name": "python3" }, @@ -926,7 +1023,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.12" + "version": "3.12.9" } }, "nbformat": 4, diff --git a/notebooks/2_b_Aberrations_twin.ipynb b/notebooks/2_b_Aberrations_twin.ipynb new file mode 100644 index 0000000..21b8e6b --- /dev/null +++ b/notebooks/2_b_Aberrations_twin.ipynb @@ -0,0 +1,436 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "dd8fd196", + "metadata": {}, + "source": [ + "# Notebook to simulate aberrations\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "67608926", + "metadata": {}, + "outputs": [], + "source": [ + "import subprocess\n", + "import time\n", + "import os\n", + "import tango\n", + "import json\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "315ccfbd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "' Run servers in DB mode\\nSteps to run the servers - see scripts/README_db_mode.md\\n\\nTerminal 1:\\nTANGO_HOST=localhost:11000 uv run python -m tango.databaseds.database 2\\n\\nTerminal 2:\\nexport TANGO_HOST=localhost:11000 \\nuv run scripts/2_register_devices.py \\n\\nTerminal 3:\\nexport TANGO_HOST=localhost:11000 \\nuv run python -m asyncroscopy.hardware.SCAN scan_instance\\n\\nTerminal 4:\\nexport TANGO_HOST=localhost:11000 \\nuv run python -m asyncroscopy.hardware.CORRECTOR corrector_instance\\n\\nTerminal 5:\\nexport TANGO_HOST=localhost:11000 \\nuv run python -m asyncroscopy.ThermoDigitalTwin microscope_twin_instance\\n'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\" Run servers in DB mode\n", + "Steps to run the servers - see scripts/README_db_mode.md\n", + "\n", + "Terminal 1:\n", + "TANGO_HOST=localhost:11000 uv run python -m tango.databaseds.database 2\n", + "\n", + "Terminal 2:\n", + "export TANGO_HOST=localhost:11000 \n", + "uv run scripts/2_register_devices.py \n", + "\n", + "Terminal 3:\n", + "export TANGO_HOST=localhost:11000 \n", + "uv run python -m asyncroscopy.hardware.SCAN scan_instance\n", + "\n", + "Terminal 4:\n", + "export TANGO_HOST=localhost:11000 \n", + "uv run python -m asyncroscopy.hardware.CORRECTOR corrector_instance\n", + "\n", + "Terminal 5:\n", + "export TANGO_HOST=localhost:11000 \n", + "uv run python -m asyncroscopy.ThermoDigitalTwin microscope_twin_instance\n", + "\"\"\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cd6358f1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Devices registered in Tango DB:\n", + "\n", + "dserver/CAMERA/camera_instance\n", + "dserver/CORRECTOR/corrector_instance\n", + "dserver/DataBaseds/2\n", + "dserver/EDS/eds_instance\n", + "dserver/SCAN/scan_instance\n", + "dserver/STAGE/stage_instance\n", + "dserver/TangoAccessControl/1\n", + "dserver/TangoTest/test\n", + "dserver/ThermoDigitalTwin/microscope_twin_instance\n", + "dserver/ThermoMicroscope/microscope_instance\n", + "sys/access_control/1\n", + "sys/database/2\n", + "sys/tg_test/1\n", + "test/camera/1\n", + "test/corrector/1\n", + "test/eds/1\n", + "test/microscope/1\n", + "test/microscope_twin/1\n", + "test/scan/1\n", + "test/stage/1\n" + ] + } + ], + "source": [ + "# Tango DB running on this\n", + "os.environ[\"TANGO_HOST\"] = \"localhost:11000\"\n", + "# os.environ[\"TANGO_HOST\"] = \"10.46.217.241:9094\"\n", + "\n", + "\n", + "# list devices on DB\n", + "db = tango.Database()\n", + "devices = db.get_device_name(\"*\", \"*\")\n", + "print(\"Devices registered in Tango DB:\\n\")\n", + "for d in devices:\n", + " print(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c1ac3776", + "metadata": {}, + "outputs": [], + "source": [ + "# set timeouts\n", + "scan = tango.DeviceProxy(\"test/scan/1\")\n", + "mic_proxy = tango.DeviceProxy(\"test/microscope_twin/1\")\n", + "corrector_proxy = tango.DeviceProxy(\"test/corrector/1\")\n", + "\n", + "scan.set_timeout_millis(120_000)\n", + "mic_proxy.set_timeout_millis(120_000)\n", + "corrector_proxy.set_timeout_millis(120_000)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ed39cc77", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Microscope commands ---\n", + " Connect\n", + " Disconnect\n", + " Init\n", + " State\n", + " Status\n", + " auto_focus\n", + " blank_beam\n", + " get_camera_image\n", + " get_fov\n", + " get_image_data_cached\n", + " get_images\n", + " get_scanned_image\n", + " get_scanned_image_with_aberrations\n", + " get_screen_current\n", + " get_spectrum\n", + " get_stage\n", + " move_stage\n", + " place_beam\n", + " set_fov\n", + " set_image_shift\n", + " set_screen_current\n", + " unblank_beam\n", + "\n", + "--- Microscope commands ---\n", + " Init\n", + " State\n", + " Status\n", + " acquire_tableau\n", + " correct_aberration\n", + " get_aberrations_coeff_sim\n", + " get_info\n", + " measure_c1a1\n", + " reconnect\n", + " set_aberrations_coeff_sim\n", + "\n", + "--- Microscope commands ---\n", + " Activate\n", + " Init\n", + " State\n", + " Status\n" + ] + } + ], + "source": [ + "print('\\n--- Microscope commands ---')\n", + "for cmd in mic_proxy.get_command_list():\n", + " print(f' {cmd}')\n", + "\n", + "print('\\n--- Microscope commands ---')\n", + "for cmd in corrector_proxy.get_command_list():\n", + " print(f' {cmd}')\n", + "\n", + "print('\\n--- Microscope commands ---')\n", + "for cmd in scan.get_command_list():\n", + " print(f' {cmd}')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a8c9c1bf", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import ast\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import pyTEMlib\n", + "from pyTEMlib import probe_tools as pt" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "29556142", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Aberrations [nm] for acceleration voltage: 200 kV
C10 0.0
C12a (A1) 0.0 C12b (A1) 0.4
C21a (B2) -68.5 C21b (B2) 64.9 C23a (A2) 11.7 C23b (A2) -29.8
C30 123.0
C32a (S3) 95.3 C32b (S3) -189.7 C34a (A3) -47.5 C34b (A3) -94.7
C41a (B4) -905 C41b (B4) 981 C43a (D4) 4.02e+03 C43b (D4) 981 C45a (A4) -4.7e+03 C45b (A4) -208
C50 5.52e+05
C52a -0.0 C52b 0.0 C54a -0.0 C54b -0.0 C56a -36663.6 C56b 21356.1
Cc 1e+06
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate aberrations and upload on the device\n", + "aberrations = pt.get_target_aberrations(\"Spectra300\", 60000)\n", + "pt.print_aberrations(aberrations)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "38af5529", + "metadata": {}, + "outputs": [], + "source": [ + "aberrations_in = json.dumps(aberrations)\n", + "corrector_proxy.set_aberrations_coeff_sim(aberrations_in)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "387d0fab", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'C10': 0,\n", + " 'C12a': 0,\n", + " 'C12b': 0.38448128113770325,\n", + " 'C21a': -68.45251255685642,\n", + " 'C21b': 64.85359774641199,\n", + " 'C23a': 11.667578600494137,\n", + " 'C23b': -29.775627778458194,\n", + " 'C30': 123,\n", + " 'C32a': 95.3047364258614,\n", + " 'C32b': -189.72105710231244,\n", + " 'C34a': -47.45099594807912,\n", + " 'C34b': -94.67424667529909,\n", + " 'C41a': -905.31842572806,\n", + " 'C41b': 981.316128853203,\n", + " 'C43a': 4021.8433526960034,\n", + " 'C43b': 131.72716642732158,\n", + " 'C45a': -4702.390968272048,\n", + " 'C45b': -208.25028574642903,\n", + " 'C50': 552000.0,\n", + " 'C52a': -0.0,\n", + " 'C52b': 0.0,\n", + " 'C54a': -0.0,\n", + " 'C54b': -0.0,\n", + " 'C56a': -36663.643489934424,\n", + " 'C56b': 21356.079837905396,\n", + " 'acceleration_voltage': 200000,\n", + " 'FOV': 34.241659495148205,\n", + " 'Cc': 1000000.0,\n", + " 'convergence_angle': 30,\n", + " 'wavelength': 0.0025079340450548005}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aberrations_read = corrector_proxy.get_aberrations_coeff_sim()\n", + "json.loads(aberrations_read)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7e0a1c1c", + "metadata": {}, + "outputs": [], + "source": [ + "scan.dwell_time = 10e-6\n", + "scan.imsize = 905 ######" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f87a9762", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Metadata: {'detector': 'haadf', 'shape': [905, 905], 'dtype': 'float32', 'dwell_time': 1e-05, 'timestamp': 1777838390.187684}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Upload abberations on the twin\n", + "json_meta, raw_bytes = mic_proxy.get_scanned_image_with_aberrations()\n", + "meta = json.loads(json_meta)\n", + "print(f\"Metadata: {meta}\")\n", + "\n", + "image = np.frombuffer(raw_bytes, dtype=meta[\"dtype\"]).reshape(meta[\"shape\"])\n", + "\n", + "plt.figure(figsize=(8, 8))\n", + "plt.imshow(image.T, cmap='gray')\n", + "plt.title(f\"Simulated {meta['detector']} image\")\n", + "plt.colorbar()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "161b761f", + "metadata": {}, + "outputs": [], + "source": [ + "# change dwell time -> less brighter atomic columns\n", + "scan.dwell_time = 0.001e-6\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d433f0e4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Metadata: {'detector': 'haadf', 'shape': [905, 905], 'dtype': 'float32', 'dwell_time': 1e-09, 'timestamp': 1777838397.137355}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Upload abberations on the twin\n", + "json_meta, raw_bytes = mic_proxy.get_scanned_image_with_aberrations()\n", + "meta = json.loads(json_meta)\n", + "print(f\"Metadata: {meta}\")\n", + "\n", + "image = np.frombuffer(raw_bytes, dtype=meta[\"dtype\"]).reshape(meta[\"shape\"])\n", + "\n", + "plt.figure(figsize=(8, 8))\n", + "plt.imshow(image.T, cmap='gray')\n", + "plt.title(f\"Simulated {meta['detector']} image\")\n", + "plt.colorbar()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e4fc558", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "asyncroscopy (3.12.9)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/3_Sample_map.ipynb b/notebooks/3_Sample_map.ipynb index e99b786..0e738a3 100644 --- a/notebooks/3_Sample_map.ipynb +++ b/notebooks/3_Sample_map.ipynb @@ -183,7 +183,19 @@ "id": "58c7aa30", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "#local \n", + "DB_HOST = \"10.46.217.241\"\n", + "DB_PORT = 9094\n", + "\n", + "PROJECT_DIR = os.path.dirname(os.getcwd())\n", + "os.environ[\"TANGO_HOST\"] = f\"{DB_HOST}:{DB_PORT}\"\n", + "env = {**os.environ, \"TANGO_HOST\": f\"{DB_HOST}:{DB_PORT}\"}\n", + "\n", + "db = tango.Database()\n", + "devices = db.get_device_name(\"*\", \"*\").value_string\n", + "print(devices)" + ] }, { "cell_type": "code", @@ -410,7 +422,7 @@ ], "metadata": { "kernelspec": { - "display_name": "asyncroscopy", + "display_name": "asyncroscopy (3.12.9)", "language": "python", "name": "python3" }, @@ -424,7 +436,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.12" + "version": "3.12.9" } }, "nbformat": 4, diff --git a/scripts/2_register_devices.py b/scripts/2_register_devices.py index 3a67713..e030071 100644 --- a/scripts/2_register_devices.py +++ b/scripts/2_register_devices.py @@ -41,6 +41,15 @@ MICRO_SERVER = "ThermoMicroscope/microscope_instance" MICRO_CLASS = "ThermoMicroscope" MICRO_DEVICE = "test/microscope/1" + +MICRO_TWIN_SERVER = "ThermoDigitalTwin/microscope_twin_instance" +MICRO_TWIN_CLASS = "ThermoDigitalTwin" +MICRO_TWIN_DEVICE = "test/microscope_twin/1" + + +CORRECTOR_SERVER = "CORRECTOR/corrector_instance" +CORRECTOR_CLASS = "CORRECTOR" +CORRECTOR_DEVICE = "test/corrector/1" # ────────────────────────────────────────────────────────────── @@ -63,13 +72,22 @@ def main(): add_device(db, STAGE_SERVER, STAGE_CLASS, STAGE_DEVICE) add_device(db, CORRECTOR_SERVER, CORRECTOR_CLASS, CORRECTOR_DEVICE) add_device(db, MICRO_SERVER, MICRO_CLASS, MICRO_DEVICE) + add_device(db, MICRO_TWIN_SERVER, MICRO_TWIN_CLASS, MICRO_TWIN_DEVICE) + + db.put_device_property(MICRO_DEVICE, {"scan_device_address": [SCAN_DEVICE]}) db.put_device_property(MICRO_DEVICE, {"camera_device_address": [CAMERA_DEVICE]}) db.put_device_property(MICRO_DEVICE, {"eds_device_address": [EDS_DEVICE]}) + db.put_device_property(MICRO_DEVICE, {"corrector_device_address": [CORRECTOR_DEVICE]}) db.put_device_property(MICRO_DEVICE, {"stage_device_address": [STAGE_DEVICE]}) db.put_device_property(MICRO_DEVICE, {"corrector_device_address": [CORRECTOR_DEVICE]}) + db.put_device_property(MICRO_TWIN_DEVICE, {"scan_device_address": [SCAN_DEVICE]}) + db.put_device_property(MICRO_TWIN_DEVICE, {"eds_device_address": [EDS_DEVICE]}) + db.put_device_property(MICRO_TWIN_DEVICE, {"corrector_device_address": [CORRECTOR_DEVICE]}) + db.put_device_property(MICRO_TWIN_DEVICE, {"stage_device_address": [STAGE_DEVICE]}) + print(f" property: scan_device_address = {SCAN_DEVICE}") print(f" property: camera_device_address = {CAMERA_DEVICE}") print(f" property: eds_device_address = {EDS_DEVICE}") diff --git a/tango_database.db b/tango_database.db deleted file mode 100644 index 5ec3f5e..0000000 Binary files a/tango_database.db and /dev/null differ diff --git a/tests/test_stem_sim.py b/tests/test_stem_sim.py new file mode 100644 index 0000000..ee78e09 --- /dev/null +++ b/tests/test_stem_sim.py @@ -0,0 +1,158 @@ +import numpy as np +import pytest +from ase.build import bulk + +from asyncroscopy.simulation.StemSim import ( + make_holes, + rotate_xtal, + sub_pix_gaussian, + create_pseudo_potential, + get_masks, + poisson_noise, + lowfreq_noise, + grid_crop, + resize_image, + shotgun_crop, +) + +# ── Fixtures ────────────────────────────────────────────────────────────────── + +@pytest.fixture +def simple_crystal(): + """Small gold FCC crystal for testing.""" + return bulk('Au', 'fcc', a=4.08, cubic=True).repeat([3, 3, 1]) + +@pytest.fixture +def simple_potential(simple_crystal): + """Generate a small potential map from the crystal.""" + bounds = [0, 12, 0, 12] + return create_pseudo_potential(simple_crystal, pixel_size=0.1, sigma=0.5, bounds=bounds) + +# ── make_holes ───────────────────────────────────────────────────────────────── + +def test_make_holes_reduces_atoms(simple_crystal): + original_count = len(simple_crystal) + result = make_holes(simple_crystal.copy(), n_holes=2, hole_size=3.0) + assert len(result) < original_count + +def test_make_holes_zero_holes(simple_crystal): + original_count = len(simple_crystal) + result = make_holes(simple_crystal.copy(), n_holes=0, hole_size=3.0) + assert len(result) == original_count + +# ── rotate_xtal ──────────────────────────────────────────────────────────────── + +def test_rotate_xtal_preserves_cell(simple_crystal): + rotated = rotate_xtal(simple_crystal, 45) + np.testing.assert_allclose(rotated.cell, simple_crystal.cell, atol=1e-6) + +def test_rotate_xtal_360_similar_count(simple_crystal): + original = len(simple_crystal) + rotated = rotate_xtal(simple_crystal, 360) + # Boundary clipping is expected even at 360°, so allow generous tolerance + assert abs(len(rotated) - original) < original * 0.5 + +# ── sub_pix_gaussian ─────────────────────────────────────────────────────────── + +def test_sub_pix_gaussian_shape(): + g = sub_pix_gaussian(size=10, sigma=0.5) + assert g.shape == (10, 10) + +def test_sub_pix_gaussian_max_is_one(): + g = sub_pix_gaussian(size=10, sigma=0.5) + assert np.isclose(g.max(), 1.0) + +def test_sub_pix_gaussian_shift(): + g_centered = sub_pix_gaussian(size=21, sigma=1.0, dx=0, dy=0) + g_shifted = sub_pix_gaussian(size=21, sigma=1.0, dx=2, dy=0) + # Peak should move — arrays must differ + assert not np.allclose(g_centered, g_shifted) + +# ── create_pseudo_potential ──────────────────────────────────────────────────── + +def test_potential_shape(simple_potential): + bounds = [0, 12, 0, 12] + expected = int((bounds[1] - bounds[0]) / 0.1) + assert simple_potential.shape == (expected, expected) + +def test_potential_normalized(simple_potential): + assert simple_potential.max() <= 1.0 + assert simple_potential.min() >= 0.0 + +# ── get_masks ────────────────────────────────────────────────────────────────── + +def test_get_masks_one_hot(simple_crystal): + masks = get_masks(simple_crystal, pixel_size=0.2, radius=3, mode='one_hot') + # First channel = background; channels sum to 1 everywhere + assert masks.ndim == 3 + assert masks[0].shape == masks[1].shape # all channels same spatial size + +def test_get_masks_binary(simple_crystal): + mask = get_masks(simple_crystal, pixel_size=0.2, radius=3, mode='binary') + assert set(np.unique(mask)).issubset({0, 1}) + +def test_get_masks_integer(simple_crystal): + mask = get_masks(simple_crystal, pixel_size=0.2, radius=3, mode='integer') + assert mask.ndim == 2 + +def test_get_masks_invalid_mode(simple_crystal): + with pytest.raises(ValueError): + get_masks(simple_crystal, mode='invalid_mode') + +# ── poisson_noise ────────────────────────────────────────────────────────────── + +def test_poisson_noise_range(simple_potential): + noisy = poisson_noise(simple_potential, counts=1e6) + assert noisy.min() >= 0.0 + assert noisy.max() <= 1.0 + +def test_poisson_noise_changes_image(simple_potential): + noisy = poisson_noise(simple_potential, counts=1e6) + assert not np.allclose(noisy, simple_potential) + +# ── lowfreq_noise ────────────────────────────────────────────────────────────── + +def test_lowfreq_noise_shape(simple_potential): + noisy = lowfreq_noise(simple_potential, noise_level=0.05) + assert noisy.shape == simple_potential.shape + +# ── grid_crop ────────────────────────────────────────────────────────────────── + +def test_grid_crop_output_count(): + img = np.random.rand(640, 640) + crops = grid_crop(img, crop_size=128, crop_glide=64) + expected_n = int((640 - 128) / 64 + 1) ** 2 + assert crops.shape[0] == expected_n + assert crops.shape[1:] == (128, 128) + +# ── resize_image ─────────────────────────────────────────────────────────────── + +def test_resize_image_2d(): + arr = np.random.rand(100, 100) + resized = resize_image(arr, 64) + assert resized.shape == (64, 64) + +def test_resize_image_3d(): + arr = np.random.rand(3, 100, 100) + resized = resize_image(arr, 64) + assert resized.shape == (3, 64, 64) + +# ── shotgun_crop ─────────────────────────────────────────────────────────────── + +def test_shotgun_crop_count(): + img = np.random.rand(1024, 1024) + crops = shotgun_crop(img, crop_size=256, n_crops=5, seed=0) + assert crops.shape[0] == 5 + assert crops.shape[1:] == (256, 256) + +def test_shotgun_crop_reproducible(): + img = np.random.rand(1024, 1024) + c1 = shotgun_crop(img, crop_size=256, n_crops=3, seed=99) + c2 = shotgun_crop(img, crop_size=256, n_crops=3, seed=99) + np.testing.assert_array_equal(c1, c2) + +def test_shotgun_crop_magnification_var(): + img = np.random.rand(1024, 1024) + # Should not raise; output still standardized to crop_size + crops = shotgun_crop(img, crop_size=256, magnification_var=0.2, n_crops=5, seed=0) + assert crops.shape == (5, 256, 256) \ No newline at end of file