pastas-plugins 0.1.0__tar.gz

pastas_plugins-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Pastas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pastas_plugins-0.1.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.1
+Name: pastas_plugins
+Version: 0.1.0
+Summary: Repository containing plugins to further enhance your pastas experience.
+Author: Pastas Developers Team
+Maintainer-email: "D.A. Brakenhoff" <d.brakenhoff@artesia-water.nl>, "M.A. Vonk" <m.vonk@artesia-water.nl>, "M. Bakker" <markbak@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Pastas
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: homepage, https://pastas.dev
+Project-URL: repository, https://github.com/pastas/pastas-plugins
+Project-URL: documentation, https://pastas.readthedocs.io
+Keywords: hydrology,groundwater,timeseries,analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Other Audience
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Hydrology
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pastas
+Provides-Extra: all
+Requires-Dist: pastas_plugins[crosscorrelation,modflow]; extra == "all"
+Provides-Extra: crosscorrelation
+Requires-Dist: statsmodels; extra == "crosscorrelation"
+Provides-Extra: modflow
+Requires-Dist: flopy; extra == "modflow"
+Provides-Extra: reservoirs
+Requires-Dist: pastas_plugins; extra == "reservoirs"
+Provides-Extra: responses
+Requires-Dist: pastas_plugins; extra == "responses"
+Provides-Extra: ruffing
+Requires-Dist: ruff; extra == "ruffing"
+Provides-Extra: pytesting
+Requires-Dist: pytest>=7; extra == "pytesting"
+Requires-Dist: pytest-cov; extra == "pytesting"
+Requires-Dist: pytest-sugar; extra == "pytesting"
+Provides-Extra: ci
+Requires-Dist: coverage; extra == "ci"
+Provides-Extra: rtd
+Requires-Dist: pastas_plugins[all]; extra == "rtd"
+Requires-Dist: sphinx_rtd_theme; extra == "rtd"
+Requires-Dist: myst_nb; extra == "rtd"
+Requires-Dist: numpydoc; extra == "rtd"
+Requires-Dist: sphinx_design; extra == "rtd"
+
+# pastas-plugins
+
+Welcome to the pastas-plugins repository, your one-stop-shop for customized
+cutting-edge additions to Pastas.
+
+
+## Current plugins
+
+The following plugins are now available:
+
+- **`cross_correlation`**: analyze and visualize the cross-correlation between two time series.
+- **`modflow`**: use modflow models as response functions.
+- **`reservoirs`**: use reservoir models to simulate time series.
+- **`responses`**: custom response functions for Pastas.
+
+## Installation
+
+<!-- TODO: add repo to PYPI so this becomes true: -->
+Install `pastas-plugins` with:
+
+```bash
+pip install pastas_plugins
+```
+
+If you want to use a specific plugin and want to ensure you install all the requisite
+dependencies, you can use the following command:
+
+```bash
+pip install pastas-plugins[<name of plugin>]
+```
+
+If you want to install them all:
+```bash
+pip install pastas-plugins[all]
+```
+
+## Usage
+
+Import the pastas-plugins module with:
+
+```python
+import pastas_plugins as pp
+```
+
+This gives you access to the following functions:
+
+```python
+pp.list_plugins()         # list of all plugins
+pp.show_plugin_versions() # show plugin versions 
+```
+
+The function `pp.show_plugin_versions()` will indicate if any dependencies are missing
+for a particular plugin. See the [Installation](#installation) section above for tips
+on how to install dependencies for a particular plugin.
+
+To use a particular plugin, you'll have to import it explicitly, e.g.:
+
+```python
+from pastas_plugins import responses
+
+rfunc = responses.Theis()
+```
+
+Separate plugins are each stored in a separate submodule within the pastas-plugins
+package. You do not need to install the dependencies for each plugin if you're only
+interested in one particular plugin.

pastas_plugins-0.1.0/README.md

@@ -0,0 +1,66 @@
+# pastas-plugins
+
+Welcome to the pastas-plugins repository, your one-stop-shop for customized
+cutting-edge additions to Pastas.
+
+
+## Current plugins
+
+The following plugins are now available:
+
+- **`cross_correlation`**: analyze and visualize the cross-correlation between two time series.
+- **`modflow`**: use modflow models as response functions.
+- **`reservoirs`**: use reservoir models to simulate time series.
+- **`responses`**: custom response functions for Pastas.
+
+## Installation
+
+<!-- TODO: add repo to PYPI so this becomes true: -->
+Install `pastas-plugins` with:
+
+```bash
+pip install pastas_plugins
+```
+
+If you want to use a specific plugin and want to ensure you install all the requisite
+dependencies, you can use the following command:
+
+```bash
+pip install pastas-plugins[<name of plugin>]
+```
+
+If you want to install them all:
+```bash
+pip install pastas-plugins[all]
+```
+
+## Usage
+
+Import the pastas-plugins module with:
+
+```python
+import pastas_plugins as pp
+```
+
+This gives you access to the following functions:
+
+```python
+pp.list_plugins()         # list of all plugins
+pp.show_plugin_versions() # show plugin versions 
+```
+
+The function `pp.show_plugin_versions()` will indicate if any dependencies are missing
+for a particular plugin. See the [Installation](#installation) section above for tips
+on how to install dependencies for a particular plugin.
+
+To use a particular plugin, you'll have to import it explicitly, e.g.:
+
+```python
+from pastas_plugins import responses
+
+rfunc = responses.Theis()
+```
+
+Separate plugins are each stored in a separate submodule within the pastas-plugins
+package. You do not need to install the dependencies for each plugin if you're only
+interested in one particular plugin.

pastas_plugins-0.1.0/pastas_plugins/__init__.py

@@ -0,0 +1,35 @@
+# ruff : noqa: F401
+import pathlib
+from importlib import import_module
+
+# from platform import python_version
+# from packaging.version import parse as parse_version
+from pastas_plugins.version import __version__
+
+
+def list_plugins():
+    plugins = pathlib.Path(__file__).parent.iterdir()
+    plugins = [
+        plugin.stem
+        for plugin in plugins
+        if plugin.is_dir() and not plugin.stem.startswith("_")
+    ]
+    plugins.sort()
+    return plugins
+
+
+def show_plugin_versions():
+    showtip = False
+    plugins = list_plugins()
+    msg = f"pastas_plugins version      : {__version__}\n"
+    for plugin in plugins:
+        try:
+            module = import_module(f"pastas_plugins.{plugin}.version")
+            version = module.__version__
+        except ModuleNotFoundError:
+            showtip = True
+            version = "not available (check dependencies)"
+        msg += f"- {(plugin + ' version'):25s} : {version}\n"
+    if showtip:
+        msg += "\nNote: To install missing dependencies use `pip install pastas-plugins[<plugin-name>]`"
+    print(msg)

pastas_plugins-0.1.0/pastas_plugins/cross_correlation/__init__.py

@@ -0,0 +1,8 @@
+# ruff: noqa: F401
+from pastas_plugins.cross_correlation.cross_correlation import (
+    ccf,
+    fit_response,
+    prewhiten,
+)
+from pastas_plugins.cross_correlation.plots import plot_ccf_overview, plot_corr
+from pastas_plugins.cross_correlation.version import __version__

pastas_plugins-0.1.0/pastas_plugins/cross_correlation/cross_correlation.py

@@ -0,0 +1,188 @@
+from typing import Tuple, Union
+
+import numpy as np
+import pandas as pd
+import pastas as ps
+import scipy as sc
+from statsmodels.tsa.ar_model import AutoReg
+from statsmodels.tsa.arima.model import ARIMA
+from statsmodels.tsa.filters.filtertools import convolution_filter
+
+
+def ccf(
+    x: pd.Series,
+    y: pd.Series,
+    nlags: Union[int, None] = None,
+    adjusted: bool = True,
+    alpha: Union[float, None] = None,
+) -> Union[pd.Series, pd.DataFrame]:
+    """Cross-correlation of two time series.
+
+    Parameters
+    ----------
+    x : pd.Series
+        Time series
+    y : pd.Series
+        Time series, len(y) should be equal to len(x).
+    nlags : int or None, optional
+        Number of lags to return cross-correlations for, by default None which
+        uses nlags equal to len(x).
+    adjusted : bool, optional
+        If True, denominators for cross-correlation are len(x)-k, otherwise
+        len(x), by default True
+    alpha : float or None, optional
+        If a float between 0 and 1 is given, the confidence intervals for the
+        given level are returned in a DataFrame. For instance if alpha=0.05,
+        95% confidence intervals are returned where the standard deviation is
+        computed according to 1/sqrt(len(x)).
+
+    Returns
+    -------
+    pandas Series or DataFrame
+    """
+    # check if lengths are equal
+    assert len(x) == len(y), "Length of series x and y should be equal"
+    # check if series are equidistant
+    for series in (x, y):
+        if pd.infer_freq(series.index) is None:
+            msg = (
+                "The frequency of the index of time series %s could not be "
+                "inferred. Please provide a time series with a equidistant time step."
+            )
+            raise ValueError(msg % series.name)
+
+    n = len(x)
+
+    xbar = x - x.mean()
+    ybar = y - y.mean()
+
+    d = np.arange(n, 0, -1) if adjusted else n
+    cc = sc.signal.correlate(xbar, ybar, mode="full", method="fft")
+    cvf = cc[n - 1 :] / (np.std(x) * np.std(y) * d)
+
+    nlags = n if nlags is None else nlags
+    index = pd.Index(np.arange(nlags), name="Lags")
+    ret = cvf[:nlags]
+
+    if alpha is not None:
+        interval = sc.stats.norm.ppf(1.0 - alpha / 2.0) / np.sqrt(n)
+        crosscorr = pd.DataFrame(
+            data=np.vstack([ret, ret - interval, ret + interval]).T,
+            index=index,
+            columns=["Cross-correlation", f"CI {alpha / 2}", f"CI {1 - alpha / 2}"],
+        )
+    else:
+        crosscorr = pd.Series(
+            data=ret,
+            index=index,
+            name="Cross-correlation",
+        )
+    return crosscorr
+
+
+def prewhiten(
+    x: pd.Series, y: Union[pd.Series, None] = None, ar: int = 20, arima: bool = False
+) -> Union[pd.Series, Tuple[pd.Series]]:
+    """Prewhiten time series using AR(ar) model.
+
+    An AR(ar) model is fitted on time series x. The goal is to obtain residuals that
+    adhere to a white noise process. Next, the AR(ar) model is applied to time series Y.
+
+    Note
+    ----
+    If prewhitened time series for x still shows significant autocorrelation or partial
+    autocorrelation, try increasing the number of autoregressive parameters.
+
+    Parameters
+    ----------
+    x : pd.Series
+        time series on which AR(ar) model will be fitted
+    y : pd.Series, optional
+        time series that will be filtered using the AR(ar) model fitted on x
+    ar : int, optional
+        number of autoregressive parameters (sometimes called `p`), by default 20
+    arima: bool, optional
+        use an ARIMA(ar,0,0) model instead of an AR(ar) model, by default False
+        which causes a significant speedup at the cost of a very small accuracy
+        penalty
+
+    Returns
+    -------
+    pwx : pd.Series
+        prewhitened time series for x (should no longer show significant
+        autocorrelation or partial autocorrelation)
+    pwy : pd.Series, optional
+        prewhitened time series for y, if y is provided
+    """
+
+    # fit AR model on x
+    if arima:
+        ml = ARIMA(x.values, order=(ar, 0, 0), trend="c").fit()
+    else:
+        ml = AutoReg(x.values, lags=ar, trend="c").fit()
+
+    # get model filtered model residuals
+    residuals = ml.resid[ar:] if arima else ml.resid
+    pwx = pd.Series(residuals, index=x.index[ar:])
+
+    if y is not None:
+        # apply same filter on y
+        arparams = ml.arparams if arima else ml.params[1:]
+        filt = np.append(1.0, -arparams)
+        pwy = convolution_filter(y.values, filt=filt, nsides=1)
+        pwy = pd.Series(data=pwy[ar:], index=y.index[ar:])
+        return pwx, pwy
+    else:
+        return pwx
+
+
+def fit_response(
+    ccf: pd.Series,
+    rfunc: ps.typing.RFunc,
+    scale_factor: float = 1.0,
+    dt: float = 1.0,
+) -> np.ndarray[float]:
+    """Fit the response function to the cross-correlation function using least
+    squares optimization.
+
+    Parameters:
+    -----------
+    ccf : pd.Series
+        The cross-correlation function.
+    rfunc : ps.typing.RFunc
+        The response function to fit on the impulse response.
+    scale_factor : float, optional
+        Scale factor applied to the cross-correlation function to obtain the
+        impulse response, by default 1.0.
+    dt : float, optional
+        Time step of the response function, by default 1.0.
+
+    Returns:
+    --------
+    np.ndarray[float]
+        The optimized parameters of the response function.
+
+    """
+
+    def obj_func(p):
+        """Objective function for least squares optimization."""
+        impulse_response = (ccf * scale_factor).values
+        blockr = rfunc.block(p, dt=dt, cutoff=rfunc.cutoff)
+
+        # make sure length of residuals is constant
+        if len(blockr) > len(impulse_response):
+            blockr = blockr[: len(impulse_response)]
+        elif len(blockr) < len(impulse_response):
+            blockr = np.append(blockr, np.zeros(len(impulse_response) - len(blockr)))
+
+        return impulse_response - blockr
+
+    params = rfunc.get_init_parameters(rfunc._name)
+    pini = params["initial"].values
+    bounds = (
+        params["pmin"].fillna(-np.inf).values,
+        params["pmax"].fillna(np.inf).values,
+    )
+
+    res = sc.optimize.least_squares(obj_func, x0=pini, bounds=bounds)
+    return res.x

pastas_plugins-0.1.0/pastas_plugins/cross_correlation/plots.py

@@ -0,0 +1,245 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from statsmodels.graphics.tsaplots import _plot_corr, plot_acf, plot_pacf
+
+from pastas_plugins.cross_correlation.cross_correlation import ccf
+
+
+def plot_corr(
+    corr: pd.Series | pd.DataFrame,
+    ax: plt.Axes | None = None,
+    vlines_kwargs: dict | None = None,
+    **kwargs,
+):
+    """Helper function for the statsmodels _plot_corr function.
+
+    Parameters
+    ----------
+    corr : pd.Series or pd.DataFrame
+        the correlation result to plot
+    ax : plt.Axes, optional
+        axes to plot on, by default None
+    vlines_kwargs : dict, optional
+        keyword arguments for the vlines function, by default None
+
+    Returns
+    -------
+    plt.Axes
+        axes with the plot
+    """
+
+    if ax is None:
+        _, ax = plt.subplots(**kwargs)
+
+    acf_x = corr.values if isinstance(corr, pd.Series) else corr.iloc[:, 0].values
+    confint = corr.iloc[:, 1:3].values if isinstance(corr, pd.DataFrame) else None
+    lags = corr.index.values
+    vlines_kwargs = {} if vlines_kwargs is None else vlines_kwargs
+    _plot_corr(
+        ax=ax,
+        title="",
+        acf_x=acf_x,
+        confint=confint,
+        lags=lags,
+        irregular=False,
+        use_vlines=True,
+        vlines_kwargs=vlines_kwargs,
+    )
+    return ax
+
+
+def plot_ccf_overview(x, y, nlags=None, tmin=None, tmax=None, axes=None):
+    """Plot an overview of the cross-correlation between two time series.
+
+    Parameters
+    ----------
+    x : pd.Series
+        Time series 1
+    y : pd.Series
+        Time series 2
+    nlags : int, optional
+        number of lags to return cross-correlations for, by default None which
+        uses number of lags equal to len(x).
+    tmin : str or pd.Timestamp, optional
+        tmin for both time series, by default None
+    tmax : str or pd.Timestamp, optional
+        tmax for both time series, by default None
+    axes : Axes mosaic, optional
+        if provided, use axes from previous plot
+
+    Returns
+    -------
+    axes : Axes mosaic
+        return axes of subplots mosaic
+    """
+    if tmin is None:
+        tmin = np.min([x.index[0], y.index[0]])
+    if tmax is None:
+        tmax = np.max([x.index[-1], y.index[-1]])
+
+    x = x.loc[tmin:tmax]
+    y = y.loc[tmin:tmax]
+
+    if axes is None:
+        mosaic = [
+            ["x", "x", "norm", "norm"],
+            ["y", "y", "norm", "norm"],
+            ["x-acf", "y-acf", "ccf", "ccf"],
+            ["x-pacf", "y-pacf", "ccf", "ccf"],
+        ]
+
+        fig, axes = plt.subplot_mosaic(mosaic, figsize=(16, 8))
+        rescale_axes = False
+        newaxes = True
+        color1 = "C0"
+        color2 = "C1"
+    else:
+        fig = axes["x"].figure
+        rescale_axes = True
+        newaxes = False
+        color1 = "C2"
+        color2 = "C3"
+
+    # set names if not provided
+    if x.name is None:
+        x.name = "x"
+    if y.name is None:
+        y.name = "y"
+
+    # plot time series
+    axes["x"].plot(x.index, x, label=x.name, color=color1)
+    axes["x"].legend(loc=(0, 1), frameon=False)
+    axes["x"].set_ylabel("x")
+    axes["x"].set_xlim(pd.Timestamp(tmin), pd.Timestamp(tmax))
+    axes["y"].plot(y.index, y, label=y.name, c=color2)
+    axes["y"].legend(loc=(0, 1), frameon=False)
+    axes["y"].set_ylabel("y")
+    axes["y"].set_xlim(pd.Timestamp(tmin), pd.Timestamp(tmax))
+
+    # plot normalized series
+    xnorm = (x - x.mean()) / x.std()
+    ynorm = (y - y.mean()) / y.std()
+    axes["norm"].plot(
+        xnorm.index, xnorm, label=x.name + " (normalized)", alpha=0.7, color=color1
+    )
+    axes["norm"].plot(
+        ynorm.index, ynorm, label=y.name + " (normalized)", alpha=0.7, color=color2
+    )
+    axes["norm"].legend(loc=(0, 1), frameon=False, ncol=2)
+    axes["norm"].set_ylabel("normalized [-]")
+    axes["norm"].set_xlim(pd.Timestamp(tmin), pd.Timestamp(tmax))
+    handles, _ = axes["norm"].get_legend_handles_labels()
+
+    # plot acf, pacf
+    plot_acf(
+        xnorm,
+        ax=axes["x-acf"],
+        color=color1,
+        alpha=0.05,
+        title="",
+        zero=False,
+        auto_ylims=True,
+        vlines_kwargs={"color": "k"},
+    )
+    plot_acf(
+        ynorm,
+        ax=axes["y-acf"],
+        color=color2,
+        alpha=0.05,
+        title="",
+        zero=False,
+        auto_ylims=True,
+        vlines_kwargs={"color": "k"},
+    )
+    axes["x-acf"].set_xlim(left=0.0)
+    axes["x-acf"].set_ylabel("ACF [-]")
+    (p1,) = axes["x-acf"].plot([], [], marker="o", ls="none", color=color1)
+    if not newaxes:
+        leg = axes["x-acf"].get_legend()
+        handles = leg.legend_handles
+        labels = [t.get_text() for t in leg.get_texts()]
+        handles += [p1]
+        labels += [x.name]
+    else:
+        handles = [p1]
+        labels = [x.name]
+
+    axes["x-acf"].legend(handles, labels, loc=(0, 1), frameon=False)
+    axes["y-acf"].set_xlim(left=0.0)
+    axes["y-acf"].get_children()[3].set_facecolor(color2)
+    (p2,) = axes["y-acf"].plot([], [], marker="o", ls="none", color=color2)
+    if not newaxes:
+        leg = axes["y-acf"].get_legend()
+        handles = leg.legend_handles
+        labels = [t.get_text() for t in leg.get_texts()]
+        handles += [p2]
+        labels += [y.name]
+    else:
+        handles = [p2]
+        labels = [y.name]
+    axes["y-acf"].legend(handles, labels, loc=(0, 1), frameon=False)
+
+    plot_pacf(
+        xnorm,
+        method="ywm",
+        ax=axes["x-pacf"],
+        color=color1,
+        alpha=0.05,
+        title="",
+        zero=False,
+        auto_ylims=True,
+        vlines_kwargs={"color": "k"},
+    )
+    plot_pacf(
+        ynorm,
+        method="ywm",
+        ax=axes["y-pacf"],
+        color=color2,
+        alpha=0.05,
+        title="",
+        zero=False,
+        auto_ylims=True,
+        vlines_kwargs={"color": "k"},
+    )
+    axes["x-pacf"].set_xlim(left=0.0)
+    axes["x-pacf"].set_ylabel("PACF [-]")
+    axes["x-pacf"].set_xlabel("Lags")
+
+    axes["y-pacf"].set_xlim(left=0.0)
+    axes["y-pacf"].get_children()[3].set_facecolor("C1")
+    axes["y-pacf"].set_xlabel("Lags")
+
+    # ccf
+    cc = ccf(x, y, nlags=nlags)
+    axes["ccf"].bar(
+        cc.index,
+        cc,
+        width=1.0,
+        linewidth=0.5,
+        alpha=0.5,
+        label=f"CCF ({x.name}|{y.name})",
+    )
+    axes["ccf"].set_ylabel("CCF [-]")
+    axes["ccf"].set_xlabel("Lags")
+    axes["ccf"].legend(loc=(0, 1), frameon=False)
+    axes["ccf"].set_xlim(left=0.0)
+
+    share_x = [axes["x"], axes["y"], axes["norm"]]
+    for i, iax in enumerate(share_x):
+        if i < (len(share_x) - 1):
+            iax.sharex(share_x[-1])
+
+    # share_x = [axes["x-acf"], axes["x-pacf"], axes["y-acf"], axes["y-pacf"]]
+    # for i, iax in enumerate(share_x):
+    #     if i < (len(share_x) - 1):
+    #         iax.sharex(share_x[-1])
+
+    fig.tight_layout()
+    fig.align_ylabels()
+
+    if rescale_axes:
+        for iax in axes.values():
+            iax.autoscale()
+
+    return axes