Second round of comments

Author: damiano-flex

docs/lectures/index.rst

@@ -10,10 +10,8 @@ Welcome to our lecture series!
     fdtd101
     fdtd_workshop
     inversedesign
-    small_signal_analysis
 
 
 .. include:: /lectures/fdtd101.rst
 .. include:: /lectures/fdtd_workshop.rst
 .. include:: /lectures/inversedesign.rst
-.. include:: /lectures/small_signal_analysis.rst

docs/lectures/small_signal_analysis.rst

@@ -254,3 +254,57 @@ def test_gaussian_pulse():
     assert "'fmax'" in msg and "'fmin'" in msg
     assert "conflict" in msg.lower()
     assert "exclude" in msg.lower()
+
+
+def test_sweep_decade():
+    """
+    Test the sweep_decade method for generating logarithmically spaced frequencies.
+    """
+    # Test basic functionality
+    freq_range = td.FreqRange.from_freq_interval(1e3, 1e6)  # 1 kHz to 1 MHz (3 decades)
+    freqs = freq_range.sweep_decade(10)  # 10 points per decade
+
+    # Check that frequencies are logarithmically spaced
+    assert len(freqs) > 0
+    assert np.isclose(freqs[0], freq_range.fmin)
+    assert np.isclose(freqs[-1], freq_range.fmax)
+
+    # Test with different number of points per decade
+    freqs_9 = freq_range.sweep_decade(9)
+    freqs_11 = freq_range.sweep_decade(11)
+
+    # More points per decade should result in more total points
+    assert len(freqs_9) < len(freqs) < len(freqs_11)
+
+    # All should span the same range
+    assert np.isclose(freqs_9[0], freqs_11[0])
+    assert np.isclose(freqs_9[-1], freqs_11[-1])
+    assert np.isclose(freqs[0], freqs_11[0])
+    assert np.isclose(freqs[-1], freqs_11[-1])
+
+
+def test_sweep_decade_edge_cases():
+    """
+    Test edge cases and error conditions for sweep_decade.
+    """
+    # Test with single decade
+    freq_range = td.FreqRange.from_freq_interval(1e3, 1e4)  # 1 decade
+    freqs = freq_range.sweep_decade(5)
+    assert len(freqs) >= 5  # Should have at least 5 points
+    assert np.isclose(freqs[0], freq_range.fmin)
+    assert np.isclose(freqs[-1], freq_range.fmax)
+
+    # Test error conditions
+    freq_range = td.FreqRange.from_freq_interval(1e3, 1e6)
+
+    # Negative points per decade
+    with pytest.raises(
+        ValueError, match="'num_points_per_decade' must be strictly positive, got -1."
+    ):
+        freq_range.sweep_decade(-1)
+
+    # Zero points per decade
+    with pytest.raises(
+        ValueError, match="'num_points_per_decade' must be strictly positive, got 0."
+    ):
+        freq_range.sweep_decade(0)

tests/test_components/test_frequencies.py

@@ -899,7 +899,11 @@ def test_heat_charge_bcs_validation(boundary_conditions):
 
     # Invalid ACVoltageSource: infinite voltage
     with pytest.raises(pd.ValidationError):
-        td.VoltageBC(source=td.ACVoltageSource(voltage=np.array([td.inf, 0, 1]), amplitude=1e-2))
+        td.VoltageBC(
+            source=td.ACVoltageSource(
+                voltage=np.array([td.inf, 0, 1]), signal=td.SinusoidalSignal(amplitude=1e-2)
+            )
+        )
 
 
 def test_ssac_freqs_validation():
@@ -937,7 +941,7 @@ def test_ssac_freqs_validation():
 
     charge_tolerance = td.ChargeToleranceSpec(rel_tol=1e5, abs_tol=1e3, max_iters=400)
     ssac_freqs_input = [1e3, 1e4, 1e5]
-    isothermal_spec = td.IsothermalSteadyChargeDCAnalysis(
+    isothermal_spec = td.IsothermalSSACAnalysis(
         temperature=300,
         tolerance_settings=charge_tolerance,
         fermi_dirac=True,
@@ -965,7 +969,7 @@ def test_ssac_freqs_validation():
         )
 
     # Test that ssac_freqs with ACVoltageSource works
-    ac_source = td.ACVoltageSource(voltage=[0, 1, 2], amplitude=1e-3)
+    ac_source = td.ACVoltageSource(voltage=[0, 1, 2], signal=td.SinusoidalSignal(amplitude=1e-3))
     sim = td.HeatChargeSimulation(
         size=(8, 8, 8),
         center=(0, 0, 0),
@@ -1332,10 +1336,14 @@ def createSolid(geometry, name):
     solid_structure_3 = createSolid(solid_box_3, "solid_3")
 
     bc_ssac1 = td.VoltageBC(
-        source=td.ACVoltageSource(voltage=[0, 1], amplitude=1e-3, name="ac_source1")
+        source=td.ACVoltageSource(
+            voltage=[0, 1], signal=td.SinusoidalSignal(amplitude=1e-3), name="ac_source1"
+        )
     )
     bc_ssac2 = td.VoltageBC(
-        source=td.ACVoltageSource(voltage=[0, 1], amplitude=1e-3, name="ac_source2")
+        source=td.ACVoltageSource(
+            voltage=[0, 1], signal=td.SinusoidalSignal(amplitude=1e-3), name="ac_source2"
+        )
     )
 
     placement1 = td.StructureStructureInterface(structures=["solid_1", "solid_2"])
@@ -1346,14 +1354,15 @@ def createSolid(geometry, name):
         td.HeatChargeBoundarySpec(condition=bc_ssac2, placement=placement2),
     ]
 
-    with pytest.raises(pd.ValidationError, match="Only a single AC source can be supplied"):
+    with pytest.raises(pd.ValidationError, match="Only a single AC source can be supplied."):
         td.HeatChargeSimulation(
             structures=[solid_structure_1, solid_structure_2, solid_structure_3],
             center=(2, 2, 2),
             size=(6, 6, 6),
             boundary_spec=boundary_spec,
             medium=air,
             grid_spec=grid_specs["uniform"],
+            analysis_spec=td.IsothermalSSACAnalysis(ssac_freqs=[1e2, 1e3]),
         )
 
 
@@ -1627,8 +1636,16 @@ def test_charge_simulation(
 
         # Two AC sources cannot be defined
         with pytest.raises(pd.ValidationError):
-            bc_ssac_n = bc_n.updated_copy(source=td.ACVoltageSource(voltage=[0, 1], amplitude=1e-3))
-            bc_ssac_p = bc_p.updated_copy(source=td.ACVoltageSource(voltage=[0, 1], amplitude=1e-3))
+            bc_ssac_n = bc_n.updated_copy(
+                source=td.ACVoltageSource(
+                    voltage=[0, 1], signal=td.SinusoidalSignal(amplitude=1e-3)
+                )
+            )
+            bc_ssac_p = bc_p.updated_copy(
+                source=td.ACVoltageSource(
+                    voltage=[0, 1], signal=td.SinusoidalSignal(amplitude=1e-3)
+                )
+            )
             analysis = sim.analysis_spec.updated_copy(ssac_freqs=[1e2, 1e3])
             sim.updated_copy(boundary_spec=[bc_n_ground, bc_p_ground], analysis_spec=analysis)
 

tests/test_components/test_heat_charge.py

@@ -20,12 +20,13 @@
 from tidy3d.components.microwave.data.monitor_data import (
     AntennaMetricsData,
 )
+from tidy3d.components.spice.analysis.ac import IsothermalSSACAnalysis
 from tidy3d.components.spice.analysis.dc import (
     ChargeToleranceSpec,
     IsothermalSteadyChargeDCAnalysis,
     SteadyChargeDCAnalysis,
 )
-from tidy3d.components.spice.sources.ac import ACVoltageSource
+from tidy3d.components.spice.sources.ac import ACSignal, ACVoltageSource, SinusoidalSignal
 from tidy3d.components.spice.sources.dc import DCCurrentSource, DCVoltageSource, GroundVoltageSource
 from tidy3d.components.spice.sources.types import VoltageSourceType
 from tidy3d.components.tcad.analysis.heat_simulation_type import UnsteadyHeatAnalysis, UnsteadySpec
@@ -445,6 +446,7 @@ def set_logging_level(level: str) -> None:
     "PML",
     "TFSF",
     "ABCBoundary",
+    "ACSignal",
     "ACVoltageSource",
     "Absorber",
     "AbsorberParams",
@@ -613,6 +615,7 @@ def set_logging_level(level: str) -> None:
     "IndexedVoltageDataArray",
     "InsulatingBC",
     "InternalAbsorber",
+    "IsothermalSSACAnalysis",
     "IsothermalSteadyChargeDCAnalysis",
     "IsotropicEffectiveDOS",
     "KerrNonlinearity",
@@ -694,6 +697,7 @@ def set_logging_level(level: str) -> None:
     "SimulationData",
     "SimulationDataMap",
     "SimulationMap",
+    "SinusoidalSignal",
     "SlotboomBandGapNarrowing",
     "SolidMedium",
     "SolidSpec",

tidy3d/__init__.py

@@ -436,6 +436,54 @@ def freqs(self, num_points: int, spacing: str = "uniform_freq") -> NDArray[np.fl
                 f"Received: {spacing!r}. Please provide a valid spacing type."
             )
 
+    def sweep_decade(self, num_points_per_decade: int) -> NDArray[np.float64]:
+        """
+        Generate frequencies with logarithmic spacing across decades.
+
+        Notes
+        -----
+        This method creates a logarithmically spaced frequency sweep.
+        It is analogous to the SPICE AC analysis command for a decade
+        sweep:  ``.ac dec <num_points_per_decade> <fmin> <fmax>``
+
+        Parameters
+        ----------
+        num_points_per_decade : int
+            Number of frequency points per decade. Must be strictly positive.
+
+        Returns
+        -------
+        NDArray[np.float64]
+            Array of frequencies with logarithmic spacing across decades.
+
+        Raises
+        ------
+        ValueError
+            If ``num_points_per_decade`` is not positive, or if frequency range is invalid.
+
+        Examples
+        --------
+        >>> freq_range = td.FreqRange.from_freq_interval(1e3, 1e6)  # 1 kHz to 1 MHz
+        >>> freqs = freq_range.sweep_decade(10)  # 10 points per decade
+        """
+        # Input validation
+        if num_points_per_decade <= 0:
+            raise ValueError(
+                f"'num_points_per_decade' must be strictly positive, got {num_points_per_decade}."
+            )
+
+        # Calculate logarithmic range
+        fstart = np.log10(self.fmin)
+        fend = np.log10(self.fmax)
+        num_decades = fend - fstart
+
+        # Calculate total number of points
+        # Add 1 to include the endpoint, ensuring we cover the full range
+        num_total_points = int(np.round(num_decades * num_points_per_decade)) + 1
+
+        # Generate logarithmically spaced frequencies
+        return np.logspace(fstart, fend, num_total_points)
+
     def wvls(self, num_points: int, spacing: str = "uniform_wvl") -> NDArray[np.float64]:
         """
         method ``wvls()`` returns a numpy array of ``num_points`` wavelengths uniformly

tidy3d/components/frequencies.py

@@ -0,0 +1,35 @@
+"""
+This class defines standard SPICE electrical_analysis types (electrical simulations configurations).
+"""
+
+from __future__ import annotations
+
+import pydantic.v1 as pd
+
+from tidy3d.components.spice.analysis.dc import IsothermalSteadyChargeDCAnalysis
+from tidy3d.components.types import ArrayFloat1D
+from tidy3d.constants import HERTZ
+
+
+class IsothermalSSACAnalysis(IsothermalSteadyChargeDCAnalysis):
+    """
+    Configures Isothermal Small-Signal AC (SSAC) analysis parameters for charge simulation.
+
+    This analysis class provides a more convenient interface for SSAC analysis by allowing
+    frequency range specification and automatic frequency sweep generation.
+
+    Examples
+    --------
+    >>> import tidy3d as td
+    >>> freq_range = td.FreqRange.from_freq_interval(start_freq=1e3, stop_freq=1e6)
+    >>> sweep_freqs = freq_range.sweep_decade(num_points_per_decade=10)
+    >>> ssac_spec = td.IsothermalSSACAnalysis(ssac_freqs=sweep_freqs)
+    """
+
+    ssac_freqs: ArrayFloat1D = pd.Field(
+        ...,
+        title="Small Signal AC Frequencies",
+        description="List of frequencies for small signal AC analysis. "
+        "At least one 'ACVoltageSource' must be present in the boundary conditions.",
+        units=HERTZ,
+    )