From 366f072d451eb94a4d3ea63c2ec17326b6a13adb Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Wed, 29 Mar 2023 15:54:14 +0200
Subject: [PATCH 01/31] Feature: multires discovery added

---
 pydmd/multires_discovery.py | 412 ++++++++++++++++++++++++++++++++++++
 1 file changed, 412 insertions(+)
 create mode 100644 pydmd/multires_discovery.py

diff --git a/pydmd/multires_discovery.py b/pydmd/multires_discovery.py
new file mode 100644
index 000000000..5826941f7
--- /dev/null
+++ b/pydmd/multires_discovery.py
@@ -0,0 +1,412 @@
+import numpy as np
+from pydmd.bopdmd import BOPDMD
+import scipy
+from sklearn.cluster import KMeans
+import matplotlib.pyplot as plt
+
+
+class multi_res_discovery:
+    def __init__(
+            self,
+            window_length,
+            n_components,
+            step_size,
+            svd_rank=None,
+            global_svd=True,
+            initialize_artificially=False,
+            use_last_freq=False,
+            use_kmean_freqs=False,
+            init_alpha=None,
+            pydmd_kwargs=None,
+            threshhold_percent=1,
+            cluster_centroids=None,
+    ):
+        self._n_components = n_components
+        self._step_size = step_size
+        self._svd_rank = svd_rank
+        self._window_length = window_length
+        self._global_svd = global_svd
+        self._initialize_artificially = initialize_artificially
+        self._use_last_freq = use_last_freq
+        self._use_kmean_freqs = use_kmean_freqs
+        self._init_alpha = init_alpha
+        self._cluster_centroids = cluster_centroids
+        if pydmd_kwargs is None:
+            self._pydmd_kwargs = {
+                'eig_sort': 'imag',
+            }
+        else:
+            self._pydmd_kwargs = pydmd_kwargs
+
+        # Set the threshold for the number of frequencies to use in clustering,
+        # where the frequencies have been sorted in order of magnitude.
+        # Note: this value is not currently implemented (it was always 1 in examples).
+        self._threshhold_percent = threshhold_percent
+
+    def _compute_svd_rank(self, data, svd_rank=None):
+        # rank to fit w/ optdmd
+        _, n_data_vars = self._data_shape(data)
+
+        if svd_rank is None:
+            svd_rank = n_data_vars
+        elif svd_rank > n_data_vars:
+            raise ValueError('svd_rank is greater than the number of spatial dimensions.')
+        return svd_rank
+
+    def _build_proj_basis(self, data, global_svd=True, svd_rank=None):
+
+        if svd_rank is None:
+            self._svd_rank = self._compute_svd_rank(data, svd_rank=svd_rank)
+
+        # Use global SVD modes for each DMD rather than individual SVD on
+        # each window.
+        if global_svd:
+            # Recover the first r modes of the global svd
+            u, _, _ = scipy.linalg.svd(data, full_matrices=False)
+            return u[:, :self._svd_rank]
+
+    def _build_initizialization(self):
+        """ Method for making initial guess of DMD eigenvalues.
+        """
+
+        # User provided initial eigenvalues.
+        init_alpha = None
+        if self._initialize_artificially and self._init_alpha is not None:
+            init_alpha = self._init_alpha
+        # Initial eigenvalue guesses from kmeans clustering.
+        elif self._initialize_artificially and self._init_alpha is None:
+            if self._use_kmean_freqs:
+                init_alpha = np.repeat(np.sqrt(self._cluster_centroids) * 1j,
+                                       int(self._svd_rank / self._n_components))
+                init_alpha = init_alpha * np.tile([1, -1],
+                                                  int(self._svd_rank / self._n_components))
+
+        return init_alpha
+
+    def build_windows(self, data, integer_windows=False):
+        """Calculate how many times to slide the window across the data.
+
+        """
+
+        if integer_windows:
+            n_split = np.floor(data.shape[1] / self._window_length).astype(int)
+        else:
+            n_split = data.shape[1] / self._window_length
+
+        n_steps = int((self._window_length * n_split))
+
+        # Number of sliding-window iterations
+        n_slides = np.floor((n_steps - self._window_length) / self._step_size).astype(int)
+
+        return n_slides
+
+    def calculate_lv_kern(self, window_length, corner_sharpness=None):
+        """Calculate the kerning window for suppressing real eigenvalues.
+
+        """
+
+        # Higher = sharper corners
+        if corner_sharpness is None:
+            corner_sharpness = 16
+
+        lv_kern = (
+                np.tanh(
+                    corner_sharpness * np.arange(1, window_length + 1) / window_length
+                )
+                - np.tanh(
+            corner_sharpness * (
+                    np.arange(1, window_length + 1) - window_length) / window_length) - 1
+        )
+
+        return lv_kern
+
+    def _data_shape(self, data):
+        n_time_steps = np.shape(data)[1]
+        n_data_vars = np.shape(data)[0]
+        return n_time_steps, n_data_vars
+
+    @property
+    def svd_rank(self):
+        """
+        :return: the rank used for the svd truncation.
+        :rtype: int or float
+        """
+        return self._svd_rank
+
+    @property
+    def modes_array(self):
+        if not hasattr(self, "_modes_array"):
+            raise ValueError("You need to call fit before")
+        return self._modes_array
+
+    @property
+    def amplitudes_array(self):
+        if not hasattr(self, "_amplitudes_array"):
+            raise ValueError("You need to call fit before")
+        return self._amplitudes_array
+
+    @property
+    def omega_array(self):
+        if not hasattr(self, "_omega_array"):
+            raise ValueError("You need to call fit before")
+        return self._omega_array
+
+    @property
+    def omega_array(self):
+        if not hasattr(self, "_omega_array"):
+            raise ValueError("You need to call fit before")
+        return self._omega_array
+
+    @property
+    def time_array(self):
+        if not hasattr(self, "_time_array"):
+            raise ValueError("You need to call fit before")
+        return self._time_array
+
+    @property
+    def window_means_array(self):
+        if not hasattr(self, "_window_means_array"):
+            raise ValueError("You need to call fit before")
+        return self._window_means_array
+
+    @property
+    def t_starts_array(self):
+        if not hasattr(self, "_t_starts_array"):
+            raise ValueError("You need to call fit before")
+        return self._t_starts_array
+
+    @property
+    def time_means_array(self):
+        if not hasattr(self, "_time_means_array"):
+            raise ValueError("You need to call fit before")
+        return self._time_means_array
+
+    def fit(self, data, time, verbose=False, corner_sharpness=None):
+        self._n_time_steps, self._n_data_vars = self._data_shape(data)
+        self._n_slides = self.build_windows(data)
+        self._svd_rank = self._compute_svd_rank(data, svd_rank=self._svd_rank)
+
+        # Check dimensionality/shape of all
+        # Each element calculate for a window is returned to the user in these array.
+        data_array = np.zeros((self._n_slides, self._n_data_vars, self._window_length))
+        self._time_array = np.zeros((self._n_slides, self._window_length))
+        self._modes_array = np.zeros((self._n_slides, self._n_data_vars, self._svd_rank),
+                                     np.complex128)
+        self._omega_array = np.zeros((self._n_slides, self._svd_rank), np.complex128)
+        self._amplitudes_array = np.zeros((self._n_slides, self._svd_rank), np.complex128)
+        self._window_means_array = np.zeros((self._n_slides, self._n_data_vars))
+        self._t_starts_array = np.zeros((self._n_slides))
+        self._time_means_array = np.zeros((self._n_slides))
+
+        # Round the corners of the window to shrink real components.
+        lv_kern = self.calculate_lv_kern(self._window_length,
+                                         corner_sharpness=corner_sharpness)
+
+        # Build the projection basis if using a global svd. If not provided local u is used instead.
+        if self._global_svd:
+            u = self._build_proj_basis(data, global_svd=self._global_svd,
+                                       svd_rank=self._svd_rank)
+            self._pydmd_kwargs['proj_basis'] = u
+            self._pydmd_kwargs['use_proj'] = False
+
+        # Initialize the DMD class.
+        if self._initialize_artificially:
+            self._init_alpha = self._build_initizialization()
+            optdmd = BOPDMD(
+                svd_rank=self._svd_rank, num_trials=0, init_alpha=self._init_alpha,
+                **self._pydmd_kwargs
+            )
+        else:
+            optdmd = BOPDMD(
+                svd_rank=self._svd_rank, num_trials=0, **self._pydmd_kwargs,
+            )
+
+        for k in range(self._n_slides):
+            if verbose:
+                if k // 50 == k / 50:
+                    print('{} of {}'.format(k, self._n_slides))
+
+            sample_start = self._step_size * k
+            sample_steps = np.arange(sample_start, sample_start + self._window_length)
+
+            data_window = data[:, sample_steps]
+            time_window = time[:, sample_steps]
+            data_array[k, :, :] = data_window
+            self._time_array[k, :] = time_window
+            self._time_means_array[k] = np.mean(time_window)
+
+            t_start = time_window[:, 0]
+            time_window = time_window - t_start
+            self._t_starts_array[k] = t_start
+
+            # Subtract off mean before rounding corners
+            # https://stackoverflow.com/questions/32030343/
+            # subtracting-the-mean-of-each-row-in-numpy-with-broadcasting
+            c = np.mean(data_window, 1, keepdims=True)
+            data_window = data_window - c
+
+            # Round corners of the window
+            data_window = data_window * lv_kern
+
+            # Fit with the desired DMD class
+            optdmd.fit(data_window, time_window)
+
+            # if use_last_freq == 1:
+            #     e_init = e
+
+            # Assign the results from this window
+            self._modes_array[k, ::] = optdmd.modes
+            self._omega_array[k, :] = optdmd.eigs
+            self._amplitudes_array[k, :] = optdmd.amplitudes
+            self._window_means_array[k, :] = c.flatten()
+
+    def cluster_omega(self, omega_array, kmeans_kwargs=None):
+        omega_rshp = omega_array.reshape(self._n_slides * self._svd_rank)
+        omega_squared = (np.conj(omega_rshp) * omega_rshp).astype('float')
+
+        if kmeans_kwargs is None:
+            random_state = 0
+            kmeans_kwargs = {
+                "n_init": "auto",
+                "random_state": random_state,
+            }
+        kmeans = KMeans(n_clusters=self._n_components, **kmeans_kwargs)
+        y_pred = kmeans.fit_predict(np.atleast_2d(omega_squared).T)
+        omega_classes = y_pred.reshape(self._n_slides, self._svd_rank)
+        cluster_centroids = kmeans.cluster_centers_.flatten()
+
+        return omega_classes, omega_squared, cluster_centroids
+
+    def plot_omega_squared_histogram(self, omega_squared, cluster_centroids):
+        fig, ax = plt.subplots(1, 1)
+        ax.hist(omega_squared, bins=64)
+        ax.set_xlabel('$|\omega|^{2}$')
+        ax.set_ylabel('Count')
+        ax.set_title('$|\omega|^2$ Spectrum & k-Means Centroids')
+        [ax.axvline(c, color='r') for c in cluster_centroids]
+
+        return fig, ax
+
+    def plot_omega_squared_time_series(self, omega_squared, omega_classes):
+        fig, ax = plt.subplots(1, 1)
+        colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]
+        for ncomponent, component in enumerate(range(self._n_components)):
+            ax.plot(
+                self._time_means_array,
+                np.where(
+                    omega_classes == component,
+                    omega_squared.reshape((self._n_slides, self._svd_rank)), np.nan
+                ),
+                color=colors[ncomponent]
+            )
+        ax.set_ylabel('$|\omega|^{2}$')
+        ax.set_xlabel('Time')
+        ax.set_title('$|\omega|^2$ Spectrum (Moving Window)')
+
+        return fig, ax
+
+    def global_reconstruction(self, ):
+        # Container for the reconstructed time series
+        glbl_reconstruction = np.zeros(
+            (self._svd_rank, self._n_time_steps)).astype('complex128')
+
+        # Count the number of windows contributing to each step
+        xn = np.zeros(self._n_time_steps)
+
+        for k in range(self._n_slides):
+            # Extract out the DMD fit for this window.
+            w = self._modes_array[k]
+            b = self._amplitudes_array[k]
+            omega = np.atleast_2d(self._omega_array[k]).T
+            c = np.atleast_2d(self._window_means_array[k]).T
+
+            # Compute each segment starting at t=0
+            t = self._time_array[k]
+            t_start = self._t_starts_array[k]
+            t = t - t_start
+
+            # Perform the global reconstruction.
+            recon_window = np.linalg.multi_dot([w, np.diag(b), np.exp(omega * t)]) + c
+
+            window_indices = slice(k * self._step_size,
+                                   k * self._step_size + self._window_length)
+            glbl_reconstruction[:, window_indices] += recon_window
+            xn[window_indices] += 1
+
+        # Weight xr so all steps are on equal footing
+        glbl_reconstruction = glbl_reconstruction / xn
+
+        return glbl_reconstruction
+
+    def scale_reconstruction(self, omega_classes, cluster_centroids, suppress_growth=True,
+                             include_means=True):
+        """Reconstruct the sliding mrDMD into the constituent components.
+
+        The reconstructed data are convolved with a guassian filter since
+        points near the middle of the window are more reliable than points
+        at the edge of the window. Note that this will leave the beginning
+        and end of time series prone to larger errors. A best practice is
+        to cut off `window_length` from each end before further analysis.
+
+
+        suppress_growth:
+        Kill positive real components of frequencies
+        """
+
+        # Each individual reconstructed window
+        xr_sep = np.zeros((self._n_components, self._svd_rank, self._n_time_steps))
+
+        # Track the total contribution from all windows to each time step
+        xn = np.zeros(self._n_time_steps)
+
+        # Convolve each windowed reconstruction with a gaussian filter.
+        # Std dev of gaussian filter
+        recon_filter_sd = self._window_length / 8
+        recon_filter = np.exp(
+            -(
+                     np.arange(self._window_length)
+                     - (self._window_length + 1) / 2
+             ) ** 2 / recon_filter_sd ** 2)
+
+        for k in range(self._n_slides):
+            w = self._modes_array[k]
+            b = self._amplitudes_array[k]
+            omega = np.atleast_2d(self._omega_array[k]).T
+            classification = omega_classes[k]
+
+            if suppress_growth:
+                omega[omega.real > 0] = 1j * omega[omega.real > 0].imag
+
+            c = np.atleast_2d(self._window_means_array[k]).T
+
+            # Compute each segment of xr starting at "t = 0"
+            t = self._time_array[k]
+            t_start = self._t_starts_array[k]
+            t = t - t_start
+
+            xr_sep_window = np.zeros(
+                (self._n_components, self._svd_rank, self._window_length))
+            for j in np.unique(omega_classes):
+                xr_sep_window[j, :, :] = np.linalg.multi_dot(
+                    [
+                        w[:, classification == j],
+                        np.diag(b[classification == j]),
+                        np.exp(omega[classification == j] * t)
+                    ]
+                )
+
+                # Add the constant offset to the lowest frequency cluster.
+                if include_means and (j == np.argmin(cluster_centroids)):
+                    xr_sep_window[j, :, :] += c
+                xr_sep_window[j, :, :] = xr_sep_window[j, :, :] * recon_filter
+                window_indices = slice(k * self._step_size,
+                                       k * self._step_size + self._window_length)
+                xr_sep[j, :, window_indices] = xr_sep[j, :,
+                                               window_indices] + xr_sep_window[j, :, :]
+
+            xn[window_indices] += recon_filter
+
+        xr_sep = xr_sep / xn
+
+        return xr_sep
+

From 66663a725d73eca216445c8009d3bdc6b35a7e8f Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Fri, 31 Mar 2023 11:55:35 +0200
Subject: [PATCH 02/31] Bug fix: Bad int type check in compute_svd

---
 pydmd/rdmd.py  | 2 +-
 pydmd/utils.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pydmd/rdmd.py b/pydmd/rdmd.py
index 8bc1431a0..9b9314114 100644
--- a/pydmd/rdmd.py
+++ b/pydmd/rdmd.py
@@ -42,7 +42,7 @@ def omega(x):
     elif 0 < svd_rank < 1:
         cumulative_energy = np.cumsum(s**2 / (s**2).sum())
         rank = np.searchsorted(cumulative_energy, svd_rank) + 1
-    elif svd_rank >= 1 and isinstance(svd_rank, int):
+    elif svd_rank >= 1 and isinstance(svd_rank, (int, np.integer)):
         rank = min(svd_rank, U.shape[1])
     else:
         rank = min(X.shape)
diff --git a/pydmd/utils.py b/pydmd/utils.py
index cb9ff8483..3b6454ee2 100644
--- a/pydmd/utils.py
+++ b/pydmd/utils.py
@@ -73,7 +73,7 @@ def omega(x):
     elif 0 < svd_rank < 1:
         cumulative_energy = np.cumsum(s**2 / (s**2).sum())
         rank = np.searchsorted(cumulative_energy, svd_rank) + 1
-    elif svd_rank >= 1 and isinstance(svd_rank, int):
+    elif svd_rank >= 1 and isinstance(svd_rank, (int, np.integer)):
         rank = min(svd_rank, U.shape[1])
     else:
         rank = X.shape[1]

From a14dcf6327873710a75a29db9cb9bf5cbf23ccf1 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 4 Apr 2023 15:31:10 +0200
Subject: [PATCH 03/31] General cleanup and bug fixes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Made several init arguments keyword arguments to better reflect algorithm logic
- Made several arguments belong to the fit command instead of the class init
to better reflect how the fit command should be used (namely window size and step size).
- Some pep8’ing
- n_components is now a required argument for the clustering operation
- Plotting now uses a circular color scheme for many clusters
- Updating the allocation to better reflect not knowing the optimal `svd_rank` a priori.
---
 pydmd/multires_discovery.py | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/pydmd/multires_discovery.py b/pydmd/multires_discovery.py
index 5826941f7..086108558 100644
--- a/pydmd/multires_discovery.py
+++ b/pydmd/multires_discovery.py
@@ -8,9 +8,9 @@
 class multi_res_discovery:
     def __init__(
             self,
-            window_length,
-            n_components,
-            step_size,
+            window_length=None,
+            step_size=None,
+            n_components=None,
             svd_rank=None,
             global_svd=True,
             initialize_artificially=False,
@@ -181,7 +181,11 @@ def time_means_array(self):
             raise ValueError("You need to call fit before")
         return self._time_means_array
 
-    def fit(self, data, time, verbose=False, corner_sharpness=None):
+    def fit(self, data, time, window_length, step_size, verbose=False,
+            corner_sharpness=None):
+        self._window_length = window_length
+        self._step_size = step_size
+
         self._n_time_steps, self._n_data_vars = self._data_shape(data)
         self._n_slides = self.build_windows(data)
         self._svd_rank = self._compute_svd_rank(data, svd_rank=self._svd_rank)
@@ -195,8 +199,8 @@ def fit(self, data, time, verbose=False, corner_sharpness=None):
         self._omega_array = np.zeros((self._n_slides, self._svd_rank), np.complex128)
         self._amplitudes_array = np.zeros((self._n_slides, self._svd_rank), np.complex128)
         self._window_means_array = np.zeros((self._n_slides, self._n_data_vars))
-        self._t_starts_array = np.zeros((self._n_slides))
-        self._time_means_array = np.zeros((self._n_slides))
+        self._t_starts_array = np.zeros(self._n_slides)
+        self._time_means_array = np.zeros(self._n_slides)
 
         # Round the corners of the window to shrink real components.
         lv_kern = self.calculate_lv_kern(self._window_length,
@@ -260,7 +264,8 @@ def fit(self, data, time, verbose=False, corner_sharpness=None):
             self._amplitudes_array[k, :] = optdmd.amplitudes
             self._window_means_array[k, :] = c.flatten()
 
-    def cluster_omega(self, omega_array, kmeans_kwargs=None):
+    def cluster_omega(self, omega_array, n_components, kmeans_kwargs=None):
+        self._n_components = n_components
         omega_rshp = omega_array.reshape(self._n_slides * self._svd_rank)
         omega_squared = (np.conj(omega_rshp) * omega_rshp).astype('float')
 
@@ -297,7 +302,7 @@ def plot_omega_squared_time_series(self, omega_squared, omega_classes):
                     omega_classes == component,
                     omega_squared.reshape((self._n_slides, self._svd_rank)), np.nan
                 ),
-                color=colors[ncomponent]
+                color=colors[ncomponent % len(colors)]
             )
         ax.set_ylabel('$|\omega|^{2}$')
         ax.set_xlabel('Time')
@@ -308,7 +313,7 @@ def plot_omega_squared_time_series(self, omega_squared, omega_classes):
     def global_reconstruction(self, ):
         # Container for the reconstructed time series
         glbl_reconstruction = np.zeros(
-            (self._svd_rank, self._n_time_steps)).astype('complex128')
+            (self._n_data_vars, self._n_time_steps)).astype('complex128')
 
         # Count the number of windows contributing to each step
         xn = np.zeros(self._n_time_steps)
@@ -354,7 +359,7 @@ def scale_reconstruction(self, omega_classes, cluster_centroids, suppress_growth
         """
 
         # Each individual reconstructed window
-        xr_sep = np.zeros((self._n_components, self._svd_rank, self._n_time_steps))
+        xr_sep = np.zeros((self._n_components, self._n_data_vars, self._n_time_steps))
 
         # Track the total contribution from all windows to each time step
         xn = np.zeros(self._n_time_steps)
@@ -385,7 +390,7 @@ def scale_reconstruction(self, omega_classes, cluster_centroids, suppress_growth
             t = t - t_start
 
             xr_sep_window = np.zeros(
-                (self._n_components, self._svd_rank, self._window_length))
+                (self._n_components, self._n_data_vars, self._window_length))
             for j in np.unique(omega_classes):
                 xr_sep_window[j, :, :] = np.linalg.multi_dot(
                     [

From 13a9081bf311ce120077fc8b5c9fe05dd8d8b36f Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Wed, 5 Apr 2023 16:48:17 +0200
Subject: [PATCH 04/31] Further clean up and bug fixing:

- Appropriated the svd_rank computation to handle the case with
no global svd and unknown svd_rank to return the number of data variables
for use in allocating the window arrays.
- build_windows now requires positional arguments intsead of accessing
class variables
- Add logic in `fit` for the case when no global svd nor svd_rank is used
and the svd_rank may change between windows.
- n_components is specified in the clustering function instead of
class creation.
---
 pydmd/multires_discovery.py | 106 ++++++++++++++++++++++++------------
 1 file changed, 70 insertions(+), 36 deletions(-)

diff --git a/pydmd/multires_discovery.py b/pydmd/multires_discovery.py
index 086108558..3bdc13856 100644
--- a/pydmd/multires_discovery.py
+++ b/pydmd/multires_discovery.py
@@ -20,23 +20,27 @@ def __init__(
             pydmd_kwargs=None,
             threshhold_percent=1,
             cluster_centroids=None,
+            reset_alpha_init=False,
     ):
         self._n_components = n_components
         self._step_size = step_size
-        self._svd_rank = svd_rank
         self._window_length = window_length
+        self._svd_rank = svd_rank
         self._global_svd = global_svd
         self._initialize_artificially = initialize_artificially
         self._use_last_freq = use_last_freq
         self._use_kmean_freqs = use_kmean_freqs
         self._init_alpha = init_alpha
         self._cluster_centroids = cluster_centroids
+        self._reset_alpha_init = reset_alpha_init
+
         if pydmd_kwargs is None:
             self._pydmd_kwargs = {
                 'eig_sort': 'imag',
             }
         else:
             self._pydmd_kwargs = pydmd_kwargs
+            self._pydmd_kwargs['eig_sort'] = pydmd_kwargs.get('eig_sort', 'imag')
 
         # Set the threshold for the number of frequencies to use in clustering,
         # where the frequencies have been sorted in order of magnitude.
@@ -44,13 +48,24 @@ def __init__(
         self._threshhold_percent = threshhold_percent
 
     def _compute_svd_rank(self, data, svd_rank=None):
-        # rank to fit w/ optdmd
-        _, n_data_vars = self._data_shape(data)
 
-        if svd_rank is None:
-            svd_rank = n_data_vars
-        elif svd_rank > n_data_vars:
-            raise ValueError('svd_rank is greater than the number of spatial dimensions.')
+        def omega(x):
+            return 0.56 * x ** 3 - 0.95 * x ** 2 + 1.82 * x + 1.43
+
+        U, s, _ = np.linalg.svd(data, full_matrices=False)
+
+        if svd_rank == 0:
+            beta = np.divide(*sorted(data.shape))
+            tau = np.median(s) * omega(beta)
+            svd_rank = np.sum(s > tau)
+        elif 0 < svd_rank < 1:
+            cumulative_energy = np.cumsum(s ** 2 / (s ** 2).sum())
+            svd_rank = np.searchsorted(cumulative_energy, svd_rank) + 1
+        elif svd_rank >= 1 and isinstance(svd_rank, (int, np.integer)):
+            svd_rank = min(svd_rank, self._n_data_vars)
+        else:
+            svd_rank = self._n_data_vars
+
         return svd_rank
 
     def _build_proj_basis(self, data, global_svd=True, svd_rank=None):
@@ -83,20 +98,20 @@ def _build_initizialization(self):
 
         return init_alpha
 
-    def build_windows(self, data, integer_windows=False):
+    def build_windows(self, data, window_length, step_size, integer_windows=False):
         """Calculate how many times to slide the window across the data.
 
         """
 
         if integer_windows:
-            n_split = np.floor(data.shape[1] / self._window_length).astype(int)
+            n_split = np.floor(data.shape[1] / window_length).astype(int)
         else:
-            n_split = data.shape[1] / self._window_length
+            n_split = data.shape[1] / window_length
 
-        n_steps = int((self._window_length * n_split))
+        n_steps = int((window_length * n_split))
 
         # Number of sliding-window iterations
-        n_slides = np.floor((n_steps - self._window_length) / self._step_size).astype(int)
+        n_slides = np.floor((n_steps - window_length) / step_size).astype(int)
 
         return n_slides
 
@@ -183,36 +198,45 @@ def time_means_array(self):
 
     def fit(self, data, time, window_length, step_size, verbose=False,
             corner_sharpness=None):
+
+        # Prepare window and data properties.
         self._window_length = window_length
         self._step_size = step_size
 
         self._n_time_steps, self._n_data_vars = self._data_shape(data)
-        self._n_slides = self.build_windows(data)
-        self._svd_rank = self._compute_svd_rank(data, svd_rank=self._svd_rank)
+        self._n_slides = self.build_windows(data, self._window_length, self._step_size)
+
+        # Build the projection basis if using a global svd.
+        if self._global_svd:
+            u = self._build_proj_basis(data, global_svd=self._global_svd,
+                                       svd_rank=self._svd_rank)
+            self._pydmd_kwargs['proj_basis'] = self._pydmd_kwargs.get('proj_basis', u)
+            self._pydmd_kwargs['use_proj'] = self._pydmd_kwargs.get('use_proj', False)
+
+            self._svd_rank = self._compute_svd_rank(data, svd_rank=self._svd_rank)
+            svd_rank_pre_allocate = self._svd_rank
+        # If not using a global svd, local u  from each window is used instead.
+        else:
+            # The various arrays the optimal svd_rank may change when using the locally
+            # optimal svd_rank. To deal with this situation, we give the maximally
+            # allowed svd_rank for pre-allocation.
+            svd_rank_pre_allocate = self._n_data_vars
 
-        # Check dimensionality/shape of all
-        # Each element calculate for a window is returned to the user in these array.
+        # Pre-allocate all elements for the sliding window DMD.
+        # Each element calculated for a window is returned through these array.
         data_array = np.zeros((self._n_slides, self._n_data_vars, self._window_length))
         self._time_array = np.zeros((self._n_slides, self._window_length))
-        self._modes_array = np.zeros((self._n_slides, self._n_data_vars, self._svd_rank),
+        self._modes_array = np.zeros(
+            (self._n_slides, self._n_data_vars, svd_rank_pre_allocate),
+            np.complex128)
+        self._omega_array = np.zeros((self._n_slides, svd_rank_pre_allocate),
                                      np.complex128)
-        self._omega_array = np.zeros((self._n_slides, self._svd_rank), np.complex128)
-        self._amplitudes_array = np.zeros((self._n_slides, self._svd_rank), np.complex128)
+        self._amplitudes_array = np.zeros((self._n_slides, svd_rank_pre_allocate),
+                                          np.complex128)
         self._window_means_array = np.zeros((self._n_slides, self._n_data_vars))
         self._t_starts_array = np.zeros(self._n_slides)
         self._time_means_array = np.zeros(self._n_slides)
 
-        # Round the corners of the window to shrink real components.
-        lv_kern = self.calculate_lv_kern(self._window_length,
-                                         corner_sharpness=corner_sharpness)
-
-        # Build the projection basis if using a global svd. If not provided local u is used instead.
-        if self._global_svd:
-            u = self._build_proj_basis(data, global_svd=self._global_svd,
-                                       svd_rank=self._svd_rank)
-            self._pydmd_kwargs['proj_basis'] = u
-            self._pydmd_kwargs['use_proj'] = False
-
         # Initialize the DMD class.
         if self._initialize_artificially:
             self._init_alpha = self._build_initizialization()
@@ -225,20 +249,26 @@ def fit(self, data, time, window_length, step_size, verbose=False,
                 svd_rank=self._svd_rank, num_trials=0, **self._pydmd_kwargs,
             )
 
+        # Round the corners of the window to shrink real components.
+        lv_kern = self.calculate_lv_kern(self._window_length,
+                                         corner_sharpness=corner_sharpness)
+
+        # Perform the sliding window DMD fitting.
         for k in range(self._n_slides):
             if verbose:
                 if k // 50 == k / 50:
                     print('{} of {}'.format(k, self._n_slides))
 
+            # Get the window indices and data.
             sample_start = self._step_size * k
             sample_steps = np.arange(sample_start, sample_start + self._window_length)
-
             data_window = data[:, sample_steps]
             time_window = time[:, sample_steps]
             data_array[k, :, :] = data_window
             self._time_array[k, :] = time_window
             self._time_means_array[k] = np.mean(time_window)
 
+            # All windows are fit with the time array reset to start at t=0.
             t_start = time_window[:, 0]
             time_window = time_window - t_start
             self._t_starts_array[k] = t_start
@@ -259,11 +289,16 @@ def fit(self, data, time, window_length, step_size, verbose=False,
             #     e_init = e
 
             # Assign the results from this window
-            self._modes_array[k, ::] = optdmd.modes
-            self._omega_array[k, :] = optdmd.eigs
-            self._amplitudes_array[k, :] = optdmd.amplitudes
+            self._modes_array[k, :, :optdmd.modes.shape[-1]] = optdmd.modes
+            self._omega_array[k, :optdmd.eigs.shape[0]] = optdmd.eigs
+            self._amplitudes_array[k, :optdmd.eigs.shape[0]] = optdmd.amplitudes
             self._window_means_array[k, :] = c.flatten()
 
+            # Reset optdmd between iterations
+            optdmd._svd_rank = self._svd_rank
+            optdmd._proj_basis = self._pydmd_kwargs['proj_basis']
+            optdmd._init_alpha = self._init_alpha
+
     def cluster_omega(self, omega_array, n_components, kmeans_kwargs=None):
         self._n_components = n_components
         omega_rshp = omega_array.reshape(self._n_slides * self._svd_rank)
@@ -413,5 +448,4 @@ def scale_reconstruction(self, omega_classes, cluster_centroids, suppress_growth
 
         xr_sep = xr_sep / xn
 
-        return xr_sep
-
+        return xr_sep
\ No newline at end of file

From ed7f20852ce06b8c4ad8b7510255fad206b2d73f Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Fri, 7 Apr 2023 17:23:11 +0200
Subject: [PATCH 05/31] Fix: Do not reset optdmd state with global_svd=True

---
 pydmd/multires_discovery.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/pydmd/multires_discovery.py b/pydmd/multires_discovery.py
index 3bdc13856..300386fd5 100644
--- a/pydmd/multires_discovery.py
+++ b/pydmd/multires_discovery.py
@@ -295,9 +295,10 @@ def fit(self, data, time, window_length, step_size, verbose=False,
             self._window_means_array[k, :] = c.flatten()
 
             # Reset optdmd between iterations
-            optdmd._svd_rank = self._svd_rank
-            optdmd._proj_basis = self._pydmd_kwargs['proj_basis']
-            optdmd._init_alpha = self._init_alpha
+            if not self._global_svd:
+                optdmd._svd_rank = self._svd_rank
+                optdmd._proj_basis = self._pydmd_kwargs['proj_basis']
+                optdmd._init_alpha = self._init_alpha
 
     def cluster_omega(self, omega_array, n_components, kmeans_kwargs=None):
         self._n_components = n_components

From 1539e3a2dd4fe9981562756dc61df5612fc0165d Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Wed, 12 Apr 2023 17:53:17 +0200
Subject: [PATCH 06/31] Maint: Further building the multi res framework

- Local vs global svd logic should be more complete
- Moved to slice objects for indexing, allowing incomplete windows
and reconstrucitng the entire data set, regardless of the number of
integer windows.
- Fixed bug in the number of slides to make across the data
- Fixed bug in the initialization of the optdmd kwargs.
- Reblacked the project
- Added logic for initializing using the previous windows frequencies.
---
 pydmd/multires_discovery.py | 362 +++++++++++++++++++++++-------------
 1 file changed, 230 insertions(+), 132 deletions(-)

diff --git a/pydmd/multires_discovery.py b/pydmd/multires_discovery.py
index 300386fd5..8d6a1248d 100644
--- a/pydmd/multires_discovery.py
+++ b/pydmd/multires_discovery.py
@@ -7,20 +7,19 @@
 
 class multi_res_discovery:
     def __init__(
-            self,
-            window_length=None,
-            step_size=None,
-            n_components=None,
-            svd_rank=None,
-            global_svd=True,
-            initialize_artificially=False,
-            use_last_freq=False,
-            use_kmean_freqs=False,
-            init_alpha=None,
-            pydmd_kwargs=None,
-            threshhold_percent=1,
-            cluster_centroids=None,
-            reset_alpha_init=False,
+        self,
+        window_length=None,
+        step_size=None,
+        n_components=None,
+        svd_rank=None,
+        global_svd=True,
+        initialize_artificially=False,
+        use_last_freq=False,
+        use_kmean_freqs=False,
+        init_alpha=None,
+        pydmd_kwargs=None,
+        cluster_centroids=None,
+        reset_alpha_init=False,
     ):
         self._n_components = n_components
         self._step_size = step_size
@@ -34,23 +33,39 @@ def __init__(
         self._cluster_centroids = cluster_centroids
         self._reset_alpha_init = reset_alpha_init
 
+        # Initialize variables that are defined in fitting.
+        self._n_data_vars = None
+        self._n_time_steps = None
+        self._window_length = None
+        self._n_slides = None
+        self._time_array = None
+        self._modes_array = None
+        self._omega_array = None
+        self._time_means_array = None
+        self._amplitudes_array = None
+        self._t_starts_array = None
+
         if pydmd_kwargs is None:
             self._pydmd_kwargs = {
-                'eig_sort': 'imag',
+                "eig_sort": "imag",
+                "proj_basis": None,
+                "use_proj": False,
             }
         else:
             self._pydmd_kwargs = pydmd_kwargs
-            self._pydmd_kwargs['eig_sort'] = pydmd_kwargs.get('eig_sort', 'imag')
-
-        # Set the threshold for the number of frequencies to use in clustering,
-        # where the frequencies have been sorted in order of magnitude.
-        # Note: this value is not currently implemented (it was always 1 in examples).
-        self._threshhold_percent = threshhold_percent
+            self._pydmd_kwargs["eig_sort"] = pydmd_kwargs.get(
+                "eig_sort", "imag"
+            )
+            self._pydmd_kwargs["proj_basis"] = pydmd_kwargs.get(
+                "proj_basis", None
+            )
+            self._pydmd_kwargs["use_proj"] = pydmd_kwargs.get(
+                "proj_basis", False
+            )
 
     def _compute_svd_rank(self, data, svd_rank=None):
-
         def omega(x):
-            return 0.56 * x ** 3 - 0.95 * x ** 2 + 1.82 * x + 1.43
+            return 0.56 * x**3 - 0.95 * x**2 + 1.82 * x + 1.43
 
         U, s, _ = np.linalg.svd(data, full_matrices=False)
 
@@ -59,7 +74,7 @@ def omega(x):
             tau = np.median(s) * omega(beta)
             svd_rank = np.sum(s > tau)
         elif 0 < svd_rank < 1:
-            cumulative_energy = np.cumsum(s ** 2 / (s ** 2).sum())
+            cumulative_energy = np.cumsum(s**2 / (s**2).sum())
             svd_rank = np.searchsorted(cumulative_energy, svd_rank) + 1
         elif svd_rank >= 1 and isinstance(svd_rank, (int, np.integer)):
             svd_rank = min(svd_rank, self._n_data_vars)
@@ -68,21 +83,14 @@ def omega(x):
 
         return svd_rank
 
-    def _build_proj_basis(self, data, global_svd=True, svd_rank=None):
-
-        if svd_rank is None:
-            self._svd_rank = self._compute_svd_rank(data, svd_rank=svd_rank)
-
-        # Use global SVD modes for each DMD rather than individual SVD on
-        # each window.
-        if global_svd:
-            # Recover the first r modes of the global svd
-            u, _, _ = scipy.linalg.svd(data, full_matrices=False)
-            return u[:, :self._svd_rank]
+    def _build_proj_basis(self, data, svd_rank=None):
+        self._svd_rank = self._compute_svd_rank(data, svd_rank=svd_rank)
+        # Recover the first r modes of the global svd
+        u, _, _ = scipy.linalg.svd(data, full_matrices=False)
+        return u[:, : self._svd_rank]
 
     def _build_initizialization(self):
-        """ Method for making initial guess of DMD eigenvalues.
-        """
+        """Method for making initial guess of DMD eigenvalues."""
 
         # User provided initial eigenvalues.
         init_alpha = None
@@ -91,17 +99,19 @@ def _build_initizialization(self):
         # Initial eigenvalue guesses from kmeans clustering.
         elif self._initialize_artificially and self._init_alpha is None:
             if self._use_kmean_freqs:
-                init_alpha = np.repeat(np.sqrt(self._cluster_centroids) * 1j,
-                                       int(self._svd_rank / self._n_components))
-                init_alpha = init_alpha * np.tile([1, -1],
-                                                  int(self._svd_rank / self._n_components))
+                init_alpha = np.repeat(
+                    np.sqrt(self._cluster_centroids) * 1j,
+                    int(self._svd_rank / self._n_components),
+                )
+                init_alpha = init_alpha * np.tile(
+                    [1, -1], int(self._svd_rank / self._n_components)
+                )
 
         return init_alpha
 
-    def build_windows(self, data, window_length, step_size, integer_windows=False):
-        """Calculate how many times to slide the window across the data.
-
-        """
+    @staticmethod
+    def build_windows(data, window_length, step_size, integer_windows=False):
+        """Calculate how many times to slide the window across the data."""
 
         if integer_windows:
             n_split = np.floor(data.shape[1] / window_length).astype(int)
@@ -113,24 +123,28 @@ def build_windows(self, data, window_length, step_size, integer_windows=False):
         # Number of sliding-window iterations
         n_slides = np.floor((n_steps - window_length) / step_size).astype(int)
 
-        return n_slides
-
-    def calculate_lv_kern(self, window_length, corner_sharpness=None):
-        """Calculate the kerning window for suppressing real eigenvalues.
+        return n_slides + 1
 
-        """
+    @staticmethod
+    def calculate_lv_kern(window_length, corner_sharpness=None):
+        """Calculate the kerning window for suppressing real eigenvalues."""
 
         # Higher = sharper corners
         if corner_sharpness is None:
             corner_sharpness = 16
 
         lv_kern = (
-                np.tanh(
-                    corner_sharpness * np.arange(1, window_length + 1) / window_length
-                )
-                - np.tanh(
-            corner_sharpness * (
-                    np.arange(1, window_length + 1) - window_length) / window_length) - 1
+            np.tanh(
+                corner_sharpness
+                * np.arange(1, window_length + 1)
+                / window_length
+            )
+            - np.tanh(
+                corner_sharpness
+                * (np.arange(1, window_length + 1) - window_length)
+                / window_length
+            )
+            - 1
         )
 
         return lv_kern
@@ -166,12 +180,6 @@ def omega_array(self):
             raise ValueError("You need to call fit before")
         return self._omega_array
 
-    @property
-    def omega_array(self):
-        if not hasattr(self, "_omega_array"):
-            raise ValueError("You need to call fit before")
-        return self._omega_array
-
     @property
     def time_array(self):
         if not hasattr(self, "_time_array"):
@@ -196,43 +204,73 @@ def time_means_array(self):
             raise ValueError("You need to call fit before")
         return self._time_means_array
 
-    def fit(self, data, time, window_length, step_size, verbose=False,
-            corner_sharpness=None):
-
+    def fit(
+        self,
+        data,
+        time,
+        window_length,
+        step_size,
+        verbose=False,
+        corner_sharpness=None,
+    ):
         # Prepare window and data properties.
         self._window_length = window_length
         self._step_size = step_size
 
         self._n_time_steps, self._n_data_vars = self._data_shape(data)
-        self._n_slides = self.build_windows(data, self._window_length, self._step_size)
+        self._n_slides = self.build_windows(
+            data, self._window_length, self._step_size
+        )
+
+        # If the window size and step size do not span the data in an integer
+        # number of slides, we add one last window that has a smaller step spacing
+        # relative to the other window spacings.
+        n_slide_last_window = self._n_time_steps - (
+            self._step_size * (self._n_slides - 1) + self._window_length
+        )
+        if n_slide_last_window > 0:
+            self._n_slides += 1
+        self._n_slide_last_window = n_slide_last_window
 
         # Build the projection basis if using a global svd.
         if self._global_svd:
-            u = self._build_proj_basis(data, global_svd=self._global_svd,
-                                       svd_rank=self._svd_rank)
-            self._pydmd_kwargs['proj_basis'] = self._pydmd_kwargs.get('proj_basis', u)
-            self._pydmd_kwargs['use_proj'] = self._pydmd_kwargs.get('use_proj', False)
+            u = self._build_proj_basis(data, svd_rank=self._svd_rank)
+            # self._pydmd_kwargs['proj_basis'] = self._pydmd_kwargs.get('proj_basis', u)
+            self._pydmd_kwargs["proj_basis"] = u
+            self._pydmd_kwargs["use_proj"] = self._pydmd_kwargs.get(
+                "use_proj", False
+            )
 
-            self._svd_rank = self._compute_svd_rank(data, svd_rank=self._svd_rank)
+            self._svd_rank = self._compute_svd_rank(
+                data, svd_rank=self._svd_rank
+            )
             svd_rank_pre_allocate = self._svd_rank
+        elif not self._global_svd and self._svd_rank > 0:
+            svd_rank_pre_allocate = self._compute_svd_rank(
+                data, svd_rank=self._svd_rank
+            )
         # If not using a global svd, local u  from each window is used instead.
         else:
-            # The various arrays the optimal svd_rank may change when using the locally
-            # optimal svd_rank. To deal with this situation, we give the maximally
+            # The optimal svd_rank may change when using the locally optimal svd_rank.
+            # To deal with this situation in the pre-allocation we give the maximally
             # allowed svd_rank for pre-allocation.
             svd_rank_pre_allocate = self._n_data_vars
 
         # Pre-allocate all elements for the sliding window DMD.
         # Each element calculated for a window is returned through these array.
-        data_array = np.zeros((self._n_slides, self._n_data_vars, self._window_length))
+        # data_array = np.zeros(
+        #     (self._n_slides, self._n_data_vars, self._window_length))  # * np.nan
         self._time_array = np.zeros((self._n_slides, self._window_length))
         self._modes_array = np.zeros(
             (self._n_slides, self._n_data_vars, svd_rank_pre_allocate),
-            np.complex128)
-        self._omega_array = np.zeros((self._n_slides, svd_rank_pre_allocate),
-                                     np.complex128)
-        self._amplitudes_array = np.zeros((self._n_slides, svd_rank_pre_allocate),
-                                          np.complex128)
+            np.complex128,
+        )
+        self._omega_array = np.zeros(
+            (self._n_slides, svd_rank_pre_allocate), np.complex128
+        )
+        self._amplitudes_array = np.zeros(
+            (self._n_slides, svd_rank_pre_allocate), np.complex128
+        )
         self._window_means_array = np.zeros((self._n_slides, self._n_data_vars))
         self._t_starts_array = np.zeros(self._n_slides)
         self._time_means_array = np.zeros(self._n_slides)
@@ -241,30 +279,41 @@ def fit(self, data, time, window_length, step_size, verbose=False,
         if self._initialize_artificially:
             self._init_alpha = self._build_initizialization()
             optdmd = BOPDMD(
-                svd_rank=self._svd_rank, num_trials=0, init_alpha=self._init_alpha,
-                **self._pydmd_kwargs
+                svd_rank=self._svd_rank,
+                num_trials=0,
+                init_alpha=self._init_alpha,
+                **self._pydmd_kwargs,
             )
         else:
             optdmd = BOPDMD(
-                svd_rank=self._svd_rank, num_trials=0, **self._pydmd_kwargs,
+                svd_rank=self._svd_rank,
+                num_trials=0,
+                **self._pydmd_kwargs,
             )
 
         # Round the corners of the window to shrink real components.
-        lv_kern = self.calculate_lv_kern(self._window_length,
-                                         corner_sharpness=corner_sharpness)
+        lv_kern = self.calculate_lv_kern(
+            self._window_length, corner_sharpness=corner_sharpness
+        )
 
         # Perform the sliding window DMD fitting.
         for k in range(self._n_slides):
             if verbose:
                 if k // 50 == k / 50:
-                    print('{} of {}'.format(k, self._n_slides))
+                    print("{} of {}".format(k, self._n_slides))
 
             # Get the window indices and data.
             sample_start = self._step_size * k
-            sample_steps = np.arange(sample_start, sample_start + self._window_length)
-            data_window = data[:, sample_steps]
-            time_window = time[:, sample_steps]
-            data_array[k, :, :] = data_window
+            if k == self._n_slides - 1 and self._n_slide_last_window > 0:
+                sample_slice = slice(-self._window_length, None)
+            else:
+                sample_slice = slice(
+                    sample_start, sample_start + self._window_length
+                )
+            # sample_steps = np.arange(sample_start, sample_start + self._window_length)
+            data_window = data[:, sample_slice]
+            time_window = time[:, sample_slice]
+            # data_array[k, :, :] = data_window
             self._time_array[k, :] = time_window
             self._time_means_array[k] = np.mean(time_window)
 
@@ -274,8 +323,6 @@ def fit(self, data, time, window_length, step_size, verbose=False,
             self._t_starts_array[k] = t_start
 
             # Subtract off mean before rounding corners
-            # https://stackoverflow.com/questions/32030343/
-            # subtracting-the-mean-of-each-row-in-numpy-with-broadcasting
             c = np.mean(data_window, 1, keepdims=True)
             data_window = data_window - c
 
@@ -285,25 +332,39 @@ def fit(self, data, time, window_length, step_size, verbose=False,
             # Fit with the desired DMD class
             optdmd.fit(data_window, time_window)
 
-            # if use_last_freq == 1:
-            #     e_init = e
-
             # Assign the results from this window
-            self._modes_array[k, :, :optdmd.modes.shape[-1]] = optdmd.modes
-            self._omega_array[k, :optdmd.eigs.shape[0]] = optdmd.eigs
-            self._amplitudes_array[k, :optdmd.eigs.shape[0]] = optdmd.amplitudes
+            self._modes_array[k, :, : optdmd.modes.shape[-1]] = optdmd.modes
+            self._omega_array[k, : optdmd.eigs.shape[0]] = optdmd.eigs
+            self._amplitudes_array[
+                k, : optdmd.eigs.shape[0]
+            ] = optdmd.amplitudes
             self._window_means_array[k, :] = c.flatten()
 
             # Reset optdmd between iterations
             if not self._global_svd:
                 optdmd._svd_rank = self._svd_rank
-                optdmd._proj_basis = self._pydmd_kwargs['proj_basis']
-                optdmd._init_alpha = self._init_alpha
+                optdmd._proj_basis = self._pydmd_kwargs["proj_basis"]
+
+                # The default behavior is to reset the optdmd object to use the default
+                # initial value (None) or the user provided values.
+                if not self._use_last_freq:
+                    optdmd._init_alpha = self._init_alpha
+                # Otherwise use the eigenvalues from this window to seed the next window.
+                elif self._use_last_freq:
+                    optdmd._init_alpha = optdmd.eigs
 
     def cluster_omega(self, omega_array, n_components, kmeans_kwargs=None):
         self._n_components = n_components
-        omega_rshp = omega_array.reshape(self._n_slides * self._svd_rank)
-        omega_squared = (np.conj(omega_rshp) * omega_rshp).astype('float')
+
+        # Reshape the omega array into a 1d array
+        n_slides = self._n_slides
+        if self._svd_rank == 0:
+            svd_rank = self._n_data_vars
+        else:
+            svd_rank = self._svd_rank
+        omega_rshp = omega_array.reshape(n_slides * svd_rank)
+
+        omega_squared = (np.conj(omega_rshp) * omega_rshp).astype("float")
 
         if kmeans_kwargs is None:
             random_state = 0
@@ -311,45 +372,62 @@ def cluster_omega(self, omega_array, n_components, kmeans_kwargs=None):
                 "n_init": "auto",
                 "random_state": random_state,
             }
-        kmeans = KMeans(n_clusters=self._n_components, **kmeans_kwargs)
-        y_pred = kmeans.fit_predict(np.atleast_2d(omega_squared).T)
-        omega_classes = y_pred.reshape(self._n_slides, self._svd_rank)
+        kmeans = KMeans(n_clusters=n_components, **kmeans_kwargs)
+        omega_classes = kmeans.fit_predict(np.atleast_2d(omega_squared).T)
+        omega_classes = omega_classes.reshape(n_slides, svd_rank)
         cluster_centroids = kmeans.cluster_centers_.flatten()
 
         return omega_classes, omega_squared, cluster_centroids
 
-    def plot_omega_squared_histogram(self, omega_squared, cluster_centroids):
+    @staticmethod
+    def plot_omega_squared_histogram(omega_squared, cluster_centroids):
+        colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]
         fig, ax = plt.subplots(1, 1)
         ax.hist(omega_squared, bins=64)
-        ax.set_xlabel('$|\omega|^{2}$')
-        ax.set_ylabel('Count')
-        ax.set_title('$|\omega|^2$ Spectrum & k-Means Centroids')
-        [ax.axvline(c, color='r') for c in cluster_centroids]
+        ax.set_xlabel("$|\omega|^{2}$")
+        ax.set_ylabel("Count")
+        ax.set_title("$|\omega|^2$ Spectrum & k-Means Centroids")
+        [
+            ax.axvline(c, color=colors[nc % len(colors)])
+            for nc, c in enumerate(cluster_centroids)
+        ]
 
         return fig, ax
 
     def plot_omega_squared_time_series(self, omega_squared, omega_classes):
         fig, ax = plt.subplots(1, 1)
         colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]
+
+        # Reshape the omega array into a 1d array
+        n_slides = self._n_slides
+        if self._svd_rank == 0:
+            svd_rank = self._n_data_vars
+        else:
+            svd_rank = self._svd_rank
+
         for ncomponent, component in enumerate(range(self._n_components)):
             ax.plot(
                 self._time_means_array,
                 np.where(
                     omega_classes == component,
-                    omega_squared.reshape((self._n_slides, self._svd_rank)), np.nan
+                    omega_squared.reshape((n_slides, svd_rank)),
+                    np.nan,
                 ),
-                color=colors[ncomponent % len(colors)]
+                color=colors[ncomponent % len(colors)],
             )
-        ax.set_ylabel('$|\omega|^{2}$')
-        ax.set_xlabel('Time')
-        ax.set_title('$|\omega|^2$ Spectrum (Moving Window)')
+        ax.set_ylabel("$|\omega|^{2}$")
+        ax.set_xlabel("Time")
+        ax.set_title("$|\omega|^2$ Spectrum (Moving Window)")
 
         return fig, ax
 
-    def global_reconstruction(self, ):
+    def global_reconstruction(
+        self,
+    ):
         # Container for the reconstructed time series
         glbl_reconstruction = np.zeros(
-            (self._n_data_vars, self._n_time_steps)).astype('complex128')
+            (self._n_data_vars, self._n_time_steps)
+        ).astype("complex128")
 
         # Count the number of windows contributing to each step
         xn = np.zeros(self._n_time_steps)
@@ -367,10 +445,13 @@ def global_reconstruction(self, ):
             t = t - t_start
 
             # Perform the global reconstruction.
-            recon_window = np.linalg.multi_dot([w, np.diag(b), np.exp(omega * t)]) + c
+            recon_window = (
+                np.linalg.multi_dot([w, np.diag(b), np.exp(omega * t)]) + c
+            )
 
-            window_indices = slice(k * self._step_size,
-                                   k * self._step_size + self._window_length)
+            window_indices = slice(
+                k * self._step_size, k * self._step_size + self._window_length
+            )
             glbl_reconstruction[:, window_indices] += recon_window
             xn[window_indices] += 1
 
@@ -379,8 +460,13 @@ def global_reconstruction(self, ):
 
         return glbl_reconstruction
 
-    def scale_reconstruction(self, omega_classes, cluster_centroids, suppress_growth=True,
-                             include_means=True):
+    def scale_reconstruction(
+        self,
+        omega_classes,
+        cluster_centroids,
+        suppress_growth=True,
+        include_means=True,
+    ):
         """Reconstruct the sliding mrDMD into the constituent components.
 
         The reconstructed data are convolved with a guassian filter since
@@ -395,7 +481,9 @@ def scale_reconstruction(self, omega_classes, cluster_centroids, suppress_growth
         """
 
         # Each individual reconstructed window
-        xr_sep = np.zeros((self._n_components, self._n_data_vars, self._n_time_steps))
+        xr_sep = np.zeros(
+            (self._n_components, self._n_data_vars, self._n_time_steps)
+        )
 
         # Track the total contribution from all windows to each time step
         xn = np.zeros(self._n_time_steps)
@@ -405,9 +493,11 @@ def scale_reconstruction(self, omega_classes, cluster_centroids, suppress_growth
         recon_filter_sd = self._window_length / 8
         recon_filter = np.exp(
             -(
-                     np.arange(self._window_length)
-                     - (self._window_length + 1) / 2
-             ) ** 2 / recon_filter_sd ** 2)
+                (np.arange(self._window_length) - (self._window_length + 1) / 2)
+                ** 2
+            )
+            / recon_filter_sd**2
+        )
 
         for k in range(self._n_slides):
             w = self._modes_array[k]
@@ -426,13 +516,14 @@ def scale_reconstruction(self, omega_classes, cluster_centroids, suppress_growth
             t = t - t_start
 
             xr_sep_window = np.zeros(
-                (self._n_components, self._n_data_vars, self._window_length))
+                (self._n_components, self._n_data_vars, self._window_length)
+            )
             for j in np.unique(omega_classes):
                 xr_sep_window[j, :, :] = np.linalg.multi_dot(
                     [
                         w[:, classification == j],
                         np.diag(b[classification == j]),
-                        np.exp(omega[classification == j] * t)
+                        np.exp(omega[classification == j] * t),
                     ]
                 )
 
@@ -440,13 +531,20 @@ def scale_reconstruction(self, omega_classes, cluster_centroids, suppress_growth
                 if include_means and (j == np.argmin(cluster_centroids)):
                     xr_sep_window[j, :, :] += c
                 xr_sep_window[j, :, :] = xr_sep_window[j, :, :] * recon_filter
-                window_indices = slice(k * self._step_size,
-                                       k * self._step_size + self._window_length)
-                xr_sep[j, :, window_indices] = xr_sep[j, :,
-                                               window_indices] + xr_sep_window[j, :, :]
+
+                if k == self._n_slides - 1 and self._n_slide_last_window > 0:
+                    window_indices = slice(-self._window_length, None)
+                else:
+                    window_indices = slice(
+                        k * self._step_size,
+                        k * self._step_size + self._window_length,
+                    )
+                xr_sep[j, :, window_indices] = (
+                    xr_sep[j, :, window_indices] + xr_sep_window[j, :, :]
+                )
 
             xn[window_indices] += recon_filter
 
         xr_sep = xr_sep / xn
 
-        return xr_sep
\ No newline at end of file
+        return xr_sep

From eee0d2221aed5a904b17b0ce9569d048cc57d5fb Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Thu, 13 Apr 2023 15:39:16 +0200
Subject: [PATCH 07/31] Feat: add setter to initial alpha for multi res disc

---
 pydmd/bopdmd.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/pydmd/bopdmd.py b/pydmd/bopdmd.py
index 2de8115f5..a7f3b81e5 100644
--- a/pydmd/bopdmd.py
+++ b/pydmd/bopdmd.py
@@ -755,6 +755,7 @@ def __init__(
         trial_size=0.2,
         eig_sort="auto",
         varpro_opts_dict=None,
+        max_rank=None,
     ):
         self._svd_rank = svd_rank
         self._compute_A = compute_A
@@ -764,6 +765,7 @@ def __init__(
         self._num_trials = num_trials
         self._trial_size = trial_size
         self._eig_sort = eig_sort
+        self._max_rank = max_rank
 
         if varpro_opts_dict is None:
             self._varpro_opts_dict = {}
@@ -815,6 +817,10 @@ def init_alpha(self):
             raise RuntimeError(msg)
         return self._init_alpha
 
+    @init_alpha.setter
+    def init_alpha(self, value):
+        self._init_alpha = value
+
     @property
     def proj_basis(self):
         """
@@ -898,7 +904,6 @@ def amplitudes_std(self):
         """
         return self.operator.amplitudes_std
 
-
     @property
     def eigenvalues_std(self):
         """
@@ -909,7 +914,6 @@ def eigenvalues_std(self):
         """
         return self.operator.eigenvalues_std
 
-
     def print_varpro_opts(self):
         """
         Prints a formatted information string that displays all chosen

From 5d4d559d05eaab1f9683fd1f5dfd1dad294d4f36 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 18 Apr 2023 14:15:26 +0200
Subject: [PATCH 08/31] Feat: added svd_rank setter to bopdmd

---
 pydmd/bopdmd.py                              |   6 +-
 pydmd/{multires_discovery.py => costsdmd.py} | 123 +++++++++++--------
 2 files changed, 75 insertions(+), 54 deletions(-)
 rename pydmd/{multires_discovery.py => costsdmd.py} (84%)

diff --git a/pydmd/bopdmd.py b/pydmd/bopdmd.py
index 10e2e6912..21d81132e 100644
--- a/pydmd/bopdmd.py
+++ b/pydmd/bopdmd.py
@@ -782,7 +782,6 @@ def __init__(
         trial_size=0.2,
         eig_sort="auto",
         varpro_opts_dict=None,
-        max_rank=None,
     ):
         self._svd_rank = svd_rank
         self._compute_A = compute_A
@@ -792,7 +791,6 @@ def __init__(
         self._num_trials = num_trials
         self._trial_size = trial_size
         self._eig_sort = eig_sort
-        self._max_rank = max_rank
 
         if varpro_opts_dict is None:
             self._varpro_opts_dict = {}
@@ -814,6 +812,10 @@ def svd_rank(self):
         """
         return self._svd_rank
 
+    @svd_rank.setter
+    def svd_rank(self, value):
+        self._svd_rank = value
+
     @property
     def compute_A(self):
         """
diff --git a/pydmd/multires_discovery.py b/pydmd/costsdmd.py
similarity index 84%
rename from pydmd/multires_discovery.py
rename to pydmd/costsdmd.py
index 8d6a1248d..3515c61b0 100644
--- a/pydmd/multires_discovery.py
+++ b/pydmd/costsdmd.py
@@ -5,7 +5,15 @@
 import matplotlib.pyplot as plt
 
 
-class multi_res_discovery:
+class CospamDMD:
+    """Coherent Spatiotemporal Scale Separation from Dynamic Mode Decomposition
+
+    :param window_length: Length of the analysis window in number of time steps.
+    :type window_length: int
+    :param step_size: Number of time steps to slide each CSM-DMD window.
+    :type compute_A: bool
+    """
+
     def __init__(
         self,
         window_length=None,
@@ -20,6 +28,8 @@ def __init__(
         pydmd_kwargs=None,
         cluster_centroids=None,
         reset_alpha_init=False,
+        force_even_eigs=True,
+        max_rank=None,
     ):
         self._n_components = n_components
         self._step_size = step_size
@@ -32,6 +42,8 @@ def __init__(
         self._init_alpha = init_alpha
         self._cluster_centroids = cluster_centroids
         self._reset_alpha_init = reset_alpha_init
+        self._force_even_eigs = force_even_eigs
+        self._max_rank = max_rank
 
         # Initialize variables that are defined in fitting.
         self._n_data_vars = None
@@ -59,9 +71,7 @@ def __init__(
             self._pydmd_kwargs["proj_basis"] = pydmd_kwargs.get(
                 "proj_basis", None
             )
-            self._pydmd_kwargs["use_proj"] = pydmd_kwargs.get(
-                "proj_basis", False
-            )
+            self._pydmd_kwargs["use_proj"] = pydmd_kwargs.get("use_proj", False)
 
     def _compute_svd_rank(self, data, svd_rank=None):
         def omega(x):
@@ -171,39 +181,45 @@ def modes_array(self):
     @property
     def amplitudes_array(self):
         if not hasattr(self, "_amplitudes_array"):
-            raise ValueError("You need to call fit before")
+            raise ValueError("You need to call fit first.")
         return self._amplitudes_array
 
     @property
     def omega_array(self):
         if not hasattr(self, "_omega_array"):
-            raise ValueError("You need to call fit before")
+            raise ValueError("You need to call fit first.")
         return self._omega_array
 
     @property
     def time_array(self):
         if not hasattr(self, "_time_array"):
-            raise ValueError("You need to call fit before")
+            raise ValueError("You need to call fit first.")
         return self._time_array
 
     @property
     def window_means_array(self):
         if not hasattr(self, "_window_means_array"):
-            raise ValueError("You need to call fit before")
+            raise ValueError("You need to call fit first.")
         return self._window_means_array
 
     @property
     def t_starts_array(self):
         if not hasattr(self, "_t_starts_array"):
-            raise ValueError("You need to call fit before")
+            raise ValueError("You need to call fit first.")
         return self._t_starts_array
 
     @property
     def time_means_array(self):
         if not hasattr(self, "_time_means_array"):
-            raise ValueError("You need to call fit before")
+            raise ValueError("You need to call fit first.")
         return self._time_means_array
 
+    @property
+    def n_components(self):
+        if not hasattr(self, "_n_components"):
+            raise ValueError("You need to call `cluster_omega()` first.")
+        return self._n_components
+
     def fit(
         self,
         data,
@@ -216,7 +232,6 @@ def fit(
         # Prepare window and data properties.
         self._window_length = window_length
         self._step_size = step_size
-
         self._n_time_steps, self._n_data_vars = self._data_shape(data)
         self._n_slides = self.build_windows(
             data, self._window_length, self._step_size
@@ -235,12 +250,10 @@ def fit(
         # Build the projection basis if using a global svd.
         if self._global_svd:
             u = self._build_proj_basis(data, svd_rank=self._svd_rank)
-            # self._pydmd_kwargs['proj_basis'] = self._pydmd_kwargs.get('proj_basis', u)
             self._pydmd_kwargs["proj_basis"] = u
             self._pydmd_kwargs["use_proj"] = self._pydmd_kwargs.get(
                 "use_proj", False
             )
-
             self._svd_rank = self._compute_svd_rank(
                 data, svd_rank=self._svd_rank
             )
@@ -249,17 +262,16 @@ def fit(
             svd_rank_pre_allocate = self._compute_svd_rank(
                 data, svd_rank=self._svd_rank
             )
-        # If not using a global svd, local u  from each window is used instead.
+        # If not using a global svd or a specified svd_rank, local u from each window is
+        # used instead. The optimal svd_rank may change when using the locally optimal
+        # svd_rank. To deal with this situation in the pre-allocation we give the
+        # maximally allowed svd_rank for pre-allocation.
+        elif self._max_rank is not None:
+            svd_rank_pre_allocate = self._max_rank
         else:
-            # The optimal svd_rank may change when using the locally optimal svd_rank.
-            # To deal with this situation in the pre-allocation we give the maximally
-            # allowed svd_rank for pre-allocation.
             svd_rank_pre_allocate = self._n_data_vars
 
         # Pre-allocate all elements for the sliding window DMD.
-        # Each element calculated for a window is returned through these array.
-        # data_array = np.zeros(
-        #     (self._n_slides, self._n_data_vars, self._window_length))  # * np.nan
         self._time_array = np.zeros((self._n_slides, self._window_length))
         self._modes_array = np.zeros(
             (self._n_slides, self._n_data_vars, svd_rank_pre_allocate),
@@ -275,21 +287,15 @@ def fit(
         self._t_starts_array = np.zeros(self._n_slides)
         self._time_means_array = np.zeros(self._n_slides)
 
-        # Initialize the DMD class.
-        if self._initialize_artificially:
-            self._init_alpha = self._build_initizialization()
-            optdmd = BOPDMD(
-                svd_rank=self._svd_rank,
-                num_trials=0,
-                init_alpha=self._init_alpha,
-                **self._pydmd_kwargs,
-            )
-        else:
-            optdmd = BOPDMD(
-                svd_rank=self._svd_rank,
-                num_trials=0,
-                **self._pydmd_kwargs,
-            )
+        # Get initial values for the eigenvalues.
+        self._init_alpha = self._build_initizialization()
+
+        # Initialize the BOPDMD object.
+        optdmd = BOPDMD(
+            svd_rank=self._svd_rank,
+            init_alpha=self._init_alpha,
+            **self._pydmd_kwargs,
+        )
 
         # Round the corners of the window to shrink real components.
         lv_kern = self.calculate_lv_kern(
@@ -310,48 +316,61 @@ def fit(
                 sample_slice = slice(
                     sample_start, sample_start + self._window_length
                 )
-            # sample_steps = np.arange(sample_start, sample_start + self._window_length)
             data_window = data[:, sample_slice]
-            time_window = time[:, sample_slice]
-            # data_array[k, :, :] = data_window
-            self._time_array[k, :] = time_window
-            self._time_means_array[k] = np.mean(time_window)
+            original_time_window = time[:, sample_slice]
+            time_window_mean = np.mean(original_time_window)
 
             # All windows are fit with the time array reset to start at t=0.
-            t_start = time_window[:, 0]
-            time_window = time_window - t_start
-            self._t_starts_array[k] = t_start
+            t_start = original_time_window[:, 0]
+            time_window = original_time_window - t_start
 
-            # Subtract off mean before rounding corners
+            # Subtract off the time mean before rounding corners.
             c = np.mean(data_window, 1, keepdims=True)
             data_window = data_window - c
 
-            # Round corners of the window
+            # Round the corners of the window.
             data_window = data_window * lv_kern
 
-            # Fit with the desired DMD class
+            # Reset optdmd between iterations
+            if not self._global_svd:
+                # Get the svd rank for this window. Primarily used when svd_rank is not
+                # fixed, i.e. svd_rank = 0.
+                _svd_rank = self._compute_svd_rank(
+                    data_window, svd_rank=self._svd_rank
+                )
+                # Force svd rank to be even to allow for conjugate pairs.
+                if _svd_rank % 2:
+                    _svd_rank += 1
+                # Force svd rank to not exceed a user specified amount.
+                if self._max_rank is not None:
+                    optdmd.svd_rank = min(_svd_rank, self._max_rank)
+                else:
+                    optdmd.svd_rank = _svd_rank
+                optdmd._proj_basis = self._pydmd_kwargs["proj_basis"]
+
+            # Fit the window using the optDMD.
             optdmd.fit(data_window, time_window)
 
-            # Assign the results from this window
+            # Assign the results from this window.
             self._modes_array[k, :, : optdmd.modes.shape[-1]] = optdmd.modes
             self._omega_array[k, : optdmd.eigs.shape[0]] = optdmd.eigs
             self._amplitudes_array[
                 k, : optdmd.eigs.shape[0]
             ] = optdmd.amplitudes
             self._window_means_array[k, :] = c.flatten()
+            self._time_array[k, :] = original_time_window
+            self._time_means_array[k] = time_window_mean
+            self._t_starts_array[k] = t_start
 
             # Reset optdmd between iterations
             if not self._global_svd:
-                optdmd._svd_rank = self._svd_rank
-                optdmd._proj_basis = self._pydmd_kwargs["proj_basis"]
-
                 # The default behavior is to reset the optdmd object to use the default
                 # initial value (None) or the user provided values.
                 if not self._use_last_freq:
-                    optdmd._init_alpha = self._init_alpha
+                    optdmd.init_alpha = self._init_alpha
                 # Otherwise use the eigenvalues from this window to seed the next window.
                 elif self._use_last_freq:
-                    optdmd._init_alpha = optdmd.eigs
+                    optdmd.init_alpha = optdmd.eigs
 
     def cluster_omega(self, omega_array, n_components, kmeans_kwargs=None):
         self._n_components = n_components

From 423bfdf9c542d6e6b3a4c7c65f3c315c379710a5 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 18 Apr 2023 14:16:06 +0200
Subject: [PATCH 09/31] Feat: Refactor class name, added comments, bug fixes

- Refactored to have a hopefully more catchy and descriptive name. No
promises that this is the last rename.
- re-blacked
- Added checks for how to initialize the DMD fit.
- Fixed global reconstruction
---
 pydmd/costsdmd.py | 88 +++++++++++++++++++++++++++++++++++++----------
 1 file changed, 69 insertions(+), 19 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 3515c61b0..917f3ea16 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -5,20 +5,52 @@
 import matplotlib.pyplot as plt
 
 
-class CospamDMD:
-    """Coherent Spatiotemporal Scale Separation from Dynamic Mode Decomposition
+class CostsDMD:
+    """Coherent Spatio-Temporal Scale Separation with DMD
 
     :param window_length: Length of the analysis window in number of time steps.
     :type window_length: int
     :param step_size: Number of time steps to slide each CSM-DMD window.
-    :type compute_A: bool
+    :type step_size: int
+    :param n_components: Number of independent frequency bands for this window length.
+    :type n_components: int
+    :param svd_rank: The rank of the BOPDMD fit.
+    :type svd_rank: int
+    :param global_svd: Flag indicating whether to find the proj_basis and initial
+        values using the entire dataset instead of individually for each window.
+        Generally using the global_svd speeds up the fitting process by not finding a
+        new initial value for each window. Default is True.
+    :type global_svd: bool
+    :param initialize_artificially: Flag indicating whether to initialize the DMD using
+        imaginary eigenvalues (i.e., the imaginary component of the cluster results from a
+        previous iteration) through the `cluster_centroids` keyword. Default is False.
+    :type initialize_artificially: bool
+    :param pydmd_kwargs: Keyword arguments to pass onto the BOPDMD object.
+    :type global_svd: dict
+    :param cluster_centroids: Cluster centroids from a previous fitting iteration to
+        use for the initial guess of the eigenvalues. Should only be the imaginary
+        component.
+    :type cluster_centroids: numpy array
+    :param reset_alpha_init: Flag indicating whether the initial guess for the BOPDMD
+        eigenvalues should be reset for each window. Resetting the initial value increases
+        the computation time due to finding a new initial guess. Default is False.
+    :type reset_alpha_init: bool
+    :param force_even_eigs: Flag indicating whether an even svd_rank should be forced
+        when not specifying the svd_rank directly (i.e., svd_rank=0). Default is True.
+    :type global_svd: bool
+    :param max_rank: Maximum svd_rank allowed when the svd_rank is found through rank
+        truncation (i.e., svd_rank=0).
+    :type max_rank: int
+    :param use_kmean_freqs:
+    :type use_kmean_freqs: bool
+    :param init_alpha:
+    :type init_alpha: numpy array
     """
 
     def __init__(
         self,
         window_length=None,
         step_size=None,
-        n_components=None,
         svd_rank=None,
         global_svd=True,
         initialize_artificially=False,
@@ -30,6 +62,7 @@ def __init__(
         reset_alpha_init=False,
         force_even_eigs=True,
         max_rank=None,
+        n_components=None,
     ):
         self._n_components = n_components
         self._step_size = step_size
@@ -102,20 +135,33 @@ def _build_proj_basis(self, data, svd_rank=None):
     def _build_initizialization(self):
         """Method for making initial guess of DMD eigenvalues."""
 
-        # User provided initial eigenvalues.
+        # If not initial values are provided return None by default.
         init_alpha = None
+        # User provided initial eigenvalues.
         if self._initialize_artificially and self._init_alpha is not None:
             init_alpha = self._init_alpha
         # Initial eigenvalue guesses from kmeans clustering.
-        elif self._initialize_artificially and self._init_alpha is None:
-            if self._use_kmean_freqs:
-                init_alpha = np.repeat(
-                    np.sqrt(self._cluster_centroids) * 1j,
-                    int(self._svd_rank / self._n_components),
-                )
-                init_alpha = init_alpha * np.tile(
-                    [1, -1], int(self._svd_rank / self._n_components)
-                )
+        elif (
+            self._initialize_artificially
+            and self._init_alpha is None
+            and self._cluster_centroids is not None
+        ):
+            init_alpha = np.repeat(
+                np.sqrt(self._cluster_centroids) * 1j,
+                int(self._svd_rank / self._n_components),
+            )
+            init_alpha = init_alpha * np.tile(
+                [1, -1], int(self._svd_rank / self._n_components)
+            )
+        # The user accidentally provided both methods of initializing the eigenvalues.
+        elif (
+            self._initialize_artificially
+            and self._init_alpha is not None
+            and self._cluster_centroids is not None
+        ):
+            raise ValueError(
+                "Only one of `init_alpha` and `cluster_centroids` can be provided"
+            )
 
         return init_alpha
 
@@ -333,8 +379,8 @@ def fit(
 
             # Reset optdmd between iterations
             if not self._global_svd:
-                # Get the svd rank for this window. Primarily used when svd_rank is not
-                # fixed, i.e. svd_rank = 0.
+                # Get the svd rank for this window. Uses rank truncation when svd_rank is
+                # not fixed, i.e. svd_rank = 0, otherwise uses the specified rank.
                 _svd_rank = self._compute_svd_rank(
                     data_window, svd_rank=self._svd_rank
                 )
@@ -468,9 +514,13 @@ def global_reconstruction(
                 np.linalg.multi_dot([w, np.diag(b), np.exp(omega * t)]) + c
             )
 
-            window_indices = slice(
-                k * self._step_size, k * self._step_size + self._window_length
-            )
+            if k == self._n_slides - 1 and self._n_slide_last_window > 0:
+                window_indices = slice(-self._window_length, None)
+            else:
+                window_indices = slice(
+                    k * self._step_size,
+                    k * self._step_size + self._window_length,
+                )
             glbl_reconstruction[:, window_indices] += recon_window
             xn[window_indices] += 1
 

From a9de7e8f514ec040201e1cba63bcdcb7687a8101 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Fri, 21 Apr 2023 10:59:22 +0200
Subject: [PATCH 10/31] Update: Clustering and reconstruciton as native to
 object.

- Added `cluster_centroids`, `n_components`, `omega_classes` as properties.
- Changed detection of array shapes to use object derived values.
- Added flag to square the frequency or not.
- Sort the frequency band clusters according to centroid magnitude.
- Reconstructions, scale-separation, and plots according to object
values instead of externally provided arguments.
- Mode thresholding for discarding insignificant frequency bands.
- Scale separation for iterative decomposition.
---
 pydmd/costsdmd.py | 211 ++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 185 insertions(+), 26 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 917f3ea16..3f4ddc0c4 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -89,6 +89,8 @@ def __init__(
         self._time_means_array = None
         self._amplitudes_array = None
         self._t_starts_array = None
+        self._cluster_centroids = None
+        self._omega_classes = None
 
         if pydmd_kwargs is None:
             self._pydmd_kwargs = {
@@ -266,6 +268,18 @@ def n_components(self):
             raise ValueError("You need to call `cluster_omega()` first.")
         return self._n_components
 
+    @property
+    def cluster_centroids(self):
+        if not hasattr(self, "_cluster_centroids"):
+            raise ValueError("You need to call `cluster_omega()` first.")
+        return self._cluster_centroids
+
+    @property
+    def omega_classes(self):
+        if not hasattr(self, "_omega_classes"):
+            raise ValueError("You need to call `cluster_omega()` first.")
+        return self._omega_classes
+
     def fit(
         self,
         data,
@@ -418,18 +432,20 @@ def fit(
                 elif self._use_last_freq:
                     optdmd.init_alpha = optdmd.eigs
 
-    def cluster_omega(self, omega_array, n_components, kmeans_kwargs=None):
-        self._n_components = n_components
+    def cluster_omega(
+        self, n_components, kmeans_kwargs=None, square_frequencies=True
+    ):
 
         # Reshape the omega array into a 1d array
-        n_slides = self._n_slides
-        if self._svd_rank == 0:
-            svd_rank = self._n_data_vars
-        else:
-            svd_rank = self._svd_rank
+        omega_array = self.omega_array
+        n_slides = omega_array.shape[0]
+        svd_rank = omega_array.shape[1]
         omega_rshp = omega_array.reshape(n_slides * svd_rank)
 
-        omega_squared = (np.conj(omega_rshp) * omega_rshp).astype("float")
+        if square_frequencies:
+            omega_squared = (np.conj(omega_rshp) * omega_rshp).astype("float")
+        else:
+            omega_squared = np.abs(omega_rshp.imag.astype("float"))
 
         if kmeans_kwargs is None:
             random_state = 0
@@ -442,16 +458,44 @@ def cluster_omega(self, omega_array, n_components, kmeans_kwargs=None):
         omega_classes = omega_classes.reshape(n_slides, svd_rank)
         cluster_centroids = kmeans.cluster_centers_.flatten()
 
-        return omega_classes, omega_squared, cluster_centroids
+        # Sort the clusters by the centroid magnitude.
+        idx = np.argsort(cluster_centroids)
+        lut = np.zeros_like(idx)
+        lut[idx] = np.arange(n_components)
+        omega_classes = lut[omega_classes]
+        cluster_centroids = cluster_centroids[idx]
+
+        # Assign the results to the object.
+        self._cluster_centroids = cluster_centroids
+        self._omega_classes = omega_classes
+        self._square_frequencies = square_frequencies
+        self._n_components = n_components
+
+        return self
+
+    def plot_omega_squared_histogram(self):
+
+        # Reshape the omega array into a 1d array
+        omega_array = self.omega_array
+        n_slides = omega_array.shape[0]
+        svd_rank = omega_array.shape[1]
+        omega_rshp = omega_array.reshape(n_slides * svd_rank)
+
+        if self._square_frequencies:
+            omega_squared = (np.conj(omega_rshp) * omega_rshp).astype("float")
+            label = "$|\omega|^{2}$"
+        else:
+            omega_squared = np.abs(omega_rshp.imag.astype("float"))
+            label = "$|\omega|$"
+
+        cluster_centroids = self._cluster_centroids
 
-    @staticmethod
-    def plot_omega_squared_histogram(omega_squared, cluster_centroids):
         colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]
         fig, ax = plt.subplots(1, 1)
         ax.hist(omega_squared, bins=64)
-        ax.set_xlabel("$|\omega|^{2}$")
+        ax.set_xlabel(label)
         ax.set_ylabel("Count")
-        ax.set_title("$|\omega|^2$ Spectrum & k-Means Centroids")
+        ax.set_title("$\omega$ Spectrum & k-Means Centroids")
         [
             ax.axvline(c, color=colors[nc % len(colors)])
             for nc, c in enumerate(cluster_centroids)
@@ -459,30 +503,36 @@ def plot_omega_squared_histogram(omega_squared, cluster_centroids):
 
         return fig, ax
 
-    def plot_omega_squared_time_series(self, omega_squared, omega_classes):
+    def plot_omega_squared_time_series(self):
         fig, ax = plt.subplots(1, 1)
         colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]
 
         # Reshape the omega array into a 1d array
-        n_slides = self._n_slides
-        if self._svd_rank == 0:
-            svd_rank = self._n_data_vars
+        omega_array = self.omega_array
+        n_slides = omega_array.shape[0]
+        svd_rank = omega_array.shape[1]
+        omega_rshp = omega_array.reshape(n_slides * svd_rank)
+
+        if self._square_frequencies:
+            omega_squared = (np.conj(omega_rshp) * omega_rshp).astype("float")
+            label = "$|\omega|^{2}$"
         else:
-            svd_rank = self._svd_rank
+            omega_squared = np.abs(omega_rshp.imag.astype("float"))
+            label = "$|\omega|$"
 
         for ncomponent, component in enumerate(range(self._n_components)):
             ax.plot(
                 self._time_means_array,
                 np.where(
-                    omega_classes == component,
+                    self._omega_classes == component,
                     omega_squared.reshape((n_slides, svd_rank)),
                     np.nan,
                 ),
                 color=colors[ncomponent % len(colors)],
             )
-        ax.set_ylabel("$|\omega|^{2}$")
+        ax.set_ylabel(label)
         ax.set_xlabel("Time")
-        ax.set_title("$|\omega|^2$ Spectrum (Moving Window)")
+        ax.set_title("$\omega$ Time Series")
 
         return fig, ax
 
@@ -531,10 +581,10 @@ def global_reconstruction(
 
     def scale_reconstruction(
         self,
-        omega_classes,
-        cluster_centroids,
         suppress_growth=True,
         include_means=True,
+        magnitude_threshold=False,
+        data=None,
     ):
         """Reconstruct the sliding mrDMD into the constituent components.
 
@@ -572,7 +622,7 @@ def scale_reconstruction(
             w = self._modes_array[k]
             b = self._amplitudes_array[k]
             omega = np.atleast_2d(self._omega_array[k]).T
-            classification = omega_classes[k]
+            classification = self._omega_classes[k]
 
             if suppress_growth:
                 omega[omega.real > 0] = 1j * omega[omega.real > 0].imag
@@ -587,7 +637,7 @@ def scale_reconstruction(
             xr_sep_window = np.zeros(
                 (self._n_components, self._n_data_vars, self._window_length)
             )
-            for j in np.unique(omega_classes):
+            for j in np.unique(self._omega_classes):
                 xr_sep_window[j, :, :] = np.linalg.multi_dot(
                     [
                         w[:, classification == j],
@@ -597,7 +647,7 @@ def scale_reconstruction(
                 )
 
                 # Add the constant offset to the lowest frequency cluster.
-                if include_means and (j == np.argmin(cluster_centroids)):
+                if include_means and (j == np.argmin(self._cluster_centroids)):
                     xr_sep_window[j, :, :] += c
                 xr_sep_window[j, :, :] = xr_sep_window[j, :, :] * recon_filter
 
@@ -616,4 +666,113 @@ def scale_reconstruction(
 
         xr_sep = xr_sep / xn
 
+        if magnitude_threshold:
+            if data is None:
+                raise ValueError(
+                    "The data must be provided when doing a magnitude cut-off of modes."
+                )
+            xr_sep = self.threshold_modes(data, xr_sep)
+
         return xr_sep
+
+    def threshold_modes(self, data, xr_sep):
+        """Remove frequency bands that do not contribute significantly to the magnitude of the reconstruction."""
+
+        # Remove scales that do not contribute significantly to the magnitude of the signal
+        n = np.nanmedian(np.abs(xr_sep.real), axis=(1, 2))
+        magnitude_threshold = np.nanmedian(np.abs(data.real)) / 10
+
+        # Trim frequencies bands that do not meet the magnitude threshold.
+        xr_sep = xr_sep[n > magnitude_threshold, ::]
+        self._cluster_centroids = self._cluster_centroids[
+            n > magnitude_threshold
+        ]
+
+        return xr_sep
+
+    def scale_separation(
+        self,
+        scale_reconstruction_kwargs=None,
+    ):
+        """Separate the lowest frequency band from the high frequency bands.
+
+        The lowest frequency band should contain the window means and can be passed on as the data for the next
+        decomposition level. The high frequencies should have frequencies shorter than 1 / window_length.
+
+        """
+
+        if scale_reconstruction_kwargs is None:
+            scale_reconstruction_kwargs = {}
+
+        xr_sep = self.scale_reconstruction(**scale_reconstruction_kwargs)
+        xr_low_frequency = xr_sep[0, :, :]
+        xr_high_frequency = xr_sep[1:, :, :].sum(axis=0)
+
+        return xr_low_frequency, xr_high_frequency
+
+    def plot_scale_separation(self, data, scale_reconstruction_kwargs=None):
+        """Plot the scale-separated low and high frequency bands."""
+        xr_low_frequency, xr_high_frequency = self.scale_separation(
+            data=data, **scale_reconstruction_kwargs
+        )
+
+        fig, axes = plt.subplots(3, 1, sharex=True, figsize=(10, 8))
+
+        ax = axes[0]
+        ax.pcolormesh(data, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.set_title(
+            "Input Data at decomposition window length = {}".format(
+                self._window_length
+            )
+        )
+
+        ax = axes[2]
+        ax.set_title("Reconstruction, high frequency")
+        ax.pcolormesh(xr_high_frequency, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.set_ylabel("Space (-)")
+        ax.set_xlabel("Time (-)")
+
+        ax = axes[1]
+        ax.set_title("Reconstruction, low frequency")
+        ax.pcolormesh(xr_low_frequency, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.set_ylabel("Space (-)")
+        ax.set_xlabel("Time (-)")
+
+        fig.tight_layout()
+
+    def plot_reconstructions(
+        self, data, plot_period=False, scale_reconstruction_kwargs=None
+    ):
+        if scale_reconstruction_kwargs is None:
+            scale_reconstruction_kwargs = {}
+
+        xr_sep = self.scale_reconstruction(
+            data=data, **scale_reconstruction_kwargs
+        )
+
+        fig, axes = plt.subplots(
+            len(self._cluster_centroids) + 1, 1, sharex=True, figsize=(10, 10)
+        )
+
+        ax = axes[0]
+        ax.pcolormesh(data.real, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.set_ylabel("Space (-)")
+        ax.set_xlabel("Time (-)")
+        ax.set_title("Input Data")
+
+        for n_cluster, cluster in enumerate(self._cluster_centroids):
+            if plot_period:
+                x = 2 * np.pi / cluster
+                title = "Reconstruction, central period={:.2f}"
+            else:
+                x = cluster
+                title = "Reconstruction, central eig={:.2f}"
+
+            ax = axes[n_cluster + 1]
+            xr_scale = xr_sep[n_cluster, :, :]
+            ax.pcolormesh(xr_scale, cmap="RdBu_r", vmin=-2, vmax=2)
+            ax.set_ylabel("Space (-)")
+            ax.set_xlabel("Time (-)")
+            ax.set_title(title.format(x))
+
+        fig.tight_layout()

From c6bf12a4aa46fde4394e23b3621156531a28096e Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Fri, 21 Apr 2023 14:53:21 +0200
Subject: [PATCH 11/31] Fix: mode trimming and clsutering results

- Add a sorted list of labels for cluster labels, useful for trimming
- Fixed mode trimming and added a flag for resetting trimming.
---
 pydmd/costsdmd.py | 37 +++++++++++++++++++++++++------------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 3f4ddc0c4..16e19f456 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -470,6 +470,8 @@ def cluster_omega(
         self._omega_classes = omega_classes
         self._square_frequencies = square_frequencies
         self._n_components = n_components
+        self._class_values = np.unique(omega_classes)[idx]
+        self._trimmed = False
 
         return self
 
@@ -678,15 +680,22 @@ def scale_reconstruction(
     def threshold_modes(self, data, xr_sep):
         """Remove frequency bands that do not contribute significantly to the magnitude of the reconstruction."""
 
-        # Remove scales that do not contribute significantly to the magnitude of the signal
-        n = np.nanmedian(np.abs(xr_sep.real), axis=(1, 2))
-        magnitude_threshold = np.nanmedian(np.abs(data.real)) / 10
+        if not self._trimmed:
+            # Remove scales that do not contribute significantly to the magnitude of the signal
+            n = np.nanmedian(np.abs(xr_sep.real), axis=(1, 2))
+            magnitude_threshold = np.nanmedian(np.abs(data.real)) / 100
 
-        # Trim frequencies bands that do not meet the magnitude threshold.
-        xr_sep = xr_sep[n > magnitude_threshold, ::]
-        self._cluster_centroids = self._cluster_centroids[
-            n > magnitude_threshold
-        ]
+            # Trim frequencies bands that do not meet the magnitude threshold.
+            xr_sep = xr_sep[n > magnitude_threshold, ::]
+            self._cluster_centroids = self._cluster_centroids[
+                n > magnitude_threshold
+            ]
+            num_modes_to_keep = np.sum(n > magnitude_threshold)
+            self._class_values = self._class_values[
+                self._class_values < num_modes_to_keep
+            ]
+
+            self._trimmed = True
 
         return xr_sep
 
@@ -712,8 +721,14 @@ def scale_separation(
 
     def plot_scale_separation(self, data, scale_reconstruction_kwargs=None):
         """Plot the scale-separated low and high frequency bands."""
+        if scale_reconstruction_kwargs is None:
+            scale_reconstruction_kwargs = {}
+        scale_reconstruction_kwargs["data"] = scale_reconstruction_kwargs.get(
+            "data", data
+        )
+
         xr_low_frequency, xr_high_frequency = self.scale_separation(
-            data=data, **scale_reconstruction_kwargs
+            scale_reconstruction_kwargs
         )
 
         fig, axes = plt.subplots(3, 1, sharex=True, figsize=(10, 8))
@@ -746,9 +761,7 @@ def plot_reconstructions(
         if scale_reconstruction_kwargs is None:
             scale_reconstruction_kwargs = {}
 
-        xr_sep = self.scale_reconstruction(
-            data=data, **scale_reconstruction_kwargs
-        )
+        xr_sep = self.scale_reconstruction(scale_reconstruction_kwargs)
 
         fig, axes = plt.subplots(
             len(self._cluster_centroids) + 1, 1, sharex=True, figsize=(10, 10)

From 532d8760db297a34ebf7f3c70f692f846d9eca55 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Mon, 24 Apr 2023 16:42:10 +0200
Subject: [PATCH 12/31] Doc: Added to docstring, reorganized class, added
 residuals plot

- Documented several new additions to the doc string
- Reorganized the class to have properties first.
- Added the ability to include residuals to the reconstruction plots.
---
 pydmd/costsdmd.py | 215 ++++++++++++++++++++++++++++------------------
 1 file changed, 130 insertions(+), 85 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 16e19f456..cd733bd92 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -6,7 +6,7 @@
 
 
 class CostsDMD:
-    """Coherent Spatio-Temporal Scale Separation with DMD
+    """Coherent Spatio-Temporal Scale Separation with DMD.
 
     :param window_length: Length of the analysis window in number of time steps.
     :type window_length: int
@@ -26,7 +26,7 @@ class CostsDMD:
         previous iteration) through the `cluster_centroids` keyword. Default is False.
     :type initialize_artificially: bool
     :param pydmd_kwargs: Keyword arguments to pass onto the BOPDMD object.
-    :type global_svd: dict
+    :type pydmd_kwargs: dict
     :param cluster_centroids: Cluster centroids from a previous fitting iteration to
         use for the initial guess of the eigenvalues. Should only be the imaginary
         component.
@@ -41,10 +41,22 @@ class CostsDMD:
     :param max_rank: Maximum svd_rank allowed when the svd_rank is found through rank
         truncation (i.e., svd_rank=0).
     :type max_rank: int
-    :param use_kmean_freqs:
+    :param use_kmean_freqs: Flag specifying if the BOPDMD fit should use initial values
+        taken from cluster centroids, e.g., from a previoius iteration.
     :type use_kmean_freqs: bool
-    :param init_alpha:
+    :param init_alpha: Initial guess for the eigenvalues provided to BOPDMD. Must be equal
+        to the `svd_rank`.
     :type init_alpha: numpy array
+    :param max_rank: Maximum allowed `svd_rank`. Overrides the optimal rank truncation if
+        `svd_rank=0`.
+    :type max_rank: int
+    :param n_components: Number of frequency bands to use for clustering.
+    :type n_components: int
+    :param force_even_eigs: Flag specifying if the `svd_rank` should be forced to be even.
+    :type force_even_eigs: bool
+    :param reset_alpha_init: Flag specifying if the initial eigenvalue guess should be reset
+        between windows.
+    :type reset_alpha_init: bool
     """
 
     def __init__(
@@ -92,6 +104,7 @@ def __init__(
         self._cluster_centroids = None
         self._omega_classes = None
 
+        # Specify default keywords to hand to BOPDMD.
         if pydmd_kwargs is None:
             self._pydmd_kwargs = {
                 "eig_sort": "imag",
@@ -108,6 +121,74 @@ def __init__(
             )
             self._pydmd_kwargs["use_proj"] = pydmd_kwargs.get("use_proj", False)
 
+    @property
+    def svd_rank(self):
+        """
+        :return: the rank used for the svd truncation.
+        :rtype: int or float
+        """
+        return self._svd_rank
+
+    @property
+    def modes_array(self):
+        if not hasattr(self, "_modes_array"):
+            raise ValueError("You need to call fit before")
+        return self._modes_array
+
+    @property
+    def amplitudes_array(self):
+        if not hasattr(self, "_amplitudes_array"):
+            raise ValueError("You need to call fit first.")
+        return self._amplitudes_array
+
+    @property
+    def omega_array(self):
+        if not hasattr(self, "_omega_array"):
+            raise ValueError("You need to call fit first.")
+        return self._omega_array
+
+    @property
+    def time_array(self):
+        if not hasattr(self, "_time_array"):
+            raise ValueError("You need to call fit first.")
+        return self._time_array
+
+    @property
+    def window_means_array(self):
+        if not hasattr(self, "_window_means_array"):
+            raise ValueError("You need to call fit first.")
+        return self._window_means_array
+
+    @property
+    def t_starts_array(self):
+        if not hasattr(self, "_t_starts_array"):
+            raise ValueError("You need to call fit first.")
+        return self._t_starts_array
+
+    @property
+    def time_means_array(self):
+        if not hasattr(self, "_time_means_array"):
+            raise ValueError("You need to call fit first.")
+        return self._time_means_array
+
+    @property
+    def n_components(self):
+        if not hasattr(self, "_n_components"):
+            raise ValueError("You need to call `cluster_omega()` first.")
+        return self._n_components
+
+    @property
+    def cluster_centroids(self):
+        if not hasattr(self, "_cluster_centroids"):
+            raise ValueError("You need to call `cluster_omega()` first.")
+        return self._cluster_centroids
+
+    @property
+    def omega_classes(self):
+        if not hasattr(self, "_omega_classes"):
+            raise ValueError("You need to call `cluster_omega()` first.")
+        return self._omega_classes
+
     def _compute_svd_rank(self, data, svd_rank=None):
         def omega(x):
             return 0.56 * x**3 - 0.95 * x**2 + 1.82 * x + 1.43
@@ -212,74 +293,6 @@ def _data_shape(self, data):
         n_data_vars = np.shape(data)[0]
         return n_time_steps, n_data_vars
 
-    @property
-    def svd_rank(self):
-        """
-        :return: the rank used for the svd truncation.
-        :rtype: int or float
-        """
-        return self._svd_rank
-
-    @property
-    def modes_array(self):
-        if not hasattr(self, "_modes_array"):
-            raise ValueError("You need to call fit before")
-        return self._modes_array
-
-    @property
-    def amplitudes_array(self):
-        if not hasattr(self, "_amplitudes_array"):
-            raise ValueError("You need to call fit first.")
-        return self._amplitudes_array
-
-    @property
-    def omega_array(self):
-        if not hasattr(self, "_omega_array"):
-            raise ValueError("You need to call fit first.")
-        return self._omega_array
-
-    @property
-    def time_array(self):
-        if not hasattr(self, "_time_array"):
-            raise ValueError("You need to call fit first.")
-        return self._time_array
-
-    @property
-    def window_means_array(self):
-        if not hasattr(self, "_window_means_array"):
-            raise ValueError("You need to call fit first.")
-        return self._window_means_array
-
-    @property
-    def t_starts_array(self):
-        if not hasattr(self, "_t_starts_array"):
-            raise ValueError("You need to call fit first.")
-        return self._t_starts_array
-
-    @property
-    def time_means_array(self):
-        if not hasattr(self, "_time_means_array"):
-            raise ValueError("You need to call fit first.")
-        return self._time_means_array
-
-    @property
-    def n_components(self):
-        if not hasattr(self, "_n_components"):
-            raise ValueError("You need to call `cluster_omega()` first.")
-        return self._n_components
-
-    @property
-    def cluster_centroids(self):
-        if not hasattr(self, "_cluster_centroids"):
-            raise ValueError("You need to call `cluster_omega()` first.")
-        return self._cluster_centroids
-
-    @property
-    def omega_classes(self):
-        if not hasattr(self, "_omega_classes"):
-            raise ValueError("You need to call `cluster_omega()` first.")
-        return self._omega_classes
-
     def fit(
         self,
         data,
@@ -719,7 +732,9 @@ def scale_separation(
 
         return xr_low_frequency, xr_high_frequency
 
-    def plot_scale_separation(self, data, scale_reconstruction_kwargs=None):
+    def plot_scale_separation(
+        self, data, scale_reconstruction_kwargs=None, plot_residual=False
+    ):
         """Plot the scale-separated low and high frequency bands."""
         if scale_reconstruction_kwargs is None:
             scale_reconstruction_kwargs = {}
@@ -731,7 +746,10 @@ def plot_scale_separation(self, data, scale_reconstruction_kwargs=None):
             scale_reconstruction_kwargs
         )
 
-        fig, axes = plt.subplots(3, 1, sharex=True, figsize=(10, 8))
+        if plot_residual:
+            fig, axes = plt.subplots(4, 1, sharex=True, figsize=(6, 4))
+        else:
+            fig, axes = plt.subplots(3, 1, sharex=True, figsize=(6, 4))
 
         ax = axes[0]
         ax.pcolormesh(data, cmap="RdBu_r", vmin=-2, vmax=2)
@@ -740,23 +758,36 @@ def plot_scale_separation(self, data, scale_reconstruction_kwargs=None):
                 self._window_length
             )
         )
+        ax = axes[1]
+        ax.set_title("Reconstruction, low frequency")
+        ax.pcolormesh(xr_low_frequency, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.set_ylabel("Space (-)")
 
         ax = axes[2]
         ax.set_title("Reconstruction, high frequency")
         ax.pcolormesh(xr_high_frequency, cmap="RdBu_r", vmin=-2, vmax=2)
         ax.set_ylabel("Space (-)")
-        ax.set_xlabel("Time (-)")
 
-        ax = axes[1]
-        ax.set_title("Reconstruction, low frequency")
-        ax.pcolormesh(xr_low_frequency, cmap="RdBu_r", vmin=-2, vmax=2)
-        ax.set_ylabel("Space (-)")
-        ax.set_xlabel("Time (-)")
+        if plot_residual:
+            ax = axes[3]
+            ax.set_title("Residual")
+            ax.pcolormesh(
+                data - xr_high_frequency - xr_low_frequency,
+                cmap="RdBu_r",
+                vmin=-2,
+                vmax=2,
+            )
+            ax.set_ylabel("Space (-)")
 
+        axes[-1].set_xlabel("Time (-)")
         fig.tight_layout()
 
     def plot_reconstructions(
-        self, data, plot_period=False, scale_reconstruction_kwargs=None
+        self,
+        data,
+        plot_period=False,
+        scale_reconstruction_kwargs=None,
+        plot_residual=False,
     ):
         if scale_reconstruction_kwargs is None:
             scale_reconstruction_kwargs = {}
@@ -764,15 +795,18 @@ def plot_reconstructions(
         xr_sep = self.scale_reconstruction(scale_reconstruction_kwargs)
 
         fig, axes = plt.subplots(
-            len(self._cluster_centroids) + 1, 1, sharex=True, figsize=(10, 10)
+            len(self._cluster_centroids) + 1, 1, sharex=True, figsize=(6, 6)
         )
 
         ax = axes[0]
         ax.pcolormesh(data.real, cmap="RdBu_r", vmin=-2, vmax=2)
         ax.set_ylabel("Space (-)")
         ax.set_xlabel("Time (-)")
-        ax.set_title("Input Data")
-
+        ax.set_title(
+            "Input Data at decomposition window length = {}".format(
+                self._window_length
+            )
+        )
         for n_cluster, cluster in enumerate(self._cluster_centroids):
             if plot_period:
                 x = 2 * np.pi / cluster
@@ -785,7 +819,18 @@ def plot_reconstructions(
             xr_scale = xr_sep[n_cluster, :, :]
             ax.pcolormesh(xr_scale, cmap="RdBu_r", vmin=-2, vmax=2)
             ax.set_ylabel("Space (-)")
-            ax.set_xlabel("Time (-)")
             ax.set_title(title.format(x))
 
+        if plot_residual:
+            ax = axes[-1]
+            ax.set_title("Residual")
+            ax.pcolormesh(
+                data - xr_sep.sum(axis=0),
+                cmap="RdBu_r",
+                vmin=-2,
+                vmax=2,
+            )
+            ax.set_ylabel("Space (-)")
+
+        axes[-1].set_xlabel("Time (-)")
         fig.tight_layout()

From ad91181da62ee62fd3a22b3146b372b6f70f70aa Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 25 Apr 2023 16:04:47 +0200
Subject: [PATCH 13/31] Plot fix for scale separated reconstruction

---
 pydmd/costsdmd.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index cd733bd92..3309d0a22 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -795,7 +795,10 @@ def plot_reconstructions(
         xr_sep = self.scale_reconstruction(scale_reconstruction_kwargs)
 
         fig, axes = plt.subplots(
-            len(self._cluster_centroids) + 1, 1, sharex=True, figsize=(6, 6)
+            len(self._cluster_centroids) + 1,
+            1,
+            sharex=True,
+            figsize=(6, 1.5 * len(self._cluster_centroids) + 1),
         )
 
         ax = axes[0]

From a11133351213b9ec66646c00e94bd0a29001f357 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 25 Apr 2023 16:10:54 +0200
Subject: [PATCH 14/31] Fix: Global reconstruction uses correct gaussian
 weighting

- matlab code and previous versions did not do the correct weighting
of each window by a gaussian, as described in the paper or implemented
for the scale separated reconstruction (e.g., high vs low frequency).
The global reconstruction now just sums up the individual reconstructed
components, using the gaussian weighting.
---
 pydmd/costsdmd.py | 49 +++++++----------------------------------------
 1 file changed, 7 insertions(+), 42 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 3309d0a22..edcd98fed 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -551,48 +551,13 @@ def plot_omega_squared_time_series(self):
 
         return fig, ax
 
-    def global_reconstruction(
-        self,
-    ):
-        # Container for the reconstructed time series
-        glbl_reconstruction = np.zeros(
-            (self._n_data_vars, self._n_time_steps)
-        ).astype("complex128")
-
-        # Count the number of windows contributing to each step
-        xn = np.zeros(self._n_time_steps)
-
-        for k in range(self._n_slides):
-            # Extract out the DMD fit for this window.
-            w = self._modes_array[k]
-            b = self._amplitudes_array[k]
-            omega = np.atleast_2d(self._omega_array[k]).T
-            c = np.atleast_2d(self._window_means_array[k]).T
-
-            # Compute each segment starting at t=0
-            t = self._time_array[k]
-            t_start = self._t_starts_array[k]
-            t = t - t_start
-
-            # Perform the global reconstruction.
-            recon_window = (
-                np.linalg.multi_dot([w, np.diag(b), np.exp(omega * t)]) + c
-            )
-
-            if k == self._n_slides - 1 and self._n_slide_last_window > 0:
-                window_indices = slice(-self._window_length, None)
-            else:
-                window_indices = slice(
-                    k * self._step_size,
-                    k * self._step_size + self._window_length,
-                )
-            glbl_reconstruction[:, window_indices] += recon_window
-            xn[window_indices] += 1
-
-        # Weight xr so all steps are on equal footing
-        glbl_reconstruction = glbl_reconstruction / xn
-
-        return glbl_reconstruction
+    def global_reconstruction(self, kwargs=None):
+        """Helper function for generating the global reconstruction."""
+        if kwargs is None:
+            kwargs = {}
+        xr_sep = self.scale_reconstruction(**kwargs)
+        x_global_recon = xr_sep.sum(axis=0)
+        return x_global_recon
 
     def scale_reconstruction(
         self,

From f5d7e04413a93317cd8b16a1ecb5bf5bc781f550 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 25 Apr 2023 18:40:09 +0200
Subject: [PATCH 15/31] Renamed plotting function

---
 pydmd/costsdmd.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index edcd98fed..4b7e73298 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -103,6 +103,7 @@ def __init__(
         self._t_starts_array = None
         self._cluster_centroids = None
         self._omega_classes = None
+        self._square_frequencies = None
 
         # Specify default keywords to hand to BOPDMD.
         if pydmd_kwargs is None:
@@ -488,7 +489,7 @@ def cluster_omega(
 
         return self
 
-    def plot_omega_squared_histogram(self):
+    def plot_omega_histogram(self):
 
         # Reshape the omega array into a 1d array
         omega_array = self.omega_array

From 9eb521e461a6eecb915965dbadedc1047e91bacf Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Wed, 26 Apr 2023 11:53:46 +0200
Subject: [PATCH 16/31] Feat: hyperparameter sweep for n clusters

- Hyperparameter sweep function for finding the optimal number of
  clusters in the kmeans clustering of window frequencies. Uses the
silhouette score.
---
 pydmd/costsdmd.py | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 4b7e73298..3ce39e04f 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -2,6 +2,7 @@
 from pydmd.bopdmd import BOPDMD
 import scipy
 from sklearn.cluster import KMeans
+from sklearn.metrics import silhouette_score
 import matplotlib.pyplot as plt
 
 
@@ -489,6 +490,35 @@ def cluster_omega(
 
         return self
 
+    def cluster_hyperparameter_sweep(
+        self, n_components_range=None, square_frequencies=False
+    ):
+        """Performs a hyperparameter search for the number of components in the kmeans clustering."""
+        if n_components_range is None:
+            n_components_range = np.arange(self.svd_rank // 4, self.svd_rank)
+        score = np.zeros_like(n_components_range, float)
+
+        # Reshape the omega array into a 1d array
+        omega_array = self.omega_array
+        n_slides = omega_array.shape[0]
+        svd_rank = omega_array.shape[1]
+        omega_rshp = omega_array.reshape(n_slides * svd_rank)
+        if square_frequencies:
+            omega_squared = (np.conj(omega_rshp) * omega_rshp).astype("float")
+        else:
+            omega_squared = np.abs(omega_rshp.imag.astype("float"))
+
+        for nind, n in enumerate(n_components_range):
+            _ = self.cluster_omega(n_components=n, square_frequencies=False)
+
+            classes_reshape = self.omega_classes.reshape(n_slides * svd_rank)
+
+            score[nind] = silhouette_score(
+                np.atleast_2d(omega_squared).T, np.atleast_2d(classes_reshape).T
+            )
+
+        return n_components_range[np.argmax(score)]
+
     def plot_omega_histogram(self):
 
         # Reshape the omega array into a 1d array

From 1e64ed4664f172b7537fab66c7020e065189bbf6 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 2 May 2023 17:31:10 +0200
Subject: [PATCH 17/31] Feat: Added `to_xarray` method for class

- to_xarray allows converting results to an xarray Dataset, enabling in
  and out functions with netcdfs and the powerful alignment tools for
comparing between decomposition levels.
---
 pydmd/costsdmd.py | 89 ++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 80 insertions(+), 9 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 3ce39e04f..961203649 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -4,6 +4,7 @@
 from sklearn.cluster import KMeans
 from sklearn.metrics import silhouette_score
 import matplotlib.pyplot as plt
+import xarray as xr
 
 
 class CostsDMD:
@@ -334,6 +335,10 @@ def fit(
             )
             svd_rank_pre_allocate = self._svd_rank
         elif not self._global_svd and self._svd_rank > 0:
+            if self._force_even_eigs and self._svd_rank % 2:
+                raise ValueError(
+                    "svd_rank is odd, but force_even_eigs is True."
+                )
             svd_rank_pre_allocate = self._compute_svd_rank(
                 data, svd_rank=self._svd_rank
             )
@@ -383,14 +388,7 @@ def fit(
                 if k // 50 == k / 50:
                     print("{} of {}".format(k, self._n_slides))
 
-            # Get the window indices and data.
-            sample_start = self._step_size * k
-            if k == self._n_slides - 1 and self._n_slide_last_window > 0:
-                sample_slice = slice(-self._window_length, None)
-            else:
-                sample_slice = slice(
-                    sample_start, sample_start + self._window_length
-                )
+            sample_slice = self.get_window_indices(k)
             data_window = data[:, sample_slice]
             original_time_window = time[:, sample_slice]
             time_window_mean = np.mean(original_time_window)
@@ -414,7 +412,7 @@ def fit(
                     data_window, svd_rank=self._svd_rank
                 )
                 # Force svd rank to be even to allow for conjugate pairs.
-                if _svd_rank % 2:
+                if self._force_even_eigs and _svd_rank % 2:
                     _svd_rank += 1
                 # Force svd rank to not exceed a user specified amount.
                 if self._max_rank is not None:
@@ -447,6 +445,21 @@ def fit(
                 elif self._use_last_freq:
                     optdmd.init_alpha = optdmd.eigs
 
+    def get_window_indices(self, k):
+        """
+
+        @return:
+        """
+        # Get the window indices and data.
+        sample_start = self._step_size * k
+        if k == self._n_slides - 1 and self._n_slide_last_window > 0:
+            sample_slice = slice(-self._window_length, None)
+        else:
+            sample_slice = slice(
+                sample_start, sample_start + self._window_length
+            )
+        return sample_slice
+
     def cluster_omega(
         self, n_components, kmeans_kwargs=None, square_frequencies=True
     ):
@@ -833,3 +846,61 @@ def plot_reconstructions(
 
         axes[-1].set_xlabel("Time (-)")
         fig.tight_layout()
+
+        return fig, axes
+
+    def to_xarray(self):
+        """Build an xarray dataset from the fitted CoSTS object.
+
+        The CoSTS object is converted to an xarray dataset, which allows
+        saving the computationally expensive results, e.g., between iterations.
+
+        The reconstructed data are not included since their size can rapidly
+        explode to unexpected sizes. e.g., a 30MB dataset, decomposed at 6
+        levels with an average number of frequency bands across decomposition
+        levels equal to 8 becomes 1.3GB once reconstructed for each band.
+
+        """
+        ds = xr.Dataset(
+            {
+                "omega": (("window_time_means", "rank"), self.omega_array),
+                "omega_classes": (
+                    ("window_time_means", "rank"),
+                    self.omega_classes,
+                ),
+                "amplitudes": (
+                    ("window_time_means", "rank"),
+                    self.amplitudes_array,
+                ),
+                "modes": (
+                    ("window_time_means", "space", "rank"),
+                    self.modes_array,
+                ),
+                "window_means": (
+                    ("window_time_means", "space"),
+                    self.window_means_array,
+                ),
+                "cluster_centroids": (
+                    "frequency_band",
+                    self._cluster_centroids,
+                ),
+            },
+            coords={
+                "window_time_means": self.time_means_array,
+                "slide": ("window_time_means", np.arange(self._n_slides)),
+                "rank": np.arange(self.svd_rank),
+                "space": np.arange(self._n_data_vars),
+                "frequency_band": np.arange(self.n_components),
+            },
+            attrs={
+                "svd_rank": self.svd_rank,
+                "square_frequencies": self._square_frequencies,
+                "n_slides": self._n_slides,
+                "window_length": self._window_length,
+                "num_frequency_bands": self.n_components,
+                "n_data_vars": self._n_data_vars,
+                "n_time_steps": self._n_time_steps,
+            },
+        )
+
+        return ds

From fad681315241912cd52452a1c488619f73ec650b Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 9 May 2023 13:33:02 +0200
Subject: [PATCH 18/31] Fix: Force n_components > 1 and plot kwargs

- In the hyperparameter sweep for the optimal number of clusters, a
  cluster size of 1 causes an error. For the case with a small svd_rank
the automatic selection of clusters is forced to be larger than one.
- Plotting functions now accept plot_kwargs and fig_kwargs controlling
  the appearance of the plots and the figures, respectively.
---
 pydmd/costsdmd.py | 66 ++++++++++++++++++++++++++++++++---------------
 1 file changed, 45 insertions(+), 21 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 961203649..ccd52badb 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -508,7 +508,9 @@ def cluster_hyperparameter_sweep(
     ):
         """Performs a hyperparameter search for the number of components in the kmeans clustering."""
         if n_components_range is None:
-            n_components_range = np.arange(self.svd_rank // 4, self.svd_rank)
+            n_components_range = np.arange(
+                np.max((self.svd_rank // 4, 2)), self.svd_rank
+            )
         score = np.zeros_like(n_components_range, float)
 
         # Reshape the omega array into a 1d array
@@ -742,7 +744,12 @@ def scale_separation(
         return xr_low_frequency, xr_high_frequency
 
     def plot_scale_separation(
-        self, data, scale_reconstruction_kwargs=None, plot_residual=False
+        self,
+        data,
+        scale_reconstruction_kwargs=None,
+        plot_residual=False,
+        fig_kwargs=None,
+        plot_kwargs=None,
     ):
         """Plot the scale-separated low and high frequency bands."""
         if scale_reconstruction_kwargs is None:
@@ -755,13 +762,24 @@ def plot_scale_separation(
             scale_reconstruction_kwargs
         )
 
+        if fig_kwargs is None:
+            fig_kwargs = {}
+        fig_kwargs["sharex"] = fig_kwargs.get("sharex", True)
+        fig_kwargs["figsize"] = fig_kwargs.get("figsize", (6, 4))
+
+        if plot_kwargs is None:
+            plot_kwargs = {}
+        plot_kwargs["vmin"] = plot_kwargs.get("vmin", -np.abs(data).max())
+        plot_kwargs["vmax"] = plot_kwargs.get("vmax", np.abs(data).max())
+        plot_kwargs["cmap"] = plot_kwargs.get("cmap", "RdBu_r")
+
         if plot_residual:
-            fig, axes = plt.subplots(4, 1, sharex=True, figsize=(6, 4))
+            fig, axes = plt.subplots(4, 1, **fig_kwargs)
         else:
-            fig, axes = plt.subplots(3, 1, sharex=True, figsize=(6, 4))
+            fig, axes = plt.subplots(3, 1, **fig_kwargs)
 
         ax = axes[0]
-        ax.pcolormesh(data, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.pcolormesh(data, **plot_kwargs)
         ax.set_title(
             "Input Data at decomposition window length = {}".format(
                 self._window_length
@@ -769,22 +787,19 @@ def plot_scale_separation(
         )
         ax = axes[1]
         ax.set_title("Reconstruction, low frequency")
-        ax.pcolormesh(xr_low_frequency, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.pcolormesh(xr_low_frequency, **plot_kwargs)
         ax.set_ylabel("Space (-)")
 
         ax = axes[2]
         ax.set_title("Reconstruction, high frequency")
-        ax.pcolormesh(xr_high_frequency, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.pcolormesh(xr_high_frequency, **plot_kwargs)
         ax.set_ylabel("Space (-)")
 
         if plot_residual:
             ax = axes[3]
             ax.set_title("Residual")
             ax.pcolormesh(
-                data - xr_high_frequency - xr_low_frequency,
-                cmap="RdBu_r",
-                vmin=-2,
-                vmax=2,
+                data - xr_high_frequency - xr_low_frequency, **plot_kwargs
             )
             ax.set_ylabel("Space (-)")
 
@@ -797,21 +812,35 @@ def plot_reconstructions(
         plot_period=False,
         scale_reconstruction_kwargs=None,
         plot_residual=False,
+        fig_kwargs=None,
+        plot_kwargs=None,
     ):
         if scale_reconstruction_kwargs is None:
             scale_reconstruction_kwargs = {}
 
         xr_sep = self.scale_reconstruction(scale_reconstruction_kwargs)
 
+        if fig_kwargs is None:
+            fig_kwargs = {}
+        fig_kwargs["sharex"] = fig_kwargs.get("sharex", True)
+        fig_kwargs["figsize"] = fig_kwargs.get(
+            "figsize", (6, 1.5 * len(self._cluster_centroids) + 1)
+        )
+
+        if plot_kwargs is None:
+            plot_kwargs = {}
+        plot_kwargs["vmin"] = plot_kwargs.get("vmin", -np.abs(data).max())
+        plot_kwargs["vmax"] = plot_kwargs.get("vmax", np.abs(data).max())
+        plot_kwargs["cmap"] = plot_kwargs.get("cmap", "RdBu_r")
+
         fig, axes = plt.subplots(
             len(self._cluster_centroids) + 1,
             1,
-            sharex=True,
-            figsize=(6, 1.5 * len(self._cluster_centroids) + 1),
+            **fig_kwargs,
         )
 
         ax = axes[0]
-        ax.pcolormesh(data.real, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.pcolormesh(data.real, **plot_kwargs)
         ax.set_ylabel("Space (-)")
         ax.set_xlabel("Time (-)")
         ax.set_title(
@@ -829,19 +858,14 @@ def plot_reconstructions(
 
             ax = axes[n_cluster + 1]
             xr_scale = xr_sep[n_cluster, :, :]
-            ax.pcolormesh(xr_scale, cmap="RdBu_r", vmin=-2, vmax=2)
+            ax.pcolormesh(xr_scale, **plot_kwargs)
             ax.set_ylabel("Space (-)")
             ax.set_title(title.format(x))
 
         if plot_residual:
             ax = axes[-1]
             ax.set_title("Residual")
-            ax.pcolormesh(
-                data - xr_sep.sum(axis=0),
-                cmap="RdBu_r",
-                vmin=-2,
-                vmax=2,
-            )
+            ax.pcolormesh(data - xr_sep.sum(axis=0), **plot_kwargs)
             ax.set_ylabel("Space (-)")
 
         axes[-1].set_xlabel("Time (-)")

From e0d0e76fdde7eae981230ab802f2233a14ea44d6 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 9 May 2023 13:33:02 +0200
Subject: [PATCH 19/31] Fix: Force n_components > 1 and plot kwargs

- In the hyperparameter sweep for the optimal number of clusters, a
  cluster size of 1 causes an error. For the case with a small svd_rank
the automatic selection of clusters is forced to be larger than one.
- Plotting functions now accept plot_kwargs and fig_kwargs controlling
  the appearance of the plots and the figures, respectively.
---
 pydmd/costsdmd.py | 66 ++++++++++++++++++++++++++++++++---------------
 1 file changed, 45 insertions(+), 21 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 961203649..ccd52badb 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -508,7 +508,9 @@ def cluster_hyperparameter_sweep(
     ):
         """Performs a hyperparameter search for the number of components in the kmeans clustering."""
         if n_components_range is None:
-            n_components_range = np.arange(self.svd_rank // 4, self.svd_rank)
+            n_components_range = np.arange(
+                np.max((self.svd_rank // 4, 2)), self.svd_rank
+            )
         score = np.zeros_like(n_components_range, float)
 
         # Reshape the omega array into a 1d array
@@ -742,7 +744,12 @@ def scale_separation(
         return xr_low_frequency, xr_high_frequency
 
     def plot_scale_separation(
-        self, data, scale_reconstruction_kwargs=None, plot_residual=False
+        self,
+        data,
+        scale_reconstruction_kwargs=None,
+        plot_residual=False,
+        fig_kwargs=None,
+        plot_kwargs=None,
     ):
         """Plot the scale-separated low and high frequency bands."""
         if scale_reconstruction_kwargs is None:
@@ -755,13 +762,24 @@ def plot_scale_separation(
             scale_reconstruction_kwargs
         )
 
+        if fig_kwargs is None:
+            fig_kwargs = {}
+        fig_kwargs["sharex"] = fig_kwargs.get("sharex", True)
+        fig_kwargs["figsize"] = fig_kwargs.get("figsize", (6, 4))
+
+        if plot_kwargs is None:
+            plot_kwargs = {}
+        plot_kwargs["vmin"] = plot_kwargs.get("vmin", -np.abs(data).max())
+        plot_kwargs["vmax"] = plot_kwargs.get("vmax", np.abs(data).max())
+        plot_kwargs["cmap"] = plot_kwargs.get("cmap", "RdBu_r")
+
         if plot_residual:
-            fig, axes = plt.subplots(4, 1, sharex=True, figsize=(6, 4))
+            fig, axes = plt.subplots(4, 1, **fig_kwargs)
         else:
-            fig, axes = plt.subplots(3, 1, sharex=True, figsize=(6, 4))
+            fig, axes = plt.subplots(3, 1, **fig_kwargs)
 
         ax = axes[0]
-        ax.pcolormesh(data, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.pcolormesh(data, **plot_kwargs)
         ax.set_title(
             "Input Data at decomposition window length = {}".format(
                 self._window_length
@@ -769,22 +787,19 @@ def plot_scale_separation(
         )
         ax = axes[1]
         ax.set_title("Reconstruction, low frequency")
-        ax.pcolormesh(xr_low_frequency, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.pcolormesh(xr_low_frequency, **plot_kwargs)
         ax.set_ylabel("Space (-)")
 
         ax = axes[2]
         ax.set_title("Reconstruction, high frequency")
-        ax.pcolormesh(xr_high_frequency, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.pcolormesh(xr_high_frequency, **plot_kwargs)
         ax.set_ylabel("Space (-)")
 
         if plot_residual:
             ax = axes[3]
             ax.set_title("Residual")
             ax.pcolormesh(
-                data - xr_high_frequency - xr_low_frequency,
-                cmap="RdBu_r",
-                vmin=-2,
-                vmax=2,
+                data - xr_high_frequency - xr_low_frequency, **plot_kwargs
             )
             ax.set_ylabel("Space (-)")
 
@@ -797,21 +812,35 @@ def plot_reconstructions(
         plot_period=False,
         scale_reconstruction_kwargs=None,
         plot_residual=False,
+        fig_kwargs=None,
+        plot_kwargs=None,
     ):
         if scale_reconstruction_kwargs is None:
             scale_reconstruction_kwargs = {}
 
         xr_sep = self.scale_reconstruction(scale_reconstruction_kwargs)
 
+        if fig_kwargs is None:
+            fig_kwargs = {}
+        fig_kwargs["sharex"] = fig_kwargs.get("sharex", True)
+        fig_kwargs["figsize"] = fig_kwargs.get(
+            "figsize", (6, 1.5 * len(self._cluster_centroids) + 1)
+        )
+
+        if plot_kwargs is None:
+            plot_kwargs = {}
+        plot_kwargs["vmin"] = plot_kwargs.get("vmin", -np.abs(data).max())
+        plot_kwargs["vmax"] = plot_kwargs.get("vmax", np.abs(data).max())
+        plot_kwargs["cmap"] = plot_kwargs.get("cmap", "RdBu_r")
+
         fig, axes = plt.subplots(
             len(self._cluster_centroids) + 1,
             1,
-            sharex=True,
-            figsize=(6, 1.5 * len(self._cluster_centroids) + 1),
+            **fig_kwargs,
         )
 
         ax = axes[0]
-        ax.pcolormesh(data.real, cmap="RdBu_r", vmin=-2, vmax=2)
+        ax.pcolormesh(data.real, **plot_kwargs)
         ax.set_ylabel("Space (-)")
         ax.set_xlabel("Time (-)")
         ax.set_title(
@@ -829,19 +858,14 @@ def plot_reconstructions(
 
             ax = axes[n_cluster + 1]
             xr_scale = xr_sep[n_cluster, :, :]
-            ax.pcolormesh(xr_scale, cmap="RdBu_r", vmin=-2, vmax=2)
+            ax.pcolormesh(xr_scale, **plot_kwargs)
             ax.set_ylabel("Space (-)")
             ax.set_title(title.format(x))
 
         if plot_residual:
             ax = axes[-1]
             ax.set_title("Residual")
-            ax.pcolormesh(
-                data - xr_sep.sum(axis=0),
-                cmap="RdBu_r",
-                vmin=-2,
-                vmax=2,
-            )
+            ax.pcolormesh(data - xr_sep.sum(axis=0), **plot_kwargs)
             ax.set_ylabel("Space (-)")
 
         axes[-1].set_xlabel("Time (-)")

From 7f0e922ad82157c8e950223bbb5659bc0e17ddcf Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Wed, 10 May 2023 16:35:58 +0200
Subject: [PATCH 20/31] Feat: added conversion from xarray, cleaned up object

- Added the from_xarray() method which converts an xarray Dataset (e.g.,
  one stored on disk as a netcdf) into a costs object. Costs methods,
such as scale separation and reconstruction can be made from this
converted object.
- Cleaned up unnecessary variables in the object related to time
  keeping. Somewhat simplifies the time keeping.
---
 pydmd/costsdmd.py | 73 +++++++++++++++++++++++++++++------------------
 1 file changed, 46 insertions(+), 27 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index ccd52badb..bc4c1e40f 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -100,12 +100,12 @@ def __init__(
         self._time_array = None
         self._modes_array = None
         self._omega_array = None
-        self._time_means_array = None
         self._amplitudes_array = None
-        self._t_starts_array = None
         self._cluster_centroids = None
         self._omega_classes = None
         self._square_frequencies = None
+        self._window_means_array = None
+        self._non_integer_n_slide = None
 
         # Specify default keywords to hand to BOPDMD.
         if pydmd_kwargs is None:
@@ -162,18 +162,6 @@ def window_means_array(self):
             raise ValueError("You need to call fit first.")
         return self._window_means_array
 
-    @property
-    def t_starts_array(self):
-        if not hasattr(self, "_t_starts_array"):
-            raise ValueError("You need to call fit first.")
-        return self._t_starts_array
-
-    @property
-    def time_means_array(self):
-        if not hasattr(self, "_time_means_array"):
-            raise ValueError("You need to call fit first.")
-        return self._time_means_array
-
     @property
     def n_components(self):
         if not hasattr(self, "_n_components"):
@@ -321,7 +309,9 @@ def fit(
         )
         if n_slide_last_window > 0:
             self._n_slides += 1
-        self._n_slide_last_window = n_slide_last_window
+            self._non_integer_n_slide = True
+        else:
+            self._non_integer_n_slide = False
 
         # Build the projection basis if using a global svd.
         if self._global_svd:
@@ -364,8 +354,6 @@ def fit(
             (self._n_slides, svd_rank_pre_allocate), np.complex128
         )
         self._window_means_array = np.zeros((self._n_slides, self._n_data_vars))
-        self._t_starts_array = np.zeros(self._n_slides)
-        self._time_means_array = np.zeros(self._n_slides)
 
         # Get initial values for the eigenvalues.
         self._init_alpha = self._build_initizialization()
@@ -391,7 +379,6 @@ def fit(
             sample_slice = self.get_window_indices(k)
             data_window = data[:, sample_slice]
             original_time_window = time[:, sample_slice]
-            time_window_mean = np.mean(original_time_window)
 
             # All windows are fit with the time array reset to start at t=0.
             t_start = original_time_window[:, 0]
@@ -432,8 +419,6 @@ def fit(
             ] = optdmd.amplitudes
             self._window_means_array[k, :] = c.flatten()
             self._time_array[k, :] = original_time_window
-            self._time_means_array[k] = time_window_mean
-            self._t_starts_array[k] = t_start
 
             # Reset optdmd between iterations
             if not self._global_svd:
@@ -446,13 +431,16 @@ def fit(
                     optdmd.init_alpha = optdmd.eigs
 
     def get_window_indices(self, k):
-        """
+        """Returns the window indices for slide `k`.
+
+        Handles non-integer number of slides by making the last slide
+        correspond to `slice(-window_length, None)`.
 
         @return:
         """
         # Get the window indices and data.
         sample_start = self._step_size * k
-        if k == self._n_slides - 1 and self._n_slide_last_window > 0:
+        if k == self._n_slides - 1 and self._non_integer_n_slide:
             sample_slice = slice(-self._window_length, None)
         else:
             sample_slice = slice(
@@ -583,7 +571,7 @@ def plot_omega_squared_time_series(self):
 
         for ncomponent, component in enumerate(range(self._n_components)):
             ax.plot(
-                self._time_means_array,
+                np.mean(self.time_array, axis=1),
                 np.where(
                     self._omega_classes == component,
                     omega_squared.reshape((n_slides, svd_rank)),
@@ -655,9 +643,9 @@ def scale_reconstruction(
 
             c = np.atleast_2d(self._window_means_array[k]).T
 
-            # Compute each segment of xr starting at "t = 0"
+            # Compute each segment of the reconstructed data starting at "t = 0"
             t = self._time_array[k]
-            t_start = self._t_starts_array[k]
+            t_start = t.min()
             t = t - t_start
 
             xr_sep_window = np.zeros(
@@ -677,7 +665,7 @@ def scale_reconstruction(
                     xr_sep_window[j, :, :] += c
                 xr_sep_window[j, :, :] = xr_sep_window[j, :, :] * recon_filter
 
-                if k == self._n_slides - 1 and self._n_slide_last_window > 0:
+                if k == self._n_slides - 1 and self._non_integer_n_slide:
                     window_indices = slice(-self._window_length, None)
                 else:
                     window_indices = slice(
@@ -910,11 +898,16 @@ def to_xarray(self):
                 ),
             },
             coords={
-                "window_time_means": self.time_means_array,
+                "window_time_means": np.mean(self.time_array, axis=1),
                 "slide": ("window_time_means", np.arange(self._n_slides)),
                 "rank": np.arange(self.svd_rank),
                 "space": np.arange(self._n_data_vars),
                 "frequency_band": np.arange(self.n_components),
+                "window_index": np.arange(self._window_length),
+                "time": (
+                    ("window_time_means", "window_index"),
+                    self.time_array,
+                ),
             },
             attrs={
                 "svd_rank": self.svd_rank,
@@ -924,7 +917,33 @@ def to_xarray(self):
                 "num_frequency_bands": self.n_components,
                 "n_data_vars": self._n_data_vars,
                 "n_time_steps": self._n_time_steps,
+                "step_size": self._step_size,
+                "non_integer_n_slide": self._non_integer_n_slide,
             },
         )
 
         return ds
+
+    def from_xarray(self, ds):
+        """Convert xarray Dataset into a fitted CoSTS object
+
+        @return:
+        """
+
+        self._omega_array = ds.omega.values
+        self._omega_classes = ds.omega_classes
+        self._amplitudes_array = ds.amplitudes.values
+        self._modes_array = ds.modes.values
+        self._window_means_array = ds.window_means.values
+        self._cluster_centroids = ds.cluster_centroids.values
+        self._time_array = ds.time.values
+        self._n_slides = ds.attrs["n_slides"]
+        self._svd_rank = ds.attrs["svd_rank"]
+        self._n_data_vars = ds.attrs["n_data_vars"]
+        self._n_time_steps = ds.attrs["n_time_steps"]
+        self._n_components = ds.attrs["num_frequency_bands"]
+        self._non_integer_n_slide = ds.attrs["non_integer_n_slide"]
+        self._step_size = ds.attrs["step_size"]
+        self._window_length = ds.attrs["window_length"]
+
+        return self

From 740088d721e6c14f2b7523f02eabce8b3b6cd99e Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Sun, 16 Jul 2023 13:30:00 -0400
Subject: [PATCH 21/31] Feat: transform methods for omega

- Replaced the `squared_frequences` keyword with a `transform_method` keyword
which transforms the omega array imaginary components depending on several options
(no transformation, squared frequencies, or log10 scaled frequencies) for the
frequency band clustering.
---
 pydmd/costsdmd.py | 72 +++++++++++++++++++++++++++++++----------------
 1 file changed, 47 insertions(+), 25 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index bc4c1e40f..bb8db986f 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -103,7 +103,7 @@ def __init__(
         self._amplitudes_array = None
         self._cluster_centroids = None
         self._omega_classes = None
-        self._square_frequencies = None
+        self._transform_method = None
         self._window_means_array = None
         self._non_integer_n_slide = None
 
@@ -449,19 +449,22 @@ def get_window_indices(self, k):
         return sample_slice
 
     def cluster_omega(
-        self, n_components, kmeans_kwargs=None, square_frequencies=True
+        self, n_components, kmeans_kwargs=None, transform_method=None
     ):
-
         # Reshape the omega array into a 1d array
         omega_array = self.omega_array
         n_slides = omega_array.shape[0]
         svd_rank = omega_array.shape[1]
         omega_rshp = omega_array.reshape(n_slides * svd_rank)
 
-        if square_frequencies:
-            omega_squared = (np.conj(omega_rshp) * omega_rshp).astype("float")
+        # Apply a transformation to omega to (maybe) better separate frequency bands
+        if transform_method == "squared":
+            omega_transform = (np.conj(omega_rshp) * omega_rshp).astype("float")
+        elif transform_method == "log10":
+            omega_transform = np.log10(np.abs(omega_array.imag.astype("float")))
         else:
-            omega_squared = np.abs(omega_rshp.imag.astype("float"))
+            transform_method = "absolute_value"
+            omega_transform = np.abs(omega_rshp.imag.astype("float"))
 
         if kmeans_kwargs is None:
             random_state = 0
@@ -470,7 +473,7 @@ def cluster_omega(
                 "random_state": random_state,
             }
         kmeans = KMeans(n_clusters=n_components, **kmeans_kwargs)
-        omega_classes = kmeans.fit_predict(np.atleast_2d(omega_squared).T)
+        omega_classes = kmeans.fit_predict(np.atleast_2d(omega_transform).T)
         omega_classes = omega_classes.reshape(n_slides, svd_rank)
         cluster_centroids = kmeans.cluster_centers_.flatten()
 
@@ -484,7 +487,7 @@ def cluster_omega(
         # Assign the results to the object.
         self._cluster_centroids = cluster_centroids
         self._omega_classes = omega_classes
-        self._square_frequencies = square_frequencies
+        self._transform_method = transform_method
         self._n_components = n_components
         self._class_values = np.unique(omega_classes)[idx]
         self._trimmed = False
@@ -492,7 +495,7 @@ def cluster_omega(
         return self
 
     def cluster_hyperparameter_sweep(
-        self, n_components_range=None, square_frequencies=False
+        self, n_components_range=None, transform_method=None
     ):
         """Performs a hyperparameter search for the number of components in the kmeans clustering."""
         if n_components_range is None:
@@ -506,42 +509,56 @@ def cluster_hyperparameter_sweep(
         n_slides = omega_array.shape[0]
         svd_rank = omega_array.shape[1]
         omega_rshp = omega_array.reshape(n_slides * svd_rank)
-        if square_frequencies:
-            omega_squared = (np.conj(omega_rshp) * omega_rshp).astype("float")
+
+        # Apply a transformation to omega to (maybe) better separate frequency bands
+        if transform_method == "squared":
+            omega_transform = (np.conj(omega_rshp) * omega_rshp).astype("float")
+        elif transform_method == "log10":
+            omega_transform = np.log10(np.abs(omega_array.imag.astype("float")))
         else:
-            omega_squared = np.abs(omega_rshp.imag.astype("float"))
+            omega_transform = np.abs(omega_rshp.imag.astype("float"))
 
         for nind, n in enumerate(n_components_range):
-            _ = self.cluster_omega(n_components=n, square_frequencies=False)
+            _ = self.cluster_omega(n_components=n, transform_method=False)
 
             classes_reshape = self.omega_classes.reshape(n_slides * svd_rank)
 
             score[nind] = silhouette_score(
-                np.atleast_2d(omega_squared).T, np.atleast_2d(classes_reshape).T
+                np.atleast_2d(omega_transform).T,
+                np.atleast_2d(classes_reshape).T,
             )
 
         return n_components_range[np.argmax(score)]
 
     def plot_omega_histogram(self):
-
         # Reshape the omega array into a 1d array
         omega_array = self.omega_array
         n_slides = omega_array.shape[0]
         svd_rank = omega_array.shape[1]
         omega_rshp = omega_array.reshape(n_slides * svd_rank)
 
-        if self._square_frequencies:
-            omega_squared = (np.conj(omega_rshp) * omega_rshp).astype("float")
+        hist_kwargs = {"bins": 64}
+        # Apply a transformation to omega to (maybe) better separate frequency bands
+        if self._transform_method == "squared":
+            omega_transform = (np.conj(omega_rshp) * omega_rshp).astype("float")
             label = "$|\omega|^{2}$"
+        elif self._transform_method == "log10":
+            omega_rshp = np.abs(omega_rshp.imag)
+            omega_transform = np.log10(np.abs(omega_array.imag.astype("float")))
+            label = "$log_{10}(|\omega|)$"
+            hist_kwargs["bins"] = np.linspace(
+                np.min(np.log10(omega_transform[omega_rshp > 0])),
+                np.max(np.log10(omega_transform[omega_rshp > 0])),
+            )
         else:
-            omega_squared = np.abs(omega_rshp.imag.astype("float"))
+            omega_transform = np.abs(omega_rshp.imag.astype("float"))
             label = "$|\omega|$"
 
         cluster_centroids = self._cluster_centroids
 
         colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]
         fig, ax = plt.subplots(1, 1)
-        ax.hist(omega_squared, bins=64)
+        ax.hist(omega_transform, **hist_kwargs)
         ax.set_xlabel(label)
         ax.set_ylabel("Count")
         ax.set_title("$\omega$ Spectrum & k-Means Centroids")
@@ -562,11 +579,15 @@ def plot_omega_squared_time_series(self):
         svd_rank = omega_array.shape[1]
         omega_rshp = omega_array.reshape(n_slides * svd_rank)
 
-        if self._square_frequencies:
-            omega_squared = (np.conj(omega_rshp) * omega_rshp).astype("float")
+        # Apply a transformation to omega to (maybe) better separate frequency bands
+        if self._transform_method == "squared":
+            omega_transform = (np.conj(omega_rshp) * omega_rshp).astype("float")
             label = "$|\omega|^{2}$"
+        elif self._transform_method == "log10":
+            omega_transform = np.log10(np.abs(omega_array.imag.astype("float")))
+            label = "$log_{10}(|\omega|)$"
         else:
-            omega_squared = np.abs(omega_rshp.imag.astype("float"))
+            omega_transform = np.abs(omega_rshp.imag.astype("float"))
             label = "$|\omega|$"
 
         for ncomponent, component in enumerate(range(self._n_components)):
@@ -574,7 +595,7 @@ def plot_omega_squared_time_series(self):
                 np.mean(self.time_array, axis=1),
                 np.where(
                     self._omega_classes == component,
-                    omega_squared.reshape((n_slides, svd_rank)),
+                    omega_transform.reshape((n_slides, svd_rank)),
                     np.nan,
                 ),
                 color=colors[ncomponent % len(colors)],
@@ -691,7 +712,8 @@ def scale_reconstruction(
 
     def threshold_modes(self, data, xr_sep):
         """Remove frequency bands that do not contribute significantly to the magnitude of the reconstruction."""
-
+        # @ToDo: rename truncate and return the object or remove since it relies on
+        #  poorly understood thresholds.
         if not self._trimmed:
             # Remove scales that do not contribute significantly to the magnitude of the signal
             n = np.nanmedian(np.abs(xr_sep.real), axis=(1, 2))
@@ -911,7 +933,7 @@ def to_xarray(self):
             },
             attrs={
                 "svd_rank": self.svd_rank,
-                "square_frequencies": self._square_frequencies,
+                "square_frequencies": self._transform_method,
                 "n_slides": self._n_slides,
                 "window_length": self._window_length,
                 "num_frequency_bands": self.n_components,

From 442a0c9c0705c7f38ddb441919bd804022e3863d Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 18 Jul 2023 11:30:04 -0400
Subject: [PATCH 22/31] Bug fix: Catch incompatible svd_ranks

---
 pydmd/costsdmd.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index bb8db986f..e0779f7b0 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -329,6 +329,10 @@ def fit(
                 raise ValueError(
                     "svd_rank is odd, but force_even_eigs is True."
                 )
+            if self._svd_rank > self._n_data_vars:
+                raise ValueError(
+                    "Rank is larger than the data spatial dimension."
+                )
             svd_rank_pre_allocate = self._compute_svd_rank(
                 data, svd_rank=self._svd_rank
             )

From 45b2227aa29969aa52f25515d14bb73b1b99ac58 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 18 Jul 2023 14:26:49 -0400
Subject: [PATCH 23/31] Fix: Use utils.compute_rank. Added dependencies to
 setup.py

---
 pydmd/costsdmd.py | 35 +++++------------------------------
 setup.py          |  3 +++
 2 files changed, 8 insertions(+), 30 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index e0779f7b0..12cf7447c 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -1,5 +1,6 @@
 import numpy as np
 from pydmd.bopdmd import BOPDMD
+from .utils import compute_rank
 import scipy
 from sklearn.cluster import KMeans
 from sklearn.metrics import silhouette_score
@@ -180,28 +181,8 @@ def omega_classes(self):
             raise ValueError("You need to call `cluster_omega()` first.")
         return self._omega_classes
 
-    def _compute_svd_rank(self, data, svd_rank=None):
-        def omega(x):
-            return 0.56 * x**3 - 0.95 * x**2 + 1.82 * x + 1.43
-
-        U, s, _ = np.linalg.svd(data, full_matrices=False)
-
-        if svd_rank == 0:
-            beta = np.divide(*sorted(data.shape))
-            tau = np.median(s) * omega(beta)
-            svd_rank = np.sum(s > tau)
-        elif 0 < svd_rank < 1:
-            cumulative_energy = np.cumsum(s**2 / (s**2).sum())
-            svd_rank = np.searchsorted(cumulative_energy, svd_rank) + 1
-        elif svd_rank >= 1 and isinstance(svd_rank, (int, np.integer)):
-            svd_rank = min(svd_rank, self._n_data_vars)
-        else:
-            svd_rank = self._n_data_vars
-
-        return svd_rank
-
     def _build_proj_basis(self, data, svd_rank=None):
-        self._svd_rank = self._compute_svd_rank(data, svd_rank=svd_rank)
+        self._svd_rank = compute_rank(data, svd_rank=svd_rank)
         # Recover the first r modes of the global svd
         u, _, _ = scipy.linalg.svd(data, full_matrices=False)
         return u[:, : self._svd_rank]
@@ -320,9 +301,7 @@ def fit(
             self._pydmd_kwargs["use_proj"] = self._pydmd_kwargs.get(
                 "use_proj", False
             )
-            self._svd_rank = self._compute_svd_rank(
-                data, svd_rank=self._svd_rank
-            )
+            self._svd_rank = compute_rank(data, svd_rank=self._svd_rank)
             svd_rank_pre_allocate = self._svd_rank
         elif not self._global_svd and self._svd_rank > 0:
             if self._force_even_eigs and self._svd_rank % 2:
@@ -333,9 +312,7 @@ def fit(
                 raise ValueError(
                     "Rank is larger than the data spatial dimension."
                 )
-            svd_rank_pre_allocate = self._compute_svd_rank(
-                data, svd_rank=self._svd_rank
-            )
+            svd_rank_pre_allocate = compute_rank(data, svd_rank=self._svd_rank)
         # If not using a global svd or a specified svd_rank, local u from each window is
         # used instead. The optimal svd_rank may change when using the locally optimal
         # svd_rank. To deal with this situation in the pre-allocation we give the
@@ -399,9 +376,7 @@ def fit(
             if not self._global_svd:
                 # Get the svd rank for this window. Uses rank truncation when svd_rank is
                 # not fixed, i.e. svd_rank = 0, otherwise uses the specified rank.
-                _svd_rank = self._compute_svd_rank(
-                    data_window, svd_rank=self._svd_rank
-                )
+                _svd_rank = compute_rank(data_window, svd_rank=self._svd_rank)
                 # Force svd rank to be even to allow for conjugate pairs.
                 if self._force_even_eigs and _svd_rank % 2:
                     _svd_rank += 1
diff --git a/setup.py b/setup.py
index 33cb633b4..05a2dd746 100644
--- a/setup.py
+++ b/setup.py
@@ -14,6 +14,9 @@
 KEYWORDS = "dynamic-mode-decomposition dmd"
 
 REQUIRED = ["numpy", "scipy", "matplotlib"]
+EXTRAS_REQUIRE = {
+    "costs": ["scikit-learn", "xarray"],
+}
 
 EXTRAS = {
     "docs": ["Sphinx>=1.4", "sphinx_rtd_theme"],

From 3338d1963308aca39e18470bf463112e59826f5f Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 18 Jul 2023 14:47:44 -0400
Subject: [PATCH 24/31] Use utils.compute_svd

---
 pydmd/costsdmd.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 12cf7447c..09b255f05 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -1,6 +1,6 @@
 import numpy as np
 from pydmd.bopdmd import BOPDMD
-from .utils import compute_rank
+from .utils import compute_rank, compute_svd
 import scipy
 from sklearn.cluster import KMeans
 from sklearn.metrics import silhouette_score
@@ -184,8 +184,9 @@ def omega_classes(self):
     def _build_proj_basis(self, data, svd_rank=None):
         self._svd_rank = compute_rank(data, svd_rank=svd_rank)
         # Recover the first r modes of the global svd
-        u, _, _ = scipy.linalg.svd(data, full_matrices=False)
-        return u[:, : self._svd_rank]
+        # u, _, _ = scipy.linalg.svd(data, full_matrices=False)
+        u, _, _ = compute_svd(data, svd_rank=svd_rank)
+        return u
 
     def _build_initizialization(self):
         """Method for making initial guess of DMD eigenvalues."""

From 88db3168cbf843438ced4373232b5609a8196a53 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 18 Jul 2023 14:48:06 -0400
Subject: [PATCH 25/31] Updated extra_requires to use h5netcdf

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 05a2dd746..d10928df7 100644
--- a/setup.py
+++ b/setup.py
@@ -15,7 +15,7 @@
 
 REQUIRED = ["numpy", "scipy", "matplotlib"]
 EXTRAS_REQUIRE = {
-    "costs": ["scikit-learn", "xarray"],
+    "costs": ["scikit-learn", "xarray", "h5netcdf"],
 }
 
 EXTRAS = {

From 10fe92d6851aaf5a319bb864c6ef9c10b72e94de Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 18 Jul 2023 18:24:28 -0400
Subject: [PATCH 26/31] Cleanup of `to_xarray` method

---
 pydmd/costsdmd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 09b255f05..86b850ba8 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -913,7 +913,7 @@ def to_xarray(self):
             },
             attrs={
                 "svd_rank": self.svd_rank,
-                "square_frequencies": self._transform_method,
+                "omega_transformation": self._transform_method,
                 "n_slides": self._n_slides,
                 "window_length": self._window_length,
                 "num_frequency_bands": self.n_components,

From 137dd7d86ea533eaba7cf397e5838f55f7fd9640 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 18 Jul 2023 18:45:10 -0400
Subject: [PATCH 27/31] Feat: property getter for commonly accessed values

---
 pydmd/costsdmd.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index 86b850ba8..c75d2a67b 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -133,6 +133,22 @@ def svd_rank(self):
         """
         return self._svd_rank
 
+    @property
+    def window_length(self):
+        """
+        :return: the length of the windows used for this decomposition level.
+        :rtype: int or float
+        """
+        return self._window_length
+
+    @property
+    def n_slides(self):
+        """
+        :return: number of window slides for this decomposition level.
+        :rtype: int
+        """
+        return self._n_slides
+
     @property
     def modes_array(self):
         if not hasattr(self, "_modes_array"):

From 9c48f2253fd20e80f3ea4f2a45ecce37db350a3a Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Thu, 20 Jul 2023 16:57:02 +0200
Subject: [PATCH 28/31] Updates to plotting routine for high and low
 frequencies

- The low frequency/input data component is now in `cividis` by default
with its own colorscale
- The high frequency components are now in `RdBu_r` with a separataely
defined colorscale
- Added keyword arguments for interacting with both sets of options
- Low frequency/input data can now optionally include black contours.
---
 pydmd/costsdmd.py | 59 +++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 52 insertions(+), 7 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index c75d2a67b..f04560a91 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -756,6 +756,8 @@ def plot_scale_separation(
         plot_residual=False,
         fig_kwargs=None,
         plot_kwargs=None,
+        hf_plot_kwargs=None,
+        plot_contours=False,
     ):
         """Plot the scale-separated low and high frequency bands."""
         if scale_reconstruction_kwargs is None:
@@ -777,7 +779,17 @@ def plot_scale_separation(
             plot_kwargs = {}
         plot_kwargs["vmin"] = plot_kwargs.get("vmin", -np.abs(data).max())
         plot_kwargs["vmax"] = plot_kwargs.get("vmax", np.abs(data).max())
-        plot_kwargs["cmap"] = plot_kwargs.get("cmap", "RdBu_r")
+        plot_kwargs["cmap"] = plot_kwargs.get("cmap", "cividis")
+
+        if hf_plot_kwargs is None:
+            hf_plot_kwargs = {}
+        hf_plot_kwargs["vmin"] = hf_plot_kwargs.get(
+            "vmin", -np.abs(xr_high_frequency).max()
+        )
+        hf_plot_kwargs["vmax"] = hf_plot_kwargs.get(
+            "vmax", np.abs(xr_high_frequency).max()
+        )
+        hf_plot_kwargs["cmap"] = hf_plot_kwargs.get("cmap", "RdBu_r")
 
         if plot_residual:
             fig, axes = plt.subplots(4, 1, **fig_kwargs)
@@ -786,6 +798,8 @@ def plot_scale_separation(
 
         ax = axes[0]
         ax.pcolormesh(data, **plot_kwargs)
+        if plot_contours:
+            ax.contour(data, colors=["k"])
         ax.set_title(
             "Input Data at decomposition window length = {}".format(
                 self._window_length
@@ -794,24 +808,28 @@ def plot_scale_separation(
         ax = axes[1]
         ax.set_title("Reconstruction, low frequency")
         ax.pcolormesh(xr_low_frequency, **plot_kwargs)
+        if plot_contours:
+            ax.contour(data, colors=["k"])
         ax.set_ylabel("Space (-)")
 
         ax = axes[2]
         ax.set_title("Reconstruction, high frequency")
-        ax.pcolormesh(xr_high_frequency, **plot_kwargs)
+        ax.pcolormesh(xr_high_frequency, **hf_plot_kwargs)
         ax.set_ylabel("Space (-)")
 
         if plot_residual:
             ax = axes[3]
             ax.set_title("Residual")
             ax.pcolormesh(
-                data - xr_high_frequency - xr_low_frequency, **plot_kwargs
+                data - xr_high_frequency - xr_low_frequency, **hf_plot_kwargs
             )
             ax.set_ylabel("Space (-)")
 
         axes[-1].set_xlabel("Time (-)")
         fig.tight_layout()
 
+        return fig, axes
+
     def plot_reconstructions(
         self,
         data,
@@ -820,6 +838,8 @@ def plot_reconstructions(
         plot_residual=False,
         fig_kwargs=None,
         plot_kwargs=None,
+        hf_plot_kwargs=None,
+        plot_contours=False,
     ):
         if scale_reconstruction_kwargs is None:
             scale_reconstruction_kwargs = {}
@@ -833,20 +853,40 @@ def plot_reconstructions(
             "figsize", (6, 1.5 * len(self._cluster_centroids) + 1)
         )
 
+        # Low frequency and input data often require separate plotting parameters.
         if plot_kwargs is None:
             plot_kwargs = {}
         plot_kwargs["vmin"] = plot_kwargs.get("vmin", -np.abs(data).max())
         plot_kwargs["vmax"] = plot_kwargs.get("vmax", np.abs(data).max())
-        plot_kwargs["cmap"] = plot_kwargs.get("cmap", "RdBu_r")
+        plot_kwargs["cmap"] = plot_kwargs.get("cmap", "cividis")
 
+        # High frequency components often require separate plotting parameters.
+        if hf_plot_kwargs is None:
+            hf_plot_kwargs = {}
+        hf_plot_kwargs["vmin"] = hf_plot_kwargs.get(
+            "vmin", -np.abs(xr_sep[1:, :, :]).max()
+        )
+        hf_plot_kwargs["vmax"] = hf_plot_kwargs.get(
+            "vmax", np.abs(xr_sep[1:, :, :]).max()
+        )
+        hf_plot_kwargs["cmap"] = hf_plot_kwargs.get("cmap", "RdBu_r")
+
+        # Determine the number of plotting elements, which changes depending on if the
+        # residual is included.
+        if plot_residual:
+            num_plot_elements = len(self._cluster_centroids) + 2
+        else:
+            num_plot_elements = len(self._cluster_centroids) + 1
         fig, axes = plt.subplots(
-            len(self._cluster_centroids) + 1,
+            num_plot_elements,
             1,
             **fig_kwargs,
         )
 
         ax = axes[0]
         ax.pcolormesh(data.real, **plot_kwargs)
+        if plot_contours:
+            ax.contour(data.real, colors=["k"])
         ax.set_ylabel("Space (-)")
         ax.set_xlabel("Time (-)")
         ax.set_title(
@@ -864,14 +904,19 @@ def plot_reconstructions(
 
             ax = axes[n_cluster + 1]
             xr_scale = xr_sep[n_cluster, :, :]
-            ax.pcolormesh(xr_scale, **plot_kwargs)
+            if n_cluster == 0:
+                ax.pcolormesh(xr_scale, **plot_kwargs)
+                if plot_contours:
+                    ax.contour(xr_scale, colors=["k"])
+            else:
+                ax.pcolormesh(xr_scale, **hf_plot_kwargs)
             ax.set_ylabel("Space (-)")
             ax.set_title(title.format(x))
 
         if plot_residual:
             ax = axes[-1]
             ax.set_title("Residual")
-            ax.pcolormesh(data - xr_sep.sum(axis=0), **plot_kwargs)
+            ax.pcolormesh(data - xr_sep.sum(axis=0), **hf_plot_kwargs)
             ax.set_ylabel("Space (-)")
 
         axes[-1].set_xlabel("Time (-)")

From 63a5dbc282ee56ca326926b3d11952c7ed9c3d80 Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 25 Jul 2023 17:55:57 +0200
Subject: [PATCH 29/31] Update: cleaning code and comments

- Dealt with some overlong comment lines
- Moved the gaussian kernel convolution to dedicated function
---
 pydmd/costsdmd.py | 37 +++++++++++++++++++++++++------------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index f04560a91..f376dd36f 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -277,6 +277,15 @@ def calculate_lv_kern(window_length, corner_sharpness=None):
 
         return lv_kern
 
+    @staticmethod
+    def build_kern(window_length):
+        recon_filter_sd = window_length / 8
+        recon_filter = np.exp(
+            -((np.arange(window_length) - (window_length + 1) / 2) ** 2)
+            / recon_filter_sd**2
+        )
+        return recon_filter
+
     def _data_shape(self, data):
         n_time_steps = np.shape(data)[1]
         n_data_vars = np.shape(data)[0]
@@ -640,14 +649,15 @@ def scale_reconstruction(
 
         # Convolve each windowed reconstruction with a gaussian filter.
         # Std dev of gaussian filter
-        recon_filter_sd = self._window_length / 8
-        recon_filter = np.exp(
-            -(
-                (np.arange(self._window_length) - (self._window_length + 1) / 2)
-                ** 2
-            )
-            / recon_filter_sd**2
-        )
+        recon_filter = self.build_kern(self._window_length)
+        # recon_filter_sd = self._window_length / 8
+        # recon_filter = np.exp(
+        #     -(
+        #         (np.arange(self._window_length) - (self._window_length + 1) / 2)
+        #         ** 2
+        #     )
+        #     / recon_filter_sd**2
+        # )
 
         for k in range(self._n_slides):
             w = self._modes_array[k]
@@ -707,11 +717,13 @@ def scale_reconstruction(
         return xr_sep
 
     def threshold_modes(self, data, xr_sep):
-        """Remove frequency bands that do not contribute significantly to the magnitude of the reconstruction."""
+        """Remove frequency bands that do not contribute significantly to the magnitude
+        of the reconstruction."""
         # @ToDo: rename truncate and return the object or remove since it relies on
         #  poorly understood thresholds.
         if not self._trimmed:
-            # Remove scales that do not contribute significantly to the magnitude of the signal
+            # Remove scales that do not contribute significantly to the magnitude of
+            # the signal
             n = np.nanmedian(np.abs(xr_sep.real), axis=(1, 2))
             magnitude_threshold = np.nanmedian(np.abs(data.real)) / 100
 
@@ -735,8 +747,9 @@ def scale_separation(
     ):
         """Separate the lowest frequency band from the high frequency bands.
 
-        The lowest frequency band should contain the window means and can be passed on as the data for the next
-        decomposition level. The high frequencies should have frequencies shorter than 1 / window_length.
+        The lowest frequency band should contain the window means and can be passed on
+        as the data for the next decomposition level. The high frequencies should have
+        frequencies shorter than 1 / window_length.
 
         """
 

From 02931248dfa9ff8e14b3b3e649f1cfa8431215ef Mon Sep 17 00:00:00 2001
From: klapo <lapo.karl@gmail.com>
Date: Tue, 25 Jul 2023 18:27:49 +0200
Subject: [PATCH 30/31] Big bug fix for reconstruction

- Reconstructing the scale separated data no longer can modify omega
inadvertantly fixing a major bug when not suppressing growth.
- Removed the scale truncation method as it no longer functions.
- Converted `scale_reconstruction` to use the `get_window_indices` method.
---
 pydmd/costsdmd.py | 60 ++++-------------------------------------------
 1 file changed, 5 insertions(+), 55 deletions(-)

diff --git a/pydmd/costsdmd.py b/pydmd/costsdmd.py
index f376dd36f..a10ce9ee1 100644
--- a/pydmd/costsdmd.py
+++ b/pydmd/costsdmd.py
@@ -1,7 +1,7 @@
 import numpy as np
 from pydmd.bopdmd import BOPDMD
 from .utils import compute_rank, compute_svd
-import scipy
+import copy
 from sklearn.cluster import KMeans
 from sklearn.metrics import silhouette_score
 import matplotlib.pyplot as plt
@@ -623,8 +623,6 @@ def scale_reconstruction(
         self,
         suppress_growth=True,
         include_means=True,
-        magnitude_threshold=False,
-        data=None,
     ):
         """Reconstruct the sliding mrDMD into the constituent components.
 
@@ -634,7 +632,6 @@ def scale_reconstruction(
         and end of time series prone to larger errors. A best practice is
         to cut off `window_length` from each end before further analysis.
 
-
         suppress_growth:
         Kill positive real components of frequencies
         """
@@ -650,19 +647,14 @@ def scale_reconstruction(
         # Convolve each windowed reconstruction with a gaussian filter.
         # Std dev of gaussian filter
         recon_filter = self.build_kern(self._window_length)
-        # recon_filter_sd = self._window_length / 8
-        # recon_filter = np.exp(
-        #     -(
-        #         (np.arange(self._window_length) - (self._window_length + 1) / 2)
-        #         ** 2
-        #     )
-        #     / recon_filter_sd**2
-        # )
 
         for k in range(self._n_slides):
+            window_indices = self.get_window_indices(k)
+
             w = self._modes_array[k]
             b = self._amplitudes_array[k]
-            omega = np.atleast_2d(self._omega_array[k]).T
+            # @ToDo: global flag for suppressing growth?
+            omega = copy.deepcopy(np.atleast_2d(self._omega_array[k]).T)
             classification = self._omega_classes[k]
 
             if suppress_growth:
@@ -692,13 +684,6 @@ def scale_reconstruction(
                     xr_sep_window[j, :, :] += c
                 xr_sep_window[j, :, :] = xr_sep_window[j, :, :] * recon_filter
 
-                if k == self._n_slides - 1 and self._non_integer_n_slide:
-                    window_indices = slice(-self._window_length, None)
-                else:
-                    window_indices = slice(
-                        k * self._step_size,
-                        k * self._step_size + self._window_length,
-                    )
                 xr_sep[j, :, window_indices] = (
                     xr_sep[j, :, window_indices] + xr_sep_window[j, :, :]
                 )
@@ -707,38 +692,6 @@ def scale_reconstruction(
 
         xr_sep = xr_sep / xn
 
-        if magnitude_threshold:
-            if data is None:
-                raise ValueError(
-                    "The data must be provided when doing a magnitude cut-off of modes."
-                )
-            xr_sep = self.threshold_modes(data, xr_sep)
-
-        return xr_sep
-
-    def threshold_modes(self, data, xr_sep):
-        """Remove frequency bands that do not contribute significantly to the magnitude
-        of the reconstruction."""
-        # @ToDo: rename truncate and return the object or remove since it relies on
-        #  poorly understood thresholds.
-        if not self._trimmed:
-            # Remove scales that do not contribute significantly to the magnitude of
-            # the signal
-            n = np.nanmedian(np.abs(xr_sep.real), axis=(1, 2))
-            magnitude_threshold = np.nanmedian(np.abs(data.real)) / 100
-
-            # Trim frequencies bands that do not meet the magnitude threshold.
-            xr_sep = xr_sep[n > magnitude_threshold, ::]
-            self._cluster_centroids = self._cluster_centroids[
-                n > magnitude_threshold
-            ]
-            num_modes_to_keep = np.sum(n > magnitude_threshold)
-            self._class_values = self._class_values[
-                self._class_values < num_modes_to_keep
-            ]
-
-            self._trimmed = True
-
         return xr_sep
 
     def scale_separation(
@@ -775,9 +728,6 @@ def plot_scale_separation(
         """Plot the scale-separated low and high frequency bands."""
         if scale_reconstruction_kwargs is None:
             scale_reconstruction_kwargs = {}
-        scale_reconstruction_kwargs["data"] = scale_reconstruction_kwargs.get(
-            "data", data
-        )
 
         xr_low_frequency, xr_high_frequency = self.scale_separation(
             scale_reconstruction_kwargs

From 18d815dcc1942ceae230f54cbebb561be8eea03b Mon Sep 17 00:00:00 2001
From: klapo <klapo@users.noreply.github.com>
Date: Mon, 31 Jul 2023 09:07:10 +0000
Subject: [PATCH 31/31] export tutorials changed in cce021a

---
 docs/source/_tutorials/tutorial16rdmd.html | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/source/_tutorials/tutorial16rdmd.html b/docs/source/_tutorials/tutorial16rdmd.html
index bc8c100a8..b03515415 100644
--- a/docs/source/_tutorials/tutorial16rdmd.html
+++ b/docs/source/_tutorials/tutorial16rdmd.html
@@ -7661,8 +7661,8 @@ <h2 id="Exact-DMD">Exact DMD<a class="anchor-link" href="#Exact-DMD">¶</a></h2>
 <div class="jp-OutputArea-child">
 <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
 <div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
-<pre>DMD Reconstruction Error: 0.017055067185666815
-DMD Training Time: 0.03313040733337402
+<pre>DMD Reconstruction Error: 0.017055067185677293
+DMD Training Time: 0.025948762893676758
 </pre>
 </div>
 </div>
@@ -7722,8 +7722,8 @@ <h2 id="Compressed-DMD">Compressed DMD<a class="anchor-link" href="#Compressed-D
 <div class="jp-OutputArea-child">
 <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
 <div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
-<pre>CDMD (Average) Reconstruction Error: 0.02902821286930133
-CDMD (Average) Training Time: 0.022034170627593982
+<pre>CDMD (Average) Reconstruction Error: 0.029294994023031783
+CDMD (Average) Training Time: 0.017836530208587657
 </pre>
 </div>
 </div>
@@ -7837,7 +7837,7 @@ <h2 id="Randomized-DMD:-Varying-Oversampling">Randomized DMD: Varying Oversampli
 <div class="jp-OutputArea-child">
 <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
 <div class="jp-RenderedImage jp-OutputArea-output" tabindex="0">
-<img alt="No description has been provided for this image" class="" src="data:image/png;base64,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"/>
+<img alt="No description has been provided for this image" class="" src="data:image/png;base64,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"/>
 </div>
 </div>
 </div>
@@ -7948,7 +7948,7 @@ <h2 id="Randomized-DMD:-Varying-Power-Iterations">Randomized DMD: Varying Power
 <div class="jp-OutputArea-child">
 <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
 <div class="jp-RenderedImage jp-OutputArea-output" tabindex="0">
-<img alt="No description has been provided for this image" class="" src="data:image/png;base64,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"/>
+<img alt="No description has been provided for this image" class="" src="data:image/png;base64,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"/>
 </div>
 </div>
 </div>
@@ -8043,16 +8043,16 @@ <h2 id="Runtime-Comparison">Runtime Comparison<a class="anchor-link" href="#Runt
 <div class="jp-OutputArea-child">
 <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
 <div class="jp-RenderedText jp-OutputArea-output" data-mime-type="application/vnd.jupyter.stderr" tabindex="0">
-<pre>/opt/hostedtoolcache/Python/3.8.17/x64/lib/python3.8/site-packages/pydmd/snapshots.py:72: UserWarning: Input data condition number 6.433008449726042e+33. Consider preprocessing data, passing in augmented data
+<pre>/opt/hostedtoolcache/Python/3.8.17/x64/lib/python3.8/site-packages/pydmd/snapshots.py:72: UserWarning: Input data condition number 1.7544404184776983e+34. Consider preprocessing data, passing in augmented data
 matrix, or regularization methods.
   warnings.warn(
-/opt/hostedtoolcache/Python/3.8.17/x64/lib/python3.8/site-packages/pydmd/snapshots.py:72: UserWarning: Input data condition number 1.76199338003729e+17. Consider preprocessing data, passing in augmented data
+/opt/hostedtoolcache/Python/3.8.17/x64/lib/python3.8/site-packages/pydmd/snapshots.py:72: UserWarning: Input data condition number 1.814688946195857e+17. Consider preprocessing data, passing in augmented data
 matrix, or regularization methods.
   warnings.warn(
-/opt/hostedtoolcache/Python/3.8.17/x64/lib/python3.8/site-packages/pydmd/snapshots.py:72: UserWarning: Input data condition number 1.1606101160101856e+17. Consider preprocessing data, passing in augmented data
+/opt/hostedtoolcache/Python/3.8.17/x64/lib/python3.8/site-packages/pydmd/snapshots.py:72: UserWarning: Input data condition number 1.1557599004545702e+17. Consider preprocessing data, passing in augmented data
 matrix, or regularization methods.
   warnings.warn(
-/opt/hostedtoolcache/Python/3.8.17/x64/lib/python3.8/site-packages/pydmd/snapshots.py:72: UserWarning: Input data condition number 1.090116156097933e+17. Consider preprocessing data, passing in augmented data
+/opt/hostedtoolcache/Python/3.8.17/x64/lib/python3.8/site-packages/pydmd/snapshots.py:72: UserWarning: Input data condition number 1.0858646571271267e+17. Consider preprocessing data, passing in augmented data
 matrix, or regularization methods.
   warnings.warn(
 </pre>
@@ -8061,7 +8061,7 @@ <h2 id="Runtime-Comparison">Runtime Comparison<a class="anchor-link" href="#Runt
 <div class="jp-OutputArea-child">
 <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
 <div class="jp-RenderedImage jp-OutputArea-output" tabindex="0">
-<img alt="No description has been provided for this image" class="" src="data:image/png;base64,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"/>
+<img alt="No description has been provided for this image" class="" src="data:image/png;base64,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"/>
 </div>
 </div>
 </div>