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"] + +} diff --git a/pyproject.toml b/pyproject.toml index d874026..5e7bd22 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", @@ -19,8 +19,9 @@ dependencies = [ [project.optional-dependencies] fast = ["torch","torchvision"] -test = ["abtem>=1.0.6"] +test = ["abtem>=1.0.6", "pytest"] md = ["orb-models"] +fairchem = ["fairchem-core"] [project.urls] Homepage = "https://github.com/h-walk/PySlice" 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 69a48aa..bf6657b 100644 --- a/src/pyslice/backend.py +++ b/src/pyslice/backend.py @@ -1,322 +1,575 @@ -# backend.py -import numpy as np +# backend.py - Backend abstraction layer for NumPy/PyTorch support +from __future__ import annotations + import os -#import torch +import logging +from abc import ABC, abstractmethod +from typing import Any, Optional, Tuple, Union +import numpy as np -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 +logger = logging.getLogger(__name__) +logger.addHandler(logging.NullHandler()) +# --------------------------------------------------------------------------- +# Optional torch import +# --------------------------------------------------------------------------- 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 = None # type: ignore[assignment] TORCH_AVAILABLE = False -DEFAULT_DEVICE, DEFAULT_FLOAT_DTYPE, DEFAULT_COMPLEX_DTYPE = config -del config +# --------------------------------------------------------------------------- +# Standalone conversion utilities +# These are intentionally module-level: they convert *away* from a backend +# and therefore don't belong to either backend class. +# --------------------------------------------------------------------------- -# Aliases for convenience -float_dtype = DEFAULT_FLOAT_DTYPE -complex_dtype = DEFAULT_COMPLEX_DTYPE +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 configure_backend(device_spec=None, backend_spec=None): - """ - Configure and return backend settings. +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) - 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) +# --------------------------------------------------------------------------- +# Backend ABC +# --------------------------------------------------------------------------- + +class Backend(ABC): + """ + 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) """ - 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 + + 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 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 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 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(self, x: Any) -> Any: + return self.xp.exp(x) + + def log(self, x: Any) -> Any: + return self.xp.log(x) + + def real(self, x: Any) -> Any: + return self.xp.real(x) + + def cos(self, x: Any) -> Any: + return self.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 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)) + + # ------------------------------------------------------------------ + # Array construction helpers (library-agnostic once xp is known) + # ------------------------------------------------------------------ + + def arange(self, *args, **kwargs) -> Any: + return self.xp.arange(*args, **kwargs) + + 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 amin(self, x: Any) -> Any: + return self.xp.amin(x) + + def amax(self, x: Any) -> Any: + return self.xp.amax(x) + + def argwhere(self, condition: Any) -> Any: + return self.xp.argwhere(condition) + + # ------------------------------------------------------------------ + # Einstein summation — falls back to numpy for mixed operands + # ------------------------------------------------------------------ + + 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 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 + # ------------------------------------------------------------------ + + @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 + # ------------------------------------------------------------------ + + @property + def pi(self) -> float: + return self.xp.pi + + +# --------------------------------------------------------------------------- +# NumpyBackend +# --------------------------------------------------------------------------- + +class NumpyBackend(Backend): + """Pure NumPy backend. No device concept; always CPU float64.""" + + 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 + + _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 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 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 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 torch.backends.mps.is_available(): + 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) - # Set precision based on device + # MPS does not support float64 if device.type == 'mps': - fdtype = torch.float32 - cdtype = torch.complex64 + float_dtype = torch.float32 + complex_dtype = torch.complex64 else: - fdtype = torch.float64 - cdtype = torch.complex128 - - return (backend, device, fdtype, cdtype) - - -def asarray(arraylike, dtype=None, device=None): - if dtype is None: - dtype = DEFAULT_FLOAT_DTYPE - if device is None: - device = DEFAULT_DEVICE - if xp != np: -# if dtype == bool: -# dtype = xp.bool - array = xp.tensor(arraylike, dtype=dtype, device=device) - else: - array = xp.asarray(arraylike, dtype=dtype) - return array - -def astype(arraylike,dtype): - if hasattr(arraylike,"to"): # torch - 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 + 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 = 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 ]: - 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 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":int}[dtype] - # infer if we're using torch or numpy (numpy does not take device arg) - if xp != np: - array = xp.zeros(dims, dtype=dtype, device=device) - else: - array = xp.zeros(dims, dtype=dtype) - return array - -def memmap(dims,dtype=DEFAULT_FLOAT_DTYPE,filename=None): - from numpy.lib.format import open_memmap - if filename is None: - print("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) - 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 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): - if xp != np: - 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: - return xp.fft.fftfreq(n, d, dtype=dtype, device=device) - else: - return xp.fft.fftfreq(n, d, dtype=dtype) - -def expand_dims(ary,d): - if xp != np: - return xp.unsqueeze(ary,dim=d) - else: - return np.expand_dims(ary,d) - -def exp(x): - 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): - return xp.real(x) - -def amax(x): - return xp.amax(x) - -def amin(x): - return xp.amin(x) - -def sum(x, axis=None, **kwargs): - if xp != np and type(x) not in [ np.memmap, np.ndarray ]: - return xp.sum(x, dim=axis, **kwargs) - else: - return np.sum(x, axis=axis, **kwargs) - -def any(x): - return xp.any(x) - -def einsum(subscripts, *operands, **kwargs): - #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: - return xp.einsum(subscripts, *operands, **kwargs) - else: - 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 - else: - return array.cpu().numpy() - -def isnan(x): - 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 xp != np and type(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): - #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 chunkIDs(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] - -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 - 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 + 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) + 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 661e3c3..315c484 100644 --- a/src/pyslice/multislice/calculators.py +++ b/src/pyslice/multislice/calculators.py @@ -3,74 +3,37 @@ import logging from typing import Optional, Tuple, List from tqdm import tqdm -import time,os +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 .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 ..backend import zeros,expand_dims,to_cpu,memmap,ones,sum,absolute,ceil,einsum,asarray,astype +from pyslice.backend import make_backend, to_cpu, to_numpy, NumpyBackend 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 """ - 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._backend = make_backend('cpu') 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') + self._backend = make_backend(device) + self.device = self._backend.device + + logger.info(f"Calculator initialized on device: {self.device}") - logger.info(f"PyTorch 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', @@ -79,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(), @@ -97,7 +60,7 @@ 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 self._backend.xp is not np else 'numpy', } if spatial_decoherence is not None: params['spatial_decoherence'] = spatial_decoherence @@ -108,7 +71,7 @@ def _generate_cache_key(self, trajectory, aperture, voltage_eV, 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, @@ -124,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 @@ -150,8 +113,9 @@ 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 self.trajectory = trajectory self.aperture = aperture @@ -165,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 @@ -178,33 +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 + 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 - 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.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: @@ -215,46 +178,37 @@ 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 - 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 = 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 - 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) + 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.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 = [] @@ -263,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.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)) - #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: + 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) # 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 TORCH_AVAILABLE 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 = xp.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 = xp.sqrt( xp.amin( xp.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 = 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 = 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() @@ -334,39 +282,43 @@ 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 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 = 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) + 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 = 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 = 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) + + # 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): - #if sum(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 ): - pbar.update(1) - continue - positions = self.trajectory.positions[frame_idx] atom_types = self.trajectory.atom_types atom_type_names = [] @@ -377,157 +329,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 = einsum('pxyln,xy->p',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",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)) + 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, 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) + potential = Potential( + self.xs, self.ys, self.zs, + positions, atom_type_names, + 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) + + 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 = 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 = 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 = xp.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( xp.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 = 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)} + 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 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) - #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 = 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 = einsum('pxy,xy->p',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 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) -# #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 = einsum('pxy,xy->p',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 - - - 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 = 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 = 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, @@ -540,23 +453,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 = 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/Å 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 = 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, @@ -569,9 +475,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...") @@ -585,80 +492,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,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 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=np.linspace(0,2*np.pi/abc[0],nxyz[0]) - self.kys=np.linspace(0,2*np.pi/abc[1],nxyz[1]) - - self.kvec = np.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.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}$)") @@ -666,5 +572,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 28be8fe..fad09c2 100644 --- a/src/pyslice/multislice/multislice.py +++ b/src/pyslice/multislice/multislice.py @@ -1,988 +1,1085 @@ +""" +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 ..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 - +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 # Å + + +# --------------------------------------------------------------------------- +# 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. - 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). + 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 = xp.amax(xp.abs(kxs)) - ky_max = xp.amax(xp.abs(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 = 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 -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. + 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. - 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. + 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 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 + 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. - """ - - 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 - 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 - - # 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 + Electron probe wavefunction for multislice calculations. - 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 + 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). - # HANDLE PROBE POSTIONS + 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: 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 = np.asarray([eV]) - if self.use_torch: - self.eVs = torch.as_tensor(self.eVs, 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 - - # 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 {} - + 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 = xp.fft.fftfreq(nx, d=dx, **device_kwargs) - self.kys = xp.fft.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'): - self._array = array.to(device=self.device, dtype=self.complex_dtype) - else: - self._array = xp.asarray(array) + # ------------------------------------------------------------------ + # 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 = zeros((1,1,nx,ny),dtype=complex_dtype) - self._array= self.generate_single_probe(mrad,self.wavelength,self.gaussianVOA,preview=preview)[None,None,:,:]*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 zeros((nx, ny), device=self.device)+1 + # Plane wave: uniform amplitude, no aperture. + return b.zeros((nx, ny), dtype=b.complex_dtype) + 1 - radius = (mrad * 1e-3) / wavelength # Convert mrad to reciprocal space units + 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 = 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 = 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 = (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 - 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 * xp.exp(-2j * xp.pi * kxs[:, None] * self.lx/2 ) * xp.exp(-2j * xp.pi * kys[None, :] * self.ly/2 ) + 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 + # ------------------------------------------------------------------ - return xp.fft.ifftshift(xp.fft.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 + def applyShifts(self): + """ + Expand the (nc,1,nx,ny) template array to (nc,npt,nx,ny) by shifting + the probe to each requested position. - @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).""" - 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 + 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 + + # Broadcast the single template probe to all npt positions. + if self.cropping: + # 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: - dtype, complex_dtype = torch.float64, torch.complex128 + 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 = 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) + 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)). - self.device = device - self.dtype = dtype - self.complex_dtype = complex_dtype - return self + 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. - 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=array.T # imshow convention: y,x. our convention: x,y - plot_array = np.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) - - 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) + Returns (shifted_probe_in_original_domain, (offset_x, offset_y)). + """ + b = self._backend + dx = x - self.lx / 2 + dy = y - self.ly / 2 - if filename is not None: - plt.savefig(filename) + if self.cropping: + 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: - plt.show() + kxs, kys = self.kxs, self.kys + offset_x = offset_y = 0 + + if not self.stay_reciprocal: + probe_k = b.fft2(array) + else: + probe_k = array + + # 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 b.ifft2(probe_k_shifted), (offset_x, offset_y) + + # ------------------------------------------------------------------ + # Decoherence + # ------------------------------------------------------------------ + + def defocus(self, dz): + """ + Apply a defocus of dz Angstroms to the probe. + + 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). - 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') - k_squared = kx_grid**2 + ky_grid**2 - P = xp.exp(-1j * xp.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 = 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 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: - 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) - if self.use_torch: - self.eVs = torch.as_tensor(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) - 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) + 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) - nc,npt,nx,ny = self._array.shape - if npt==1: + if self._array.shape[1] == 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 = np.linspace(-2*sigma_dz,2*sigma_dz,N) # suppose N=25 - amplitudes = np.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) - 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 = self.eVs.reshape(nc) - self.wavelengths = ones(N, device=self.device)[:,None]*self.wavelengths[None,:] - self.wavelengths = self.wavelengths.reshape(nc) - if npt==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 (Å). - 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? - return + 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. - # inflate self._array to store probe cube (npt,nx,ny) - 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] - else: - self._array = self._array[:,0,None,:,:] * 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 + 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) - self._array[:,i,:,:],(dpx,dpy) = self.placeProbe(self._array[:,i,:,:], px, py ) - self.offsets[i,0] = int(dpx) ; self.offsets[i,1] = int(dpy) + 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 #; print("applyShifts expands to",nc,npt,nx,ny) + nc, npt, nx, ny = self._array.shape + self.defocus(dzs) # expands: (nc,1,nx,ny) → (N·nc,1,nx,ny) - 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 - 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) - 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 - else: - 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 - 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 ) - probe_k_shifted = probe_k * kx_shift * ky_shift + # 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] - if self.stay_reciprocal: - return probe_k_shifted,(offset_x,offset_y) - return xp.fft.ifft2(probe_k_shifted),(offset_x,offset_y) + 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. - 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)) - # 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 + 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 = xp.fft.ifftshift(xp.fft.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 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] ) - 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 * \ - (1/(n+1)) * C * ( ks * wavelength ) ** (n+1) * \ - xp.cos( m * (theta-phi0) ) - return xp.exp(-1j * dPhi) - -#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 - - -def create_batched_probes(base_probe, probe_positions, device=None): - """ - Create a batch of shifted probes for vectorized processing. + self._array = b.ifftshift(b.ifft2(reciprocal)) - Args: - base_probe: ProbeTorch object - probe_positions: List of (x,y) positions - device: PyTorch device + # ------------------------------------------------------------------ + # Copy + # ------------------------------------------------------------------ - Returns: - 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: - # 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) + def copy(self, selected_probes=None) -> Probe: + """ + Deep copy, optionally selecting a subset of probe positions. - n_probes = len(probe_positions) - probe_arrays = [] + 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)) - nx = len(base_probe.xs) - ny = len(base_probe.ys) + 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) - # Compute dx, dy on same device as probe - if TORCH_AVAILABLE and 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] + return new_probe - lx = nx*dx ; ly = ny*dy + # ------------------------------------------------------------------ + # Output + # ------------------------------------------------------------------ - for px, py in probe_positions: - # Create shifted probe using phase ramp in k-space - probe_k = xp.fft.fft2(base_probe._array) + @property + def array(self) -> np.ndarray: + """CPU NumPy copy of the probe array.""" + return to_numpy(self._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) ) - probe_k_shifted = probe_k * kx_shift * ky_shift - - # Convert back to real space - shifted_probe_array = xp.fft.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) + 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 - return Probe(base_probe.xs, base_probe.ys, base_probe.mrad, base_probe.eV, array=array, device=base_probe.device) + 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()) + 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) + + +# --------------------------------------------------------------------------- +# 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): - - # 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 - - # 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 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 - 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) - # 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 = torch.as_tensor(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,:,:] * 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 ) - # 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 = xp.fft.fftshift(xp.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) - #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,:,:]) - # 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) - - # 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) - - # 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 not TORCH_AVAILABLE: - 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]*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.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) * \ - (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: - # #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: - 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') - 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 = xp.exp(-1j * xp.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 = xp.roll(potential_slice[None,:,:],rollx,z)[:,:probe.cropping,:] - #rolly = list(probe.offsets[:,1]) ; z = [2]*len(rolly) - #pot = xp.roll(pot[:,:,:],rolly,z)[:,:,:probe.cropping] - nx,ny = potential_slice.shape - #xr = xp.arange(nx) ; yr = xp.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 = xp.roll(potential_slice,int(-o[0]),0)[:probe.cropping,:] - # #pot = xp.roll(pot,int(-o[1]),1)[:,:probe.cropping] - # # rolling indices: faster (0.7s per on Nick's particles) - # xi = xp.roll(xr,-o[0])[:probe.cropping] - # 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) - for p,(x,y) in enumerate(probe.offsets): - xi[p,:] = xp.roll(xr,-x)[:probe.cropping] - yi[p,:] = xp.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) - + # 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 = xp.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 - slice_wavefunctions.append(clone(array)) + 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 = {"dim":(-2,-1)} if TORCH_AVAILABLE else {"axes":(-2,-1)} - #print(kwarg,array.dtype,array.shape) - #print("FFT / multiply / iFFT") ; start = time.time() - fft_array = xp.fft.fft2(array, **kwarg) - propagated_fft = P * fft_array - array = xp.fft.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 - if TORCH_AVAILABLE: - return torch.stack(slice_wavefunctions, dim=0) - else: - return xp.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(xp.absolute(exitwave)), cmap="inferno") ; axs[0].set_title("exit wave") - #axs[1].imshow(to_cpu(xp.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 = xp.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...) +# --------------------------------------------------------------------------- +# 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 = xp.fft.ifft2(xp.fft.fft2(exitwave)/P)/psi1 - # t = exp(i σ O) --> O = log(t)/i/σ - O = xp.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 - # 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(xp.absolute(exitwave)), cmap="inferno") ; axs[0].set_title("exit wave") - #axs[1].imshow(to_cpu(xp.absolute(probe._array[0,0,:,:])), cmap="inferno") ; axs[1].set_title("entrance wave") - #axs[2].imshow(to_cpu(xp.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*=xp.absolute(psi1)/(xp.absolute(psi1)+damping*xp.amax(xp.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 0ed216f..bb4bb70 100644 --- a/src/pyslice/multislice/potentials.py +++ b/src/pyslice/multislice/potentials.py @@ -1,462 +1,411 @@ -import numpy as np +from __future__ import annotations + +import os +import logging from pathlib import Path -import logging,os +from typing import Optional, Union + +import numpy as np 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 + +from pyslice.backend import Backend, to_numpy logger = logging.getLogger(__name__) -# Global storage for Kirkland parameters on GPU - store per device -kirklandABCDs = [] -def kirkland(qsq, Z): +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: """ - GPU-accelerated Kirkland structure factor calculation using PyTorch. - + 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). + + 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. + """ + 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: - 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|² 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 len(kirklandABCDs)==0: - # 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 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, :, :] - - 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) - + + # 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 = 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 - - # 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: - 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 - 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) + + if backend is not None: + xs = backend.linspace(0, lx, nx) + ys = backend.linspace(0, ly, ny) + zs = backend.linspace(0, lz, nz) else: - kirklandABCDs = np.asarray(kirkland_params) + 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 + + +# --------------------------------------------------------------------------- +# 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=None, atomTypes=None, array=None, 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 - - # 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 + """ + 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. + """ + + 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) + + # ---------------------------------------------------------------- + # 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) - # 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) - 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: - if isinstance(at, str): - atomic_numbers.append(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) - - 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 - - # 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) - - # 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] - if TORCH_AVAILABLE: - type_mask = torch.tensor(type_mask, - dtype=torch.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 xp.any(spatial_mask): - continue #return xp.zeros((len(self.kxs),len(self.kys))) - - # 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))) - - 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 ) - 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]) - - # Einstein summation - match NumPy - kwarg={True:{},False:{"optimize":True}}[TORCH_AVAILABLE] - shape_factor += xp.einsum('ax,ay->xy', expx, expy, **kwarg) - - reciprocal += shape_factor * form_factor - - real = xp.fft.ifft2(reciprocal) - real = xp.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 TORCH_AVAILABLE 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): - if self._array is not None: + form_factors = {} + for at in unique_types: + Z = _resolve_z(at) + if kind == "kirkland": + form_factors[at] = kirkland_form_factor(qsq, Z, kirkland_params, backend) + elif kind == "gauss": + 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 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) + 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 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) - - def to_cpu(self): - return 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=None): - if self._array is None: + 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 = 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) - # Convert to CPU if on GPU/MPS device - #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) - - 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/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/multislice/sed.py b/src/pyslice/multislice/sed.py index 409316d..350fe36 100644 --- a/src/pyslice/multislice/sed.py +++ b/src/pyslice/multislice/sed.py @@ -1,110 +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 +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=np.asarray(v_xyz,dtype=float) - v_xyz/=np.sqrt(np.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=np.fft.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=np.exp(1j*np.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,:,:] - #if not keepComplex: - Zs=np.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..d3a9841 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,281 @@ 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)) + # 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], + 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: + """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)) 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 1bfc56a..f7335ff 100644 --- a/src/pyslice/postprocessing/haadf_data.py +++ b/src/pyslice/postprocessing/haadf_data.py @@ -7,34 +7,10 @@ import logging 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 -#from ..data.pyslice_serial import PySliceSerial +from pyslice.backend import Backend, to_cpu, to_numpy 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): """ @@ -67,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 @@ -109,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): @@ -138,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 = xp.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 @@ -170,64 +144,22 @@ 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 = xp.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 = 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 = 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 = absolute(self._wf_array)**2 ; mask = absolute(mask) - self._array = 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) + 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 = to_numpy(self._xs) ys_np = to_numpy(self._ys) @@ -265,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 c6e4fe4..a64a648 100644 --- a/src/pyslice/postprocessing/tacaw_data.py +++ b/src/pyslice/postprocessing/tacaw_data.py @@ -1,168 +1,114 @@ """ Core data structure for TACAW EELS calculations. """ -import numpy as np -from typing import Optional, Tuple, Dict, Any, List, Union +from __future__ import annotations + +import logging +import os from pathlib import Path -import logging, os +from typing import List, Optional, Union + +import numpy as np +from tqdm import tqdm + from .wf_data import WFData 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 +from pyslice.backend import Backend, to_numpy, to_cpu 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): """ - 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, chunkFFT: bool = False) -> None: - """ - Initialize TACAWData from WFData by performing FFT. + def __init__(self, + wf_data: WFData, + layer_index: Optional[int] = None, + keep_complex: bool = False, + chunkFFT: bool = False, + chunk_size_time: Optional[int] = None, + force_rerun: bool = False) -> None: - 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) + self._backend = wf_data._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) - - # 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.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 + self.force_rerun = force_rerun + + 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 = 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) - 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): @@ -170,7 +116,6 @@ def data(self, value): @property def intensity(self): - """Backward compatible alias for internal intensity array.""" return self._array @intensity.setter @@ -179,440 +124,264 @@ 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 TORCH_AVAILABLE: - self._frequencies = xp.Tensor(self._frequencies) - self._array = xp.Tensor(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" + + 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 nw == fft_len 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}]") - - # Compute frequencies from time sampling - n_freq = len(self._time) - dt = self._time[1] - self._time[0] - 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] - - # 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") + wf_layer = self._wf_array[:, :, :, :, layer_index] # p,t,kx,ky + + if self.chunk_size_time is None: + self.n_chunks = 1 + else: + 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._array = xp.zeros(wf_layer.shape, dtype = dtype) + self.n_chunks = len(self._time) // self.chunk_size_time - 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) + indices = np.linspace(0, len(self._time), self.n_chunks + 1) + 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], fft_len, + 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: + # 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 = absolute(wf_fft)**2 + wf_fft = b.absolute(wf_fft) ** 2 + self._array = wf_fft if self._array is None else self._array + wf_fft - 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 - - self._array = wf_fft - - #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 - - # Ensure cache directory exists (may have been cleaned up by calculator) + # 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", 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 = sum(probe_intensity, axis=(1, 2)) # Sum over kx, ky - 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] - spectrum = np.mean(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 - - # Convert to numpy if PyTorch tensor - if TORCH_AVAILABLE and hasattr(spectrum, 'cpu'): - spectrum = spectrum.cpu().numpy() - - 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 np.array([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, :, :] - - # 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 = np.sum(probe_intensity) - - spectrum_intensities.append(probe_intensity_sum) - - return np.array(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 = sum(probe_intensity, axis=0) # Sum over frequencies - 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] - diffraction_pattern = np.mean(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 = 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() + pattern = to_numpy(b.sum(self._array[probe_index], axis=0)) if space == "real": - diffraction_pattern = np.absolute(np.fft.ifft2(diffraction_pattern)) - - return diffraction_pattern - - def spectral_diffraction(self, frequency: float, probe_index: int = None, space: str = "reciprocal") -> np.ndarray: - """ - Extract spectral diffraction pattern at a specific frequency. + pattern = to_numpy(b.absolute(b.ifft2(b.asarray(pattern)))) + return pattern - 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 TORCH_AVAILABLE and hasattr(all_spectral_diffractions[0], 'cpu'): - all_spectral_diffractions = [sd.cpu().numpy() for sd in all_spectral_diffractions] - spectral_diffraction = np.mean(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 TORCH_AVAILABLE and hasattr(spectral_diffraction, 'cpu'): - spectral_diffraction = spectral_diffraction.cpu().numpy() + pattern = to_numpy(self._array[probe_index, freq_idx, :, :]) if space == "real": - spectral_diffraction = np.absolute(np.fft.ifft2(spectral_diffraction)) - - return spectral_diffraction - - 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. + pattern = to_numpy(b.absolute(b.ifft2(b.asarray(pattern)))) + return pattern - 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 = to_cpu(self.kxs) - kys = 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(to_cpu(xp.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(to_cpu(xp.sum(masked,axis=(1,2)))) - return np.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=np.double) + + for w in range(n_freq): + w_slice = self._array[probe_indices, w, :, :] + if space == "real": + 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] - 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 = to_cpu(kx) - ky = 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": - kwarg = {"dim":(1,2)} if TORCH_AVAILABLE else {"axes":(1,2)} - w_slice = xp.fft.ifft2(w_slice,**kwarg) - # bring to CPU - if TORCH_AVAILABLE and hasattr(w_slice, 'cpu'): - w_slice = w_slice.cpu().numpy() - # sum across probe positions - w_slice = np.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) - - # 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 - aspect = None - - if isinstance(xvals,str): - if xvals in ["kx","k"]: - xlabel = "kx ($\\AA^{-1}$)" ; xvals = to_cpu(self.kxs) - elif xvals == "ky": - xlabel = "ky ($\\AA^{-1}$)" ; xvals = to_cpu(self.kys) - elif xvals == "x": - xlabel = "x ($\\AA$)" ; xvals = to_cpu(self.xs) - elif xvals == "y": - xlabel = "y ($\\AA$)" ; xvals = to_cpu(self.ys) - - if isinstance(yvals,str): - if yvals == "omega": - aspect = "auto" - if yvals == "kx": - ylabel = "kx ($\\AA^{-1}$)" ; yvals = to_cpu(self.kxs) - elif yvals in ["ky","k"]: - ylabel = "ky ($\\AA^{-1}$)" ; yvals = to_cpu(self.kys) - elif yvals == "x": - ylabel = "x ($\\AA$)" ; yvals = to_cpu(self.xs) - elif yvals == "y": - ylabel = "y ($\\AA$)" ; yvals = to_cpu(self.ys) - elif yvals == "omega": - ylabel = "frequency (THz)" ; yvals = to_cpu(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 - """ - super().__init__(wf_data, layer_index, keep_complex) + def __init__(self, wf_data: WFData, layer_index: Optional[int] = None, + keep_complex: bool = False, force_rerun: bool = False) -> None: + super().__init__(wf_data, layer_index, keep_complex, force_rerun=force_rerun) 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 6e00ac9..d0f6481 100644 --- a/src/pyslice/postprocessing/wf_data.py +++ b/src/pyslice/postprocessing/wf_data.py @@ -1,61 +1,34 @@ """ Wave function data structure. """ +from __future__ import annotations + import numpy as np -from typing import List, Tuple, Optional -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 +from typing import List, Optional, Tuple + +from ..multislice.multislice import Probe, aberrationFunction +from ..data.pyslice_serial import PySliceSerial, Signal, Dimensions, Dimension, Metadata +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__( @@ -64,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): @@ -149,309 +122,236 @@ 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 = 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) - @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/xp.sum(xp.absolute(self._array)) # normalized: ensure values arerelative probabilities of each voxel - ary = xp.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): + 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, + whichProbe="mean", + whichTimestep="mean", + powerscaling=0.25, + extent=None, + 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 = 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 = 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(np.absolute(kys_np)),np.argmin(np.absolute(kxs_np))]=0 - - # Convert to numpy array if it's a tensor - # Apply powerscaling to intensity (|Ψ|²) - img_data = (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) - if hasattr(array, 'mean'): # torch tensor - array = array.mean(dim=0) # Average over time dimension - else: # numpy array - array = np.mean(array, axis=0) + 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 = xp.fft.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 = xp.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 = xp.fft.ifft2(self._array[:,:,:,:,-1]) - array = xp.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 = mean(abs(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 = 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 = xp.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 = xp.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): - P = P.to(self._array.device) - #if dz>0: - 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) - self._array = self._array[:,None,:,:,:,:] * 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') - 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 = 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 - 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 = xp.sqrt( self._kxs[:,None]**2 + self._kys[None,:]**2 ) - mask = zeros(radii.shape, device=self._array.device if TORCH_AVAILABLE 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 = 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=xp.argwhere(self._kys >= ky_range[0])[0] - j2=xp.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 26f11d3..5638a80 100644 --- a/tests/00_probe.py +++ b/tests/00_probe.py @@ -1,4 +1,6 @@ -import sys,os,time +import testtools +from testtools import differ +import sys, os, time try: import pyslice except ModuleNotFoundError: @@ -6,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) @@ -21,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/test_pyslice_abtem.ipynb b/tests/test_pyslice_abtem.ipynb new file mode 100644 index 0000000..05b1b31 --- /dev/null +++ b/tests/test_pyslice_abtem.ipynb @@ -0,0 +1,865 @@ +{ + "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": [ + "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:33<00:00, 3.32s/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(force_rerun=True)\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", + " 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)\")" + ] + }, + { + "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": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAGdCAYAAAAWp6lMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAaTtJREFUeJzt3XtcVGX+B/DPcBtEBEQUREHS1PIGeYFou2iSSGVll7W2LbSyG9bu0k13f6vVVrbVmls7RZdVu2e1u3axLCOLTLxhlGWZGKaJgFcQVC4z5/fHM/cBYWDOc2bOfN6vFy+YC3POHIY53/k+3+/zGBRFUUBERESkYyFa7wARERGR2hjwEBERke4x4CEiIiLdY8BDREREuseAh4iIiHSPAQ8RERHpHgMeIiIi0j0GPERERKR7YVrvgK9ZLBZUVVWhV69eMBgMWu8OERERdYKiKDh69CiSk5MREuL7fIzuAp6qqiqkpKRovRtERETUBXv27MHAgQN9/ri6C3h69eoFWA9YTEyM1rtDREREnVBfX4+UlBT7edzXdBfw2IaxYmJiGPAQEREFGLXKUXRTtGwymTBixAhMmDBB610hIiIiP2PQ22rp9fX1iI2NRV1dHTM8REREAULt87duMjxERERE7dFdDQ8REVFbFEVBa2srzGaz1rsSlEJDQxEWFqbZlDEMeIiISPeam5uxb98+HDt2TOtdCWpRUVHo378/IiIipG+bAQ8REemaxWJBZWUlQkNDkZycjIiICE5MK5miKGhubsb+/ftRWVmJoUOHqjK54Mkw4CEiIl1rbm6GxWJBSkoKoqKitN6doNWjRw+Eh4fjl19+QXNzMyIjI6Vu3y+Llj/44AMMHz4cQ4cOxYsvvqj17hARkQ7IziiQJy3/Bn6X4WltbUVhYSHWrFmD2NhYjBs3DtOnT0efPn203jUiIiIKUH4X7m7cuBEjR47EgAEDEB0djby8PHzyySda7xYREZHuLFu2DHFxcfbL999/PzIyMjTdJ7X4POApKSnBtGnTkJycDIPBgBUrVnjcx2QyIS0tDZGRkcjKysLGjRvtt1VVVWHAgAH2ywMGDMDevXt9vZtERER+b+bMmTAYDDAYDIiIiMCpp56KBx98EK2trZ36/S+++ALnn38+4uPjERUVhaFDhyI/Px/Nzc1t3v/uu+9GcXGxj5+Ff/B5wNPY2Ij09HSYTKY2b1++fDkKCwuxYMECbNmyBenp6cjNzUVtba2vd4WIiCjgTZ06Ffv27cOOHTtw11134f7778fjjz/e4e9t27YNU6dOxfjx41FSUoKtW7fi6aefRkRERLtzEUVHR+u2hMTnAU9eXh4eeughTJ8+vc3bFy1ahNmzZ2PWrFkYMWIEioqKEBUVhSVLlgAAkpOTXTI6e/fuRXJycrvba2pqQn19vcsXEenU3jJgfRFgsWi9J0TSGI1GJCUlYdCgQbjtttuQk5ODt956CzExMXjnnXdc7rtixQr07NkTR48exSeffIKkpCQ89thjGDVqFIYMGYKpU6fihRdeQI8ePdrcVltDWkuWLMHIkSNhNBrRv39/zJkzx37bkSNHcNNNN6Fv376IiYnB+eefj2+++UalI9E9Umt4mpubUVZWhpycHMcOhIQgJycHpaWlAIDMzEx899132Lt3LxoaGvDRRx8hNze33cdcuHAhYmNj7V8pKSlSngsRaeDDe4FV9wFVW7TeEwp0igI0N8r/8sHylT169EBISAiuvvpqLF261OW2pUuX4sorr0SvXr2QlJSEffv2oaSkpMvbevbZZ1FQUICbb74ZW7duxXvvvYdTTz3VfvtVV12F2tpafPTRRygrK8PYsWMxefJkHDp0qFvPUQ1Su7QOHDgAs9mMxMREl+sTExPx448/ih0KC8M//vEPTJo0CRaLBffee+9J02vz5s1DYWGh/XJ9fT2DHiK9am4Q35uOar0nFOhajgGPtD96oJo/VwERPbv0q4qioLi4GB9//DHuuOMOXHXVVTjrrLOwb98+9O/fH7W1tfjwww/x6aefAtZg5OOPP8Z5552HpKQknHnmmZg8eTKuv/76Ti/O+dBDD+Guu+7CH/7wB/t1EyZMAACsXbsWGzduRG1tLYxGIwDgiSeewIoVK/DOO+/g5ptv7tLzVIvfdWkBwCWXXIKffvoJFRUVHR4wo9GImJgYvPLKK/Y/JhHplP3Tcfc/JRMFig8++ADR0dGIjIxEXl4eZsyYgfvvvx+ZmZkYOXIkXnrpJQDAq6++ikGDBuHcc88FrGtXLV26FL/++isee+wxDBgwAI888ghGjhyJffv2dbjd2tpaVFVVtXte/eabb9DQ0IA+ffogOjra/lVZWYmdO3f6+Ch0n9QMT0JCAkJDQ1FTU+NyfU1NDZKSkrr12AUFBSgoKLAvL09EemQNdHwwLEBBLjxKZFu02K6XJk2ahGeffRYRERFITk5GWJjj1H3TTTfBZDJh7ty5WLp0KWbNmuWxbMaAAQNw3XXX4brrrsPf/vY3DBs2DEVFRXjggQdOut326nxsGhoa0L9/f3z++ecetzm3uvsLqQFPREQExo0bh+LiYlx22WWAdY2T4uJilyKorjCZTDCZTFwFl0jPFGuxMgMe6i6DoctDS7L17NnTpW7G2e9//3vce++9eOqpp7Bt2zbk5+ef9LF69+6N/v37o7GxscPt9urVC2lpaSguLsakSZM8bh87diyqq6sRFhaGtLQ0L56RNnwe8DQ0NKCiosJ+ubKyEuXl5YiPj0dqaioKCwuRn5+P8ePHIzMzE4sXL0ZjYyNmzZrVre0yw0MUBDikReSid+/euPzyy3HPPfdgypQpGDhwoP225557DuXl5Zg+fTqGDBmCEydO4OWXX8b333+Pp59+ulOPf//99+PWW29Fv379kJeXh6NHj+Krr77CHXfcgZycHGRnZ+Oyyy7DY489hmHDhqGqqgorV67E9OnTMX78eBWfufd8HvBs3rzZJRK0FRTn5+dj2bJlmDFjBvbv34/58+ejuroaGRkZWLVqlUchMxGRJw5pEbm78cYb8frrr+OGG25wuT4zMxNr167FrbfeiqqqKkRHR2PkyJFYsWIFzjvvvE49dn5+Pk6cOIEnn3wSd999NxISEnDllVcCAAwGAz788EP85S9/waxZs7B//34kJSXh3HPP9ctzukFR9PHO4Tyk9dNPP6Gurq7TVehEFCD+mQEcrgR+9xYwrP3pKoicnThxApWVlTjllFOkr9AtwyuvvII//elPqKqqQkREhNa7c1In+1vYRmjUOn/7ZZdWVxQUFGDbtm3YtGmT1rtCRKphhofI5tixY9i5cyceffRR3HLLLX4f7GhNNwGPyWTCiBEj7PMDEJEOsYaHyO6xxx7DaaedhqSkJMybN0/r3fF7ugl4mOEhCgbM8BDZ3H///WhpaUFxcTGio6O13h2/p5uAh4iCgC3QUbiWFhF5hwEPEQUODmkRURfpJuBhDQ9RMOCQFnWdTpqSA5qWfwPdBDys4SEKAszwUBeEh4cD1q4m0pbtb2D7m8gkdWkJIqLuYYaHvBcaGoq4uDjU1tYCAKKiojzWmyJ1KYqCY8eOoba2FnFxcQgNDZW+Dwx4iChwMMNDXWRboNoW9JA24uLiur1YeFfpJuDh4qFEwYAZHuoag8GA/v37o1+/fmhpadF6d4JSeHi4JpkdG90EPFw8lCgI2FdLZ1s6dU1oaKimJ13Sjm6KlokoCDCzQ0RdxICHiAIIh7SIqGsY8BBR4GDRMhF1EQMeIgogzPAQUdfoJuDhTMtEQYAZHiLqIt0EPJxpmSgIcPFQIuoi3QQ8RBQMOKRFRF3DgIeIAgeHtIioixjwEFEAYYaHiLqGAQ8RBQ5meIioixjwEFEAYYaHiLpGNwEP29KJggAzPETURboJeNiWThQEuHgoEXWRbgIeIgoGHNIioq5hwENEgYNDWkTURQx4iCiAMMNDRF3DgIeIAgcDHSLqIgY8RBRAmOEhoq7xy4Bn+vTp6N27N6688kqtd4WI/AlreIioi/wy4PnDH/6Al19+WevdICK/w9XSiahr/DLgmThxInr16qX1bhCRP3EexuKQFhF5yeuAp6SkBNOmTUNycjIMBgNWrFjhcR+TyYS0tDRERkYiKysLGzdu9NX+ElGwcglyGPAQkXe8DngaGxuRnp4Ok8nU5u3Lly9HYWEhFixYgC1btiA9PR25ubmora213ycjIwOjRo3y+KqqquresyEiHWOGh4i6LszbX8jLy0NeXl67ty9atAizZ8/GrFmzAABFRUVYuXIllixZgrlz5wIAysvLu7PPLpqamtDU1GS/XF9f77PHJiI/wgwPEXWDT2t4mpubUVZWhpycHMcGQkKQk5OD0tJSX27KbuHChYiNjbV/paSkqLIdItIaMzxE1HU+DXgOHDgAs9mMxMREl+sTExNRXV3d6cfJycnBVVddhQ8//BADBw48abA0b9481NXV2b/27NnTredARH6KGR4i6gavh7Rk+PTTTzt9X6PRCKPRCJPJBJPJBLPZrOq+EZFGnFvR2ZZORF7yaYYnISEBoaGhqKmpcbm+pqYGSUlJvtyUh4KCAmzbtg2bNm1SdTtEpBUOaRFR1/k04ImIiMC4ceNQXFxsv85isaC4uBjZ2dm+3JQHk8mEESNGYMKECapuh4g0wiEtIuoGr4e0GhoaUFFRYb9cWVmJ8vJyxMfHIzU1FYWFhcjPz8f48eORmZmJxYsXo7Gx0d61pZaCggIUFBSgvr4esbGxqm6LiLTADA8RdZ3XAc/mzZsxadIk++XCwkIAQH5+PpYtW4YZM2Zg//79mD9/Pqqrq5GRkYFVq1Z5FDITEXmFGR4i6gavA56JEydC6eDT1Zw5czBnzpzu7JfXWLRMpHdKmz8SEXWGX66l1RUsWibSOZfOLEY8ROQd3QQ8RKRzLouHsi2diLyjm4CHXVpEeseiZSLqOt0EPBzSItI5Fi0TUTfoJuAhoiDCDA8ReUk3AQ+HtIh0jhkeIuoG3QQ8HNIi0jvW8BBR1+km4CEinePioUTUDQx4iCgwcEiLiLqBAQ8RBQgOaRFR1+km4GHRMpHOMcNDRN2gm4CHRctEescMDxF1nW4CHiLSOWZ4iKgbGPAQUYBghoeIuo4BDxEFBpe2dAY8ROQd3QQ8LFom0jkOaRFRN+gm4GHRMpHecUiLiLpONwEPEekcMzxE1A0MeIgoQDDDQ0Rdx4CHiAIDMzxE1A0MeIgo8DDDQ0ReYsBDRIGBq6UTUTcw4CGiwMAhLSLqBt0EPJyHh0jvWLRMRF2nm4CH8/AQ6RwzPETUDboJeIhI75jhIaKuY8BDRIGBGR4i6gYGPEQUIJjhIaKuY8BDRIGBq6UTUTcw4CGiwMAhLSLqBr8LePbs2YOJEydixIgRGDNmDN5++22td4mI/AKHtIio68K03gF3YWFhWLx4MTIyMlBdXY1x48bhwgsvRM+ePbXeNSLSEjM8RNQNfhfw9O/fH/379wcAJCUlISEhAYcOHWLAQxT0mOEhoq7zekirpKQE06ZNQ3JyMgwGA1asWOFxH5PJhLS0NERGRiIrKwsbN27s0s6VlZXBbDYjJSWlS79PRDrCDA8RdYPXAU9jYyPS09NhMpnavH358uUoLCzEggULsGXLFqSnpyM3Nxe1tbX2+2RkZGDUqFEeX1VVVfb7HDp0CNdffz2ef/75rj43ItIT54CHi4cSkZe8HtLKy8tDXl5eu7cvWrQIs2fPxqxZswAARUVFWLlyJZYsWYK5c+cCAMrLy0+6jaamJlx22WWYO3cuzjrrrA7v29TUZL9cX1/v5TMiosDAIS0i6jqfdmk1NzejrKwMOTk5jg2EhCAnJwelpaWdegxFUTBz5kycf/75uO666zq8/8KFCxEbG2v/4vAXkU5xSIuIusGnAc+BAwdgNpuRmJjocn1iYiKqq6s79RhfffUVli9fjhUrViAjIwMZGRnYunVru/efN28e6urq7F979uzp9vMgIn/EDA8RdZ3fdWmdffbZsFg6Pz5vNBphNBphMplgMplgNptV3T8i0ggzPETUDT7N8CQkJCA0NBQ1NTUu19fU1CApKcmXm/JQUFCAbdu2YdOmTapuh4i0wgwPEXWdTwOeiIgIjBs3DsXFxfbrLBYLiouLkZ2d7ctNeTCZTBgxYgQmTJig6naISCPM8BBRN3g9pNXQ0ICKigr75crKSpSXlyM+Ph6pqakoLCxEfn4+xo8fj8zMTCxevBiNjY32ri21FBQUoKCgAPX19YiNjVV1W0SkAZfFQ9mWTkTe8Trg2bx5MyZNmmS/XFhYCADIz8/HsmXLMGPGDOzfvx/z589HdXU1MjIysGrVKo9CZl9jDQ+R3nFIi4i6zqAo+nrnsGV46urqEBMTo/XuEJGvVH4JvHSx+Pm0i4GrX9N6j4jIh9Q+f/vdaulERG1jhoeIuk43AQ+Llol0jkXLRNQNugl42JZOpHfM8BBR1+km4CEinWOGh4i6gQEPEQUGtqUTUTfoJuBhDQ+R3nFIi4i6TjcBD2t4iHROafcCEVGHdBPwEJHeMcNDRF3HgIeIAgOLlomoG3QT8LCGh0jvmOEhoq7TTcDDGh4inWOGh4i6QTcBDxHpHNvSiagbGPAQUYDgkBYRdR0DHiLquuZGoPmYnG0xyCGibtBNwMOiZSLJLGbgmWzgmTMBi4whJmZ4iKjrdBPwsGiZSLKWY8CRX8RX63H1t8eiZSLqBt0EPEQkmfQiYmZ4iKjrGPAQUdfIDnhctiEp4GmoBTa9CJyol7M9IlINAx4i6hrnLIuUgEfy9gDgq38CK+8CvnlDzvaISDUMeIioa1wyPDIyLhoMaZ04Yv1eJ2d7RKQaBjxE1DXSh7Q0KFq2bZMTHRIFPAY8RNQ1zkGAxSx527ICHovrdyIKWLoJeDgPD5FkzkGObjM8DHiI9EI3AQ/n4SGSLBja0hnwEOmGbgIeIpJMy7Z0WQGILYvFgIco4DHgIaKuCYqiZWZ4iPSCAQ8RdU0wDWnJLsomIp9jwENEXaPlxIPSMzxcyoIo0DHgIaKu0XTiQQmbA+fhIdITvwt4jhw5gvHjxyMjIwOjRo3CCy+8oPUuEVFbWMNDRAEkTOsdcNerVy+UlJQgKioKjY2NGDVqFC6//HL06dNH610jImcuAY+MGhe2pRNR1/ldhic0NBRRUVEAgKamJiiKAoXj50T+Jxja0hW2pRPphdcBT0lJCaZNm4bk5GQYDAasWLHC4z4mkwlpaWmIjIxEVlYWNm7c6NU2jhw5gvT0dAwcOBD33HMPEhISvN1NIlIbh7SIKIB4HfA0NjYiPT0dJpOpzduXL1+OwsJCLFiwAFu2bEF6ejpyc3NRW1trv4+tPsf9q6qqCgAQFxeHb775BpWVlXj99ddRU1PTnedIRGpQJC8toemQFtvSiQKd1zU8eXl5yMvLa/f2RYsWYfbs2Zg1axYAoKioCCtXrsSSJUswd+5cAEB5eXmntpWYmIj09HR8+eWXuPLKK9u8T1NTE5qamuyX6+vrvXxGRNQlzPAQUQDxaQ1Pc3MzysrKkJOT49hASAhycnJQWlraqceoqanB0aNHAQB1dXUoKSnB8OHD273/woULERsba/9KSUnxwTMhog7JnodHkwyP4vqdiAKWTwOeAwcOwGw2IzEx0eX6xMREVFdXd+oxfvnlF5xzzjlIT0/HOeecgzvuuAOjR49u9/7z5s1DXV2d/WvPnj3dfh5E1Amy5+FhhoeIusHv2tIzMzM7PeQFAEajEUajESaTCSaTCWYzx9qJpNCia8q+PUkBDxcPJdINn2Z4EhISEBoa6lFkXFNTg6SkJF9uykNBQQG2bduGTZs2qbodIrIKirZ0ZniI9MKnAU9ERATGjRuH4uJi+3UWiwXFxcXIzs725aY8mEwmjBgxAhMmTFB1O0RkxaJlIgogXg9pNTQ0oKKiwn65srIS5eXliI+PR2pqKgoLC5Gfn4/x48cjMzMTixcvRmNjo71rSy0FBQUoKChAfX09YmNjVd0WEbkFAVJWE+dMy0TUdV4HPJs3b8akSZPslwsLCwEA+fn5WLZsGWbMmIH9+/dj/vz5qK6uRkZGBlatWuVRyExEAS6YMjxSAjoiUpPXAc/EiRM7XOphzpw5mDNnTnf2y2ssWiaSTHpNjRarpTPDQ6QXfreWVlexaJlIsmDK8HAeHqKAp5uAh4gks8ieh0fy9sAMD5Ge6CbgYZcWkWSaDmmxLZ2IvKObgIdDWkSSBdWQFgMeokCnm4CHiCTTNMPDgIeIvKObgIdDWkSSBVWGh92fRIFONwEPh7SIJHMJeHQ68SDX0iLSDd0EPEQkWVBkeJQ2tk1EgYgBDxF1jZYBD7u0iMhLugl4WMNDJJkie4gpSIqWmxvlbYsoiOgm4GEND5FkQTGkJTng2VsGPDoIWLNQzvaIgohuAh4ikoxt6b5X/R1gaQGqvpazPaIgwoCHSE8a9gPmVjnbYoZHhe2ZXb8Tkc8w4CHSi0OVwD+GA/+5Qc72nE/Kul0t3focLZICEBZJE6mGAQ+RXhzaKU7Q+3+Ssz1meHzPtiCrrACLKIjoJuBhlxYFPfucMZJbtiHpBC29ZkiDeXiY4SFSjW4CHnZpUdCzSK7/YNGyCtvjzM5EatFNwEMU9KSfnCVPBBgUQ1qSa4aIgggDHiK90KrAFpx4MGC3RxREGPAQ6YVWJ2dZ29QiwyN78VC2pROphgEPkV5IPzkHUw0P29KJAh0DHiK9sJ0kNRnS0mmGh23pRLqhm4CHbekU9HQ/pKVFgKVRqz8zPEQ+p5uAh23pFPR035buvG0JGR7pq8GzLZ1ITboJeIiCnuwhLYvkpSVkD2lpMtEhh7SI1MKAh0gv7NkBWdkI5wyIjBO05IyL9LXCNCg8JwoiDHiI9EKrjiJoMMSk9wwP29KJfI4BD5FeyJ6lV8u2dBlkrxXmvE1meIh8jgEPkV4EU5cWJGSVtMjw2INWBjxEvsaAh0gvNB3Skl20LGGbmg5pMeAh8jW/DXiOHTuGQYMG4e6779Z6V4gCQzDNtAzZGR7Zbems4SHyNb8NeB5++GGceeaZWu8GUeBwzg5IKSLWOMOjdk2PRcMMD9vSiXzOLwOeHTt24Mcff0ReXp7Wu0IUOGS3UQdVhodt6USBzuuAp6SkBNOmTUNycjIMBgNWrFjhcR+TyYS0tDRERkYiKysLGzdu9Gobd999NxYuXOjtrhEFt6BY6sHlCpW3x7Z0Ij3xOuBpbGxEeno6TCZTm7cvX74chYWFWLBgAbZs2YL09HTk5uaitrbWfp+MjAyMGjXK46uqqgrvvvsuhg0bhmHDhnXvmREFG+dhEBlDIs4BiJSuoiDI8LBomUg1Yd7+Ql5e3kmHmhYtWoTZs2dj1qxZAICioiKsXLkSS5Yswdy5cwEA5eXl7f7++vXr8eabb+Ltt99GQ0MDWlpaEBMTg/nz57d5/6amJjQ1Ndkv19fXe/uUiPRBesZFwyE0cYW87cnufGNbOpHP+bSGp7m5GWVlZcjJyXFsICQEOTk5KC0t7dRjLFy4EHv27MGuXbvwxBNPYPbs2e0GO7b7x8bG2r9SUlJ88lyIAo7sE7TWQ1p6bEtnDQ+Ranwa8Bw4cABmsxmJiYku1ycmJqK6utqXm7KbN28e6urq7F979uxRZTtEXtv/E/DqlcAe72rYukz6kJbei5Y1WEtLdlu6xQKsKADWPytne0Qa8npIS6aZM2d2eB+j0Qij0QiTyQSTyQSzmcV+5Cd+eBeoWA3EDgRSMtXfnu6Llju8wsfba2NmZ4NBzjZltaUfrADKXwWiEoAzb5OzTSKN+DTDk5CQgNDQUNTU1LhcX1NTg6SkJF9uykNBQQG2bduGTZs2qbodok4zt4jvlhY522Nbuo83J3kIDRoMaZmbrd8lvUaJNOTTgCciIgLjxo1DcXGx/TqLxYLi4mJkZ2f7clMeTCYTRowYgQkTJqi6HaJOs3fcyJqlV+8ZHg3b0tu6rOY2ZRdJs2aIgoDXQ1oNDQ2oqKiwX66srER5eTni4+ORmpqKwsJC5OfnY/z48cjMzMTixYvR2Nho79pSS0FBAQoKClBfX4/Y2FhVt0XUKbJXL2cNj483p2HAA1lDaFzKgoKH1wHP5s2bMWnSJPvlwsJCAEB+fj6WLVuGGTNmYP/+/Zg/fz6qq6uRkZGBVatWeRQy+xpreMjvyD6ZSO/SUtr+WbXtSQ5A3B9fdhBpMQOhKpdZWiTXDBFpyOv/pokTJ0Lp4M1tzpw5mDNnTnf2y2vM8JDfkZ3h0XRIS3KAJYMWGR6L7DosZngoePjlWlpEuiC7HoNDWr7lfgz1GETKDsqJNKSbgIdFy+R3girDw6Jl32xTowwPFPkZNCLJdBPwsC2d/I7sDhjZJ0vZwy/BVrQsI1CW/jck0o5uAh4iv2Ovj5C88CR0OqQlPcMjOcCC2xpaUuqiJA+DEmmIAQ+RWqS3pet8SCsoMjzOGRfJnW8sXCad003Awxoe8jvS29LNbf+s2vY0DLBkbDMohrQkb49IQ7oJeFjDQ35H9hwn0oe0ZM/DI3tIy71LS4c1NbKDZCIN6SbgIfI7smt4pJ8sOaSl6jZlB1jM8JDOMeAhUovsla/Zlu7j7Wldw6PD7RFpSDcBD2t4yO9YtKzh0WG9icf29RjwsC2dSC26CXhYw0N+R5HdpaXzmZaDIcMjvS2dRcsUPHQT8BD5HYvkGh6XImI9BjzuAYjsgEd2m7iMeX9YtEzBgwEPkVpkr6Wl5ZCWJkXLKm/TonENjxarsxPpGAMeIrXYi5Y507JvtqfxkJYujykzPBQ8dBPwsGiZ/I7somVN29JlLDwZBG3psoeYXOq+WLRM+qabgIdFy+R3ZBctB11butrbC7a2dGZ4SN90E/AQ+R0t29L1OPwSDBke5+fEtnQin2LAQ6QW2RMP6n3xUK1rePQ4pMWiZQoiDHiI1CK9LV3DOVxkbw8yMjzua2npsC6KbekURBjwEKnF3pYuK+AJtiEttVdLlzyEBi3+hlxLi4IHAx4itbBo2cfbC4IhLb3/DYk0xICHSC1B1ZYeDEXLsouIuVo6kS/pJuDhPDzkd3Sf4VHa/lnG9sQVKm9P4y4tPbbBE2lINwEP5+Ehv2PrmmJbukrb12PAI/lvKHuxUiIN6SbgIfI79gyPpGBA9slL+hBaMGR4NFxagkNapHMMeIjUIr1LS+cFr7IDEPcAQPo8PDqc94dIQwx4iNTCmZZ9vUG3i3rM8GjZls4aHtI3BjxEatF90TLb0lXdJjM8RD7FgIdILcHUli4lqJOd4XF7fLUzIIqi7ezVrOEhnQvTegfakpaWhpiYGISEhKB3795Ys2aN1rtE5D3Za2nJPnmxLd3H25M8k7T7NtiWTjrnlwEPAKxbtw7R0dFa7wZR19mDDkWczAwGdben9yEtjwyP2puTHfC4BanSV0tnhof0jUNaRGqRnXHRcqVtXdbwSO7SCoYiaSINeR3wlJSUYNq0aUhOTobBYMCKFSs87mMymZCWlobIyEhkZWVh48aNXm3DYDDgvPPOw4QJE/Daa695u4tE/kH2LLZ6z/BIz7iwDZ5IT7we0mpsbER6ejpuuOEGXH755R63L1++HIWFhSgqKkJWVhYWL16M3NxcbN++Hf369QMAZGRkoLW11eN3P/nkEyQnJ2Pt2rUYMGAA9u3bh5ycHIwePRpjxozp6nMk0ob0jAvb0n27OY0DLK6WTuRTXgc8eXl5yMvLa/f2RYsWYfbs2Zg1axYAoKioCCtXrsSSJUswd+5cAEB5eflJtzFgwAAAQP/+/XHhhRdiy5Yt7QY8TU1NaGpqsl+ur6/39ikRqUPTAESHAY/ui5a1yPBwaQkKHj6t4WlubkZZWRlycnIcGwgJQU5ODkpLSzv1GI2NjTh69CgAoKGhAZ999hlGjhzZ7v0XLlyI2NhY+1dKSooPngmRD2i61IOMrinZwyFBluGRnRXkkBbpnE8DngMHDsBsNiMxMdHl+sTERFRXV3fqMWpqanD22WcjPT0dZ555Jq6//vqTroA+b9481NXV2b/27NnT7edB5BPSMzxOAYAeh7SkZ3gkt4m7z/Ojy7mUiLTjd23pgwcPxjfffNPp+xuNRhiNRphMJphMJpjN/KclP6HlQpBSsgPO8/DoMMMju4iYbelEqvJphichIQGhoaGoqalxub6mpgZJSUm+3JSHgoICbNu2DZs2bVJ1O0SdZpGc4dFypmUp2+vwCh9vT+shLbalE/mSTwOeiIgIjBs3DsXFxfbrLBYLiouLkZ2d7ctNeTCZTBgxYsRJh7+IpNKyLV2XQ1o6D0DYlk6kKq+HtBoaGlBRUWG/XFlZifLycsTHxyM1NRWFhYXIz8/H+PHjkZmZicWLF6OxsdHetaWWgoICFBQUoL6+HrGxsapui6hDmqyLpPMMT9AVLeswSCbSkNcBz+bNmzFp0iT75cLCQgBAfn4+li1bhhkzZmD//v2YP38+qqurkZGRgVWrVnkUMhPpmiZzquh94sEga0tnDQ+RT3kd8EycOBFKB5+s5syZgzlz5nRnv7zGomXyKx7DEyq/Lt0zSnoMsIIuw6PDrCCRhnSzlhaLlsmveGR4uNJ297encYZH7SBSi7Z02YX1RBrSTcBD5Fc8Zs1VO8MjeXsIxgyPzgIsaDCVAZGGdBPwsEuL/Ir7yUr17IDsOWPaOPnLDgj0XsMjZbZs52FQDmmRvukm4OGQFvkV6Rke2cMvbTy+2tv0GLbTW8CjQQ0P19KiIKKbgIfIr8iux9A6wGrvOt9u1O2izgIeLebh4cSDFER0E/BwSIv8iuwWY63rTdq7zqfbZFu6z7EtnYKIbgIeDmmRX9E6OyA7wGrvOt9u1O2i3tbSYls6kZp0E/AQ+RXpAYjktvSgzPCwLZ0okDHgIVKD3tvSNc3wGKwX1Q54NA4ipbelM8ND+qabgIc1PORXtG5L1+OQli0AMdjetvQ2D48GbenOWSVmeEjndBPwsIaH/Irs4RCtW6ilbNMt4NHbYp6a1PCwLZ2Ch24CHiK/Ir3gNQgmHoR7wKOzLi22pROpigEPkRqkr6Uluf5DywxPSKjtCpW3p3GGR3pbOmt4SN8Y8BCpQXYRsWYt1AanjIvaJ2hbhsca8MiqqZE2hKZxhodDWqRzDHiI1KB1EbGsmqGQUKcARKdFyyFhrpfV4tGWLnlpCa6lRTqnm4CHXVrkV7RuE5eVjTCEyMuA2DM8strS3QIe2UGrjACEGR4KIroJeNilRX7F/WSl17Z0mQGP8zalbM9WMyQpw6PFkBYnHqQgEqb1DhDpku4zPM7Bh8H1OtW26T6kpTKPIS2dzezsvg1meEjnGPAQqUHzSet0GPBo1ZYeGu56WS2atKVz4kEKHgx4iNSgddGyrLW7XAIeSUs9yGpLtx1DaUNabEsnUhMDHiI1SG9L12pIy6BBhkdWW7pTJxo0CHhkZ3gY8JDOMeAhUoP0DI9GNUOa1vDorC1dixoeFi1TENFNlxbb0smvaF20rEWXluonTI3b0mVPHsm2dCKf0k3Aw7Z08ivuJ2PZbekyi5alDflotHioZhketqUT+ZJuAh4iv6LZUg+Styd1Hh7ZQ1paz8PDtnQiX2LAQ6QG6W3iGmZ4ZM+0HCJ5LS17W7qkrjD79iUEkC5Fy2qvdk+kLRYtE6lB723ptsc3hDrV1Ogtw6PxkJasqQVkbY9IYwx4iNSgeVu6xHl4DG7XqbdR6zZlt6XrtIZHiyE0Ig1xSIsc9m4BDu/Sei/0QfO2dInz8Oi2hkfn8/DIfo3aHNkDVG+Vsy0tWMzAr5sBc4vWe0JuGPCQ0HgAeDEHePUKrfdEPZUlwH9vBo4dUn9b7tmHYGhLlzrZoQ4zPPaZncNdL6tFqwzPK5cBz0+S83+oha9fAV6cDHz1T633hNz4ZcBTWVmJSZMmYcSIERg9ejQaGxu13iX9a9wv3vDq92m9J+opNQHfLgd+WqX+ttxPHmrPqeJcUwOdFy1r1ZYuK4jUau0uWRmeul8BS4t4z9GjI7vF97o9Wu8JufHLGp6ZM2fioYcewjnnnINDhw7BaDRqvUv6Z252/a5HzdbAueWY+tvy6LiRdbKMAFqPSw54bBkXmet3Qf0hLVuQGiIpAFHcMjyqH08tFitVgNYm8bPtu97YhrLMrVrvCbnxuwzP999/j/DwcJxzzjkAgPj4eISF+WVcpi+2f05Li37bU+1vRBLG1rVqSw+VNRwSDG3ptiBSctGyrO3JXn8Nttel9e+m1xoX+/uMjj88BiivA56SkhJMmzYNycnJMBgMWLFihcd9TCYT0tLSEBkZiaysLGzcuLHTj79jxw5ER0dj2rRpGDt2LB555BFvd5G6wuL05mPR6ScTs8RPllq1pcvuKDKESBxGc8/wqMzjmMpanV2jGh4ZQ1pmp/89vQYEtvdSi04DugDmdeqksbER6enpuOGGG3D55Zd73L58+XIUFhaiqKgIWVlZWLx4MXJzc7F9+3b069cPAJCRkYHWVs+T6ieffILW1lZ8+eWXKC8vR79+/TB16lRMmDABF1xwQZv709TUhKYmxz9RfX29t0+J4PbmY25xZAr0pFXisJ1WbemhsoZDtKzh0WtbuvX5yKrh0WKxUpf3Gb0OadneZxjw+BuvA568vDzk5eW1e/uiRYswe/ZszJo1CwBQVFSElStXYsmSJZg7dy4AoLy8vN3fHzBgAMaPH4+UlBQAwIUXXojy8vJ2A56FCxfigQce8PZpkDvnf05zM4AoLfdGHTLrlGRP6uZe/yF1SIsTD/pme7a/oeSusPYuq6HV7YOVHtnKA/T6/AKYT3PDzc3NKCsrQ05OjmMDISHIyclBaWlppx5jwoQJqK2txeHDh2GxWFBSUoLTTz+93fvPmzcPdXV19q89e1gZ3yXOw1gc0uo+rdbSkrUMgj34cJ6HR9bEg7Lb0iUN2Vnc6rD0OPGg84cN3RYtW58jh7T8jk8DngMHDsBsNiMxMdHl+sTERFRXV3fqMcLCwvDII4/g3HPPxZgxYzB06FBcfPHF7d7faDQiJiYGr7zyCs4880xMnjy5288jKLmkmnU6tq5l0bKspR6kDWnZshGhcoa0nIMbzVZLl1WHJSlL55HhkVC0HAzvMxaJ7zNaUBTgnRuAFbdrvSde88v2p46GzdpSUFCAgoIC1NfXIzY2VrV90y2XIS2d/qPaPlHKqB3Qqi1dWgu105AWJAxpOQc8toyL6kNa7m3ikjvtZE9WKaNLyzmro9f3Gb0PaZ04Anz3H/HzRYuA8Eit96jTfJrhSUhIQGhoKGpqalyur6mpQVJSki83Rb5mDoYuLesnylYNipZl1fCESp4kT1rRclsZHknDdrKLiLWaeJBFy76h9yEtl3NFYD1HnwY8ERERGDduHIqLi+3XWSwWFBcXIzs725eb8mAymTBixAhMmDBB1e3olsW9aFmHZBYta1XDI23SOskBT1tDWtLX0mJberdxSCvwBfBogNdDWg0NDaioqLBfrqysRHl5OeLj45GamorCwkLk5+dj/PjxyMzMxOLFi9HY2Gjv2lILh7S6KYBfxJ2iKE4Bj4RPlrLX0rK3pUdYt6fBkJaqJ0zngEfvbemS5/2xb1920bJOAx6ZtYJacP4bBthogNcBz+bNmzFp0iT75cLCQgBAfn4+li1bhhkzZmD//v2YP38+qqurkZGRgVWrVnkUMvuayWSCyWSC2SxpPRi90XvAI/v5yV5Ly31IS7GIE6ato8nn29Owhkf3beka1fDIKFpu1WDiwfp9wJ71wGnTHP8fajLrfOJB5yAnwM4VXv/1J06cCKWDTx5z5szBnDlzurNfXlM9w1P7A1D6L+C8+4C4VN8/vtYsgTsu2ynOWR1N2tIlFy0D8gIeGfPwOD+2tHl/NJq9Wtdt6RoMnX/8Z+D7/wLXLAeGT1V/e8E0pBVg5wq/W0vLb21eAnz9qlhtW4+0eCOSSfbz07otva198CXp8/BoULRsr6mRPBGgrNXZ3TM6el1aoqHW+r2mo3v6ht6HtFzqPQNrSEs3AY/qRcvN1hW2W46r8/ha0/uQluxUuu3kYa83kbyWFlQ+gWlZtCytLd3tmMrqfJM+l5KkjBI0+mDVekLu9vQ+pMUMj/YKCgqwbds2bNq0SZ0N2NOUOsx+wD1qD6wXcafIHtKSvnq5bXsRTtdJGGJiW7oPtyc5ALG4vWZkDGk5/+/JKlq2bdMW+KhN72tpBfCHY90EPKoLphdxgEXtnSK9aNl6spQ9EaC0Ia1gakuXNaTl1mknu9Bdr23ptkBH1lIWFp1PPBjA9Z66CXhUH9LS+7is+2rpeuMypCWxaFnaJHJtFC2reQKzD9lpkeEJ9bhKnU1KnofHHrTKrhmyvWYU9Z+jFhMPtkpcQw9BNqTFGh5tqD6kJXPSOi1o0Wp4tAbYv13OtmTP/+E+xCR7pmXIGtLScC0tvWV4pLeltzEMqvbrVIulJew1PLICHqfRANUX1NVAAI8G6CbgUZ3uMzwavIhfuQx49jdA40H1tyU7lS67PqLNtnTZNTwShtAgc/FQyV1a0tvSJQ+DQqPV0mVneOwfHhU5w4SyBXC9JwOeztJ9mlKDsfXDu8TxPFql/rZkp9JlFy27tzRDVsBjkDQvjnOXlqyiZckLsmrVli4zw6PF0LnsGh6XmYh1eL4I4HUXGfB0VlANaUl4ESsK0GJr9ZfQPdEq+Y3Wo4ZH5tpWoa77IGt7agYgfrGWluy2dFlFy5I6+6DBBytFcXzAkV3D4/6zXgTwTMu6CXjUL1oOoi4tGW9ELu2pEgIe6W3pbi3Nsmp4QmQNMdkmHpRVtOxEWlu6RgGIrBoe2ZNVwv2Dh4T/Q+nNChbXY6jH8wVreLSnftGy3mt4JKdhW50mcJQS8Lg9P9VPlu4nL7VnBXYqIrZnJHQ0D4/sDI/LRIdt1PC0Nvv+vcB98VCo3JruPuwKHQ5pOb+3SFlSpuXkl/UggDt6dRPwqE72xIMWC7BzDXDskKTtSU5TOs9YLWP2avfOLLX/jloVLTsHIN09eTUdBdYXidfgsUPAtveAE/Xtb+9EXfe2d1KSV0uv3+v42Rbw1FcBP38hjsELk4DFo8Ux8hWPNnGVg0jZ24MGmdZWydtzf+8MsICgU5zPFQFWwyNh6VidkD2ktfMz4LUrgPRrgOlF6m9P9rizc5Aj5Y3ILcBpbQLCjOptT6uZlkNCnQICL05e5hagbBlQvRU4//+A6H5AyRPAV4uBX9aKYKayBDDGAONmOuqvDCFA/GDx8xd/B3r0BrJuEfc3xvhu8dK2Fg/1ZYbn+GHgvzcDgycCwy8EllgXmYwfLJ4TrK+hly8BevUHju4T1+36yncLUrbbNaXS27R7jRJkZHgkv8+4ZHgkZ5LbuqwHAVyjxICns2R3adX/av2+t6N7+ob0IS3nNyIJGR738Xu1/1G1zPCEeDnEVP0d8M4s4MBP1svfAjNXAhWfiss/vO+4b1M9sO4px2VDCPCbO4G6PUD5a8DqBUCvJODtmcD4G4GLnvDR87MFNwbrl4+zEZteBHZ8AlR+KY5HQzXQ9zTgd28BzQ2u97UFO4A4RhueBeIGAZc8JTKznz8CHNwJXLxIvM4MoUDPPp14jlpleKxBsmKWUMMjuaZG+hp6rSe/rAcBPNOybgIek8kEk8kEs1mlf1jZXVqazR2hxZCW5C4tSHiz1aot3XkiwM5sc+dnwBu/E0Fnz77id6q+BpZfB9R853rfsfnAaRcBpf8Cdq0VJ+OB44GInsClJmDPRuDgDuC/t4jbNr0ADJsK9E8HeiZ0M9vjvDq7LeDpRobHYgF2fAz88pUIVjb9W1zfehz45nXx85SHgd6DxH2z5wCxA4HEUcDnC8Xf9efPgbKljv+dcTOBzUuAr18Rl2u+Bw79LI7rnI2AsVcH+yS5pkZxq/sym/XXpSU9w6PBkFZrE7BqLjA013fZxpNx+RsGVkCnm4CnoKAABQUFqK+vR2xsrO83ILto2T53hOQF76DFkJaMDI/kVLPHwpOyJh4M6fyQ1ok64H+3ieM/5Hzgin8DB3YAS3KBncXiPj37Ao37RR3LOXeJAGBYrnija2kEIq3/awYDkPE7oPgB17/na1eI7z16A0OnAGfdASSNBj59AKj7FbjsGdcTfLvPr40MjzdDWgd3AjtWA2OvA8Iigf/dAmx9u/379+wrhrdgPaa5DztuO+Uc4MgeYPEo1w8Kb/5OZH8MIUBYD+CAdRbxo1ViuPCsO4DyN4A964GpfwfCI92eY1tDWhKKlp2HQXVXtCx5sVIthrR++UoE2nu3SAp4nGt4AivDw6LlzpIe8Gg5d4TsT15a1PBILlqWtRBkWzMf//gh8Nx5QO0Prr/z6f1i6CZ+MHD160BUPJCaBYyc7rjP2OuB374CXPu2CHZsQsMcwY7NmBmOYOT0S4DepzhuO34Y+HY5UHQOsKIAWLsI2PoWsOvLzj5B6/PrYoZnxe3AqvuAV68E3rpeBDshYUD674DwnuI+o69y3H/k5a7dUu7iUoC4VNfrbENdFz8pjteg3ziOZalJFD1/8EcR/Hz7ZhtPsa3ZsmWshxYqb64h2TMtO7/PSGlL12BIq7nR+r2ho3v6RgDPtKybDI/qZBcty87wWCRH7baiV0jq0vL45CVpSEvaLL1ttKWvng+cXQi8f6fI0mxeCpxxrRh6GvQbceIFgGn/BMJ7OB5r4jxg2wqxz4MniYxGZ8QOANKvBn5cKQqfY1NEFqlHb2BfOfDVU8D2lUD5q47fqSgW2aWOuGR47Fd2br+O7BZZFQDYvc76MCHA5S8Aoy4HzrsH2L0eGP1boH4fsGcDcMbvO37cQWcDR14HTrsYOPwLULNVBFBj80VQNutDEVjv3iCyPC9f6vh/3vIyMCxPvE5ikq1Px23xUEhqS3fJ8Kj8OpU9Aaj0Li339xkZ76UnXL+rLYDn4WHA0xmKIr8tXXqGR/aQluSxdffjKK0tXYuZlq0Znp2fiS+b3aXAz2tEcXJknPid4RcCp5zr+lh9hwEXLxZLfwz6jXf7cdmzIni2Pe+IKPE99UxgYKZ1KOktkfkyN4upFzr3BK3Pz+D9xIPf/098TxguTu7xg8Xw3ICx4vr4wY5Os2veENko52xWe867R+zLefeI11dFMTB+lmutUlgEkLNAPG9bUTgA7C0Tbe1QgCkPAZk3a9eWbjA4FbqrneGRXbQsO5PsXsMjMVsuozQAgb1aOgOeztAiorUHPBpE7VICHqcMjxbFhGoPaWm1WnpIaPudfdXfOn4+cUR8P+/etu87Lr9r+2EwtF+TExIianZOuwjoOxx4Jhuo/V5kVWL6n/xxXQI6L4ufv/uP+J51CzDhxpPfNzJGfHVG/GDgMpPjct/hbd8v/Wqgqlx0c/XqDySfAWz/0HHC/+heMRzm0iZuEMHQZ38Dcu4Xw42+5rLivRY1PDocOtdiSKtVcoaHXVo6p8WYpewF71y6tCS/Ecn4R/VoS9drhsdpTpWe/YBRV4gT6A/vA0d+EddHRIvx/tMuFidfmULDgZGXiZ+TzwCqtogs1BnXnvz3utqWfqgS2PeNOC4jLu3mznfDlIdE5ix5rDgGdb+KwC8iGvjkL8DaJx33NYQ4MlpbXhJBs6/a+525tKVLyvA4f9BQLCJDcLJaqW5vT3JGSYshLfuH4+Pi/8RXc1+1h/Pw6JwWK4k7Z3ikvIid5+GR8KlEdpeW7JmWPdbS8vHQxOYlogh5ykNissAdq8X1hhAxWeWO1WIunb7DxPXHDjoCnskLgAHj2s9IyHJqjgh4flzZccDT1aLln1aJ74POEq3xWgkNA8bf4Lh8q1Ox9ok6oOQxx+UwI5A0xpGR++lj4MLHff8eoLRVtCyxLd12WdWAx7louVn8H4ao2Kuj5ZCWYhHbD4vo6De6hzMta0/VeXi0iGidX8TONRFq0XKmZSkZnjZmWlaT+5CWLz85H60BPrxHvC7q9gI/feTalj69yHMm6dQzgW/eED8Pn+rZYaSFUZeLE/2OT8TSFScbtulqW7ot4BkmoV23qyb9GeidJmqswnuIYugbPwGaGoAnRwJ1u0UB+r5y4NJnRIeYLzgPoWkxpGW/HKXe9tqq3QuJbO/e3ef+3illSMu5MPu4+gEP19LSnqqLhzr/gRWz+m8K0GA1celDWrIXD9VqSEuFGp7y1xx/r+0rxYkrIlrM/TIwU1zvvmzGqTniPoMn+kewAwD9ThcT+VlagG3vdnDnLmR4TtSLpR/g5wGPwSAyXJf+S2RywiJE4BPd19Eht+4psbTHR/eJy4oC7PhUtNm//8euZRBd2tIlrXgve54a9/cWtd9r3GtaZC+fIeXDI2t49K2t2TOd159Rg3uxXUeztHaX9CEtrWdAlVS03NZK2x357r/Ax38Rw1ETZotg5ZP/EzP7tjY5Cr579gMaa0XQcONqEeS097qMHQj8catr+7k/GH2VmNF569uiw6k9Xcnw7PxMvCHHDwESTvXZLks1dIpjiQ9YA9ySJ8T8RT9/7ri+3+liQsjoJM8JDdujOHVpycrwyB5alt2dqeWQFiSVB7h8OA6sIS3dZHhU5ZGmlD1/hOSAQMY/qfTV0jXO8HR2SKvkCbGu1dEqcUJbfi3w7FlimYaDO8TwxrEDgDEWuPlzYPJ8McldRFTHQXhUvB8GPFeKAOaXr8RsyB3xpi3d1p01PM8HO6qR4XlAqFHM/Jx+jbjus7+J10aoUQTDsHZ6/TMdePXyzmd7LE5DWlpMPAgJQ8uyMzzuz0/2uoTM8JwUMzydoUXlvVnihFkWi+sbnZQ0rB+slq4mb9bSatgv5qYxhIqTGSDWblIUYL0JOLRTnNwuNYnnseVlIOMaMdHfOXep+zzUFjsQGHqBqOMpWwZM+Vvb97N3oTkPaZ3kxN5QK1q/AbHkRaCKSwVuXSta5SOixQr0h3YCUQnAxPuAuDQR5Pxsnc/ol69ENvDEEVEjZQuI2uJctCythkfyIr7u/+eqz7DulvGQkQFxr+FRG2da1jktWw2h03HnFslpWNvfMCxSHE+1n6PHWlonOTmvuA2oWO24nHWbY+2mAWOBjc8D594jAgOgEx1NAWb8DSLg+fpVMUOze/0RujCkZatzGjAeSBypym5LY+u0A4ALH/O8/Zo3xDw/e9aL5ULWW+cGKn8NGHO1mFiyVyIwcIJYDqR+HxCd2E5busoTHdpnkzaK4EftVnGtMzy6nOKDGR5903xcVu1/Ug2G7FyWlpA403JEtDXgUTtr5jak1XJMtI8njRYz8m7/CIg/Behzqgh2DCHiJJCaBVzwoONxRl9pHfbRsaFTgJiBQP2vwI8fiLmDPHhRtKwoIgsG6wrmehfeAxiULQKa7R8Bv24Wbfi7vhRrdtnW7YpOBNLOFkN9I6eLzjBIXEvL+UOcMRo41iQ/w6P2/73m5Q8yPjxypmWf2b59O2bMmOFy+Y033sBll12m3U55ZEBkBDwyh7R0HtDB6Z/U2EvUwEifabkVKDobuORfosX4+CHX+4+6Epj+nOsJPViEhAJjrhKT7/24su2Ax5sMT/VW4NDPIpvnvBCq3oWGAfnvi5q4HnHArrVi4diarcCBClEXZqtr+v5/YnkRuGV41FxLyznYiIgWc0OpXkTsPqSl9nupFkNakjM8nGnZd4YPH47y8nIAQENDA9LS0nDBBRdou1MehWiSX8SyMzwy/klbNGpLN0ZbL6vwRntkD7DjY5GtaDoqrnOfP+mj+4CWRiCqDxA3SEy8BwBn/0ndCdH83bA8EfDs+FS8Hj3mnfIiw/PjB+L7qTmOv3ewCDM6hgTTzhZfsK6o/eG9wK+bRCao/FXH8iKGEM8Mz8GdIjCf9GffDQk6v89EWFeoV71oWXLAo8mQlpYZHgY8PvPee+9h8uTJ6Nmzp7Y7osmQlsQMjyZDWm4Bj9qzSdv+ZhHW9n5fp7bNLcBrVwH7f3C9PsTtxN3SKL5nXAvkPCDajMN6AIkjfLs/gWbgeBEEHjsoJuBzX9DUmwzPD++L76dPU29/A01ET8e6XxYLcLhSFDjDtj6ZNeB5/bdA7iNA7TYROJqbRRegL9jex0KNjsyn6kNa7jU8On8vlV7DE1hDWl5/pCwpKcG0adOQnJwMg8GAFStWeNzHZDIhLS0NkZGRyMrKwsaNG7u0c2+99ZbL8JZmtC5Ek160LHniQUh4jrYhLHuGp5tvRO6/v6FIBDvGWNcgxzlTERnr+Dn9GpHROX0aMPQknTTBIiQUGJorft7+URt3sGV4Qk6e4TmwQ5ysQ8LEvDTkKSQEuNhp7a76KteaurVPAj+XiJ93fiZmwfYF2/tKaIRTwCM5wyO7hoddWn7F64CnsbER6enpMJlMbd6+fPlyFBYWYsGCBdiyZQvS09ORm5uL2tpa+30yMjIwatQoj6+qqir7ferr67Fu3TpceOGFXX1uviP7RWwxu0bOsj+VSBnSkt094VS0jG4e052fAY8NBv57C/DNcuCJ4aIVGAByHwLSnYJ0o9PK21f8W3ySTj2LGZ22nGb9X9/ysuecPG22pbsFPC3Hgf/dIn4ePBHo0Vv1XQ5YfYcDE/8sfj7tIuDwLsdtjfvFfE+wfoLf5vmhtlMUBWg86Lhs75SMcAy7SZ9pWef1kDLmNAumLq28vDzk5bU/kdeiRYswe/ZszJolZk0tKirCypUrsWTJEsydOxcA7DU6J/Puu+9iypQpiIw8+ayhTU1NaGpyvIjr6+u9eDadJHtIy2PcWXYNj+SJB2ENgNScE8+5aBldeI4/fw58/qiYN6byS6Cp3rUDBhDFthm/B1KzRYs1rBmlm4pFpqd/OlCwUdtFLP3Z8AuBQb8RQy3/uRGYtcoxa3BHQ1qKArx3B7C3TAQ6eW20b5OrifcBZ94qMo+HK4ENz4kJDm2LltoU/w3Y8oropsuc3f7rt+WEKMaPSRaX1z0NrP4rMO2folvOJcNjzXyq3Txge+8MCRcnZz0OaTk/JylFy5xpGQDQ3NyMsrIy5OQ4UvQhISHIyclBaWmpV4/V2eGshQsXIjY21v6VkuKjhfWcab3+i9ovYts/pW0ZBEtL51ai7g6PIS2VP5nY3hQ6G/Ac3gWsuF0U0a55BHj5UlFbsvVtoKEa6NXfceKdMBuYtxe4cokYLkgYKlYxT/8dkDha1Kf0Txf3TThVdNCQp5BQ4PLnRfdQ1dfA/252mgivg6LlzUvE38YQCvz2FaDPEPn7H4hsw6xn/wko/AE46w7Hbem/E8HJ8UOiuP6LR4GXL3OdnLC5Edi+Sgx7LckFFo8B9m4Rgcy6p8R9Pr0fOH7EEdy4DGlJ+vBoe57SPjxaX6Oyu7RkzmmGIMjwnMyBAwdgNpuRmJjocn1iYiJ+/PHHTj9OXV0dNm7ciP/85z8d3nfevHkoLCy0X66vr/d90CO7S0urDE94T6CpTvys5grt5hbHMTSEis4QNT95KYrjH7OtIa1S6/DsmbeLk+mxQ8CrVwAHK8QK47bhlPE3iOtqfxCTvTUdFSuXj77Ss+Da+cRBnRc7EJjxijj+294V9STn3n3yDE/dXmCVyB7jggccC26SdwwG0dlm+5/MuAbIugU48osIbFbNFS3uxQ8CDTUia/P5QpH9DI9y1AF9+Q8xHUDjfnH5+GEx5DvCOrWI1IDH+t4ZGSOmo1B9SRnbe2mUaFCQ3eAiu2g5wGp4/LJLKzY2FjU1NZ26r9FohNFohMlkgslkgtmswsRZ0oe0NOosiIhyBDxttgb7iPNwVo840Zmj1tizorj+vdyLln/dDHxsrWUICROLMH54jwhsbLPBAsDZhUDOAsdjBttcOTKdci5w0T/EENWG54Cz7jx5hue7/4i/8cBMsSQHdV1UvFje4+BOMbwYEgokZ4jbGmpEtuarxeLy1nccJ/iWY+L/x9Iq5lLab/2AO+hs4Je1wNeviC9YW+dtAU/ZMrF8hloF5tIzPNb3mvAeIuCRvZaW7MVDgznDk5CQgNDQUI9gpaamBklJSb7clIeCggIUFBSgvr4esbGxnfgNL8guRJOe4bH9k0a5XRfV7q90i/PziYwVAY8az/HNa0U25rcvOa6zZXh++gh443euf8uP7nX8HJUA5L9nXaH8BPCbPzluY7CjvvRrgM8eEifZ7SvFnEVA2xme7/9r/Z0Z/Nv4QnZB29dn3gJsfAGo3yv+P44dENf/5g9ikscB44GypWINs4MV4v3kihfE/9CaR4C6PeL+oeGOouWa74C3rgfurRQfuHzN9r5iax5Qu2bINoQVEQUck5ABMbe4zo4tPcMTWDU8Pg14IiIiMG7cOBQXF9tnRrZYLCguLsacOep+8lI3w+New6P2kJZGnQXOAY+aw3a2bE5YD8c2fR3wHKhwTED3ktN8LLYaHkCcSG1sxbIRvYDRVwCTF4hPu4G+DlOgCg0Hxl4PlDwObPq3mLMItrZ0p9XSD1WKeh9DCHD6pZrusu5FRAE3rgaO7Ab6nQa8c6PI1Ez6P9F5BQBxKSKw6XuayMzFJIvFWxNHAc9ZhxoPVTpq2mD939+zARgyyff7rFmGx/q+Jn2eIdbwnIzXAU9DQwMqKirslysrK1FeXo74+HikpqaisLAQ+fn5GD9+PDIzM7F48WI0Njbau7bUomqGR/aQlsfK3mr/k1qDm7AIx/i9ms/RFvCER4pPhujiJ5OWE6Iw8uBOURg8ZoYYqweAH9933O/4YcfPtlQ6nBYSTTkTyP9AtOLGpjhmnSVtjc0X9SC7vgS+e0dcZ4DraullS8XPaecA0X2129dgETtAfAHAdf/1vL3f6WJ1d3f9x4jsanOD6HB0/xD3/f/E8OXQHGDCTb7ZV0VxreGBhPdu9w+PagcE7sdR9QYXs2t3pN5reDZv3oxJkxyRuK1gOD8/H8uWLcOMGTOwf/9+zJ8/H9XV1cjIyMCqVas8CpkDitZdWrKmQw8JFwFB63F1X8itThkeW8Dj7SeTul+BN38H7PtGXP72TaDkCeCSp0Q9wA/W7E72HLG2UuUXQN/TxSfLsEhgyPlikc51T4tW25AQx2KK5B/iUoBz7gZKHgPWP2O90mlIyxYEAcC4fE12kbxw65fAf28Gxt8IbHrR9bYt1mHnnz4S/59n/L7txzC3iCGzI3uAhGHA0AvaH8Z0fp+2rRsmqwHEtnSG3jI8Hm33Oh/SmjhxIpQOWpbnzJmj+hCWO6lFy3rr0rJ9CgkNF1+tx1Ue0rI+n/AejnlWvPlkcqgSePkSkVrvES+GPn54TywY+VY+MPMDYO9mcWI86w6gV5LopgqPFKnt+3aJN1WDQQRI5L/Ouw+oLAH2rBeX21pcNXtOOyusk1+JHwzc9Kn4OaoP8M4sYOI84JO/uN7vvTtF1jXhVFGD9+1bIrAx9hINBbudpjg54/fARYscNUHOnN83pdXwuGV4ZK8GL2sKE5sAy/DoZrXCgoICbNu2DZs2bfL9g2vepSVpSMsW8EDl52hrXw13zvBYn2NrM7B6AbBjtevvbHgOeGQAUFEMvHWdCHbiBwO3fCFakW8rFW+SrceBZReL30nJEsEOAPRKdIzjh/dgcWugCA0TE+TZtDY5FS0DSBoNXPA3TXaNumHYFGDer8BZc8T/MazdeYMniiH1r18RH2yWXQysXQQszQOKzhbBjjEGOO1iUbf19ati6oK22IMBg6M7U9aHxwhZQ1paZ3gY8GjCZDJhxIgRmDBhgu8fXPqQlkYr/IaEO9aBUitybzoqPrHDWkMTbp1e2faPW/6aaHt942qgwvpp8Phh0bHT3AC8PVMMUUX0AmZ+KFpaYa0HyntUvLm1Hhf1AnmPqvMcSK5TJjp+PrrP9bYJs4N7lflAZvvQcebtQPwQIHeho36n/HUxF9OxA6KuLiJaBDqDJwGz1wBXvwZMs2ZnN77QdmbjhHWKDecV5GWtpWXP8Ohsklr384JiEYvRBgjdvFOom+HRuktL5pCWyqsY/+9WxzwePfs63ohshczfvGHdp1Zg+fXiU976IlHoCDi+Z90MxPR3fezkM0RLbVSCmBgw+Qx1ngPJFRICnHqB47Lzuk+jr9Rkl8iHMmcDd24BkkaJBWSjEoDGWuDQTiA2VQyDzd0DzN0NXL9CDHXBOnVBzEARFH3zhueJt/Rf4nv/DKdMsjXgOX5EndnkPQIelc8VHmsSqpzhaSujE0BZHt0EPKrSakjL1n6reobHeUjLaXmJ7jpQ4baSb7NYeBMQn+TyHhWFywDw7XKg7CXRnmoIEcFKS6MIkGwzIQ+2FsuH9wTObGeukNyHgXt3ivQ46celJqDfSDEBZPrV4oSS84CjOJT0ISxC/H0BoFcykP+uGJYOCfEchg4NAzKtGaEP/gg8MVQscwGIZoYtL4ufc+4Xk4jC+l66vgj4+yDH+4qz1maRMTpaLS4rCrDheTGXUGdoNqRlPTayMjyGEM/rAoBfzrTsd5zXmrK0Sgh4rI8fGSuGc2TNHRES7rsp3z97WHTXpF8DTC8S11VtEfU7UX2AvMfFm5itaPnAT8D7d4qfh5wPTHkYKPqNo1g1NRv43XLRppx8BtCzT/f2jwJLr0Tg9nWOy/P2cihLr867T2R/R13uGLJuz7iZYsbnmu9EpueNq8Xq75UlYrjl9EuAQdnAtvfE/au/FfNtAcDmf4uMsHMgtaFILHha8al4v9n+IfDRPeJD1h++6XjqA495eCSuFXbiiITRAOuH4/CeQPNR63WBE/Do5h1DSg2P7dOk6l1atrkjbJNlSZp4MDSi6zU85lZRSAwAXz0lgh1YMzd7Nok3pZ+sn77SznacrPpY09M9+4mOKwDIvFlMbJZ1q7icOEoMUYUZgUl/Bobndevpkg4w2NGvyBjg7D92HOwAQI/ewG1fAX+pEWvdQRETjjbViw9JF1sLmlOyxPDY8cOO9+9DPwP7ysU8XrbhrR2fWL+vBhoPONrnWxqBdf/seH9s2XJZQ1q2c0WP3uK7Wkv02NjOhc5dcQE027JuMjxSJh4M7ykK4XS3wq9tSCvMqUurrbFaM1BfJeZHAYDGgyLj0nJMdE/V7QaG5TkCm179RZHpvy9wnawqzWlxx7H54o0pfrB4I2qoBXpblxG44G9i9tWULNcZkomInIVHiuAm/Xdi+Cmqt3hvsb2f9UoUgdGah8VyJcePAD+vEV1gzQ2i2+/8vwK7rRllxSze22xD8ACw8UUxFN/efF3O6/ZJG9Kynit6xAGHrduzmNWbPNXs9uHY0hJQGR7dBDyqcs/wyKrhsc8dIXPiQesbxJaXgE0viLHhq5aKif7+e7NICQ+ZDExdKCb62/qW62P99JH4PjZfTCm/JNc12AFc62sMBqDvcPFzaLgj2IGtWDVHhSdMRLqUMkF8tSUyBsj7u/h56zsi4GluEJertwKvz3B9r7JNdjl0ivigu2cDsGyaKJyuLBHt8hcvFpmiNY+Ix7IPaUk+V9gmVoQ1y2Nrw/c1i9uHY0sLa3h0x+xWiKZ6mlJChudEvRh2GjHddUjLVsOz/UPHfd8tAHZ8KtK6ALCzGHhhsmMM96w7xCzGYUbg/T+KaeTzHhOfus69V2R5UrKA9+YAvU8RM6QSEWllWC4QnSiyMle8CBQ/AOwts942VQxpKWYxVDTpz+K+yy4WnWPPZDva279aLCZHPH7I9fFt02105lxx+BfxYbpngvfPwznDY7/uhHoBj+1c6DyFSQDNtqybgEfKTMtaRe2+yPC0HBdj1YkjRVbls4eAjc+J+S4GWj8RhYaJCb1qvgf6DBELAH79CrDtXXF76llikr/V8x2znY65GpjykGM7p11sTXdaayzOd5pFNfkM8QbCSf+ISEvGXsAdZaLbKKIn0PNp4Llzxck7/Roxv9PRKmDk5Y7gYeZK4L+zxdpuNrY5xXrEi/fBd28Xl23BS+sJYPtHYnj/mzdE99fFT4qFiQHRMfbxPPHz0CnA9Odcg5eO2NrQw6PE+665Wd06Htu5z7mjlxke+dSt4ZE9pNVGhkdRuh4o/PA+8NF9QP1eIPcR0cWweYm47dhBR83NwEzg9IuBM63Fwooi/kErVotx66tfE/+ov/+vyNbs3w5Mnu+6LVvXVVuSRnVt/4mIfM25LjBxpAg2ft0k3h9tQ/vOYvoD+e+LwuaW42JIy7aW34hLgDOuFavD1+0RjRYwiCzRG1e7Ps6xg8D4WWKWaOcaoZ9WASWPi6k1Gg+ISVjH5p88ALKdK8KMYooPc7O6NZ/Oc7aF+HAKE0l0E/Coyn1BOLVTeGa3gAcK8MQw0d596mTP+x+oEMNOYUYRgOxeL4rWTjlXZInenunY5y/+LgqMLS1iQq4DP4mi4ykPi2DHmcEg5j9ZbxLtn7ZPJRFRwJVL1DwCRERyjb6y44ksDQYxHAbrBJi2gMe2ltsQx8LamP6cCGIO7gAO7RILF+8rFxkiW5bIECLes/ueJgKjjc8DWbcA790hiq+PHRJZ9fbYgpuwSPFhs6lO5QyP9TwiY1Z+FTDg6QytMzyAmHl03dOOgKf2R2D7SuDXMpFWtdXTvOgUEBlCxdo0llYxbNXcCNRuEzU4IeHAtH+K59RUDwwY1/a+9EoUq4oTEZHDqCuALx4T75GDfuN5e/oM8eVsx2rg3Tnid045V6wcH3+KyKafcq54L3/5UlEIDQCVX5x8H5wzPNH9RAda5ReijlINLrPy2zI8rOHRF4tbhudkAY+tNbGt1XvbYm4Rqwa3nAB++zJQtkzMIwFrV4GzXV+KVvDSf4l0qrPUbNGO+OtGEdwoilgxfGexuD3zZrEezZvXiLHeGa8CyRmdPABEROQiLgW4vVScFzrbBj70AuDu7Z7XGwxiLbGleY5gB9YZo39ZJwKh8TeIoObYITGLdERP4MAOcb+wSCDzFlFqsPZJYNwsdQqXZa67qAIGPJ3hzfoony4QhWhXvyZe3B1Zu1jU2ADAC+cD+39w3OYeNFlagRfPd6wldOoFIuOTOAoYdJYYMz5aBcQOFPNM/GuCyAxFxokZR8MjgWv/I8aZE0d4eRCIiMiF8zQa3ZU0Crj5c7GcjrlJfLit/xV4aZp479/4vFgmY/MSoOpr198NixTF1msXiYBp+e+BnAWO9QSbj4lu2R69gU/+T3wgvuRpR5ams1yWIbJ1aTHgkU7dLq1ODmk1NwKb/i1erCtuA25fL8ZoN1i7oWIHAte/K9aLAUQ74xd/d/y+c7AD6zw8FzwoXsA9eovI/fAukaG57Nm2x5tjB4rvPeKACx8D3rlBrEZsKyYeynltiIj8Up8hwE2rRUDy7hyg/FXHkNGxg6K2B9ausKg+oj4ItilFwkSn2PLfizmG/r1OLLyaNBp4/bdihMDWyQVra/7hXWK2e/f6zfa0VbTMmZblk9ql1V5E++NKx0RWjfuBZ88SQ1VNdeK6ut3AhmeB3/xBXP7qKfFYw6aKyz+tElH6iEtF23faOY4sUfVWEfDAIOaNGHFpx/s9crqYuC9CpTkZiIjI9wwGIO03IuABRFOJpRX46p9ixOHat8WH4KfHWu9vnQbktIvEB+2Vd4kA551ZwKS/OIqkzc2OGZLfu0PUb4YagT993/E6YbYsEdwmqWWGx49VlQPfvSMWqOtouQJFEYHH8cPisj3D0yLGUUueAAafJyLl1ibRZgiIYGTXV6KADAASR4sF7DY+L4rcRlwKRPQCvvuPuP2cu4F+p4sWxWFTRQbIfb2opNHAFf8WL/K2OrXawyUZiIgCz+BJoowiup9Y0iI8EjjzNnGusdV3znhV1H2OvMzxe32HA1e9BBSdDRysEEEPIOYWOv1iIDpJfBhvqhfXm5vEQqoT57a/L4oCvHyJaNuHdc62rtTwNDeKoMu29pdkwRXwKAqw4nag9nvxQpr055Pff0MRsMrpReA88eB7d4ji4vUmMYvw3i2OSDfnfqBXMrB7nVixd/AkkZnZWya+njtXFBabm0Sr4sDxIqIfccnJ96ejlkkiItKHmP5AwQZx3rGVJIQZXWs7T58mvtz17ANc8zrw5rVi/rWwHsB594rgCRCBz7Z3xXnqaBWw8QUx8mCbIdrdL+scwQ6sHcDeZngsZuDFHJEluvUrIHZAJw+E7wTPksPNjSIoqf1eXC5/XfwBGg96zltw/IjI6nz5D9frbUtLHKwQwY4tjbhng/ijR8YB2XPEQpjhkcCQ88WQUkiomHn4yqVA8lixLkvFp+J3J8zmzMNEROQpLlUEL12RfAZw61rg7EKxHqIt2AGAC58Q9aG3fgnEpgDHDoh1D9cXOSZDrPle/Hyo0rquopODFY4anu//B+xaKyai/fR+MWVKW376WEyLcvwwsO6prj2nbjIoiqJ04n4Bw1bDU1dXh5gYa9qv7CXg/T+IIq9jBxx3jk0VdTWASLENywPO/hPwwiSRxTE3i/tE9xOZmov+IW6zyXlAzKFw6Gdg+IVijaiOghdzi5hBs/o7EUCd/9e2Z/UkIiJSW+WXwFvXu64HNnm+WBDVfY6d7Dli5CPvMVFzuuMTz8dLGA7cvEaUbPy4UnQRT/oz8NpVjmlSwiKBpDGiVONixxQrbZ6/fUi/Ac/61xAzYYaYRfif6aLC3aZ/hpjxsi39RjqyQAAw7SlgXL4YDjt+GHhypIhsJ/1FzIjJ7AwREQWy+ioxRUrVFtehq559xYiEuVlMjJj/vhgRCe8hAhj3gCckTARJtqEym4GZYo44GICEoWKGf5vLikS3ctIo1P/mr4hNOY0BT0ec29J/+ukn1M3thZjz/yiKg9c8JDI14T3EvAkXPAg8P1HUz1y5RBT2Fj8IbHrR8YCT/iIWgBs707EQJiCGwMJ7OIa3iIiI9KCpAXg2GziyW6wQf/t6cb6r+V4EKs6z/z8y0DHD/x++BZqOinb4T/5PXGeMBTJ+J+YNsi2XNCxPLCj92UOiqcdtPqF69ELsA3sZ8HSWPcMztxdijE7Zlyv+7Vr023xM/CFtGZr6KmDxGFGLkzhKjH0ye0NERMFkz0Zg9Xzg/P8D0s5u/36fPSQWO815ADj7j+K6lhPAvy8QXczXvCGWuKjeKpbUiEsVK8LbOsyqvhaJB0AUVScMRf0v3yD20aMMeDrLHvC8cQtifnxDpNAm3CTGHEM6qNFeNQ9Y/4xncEREREQO5haRCeozxPN6Q2jH51sAWHoh8MtXomZowmzUF+Uh9k/rGPB0lj3gOXQQMbtXA4kjxZTdnWExA3V7gN5pau8mERFRcDtaI2p7hl8EhISgft8uxCafwoCns9Su8iYiIiLfU/v8HTzz8BAREVHQYsBDREREuueXAc+TTz6JkSNHYsSIEbjzzjuhs1E3IiIikszvAp79+/fjX//6F8rKyrB161aUlZVh/fr1Wu8WERERBTC/XDy0tbUVJ06cAAC0tLSgX79+Hf4OERERUXu8zvCUlJRg2rRpSE5OhsFgwIoVKzzuYzKZkJaWhsjISGRlZWHjxo2dfvy+ffvi7rvvRmpqKpKTk5GTk4MhQ4Z04jeJiIiI2uZ1wNPY2Ij09HSYTKY2b1++fDkKCwuxYMECbNmyBenp6cjNzUVtba39PhkZGRg1apTHV1VVFQ4fPowPPvgAu3btwt69e7Fu3TqUlJR071kSERFRUPN6SCsvLw95eXnt3r5o0SLMnj0bs2bNAgAUFRVh5cqVWLJkCebOnQsAKC9vZ+FOAG+//TZOPfVUxMfHAwAuuugirF+/Hueee26b929qakJTU5P9cn19vbdPiYiIiHTOp0XLzc3NKCsrQ05OjmMDISHIyclBaWlppx4jJSUF69atw4kTJ2A2m/H5559j+PDh7d5/4cKFiI2NtX+lpKT45LkQERGRfvg04Dlw4ADMZjMSExNdrk9MTER1dXWnHuPMM8/EhRdeiDPOOANjxozBkCFDcMkll7R7/3nz5qGurs7+tWfPnm4/DyIiItIXv+zSevjhh/Hwww936r5GoxFGoxEmkwkmkwlms1n1/SMiIqLA4tMMT0JCAkJDQ1FTU+NyfU1NDZKSkny5KQ8FBQXYtm0bNm3apOp2iIiIKPD4NOCJiIjAuHHjUFxcbL/OYrGguLgY2dnZvtyUB5PJhBEjRmDChAmqboeIiIgCj9dDWg0NDaioqLBfrqysRHl5OeLj45GamorCwkLk5+dj/PjxyMzMxOLFi9HY2Gjv2lJLQUEBCgoKUFdXh7i4OHZrERERBRDbeVu15aQUL61Zs0YB4PGVn59vv8/TTz+tpKamKhEREUpmZqayfv16bzfTZTt37mxz//jFL37xi1/84pf/f+3cuVOV+MCg6GxlziNHjqB3797YvXs3YmNjtd6dgFZfX4+UlBTs2bMHMTExWu9OQOOx9A0eR9/hsfQdHkvfqKurQ2pqKg4fPoy4uDifP75fdml1R0iIKEuKjY3lC89HYmJieCx9hMfSN3gcfYfH0nd4LH3Ddh73+eOq8qhEREREfoQBDxEREeme7gIeo9GIBQsWwGg0ar0rAY/H0nd4LH2Dx9F3eCx9h8fSN9Q+jrorWiYiIiJyp7sMDxEREZE7BjxERESkewx4iIiISPcY8BAREZHuBXTA8/DDD+Oss85CVFRUu7MyGgwGj68333zT5T6ff/45xo4dC6PRiFNPPRXLli2T9Az8Q2eO4+7du3HRRRchKioK/fr1wz333IPW1laX+wT7cWxLWlqax+vv0UcfdbnPt99+i3POOQeRkZFISUnBY489ptn++juTyYS0tDRERkYiKysLGzdu1HqX/Nr999/v8fo77bTT7LefOHECBQUF6NOnD6Kjo3HFFVegpqZG0332FyUlJZg2bRqSk5NhMBiwYsUKl9sVRcH8+fPRv39/9OjRAzk5OdixY4fLfQ4dOoRrr70WMTExiIuLw4033oiGhgbJz0R7HR3LmTNnerxOp06d6nIfXxzLgA54mpubcdVVV+G222476f2WLl2Kffv22b8uu+wy+22VlZW46KKLMGnSJJSXl+OPf/wjbrrpJnz88ccSnoF/6Og4ms1mXHTRRWhubsa6devw0ksvYdmyZZg/f779PjyO7XvwwQddXn933HGH/bb6+npMmTIFgwYNQllZGR5//HHcf//9eP755zXdZ3+0fPlyFBYWYsGCBdiyZQvS09ORm5uL2tparXfNr40cOdLl9bd27Vr7bX/605/w/vvv4+2338YXX3yBqqoqXH755Zrur79obGxEeno6TCZTm7c/9thjeOqpp1BUVIQNGzagZ8+eyM3NxYkTJ+z3ufbaa/H9999j9erV+OCDD1BSUoKbb75Z4rPwDx0dSwCYOnWqy+v0jTfecLndJ8dSlRW6JFu6dKkSGxvb5m0AlP/973/t/u69996rjBw50uW6GTNmKLm5uT7fT3/X3nH88MMPlZCQEKW6utp+3bPPPqvExMQoTU1NisLj2K5BgwYpTz75ZLu3P/PMM0rv3r3tx1FRFOW+++5Thg8fLmkPA0dmZqZSUFBgv2w2m5Xk5GRl4cKFmu6XP1uwYIGSnp7e5m1HjhxRwsPDlbffftt+3Q8//KAAUEpLSyXupf9zP49YLBYlKSlJefzxx+3XHTlyRDEajcobb7yhKIqibNu2TQGgbNq0yX6fjz76SDEYDMrevXslPwP/0dY5OT8/X7n00kvb/R1fHcuAzvB0VkFBARISEpCZmYklS5a4LD1fWlqKnJwcl/vn5uaitLRUgz31T6WlpRg9ejQSExPt1+Xm5qK+vh7ff/+9/T48jm179NFH0adPH5xxxhl4/PHHXYYCS0tLce655yIiIsJ+XW5uLrZv347Dhw9rtMf+p7m5GWVlZS6vsZCQEOTk5PA11oEdO3YgOTkZgwcPxrXXXovdu3cDAMrKytDS0uJyTE877TSkpqbymHagsrIS1dXVLscuNjYWWVlZ9mNXWlqKuLg4jB8/3n6fnJwchISEYMOGDZrstz/7/PPP0a9fPwwfPhy33XYbDh48aL/NV8dSd4uHunvwwQdx/vnnIyoqCp988gluv/12NDQ04M477wQAVFdXu5zIASAxMRH19fU4fvw4evToodGe+4/2jpHttpPdJ9iP45133omxY8ciPj4e69atw7x587Bv3z4sWrQIsB63U045xeV3nI9t7969Ndlvf3PgwAGYzeY2X2M//vijZvvl77KysrBs2TIMHz4c+/btwwMPPIBzzjkH3333HaqrqxEREeFRt5eYmGj/v6a22Y5PW69H5/fEfv36udweFhaG+Ph4Hl83U6dOxeWXX45TTjkFO3fuxJ///Gfk5eWhtLQUoaGhPjuWfhfwzJ07F3//+99Pep8ffvjBpfDuZP7617/afz7jjDPQ2NiIxx9/3B7w6JWvjyM5eHNsCwsL7deNGTMGERERuOWWW7Bw4UJOQ0+qy8vLs/88ZswYZGVlYdCgQXjrrbeC9kMI+Z+rr77a/vPo0aMxZswYDBkyBJ9//jkmT57ss+34XcBz1113YebMmSe9z+DBg7v8+FlZWfjb3/6GpqYmGI1GJCUleXQl1NTUICYmJqDfEHx5HJOSkjy6YWzHLCkpyf5dj8exLd05tllZWWhtbcWuXbswfPjwdo8bnI4tAQkJCQgNDW3zWPE4dV5cXByGDRuGiooKXHDBBWhubsaRI0dcsjw8ph2zHZ+amhr079/ffn1NTQ0yMjLs93EvqG9tbcWhQ4d4fDswePBgJCQkoKKiApMnT/bZsfS7gKdv377o27evao9fXl6O3r172z9dZ2dn48MPP3S5z+rVq5Gdna3aPsjgy+OYnZ2Nhx9+GLW1tfa04urVqxETE4MRI0bY76PH49iW7hzb8vJyhISE2I9jdnY2/vKXv6ClpQXh4eGA9bgNHz6cw1lOIiIiMG7cOBQXF9u7LC0WC4qLizFnzhytdy9gNDQ0YOfOnbjuuuswbtw4hIeHo7i4GFdccQUAYPv27di9e7cu/2996ZRTTkFSUhKKi4vtAU59fT02bNhg73bNzs7GkSNHUFZWhnHjxgEAPvvsM1gsFmRlZWm6//7u119/xcGDB+3BpM+OZRcLrf3CL7/8onz99dfKAw88oERHRytff/218vXXXytHjx5VFEVR3nvvPeWFF15Qtm7dquzYsUN55plnlKioKGX+/Pn2x/j555+VqKgo5Z577lF++OEHxWQyKaGhocqqVas0fGZydXQcW1tblVGjRilTpkxRysvLlVWrVil9+/ZV5s2bZ38MHkdP69atU5588kmlvLxc2blzp/Lqq68qffv2Va6//nr7fY4cOaIkJiYq1113nfLdd98pb775phIVFaU899xzmu67P3rzzTcVo9GoLFu2TNm2bZty8803K3FxcS7dg+TqrrvuUj7//HOlsrJS+eqrr5ScnBwlISFBqa2tVRRFUW699VYlNTVV+eyzz5TNmzcr2dnZSnZ2tta77ReOHj1qfy8EoCxatEj5+uuvlV9++UVRFEV59NFHlbi4OOXdd99Vvv32W+XSSy9VTjnlFOX48eP2x5g6dapyxhlnKBs2bFDWrl2rDB06VLnmmms0fFbaONmxPHr0qHL33XcrpaWlSmVlpfLpp58qY8eOVYYOHaqcOHHC/hi+OJYBHfDk5+crADy+1qxZoyjWtrWMjAwlOjpa6dmzp5Kenq4UFRUpZrPZ5XHWrFmjZGRkKBEREcrgwYOVpUuXavSMtNHRcVQURdm1a5eSl5en9OjRQ0lISFDuuusupaWlxeVxgv04uisrK1OysrKU2NhYJTIyUjn99NOVRx55xOWfWFEU5ZtvvlHOPvtsxWg0KgMGDFAeffRRzfbZ3z399NNKamqqEhERoWRmZirr16/Xepf82owZM5T+/fsrERERyoABA5QZM2YoFRUV9tuPHz+u3H777Urv3r2VqKgoZfr06cq+ffs03Wd/sWbNmjbfF/Pz8xXF2pr+17/+VUlMTFSMRqMyefJkZfv27S6PcfDgQeWaa65RoqOjlZiYGGXWrFn2D5LB5GTH8tixY8qUKVOUvn37KuHh4cqgQYOU2bNne3yQ8cWxNCjOPdpEREREOhQU8/AQERFRcGPAQ0RERLrHgIeIiIh0jwEPERER6R4DHiIiItI9BjxERESkewx4iIiISPcY8BAREZHuMeAhIiIi3WPAQ0RERLrHgIeIiIh0jwEPERER6d7/A7RGjSn9E9BdAAAAAElFTkSuQmCC", + "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.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, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "backend = wf._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": "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", + "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": "iVBORw0KGgoAAAANSUhEUgAAA+4AAAH5CAYAAAAfqGS0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XmcVXX9x/HXOecuM8ww7Aw7uKEgCiqLu6KYYlJpmdYvwyXLGiqlDVpcWtS0lKwpyjItKy0rK3ErSnEXUdxQREVBlmGfYba7nHN+f9xz7twBVJh74dxzeD8fDx7MvXOH+zncOzPncz6f7+druK7rIiIiIiIiIiJlyQw6ABERERERERF5d0rcRURERERERMqYEncRERERERGRMqbEXURERERERKSMKXEXERERERERKWNK3EVERERERETKmBJ3ERERERERkTIWCzqAUnMch9WrV9O9e3cMwwg6HBEREREREYk413XZunUrgwYNwjRLXx+PXOK+evVqhg4dGnQYIiIiIiIispdZuXIlQ4YMKfm/G7nEvXv37uD9h9XU1AQdjoiIiIiIiERcU1MTQ4cOzeejpRa5xN1vj6+pqVHiLiIiIiIiInvM7lqureF0IiIiIiIiImVMibuIiIiIiIhIGVPiLiIiIiIiIlLGIrPGvb6+nvr6emzbDjoUERERERGRkrNtm0wmE3QYe6V4PI5lWYE9v+G6rhvYs+8GTU1N9OjRg8bGRg2nExERERGR0HNdl7Vr17Jly5agQ9mr9ezZkwEDBuxwAN3uzkMjU3EXERERERGJIj9p79+/P926ddttk8tlx1zXpbW1lXXr1gEwcODAPR6DEncREREREZEyZdt2Pmnv06dP0OHstSorKwFYt24d/fv33+Nt8xpOJyIiIiIiUqb8Ne3dunULOpS9nv8aBDFnQIm7iIiIiIhImVN7fPCCfA2UuIuIiIiIiIiUMSXuIiIiIiIiImVMibuIiIiIiIjsUW+99RaGYbB48eKgQwmFskzc77nnHg488EAOOOAAfv3rXwcdjoiIiIiIiOxhDz30EIZhaP/6ctwOLpvNMnPmTP73v//Ro0cPjjjiCM4880xtfSAiIiIiIiJ7pbKruD/99NMcfPDBDB48mOrqaqZOncqDDz4YdFgiIiIiIiJlwXVdWtPZPf7Hdd1divP+++/n2GOPpWfPnvTp04czzjiDN954o9NjXn31VY4++mgqKioYM2YMDz/8MHit9JMnTwagV69eGIbB+eefD4DjOFxzzTXss88+VFZWMnbsWO666678v+lX6h944AEOO+wwKisrOemkk1i3bh333Xcfo0aNoqamhk9+8pO0traW4BXZ/UpecV+wYAHXX389ixYtYs2aNfz973/nIx/5SKfH1NfXc/3117N27VrGjh3LT3/6UyZOnAjA6tWrGTx4cP6xgwcPZtWqVaUOU0REREREJJTaMjajL39gjz/vku+eSrfEzqeQLS0tzJw5k0MPPZTm5mYuv/xyzjzzzE7r2r/2ta8xZ84cRo8ezQ033MC0adNYvnw5Q4cO5a9//Ssf/ehHWbp0KTU1NVRWVgJwzTXXcPvttzN37lwOOOAAFixYwKc+9Sn69evHCSeckP+3r7zySn72s5/RrVs3Pv7xj/Pxj3+cZDLJH//4R5qbmznzzDP56U9/yje+8Y0S/0+VXskT95aWFsaOHcuFF17IWWedtd3n77zzTmbOnMncuXOZNGkSc+bM4dRTT2Xp0qX079+/1OGIiIiIiIhIAD760Y92un3LLbfQr18/lixZQnV1NQAzZszIP+4Xv/gF999/P7/5zW/4+te/Tu/evQHo378/PXv2BCCVSnH11Vfzn//8h6OOOgqAfffdl0cffZRf/vKXnRL373//+xxzzDEAXHTRRcyePZs33niDfffdF4CPfexj/O9//9s7E/epU6cyderUd/38DTfcwMUXX8wFF1wAwNy5c5k3bx633HILs2bNYtCgQZ0q7KtWrcpX43cklUqRSqXyt5uamkp2LCIiInuTFx76K62vzmf8RXOIxRNBhyMiIu+iMm6x5LunBvK8u2LZsmVcfvnlPPXUU2zYsAHHcQBYsWIFo0ePBsgn3wCxWIzx48fzyiuvvOu/+frrr9Pa2sopp5zS6f50Os1hhx3W6b5DDz00/3FtbS3dunXLJ+3+fU8//fQuHVNQ9uhwunQ6zaJFi5g9e3b+PtM0mTJlCk888QQAEydO5KWXXmLVqlX06NGD++67j+985zvv+m9ec801XHXVVXskfhERkSg79KELAVj+39Hsc+qMoMMREZF3YRjGLrWsB2XatGkMHz6cm2++mUGDBuE4DmPGjCGdTnf532xubgZg3rx5nZZYAySTyU634/F4/mPDMDrd9u/zLyaUuz06nG7Dhg3Ytk1tbW2n+2tra1m7di14V1l+/OMfM3nyZMaNG8dXvvKV95woP3v2bBobG/N/Vq5cuduPQ0REJMqspneCDkFEREJu48aNLF26lG9/+9ucfPLJjBo1is2bN2/3uCeffDL/cTabZdGiRYwaNQqARCLX/WXbdv4xo0ePJplMsmLFCvbff/9Of4YOHbpHji0IZXmZ5kMf+hAf+tCHduqxyWSSZDJJfX099fX1nV5UERER2XkrzMEMc1bR2G980KGIiEjI9erViz59+vCrX/2KgQMHsmLFCmbNmrXd4+rr6znggAMYNWoUN954I5s3b+bCC3MdYMOHD8cwDO655x5OP/10Kisr6d69O1/96le57LLLcByHY489lsbGRh577DFqamqYPn16AEe7++3Rinvfvn2xLIuGhoZO9zc0NDBgwICi/u26ujqWLFnCwoULi4xSRERk75Qi12LoYAQdioiIhJxpmtxxxx0sWrSIMWPGcNlll3H99ddv97hrr72Wa6+9lrFjx/Loo4/yz3/+k759+4K3w9hVV13FrFmzqK2tZcaM3DKu733ve3znO9/hmmuuYdSoUZx22mnMmzePffbZZ48f555iuLu6Gd+u/OOGsd12cJMmTWLixIn89Kc/BW8PvmHDhjFjxowdXoHZWYUV99dee43GxkZqampKchwiIiJ7g9e+ezgjnTd4/oRfM3by2UGHIyIiQHt7O8uXL2efffahoqIi6HD2au/1WjQ1NdGjR4/dloeWvFW+ubmZ119/PX97+fLlLF68mN69ezNs2DBmzpzJ9OnTGT9+PBMnTmTOnDm0tLTkp8x3VV1dHXV1dfn/MBEREdk1I503AKjc+lbQoYiIiEiBkifuzzzzDJMnT87fnjlzJgDTp0/n1ltv5ZxzzmH9+vVcfvnlrF27lnHjxnH//fdvN7BOREREgtGe7Bt0CCIiIlKg5In7iSeeyPt138+YMSO/PqFUNJxORESkOKuN/gxy19HWbfBOPFpERET2lD06nG530nA6ERGR4pjehfdw7GgrIiKy94hM4i4iIiLFGcB6AOLt2++zKyIiIsFR4i4iIiKd9Nz4bNAhiIiISIHIJO719fWMHj2aCRMmBB2KiIhIqO2+jWJFRESkKyKTuGuNu4iISKkocxcRESknkUncRUREpDhLGQHA1up9gw5FRETkfd1666307Nkzf/vKK69k3Lhxgca0u0QmcVervIiISHEaqQbAMSJzeiAiIgE6//zzMQwDwzBIJBLsv//+fPe73yWbze7U1z/88MOcdNJJ9O7dm27dunHAAQcwffp00un0Dh//1a9+lfnz55f4KMpDZH4zq1VeRESkOA6G94E2hBMRkdI47bTTWLNmDcuWLeMrX/kKV155Jddff/37ft2SJUs47bTTGD9+PAsWLODFF1/kpz/9KYlEAtu2d/g11dXV9OnTZzccRfAik7iLiIhIcY7kRQCS7euDDkVERCIimUwyYMAAhg8fzuc//3mmTJnCn//8Z2pqarjrrrs6Pfbuu++mqqqKrVu38uCDDzJgwACuu+46xowZw3777cdpp53GzTffTGVl5Q6fa0et8rfccgsHH3wwyWSSgQMHMmPGjPzntmzZwmc+8xn69etHTU0NJ510Es8///xu+p8ojhJ3ERER6aS527CgQxARkZ2Rbnn3P5n2XXhs2/s/tkQqKysxTZNzzz2X3/72t50+99vf/paPfexjdO/enQEDBrBmzRoWLFjQ5ef6xS9+QV1dHZ/97Gd58cUX+ec//8n++++f//zZZ5/NunXruO+++1i0aBGHH344J598Mps2bSrqGHeHWNABiIiISHnY6lbS3WhjS/V+QYciIiI74+pB7/65Az4A//eXjtvX7w+Z1h0/dvixcMG8jttzDoHWjZ0fc2VjUaG6rsv8+fN54IEH+OIXv8jZZ5/N0UcfzZo1axg4cCDr1q3j3nvv5T//+Q94SfUDDzzACSecwIABAzjyyCM5+eST+fSnP01NTc1OPef3v/99vvKVr/DlL385f58/E+3RRx/l6aefZt26dSSTSQB+9KMfcffdd3PXXXfx2c9+tqjjLbXIVNw1nE5ERKQ4prcNnGMYQYciIiIRcc8991BdXU1FRQVTp07lnHPO4corr2TixIkcfPDB3HbbbQDcfvvtDB8+nOOPPx4Ay7L47W9/yzvvvMN1113H4MGDufrqqzn44INZs2bN+z7vunXrWL16NSeffPIOP//888/T3NxMnz59qK6uzv9Zvnw5b7zxRon/F4oXmYp7XV0ddXV1NDU10aNHj6DDERERCZ0qI9dWmUxtfN/HiohIGfjm6nf/nGF1vv2119/jsdvUcy99scjAOkyePJlf/OIXJBIJBg0aRCzWkYJ+5jOfob6+nlmzZvHb3/6WCy64AGObi8eDBw/mvPPO47zzzuN73/seI0eOZO7cuVx11VXv+bzvtg7e19zczMCBA3nooYe2+1zhFnPlIjKJu4iIiJTGgIYFwIeCDkNERN5Poir4x76PqqqqTuvKC33qU5/i61//OjfddBNLlixh+vTp7/lv9erVi4EDB9LS8v5r7rt3786IESOYP38+kydP3u7zhx9+OGvXriUWizFixIhdOKJgKHEXERERERGRPa5Xr16cddZZfO1rX+MDH/gAQ4YMyX/ul7/8JYsXL+bMM89kv/32o729nd/97ne8/PLL/PSnP92pf//KK6/kkksuoX///kydOpWtW7fy2GOP8cUvfpEpU6Zw1FFH8ZGPfITrrruOkSNHsnr1aubNm8eZZ57J+PHjd+OR77rIrHEXERGR0nDdoCMQEZG9xUUXXUQ6nebCCy/sdP/EiRNpbm7mkksu4eCDD+aEE07gySef5O677+aEE07YqX97+vTpzJkzh5///OccfPDBnHHGGSxbtgwAwzC49957Of7447ngggsYOXIk5557Lm+//Ta1tbW75ViLYbhutH49+2vcGxsbd3raoIiIiMALlx/GoeabPD1qFhPPmR10OCIiArS3t7N8+XL22WcfKioqgg6n5H7/+99z2WWXsXr1ahKJRNDhvKf3ei12dx4amYq7psqLiIgU5x36AeCiqfIiIrJ7tba28sYbb3Dttdfyuc99ruyT9qBFJnGvq6tjyZIlLFy4MOhQREREQsnvwXOdSDXjiYhIGbruuus46KCDGDBgALNnq8vr/UQmcRcREZHifNB6CoB4dmvQoYiISMRdeeWVZDIZ5s+fT3V1ddDhlD0l7iIiIoLrOPmPN3Y/MNBYREREpDMl7iIiIoJTMKu2ofuYQGMRERGRzpS4i4iICK5jd3ys0wMRkbLjFHRGSTCCfA1igT2ziIiIlA2nYCBdIr050FhERKRDIpHANE1Wr15Nv379SCQSGIZ2/9iTXNclnU6zfv16TNMMZAK+EncRERHBdTsq7gesvQc4KdB4REQkxzRN9tlnH9asWcPq1auDDmev1q1bN4YNG4Zp7vnONCXuIiIi0mk4navd4EREykoikWDYsGFks1ls296Jr5BSsyyLWCwWWLdDZBL3+vp66uvr9UYWERHpAsfR708RkXJmGAbxeJx4PB50KBKAyEyfqaurY8mSJSxcuDDoUERERELHjVWy0BkJQNbQSaGIiEg5iUziLiIiIl3nYLDMGQKAOuVFRETKixJ3ERERwQVcvHV7WuQuIiJSVpS4i4iICG6qjf+LzQfAcLJBhyMiIiIFlLiLiIgIbqYt//GqmnGBxiIiIiKdKXEXERERXLdjO7i3ekwINBYRERHpTIm7iIiIdNoOztESdxERkbKixF1ERERwCiruFZnGQGMRERGRzsoycT/zzDPp1asXH/vYx4IORUREZK9gFJTZx6/+Q6CxiIiISGdlmbh/+ctf5ne/+13QYYiIiOw1Civu4LzHI0VERGRPK8vE/cQTT6R79+5BhyEiIrLXKBxOZ2gfdxERkbKyy4n7ggULmDZtGoMGDcIwDO6+++7tHlNfX8+IESOoqKhg0qRJPP3006WKV0RERHaDbGVfHrMPhm2SeBEREQneLifuLS0tjB07lvr6+h1+/s4772TmzJlcccUVPPvss4wdO5ZTTz2VdevW5R8zbtw4xowZs92f1atXF3c0IiIi0iWOEecFd18ADFRxFxERKSexXf2CqVOnMnXq1Hf9/A033MDFF1/MBRdcAMDcuXOZN28et9xyC7NmzQJg8eLFxcTcSSqVIpVK5W83NTWV7N8WERHZmzgYuQ9UcRcRESkrJV3jnk6nWbRoEVOmTOl4AtNkypQpPPHEE6V8qrxrrrmGHj165P8MHTp0tzyPiIhIpLVt5rPWvNzHWuMuIiJSVkqauG/YsAHbtqmtre10f21tLWvXrt3pf2fKlCmcffbZ3HvvvQwZMuQ9k/7Zs2fT2NiY/7Ny5cqijkFERGRvZLRtJm7YALxVPTbocERERKTALrfK7wn/+c9/dvqxyWSSZDJJfX099fX12La9W2MTERGJItfN/f5scrvxco/JQYcjIiIiBUpace/bty+WZdHQ0NDp/oaGBgYMGFDKp9pOXV0dS5YsYeHChbv1eURERKLIcXLt8Q4GrobTiYiIlJWSJu6JRIIjjjiC+fPn5+9zHIf58+dz1FFHlfKptlNfX8/o0aOZMGHCbn0eERGRSPIG0vU0WkhkNOhVRESknOxyq3xzczOvv/56/vby5ctZvHgxvXv3ZtiwYcycOZPp06czfvx4Jk6cyJw5c2hpaclPmd9d6urqqKuro6mpiR49euzW5xIREYkat2Ag3alr5gLHBBqPiIiIdNjlxP2ZZ55h8uSOtW8zZ84EYPr06dx6662cc845rF+/nssvv5y1a9cybtw47r///u0G1omIiEj5cAu3gNNUeRERkbKyy4n7iSee2Omq/I7MmDGDGTNmFBPXLtNwOhERka5znY7E3UD7uIuIiJSTkq5xD5KG04mIiHRdqvtQ/md728Cp4i4iIlJWIpO4i4iISNfZsSqedEbnbihxFxERKStK3EVERATXzW0Fh1rlRUREyk5kEndtByciItJ1Zus6Pm39GwDDVeIuIiJSTiKTuGuNu4iISNfFm1cx1FwPwLJu44IOR0RERApEJnEXERGRrnOc3K4sK5x+PNHjg0GHIyIiIgUik7irVV5ERKQI3kA6FwNHw+lERETKSmQSd7XKi4iIFMHbx73KaCdutwUdjYiIiBSITOIuIiIiXedX2fsaTZzXcG3Q4YiIiEgBJe4iIiIChZPk1SkvIiJSVpS4i4iICK7TkbhrH3cREZHyEpnEXcPpREREuq6l14E8YI/P3dA+7iIiImUlMom7htOJiIh0XSbRk/85/v7t6pUXEREpJ5FJ3EVERKTrHNfFwQDA0HZwIiIiZUWJu4iIiBBvWcvHrAWgNe4iIiJlR4m7iIiIULnlNSaaSwF4NXlo0OGIiIhIASXuIiIikh9I96Izgnk15wQdjYiIiBSITOKuqfIiIiJFcG0AHExcrXEXEREpK5FJ3DVVXkREpOv8HeAsHEwnG3Q4IiIiUiAyibuIiIgUwcvcx5hv8bUN3ww6GhERESmgxF1ERERw3Y5J8toOTkREpLwocRcREZFt1rVrOzgREZFyosRdRERE2NLrEP5lHwmAoYK7iIhIWVHiLiIiIrRV1DLPT9xVcRcRESkrStxFREQEFxcXI39LREREyocSdxERESHZsooPWk+ChtOJiIiUncgk7vX19YwePZoJEyYEHYqIiEjo9Nr4HB+yngDglfjooMMRERGRApFJ3Ovq6liyZAkLFy4MOhQREZHwcXLr2h+xx3Br1YVBRyMiIiIFIpO4i4iISNf528G5GFrhLiIiUmaUuIuIiAi4uYq7i4GjNe4iIiJlJRZ0ACIiIhI810vcT7BeYOCWy4Bngg5JREREPKq4i4iICIbbsXe7RTbQWERERKQzJe4iIiKSX+MOYKpVXkREpKwocRcREREaeh/BX+3jvFtK3EVERMqJEncRERFha7fh3GUfD4CB876PFxERkT2n7BL3lStXcuKJJzJ69GgOPfRQ/vKXvwQdkoiISOQ5rovj5k4LtCGciIhIeSm7qfKxWIw5c+Ywbtw41q5dyxFHHMHpp59OVVVV0KGJiIhEVrfWd5hsPQdK3EVERMpO2SXuAwcOZODAgQAMGDCAvn37smnTJiXuIiIiu9Hg9Y9wVuweAF42D2RY0AGJiIhI3i63yi9YsIBp06YxaNAgDMPg7rvv3u4x9fX1jBgxgoqKCiZNmsTTTz/dpeAWLVqEbdsMHTq0S18vIiIiO8d1cuva77GP5IfJLwUdjoiIiBTY5cS9paWFsWPHUl9fv8PP33nnncycOZMrrriCZ599lrFjx3Lqqaeybt26/GPGjRvHmDFjtvuzevXq/GM2bdrEpz/9aX71q1919dhERERkp+Xa4x0MHHXKi4iIlJVdbpWfOnUqU6dOfdfP33DDDVx88cVccMEFAMydO5d58+Zxyy23MGvWLAAWL178ns+RSqX4yEc+wqxZszj66KPf97GpVCp/u6mpaRePSERERHBzFXcXA0f7uIuIiJSVkk6VT6fTLFq0iClTpnQ8gWkyZcoUnnjiiZ36N1zX5fzzz+ekk07ivPPOe9/HX3PNNfTo0SP/R231IiIiXeAl6x+2HufW9kuDjkZEREQKlDRx37BhA7ZtU1tb2+n+2tpa1q5du1P/xmOPPcadd97J3Xffzbhx4xg3bhwvvvjiuz5+9uzZNDY25v+sXLmy6OMQERHZ67gde7dXuy2BhiIiIiKdld1U+WOPPRbHcXbikTnJZJJkMkl9fT319fXYtr1b4xMREYkit6A9XtvBiYiIlJeSVtz79u2LZVk0NDR0ur+hoYEBAwaU8qm2U1dXx5IlS1i4cOFufR4REZEoWtlzEn/MTgYl7iIiImWnpIl7IpHgiCOOYP78+fn7HMdh/vz5HHXUUaV8KhERESmhDd1Hcrt9CihxFxERKTu73Crf3NzM66+/nr+9fPlyFi9eTO/evRk2bBgzZ85k+vTpjB8/nokTJzJnzhxaWlryU+Z3F7XKi4iIdJ3rguNdz1fiLiIiUl52OXF/5plnmDx5cv72zJkzAZg+fTq33nor55xzDuvXr+fyyy9n7dq1jBs3jvvvv3+7gXWlVldXR11dHU1NTfTo0WO3PpeIiEjUVLe+w1HmywCY7PysGREREdn9DNeNxmathRX31157jcbGRmpqaoIOS0REJBSe+O03OOrtuQA8ymEce+VDQYckIiISGn4BeXfloSVd4x4kDacTEREpgrcd3B+yJzPD/GbQ0YiIiEiByCTuIiIiUgSvAc/BwHEi0YwnIiISGUrcRUREBMOruDsaTSciIlJ2IpO419fXM3r0aCZMmBB0KCIiIqHjeun69Ni/+af75aDDERERkQKRSdy1xl1ERKQIbsck+f5sDjQUERER6SwyibuIiIgUodMmM2qWFxERKSdK3EVERIQ3ehzFrdkPAGAqcRcRESkrkUnctcZdRESk61Z2H8evsmeAEncREZGyE5nEXWvcRUREus71JsoDmisvIiJSZiKTuIuIiEjXdW9bzVjzDVDiLiIiUnaUuIuIiAgTGv7MLxNzAFjqDg06HBERESkQmcRda9xFRESKkdsOrj77Ic5IXx10MCIiIlIgMom71riLiIgUwdsOzvFODVxX7fIiIiLlIjKJu4iIiHSd4eYq7v6AOuXtIiIi5UOJu4iIiHhz5eHLsb/zv8RluI4ddEAiIiLiUeIuIiIi4FXcAfYxG3CUuIuIiJQNJe4iIiJdlLWdnXhUWHTujXfcKB2biIhIuEUmcddUeRER2ZNu/PdrjPvuv3l93dagQymJV7sfxc3Z0/O3XUeJu4iISLmITOKuqfIiIrJHvfx3zs7+i+VLXwg6kpJYUn0MN2Y/lr+txF1ERKR8xIIOQEREJIxOa/kHo+Iv8+SWw4Bjgg6naC5ufqI8gKtWeRERkbIRmYq7iIjInjQy8woAybaGoEMpie7pdYw03snfdlRxFxERKRtK3EVERLrAIpfY9tvwVNChlMRpDb/mn8nvALDcqSUqafszv6pj6TXHkk23Bx2KiIhIlylxFxERKYK7E48Jh9yR/CDzSSanb8SNVwcdUEmMX307B6ZeZNUrTwcdioiISJcpcRcRESlGVDJ3b027661zd91oHFgjVQCk41VBhyIiItJlStxFRESKEI30FgzvSPzE3YnIgZneBQnHtYIORUREpMuUuIuIiBQhIoVpDC/B/U78du5NzIbWTUGHVBLdjTYA3NTWoEMRERHpssgk7vX19YwePZoJEyYEHYqIiOwFVhsDANhUtV/QoZRIxxWI0ebbOHYm0GhKLdH4ZtAhiIiIdFlkEve6ujqWLFnCwoULgw5FRET2Ai9YowBIWdFYO21st297RFoJPFFp/RcRkb1TZBJ3ERGRPWmedRKzMp/hrV5HBR1KSSyuOoa52Wn5227E9nF3lLmLiEiIKXEXERHpgr7ORlwMtsb7BR1KSTxdPYVrs58g7Q1xc7arwIdP4WR820oEGouIiEgxlLiLiIh0weczv+OH8Zvp1r4m6FBKwnE7T5WPQsXddlxedoYDkDWSQYcjIiLSZUrcRUREuqA/uanrNa3vBB1KSXTPbmKIsY6kkQXAdeygQyqa7brY3qmO44b/eEREZO+lxF1ERKQIB62/L+gQSuK8DTfwaPJSABrcnrgROEVwbIchxnoA3Gw26HBERES6LPy/lUVERAIUmZFnXqv81zKfZVLq52SrBwcdUdHsVDO9jWYAmquHBR2OiIhIlylxFxERKYIbkczdoPOadicCB2bbHe3xzd2GBhqLiIhIMcoucd+yZQvjx49n3LhxjBkzhptvvjnokERERN5VBPLbHO9AHDd3ahCFw3Ltjvb4bPmd8oiIiOy0WNABbKt79+4sWLCAbt260dLSwpgxYzjrrLPo06dP0KGJiIjsQBRSXDC84/hxYi6fdOZjNv0B+h4YdFhFsQsS91jbRkBVdxERCaeyu/xsWRbdunUDIJVK4bpup31YRUREysESN7fNWItVE3QoJdLxu/YIcxlk2gKNphTcglb5vuseDzQWERGRYuxy4r5gwQKmTZvGoEGDMAyDu+++e7vH1NfXM2LECCoqKpg0aRJPP/30Lj3Hli1bGDt2LEOGDOFrX/saffv23dUwRUREdqsH7fEAZI140KGUhOF2XuPuuuHfxz1rZ/IfO7a2gxMRkfDa5cS9paWFsWPHUl9fv8PP33nnncycOZMrrriCZ599lrFjx3Lqqaeybt26/GP89evb/lm9ejUAPXv25Pnnn2f58uX88Y9/pKGhoZhjFBERKSnXdXnYPpTvZs7jhZoTgw6nJBZVHMXvsqfkb7tO+BP3wmTdcLQdnIiIhNcur3GfOnUqU6dOfdfP33DDDVx88cVccMEFAMydO5d58+Zxyy23MGvWLAAWL168U89VW1vL2LFjeeSRR/jYxz62w8ekUilSqVT+dlNT0y4ekYiIyK5xHIfhRgMb3BpaK8YEHU5J3F/1IZ5s2MRU6yn6GU3ghr9Cbce65T92nfAfj4iI7L1KusY9nU6zaNEipkyZ0vEEpsmUKVN44okndurfaGhoYOvWrQA0NjayYMECDjzw3YfjXHPNNfTo0SP/Z+hQDZ4REZHdy85mmJP4OTcl6jGd9qDDKQknv8TdyN12wj9fJpPsxX32BADcCFyIEBGRvVdJE/cNGzZg2za1tbWd7q+trWXt2rU79W+8/fbbHHfccYwdO5bjjjuOL37xixxyyCHv+vjZs2fT2NiY/7Ny5cqij0NEROS9OAXTyvu0vxNoLKVSZW+lL43E8Y4tAmvcHdfFxvJuKHEXEZHwKrvt4CZOnLjTrfQAyWSSZDJJfX099fX12Bo+IyIiu1nhNmOnbPw98IlA4ymFr2++glEVSwBocrvhepX3MLMzGXqTW0KnVnkREQmzklbc+/bti2VZ2w2Ta2hoYMCAAaV8qu3U1dWxZMkSFi5cuFufR0REpPAicVR2LPXT9M+lL+PQ1K9p7T0q4IiKF9v0GkdbuYsRa3uMCzocERGRLitp4p5IJDjiiCOYP39+/j7HcZg/fz5HHXVUKZ9KREQkMG5BxT0yibvXGu94KXwUjsv1JsmvcXuztnp00OGIiIh02S63yjc3N/P666/nby9fvpzFixfTu3dvhg0bxsyZM5k+fTrjx49n4sSJzJkzh5aWlvyU+d1FrfIiIrKnFLbKQwQyXMgfh98i70Qgc/e3g7MxsSMwbE9ERPZeu5y4P/PMM0yePDl/e+bMmQBMnz6dW2+9lXPOOYf169dz+eWXs3btWsaNG8f999+/3cC6Uqurq6Ouro6mpiZ69OixW59LRET2boX7g0dhiBuA4SXu18V/ycvOCJKbb4RhE4MOqyiOV3EfYmygsq0B2D/okERERLpklxP3E088Efd9rsLPmDGDGTNmFBPXLlPFXURE9pRMopoF9iEcb72IEZFtxgzvd3tvo5njrJd4NdUYdEjFKzgnGLX2buCYQMMRERHpqpKucQ+ShtOJiMieYpsV/N0+FgCDqFTcOx/H+12kDwO7YJK8oanyIiISYpFJ3EVERPYUx4GX3RFcl/k4D1d+IOhwSuLJ+CT+kj0+f9uNwBIA184U3Mi+10NFRETKWtnt4y4iIlLunFQz+xhrWOIOp63iBL4YdEAlcHvFJ3h1y1YOM19nf3N1JCru7RX98h9rH3cREQmzyFTc6+vrGT16NBMmTAg6FBERiThj62p+mZjDnPjPIzF9vZA/VR4n/BX35u77MTd7BqhVXkREQi4yibvWuIuIyJ7i7w/e02hhQHpF0OGURMJppRvt+enyUWiVd1wXxz/VicDxiIjI3kut8iIiIruocDu4GU03AOcGGk8p3NT8VUZUrAQg41qRaJV3shkqSQFEZvq/iIjsnSJTcRcREdlTHLtj0JkZkUquX2k/J/UdDkj9ni0Djgo6pKL1WfVfLog9AMBr1ZOCDkdERKTLIpO4a427iIjsKYWDziKzHZxXYXe8Ne5O+Avu+dfpKecgXqkJ/4UIERHZe0UmcdcadxER2VM6V9yj0YKdX9vu3Y5Cq7w/i8BxTWw7/McjIiJ7L61xFxER2UWFFXeTaCXus+J3sMntTvXGbwEnBx1WcbzXaYS5lqr0uqCjERER6bLIVNxFRET2lNbqYfzVPhYAMyqt8t5xjDdf4wPWImJt64MOqWj+BZaBxiamNvwy6HBERES6LDKJu9a4i4jInpJK9uWP2Vw1OmrD6fIi0CrvFM4iiMjrBJDK2rSmszvxSBERiYrIJO5a4y4iInuK47qscftQn/0Qd8dODTqcknjCPIJ77ElsdLvDNssBQqswcXeik+h++GePcdKPHiadjc7FCBEReW+RSdxFRET2mNaN7G+u4t/2eP5kfTjoaErix7GLmZH5Mm+7A4IOpWSaKgfnP47K9H/Hcdm4dgVG0yq2tLQFHY6IiOwhStxFRER2UfWGF/hd4od8L34LWSciCaHXGe8a3qlBBKblr+k1kW9mLgLAiMDxAGQdl8eTX+KJii/iNjcEHY6IiOwhStxFRGS3e3VtE9+7ZwmbW9JBh1ISfhv5MGMdg+zVQYdTGk7Wq0rn9nGPwnZwtuNie6c6UVnj7tgZ4kbu/eek24MOR0RE9hAl7iIistv9ef6TPPHY//jPMy8FHUpJ+PuD9zBa+Y39raDDKYl7sp9lecWnOMBYAYDrhD9xLxxOZ0ZkjXs23dEe72bUKi8isrdQ4i4iIrvdqWt/yb3JbzJ05b+CDqUk3IIkMCrbwfkuMS7ngPbfsXrQKUGHUrTRb9/OD+M3A7Cw27FBh1MSdqbjvWdH4OKKiIjsnMgk7toOTkSkfGVdC7ZJeMOscOJ6VLaD8y9A2GaCDDEcr2U+1LzX6S77eP7XbWrQ0ZSEU/A9pLxdRGTvEZnEXdvBiYiUr2OaHwBg6KYngg6lJAoTdysiFXd/H3fDjMypQT5xt10zMtXpbLZjToRtR2PgnoiIvL9Y0AGIiMjeo7o9KoPcCiruEUvcz7P/wSfiKXptuAQY/L5fV9a8SfK1xma6ZzcEHU1JuHbH+82xo9HBIiIi7y9Cl9VFRKTsRaPoycaag/ll9oMAWESj6ml6L87h7kt82HqcypZVQYdUPO8Cy4nW88zc/IOgoykJu6Dino73CDQWERHZc5S4i4jIHhSNzL2xah9+nT0dotQq763Vd7xTgyhsB+cW7N0elX3c/Sp7i5ukrSrkHREiIrLT1CovIiJ7TPhTwRzbdWmlgluyp2Fj8hnXxTDCPcztMcYRt9sZFt+Se6GiMHQvgksa0sk+fC59KWDwmQhcXBERkZ2jiruIiOwxy7tHY+ePRGsDo4y3ud2ewg+yn4rEdO+Z7qVclPkaG80+UFCBD7MNFcNJezsaROF4ALKxbjziHMqTzijsdCrocEREZA9R4i4iIrvdq7GDAFhac3TQoZTEkIb53JX8Ll+J/Rkisp+2k6/eRqdV/oU+U7kw83UAzIi0ymcdl78lruD5is9S1fB00OGIiMgeEpnEXfu4i4iUL8tLmuyI/Nrxt4PrazQxiA04TviTQj9Pdw3vNYpAhdp2Ot5zUWmVp3UzB5krAXA1VV5EZK8RjTMo7eMuIlLWvlN9JaekruOdiv2DDqU0vER9kvkqj1d8CTvVEnRERVtoXciryen0dTcC4EYgcXdcF9v1E/fwX1wBsBrfzn/sOkrcRUT2FpFJ3EVEpHyd2n4//05+nZPW/DroUEpjm4TJtsOfFFaQosLIMKf7Vzm0/WZeH/zhoEMq2qkrbuDPye8BMN86LuhwSsIpeO+5EXjfiYjIzlHiLiIiu13WzU1cNyLQUk5Bq3z+dgRalv193FNWFU1U4RjxoEMqmuXk9jz/ceZj3BI/J+hwSqLwveY6mUBjERGRPUeJu4iI7HYXp38HQP/UW0GHUhrbDDrLRiBxN7zE3fDWuEdg3l5+73YbEyf8nf9QsI/7th+LiEi0aR93ERHZY6qzm4MOoTS2yQKj0LJsGblM/eT2BzgptoLeG84FRgQdVnG8dfo1RhvVdmPQ0ZRE4br2bTs/REQkulRxFxER2UVv9xjPdZmP52/bIR8S5hZciBiTfoFPxP5Hj+bXA42pJLyK+yWxf/HHzKVBR1MShVX25uSAQGMREZE9R4m7iIjsQRHovwbeqR7Lz+2PkHJz68CdbLjXGjsFe7b728FFYR93o2AyflS2g3Pt3HvtBWcf1vU6LOhwRERkD1GrvIiI7DnhzwUBsL2k9k77RGLYHG91Czqkoriuy+P2aAygwhtKZ0Qg0TUKZhFEZTu4xpqDuCz9eRqp4gNRGEQgIiI7pWwr7q2trQwfPpyvfvWrQYciIiIlsqjbMUGHUBJV7Q0cbLzFT7Mf4ZvZz5Cp6B10SEVxMPlk5tt8IvNt2qzq3J0R2Md9dXwEq9w+AJgROB6A1or+/MM5hkedQ7BD3ukhIiI7r2wT9x/84AcceeSRQYchIiIl0EQVAP+uOiPoUEpi/Jo/MS/5TS6K3Q+AHfLKp9upFcLw7gz3MQHc0+tTnJv+NgBWBDoIALKOy0/jN/FaxXT2X/HnoMMREZE9pCwT92XLlvHqq68yderUoEMREZESsLyWZX8/99DzjqeSdnqyFccOd+WzMEc3IrTG3XbAcXPHE5U17vGWNUw2nwdNlRcR2avscuK+YMECpk2bxqBBgzAMg7vvvnu7x9TX1zNixAgqKiqYNGkSTz/99C49x1e/+lWuueaaXQ1NRETK1BT7J3wg9UNa3GTQoZSE4SVM02P/ZnHF54htfC3okIripFtYnLyYZ5OfJeGmcne64U8KHdfFJlqJe+91T9HN8F6jkO9mICIiO2+XE/eWlhbGjh1LfX39Dj9/5513MnPmTK644gqeffZZxo4dy6mnnsq6devyjxk3bhxjxozZ7s/q1av5xz/+wciRIxk5cmRxRyYiImVjHEt5MPkNZm7+QdChlMY2SW3hFl1h5DoOPY0WehvN/KP2C0xq/xkvDjon6LCK9vmGq3g8+SXSrsU/nGODDqckOlXZVXEXEdlr7PJU+alTp75nC/sNN9zAxRdfzAUXXADA3LlzmTdvHrfccguzZs0CYPHixe/69U8++SR33HEHf/nLX2hubiaTyVBTU8Pll1++w8enUilSqVT+dlNT064ekohIWWlsyzD/lQY+cPAAqpPR2Pwj47XIm264E1yfsU3iHvaWZadgH/dUrCcNZEmZ4Z6UD1DhtGAaLl9Pf467nWP5mOtiGCFfrlFYZQ/5+67QU29upDJhceiQnkGHIiJSlkq6xj2dTrNo0SKmTJnS8QSmyZQpU3jiiSd26t+45pprWLlyJW+99RY/+tGPuPjii981afcf36NHj/yfoUOHluRYRESCcsujy5n55+f541NvBx1KSTi2ww9ivwGgm9MSdDglYTid265DX3EvXM9uemvcgwunZEzvAovfLh/2IYIAbsF7zY1Iq3xLKst5tzzNeb95OhKzFUREdoeSJu4bNmzAtm1qa2s73V9bW8vatWtL+VR5s2fPprGxMf9n5cqVu+V5RET2lM2taSxsNrWEe+CZz7Yz1BpbAEi46aDDKZFoVdzdggsR45of4fLY7xi66bFAYyoFfy/6GDaVtGM7EVjnXtjtEYE5BHiJezrr0NiWIQLXVkREdouy7sE8//zz3/cxyWSSZDJJfX099fX12HY0fomJyN5r9MYHeSX5ff6x8WrgoKDDKZptZ4nnb0XjrPylqqN5akOSGbF/AOBEKHHfr+U5Jsbu54mm8Hew+Usabkz8ghv5BW2plRCvCTqsohRW3DcmhwUaS6lkC7L1rONgmVag8YiIlKOSVtz79u2LZVk0NDR0ur+hoYEBAwaU8qm2U1dXx5IlS1i4cOFufR4Rkd3t3BVXkTBszn79G0GHUhJ2tqNzIBppOzxXfTw/yp7DMmcwAG7ILxq7bkfi7hq5pMlww1+dNrc5BjsKreXeRaK/28fwYp8PBB1NSRQuYYjCcgYRkd2hpIl7IpHgiCOOYP78+fn7HMdh/vz5HHXUUaV8KhERCYlsyJPaHbG9dbjzncP5m30s7cneQYdUFMcwWezsx2JnX4jQPu7GNlvARaErb2WviXwrcyF32cfjRCTJtdubuTPxXe5KXEk2k9qJrxAR2fvscqt8c3Mzr7/+ev728uXLWbx4Mb1792bYsGHMnDmT6dOnM378eCZOnMicOXNoaWnJT5nfXdQqLyJSntyCivu/reP4VKDRlEb39Dr2MdZQn/0wW+nGbTX7Bx1SUZxkTz6S/h6GAX8y7vbvDTiq4r1tDaMtnWWs+SYATjb8Ffd13Q7gD3butRkZkcTdaFrJJPNVADZnojHbQ0Sk1Ha54v7MM89w2GGHcdhhhwEwc+ZMDjvssPzk93POOYcf/ehHXH755YwbN47Fixdz//33bzewrtTUKi8iUfFIjw8B8FyPU4IOpSSyBWty680opO1wzrqb+F/yK0yzcjumhL3y6VfXTcMAf7u0CLTK39DtUj6c/n7+th3y6f94reRfsv7GsuR5nPb2j4MOpyQKhwbaEbi4IiKyO+xyxf3EE0983/a5GTNmMGPGjGLiEhHZay2qOp5nN1pU1RzJYUEHUwL+MK2sa2KHO7/N81uwDVySpEOfbPjXHQzA9VrliUCrvH9BJeuaxAwn9NP/AapbVnCw9RJxw47MVHm74AeDbaviLiKyI2U9VX5XqFVeRKLi5YrD+Hd2EB+pGhR0KCWRrujLke0/pcZopcpqCjqckvCnlf8gfgs/iN/Cc6vrYUx4uwmM5rU8npxBhjhrOCl3XwQq7v4sAhuTGE4kKu6jGv6Vbys3ojBsz5uH5CscZikiIh0ik7jX1dVRV1dHU1MTPXr0CDocEZEum9T0AEfEXmFry2kQgZq7g0mV0c6DyW/Q6FQBZwUdUtG2TWrdkCdQrp1hkLGJlBvn74POY/aK8UwbMJojgw6sSDc0z6Jvci1r3D687AxnnJEIOqTiFXYNRODiCtssYXCUuIuI7FBkEncRkag4dut9HBR7kXnNPSECo9yyjkuW3BZjVkQSDWObFuWwt2D7FU8XaEv0Zrk7kNZYz6DDKlpvdxODjE2clb6SZ92RPFzZJ+iQimY4HYmt4Yb7gpGvcG/6KHRFiIjsDiXdDi5I9fX1jB49mgkTJgQdiohIUQ5KvQjABzf/PuhQSqO5gW/HbgfAjMCkcgAzYom7v57dwcwNqCtY9x5m/vvN8U53IrFHeMHFLyPs7ztP4bp2LXkUEdmxyCTumiovIlKmWjdyivUsADGicVK+7f7ghDyBcr0LES4GI7Y8xVdjd7L/lkeDDqtolndcWUzAxbbDf+GocF37tp0fYZUxK1jojGSePZFU9ZCgwxERKUuRSdxFRKQ8Fba+WhFJ3B9PHsct2dNY5+baycNecXe9SrSLwbCtzzEj9g/2a3oq6LCK5lfc70l+m7cq/o/YxleCDql4Bcn6O4l9Ag2lVJp6HMjZ6Supy1waja4IEZHdQIm7iIjsVoXrVy3DxXXCX/WcVzmN72Y/zUvOiNwdYU/cvWTQMQzIbwcX/tdp26UZTgTWT/tV9h9lzuaenuGfgcE228FllbiLiOxQZIbTaTs4EZHytG2yZNtZYma4p3v7+4M/544kbcdJVAwMOqSi2EaCV52hpMwK8Na4R8G2ibsbgXOExd1P5MGGGp51DqBnRJLcrOPy4/jP6Ucjsc0/gaFHBB2SiEjZiUziru3gRETKU2HF/e/2MUy1HWLxQEMqWnd7E7U0cqsxja0Zi+/3HhN0SEXJ1gzhtPQP6dUtzs+Nf+fujEDF/U2GUOU0c5C5EgAn5J0RAK92G8/f7NyFouMjkrj3WvMIp1m5mQovtTcGHY6ISFlSq7yISJn5TfLTALwR2z/oUErCr7i/4QzkskwdthH+a8bfbfwOT1XM4ChrKQCOG+4Eys//DMPoODWIQOI+3b2K09I/5C2nFgAnAhV323WZaj7FC8mLuHTdt4MOpzQyrfkPo7CcQURkdwj/2ZOISMQ8YR2Ok91AtmoEnw86mBJwvCnYtr8lV8iTXApasE0ztz992Adq+S+JaQBep7xBuI+JgtfF8dbtO074k8I+7W8z2HyNGqONpNMWdDgl4Ra8Lm7B1nAiItIhMom71riLSFQsM0bwn+ynGJ2oiUTi3th7HCekbgAgQQY7G/5Krr8d3BXOz6lPbuDpt74Cx3wn6LC6LLb5DeYnvkKj3ZO0cVLuzghU3P2LRK530SgKa9zPWP8bDo8tAMCMyHZwhctpVHEXEdmxyCTuWuMuIlHxkdQ9ONYWnstODTqUkkibSd52B/BWxScB2ND8IlQPCzqsopheUusYJhYuhLyS62bb2N9cwwa3jX8N/BDfXTqYY/odwMSgAyvSvdZXMEyHt4yhvG33o1eiJuiQima4hfu4h//iCtDp+0eJu4jIjkUmcRcRiYr/y/6N/vFNXJXZN+hQSsKfwJ5xLeKGHYmqp+ntR5814uB23ls7lLwt+hxM2pP9WOKOYHS8NuioirYvqzFNl7rY93i1vRu/63FQ0CEVrbDK7r8Pw65w9oBa5UVEdkzD6UREykx/NgFwRft1QYdSEsnNr/G12B3EjdzJuR2BE3O/4m77179DPq3cLZg74O8GF/aBe67jYBq5Y7Cs3OsUhfkKhUsYotIqbxRW3EP+vSQisruo4i4iIrtVt6Y3qYv9M3/byYa/FdbyKp224e1r54S8ZdntqLjXNr3IF6x59GkaC4wLOrIus+1s/iTHtHJDBJ2QDxEEMAta5aOSuLdZ3VniDOdJZxR9ak8MOhwRkbKkxF1ERHarbdes2tl0YLGUyv3m8cTTjRyQaAY7/K3yrpe4u4bBwKbnOTP+ZxY2bQZmBB1al2WzmfxJzvWp7zI8+TavvPMTGPXJgCMrTmGy/rq1D1FYUPNGv5O4KD0IgB/b4b+4IiKyOyhxFxGR3WubwW1RaIW9yfwUG7Jp5sbugHT4W+Udr2PApWM/OCPkbeWFF4xiOFQaabDDf9HIH0h3SfpSXus+mQ8EHVAJZAs6IcK+taKIyO4SmcRd28GJiJSnbYfRRWFqtJ9crE0OZ8HWQ9iaHBx0SEVxzDgrnH5sivUDb89zf8u7sCo8H8h6SxrckF9gAfhPxanc13oQy9zBkUlybdulzrqbQ803ia2/BBgadEgiImUnMom7toMTESlPbsGa3PvtCexjVgYaTylUOVuxyfJYjzO4cs1RfK7vvnww6KCK0Nr7YE5P/4R9aqq4xngMAJdwJ4WOA8udWiwcnAgl7vOTJ/G83QjA4Ii0lY9e9RdOjv8ZgMdbVwUdjohIWdJUeRGRMuK6LjPTlwDQ4lYEHU5peBX2f9uHc0nmMlLdw72HO8AD7hd4oeKzDHTWQQTae/3wDcDwKu5myPcItxPVTE7fyPHpn2Cb/hDB8Cfutusy0ljJU8kv8NvUZUGHUxLJzJb8x24EOnJERHaHyFTcRUSiwHHhEedQ/pA9mXazkouCDqgE/DXtNrnJ3tmQJ7kAptdGbloxwA39NmP+dnCGQb5VnpAfU+HFFNfIvfdcJ/xJ4YD0CqqNt6k1thAL90vUofB1icBrJCKyOyhxFxEpI1nHYT09+Vb2IuKWEYnE/a3+p3DVc1U0k+sgCHt1GsDyEvcPbPkTX0n+mxdWfgSYG3RYXVa54UXuSXyTjW2DwJjs3Rvu18nfh94yDVz/YkQE5uB8q+Va9kmsgIILSGFXuI97FJYziIjsDkrcRUTKiJ3Ncon1T7JY/N45JehwSqIl1oNX3OHMS8zmIGMFr666HUacEXRYRfETppjh0N1ow3Lagw6pKGZmK2PMt3jLsVlUexLXPRfj4CEjODzowIrgbl3LvYnZpEiwKjGe9pZG2hJ9gg6raBb2Dj8ONVXcRUTelxJ3EZEyks2mmRW/A4B/p47AcVxM0wg6rKI4XoXdxMUy3EhU1GKGt32amQDACPsxedVpF5NURX8WuQfSK14bdFRFcdLtjDbfps1NMLfvXB5oaOB7/cYEHVbRCmcPWG7I33e+wu8fJe4iIjuk4XQiImXEzmTyHz+cnEnWDn8rbN/NzzHD+jujzFx7r2Nn3vdryplT0G7tWl7iHvIEynX895lBx3WicLfK++vZHUxiZu50x4nAMg2zoMoemVZ5t7BVXom7iMiORKbirn3cRSQK7Gznk1bbtiFuBRZPKQzYsogz43/J3w771Gjbzuaveucr7iGfwO4Pp3MMg57Nb3KhdR+9mvcHJgQdWpc53vvMNsx810ok5iu40WuVbzZreMfty++zpxAbeB7HBR2QiEgZikzFva6ujiVLlrBw4cKgQxER6TJ7m2p0NpsOLJaS2eaCqhP2xN1x+Zt9LP+wj8aNeVv2hb3i7l14cDHp3fgil8d/z/HN84IOqyh+Z4SDyccb5rAo+TkOXHln0GEVrbDK/qo7PNBYSuWBvudzbOomfmlPI+uGe2mQiMjuEpmKu4hIFNjZzHveDqVtW19D3grrmDFmZr4AwO/juYvFhhPuijsFHQOGkUucjJBvB+d47zMbiwq3jT7GVqxMS9BhFc2vsp+Suo5l7hCWu27+NQsru+D7x7bD/b4TEdldlLiLiJQRZ5sKux3y6jRsX412Qp64F7Zbt1UOYKEzknWJIYHGVCzHiLHe7UGz2b2gGS/cFyP8zg4Hs2Mf95B3RgD8kdOJZVvY5HYH7/0Ys8KduGcdl2nm45xsPYu94RRgdNAhiYiUHSXuIiJlZNtEPWoV9wX2IVjx3oGGUyzHdkmSxsFk5YAP8NlFQ5naawAfDDqwImzsfzRnpn7B2P49+Y75AkSh4u5aNLg9aTR75hN3wj79H5jrnkVzwSyMrOMSC/cYDKat+yWnJnK7aTzWMjTocEREylJk1riLiERBuqIv56S+k7+97bC6UPKqnHOzZ/DpzGwa+kwMOqKiOK0bWFpxPssqPk3CS5jCPvTMj940ACN3amCEvOLe0vsgJqV+zgXJG8D0XqiQDxHEe68lSfO/xGUsSHwZJ9UcdEhF651Zm/849FsriojsJqq4i4iUkYxRwVPuKP5qH4fjGhwZgR/T/om47V0rzoY8yS3siojFcq+PE/rqdC5+g4LEPeTH5F9MsUyj45gikBQOcVbjGFn2MRsAaIpAV07hdnC4EbhYKSKyG4T/jFBEJEL8ZOMrmc8D8N9ETcARFe+Jvmdz3cpRrKMXRKE67U0rz7omI9bcz9PJH/DGuiOAvwUdWpf1XLeQPye+x6atB2AYk717w/06+RcjLNPoaJWPQFJ4X+wrxIyOzoGwb68IYBbMHjBCPgNDRGR3Uau8iEg5aVnHp60H+Ij5KESgkguwIT6AZ92RXBr7Ky8mL2LE23/Zia8qX4VDz2Jumv7GFrrZTUGHVZR4aiMTzaWMyL7Jpn4TOC89i993/0zQYRUluf5F7kpcyez2G2lKDuR5Z1+aYv2CDqsoruN0StoBshGouJsFF1SMCAwQFBHZHZS4i4iUEWvrKr4bv41vxf9AJe1kI7DG3b/4kCRNd6MN004FHVJRbLuj9d/w1k6bIU82XO81cgyTTGV/HnEO5c34yKDDKorVvoXx5msc4CznmUGf5MPp77Ow/0eDDqso/nuvkBOBnxGFSxhUcRcR2bGybJUfMWIENTU1mKZJr169+N///hd0SCIie4Rfze1nNPJKxYUs2/hvGBTuYW77Nj7FRdZiRhtvQwRae12no+JumLlfo2FP3DuGthm5AXUR6PZwvNfEwcT09jm3Qz6bzrYz2524OSH/fmLbVvkIDBAUEdkdyjJxB3j88ceprq4OOgwRkT1q25PwKJyUj9vybybEH+i4I+QVNccftmd0VNzDPoHdr7i7mFS0rOZc67/0aB8IHB10aF3mzyJwDRPL6y8M+8WIHW0Pue0WkmHUZHRni1vF9zLn0dZnGuG+VCkisnuUbeIuIrI3cuzMNrfDf1K+3ZpVJ9xJbtaq5H57ArZVwSDTn8AejYq7axj0aHqVa+O/ZmnLQcBXg46sy/wLLI5hMX7tnTya/B2vr/ogcFPQoXVZtqBVfpk7BMN1SLrhX/V4bffZvNjUCMBJRjLocEREytIu/7RfsGAB06ZNY9CgQRiGwd13373dY+rr6xkxYgQVFRVMmjSJp59+epeewzAMTjjhBCZMmMAf/vCHXQ1RRCS03O0S9/APnmK7xD3cx5TuNpBLMpdxufVlyLfKh/tiBPlKtBGZfdz9JRkuJhV2C0OMDVRmtwQdVlHcgor72VzPlPSPSFUPDjSmUijcIjLs20WKiOwuu1xxb2lpYezYsVx44YWcddZZ233+zjvvZObMmcydO5dJkyYxZ84cTj31VJYuXUr//v0BGDdu3A4HLj344IMMGjSIRx99lMGDB7NmzRqmTJnCIYccwqGHHrrDeFKpFKlUx6CjpqZwT/YVkb2bu83wqSgk7ua2e2eHfC/trNcxYJoGTrIHLzvDabAGc2DQgRXBxqTZrSBlVGB568FDz1/jbphgRmMf94wR45bsaVjYWIkYkAn99ooAtuNwmLGMs62HsRsPADXLi4hsZ5cT96lTpzJ16tR3/fwNN9zAxRdfzAUXXADA3LlzmTdvHrfccguzZs0CYPHixe/5HIMH564eDxw4kNNPP51nn332XRP3a665hquuumpXD0NEpCxtW3EP+yA3CtrI33QHsdGtpikR7i25/E5/yzBoGjCJj6avYUy/Gk4KOrAivDNoKuekBnHC8H7MNN6CCAwJs12TJreSlFmZ74wg7McUq+K72U9jGtDXW7ifDfnSE4Cvt/yIKckFADzfFu6uCBGR3aWkC6PS6TSLFi1iypQpHU9gmkyZMoUnnnhip/6NlpYWtm7dCkBzczP//e9/Ofjgg9/18bNnz6axsTH/Z+XKlSU4EhGRYGzseQjnp7+Wvx2lNe638iHOTl/J4n4fDjqkoiTXPcebyf/jrswX8tXpsE8r94e2mQYFrfLhruSuHngyh6Z+ww/7XA2GN0TQDff3k19dj5kmP8l+nwcSXye+YWnQYRVtf/vN/Meh36FBRGQ3Kelwug0bNmDbNrW1tZ3ur62t5dVXX92pf6OhoYEzzzwTvP1KL774YiZMmPCuj08mkySTSerr66mvr9/hHqciImHRlujNQ85h3Jw9nUHGBvrEewYdUtH8xN2fwB721l7HzmIaLgYulukn7uHO3P0l7oZhYHgXI8KeuDve+8wyjY7p/2GvuGcz1LKJmJlgOKsZZDawNL016LCKZmIXfBzuiysiIrtL2U2V33fffXn++ed3+evq6uqoq6ujqamJHj167JbYRER2t6ydSzZ+kP0UAHNrDgo4ouLdWXMh1zdNYUvVfhCB4VOuP60ci5qNL/Bw4lI2NA8EFgQdWpfVrnuE2+K/oHHLWAzz5NydYd86zXufmaYB+cQ93Bf3jS0reKpiBs1uJZvpBQXvxzCzCi6oqOIuIrJjJW2V79u3L5Zl0dDQ0On+hoYGBgwYUMqnEhGJpMqtb/Ex62GONl+CCFSnAZbH9uVR5xBONx7lqeQXOHHlz4MOqSiO3TH0zHLTDDfX0c9ZH3RYRalsW8sJ1gsMS79Oa69RfC59Gb+qvCjosIrSr+ERfhe/ho823kYm0YtlzmA2W32DDqso/p7ttmHmhu4Bzg6G/YaNVVBxD3tXhIjI7lLSxD2RSHDEEUcwf/78/H2O4zB//nyOOuqoUj7Vdurr6xk9evR7ttWLiJS73hsX8aP4L/mMdS/gdtq3Oaz8iw9VRopaYwvJbLhbe12nY5sx06vkmmHfOq1gOzi7si8POBN4LrbjobBhUdG6huOtFxmWeYO3B3+QU9LX85c+lwQdVlH8mRc2Fg65957jRCtxt1RxFxHZoV1O3Jubm1m8eHF+Mvzy5ctZvHgxK1asAGDmzJncfPPN3Hbbbbzyyit8/vOfp6WlJT9lfnepq6tjyZIlLFy4cLc+j4jI7uRPkT/JWsxbFf/HwHfuDTqkoh3R9iifsOZTy8bcHSE/Me9olTfza6fDnrj709ZdwwRvN7jQN3t47zMXq2AWQcAxFclP3B1MHG/gnhuxxL1wvbuIiHTY5TXuzzzzDJMnT87fnjlzJgDTp0/n1ltv5ZxzzmH9+vVcfvnlrF27lnHjxnH//fdvN7BORES2t+1JeBSmyn+k5S8cGF/Kq/YoiMBe2m6+Vd7CtHK/Rs2wt/cWVNwT7Rv5sPko3TM9gRMCDqzr8mu/TbNg+n+4X6fOFXez031h1uxWUk0L52e+QUvPkfwj6IBERMrQLifuJ554YkFL3Y7NmDGDGTNmFBPXLtNUeRGJhG0SdyMC1TQ/qc2aCYjAgLBUogcP24fSXDGUg6yIVNzpqLh327qcnyR+zsr2QcA3gg6sy/zE3TUsBq97iAcT17B6w6HAHUGH1mWOnQHANiy2WL1Yne2NXX5zhnfZKfZPSGVz78HBTmXQ4YiIlKWSrnEPklrlRSQStknU3QhU0/zWVzufuIf7mLb0OpTpmVnc3L2uo+Ie8sTd9friXaKzHRwFiXvSbmGkuYo+2bVBR1UUt6BV/tpe3+Xo1M9Y3//ooMMqWuEQzigM5BQR2R3Cf5lWRCRKtmkjj8L6VX9KtGPGc7dDfkx24f7gsQredAbQZPYg3PPKXRzXAMPAMMz8faHmr3E3TAy/MyLkSxraE735U3YybrfeBev2w/06ua5L1nEZwEY+E7sXN1MFnBx0WCIiZScyibta5UUkCratsEdij2Zyx7Q13peXneFsjIV75onjLRezDAO7936cnL6BmooYLwQdWBFeHvoJzn1+LB8ePIjPG5sAMEOeuDsOZF0T14hhGrnTHSPknRGt1cOZnb2YAyqq6WtEI3F3HJc/xr/PAeY79DOaWO/2CjokEZGypFZ5EZEy8lqvE/hC+ku85XjJrZMJOqSi+RX353uewgfT1/CX3p8LOqSi9F95Py8lL+Qbm6/IDz0Lee6Un11jAIYZjYr7c0PPY//U7fx1yOx8xT3s8xVst6PbY3rTXO5OfIc+ax4OOqyiZO0sR1tL6Gc0gabKi4i8q8hU3EVEomB9xXDudbIMtdczyX2FVGJA0CEVzd/qyfLWg4e9QmjYKaqNdhKkI9SunPvbLGiVN99nEG25818T0zQ6tu0Le+KeSVFDC1VmgoHZdxhrvsHC9o1Bh1UUO9v54mQs5K+RiMjuosRdRKSM+MnGL+1p/NKexld6jww6pKJdG/s8qZZG9q0aAWwmG/Ik17E7hp7F2tZxX+Ib3p7apwUdWpcNXfc/fhH/E22bj8YwT/HuDffr1DGLgI7EPeSt8j3XPMoLFZ/jtaaRtMb75O4M+QDL7DaJuxXy10hEZHeJTOKuNe4iEgV9mpfyQXMRr7uDWOoOC32SC/C0cQgNTooftr/EQ4kfsXrDaODuoMPqMrdg6JnlOowyV5JxraDDKkrP1rc40lrIwvY+ZLtfxJfTXyDZrTvXBR1YEQ5cdy+/jP+Ltk2n4PY+mHfcvmwyegYdVlGc/FR5C9frjAj7AEs72zl+S63yIiI7pDXuIiJlZMyG+6hP3MRHrMcgAi3YFBxDJWlGmA30zIa7tTe/zRgWprd2OuxVQjdfXTexK3ryD+dYHjImBhxVcXq3vMGp1jMMaH+T5oFHcmzqJq6oujzosIrjJemOYXldHlFI3LetuNv5mQsiItIhMom7iEgkeCfhn4/9iyXJCzhyxa+CjqhoJ9uP8mHzUSpJAWCGfB931+mouJt+C7bh4tghTt7z26QZmN7AvdCnToWdEfkhguE+Kn/XCdcwwXvvEfLE3dl2jTtO6Ic9iojsDpFplRcRiYLCqdfdjBSGnQo0nlL4lnszNYkWnnC+DAVT5kPL6VjjbsU6fo3aThbTSgQYWBG818Q1DWLZrXzAXEilXQlMCTqyrnO895lpYUZliKD33nMMCzdfcQ93a3nWzpJy45g4nJr+ITYmD9o2lqlTVBGRQvqpKCJSRoxtqmdh374KwHSd3D5jVkXudsjXsLbE+7DQGcmG5HD2t+L5++1slng8rIm7n9AaxJvX8KvEjWxyaoBvBBxYEfzvHcOiesur3J34Ns2t/YATg46sy5x8xd0iZXVjs1tNNuSncplutRyYug3T6NhW0Q739RURkd0iMq3y9fX1jB49mgkTJgQdiohIlxl+Rc3NVQjD3gZLwbApI56ECGzJtbz/yZydvpL7+l2EZXUMpXPC/Fr5XRCGmW+VN0LeLO9/L2FaxOw2xplvsq/zVtBhFcW/sOcaFv8Y/FUOS/2KFwafE3RYRfEHcCZj1nb3iYhIh3Bfpi1QV1dHXV0dTU1N9OjRI+hwRES6xktqU0acStLbVeDDKJ+4x6KRuDv5bcYMrFicNW5vHAxqQr3GvaPijml6H4U8eSqouBteZ4QZ8mUajRVD+Id9NJnKg7H89v+Ql6f95QvdYi5fcP+MhYPdfixU6FxORKRQZBJ3EZEo8Ae3pUl4iXu4k1wKJ65X1PCmM4B1sX7sE3RQRbC9JNc0DMx4JUelfgbA87GqgCPruieHXMD5y47hk0NGcIFXcTdDn7h3rHH3OyPCvkxjTe/xfCdTwWm9BtDXT9xDPnDP2LKSX8evJ0N3psYWALAhfT2gxF1EpFBkWuVFRKLgoe5n8NXM53jaOhwAI+QT2B3bxjJyiUVz/yM4KX0D36z8TtBhFeXgFX9kYfLzfKihPl/1JOQJlGPESJHAtRIY3rTysA8R/PvAmYxsv43Fw87H8AadmSHfts/2ujosy+CojX/nj/HvM3rN34MOqzjtjUyxnmOi+0L+LsfOvOeXiIjsjVRxFxEpI0uTh/Afu5Y+iSpqWtaxLjEk6JCKYtvZ/BXiuDeBPeyTvWPZZvoZjVS6rRTk7aE+Ln+bNMMAA3+Ne7hlMUkTByuBma+4hzxxz2aIkSVmQJ/UKo60lvBk2/igwyqK7SXpWcMi41jEDZtsVom7iMi2lLiLiJQRP/l7rNtJ/HLzeKb1GsS0oIMqgu0azEzPwMThnIruAGRDviY3v3WaYWEYBnclriJGBrd1HHQfHHR0XTJyw3/4cfw+jE1TMMzTIAJJbscsAjC9LgIr5K3yB6/8A69XzGHh2g+QrewHO9iJImxcL3F3sLAxiWOr4i4isgORSdzr6+upr6/HtsP9S1lE9m7D25ZwovkOceNQXsLCdsKdPNmY/Ms5GoDPtK/ivsQsWlM1wElBh9ZlhZO9AQ41Xidh2KxNtwccWdf1b17KUdajPNk6BLfyk8zOXIRhxbk66MCKcPSmv3J8/BmSm/4PY9A4NrnVbKU61Cun/T3bXSOG6+9zHvLE3fa2uLMNC9uwgAx2NtzHJCKyO0RmjXtdXR1Llixh4cKFQYciItJlZzXexq2J6xmbfQkiUJ0u3NYpgc0ocwUj3JWBxlS0gmnlAI73q9TfYzuc/AtEBlR050/2yfzVCe9+5wD7tLzAR6zH6dW2ArfXPhye+hVT3Z8EHVZx/PeYYWJ47z9CPovA9Y4pV3H3vqdC/b0kIrJ7RKbiLiISBf5WacemHuYTyZ/zWsNE4G9Bh9VldrqdqeZTOJjE4mdABFqw8bogXLNz4u6GeAcAwx+sV7CPe4hn7QFgeO8zw7Q6tk4L8RwC6Lho5Jox8CruYW+V95N0x+hI3G2tcRcR2Y4SdxGRMuIn7pbh0sfYSoXdEnRIRXHatvCLRK7K+XbsTIjAOuN8a7KRS9ht/+8QVwldv2prmBh2imPNF70ThKnBBlaE/FaKBYm7E/arEU5Ht4d/4SjfARJShWvcvxS/gg3Naa6vGhp0WCIiZUeJu4hIGfETd9tMerfDmwzibQcHkHVNYrEEALGQJxqN8X685IygJVkLkau4G8RSW7g9cQ1Z1wRmBR1alxVW3GPtW7gj8T0MXOD0oEPrOn++gmmBlSDlxnHccK96XNfvGPZtv50jhtawptnmHbeNjJkIOiwRkbKjxF1EpIz4ibpj5U5cjZAnuU6+mmZiWP5k73C3yj/R/1xuff1IZgzanykQkXW5HYm74XUQGIS7Op3/3jEtTGyONF8BwHUcDDOkyW7BfIUXh0/nk0sm8dGBQzgy6LiKYLv+z4cEMTM34DH0nREiIruBEncRkTJiem3kjpXsdDus7KxXccfCisUhAmvc/XXSptd+3UQ1uA6h3gDALRhO5yW1lhHu5MnwjskwLCyr43THtrPEQlrRXZccwb/tI0hX7Vewbj/Mb7yOAZaWafCh7AO41nrMxqFA76BDExEpK0rcRUTKiN8q7/qJe9gr7k6u4m5jYsYSrHV7YWMx2HXBG4IWNrZXDbS8+M9N/Iy1Te3c02tkwJF13X8Gfo5LVk7hwiEHMbLgdQlzddqvuBumheFdNMJP3OPhTNyf6306t746mrra/ejrJ+7hvr5Czw2L+Gn8Z7S1jOKozIMMja/ipa0fBQ4NOjQRkbISmcRd+7iLSBT8Pv5xss3rOa6qH6yPQOKenxhtYlb1ZUKqHoA3XTDDmbdzyupf8LnEv1m+9kJgdr7ymQ3xxPKUWckWumPHumH4Q8+8lmXrPb+yfP241xU8+9Y6rh4yiYOsgmMK8XmCna9Omwzd+Di/jt9M64bDgMOCDq3Lks2rmGY9yUupdESWnYiI7B7hvIy+A9rHXUSiYL51DL+3P8CW7iN5wdmHlebgoEMqim37FXeLWEHl1g7xGtaqzGaGm+tI2s1AvrM81FuN+WuKDYP8dnCEfOBeq1FBE9UYsSSxbVrlwyrfVm4YVKfXMsV6jmFtrwYdVlFcf+CeEcMx/MRd28GJiGwrMhV3EZEo8JO/jX2O4EPpH3Bgr+6cEnRQRUhX1PK1zGfpVpHka1ZHQmg7LvGQlnILW7ABvpW+iR7xBpKbfgzDjw44uq45dPODjIo9RvfN08Cclr/fCfPFiHx1GsxOiXt4L0Z8ZOUPuSp5L8+sqsPs3hciMMDSLdjH3U/c3ZDvTS8isjsocRcRKSOjs0sYYrRTxQgAsiEfPJVO9OAv9okMilUw283w18QVWDjY7cdAvGfQ4XVJ4bRygNHOawyzVvFye2OwgRVhRPNiJsXm82TzARjxs/le5lO4GHwjpHMIAD7SfAdnxVZQ03gpVuw42t04NmY+UQwj08mQMOzcMhPv/We44f4ZgTcHo3PFPbyvkYjI7qLEXUSkjFyd/RH9kpu5N3MIACEueMI2E9hN0+IIcxkATZl0wJF1XT5xN3K/QvP7uIc42cgnf4aFGa/gN3Zur/OvGyFtiwAmpR7ngNgyFrefi2maHJS6DYBnKnoFHVqXGd52kZgWhtdF4G8hGVZ+dd0xLRxvjburVnkRke0ocRcRKSOWt/1b35bXeSRxI5ta+wJPBh1W17Vt5kRzMdVuL2LWifm77Wx4T8zzSa5X8fTHt4V5PXh+OzgDCmvsYd5PO78dnBnDMAxMI3chLMyzCDreezEMM+bdF+L3HYC3dME1LBzvYpha5UVEtqfEXUSkjFiuDQbELYOh5nosJ7ytygDJTUu5NXEdK9KDMa0vkHVNYoaTH1oXRtu2yjtGruLuhDlx97iGhek6HGEsxcDFtU8O7amCvyOD6U2Ut0wDx3ZDnrjnElrDKkjcCXerfOFwuj/0ruOVt9dwQa9JQYclIlJ2wvnbWEQkoizvJNyMV3q3w50M5reD89rJc387ONnwVtQ2W314wxlINtEDChJ3QlwlzFenAcPN8NfkVQBsTV8AlRUBR9c1Jn7FPZe418duJGm24249GHqOCDi6rulYpmHlE3cr5BX35wedw2dfPpgzDx7GmhaTZ93unBvS+RciIrtTZLaDEym5pjXwk3Hw6I1BRyJ7ET9RtxLRSNzz61e9dvKs93eYK+5/6P1FTk7/mFWDTwPA9S9KhHqQoFeFNi2Mwu3gwtwqT0erPMAxvMAJ1guQaQk4sq7LX2CxYmwccjL7tt/ON3r8KOiwipJ2YzTTDSfWDcvMvfeyIe6K6OSpX8Ky/wQdhbyXpjVw80nw3O1BRyLyvpS4i7ybJ38Om5fDf64MOhJ5L6uehZ9NgKX3Bx1JSfiJuhnPVTnNkCfujrd+1Z8WbftJbogHufl70Pv7nWeMBO1uPNyJe0HF3TStgrvDe0ymd0x+q7xthP+9tyK+L4/aB9NeOYCYZeFgYoc8x7W991jMNBjX9hQXWfdSs+WVoMMq3oqn4L6vwx8+GnQk8l7+cyWsWgT/qAs6EpH3VZaJ+/Lly5k8eTKjR4/mkEMOoaUlvFfHJcQGjs39PeK4oCOR9/KnT8CG1+BP5wQdSdEcxyXmVQmtpFdxD/lWT4V7NAM0GdVscqtDneT6a6Rj3r70V/X5EQelbqNh4EkBR9Z1f6udwdHtN7F0yFkYRsepQZgH7vkXvfxW+fxyjRDv4/6Xmul8KvMtNgw4Ll+dDvOafYB918/nh7FfceiW+Ry99X6+E7+d3psXBx1W8RpXBh2B7IxUU9ARiOy0slzjfv755/P973+f4447jk2bNpFMJoMOSfZCbe1tVAINbVAbdDDy7tq3BB1BydiOww+zn8TC4exuuS2rYmGvuPuDp7yk6Qzz52xuzfDvmn0DjqzrLtz4Y76ZWMKWdd8GzsX08twwJ1DNZg9W05dsrDumWZC4h7hV/rOJa9nY2Mwv+3lbK+YT9/Au0/DfY5ZpUN30OjfFf0qmpT8Q3gvMtc1LOCr2EE+1DsD1tx8M8byIvGFHBh2B7IQNB32CvkvvZUvVvmiygpS7squ4v/zyy8TjcY47LvdLqHfv3sRiZXl9QSJu+drNALy9ObwneXuFbn2DjqBkbBd+bX+QX9rTsKp6s8wZzJvuwKDDKo7TueJueUlhmNew9s+uZpS5koSd6wbzK59h3jrNzbf/02mNe5gn5W+iB2vpgxnLLTuJQsU9W5C4JzNb+JD1BBOyzwQdVnH8JN2M4XrzCCKRuMcKhjqGuMMo6l5dnwagKaXXSMrfLifuCxYsYNq0aQwaNAjDMLj77ru3e0x9fT0jRoygoqKCSZMm8fTTT+/0v79s2TKqq6uZNm0ahx9+OFdfffWuhihSEpWblgAwMR3iPbT3BpNn5/7e/5SgIylaYTIb6zGIU9LX86HMDwKNqVibux/IlZlPc3/1h8Fbx0rIq9Om23la+Uebfs9v4tfTu+GJgCPruomN9/Ot2O0MaHwOwzRx3NzrFOaKu/8e8xsI8ol7iC9GfGvjbJ5PfoaBax/CtKIxVd7wXw8zVlBxD/cxARAr6Ba1U0FGIu8h7ea+j2JuOuhQRN7XLpeyW1paGDt2LBdeeCFnnXXWdp+/8847mTlzJnPnzmXSpEnMmTOHU089laVLl9K/f38Axo0bR3YHWwE9+OCDZLNZHnnkERYvXkz//v057bTTmDBhAqecsuOT8lQqRSrV8QOxqUlrVaREsvpFGwp+VSPbHnQkRbMzGQ4zlmFjkoxNBsB1c2vfTTOc+7lv7TaMW+3TOLYq1xlxRfYmesbXEdv4Exg8MejwuiQ/2durDu6XXspY6zmebl0TcGRdd3DzExwRW8BTW3OzPW6wz8Zx4YJYt6BD67JLsn/AjbWRaBsJ9MjvbBDmdfsVTis9jFYsw8WworGPO97e9K5pRavivub5jo+zKfC2+JTyUtvwMACD7NVBhyLyvnY5cZ86dSpTp05918/fcMMNXHzxxVxwwQUAzJ07l3nz5nHLLbcwa9YsABYvfvehI4MHD2b8+PEMHToUgNNPP53Fixe/a+J+zTXXcNVVV+3qYYi8rxAXBPcuoz8MB50BViLoSIpmtzXy9+QVADSan83fn3VcEiFN3Duqnrn4x7ivMdRazavtjQFH1nXbDj2LQpXQ8LeD8wbT/cI5E9tx+XS8KtjAinCW+yA9Y828nf4aAOdU/pK3N7fz1z5jgw6ty/LvPcvCilzFPZ7/XnKjkLhvKRhOZ2rJZ7nKeBX3fyRO58NBByPyPkq6xj2dTrNo0SKmTJnS8QSmyZQpU3jiiZ1rIZwwYQLr1q1j8+bNOI7DggULGDVq1Ls+fvbs2TQ2Nub/rFypKZ5SGov3vTjoEGRnPPht+O1UWPZA0JEUrXBv85jbzoOJrzE/8RXsdFugcRUj3rqOicYrDMuugILt4NwQDwgzXT9xz53wuV6yG+ZKLl5LvL++3b9O5BLeK5imv4+7tx2cvy1cmGcRdCzTiOfff2bYK+4Fa9z9BNeIQuLut8ePnArJ6qCjkXfjvU5+y7xIOStp4r5hwwZs26a2tvMM7traWtauXbtT/0YsFuPqq6/m+OOP59BDD+WAAw7gjDPOeNfHJ5NJampq+P3vf8+RRx7JySefXPRxiAC0O/GOGyE+0Yu89Uth9bPQHv5lMra3hCjjWliWxUhzFfuZa8hmw7v2rrbhYf6c/B4f2/IbKBhSF+bJ3sY2CaFfpQ53xd1L/rxjOchYwcHGWzghfu/FvAssViz3s9y/GJEN8cbn/kUj04pheoN7rZDvPGEUXAhb1P9j/F96Ns/3OT3osIrnLbdbH/5VXNFm537GtTtK3MtaywZ45MfQFN4laaVQlu/S92vH35G6ujrq6upoamqiR48euy022Xu0uwWJu52BWPhbsaMovfYVEkD7vd+kYmy493L3kyQbk1gsXnB/eE/M/ZZXvyrtJ+5uiCd7bzF6ssbtDbHcmtWO9t7wHpPfKu/v4f4X69tUxDKsaZ4CfcL5OzVfcfequJekfkt1fBUVm66E/Y4NOLquKTymfKt8yBP3u/p9kbqGaXxx6Di2tFk85riMig8KOqyibWpsojewZuWb9Mu0Q7xiJ75K9rTK9vUAnGf/Dfht0OHIu7nrAli+AF7+O1zyaNDRBKakiXvfvn2xLIuGhoZO9zc0NDBgwIBSPpXIbrfvmnkdN+yUEvcyZbXlfulWpDYEHUrRHDuX5NpYJAsSdzvEVU9sP3H3Ku3egDAnxK2ws7pdxbJ1zfxxwAQouChBmNcau53XuPsT2N0QD/vwk1y/Rf7w7PPsZy3nxdZ1AUfWdfmKeyyG3XNfxrT/msqKJAuDDqwILUY31tMLktXEUrnydJi3i/Sl2nNLnA51l0LDyzDkiKBDkh0wnYJBxK4LRjjnyUTe8gW5v9e+GHQkgSppq3wikeCII45g/vz5+fscx2H+/PkcddRRpXyq7dTX1zN69GgmTJiwW59H9h59mpfmP47EoJyIMsJ/fpdnZ3Pt47ZhYZhWfksuP6EPJS/RyCfu+Yp7eI/J9pJcyz/Bi8RwOr9V3tsGDn87uPAek+Udk1+Zznd9hPh1es3ch2ed/XESNcRicZrpRosT7ovKWW+Pc8s0GNi6lE9Y8xnS9FzQYRXNyRT0yGs7uLLV6eJkiJdwRd7Ez+X+Pu6rQUcSqF2uuDc3N/P666/nby9fvpzFixfTu3dvhg0bxsyZM5k+fTrjx49n4sSJzJkzh5aWlvyU+d1FrfJSan6yfm3mXC6L15B8368QKU5hxR0gi0kCm2w2vCcTHa3yuWPKGAna3TiOE96BWo53omd5i6b/NPhbfGzd+Xxj6GiODDi2rvptr0t5ccsqvjQw10Lu+Il7WCufrovlXdXzp/87EVjScHn8q6xqaeMffUdhWbnXyA7ra+Q5Zsu/ODL2CrWNn6L75kf4VPw3PLF5E/CpoEMrSmHibqfbvJ/qUm46Dau00+quLFfeLAJie/fZ+C4n7s888wyTJ0/O3545cyYA06dP59Zbb+Wcc85h/fr1XH755axdu5Zx48Zx//33bzewTqTcGd6V1wwx0lmHZEy/dstTuE9aC6WSvfhx5mMkKir5Yj6Bt8NdcfeSJNdLnr7b54csfGszvxh4eMCBdd332q+mKrGJisZfABMxLQsXM9QJ1KZYP95wwU7UAOAa4a64O47L5NQNWDjcVdUHADe/o0F4v58Kq9Ox9FZ+GPsVMcMBdm0uUDk5tPUJxsWeYmHLcdgRmiq/dPSXcZb8i+HmOjKpdiXuZeqPQy7nu0tOBcDJpDC1A0B58hN3K/5+j4y0XU7cTzzxRNz3mbA9Y8YMZsyYUUxcu6y+vp76+nrsEA88kvJiOrkfEinipLPhrQ5GXVOsNz2z3vp2OwtWWc7c3CnpZB9+ap/F4HgucV9t9CPmZDDD/PbzT8C9aqdfpQ7zGtYD7DcZYG5gmZOrqPnH5IT4mPzf6+Z2rfLhPCYbeNvNzdaxvBM9Jz/9P7xJoV3Q7WG5ac6JPZT7RIjX5hZOynf8xD2kF4wKtbpx1tKb4awjk25Do+nKUzMV2K6BZbhkMu3qrixXr3lb/j5yIxx7WdDRBKaka9yDVFdXx5IlS1i4MCQjWjYsg607t0WeBMPwEvfvx3+Ls/61oMORd/Htobd13MiGe9+d7DYt2B8z53BCeg6p6vBOWF5ZcwQ/zJzLkp4nAhAzc792wlyd7pjsnbsYMWHTPH4Wv4l91z0YcGRdd2zzA1wW+ws9mnKzPTqG04XzqlHh+8v0Zwf6cxZC3Cr/5+yXeSI5g8qm5fkLEoR8Doaxw33cw/sa+VIZO783eDYd7t9NUZaxXdLkvpcyac0iKFvdB+b+TjUGHUmgwluaCrOta+Fn43MfX7l3vwHLmel0rCu227YGGou8u63ZggZEO8TT1wE31cxBxgr60hMiUp1+p/oQfmFX8umewwE4c+sfOT/+PMmGLwAfDzq8LumYVp77FTq4/TUmWU/yZMvBAUfWdce0zmdMbDGLth4DnMQfjA9Cpo2pyV5Bh9YlTqadr8fuwMbEck8C4h2t8iFOCvuymRqjlZUmmAU7T2SzGRKxcLaQFlbc/YthhhveCxG+YW/8kUnWS+CtcZfydNL631Np5M4dshkl7mXr2EvhrxfBPscHHUmgIlNxD9VU+YaXg45AdoJVkLhnM7paXq7asnBY+1ymdvsTVIYzyfAl17/E/clZXN3+fShM3O3wJu7bdhHsm17KFOs5KlpWBRxZ11nbbDPmb6EW1vXg0LEdnN9t/VvzY/woew7Zyr7BxtVFdrqdL8T+yRdjd2N6czB+3O/7HNh+KysHnRp0eF1muf57L07M6rho6YR4Grbp7UNvWLH8+tUoVNwHrnsEgFY3SUv3fYMOpzTWvsjmO79A28Nzgo6kZMY25/YEvyj9FVI1+wQdjrwbv8MoxD/rSiEyiXuoWuXNggphSNcP7g3m9P8+a91cIqg2tzKVaua76y+lPn4TzVkztGs8fa7XMeBPlf9R9lruSXyT2Mal7/OV5atb+1rGGG/SM7MeAMfwtuYK8Yl5PtEw/W3G/O3gwtlWTqft4LyKp/e95IT0d5RbMO/GiuVeJ9uqIEUC2w3vmDCLjuq01aniHuLvJ7cjcTcitMbd8LaAm5W5mC19o7GH+9q3XqHXK39g5eN/DjqUkom5uUQwrXlG5c30E/dwd1YWKzKJe6gkuuf+7jE09IlGlDW7Sda7ua0FbSXu5SnTxkHZVznaWkJzJvzfS/46VX/bqn3dFYwx34JUeJdqHLHmDu5JfptJ670TPTP8A8I6qp7earN8e294kw1v57R8wj6YBvYx1uBmwtnimy2oylheMhiFIYL5velj8fwFCQAnxFtGdrTKx1lXewyfTV/GvJpzgg6raKaXuKeIk4pIQti6KtcxOjIVnc5Rf1lk2o2TtqPxOkXSHZ/I/b1qUdCRBEqJexC8H+ZY2iuynKWzNhlvDISd2buv8JWtbEdS8W3757BpeaDhFMv1kg0/cXe8ynuoB0/5yayx7V7a4T2mJqpodLth+q17fsU9zIl7vuKeS25vzn6b/yW/QmLz68EG1kX+ADrHNTCt3KnOlKa7+XH85/TZ8FTA0XWdn7gblpW/IAFgh7h99Mqqb3NC6gaaB0wkVT2UB50JLIuPDDqsovmJe43RQqZlc9DhlIQbwWWDfsX9Z4mbMLSUVcpcZBL3UK1xz3qJe0ybTpSzj2+5hcPN3EmrHfJp5ZGV7Rgk81HzIdzmhkDDKda2FXfbT3ZDfFLu7+NOvq3cSzZCfDFisv0zxqZ+jdtzaO6OfBdBmBN3rwrtdQ+EfTs4J5t7f9kFpzkHpZ7no9ajVG0N5wU+x7YxvdaImBXHtEwmpuo5vH0umYreQYfXZevondu6L16V74oI864TPtPJ/X66Pv4rBr30i6DDKQm7cDlQSH82bMtP3PsZjdC8LuhwRN5TZBL3UK1xHzg29/e6JbA13IlGlB3T/nD+4wzhnNYbedtcUMmmQn6BxatC5yvt3t9uiJNcv+Lu+om7nxiGOMn11337SUYUKu4dw+k67+OOG87WUSf/vdRxmuN6QwSNkHZ7ZG2bl5wRvOIMw/Qu/G82e7OJGmw3vEuF/CQ9ZhlUt6/lw+ajjGkLwbnc+7Ccjk69qFSqOw1KDfMF5QIxOn4e2BF5nSKptzfg8YL7g44kUNoOLgjdekOiGtLNkGkJOhp5F/5V2NNTV/OlASdxaNAByfa2+SWbSbeG+hLLthX3/N8hTtz9KrThJU354Wch3u7JTzQsL8ldOOxCLnr9GM4auA9HBhxbV93U/VJWrl3PV/pNhE4V95Am7t5wusKKO0a4Lxo5hsUZ6asBeKlbDQCmYQBuqCvU56Tuwo41UtE6gtiWF/hJ4ucs2ToG+GLQoRUl5hRsLZaNxnK7bEGV3c20YsTCv+TTP9cDsCPyOkWSfx60ly8zjkzFPXT8N55+SJStjkmjscgMlokae5vBWZlUOAdp+RqrRvCL7DSeqjoRIrIePL/G3ZsI+88hX2Gf9tt5esiFwQbWRa7j8IfY9/lD/AdYGW9ooFVBC5Wh7sxZZQ3hRXdfnIrcQE7Xnyof0iQ33a2WqalrOI/v5e/zK+5h7YzIFiTnMa/b4+vWH/le7BbcELf4fjhzP1+I/ZOK1EYMb26EGdLXqND3B8/l99kpALgRWW5nF+zWkA7571vfucl6lju1ADiaZ1S+/PlgEbhYVAwl7kFY/xq0bcp9bKfe79ESkDjR2yJk1bLF3PzDmSy859dBh1ISmWyWJrcyfzsb8hOJTdUH8sPsJ3ikZhoAzWYN691wt8HmE3dvz2nDiuNidkpCwsRxbI6ylnCM9XLHdPkIrMv1QzfYtlU+nMdkmwlecYezzBiRv69j275wJoWF7y/Tu7DyUeO/nBf7D7SGd/iZWbDFnektqYlC4r6BHrzpDgTAyEbjXO+pQefnP45K4t7g1ORmLABORC6wRJI/w+jvlwQdSaAik7iHajjdisc7PlbFvWz5657+mriSIW/9NehwSmL5i09wcdtvqH7x90GHUhItg47h0NRvmG8fBkA2He6To3wLtjfs7No+32dCai4NtccHHFnXPV91DDdlP8KGnrnZHjHv2MKa5NrZju4Hw9uOa8Tmx7k+NpcJm/4ZYGTFObn9QT5v/ZPKlhUAuP7pQUj3pnecbeYQFCTuoW2Vb9nEw4lL+W9iJjHvsOwI7DyR35s+Fsfwtlj0k/kwa8/YpP0unIgUabZSwTJnMCucfqQy0Vjjns46+R2EXJ2Tl6+hk3J/N7wUdCSBiswa97q6Ourq6mhqaqJHjx5Bh/PeCn8wROSHeeS4Lgkvce9nNLKydW3QEZVEG7kWI8uJxvuu3euESOe37Qt3BcBINTLMaKCnWwEF7bBhrU4DPFd9HPOy+3Nlr9EAjN38ID+L3w/rTgUODDq8XeYULFuwvC6Cvq1vMim2gIUt4d0p5Iz2e9g//gYvbv0AMJ4H4idhtG5kfLf+QYfWNS3r+KL1Nxy6Ax/I3WeEe/q/nU0x3FzXaYs7f/ieHYXE3Yrnt1g0QzwDA3Lrcc/bVM+RsYcAMCJyrpfKOJySvh6AR7oNDTqc4mXa+brza06xcnuDq1W+jJ37J7jeG1DnOB27uexl9s6jDlrhD/CItE9FzrbTUiPyS/fQN28GYGTmlaBDKYn2TO6E71uZi5jQ/nPW7vPRoEMqyvBV81iQvIxPbvgJFFQL7ZBWPQFsbwqx5SUate1vcIb1JP2alwYcWdcUVtxjVudJ+UZIB7lRGLv3nvtD8uN8N/tp2qrCeXJuNq/lK/G7mO78I3/ffYO/yGHtc3lm0CcDja2r/IF72YJTt46Ke3irn5bXFm9ZsYKKe3i/lyC348kH2/9FH2Mr/7KP5I3uE4OOqCRGN/yDb8Vu53Djtfzv31DLtPJ/xgMAjGq/haXDzgk6Ink3VsEMGXvvvcCixD0Ihcm6Ed61q5FmxTkqM5d/2d6M6Gx4T4oKhXVP5ncTe+1efhe/ho9bD7GenrSHeDgYdGwH52+ddm7jLdyZ+C59Vz8UcGBdV5NpYD9jFRXZ5twdoV9n3BG36SUZRj5xD+cxUbCPu+FP/ffuD2uzh5/kFm4Hl41Vs5kaMkY4OyP8ideFx2T77f92eN97lpekm7E4Ziwia9wLzvO+lJnBY/0+Hmg4pTJyyyNcHLuXkeY7tGdCfnEFcPzvKdegjSSZsP7A2xsUTpNX4i57lP+Gm/AZ2O+koKMpDceG+74BL/896EhKwgXW2DW87eYmjUalzS1qv5PMLW9xvPUiB5orwWvjCzN/erw/TX5w9m0mma+SbF8fcGRd98n1P2F+8muMaPg3AEZ++FQ4W2Fdu7BV3lttFoWKu5+4e7d7u40MYCPY4RzW1LG1YsdpTr6DJaQXMP1j8qvsFMwiCHOrfMxrlbdiMTI99+fL6S/w09j57/t1Zc0bcpZ2LVzMyOxMY3nnQtfGf038ncff9/HlLpPOvU65Ne5GZAYRR05qK1w7rON2iDuMiqXEPQj+ldgI7UXovPR3eGou/CXkv2w9Ga+9N+16FVwnGlf3wron87tx0rk17ceYL3NF7DZ6vnVv0CEVx6+4G14Ldr6aFt6T8nzlbJu28rBuyWVns7S7cdKuhemtsctXqUN6TDleMuu9Pte1focnK75I94Zngg2ri/wBdIXV6YMbH+b7sd+w34b/BRhZ1+UTd6MjcfeT+DBvGTktczVTU9dgVPfDqOrLP5xjecQYH3RYxcl2JISVtEP7lqAjKonC+Thuy8ZAYykFP3FPGhlujNczbFXIzyGiys50XrK6F1fcIzOcrr6+nvr6+k57TJYt/w0XocR9zTvLGRx0ECWU2bqBq2K/ZXrMqxJG5IeEE7GSu+390u1vbOGC2AO8sa4fEOKLR36C7iVPjpfAE+KTcj+Z9Svt+H+HtFU+W9mXg1K3YRrwpp+4R6Di7q8pNrwKtb8dXEiL0/n9552C6vTQlpc4MjafJ7cOCDCyrnOyfsW942LE7KqrWLGxmR/1HhtgZF3nOC5LnSEAxOIVWGbuZ3qYB3JCR4GmykjxSsWFrHtzMLAk6KiKFitI3O10a6CxlIJdsBPNmdZjPNu0b6DxyLvYdh5YRM7JuyIyFfe6ujqWLFnCwoULgw7l/R12Hgw4BBb9Fpb8Yye+oPy1E52LEADZ5o35pH2j2512wrkmclstRhUAf3GisUTDzXaeIu9mwtnWm+clG/lKu195j0Li7k1gz7eVh/SY/Dbrwm3G8scU4i2sDNdf4+4l7P78lZB2Ebg7aJXP7+Me0mPKYvGGM5B36LjwsCnWn3fcfthmOH8HFy5bsEyDeLaFD5gLOcZ+OtC4irbNfuCxiHTtFR6HnQ73Li4A2Uw0E8LXG5r4+g2/4t/PLw86lNIofF2+vQ56DnuvR0daZCruoVI7GvoeCGtfhMZVQUdTEq2x3BZ8ixjFEUEHUwJZLwHc4NYwPjWXswcM4ciggyoBfzjdw/bBfMx18yfpYeUn6u1unAojE/5dGvxk1tymrTykSS6A6VWh/Yp7/u+QJk/+/vNmwffO6sFTGf9UXw4fPIBfBRhbMX5QcRmbtzQyu/coKFg77YS05O7uoOIe9otGbTX7cEb6x9TWJHnKu89/H4a1Qm1nUlwau4usaxFzJ5Nsa+BXiRtpdKuAbwYdXpdl022dTrBjbjQSwnhhq3zYL5QD2XTnY4hKd+WG/8zhuqYfs+SBCTD2P0GHUzz/danoAbFoFNK6Sol7UPw3XkSGnvkty61OyKd6e/x1T/7+4Gk7vC2whV6P7cem1ixrnV6kbYdkzNqJrypjXlWjiSoq2IIR0kFavneqDua27ClUdR/HpKiscScXu7/N0ytDz+EzLx3MqSOHhvMi39YGbolfR7tZCUzN3ZfoxgZ60GJ0Czq6LnvV3J+33VaciprOnwhp+39jrzGclbqSQX178jP/znzFPZzH5F80ihXsXzwtPY8Px1ZQsbkH0C/A6Lomm27j0tjfAGhnDpa35ZMV0tfI195/LKenbmQfYy23JX5IzI3GMK3CCxBOJvwV95beozk+dSOft/7JJ2L/i0ziPmrlHQCMbg1BF/LOiOAS466KTKt8qCx/BF75V+7jbDR+SDQmB/B3+xges0dHYssx22ufyrhe4h6RSaM3V17E3c4xjDHfor25MehwimbbDrZreNWZ8Le5Let5DFdkL2BZ3ykA2FYFzW5FpzWtYWNsU3E3Y0laqCQV0q373NRWTrIWcyzP5+/zq552SKueFKxl72iV995zIU2g0vHuPOuO5K3E/h13hn0wovciFeTtnJh+iM/F5pFsDGdLrJPpuCgZK9gOzgrxshOAlBtnhVvLa976/XhEKu4zKq7hKecgiEjFPUWCFW4tr7u5KU1GRJY0rOw+LugQSsvvpmxZD3+9GDa8HnREgQnv2WCYPfkLSDXlPo5IxX1197GcZD7HZbG/kmraEHQ4RfMHlgw313FH4nt8vOHGoEMqiba0zZWx27gy/jsyTeuCDqdo/z7gO+yXup252WkAGCFvlc/anddPzxs6kzGpW1g46LyAI+u6hxIn8OvsVFI1uTVpluW1YIc0yc3vD16wdrpn06tcFfstU7f+NcDIinNqZj7TrQdItOd+fncMpwvp6+S9v6zC5UD+MMGQDkZMrn+R+xLf4JrUtfn7nJBPlc8WFC+sWAwr5lXcQ564t3sX+/0LlHGy4ITzIlihFU5fFjkj2eDWkHLD37Sb8bop/e5KIyLbjC3tcQwAS+IHBx1KacS7wfBjcx+/+GdoXht0RIEJ/3ddGBUm6yFPNHztNlSSImHYNLW3UtEj6IiKY2c6TiaONF9hWTReJtoyNu0kqCJFur0l6HCK1p5xACM/HNEM+YWweLqRvjRS4eYqGX5LbJgruXcnP8Qr2SZ+32skAAO2LOa62G9g0ygIYbO8nyAVbjNW3foO02P/5tX2UQFGVpwLM3cwML6e15o/ChzAU8mjeKZ9MPtUhnMCe6LpLS6y5lGRHgp4J3whb5WnfSujzJW8XfDjIOzLafJb3LkGlmnlK+4xHNwQz2FxVz3LN2J/YpXbt+NOOw1mRZBhFa09Y3Nd9lyuy57LlwYdwNFBB1Sk2PqX+UbsT0wyXwHAdKKRuLc6uXOiuBP+rggA+h8EF8yDXxwDDS+FvruyGKq4ByEbvcQ9096Wr9BkIpAQ2tus3YrKRNi/t11IH2MrAJn28G/l0pbJVWUedg7lhNQN/HHYVUGHVJSTVs/lmYrPM2HNH6Gg8m6HtOoJYHtVJr/yWdO2ko/HHmZU26KAI+saZwf7g0dhOziDzkP3/lZ1Dt/MXkxTj4MCjqxrqje/wnfif+CMtn/l73t18Nkc0/4T/ln7+UBj6yr/opFdMHDP8RP3kHYR2NlcouQfU8xb424aLk6IK9Rmw0t8PvYvppjPMs+eyH3mCeG9YOSzM9Rlf89lsbtIkCGVCed7rlBs41I+H/sXLgZj23/FbwZ8O+iQSsLwdtzp7mwNOpSSWbGxlRVN3gXKiHRGdEVkEvf6+npGjx7NhAkTgg7l/RVeKTJDPhzMc9ibvyBp5L6h0hFICDf2P5rjUjfy1cznALAiMlimh9vxQzwKifvkt+YwN34jB8UbeNsdwCajZ9AhFcWfdu2vBz9s4zxui1/LoWv/FnBkXdczu4GBbMwPNQr7VHm/Qtgpcfe2ujNDfGLuJ+5+O7mfwIf1mlH+AkvBkgY7WcMq+rHV6B5gZF3nv/fcHWxxF9aKu+3FnfUSdyPWMfsiG+IZQP5Wac1UUJe5lG8ZX4REeIdXArjpZj5j/pMvx/6Gi0F7BBJ3x3uPbXW70Ug1rW40hp8dtf7PACTcaBQHAe5atJKGFu93rCru4Reqfdz9Kvsn/wxTfxh0NKVR0KKcSYW/4t5uJFnp1rLcybWJRiFxd+0sCaPj5C6bCn/ivk/zs5xmLWRw0tsWLuQnEvlk1rug1ye1khOsF+jVGs7BUwA/bv02T1R8kZpNL0LBdPmwJu7ujiruhndMhD9x91uTu7lt1NAc2jks/uuU37s9AkMEO5ZpdBxTPnEP6Rp3v+Ke9Y4jluzGrMxn+Frms9huONvkKdhpJ2vkEsGw/24CyKQ62q5vT1zN8e/8MtB4SsHxBhH7a9wzdjh/Nmyr0ewFwK+MjwUdSmm8Oo/PPf0BJpiv5W5HpFu5K7TGPQh+i0eEtjUwsh0/0LOp8K+pyWT9gSXeYJkIJO6ZVCuF77hsOvxbuVheUjEw0cbXYncweH0f4PCgw+qy/P7S1jZ7nof0pJyCIVPGNsdkhjRxz1fcC6qephXuY6IwcfcuGs3efDmjK17i2dVzYOwFAUfXBX7iXnCBZUDTC3wzdicVjQeH8ueE6w1GtI3tW+UJaat8umogH0p9j5oKi9sBK57kDvskAL5DeDsS/a3SXCsJuLjZ9txwOjO89bJ0e0v+HGKS+SovtvUJOKLiuV4CONxo4OrYr0lsGgKEoHP3fVje2vZmO5y7t2wn3UJVdkvH7b24VV6JexD8Coa/l3sEmJ0S9/BXcqvWLWJW7E+4XoXGIryJk6+9tblT4m5H4HWKObnvpV7xDJ+L/ZMtjb2BOUGH1WWG673PvOTWjUDi7iezfnJrhDzJbe53GPu0386+vSuZ79/pTyuPUMXdzbfKh/OYdlRx79O8lNNj83gupFthut7grMJW+bv6foFvLPswF9ceHcp0I2MmecHdj75W7nyocI96O8TVz/xWafEKnnbq6G9sIbv2EWKDDg06tC5Lt3e+2B/2YbAUJO69jGY+Gfsvb7XuE3RIJRGzc++/3s4GXMfBCPEFI9hBhV2t8rJHnXoNHPYpeOCb8J8rg46mJEy7I3FvM8O9jgugauOLXBL7FydaL9Duxkm74b9qmWprzn98fvrrrOk9PtB4SsFfN02yR+fbIeW3j+cr7SFfDw5geslsPnE3/fXg4Twm28lVcV2r47q36XcRhDhx92M3vKTQr1SHNXHPV9yNwiGC3msW0mPKkmCN25utZscsj8bkIJa5Q2iPhXPdvr8FZswbxGkacKz5Iieai8mmw9u953iJhhGryLdhp0PejbjtTjT+hfMwc7017s1ubtq/5Yb3Inmhaie35fTM2F2kI7B81U/UH7dHM2PIX2HsJ4KOKDCquAdh5Ady+7g/dzskqoOOpiQs7wf41zMXc2qvcUGHUzT/h/nb5nCmtl5N3+oEzwQdVJH8af+b3GoecsYx1eoddEhFi3uDV4xuPb3b4W6fMp3OFXd/rXuYK+5+q7zlV9pj4b4YYe9gf/C2/uM4PnUjtT2785cAYyvGLONS0ql2vlMzJHeHf3whnU6XXw9eUHEP+0Wj1bXHc3bqZxw9pA9/9O4zvYQ3G9LqtLF1LZ+1/oXh9AZOxjAMbo3/kJjhsK71/6BXTdAhdo1XcTfiSVJuHAzIpMK9PC2b2na3nXBfiABwvYSwzcgl7vGQX/z3FY7xSLW2kKwM54W9PO912kAPNrnVEIvOUuNdpcQ9KP769oi0e/hrjdvdhLe3dri53vG43uuUyob/mNockyedUbR4V5aj8DolvF+ysW65QSxx0rlEI6R7/75ccRivNcXp191r1wv5IDcKK7nesTTVHsmE9p+z74Be3BlwbF1RsekVfhb/CS2pIcAJABiJSla4tbhGZdDhddlTHEKjk+HbidwJnr+9JyHdkmtl3+O4KT2bg4YM5zD/zvy2feH8fspfNDI7fr6NbXmc/WLP0G/TB4HwtflaW1fyzfifeMceAFwN3tZwMRzsEE+VX7zPRXzptUMZ13s/DtzyCACZEHcQ4M3JKRSFbXJfHvxxvvHycEZXbubHznWRqbgXDlROF3RbhpaXK2WIRWLQYzHUKh8Ad8k/ePo/Xl0mIpMRX4kfzIP2Eaxy+5LKRuCbyj9h8BL3dAQS96bKYZyb/g4/yZ7F2dZDdN/4QtAhFcdxiHuzBxLVucTdxA310JIHqz/C17OfY1O/ibk7/LXuIa16sqOKe7yS9fSkkXB2G1ktaznDeorx2ec67vMuFIU0x4WC95ifE3a0mIfzvdeS7M+jziGsrhyZv8+IYOJ+SPOjXBr7G/23PPceX1m+OoY9dnRG2N6pqRPSLe4ANpu9ecUdTqqilow35HbbinXYbOk9ltNS1zI7cxFEpDq91erJK+5w1idynUaxiCTu/zWPzn+cbotAq7x3Tn6K+Qyf2XITvHpv0BEFRhX3IPzlAib6Jw4Rqbj/sdv/8cHNP+HmxI9Z/noKDp8ddEhF8dunEpbBLfHrSBhZ3MyJGPHwVtTavKuUH7Ye56LYfSxsSAMfCjqsrjNNjk3+lfWNW7mq56CO+7PtoW2j8k/MY1buxHzZ8E9y7vNjOf2AgYR1IsHf3Mkk7DaOr8hdXPGTjrBuycUOtoNLtjUwK/YnjEw1cFKAwXXdGe7DZKwMZvpwoBq8irsb0qsR/vvLLOy+ye9oEM5jGrBmPn9L/JSGLUcA3sU9bytCQrqcxvEutNoFE+T9reHsEF+E9TvaknGLjLclXJjX7AO0UcGr7jAsx6HNTZAi/LN//O3f4okktEOc8L7nCv3cOJdT3fkMNDZtN5sglKr78Zq1PyPt1zk9fT+sGgMHnR50VIFQ4r6nOXanq/1uNkU4m3o7S2VtKkjR22jmrdTWoMMpmuEl7m6sgpOtxeC1ucVDnLj77UXt/i/bbLiv/gO0Zl1SJKiuKqjehriLxcq20I12LMMf6GYCRmjXrwJcbZ9HOuvwWPd+AHRrXcUVsduw2nrkW83DxLG3H3oWb9/EJbF/sd7uFWBkxfkmt1Adb2NV+3RgIK9UjOXNlgQ9KgftxFeXnx6Nr/JJaz4D28bkt37LD3sM6RDBRNsGDjdf59nMgPx9rj8t2g5nF4Frb783vZ/EO9lwXowA2G/NPdRZS6jKTMM2E+CAHfItWP0lg0sYwajUrQzqUcHjQQdVpCEN/2OG9RSWsS8AsQjsIIT3WrW5CTAgG4XE/YjzueR/Izh3y6/4bGxeZIqeXVF2rfJLly5l3Lhx+T+VlZXcfffdQYdVOtu82dwQJxmF0ukMKX+zsQgkhH5bjhvvmJCfDnmbW48372VR8nPUxf4JgJEN99V/Ci5G9OyW5PTU1Zxu3wCV4U2eZm/8FksqLmTQ2v9BwaTl0FanAWebYW6J1EYuiD3AKdn/BRxZ17iuX3HvSDRMyxt6FtKEkMJZBF47+f09zuXSzAzW9wlnr8egjU9wdfw3HNl0f/6+zQOPYUrqOm6q+WqgsXWZ18brmh3vPdfwl9OEM3HfUau8/71lhzhxH9VwD1+L/5kh6eUsiR3Eg/YRtCb7BR1WUZINi/mi9Tc+nHwWgPYILCHcd8N/+Wr8Lwwx1nN0+02czs+CDqkkumU2YXk/07NRmCrvne9l/N+7Ie7GKVbZVdwPPPBAFi/OVTibm5sZMWIEp5xyStBhlc42iXpot9rZxh+3Xkjf2ObcjUz4E8JHB13ArLeP4JQBozh+/R9JGlkyId/KhfZG+hgd3RBWyC+wuE1ruN69gcZYFT27HcsSdwRmNndSG9Yulvx2cFauK6J283P8PP4zUpsPglDu0gw9nC1ksbAML4G3wt2ujJdoFFbco5C4d/C35fL3cQ/nRaMd7ePuJGp43R1C94Lt1MLEr05TcEyh33nCOwHf8Rr38J6c+3ucG/Ekd1SdxytNTdzWdyKjgg6sCFXrn+Ur8bv4r3UMd3M4qQgMCTP9Ylq8ktX0pdK23u9Lyp6bTfNE7HMA/N0+hiGJcF8w8rVnnY6tmffiinvZJe6F/vnPf3LyySdTVVUVdCilU/Bm26f9dh69dAqDAw2oNBJ0HFcUKrmbzV686g7jxKoBpImTJIudDnd3hJPpnKj7JxZhlWnewAetp9jg1tBWmfth7ri5NWuJWDhTd9Mb5ObvC16VauBE62leag/nCaxjOyyq+DwAW1LHAZX5ixL+0LqwcfyKe6fEPfd65Y8phDsb+BcdcsszcscSJ5tf0x8GG1a/Bb86kXeqDoZ+h+TuLHid/PkKTlg7WPLvvcKKu/dxSBP3HVXcfxP/BG2tzZxdWRtgZMWxnNzPbDNeSUU89x4Me6LrekWZuGVyS/w6KshAdjLEkkGH1mWGNxnfiud228nY4b/4mm5vwX9FZmUu5ifd9gs4ohJ48Nv8M3sHxLyf3Xtx4r7LrfILFixg2rRpDBo0CMMwdtjGXl9fz4gRI6ioqGDSpEk8/fTTXQruz3/+M+ecc06XvrZseW+2lBvDxaQtHe4f5L5kQeKOHf7E3f/hnYiZZLzrW+mQD5Zx0523cjFD/jql23MXIlLE6dktznnWg1wW+wvpjW8HHVqXmfmKe6zT32ZIJ91mC6ZCG7Fcwu7v426FtDrt2ttXcvOJu+vw3L03035VPxb+4crAYuyK/GUGL9H9/LqrWFbxaUas+FuQYe2S1+/5MX3ZzLiWR6luyLXzFraVV7Ws4LLYXZy79baOoXuuS3b9G2x9axHt7W3l3WGww4q7V38Jaav8xj5H8In0t7it5pL8fQ8kTuF39qmkkn0Cja0YlpO7MG4lKkjGopK4537nOrFunGQt5mjz5e22iAsb00vcY/E434rdzrfN3+K0h3v7tJQ3Rd5xDVLEI7HTk9vcwBBjfX4nISciy4y7Ypcr7i0tLYwdO5YLL7yQs846a7vP33nnncycOZO5c+cyadIk5syZw6mnnsrSpUvp378/AOPGjSO7g7VLDz74IIMG5QbhNDU18fjjj3PHHXe8ZzypVIpUquMFbGpq2tVD2rO8N1vaGxAWicTddUkWTOK0Ql7JBRi14UG+aL3MoLaPkPHWEGZDvgTA/6W7xa2ip9FCLOSvU6Y9d8KQchNUJ2Ocbz3AfuYatmw6H2rDt58xgOWdfPuJoJmfgh3OnxOFra4xP7k1t6lOB6ixNcODS9by4XGDScR2cB27ZSPOmhcxaw+C7rmBYO8MOpVPP9aXowf34dfew/yhZ1VGO4c9nVs/PWHZjTSs+D9qhx2w5w6oCP7ANtNL3F3/un45J7IF2lu3ctDqjosMh7Q9lfugIMnt3raaL8f+BilY/93/sLFyBAPa36Cn20h34Mj2n7LO6MOlU0bypZPL8HXz2/8LLkY8P+Cj/PCt/Tmx/xgmBRhaV7XGe/GEczBGRUeS7ndGZMPaGQFYXkJoxis5f+vN/D55N8uWfBbGXRt0aF3ndVPaie44LQam4ZJqayFeFd65MobXGWElunFxLLfFWHvbVioqwrld6f+zd5bhUZxdGL5H1uLuCSQESXB3dyhSaGkpUCilpYUqdXd3of611FsoVLFS3N3dk0CIe7I68/2Y3U1S3Fm693VxkezuzLyzm515n/ec8xwAq7OmXRRUwinCXl4EHp7bq9i16vZS1USkUIhit155Jm2XiLMW7n379qVv374nff7tt9/mtttu45ZbbgHgk08+YebMmXz55Zc8+uijAO4a9lPx+++/06tXL4xG4ylf98orr/Dcc8+d7WlcPnzDWNnweWZtOMBk3bvEzf0SxvwM0hVdtXBKFGuF+wu0X4kmR4o6zRZXPo0K/ma4biWLy1OxocOmStitHp6a4xTua8VG/GZpSVhoAh70zTkOq3Ol3yroEAQBm6Athtk82ETQlSp/fMT98ovcc8Fur7Kg54y0V0bcL/45ORSVrGIzoUYFg/H4kqsnftvKrC1HKE7fxq3XVt7XivevJWf+e8QfnYPeuSiZI4aTY6iBINemnAHY5UrjSleNu0WVecR2O+/qPwIg/ZdHiZw0/aKf54XAFXEXXS7l7lR/z8iMmLPxIOX2VnSRthAj5FY+USVVPqlJZ3aubEFy2UbChXzCK/LB+bkV4kc2wSgqfLPyEHd1TUYUr6xyB5sgU6T6YBMru5uUm6LZrJbRRPbMtHKHM/Oham/6OuohQoVchIq6gGdG3WVVWxiX9UYcIugEB4rNsxfLXYEnQWfCgg4TVqxmz464u0oadHojFlXGINixe/jnZKuo/EzWGiew/sA90O6Fyzqm80WxmZGAnx1d+Mvallk9+uKZTiXnzwVVi1arlfXr1/PYY5U9vEVRpEePHqxcufKs9jV16lRuv/32077uscceY9KkSe7fi4uLiY+PP8uRX0KMgWyPGMB0x0Ze0E2BdMBh8WjhbjGX45pG9LK+Tp/QOLpf5jGdL6LzYo5s4Ab9RxwptvJ7aOPLPazzQnCa0WXp4plZ0YYmHmrQ5MJlFujqkev+34Nb7lRG3LVFCLdwvwKi0+eCo0qKnuRMlZec53ahzekcisq2XbtQdvxBSNrf6MuPIdrKCKScQ2oEt/t/QNe6ETzeLwW9LJJdYmbrtq0s0L9E8OYyzL12YvQNYN/2tdSY2ptagjb2TDWECAoIV3IIr8ghz2EGBmDSVUY9Bb9IeltexYFIcI2G7GjZl3p/DKRF8T/sXLeAes27kp5fgUkvEe5/ZdaD3m2/G0FVec4YqD3gEu5XmIlgudVO2pGjKHn7EcpySWzeA4NvEJ+sLWSXfRyP9ahN6+W30cSmBQiqljSY/INIeXg+5vIStq1fRFHGbowxqUSntCEyOJD1VgcDX51By/KNHNgbRXLdhmc0JrtDIb/MitWhgLWcGCEfMaTGBa/9XRszklE7WzMqvgbtnY95enTaVLiPkdI8gi21wZkz8GDFu9QyHGRrbhKQfLmHeE7onHMI2WDELjkDUB7u/+OaQ6AzYkavCXePT5V3CXeD28/I5uFlkfZ/fyY2z/6MABSbFjjLJ4CjhFEh+3uF+4UgNzcXh8NBZGT1ld/IyEh27dp1xvspKipizZo1TJ9++kiFwWDAYDAwefJkJk+ejMMDepla7ArWqm+93QJ6zzXgs5rLMAF2VcSBhMV2ZU30zgXXxVyU9eh0MuCclHkw+VIYW5REyozRUFzZSs1Tcd2cbILB+b8eVM/ulbtCbI7JmkuSKQSqCHhPjbhXTZV3CXbVP4pOlneQJJkL1RBOVVXmvjOOPsXTEYUqAsapPaPI43BeOVNWHCIu2MS4jkn8vmon6UoIAiqBlLJxzmc0GfIATy63U2x9gQl+i3A0HkGTNj3YXVpM2cG1mHMPc9Tmy/W6OEa1reE+TFigH1JUA4yyyOc3tyDIR8+6pb1pUTiH0Jnj6LrgCw7lVyAI8EXgFMKi4ki57mn0flqKaU5+ARs/GkNpYB363v4KJsOlX8id42gFwAt6VyaBS7hfekGoqirLfv+CiC2fkN/4dtoO0hyS048cpfCLgTRU97pfW7TQj6Wxozl0rAVGnYkbWtVkm+0+flo8hTVKPVLC29PmX/s3+vjTtOMAYED1x3USH/h+SRPzatasNYBTuOdsnguohDfuc9xYs+e+xUvrRH4vqQNAO3EbP+hfRkWgIiAJsflIjC3HgE/Ieb8vJ4pOx5Tt4HZpDtGFTYEzW2i4kgjNW8+Luq/YUNoemAhVjOoUh2d6ewA8HfgC6Vl53BWQAJKzVa6Hl6e5jYdlI1bXQrnZc++3AF+GPsjOg2mMCmvubjVm93Aj4uN8B64C4e5qne1ylb8adMa5ckWGeQMDA8nKyjqrbSZOnMjEiRMpLi4mMDDwoo3tvCnLIyprCQ2FYhRVqxHydHdEi0PgH0fTyt+vAiMMV32aIBvcta9WD+9ZOjf4Jn491JnBIb70y51PuNkIdLrcwzpn7E6Bbhe1CYTdKdztHty27235VjLLzPwZrLnAih6fKl95bXOlk8s6A2lqJLJy4dKQZ208jE/hXkRJZa8uhT3hPZBjm1I7PpqEqHCsYggPbyvgqzmr8Zn/OMXR9zF4+XBSdNGs9elIDfN0InZ8yeL6I1l1IB+9lESTCbcQF+wUsWF+UHOQ+3j/tkyVRIGZ93QAQHBGqhOHvUb5pwvJUvxJzy9FJ8lIDjNdKuYhHVLZ9uleGjzwFwBbf3+HXvZFkLeI2e9n0fHuL/Az6i/Y+3M6qhqyudvAuWrdL3HEPTMnj51T7qJbmVZvWrHhSfbUbUNynUbs+e4+ujtFe64QjF2ViCKXnkcm00+8A2OzkQT56GnVdRD3r/Enp8TCeL+kszp+eUIX2LMav/TFABQf3UPwrzcioFIUtobA2Dru16Yv/5n4lc/zliqyQ3yVNDGBUMooVY34CWZ8ivfDwucwL3yFrbXG03LUi+5ti5d9hj1jAyFD3wXdqUsCXbjWjqsK97iiDQzT/ci6wnxg/Fmd65WAqrjaKx7fx131YOG+U01ktxqG3uSH1ZV54eGGWn9HjOW5zDb0j2xJcto0qFKy5qkcluJZr5oY6ROM3ek95enCvUIOYrqjI0OlpXCVdHpSnHOJRCGTJ+TvMG3YA73uv9zDuixcUOEeFhaGJEnHie6srCyiojy/7vmCkLmJobvuJ0VXAyuys52GZ18kyvWhjLM9RBNhH0v191J8LApYdrmHdV5IamXEfYz1R0J1ezFlPgjJJ/d3uNJxGSEm6IqYpH+fAnMA8MTlHtY5kxF3DYPMwdSL8me6S8Ar4LB5bgTAle7qmpiXRrWmrnkKNcMDmHuZx3YuKIKB6Y6OiMC1zsdc5+Y4WSS3MJ3yPx4E33B8hn542mNY7A5emXeADNvDvNxc5abBA/i3rVg4ML5TCMnLH6KXbQH5P6winAIEyUHSmF8o/ng2sY4jTJ32KtCT0e1qVIr2M0T4V/u30JiabO/wBsqOv/iwa3M61o2kpKSIFX8/Srvdr9KgZCkZ21cQWKMhDQ9/7d6ub9nvzHu3gmYTviY04OzGcK4oispAcQUqINg7AfoqEfdLJ9znbj/Gl9Nm8L06BwWBHCmcSCWbimkT+LTDFH4v7EqYfj9R179JZIOuWKxWlv/5CYlbP+AZ3bcUNB4Lzm4gd3dL5unft1M/5uwW8iOa9Yc9r5Fs3oq1rIjDs96mobPO//Dsd2k0TvMv2LtlFbHz7gZglukafnlkLIE+Oiz2XizdPYElm3ZgPDiPwdaZpIqHabn/A3avbEfdtv0oO7gGv38eRkQlbVEjEnpOOKOxNT72C9/pZlGcOxBIBUBw9XH30MU9lzhXxcrpqCviriqe2QYTwOwMYBhkkTKncBc8PEhzTIxig2qnl180NkGPVZE8XuRanAEZvSRVMSL27HMq8kvkAdud7FbieFz3I6Ldc+dELiy+0WQq0QQKZYyV51C2N/M/K9wvqCmfXq+nefPmzJ8/3/2YoijMnz+ftm3bXshDHcfkyZNJTU2lZcuWF/U4543zwm1FdjvLe3zE3XnhE1GIF3MIceRc7iGdNy7hLumM1LfvpLe0Drk043IP67yocKbGm3y0sgwDnn1zMjsEyjCBwR8Ah6hNjhQPnkgIDhsCCrKkiSZZlrGgx6pKp932SsSm9+cB2508qk50PyYpFh6Rf+Qx6XsUe/WJ+baMAjIn98XnwBx8tn6LJffQaY/x7crDZBRUEOFvZHC/ky+sSaJAQK/HsKsiIUoBADuihxATFcO60IEA3O/4iruNs5jQ5cLU1dbvOZrG906jb6NY/Awy0WGhdLzpUdb4aS4ghbOe56f1WTxlHcMqqQVpHV7DgUBP89+kvd2FGQtX47gEtcuq4uB9/Yd8oP8QyTnJSzfWZa6jBcXGuIt+fJtD4cW/djD+2/WsNtfgC/87OTboBwy3zqIcI40d2zj6z4fsUhPY2mc6kQ26AmDQ62k/9B4intyJ7pG91Eyq697nzW1rsvnpXgxsHHNWY0mq04h0otALDg6vmEqtjF8rn8v4FUdFMRZzGYZfx+KDhU26JnS++zMCfbT7uUGW6FE/iudHdOPxJ18h+uG1rAjS/r4qFryKw26ncOpERLTPVVz7+RmXIwRXpNFB2k6w9aj7MZfg9VTh7nbKrxpx9/RUebuFYeZfuEWajVFSQdYyKkQPD9K4FiOMssid/u9Tx/IteWGtLvewzovuJX9wqzQLX1u+O+Lu8PAOQq408gpnN3fJ4fnCfW+Hd+lufYvFitNrysN10/lw1sK9tLSUTZs2uZ3hDx48yKZNm0hLSwNg0qRJfP7553z99dfs3LmTO++8k7KyMrfL/MVi4sSJ7Nixg7Vr117U45w3zgu3BR0WV8KDp1/MnYLQjJbaqVc9/wtVNeKuiK6LuWef111ZT7NEfy91rNsBMKhWj2n1dCJcJRlGnXYZm+p/MwMsL5Iec3wdqqcwX7mFg8aRGIsPQDXjKc8s03ANW66S2ivh4E75T26XZ2K3WSjfs4hZi5cz/LNVXPPhCh4tu8n92ozNC065/5LDmwme/yCBlPJArzr46E+dRNa6RUuW+vYCpydHQi9tQSG8x93u16TWb0Kw78VNUw/r/yQOVaBB2UoWLfqbOUor0vpMIaHHHRzr9QnlmIhSc3hmbhpDPl5BQdnFvfYoVf6+VOdntTjsRsbbJnE4rPNFPrbKvA8msGT5EgDGdUjk1vtfJKZZP4Jia3O0xcMA9BPX0L5WCCPa1DhuH7Is4+NzvE+MS0yfDaIocDBIq4q3rf6So0oI+4nlENH4Uc7e+V+x7fvHSVCPkEsQSXdOI9DXdNL9BfsZqDvyLT7jWkaU3MOf/3ue2Io9FKs+lKsG4qwHyN61/IzGJjjTyqnSDk7weOGu3WurCnfXzx6bKm8tY6LjO57RfYtRJ1HhE8NSRwOOGGtd7pGdF03z53CrNIsQ21H0Ou27Zfbw0shhZT/wlO47fG15PKR/kk6WdygO9jyviKpYLRUYsWBxLkSIV0GqvEtnuP3B/sPC/axT5detW0fXrl3dv7sc3UePHs2UKVO44YYbyMnJ4emnn+bYsWM0adKEOXPmHGdY95/F+cdmUyWsgivi7tnCXX94EbsM4yh1esvrVc8+H4CXfB/nWE4uk8JSEJzCXfXw9KlgezYJYg4ZzhaLkqCi2i0IZ1hfeaURengOr8u/U2DuALShwFSDraovJZLneo1KqgJCpZGbqTyTt3Qfo5r9gG6Xe3hnjd1hx4QZg1jpri3LlWKq5NO+hBZuYZ99MCvtwxAECGrUl1npe+hX9ivle5dC97En3rmikP/zBIayDX9/6N582GnHIwgCMdc+z87vdnEouB19E7Wk+gYp9fkm7nnU0myGDby4i8wAtVObsiqgF21K5jLO/hN7/Z9mUFMtMhzb7kbs9dqycdVGWGNic3ohY79eyw/j2mDSX5zMC7VKyzdXH3d3M7iLvLj3508fM6jwR5L1Szlw3d/0aVi933Byv/tZUCbzSV4z3rm+yXElCRcDoXYPWPsb/tYcOlnfYVKbAKJKd/Dajkz89vnxSsE3IMC+Vi/QJiTitPsLDYtA6vEM5X9tI+nIHyDC/LgJ5JTZmZcVQJP9wTyRcgYDc4nzKmnl7taRimcKKNXdm77ynBzOuZHHCnenULKqEga9nmMRHbnXFs6QkFh6XO6xnQfdimaQpNvLCnN7jLqaAJg93CRMVyW7MkcfS5pa5jbe81SiDvzCLuPzZKtBTLN3QjU2oP7lHtR54hLuNlf2ocNzy2jOl7MW7l26dKlmZHMi7rrrLu66667zGddZ4zGu8u5UeR3dLW8yql0yT8R49uqeYi3HKNgoUrWIhw7P/0LtJYG9agiiMQDFaX6mevoCi3NBRe9X2RfXYi7H6KHCPbBgKx3kxcy3h4OzlhA82y1fdrZ9E53iVmcvYai0lDzFsxYjPlywl7T8cu6ob2encSxF+AJaeq9UpfVlaOEWKlQ9fj6+PNS2LoOaxBAX7MOi3zvBxl8Jzl3nfq2iqDhUFZ2kfc57Zn9AnfJtlKpGQgc8X82w61TUrV2X8ifWU0euErUUBG4ed+8FfAdOT9TAp+D7uRiwcXvrCAxVxiOH1KBfvxokNy/huo9XEJcxixUffErne79Eli+8p6xaJeLu6l3uEsgXU7b/vXwNXXe/oK0S1O5znGh3DohuN9x7SZetarXsi3WNRLyYQ6yQx+BO3VHUFjy8fRGP5P6ILCssM3Sifd9RZ7zPm9vW4Mc1aVyf/Qy3+K5gwsiHWXuokJe/XseutRnc2ymGwsUfoe6dR7lfDWzRLdBF1sEgiag12pEQ4lMZVa8SncZZlys4rx0Wu6Pa39IVj6vGXaj8u17h34vZJbVo6l/vMg7s3FFtZgTAgh6DTsTobB1p8XCDW51zDiHpTAypmM7tuo34ZNwGDYdf7qGdM7JzvirpjegkLaXc042IFatmGLhCSeUh+x108Qvn9MvaVzbNFoxgrv4Yn9qvAUBQvBF3j8djXOVdLQ3QYcZAqV2o7JfrodidPS9L8COSQow4U7A9+LxsTvtegyxid0Xc7Z59oXAJd5+AEByqgCSoWCvKMPqff5uiy4IzqqHKWqZHffsOkqWVhGQVAwmXeXDnhuScfEvO9kHu3uce1Mc9f+9KxAUfscvRko2+9UgCHFQKCUnWkaMGEi4UMd3RgfSmD3H34M7VhHdCk26wEeLsaViKczAEhPPEb1uZti6Du1oHc3NtM9FrXwVgafwd9G3U4KzGeLqU+ktBzdoNWVr7EeTMDdzY+vj0b4A6kf58e30sKVM/Rl/iYO3b1xJz02Ri4y7s37dSJVoriNrCyPWZb/CqYRZrD08EXrhgx1q7ZTt7Ny+noCCXjnm/ECCUc8S3PnWGv3rBjnG+xESE8bDpKeYXRtI0pQ7xIZpJYOc64by6+0a2qYlMHHnLWUX/dZLIW9c35qVZO+nS81ECTAa61o0gKcwXfd5OKt6+gzjytRcXb4SjvwFQoepJsUwhKdyXx121t1VT5Z3dGqxWK9d+tJzco4f4oE8wTTr0u4DvyMVjZ1gvPt0XQPPwBu62fRv8uzHPUZ+X/f5tM+kZ2Kzl6J1pvUad5F5U9vSOO7JTLEkGE8n2fbSU1rOupOflHtZ5oUNbOJJ1BvraFzBYPoA+1xeSu1zuoZ07zuuEWdXmEZ4czHDhV3KAMDEfh7PCW/BG3L1cMqqY03GVfKEUZ1uuMtGvMjxjN4Pu5HV/VzpDzb9SKNkxOBphdUXcPdyLwOAU7gYff8zo8cWC1Vx2uYd1zqiuSazTsbeBeR29dD+y7ZgCeGAEQFGQnD3IRWdU1VW/KnqQcM9a8SMT5D+oLRzh8O72AChV7FRkSWSM/DrmijLGDOzBfSeoWU5MqMEhYvBRy8nZvZ3ApGb8vDYdQXXQYt0DhGzUfBp2icl0Hvn4JTy7C0vHEacfe+P6Ddja+hVSVj9Ky/IlFHzejll1HqTnDXeju0CR1WoRd2eqvIiCTnBc0NrpzIISoqYPpqWQrT0gQLnoS9StP4B09vXoF5P6na5l4cJ93NO90qhwYtdklu/LJbb9TaQkn12bOYDG8UFMHV9p1CuKAre1Dsc89yN81TIOEM36iKEE2POJLt1KkD0XM3r0ssiBnDKKdBUgVabHA+RGtGe49QnyLf7IZRuZqX8Jxz8y5fXX4hN85XfzyTPEs1CxUMO3pvsxlyeGw0O9PayWCvROLyM/WSSmeCNbDHeQmxELrDuDPVyZuPyLZL0PZkm776oe3MUFxYHkLBOS9Ua62JbQVN7A1oKOgOcLd1UyYLKbkS1Fl3tE543o9MIox2n06I24ez4ekypfswMfm8azuiiQCdJvdEnPhYwnIK7F5R7ZOaM4L9wVcgD7LDFY0JHqsCJ4sHC/w/E9Op2dfcq9FDmjn55uImhQLSCAwejLc+ptmG3woM6zUrCrIjhcwl27kKvOiYSnekYoDrtb3rrqwF0Rd/lKM57K3gkHFqNIemyiAX1yZ4RAzX08KF3rKtJTWg+F6+FfEXdBEPhk4kBsDoWkcL8T7l4QBD6q9TFTt5cyqTiWrj/ewY+6/fzlNwz/CgVUcKgCjv7v4mM0nHAfVxMN+43nYGwK4p/3UMN+kH57n2Hu9+X0Hn1hFi2qmtMhuP4KL3w7uC9XpPOz5UUm+0+hToADfUAYQd3uQwipeQZbX1pGt6vJ6HbVx9WyZgg7n+9zxmUZZ8K1resyd28z5hk706bfGK4POt5kb22Fjbf/3s2+tU6Hf1NllpQcFM1KRatgHdIojOy94SSrh9n57QRS7plxRmNQFNVdInGpcbXArGpgGebIooFwAF1FBHDl/W2cDptZmxNZVB16SUQnyQQI5ZQpnrtQDqBzCXeDCcUt3D3zfgvVDc5kvQFFuDr8jHB2BkmSstlpHEt+fhBw+HKP6rxwCfV9aiw9LK9zW7sUbrjcg7pMXDXC3WNS5aMaMk3qxwGljNt1f9GqdAcUjPBo4e6KfDpkX3qUvAnAHtkfj7X3UBR3+pSkN/J33N3ccnQwd8alcIU3GzwpqqJoJQyAwceP+bou5FmtTBAuTZ/oi4GrtY7gFO6uyLvgoQ6qdrvN/Z1xRdxFZ2RN4gqKPFnLKP2sL372AkTAAOTI0YQ9sonynENE2zNQVAFRqKyOdgjVI8Ou1ONT0ah2IlO3b2PtrkPcnjsPo2hFbZ1KcsuFLP/tbYyhNWnevONFOcUrkcTGnVDrr2Hn9w+ScvBrWh74iIzMscRFn39UVZUN3G+9ExGVV5zfI9Ul4C+QOV1RhY0fVqdRhh/2oV8TWe/0pm5XIrJ0QbvoYtTLDBr76ClfE2jS8dygBuxJuZf5mxrSqvdo93Od64TzZP8UGscH0bJmCGuWv4vt7+tIyZ9P5j+TiW7cE/Q+4B8D4vFjX7grm3t+3MjIVIn7rmmBwTeIisJsDk57Airy2Bh3M5aIxgxtHkeg6cJnRUQWb2WouI5os93dm35Q3v94wfAPqzIfAA+869osmnCyCXoEQUA2aN8pWfXs9F69cw6hM/igSs77ridH3KsEY3R6o7uDkOLhZZGuOVCFHADWymxLj0VVkZzCvVQ1kkMwubqza/N5NXHVCHdPorKtwdXRx92dKiVXmpxZ7A708oWd4FwylMqbq05nQNKZsKLDegn6KV8sbDYr+9QEDKqVMJOf2yzHkx1h3RF3p7meS8ALHhpxdygq8xzNkXDQRndxa9xL1/6AbfM0god9BAHRpxiUHaX4KIJvGIJeE9uH57xHDXsB2WoQm5RatBR3E27PZO+sd7HZVVKBjXJDVNlEC8tqANSz7zxKmyTNRDHu6GyMOisHiaNF+17IskT7m54411P3aARZT70Rb3Lk1QXE2tOZ+duXjLrz/KPuqqDnV0VbBHnNWTPt9ii5QML9l+XbKbPaqRsZQJe64Rdkn/816tRJpU6d1GqPGXUS4zpWpu23at+Nv9aN4JqCb4he9jgs0/4+ZrT8gRy/egT76hnaLA5JFFAUlZdm7STIeoQRO15i375I8ts8SvKySaSqOQA8l9mO1aqOtPxynh144b2pU3PncIv+F1YUWIBBUMWoTlU801W+NDiVuy1PYTAa+AaQ9Vr2oc6TW+WqqnvxX2/0qVwo99D7LQB6X0bYn0JQ7Lyh1+Nw+xl58DlVmRtZ9EGacMfi2b5TigPBWYfr0k1XQ5nxueIV7peavP2kWLcCwZX9CD38IlGoi2CVkkKBb02EXO36YLYp+HumWXn1VViD0b0A4clOo2ZVop/1FQD2+AXRTNhNA/EYjqIkiPfMdHnJOWEQnZMiV1s7wUMXwuySgdtsDwCw23lOrsi7LCgX9Mb7xYp0xuSvJvO78URP+KP6k4qC5Z8XsW/6GWP5USQUMqR4gu+ajykwgp/2CtygRLI24Va63XgfK355h/6HXsGx+Rckg5b6nh/bTVsc2q8J939H3M+EWuG+vGH6muvVuQBkJA4l0ZPcsi8SgqzH3vctbpy+lVWHU0g5lE+LmudnMFm15Vul4dqFS5W32B00W34Hv+mt5DZ+/ZK0dPsv02LUSyx4fxf11T0YsKEi8NBSBw52AZBXVMqd3VNYvWweJdlZ1DBYCBTKiLNth6WaU34GUeyKHUpNY3NWby9n5tZMnrom9YKWCVC1/7xYGc1XXeZ7Hircy6UAVqspRDnvSbLe+b8nR9xVlRGOZxAdFl72DUF1LZR7aIYbgCLILLdrfRj1suSOuHu6cE831uGoI5ts33pQ+jsyitY+TfbQPNgqi0MCKvfLv9DyoB843r7ivFEuBVeNcPeYGvc1n/E/9RM+lAddNRH3LSF9+MCazM3RNfgu8w5i1WyUzO/B3/NS3AAcdqu7IlevN1K3aDnv6KYjHWvrTuXzNMxWp1u5KKCTBCZYvyJFv5ttWXWgwZk0EL7y+CjyGVbsTGdSdHOoItxFD40AOKpkdMjOlFbJN4ym5k9wILJJURGls5s0m20Ohn68AoDpd7bDqJPYfrSIucf8uVtfTlD2Yiz7lmBI7uQew9R1Gfiu3MBANcO9nzhHOvs+Hsi27t/xcU4jvte/w4JhXQj1M9Bx2H0880Yxf5Y3ZLVjIggQ1WIwJtEG+98CYKvc8Kx9/gVBoL1uD84gD/V6jTvLPVy91Gjem8TD0axak86zf27n+3FtziuNWbVb6CGuRwVE+mqi3dXP/QII93nzZnONuhObKKM29czrjScRFRKA4aGZrD6Yz/6cUg7llDBQFSgx25F3/8ngJXdxKOonYhdPYqnhKH+mvEVpg6lIvwzDhwr2B7Yl6pbv6BEURie7wuYXf6Rb+WJ2rBVp2LobFVYHL8/aSfMawQxueoIWfmeB4BLnVZzy3T3dr/T53ElwuccbdNp3SG/QspVcqeaeiCoILLfVBcBoNLozLN2Zbx6IrYq3h04WUd1GxB68wAIsCbqWqftaMjI8GrJe0x60lXuucFcc5OljMVvMOASJe+UZkAnYX/EKd0/GU2rcVbsFAbCqOizC1RFxd/UmNeokYoVcagpZZJQXX+5hnTM2SwUSYFMldDqZcGsaHaTlbCg53jTIU6hwphUZZRFBELCLRnCAw+K59WkFDhM5BKMz+QMg6rTUPclD3UbtVYS7K6glSRIFBADggLNOON8x4zV8M/WsUVP4buVBxnVK5tuVh9mp1uAHR3dGyf9Q8uskDJNWsi8jk3t+O8yOzGKM3MymwKZENexOcoCdZvNvItm6i0N/3Y7E/dzWOYWwAO37EOBjJLn3eOJ//40ifCnBn9QGTRBRySOIUApZrO9E/3N4T7LqjyVm41Ps9m1O3WjPbPF3sZjUsy5/bc5Ef3Qdi958j5gb36dl7XOr+1MtxXyh1xZZEJ4CINdYgyWOhpQZz0+Y/TFnDg1XPgAiHIrqTe3g89uflzMj2FdPnwbV/Q9URWHjm08TXZ5P3rTrCaWIEkx07TmAkNAw7OGLKDuyjVpNrnULab0s8lzwLFoX/MW61WXQuhtfLj/I1FV7abb+C3brnqNug+M9ehzWCiSd8bRZQpXCvcp0VPDsiLuYvZNR0t/Y1SSgKzqDlkGlx+6xKctVe9AbdCK7ao7kll0tuSYygeaXdWTnjq0kj1HS35SqJvRSH3fE3VMNbl24Pit/XxN2VUQWFFRbOYLJM7MrMQbwUvIPzNhwhCBjlVmQhwc9zxUPLUL2XBxOIzcbMlb16rhIuGpNDLKIy17Lbi2/zKM6d2xOR1EbMnpJRHC6ynty+wlH9i4W6CfxlaT1Y7Y7HWEVm+d+Tq6/O6MzqlEQ1pLh1if4LuSuyzyyc0MtymCPYRRbDOPcqcRVnZYdZ+mx4Mg/TKOdbzLV8AIvy1/Qa0E/crYvpOXmp2gm7OFgw/soVH0JK9tL2ZuNyP/yBnZkFhFglHlkQFMee/gpbr+mA906deFAj/8BYEEm0V+pVlMLMLxlPGXhTWhl+Yif6r6HJAoIokhaoDahb+bYck7vSZMBE9nb7TNq3DH9nLa/mgn3N/DD2CZ8bPyQQY55+Hzbh1lLV5/TvtRqrvLa39zaiOu52fYY28LPZckFVFVl1pcv0nvlSBLFYxTJ4SQOvXD94L2cPYIokjDyY4rxJRStRdTWqCGEhIYBIEfWw7fZddWi3wDGZlp7zbr5C8grLOKTxft5RP6Ja6VlREwfgiVjc7XXb928FstLNVj/wYjTD8qZKi9UEe7uiLuHCnefzFW8oJvCNXatzEdn8GWDkswaNVVLWfZALKUFjJbmMlRcglGW0BuM2JCxODy3hNBRkMYLuik8qvsRnSSyPHIEfS2vsCl62OUe2nlhs9oAlUAfPRVocz1rhWd3NLA4/ZgCfIw4VOe8yCvcvVwKFFtlH/fKGnfP/uO75tDLrDeMp1nu71hF7SJhN3uuILQYwrjB8hS32h5EJwkIzvQiQfHMGy6ArayQJPEYcWiGQw5RS3Pz5Ij79YVf8oz8NcHWYwAIfuGsVOqzX/Sw9kGqCg4bDrsNveBArmJEJ6Hwovw/XpY/x24uPW5TpSyfv9+8mTFvTSWzqPpnmTHzVWQcrKYB9Qy5JJCFYdpIhoqLeMp3Bk9c34HvfbR6Vt+Ko9RnP9cmVLDgwS7c0j4RXRX37GYd+7KqzUfUkbN4ua2ASV99Yi9LIu/d2IQBTeIY2bu9+3F7k5t5xHYbKwKvOae3RhAlane6AaN/8Dltf7XTsEYkATd+RokURH3xMKGLz9Gozlnj7p4QXQBvuk3LZtIv7Q0Mgo2DoZ0IuH81cnitc9uZlwtGWEwN9jXTzB1tqkStAQ+cdpvUtn3IJBR/ypky5RNKzHb+ChrJTpIIVotQvuoPaavA2T3g/lnZFOBH8/yZZO7bfMp9i6eIuAseWhOuuDrtOOdDBl9/hlif50brk6gemtprL8jgOd3XPK77Hp0kYJQ93+DW7gzSWNEhiQLlpmh2qjUoEj00Mu3koYwJ7DeMpF7pamY5WjPd0QEznvl358IVqAk06bC5tNN/VLhfNanynoLivFBY0PG6/UbedlzPpk6D8bzEqUoMthJChRL0goJN0G5UDk+OuIsGVqsp6EQBQRAQnO6pnhxxt5m11VaroC1CONw9WD33c+pq/ocwOZ9NykQADM6JhMXTJhJTR8Gh5Yg9PwTAUWU9VZZERspaX/RiSwX4Vy8DOjTnPXqV/k60spmb/xfJ1PFtCfbVo5YcI3r/NO01qXeSEOoHS0cTgCb+y+rfhCQK1B94L19/vx8ByGg4gdeGdjlpN4g2fUZAn5NH0OrHBPLejU2rPdaiy0DSAprTNMGzJ0JXMqa63SkYPg2+60kD21aKyioI9DWd1T5cfdzVKnci0ancz7WZRvl2Ldq4JaAzje763SPTg69Wml5zJxus5eiComkYd/rFFJ0sszu8D9E53/NA4cvsFB9gWN/byVV+Yd20G2nBHuxTBqAO/pSntieyrwi262oSK+WRNfs1ou/+odr+th3KYu5XzxPS5Boau8zppMrFwMNBrVlzpIIwvxa0OdmgFMdxmQFXCm7h7rzPuu5NiqqVROnO0qvkSsBm1RaGrWgt7iLKdvGu7kPITfDIln0ADqv2OdmdUkjvXKy2Ojy3gxCATrEgCSp6g5EnlPHYFZVVxiiu3CLi05C3n6eOjOdmnS9f+LyJFRkjNo/NXjlfrpqI++TJk0lNTaVlyyv7AqLYKy8UZZgoUv2wqJ69fiIqrrZcPtidK8yK1XMNS1zu8a6LeGXttOdeJBTnTdfmjLQr7h6snvs56Z2tdWSn8Y+/UshIaR6dSmde5pGdBce2ws4/cdjMWIxa+7OqDuySJLmjoPZ/ry5bywnb/hUAn9v7sze7lJe/+B7l+TDUt1LQY2OjWptufa6jdZeBbJc1Y8Ui1ZemvbRIe+d60fhd+y6hwz7gsWFdL3gLR0EQGNo8jqRwvwu6Xy/VCU5qQSk++AoW9m09+3R51SmelCrCvcuRT9liuJUOGZ+e05g+tfTkbutdFDYZ7xXtVxiCKNLsuodo2GPkGW8T2Kpy0e5+3zn0TImgY8NazGnyEX87miMrVnQzbsGw7QckUSC3qVayVD93DmU5h6vtK/PXJ3hA+I6Bm25jtq0pd1nvJiusnfv5tJC2vG0fxh7/1icci7rzT9TnQ1HW/O8czv7iozrneYpLuOsqr6ue2sbK5syidC3++9nyGSytoIF53WUe2bnjirjbBC0aXaNiO3dJv5KYu/Ayj+z8kJ1BJlFvwuRs/VvhoX93AFhLqWnbT10xnQCT7qox9j5XrhrhPnHiRHbs2MHatWsv91BOieI0opP1BvdjFVYP/kIBkvPLI+kMlcLd5rkp2ErxUW6W5tJfWgmA6Iq4e2jaHoDdot103cJddkbk7J77OendPWW1c/Gz5fOi7itGln1zmUd25thWfgLALEsjflp3BAAHlcJdEATszt8Ve/V6z2NLviBAKSJdDWfIyLuIMCrck/cSomJDRMGuimyodRfhAUZESUTs+Rwlqokdtcbi6+vn3v/Q5nH0bxTtbdHlyYgi6b4NACjas+ysN1fd+fCVfwOyaiNAqEA+Bw+WErONZcck/lTaUbt5t7Pe3suVR8NmbVknNKBQ9cXc510EZ+eLxwe3oHDA//hR6AfAw/LPPNnenxsHX8tGqSE6wcGhP1517yfnwGa6FM4AIFQoYXjFTyxX6lPun+h+jeTc98l8PSpm3IOAijhrEpiLLup5nwuqc0FcdQp3vSTyt/4h1hvGY8vZd5lHd264yh9tTuHubnHnwZmIDqdwd0XcE8q28KBuGnXzPVu461WXzjBhkEUMWDGbPTdI4yontqoyQd5UeW+q/KUmp/aNTD4Yy2G/2nSxbaMXKxE2HoMOt17uoZ0zsjPiLup9KNCFc7AiEjOe2sQdhLz9PK/7mgNqHPCcW7h79A3KKdxdCyt7wrrzV6Y/dQM7eGaSm6qiR1tIcbXa0Rm0vzmd6iGfU1kebNHS2b+y98Gy8xgPGXCbRrnQhLyd/NJyPvh9G3WjArihng796skALI8Yzo2pMXwy1sTEaR+gmosJ9NETHBzCU4MrI1YprXtB62O0vcSn6eXSYIlqDvvXYDx29hEwVTk+4l5Z5H72pSfrDhegqJAQ4kN04Nml7Xu5MpElkaDxf7GjoIR2KZUdHkRRYFirREoafcOsXz9HZy3g5j7tEUWB/KYTYd0d1Er/BUfuQ0ihiZT9/hDhgoPNcmPC7EdJEo/xnm4yx8QO7n36OoqpJRzBx3L8344lez8+tnz37+kb/yG+7dBL8A6cBc4AjUu4i6JAsFBKqFBClof6/9idwRhXxF02Olvcecr99gS4hbsz4u4qi/RkPyOqZSP68pl6H82M2zi470OIG3W5h3ZuOAW6DZlgHz1jrQ+RGObLR6G1L/fILgte4X6JORbXl48dwSQb/OhlWc9NLKTkcJBHC3edU9BKeiNTw+5ifu4wXotp6LEtQv59MS+O7UAT86ckx4Txy2Ue27miOD0HHM4U+dzgJvzo8GeMwcOM3Fw4rIho0Ri9SWtLptO7euVexJvu0U1abWXcCf66VRXWfA7GQGh8w2l3lb/sc0JUC1uVmvgnt6Pm/hknfJ2PoP09PjltLWtKIxBQuMk4khAgVw2gTp87AGiWEMwfD/Q93zP04qH4NRrAa7sK2FTWiDaKiiieeQaFwxDME7axSJLM8+5HXQl5Z1/vWbRuGndKWxCj+531tl6uXJKjgkmOOrFRpL9RR7/hE6o91q7n9Wxf9zr1OcCWGS9Td9Q77CsWiFZ1FHR/g/SycsxL7uQt+/XcXOXvtVHWr4w3fMiazH5A9YyNPf98QUOgWDXR3/oyCdtj+a6NWpkxVJgG26ajHt2I0O1pCEu+GG/FqXGmyiNXZla60rHtHmoI6zKytTt9jFwRd1d01xNR3HM9pwGx0zhQ9PBIrh5nxN1gokw0gOLZvlOuzltWdASadOxUa2DBF5xzvv8aXuF+ianawkqQDOCorHv3VGRXWo7Bx13LVbXnp6fhMpZxCXed3kQh/pQ49Jd5ZOdOBXoOKZGU6rS2P5WOsJ5ZpuGwVrgTyo2ulX9nyrwOOygKiBe2EkhVFLJmPEpU7kocTUcj9XkJDP6VL9g7D2Y/pP1cqyv4RZziBOyoa74AYGXY9UwZ24qXp1awctsSdvk05ZYqLy3DiC9mhpp/43DA3URZDlGh6jEJVmb6DeXmpHPr3e3l6qJmg7Z8Pb2EcouDvdml1I3yP4OtNBw6X7539MBXkiqF+3lE3BMOT2ewbj0bjTWBQWe9vZerA5NBZmebNyhZ8SR3H+hCza+3srbiHpr4FzGtVUskQWD43s/ZfLiYuOAq0XWnw7ysVBeFqqIQvO83AObVfJCsfdGk78tjyaZddLavgK3TIE0rcROArGILkeN+vpSnDMDqiBt5O70OLcJa0NP5mKtVrs1ThbvTJ8cuauehc2W6XcyF8otMflhLXrA+RGBQKM2gSutfzz0nFAU9WlmdzuBbWR5p8eB2cE4TOisygT7avNzjTIgvIF7hfonR5WyjvnCQIClVW411gGrz3BVLgANCDQoUPYIpyOMFIYDD2bLP4RTuLsMuqwf3K90a2o8x1mSGJ8TTEQhR8ugobiG8uBhodLmHd9ZYzGX4AIoqYDQ6U+QNVVZfi9LI10Vj1Ev46M//MldhdfDQL5s5eqQ3MwwrkTZ+jWXvfAw3fg1xWq9yZdGrlTHK3bMRmo8+4b6yis38MXcutzlyyFMD6HH9HQiCwKPXd+bHGj/RKLq64PpGHEyybQ/zg6/n93EdgA4882tN8g9sYMygMd7adC/gTGVuFBfIqgP5bEgrOCvh7ipxF6v+LQli9SfPkAqzldqWHSBAdENvfft/nev69OBznyRyZu0k51ABAF1bt3S3m/x6XDt2HyuhUVyl57XDNwqAJsULKPzzSYL6PQOSjhWbt1HLUUE5BnoOvZW9y7P4bPFeCv56Ghx/g7PcY5NSi2biPoxHVmgGrLpLW7qXoavBQkUlxa8yo80m6EAFu4ca92aGtuEN60PEhkbTDNAbtUw3gwdH3MsM4SxUmpJqCABA0Hl+ByEUOwtpgeSwEG/yw+4W7h4ccbe7Iu4ygSYd14pLqWMt0DoaXI6MmsvMVSPcJ0+ezOTJk3E4rmzB2GTlPcw0pPM877jrn1S75174AB6TH+RomZnfI+rTYcOHjNNPpXh/X+j02uUe2jnhdv4XNeHua8nmJfl/yBU+QJfLPLpzw2x3ZXpoCyuJhSv5Vv8qW3LaAMMv8+jOngo5mO7mDzAIVhbotMuYwVgZsXF82oUQcwEb9C1oNvQhqNvn3A6kKOTtWcHoeSrbjhQji3UZJzzLM47JxJdmYPlqEIZxsyG6Ed8lvMDNR7XU4KKNvxHkFO7fLthI6cqvCJPKmBY8jo1pBdgcMu31NchKHEzXaC0LQhIFRrapcdwQAno/zsKjxbzRpx6BJu1v8vUxPVDV7l7R7qUaHaJVwg6txLr1ALS6+4y3U63ltBe3ohcMQG/tQefflnCWEffdW1bSRKigFB8ia3tqwZSXC8ltnZII9zfw4LTNyJLA8Fbx7ueMOonG8dXbRTbsNYY/dy5igG0OQes/oCJ9KcVNbufjzTGssHzAw83hjoBgJnb1w2/tewy0z2ObWpPfHe3409EW3/AEkvMXscTRkDnFDmqEQmlRPrumTCAjqhedrxlJsO/Fy6BzZRy67re40rFVZ614yTEoy4WoBhdtDBeaYl0Yi5SmdPTR7leuDDejYNMW9zzwXmRzfk46Z3BGcM7JJQ82IkbWM97+IFa7wnIfPxyS9jl5cutfRJkcNZBC1Z8gk46R8j80V/ZCzgCvcPdkJk6cyMSJEykuLiYw8MrtVii42jToDAiyduPwdOFurnKTClBLSBUPs7U843IP65xxRdwVZ8Td4ChlhDyfQseZR7CuNCqs1ScSorM2SHZ4wOq/ww5bfobavcAvHIBSm0omoegl0V3La9AbcKgCkqAimbXITjPrOso2/IzvOQp3ddsvhM64jdsdbXnW9wE+HtGMulE9eOvPtvTffh9t2Int62sxj5rJW6vL+N7yKnMNj+J7ZBlYy8i3SjRdfAsNhINYrDqeLLwGG3pa1gwmq/m3dGlx+myHEa2PF/M4HeG9eKlKF3k7d+k/YMeROsCZC3ex5Ajf61+hGF/gfgBKDVGsU+qQrz+7UoyCnYsBSPdtQIp01UwxvJwng5vGUj8mAEWFiIBTR8AD/Uy0vfcbXvroLe4u+4CA7E2Y/p5AgeUlEBLp370rOOvqe97yLF9tGcFecwDZJRZGJgRxW6ckxn1tomJvLr9tPMq9PWpz8Lt7aFEwmwXZATy+PYZRbWpwfysTxoBw0PtWO/6+zDxKt/9N42gTQv3Bxw+w4DAc3QApA0/YSz4pfxlDxUOE2QMAzUDLLupA0SLuji96IxYdRrhrnccID7Ot+hxCHxBJY/NnWNCxXVGRPLA3vSF/J9dJizE46gLt3a1/PTlVXlVVd0tjgyy6fY08WbjbavehpeVjAOb46ChQ/9vt4Lx31UuMy/RC1BndFwnhHNrtXElYnGnxBlkEWbtIePI5uRZSHM6Iu8uExZNrudqlf8YQ/UIy824G6iHptVVYV0eAKxll1ceI857EHtUE+Q5NFKw5qLkKp1RJBzboJW61Pcgk+RcaiQcpUP0IFkoRDi07+4iAqoLDhvnv5zEB+0jglzvauvuRv3BDGx789nX89t5NTXMOO/54h6KKAWBMIk0JJ0HMwbr7H9bszKSPcJAyfDja7H7eiEklMTqKhnFX7uKiF88lrlEXWA3Jjv0UFhURdMaL2Fo6fFVX+W1R1/Le9gaMjEjgTCwPVVVlR2YxugytxtgS2+aczsHL1UvtyDNf/A7zMzBh4oPc83k9muX+TmPpEHJMY55rmUB8SGVZVN34SOrGRx63/bVNY1m6N5ffNmYwJnQHDXP+BKDEtwblxQ7Kln+KtPZ76HgvdHsSVVFYuWgW7+4NJfLwX3yg/5Bi35oEpA6qfu/I3on58z4YbYXkNr+fsAHPHnfsrrnfc5t+KwvLawMdATgqJ+CwmrHiw8FSiWRU8jf9RUiP+872bbws+OVu5nppCeGOZkALDHqZIrT7odmu4Ct5Xnfp0KMLeVP3KYvMvYFbKYlozhDLs9QMjeLtyz24c6Sqv5RRJ+Fwtf714BbNVUtvg0x6st0tcq1XT0/zs8Ar3C8xrtoZWWdAdIpcV49Cj0RxsFAYj0WvQ+9YDjrtIiF6QiT3JBwJ68Db1odIiEigFaB3CXcPTp8KtByhgXiIUrUEANHgdGL3gFqu8mUf4wfIxzZpkQ69H+3/voZH5YaU137c/TqDLLJIacLzTAHgedsoXtV9gY8lG/L2V49slOfD6k+gNAsEkaIGo9lDAvuyS0m27KTFvnchoT2m0nRy1EAszce7RbuLx4e04Ya3n+IT25PkHT1AAOW8dl0nFv/akTjrfnSZNpJ3ai3b0uqMJmXQw/w3m5d4uVQExSSTJwQTSgGLJ99CYURrYpr3o33ThqfcTlW0yZ5aZRrkqnc/SSvtaizdm8MDUzdTr2wN3+hXABDRoOv5nYyX/zzBvno+vWsQWUV9iA020fksOiX0rh9FP90Uniz9H4G/awu9f5gG8dxDj9Niy1FmTV2DTrWiLHsPMakLh/54lXb5S5lnG8VUpQsWVUdA2SHI2l6Z0p63H/uUgRhthQAErX+fYymDiEpuWnlghx2TQ7vPSlVq678KuZ+VhXmMrUgk2NKQu+X95B7YQMgFeq8uNvHH/uYN3TcsLh0GDHf7GeEUVr4Gz5MTqnPurTiDNIIphA1qHRQx6DRbXrnYjmxlj2EUR9QwDPIu8nySmJvTAoOpFqmXe3DniLmKEV2AScbqlK42qxnDKba7WvG8b5qHI6ma26OkN5Ie0JS2hz/g7s4NuelyD+wcsVvKiBAKQYBCo8Ft7iF5cMS92BDFIqUpPXw1V3BZr52TXnB4bC2X6KzbF5wLK7LB6cB+qYxlFAVydkH6Kig+Cm0mgM8ZTFnMxRgrjgFQqpog/xg+xfuJsR6ik6hSVjfK/VJBEGghHyJBzKFcNbA7pCsbihbTVtqBff9i5LBkUFWK1v6Icf6TGCx57m3/WnWYJ+y3IqAwS/8YgpgOhzUB8qk6lDt7HF+LGOKr54Fr2zPku+eoLx4iKS6G3vUjefvoozy1YB/DVq7ldTWNEnxIGvjwhXkfvXg5FYJAZmgbQnNn09M6HzLmk5/+AQWJ2wkOOnn0XVVdwr3arpzPnf6wXyw9SHaJBXR1saEjL6o9MfU7nvfpePFikCUSQs++7ZOvQaZpQjAxRzTRnqGGET7oRURRYFCTWBbvHsySbfPpxFaY0p9EwKpKtKsVxoAe3Vn0eWN6S+so2fgL/n0bQHEm6jcDkcuz2anEs1+NZYNSmyW/5TPtTqtWM5++FmbeT6ztEACKT2jleTg77vy6MYNmSi0A/HI2XaB36RLg6k3vDDiJosBzum/wowxbUUPwS7jMAzx7XNmVissp32VE7MFdkWyWMvwFBzIKsiiwO6wXT+6ryz3htT3UoQnEbdOYqn+fZTTFKPfD5pSudqvlPync/4tZBpcPVUWqEnGXDSYyCaUAz62dNpsr62YMRl+3MBQ9WLi7Ltou11udoYrpmYd2AJCcGRDu2nZXK5dLIdwL0+CDZvBxW/jrfljyBkwfp4n502DZ/Q8yDrLUIBpY/ses/BiKN/8BwBKxBU3/ZWr0jvw+AFvUJO7u3YjNOi3SWLhjPqrDxsZ3hhA4604Mljz2KrG8bbuOd2xD2a3GERtkol1yOBPsD7BN0dyA05Rw/NuPI9TvxLeHPg2i6dsyhXViI564JhVBELi2aSwiCuMcUwHYnjASg5+nxFW8eDr1b/ucrO7vcSD5ZkrwxQczmzesPOU2J4q4Nzn6E6sNE+h39INTbmu1K+7Sla/u7IHu8TSi7vgdnD2RvXi5XNTpMJgjaiiKKvB1+EO0rVcpLh/rl8qb0lhsqhY5Xq/U5vPUb+g59lmaJQSzK6Q7AI6tv2qrV79PQCjKYL8SzVjHE4Td8gOz/a5lX66ZF95+i/wXa8P/esCxrZQIfjxqG4c5oon7eAZZpJmwh8/tT1BXSAcgypaGo6Lokr8v54LgXPxXpcr50CBpGUOlpdhKcy/jyM4DZ5sx1Xmt8rEVcKs0iz4Vf13mgZ07NrOWEm9BjyAIGF0tmj2405NamE4rcTeJYhaiKLg7Ptk9dD5+vngj7pcSxY7gjGno9EZMgue3TrNWaMLdosoYdDKiK6KreO4XKqBgG9dJS4i2NQWao9NXijarxYxJf2lby1wIdM5adskp2PXO/y9JKxffcGg7EXXBC6TpaxNVvAXD/vmw8gNof+8pN83f9CfRwJ+OtgDM2nSIwce0OveC2O7I/6qri0KLoi8U23B/vQg+j28Ph3/GdGQFe354iKbFC7CoMlN9buBQ3dtIjQ+ndqQftcL9eN6Z6rfuUB3u+C6SthUL2WVozA+d65xyjK8MacizA+u7TXuSwv3oGquwJzueMLWY2gMfOo83z4uXs0Mw+BPZcQx0HMOXM3rz+horvbIiTxltUU4QcdcpFUQKhRy2l5zyeLs3r+BP4X6WmFqTEtUPziKd2YuXi0n7OtEMM7yEtTSfFwbeUO25cH8D1/fpzojfHydMKKIksR9fXdfa/XxEy8FY5r1NUPkhyNyMLbQe9v3Lud02ieu6NqNNUihfj23FTZ+vIq1MT4ghG4cqMMPRkVftw8kjkN5VXOWHFH5Fb8N3AByToshQwokTcjiwZRlJrfujqio5JRbCs1cgGPwhvuVpzy+/zMpTv21jcNNYeqYeX+d/IRFc5Y+6yvmQxcN70+MMMKmidk4+1lye0n1HvjkQ8MyuSHZnv3aroH02rnmJxXrll0WeDIezhaIrM8LlP+WpgbTzxSvcLzFzw8eyJzMfndGXEHsBT8rfkro/BPjocg/tnLA5e0Na0WEQBQSDP9lqECWC52YRxGfO403dFHctl75KxN1mMWPywFNzC3dnxF0KjOYF2wgUvT/PXPSDm5ht7M+LSg2OZNu4UVrAq7ovUOc/j5DQ7pQTlLX22kQoKWRFd4N08D00D72unCw1iBoN2x/3+gmGVwkp3Y3aZCRGnUTNRp2oOKTHald440ANHlei2NPoQUZdd9tJj9miZggz7u3G/5Yl8nRKJP7GU0cOtVXt6s7CNzYOocH8PSxJmMDgsIgzepu8eLnQNGrWDvOalSzanY3doRy30OVGdZnTVX3+zAR4wda5NBSPYvY56u7w4MXLlYAsibx3xyAKy20nNAS9qVUCK/Z1JbfUymcjmlf7fvRqUoslfzemp7COvPUzeCR/CJvMDTEERTGhi+aXUifSn8UPdWXrwRT+2BXHkpIYdhWCJbecSINEw9jKYwYqxe6fCxMHcPSYSFz5InJ3LyepdX/em7+X3+cvYZbpaYyCDWHgB9D4xlOeX/q3dyClRfHwnvb8/WAPwv0NUFFA/pQRiA4zgQNfRki4MCaRLt8iQa6cD1kFA6iV80BPQ3BG3F3ZQbLLtBf75RzWeeGwaosoNkFbjKhXtJy9hgc5sicFWH6ZR3duOJxeBKpTsH8jDeXr8q68ltTfYzwiLiRXjXD3iD7uko4/g0fxV3omzxhMGMuOMUaejSXH5LHC3epMlbcIevyBkug2tLJ8ROuYEH6+3IM7R1wt+1wXCZ0s0d78HlZ0zNQHEHCZx3cuuDIg3CnyfqH8z9Efo1286MJ9zrZj3PnDRgDigk2sFPrzZ8k2BrAKdeFLCDf/dsLtVFXlzby2pFkb81mX5uxesI7Jee8BsEGpTae6xwvisrCGzCuK4efmWp/g9vVi6fnLG2SoYYBAdtTHzLj29JVeEf5GHuubcs7n3LNTR3bX2UL/cN8zeLUXLxeHpgnBBPnoKCy3seFwPq2Swk74OqspkhdsIzCY/HC5MQiCs7fxafq4Bx5dCoAlvvMFHr0XL+dPfIgP8SeZ3UuiwMcjm5/wuVA/A/vCe9Azbx1b1q/gH3NrDHIw71/fCJO+cqHW1yDTpl4c1LuBgc7HVOdCWNWWnQnmXe6fUzsMomxNMUu257GjOIDaW+eSu+QfzGpDlthS6C2tg1/HQ3BNOInwVo9spPGx6bypk+hrrcmer8YTftMT5H8/lpCCLQC8MW8ftw9vTqDP+ZetuDoiCVUi7u7e9B4q3F3txFRn/3ZZp0V09R7cQchh1T4Ll3CX9AZ0gsMzWv+eBMXmjLg7P6csfTwZZWGUGf6bQZGrRrh7Sh93V1q8USehGJxfLA/uGelaaXVZRBicTqMWDzb3cLv8Oy8SgiCQI0ditSvYFM+MKBXhR44agORMF3BFiM02BVVVL1xP8OJM2PQ9JHWFoHiUb4eyLr8zAq25oWUNnh1Yn7T8ckZ8OJ5dtgT04XdxsmT5g7llpOWXo5ME2ieHkV5Qn2Vz69NB2s4/fgPpG3y8YdFbwxpzpKCCFjW1mVqIr57QuNpkpBciCvDSdc1PHnW8wNSN8sDUDC9XFZIo8EDkRloc+ZbsBddA0qsnfJ3dpC3kxcomt3BXBdf35OTX8rKyUupatoEA0c3OpGmcFy+eQ1SrIfT4LYR9ahwGWeTzm1vQrtaJF7+qcqL7aVpAM2Iq9nBIiKNpYgQ7jLfRf1MKvtkS3ee9zYviKmoHDucpxyOUW97lWmk51j8mob9zCUjHT9WLlnxEEDBbacNj8g+0z9+I/aNZhCgWClQ/3rdfy1d7g5nx3hI+HtmcJvHn55Tu8skR9JX3XZszHdsV5fU01kVcx8cZiaQGtwOnyMXTI+7OsgWbM/1f9KDWvydDcUXcnZkRBqeJoCeXGZ8PXnO6S4ndQnjZPmoKmZh0krvNmIz9jIy6rkQsqsR2pQZpYhyA2wjDk79Qroh7VXMlg3SFuI2qKuybD4XpZ7XZbeLztLR8ghrbAgCjLNBM2EM7cRsWi1lrj2Y+T5McxQE/j4QFL8AX3eCjNohZW+hvmU1UgImnB6Ri1EnUifTnyaGtmewYzDuLM1i4O/tf+1Egawf5c18jhGJaJYbga5C5plE0E+z3cY3lRQJSu59wCNGBJrdodzGwcYz2HnRK8vZP9/Kfo2GknhQxnfDMBSd9javlW1W94RIfwils5fetm4dRsJFDCNHJTU76Oi9ePJHujZPIMtR0i/ZOdcLPeV85ze7lKdsYFnf6EUEQSIkKIMhHh9GaT2LRGgBSet7KH3d34ueQCRSqvuhzt+NY8/nxOyvPx3fv7wDsiL+BzXXuwa6KyIqFUtXIhzGvMnD8CySG+ZJZZOatKT9RvPyLcxu4M9r5a+DNTLTeQ1FYM/dTdqc49FThnm6sy19KW4r8EwHQ6VxzckWbz3ggZfoQljvqk6ZLAkDSu1r/em49uMv9H2eNexP2cKs0C2P6sss7sMvEVRNx9wgK03gl+w6K9T6s0PVHrVI7jcMKoueZnhUEpHCT9RWSg/z4B/Cz5TNV/xzGYgk4tZPxlYrgTJ9C1rsfmyhOxygXoBQmQ1jdyze4pW9pwjhlINzw7Rlv5lpIMTkj7UadxC/65xAFlbwjPbF+PxiL5EvYI5sQ5HNssLH6EziyDmQTqAqUa0ZxH9oH8Vj/VHz0lZebQU1iWXson+9WpfHAT+v5p1sGIVE1YctU2DMXLEW0AFYbJH5MnA9AZICRVvWSmL/Ll2cbRp/xsG5pV5NOtcNIjvA7g1d78XJ1kdh2CGx6lnr2PRw9kkZM7AnaNllLaCbsIVCtUgjkjrifXLiX7/oHgMNBLQkXvXEAL1cXAUYds+7R2hrGh5x9S7qqXNMqheZ1XyU6sLKdWtukUOrt+hFZUNgr16Fl8xYIgsAbo7vx/ns38TSfY//nBcT6g9lYaGT7kSKG1JHx2fodOsXCNqUmqS270y45nNffHMMQZR6f+9/Js6NvxN+o46+7O/DQB9/xYcmjOOZJ2Gp3RhdR+8wGrKow72lY9RG0mcA2qR/LlUh6BcS5X+IS7orVM6O5VocWiDG4OwhVmYM7rCCaTrbpFcvRiC7caQugZWAwNwCyQRPueg+OuNtUiVLViOpcWGnl2MgNuh9IS1OAQZd7eJccr3C/lDhXjSzIGHQSirGqcLeAzvOEu8WmXfhckXa9BE3F3TgU0WN7nguu0gWpUrgPUucTLeeyr+Ru4DIJ951/aqIdoO3Es9rULdydtXk6WaIMPb5YyJ7/ISlKEShFZK6ZQXS74QCUFeZSmrmHyHptz+xzTGhLcUAdvlP7sExuTZuSf8irUCiO786ARscL7aeuSWVrRhETsp4hZP66as+VqQY2Kcn8prTn9gbJ7sffu7EJmUXmsxLhoihQO9Kbtu7lv0lgZA0OyMkk2fdxcOWvxFx3fHGKMX83MwzPcsQSCdwKgFkfwg6lBvnyyd2qw7O1xVmhVteLeAZevFw+zlewuxAEgZig6kLwTuVHGskzABAbX+/OcokP8aHx4HvY9Ot8otV8HvlsEYtytUW1xv6v0ci2GYAf1V48lhqFn0Gm2fWP8NaGETx9TarbUNXXIPPQ6OtY8eGXdGAz+76/m+T7Zp/+fq6qMPsRWPOp9vuK9xll2s8KhrvTlAH+F/EYy/bm8GRwCs0XvQaKHbo8CqJ08n1fQcQXraWfeIAgeyBQF12V+n2HzYKk8zzhbrZXluMCSEZNuBtUzxXuK1Me56ndA+kTEsWNALL29+1Kof+v4V0iv5Q4I7lWdJh0EkZjFaHuoX+AFudFwlXbrndeJCQUd49MT0N0R9z/ZcIC2G1nkRKmqnBkgzvV7LzI3AIzbgdgY/QwlluTT7uJi2MHt7NBN5af9c9jdFSayLhauaQcne5+zL7mS+0Hh53cyT2J/Lkv2Z8M0HqxnwKrXeHZ9QaaZT/J6zmtWZEp8HZpT75T+/DMwAYnrPkzyBKTRzRjptQNhypQoPrxtb0nQyzP0sjyBePFZ3A0GlFNpPsaZG/k3IuXsyQ/VhPW+gPzTvi86k6Hr/yeHozpTz/rK/wRNu6E2xSUmllrTSBDDaNGy/4XYdRevFzd1KhZeR9P6jyq2nODmiawoNZjiKgsyg3AIIv4G2SszhrmfUoMJbUH4+dsY9qnQRSf39ziuIWGxHA/lD6vYlUlkotWsmv26Y2QHXvmuUX7dEcHFAT6VMxkjv5RfNUy9+vsxlBqCUfpu2QQLHoZlrwO/zx7/A7TVsHvd8H8F8BcfPzzwJ7lv3Fg/T+nHduFpOuxKXykf5/4sq3gjLiPtD7GDZansHlgBixVgmmuBRbXnFyPzWPT/81W12KEU7I6Mz1cmuq/hjfifilxCXdV1szpVB1WVUIvONz9JD2NkEMzWah/nX2lrYB26IxVbhr2imrp5p7CvJAb+TivKZ1DK3u62gUZ1Mp+kmfEpu/h94nQchz0f+vcBpO1HVZ+BFungsPKTp8WXHdwAD7frWfJAx0J9j9FNCBvP+Z5LxK1awYI0Fg4iMG/0uXcKhgArUdzsWrCDzPxhWsgbz/ZW/6mhu0AABFZS7F/0hnp/q38b002P606yDvNjtGw+wgAzMV5jPphN2sPFQAyd3SuReukEGx2hfgQH1KiT+7DHxfsw5Dht9Hx2yT0fiH0bpzAk/WjqBXuR6Dp/J1wvXjxAuHNB8Hhz0ktW0tFeTkmn39dN5zO8VXbwbkk/MkS5VceLOAx223UifTj76gTpN978eLllAQ2vx510+eoSZ0RA47PSht/4xAm/5PCM4G+DGkWT2ZxBSO/eIWi0jJsSHzYJPGMjtOpbTvmb7mV7pmfkbzmKSqS62Oqc+LuKqUWOzfMNdHddh2ZhDDN0YUljka8p/+IumIGZY4S92sNsshuNR6L1U6uEEEc2bDifYhqBI2ur9xpwWHY6Czt2/wTDPoAanVzP525ez115o0GoKJuGia/S+NFIzn9jASnEbFellimNATAioQnSvcGO95ik2Eai4pvAloim/xZ5qiPoPehvcPmMdkQValq6g0gOHWF6qEBz/PFK9wvJc5UeVfEXVVV+lhfIyzQj6l+UZd7dOeEWJ5HophFnloIgNFgQlEFREHVIs1GzzMD26dPZaYSTOuAmu7H7IImIh22KhcKVYV9/0BMU/A93mlWXfMZAqBumYrQ++VqEfwz4sBi+Gag+9f0gGbckH07EgqvON7C+O6t8OBWMAX/68AqrPsSde4TGO3a6vwKsRnJw14kosoYrM5WLsMsT+EbFs/owsnUFjPwO7wZ3+WvAfCZvT+Nxf1sUVqyafoe5mzJ4DvdKzRcugM1XIcQ3Rjxk660NPdnj2EIb97QjJ6pJ0+tPRFd6kaw8Nlh6CXxwrnbe/HixU1Cg3bkzggmTChg4+o5NO06pNrzqtMcVa3y/XP1ZFdPYk63fF8uwBm5bHvx4uUE+IYi3LOek931fA0yD/dv6P490EfHz+PbcPP/1qCqKt3qnXk7rLZjXuaf13fQw7EM68+jYMIiCK113Ot+XpvO9qPFZJhu4O5uybwfYOS+nyDDEk6skMuYkMp5Ucc6Yfyx+SjDrE+xT43lAXkaE+Q/YMY4KDhITrN7Wb4vl7TD0ST7X0cbywpCijPg22uh5wvQ/h4A8ha8h2vZYv/aOTToekPlgFQVDiyE9VPAFAId7ofgGtUHbTPD/Ochthk0vO7Eb0D6Wu18fSrNa0VnWaTgbAOnkyo/CdvlNiI+RyRLEUFCGQbRmQ1r8mGI7QkijAbWeGA5LkDr/e/ytW4LB823A43cwl3wRty9XHTcqfIyAToRFYkDagzFdv0J2314Aqpdi0A7nCuWBp2EBR0mrNgt5cgeWFrsamWnq9I2zOFMlVfslZkRyqLXEBe/gqVWbwyjplbfybGtCJlaHZpgKYYDi6BO77MaR1ZYa5bXeZ16uXNZHHw9r23XItfDW8WTvOkoJkcJuRv/IqxdlRS7igKYMR72zkUAljvqM1l/Cy/deRMRYdV7ilsFA6hgFKwM6taBL5f6suyoyh/bFtLAXsB+JRr//i9w/8IDZBVX4NiSiSzKrBdSaMsOHH/chxScgN5RRmtxF1G96561aHfhKrXw4sXLhUcQJXZG9CU7M51jRxWa/ut5lzhXq0iIxMzZLNS/w+GsNsA3/96A3D2rEYmkXa3QS3EKXrx4AWqF+7Hgwc5wlvdNH4MOw9BP2PTTIJqwn11px6j3L+GuVBTz04o9ADzcpy4jWmsCudxi59EZsF6tyz3GyrnqtU3j6NsgmoJyKxkFFUz60US98jS6SZsoWjyZHnMSKVJd2T1DMNGPmfXmkXToR82vp15/VIM/tbNmufeZdvgADVy/HNkAMyfB0Y2Vg9z4HbS4Bbo+ASZni7tFr8CqySAbIbET+P1rQaMwHaaN0fKHxvwFIU7HdVUT7pKsCVpBELhOXoZJLcdW2gT8Ys/4/T0h1nItYHMJo9yCs22f6jynyta/npkmDxBZvI0a0hbynQFCweU/9R8V7t4a90uIS+S6Iu4uh+8Kq+d+oVRn/bYiVV4kzM7aaaul7JTbXqnUK11NP3EV/rY892MOUbtZKTancM/ajrj4FQAM++ceV7dlX6+lhSmqQIYaRnnJ2bdae/r3bUzaEke/o7e6RfuELrV4ZUgj9gR1AODwil+qbyTpUUpzsKLjedsoJkhP8dS4G0j8l2gHCFK1MQfrHfRpEEXL+nVRECg6sB6Aj+RRXNcqkY9GtcSg1xPub+Cn29uQ2+xeVjpSke1lCDk7KVD9eF6awNDm3nRZL16uVOzdnuMB2518nxZ8XBRdVbV7UFXhrreXkihmEejIO25f2Qe38mnFA6w03EXrmp6XVeXFiydjkKVzWuzumBrPr3XfYKmjAWNnV/DPjiztWnB0E9gtHJr5Bj+XjeUW4yKubVopWm9slcD7w5syqWcdaoVX95gx6iSiA020rBnC1AkdeDfwYT6xX8NT5pEUqSYaxQVyc9saXNs0lgqMjDh6HY6kbpromvMomfM/woCNA0oUyeZv+KCog3vfJWY7aWI8FsmXhYGDSQ9uA4oN1nwG3wzSWtge3QgrPtA2sJu17jb/JigemgyH4iMwZQAUHIIqwl3UVZblPSL9wAu6KaiFR8/6/a1G+lp4q542zkuIYHcJd81Yr1K4e2YGAVUMoyVnxqjoKsH1UB+t8+WKDPO+8847fPHFF6iqSo8ePXjvvfeuihRae2Ai/7MP4KgawgM6CQQYK80mUilAza+LEHJm9UpXFK6LhFO462WRo6o/CgKyzX6ZBwfk7NFSyf3OvP/q0MIvSdTvY2VZA3DGphzO/pGKzQwOG7bpd+C61L/huIm7bXaqeg3uP5JNkipxj+0uZiuteN7agJv/fSBbhVbvVbMjhFUxm9vxBwdM9Zm7PQuAMe1qIghQJ9KfG1rEA9Cw23D47UfqlKzmrzW76V/XDyEwlhJFzzO6x9hh2U+aLpHvxrY+aY35JmNL2pUvJLleQ4w6iR6pkbw1bw8jzA/RRtxJw3b90EkiTeKDWP5IN3wM2mQh2FfPjasmMlt8jDChmMds4+jZsSm+hivycuLFixegba1QjDqRo0Vmdh0rqX5dcEfcq6zlu9rBqcdP+I6sn0UEcExfk8a+nue87MXLf5V7B3dk0OQXOJpfwbhv1vFUzFrGFn6I0HQkgTv/IkQopVFiTLX2rQADG8ecdt/RgSam3NmT9+fXJDXQyEMNo91meWabgzUH8zlSWMEPwRMZJS4FUUfwZq1P/d8Rt2DPkNmZWUxOiYUwPz2j5tjYmT4EH/pRUKZdr+6qMYRJxa8hFhzUaudnPQSqg4qAJEzFB2DNF9D+PjD+a97T8jbY/hvk7dXE+9jZyC7hLldew2yCdt72szEVztyijaNWV2h3D+h9wD8KLEVwaCnk7qs+x7uIiE6/LMEZcTfpJOboHyFRyMSRMQ8prtklGceFRHR6EUjOVP+M4FaM3PsYXeLqcWLr1KubKy7inpOTw4cffsj69evZunUr69evZ9WqVZd7WBeE8uC6vGofzjeO3hh1IiadxE3SfMbLf2HLP7Vr95WKa3VPca6ESaJAH8fbNLd8SlnQWbRNUxTY8Qd80QPyD5z/wOxWmP0oTG4JX/Y6q5U52XWRqFIP/k3YA3SyvMPhiO7w0wh02VsoVH1paf6IybZrWHescnJrtjkYlTOSNpYPORbdHRD4eW368Qda9g78dR9MbgV/3qu1e/tpBEwbTeR3XYgTcuhdP5JnB9bnmQH1Gd4qwV13mtioI8VyCP5CBf1mtmbXxyN4f/5eOr6+kBl7bByQavLFzS1olhB8/HGdHGnzHON8P+Canj0BqBflT2yQCRBYpaQyrGVlBD3YV+9e4a8V7kdKnToMsrzAEMuz/ENrRrercdLjePHi5fJj1Em0SwqlvnCIHauru8uX+8bxlu06/jRUusOfarFcd3gxAAVR7S/iiL148XKhCfHVM/veTtzZpRZ6SWTZMVmLaK7/ilBHDrlqAM37jjmv/T87sD53dK5VzeHeqJN4pG89AF5Zayd3zDLM133LGOVJpth70bjXaOrHBAAqq3cfZsX+PDalFyLojPRr3YC7uyVjkEU+PBzHROlpdvb+ATWqIWX9P2Kzfyc6Zj/EXiUWh6WENYv/rMwqMhdRYbbw8tJ8lnX4EkJqQVEaTLsFg7O3uairNFG2O0MydtsZpmGrqjaPS1+lpex/2EKL6AfFQ4xTJO/8/dT7UBTI2+9eQD1rSrJg1yxQVSRnqjw6V8RdRIcdg2DHZi49t/1fZlxeBLLzc7L7RrJMachh3aVZDLnSuOKEO4DdbsdsNmOz2bDZbEREnLkBx5WMxVljIgqgl0SMOgmr8yJhs3hoj0WncEeuDDcbnQLPcibmHg4bbPwePmoNU0dBxlpYOVl7TlVhzedQUXh2YypMgy97w+qPtd/zD8D2X894c0nVMgWkKhfzMmMUaWok36zPxXpwOQDP2EYTFasJ1qX7ctyv/XltOtklFgyBkXw6ujV6SWT30Xz2bl1T7TgzQ25mvqMpqA7NeOXnkbDrL1AVZlmbkqGGMaHLSS5MoohPs2Haj4KKsfwob8/bTWG5jaRwX74a05J2yac2jRrduR4/PFyZRi8IgrtGvWlC0Cl7n49pV4MjhLNBrUP/RtFEB3qjbl68XOnc7reMmYbHSd1evcuF2TeeDxxDmGPsV/mgM+Iu/CvirtqtJJZuACCoQa9LMWwvXrxcQPwMMo/0qcff93eiomZ33rNXmlWuCexLQsTJF/zPhwGNommaEES51UH/7zKY+P0GVpsT+Mz3DlonRzEqfB9L9PfR+J+RlP96H/WENG5smcBL1zbkgV51+Xl8WyL8DczODafvz0UMmryc/t8dYVDOHeQLgTzqGE9ny9sMWxjEK7N3aQdd+Arqm7UpWP4lY385wrbuU8AQCBlrKBV8ech2O46AyrIAu+AqizzDOfmuv+DIeqyCEYtfrFZfH+gMejTXnPLZ8cep97HsbfigGWyZeurXnYxpY+Cn4bB+CpIr4u6MThtliQq0IJSt/MSt+K50JFeqvF47J1erO1c76v8aZy3clyxZwoABA4iJiUEQBH777bfjXjN58mRq1qyJ0WikdevWrFmz5oT7OhHh4eE8+OCDJCQkEBMTQ48ePahV63jnS0/EUpJHvJBFpK4cQRDQSSI2Z7WCxXIW/cGvIErEAA4pkVgNlU6dBmevxdOaYSgKfD0Afp8AuXu0i2nHB9laewIfzN+LeeHrMOtBeK8xfNIRvh+mpZYrp1kQmHozHN1AqejPHEdLABzL3z/j1UxZ1VZaxSoOnH0aRKGTBDZnFDHD3IInbbcgN76BsR1qEkgpum1TIXML1kMrWb1A+07c2TWZiAAjN9W2sdYwgbjfhmiZAE6+XpXOrbaHuN7yNFt1DXH4xUDrO/mg3rc8ZBtPx9rhNI4POvk4ez4Lo//iwMjVPB77NfWiAnj3hibMu78z7U8j2k/GnV1qMbBxDM8NrH/K13WpE0HdSH9kUeC2jknndCwvXrxcWmq2vgaAOtYdFOYecz+uOK+N1YLsolO4U/16e2TbUnwxk6/6U6+pN+LuxYunUjPMlx/GtcGv1+PMUtqQpQYR0f2ui3Y8QRB4YVADQnz1ZBVbmL8rG4DBTWMRRYG6SUkkiDnEm3fTs+xPntF9w7iOlSWkTeKD+OOuDgxtFodeEtmSUcShvHJiAo38PL4tHz58OwM6twXgsyUHWLYnB+u23/GxF1Gg+mN1KIz9LZuintrCZYySyW4lHqlKZx6HcIKIu7kYFr+uZUlu/UVLjQdw2LXe9MAntj60LX6V7e3fB1Ekt9TCexm1tfKjzE1aWv/JWKDtgz/O4b23WyFthfbz8vc4qq/BJiUJh0mbA4qiwEG0Mgdh/z9nv/8rAJcXgazXFiCClXxulBaQmjfvNFtenZx1UWpZWRmNGzdm7NixDBky5Ljnf/75ZyZNmsQnn3xC69ateffdd+nduze7d+92R86bNGmC3X58/fPff/+NyWTir7/+4tChQ5hMJvr27cuSJUvo1KnTCcdjsViwWCqdvouLr9wVJcO2n1lqeI7ZQgdA63Fpd9ZO265U4b5vvlaj0+WxE7Yzmxk6lumHe/FIQj1cXTnvU78nWb8LXdqTEH3Nyfd9eDmkrQSdD3R+BFqM5dedxTz89RZsDpW8WjV5xi8SoTQLjhXCsS2wdy6s+BB6PV+tD6gbSwmqZMAu6OhT8QKlqolawlEqwvrSSHGckXu/zPER90FNYmlRM4SPF+3j6bV34GuQmNu3HgjwmPwDN5YtwrL4EPZDy/nAlo2f38MMa9EHgG5tWmE7KBPsKMQ+7xnkHk+TWWxm7aF8AHYbGjCgpB5ymYC4TMDq0CbKd3Y5zYKVzgSJHUkCfrxAGUORAUbeH/5vz+njEUWBH29vQ0G59TizGi9evFyZRCXU4aBYk0TlEAfXzqZp31sAEG0l1BPSiFWqOsQ7Vfy/FjzztswhDtjl05x2eh1evHjxXERR4NZOtUmvP4OMEjMtal7cLhENYgNZ8Wg3lu/LZebWTHJLrYxpr7WYS2najpxZgYQLmpnvnvjraRvsU237qEAjbw1rzOP96vHzunTySq3c3S2ZIB9tvvZIn3oUVdjIXTudtJ9+oINylDLVgLFuT2rnWdmbXcota2KY2mo8n2xysMWchE6ujGHanMLdbUSsOLSI9v75lYNofgsMeBe2/AS5uylU/fjcfg0lSAyflsk9+X58tGg/+WVW2ujr0lrcqZVCtjuBMP93aaiqVq6gZu+EoATQH28u7Kaq4/7I6Xw1s4C/s7J4Kdztzc+fYlcGsALTrhlgexU8rC2c6xakc0bcw6wZvKr7gmO58cCDl3dwl4GzFu59+/alb9++J33+7bff5rbbbuOWW7QJwSeffMLMmTP58ssvefTRRwHYtGnTSbefNm0aycnJhIRoEdz+/fuzatWqkwr3V155heeee+5sT+Oy4DK7cBmd4eoProLNeo6p8tt/gwUvQr/XTyxkXZRkwe6ZUP/a4/t+n4zSbPjOuTgTUR8aXX/cS8zOVBWjrvLCV4dDtBJ3sq8489T73/SD9n+jYVjb3MPkhft4b/5e99NT9vsR33sGt9a1a2PJ3KSJ9qytWh/QsXMhoU31fRr8eTXmXabt3USJFEjbWmH03PM6XUsj+Orfol1VYfdsra9nXCstwlRRQIiz5YQrLcdFbJCJFwc35MFedVFVre4bYGdgRyhbhGHXDAzAfjWaxp0GuWvCO9SJ5FXdCB63T0Ze/REcXERgYRbXiUM5FH8tb17fmPHfrmfXsRKtXQnQsXYYbZOu7DZLIb56Qnz1Z/BKL168XCnkBKSSWHgI89Ht7scCs9cxx/Ao+0qTAa0Ex6Hz56ASSaFU/Trkd2QZAOb4E9+TvXjx4nnEh/oSH3oKgXgBMeokuqdE0j2levtYo17HWt+WhJf/Q44aQJt+o0+6j1A/w0lLCZ9uUopu83tIzuzMZUIznh3ajFKznYEfLmNDWiHvJd/KDPEIUIG+WutfTbg7XK1/5z2tiXbZBCkDoPgodHxAe843gmLfmnxY2J7Q0DDq+BlYf7iAF2fuBGdZ7CxHK6dw/+PEwn3P35U/O6xa9ml4XTi8Er7qA6G14ZZZx7e4c3FoifZ/6iAIrYXFrmU4V+06sEVuzBFbKLGWPC21v+F12v7/fgK6PXlq7XAFMCboS7YfLeKrsFQAZOfCgyuF/r/GBa1xt1qtrF+/nh49elQeQBTp0aMHK1euPKN9xMfHs2LFCsxmMw6Hg0WLFlG37slNzh577DGKiorc/9LTT2ACdoXgcLVOqyLcXT/bz1W460yaS+a312rmFidj61T46374aeSZ73v+89r/kgEaDD3+eVXFZtW+OK6WEwB2UYvMK1ZnFkFFgZZi9O8Ud79wFEMQX5e3p+0r892ifXznJJ4fpKVqvzwvjdXmeNTaPaHzw3DvJmh9B9w0DeJbHzcks83BtysPk08Ab1zXmKevSQEElu7NpbCoCEqc6aE2M9Zpt2p1QV/2RjmgmS0hypjR41AFRJ8TC+cgH71btAOY6najXNXO2azqeEr/IEPb1nM/L4oCMV1v41HbOBQEyN6BjzUPGQcDG8dQI9SXWfd0ZOnDXVn+aDfWPNGdb8a2uio6KXjx4uXKQg3T7qeGgt3uxxRFWzBUqkwJMmN60NX6Dl+ETKrcVlV5yzaEV2zDCWvaHy9evHi5kBSnjqBcNfB32Gjqxp5b8MJYozXFyZVt2AKbX0eYn4GaYb68OrQRAJ8uOUB+mZYOr6si3H/0G80t1ofIDW4KC1+GlR8CsL75K0wOeYTnw97g3XUVlJhtUKcXt/h8wNeO3tzYKoGvbmlJ4/ggJFHgnm7JfDaqBbMdrXhHuZHiXu+eeLB1+7Cwxr0Uqz7sjb8OnK2H2fKT9n/eXvhmMBxaDhu+OX77Q9pCqiWunfb/CYJper2eXxydtV82fgtluVoWwZH1sPTtM39jC9Ph4/Yw75kz3+YCoJXdChh12nsj67X5tyuF/r/GBe3flJubi8PhIDKy+ipaZGQku3btOqN9tGnThn79+tG0aVNEUaR79+4MHDjwpK83GAwYDAYmT57M5MmTcTiuXLMCV+pNVeHuEHXgALvVcootT0FSFy1anLFGMze7dR4YTpC6vPln7f8Gx5c3nJCjm2Djd9rPo/901zuSvQvKc8EQAHMf57NDS9mur0F+wdNAgvOcNBEbue9nPl/Ui2tXDCXMmqGlxLce7z6Eucsz9FzTjvSNdsBKhL+BB3vXZViLeFRVZc3BfP7akskNn63CpJOICDAQYNThox9MTLGJZ+PsBPpUSdUsOcaaA4WUWx1EBRgZ1ETzYagX5c+uYyXs//sTmu96ExoPh+yd6DPWYFdF0tVw3l3jxxs1FfQGf14VxrHbGsxzfmdWJ96mbhyz1rbmOmkJz9jH0KNn92oLGQDDWyfQbWl/JhXreVv/CZlqML+pnXiwYTQ4xX1VB1YvXrx4uRiY4hrAPggpP1jl0eP9P0TnwmHVTPmsYguzylORxPrcn1z7UgzXixcv/yF69x3M7Pg2DKh75i18j0MUCR7+Oce+BaE4g9a9h7uf6tsgio61w1i6N9f9mF6uDJLsNzVktZLPdfpwtyieHTqaOxdHAJWLnUv35vJE/xTWp5cgizqGNIslwKhjxp3tKLXYCTTpUFWVsOgavJcZjLRHxz3xkPXHs+QHNSSlkxYMswck8NCRjuRaWtPSFsy0UGeJZKvbtdr67TMgeztM0YxD/9lyGNFWRtcoC0Lf1yBtNQDXz3TwQcVn/HT0IY4Zgtlr+RWcte1Gncg0RydurCsS2fk2+P0uKHUGsQ4vh7I88D2DRZK/n4Csbdq/BkMhWlsEoeCw1t44ot7p9nDmFKZp7Zxr93D3oHctRshOx3yvcL+CeOmll3jppZfOapuJEycyceJEiouLCQwMvGhjOx/cLpVSpXD/LmAcLxwdxCMxXTmnMmXZAMO+gc86Q/YO+H0iXPdVpdAGOLZNSy8HDh45RmLRs9Dj2ZPvU1VhzqOAijV1KPvkFFJxmmAseR22TYfgRCjQJn71xcOso3LhwShoq5iBBdvYN+8L3qc7z+u+1lKOEju7v9zzdmSRXuIg3N/Iy9c2pGvdcGTnyqcgCLw6tBHZJRbWHMynwubgcF55tWH66CVe6hUDsh4M/rD0Ldqv+R+3SjdiTZ3gjlgPaBzDrmO7sRxcqaUibfgagGJ8ucN2LyuVVNQt2aQXalkhGyo6AFRLnzoVrRNDaamM4337tZT7JvBc64TjXmOQJe7vWYcHp1Ww2VKLUtVEyzoxhPod7xvgxYsXLxeLyOQmsAhiHUexWCowGEyoirbgXbWPuyvhR6mi3Hdmah4ySWG+xy1OevHixcv5IksiA86gZ/xpkXREjZly3MOCIPDswPr0eXcJNod2bdNLldcyvbPePbfUghrdmAXWVCYc7IwsCgxqEkuon56f1qSx/nABN32utarunhJBhL8zfVsUCDTp3Me6o0st7vlxI18tP8jeQ+l8kP4OkcD+skxq9b2LZftyyS3V5szrDxeQV2rR5oWR9Vna5HVSW95H6NRroTyPkuBU3tkdzEzDm6hHBOj0AMXDpvPRt9+zwxFH2Iq7AYgSCjikqwxq+Rpk9qgRDM64iWc27qfPntnYBR2FYhBhjhzYMxuaniYb9+AS2FHZ1k7551nEUTM0cf15N21uPXEVhFwAs2JVhR9v0nTLsG95xfIepToRH7UpEIzOoGkoWT3eK+2/wAVNlQ8LC0OSJLKysqo9npWVRVRU1IU8lEeiOh3FValSrBUb49itJlAi/Kv1VmkOWE7Rc7HkGMx+RIuAB0Rr4l3UwY7fNCf2qmESZ8rNBqU2iZteR1327qlbrO34HdJWosomxmb054b355I15WZ4J1WrqQcm2O4l0y/VvYlkqGwHViEFuH/+09GWbxy92GxorrWO+6IHTL8Ntv/G9PVaWcMNLeLpmRrpFu0u/AwyU8e3ZcfzvVn0YBem3dGWr8a05JkB2nHN677D8V4TmPMY5B9E3f4rEg72q7H0ql+Z9XFNIy2qParwdgqH/wn1riErqAmDLc+RHtSSL8e0xkcvsSGtkA1p2vvSrlboGUfATXqJZrWiSVMjuaNz0kkntNc2jaV2hB8H1WhyCGLghbg5efHixctZEBGTxKvqGMbaHuJgrnMx1Hm/UIXKa3BE9nJm6x9lXME77scKdy6kr7iatmEe2r7Uixcv/3lqhfsxtkOlW72uSsTd36jFM5/5Yztdtvbi1oNdQRB5a1hjpyleCt/e2hp/g+yOBN/Y8vhgjYt+DaJICPGhoNzGyr3H+M2hpbTXWP00zHqII4v+RyDaXF9S7WxcOQ8qCpi1NZNR/1vD4Kl5lNw0E6XHC9xif5LtaiJrlLoIqLBtOtOyY/jE1h87MsvURu7jyobK+euELslEBhjILDJzx8pAHrDewbPWkXxj7ky54HP6lssOO8rsRwD429EcmypRenAd5szd8NNNYC0Bh0XzoLoQZG13BxtZ8CKd1HX0k9a4I+46Z427jv9mxP2CCne9Xk/z5s2ZP7/SfVFRFObPn0/btm0v5KGOY/LkyaSmptKyZcuLepzzQXGZXUiVK2E+ek3kVWudlrMH3muktUo7WQuzjd/C6k/gz3u03xPawOCPNSfgdf/Tots4HTG3/gLAJ/ZrOKBEaV/4NG2lkMMrYO4TlV9cRdHM7oBlkTexLNtIKUZIXw1lOaA62Cg1ZFZuBPfmVda9y1VcKheEDGO6oyPdLW9QIRgRBYFxRWOxhDXQvuBbp8K00VxzUDvOkGaVPTRPhI9epmaYLy1rhtC1XgS3tE/kmkbRFKq+SNZi7b14vwlCWQ55qj+bdU1onViZ9lMj1JdGcYE4FJW3doZgHvoNQy3PcECN4fZOtehaL4Kfb2/L8FbxvDKkISsf68YPt7VBEs+8xvy1oQ15f3hTxrZPPOlrJFHgwd5afaleFqstLnjx4sXLpUAQRdZG3cBSpRF7cp33JPX4Fpt6ewkpYhqR9iPux2rs/56P9e/RR1h1KYfsxYsXLxeUu7vVJinMl8gAQzWT3Uk969C7fiSyKLizPJ8fWJ9BTSrnqY3jg5gythX+RpnkCD861Tl5Wr8siTzerx5+Bpk2jeoROupr/nK0RcYBaz5jROarNBH306VuOD/qX6TH8hGoH7Rg3dzvkbGTnl/BpAVl/GK8lnU54KuX+M2hZYXaNv7Ej2vS3Meaa65s46s3Vgr3nqmRLHm4K68MaUi9qAC2hvejovEtfOnoQ0vbZ5S3uOPUbw6nUlEAACoZSURBVFZ5LpmlKoWqLy9KE7lbmUS78reY/v1HkLcXh8GZ5bzpey3oeL5sm+7+Ua1SXmswaDpDb9CCnzL2M27zfDVx1qnypaWl7Nu3z/37wYMH2bRpEyEhISQkJDBp0iRGjx5NixYtaNWqFe+++y5lZWVul/mLxRWXKm8zawK69R0gSmAt55h/A5bbiyn1TXG/rJFtE6nSKoIzC4ER2oMHF4OtHI5ugAOLoFbXyv2W52uuk+u1dO+C1JH8vHg/w1rEE9Loei2qPfthrfbdta+STArxY6HSlK7KJpLEY1pdS2JHzaCiNAvyD8KN32sp9sO+Jm/u60zYqa0MiqLE1+ZOPKybCsCHFb0IMMqkG5rySdk1NBf3IEdXthAr8K3FA7Y7wRntNtsc/LMT3qjxKU/2zIBlb6NkrOdXR3uaJgSRdA7txB7vl0L3nVk8abuFSRHrCSncDqqDaY7OdKwf4053cjGydQ0eztjCt6sOM29HFseKzYT56bm+eRwADeMCeSWu0UmOdnqiA00MbGw67et6pUby0rUNiA40EmD0tlLy4sXLpadOpB/rDxewN6sEANUp3JUqEXecPwtV5kUh5ZoBql9Cw0s6Xi9evHi5kPgZZGbe0xFBqO7Anhzhz6ejWpBXamHW1kyCffVc0+j47MjmNYJZ8Wg3dJJ42iBPnwbR9GkQ7f790frPkbBjPI3Eg5SrBo4GNeedXnVZ83ESLcQ9COW5TFLf4BfdZ5gVkXk7sli8RxPE93SvzdqdEhz7H7rcHVxr/4KPdTfSKCGUWftbM0n9hWLVF72x+nzUIEsMb5XA8FZadoCqqqw5lEd6fgXL9+XRM9UZSLKUQvoqrb7fGAQd7mNuGtyR/wSJwjGeubkDgaauLJ+ylidze5AtlbDI0piXjd9S374XZdUniD2eOvcPRlXdwn2i9R46VzRz9jkBo1ET7rJvCOOt92M0GnkPYP8CCKoBoadpoXyVcNbCfd26dXTtWikkJ03SHGdHjx7NlClTuOGGG8jJyeHpp5/m2LFjNGnShDlz5hxnWHdVYzPD99dp/c8L0yG4Jix6BWLH8oz9Fq4LinO/tGHFerrqfmFTtrFSuLe6DWXPXMR982DNZ5pwVxSYMa7aShSmYB7flcTs3bv4ZX0G349rTWSzUVC7F/g73++gGuQGNmB2XhQRQf6sK01hOAsx71uK0RSkiXbQWsWtnAzt7qIiuB7XZd9CiVrGkKax+Bgkpq3qzJ2GOWQQyQKlKQ91qcXotjX5ZHEcPxZU8FqNys/XILvq1LWLzJGCCv7Zmc0vG4/yYJ+eGOr0pt+7S9iVVcqLzSrfi7MhJsjExK7JvPm3wu8FfXntmkT+WLCYf/IjeCf1+L+1YS3jMeklnvp9G8eKtTTPMe1qXvI6TUEQGNG6xiU9phcvXrxUpWGglTJxOQH7tkOvhyn1S+Rj+wB0gTVxFUC5PEIENFFfXl5GnOMoCBBTp9llHL0XL168nD8m/cnnf6F+Bka1rXnK7f3PMfgyrlsqozZP4m35Y5YqDenXNJH6MQH8aGoEtjkALFSaMKRlMrUi/Hjqt21Y7QoxgUZGt6tJQogPGb+EESfkMlH+g0OpD9AyMZQV+/PoYnkbAfhbd2p5JwgC3epG8PXKwyzYeYyeMVatZd3CV7TMWMAWlMQjR7vw68YjqIh0bd/e3cJv+p3t+GzJAf7JvIW92aV8YOnPu7rJ/LbuME0aFFMvKuCUxz8pGeug8DBlqoH5SlO2zdvJMAlsqoRRr73fBqOJuUpLfO2SFoT89loIiIX7tmqB0qo4bFomQFQjiL067ltnLdy7dOmCeprUhLvuuou77jpBv8KLyEVzlbeUar2+8/dD3j6wlGj9EhsMBUGCE/UGn/WAJtoNAVCvn7aduZD6R35BoBmmKmJR0GkpH3pLnvuxrGIzEw5cw3Tmoe6ejVBwCPbOqxTtAXEQXoe81NHM/aUIgH3Zpdzw6Uq+GdsaX0MQpXllRAeakAMTSC8V+MzRn3EdE9m6oz0c+Qh99hYwjAC/KIhuDHvnao6R8a35fE8QB3PLiAww8MyA+hSbbfy0Jp3W5e9iRyLUz8iYdjXx0cs80Ov4Vn3BPlraUb+G0dSJ9KdWuB+xQSaOFFbwv2UHqRXuy66sUvSyyIATrGSeKeM6JrFodw7rDhcw4Ze9QAw6SaDLSdxIBzSOoXViCC/M3EleqeW0F2UvXrx4uRppJB/mJv1kDuXGAw9TFFCH1+zDaesbyjjXiwTXfUq73x/es5kUQaEIP8KivIuPXrx48XIuJEf406R+fYZvexKAhU1jEQSBoHqdYOvrACxQmzOpQyJxwSY2Hi5gxsYjPNovBaNOomdqJPfp7uI923N85+jBja1rkBDigyCAXdU0SdV2cCejW0ok/6xcx8Nb74Ctxe7H1cA4dpua8tWROGYcywAErm0ay8N9Kuf7dSL9efP6xuBsQffN8lr0Xlifw4W+NJi2mb/u7nhub05RGlZdIPPM9TFjwM9+FCTQCQ5kZ1DQFXAz2xXUnD0IAMVHYN98qNOrcl+Kohl2b/lZa7PX6yWts5UgwNGNWlZZdOMzH5uqatnQet9zO7cLxBXpKn8unFeqfEUB6P2PF+GgpZ7PGFf9sT1ztBpyUQfj5kGgM2p8aBlkbtbaqAkiXD+F7NBWvLNax4s6f4LNaQwUV+Arxbt3VeCrecmn5syGP+6BthP5ZZvE+vJwluga0knaCmu/gKajILYFNLoBWt8OwLf/7EFR99IgNoDCchuH8srp9MZC97599RINYgNZXfYYfgaZ65rHEWjSkZ4eTryYgxqShHDPRs2Zfvo42D4Dx1+T+CHrIUDi8X4pBProCPTRMbhpLL+szwCn0YWP/uR/Ore0T8TPIDOyjTa5k0SBm1on8Mbc3bwxt7KdRs+UyOrt3M4So07ix9vb8MGCfXy4YC+KCm1rhZ1yFTQiwMgHw5ue9HkvXrx4udqJSm4CCzVnebO5wr0YX7UZictWXnA+l39wMwCZhpoECmfu/+HFixcvXqpzd7faLNydTcuaISSGaUKwbaMUftnUiQQhCzl1gNsg+a1hjXmkbz0iA5yp4pJInbbX0GZeOOERMdycEIQgCDSJD2Kj02C5avr/yWidGEKhLgK7KoAA6Hwo7voiE7ensnR/vjampFAe7VuPxvFBJ92PQZa4rXMdBjRJoN2r89l2pJj0/PJza3HcYCgv70nizzU76VQnnCYHK53sXVlgBllkoLgCvWBjpnA7RfbujJDno6z/GrGqcJ/3lCbaARS75ofVfAzojFqG8dZfoNND0OVRLVJfng+FhyGy4fF6sPgoTB2tGeeN/gPiWhw/9sMrtCzrmn3O/rzPgqtGuJ8TJVkw/3nY/COEJmvO7KG1YNdMqD9Ye41PKCT3AP8oCKmlffjrp2irOwDrvoLuT2krPT8M054H6PEcJHfnuR82MHNLPi39OzGEmbyn/4hZxVFAEwDSonrz7u4N3CfP0NqUbfiaAN31wLVMcfTWhPuGb6HL43Dr35r5HOBQVH5eq7my39YxiZY1Qxg7ZS27jmkpLnpZpMzqYPVB7ct3fYs4/I06etWPYt5vKcSquaTv2YTVvxU6yUzNAe9BeS4HS/VkmQWSwn2r1fVM6FKLv7YcJTLAyE0naHdWlahAI3d3r97jd2TrGqw6kEdGQQVlFjs6SeT2TuffNkIniUzqWYfOdcL5duWhak6hXrx48eLleEKjEynFhJ9QwaG9W5GsQdQQjhGsVApy0VXj7kyVt2duB6A8sM5lGrUXL168XB2kxgSw/JFu+BoqZVjrpBDaGu4lv8zCX10qjeYEQXCLdhe3d0rCoaj0rh/lFrQ9UiKrCPfTR9yNOol2tSOYsPNe7q+bj6HVGMbPOERuaT4mncRzA+tzfYs49/5PR1SgkVaJIVgOrsb60xQY/0M1M+4TkrkFlr0D+QcgvjX0e52lB4vII5ARrRM4UON+vl+YS4a+Jo9UGfcbuk8xCDZGLm5NlqM3I+T5WlC1JEsrFV7+Hqx0utxf+ymYi6F2D020AyR1ha3TtBbXaSu1DOm9f4Ni0/Rbh/u011nL4OgmzQ+sLFt7bP5zMPrPynMozYG5j2vG2wC93j+j9+tcuWqE+xmlypccgy1Tob3TiV2UYfuvoDogdzd83hVim2tp7tmPQtfHtKjDyOnV99Phfu0DBqjdW/tfEEE2grUUGlwH7e5mc3ohM7dkauMr7cIQw0yo0uccoEOdMIbOv450onjT8AWCw8qyslj0ssgiexP2KTHEJLTCx1IM+sqWeot2Z5NZZCbYR0fv+lEYdRKz7+1IsdmOn0FGAHZkFrNodzZHCs3c000T0n4GmXW17uKZnaMoXuILS5YAMK5DIvfd+CvDXl+IipWJXZKrGW4khfux4IEu+Oilc6oLD/TR8e2trc96uzOleY1gmtcIvmj79+LFi5erBUEUOaqrQR3bLgoObyHSYWOx4VG25jUD+gGgSEaOqcEUCVoGm0/hHgCkqPqn3LcXL168eDk9oX6Gar/rJJGfx7ehxGwnNebUNeJGncT9PasvonZPieCNubuRROGMhDtAt3oRPLajHvdkGCjcsxe7olIvyp8Pb2pKcoT/GeyhOv3rBdLvyJuEZpfAwpeg3T1aVrNPKJiqRO0LDsHfT2l19S58QskqNrM/pwxBgDaJoXSvF8F7jleoF1FpYq2XRMqQMWAjPbeQw2oc65XaNBf3wuYfIDC+srNWrxeh8Y3HD7TpCJD08Oe9muarSoPKjlksfw8Wv6b9HJ6ilT4fXAKHV0KNtlqm9U8jwOzszBVWV1uAuIhcNcL9uFT5P+6B/s9BcJVavEWvwJ65mtO7rAffUOj/FviFw/L3NQf2Q0tBlLFGN8Nstp3Y+VvSQb3+1R+r1RXHuAUoB5ehazYCFXh19i4A/A0y+y2xrHCk0kbcSX5oc/dmzWuE0CE5jOn7OhCf2oYQy1Hm7k5gaJMYjhVX0Hffq4wNqsNj/ppoV1UVQRDcLSCGNotzC2lBEAg0VY63QWwgDWKPLxvo36E53+9c7R5bicXOF8sOMnfHMfLLrCSE+DCoyfG15zFBp3dN9+LFixcvVz7F/rUgfxfWzJ0YwjU33qp93Atj2jPEMplG4YH8pqg8Zb6JGva2PNKw72UctRcvXrxcvdQ6hy5LLupG+vNQ77oYdRKydGbCvWvdCAByS7XWoAMax/D60EanNO47Fd0bJfLUnFv4SP++Fklf9o72hE+YljUcWktLSf96ABSmaVnEDYZCw+vAL4KV+zW/rwYxge5S2n97aYmigL9QAcBC/QMMDf2Vn7K60vz/7d15fFNV2gfwX5I26Z5036AbS0tLNwoNZUAFKoUXGRRGERkpCqLQERUGR0alqK/AWAcctQizgb4qm8PiimChMkBtobRQaKm0FMrShe77ft4/AoHYshRCk9Tf9/O5H5N7T26e4NObPPeee470NDrSP4F05nZUWnrjv5Kh+CxrKOQ5qXhsaF9MCv1FXRPyKOAeopkC28FPcyuys7/OAHeirlTT7yzwEcgmf6AZC6w4S3Pht/QUsPEJoLkacAsGJv1Nc/G3pgb3Uq8p3Ds5uQ0o3APM/RFw6g+0twE5XwEN5cCFNDT3iUJTSweUYdM17f1GA8krgWObUDjkZUzfYY6i6t0Y6uOAcYGucLCWo7apTTOyo8oSXg5WqGhowcG8MqSeKcfFqiZU1DdDKnHHb8+dQnhfFVLOlEMuk+KT2ZGYtu4nxLa+AhXq8JKqv06oL0QPwIG8Mnx4whwW5n4A2jA1whONLe04mFeOz9MKYaMww85jl5B/uQ5ymRTNbZrui9Nv0W29KyP6OSH9tWiYyaRQWppjZ+ZFLN56HOcrNH8I8x/od9t/9EREZHqEcwBQ8Q0sKn9Gh9PVW4yu9bK62j2yQwicr2zAqRZnnDFzRaLfoBvskYiIDEUikSBudP/baHmNm9ICw/0ckFpQgcUx/ph3f7/b7hrfFQ+VJS54xGBD8SnMMtP0TG6HDLKGMoiNj0MyNxnY/ixQVYgSmTsujv8Xhgz7jfb1h1I0Y6mM6Od4W+9XAnuseCwCL3zShB9qD0PVbwaKC2X4c+VrqIUlRIXmduH/ni5DhxCYHOYJXDlR0dEh4OLsD0z7vy73famqEa+UTkdq0/3wveSItbUS+IxfqeldXVcK/DNaU7T3HQ7M3In8qjacPlGEqL53cG9/N/Tewt0lEKjOAVLXAhPf1VxJbygHrBzR4hGJ332UglPFNVj1WJjmLIxUBox5Ff9RxmLJ9iy0tGmK2LSCCqRduU/8dnQIgW1HL2LbUc098DOjvBHuZY+pEZ7YmHYel6HqNNrjMB/NVfcDeWWoa26Dp8oSw301SevjaIWz5Q34656fte2vFu1jAlzu+Ozc9V10Jod5wkNlifmfHYWbnQWm3OEUbUREZBpsPAcDuYBT4xmUXrmPXVz3g+3qIyGAnCLNFQR/V1ue1CUi6kX+PWsYKhta4amnXrUxQW5YdiEWB/rMRZuZFU7mFWCbfBnO2P8O9zdWouXSCXQIczzV8Dyy/1OFqQXH8OrEQXCwluPQlSvuUbdZuCfZP4bfu9khJswPc/YuRtg5FfKPZKMW1pge6YUR/Rzx48+X8UX6BSzacgwSiQQZhZX47KdCmMkk2Dw3CsF9dHsmd3QIbD5yHsu/yUFtcxsAOU4V12LShwew+rEwRAdaAnXFmhHmHfoBj3+ORmGOGf84iOKaJrwWdPs1453oNYV7p3vcR78G7JgBHNsERC8Dsndo1gc8hH8dOo+si5pp1F7YlIGm1naE9FFh1Z5cfH9SM6/5mAAX/Gl8AA7ll+HHny+jvUPA1sIMMqkUl6oaUVjRAIWZFCP6OeI3/Z3Q38UGzrYKXKxsxEfJ+didXQJHa7n27Nczo/yw6fB5CAGd6eCuunrVHQCmDvGE9Mr95S+PD8Aftx7DEC97PBzuid/0d0R7h0Bbu0Afe/11XR/m44DUJWPRLgTM+cOMiKhXcwsaidm7FiFX9MXylsora68V7nYVWfiPPB6VdX1QkTMN82TJsFbeb7B4iYhI/6zkZjedKaq7YoJckfB9Ln442wKgBWZSB0S3JEBkW+CL+23wlvQdWLZmod4hEJKKBvzn6AV8k3UJYwNccaGyEWZSCYb5ONz0PV61+19YlOfgvgkLAQC/DfPA+3vzkHlec695uJcKb04OgrlMionB7mhu68BXxy5hwcYM7T5a2oE5nxzGl38YqR3876cz5Xjr62ycvFSj3c/LMQH46+5cHDlXiTmfHMGsET54ZcJgWMz5ARAdgLUj/rX3NIprmjT7Pb5Nb/+WXZGIW03KbmKu3uN+uawcTp9Fa+Zfn/hXYN9yoKEcZVO2YNRWgcbWdoT1VWn/J0skmisLEolmmoYXxw7QFs934kJlA+RmUrjYXhsJMn7nCWzLuIhdL97X5ZmtBRszcDCvDF8+P1JvZ76IiIi6ErUiCUXVTfiLbwamFSUg0yoKYS/vAgBk7d+J4L0zUSD1QZ7NEDxYsw0nvWYg6Ok1hg6biIiM2Ji/JuPM5XpYy2XY8HQk1v2Yjx9ySqEw09zq62gtx+6X7sO5iga8tv0Esouu3Rc+1NseX8wbcdP955XW4nxFI0YHuGjXTXz/vzh5qQY2CjN898IonenoWto6MOeTI9j/82UEeyqxYOwAvLPrFE6X1iHYU4mpQzzx9fEiHDmnOYltqzDDC9ED8NRvfCGTStDS1oHl3+Zgw6GzAIB+ztZYPS0MIX1UuFzbjAcS9qG+pR1qXwfknzqO9PeeQ3V1Nezsbj7I4J3oNVfcf+nZT4/i09CZsEyOB75ZpFlp5YjXM1VobC1DpI8DNs0djre+ycb6g2chBPA/wW54MXogBrp2fyTFX+pj3/keh2W/DUL8pKAbnhD42+OaKeLu5v4SIiKi2xHkoURRdROKquqvrLmuq7z2e0rAqVYz0KpF3zADRElERKbkpeiB+NeBArz+0CBEeDvA29EK6av3o7KhFQCwfEowHG0UcLRR4JsFI5Fxvgpbj5zHT2cqMPs2pnXu72LbadT7uNH9sezLk3hz8uBOc8jLzaRYP2sY8krrMMDFBlKpBP6utpiceABZF6u1vbClEuAJtRdeih6oc0ux3EyKZb8NwgP+znj5i+PIv1yPR9YcwpyRvqhsaEF9SztC+yjx+TPDEbehDel6+nfsSq+94t73xS0I91Dgs5DjsCk7Dpz+Hhf8HsPI7Ichk0rw7YJR8HezhRACyT9fhpudBQa56//MCBERkTH6ZOd3uJz2BfpKy1AvFDB3D8Lv4+IBACcOfoXBe36PAvSBkyiHraQRtU/vh61XqKHDJiIiE7P7ZDHmf3YUjw3ri+WPBBs6HADA4bMVmP/ZUXiqLDEp1AMTg93hprS46Wsq61uw9MuT+OrYJZ31m+cOh9rPEZcrKuHi6MAr7t3lrrTAsXIpni4Yi88mP4wGVQBePeIMAJg90hf+bpozNRKJRDsdAhER0a9FuHkhgs2/QGpHAKa1LsUEpRt+f2WbRKIZi8VTFEEuaUczzGHrGWjQeImIyDSNC3JDZvw4WN/hVHP3wjAfBxx+Nbpbr7G3luOD6eGYHOqB13eeQFF1Ex4MdIXaTzOgnsLs3n6+XlO4/3Jwur/PjMCMj7OQdrYC/5tmi6OF45DVWI2QPkosGjfQ0OESEREZlMvAYUAaECg5Bwk6IJV0ng5OLtF8p15S+MFXZm6wWImIyLTZKHpN2YnoQFeo/Rzw39NleMDfucfet9cMHx4XF4fs7GwcPnwYAODrZIN3H9V06fs45RyyLlZDZWWONTOG3POzIURERMbOxWew5kq6pBHhkjxYdNRpt0mkuj8PalRBBoiQiIjIONlamON/gt31Oir/rfSawr0r4we74dn7/YAro8b/7fHwLgeNIyIi+rWRmMlxydwbALBNsQxPlK66tlFqhhpx7fvSzDPEECESERHRFb2nz8INLB7nD3srOXydrHH/wJ7rykBERGTsapSDgLI8zRPJtXP5DS5DENL8T5ijDQMkF7Au/CHDBUlERES9v3A3k0nx3P39DB0GERGR0ZF6hABlXwEAxPXTwV152AozFMr7w9PTy1AhEhERUW/vKk9EREQ35tAv4rpn1wr36weqC3CzhVQqARERERlOryncExMTERgYiGHDhhk6FCIiIpPgHhCFbeIBAIC4rqu8Rc0ZnLV4AmctnsBEm1wDRkhEREToTYX7L0eVJyIiopuTKqxQb6sZxBXXXWWXtdZrH4fKLxkiNCIiIrpOrynciYiIqPvc7BQAAHHdTwLJdVffbX2HGiQuIiIiuoaFOxER0a/YQG8PAICHUq5dJ2ut0T7uMyjSIHERERHRNb1+VHkiIiK6Me8HngLszNAn6BHtOqd+EWiDDJUyZzjb2hs0PiIiIgIkQghh6CD0qaamBkqlEtXV1bCzszN0OERERCapuaYUcktbSMwtDR0KERGR0bvXdSivuBMREVEnCjsXQ4dAREREV/AedyIiIiIiIiIjxsKdiIiIiIiIyIj1msI9MTERgYGBGDZsmKFDISIiIiIiItIbDk5HREREREREdBfudR3aa664ExEREREREfVGLNyJiIiIiIiIjBgLdyIiIiIiIiIjxsKdiIiIiIiIyIixcCciIiIiIiIyYizciYiIiIiIiIwYC3ciIiIiIiIiI2aUhfu7776LoKAgDB48GJ9++qmhwyEiIiIiIiIyGDNDB/BLWVlZ+Pzzz5Geng4hBEaPHo2HHnoIKpXK0KERERERERER9Tiju+Kek5ODqKgoWFhYwNLSEqGhodi1a5ehwyIiIiIiIiIyiG4X7vv378ekSZPg4eEBiUSCHTt2dGqTmJgIHx8fWFhYQK1WIy0t7bb3P3jwYCQnJ6OqqgqVlZVITk7GxYsXuxsmERERERERUa/Q7a7y9fX1CA0NxdNPP40pU6Z02r5582YsXLgQa9euhVqtxnvvvYeYmBjk5ubCxcUFABAWFoa2trZOr929ezcCAwOxYMECjBkzBkqlEsOHD4dMJrthPM3NzWhubtY+r66uBgDU1NR096MRERERERERddvV+lMIcW/eQNwFAGL79u066yIjI0VcXJz2eXt7u/Dw8BArVqy4o/eYPXu2+Prrr2+4PT4+XgDgwoULFy5cuHDhwoULFy5cDLrk5+ffUd17K3odnK6lpQXp6elYsmSJdp1UKkV0dDRSUlJuez+lpaVwcXFBbm4u0tLSsHbt2hu2XbJkCRYuXKh9XlVVBW9vbxQWFkKpVN7FpyG6uZqaGvTt2xfnz5+HnZ2docOhXoy5Rj2FuUY9hblGPYW5Rj2luroaXl5ecHBwuCf712vhXlZWhvb2dri6uuqsd3V1xalTp257P5MnT0Z1dTWsra2xfv16mJndOEyFQgGFQtFpvVKp5B8n9Qg7OzvmGvUI5hr1FOYa9RTmGvUU5hr1FKn03oz/bnTTwQHo1tV5IiIiIiIiot5Mr6cDnJycIJPJUFJSorO+pKQEbm5u+nwrIiIiIiIiol8FvRbucrkcERERSEpK0q7r6OhAUlISoqKi9PlWN6RQKBAfH99l93kifWKuUU9hrlFPYa5RT2GuUU9hrlFPude5JhHdHK++rq4OeXl5AIDw8HCsWrUKo0ePhoODA7y8vLB582bExsZi3bp1iIyMxHvvvYctW7bg1KlTne59JyIiIiIiIqKb63bhnpycjNGjR3daHxsbiw0bNgAAPvzwQyQkJKC4uBhhYWF4//33oVar9Rc1ERERERER0a9Etwt3IiIiIiIiIuo592aseiIiIiIiIiLSCxbuREREREREREaMhTsRERERERGRETPpwv3tt9/GiBEjYGVlBZVK1WUbiUTSadm0aZNOm+TkZAwZMgQKhQL9+/fXDrJHdNXt5FphYSEmTpwIKysruLi4YPHixWhra9Npw1yj7vLx8el0DFu5cqVOm+PHj2PUqFGwsLBA37598c477xgsXjJtiYmJ8PHxgYWFBdRqNdLS0gwdEpm4ZcuWdTqGBQQEaLc3NTUhLi4Ojo6OsLGxwdSpU1FSUmLQmMk07N+/H5MmTYKHhwckEgl27Nihs10IgaVLl8Ld3R2WlpaIjo7G6dOnddpUVFRgxowZsLOzg0qlwuzZs1FXV9fDn4SM3a1ybdasWZ2Oc+PHj9dpo49cM+nCvaWlBY8++ijmzZt303br169HUVGRdnn44Ye12woKCjBx4kSMHj0amZmZePHFFzFnzhx8//33PfAJyFTcKtfa29sxceJEtLS04NChQ/j444+xYcMGLF26VNuGuUZ36s0339Q5hj3//PPabTU1NRg3bhy8vb2Rnp6OhIQELFu2DH//+98NGjOZns2bN2PhwoWIj4/H0aNHERoaipiYGJSWlho6NDJxQUFBOsewAwcOaLe99NJL+Oqrr7B161b8+OOPuHTpEqZMmWLQeMk01NfXIzQ0FImJiV1uf+edd/D+++9j7dq1SE1NhbW1NWJiYtDU1KRtM2PGDJw8eRJ79uzB119/jf3792Pu3Lk9+CnIFNwq1wBg/PjxOse5jRs36mzXS66JXmD9+vVCqVR2uQ2A2L59+w1f+/LLL4ugoCCdddOmTRMxMTF6j5NM341y7dtvvxVSqVQUFxdr13300UfCzs5ONDc3C8Fcozvk7e0tVq9efcPta9asEfb29to8E0KIP/3pT8Lf37+HIqTeIjIyUsTFxWmft7e3Cw8PD7FixQqDxkWmLT4+XoSGhna5raqqSpibm4utW7dq1+Xk5AgAIiUlpQejJFP3y9/7HR0dws3NTSQkJGjXVVVVCYVCITZu3CiEECI7O1sAEIcPH9a2+e6774REIhEXL17s4U9ApqKr2jI2NlZMnjz5hq/RV66Z9BX32xUXFwcnJydERkbi3//+N66fAS8lJQXR0dE67WNiYpCSkmKASMlUpaSkIDg4GK6urtp1MTExqKmpwcmTJ7VtmGt0J1auXAlHR0eEh4cjISFB5xaMlJQU3HfffZDL5dp1MTExyM3NRWVlpYEiJlPT0tKC9PR0nWOUVCpFdHQ0j1F0106fPg0PDw/4+flhxowZKCwsBACkp6ejtbVVJ+8CAgLg5eXFvKO7UlBQgOLiYp3cUiqVUKvV2txKSUmBSqXC0KFDtW2io6MhlUqRmppqkLjJdCUnJ8PFxQX+/v6YN28eysvLtdv0lWtmeo/ayLz55psYM2YMrKyssHv3bsyfPx91dXVYsGABAKC4uFin2AIAV1dX1NTUoLGxEZaWlgaKnEzJjfLo6rabtWGu0c0sWLAAQ4YMgYODAw4dOoQlS5agqKgIq1atAq7kla+vr85rrs89e3t7g8RNpqWsrAzt7e1dHqNOnTplsLjI9KnVamzYsAH+/v4oKirCG2+8gVGjRuHEiRMoLi6GXC7vNHaMq6ur9ruT6E5czZ+ujmnX/y5zcXHR2W5mZgYHBwfmH3XL+PHjMWXKFPj6+iI/Px9//vOfMWHCBKSkpEAmk+kt14yucH/llVfwl7/85aZtcnJydAY2uZnXX39d+zg8PBz19fVISEjQFu7066XvXCO6Xd3JvYULF2rXhYSEQC6X49lnn8WKFSugUCh6IFoiojs3YcIE7eOQkBCo1Wp4e3tjy5YtPGFNRL3C448/rn0cHByMkJAQ9OvXD8nJyRg7dqze3sfoCvdFixZh1qxZN23j5+d3x/tXq9V466230NzcDIVCATc3t06jl5aUlMDOzo5fKL2cPnPNzc2t0+jLV/PKzc1N+1/mGuEuc0+tVqOtrQ1nz56Fv7//DfMK1+Ue0a04OTlBJpN1mUvMI9InlUqFgQMHIi8vDw8++CBaWlpQVVWlc9WdeUd362r+lJSUwN3dXbu+pKQEYWFh2ja/HHyzra0NFRUVzD+6K35+fnByckJeXh7Gjh2rt1wzusLd2dkZzs7O92z/mZmZsLe3116pioqKwrfffqvTZs+ePYiKirpnMZBx0GeuRUVF4e2330Zpaam2K8yePXtgZ2eHwMBAbRvmGuEucy8zMxNSqVSbZ1FRUXj11VfR2toKc3Nz4Epe+fv7s5s83Ta5XI6IiAgkJSVpZ17p6OhAUlIS/vCHPxg6POpF6urqkJ+fjyeffBIREREwNzdHUlISpk6dCgDIzc1FYWEhvxvprvj6+sLNzQ1JSUnaQr2mpgapqanaGYKioqJQVVWF9PR0REREAAD27t2Ljo4OqNVqg8ZPpu3ChQsoLy/XnjTSW67d4YB6RuHcuXMiIyNDvPHGG8LGxkZkZGSIjIwMUVtbK4QQ4ssvvxT/+Mc/RFZWljh9+rRYs2aNsLKyEkuXLtXu48yZM8LKykosXrxY5OTkiMTERCGTycSuXbsM+MnI2Nwq19ra2sTgwYPFuHHjRGZmpti1a5dwdnYWS5Ys0e6DuUbddejQIbF69WqRmZkp8vPzxaeffiqcnZ3FzJkztW2qqqqEq6urePLJJ8WJEyfEpk2bhJWVlVi3bp1BYyfTs2nTJqFQKMSGDRtEdna2mDt3rlCpVDqzZRB116JFi0RycrIoKCgQBw8eFNHR0cLJyUmUlpYKIYR47rnnhJeXl9i7d684cuSIiIqKElFRUYYOm0xAbW2t9vcYALFq1SqRkZEhzp07J4QQYuXKlUKlUomdO3eK48ePi8mTJwtfX1/R2Nio3cf48eNFeHi4SE1NFQcOHBADBgwQ06dPN+CnImN0s1yrra0Vf/zjH0VKSoooKCgQP/zwgxgyZIgYMGCAaGpq0u5DH7lm0oV7bGysANBp2bdvnxBXhtkPCwsTNjY2wtraWoSGhoq1a9eK9vZ2nf3s27dPhIWFCblcLvz8/MT69esN9InIWN0q14QQ4uzZs2LChAnC0tJSODk5iUWLFonW1lad/TDXqDvS09OFWq0WSqVSWFhYiEGDBonly5frfBEIIcSxY8fEyJEjhUKhEJ6enmLlypUGi5lM2wcffCC8vLyEXC4XkZGR4qeffjJ0SGTipk2bJtzd3YVcLheenp5i2rRpIi8vT7u9sbFRzJ8/X9jb2wsrKyvxyCOPiKKiIoPGTKZh3759Xf42i42NFeLKlHCvv/66cHV1FQqFQowdO1bk5ubq7KO8vFxMnz5d2NjYCDs7O/HUU09pL8oQXXWzXGtoaBDjxo0Tzs7OwtzcXHh7e4tnnnmm00lvfeSaRFw/NxoRERERERERGZVfxTzuRERERERERKaKhTsRERERERGREWPhTkRERERERGTEWLgTERERERERGTEW7kRERERERERGjIU7ERERERERkRFj4U5ERERERERkxFi4ExERERERERkxFu5ERERERERERoyFOxEREREREZERY+FOREREREREZMT+Hx0pNMab1sDvAAAAAElFTkSuQmCC", + "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": 13, + "id": "519a5651-2dfd-4223-acc0-b4475221dc64", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "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": "markdown", + "id": "46bd964c-1107-491b-a884-0131e624620b", + "metadata": {}, + "source": [ + "# Test TACAW" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "ee9b7e77-d5f7-416a-b82b-be15d0bb7657", + "metadata": {}, + "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\n", + "tacaw = TACAWData(wf, chunkFFT=True, chunk_size_time=2, force_rerun=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "0ad973ef-519d-4bcb-9f08-142c0600b028", + "metadata": {}, + "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": 26, + "id": "a6be77c9-ce5d-42e1-ba20-fbfb3a370a51", + "metadata": {}, + "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": { + "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 +} 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}%)")