PyFiberModes 0.13.2__tar.gz → 0.14.1__tar.gz

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/.github/workflows/quality.yml

@@ -19,4 +19,5 @@ jobs:
           python-version: "3.11"
       - run: python -m pip install --upgrade pip && python -m pip install -e ".[dev]"
       - run: python -m ruff check PyFiberModes tests tools
+      - run: python -m mypy
       - run: python tools/check_release.py

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/.zenodo.json

@@ -9,7 +9,7 @@
   "license": "MIT",
   "upload_type": "software",
   "access_right": "open",
-  "version": "0.13.2",
+  "version": "0.14.1",
   "publication_date": "2026-09-23",
   "keywords": [
     "optical fibers",

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/CHANGELOG.md

@@ -6,6 +6,23 @@ use [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.14.1] - 2026-09-23
+
+## [0.14.0] - 2026-09-23
+
+### Added
+
+- Expanded the specialty-fiber, field, analysis, validation, and performance
+  galleries so every documentation series contains multiple examples.
+- Defined a stable root-level public API, compatibility and deprecation policy,
+  API snapshot regression test, and migration guide.
+
+### Changed
+
+- Replaced the opaque `ssif`, `tlsif`, `mlsif`, and `NeffSolver` names with
+  descriptive two-layer, three-layer, multilayer, and effective-index solver
+  namespaces and class names.
+
 ## [0.13.2] - 2026-09-23
 
 ### Changed
@@ -86,7 +103,9 @@ use [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 - Established the current tagged baseline for subsequent documented releases.
 
-[Unreleased]: https://github.com/MartinPdeS/PyFiberModes/compare/v0.13.2...HEAD
+[Unreleased]: https://github.com/MartinPdeS/PyFiberModes/compare/v0.14.1...HEAD
+[0.14.1]: https://github.com/MartinPdeS/PyFiberModes/releases/tag/v0.14.1
+[0.14.0]: https://github.com/MartinPdeS/PyFiberModes/releases/tag/v0.14.0
 [0.13.2]: https://github.com/MartinPdeS/PyFiberModes/releases/tag/v0.13.2
 [0.13.1]: https://github.com/MartinPdeS/PyFiberModes/releases/tag/v0.13.1
 [0.13.0]: https://github.com/MartinPdeS/PyFiberModes/releases/tag/v0.13.0

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/Makefile

@@ -31,6 +31,7 @@ test:
 
 quality:
 	$(PYTHON) -m ruff check PyFiberModes tests tools
+	$(PYTHON) -m mypy
 
 release-check:
 	$(PYTHON) tools/check_release.py $(if $(VERSION),--version $(VERSION),)

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFiberModes
-Version: 0.13.2
+Version: 0.14.1
 Summary: Guided-mode analysis and design for circular optical fibers.
 Author-email: Martin Poinsinet de Sivry-Houle <martin.poinsinet.de.sivry@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -697,7 +697,6 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: PyOptik<3,>=2
 Requires-Dist: PyFinitDiff
 Requires-Dist: pyyaml
 Requires-Dist: numpy
@@ -709,6 +708,7 @@ Requires-Dist: pytest-json-report~=1.5; extra == "testing"
 Requires-Dist: coverage~=7.6; extra == "testing"
 Requires-Dist: ruff<1,>=0.8; extra == "testing"
 Requires-Dist: matplotlib>=3.8; extra == "testing"
+Requires-Dist: mypy<2,>=1.15; extra == "testing"
 Provides-Extra: plotting
 Requires-Dist: matplotlib>=3.8; extra == "plotting"
 Provides-Extra: benchmarking
@@ -723,6 +723,7 @@ Requires-Dist: sphinx-rtd-theme==3.1.0; extra == "documentation"
 Requires-Dist: pydata-sphinx-theme==0.17.1; extra == "documentation"
 Provides-Extra: dev
 Requires-Dist: ruff<1,>=0.8; extra == "dev"
+Requires-Dist: mypy<2,>=1.15; extra == "dev"
 Dynamic: license-file
 
 .. image:: https://raw.githubusercontent.com/MartinPdeS/PyFiberModes/master/docs/source/_static/logo.png
@@ -813,9 +814,9 @@ simulations:
 
    python -c "import PyFiberModes; print(PyFiberModes.__version__)"
 
-PyFiberModes currently uses the ``MaterialBank`` interface provided by
-PyOptik 2.x. Released dependency metadata selects the compatible
-``PyOptik>=2,<3`` range automatically.
+Fiber material names are resolved through a lightweight, pluggable registry.
+PyOptik is not required; applications can register their own dispersive model
+objects or simple wavelength-to-index callables.
 
 First mode calculation
 ----------------------
@@ -1012,6 +1013,17 @@ contains the API reference and executable example gallery, including:
 * double-clad fiber field analysis; and
 * comparisons between supported analytical solvers.
 
+API stability
+-------------
+
+Supported imports come from the package root, for example
+``from PyFiberModes import Fiber, LP01``. The
+`public API policy <https://martinpdes.github.io/PyFiberModes/latest/api_policy.html>`_
+defines compatibility guarantees and the deprecation period. Review the
+`migration guide <https://martinpdes.github.io/PyFiberModes/latest/migration_guide.html>`_
+when upgrading across minor or major versions. Internal solver modules are not
+covered by the compatibility guarantee.
+
 Development and testing
 -----------------------
 

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/PyFiberModes/__init__.py

@@ -1,7 +1,27 @@
 """Public API for circular optical-fiber mode analysis."""
 
-from PyFiberModes.mode import Mode, Family  # noqa: F401
-from PyFiberModes.mode_instances import *  # noqa: F403
+from PyFiberModes.mode import Family, Mode
+from PyFiberModes.mode_instances import (
+    EH11,
+    HE11,
+    HE12,
+    HE21,
+    HE22,
+    HE31,
+    HE32,
+    LP01,
+    LP02,
+    LP03,
+    LP11,
+    LP12,
+    LP21,
+    LP22,
+    LP31,
+    LP32,
+    LP41,
+    TE01,
+    TM01,
+)
 from PyFiberModes.factory import FiberFactory
 from PyFiberModes.fiber import Fiber, load_fiber
 from PyFiberModes.field import Field
@@ -12,6 +32,13 @@ from PyFiberModes.solver.results import SolverResult
 from PyFiberModes.analysis import ModeSweepResult, find_modes, sweep_modes
 from PyFiberModes.optimization import DesignParameter, DesignResult, optimize_fiber
 from PyFiberModes.propagation import CoupledModeSystem, PropagationResult, coupling_matrix, overlap
+from PyFiberModes.materials import (
+    CallableIndex,
+    ConstantIndex,
+    FusedSilica,
+    MaterialRegistry,
+    RefractiveIndexModel,
+)
 
 
 try:
@@ -21,7 +48,7 @@ except ImportError:
     __version__ = "0.0.0"
 
 
-__all__ = [  # noqa: F405
+__all__ = [
     'Mode',
     'Family',
     'Fiber',
@@ -34,10 +61,17 @@ __all__ = [  # noqa: F405
     'ModeSweepResult', 'find_modes', 'sweep_modes',
     'DesignParameter', 'DesignResult', 'optimize_fiber',
     'CoupledModeSystem', 'PropagationResult', 'coupling_matrix', 'overlap',
+    'RefractiveIndexModel', 'ConstantIndex', 'CallableIndex', 'FusedSilica',
+    'MaterialRegistry',
     'HE11',
     'HE12',
+    'HE21',
     'HE22',
     'HE31',
+    'HE32',
+    'EH11',
+    'TE01',
+    'TM01',
     'LP01',
     'LP11',
     'LP21',
@@ -47,4 +81,5 @@ __all__ = [  # noqa: F405
     'LP22',
     'LP03',
     'LP32',
+    'LP41',
 ]

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/PyFiberModes/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.13.2'
-__version_tuple__ = version_tuple = (0, 13, 2)
+__version__ = version = '0.14.1'
+__version_tuple__ = version_tuple = (0, 14, 1)
 
 __commit_id__ = commit_id = None

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/PyFiberModes/analysis.py

@@ -64,7 +64,7 @@ class ModeSweepResult:
         index = self.modes.index(mode)
         return {name: value[:, index] for name, value in self.values.items()}
 
-    def as_records(self) -> list[dict]:
+    def as_records(self) -> list[dict[str, float | Mode]]:
         """Convert the dense result into row-oriented records.
 
         Returns
@@ -133,9 +133,13 @@ def find_modes(fiber, families=("LP",), max_nu=6, max_m=6) -> tuple[Mode, ...]:
     found = []
     for mode in candidate_modes(families, max_nu, max_m):
         try:
-            neff = fiber.get_effective_index(mode)
-            guided = fiber.last_layer.refractive_index < neff <= fiber.maximum_index
-            if np.isfinite(neff) and guided:
+            effective_index = fiber.get_effective_index(mode)
+            guided = (
+                fiber.last_layer.refractive_index
+                < effective_index
+                <= fiber.maximum_index
+            )
+            if np.isfinite(effective_index) and guided:
                 found.append(mode)
         except (ArithmeticError, AssertionError, RuntimeError, ValueError):
             continue
@@ -191,7 +195,6 @@ def sweep_modes(
     parameters = np.asarray(tuple(parameters), dtype=float)
     if parameters.ndim != 1 or not len(parameters):
         raise ValueError("parameters must be a non-empty one-dimensional sequence")
-    working_fiber = deepcopy(fiber)
     if setter is None:
         if parameter_name != "wavelength":
             raise ValueError("a setter is required for non-wavelength sweeps")
@@ -202,19 +205,26 @@ def sweep_modes(
     if modes is None:
         discovered = []
         for parameter in parameters:
-            setter(working_fiber, float(parameter))
-            for mode in find_modes(working_fiber, families, max_nu, max_m):
+            parameter_fiber = deepcopy(fiber)
+            setter(parameter_fiber, float(parameter))
+            for mode in find_modes(parameter_fiber, families, max_nu, max_m):
                 if mode not in discovered:
                     discovered.append(mode)
         modes = discovered
     modes = tuple(modes)
     values = {metric: np.full((len(parameters), len(modes)), np.nan) for metric in metrics}
-    for i, parameter in enumerate(parameters):
-        setter(working_fiber, float(parameter))
-        for j, mode in enumerate(modes):
-            for metric in metrics:
+    parameter_fibers = tuple(deepcopy(fiber) for _ in parameters)
+    for parameter_fiber, parameter in zip(parameter_fibers, parameters, strict=True):
+        setter(parameter_fiber, float(parameter))
+
+    for i, parameter_fiber in enumerate(parameter_fibers):
+        metric_functions = {
+            metric: getattr(parameter_fiber, f"get_{metric}") for metric in metrics
+        }
+        for metric, metric_function in metric_functions.items():
+            for j, mode in enumerate(modes):
                 try:
-                    value = getattr(working_fiber, f"get_{metric}")(mode)
+                    value = metric_function(mode)
                     values[metric][i, j] = value if np.isfinite(value) else np.nan
                 except (ArithmeticError, AssertionError, RuntimeError, ValueError):
                     pass

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/PyFiberModes/factory.py

@@ -55,10 +55,6 @@ class FiberFactory:
     ----------
     layers_list : list[ProxyLayer]
         List of ProxyLayer objects representing the layers of the fiber.
-    neff_solver : None
-        Placeholder for a solver object (if required).
-    cutoff_solver : None
-        Placeholder for a cutoff solver object (if required).
     wavelength : float
         Wavelength used in simulations.
     """
@@ -72,8 +68,6 @@ class FiberFactory:
             Vacuum wavelength in meters for generated fibers.
         """
         self.layers_list = []
-        self.neff_solver = None
-        self.cutoff_solver = None
         self.wavelength = wavelength
 
     def add_layer(self, index: float, name: str = "", radius: float = 0.0):

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/PyFiberModes/fiber.py

@@ -22,6 +22,7 @@ from PyFiberModes.fundamentals import (
 from PyFiberModes import loader
 from PyFiberModes.coordinates import CylindricalCoordinates
 from PyFiberModes.exceptions import ValidationError
+from PyFiberModes.materials import DEFAULT_MATERIALS, MaterialRegistry
 from PyFiberModes.services import FieldAnalysis, ModalAnalysis
 
 
@@ -1004,7 +1005,12 @@ def get_fiber_from_delta_and_V0(delta: float, V0: float, wavelength: float) -> F
     return fiber
 
 
-def load_fiber(fiber_name: str, wavelength: float = None, add_air_layer: bool = False) -> Fiber:
+def load_fiber(
+    fiber_name: str,
+    wavelength: float | None = None,
+    add_air_layer: bool = False,
+    materials: MaterialRegistry = DEFAULT_MATERIALS,
+) -> Fiber:
     """Load a named YAML fiber definition.
 
     Parameters
@@ -1015,6 +1021,8 @@ def load_fiber(fiber_name: str, wavelength: float = None, add_air_layer: bool =
         Vacuum wavelength in meters used to evaluate material indices.
     add_air_layer : bool, optional
         Add an outer air layer when true.
+    materials : MaterialRegistry, optional
+        Registry used to resolve material names in the YAML definition.
 
     Returns
     -------
@@ -1024,7 +1032,8 @@ def load_fiber(fiber_name: str, wavelength: float = None, add_air_layer: bool =
     fiber_dict = loader.load_fiber_as_dict(
         fiber_name=fiber_name,
         wavelength=wavelength,
-        order='out-to-in'
+        order='out-to-in',
+        materials=materials,
     )
 
     fiber = Fiber(wavelength=wavelength)

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/PyFiberModes/fundamentals.py

@@ -1,13 +1,19 @@
 """Fundamental normalized-frequency and propagation relations."""
 
+from __future__ import annotations
+
 import numpy
 import numpy as np
+from typing import TYPE_CHECKING
 from PyFiberModes.mode import Mode
 from PyFiberModes.mode_instances import HE11, LP01
 from scipy.constants import c
 
 from PyFiberModes.coordinates import CylindricalCoordinates
 
+if TYPE_CHECKING:
+    from PyFiberModes.solver.results import SolverResult
+
 
 def get_delta_from_fiber(fiber) -> float:
     r"""
@@ -31,7 +37,7 @@ def get_delta_from_fiber(fiber) -> float:
     return 0.5 * (1 - n_ratio)
 
 
-def get_wavelength_from_V0(fiber: object, V0: float) -> float:
+def get_wavelength_from_V0(fiber: object, normalized_frequency: float) -> float:
     r"""
     Compute the wavelength corresponding to a given V-number, \(V_0\).
 
@@ -46,7 +52,7 @@ def get_wavelength_from_V0(fiber: object, V0: float) -> float:
     ----------
     fiber : Fiber
         The fiber object.
-    V0 : float
+    normalized_frequency : float
         The V-number.
 
     Returns
@@ -56,7 +62,7 @@ def get_wavelength_from_V0(fiber: object, V0: float) -> float:
     """
     NA = fiber.get_NA()
     last_layer = fiber.last_layer
-    wavelength = 2 * np.pi / V0 * last_layer.radius_in * NA
+    wavelength = 2 * np.pi / normalized_frequency * last_layer.radius_in * NA
     return wavelength
 
 
@@ -95,11 +101,14 @@ def get_propagation_constant_from_omega(
 
     from PyFiberModes import solver
 
-    neff_solver = solver.ssif.NeffSolver(fiber=fiber, wavelength=wavelength) if fiber.n_layer == 2 \
-        else solver.mlsif.NeffSolver(fiber=fiber, wavelength=wavelength)
+    effective_index_solver = (
+        solver.two_layer.EffectiveIndexSolver(fiber=fiber, wavelength=wavelength)
+        if fiber.n_layer == 2
+        else solver.multilayer.EffectiveIndexSolver(fiber=fiber, wavelength=wavelength)
+    )
 
-    neff = neff_solver.solve(mode=mode, delta_neff=delta_neff)
-    return neff * (2 * numpy.pi / wavelength)
+    effective_index = effective_index_solver.solve(mode=mode, delta_neff=delta_neff)
+    return effective_index * (2 * numpy.pi / wavelength)
 
 
 def get_U_parameter(
@@ -132,9 +141,11 @@ def get_U_parameter(
     from PyFiberModes import solver
     assert fiber.n_layer == 2, "U-parameter can only be calculated for two-layer fibers."
 
-    neff_solver = solver.ssif.NeffSolver(fiber=fiber, wavelength=wavelength)
-    neff = neff_solver.solve(mode=mode, delta_neff=delta_neff)
-    U, _, _ = neff_solver.get_U_W_V_parameter(neff=neff)
+    effective_index_solver = solver.two_layer.EffectiveIndexSolver(
+        fiber=fiber, wavelength=wavelength
+    )
+    effective_index = effective_index_solver.solve(mode=mode, delta_neff=delta_neff)
+    U, _, _ = effective_index_solver.get_U_W_V_parameter(neff=effective_index)
     return U
 
 
@@ -165,11 +176,49 @@ def get_effective_index(
     from PyFiberModes import solver
 
     if fiber.n_layer == 2:
-        neff_solver = solver.ssif.NeffSolver(fiber=fiber, wavelength=wavelength)
+        effective_index_solver = solver.two_layer.EffectiveIndexSolver(
+            fiber=fiber, wavelength=wavelength
+        )
     else:
-        neff_solver = solver.mlsif.NeffSolver(fiber=fiber, wavelength=wavelength)
+        effective_index_solver = solver.multilayer.EffectiveIndexSolver(
+            fiber=fiber, wavelength=wavelength
+        )
 
-    return neff_solver.solve(mode=mode, delta_neff=delta_neff)
+    return effective_index_solver.solve(mode=mode, delta_neff=delta_neff)
+
+
+def get_effective_index_result(
+        fiber,
+        wavelength: float,
+        mode: Mode,
+        delta_neff: float = 1e-6) -> "SolverResult[float]":
+    """Compute an effective index with structured convergence diagnostics.
+
+    Parameters
+    ----------
+    fiber : Fiber
+        Fiber to solve.
+    wavelength : float
+        Vacuum wavelength in meters.
+    mode : Mode
+        Mode to solve.
+    delta_neff : float, optional
+        Maximum effective-index search step.
+
+    Returns
+    -------
+    SolverResult[float]
+        Effective index, residual, bracket, iteration count, and explanation.
+    """
+    from PyFiberModes import solver
+
+    solver_class = (
+        solver.two_layer.EffectiveIndexSolver
+        if fiber.n_layer == 2
+        else solver.multilayer.EffectiveIndexSolver
+    )
+    effective_index_solver = solver_class(fiber=fiber, wavelength=wavelength)
+    return effective_index_solver.solve_result(mode=mode, delta_neff=delta_neff)
 
 
 def get_mode_cutoff_v0(
@@ -199,12 +248,14 @@ def get_mode_cutoff_v0(
         return 0
 
     match fiber.n_layer:
-        case 2:  # Standard Step-Index Fiber [SSIF|
-            cutoff_solver = solver.ssif.CutoffSolver(fiber=fiber, wavelength=wavelength)
-        case 3:  # Three-Layer Step-Index Fiber [TLSIF]
-            cutoff_solver = solver.tlsif.CutoffSolver(fiber=fiber, wavelength=wavelength)
-        case _:  # Multi-Layer Step-Index Fiber [MLSIF]
-            cutoff_solver = solver.solver.FiberSolver(fiber=fiber, wavelength=wavelength)
+        case 2:
+            cutoff_solver = solver.two_layer.CutoffSolver(fiber=fiber, wavelength=wavelength)
+        case 3:
+            cutoff_solver = solver.three_layer.CutoffSolver(fiber=fiber, wavelength=wavelength)
+        case _:
+            raise NotImplementedError(
+                "Cutoff calculations are currently available for two- and three-layer fibers"
+            )
 
     cutoff = cutoff_solver.solve(mode=mode)
 
@@ -241,10 +292,14 @@ def get_radial_field(
     """
     from PyFiberModes import solver
 
-    if fiber.n_layer == 2:  # Standard Step-Index Fiber [SSIF]
-        neff_solver = solver.ssif.NeffSolver(fiber=fiber, wavelength=wavelength)
-    else:  # Multi-Layer Step-Index Fiber [MLSIF]
-        neff_solver = solver.mlsif.NeffSolver(fiber=fiber, wavelength=wavelength)
+    if fiber.n_layer == 2:
+        effective_index_solver = solver.two_layer.EffectiveIndexSolver(
+            fiber=fiber, wavelength=wavelength
+        )
+    else:
+        effective_index_solver = solver.multilayer.EffectiveIndexSolver(
+            fiber=fiber, wavelength=wavelength
+        )
 
     neff = get_effective_index(
         fiber=fiber,
@@ -260,15 +315,15 @@ def get_radial_field(
 
     match mode.family:
         case 'LP':
-            (er, ephi, ez), (hr, hphi, hz) = neff_solver.get_LP_field(**kwargs)
+            (er, ephi, ez), (hr, hphi, hz) = effective_index_solver.get_LP_field(**kwargs)
         case 'TE':
-            (er, ephi, ez), (hr, hphi, hz) = neff_solver.get_TE_field(**kwargs)
+            (er, ephi, ez), (hr, hphi, hz) = effective_index_solver.get_TE_field(**kwargs)
         case 'TM':
-            (er, ephi, ez), (hr, hphi, hz) = neff_solver.get_TM_field(**kwargs)
+            (er, ephi, ez), (hr, hphi, hz) = effective_index_solver.get_TM_field(**kwargs)
         case 'EH':
-            (er, ephi, ez), (hr, hphi, hz) = neff_solver.get_EH_field(**kwargs)
+            (er, ephi, ez), (hr, hphi, hz) = effective_index_solver.get_EH_field(**kwargs)
         case 'HE':
-            (er, ephi, ez), (hr, hphi, hz) = neff_solver.get_HE_field(**kwargs)
+            (er, ephi, ez), (hr, hphi, hz) = effective_index_solver.get_HE_field(**kwargs)
 
     e_field = CylindricalCoordinates(rho=er, phi=ephi, z=ez)
     h_field = CylindricalCoordinates(rho=hr, phi=hphi, z=hz)

{pyfibermodes-0.13.2 → pyfibermodes-0.14.1}/PyFiberModes/loader.py

@@ -1,9 +1,15 @@
 """Load and normalize YAML fiber definitions."""
 
-import yaml
-import numpy as np
 from pathlib import Path
-from PyOptik import MaterialBank
+from typing import Any, TypeAlias
+
+import numpy as np
+import yaml
+
+from PyFiberModes.materials import DEFAULT_MATERIALS, MaterialRegistry
+
+LayerData: TypeAlias = dict[str, Any]
+LayerCollection: TypeAlias = dict[str, LayerData]
 
 
 def get_fiber_file_path(fiber_name: str) -> Path:
@@ -23,7 +29,7 @@ def get_fiber_file_path(fiber_name: str) -> Path:
     return Path(__file__).parent / 'fiber_files' / f'{fiber_name}.yaml'
 
 
-def load_yaml_configuration(file_path: Path) -> dict:
+def load_yaml_configuration(file_path: Path) -> dict[str, Any]:
     """
     Load and parse a YAML configuration file.
 
@@ -44,7 +50,12 @@ def load_yaml_configuration(file_path: Path) -> dict:
         return yaml.safe_load(file)
 
 
-def calculate_layer_index(layer: dict, wavelength: float, outer_layer: dict = None) -> float:
+def calculate_layer_index(
+    layer: LayerData,
+    wavelength: float | None,
+    outer_layer: LayerData | None = None,
+    materials: MaterialRegistry = DEFAULT_MATERIALS,
+) -> float:
     """
     Calculate the refractive index for a layer.
 
@@ -62,14 +73,21 @@ def calculate_layer_index(layer: dict, wavelength: float, outer_layer: dict = No
     float
         Computed refractive index for the layer.
     """
-    if 'material' in layer and wavelength:
-        return getattr(MaterialBank, layer['material']).compute_refractive_index(wavelength)
+    if 'material' in layer and wavelength is not None:
+        return materials.refractive_index(str(layer['material']), wavelength)
     elif 'NA' in layer and outer_layer:
         return np.sqrt(layer['NA']**2 + outer_layer['index']**2)
-    return layer.get('index')
+    index = layer.get('index')
+    if index is None:
+        raise ValueError("layer must define material, numerical aperture, or index")
+    return float(index)
 
 
-def process_layers(layers: dict, wavelength: float = None) -> dict:
+def process_layers(
+    layers: LayerCollection,
+    wavelength: float | None = None,
+    materials: MaterialRegistry = DEFAULT_MATERIALS,
+) -> LayerCollection:
     """
     Process and calculate refractive indices for all layers.
 
@@ -89,14 +107,14 @@ def process_layers(layers: dict, wavelength: float = None) -> dict:
     outer_layer = None
 
     for idx, layer in layers.items():
-        layer_index = calculate_layer_index(layer, wavelength, outer_layer)
+        layer_index = calculate_layer_index(layer, wavelength, outer_layer, materials)
         processed_layers[idx] = {**layer, 'index': layer_index}
         outer_layer = processed_layers[idx]
 
     return processed_layers
 
 
-def cleanup_layers(layers: dict) -> dict:
+def cleanup_layers(layers: LayerCollection) -> LayerCollection:
     """
     Remove unnecessary keys from layer dictionaries.
 
@@ -116,7 +134,7 @@ def cleanup_layers(layers: dict) -> dict:
     return layers
 
 
-def reorder_layers(layers: dict, order: str) -> dict:
+def reorder_layers(layers: LayerCollection, order: str) -> LayerCollection:
     """
     Reorder layers based on the specified order.
 
@@ -137,7 +155,12 @@ def reorder_layers(layers: dict, order: str) -> dict:
     return layers
 
 
-def load_fiber_as_dict(fiber_name: str, wavelength: float = None, order: str = 'in-to-out') -> dict:
+def load_fiber_as_dict(
+    fiber_name: str,
+    wavelength: float | None = None,
+    order: str = 'in-to-out',
+    materials: MaterialRegistry = DEFAULT_MATERIALS,
+) -> dict[str, LayerCollection]:
     """
     Load and process a fiber configuration file.
 
@@ -167,7 +190,7 @@ def load_fiber_as_dict(fiber_name: str, wavelength: float = None, order: str = '
     config = load_yaml_configuration(file_path)
     layers = config.get('layers', {})
 
-    processed_layers = process_layers(layers, wavelength)
+    processed_layers = process_layers(layers, wavelength, materials)
     cleaned_layers = cleanup_layers(processed_layers)
     reordered_layers = reorder_layers(cleaned_layers, order)