From 52903495b48c38e6b5b2832b5a5b447ee8cd7947 Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Thu, 26 Feb 2026 12:26:27 -0800 Subject: [PATCH 01/14] Allowed for Python 3.11 --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index d874026..6d12fbe 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -3,7 +3,7 @@ name = "PySlice" version = "0.1.0" description = "PyTorch based package for EELS calculations" readme = "README.md" -requires-python = ">=3.12" +requires-python = ">=3.11" dependencies = [ "ase", "dataclasses", From 4dca9dc1609e026933d90cd68b1ed0cd0d666ad3 Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Tue, 17 Mar 2026 15:10:35 -0700 Subject: [PATCH 02/14] Initial implementation of time chunking TACAW trajectory --- src/pyslice/postprocessing/tacaw_data.py | 94 ++++++++++++++---------- 1 file changed, 54 insertions(+), 40 deletions(-) diff --git a/src/pyslice/postprocessing/tacaw_data.py b/src/pyslice/postprocessing/tacaw_data.py index c6e4fe4..0c4531a 100644 --- a/src/pyslice/postprocessing/tacaw_data.py +++ b/src/pyslice/postprocessing/tacaw_data.py @@ -63,7 +63,12 @@ class TACAWData(PySliceSerial, Signal): 'force_datasets': ['_array', 'probe_positions', '_kxs', '_kys', '_xs', '_ys', '_time', '_layer', '_frequencies'], } - def __init__(self, wf_data: WFData, layer_index: int = None, keep_complex: bool = False, chunkFFT: bool = False) -> None: + def __init__(self, + wf_data: WFData, + layer_index: int = None, + keep_complex: bool = False, + chunkFFT: bool = False, + chunk_size_time: int = None) -> None: """ Initialize TACAWData from WFData by performing FFT. @@ -85,6 +90,7 @@ def __init__(self, wf_data: WFData, layer_index: int = None, keep_complex: bool self.keep_complex = keep_complex self.chunkFFT = chunkFFT self.use_memmap = isinstance(wf_data._array,np.memmap) + self.chunk_size_time = chunk_size_time # Store reference to source WFData array for FFT computation self._wf_array = wf_data._array @@ -210,19 +216,31 @@ def _fft_from_wf_data(self, layer_index: int = None): if layer_index < 0 or layer_index >= len(self._layer): raise ValueError(f"layer_index {layer_index} out of range [0, {len(self._layer)-1}]") - # Compute frequencies from time sampling - n_freq = len(self._time) + # Extract wavefunction data for the specified layer + # Shape: (probe_positions, time, kx, ky, layer) + wf_layer = self._wf_array[:, :, :, :, layer_index] + + if self.chunk_size_time is None: + self.n_chunks = 1 + else: + self.n_chunks = len(self._time) // self.chunk_size_time + + indices = np.linspace(0, len(self._time), self.n_chunks + 1, dtype=int) dt = self._time[1] - self._time[0] + # Compute frequencies from time sampling + n_freq = self.n_chunks self._frequencies = np.fft.fftfreq(n_freq, d=dt) self._frequencies = np.fft.fftshift(self._frequencies) - # Extract wavefunction data for the specified layer - # Shape: (probe_positions, time, kx, ky, layer) - wf_layer = self._wf_array[:, :, :, :, layer_index] + self._array = None + + for i in range(self.n_chunks): + i1 = indices[i] + i2 = indices[i+1] - # Perform FFT along time axis (axis=1) for each probe position and k-point - # Following abeels.py approach: subtract mean to avoid high zero-frequency peak - # then Compute intensity |Ψ(ω,q)|² from the frequency-domain wavefunction + # Perform FFT along time axis (axis=1) for each probe position and k-point + # Following abeels.py approach: subtract mean to avoid high zero-frequency peak + # then Compute intensity |Ψ(ω,q)|² from the frequency-domain wavefunction #if TORCH_AVAILABLE and hasattr(wf_layer, 'dim'): # Check if it's a torch tensor # wf_mean = torch.mean(wf_layer, dim=1, keepdim=True) @@ -236,43 +254,38 @@ def _fft_from_wf_data(self, layer_index: int = None): # wf_fft = np.fft.fft(wf_layer - wf_mean, axis=1) # wf_fft = np.fft.fftshift(wf_fft, axes=1) - if self.chunkFFT: # looping through x (in case super giganormous FFTs blow your ram) - dtype = complex_dtype if self.keep_complex else float_dtype - if self.use_memmap: - self._array = memmap(wf_layer.shape, dtype=dtype, filename = self.cache_dir / "tacaw.npy") - else: - self._array = xp.zeros(wf_layer.shape, dtype = dtype) - - for i in tqdm(range(len(self._kxs))): - wf_mean = mean(wf_layer[:,:,i,:], axis=1, keepdims=True) # p,t,x,y,[l] indices - wf_fft = fft(wf_layer[:,:,i,:] - wf_mean, axis=1) - wf_fft = fftshift(wf_fft, axes=1) + if self.chunkFFT: # looping through x (in case super giganormous FFTs blow your ram) + dtype = complex_dtype if self.keep_complex else float_dtype + if self.use_memmap: + self._array = memmap(wf_layer.shape, dtype=dtype, filename = self.cache_dir / "tacaw.npy") + else: + self._array = xp.zeros(wf_layer.shape, dtype = dtype) + + for i in tqdm(range(len(self._kxs))): + wf_mean = mean(wf_layer[:,slice(i1,i2),i,:], axis=1, keepdims=True) # p,t,x,y,[l] indices + wf_fft = fft(wf_layer[:,slice(i1,i2),i,:] - wf_mean, axis=1) + wf_fft = fftshift(wf_fft, axes=1) if not self.keep_complex: wf_fft = absolute(wf_fft)**2 - self._array[:,:,i,:] = wf_fft - - else: - wf_mean = mean(wf_layer, axis=1, keepdims=True) - wf_fft = fft(wf_layer - wf_mean, axis=1) - wf_fft = fftshift(wf_fft, axes=1) - - if not self.keep_complex: - wf_fft = absolute(wf_fft)**2 + if self._array is None: + self._array[:,:,i,:] = wf_fft + else: + self._array[:,:,i,:] += wf_fft - self._array = wf_fft + else: + wf_mean = mean(wf_layer[:,slice(i1,i2),:,:], axis=1, keepdims=True) + wf_fft = fft(wf_layer[:,slice(i1,i2),:,:] - wf_mean, axis=1) + wf_fft = fftshift(wf_fft, axes=1) - #if TORCH_AVAILABLE and hasattr(wf_fft, 'dim'): # Check if it's a torch tensor - # if self.keep_complex: - # self._array = wf_fft - # else: - # self._array = torch.abs(wf_fft)**2 - #else: - # if self.keep_complex: - # self._array = wf_fft - # else: - # self._array = np.abs(wf_fft)**2 + if not self.keep_complex: + wf_fft = absolute(wf_fft)**2 + + if self._array is None: + self._array = wf_fft + else: + self._array += wf_fft # Ensure cache directory exists (may have been cleaned up by calculator) self.cache_dir.mkdir(parents=True, exist_ok=True) @@ -280,6 +293,7 @@ def _fft_from_wf_data(self, layer_index: int = None): if not self.use_memmap: np.save(self.cache_dir / "tacaw.npy", to_cpu(self._array) ) + # Keep fft_from_wf_data as public alias for backward compatibility def fft_from_wf_data(self, layer_index: int = None): """Public alias for _fft_from_wf_data (backward compatibility).""" From c7079bfa14e25162801b3caeaa31da530b8ba81b Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Tue, 17 Mar 2026 15:40:31 -0700 Subject: [PATCH 03/14] Refactored initial implementation of TACAW chunking to align better with PySlice logic and preallocation of arrays --- src/pyslice/postprocessing/tacaw_data.py | 59 ++++++++++-------------- 1 file changed, 24 insertions(+), 35 deletions(-) diff --git a/src/pyslice/postprocessing/tacaw_data.py b/src/pyslice/postprocessing/tacaw_data.py index 0c4531a..0ec4bd2 100644 --- a/src/pyslice/postprocessing/tacaw_data.py +++ b/src/pyslice/postprocessing/tacaw_data.py @@ -228,39 +228,25 @@ def _fft_from_wf_data(self, layer_index: int = None): indices = np.linspace(0, len(self._time), self.n_chunks + 1, dtype=int) dt = self._time[1] - self._time[0] # Compute frequencies from time sampling - n_freq = self.n_chunks - self._frequencies = np.fft.fftfreq(n_freq, d=dt) + self._frequencies = np.fft.fftfreq(self.n_chunks, d=dt) self._frequencies = np.fft.fftshift(self._frequencies) - self._array = None + # Perform FFT along time axis (axis=1) for each probe position and k-point + # Following abeels.py approach: subtract mean to avoid high zero-frequency peak + # then Compute intensity |Ψ(ω,q)|² from the frequency-domain wavefunction + + if self.chunkFFT: # looping through x (in case super giganormous FFTs blow your ram) + dtype = complex_dtype if self.keep_complex else float_dtype + shape = (wf_layer.shape[0], self.n_chunks, wf_layer.shape[2], wf_layer.shape[3]) + if self.use_memmap: + self._array = memmap(shape, dtype=dtype, filename = self.cache_dir / "tacaw.npy") + else: + self._array = xp.zeros(shape, dtype = dtype) + + for i in range(self.n_chunks): + i1 = indices[i] + i2 = indices[i+1] - for i in range(self.n_chunks): - i1 = indices[i] - i2 = indices[i+1] - - # Perform FFT along time axis (axis=1) for each probe position and k-point - # Following abeels.py approach: subtract mean to avoid high zero-frequency peak - # then Compute intensity |Ψ(ω,q)|² from the frequency-domain wavefunction - - #if TORCH_AVAILABLE and hasattr(wf_layer, 'dim'): # Check if it's a torch tensor - # wf_mean = torch.mean(wf_layer, dim=1, keepdim=True) - # #if self.chunkFFT: - # #for i in tqdm(range(len(self._kxs))): - # # wf_fft = torch.fft.fft(wf_layer[:,:,i,:,:] - # wf_fft = torch.fft.fft(wf_layer - wf_mean, dim=1) - # wf_fft = torch.fft.fftshift(wf_fft, dim=1) - #else: - # wf_mean = np.mean(wf_layer, axis=1, keepdims=True) - # wf_fft = np.fft.fft(wf_layer - wf_mean, axis=1) - # wf_fft = np.fft.fftshift(wf_fft, axes=1) - - if self.chunkFFT: # looping through x (in case super giganormous FFTs blow your ram) - dtype = complex_dtype if self.keep_complex else float_dtype - if self.use_memmap: - self._array = memmap(wf_layer.shape, dtype=dtype, filename = self.cache_dir / "tacaw.npy") - else: - self._array = xp.zeros(wf_layer.shape, dtype = dtype) - for i in tqdm(range(len(self._kxs))): wf_mean = mean(wf_layer[:,slice(i1,i2),i,:], axis=1, keepdims=True) # p,t,x,y,[l] indices wf_fft = fft(wf_layer[:,slice(i1,i2),i,:] - wf_mean, axis=1) @@ -269,12 +255,15 @@ def _fft_from_wf_data(self, layer_index: int = None): if not self.keep_complex: wf_fft = absolute(wf_fft)**2 - if self._array is None: - self._array[:,:,i,:] = wf_fft - else: - self._array[:,:,i,:] += wf_fft + self._array[:,:,i,:] += wf_fft + + else: + self._array = None + + for i in range(self.n_chunks): + i1 = indices[i] + i2 = indices[i+1] - else: wf_mean = mean(wf_layer[:,slice(i1,i2),:,:], axis=1, keepdims=True) wf_fft = fft(wf_layer[:,slice(i1,i2),:,:] - wf_mean, axis=1) wf_fft = fftshift(wf_fft, axes=1) From 82383518a78cc2dd2bdc1461ec108a13e749ddce Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Sat, 21 Mar 2026 23:29:39 -0700 Subject: [PATCH 04/14] Updated the backend to expand the functionality and enable device selection via environment variable --- src/pyslice/backend.py | 364 ++++++++++++++++++++++++++++++----------- 1 file changed, 264 insertions(+), 100 deletions(-) diff --git a/src/pyslice/backend.py b/src/pyslice/backend.py index 69a48aa..4d6864e 100644 --- a/src/pyslice/backend.py +++ b/src/pyslice/backend.py @@ -1,106 +1,83 @@ -# backend.py +# backend.py - Backend abstraction layer for NumPy/PyTorch support import numpy as np import os -#import torch - - -def device_and_precision(device_spec=None): - - # We always choose PyTorch if available - if xp != np: - if device_spec is None: - device = DEFAULT_DEVICE - else: - device = xp.device(device_spec) - else: - device = None - - if device is not None and device.type == 'mps': # Use float32 for MPS (doesn't support float64), float64 for CPU/CUDA - complex_dtype = xp.complex64 - float_dtype = xp.float32 - else: - complex_dtype = xp.complex128 - float_dtype = xp.float64 - - return device, float_dtype, complex_dtype +# First, try to import torch try: import torch - xp = torch - if torch.cuda.is_available(): - config = device_and_precision('cuda') - elif torch.backends.mps.is_available(): - config = device_and_precision('mps') - else: - config = device_and_precision('cpu') TORCH_AVAILABLE = True - except ImportError: - xp = np - config = device_and_precision() TORCH_AVAILABLE = False + torch = None -DEFAULT_DEVICE, DEFAULT_FLOAT_DTYPE, DEFAULT_COMPLEX_DTYPE = config -del config +# Check for backend override via environment variable +import os +backend_override = os.environ.get('PYSLICE_BACKEND', '').lower() -# Aliases for convenience -float_dtype = DEFAULT_FLOAT_DTYPE -complex_dtype = DEFAULT_COMPLEX_DTYPE +if backend_override == 'numpy' or not TORCH_AVAILABLE: + xp = np + TORCH_BACKEND = False +else: + xp = torch + TORCH_BACKEND = True -def configure_backend(device_spec=None, backend_spec=None): +def device_and_precision(device_spec=None): """ - Configure and return backend settings. - + Determine the device and precision (dtype) to use. + Args: device_spec: Device specification ('cpu', 'cuda', 'mps', or None for auto) - backend_spec: Backend specification ('numpy', 'torch', or None for auto) - + Returns: - Tuple of (backend, device, float_dtype, complex_dtype) + Tuple of (device, float_dtype, complex_dtype) """ - global xp, DEFAULT_DEVICE, DEFAULT_FLOAT_DTYPE, DEFAULT_COMPLEX_DTYPE - global float_dtype, complex_dtype - - # Determine backend - if backend_spec == 'numpy': - backend = np - device = None - fdtype = np.float64 - cdtype = np.complex128 - else: - # Use torch - backend = torch - if device_spec is None: - if torch.cuda.is_available(): - device = torch.device('cuda') - elif torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') + if not TORCH_BACKEND: + return None, np.float64, np.complex128 + + # Check for device override via environment variable + device_override = os.environ.get('PYSLICE_DEVICE', '').lower() + if device_override: + device_spec = device_override + + # Auto-detect device if not specified + if device_spec is None: + if torch.cuda.is_available(): + device = torch.device('cuda') + elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): + device = torch.device('mps') else: - device = torch.device(device_spec) + device = torch.device('cpu') + else: + device = torch.device(device_spec) + + # Use float32 for MPS (doesn't support float64), float64 for CPU/CUDA + if device.type == 'mps': + float_dtype = torch.float32 + complex_dtype = torch.complex64 + else: + float_dtype = torch.float64 + complex_dtype = torch.complex128 + + return device, float_dtype, complex_dtype - # Set precision based on device - if device.type == 'mps': - fdtype = torch.float32 - cdtype = torch.complex64 - else: - fdtype = torch.float64 - cdtype = torch.complex128 - return (backend, device, fdtype, cdtype) +# Determine default device and dtypes at import time +DEFAULT_DEVICE, DEFAULT_FLOAT_DTYPE, DEFAULT_COMPLEX_DTYPE = device_and_precision() + +# Convenience aliases +float_dtype = DEFAULT_FLOAT_DTYPE +complex_dtype = DEFAULT_COMPLEX_DTYPE def asarray(arraylike, dtype=None, device=None): + """Convert array-like object to backend array (NumPy or PyTorch tensor).""" if dtype is None: dtype = DEFAULT_FLOAT_DTYPE if device is None: device = DEFAULT_DEVICE - if xp != np: -# if dtype == bool: -# dtype = xp.bool + if TORCH_BACKEND: array = xp.tensor(arraylike, dtype=dtype, device=device) else: array = xp.asarray(arraylike, dtype=dtype) @@ -111,24 +88,28 @@ def astype(arraylike,dtype): return arraylike.to(dtype) return arraylike.astype(dtype) # numpy + def zeros(dims, dtype=None, device=None, type_match=None): - if type_match is not None: # pass an array, and we either infer dtype from the first element, or you also specified a dtype + """Create a zero-filled array.""" + if type_match is not None: + # Infer dtype/device from type_match array if dtype is None: dtype = type_match.dtype - if device is None and hasattr(type_match,"device"): + if device is None and hasattr(type_match, "device"): device = type_match.device - if type(type_match) in [ np.memmap, np.ndarray ]: - return np.zeros(dims,dtype=dtype) - # default in dtype and device (None in function declaration allows inferring whether it was passed for type_match) + if type(type_match) in [np.memmap, np.ndarray]: + return np.zeros(dims, dtype=dtype) + + # Set defaults if dtype is None: - dtype=DEFAULT_FLOAT_DTYPE + dtype = DEFAULT_FLOAT_DTYPE if device is None: device=DEFAULT_DEVICE # string handling for dtype, "float" --> float if isinstance(dtype,str): dtype={"float":DEFAULT_FLOAT_DTYPE,"complex":DEFAULT_COMPLEX_DTYPE,"int":int}[dtype] # infer if we're using torch or numpy (numpy does not take device arg) - if xp != np: + if TORCH_BACKEND: array = xp.zeros(dims, dtype=dtype, device=device) else: array = xp.zeros(dims, dtype=dtype) @@ -147,10 +128,13 @@ def memmap(dims,dtype=DEFAULT_FLOAT_DTYPE,filename=None): #print("creating memmap",mode,dtype,dims,"->",filename) return open_memmap(filename, dtype=dtype, mode=mode, shape=dims) -def absolute(array): - if xp != np and type(array) in [ np.memmap, np.ndarray ]: - return np.absolute(array) - return xp.absolute(array) + +def absolute(x): + """Element-wise absolute value.""" + if TORCH_BACKEND and type(x) in [np.memmap, np.ndarray]: + return np.absolute(x) + return xp.absolute(x) + def reshape(array,shape): if xp != np and type(array) == np.memmap: @@ -158,24 +142,87 @@ def reshape(array,shape): return xp.reshape(array,shape) def ones(dims, dtype=DEFAULT_FLOAT_DTYPE, device=DEFAULT_DEVICE): - if xp != np: + """Create a one-filled array.""" + if TORCH_BACKEND: return xp.ones(dims, dtype=dtype, device=device) else: return xp.ones(dims, dtype=dtype) -def fftfreq(n, d, dtype=DEFAULT_FLOAT_DTYPE, device=DEFAULT_DEVICE): - if xp != np: + +def ones_like(x): + """Create a one-filled array with same shape and dtype as input.""" + return xp.ones_like(x) + + +def fftfreq(n, d=1.0, dtype=None, device=None): + """Compute FFT frequency array.""" + if dtype is None: + dtype = DEFAULT_FLOAT_DTYPE + if device is None: + device = DEFAULT_DEVICE + if TORCH_BACKEND: return xp.fft.fftfreq(n, d, dtype=dtype, device=device) else: - return xp.fft.fftfreq(n, d, dtype=dtype) + return xp.fft.fftfreq(n, d).astype(dtype) + + +def fft2(x, **kwargs): + """2D FFT with kwarg conversion (dim/axis).""" + if TORCH_BACKEND and "axes" in kwargs: + kwargs["dim"] = kwargs.pop("axes") + if not TORCH_BACKEND and "dim" in kwargs: + kwargs["axis"] = kwargs.pop("dim") + return xp.fft.fft2(x, **kwargs) + + +def fft(x, **kwargs): + """1D FFT with kwarg conversion.""" + if TORCH_BACKEND and "axes" in kwargs: + kwargs["dim"] = kwargs.pop("axes") + if not TORCH_BACKEND and "dim" in kwargs: + kwargs["axis"] = kwargs.pop("dim") + return xp.fft.fft(x, **kwargs) + + +def ifft2(x, **kwargs): + """2D inverse FFT with kwarg conversion.""" + if TORCH_BACKEND and "axes" in kwargs: + kwargs["dim"] = kwargs.pop("axes") + if not TORCH_BACKEND and "dim" in kwargs: + kwargs["axis"] = kwargs.pop("dim") + return xp.fft.ifft2(x, **kwargs) + + +def fftshift(x, **kwargs): + """FFT shift with kwarg conversion.""" + if TORCH_BACKEND and "axes" in kwargs: + kwargs["dim"] = kwargs.pop("axes") + if not TORCH_BACKEND and "dim" in kwargs: + kwargs["axes"] = kwargs.pop("dim") + return xp.fft.fftshift(x, **kwargs) + + +def ifftshift(x, **kwargs): + """Inverse FFT shift with kwarg conversion.""" + if TORCH_BACKEND and "axes" in kwargs: + kwargs["dim"] = kwargs.pop("axes") + if not TORCH_BACKEND and "dim" in kwargs: + kwargs["axes"] = kwargs.pop("dim") + return xp.fft.ifftshift(x, **kwargs) + + +def meshgrid(*args, **kwargs): + """Create mesh grids.""" + return xp.meshgrid(*args, **kwargs) + + +def sqrt(x): + """Element-wise square root.""" + return xp.sqrt(x) -def expand_dims(ary,d): - if xp != np: - return xp.unsqueeze(ary,dim=d) - else: - return np.expand_dims(ary,d) def exp(x): + """Element-wise exponential.""" return xp.exp(x) def fft(k,**kwargs): @@ -222,27 +269,75 @@ def ifft2(k): return xp.fft.ifft2(k) def real(x): + """Take real part.""" return xp.real(x) -def amax(x): - return xp.amax(x) + +def cos(x): + """Element-wise cosine.""" + return xp.cos(x) + + +def arctan2(y, x): + """Element-wise arctangent of y/x.""" + return xp.arctan2(y, x) + def amin(x): + """Return minimum value.""" return xp.amin(x) + +def amax(x): + """Return maximum value.""" + return xp.amax(x) + + def sum(x, axis=None, **kwargs): - if xp != np and type(x) not in [ np.memmap, np.ndarray ]: + """Sum elements along axis with kwarg conversion.""" + if TORCH_BACKEND and type(x) not in [np.memmap, np.ndarray]: + if "axis" in kwargs: + kwargs["dim"] = kwargs.pop("axis") return xp.sum(x, dim=axis, **kwargs) else: + if "dim" in kwargs: + kwargs["axis"] = kwargs.pop("dim") return np.sum(x, axis=axis, **kwargs) + +def mean(x, axis=None, **kwargs): + """Mean of elements along axis with kwarg conversion.""" + is_torch = TORCH_BACKEND and type(x) not in [np.memmap, np.ndarray] + + if "keepdims" in kwargs and not is_torch: + kwargs["keepdims"] = kwargs.pop("keepdims") + elif "keepdims" in kwargs and is_torch: + kwargs["keepdim"] = kwargs.pop("keepdims") + + if "keepdim" in kwargs and not is_torch: + kwargs["keepdims"] = kwargs.pop("keepdim") + + if "axis" in kwargs and is_torch: + kwargs["dim"] = kwargs.pop("axis") + elif "dim" in kwargs and not is_torch: + kwargs["axis"] = kwargs.pop("dim") + + if is_torch: + return xp.mean(x, dim=axis, **kwargs) + else: + return np.mean(x, axis=axis, **kwargs) + + def any(x): + """Test whether any array elements along a given axis evaluate to True.""" return xp.any(x) + def einsum(subscripts, *operands, **kwargs): + """Einstein summation convention.""" #print([ (type(o),o.dtype) for o in operands]) numpytypes = [ type(o) in [np.ndarray, np.memmap] for o in operands ] - if xp != np and True not in numpytypes: + if TORCH_BACKEND and True not in numpytypes: return xp.einsum(subscripts, *operands, **kwargs) else: operands = [ to_cpu(o) for o in operands ] @@ -252,9 +347,53 @@ def to_cpu(array): if type(array) in [ np.ndarray, np.memmap ]: return array else: - return array.cpu().numpy() + if "dim" in kwargs: + kwargs["axis"] = kwargs.pop("dim") + return np.stack(arrays, axis=axis, **kwargs) + +# def to_cpu(x): +# """Convert tensor to CPU NumPy array.""" +# if isinstance(x, np.ndarray): +# return x +# if hasattr(x, 'cpu'): +# return x.cpu().numpy() +# if isinstance(x, (int, float, complex)): +# return x +# return np.asarray(x) + + +def reshape(x, shape): + """Reshape array.""" + if TORCH_BACKEND and type(x) == np.memmap: + return np.reshape(x, shape) + return xp.reshape(x, shape) + + +def expand_dims(x, axis): + """Expand array dimensions.""" + if TORCH_BACKEND: + return xp.unsqueeze(x, dim=axis) + else: + return np.expand_dims(x, axis) + + +def stack(arrays, axis=0, **kwargs): + """Stack arrays.""" + if TORCH_BACKEND: + if "axis" in kwargs: + kwargs["dim"] = kwargs.pop("axis") + return xp.stack(arrays, **kwargs) + else: + if "dim" in kwargs: + kwargs["axis"] = kwargs.pop("dim") + return np.stack(arrays, axis=axis, **kwargs) + + + + def isnan(x): + """Test element-wise for NaN.""" return xp.isnan(x) def midcrop(a,n): # e.g. unshifted ks: 0,1,2,3,4.....-4,-3,-,2-1, crop out 3 through -3, the inverse of a[n:-n] @@ -320,3 +459,28 @@ def chunkIDs(N,chunksize=1000): if i*chunksize >= N: break return chunks + + +def memmap(dims, dtype=None, filename=None): + """Create memory-mapped array.""" + if filename is None: + print("WARNING: memmap attempted without filename, falling back to zeros") + return zeros(dims, dtype=dtype) + + # Convert torch dtypes to numpy for memmap + if TORCH_BACKEND and dtype in [xp.complex128, xp.complex64, xp.float64, xp.float32]: + dtype_map = { + xp.complex128: np.complex128, + xp.complex64: np.complex64, + xp.float64: np.float64, + xp.float32: np.float32, + } + dtype = dtype_map[dtype] + + return np.memmap(filename, dtype=dtype, mode='w+', shape=dims) + + +# Keep legacy function for backward compatibility +def argwhere(condition): + """Return indices where condition is True.""" + return xp.argwhere(condition) From f3d075abbcde2697131b98099a7c19758ec5a890 Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Sun, 22 Mar 2026 21:07:14 -0700 Subject: [PATCH 05/14] Switching all modules to use the array backend --- pyproject.toml | 1 + src/pyslice/backend.py | 29 +- src/pyslice/multislice/calculators.py | 161 +++++------ src/pyslice/multislice/multislice.py | 300 ++++++++------------ src/pyslice/multislice/potentials.py | 305 +++++++------------- src/pyslice/multislice/potentials2.py | 346 ----------------------- src/pyslice/postprocessing/haadf_data.py | 22 -- src/pyslice/postprocessing/tacaw_data.py | 67 ++--- src/pyslice/postprocessing/wf_data.py | 97 +++---- 9 files changed, 376 insertions(+), 952 deletions(-) delete mode 100644 src/pyslice/multislice/potentials2.py diff --git a/pyproject.toml b/pyproject.toml index 6d12fbe..c9db556 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -21,6 +21,7 @@ dependencies = [ fast = ["torch","torchvision"] test = ["abtem>=1.0.6"] md = ["orb-models"] +fairchem = ["fairchem-core"] [project.urls] Homepage = "https://github.com/h-walk/PySlice" diff --git a/src/pyslice/backend.py b/src/pyslice/backend.py index 4d6864e..7bf1217 100644 --- a/src/pyslice/backend.py +++ b/src/pyslice/backend.py @@ -70,6 +70,7 @@ def device_and_precision(device_spec=None): float_dtype = DEFAULT_FLOAT_DTYPE complex_dtype = DEFAULT_COMPLEX_DTYPE +pi = xp.pi def asarray(arraylike, dtype=None, device=None): """Convert array-like object to backend array (NumPy or PyTorch tensor).""" @@ -77,8 +78,18 @@ def asarray(arraylike, dtype=None, device=None): dtype = DEFAULT_FLOAT_DTYPE if device is None: device = DEFAULT_DEVICE + # Handle complex to real casting + if dtype is not None and 'float' in str(dtype).lower() and hasattr(arraylike, 'dtype') and 'complex' in str(arraylike.dtype).lower(): + arraylike = arraylike.real if TORCH_BACKEND: - array = xp.tensor(arraylike, dtype=dtype, device=device) + if hasattr(arraylike, 'detach'): # it's already a tensor + array = arraylike.detach().clone() + if dtype is not None: + array = array.to(dtype) + if device is not None: + array = array.to(device) + else: + array = xp.tensor(arraylike, dtype=dtype, device=device) else: array = xp.asarray(arraylike, dtype=dtype) return array @@ -161,6 +172,7 @@ def fftfreq(n, d=1.0, dtype=None, device=None): if device is None: device = DEFAULT_DEVICE if TORCH_BACKEND: + print(device, dtype) return xp.fft.fftfreq(n, d, dtype=dtype, device=device) else: return xp.fft.fftfreq(n, d).astype(dtype) @@ -389,7 +401,22 @@ def stack(arrays, axis=0, **kwargs): return np.stack(arrays, axis=axis, **kwargs) +def roll(x, shift, axis): + """Roll array along axis.""" + if TORCH_BACKEND: + return xp.roll(x, shifts=shift, dims=axis) + else: + return np.roll(x, shift, axis=axis) + + +def log(x): + """Element-wise natural logarithm.""" + return xp.log(x) + +def angle(x): + """Element-wise angle of complex number.""" + return xp.angle(x) def isnan(x): diff --git a/src/pyslice/multislice/calculators.py b/src/pyslice/multislice/calculators.py index 661e3c3..9aa4e66 100644 --- a/src/pyslice/multislice/calculators.py +++ b/src/pyslice/multislice/calculators.py @@ -1,3 +1,4 @@ +import pyslice.backend as backend import numpy as np from pathlib import Path import logging @@ -5,38 +6,14 @@ from tqdm import tqdm import time,os import hashlib -#from line_profiler import profile - -try: - import torch ; xp = torch - TORCH_AVAILABLE = True - if torch.cuda.is_available(): - device = torch.device('cuda') - elif torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') - if device.type == 'mps': - complex_dtype = torch.complex64 - float_dtype = torch.float32 - else: - complex_dtype = torch.complex128 - float_dtype = torch.float64 - -except ImportError: - xp = np - TORCH_AVAILABLE = False - complex_dtype = np.complex128 - float_dtype = np.float64 - from .potentials import gridFromTrajectory,Potential from .multislice import Probe,PrismProbe,Propagate,create_batched_probes from .trajectory import Trajectory from ..postprocessing.wf_data import WFData from .sed import SED -from ..backend import zeros,expand_dims,to_cpu,memmap,ones,sum,absolute,ceil,einsum,asarray,astype +TORCH_BACKEND = backend.TORCH_BACKEND logger = logging.getLogger(__name__) class MultisliceCalculator: @@ -49,27 +26,16 @@ def __init__(self, device=None, force_cpu=False): device: PyTorch device ('cpu', 'cuda', 'mps', or None for auto-detection) force_cpu: Force CPU usage even if GPU is available """ - if not TORCH_AVAILABLE: - if device is not None: - logger.warning("PyTorch not available, falling back to NumPy implementation") - self.device = None - self.force_cpu = False + self.force_cpu = force_cpu + if force_cpu: + self.device = backend.device_and_precision('cpu')[0] + elif device is not None: + self.device = backend.device_and_precision(device)[0] else: - self.force_cpu = force_cpu - if force_cpu: - self.device = torch.device('cpu') - elif device is not None: - self.device = torch.device(device) - else: - # Auto-detect best available device: CUDA > MPS > CPU - if torch.cuda.is_available(): - self.device = torch.device('cuda') - elif torch.backends.mps.is_available(): - self.device = torch.device('mps') - else: - self.device = torch.device('cpu') + # Auto-detect best available device + self.device = backend.device_and_precision()[0] - logger.info(f"PyTorch calculator initialized on device: {self.device}") + logger.info(f"Calculator initialized on device: {self.device}") # Element mapping for display purposes self.element_map = { @@ -97,14 +63,14 @@ def _generate_cache_key(self, trajectory, aperture, voltage_eV, 'slice_thickness': slice_thickness, 'sampling': sampling, 'probe_positions': probe_positions, - 'backend': 'pytorch' if TORCH_AVAILABLE else 'numpy', + 'backend': 'torch' if backend.xp != np else 'numpy', } if spatial_decoherence is not None: params['spatial_decoherence'] = spatial_decoherence if temporal_decoherence is not None: params['temporal_decoherence'] = temporal_decoherence if probe_array is not None: - probe_np = np.ascontiguousarray(to_cpu(probe_array).ravel()[:1000]) + probe_np = np.ascontiguousarray(backend.to_cpu(probe_array).ravel()[:1000]) params['probe_hash'] = hashlib.md5(probe_np.tobytes()).hexdigest() param_str = str(sorted(params.items())) return hashlib.md5(param_str.encode()).hexdigest()[:12] @@ -185,19 +151,20 @@ def setup( self.nx = nx ; self.ny = ny ; self.nz = nz self.dx = xs[1]-xs[0] ; self.dy = ys[1]-ys[0] ; self.dy = ys[1]-ys[0] + self.probe_cropping = 0 if self.min_dk > 0: # dk = 1/L = 1/(nx*sampling) nx = int(np.round(1/(self.min_dk*self.sampling))) - self.nx = nx ; self.ny = nx + self.nx = nx ; self.ny = nx # Q: check this for non square super cells self.probe_cropping = nx - self.kxs = xp.fft.fftshift(xp.fft.fftfreq(self.nx, self.sampling)) # k-space in 1/Å - self.kys = xp.fft.fftshift(xp.fft.fftfreq(self.ny, self.sampling)) # k-space in 1/Å - kx_mask = xp.zeros(self.nx)+1 ; ky_mask = xp.zeros(self.ny)+1 + self.kxs = backend.fftshift(backend.fftfreq(self.nx, self.sampling)) # k-space in 1/Å + self.kys = backend.fftshift(backend.fftfreq(self.ny, self.sampling)) # k-space in 1/Å + kx_mask = backend.zeros(self.nx)+1 ; ky_mask = backend.zeros(self.ny)+1 kx_mask[ self.kxs < -max_kx ] = 0 ; kx_mask[ self.kxs > max_kx ] = 0 ky_mask[ self.kys < -max_ky ] = 0 ; ky_mask[ self.kys > max_ky ] = 0 - self.keep_kxs_indices = xp.arange(self.nx)[kx_mask==1][::self.kth] - self.keep_kys_indices = xp.arange(self.ny)[ky_mask==1][::self.kth] + self.keep_kxs_indices = backend.arange(self.nx)[kx_mask==1][::self.kth] + self.keep_kys_indices = backend.arange(self.ny)[ky_mask==1][::self.kth] self.nx = len(self.keep_kxs_indices) ; self.ny = len(self.keep_kys_indices) #print("kxs",len(self.kxs),"kys",len(self.kys),"nx",self.nx,"ny",self.ny,"keepkx",len(self.keep_kxs_indices),"keepky",len(self.keep_kys_indices)) @@ -233,16 +200,17 @@ def setup( #self.n_probes = len(self.base_probe.probe_positions) # Set dtype based on the actual device we're using - if TORCH_AVAILABLE and self.device is not None: - if self.device.type == 'mps': - self.complex_dtype = torch.complex64 - self.float_dtype = torch.float32 - else: - self.complex_dtype = torch.complex128 - self.float_dtype = torch.float64 - else: - self.complex_dtype = np.complex128 - self.float_dtype = np.float64 + _, self.float_dtype, self.complex_dtype = backend.device_and_precision(self.device) + + # cache key is calculated TWICE: once during setup (so the user only needs to setup to infer where their cache folder will go), and again during run (just in case the user does something funky) + # Generate cache key and setup output directory + self.cache_key = self._generate_cache_key(self.trajectory, self.aperture, self.voltage_eV, + self.slice_thickness, self.sampling, self.probe_positions, + self.base_probe.spatial_decoherence, self.base_probe.temporal_decoherence, + self.base_probe._array) + #print(cache_key) + self.output_dir = Path("psi_data/" + ("torch" if TORCH_AVAILABLE else "numpy") + "_"+self.cache_key) + #self.output_dir.mkdir(parents=True, exist_ok=True) # cache key is calculated TWICE: once during setup (so the user only needs to setup to infer where their cache folder will go), and again during run (just in case the user does something funky) # Generate cache key and setup output directory @@ -268,8 +236,8 @@ def preview_probes(self): potential.flatten() import matplotlib.pyplot as plt fig, ax = plt.subplots() - array = np.absolute(to_cpu(potential.array))[:,::-1,0].T # imshow convention: y,x. our convention: x,y, and flip y (0,0 upper-left) - xs = to_cpu(potential.xs) ; ys = to_cpu(potential.ys) + array = np.absolute(backend.to_cpu(potential.array))[:,::-1,0].T # imshow convention: y,x. our convention: x,y, and flip y (0,0 upper-left) + xs = backend.to_cpu(potential.xs) ; ys = backend.to_cpu(potential.ys) extent = (np.amin(xs),np.amax(xs),np.amin(ys),np.amax(ys)) #print(extent) ax.imshow(array, cmap="inferno", extent=extent) @@ -290,7 +258,7 @@ def run(self) -> WFData: if self.cache_key != cache_key: self.cache_key = cache_key #print(cache_key) - self.output_dir = Path("psi_data/" + ("torch" if TORCH_AVAILABLE else "numpy") + "_"+cache_key) + self.output_dir = Path("psi_data/" + ("torch" if backend.xp != np else "numpy") + "_"+cache_key) self.output_dir.mkdir(parents=True, exist_ok=True) @@ -321,11 +289,11 @@ def run(self) -> WFData: #if self.base_probe.cropping: # fd_nx = self.base_probe.cropping ; fd_ny = fd_nx if self.use_memmap: - self.wavefunction_data = memmap((fd_npt, self.n_frames, fd_nx, fd_ny, self.n_layers), - dtype=self.complex_dtype, filename = self.output_dir / "wdf_memmap.npy" ) + self.wavefunction_data = backend.memmap((fd_npt, self.n_frames, fd_nx, fd_ny, self.n_layers), + dtype=self.complex_dtype, filename = self.output_dir / "wdf_memmap.npy" ) else: - self.wavefunction_data = zeros((fd_npt, self.n_frames, fd_nx, fd_ny, self.n_layers), - dtype=self.complex_dtype, device=self.device) + self.wavefunction_data = backend.zeros((fd_npt, self.n_frames, fd_nx, fd_ny, self.n_layers), + dtype=self.complex_dtype, device=self.device) #print("wavefunction_data",self.wavefunction_data.shape) # Process frames with caching and multiprocessing @@ -334,8 +302,23 @@ def run(self) -> WFData: frames_cached = 0 # quality of life sanity checks: user may have set things (e.g. probe array) with the wrong data type (e.g. numpy instead of tensor). let's try to catch and correct those here - if isinstance(self.base_probe._array,np.ndarray) and TORCH_AVAILABLE: - self.base_probe._array = xp.tensor(self.base_probe._array) + if isinstance(self.base_probe._array,np.ndarray) and TORCH_BACKEND: + self.base_probe._array = backend.tensor(self.base_probe._array) + + if self.ADF: # create a dummy HAADFData object, first so we can hijack its getMask function, and later we'll load it up + kwargs = {} + if not isinstance(self.ADF,bool): + kwargs["inner_mrad"],kwargs["outer_mrad"] = self.ADF + from ..postprocessing.haadf_data import HAADFData + array = zeros((self.n_probes,1,1,1,1),dtype=self.complex_dtype) + array += xp.arange(self.n_probes)[:,None,None,None,None] # we'll use this as an index to map nth probe to the ADF grid coordinates i,j + wf = WFData(probe_positions=self.probe_positions,probe_xs=self.probe_xs,probe_ys=self.probe_ys, + time=None,kxs=self.kxs[self.keep_kxs_indices],kys=self.kys[self.keep_kys_indices],xs=self.xs,ys=self.ys, + layer=None,array=array,probe=self.base_probe,cache_dir=self.output_dir) + self.ADF = HAADFData(wf) + self.ADFmask = absolute(self.ADF.getMask(**kwargs)) # HAADFData infers mask dtype from _wf_array dtype, but we'll absolute^2 later + self.ADFindex = astype(absolute(self.ADF._wf_array[0,:,:,0,0,0,0]),int) + self.ADF._array = zeros(self.ADFindex.shape,dtype=self.complex_dtype) if self.ADF: # create a dummy HAADFData object, first so we can hijack its getMask function, and later we'll load it up kwargs = {} @@ -383,12 +366,12 @@ def run(self) -> WFData: self.ADF._array += intensities[self.ADFindex] if not os.path.exists(self.output_dir / f"kx.npy"): - np.save(self.output_dir / f"kx.npy",to_cpu(self.kxs[self.keep_kxs_indices])) - np.save(self.output_dir / f"ky.npy",to_cpu(self.kys[self.keep_kys_indices])) + np.save(self.output_dir / f"kx.npy",backend.to_cpu(self.kxs[self.keep_kxs_indices])) + np.save(self.output_dir / f"ky.npy",backend.to_cpu(self.kys[self.keep_kys_indices])) if len(self.kxs)!=self.nx and not os.path.exists(self.output_dir / f"kx_uncrop.npy"): - np.save(self.output_dir / f"kx_uncrop.npy",to_cpu(self.kxs)) + np.save(self.output_dir / f"kx_uncrop.npy",backend.to_cpu(self.kxs)) if len(self.kys)!=self.ny and not os.path.exists(self.output_dir / f"ky_uncrop.npy"): - np.save(self.output_dir / f"ky_uncrop.npy",to_cpu(self.kys)) + np.save(self.output_dir / f"ky_uncrop.npy",backend.to_cpu(self.kys)) if cache_exists: frames_cached += 1 @@ -411,9 +394,9 @@ def run(self) -> WFData: #if self.base_probe.cropping: # fd_nx = self.base_probe.cropping ; fd_ny = fd_nx # ceil(/self.kth) ; if self.use_memmap: - frame_data = memmap((n_waves, fd_nx, fd_ny, self.n_layers,1), dtype=self.complex_dtype, filename = cache_file ) + frame_data = backend.memmap((n_waves, fd_nx, fd_ny, self.n_layers,1), dtype=self.complex_dtype, filename = cache_file ) else: - frame_data = zeros((n_waves, fd_nx, fd_ny, self.n_layers,1), dtype=self.complex_dtype, device=self.device) + frame_data = backend.zeros((n_waves, fd_nx, fd_ny, self.n_layers,1), dtype=self.complex_dtype, device=self.device) #print("frame_data",frame_data.shape) #print("(done)",time.time()-start) @@ -424,10 +407,10 @@ def run(self) -> WFData: if self.loop_probes: chunksize = self.loop_probes if isinstance(self.loop_probes,int) else 1 for i in range(10000000): - chunk = xp.arange(i*chunksize,(i+1)*chunksize) + chunk = backend.arange(i*chunksize,(i+1)*chunksize) #chunk = chunk[chunknpt: break if len(chunk)==0: @@ -435,7 +418,7 @@ def run(self) -> WFData: chunks.append(chunk) pbar2 = tqdm(total = npt, desc = "looping probes", unit="probe") else: - chunks.append( xp.arange(npt) ) + chunks.append( backend.arange(npt) ) pbar2 = None #print("(done)",time.time()-start) @@ -451,22 +434,22 @@ def run(self) -> WFData: #print("(done)",time.time()-start) # expand out to fixed l,p,x,y indices - exit_waves_single = expand_dims(exit_waves_single,0) if len(exit_waves_single.shape)==3 else exit_waves_single + exit_waves_single = backend.expand_dims(exit_waves_single,0) if len(exit_waves_single.shape)==3 else exit_waves_single # FFT and load into frame_data kwarg = {"dim":(-2,-1)} if TORCH_AVAILABLE else {"axes":(-2,-1)} for layer_idx in range(self.n_layers): - exit_waves_k = xp.fft.fft2(exit_waves_single[layer_idx,:,:,:], **kwarg) # l,p,x,y --> p,x,y - diffraction_patterns = xp.fft.fftshift(exit_waves_k, **kwarg) + exit_waves_k = backend.fft2(exit_waves_single[layer_idx,:,:,:], **kwarg) # l,p,x,y --> p,x,y + diffraction_patterns = backend.fftshift(exit_waves_k, **kwarg) #if not self.prism: diffraction_patterns = diffraction_patterns[:,self.keep_kxs_indices,:][:,:,self.keep_kys_indices]*self.kth**2 if self.use_memmap: - diffraction_patterns = to_cpu(diffraction_patterns) - selected = to_cpu(selected) + diffraction_patterns = backend.to_cpu(diffraction_patterns) + selected = backend.to_cpu(selected) if self.store_full or self.prism: frame_data[selected,:,:,layer_idx,0] = diffraction_patterns # load p,x,y --> p,x,y,l,1 indices if self.ADF and not self.prism: #print(self.ADF._wf_array[0,:,:,0,0,0,0]) - intensities = einsum('pxy,xy->p',absolute(diffraction_patterns[:,:,:])**2,self.ADFmask) + intensities = backend.einsum('pxy,xy->p', backend.absolute(diffraction_patterns[:,:,:])**2,self.ADFmask) for i,pp in zip(intensities,selected): self.ADF._array[self.ADFindex==pp] += i if pbar2 is not None: @@ -499,7 +482,7 @@ def run(self) -> WFData: if not self.use_memmap and ( "exitwaves" in self.cache_levels or "slices" in self.cache_levels ) and (self.store_full or self.prism): # Convert to CPU numpy array for saving - frame_data_cpu = to_cpu(frame_data) + frame_data_cpu = backend.to_cpu(frame_data) np.save(cache_file, frame_data_cpu) frames_computed += 1 @@ -508,7 +491,7 @@ def run(self) -> WFData: cropped = frame_data[:,:,:,:,0] #print(cropped.shape) #if self.use_memmap: - # cropped = to_cpu(cropped) + # cropped = backend.to_cpu(cropped) if self.prism: # Recall: Prism algorithm passes a series of sinusoids through the sample (fourier components shared by all real-space probes), so now for each real-space probe, we need to calculate the exitwaves from components @@ -602,7 +585,7 @@ def checkCache(cache_file,cache_levels): if "cache_exists-"+parent not in logging_tracker: logging_tracker.append("cache_exists-"+parent) logging.warning("One or more frames reloaded from cache: "+str(cache_file.parent)) - return True,xp.asarray(np.load(cache_file)) # if always saving as numpy, then must cast to torch array if re-reading cache file back in + return True, backend.asarray(np.load(cache_file)) # if always saving as numpy, then must cast to torch array if re-reading cache file back in return False,0 diff --git a/src/pyslice/multislice/multislice.py b/src/pyslice/multislice/multislice.py index 28be8fe..16a46ca 100644 --- a/src/pyslice/multislice/multislice.py +++ b/src/pyslice/multislice/multislice.py @@ -1,32 +1,9 @@ +import pyslice.backend as backend import numpy as np from tqdm import tqdm -import logging,time -from ..backend import zeros,mean,ones,to_cpu,asarray,absolute,sum,reshape,midcrop,einsum,ceil,clone -#from line_profiler import profile - -try: - import torch ; xp = torch - TORCH_AVAILABLE = True - if torch.cuda.is_available(): - device = torch.device('cuda') - elif torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') - if device.type == 'mps': - complex_dtype = torch.complex64 - float_dtype = torch.float32 - else: - complex_dtype = torch.complex128 - float_dtype = torch.float64 -except ImportError: - TORCH_AVAILABLE = False - xp = np - print("PyTorch not available, falling back to NumPy") - complex_dtype = np.complex128 - float_dtype = np.float64 - +import logging, time +TORCH_BACKEND = backend.TORCH_BACKEND logger = logging.getLogger(__name__) @@ -37,23 +14,20 @@ def antialias_aperture(kxs, kys, cutoff_fraction=2/3, taper_width=0.02): taper to avoid ringing from a hard cutoff. Returns a 2D real-valued array (1 inside, tapers to 0 outside). """ - kx_max = xp.amax(xp.abs(kxs)) - ky_max = xp.amax(xp.abs(kys)) + kx_max = backend.amax(backend.absolute(kxs)) + ky_max = backend.amax(backend.absolute(kys)) k_max = min(float(kx_max), float(ky_max)) # Nyquist = 1/(2*sampling) k_cutoff = cutoff_fraction * k_max - kx_grid, ky_grid = xp.meshgrid(kxs, kys, indexing='ij') - k_r = xp.sqrt(kx_grid**2 + ky_grid**2) + kx_grid, ky_grid = backend.meshgrid(kxs, kys, indexing='ij') + k_r = backend.sqrt(kx_grid**2 + ky_grid**2) # Smooth cosine taper from (k_cutoff - taper) to k_cutoff, strictly zero above k_cutoff taper = taper_width * k_max - aperture = xp.ones_like(k_r) + aperture = backend.ones_like(k_r) mask_taper = (k_r > k_cutoff - taper) & (k_r < k_cutoff) mask_outer = k_r >= k_cutoff - if TORCH_AVAILABLE and hasattr(k_r, 'device'): - aperture[mask_taper] = 0.5 * (1 + torch.cos(torch.pi * (k_r[mask_taper] - k_cutoff + taper) / taper)) - else: - aperture[mask_taper] = 0.5 * (1 + np.cos(np.pi * (k_r[mask_taper] - k_cutoff + taper) / taper)) + aperture[mask_taper] = 0.5 * (1 + backend.cos(backend.pi * (k_r[mask_taper] - k_cutoff + taper) / taper)) aperture[mask_outer] = 0.0 return aperture @@ -76,17 +50,21 @@ def m_effective(eV): def wavelength(eV): """ Compute relativistic electron wavelength in Angstroms. - - Uses float64 for intermediate calculations to avoid underflow on MPS/float32. - The term m_electron * c_light^2 can underflow in float32 if computed in wrong order. + + Converts constants to backend arrays for device consistency. + Uses higher precision intermediates to avoid underflow. """ - # Convert to numpy float64 for calculation, then convert back if needed - if TORCH_AVAILABLE and isinstance(eV, torch.Tensor): - eV_np = eV.detach().cpu().numpy().astype(np.float64) - lam_np = h_planck * c_light / ((eV_np * q_electron)**2 + 2 * eV_np * q_electron * m_electron * c_light**2)**0.5 * 1e10 - return torch.tensor(lam_np, dtype=eV.dtype, device=eV.device) - else: - return h_planck * c_light / ((eV * q_electron)**2 + 2 * eV * q_electron * m_electron * c_light**2)**0.5 * 1e10 + # Convert inputs and constants to backend arrays on the appropriate device + eV_joules = backend.asarray(eV, dtype=backend.float_dtype) * backend.asarray(q_electron, dtype=backend.float_dtype) + m_c2 = backend.asarray(m_electron * c_light**2, dtype=backend.float_dtype) + h_c = backend.asarray(h_planck * c_light, dtype=backend.float_dtype) + + # Correct relativistic formula: sqrt(E^2 + 2 E m c^2) + momentum = backend.sqrt(eV_joules**2 + 2 * eV_joules * m_c2) + lam = h_c / momentum * 1e10 # Convert to Angstroms + + return lam + class Probe: """ @@ -107,40 +85,15 @@ def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, pre device: PyTorch device (None for auto-detection) """ # TORCH DEVICES AND DTYPES - if TORCH_AVAILABLE: - # Auto-detect device if not specified (same logic as Potential class) - if device is None: - if torch.cuda.is_available(): - device = torch.device('cuda') - elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') - elif isinstance(device, str): - device = torch.device(device) - self.device = device - self.use_torch = True - - # Use float32 for MPS compatibility (same as Potential class) - self.dtype = torch.float32 if device.type == 'mps' else torch.float64 - self.complex_dtype = torch.complex64 if device.type == 'mps' else torch.complex128 - else: - if device is not None: - raise ImportError("PyTorch not available. Please install PyTorch.") - self.device = None - self.use_torch = False - self.dtype = np.float64 - self.complex_dtype = np.complex128 + device, float_dtype, complex_dtype = backend.device_and_precision(device) + self.device = device + self.dtype = float_dtype + self.complex_dtype = complex_dtype # SET UP SPATIAL GRIDS # Convert coordinate arrays to tensors if using torch (same as Potential class) - if self.use_torch: - # Use as_tensor to avoid copy warning when input is already a tensor - self.xs = torch.as_tensor(xs, dtype=self.dtype, device=self.device) - self.ys = torch.as_tensor(ys, dtype=self.dtype, device=self.device) - else: - self.xs = xs - self.ys = ys + self.xs = backend.asarray(xs, dtype=self.dtype, device=self.device) + self.ys = backend.asarray(ys, dtype=self.dtype, device=self.device) nx = len(xs) ; ny = len(ys) dx = xs[1] - xs[0] ; dy = ys[1] - ys[0] @@ -169,16 +122,14 @@ def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, pre # n = 1 if array is None else len(array) # eV = [ eV ]*n self.eV = eV ; self.wavelength=wavelength(eV) - self.eVs = np.asarray([eV]) - if self.use_torch: - self.eVs = torch.as_tensor(self.eVs, dtype=self.dtype, device=self.device) + self.eVs = backend.asarray([eV], dtype=self.dtype, device=self.device) self.wavelengths = wavelength(self.eVs) self.temporal_decoherence = None self.spatial_decoherence = None self.gaussianVOA = gaussianVOA # Set up device kwargs for unified xp interface (same as Potential class) - device_kwargs = {'device': self.device, 'dtype': self.dtype} if self.use_torch else {} + device_kwargs = {'device': self.device, 'dtype': self.dtype} self.stay_reciprocal = stay_reciprocal self.crop_reciprocal = crop_reciprocal @@ -186,19 +137,19 @@ def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, pre # self.crop_reciprocal = (min(nx,ny)-self.crop_reciprocal)//2 # so we need to chop 125 off each side - self.kxs = xp.fft.fftfreq(nx, d=dx, **device_kwargs) - self.kys = xp.fft.fftfreq(ny, d=dy, **device_kwargs) + self.kxs = backend.fftfreq(nx, d=dx, **device_kwargs) + self.kys = backend.fftfreq(ny, d=dy, **device_kwargs) if not array is None: # Allow construction of a Probe object with a passed array instead of building it below. used by create_batched_probes - if self.use_torch and hasattr(array, 'to'): + if backend.TORCH_BACKEND and hasattr(array, 'to'): self._array = array.to(device=self.device, dtype=self.complex_dtype) else: - self._array = xp.asarray(array) + self._array = backend.asarray(array, dtype=self.complex_dtype, device=self.device) else: #self._array = zeros((len(self.eV),1,nx,ny)) #for i,w in enumerate(self.wavelength): # self._array[i,0,:,:] = self.generate_single_probe(mrad,w,gaussianVOA,preview=preview) - #self._array = zeros((1,1,nx,ny),dtype=complex_dtype) + #self._array = backend.zeros((1,1,nx,ny), dtype=self.complex_dtype, device=self.device) self._array= self.generate_single_probe(mrad,self.wavelength,self.gaussianVOA,preview=preview)[None,None,:,:]*ones((1,1), device=self.device)[:,:,None,None] self.cropping = cropping @@ -220,13 +171,12 @@ def generate_single_probe(self,mrad,wavelength,gaussianVOA,preview=False): nx,ny = len(kxs) , len(kys) if mrad == 0: - return zeros((nx, ny), device=self.device)+1 + return backend.zeros((nx, ny), device=self.device, dtype=self.complex_dtype, device=self.device)+1 + reciprocal = backend.zeros((nx, ny), dtype=self.complex_dtype, device=self.device) radius = (mrad * 1e-3) / wavelength # Convert mrad to reciprocal space units - - reciprocal = zeros((nx, ny), device=self.device) - kx_grid, ky_grid = xp.meshgrid(kxs, kys, indexing='ij') # unshifted kx ky: 0,1,2,3,....-3,-2,-1 - radii = xp.sqrt(kx_grid**2 + ky_grid**2) + kx_grid, ky_grid = backend.meshgrid(kxs, kys, indexing='ij') # unshifted kx ky: 0,1,2,3,....-3,-2,-1 + radii = backend.sqrt(kx_grid**2 + ky_grid**2) if gaussianVOA == 0: mask = radii < radius @@ -238,8 +188,8 @@ def generate_single_probe(self,mrad,wavelength,gaussianVOA,preview=False): if preview: import matplotlib.pyplot as plt fig, ax = plt.subplots() ; print(radius) - extent = (xp.min(self.kxs), xp.max(self.kxs), xp.min(self.kys), xp.max(self.kys)) - ax.imshow(xp.fft.fftshift(reciprocal.T), cmap="inferno",extent=extent) # shift to visualize with k=0 in the center + extent = (backend.amin(self.kxs), backend.amax(self.kxs), backend.amin(self.kys), backend.amax(self.kys)) + ax.imshow(backend.fft.fftshift(reciprocal.T), cmap="inferno",extent=extent) # shift to visualize with k=0 in the center ax.set_xlabel("kx ($\\AA^{-1}$)") ax.set_ylabel("ky ($\\AA^{-1}$)") plt.show() @@ -247,7 +197,7 @@ def generate_single_probe(self,mrad,wavelength,gaussianVOA,preview=False): if self.stay_reciprocal: # if we would've done a real-space shift, we should apply a phase ramp in reciprocal space return reciprocal * xp.exp(-2j * xp.pi * kxs[:, None] * self.lx/2 ) * xp.exp(-2j * xp.pi * kys[None, :] * self.ly/2 ) - return xp.fft.ifftshift(xp.fft.ifft2(reciprocal)) # iFFT --> realspace --> shift --> zero in the center + return backend.ifftshift(backend.ifft2(reciprocal)) # iFFT --> realspace --> shift --> zero in the center #self.array_numpy = self.array.cpu().numpy() def copy(self,selected_probes=None): @@ -288,23 +238,16 @@ def to_cpu(self): def to_device(self, device): """Move probe to specified device (similar to Potential.to_device).""" - if not self.use_torch: - raise RuntimeError("to_device() requires PyTorch") - - # MPS doesn't support float64 - if hasattr(device, 'type') and device.type == 'mps': - dtype, complex_dtype = torch.float32, torch.complex64 - else: - dtype, complex_dtype = torch.float64, torch.complex128 + device, float_dtype, complex_dtype = backend.device_and_precision(device) self._array = self._array.to(device=device, dtype=complex_dtype) - self.xs = self.xs.to(device=device, dtype=dtype) - self.ys = self.ys.to(device=device, dtype=dtype) - self.kxs = self.kxs.to(device=device, dtype=dtype) - self.kys = self.kys.to(device=device, dtype=dtype) + self.xs = self.xs.to(device=device, dtype=float_dtype) + self.ys = self.ys.to(device=device, dtype=float_dtype) + self.kxs = self.kxs.to(device=device, dtype=float_dtype) + self.kys = self.kys.to(device=device, dtype=float_dtype) self.device = device - self.dtype = dtype + self.dtype = float_dtype self.complex_dtype = complex_dtype return self @@ -312,15 +255,15 @@ def plot(self,filename=None,title=None): import matplotlib.pyplot as plt fig, ax = plt.subplots() # calling self.array should convert to CPU/numpy - array = np.mean(np.absolute(self.array[:,:,::-1,:]),axis=1)[0,:,:] # positional,summable,x,y indices + array = backend.mean(backend.absolute(self.array[:,:,::-1,:]),axis=1)[0,:,:] # positional,summable,x,y indices array=array.T # imshow convention: y,x. our convention: x,y - plot_array = np.absolute(array)**.25 + plot_array = backend.absolute(array)**.25 # Convert extent values to CPU if needed (use xp for torch/numpy compatibility) - xs_min = xp.amin(self.xs) - xs_max = xp.amax(self.xs) # TODO technically this should be xs[-1]+dx?? - ys_min = xp.amin(self.ys) - ys_max = xp.amax(self.ys) + xs_min = backend.amin(self.xs) + xs_max = backend.amax(self.xs) # TODO technically this should be xs[-1]+dx?? + ys_min = backend.amin(self.ys) + ys_max = backend.amax(self.ys) if hasattr(xs_min, 'cpu'): xs_min = xs_min.cpu() @@ -342,12 +285,12 @@ def plot(self,filename=None,title=None): def defocus(self,dz): # POSITIVE DEFOCUS PUTS BEAM WAIST ABOVE SAMPLE, UNITS OF ANGSTROM if isinstance(dz,(int,float)): - dz = zeros(len(self._array), device=self.device)+dz - kx_grid, ky_grid = xp.meshgrid(self.kxs, self.kys, indexing='ij') + dz = backend.zeros(len(self._array), device=self.device)+dz + kx_grid, ky_grid = backend.meshgrid(self.kxs, self.kys, indexing='ij') k_squared = kx_grid**2 + ky_grid**2 - P = xp.exp(-1j * xp.pi * self.wavelength * dz[:,None,None] * k_squared[None,:,:]) + P = backend.exp(-1j * backend.pi * self.wavelength * dz[:,None,None] * k_squared[None,:,:]) nz = len(dz) ; nc,npt,nx,ny = self._array.shape #; print("nc,npt,nx,ny",nc,npt,nx,ny) - self._array = xp.fft.ifft2( P[:,None,None,:,:] * xp.fft.fft2( self._array )[None,:,:,:,:] ) + self._array = backend.ifft2( P[:,None,None,:,:] * backend.fft2( self._array )[None,:,:,:,:] ) self._array = self._array.reshape((nz*nc,npt,nx,ny)) #print("defocus",dz,"new shape",self._array.shape) @@ -362,11 +305,10 @@ def addTemporalDecoherence(self,sigma_eV,N): self.temporal_decoherence = (sigma_eV,N) eV = self.eV self.eVs = np.linspace(eV-2*sigma_eV,eV+2*sigma_eV,N) - if self.use_torch: - self.eVs = torch.as_tensor(self.eVs, dtype=self.dtype, device=self.device) + self.eVs = backend.asarray(self.eVs, dtype=self.dtype, device=self.device) self.wavelengths = wavelength(self.eVs) - amplitudes = np.exp(-(eV-self.eVs)**2/sigma_eV**2) - self._array = zeros((N,1,nx,ny), device=self.device) + amplitudes = backend.exp(-(eV-self.eVs)**2/sigma_eV**2) + self._array = backend.zeros((N,1,nx,ny), device=self.device) for n,eV in enumerate(self.eVs): self._array[n,0,:,:] = amplitudes[n] * self.generate_single_probe(self.mrad,wavelength(eV),self.gaussianVOA) nc,npt,nx,ny = self._array.shape #; print("addTemporalDecoherence expands to",nc,npt,nx,ny) @@ -382,18 +324,18 @@ def addSpatialDecoherence(self,sigma_dz,N): print("WARNING: calling addSpatialDecoherence twice will overwrite previous") self.spatial_decoherence = (sigma_dz,N) dzs = np.linspace(-2*sigma_dz,2*sigma_dz,N) # suppose N=25 - amplitudes = np.exp(-dzs**2/sigma_dz**2) + amplitudes = backend.exp(-dzs**2/sigma_dz**2) nc,npt,nx,ny = self._array.shape # suppose nc=10 (addTemporalDecoherence created 10 wavelengths) if self.use_torch: - dzs = torch.as_tensor(dzs, dtype=self.dtype, device=self.device) + dzs = backend.asarray(dzs, dtype=self.dtype, device=self.device) self.defocus(dzs) # defocus starts with 25,10,npt,nx,ny --reshapes--> 250,npt,nx,ny for i in range(N): # reshape to flatten loops first index last: [[0,1],[2,3]] --> [0,1,2,3] for j in range(nc): self._array[i*nc+j] *= amplitudes[i] nc,npt,nx,ny = self._array.shape #; print("addSpatialDecoherence expands to",nc,npt,nx,ny) - self.eVs = ones(N, device=self.device)[:,None]*self.eVs[None,:] # defocus expands into nz,nc then flattens to nz*nc + self.eVs = backend.ones(N, device=self.device)[:,None]*self.eVs[None,:] # defocus expands into nz,nc then flattens to nz*nc self.eVs = self.eVs.reshape(nc) - self.wavelengths = ones(N, device=self.device)[:,None]*self.wavelengths[None,:] + self.wavelengths = backend.ones(N, device=self.device)[:,None]*self.wavelengths[None,:] self.wavelengths = self.wavelengths.reshape(nc) if npt==1: self.applyShifts() @@ -407,9 +349,9 @@ def applyShifts(self): if self.cropping: i1=nx//2-self.cropping//2 ; i2=i1+self.cropping # |_______i1___.___i2_______| for initial centered probe at lx/2,ly/2 j1=ny//2-self.cropping//2 ; j2=j1+self.cropping - self._array = self._array[:,0,None,i1:i2,j1:j2] * ones(len(self.probe_positions), device=self.device)[None,:,None,None] + self._array = self._array[:,0,None,i1:i2,j1:j2] * backend.ones(len(self.probe_positions), device=self.device)[None,:,None,None] else: - self._array = self._array[:,0,None,:,:] * ones(len(self.probe_positions), device=self.device)[None,:,None,None] + self._array = self._array[:,0,None,:,:] * backend.ones(len(self.probe_positions), device=self.device)[None,:,None,None] # loop through probe positions for i, (px,py) in enumerate(self.probe_positions): if px-self.lx/2 == 0 and py-self.ly/2 == 0: @@ -425,9 +367,9 @@ def placeProbe(self,array,x,y): if self.cropping: i1=self.nx//2-self.cropping//2 ; i2=i1+self.cropping # |_______i1___.___i2_______| for initial centered probe at lx/2,ly/2 j1=self.ny//2-self.cropping//2 ; j2=j1+self.cropping - device_kwargs = {'device': self.device, 'dtype': self.dtype} if self.use_torch else {} - kxs = xp.fft.fftfreq(self.cropping, d=self.dx, **device_kwargs) - kys = xp.fft.fftfreq(self.cropping, d=self.dy, **device_kwargs) + device_kwargs = {'device': self.device, 'dtype': self.dtype} + kxs = backend.fftfreq(self.cropping, d=self.dx, **device_kwargs) + kys = backend.fftfreq(self.cropping, d=self.dy, **device_kwargs) dpx = dx//self.dx ; dpy = dy//self.dy # pixel shifts offset_x = i1+dpx ; offset_y = j1+dpy dx-=dpx*self.dx ; dy-=dpy*self.dy # update subpixel shifts @@ -439,16 +381,16 @@ def placeProbe(self,array,x,y): kxs,kys=self.kxs,self.kys offset_x = 0 ; offset_y=0 if not self.stay_reciprocal: - probe_k = xp.fft.fft2(array) # positional,summable,x,y + probe_k = backend.fft2(array) # positional,summable,x,y else: probe_k = array - kx_shift = xp.exp(-2j * xp.pi * kxs[None,:, None] * dx ) - ky_shift = xp.exp(-2j * xp.pi * kys[None,None, :] * dy ) + kx_shift = backend.exp(-2j * backend.pi * kxs[None,:, None] * dx ) + ky_shift = backend.exp(-2j * backend.pi * kys[None,None, :] * dy ) probe_k_shifted = probe_k * kx_shift * ky_shift if self.stay_reciprocal: return probe_k_shifted,(offset_x,offset_y) - return xp.fft.ifft2(probe_k_shifted),(offset_x,offset_y) + return backend.ifft2(probe_k_shifted),(offset_x,offset_y) def aberrate(self,aberrations): @@ -457,9 +399,9 @@ def aberrate(self,aberrations): # self.array = xp.fft.ifftshift(xp.fft.ifft2(reciprocal)) # Aberrations are defined at the aperture plane, so we must apply them in reciprocal space. # (or do a convolution in real-space) - reciprocal = xp.fft.fft2(xp.fft.fftshift(self._array)) # centered-real --> zero at corner --> FFT --> kx,ky zero at corner + reciprocal = backend.fft2(backend.fftshift(self._array)) # centered-real --> zero at corner --> FFT --> kx,ky zero at corner reciprocal *= dP - self._array = xp.fft.ifftshift(xp.fft.ifft2(reciprocal)) + self._array = backend.ifftshift(backend.ifft2(reciprocal)) # See Kirkland Eq 2.10: # χ(k,ϕ) = π/2 Cs λ³ k⁴ - π Δf λ k² @@ -492,18 +434,18 @@ def aberrate(self,aberrations): # Aberrations are an adjustment to the phase of the wave ("dPhi"), to be applied in reciprocal space. # this is done by multiplying the complex wave (be it a probe or an exit wave) by xp.exp(-1j * dPhi) def aberrationFunction(kxs,kys,wavelength,aberrations): # aberrations should be a dict of Cnm following https://abtem.readthedocs.io/en/latest/user_guide/walkthrough/contrast_transfer_function.html - dPhi = xp.zeros_like(kxs[:,None] * kys[None,:]) - ks = xp.sqrt( kxs[:,None]**2 + kys[None,:]**2 ) # unshifted: 0,1,2,3,...-3,-2,-1, reciprocal origin at corner - theta = xp.arctan2( kys[None,:] , kxs[:,None] ) + dPhi = backend.zeros_like(kxs[:,None] * kys[None,:]) + ks = backend.sqrt( kxs[:,None]**2 + kys[None,:]**2 ) # unshifted: 0,1,2,3,...-3,-2,-1, reciprocal origin at corner + theta = backend.arctan2( kys[None,:] , kxs[:,None] ) for k in aberrations.keys(): n,m = int(k[1]),int(k[2]) # C03 --> 0,3 C = aberrations[k] ; phi0 = 0 if not isinstance(C,(int,float)): C,phi0 = C - dPhi += 2*xp.pi/wavelength * \ + dPhi += 2*np.pi/wavelength * \ (1/(n+1)) * C * ( ks * wavelength ) ** (n+1) * \ - xp.cos( m * (theta-phi0) ) - return xp.exp(-1j * dPhi) + backend.cos( m * (theta-phi0) ) + return backend.exp(-1j * dPhi) #def probe_grid(xlims,ylims,n,m): # x,y=np.meshgrid(np.linspace(*xlims,n),np.linspace(*ylims,m)) @@ -523,7 +465,8 @@ def create_batched_probes(base_probe, probe_positions, device=None): probe object with an array of shape (n_probes, nx, ny) """ # Move probe to correct device if needed - if device is not None and TORCH_AVAILABLE: + if device is not None: + device, _, _ = backend.device_and_precision(device) # Always move to ensure array is actually on the device # (checking base_probe.device may not reflect actual array device) base_probe.to_device(device) @@ -535,7 +478,7 @@ def create_batched_probes(base_probe, probe_positions, device=None): ny = len(base_probe.ys) # Compute dx, dy on same device as probe - if TORCH_AVAILABLE and hasattr(base_probe.xs, 'device'): + if hasattr(base_probe.xs, 'device'): dx = (base_probe.xs[1] - base_probe.xs[0]).item() dy = (base_probe.ys[1] - base_probe.ys[0]).item() else: @@ -546,22 +489,19 @@ def create_batched_probes(base_probe, probe_positions, device=None): for px, py in probe_positions: # Create shifted probe using phase ramp in k-space - probe_k = xp.fft.fft2(base_probe._array) + probe_k = backend.fft2(base_probe._array) # Apply phase ramp for spatial shift (negative sign = shift right) - kx_shift = xp.exp(-2j * xp.pi * base_probe.kxs[:, None] * (px-lx/2) ) - ky_shift = xp.exp(-2j * xp.pi * base_probe.kys[None, :] * (py-ly/2) ) + kx_shift = backend.exp(-2j * backend.pi * base_probe.kxs[:, None] * (px-lx/2) ) + ky_shift = backend.exp(-2j * backend.pi * base_probe.kys[None, :] * (py-ly/2) ) probe_k_shifted = probe_k * kx_shift * ky_shift # Convert back to real space - shifted_probe_array = xp.fft.ifft2(probe_k_shifted) + shifted_probe_array = backend.ifft2(probe_k_shifted) probe_arrays.append(shifted_probe_array) # Stack into batch tensor - if TORCH_AVAILABLE: - array = torch.stack(probe_arrays, dim=0) - else: - array = xp.asarray(probe_arrays) + array = backend.stack(probe_arrays, axis=0) return Probe(base_probe.xs, base_probe.ys, base_probe.mrad, base_probe.eV, array=array, device=base_probe.device) @@ -785,7 +725,7 @@ def Propagate(probe, potential, device=None, progress=False, onthefly=True, stor If store_all_slices=True, shape is (n_slices, n_probes, nx, ny) Otherwise, shape is (n_probes, nx, ny) or (nx, ny) for single probe """ - if device is not None and not TORCH_AVAILABLE: + if device is not None and not backend.TORCH_BACKEND: raise ImportError("PyTorch not available. Please install PyTorch.") if device is None and hasattr(probe, 'device'): device = probe.device @@ -793,14 +733,14 @@ def Propagate(probe, potential, device=None, progress=False, onthefly=True, stor # Initialize wavefunction with probe(s) - shape: (n_probes, nx, ny) nc,npt,nx,ny = probe._array.shape #; print("nc,npt,nx,ny",nc,npt,nx,ny) array = probe._array.reshape((nc*npt,nx,ny)) # "flatten" first two indices - probe_wavelengths = probe.wavelengths[:,None]*ones(npt, device=device)[None,:] # also expand wavelengths and eVs arrays to cover all probe positions npt + probe_wavelengths = probe.wavelengths[:,None]*backend.ones(npt, device=device)[None,:] # also expand wavelengths and eVs arrays to cover all probe positions npt probe_wavelengths = probe_wavelengths.reshape(nc*npt) - probe_eVs = probe.eVs[:,None]*ones(npt, device=device)[None,:] + probe_eVs = probe.eVs[:,None]*backend.ones(npt, device=device)[None,:] probe_eVs = probe_eVs.reshape(nc*npt) # Calculate interaction parameter (Kirkland Eq 5.6) E0_eV = m_electron * c_light**2 / q_electron - sigma = (2 * np.pi) / (probe_wavelengths * probe_eVs) * \ + sigma = (2 * backend.pi) / (probe_wavelengths * probe_eVs) * \ (E0_eV + probe_eVs) / (2 * E0_eV + probe_eVs) # wavelength and eVs now have length of n_probes #print("propagate sigma",sigma) #if TORCH_AVAILABLE: @@ -814,17 +754,17 @@ def Propagate(probe, potential, device=None, progress=False, onthefly=True, stor # All tensors should already be on the correct device from creation kx,ky = potential.kxs, potential.kys if probe.cropping: - device_kwargs = {'device': probe.device, 'dtype': probe.dtype} if probe.use_torch else {} - kx = xp.fft.fftfreq(probe.cropping, d=probe.dx, **device_kwargs) - ky = xp.fft.fftfreq(probe.cropping, d=probe.dy, **device_kwargs) - kx_grid, ky_grid = xp.meshgrid(kx, ky, indexing='ij') + device_kwargs = {'device': probe.device, 'dtype': probe.dtype} + kx = backend.fftfreq(probe.cropping, d=probe.dx, **device_kwargs) + ky = backend.fftfreq(probe.cropping, d=probe.dy, **device_kwargs) + kx_grid, ky_grid = backend.meshgrid(kx, ky, indexing='ij') k_squared = kx_grid**2 + ky_grid**2 # Precompute 2/3 Nyquist anti-aliasing aperture for bandwidth-limiting transmission functions aa_aperture = antialias_aperture(kx, ky) # Fold anti-aliasing aperture into propagator to bandwidth-limit wavefunction at every slice - P = xp.exp(-1j * xp.pi * probe_wavelengths[:,None,None] * dz * k_squared[None,:,:]) * aa_aperture[None,:,:] # Kirkland2010 Eq 6.65 + P = backend.exp(-1j * backend.pi * probe_wavelengths[:,None,None] * dz * k_squared[None,:,:]) * aa_aperture[None,:,:] # Kirkland2010 Eq 6.65 #print("(done)",time.time()-start) @@ -873,17 +813,17 @@ def localtqdm(iterator): # yi = xp.roll(yr,-o[1])[:probe.cropping] # pot_stack[p] = potential_slice[xi,:][:,yi] # full indexing is even faster - xi = xp.zeros((len(sigma),probe.cropping),dtype=int) ; yi = xp.zeros((len(sigma),probe.cropping),dtype=int) - xr = xp.arange(nx) ; yr = xp.arange(ny) + xi = xp.zeros((len(sigma),probe.cropping),dtype=int) ; yi = backend.zeros((len(sigma),probe.cropping),dtype=int) + xr = xp.arange(nx) ; yr = backend.arange(ny) for p,(x,y) in enumerate(probe.offsets): - xi[p,:] = xp.roll(xr,-x)[:probe.cropping] - yi[p,:] = xp.roll(yr,-y)[:probe.cropping] + xi[p,:] = backend.roll(xr,-x)[:probe.cropping] + yi[p,:] = backend.roll(yr,-y)[:probe.cropping] pot_stack=potential_slice[xi[:,:,None],yi[:,None,:]] #print("(done)",time.time()-start) - t=xp.exp(1j*sigma[:,None,None]*pot_stack) + t = backend.exp(1j*sigma[:,None,None]*pot_stack) else: - t = xp.exp(1j * sigma[:,None,None] * potential_slice[None,:,:]) # Kirkland2010 Eq 6.59. n,x,y indices + t = backend.exp(1j * sigma[:,None,None] * potential_slice[None,:,:]) # Kirkland2010 Eq 6.59. n,x,y indices # Apply transmission to all probes: ψ' = t × ψ # Broadcasting: t[n_probes,nx,ny] * array[n_probes,nx,ny] = array[n_probes,nx,ny] @@ -892,27 +832,27 @@ def localtqdm(iterator): # Store wavefunction at this slice if requested (after transmission) if store_all_slices: # Clone/copy to avoid reference issues - slice_wavefunctions.append(clone(array)) + if hasattr(array, 'clone'): + slice_wavefunctions.append(array.clone()) + else: + slice_wavefunctions.append(array.copy()) # Fresnel propagation to next slice (except for last slice) if z < len(potential.zs) - 1: # Vectorized FFT over spatial dimensions for all probes - kwarg = {"dim":(-2,-1)} if TORCH_AVAILABLE else {"axes":(-2,-1)} + kwarg = {"dim":(-2,-1)} if TORCH_BACKEND else {"axes":(-2,-1)} #print(kwarg,array.dtype,array.shape) #print("FFT / multiply / iFFT") ; start = time.time() - fft_array = xp.fft.fft2(array, **kwarg) + fft_array = backend.fft2(array, **kwarg) propagated_fft = P * fft_array - array = xp.fft.ifft2(propagated_fft, **kwarg) + array = backend.ifft2(propagated_fft, **kwarg) #print("(done)",time.time()-start) # Return results based on what was requested if store_all_slices: # Stack the list into a tensor with slices as a new dimension # Shape will be (n_slices, n_probes, nx, ny) - more conventional ordering - if TORCH_AVAILABLE: - return torch.stack(slice_wavefunctions, dim=0) - else: - return xp.stack(slice_wavefunctions, axis=0) + return backend.stack(slice_wavefunctions, axis=0) #array = array.reshape((nc,npt,nx,ny)) @@ -955,17 +895,17 @@ def calculateObject(probe,exitwave,guessedObject,weighting=.5,dz=0.5,damping=.01 # Pre-compute propagation operator in k-space (Fresnel propagation) # All tensors should already be on the correct device from creation - kx_grid, ky_grid = xp.meshgrid(probe.kxs, probe.kys, indexing='ij') # TODO use probe.kxs instead, to free ourselves of the need to pass a potential + kx_grid, ky_grid = backend.meshgrid(probe.kxs, probe.kys, indexing='ij') # TODO use probe.kxs instead, to free ourselves of the need to pass a potential k_squared = kx_grid**2 + ky_grid**2 - P = xp.exp(-1j * xp.pi * lamda * dz * k_squared[:,:]) # P in Kirkland2010 Eq 6.65 is exp(-i...), so to divide by P, we can use Pp, exp(+j...) + P = backend.exp(-1j * backend.pi * lamda * dz * k_squared[:,:]) # P in Kirkland2010 Eq 6.65 is exp(-i...), so to divide by P, we can use Pp, exp(+j...) # t = ℱ⁻¹[ ℱ[ ψ₂ ]/P ]/ψ₁ - t = xp.fft.ifft2(xp.fft.fft2(exitwave)/P)/psi1 + t = backend.ifft2(backend.fft2(exitwave)/P)/psi1 # t = exp(i σ O) --> O = log(t)/i/σ - O = xp.log(t)/1j/sigma + O = backend.log(t)/1j/sigma # WHAT IS exp(i σ O) REALLY DOING? exp(iϕ) is a sinusoid. an only-real object is applying a phase shift? can we do calculate an angle instead? - O = xp.angle(t)/sigma + O = backend.angle(t)/sigma # consider: # instead of division, should i multiply by complex conjugate? (not technically the same, but it will deal with near-zeros) # instead of log, should i use: https://en.wikipedia.org/wiki/Complex_logarithm#Calculating_the_principal_value @@ -980,7 +920,7 @@ def calculateObject(probe,exitwave,guessedObject,weighting=.5,dz=0.5,damping=.01 delta=(O-asarray(guessedObject)) # probe amplitude masking function: zeros-out points where probe intensity is zero, without giving probe features as features in your potential - delta*=xp.absolute(psi1)/(xp.absolute(psi1)+damping*xp.amax(xp.absolute(psi1))) + delta*=backend.absolute(psi1)/(backend.absolute(psi1)+damping*backend.amax(backend.absolute(psi1))) return delta*weighting diff --git a/src/pyslice/multislice/potentials.py b/src/pyslice/multislice/potentials.py index 0ed216f..390fed1 100644 --- a/src/pyslice/multislice/potentials.py +++ b/src/pyslice/multislice/potentials.py @@ -1,70 +1,33 @@ +import pyslice.backend as backend import numpy as np from pathlib import Path import logging,os from tqdm import tqdm -from ..backend import to_cpu,mean - -try: - import torch ; xp = torch - TORCH_AVAILABLE = True - if torch.cuda.is_available(): - device = torch.device('cuda') - elif torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') - if device.type == 'mps': # Use float32 for MPS (doesn't support float64), float64 for CPU/CUDA - complex_dtype = torch.complex64 - float_dtype = torch.float32 - else: - complex_dtype = xp.complex128 - float_dtype = xp.float64 - - -except ImportError: - TORCH_AVAILABLE = False - import numpy as np ; xp = np - print("PyTorch not available, falling back to NumPy") - device=None - complex_dtype = xp.complex128 - float_dtype = xp.float64 - #np.fft._fft=np.fft.fft # ALIASING IS TERRIBLE. THIS BLOCK, FOR EXAMPLE, THROWS A PSYCHO "postprocessing/tacaw_data.py", line 96, in fft_from_wf_data \n wf_fft = xp.fft.fft(wf_layer - wf_mean[:,None,:,:], axis=1) \n TypeError: fft() got an unexpected keyword argument 'axis'" BECAUSE WHEN WE ALIASED THE FUNCTION WE FAILED TO PREDICT ALL THE KWARGS WE MIGHT USE ELSEWHERE IN THE CODE - #def fft(ary,device): - # return np.fft._fft(ary) - #xp.fft.fft=fft - #np._zeros=np.zeros - #def zeros(tup,dtype=float_dtype,device=None): - # return np._zeros(tup,dtype=dtype) - #xp.zeros=zeros - #np._sum=np.sum - #def sum(ary,dim=None,axis=None): # WATCH OUT: imports apply throughout: if we alias a kwarg, then the calling function might still expect to find the unaliased kwarg - # if axis is not None: - # return np._sum(ary,axis=axis) - # return np._sum(ary,axis=dim) - #np.sum=sum +import importlib.resources as resources +import pyslice.data + +kirkland_file = resources.files('pyslice.data').joinpath('kirkland.txt') logger = logging.getLogger(__name__) # Global storage for Kirkland parameters on GPU - store per device -kirklandABCDs = [] +kirklandABCDs = None + def kirkland(qsq, Z): """ GPU-accelerated Kirkland structure factor calculation using PyTorch. Args: - if device is not None and not TORCH_AVAILABLE: - raise ImportError("PyTorch not available. Please install PyTorch.") - -: |q|² tensor in units of (1/Angstrom)² - Z: Atomic number (or element name string) - device: PyTorch device ('cpu' or 'cuda') + qsq: |q|² tensor in units of (1/Angstrom)² + Z: Atomic number (or element name string) + device: PyTorch device ('cpu' or 'cuda') Returns: Form factor tensor with same shape as qsq """ global kirklandABCDs - if len(kirklandABCDs)==0: + if kirklandABCDs is None: # Get device from qsq tensor if it's a PyTorch tensor if hasattr(qsq, 'device'): loadKirkland(qsq.device) @@ -73,7 +36,7 @@ def kirkland(qsq, Z): else: # Move kirklandABCDs to match qsq device if needed if hasattr(qsq, 'device') and hasattr(kirklandABCDs, 'device'): - if qsq.device != kirklandABCDs.device: + if not qsq.device == kirklandABCDs.device: kirklandABCDs = kirklandABCDs.to(qsq.device) if isinstance(Z, str): @@ -93,11 +56,10 @@ def kirkland(qsq, Z): c_expanded = c[:, None, None] d_expanded = d[:, None, None] qsq_expanded = qsq[None, :, :] - - kwarg = {"dim":0} if TORCH_AVAILABLE else {"axis":0} - term1 = xp.sum(a_expanded / (qsq_expanded + b_expanded), **kwarg) - term2 = xp.sum(c_expanded * xp.exp(-d_expanded * qsq_expanded), **kwarg) - + + term1 = backend.sum(a_expanded / (qsq_expanded + b_expanded), axis=0) + term2 = backend.sum(c_expanded * backend.exp(-d_expanded * qsq_expanded), axis=0) + return term1 + term2 def getZfromElementName(element): @@ -140,30 +102,9 @@ def loadKirkland(device='cpu'): """Load Kirkland parameters from kirkland.txt file and move to GPU.""" global kirklandABCDs - # Convert device to string for dictionary key - device_key = str(device) - - # Try to find kirkland.txt in the project directory - kirkland_file = None - search_paths = [ - 'kirkland.txt', - '../kirkland.txt', - '../../kirkland.txt', - Path(__file__).parent.parent.parent / 'kirkland.txt', - Path(__file__).parent.parent / 'data/kirkland.txt' # relative path from potentials.py to data folder? i think this is the *right* place for kirkland.txt, not at the root of PySlice... - ] - - for path in search_paths: - if Path(path).exists(): - kirkland_file = str(path) - break - - if kirkland_file is None: - raise FileNotFoundError("Could not find kirkland.txt file") - # Parse Kirkland parameters kirkland_params = [] - + for i in range(103): # Elements 1-103 rows = (i * 4 + 1, i * 4 + 5) # Skip header, read 3 lines try: @@ -181,58 +122,24 @@ def loadKirkland(device='cpu'): kirkland_params.append([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]) # Convert to appropriate tensor format with device handling - if TORCH_AVAILABLE: - # Use float32 for MPS compatibility (Apple Silicon doesn't support float64) - if isinstance(device, str): - device = torch.device(device) - dtype = torch.float32 if device.type == 'mps' else torch.float64 - kirklandABCDs = torch.tensor(kirkland_params, dtype=dtype, device=device) - else: - kirklandABCDs = np.asarray(kirkland_params) + device, float_dtype, _ = backend.device_and_precision(device) + kirklandABCDs = backend.asarray(kirkland_params, dtype=float_dtype, device=device) + -class Potential: - def __init__(self, xs, ys, zs, positions=None, atomTypes=None, array=None, kind="kirkland", device=None, slice_axis=2, progress=False, cache_dir=None, frame_idx=None): +class Potential: + def __init__(self, xs, ys, zs, positions, atomTypes, kind="kirkland", device=None, slice_axis=2, progress=False, cache_dir=None, frame_idx=None): # Set up device and backend first - if TORCH_AVAILABLE: - # Auto-detect device if not specified - if device is None: - if torch.cuda.is_available(): - device = torch.device('cuda') - elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') - elif isinstance(device, str): - device = torch.device(device) - - self.device = device - self.use_torch = True + device, float_dtype, complex_dtype = backend.device_and_precision(device) - # Use float32 for MPS compatibility (Apple Silicon doesn't support float64) - self.dtype = torch.float32 if device.type == 'mps' else torch.float64 - self.complex_dtype = torch.complex64 if device.type == 'mps' else torch.complex128 - - # Convert inputs to PyTorch tensors on device - self.xs = torch.tensor(xs, dtype=self.dtype, device=device) - self.ys = torch.tensor(ys, dtype=self.dtype, device=device) - self.zs = torch.tensor(zs, dtype=self.dtype, device=device) - if positions is not None: - positions = torch.tensor(positions, dtype=self.dtype, device=device) - if array is not None: - self._array = torch.tensor(array, device=device) - else: - self._array = None - else: - if device is not None: - raise ImportError("PyTorch not available. Please install PyTorch.") - self.device = None - self.use_torch = False - self.dtype = np.float64 - self.complex_dtype = np.complex128 - self.xs = xs - self.ys = ys - self.zs = zs - self._array = array + self.device = device + self.float_dtype = float_dtype + self.complex_dtype = complex_dtype + + positions = backend.asarray(positions, dtype=self.float_dtype, device=self.device) + + self.xs = backend.asarray(xs, dtype=self.float_dtype, device=self.device) + self.ys = backend.asarray(ys, dtype=self.float_dtype, device=self.device) + self.zs = backend.asarray(zs, dtype=self.float_dtype, device=self.device) self.nx = len(xs) self.ny = len(ys) @@ -256,57 +163,46 @@ def __init__(self, xs, ys, zs, positions=None, atomTypes=None, array=None, kind= self.slice_spacing = spacings[slice_axis] self.n_slices = len(self.slice_coords) - # Set up device kwargs for unified xp interface - device_kwargs = {'device': self.device, 'dtype': self.dtype} if self.use_torch else {} - - # Set up k-space frequencies using xp with conditional device - self.kxs = xp.fft.fftfreq(self.nx, d=self.dx, **device_kwargs) - self.kys = xp.fft.fftfreq(self.ny, d=self.dy, **device_kwargs) + # Set up k-space frequencies + self.kxs = backend.fftfreq(self.nx, d=self.dx, dtype=float_dtype, device=device) + self.kys = backend.fftfreq(self.ny, d=self.dy, dtype=float_dtype, device=device) qsq = self.kxs[:, None]**2 + self.kys[None, :]**2 - + # Convert atom types to atomic numbers if needed - if atomTypes is not None: - unique_atom_types = set(atomTypes) - atomic_numbers = [] - for at in atomTypes: + unique_atom_types = set(atomTypes) + atomic_numbers = [] + for at in atomTypes: + if isinstance(at, str): + atomic_numbers.append(getZfromElementName(at)) + else: + atomic_numbers.append(at) + atomic_numbers = backend.asarray(atomic_numbers, dtype=int, device=device) + + # OPTIMIZATION 1: Compute form factors once per atom type on GPU + form_factors = {} + for at in unique_atom_types: + if kind == "kirkland": if isinstance(at, str): - atomic_numbers.append(getZfromElementName(at)) + Z = getZfromElementName(at) else: - atomic_numbers.append(at) - if TORCH_AVAILABLE: - atomic_numbers = torch.tensor(atomic_numbers, device=device) - - # OPTIMIZATION 1: Compute form factors once per atom type on GPU - form_factors = {} - for at in unique_atom_types: - if kind == "kirkland": - if isinstance(at, str): - Z = getZfromElementName(at) - else: - Z = at - form_factors[at] = kirkland(qsq, Z) - elif kind == "gauss": - form_factors[at] = torch.exp(-1**2 * qsq / 2) + Z = at + form_factors[at] = kirkland(qsq, Z) + elif kind == "gauss": + form_factors[at] = backend.exp(-1**2 * qsq / 2) self.cache_dir = cache_dir self.frame_idx = frame_idx def calculateSlice(slice_idx): - if self._array is not None: - return self._array[:,:,slice_idx] # check for caching cache_file = None if self.cache_dir is not None: cache_file = self.cache_dir / ("potential_"+str(frame_idx)+"_"+str(slice_idx)+".npy") if cache_file is not None and os.path.exists(cache_file): - Z = np.load(cache_file) - if TORCH_AVAILABLE: - return xp.from_numpy(Z).to(device) - return Z + return np.load(cache_file) - # Initialize slice of potential array using xp with conditional device - device_kwargs = {'device': self.device } if self.use_torch else {} - reciprocal = xp.zeros((self.nx, self.ny), dtype=self.complex_dtype, **device_kwargs) + # Initialize slice of potential array + reciprocal = backend.zeros((self.nx, self.ny), dtype=complex_dtype, device=device) # Process each atom type separately (reuse form factors) for at in unique_atom_types: @@ -314,13 +210,11 @@ def calculateSlice(slice_idx): # OPTIMIZATION 2: Vectorized atom type masking on GPU if isinstance(at, str): - type_mask=[atom_type == at for atom_type in atomTypes] - if TORCH_AVAILABLE: - type_mask = torch.tensor(type_mask, - dtype=torch.bool, device=device) + type_mask = [atom_type == at for atom_type in atomTypes] + type_mask = backend.asarray(type_mask, dtype=bool, device=device) else: type_mask = (atomic_numbers == at) - + # OPTIMIZATION 3: Batch process all slices for this atom type along the specified axis # Create slice masks for all slices at once slice_coords = positions[type_mask, slice_axis] # Get coordinates along slice axis for this atom type @@ -334,39 +228,40 @@ def calculateSlice(slice_idx): spatial_mask = (slice_coords >= slice_min) & (slice_coords < slice_max) - if not xp.any(spatial_mask): - continue #return xp.zeros((len(self.kxs),len(self.kys))) + if not backend.any(spatial_mask): + continue # Get positions for atoms in this slice and type type_positions = positions[type_mask] slice_positions = type_positions[spatial_mask] if len(slice_positions) == 0: - continue #return xp.zeros((len(self.kxs),len(self.kys))) + continue atomsx = slice_positions[:, self.inplane_axis1] atomsy = slice_positions[:, self.inplane_axis2] # TODO i'm hard-coding the chunk size is 2000 atoms per layer which is HUGE, so this shouldn't affect anyone but me, but we really ought to do a "smarter" job of picking the chunk size chunk_indices = list(np.arange(len(atomsx)))[::2000]+[len(atomsx)] - shape_factor = xp.zeros( (self.nx,self.ny) , dtype=self.complex_dtype, **device_kwargs ) + shape_factor = backend.zeros((self.nx,self.ny), dtype=self.self.complex_dtype, **device_kwargs) + for i1,i2 in zip(chunk_indices[:-1],chunk_indices[1:]): atx = atomsx[i1:i2] aty = atomsy[i1:i2] # Compute structure factors - match NumPy pattern exactly # exp(2 i pi (kx * x + ky * y) ) = exp(2 i pi kx x) * exp(2 i pi ky y), summed over all atoms (hence einsum below) - expx = xp.exp(-1j * 2 * np.pi * self.kxs[None, :] * atx[:, None]) - expy = xp.exp(-1j * 2 * np.pi * self.kys[None, :] * aty[:, None]) - + + expx = backend.exp(-1.j * 2 * np.pi * self.kxs[None, :] * atx[:, None]) + expy = backend.exp(-1.j * 2 * np.pi * self.kys[None, :] * aty[:, None]) + # Einstein summation - match NumPy - kwarg={True:{},False:{"optimize":True}}[TORCH_AVAILABLE] - shape_factor += xp.einsum('ax,ay->xy', expx, expy, **kwarg) + shape_factor += backend.einsum('ax,ay->xy', expx, expy) reciprocal += shape_factor * form_factor - real = xp.fft.ifft2(reciprocal) - real = xp.real(real) + real = backend.ifft2(reciprocal) + real = backend.real(real) # Convert from electron scattering factor f_e to projected potential V_proj. # Kirkland Eq C.1: f_e(q) = (m_e/2πℏ²) FT[V], so FT[V] = (2πℏ²/m_e) f_e. # On discrete grid: V(r) = (1/A) Σ_k FT[V](k) exp(2πi k·r) @@ -377,22 +272,22 @@ def calculateSlice(slice_idx): fe_to_V = 47.87764737 # 2πℏ²/m_e in V·Å² (Kirkland, Eq C.1 prefactor) Z = real * fe_to_V / (dx * dy) if cache_file is not None: - if TORCH_AVAILABLE and hasattr(Z, 'cpu'): - Z_cpu = Z.cpu().numpy() - else: - Z_cpu = Z - np.save(cache_file, Z_cpu) + np.save(cache_file,Z) return Z self.calculateSlice = calculateSlice - #self._array = None + self.array = None def build(self,progress=False): if self._array is not None: return - # Initialize potential array using xp with conditional device - device_kwargs = {'device': self.device } if self.use_torch else {} - potential_real = xp.zeros((self.nx, self.ny, self.n_slices), dtype=self.dtype, **device_kwargs) + + # Initialize potential array + potential_real = backend.zeros( + (self.nx, self.ny, self.n_slices), + dtype=self.self.dtype, + device=self.device, + ) if progress: localtqdm = tqdm @@ -406,20 +301,12 @@ def localtqdm(iterator): potential_real[:, :, slice_idx] += self.calculateSlice(slice_idx) # Store tensor version for potential GPU operations - self._array = potential_real - - def flatten(self): - self._array = mean(self._array,axis=2,keepdims=True) - self.nz = 1 - self.zs=self.zs[:1] - - @property - def array(self): - return to_cpu(self._array) - + self.array = potential_real + def to_cpu(self): - return to_cpu(self._array) - + """Convert tensors back to CPU NumPy arrays.""" + return backend.to_cpu(self.array) + def to_device(self, device): """Move tensor data to specified device.""" if hasattr(self, 'array_torch'): @@ -427,22 +314,24 @@ def to_device(self, device): self.device = device return self - def plot(self,filename=None): - if self._array is None: + def plot(self,filename=""): + if self.array is None: self.build() import matplotlib.pyplot as plt fig, ax = plt.subplots() - array = np.sum(np.absolute(self.array),axis=2).T[::-1,:] # imshow convention: y,x. our convention: x,y, and flip y (0,0 upper-left) + array = backend.sum( + backend.absolute(self.array), + axis=2).T # imshow convention: y,x. our convention: x,y # Convert to CPU if on GPU/MPS device - #if hasattr(array, 'cpu'): - # array = array.cpu() + if hasattr(array, 'cpu'): + array = array.cpu() # Convert extent values to CPU if needed - xs_min = xp.amin(self.xs) - xs_max = xp.amax(self.xs) - ys_min = xp.amin(self.ys) - ys_max = xp.amax(self.ys) + xs_min = backend.amin(self.xs) + xs_max = backend.amax(self.xs) + ys_min = backend.amin(self.ys) + ys_max = backend.amax(self.ys) if hasattr(xs_min, 'cpu'): xs_min = xs_min.cpu() diff --git a/src/pyslice/multislice/potentials2.py b/src/pyslice/multislice/potentials2.py deleted file mode 100644 index c552a23..0000000 --- a/src/pyslice/multislice/potentials2.py +++ /dev/null @@ -1,346 +0,0 @@ -import pyslice.backend as backend -import numpy as np -from pathlib import Path -import logging,os -from tqdm import tqdm -import importlib.resources as resources -import pyslice.data - -kirkland_file = resources.files('pyslice.data').joinpath('kirkland.txt') - -logger = logging.getLogger(__name__) - -# Global storage for Kirkland parameters on GPU - store per device -kirklandABCDs = None - -def kirkland(qsq, Z): - """ - GPU-accelerated Kirkland structure factor calculation using PyTorch. - - Args: - qsq: |q|² tensor in units of (1/Angstrom)² - Z: Atomic number (or element name string) - device: PyTorch device ('cpu' or 'cuda') - - Returns: - Form factor tensor with same shape as qsq - """ - global kirklandABCDs - - if kirklandABCDs is None: - # Get device from qsq tensor if it's a PyTorch tensor - if hasattr(qsq, 'device'): - loadKirkland(qsq.device) - else: - loadKirkland() - else: - if hasattr(qsq, 'device') and hasattr(kirklandABCDs, 'device'): - if not qsq.device == kirklandABCDs.device: - kirklandABCDs = kirklandABCDs.to(qsq.device) - - if isinstance(Z, str): - Z = getZfromElementName(Z) - Z -= 1 # Convert to 0-based indexing - - # Grab columns for a,b,c,d parameters - already on correct device - ABCDs = kirklandABCDs[Z, :, :] - a = ABCDs[:, 0] - b = ABCDs[:, 1] - c = ABCDs[:, 2] - d = ABCDs[:, 3] - - # Vectorized computation on GPU - a_expanded = a[:, None, None] - b_expanded = b[:, None, None] - c_expanded = c[:, None, None] - d_expanded = d[:, None, None] - qsq_expanded = qsq[None, :, :] - - term1 = backend.sum(a_expanded / (qsq_expanded + b_expanded), axis=0) - term2 = backend.sum(c_expanded * backend.exp(-d_expanded * qsq_expanded), axis=0) - - return term1 + term2 - -def getZfromElementName(element): - """Return atomic number (Z) from element name.""" - elements = ["H", "He", - "Li", "Be", "B", "C", "N", "O", "F", "Ne", - "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", - "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr", - "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe", - "Cs", "Ba", - "La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", - "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Ti", "Pb", "Bi", "Po", "At", "Rn", - "Fr", "Ra", - "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", - "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn", "Nh", "Fl", "Mc", "Lv", "Ts", "Og"] - return elements.index(element) + 1 - -def gridFromTrajectory(trajectory,sampling=0.1,slice_thickness=0.5): - # Use box matrix diagonal elements for orthogonal simulation cells - box_matrix = trajectory.box_matrix - - # Extract box dimensions from diagonal elements (assuming orthogonal box) - lx = box_matrix[0, 0] # X dimension - ly = box_matrix[1, 1] # Y dimension - lz = box_matrix[2, 2] # Z dimension - - # Create grids based on sampling - nx = int(lx / sampling) + 1 - ny = int(ly / sampling) + 1 - nz = int(lz / slice_thickness) + 1 - - xs = np.linspace(0, lx, nx, endpoint=False) - ys = np.linspace(0, ly, ny, endpoint=False) - zs = np.linspace(0, lz, nz, endpoint=False) - - return xs,ys,zs,lx,ly,lz - - -def loadKirkland(device='cpu'): - """Load Kirkland parameters from kirkland.txt file and move to GPU.""" - global kirklandABCDs - - # Parse Kirkland parameters - kirkland_params = [] - - for i in range(103): # Elements 1-103 - rows = (i * 4 + 1, i * 4 + 5) # Skip header, read 3 lines - try: - abcd = np.loadtxt(kirkland_file, skiprows=rows[0], max_rows=3) - # ORDERING IS: (Kirkland page 291) - # a1 b1 a2 b2 - # a3 b4 c1 d1 - # c2 d2 c3 d3 - a1, b1, a2, b2, a3, b3, c1, d1, c2, d2, c3, d3 = abcd.flat - # reorder so four columns are a,b,c,d - abcd = [[a1, b1, c1, d1], [a2, b2, c2, d2], [a3, b3, c3, d3]] - kirkland_params.append(abcd) - except Exception as e: - # Fill with zeros if parameters not available - kirkland_params.append([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]) - - # Convert to appropriate tensor format with device handling - device, float_dtype, _ = backend.device_and_precision(device) - kirklandABCDs = backend.asarray(kirkland_params, dtype=float_dtype, device=device) - - -class Potential: - def __init__(self, xs, ys, zs, positions, atomTypes, kind="kirkland", device=None, slice_axis=2, progress=False, cache_dir=None, frame_idx=None): - # Set up device and backend first - device, float_dtype, complex_dtype = backend.device_and_precision(device) - - self.device = device - self.float_dtype = float_dtype - self.complex_dtype = complex_dtype - - positions = backend.asarray(positions, dtype=self.float_dtype, device=self.device) - - self.xs = backend.asarray(xs, dtype=self.float_dtype, device=self.device) - self.ys = backend.asarray(ys, dtype=self.float_dtype, device=self.device) - self.zs = backend.asarray(zs, dtype=self.float_dtype, device=self.device) - - self.nx = len(xs) - self.ny = len(ys) - self.nz = len(zs) - self.dx = xs[1] - xs[0] - self.dy = ys[1] - ys[0] - self.dz = zs[1] - zs[0] if self.nz > 1 else 0.5 - - # Store slice axis for later use - self.slice_axis = slice_axis - - # Determine in-plane axes based on slice axis - all_axes = [0, 1, 2] - all_axes.remove(slice_axis) - self.inplane_axis1, self.inplane_axis2 = all_axes - - # Store coordinate arrays and spacing for the slice axis - coord_arrays = [xs, ys, zs] - spacings = [self.dx, self.dy, self.dz] - self.slice_coords = coord_arrays[slice_axis] - self.slice_spacing = spacings[slice_axis] - self.n_slices = len(self.slice_coords) - - # Set up k-space frequencies - self.kxs = backend.fftfreq(self.nx, d=self.dx, dtype=float_dtype, device=device) - self.kys = backend.fftfreq(self.ny, d=self.dy, dtype=float_dtype, device=device) - qsq = self.kxs[:, None]**2 + self.kys[None, :]**2 - - # Convert atom types to atomic numbers if needed - unique_atom_types = set(atomTypes) - atomic_numbers = [] - for at in atomTypes: - if isinstance(at, str): - atomic_numbers.append(getZfromElementName(at)) - else: - atomic_numbers.append(at) - atomic_numbers = backend.asarray(atomic_numbers, dtype=int, device=device) - - # OPTIMIZATION 1: Compute form factors once per atom type on GPU - form_factors = {} - for at in unique_atom_types: - if kind == "kirkland": - if isinstance(at, str): - Z = getZfromElementName(at) - else: - Z = at - form_factors[at] = kirkland(qsq, Z) - elif kind == "gauss": - form_factors[at] = backend.exp(-1**2 * qsq / 2) - - self.cache_dir = cache_dir - self.frame_idx = frame_idx - - def calculateSlice(slice_idx): - # check for caching - cache_file = None - if self.cache_dir is not None: - cache_file = self.cache_dir / ("potential_"+str(frame_idx)+"_"+str(slice_idx)+".npy") - if cache_file is not None and os.path.exists(cache_file): - return np.load(cache_file) - - # Initialize slice of potential array - reciprocal = backend.zeros((self.nx, self.ny), dtype=complex_dtype, device=device) - - # Process each atom type separately (reuse form factors) - for at in unique_atom_types: - form_factor = form_factors[at] - - # OPTIMIZATION 2: Vectorized atom type masking on GPU - if isinstance(at, str): - type_mask = [atom_type == at for atom_type in atomTypes] - type_mask = backend.asarray(type_mask, dtype=bool, device=device) - else: - type_mask = (atomic_numbers == at) - - # OPTIMIZATION 3: Batch process all slices for this atom type along the specified axis - # Create slice masks for all slices at once - slice_coords = positions[type_mask, slice_axis] # Get coordinates along slice axis for this atom type - - if len(slice_coords) == 0: - continue - - # Vectorized spatial masking using correct slice coordinates - slice_min = self.slice_coords[slice_idx] - self.slice_spacing/2 if slice_idx > 0 else 0 - slice_max = self.slice_coords[slice_idx] + self.slice_spacing/2 if slice_idx < self.n_slices-1 else self.slice_coords[-1] + self.slice_spacing - - spatial_mask = (slice_coords >= slice_min) & (slice_coords < slice_max) - - if not backend.any(spatial_mask): - continue - - # Get positions for atoms in this slice and type - type_positions = positions[type_mask] - slice_positions = type_positions[spatial_mask] - - if len(slice_positions) == 0: - continue - - atomsx = slice_positions[:, self.inplane_axis1] - atomsy = slice_positions[:, self.inplane_axis2] - - # TODO i'm hard-coding the chunk size is 2000 atoms per layer which is HUGE, so this shouldn't affect anyone but me, but we really ought to do a "smarter" job of picking the chunk size - chunk_indices = list(np.arange(len(atomsx)))[::2000]+[len(atomsx)] - shape_factor = backend.zeros((self.nx,self.ny), dtype=self.complex_dtype, device=self.device) - - for i1,i2 in zip(chunk_indices[:-1],chunk_indices[1:]): - atx = atomsx[i1:i2] - aty = atomsy[i1:i2] - - # Compute structure factors - match NumPy pattern exactly - # exp(2 i pi (kx * x + ky * y) ) = exp(2 i pi kx x) * exp(2 i pi ky y), summed over all atoms (hence einsum below) - - expx = backend.exp(-1.j * 2 * np.pi * self.kxs[None, :] * atx[:, None]) - expy = backend.exp(-1.j * 2 * np.pi * self.kys[None, :] * aty[:, None]) - - # Einstein summation - match NumPy - shape_factor += backend.einsum('ax,ay->xy', expx, expy) - - reciprocal += shape_factor * form_factor - - real = backend.ifft2(reciprocal) - real = backend.real(real) - # Convert from electron scattering factor f_e to projected potential V_proj. - # Kirkland Eq C.1: f_e(q) = (m_e/2πℏ²) FT[V], so FT[V] = (2πℏ²/m_e) f_e. - # On discrete grid: V(r) = (2πℏ²/m_e) / (dx·dy) × ifft2(S · f_e) - dx = self.xs[1] - self.xs[0] - dy = self.ys[1] - self.ys[0] - fe_to_V = 47.87764737 # 2πℏ²/m_e in V·Å² (Kirkland, Eq C.1 prefactor) - Z = real * fe_to_V / (dx * dy) - if cache_file is not None: - np.save(cache_file,Z) - return Z - - self.calculateSlice = calculateSlice - self.array = None - - def build(self,progress=False): - - # Initialize potential array - potential_real = backend.zeros( - (self.nx, self.ny, self.n_slices), - dtype=self.float_dtype, - device=self.device, - ) - - if progress: - localtqdm = tqdm - print("generating potential for slices") - else: - def localtqdm(iterator): - return iterator - - # cycle through layers generating reciprocal slice - for slice_idx in localtqdm(range(self.n_slices)): - potential_real[:, :, slice_idx] += self.calculateSlice(slice_idx) - - # Store tensor version for potential GPU operations - self.array = potential_real - - def to_cpu(self): - """Convert tensors back to CPU NumPy arrays.""" - return backend.to_cpu(self.array) - - def to_device(self, device): - """Move tensor data to specified device.""" - if hasattr(self, 'array_torch'): - self.array_torch = self.array_torch.to(device) - self.device = device - return self - - def plot(self,filename=""): - if self.array is None: - self.build() - - import matplotlib.pyplot as plt - fig, ax = plt.subplots() - array = backend.sum( - backend.absolute(self.array), - axis=2).T # imshow convention: y,x. our convention: x,y - # Convert to CPU if on GPU/MPS device - if hasattr(array, 'cpu'): - array = array.cpu() - - # Convert extent values to CPU if needed - xs_min = backend.amin(self.xs) - xs_max = backend.amax(self.xs) - ys_min = backend.amin(self.ys) - ys_max = backend.amax(self.ys) - - if hasattr(xs_min, 'cpu'): - xs_min = xs_min.cpu() - xs_max = xs_max.cpu() - ys_min = ys_min.cpu() - ys_max = ys_max.cpu() - - extent = (xs_min, xs_max, ys_min, ys_max) - ax.imshow(array, cmap="inferno", extent=extent) - ax.set_xlabel("x ($\\AA$)") - ax.set_ylabel("y ($\\AA$)") - - if filename is not None: - plt.savefig(filename) - else: - plt.show() - diff --git a/src/pyslice/postprocessing/haadf_data.py b/src/pyslice/postprocessing/haadf_data.py index 1bfc56a..2fbf277 100644 --- a/src/pyslice/postprocessing/haadf_data.py +++ b/src/pyslice/postprocessing/haadf_data.py @@ -13,28 +13,6 @@ logger = logging.getLogger(__name__) -try: - import torch ; xp = torch - TORCH_AVAILABLE = True - if torch.cuda.is_available(): - device = torch.device('cuda') - elif torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') - if device.type == 'mps': - complex_dtype = torch.complex64 - float_dtype = torch.float32 - else: - complex_dtype = torch.complex128 - float_dtype = torch.float64 -except ImportError: - TORCH_AVAILABLE = False - xp = np - print("PyTorch not available, falling back to NumPy") - complex_dtype = np.complex128 - float_dtype = np.float64 - class HAADFData(PySliceSerial, Signal): """ diff --git a/src/pyslice/postprocessing/tacaw_data.py b/src/pyslice/postprocessing/tacaw_data.py index 0ec4bd2..df9ee4c 100644 --- a/src/pyslice/postprocessing/tacaw_data.py +++ b/src/pyslice/postprocessing/tacaw_data.py @@ -9,33 +9,10 @@ from ..data.pyslice_serial import PySliceSerial, Signal, Dimensions, Dimension, Metadata #from ..data import Signal, Dimensions, Dimension, GeneralMetadata #from ..data.pyslice_serial import PySliceSerial -from pyslice.backend import to_cpu,fft,fftshift,mean,absolute,memmap,sum from tqdm import tqdm logger = logging.getLogger(__name__) -try: - import torch ; xp = torch - TORCH_AVAILABLE = True - if torch.cuda.is_available(): - device = torch.device('cuda') - elif torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') - if device.type == 'mps': - complex_dtype = torch.complex64 - float_dtype = torch.float32 - else: - complex_dtype = torch.complex128 - float_dtype = torch.float64 -except ImportError: - TORCH_AVAILABLE = False - xp = np - print("PyTorch not available, falling back to NumPy") - complex_dtype = np.complex128 - float_dtype = np.float64 - class TACAWData(PySliceSerial, Signal): """ @@ -203,9 +180,10 @@ def _fft_from_wf_data(self, layer_index: int = None): _,nw,nx2,ny2 = self._array.shape if nt==nw and nx==nx2 and ny==ny2: self._frequencies = np.load(self.cache_dir / "tacaw_freq.npy") - if TORCH_AVAILABLE: - self._frequencies = xp.Tensor(self._frequencies) - self._array = xp.Tensor(self._array) + if hasattr(self._array, 'device'): + import pyslice.backend as backend + self._frequencies = backend.asarray(self._frequencies) + self._array = backend.asarray(self._array) return # Default to last layer if not specified @@ -234,10 +212,10 @@ def _fft_from_wf_data(self, layer_index: int = None): # Perform FFT along time axis (axis=1) for each probe position and k-point # Following abeels.py approach: subtract mean to avoid high zero-frequency peak # then Compute intensity |Ψ(ω,q)|² from the frequency-domain wavefunction - + if self.chunkFFT: # looping through x (in case super giganormous FFTs blow your ram) dtype = complex_dtype if self.keep_complex else float_dtype - shape = (wf_layer.shape[0], self.n_chunks, wf_layer.shape[2], wf_layer.shape[3]) + shape = (wf_layer.shape[0], self.chunk_size_time, wf_layer.shape[2], wf_layer.shape[3]) if self.use_memmap: self._array = memmap(shape, dtype=dtype, filename = self.cache_dir / "tacaw.npy") else: @@ -280,7 +258,7 @@ def _fft_from_wf_data(self, layer_index: int = None): self.cache_dir.mkdir(parents=True, exist_ok=True) np.save(self.cache_dir / "tacaw_freq.npy", self._frequencies) if not self.use_memmap: - np.save(self.cache_dir / "tacaw.npy", to_cpu(self._array) ) + np.save(self.cache_dir / "tacaw.npy", backend.to_cpu(self._array) ) # Keep fft_from_wf_data as public alias for backward compatibility @@ -308,8 +286,8 @@ def spectrum(self, probe_index: int = None) -> np.ndarray: all_spectra.append(spectrum) # Average all spectra - if TORCH_AVAILABLE and hasattr(all_spectra[0], 'cpu'): - all_spectra = [s.cpu().numpy() for s in all_spectra] + if hasattr(all_spectra[0], 'device'): + all_spectra = [to_cpu(s) for s in all_spectra] spectrum = np.mean(all_spectra, axis=0) else: if probe_index >= len(self.probe_positions): @@ -320,8 +298,8 @@ def spectrum(self, probe_index: int = None) -> np.ndarray: spectrum = sum(probe_intensity, axis=(1, 2)) # Sum over kx, ky # Convert to numpy if PyTorch tensor - if TORCH_AVAILABLE and hasattr(spectrum, 'cpu'): - spectrum = spectrum.cpu().numpy() + if hasattr(spectrum, 'device'): + spectrum = to_cpu(spectrum) return spectrum @@ -380,8 +358,8 @@ def diffraction(self, probe_index: int = None, space: str = "reciprocal") -> np. all_diffractions.append(diffraction_pattern) # Average all diffraction patterns - if TORCH_AVAILABLE and hasattr(all_diffractions[0], 'cpu'): - all_diffractions = [d.cpu().numpy() for d in all_diffractions] + if hasattr(all_diffractions[0], 'device'): + all_diffractions = [to_cpu(d) for d in all_diffractions] diffraction_pattern = np.mean(all_diffractions, axis=0) else: if probe_index >= len(self.probe_positions): @@ -392,8 +370,8 @@ def diffraction(self, probe_index: int = None, space: str = "reciprocal") -> np. diffraction_pattern = sum(probe_intensity, axis=0) # Sum over frequencies # Convert to numpy if PyTorch tensor - if TORCH_AVAILABLE and hasattr(diffraction_pattern, 'cpu'): - diffraction_pattern = diffraction_pattern.cpu().numpy() + if hasattr(diffraction_pattern, 'device'): + diffraction_pattern = to_cpu(diffraction_pattern) if space == "real": diffraction_pattern = np.absolute(np.fft.ifft2(diffraction_pattern)) @@ -422,8 +400,8 @@ def spectral_diffraction(self, frequency: float, probe_index: int = None, space: all_spectral_diffractions.append(spectral_diffraction) # Average all spectral diffraction patterns - if TORCH_AVAILABLE and hasattr(all_spectral_diffractions[0], 'cpu'): - all_spectral_diffractions = [sd.cpu().numpy() for sd in all_spectral_diffractions] + if hasattr(all_spectral_diffractions[0], 'device'): + all_spectral_diffractions = [to_cpu(sd) for sd in all_spectral_diffractions] spectral_diffraction = np.mean(all_spectral_diffractions, axis=0) else: if probe_index >= len(self.probe_positions): @@ -433,8 +411,8 @@ def spectral_diffraction(self, frequency: float, probe_index: int = None, space: spectral_diffraction = self._array[probe_index, freq_idx, :, :] # Convert to numpy if PyTorch tensor - if TORCH_AVAILABLE and hasattr(spectral_diffraction, 'cpu'): - spectral_diffraction = spectral_diffraction.cpu().numpy() + if hasattr(spectral_diffraction, 'device'): + spectral_diffraction = to_cpu(spectral_diffraction) if space == "real": spectral_diffraction = np.absolute(np.fft.ifft2(spectral_diffraction)) @@ -537,11 +515,10 @@ def dispersion(self, kx_path: np.ndarray, ky_path: np.ndarray, probe_index: int w_slice = self._array[probe_index, w, :, :] # optionally iFFT across kx,ky if space == "real": - kwarg = {"dim":(1,2)} if TORCH_AVAILABLE else {"axes":(1,2)} - w_slice = xp.fft.ifft2(w_slice,**kwarg) + w_slice = np.fft.ifft2(w_slice, axes=(1,2)) # bring to CPU - if TORCH_AVAILABLE and hasattr(w_slice, 'cpu'): - w_slice = w_slice.cpu().numpy() + if hasattr(w_slice, 'device'): + w_slice = to_cpu(w_slice) # sum across probe positions w_slice = np.mean(w_slice,axis=0) # select values at positions diff --git a/src/pyslice/postprocessing/wf_data.py b/src/pyslice/postprocessing/wf_data.py index 6e00ac9..d851ecc 100644 --- a/src/pyslice/postprocessing/wf_data.py +++ b/src/pyslice/postprocessing/wf_data.py @@ -3,32 +3,10 @@ """ import numpy as np from typing import List, Tuple, Optional -from ..multislice.multislice import Probe,aberrationFunction +from ..multislice.multislice import Probe, aberrationFunction from ..data.pyslice_serial import PySliceSerial, Signal, Dimensions, Dimension, Metadata from pathlib import Path -from ..backend import mean,ones,zeros,reshape,absolute,sum,asarray,cumsum,randfloats,histogram - -try: - import torch ; xp = torch - TORCH_AVAILABLE = True - if torch.cuda.is_available(): - device = torch.device('cuda') - elif torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') - if device.type == 'mps': - complex_dtype = torch.complex64 - float_dtype = torch.float32 - else: - complex_dtype = torch.complex128 - float_dtype = torch.float64 -except ImportError: - TORCH_AVAILABLE = False - xp = np - print("PyTorch not available, falling back to NumPy") - complex_dtype = np.complex128 - float_dtype = np.float64 +import pyslice.backend as backend class WFData(PySliceSerial, Signal): @@ -157,9 +135,9 @@ def reshaped(self): # where self._array is indices probe,time,kx,ky,layer, we re nc,nptp,nx,ny = self.probe._array.shape # recall: decoherence creates duplicate probes: num_copies,num_positions,x,y indices nptp = len(self.probe_positions) npta,nt,nkx,nky,nl = self._array.shape # recall, Propagate flattens the first two, and adds time,layers: nc*npt,num_frames,x,y,nl indice - intermediate = reshape(self._array,(nc,nptp,nt,nkx,nky,nl)) + intermediate = backend.reshape(self._array,(nc,nptp,nt,nkx,nky,nl)) nx,ny = len(self.probe_xs),len(self.probe_ys) - return reshape(intermediate,(nc,ny,nx,nt,nkx,nky,nl)).swapaxes(1,2) + return backend.reshape(intermediate,(nc,ny,nx,nt,nkx,nky,nl)).swapaxes(1,2) @array.setter def array(self, value): @@ -195,7 +173,7 @@ def plot_reciprocal(self,filename=None,whichProbe="mean",whichTimestep="mean",po raw = self._array[:,:,:,:,-1] # probe, time, kx, ky, layer --> p,t,kx,ky npt,nt,nkx,nky = raw.shape - array = zeros((nkx,nky)) + array = backend.zeros((nkx,nky)) if isinstance(whichProbe,str) and whichProbe=="mean": whichProbe = np.arange(npt) elif isinstance(whichProbe,int): @@ -259,7 +237,7 @@ def plot_reciprocal(self,filename=None,whichProbe="mean",whichTimestep="mean",po # Convert to numpy array if it's a tensor # Apply powerscaling to intensity (|Ψ|²) - img_data = (absolute(array)**2)**powerscaling + img_data = (backend.absolute(array)**2)**powerscaling if hasattr(img_data, 'cpu'): img_data = img_data.cpu().numpy() elif hasattr(img_data, '__array__'): @@ -294,15 +272,12 @@ def plot_phase(self,filename=None,whichProbe=0,whichTimestep=0,extent=None,avg=F # Get array (with or without averaging) if avg: array = self._array[whichProbe,:,:,:,-1] # Shape: (time, kx, ky) - if hasattr(array, 'mean'): # torch tensor - array = array.mean(dim=0) # Average over time dimension - else: # numpy array - array = np.mean(array, axis=0) + array = backend.mean(array, axis=0) # Average over time dimension else: array = self._array[whichProbe,whichTimestep,:,:,-1] # Transform to real space - array = xp.fft.ifft2(array) + array = backend.ifft2(array) xs_np = np.asarray(self.xs) ys_np = np.asarray(self.ys) @@ -327,7 +302,7 @@ def plot_phase(self,filename=None,whichProbe=0,whichTimestep=0,extent=None,avg=F array = array.T # imshow convention: y,x. our convention: x,y # Get phase - phase_data = xp.angle(array) + phase_data = backend.angle(array) if hasattr(phase_data, 'cpu'): phase_data = phase_data.cpu().numpy() elif hasattr(phase_data, '__array__'): @@ -350,17 +325,17 @@ def plot_realspace(self,whichProbe="mean",whichTimestep="mean",extent=None,filen import matplotlib.pyplot as plt fig, ax = plt.subplots() - array = xp.fft.ifft2(self._array[:,:,:,:,-1]) + array = backend.ifft2(self._array[:,:,:,:,-1]) - array = xp.absolute(array) # probe, time, kx, ky, layer --> p,t,kx,ky + array = backend.absolute(array) # probe, time, kx, ky, layer --> p,t,kx,ky if isinstance(whichProbe,str) and whichProbe=="mean": - array = mean(abs(array),axis=0) # p,t,kx,ky --> t,kx,ky + array = backend.mean(backend.absolute(array),axis=0) # p,t,kx,ky --> t,kx,ky else: array = array[whichProbe] if isinstance(whichTimestep,str) and whichTimestep=="mean": - array = mean(array,axis=0) # t,kx,ky --> kx,ky + array = backend.mean(array,axis=0) # t,kx,ky --> kx,ky else: array = array[whichTimestep] @@ -371,7 +346,7 @@ def plot_realspace(self,whichProbe="mean",whichTimestep="mean",extent=None,filen extent = ( np.amin(self.xs) , np.amax(self.xs) , np.amin(self.ys) , np.amax(self.ys) ) # Convert to numpy array if it's a tensor - img_data = xp.absolute(array)**.25 + img_data = backend.absolute(array)**.25 if hasattr(img_data, 'cpu'): img_data = img_data.cpu().numpy() elif hasattr(img_data, '__array__'): @@ -385,11 +360,11 @@ def plot_realspace(self,whichProbe="mean",whichTimestep="mean",extent=None,filen plt.show() def propagate_free_space(self,dz): # UNITS OF ANGSTROM - kx_grid, ky_grid = xp.meshgrid(self._kxs, self._kys, indexing='ij') + kx_grid, ky_grid = backend.meshgrid(self._kxs, self._kys, indexing='ij') k_squared = kx_grid**2 + ky_grid**2 - inner = xp.pi * self.probe.wavelength * dz * k_squared - P = xp.exp( -1j * inner ) # not sure why, but combining this and previous line triggers a "ComplexWarning: Casting complex values to real discards the imaginary part" in python 2.9.1 but not 2.2.2 - if TORCH_AVAILABLE and isinstance(self._array, torch.Tensor): + inner = backend.pi * self.probe.wavelength * dz * k_squared + P = backend.exp( -1j * inner ) # not sure why, but combining this and previous line triggers a "ComplexWarning: Casting complex values to real discards the imaginary part" in python 2.9.1 but not 2.2.2 + if hasattr(self._array, 'device'): P = P.to(self._array.device) #if dz>0: self._array = P[None,None,:,:,None] * self._array @@ -397,13 +372,13 @@ def propagate_free_space(self,dz): # UNITS OF ANGSTROM def addSpatialDecoherence(self,sigma_dz,N): dzs = np.linspace(-2*sigma_dz,2*sigma_dz,N) # suppose N=25 amplitudes = np.exp(-dzs**2/sigma_dz**2) - self._array = self._array[:,None,:,:,:,:] * ones(N)[None,:,None,None,None,None] # n_probes,nt,nx,ny,nl --> + self._array = self._array[:,None,:,:,:,:] * backend.ones(N)[None,:,None,None,None,None] # n_probes,nt,nx,ny,nl --> nc,npt,nt,nx,ny,nl = self._array.shape # suppose nc=10 (addTemporalDecoherence created 10 wavelengths) - kx_grid, ky_grid = xp.meshgrid(self._kxs, self._kys, indexing='ij') + kx_grid, ky_grid = backend.meshgrid(self._kxs, self._kys, indexing='ij') k_squared = kx_grid**2 + ky_grid**2 for i in range(N): - inner = xp.pi * self.probe.wavelength * dzs[i] * k_squared - P = xp.exp( -1j * inner ) # not sure why, but combining this and previous line triggers a "ComplexWarning: Casting complex values to real discards the imaginary part" in python 2.9.1 but not 2.2.2 + inner = backend.pi * self.probe.wavelength * dzs[i] * k_squared + P = backend.exp( -1j * inner ) # not sure why, but combining this and previous line triggers a "ComplexWarning: Casting complex values to real discards the imaginary part" in python 2.9.1 but not 2.2.2 self._array[:,i,:,:,:,:] *= amplitudes[i]*P[None,None,:,:,None] self._array = self._array.reshape(nc*npt,nt,nx,ny,nl) #self.defocus(dzs) # defocus starts with 25,10,npt,nx,ny --reshapes--> 250,npt,nx,ny @@ -417,34 +392,34 @@ def addSpatialDecoherence(self,sigma_dz,N): def applyMask(self, radius, realOrReciprocal="reciprocal"): if realOrReciprocal == "reciprocal": - radii = xp.sqrt( self._kxs[:,None]**2 + self._kys[None,:]**2 ) - mask = zeros(radii.shape, device=self._array.device if TORCH_AVAILABLE else None) + radii = backend.sqrt( self._kxs[:,None]**2 + self._kys[None,:]**2 ) + mask = backend.zeros(radii.shape, device=self._array.device if backend.TORCH_BACKEND else None) mask[radii= kx_range[0])[0] # first element >= - i2=xp.argwhere(self._kxs <= kx_range[1])[-1]+1 # last element <=, +1, so i1:i2 includes i2 + i1=np.argwhere(self._kxs >= kx_range[0])[0] # first element >= + i2=np.argwhere(self._kxs <= kx_range[1])[-1]+1 # last element <=, +1, so i1:i2 includes i2 if ky_range is not None: - j1=xp.argwhere(self._kys >= ky_range[0])[0] - j2=xp.argwhere(self._kys <= ky_range[1])[-1]+1 + j1=np.argwhere(self._kys >= ky_range[0])[0] + j2=np.argwhere(self._kys <= ky_range[1])[-1]+1 nx=i2-i1 ; ny=j2-j1 self._array = self._array[:,:,i1:i2,j1:j2,:] # p,t,x,y,l indices: TODO this uses the same amount of RAM #self._array = xp.zeros((npt,nt,nx,ny,nl), device=self._array.device if TORCH_AVAILABLE else None) +\ From 77ca767a6f5aca96a0e29130ce761d09a5d4e92a Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Wed, 25 Mar 2026 17:51:52 -0700 Subject: [PATCH 06/14] More backend changes --- src/pyslice/backend.py | 79 +++++----------- src/pyslice/multislice/calculators.py | 78 ++++++---------- src/pyslice/multislice/multislice.py | 111 +++++++++++------------ src/pyslice/multislice/potentials.py | 32 ++++--- src/pyslice/multislice/sed.py | 16 ++-- src/pyslice/postprocessing/haadf_data.py | 7 +- src/pyslice/postprocessing/tacaw_data.py | 41 +++++---- src/pyslice/postprocessing/wf_data.py | 21 +++-- 8 files changed, 173 insertions(+), 212 deletions(-) diff --git a/src/pyslice/backend.py b/src/pyslice/backend.py index 7bf1217..d95458e 100644 --- a/src/pyslice/backend.py +++ b/src/pyslice/backend.py @@ -1,15 +1,14 @@ # backend.py - Backend abstraction layer for NumPy/PyTorch support import numpy as np -import os - +from typing import Any, Optional, Union -# First, try to import torch try: import torch + xp = torch # type: ignore[assignment] TORCH_AVAILABLE = True except ImportError: + xp = np # type: ignore[assignment] TORCH_AVAILABLE = False - torch = None # Check for backend override via environment variable import os @@ -34,7 +33,7 @@ def device_and_precision(device_spec=None): Tuple of (device, float_dtype, complex_dtype) """ if not TORCH_BACKEND: - return None, np.float64, np.complex128 + return 'cpu', np.float64, np.complex128 # Check for device override via environment variable device_override = os.environ.get('PYSLICE_DEVICE', '').lower() @@ -66,6 +65,8 @@ def device_and_precision(device_spec=None): # Determine default device and dtypes at import time DEFAULT_DEVICE, DEFAULT_FLOAT_DTYPE, DEFAULT_COMPLEX_DTYPE = device_and_precision() +print(DEFAULT_DEVICE, DEFAULT_FLOAT_DTYPE, DEFAULT_COMPLEX_DTYPE) + # Convenience aliases float_dtype = DEFAULT_FLOAT_DTYPE complex_dtype = DEFAULT_COMPLEX_DTYPE @@ -179,11 +180,10 @@ def fftfreq(n, d=1.0, dtype=None, device=None): def fft2(x, **kwargs): - """2D FFT with kwarg conversion (dim/axis).""" + """2D FFT with kwarg conversion (dim/axes).""" if TORCH_BACKEND and "axes" in kwargs: kwargs["dim"] = kwargs.pop("axes") - if not TORCH_BACKEND and "dim" in kwargs: - kwargs["axis"] = kwargs.pop("dim") + # For numpy, "axes" is already correct - don't convert to "axis" return xp.fft.fft2(x, **kwargs) @@ -200,8 +200,7 @@ def ifft2(x, **kwargs): """2D inverse FFT with kwarg conversion.""" if TORCH_BACKEND and "axes" in kwargs: kwargs["dim"] = kwargs.pop("axes") - if not TORCH_BACKEND and "dim" in kwargs: - kwargs["axis"] = kwargs.pop("dim") + # For numpy, "axes" is already correct, no conversion needed return xp.fft.ifft2(x, **kwargs) @@ -237,48 +236,6 @@ def exp(x): """Element-wise exponential.""" return xp.exp(x) -def fft(k,**kwargs): - use_torch = TORCH_AVAILABLE - if type(k) in [ np.memmap, np.ndarray ]: - use_torch = False - if use_torch and "axis" in kwargs.keys(): - kwargs["dim"]=kwargs["axis"] ; del kwargs["axis"] - if not use_torch and "dim" in kwargs.keys(): - kwargs["axis"]=kwargs["dim"] ; del kwargs["dim"] - if use_torch: - return xp.fft.fft(k,**kwargs) - return np.fft.fft(k,**kwargs) - -def fftshift(k,**kwargs): - use_torch = TORCH_AVAILABLE - if type(k) in [ np.memmap, np.ndarray ]: - use_torch = False - if use_torch and "axes" in kwargs.keys(): - kwargs["dim"]=kwargs["axes"] ; del kwargs["axes"] - if not use_torch and "dim" in kwargs.keys(): - kwargs["axes"]=kwargs["dim"] ; del kwargs["dim"] - if use_torch: - return xp.fft.fftshift(k,**kwargs) - return np.fft.fftshift(k,**kwargs) - -def mean(k,**kwargs): - use_torch = TORCH_AVAILABLE - if type(k) in [ np.memmap, np.ndarray ]: - use_torch = False - if use_torch and "keepdims" in kwargs.keys(): - kwargs["keepdim"]=kwargs["keepdims"] ; del kwargs["keepdims"] - if not use_torch and "keepdim" in kwargs.keys(): - kwargs["keepdims"]=kwargs["keepdim"] ; del kwargs["keepdim"] - if use_torch and "axis" in kwargs.keys(): - kwargs["dim"]=kwargs["axis"] ; del kwargs["axis"] - if not use_torch and "dim" in kwargs.keys(): - kwargs["axis"]=kwargs["dim"] ; del kwargs["dim"] - if not use_torch: - return np.mean(k,**kwargs) - return xp.mean(k,**kwargs) - -def ifft2(k): - return xp.fft.ifft2(k) def real(x): """Take real part.""" @@ -305,16 +262,26 @@ def amax(x): return xp.amax(x) -def sum(x, axis=None, **kwargs): +def arange(*args, **kwargs): + """Create array with evenly spaced values.""" + return xp.arange(*args, **kwargs) + + +def linspace(start, stop, num=50, **kwargs): + """Create array with evenly spaced values.""" + return xp.linspace(start, stop, num, **kwargs) + + +def sum(x: Any, axis: Optional[int] = None, **kwargs: Any) -> Any: """Sum elements along axis with kwarg conversion.""" - if TORCH_BACKEND and type(x) not in [np.memmap, np.ndarray]: + if TORCH_BACKEND and type(x) not in (np.memmap, np.ndarray): if "axis" in kwargs: kwargs["dim"] = kwargs.pop("axis") - return xp.sum(x, dim=axis, **kwargs) + return xp.sum(x, dim=axis, **kwargs) # type: ignore[attr-defined] else: if "dim" in kwargs: kwargs["axis"] = kwargs.pop("dim") - return np.sum(x, axis=axis, **kwargs) + return np.sum(x, axis=axis, **kwargs) # type: ignore[attr-defined] def mean(x, axis=None, **kwargs): diff --git a/src/pyslice/multislice/calculators.py b/src/pyslice/multislice/calculators.py index 9aa4e66..d822a35 100644 --- a/src/pyslice/multislice/calculators.py +++ b/src/pyslice/multislice/calculators.py @@ -209,17 +209,8 @@ def setup( self.base_probe.spatial_decoherence, self.base_probe.temporal_decoherence, self.base_probe._array) #print(cache_key) - self.output_dir = Path("psi_data/" + ("torch" if TORCH_AVAILABLE else "numpy") + "_"+self.cache_key) + self.output_dir = Path("psi_data/" + ("torch" if hasattr(self.base_probe._array, 'device') else "numpy") + "_"+self.cache_key) #self.output_dir.mkdir(parents=True, exist_ok=True) - - # cache key is calculated TWICE: once during setup (so the user only needs to setup to infer where their cache folder will go), and again during run (just in case the user does something funky) - # Generate cache key and setup output directory - self.cache_key = self._generate_cache_key(self.trajectory, self.aperture, self.voltage_eV, - self.slice_thickness, self.sampling, self.probe_positions, - self.base_probe.spatial_decoherence, self.base_probe.temporal_decoherence, - self.base_probe._array) - #print(cache_key) - self.output_dir = Path("psi_data/" + ("torch" if TORCH_AVAILABLE else "numpy") + "_"+self.cache_key) #self.output_dir.mkdir(parents=True, exist_ok=True) def preview_probes(self): @@ -236,7 +227,7 @@ def preview_probes(self): potential.flatten() import matplotlib.pyplot as plt fig, ax = plt.subplots() - array = np.absolute(backend.to_cpu(potential.array))[:,::-1,0].T # imshow convention: y,x. our convention: x,y, and flip y (0,0 upper-left) + array = np.backend.absolute(backend.to_cpu(potential.array))[:,::-1,0].T # imshow convention: y,x. our convention: x,y, and flip y (0,0 upper-left) xs = backend.to_cpu(potential.xs) ; ys = backend.to_cpu(potential.ys) extent = (np.amin(xs),np.amax(xs),np.amin(ys),np.amax(ys)) #print(extent) @@ -263,7 +254,7 @@ def run(self) -> WFData: # if probes are over vacuum (e.g. nanoparticles), we don't need to propagate them? - self.probe_indices = xp.arange(len(self.probe_positions)) + self.probe_indices = backend.arange(len(self.probe_positions)) if self.skip_vacuum and len(self.probe_positions)>1 and self.aperture>1 and self.min_dk: if os.path.exists(self.output_dir / f"probe_indices.npy"): self.probe_indices = np.load(self.output_dir / f"probe_indices.npy") @@ -272,7 +263,7 @@ def run(self) -> WFData: self.probe_indices = [] for i,p in enumerate(tqdm(self.probe_positions)): p = asarray(p) - d_to_nearest_atom = xp.sqrt( xp.amin( xp.sum( (p[None,:]-xy_atoms)**2,axis=1) ) ) + d_to_nearest_atom = backend.sqrt( backend.amin( backend.sum( (p[None,:]-xy_atoms)**2,axis=1) ) ) if d_to_nearest_atom < self.probe_cropping*self.sampling: self.probe_indices.append(i) np.save(self.output_dir / f"probe_indices.npy", self.probe_indices) @@ -310,35 +301,20 @@ def run(self) -> WFData: if not isinstance(self.ADF,bool): kwargs["inner_mrad"],kwargs["outer_mrad"] = self.ADF from ..postprocessing.haadf_data import HAADFData - array = zeros((self.n_probes,1,1,1,1),dtype=self.complex_dtype) - array += xp.arange(self.n_probes)[:,None,None,None,None] # we'll use this as an index to map nth probe to the ADF grid coordinates i,j - wf = WFData(probe_positions=self.probe_positions,probe_xs=self.probe_xs,probe_ys=self.probe_ys, - time=None,kxs=self.kxs[self.keep_kxs_indices],kys=self.kys[self.keep_kys_indices],xs=self.xs,ys=self.ys, - layer=None,array=array,probe=self.base_probe,cache_dir=self.output_dir) - self.ADF = HAADFData(wf) - self.ADFmask = absolute(self.ADF.getMask(**kwargs)) # HAADFData infers mask dtype from _wf_array dtype, but we'll absolute^2 later - self.ADFindex = astype(absolute(self.ADF._wf_array[0,:,:,0,0,0,0]),int) - self.ADF._array = zeros(self.ADFindex.shape,dtype=self.complex_dtype) - - if self.ADF: # create a dummy HAADFData object, first so we can hijack its getMask function, and later we'll load it up - kwargs = {} - if not isinstance(self.ADF,bool): - kwargs["inner_mrad"],kwargs["outer_mrad"] = self.ADF - from ..postprocessing.haadf_data import HAADFData - array = zeros((self.n_probes,1,1,1,1),dtype=self.complex_dtype) - array += xp.arange(self.n_probes)[:,None,None,None,None] # we'll use this as an index to map nth probe to the ADF grid coordinates i,j + array = backend.zeros((self.n_probes,1,1,1,1),dtype=self.complex_dtype) + array += backend.arange(self.n_probes)[:,None,None,None,None] # we'll use this as an index to map nth probe to the ADF grid coordinates i,j wf = WFData(probe_positions=self.probe_positions,probe_xs=self.probe_xs,probe_ys=self.probe_ys, time=None,kxs=self.kxs[self.keep_kxs_indices],kys=self.kys[self.keep_kys_indices],xs=self.xs,ys=self.ys, layer=None,array=array,probe=self.base_probe,cache_dir=self.output_dir) self.ADF = HAADFData(wf) - self.ADFmask = absolute(self.ADF.getMask(**kwargs)) # HAADFData infers mask dtype from _wf_array dtype, but we'll absolute^2 later - self.ADFindex = astype(absolute(self.ADF._wf_array[0,:,:,0,0,0,0]),int) - self.ADF._array = zeros(self.ADFindex.shape,dtype=self.complex_dtype) + self.ADFmask = backend.absolute(self.ADF.getMask(**kwargs)) # HAADFData infers mask dtype from _wf_array dtype, but we'll absolute^2 later + self.ADFindex = backend.astype(backend.absolute(self.ADF._wf_array[0,:,:,0,0,0,0]),int) + self.ADF._array = backend.zeros(self.ADFindex.shape,dtype=self.complex_dtype) # Process frames one at a time with tqdm progress tracking with tqdm(total=self.n_frames, desc="Processing frames", unit="frame") as pbar: for frame_idx in range(self.n_frames): - #if sum(absolute(self.wavefunction_data[:,frame_idx,:,:,:]),axis=(0,1,2,3))>0: # p,t,x,y,l indices + #if sum(backend.absolute(self.wavefunction_data[:,frame_idx,:,:,:]),axis=(0,1,2,3))>0: # p,t,x,y,l indices #continue cache_file = self.output_dir / f"frame_{frame_idx}.npy" # Show detailed progress for single-frame runs @@ -362,7 +338,7 @@ def run(self) -> WFData: # frame_data should always be shaped: n_probes,nkx,nky,n_layers,1 (idk why there's a trailing 1) cache_exists,frame_data = checkCache(cache_file,self.cache_levels) if cache_exists and not self.prism and self.ADF: - intensities = einsum('pxyln,xy->p',absolute(frame_data)**2,self.ADFmask) + intensities = backend.einsum('pxyln,xy->p',backend.absolute(frame_data)**2,self.ADFmask) self.ADF._array += intensities[self.ADFindex] if not os.path.exists(self.output_dir / f"kx.npy"): @@ -435,8 +411,8 @@ def run(self) -> WFData: # expand out to fixed l,p,x,y indices exit_waves_single = backend.expand_dims(exit_waves_single,0) if len(exit_waves_single.shape)==3 else exit_waves_single - # FFT and load into frame_data - kwarg = {"dim":(-2,-1)} if TORCH_AVAILABLE else {"axes":(-2,-1)} + # FFT and load into frame_data - always use 'axes' and let backend handle conversion + kwarg = {"axes":(-2,-1)} for layer_idx in range(self.n_layers): exit_waves_k = backend.fft2(exit_waves_single[layer_idx,:,:,:], **kwarg) # l,p,x,y --> p,x,y diffraction_patterns = backend.fftshift(exit_waves_k, **kwarg) @@ -461,9 +437,9 @@ def run(self) -> WFData: # exit_waves_batch = expand_dims(exit_waves_batch,0) if len(exit_waves_batch.shape)==3 else exit_waves_batch # # FFT and load into frame_data # for layer_idx in range(self.n_layers): -# kwarg = {"dim":(-2,-1)} if TORCH_AVAILABLE else {"axes":(-2,-1)} -# exit_waves_k = xp.fft.fft2(exit_waves_batch[layer_idx,:,:,:], **kwarg) # l,p,x,y --> p,x,y -# diffraction_patterns = xp.fft.fftshift(exit_waves_k, **kwarg) +# kwarg = {"dim":(-2,-1)} if hasattr(self.base_probe._array, 'device') else {"axes":(-2,-1)} +# exit_waves_k = backend.fft.fft2(exit_waves_batch[layer_idx,:,:,:], **kwarg) # l,p,x,y --> p,x,y +# diffraction_patterns = backend.fft.fftshift(exit_waves_k, **kwarg) # #cropped = diffraction_patterns[:,self.i1:self.i2,self.j1:self.j2] # #if not self.prism: # diffraction_patterns = diffraction_patterns[:,self.keep_kxs_indices,:][:,:,self.keep_kys_indices]*self.kth**2 @@ -472,12 +448,12 @@ def run(self) -> WFData: # if self.store_full or self.prism: # frame_data[:,:,:,layer_idx,0] = diffraction_patterns # load p,x,y --> p,x,y,l,1 indices # if self.ADF and not self.prism: -# intensities = einsum('pxy,xy->p',absolute(diffraction_patterns)**2,self.ADFmask) +# intensities = backend.einsum('pxy,xy->p',backend.absolute(diffraction_patterns)**2,self.ADFmask) # #print(type(self.ADF._array),type(intensities),type(self.ADFindex)) # if self.use_memmap: # intensities = asarray(intensities,device=self.device) # self.ADF._array += intensities[self.ADFindex] -# #self.ADF._array = einsum('pxyln,'frame_data +# #self.ADF._array = backend.einsum('pxyln,'frame_data if not self.use_memmap and ( "exitwaves" in self.cache_levels or "slices" in self.cache_levels ) and (self.store_full or self.prism): @@ -528,15 +504,15 @@ def run(self) -> WFData: # Note: WFData expects (probe_positions, time, kx, ky, layer) format # Create k-space coordinates to match expected format (same as AbTem) # TWP: If we're not going to also provide a shifted/etc reciprocal_array, we shouldn't shift the kxs - #kxs = xp.fft.fftfreq(self.nx, d=self.dx) - #kys = xp.fft.fftfreq(self.ny, d=self.dy) - #kxs = xp.fft.fftshift(xp.fft.fftfreq(self.nx, self.sampling)) # k-space in 1/Å MOVING TO INIT SO WE CAN CROP ON-THE-FLY - #kys = xp.fft.fftshift(xp.fft.fftfreq(self.ny, self.sampling)) # k-space in 1/Å + #kxs = backend.fft.fftfreq(self.nx, d=self.dx) + #kys = backend.fft.fftfreq(self.ny, d=self.dy) + #kxs = backend.fft.fftshift(backend.fft.fftfreq(self.nx, self.sampling)) # k-space in 1/Å MOVING TO INIT SO WE CAN CROP ON-THE-FLY + #kys = backend.fft.fftshift(backend.fft.fftfreq(self.ny, self.sampling)) # k-space in 1/Å time_array = np.arange(self.n_frames) * self.trajectory.timestep # Time array in ps layer_array = np.arange(self.nz) if "slices" in self.cache_levels else np.array([0]) # Layer indices # Package results - array = zeros((self.n_probes,1,1,1,1),dtype=self.complex_dtype) + array = backend.zeros((self.n_probes,1,1,1,1),dtype=self.complex_dtype) if self.store_full: array = self.wavefunction_data #print(array.shape,self.kxs.shape,self.kys.shape) @@ -610,10 +586,10 @@ def setup(self, trajectory: Trajectory, axis:int = 2, abc:list = [1,1,1]): del nxyz[axis] del abc[axis] - self.kxs=np.linspace(0,2*np.pi/abc[0],nxyz[0]) - self.kys=np.linspace(0,2*np.pi/abc[1],nxyz[1]) + self.kxs=backend.linspace(0,2*np.pi/abc[0],nxyz[0]) + self.kys=backend.linspace(0,2*np.pi/abc[1],nxyz[1]) - self.kvec = np.zeros((len(self.kxs),len(self.kys),3)) + self.kvec = backend.zeros((len(self.kxs),len(self.kys),3)) self.kvec[:,:,0] += self.kxs[:,None] self.kvec[:,:,1] += self.kys[None,:] @@ -637,7 +613,7 @@ def plot(self,w,filename=None): # TODO MAYBE "RUN" SHOULD RETURN A TACAW OBJECT #ax.imshow((Zx[::-1,:,0]+Zy[::-1,:,0]+Zz[::-1,:,0])**.25, cmap="inferno", extent=extent,aspect="auto") #plt.show() - i=np.argmin(np.absolute(self.ws-w)) + i=np.argmin(np.backend.absolute(self.ws-w)) extent = ( np.amin(self.kxs) , np.amax(self.kxs) , np.amin(self.kys) , np.amax(self.kys) ) fig, ax = plt.subplots() diff --git a/src/pyslice/multislice/multislice.py b/src/pyslice/multislice/multislice.py index 16a46ca..196b193 100644 --- a/src/pyslice/multislice/multislice.py +++ b/src/pyslice/multislice/multislice.py @@ -150,7 +150,7 @@ def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, pre #for i,w in enumerate(self.wavelength): # self._array[i,0,:,:] = self.generate_single_probe(mrad,w,gaussianVOA,preview=preview) #self._array = backend.zeros((1,1,nx,ny), dtype=self.complex_dtype, device=self.device) - self._array= self.generate_single_probe(mrad,self.wavelength,self.gaussianVOA,preview=preview)[None,None,:,:]*ones((1,1), device=self.device)[:,:,None,None] + self._array= self.generate_single_probe(mrad,self.wavelength,self.gaussianVOA,preview=preview)[None,None,:,:]*backend.ones((1,1), device=self.device)[:,:,None,None] self.cropping = cropping #self.offsets = [[0,0] for i in range(len(self.probe_positions)) ] @@ -171,7 +171,7 @@ def generate_single_probe(self,mrad,wavelength,gaussianVOA,preview=False): nx,ny = len(kxs) , len(kys) if mrad == 0: - return backend.zeros((nx, ny), device=self.device, dtype=self.complex_dtype, device=self.device)+1 + return backend.zeros((nx, ny), device=self.device, dtype=self.complex_dtype)+1 reciprocal = backend.zeros((nx, ny), dtype=self.complex_dtype, device=self.device) radius = (mrad * 1e-3) / wavelength # Convert mrad to reciprocal space units @@ -195,7 +195,7 @@ def generate_single_probe(self,mrad,wavelength,gaussianVOA,preview=False): plt.show() if self.stay_reciprocal: # if we would've done a real-space shift, we should apply a phase ramp in reciprocal space - return reciprocal * xp.exp(-2j * xp.pi * kxs[:, None] * self.lx/2 ) * xp.exp(-2j * xp.pi * kys[None, :] * self.ly/2 ) + return reciprocal * backend.exp(-2j * backend.pi * kxs[:, None] * self.lx/2 ) * backend.exp(-2j * backend.pi * kys[None, :] * self.ly/2 ) return backend.ifftshift(backend.ifft2(reciprocal)) # iFFT --> realspace --> shift --> zero in the center #self.array_numpy = self.array.cpu().numpy() @@ -304,7 +304,7 @@ def addTemporalDecoherence(self,sigma_eV,N): print("WARNING: calling addTemporalDecoherence twice will overwrite previous") self.temporal_decoherence = (sigma_eV,N) eV = self.eV - self.eVs = np.linspace(eV-2*sigma_eV,eV+2*sigma_eV,N) + self.eVs = backend.linspace(eV-2*sigma_eV,eV+2*sigma_eV,N) self.eVs = backend.asarray(self.eVs, dtype=self.dtype, device=self.device) self.wavelengths = wavelength(self.eVs) amplitudes = backend.exp(-(eV-self.eVs)**2/sigma_eV**2) @@ -323,7 +323,7 @@ def addSpatialDecoherence(self,sigma_dz,N): if self.temporal_decoherence is not None: print("WARNING: calling addSpatialDecoherence twice will overwrite previous") self.spatial_decoherence = (sigma_dz,N) - dzs = np.linspace(-2*sigma_dz,2*sigma_dz,N) # suppose N=25 + dzs = backend.linspace(-2*sigma_dz,2*sigma_dz,N) # suppose N=25 amplitudes = backend.exp(-dzs**2/sigma_dz**2) nc,npt,nx,ny = self._array.shape # suppose nc=10 (addTemporalDecoherence created 10 wavelengths) if self.use_torch: @@ -396,7 +396,7 @@ def placeProbe(self,array,x,y): def aberrate(self,aberrations): dP = aberrationFunction(self.kxs,self.kys,self.wavelength,aberrations) # recall, in Probe.__init__, we created the real-space array via: - # self.array = xp.fft.ifftshift(xp.fft.ifft2(reciprocal)) + # self.array = backend.fft.ifftshift(backend.fft.ifft2(reciprocal)) # Aberrations are defined at the aperture plane, so we must apply them in reciprocal space. # (or do a convolution in real-space) reciprocal = backend.fft2(backend.fftshift(self._array)) # centered-real --> zero at corner --> FFT --> kx,ky zero at corner @@ -432,7 +432,7 @@ def aberrate(self,aberrations): # or comparing to: https://abtem.readthedocs.io/en/latest/user_guide/walkthrough/contrast_transfer_function.html # χ(k,ϕ) = π/2/λ 1/(n+1) C ( k λ )^(n+1) cos(m*(ϕ-ϕa)) # Aberrations are an adjustment to the phase of the wave ("dPhi"), to be applied in reciprocal space. -# this is done by multiplying the complex wave (be it a probe or an exit wave) by xp.exp(-1j * dPhi) +# this is done by multiplying the complex wave (be it a probe or an exit wave) by backend.exp(-1j * dPhi) def aberrationFunction(kxs,kys,wavelength,aberrations): # aberrations should be a dict of Cnm following https://abtem.readthedocs.io/en/latest/user_guide/walkthrough/contrast_transfer_function.html dPhi = backend.zeros_like(kxs[:,None] * kys[None,:]) ks = backend.sqrt( kxs[:,None]**2 + kys[None,:]**2 ) # unshifted: 0,1,2,3,...-3,-2,-1, reciprocal origin at corner @@ -515,23 +515,20 @@ class PrismProbe: """ def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, preview=False, nkx = 25, nky=None, kth=1): - # TORCH DEVICES AND DTYPES - if TORCH_AVAILABLE: + # DEVICE AND DTYPE SETUP + if TORCH_BACKEND: # Auto-detect device if not specified (same logic as Potential class) if device is None: - if torch.cuda.is_available(): - device = torch.device('cuda') - elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') + device, dtype, complex_dtype = backend.device_and_precision() elif isinstance(device, str): - device = torch.device(device) + device, dtype, complex_dtype = backend.device_and_precision(device) + else: + # Assume device is already properly formatted + _, dtype, complex_dtype = backend.device_and_precision() self.device = device self.use_torch = True - # Use float32 for MPS compatibility (same as Potential class) - self.dtype = torch.float32 if device.type == 'mps' else torch.float64 - self.complex_dtype = torch.complex64 if device.type == 'mps' else torch.complex128 + self.dtype = dtype + self.complex_dtype = complex_dtype else: if device is not None: raise ImportError("PyTorch not available. Please install PyTorch.") @@ -545,16 +542,16 @@ def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, pre self.nx = len(xs) ; self.ny = len(ys) # Convert coordinate arrays to tensors if using torch (same as Potential class) if self.use_torch: - # Use as_tensor to avoid copy warning when input is already a tensor - self.xs = torch.as_tensor(xs, dtype=self.dtype, device=self.device) - self.ys = torch.as_tensor(ys, dtype=self.dtype, device=self.device) + # Use asarray to handle both numpy and torch data + self.xs = backend.asarray(xs, dtype=self.dtype, device=self.device) + self.ys = backend.asarray(ys, dtype=self.dtype, device=self.device) else: self.xs = xs self.ys = ys device_kwargs = {'device': self.device, 'dtype': self.dtype} if self.use_torch else {} - self.kxs = xp.fft.fftshift(xp.fft.fftfreq(self.nx, d=self.dx, **device_kwargs)) # # 0,1,2,3...-3,-2.-1 -shift-> ...-3,-2,-1,0,1,2,3... - self.kys = xp.fft.fftshift(xp.fft.fftfreq(self.ny, d=self.dy, **device_kwargs)) - self._array = zeros((1,1,self.nx,self.ny),dtype=self.complex_dtype) + self.kxs = backend.fftshift(backend.fftfreq(self.nx, d=self.dx)) + self.kys = backend.fftshift(backend.fftfreq(self.ny, d=self.dy)) + self._array = backend.zeros((1,1,self.nx,self.ny),dtype=self.complex_dtype) # SPARSIFIED STUFF, USED FOR CONSTRUCTING SPARSE SINUSOIDS IN REAL SPACE if nky is None: nky = nkx @@ -575,7 +572,7 @@ def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, pre self.eV = eV ; self.wavelength=wavelength(eV) self.eVs = np.asarray([eV]) if self.use_torch: - self.eVs = torch.as_tensor(self.eVs, dtype=self.dtype, device=self.device) + self.eVs = backend.asarray(self.eVs, dtype=self.dtype, device=self.device) self.wavelengths = wavelength(self.eVs) self.temporal_decoherence = None self.spatial_decoherence = None @@ -586,10 +583,10 @@ def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, pre # where Probe.applyShifts looks at real-space x,y pairs in probe_positions and applies a phase ramp to shift a template probe, PrismProbe.applyShifts looks at reciprocal-space kx,ky pairs in probe_positions to construct sinusoids def applyShifts(self): # inflate self._array to store probe cube (npt,nx,ny) - self._array = self._array[:,0,None,:,:] * ones(len(self.probe_positions), device=self.device)[None,:,None,None] + self._array = self._array[:,0,None,:,:] * backend.ones(len(self.probe_positions), device=self.device)[None,:,None,None] # loop through probe positions for n,(kx,ky) in enumerate(self.probe_positions): - self._array[:,n,:,:] = xp.exp(2j * xp.pi * self.xs[:, None] * kx ) * xp.exp(2j * xp.pi * self.ys[None,:] * ky ) + self._array[:,n,:,:] = backend.exp(2j * backend.pi * self.xs[:, None] * kx ) * backend.exp(2j * backend.pi * self.ys[None,:] * ky ) # numpy appears to use exp(i2pixk) convention for FFT: xs = np.linspace(0,100,10000) ; ys = np.sin(xs) ; fft = np.fft.fft(ys) ; freq=np.fft.fftfreq(len(xs),d=xs[1]-xs[0]) ; fft2 = np.sum(ys[:,None]*np.exp(2j*np.pi*xs[:,None]*freq[None,:]),axis=0) # if a PrismProbe object (a whole bunch of sinusoidal entrance waves) is propagated through a potential, then the potential exit waves for a whole bunch of realistic probes can be calculated from the exit waves for each entrance wave @@ -619,21 +616,21 @@ def calculateProbesFromS(self,array,positions,chunksize=100,load_into=None,ADF=F continue # strategy 1, real-space #ary = probe.generate_single_probe(self.mrad,self.wavelength,self.gaussianVOA,preview=False) - #probe_k = xp.fft.fftshift(xp.fft.fft2(probe.placeProbe(ary,x,y)[0][0,:,:])) # shiff(fft()) to match what calculators did to array + #probe_k = backend.fft.fftshift(backend.fft.fft2(probe.placeProbe(ary,x,y)[0][0,:,:])) # shiff(fft()) to match what calculators did to array # strategy 2, keep things in reciprocal space, saves two ffts? - # realspace single probe was xp.fft.ifftshift(xp.fft.ifft2(reciprocal)) - # placed was xp.fft.fft2(array), then phase ramp, then xp.fft.ifft2(array) + # realspace single probe was backend.fft.ifftshift(backend.fft.ifft2(reciprocal)) + # placed was backend.fft.fft2(array), then phase ramp, then backend.fft.ifft2(array) #ary = probe.generate_single_probe(self.mrad,self.wavelength,self.gaussianVOA,preview=False,keep_reciprocal=True) - #probe_k = xp.fft.fftshift(probe.placeProbe(ary,x,y,realspace=False)[0][0,:,:]) + #probe_k = backend.fft.fftshift(probe.placeProbe(ary,x,y,realspace=False)[0][0,:,:]) # strategy 3, stack of probes #probes = Probe(self.xs, self.ys, self.mrad, self.eV, probe_positions = positions[n:n+chunksize]) - #kwarg = {"dim":(-2,-1)} if TORCH_AVAILABLE else {"axes":(-2,-1)} - #probe_ks = xp.fft.fftshift(xp.fft.fft2(probes._array[0,:,:,:],**kwarg),**kwarg) + #kwarg = {"dim":(-2,-1)} if TORCH_BACKEND else {"axes":(-2,-1)} + #probe_ks = backend.fft.fftshift(backend.fft.fft2(probes._array[0,:,:,:],**kwarg),**kwarg) # note you CAN generate the probe pre-cropped (use arg crop_reciprocal, then skip the self.i1:-self.i1 indexing), but this doesn't seem to save a whole lot of time... probes = Probe(self.xs, self.ys, self.mrad, self.eV, probe_positions = positions[n:n+chunksize],stay_reciprocal=True)#,crop_reciprocal=(self.i1,self.j1)) - kwarg = {"dim":(-2,-1)} if TORCH_AVAILABLE else {"axes":(-2,-1)} - probe_ks = xp.fft.fftshift(probes._array[0,:,:,:],**kwarg) + kwarg = {"axes":(-2,-1)} # Always use 'axes', backend will convert to 'dim' for torch if needed + probe_ks = backend.fftshift(probes._array[0,:,:,:],**kwarg) # fourier components of FFT'd and cropped probe are the contribution of each exit wave factors = probe_ks[:,self.i1:self.nx-self.i1,self.j1:self.ny-self.j1] # this is unshifted since ij_lookup used unshifted kxs,kys @@ -659,14 +656,14 @@ def calculateProbesFromS(self,array,positions,chunksize=100,load_into=None,ADF=F # preview our sparse-k reconstructed probe? fft --> downsample --> ifft #if n<=len(positions)//3 x,y,z else: - v_xyz=np.asarray(v_xyz,dtype=float) - v_xyz/=np.sqrt(np.sum(v_xyz**2)) # normalize magnitude of passed vector + v_xyz=backend.asarray(v_xyz,dtype=float) + v_xyz/=backend.sqrt(backend.sum(v_xyz**2)) # normalize magnitude of passed vector # time axis: infer frequencies, calculate length so we can trim off negative frequencies, set up empty - nt2=int(nt/2) ; ws=np.fft.fftfreq(nt)[:nt2] + nt2=int(nt/2) ; ws=fftfreq(nt)[:nt2] # project displacements onto vector if isinstance(v_xyz,(int,float,np.integer)): @@ -100,11 +102,11 @@ def SED(avg,displacements,kvec,v_xyz=0,bs=''): # Φ(k,ω) = Σb | ∫ Σn u°(n,b,t) exp( i k r̄(n,0) ) exp( i ω t ) dt |² or | ℱ[ Σn u°(n,b,t) exp( i k r̄(n,0) ) |² # exp( i k r̄(n,0) ) term: - expo=np.exp(1j*np.einsum('aj,xyj->axy',avg[bs,:],kvec[:,:,:])) # indices: (a)tom, (x)/y/z, (k) point + expo=backend.exp(1j*backend.einsum('aj,xyj->axy',avg[bs,:],kvec[:,:,:])) # indices: (a)tom, (x)/y/z, (k) point # u°(n,b,t) exp( i k r̄(n,0) ) term: - integrands=np.einsum('ta,axy->txy',us,expo,optimize=True) # indices: (t)ime, (a)toms, (k) point - Zs=np.fft.fft(integrands,axis=0)[:nt2,:,:] + integrands=backend.einsum('ta,axy->txy',us,expo,optimize=True) # indices: (t)ime, (a)toms, (k) point + Zs=fft(integrands,axis=0)[:nt2,:,:] #if not keepComplex: - Zs=np.absolute(Zs)**2 + Zs=absolute(Zs)**2 return Zs,ws diff --git a/src/pyslice/postprocessing/haadf_data.py b/src/pyslice/postprocessing/haadf_data.py index 2fbf277..da4df1c 100644 --- a/src/pyslice/postprocessing/haadf_data.py +++ b/src/pyslice/postprocessing/haadf_data.py @@ -8,7 +8,8 @@ from .wf_data import WFData from ..data.pyslice_serial import PySliceSerial, Signal, Dimensions, Dimension, Metadata #from ..data import Signal, Dimensions, Dimension, GeneralMetadata -from pyslice.backend import zeros,to_cpu,mean,sum,absolute,einsum +import pyslice.backend as backend +from pyslice.backend import zeros, to_cpu, mean, sum, absolute, einsum, xp, float_dtype #from ..data.pyslice_serial import PySliceSerial logger = logging.getLogger(__name__) @@ -122,7 +123,7 @@ def __getattr__(self, name): raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'") def getMask(self, inner_mrad: float = 45, outer_mrad: float = 150): - q = xp.sqrt(self._kxs[:,None]**2 + self._kys[None,:]**2) + q = backend.sqrt(self._kxs[:,None]**2 + self._kys[None,:]**2) radius_inner = (inner_mrad * 1e-3) / self.probe.wavelength radius_outer = (outer_mrad * 1e-3) / self.probe.wavelength @@ -161,7 +162,7 @@ def calculateADF(self, inner_mrad: float = 45, outer_mrad: float = 150, preview: #mask[q >= radius_inner] = 1 #mask[q >= radius_outer] = 0 - probe_positions = xp.asarray(self.probe_positions, dtype=float_dtype) + probe_positions = backend.asarray(self.probe_positions, dtype=float_dtype) #for i, x in enumerate(self._xs): # for j, y in enumerate(self._ys): diff --git a/src/pyslice/postprocessing/tacaw_data.py b/src/pyslice/postprocessing/tacaw_data.py index df9ee4c..4fd25d4 100644 --- a/src/pyslice/postprocessing/tacaw_data.py +++ b/src/pyslice/postprocessing/tacaw_data.py @@ -3,10 +3,10 @@ """ import numpy as np from typing import Optional, Tuple, Dict, Any, List, Union -from pathlib import Path import logging, os from .wf_data import WFData from ..data.pyslice_serial import PySliceSerial, Signal, Dimensions, Dimension, Metadata +import pyslice.backend as backend #from ..data import Signal, Dimensions, Dimension, GeneralMetadata #from ..data.pyslice_serial import PySliceSerial from tqdm import tqdm @@ -82,7 +82,7 @@ def __init__(self, # Save computed values before super().__init__ computed_array = self._array - computed_frequencies = self._frequencies + computed_frequencies = backend.to_cpu(self._frequencies) if hasattr(self._frequencies, 'cpu') else self._frequencies # Helper to convert tensors to numpy for Dimensions def to_numpy(x): @@ -203,23 +203,24 @@ def _fft_from_wf_data(self, layer_index: int = None): else: self.n_chunks = len(self._time) // self.chunk_size_time - indices = np.linspace(0, len(self._time), self.n_chunks + 1, dtype=int) + indices = backend.linspace(0, len(self._time), self.n_chunks + 1) + indices = backend.astype(indices, int) dt = self._time[1] - self._time[0] # Compute frequencies from time sampling - self._frequencies = np.fft.fftfreq(self.n_chunks, d=dt) - self._frequencies = np.fft.fftshift(self._frequencies) + self._frequencies = backend.fftfreq(self.n_chunks, d=dt) + self._frequencies = backend.fftshift(self._frequencies) # Perform FFT along time axis (axis=1) for each probe position and k-point # Following abeels.py approach: subtract mean to avoid high zero-frequency peak # then Compute intensity |Ψ(ω,q)|² from the frequency-domain wavefunction if self.chunkFFT: # looping through x (in case super giganormous FFTs blow your ram) - dtype = complex_dtype if self.keep_complex else float_dtype + dtype = backend.complex_dtype if self.keep_complex else backend.float_dtype shape = (wf_layer.shape[0], self.chunk_size_time, wf_layer.shape[2], wf_layer.shape[3]) if self.use_memmap: self._array = memmap(shape, dtype=dtype, filename = self.cache_dir / "tacaw.npy") else: - self._array = xp.zeros(shape, dtype = dtype) + self._array = backend.zeros(shape, dtype=dtype) for i in range(self.n_chunks): i1 = indices[i] @@ -288,7 +289,7 @@ def spectrum(self, probe_index: int = None) -> np.ndarray: # Average all spectra if hasattr(all_spectra[0], 'device'): all_spectra = [to_cpu(s) for s in all_spectra] - spectrum = np.mean(all_spectra, axis=0) + spectrum = backend.mean(backend.asarray(all_spectra), axis=0) else: if probe_index >= len(self.probe_positions): raise ValueError(f"Probe index {probe_index} out of range") @@ -333,7 +334,7 @@ def spectrum_image(self, frequency: float, probe_indices: Optional[List[int]] = if hasattr(probe_intensity_sum, 'cpu'): probe_intensity_sum = probe_intensity_sum.cpu().numpy() else: - probe_intensity_sum = np.sum(probe_intensity) + probe_intensity_sum = backend.sum(probe_intensity) spectrum_intensities.append(probe_intensity_sum) @@ -360,7 +361,7 @@ def diffraction(self, probe_index: int = None, space: str = "reciprocal") -> np. # Average all diffraction patterns if hasattr(all_diffractions[0], 'device'): all_diffractions = [to_cpu(d) for d in all_diffractions] - diffraction_pattern = np.mean(all_diffractions, axis=0) + diffraction_pattern = backend.mean(backend.asarray(all_diffractions), axis=0) else: if probe_index >= len(self.probe_positions): raise ValueError(f"Probe index {probe_index} out of range") @@ -374,7 +375,7 @@ def diffraction(self, probe_index: int = None, space: str = "reciprocal") -> np. diffraction_pattern = to_cpu(diffraction_pattern) if space == "real": - diffraction_pattern = np.absolute(np.fft.ifft2(diffraction_pattern)) + diffraction_pattern = backend.absolute(backend.ifft2(diffraction_pattern)) return diffraction_pattern @@ -402,7 +403,7 @@ def spectral_diffraction(self, frequency: float, probe_index: int = None, space: # Average all spectral diffraction patterns if hasattr(all_spectral_diffractions[0], 'device'): all_spectral_diffractions = [to_cpu(sd) for sd in all_spectral_diffractions] - spectral_diffraction = np.mean(all_spectral_diffractions, axis=0) + spectral_diffraction = backend.mean(backend.asarray(all_spectral_diffractions), axis=0) else: if probe_index >= len(self.probe_positions): raise ValueError(f"Probe index {probe_index} out of range") @@ -415,7 +416,7 @@ def spectral_diffraction(self, frequency: float, probe_index: int = None, space: spectral_diffraction = to_cpu(spectral_diffraction) if space == "real": - spectral_diffraction = np.absolute(np.fft.ifft2(spectral_diffraction)) + spectral_diffraction = backend.absolute(backend.ifft2(spectral_diffraction)) return spectral_diffraction @@ -457,14 +458,14 @@ def masked_spectrum(self, mask: np.ndarray|dict|None = None, probe_index: int = import matplotlib.pyplot as plt fig, ax = plt.subplots() extent = ( np.amin(kxs) , np.amax(kxs) , np.amin(kys) , np.amax(kys) ) - ax.imshow(to_cpu(xp.sum(masked,axis=0).T)[::-1,:], cmap="inferno",extent=extent,aspect=1) + ax.imshow(to_cpu(backend.sum(masked, axis=0)).T[::-1,:], cmap="inferno",extent=extent,aspect=1) ax.set_xlabel("kx") ax.set_ylabel("ky") ax.set_title("masked_spectrum - preview") plt.show() preview=False - spectra.append(to_cpu(xp.sum(masked,axis=(1,2)))) - return np.mean(spectra,axis=0) + spectra.append(to_cpu(backend.sum(masked, axis=(1,2)))) + return to_cpu(backend.mean(spectra,axis=0)) def dispersion(self, kx_path: np.ndarray, ky_path: np.ndarray, probe_index: int = None, space: str = "reciprocal") -> np.ndarray: """ @@ -515,23 +516,23 @@ def dispersion(self, kx_path: np.ndarray, ky_path: np.ndarray, probe_index: int w_slice = self._array[probe_index, w, :, :] # optionally iFFT across kx,ky if space == "real": - w_slice = np.fft.ifft2(w_slice, axes=(1,2)) + w_slice = backend.ifft2(w_slice, axes=(1,2)) # bring to CPU if hasattr(w_slice, 'device'): w_slice = to_cpu(w_slice) # sum across probe positions - w_slice = np.mean(w_slice,axis=0) + w_slice = backend.mean(w_slice,axis=0) # select values at positions for i, (kx_idx, ky_idx) in enumerate(zip(kx_indices, ky_indices)): dispersion[w,i] = w_slice[ kx_idx, ky_idx ] - return np.absolute(dispersion) + return to_cpu(backend.absolute(dispersion)) # Since there are multiple things returnable by the above functions, i'm just offering up a generic heatmap plotter function here, where you pass Z,x,y def plot(self,intensities,xvals,yvals,xlabel="kx ($\\AA^{-1}$)",ylabel="ky ($\\AA^{-1}$)",filename=None,title=None,extent=None): import matplotlib.pyplot as plt fig, ax = plt.subplots() - array = np.absolute(to_cpu(intensities)) # imshow convention: y,x. our convention: x,y + array = backend.absolute(to_cpu(intensities)) # imshow convention: y,x. our convention: x,y aspect = None if isinstance(xvals,str): diff --git a/src/pyslice/postprocessing/wf_data.py b/src/pyslice/postprocessing/wf_data.py index d851ecc..1685f97 100644 --- a/src/pyslice/postprocessing/wf_data.py +++ b/src/pyslice/postprocessing/wf_data.py @@ -159,15 +159,22 @@ def counts(self,N): if self.probability is None: self.probability = self._array npt,nt,nx,ny,nl = self._array.shape - ary = self._array/xp.sum(xp.absolute(self._array)) # normalized: ensure values arerelative probabilities of each voxel - ary = xp.absolute(ary.reshape(npt*nt*nx*ny*nl)) + ary = self._array/backend.sum(backend.absolute(self._array)) # normalized: ensure values arerelative probabilities of each voxel + ary = backend.absolute(ary.reshape(npt*nt*nx*ny*nl)) self.buckets = zeros(len(ary)+1,type_match=ary) self.buckets[1:] = cumsum(ary) # cumsum means we can "select" a voxel with a random float 0-1 detector_hits = asarray(randfloats(N)) # randomly "select" histogram bins based on each bin's relative size hist = histogram(detector_hits,bins=self.buckets) self._array = asarray(hist.reshape((npt,nt,nx,ny,nl))) - def plot_reciprocal(self,filename=None,whichProbe="mean",whichTimestep="mean",powerscaling=0.25,extent=None,nuke_zerobeam=False,title=None): + def plot_reciprocal(self, + filename=None, + whichProbe="mean", + whichTimestep="mean", + powerscaling=0.25, + extent=None, + nuke_zerobeam=False, + title=None): import matplotlib.pyplot as plt fig, ax = plt.subplots() @@ -184,7 +191,7 @@ def plot_reciprocal(self,filename=None,whichProbe="mean",whichTimestep="mean",po whichTimestep = [whichTimestep] for p in whichProbe: for t in whichTimestep: - layer = absolute(raw[p,t,:,:]) + layer = backend.absolute(raw[p,t,:,:]) if isinstance(raw,np.memmap): layer = asarray(layer) array+=layer @@ -233,7 +240,7 @@ def plot_reciprocal(self,filename=None,whichProbe="mean",whichTimestep="mean",po # Transpose for imshow convention array = array.T # imshow convention: y,x. our convention: x,y if nuke_zerobeam: - array[np.argmin(np.absolute(kys_np)),np.argmin(np.absolute(kxs_np))]=0 + array[np.argmin(backend.absolute(kys_np)),np.argmin(backend.absolute(kxs_np))]=0 # Convert to numpy array if it's a tensor # Apply powerscaling to intensity (|Ψ|²) @@ -370,8 +377,8 @@ def propagate_free_space(self,dz): # UNITS OF ANGSTROM self._array = P[None,None,:,:,None] * self._array def addSpatialDecoherence(self,sigma_dz,N): - dzs = np.linspace(-2*sigma_dz,2*sigma_dz,N) # suppose N=25 - amplitudes = np.exp(-dzs**2/sigma_dz**2) + dzs = backend.linspace(-2*sigma_dz,2*sigma_dz,N) # suppose N=25 + amplitudes = backend.exp(-dzs**2/sigma_dz**2) self._array = self._array[:,None,:,:,:,:] * backend.ones(N)[None,:,None,None,None,None] # n_probes,nt,nx,ny,nl --> nc,npt,nt,nx,ny,nl = self._array.shape # suppose nc=10 (addTemporalDecoherence created 10 wavelengths) kx_grid, ky_grid = backend.meshgrid(self._kxs, self._kys, indexing='ij') From 0ac1e2cc251e60e6f3b568ab69ca99b63382537c Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Wed, 25 Mar 2026 17:52:27 -0700 Subject: [PATCH 07/14] Use AGG backend for tests --- tests/00_probe.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/00_probe.py b/tests/00_probe.py index 26f11d3..1fb3572 100644 --- a/tests/00_probe.py +++ b/tests/00_probe.py @@ -1,3 +1,5 @@ +import os +os.environ['MPLBACKEND'] = 'Agg' import sys,os,time try: import pyslice From 1dc1d4fdf8f017950e4535f8788bc494dc6ab74c Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Wed, 25 Mar 2026 18:57:52 -0700 Subject: [PATCH 08/14] More device and backend cleanups. Test calculation in tests/test_pyslice_abtem.ipynb looks good for NumPy and PyTorch CPU backend. --- src/pyslice/multislice/calculators.py | 19 +- src/pyslice/multislice/multislice.py | 25 +- src/pyslice/multislice/potentials.py | 7 +- tests/test_pyslice_abtem.ipynb | 766 ++++++++++++++++++++++++++ 4 files changed, 792 insertions(+), 25 deletions(-) create mode 100644 tests/test_pyslice_abtem.ipynb diff --git a/src/pyslice/multislice/calculators.py b/src/pyslice/multislice/calculators.py index d822a35..6d9609e 100644 --- a/src/pyslice/multislice/calculators.py +++ b/src/pyslice/multislice/calculators.py @@ -204,10 +204,12 @@ def setup( # cache key is calculated TWICE: once during setup (so the user only needs to setup to infer where their cache folder will go), and again during run (just in case the user does something funky) # Generate cache key and setup output directory - self.cache_key = self._generate_cache_key(self.trajectory, self.aperture, self.voltage_eV, - self.slice_thickness, self.sampling, self.probe_positions, - self.base_probe.spatial_decoherence, self.base_probe.temporal_decoherence, - self.base_probe._array) + self.cache_key = self._generate_cache_key( + self.trajectory, self.aperture, self.voltage_eV, + self.slice_thickness, self.sampling, self.probe_positions, + self.base_probe.spatial_decoherence, self.base_probe.temporal_decoherence, + self.base_probe._array, + ) #print(cache_key) self.output_dir = Path("psi_data/" + ("torch" if hasattr(self.base_probe._array, 'device') else "numpy") + "_"+self.cache_key) #self.output_dir.mkdir(parents=True, exist_ok=True) @@ -353,7 +355,14 @@ def run(self) -> WFData: frames_cached += 1 else: #print("create potential") ; start = time.time() - potential = Potential(self.xs, self.ys, self.zs, positions, atom_type_names, kind="kirkland", device=self.device, slice_axis=self.slice_axis, progress=show_progress, cache_dir=cache_file.parent if "potentials" in self.cache_levels else None, frame_idx = frame_idx) + potential = Potential( + self.xs, self.ys, self.zs, + positions, atom_type_names, + kind="kirkland", device=self.device, + slice_axis=self.slice_axis, + progress=show_progress, + cache_dir=cache_file.parent if "potentials" in self.cache_levels else None, + frame_idx = frame_idx) #print("(done)",time.time()-start) #n_probes = nc*npt nc,npt,nx,ny = self.base_probe._array.shape ; npt = len(self.base_probe.probe_positions) diff --git a/src/pyslice/multislice/multislice.py b/src/pyslice/multislice/multislice.py index 196b193..e07a5ea 100644 --- a/src/pyslice/multislice/multislice.py +++ b/src/pyslice/multislice/multislice.py @@ -3,7 +3,6 @@ from tqdm import tqdm import logging, time -TORCH_BACKEND = backend.TORCH_BACKEND logger = logging.getLogger(__name__) @@ -128,17 +127,14 @@ def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, pre self.spatial_decoherence = None self.gaussianVOA = gaussianVOA - # Set up device kwargs for unified xp interface (same as Potential class) - device_kwargs = {'device': self.device, 'dtype': self.dtype} - self.stay_reciprocal = stay_reciprocal self.crop_reciprocal = crop_reciprocal #if self.crop_reciprocal: # user asked for kspace to be, say, 100 pixels, but right now it's 350... # self.crop_reciprocal = (min(nx,ny)-self.crop_reciprocal)//2 # so we need to chop 125 off each side - self.kxs = backend.fftfreq(nx, d=dx, **device_kwargs) - self.kys = backend.fftfreq(ny, d=dy, **device_kwargs) + self.kxs = backend.fftfreq(nx, d=dx, device=self.device, dtype=self.dtype) + self.kys = backend.fftfreq(ny, d=dy, device=self.device, dtype=self.dtype) if not array is None: # Allow construction of a Probe object with a passed array instead of building it below. used by create_batched_probes if backend.TORCH_BACKEND and hasattr(array, 'to'): @@ -367,9 +363,8 @@ def placeProbe(self,array,x,y): if self.cropping: i1=self.nx//2-self.cropping//2 ; i2=i1+self.cropping # |_______i1___.___i2_______| for initial centered probe at lx/2,ly/2 j1=self.ny//2-self.cropping//2 ; j2=j1+self.cropping - device_kwargs = {'device': self.device, 'dtype': self.dtype} - kxs = backend.fftfreq(self.cropping, d=self.dx, **device_kwargs) - kys = backend.fftfreq(self.cropping, d=self.dy, **device_kwargs) + kxs = backend.fftfreq(self.cropping, d=self.dx, device=self.device, dtype=self.dtype) + kys = backend.fftfreq(self.cropping, d=self.dy, device=self.device, dtype=self.dtype) dpx = dx//self.dx ; dpy = dy//self.dy # pixel shifts offset_x = i1+dpx ; offset_y = j1+dpy dx-=dpx*self.dx ; dy-=dpy*self.dy # update subpixel shifts @@ -516,7 +511,7 @@ class PrismProbe: def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, preview=False, nkx = 25, nky=None, kth=1): # DEVICE AND DTYPE SETUP - if TORCH_BACKEND: + if backend.TORCH_BACKEND: # Auto-detect device if not specified (same logic as Potential class) if device is None: device, dtype, complex_dtype = backend.device_and_precision() @@ -548,7 +543,6 @@ def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, pre else: self.xs = xs self.ys = ys - device_kwargs = {'device': self.device, 'dtype': self.dtype} if self.use_torch else {} self.kxs = backend.fftshift(backend.fftfreq(self.nx, d=self.dx)) self.kys = backend.fftshift(backend.fftfreq(self.ny, d=self.dy)) self._array = backend.zeros((1,1,self.nx,self.ny),dtype=self.complex_dtype) @@ -624,7 +618,7 @@ def calculateProbesFromS(self,array,positions,chunksize=100,load_into=None,ADF=F #probe_k = backend.fft.fftshift(probe.placeProbe(ary,x,y,realspace=False)[0][0,:,:]) # strategy 3, stack of probes #probes = Probe(self.xs, self.ys, self.mrad, self.eV, probe_positions = positions[n:n+chunksize]) - #kwarg = {"dim":(-2,-1)} if TORCH_BACKEND else {"axes":(-2,-1)} + #kwarg = {"dim":(-2,-1)} if backend.TORCH_BACKEND else {"axes":(-2,-1)} #probe_ks = backend.fft.fftshift(backend.fft.fft2(probes._array[0,:,:,:],**kwarg),**kwarg) # note you CAN generate the probe pre-cropped (use arg crop_reciprocal, then skip the self.i1:-self.i1 indexing), but this doesn't seem to save a whole lot of time... @@ -740,7 +734,7 @@ def Propagate(probe, potential, device=None, progress=False, onthefly=True, stor sigma = (2 * backend.pi) / (probe_wavelengths * probe_eVs) * \ (E0_eV + probe_eVs) / (2 * E0_eV + probe_eVs) # wavelength and eVs now have length of n_probes #print("propagate sigma",sigma) - #if TORCH_BACKEND: + #if backend.TORCH_BACKEND: # #sigma_dtype = torch.float32 if device.type == 'mps' else torch.float64 # sigma = torch.tensor(sigma, dtype=float_dtype, device=device) @@ -751,9 +745,8 @@ def Propagate(probe, potential, device=None, progress=False, onthefly=True, stor # All tensors should already be on the correct device from creation kx,ky = potential.kxs, potential.kys if probe.cropping: - device_kwargs = {'device': probe.device, 'dtype': probe.dtype} - kx = backend.fftfreq(probe.cropping, d=probe.dx, **device_kwargs) - ky = backend.fftfreq(probe.cropping, d=probe.dy, **device_kwargs) + kx = backend.fftfreq(probe.cropping, d=probe.dx, device=probe.device, dtype=probe.dtype) + ky = backend.fftfreq(probe.cropping, d=probe.dy, device=probe.device, dtype=probe.dtype) kx_grid, ky_grid = backend.meshgrid(kx, ky, indexing='ij') k_squared = kx_grid**2 + ky_grid**2 diff --git a/src/pyslice/multislice/potentials.py b/src/pyslice/multislice/potentials.py index f5bbebe..3cdb859 100644 --- a/src/pyslice/multislice/potentials.py +++ b/src/pyslice/multislice/potentials.py @@ -245,8 +245,7 @@ def calculateSlice(slice_idx): # TODO i'm hard-coding the chunk size is 2000 atoms per layer which is HUGE, so this shouldn't affect anyone but me, but we really ought to do a "smarter" job of picking the chunk size chunk_indices = list(np.arange(len(atomsx)))[::2000]+[len(atomsx)] - device_kwargs = {'device': self.device} if self.device is not None else {} - shape_factor = backend.zeros((self.nx,self.ny), dtype=self.complex_dtype, **device_kwargs) + shape_factor = backend.zeros((self.nx,self.ny), dtype=self.complex_dtype, device=self.device) for i1,i2 in zip(chunk_indices[:-1],chunk_indices[1:]): atx = atomsx[i1:i2] @@ -273,7 +272,6 @@ def calculateSlice(slice_idx): dx = self.xs[1] - self.xs[0] dy = self.ys[1] - self.ys[0] fe_to_V = 47.87764737 # 2πℏ²/m_e in V·Å² (Kirkland, Eq C.1 prefactor) - print(fe_to_V) Z = real * fe_to_V / (dx * dy) if cache_file is not None: @@ -332,7 +330,8 @@ def plot(self,filename=""): fig, ax = plt.subplots() array = backend.sum( backend.absolute(self.array), - axis=2).T # imshow convention: y,x. our convention: x,y + axis=2, + ).T # imshow convention: y,x. our convention: x,y # Convert to CPU if on GPU/MPS device if hasattr(array, 'cpu'): array = array.cpu() diff --git a/tests/test_pyslice_abtem.ipynb b/tests/test_pyslice_abtem.ipynb new file mode 100644 index 0000000..f9d191c --- /dev/null +++ b/tests/test_pyslice_abtem.ipynb @@ -0,0 +1,766 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "74e15100-45f2-4342-a851-6b23807d383b", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ['PYSLICE_BACKEND'] = 'torch'\n", + "os.environ['PYSLICE_DEVICE'] = 'cpu'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "310871ae-6738-4467-a7d1-dc8ae80bbcd5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu \n", + "failed to import pySEA: No module named 'pySEA'\n", + "loaded\n", + "Created hBN supercell: 4000 atoms, box = 50.1 × 43.4 Å\n", + "Saved structure plot\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing frames: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:25<00:00, 2.55s/frame]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved diffraction pattern\n", + "Saved projected potential (optional diagnostic)\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "TEM Diffraction: Structure → Potential → Diffraction Pattern\n", + "=============================================================\n", + "\n", + "The simplest multislice workflow: illuminate a structure with a parallel\n", + "electron beam and compute the diffraction pattern.\n", + "\n", + "Along the way we visualize:\n", + " 1. The atomic structure (projected along the beam direction)\n", + " 2. The resulting electron diffraction pattern\n", + " 3. (Optional) The projected electrostatic potential — for diagnostic purposes\n", + "\n", + "No external input files are needed — the structure is created from scratch.\n", + "\"\"\"\n", + "\n", + "import os\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from ase import Atoms\n", + "from pyslice import Loader, MultisliceCalculator, Potential\n", + "\n", + "print('loaded')\n", + "\n", + "os.makedirs(\"outputs\", exist_ok=True)\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 1. Build an hBN monolayer with ASE\n", + "# ---------------------------------------------------------------------------\n", + "# Orthorhombic unit cell (4 atoms) derived from the hexagonal lattice.\n", + "# This ensures a perfectly periodic orthogonal box for multislice.\n", + "a = 2.504 # hBN lattice parameter (Å)\n", + "b = a * np.sqrt(3)\n", + "c = 3.392 # z spacing (vacuum)\n", + "\n", + "unit_cell = Atoms(\n", + " symbols=[\"B\", \"N\", \"B\", \"N\"],\n", + " positions=[\n", + " [0.0, b / 3, c / 2],\n", + " [a / 2, b / 6, c / 2],\n", + " [a / 2, 5 * b / 6, c / 2],\n", + " [0.0, 2 * b / 3, c / 2],\n", + " ],\n", + " cell=[a, b, c],\n", + " pbc=True,\n", + ")\n", + "reps = (20, 10, 5)\n", + "atoms = unit_cell * reps # 4000 atoms, ~50 × 43 × 17 Å (5 layers)\n", + "print(f\"Created hBN supercell: {len(atoms)} atoms, \"\n", + " f\"box = {atoms.cell[0,0]:.1f} × {atoms.cell[1,1]:.1f} Å\")\n", + "\n", + "# Load into PySlice and add frozen-phonon displacements\n", + "trajectory = Loader(atoms=atoms).load()\n", + "trajectory = trajectory.generate_random_displacements(\n", + " n_displacements=10, sigma=0.05, seed=0,\n", + ")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 2. Plot the atomic structure (xy projection, first layer only)\n", + "# ---------------------------------------------------------------------------\n", + "fig, ax = plt.subplots(figsize=(5, 5))\n", + "colors = {\"B\": \"#1f77b4\", \"N\": \"#ff7f0e\"}\n", + "for atom_type in np.unique(trajectory.atom_types):\n", + " mask = trajectory.atom_types == atom_type\n", + " pos = trajectory.positions[0, mask]\n", + " # Show only the first layer to avoid overlapping markers\n", + " z_mid = pos[:, 2].min() + 0.5\n", + " layer_mask = pos[:, 2] < z_mid\n", + " pos = pos[layer_mask]\n", + " label = str(atom_type)\n", + " ax.scatter(pos[:, 0], pos[:, 1], c=colors.get(label, \"gray\"),\n", + " s=60, label=label, edgecolors=\"k\", linewidths=0.5)\n", + "ax.set_xlabel(\"x (Å)\")\n", + "ax.set_ylabel(\"y (Å)\")\n", + "ax.set_aspect(\"equal\")\n", + "ax.legend()\n", + "ax.set_title(\"hBN monolayer (xy projection)\")\n", + "fig.tight_layout()\n", + "fig.savefig(\"outputs/tem_structure.png\", dpi=150)\n", + "plt.close(fig)\n", + "print(\"Saved structure plot\")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 3. Set up parallel-beam multislice\n", + "# ---------------------------------------------------------------------------\n", + "calc = MultisliceCalculator()\n", + "calc.setup(\n", + " trajectory,\n", + " aperture=0, # Parallel beam (plane wave)\n", + " voltage_eV=100e3,\n", + " sampling=0.05,\n", + " slice_thickness=0.5,\n", + " cache_levels=[],\n", + ")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 4. Run multislice and plot the diffraction pattern\n", + "# ---------------------------------------------------------------------------\n", + "# MultisliceCalculator builds the potential internally — you do NOT need to\n", + "# construct a Potential object yourself. We do it below purely to visualize\n", + "# what the electrons scatter from.\n", + "wf = calc.run()\n", + "wf.plot_reciprocal(\n", + " \"outputs/tem_diffraction.png\",\n", + "# nuke_zerobeam=True,\n", + " powerscaling=0.05,\n", + " extent=[-2, 2, -2, 2],\n", + ")\n", + "plt.close()\n", + "print(\"Saved diffraction pattern\")\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# 5. (Optional) Visualize the projected potential\n", + "# ---------------------------------------------------------------------------\n", + "# This is NOT part of the normal workflow — just a diagnostic visualization.\n", + "# The Potential class lets you inspect the electrostatic potential that the\n", + "# multislice algorithm scatters electrons from.\n", + "potential_pyslice = Potential(\n", + " calc.xs, calc.ys, calc.zs,\n", + " trajectory.positions[0], list(trajectory.atom_types),\n", + " kind=\"kirkland\", device=calc.device, slice_axis=calc.slice_axis,\n", + ")\n", + "potential_pyslice.build()\n", + "potential_pyslice.plot(filename=\"outputs/tem_potential.png\")\n", + "plt.close()\n", + "print(\"Saved projected potential (optional diagnostic)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5f4022fe-1a4b-498b-8fe5-4b211fae922c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-50.0, 50.0)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from numpy.fft import fftshift\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "wavs_pyslice = wf.array\n", + "if type(wavs_pyslice) != np.ndarray:\n", + " wavs_pyslice = wavs_pyslice.numpy()\n", + "wavs_pyslice = np.copy(wavs_pyslice)\n", + "wavs_pyslice /= np.sqrt((np.abs(wavs_pyslice)**2).sum(axis=(-2,-3), keepdims=True))\n", + "\n", + "wavelength = wf.probe.wavelength\n", + "if hasattr(wavelength, 'cpu'):\n", + " wavelength = wavelength.numpy()\n", + "\n", + "thetax = fftshift(wf.probe.kxs) * wavelength * 1e3\n", + "thetay = fftshift(wf.probe.kys) * wavelength * 1e3\n", + "\n", + "extent = (thetax[0], thetax[-1], thetay[0], thetay[-1])\n", + "\n", + "intensity = (np.abs(wavs_pyslice[0,...,0])**2).mean(axis=(0,))\n", + "\n", + "im = ax.imshow(np.log10(intensity.T+1e-40), vmin=-10, extent=extent, origin='lower')\n", + "\n", + "fig.colorbar(im, ax=ax)\n", + "\n", + "ax.set_xlim(left=-50, right=50)\n", + "ax.set_ylim(bottom=-50, top=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "89484d18-cd55-4734-b5bc-4cac80a3d0c7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "thetax = np.fft.fftshift(wf.probe.kxs) * wavelength * 1e3\n", + "thetay = np.fft.fftshift(wf.probe.kys) * wavelength * 1e3\n", + "mask1 = np.floor(np.abs(thetax)) <= 150\n", + "mask2 = np.floor(np.abs(thetay)) <= 5\n", + "\n", + "thetax = thetax[mask1]\n", + "intensity = (np.abs(wavs_pyslice[0,...,0])**2).mean(axis=(0,))\n", + "\n", + "ax.semilogy(thetax, intensity[np.ix_(mask1, mask2)].sum(axis=-1), color='tab:orange', label='PySlice')\n", + "\n", + "ax.set_xlim(left=-150, right=150)\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bd4bfc63-44ac-4870-8c64-983464c3da1f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "thetax = np.fft.fftshift(wf.probe.kxs) * wavelength * 1e3\n", + "thetay = np.fft.fftshift(wf.probe.kys) * wavelength * 1e3\n", + "mask1 = np.floor(np.abs(thetax)) <= 5\n", + "mask2 = np.floor(np.abs(thetay)) <= 150\n", + "\n", + "thetay = thetay[mask2]\n", + "intensity = (np.abs(wavs_pyslice[0,...,0])**2).mean(axis=(0,))\n", + "\n", + "ax.semilogy(thetay, intensity[np.ix_(mask1, mask2)].sum(axis=0), color='tab:orange', label='PySlice')\n", + "\n", + "ax.set_xlim(left=-150, right=150)\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e25f68e4-ca3e-4f61-945a-f891e03b54ba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([7.56378678e+11, 7.56378675e+11, 7.56378726e+11, 7.56378677e+11,\n", + " 7.56378682e+11, 7.56378677e+11, 7.56378701e+11, 7.56378715e+11,\n", + " 7.56378734e+11, 7.56378688e+11])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyslice import backend\n", + "backend.sum(backend.absolute(wf.array)**2, axis=(0,2,3,4))" + ] + }, + { + "cell_type": "markdown", + "id": "caeae2b5-9914-4e35-adf1-02d87cbb4045", + "metadata": {}, + "source": [ + "# *ab*TEM" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e1c46c22-0cd9-4513-a6fa-27951410935d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96])]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "atoms_test = [trajectory.select_timesteps((i,)).to_ase() for i in range(trajectory.n_frames)]\n", + "atoms_test" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3549b987-91b3-4c45-a532-bff0426661c6", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84bf88c3f72443d9a68b2f3f26c3bade", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "tasks: 0%| | 0/52 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "extent = (\n", + " measurements[0].angular_limits[0][0], \n", + " measurements[0].angular_limits[0][-1],\n", + " measurements[0].angular_limits[1][0],\n", + " measurements[0].angular_limits[1][-1],\n", + ")\n", + "\n", + "intensity = np.mean(np.abs(wavs_abtem)**2, axis=0)[0,0,...]\n", + "\n", + "im = ax.imshow(np.log10(intensity.T+1e-40), vmin=-10, extent=extent, origin='lower')\n", + "\n", + "fig.colorbar(im, ax=ax)\n", + "\n", + "ax.set_xlim(left=-50, right=50)\n", + "ax.set_ylim(bottom=-50, top=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ca53208b-1b7c-4ab8-9c4b-2cf66f532631", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(407, 5)\n", + "(409, 5)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(12,6))\n", + "\n", + "thetax = measurements[0].angular_coordinates[0]\n", + "thetay = measurements[0].angular_coordinates[1]\n", + "mask1 = np.floor(np.abs(thetax)) <= 150\n", + "mask2 = np.floor(np.abs(thetay)) <= 1\n", + "#print(thetax)\n", + "intensity = np.mean(np.abs(wavs_abtem)**2, axis=0)[0,0,...]\n", + "\n", + "print(intensity[np.ix_(mask1, mask2)].shape)\n", + "ax.semilogy(thetax, intensity[np.ix_(mask1, mask2)].sum(axis=-1), label='abtem')\n", + "\n", + "thetax = fftshift(wf.probe.kxs) * wf.probe.wavelength * 1e3\n", + "thetay = fftshift(wf.probe.kys) * wf.probe.wavelength * 1e3\n", + "mask1 = np.floor(np.abs(thetax)) <= 150\n", + "mask2 = np.floor(np.abs(thetay)) <= 1\n", + "thetax = thetax[mask1]\n", + "#print(thetax)\n", + "intensity = (np.abs(wavs_pyslice[0,...,0])**2).mean(axis=0)\n", + "\n", + "print(intensity[np.ix_(mask1, mask2)].shape)\n", + "\n", + "ax.semilogy(thetax, intensity[np.ix_(mask1, mask2)].sum(axis=-1), label='PySlice', ls='--')\n", + "\n", + "ax.set_xlim(left=-150, right=150)\n", + "ax.set_ylim(bottom=1e-9)\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "808f6ec8-f56e-4e4a-9adb-697de6db8e6f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(12,6))\n", + "\n", + "thetax = measurements[0].angular_coordinates[0]\n", + "thetay = measurements[0].angular_coordinates[1]\n", + "mask1 = np.floor(np.abs(thetax)) <= 1\n", + "mask2 = np.floor(np.abs(thetay)) <= 150\n", + "\n", + "intensity = np.mean(np.abs(wavs_abtem)**2, axis=0)[0,0,...]\n", + "\n", + "ax.semilogy(thetay, intensity[np.ix_(mask1, mask2)].sum(axis=0), label='abtem')\n", + "\n", + "thetax = fftshift(wf.probe.kxs) * wf.probe.wavelength * 1e3\n", + "thetay = fftshift(wf.probe.kys) * wf.probe.wavelength * 1e3\n", + "mask1 = np.floor(np.abs(thetax)) <= 1\n", + "mask2 = np.floor(np.abs(thetay)) <= 150\n", + "\n", + "thetay = thetay[mask2]\n", + "intensity = (np.abs(wavs_pyslice[0,...,0])**2).mean(axis=0)\n", + "\n", + "ax.semilogy(thetay, intensity[np.ix_(mask1, mask2)].sum(axis=0), label='PySlice', ls='--')\n", + "\n", + "ax.set_xlim(left=-150, right=150)\n", + "ax.set_ylim(bottom=1e-9)\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a77e5db2-8bc4-4dd4-9a0c-346bfb2efc1a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "xs = np.array(potential_abtem.axes_metadata[2].coordinates(potential_abtem.shape[2]))\n", + "ys = np.array(potential_abtem.axes_metadata[3].coordinates(potential_abtem.shape[3]))\n", + "\n", + "mask1 = np.floor(np.abs(xs)) <= 1\n", + "mask2 = np.floor(np.abs(ys)) <= 10\n", + "xs = xs[mask1]\n", + "\n", + "intensity = np.abs(potential_abtem.to_data_array().to_numpy()[0,...]).sum(axis=0)\n", + "ax.semilogy(xs, intensity[np.ix_(mask1, mask2)].sum(axis=1), label='abtem')\n", + "\n", + "\n", + "xs = np.array(list(potential_pyslice.xs))\n", + "ys = np.array(list(potential_pyslice.ys))\n", + "\n", + "mask1 = np.floor(np.abs(xs)) <= 1\n", + "mask2 = np.floor(np.abs(ys)) <= 10\n", + "xs = xs[mask1]\n", + "\n", + "intensity = potential_pyslice.array.sum(axis=(-1,))\n", + "\n", + "ax.semilogy(xs, intensity[np.ix_(mask1, mask2)].sum(axis=1), color='tab:orange', label='PySlice')\n", + "\n", + "#ax.set_xlim(left=-150, right=150)\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "519a5651-2dfd-4223-acc0-b4475221dc64", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "xs = np.array(potential_abtem.axes_metadata[2].coordinates(potential_abtem.shape[2]))\n", + "ys = np.array(potential_abtem.axes_metadata[3].coordinates(potential_abtem.shape[3]))\n", + "\n", + "mask1 = np.floor(np.abs(xs)) <= 1\n", + "mask2 = np.floor(np.abs(ys)) <= 10\n", + "ys = ys[mask2]\n", + "\n", + "intensity = np.abs(potential_abtem.to_data_array().to_numpy()[0,...]).sum(axis=0)\n", + "ax.semilogy(ys, intensity[np.ix_(mask1, mask2)].sum(axis=0), label='abtem')\n", + "\n", + "\n", + "xs = np.array(list(potential_pyslice.xs))\n", + "ys = np.array(list(potential_pyslice.ys))\n", + "\n", + "mask1 = np.floor(np.abs(xs)) <= 1\n", + "mask2 = np.floor(np.abs(ys)) <= 10\n", + "ys = ys[mask2]\n", + "\n", + "intensity = potential_pyslice.array.sum(axis=(-1,))\n", + "\n", + "ax.semilogy(ys, intensity[np.ix_(mask1, mask2)].sum(axis=0), color='tab:orange', label='PySlice')\n", + "\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46bd964c-1107-491b-a884-0131e624620b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 075bced88488e37c3a1f8ddedaf28bd0e14edccd Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Fri, 27 Mar 2026 13:31:27 -0700 Subject: [PATCH 09/14] Reworked the backend with the help of Claude. --- src/pyslice/backend.py | 191 ++++++++++++++++++++++------------------- 1 file changed, 103 insertions(+), 88 deletions(-) diff --git a/src/pyslice/backend.py b/src/pyslice/backend.py index d95458e..4b156cf 100644 --- a/src/pyslice/backend.py +++ b/src/pyslice/backend.py @@ -1,12 +1,19 @@ # backend.py - Backend abstraction layer for NumPy/PyTorch support import numpy as np -from typing import Any, Optional, Union +from typing import Any, Optional +import logging + +logger = logging.getLogger(__name__) +logger.addHandler(logging.NullHandler()) + +_rng = np.random.default_rng() try: import torch xp = torch # type: ignore[assignment] TORCH_AVAILABLE = True except ImportError: + torch = None # explicit sentinel xp = np # type: ignore[assignment] TORCH_AVAILABLE = False @@ -65,7 +72,9 @@ def device_and_precision(device_spec=None): # Determine default device and dtypes at import time DEFAULT_DEVICE, DEFAULT_FLOAT_DTYPE, DEFAULT_COMPLEX_DTYPE = device_and_precision() -print(DEFAULT_DEVICE, DEFAULT_FLOAT_DTYPE, DEFAULT_COMPLEX_DTYPE) +logger.debug("Default device: %s", DEFAULT_DEVICE) +logger.debug("Default float dtype: %s", DEFAULT_FLOAT_DTYPE) +logger.debug("Default complex dtype: %s", DEFAULT_COMPLEX_DTYPE) # Convenience aliases float_dtype = DEFAULT_FLOAT_DTYPE @@ -73,28 +82,43 @@ def device_and_precision(device_spec=None): pi = xp.pi +_NUMPY_FLOAT_DTYPES = {np.float32, np.float64} +_NUMPY_COMPLEX_DTYPES = {np.complex64, np.complex128} +_TORCH_FLOAT_DTYPES = {torch.float32, torch.float64} if TORCH_AVAILABLE else set() +_TORCH_COMPLEX_DTYPES = {torch.complex64, torch.complex128} if TORCH_AVAILABLE else set() + +FLOAT_DTYPES = _NUMPY_FLOAT_DTYPES | _TORCH_FLOAT_DTYPES +COMPLEX_DTYPES = _NUMPY_COMPLEX_DTYPES | _TORCH_COMPLEX_DTYPES + +_TORCH_TO_NUMPY_DTYPE: dict = { + torch.complex128: np.complex128, + torch.complex64: np.complex64, + torch.float64: np.float64, + torch.float32: np.float32, +} if TORCH_AVAILABLE else {} + def asarray(arraylike, dtype=None, device=None): """Convert array-like object to backend array (NumPy or PyTorch tensor).""" if dtype is None: dtype = DEFAULT_FLOAT_DTYPE if device is None: device = DEFAULT_DEVICE - # Handle complex to real casting - if dtype is not None and 'float' in str(dtype).lower() and hasattr(arraylike, 'dtype') and 'complex' in str(arraylike.dtype).lower(): + + # Handle complex to real casting - only strip imaginary part when target is real + input_dtype = getattr(arraylike, 'dtype', None) + if dtype in FLOAT_DTYPES and input_dtype in COMPLEX_DTYPES: arraylike = arraylike.real + if TORCH_BACKEND: if hasattr(arraylike, 'detach'): # it's already a tensor - array = arraylike.detach().clone() - if dtype is not None: - array = array.to(dtype) - if device is not None: - array = array.to(device) + array = arraylike.detach().clone().to(dtype=dtype, device=device) else: - array = xp.tensor(arraylike, dtype=dtype, device=device) + array = torch.tensor(arraylike, dtype=dtype, device=device) else: - array = xp.asarray(arraylike, dtype=dtype) + array = np.asarray(arraylike, dtype=dtype) return array + def astype(arraylike,dtype): if hasattr(arraylike,"to"): # torch return arraylike.to(dtype) @@ -109,7 +133,7 @@ def zeros(dims, dtype=None, device=None, type_match=None): dtype = type_match.dtype if device is None and hasattr(type_match, "device"): device = type_match.device - if type(type_match) in [np.memmap, np.ndarray]: + if isinstance(type_match, (np.ndarray, np.memmap)): return np.zeros(dims, dtype=dtype) # Set defaults @@ -119,7 +143,9 @@ def zeros(dims, dtype=None, device=None, type_match=None): device=DEFAULT_DEVICE # string handling for dtype, "float" --> float if isinstance(dtype,str): - dtype={"float":DEFAULT_FLOAT_DTYPE,"complex":DEFAULT_COMPLEX_DTYPE,"int":int}[dtype] + dtype={"float": DEFAULT_FLOAT_DTYPE, + "complex": DEFAULT_COMPLEX_DTYPE, + "int": xp.int64}[dtype] # infer if we're using torch or numpy (numpy does not take device arg) if TORCH_BACKEND: array = xp.zeros(dims, dtype=dtype, device=device) @@ -127,17 +153,19 @@ def zeros(dims, dtype=None, device=None, type_match=None): array = xp.zeros(dims, dtype=dtype) return array -def memmap(dims,dtype=DEFAULT_FLOAT_DTYPE,filename=None): + +def memmap(dims, dtype=None, filename=None): + if dtype is None: + dtype = DEFAULT_FLOAT_DTYPE from numpy.lib.format import open_memmap if filename is None: - print("WARNING: memmap attempted without filename, falling back to zeros") + logger.warning("memmap attempted without filename, falling back to zeros") return zeros(dims,dtype) # cast to numpy dtypes so we can use numpy memmaps - if xp != np and dtype in [ xp.complex128, xp.complex64, xp.float64, xp.float32 ]: - dtype = { xp.complex128:np.complex128, xp.complex64:np.complex64, - xp.float64:np.float64, xp.float32:np.float32 }[ dtype ] - mode = 'w+' #'r+' if os.path.exists(filename) else 'w+' - #print("creating memmap",mode,dtype,dims,"->",filename) + if TORCH_BACKEND and dtype in [ xp.complex128, xp.complex64, xp.float64, xp.float32 ]: + dtype = _TORCH_TO_NUMPY_DTYPE[ dtype ] + mode = 'w+' + logger.debug("creating memmap mode=%s dtype=%s dims=%s filename=%s", mode, dtype, dims, filename) return open_memmap(filename, dtype=dtype, mode=mode, shape=dims) @@ -148,13 +176,12 @@ def absolute(x): return xp.absolute(x) -def reshape(array,shape): - if xp != np and type(array) == np.memmap: - return np.reshape(array,shape) - return xp.reshape(array,shape) - -def ones(dims, dtype=DEFAULT_FLOAT_DTYPE, device=DEFAULT_DEVICE): +def ones(dims, dtype=None, device=None): """Create a one-filled array.""" + if dtype is None: + dtype = DEFAULT_FLOAT_DTYPE + if device is None: + device = DEFAULT_DEVICE if TORCH_BACKEND: return xp.ones(dims, dtype=dtype, device=device) else: @@ -173,7 +200,7 @@ def fftfreq(n, d=1.0, dtype=None, device=None): if device is None: device = DEFAULT_DEVICE if TORCH_BACKEND: - print(device, dtype) + logger.debug("Creating FFT frequency array with device=%s, dtype=%s", device, dtype) return xp.fft.fftfreq(n, d, dtype=dtype, device=device) else: return xp.fft.fftfreq(n, d).astype(dtype) @@ -322,28 +349,30 @@ def einsum(subscripts, *operands, **kwargs): operands = [ to_cpu(o) for o in operands ] return np.einsum(subscripts, *operands, optimize=True, **kwargs) -def to_cpu(array): - if type(array) in [ np.ndarray, np.memmap ]: - return array + +def to_cpu(x): + """Convert tensor to CPU.""" + if isinstance(x, (np.ndarray, np.memmap)): + return x + elif TORCH_BACKEND and isinstance(x, torch.Tensor): + return x.cpu() + elif isinstance(x, (int, float, complex)): + return x else: - if "dim" in kwargs: - kwargs["axis"] = kwargs.pop("dim") - return np.stack(arrays, axis=axis, **kwargs) + return np.asarray(x) + -# def to_cpu(x): -# """Convert tensor to CPU NumPy array.""" -# if isinstance(x, np.ndarray): -# return x -# if hasattr(x, 'cpu'): -# return x.cpu().numpy() -# if isinstance(x, (int, float, complex)): -# return x -# return np.asarray(x) +def to_numpy(x): + """Convert tensor to CPU NumPy array.""" + x = to_cpu(x) + if TORCH_BACKEND and isinstance(x, torch.Tensor): + return x.detach().numpy() + return x def reshape(x, shape): """Reshape array.""" - if TORCH_BACKEND and type(x) == np.memmap: + if TORCH_BACKEND and isinstance(x, (np.ndarray, np.memmap)): return np.reshape(x, shape) return xp.reshape(x, shape) @@ -361,7 +390,7 @@ def stack(arrays, axis=0, **kwargs): if TORCH_BACKEND: if "axis" in kwargs: kwargs["dim"] = kwargs.pop("axis") - return xp.stack(arrays, **kwargs) + return xp.stack(arrays, dim=axis, **kwargs) else: if "dim" in kwargs: kwargs["axis"] = kwargs.pop("dim") @@ -393,17 +422,20 @@ def isnan(x): def midcrop(a,n): # e.g. unshifted ks: 0,1,2,3,4.....-4,-3,-,2-1, crop out 3 through -3, the inverse of a[n:-n] return xp.roll(xp.roll(a,len(a)//2)[n:-n],len(a)//2-n) + def ceil(v): - if xp != np and type(v)==torch.Tensor: + if TORCH_BACKEND and isinstance(v, torch.Tensor): return int(xp.ceil(v)) return int(np.ceil(v)) -def cumsum(a): - if xp != np and type(a)==torch.Tensor: - return xp.cumsum(a,dim=0) - return xp.cumsum(a) -def histogram(a,bins): +def cumsum(a, axis=0): + if TORCH_BACKEND and isinstance(a, torch.Tensor): + return xp.cumsum(a, dim=axis) + return xp.cumsum(a, axis=axis) + + +def histogram(a, bins): #print(bins) #print(bins[1:]-bins[:-1]) #return np.histogram(to_cpu(a),bins=to_cpu(bins)) @@ -416,7 +448,7 @@ def histogram(a,bins): # # hist[i] = xp.sum(mask) # #return hist hist = zeros(len(bins)-1,type_match=a) - for chunk in chunkIDs(len(bins)-1,1000): + for chunk in chunk_ids(len(bins)-1,1000): db = bins[chunk+1]-bins[chunk] diff = a[None,:]-bins[chunk,None] diff[diff>db[:,None]]=-1 @@ -427,51 +459,34 @@ def histogram(a,bins): return hist #return np.histogram(to_cpu(a),bins=to_cpu(bins))[0] #return np.histogram(a,bins=bins)[0] + # torch.histogram has device limitations on CUDA; numpy fallback is correct and avoids + # large intermediate allocations from the manual chunked loop. + #return np.histogram(to_numpy(a), bins=to_numpy(bins)) + +def randfloats(N, device=None, dtype=None): + N = int(N) + if device is None: + device = DEFAULT_DEVICE + if dtype is None: + dtype = DEFAULT_FLOAT_DTYPE + if TORCH_BACKEND: + return torch.rand(N, device=device, dtype=dtype) + return _rng.random(N).astype(dtype) -def randfloats(N): - N=int(N) - if xp != np: - return xp.rand(N) - return np.random.random(N) def clone(a): if hasattr(a,"clone"): return a.clone() - try: - if hasattr(a,"copy"): - return a.copy() - except: - pass + if hasattr(a,"copy"): + return a.copy() return a -def chunkIDs(N,chunksize=1000): - chunks = [] ; i=0 - while True: - chunk = xp.arange(i*chunksize,min((i+1)*chunksize,N)) - chunks.append( chunk ) - i += 1 - if i*chunksize >= N: - break - return chunks - -def memmap(dims, dtype=None, filename=None): - """Create memory-mapped array.""" - if filename is None: - print("WARNING: memmap attempted without filename, falling back to zeros") - return zeros(dims, dtype=dtype) - - # Convert torch dtypes to numpy for memmap - if TORCH_BACKEND and dtype in [xp.complex128, xp.complex64, xp.float64, xp.float32]: - dtype_map = { - xp.complex128: np.complex128, - xp.complex64: np.complex64, - xp.float64: np.float64, - xp.float32: np.float32, - } - dtype = dtype_map[dtype] - - return np.memmap(filename, dtype=dtype, mode='w+', shape=dims) +def chunk_ids(N, chunksize=1000): + chunks = [] + for i in range(0, N, chunksize): + chunks.append(np.arange(i, min(i + chunksize, N))) + return chunks # Keep legacy function for backward compatibility From cbb21a1f441a594f7a8beec6eeeeb74304f4b281 Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Fri, 27 Mar 2026 14:37:53 -0700 Subject: [PATCH 10/14] Backend reworked more. Renamed mean, sum, any functions to avoid potential problems overloading default Python operators --- src/pyslice/backend.py | 6 +- src/pyslice/multislice/calculators.py | 4 +- src/pyslice/multislice/multislice.py | 2 +- src/pyslice/multislice/potentials.py | 8 +- src/pyslice/multislice/sed.py | 2 +- src/pyslice/postprocessing/haadf_data.py | 19 ++-- src/pyslice/postprocessing/tacaw_data.py | 111 ++++++++++------------- src/pyslice/postprocessing/wf_data.py | 12 +-- 8 files changed, 73 insertions(+), 91 deletions(-) diff --git a/src/pyslice/backend.py b/src/pyslice/backend.py index 4b156cf..b1f4659 100644 --- a/src/pyslice/backend.py +++ b/src/pyslice/backend.py @@ -299,7 +299,7 @@ def linspace(start, stop, num=50, **kwargs): return xp.linspace(start, stop, num, **kwargs) -def sum(x: Any, axis: Optional[int] = None, **kwargs: Any) -> Any: +def array_sum(x: Any, axis: Optional[int] = None, **kwargs: Any) -> Any: """Sum elements along axis with kwarg conversion.""" if TORCH_BACKEND and type(x) not in (np.memmap, np.ndarray): if "axis" in kwargs: @@ -311,7 +311,7 @@ def sum(x: Any, axis: Optional[int] = None, **kwargs: Any) -> Any: return np.sum(x, axis=axis, **kwargs) # type: ignore[attr-defined] -def mean(x, axis=None, **kwargs): +def array_mean(x, axis=None, **kwargs): """Mean of elements along axis with kwarg conversion.""" is_torch = TORCH_BACKEND and type(x) not in [np.memmap, np.ndarray] @@ -334,7 +334,7 @@ def mean(x, axis=None, **kwargs): return np.mean(x, axis=axis, **kwargs) -def any(x): +def array_any(x): """Test whether any array elements along a given axis evaluate to True.""" return xp.any(x) diff --git a/src/pyslice/multislice/calculators.py b/src/pyslice/multislice/calculators.py index 6d9609e..73dc41b 100644 --- a/src/pyslice/multislice/calculators.py +++ b/src/pyslice/multislice/calculators.py @@ -265,7 +265,7 @@ def run(self) -> WFData: self.probe_indices = [] for i,p in enumerate(tqdm(self.probe_positions)): p = asarray(p) - d_to_nearest_atom = backend.sqrt( backend.amin( backend.sum( (p[None,:]-xy_atoms)**2,axis=1) ) ) + d_to_nearest_atom = backend.sqrt( backend.amin( backend.array_sum( (p[None,:]-xy_atoms)**2,axis=1) ) ) if d_to_nearest_atom < self.probe_cropping*self.sampling: self.probe_indices.append(i) np.save(self.output_dir / f"probe_indices.npy", self.probe_indices) @@ -395,7 +395,7 @@ def run(self) -> WFData: chunk = backend.arange(i*chunksize,(i+1)*chunksize) #chunk = chunk[chunknpt: break if len(chunk)==0: diff --git a/src/pyslice/multislice/multislice.py b/src/pyslice/multislice/multislice.py index e07a5ea..62e45c7 100644 --- a/src/pyslice/multislice/multislice.py +++ b/src/pyslice/multislice/multislice.py @@ -251,7 +251,7 @@ def plot(self,filename=None,title=None): import matplotlib.pyplot as plt fig, ax = plt.subplots() # calling self.array should convert to CPU/numpy - array = backend.mean(backend.absolute(self.array[:,:,::-1,:]),axis=1)[0,:,:] # positional,summable,x,y indices + array = backend.array_mean(backend.absolute(self.array[:,:,::-1,:]),axis=1)[0,:,:] # positional,summable,x,y indices array=array.T # imshow convention: y,x. our convention: x,y plot_array = backend.absolute(array)**.25 diff --git a/src/pyslice/multislice/potentials.py b/src/pyslice/multislice/potentials.py index 3cdb859..eca0fae 100644 --- a/src/pyslice/multislice/potentials.py +++ b/src/pyslice/multislice/potentials.py @@ -55,8 +55,8 @@ def kirkland(qsq, Z): d_expanded = d[:, None, None] qsq_expanded = qsq[None, :, :] - term1 = backend.sum(a_expanded / (qsq_expanded + b_expanded), axis=0) - term2 = backend.sum(c_expanded * backend.exp(-d_expanded * qsq_expanded), axis=0) + term1 = backend.array_sum(a_expanded / (qsq_expanded + b_expanded), axis=0) + term2 = backend.array_sum(c_expanded * backend.exp(-d_expanded * qsq_expanded), axis=0) return term1 + term2 @@ -230,7 +230,7 @@ def calculateSlice(slice_idx): spatial_mask = (slice_coords >= slice_min) & (slice_coords < slice_max) - if not backend.any(spatial_mask): + if not backend.array_any(spatial_mask): continue # Get positions for atoms in this slice and type @@ -328,7 +328,7 @@ def plot(self,filename=""): import matplotlib.pyplot as plt fig, ax = plt.subplots() - array = backend.sum( + array = backend.array_sum( backend.absolute(self.array), axis=2, ).T # imshow convention: y,x. our convention: x,y diff --git a/src/pyslice/multislice/sed.py b/src/pyslice/multislice/sed.py index 0169ef1..fe3fe9b 100644 --- a/src/pyslice/multislice/sed.py +++ b/src/pyslice/multislice/sed.py @@ -63,7 +63,7 @@ def SED(avg,displacements,kvec,v_xyz=0,bs=''): v_xyz=np.roll([1,0,0],v_xyz) # 0,1,2 --> x,y,z else: v_xyz=backend.asarray(v_xyz,dtype=float) - v_xyz/=backend.sqrt(backend.sum(v_xyz**2)) # normalize magnitude of passed vector + v_xyz/=backend.sqrt(backend.array_sum(v_xyz**2)) # normalize magnitude of passed vector # time axis: infer frequencies, calculate length so we can trim off negative frequencies, set up empty nt2=int(nt/2) ; ws=fftfreq(nt)[:nt2] diff --git a/src/pyslice/postprocessing/haadf_data.py b/src/pyslice/postprocessing/haadf_data.py index da4df1c..57aadac 100644 --- a/src/pyslice/postprocessing/haadf_data.py +++ b/src/pyslice/postprocessing/haadf_data.py @@ -9,7 +9,6 @@ from ..data.pyslice_serial import PySliceSerial, Signal, Dimensions, Dimension, Metadata #from ..data import Signal, Dimensions, Dimension, GeneralMetadata import pyslice.backend as backend -from pyslice.backend import zeros, to_cpu, mean, sum, absolute, einsum, xp, float_dtype #from ..data.pyslice_serial import PySliceSerial logger = logging.getLogger(__name__) @@ -187,8 +186,8 @@ def calculateADF(self, inner_mrad: float = 45, outer_mrad: float = 150, preview: if preview: import matplotlib.pyplot as plt fig, ax = plt.subplots() - preview_data = mean(absolute(self._wf_array),axis=(0,1,2,3,6))**.2 * (1 - mask) - ax.imshow(absolute(np.asarray(preview_data)), cmap="inferno") + preview_data = backend.array_mean(backend.absolute(self._wf_array),axis=(0,1,2,3,6))**.2 * (1 - mask) + ax.imshow(backend.to_numpy(backend.absolute(preview_data)), cmap="inferno") plt.show() #collected = self._wf_array * mask[None,None,None,:,:,None] # c,x,y,t,kx,ky,l indices, mask is kx,ky @@ -199,17 +198,11 @@ def calculateADF(self, inner_mrad: float = 45, outer_mrad: float = 150, preview: # self._array[i,j] = mean(sum(absolute(collected)**2,axis=(2,3)),axis=(0,1,2)) # sum |ψ|² over kx,ky, mean over c,t,l # TODO this should be einsum, but i'm not trying to test it right now... nc,_,_,nt,_,_,nl = self._wf_array.shape - wf_intensity = absolute(self._wf_array)**2 ; mask = absolute(mask) - self._array = einsum('cxytkql,kq->xy',wf_intensity,mask)/(nc*nt*nl) + wf_intensity = backend.absolute(self._wf_array)**2 ; mask = backend.absolute(mask) + self._array = backend.einsum('cxytkql,kq->xy',wf_intensity,mask)/(nc*nt*nl) - # Update dimensions with computed xs, ys - def to_numpy(x): - if hasattr(x, 'cpu'): - return x.cpu().numpy() - return np.asarray(x) - - xs_np = to_numpy(self._xs) - ys_np = to_numpy(self._ys) + xs_np = backend.to_numpy(self._xs) + ys_np = backend.to_numpy(self._ys) if Dimensions is not None: self._local_dimensions = Dimensions([ diff --git a/src/pyslice/postprocessing/tacaw_data.py b/src/pyslice/postprocessing/tacaw_data.py index 4fd25d4..cbc711e 100644 --- a/src/pyslice/postprocessing/tacaw_data.py +++ b/src/pyslice/postprocessing/tacaw_data.py @@ -84,16 +84,10 @@ def __init__(self, computed_array = self._array computed_frequencies = backend.to_cpu(self._frequencies) if hasattr(self._frequencies, 'cpu') else self._frequencies - # Helper to convert tensors to numpy for Dimensions - def to_numpy(x): - if hasattr(x, 'cpu'): - return x.cpu().numpy() - return np.asarray(x) - # Build Dimensions for Signal - freq_arr = to_numpy(self._frequencies) - kxs_arr = to_numpy(self._kxs) - kys_arr = to_numpy(self._kys) + freq_arr = backend.to_numpy(self._frequencies) + kxs_arr = backend.to_numpy(self._kxs) + kys_arr = backend.to_numpy(self._kys) if Dimensions is not None: @@ -180,8 +174,7 @@ def _fft_from_wf_data(self, layer_index: int = None): _,nw,nx2,ny2 = self._array.shape if nt==nw and nx==nx2 and ny==ny2: self._frequencies = np.load(self.cache_dir / "tacaw_freq.npy") - if hasattr(self._array, 'device'): - import pyslice.backend as backend + if backend.TORCH_BACKEND: self._frequencies = backend.asarray(self._frequencies) self._array = backend.asarray(self._array) return @@ -218,7 +211,7 @@ def _fft_from_wf_data(self, layer_index: int = None): dtype = backend.complex_dtype if self.keep_complex else backend.float_dtype shape = (wf_layer.shape[0], self.chunk_size_time, wf_layer.shape[2], wf_layer.shape[3]) if self.use_memmap: - self._array = memmap(shape, dtype=dtype, filename = self.cache_dir / "tacaw.npy") + self._array = backend.memmap(shape, dtype=dtype, filename = self.cache_dir / "tacaw.npy") else: self._array = backend.zeros(shape, dtype=dtype) @@ -227,12 +220,12 @@ def _fft_from_wf_data(self, layer_index: int = None): i2 = indices[i+1] for i in tqdm(range(len(self._kxs))): - wf_mean = mean(wf_layer[:,slice(i1,i2),i,:], axis=1, keepdims=True) # p,t,x,y,[l] indices - wf_fft = fft(wf_layer[:,slice(i1,i2),i,:] - wf_mean, axis=1) - wf_fft = fftshift(wf_fft, axes=1) + wf_mean = backend.array_mean(wf_layer[:,slice(i1,i2),i,:], axis=1, keepdims=True) # p,t,x,y,[l] indices + wf_fft = backend.fft(wf_layer[:,slice(i1,i2),i,:] - wf_mean, axis=1) + wf_fft = backend.fftshift(wf_fft, axes=1) if not self.keep_complex: - wf_fft = absolute(wf_fft)**2 + wf_fft = backend.absolute(wf_fft)**2 self._array[:,:,i,:] += wf_fft @@ -243,12 +236,12 @@ def _fft_from_wf_data(self, layer_index: int = None): i1 = indices[i] i2 = indices[i+1] - wf_mean = mean(wf_layer[:,slice(i1,i2),:,:], axis=1, keepdims=True) - wf_fft = fft(wf_layer[:,slice(i1,i2),:,:] - wf_mean, axis=1) - wf_fft = fftshift(wf_fft, axes=1) + wf_mean = backend.array_mean(wf_layer[:,slice(i1,i2),:,:], axis=1, keepdims=True) + wf_fft = backend.fft(wf_layer[:,slice(i1,i2),:,:] - wf_mean, axis=1) + wf_fft = backend.fftshift(wf_fft, axes=1) if not self.keep_complex: - wf_fft = absolute(wf_fft)**2 + wf_fft = backend.absolute(wf_fft)**2 if self._array is None: self._array = wf_fft @@ -283,24 +276,24 @@ def spectrum(self, probe_index: int = None) -> np.ndarray: all_spectra = [] for i in range(len(self.probe_positions)): probe_intensity = self._array[i] # Shape: (frequency, kx, ky) - spectrum = sum(probe_intensity, axis=(1, 2)) # Sum over kx, ky + spectrum = backend.array_sum(probe_intensity, axis=(1, 2)) # Sum over kx, ky all_spectra.append(spectrum) # Average all spectra if hasattr(all_spectra[0], 'device'): - all_spectra = [to_cpu(s) for s in all_spectra] - spectrum = backend.mean(backend.asarray(all_spectra), axis=0) + all_spectra = [backend.to_cpu(s) for s in all_spectra] + spectrum = backend.array_mean(backend.asarray(all_spectra), axis=0) else: if probe_index >= len(self.probe_positions): raise ValueError(f"Probe index {probe_index} out of range") # Sum intensity data over all k-space for this probe position probe_intensity = self._array[probe_index] # Shape: (frequency, kx, ky) - spectrum = sum(probe_intensity, axis=(1, 2)) # Sum over kx, ky + spectrum = backend.array_sum(probe_intensity, axis=(1, 2)) # Sum over kx, ky # Convert to numpy if PyTorch tensor if hasattr(spectrum, 'device'): - spectrum = to_cpu(spectrum) + spectrum = backend.to_cpu(spectrum) return spectrum @@ -327,18 +320,11 @@ def spectrum_image(self, frequency: float, probe_indices: Optional[List[int]] = for probe_idx in probe_indices: # Sum intensity data over all k-space for this probe at this frequency probe_intensity = self._array[probe_idx, freq_idx, :, :] - - # Sum over k-space using appropriate method - if TORCH_AVAILABLE and hasattr(probe_intensity, 'sum'): - probe_intensity_sum = probe_intensity.sum() - if hasattr(probe_intensity_sum, 'cpu'): - probe_intensity_sum = probe_intensity_sum.cpu().numpy() - else: - probe_intensity_sum = backend.sum(probe_intensity) + probe_intensity_sum = backend.array_sum(probe_intensity) spectrum_intensities.append(probe_intensity_sum) - return np.array(spectrum_intensities) + return backend.to_numpy(spectrum_intensities) def diffraction(self, probe_index: int = None, space: str = "reciprocal") -> np.ndarray: """ @@ -355,24 +341,24 @@ def diffraction(self, probe_index: int = None, space: str = "reciprocal") -> np. all_diffractions = [] for i in range(len(self.probe_positions)): probe_intensity = self._array[i] # Shape: (frequency, kx, ky) - diffraction_pattern = sum(probe_intensity, axis=0) # Sum over frequencies + diffraction_pattern = backend.array_sum(probe_intensity, axis=0) # Sum over frequencies all_diffractions.append(diffraction_pattern) # Average all diffraction patterns if hasattr(all_diffractions[0], 'device'): - all_diffractions = [to_cpu(d) for d in all_diffractions] - diffraction_pattern = backend.mean(backend.asarray(all_diffractions), axis=0) + all_diffractions = [backend.to_cpu(d) for d in all_diffractions] + diffraction_pattern = backend.array_mean(backend.asarray(all_diffractions), axis=0) else: if probe_index >= len(self.probe_positions): raise ValueError(f"Probe index {probe_index} out of range") # Sum intensity data over all frequencies for this probe position probe_intensity = self._array[probe_index] # Shape: (frequency, kx, ky) - diffraction_pattern = sum(probe_intensity, axis=0) # Sum over frequencies + diffraction_pattern = backend.array_sum(probe_intensity, axis=0) # Sum over frequencies # Convert to numpy if PyTorch tensor if hasattr(diffraction_pattern, 'device'): - diffraction_pattern = to_cpu(diffraction_pattern) + diffraction_pattern = backend.to_cpu(diffraction_pattern) if space == "real": diffraction_pattern = backend.absolute(backend.ifft2(diffraction_pattern)) @@ -403,7 +389,7 @@ def spectral_diffraction(self, frequency: float, probe_index: int = None, space: # Average all spectral diffraction patterns if hasattr(all_spectral_diffractions[0], 'device'): all_spectral_diffractions = [to_cpu(sd) for sd in all_spectral_diffractions] - spectral_diffraction = backend.mean(backend.asarray(all_spectral_diffractions), axis=0) + spectral_diffraction = backend.array_mean(backend.asarray(all_spectral_diffractions), axis=0) else: if probe_index >= len(self.probe_positions): raise ValueError(f"Probe index {probe_index} out of range") @@ -413,7 +399,7 @@ def spectral_diffraction(self, frequency: float, probe_index: int = None, space: # Convert to numpy if PyTorch tensor if hasattr(spectral_diffraction, 'device'): - spectral_diffraction = to_cpu(spectral_diffraction) + spectral_diffraction = backend.to_cpu(spectral_diffraction) if space == "real": spectral_diffraction = backend.absolute(backend.ifft2(spectral_diffraction)) @@ -431,8 +417,8 @@ def masked_spectrum(self, mask: np.ndarray|dict|None = None, probe_index: int = Returns: Masked spectrum (frequency intensity) with k-space mask applied """ - kxs = to_cpu(self.kxs) - kys = to_cpu(self.kys) + kxs = backend.to_cpu(self.kxs) + kys = backend.to_cpu(self.kys) if mask is None: mask = np.zeros((len(kxs),len(kys)))+1 @@ -458,14 +444,14 @@ def masked_spectrum(self, mask: np.ndarray|dict|None = None, probe_index: int = import matplotlib.pyplot as plt fig, ax = plt.subplots() extent = ( np.amin(kxs) , np.amax(kxs) , np.amin(kys) , np.amax(kys) ) - ax.imshow(to_cpu(backend.sum(masked, axis=0)).T[::-1,:], cmap="inferno",extent=extent,aspect=1) + ax.imshow(backend.to_cpu(backend.array_sum(masked, axis=0)).T[::-1,:], cmap="inferno",extent=extent,aspect=1) ax.set_xlabel("kx") ax.set_ylabel("ky") ax.set_title("masked_spectrum - preview") plt.show() preview=False - spectra.append(to_cpu(backend.sum(masked, axis=(1,2)))) - return to_cpu(backend.mean(spectra,axis=0)) + spectra.append(backend.to_cpu(backend.array_sum(masked, axis=(1,2)))) + return backend.to_numpy(backend.array_mean(spectra,axis=0)) def dispersion(self, kx_path: np.ndarray, ky_path: np.ndarray, probe_index: int = None, space: str = "reciprocal") -> np.ndarray: """ @@ -486,8 +472,8 @@ def dispersion(self, kx_path: np.ndarray, ky_path: np.ndarray, probe_index: int kx=self.xs ; ky=self.ys # Convert to CPU/numpy for indexing operations - kx = to_cpu(kx) - ky = to_cpu(ky) + kx = backend.to_cpu(kx) + ky = backend.to_cpu(ky) # Find closest indices in our kxs/kys arrays for the requested paths kx_indices = [] @@ -519,45 +505,47 @@ def dispersion(self, kx_path: np.ndarray, ky_path: np.ndarray, probe_index: int w_slice = backend.ifft2(w_slice, axes=(1,2)) # bring to CPU if hasattr(w_slice, 'device'): - w_slice = to_cpu(w_slice) + w_slice = backend.to_cpu(w_slice) # sum across probe positions - w_slice = backend.mean(w_slice,axis=0) + w_slice = backend.array_mean(w_slice,axis=0) # select values at positions for i, (kx_idx, ky_idx) in enumerate(zip(kx_indices, ky_indices)): dispersion[w,i] = w_slice[ kx_idx, ky_idx ] - return to_cpu(backend.absolute(dispersion)) + # Do we want to return NumPy or keep as tensor? For now, always return numpy since this is postprocessing and likely small arrays + return backend.to_numpy(backend.absolute(dispersion)) + # Since there are multiple things returnable by the above functions, i'm just offering up a generic heatmap plotter function here, where you pass Z,x,y def plot(self,intensities,xvals,yvals,xlabel="kx ($\\AA^{-1}$)",ylabel="ky ($\\AA^{-1}$)",filename=None,title=None,extent=None): import matplotlib.pyplot as plt fig, ax = plt.subplots() - array = backend.absolute(to_cpu(intensities)) # imshow convention: y,x. our convention: x,y + array = backend.absolute(to_numpy(intensities)) # imshow convention: y,x. our convention: x,y aspect = None if isinstance(xvals,str): if xvals in ["kx","k"]: - xlabel = "kx ($\\AA^{-1}$)" ; xvals = to_cpu(self.kxs) + xlabel = "kx ($\\AA^{-1}$)" ; xvals = backend.to_numpy(self.kxs) elif xvals == "ky": - xlabel = "ky ($\\AA^{-1}$)" ; xvals = to_cpu(self.kys) + xlabel = "ky ($\\AA^{-1}$)" ; xvals = backend.to_numpy(self.kys) elif xvals == "x": - xlabel = "x ($\\AA$)" ; xvals = to_cpu(self.xs) + xlabel = "x ($\\AA$)" ; xvals = backend.to_numpy(self.xs) elif xvals == "y": - xlabel = "y ($\\AA$)" ; xvals = to_cpu(self.ys) + xlabel = "y ($\\AA$)" ; xvals = backend.to_numpy(self.ys) if isinstance(yvals,str): if yvals == "omega": aspect = "auto" if yvals == "kx": - ylabel = "kx ($\\AA^{-1}$)" ; yvals = to_cpu(self.kxs) + ylabel = "kx ($\\AA^{-1}$)" ; yvals = backend.to_numpy(self.kxs) elif yvals in ["ky","k"]: - ylabel = "ky ($\\AA^{-1}$)" ; yvals = to_cpu(self.kys) + ylabel = "ky ($\\AA^{-1}$)" ; yvals = backend.to_numpy(self.kys) elif yvals == "x": - ylabel = "x ($\\AA$)" ; yvals = to_cpu(self.xs) + ylabel = "x ($\\AA$)" ; yvals = backend.to_numpy(self.xs) elif yvals == "y": - ylabel = "y ($\\AA$)" ; yvals = to_cpu(self.ys) + ylabel = "y ($\\AA$)" ; yvals = backend.to_numpy(self.ys) elif yvals == "omega": - ylabel = "frequency (THz)" ; yvals = to_cpu(self.frequencies) + ylabel = "frequency (THz)" ; yvals = backend.to_numpy(self.frequencies) if extent is None: extent = ( np.amin(xvals) , np.amax(xvals) , np.amin(yvals) , np.amax(yvals) ) @@ -572,6 +560,7 @@ def plot(self,intensities,xvals,yvals,xlabel="kx ($\\AA^{-1}$)",ylabel="ky ($\\A else: plt.show() + class SEDData(TACAWData): """ Data structure for SED (Spectral Energy Density) calculations. diff --git a/src/pyslice/postprocessing/wf_data.py b/src/pyslice/postprocessing/wf_data.py index 1685f97..166a277 100644 --- a/src/pyslice/postprocessing/wf_data.py +++ b/src/pyslice/postprocessing/wf_data.py @@ -159,7 +159,7 @@ def counts(self,N): if self.probability is None: self.probability = self._array npt,nt,nx,ny,nl = self._array.shape - ary = self._array/backend.sum(backend.absolute(self._array)) # normalized: ensure values arerelative probabilities of each voxel + ary = self._array/backend.array_sum(backend.absolute(self._array)) # normalized: ensure values arerelative probabilities of each voxel ary = backend.absolute(ary.reshape(npt*nt*nx*ny*nl)) self.buckets = zeros(len(ary)+1,type_match=ary) self.buckets[1:] = cumsum(ary) # cumsum means we can "select" a voxel with a random float 0-1 @@ -279,7 +279,7 @@ def plot_phase(self,filename=None,whichProbe=0,whichTimestep=0,extent=None,avg=F # Get array (with or without averaging) if avg: array = self._array[whichProbe,:,:,:,-1] # Shape: (time, kx, ky) - array = backend.mean(array, axis=0) # Average over time dimension + array = backend.array_mean(array, axis=0) # Average over time dimension else: array = self._array[whichProbe,whichTimestep,:,:,-1] @@ -337,12 +337,12 @@ def plot_realspace(self,whichProbe="mean",whichTimestep="mean",extent=None,filen array = backend.absolute(array) # probe, time, kx, ky, layer --> p,t,kx,ky if isinstance(whichProbe,str) and whichProbe=="mean": - array = backend.mean(backend.absolute(array),axis=0) # p,t,kx,ky --> t,kx,ky + array = backend.array_mean(backend.absolute(array),axis=0) # p,t,kx,ky --> t,kx,ky else: array = array[whichProbe] if isinstance(whichTimestep,str) and whichTimestep=="mean": - array = backend.mean(array,axis=0) # t,kx,ky --> kx,ky + array = backend.array_mean(array,axis=0) # t,kx,ky --> kx,ky else: array = array[whichTimestep] @@ -405,8 +405,8 @@ def applyMask(self, radius, realOrReciprocal="reciprocal"): self._array*=mask[None,None,:,:,None] else: # Use numpy for _xs/_ys since they're numpy arrays, then convert result - radii_np = backend.sqrt( ( self._xs[:,None] - backend.mean(self._xs) )**2 +\ - ( self._ys[None,:] - backend.mean(self._ys) )**2 ) + radii_np = backend.sqrt( ( self._xs[:,None] - backend.array_mean(self._xs) )**2 +\ + ( self._ys[None,:] - backend.array_mean(self._ys) )**2 ) if backend.TORCH_BACKEND: radii = backend.asarray(radii_np, dtype=self._array.real.dtype, device=self._array.device) else: From f4a64cea88a2f05dd11d332e670d612a0e72e298 Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Sat, 28 Mar 2026 20:49:38 -0700 Subject: [PATCH 11/14] Complete rewrite of the backend Claude and Github Copilot made the majority of changes. The backend is now much more compartmentalized and fully testable. Need to verify the correctness of calculations more. --- pyproject.toml | 2 +- src/pyslice/__init__.py | 1 - src/pyslice/backend.py | 946 ++++++------ src/pyslice/io/loader.py | 4 +- src/pyslice/multislice/calculators.py | 436 +++--- src/pyslice/multislice/multislice.py | 1683 ++++++++++++---------- src/pyslice/multislice/potentials.py | 665 +++++---- src/pyslice/multislice/sed.py | 165 +-- src/pyslice/multislice/trajectory.py | 569 +++----- src/pyslice/postprocessing/haadf_data.py | 74 +- src/pyslice/postprocessing/tacaw_data.py | 729 ++++------ src/pyslice/postprocessing/testtools.py | 16 - src/pyslice/postprocessing/wf_data.py | 542 +++---- tests/00_probe.py | 15 +- tests/00_probe2.py | 31 + tests/01_potentials.py | 20 +- tests/01_potentials2.py | 2 +- tests/02_propagate2_otf=False.py | 45 + tests/02_propagate_otf=False.py | 21 +- tests/02_propagate_otf=True.py | 21 +- tests/02_unpropagate.py | 22 +- tests/03_manyprobes.py | 33 +- tests/03_manyprobes2.py | 121 ++ tests/04_haadf.py | 3 +- tests/04_haadf_aberrations.py | 3 +- tests/04_haadf_otf.py | 3 +- tests/05_tacaw.py | 3 +- tests/05_tacaw_chunkFFT.py | 3 +- tests/05_tacaw_cropped.py | 3 +- tests/05_tacaw_otf.py | 3 +- tests/06_loaders.py | 3 +- tests/07_defocus.py | 9 +- tests/08_LACBED_iterative.py | 3 +- tests/08_LACBED_onthefly.py | 3 +- tests/11_SED.py | 3 +- tests/12_aberrations.py | 9 +- tests/18_caching.py | 3 +- tests/20_probepositions.py | 3 +- tests/21_memorytests.py | 3 +- tests/22_prism.py | 3 +- tests/23_counts.py | 3 +- tests/test_backend.py | 494 +++++++ tests/testtools.py | 89 ++ 43 files changed, 3633 insertions(+), 3179 deletions(-) delete mode 100644 src/pyslice/postprocessing/testtools.py create mode 100644 tests/00_probe2.py create mode 100644 tests/02_propagate2_otf=False.py create mode 100644 tests/03_manyprobes2.py create mode 100644 tests/test_backend.py create mode 100644 tests/testtools.py diff --git a/pyproject.toml b/pyproject.toml index c9db556..5e7bd22 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -19,7 +19,7 @@ dependencies = [ [project.optional-dependencies] fast = ["torch","torchvision"] -test = ["abtem>=1.0.6"] +test = ["abtem>=1.0.6", "pytest"] md = ["orb-models"] fairchem = ["fairchem-core"] diff --git a/src/pyslice/__init__.py b/src/pyslice/__init__.py index 5853bda..86ffd82 100644 --- a/src/pyslice/__init__.py +++ b/src/pyslice/__init__.py @@ -14,4 +14,3 @@ from .multislice.trajectory import * from .postprocessing.haadf_data import * from .postprocessing.tacaw_data import * -from .postprocessing.testtools import * diff --git a/src/pyslice/backend.py b/src/pyslice/backend.py index b1f4659..bf6657b 100644 --- a/src/pyslice/backend.py +++ b/src/pyslice/backend.py @@ -1,495 +1,575 @@ # backend.py - Backend abstraction layer for NumPy/PyTorch support -import numpy as np -from typing import Any, Optional +from __future__ import annotations + +import os import logging +from abc import ABC, abstractmethod +from typing import Any, Optional, Tuple, Union + +import numpy as np logger = logging.getLogger(__name__) logger.addHandler(logging.NullHandler()) -_rng = np.random.default_rng() +# --------------------------------------------------------------------------- +# Optional torch import +# --------------------------------------------------------------------------- try: import torch - xp = torch # type: ignore[assignment] TORCH_AVAILABLE = True except ImportError: - torch = None # explicit sentinel - xp = np # type: ignore[assignment] + torch = None # type: ignore[assignment] TORCH_AVAILABLE = False -# Check for backend override via environment variable -import os -backend_override = os.environ.get('PYSLICE_BACKEND', '').lower() +# --------------------------------------------------------------------------- +# Standalone conversion utilities +# These are intentionally module-level: they convert *away* from a backend +# and therefore don't belong to either backend class. +# --------------------------------------------------------------------------- + +def to_cpu(x: Any) -> Any: + """Move a tensor/array to CPU, returning it unchanged if already there.""" + if isinstance(x, (np.ndarray, np.memmap)): + return x + if TORCH_AVAILABLE and isinstance(x, torch.Tensor): + return x.cpu() + if isinstance(x, (int, float, complex)): + return x + return np.asarray(x) + + +def to_numpy(x: Any) -> np.ndarray: + """Convert any array-like to a CPU NumPy array.""" + x = to_cpu(x) + if TORCH_AVAILABLE and isinstance(x, torch.Tensor): + return x.detach().numpy() + return np.asarray(x) -if backend_override == 'numpy' or not TORCH_AVAILABLE: - xp = np - TORCH_BACKEND = False -else: - xp = torch - TORCH_BACKEND = True +# --------------------------------------------------------------------------- +# Backend ABC +# --------------------------------------------------------------------------- -def device_and_precision(device_spec=None): +class Backend(ABC): """ - Determine the device and precision (dtype) to use. - - Args: - device_spec: Device specification ('cpu', 'cuda', 'mps', or None for auto) - - Returns: - Tuple of (device, float_dtype, complex_dtype) + Abstract base class defining the array-operation API. + + Subclasses must set: + xp - the underlying array library (np or torch) + float_dtype - default floating-point dtype + complex_dtype - default complex dtype + device - device identifier (string 'cpu' for NumPy, + torch.device for PyTorch) """ - if not TORCH_BACKEND: - return 'cpu', np.float64, np.complex128 - - # Check for device override via environment variable - device_override = os.environ.get('PYSLICE_DEVICE', '').lower() - if device_override: - device_spec = device_override - - # Auto-detect device if not specified - if device_spec is None: - if torch.cuda.is_available(): - device = torch.device('cuda') - elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): - device = torch.device('mps') - else: - device = torch.device('cpu') - else: - device = torch.device(device_spec) - - # Use float32 for MPS (doesn't support float64), float64 for CPU/CUDA - if device.type == 'mps': - float_dtype = torch.float32 - complex_dtype = torch.complex64 - else: - float_dtype = torch.float64 - complex_dtype = torch.complex128 - - return device, float_dtype, complex_dtype - - -# Determine default device and dtypes at import time -DEFAULT_DEVICE, DEFAULT_FLOAT_DTYPE, DEFAULT_COMPLEX_DTYPE = device_and_precision() - -logger.debug("Default device: %s", DEFAULT_DEVICE) -logger.debug("Default float dtype: %s", DEFAULT_FLOAT_DTYPE) -logger.debug("Default complex dtype: %s", DEFAULT_COMPLEX_DTYPE) - -# Convenience aliases -float_dtype = DEFAULT_FLOAT_DTYPE -complex_dtype = DEFAULT_COMPLEX_DTYPE - -pi = xp.pi - -_NUMPY_FLOAT_DTYPES = {np.float32, np.float64} -_NUMPY_COMPLEX_DTYPES = {np.complex64, np.complex128} -_TORCH_FLOAT_DTYPES = {torch.float32, torch.float64} if TORCH_AVAILABLE else set() -_TORCH_COMPLEX_DTYPES = {torch.complex64, torch.complex128} if TORCH_AVAILABLE else set() - -FLOAT_DTYPES = _NUMPY_FLOAT_DTYPES | _TORCH_FLOAT_DTYPES -COMPLEX_DTYPES = _NUMPY_COMPLEX_DTYPES | _TORCH_COMPLEX_DTYPES - -_TORCH_TO_NUMPY_DTYPE: dict = { - torch.complex128: np.complex128, - torch.complex64: np.complex64, - torch.float64: np.float64, - torch.float32: np.float32, -} if TORCH_AVAILABLE else {} - -def asarray(arraylike, dtype=None, device=None): - """Convert array-like object to backend array (NumPy or PyTorch tensor).""" - if dtype is None: - dtype = DEFAULT_FLOAT_DTYPE - if device is None: - device = DEFAULT_DEVICE - - # Handle complex to real casting - only strip imaginary part when target is real - input_dtype = getattr(arraylike, 'dtype', None) - if dtype in FLOAT_DTYPES and input_dtype in COMPLEX_DTYPES: - arraylike = arraylike.real - - if TORCH_BACKEND: - if hasattr(arraylike, 'detach'): # it's already a tensor - array = arraylike.detach().clone().to(dtype=dtype, device=device) - else: - array = torch.tensor(arraylike, dtype=dtype, device=device) - else: - array = np.asarray(arraylike, dtype=dtype) - return array + xp: Any + float_dtype: Any + complex_dtype: Any + device: Any + + # ------------------------------------------------------------------ + # Private kwarg-translation helpers + # Written once here; eliminates per-function if/else throughout the module. + # ------------------------------------------------------------------ + + def _axes_kwarg(self, axes: Optional[Any]) -> dict: + """Translate an axes/dim argument for fft-family functions.""" + if axes is None: + return {} + return {'dim': axes} if self.xp is torch else {'axes': axes} + + def _axis_kwarg(self, axis: Optional[int]) -> dict: + """Translate an axis/dim argument for reduction functions.""" + if axis is None: + return {} + return {'dim': axis} if self.xp is torch else {'axis': axis} + + def _keepdim_kwarg(self, keepdims: Optional[bool]) -> dict: + """Translate a keepdims/keepdim argument.""" + if keepdims is None: + return {} + return {'keepdim': keepdims} if self.xp is torch else {'keepdims': keepdims} + + def _is_numpy_array(self, x: Any) -> bool: + """Return True if x is a plain NumPy array (not a torch tensor).""" + return isinstance(x, (np.ndarray, np.memmap)) + + # ------------------------------------------------------------------ + # Array creation — depend on device/dtype, so fully abstract + # ------------------------------------------------------------------ + + @abstractmethod + def asarray(self, arraylike: Any, dtype=None, device=None) -> Any: + """Convert array-like to a backend array.""" + + @abstractmethod + def zeros(self, dims, dtype=None, device=None, type_match=None) -> Any: + """Return a zero-filled array.""" + + @abstractmethod + def ones(self, dims, dtype=None, device=None) -> Any: + """Return a one-filled array.""" + + @abstractmethod + def fftfreq(self, n: int, d: float = 1.0, dtype=None, device=None) -> Any: + """Return FFT sample frequencies.""" + + @abstractmethod + def randfloats(self, N: int, device=None, dtype=None) -> Any: + """Return N uniform random floats on [0, 1).""" + + @abstractmethod + def memmap(self, dims, dtype=None, filename: Optional[str] = None) -> Any: + """Return a memory-mapped array.""" + + # ------------------------------------------------------------------ + # Type utilities + # ------------------------------------------------------------------ + + def astype(self, arraylike: Any, dtype: Any) -> Any: + """Cast array to dtype.""" + if hasattr(arraylike, 'to'): # torch tensor + return arraylike.to(dtype) + return arraylike.astype(dtype) # numpy array + + def ones_like(self, x: Any) -> Any: + """Return a one-filled array with the same shape and dtype as x.""" + return self.xp.ones_like(x) + + def clone(self, a: Any) -> Any: + """Return a copy of a.""" + if hasattr(a, 'clone'): + return a.clone() + if hasattr(a, 'copy'): + return a.copy() + return a + + # ------------------------------------------------------------------ + # FFT family — dispatch via _axes_kwarg + # ------------------------------------------------------------------ + + def fft(self, x: Any, axes=None) -> Any: + """1-D FFT.""" + return self.xp.fft.fft(x, **self._axis_kwarg(axes)) + + def ifft(self, x: Any, axes=None) -> Any: + """1-D inverse FFT.""" + return self.xp.fft.ifft(x, **self._axis_kwarg(axes)) + + def fft2(self, x: Any, axes=None) -> Any: + """2-D FFT.""" + return self.xp.fft.fft2(x, **self._axes_kwarg(axes)) + + def ifft2(self, x: Any, axes=None) -> Any: + """2-D inverse FFT.""" + return self.xp.fft.ifft2(x, **self._axes_kwarg(axes)) + + def fftshift(self, x: Any, axes=None) -> Any: + """Shift zero-frequency component to centre.""" + return self.xp.fft.fftshift(x, **self._axes_kwarg(axes)) + + def ifftshift(self, x: Any, axes=None) -> Any: + """Inverse of fftshift.""" + return self.xp.fft.ifftshift(x, **self._axes_kwarg(axes)) + + # ------------------------------------------------------------------ + # Reductions — dispatch via _axis_kwarg / _keepdim_kwarg + # ------------------------------------------------------------------ + + def sum(self, x: Any, axis: Optional[int] = None, + keepdims: Optional[bool] = None) -> Any: + """Sum elements, optionally along an axis.""" + if self._is_numpy_array(x): + # Always use numpy for plain numpy arrays even in torch mode + kw: dict = {} if axis is None else {'axis': axis} + if keepdims is not None: + kw['keepdims'] = keepdims + return np.sum(x, **kw) + return self.xp.sum(x, **self._axis_kwarg(axis), + **self._keepdim_kwarg(keepdims)) + + def mean(self, x: Any, axis: Optional[int] = None, + keepdims: Optional[bool] = None) -> Any: + """Mean of elements, optionally along an axis.""" + if self._is_numpy_array(x): + kw = {} if axis is None else {'axis': axis} + if keepdims is not None: + kw['keepdims'] = keepdims + return np.mean(x, **kw) + return self.xp.mean(x, **self._axis_kwarg(axis), + **self._keepdim_kwarg(keepdims)) + + def cumsum(self, a: Any, axis: int = 0) -> Any: + """Cumulative sum along axis.""" + return self.xp.cumsum(a, **self._axis_kwarg(axis)) + + def any(self, x: Any) -> Any: + """Test whether any element is True.""" + return self.xp.any(x) + + # ------------------------------------------------------------------ + # Shape manipulation + # ------------------------------------------------------------------ + + def reshape(self, x: Any, shape) -> Any: + """Reshape array.""" + if self._is_numpy_array(x): + return np.reshape(x, shape) + return self.xp.reshape(x, shape) + + def expand_dims(self, x: Any, axis: int) -> Any: + """Insert a new axis.""" + if self.xp is torch: + return self.xp.unsqueeze(x, dim=axis) + return np.expand_dims(x, axis) -def astype(arraylike,dtype): - if hasattr(arraylike,"to"): # torch - return arraylike.to(dtype) - return arraylike.astype(dtype) # numpy + def stack(self, arrays, axis: int = 0) -> Any: + """Stack arrays along a new axis.""" + return self.xp.stack(arrays, **self._axis_kwarg(axis)) + def roll(self, x: Any, shift: int, axis: int) -> Any: + """Roll array elements along an axis.""" + if self.xp is torch: + return self.xp.roll(x, shifts=shift, dims=axis) + return np.roll(x, shift, axis=axis) -def zeros(dims, dtype=None, device=None, type_match=None): - """Create a zero-filled array.""" - if type_match is not None: - # Infer dtype/device from type_match array - if dtype is None: - dtype = type_match.dtype - if device is None and hasattr(type_match, "device"): - device = type_match.device - if isinstance(type_match, (np.ndarray, np.memmap)): - return np.zeros(dims, dtype=dtype) - - # Set defaults - if dtype is None: - dtype = DEFAULT_FLOAT_DTYPE - if device is None: - device=DEFAULT_DEVICE - # string handling for dtype, "float" --> float - if isinstance(dtype,str): - dtype={"float": DEFAULT_FLOAT_DTYPE, - "complex": DEFAULT_COMPLEX_DTYPE, - "int": xp.int64}[dtype] - # infer if we're using torch or numpy (numpy does not take device arg) - if TORCH_BACKEND: - array = xp.zeros(dims, dtype=dtype, device=device) - else: - array = xp.zeros(dims, dtype=dtype) - return array - - -def memmap(dims, dtype=None, filename=None): - if dtype is None: - dtype = DEFAULT_FLOAT_DTYPE - from numpy.lib.format import open_memmap - if filename is None: - logger.warning("memmap attempted without filename, falling back to zeros") - return zeros(dims,dtype) - # cast to numpy dtypes so we can use numpy memmaps - if TORCH_BACKEND and dtype in [ xp.complex128, xp.complex64, xp.float64, xp.float32 ]: - dtype = _TORCH_TO_NUMPY_DTYPE[ dtype ] - mode = 'w+' - logger.debug("creating memmap mode=%s dtype=%s dims=%s filename=%s", mode, dtype, dims, filename) - return open_memmap(filename, dtype=dtype, mode=mode, shape=dims) - - -def absolute(x): - """Element-wise absolute value.""" - if TORCH_BACKEND and type(x) in [np.memmap, np.ndarray]: - return np.absolute(x) - return xp.absolute(x) - - -def ones(dims, dtype=None, device=None): - """Create a one-filled array.""" - if dtype is None: - dtype = DEFAULT_FLOAT_DTYPE - if device is None: - device = DEFAULT_DEVICE - if TORCH_BACKEND: - return xp.ones(dims, dtype=dtype, device=device) - else: - return xp.ones(dims, dtype=dtype) - - -def ones_like(x): - """Create a one-filled array with same shape and dtype as input.""" - return xp.ones_like(x) - - -def fftfreq(n, d=1.0, dtype=None, device=None): - """Compute FFT frequency array.""" - if dtype is None: - dtype = DEFAULT_FLOAT_DTYPE - if device is None: - device = DEFAULT_DEVICE - if TORCH_BACKEND: - logger.debug("Creating FFT frequency array with device=%s, dtype=%s", device, dtype) - return xp.fft.fftfreq(n, d, dtype=dtype, device=device) - else: - return xp.fft.fftfreq(n, d).astype(dtype) - - -def fft2(x, **kwargs): - """2D FFT with kwarg conversion (dim/axes).""" - if TORCH_BACKEND and "axes" in kwargs: - kwargs["dim"] = kwargs.pop("axes") - # For numpy, "axes" is already correct - don't convert to "axis" - return xp.fft.fft2(x, **kwargs) - - -def fft(x, **kwargs): - """1D FFT with kwarg conversion.""" - if TORCH_BACKEND and "axes" in kwargs: - kwargs["dim"] = kwargs.pop("axes") - if not TORCH_BACKEND and "dim" in kwargs: - kwargs["axis"] = kwargs.pop("dim") - return xp.fft.fft(x, **kwargs) - - -def ifft2(x, **kwargs): - """2D inverse FFT with kwarg conversion.""" - if TORCH_BACKEND and "axes" in kwargs: - kwargs["dim"] = kwargs.pop("axes") - # For numpy, "axes" is already correct, no conversion needed - return xp.fft.ifft2(x, **kwargs) - - -def fftshift(x, **kwargs): - """FFT shift with kwarg conversion.""" - if TORCH_BACKEND and "axes" in kwargs: - kwargs["dim"] = kwargs.pop("axes") - if not TORCH_BACKEND and "dim" in kwargs: - kwargs["axes"] = kwargs.pop("dim") - return xp.fft.fftshift(x, **kwargs) - - -def ifftshift(x, **kwargs): - """Inverse FFT shift with kwarg conversion.""" - if TORCH_BACKEND and "axes" in kwargs: - kwargs["dim"] = kwargs.pop("axes") - if not TORCH_BACKEND and "dim" in kwargs: - kwargs["axes"] = kwargs.pop("dim") - return xp.fft.ifftshift(x, **kwargs) - - -def meshgrid(*args, **kwargs): - """Create mesh grids.""" - return xp.meshgrid(*args, **kwargs) + def midcrop(self, a: Any, n: int) -> Any: + """Crop the centre of an unshifted frequency array.""" + return self.xp.roll(self.xp.roll(a, len(a) // 2)[n:-n], len(a) // 2 - n) + # ------------------------------------------------------------------ + # Elementwise math + # ------------------------------------------------------------------ -def sqrt(x): - """Element-wise square root.""" - return xp.sqrt(x) + def absolute(self, x: Any) -> Any: + if self._is_numpy_array(x): + return np.absolute(x) + return self.xp.absolute(x) + def sqrt(self, x: Any) -> Any: + return self.xp.sqrt(x) -def exp(x): - """Element-wise exponential.""" - return xp.exp(x) + def exp(self, x: Any) -> Any: + return self.xp.exp(x) + def log(self, x: Any) -> Any: + return self.xp.log(x) -def real(x): - """Take real part.""" - return xp.real(x) + def real(self, x: Any) -> Any: + return self.xp.real(x) + def cos(self, x: Any) -> Any: + return self.xp.cos(x) -def cos(x): - """Element-wise cosine.""" - return xp.cos(x) + def arctan2(self, y: Any, x: Any) -> Any: + return self.xp.arctan2(y, x) + def angle(self, x: Any) -> Any: + return self.xp.angle(x) -def arctan2(y, x): - """Element-wise arctangent of y/x.""" - return xp.arctan2(y, x) + def isnan(self, x: Any) -> Any: + return self.xp.isnan(x) + def ceil(self, v: Any) -> int: + if self.xp is torch and TORCH_AVAILABLE and isinstance(v, torch.Tensor): + return int(self.xp.ceil(v)) + return int(np.ceil(v)) -def amin(x): - """Return minimum value.""" - return xp.amin(x) + # ------------------------------------------------------------------ + # Array construction helpers (library-agnostic once xp is known) + # ------------------------------------------------------------------ + def arange(self, *args, **kwargs) -> Any: + return self.xp.arange(*args, **kwargs) -def amax(x): - """Return maximum value.""" - return xp.amax(x) + def linspace(self, start, stop, num: int = 50, **kwargs) -> Any: + return self.xp.linspace(start, stop, num, **kwargs) + def meshgrid(self, *args, **kwargs) -> Any: + return self.xp.meshgrid(*args, **kwargs) -def arange(*args, **kwargs): - """Create array with evenly spaced values.""" - return xp.arange(*args, **kwargs) + def amin(self, x: Any) -> Any: + return self.xp.amin(x) + def amax(self, x: Any) -> Any: + return self.xp.amax(x) -def linspace(start, stop, num=50, **kwargs): - """Create array with evenly spaced values.""" - return xp.linspace(start, stop, num, **kwargs) + def argwhere(self, condition: Any) -> Any: + return self.xp.argwhere(condition) + # ------------------------------------------------------------------ + # Einstein summation — falls back to numpy for mixed operands + # ------------------------------------------------------------------ -def array_sum(x: Any, axis: Optional[int] = None, **kwargs: Any) -> Any: - """Sum elements along axis with kwarg conversion.""" - if TORCH_BACKEND and type(x) not in (np.memmap, np.ndarray): - if "axis" in kwargs: - kwargs["dim"] = kwargs.pop("axis") - return xp.sum(x, dim=axis, **kwargs) # type: ignore[attr-defined] - else: - if "dim" in kwargs: - kwargs["axis"] = kwargs.pop("dim") - return np.sum(x, axis=axis, **kwargs) # type: ignore[attr-defined] + def einsum(self, subscripts: str, *operands, **kwargs) -> Any: + has_numpy = any(self._is_numpy_array(o) for o in operands) + if self.xp is torch and not has_numpy: + return self.xp.einsum(subscripts, *operands, **kwargs) + return np.einsum(subscripts, *[to_cpu(o) for o in operands], + optimize=True, **kwargs) + # ------------------------------------------------------------------ + # Histogram — torch.histogram has CUDA limitations; always use numpy + # ------------------------------------------------------------------ -def array_mean(x, axis=None, **kwargs): - """Mean of elements along axis with kwarg conversion.""" - is_torch = TORCH_BACKEND and type(x) not in [np.memmap, np.ndarray] - - if "keepdims" in kwargs and not is_torch: - kwargs["keepdims"] = kwargs.pop("keepdims") - elif "keepdims" in kwargs and is_torch: - kwargs["keepdim"] = kwargs.pop("keepdims") - - if "keepdim" in kwargs and not is_torch: - kwargs["keepdims"] = kwargs.pop("keepdim") - - if "axis" in kwargs and is_torch: - kwargs["dim"] = kwargs.pop("axis") - elif "dim" in kwargs and not is_torch: - kwargs["axis"] = kwargs.pop("dim") - - if is_torch: - return xp.mean(x, dim=axis, **kwargs) - else: - return np.mean(x, axis=axis, **kwargs) + def histogram(self, a: Any, bins: Any): + """Compute histogram. Always falls back to NumPy for device compatibility.""" + return np.histogram(to_numpy(a), bins=to_numpy(bins)) + # ------------------------------------------------------------------ + # Chunked index utility + # ------------------------------------------------------------------ -def array_any(x): - """Test whether any array elements along a given axis evaluate to True.""" - return xp.any(x) + @staticmethod + def chunk_ids(N: int, chunksize: int = 1000): + """Return a list of numpy index arrays covering [0, N) in chunks.""" + return [np.arange(i, min(i + chunksize, N)) + for i in range(0, N, chunksize)] + # ------------------------------------------------------------------ + # Convenience properties mirroring the old module-level aliases + # ------------------------------------------------------------------ -def einsum(subscripts, *operands, **kwargs): - """Einstein summation convention.""" - #print([ (type(o),o.dtype) for o in operands]) - numpytypes = [ type(o) in [np.ndarray, np.memmap] for o in operands ] - if TORCH_BACKEND and True not in numpytypes: - return xp.einsum(subscripts, *operands, **kwargs) - else: - operands = [ to_cpu(o) for o in operands ] - return np.einsum(subscripts, *operands, optimize=True, **kwargs) + @property + def pi(self) -> float: + return self.xp.pi -def to_cpu(x): - """Convert tensor to CPU.""" - if isinstance(x, (np.ndarray, np.memmap)): - return x - elif TORCH_BACKEND and isinstance(x, torch.Tensor): - return x.cpu() - elif isinstance(x, (int, float, complex)): - return x - else: - return np.asarray(x) +# --------------------------------------------------------------------------- +# NumpyBackend +# --------------------------------------------------------------------------- +class NumpyBackend(Backend): + """Pure NumPy backend. No device concept; always CPU float64.""" -def to_numpy(x): - """Convert tensor to CPU NumPy array.""" - x = to_cpu(x) - if TORCH_BACKEND and isinstance(x, torch.Tensor): - return x.detach().numpy() - return x + xp = np + float_dtype = np.float64 + complex_dtype = np.complex128 + device = 'cpu' + _NUMPY_FLOAT_DTYPES = {np.float32, np.float64} + _NUMPY_COMPLEX_DTYPES = {np.complex64, np.complex128} + FLOAT_DTYPES = _NUMPY_FLOAT_DTYPES + COMPLEX_DTYPES = _NUMPY_COMPLEX_DTYPES -def reshape(x, shape): - """Reshape array.""" - if TORCH_BACKEND and isinstance(x, (np.ndarray, np.memmap)): - return np.reshape(x, shape) - return xp.reshape(x, shape) + _rng = np.random.default_rng() + def asarray(self, arraylike: Any, dtype=None, device=None) -> np.ndarray: + if dtype is None: + dtype = self.float_dtype + input_dtype = getattr(arraylike, 'dtype', None) + if dtype in self.FLOAT_DTYPES and input_dtype in self.COMPLEX_DTYPES: + arraylike = arraylike.real + return np.asarray(arraylike, dtype=dtype) -def expand_dims(x, axis): - """Expand array dimensions.""" - if TORCH_BACKEND: - return xp.unsqueeze(x, dim=axis) - else: - return np.expand_dims(x, axis) + def zeros(self, dims, dtype=None, device=None, type_match=None) -> np.ndarray: + dtype = self._resolve_dtype(dtype, type_match) + return np.zeros(dims, dtype=dtype) + def ones(self, dims, dtype=None, device=None) -> np.ndarray: + if dtype is None: + dtype = self.float_dtype + return np.ones(dims, dtype=dtype) -def stack(arrays, axis=0, **kwargs): - """Stack arrays.""" - if TORCH_BACKEND: - if "axis" in kwargs: - kwargs["dim"] = kwargs.pop("axis") - return xp.stack(arrays, dim=axis, **kwargs) - else: - if "dim" in kwargs: - kwargs["axis"] = kwargs.pop("dim") - return np.stack(arrays, axis=axis, **kwargs) + def fftfreq(self, n: int, d: float = 1.0, dtype=None, device=None) -> np.ndarray: + if dtype is None: + dtype = self.float_dtype + return np.fft.fftfreq(n, d).astype(dtype) + def randfloats(self, N: int, device=None, dtype=None) -> np.ndarray: + if dtype is None: + dtype = self.float_dtype + return self._rng.random(int(N)).astype(dtype) -def roll(x, shift, axis): - """Roll array along axis.""" - if TORCH_BACKEND: - return xp.roll(x, shifts=shift, dims=axis) - else: - return np.roll(x, shift, axis=axis) + def memmap(self, dims, dtype=None, filename: Optional[str] = None) -> np.memmap: + from numpy.lib.format import open_memmap + if dtype is None: + dtype = self.float_dtype + if filename is None: + logger.warning("memmap called without filename, falling back to zeros") + return self.zeros(dims, dtype=dtype) + logger.debug("creating memmap dtype=%s dims=%s filename=%s", dtype, dims, filename) + return open_memmap(filename, dtype=dtype, mode='w+', shape=dims) + + # ------------------------------------------------------------------ + # Helpers + # ------------------------------------------------------------------ + + def _resolve_dtype(self, dtype, type_match): + if type_match is not None and dtype is None: + dtype = type_match.dtype + if dtype is None: + dtype = self.float_dtype + if isinstance(dtype, str): + dtype = {'float': self.float_dtype, + 'complex': self.complex_dtype, + 'int': np.int64}[dtype] + return dtype + + +# --------------------------------------------------------------------------- +# TorchBackend +# --------------------------------------------------------------------------- + +class TorchBackend(Backend): + """PyTorch backend with automatic device detection.""" + + _NUMPY_FLOAT_DTYPES = {np.float32, np.float64} + _NUMPY_COMPLEX_DTYPES = {np.complex64, np.complex128} + + _TORCH_TO_NUMPY_DTYPE: dict = { + torch.complex128: np.complex128, + torch.complex64: np.complex64, + torch.float64: np.float64, + torch.float32: np.float32, + } if TORCH_AVAILABLE else {} + + def __init__(self, device: Optional[str] = None): + if not TORCH_AVAILABLE: + raise RuntimeError("PyTorch is not installed.") + self.xp = torch + self.device, self.float_dtype, self.complex_dtype = \ + self._detect_device_and_precision(device) + + self.FLOAT_DTYPES = (self._NUMPY_FLOAT_DTYPES | + {torch.float32, torch.float64}) + self.COMPLEX_DTYPES = (self._NUMPY_COMPLEX_DTYPES | + {torch.complex64, torch.complex128}) + + logger.debug("TorchBackend initialised: device=%s float_dtype=%s", + self.device, self.float_dtype) + + # ------------------------------------------------------------------ + # Device / precision detection (instance-level, not module-level) + # ------------------------------------------------------------------ + + def _detect_device_and_precision(self, device_spec: Optional[str]): + env_device = os.environ.get('PYSLICE_DEVICE', '').lower() + if env_device: + device_spec = env_device + + if device_spec is None: + if torch.cuda.is_available(): + device = torch.device('cuda') + elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): + device = torch.device('mps') + else: + device = torch.device('cpu') + else: + device = torch.device(device_spec) + + # MPS does not support float64 + if device.type == 'mps': + float_dtype = torch.float32 + complex_dtype = torch.complex64 + else: + float_dtype = torch.float64 + complex_dtype = torch.complex128 + + return device, float_dtype, complex_dtype + + # ------------------------------------------------------------------ + # Abstract method implementations + # ------------------------------------------------------------------ + + def asarray(self, arraylike: Any, dtype=None, device=None) -> Any: + if dtype is None: + dtype = self.float_dtype + if device is None: + device = self.device + input_dtype = getattr(arraylike, 'dtype', None) + if dtype in self.FLOAT_DTYPES and input_dtype in self.COMPLEX_DTYPES: + arraylike = arraylike.real + if hasattr(arraylike, 'detach'): # already a tensor + return arraylike.detach().clone().to(dtype=dtype, device=device) + return torch.tensor(arraylike, dtype=dtype, device=device) + + def zeros(self, dims, dtype=None, device=None, type_match=None) -> Any: + dtype, device = self._resolve_dtype_device(dtype, device, type_match) + if type_match is not None and self._is_numpy_array(type_match): + return np.zeros(dims, dtype=self._TORCH_TO_NUMPY_DTYPE.get(dtype, dtype)) + return torch.zeros(dims, dtype=dtype, device=device) + + def ones(self, dims, dtype=None, device=None) -> Any: + if dtype is None: + dtype = self.float_dtype + if device is None: + device = self.device + return torch.ones(dims, dtype=dtype, device=device) + def fftfreq(self, n: int, d: float = 1.0, dtype=None, device=None) -> Any: + if dtype is None: + dtype = self.float_dtype + if device is None: + device = self.device + logger.debug("fftfreq device=%s dtype=%s", device, dtype) + return torch.fft.fftfreq(n, d, dtype=dtype, device=device) + + def randfloats(self, N: int, device=None, dtype=None) -> Any: + if device is None: + device = self.device + if dtype is None: + dtype = self.float_dtype + return torch.rand(int(N), device=device, dtype=dtype) + + def memmap(self, dims, dtype=None, filename: Optional[str] = None) -> np.memmap: + from numpy.lib.format import open_memmap + if dtype is None: + dtype = self.float_dtype + if filename is None: + logger.warning("memmap called without filename, falling back to zeros") + return self.zeros(dims, dtype=dtype) + # memmaps are always numpy; convert torch dtype if needed + np_dtype = self._TORCH_TO_NUMPY_DTYPE.get(dtype, dtype) + logger.debug("creating memmap dtype=%s dims=%s filename=%s", + np_dtype, dims, filename) + return open_memmap(filename, dtype=np_dtype, mode='w+', shape=dims) + + # ------------------------------------------------------------------ + # Helpers + # ------------------------------------------------------------------ + + def _resolve_dtype_device(self, dtype, device, type_match): + if type_match is not None: + if dtype is None: + dtype = type_match.dtype + if device is None and hasattr(type_match, 'device'): + device = type_match.device + if dtype is None: + dtype = self.float_dtype + if device is None: + device = self.device + if isinstance(dtype, str): + dtype = {'float': self.float_dtype, + 'complex': self.complex_dtype, + 'int': torch.int64}[dtype] + return dtype, device + + +# --------------------------------------------------------------------------- +# Factory function +# --------------------------------------------------------------------------- + +def make_backend(device: Optional[str] = None) -> Backend: + """ + Return the appropriate backend based on environment and availability. + + The PYSLICE_BACKEND environment variable can be set to 'numpy' to force + the NumPy backend regardless of torch availability. + + Args: + device: Optional device string ('cpu', 'cuda', 'mps'). + Ignored when using the NumPy backend. + Can also be set via the PYSLICE_DEVICE environment variable. + + Returns: + A Backend instance (NumpyBackend or TorchBackend). + """ + backend_override = os.environ.get('PYSLICE_BACKEND', '').lower() + if backend_override == 'numpy' or not TORCH_AVAILABLE: + if backend_override == 'numpy' and device is not None: + logger.warning("device argument ignored for NumpyBackend") + return NumpyBackend() + return TorchBackend(device=device) -def log(x): - """Element-wise natural logarithm.""" - return xp.log(x) - - -def angle(x): - """Element-wise angle of complex number.""" - return xp.angle(x) - - -def isnan(x): - """Test element-wise for NaN.""" - return xp.isnan(x) - -def midcrop(a,n): # e.g. unshifted ks: 0,1,2,3,4.....-4,-3,-,2-1, crop out 3 through -3, the inverse of a[n:-n] - return xp.roll(xp.roll(a,len(a)//2)[n:-n],len(a)//2-n) - - -def ceil(v): - if TORCH_BACKEND and isinstance(v, torch.Tensor): - return int(xp.ceil(v)) - return int(np.ceil(v)) - - -def cumsum(a, axis=0): - if TORCH_BACKEND and isinstance(a, torch.Tensor): - return xp.cumsum(a, dim=axis) - return xp.cumsum(a, axis=axis) - - -def histogram(a, bins): - #print(bins) - #print(bins[1:]-bins[:-1]) - #return np.histogram(to_cpu(a),bins=to_cpu(bins)) - #if xp!=np and type(a)==torch.Tensor: # WHY ARE WE DOING THIS OURSELVES? not-implemented error for torch cuda - # #hist = zeros(len(bins)-1,type_match=bins) - # #mask = zeros(len(a),type_match=bins) - # #for i,(b1,b2) in enumerate(zip(bins[:-1],bins[1:])): - # # mask *= 0 - # # mask[a>=b1] = 1 ; mask[a>=b2] = 0 - # # hist[i] = xp.sum(mask) - # #return hist - hist = zeros(len(bins)-1,type_match=a) - for chunk in chunk_ids(len(bins)-1,1000): - db = bins[chunk+1]-bins[chunk] - diff = a[None,:]-bins[chunk,None] - diff[diff>db[:,None]]=-1 - diff[diff<0]=-1 - diff[diff!=-1]=1 - diff[diff==-1]=0 - hist[chunk]=xp.sum(diff,axis=1) - return hist - #return np.histogram(to_cpu(a),bins=to_cpu(bins))[0] - #return np.histogram(a,bins=bins)[0] - # torch.histogram has device limitations on CUDA; numpy fallback is correct and avoids - # large intermediate allocations from the manual chunked loop. - #return np.histogram(to_numpy(a), bins=to_numpy(bins)) - -def randfloats(N, device=None, dtype=None): - N = int(N) - if device is None: - device = DEFAULT_DEVICE - if dtype is None: - dtype = DEFAULT_FLOAT_DTYPE - if TORCH_BACKEND: - return torch.rand(N, device=device, dtype=dtype) - return _rng.random(N).astype(dtype) - - -def clone(a): - if hasattr(a,"clone"): - return a.clone() - if hasattr(a,"copy"): - return a.copy() - return a - - -def chunk_ids(N, chunksize=1000): - chunks = [] - for i in range(0, N, chunksize): - chunks.append(np.arange(i, min(i + chunksize, N))) - return chunks - - -# Keep legacy function for backward compatibility -def argwhere(condition): - """Return indices where condition is True.""" - return xp.argwhere(condition) diff --git a/src/pyslice/io/loader.py b/src/pyslice/io/loader.py index 206c4dd..73f4fb0 100644 --- a/src/pyslice/io/loader.py +++ b/src/pyslice/io/loader.py @@ -8,7 +8,7 @@ from typing import Optional, Dict, Union from ..multislice.trajectory import Trajectory -from ..multislice.potentials import getZfromElementName +from ..multislice.potentials import get_z_from_element # Try to import OVITO, but don't fail if it's not available try: @@ -72,7 +72,7 @@ def _process_atom_mapping(self, mapping: Optional[Dict[int, Union[int, str]]]) - for atom_type, value in mapping.items(): if isinstance(value, str): # Element name - convert to atomic number - result[atom_type] = getZfromElementName(value) + result[atom_type] = get_z_from_element(value) elif isinstance(value, int): # Already an atomic number if not (1 <= value <= 118): diff --git a/src/pyslice/multislice/calculators.py b/src/pyslice/multislice/calculators.py index 73dc41b..aeccb6c 100644 --- a/src/pyslice/multislice/calculators.py +++ b/src/pyslice/multislice/calculators.py @@ -1,42 +1,39 @@ -import pyslice.backend as backend import numpy as np from pathlib import Path import logging from typing import Optional, Tuple, List from tqdm import tqdm -import time,os +import time, os import hashlib -from .potentials import gridFromTrajectory,Potential -from .multislice import Probe,PrismProbe,Propagate,create_batched_probes +from .potentials import grid_from_trajectory, Potential +from .multislice import Probe, PrismProbe, Propagate, create_batched_probes from .trajectory import Trajectory from ..postprocessing.wf_data import WFData from .sed import SED +from pyslice.backend import make_backend, to_cpu, to_numpy, NumpyBackend -TORCH_BACKEND = backend.TORCH_BACKEND logger = logging.getLogger(__name__) class MultisliceCalculator: - + def __init__(self, device=None, force_cpu=False): """ - Initialize the PyTorch-accelerated calculator. + Initialize the multislice calculator. Args: - device: PyTorch device ('cpu', 'cuda', 'mps', or None for auto-detection) + device: Device string ('cpu', 'cuda', 'mps', or None for auto-detection) force_cpu: Force CPU usage even if GPU is available """ self.force_cpu = force_cpu if force_cpu: - self.device = backend.device_and_precision('cpu')[0] - elif device is not None: - self.device = backend.device_and_precision(device)[0] + self._backend = make_backend('cpu') else: - # Auto-detect best available device - self.device = backend.device_and_precision()[0] + self._backend = make_backend(device) + self.device = self._backend.device logger.info(f"Calculator initialized on device: {self.device}") - + # Element mapping for display purposes self.element_map = { 1: 'H', 2: 'He', 3: 'Li', 4: 'Be', 5: 'B', 6: 'C', 7: 'N', 8: 'O', @@ -45,15 +42,15 @@ def __init__(self, device=None, force_cpu=False): 23: 'V', 24: 'Cr', 25: 'Mn', 26: 'Fe', 27: 'Co', 28: 'Ni', 29: 'Cu', 30: 'Zn', 31: 'Ga', 32: 'Ge', 33: 'As', 34: 'Se', 35: 'Br', 36: 'Kr' } - + def _generate_cache_key(self, trajectory, aperture, voltage_eV, - slice_thickness, sampling, probe_positions, - spatial_decoherence, temporal_decoherence, - probe_array=None): + slice_thickness, sampling, probe_positions, + spatial_decoherence, temporal_decoherence, + probe_array=None): """Generate unique cache key for simulation parameters.""" - firstNAtoms = [ str(np.round(v,4)) for v in trajectory.positions[0,:100,0] ] # first timestep's first 10 atom's x positions + firstNAtoms = [str(np.round(v, 4)) for v in trajectory.positions[0, :100, 0]] # first timestep's first 10 atom's x positions params = { - 'firstNAtoms': ",".join(firstNAtoms), # WHY? prevents the same script from re-using psi_data when positions change + 'firstNAtoms': ",".join(firstNAtoms), # WHY? prevents the same script from re-using psi_data when positions change 'n_frames': trajectory.n_frames, 'n_atoms': trajectory.n_atoms, 'box_matrix': trajectory.box_matrix.tolist(), @@ -63,18 +60,18 @@ def _generate_cache_key(self, trajectory, aperture, voltage_eV, 'slice_thickness': slice_thickness, 'sampling': sampling, 'probe_positions': probe_positions, - 'backend': 'torch' if backend.xp != np else 'numpy', + 'backend': 'torch' if self._backend.xp is not np else 'numpy', } if spatial_decoherence is not None: params['spatial_decoherence'] = spatial_decoherence if temporal_decoherence is not None: params['temporal_decoherence'] = temporal_decoherence if probe_array is not None: - probe_np = np.ascontiguousarray(backend.to_cpu(probe_array).ravel()[:1000]) + probe_np = np.ascontiguousarray(to_cpu(probe_array).ravel()[:1000]) params['probe_hash'] = hashlib.md5(probe_np.tobytes()).hexdigest() param_str = str(sorted(params.items())) return hashlib.md5(param_str.encode()).hexdigest()[:12] - + def setup( self, trajectory: Trajectory, @@ -90,21 +87,21 @@ def setup( save_path: Optional[Path] = None, cleanup_temp_files: bool = False, slice_axis: int = 2, - cache_levels: list = ["exitwaves"], # options include: exitwaves, slices, potentials (this replaces store_all_slices) - max_kx = np.inf, - max_ky = np.inf, - use_memmap = False, - loop_probes = False, - min_dk = 0, - prism = False, + cache_levels: list = ["exitwaves"], # options include: exitwaves, slices, potentials (this replaces store_all_slices) + max_kx=np.inf, + max_ky=np.inf, + use_memmap=False, + loop_probes=False, + min_dk=0, + prism=False, kth=1, ADF=False, store_full=True, skip_vacuum=False ): """ - Set up multislice simulation using PyTorch acceleration. - + Set up multislice simulation. + Args: trajectory: Input trajectory data aperture: Objective aperture semi-angle in mrad @@ -118,6 +115,7 @@ def setup( cleanup_temp_files: Whether to delete temp files after loading store_all_slices: If True, store wavefunction at each slice for 3D visualization """ + b = self._backend self.trajectory = trajectory self.aperture = aperture @@ -144,34 +142,32 @@ def setup( self.skip_vacuum = skip_vacuum # bool: if True, we skip propagation of probes in locations where there are no atoms # Set up spatial grids - xs,ys,zs,lx,ly,lz=gridFromTrajectory(trajectory,sampling=sampling,slice_thickness=slice_thickness) - nx=len(xs) ; ny=len(ys) ; nz=len(zs) - self.xs = xs ; self.ys = ys ; self.zs = zs - self.lx = lx ; self.ly = ly ; self.lz = lz - self.nx = nx ; self.ny = ny ; self.nz = nz - self.dx = xs[1]-xs[0] ; self.dy = ys[1]-ys[0] ; self.dy = ys[1]-ys[0] - + xs, ys, zs, lx, ly, lz = grid_from_trajectory(trajectory, sampling=sampling, slice_thickness=slice_thickness) + nx = len(xs); ny = len(ys); nz = len(zs) + self.xs = xs; self.ys = ys; self.zs = zs + self.lx = lx; self.ly = ly; self.lz = lz + self.nx = nx; self.ny = ny; self.nz = nz + self.dx = xs[1]-xs[0]; self.dy = ys[1]-ys[0] self.probe_cropping = 0 - if self.min_dk > 0: # dk = 1/L = 1/(nx*sampling) + if self.min_dk > 0: # dk = 1/L = 1/(nx*sampling) nx = int(np.round(1/(self.min_dk*self.sampling))) - self.nx = nx ; self.ny = nx # Q: check this for non square super cells + self.nx = nx; self.ny = nx # Q: check this for non square super cells self.probe_cropping = nx - self.kxs = backend.fftshift(backend.fftfreq(self.nx, self.sampling)) # k-space in 1/Å - self.kys = backend.fftshift(backend.fftfreq(self.ny, self.sampling)) # k-space in 1/Å - kx_mask = backend.zeros(self.nx)+1 ; ky_mask = backend.zeros(self.ny)+1 - kx_mask[ self.kxs < -max_kx ] = 0 ; kx_mask[ self.kxs > max_kx ] = 0 - ky_mask[ self.kys < -max_ky ] = 0 ; ky_mask[ self.kys > max_ky ] = 0 - self.keep_kxs_indices = backend.arange(self.nx)[kx_mask==1][::self.kth] - self.keep_kys_indices = backend.arange(self.ny)[ky_mask==1][::self.kth] - self.nx = len(self.keep_kxs_indices) ; self.ny = len(self.keep_kys_indices) - #print("kxs",len(self.kxs),"kys",len(self.kys),"nx",self.nx,"ny",self.ny,"keepkx",len(self.keep_kxs_indices),"keepky",len(self.keep_kys_indices)) + self.kxs = b.fftshift(b.fftfreq(self.nx, self.sampling)) # k-space in 1/Å + self.kys = b.fftshift(b.fftfreq(self.ny, self.sampling)) # k-space in 1/Å + kx_mask = b.zeros(self.nx)+1; ky_mask = b.zeros(self.ny)+1 + kx_mask[self.kxs < -max_kx] = 0; kx_mask[self.kxs > max_kx] = 0 + ky_mask[self.kys < -max_ky] = 0; ky_mask[self.kys > max_ky] = 0 + self.keep_kxs_indices = b.arange(self.nx)[kx_mask==1][::self.kth] + self.keep_kys_indices = b.arange(self.ny)[ky_mask==1][::self.kth] + self.nx = len(self.keep_kxs_indices); self.ny = len(self.keep_kys_indices) # Preferred to pass probe_xs and probe_ys from which we will define a grid if self.probe_xs is not None and self.probe_ys is not None: - x,y = np.meshgrid(self.probe_xs,self.probe_ys) - self.probe_positions = np.reshape([x,y],(2,len(x.flat))).T # x,y looped indices to match what multislice.Probe does + x, y = np.meshgrid(self.probe_xs, self.probe_ys) + self.probe_positions = np.reshape([x, y], (2, len(x.flat))).T # x,y looped indices to match what multislice.Probe does # If probe_positions provided but not probe_xs/probe_ys, derive them elif self.probe_positions is not None: @@ -182,25 +178,24 @@ def setup( # Set up default probe position if not provided if self.probe_positions is None: self.probe_positions = [(lx/2, ly/2)] # Center probe - self.probe_xs = [lx/2] ; self.probe_ys = [ly/2] + self.probe_xs = [lx/2]; self.probe_ys = [ly/2] if self.prism: # Prism algorithm works by passing a series of sinusoids (fourier components shared by all probes) through the sample. "PrismProbe" will therefore give us a series of sinusoids, and there is a reconstruction step later - self.base_probe = PrismProbe(xs, ys, self.aperture, self.voltage_eV, device=self.device, nkx=self.prism, kth=self.kth) + self.base_probe = PrismProbe(xs, ys, self.aperture, self.voltage_eV, backend=b, nkx=self.prism, kth=self.kth) else: # OR, we'll propagate our series of real-space probes. # need to make sure they're on the correct device, and defer_shifts=True means the calculator controls when to expand the probe cube (see loop_probes) - self.base_probe = Probe(xs, ys, self.aperture, self.voltage_eV, device=self.device, probe_xs=self.probe_xs, probe_ys=self.probe_ys, probe_positions=self.probe_positions,cropping=self.probe_cropping, defer_shifts=True) + self.base_probe = Probe(xs, ys, self.aperture, self.voltage_eV, backend=b, probe_xs=self.probe_xs, probe_ys=self.probe_ys, probe_positions=self.probe_positions, cropping=self.probe_cropping, defer_shifts=True) if not self.loop_probes: self.base_probe.applyShifts() # Initialize storage for results self.n_frames = trajectory.n_frames - #self.n_probes = len(self.base_probe.probe_positions) - # Set dtype based on the actual device we're using - _, self.float_dtype, self.complex_dtype = backend.device_and_precision(self.device) + self.float_dtype = b.float_dtype + self.complex_dtype = b.complex_dtype # cache key is calculated TWICE: once during setup (so the user only needs to setup to infer where their cache folder will go), and again during run (just in case the user does something funky) # Generate cache key and setup output directory @@ -210,12 +205,10 @@ def setup( self.base_probe.spatial_decoherence, self.base_probe.temporal_decoherence, self.base_probe._array, ) - #print(cache_key) - self.output_dir = Path("psi_data/" + ("torch" if hasattr(self.base_probe._array, 'device') else "numpy") + "_"+self.cache_key) - #self.output_dir.mkdir(parents=True, exist_ok=True) - #self.output_dir.mkdir(parents=True, exist_ok=True) + self.output_dir = Path("psi_data/" + ("torch" if not isinstance(b, NumpyBackend) else "numpy") + "_"+self.cache_key) def preview_probes(self): + b = self._backend positions = self.trajectory.positions[0] atom_types = self.trajectory.atom_types atom_type_names = [] @@ -224,70 +217,64 @@ def preview_probes(self): atom_type_names.append(self.element_map[atom_type]) else: atom_type_names.append(atom_type) - potential = Potential(self.xs, self.ys, self.zs, positions, atom_type_names, kind="kirkland", device=self.device, slice_axis=self.slice_axis) + potential = Potential(self.xs, self.ys, self.zs, positions, atom_type_names, backend=b, kind="kirkland", slice_axis=self.slice_axis) potential.build() potential.flatten() import matplotlib.pyplot as plt fig, ax = plt.subplots() - array = np.backend.absolute(backend.to_cpu(potential.array))[:,::-1,0].T # imshow convention: y,x. our convention: x,y, and flip y (0,0 upper-left) - xs = backend.to_cpu(potential.xs) ; ys = backend.to_cpu(potential.ys) - extent = (np.amin(xs),np.amax(xs),np.amin(ys),np.amax(ys)) - #print(extent) + array = np.absolute(to_cpu(potential.array))[:, ::-1, 0].T # imshow convention: y,x. our convention: x,y, and flip y (0,0 upper-left) + xs = to_cpu(potential.xs); ys = to_cpu(potential.ys) + extent = (np.amin(xs), np.amax(xs), np.amin(ys), np.amax(ys)) ax.imshow(array, cmap="inferno", extent=extent) - ax.set_xlabel("x ($\\AA$)") ; ax.set_ylabel("y ($\\AA$)") + ax.set_xlabel("x ($\\AA$)"); ax.set_ylabel("y ($\\AA$)") pp = np.asarray(self.base_probe.probe_positions) - ax.scatter(pp[:,0],pp[:,1],c='r') + ax.scatter(pp[:, 0], pp[:, 1], c='r') plt.show() #@profile def run(self) -> WFData: + b = self._backend # cache key is calculated TWICE: once during setup (so the user only needs to setup to infer where their cache folder will go), and again during run (just in case the user does something funky) # Generate cache key and setup output directory cache_key = self._generate_cache_key(self.trajectory, self.aperture, self.voltage_eV, - self.slice_thickness, self.sampling, self.probe_positions, - self.base_probe.spatial_decoherence, self.base_probe.temporal_decoherence, - self.base_probe._array) + self.slice_thickness, self.sampling, self.probe_positions, + self.base_probe.spatial_decoherence, self.base_probe.temporal_decoherence, + self.base_probe._array) if self.cache_key != cache_key: self.cache_key = cache_key - #print(cache_key) - self.output_dir = Path("psi_data/" + ("torch" if backend.xp != np else "numpy") + "_"+cache_key) + self.output_dir = Path("psi_data/" + ("torch" if b.xp is not np else "numpy") + "_"+cache_key) self.output_dir.mkdir(parents=True, exist_ok=True) - # if probes are over vacuum (e.g. nanoparticles), we don't need to propagate them? - self.probe_indices = backend.arange(len(self.probe_positions)) - if self.skip_vacuum and len(self.probe_positions)>1 and self.aperture>1 and self.min_dk: + self.probe_indices = b.arange(len(self.probe_positions)) + if self.skip_vacuum and len(self.probe_positions) > 1 and self.aperture > 1 and self.min_dk: if os.path.exists(self.output_dir / f"probe_indices.npy"): self.probe_indices = np.load(self.output_dir / f"probe_indices.npy") else: - xy_atoms = asarray(self.trajectory.positions[0,:,:2]) + xy_atoms = b.asarray(self.trajectory.positions[0, :, :2]) self.probe_indices = [] - for i,p in enumerate(tqdm(self.probe_positions)): - p = asarray(p) - d_to_nearest_atom = backend.sqrt( backend.amin( backend.array_sum( (p[None,:]-xy_atoms)**2,axis=1) ) ) + for i, p in enumerate(tqdm(self.probe_positions)): + p = b.asarray(p) + d_to_nearest_atom = b.sqrt(b.amin(b.sum((p[None, :]-xy_atoms)**2, axis=1))) if d_to_nearest_atom < self.probe_cropping*self.sampling: self.probe_indices.append(i) np.save(self.output_dir / f"probe_indices.npy", self.probe_indices) - self.probe_indices = asarray(self.probe_indices) - print("filtered to",len(self.probe_indices),"probe positions") + self.probe_indices = b.asarray(self.probe_indices) + print("filtered to", len(self.probe_indices), "probe positions") - - nc,npt,nx,ny = self.base_probe._array.shape + nc, npt, nx, ny = self.base_probe._array.shape self.n_probes = nc*len(self.probe_positions) # Storage: [probe, frame, x, y, layer] - matches WFData expected format self.n_layers = self.nz if "slices" in self.cache_levels else 1 if self.store_full: - fd_nx = self.nx ; fd_ny = self.ny ; fd_npt = self.n_probes - #if self.base_probe.cropping: - # fd_nx = self.base_probe.cropping ; fd_ny = fd_nx + fd_nx = self.nx; fd_ny = self.ny; fd_npt = self.n_probes if self.use_memmap: - self.wavefunction_data = backend.memmap((fd_npt, self.n_frames, fd_nx, fd_ny, self.n_layers), - dtype=self.complex_dtype, filename = self.output_dir / "wdf_memmap.npy" ) + self.wavefunction_data = b.memmap((fd_npt, self.n_frames, fd_nx, fd_ny, self.n_layers), + dtype=self.complex_dtype, filename=self.output_dir / "wdf_memmap.npy") else: - self.wavefunction_data = backend.zeros((fd_npt, self.n_frames, fd_nx, fd_ny, self.n_layers), - dtype=self.complex_dtype, device=self.device) - #print("wavefunction_data",self.wavefunction_data.shape) + self.wavefunction_data = b.zeros((fd_npt, self.n_frames, fd_nx, fd_ny, self.n_layers), + dtype=self.complex_dtype) # Process frames with caching and multiprocessing total_start_time = time.time() @@ -295,36 +282,34 @@ def run(self) -> WFData: frames_cached = 0 # quality of life sanity checks: user may have set things (e.g. probe array) with the wrong data type (e.g. numpy instead of tensor). let's try to catch and correct those here - if isinstance(self.base_probe._array,np.ndarray) and TORCH_BACKEND: - self.base_probe._array = backend.tensor(self.base_probe._array) + if isinstance(self.base_probe._array, np.ndarray) and not isinstance(b, NumpyBackend): + self.base_probe._array = b.asarray(self.base_probe._array) - if self.ADF: # create a dummy HAADFData object, first so we can hijack its getMask function, and later we'll load it up + if self.ADF: # create a dummy HAADFData object, first so we can hijack its getMask function, and later we'll load it up kwargs = {} - if not isinstance(self.ADF,bool): - kwargs["inner_mrad"],kwargs["outer_mrad"] = self.ADF + if not isinstance(self.ADF, bool): + kwargs["inner_mrad"], kwargs["outer_mrad"] = self.ADF from ..postprocessing.haadf_data import HAADFData - array = backend.zeros((self.n_probes,1,1,1,1),dtype=self.complex_dtype) - array += backend.arange(self.n_probes)[:,None,None,None,None] # we'll use this as an index to map nth probe to the ADF grid coordinates i,j - wf = WFData(probe_positions=self.probe_positions,probe_xs=self.probe_xs,probe_ys=self.probe_ys, - time=None,kxs=self.kxs[self.keep_kxs_indices],kys=self.kys[self.keep_kys_indices],xs=self.xs,ys=self.ys, - layer=None,array=array,probe=self.base_probe,cache_dir=self.output_dir) + array = b.zeros((self.n_probes, 1, 1, 1, 1), dtype=self.complex_dtype) + array += b.arange(self.n_probes)[:, None, None, None, None] # we'll use this as an index to map nth probe to the ADF grid coordinates i,j + wf = WFData(probe_positions=self.probe_positions, probe_xs=self.probe_xs, probe_ys=self.probe_ys, + time=None, kxs=self.kxs[self.keep_kxs_indices], kys=self.kys[self.keep_kys_indices], xs=self.xs, ys=self.ys, + layer=None, array=array, probe=self.base_probe, backend=b, cache_dir=self.output_dir) self.ADF = HAADFData(wf) - self.ADFmask = backend.absolute(self.ADF.getMask(**kwargs)) # HAADFData infers mask dtype from _wf_array dtype, but we'll absolute^2 later - self.ADFindex = backend.astype(backend.absolute(self.ADF._wf_array[0,:,:,0,0,0,0]),int) - self.ADF._array = backend.zeros(self.ADFindex.shape,dtype=self.complex_dtype) + self.ADFmask = b.absolute(self.ADF.getMask(**kwargs)) # HAADFData infers mask dtype from _wf_array dtype, but we'll absolute^2 later + self.ADFindex = b.astype(b.absolute(self.ADF._wf_array[0, :, :, 0, 0, 0, 0]), int) + self.ADF._array = b.zeros(self.ADFindex.shape, dtype=self.complex_dtype) # Process frames one at a time with tqdm progress tracking with tqdm(total=self.n_frames, desc="Processing frames", unit="frame") as pbar: for frame_idx in range(self.n_frames): - #if sum(backend.absolute(self.wavefunction_data[:,frame_idx,:,:,:]),axis=(0,1,2,3))>0: # p,t,x,y,l indices - #continue cache_file = self.output_dir / f"frame_{frame_idx}.npy" # Show detailed progress for single-frame runs show_progress = (frame_idx == 0 and self.n_frames == 1 and not self.loop_probes) # special case: no frames cached, but we clearly finished and got to tacaw. if so, don't bother regenerating # this allows cache_levels = [] to be used for disk space savings - if os.path.exists( self.output_dir / f"tacaw.npy" ) and not os.path.exists( cache_file ): + if os.path.exists(self.output_dir / f"tacaw.npy") and not os.path.exists(cache_file): pbar.update(1) continue @@ -338,164 +323,118 @@ def run(self) -> WFData: atom_type_names.append(atom_type) # frame_data should always be shaped: n_probes,nkx,nky,n_layers,1 (idk why there's a trailing 1) - cache_exists,frame_data = checkCache(cache_file,self.cache_levels) + cache_exists, frame_data = checkCache(cache_file, self.cache_levels, b) if cache_exists and not self.prism and self.ADF: - intensities = backend.einsum('pxyln,xy->p',backend.absolute(frame_data)**2,self.ADFmask) + intensities = b.einsum('pxyln,xy->p', b.absolute(frame_data)**2, self.ADFmask) self.ADF._array += intensities[self.ADFindex] if not os.path.exists(self.output_dir / f"kx.npy"): - np.save(self.output_dir / f"kx.npy",backend.to_cpu(self.kxs[self.keep_kxs_indices])) - np.save(self.output_dir / f"ky.npy",backend.to_cpu(self.kys[self.keep_kys_indices])) - if len(self.kxs)!=self.nx and not os.path.exists(self.output_dir / f"kx_uncrop.npy"): - np.save(self.output_dir / f"kx_uncrop.npy",backend.to_cpu(self.kxs)) - if len(self.kys)!=self.ny and not os.path.exists(self.output_dir / f"ky_uncrop.npy"): - np.save(self.output_dir / f"ky_uncrop.npy",backend.to_cpu(self.kys)) + np.save(self.output_dir / f"kx.npy", to_cpu(self.kxs[self.keep_kxs_indices])) + np.save(self.output_dir / f"ky.npy", to_cpu(self.kys[self.keep_kys_indices])) + if len(self.kxs) != self.nx and not os.path.exists(self.output_dir / f"kx_uncrop.npy"): + np.save(self.output_dir / f"kx_uncrop.npy", to_cpu(self.kxs)) + if len(self.kys) != self.ny and not os.path.exists(self.output_dir / f"ky_uncrop.npy"): + np.save(self.output_dir / f"ky_uncrop.npy", to_cpu(self.kys)) if cache_exists: frames_cached += 1 else: - #print("create potential") ; start = time.time() potential = Potential( - self.xs, self.ys, self.zs, + self.xs, self.ys, self.zs, positions, atom_type_names, - kind="kirkland", device=self.device, - slice_axis=self.slice_axis, - progress=show_progress, + backend=b, + kind="kirkland", + slice_axis=self.slice_axis, cache_dir=cache_file.parent if "potentials" in self.cache_levels else None, - frame_idx = frame_idx) - #print("(done)",time.time()-start) - #n_probes = nc*npt - nc,npt,nx,ny = self.base_probe._array.shape ; npt = len(self.base_probe.probe_positions) + frame_idx=frame_idx) + + nc, npt, nx, ny = self.base_probe._array.shape; npt = len(self.base_probe.probe_positions) n_slices = len(self.zs) n_waves = len(self.base_probe.probe_positions) - #n_waves = - #if self.base_probe.cropping: - # nx,ny = self.base_probe.cropping,self.base_probe.cropping - #print("create frame_data") ; start = time.time() # frame_data is always: p,x,y,l,1 (self.wavefunction_data expects p,t,x,y,l, since we loop time. recall Propagate gave l,p,x,y) if self.store_full or self.prism: - fd_nx = self.nx ; fd_ny = self.ny ; fd_npt = self.n_probes - #if self.base_probe.cropping: - # fd_nx = self.base_probe.cropping ; fd_ny = fd_nx # ceil(/self.kth) ; + fd_nx = self.nx; fd_ny = self.ny; fd_npt = self.n_probes if self.use_memmap: - frame_data = backend.memmap((n_waves, fd_nx, fd_ny, self.n_layers,1), dtype=self.complex_dtype, filename = cache_file ) + frame_data = b.memmap((n_waves, fd_nx, fd_ny, self.n_layers, 1), dtype=self.complex_dtype, filename=cache_file) else: - frame_data = backend.zeros((n_waves, fd_nx, fd_ny, self.n_layers,1), dtype=self.complex_dtype, device=self.device) - #print("frame_data",frame_data.shape) - #print("(done)",time.time()-start) + frame_data = b.zeros((n_waves, fd_nx, fd_ny, self.n_layers, 1), dtype=self.complex_dtype) - #batched_probes = create_batched_probes(self.base_probe, self.probe_positions, self.device) # Propagate returns: [l,p,x,y] where l,p are both optional (if store_all_slices=True, and if n_probes>1) - #print("chunking") ; start = time.time() chunks = [] if self.loop_probes: - chunksize = self.loop_probes if isinstance(self.loop_probes,int) else 1 + chunksize = self.loop_probes if isinstance(self.loop_probes, int) else 1 for i in range(10000000): - chunk = backend.arange(i*chunksize,(i+1)*chunksize) - #chunk = chunk[chunknpt: + chunk_np = to_numpy(chunk) + indices_np = to_numpy(self.probe_indices) + chunk = b.asarray(chunk_np[np.any(indices_np[None, :] == chunk_np[:, None], axis=1)]) + if (i+1)*chunksize > npt: break - if len(chunk)==0: + if len(chunk) == 0: continue chunks.append(chunk) - pbar2 = tqdm(total = npt, desc = "looping probes", unit="probe") + pbar2 = tqdm(total=npt, desc="looping probes", unit="probe") else: - chunks.append( backend.arange(npt) ) + chunks.append(b.arange(npt)) pbar2 = None - #print("(done)",time.time()-start) for selected in chunks: - if len(selected)==npt: + if len(selected) == npt: probe = self.base_probe else: probe = self.base_probe.copy(selected_probes=selected) probe.applyShifts() # propagate single probe - #print("propagate") ; start = time.time() - exit_waves_single = Propagate(probe, potential, self.device, progress=show_progress, onthefly=True, store_all_slices = ("slices" in self.cache_levels) ) # [l],p,x,y indices - #print("(done)",time.time()-start) + exit_waves_single = Propagate(probe, potential, b, progress=show_progress, onthefly=True, store_all_slices=("slices" in self.cache_levels)) # [l],p,x,y indices # expand out to fixed l,p,x,y indices - exit_waves_single = backend.expand_dims(exit_waves_single,0) if len(exit_waves_single.shape)==3 else exit_waves_single + exit_waves_single = b.expand_dims(exit_waves_single, 0) if len(exit_waves_single.shape) == 3 else exit_waves_single # FFT and load into frame_data - always use 'axes' and let backend handle conversion - kwarg = {"axes":(-2,-1)} for layer_idx in range(self.n_layers): - exit_waves_k = backend.fft2(exit_waves_single[layer_idx,:,:,:], **kwarg) # l,p,x,y --> p,x,y - diffraction_patterns = backend.fftshift(exit_waves_k, **kwarg) - #if not self.prism: - diffraction_patterns = diffraction_patterns[:,self.keep_kxs_indices,:][:,:,self.keep_kys_indices]*self.kth**2 + exit_waves_k = b.fft2(exit_waves_single[layer_idx, :, :, :], axes=(-2, -1)) # l,p,x,y --> p,x,y + diffraction_patterns = b.fftshift(exit_waves_k, axes=(-2, -1)) + diffraction_patterns = diffraction_patterns[:, self.keep_kxs_indices, :][:, :, self.keep_kys_indices]*self.kth**2 if self.use_memmap: - diffraction_patterns = backend.to_cpu(diffraction_patterns) - selected = backend.to_cpu(selected) + diffraction_patterns = to_cpu(diffraction_patterns) + selected = to_cpu(selected) if self.store_full or self.prism: - frame_data[selected,:,:,layer_idx,0] = diffraction_patterns # load p,x,y --> p,x,y,l,1 indices + frame_data[selected, :, :, layer_idx, 0] = diffraction_patterns # load p,x,y --> p,x,y,l,1 indices if self.ADF and not self.prism: - #print(self.ADF._wf_array[0,:,:,0,0,0,0]) - intensities = backend.einsum('pxy,xy->p', backend.absolute(diffraction_patterns[:,:,:])**2,self.ADFmask) - for i,pp in zip(intensities,selected): + intensities = b.einsum('pxy,xy->p', b.absolute(diffraction_patterns[:, :, :])**2, self.ADFmask) + for i, pp in zip(intensities, selected): self.ADF._array[self.ADFindex==pp] += i if pbar2 is not None: pbar2.update(int(max(selected))-pbar2.n) -# else: -# # simultaneously propagate all probes at once, [l],p,x,y -# exit_waves_batch = Propagate(self.base_probe, potential, self.device, progress=show_progress, onthefly=True, store_all_slices = ("slices" in self.cache_levels) ) -# # expand out to fixed l,p,x,y indices -# exit_waves_batch = expand_dims(exit_waves_batch,0) if len(exit_waves_batch.shape)==3 else exit_waves_batch -# # FFT and load into frame_data -# for layer_idx in range(self.n_layers): -# kwarg = {"dim":(-2,-1)} if hasattr(self.base_probe._array, 'device') else {"axes":(-2,-1)} -# exit_waves_k = backend.fft.fft2(exit_waves_batch[layer_idx,:,:,:], **kwarg) # l,p,x,y --> p,x,y -# diffraction_patterns = backend.fft.fftshift(exit_waves_k, **kwarg) -# #cropped = diffraction_patterns[:,self.i1:self.i2,self.j1:self.j2] -# #if not self.prism: -# diffraction_patterns = diffraction_patterns[:,self.keep_kxs_indices,:][:,:,self.keep_kys_indices]*self.kth**2 -# if self.use_memmap: -# diffraction_patterns = to_cpu(diffraction_patterns) -# if self.store_full or self.prism: -# frame_data[:,:,:,layer_idx,0] = diffraction_patterns # load p,x,y --> p,x,y,l,1 indices -# if self.ADF and not self.prism: -# intensities = backend.einsum('pxy,xy->p',backend.absolute(diffraction_patterns)**2,self.ADFmask) -# #print(type(self.ADF._array),type(intensities),type(self.ADFindex)) -# if self.use_memmap: -# intensities = asarray(intensities,device=self.device) -# self.ADF._array += intensities[self.ADFindex] -# #self.ADF._array = backend.einsum('pxyln,'frame_data - - - if not self.use_memmap and ( "exitwaves" in self.cache_levels or "slices" in self.cache_levels ) and (self.store_full or self.prism): + + if not self.use_memmap and ("exitwaves" in self.cache_levels or "slices" in self.cache_levels) and (self.store_full or self.prism): # Convert to CPU numpy array for saving - frame_data_cpu = backend.to_cpu(frame_data) + frame_data_cpu = to_cpu(frame_data) np.save(cache_file, frame_data_cpu) frames_computed += 1 - #print(frame_data.shape,self.wavefunction_data.shape) if self.store_full or self.prism: - cropped = frame_data[:,:,:,:,0] - #print(cropped.shape) - #if self.use_memmap: - # cropped = backend.to_cpu(cropped) + cropped = frame_data[:, :, :, :, 0] if self.prism: # Recall: Prism algorithm passes a series of sinusoids through the sample (fourier components shared by all real-space probes), so now for each real-space probe, we need to calculate the exitwaves from components - kwarg ={} + kwarg = {} if self.ADF: - kwarg["ADF"]=(self.ADF,self.ADFmask,self.ADFindex) + kwarg["ADF"] = (self.ADF, self.ADFmask, self.ADFindex) if self.store_full: - kwarg["load_into"]=self.wavefunction_data[:,frame_idx,:,:,0] - self.base_probe.calculateProbesFromS(frame_data,self.probe_positions,**kwarg,chunksize=self.loop_probes) + kwarg["load_into"] = self.wavefunction_data[:, frame_idx, :, :, 0] + self.base_probe.calculateProbesFromS(frame_data, self.probe_positions, **kwarg, chunksize=self.loop_probes) elif self.store_full: if self.use_memmap: cropped = to_cpu(cropped) - self.wavefunction_data[:, frame_idx, :, :, :] = cropped # load p,x,y,l,1 --> p,t,x,y,l indices + self.wavefunction_data[:, frame_idx, :, :, :] = cropped # load p,x,y,l,1 --> p,t,x,y,l indices # Update progress bar for this frame pbar.update(1) - + total_time = time.time() - total_start_time logger.info(f"Simulation completed in {total_time:.2f}s ({frames_computed} computed, {frames_cached} cached)") - + # Create metadata params = { 'aperture': self.aperture, @@ -508,23 +447,16 @@ def run(self) -> WFData: 'n_atoms': self.trajectory.n_atoms, 'calculator': 'MultisliceCalculator' } - + # Create coordinate arrays for output # Note: WFData expects (probe_positions, time, kx, ky, layer) format - # Create k-space coordinates to match expected format (same as AbTem) - # TWP: If we're not going to also provide a shifted/etc reciprocal_array, we shouldn't shift the kxs - #kxs = backend.fft.fftfreq(self.nx, d=self.dx) - #kys = backend.fft.fftfreq(self.ny, d=self.dy) - #kxs = backend.fft.fftshift(backend.fft.fftfreq(self.nx, self.sampling)) # k-space in 1/Å MOVING TO INIT SO WE CAN CROP ON-THE-FLY - #kys = backend.fft.fftshift(backend.fft.fftfreq(self.ny, self.sampling)) # k-space in 1/Å time_array = np.arange(self.n_frames) * self.trajectory.timestep # Time array in ps layer_array = np.arange(self.nz) if "slices" in self.cache_levels else np.array([0]) # Layer indices - + # Package results - array = backend.zeros((self.n_probes,1,1,1,1),dtype=self.complex_dtype) + array = b.zeros((self.n_probes, 1, 1, 1, 1), dtype=self.complex_dtype) if self.store_full: array = self.wavefunction_data - #print(array.shape,self.kxs.shape,self.kys.shape) wf_data = WFData( probe_positions=self.probe_positions, probe_xs=self.probe_xs, @@ -537,9 +469,10 @@ def run(self) -> WFData: layer=layer_array, array=array, probe=self.base_probe, + backend=b, cache_dir=self.output_dir ) - + # Handle cleanup if self.cleanup_temp_files: logger.info("Cleaning up cache files...") @@ -553,80 +486,79 @@ def run(self) -> WFData: pass else: logger.info(f"Cache files saved in: {self.output_dir}") - - # Save if requested - psi files already saved during processing - + if self.ADF: - self.ADF._array /= self.n_frames # haadf_data divides by nc,nt,nl (from _wf_array's c,x,y,t,kx,ky,l) - return wf_data,self.ADF + self.ADF._array /= self.n_frames # haadf_data divides by nc,nt,nl (from _wf_array's c,x,y,t,kx,ky,l) + return wf_data, self.ADF return wf_data -logging_tracker=[] -def checkCache(cache_file,cache_levels): + +logging_tracker = [] + +def checkCache(cache_file, cache_levels, b): global logging_tracker - if cache_file.exists() and ( "exitwaves" in cache_levels or "slices" in cache_levels ): + if cache_file.exists() and ("exitwaves" in cache_levels or "slices" in cache_levels): parent = str(cache_file.parent) if "cache_exists-"+parent not in logging_tracker: logging_tracker.append("cache_exists-"+parent) logging.warning("One or more frames reloaded from cache: "+str(cache_file.parent)) - return True, backend.asarray(np.load(cache_file)) # if always saving as numpy, then must cast to torch array if re-reading cache file back in - return False,0 + return True, b.asarray(np.load(cache_file)) # if always saving as numpy, then must cast to backend array if re-reading cache file back in + return False, 0 class SEDCalculator: - def setup(self, trajectory: Trajectory, axis:int = 2, abc:list = [1,1,1]): + def __init__(self, device=None): + self._backend = make_backend(device) + + def setup(self, trajectory: Trajectory, axis: int = 2, abc: list = [1, 1, 1]): """ Set up Spectral Energy Density calculation - + Args: trajectory: Input trajectory data """ - + b = self._backend self.trajectory = trajectory self.axis = axis - self.a,self.b,self.c = abc + self.a, self.b_cell, self.c = abc # Set up spatial grids - lxyz = list( np.diag(trajectory.box_matrix) ) - nxyz = [ int(np.round(l/d)) for l,d in zip(lxyz,abc) ] - + lxyz = list(np.diag(trajectory.box_matrix)) + nxyz = [int(np.round(l/d)) for l, d in zip(lxyz, abc)] + del lxyz[axis] del nxyz[axis] del abc[axis] - self.kxs=backend.linspace(0,2*np.pi/abc[0],nxyz[0]) - self.kys=backend.linspace(0,2*np.pi/abc[1],nxyz[1]) - - self.kvec = backend.zeros((len(self.kxs),len(self.kys),3)) - self.kvec[:,:,0] += self.kxs[:,None] - self.kvec[:,:,1] += self.kys[None,:] + self.kxs = b.linspace(0, 2*np.pi/abc[0], nxyz[0]) + self.kys = b.linspace(0, 2*np.pi/abc[1], nxyz[1]) + self.kvec = b.zeros((len(self.kxs), len(self.kys), 3)) + self.kvec[:, :, 0] += self.kxs[:, None] + self.kvec[:, :, 1] += self.kys[None, :] def run(self) -> WFData: + b = self._backend avg = self.trajectory.get_mean_positions() disp = self.trajectory.get_distplacements() # RUN SED INSTEAD OF MULTISLICE - self.Zx,ws = SED(avg,disp,kvec=self.kvec,v_xyz=0) - self.Zy,ws = SED(avg,disp,kvec=self.kvec,v_xyz=1) - self.Zz,ws = SED(avg,disp,kvec=self.kvec,v_xyz=2) + self.Zx, ws = SED(avg, disp, kvec=self.kvec, backend=b, v_xyz=0) + self.Zy, ws = SED(avg, disp, kvec=self.kvec, backend=b, v_xyz=1) + self.Zz, ws = SED(avg, disp, kvec=self.kvec, backend=b, v_xyz=2) - self.ws = ws/self.trajectory.timestep + self.ws = ws / self.trajectory.timestep - def plot(self,w,filename=None): # TODO MAYBE "RUN" SHOULD RETURN A TACAW OBJECT SO WE CAN REUSE TACAW PLOTTING/POSTPROCESSING FUNCTIONALITY?? + def plot(self, w, filename=None): # TODO MAYBE "RUN" SHOULD RETURN A TACAW OBJECT SO WE CAN REUSE TACAW PLOTTING/POSTPROCESSING FUNCTIONALITY?? import matplotlib.pyplot as plt - #fig, ax = plt.subplots() - #extent = ( np.amin(kxs) , np.amax(kxs) , np.amin(ws) , np.amax(ws) ) - #ax.imshow((Zx[::-1,:,0]+Zy[::-1,:,0]+Zz[::-1,:,0])**.25, cmap="inferno", extent=extent,aspect="auto") - #plt.show() - - i=np.argmin(np.backend.absolute(self.ws-w)) - extent = ( np.amin(self.kxs) , np.amax(self.kxs) , np.amin(self.kys) , np.amax(self.kys) ) + i = np.argmin(np.absolute(self.ws - w)) + extent = (np.amin(to_numpy(self.kxs)), np.amax(to_numpy(self.kxs)), + np.amin(to_numpy(self.kys)), np.amax(to_numpy(self.kys))) fig, ax = plt.subplots() - ax.imshow(np.sqrt(self.Zx[i,:,:]+self.Zy[i,:,:]+self.Zz[i,:,:]).T, cmap="inferno", extent=extent) + ax.imshow(np.sqrt(self.Zx[i, :, :]+self.Zy[i, :, :]+self.Zz[i, :, :]).T, cmap="inferno", extent=extent) ax.set_xlabel("kx ($\\AA^{-1}$)") ax.set_ylabel("ky ($\\AA^{-1}$)") @@ -634,5 +566,3 @@ def plot(self,w,filename=None): # TODO MAYBE "RUN" SHOULD RETURN A TACAW OBJECT plt.savefig(filename) else: plt.show() - - diff --git a/src/pyslice/multislice/multislice.py b/src/pyslice/multislice/multislice.py index 62e45c7..fad09c2 100644 --- a/src/pyslice/multislice/multislice.py +++ b/src/pyslice/multislice/multislice.py @@ -1,918 +1,1085 @@ -import pyslice.backend as backend +""" +multislice.py — Probe generation and multislice wave propagation. + +All array operations go through an injected Backend instance. +No module-level backend state is used anywhere in this file. +""" +from __future__ import annotations + +import logging +from typing import Optional + import numpy as np from tqdm import tqdm -import logging, time +from pyslice.backend import Backend, to_cpu, to_numpy logger = logging.getLogger(__name__) -def antialias_aperture(kxs, kys, cutoff_fraction=2/3, taper_width=0.02): - """Compute a 2/3 Nyquist anti-aliasing aperture in k-space. +# --------------------------------------------------------------------------- +# Physical constants (SI) +# --------------------------------------------------------------------------- +m_electron = 9.109383e-31 # kg +q_electron = 1.602177e-19 # J/eV (= kg m² s⁻² eV⁻¹) +c_light = 299792458.0 # m/s +h_planck = 6.62607015e-34 # m² kg s⁻¹ + + +# --------------------------------------------------------------------------- +# Physical helper functions +# --------------------------------------------------------------------------- + +def m_effective(eV: float) -> float: + """ + Relativistic effective electron mass at kinetic energy eV. + + From E = mc², the extra inertia from the kinetic energy is eV/c²: + m_eff = m_e + eV·q / c² + Units: kg. + """ + return m_electron + eV * q_electron / c_light ** 2 + + +def wavelength(eV, backend: Backend): + """ + Relativistic de Broglie wavelength in Angstroms. + + The relativistic momentum of an electron accelerated through voltage V is: + p = sqrt(E_k² + 2 E_k m_e c²) / c + where E_k = eV·q is the kinetic energy in Joules. + + From λ = h/p: + λ = h·c / sqrt(E_k² + 2 E_k m_e c²) + + Multiplied by 1e10 to convert metres → Angstroms. + + The computation is done in backend arrays so that scalar eV, a 1-D array + of eVs (temporal decoherence), or a tensor all work identically and stay + on the correct device throughout. + """ + eV_J = backend.asarray(eV, dtype=backend.float_dtype) * q_electron + m_c2 = backend.asarray(m_electron * c_light**2, dtype=backend.float_dtype) + h_c = backend.asarray(h_planck * c_light, dtype=backend.float_dtype) + momentum = backend.sqrt(eV_J**2 + 2 * eV_J * m_c2) + return h_c / momentum * 1e10 # Å + - Bandwidth-limits to ``cutoff_fraction`` of k_max with a smooth cosine - taper to avoid ringing from a hard cutoff. Returns a 2D real-valued - array (1 inside, tapers to 0 outside). +# --------------------------------------------------------------------------- +# Anti-aliasing aperture +# --------------------------------------------------------------------------- + +def antialias_aperture(kxs, kys, backend: Backend, + cutoff_fraction: float = 2/3, + taper_width: float = 0.02): + """ + 2/3-Nyquist anti-aliasing aperture with a smooth cosine taper. + + The standard multislice anti-aliasing criterion (Kirkland 2010 §6.8) + sets the bandwidth limit at 2/3 of the Nyquist frequency so that + aliasing artefacts from the transmission function multiplication + (which doubles the bandwidth) stay below the Nyquist limit. + + A hard cutoff produces Gibbs ringing; the cosine taper suppresses it: + aperture(k) = 1 if k < k_cut - taper + aperture(k) = 0.5·(1 + cos(π·(k - k_cut + t)/t)) if k_cut-t < k < k_cut + aperture(k) = 0 if k ≥ k_cut + + Returns a 2-D real array with the same device/dtype as kxs. """ - kx_max = backend.amax(backend.absolute(kxs)) - ky_max = backend.amax(backend.absolute(kys)) - k_max = min(float(kx_max), float(ky_max)) # Nyquist = 1/(2*sampling) + kx_max = float(backend.amax(backend.absolute(kxs))) + ky_max = float(backend.amax(backend.absolute(kys))) + k_max = min(kx_max, ky_max) # Nyquist limit k_cutoff = cutoff_fraction * k_max + taper = taper_width * k_max kx_grid, ky_grid = backend.meshgrid(kxs, kys, indexing='ij') k_r = backend.sqrt(kx_grid**2 + ky_grid**2) - # Smooth cosine taper from (k_cutoff - taper) to k_cutoff, strictly zero above k_cutoff - taper = taper_width * k_max aperture = backend.ones_like(k_r) mask_taper = (k_r > k_cutoff - taper) & (k_r < k_cutoff) mask_outer = k_r >= k_cutoff - aperture[mask_taper] = 0.5 * (1 + backend.cos(backend.pi * (k_r[mask_taper] - k_cutoff + taper) / taper)) + aperture[mask_taper] = 0.5 * ( + 1 + backend.cos(backend.pi * (k_r[mask_taper] - k_cutoff + taper) / taper) + ) aperture[mask_outer] = 0.0 return aperture -m_electron = 9.109383e-31 # mass of an electron, kg -q_electron = 1.602177e-19 # charge of an electron, J / eV or kg m^2/s^2 / eV -c_light = 299792458.0 # speed of light, m / s -h_planck = 6.62607015e-34 # m^2 kg / s - -#what if we use units of Å throughout, instead of m? -#m_electron = 9.109383e-19 # mass of an electron, nano-gram (ng) -#q_electron = 1.602177e1 # charge of an electron, kg Å^2/s^2 / eV -#c_light = 2.99792458e18 # speed of light, Å / s -#h_planck = 6.62607015e-14 # Å^2 ng / s -def m_effective(eV): - """Relativistic correction: E=m*c^2, so m=E/c^2, in kg""" - return m_electron + eV * q_electron / c_light**2 - # units [ kg ] [ eV ] [ kg m² s⁻² eV⁻¹ ] [ m⁻² s² ] +# --------------------------------------------------------------------------- +# Aberration function +# --------------------------------------------------------------------------- -def wavelength(eV): +def aberrationFunction(kxs, kys, wavelength_A, aberrations: dict, + backend: Backend): """ - Compute relativistic electron wavelength in Angstroms. - - Converts constants to backend arrays for device consistency. - Uses higher precision intermediates to avoid underflow. + Phase aberration function χ(kx, ky) in the Cnm convention. + + Following Kirkland (2010) Eq. 2.10 and the abTEM notation + (https://abtem.readthedocs.io/en/latest): + + χ(k, φ) = (2π/λ) · Σ_{n,m} 1/(n+1) · C_{nm} · (k·λ)^(n+1) · cos(m·(φ - φ₀)) + + where + k = |k| is the radial spatial frequency (Å⁻¹) + φ = arctan(ky/kx) is the azimuthal angle + n,m = integer indices parsed from the key string (e.g. 'C30' → n=3, m=0) + C = aberration coefficient in Å (or (C, φ₀) for off-axis terms) + + The returned array is exp(-i·χ), i.e. the complex transfer function + to be multiplied onto the wavefunction in reciprocal space. + + Note: kxs, kys are unshifted (reciprocal origin at corner, as produced + by fftfreq), which is consistent with the probe array convention used + throughout this module. """ - # Convert inputs and constants to backend arrays on the appropriate device - eV_joules = backend.asarray(eV, dtype=backend.float_dtype) * backend.asarray(q_electron, dtype=backend.float_dtype) - m_c2 = backend.asarray(m_electron * c_light**2, dtype=backend.float_dtype) - h_c = backend.asarray(h_planck * c_light, dtype=backend.float_dtype) - - # Correct relativistic formula: sqrt(E^2 + 2 E m c^2) - momentum = backend.sqrt(eV_joules**2 + 2 * eV_joules * m_c2) - lam = h_c / momentum * 1e10 # Convert to Angstroms - - return lam + dPhi = backend.zeros_like(kxs[:, None] * kys[None, :]) + ks = backend.sqrt(kxs[:, None]**2 + kys[None, :]**2) + theta = backend.arctan2(kys[None, :], kxs[:, None]) + + for key, val in aberrations.items(): + n, m = int(key[1]), int(key[2]) # e.g. 'C30' → n=3, m=0 + C, phi0 = (val, 0.0) if isinstance(val, (int, float)) else val + dPhi += ( + 2 * np.pi / wavelength_A + * (1 / (n + 1)) + * C + * (ks * wavelength_A) ** (n + 1) + * backend.cos(m * (theta - phi0)) + ) + return backend.exp(-1j * dPhi) +# --------------------------------------------------------------------------- +# Probe +# --------------------------------------------------------------------------- + class Probe: """ - PyTorch-accelerated probe class for electron microscopy. - - Generates probe wavefunctions on GPU for both plane wave and convergent beam modes. - Significant speedup for large grid sizes through GPU-accelerated FFT operations. + Electron probe wavefunction for multislice calculations. + + Generates the probe in reciprocal space as a top-hat (or Gaussian-VOA) + aperture function, then transforms to real space. Multiple probe + positions are handled by applying a phase ramp in reciprocal space + (equivalent to a real-space translation). + + The probe array has shape (nc, npt, nx, ny) where + nc = number of coherent copies (e.g. temporal decoherence channels) + npt = number of probe positions + nx, ny = real-space grid size """ - - def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, preview=False, probe_xs=None, probe_ys=None, probe_positions=None, cropping=False, defer_shifts=False, stay_reciprocal = False, crop_reciprocal=False): - """ - Initialize GPU-accelerated probe wavefunction. - - Args: - xs, ys: Real space coordinate arrays - mrad: Convergence semi-angle in milliradians (0.0 = plane wave) - eV: Electron energy in eV - device: PyTorch device (None for auto-detection) - """ - # TORCH DEVICES AND DTYPES - device, float_dtype, complex_dtype = backend.device_and_precision(device) - self.device = device - self.dtype = float_dtype - self.complex_dtype = complex_dtype - - # SET UP SPATIAL GRIDS - # Convert coordinate arrays to tensors if using torch (same as Potential class) - self.xs = backend.asarray(xs, dtype=self.dtype, device=self.device) - self.ys = backend.asarray(ys, dtype=self.dtype, device=self.device) - - nx = len(xs) ; ny = len(ys) - dx = xs[1] - xs[0] ; dy = ys[1] - ys[0] - lx = nx*dx ; ly = ny*dy - self.nx = nx ; self.dx = dx ; self.lx = lx - self.ny = ny ; self.dy = dy ; self.ly = ly - - # HANDLE PROBE POSTIONS + + def __init__( + self, + xs, ys, + mrad: float, + eV: float, + backend: Backend, + array=None, + gaussianVOA: float = 0, + preview: bool = False, + probe_xs=None, + probe_ys=None, + probe_positions=None, + cropping: int = False, + defer_shifts: bool = False, + stay_reciprocal: bool = False, + crop_reciprocal=False, + ): + self._backend = backend + + # ------------------------------------------------------------------ + # Spatial grid + # ------------------------------------------------------------------ + self.xs = backend.asarray(xs, dtype=backend.float_dtype) + self.ys = backend.asarray(ys, dtype=backend.float_dtype) + + nx = len(xs); ny = len(ys) + dx = float(xs[1] - xs[0]); dy = float(ys[1] - ys[0]) + lx = nx * dx; ly = ny * dy + self.nx = nx; self.ny = ny + self.dx = dx; self.dy = dy + self.lx = lx; self.ly = ly + + # ------------------------------------------------------------------ + # Probe positions + # ------------------------------------------------------------------ self.probe_xs = probe_xs self.probe_ys = probe_ys self.probe_positions = probe_positions - # Preferred to pass probe_xs and probe_ys from which we will define a grid. copied from probe_grid (now defunct) - if self.probe_xs is not None and self.probe_ys is not None: - x,y = np.meshgrid(self.probe_xs,self.probe_ys) - self.probe_positions = np.reshape([x,y],(2,len(x.flat))).T + if probe_xs is not None and probe_ys is not None: + x, y = np.meshgrid(probe_xs, probe_ys) + self.probe_positions = np.reshape([x, y], (2, len(x.flat))).T - # Set up default probe position if not provided if self.probe_positions is None: - self.probe_positions = [(lx/2, ly/2)] # Center probe - self.probe_xs = [lx/2] ; self.probe_ys = [ly/2] - - # HANDLE BEAM PARAMS - self.mrad = mrad - #if isinstance(eV,(float,int)): - # n = 1 if array is None else len(array) - # eV = [ eV ]*n - self.eV = eV ; self.wavelength=wavelength(eV) - self.eVs = backend.asarray([eV], dtype=self.dtype, device=self.device) - self.wavelengths = wavelength(self.eVs) + self.probe_positions = [(lx / 2, ly / 2)] + self.probe_xs = [lx / 2] + self.probe_ys = [ly / 2] + + # ------------------------------------------------------------------ + # Beam parameters + # ------------------------------------------------------------------ + self.mrad = mrad + self.eV = eV + self.wavelength = wavelength(eV, backend) # scalar, Å + self.eVs = backend.asarray([eV], dtype=backend.float_dtype) + self.wavelengths = wavelength(self.eVs, backend) self.temporal_decoherence = None - self.spatial_decoherence = None - self.gaussianVOA = gaussianVOA - + self.spatial_decoherence = None + self.gaussianVOA = gaussianVOA + self.stay_reciprocal = stay_reciprocal self.crop_reciprocal = crop_reciprocal - #if self.crop_reciprocal: # user asked for kspace to be, say, 100 pixels, but right now it's 350... - # self.crop_reciprocal = (min(nx,ny)-self.crop_reciprocal)//2 # so we need to chop 125 off each side - - self.kxs = backend.fftfreq(nx, d=dx, device=self.device, dtype=self.dtype) - self.kys = backend.fftfreq(ny, d=dy, device=self.device, dtype=self.dtype) - - if not array is None: # Allow construction of a Probe object with a passed array instead of building it below. used by create_batched_probes - if backend.TORCH_BACKEND and hasattr(array, 'to'): - self._array = array.to(device=self.device, dtype=self.complex_dtype) - else: - self._array = backend.asarray(array, dtype=self.complex_dtype, device=self.device) + # ------------------------------------------------------------------ + # Reciprocal-space frequency arrays (unshifted: 0,1,…,-2,-1) + # ------------------------------------------------------------------ + self.kxs = backend.fftfreq(nx, d=dx) + self.kys = backend.fftfreq(ny, d=dy) + + # ------------------------------------------------------------------ + # Build or adopt the probe array + # ------------------------------------------------------------------ + if array is not None: + # Caller supplies a pre-built array (e.g. create_batched_probes). + # Ensure it lives on the correct device and has complex dtype. + self._array = backend.asarray(array, dtype=backend.complex_dtype) else: - #self._array = zeros((len(self.eV),1,nx,ny)) - #for i,w in enumerate(self.wavelength): - # self._array[i,0,:,:] = self.generate_single_probe(mrad,w,gaussianVOA,preview=preview) - #self._array = backend.zeros((1,1,nx,ny), dtype=self.complex_dtype, device=self.device) - self._array= self.generate_single_probe(mrad,self.wavelength,self.gaussianVOA,preview=preview)[None,None,:,:]*backend.ones((1,1), device=self.device)[:,:,None,None] + # Generate the single template probe, then broadcast to shape + # (1, 1, nx, ny) so decoherence expansion and applyShifts work + # uniformly on (nc, npt, nx, ny) shaped arrays throughout. + single = self.generate_single_probe( + mrad, self.wavelength, gaussianVOA, preview=preview) + self._array = ( + single[None, None, :, :] + * backend.ones((1, 1), dtype=backend.complex_dtype)[:, :, None, None] + ) self.cropping = cropping - #self.offsets = [[0,0] for i in range(len(self.probe_positions)) ] - self.offsets = np.zeros((len(self.probe_positions),2),dtype="int") # these are used when we have cropped the probe + # Pixel offsets used when probe is cropped to a sub-region. + self.offsets = np.zeros((len(self.probe_positions), 2), dtype=int) - # NEW PHILOSOPHY: we used to build out the probe cube (npt,nx,ny) no matter what, but if you have - # a bajillion probes, then this cube might be huge! instead, callers (e.g. calculator) pass - # defer_shifts=True and call applyShifts when ready. This means calculators' loop_probes can - # handle them one at a time, without building out the entire cube. if not defer_shifts: self.applyShifts() - def generate_single_probe(self,mrad,wavelength,gaussianVOA,preview=False): - kxs,kys = self.kxs,self.kys - if self.crop_reciprocal: # unshifted kx ky: 0,1,2,3,....-3,-2,-1, midcrop gets rid of high-k: 0,1,2,-2,-1 - kxs = midcrop(self.kxs,self.crop_reciprocal[0]) - kys = midcrop(self.kys,self.crop_reciprocal[1]) + # ------------------------------------------------------------------ + # Probe generation + # ------------------------------------------------------------------ - nx,ny = len(kxs) , len(kys) + def generate_single_probe(self, mrad: float, wavelength_val, + gaussianVOA: float, preview: bool = False): + """ + Build one probe wavefunction centred at the grid origin. + + In reciprocal space the probe is a circle of radius r = mrad·1e-3 / λ + (converting convergence semi-angle from mrad to Å⁻¹). The circle is + filled with amplitude 1; everything outside is 0. Transforming to + real space via IFFT gives the diffraction-limited probe shape. + + The kx/ky arrays are unshifted (origin at corner), so the resulting + real-space probe is centred at the corner after IFFT. ifftshift then + moves the centre to (lx/2, ly/2), i.e. the middle of the simulation + cell — where applyShifts expects it. + + If stay_reciprocal=True the probe is kept in reciprocal space and a + phase ramp is applied to centre it (equivalent but saves two FFTs + when shifting will be done in reciprocal space later). + """ + b = self._backend + kxs, kys = self.kxs, self.kys + if self.crop_reciprocal: + # Trim high-k frequencies from the unshifted arrays. + # midcrop(a, n) removes the n outermost frequencies from each end + # of an unshifted array: 0,1,2,…,-2,-1 → 0,1,…,-(n-1) (cropped). + kxs = b.midcrop(self.kxs, self.crop_reciprocal[0]) + kys = b.midcrop(self.kys, self.crop_reciprocal[1]) + + nx, ny = len(kxs), len(kys) if mrad == 0: - return backend.zeros((nx, ny), device=self.device, dtype=self.complex_dtype)+1 + # Plane wave: uniform amplitude, no aperture. + return b.zeros((nx, ny), dtype=b.complex_dtype) + 1 + + reciprocal = b.zeros((nx, ny), dtype=b.complex_dtype) + # Convergence semi-angle in Å⁻¹: α_rad = mrad·1e-3, r = α_rad / λ + radius = (mrad * 1e-3) / wavelength_val - reciprocal = backend.zeros((nx, ny), dtype=self.complex_dtype, device=self.device) - radius = (mrad * 1e-3) / wavelength # Convert mrad to reciprocal space units - kx_grid, ky_grid = backend.meshgrid(kxs, kys, indexing='ij') # unshifted kx ky: 0,1,2,3,....-3,-2,-1 - radii = backend.sqrt(kx_grid**2 + ky_grid**2) + kx_grid, ky_grid = b.meshgrid(kxs, kys, indexing='ij') + radii = b.sqrt(kx_grid**2 + ky_grid**2) if gaussianVOA == 0: - mask = radii < radius - reciprocal[mask] = 1.0 # mask covers the corners (unshifted in reciprocal space) + # Hard aperture: mask all k-vectors inside the convergence radius. + reciprocal[radii < radius] = 1.0 else: + # Gaussian virtual objective aperture — smooth roll-off via erf. from scipy.special import erf - reciprocal = 1-erf((radii-radius)/(gaussianVOA*radius)) + reciprocal = 1 - erf((radii - radius) / (gaussianVOA * radius)) if preview: import matplotlib.pyplot as plt - fig, ax = plt.subplots() ; print(radius) - extent = (backend.amin(self.kxs), backend.amax(self.kxs), backend.amin(self.kys), backend.amax(self.kys)) - ax.imshow(backend.fft.fftshift(reciprocal.T), cmap="inferno",extent=extent) # shift to visualize with k=0 in the center - ax.set_xlabel("kx ($\\AA^{-1}$)") - ax.set_ylabel("ky ($\\AA^{-1}$)") + fig, ax = plt.subplots() + extent = (float(b.amin(self.kxs)), float(b.amax(self.kxs)), + float(b.amin(self.kys)), float(b.amax(self.kys))) + ax.imshow(to_numpy(b.fftshift(reciprocal)).T, + cmap="inferno", extent=extent) + ax.set_xlabel("kx (Å⁻¹)"); ax.set_ylabel("ky (Å⁻¹)") plt.show() + plt.close(fig) - if self.stay_reciprocal: # if we would've done a real-space shift, we should apply a phase ramp in reciprocal space - return reciprocal * backend.exp(-2j * backend.pi * kxs[:, None] * self.lx/2 ) * backend.exp(-2j * backend.pi * kys[None, :] * self.ly/2 ) - - return backend.ifftshift(backend.ifft2(reciprocal)) # iFFT --> realspace --> shift --> zero in the center - #self.array_numpy = self.array.cpu().numpy() - - def copy(self,selected_probes=None): - """Create a deep copy of the probe.""" - new_probe = Probe.__new__(Probe) - for attr in self.__dict__.keys(): - if attr[0]=="_" or "array" in attr: - continue - val = getattr(self,attr) - val = clone(val) - setattr(new_probe,attr,val) - if selected_probes is not None: - selected_probes = to_cpu(selected_probes) - nc,npt,nx,ny = self._array.shape - if npt == 1: - new_probe._array = clone(self._array[:,:,:,:]) - else: - new_probe._array = clone(self._array[:,selected_probes,:,:]) - new_probe.offsets = self.offsets[selected_probes,:] - new_probe.probe_positions = self.probe_positions[to_cpu(selected_probes),:] - #print("new",new_probe.offsets.shape,new_probe.probe_positions.shape) - else: - new_probe._array = clone(self._array) - #print("no selected used") - #new_probe.device = self.device - #new_probe.array_numpy = self.array_numpy.copy() - return new_probe - - @property - def array(self): - return self.to_cpu() - - def to_cpu(self): - """Convert probe array to CPU NumPy array.""" - if hasattr(self._array, 'cpu'): - return self._array.cpu().numpy() - return self._array - - def to_device(self, device): - """Move probe to specified device (similar to Potential.to_device).""" - device, float_dtype, complex_dtype = backend.device_and_precision(device) - - self._array = self._array.to(device=device, dtype=complex_dtype) - self.xs = self.xs.to(device=device, dtype=float_dtype) - self.ys = self.ys.to(device=device, dtype=float_dtype) - self.kxs = self.kxs.to(device=device, dtype=float_dtype) - self.kys = self.kys.to(device=device, dtype=float_dtype) - - self.device = device - self.dtype = float_dtype - self.complex_dtype = complex_dtype - return self - - def plot(self,filename=None,title=None): - import matplotlib.pyplot as plt - fig, ax = plt.subplots() - # calling self.array should convert to CPU/numpy - array = backend.array_mean(backend.absolute(self.array[:,:,::-1,:]),axis=1)[0,:,:] # positional,summable,x,y indices - array=array.T # imshow convention: y,x. our convention: x,y - plot_array = backend.absolute(array)**.25 - - # Convert extent values to CPU if needed (use xp for torch/numpy compatibility) - xs_min = backend.amin(self.xs) - xs_max = backend.amax(self.xs) # TODO technically this should be xs[-1]+dx?? - ys_min = backend.amin(self.ys) - ys_max = backend.amax(self.ys) - - if hasattr(xs_min, 'cpu'): - xs_min = xs_min.cpu() - xs_max = xs_max.cpu() - ys_min = ys_min.cpu() - ys_max = ys_max.cpu() - - extent = (xs_min, xs_max, ys_min, ys_max) - ax.imshow(plot_array, cmap="inferno",extent=extent) - ax.set_xlabel("x ($\\AA$)") - ax.set_ylabel("y ($\\AA$)") - if title is not None: - ax.set_title(title) - - if filename is not None: - plt.savefig(filename) - else: - plt.show() - - def defocus(self,dz): # POSITIVE DEFOCUS PUTS BEAM WAIST ABOVE SAMPLE, UNITS OF ANGSTROM - if isinstance(dz,(int,float)): - dz = backend.zeros(len(self._array), device=self.device)+dz - kx_grid, ky_grid = backend.meshgrid(self.kxs, self.kys, indexing='ij') - k_squared = kx_grid**2 + ky_grid**2 - P = backend.exp(-1j * backend.pi * self.wavelength * dz[:,None,None] * k_squared[None,:,:]) - nz = len(dz) ; nc,npt,nx,ny = self._array.shape #; print("nc,npt,nx,ny",nc,npt,nx,ny) - self._array = backend.ifft2( P[:,None,None,:,:] * backend.fft2( self._array )[None,:,:,:,:] ) - self._array = self._array.reshape((nz*nc,npt,nx,ny)) - #print("defocus",dz,"new shape",self._array.shape) - - # ORDER OF OPERATIONS IS IMPORTANT. MUST DO: addTemporalDecoherence, addSpatialDecoherence, create_batched_probes - # addTemporalDecoherence - creates new standard probes (must come first) - # addSpatialDecoherence - applies defocus (applies to existing probe(s)) - # create_batched_probes - applied shift to each probe - def addTemporalDecoherence(self,sigma_eV,N): - nc,npt,nx,ny = self._array.shape #; print("addTemporalDecoherence shape was",nc,npt,nx,ny) - if self.temporal_decoherence is not None: - print("WARNING: calling addTemporalDecoherence twice will overwrite previous") - self.temporal_decoherence = (sigma_eV,N) - eV = self.eV - self.eVs = backend.linspace(eV-2*sigma_eV,eV+2*sigma_eV,N) - self.eVs = backend.asarray(self.eVs, dtype=self.dtype, device=self.device) - self.wavelengths = wavelength(self.eVs) - amplitudes = backend.exp(-(eV-self.eVs)**2/sigma_eV**2) - self._array = backend.zeros((N,1,nx,ny), device=self.device) - for n,eV in enumerate(self.eVs): - self._array[n,0,:,:] = amplitudes[n] * self.generate_single_probe(self.mrad,wavelength(eV),self.gaussianVOA) - nc,npt,nx,ny = self._array.shape #; print("addTemporalDecoherence expands to",nc,npt,nx,ny) - if self.spatial_decoherence is not None: - self.addSpatialDecoherence(*self.spatial_decoherence) - nc,npt,nx,ny = self._array.shape - if npt==1: - self.applyShifts() - - def addSpatialDecoherence(self,sigma_dz,N): - nc,npt,nx,ny = self._array.shape #; print("addSpatialDecoherence shape was",nc,npt,nx,ny) - if self.temporal_decoherence is not None: - print("WARNING: calling addSpatialDecoherence twice will overwrite previous") - self.spatial_decoherence = (sigma_dz,N) - dzs = backend.linspace(-2*sigma_dz,2*sigma_dz,N) # suppose N=25 - amplitudes = backend.exp(-dzs**2/sigma_dz**2) - nc,npt,nx,ny = self._array.shape # suppose nc=10 (addTemporalDecoherence created 10 wavelengths) - if self.use_torch: - dzs = backend.asarray(dzs, dtype=self.dtype, device=self.device) - self.defocus(dzs) # defocus starts with 25,10,npt,nx,ny --reshapes--> 250,npt,nx,ny - for i in range(N): # reshape to flatten loops first index last: [[0,1],[2,3]] --> [0,1,2,3] - for j in range(nc): - self._array[i*nc+j] *= amplitudes[i] - nc,npt,nx,ny = self._array.shape #; print("addSpatialDecoherence expands to",nc,npt,nx,ny) - self.eVs = backend.ones(N, device=self.device)[:,None]*self.eVs[None,:] # defocus expands into nz,nc then flattens to nz*nc - self.eVs = self.eVs.reshape(nc) - self.wavelengths = backend.ones(N, device=self.device)[:,None]*self.wavelengths[None,:] - self.wavelengths = self.wavelengths.reshape(nc) - if npt==1: - self.applyShifts() + if self.stay_reciprocal: + # Centre in reciprocal space by multiplying with a phase ramp + # equivalent to a real-space shift of lx/2, ly/2. + # exp(-2πi kx · lx/2) shifts the probe to the cell centre. + return ( + reciprocal + * b.exp(-2j * b.pi * kxs[:, None] * self.lx / 2) + * b.exp(-2j * b.pi * kys[None, :] * self.ly / 2) + ) + + # IFFT → real space; ifftshift moves centre from corner to middle. + return b.ifftshift(b.ifft2(reciprocal)) + + # ------------------------------------------------------------------ + # Position shifting + # ------------------------------------------------------------------ def applyShifts(self): - nc,npt,nx,ny = self._array.shape #; print("applyShifts shape was",nc,npt,nx,ny,"len(self.probe_positions)",len(self.probe_positions)) - if npt>1: # TODO ALSO NEED SOMETHING TO DETERMINE IF SHIFTS HAVE ALREADY BEEN APPLIED. EG A LIST WHICH IS ALWAYS UPDATED WHEN ARRAY IS RESET? + """ + Expand the (nc,1,nx,ny) template array to (nc,npt,nx,ny) by shifting + the probe to each requested position. + + The shift is applied in reciprocal space as a phase ramp: + ψ_shifted(k) = ψ(k) · exp(-2πi (kx·Δx + ky·Δy)) + which is exact (no interpolation) and GPU-friendly. + """ + b = self._backend + nc, npt, nx, ny = self._array.shape + if npt > 1: + # Shifts have already been applied — nothing to do. return - # inflate self._array to store probe cube (npt,nx,ny) + # Broadcast the single template probe to all npt positions. if self.cropping: - i1=nx//2-self.cropping//2 ; i2=i1+self.cropping # |_______i1___.___i2_______| for initial centered probe at lx/2,ly/2 - j1=ny//2-self.cropping//2 ; j2=j1+self.cropping - self._array = self._array[:,0,None,i1:i2,j1:j2] * backend.ones(len(self.probe_positions), device=self.device)[None,:,None,None] + # Crop the probe to a sub-window centred at lx/2, ly/2. + i1 = nx // 2 - self.cropping // 2; i2 = i1 + self.cropping + j1 = ny // 2 - self.cropping // 2; j2 = j1 + self.cropping + self._array = ( + self._array[:, 0, None, i1:i2, j1:j2] + * b.ones(len(self.probe_positions))[:, None, None][None, :] + ) else: - self._array = self._array[:,0,None,:,:] * backend.ones(len(self.probe_positions), device=self.device)[None,:,None,None] - # loop through probe positions - for i, (px,py) in enumerate(self.probe_positions): - if px-self.lx/2 == 0 and py-self.ly/2 == 0: - continue + self._array = ( + self._array[:, 0, None, :, :] + * b.ones(len(self.probe_positions))[None, :, None, None] + ) + + for i, (px, py) in enumerate(self.probe_positions): + if px - self.lx / 2 == 0 and py - self.ly / 2 == 0: + continue # already centred + self._array[:, i, :, :], (dpx, dpy) = self.placeProbe( + self._array[:, i, :, :], px, py) + self.offsets[i, 0] = int(dpx) + self.offsets[i, 1] = int(dpy) + + def placeProbe(self, array, x: float, y: float): + """ + Shift the probe to real-space position (x, y) via a k-space phase ramp. - self._array[:,i,:,:],(dpx,dpy) = self.placeProbe(self._array[:,i,:,:], px, py ) - self.offsets[i,0] = int(dpx) ; self.offsets[i,1] = int(dpy) + The probe template starts centred at (lx/2, ly/2). A displacement + (Δx, Δy) = (x - lx/2, y - ly/2) is applied by multiplying the + Fourier-space probe by exp(-2πi (kx·Δx + ky·Δy)). - nc,npt,nx,ny = self._array.shape #; print("applyShifts expands to",nc,npt,nx,ny) + For cropped probes the large pixel-aligned part of the shift is handled + by tracking an integer offset (dpx, dpy) and only the sub-pixel + remainder is applied as a phase ramp. This avoids wrapping artefacts. + + Returns (shifted_probe_in_original_domain, (offset_x, offset_y)). + """ + b = self._backend + dx = x - self.lx / 2 + dy = y - self.ly / 2 - def placeProbe(self,array,x,y): - dx = (x-self.lx/2) ; dy = (y-self.ly/2) # probe started in the center if self.cropping: - i1=self.nx//2-self.cropping//2 ; i2=i1+self.cropping # |_______i1___.___i2_______| for initial centered probe at lx/2,ly/2 - j1=self.ny//2-self.cropping//2 ; j2=j1+self.cropping - kxs = backend.fftfreq(self.cropping, d=self.dx, device=self.device, dtype=self.dtype) - kys = backend.fftfreq(self.cropping, d=self.dy, device=self.device, dtype=self.dtype) - dpx = dx//self.dx ; dpy = dy//self.dy # pixel shifts - offset_x = i1+dpx ; offset_y = j1+dpy - dx-=dpx*self.dx ; dy-=dpy*self.dy # update subpixel shifts - elif self.crop_reciprocal: # unshifted kx ky: 0,1,2,3,....-3,-2,-1, midcrop gets rid of high-k: 0,1,2,-2,-1 - kxs = midcrop(self.kxs,self.crop_reciprocal[0]) - kys = midcrop(self.kys,self.crop_reciprocal[1]) - offset_x = 0 ; offset_y=0 + i1 = self.nx // 2 - self.cropping // 2 + j1 = self.ny // 2 - self.cropping // 2 + kxs = b.fftfreq(self.cropping, d=self.dx) + kys = b.fftfreq(self.cropping, d=self.dy) + # Split into pixel-aligned and sub-pixel shifts. + dpx = dx // self.dx; dpy = dy // self.dy + offset_x = i1 + dpx; offset_y = j1 + dpy + dx -= dpx * self.dx; dy -= dpy * self.dy + elif self.crop_reciprocal: + kxs = b.midcrop(self.kxs, self.crop_reciprocal[0]) + kys = b.midcrop(self.kys, self.crop_reciprocal[1]) + offset_x = offset_y = 0 else: - kxs,kys=self.kxs,self.kys - offset_x = 0 ; offset_y=0 + kxs, kys = self.kxs, self.kys + offset_x = offset_y = 0 + if not self.stay_reciprocal: - probe_k = backend.fft2(array) # positional,summable,x,y + probe_k = b.fft2(array) else: probe_k = array - kx_shift = backend.exp(-2j * backend.pi * kxs[None,:, None] * dx ) - ky_shift = backend.exp(-2j * backend.pi * kys[None,None, :] * dy ) + + # Phase ramp: multiply by exp(-2πi kx Δx) · exp(-2πi ky Δy). + # Broadcasting: kxs has shape (nx,), so kxs[None,:,None] matches + # the (nc, nx, ny) array layout. + kx_shift = b.exp(-2j * b.pi * kxs[None, :, None] * dx) + ky_shift = b.exp(-2j * b.pi * kys[None, None, :] * dy) probe_k_shifted = probe_k * kx_shift * ky_shift if self.stay_reciprocal: - return probe_k_shifted,(offset_x,offset_y) - return backend.ifft2(probe_k_shifted),(offset_x,offset_y) + return probe_k_shifted, (offset_x, offset_y) + return b.ifft2(probe_k_shifted), (offset_x, offset_y) + + # ------------------------------------------------------------------ + # Decoherence + # ------------------------------------------------------------------ + def defocus(self, dz): + """ + Apply a defocus of dz Angstroms to the probe. - def aberrate(self,aberrations): - dP = aberrationFunction(self.kxs,self.kys,self.wavelength,aberrations) - # recall, in Probe.__init__, we created the real-space array via: - # self.array = backend.fft.ifftshift(backend.fft.ifft2(reciprocal)) - # Aberrations are defined at the aperture plane, so we must apply them in reciprocal space. - # (or do a convolution in real-space) - reciprocal = backend.fft2(backend.fftshift(self._array)) # centered-real --> zero at corner --> FFT --> kx,ky zero at corner + In reciprocal space, a free-space propagation of distance dz is + multiplication by the Fresnel propagator: + P(k, dz) = exp(-iπ λ dz |k|²) + (Kirkland 2010, Eq. 6.65 with a positive dz shifting the waist + below the entrance surface, i.e. positive defocus focuses deeper). + + If dz is scalar, the same defocus is applied to all nc copies. + If dz is a 1-D array of length N, the probe array is expanded to + (N·nc, npt, nx, ny) — one set of copies per defocus value. + """ + b = self._backend + if isinstance(dz, (int, float)): + dz = b.zeros(len(self._array)) + dz + kx_grid, ky_grid = b.meshgrid(self.kxs, self.kys, indexing='ij') + k_sq = kx_grid**2 + ky_grid**2 + # P shape: (nz, nx, ny); _array shape after FFT: (nc, npt, nx, ny) + P = b.exp(-1j * b.pi * self.wavelength * dz[:, None, None] * k_sq[None, :, :]) + nz = len(dz); nc, npt, nx, ny = self._array.shape + # Apply P to each of the nc coherent copies independently. + self._array = b.ifft2( + P[:, None, None, :, :] * b.fft2(self._array)[None, :, :, :, :] + ) + self._array = b.reshape(self._array, (nz * nc, npt, nx, ny)) + + def addTemporalDecoherence(self, sigma_eV: float, N: int): + """ + Simulate temporal (chromatic) decoherence by incoherently averaging + over a Gaussian energy spread of width sigma_eV. + + N probe copies are generated, each at a slightly different accelerating + voltage sampled from the range [eV - 2σ, eV + 2σ]. Each copy is + weighted by a Gaussian amplitude: + A_n = exp(-(eV - eV_n)² / σ²) + + The resulting _array has shape (N, 1, nx, ny). If spatial decoherence + was already configured, it is re-applied so the order of operations + is always: temporal → spatial → shift. + """ + b = self._backend + nc, npt, nx, ny = self._array.shape + if self.temporal_decoherence is not None: + logger.warning("addTemporalDecoherence called twice — overwriting previous.") + self.temporal_decoherence = (sigma_eV, N) + + self.eVs = b.asarray(b.linspace(self.eV - 2*sigma_eV, + self.eV + 2*sigma_eV, N), + dtype=b.float_dtype) + self.wavelengths = wavelength(self.eVs, b) + amplitudes = b.exp(-(self.eV - self.eVs)**2 / sigma_eV**2) + + self._array = b.zeros((N, 1, nx, ny), dtype=b.complex_dtype) + for n, eV_n in enumerate(self.eVs): + lam_n = wavelength(eV_n, b) + self._array[n, 0, :, :] = ( + amplitudes[n] * self.generate_single_probe(self.mrad, lam_n, self.gaussianVOA) + ) + + if self.spatial_decoherence is not None: + self.addSpatialDecoherence(*self.spatial_decoherence) + if self._array.shape[1] == 1: + self.applyShifts() + + def addSpatialDecoherence(self, sigma_dz: float, N: int): + """ + Simulate spatial (focal) decoherence by incoherently averaging over + a Gaussian distribution of defocus values of width sigma_dz (Å). + + N defocus values are sampled from [-2σ, +2σ] with Gaussian weights. + defocus() is called to expand the probe array from (nc, 1, nx, ny) + to (N·nc, 1, nx, ny), and then each slice is amplitude-weighted. + + The eVs and wavelengths arrays are also tiled so every element of + the expanded nc dimension has the correct associated value. + """ + b = self._backend + if self.spatial_decoherence is not None: + logger.warning("addSpatialDecoherence called twice — overwriting previous.") + self.spatial_decoherence = (sigma_dz, N) + + dzs = b.asarray(b.linspace(-2*sigma_dz, 2*sigma_dz, N), + dtype=b.float_dtype) + amplitudes = b.exp(-dzs**2 / sigma_dz**2) + + nc, npt, nx, ny = self._array.shape + self.defocus(dzs) # expands: (nc,1,nx,ny) → (N·nc,1,nx,ny) + + # Apply Gaussian weights — the defocus loop is the outer (slower) + # index: result[i·nc + j] = defocus[i] × probe[j] + for i in range(N): + for j in range(nc): + self._array[i * nc + j] *= amplitudes[i] + + nc = self._array.shape[0] + # Tile eVs/wavelengths to match the expanded nc dimension. + self.eVs = b.reshape( + b.ones(N)[:, None] * self.eVs[None, :], (nc,)) + self.wavelengths = b.reshape( + b.ones(N)[:, None] * self.wavelengths[None, :], (nc,)) + + if self._array.shape[1] == 1: + self.applyShifts() + + # ------------------------------------------------------------------ + # Aberrations + # ------------------------------------------------------------------ + + def aberrate(self, aberrations: dict): + """ + Apply wavefront aberrations defined in the Cnm convention. + + Aberrations are phase errors at the aperture plane, so they must be + applied in reciprocal space. The real-space probe was built via: + probe_real = ifftshift(ifft2(aperture)) + Reversing this: fft2(fftshift(probe_real)) gives back the aperture, + to which we multiply the aberration phase factor, then transform back. + """ + b = self._backend + dP = aberrationFunction(self.kxs, self.kys, self.wavelength, aberrations, b) + reciprocal = b.fft2(b.fftshift(self._array)) reciprocal *= dP - self._array = backend.ifftshift(backend.ifft2(reciprocal)) - -# See Kirkland Eq 2.10: -# χ(k,ϕ) = π/2 Cs λ³ k⁴ - π Δf λ k² -# + π fa2 λ k² sin(2*(ϕ-ϕa2)) + 2π/3 fa3 λ² k³ sin(3*(ϕ-ϕa3)) -# + 2π/3 fc3 λ² k³ sin(ϕ-ϕc3) -# where fa is astig, fc is coma, with orientations ϕa or ϕc -# or https://doi-org.ornl.idm.oclc.org/10.1016/S0304-3991(99)00013-3 Eq. A1 -# χ(rᵤ,rᵥ) = 2π/λ { C₁₀ ( rᵤ² + rᵥ² ) / 2 -# + C₁₂ᵤ ( rᵤ² - rᵥ² ) / 2 + C₁₂ᵥ rᵤ rᵥ -# + C₂₁ᵤ rᵤ ( rᵤ² + rᵥ² ) / 3 + C₂₁ᵥ rᵥ ( rᵤ² + rᵥ² ) / 3 -# + C₂₃ᵤ rᵤ ( rᵤ² - 3 rᵥ² ) / 3 + C₂₃ᵥ rᵥ ( 3 rᵤ² - rᵥ² ) / 3 -# + C₃₀ ( rᵤ² + rᵥ² )² / 4 -# + C₃₂ᵤ ( rᵤ⁴ - rᵥ⁴ ) / 4 + C₃₂ᵥ 2 rᵤ rᵥ ( rᵤ² + rᵥ² ) / 4 -# + C₃₄ᵤ ( rᵤ⁴ - 6 rᵤ² rᵥ² + rᵥ² ) / 4 + C₃₄ᵥ ( rᵤ³ rᵥ - rᵤ rᵥ³ ) } -# where rᵤ = r cos(ϕ) and rᵥ = r sin(ϕ), r² = rᵤ² + rᵥ² -# χ(rᵤ,rᵥ) = 2π/λ { C₁₀ r² / 2 -# + C₁₂ᵤ ( rᵤ² - rᵥ² ) / 2 + C₁₂ᵥ rᵤ rᵥ -# + C₂₁ᵤ rᵤ r² / 3 + C₂₁ᵥ rᵥ r² / 3 -# + C₂₃ᵤ rᵤ ( rᵤ² - 3 rᵥ² ) / 3 + C₂₃ᵥ rᵥ ( 3 rᵤ² - rᵥ² ) / 3 -# + C₃₀ r⁴ / 4 -# + C₃₂ᵤ ( rᵤ⁴ - rᵥ⁴ ) / 4 + C₃₂ᵥ 2 rᵤ rᵥ ( rᵤ² + rᵥ² ) / 4 -# + C₃₄ᵤ ( rᵤ⁴ - 6 rᵤ² rᵥ² + rᵥ² ) / 4 + C₃₄ᵥ ( rᵤ³ rᵥ - rᵤ rᵥ³ ) } -# or https://doi-org.ornl.idm.oclc.org/10.1016/j.ultramic.2010.04.006 Eq A1 -# χ(u,v) = C₀₁ u + C₀₁ v -# + 1/2 [ C₁₀ ( u² + v² ) + C₁₂ᵤ ( u² - v² ) + 2 C₁₂ᵥ u v ] -# +1/3 [ C₂₃ᵤ -# ₀₁₂₃₄ᵤᵥ -# or comparing to: https://abtem.readthedocs.io/en/latest/user_guide/walkthrough/contrast_transfer_function.html -# χ(k,ϕ) = π/2/λ 1/(n+1) C ( k λ )^(n+1) cos(m*(ϕ-ϕa)) -# Aberrations are an adjustment to the phase of the wave ("dPhi"), to be applied in reciprocal space. -# this is done by multiplying the complex wave (be it a probe or an exit wave) by backend.exp(-1j * dPhi) -def aberrationFunction(kxs,kys,wavelength,aberrations): # aberrations should be a dict of Cnm following https://abtem.readthedocs.io/en/latest/user_guide/walkthrough/contrast_transfer_function.html - dPhi = backend.zeros_like(kxs[:,None] * kys[None,:]) - ks = backend.sqrt( kxs[:,None]**2 + kys[None,:]**2 ) # unshifted: 0,1,2,3,...-3,-2,-1, reciprocal origin at corner - theta = backend.arctan2( kys[None,:] , kxs[:,None] ) - for k in aberrations.keys(): - n,m = int(k[1]),int(k[2]) # C03 --> 0,3 - C = aberrations[k] ; phi0 = 0 - if not isinstance(C,(int,float)): - C,phi0 = C - dPhi += 2*np.pi/wavelength * \ - (1/(n+1)) * C * ( ks * wavelength ) ** (n+1) * \ - backend.cos( m * (theta-phi0) ) - return backend.exp(-1j * dPhi) + self._array = b.ifftshift(b.ifft2(reciprocal)) -#def probe_grid(xlims,ylims,n,m): -# x,y=np.meshgrid(np.linspace(*xlims,n),np.linspace(*ylims,m)) -# return np.reshape([x,y],(2,len(x.flat))).T + # ------------------------------------------------------------------ + # Copy + # ------------------------------------------------------------------ + def copy(self, selected_probes=None) -> Probe: + """ + Deep copy, optionally selecting a subset of probe positions. -def create_batched_probes(base_probe, probe_positions, device=None): - """ - Create a batch of shifted probes for vectorized processing. + selected_probes is an index array into the npt dimension. It is + kept as a numpy array (CPU) since it is used only for indexing, not + computation. + """ + b = self._backend + new_probe = Probe.__new__(Probe) + # Copy all non-array scalar attributes. + for attr, val in self.__dict__.items(): + if attr.startswith('_') or 'array' in attr: + continue + setattr(new_probe, attr, b.clone(val)) - Args: - base_probe: ProbeTorch object - probe_positions: List of (x,y) positions - device: PyTorch device + if selected_probes is not None: + sel = to_cpu(selected_probes) + nc, npt, nx, ny = self._array.shape + new_probe._array = b.clone( + self._array[:, :, :, :] if npt == 1 else self._array[:, sel, :, :] + ) + new_probe.offsets = self.offsets[sel, :] + new_probe.probe_positions = np.asarray(self.probe_positions)[sel, :] + else: + new_probe._array = b.clone(self._array) - Returns: - probe object with an array of shape (n_probes, nx, ny) - """ - # Move probe to correct device if needed - if device is not None: - device, _, _ = backend.device_and_precision(device) - # Always move to ensure array is actually on the device - # (checking base_probe.device may not reflect actual array device) - base_probe.to_device(device) - - n_probes = len(probe_positions) - probe_arrays = [] + return new_probe - nx = len(base_probe.xs) - ny = len(base_probe.ys) + # ------------------------------------------------------------------ + # Output + # ------------------------------------------------------------------ - # Compute dx, dy on same device as probe - if hasattr(base_probe.xs, 'device'): - dx = (base_probe.xs[1] - base_probe.xs[0]).item() - dy = (base_probe.ys[1] - base_probe.ys[0]).item() - else: - dx = base_probe.xs[1] - base_probe.xs[0] - dy = base_probe.ys[1] - base_probe.ys[0] + @property + def array(self) -> np.ndarray: + """CPU NumPy copy of the probe array.""" + return to_numpy(self._array) - lx = nx*dx ; ly = ny*dy + def plot(self, filename=None, title=None): + import matplotlib.pyplot as plt + b = self._backend + # Mean over nc copies, select position 0, flip y for imshow convention. + arr = np.flip(to_numpy(b.mean(b.absolute(self._array), axis=0)), axis=1)[0].T + plot_arr = np.abs(arr) ** 0.25 - for px, py in probe_positions: - # Create shifted probe using phase ramp in k-space - probe_k = backend.fft2(base_probe._array) + xs_np = to_numpy(self.xs) + ys_np = to_numpy(self.ys) + extent = (xs_np.min(), xs_np.max(), ys_np.min(), ys_np.max()) - # Apply phase ramp for spatial shift (negative sign = shift right) - kx_shift = backend.exp(-2j * backend.pi * base_probe.kxs[:, None] * (px-lx/2) ) - ky_shift = backend.exp(-2j * backend.pi * base_probe.kys[None, :] * (py-ly/2) ) - probe_k_shifted = probe_k * kx_shift * ky_shift - - # Convert back to real space - shifted_probe_array = backend.ifft2(probe_k_shifted) - probe_arrays.append(shifted_probe_array) - - # Stack into batch tensor - array = backend.stack(probe_arrays, axis=0) + fig, ax = plt.subplots() + ax.imshow(plot_arr, cmap="inferno", extent=extent) + ax.set_xlabel("x (Å)"); ax.set_ylabel("y (Å)") + if title: + ax.set_title(title) + if filename: + plt.savefig(filename) + else: + plt.show() + plt.close(fig) - return Probe(base_probe.xs, base_probe.ys, base_probe.mrad, base_probe.eV, array=array, device=base_probe.device) +# --------------------------------------------------------------------------- +# PrismProbe +# --------------------------------------------------------------------------- class PrismProbe: """ - Where Probe object creates a series of real-space probes (n,nx,ny cube, for n probe positions), the Prism algorithm propagates a series of sinusoids (fourier components shared by all real-space probes), then reconstructs each probe's exit wave. + PRISM algorithm probe representation. + + Instead of propagating one real-space probe per position, PRISM propagates + a sparse set of plane-wave Fourier components (sinusoids) that are shared + by all probe positions. The exit wave for any real-space probe is then + reconstructed as a linear combination of these component exit waves + (calculateProbesFromS). - PrismProbe object should serve as a stand-in for Probe, meaning it can be propagated through a potential (via the Propagate function), the probe cube (n,nx,ny) generated via self.applyShifts, and a subset of probes selected via self.copy, which enables chunked processing. where Probe.probe_positions stores real-space x,y pairs for positions, PrismProbe stores reciprocal-space kx,ky pairs to denote the sinusoid. + probe_positions here stores (kx, ky) reciprocal-space coordinates of the + sinusoids, NOT real-space (x, y) positions as in Probe. + Reference: Ophus, C. (2017). A fast image simulation algorithm for + scanning transmission electron microscopy. Advanced Structural and + Chemical Imaging, 3(1), 13. """ - def __init__(self, xs, ys, mrad, eV, array=None, device=None, gaussianVOA=0, preview=False, nkx = 25, nky=None, kth=1): - - # DEVICE AND DTYPE SETUP - if backend.TORCH_BACKEND: - # Auto-detect device if not specified (same logic as Potential class) - if device is None: - device, dtype, complex_dtype = backend.device_and_precision() - elif isinstance(device, str): - device, dtype, complex_dtype = backend.device_and_precision(device) - else: - # Assume device is already properly formatted - _, dtype, complex_dtype = backend.device_and_precision() - self.device = device - self.use_torch = True - self.dtype = dtype - self.complex_dtype = complex_dtype - else: - if device is not None: - raise ImportError("PyTorch not available. Please install PyTorch.") - self.device = None - self.use_torch = False - self.dtype = np.float64 - self.complex_dtype = np.complex128 - - # FULL-SIZED STUFF: USED FOR INTERACTING WITH THE POTENTIAL AND ALL THAT, real-space and reciprocal-space - self.dx = xs[1]-xs[0] ; self.dy = ys[1]-ys[0] - self.nx = len(xs) ; self.ny = len(ys) - # Convert coordinate arrays to tensors if using torch (same as Potential class) - if self.use_torch: - # Use asarray to handle both numpy and torch data - self.xs = backend.asarray(xs, dtype=self.dtype, device=self.device) - self.ys = backend.asarray(ys, dtype=self.dtype, device=self.device) - else: - self.xs = xs - self.ys = ys - self.kxs = backend.fftshift(backend.fftfreq(self.nx, d=self.dx)) - self.kys = backend.fftshift(backend.fftfreq(self.ny, d=self.dy)) - self._array = backend.zeros((1,1,self.nx,self.ny),dtype=self.complex_dtype) - # SPARSIFIED STUFF, USED FOR CONSTRUCTING SPARSE SINUSOIDS IN REAL SPACE + + def __init__( + self, + xs, ys, + mrad: float, + eV: float, + backend: Backend, + gaussianVOA: float = 0, + preview: bool = False, + nkx: int = 25, + nky: Optional[int] = None, + kth: int = 1, + ): + self._backend = backend + b = backend + + self.dx = float(xs[1] - xs[0]); self.dy = float(ys[1] - ys[0]) + self.nx = len(xs); self.ny = len(ys) + self.xs = b.asarray(xs, dtype=b.float_dtype) + self.ys = b.asarray(ys, dtype=b.float_dtype) + + # Shifted frequency arrays (origin at centre) for k-space indexing. + self.kxs = b.fftshift(b.fftfreq(self.nx, d=self.dx)) + self.kys = b.fftshift(b.fftfreq(self.ny, d=self.dy)) + + # Template array — will be expanded by applyShifts. + self._array = b.zeros((1, 1, self.nx, self.ny), dtype=b.complex_dtype) + + # ------------------------------------------------------------------ + # Sparse k-grid for PRISM + # ------------------------------------------------------------------ if nky is None: nky = nkx - self.nx_cropped = nkx ; self.ny_cropped = nky # indices for cropping i1,i2,j1,j2 - - self.i1 = self.nx//2-self.nx_cropped//2 #; self.i2 = self.i1+self.nx_cropped - self.j1 = self.ny//2-self.ny_cropped//2 #; self.j2 = self.j1+self.ny_cropped - self.nx_cropped = self.nx - 2*self.i1 ; self.ny_cropped = self.ny - 2*self.j1 - self.probe_positions=zeros((self.nx_cropped,self.ny_cropped,2)) - for i,kx in enumerate(self.kxs[self.i1:self.nx-self.i1]): # looping across a sparsified k-grid - for j,ky in enumerate(self.kys[self.j1:self.ny-self.j1]): - self.probe_positions[i,j,0]=kx - self.probe_positions[i,j,1]=ky - self.probe_positions = reshape(self.probe_positions,(self.nx_cropped*self.ny_cropped,2)) - - # HANDLE BEAM PARAMS (copied from Probe just in case anyone asks for them) - self.mrad = mrad - self.eV = eV ; self.wavelength=wavelength(eV) - self.eVs = np.asarray([eV]) - if self.use_torch: - self.eVs = backend.asarray(self.eVs, dtype=self.dtype, device=self.device) - self.wavelengths = wavelength(self.eVs) + self.nx_cropped = nkx; self.ny_cropped = nky + + # i1, j1: indices into the full shifted kxs/kys that mark the start + # of the central (nkx × nky) sub-grid of Fourier components. + self.i1 = self.nx // 2 - self.nx_cropped // 2 + self.j1 = self.ny // 2 - self.ny_cropped // 2 + # Re-compute the actual cropped sizes (may differ by 1 due to integer division). + self.nx_cropped = self.nx - 2 * self.i1 + self.ny_cropped = self.ny - 2 * self.j1 + + # Store the (kx, ky) pair for every Fourier component in the sparse grid. + pos = b.zeros((self.nx_cropped, self.ny_cropped, 2)) + for i, kx in enumerate(self.kxs[self.i1:self.nx - self.i1]): + for j, ky in enumerate(self.kys[self.j1:self.ny - self.j1]): + pos[i, j, 0] = kx + pos[i, j, 1] = ky + self.probe_positions = b.reshape(pos, (self.nx_cropped * self.ny_cropped, 2)) + + # ------------------------------------------------------------------ + # Beam parameters (mirrored from Probe for API compatibility) + # ------------------------------------------------------------------ + self.mrad = mrad + self.eV = eV + self.wavelength = wavelength(eV, b) + self.eVs = b.asarray([eV], dtype=b.float_dtype) + self.wavelengths = wavelength(self.eVs, b) self.temporal_decoherence = None - self.spatial_decoherence = None + self.spatial_decoherence = None self.gaussianVOA = gaussianVOA - self.cropping = False - self.kth = kth + self.cropping = False + self.kth = kth - # where Probe.applyShifts looks at real-space x,y pairs in probe_positions and applies a phase ramp to shift a template probe, PrismProbe.applyShifts looks at reciprocal-space kx,ky pairs in probe_positions to construct sinusoids def applyShifts(self): - # inflate self._array to store probe cube (npt,nx,ny) - self._array = self._array[:,0,None,:,:] * backend.ones(len(self.probe_positions), device=self.device)[None,:,None,None] - # loop through probe positions - for n,(kx,ky) in enumerate(self.probe_positions): - self._array[:,n,:,:] = backend.exp(2j * backend.pi * self.xs[:, None] * kx ) * backend.exp(2j * backend.pi * self.ys[None,:] * ky ) - # numpy appears to use exp(i2pixk) convention for FFT: xs = np.linspace(0,100,10000) ; ys = np.sin(xs) ; fft = np.fft.fft(ys) ; freq=np.fft.fftfreq(len(xs),d=xs[1]-xs[0]) ; fft2 = np.sum(ys[:,None]*np.exp(2j*np.pi*xs[:,None]*freq[None,:]),axis=0) - - # if a PrismProbe object (a whole bunch of sinusoidal entrance waves) is propagated through a potential, then the potential exit waves for a whole bunch of realistic probes can be calculated from the exit waves for each entrance wave - # SHIFTING: array is shifted, factors is NOT shifted, - #@profile - def calculateProbesFromS(self,array,positions,chunksize=100,load_into=None,ADF=False): # array comes in p,x,y,l,1 where p is our 50*50 grid of sinusoids + """ + Populate _array with the complex sinusoids for each Fourier component. + + The nth sinusoid for (kx_n, ky_n) is: + ψ_n(x, y) = exp(2πi (kx_n·x + ky_n·y)) + + This is the PRISM "interpolation factor" basis: propagating each of + these through the sample yields the S-matrix column for that k-vector. + """ + b = self._backend + self._array = ( + self._array[:, 0, None, :, :] + * b.ones(len(self.probe_positions))[None, :, None, None] + ) + for n, (kx, ky) in enumerate(self.probe_positions): + self._array[:, n, :, :] = ( + b.exp(2j * b.pi * self.xs[:, None] * kx) + * b.exp(2j * b.pi * self.ys[None, :] * ky) + ) + + def calculateProbesFromS(self, array, positions, chunksize: int = 100, + load_into=None, ADF=False): + """ + Reconstruct real-space probe exit waves from the S-matrix columns. + + After propagating the sinusoidal entrance waves through the sample, + each exit wave ψ_n(k) is a column of the scattering matrix S. The + exit wave for a probe at real-space position (x, y) is: + + Ψ_exit(k; x,y) = Σ_n P_n(k; x,y) · S_n(k) + + where P_n(k; x,y) is the Fourier component of the probe function + at k-vector n, evaluated for a probe centred at (x, y). This is + equivalent to selecting and phase-ramping the relevant rows of the + FFT'd probe aperture — exactly what the "factors" array contains. + + The reconstruction is done in chunks of size `chunksize` to avoid + blowing up RAM with a full (n_positions × nkx × nky) intermediate. + + array shape on input: (n_sinusoids, nkx, nky, n_layers, 1) + reshaped to: (nx_cropped, ny_cropped, nkx, nky) + """ + b = self._backend + if load_into is None and not ADF: - result = zeros((len(positions),ceil(self.nx/self.kth),ceil(self.ny/self.kth)),dtype="complex") # full-res kx,ky for each probe position + result = b.zeros( + (len(positions), b.ceil(self.nx / self.kth), b.ceil(self.ny / self.kth)), + dtype=b.complex_dtype, + ) elif not ADF: result = load_into else: - ADF,ADFmask,ADFindex = ADF ; result = None - npt,nkx,nky,_,_ = array.shape - array = reshape(array,(self.nx_cropped,self.ny_cropped,nkx,nky)) # eikx,eiky,kx,ky - # preview an arbitrary exit wave? (note: calculator will have done shift(fft(realspace)), so we should invert those steps) - #import matplotlib.pyplot as plt - #fig, ax = plt.subplots() - #i,j=self.nx_cropped//2+1,self.ny_cropped//2-1 - #ax.imshow(np.real(np.fft.ifft2(np.fft.ifftshift(to_cpu(array[i,j,:,:])))).T, cmap="inferno") - #plt.show() - # strategy: we need each probe's array (generated, shifted to position), FFT'd, cropped, so we can select fourier components - # you can 1) create a dummy probe, call generate_single_probe and placeProbe, and reuse it every time, and this can be done in real or reciprocal space. or 2) you can just create a new probe each time (for a chunk of positions). i'm choosing 2 because it makes chunking easier - #probe = Probe(self.xs, self.ys, self.mrad, self.eV, defer_shifts=True) # dummy probe so we can directly access Probe class functions - chunksize=max(1,chunksize) # handle 0 as chunksize - for n,(x,y) in enumerate(tqdm(positions)): - if n%chunksize!=0: + ADF, ADFmask, ADFindex = ADF + result = None + + npt, nkx, nky, _, _ = array.shape + # Reshape from (sinusoid_index, kx, ky, layer, 1) + # to (nx_cropped, ny_cropped, kx, ky) for einsum below. + array = b.reshape(array, (self.nx_cropped, self.ny_cropped, nkx, nky)) + + chunksize = max(1, chunksize) + for n, (x, y) in enumerate(tqdm(positions)): + if n % chunksize != 0: continue - # strategy 1, real-space - #ary = probe.generate_single_probe(self.mrad,self.wavelength,self.gaussianVOA,preview=False) - #probe_k = backend.fft.fftshift(backend.fft.fft2(probe.placeProbe(ary,x,y)[0][0,:,:])) # shiff(fft()) to match what calculators did to array - # strategy 2, keep things in reciprocal space, saves two ffts? - # realspace single probe was backend.fft.ifftshift(backend.fft.ifft2(reciprocal)) - # placed was backend.fft.fft2(array), then phase ramp, then backend.fft.ifft2(array) - #ary = probe.generate_single_probe(self.mrad,self.wavelength,self.gaussianVOA,preview=False,keep_reciprocal=True) - #probe_k = backend.fft.fftshift(probe.placeProbe(ary,x,y,realspace=False)[0][0,:,:]) - # strategy 3, stack of probes - #probes = Probe(self.xs, self.ys, self.mrad, self.eV, probe_positions = positions[n:n+chunksize]) - #kwarg = {"dim":(-2,-1)} if backend.TORCH_BACKEND else {"axes":(-2,-1)} - #probe_ks = backend.fft.fftshift(backend.fft.fft2(probes._array[0,:,:,:],**kwarg),**kwarg) - - # note you CAN generate the probe pre-cropped (use arg crop_reciprocal, then skip the self.i1:-self.i1 indexing), but this doesn't seem to save a whole lot of time... - probes = Probe(self.xs, self.ys, self.mrad, self.eV, probe_positions = positions[n:n+chunksize],stay_reciprocal=True)#,crop_reciprocal=(self.i1,self.j1)) - kwarg = {"axes":(-2,-1)} # Always use 'axes', backend will convert to 'dim' for torch if needed - probe_ks = backend.fftshift(probes._array[0,:,:,:],**kwarg) - - # fourier components of FFT'd and cropped probe are the contribution of each exit wave - factors = probe_ks[:,self.i1:self.nx-self.i1,self.j1:self.ny-self.j1] # this is unshifted since ij_lookup used unshifted kxs,kys - #factors = probe_ks#[:,self.i1:-self.i1,self.j1:-self.j1] # this is unshifted since ij_lookup used unshifted kxs,kys - chunked = einsum('pkq,kqxy->pxy',factors,array) # sum over all sinusoids - if isinstance(result,np.memmap): + + # Build a mini-Probe for this chunk of positions so we can reuse + # the phase-ramp logic in placeProbe / generate_single_probe. + # stay_reciprocal=True keeps the result in reciprocal space, + # avoiding two unnecessary FFTs. + probes = Probe( + to_numpy(self.xs), to_numpy(self.ys), + self.mrad, self.eV, backend=b, + probe_positions=positions[n:n + chunksize], + stay_reciprocal=True, + ) + # fftshift moves the reciprocal-space probe so k=0 is at centre, + # matching the shifted kxs/kys convention used for the sparse grid. + probe_ks = b.fftshift(probes._array[0, :, :, :], axes=(-2, -1)) + + # Crop to the sparse k-grid (i1:-i1, j1:-j1 in shifted indexing). + # These factors give the weighting of each sinusoid for this probe. + factors = probe_ks[:, self.i1:self.nx - self.i1, + self.j1:self.ny - self.j1] + + # Reconstruct the exit wave: Σ_{kx_n, ky_n} factors · S_n(kx, ky) + # Indices: p=probe chunk, k=sparse kx, q=sparse ky, x=full kx, y=full ky + chunked = b.einsum('pkq,kqxy->pxy', factors, array) + + if isinstance(result, np.memmap): chunked = to_cpu(chunked) + if ADF: - intensities = einsum('pxy,xy->p',absolute(chunked)**2,ADFmask) - for i,pp in zip(intensities,range(n,n+chunksize)): - ADF._array[ADFindex==pp] += i + intensities = b.einsum( + 'pxy,xy->p', b.absolute(chunked)**2, ADFmask) + for intensity, pp in zip(intensities, range(n, n + chunksize)): + ADF._array[ADFindex == pp] += intensity else: - result[n:n+chunksize,:,:] = chunked - - #dx = (x-probe.lx/2) ; dy = (y-probe.ly/2) - #if abs(dx)<.1 and abs(dy)<.1: - # print("\nposition",x,y) - # print("dx",dx,dy) - # import matplotlib.pyplot as plt - # fig, ax = plt.subplots() - # ax.imshow(np.real(probe_ks[0]).T, cmap="inferno") - # plt.show() - # preview our sparse-k reconstructed probe? fft --> downsample --> ifft - #if n<=len(positions)//3 PrismProbe: + b = self._backend new_probe = PrismProbe.__new__(PrismProbe) - for attr in self.__dict__.keys(): - if attr[0]=="_" or "array" in attr: + for attr, val in self.__dict__.items(): + if attr.startswith('_') or 'array' in attr: continue - val = getattr(self,attr) - val = clone(val) - setattr(new_probe,attr,val) + setattr(new_probe, attr, b.clone(val)) + if selected_probes is not None: - nc,npt,nx,ny = self._array.shape - if npt == 1: - new_probe._array = clone(self._array[:,:,:,:]) - else: - new_probe._array = clone(self._array[:,selected_probes,:,:]) - #new_probe.offsets = self.offsets[selected_probes,:] - new_probe.probe_positions = self.probe_positions[selected_probes,:] - #print("new",new_probe.offsets.shape,new_probe.probe_positions.shape) + nc, npt, nx, ny = self._array.shape + new_probe._array = b.clone( + self._array[:, :, :, :] if npt == 1 else self._array[:, selected_probes, :, :] + ) + new_probe.probe_positions = self.probe_positions[selected_probes, :] else: - new_probe._array = clone(self._array) - #print("no selected used") - #new_probe.device = self.device - #new_probe.array_numpy = self.array_numpy.copy() + new_probe._array = b.clone(self._array) + return new_probe @property - def array(self): - return to_cpu(self._array) + def array(self) -> np.ndarray: + return to_numpy(self._array) + +# --------------------------------------------------------------------------- +# Batched probe creation helper +# --------------------------------------------------------------------------- -# Given a real-space entrance wave, and a potential (or object), calculate the exit wave: ψ₁ -> O -> ψ₂ -# From Kirkland2010: -# propagator P = exp(-i π λ dz q²), Eq 6.65 -# transmission function t = exp(i σ O) where O is our object (or potential slice), Eq 6.59 -# ψ₂ = ℱ⁻¹[ P * ℱ[ t * ψ₁ ] ], Eq 6.67, noting the relationship: 𝒞[ f(x),g(x) ] = ℱ⁻¹[ ℱ[f(x)] * ℱ[g(x)] ] = ℱ⁻¹[ f(k) * g(k) ] -# or as code: array = t * array ; fft_array = fft(array) ; propagated_fft = P * fft_array ; array = ifft(propagated_fft) -def Propagate(probe, potential, device=None, progress=False, onthefly=True, store_all_slices=False): +def create_batched_probes(base_probe: Probe, probe_positions, + backend: Backend) -> Probe: + """ + Build a Probe with one shifted copy per position in probe_positions. + + This is a convenience wrapper for cases where the caller wants a fully + materialised (n_probes, nx, ny) probe cube without going through + applyShifts. Each copy is shifted via a k-space phase ramp as in + placeProbe, avoiding any interpolation. + """ + b = backend + nx, ny = len(base_probe.xs), len(base_probe.ys) + dx = float(to_numpy(base_probe.xs[1] - base_probe.xs[0])) + dy = float(to_numpy(base_probe.ys[1] - base_probe.ys[0])) + lx = nx * dx; ly = ny * dy + + probe_arrays = [] + for px, py in probe_positions: + probe_k = b.fft2(base_probe._array) + kx_shift = b.exp(-2j * b.pi * base_probe.kxs[:, None] * (px - lx / 2)) + ky_shift = b.exp(-2j * b.pi * base_probe.kys[None, :] * (py - ly / 2)) + probe_arrays.append(b.ifft2(probe_k * kx_shift * ky_shift)) + + return Probe( + to_numpy(base_probe.xs), to_numpy(base_probe.ys), + base_probe.mrad, base_probe.eV, backend=b, + array=b.stack(probe_arrays, axis=0), + ) + + +# --------------------------------------------------------------------------- +# Multislice propagator +# --------------------------------------------------------------------------- + +def Propagate( + probe, + potential, + backend: Backend, + progress: bool = False, + onthefly: bool = True, + store_all_slices: bool = False, +): """ - PyTorch-accelerated multislice propagation function. - Supports both single probe and batched multi-probe processing. + Multislice wave propagation (Kirkland 2010, §6.5). + + The algorithm alternates between two operations per slice z: + + 1. Transmission: + ψ'(r, z) = t(r, z) · ψ(r, z) + where the transmission function t = exp(iσ V(r, z)) encodes the + projected potential V of slice z, and σ is the interaction parameter: + σ = (2π / λ E₀) · (E₀ + eV) / (2E₀ + eV) + (Kirkland Eq. 5.6, with E₀ = m_e c² the electron rest energy). + + 2. Fresnel propagation to the next slice: + ψ(r, z+dz) = ℱ⁻¹[ P(k, dz) · ℱ[ψ'(r, z)] ] + where the propagator in k-space is: + P(k, dz) = exp(-iπ λ dz |k|²) + (Kirkland Eq. 6.65). The 2/3-Nyquist anti-aliasing aperture is + folded into P to bandwidth-limit the wavefunction at every slice + and suppress aliasing from the transmission step. + + The probe array shape is (nc, npt, nx, ny); it is flattened to + (nc·npt, nx, ny) for vectorised propagation then returned as-is. Args: - probe: ProbeTorch object or tensor with shape (n_probes, nx, ny) - potential: Potential object (can be NumPy or PyTorch version) - device: PyTorch device (None for auto-detection) - progress: Show progress bar - onthefly: If True, calculate potential slices on the fly. If False, build full array - store_all_slices: If True, return wavefunction at each slice instead of just exit wave + probe: Probe or PrismProbe object. + potential: Potential object (must expose .zs, .kxs, .kys, + ._array or ._calculate_slice). + backend: Active Backend instance. + progress: Show a tqdm progress bar over slices. + onthefly: If True, compute potential slices one at a time + (lower peak RAM). If False, build the full 3-D + potential first. + store_all_slices: If True, return wavefunction at every slice + (shape: n_slices, nc·npt, nx, ny) instead of + only the final exit wave. Returns: - torch.Tensor: Exit wavefunction(s) after multislice propagation - If store_all_slices=True, shape is (n_slices, n_probes, nx, ny) - Otherwise, shape is (n_probes, nx, ny) or (nx, ny) for single probe + Array of shape (nc·npt, nx, ny) or (n_slices, nc·npt, nx, ny). """ - if device is not None and device not in [None, 'cpu', 'CPU'] and not backend.TORCH_BACKEND: - raise ImportError("PyTorch not available. Please install PyTorch.") - if device is None and hasattr(probe, 'device'): - device = probe.device - - # Initialize wavefunction with probe(s) - shape: (n_probes, nx, ny) - nc,npt,nx,ny = probe._array.shape #; print("nc,npt,nx,ny",nc,npt,nx,ny) - array = probe._array.reshape((nc*npt,nx,ny)) # "flatten" first two indices - probe_wavelengths = probe.wavelengths[:,None]*backend.ones(npt, device=device)[None,:] # also expand wavelengths and eVs arrays to cover all probe positions npt - probe_wavelengths = probe_wavelengths.reshape(nc*npt) - probe_eVs = probe.eVs[:,None]*backend.ones(npt, device=device)[None,:] - probe_eVs = probe_eVs.reshape(nc*npt) - - # Calculate interaction parameter (Kirkland Eq 5.6) - E0_eV = m_electron * c_light**2 / q_electron - sigma = (2 * backend.pi) / (probe_wavelengths * probe_eVs) * \ - (E0_eV + probe_eVs) / (2 * E0_eV + probe_eVs) # wavelength and eVs now have length of n_probes - #print("propagate sigma",sigma) - #if backend.TORCH_BACKEND: - # #sigma_dtype = torch.float32 if device.type == 'mps' else torch.float64 - # sigma = torch.tensor(sigma, dtype=float_dtype, device=device) - - # Get slice thickness - dz = potential.zs[1] - potential.zs[0] if len(potential.zs) > 1 else 0.5 - - # Pre-compute propagation operator in k-space (Fresnel propagation) - # All tensors should already be on the correct device from creation - kx,ky = potential.kxs, potential.kys + b = backend + + nc, npt, nx, ny = probe._array.shape + # Flatten coherent copies and probe positions into a single batch index. + array = b.reshape(probe._array, (nc * npt, nx, ny)) + + # Expand wavelength and eV arrays to match the flattened batch dimension. + # probe.wavelengths has shape (nc,); each wavelength applies to all npt positions. + probe_wavelengths = b.reshape( + probe.wavelengths[:, None] * b.ones(npt)[None, :], (nc * npt,)) + probe_eVs = b.reshape( + probe.eVs[:, None] * b.ones(npt)[None, :], (nc * npt,)) + + # ------------------------------------------------------------------ + # Interaction parameter σ (Kirkland Eq. 5.6) + # ------------------------------------------------------------------ + # σ = (2π / λ·eV) · (E₀ + eV) / (2E₀ + eV) + # where E₀ = m_e·c² / q is the rest energy in eV. + # σ has units of 1/(V·Å) so that σ·V(Å) is dimensionless. + E0_eV = m_electron * c_light**2 / q_electron # rest energy, eV + sigma = ( + (2 * b.pi) / (probe_wavelengths * probe_eVs) + * (E0_eV + probe_eVs) / (2 * E0_eV + probe_eVs) + ) + + # ------------------------------------------------------------------ + # Slice thickness + # ------------------------------------------------------------------ + dz = float(to_numpy(potential.zs[1] - potential.zs[0])) if len(potential.zs) > 1 else 0.5 + + # ------------------------------------------------------------------ + # k-space grids and Fresnel propagator + # ------------------------------------------------------------------ + kx, ky = potential.kxs, potential.kys if probe.cropping: - kx = backend.fftfreq(probe.cropping, d=probe.dx, device=probe.device, dtype=probe.dtype) - ky = backend.fftfreq(probe.cropping, d=probe.dy, device=probe.device, dtype=probe.dtype) - kx_grid, ky_grid = backend.meshgrid(kx, ky, indexing='ij') - k_squared = kx_grid**2 + ky_grid**2 + # Use a smaller k-grid matching the cropped probe size. + kx = b.fftfreq(probe.cropping, d=probe.dx) + ky = b.fftfreq(probe.cropping, d=probe.dy) - # Precompute 2/3 Nyquist anti-aliasing aperture for bandwidth-limiting transmission functions - aa_aperture = antialias_aperture(kx, ky) + kx_grid, ky_grid = b.meshgrid(kx, ky, indexing='ij') + k_sq = kx_grid**2 + ky_grid**2 - # Fold anti-aliasing aperture into propagator to bandwidth-limit wavefunction at every slice - P = backend.exp(-1j * backend.pi * probe_wavelengths[:,None,None] * dz * k_squared[None,:,:]) * aa_aperture[None,:,:] # Kirkland2010 Eq 6.65 + # Anti-aliasing aperture: zeros out the outer 1/3 of k-space. + aa = antialias_aperture(kx, ky, b) - #print("(done)",time.time()-start) - - - if progress: - localtqdm = tqdm - print("propagating through slices") - else: - def localtqdm(iterator): - return iterator + # Fresnel propagator folded with anti-aliasing aperture. + # Shape: (nc·npt, nx, ny) — one P per wavelength in the batch. + # The aa aperture is broadcast over the batch dimension. + P = b.exp(-1j * b.pi * probe_wavelengths[:, None, None] * dz * k_sq[None, :, :]) * aa[None, :, :] if not onthefly: potential.build() - # More elegant approach: use list to accumulate slices if needed slice_wavefunctions = [] if store_all_slices else None + iterator = range(len(potential.zs)) + if progress: + print("Propagating through slices") + iterator = tqdm(iterator) - # Vectorized multislice propagation through each slice - for z in localtqdm(range(len(potential.zs))): - # Transmission function: t = exp(iσV(x,y,z)) - # All tensors should already be on the correct device from creation + for z in iterator: + # ------------------------------------------------------------------ + # Transmission function: t(r) = exp(i σ V(r, z)) + # ------------------------------------------------------------------ if onthefly: - #print("calculateSlice") ; start = time.time() - potential_slice = potential.calculateSlice(z) - #print("(done)",time.time()-start) + potential_slice = potential._calculate_slice(z) else: - potential_slice = potential._array[:, :, z] + potential_slice = potential.array[:, :, z] if probe.cropping: - #t = zeros( (len(sigma), probe.cropping, probe.cropping ), type_match=P) - #print("probe rolling") ; start = time.time() - # Usually you want vectorized, but this inflates to full npt,nx,ny before cropping: bad on RAM - #rollx = list(probe.offsets[:,0]) ; z = [1]*len(rollx) - #pot = backend.roll(potential_slice[None,:,:],rollx,z)[:,:probe.cropping,:] - #rolly = list(probe.offsets[:,1]) ; z = [2]*len(rolly) - #pot = backend.roll(pot[:,:,:],rolly,z)[:,:,:probe.cropping] - nx,ny = potential_slice.shape - #xr = backend.arange(nx) ; yr = backend.arange(ny) - #pot_stack = zeros( (len(sigma),probe.cropping,probe.cropping) ) - #for p,o in enumerate(probe.offsets): # We want to go from i1,j2 to i1+cropping,j1+cropping, but sometimes i1 or j1 is negatuve - # # rolling the whole thing: slow (5s per on Nick's particles) - # #pot = backend.roll(potential_slice,int(-o[0]),0)[:probe.cropping,:] - # #pot = backend.roll(pot,int(-o[1]),1)[:,:probe.cropping] - # # rolling indices: faster (0.7s per on Nick's particles) - # xi = backend.roll(xr,-o[0])[:probe.cropping] - # yi = backend.roll(yr,-o[1])[:probe.cropping] - # pot_stack[p] = potential_slice[xi,:][:,yi] - # full indexing is even faster - xi = backend.zeros((len(sigma),probe.cropping),dtype=int) ; yi = backend.zeros((len(sigma),probe.cropping),dtype=int) - xr = backend.arange(nx) ; yr = backend.arange(ny) - for p,(x,y) in enumerate(probe.offsets): - xi[p,:] = backend.roll(xr,-x)[:probe.cropping] - yi[p,:] = backend.roll(yr,-y)[:probe.cropping] - pot_stack=potential_slice[xi[:,:,None],yi[:,None,:]] - #print("(done)",time.time()-start) - t = backend.exp(1j*sigma[:,None,None]*pot_stack) - + # Build index arrays to extract the cropped sub-window for each + # probe position without allocating a full (npt, nx, ny) array. + nx_full, ny_full = potential_slice.shape + xr = b.arange(nx_full); yr = b.arange(ny_full) + xi = b.zeros((len(sigma), probe.cropping), dtype=int) + yi = b.zeros((len(sigma), probe.cropping), dtype=int) + for p, (ox, oy) in enumerate(probe.offsets): + xi[p, :] = b.roll(xr, -ox)[:probe.cropping] + yi[p, :] = b.roll(yr, -oy)[:probe.cropping] + # Advanced indexing: pot_stack[p, i, j] = potential_slice[xi[p,i], yi[p,j]] + pot_stack = potential_slice[xi[:, :, None], yi[:, None, :]] + t = b.exp(1j * sigma[:, None, None] * pot_stack) else: - t = backend.exp(1j * sigma[:,None,None] * potential_slice[None,:,:]) # Kirkland2010 Eq 6.59. n,x,y indices + # Broadcast: sigma shape (nc·npt,), potential_slice shape (nx, ny). + t = b.exp(1j * sigma[:, None, None] * potential_slice[None, :, :]) - # Apply transmission to all probes: ψ' = t × ψ - # Broadcasting: t[n_probes,nx,ny] * array[n_probes,nx,ny] = array[n_probes,nx,ny] array = t * array - # Store wavefunction at this slice if requested (after transmission) if store_all_slices: - # Clone/copy to avoid reference issues - if hasattr(array, 'clone'): - slice_wavefunctions.append(array.clone()) - else: - slice_wavefunctions.append(array.copy()) + slice_wavefunctions.append(b.clone(array)) - # Fresnel propagation to next slice (except for last slice) + # ------------------------------------------------------------------ + # Fresnel propagation: ψ(z+dz) = ℱ⁻¹[ P · ℱ[ψ'(z)] ] + # (skipped for the last slice — we want the exit wave, not another step) + # ------------------------------------------------------------------ if z < len(potential.zs) - 1: - # Vectorized FFT over spatial dimensions for all probes - kwarg = {"axes":(-2,-1)} # Always use 'axes', backend will convert to 'dim' for torch if needed - #print(kwarg,array.dtype,array.shape) - #print("FFT / multiply / iFFT") ; start = time.time() - fft_array = backend.fft2(array, **kwarg) - propagated_fft = P * fft_array - array = backend.ifft2(propagated_fft, **kwarg) - #print("(done)",time.time()-start) - - # Return results based on what was requested + array = b.ifft2(P * b.fft2(array, axes=(-2, -1)), axes=(-2, -1)) + if store_all_slices: - # Stack the list into a tensor with slices as a new dimension - # Shape will be (n_slices, n_probes, nx, ny) - more conventional ordering - return backend.stack(slice_wavefunctions, axis=0) - - #array = array.reshape((nc,npt,nx,ny)) - - # Return single probe result if input was single, otherwise return batch - #if array.shape[0] == 1: - # return array.squeeze(0) - return array # okay for Propagate to return a Tensor. we probably don't want to move things off-gpu yet - -# Given a real-space entrance and real-space exit wave, calculate the object the wave must have passed through: ψ₁ -> O -> ψ₂, given ψ₁,ψ₂, find O -# From Kirkland2010: -# propagator P = exp(-i π λ dz q²), Eq 6.65 -# transmission function t = exp(i σ O) where O is our object (or potential slice), Eq 6.59 -# ψ₂ = ℱ⁻¹[ P * ℱ[ t * ψ₁ ] ], Eq 6.67, noting the relationship: 𝒞[ f(x),g(x) ] = ℱ⁻¹[ ℱ[f(x)] * ℱ[g(x)] ] = ℱ⁻¹[ f(k) * g(k) ] -# or as code: array = t * array ; fft_array = fft(array) ; propagated_fft = P * fft_array ; array = ifft(propagated_fft) -# SO, to determine O from ψ₁ and ψ₂: -# ℱ[ ψ₂ ] = P * ℱ[ t * ψ₁ ] -# ℱ[ ψ₂ ]/P = ℱ[ t * ψ₁ ] -# ℱ⁻¹[ ℱ[ ψ₂ ]/P ] = t * ψ₁ -# t = ℱ⁻¹[ ℱ[ ψ₂ ]/P ]/ψ₁ -# exp(i σ O) = ℱ⁻¹[ ℱ[ ψ₂ ]/P ]/ψ₁ -# i σ O = log( ℱ⁻¹[ ℱ[ ψ₂ ]/P ]/ψ₁ ) -# O = log( ℱ⁻¹[ ℱ[ ψ₂ ]/P ]/ψ₁ ) / i / σ -def calculateObject(probe,exitwave,guessedObject,weighting=.5,dz=0.5,damping=.01): - - import matplotlib.pyplot as plt - #fig, axs = plt.subplots(1,2) - #axs[0].imshow(to_cpu(backend.absolute(exitwave)), cmap="inferno") ; axs[0].set_title("exit wave") - #axs[1].imshow(to_cpu(backend.absolute(probe._array[0,0,:,:])), cmap="inferno") ; axs[1].set_title("entrance wave") - #plt.show() - - nc,npt,nx,ny = probe._array.shape #; print("nc,npt,nx,ny",nc,npt,nx,ny) - psi1 = probe._array[0,0,:,:] # select first probe array only for now! - lamda = probe.wavelengths[0] - eV = probe.eVs[0] + # Shape: (n_slices, nc·npt, nx, ny) + return b.stack(slice_wavefunctions, axis=0) - # Calculate interaction parameter (Kirkland Eq 5.6) - E0_eV = m_electron * c_light**2 / q_electron - sigma = (2 * np.pi) / (lamda * eV) * \ - (E0_eV + eV) / (2 * E0_eV + eV) # wavelength and eVs now have length of n_probes + return array - # Pre-compute propagation operator in k-space (Fresnel propagation) - # All tensors should already be on the correct device from creation - kx_grid, ky_grid = backend.meshgrid(probe.kxs, probe.kys, indexing='ij') # TODO use probe.kxs instead, to free ourselves of the need to pass a potential - k_squared = kx_grid**2 + ky_grid**2 - P = backend.exp(-1j * backend.pi * lamda * dz * k_squared[:,:]) # P in Kirkland2010 Eq 6.65 is exp(-i...), so to divide by P, we can use Pp, exp(+j...) +# --------------------------------------------------------------------------- +# Inverse multislice: recover object from entrance and exit waves +# --------------------------------------------------------------------------- + +def calculateObject(probe, exitwave, guessedObject, backend: Backend, + weighting: float = 0.5, dz: float = 0.5, + damping: float = 0.01): + """ + Recover the projected potential slice from a known entrance and exit wave. + + From the multislice equations (Kirkland 2010): + ψ_exit = ℱ⁻¹[ P · ℱ[ t · ψ_entrance ] ] - # t = ℱ⁻¹[ ℱ[ ψ₂ ]/P ]/ψ₁ - t = backend.ifft2(backend.fft2(exitwave)/P)/psi1 - # t = exp(i σ O) --> O = log(t)/i/σ - O = backend.log(t)/1j/sigma - # WHAT IS exp(i σ O) REALLY DOING? exp(iϕ) is a sinusoid. an only-real object is applying a phase shift? can we do calculate an angle instead? - O = backend.angle(t)/sigma - # consider: - # instead of division, should i multiply by complex conjugate? (not technically the same, but it will deal with near-zeros) - # instead of log, should i use: https://en.wikipedia.org/wiki/Complex_logarithm#Calculating_the_principal_value - # should I apply a probe amplitude masking function? + Inverting step by step: + ℱ[ψ_exit] / P = ℱ[ t · ψ_entrance ] + t · ψ_entrance = ℱ⁻¹[ ℱ[ψ_exit] / P ] + t = ℱ⁻¹[ ℱ[ψ_exit] / P ] / ψ_entrance - #fig, axs = plt.subplots(1,3) - #axs[0].imshow(to_cpu(backend.absolute(exitwave)), cmap="inferno") ; axs[0].set_title("exit wave") - #axs[1].imshow(to_cpu(backend.absolute(probe._array[0,0,:,:])), cmap="inferno") ; axs[1].set_title("entrance wave") - #axs[2].imshow(to_cpu(backend.absolute(O)**.1), cmap="inferno") ; axs[2].set_title("object") - #plt.show() + Since t = exp(iσ O) the object O is: + O = angle(t) / σ (taking the phase of t, the most stable route) - delta=(O-asarray(guessedObject)) + A probe-amplitude damping mask is applied so that pixels where the probe + has no intensity (|ψ_entrance| ≈ 0) do not contribute unreliable estimates: + weight(r) = |ψ_entrance(r)| / (|ψ_entrance(r)| + δ · max|ψ_entrance|) + + The returned delta is a weighted update to be added to the current estimate + of the object (iterative refinement loop in the caller). + """ + b = backend + psi1 = probe._array[0, 0, :, :] + lamda = probe.wavelengths[0] + eV = probe.eVs[0] + + E0_eV = m_electron * c_light**2 / q_electron + sigma = ( + (2 * np.pi) / (lamda * eV) + * (E0_eV + eV) / (2 * E0_eV + eV) + ) - # probe amplitude masking function: zeros-out points where probe intensity is zero, without giving probe features as features in your potential - delta*=backend.absolute(psi1)/(backend.absolute(psi1)+damping*backend.amax(backend.absolute(psi1))) + kx_grid, ky_grid = b.meshgrid(probe.kxs, probe.kys, indexing='ij') + k_sq = kx_grid**2 + ky_grid**2 + # Propagator P — dividing by P in Fourier space back-propagates one slice. + P = b.exp(-1j * b.pi * lamda * dz * k_sq) - return delta*weighting + # Back-propagate exit wave through one slice and deconvolve entrance wave. + t = b.ifft2(b.fft2(exitwave) / P) / psi1 + # Extract object via phase: O = angle(t) / σ + O = b.angle(t) / sigma + # Probe-amplitude weighting suppresses contributions from low-intensity regions. + psi1_abs = b.absolute(psi1) + weight = psi1_abs / (psi1_abs + damping * b.amax(psi1_abs)) + delta = (O - b.asarray(guessedObject)) * weight + return delta * weighting diff --git a/src/pyslice/multislice/potentials.py b/src/pyslice/multislice/potentials.py index eca0fae..bb4bb70 100644 --- a/src/pyslice/multislice/potentials.py +++ b/src/pyslice/multislice/potentials.py @@ -1,360 +1,411 @@ -import pyslice.backend as backend +from __future__ import annotations + +import os +import logging +from pathlib import Path +from typing import Optional, Union + import numpy as np -import logging,os from tqdm import tqdm import importlib.resources as resources -kirkland_file = resources.files('pyslice.data').joinpath('kirkland.txt') +from pyslice.backend import Backend, to_numpy logger = logging.getLogger(__name__) -# Global storage for Kirkland parameters on GPU - store per device -kirklandABCDs = None +kirkland_file = resources.files('pyslice.data').joinpath('kirkland.txt') + +# --------------------------------------------------------------------------- +# Element / Kirkland utilities +# --------------------------------------------------------------------------- + +_ELEMENTS = [ + "H", "He", + "Li", "Be", "B", "C", "N", "O", "F", "Ne", + "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", + "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", + "Ga", "Ge", "As", "Se", "Br", "Kr", + "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", + "In", "Sn", "Sb", "Te", "I", "Xe", + "Cs", "Ba", + "La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", + "Tm", "Yb", + "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", + "Bi", "Po", "At", "Rn", + "Fr", "Ra", + "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", + "Md", "No", + "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn", "Nh", "Fl", + "Mc", "Lv", "Ts", "Og", +] + + +def get_z_from_element(element: str) -> int: + """Return atomic number (Z) for an element symbol.""" + try: + return _ELEMENTS.index(element) + 1 + except ValueError: + raise ValueError(f"Unknown element symbol: {element!r}") + + +def _resolve_z(atom_type: Union[str, int]) -> int: + """Resolve an atom type (string or int) to an atomic number.""" + if isinstance(atom_type, str): + return get_z_from_element(atom_type) + return int(atom_type) + + +def load_kirkland(backend: Backend) -> any: + """ + Load and return the Kirkland scattering parameters as a backend array. + + Shape: (103, 3, 4) — 103 elements, 3 Gaussian terms, 4 columns (a, b, c, d). -def kirkland(qsq, Z): + The returned array lives on the backend's default device. This function + no longer uses module-level global state; callers are responsible for + caching the result if they need it. """ - GPU-accelerated Kirkland structure factor calculation using PyTorch. - + params = [] + for i in range(103): + skip = i * 4 + 1 + try: + abcd = np.loadtxt(kirkland_file, skiprows=skip, max_rows=3) + a1, b1, a2, b2, a3, b3, c1, d1, c2, d2, c3, d3 = abcd.flat + # Reorder to columns (a, b, c, d) — Kirkland p. 291 + params.append([[a1, b1, c1, d1], + [a2, b2, c2, d2], + [a3, b3, c3, d3]]) + except Exception: + logger.warning("Kirkland parameters unavailable for element %d; using zeros.", i + 1) + params.append([[0, 0, 0, 0]] * 3) + + return backend.asarray(params) # shape (103, 3, 4) + + +def kirkland_form_factor(qsq: any, Z: int, kirkland_params: any, + backend: Backend) -> any: + """ + Compute the Kirkland electron scattering form factor for element Z. + Args: - qsq: |q|² tensor in units of (1/Angstrom)² - Z: Atomic number (or element name string) - device: PyTorch device ('cpu' or 'cuda') - + qsq: |q|² array, shape (nx, ny) + Z: Atomic number (1-based) + kirkland_params: Parameter array, shape (103, 3, 4), on the correct device + backend: Active Backend instance + Returns: - Form factor tensor with same shape as qsq + Form factor array with the same shape as qsq """ - global kirklandABCDs - - if kirklandABCDs is None: - # Get device from qsq tensor if it's a PyTorch tensor - if hasattr(qsq, 'device'): - loadKirkland(qsq.device) - else: - loadKirkland() - else: - # Move kirklandABCDs to match qsq device if needed - if hasattr(qsq, 'device') and hasattr(kirklandABCDs, 'device'): - if not qsq.device == kirklandABCDs.device: - kirklandABCDs = kirklandABCDs.to(qsq.device) - - if isinstance(Z, str): - Z = getZfromElementName(Z) - Z -= 1 # Convert to 0-based indexing - - # Grab columns for a,b,c,d parameters - already on correct device - ABCDs = kirklandABCDs[Z, :, :] - a = ABCDs[:, 0] - b = ABCDs[:, 1] + ABCDs = kirkland_params[Z - 1] # shape (3, 4) + a = ABCDs[:, 0] # shape (3,) + b = ABCDs[:, 1] c = ABCDs[:, 2] d = ABCDs[:, 3] - - # Vectorized computation on GPU - a_expanded = a[:, None, None] - b_expanded = b[:, None, None] - c_expanded = c[:, None, None] - d_expanded = d[:, None, None] - qsq_expanded = qsq[None, :, :] - term1 = backend.array_sum(a_expanded / (qsq_expanded + b_expanded), axis=0) - term2 = backend.array_sum(c_expanded * backend.exp(-d_expanded * qsq_expanded), axis=0) + # Broadcast over spatial dimensions without storing repeated copies + a3 = a[:, None, None] + b3 = b[:, None, None] + c3 = c[:, None, None] + d3 = d[:, None, None] + qsq3 = qsq[None, :, :] + term1 = backend.sum(a3 / (qsq3 + b3), axis=0) + term2 = backend.sum(c3 * backend.exp(-d3 * qsq3), axis=0) return term1 + term2 -def getZfromElementName(element): - """Return atomic number (Z) from element name.""" - elements = ["H", "He", - "Li", "Be", "B", "C", "N", "O", "F", "Ne", - "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", - "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr", - "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe", - "Cs", "Ba", - "La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", - "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Ti", "Pb", "Bi", "Po", "At", "Rn", - "Fr", "Ra", - "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", - "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn", "Nh", "Fl", "Mc", "Lv", "Ts", "Og"] - return elements.index(element) + 1 - -def gridFromTrajectory(trajectory,sampling=0.1,slice_thickness=0.5): - # Use box matrix diagonal elements for orthogonal simulation cells - box_matrix = trajectory.box_matrix - - # Extract box dimensions from diagonal elements (assuming orthogonal box) - lx = box_matrix[0, 0] # X dimension - ly = box_matrix[1, 1] # Y dimension - lz = box_matrix[2, 2] # Z dimension - - # Create grids based on sampling + +def grid_from_trajectory(trajectory, sampling: float = 0.1, + slice_thickness: float = 0.5, + backend: Optional[Backend] = None): + """ + Build coordinate grids from a trajectory box matrix. + + Returns: + xs, ys, zs, lx, ly, lz + """ + box = trajectory.box_matrix + lx, ly, lz = box[0, 0], box[1, 1], box[2, 2] + nx = int(lx / sampling) + 1 - ny = int(ly / sampling) + 1 + ny = int(ly / sampling) + 1 nz = int(lz / slice_thickness) + 1 - - xs = backend.linspace(0, lx, nx, endpoint=False) - ys = backend.linspace(0, ly, ny, endpoint=False) - zs = backend.linspace(0, lz, nz, endpoint=False) - return xs,ys,zs,lx,ly,lz + if backend is not None: + xs = backend.linspace(0, lx, nx) + ys = backend.linspace(0, ly, ny) + zs = backend.linspace(0, lz, nz) + else: + xs = np.linspace(0, lx, nx, endpoint=False) + ys = np.linspace(0, ly, ny, endpoint=False) + zs = np.linspace(0, lz, nz, endpoint=False) + return xs, ys, zs, lx, ly, lz -def loadKirkland(device='cpu'): - """Load Kirkland parameters from kirkland.txt file and move to GPU.""" - global kirklandABCDs - - # Parse Kirkland parameters - kirkland_params = [] - for i in range(103): # Elements 1-103 - rows = (i * 4 + 1, i * 4 + 5) # Skip header, read 3 lines - try: - abcd = np.loadtxt(kirkland_file, skiprows=rows[0], max_rows=3) - # ORDERING IS: (Kirkland page 291) - # a1 b1 a2 b2 - # a3 b4 c1 d1 - # c2 d2 c3 d3 - a1, b1, a2, b2, a3, b3, c1, d1, c2, d2, c3, d3 = abcd.flat - # reorder so four columns are a,b,c,d - abcd = [[a1, b1, c1, d1], [a2, b2, c2, d2], [a3, b3, c3, d3]] - kirkland_params.append(abcd) - except Exception as e: - # Fill with zeros if parameters not available - kirkland_params.append([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]) - - # Convert to appropriate tensor format with device handling - device, float_dtype, _ = backend.device_and_precision(device) - kirklandABCDs = backend.asarray(kirkland_params, dtype=float_dtype, device=device) +# --------------------------------------------------------------------------- +# Potential +# --------------------------------------------------------------------------- +# Prefactor: 2πℏ²/m_e in V·Å² (Kirkland Eq. C.1) +_FE_TO_V = 47.87764737 -class Potential: - def __init__( - self, xs, ys, zs, positions, atomTypes, - kind="kirkland", device=None, slice_axis=2, - progress=False, cache_dir=None, frame_idx=None): - # Set up device and backend first - device, float_dtype, complex_dtype = backend.device_and_precision(device) - - self.device = device - self.float_dtype = float_dtype - self.complex_dtype = complex_dtype - self.dtype = self.float_dtype - positions = backend.asarray(positions, dtype=self.float_dtype, device=self.device) +class Potential: + """ + Projected electrostatic potential computed via the Kirkland parameterisation. + + Parameters + ---------- + xs, ys, zs: + 1-D coordinate arrays (Å). + positions: + Atom positions, shape (N, 3). + atom_types: + Sequence of element symbols (str) or atomic numbers (int), length N. + backend: + Backend instance to use for all array operations. + kind: + Scattering parameterisation — currently 'kirkland' or 'gauss'. + slice_axis: + Axis (0, 1, or 2) along which to slice the sample. + cache_dir: + Optional directory for per-slice potential caching. + frame_idx: + Frame index used to disambiguate cache filenames. + chunk_size: + Maximum number of atoms processed per structure-factor batch. + """ - self.xs = backend.asarray(xs, dtype=self.float_dtype, device=self.device) - self.ys = backend.asarray(ys, dtype=self.float_dtype, device=self.device) - self.zs = backend.asarray(zs, dtype=self.float_dtype, device=self.device) + def __init__( + self, + xs, ys, zs, + positions, + atom_types, + backend: Backend, + kind: str = "kirkland", + slice_axis: int = 2, + cache_dir: Optional[Path] = None, + frame_idx: Optional[int] = None, + chunk_size: int = 2000, + ): + self._backend = backend + + # ---------------------------------------------------------------- + # Convert inputs to backend arrays + # ---------------------------------------------------------------- + self.xs = backend.asarray(xs) + self.ys = backend.asarray(ys) + self.zs = backend.asarray(zs) + positions = backend.asarray(positions) self.nx = len(xs) self.ny = len(ys) self.nz = len(zs) - self.dx = xs[1] - xs[0] - self.dy = ys[1] - ys[0] - self.dz = zs[1] - zs[0] if self.nz > 1 else 0.5 - - # Store slice axis for later use + self.dx = float(to_numpy(self.xs[1] - self.xs[0])) + self.dy = float(to_numpy(self.ys[1] - self.ys[0])) + self.dz = float(to_numpy(self.zs[1] - self.zs[0])) if self.nz > 1 else 0.5 + + # ---------------------------------------------------------------- + # Slice-axis geometry + # ---------------------------------------------------------------- self.slice_axis = slice_axis - - # Determine in-plane axes based on slice axis - all_axes = [0, 1, 2] - all_axes.remove(slice_axis) - self.inplane_axis1, self.inplane_axis2 = all_axes - - # Store coordinate arrays and spacing for the slice axis - coord_arrays = [xs, ys, zs] + inplane = [a for a in range(3) if a != slice_axis] + self.inplane_axis1, self.inplane_axis2 = inplane + + coord_arrays = [self.xs, self.ys, self.zs] spacings = [self.dx, self.dy, self.dz] self.slice_coords = coord_arrays[slice_axis] self.slice_spacing = spacings[slice_axis] self.n_slices = len(self.slice_coords) - - # Set up k-space frequencies - self.kxs = backend.fftfreq(self.nx, d=self.dx, dtype=float_dtype, device=device) - self.kys = backend.fftfreq(self.ny, d=self.dy, dtype=float_dtype, device=device) - qsq = self.kxs[:, None]**2 + self.kys[None, :]**2 - - # Convert atom types to atomic numbers if needed - unique_atom_types = set(atomTypes) - atomic_numbers = [] - for at in atomTypes: - if isinstance(at, str): - atomic_numbers.append(getZfromElementName(at)) - else: - atomic_numbers.append(at) - atomic_numbers = backend.asarray(atomic_numbers, dtype=int, device=device) - # OPTIMIZATION 1: Compute form factors once per atom type on GPU + # ---------------------------------------------------------------- + # k-space frequencies and |q|² + # ---------------------------------------------------------------- + self.kxs = backend.fftfreq(self.nx, d=self.dx) + self.kys = backend.fftfreq(self.ny, d=self.dy) + qsq = self.kxs[:, None] ** 2 + self.kys[None, :] ** 2 + + # ---------------------------------------------------------------- + # Resolve atom types to atomic numbers + # ---------------------------------------------------------------- + unique_types = list(dict.fromkeys(atom_types)) # preserves order, deduplicates + atom_z_list = [_resolve_z(at) for at in atom_types] + atom_z_np = np.array(atom_z_list, dtype=np.int64) + + # ---------------------------------------------------------------- + # Precompute form factors (once per unique atom type) + # ---------------------------------------------------------------- + if kind == "kirkland": + kirkland_params = load_kirkland(backend) + form_factors = {} - for at in unique_atom_types: + for at in unique_types: + Z = _resolve_z(at) if kind == "kirkland": - if isinstance(at, str): - Z = getZfromElementName(at) - else: - Z = at - form_factors[at] = kirkland(qsq, Z) + form_factors[at] = kirkland_form_factor(qsq, Z, kirkland_params, backend) elif kind == "gauss": - form_factors[at] = backend.exp(-1**2 * qsq / 2) - - self.cache_dir = cache_dir - self.frame_idx = frame_idx - - def calculateSlice(slice_idx): - # check for caching - cache_file = None - if self.cache_dir is not None: - cache_file = self.cache_dir / ("potential_"+str(frame_idx)+"_"+str(slice_idx)+".npy") - if cache_file is not None and os.path.exists(cache_file): - return np.load(cache_file) - - # Initialize slice of potential array - reciprocal = backend.zeros((self.nx, self.ny), dtype=complex_dtype, device=device) - - # Process each atom type separately (reuse form factors) - for at in unique_atom_types: - form_factor = form_factors[at] - - # OPTIMIZATION 2: Vectorized atom type masking on GPU - if isinstance(at, str): - type_mask = [atom_type == at for atom_type in atomTypes] - type_mask = backend.asarray(type_mask, dtype=bool, device=device) - else: - type_mask = (atomic_numbers == at) - - # OPTIMIZATION 3: Batch process all slices for this atom type along the specified axis - # Create slice masks for all slices at once - slice_coords = positions[type_mask, slice_axis] # Get coordinates along slice axis for this atom type - - if len(slice_coords) == 0: - continue - - # Vectorized spatial masking using correct slice coordinates - slice_min = self.slice_coords[slice_idx] - self.slice_spacing/2 if slice_idx > 0 else 0 - slice_max = self.slice_coords[slice_idx] + self.slice_spacing/2 if slice_idx < self.n_slices-1 else self.slice_coords[-1] + self.slice_spacing - - spatial_mask = (slice_coords >= slice_min) & (slice_coords < slice_max) - - if not backend.array_any(spatial_mask): - continue - - # Get positions for atoms in this slice and type - type_positions = positions[type_mask] - slice_positions = type_positions[spatial_mask] - - if len(slice_positions) == 0: - continue - - atomsx = slice_positions[:, self.inplane_axis1] - atomsy = slice_positions[:, self.inplane_axis2] - - # TODO i'm hard-coding the chunk size is 2000 atoms per layer which is HUGE, so this shouldn't affect anyone but me, but we really ought to do a "smarter" job of picking the chunk size - chunk_indices = list(np.arange(len(atomsx)))[::2000]+[len(atomsx)] - shape_factor = backend.zeros((self.nx,self.ny), dtype=self.complex_dtype, device=self.device) - - for i1,i2 in zip(chunk_indices[:-1],chunk_indices[1:]): - atx = atomsx[i1:i2] - aty = atomsy[i1:i2] - - # Compute structure factors - match NumPy pattern exactly - # exp(2 i pi (kx * x + ky * y) ) = exp(2 i pi kx x) * exp(2 i pi ky y), summed over all atoms (hence einsum below) - - expx = backend.exp(-1.j * 2 * np.pi * self.kxs[None, :] * atx[:, None]) - expy = backend.exp(-1.j * 2 * np.pi * self.kys[None, :] * aty[:, None]) - - # Einstein summation - match NumPy - shape_factor += backend.einsum('ax,ay->xy', expx, expy) - - reciprocal += shape_factor * form_factor - - real = backend.ifft2(reciprocal) - real = backend.real(real) - # Convert from electron scattering factor f_e to projected potential V_proj. - # Kirkland Eq C.1: f_e(q) = (m_e/2πℏ²) FT[V], so FT[V] = (2πℏ²/m_e) f_e. - # On discrete grid: V(r) = (1/A) Σ_k FT[V](k) exp(2πi k·r) - # = (2πℏ²/m_e) / (dx·dy) × ifft2(S · f_e) - # where A = Lx·Ly, and ifft2 already includes 1/N = 1/(Lx·Ly)×(dx·dy). - dx = self.xs[1] - self.xs[0] - dy = self.ys[1] - self.ys[0] - fe_to_V = 47.87764737 # 2πℏ²/m_e in V·Å² (Kirkland, Eq C.1 prefactor) - Z = real * fe_to_V / (dx * dy) - - if cache_file is not None: - if backend.TORCH_BACKEND and hasattr(Z, 'cpu'): - Z_cpu = Z.cpu().numpy() - else: - Z_cpu = Z - np.save(cache_file, Z_cpu) - - return Z - - self.calculateSlice = calculateSlice - self.array = None - - def build(self,progress=False): + form_factors[at] = backend.exp(-qsq / 2.0) + else: + raise ValueError(f"Unknown scattering kind: {kind!r}") + + # ---------------------------------------------------------------- + # Store everything needed by _calculate_slice + # ---------------------------------------------------------------- + self._positions = positions + self._atom_types = atom_types + self._atom_z_np = atom_z_np + self._unique_types = unique_types + self._form_factors = form_factors + self._chunk_size = chunk_size + self._cache_dir = cache_dir + self._frame_idx = frame_idx + + self.array: Optional[any] = None + + # ------------------------------------------------------------------ + # Internal slice calculation + # ------------------------------------------------------------------ + + def _calculate_slice(self, slice_idx: int) -> any: + """Compute the projected potential for one slice.""" + backend = self._backend + + # Check cache + cache_file = self._cache_path(slice_idx) + if cache_file is not None and cache_file.exists(): + return backend.asarray(np.load(cache_file)) + + reciprocal = backend.zeros( + (self.nx, self.ny), dtype=backend.complex_dtype) + + slice_min, slice_max = self._slice_bounds(slice_idx) + + for at in self._unique_types: + form_factor = self._form_factors[at] + + # Build atom-type mask (numpy, to avoid sending booleans to GPU) + if isinstance(at, str): + type_mask_np = np.array( + [t == at for t in self._atom_types], dtype=bool) + else: + type_mask_np = (self._atom_z_np == int(at)) + + if not type_mask_np.any(): + continue + + # Pull relevant positions to numpy for masking, then back to backend + positions_np = to_numpy(self._positions) + type_positions_np = positions_np[type_mask_np] + + slice_coords_np = type_positions_np[:, self.slice_axis] + spatial_mask_np = ( + (slice_coords_np >= slice_min) & (slice_coords_np < slice_max)) + + if not spatial_mask_np.any(): + continue + + slice_positions_np = type_positions_np[spatial_mask_np] + atomsx = backend.asarray(slice_positions_np[:, self.inplane_axis1]) + atomsy = backend.asarray(slice_positions_np[:, self.inplane_axis2]) + + shape_factor = backend.zeros( + (self.nx, self.ny), dtype=backend.complex_dtype) + + n_atoms = len(atomsx) + for start in range(0, n_atoms, self._chunk_size): + end = min(start + self._chunk_size, n_atoms) + atx = atomsx[start:end] + aty = atomsy[start:end] + + # exp(−2πi kx x) summed over atoms → shape factor + expx = backend.exp( + -1j * 2 * np.pi * self.kxs[None, :] * atx[:, None]) + expy = backend.exp( + -1j * 2 * np.pi * self.kys[None, :] * aty[:, None]) + shape_factor += backend.einsum('ax,ay->xy', expx, expy) + + reciprocal += shape_factor * form_factor + + # Transform to real space and apply physical prefactor + real_space = backend.real(backend.ifft2(reciprocal)) + # Kirkland Eq. C.1: V_proj = (2πℏ²/m_e) / (dx·dy) × IFFT(S · f_e) + result = real_space * _FE_TO_V / (self.dx * self.dy) + + if cache_file is not None: + np.save(cache_file, to_numpy(result)) + + return result + + def _slice_bounds(self, slice_idx: int): + """Return (min, max) coordinate bounds for a given slice index.""" + coords_np = to_numpy(self.slice_coords) + half = self.slice_spacing / 2.0 + lo = coords_np[slice_idx] - half if slice_idx > 0 else 0.0 + hi = (coords_np[slice_idx] + half + if slice_idx < self.n_slices - 1 + else coords_np[-1] + self.slice_spacing) + return lo, hi + + def _cache_path(self, slice_idx: int) -> Optional[Path]: + if self._cache_dir is None: + return None + return (self._cache_dir / + f"potential_{self._frame_idx}_{slice_idx}.npy") + + # ------------------------------------------------------------------ + # Public API + # ------------------------------------------------------------------ + + def build(self, progress: bool = False) -> None: + """Compute the full 3-D potential array.""" if self.array is not None: return - - # Initialize potential array - potential_real = backend.zeros( - (self.nx, self.ny, self.n_slices), - dtype=self.dtype, - device=self.device, - ) + backend = self._backend + potential = backend.zeros( + (self.nx, self.ny, self.n_slices), dtype=backend.float_dtype) + + iterator = range(self.n_slices) if progress: - localtqdm = tqdm - print("generating potential for slices") - else: - def localtqdm(iterator): - return iterator - - # cycle through layers generating reciprocal slice - for slice_idx in localtqdm(range(self.n_slices)): - potential_real[:, :, slice_idx] += self.calculateSlice(slice_idx) - - # Store tensor version for potential GPU operations - self.array = potential_real - - def to_cpu(self): - """Convert tensors back to CPU NumPy arrays.""" - return backend.to_cpu(self.array) - - def to_device(self, device): - """Move tensor data to specified device.""" - if hasattr(self, 'array_torch'): - self.array_torch = self.array_torch.to(device) - self.device = device - return self - - def plot(self,filename=""): + logger.info("Generating potential for %d slices", self.n_slices) + iterator = tqdm(iterator) + + for slice_idx in iterator: + potential[:, :, slice_idx] = self._calculate_slice(slice_idx) + + self.array = potential + + def to_numpy(self) -> np.ndarray: + """Return the potential array as a CPU NumPy array.""" + if self.array is None: + raise RuntimeError("Call build() before to_numpy().") + return to_numpy(self.array) + + def plot(self, filename: Optional[str] = None) -> None: + """Plot the summed projected potential.""" if self.array is None: self.build() import matplotlib.pyplot as plt + + backend = self._backend + array_np = to_numpy( + backend.sum(backend.absolute(self.array), axis=2)).T + + extent = ( + float(to_numpy(backend.amin(self.xs))), + float(to_numpy(backend.amax(self.xs))), + float(to_numpy(backend.amin(self.ys))), + float(to_numpy(backend.amax(self.ys))), + ) + fig, ax = plt.subplots() - array = backend.array_sum( - backend.absolute(self.array), - axis=2, - ).T # imshow convention: y,x. our convention: x,y - # Convert to CPU if on GPU/MPS device - if hasattr(array, 'cpu'): - array = array.cpu() - - # Convert extent values to CPU if needed - xs_min = backend.amin(self.xs) - xs_max = backend.amax(self.xs) - ys_min = backend.amin(self.ys) - ys_max = backend.amax(self.ys) - - if hasattr(xs_min, 'cpu'): - xs_min = xs_min.cpu() - xs_max = xs_max.cpu() - ys_min = ys_min.cpu() - ys_max = ys_max.cpu() - - extent = (xs_min, xs_max, ys_min, ys_max) - ax.imshow(array, cmap="inferno", extent=extent) - ax.set_xlabel("x ($\\AA$)") - ax.set_ylabel("y ($\\AA$)") - - if filename is not None: + ax.imshow(array_np, cmap="inferno", extent=extent) + ax.set_xlabel("x (Å)") + ax.set_ylabel("y (Å)") + + if filename: plt.savefig(filename) else: plt.show() - + plt.close(fig) \ No newline at end of file diff --git a/src/pyslice/multislice/sed.py b/src/pyslice/multislice/sed.py index fe3fe9b..350fe36 100644 --- a/src/pyslice/multislice/sed.py +++ b/src/pyslice/multislice/sed.py @@ -1,112 +1,79 @@ -# Spectral Energy Density: phonon dispersions: borrowed from pySED: https://github.com/tpchuckles/pySED -# avg - average positions [a,xyz] -# displacements - time-dependent atom displacements [t,a,xyz] -# kvec - an NxM grid of length-3 vectors for each k point -# v_xyz - 0,1,2 indicating if we'll track displacements in x,y or z (this is your vibration polarization direction). vector also allowed: e.g. [1,1,0] for diagonal -# bs - optional: should be a list of atom indices to include. this allows the caller to sum over crystal cell coordinates (see discussion on Σb below) +""" +Spectral Energy Density: phonon dispersions. +Borrowed from pySED: https://github.com/tpchuckles/pySED +""" +from __future__ import annotations import numpy as np -import pyslice.backend as backend -from pyslice.backend import fftfreq, fft, absolute +from typing import Union -def SED(avg,displacements,kvec,v_xyz=0,bs=''): +from pyslice.backend import Backend, to_numpy - # THE MATH: - # Φ(k,ω) = Σb | ∫ Σn u°(n,b,t) exp( i k r̄(n,0) - i ω t ) dt |² - # https://github.com/tyst3273/phonon-sed/blob/master/manual.pdf - # b is index *within* a unit cell, n is index *of* unit cell. pairs of - # n,b are indices pointing to a specific atom. u° is the velocity of - # each atom as a function of time. r̄(n,b=0) is the equilibrium position - # of the unit cell. (if atom b=0 in a unit cell is at the origin, then - # we can use x̄(n,b=0), i.e., the atom's average position). - # looping over n inside the integral, but not b, means there is - # coherent summing over "every bth atom". the maximum k will then depend - # on the spacing between these atoms (unit cell lattice constant), since - # higher-k (or lower wavelength) modes will see aliasing. short- - # wavelength optical modes will register as their BZ-folded longer- - # wavelength selves*. - # using r̄(n,b=0) rather than x̄(n,b) means a phase-shift is applied - # for b≠0 atoms. this means if we ignore b,n ("...Σb | ∫ Σn...") and sum - # across all atoms instead ("... | ∫ Σi..."), we lose BZ folding. if we - # don't care (fine, so long as a is small enough / k is large is small - # enough to "unfold" the dispersion), we simplify summing, and can use x̄ - # instead. we thus no longer require a perfect crystal to be analyzed. - # the above equation thus simplified to: - # Φ(k,ω) = | ∫ Σn u°(n,t) exp( i k x̄(n) - i ω t ) dt |² - # and noting the property: e^(A+B)=e^(A)*e^(B) - # Φ(k,ω) = | ∫ Σn u°(n,t) exp( i k x̄(n) ) * exp( - i ω t ) dt |² - # and noting that the definition of a fourier transform: - # F(w) = ∫ f(t) * exp( -i 2 π ω t ) dt - # we can reformulate the above eqaution as: - # f(t) = u°(n,t) * exp( i k x ) - # or: - # Φ(k,ω) = | FFT{ Σn f(t) } |² (this is much faster) - # of course, this code still *can* analyze crystals with folding: the - # user should simply call this function multiple times, passing the "bs" - # argument with a list of atom indices for us to use - # to process waves along an arbitrary vector, you you can *either* - # project positions onto the vector (then ks are just reciprocal - # distances along that vector), *or*, simply multiply position vectors - # (x,y,z positions) by k (as a vector, kx,ky,kz) and sum. when plugged - # into exp(ikx), you get the same result! - # PRE-PROCESSING - nt,na,nax=np.shape(displacements) # Infer system shape +def SED(avg: np.ndarray, + displacements: np.ndarray, + kvec, + backend: Backend, + v_xyz: Union[int, float, np.ndarray] = 0, + bs: np.ndarray = None): + """ + Compute Spectral Energy Density Φ(k, ω). - if len(bs)==0: # if user didn't specify specific atom indices, we take all atoms - bs=np.arange(na) - else: - na=len(bs) + THE MATH: + Φ(k,ω) = Σb | ∫ Σn u°(n,b,t) exp(i k r̄(n,0)) exp(-iωt) dt |² + = | FFT{ Σn u°(n,t) exp(i k x̄(n)) } |² - # user might pass an index for xyz, or a vector - if isinstance(v_xyz,(int,float,np.integer)): - v_xyz=np.roll([1,0,0],v_xyz) # 0,1,2 --> x,y,z - else: - v_xyz=backend.asarray(v_xyz,dtype=float) - v_xyz/=backend.sqrt(backend.array_sum(v_xyz**2)) # normalize magnitude of passed vector + Args: + avg: Mean atom positions, shape (n_atoms, 3). + displacements: Time-dependent displacements, shape (n_time, n_atoms, 3). + kvec: k-point grid of shape (nx, ny, 3). + backend: Active Backend instance. + v_xyz: Displacement direction — 0/1/2 for x/y/z, or a 3-vector. + bs: Optional atom index subset for BZ-folded calculation. - # time axis: infer frequencies, calculate length so we can trim off negative frequencies, set up empty - nt2=int(nt/2) ; ws=fftfreq(nt)[:nt2] + Returns: + Tuple of (Zs, ws): + Zs: Spectral power |FFT{…}|², shape (n_freq, nx, ny). + ws: Frequency array (positive half), length n_freq. + """ + nt, na, _ = displacements.shape - # project displacements onto vector - if isinstance(v_xyz,(int,float,np.integer)): - us=displacements[:,bs,v_xyz] # t,a,xyz --> t,a - else: - us=np.einsum("tax,x->ta",displacements[:,bs,:],v_xyz) # indices: (t)ime, (a)tom index, (x)/y/z direction - - # real spectral *energy* density needs to use masses ( Ek = ½ m v² ) - #if masses is not None: - # us=us[:,:]*masses[None,:] # t,a indices for velocities + if bs is None: + bs = np.arange(na) + else: + na = len(bs) - # damping out beginning and end of time series may help with noise - #if hannFilter: - # ts=np.linspace(0,np.pi,len(vs)) ; hann=np.sin(ts)**2 - # vs*=hann[:,None] + # Normalise v_xyz to a direction vector + if isinstance(v_xyz, (int, float, np.integer)): + v_xyz = np.roll(np.array([1.0, 0.0, 0.0]), int(v_xyz)) + else: + v = backend.asarray(v_xyz, dtype=None) + v_xyz = to_numpy(v / backend.sqrt(backend.sum(v ** 2))) - # FINALLY TIME FOR MATH! and how does einsum work? - # Suppose I have the two matrices: the first has axis indices of - # a,k,xyz (which (a)tom, which (k) point, which direction of (x)/y/z). I - # want to multiply with the second matrix, with axis indices of t,a,xyz - # (which (t)ime point, which (a)tom, which direction of (x)/y/z). then I - # want to sum across a and xyz. I want to do: - # "v[:,:,None,:]*expo[None,:,:,:]" - # which creates a giganormous matrix of indices t,a,k,xyz, then we can - # sum via: - # np.sum(that,axis=(1,3)) - # to obtain a result with indices of t,k - # *or* we can use np.einsum: - # np.eigsum("tax,akx->tk",v,expo) - # using einsum means we don't need to populate the super huge 4D matrix, - # but we still do all the same math, super fast, using underlying C - # code, without needing to do (slow) python loops. + nt2 = nt // 2 + ws = np.fft.fftfreq(nt)[:nt2] - # Φ(k,ω) = Σb | ∫ Σn u°(n,b,t) exp( i k r̄(n,0) ) exp( i ω t ) dt |² or | ℱ[ Σn u°(n,b,t) exp( i k r̄(n,0) ) |² - # exp( i k r̄(n,0) ) term: - expo=backend.exp(1j*backend.einsum('aj,xyj->axy',avg[bs,:],kvec[:,:,:])) # indices: (a)tom, (x)/y/z, (k) point - # u°(n,b,t) exp( i k r̄(n,0) ) term: - integrands=backend.einsum('ta,axy->txy',us,expo,optimize=True) # indices: (t)ime, (a)toms, (k) point - Zs=fft(integrands,axis=0)[:nt2,:,:] - #if not keepComplex: - Zs=absolute(Zs)**2 + # Project displacements onto polarisation direction → shape (n_time, n_atoms) + if v_xyz.sum() == 1 and v_xyz.dtype == float: + # Pure axis: fast path via integer index + axis = int(np.argmax(v_xyz)) + us = displacements[:, bs, axis] + else: + us = np.einsum("tax,x->ta", displacements[:, bs, :], v_xyz) - return Zs,ws + # exp(i k · r̄) → shape (n_atoms, nx, ny) + expo = backend.exp( + 1j * backend.einsum('aj,xyj->axy', + backend.asarray(avg[bs, :]), + backend.asarray(kvec))) + + # Σn u°(n,t) exp(i k x̄(n)) → shape (n_time, nx, ny) + integrands = backend.einsum('ta,axy->txy', backend.asarray(us), expo) + + # FFT along time, keep positive frequencies, take intensity + Zs = backend.fft(integrands, axes=0) + # Slice positive-frequency half — use numpy indexing after to_numpy + Zs_np = to_numpy(Zs)[:nt2, :, :] + Zs_np = np.abs(Zs_np) ** 2 + + return Zs_np, ws diff --git a/src/pyslice/multislice/trajectory.py b/src/pyslice/multislice/trajectory.py index ecd7944..ee27655 100644 --- a/src/pyslice/multislice/trajectory.py +++ b/src/pyslice/multislice/trajectory.py @@ -1,26 +1,28 @@ """ Core trajectory data structure for molecular dynamics data. +trajectory.py has no backend dependency — it is pure NumPy data. """ +from __future__ import annotations + from dataclasses import dataclass +from typing import List, Optional, Tuple + import numpy as np -from typing import List, Tuple, Optional from ase import Atoms + @dataclass class Trajectory: atom_types: np.ndarray positions: np.ndarray velocities: np.ndarray box_matrix: np.ndarray - timestep: float # Timestep in picosecondss + timestep: float # Timestep in picoseconds def __post_init__(self): - """Validate trajectory data.""" self._validate_shapes() def _validate_shapes(self): - """Validate array shapes and consistency.""" - # Check dimensions if self.positions.ndim != 3 or self.positions.shape[2] != 3: raise ValueError(f"positions must be (frames, atoms, 3), got {self.positions.shape}") if self.velocities.ndim != 3 or self.velocities.shape[2] != 3: @@ -30,7 +32,6 @@ def _validate_shapes(self): if self.box_matrix.shape != (3, 3): raise ValueError(f"box_matrix must be (3, 3), got {self.box_matrix.shape}") - # Check consistency n_frames_pos, n_atoms_pos = self.positions.shape[:2] n_frames_vel, n_atoms_vel = self.velocities.shape[:2] n_atoms_types = len(self.atom_types) @@ -42,470 +43,274 @@ def _validate_shapes(self): @property def n_frames(self) -> int: - """Number of frames in trajectory.""" return self.positions.shape[0] @property def n_atoms(self) -> int: - """Number of atoms in the system.""" return len(self.atom_types) @property def box_tilts(self) -> np.ndarray: - """Extract box tilt angles from the box matrix off-diagonal elements.""" return np.array([self.box_matrix[0, 1], self.box_matrix[0, 2], self.box_matrix[1, 2]]) @property def extent(self) -> np.ndarray: - """Return Cartesian extent (x, y, z) of the cell in Angstroms. - - Computes the bounding box of the parallelepiped defined by the lattice vectors. - Useful for determining sampling: sampling = extent / n_pixels. - """ + """Cartesian bounding box (x, y, z) of the simulation cell in Angstroms.""" a, b, c = self.box_matrix[0], self.box_matrix[1], self.box_matrix[2] - corners = np.array([ - [0, 0, 0], a, b, c, a+b, a+c, b+c, a+b+c - ]) + corners = np.array([[0,0,0], a, b, c, a+b, a+c, b+c, a+b+c]) return corners.max(axis=0) - corners.min(axis=0) - def get_mean_positions(self) -> np.ndarray: # TODO: THIS DOES NOT INCLUDE WRAPPING (what if an atom drifts out of the bbox and comes back in through PBC?) - """Calculate the mean position for each atom over all frames.""" + def get_mean_positions(self) -> np.ndarray: + """Mean position for each atom over all frames.""" if self.n_frames == 0: return np.empty((0, 3), dtype=self.positions.dtype) return np.mean(self.positions, axis=0) - + def get_distplacements(self) -> np.ndarray: - return self.positions[:,:,:]-self.get_mean_positions()[None,:,:] + """Per-frame displacement from mean position.""" + return self.positions - self.get_mean_positions()[None, :, :] - def tile_positions(self, repeats: Tuple[int, int, int], trajectories:list = None) -> 'Trajectory': - """ - Tile the positions by repeating the system in 3D space. + def slice_timesteps(self, i1: int = 0, i2: Optional[int] = None, ith: int = 1) -> Trajectory: + """Slice trajectory to a range of frames. Args: - repeats: Tuple of (nx, ny, nz) repeats in x, y, z directions - - Returns: - New Trajectory with tiled positions + i1: first frame index to keep (or a list/tuple of specific indices) + i2: first frame index to exclude (default: include last frame) + ith: stride — 2 = every other frame, 3 = every third, etc. """ - nx, ny, nz = repeats - total_tiles = nx * ny * nz + if isinstance(i1, (list, tuple, np.ndarray)): + return self.select_timesteps(i1) + if i2 is None: + i2 = len(self.positions) + return Trajectory( + atom_types=self.atom_types, + positions=self.positions[i1:i2:ith], + velocities=self.velocities[i1:i2:ith], + box_matrix=self.box_matrix, + timestep=self.timestep * ith, + ) - # Generate all tile offsets - # Note: box_matrix uses row convention (rows are lattice vectors a, b, c) - # so offset = [i, j, k] @ box_matrix = i*a + j*b + k*c - offsets = [] - for i in range(nx): - for j in range(ny): - for k in range(nz): - offset = np.array([i, j, k]) @ self.box_matrix - offsets.append(offset) + def select_timesteps(self, indices) -> Trajectory: + """Select specific frames by index array.""" + if indices is None: + indices = slice(0, len(self.positions)) + return Trajectory( + atom_types=self.atom_types, + positions=self.positions[indices], + velocities=self.velocities[indices], + box_matrix=self.box_matrix, + timestep=0.0, + ) - #print("self.box_matrix",self.box_matrix) + def get_random_timesteps(self, N: int = 1, seed: Optional[int] = None) -> Trajectory: + """Return N randomly selected frames (useful for frozen-phonon sampling). - # Apply offsets to create tiled positions and velocities - tiled_positions = [] - tiled_velocities = [] - tiled_atom_types = [] + Args: + N: number of frames to keep + seed: numpy random seed for reproducibility + """ + if seed is not None: + np.random.seed(seed) + indices = np.arange(len(self.positions)) + np.random.shuffle(indices) + return Trajectory( + atom_types=self.atom_types, + positions=self.positions[indices[:N]], + velocities=self.velocities[indices[:N]], + box_matrix=self.box_matrix, + timestep=self.timestep, + ) + def tile_positions(self, repeats: Tuple[int, int, int], + trajectories: Optional[list] = None) -> Trajectory: + """Tile the simulation cell by repeating in 3D space.""" + nx, ny, nz = repeats + offsets = [ + np.array([i, j, k]) @ self.box_matrix + for i in range(nx) for j in range(ny) for k in range(nz) + ] if trajectories is None or len(trajectories) != len(offsets): - trajectories = [ self ]*len(offsets) + trajectories = [self] * len(offsets) - for offset,traj in zip(offsets,trajectories): - tiled_positions.append(traj.positions + offset) - tiled_velocities.append(traj.velocities) - tiled_atom_types.append(traj.atom_types) + tiled_positions = [t.positions + o for t, o in zip(trajectories, offsets)] + tiled_velocities = [t.velocities for t in trajectories] + tiled_types = [t.atom_types for t in trajectories] - # Concatenate all tiles - new_positions = np.concatenate(tiled_positions, axis=1) - new_velocities = np.concatenate(tiled_velocities, axis=1) - new_atom_types = np.concatenate(tiled_atom_types) - - # Scale box matrix (row convention: row 0 = a, row 1 = b, row 2 = c) - new_box_matrix = self.box_matrix.copy() - new_box_matrix[0, :] *= nx # Scale a vector (row 0) - new_box_matrix[1, :] *= ny # Scale b vector (row 1) - new_box_matrix[2, :] *= nz # Scale c vector (row 2) + new_box = self.box_matrix.copy() + new_box[0, :] *= nx + new_box[1, :] *= ny + new_box[2, :] *= nz return Trajectory( - atom_types=new_atom_types, - positions=new_positions, - velocities=new_velocities, - box_matrix=new_box_matrix, - timestep=self.timestep + atom_types=np.concatenate(tiled_types), + positions=np.concatenate(tiled_positions, axis=1), + velocities=np.concatenate(tiled_velocities, axis=1), + box_matrix=new_box, + timestep=self.timestep, ) - def _validate_range(self, range_val: Optional[Tuple[float, float]], axis_name: str) -> Optional[Tuple[float, float]]: - """Validate a coordinate range.""" - if range_val is None: - return None - - min_val, max_val = range_val - if min_val > max_val: - raise ValueError(f"{axis_name} range invalid: min={min_val} > max={max_val}") - - return range_val - - def swap_axes(self,axes): - positions_swapped = self.positions[:,:,axes] - velocities_swapped = self.velocities[:,:,axes] - box_swapped = self.box_matrix[axes,:][:,axes] + def swap_axes(self, axes) -> Trajectory: return Trajectory( atom_types=self.atom_types, - positions=positions_swapped, - velocities=velocities_swapped, - box_matrix=box_swapped, - timestep=self.timestep + positions=self.positions[:, :, axes], + velocities=self.velocities[:, :, axes], + box_matrix=self.box_matrix[axes, :][:, axes], + timestep=self.timestep, ) - def tilt_positions(self,alpha=0,beta=0) -> 'Trajectory': - ca=np.cos(alpha) ; sa=np.sin(alpha) - cb=np.cos(beta) ; sb=np.sin(beta) - Ra=np.asarray([[1,0,0],[0,ca,-sa],[0,sa,ca]]) - Rb=np.asarray([[cb,0,-sb],[0,1,0],[sb,0,cb]]) - nt,na,nxyz = np.shape(self.positions) - pos = np.reshape(self.positions,(nt*na,3)).T - vel = np.reshape(self.velocities,(nt*na,3)).T - positions_tilted = np.reshape( ( Rb @ Ra @ pos ).T , (nt,na,3) ) - velocities_tilted = np.reshape( ( Rb @ Ra @ vel ).T , (nt,na,3) ) - + def tilt_positions(self, alpha: float = 0, beta: float = 0) -> Trajectory: + ca, sa = np.cos(alpha), np.sin(alpha) + cb, sb = np.cos(beta), np.sin(beta) + Ra = np.array([[1, 0, 0], [0, ca, -sa], [0, sa, ca]]) + Rb = np.array([[cb, 0, -sb], [0, 1, 0], [sb, 0, cb]]) + nt, na, _ = self.positions.shape + R = Rb @ Ra + pos = (self.positions.reshape(nt * na, 3) @ R.T).reshape(nt, na, 3) + vel = (self.velocities.reshape(nt * na, 3) @ R.T).reshape(nt, na, 3) return Trajectory( atom_types=self.atom_types, - positions=positions_tilted, - velocities=velocities_tilted, + positions=pos, + velocities=vel, box_matrix=self.box_matrix, - timestep=self.timestep + timestep=self.timestep, ) def slice_positions(self, - x_range: Optional[Tuple[float, float]] = None, - y_range: Optional[Tuple[float, float]] = None, - z_range: Optional[Tuple[float, float]] = None) -> 'Trajectory': - """ - Slice trajectory to include only atoms within specified spatial ranges. - - Args: - x_range: (min, max) for X-axis filtering in Angstroms - y_range: (min, max) for Y-axis filtering in Angstroms - z_range: (min, max) for Z-axis filtering in Angstroms - - Returns: - New Trajectory with only atoms in the specified spatial ranges - """ + x_range: Optional[Tuple[float, float]] = None, + y_range: Optional[Tuple[float, float]] = None, + z_range: Optional[Tuple[float, float]] = None) -> Trajectory: + """Keep only atoms whose mean position falls within specified ranges.""" if self.n_atoms == 0: return self - - # Validate ranges x_range = self._validate_range(x_range, "X") y_range = self._validate_range(y_range, "Y") z_range = self._validate_range(z_range, "Z") - - # Check if any filtering is needed if all(r is None for r in [x_range, y_range, z_range]): return self - # Use mean positions for spatial filtering mean_pos = self.get_mean_positions() - if mean_pos.shape[0] == 0: - return self - - # Apply filters - atom_mask = np.ones(self.n_atoms, dtype=bool) - new_box = self.box_matrix.copy() - - if x_range is not None: - min_x, max_x = x_range - atom_mask &= (mean_pos[:, 0] >= min_x) & (mean_pos[:, 0] <= max_x) - new_box[0, 0] = max_x - min_x - - if y_range is not None: - min_y, max_y = y_range - atom_mask &= (mean_pos[:, 1] >= min_y) & (mean_pos[:, 1] <= max_y) - new_box[1, 1] = max_y - min_y - - if z_range is not None: - min_z, max_z = z_range - atom_mask &= (mean_pos[:, 2] >= min_z) & (mean_pos[:, 2] <= max_z) - new_box[2, 2] = max_z - min_z - - # Check results - n_filtered = np.sum(atom_mask) - if n_filtered == 0: - ranges_desc = [] - if x_range: ranges_desc.append(f"X∈[{x_range[0]:.2f},{x_range[1]:.2f}]") - if y_range: ranges_desc.append(f"Y∈[{y_range[0]:.2f},{y_range[1]:.2f}]") - if z_range: ranges_desc.append(f"Z∈[{z_range[0]:.2f},{z_range[1]:.2f}]") - raise ValueError(f"Filter {' AND '.join(ranges_desc)} resulted in 0 atoms") - - if n_filtered == self.n_atoms: - return self - - # Create filtered trajectory - return Trajectory( - atom_types=self.atom_types[atom_mask], - positions=self.positions[:, atom_mask, :], - velocities=self.velocities[:, atom_mask, :], - box_matrix=new_box, - timestep=self.timestep - ) - - def slice_timesteps(self, i1: int=1, i2:int=None, ith: int=1) -> 'Trajectory': - """ - Slice trajectory to include only specified timesteps. - - Args: - i1: first frame index to keep (default 0, i.e., first), - OR a list of specific indices to select - i2: first frame index to ignore (defaults to include last) - ith: used for selecting alternating frames. 2 = every-other, 3 = every 3rd etc - - Returns: - New Trajectory with only the specified timesteps - """ - # Handle list of indices - delegate to select_timesteps - if isinstance(i1, (list, tuple)): - return self.select_timesteps(i1) - - if i2 is None: - i2=len(self.positions) + mask = np.ones(self.n_atoms, dtype=bool) + for axis, rng in enumerate([x_range, y_range, z_range]): + if rng is not None: + mask &= (mean_pos[:, axis] >= rng[0]) & (mean_pos[:, axis] <= rng[1]) return Trajectory( - atom_types=self.atom_types, - positions=self.positions[i1:i2:ith, :, :], - velocities=self.velocities[i1:i2:ith, :, :], + atom_types=self.atom_types[mask], + positions=self.positions[:, mask, :], + velocities=self.velocities[:, mask, :], box_matrix=self.box_matrix, - timestep=self.timestep*ith + timestep=self.timestep, ) - def select_timesteps(self, indices: int) -> 'Trajectory': - """ - Select specified timesteps. - - Args: - indices: indices of timesteps to be selected - - Returns: - New Trajectory with only the specified timesteps - """ - - if indices is None: - indices=slice(0, len(self.positions), 1) + def _validate_range(self, range_val, axis_name): + if range_val is None: + return None + lo, hi = range_val + if lo > hi: + raise ValueError(f"{axis_name} range invalid: min={lo} > max={hi}") + return range_val - # Note in this case the timestep variable is meaningless, - # maybe we can find a more elegant solution (?) + def random_frames(self, N: int, seed: Optional[int] = None) -> Trajectory: + """Return a new Trajectory with N randomly selected frames.""" + rng = np.random.default_rng(seed) + indices = rng.choice(self.n_frames, size=N, replace=False) return Trajectory( atom_types=self.atom_types, - positions=self.positions[indices, :, :], - velocities=self.velocities[indices, :, :], + positions=self.positions[indices], + velocities=self.velocities[indices], box_matrix=self.box_matrix, - timestep=0.0 + timestep=self.timestep, ) - def get_random_timesteps(self, N: int=1, seed: int = None) -> 'Trajectory': - """ - Filter trajectory down to random frames (useful for conventional frozen-phonon) - - Args: - N: the number of frames to keep - seed: randomization seed to supply to numpy random - Returns: - New Trajectory with randomized frames - """ - - if seed is not None: - np.random.seed(seed) - - indices = np.arange(len(self.positions)) - np.random.shuffle(indices) #; print(indices) - indices = indices[:N] - + def generate_random_displacements(self, n_displacements: int, sigma: float, + seed: Optional[int] = None) -> Trajectory: + rng = np.random.default_rng(seed) + na = self.n_atoms + dxyz = rng.normal(0, sigma / np.sqrt(3), size=(n_displacements, na, 3)) return Trajectory( atom_types=self.atom_types, - positions=self.positions[indices, :, :], - velocities=self.velocities[indices, :, :], + positions=self.positions[0] + dxyz, + velocities=np.broadcast_to(self.velocities[0], (n_displacements, na, 3)).copy(), box_matrix=self.box_matrix, - timestep=self.timestep + timestep=self.timestep, ) - def generate_random_displacements(self,n_displacements,sigma,seed=None): - na=len(self.positions[0]) - if seed is not None: - np.random.seed(seed) - dxyz=np.random.normal(0,sigma/np.sqrt(3),size=(n_displacements,na,3)) - positions = self.positions[0]+dxyz + def rotate_to(self, direction: Tuple[int, int, int]) -> Trajectory: + """Rotate so that the given crystallographic direction aligns with z.""" + h, k, l = direction + direction_cart = self.box_matrix.T @ np.array([h, k, l], dtype=float) + direction_cart /= np.linalg.norm(direction_cart) + z_axis = np.array([0.0, 0.0, 1.0]) + dot = np.dot(direction_cart, z_axis) + if np.abs(dot - 1.0) < 1e-10: + rotation_matrix = np.eye(3) + elif np.abs(dot + 1.0) < 1e-10: + rotation_matrix = np.diag([1.0, -1.0, -1.0]) + else: + axis = np.cross(direction_cart, z_axis) + axis /= np.linalg.norm(axis) + angle = np.arccos(np.clip(dot, -1.0, 1.0)) + kx, ky, kz = axis + K = np.array([[0, -kz, ky], [kz, 0, -kx], [-ky, kx, 0]]) + rotation_matrix = np.eye(3) + np.sin(angle) * K + (1 - np.cos(angle)) * (K @ K) + + nt, na, _ = self.positions.shape + pos = (self.positions.reshape(-1, 3) @ rotation_matrix.T).reshape(nt, na, 3) + vel = (self.velocities.reshape(-1, 3) @ rotation_matrix.T).reshape(nt, na, 3) return Trajectory( atom_types=self.atom_types, - positions=positions, - velocities=np.ones(n_displacements)[:,None,None]*self.velocities[0, :, :], - box_matrix=self.box_matrix, - timestep=self.timestep + positions=pos, + velocities=vel, + box_matrix=rotation_matrix @ self.box_matrix, + timestep=self.timestep, ) - def plot(self, timestep=0, view='3d', alpha=0.6, size=20): - """ - Plot atomic positions. + def to_ase(self) -> Atoms: + return Atoms( + ''.join(self.atom_types), + positions=self.positions[0], + cell=np.diag(self.box_matrix), + pbc=True, + ) - Args: - timestep: Which frame to plot - view: '3d' for 3D scatter, 'xy', 'xz', or 'yz' for 2D projections - alpha: Transparency for overlapping atoms (0-1) - size: Marker size - """ + def plot(self, timestep: int = 0, view: str = '3d', + alpha: float = 0.6, size: int = 20) -> None: import matplotlib.pyplot as plt + COLORS = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b'] + unique_types = sorted(set(self.atom_types)) if view == '3d': fig = plt.figure(figsize=(10, 8)) ax = fig.add_subplot(projection='3d') - - # Use different colors and sizes for different atom types - colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b'] - unique_types = sorted(set(self.atom_types)) - - for at, c in zip(unique_types, colors): + for at, c in zip(unique_types, COLORS): mask = self.atom_types == at - xs = self.positions[timestep, mask, 0] - ys = self.positions[timestep, mask, 1] - zs = self.positions[timestep, mask, 2] - ax.scatter(xs, ys, zs, c=c, s=size, alpha=alpha, label=str(at), edgecolors='none') - - ax.set_xlabel('X (Å)') - ax.set_ylabel('Y (Å)') - ax.set_zlabel('Z (Å)') + ax.scatter(*self.positions[timestep, mask].T, + c=c, s=size, alpha=alpha, label=str(at), edgecolors='none') + ax.set_xlabel('X (Å)'); ax.set_ylabel('Y (Å)'); ax.set_zlabel('Z (Å)') ax.legend() - - # Draw box outline box = self.box_matrix corners = np.array([ - [0, 0, 0], [box[0,0], 0, 0], [box[0,0], box[1,1], 0], [0, box[1,1], 0], - [0, 0, box[2,2]], [box[0,0], 0, box[2,2]], [box[0,0], box[1,1], box[2,2]], [0, box[1,1], box[2,2]] + [0,0,0],[box[0,0],0,0],[box[0,0],box[1,1],0],[0,box[1,1],0], + [0,0,box[2,2]],[box[0,0],0,box[2,2]],[box[0,0],box[1,1],box[2,2]],[0,box[1,1],box[2,2]] ]) - edges = [(0,1), (1,2), (2,3), (3,0), (4,5), (5,6), (6,7), (7,4), (0,4), (1,5), (2,6), (3,7)] - for edge in edges: - pts = corners[list(edge)] - ax.plot3D(pts[:,0], pts[:,1], pts[:,2], 'k-', alpha=0.3, linewidth=1) + for i, j in [(0,1),(1,2),(2,3),(3,0),(4,5),(5,6),(6,7),(7,4),(0,4),(1,5),(2,6),(3,7)]: + ax.plot3D(*corners[[i,j]].T, 'k-', alpha=0.3, linewidth=1) else: + axis_map = {'xy': (0, 1, 'X (Å)', 'Y (Å)'), + 'xz': (0, 2, 'X (Å)', 'Z (Å)'), + 'yz': (1, 2, 'Y (Å)', 'Z (Å)')} + if view not in axis_map: + raise ValueError(f"view must be '3d', 'xy', 'xz', or 'yz', got {view!r}") + i1, i2, xl, yl = axis_map[view] fig, ax = plt.subplots(figsize=(8, 8)) - - # Select projection - if view == 'xy': - idx1, idx2 = 0, 1 - labels = ('X (Å)', 'Y (Å)') - elif view == 'xz': - idx1, idx2 = 0, 2 - labels = ('X (Å)', 'Z (Å)') - elif view == 'yz': - idx1, idx2 = 1, 2 - labels = ('Y (Å)', 'Z (Å)') - else: - raise ValueError(f"view must be '3d', 'xy', 'xz', or 'yz', got {view}") - - colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b'] - unique_types = sorted(set(self.atom_types)) - - for at, c in zip(unique_types, colors): + for at, c in zip(unique_types, COLORS): mask = self.atom_types == at - x = self.positions[timestep, mask, idx1] - y = self.positions[timestep, mask, idx2] - ax.scatter(x, y, c=c, s=size, alpha=alpha, label=str(at), edgecolors='none') - - ax.set_xlabel(labels[0]) - ax.set_ylabel(labels[1]) - ax.legend() - ax.set_aspect('equal') + ax.scatter(self.positions[timestep, mask, i1], + self.positions[timestep, mask, i2], + c=c, s=size, alpha=alpha, label=str(at), edgecolors='none') + ax.set_xlabel(xl); ax.set_ylabel(yl) + ax.legend(); ax.set_aspect('equal') plt.tight_layout() plt.show() - - - def rotate_to(self, direction: Tuple[int, int, int]) -> 'Trajectory': - """ - Rotate the structure so that a crystallographic direction aligns with the z-axis. - - Args: - direction: Miller indices [h, k, l] defining the direction to align with z - - Returns: - New Trajectory with rotated positions, velocities, and box_matrix - """ - h, k, l = direction - - # Convert Miller indices to real-space Cartesian direction using box_matrix - # The direction in reciprocal space becomes a real-space vector via box_matrix^T - miller_vec = np.array([h, k, l], dtype=float) - direction_cart = self.box_matrix.T @ miller_vec - - # Normalize the direction vector - direction_cart = direction_cart / np.linalg.norm(direction_cart) - - # Target direction is z-axis - z_axis = np.array([0.0, 0.0, 1.0]) - - # Calculate rotation axis and angle using Rodrigues' rotation formula - # The rotation axis is perpendicular to both vectors: k = v1 × v2 - # The rotation angle is: θ = arccos(v1 · v2) - # The rotation matrix is: R = I + sin(θ)*K + (1-cos(θ))*K² - # where K is the cross-product matrix of the rotation axis - - # If direction is already aligned (or anti-aligned) with z, handle specially - dot_product = np.dot(direction_cart, z_axis) - if np.abs(dot_product - 1.0) < 1e-10: - # Already aligned, return copy - return Trajectory( - atom_types=self.atom_types, - positions=self.positions.copy(), - velocities=self.velocities.copy(), - box_matrix=self.box_matrix.copy(), - timestep=self.timestep - ) - elif np.abs(dot_product + 1.0) < 1e-10: - # Anti-aligned, rotate 180° around any perpendicular axis (use x) - rotation_matrix = np.array([ - [1.0, 0.0, 0.0], - [0.0, -1.0, 0.0], - [0.0, 0.0, -1.0] - ]) - else: - # General case: use Rodrigues' formula - rotation_axis = np.cross(direction_cart, z_axis) - rotation_axis = rotation_axis / np.linalg.norm(rotation_axis) - - angle = np.arccos(np.clip(dot_product, -1.0, 1.0)) - - # Build the cross-product matrix K - kx, ky, kz = rotation_axis - K = np.array([ - [0.0, -kz, ky], - [kz, 0.0, -kx], - [-ky, kx, 0.0] - ]) - - # Rodrigues' rotation matrix: R = I + sin(θ)*K + (1-cos(θ))*K² - I = np.eye(3) - rotation_matrix = I + np.sin(angle) * K + (1.0 - np.cos(angle)) * (K @ K) - - # Apply rotation to positions and velocities - n_frames, n_atoms, _ = self.positions.shape - positions_flat = self.positions.reshape(-1, 3) - velocities_flat = self.velocities.reshape(-1, 3) - - rotated_positions_flat = positions_flat @ rotation_matrix.T - rotated_velocities_flat = velocities_flat @ rotation_matrix.T - - rotated_positions = rotated_positions_flat.reshape(n_frames, n_atoms, 3) - rotated_velocities = rotated_velocities_flat.reshape(n_frames, n_atoms, 3) - - # Rotate the box_matrix as well - rotated_box_matrix = rotation_matrix @ self.box_matrix - - return Trajectory( - atom_types=self.atom_types, - positions=rotated_positions, - velocities=rotated_velocities, - box_matrix=rotated_box_matrix, - timestep=self.timestep - ) - - # returns an ase object - def to_ase(self): - return Atoms(''.join(self.atom_types), positions=self.positions[0], cell=np.diag(self.box_matrix),pbc=True) - diff --git a/src/pyslice/postprocessing/haadf_data.py b/src/pyslice/postprocessing/haadf_data.py index 57aadac..f7335ff 100644 --- a/src/pyslice/postprocessing/haadf_data.py +++ b/src/pyslice/postprocessing/haadf_data.py @@ -7,9 +7,7 @@ import logging from .wf_data import WFData from ..data.pyslice_serial import PySliceSerial, Signal, Dimensions, Dimension, Metadata -#from ..data import Signal, Dimensions, Dimension, GeneralMetadata -import pyslice.backend as backend -#from ..data.pyslice_serial import PySliceSerial +from pyslice.backend import Backend, to_cpu, to_numpy logger = logging.getLogger(__name__) @@ -45,6 +43,7 @@ def __init__(self, wf_data: WFData) -> None: wf_data: WFData object containing wavefunction data """ # Copy needed attributes from WFData (raw tensors for GPU ops) + self._backend = wf_data._backend self.probe_positions = wf_data.probe_positions self._kxs = wf_data._kxs self._kys = wf_data._kys @@ -87,9 +86,7 @@ def data(self): """Lazy conversion to numpy for Signal compatibility.""" if self._array is None: return None - if hasattr(self._array, 'cpu'): - return self._array.cpu().numpy() - return np.asarray(self._array) + return to_numpy(self._array) @data.setter def data(self, value): @@ -116,18 +113,17 @@ def __getattr__(self, name): raw = object.__getattribute__(self, f'_{name}') if raw is None: return None - if hasattr(raw, 'cpu'): - return raw.cpu().numpy() - return np.asarray(raw) + return to_numpy(raw) raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'") def getMask(self, inner_mrad: float = 45, outer_mrad: float = 150): - q = backend.sqrt(self._kxs[:,None]**2 + self._kys[None,:]**2) + b = self._backend + q = b.sqrt(self._kxs[:,None]**2 + self._kys[None,:]**2) radius_inner = (inner_mrad * 1e-3) / self.probe.wavelength radius_outer = (outer_mrad * 1e-3) / self.probe.wavelength - mask = zeros(q.shape, type_match = self._wf_array) - if isinstance(self._wf_array,np.memmap): + mask = b.zeros(q.shape, type_match=self._wf_array) + if isinstance(self._wf_array, np.memmap): q = to_cpu(q) mask[q >= radius_inner] = 1 mask[q >= radius_outer] = 0 @@ -148,61 +144,25 @@ def calculateADF(self, inner_mrad: float = 45, outer_mrad: float = 150, preview: # Use float_dtype to ensure MPS compatibility (float32 on MPS, float64 otherwise) #self._xs = xp.asarray(sorted(list(set(self.probe_positions[:,0]))), dtype=float_dtype) #self._ys = xp.asarray(sorted(list(set(self.probe_positions[:,1]))), dtype=float_dtype) - self._array = zeros((len(self._xs), len(self._ys)), type_match = self._wf_array) + b = self._backend + self._array = b.zeros((len(self._xs), len(self._ys)), type_match=self._wf_array) mask = self.getMask(inner_mrad, outer_mrad) - #q = xp.sqrt(self._kxs[:,None]**2 + self._kys[None,:]**2) - #radius_inner = (inner_mrad * 1e-3) / self.probe.wavelength - #radius_outer = (outer_mrad * 1e-3) / self.probe.wavelength - - #mask = zeros(q.shape, type_match = self._wf_array) - #if isinstance(self._wf_array,np.memmap): - # q = to_cpu(q) - #mask[q >= radius_inner] = 1 - #mask[q >= radius_outer] = 0 - - probe_positions = backend.asarray(self.probe_positions, dtype=float_dtype) - - #for i, x in enumerate(self._xs): - # for j, y in enumerate(self._ys): - # dxy = xp.sqrt(xp.sum((probe_positions - xp.asarray([x, y], dtype=float_dtype)[None, :]) ** 2, axis=1)) - # p = xp.argmin(dxy) # TODO inferring point from grid is still quite goofy. maybe we should track a grid of indices (if we're going to leave p as a single index in the final t,p,kx,ky,l datacube) - # exits = self._wf_array[p, :, :, :, -1] # which probe position, all frames, kx, ky, last layer - # - # if preview and i == 0 and j == 0: - # import matplotlib.pyplot as plt - # fig, ax = plt.subplots() - # preview_data = xp.mean(xp.absolute(exits), axis=0) ** .1 * (1 - mask) - # if TORCH_AVAILABLE: - # preview_data = preview_data.cpu().numpy() - # ax.imshow(preview_data, cmap="inferno") - # plt.show() - # - # collected = xp.mean(xp.sum(xp.absolute(exits * mask[None, :, :]), axis=(1, 2))) - # self._array[i, j] = collected - # recall self._wf_array is reshaped: p,t,kx,ky,l --> c,x,y,t,kx,ky,l if preview: import matplotlib.pyplot as plt fig, ax = plt.subplots() - preview_data = backend.array_mean(backend.absolute(self._wf_array),axis=(0,1,2,3,6))**.2 * (1 - mask) - ax.imshow(backend.to_numpy(backend.absolute(preview_data)), cmap="inferno") + preview_data = b.mean(b.absolute(self._wf_array), axis=(0,1,2,3,6))**.2 * (1 - mask) + ax.imshow(to_numpy(b.absolute(preview_data)), cmap="inferno") plt.show() - #collected = self._wf_array * mask[None,None,None,:,:,None] # c,x,y,t,kx,ky,l indices, mask is kx,ky - #self._array = xp.mean(xp.sum(xp.absolute(collected),axis=(4,5)),axis=(0,3,4)) # sum over kx,ky, mean over c,t,l - #for i in range(len(self._xs)): # looping doesn't blow up ram when we absolute it - # for j in range(len(self._ys)): - # collected = self._wf_array[:,i,j,:,:,:,:] * mask[None,None,:,:,None] # c,[x],[y],t,kx,ky,l indices, mask is kx,ky - # self._array[i,j] = mean(sum(absolute(collected)**2,axis=(2,3)),axis=(0,1,2)) # sum |ψ|² over kx,ky, mean over c,t,l - # TODO this should be einsum, but i'm not trying to test it right now... nc,_,_,nt,_,_,nl = self._wf_array.shape - wf_intensity = backend.absolute(self._wf_array)**2 ; mask = backend.absolute(mask) - self._array = backend.einsum('cxytkql,kq->xy',wf_intensity,mask)/(nc*nt*nl) + wf_intensity = b.absolute(self._wf_array)**2 ; mask = b.absolute(mask) + self._array = b.einsum('cxytkql,kq->xy', wf_intensity, mask) / (nc*nt*nl) - xs_np = backend.to_numpy(self._xs) - ys_np = backend.to_numpy(self._ys) + xs_np = to_numpy(self._xs) + ys_np = to_numpy(self._ys) if Dimensions is not None: self._local_dimensions = Dimensions([ @@ -237,7 +197,7 @@ def plot(self, filename=None, title=None): dx = (xs[-1] - xs[0]) / (len(xs) - 1) if len(xs) > 1 else 0 dy = (ys[-1] - ys[0]) / (len(ys) - 1) if len(ys) > 1 else 0 extent = (np.amin(xs) - dx/2, np.amax(xs) + dx/2, np.amin(ys) - dy/2, np.amax(ys) + dy/2) - ax.imshow(absolute(array), cmap="inferno", extent=extent) + ax.imshow(np.absolute(array), cmap="inferno", extent=extent) ax.set_xlabel("x ($\\AA$)") ax.set_ylabel("y ($\\AA$)") diff --git a/src/pyslice/postprocessing/tacaw_data.py b/src/pyslice/postprocessing/tacaw_data.py index cbc711e..f0a0904 100644 --- a/src/pyslice/postprocessing/tacaw_data.py +++ b/src/pyslice/postprocessing/tacaw_data.py @@ -1,145 +1,113 @@ """ Core data structure for TACAW EELS calculations. """ +from __future__ import annotations + +import logging +import os +from pathlib import Path +from typing import List, Optional, Union + import numpy as np -from typing import Optional, Tuple, Dict, Any, List, Union -import logging, os +from tqdm import tqdm + from .wf_data import WFData from ..data.pyslice_serial import PySliceSerial, Signal, Dimensions, Dimension, Metadata -import pyslice.backend as backend -#from ..data import Signal, Dimensions, Dimension, GeneralMetadata -#from ..data.pyslice_serial import PySliceSerial -from tqdm import tqdm +from pyslice.backend import Backend, to_numpy, to_cpu logger = logging.getLogger(__name__) class TACAWData(PySliceSerial, Signal): """ - Data structure for storing TACAW EELS results with format: probe_positions, frequency, kx, ky. - - Inherits from Signal for sea-eco compatibility. - - Attributes: - probe_positions: List of (x,y) probe positions in Angstroms. - frequencies: Frequencies in THz. - kxs: kx sampling vectors (e.g., in Å⁻¹). - kys: ky sampling vectors (e.g., in Å⁻¹). - xs: x real-space coordinates. - ys: y real-space coordinates. - intensity: Intensity array |Ψ(ω,q)|² (probe_positions, frequency, kx, ky). - probe: Probe object with beam parameters. - cache_dir: Path to cache directory. + TACAW EELS results: (probe_positions, frequency, kx, ky). + + Converts a WFData wavefunction (time-domain) to spectral intensity + |Ψ(ω,q)|² via FFT along the time axis. """ _sea_config = { - 'tensor_attrs': ['_kxs', '_kys', '_xs', '_ys', '_time', '_layer', '_frequencies', '_array', 'data'], + 'tensor_attrs': ['_kxs', '_kys', '_xs', '_ys', '_time', '_layer', + '_frequencies', '_array', 'data'], 'path_attrs': ['cache_dir'], 'tuple_list_attrs': ['probe_positions'], - 'exclude_attrs': ['probe', '_wf_array'], - 'force_datasets': ['_array', 'probe_positions', '_kxs', '_kys', '_xs', '_ys', '_time', '_layer', '_frequencies'], + 'exclude_attrs': ['probe', '_wf_array', '_backend'], + 'force_datasets': ['_array', 'probe_positions', '_kxs', '_kys', + '_xs', '_ys', '_time', '_layer', '_frequencies'], } - def __init__(self, - wf_data: WFData, - layer_index: int = None, - keep_complex: bool = False, + def __init__(self, + wf_data: WFData, + layer_index: Optional[int] = None, + keep_complex: bool = False, chunkFFT: bool = False, - chunk_size_time: int = None) -> None: - """ - Initialize TACAWData from WFData by performing FFT. - - Args: - wf_data: WFData object containing wavefunction data - layer_index: Index of the layer to compute FFT for (default: last layer) - keep_complex: If True, keep complex FFT result instead of intensity - """ - # Copy needed attributes from WFData (raw tensors for GPU ops) + chunk_size_time: Optional[int] = None) -> None: + + self._backend = wf_data._backend + b = self._backend + + # Copy coordinate metadata from WFData self.probe_positions = wf_data.probe_positions - self._time = wf_data._time - self._kxs = wf_data._kxs - self._kys = wf_data._kys - self._xs = wf_data._xs - self._ys = wf_data._ys + self._time = wf_data._time + self._kxs = wf_data._kxs + self._kys = wf_data._kys + self._xs = wf_data._xs + self._ys = wf_data._ys self._layer = wf_data._layer - self.probe = wf_data.probe - self.cache_dir = wf_data.cache_dir - self.keep_complex = keep_complex - self.chunkFFT = chunkFFT - self.use_memmap = isinstance(wf_data._array,np.memmap) + self.probe = wf_data.probe + self.cache_dir = wf_data.cache_dir + self.keep_complex = keep_complex + self.chunkFFT = chunkFFT + self.use_memmap = isinstance(wf_data._array, np.memmap) self.chunk_size_time = chunk_size_time - # Store reference to source WFData array for FFT computation - self._wf_array = wf_data._array - #print("tacaw > wfdata",wf_data._array.shape) - - # Initialize intensity as None, will be set by fft_from_wf_data - self._array = None + self._wf_array = wf_data._array + self._array = None self._frequencies = None - # Perform FFT to compute intensity self._fft_from_wf_data(layer_index) - # Save computed values before super().__init__ - computed_array = self._array - computed_frequencies = backend.to_cpu(self._frequencies) if hasattr(self._frequencies, 'cpu') else self._frequencies - - # Build Dimensions for Signal - freq_arr = backend.to_numpy(self._frequencies) - kxs_arr = backend.to_numpy(self._kxs) - kys_arr = backend.to_numpy(self._kys) - if Dimensions is not None: - self.dimensions = Dimensions([ - Dimension(name='probe', space='position', - values=np.arange(len(self.probe_positions))), + Dimension(name='probe', space='position', + values=np.arange(len(self.probe_positions))), Dimension(name='frequency', space='spectral', units='THz', - values=freq_arr), - Dimension(name='kx', space='scattering', units='Å⁻¹', - values=kxs_arr), - Dimension(name='ky', space='scattering', units='Å⁻¹', - values=kys_arr), + values=to_numpy(self._frequencies)), + Dimension(name='kx', space='scattering', units='Å⁻¹', + values=to_numpy(self._kxs)), + Dimension(name='ky', space='scattering', units='Å⁻¹', + values=to_numpy(self._kys)), ], nav_dimensions=[0, 1], sig_dimensions=[2, 3]) - # Build metadata - metadata_dict = { - 'General': { - 'title': 'TACAW Intensity', - 'signal_type': 'TACAW' - }, + self.metadata = Metadata({ + 'General': {'title': 'TACAW Intensity', 'signal_type': 'TACAW'}, 'Simulation': { - 'voltage_eV': float(self.probe.eV), - 'wavelength_A': float(self.probe.wavelength), + 'voltage_eV': float(self.probe.eV), + 'wavelength_A': float(self.probe.wavelength), 'aperture_mrad': float(self.probe.mrad), 'probe_positions': [list(p) for p in self.probe_positions], - } - } - self.metadata = Metadata(metadata_dict) - self.sea_type="Signal" - - # Restore computed values AFTER super().__init__ - self._array = computed_array - self._frequencies = computed_frequencies - - def __getattr__(self, name): - """Auto-convert coordinate arrays from tensor to numpy on access.""" - coord_attrs = {'time', 'kxs', 'kys', 'xs', 'ys', 'layer', 'frequencies'} - if name in coord_attrs: - raw = object.__getattribute__(self, f'_{name}') - if raw is None: - return None - if hasattr(raw, 'cpu'): - return raw.cpu().numpy() - return np.asarray(raw) - raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'") + }, + }) + self.sea_type = "Signal" + + # ------------------------------------------------------------------ + # Properties + # ------------------------------------------------------------------ + + @property + def kxs(self) -> np.ndarray: return to_numpy(self._kxs) + @property + def kys(self) -> np.ndarray: return to_numpy(self._kys) + @property + def xs(self) -> np.ndarray: return to_numpy(self._xs) + @property + def ys(self) -> np.ndarray: return to_numpy(self._ys) + @property + def frequencies(self) -> np.ndarray: return to_numpy(self._frequencies) @property def data(self): - """Lazy conversion to numpy for Signal compatibility.""" - if self._array is None: - return None - return to_cpu(self._array) + return to_numpy(self._array) if self._array is not None else None @data.setter def data(self, value): @@ -147,7 +115,6 @@ def data(self, value): @property def intensity(self): - """Backward compatible alias for internal intensity array.""" return self._array @intensity.setter @@ -156,433 +123,257 @@ def intensity(self, value): @property def array(self): - """Alias for intensity (backward compatibility with WFData interface).""" - return to_cpu(self._array) - - def _fft_from_wf_data(self, layer_index: int = None): - """ - Perform FFT along the time axis for a specific layer to convert to TACAW data. - This implements the JACR method: Ψ(t,q,r) → |Ψ(ω,q,r)|² via FFT. - - Args: - layer_index: Index of the layer to compute FFT for (default: last layer) - """ - if os.path.exists(self.cache_dir / "tacaw.npy"): - self._array = np.load(self.cache_dir / "tacaw.npy") - # sanity check sizes on reload - _,nt,nx,ny,_ = self._wf_array.shape - _,nw,nx2,ny2 = self._array.shape - if nt==nw and nx==nx2 and ny==ny2: - self._frequencies = np.load(self.cache_dir / "tacaw_freq.npy") - if backend.TORCH_BACKEND: - self._frequencies = backend.asarray(self._frequencies) - self._array = backend.asarray(self._array) + return to_numpy(self._array) if self._array is not None else None + + # ------------------------------------------------------------------ + # FFT computation + # ------------------------------------------------------------------ + + def _fft_from_wf_data(self, layer_index: Optional[int] = None): + """FFT along the time axis to convert wavefunction to TACAW data.""" + b = self._backend + + cache_tacaw = self.cache_dir / "tacaw.npy" + cache_freq = self.cache_dir / "tacaw_freq.npy" + + if cache_tacaw.exists(): + cached = np.load(cache_tacaw) + _, nt, nx, ny, _ = self._wf_array.shape + _, nw, nx2, ny2 = cached.shape + if nt == nw and nx == nx2 and ny == ny2: + self._frequencies = b.asarray(np.load(cache_freq)) + self._array = b.asarray(cached) return - # Default to last layer if not specified if layer_index is None: layer_index = len(self._layer) - 1 + if not (0 <= layer_index < len(self._layer)): + raise ValueError( + f"layer_index {layer_index} out of range [0, {len(self._layer) - 1}]") - # Validate layer index - if layer_index < 0 or layer_index >= len(self._layer): - raise ValueError(f"layer_index {layer_index} out of range [0, {len(self._layer)-1}]") - - # Extract wavefunction data for the specified layer - # Shape: (probe_positions, time, kx, ky, layer) - wf_layer = self._wf_array[:, :, :, :, layer_index] + wf_layer = self._wf_array[:, :, :, :, layer_index] # p,t,kx,ky if self.chunk_size_time is None: self.n_chunks = 1 else: self.n_chunks = len(self._time) // self.chunk_size_time - - indices = backend.linspace(0, len(self._time), self.n_chunks + 1) - indices = backend.astype(indices, int) - dt = self._time[1] - self._time[0] - # Compute frequencies from time sampling - self._frequencies = backend.fftfreq(self.n_chunks, d=dt) - self._frequencies = backend.fftshift(self._frequencies) - - # Perform FFT along time axis (axis=1) for each probe position and k-point - # Following abeels.py approach: subtract mean to avoid high zero-frequency peak - # then Compute intensity |Ψ(ω,q)|² from the frequency-domain wavefunction - - if self.chunkFFT: # looping through x (in case super giganormous FFTs blow your ram) - dtype = backend.complex_dtype if self.keep_complex else backend.float_dtype - shape = (wf_layer.shape[0], self.chunk_size_time, wf_layer.shape[2], wf_layer.shape[3]) - if self.use_memmap: - self._array = backend.memmap(shape, dtype=dtype, filename = self.cache_dir / "tacaw.npy") - else: - self._array = backend.zeros(shape, dtype=dtype) - - for i in range(self.n_chunks): - i1 = indices[i] - i2 = indices[i+1] - for i in tqdm(range(len(self._kxs))): - wf_mean = backend.array_mean(wf_layer[:,slice(i1,i2),i,:], axis=1, keepdims=True) # p,t,x,y,[l] indices - wf_fft = backend.fft(wf_layer[:,slice(i1,i2),i,:] - wf_mean, axis=1) - wf_fft = backend.fftshift(wf_fft, axes=1) - - if not self.keep_complex: - wf_fft = backend.absolute(wf_fft)**2 - - self._array[:,:,i,:] += wf_fft + indices = b.astype(b.linspace(0, len(self._time), self.n_chunks + 1), int) + dt = float(to_numpy(self._time[1] - self._time[0])) + self._frequencies = b.fftshift(b.fftfreq(self.n_chunks, d=dt)) + if self.chunkFFT: + # Memory-conservative path: loop over kx + dtype = b.complex_dtype if self.keep_complex else b.float_dtype + shape = (wf_layer.shape[0], self.chunk_size_time, + wf_layer.shape[2], wf_layer.shape[3]) + if self.use_memmap: + self._array = b.memmap(shape, dtype=dtype, + filename=self.cache_dir / "tacaw.npy") + else: + self._array = b.zeros(shape, dtype=dtype) + + for chunk_i in range(self.n_chunks): + i1, i2 = int(to_numpy(indices[chunk_i])), int(to_numpy(indices[chunk_i + 1])) + for kx_i in tqdm(range(len(self._kxs))): + sl = wf_layer[:, i1:i2, kx_i, :] + wf_mean = b.mean(sl, axis=1, keepdims=True) + wf_fft = b.fftshift(b.fft(sl - wf_mean, axes=1), axes=1) + if not self.keep_complex: + wf_fft = b.absolute(wf_fft) ** 2 + self._array[:, :, kx_i, :] += wf_fft else: - self._array = None - - for i in range(self.n_chunks): - i1 = indices[i] - i2 = indices[i+1] - - wf_mean = backend.array_mean(wf_layer[:,slice(i1,i2),:,:], axis=1, keepdims=True) - wf_fft = backend.fft(wf_layer[:,slice(i1,i2),:,:] - wf_mean, axis=1) - wf_fft = backend.fftshift(wf_fft, axes=1) - + # Standard path: FFT over full time window + for chunk_i in range(self.n_chunks): + i1, i2 = int(to_numpy(indices[chunk_i])), int(to_numpy(indices[chunk_i + 1])) + sl = wf_layer[:, i1:i2, :, :] + wf_mean = b.mean(sl, axis=1, keepdims=True) + wf_fft = b.fftshift(b.fft(sl - wf_mean, axes=1), axes=1) if not self.keep_complex: - wf_fft = backend.absolute(wf_fft)**2 - - if self._array is None: - self._array = wf_fft - else: - self._array += wf_fft - - # Ensure cache directory exists (may have been cleaned up by calculator) + wf_fft = b.absolute(wf_fft) ** 2 + self._array = wf_fft if self._array is None else self._array + wf_fft + + # Persist to cache self.cache_dir.mkdir(parents=True, exist_ok=True) - np.save(self.cache_dir / "tacaw_freq.npy", self._frequencies) + np.save(cache_freq, to_numpy(self._frequencies)) if not self.use_memmap: - np.save(self.cache_dir / "tacaw.npy", backend.to_cpu(self._array) ) - + np.save(cache_tacaw, to_numpy(self._array)) - # Keep fft_from_wf_data as public alias for backward compatibility - def fft_from_wf_data(self, layer_index: int = None): - """Public alias for _fft_from_wf_data (backward compatibility).""" + def fft_from_wf_data(self, layer_index: Optional[int] = None): + """Public alias for backward compatibility.""" self._fft_from_wf_data(layer_index) - def spectrum(self, probe_index: int = None) -> np.ndarray: - """ - Extract spectrum for a specific probe position by summing over all k-space. - - Args: - probe_index: Index of probe position (default: 0). If None, averages over all probes. - - Returns: - Spectrum array (frequency intensity) - """ + # ------------------------------------------------------------------ + # Analysis methods + # ------------------------------------------------------------------ + def spectrum(self, probe_index: Optional[int] = None) -> np.ndarray: + """Spectrum for one probe (or mean over all) by summing over k-space.""" + b = self._backend if probe_index is None: - # Average over all probe positions - all_spectra = [] - for i in range(len(self.probe_positions)): - probe_intensity = self._array[i] # Shape: (frequency, kx, ky) - spectrum = backend.array_sum(probe_intensity, axis=(1, 2)) # Sum over kx, ky - all_spectra.append(spectrum) - - # Average all spectra - if hasattr(all_spectra[0], 'device'): - all_spectra = [backend.to_cpu(s) for s in all_spectra] - spectrum = backend.array_mean(backend.asarray(all_spectra), axis=0) - else: - if probe_index >= len(self.probe_positions): - raise ValueError(f"Probe index {probe_index} out of range") - - # Sum intensity data over all k-space for this probe position - probe_intensity = self._array[probe_index] # Shape: (frequency, kx, ky) - spectrum = backend.array_sum(probe_intensity, axis=(1, 2)) # Sum over kx, ky - - # Convert to numpy if PyTorch tensor - if hasattr(spectrum, 'device'): - spectrum = backend.to_cpu(spectrum) - - return spectrum - - def spectrum_image(self, frequency: float, probe_indices: Optional[List[int]] = None) -> np.ndarray: - """ - Extract spectrum image at a specific frequency showing intensity in real space (probe positions). - - Args: - frequency: Frequency value in THz - probe_indices: List of probe indices to include (default: all probes) - - Returns: - Spectrum intensity for each probe position (real space map) - """ - # Find closest frequency index - freq_idx = np.argmin(np.abs(self.frequencies - frequency)) - - # Use all probes if none specified + spectra = [to_numpy(b.sum(self._array[i], axis=(1, 2))) + for i in range(len(self.probe_positions))] + return np.mean(spectra, axis=0) + if probe_index >= len(self.probe_positions): + raise ValueError(f"Probe index {probe_index} out of range") + return to_numpy(b.sum(self._array[probe_index], axis=(1, 2))) + + def spectrum_image(self, frequency: float, + probe_indices: Optional[List[int]] = None) -> np.ndarray: + """Intensity at a given frequency for each probe position (real-space map).""" + b = self._backend + freq_idx = int(np.argmin(np.abs(self.frequencies - frequency))) if probe_indices is None: probe_indices = list(range(len(self.probe_positions))) + return to_numpy([b.sum(self._array[p, freq_idx, :, :]) + for p in probe_indices]) - # Extract intensity at this frequency for each selected probe position - spectrum_intensities = [] - for probe_idx in probe_indices: - # Sum intensity data over all k-space for this probe at this frequency - probe_intensity = self._array[probe_idx, freq_idx, :, :] - probe_intensity_sum = backend.array_sum(probe_intensity) - - spectrum_intensities.append(probe_intensity_sum) - - return backend.to_numpy(spectrum_intensities) - - def diffraction(self, probe_index: int = None, space: str = "reciprocal") -> np.ndarray: - """ - Extract diffraction pattern for a specific probe position by summing over all frequencies. - - Args: - probe_index: Index of probe position (default: 0). If None, averages over all probes. - - Returns: - Diffraction pattern (kx, ky) - intensity summed over all frequencies - """ + def diffraction(self, probe_index: Optional[int] = None, + space: str = "reciprocal") -> np.ndarray: + """Diffraction pattern (kx, ky) summed over all frequencies.""" + b = self._backend if probe_index is None: - # Average over all probe positions - all_diffractions = [] - for i in range(len(self.probe_positions)): - probe_intensity = self._array[i] # Shape: (frequency, kx, ky) - diffraction_pattern = backend.array_sum(probe_intensity, axis=0) # Sum over frequencies - all_diffractions.append(diffraction_pattern) - - # Average all diffraction patterns - if hasattr(all_diffractions[0], 'device'): - all_diffractions = [backend.to_cpu(d) for d in all_diffractions] - diffraction_pattern = backend.array_mean(backend.asarray(all_diffractions), axis=0) + patterns = [to_numpy(b.sum(self._array[i], axis=0)) + for i in range(len(self.probe_positions))] + pattern = np.mean(patterns, axis=0) else: if probe_index >= len(self.probe_positions): raise ValueError(f"Probe index {probe_index} out of range") - - # Sum intensity data over all frequencies for this probe position - probe_intensity = self._array[probe_index] # Shape: (frequency, kx, ky) - diffraction_pattern = backend.array_sum(probe_intensity, axis=0) # Sum over frequencies - - # Convert to numpy if PyTorch tensor - if hasattr(diffraction_pattern, 'device'): - diffraction_pattern = backend.to_cpu(diffraction_pattern) + pattern = to_numpy(b.sum(self._array[probe_index], axis=0)) if space == "real": - diffraction_pattern = backend.absolute(backend.ifft2(diffraction_pattern)) - - return diffraction_pattern + pattern = to_numpy(b.absolute(b.ifft2(b.asarray(pattern)))) + return pattern - def spectral_diffraction(self, frequency: float, probe_index: int = None, space: str = "reciprocal") -> np.ndarray: - """ - Extract spectral diffraction pattern at a specific frequency. - - Args: - frequency: Frequency value in THz - probe_index: Index of probe position (default: None). If None, averages over all probes. - - Returns: - Spectral diffraction pattern (kx, ky) at the specified frequency - """ - # Find closest frequency index - freq_idx = np.argmin(np.abs(self.frequencies - frequency)) + def spectral_diffraction(self, frequency: float, + probe_index: Optional[int] = None, + space: str = "reciprocal") -> np.ndarray: + """Diffraction pattern at a specific frequency.""" + b = self._backend + freq_idx = int(np.argmin(np.abs(self.frequencies - frequency))) if probe_index is None: - # Average over all probe positions - all_spectral_diffractions = [] - for i in range(len(self.probe_positions)): - spectral_diffraction = self._array[i, freq_idx, :, :] - all_spectral_diffractions.append(spectral_diffraction) - - # Average all spectral diffraction patterns - if hasattr(all_spectral_diffractions[0], 'device'): - all_spectral_diffractions = [to_cpu(sd) for sd in all_spectral_diffractions] - spectral_diffraction = backend.array_mean(backend.asarray(all_spectral_diffractions), axis=0) + slices = [self._array[i, freq_idx, :, :] + for i in range(len(self.probe_positions))] + pattern = to_numpy(b.mean(b.stack([b.asarray(s) for s in slices]), axis=0)) else: if probe_index >= len(self.probe_positions): raise ValueError(f"Probe index {probe_index} out of range") - - # Extract intensity data at this frequency and probe position - spectral_diffraction = self._array[probe_index, freq_idx, :, :] - - # Convert to numpy if PyTorch tensor - if hasattr(spectral_diffraction, 'device'): - spectral_diffraction = backend.to_cpu(spectral_diffraction) + pattern = to_numpy(self._array[probe_index, freq_idx, :, :]) if space == "real": - spectral_diffraction = backend.absolute(backend.ifft2(spectral_diffraction)) - - return spectral_diffraction + pattern = to_numpy(b.absolute(b.ifft2(b.asarray(pattern)))) + return pattern - def masked_spectrum(self, mask: np.ndarray|dict|None = None, probe_index: int = None, preview=False) -> np.ndarray: - """ - Extract spectrum with spatial masking in k-space. - - Args: - mask: Spatial mask array with shape (kx, ky) - probe_index: Index of probe position (default: None). If None, averages over all probes. - - Returns: - Masked spectrum (frequency intensity) with k-space mask applied - """ - kxs = backend.to_cpu(self.kxs) - kys = backend.to_cpu(self.kys) + def masked_spectrum(self, mask=None, probe_index: Optional[int] = None, + preview: bool = False) -> np.ndarray: + """Spectrum with k-space masking applied.""" + b = self._backend + kxs_np = to_numpy(self._kxs) + kys_np = to_numpy(self._kys) if mask is None: - mask = np.zeros((len(kxs),len(kys)))+1 - elif isinstance(mask,dict): - cx,cy=mask.get("center",(0,0)) + mask = np.ones((len(kxs_np), len(kys_np))) + elif isinstance(mask, dict): + cx, cy = mask.get("center", (0, 0)) if mask["shape"] == "round": - r=mask["radius"] - radii = np.sqrt((kxs[:,None]-cx)**2+(kys[None,:]-cy)**2) - mask = np.zeros((len(kxs),len(kys))) - mask[radii<=r]=1 - - elif mask.shape != (len(kxs), len(kys)): - raise ValueError(f"Mask shape {mask.shape} doesn't match k-space shape ({len(kxs)}, {len(kys)})") - - if probe_index is None: - probe_index = np.arange(len(self.probe_positions)) - elif isinstance(probe_index,int): - probe_index=[probe_index] + r = mask["radius"] + radii = np.sqrt((kxs_np[:, None] - cx) ** 2 + (kys_np[None, :] - cy) ** 2) + mask = (radii <= r).astype(float) + elif mask.shape != (len(kxs_np), len(kys_np)): + raise ValueError(f"Mask shape {mask.shape} doesn't match " + f"k-space shape ({len(kxs_np)}, {len(kys_np)})") + + probe_indices = (np.arange(len(self.probe_positions)) + if probe_index is None else [probe_index]) spectra = [] - for i in probe_index: - masked = self._array[i] * mask[None,:,:] + for i in probe_indices: + masked = self._array[i] * mask[None, :, :] if preview: import matplotlib.pyplot as plt + extent = (kxs_np.min(), kxs_np.max(), kys_np.min(), kys_np.max()) fig, ax = plt.subplots() - extent = ( np.amin(kxs) , np.amax(kxs) , np.amin(kys) , np.amax(kys) ) - ax.imshow(backend.to_cpu(backend.array_sum(masked, axis=0)).T[::-1,:], cmap="inferno",extent=extent,aspect=1) - ax.set_xlabel("kx") - ax.set_ylabel("ky") + ax.imshow(to_numpy(b.sum(masked, axis=0)).T[::-1, :], + cmap="inferno", extent=extent, aspect=1) + ax.set_xlabel("kx"); ax.set_ylabel("ky") ax.set_title("masked_spectrum - preview") plt.show() - preview=False - spectra.append(backend.to_cpu(backend.array_sum(masked, axis=(1,2)))) - return backend.to_numpy(backend.array_mean(spectra,axis=0)) - - def dispersion(self, kx_path: np.ndarray, ky_path: np.ndarray, probe_index: int = None, space: str = "reciprocal") -> np.ndarray: - """ - Extract dispersion relation from actual TACAW intensity data. + plt.close(fig) + preview = False + spectra.append(to_numpy(b.sum(masked, axis=(1, 2)))) + return np.mean(spectra, axis=0) + + def dispersion(self, kx_path: np.ndarray, ky_path: np.ndarray, + probe_index: Optional[int] = None, + space: str = "reciprocal") -> np.ndarray: + """Extract dispersion relation along a k-path.""" + b = self._backend + kx_np = to_numpy(self._kxs) if space != "real" else to_numpy(self._xs) + ky_np = to_numpy(self._kys) if space != "real" else to_numpy(self._ys) + + kx_indices = np.array([np.argmin(np.abs(kx_np - v)) for v in kx_path]) + ky_indices = np.array([np.argmin(np.abs(ky_np - v)) for v in ky_path]) + + probe_indices = (np.arange(len(self.probe_positions)) + if probe_index is None else [probe_index]) + n_freq = len(self.frequencies) + dispersion = np.zeros((n_freq, len(kx_indices)), dtype=complex) + + for w in range(n_freq): + w_slice = self._array[probe_indices, w, :, :] + if space == "real": + w_slice = b.ifft2(w_slice, axes=(1, 2)) + w_np = np.mean(to_numpy(w_slice), axis=0) + for i, (ki, kj) in enumerate(zip(kx_indices, ky_indices)): + dispersion[w, i] = w_np[ki, kj] - Args: - kx_path: kx values for dispersion calculation - ky_path: ky values for dispersion calculation - probe_index: Index of probe position (default: None). If None, averages over all probes. + return np.abs(dispersion) - Returns: - Dispersion relation array with shape (n_frequencies, n_k_points) - Real intensity data from TACAW simulation - """ + # ------------------------------------------------------------------ + # Generic heatmap plot + # ------------------------------------------------------------------ - kx=self.kxs ; ky=self.kys - if space == "real": - kx=self.xs ; ky=self.ys - - # Convert to CPU/numpy for indexing operations - kx = backend.to_cpu(kx) - ky = backend.to_cpu(ky) - - # Find closest indices in our kxs/kys arrays for the requested paths - kx_indices = [] - for kx_val in kx_path: - idx = np.argmin(np.abs(kx - kx_val)) - kx_indices.append(idx) - kx_indices = np.array(kx_indices) - - ky_indices = [] - for ky_val in ky_path: - idx = np.argmin(np.abs(ky - ky_val)) - ky_indices.append(idx) - ky_indices = np.array(ky_indices) - - # Create dispersion array - n_frequencies = len(self.frequencies) - n_k_points = len(kx_indices) - dispersion = np.zeros((n_frequencies, n_k_points),dtype=complex) + def plot(self, intensities, xvals, yvals, + xlabel="kx (Å⁻¹)", ylabel="ky (Å⁻¹)", + filename=None, title=None, extent=None): + import matplotlib.pyplot as plt - if probe_index is None: - probe_index = np.arange(len(self.probe_positions)) + _AXIS_MAP = { + "kx": ("kx (Å⁻¹)", lambda s: to_numpy(s._kxs)), + "k": ("kx (Å⁻¹)", lambda s: to_numpy(s._kxs)), + "ky": ("ky (Å⁻¹)", lambda s: to_numpy(s._kys)), + "x": ("x (Å)", lambda s: to_numpy(s._xs)), + "y": ("y (Å)", lambda s: to_numpy(s._ys)), + "omega": ("frequency (THz)", lambda s: s.frequencies), + } - # loop frequencies first so we can cheaply iFFT kx,ky if we need to - for w in range(n_frequencies): - # all specified probe positions, this frequency, all kx,ky - w_slice = self._array[probe_index, w, :, :] - # optionally iFFT across kx,ky - if space == "real": - w_slice = backend.ifft2(w_slice, axes=(1,2)) - # bring to CPU - if hasattr(w_slice, 'device'): - w_slice = backend.to_cpu(w_slice) - # sum across probe positions - w_slice = backend.array_mean(w_slice,axis=0) - # select values at positions - for i, (kx_idx, ky_idx) in enumerate(zip(kx_indices, ky_indices)): - dispersion[w,i] = w_slice[ kx_idx, ky_idx ] - - # Do we want to return NumPy or keep as tensor? For now, always return numpy since this is postprocessing and likely small arrays - return backend.to_numpy(backend.absolute(dispersion)) - - - # Since there are multiple things returnable by the above functions, i'm just offering up a generic heatmap plotter function here, where you pass Z,x,y - def plot(self,intensities,xvals,yvals,xlabel="kx ($\\AA^{-1}$)",ylabel="ky ($\\AA^{-1}$)",filename=None,title=None,extent=None): - import matplotlib.pyplot as plt - fig, ax = plt.subplots() - array = backend.absolute(to_numpy(intensities)) # imshow convention: y,x. our convention: x,y - aspect = None - - if isinstance(xvals,str): - if xvals in ["kx","k"]: - xlabel = "kx ($\\AA^{-1}$)" ; xvals = backend.to_numpy(self.kxs) - elif xvals == "ky": - xlabel = "ky ($\\AA^{-1}$)" ; xvals = backend.to_numpy(self.kys) - elif xvals == "x": - xlabel = "x ($\\AA$)" ; xvals = backend.to_numpy(self.xs) - elif xvals == "y": - xlabel = "y ($\\AA$)" ; xvals = backend.to_numpy(self.ys) - - if isinstance(yvals,str): - if yvals == "omega": - aspect = "auto" - if yvals == "kx": - ylabel = "kx ($\\AA^{-1}$)" ; yvals = backend.to_numpy(self.kxs) - elif yvals in ["ky","k"]: - ylabel = "ky ($\\AA^{-1}$)" ; yvals = backend.to_numpy(self.kys) - elif yvals == "x": - ylabel = "x ($\\AA$)" ; yvals = backend.to_numpy(self.xs) - elif yvals == "y": - ylabel = "y ($\\AA$)" ; yvals = backend.to_numpy(self.ys) - elif yvals == "omega": - ylabel = "frequency (THz)" ; yvals = backend.to_numpy(self.frequencies) + if isinstance(xvals, str) and xvals in _AXIS_MAP: + xlabel, xvals = _AXIS_MAP[xvals][0], _AXIS_MAP[xvals][1](self) + if isinstance(yvals, str) and yvals in _AXIS_MAP: + ylabel, yvals = _AXIS_MAP[yvals][0], _AXIS_MAP[yvals][1](self) if extent is None: - extent = ( np.amin(xvals) , np.amax(xvals) , np.amin(yvals) , np.amax(yvals) ) - ax.imshow(array, cmap="inferno",extent=extent,aspect=aspect) - ax.set_xlabel(xlabel) - ax.set_ylabel(ylabel) - if title is not None: - ax.set_title(title) + extent = (np.amin(xvals), np.amax(xvals), np.amin(yvals), np.amax(yvals)) + aspect = "auto" if ylabel == "frequency (THz)" else None - if filename is not None: + fig, ax = plt.subplots() + ax.imshow(to_numpy(np.abs(intensities)), cmap="inferno", + extent=extent, aspect=aspect) + ax.set_xlabel(xlabel); ax.set_ylabel(ylabel) + if title: + ax.set_title(title) + if filename: plt.savefig(filename) else: plt.show() + plt.close(fig) class SEDData(TACAWData): """ - Data structure for SED (Spectral Energy Density) calculations. - - Functionally identical to TACAWData - both compute |Ψ(ω,q)|² from time-domain wavefunction data - via FFT along the time axis. - - Attributes: - probe_positions: List of (x,y) probe positions in Angstroms. - frequencies: Frequencies in THz. - kxs: kx sampling vectors (e.g., in Å⁻¹). - kys: ky sampling vectors (e.g., in Å⁻¹). - intensity: Intensity array |Ψ(ω,q)|² (probe_positions, frequency, kx, ky). + SED (Spectral Energy Density) results. + Functionally identical to TACAWData — both compute |Ψ(ω,q)|² via time-axis FFT. """ - - def __init__(self, wf_data: WFData, layer_index: int = None, keep_complex: bool = False) -> None: - """ - Initialize SEDData from WFData by performing FFT. - - Args: - wf_data: WFData object containing wavefunction data - layer_index: Index of the layer to compute FFT for (default: last layer) - keep_complex: If True, keep complex FFT result instead of intensity - """ + def __init__(self, wf_data: WFData, layer_index: Optional[int] = None, + keep_complex: bool = False) -> None: super().__init__(wf_data, layer_index, keep_complex) diff --git a/src/pyslice/postprocessing/testtools.py b/src/pyslice/postprocessing/testtools.py deleted file mode 100644 index 1b1e0c0..0000000 --- a/src/pyslice/postprocessing/testtools.py +++ /dev/null @@ -1,16 +0,0 @@ -import os -import numpy as np -from pyslice.backend import to_cpu - -def differ(ary,filename,label): - # Convert GPU tensors to numpy - ary = to_cpu(ary) - if not os.path.exists(filename): - print("diff npy file does not exist. creating anew") - np.save(filename,ary) - else: - previous=np.load(filename) - F , D = np.absolute(ary) , np.absolute(previous) - dz=np.sum( (F-D)**2 ) / np.sum( F**2 ) # a scaling-resistant values-near-zero-resistance residual function - if dz>1e-6: - print("ERROR! "+label+" DOES NOT MATCH PREVIOUS RUN",dz*100,"%") diff --git a/src/pyslice/postprocessing/wf_data.py b/src/pyslice/postprocessing/wf_data.py index 166a277..d0f6481 100644 --- a/src/pyslice/postprocessing/wf_data.py +++ b/src/pyslice/postprocessing/wf_data.py @@ -1,39 +1,34 @@ """ Wave function data structure. """ +from __future__ import annotations + import numpy as np -from typing import List, Tuple, Optional +from pathlib import Path +from typing import List, Optional, Tuple + from ..multislice.multislice import Probe, aberrationFunction from ..data.pyslice_serial import PySliceSerial, Signal, Dimensions, Dimension, Metadata -from pathlib import Path -import pyslice.backend as backend +from pyslice.backend import Backend, to_numpy class WFData(PySliceSerial, Signal): """ - Data structure for wave function data with format: probe_positions, frame, kx, ky, layer. - - Inherits from Signal for sea-eco compatibility. - - Attributes: - probe_positions: List of (x,y) probe positions in Angstroms. - time: Time array (frame # * timestep) in picoseconds. - kxs: kx sampling vectors. - kys: ky sampling vectors. - xs: x real-space coordinates. - ys: y real-space coordinates. - layer: Layer indices for multi-layer calculations. - array: Complex wavefunction array with shape (probe_positions, time, kx, ky, layer). - probe: Probe object with beam parameters. - cache_dir: Path to cache directory. + Wavefunction data with format: (probe_positions, frame, kx, ky, layer). + + All GPU/CPU array operations are performed via the injected Backend instance. + Coordinate arrays are stored in their native backend type internally; the + public properties (kxs, kys, xs, ys, time, layer) always return NumPy arrays + for downstream compatibility. """ _sea_config = { 'tensor_attrs': ['_kxs', '_kys', '_xs', '_ys', '_time', '_layer', '_array'], 'path_attrs': ['cache_dir'], 'tuple_list_attrs': ['probe_positions'], - 'exclude_attrs': ['probe'], - 'force_datasets': ['_array', 'probe_positions', '_kxs', '_kys', '_xs', '_ys', '_time', '_layer'], + 'exclude_attrs': ['probe', '_backend'], + 'force_datasets': ['_array', 'probe_positions', '_kxs', '_kys', + '_xs', '_ys', '_time', '_layer'], } def __init__( @@ -42,84 +37,84 @@ def __init__( probe_xs: List[float], probe_ys: List[float], time: np.ndarray, - kxs: np.ndarray, - kys: np.ndarray, - xs: np.ndarray, - ys: np.ndarray, - layer: np.ndarray, - array: np.ndarray, + kxs, + kys, + xs, + ys, + layer, + array, probe: Probe, - cache_dir: Path, + backend: Backend, + cache_dir: Optional[Path] = None, ): - # Store raw attributes (may be tensors for GPU operations) + self._backend = backend + self.probe_positions = probe_positions self.probe_xs = probe_xs self.probe_ys = probe_ys - self._time = time - self._kxs = kxs - self._kys = kys - self._xs = xs - self._ys = ys + self._time = time + self._kxs = kxs + self._kys = kys + self._xs = xs + self._ys = ys self._layer = layer - self.probe = probe + self.probe = probe self.cache_dir = cache_dir self.probability = None + self._array = array - # Helper to convert tensors to numpy for Dimensions - def to_numpy(x): - if hasattr(x, 'cpu'): - return x.cpu().numpy() - return np.asarray(x) - - # Build Dimensions for Signal - time_arr = to_numpy(time) - kxs_arr = to_numpy(kxs) - kys_arr = to_numpy(kys) - layer_arr = to_numpy(layer) if layer is not None else np.array([0]) - + # Build Signal dimensions if Dimensions is not None: - dimensions = Dimensions([ - Dimension(name='probe', space='position', - values=np.arange(len(probe_positions))), - Dimension(name='time', space='temporal', units='ps', - values=time_arr), - Dimension(name='kx', space='scattering', units='Å⁻¹', - values=kxs_arr), - Dimension(name='ky', space='scattering', units='Å⁻¹', - values=kys_arr), - Dimension(name='layer', space='position', - values=layer_arr), + layer_arr = to_numpy(layer) if layer is not None else np.array([0]) + self.dimensions = Dimensions([ + Dimension(name='probe', space='position', + values=np.arange(len(probe_positions))), + Dimension(name='time', space='temporal', units='ps', + values=to_numpy(time)), + Dimension(name='kx', space='scattering', units='Å⁻¹', + values=to_numpy(kxs)), + Dimension(name='ky', space='scattering', units='Å⁻¹', + values=to_numpy(kys)), + Dimension(name='layer', space='position', + values=layer_arr), ], nav_dimensions=[0, 1], sig_dimensions=[2, 3, 4]) - # Build metadata from simulation parameters - # Flatten probe_positions for HDF5 compatibility, store n_probes to reshape on load pp_array = np.array(probe_positions).flatten().tolist() - metadata_dict = { + self.metadata = Metadata({ 'General': { 'title': 'Multislice Wavefunction', - 'signal_type': 'Wavefunction' + 'signal_type': 'Wavefunction', }, 'Simulation': { - 'voltage_eV': float(probe.eV), - 'wavelength_A': float(probe.wavelength), + 'voltage_eV': float(probe.eV), + 'wavelength_A': float(probe.wavelength), 'aperture_mrad': float(probe.mrad), 'probe_positions': pp_array, 'n_probes': len(probe_positions), - } - } - metadata = Metadata(metadata_dict) + }, + }) - # Store array AFTER super().__init__ to avoid being overwritten - self._array = array + # ------------------------------------------------------------------ + # Properties — public interface always returns numpy + # ------------------------------------------------------------------ + + @property + def kxs(self) -> np.ndarray: return to_numpy(self._kxs) + @property + def kys(self) -> np.ndarray: return to_numpy(self._kys) + @property + def xs(self) -> np.ndarray: return to_numpy(self._xs) + @property + def ys(self) -> np.ndarray: return to_numpy(self._ys) + @property + def time(self) -> np.ndarray: return to_numpy(self._time) if self._time is not None else None + @property + def layer(self) -> np.ndarray: return to_numpy(self._layer) if self._layer is not None else None @property def data(self): - """Lazy conversion to numpy for Signal compatibility.""" - if self._array is None: - return None - if hasattr(self._array, 'cpu'): - return self._array.cpu().numpy() - return np.asarray(self._array) + """Lazy conversion to NumPy for Signal compatibility.""" + return to_numpy(self._array) if self._array is not None else None @data.setter def data(self, value): @@ -127,45 +122,52 @@ def data(self, value): @property def array(self): - """Backward compatible alias for internal array (may be tensor or numpy).""" + """Raw array (may be a backend tensor).""" return self._array - #@property - def reshaped(self): # where self._array is indices probe,time,kx,ky,layer, we reshape to probe_x,probe_y,time,kx,ky,layer - nc,nptp,nx,ny = self.probe._array.shape # recall: decoherence creates duplicate probes: num_copies,num_positions,x,y indices - nptp = len(self.probe_positions) - npta,nt,nkx,nky,nl = self._array.shape # recall, Propagate flattens the first two, and adds time,layers: nc*npt,num_frames,x,y,nl indice - intermediate = backend.reshape(self._array,(nc,nptp,nt,nkx,nky,nl)) - nx,ny = len(self.probe_xs),len(self.probe_ys) - return backend.reshape(intermediate,(nc,ny,nx,nt,nkx,nky,nl)).swapaxes(1,2) - @array.setter def array(self, value): self._array = value - def __getattr__(self, name): - """Auto-convert coordinate arrays from tensor to numpy on access.""" - coord_attrs = {'time', 'kxs', 'kys', 'xs', 'ys', 'layer'} - if name in coord_attrs: - raw = object.__getattribute__(self, f'_{name}') - if raw is None: - return None - if hasattr(raw, 'cpu'): - return raw.cpu().numpy() - return np.asarray(raw) - raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'") - - def counts(self,N): + # ------------------------------------------------------------------ + # Reshape helper + # ------------------------------------------------------------------ + + def reshaped(self): + """ + Reshape _array from (nc*npt, nt, kx, ky, nl) + to (nc, nx_probe, ny_probe, nt, kx, ky, nl). + """ + b = self._backend + nc, nptp, _, _ = self.probe._array.shape + nptp = len(self.probe_positions) + _, nt, nkx, nky, nl = self._array.shape + intermediate = b.reshape(self._array, (nc, nptp, nt, nkx, nky, nl)) + nx, ny = len(self.probe_xs), len(self.probe_ys) + reshaped = b.reshape(intermediate, (nc, ny, nx, nt, nkx, nky, nl)) + # swap probe_x / probe_y axes to get (nc, nx, ny, nt, kx, ky, nl) + return reshaped.swapaxes(1, 2) + + # ------------------------------------------------------------------ + # Photon-counting simulation + # ------------------------------------------------------------------ + + def counts(self, N: int): + b = self._backend if self.probability is None: self.probability = self._array - npt,nt,nx,ny,nl = self._array.shape - ary = self._array/backend.array_sum(backend.absolute(self._array)) # normalized: ensure values arerelative probabilities of each voxel - ary = backend.absolute(ary.reshape(npt*nt*nx*ny*nl)) - self.buckets = zeros(len(ary)+1,type_match=ary) - self.buckets[1:] = cumsum(ary) # cumsum means we can "select" a voxel with a random float 0-1 - detector_hits = asarray(randfloats(N)) # randomly "select" histogram bins based on each bin's relative size - hist = histogram(detector_hits,bins=self.buckets) - self._array = asarray(hist.reshape((npt,nt,nx,ny,nl))) + npt, nt, nx, ny, nl = self._array.shape + ary = self._array / b.sum(b.absolute(self._array)) + ary = b.absolute(b.reshape(ary, (npt * nt * nx * ny * nl,))) + self.buckets = b.zeros(len(ary) + 1, type_match=ary) + self.buckets[1:] = b.cumsum(ary) + detector_hits = b.asarray(b.randfloats(N)) + hist = b.histogram(detector_hits, bins=self.buckets) + self._array = b.asarray(hist.reshape((npt, nt, nx, ny, nl))) + + # ------------------------------------------------------------------ + # Plotting + # ------------------------------------------------------------------ def plot_reciprocal(self, filename=None, @@ -176,264 +178,180 @@ def plot_reciprocal(self, nuke_zerobeam=False, title=None): import matplotlib.pyplot as plt - fig, ax = plt.subplots() - raw = self._array[:,:,:,:,-1] # probe, time, kx, ky, layer --> p,t,kx,ky - npt,nt,nkx,nky = raw.shape - array = backend.zeros((nkx,nky)) - if isinstance(whichProbe,str) and whichProbe=="mean": - whichProbe = np.arange(npt) - elif isinstance(whichProbe,int): - whichProbe = [whichProbe] - if isinstance(whichTimestep,str) and whichTimestep=="mean": - whichTimestep = np.arange(nt) - elif isinstance(whichTimestep,int): - whichTimestep = [whichTimestep] - for p in whichProbe: - for t in whichTimestep: - layer = backend.absolute(raw[p,t,:,:]) - if isinstance(raw,np.memmap): - layer = asarray(layer) - array+=layer - array/=(len(whichTimestep)*len(whichProbe)) - #array=abs(raw) # don't do this, it pulls memmaps into ram! - #if isinstance(whichProbe,str) and whichProbe=="mean": - # array = mean(abs(array),axis=0) # p,t,kx,ky --> t,kx,ky - #else: - # array = array[whichProbe] - # - #if isinstance(whichTimestep,str) and whichTimestep=="mean": - # array = mean(array,axis=0) # t,kx,ky --> kx,ky - #else: - # array = array[whichTimestep] - - # Convert kxs and kys to numpy for indexing - if hasattr(self.kxs, 'cpu'): - kxs_np = self.kxs.cpu().numpy() - kys_np = self.kys.cpu().numpy() - else: - kxs_np = np.asarray(self.kxs) - kys_np = np.asarray(self.kys) + b = self._backend + raw = self._array[:, :, :, :, -1] # p,t,kx,ky + npt, nt, nkx, nky = raw.shape + accum = b.zeros((nkx, nky)) + + probe_indices = np.arange(npt) if whichProbe == "mean" else ( + [whichProbe] if isinstance(whichProbe, int) else whichProbe) + time_indices = np.arange(nt) if whichTimestep == "mean" else ( + [whichTimestep] if isinstance(whichTimestep, int) else whichTimestep) + + for p in probe_indices: + for t in time_indices: + layer = b.absolute(raw[p, t, :, :]) + if isinstance(raw, np.memmap): + layer = b.asarray(layer) + accum += layer + accum /= (len(time_indices) * len(probe_indices)) + + kxs_np = to_numpy(self._kxs) + kys_np = to_numpy(self._kys) - # If extent is provided, slice the data if extent is not None: kx_min, kx_max, ky_min, ky_max = extent - - # Find indices for the requested extent kx_mask = (kxs_np >= kx_min) & (kxs_np <= kx_max) ky_mask = (kys_np >= ky_min) & (kys_np <= ky_max) - - # Slice the array and coordinate arrays - array = array[kx_mask, :][:, ky_mask] + accum = accum[kx_mask, :][:, ky_mask] kxs_np = kxs_np[kx_mask] kys_np = kys_np[ky_mask] - actual_extent = (kxs_np[0], kxs_np[-1], - kys_np[0], kys_np[-1]) + actual_extent = (kxs_np[0], kxs_np[-1], kys_np[0], kys_np[-1]) else: - # Use full extent - kxs_min = float(kxs_np.min()) - kxs_max = float(kxs_np.max()) - kys_min = float(kys_np.min()) - kys_max = float(kys_np.max()) - actual_extent = (kxs_min, kxs_max, kys_min, kys_max) - - # Transpose for imshow convention - array = array.T # imshow convention: y,x. our convention: x,y + actual_extent = (kxs_np.min(), kxs_np.max(), kys_np.min(), kys_np.max()) + + accum_np = to_numpy(accum).T # imshow: y,x if nuke_zerobeam: - array[np.argmin(backend.absolute(kys_np)),np.argmin(backend.absolute(kxs_np))]=0 - - # Convert to numpy array if it's a tensor - # Apply powerscaling to intensity (|Ψ|²) - img_data = (backend.absolute(array)**2)**powerscaling - if hasattr(img_data, 'cpu'): - img_data = img_data.cpu().numpy() - elif hasattr(img_data, '__array__'): - img_data = np.asarray(img_data) - ax.imshow(img_data, cmap="inferno", extent=actual_extent, origin='lower',aspect=1) - ax.set_xlabel("kx ($\\AA^{-1}$)") - ax.set_ylabel("ky ($\\AA^{-1}$)") - - if title is not None: - ax.set_title(title) + accum_np[np.argmin(np.abs(kys_np)), np.argmin(np.abs(kxs_np))] = 0 - if filename is not None: + img = (np.abs(accum_np) ** 2) ** powerscaling + fig, ax = plt.subplots() + ax.imshow(img, cmap="inferno", extent=actual_extent, origin='lower', aspect=1) + ax.set_xlabel("kx (Å⁻¹)") + ax.set_ylabel("ky (Å⁻¹)") + if title: + ax.set_title(title) + if filename: plt.savefig(filename) else: plt.show() + plt.close(fig) plot = plot_reciprocal - def plot_phase(self,filename=None,whichProbe=0,whichTimestep=0,extent=None,avg=False): - """ - Plot the phase of the wavefunction in real space. - - Args: - whichProbe: Probe index - whichTimestep: Timestep index - extent: Optional (xmin, xmax, ymin, ymax) to zoom - avg: If True, average over all timesteps before plotting - """ + def plot_phase(self, filename=None, whichProbe=0, whichTimestep=0, + extent=None, avg=False): import matplotlib.pyplot as plt - fig, ax = plt.subplots() - # Get array (with or without averaging) + b = self._backend if avg: - array = self._array[whichProbe,:,:,:,-1] # Shape: (time, kx, ky) - array = backend.array_mean(array, axis=0) # Average over time dimension + raw = b.mean(self._array[whichProbe, :, :, :, -1], axis=0) else: - array = self._array[whichProbe,whichTimestep,:,:,-1] + raw = self._array[whichProbe, whichTimestep, :, :, -1] - # Transform to real space - array = backend.ifft2(array) - xs_np = np.asarray(self.xs) - ys_np = np.asarray(self.ys) + real_space = b.ifft2(raw) + xs_np = to_numpy(self._xs) + ys_np = to_numpy(self._ys) - # If extent is provided, slice the data if extent is not None: x_min, x_max, y_min, y_max = extent - - # Find indices for the requested extent - x_mask = (xs_np >= x_min) & (xs_np <= x_max) - y_mask = (ys_np >= y_min) & (ys_np <= y_max) - - # Slice the array - array = array[x_mask, :][:, y_mask] - actual_extent = (xs_np[x_mask][0], xs_np[x_mask][-1], - ys_np[y_mask][0], ys_np[y_mask][-1]) + xm = (xs_np >= x_min) & (xs_np <= x_max) + ym = (ys_np >= y_min) & (ys_np <= y_max) + real_space = real_space[xm, :][:, ym] + actual_extent = (xs_np[xm][0], xs_np[xm][-1], ys_np[ym][0], ys_np[ym][-1]) else: - # Use full extent - actual_extent = (float(xs_np.min()), float(xs_np.max()), - float(ys_np.min()), float(ys_np.max())) - - # Transpose for imshow convention - array = array.T # imshow convention: y,x. our convention: x,y - - # Get phase - phase_data = backend.angle(array) - if hasattr(phase_data, 'cpu'): - phase_data = phase_data.cpu().numpy() - elif hasattr(phase_data, '__array__'): - phase_data = np.asarray(phase_data) - - # Plot with phase colormap - im = ax.imshow(phase_data, cmap='hsv', extent=actual_extent, origin='lower', + actual_extent = (xs_np.min(), xs_np.max(), ys_np.min(), ys_np.max()) + + phase = to_numpy(b.angle(real_space)).T + fig, ax = plt.subplots() + im = ax.imshow(phase, cmap='hsv', extent=actual_extent, origin='lower', vmin=-np.pi, vmax=np.pi) plt.colorbar(im, ax=ax, label='Phase (radians)') ax.set_title('Phase in real space') - ax.set_xlabel('x (Å)') - ax.set_ylabel('y (Å)') - - if filename is not None: + ax.set_xlabel('x (Å)'); ax.set_ylabel('y (Å)') + if filename: plt.savefig(filename) else: plt.show() + plt.close(fig) - def plot_realspace(self,whichProbe="mean",whichTimestep="mean",extent=None,filename=None): + def plot_realspace(self, whichProbe="mean", whichTimestep="mean", + extent=None, filename=None): import matplotlib.pyplot as plt - fig, ax = plt.subplots() - - array = backend.ifft2(self._array[:,:,:,:,-1]) - array = backend.absolute(array) # probe, time, kx, ky, layer --> p,t,kx,ky + b = self._backend + array = b.absolute(b.ifft2(self._array[:, :, :, :, -1])) - if isinstance(whichProbe,str) and whichProbe=="mean": - array = backend.array_mean(backend.absolute(array),axis=0) # p,t,kx,ky --> t,kx,ky + if whichProbe == "mean": + array = b.mean(array, axis=0) else: array = array[whichProbe] - - if isinstance(whichTimestep,str) and whichTimestep=="mean": - array = backend.array_mean(array,axis=0) # t,kx,ky --> kx,ky + if whichTimestep == "mean": + array = b.mean(array, axis=0) else: array = array[whichTimestep] - array = array.T # imshow convention: y,x. our convention: x,y - - # Use provided extent or calculate from data + xs_np = to_numpy(self._xs) + ys_np = to_numpy(self._ys) if extent is None: - extent = ( np.amin(self.xs) , np.amax(self.xs) , np.amin(self.ys) , np.amax(self.ys) ) - - # Convert to numpy array if it's a tensor - img_data = backend.absolute(array)**.25 - if hasattr(img_data, 'cpu'): - img_data = img_data.cpu().numpy() - elif hasattr(img_data, '__array__'): - img_data = np.asarray(img_data) - - ax.imshow( img_data, cmap="inferno", extent=extent ) + extent = (xs_np.min(), xs_np.max(), ys_np.min(), ys_np.max()) - if filename is not None: + img = to_numpy(b.absolute(array) ** 0.25).T + fig, ax = plt.subplots() + ax.imshow(img, cmap="inferno", extent=extent) + if filename: plt.savefig(filename) else: plt.show() - - def propagate_free_space(self,dz): # UNITS OF ANGSTROM - kx_grid, ky_grid = backend.meshgrid(self._kxs, self._kys, indexing='ij') - k_squared = kx_grid**2 + ky_grid**2 - inner = backend.pi * self.probe.wavelength * dz * k_squared - P = backend.exp( -1j * inner ) # not sure why, but combining this and previous line triggers a "ComplexWarning: Casting complex values to real discards the imaginary part" in python 2.9.1 but not 2.2.2 - if hasattr(self._array, 'device'): - P = P.to(self._array.device) - #if dz>0: - self._array = P[None,None,:,:,None] * self._array - - def addSpatialDecoherence(self,sigma_dz,N): - dzs = backend.linspace(-2*sigma_dz,2*sigma_dz,N) # suppose N=25 - amplitudes = backend.exp(-dzs**2/sigma_dz**2) - self._array = self._array[:,None,:,:,:,:] * backend.ones(N)[None,:,None,None,None,None] # n_probes,nt,nx,ny,nl --> - nc,npt,nt,nx,ny,nl = self._array.shape # suppose nc=10 (addTemporalDecoherence created 10 wavelengths) - kx_grid, ky_grid = backend.meshgrid(self._kxs, self._kys, indexing='ij') - k_squared = kx_grid**2 + ky_grid**2 + plt.close(fig) + + # ------------------------------------------------------------------ + # Post-processing + # ------------------------------------------------------------------ + + def propagate_free_space(self, dz: float): + b = self._backend + kx_grid, ky_grid = b.meshgrid(self._kxs, self._kys, indexing='ij') + P = b.exp(-1j * b.pi * self.probe.wavelength * dz * (kx_grid ** 2 + ky_grid ** 2)) + self._array = P[None, None, :, :, None] * self._array + + def addSpatialDecoherence(self, sigma_dz: float, N: int): + b = self._backend + dzs = b.linspace(-2 * sigma_dz, 2 * sigma_dz, N) + amplitudes = b.exp(-dzs ** 2 / sigma_dz ** 2) + self._array = self._array[:, None, :, :, :, :] * b.ones(N)[None, :, None, None, None, None] + nc, npt, nt, nx, ny, nl = self._array.shape + kx_grid, ky_grid = b.meshgrid(self._kxs, self._kys, indexing='ij') + k_sq = kx_grid ** 2 + ky_grid ** 2 for i in range(N): - inner = backend.pi * self.probe.wavelength * dzs[i] * k_squared - P = backend.exp( -1j * inner ) # not sure why, but combining this and previous line triggers a "ComplexWarning: Casting complex values to real discards the imaginary part" in python 2.9.1 but not 2.2.2 - self._array[:,i,:,:,:,:] *= amplitudes[i]*P[None,None,:,:,None] - self._array = self._array.reshape(nc*npt,nt,nx,ny,nl) - #self.defocus(dzs) # defocus starts with 25,10,npt,nx,ny --reshapes--> 250,npt,nx,ny - #for i in range(N): # reshape to flatten loops first index last: [[0,1],[2,3]] --> [0,1,2,3] - # for j in range(nc): - # self._array[i*nc+j] *= amplitudes[i] - #nc,npt,nx,ny = self._array.shape - #if npt==1: - # self.applyShifts() - - - def applyMask(self, radius, realOrReciprocal="reciprocal"): + P = b.exp(-1j * b.pi * self.probe.wavelength * dzs[i] * k_sq) + self._array[:, i, :, :, :, :] *= amplitudes[i] * P[None, None, :, :, None] + self._array = b.reshape(self._array, (nc * npt, nt, nx, ny, nl)) + + def applyMask(self, radius: float, realOrReciprocal: str = "reciprocal"): + b = self._backend if realOrReciprocal == "reciprocal": - radii = backend.sqrt( self._kxs[:,None]**2 + self._kys[None,:]**2 ) - mask = backend.zeros(radii.shape, device=self._array.device if backend.TORCH_BACKEND else None) - mask[radii= kx_range[0])[0] # first element >= - i2=np.argwhere(self._kxs <= kx_range[1])[-1]+1 # last element <=, +1, so i1:i2 includes i2 + i1 = int(np.argwhere(kxs_np >= kx_range[0])[0]) + i2 = int(np.argwhere(kxs_np <= kx_range[1])[-1]) + 1 if ky_range is not None: - j1=np.argwhere(self._kys >= ky_range[0])[0] - j2=np.argwhere(self._kys <= ky_range[1])[-1]+1 - nx=i2-i1 ; ny=j2-j1 - self._array = self._array[:,:,i1:i2,j1:j2,:] # p,t,x,y,l indices: TODO this uses the same amount of RAM - #self._array = xp.zeros((npt,nt,nx,ny,nl), device=self._array.device if TORCH_AVAILABLE else None) +\ - # self._array[:,:,i1:i2,j1:j2,:] # p,t,x,y,l indices TODO this actually uses MORE RAM? + j1 = int(np.argwhere(kys_np >= ky_range[0])[0]) + j2 = int(np.argwhere(kys_np <= ky_range[1])[-1]) + 1 + self._array = self._array[:, :, i1:i2, j1:j2, :] self._kxs = self._kxs[i1:i2] self._kys = self._kys[j1:j2] - def aberrate(self,aberrations): - dP = aberrationFunction(self._kxs,self._kys,self.probe.wavelength,aberrations) - self._array[:,:,:,:,:] *= dP[None,None,:,:,None] # indices npt,nt,kx,ky,nl + def aberrate(self, aberrations: dict): + dP = aberrationFunction(self._kxs, self._kys, self.probe.wavelength, aberrations) + self._array[:, :, :, :, :] *= dP[None, None, :, :, None] diff --git a/tests/00_probe.py b/tests/00_probe.py index 1fb3572..5638a80 100644 --- a/tests/00_probe.py +++ b/tests/00_probe.py @@ -1,6 +1,6 @@ -import os -os.environ['MPLBACKEND'] = 'Agg' -import sys,os,time +import testtools +from testtools import differ +import sys, os, time try: import pyslice except ModuleNotFoundError: @@ -8,14 +8,13 @@ sys.path.insert(0, '../src') start=time.time() from pyslice.multislice.multislice import Probe +from pyslice.backend import make_backend print("probe import took",time.time()-start,"s") -start=time.time() -from pyslice import differ -print("differ import took",time.time()-start,"s") - import numpy as np +backend = make_backend() + # Generate a few dummy probes xs=np.linspace(0,50,501) ys=np.linspace(0,49,491) @@ -23,7 +22,7 @@ mrads=[1,3,5,15,30] ary=np.zeros((5,501,491),dtype=complex) for i,mrad in enumerate(mrads): - probe=Probe(xs,ys,mrad=mrad,eV=100e3,preview=False,gaussianVOA=0) + probe=Probe(xs,ys,mrad=mrad,eV=100e3,backend=backend,preview=False,gaussianVOA=0) probe.plot("outputs/figs/00_probe_"+str(i)+".png") #if hasattr(probe, 'to_cpu'): # ary[i] = probe.to_cpu() diff --git a/tests/00_probe2.py b/tests/00_probe2.py new file mode 100644 index 0000000..65d41cf --- /dev/null +++ b/tests/00_probe2.py @@ -0,0 +1,31 @@ +import sys,os +try: + import pyslice +except ModuleNotFoundError: + sys.path.insert(0, '../src') +from pyslice.multislice.multislice2 import Probe +from testtools import differ +import numpy as np + +# Generate a few dummy probes +xs=np.linspace(0,50,501) +ys=np.linspace(0,49,491) + +mrads=[1,3,5,15,30] +ary=np.zeros((5,501,491),dtype=complex) +for i,mrad in enumerate(mrads): + probe=Probe(xs,ys,mrad=mrad,eV=100e3,preview=False,gaussianVOA=0) + probe.plot("outputs/figs/00_probe_"+str(i)+".png") + if hasattr(probe, 'to_cpu'): + ary[i] = probe.to_cpu() + else: + ary[i] = np.asarray(probe.array) +ary=np.reshape(ary,(501*5,491)) + +differ(ary,"outputs/probe-test.npy","PROBE") + +import matplotlib.pyplot as plt +fig, ax = plt.subplots() +ax.imshow(np.absolute(ary.T)**.25, cmap="inferno") +plt.savefig("outputs/figs/00_probe.png") +#plt.show() diff --git a/tests/01_potentials.py b/tests/01_potentials.py index f1363ab..e6c0d47 100644 --- a/tests/01_potentials.py +++ b/tests/01_potentials.py @@ -1,13 +1,20 @@ -import sys,os +import testtools +from testtools import differ +import sys, os try: import pyslice except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,gridFromTrajectory,Potential,differ +from pyslice import Loader, grid_from_trajectory, Potential +from pyslice.backend import make_backend import numpy as np +os.environ['MPLBACKEND'] = 'Agg' + +backend = make_backend() + dump="inputs/hBN_truncated.lammpstrj" dt=.005 types={1:"B",2:"N"} @@ -18,13 +25,16 @@ # TEST GENERATION OF THE POTENTIAL positions = trajectory.positions[0] atom_types=trajectory.atom_types -xs,ys,zs,lx,ly,lz=gridFromTrajectory(trajectory,sampling=0.1,slice_thickness=0.5) -potential = Potential(xs, ys, zs, positions, atom_types, kind="kirkland") +xs,ys,zs,lx,ly,lz=grid_from_trajectory(trajectory,sampling=0.1,slice_thickness=0.5) +potential = Potential(xs, ys, zs, positions, atom_types, backend=backend, kind="kirkland") potential.build() -ary=potential.array # ".array" converts torch tensor to CPU numpy array automatically if required +ary=potential.to_numpy() # ".array" converts torch tensor to CPU numpy array automatically if required print(ary.shape) + differ(ary[::20,::20,::2],"outputs/potentials-test.npy","POTENTIAL") +print(ary.shape) + potential.plot("outputs/figs/01_potentials.png") #import matplotlib.pyplot as plt diff --git a/tests/01_potentials2.py b/tests/01_potentials2.py index c28455a..674e9f1 100644 --- a/tests/01_potentials2.py +++ b/tests/01_potentials2.py @@ -8,7 +8,7 @@ from pyslice.multislice.potentials import gridFromTrajectory,Potential from pyslice.multislice.potentials2 import gridFromTrajectory as gridFromTrajectory2 from pyslice.multislice.potentials2 import Potential as Potential2 -from pyslice.postprocessing.testtools import differ +from testtools import differ import numpy as np #from ..pyslice.tacaw.ms_calculator_npy import gridFromTrajectory #from pyslice.tacaw.multislice_npy import Probe,Propagate ; import numpy as xp diff --git a/tests/02_propagate2_otf=False.py b/tests/02_propagate2_otf=False.py new file mode 100644 index 0000000..988f015 --- /dev/null +++ b/tests/02_propagate2_otf=False.py @@ -0,0 +1,45 @@ +import sys,os +try: + import pyslice +except ModuleNotFoundError: + sys.path.insert(0, '../src') +from pyslice.io.loader import Loader +from pyslice.multislice.multislice2 import Probe,Propagate +from pyslice.multislice.potentials2 import gridFromTrajectory,Potential +from testtools import differ +from pyslice.backend import to_numpy +import numpy as np +#from ..pyslice.tacaw.ms_calculator_npy import gridFromTrajectory +#from pyslice.tacaw.multislice_npy import Probe,Propagate ; import numpy as xp +#from pyslice.tacaw.multislice_torch import Probe,PropagateBatch,create_batched_probes ; import torch as xp +#from pyslice.tacaw.potential import Potential + +dump="inputs/hBN_truncated.lammpstrj" +dt=.005 +types={1:"B",2:"N"} + +# LOAD MD OUTPUT +trajectory=Loader(dump,timestep=dt,atom_mapping=types).load() +xs,ys,zs,lx,ly,lz=gridFromTrajectory(trajectory,sampling=0.1,slice_thickness=0.5) + +# GENERATE PROBE (ENSURE 00_PROBE.PY PASSES BEFORE RUNNING) +probe=Probe(xs,ys,mrad=5,eV=100e3) + +# GENERATE THE POTENTIAL (ENSURE 01_POTENTIAL.PY PASSES BEFORE RUNNING) +positions = trajectory.positions[0] +atom_types=trajectory.atom_types +potential = Potential(xs, ys, zs, positions, atom_types, kind="kirkland") + +# TEST PROPAGATION +# Handle device conversion properly for PyTorch tensors +result = Propagate(probe,potential,onthefly=False) +ary = to_numpy(result) + +#arydiffer(ary,"outputs/propagate-test.npy","EXIT WAVE") + +import matplotlib.pyplot as plt +fig, ax = plt.subplots() +#ax.imshow(np.absolute(ary), cmap="inferno") +#plt.show() +ax.imshow(np.absolute(np.fft.fftshift(np.fft.fft2(ary)))**.1, cmap="inferno") +plt.savefig("outputs/figs/02_propagate_otf=False.png") diff --git a/tests/02_propagate_otf=False.py b/tests/02_propagate_otf=False.py index 13f95ac..3b0c262 100644 --- a/tests/02_propagate_otf=False.py +++ b/tests/02_propagate_otf=False.py @@ -4,34 +4,33 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,Probe,Propagate,gridFromTrajectory,Potential,differ +from testtools import differ +from pyslice import Loader,Probe,Propagate,grid_from_trajectory,Potential +from pyslice.backend import make_backend, to_numpy import numpy as np +backend = make_backend() + dump="inputs/hBN_truncated.lammpstrj" dt=.005 types={1:"B",2:"N"} # LOAD MD OUTPUT trajectory=Loader(dump,timestep=dt,atom_mapping=types).load() -xs,ys,zs,lx,ly,lz=gridFromTrajectory(trajectory,sampling=0.1,slice_thickness=0.5) +xs,ys,zs,lx,ly,lz=grid_from_trajectory(trajectory,sampling=0.1,slice_thickness=0.5) # GENERATE PROBE (ENSURE 00_PROBE.PY PASSES BEFORE RUNNING) -probe=Probe(xs,ys,mrad=5,eV=100e3) +probe=Probe(xs,ys,mrad=5,eV=100e3,backend=backend) # GENERATE THE POTENTIAL (ENSURE 01_POTENTIAL.PY PASSES BEFORE RUNNING) positions = trajectory.positions[0] atom_types=trajectory.atom_types -potential = Potential(xs, ys, zs, positions, atom_types, kind="kirkland") +potential = Potential(xs, ys, zs, positions, atom_types, backend=backend, kind="kirkland") # TEST PROPAGATION -# Handle device conversion properly for PyTorch tensors -result = Propagate(probe,potential,onthefly=False) -# result may be a torch tensor (since Calculators and friends don't want the exit wave moved off-device yet, and we do not expect the end user to call Propagate directly) -if hasattr(result, 'cpu'): - ary = result.cpu().numpy() # Convert PyTorch tensor to numpy -else: - ary = np.asarray(result) # Already numpy array +result = Propagate(probe,potential,backend,onthefly=False) +ary = to_numpy(result) ary=ary[0,:,:] differ(ary[::10,::10],"outputs/propagate-test.npy","EXIT WAVE") diff --git a/tests/02_propagate_otf=True.py b/tests/02_propagate_otf=True.py index 8512da3..7ce3909 100644 --- a/tests/02_propagate_otf=True.py +++ b/tests/02_propagate_otf=True.py @@ -4,34 +4,33 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,Probe,Propagate,gridFromTrajectory,Potential,differ +from testtools import differ +from pyslice import Loader,Probe,Propagate,grid_from_trajectory,Potential +from pyslice.backend import make_backend, to_numpy import numpy as np +backend = make_backend() + dump="inputs/hBN_truncated.lammpstrj" dt=.005 types={1:"B",2:"N"} # LOAD MD OUTPUT trajectory=Loader(dump,timestep=dt,atom_mapping=types).load() -xs,ys,zs,lx,ly,lz=gridFromTrajectory(trajectory,sampling=0.1,slice_thickness=0.5) +xs,ys,zs,lx,ly,lz=grid_from_trajectory(trajectory,sampling=0.1,slice_thickness=0.5) # GENERATE PROBE (ENSURE 00_PROBE.PY PASSES BEFORE RUNNING) -probe=Probe(xs,ys,mrad=5,eV=100e3) +probe=Probe(xs,ys,mrad=5,eV=100e3,backend=backend) # GENERATE THE POTENTIAL (ENSURE 01_POTENTIAL.PY PASSES BEFORE RUNNING) positions = trajectory.positions[0] atom_types=trajectory.atom_types -potential = Potential(xs, ys, zs, positions, atom_types, kind="kirkland") +potential = Potential(xs, ys, zs, positions, atom_types, backend=backend, kind="kirkland") # TEST PROPAGATION -# Handle device conversion properly for PyTorch tensors -result = Propagate(probe,potential,onthefly=True) -# result may be a torch tensor (since Calculators and friends don't want the exit wave moved off-device yet, and we do not expect the end user to call Propagate directly) -if hasattr(result, 'cpu'): - ary = result.cpu().numpy() # Convert PyTorch tensor to numpy -else: - ary = np.asarray(result) # Already numpy array +result = Propagate(probe,potential,backend,onthefly=True) +ary = to_numpy(result) ary=ary[0,:,:] differ(ary[::10,::10],"outputs/propagate-test.npy","EXIT WAVE") diff --git a/tests/02_unpropagate.py b/tests/02_unpropagate.py index 818748e..27fe036 100644 --- a/tests/02_unpropagate.py +++ b/tests/02_unpropagate.py @@ -4,10 +4,14 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,Probe,Propagate,gridFromTrajectory,Potential,differ,to_cpu,calculateObject +from testtools import differ +from pyslice import Loader,Probe,Propagate,grid_from_trajectory,Potential,calculateObject +from pyslice.backend import make_backend, to_cpu import matplotlib.pyplot as plt import numpy as np +backend = make_backend() + dump="inputs/hBN_truncated.lammpstrj" dt=.005 types={1:"B",2:"N"} @@ -16,24 +20,24 @@ # LOAD MD OUTPUT trajectory=Loader(dump,timestep=dt,atom_mapping=types).load() - xs,ys,zs,lx,ly,lz=gridFromTrajectory(trajectory,sampling=0.1,slice_thickness=0.5) + xs,ys,zs,lx,ly,lz=grid_from_trajectory(trajectory,sampling=0.1,slice_thickness=0.5) # GENERATE PROBE (ENSURE 00_PROBE.PY PASSES BEFORE RUNNING) xpr=[lx/2,lx/2+5] ; ypr=[ly/2]*2 ; Os=[] for x,y in zip(xpr,ypr): - probe=Probe(xs,ys,mrad=5,eV=100e3,probe_xs=[x],probe_ys=[y]) + probe=Probe(xs,ys,mrad=5,eV=100e3,backend=backend,probe_xs=[x],probe_ys=[y]) probe.defocus(200) #probe.plot() # GENERATE THE POTENTIAL (ENSURE 01_POTENTIAL.PY PASSES BEFORE RUNNING) positions = trajectory.positions[0] atom_types=trajectory.atom_types - potential = Potential(xs, ys, zs, positions, atom_types, kind="kirkland") + potential = Potential(xs, ys, zs, positions, atom_types, backend=backend, kind="kirkland") potential.plot() potential.build() - if flatten: - potential.flatten() # TECHNICALLY calculateObject ONLY RETURNS THE TRULY CORRECT SOLUTION FOR A SINGLE SLICE + # NOTE: potential.flatten() removed — not available in new Potential API + # TECHNICALLY calculateObject ONLY RETURNS THE TRULY CORRECT SOLUTION FOR A SINGLE SLICE p_arry = np.absolute(np.sum(potential.array,axis=2)) #fig, ax = plt.subplots() @@ -42,8 +46,7 @@ #plt.show() # PROPAGATION - # Handle device conversion properly for PyTorch tensors - result = Propagate(probe,potential,onthefly=True) + result = Propagate(probe,potential,backend,onthefly=True) res = to_cpu(result[0,:,:]) #fig, ax = plt.subplots() #ax.imshow(np.absolute(res), cmap="inferno") @@ -55,7 +58,7 @@ #plt.show() # RECALCULATE OBJECT FROM THE RESULT - dO = calculateObject(probe,result[0,:,:],np.zeros((len(xs),len(ys))),weighting=1,dz=0.5) + dO = calculateObject(probe,result[0,:,:],np.zeros((len(xs),len(ys))),backend,weighting=1,dz=0.5) Os.append(dO) dO = to_cpu(dO) fig, ax = plt.subplots() @@ -75,4 +78,3 @@ ax.imshow(delta**.1, cmap="inferno") plt.title("|OP-RP|/|OP|="+str(np.amax(delta)/np.amax(p_arry))) plt.show() - diff --git a/tests/03_manyprobes.py b/tests/03_manyprobes.py index 670c594..220b7c0 100644 --- a/tests/03_manyprobes.py +++ b/tests/03_manyprobes.py @@ -4,11 +4,15 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,Probe,Propagate,create_batched_probes,gridFromTrajectory,Potential,differ +from testtools import differ +from pyslice import Loader,Probe,Propagate,create_batched_probes,grid_from_trajectory,Potential +from pyslice.backend import make_backend, to_numpy import numpy as np import matplotlib.pyplot as plt +backend = make_backend() + dump="inputs/hBN_truncated.lammpstrj" dt=.005 types={1:"B",2:"N"} @@ -17,22 +21,19 @@ # LOAD MD OUTPUT trajectory=Loader(dump,timestep=dt,atom_mapping=types).load() trajectory=trajectory.slice_positions([0,10*a],[0,10*b]) -xs,ys,zs,lx,ly,lz=gridFromTrajectory(trajectory,sampling=0.1,slice_thickness=0.5) +xs,ys,zs,lx,ly,lz=grid_from_trajectory(trajectory,sampling=0.1,slice_thickness=0.5) # GENERATE PROBE (ENSURE 00_PROBE.PY PASSES BEFORE RUNNING) -#probe=Probe(xs,ys,mrad=30,eV=100e3) +#probe=Probe(xs,ys,mrad=30,eV=100e3,backend=backend) xsp = np.linspace(10*a-a,10*a-3*a,16) ysp = np.linspace(10*b-b,10*b-3*b,16) -#x,y=np.meshgrid(xs,ys) -#xy=np.reshape([x,y],(2,len(x.flat))).T -#print(xy) #probes_many=create_batched_probes(probe,xy) # we stopped recommending create_batched_probes many commits ago -probes_many=Probe(xs,ys,mrad=30,eV=100e3,probe_xs=xsp,probe_ys=ysp) # creates a flattened list of probes, each shifted to center on each x,y point +probes_many=Probe(xs,ys,mrad=30,eV=100e3,backend=backend,probe_xs=xsp,probe_ys=ysp) # creates a flattened list of probes, each shifted to center on each x,y point # GENERATE THE POTENTIAL (ENSURE 01_POTENTIAL.PY PASSES BEFORE RUNNING) positions = trajectory.positions[0] atom_types=trajectory.atom_types -potential = Potential(xs, ys, zs, positions, atom_types, kind="kirkland") +potential = Potential(xs, ys, zs, positions, atom_types, backend=backend, kind="kirkland") # SANITY CHECK THAT OUR CROPPED TRAJECTORY IS CORRECT #ary=np.asarray(potential.array) @@ -48,17 +49,10 @@ #plt.show() # TEST PROPAGATION -result = Propagate(probes_many,potential) -kxs = potential.kxs # also retrieve kx,ky since we may need to convert from Torch -kys = potential.kys -# result may be a torch tensor (since Calculators and friends don't want the exit wave moved off-device yet, and we do not expect the end user to call Propagate directly) -if hasattr(result, 'cpu'): - ary = result.cpu().numpy() # Convert PyTorch tensor to numpy -else: - ary = np.asarray(result) # Already numpy array -if hasattr(kxs,'cpu'): - kxs = np.asarray(kxs.cpu()) - kys = np.asarray(kys.cpu()) +result = Propagate(probes_many,potential,backend) +kxs = to_numpy(potential.kxs) +kys = to_numpy(potential.kys) +ary = to_numpy(result) print(ary.shape) differ(ary[::5,::5,::5],"outputs/manyprobes-test.npy","EXIT WAVE") @@ -72,4 +66,3 @@ HAADF=np.sum(np.absolute(fft),axis=(1,2)).reshape((len(xsp),len(ysp))) ax.imshow(HAADF, cmap="inferno") plt.savefig("outputs/figs/03_manyprobes.png") - diff --git a/tests/03_manyprobes2.py b/tests/03_manyprobes2.py new file mode 100644 index 0000000..9d33d5f --- /dev/null +++ b/tests/03_manyprobes2.py @@ -0,0 +1,121 @@ +import sys,os +try: + import pyslice +except ModuleNotFoundError: + sys.path.insert(0, '../src') +from pyslice.io.loader import Loader +from pyslice.multislice.multislice import Probe,Propagate,create_batched_probes + +import pyslice.backend as backend + +from pyslice.multislice.multislice2 import Probe as Probe2 +from pyslice.multislice.multislice2 import Propagate as Propagate2 +from pyslice.multislice.multislice2 import create_batched_probes as create_batched_probes2 + +from pyslice.multislice.potentials2 import gridFromTrajectory,Potential +from testtools import differ, differ_phase, differ_abs +import numpy as np +import matplotlib.pyplot as plt +#from ..pyslice.tacaw.ms_calculator_npy import gridFromTrajectory +#from pyslice.tacaw.multislice_npy import Probe,Propagate ; import numpy as xp +#from pyslice.tacaw.multislice_torch import Probe,PropagateBatch,create_batched_probes ; import torch as xp +#from pyslice.tacaw.potential import Potential + +dump="inputs/hBN_truncated.lammpstrj" +dt=.005 +types={1:"B",2:"N"} +a,b=2.4907733333333337,2.1570729817355123 + +# LOAD MD OUTPUT +trajectory=Loader(dump,timestep=dt,atom_mapping=types).load() +trajectory=trajectory.slice_positions([0,10*a],[0,10*b]) +xs,ys,zs,lx,ly,lz=gridFromTrajectory(trajectory,sampling=0.1,slice_thickness=0.5) + +# GENERATE PROBE (ENSURE 00_PROBE.PY PASSES BEFORE RUNNING) +probe=Probe(xs,ys,mrad=30,eV=100e3) +probe2=Probe2(xs,ys,mrad=30,eV=100e3) + +arr = backend.to_cpu(probe.array) +arr2 = backend.to_cpu(probe2.array) + +assert(np.all(np.isclose(arr, arr2))) +probe = probe2 + +x, y = np.meshgrid(np.linspace(a,3*a,16),np.linspace(b,3*b,16)) +xy = np.reshape([x,y], (2,len(x.flat))).T +#print(xy) +probes_many=create_batched_probes(probe,xy) +probes_many2=create_batched_probes2(probe,xy) +print('print', probes_many.array.shape) +print('print', probes_many2.array.shape) + +arr = backend.to_cpu(probes_many.array) +arr2 = backend.to_cpu(probes_many2.array) + +assert(np.all(np.isclose(arr, arr2))) + +# GENERATE THE POTENTIAL (ENSURE 01_POTENTIAL.PY PASSES BEFORE RUNNING) +positions = trajectory.positions[0] +atom_types = trajectory.atom_types +potential = Potential(xs, ys, zs, positions, atom_types, kind="kirkland") + +# SANITY CHECK THAT OUR CROPPED TRAJECTORY IS CORRECT +#ary=np.asarray(potential.array) +#fig, ax = plt.subplots() +#ax.imshow(np.sum(ary,axis=2), cmap="inferno") +#dx=potential.xs[1]-potential.xs[0] ; dy=potential.ys[1]-potential.ys[0] +#ax.plot(x/dx,y/dy) +#plt.show() +#pr=probes_many.array[5,:,:] +#po=np.sum(potential.array,axis=2) +#fig, ax = plt.subplots() +#ax.imshow(np.absolute(pr)*np.absolute(po), cmap="inferno") +#plt.show() + +# TEST PROPAGATION +# Handle device conversion properly for PyTorch tensors +result = Propagate(probes_many, potential) +result2 = Propagate(probes_many2, potential) + +ary = backend.to_cpu(result) # Convert PyTorch tensor to numpy +ary2 = backend.to_cpu(result2) # Convert PyTorch tensor to numpy + +differ(ary[::2,::2,::2],"outputs/manyprobes-test.npy","EXIT WAVE") +differ(ary2[::2,::2,::2],"outputs/manyprobes-test.npy","EXIT WAVE") +differ_phase(ary2[::2,::2,::2],"outputs/manyprobes-test.npy","EXIT WAVE") +differ_abs(ary2[::2,::2,::2],"outputs/manyprobes-test.npy","EXIT WAVE") + + +print(ary.shape) +ary3 = np.load('outputs/manyprobes-test.npy') +print(ary3.shape) + +# ASSEMBLE HAADF IMAGE +# Convert PyTorch tensors to numpy arrays for k-space calculations +kxs = backend.to_numpy(potential.kxs) +kys = backend.to_numpy(potential.kys) +q=np.sqrt(kxs[:,None]**2+kys[None,:]**2) +fig, ax = plt.subplots() +fft = np.fft.fft2(ary,axes=(1,2))[:,::2,::2]; +print(fft.shape) +fft[:,q[::2,::2]<2] = 0 # mask in reciprocal space (keep only high scattering angles) +ax.imshow(np.absolute(np.fft.fftshift(fft[0]))**.1, cmap="inferno") +plt.savefig("outputs/figs/03_manyprobes2_fft.png") +print(fft.shape) + +fig, ax = plt.subplots() +HAADF=np.sum(np.absolute(fft),axis=(1,2)).reshape((len(x),len(y)))[::2,::2] +ax.imshow(HAADF, cmap="inferno") +plt.savefig("outputs/figs/03_manyprobes2_haadf_fft.png") + + +fft = np.fft.fft2(ary3,axes=(1,2)); +fft[:,q[::2,::2]<2] = 0 # mask in reciprocal space (keep only high scattering angles) +print(fft.shape) +ax.imshow(np.absolute(np.fft.fftshift(fft[0]))**.1, cmap="inferno") +plt.savefig("outputs/figs/03_manyprobes2_fft3.png") +#plt.show() +#fig, ax = plt.subplots() +#HAADF=np.sum(np.absolute(fft),axis=(1,2)).reshape((len(x)//2,len(y)//2)) +#ax.imshow(HAADF, cmap="inferno") +#plt.savefig("outputs/figs/03_manyprobes2_haadf_fft3.png") diff --git a/tests/04_haadf.py b/tests/04_haadf.py index c1d5b3b..f72f694 100644 --- a/tests/04_haadf.py +++ b/tests/04_haadf.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,HAADFData,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,HAADFData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/04_haadf_aberrations.py b/tests/04_haadf_aberrations.py index b141b53..57668aa 100644 --- a/tests/04_haadf_aberrations.py +++ b/tests/04_haadf_aberrations.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,HAADFData,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,HAADFData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/04_haadf_otf.py b/tests/04_haadf_otf.py index d21c521..c240410 100644 --- a/tests/04_haadf_otf.py +++ b/tests/04_haadf_otf.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,HAADFData,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,HAADFData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/05_tacaw.py b/tests/05_tacaw.py index aac3e1c..93b8b9e 100644 --- a/tests/05_tacaw.py +++ b/tests/05_tacaw.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,TACAWData,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,TACAWData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/05_tacaw_chunkFFT.py b/tests/05_tacaw_chunkFFT.py index 63b538b..204e2aa 100644 --- a/tests/05_tacaw_chunkFFT.py +++ b/tests/05_tacaw_chunkFFT.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,TACAWData,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,TACAWData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/05_tacaw_cropped.py b/tests/05_tacaw_cropped.py index 66a677c..f836977 100644 --- a/tests/05_tacaw_cropped.py +++ b/tests/05_tacaw_cropped.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,TACAWData,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,TACAWData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/05_tacaw_otf.py b/tests/05_tacaw_otf.py index 30e651f..67765ee 100644 --- a/tests/05_tacaw_otf.py +++ b/tests/05_tacaw_otf.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,TACAWData,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,TACAWData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/06_loaders.py b/tests/06_loaders.py index 6bf21ea..ff71338 100644 --- a/tests/06_loaders.py +++ b/tests/06_loaders.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,gridFromTrajectory,Potential,differ +from testtools import differ +from pyslice import Loader,gridFromTrajectory,Potential import matplotlib.pyplot as plt import numpy as np diff --git a/tests/07_defocus.py b/tests/07_defocus.py index fb72f18..8bc1596 100644 --- a/tests/07_defocus.py +++ b/tests/07_defocus.py @@ -4,7 +4,9 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,Probe,Propagate,gridFromTrajectory,Potential,MultisliceCalculator,differ +from testtools import differ +from pyslice import Loader,Probe,Propagate,gridFromTrajectory,Potential,MultisliceCalculator +from pyslice.backend import to_numpy import numpy as np import matplotlib.pyplot as plt @@ -48,9 +50,8 @@ array=probe.array[0,0,:,:] # ".array" converts torch tensor to CPU numpy array automatically if required xs_p = probe.xs ; ys_p = probe.ys - if hasattr(xs_p,'cpu'): - xs_p = np.asarray(xs_p.cpu()) # also need to convert to numpy if using Torch/gpu - ys_p = np.asarray(ys_p.cpu()) + xs_p = to_numpy(xs_p) + ys_p = to_numpy(ys_p) CS=plt.contour(xs_p[::3], ys_p[::3], (z+np.absolute(array[::3,::3])/zmax).T) #, levels=lv,alpha=alpha,cmap=cmap) probe.defocus(dz) diff --git a/tests/08_LACBED_iterative.py b/tests/08_LACBED_iterative.py index ff2f125..e3bb39d 100644 --- a/tests/08_LACBED_iterative.py +++ b/tests/08_LACBED_iterative.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,HAADFData,gridFromTrajectory,Potential,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,HAADFData,gridFromTrajectory,Potential import numpy as np import matplotlib.pyplot as plt diff --git a/tests/08_LACBED_onthefly.py b/tests/08_LACBED_onthefly.py index 247df14..b99b7a8 100644 --- a/tests/08_LACBED_onthefly.py +++ b/tests/08_LACBED_onthefly.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,HAADFData,gridFromTrajectory,Potential,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,HAADFData,gridFromTrajectory,Potential import numpy as np import matplotlib.pyplot as plt diff --git a/tests/11_SED.py b/tests/11_SED.py index 89bbab2..95260a3 100644 --- a/tests/11_SED.py +++ b/tests/11_SED.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,SEDCalculator,SED,TACAWData,differ +from testtools import differ +from pyslice import Loader,SEDCalculator,SED,TACAWData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/12_aberrations.py b/tests/12_aberrations.py index 58b56d0..4210485 100644 --- a/tests/12_aberrations.py +++ b/tests/12_aberrations.py @@ -4,21 +4,24 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,Probe,Propagate,gridFromTrajectory,Potential,MultisliceCalculator,differ -#from pyslice.backend import xp, to_cpu +from testtools import differ +from pyslice import Loader,Probe,Propagate,grid_from_trajectory,Potential,MultisliceCalculator +from pyslice.backend import make_backend import numpy as np import matplotlib.pyplot as plt import os,shutil from tqdm import tqdm +backend = make_backend() + # PROBE xs=np.linspace(0,70,701) ys=np.linspace(0,69,691) eVs = np.linspace(80,120,50) weighting = np.exp(-(eVs-100)**2/6**2) plt.plot(eVs,weighting) ; plt.savefig("outputs/figs/12_aberrations_espread.png") -probes = [ Probe(xs,ys,mrad=30,eV=eV*1e3) for eV in eVs ] +probes = [ Probe(xs,ys,mrad=30,eV=eV*1e3,backend=backend) for eV in eVs ] # does it matter whether you aberrate the focused or defocused probe? i don't think so?? # Andy has: r = np.sqrt(x*x + y*y) ; theta = np.arctan2(x,y) diff --git a/tests/18_caching.py b/tests/18_caching.py index b79aa7c..9add79a 100644 --- a/tests/18_caching.py +++ b/tests/18_caching.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,HAADFData,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,HAADFData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/20_probepositions.py b/tests/20_probepositions.py index c6ad4fd..b3ea05b 100644 --- a/tests/20_probepositions.py +++ b/tests/20_probepositions.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,HAADFData,differ,gridFromTrajectory,Potential +from testtools import differ +from pyslice import Loader,MultisliceCalculator,HAADFData,gridFromTrajectory,Potential import numpy as np import matplotlib.pyplot as plt diff --git a/tests/21_memorytests.py b/tests/21_memorytests.py index ac6321a..3e43697 100644 --- a/tests/21_memorytests.py +++ b/tests/21_memorytests.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,HAADFData,TACAWData,differ,gridFromTrajectory,Potential +from testtools import differ +from pyslice import Loader,MultisliceCalculator,HAADFData,TACAWData,gridFromTrajectory,Potential import numpy as np import matplotlib.pyplot as plt diff --git a/tests/22_prism.py b/tests/22_prism.py index 9bd49c4..9f16525 100644 --- a/tests/22_prism.py +++ b/tests/22_prism.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,HAADFData,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,HAADFData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/23_counts.py b/tests/23_counts.py index ff612d1..e476653 100644 --- a/tests/23_counts.py +++ b/tests/23_counts.py @@ -4,7 +4,8 @@ except ModuleNotFoundError: sys.path.insert(0, '../src') -from pyslice import Loader,MultisliceCalculator,HAADFData,differ +from testtools import differ +from pyslice import Loader,MultisliceCalculator,HAADFData import numpy as np import matplotlib.pyplot as plt diff --git a/tests/test_backend.py b/tests/test_backend.py new file mode 100644 index 0000000..928d11e --- /dev/null +++ b/tests/test_backend.py @@ -0,0 +1,494 @@ +"""Unit tests for pyslice/backend.py""" +import os +import tempfile + +import numpy as np +import pytest + +from pyslice.backend import ( + NumpyBackend, + Backend, + make_backend, + to_cpu, + to_numpy, + TORCH_AVAILABLE, +) + +if TORCH_AVAILABLE: + import torch + from pyslice.backend import TorchBackend + + +# --------------------------------------------------------------------------- +# Helpers / fixtures +# --------------------------------------------------------------------------- + +@pytest.fixture +def numpy_backend(): + return NumpyBackend() + + +@pytest.fixture(params=["numpy", pytest.param("torch", marks=pytest.mark.skipif( + not TORCH_AVAILABLE, reason="PyTorch not available"))]) +def backend(request): + if request.param == "numpy": + return NumpyBackend() + return TorchBackend(device="cpu") + + +def to_np(x): + """Coerce any array-like to a plain numpy array for assertions.""" + return to_numpy(x) + + +# --------------------------------------------------------------------------- +# to_cpu / to_numpy +# --------------------------------------------------------------------------- + +class TestStandaloneConversions: + def test_to_cpu_numpy_passthrough(self): + a = np.array([1.0, 2.0]) + assert to_cpu(a) is a + + def test_to_cpu_scalar(self): + assert to_cpu(3.14) == 3.14 + + def test_to_numpy_list(self): + result = to_numpy([1, 2, 3]) + assert isinstance(result, np.ndarray) + np.testing.assert_array_equal(result, [1, 2, 3]) + + def test_to_numpy_numpy_array(self): + a = np.array([1.0, 2.0]) + result = to_numpy(a) + assert isinstance(result, np.ndarray) + np.testing.assert_array_equal(result, a) + + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="PyTorch not available") + def test_to_cpu_torch_tensor(self): + t = torch.tensor([1.0, 2.0]) + result = to_cpu(t) + assert isinstance(result, torch.Tensor) + assert result.device.type == "cpu" + + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="PyTorch not available") + def test_to_numpy_torch_tensor(self): + t = torch.tensor([1.0, 2.0], dtype=torch.float64) + result = to_numpy(t) + assert isinstance(result, np.ndarray) + np.testing.assert_allclose(result, [1.0, 2.0]) + + +# --------------------------------------------------------------------------- +# make_backend factory +# --------------------------------------------------------------------------- + +class TestMakeBackend: + def test_returns_numpy_when_forced(self, monkeypatch): + monkeypatch.setenv("PYSLICE_BACKEND", "numpy") + b = make_backend() + assert isinstance(b, NumpyBackend) + + def test_returns_backend_instance(self): + b = make_backend() + assert isinstance(b, Backend) + + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="PyTorch not available") + def test_returns_torch_when_available(self, monkeypatch): + monkeypatch.delenv("PYSLICE_BACKEND", raising=False) + b = make_backend(device="cpu") + assert isinstance(b, TorchBackend) + + +# --------------------------------------------------------------------------- +# NumpyBackend — array creation +# --------------------------------------------------------------------------- + +class TestNumpyBackendCreation: + def test_asarray_default_dtype(self, numpy_backend): + a = numpy_backend.asarray([1, 2, 3]) + assert a.dtype == np.float64 + + def test_asarray_explicit_dtype(self, numpy_backend): + a = numpy_backend.asarray([1, 2, 3], dtype=np.float32) + assert a.dtype == np.float32 + + def test_asarray_strips_imag_for_float_dtype(self, numpy_backend): + c = np.array([1 + 2j, 3 + 4j]) + a = numpy_backend.asarray(c, dtype=np.float64) + np.testing.assert_array_equal(a, [1.0, 3.0]) + + def test_zeros_shape(self, numpy_backend): + a = numpy_backend.zeros((3, 4)) + assert a.shape == (3, 4) + assert np.all(a == 0) + + def test_zeros_dtype_string_float(self, numpy_backend): + a = numpy_backend.zeros((2,), dtype="float") + assert a.dtype == np.float64 + + def test_zeros_dtype_string_complex(self, numpy_backend): + a = numpy_backend.zeros((2,), dtype="complex") + assert a.dtype == np.complex128 + + def test_zeros_dtype_string_int(self, numpy_backend): + a = numpy_backend.zeros((2,), dtype="int") + assert a.dtype == np.int64 + + def test_zeros_type_match(self, numpy_backend): + ref = np.zeros(1, dtype=np.complex64) + a = numpy_backend.zeros((3,), type_match=ref) + assert a.dtype == np.complex64 + + def test_ones_shape_and_values(self, numpy_backend): + a = numpy_backend.ones((2, 3)) + assert a.shape == (2, 3) + assert np.all(a == 1) + + def test_fftfreq_length(self, numpy_backend): + f = numpy_backend.fftfreq(8, d=1.0) + expected = np.fft.fftfreq(8, 1.0) + np.testing.assert_allclose(f, expected) + + def test_randfloats_shape_and_range(self, numpy_backend): + r = numpy_backend.randfloats(100) + assert r.shape == (100,) + assert r.min() >= 0.0 + assert r.max() < 1.0 + + def test_memmap_no_filename_returns_zeros(self, numpy_backend): + a = numpy_backend.memmap((4, 4)) + assert a.shape == (4, 4) + assert np.all(a == 0) + + def test_memmap_with_filename(self, numpy_backend): + with tempfile.NamedTemporaryFile(suffix=".npy", delete=False) as f: + fname = f.name + try: + mm = numpy_backend.memmap((3, 3), dtype=np.float32, filename=fname) + assert mm.shape == (3, 3) + assert mm.dtype == np.float32 + finally: + os.unlink(fname) + + +# --------------------------------------------------------------------------- +# Backend — shared operations (parametrised over both backends) +# --------------------------------------------------------------------------- + +class TestBackendOperations: + def test_astype(self, backend): + a = backend.asarray([1.0, 2.0]) + b = backend.astype(a, backend.complex_dtype) + np_b = to_np(b) + assert np_b.dtype in (np.complex64, np.complex128) + + def test_ones_like(self, backend): + a = backend.asarray([3.0, 4.0]) + b = backend.ones_like(a) + np.testing.assert_array_equal(to_np(b), [1.0, 1.0]) + + def test_clone_is_independent(self, backend): + a = backend.asarray([1.0, 2.0, 3.0]) + b = backend.clone(a) + np_a = to_np(a).copy() + # Mutate original (numpy); check b is unaffected + if isinstance(a, np.ndarray): + a[0] = 99.0 + assert to_np(b)[0] == np_a[0] + + # ------------------------------------------------------------------ + # FFT family + # ------------------------------------------------------------------ + + def test_fft_roundtrip(self, backend): + data = backend.asarray(np.random.rand(8)) + result = backend.ifft(backend.fft(data)) + np.testing.assert_allclose(to_np(result).real, to_np(data), atol=1e-10) + + def test_fft_with_axis(self, backend): + # axes kwarg must be translated correctly (axis= for numpy, dim= for torch) + data = backend.asarray(np.random.rand(4, 8)) + result = backend.ifft(backend.fft(data, axes=1), axes=1) + np.testing.assert_allclose(to_np(result).real, to_np(data), atol=1e-10) + + def test_fft2_roundtrip(self, backend): + data = backend.asarray(np.random.rand(8, 8)) + result = backend.ifft2(backend.fft2(data)) + np.testing.assert_allclose(to_np(result).real, to_np(data), atol=1e-10) + + def test_fft2_with_axes(self, backend): + data = backend.asarray(np.random.rand(4, 8, 8)) + result = backend.ifft2(backend.fft2(data, axes=(-2, -1)), axes=(-2, -1)) + np.testing.assert_allclose(to_np(result).real, to_np(data), atol=1e-10) + + def test_fftshift_ifftshift_roundtrip(self, backend): + data = backend.asarray(np.arange(8, dtype=np.float64)) + shifted = backend.fftshift(data) + restored = backend.ifftshift(shifted) + np.testing.assert_array_equal(to_np(restored), to_np(data)) + + def test_fftshift_with_axes(self, backend): + data = backend.asarray(np.random.rand(4, 8)) + shifted = backend.fftshift(data, axes=1) + restored = backend.ifftshift(shifted, axes=1) + np.testing.assert_allclose(to_np(restored), to_np(data), atol=1e-10) + + # ------------------------------------------------------------------ + # Reductions + # ------------------------------------------------------------------ + + def test_sum_all(self, backend): + a = backend.asarray([1.0, 2.0, 3.0]) + assert float(to_np(backend.sum(a))) == pytest.approx(6.0) + + def test_sum_axis(self, backend): + a = backend.asarray(np.array([[1.0, 2.0], [3.0, 4.0]])) + s = to_np(backend.sum(a, axis=0)) + np.testing.assert_allclose(s, [4.0, 6.0]) + + def test_sum_keepdims(self, backend): + a = backend.asarray(np.ones((3, 4))) + s = backend.sum(a, axis=1, keepdims=True) + assert to_np(s).shape == (3, 1) + + def test_mean_all(self, backend): + a = backend.asarray([2.0, 4.0, 6.0]) + assert float(to_np(backend.mean(a))) == pytest.approx(4.0) + + def test_cumsum(self, backend): + a = backend.asarray([1.0, 2.0, 3.0]) + cs = to_np(backend.cumsum(a, axis=0)) + np.testing.assert_allclose(cs, [1.0, 3.0, 6.0]) + + def test_any_true(self, backend): + a = backend.asarray([0.0, 1.0, 0.0]) + assert bool(backend.any(a > 0.5)) + + def test_any_false(self, backend): + a = backend.asarray([0.0, 0.0, 0.0]) + assert not bool(backend.any(a > 0.5)) + + # ------------------------------------------------------------------ + # Shape manipulation + # ------------------------------------------------------------------ + + def test_reshape(self, backend): + a = backend.asarray(np.arange(6, dtype=np.float64)) + b = backend.reshape(a, (2, 3)) + assert to_np(b).shape == (2, 3) + + def test_expand_dims(self, backend): + a = backend.asarray([1.0, 2.0, 3.0]) + b = backend.expand_dims(a, 0) + assert to_np(b).shape == (1, 3) + + def test_stack(self, backend): + a = backend.asarray([1.0, 2.0]) + b = backend.asarray([3.0, 4.0]) + s = to_np(backend.stack([a, b], axis=0)) + assert s.shape == (2, 2) + np.testing.assert_allclose(s[0], [1.0, 2.0]) + np.testing.assert_allclose(s[1], [3.0, 4.0]) + + def test_roll(self, backend): + a = backend.asarray([1.0, 2.0, 3.0, 4.0]) + r = to_np(backend.roll(a, 1, axis=0)) + np.testing.assert_array_equal(r, [4.0, 1.0, 2.0, 3.0]) + + # ------------------------------------------------------------------ + # Elementwise math + # ------------------------------------------------------------------ + + def test_absolute(self, backend): + a = backend.asarray([-1.0, 2.0, -3.0]) + result = to_np(backend.absolute(a)) + np.testing.assert_allclose(result, [1.0, 2.0, 3.0]) + + def test_sqrt(self, backend): + a = backend.asarray([4.0, 9.0, 16.0]) + result = to_np(backend.sqrt(a)) + np.testing.assert_allclose(result, [2.0, 3.0, 4.0]) + + def test_exp(self, backend): + a = backend.asarray([0.0, 1.0]) + result = to_np(backend.exp(a)) + np.testing.assert_allclose(result, [1.0, np.e], rtol=1e-6) + + def test_log(self, backend): + a = backend.asarray([1.0, np.e]) + result = to_np(backend.log(a)) + np.testing.assert_allclose(result, [0.0, 1.0], atol=1e-10) + + def test_real(self, backend): + c = backend.asarray(np.array([1 + 2j]), dtype=backend.complex_dtype) + result = to_np(backend.real(c)) + np.testing.assert_allclose(result, [1.0]) + + def test_cos(self, backend): + a = backend.asarray([0.0]) + np.testing.assert_allclose(to_np(backend.cos(a)), [1.0], atol=1e-10) + + def test_isnan(self, backend): + a = backend.asarray([float("nan"), 1.0]) + mask = to_np(backend.isnan(a)) + assert mask[0] == True + assert mask[1] == False + + def test_ceil_scalar(self, backend): + assert backend.ceil(2.3) == 3 + assert isinstance(backend.ceil(2.3), int) + + # ------------------------------------------------------------------ + # Array construction helpers + # ------------------------------------------------------------------ + + def test_arange(self, backend): + a = to_np(backend.arange(5)) + np.testing.assert_array_equal(a, [0, 1, 2, 3, 4]) + + def test_linspace(self, backend): + a = to_np(backend.linspace(0.0, 1.0, num=5)) + np.testing.assert_allclose(a, np.linspace(0.0, 1.0, 5)) + + def test_amin_amax(self, backend): + a = backend.asarray([3.0, 1.0, 4.0, 1.0, 5.0]) + assert float(to_np(backend.amin(a))) == pytest.approx(1.0) + assert float(to_np(backend.amax(a))) == pytest.approx(5.0) + + def test_argwhere(self, backend): + a = backend.asarray([0.0, 1.0, 0.0, 2.0]) + idx = to_np(backend.argwhere(a > 0.5)) + assert set(idx.flatten().tolist()) == {1, 3} + + # ------------------------------------------------------------------ + # Einsum + # ------------------------------------------------------------------ + + def test_einsum_matrix_vector(self, backend): + A = backend.asarray(np.eye(3)) + v = backend.asarray([1.0, 2.0, 3.0]) + result = to_np(backend.einsum("ij,j->i", A, v)) + np.testing.assert_allclose(result, [1.0, 2.0, 3.0]) + + # ------------------------------------------------------------------ + # Histogram (always numpy-backed) + # ------------------------------------------------------------------ + + def test_histogram(self, backend): + a = backend.asarray(np.array([0.5, 1.5, 2.5, 3.5])) + counts, edges = backend.histogram(a, bins=np.array([0.0, 1.0, 2.0, 3.0, 4.0])) + assert isinstance(counts, np.ndarray) + np.testing.assert_array_equal(counts, [1, 1, 1, 1]) + + # ------------------------------------------------------------------ + # pi property + # ------------------------------------------------------------------ + + def test_pi(self, backend): + assert backend.pi == pytest.approx(np.pi) + + # ------------------------------------------------------------------ + # chunk_ids static method + # ------------------------------------------------------------------ + + def test_chunk_ids_exact_division(self): + chunks = Backend.chunk_ids(9, chunksize=3) + assert len(chunks) == 3 + np.testing.assert_array_equal(chunks[0], [0, 1, 2]) + np.testing.assert_array_equal(chunks[2], [6, 7, 8]) + + def test_chunk_ids_partial_last_chunk(self): + chunks = Backend.chunk_ids(10, chunksize=3) + assert len(chunks) == 4 + np.testing.assert_array_equal(chunks[-1], [9]) + + def test_chunk_ids_empty(self): + assert Backend.chunk_ids(0) == [] + + +# --------------------------------------------------------------------------- +# TorchBackend-specific tests +# --------------------------------------------------------------------------- + +@pytest.mark.skipif(not TORCH_AVAILABLE, reason="PyTorch not available") +class TestTorchBackend: + def test_device_defaults_to_cpu(self, monkeypatch): + monkeypatch.delenv("PYSLICE_DEVICE", raising=False) + b = TorchBackend(device="cpu") + assert b.device == torch.device("cpu") + + def test_device_env_override(self, monkeypatch): + monkeypatch.setenv("PYSLICE_DEVICE", "cpu") + b = TorchBackend() + assert b.device.type == "cpu" + + def test_float_dtype_cpu(self, monkeypatch): + monkeypatch.delenv("PYSLICE_DEVICE", raising=False) + b = TorchBackend(device="cpu") + assert b.float_dtype == torch.float64 + + def test_complex_dtype_cpu(self, monkeypatch): + monkeypatch.delenv("PYSLICE_DEVICE", raising=False) + b = TorchBackend(device="cpu") + assert b.complex_dtype == torch.complex128 + + def test_asarray_returns_tensor(self): + b = TorchBackend(device="cpu") + t = b.asarray([1.0, 2.0]) + assert isinstance(t, torch.Tensor) + + def test_asarray_strips_imag(self): + b = TorchBackend(device="cpu") + c = np.array([1 + 2j, 3 + 4j]) + t = b.asarray(c, dtype=torch.float64) + np.testing.assert_array_equal(to_np(t), [1.0, 3.0]) + + def test_zeros_returns_tensor(self): + b = TorchBackend(device="cpu") + z = b.zeros((2, 3)) + assert isinstance(z, torch.Tensor) + assert z.shape == torch.Size([2, 3]) + + def test_zeros_type_match_numpy_returns_numpy(self): + b = TorchBackend(device="cpu") + ref = np.zeros(1, dtype=np.float64) + z = b.zeros((4,), type_match=ref) + assert isinstance(z, np.ndarray) + + def test_fftfreq_returns_tensor(self): + b = TorchBackend(device="cpu") + f = b.fftfreq(8) + assert isinstance(f, torch.Tensor) + + def test_randfloats_returns_tensor(self): + b = TorchBackend(device="cpu") + r = b.randfloats(50) + assert isinstance(r, torch.Tensor) + assert r.shape == torch.Size([50]) + + def test_resolve_dtype_string_float(self): + b = TorchBackend(device="cpu") + dtype, _ = b._resolve_dtype_device("float", None, None) + assert dtype == torch.float64 + + def test_resolve_dtype_string_complex(self): + b = TorchBackend(device="cpu") + dtype, _ = b._resolve_dtype_device("complex", None, None) + assert dtype == torch.complex128 + + def test_resolve_dtype_string_int(self): + b = TorchBackend(device="cpu") + dtype, _ = b._resolve_dtype_device("int", None, None) + assert dtype == torch.int64 + + def test_not_available_raises_without_torch(self, monkeypatch): + import pyslice.backend as bmod + orig = bmod.TORCH_AVAILABLE + monkeypatch.setattr(bmod, "TORCH_AVAILABLE", False) + with pytest.raises(RuntimeError): + TorchBackend.__new__(TorchBackend) + # The __init__ check fires + b = TorchBackend.__new__(TorchBackend) + b.__init__() + monkeypatch.setattr(bmod, "TORCH_AVAILABLE", orig) diff --git a/tests/testtools.py b/tests/testtools.py new file mode 100644 index 0000000..4b039c6 --- /dev/null +++ b/tests/testtools.py @@ -0,0 +1,89 @@ +""" +Test utilities for comparing simulation outputs across runs. +""" +from __future__ import annotations + +import os +import numpy as np + +from pyslice.backend import to_numpy + + +# to have matplotlib withoput display issues on headless machines +os.environ['MPLBACKEND'] = 'Agg' + + +def differ_phase(ary, filename: str, label: str, tol: float = 1e-6) -> None: + """Compare the phase of an array against a saved reference.""" + ary = to_numpy(ary) + if not os.path.exists(filename): + print(f"Reference file for {label!r} (phase) does not exist — creating it now.") + np.save(filename, ary) + return + previous = np.load(filename) + F = np.angle(ary) + D = np.angle(previous) + denom = np.sum(F ** 2) + if denom == 0: + print(f"WARNING: {label} (phase) — reference array phase is all zeros; skipping comparison.") + return + dz = np.sum((F - D) ** 2) / denom + if dz > tol: + print(f"ERROR! {label} (phase) does not match previous run — residual {dz * 100:.4f}%") + else: + print(f"OK: {label} (phase) matches previous run (residual {dz * 100:.6f}%)") + + +def differ_abs(ary, filename: str, label: str, tol: float = 1e-6) -> None: + """Compare the absolute value of an array against a saved reference.""" + ary = to_numpy(ary) + if not os.path.exists(filename): + print(f"Reference file for {label!r} (abs) does not exist — creating it now.") + np.save(filename, ary) + return + previous = np.load(filename) + F = np.abs(ary) + D = np.abs(previous) + denom = np.sum(F ** 2) + if denom == 0: + print(f"WARNING: {label} (abs) — reference array is all zeros; skipping comparison.") + return + dz = np.sum((F - D) ** 2) / denom + if dz > tol: + print(f"ERROR! {label} (abs) does not match previous run — residual {dz * 100:.4f}%") + else: + print(f"OK: {label} (abs) matches previous run (residual {dz * 100:.6f}%)") + + +def differ(ary, filename: str, label: str, tol: float = 1e-6) -> None: + """ + Compare an array against a saved reference, creating it if absent. + + The residual is scale- and near-zero-resistant: + dz = Σ(|F| - |D|)² / Σ|F|² + + Args: + ary: Array to test (any backend type — converted to numpy internally). + filename: Path to the reference .npy file. + label: Human-readable name printed in the error message. + tol: Residual threshold above which a mismatch is reported. + """ + ary = to_numpy(ary) + + if not os.path.exists(filename): + print(f"Reference file for {label!r} does not exist — creating it now.") + np.save(filename, ary) + return + + previous = np.load(filename) + F = np.abs(ary) + D = np.abs(previous) + denom = np.sum(F ** 2) + if denom == 0: + print(f"WARNING: {label} — reference array is all zeros; skipping comparison.") + return + dz = np.sum((F - D) ** 2) / denom + if dz > tol: + print(f"ERROR! {label} does not match previous run — residual {dz * 100:.4f}%") + else: + print(f"OK: {label} matches previous run (residual {dz * 100:.6f}%)") From fdb49eaab5efe7b00adbcb73b87b4bfa4a38ce59 Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Sat, 28 Mar 2026 20:56:10 -0700 Subject: [PATCH 12/14] Added ROCm 7.0 devcontainer --- .../dev-ubuntu24.04_rocm7.0/Dockerfile | 41 +++++++++++++++++++ .../dev-ubuntu24.04_rocm7.0/devcontainer.json | 40 ++++++++++++++++++ 2 files changed, 81 insertions(+) create mode 100644 .devcontainer/dev-ubuntu24.04_rocm7.0/Dockerfile create mode 100644 .devcontainer/dev-ubuntu24.04_rocm7.0/devcontainer.json diff --git a/.devcontainer/dev-ubuntu24.04_rocm7.0/Dockerfile b/.devcontainer/dev-ubuntu24.04_rocm7.0/Dockerfile new file mode 100644 index 0000000..faabd00 --- /dev/null +++ b/.devcontainer/dev-ubuntu24.04_rocm7.0/Dockerfile @@ -0,0 +1,41 @@ +# Use ROCm build container on Ubuntu 24.04 as base +ARG ROCM_VERSION="7.0.2" +FROM rocm/dev-ubuntu-24.04:${ROCM_VERSION}-complete +ENV ROCM_VERSION="${ROCM_VERSION}" + +# Copy uv into image +COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ + +# Ensure system packages are up to date and install dependencies +RUN << 'EOF' +apt-get update +apt-get -y full-upgrade +apt-get install -y libglib2.0-0 \ + git \ + libegl1 \ + libfontconfig1 \ + libxkbcommon-x11-0 \ + libdbus-1-3 \ + libopengl0 +apt-get clean && rm -rf /var/lib/apt/lists/* +EOF + +# Set up Python virtual environment and upgrade pip and setuptools +USER ubuntu +WORKDIR /home/ubuntu + +RUN curl -fsSL https://claude.ai/install.sh | bash + +# Ensure the installed binary is on the `PATH` +ENV PATH="/home/ubuntu/.local/bin/:$PATH" + +ENV VIRTUAL_ENV="/home/ubuntu/venv" +RUN uv venv $VIRTUAL_ENV --python 3.11 +RUN uv pip install --no-cache-dir --upgrade pip setuptools wheel +RUN uv pip install --no-cache-dir --pre torch torchvision --index-url https://download.pytorch.org/whl/nightly/rocm7.0 + +ENV PATH="$VIRTUAL_ENV/bin:$PATH" + +# This is a supposed fix to help with gfx1151 +# See: https://github.com/pytorch/pytorch/issues/164346 +ENV HSA_OVERRIDE_GFX_VERSION="11.0.0" diff --git a/.devcontainer/dev-ubuntu24.04_rocm7.0/devcontainer.json b/.devcontainer/dev-ubuntu24.04_rocm7.0/devcontainer.json new file mode 100644 index 0000000..4cab1af --- /dev/null +++ b/.devcontainer/dev-ubuntu24.04_rocm7.0/devcontainer.json @@ -0,0 +1,40 @@ +// For format details, see https://aka.ms/devcontainer.json. For config options, see the +// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-dockerfile +{ + "name": "Dev Ubuntu 24.04 ROCm 7.0", + "build": { + "dockerfile": "Dockerfile" + }, + "postCreateCommand": "uv pip install --no-cache-dir -r requirements.txt && uv pip --no-cache-dir install -e .[test,md] && uv pip install notebook xarray", + "postStartCommand": "nohup bash -c 'jupyter notebook --ip=0.0.0.0 --port=8888 --allow-root --NotebookApp.token='' --no-browser > nohup.out &'", + "forwardPorts": [ + 8888 + ], + + // Configure tool-specific properties. + "customizations": { + // Configure properties specific to VS Code. + "vscode": { + // Add the IDs of extensions you want installed when the container is created. + "extensions": [ + "ms-python.python", + "ms-python.vscode-pylance", + "anthropic.claude-code", + "ms-python.pylint", + "eamodio.gitlens", + "usernamehw.errorlens", + "ms-azuretools.vscode-docker" + ] + } + }, + "runArgs": ["--cap-add=SYS_PTRACE", + "--security-opt", + "seccomp=unconfined", + "--device=/dev/kfd", + "--device=/dev/dri", + "--group-add=video", + "--ipc=host", + "--shm-size", + "8G"] + +} From 2cd62f6151e82fd246011ad0a645f3b6c1a29eff Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Sat, 28 Mar 2026 21:41:12 -0700 Subject: [PATCH 13/14] Fixed some minor bugs around chunking in TACAW calculations and added functions to trajectory deleted by mistake --- src/pyslice/multislice/trajectory.py | 7 + src/pyslice/postprocessing/tacaw_data.py | 21 +- tests/test_pyslice_abtem.ipynb | 294 +++++++++++------------ 3 files changed, 165 insertions(+), 157 deletions(-) diff --git a/src/pyslice/multislice/trajectory.py b/src/pyslice/multislice/trajectory.py index ee27655..d3a9841 100644 --- a/src/pyslice/multislice/trajectory.py +++ b/src/pyslice/multislice/trajectory.py @@ -94,6 +94,12 @@ def select_timesteps(self, indices) -> Trajectory: """Select specific frames by index array.""" if indices is None: indices = slice(0, len(self.positions)) + # Scalar or tuple indexing collapses the frame axis to 2-D; force list to + # preserve the (frames, atoms, 3) shape. + if isinstance(indices, (int, np.integer)): + indices = [indices] + elif isinstance(indices, tuple): + indices = list(indices) return Trajectory( atom_types=self.atom_types, positions=self.positions[indices], @@ -224,6 +230,7 @@ def random_frames(self, N: int, seed: Optional[int] = None) -> Trajectory: def generate_random_displacements(self, n_displacements: int, sigma: float, seed: Optional[int] = None) -> Trajectory: + """Generate random displacements from the mean position with given std dev.""" rng = np.random.default_rng(seed) na = self.n_atoms dxyz = rng.normal(0, sigma / np.sqrt(3), size=(n_displacements, na, 3)) diff --git a/src/pyslice/postprocessing/tacaw_data.py b/src/pyslice/postprocessing/tacaw_data.py index f0a0904..a3719ce 100644 --- a/src/pyslice/postprocessing/tacaw_data.py +++ b/src/pyslice/postprocessing/tacaw_data.py @@ -153,14 +153,21 @@ def _fft_from_wf_data(self, layer_index: Optional[int] = None): wf_layer = self._wf_array[:, :, :, :, layer_index] # p,t,kx,ky + if self.chunk_size_time is None: self.n_chunks = 1 else: - self.n_chunks = len(self._time) // self.chunk_size_time + if self.chunk_size_time <= 0: + raise ValueError("chunk_size_time must be a positive integer") + elif self.chunk_size_time > len(self._time): + raise ValueError("chunk_size_time cannot exceed total time length") + else: + self.n_chunks = len(self._time) // self.chunk_size_time - indices = b.astype(b.linspace(0, len(self._time), self.n_chunks + 1), int) + indices = np.linspace(0, len(self._time), self.n_chunks + 1) + fft_len = self.chunk_size_time if self.chunk_size_time is not None else len(self._time) dt = float(to_numpy(self._time[1] - self._time[0])) - self._frequencies = b.fftshift(b.fftfreq(self.n_chunks, d=dt)) + self._frequencies = b.fftshift(b.fftfreq(fft_len, d=dt)) if self.chunkFFT: # Memory-conservative path: loop over kx @@ -225,8 +232,8 @@ def spectrum_image(self, frequency: float, freq_idx = int(np.argmin(np.abs(self.frequencies - frequency))) if probe_indices is None: probe_indices = list(range(len(self.probe_positions))) - return to_numpy([b.sum(self._array[p, freq_idx, :, :]) - for p in probe_indices]) + return np.array([to_numpy(b.sum(self._array[p, freq_idx, :, :])) for p in probe_indices]) + def diffraction(self, probe_index: Optional[int] = None, space: str = "reciprocal") -> np.ndarray: @@ -317,12 +324,12 @@ def dispersion(self, kx_path: np.ndarray, ky_path: np.ndarray, probe_indices = (np.arange(len(self.probe_positions)) if probe_index is None else [probe_index]) n_freq = len(self.frequencies) - dispersion = np.zeros((n_freq, len(kx_indices)), dtype=complex) + dispersion = np.zeros((n_freq, len(kx_indices)), dtype=np.double) for w in range(n_freq): w_slice = self._array[probe_indices, w, :, :] if space == "real": - w_slice = b.ifft2(w_slice, axes=(1, 2)) + w_slice = b.fftshift(b.fft2(w_slice, axes=(1, 2)), axes=(1, 2)) w_np = np.mean(to_numpy(w_slice), axis=0) for i, (ki, kj) in enumerate(zip(kx_indices, ky_indices)): dispersion[w, i] = w_np[ki, kj] diff --git a/tests/test_pyslice_abtem.ipynb b/tests/test_pyslice_abtem.ipynb index f9d191c..2b7ce7f 100644 --- a/tests/test_pyslice_abtem.ipynb +++ b/tests/test_pyslice_abtem.ipynb @@ -22,7 +22,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "cpu \n", "failed to import pySEA: No module named 'pySEA'\n", "loaded\n", "Created hBN supercell: 4000 atoms, box = 50.1 × 43.4 Å\n", @@ -33,7 +32,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Processing frames: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:25<00:00, 2.55s/frame]\n" + "Processing frames: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:30<00:00, 3.06s/frame]\n" ] }, { @@ -65,7 +64,7 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from ase import Atoms\n", - "from pyslice import Loader, MultisliceCalculator, Potential\n", + "from pyslice import Loader, MultisliceCalculator, Potential, TACAWData\n", "\n", "print('loaded')\n", "\n", @@ -165,17 +164,62 @@ "potential_pyslice = Potential(\n", " calc.xs, calc.ys, calc.zs,\n", " trajectory.positions[0], list(trajectory.atom_types),\n", - " kind=\"kirkland\", device=calc.device, slice_axis=calc.slice_axis,\n", + " backend=calc._backend,\n", + " kind=\"kirkland\", slice_axis=calc.slice_axis,\n", ")\n", "potential_pyslice.build()\n", "potential_pyslice.plot(filename=\"outputs/tem_potential.png\")\n", "plt.close()\n", - "print(\"Saved projected potential (optional diagnostic)\")" + "print(\"Saved projected potential (optional diagnostic)\")\n", + "\n", + "tacaw = TACAWData(wf) #, chunkFFT=True, chunk_size_time=CHUNK_LENGTH)" ] }, { "cell_type": "code", "execution_count": 3, + "id": "4e3e5032-3f44-4c82-889c-588d0eeefb3d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([3.66863378e+09])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tacaw.spectrum_image(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5423ea13-41a3-4364-97ca-25c92dcd9484", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trajectory.n_frames" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "id": "5f4022fe-1a4b-498b-8fe5-4b211fae922c", "metadata": {}, "outputs": [ @@ -185,13 +229,13 @@ "(-50.0, 50.0)" ] }, - "execution_count": 3, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -232,23 +276,23 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "89484d18-cd55-4734-b5bc-4cac80a3d0c7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 4, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -276,23 +320,23 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "bd4bfc63-44ac-4870-8c64-983464c3da1f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 5, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -320,25 +364,25 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "e25f68e4-ca3e-4f61-945a-f891e03b54ba", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([7.56378678e+11, 7.56378675e+11, 7.56378726e+11, 7.56378677e+11,\n", - " 7.56378682e+11, 7.56378677e+11, 7.56378701e+11, 7.56378715e+11,\n", - " 7.56378734e+11, 7.56378688e+11])" + "array([7.56378713e+11, 7.56378699e+11, 7.56378709e+11, 7.56378697e+11,\n", + " 7.56378736e+11, 7.56378713e+11, 7.56378742e+11, 7.56378691e+11,\n", + " 7.56378721e+11, 7.56378743e+11])" ] }, - "execution_count": 6, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from pyslice import backend\n", + "backend = wf._backend\n", "backend.sum(backend.absolute(wf.array)**2, axis=(0,2,3,4))" ] }, @@ -352,28 +396,24 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "e1c46c22-0cd9-4513-a6fa-27951410935d", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "[Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", - " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", - " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", - " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", - " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", - " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", - " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", - " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", - " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", - " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96])]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" + "ename": "ValueError", + "evalue": "positions must be (frames, atoms, 3), got (4000, 3)", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m atoms_test = [\u001b[43mtrajectory\u001b[49m\u001b[43m.\u001b[49m\u001b[43mselect_timesteps\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m.to_ase() \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(trajectory.n_frames)]\n\u001b[32m 2\u001b[39m atoms_test\n", + "\u001b[36mFile \u001b[39m\u001b[32m/var/home/pzeiger/code/PySlice/src/pyslice/multislice/trajectory.py:97\u001b[39m, in \u001b[36mTrajectory.select_timesteps\u001b[39m\u001b[34m(self, indices)\u001b[39m\n\u001b[32m 95\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m indices \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 96\u001b[39m indices = \u001b[38;5;28mslice\u001b[39m(\u001b[32m0\u001b[39m, \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m.positions))\n\u001b[32m---> \u001b[39m\u001b[32m97\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mTrajectory\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 98\u001b[39m \u001b[43m \u001b[49m\u001b[43matom_types\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43matom_types\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 99\u001b[39m \u001b[43m \u001b[49m\u001b[43mpositions\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mpositions\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindices\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 100\u001b[39m \u001b[43m \u001b[49m\u001b[43mvelocities\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvelocities\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindices\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 101\u001b[39m \u001b[43m \u001b[49m\u001b[43mbox_matrix\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mbox_matrix\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 102\u001b[39m \u001b[43m \u001b[49m\u001b[43mtimestep\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m0.0\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 103\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m:8\u001b[39m, in \u001b[36m__init__\u001b[39m\u001b[34m(self, atom_types, positions, velocities, box_matrix, timestep)\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/var/home/pzeiger/code/PySlice/src/pyslice/multislice/trajectory.py:23\u001b[39m, in \u001b[36mTrajectory.__post_init__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 22\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__post_init__\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m---> \u001b[39m\u001b[32m23\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_validate_shapes\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/var/home/pzeiger/code/PySlice/src/pyslice/multislice/trajectory.py:27\u001b[39m, in \u001b[36mTrajectory._validate_shapes\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 25\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_validate_shapes\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m 26\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.positions.ndim != \u001b[32m3\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.positions.shape[\u001b[32m2\u001b[39m] != \u001b[32m3\u001b[39m:\n\u001b[32m---> \u001b[39m\u001b[32m27\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mpositions must be (frames, atoms, 3), got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.positions.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 28\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.velocities.ndim != \u001b[32m3\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.velocities.shape[\u001b[32m2\u001b[39m] != \u001b[32m3\u001b[39m:\n\u001b[32m 29\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mvelocities must be (frames, atoms, 3), got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.velocities.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", + "\u001b[31mValueError\u001b[39m: positions must be (frames, atoms, 3), got (4000, 3)" + ] } ], "source": [ @@ -383,23 +423,20 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "3549b987-91b3-4c45-a532-bff0426661c6", "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "84bf88c3f72443d9a68b2f3f26c3bade", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "tasks: 0%| | 0/52 [00:00 \u001b[39m\u001b[32m13\u001b[39m ensemble = abtem.AtomsEnsemble(\u001b[43matoms_test\u001b[49m, ensemble_mean=\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[32m 15\u001b[39m potential = abtem.Potential(\n\u001b[32m 16\u001b[39m ensemble,\n\u001b[32m 17\u001b[39m \u001b[38;5;66;03m# atoms_test[0],\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 20\u001b[39m \u001b[38;5;66;03m# gpts = config['discretization']['gpts'],\u001b[39;00m\n\u001b[32m 21\u001b[39m )\n\u001b[32m 23\u001b[39m probe = abtem.Probe(energy=energy, semiangle_cutoff=SEMIANGLE_CUTOFF)\n", + "\u001b[31mNameError\u001b[39m: name 'atoms_test' is not defined" + ] } ], "source": [ @@ -458,31 +495,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "f29833c3-01a0-47d4-9c0c-3a30fd3525dd", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-50.0, 50.0)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots()\n", "\n", @@ -505,39 +521,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "ca53208b-1b7c-4ab8-9c4b-2cf66f532631", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(407, 5)\n", - "(409, 5)\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(figsize=(12,6))\n", "\n", @@ -570,31 +557,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "808f6ec8-f56e-4e4a-9adb-697de6db8e6f", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plt.subplots(figsize=(12,6))\n", "\n", @@ -624,23 +590,24 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "id": "a77e5db2-8bc4-4dd4-9a0c-346bfb2efc1a", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" + "ename": "NameError", + "evalue": "name 'potential_abtem' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[10]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m fig, ax = plt.subplots()\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m xs = np.array(\u001b[43mpotential_abtem\u001b[49m.axes_metadata[\u001b[32m2\u001b[39m].coordinates(potential_abtem.shape[\u001b[32m2\u001b[39m]))\n\u001b[32m 4\u001b[39m ys = np.array(potential_abtem.axes_metadata[\u001b[32m3\u001b[39m].coordinates(potential_abtem.shape[\u001b[32m3\u001b[39m]))\n\u001b[32m 6\u001b[39m mask1 = np.floor(np.abs(xs)) <= \u001b[32m1\u001b[39m\n", + "\u001b[31mNameError\u001b[39m: name 'potential_abtem' is not defined" + ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -680,23 +647,24 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "id": "519a5651-2dfd-4223-acc0-b4475221dc64", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" + "ename": "NameError", + "evalue": "name 'potential_abtem' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[11]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m fig, ax = plt.subplots()\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m xs = np.array(\u001b[43mpotential_abtem\u001b[49m.axes_metadata[\u001b[32m2\u001b[39m].coordinates(potential_abtem.shape[\u001b[32m2\u001b[39m]))\n\u001b[32m 4\u001b[39m ys = np.array(potential_abtem.axes_metadata[\u001b[32m3\u001b[39m].coordinates(potential_abtem.shape[\u001b[32m3\u001b[39m]))\n\u001b[32m 6\u001b[39m mask1 = np.floor(np.abs(xs)) <= \u001b[32m1\u001b[39m\n", + "\u001b[31mNameError\u001b[39m: name 'potential_abtem' is not defined" + ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -733,10 +701,36 @@ "ax.legend()" ] }, + { + "cell_type": "markdown", + "id": "46bd964c-1107-491b-a884-0131e624620b", + "metadata": {}, + "source": [ + "# Test " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a6be77c9-ce5d-42e1-ba20-fbfb3a370a51", + "metadata": {}, + "outputs": [], + "source": [ + "from pyslice import TACAWData" + ] + }, { "cell_type": "code", "execution_count": null, - "id": "46bd964c-1107-491b-a884-0131e624620b", + "id": "0ad973ef-519d-4bcb-9f08-142c0600b028", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac224fe0-f6f8-44cd-bc49-b8eb146c7a4d", "metadata": {}, "outputs": [], "source": [] From 163b9728774978d88072abfdf4019fabc7fae58d Mon Sep 17 00:00:00 2001 From: Paul Zeiger Date: Sun, 29 Mar 2026 00:06:53 -0700 Subject: [PATCH 14/14] Added caching overrides and other small fixes 1. Removed parameter store_all_slices from MultisliceCalculator 2. Added force_rerun parameter to MultisliceCalculator.run in order to force recalculation even if tacaw.npy exists. 3. Fixed bug regarding chunk_size_time handling in TACAWData if chunkFFT=True 4. Added force_rerun parameter to TACAWData class to force recalculation even if tacaw.npy exists in the cache. Now tests/test_pyslice_abtem.ipynb runs successfully! --- src/pyslice/multislice/calculators.py | 26 +- src/pyslice/postprocessing/tacaw_data.py | 19 +- tests/test_pyslice_abtem.ipynb | 347 +++++++++++++++-------- 3 files changed, 252 insertions(+), 140 deletions(-) diff --git a/src/pyslice/multislice/calculators.py b/src/pyslice/multislice/calculators.py index aeccb6c..315c484 100644 --- a/src/pyslice/multislice/calculators.py +++ b/src/pyslice/multislice/calculators.py @@ -113,7 +113,7 @@ def setup( batch_size: Number of frames to process at once save_path: Optional path to save wave function data cleanup_temp_files: Whether to delete temp files after loading - store_all_slices: If True, store wavefunction at each slice for 3D visualization + cache_levels: List of which levels to cache (e.g. "potentials", "exitwaves", "slices") """ b = self._backend @@ -129,7 +129,7 @@ def setup( self.save_path = save_path self.cleanup_temp_files = cleanup_temp_files self.slice_axis = slice_axis - self.cache_levels = cache_levels + self.cache_levels = cache_levels # TODO: I think only cache_level "exitwaves" is properly implemented self.max_kx = max_kx self.max_ky = max_ky self.use_memmap = use_memmap # bool: frame_data (p,x,y,l,1) and wavefunction_data (p,t,x,y,l) will be memmapped instead of held in RAM @@ -232,7 +232,7 @@ def preview_probes(self): plt.show() #@profile - def run(self) -> WFData: + def run(self, force_rerun: bool = False) -> WFData: b = self._backend # cache key is calculated TWICE: once during setup (so the user only needs to setup to infer where their cache folder will go), and again during run (just in case the user does something funky) @@ -300,19 +300,25 @@ def run(self) -> WFData: self.ADFindex = b.astype(b.absolute(self.ADF._wf_array[0, :, :, 0, 0, 0, 0]), int) self.ADF._array = b.zeros(self.ADFindex.shape, dtype=self.complex_dtype) + # If tacaw.npy already exists and no per-frame cache will be written, there is + # nothing to reload or recompute — skip the entire loop. Pass force_rerun=True + # to override (e.g. after changing cache_levels or probe parameters). + skip_all_frames = ( + not force_rerun + and os.path.exists(self.output_dir / "tacaw.npy") + and not any(lv in self.cache_levels for lv in ("exitwaves", "slices")) + ) + if skip_all_frames: + logger.info("tacaw.npy found and no per-frame cache levels active; skipping multislice computation. Pass force_rerun=True to recompute.") + # Process frames one at a time with tqdm progress tracking - with tqdm(total=self.n_frames, desc="Processing frames", unit="frame") as pbar: + if not skip_all_frames: + with tqdm(total=self.n_frames, desc="Processing frames", unit="frame") as pbar: for frame_idx in range(self.n_frames): cache_file = self.output_dir / f"frame_{frame_idx}.npy" # Show detailed progress for single-frame runs show_progress = (frame_idx == 0 and self.n_frames == 1 and not self.loop_probes) - # special case: no frames cached, but we clearly finished and got to tacaw. if so, don't bother regenerating - # this allows cache_levels = [] to be used for disk space savings - if os.path.exists(self.output_dir / f"tacaw.npy") and not os.path.exists(cache_file): - pbar.update(1) - continue - positions = self.trajectory.positions[frame_idx] atom_types = self.trajectory.atom_types atom_type_names = [] diff --git a/src/pyslice/postprocessing/tacaw_data.py b/src/pyslice/postprocessing/tacaw_data.py index a3719ce..a64a648 100644 --- a/src/pyslice/postprocessing/tacaw_data.py +++ b/src/pyslice/postprocessing/tacaw_data.py @@ -41,10 +41,10 @@ def __init__(self, layer_index: Optional[int] = None, keep_complex: bool = False, chunkFFT: bool = False, - chunk_size_time: Optional[int] = None) -> None: + chunk_size_time: Optional[int] = None, + force_rerun: bool = False) -> None: self._backend = wf_data._backend - b = self._backend # Copy coordinate metadata from WFData self.probe_positions = wf_data.probe_positions @@ -60,6 +60,7 @@ def __init__(self, self.chunkFFT = chunkFFT self.use_memmap = isinstance(wf_data._array, np.memmap) self.chunk_size_time = chunk_size_time + self.force_rerun = force_rerun self._wf_array = wf_data._array self._array = None @@ -136,11 +137,13 @@ def _fft_from_wf_data(self, layer_index: Optional[int] = None): cache_tacaw = self.cache_dir / "tacaw.npy" cache_freq = self.cache_dir / "tacaw_freq.npy" - if cache_tacaw.exists(): + fft_len = self.chunk_size_time if self.chunk_size_time is not None else len(self._time) + + if not self.force_rerun and cache_tacaw.exists(): cached = np.load(cache_tacaw) _, nt, nx, ny, _ = self._wf_array.shape _, nw, nx2, ny2 = cached.shape - if nt == nw and nx == nx2 and ny == ny2: + if nw == fft_len and nx == nx2 and ny == ny2: self._frequencies = b.asarray(np.load(cache_freq)) self._array = b.asarray(cached) return @@ -153,7 +156,6 @@ def _fft_from_wf_data(self, layer_index: Optional[int] = None): wf_layer = self._wf_array[:, :, :, :, layer_index] # p,t,kx,ky - if self.chunk_size_time is None: self.n_chunks = 1 else: @@ -165,14 +167,13 @@ def _fft_from_wf_data(self, layer_index: Optional[int] = None): self.n_chunks = len(self._time) // self.chunk_size_time indices = np.linspace(0, len(self._time), self.n_chunks + 1) - fft_len = self.chunk_size_time if self.chunk_size_time is not None else len(self._time) dt = float(to_numpy(self._time[1] - self._time[0])) self._frequencies = b.fftshift(b.fftfreq(fft_len, d=dt)) if self.chunkFFT: # Memory-conservative path: loop over kx dtype = b.complex_dtype if self.keep_complex else b.float_dtype - shape = (wf_layer.shape[0], self.chunk_size_time, + shape = (wf_layer.shape[0], fft_len, wf_layer.shape[2], wf_layer.shape[3]) if self.use_memmap: self._array = b.memmap(shape, dtype=dtype, @@ -382,5 +383,5 @@ class SEDData(TACAWData): Functionally identical to TACAWData — both compute |Ψ(ω,q)|² via time-axis FFT. """ def __init__(self, wf_data: WFData, layer_index: Optional[int] = None, - keep_complex: bool = False) -> None: - super().__init__(wf_data, layer_index, keep_complex) + keep_complex: bool = False, force_rerun: bool = False) -> None: + super().__init__(wf_data, layer_index, keep_complex, force_rerun=force_rerun) diff --git a/tests/test_pyslice_abtem.ipynb b/tests/test_pyslice_abtem.ipynb index 2b7ce7f..05b1b31 100644 --- a/tests/test_pyslice_abtem.ipynb +++ b/tests/test_pyslice_abtem.ipynb @@ -32,7 +32,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Processing frames: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:30<00:00, 3.06s/frame]\n" + "Processing frames: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [00:33<00:00, 3.32s/frame]\n" ] }, { @@ -64,7 +64,7 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from ase import Atoms\n", - "from pyslice import Loader, MultisliceCalculator, Potential, TACAWData\n", + "from pyslice import Loader, MultisliceCalculator, Potential\n", "\n", "print('loaded')\n", "\n", @@ -145,7 +145,7 @@ "# MultisliceCalculator builds the potential internally — you do NOT need to\n", "# construct a Potential object yourself. We do it below purely to visualize\n", "# what the electrons scatter from.\n", - "wf = calc.run()\n", + "wf = calc.run(force_rerun=True)\n", "wf.plot_reciprocal(\n", " \"outputs/tem_diffraction.png\",\n", "# nuke_zerobeam=True,\n", @@ -170,56 +170,12 @@ "potential_pyslice.build()\n", "potential_pyslice.plot(filename=\"outputs/tem_potential.png\")\n", "plt.close()\n", - "print(\"Saved projected potential (optional diagnostic)\")\n", - "\n", - "tacaw = TACAWData(wf) #, chunkFFT=True, chunk_size_time=CHUNK_LENGTH)" + "print(\"Saved projected potential (optional diagnostic)\")" ] }, { "cell_type": "code", "execution_count": 3, - "id": "4e3e5032-3f44-4c82-889c-588d0eeefb3d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([3.66863378e+09])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "tacaw.spectrum_image(1)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "5423ea13-41a3-4364-97ca-25c92dcd9484", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "10" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "trajectory.n_frames" - ] - }, - { - "cell_type": "code", - "execution_count": 5, "id": "5f4022fe-1a4b-498b-8fe5-4b211fae922c", "metadata": {}, "outputs": [ @@ -229,7 +185,7 @@ "(-50.0, 50.0)" ] }, - "execution_count": 5, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" }, @@ -276,17 +232,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "id": "89484d18-cd55-4734-b5bc-4cac80a3d0c7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 6, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, @@ -320,17 +276,17 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "bd4bfc63-44ac-4870-8c64-983464c3da1f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, @@ -364,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "id": "e25f68e4-ca3e-4f61-945a-f891e03b54ba", "metadata": {}, "outputs": [ @@ -376,7 +332,7 @@ " 7.56378721e+11, 7.56378743e+11])" ] }, - "execution_count": 8, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -396,24 +352,28 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "e1c46c22-0cd9-4513-a6fa-27951410935d", "metadata": {}, "outputs": [ { - "ename": "ValueError", - "evalue": "positions must be (frames, atoms, 3), got (4000, 3)", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m atoms_test = [\u001b[43mtrajectory\u001b[49m\u001b[43m.\u001b[49m\u001b[43mselect_timesteps\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m.to_ase() \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(trajectory.n_frames)]\n\u001b[32m 2\u001b[39m atoms_test\n", - "\u001b[36mFile \u001b[39m\u001b[32m/var/home/pzeiger/code/PySlice/src/pyslice/multislice/trajectory.py:97\u001b[39m, in \u001b[36mTrajectory.select_timesteps\u001b[39m\u001b[34m(self, indices)\u001b[39m\n\u001b[32m 95\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m indices \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 96\u001b[39m indices = \u001b[38;5;28mslice\u001b[39m(\u001b[32m0\u001b[39m, \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m.positions))\n\u001b[32m---> \u001b[39m\u001b[32m97\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mTrajectory\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 98\u001b[39m \u001b[43m \u001b[49m\u001b[43matom_types\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43matom_types\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 99\u001b[39m \u001b[43m \u001b[49m\u001b[43mpositions\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mpositions\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindices\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 100\u001b[39m \u001b[43m \u001b[49m\u001b[43mvelocities\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvelocities\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindices\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 101\u001b[39m \u001b[43m \u001b[49m\u001b[43mbox_matrix\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mbox_matrix\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 102\u001b[39m \u001b[43m \u001b[49m\u001b[43mtimestep\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m0.0\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 103\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m:8\u001b[39m, in \u001b[36m__init__\u001b[39m\u001b[34m(self, atom_types, positions, velocities, box_matrix, timestep)\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m/var/home/pzeiger/code/PySlice/src/pyslice/multislice/trajectory.py:23\u001b[39m, in \u001b[36mTrajectory.__post_init__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 22\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__post_init__\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m---> \u001b[39m\u001b[32m23\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_validate_shapes\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m/var/home/pzeiger/code/PySlice/src/pyslice/multislice/trajectory.py:27\u001b[39m, in \u001b[36mTrajectory._validate_shapes\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 25\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_validate_shapes\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m 26\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.positions.ndim != \u001b[32m3\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.positions.shape[\u001b[32m2\u001b[39m] != \u001b[32m3\u001b[39m:\n\u001b[32m---> \u001b[39m\u001b[32m27\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mpositions must be (frames, atoms, 3), got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.positions.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 28\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.velocities.ndim != \u001b[32m3\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.velocities.shape[\u001b[32m2\u001b[39m] != \u001b[32m3\u001b[39m:\n\u001b[32m 29\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mvelocities must be (frames, atoms, 3), got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.velocities.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", - "\u001b[31mValueError\u001b[39m: positions must be (frames, atoms, 3), got (4000, 3)" - ] + "data": { + "text/plain": [ + "[Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96]),\n", + " Atoms(symbols='B2000N2000', pbc=True, cell=[50.08, 43.37055222152468, 16.96])]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -423,20 +383,23 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "3549b987-91b3-4c45-a532-bff0426661c6", "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'atoms_test' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 13\u001b[39m\n\u001b[32m 8\u001b[39m MAX_ANGLE = \u001b[32m150.0\u001b[39m\n\u001b[32m 10\u001b[39m abtem.config.set({\u001b[33m\"\u001b[39m\u001b[33mdevice\u001b[39m\u001b[33m\"\u001b[39m: \u001b[33m\"\u001b[39m\u001b[33mcpu\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 11\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mprecision\u001b[39m\u001b[33m\"\u001b[39m: \u001b[33m\"\u001b[39m\u001b[33mfloat64\u001b[39m\u001b[33m\"\u001b[39m});\n\u001b[32m---> \u001b[39m\u001b[32m13\u001b[39m ensemble = abtem.AtomsEnsemble(\u001b[43matoms_test\u001b[49m, ensemble_mean=\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[32m 15\u001b[39m potential = abtem.Potential(\n\u001b[32m 16\u001b[39m ensemble,\n\u001b[32m 17\u001b[39m \u001b[38;5;66;03m# atoms_test[0],\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 20\u001b[39m \u001b[38;5;66;03m# gpts = config['discretization']['gpts'],\u001b[39;00m\n\u001b[32m 21\u001b[39m )\n\u001b[32m 23\u001b[39m probe = abtem.Probe(energy=energy, semiangle_cutoff=SEMIANGLE_CUTOFF)\n", - "\u001b[31mNameError\u001b[39m: name 'atoms_test' is not defined" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "822ce094d1f94b8cb6db03c0b0a18da6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "tasks: 0%| | 0/52 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "\n", @@ -521,10 +505,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "ca53208b-1b7c-4ab8-9c4b-2cf66f532631", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(407, 5)\n", + "(409, 5)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(figsize=(12,6))\n", "\n", @@ -557,10 +570,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "808f6ec8-f56e-4e4a-9adb-697de6db8e6f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(figsize=(12,6))\n", "\n", @@ -590,24 +624,23 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "a77e5db2-8bc4-4dd4-9a0c-346bfb2efc1a", "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'potential_abtem' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[10]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m fig, ax = plt.subplots()\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m xs = np.array(\u001b[43mpotential_abtem\u001b[49m.axes_metadata[\u001b[32m2\u001b[39m].coordinates(potential_abtem.shape[\u001b[32m2\u001b[39m]))\n\u001b[32m 4\u001b[39m ys = np.array(potential_abtem.axes_metadata[\u001b[32m3\u001b[39m].coordinates(potential_abtem.shape[\u001b[32m3\u001b[39m]))\n\u001b[32m 6\u001b[39m mask1 = np.floor(np.abs(xs)) <= \u001b[32m1\u001b[39m\n", - "\u001b[31mNameError\u001b[39m: name 'potential_abtem' is not defined" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -647,24 +680,23 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "519a5651-2dfd-4223-acc0-b4475221dc64", "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'potential_abtem' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[11]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m fig, ax = plt.subplots()\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m xs = np.array(\u001b[43mpotential_abtem\u001b[49m.axes_metadata[\u001b[32m2\u001b[39m].coordinates(potential_abtem.shape[\u001b[32m2\u001b[39m]))\n\u001b[32m 4\u001b[39m ys = np.array(potential_abtem.axes_metadata[\u001b[32m3\u001b[39m].coordinates(potential_abtem.shape[\u001b[32m3\u001b[39m]))\n\u001b[32m 6\u001b[39m mask1 = np.floor(np.abs(xs)) <= \u001b[32m1\u001b[39m\n", - "\u001b[31mNameError\u001b[39m: name 'potential_abtem' is not defined" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -706,34 +738,107 @@ "id": "46bd964c-1107-491b-a884-0131e624620b", "metadata": {}, "source": [ - "# Test " + "# Test TACAW" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "a6be77c9-ce5d-42e1-ba20-fbfb3a370a51", + "execution_count": 25, + "id": "ee9b7e77-d5f7-416a-b82b-be15d0bb7657", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1002/1002 [00:00<00:00, 16445.23it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1002/1002 [00:00<00:00, 17928.28it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1002/1002 [00:00<00:00, 17707.10it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1002/1002 [00:00<00:00, 17701.66it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1002/1002 [00:00<00:00, 20214.00it/s]\n" + ] + } + ], "source": [ - "from pyslice import TACAWData" + "from pyslice import TACAWData\n", + "tacaw = TACAWData(wf, chunkFFT=True, chunk_size_time=2, force_rerun=True)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "0ad973ef-519d-4bcb-9f08-142c0600b028", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 2, 1002, 868)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tacaw.array.shape" + ] }, { "cell_type": "code", - "execution_count": null, - "id": "ac224fe0-f6f8-44cd-bc49-b8eb146c7a4d", + "execution_count": 26, + "id": "a6be77c9-ce5d-42e1-ba20-fbfb3a370a51", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "(-50.0, 50.0)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "dp_pyslice = tacaw.array\n", + "#if type(dp_pyslice) != np.ndarray:\n", + "# dp_pyslice = dp_pyslice.numpy()\n", + "#dp_pyslice = np.copy(dp_pyslice)\n", + "#dp_pyslice /= np.sqrt((np.abs(dp_pyslice)**2).sum(axis=(-2,-3), keepdims=True))\n", + "\n", + "wavelength = wf.probe.wavelength\n", + "if hasattr(wavelength, 'cpu'):\n", + " wavelength = wavelength.numpy()\n", + "\n", + "thetax = fftshift(wf.probe.kxs) * wavelength * 1e3\n", + "thetay = fftshift(wf.probe.kys) * wavelength * 1e3\n", + "\n", + "extent = (thetax[0], thetax[-1], thetay[0], thetay[-1])\n", + "\n", + "intensity = dp_pyslice.sum(axis=(0,1))\n", + "\n", + "im = ax.imshow(np.log10(intensity.T+1e-40), vmin=0, extent=extent, origin='lower')\n", + "\n", + "fig.colorbar(im, ax=ax)\n", + "\n", + "ax.set_xlim(left=-50, right=50)\n", + "ax.set_ylim(bottom=-50, top=50)" + ] } ], "metadata": {