aobasis 1.0.0__tar.gz

aobasis-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jacob Taylor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aobasis-1.0.0/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: aobasis
+Version: 1.0.0
+Summary: A package for generating AO basis sets (KL, Zernike, Fourier)
+Author-email: Jacob Taylor <jtaylor@keck.hawaii.edu>
+License: MIT License
+        
+        Copyright (c) 2025 Jacob Taylor
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/jacotay7/aobasis
+Project-URL: Bug Tracker, https://github.com/jacotay7/aobasis/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: matplotlib>=3.5
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: imageio; extra == "dev"
+Dynamic: license-file
+
+# AO Basis (aobasis)
+
+A Python package for generating various modal basis sets for Adaptive Optics (AO) systems. This tool allows you to easily create, visualize, and save basis sets for any deformable mirror geometry.
+
+## Features
+
+- **Karhunen-Loève (KL) Modes**: Optimized for atmospheric turbulence (Von Kármán spectrum).
+  - Optional GPU acceleration available for large systems (requires CuPy).
+- **Zernike Polynomials**: Standard optical aberration modes (Noll indexing).
+- **Fourier Modes**: Sinusoidal basis sets.
+- **Zonal Basis**: Single actuator pokes (Identity).
+- **Hadamard Basis**: Orthogonal binary patterns for calibration.
+- **Flexible Geometry**: Works with arbitrary actuator positions (defaulting to circular grids).
+- **Piston Removal**: Option to exclude piston/DC modes from generation.
+- **Visualization**: Built-in plotting tools for quick inspection.
+- **Serialization**: Save and load basis sets to/from `.npz` files.
+
+## Installation
+
+### Prerequisites
+- Python 3.8 or higher
+- (Optional) For GPU-accelerated KL generation: CUDA-compatible GPU and CuPy
+
+### Install from Source
+Clone the repository and install using pip:
+
+```bash
+git clone https://github.com/jacotay7/aobasis.git
+cd aobasis
+pip install .
+```
+
+For development (editable install with test dependencies):
+```bash
+pip install -e ".[dev]"
+```
+
+### GPU Acceleration (Optional)
+To enable GPU acceleration for KL basis generation, you need to install CuPy and ensure you have a CUDA-compatible GPU.
+
+#### Requirements
+- NVIDIA GPU with CUDA support
+- CUDA Toolkit (version 11.x or 12.x)
+
+#### Installation via Conda (Recommended)
+This method automatically handles CUDA dependencies:
+
+```bash
+# Create a new conda environment (optional but recommended)
+conda create -n aobasis python=3.12
+conda activate aobasis
+
+# Install CuPy from conda-forge (auto-detects CUDA version)
+conda install -c conda-forge cupy
+
+# Install CUDA toolkit if not already present
+conda install -c nvidia cuda-toolkit
+```
+
+#### Installation via Pip
+If you prefer pip and already have CUDA installed on your system:
+
+```bash
+# For CUDA 12.x
+pip install cupy-cuda12x
+
+# For CUDA 11.x
+pip install cupy-cuda11x
+```
+
+#### Verify Installation
+Test that CuPy is working correctly:
+
+```python
+import cupy as cp
+print(f"CuPy version: {cp.__version__}")
+print(f"CUDA available: {cp.cuda.is_available()}")
+
+# Simple test
+a = cp.array([1, 2, 3])
+b = cp.array([4, 5, 6])
+print(f"Sum: {cp.asnumpy(a + b)}")  # Should print [5, 7, 9]
+```
+
+If you encounter any issues, consult the [CuPy installation guide](https://docs.cupy.dev/en/stable/install.html).
+
+## Quick Start
+
+Here is a simple example of generating and plotting KL modes for a 10-meter telescope:
+
+```python
+from aobasis import KLBasisGenerator, make_circular_actuator_grid
+
+# 1. Define the actuator geometry
+positions = make_circular_actuator_grid(telescope_diameter=10.0, grid_size=20)
+
+# 2. Initialize the generator (use_gpu=True for GPU acceleration if available)
+kl_gen = KLBasisGenerator(positions, fried_parameter=0.16, outer_scale=30.0, use_gpu=False)
+
+# 3. Generate modes (excluding piston)
+modes = kl_gen.generate(n_modes=50, ignore_piston=True)
+
+# 4. Plot the first 6 modes
+kl_gen.plot(count=6, title_prefix="KL Mode")
+
+# 5. Save to disk
+kl_gen.save("my_kl_basis.npz")
+```
+
+## Performance
+
+Generation times for 100 modes benchmarked on the following system:
+- **CPU**: AMD Ryzen 9 9950X3D (16-core, 32-thread)
+- **GPU**: NVIDIA GeForce RTX 5090 (32 GB)
+- **OS**: Linux (Ubuntu)
+
+| Basis | 16x16 Grid (~170 acts) | 32x32 Grid (~740 acts) | 64x64 Grid (~3100 acts) |
+|-------|------------------------|------------------------|-------------------------|
+| **KL (CPU)** | 0.010s | 0.170s | 3.008s |
+| **KL (GPU)** | 0.005s | 0.019s | 0.202s |
+| **Zernike** | 0.001s | 0.002s | 0.005s |
+| **Fourier** | <0.001s | 0.001s | 0.003s |
+| **Zonal** | <0.001s | <0.001s | 0.003s |
+| **Hadamard** | <0.001s | 0.001s | 0.031s |
+
+*Note: KL basis generation is computationally intensive ($O(N^3)$) due to the dense covariance matrix diagonalization. GPU acceleration provides significant speedup (8-15x) for larger grids.*
+
+## Tutorials
+
+We provide Jupyter notebooks to help you get started.
+
+1.  **Getting Started**: `tutorials/getting_started.ipynb` covers all supported basis types and features.
+
+To run the tutorials:
+```bash
+# Install Jupyter if you haven't already
+pip install jupyter
+
+# Launch the notebook server
+jupyter notebook tutorials/getting_started.ipynb
+```
+
+## Development & Testing
+
+This project uses `pytest` for testing. To run the test suite:
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1.  Fork the repository.
+2.  Create your feature branch (`git checkout -b feature/AmazingFeature`).
+3.  Commit your changes (`git commit -m 'Add some AmazingFeature'`).
+4.  Push to the branch (`git push origin feature/AmazingFeature`).
+5.  Open a Pull Request.
+
+## Issues
+
+If you encounter any bugs or have feature requests, please file an issue on the [GitHub Issues](https://github.com/jacotay7/aobasis/issues) page.
+
+## Contact
+
+For questions or support, please contact:
+
+**User Name**  
+Email: jtaylor@keck.hawaii.edu
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

aobasis-1.0.0/README.md

@@ -0,0 +1,178 @@
+# AO Basis (aobasis)
+
+A Python package for generating various modal basis sets for Adaptive Optics (AO) systems. This tool allows you to easily create, visualize, and save basis sets for any deformable mirror geometry.
+
+## Features
+
+- **Karhunen-Loève (KL) Modes**: Optimized for atmospheric turbulence (Von Kármán spectrum).
+  - Optional GPU acceleration available for large systems (requires CuPy).
+- **Zernike Polynomials**: Standard optical aberration modes (Noll indexing).
+- **Fourier Modes**: Sinusoidal basis sets.
+- **Zonal Basis**: Single actuator pokes (Identity).
+- **Hadamard Basis**: Orthogonal binary patterns for calibration.
+- **Flexible Geometry**: Works with arbitrary actuator positions (defaulting to circular grids).
+- **Piston Removal**: Option to exclude piston/DC modes from generation.
+- **Visualization**: Built-in plotting tools for quick inspection.
+- **Serialization**: Save and load basis sets to/from `.npz` files.
+
+## Installation
+
+### Prerequisites
+- Python 3.8 or higher
+- (Optional) For GPU-accelerated KL generation: CUDA-compatible GPU and CuPy
+
+### Install from Source
+Clone the repository and install using pip:
+
+```bash
+git clone https://github.com/jacotay7/aobasis.git
+cd aobasis
+pip install .
+```
+
+For development (editable install with test dependencies):
+```bash
+pip install -e ".[dev]"
+```
+
+### GPU Acceleration (Optional)
+To enable GPU acceleration for KL basis generation, you need to install CuPy and ensure you have a CUDA-compatible GPU.
+
+#### Requirements
+- NVIDIA GPU with CUDA support
+- CUDA Toolkit (version 11.x or 12.x)
+
+#### Installation via Conda (Recommended)
+This method automatically handles CUDA dependencies:
+
+```bash
+# Create a new conda environment (optional but recommended)
+conda create -n aobasis python=3.12
+conda activate aobasis
+
+# Install CuPy from conda-forge (auto-detects CUDA version)
+conda install -c conda-forge cupy
+
+# Install CUDA toolkit if not already present
+conda install -c nvidia cuda-toolkit
+```
+
+#### Installation via Pip
+If you prefer pip and already have CUDA installed on your system:
+
+```bash
+# For CUDA 12.x
+pip install cupy-cuda12x
+
+# For CUDA 11.x
+pip install cupy-cuda11x
+```
+
+#### Verify Installation
+Test that CuPy is working correctly:
+
+```python
+import cupy as cp
+print(f"CuPy version: {cp.__version__}")
+print(f"CUDA available: {cp.cuda.is_available()}")
+
+# Simple test
+a = cp.array([1, 2, 3])
+b = cp.array([4, 5, 6])
+print(f"Sum: {cp.asnumpy(a + b)}")  # Should print [5, 7, 9]
+```
+
+If you encounter any issues, consult the [CuPy installation guide](https://docs.cupy.dev/en/stable/install.html).
+
+## Quick Start
+
+Here is a simple example of generating and plotting KL modes for a 10-meter telescope:
+
+```python
+from aobasis import KLBasisGenerator, make_circular_actuator_grid
+
+# 1. Define the actuator geometry
+positions = make_circular_actuator_grid(telescope_diameter=10.0, grid_size=20)
+
+# 2. Initialize the generator (use_gpu=True for GPU acceleration if available)
+kl_gen = KLBasisGenerator(positions, fried_parameter=0.16, outer_scale=30.0, use_gpu=False)
+
+# 3. Generate modes (excluding piston)
+modes = kl_gen.generate(n_modes=50, ignore_piston=True)
+
+# 4. Plot the first 6 modes
+kl_gen.plot(count=6, title_prefix="KL Mode")
+
+# 5. Save to disk
+kl_gen.save("my_kl_basis.npz")
+```
+
+## Performance
+
+Generation times for 100 modes benchmarked on the following system:
+- **CPU**: AMD Ryzen 9 9950X3D (16-core, 32-thread)
+- **GPU**: NVIDIA GeForce RTX 5090 (32 GB)
+- **OS**: Linux (Ubuntu)
+
+| Basis | 16x16 Grid (~170 acts) | 32x32 Grid (~740 acts) | 64x64 Grid (~3100 acts) |
+|-------|------------------------|------------------------|-------------------------|
+| **KL (CPU)** | 0.010s | 0.170s | 3.008s |
+| **KL (GPU)** | 0.005s | 0.019s | 0.202s |
+| **Zernike** | 0.001s | 0.002s | 0.005s |
+| **Fourier** | <0.001s | 0.001s | 0.003s |
+| **Zonal** | <0.001s | <0.001s | 0.003s |
+| **Hadamard** | <0.001s | 0.001s | 0.031s |
+
+*Note: KL basis generation is computationally intensive ($O(N^3)$) due to the dense covariance matrix diagonalization. GPU acceleration provides significant speedup (8-15x) for larger grids.*
+
+## Tutorials
+
+We provide Jupyter notebooks to help you get started.
+
+1.  **Getting Started**: `tutorials/getting_started.ipynb` covers all supported basis types and features.
+
+To run the tutorials:
+```bash
+# Install Jupyter if you haven't already
+pip install jupyter
+
+# Launch the notebook server
+jupyter notebook tutorials/getting_started.ipynb
+```
+
+## Development & Testing
+
+This project uses `pytest` for testing. To run the test suite:
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1.  Fork the repository.
+2.  Create your feature branch (`git checkout -b feature/AmazingFeature`).
+3.  Commit your changes (`git commit -m 'Add some AmazingFeature'`).
+4.  Push to the branch (`git push origin feature/AmazingFeature`).
+5.  Open a Pull Request.
+
+## Issues
+
+If you encounter any bugs or have feature requests, please file an issue on the [GitHub Issues](https://github.com/jacotay7/aobasis/issues) page.
+
+## Contact
+
+For questions or support, please contact:
+
+**User Name**  
+Email: jtaylor@keck.hawaii.edu
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

aobasis-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aobasis"
+version = "1.0.0"
+description = "A package for generating AO basis sets (KL, Zernike, Fourier)"
+readme = "README.md"
+authors = [{ name = "Jacob Taylor", email = "jtaylor@keck.hawaii.edu" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "numpy>=1.20",
+    "scipy>=1.7",
+    "matplotlib>=3.5",
+]
+requires-python = ">=3.8"
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-cov",
+    "imageio",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/jacotay7/aobasis"
+"Bug Tracker" = "https://github.com/jacotay7/aobasis/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

aobasis-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aobasis-1.0.0/src/aobasis/__init__.py

@@ -0,0 +1,26 @@
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("aobasis")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+from .base import BasisGenerator
+from .kl import KLBasisGenerator
+from .zernike import ZernikeBasisGenerator
+from .fourier import FourierBasisGenerator
+from .zonal import ZonalBasisGenerator
+from .hadamard import HadamardBasisGenerator
+from .utils import make_circular_actuator_grid, make_concentric_actuator_grid, plot_basis_modes
+
+__all__ = [
+    "BasisGenerator",
+    "KLBasisGenerator",
+    "ZernikeBasisGenerator",
+    "FourierBasisGenerator",
+    "ZonalBasisGenerator",
+    "HadamardBasisGenerator",
+    "make_circular_actuator_grid",
+    "make_concentric_actuator_grid",
+    "plot_basis_modes",
+]

aobasis-1.0.0/src/aobasis/base.py

@@ -0,0 +1,76 @@
+from abc import ABC, abstractmethod
+import numpy as np
+from pathlib import Path
+from typing import Tuple, Optional, Union
+from .utils import plot_basis_modes
+
+class BasisGenerator(ABC):
+    """
+    Abstract base class for AO basis generators.
+    """
+    
+    def __init__(self, positions: np.ndarray):
+        """
+        Args:
+            positions: (N, 2) array of actuator coordinates (x, y) in meters.
+        """
+        self.positions = np.array(positions)
+        self.n_actuators = self.positions.shape[0]
+        self.modes: Optional[np.ndarray] = None
+        
+    @abstractmethod
+    def generate(self, n_modes: int, **kwargs) -> np.ndarray:
+        """
+        Generate the basis modes.
+        
+        Args:
+            n_modes: Number of modes to generate.
+            
+        Returns:
+            modes: (n_actuators, n_modes) matrix.
+        """
+        pass
+    
+    def save(self, filepath: Union[str, Path]) -> None:
+        """
+        Save the generated basis and actuator positions to a .npz file.
+        """
+        if self.modes is None:
+            raise ValueError("No modes generated yet. Call generate() first.")
+            
+        np.savez(
+            filepath,
+            modes=self.modes,
+            positions=self.positions,
+            basis_type=self.__class__.__name__
+        )
+        
+    @classmethod
+    def load(cls, filepath: Union[str, Path]) -> 'BasisGenerator':
+        """
+        Load a basis from a .npz file. 
+        Note: This returns a generic container or re-instantiates the specific class if possible.
+        For simplicity here, we might just return the data or a generic wrapper.
+        """
+        data = np.load(filepath)
+        positions = data['positions']
+        modes = data['modes']
+        
+        # Create a generic instance to hold the data
+        # In a more complex system, we might factory this based on basis_type
+        instance = ConcreteBasis(positions)
+        instance.modes = modes
+        return instance
+
+    def plot(self, count: int = 6, outfile: Optional[Union[str, Path]] = None, **kwargs):
+        """Plot the generated modes."""
+        if self.modes is None:
+            raise ValueError("No modes to plot.")
+        plot_basis_modes(self.modes, self.positions, count=count, outfile=outfile, **kwargs)
+
+class ConcreteBasis(BasisGenerator):
+    """Helper class for loading existing bases."""
+    def generate(self, n_modes: int, **kwargs) -> np.ndarray:
+        if self.modes is None:
+            raise NotImplementedError("This is a loaded basis container.")
+        return self.modes[:, :n_modes]

aobasis-1.0.0/src/aobasis/fourier.py

@@ -0,0 +1,82 @@
+import numpy as np
+from .base import BasisGenerator
+
+class FourierBasisGenerator(BasisGenerator):
+    """
+    Generates Fourier modes (sine/cosine) on the actuator grid.
+    """
+    
+    def __init__(self, positions: np.ndarray, pupil_diameter: float):
+        super().__init__(positions)
+        self.pupil_diameter = pupil_diameter
+
+    def generate(self, n_modes: int, ignore_piston: bool = False, **kwargs) -> np.ndarray:
+        """
+        Generate Fourier modes.
+        We generate pairs of sin/cos for increasing spatial frequencies.
+        """
+        x = self.positions[:, 0]
+        y = self.positions[:, 1]
+        
+        modes_list = []
+        
+        # Piston
+        if not ignore_piston:
+            modes_list.append(np.ones_like(x))
+        
+        # Loop through spatial frequencies
+        # kx, ky integers
+        # We'll spiral out or just loop kx, ky
+        # Simple ordering: by magnitude of k vector
+        
+        k_pairs = []
+        # Generate a pool of k-vectors
+        k_max = int(np.sqrt(n_modes)) + 2
+        for kx in range(-k_max, k_max + 1):
+            for ky in range(-k_max, k_max + 1):
+                if kx == 0 and ky == 0:
+                    continue
+                # We only need half the plane for real Fourier basis (sin/cos)
+                # But simpler to just generate sin/cos pairs for positive k's?
+                # Let's stick to standard real Fourier series expansion logic
+                # cos(2pi(ux + vy)), sin(2pi(ux + vy))
+                k_pairs.append((kx, ky))
+                
+        # Sort by spatial frequency magnitude
+        k_pairs.sort(key=lambda k: k[0]**2 + k[1]**2)
+        
+        # Filter duplicates/redundancies for real basis
+        # We want unique spatial frequencies. 
+        # For each (kx, ky), we can have cos and sin.
+        # But (kx, ky) and (-kx, -ky) are redundant.
+        # So we keep only "positive" half plane.
+        
+        unique_ks = []
+        seen = set()
+        for kx, ky in k_pairs:
+            if (kx, ky) in seen or (-kx, -ky) in seen:
+                continue
+            seen.add((kx, ky))
+            unique_ks.append((kx, ky))
+            
+        # Generate modes
+        # Fundamental frequency base: 1 cycle per pupil diameter
+        f0 = 1.0 / self.pupil_diameter
+        
+        for kx, ky in unique_ks:
+            if len(modes_list) >= n_modes:
+                break
+                
+            arg = 2 * np.pi * f0 * (kx * x + ky * y)
+            
+            # Cosine component
+            modes_list.append(np.cos(arg))
+            
+            if len(modes_list) >= n_modes:
+                break
+                
+            # Sine component
+            modes_list.append(np.sin(arg))
+            
+        self.modes = np.column_stack(modes_list)
+        return self.modes

aobasis-1.0.0/src/aobasis/hadamard.py

@@ -0,0 +1,51 @@
+import numpy as np
+from scipy.linalg import hadamard
+from .base import BasisGenerator
+
+class HadamardBasisGenerator(BasisGenerator):
+    """
+    Generates Hadamard modes.
+    Useful for interaction matrix calibration (multiplexing).
+    """
+    
+    def generate(self, n_modes: int, **kwargs) -> np.ndarray:
+        """
+        Generate Hadamard modes.
+        
+        Since Hadamard matrices exist only for sizes 2^k (or multiples of 4),
+        we find the next power of 2 >= n_actuators, generate the Hadamard matrix,
+        and truncate it to the number of actuators (rows) and requested modes (columns).
+        """
+        # Find next power of 2 covering the number of actuators
+        # We need at least n_actuators rows to define the pattern on the grid
+        # And we need enough columns for n_modes
+        
+        # Usually for calibration, we want a square matrix that covers all actuators.
+        # So size >= n_actuators.
+        
+        size = 1
+        while size < self.n_actuators:
+            size *= 2
+            
+        # If n_modes is larger than this size, we might need a larger matrix?
+        # But usually we can't have more orthogonal modes than actuators (degrees of freedom).
+        # However, Hadamard patterns are defined by the full matrix.
+        
+        if n_modes > size:
+             # If user asks for more modes than the natural Hadamard block size covering actuators,
+             # we might need to go bigger.
+             while size < n_modes:
+                 size *= 2
+        
+        H = hadamard(size)
+        
+        # Truncate to actuators (rows) and modes (cols)
+        # Note: Truncated Hadamard is not necessarily orthogonal!
+        # But it is the standard way to project Hadamard patterns onto a smaller aperture.
+        
+        self.modes = H[:self.n_actuators, :n_modes]
+        
+        # Optional: Normalize? Hadamard entries are 1 and -1.
+        # Keeping them as is is standard.
+        
+        return self.modes