Added esis.optics.PrimaryMirror class. (#11)

Author: roytsmart

esis/optics/__init__.py

@@ -5,9 +5,11 @@
 from . import abc
 from ._front_apertures import FrontAperture
 from ._central_obscurations import CentralObscuration
+from ._primary_mirrors import PrimaryMirror
 
 __all__ = [
     "abc",
     "FrontAperture",
     "CentralObscuration",
+    "PrimaryMirror",
 ]

esis/optics/_primary_mirrors/__init__.py

@@ -0,0 +1,9 @@
+from ._primary_mirrors import (
+    AbstractPrimaryMirror,
+    PrimaryMirror,
+)
+
+__all__ = [
+    "AbstractPrimaryMirror",
+    "PrimaryMirror",
+]

esis/optics/_primary_mirrors/_primary_mirrors.py

@@ -0,0 +1,163 @@
+import abc
+import dataclasses
+import numpy as np
+import astropy.units as u
+import named_arrays as na
+import optika
+
+__all__ = [
+    "AbstractPrimaryMirror",
+    "PrimaryMirror",
+]
+
+
+@dataclasses.dataclass(eq=False, repr=False)
+class AbstractPrimaryMirror(
+    optika.mixins.Printable,
+    optika.mixins.Rollable,
+    optika.mixins.Yawable,
+    optika.mixins.Pitchable,
+    optika.mixins.Translatable,
+):
+    """
+    An interface describing the primary mirror of the instrument.
+    """
+
+    @property
+    @abc.abstractmethod
+    def sag(self) -> None | optika.sags.AbstractSag:
+        """
+        The sag function of this primary mirror.
+        """
+
+    @property
+    @abc.abstractmethod
+    def num_folds(self) -> u.Quantity | na.AbstractScalar:
+        """
+        The order of the rotational symmetry of the optical system.
+        This is also the number of sides of the regular polygonal aperture.
+        """
+
+    @property
+    @abc.abstractmethod
+    def width_clear(self) -> u.Quantity | na.AbstractScalar:
+        """
+        The width of the clear aperture from edge to edge.
+        """
+
+    @property
+    def radius_clear(self) -> u.Quantity | na.AbstractScalar:
+        """
+        The clear radius of the aperture from center to vertex.
+        """
+        halfwidth_clear = self.width_clear / 2
+        num_sides = self.num_folds
+        if (num_sides % 2) != 0:  # pragma: nocover
+            raise ValueError("odd numbers of sides not supported")
+        result = halfwidth_clear / np.cos(360 * u.deg / num_sides / 2)
+        return result
+
+    @property
+    @abc.abstractmethod
+    def width_border(self) -> u.Quantity | na.AbstractScalar:
+        """
+        The width of the border around the clear aperture.
+        """
+
+    @property
+    def radius_mechanical(self) -> u.Quantity | na.AbstractScalar:
+        """
+        The radius of the mechanical aperture from center to vertex.
+        """
+        halfwidth_clear = self.width_clear / 2
+        width_border = self.width_border
+        halfwidth = halfwidth_clear + width_border
+        num_sides = self.num_folds
+        if (num_sides % 2) != 0:  # pragma: nocover
+            raise ValueError("odd numbers of sides not supported")
+        result = halfwidth / np.cos(360 * u.deg / num_sides / 2)
+        return result
+
+    @property
+    @abc.abstractmethod
+    def material(self) -> None | optika.materials.AbstractMaterial:
+        """
+        The optics material composing this object.
+        """
+
+    @property
+    def surface(self) -> optika.surfaces.Surface:
+        """
+        Represent this object as an :mod:`optika` surface.
+        """
+        return optika.surfaces.Surface(
+            name="primary",
+            sag=self.sag,
+            material=self.material,
+            aperture=optika.apertures.RegularPolygonalAperture(
+                radius=self.radius_clear,
+                num_vertices=self.num_folds,
+            ),
+            aperture_mechanical=optika.apertures.RegularPolygonalAperture(
+                radius=self.radius_mechanical,
+                num_vertices=self.num_folds,
+            ),
+            transformation=self.transformation,
+        )
+
+
+@dataclasses.dataclass(eq=False, repr=False)
+class PrimaryMirror(
+    AbstractPrimaryMirror,
+):
+    """
+    A model of the primary mirror of the instrument.
+
+    This mirror collects light from the Sun and focuses it onto the field stop.
+    """
+
+    sag: None | optika.sags.AbstractSag = None
+    """
+    The sag function of this primary mirror.
+    """
+
+    num_folds: int = 0
+    """
+    The order of the rotational symmetry of the optical system.
+    This is also the number of sides of the regular polygonal aperture.
+    """
+
+    width_clear: u.Quantity | na.AbstractScalar = 0 * u.mm
+    """
+    The width of the clear aperture from edge to edge.
+    """
+
+    width_border: u.Quantity | na.AbstractScalar = 0 * u.mm
+    """
+    The width of the border around the clear aperture.
+    """
+
+    material: None | optika.materials.AbstractMaterial = None
+    """
+    The optical material composing this object.
+    """
+
+    translation: u.Quantity | na.AbstractCartesian3dVectorArray = 0 * u.mm
+    """
+    A transformation which can arbitrarily translate this object.
+    """
+
+    pitch: u.Quantity | na.AbstractScalar = 0 * u.deg
+    """
+    The pitch angle of this object.
+    """
+
+    yaw: u.Quantity | na.AbstractScalar = 0 * u.deg
+    """
+    The yaw angle of this object.
+    """
+
+    roll: u.Quantity | na.AbstractScalar = 0 * u.deg
+    """
+    The roll angle of this object
+    """

esis/optics/_primary_mirrors/_primary_mirrors_test.py

@@ -0,0 +1,92 @@
+import numpy as np
+import pytest
+import astropy.units as u
+import named_arrays as na
+import optika
+from optika._tests import test_mixins
+import esis
+
+
+class AbstractTestAbstractPrimaryMirror(
+    test_mixins.AbstractTestPrintable,
+    test_mixins.AbstractTestRollable,
+    test_mixins.AbstractTestYawable,
+    test_mixins.AbstractTestPitchable,
+    test_mixins.AbstractTestTranslatable,
+):
+    def test_sag(
+        self,
+        a: esis.optics.abc.AbstractPrimaryMirror,
+    ):
+        assert isinstance(a.sag, optika.sags.AbstractSag)
+
+    def test_num_folds(
+        self,
+        a: esis.optics.abc.AbstractPrimaryMirror,
+    ):
+        assert isinstance(a.num_folds, int)
+        assert a.num_folds > 2
+
+    def test_width_clear(
+        self,
+        a: esis.optics.abc.AbstractPrimaryMirror,
+    ):
+        assert isinstance(na.as_named_array(a.width_clear), na.AbstractScalar)
+        assert na.unit_normalized(a.width_clear).is_equivalent(u.mm)
+
+    def test_radius_clear(
+        self,
+        a: esis.optics.abc.AbstractPrimaryMirror,
+    ):
+        assert isinstance(na.as_named_array(a.radius_clear), na.AbstractScalar)
+        assert na.unit_normalized(a.radius_clear).is_equivalent(u.mm)
+
+    def test_width_border(
+        self,
+        a: esis.optics.abc.AbstractPrimaryMirror,
+    ):
+        assert isinstance(na.as_named_array(a.width_border), na.AbstractScalar)
+        assert na.unit_normalized(a.width_border).is_equivalent(u.mm)
+
+    def test_radius_mechanical(
+        self,
+        a: esis.optics.abc.AbstractPrimaryMirror,
+    ):
+        assert isinstance(na.as_named_array(a.radius_mechanical), na.AbstractScalar)
+        assert na.unit_normalized(a.radius_mechanical).is_equivalent(u.mm)
+
+    def test_material(
+        self,
+        a: esis.optics.abc.AbstractPrimaryMirror,
+    ):
+        assert isinstance(a.material, optika.materials.AbstractMaterial)
+
+    def test_translation(
+        self,
+        a: esis.optics.abc.AbstractPrimaryMirror,
+    ):
+        result = a.translation
+        assert np.issubdtype(na.get_dtype(result), float)
+        assert na.unit_normalized(result).is_equivalent(u.mm)
+
+    def test_surface(
+        self,
+        a: esis.optics.abc.AbstractPrimaryMirror,
+    ):
+        assert isinstance(a.surface, optika.surfaces.AbstractSurface)
+
+
+@pytest.mark.parametrize(
+    argnames="a",
+    argvalues=[
+        esis.optics.PrimaryMirror(
+            sag=optika.sags.ParabolicSag(1000 * u.mm),
+            num_folds=8,
+            material=optika.materials.Mirror(),
+        ),
+    ],
+)
+class TestPrimaryMirror(
+    AbstractTestAbstractPrimaryMirror,
+):
+    pass

esis/optics/abc.py

@@ -4,8 +4,10 @@
 
 from ._front_apertures import AbstractFrontAperture
 from ._central_obscurations import AbstractCentralObscuration
+from ._primary_mirrors import AbstractPrimaryMirror
 
 __all__ = [
     "AbstractFrontAperture",
     "AbstractCentralObscuration",
+    "AbstractPrimaryMirror",
 ]