yippy 0.1__tar.gz

yippy-0.1/.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,93 @@
+name: Publish to PyPI
+
+on: push
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.x"
+    - name: Install pypa/build
+      run: >-
+        python3 -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: python3 -m build
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v3
+      with:
+        name: python-package-distributions
+        path: dist/
+
+  publish-to-pypi:
+    name: >-
+      Publish Python distribution to PyPI
+    if: startsWith(github.ref, 'refs/tags/')
+    needs:
+    - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/yippy
+    permissions:
+      id-token: write
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v3
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    name: >-
+      Sign the Python distribution with Sigstore
+      and upload them to GitHub Release
+    needs:
+    - publish-to-pypi
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v3
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Sign the dists with Sigstore
+      uses: sigstore/gh-action-sigstore-python@v1.2.3
+      with:
+        inputs: >-
+          ./dist/*.tar.gz
+          ./dist/*.whl
+    - name: Create GitHub Release
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+      run: >-
+        gh release create
+        '${{ github.ref_name }}'
+        --repo '${{ github.repository }}'
+        --notes ""
+    - name: Upload artifact signatures to GitHub Release
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+      # Upload to GitHub Release using the `gh` CLI.
+      # `dist/` contains the built packages, and the
+      # sigstore-produced signatures and certificates.
+      run: >-
+        gh release upload
+        '${{ github.ref_name }}' dist/**
+        --repo '${{ github.repository }}'

yippy-0.1/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

yippy-0.1/.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: "v4.5.0"
+    hooks:
+      - id: trailing-whitespace
+      - id: name-tests-test
+      - id: end-of-file-fixer
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.3.0
+    hooks:
+      # Run the linter.
+      - id: ruff
+        args: [ --fix ]
+      # Run the formatter.
+      - id: ruff-format

yippy-0.1/LICENSE

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

yippy-0.1/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.3
+Name: yippy
+Version: 0.1
+Summary: A minimal wrapper to create a coronagraph object from a yield input package
+Project-URL: Homepage, https://github.com/CoreySpohn/yippy
+Project-URL: Issues, https://github.com/CoreySpohn/yippy/issues
+Author-email: Corey Spohn <corey.a.spohn@nasa.gov>
+License: MIT License
+        
+        Copyright (c) 2024 Corey Spohn
+        
+        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.
+License-File: LICENSE
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Requires-Dist: astropy
+Requires-Dist: lod-unit
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Description-Content-Type: text/markdown
+
+# yippy
+A minimal wrapper to create a coronagraph object from a yield input package

yippy-0.1/README.md

@@ -0,0 +1,2 @@
+# yippy
+A minimal wrapper to create a coronagraph object from a yield input package

yippy-0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ['hatchling', "hatch-fancy-pypi-readme"]
+build-backend = "hatchling.build"
+
+[project]
+name = "yippy"
+version = "0.1"
+authors = [{ name = "Corey Spohn", email = "corey.a.spohn@nasa.gov" }]
+description = "A minimal wrapper to create a coronagraph object from a yield input package"
+dependencies = ["numpy", "astropy", "scipy", "lod_unit", "tqdm"]
+license = { file = "LICENSE" }
+dynamic = ['readme']
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering :: Astronomy",
+]
+
+[project.urls]
+Homepage = "https://github.com/CoreySpohn/yippy"
+Issues = "https://github.com/CoreySpohn/yippy/issues"
+
+[tool.hatch.metadata.hooks.fancy-pypi-readme]
+content-type = "text/markdown"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]]
+path = "README.md"

yippy-0.1/src/yippy/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ["Coronagraph", "setup_logger", "logger"]
+
+from .coronagraph import Coronagraph
+from .logger import setup_logger

yippy-0.1/src/yippy/coronagraph.py

@@ -0,0 +1,456 @@
+from pathlib import Path
+
+import astropy.io.fits as pyfits
+import astropy.units as u
+import numpy as np
+import xarray as xr
+from lod_unit import lod
+from scipy.interpolate import RegularGridInterpolator, interp1d
+from scipy.ndimage import rotate, zoom
+from tqdm import tqdm
+
+from yippy.logger import setup_logger
+
+
+class Coronagraph:
+    def __init__(self, yip_path, logging_level="INFO"):
+        """
+        Args:
+            yip_path (str):
+                Yield input package directory. Must have fits files
+                    stellar_intens.fits - Stellar intensity map
+                        Unitless 3d array of the stellar intensity function I,
+                        as a function of (x, y) pixel coordinates and the
+                        stellar angular diameter theta_star. Values in the map
+                        are equal to the stellar count rate in a given pixel
+                        divided by the total stellar count rate entering the
+                        coronagraph. Does not include reductions such as QE, as
+                        in without a coronagraph the total of I is unity.
+                    stellar_intens_diam_list.fits - Stellar diameter list
+                        A vector of stellar diameter values (lam/D) corresponding
+                        to the theta_star values in stellar_intens.
+                    offax_psf_offset_list - The off-axis PSF list
+                    offax_psf - PSF of off-axis sources
+                    sky_trans - Sky transmission data
+            logging_level (str):
+                Logging level for the logger (e.g. INFO, DEBUG, WARNING, ERROR,
+                CRITICAL), use to suppress logging if used as part of a larger
+                workflow. Default is INFO.
+        """
+
+        self.logger = setup_logger(logging_level)
+        ###################
+        # Read input data #
+        ###################
+        self.logger.info("Creating coronagraph")
+
+        yip_path = Path(yip_path)
+        self.name = yip_path.stem
+        # Get header and calculate the lambda/D value
+        stellar_intens_header = pyfits.getheader(
+            Path(yip_path, "stellar_intens.fits"), 0
+        )
+
+        # Stellar intensity of the star being observed as function of stellar
+        # angular diameter (unitless)
+        self.stellar_intens = pyfits.getdata(Path(yip_path, "stellar_intens.fits"), 0)
+        # the stellar angular diameters in stellar_intens_1 in units of lambda/D
+        self.stellar_intens_diam_list = (
+            pyfits.getdata(Path(yip_path, "stellar_intens_diam_list.fits"), 0) * lod
+        )
+
+        # Get pixel scale with units
+        self.pixel_scale = stellar_intens_header["PIXSCALE"] * lod / u.pixel
+
+        # Load off-axis data (e.g. the planet) (unitless intensity maps)
+        self.offax_psf = pyfits.getdata(Path(yip_path, "offax_psf.fits"), 0)
+
+        # The offset list here is in units of lambda/D
+        self.offax_psf_offset_list = (
+            pyfits.getdata(Path(yip_path, "offax_psf_offset_list.fits"), 0) * lod
+        )
+
+        ########################################################################
+        # Determine the format of the input coronagraph files so we can handle #
+        # the coronagraph correctly (e.g. radially symmetric in x direction)   #
+        ########################################################################
+        if len(self.offax_psf_offset_list.shape) > 1:
+            if (self.offax_psf_offset_list.shape[1] != 2) and (
+                self.offax_psf_offset_list.shape[0] == 2
+            ):
+                # This condition occurs when the offax_psf_offset_list is transposed
+                # from the expected format for radially symmetric coronagraphs
+                self.offax_psf_offset_list = self.offax_psf_offset_list.T
+
+        # Check that we have both x and y offset information (even if there
+        # is only one axis with multiple values)
+        if self.offax_psf_offset_list.shape[1] != 2:
+            raise UserWarning("Array offax_psf_offset_list should have 2 columns")
+
+        # Get the unique values of the offset list so that we can format the
+        # data into
+        self.offax_psf_offset_x = np.unique(self.offax_psf_offset_list[:, 0])
+        self.offax_psf_offset_y = np.unique(self.offax_psf_offset_list[:, 1])
+
+        if (len(self.offax_psf_offset_x) == 1) and (
+            self.offax_psf_offset_x[0] == 0 * lod
+        ):
+            self.type = "1d"
+            # Instead of handling angles for 1dy, swap the x and y
+            self.offax_psf_offset_x, self.offax_psf_offset_y = (
+                self.offax_psf_offset_y,
+                self.offax_psf_offset_x,
+            )
+
+            # self.offax_psf_base_angle = 90.0 * u.deg
+            self.logger.info("Coronagraph is radially symmetric")
+        elif (len(self.offax_psf_offset_y) == 1) and (
+            self.offax_psf_offset_y[0] == 0 * lod
+        ):
+            self.type = "1d"
+            # self.offax_psf_base_angle = 0.0 * u.deg
+            self.logger.info("Coronagraph is radially symmetric")
+        elif len(self.offax_psf_offset_x) == 1:
+            # 1 dimensional with offset (e.g. no offset=0)
+            self.type = "1dno0"
+            self.offax_psf_offset_x, self.offax_psf_offset_y = (
+                self.offax_psf_offset_y,
+                self.offax_psf_offset_x,
+            )
+            # self.offax_psf_base_angle = 90.0 * u.deg
+            self.logger.info("Coronagraph is radially symmetric")
+        elif len(self.offax_psf_offset_y) == 1:
+            self.type = "1dno0"
+            # self.offax_psf_base_angle = 0.0 * u.deg
+            self.logger.info("Coronagraph is radially symmetric")
+        elif np.min(self.offax_psf_offset_list) >= 0 * lod:
+            self.type = "2dq"
+            # self.offax_psf_base_angle = 0.0 * u.deg
+            # self.logger.info(
+            #     f"Quarterly symmetric response --> reflecting PSFs ({self.type})"
+            # )
+            self.logger.info("Coronagraph is quarterly symmetric")
+        else:
+            self.type = "2df"
+            # self.offax_psf_base_angle = 0.0 * u.deg
+            self.logger.info("Coronagraph response is full 2D")
+
+        ############
+        # Clean up #
+        ############
+        # Center coronagraph model so that image size is odd and central pixel is center
+        # TODO: Automate this process
+        verified_coronagraph_models = [
+            "LUVOIR-A_APLC_10bw_smallFPM_2021-05-05_Dyn10pm-nostaticabb",
+            "LUVOIR-A_APLC_18bw_medFPM_2021-05-07_Dyn10pm-nostaticabb",
+            "LUVOIR-B-VC6_timeseries",
+            "LUVOIR-B_VC6_timeseries",
+        ]
+        if yip_path.parts[-1] in verified_coronagraph_models:
+            self.stellar_intens = self.stellar_intens[:, 1:, 1:]
+            self.offax_psf = self.offax_psf[:, :-1, 1:]
+        else:
+            raise UserWarning(
+                "Please validate centering for this unknown coronagraph model"
+            )
+
+        # Simulation parameters
+        self.yip_path = yip_path
+
+        #########################################################################
+        # Interpolate coronagraph model (in log space to avoid negative values) #
+        #########################################################################
+        # Fill value for interpolation
+        fill = np.log(1e-100)
+
+        # interpolate stellar data
+        self.ln_stellar_intens_interp = interp1d(
+            self.stellar_intens_diam_list,
+            np.log(self.stellar_intens),
+            kind="cubic",
+            axis=0,
+            bounds_error=False,
+            fill_value=fill,
+        )
+        self.stellar_intens_interp = lambda stellar_diam: np.exp(
+            self.ln_stellar_intens_interp(stellar_diam)
+        )
+
+        # interpolate planet data depending on type
+        if "1" in self.type:
+            # Always set up to interpolate along the x axis
+            self.ln_offax_psf_interp = interp1d(
+                self.offax_psf_offset_list[:, 0],
+                np.log(self.offax_psf),
+                kind="cubic",
+                axis=0,
+                bounds_error=False,
+                fill_value=fill,
+            )
+        else:
+            zz_temp = self.offax_psf.reshape(
+                self.offax_psf_offset_x.shape[0],
+                self.offax_psf_offset_y.shape[0],
+                self.offax_psf.shape[1],
+                self.offax_psf.shape[2],
+            )
+            if self.type == "2dq":
+                # Reflect PSFs to cover the x = 0 and y = 0 axes.
+                offax_psf_offset_x = np.append(
+                    -self.offax_psf_offset_x[0], self.offax_psf_offset_x
+                )
+                offax_psf_offset_y = np.append(
+                    -self.offax_psf_offset_y[0], self.offax_psf_offset_y
+                )
+                zz = np.pad(zz_temp, ((1, 0), (1, 0), (0, 0), (0, 0)))
+                zz[0, 1:] = zz_temp[0, :, ::-1, :]
+                zz[1:, 0] = zz_temp[:, 0, :, ::-1]
+                zz[0, 0] = zz_temp[0, 0, ::-1, ::-1]
+
+                self.ln_offax_psf_interp = RegularGridInterpolator(
+                    (offax_psf_offset_x, offax_psf_offset_y),
+                    np.log(zz),
+                    method="linear",
+                    bounds_error=False,
+                    fill_value=fill,
+                )
+            else:
+                # This section included references to non-class attributes for
+                # offax_psf_offset_x and offax_psf_offset_y. I think it meant
+                # to be the class attributes
+                self.ln_offax_psf_interp = RegularGridInterpolator(
+                    (self.offax_psf_offset_x, self.offax_psf_offset_y),
+                    np.log(zz_temp),
+                    method="linear",
+                    bounds_error=False,
+                    fill_value=fill,
+                )
+        self.offax_psf_interp = lambda coordinate: np.exp(
+            self.ln_offax_psf_interp(coordinate)
+        )
+
+        ##################################################
+        # Get remaining parameters and throughput values #
+        ##################################################
+
+        # Gets the number of pixels in the image
+        self.img_pixels = self.stellar_intens.shape[1] * u.pixel
+        self.npixels = self.img_pixels.value.astype(int)
+
+        # Photometric parameters.
+        head = pyfits.getheader(Path(yip_path, "stellar_intens.fits"), 0)
+
+        # fractional obscuration
+        self.frac_obscured = head["OBSCURED"]
+
+        # fractional bandpass
+        self.frac_bandwidth = (head["MAXLAM"] - head["MINLAM"]) / head["LAMBDA"]
+
+        # PSF datacube info
+        self.has_psf_datacube = False
+
+    def get_coro_thruput(self, aperture_radius_lod=0.8, oversample=100, plot=True):
+        """
+        Get coronagraph throughput
+        Args:
+            aperture_radius (float):
+                Circular aperture radius, in lambda/D (I think)
+            oversample (int):
+                Oversampling factor for interpolation
+            plot (Boolean):
+                Whether to plot the coronagraph throughput
+        Returns:
+            coro_thruput (float):
+                Coronagraph throughput
+        """
+        # Add units
+        aperture_radius = aperture_radius_lod * lod
+
+        # Compute off-axis PSF at the median separation value
+        # Previously was labeled half max, but there is no guarantee the
+        # separations are equally spaced
+        if len(self.offax_psf_offset_x) != 1:
+            med_offset = self.offax_psf_offset_x[self.offax_psf_offset_x.shape[0] // 2]
+        elif len(self.offax_psf_offset_y) != 1:
+            med_offset = self.offax_psf_offset_y[self.offax_psf_offset_y.shape[0] // 2]
+        else:
+            raise UserWarning(
+                (
+                    "Array offax_psf_offset_list should have more than 1"
+                    " unique element for at least one axis"
+                )
+            )
+        # Create (x, y) coordiantes of the aperture in lam/D
+        # if self.type in ["1dx", "1dxo"]:
+        aperture_pos = u.Quantity([med_offset, self.offax_psf_offset_y[0]])
+        # elif self.type in ["1dy", "1dyo"]:
+        #     aperture_pos = u.Quantity([self.offax_psf_offset_x[0], med_offset])
+
+        # Create image
+        imgs = self.offax_psf_interp(med_offset)
+
+        # Compute aperture position and radius on subarray in pixels.
+        # This was 3 times the aperture radius in pixels, I don't know why 3
+        # Npix = int(np.ceil(3 * aperture_radius / self.pixel_scale))
+        aperture_radius_pix = np.ceil(
+            3 * aperture_radius / self.pixel_scale
+        ).value.astype(int)
+
+        aperture_pos_pix = (
+            (aperture_pos / self.pixel_scale).value + (imgs.shape[0] - 1) / 2
+        ).astype(int)
+        subarr = imgs[
+            aperture_pos_pix[1] - aperture_radius_pix : aperture_pos_pix[1]
+            + aperture_radius_pix
+            + 1,
+            aperture_pos_pix[0] - aperture_radius_pix : aperture_pos_pix[0]
+            + aperture_radius_pix
+            + 1,
+        ]
+        # (aperture_pos / self.pixel_scale + (imgs.shape[0] - 1) / 2.0)
+        # This doesn't make sense to me
+        pos_subarr = [0, 0] + aperture_radius_pix
+        rad_subarr = aperture_radius / self.pixel_scale
+
+        # Compute aperture position and radius on oversampled subarray in pixels.
+        norm = np.sum(subarr)
+        subarr_zoom = zoom(subarr, oversample, mode="nearest", order=5)
+        subarr_zoom *= norm / np.sum(subarr_zoom)
+        pos_subarr_zoom = pos_subarr * oversample + (oversample - 1.0) / 2.0
+        rad_subarr_zoom = rad_subarr * oversample
+
+        # Compute aperture on oversampled subarray in pixels.
+        ramp = np.arange(subarr_zoom.shape[0])
+        offax_psf_offset_x, yy = np.meshgrid(ramp, ramp)
+        aptr = (
+            np.sqrt(
+                (offax_psf_offset_x - pos_subarr_zoom[0]) ** 2
+                + (yy - pos_subarr_zoom[1]) ** 2
+            )
+            <= rad_subarr_zoom.value
+        )
+
+        # Compute coronagraph throughput
+        coro_thruput = np.sum(subarr_zoom[aptr])
+
+        return coro_thruput
+
+    def get_disk_psfs(self):
+        """
+        Load the disk image from a file or generate it if it doesn't exist
+        """
+        # Load data cube of spatially dependent PSFs.
+        disk_dir = Path(".cache/disks/")
+        if not disk_dir.exists():
+            disk_dir.mkdir(parents=True, exist_ok=True)
+        path = Path(
+            disk_dir,
+            self.yip_path.name + ".nc",
+        )
+
+        coords = {
+            "x psf offset (pix)": np.arange(self.npixels),
+            "y psf offset (pix)": np.arange(self.npixels),
+            "x (pix)": np.arange(self.npixels),
+            "y (pix)": np.arange(self.npixels),
+        }
+        dims = ["x psf offset (pix)", "y psf offset (pix)", "x (pix)", "y (pix)"]
+        if path.exists():
+            self.logger.info(
+                "Loading data cube of spatially dependent PSFs, please hold..."
+            )
+            psfs_xr = xr.open_dataarray(path)
+        else:
+            self.logger.info(
+                "Calculating data cube of spatially dependent PSFs, please hold..."
+            )
+            # Compute pixel grid.
+            # lambda/D
+            pixel_lod = (
+                (np.arange(self.npixels) - ((self.npixels - 1) // 2))
+                * u.pixel
+                * self.pixel_scale
+            )
+
+            x_lod, y_lod = np.meshgrid(pixel_lod, pixel_lod, indexing="xy")
+
+            # lambda/D
+            pixel_dist_lod = np.sqrt(x_lod**2 + y_lod**2)
+
+            # deg
+            pixel_angle = np.arctan2(y_lod, x_lod)
+
+            # Compute pixel grid contrast.
+            psfs_shape = (
+                pixel_dist_lod.shape[0],
+                pixel_dist_lod.shape[1],
+                self.npixels,
+                self.npixels,
+            )
+            psfs = np.zeros(psfs_shape, dtype=np.float32)
+            npsfs = np.prod(pixel_dist_lod.shape)
+
+            pbar = tqdm(
+                total=npsfs, desc="Computing datacube of PSFs at every pixel", delay=0.5
+            )
+
+            radially_symmetric_psf = "1d" in self.type
+            # Get the PSF (npixel, npixel) of a source at every pixel
+
+            # Note: intention is that i value maps to x offset and j value maps
+            # to y offset
+            for i in range(pixel_dist_lod.shape[0]):
+                for j in range(pixel_dist_lod.shape[1]):
+                    # Basic structure here is to get the distance in lambda/D,
+                    # determine whether the psf has to be rotated (if the
+                    # coronagraph is defined in 1 dimension), evaluate
+                    # the offaxis psf at the distance, then rotate the
+                    # image
+                    if self.type == "1d":
+                        psf_eval_dists = pixel_dist_lod[i, j]
+                        rotate_angle = pixel_angle[i, j]
+                    elif self.type == "1dno0":
+                        psf_eval_dists = np.sqrt(
+                            pixel_dist_lod[i, j] ** 2 - self.offax_psf_offset_x[0] ** 2
+                        )
+                        rotate_angle = pixel_angle[i, j] + np.arcsin(
+                            self.offax_psf_offset_x[0] / pixel_dist_lod[i, j]
+                        )
+                    elif self.type == "2dq":
+                        # lambda/D
+                        temp = np.array([y_lod[i, j], x_lod[i, j]])
+                        psf = self.offax_psf_interp(np.abs(temp))[0]
+                        if y_lod[i, j] < 0.0:
+                            # lambda/D
+                            psf = psf[::-1, :]
+                        if x_lod[i, j] < 0.0:
+                            # lambda/D
+                            psf = psf[:, ::-1]
+                    else:
+                        # lambda/D
+                        temp = np.array([y_lod[i, j], x_lod[i, j]])
+                        psf = self.offax_psf_interp(temp)[0]
+
+                    if radially_symmetric_psf:
+                        psf = self.ln_offax_psf_interp(psf_eval_dists)
+                        temp = np.exp(
+                            rotate(
+                                psf,
+                                -rotate_angle.to(u.deg).value,
+                                reshape=False,
+                                mode="nearest",
+                                order=5,
+                            )
+                        )
+                    psfs[i, j] = temp
+                    pbar.update(1)
+
+            # Save data cube of spatially dependent PSFs.
+            psfs_xr = xr.DataArray(
+                psfs,
+                coords=coords,
+                dims=dims,
+            )
+            psfs_xr.to_netcdf(path)
+        self.has_psf_datacube = True
+        self.psf_datacube = np.ascontiguousarray(psfs_xr)

yippy-0.1/src/yippy/logger.py

@@ -0,0 +1,45 @@
+import logging
+
+
+def setup_logger(shell_level="INFO", file_level="DEBUG", disable_shell_logging=False):
+    # Map string level names to logging levels
+    level_mapping = {
+        "CRITICAL": logging.CRITICAL,
+        "ERROR": logging.ERROR,
+        "WARNING": logging.WARNING,
+        "INFO": logging.INFO,
+        "DEBUG": logging.DEBUG,
+        "NOTSET": logging.NOTSET,
+    }
+
+    logger = logging.getLogger(__name__)
+
+    logger.handlers = []  # Clear existing handlers
+
+    logger.setLevel(logging.DEBUG)  # Set the lowest level to capture all logs
+
+    # File Handler
+    file_handler = logging.FileHandler("debug.log")
+    file_handler.setLevel(level_mapping.get(file_level.upper(), logging.DEBUG))
+    file_fmt = (
+        "%(levelname)s %(asctime)s [%(filename)s:%(funcName)s:%(lineno)d] %(message)s"
+    )
+    file_formatter = logging.Formatter(file_fmt)
+    file_handler.setFormatter(file_formatter)
+    logger.addHandler(file_handler)
+
+    # Shell Handler
+    if not disable_shell_logging:
+        shell_handler = logging.StreamHandler()
+        shell_handler.setLevel(level_mapping.get(shell_level.upper(), logging.INFO))
+        shell_fmt = "%(levelname)s [%(asctime)s] %(message)s"
+        shell_formatter = logging.Formatter(shell_fmt)
+        shell_handler.setFormatter(shell_formatter)
+        logger.addHandler(shell_handler)
+
+    logger.propagate = False
+    return logger
+
+
+# Initialize with default settings
+logger = setup_logger()