flexcompute-core 0.0.1.dev2__py3-none-any.whl → 0.0.1.dev3__py3-none-any.whl

flexcompute/core/_migration/em/apodization/__init__.py

@@ -0,0 +1 @@
+"""Apodization validation scope."""

flexcompute/core/_migration/em/apodization/schema.py

@@ -0,0 +1,88 @@
+"""Defines specification for apodization."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from pydantic import Field, NonNegativeFloat, PositiveFloat
+
+from flexcompute.core._migration.em.schema.tidy3d.components.base import Tidy3dBaseModel
+from flexcompute.core._migration.em.schema.tidy3d.components.viz import add_ax_if_none
+from flexcompute.core._migration.em.schema.tidy3d.constants import SECOND
+
+if TYPE_CHECKING:
+    from flexcompute.core._migration.em.schema.tidy3d.components.types import ArrayFloat1D, Ax
+
+
+class ApodizationSpec(Tidy3dBaseModel):
+    """Stores specifications for the apodizaton of frequency-domain monitors.
+
+    Example
+    -------
+    >>> apod_spec = ApodizationSpec(start=1, end=2, width=0.2)
+
+
+    .. image:: ../../_static/img/apodization.png
+        :width: 80%
+        :align: center
+
+    """
+
+    start: NonNegativeFloat | None = Field(
+        default=None,
+        title="Start Interval",
+        description="Defines the time at which the start apodization ends.",
+        json_schema_extra={"units": SECOND},
+    )
+
+    end: NonNegativeFloat | None = Field(
+        default=None,
+        title="End Interval",
+        description="Defines the time at which the end apodization begins.",
+        json_schema_extra={"units": SECOND},
+    )
+
+    width: PositiveFloat | None = Field(
+        default=None,
+        title="Apodization Width",
+        description="Characteristic decay length of the apodization function, i.e., the width of the ramping up of the scaling function from 0 to 1.",
+        json_schema_extra={"units": SECOND},
+    )
+
+    @add_ax_if_none
+    def plot(self, times: ArrayFloat1D, ax: Ax = None) -> Ax:
+        """Plot the apodization function.
+
+        Parameters
+        ----------
+        times : np.ndarray
+            Array of times (seconds) to plot source at.
+            To see source time amplitude for a specific :class:`.Simulation`,
+            pass ``simulation.tmesh``.
+        ax : matplotlib.axes._subplots.Axes = None
+            Matplotlib axes to plot on, if not specified, one is created.
+
+        Returns
+        -------
+        matplotlib.axes._subplots.Axes
+            The supplied or created matplotlib axes.
+        """
+        times = np.array(times)
+        amp = np.ones_like(times)
+
+        if self.start is not None:
+            start_ind = times < self.start
+            time_scaled = (times[start_ind] - self.start) / self.width
+            amp[start_ind] *= np.exp(-0.5 * time_scaled**2)
+
+        if self.end is not None:
+            end_ind = times > self.end
+            time_scaled = (times[end_ind] - self.end) / self.width
+            amp[end_ind] *= np.exp(-0.5 * time_scaled**2)
+
+        ax.plot(times, amp, color="blueviolet")
+        ax.set_xlabel("time (s)")
+        ax.set_title("apodization function")
+        ax.set_aspect("auto")
+        return ax

flexcompute/core/_migration/em/apodization/validation.py

@@ -0,0 +1,54 @@
+"""Pure rules for apodization validation."""
+
+from __future__ import annotations
+
+from flexcompute.core.validation import ValidationDiagnostic, ValidationReport, error
+
+
+def validate_end_order(start: float | None, end: float | None) -> tuple[ValidationDiagnostic, ...]:
+    """Require the end apodization to begin no earlier than the start apodization ends."""
+    if start is not None and end is not None and end < start:
+        return (
+            error(
+                "em.apodization.end_greater_than_start",
+                "End apodization begins before start apodization ends.",
+                ("end",),
+            ),
+        )
+    return ()
+
+
+def validate_width(
+    start: float | None, end: float | None, width: float | None
+) -> tuple[ValidationDiagnostic, ...]:
+    """Require a width when either the start or the end apodization is requested."""
+    if (start is not None or end is not None) and width is None:
+        return (
+            error(
+                "em.apodization.width_provided",
+                "Apodization width must be set.",
+                ("width",),
+            ),
+        )
+    return ()
+
+
+def validate(schema: object) -> ValidationReport:
+    """Validate a moved apodization spec in the order of the replaced validators.
+
+    The end-before-start rule comes first, as that validator ran first, so the first error
+    matches the public constructor.
+
+    The validation dispatch calls this on every node whose class has this scope. A node of
+    any other class reports nothing.
+    """
+    from .schema import ApodizationSpec
+
+    if not isinstance(schema, ApodizationSpec):
+        return ValidationReport()
+    return ValidationReport(
+        diagnostics=(
+            *validate_end_order(schema.start, schema.end),
+            *validate_width(schema.start, schema.end, schema.width),
+        )
+    )

flexcompute/core/_migration/em/boundary/__init__.py

@@ -0,0 +1 @@
+"""Boundary-condition validation scope."""

flexcompute/core/_migration/em/boundary/placement/__init__.py

@@ -0,0 +1 @@
+"""Boundary-placement validation scope."""

flexcompute/core/_migration/em/boundary/placement/schema.py

@@ -0,0 +1,101 @@
+"""Defines placements for boundary conditions."""
+
+from __future__ import annotations
+
+from abc import ABC
+
+from pydantic import Field
+
+from flexcompute.core._migration.em.schema.tidy3d.components.types.base import discriminated_union
+from flexcompute.core._migration.em.schema.tidy3d.components.base import Tidy3dBaseModel
+from flexcompute.core._migration.em.schema.tidy3d.components.types import BoxSurface
+
+
+class AbstractBCPlacement(ABC, Tidy3dBaseModel):
+    """Abstract placement for boundary conditions."""
+
+
+class StructureBoundary(AbstractBCPlacement):
+    """Placement of boundary conditions on the structure's boundary.
+
+    Example
+    -------
+    >>> bc_placement = StructureBoundary(structure="box")
+    """
+
+    structure: str = Field(
+        title="Structure Name",
+        description="Name of the structure.",
+    )
+
+
+class StructureStructureInterface(AbstractBCPlacement):
+    """Placement of boundary conditions between two structures.
+
+    Example
+    -------
+    >>> bc_placement = StructureStructureInterface(structures=["box", "sphere"])
+    """
+
+    structures: tuple[str, str] = Field(
+        title="Structures",
+        description="Names of two structures.",
+    )
+
+
+class MediumMediumInterface(AbstractBCPlacement):
+    """Placement of boundary conditions between two mediums.
+
+    Example
+    -------
+    >>> bc_placement = MediumMediumInterface(mediums=["dieletric", "metal"])
+    """
+
+    mediums: tuple[str, str] = Field(
+        title="Mediums",
+        description="Names of two mediums.",
+    )
+
+
+class SimulationBoundary(AbstractBCPlacement):
+    """Placement of boundary conditions on the simulation box boundary.
+
+    Example
+    -------
+    >>> bc_placement = SimulationBoundary(surfaces=["x-", "x+"])
+    """
+
+    surfaces: tuple[BoxSurface, ...] = Field(
+        default=("x-", "x+", "y-", "y+", "z-", "z+"),
+        title="Surfaces",
+        description="Surfaces of simulation domain where to apply boundary conditions.",
+    )
+
+
+class StructureSimulationBoundary(AbstractBCPlacement):
+    """Placement of boundary conditions on the simulation box boundary covered by the structure.
+
+    Example
+    -------
+    >>> bc_placement = StructureSimulationBoundary(structure="box", surfaces=["y-", "y+"])
+    """
+
+    structure: str = Field(
+        title="Structure Name",
+        description="Name of the structure.",
+    )
+
+    surfaces: tuple[BoxSurface, ...] = Field(
+        default=("x-", "x+", "y-", "y+", "z-", "z+"),
+        title="Surfaces",
+        description="Surfaces of simulation domain where to apply boundary conditions.",
+    )
+
+
+BCPlacementType = discriminated_union(
+    StructureBoundary
+    | StructureStructureInterface
+    | MediumMediumInterface
+    | SimulationBoundary
+    | StructureSimulationBoundary
+)

flexcompute/core/_migration/em/boundary/placement/validation.py

@@ -0,0 +1,42 @@
+"""Pure rules for boundary-condition placements."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from flexcompute.core.validation import ValidationDiagnostic, ValidationReport, error
+
+if TYPE_CHECKING:
+    from .schema import MediumMediumInterface, StructureStructureInterface
+
+
+def validate_distinct_names(
+    interface: StructureStructureInterface | MediumMediumInterface,
+) -> tuple[ValidationDiagnostic, ...]:
+    """Reject an interface that names the same structure or medium twice."""
+    from .schema import StructureStructureInterface
+
+    if isinstance(interface, StructureStructureInterface):
+        field, kind, owner = "structures", "structure", "StructureStructureInterface"
+    else:
+        field, kind, owner = "mediums", "medium", "MediumMediumInterface"
+    names = getattr(interface, field)
+    if names[0] != names[1]:
+        return ()
+    return (
+        error(
+            f"em.boundary.placement.duplicate_{kind}",
+            f"The same {kind} is provided twice in '{owner}'.",
+            (field,),
+        ),
+    )
+
+
+def validate(schema: object) -> ValidationReport:
+    """Run the placement rules for one node; any other node reports nothing."""
+    from .schema import MediumMediumInterface, StructureStructureInterface
+
+    diagnostics = ()
+    if isinstance(schema, (StructureStructureInterface, MediumMediumInterface)):
+        diagnostics = validate_distinct_names(schema)
+    return ValidationReport(diagnostics=diagnostics)