AnisoCADO 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

anisocado/__init__.py

@@ -1,2 +1,11 @@
 from .psf import AnalyticalScaoPsf
-from .misc import field_positions_for_simcado_psf, make_simcado_psf_file
+from .misc import field_positions_for_simcado_psf, make_simcado_psf_file
+
+
+from importlib import metadata
+from packaging.version import parse
+
+try:
+    __version__ = parse(metadata.version(__package__))
+except metadata.PackageNotFoundError:
+    __version__ = "undetermined"

anisocado/_anisocado.py

@@ -1,28 +1,43 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
+Main module.
+
 Created on Tue Mar 12 18:48:47 2019
 
 @author: Eric Gendron
-Edited by Kieran Leschinski
+Edited by Kieran Leschinski and Fabian Haberhauer
 """
 
+import numpy as np
 import matplotlib.pyplot as plt
-from anisocado.psf_utils import *
-from anisocado.psf_utils import get_atmospheric_turbulence
-
-#  _   _             ____                  _
-# | | | |___  ___   / ___|__ _ ___  ___   / |
-# | | | / __|/ _ \ | |   / _` / __|/ _ \  | |
-# | |_| \__ \  __/ | |__| (_| \__ \  __/  | |
-#  \___/|___/\___|  \____\__,_|___/\___|  |_|
 
+from anisocado.psf_utils import (
+    get_atmospheric_turbulence,
+    computeEeltOTF,
+    computeSpatialFreqArrays,
+    createAdHocScaoPsf,
+    anisoplanaticSpectrum,
+    convertSpectrum2Dphi,
+    defineDmFrequencyArea,
+    computeBpSpectrum,
+    otherSpectrum,
+    airmassImpact,
+    fittingSpectrum,
+    aliasingSpectrum,
+    computeWiener,
+    r0Converter,
+    fake_generatePupil,
+    core_generatePsf,
+)
+
+
+# use-case 1
 
 def shift_scao_psf(plots=False):
     """
     Problem:
     You have an on-axis PSF.
-    You want to 'move' it off-axis, let's say (+15, +20) arcsec.
+    You want to "move" it off-axis, let's say (+15, +20) arcsec.
 
 
     For that, you will need to know:
@@ -31,7 +46,6 @@ def shift_scao_psf(plots=False):
         - the global L0
 
     """
-    ###########
     # Setup
 
     # Let's take an example. I create a PSF, that could be coming from
@@ -50,10 +64,10 @@ def shift_scao_psf(plots=False):
 
     if plots:
         # I can even look at it:
-        plt.imshow(psf.T, origin='l')
-        print('Strehl ratio of initial psf is ', psf.max())
+        plt.imshow(psf.T, origin="l")
+        print("Strehl ratio of initial psf is ", psf.max())
 
-    # OK. That's the starting point.......................
+    # OK. That's the starting point.
 
     # Now I need to know the atmospheric properties, in particular the Cn2h
     # profile. Let me offer you a little selection of atmospheric profiles.
@@ -74,9 +88,8 @@ def shift_scao_psf(plots=False):
     # in arcsecs (this one is for those who'd like to check nothing will change
     # at the end)
     # offx, offy = (0, 0)
-    offx, offy = (0., 16.)   # in arcsecs
+    offx, offy = (0., 16.)  # [arcsec]
 
-    ####################
     # Generate PSF
 
     # Then let's start the work. I will create spatial frequency arrays.
@@ -104,21 +117,16 @@ def shift_scao_psf(plots=False):
 
     psf_aniso = core_generatePsf(Dphi, fto)
 
-    print('Strehl off-axis is', psf_aniso.max())
-    plt.imshow(psf_aniso.T, origin='l' )
+    print("Strehl off-axis is", psf_aniso.max())
+    plt.imshow(psf_aniso.T, origin="lower")
 
     return psf_aniso
 
-#  _   _             ____                 ____
-# | | | |___  ___   / ___|__ _ ___  ___  |___ \
-# | | | / __|/ _ \ | |   / _` / __|/ _ \   __) |
-# | |_| \__ \  __/ | |__| (_| \__ \  __/  / __/
-#  \___/|___/\___|  \____\__,_|___/\___| |_____|
 
+# use-case 2
 
 def exnihilo_scao_psf():
     """
-
     You want to generate SCAO PSFs ex-nihilo, using a simple, approximative
     simulation software.
     You are aware that the simulated PSFs will be perfectly smooth (infinitely
@@ -128,8 +136,6 @@ def exnihilo_scao_psf():
     For this you need to know all the parameters of the simulation.
 
     """
-
-    ###########
     # Setup
 
     # nb of pixels of the image to be simulated.
@@ -152,7 +158,8 @@ def exnihilo_scao_psf():
     L0 = 25.   # 25 metres is the Armazones median value
     seeing = 0.8          # in arcseconds
     r0Vis = 0.103 / seeing  # r0Vis is in metres here, 0.103 is in metres.arcsec
-    r0IR = r0Converter(r0Vis, 500e-9, wavelengthIR) # convert r0 at 500nm to IR
+    # convert r0 at 500nm to IR
+    r0IR = r0Converter(r0Vis, 500e-9, wavelengthIR)
 
     # Just to use that wonderful function, i decide that the seeing given here
     # was expressed at zenith, while our telescope observes at 30° from zenith.
@@ -161,7 +168,8 @@ def exnihilo_scao_psf():
     # telescope, so that their apparent distance grows with airmass --> this is
     # very bad for anisoplanatism !..
     zenDist = 30.  # I observe at 30° from zenith
-    r0IR = airmassImpact(r0IR, zenDist)  # apparent seeing degrades with airmass
+    # apparent seeing degrades with airmass
+    r0IR = airmassImpact(r0IR, zenDist)
 
     layerAltitude = np.array(layerAltitude)
     layerAltitude *= 1/np.cos(zenDist*np.pi/180)  # layers appear further away
@@ -184,12 +192,9 @@ def exnihilo_scao_psf():
     # Here is the position of the object in the field
     offx, offy = (10., 0.)
 
-
-    #################
     # PSF generation
 
-    # Let's go. Let's define some basic parameters (arrays of spatial
-    # frequencies)
+    # Let's define some basic parameters (arrays of spatial frequencies)
     kx, ky, uk = computeSpatialFreqArrays(N, pixelSize, wavelengthIR)
     M4 = defineDmFrequencyArea(kx, ky, rotdegree)
 
@@ -215,22 +220,16 @@ def exnihilo_scao_psf():
     FTOtel = computeEeltOTF(pup)
     psf = core_generatePsf(Dphi, FTOtel)
 
-    print('Strehl is ', psf.max())
-    plt.imshow( np.log(psf) )
+    print("Strehl is ", psf.max())
+    plt.imshow(np.log(psf))
 
     return psf
 
 
-#  _   _             ____                 _____
-# | | | |___  ___   / ___|__ _ ___  ___  |___ /
-# | | | / __|/ _ \ | |   / _` / __|/ _ \   |_ \
-# | |_| \__ \  __/ | |__| (_| \__ \  __/  ___) |
-#  \___/|___/\___|  \____\__,_|___/\___| |____/
-
+# use-case 3
 
 def instantaneous_scao_psf():
     """
-
     The dirty one.
     Let's try to simulate the fluctuations due to short exposures.
 
@@ -275,10 +274,3 @@ def instantaneous_scao_psf():
     # Here, possibilities are infinite ..
     # You can add some static aberrations, etc etc,
     # and generate all the PSFs you want.
-
-
-
-
-
-
-

anisocado/misc.py

@@ -1,18 +1,19 @@
+# -*- coding: utf-8 -*-
+
 import numpy as np
 from astropy.io import fits
 from astropy.table import Table
 
 from matplotlib import pyplot as plt
-from matplotlib.colors import LogNorm
 
 from anisocado import AnalyticalScaoPsf
 
 
-def strehl_map(r=25, dr=3, **kwargs):
+def strehl_map(r: int = 25, dr: int = 3, **kwargs):
     psf = AnalyticalScaoPsf(**kwargs)
     x, y = np.mgrid[-r:r+dr:dr, -r:dr+r:dr]
 
-    strlmap = np.zeros(x.shape)
+    strlmap = np.zeros_like(x)
     for i in range(len(x)):
         for j in range(len(y)):
             psf.shift_off_axis(x[i, j], y[i, j])
@@ -22,11 +23,11 @@ def strehl_map(r=25, dr=3, **kwargs):
 
 
 def on_axis_strehl_for_kernel_size(Narr=(128, 512, 2048), **kwargs):
-    """Only for the on-axis kernel"""
+    """Only for the on-axis kernel."""
     return [AnalyticalScaoPsf(N=N, **kwargs).strehl_ratio for N in Narr]
 
 
-def make_psf_grid(r=14, dr=7, **kwargs):
+def make_psf_grid(r: int = 14, dr: int = 7, **kwargs):
     psf = AnalyticalScaoPsf(**kwargs)
     x, y = np.mgrid[-r:r+1:dr, -r:r+1:dr]
 
@@ -39,26 +40,30 @@ def make_psf_grid(r=14, dr=7, **kwargs):
     return psf_grid
 
 
-def make_image_of_psf_grid(filt_name="Ks", wave=2.15, for_joss=True):
+def make_image_of_psf_grid(
+    filt_name: str = "Ks",
+    wave: float = 2.15,
+    for_joss: bool = True
+) -> None:
     psf_grid = make_psf_grid(wavelength=wave, N=128)
 
     plt.figure(figsize=(10, 10))
     i = 0
     for y in range(5):
         for x in range(5):
-            plt.subplot(5, 5, 1+x+5*(4-y))
-            plt.imshow(psf_grid[i], origin="l", norm=LogNorm())
+            plt.subplot(5, 5, 1 + x + 5 * (4 - y))
+            plt.imshow(psf_grid[i], origin="lower", norm="log")
             plt.axis("off")
-            plt.title("({}, {})".format((7*x-14), (7*x-14)))
+            plt.title(f"({7*x - 14}, {7*x - 14})")
             i += 1
 
     if for_joss:
         plt.tight_layout()
-        path = "../docs/joss_paper/{}-band_psf_grid".format(filt_name)
+        path = f"../docs/joss_paper/{filt_name}-band_psf_grid"
         plt.savefig(path+".png", format="png")
         plt.savefig(path+".pdf", format="pdf")
     else:
-        plt.suptitle("{}-band ({}um) SCAO PSFs".format(filt_name, wave))
+        plt.suptitle(f"{filt_name}-band ({wave} um) SCAO PSFs")
 
 
 # make_image_of_psf_grid("Ks", 2.15)
@@ -66,7 +71,12 @@ def make_image_of_psf_grid(filt_name="Ks", wave=2.15, for_joss=True):
 # make_image_of_psf_grid("J", 1.2)
 
 
-def make_simcado_psf_file(coords, wavelengths, header_cards=None, **kwargs):
+def make_simcado_psf_file(
+    coords,
+    wavelengths,
+    header_cards=None,
+    **kwargs,
+) -> fits.HDUList:
     """
     Generate a set of Field-Varying PSF cubes for use with SimCADO
 
@@ -142,7 +152,7 @@ def make_simcado_psf_file(coords, wavelengths, header_cards=None, **kwargs):
 
     psf_hdus = []
     for wave in wavelengths:
-        print("Making psf cube for {} um".format(wave))
+        print(f"Making psf cube for {wave} um")
         psf = AnalyticalScaoPsf(wavelength=wave, **kwargs)
         kernel_cube = [psf.shift_off_axis(dx, dy) for dx, dy in coords]
 
@@ -158,9 +168,12 @@ def make_simcado_psf_file(coords, wavelengths, header_cards=None, **kwargs):
     return hdulist
 
 
-def field_positions_for_simcado_psf(radii=None, theta=45):
+def field_positions_for_simcado_psf(
+    radii: list[float] | None = None,
+    theta: float = 45.,
+) -> list[tuple[float, float]]:
     """
-    Generates a list of field position where the PSF will be sampled
+    Generate a list of field position where the PSF will be sampled.
 
     The PSF will be sampled at intervals of ``theta`` around concentric circles
     placed at distances ``radii`` from the centre of the field of view.
@@ -189,10 +202,9 @@ def field_positions_for_simcado_psf(radii=None, theta=45):
         hdu = anisocado.make_simcado_psf_file(cds, wavelengths=[1.2, 1.6, 2.2])
 
     """
-
     coords = [(0, 0)]
     if radii is None:
-        radii =  [1, 2, 4, 8, 16, 32]
+        radii = [1, 2, 4, 8, 16, 32]
     for r in radii:
         for ang in np.arange(0, 360, theta):
             coords += [(r * np.cos(np.deg2rad(ang)),
@@ -205,11 +217,9 @@ def make_strehl_map_from_coords(coords):
     x, y = np.array(coords).T
 
     from scipy.interpolate import griddata
-    map = griddata((x, y), np.arange(len(x)),
-                   np.array(np.meshgrid(np.arange(-25, 26),
-                                        np.arange(-25, 26))).T,
-                   method="nearest")
-
-    return map
-
+    smap = griddata((x, y), np.arange(len(x)),
+                    np.array(np.meshgrid(np.arange(-25, 26),
+                                         np.arange(-25, 26))).T,
+                    method="nearest")
 
+    return smap

anisocado/psf.py

@@ -1,15 +1,37 @@
+# -*- coding: utf-8 -*-
+"""Contains AnalyticalScaoPsf, the main product of this package."""
+
 import warnings
+
+import numpy as np
 from matplotlib import pyplot as plt
 from matplotlib.colors import LogNorm
 
 from astropy.io import fits
 
-from .psf_utils import *
+from .psf_utils import (
+    get_atmospheric_turbulence,
+    computeEeltOTF,
+    computeSpatialFreqArrays,
+    get_profile_defaults,
+    anisoplanaticSpectrum,
+    convertSpectrum2Dphi,
+    defineDmFrequencyArea,
+    computeBpSpectrum,
+    otherSpectrum,
+    airmassImpact,
+    fittingSpectrum,
+    aliasingSpectrum,
+    computeWiener,
+    r0Converter,
+    fake_generatePupil,
+    core_generatePsf,
+)
 
 
 class AnalyticalScaoPsf:
     """
-    A class to generate SCAO PSFs for the ELT
+    A class to generate SCAO PSFs for the ELT.
 
     It is important to note that original PSF is generated for an on-axis
     guide star (``self.psf_on_axis``) at a specific wavelength. This PSF is
@@ -31,7 +53,8 @@ class AnalyticalScaoPsf:
     wavelength : float
         [um] Default: 2.15 um. Wavelength for which the PSF should be generated
     rotdegree : float
-        [deg] Default: 0 deg. Rotation angle of the pupil w.r.t the plane of the optical axis
+        [deg] Default: 0 deg. Rotation angle of the pupil w.r.t the plane of
+        the optical axis.
     nmRms : float
         [nm] Default: 100 nm. Residual wavefront error of the system
     L0 : float
@@ -142,13 +165,13 @@ class AnalyticalScaoPsf:
         self._kernel_sum = None
         self.seed = None
         self.rng = None
-        
+
         self.__dict__.update(psf_on_axis)
         self.update()
 
-    def update(self, **kwargs):
+    def update(self, **kwargs) -> None:
         """
-        Updates the parameter needed to generate a PSF and/or shift if off-axis
+        Update the parameter needed to generate a PSF and/or shift if off-axis.
 
         Valid parameter names can be found in ``self.kwarg_names``
 
@@ -156,10 +179,10 @@ class AnalyticalScaoPsf:
         self._wave_m = self.wavelength
         if self.wavelength > 0.1:  # assume its in um
             self._wave_m *= 1e-6
-        
+
         for key in kwargs:
             if key not in self.kwarg_names:
-                warnings.warn("{} not found in self.kwarg_names".format(key))
+                warnings.warn(f"{key} not found in self.kwarg_names")
 
         self.__dict__.update(kwargs)
         if self.seed is not None:
@@ -208,7 +231,7 @@ class AnalyticalScaoPsf:
             self.psf_on_axis = self.make_psf()
             self.psf_latest = self.psf_on_axis
 
-    def make_psf(self):
+    def make_psf(self) -> np.ndarray:
         """
         Generates a analytical SCAO PSF for a long (>10 sec) exposure
 
@@ -218,7 +241,7 @@ class AnalyticalScaoPsf:
 
         Returns
         -------
-        psf : array
+        psf : np.ndarray
             The PSF kernel
 
         Examples
@@ -234,7 +257,8 @@ class AnalyticalScaoPsf:
                                        dx, dy, self._wave_m,
                                        self.kx, self.ky, self.W, self.M4)
         Wfit = fittingSpectrum(self.W, self.M4)
-        Walias = aliasingSpectrum(self.kx, self.ky, self.r0IR, self.L0, self.M4)
+        Walias = aliasingSpectrum(
+            self.kx, self.ky, self.r0IR, self.L0, self.M4)
         Wbp = computeBpSpectrum(self.kx, self.ky, self.V, self.Fe, self.tret,
                                 self.gain, self.W, self.M4)
         Wother = otherSpectrum(self.nmRms, self.M4, self.uk, self._wave_m)
@@ -257,27 +281,22 @@ class AnalyticalScaoPsf:
 
         return psf
 
-    def shift_off_axis(self, dx, dy):
+    def shift_off_axis(self, dx: float, dy: float) -> np.ndarray:
         """
-        Shifts the on-axis PSF off axis by an amount ``(dx, dy)`` in arcsec
+        Shift the on-axis PSF off axis by an amount ``(dx, dy)`` in arcsec.
 
         Parameters
         ----------
         dx, dy : float
             [arcsec] Offset in each of the dimensions relative to the plane of
-            the optical axis
+            the optical axis.
 
         Returns
         -------
-        psf : array
-            The PSF kernel
-
-        Examples
-        --------
-
+        psf : np.ndarray
+            The PSF kernel.
 
         """
-
         self.x_last = dx
         self.y_last = dy
 
@@ -302,9 +321,13 @@ class AnalyticalScaoPsf:
 
         return psf
 
-    def make_short_exposure_psf(self, dit=1.0, screen_step_length=0.5):
+    def make_short_exposure_psf(
+        self,
+        dit: float = 1.0,
+        screen_step_length: float = 0.5,
+    ) -> np.ndarray:
         """
-        Returns a PSF for an 'short' exposure time of ``DIT``
+        Return a PSF for an 'short' exposure time of ``DIT``.
 
         The PSF kernel will be a single 2D array made from N stacked
         instantaneous PSFs, where the instantaneous PSFs are generated at time
@@ -313,23 +336,18 @@ class AnalyticalScaoPsf:
 
         Parameters
         ----------
-        dit : float
-            [s] Default is 1.0 sec. Exposure time for the PSF
-
-        screen_step_length : float
+        dit : float, optional
+            Exposure time for the PSF in seconds. The default is 1.0 s.
+        screen_step_length : float, optional
             [m] Sample step length for atmospheric phase screen
             Default is 0.5m - the length of the M4 actuator pitch
 
         Returns
         -------
-        psfLE : array
-
-        Examples
-        --------
-
+        psfLE : np.ndarray
+            DESCRIPTION.
 
         """
-
         # The dirty one.
         # Let's try to simulate the fluctuations due to short exposures.
         Waniso = anisoplanaticSpectrum(self.Cn2h, self.layerAltitude, self.L0,
@@ -337,7 +355,8 @@ class AnalyticalScaoPsf:
                                        self._wave_m, self.kx, self.ky,
                                        self.W, self.M4)
         Wfit = fittingSpectrum(self.W, self.M4)
-        Walias = aliasingSpectrum(self.kx, self.ky, self.r0IR, self.L0, self.M4)
+        Walias = aliasingSpectrum(
+            self.kx, self.ky, self.r0IR, self.L0, self.M4)
         Wbp = computeBpSpectrum(self.kx, self.ky, self.V, self.Fe, self.tret,
                                 self.gain, self.W, self.M4)
         Wother = otherSpectrum(self.nmRms, self.M4, self.uk, self._wave_m)
@@ -386,26 +405,26 @@ class AnalyticalScaoPsf:
 
     @property
     def strehl_ratio(self):
-        """Return an Strehl ratio of the kernel in ``self.psf_latest``"""
+        """Return a Strehl ratio of the kernel in ``self.psf_latest``."""
         return np.max(self.psf_latest) * self._kernel_sum
 
     @property
     def kernel(self):
-        """Return the kernel held in ``self.psf_latest``"""
+        """Return the kernel held in ``self.psf_latest``."""
         return self.psf_latest
 
     @property
     def hdu(self):
-        """Return the ``ImageHDU`` from ``get_hdu()``"""
+        """Return the ``ImageHDU`` from ``get_hdu()``."""
         return self.get_hdu()
 
-    def writeto(self, **kwargs):
-        """Calls the ``writeto`` method of the ImageHDU from ``self.hdu``"""
+    def writeto(self, **kwargs) -> None:
+        """Call the ``writeto`` method of the ImageHDU from ``self.hdu``."""
         self.hdu.writeto(**kwargs)
 
-    def get_hdu(self, **kwargs):
+    def get_hdu(self, **kwargs) -> fits.ImageHDU:
         """
-        Makes an ``ImageHDU`` with the kernel and relevant header info
+        Make an ``ImageHDU`` with the kernel and relevant header info.
 
         Additional keyword-value pairs can be passed to the header as kwargs
 
@@ -418,7 +437,7 @@ class AnalyticalScaoPsf:
 
         hdr = fits.Header()
         hdr["CDELT1"] = self.pixelSize / 3600.  # because pixelSize is in arcsec
-        hdr["CDELT2"] = self.pixelSize / 3600.  
+        hdr["CDELT2"] = self.pixelSize / 3600.
         hdr["CRVAL1"] = self.x_last / 3600.
         hdr["CRVAL2"] = self.y_last / 3600.
         hdr["CRPIX1"] = w / 2.
@@ -439,9 +458,7 @@ class AnalyticalScaoPsf:
 
         return hdu_psf
 
-    def plot_psf(self, which="psf_latest"):
-        """Plots a logscale PSF kernel: ["psf_latest", "psf_on_axis"]"""
-        plt.imshow(getattr(self, which).T, origin='l', norm=LogNorm())
-        print('Strehl ratio of {} is {}'.format(which, self.psf_latest.max()))
-
-
+    def plot_psf(self, which="psf_latest") -> None:
+        """Plot a logscale PSF kernel: ["psf_latest", "psf_on_axis"]."""
+        plt.imshow(getattr(self, which).T, origin='l', norm="log")
+        print(f"Strehl ratio of {which} is {self.psf_latest.max()}")