OpenIRF 0.2.0__tar.gz → 0.3.0__tar.gz

{openirf-0.2.0 → openirf-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenIRF
-Version: 0.2.0
+Version: 0.3.0
 Summary: An Open-Source Package for Impulse Response Function Estimation of Mechanical Systems
 Author-email: Oliver Maximilian Zobel <oliver.zobel@tum.de>
 License-Expression: MIT
@@ -35,3 +35,7 @@ A collection of tools for the time domain analysis of mechanical systems.
 To install OpenIRF through pip, use the following command:
 
 `pip install openirf`
+
+## AI Usage Disclosure
+
+Claude Code was used to create parts of the tests and plotting functions, as well as to set up the project infrastructure, packaging, and the documentation infrastructure. The main computation code was written by humans and verified using real data.

{openirf-0.2.0 → openirf-0.3.0}/README.md

@@ -13,3 +13,7 @@ A collection of tools for the time domain analysis of mechanical systems.
 To install OpenIRF through pip, use the following command:
 
 `pip install openirf`
+
+## AI Usage Disclosure
+
+Claude Code was used to create parts of the tests and plotting functions, as well as to set up the project infrastructure, packaging, and the documentation infrastructure. The main computation code was written by humans and verified using real data.

openirf-0.3.0/docs/experimental_irf.rst

@@ -0,0 +1 @@
+.. image:: ../src/openirf/logo_small.png
   :members:

openirf-0.3.0/docs/index.rst

@@ -0,0 +1,14 @@
+.. image:: ../src/openirf/logo_small.png
+	:alt: OpenIRF
+	:align: center
+	:width: 80%
+
+**An Open-Source Package for Impulse Response Function Estimation of Mechanical Systems**
+
+OpenIRF Documentation
+=======================
+
+.. toctree::
+	numerical_irf
+	experimental_irf
+	utils

openirf-0.3.0/docs/numerical_irf.rst

@@ -0,0 +1 @@
+.. image:: ../src/openirf/logo_small.png
   :members:

openirf-0.3.0/docs/utils.rst

@@ -0,0 +1,29 @@
+.. image:: ../src/openirf/logo_small.png
+	:alt: OpenIRF
+	:align: center
+	:width: 80%
+
+Utility Functions
+=================
+
+Interactive Selection Tools
+---------------------------
+
+.. autofunction:: openirf.interactive_retrigger
+
+Plotting Functions
+------------------
+
+.. autofunction:: openirf.experimental_time_series_plot
+
+.. autofunction:: openirf.numerical_irf_plot
+
+General Utility Functions
+-------------------------
+
+.. autofunction:: openirf.build_convolution_matrix
+
+.. autofunction:: openirf.newmark_integration
+
+.. autofunction:: openirf.extract_impulse_time_series
+

{openirf-0.2.0 → openirf-0.3.0}/pyproject.toml

@@ -31,6 +31,9 @@ classifiers = [
 [project.urls]
 Homepage = "https://gitlab.com/opentds/openirf"
 
+[tool.setuptools.package-data]
+openirf = ["*.png"]
+
 [tool.setuptools_scm]
 version_scheme = "post-release"
 local_scheme = "node-and-date"

{openirf-0.2.0 → openirf-0.3.0}/src/OpenIRF.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenIRF
-Version: 0.2.0
+Version: 0.3.0
 Summary: An Open-Source Package for Impulse Response Function Estimation of Mechanical Systems
 Author-email: Oliver Maximilian Zobel <oliver.zobel@tum.de>
 License-Expression: MIT
@@ -35,3 +35,7 @@ A collection of tools for the time domain analysis of mechanical systems.
 To install OpenIRF through pip, use the following command:
 
 `pip install openirf`
+
+## AI Usage Disclosure
+
+Claude Code was used to create parts of the tests and plotting functions, as well as to set up the project infrastructure, packaging, and the documentation infrastructure. The main computation code was written by humans and verified using real data.

{openirf-0.2.0 → openirf-0.3.0}/src/OpenIRF.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ docs/make.bat
 docs/numerical_irf.rst
 docs/requirements.in
 docs/requirements.txt
+docs/utils.rst
 src/OpenIRF.egg-info/PKG-INFO
 src/OpenIRF.egg-info/SOURCES.txt
 src/OpenIRF.egg-info/dependency_links.txt
@@ -25,11 +26,16 @@ src/OpenIRF.egg-info/scm_version.json
 src/OpenIRF.egg-info/top_level.txt
 src/openirf/__init__.py
 src/openirf/experimental_irf.py
+src/openirf/logo_small.png
 src/openirf/numerical_irf.py
 src/openirf/utils.py
 tests/convolution_matrix_test.py
+tests/experimental_irf_calculation_test.py
+tests/experimental_time_series_plot_test.py
+tests/interactive_retrigger_test.py
 tests/mck_import_test.py
 tests/numerical_irf_test.py
+tests/plot_style_test.py
 tests/retrigger_data_test.py
 tests/string_print_test.py
 tests/time_series_import_test.py

{openirf-0.2.0 → openirf-0.3.0}/src/OpenIRF.egg-info/scm_file_list.json

@@ -14,17 +14,23 @@
     "docs/numerical_irf.rst",
     "docs/requirements.in",
     "docs/requirements.txt",
+    "docs/utils.rst",
     "pyproject.toml",
     "requirements.txt",
     "requirements_dev.txt",
     "ruff.toml",
     "src/openirf/__init__.py",
     "src/openirf/experimental_irf.py",
+    "src/openirf/logo_small.png",
     "src/openirf/numerical_irf.py",
     "src/openirf/utils.py",
     "tests/convolution_matrix_test.py",
+    "tests/experimental_irf_calculation_test.py",
+    "tests/experimental_time_series_plot_test.py",
+    "tests/interactive_retrigger_test.py",
     "tests/mck_import_test.py",
     "tests/numerical_irf_test.py",
+    "tests/plot_style_test.py",
     "tests/retrigger_data_test.py",
     "tests/string_print_test.py",
     "tests/time_series_import_test.py"

openirf-0.3.0/src/OpenIRF.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.3.0",
+  "distance": 0,
+  "node": "g8d2df7f4a383fb6659b88fe05767fddceada62e4",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-31"
+}

{openirf-0.2.0 → openirf-0.3.0}/src/openirf/experimental_irf.py

@@ -12,9 +12,10 @@ class ExperimentalIRF:
 
     Shape of time series arrays
     ---------------------------
-    - 3D: Multiple dofs, multiple measurements (dof,number_of_measurements,points)
-    - 2D: Single dof, multiple measurements (number_of_measurements,points)
-    - 1D: Single dof, one measurement (points)
+    - SISO: ``y_vec`` with shape ``(n_t)``, ``f_vec`` with shape ``(n_t)``
+    - SISO with averaging: ``y_vec`` with shape ``(n_avg,n_t)``, ``f_vec`` with shape ``(n_avg,n_t)``
+    - MIMO: ``y_vec`` with shape ``(n_resp, n_exc, n_t)``, ``f_vec`` with shape ``(n_exc, n_t)``
+    - MIMO with averaging: ``y_vec`` with shape ``(n_resp, n_exc, n_avg, n_t)``, ``f_vec`` with shape ``(n_exc, n_avg, n_t)``
 
     Constraints
     -----------
@@ -26,25 +27,25 @@ class ExperimentalIRF:
     ----------
     :param t_vec: Time vector of time series ``y_vec`` and ``f_vec``.
     :type t_vec: ndarray
-    :param y_vec: Time series of system responses.
+    :param y_vec: Time series of the system responses.
     :type y_vec: ndarray
-    :param f_vec: Time series of applied forces.
+    :param f_vec: Time series of the applied forces.
     :type f_vec: ndarray
     :param H: Calculated IRF matrix.
     :type H: ndarray
-    :param t_vec_IRF: Time vector for calculated IRFs.
+    :param t_vec_IRF: Time vector for the calculated IRFs.
     :type t_vec_IRF: ndarray
 
     """
 
     # Declare parameters as attributes
     t_vec = np.empty(0)
-    y_vec = np.empty((0, 0, 0))
+    y_vec = np.empty((0, 0, 0, 0))
     f_vec = np.empty((0, 0, 0))
     H = np.empty((0, 0, 0))
     t_vec_IRF = np.empty(0)
 
-    def __init__(self, t_vec=np.empty((0)), y_vec=np.empty((0, 0, 0)), f_vec=np.empty((0, 0, 0))):
+    def __init__(self, y_vec=np.empty((0, 0, 0, 0)), f_vec=np.empty((0, 0, 0)), t_vec=np.empty((0))):
         # Initialize ExperimentalIRF class with provided data
         if t_vec.size != 0:
             self.t_vec = convert_to_1d_array(t_vec)
@@ -52,24 +53,6 @@ class ExperimentalIRF:
         if y_vec.size != 0 or f_vec.size != 0:
             self.add_time_series(y_vec, f_vec, t_vec=self.t_vec)
 
-    # Convert any array passed to ExperimentalIRF into a 3D array for concise internal storage.
-    def _convert_to_3d_array(self, array):
-        # Input convention:
-        # 3D: Multiple dofs, multiple measurements (dof,number_of_measurements,points)
-        # 2D: Single dof, multiple measurements (number_of_measurements,points)
-        # 1D: Single dof, one measurement (points)
-
-        if array.ndim == 1:
-            array = array[np.newaxis, np.newaxis, :]
-        elif array.ndim == 2:
-            array = array[np.newaxis, :, :]
-        elif array.ndim == 3:
-            pass
-        else:
-            raise ValueError(f"Expected 1D, 2D, or 3D array. Got {array.ndim}D.")
-
-        return array
-
     def __str__(self):
         # Prints a formatted object summary of the ExperimentalIRF object
         def print_array(arr):
@@ -100,9 +83,10 @@ class ExperimentalIRF:
 
         Shape of time series arrays
         ---------------------------
-        - 3D: Multiple dofs, multiple measurements (dof,number_of_measurements,points)
-        - 2D: Single dof, multiple measurements (number_of_measurements,points)
-        - 1D: Single dof, one measurement (points)
+        - SISO: ``y_vec`` with shape ``(n_t)``, ``f_vec`` with shape ``(n_t)``
+        - SISO with averaging: ``y_vec`` with shape ``(n_avg,n_t)``, ``f_vec`` with shape ``(n_avg,n_t)``
+        - MIMO: ``y_vec`` with shape ``(n_resp, n_exc, n_t)``, ``f_vec`` with shape ``(n_exc, n_t)``
+        - MIMO with averaging: ``y_vec`` with shape ``(n_resp, n_exc, n_avg, n_t)``, ``f_vec`` with shape ``(n_exc, n_avg, n_t)``
 
         Constraints
         -----------
@@ -114,17 +98,30 @@ class ExperimentalIRF:
         ----------
         :param t_vec: Time vector of time series ``y_vec`` and ``f_vec``.
         :type t_vec: ndarray
-        :param y_vec: Time series of system responses.
+        :param y_vec: Time series of the system responses.
         :type y_vec: ndarray
-        :param f_vec: Time series of applied forces.
+        :param f_vec: Time series of the applied forces.
         :type f_vec: ndarray, optional
 
         """
         # Shape input data
         if t_vec is not None:
             t_vec = convert_to_1d_array(t_vec)
-        y_vec = self._convert_to_3d_array(y_vec)
-        f_vec = self._convert_to_3d_array(f_vec)
+
+        # Detect input data mode
+        if y_vec.ndim == 1 and f_vec.ndim == 1:  # SISO
+            f_vec = f_vec[np.newaxis, np.newaxis, :]
+            y_vec = y_vec[np.newaxis, np.newaxis, np.newaxis, :]
+        elif y_vec.ndim == 2 and f_vec.ndim == 2:  # SISO with averaging
+            f_vec = f_vec[np.newaxis, :]
+            y_vec = y_vec[np.newaxis, np.newaxis, :, :]
+        elif y_vec.ndim == 3 and f_vec.ndim == 2:  # SISO with averaging
+            f_vec = f_vec[:, np.newaxis, :]
+            y_vec = y_vec[:, :, np.newaxis, :]
+        elif y_vec.ndim == 4 and f_vec.ndim == 3:  # SISO with averaging
+            pass
+        else:
+            raise Exception("Shape of provided time series for y_vec and f_vec does not match a supported format.")
 
         # Input check - Time Vector
         if self.t_vec.size != 0 and t_vec is not None:
@@ -135,15 +132,21 @@ class ExperimentalIRF:
                 raise Exception("No t_vec provided for data.")
             self.t_vec = t_vec
 
-        # Input check - Data
+        # Input Check - Number of time samples
         if y_vec.shape[-1] != len(self.t_vec):
             raise Exception("Provided y_vec does not match length of stored t_vec.")
         if f_vec.shape[-1] != len(self.t_vec):
             raise Exception("Provided f_vec does not match length of stored t_vec.")
 
+        # Input Check - Match of n_exc, and n_avg dimensions
+        if y_vec.shape[1] != f_vec.shape[0]:  # Mismatch of n_exc axis
+            raise Exception("Number of excitation dofs in y_vec and f_vec does not match.")
+        if y_vec.shape[2] != f_vec.shape[1]:  # Mismatch of n_avg axis
+            raise Exception("Number of averages in y_vec and f_vec does not match.")
+
         if self.y_vec.size != 0:  # Only y_vec or f_vec must be checked here, since they can only be initialized in pairs.
-            y_vec_new = np.append(self.y_vec, y_vec, axis=0)
-            f_vec_new = np.append(self.f_vec, f_vec, axis=0)
+            y_vec_new = np.append(self.y_vec, y_vec, axis=2)
+            f_vec_new = np.append(self.f_vec, f_vec, axis=1)
         else:
             y_vec_new = y_vec
             f_vec_new = f_vec
@@ -164,32 +167,34 @@ class ExperimentalIRF:
         :type trigger_level: float
 
         """
-        n_dof = self.y_vec.shape[0]
-        n_run = self.y_vec.shape[1]
-        t_trigg_idx = np.zeros(n_run, dtype=int)
+        n_resp_dof = self.y_vec.shape[0]  # Response dofs
+        n_exc_dof = self.y_vec.shape[1]  # Excitation dofs
+        n_avg = self.y_vec.shape[2]
+        t_trigg_idx = np.zeros((n_exc_dof, n_avg), dtype=int)
+        t_vec_len_old = len(self.t_vec)
 
         # Get trigger index for each provided force time series
-        for run in range(0, n_run):
-            while self.f_vec[0, run, t_trigg_idx[run]] < trigger_level:
-                t_trigg_idx[run] += 1
+        for exc_dof in range(0, n_exc_dof):
+            for run in range(0, n_avg):
+                t_trigg_idx[exc_dof, run] = get_trigger_index(self.f_vec[exc_dof, run], trigger_level)
 
         # Construct trimmed time vector
         self.t_vec = self.t_vec[np.max(t_trigg_idx) :] - self.t_vec[np.max(t_trigg_idx)]
-        new_len = len(self.t_vec)
+        t_vec_len_new = len(self.t_vec)
 
         # Trim force and response time series
-        y_vec_trimmed = np.zeros([n_dof, n_run, new_len])
-        f_vec_trimmed = np.zeros([1, n_run, new_len])
-
-        for run in range(0, n_run):
-            idx = t_trigg_idx[run]
-            f_vec_trimmed[0, run] = self.f_vec[0, run, idx : idx + new_len]
+        y_vec_trimmed = np.zeros([n_resp_dof, n_exc_dof, n_avg, t_vec_len_new])
+        f_vec_trimmed = np.zeros([n_exc_dof, n_avg, t_vec_len_new])
 
-            for dof in range(0, n_dof):
-                y_vec_trimmed[dof, run] = self.y_vec[dof, run, idx : idx + new_len]
+        for exc_dof in range(0, n_exc_dof):
+            for run in range(0, n_avg):
+                idx = t_trigg_idx[exc_dof, run]
+                f_vec_trimmed[exc_dof, run] = self.f_vec[exc_dof, run, idx : idx + t_vec_len_new]
+                y_vec_trimmed[:, exc_dof, run] = self.y_vec[:, exc_dof, run, idx : idx + t_vec_len_new]
 
         self.y_vec = y_vec_trimmed
         self.f_vec = f_vec_trimmed
+        print(f"[OpenIRF]: Time data retriggered. Length of t_vec {t_vec_len_old} -> {t_vec_len_new}.")
 
     def calculate_IRF(self, t_len, extract_impulse=True, resp_dofs=None, exci_dofs=None, deconvolve_type="truncated_convolution", averaged_runs="all"):
         """
@@ -224,53 +229,62 @@ class ExperimentalIRF:
 
         """
 
+        n_resp_dof = self.y_vec.shape[0]  # Response dofs
+        n_exc_dof = self.y_vec.shape[1]  # Excitation dofs
+
         # Selection of runs to average
         if np.all(averaged_runs == "all"):
             f_vec = self.f_vec
             y_vec = self.y_vec
         else:
             f_vec = self.f_vec[:, averaged_runs]
-            y_vec = self.y_vec[:, averaged_runs]
+            y_vec = self.y_vec[:, :, averaged_runs]
+
+        n_avg = y_vec.shape[2]  # Number of averages considering the user selection
 
+        # Determin index for requested IRF length
         h_len = np.argmin(np.abs(self.t_vec - t_len))
 
-        y_vec_trimmed = y_vec[:, :, 0:h_len]
+        # Trim responses to requested length
+        y_vec_trimmed = y_vec[:, :, :, 0:h_len]
 
-        F_exp_list = []
+        # Preallocate final IRF matrix
+        H = np.zeros([n_resp_dof, n_exc_dof, h_len])
 
-        # Build force convolution matrices
-        for idx in tqdm(range(0, f_vec.shape[1]), desc="[OpenIRF]: Building Force Convolution Matrices"):
-            if extract_impulse:
-                f_vec_trimmed = extract_impulse_time_series(f_vec[:, idx], self.t_vec)
-            else:
-                f_vec_trimmed = f_vec[:, idx]
+        for exc_dof in range(0, n_exc_dof):  # Loop over the different force excitation dofs
+            F_exp_list = []
 
-            # Trim to requested IRF length
-            f_vec_trimmed = f_vec_trimmed[0:h_len]
+            # Build force convolution matrices
+            for run in tqdm(range(0, n_avg), desc=f"[OpenIRF]: Building Force Convolution Matrices for excitation dof ({exc_dof + 1}/{n_exc_dof})"):
+                if extract_impulse:
+                    f_vec_trimmed = extract_impulse_time_series(f_vec[exc_dof, run], self.t_vec)
+                else:
+                    f_vec_trimmed = f_vec[exc_dof, run]
 
-            # Build force convolution matrix
-            F_exp_run = build_convolution_matrix(f_vec_trimmed)
+                # Trim to requested IRF length
+                f_vec_trimmed = f_vec_trimmed[0:h_len]
 
-            F_exp_list.append(F_exp_run)
+                # Build force convolution matrix
+                F_exp_run = build_convolution_matrix(f_vec_trimmed)
 
-        # Build and invert auto-correlation matrix
-        F_exp = np.vstack(F_exp_list)
-        R = F_exp.transpose() @ F_exp
-        R_inv = np.linalg.inv(R)
+                F_exp_list.append(F_exp_run)
 
-        # Build pseudo-inverse
-        F_plus = R_inv @ F_exp.transpose()
+            # Build and invert auto-correlation matrix
+            F_exp = np.vstack(F_exp_list)
+            R = F_exp.transpose() @ F_exp
+            R_inv = np.linalg.inv(R)
 
-        # Cleanup temporary variables
-        del F_exp_run, F_exp_list, R, R_inv, F_exp
+            # Build pseudo-inverse
+            F_plus = R_inv @ F_exp.transpose()
 
-        H = np.zeros([y_vec_trimmed.shape[0], f_vec.shape[0], h_len])
+            # Cleanup temporary variables
+            del F_exp_run, F_exp_list, R, R_inv, F_exp
 
-        # Build stacked response vector and calculate IRF
-        for dof in tqdm(range(0, y_vec_trimmed.shape[0]), desc="[OpenIRF]: Calculating IRFs"):
-            y_stacked = y_vec_trimmed[dof].reshape(-1)
-            H[dof, 0] = F_plus @ y_stacked / self.t_vec[1]
+            # Build stacked response vector and calculate IRF
+            for resp_dof in tqdm(range(0, n_resp_dof), desc=f"[OpenIRF]: Calculating Experimental IRFs for excitation dof ({exc_dof + 1}/{n_exc_dof})"):
+                y_stacked = y_vec_trimmed[resp_dof, exc_dof].reshape(-1)
+                H[resp_dof, exc_dof] = F_plus @ y_stacked / self.t_vec[1]
 
-        # Assign H to class instance
+        # Assign IRF matrix to class instance
         self.H = H
         self.t_vec_IRF = self.t_vec[:h_len]

{openirf-0.2.0 → openirf-0.3.0}/src/openirf/numerical_irf.py

@@ -55,7 +55,7 @@ class NumericalIRF:
     def __init__(self, M=np.empty((0, 0)), C=np.empty((0, 0)), K=np.empty((0, 0))):
         # Initialize NumericalIRF class with provided data
         if M.size == 0 and K.size != 0:
-            raise Exception("No mass matrix M was provided.")  # noqa: TRY002
+            raise Exception("No mass matrix M was provided.")
         elif K.size == 0 and M.size != 0:
             raise Exception("No stiffness matrix K was provided.")
         elif M.size == 0 and K.size == 0 and C.size != 0: