Upload 6 files

app.py

@@ -0,0 +1,134 @@
+import streamlit as st
+import matplotlib.pyplot as plt
+import numpy as np
+
+from loudspeaker_tmatrix.core import simulate_loudspeaker
+from loudspeaker_tmatrix.visualization import plot_loudspeaker_response
+from loudspeaker_tmatrix.config import (
+    load_config,
+    load_loudspeaker_config,
+    AcousticalConstantsConfig,
+)
+
+config_path = "configs/config.yaml"
+default_loudspeaker_path = "configs/default_loudspeaker.yaml"
+
+cfg = load_config(config_path)
+loudspeaker_cfg = load_loudspeaker_config(default_loudspeaker_path)
+
+freq_array = np.logspace(
+    np.log10(cfg.frequency.min), np.log10(cfg.frequency.max), num=cfg.frequency.n_bins
+)
+
+angular_freq_array = 2 * np.pi * freq_array
+
+st.sidebar.title("Thiele Small parameters")
+
+### Sliders
+slider_Re = st.sidebar.slider(
+    "Electrical Coil Resistance (Re) [Ohm]",
+    0.0,
+    10.0,
+    loudspeaker_cfg.electrical.coil_resistance,
+)
+slider_Le = st.sidebar.slider(
+    "Electrical Coil Inductance (Le) [mH]",
+    0.0,
+    10.0,
+    loudspeaker_cfg.electrical.coil_inductance * 1e3,
+)
+slider_Le /= 1e3
+slider_Bl = st.sidebar.slider(
+    "Electromechanical factor (Bl) [N/A]",
+    0.0,
+    10.0,
+    loudspeaker_cfg.electromechanical_factor,
+)
+slider_Mm = st.sidebar.slider(
+    "Mechanical Mass (Mm) [mg]",
+    0.0,
+    50.0,
+    loudspeaker_cfg.mechanical.mass * 1e3,
+)
+slider_Mm /= 1e3
+slider_Cm = st.sidebar.slider(
+    "Mechanical Compliance (Cm) [mm/N]",
+    0.0,
+    5.0,
+    loudspeaker_cfg.mechanical.compliance * 1e3,
+)
+slider_Cm /= 1e3
+slider_Rm = st.sidebar.slider(
+    "Mechanical Resistance (Rm) [kg/s]",
+    0.0,
+    10.0,
+    loudspeaker_cfg.mechanical.resistance,
+)
+slider_diam = st.sidebar.slider(
+    "Effective diameter of radiation [cm]",
+    0.0,
+    50.0,
+    loudspeaker_cfg.acoustical.effective_diameter * 1e2,
+)
+slider_diam /= 1e2
+
+default_params = st.sidebar.button("Set default parameters")
+
+if default_params:
+    st.rerun(scope="app")
+
+
+freq_array = np.logspace(
+    np.log10(cfg.frequency.min), np.log10(cfg.frequency.max), num=cfg.frequency.n_bins
+)
+
+angular_freq_array = 2 * np.pi * freq_array
+
+thiele_small_params = {
+    "Re": slider_Re,
+    "Le": slider_Le,
+    "Bl": slider_Bl,
+    "Mm": slider_Mm,
+    "Cm": slider_Cm,
+    "Rm": slider_Rm,
+    "effective_diameter": slider_diam,
+}
+
+loudspeaker_responses = simulate_loudspeaker(
+    thiele_small_params, angular_freq_array, cfg.acoustical_constants
+)
+
+
+# Electrical impedance
+electrical_impedance_plot = plot_loudspeaker_response(
+    response_array=loudspeaker_responses["electrical_impedance"],
+    freq_array=freq_array,
+    title="Electrical Impedance",
+    magnitude_in_db=False,
+    magnitude_units="Ohm",
+    shift_phase=False,
+)
+
+
+mechanical_velocity_plot = plot_loudspeaker_response(
+    response_array=loudspeaker_responses["mechanical_velocity"],
+    freq_array=freq_array,
+    title="Mechanical Velocity",
+    magnitude_in_db=False,
+    magnitude_units="m/s",
+    shift_phase=True,
+)
+
+
+acoustical_pressure = plot_loudspeaker_response(
+    response_array=loudspeaker_responses["acoustical_pressure"],
+    freq_array=freq_array,
+    title="Acoustical Pressure",
+    magnitude_in_db=True,
+    magnitude_units="dB",
+    shift_phase=False,
+)
+
+st.pyplot(electrical_impedance_plot)
+st.pyplot(mechanical_velocity_plot)
+st.pyplot(acoustical_pressure)

config.py

@@ -0,0 +1,58 @@
+from pydantic import BaseModel
+import yaml
+
+
+class FrequencyConfig(BaseModel):
+    min: int
+    max: int
+    n_bins: int
+
+
+class AcousticalConstantsConfig(BaseModel):
+    sound_speed: float
+    air_density: float
+    atmospheric_pressure: int
+    reference_pressure: float
+    measurement_distance: float
+    directivity_factor: int
+
+
+class Config(BaseModel):
+    default_loudspeaker_cfg: str
+    frequency: FrequencyConfig
+    acoustical_constants: AcousticalConstantsConfig
+
+
+def load_config(yaml_path: str) -> Config:
+    with open(yaml_path, "r") as file:
+        data = yaml.safe_load(file)
+    return Config(**data)
+
+
+class ElectricalConfig(BaseModel):
+    input_voltage: float
+    coil_resistance: float
+    coil_inductance: float
+
+
+class MechanicalConfig(BaseModel):
+    mass: float
+    compliance: float
+    resistance: float
+
+
+class AcousticalConfig(BaseModel):
+    effective_diameter: float
+
+
+class LoudspeakerConfig(BaseModel):
+    electrical: ElectricalConfig
+    electromechanical_factor: float
+    mechanical: MechanicalConfig
+    acoustical: AcousticalConfig
+
+
+def load_loudspeaker_config(yaml_path: str) -> LoudspeakerConfig:
+    with open(yaml_path, "r") as file:
+        data = yaml.safe_load(file)
+    return LoudspeakerConfig(**data)

core.py

@@ -0,0 +1,138 @@
+import numpy as np
+
+from loudspeaker_tmatrix import tmatrix
+from loudspeaker_tmatrix.utils import layer_wise_dot_product, struve, bessel
+from loudspeaker_tmatrix.config import AcousticalConstantsConfig
+
+
+def simulate_loudspeaker(
+    thiele_small_params: dict,
+    angular_freq_array: np.ndarray,
+    acoustical_constants: AcousticalConstantsConfig,
+):
+
+    n_bins = len(angular_freq_array)
+    Re_tmatrix = tmatrix.resistance_series(thiele_small_params["Re"], n_bins)
+    Z_Le_tmatrix = tmatrix.inductance_series(
+        thiele_small_params["Le"], angular_freq_array
+    )
+    Bl_tmatrix = tmatrix.gyrator(thiele_small_params["Bl"], n_bins)
+    Z_Mm_tmatrix = tmatrix.inductance_series(
+        thiele_small_params["Mm"], angular_freq_array
+    )
+    Z_Cm_tmatrix = tmatrix.capacitance_series(
+        thiele_small_params["Cm"], angular_freq_array
+    )
+    Rm_tmatrix = tmatrix.resistance_series(thiele_small_params["Rm"], n_bins)
+
+    electro_mechanical_tmatrix = layer_wise_dot_product(
+        Re_tmatrix,
+        Z_Le_tmatrix,
+        Bl_tmatrix,
+        Z_Mm_tmatrix,
+        Z_Cm_tmatrix,
+        Rm_tmatrix,
+    )
+
+    t_11 = electro_mechanical_tmatrix[0, 0]
+    t_12 = electro_mechanical_tmatrix[0, 1]
+    t_21 = electro_mechanical_tmatrix[1, 0]
+    t_22 = electro_mechanical_tmatrix[1, 1]
+
+    # Electrical response
+    electrical_impedance_shorted_output = t_12 / t_22
+
+    # Mechanical response
+    electrical_input_voltage = np.ones(n_bins)
+    electrical_input_current = (
+        electrical_input_voltage / electrical_impedance_shorted_output
+    )
+
+    electro_mechanical_tmatrix_det = np.abs(t_11 * t_22 - t_12 * t_21)
+
+    electro_mechanical_tmatrix_inv = np.array(
+        [
+            [
+                t_22 / electro_mechanical_tmatrix_det,
+                -t_12 / electro_mechanical_tmatrix_det,
+            ],
+            [
+                -t_21 / electro_mechanical_tmatrix_det,
+                t_11 / electro_mechanical_tmatrix_det,
+            ],
+        ]
+    )
+
+    mechanical_force, mechanical_velocity = layer_wise_dot_product(
+        electro_mechanical_tmatrix_inv,
+        np.array(
+            [
+                [electrical_input_voltage, electrical_input_voltage],
+                [electrical_input_current, electrical_input_current],
+            ]
+        ),
+    )[:, 0]
+
+    # Acoustical response
+    air_impedance = acoustical_constants.air_density * acoustical_constants.sound_speed
+    wave_number_array = angular_freq_array / acoustical_constants.sound_speed
+
+    effective_radiation_radius = thiele_small_params["effective_diameter"] / 2
+
+    ka_array = wave_number_array * effective_radiation_radius
+    Sd_value = np.pi * effective_radiation_radius**2
+    Sd_tmatrix = tmatrix.transformer(Sd_value, n_bins)
+
+    ### Mechanical impedance of radiation
+    ZM_rad_real_array = Sd_value * air_impedance * (1 - bessel(2 * ka_array) / ka_array)
+    ZM_rad_imag_array = (
+        Sd_value * air_impedance * (1j * (struve(2 * ka_array) / ka_array))
+    )
+    ZM_rad_array = ZM_rad_real_array + ZM_rad_imag_array
+    ZM_rad_tmatrix = np.array(
+        [[np.ones(n_bins), ZM_rad_array], [np.zeros(n_bins), np.ones(n_bins)]]
+    )
+
+    # Specific acoustic impedance
+    ZA_rad = (
+        1j
+        * angular_freq_array
+        * acoustical_constants.air_density
+        * acoustical_constants.directivity_factor
+    ) / (
+        4
+        * np.pi
+        * acoustical_constants.measurement_distance
+        * np.exp(1j * wave_number_array * acoustical_constants.measurement_distance)
+    )
+    Z_delay = 1j * np.exp(
+        -1j * wave_number_array * acoustical_constants.measurement_distance
+    )  # Phase rotation due air propagation time
+
+    electro_mechanical_acoustic_tmatrix = layer_wise_dot_product(
+        electro_mechanical_tmatrix, ZM_rad_tmatrix, Sd_tmatrix
+    )
+
+    electrical_input_voltage = 2.83
+
+    t_11 = electro_mechanical_acoustic_tmatrix[0, 0]
+    t_12 = electro_mechanical_acoustic_tmatrix[0, 1]
+    t_21 = electro_mechanical_acoustic_tmatrix[1, 0]
+    t_22 = electro_mechanical_acoustic_tmatrix[1, 1]
+
+    voltage_pressure_transfer_function = (ZA_rad) / (t_11 * ZA_rad + t_12)
+
+    acoustical_pressure = (
+        electrical_input_voltage
+        * (voltage_pressure_transfer_function / Z_delay)
+        / acoustical_constants.reference_pressure
+    )
+
+    loudspeaker_responses = {
+        "electrical_impedance": electrical_impedance_shorted_output,
+        "mechanical_force": mechanical_force,
+        "mechanical_velocity": mechanical_velocity,
+        "acoustical_pressure": acoustical_pressure,
+    }
+
+    return loudspeaker_responses

tmatrix.py

@@ -0,0 +1,49 @@
+import numpy as np
+
+
+def series_impedance(impedance_array):
+    n_bins = len(impedance_array)
+    tmatrix = np.array(
+        [
+            [np.ones(n_bins), impedance_array],
+            [np.zeros(n_bins), np.ones(n_bins)],
+        ]
+    )
+    return tmatrix
+
+
+def inductance_series(inductance_value, angular_freq_array):
+    impedance_array = 1j * angular_freq_array * inductance_value
+    return series_impedance(impedance_array)
+
+
+def capacitance_series(capacitance_value, angular_freq_array):
+    impedance_array = 1 / (1j * angular_freq_array * capacitance_value)
+    return series_impedance(impedance_array)
+
+
+def resistance_series(resistance_value, n_bins):
+    impedance_array = np.ones(n_bins) * resistance_value
+    return series_impedance(impedance_array)
+
+
+def transformer(transformer_value, n_bins):
+    transformer_array = np.ones(n_bins) * transformer_value
+    transformer = np.array(
+        [
+            [transformer_array, np.zeros(n_bins)],
+            [np.zeros(n_bins), 1 / transformer_array],
+        ]
+    )
+    return transformer
+
+
+def gyrator(gyrator_value, n_bins):
+    gyrator_array = np.ones(n_bins) * gyrator_value
+    gyrator = np.array(
+        [
+            [np.zeros(n_bins), gyrator_array],
+            [1 / gyrator_array, np.zeros(n_bins)],
+        ]
+    )
+    return gyrator

utils.py

@@ -0,0 +1,63 @@
+import numpy as np
+
+
+def layer_wise_dot_product(*matrices: np.ndarray) -> np.ndarray:
+    """
+    Performs the sequential layer-wise dot product of multiple 3D matrices along the last dimension.
+
+    Args:
+    *matrices: A variable number of 3D numpy arrays.
+
+    Returns:
+    A 3D numpy array containing the sequential dot product results for each layer in the last dimension.
+    """
+    if not all(matrix.shape == matrices[0].shape for matrix in matrices):
+        raise ValueError("All matrices must have the same dimensions.")
+
+    result = np.zeros_like(matrices[0], dtype="complex")
+
+    _, _, num_layers = matrices[0].shape
+
+    for layer_i in range(num_layers):
+        # Start the product with the identity matrix for the first multiplication
+        dot_product = np.eye(result.shape[0])
+        for matrix in matrices:
+            dot_product = np.dot(dot_product, matrix[:, :, layer_i])
+
+        result[:, :, layer_i] = dot_product
+
+    return result
+
+
+def bessel(z):
+    """
+    Bessel function aproximation for air radiation impedance
+    """
+    bessel_sum = 0
+    for k in range(25):
+        bessel_i = ((-1) ** k * (z / 2) ** (2 * k + 1)) / (
+            np.math.factorial(k) * np.math.factorial(k + 1)
+        )
+        bessel_sum = bessel_sum + bessel_i
+    return bessel_sum
+
+
+def struve(z):
+    """
+    Srtuve function aproximation for air radiation impedance
+    """
+    struve_sum = 0
+    for k in range(25):
+        struve_i = (((-1) ** k * (z / 2) ** (2 * k + 2))) / (
+            np.math.factorial(int(k + 1 / 2)) * np.math.factorial(int(k + 3 / 2))
+        )
+        struve_sum = struve_sum + struve_i
+    return struve_sum
+
+
+def to_db(x):
+    """
+    decibel calculus
+    """
+    db = 20 * np.log10(np.abs(x))
+    return db

visualization.py

@@ -0,0 +1,47 @@
+import numpy as np
+from matplotlib import pyplot as plt
+
+from loudspeaker_tmatrix.utils import to_db
+
+
+def plot_loudspeaker_response(
+    response_array: np.ndarray,
+    freq_array: np.ndarray,
+    title: str,
+    magnitude_in_db: bool,
+    magnitude_units: str,
+    shift_phase: bool,
+):
+
+    if magnitude_in_db:
+        magnitude = to_db(response_array)
+    else:
+        magnitude = np.abs(response_array)
+
+    if shift_phase:
+        phase = np.angle(-response_array, deg=True)
+    else:
+        phase = np.angle(response_array, deg=True)
+
+    fig, ax1 = plt.subplots(figsize=(12, 4))
+    fig.suptitle(title)
+
+    ax1.semilogx(freq_array, magnitude, label="Magnitude", color="C0")
+    ax1.set_xlabel("Frequency [Hz]")
+    ax1.set_ylabel(f"Magnitude [{magnitude_units}]", color="C0")
+    ax1.tick_params(axis="y", labelcolor="C0")
+
+    ax2 = ax1.twinx()
+    ax2.semilogx(freq_array, phase, color="r", label="Phase")
+    x_ticks = np.sort(np.array([16, 31, 63, 125, 250, 500, 1000, 2000, 4000]))
+    ax2.set_xticks(ticks=x_ticks, labels=x_ticks.tolist(), rotation=45)
+    ax2.set_ylabel("Phase [º]", color="r")
+    ax2.tick_params(axis="y", labelcolor="r")
+    y_label1 = [r"$-180º$", r"$-90º$", r"$0º$", r"$90º$", r"$180º$"]
+    ax2.set_yticks(np.array([-180, -90, 0, 90, 180]), y_label1)
+
+    ax1.set_xlim(10, 4000)
+    ax2.set_ylim(-180, 180)
+    ax1.grid(axis="x")
+    ax2.grid(axis="y")
+    return fig