lezargus 0.0.4.dev42__tar.gz → 0.0.4.dev51__tar.gz

lezargus-0.0.4.dev51/.vscode/settings.json

@@ -0,0 +1,2 @@
+{
+}

{lezargus-0.0.4.dev42 → lezargus-0.0.4.dev51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lezargus
-Version: 0.0.4.dev42
+Version: 0.0.4.dev51
 Summary: The accompanying data software package to the IRTF SPECTRE Spectrograph.
 Project-URL: Homepage, http://irtfweb.ifa.hawaii.edu/~spectre/
 Project-URL: Documentation, https://psmd-iberutaru.github.io/Lezargus/

{lezargus-0.0.4.dev42 → lezargus-0.0.4.dev51}/docs/source/conf.py

@@ -5,7 +5,6 @@
 
 import os
 import sys
-import sphinx_book_theme
 
 # For the Python code itself.
 sys.path.insert(0, os.path.abspath(os.path.join("..", "..", "src")))

{lezargus-0.0.4.dev42 → lezargus-0.0.4.dev51}/pyproject.toml

@@ -57,10 +57,10 @@ exclude = [
 dependencies = [
     "pyinstaller",
     "coverage[toml]>=7.3.4",
-    "pytest>=7.4.0",
-    "black[jupyter]>=23.12.0",
-    "pylint[spelling]>=3.0.0",
-    "ruff>=0.1.13",
+    "pytest>=8.1.0",
+    "black[jupyter]>=24.4.0",
+    "pylint[spelling]>=3.1.0",
+    "ruff>=0.3.7",
     "sphinx>=7.2.6",
     "sphinx-book-theme>=1.1.0",
 ]
@@ -183,12 +183,13 @@ good-names-rgxs = [
 ]
 disable = [
     "R0801", # (duplicate-code)
+    "R0401", # (cyclic-import)
     "R0902", # (too-many-instance-attributes)
     "R0903", # (too-few-public-methods)
     "R0913", # (too-many-arguments)
     "R0914", # (too-many-locals)
-    "R0401", # (cyclic-import)
     "C0302", # (too-many-lines)
+    "C0413", # (wrong-import-position) - Let Ruff and isort handle imports.
 ]
 extension-pkg-allow-list = [
     "PySide6",

{lezargus-0.0.4.dev42 → lezargus-0.0.4.dev51}/src/lezargus/__version__.py

@@ -4,4 +4,4 @@ Please do not manually edit this value.
 """
 
 # DO NOT EDIT MANUALLY.
-__version__ = "0.0.4.dev42"
+__version__ = "0.0.4.dev51"

{lezargus-0.0.4.dev42 → lezargus-0.0.4.dev51}/src/lezargus/container/__init__.py

@@ -1,24 +1,31 @@
 """Containers for data.
 
-This module contains the containers for spectral data. We have 4 main classes,
-broken into different files for ease. There is a parent class which we use
-to define connivent arithmetic.
+This module contains the containers to hold different data. We have 4 major
+classes for <=3-dimensional data, broken into different files for ease.
+There is a parent class which we use to define connivent arithmetic.
+
+Aside from the 4 major classes, there are other minor containers with more
+specific purposes.
 """
 
-# The parent class used to properly handle the arithmetic of spectra
+# The parent class used to properly handle the arithmetic of spectrum
 # and data cubes.
 from lezargus.container.parent import LezargusContainerArithmetic
 
 # isort: split
 
-# And all of the following data structures for any given N-dimensional data.
+# The major classes for dimensional data.
 from lezargus.container.cube import LezargusCube
 from lezargus.container.image import LezargusImage
 from lezargus.container.mosaic import LezargusMosaic
-from lezargus.container.spectra import LezargusSpectra
+from lezargus.container.spectrum import LezargusSpectrum
 
 # isort: split
 
+# The minor classes for dimensional data, with a very specific implementation
+# details.
+
+
 # Other inner packages. Although easily accessible by the user, the depth of
 # these packages and functions, compared to the main containers, implies that
 # we should still abstract it away from the end-user.

lezargus-0.0.4.dev51/src/lezargus/container/atmosphere.py

@@ -0,0 +1,128 @@
+"""Container classes to hold both atmospheric transmission and radiance.
+
+We define small wrappers to hold atmospheric transmission and radiance data
+so that it can be used more easily. The data itself usually has been derived
+from PSG. These container classes are just intuitive wrappers around
+interpolation.
+"""
+
+import lezargus
+from lezargus.library import hint
+from lezargus.library import logging
+
+
+class AtmosphereSpectrumGenerator:
+    """Atmospheric spectrum generator/interpolator.
+
+    This class generates, via interpolation of a pre-computed grid,
+    atmospheric transmission and radiance spectrum.
+
+    Attributes
+    ----------
+    wavelength : ndarray
+        The wavelength axis of the grid data we are interpolating over.
+    zenith_angle : ndarray
+        The zenith angle axis of the grid data we are interpolating over.
+        The actual interpolation uses airmass instead of zenith angle.
+    airmass : ndarray
+        The calculated airmass axis of the grid data we are interpolating over.
+    pwv : ndarray
+        The precipitable water vapor axis of the grid data we are interpolating
+        over.
+    transmission : ndarray
+        The transmission data grid, axes defined by other attributes.
+    radiance : ndarray
+        The radiance data grid, axes defined by other attributes.
+    _transmission_interpolator : RegularNDInterpolator
+        The interpolator class for the transmission data which we use as the
+        backbone of this generator.
+    _radiance_interpolator : RegularNDInterpolator
+        The interpolator class for the transmission data which we use as the
+        backbone of this generator.
+
+    """
+
+    def __init__(
+        self: "AtmosphereSpectrumGenerator",
+        wavelength: hint.ndarray,
+        zenith_angle: hint.ndarray,
+        pwv: hint.ndarray,
+        transmission: hint.ndarray,
+        radiance: hint.ndarray,
+    ) -> None:
+        """Initialize the atmospheric transmission and radiance container.
+
+        Parameters
+        ----------
+        wavelength : ndarray
+            The wavelength axis of the grid data that defines the transmission
+            and radiance data.
+        zenith_angle : ndarray
+            The zenith angle axis of the grid data that defines the
+            transmission and radiance data.
+        pwv : ndarray
+            The precipitable water vapor axis of the grid data that defines
+            the transmission and radiance data.
+        transmission : ndarray
+            The transmission data grid, axes defined by other attributes.
+        radiance : ndarray
+            The radiance data grid, axes defined by other attributes.
+
+        """
+        # Interpolation using airmass over zenith angle makes more sense as
+        # airmass has a linear response.
+        airmass = lezargus.library.atmosphere.airmass(zenith_angle=zenith_angle)
+
+        # We check that the shape provided by the defining axes matches the
+        # data shape. The provided axis order is reversed of Numpy's
+        # conventions.
+        domain = (wavelength, airmass, pwv)
+        domain_shape = tuple(domaindex.size for domaindex in domain)
+        if (
+            reversed(domain_shape) != transmission.shape
+            or reversed(domain_shape) != radiance.shape
+        ):
+            logging.error(
+                error_type=logging.InputError,
+                message=(
+                    f"The shape of transmission {transmission.shape} or"
+                    f" radiance {radiance.shape} does not match the expected"
+                    f" shape of {domain_shape} from the input axes."
+                ),
+            )
+
+        # We can properly build our class.
+        self.wavelength = wavelength
+        self.zenith_angle = zenith_angle
+        self.airmass = airmass
+        self.pwv = pwv
+        self.transmission = transmission
+        self.radiance = radiance
+
+        # Building the interpolators.
+        self._transmission_interpolator = (
+            lezargus.library.interpolate.RegularNDInterpolate(
+                domain=domain,
+                v=self.transmission,
+            )
+        )
+        self._radiance_interpolator = (
+            lezargus.library.interpolate.RegularNDInterpolate(
+                domain=domain,
+                v=self.radiance,
+            )
+        )
+
+    def generate_transmission_spectra(
+        self: hint.Self,
+        zenith_angle: float,
+        pwv: float,
+    ) -> hint.LezargusSpectrum:
+        """TODO."""
+
+    def generate_radiance_spectra(
+        self: hint.Self,
+        zenith_angle: float,
+        pwv: float,
+    ) -> hint.LezargusSpectrum:
+        """TODO."""

{lezargus-0.0.4.dev42 → lezargus-0.0.4.dev51}/src/lezargus/container/broadcast.py

@@ -7,64 +7,70 @@ the internal conversions (such as the flags, mask, wavelength, etc) as well
 based on the input template structure broadcasting to.
 """
 
-# This is a last resort solution to fixing the recursive import of the
-# type hints here.
+# isort: split
+# Import required to remove circular dependencies from type checking.
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lezargus.library import hint
+# isort: split
+
+
 import numpy as np
 
 import lezargus
-from lezargus.library import hint
 from lezargus.library import logging
 
 
-def broadcast_spectra_to_cube_uniform(
-    input_spectra: hint.LezargusSpectra,
+def broadcast_spectrum_to_cube_uniform(
+    input_spectrum: hint.LezargusSpectrum,
     template_cube: hint.LezargusCube,
     wavelength_mode: str = "error",
 ) -> hint.LezargusCube:
-    """Make a LezargusCube from a LezargusSpectra via uniform broadcasting.
+    """Make a LezargusCube from a LezargusSpectrum via uniform broadcasting.
 
     We make a LezargusCube, from a provided template, using uniform
     broadcasting. Uniform broadcasting is where all spectral slices, within
     the cube, are all the same for a uniform spatial distribution of the
-    spectra, which is in this case the provided input spectra.
+    spectrum, which is in this case the provided input spectrum.
 
-    In the case of both the input spectra and provided template cube having
+    In the case of both the input spectrum and provided template cube having
     different wavelength arrays, we follow the provided mode to handle the
     different cases. The input template cube only provides the array shapes and
     the wavelength axis (dependant on the mode); the rest comes from the
-    input spectra.
+    input spectrum.
 
     Parameters
     ----------
-    input_spectra : LezargusSpectra
-        The input spectra which will be broadcasted to fit the input template
+    input_spectrum : LezargusSpectrum
+        The input spectrum which will be broadcasted to fit the input template
         cube.
     template_cube : LezargusCube
         The template cube which will serve as a template to determine the
         dimensional properties of the resulting broadcasting cube.
     wavelength_mode : str, default = "error"
         The mode to handle possible wavelength array conflicts between the
-        spectra and the cube. The available options are:
+        spectrum and the cube. The available options are:
 
-            - "spectra" : Prefer the spectra's wavelength array; the cube's
+            - "spectrum" : Prefer the spectrum's wavelength array; the cube's
               wavelength is ignored.
-            - "cube" : Prefer the cube's wavelength array; the spectra is
+            - "cube" : Prefer the cube's wavelength array; the spectrum is
               interpolated to align to the new wavelength.
             - "error" : We log an error. We still attempt to figure it out,
-              defaulting to the spectra's wavelength array.
+              defaulting to the spectrum's wavelength array.
 
     Returns
     -------
     broadcast_cube : LezargusCube
-        The LezargusCube after the spectra was uniformly broadcast spatially.
-        Any header information came from first the spectra then the cube.
+        The LezargusCube after the spectrum was uniformly broadcast spatially.
+        Any header information came from first the spectrum then the cube.
 
     """
     # First thing is first, type check the input.
     if not (
-        isinstance(input_spectra, lezargus.container.LezargusSpectra)
+        isinstance(input_spectrum, lezargus.container.LezargusSpectrum)
         and isinstance(template_cube, lezargus.container.LezargusCube)
     ):
         # The objects are not the proper type so broadcasting them might go
@@ -72,9 +78,9 @@ def broadcast_spectra_to_cube_uniform(
         logging.error(
             error_type=logging.InputError,
             message=(
-                f"The input spectra type {type(input_spectra)} and template"
+                f"The input spectrum type {type(input_spectrum)} and template"
                 f" cube type {type(template_cube)} are not instances of the"
-                " expected LezargusSpectra and LezargusCube types"
+                " expected LezargusSpectrum and LezargusCube types"
                 " respectively. Broadcasting may fail."
             ),
         )
@@ -82,22 +88,23 @@ def broadcast_spectra_to_cube_uniform(
     # Now, we need to determine the definitive wavelength array based on the
     # provided wavelength mode. However, the two wavelength units might be
     # different, this is problem that we ought to warn.
-    if input_spectra.wavelength_unit != template_cube.wavelength_unit:
+    if input_spectrum.wavelength_unit != template_cube.wavelength_unit:
         logging.warning(
             warning_type=logging.AccuracyWarning,
             message=(
-                "The input spectra wavelength unit is"
-                f" {input_spectra.wavelength_unit}, different from the template"
-                f" cube wavelength unit {template_cube.wavelength_unit}"
+                "The input spectrum wavelength unit is"
+                f" {input_spectrum.wavelength_unit}, different from the "
+                " template cube wavelength unit "
+                f" {template_cube.wavelength_unit}"
             ),
         )
     # Regardless of the unit situation, we try our best to determine the
     # the preferred wavelength.
     wavelength_mode = wavelength_mode.casefold()
-    if wavelength_mode == "spectra":
-        # We rely on the spectra's wavelength.
-        broadcast_wavelength = input_spectra.wavelength
-        broadcast_wavelength_unit = input_spectra.wavelength_unit
+    if wavelength_mode == "spectrum":
+        # We rely on the spectrum's wavelength.
+        broadcast_wavelength = input_spectrum.wavelength
+        broadcast_wavelength_unit = input_spectrum.wavelength_unit
     elif wavelength_mode == "cube":
         # We rely on the cube's wavelength.
         broadcast_wavelength = template_cube.wavelength
@@ -105,19 +112,19 @@ def broadcast_spectra_to_cube_uniform(
     elif wavelength_mode == "error":
         # If the wavelengths differ, we raise an error on their mismatch.
         if not np.all(
-            np.isclose(input_spectra.wavelength, template_cube.wavelength),
+            np.isclose(input_spectrum.wavelength, template_cube.wavelength),
         ):
             logging.error(
                 error_type=logging.InputError,
                 message=(
-                    "Input spectra and template cube wavelength arrays do not"
+                    "Input spectrum and template cube wavelength arrays do not"
                     " match; wavelength mode is `error`; returning None."
                 ),
             )
-        # Regardless if the error was logged or not, we use the input spectra
+        # Regardless if the error was logged or not, we use the input spectrum
         # as the broadcast.
-        broadcast_wavelength = input_spectra.wavelength
-        broadcast_wavelength_unit = input_spectra.wavelength_unit
+        broadcast_wavelength = input_spectrum.wavelength
+        broadcast_wavelength_unit = input_spectrum.wavelength_unit
     else:
         # The input parameter is not a given parameter.
         logging.critical(
@@ -128,23 +135,23 @@ def broadcast_spectra_to_cube_uniform(
             ),
         )
 
-    # Finally, we determine the appropriate data based on the spectra and
+    # Finally, we determine the appropriate data based on the spectrum and
     # the preferred wavelength array.
     (
         interpolated_data,
         interpolated_uncertainty,
         interpolated_mask,
         interpolated_flags,
-    ) = input_spectra.interpolate(
+    ) = input_spectrum.interpolate(
         wavelength=broadcast_wavelength,
         skip_mask=False,
         skip_flags=False,
     )
     # The data unit for the data and the like.
-    broadcast_data_unit = input_spectra.data_unit
+    broadcast_data_unit = input_spectrum.data_unit
 
     # Now, we assemble the cube. We only need the spatial coverage of the cube
-    # and broadcast our 1D spectra to the spatial dimensions. We do not
+    # and broadcast our 1D spectrum to the spatial dimensions. We do not
     # really care for the wavelength shape of the cube.
     x_dim, y_dim, __ = template_cube.data.shape
     wave_dim = broadcast_wavelength.shape[0]
@@ -173,9 +180,9 @@ def broadcast_spectra_to_cube_uniform(
 
     # Finally, we reconstruct the cube. We work on copies of the headers
     # just in case.
-    spectra_header = input_spectra.header.copy()
+    spectrum_header = input_spectrum.header.copy()
     cube_header = template_cube.header.copy()
-    broadcast_header = cube_header.update(spectra_header)
+    broadcast_header = cube_header.update(spectrum_header)
 
     # Building the new broadcasted cube. We use the template's cube's class
     # just in case it has been subclassed or something.
@@ -196,13 +203,13 @@ def broadcast_spectra_to_cube_uniform(
     return broadcast_cube
 
 
-def broadcast_spectra_to_cube_center(
-    input_spectra: hint.LezargusSpectra,
+def broadcast_spectrum_to_cube_center(
+    input_spectrum: hint.LezargusSpectrum,
     template_cube: hint.LezargusCube,
     wavelength_mode: str = "error",
     allow_even_center: bool = True,
 ) -> hint.LezargusCube:
-    """Make a LezargusCube from a LezargusSpectra via center broadcasting.
+    """Make a LezargusCube from a LezargusSpectrum via center broadcasting.
 
     We make a LezargusCube, from a provided template, using center
     broadcasting. Center broadcasting is the provided spectral slice is
@@ -211,45 +218,45 @@ def broadcast_spectra_to_cube_center(
     is even, we can still try to place the image in the center, biasing it
     towards the lower value corner.
 
-    In the case of both the input spectra and provided template cube having
+    In the case of both the input spectrum and provided template cube having
     different wavelength arrays, we follow the provided mode to handle the
     different cases. The input template cube only provides the array shapes and
     the wavelength axis (dependant on the mode); the rest comes from the
-    input spectra.
+    input spectrum.
 
     Parameters
     ----------
-    input_spectra : LezargusSpectra
-        The input spectra which will be broadcasted to fit the input template
+    input_spectrum : LezargusSpectrum
+        The input spectrum which will be broadcasted to fit the input template
         cube.
     template_cube : LezargusCube
         The template cube which will serve as a template to determine the
         dimensional properties of the resulting broadcasting cube.
     wavelength_mode : str, default = "error"
         The mode to handle possible wavelength array conflicts between the
-        spectra and the cube. The available options are:
+        spectrum and the cube. The available options are:
 
-            - "spectra" : Prefer the spectra's wavelength array; the cube's
+            - "spectrum" : Prefer the spectrum's wavelength array; the cube's
               wavelength is ignored.
-            - "cube" : Prefer the cube's wavelength array; the spectra is
+            - "cube" : Prefer the cube's wavelength array; the spectrum is
               interpolated to align to the new wavelength.
             - "error" : We log an error and return None.
 
     allow_even_center : bool, default = True
         If True, and if any axis of an image slice is even, a warning is
-        logged and the spectra is put it as close to the center as possible.
+        logged and the spectrum is put it as close to the center as possible.
         If False, instead, an exception is raised.
 
     Returns
     -------
     broadcast_cube : LezargusCube
-        The LezargusCube after the spectra was center broadcast spatially.
-        Any header information came from first the spectra then the cube.
+        The LezargusCube after the spectrum was center broadcast spatially.
+        Any header information came from first the spectrum then the cube.
 
     """
     # First thing is first, type check the input.
     if not (
-        isinstance(input_spectra, lezargus.container.LezargusSpectra)
+        isinstance(input_spectrum, lezargus.container.LezargusSpectrum)
         and isinstance(template_cube, lezargus.container.LezargusCube)
     ):
         # The objects are not the proper type so broadcasting them might go
@@ -257,9 +264,9 @@ def broadcast_spectra_to_cube_center(
         logging.error(
             error_type=logging.InputError,
             message=(
-                f"The input spectra type {type(input_spectra)} and template"
+                f"The input spectrum type {type(input_spectrum)} and template"
                 f" cube type {type(template_cube)} are not instances of the"
-                " expected LezargusSpectra and LezargusCube types"
+                " expected LezargusSpectrum and LezargusCube types"
                 " respectively. Broadcasting may fail."
             ),
         )
@@ -267,22 +274,23 @@ def broadcast_spectra_to_cube_center(
     # Now, we need to determine the definitive wavelength array based on the
     # provided wavelength mode. However, the two wavelength units might be
     # different, this is problem that we ought to warn.
-    if input_spectra.wavelength_unit != template_cube.wavelength_unit:
+    if input_spectrum.wavelength_unit != template_cube.wavelength_unit:
         logging.warning(
             warning_type=logging.AccuracyWarning,
             message=(
-                "The input spectra wavelength unit is"
-                f" {input_spectra.wavelength_unit}, different from the template"
-                f" cube wavelength unit {template_cube.wavelength_unit}"
+                "The input spectrum wavelength unit is"
+                f" {input_spectrum.wavelength_unit}, different from the "
+                " template cube wavelength unit "
+                f" {template_cube.wavelength_unit}"
             ),
         )
     # Regardless of the unit situation, we try our best to determine the
     # the preferred wavelength.
     wavelength_mode = wavelength_mode.casefold()
-    if wavelength_mode == "spectra":
-        # We rely on the spectra's wavelength.
-        broadcast_wavelength = input_spectra.wavelength
-        broadcast_wavelength_unit = input_spectra.wavelength_unit
+    if wavelength_mode == "spectrum":
+        # We rely on the spectrum's wavelength.
+        broadcast_wavelength = input_spectrum.wavelength
+        broadcast_wavelength_unit = input_spectrum.wavelength_unit
     elif wavelength_mode == "cube":
         # We rely on the cube's wavelength.
         broadcast_wavelength = template_cube.wavelength
@@ -290,12 +298,12 @@ def broadcast_spectra_to_cube_center(
     elif wavelength_mode == "error":
         # If the wavelengths differ, we raise an error on their mismatch.
         if not np.all(
-            np.isclose(input_spectra.wavelength, template_cube.wavelength),
+            np.isclose(input_spectrum.wavelength, template_cube.wavelength),
         ):
             logging.error(
                 error_type=logging.InputError,
                 message=(
-                    "Input spectra and template cube wavelength arrays do not"
+                    "Input spectrum and template cube wavelength arrays do not"
                     " match; wavelength mode is `error`; returning None."
                 ),
             )
@@ -303,8 +311,8 @@ def broadcast_spectra_to_cube_center(
             broadcast_wavelength_unit = None
             return None
         # Otherwise, if they do match, we can continue with the broadcasting.
-        broadcast_wavelength = input_spectra.wavelength
-        broadcast_wavelength_unit = input_spectra.wavelength_unit
+        broadcast_wavelength = input_spectrum.wavelength
+        broadcast_wavelength_unit = input_spectrum.wavelength_unit
     else:
         # The input parameter is not a given parameter.
         logging.critical(
@@ -315,23 +323,23 @@ def broadcast_spectra_to_cube_center(
             ),
         )
 
-    # Finally, we determine the appropriate data based on the spectra and
+    # Finally, we determine the appropriate data based on the spectrum and
     # the preferred wavelength array.
     (
         interpolated_data,
         interpolated_uncertainty,
         interpolated_mask,
         interpolated_flags,
-    ) = input_spectra.interpolate(
+    ) = input_spectrum.interpolate(
         wavelength=broadcast_wavelength,
         skip_mask=False,
         skip_flags=False,
     )
     # The data unit for the data and the like.
-    broadcast_data_unit = input_spectra.data_unit
+    broadcast_data_unit = input_spectrum.data_unit
 
     # Now, we assemble the cube. We only need the spatial coverage of the cube
-    # and broadcast our 1D spectra to the spatial dimensions. We do not
+    # and broadcast our 1D spectrum to the spatial dimensions. We do not
     # really care for the wavelength shape of the cube.
     x_dim, y_dim, __ = template_cube.data.shape
     wave_dim = broadcast_wavelength.shape[0]
@@ -347,7 +355,7 @@ def broadcast_spectra_to_cube_center(
                 warning_type=logging.AccuracyWarning,
                 message=(
                     f"The image slice of the template cube is even: ({x_dim},"
-                    f" {y_dim}). A best attempt at putting the spectra in the"
+                    f" {y_dim}). A best attempt at putting the spectrum in the"
                     " center is attempted."
                 ),
             )
@@ -388,9 +396,9 @@ def broadcast_spectra_to_cube_center(
 
     # Finally, we reconstruct the cube. We work on copies of the headers
     # just in case.
-    spectra_header = input_spectra.header.copy()
+    spectrum_header = input_spectrum.header.copy()
     cube_header = template_cube.header.copy()
-    cube_header.update(spectra_header)
+    cube_header.update(spectrum_header)
     broadcast_header = cube_header
 
     # Building the new broadcasted cube. We use the template's cube's class

{lezargus-0.0.4.dev42 → lezargus-0.0.4.dev51}/src/lezargus/container/parent.py

@@ -19,12 +19,10 @@ from lezargus.library import logging
 
 
 class LezargusContainerArithmetic:
-    """Lezargus wavelength-aware arithmetic.
+    """Lezargus wavelength-aware arithmetic for the major containers.
 
     This is the class which allows for the arithmetic behind the scenes to
-    work with wavelength knowledge. All we do is overwrite the NDDataArray
-    arithmetic functions to perform wavelength checks and pass it through
-    without wavelength issues.
+    work with wavelength knowledge.
 
     Attributes
     ----------