Near2far fix for 2D Cylinder

Normalization to power density

delete some unuseful comments

delete a wrong commnet in def integrate_2d

something

fix rcs

near2far fix

delete compute2d

format changes

format issues

fix

fix

format

tidy3d/components/data/monitor_data.py

@@ -1882,6 +1882,20 @@ def propagation_phase(dist: Union[float, None], k: complex) -> complex:
             return 1.0
         return -1j * k * np.exp(1j * k * dist) / (4 * np.pi * dist)
 
+    @staticmethod
+    def propagation_phase_2d(dist: Union[float, None], k: complex) -> complex:
+        """Phase associated with propagation of a distance with a given wavenumber."""
+        if dist is None:
+            return 1.0
+        return -np.exp(1j * k * dist) * np.sqrt(1j * k / (8 * np.pi * dist))
+
+    @staticmethod
+    def propagation_phase_3d(dist: Union[float, None], k: complex) -> complex:
+        """Phase associated with propagation of a distance with a given wavenumber."""
+        if dist is None:
+            return 1.0
+        return -1j * k * np.exp(1j * k * dist) / (4 * np.pi * dist)
+
     @property
     def fields_spherical(self) -> xr.Dataset:
         """Get all field components in spherical coordinates relative to the monitor's
@@ -1973,6 +1987,32 @@ def radar_cross_section(self) -> xr.DataArray:
 
         return self.make_data_array(data=rcs_data)
 
+    @property
+    def radar_cross_section_2d(self) -> xr.DataArray:
+        """Radar cross section in units of incident power."""
+
+        _, index_k = self.nk
+        if not np.all(index_k == 0):
+            raise SetupError("Can't compute RCS for a lossy background medium.")
+
+        k = self.k[None, None, None, ...]
+        eta = self.eta[None, None, None, ...]
+
+        # 2D constant
+        constant = k**2 / (16 * np.pi * eta)
+
+        # normalize fields by the distance-based phase factor
+        coords_sph = self.coords_spherical
+        if coords_sph["r"] is None:
+            phase = 1.0
+        else:
+            phase = self.propagation_phase_2d(dist=coords_sph["r"][..., None], k=k)
+        Etheta = self.Etheta.values / phase
+        Ephi = self.Ephi.values / phase
+        rcs_data = constant * (np.abs(Etheta) ** 2 + np.abs(Ephi) ** 2)
+
+        return self.make_data_array(data=rcs_data)
+
 
 class FieldProjectionAngleData(AbstractFieldProjectionData):
     """Data associated with a :class:`.FieldProjectionAngleMonitor`: components of projected fields.

tidy3d/components/field_projection.py

@@ -337,6 +337,15 @@ def _resample_surface_currents(
         currents = currents.colocate(*colocation_points)
         return currents
 
+    def integrate_1d(
+        self,
+        function: np.ndarray,
+        phase: np.ndarray,
+        pts_u: np.ndarray,
+    ):
+        """Trapezoidal integration in two dimensions."""
+        return np.trapz(np.squeeze(function) * np.squeeze(phase), pts_u, axis=0)
+
     def integrate_2d(
         self,
         function: np.ndarray,
@@ -397,7 +406,6 @@ def _far_fields_for_surface(
 
         theta = np.atleast_1d(theta)
         phi = np.atleast_1d(phi)
-
         sin_theta = np.sin(theta)
         cos_theta = np.cos(theta)
         sin_phi = np.sin(phi)
@@ -421,21 +429,38 @@ def integrate_for_one_theta(i_th: int):
 
                 phase_ij = phase[idx_u][:, None] * phase[idx_v][None, :] * phase[idx_w]
 
-                J[idx_u, i_th, j_ph] = self.integrate_2d(
-                    currents_f[f"E{cmp_1}"].values, phase_ij, pts[idx_u], pts[idx_v]
-                )
+                if self.is_3d_simulation():
+                    J[idx_u, i_th, j_ph] = self.integrate_2d(
+                        currents_f[f"E{cmp_1}"].values, phase_ij, pts[idx_u], pts[idx_v]
+                    )
 
-                J[idx_v, i_th, j_ph] = self.integrate_2d(
-                    currents_f[f"E{cmp_2}"].values, phase_ij, pts[idx_u], pts[idx_v]
-                )
+                    J[idx_v, i_th, j_ph] = self.integrate_2d(
+                        currents_f[f"E{cmp_2}"].values, phase_ij, pts[idx_u], pts[idx_v]
+                    )
 
-                M[idx_u, i_th, j_ph] = self.integrate_2d(
-                    currents_f[f"H{cmp_1}"].values, phase_ij, pts[idx_u], pts[idx_v]
-                )
+                    M[idx_u, i_th, j_ph] = self.integrate_2d(
+                        currents_f[f"H{cmp_1}"].values, phase_ij, pts[idx_u], pts[idx_v]
+                    )
 
-                M[idx_v, i_th, j_ph] = self.integrate_2d(
-                    currents_f[f"H{cmp_2}"].values, phase_ij, pts[idx_u], pts[idx_v]
-                )
+                    M[idx_v, i_th, j_ph] = self.integrate_2d(
+                        currents_f[f"H{cmp_2}"].values, phase_ij, pts[idx_u], pts[idx_v]
+                    )
+                else:
+                    J[idx_u, i_th, j_ph] = self.integrate_1d(
+                        currents_f[f"E{cmp_1}"].values, phase_ij, pts[idx_u]
+                    )
+
+                    J[idx_v, i_th, j_ph] = self.integrate_1d(
+                        currents_f[f"E{cmp_2}"].values, phase_ij, pts[idx_u]
+                    )
+
+                    M[idx_u, i_th, j_ph] = self.integrate_1d(
+                        currents_f[f"H{cmp_1}"].values, phase_ij, pts[idx_u]
+                    )
+
+                    M[idx_v, i_th, j_ph] = self.integrate_1d(
+                        currents_f[f"H{cmp_2}"].values, phase_ij, pts[idx_u]
+                    )
 
         if len(theta) < 2:
             integrate_for_one_theta(0)
@@ -534,6 +559,10 @@ def project_fields(
             return self._project_fields_cartesian(proj_monitor)
         return self._project_fields_kspace(proj_monitor)
 
+    def is_3d_simulation(self) -> bool:
+        """Determine if the simulation is 2D or 3D based on the size attribute."""
+        return self.sim_data.simulation.size[2] != 0.01
+
     def _project_fields_angular(
         self, monitor: FieldProjectionAngleMonitor
     ) -> FieldProjectionAngleData:
@@ -554,17 +583,24 @@ def _project_fields_angular(
         theta = np.atleast_1d(monitor.theta)
         phi = np.atleast_1d(monitor.phi)
 
-        # compute projected fields for the dataset associated with each monitor
+        medium = monitor.medium if monitor.medium else self.medium
+        k = AbstractFieldProjectionData.wavenumber(medium=medium, frequency=freqs)
+
         field_names = ("Er", "Etheta", "Ephi", "Hr", "Htheta", "Hphi")
         fields = [
             np.zeros((1, len(theta), len(phi), len(freqs)), dtype=complex) for _ in field_names
         ]
 
-        medium = monitor.medium if monitor.medium else self.medium
-        k = AbstractFieldProjectionData.wavenumber(medium=medium, frequency=freqs)
-        phase = np.atleast_1d(
-            AbstractFieldProjectionData.propagation_phase(dist=monitor.proj_distance, k=k)
-        )
+        if self.is_3d_simulation():
+            # compute projected fields for the dataset associated with each monitor in 3D
+            phase = np.atleast_1d(
+                AbstractFieldProjectionData.propagation_phase_3d(dist=monitor.proj_distance, k=k)
+            )
+        else:
+            # compute projected fields for the dataset associated with each monitor in 2D
+            phase = np.atleast_1d(
+                AbstractFieldProjectionData.propagation_phase_2d(dist=monitor.proj_distance, k=k)
+            )
 
         for surface in self.surfaces:
             # apply windowing to currents