Added esis.optics.CentralObscuration class.

Author: roytsmart

.github/workflows/tests.yml

@@ -0,0 +1,48 @@
+
+name: tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  pytest:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+        python-version: ["3.10", "3.12"]
+    name: ${{ matrix.os }}, Python ${{ matrix.python-version }} tests
+    steps:
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install package
+        run: |
+          python -m pip install --upgrade pip
+          pip install setuptools wheel
+          pip install -e .
+
+      - name: Test with pytest
+        run: |
+          pip install pytest pytest-cov
+          pytest --cov=. --cov-report=xml --cov-report=html
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: coverage.xml
+          flags: unittests
+          env_vars: OS,PYTHON
+          name: codecov-umbrella
+          fail_ci_if_error: true

esis/optics/__init__.py

@@ -0,0 +1,11 @@
+"""
+Model the ESIS optical system.
+"""
+
+from . import abc
+from ._central_obscurations import CentralObscuration
+
+__all__ = [
+    "abc",
+    "CentralObscuration",
+]

esis/optics/_central_obscurations/__init__.py

@@ -0,0 +1,9 @@
+from ._central_obscurations import (
+    AbstractCentralObscuration,
+    CentralObscuration,
+)
+
+__all__ = [
+    "AbstractCentralObscuration",
+    "CentralObscuration",
+]

esis/optics/_central_obscurations/_central_obscurations.py

@@ -0,0 +1,76 @@
+import abc
+import dataclasses
+import numpy as np
+import astropy.units as u
+import named_arrays as na
+import optika
+
+__all__ = [
+    "CentralObscuration",
+]
+
+
+@dataclasses.dataclass(eq=False, repr=False)
+class AbstractCentralObscuration(
+    optika.mixins.Printable,
+    optika.mixins.Translatable,
+):
+    @property
+    @abc.abstractmethod
+    def num_folds(self) -> int:
+        """the order of the rotational symmetry of the optical system"""
+
+    @property
+    @abc.abstractmethod
+    def halfwidth(self) -> u.Quantity | na.AbstractScalar:
+        """distance from the center to the edge of the obscuration"""
+
+    @property
+    def radius(self) -> u.Quantity | na.AbstractScalar:
+        """
+        distance from the center to a vertex of the obscuration
+        """
+        return self.halfwidth / np.cos(360 * u.deg / self.num_folds / 2)
+
+    @property
+    @abc.abstractmethod
+    def remove_last_vertex(self) -> bool:
+        """flag controlling whether the last vertex should be removed"""
+
+    @property
+    def surface(self) -> optika.surfaces.Surface:
+        num_folds = self.num_folds
+        radius = self.radius
+        offset_angle = 360 * u.deg / num_folds
+        angle = na.linspace(
+            start=0 * u.deg,
+            stop=360 * u.deg,
+            num=num_folds,
+            axis="vertex",
+            endpoint=False,
+        )
+        if self.remove_last_vertex:
+            angle = angle[dict(vertex=slice(None, ~0))]
+        angle = angle - offset_angle
+        return optika.surfaces.Surface(
+            name="obscuration",
+            aperture=optika.apertures.PolygonalAperture(
+                vertices=na.Cartesian3dVectorArray(
+                    x=radius * np.cos(angle),
+                    y=radius * np.sin(angle),
+                    z=0 * u.mm,
+                ),
+                inverted=True,
+            ),
+            transformation=self.transformation,
+        )
+
+
+@dataclasses.dataclass(eq=False, repr=False)
+class CentralObscuration(
+    AbstractCentralObscuration,
+):
+    num_folds: int = 0
+    halfwidth: u.Quantity | na.AbstractScalar = 0 * u.mm
+    remove_last_vertex: bool = False
+    translation: u.Quantity | na.AbstractCartesian3dVectorArray = 0 * u.mm

esis/optics/_central_obscurations/_central_obscurations_test.py

@@ -0,0 +1,54 @@
+import pytest
+import numpy as np
+import astropy.units as u
+import named_arrays as na
+import optika
+from optika._tests import test_mixins
+import esis
+
+
+class AbstractTestAbstractCentralObscuration(
+    test_mixins.AbstractTestPrintable,
+    test_mixins.AbstractTestTranslatable,
+):
+    def test_num_folds(self, a: esis.optics.abc.AbstractCentralObscuration):
+        result = a.num_folds
+        assert isinstance(result, int)
+        assert result >= 0
+
+    def test_halfwidth(self, a: esis.optics.abc.AbstractCentralObscuration):
+        result = a.halfwidth
+        assert na.unit_normalized(result).is_equivalent(u.mm)
+        assert np.all(result >= 0)
+
+    def test_radiush(self, a: esis.optics.abc.AbstractCentralObscuration):
+        result = a.radius
+        assert na.unit_normalized(result).is_equivalent(u.mm)
+        assert np.all(result >= 0)
+
+    def test_remove_last_vertex(self, a: esis.optics.abc.AbstractCentralObscuration):
+        result = a.remove_last_vertex
+        assert isinstance(result, bool)
+
+    def test_surface(self, a: esis.optics.abc.AbstractCentralObscuration):
+        result = a.surface
+        assert isinstance(result, optika.surfaces.AbstractSurface)
+        assert isinstance(result.aperture, optika.apertures.AbstractAperture)
+        assert np.all(result.aperture.inverted)
+
+
+@pytest.mark.parametrize(
+    argnames="a",
+    argvalues=[
+        esis.optics.CentralObscuration(
+            num_folds=8,
+            halfwidth=50 * u.mm,
+            remove_last_vertex=True,
+            translation=na.Cartesian3dVectorArray(z=100) * u.mm,
+        )
+    ],
+)
+class TestCentralObscuration(
+    AbstractTestAbstractCentralObscuration,
+):
+    pass

esis/optics/abc.py

@@ -0,0 +1,9 @@
+"""
+Abstract classes used in this module.
+"""
+
+from ._central_obscurations import AbstractCentralObscuration
+
+__all__ = [
+    "AbstractCentralObscuration",
+]