Some style clean-ups

Author: 1400073

simphony/time_domain/ideal.py

@@ -108,6 +108,7 @@ def run(self, inputs: dict) -> dict:
             "o0": o0_response,
             "o1": o1_response,
         }
+        return response
 
         return response
 
@@ -173,6 +174,7 @@ def run(self, inputs: dict, **kwargs) -> dict:
             "o0": o0_response,
             "o1": o1_response,
         }
+        return response
 
 
 class PhaseModulator(SampleModeComponent, BlockModeComponent):
@@ -303,14 +305,14 @@ def __init__(
         for i in range(self.r):  # inputs 0 … r-1
             for j in range(self.s):  # outputs r … r+s-1
                 phi = phases[i, j + self.r]
-                s_dict_time[(f"o{i}", f"o{j+self.r}")] = (
+                s_dict_time[(f"o{i}", f"o{j + self.r}")] = (
                     amplitude / jnp.sqrt(self.s) * jnp.exp(1j * phi)
                 )
 
         for i in range(self.s):  # inputs r … r+s-1
             for j in range(self.r):  # outputs 0 … r-1
                 phi = phases[i + self.s, j]
-                s_dict_time[(f"o{i+self.r}", f"o{j}")] = (
+                s_dict_time[(f"o{i + self.r}", f"o{j}")] = (
                     amplitude / jnp.sqrt(self.r) * jnp.exp(1j * phi)
                 )
 
@@ -330,7 +332,7 @@ def response(self, inputs: dict) -> dict:
         N = len(self.ports)
         for j, port in enumerate(self.ports):
             # sum over all inputs
-            resp = sum(inputs[f"o{l}"] * self.s_dict_time[j, l] for l in range(N))
+            resp = sum(inputs[f"o{idx}"] * self.s_dict_time[j, idx] for idx in range(N))
             response[port] = resp
         return response
 

simphony/time_domain/pole_residue_model.py

@@ -63,7 +63,7 @@ class IIRModelBaseband(PoleResidueModel):
     def __init__(
         self, wvl_microns, center_wvl, s_params, sampling_period, order, options=None
     ):
-        if options == None:
+        if options is None:
             self.options = BVF_Options()
         else:
             self.options = options
@@ -226,8 +226,6 @@ def compute_error(self):
         return np.max(np.abs(self.S - self.compute_response()))
 
     def compute_time_response(self, sig=None, t=None):
-        c = 299792458
-
         sys = self.generate_sys_discrete()
 
         if t is None:
@@ -266,7 +264,7 @@ def compute_lstsq_matrices(self, phi0, phi1):
                     # This allows us to implement the Fast Vector Fitting algorithm:
                     # https://scholar.googleusercontent.com/scholar?q=cache:u4aY-dn1tF8J:scholar.google.com/+piero+triverio+vector+fitting&hl=en&as_sdt=0,45
 
-                    Q1, R11 = np.linalg.qr(A1)
+                    Q1, _ = np.linalg.qr(A1)
                     R12 = Q1.conj().T @ A2
                     Q2, R22 = np.linalg.qr(A2 - Q1 @ R12)
 

simphony/time_domain/simulation.py

@@ -1,34 +1,29 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 import jax.numpy as jnp
 import matplotlib.pyplot as plt
-import networkx as nx
 import numpy as np
 import sax
 from jax import config, jit, lax
 from numpy.typing import ArrayLike
+from scipy.interpolate import interp1d
 
+from simphony.exceptions import UndefinedActiveComponent
+from simphony.simulation import Simulation, SimulationResult
+from simphony.time_domain.pole_residue_model import BVF_Options, IIRModelBaseband
 from simphony.time_domain.time_system import (
     BlockModeComponent,
     SampleModeComponent,
     TimeSystem,
     TimeSystemIIR,
 )
-from simphony.utils import SPEED_OF_LIGHT
+from simphony.utils import SPEED_OF_LIGHT, dict_to_matrix
 
 config.update("jax_enable_x64", True)
 
-from dataclasses import dataclass
-
-from scipy.interpolate import interp1d
-
-from simphony.exceptions import UndefinedActiveComponent
-from simphony.simulation import Simulation, SimulationResult
-from simphony.time_domain.pole_residue_model import BVF_Options, IIRModelBaseband
-from simphony.utils import dict_to_matrix
-
 if TYPE_CHECKING:
     from simphony.circuit.circuit import Circuit
 
@@ -390,8 +385,6 @@ def _sample_mode_run(
         )
 
     def _block_mode_run(self, t: ArrayLike, input_signals: dict) -> TimeResult:
-        graph = nx.DiGraph()
-
         # --------------------------------------------------------------
         # Turn self.td_netlist into a Networkx Graph
         # --------------------------------------------------------------
@@ -417,10 +410,7 @@ def _block_mode_run(self, t: ArrayLike, input_signals: dict) -> TimeResult:
         # Determine which exposed ports are Inputs and which are Outputs
         # --------------------------------------------------------------
 
-        exposed_ports = {
-            "inputs": [],
-            "outputs": [],
-        }
+        pass
 
     # ------------------------------------------------------------------
     # HELPER: build immutable/tuple wiring maps (hashable for jit)

simphony/time_domain/time_system.py

@@ -14,17 +14,17 @@
 
 class TimeSystem(ABC):
     def __init__(self, optical_ports, electrical_ports, logic_ports) -> None:
-        if optical_ports == None:
+        if optical_ports is None:
             self.optical_ports = []
         else:
             self.optical_ports = optical_ports
 
-        if electrical_ports == None:
+        if electrical_ports is None:
             self.electrical_ports = []
         else:
             self.electrical_ports = electrical_ports
         # self.electrical_ports = electrical_ports
-        if logic_ports == None:
+        if logic_ports is None:
             self.logic_ports = []
         else:
             self.logic_ports = logic_ports
@@ -134,7 +134,7 @@ def my_dlsim(system, u, t=None, x0=None):
     return tout, yout, xout
 
 
-def my_dlsimworks(system, u, t=None, x0=None):
+def my_dlsimworks_jax(system, u, t=None, x0=None):
     out_samples = len(u)
     stoptime = (out_samples) * system.dt
 
@@ -302,8 +302,6 @@ def run(self, inputs: dict, time_sim=True, **kwargs) -> ArrayLike:
         # if state_vector is not None:
         #      self.state_vector = state_vector
 
-        first_key = next(iter(inputs))
-        N = inputs[first_key].shape
         responses = {}
 
         input = jnp.hstack([value.reshape(-1, 1) for value in inputs.values()])

simphony/time_domain/vector_fitting/s_domain.py

@@ -1,14 +1,13 @@
 import jax
-
-jax.config.update("jax_enable_x64", True)
-from time import time
-
 import jax.numpy as jnp
 import matplotlib.pyplot as plt
+import numpy as np
 from scipy.constants import speed_of_light
 
 from simphony.simulation.jax_tools import python_based_while_loop
 
+jax.config.update("jax_enable_x64", True)
+
 
 # @jax.jit
 def _initial_poles(model_order, frequency, alpha):
@@ -42,18 +41,13 @@ def _lstsq_matrices(model_order, transfer_function, phi0, phi1):
     M = jnp.zeros(((num_ports**2) * (model_order), (model_order)), dtype=complex)
     B = jnp.zeros(((num_ports**2) * (model_order)), dtype=complex)
 
-    A1 = phi0
-    Q1, R11 = jnp.linalg.qr(A1)
-
     iter = 0
     for i in range(num_ports):
         for j in range(num_ports):
             D = jnp.diag(transfer_function[:, i, j])
             A_block = jnp.hstack([phi0, -D @ phi1])  # never build the big matrix
             Q, R = jnp.linalg.qr(A_block, mode="reduced")
 
-            R11 = R[: model_order + 1, : model_order + 1]
-            R12 = R[: model_order + 1, model_order + 1 :]
             R22 = R[model_order + 1 :, model_order + 1 :]
             Q2 = Q[:, model_order + 1 :]
 
@@ -80,9 +74,6 @@ def _lstsq_matrices(model_order, transfer_function, phi0, phi1):
     return M, B
 
 
-import numpy as np
-
-
 def _full_lstsq_matrices(transfer_function, phi0, phi1):
     D = []
     V = []
@@ -395,9 +386,9 @@ def optimize_order(bias_fn, min_order, max_order):
     C_max_minus_1, *_ = bias_fn(max_order - 1)
     lambda_lower = jnp.abs(C_max_minus_1 - C_max)
     lambda_upper = C_min - C_max
-    l = jnp.log10(lambda_lower)
-    u = jnp.log10(lambda_upper)
-    complexity_penalty = 10 ** (0.5 * (u + l))
+    lower_log = jnp.log10(lambda_lower)
+    upper_log = jnp.log10(lambda_upper)
+    complexity_penalty = 10 ** (0.5 * (upper_log + lower_log))
 
     # TODO: implement Golden Section Search
     # to minimize C - complexity_penalty * order
@@ -490,10 +481,7 @@ def main():
     )
     residues = jnp.reshape(residues[1:], (10, 1, 1))
     feedthrough = jnp.zeros((1, 1), dtype=complex)
-    N = len(poles)
-
     f = jnp.linspace(0.001, 10 / (2 * jnp.pi), 100)
-    aortic_response = pole_residue_response(f, poles, residues, feedthrough)
 
     _mzi, info = sax.circuit(
         netlist={
@@ -531,7 +519,6 @@ def mzi(wl=1.55):
     f_max = speed_of_light / 1.50e-6
     # f_min = speed_of_light / 1.565e-6
     # f_max = speed_of_light / 1.5350e-6
-    f_center = 0.5 * (f_min + f_max)
     frequency = jnp.linspace(f_min, f_max, 1000)
 
     plt.plot(
@@ -598,15 +585,12 @@ def main2():
     )
     residues = jnp.reshape(residues[1:], (10, 1, 1))
     feedthrough = jnp.zeros((1, 1), dtype=complex)
-    N = len(poles)
-
     f = jnp.linspace(0.001, 10 / (2 * jnp.pi), 100)
     response = pole_residue_response(f, poles, residues, feedthrough)
 
     poles1, residues1, feedthrough1, error = vector_fitting(
         10, response, f, max_iterations=5
     )
-    toc = time()
     H = pole_residue_response(f, poles1, residues1, feedthrough1)
     plt.plot(f, jnp.abs(H[:, 0, 0]) ** 2)
     plt.plot(f, jnp.abs(response[:, 0, 0]) ** 2, "r--")

simphony/time_domain/vector_fitting/z_domain.py

@@ -41,9 +41,6 @@ def _lstsq_matrices(model_order, transfer_function, phi0, phi1):
     )
     B = jnp.zeros(((num_inputs * num_outputs) * (model_order)), dtype=complex)
 
-    A1 = phi0
-    Q1, R11 = jnp.linalg.qr(A1)
-
     iter = 0
     # for i in range(num_ports):
     #     for j in range(num_ports):
@@ -53,8 +50,6 @@ def _lstsq_matrices(model_order, transfer_function, phi0, phi1):
             A_block = jnp.hstack([phi0, -D @ phi1])  # never build the big matrix
             Q, R = jnp.linalg.qr(A_block, mode="reduced")
 
-            R11 = R[: model_order + 1, : model_order + 1]
-            R12 = R[: model_order + 1, model_order + 1 :]
             R22 = R[model_order + 1 :, model_order + 1 :]
             Q2 = Q[:, model_order + 1 :]
 
@@ -398,9 +393,9 @@ def optimize_order(bias_fn, min_order, max_order):
     C_max_minus_1, *_ = bias_fn(max_order - 1)
     lambda_lower = jnp.abs(C_max_minus_1 - C_max)
     lambda_upper = C_min - C_max
-    l = jnp.log10(lambda_lower)
-    u = jnp.log10(lambda_upper)
-    complexity_penalty = 10 ** (0.5 * (u + l))
+    lower_log = jnp.log10(lambda_lower)
+    upper_log = jnp.log10(lambda_upper)
+    complexity_penalty = 10 ** (0.5 * (upper_log + lower_log))
 
     # TODO: implement Golden Section Search
     # to minimize C - complexity_penalty * order
@@ -818,8 +813,6 @@ def state_space_frequency_response_discrete(A, B, C, D, f, f_center, dt):
 
 
 def main():
-    from time import time
-
     import sax
 
     from simphony.libraries import ideal
@@ -860,12 +853,9 @@ def main():
     sampling_frequency = 1e14
     model_order = 10
 
-    tic = time()
     poles, residues, feedthrough, error = optimize_order_vector_fitting_discrete(
         10, 50, s_params, frequency, f_center, sampling_frequency
     )
-    toc = time()
-    elapsed_time_1 = toc - tic
     model_order = len(poles)
     poles_eng, residues_eng, feedthrough_eng, erro = vector_fitting_discrete(
         model_order,
@@ -908,7 +898,7 @@ def main():
     plt.scatter(residues_eng[:, 0, 1].real, residues_eng[:, 0, 1].imag)
     plt.show()
 
-    H = pole_residue_response_discrete(
+    pole_residue_response_discrete(
         f,
         f_center,
         sampling_frequency,

tox.ini

@@ -34,3 +34,10 @@ exclude =
     .tox,
     extra,
     deprecated
+
+per-file-ignores =
+    simphony/time_domain/SSFM_old.py:E226,F841
+    simphony/time_domain/examples/*.py:E203,E402
+    simphony/time_domain/old_simulation.py:C901,E402,E711,F541
+    simphony/time_domain/quicker_delete.py:E226,E402
+    simphony/time_domain/tests/*.py:E402,F841