tomoAO 0.0.1__tar.gz

tomoao-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 cmcorreia
+
+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.

tomoao-0.0.1/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: tomoAO
+Version: 0.0.1
+Summary: Python package with atmospheric tomography generic functions and tools
+Home-page: https://github.com/cmcorreia/PyTomo
+Author: SpaceODT
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aotools
+Requires-Dist: numpy
+Requires-Dist: astropy
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# tomoAO
+Python package with atmospheric tomography generic functions and tools
+
+## Installation
+
+1. Install OOPAO
+    ```sh
+    pip install git+https://github.com/cheritier/OOPAO
+    ```
+
+2. Install cupy according to your cuda version (Optional)
+    ```sh
+    pip install cupy-cuda11x
+    ```
+    ```sh
+    pip install cupy-cuda12x
+    ```
+
+3. Install tomoAO via pip
+    ```sh
+    pip install tomoAO
+    ```
+
+    Or clone the repository
+    ```sh
+    git clone https://github.com/cmcorreia/PyTomo
+    pip install -e 'path to tomoAO'
+    ```

tomoao-0.0.1/README.md

@@ -0,0 +1,32 @@
+# tomoAO
+Python package with atmospheric tomography generic functions and tools
+
+## Installation
+
+1. Install OOPAO
+    ```sh
+    pip install git+https://github.com/cheritier/OOPAO
+    ```
+
+2. Install cupy according to your cuda version (Optional)
+    ```sh
+    pip install cupy-cuda11x
+    ```
+    ```sh
+    pip install cupy-cuda12x
+    ```
+
+3. Install tomoAO via pip
+    ```sh
+    pip install tomoAO
+    ```
+
+    Or clone the repository
+    ```sh
+    git clone https://github.com/cmcorreia/PyTomo
+    pip install -e 'path to tomoAO'
+    ```
+    
+
+
+

tomoao-0.0.1/setup.cfg

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

tomoao-0.0.1/setup.py

@@ -0,0 +1,45 @@
+import io
+import os
+from setuptools import setup, find_packages
+
+
+def read(*paths, **kwargs):
+    """Read the contents of a text file safely.
+    # >>> read("project_name", "VERSION")
+    '0.1.0'
+    # >>> read("README.md")
+    # ...
+    """
+
+    content = ""
+    with io.open(
+        os.path.join(os.path.dirname(__file__), *paths),
+        encoding=kwargs.get("encoding", "utf8"),
+    ) as open_file:
+        content = open_file.read().strip()
+    return content
+
+
+setup(
+    name = 'tomoAO',
+    version=open("tomoAO/version.py").read().split('=')[1].strip().strip('"'),
+    license = 'MIT',
+    author = 'SpaceODT',
+    description='Python package with atmospheric tomography generic functions and tools',
+    long_description=read("README.md"),
+    long_description_content_type='text/markdown',
+    packages = find_packages(),
+    url='https://github.com/cmcorreia/PyTomo',
+    install_requires = [
+    'aotools',
+    'numpy',
+    'astropy'
+    ],
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+        'Intended Audience :: Science/Research',
+        'Natural Language :: English',
+    ]
+)

tomoao-0.0.1/tomoAO/IO/__init__.py

@@ -0,0 +1 @@
+from .io_functions import *

tomoao-0.0.1/tomoAO/IO/io_functions.py

@@ -0,0 +1,47 @@
+import configparser
+import os
+import numpy as np
+from astropy.io import fits
+
+
+def load_from_ini(config_file, ao_mode=None, config_dir=os.path.dirname(__file__)):
+    # Instantiate configparser
+    config = configparser.ConfigParser()
+    config.optionxform = str
+    # Path of the configuration file is given as the "configdir" argument
+    # Read the configuration file
+    config.read(config_dir + config_file)
+
+    # Get the section of the config file containing the reconstructor
+    # parameters for the chosen AO_MODE
+    if ao_mode is None:
+        ao_mode = 'default'
+
+    parm = dict(config[ao_mode].items())
+    # breakpoint()
+    #print(parm)
+    # for key, value in parm.items():
+    #     print(key, value)
+    #     print(eval(value))
+    #     print("----------------")
+    # breakpoint()
+    return {key: eval(value) for key, value in
+            parm.items()}  # returns a dictionary with entries in specified data types
+
+
+def open_influence_matrix(config, baseline_folder=None, filename=None):
+    if baseline_folder is None:
+        baseline_folder = config["path2imx"]
+
+    if filename is None:
+        filename = config["influence_matrix"]
+
+    #with fits.open(baseline_folder + "influence_matrix_5Mar.fits") as hdul:
+    with fits.open(baseline_folder+filename) as hdul:
+        hdul.verify('fix')
+        IM = hdul[0].data
+
+    # For now, concatenating n_channels times the same IM
+    n_channels = config["n_lgs"]
+
+    return np.array([IM] * n_channels)

tomoao-0.0.1/tomoAO/Reconstruction/__init__.py

@@ -0,0 +1 @@
+from .recontructors import *

tomoao-0.0.1/tomoAO/Reconstruction/reconClassType.py

@@ -0,0 +1,297 @@
+"""
+Created on Tue Apr 18 15:25:00 2023
+
+@author: ccorreia@spaceodt.net
+"""
+
+
+import tomoAO.tools.tomography_tools as tools
+
+
+import numpy as np
+cuda_available = False
+try:
+    import cupy as cp
+    if cp.cuda.is_available():
+        cuda_available = True
+except:
+    cuda_available = False
+
+
+import matplotlib.pyplot as plt
+from scipy.sparse import block_diag
+
+from time import time
+
+
+
+
+
+
+class tomoReconstructor:
+    def __init__(self, aoSys, weight_vector=None, alpha=None,
+                 model='zonal', noise_covariance=None, lag=0,
+                 weightOptimDir=-1, os=2, zernikeMode=None):
+        """Initialization function.
+
+        Instantiate a LinearMMSE reconstructor
+
+        :param tel: Telescope object [Telescope]
+        :param atmModel: atmosphere object [Atmosphere]
+        :param guideStar: a list of guide star objects [list of Source objects]
+        :param mmseStar: a list of target star objects [list of Source objects]
+        :param dm: deformable mirror object [Deformable Mirror]
+        :param outputRecGrid: a mask where the phase is to be reconstructed
+        :param validSubapMask: a multi-dim mask with the valid subapertures per WFS channel [bool]
+        :param model: whether 'zonal' (default) or modal [str]
+        :param noiseCovariance: the noise covariance matrix as a scalar [float] or a matrix [ndarray]
+        :param lag: the AO system lag that can be compensated through tomography [float]
+        :param weightOptimDir: a vector with the relative weights for each optimization direction [float]
+        :param os: the over-sampling factor [1, 2, 4] (default=2) to apply to the reconstructed phase w.r.t the inpup slopes-maps [int]
+        :param zernikeMode: zernike modes used for modal removal sampled with the required os factor [ndarray]
+
+        :return: This class instantiates the direct matrices and generates an MMSE reconstructor
+        """
+
+        self.tel = aoSys.tel
+        self.atmModel = aoSys.atm
+
+
+        if isinstance(aoSys.lgsAst, list):
+            # It's already a list, no need to convert
+            self.guideStar = aoSys.lgsAst
+        else:
+            # Convert to a list
+            self.guideStar = [aoSys.lgsAst]
+        self.nGuideStar = len(self.guideStar)
+
+
+        if isinstance(aoSys.mmseStar, list):
+            # It's already a list, no need to convert
+            self.mmseStar = aoSys.mmseStar
+        else:
+            # Convert to a list
+            self.mmseStar = [aoSys.mmseStar]
+
+        self.nMmseStar = len(self.mmseStar) if self.mmseStar is not None else 0
+
+
+        self.dm = aoSys.dm
+
+        self._alpha = alpha
+        self._lag = lag
+        self.weightOptimDir = weightOptimDir
+        self.os = os
+        self.model = model
+        self.zernikeMode = zernikeMode
+
+        self.outputRecGrid = aoSys.outputReconstructiongrid
+
+        #All valid subap mask
+        self.unfiltered_subap_mask = aoSys.unfiltered_subap_mask
+
+        #Valid subap mask
+        self._filtered_subap_mask = aoSys.filtered_subap_mask
+
+        if weight_vector is None:
+            self.weight_vector = self.computeDefaultWeightVector()
+        else:
+            self.weight_vector = weight_vector
+
+        if noise_covariance is None:
+            self.noise_covariance = self.computeDefaultNoiseCovariance()
+        else:
+            self.noise_covariance = noise_covariance
+
+
+
+
+
+
+        # self._weight_vector = weight_vector
+        if isinstance(self.weightOptimDir, str):
+            if self.weightOptimDir.lower() == 'avr' or self.weightOptimDir.lower() == 'average':
+                self.weightOptimDir = 1 / self.nMmseStar * np.ones(self.nMmseStar)
+            else:
+                raise ValueError('Keyword for optimization weights not recognized')
+        elif self.weightOptimDir != -1:  # Default optimization in individual directions
+            if len(self.weightOptimDir) != self.nMmseStar:
+                raise ValueError('The weights are not the same size as the number of optimization directions')
+            else:
+                self.weightOptimDir = self.weightOptimDir / np.sum(self.weightOptimDir)
+
+        # %% scale r0 in case of different wavelengths
+        wvlScale = self.guideStar[0].wavelength / self.atmModel.wavelength
+        self.atmModel.r0 = self.atmModel.r0 * wvlScale ** 1.2
+
+
+        # Gamma, gridMask = tools.sparseGradientMatrixAmplitudeWeighted(self.unfiltered_subap_mask, amplMask=None,
+        #                                                               os=self.os)
+        #
+        # Gamma = [Gamma] * self.nGuideStar  # Replicate Gamma nMmseStar times
+        # gridMask = [gridMask] * self.nGuideStar
+        # Gamma = [np.asarray(mat) for mat in Gamma]
+        # self.Gamma = block_diag(Gamma)
+        # self.gridMask = gridMask
+
+
+        # %% FITTING MATRIX
+        if self.dm is not None:
+            iFittingMatrix = 2*self.dm.modes[self.outputRecGrid.flatten("F"),]
+
+            if cuda_available:
+                self.fittingMatrix = cp.linalg.pinv(cp.asarray(iFittingMatrix), rcond=1e-3).get()
+            else:
+                self.fittingMatrix = np.linalg.pinv(iFittingMatrix, rcond=1e-3)
+        else:
+            self.fittingMatrix = None
+
+        # %% RECONSTRUCTOR
+        self.buildReconstructor()
+
+
+
+
+    @property
+    def noise_covariance(self):
+        return self._noise_covariance
+
+    @noise_covariance.setter
+    def noise_covariance(self, val):
+        if val is not None:
+            if self.model == 'modal' and isinstance(val, (int, float)):
+                    n_mode = len(self.zernikeMode)
+                    val = [[val] * n_mode] * n_mode
+                    val = [[val[i][j] if i == j else 0 for j in range(n_mode)] for i in range(n_mode)]
+            elif isinstance(val, (int, float)):
+                val = val * np.eye(self.Gamma.shape[0])
+        else:
+            #Default noise covariance matrix TODO: Evaluate if this should be the default setting
+            val = 1e-3 * self.alpha * np.diag(1 / (self.weight_vector.flatten(order='F') + 1e-8))
+
+        self._noise_covariance = val
+
+
+    def computeDefaultNoiseCovariance(self):
+        self.noise_covariance = None
+
+
+    @property
+    def weight_vector(self):
+        return self._weight_vector
+
+    @weight_vector.setter
+    def weight_vector(self, val):
+
+        if val is not None:
+            self._weight_vector = val
+
+        else:
+            # #Default weight vector TODO: Evaluate if this should be the default setting
+            weight_vector = np.ones([2 * np.count_nonzero(self.unfiltered_subap_mask), self.nGuideStar])
+            filteredAllValidMask = self.filtered_subap_mask.T[self.unfiltered_subap_mask]
+            filteredAllValidMask = np.tile(filteredAllValidMask, 2)
+            weight_vector[~filteredAllValidMask] = 0
+            self._weight_vector = weight_vector
+
+
+    def computeDefaultWeightVector(self):
+        self.weight_vector = None
+
+
+    @property
+    def filtered_subap_mask(self):
+        return self._filtered_subap_mask
+
+    @filtered_subap_mask.setter
+    def filtered_subap_mask(self, val):
+        self._filtered_subap_mask = val
+
+
+    @property
+    def alpha(self):
+        return self._alpha
+
+    @alpha.setter
+    def alpha(self, val):
+        self._alpha = val
+
+
+    @property
+    def R_unfiltered(self):
+        return self._R_unfiltered
+
+    def buildCovarianceMatrices(self):
+        print("Building the covariance matrices")
+        self.Cox = []
+        for i in range(len(self.mmseStar)):
+            res = tools.spatioAngularCovarianceMatrix(self.tel, self.atmModel, [self.mmseStar[i]], self.guideStar,
+                                                self.unfiltered_subap_mask, self.os)
+            self.Cox.append(res)
+
+
+        self.Cxx = tools.spatioAngularCovarianceMatrix(self.tel, self.atmModel, self.guideStar, self.guideStar,
+                                                 self.unfiltered_subap_mask, self.os)
+
+
+    def buildGamma(self):
+        print("Building Gamma")
+        Gamma, gridMask = tools.sparseGradientMatrixAmplitudeWeighted(self.unfiltered_subap_mask, amplMask=None,
+                                                                      os=self.os)
+
+        Gamma = [Gamma] * self.nGuideStar  # Replicate Gamma nMmseStar times
+        gridMask = [gridMask] * self.nGuideStar
+        Gamma = [np.asarray(mat) for mat in Gamma]
+        self.Gamma = block_diag(Gamma).todense()
+        self.gridMask = gridMask
+
+
+    def buildReconstructor(self):
+        print("Using GPU" if cuda_available else "GPU not available, using CPU")
+
+        start = time()
+        self.buildGamma()
+        print(f"Took {time()-start} seconds to build Gamma")
+
+
+        start = time()
+        self.buildCovarianceMatrices()
+        print(f"Took {time()-start} seconds to build the covariance matrices")
+
+
+        print("Building the reconstructor")
+        start = time()
+
+
+        if cuda_available:
+            self.Cox = cp.asarray(self.Cox)
+            self.Cxx = cp.asarray(self.Cxx)
+            self.noise_covariance = cp.asarray(self.noise_covariance)
+            self.Gamma = cp.asarray(self.Gamma)
+
+        if self.weightOptimDir == -1:
+            self.Reconstructor = [None] * self.nMmseStar
+
+            for k in range(self.nMmseStar):
+
+                if cuda_available:
+                    self.Reconstructor[k] = (
+                                self.Cox[k] @ self.Gamma.T @ cp.linalg.pinv(self.Gamma @ self.Cxx @ self.Gamma.T + self.noise_covariance)).get()
+                else:
+                    self.Reconstructor[k] = self.Cox[k] @ self.Gamma.T @ np.linalg.pinv(self.Gamma @ self.Cxx @ self.Gamma.T + self.noise_covariance)
+
+        else:  # weighted sum over all the optimisation directions
+            # This code uses the ss stars to compute a weighted average tomographic
+            # reconstructor over all of them
+            self.Reconstructor = [None]
+            CoxWAvr = np.sum([ self.Cox[k] * self.weightOptimDir[k] for k in range(self.nMmseStar)], axis=0)
+            self.Reconstructor[0] = CoxWAvr @  self.Gamma.T @ np.linalg.pinv(self.Gamma @ self.Cxx @  self.Gamma.T + self.noise_covariance)
+
+
+        self._R_unfiltered = self.fittingMatrix @ self.Reconstructor[0]
+        print(f"Took {time()-start} seconds to build the reconstructor")
+
+
+
+
+

tomoao-0.0.1/tomoAO/Reconstruction/recontructors.py

@@ -0,0 +1,114 @@
+import tomoAO.tools.tomography_tools as tools
+from tomoAO.Reconstruction.reconClassType import tomoReconstructor
+from tomoAO.IO import load_from_ini
+from tomoAO.Simulation import AOSystem
+
+from scipy.linalg import block_diag
+
+import numpy as np
+cuda_available = False
+try:
+    import cupy as cp
+    if cp.cuda.is_available():
+        cuda_available = True
+except:
+    cuda_available = False
+
+
+def tomographic_reconstructor_phase_space(config_file, config_dir, alpha, weight_vector=None, noise_covariance=None, debug=False):
+
+    config_vars = load_from_ini(config_file, ao_mode="MLAO", config_dir=config_dir)
+
+    aoSys = AOSystem(config_vars)
+
+    rec = tomoReconstructor(aoSys, alpha=alpha, weight_vector=weight_vector, noise_covariance=noise_covariance, os=2)
+
+    if debug:
+        return rec
+
+    return rec._R_unfiltered
+
+
+
+def tomographic_reconstructor_dm_space(aoSys, IM, weight, alpha, Cn=None):
+
+    # %% LGS-to-LGS cross-covariance matrix
+    Cxx = tools.spatioAngularCovarianceMatrix(aoSys.tel, aoSys.atm, aoSys.lgsAst, aoSys.lgsAst,
+                                              aoSys.act_mask, os=1, dm_space=True)
+    # %% LGS-to-science cross-covariance matrix
+    Cox = []
+    for i in range(len([aoSys.mmseStar])):
+        res = tools.spatioAngularCovarianceMatrix(aoSys.tel, aoSys.atm, [[aoSys.mmseStar][i]],
+                                                  aoSys.lgsAst,
+                                                  aoSys.act_mask, os=1, dm_space=True)
+        Cox.append(res)
+
+    Cox = Cox[0]
+
+    # TODO this scaling was chosen roughly to match the original invcov matrix read from file
+    Cxx = Cxx / 36
+    Cox = Cox / 36
+
+    if Cn is None:
+        Cn = 1e-3 * alpha * np.diag(1 / (weight.flatten(order='F') + 1e-8))
+
+    IM = block_diag(*IM)
+
+    if cuda_available:
+        Cox = cp.asarray(Cox)
+        IM = cp.asarray(IM)
+        Cxx = cp.asarray(Cxx)
+        Cn = cp.asarray(Cn)
+
+        return (Cox @ IM.T @ np.linalg.pinv(IM @ Cxx @ IM.T + Cn)).get()
+
+    return Cox @ IM.T @ np.linalg.pinv(IM @ Cxx @ IM.T + Cn)
+
+
+
+
+def averaging_bayesian_reconstructor_dm_space(IM, weight_vector, inv_cov_mat, alpha):
+    """
+    This function computes the Bayesian reconstructor as:
+
+    :math:`R = {(H^{T} W^{T} + A)}^{-1} H^{T} W^{T}`
+
+    Args:
+        IM:
+        weight_vector:
+        inv_cov_mat:
+        median_intensity:
+
+    Returns:
+
+    """
+
+    n_lgs = weight_vector.shape[1]
+
+    IMw = IM.copy()
+    n_act = IM.shape[-1]
+
+    for k in range(n_lgs):
+        W = np.tile(np.reshape(weight_vector[:, k], (-1, 1)), (1, n_act))
+        IMw[k, :, :] = IMw[k, :, :] * W
+
+    IMw = block_diag(*IMw)
+    IM = block_diag(*IM)
+
+    # perform the regularized inversion
+    return 1 / n_lgs * np.hstack([np.eye(n_act)] * n_lgs) @ np.linalg.inv(
+        IMw.T @ IM + alpha * 1e-3 * block_diag(*[inv_cov_mat]*n_lgs) + 1.) @ (
+        IMw.T)  # the one is there to penalize piston
+
+
+
+
+
+
+
+
+
+
+
+
+

tomoao-0.0.1/tomoAO/Simulation/__init__.py

@@ -0,0 +1 @@
+from .aoSystem import AOSystem

tomoao-0.0.1/tomoAO/Simulation/aoSystem.py

@@ -0,0 +1,170 @@
+"""
+Created on Tue Apr 18 15:25:00 2023
+
+@author: ccorreia@spaceodt.net
+"""
+
+import tomoAO.tools.tomography_tools as tools
+
+# %% USE OOPAO, define a geometry and compute the cross-covariance matrix for all the layers
+import numpy as np
+
+from OOPAO.Atmosphere import Atmosphere
+from OOPAO.DeformableMirror import DeformableMirror
+from OOPAO.MisRegistration import MisRegistration
+from OOPAO.Source import Source
+from OOPAO.Telescope import Telescope
+from OOPAO.ShackHartmann import ShackHartmann
+
+
+
+
+class AOSystem:
+    def __init__(self, param):
+        # %% -----------------------     TELESCOPE   ----------------------------------
+
+        # create the Telescope object (not Keck for now)
+        tel = Telescope(resolution=param['resolution'],
+                        diameter=param['diameter'],
+                        samplingTime=param['samplingTime'],
+                        centralObstruction=param['centralObstruction'])
+
+        thickness_spider = 0.05  # size in m
+        angle = [45, 135, 225, 315]  # in degrees
+        offset_X = [-0.4, 0.4, 0.4, -0.4]  # shift offset of the spider
+        offset_Y = None
+
+        tel.apply_spiders(angle, thickness_spider, offset_X=offset_X, offset_Y=offset_Y)
+
+
+        # data = loadmat(f'{param["path2matrices"]}tel_pupil.mat')
+        # pupil = data['pup']  # Extract the array
+        #
+        # tel.pupil = pupil
+        # %% -----------------------     NGS   ----------------------------------
+        # create the Source object
+        ngs = Source(optBand=param['opticalBand'],
+                     magnitude=param['magnitude'],
+                     altitude=param['srcAltitude'])
+
+        # combine the NGS to the telescope using '*' operator:
+        ngs * tel
+        # %% LGS objects
+
+
+        lgsAst = [Source(optBand=param['opticalBand'],
+                      magnitude=param['lgs_magnitude'],
+                      altitude=param['lgs_altitude'],
+                      coordinates=[param['lgs_zenith'][kLgs], param['lgs_azimuth'][kLgs]])
+                  for kLgs in range(param["n_lgs"])]
+
+        # %% science targets
+        sciSrc = Source(optBand='K',
+                        magnitude=0,
+                        altitude=np.inf,
+                        coordinates=[0, 0])
+
+        # %% science targets
+
+        recCalSrc = Source(optBand='Na',
+                           magnitude=0,
+                           altitude=np.inf,
+                           coordinates=[0, 0])
+        # %% -----------------------     ATMOSPHERE   ----------------------------------
+
+        # create the Atmosphere object
+
+        atm = Atmosphere(telescope=tel,
+                         r0=param['r0'],
+                         L0=param['L0'],
+                         windSpeed=param['windSpeed'],
+                         fractionalR0=param['fractionnalR0'],
+                         windDirection=param['windDirection'],
+                         altitude=np.array(param['altitude']),
+                         param=param)
+
+
+        # %% -----------------------     DEFORMABLE MIRROR   ----------------------------------
+        # mis-registrations object
+        misReg = MisRegistration(param)
+
+
+        # set coordinate vector to match the Keck actuator location
+        act_mask = np.loadtxt(param["actuator_mask"], dtype=bool, delimiter=",")
+        if act_mask.shape[0] != param['nActuator']:
+            act_mask = np.pad(act_mask, pad_width=int(param['nSubapExtra']/2), mode='constant', constant_values=0)
+
+        X, Y = tools.meshgrid(param['nActuator'], tel.D, offset_x=0.0, offset_y=0.0, stretch_x=1, stretch_y=1)
+
+
+        coordinates = np.array([X[act_mask], Y[act_mask]]).T
+
+        self.dm_coordinates = coordinates
+        # if no coordinates specified, create a cartesian dm
+        resolution = tel.resolution
+
+        # TODO this cannot be set by default, since the wavefront resolution is set only during the MMSE reconstructor. THere is a loophole here!
+        #tel.resolution = 2 * param['nSubaperture'] + 1
+        tel.resolution = param['dm_resolution']# this is to compute a low-resolution DM IF, where low-resolution is the wavefront reconstruction resolution
+        dm = DeformableMirror(telescope=tel,
+                              nSubap=param['nSubaperture'],
+                              mechCoupling=param['mechanicalCoupling'],
+                              misReg=misReg,
+                              coordinates=coordinates,
+                              pitch=tel.D / (param['nActuator'] - 1))
+
+
+        dm.act_mask = act_mask
+        tel.resolution = resolution
+        # %% -----------------------     Wave Front Sensor   ----------------------------------
+        wfs = ShackHartmann(telescope=tel,
+                            nSubap=param['nSubaperture'],
+                            lightRatio=0.5)
+
+
+        unfiltered_subap_mask = np.loadtxt(param["unfiltered_subap_mask"],
+                                           dtype=bool, delimiter=",")
+
+        if unfiltered_subap_mask.shape[0] != param['nSubaperture']:
+            unfiltered_subap_mask = np.pad(unfiltered_subap_mask,
+                                           pad_width=int(param['nSubapExtra']/2),
+                                           mode='constant',
+                                           constant_values=0)
+
+
+        filtered_subap_mask = np.loadtxt(param["filtered_subap_mask"],
+                                         dtype=bool, delimiter=",")
+
+        if filtered_subap_mask.shape[0] != param['nSubaperture']:
+            filtered_subap_mask = np.pad(filtered_subap_mask,
+                                         pad_width=int(param['nSubapExtra']/2),
+                                         mode='constant',
+                                         constant_values=0)
+
+
+        wfs.valid_subapertures = unfiltered_subap_mask
+        wfs.subap_mask = unfiltered_subap_mask #Force existence of subap_mask variable for backwards compatibility
+
+
+
+        # %% -----------------------     Wave Front Reconstruction   ----------------------------------
+
+        outputReconstructiongrid = tools.reconstructionGrid(unfiltered_subap_mask, param['os'], dm_space=False)
+
+
+        # %% -----------------------     Self Allocation   ----------------------------------
+
+        self.param = param
+        self.atm = atm
+        self.tel = tel
+        self.dm = dm
+        self.wfs = wfs
+        self.lgsAst = lgsAst
+        self.mmseStar = ngs
+        self.misreg = misReg
+        self.outputReconstructiongrid = outputReconstructiongrid
+        self.sciSrc = sciSrc
+        self.act_mask = act_mask
+        self.unfiltered_subap_mask = unfiltered_subap_mask
+        self.filtered_subap_mask = filtered_subap_mask
+

tomoao-0.0.1/tomoAO/__init__.py

@@ -0,0 +1,6 @@
+# # from .reconClassType import LinearMMSE
+# import tomoAO.Reconstruction.recontructors
+import tomoAO.IO
+import tomoAO.Simulation
+import tomoAO.Reconstruction
+from .version import __version__

tomoao-0.0.1/tomoAO/tools/tomography_tools.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Apr 18 15:25:00 2023
+
+@author: ccorreia@spaceodt.net
+"""
+
+import numpy as np
+cuda_available = False
+try:
+    import cupy as cp
+    if cp.cuda.is_available():
+        cuda_available = True
+except:
+    cuda_available = False
+
+from scipy.sparse import csr_matrix
+from scipy.special import gamma, kv
+
+import math
+
+
+
+def bessel_i(n, x, terms=10):
+    x = cp.asarray(x, dtype=cp.float64)
+    sum_result = cp.zeros_like(x, dtype=cp.float64)
+
+    for m in range(terms):
+        term = (1 / (math.factorial(m) * math.gamma(m + n + 1))) * (x / 2) ** (2 * m + n)
+        sum_result += term
+
+    return sum_result
+
+def bessel_k(n, x, terms=10):
+    x = cp.asarray(x, dtype=cp.float64)
+
+    if cp.any(x <= 0):
+        raise ValueError("x must be positive for K_n(x)")
+
+    i_n = bessel_i(n, x, terms)
+    i_neg_n = bessel_i(-n, x, terms)
+
+    return (np.pi / 2) * (i_neg_n - i_n) / np.sin(n * cp.pi)
+
+
+def covariance_matrix(rho, r0, L0):
+    L0r0ratio = (L0 / r0) ** (5 / 3)
+    cst = (24 * gamma(6 / 5) / 5) ** (5 / 6) * \
+          (gamma(11 / 6) / (2 ** (5 / 6) * np.pi ** (8 / 3))) * L0r0ratio
+    out = np.ones(rho.shape, dtype=rho.dtype) * (24 * gamma(6 / 5) / 5) ** (5 / 6) * \
+          (gamma(11 / 6) * gamma(5 / 6) /
+           (2 * np.pi ** (8 / 3))) * L0r0ratio
+    index = rho != 0
+    u = 2 * np.pi * rho[index] / L0
+    if cuda_available:
+        out[index] = cst * u ** (5 / 6) * bessel_k(5 / 6, cp.asarray(u), terms=10).get()
+
+    else:
+        out[index] = cst * u ** (5 / 6) * kv(5 / 6, u)
+
+    return out
+
+
+
+def dists(rho1, rho2):
+    dist = np.abs(np.subtract.outer(rho1.flatten(), rho2.flatten()))
+    return dist
+
+
+def meshgrid(nPts, D, offset_x=0, offset_y=0, stretch_x=1, stretch_y=1):
+    x = np.linspace(-D / 2, D / 2, nPts)
+    X, Y = np.meshgrid(x * stretch_x, x * stretch_y)
+    X = X + offset_x
+    Y = Y + offset_y
+    return X, Y
+
+
+def reconstructionGrid(mask, os, dm_space=False):
+    # os stands for oversampling. Can be 1 or 2.
+    # If os=1, reconstructionGrid pitch = subaperturePitch,
+    # if os=2, reconstructionGrid pitch = subaperturePitch/2
+    from scipy.signal import convolve2d
+    if os == 1 and dm_space:
+        val = mask
+    elif os == 1 and not dm_space:
+        val = convolve2d(np.ones((2, 2)), mask).astype('bool')
+    elif os == 2:
+        nElements = os * mask.shape[0] + 1  # Linear number of lenslet+actuator
+        validLensletActuator = np.zeros((nElements, nElements), dtype=bool)
+        index = np.arange(1, nElements, 2)  # Lenslet index
+        validLensletActuator[np.ix_(index, index)] = mask
+        kernel = np.ones((3, 3))
+        output = convolve2d(validLensletActuator, kernel, mode='same')
+        val = output.astype(bool)
+    return val
+
+
+def spatioAngularCovarianceMatrix(tel, atm, src1, src2, mask, os, dm_space=0):
+    # Compute the discrete reconstruction mask from the subap_mask passed on as input
+
+    recIdx = reconstructionGrid(mask, os, dm_space)
+    if src1 == src2:  # auto-covariance matrix
+
+        arcsec2radian = np.pi / 180 / 3600
+        nPts = recIdx.shape[0]
+        crossCovCell = np.empty((len(src1), len(src2)), dtype=object)
+        for i in range(0, len(src1)):
+            for j in range(0, len(src2)):
+                if j >= i:
+
+                    phaseCovElem = np.zeros((nPts ** 2, nPts ** 2, len(atm.altitude)))
+                    for l in range(0, len(atm.altitude)):
+                        # CROSS COVARIANCE BETWEEN TWO STARS
+                        # STAR 1
+                        coneCompressionFactor = 1 - \
+                                                atm.altitude[l] / src1[i].altitude
+                        x = src1[i].coordinates[0] * atm.altitude[l] * \
+                            arcsec2radian * \
+                            np.cos(src1[i].coordinates[1] * np.pi / 180)
+                        y = src1[i].coordinates[0] * atm.altitude[l] * \
+                            arcsec2radian * \
+                            np.sin(src1[i].coordinates[1] * np.pi / 180)
+                        X, Y = meshgrid(nPts, tel.D, offset_x=x, offset_y=y,
+                                        stretch_x=coneCompressionFactor, stretch_y=coneCompressionFactor)
+
+                        rho1 = X + 1j * Y
+
+
+                        # STAR 2
+                        coneCompressionFactor = 1 - \
+                                                atm.altitude[l] / src2[j].altitude
+                        x = src2[j].coordinates[0] * atm.altitude[l] * \
+                            arcsec2radian * \
+                            np.cos(src2[j].coordinates[1] * np.pi / 180)
+                        y = src2[j].coordinates[0] * atm.altitude[l] * \
+                            arcsec2radian * \
+                            np.sin(src2[j].coordinates[1] * np.pi / 180)
+                        X, Y = meshgrid(nPts, tel.D, offset_x=x, offset_y=y,
+                                        stretch_x=coneCompressionFactor, stretch_y=coneCompressionFactor)
+                        rho2 = X + 1j * Y
+
+                        dist = dists(rho1.T, rho2.T)  # not sure why, using the transpose makes it equal to Matlab's
+
+                        phaseCovElem[:, :, l] = covariance_matrix(
+                            dist, atm.r0, atm.L0) * atm.fractionalR0[l]
+
+
+                    crossCovCell[i, j] = np.sum(phaseCovElem, axis=2)[
+                                         recIdx.flatten("F"), :][:, recIdx.flatten("F")]
+
+        # populate the off-diagonal blocks left null in the previous step
+        for i in range(0, len(src1)):
+            for j in range(0, len(src1)):
+                if j < i:
+                    crossCovCell[i, j] = np.transpose(crossCovCell[j, i])
+
+        crossCovMat = np.block(
+            [[crossCovCell[i, j] for j in range(len(src1))] for i in range(len(src2))])
+        crossCovMat = np.vstack(crossCovMat)
+        return crossCovMat
+    else:
+        # breakpoint()
+        arcsec2radian = np.pi / 180 / 3600
+        nPts = recIdx.shape[0]
+        crossCovCell = np.empty((len(src1), len(src2)), dtype=object)
+        for i in range(0, len(src1)):
+            for j in range(0, len(src2)):
+                phaseCovElem = np.zeros((nPts ** 2, nPts ** 2, len(atm.altitude)))
+                for l in range(0, len(atm.altitude)):
+                    # CROSS COVARIANCE BETWEEN TWO STARS
+                    # STAR 1
+                    coneCompressionFactor = 1 - \
+                                            atm.altitude[l] / src1[i].altitude
+                    x = src1[i].coordinates[0] * atm.altitude[l] * \
+                        arcsec2radian * \
+                        np.cos(src1[i].coordinates[1] * np.pi / 180)
+                    y = src1[i].coordinates[0] * atm.altitude[l] * \
+                        arcsec2radian * \
+                        np.sin(src1[i].coordinates[1] * np.pi / 180)
+                    X, Y = meshgrid(nPts, tel.D, offset_x=x, offset_y=y,
+                                    stretch_x=coneCompressionFactor, stretch_y=coneCompressionFactor)
+                    rho1 = X + 1j * Y
+                    # STAR 2
+                    coneCompressionFactor = 1 - \
+                                            atm.altitude[l] / src2[j].altitude
+                    x = src2[j].coordinates[0] * atm.altitude[l] * \
+                        arcsec2radian * \
+                        np.cos(src2[j].coordinates[1] * np.pi / 180)
+                    y = src2[j].coordinates[0] * atm.altitude[l] * \
+                        arcsec2radian * \
+                        np.sin(src2[j].coordinates[1] * np.pi / 180)
+                    X, Y = meshgrid(nPts, tel.D, offset_x=x, offset_y=y,
+                                    stretch_x=coneCompressionFactor, stretch_y=coneCompressionFactor)
+                    rho2 = X + 1j * Y
+
+                    dist = dists(rho1.T, rho2.T)  # not sure why, using the transpose makes it equal to Matlab's
+                    phaseCovElem[:, :, l] = covariance_matrix(
+                        dist, atm.r0, atm.L0) * atm.fractionalR0[l]
+                crossCovCell[i, j] = np.sum(phaseCovElem, axis=2)[
+                                     recIdx.flatten("F"), :][:, recIdx.flatten("F")]
+        crossCovMat = np.block(
+            [[crossCovCell[i, j] for j in range(len(src2))] for i in range(len(src1))])
+        if len(src1) > 1:
+            crossCovMat = np.vstack(crossCovMat)
+        return crossCovMat
+
+
+
+
+
+def sparseGradientMatrixAmplitudeWeighted(validLenslet, amplMask, os=2):
+
+    nLenslet = validLenslet.shape[0]
+
+    nMap = os * nLenslet + 1
+
+    if amplMask is None:
+        amplMask = np.ones((nMap, nMap))
+
+    nValidLenslet_ = np.count_nonzero(validLenslet)
+    dsa = 1
+
+    i0x = np.tile([0, 1, 2], 3)
+
+    j0x = np.repeat([0, 1, 2], 3)
+
+    i0y = np.tile([0, 1, 2], 3)
+
+    j0y = np.repeat([0, 1, 2], 3)
+
+    s0x = np.array([-1 / 4, -1 / 2, -1 / 4, 0, 0, 0, 1 / 4, 1 / 2, 1 / 4]) * (1 / dsa)
+
+    s0y = -np.array([1 / 4, 0, -1 / 4, 1 / 2, 0, -1 / 2, 1 / 4, 0, -1 / 4]) * (1 / dsa)
+
+    Gv = np.array([[-2, 2, -1, 1], [-2, 2, -1, 1], [-1, 1, -2, 2], [-1, 1, -2, 2]])
+
+    i_x = np.zeros(9 * nValidLenslet_)
+    j_x = np.zeros(9 * nValidLenslet_)
+    s_x = np.zeros(9 * nValidLenslet_)
+    i_y = np.zeros(9 * nValidLenslet_)
+    j_y = np.zeros(9 * nValidLenslet_)
+    s_y = np.zeros(9 * nValidLenslet_)
+
+    jMap0, iMap0 = np.meshgrid(np.arange(0, 3), np.arange(0, 3))
+
+    gridMask = np.zeros((nMap, nMap), dtype=bool)
+
+    u = np.arange(0, 9)
+
+    for jLenslet in range(0, nLenslet):
+        jOffset = os * (jLenslet)
+        for iLenslet in range(0, nLenslet):
+            if validLenslet[iLenslet, jLenslet]:
+                I = (iLenslet) * os + 1
+                J = (jLenslet) * os + 1
+
+                a = amplMask[I - 1:I + os, J - 1:J + os]
+
+                numIllum = np.sum(a)
+
+                if numIllum == (os + 1) ** 2:
+                    iOffset = os * (iLenslet)
+                    i_x[u] = i0x + iOffset
+                    j_x[u] = j0x + jOffset
+                    s_x[u] = s0x
+                    i_y[u] = i0y + iOffset
+                    j_y[u] = j0y + jOffset
+                    s_y[u] = s0y
+                    u = u + (os + 1) ** 2
+
+                    gridMask[iMap0 + iOffset, jMap0 + jOffset] = True
+
+    indx = np.ravel_multi_index((i_x.astype(int), j_x.astype(int)), (nMap, nMap), order='F')
+    indy = np.ravel_multi_index((i_y.astype(int), j_y.astype(int)), (nMap, nMap), order='F')
+
+    v = np.tile(np.arange(0, 2 * nValidLenslet_), (u.size, 1)).T
+
+    Gamma = csr_matrix((np.concatenate((s_x, s_y)), (v.flatten(), np.concatenate((indx, indy)))),
+                       shape=(2 * nValidLenslet_, nMap ** 2))
+    Gamma = Gamma.todense()
+    Gamma = Gamma[:, gridMask.flatten("F")]
+
+    return Gamma, gridMask
+
+
+
+
+
+
+
+
+
+

tomoao-0.0.1/tomoAO/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

tomoao-0.0.1/tomoAO.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: tomoAO
+Version: 0.0.1
+Summary: Python package with atmospheric tomography generic functions and tools
+Home-page: https://github.com/cmcorreia/PyTomo
+Author: SpaceODT
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aotools
+Requires-Dist: numpy
+Requires-Dist: astropy
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# tomoAO
+Python package with atmospheric tomography generic functions and tools
+
+## Installation
+
+1. Install OOPAO
+    ```sh
+    pip install git+https://github.com/cheritier/OOPAO
+    ```
+
+2. Install cupy according to your cuda version (Optional)
+    ```sh
+    pip install cupy-cuda11x
+    ```
+    ```sh
+    pip install cupy-cuda12x
+    ```
+
+3. Install tomoAO via pip
+    ```sh
+    pip install tomoAO
+    ```
+
+    Or clone the repository
+    ```sh
+    git clone https://github.com/cmcorreia/PyTomo
+    pip install -e 'path to tomoAO'
+    ```

tomoao-0.0.1/tomoAO.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+setup.py
+tomoAO/__init__.py
+tomoAO/version.py
+tomoAO.egg-info/PKG-INFO
+tomoAO.egg-info/SOURCES.txt
+tomoAO.egg-info/dependency_links.txt
+tomoAO.egg-info/requires.txt
+tomoAO.egg-info/top_level.txt
+tomoAO/IO/__init__.py
+tomoAO/IO/io_functions.py
+tomoAO/Reconstruction/__init__.py
+tomoAO/Reconstruction/reconClassType.py
+tomoAO/Reconstruction/recontructors.py
+tomoAO/Simulation/__init__.py
+tomoAO/Simulation/aoSystem.py
+tomoAO/tools/__init__.py
+tomoAO/tools/tomography_tools.py

tomoao-0.0.1/tomoAO.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tomoao-0.0.1/tomoAO.egg-info/requires.txt

@@ -0,0 +1,3 @@
+aotools
+numpy
+astropy

tomoao-0.0.1/tomoAO.egg-info/top_level.txt

@@ -0,0 +1 @@
+tomoAO