maint[autograd]: raise error when differentiating server-side field projection

Author: yaugenst-flex

CHANGELOG.md

@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+- Attempting to differentiate server-side field projections now raises a clear error instead of silently failing.
+
 ## [2.8.3] - 2025-04-24
 
 ### Added

tests/test_components/test_autograd.py

@@ -1260,7 +1260,7 @@ def objective(args):
 class TestFieldProjection:
     @staticmethod
     def setup(far_field_approx, projection_type, sim_2d):
-        if sim_2d and not far_field_approx:
+        if (sim_2d or not IS_3D) and not far_field_approx:
             pytest.skip("Exact field projection not implemented for 2d simulations")
 
         r_proj = 50 * WVL
@@ -1274,39 +1274,36 @@ def setup(far_field_approx, projection_type, sim_2d):
 
         if projection_type == "angular":
             theta_proj = np.linspace(np.pi / 10, np.pi - np.pi / 10, 2)
-            phi_proj = np.linspace(np.pi / 10, np.pi - np.pi / 10, 3)
             monitor_far = td.FieldProjectionAngleMonitor(
                 center=monitor.center,
                 size=monitor.size,
                 freqs=monitor.freqs,
-                phi=tuple(phi_proj),
+                phi=(np.pi / 2, 3 * np.pi / 2),
                 theta=tuple(theta_proj),
                 proj_distance=r_proj,
                 far_field_approx=far_field_approx,
                 name="far_field",
             )
         elif projection_type == "cartesian":
-            x_proj = np.linspace(-10, 10, 2)
             y_proj = np.linspace(-10, 10, 3)
             monitor_far = td.FieldProjectionCartesianMonitor(
                 center=monitor.center,
                 size=monitor.size,
                 freqs=monitor.freqs,
-                x=x_proj,
+                x=[0],
                 y=y_proj,
                 proj_axis=1,
                 proj_distance=r_proj,
                 far_field_approx=far_field_approx,
                 name="far_field",
             )
         elif projection_type == "kspace":
-            ux = np.linspace(-0.7, 0.7, 2)
             uy = np.linspace(-0.7, 0.7, 3)
             monitor_far = td.FieldProjectionKSpaceMonitor(
                 center=monitor.center,
                 size=monitor.size,
                 freqs=monitor.freqs,
-                ux=ux,
+                ux=[0],
                 uy=uy,
                 proj_axis=1,
                 proj_distance=r_proj,
@@ -1370,6 +1367,26 @@ def objective(x0):
 
         check_grads(objective, modes=["rev"], order=1)(1.0)
 
+    def test_error_if_server_side_projection(
+        self, use_emulated_run, far_field_approx, projection_type, sim_2d
+    ):
+        """Using a far field monitor directly should error"""
+        # build a projection‐only monitor sim
+        sim_base, monitor_far = self.setup(far_field_approx, projection_type, sim_2d)
+        sim_base = sim_base.updated_copy(monitors=[monitor_far])
+
+        def objective(args):
+            structures_traced_dict = make_structures(args)
+            structures = list(SIM_BASE.structures)
+            for structure_key in structure_keys_:
+                structures.append(structures_traced_dict[structure_key])
+            sim = sim_base.updated_copy(structures=structures)
+            sim_data = run(sim, task_name="field_projection_test")
+            return sim_data["far_field"].power.sum().item()
+
+        with pytest.raises(NotImplementedError):
+            ag.grad(objective)(params0)
+
 
 def test_autograd_deepcopy():
     """make sure deepcopy works as expected in autograd."""

tests/utils.py

@@ -1092,6 +1092,112 @@ def make_directivity_data(monitor: td.DirectivityMonitor) -> td.DirectivityData:
             projection_surfaces=monitor.projection_surfaces,
         )
 
+    def make_field_projection_angle_data(
+        monitor: td.FieldProjectionAngleMonitor,
+    ) -> td.FieldProjectionAngleData:
+        """Random FieldProjectionAngleData from a FieldProjectionAngleMonitor."""
+        f = list(monitor.freqs)
+        r = np.atleast_1d(getattr(monitor, "proj_distance", 1.0))
+        theta = list(monitor.theta)
+        phi = list(monitor.phi)
+
+        coords = dict(r=r, theta=theta, phi=phi, f=f)
+        scalar_field = make_data(
+            coords=coords,
+            data_array_type=td.FieldProjectionAngleDataArray,
+            is_complex=True,
+        )
+
+        return td.FieldProjectionAngleData(
+            monitor=monitor,
+            Er=scalar_field,
+            Etheta=scalar_field,
+            Ephi=scalar_field,
+            Hr=scalar_field,
+            Htheta=scalar_field,
+            Hphi=scalar_field,
+            projection_surfaces=monitor.projection_surfaces,
+        )
+
+    def make_field_projection_cartesian_data(
+        monitor: td.FieldProjectionCartesianMonitor,
+    ) -> td.FieldProjectionCartesianData:
+        """Random FieldProjectionCartesianData from a FieldProjectionCartesianMonitor."""
+
+        f = list(monitor.freqs)
+        proj_distance = getattr(monitor, "proj_distance", 1.0)
+
+        # in-plane grids always come from monitor.x and monitor.y
+        x_plane = list(monitor.x)
+        y_plane = list(monitor.y)
+
+        # map the two planes to global (x, y, z) depending on the normal axis
+        if monitor.proj_axis == 0:  # (y, z)
+            coords = dict(
+                x=np.atleast_1d(proj_distance),
+                y=x_plane,
+                z=y_plane,
+                f=f,
+            )
+        elif monitor.proj_axis == 1:  # (x, z)
+            coords = dict(
+                x=x_plane,
+                y=np.atleast_1d(proj_distance),
+                z=y_plane,
+                f=f,
+            )
+        else:  # (x, y)
+            coords = dict(
+                x=x_plane,
+                y=y_plane,
+                z=np.atleast_1d(proj_distance),
+                f=f,
+            )
+
+        scalar_field = make_data(
+            coords=coords,
+            data_array_type=td.FieldProjectionCartesianDataArray,
+            is_complex=True,
+        )
+
+        return td.FieldProjectionCartesianData(
+            monitor=monitor,
+            Er=scalar_field,
+            Etheta=scalar_field,
+            Ephi=scalar_field,
+            Hr=scalar_field,
+            Htheta=scalar_field,
+            Hphi=scalar_field,
+            projection_surfaces=monitor.projection_surfaces,
+        )
+
+    def make_field_projection_kspace_data(
+        monitor: td.FieldProjectionKSpaceMonitor,
+    ) -> td.FieldProjectionKSpaceData:
+        """Random FieldProjectionKSpaceData from a FieldProjectionKSpaceMonitor."""
+        f = list(monitor.freqs)
+        r = np.atleast_1d(getattr(monitor, "proj_distance", 1.0))
+        ux = list(monitor.ux)
+        uy = list(monitor.uy)
+
+        coords = dict(ux=ux, uy=uy, r=r, f=f)
+        scalar_field = make_data(
+            coords=coords,
+            data_array_type=td.FieldProjectionKSpaceDataArray,
+            is_complex=True,
+        )
+
+        return td.FieldProjectionKSpaceData(
+            monitor=monitor,
+            Er=scalar_field,
+            Etheta=scalar_field,
+            Ephi=scalar_field,
+            Hr=scalar_field,
+            Htheta=scalar_field,
+            Hphi=scalar_field,
+            projection_surfaces=monitor.projection_surfaces,
+        )
+
     MONITOR_MAKER_MAP = {
         td.FieldMonitor: make_field_data,
         td.FieldTimeMonitor: make_field_time_data,
@@ -1101,6 +1207,9 @@ def make_directivity_data(monitor: td.DirectivityMonitor) -> td.DirectivityData:
         td.DiffractionMonitor: make_diff_data,
         td.FluxMonitor: make_flux_data,
         td.DirectivityMonitor: make_directivity_data,
+        td.FieldProjectionAngleMonitor: make_field_projection_angle_data,
+        td.FieldProjectionCartesianMonitor: make_field_projection_cartesian_data,
+        td.FieldProjectionKSpaceMonitor: make_field_projection_kspace_data,
     }
 
     data = [MONITOR_MAKER_MAP[type(mnt)](mnt) for mnt in simulation.monitors]

tidy3d/components/data/monitor_data.py

@@ -2433,6 +2433,20 @@ def radar_cross_section(self) -> DataArray:
 
         return self.make_data_array(data=rcs_data)
 
+    def make_adjoint_sources(
+        self, dataset_names: list[str], fwidth: float
+    ) -> List[Union[CustomCurrentSource, PointDipole]]:
+        """Error if server-side field projection is used for autograd"""
+
+        raise NotImplementedError(
+            "Adjoint is currently not implemented for server-side field projections. "
+            "To compute derivatives with respect to field projection data, please use a 'FieldMonitor' "
+            "and use a local projection in your objective function via 'FieldProjector.from_near_field_monitors'. "
+            "Using field projection monitors directly is not supported as the full field information is required "
+            "to construct the adjoint source for this problem. The field projection data does not contain the "
+            "information necessary for gradient computation."
+        )
+
 
 class FieldProjectionAngleData(AbstractFieldProjectionData):
     """Data associated with a :class:`.FieldProjectionAngleMonitor`: components of projected fields.