AeroViz 0.1.21__py3-none-any.whl

AeroViz/plot/templates/corr_matrix.py

@@ -0,0 +1,267 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from matplotlib import colormaps
+from matplotlib.pyplot import Figure, Axes
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+from scipy.stats import pearsonr
+
+from AeroViz.plot.utils import *
+
+__all__ = ['corr_matrix', 'cross_corr_matrix']
+
+
+@set_figure
+def corr_matrix(data: pd.DataFrame,
+                cmap: str = "RdBu",
+                ax: Axes | None = None,
+                items_order: list = None,  # 新增參數用於指定順序
+                **kwargs
+                ) -> tuple[Figure, Axes]:
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+    _corr = data.corr()
+    breakpoint()
+    corr = pd.melt(_corr.reset_index(), id_vars='index')
+    corr.columns = ['x', 'y', 'value']
+
+    p_values = _corr.apply(lambda col1: _corr.apply(lambda col2: pearsonr(col1, col2)[1]))
+    p_values = p_values.mask(p_values > 0.05)
+    p_values = pd.melt(p_values.reset_index(), id_vars='index').dropna()
+    p_values.columns = ['x', 'y', 'value']
+
+    # Mapping from column names to integer coordinates
+    x_labels = [v for v in sorted(corr['x'].unique())]
+    y_labels = [v for v in sorted(corr['y'].unique())]
+    x_to_num = {p[1]: p[0] for p in enumerate(x_labels)}
+    y_to_num = {p[1]: p[0] for p in enumerate(y_labels)}
+
+    # Show column labels on the axes
+    ax.set_xticks([x_to_num[v] for v in x_labels])
+    ax.set_xticklabels(x_labels, rotation=90, horizontalalignment='center')
+    ax.set_yticks([y_to_num[v] for v in y_labels])
+    ax.set_yticklabels(y_labels)
+
+    # ax.tick_params(axis='both', which='major', direction='out', top=True, left=True)
+
+    ax.grid(False, 'major')
+    ax.grid(True, 'minor')
+    ax.set_xticks([t + 0.5 for t in ax.get_xticks()], minor=True)
+    ax.set_yticks([t + 0.5 for t in ax.get_yticks()], minor=True)
+
+    ax.set_xlim([-0.5, max([v for v in x_to_num.values()]) + 0.5])
+    ax.set_ylim([-0.5, max([v for v in y_to_num.values()]) + 0.5])
+
+    n_colors = 256  # Use 256 colors for the diverging color palette
+    palette = sns.color_palette(cmap, n_colors=n_colors)  # Create the palette
+
+    # Range of values that will be mapped to the palette, i.e. min and max possible correlation
+    color_min, color_max = [-1, 1]
+
+    def value_to_color(val):
+        val_position = float((val - color_min)) / (color_max - color_min)
+        ind = int(val_position * (n_colors - 1))  # target index in the color palette
+        return palette[ind]
+
+    point = ax.scatter(
+        x=corr['x'].map(x_to_num),
+        y=corr['y'].map(y_to_num),
+        s=corr['value'].abs() * 70,
+        c=corr['value'].apply(value_to_color),  # Vector of square color values, mapped to color palette
+        marker='s',
+        label='$R^{2}$'
+    )
+
+    axes_image = plt.cm.ScalarMappable(cmap=colormaps[cmap])
+
+    cax = inset_axes(ax, width="5%",
+                     height="100%",
+                     loc='lower left',
+                     bbox_to_anchor=(1.02, 0., 1, 1),
+                     bbox_transform=ax.transAxes,
+                     borderpad=0)
+
+    cbar = plt.colorbar(mappable=axes_image, cax=cax, label=r'$R^{2}$')
+
+    cbar.set_ticks([0, 0.25, 0.5, 0.75, 1])
+    cbar.set_ticklabels(np.linspace(-1, 1, 5))
+
+    point2 = ax.scatter(
+        x=p_values['x'].map(x_to_num),
+        y=p_values['y'].map(y_to_num),
+        s=10,
+        marker='*',
+        color='k',
+        label='p < 0.05'
+    )
+
+    ax.legend(handles=[point2], labels=['p < 0.05'], bbox_to_anchor=(0.02, 1, 0.05, 0.05))
+
+    plt.show()
+
+    return fig, ax
+
+
+@set_figure(figsize=(6, 6))
+def cross_corr_matrix(data1: pd.DataFrame,
+                      data2: pd.DataFrame,
+                      cmap: str = "RdBu",
+                      ax: Axes | None = None,
+                      items_order: list = None,  # 新增參數用於指定順序
+                      **kwargs
+                      ) -> tuple[Figure, Axes]:
+    """
+    Create a correlation matrix between two different DataFrames.
+
+    Parameters:
+    -----------
+    data1 : pd.DataFrame
+        First DataFrame
+    data2 : pd.DataFrame
+        Second DataFrame
+    cmap : str, optional
+        Color map for the correlation matrix
+    ax : Axes, optional
+        Matplotlib axes to plot on
+    items_order : list, optional
+        List specifying the order of items to display
+    **kwargs : dict
+        Additional keyword arguments
+    """
+    if ax is None:
+        fig_kws = kwargs.get('fig_kws', {})
+        default_figsize = fig_kws.get('figsize', (8, 8))
+        fig = plt.figure(figsize=default_figsize)
+        ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
+    else:
+        fig = ax.get_figure()
+
+    # 如果沒有指定順序，使用原始列名順序
+    if items_order is None:
+        x_labels = list(data1.columns)
+        y_labels = list(data2.columns)
+    else:
+        # 使用指定順序，但只包含實際存在於數據中的列
+        x_labels = [item for item in items_order if item in data1.columns]
+        y_labels = [item for item in items_order if item in data2.columns]
+
+    # Calculate cross-correlation between the two DataFrames
+    correlations = []
+    p_values_list = []
+
+    for col1 in x_labels:  # 使用指定順序的列名
+        for col2 in y_labels:
+            try:
+                mask = ~(np.isnan(data1[col1]) | np.isnan(data2[col2]))
+                if mask.sum() > 2:
+                    corr, p_val = pearsonr(data1[col1][mask], data2[col2][mask])
+                else:
+                    corr, p_val = np.nan, np.nan
+            except Exception as e:
+                print(f"Error calculating correlation for {col1} and {col2}: {str(e)}")
+                corr, p_val = np.nan, np.nan
+
+            correlations.append({
+                'x': col1,
+                'y': col2,
+                'value': corr
+            })
+            if p_val is not None and p_val < 0.05:
+                p_values_list.append({
+                    'x': col1,
+                    'y': col2,
+                    'value': p_val
+                })
+
+    corr = pd.DataFrame(correlations)
+    p_values = pd.DataFrame(p_values_list)
+
+    # Create mapping using the specified order
+    x_to_num = {label: i for i, label in enumerate(x_labels)}
+    y_to_num = {label: i for i, label in enumerate(y_labels)}
+
+    # 調整標籤顯示
+    ax.set_xticks([x_to_num[v] for v in x_labels])
+    ax.set_xticklabels(x_labels, rotation=45, ha='right')
+    ax.set_yticks([y_to_num[v] for v in y_labels])
+    ax.set_yticklabels(y_labels)
+
+    ax.grid(False, 'major')
+    ax.grid(True, 'minor')
+    ax.set_xticks([t + 0.5 for t in ax.get_xticks()], minor=True)
+    ax.set_yticks([t + 0.5 for t in ax.get_yticks()], minor=True)
+
+    ax.set_xlim([-0.5, max([v for v in x_to_num.values()]) + 0.5])
+    ax.set_ylim([-0.5, max([v for v in y_to_num.values()]) + 0.5])
+
+    # Color mapping
+    n_colors = 256
+    palette = sns.color_palette(cmap, n_colors=n_colors)
+    color_min, color_max = [-1, 1]
+
+    def value_to_color(val):
+        if pd.isna(val):
+            return (1, 1, 1)
+        val_position = float((val - color_min)) / (color_max - color_min)
+        val_position = np.clip(val_position, 0, 1)
+        ind = int(val_position * (n_colors - 1))
+        return palette[ind]
+
+    # Plot correlation squares
+    x_coords = corr['x'].map(x_to_num)
+    y_coords = corr['y'].map(y_to_num)
+    sizes = corr['value'].abs().fillna(0) * 70
+    colors = [value_to_color(val) for val in corr['value']]
+
+    point = ax.scatter(
+        x=x_coords,
+        y=y_coords,
+        s=sizes,
+        c=colors,
+        marker='s',
+        label='$R^{2}$'
+    )
+
+    # 調整顏色軸的位置和大小
+    cax = fig.add_axes([0.91, 0.1, 0.02, 0.8])
+    axes_image = plt.cm.ScalarMappable(cmap=colormaps[cmap])
+    cbar = plt.colorbar(mappable=axes_image, cax=cax, label=r'$R^{2}$')
+    cbar.set_ticks([0, 0.25, 0.5, 0.75, 1])
+    cbar.set_ticklabels(np.linspace(-1, 1, 5))
+
+    # Plot significance markers
+    if not p_values.empty:
+        point2 = ax.scatter(
+            x=p_values['x'].map(x_to_num),
+            y=p_values['y'].map(y_to_num),
+            s=10,
+            marker='*',
+            color='k',
+            label='p < 0.05'
+        )
+        ax.legend(handles=[point2], labels=['p < 0.05'],
+                  bbox_to_anchor=(0.005, 1.04), loc='upper left')
+
+    # Add labels
+    ax.set_xlabel('NZ', labelpad=10)
+    ax.set_ylabel('FS', labelpad=10)
+
+    plt.show()
+
+    return fig, ax
+
+
+if __name__ == '__main__':
+    import pandas as pd
+    from pandas import to_numeric
+
+    df_NZ = pd.read_csv('/Users/chanchihyu/Desktop/NZ_minion_202402-202411.csv', parse_dates=True, index_col=0)
+    df_FS = pd.read_csv('/Users/chanchihyu/Desktop/FS_minion_202402-202411.csv', parse_dates=True, index_col=0)
+
+    items = ['Ext', 'Sca', 'Abs', 'PNC', 'PSC', 'PVC', 'SO2', 'NO', 'NOx', 'NO2', 'CO', 'O3', 'THC', 'NMHC', 'CH4',
+             'PM10', 'PM2.5', 'WS', 'AT', 'RH',
+             'OC', 'EC', 'Na+', 'NH4+', 'NO3-', 'SO42-', 'Al', 'Si', 'Ca', 'Ti', 'V', 'Cr', 'Mn', 'Fe', 'Cu', 'Zn']
+    df_NZ = df_NZ.apply(to_numeric, errors='coerce')
+
+    corr_matrix(df_NZ[items], items_order=items)

AeroViz/plot/templates/diurnal_pattern.py

@@ -0,0 +1,61 @@
+import matplotlib.pyplot as plt
+from matplotlib.pyplot import Figure, Axes
+from matplotlib.ticker import AutoMinorLocator
+from pandas import DataFrame
+
+from AeroViz.plot.utils import *
+
+__all__ = ['diurnal_pattern']
+
+
+@set_figure
+def diurnal_pattern(df: DataFrame,
+                    y: str | list[str],
+                    std_area: float = 0.5,
+                    ax: Axes | None = None,
+                    **kwargs
+                    ) -> tuple[Figure, Axes]:
+    if 'hour' not in df.columns and 'Hour' not in df.columns:
+        df['Hour'] = df.index.hour
+
+    Hour = range(0, 24)
+    mean = df.groupby('Hour')[y].mean()
+    std = df.groupby('Hour')[y].std() * std_area
+
+    fig, ax = plt.subplots() if ax is None else (ax.get_figure(), ax)
+
+    # Plot Diurnal pattern
+    ax.plot(Hour, mean, 'blue', zorder=3)
+    ax.fill_between(Hour, y1=mean + std, y2=mean - std, alpha=0.2, color='blue', edgecolor=None, zorder=2)
+
+    # Plot Boxplot for each hour
+    bp = ax.boxplot([df[df['Hour'] == h][y].dropna() for h in Hour],
+                    positions=Hour,
+                    widths=0.5,
+                    patch_artist=True,
+                    showfliers=False,
+                    zorder=1)
+
+    # Customize boxplot colors
+    for element in ['boxes', 'whiskers', 'fliers', 'means', 'medians', 'caps']:
+        plt.setp(bp[element], color='gray')
+
+    for patch in bp['boxes']:
+        patch.set(facecolor='lightgray', alpha=0.5)
+
+    ax.set(xlabel=kwargs.get('xlabel', 'Hours'),
+           ylabel=kwargs.get('ylabel', Unit(y)),
+           xlim=kwargs.get('xlim', (-0.5, 23.5)),
+           ylim=kwargs.get('ylim', (None, None)),
+           xticks=kwargs.get('xticks', range(0, 24, 4)),
+           xticklabels=kwargs.get('xticklabels', range(0, 24, 4)))
+
+    ax.tick_params(axis='both', which='major')
+    ax.tick_params(axis='x', which='minor')
+    ax.xaxis.set_minor_locator(AutoMinorLocator())
+    ax.ticklabel_format(axis='y', style='sci', scilimits=(-2, 3), useMathText=True)
+
+    plt.tight_layout()
+    plt.show()
+
+    return fig, ax

AeroViz/plot/templates/koschmieder.py

@@ -0,0 +1,95 @@
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.pyplot import Figure, Axes
+from scipy.optimize import curve_fit
+
+from AeroViz.plot.utils import *
+
+__all__ = ['koschmieder']
+
+
+@set_figure(figsize=(2.4, 3))
+def koschmieder(df: pd.DataFrame,
+                vis: str,
+                ext: list[str],
+                ax: Axes | None = None,
+                **kwargs
+                ) -> tuple[Figure, Axes]:
+    """
+    Plot Koschmieder relationship between Visibility and Extinction.
+
+    x = Visibility, y = Extinction, log-log fit!!
+    """
+    def _log_fit(x, y, func=lambda x, a: -x + a):
+        x_log, y_log = np.log(x), np.log(y)
+        popt, pcov = curve_fit(func, x_log, y_log)
+
+        return np.exp(popt)[0], pcov
+
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+    boxcolors = ['#a5bf6b', '#3f83bf']
+    scattercolor = ['green', 'blue']
+    arts = []
+    labels = []
+
+    for i, ext_col in enumerate(ext):
+        _df = df[[ext_col, vis]].dropna().copy()
+        x_data = _df[vis]
+        y_data = _df[ext_col]
+
+        bins = np.linspace(0, 50, 25)
+        wid = (bins + (bins[1] - bins[0]) / 2)[0:-1]
+
+        _df[f'{vis}_bins'] = pd.cut(x_data, bins=bins, labels=wid)
+
+        grouped = _df.groupby(f'{vis}_bins', observed=False)
+
+        vis_labels, vals, median_vals = [], [], []
+        for _, subdf in grouped:
+            if len(subdf[ext_col].dropna()) > 3:
+                vis_labels.append(subdf[vis].mean())
+                vals.append(subdf[ext_col].dropna().values)
+                median_vals.append(subdf[ext_col].mean())
+
+        plt.boxplot(vals, labels=vis_labels, positions=np.array(vis_labels, dtype='float'),
+                    widths=(bins[1] - bins[0]) / 2.5,
+                    showfliers=False, showmeans=True, meanline=False, patch_artist=True,
+                    boxprops=dict(facecolor=boxcolors[i], alpha=.7),
+                    meanprops=dict(marker='o', markerfacecolor='white', markeredgecolor='k', markersize=4),
+                    medianprops=dict(color='#000000', ls='-'))
+
+        plt.scatter(x_data, y_data, marker='.', s=10, facecolor='white', edgecolor=boxcolors[i], alpha=0.1)
+
+        # fit curve
+        coeff, _ = _log_fit(np.array(vis_labels, dtype='float'), np.array(median_vals, dtype='float'))
+
+        # Plot lines (ref & Measurement)
+        x_fit = np.linspace(0.1, 50, 1000)
+
+        func = lambda x, a: a / x
+        line, = ax.plot(x_fit, func(x_fit, coeff), c=scattercolor[i], lw=3,
+                        label=f'Vis (km) = {round(coeff)} / Ext')
+
+        arts.append(line)
+        if 'dry' in ext_col:
+            labels.append(f'Vis (km) = {round(coeff)} / Ext (dry)')
+        else:
+            labels.append(f'Vis (km) = {round(coeff)} / Ext (amb)')
+
+    ax.legend(handles=arts, labels=labels, loc='upper right', prop=dict(weight='bold'), bbox_to_anchor=(0.99, 0.99))
+
+    ax.set(xlabel=kwargs.get('xlabel', 'Visibility (km)'),
+           ylabel=kwargs.get('ylabel', 'Extinction (1/Mm)'),
+           title=kwargs.get('title', 'Koschmieder relationship'),
+           xlim=kwargs.get('xlim', (0, 30)),
+           ylim=kwargs.get('ylim', (0, 800))
+           )
+
+    plt.xticks(ticks=np.array(range(0, 31, 5)), labels=np.array(range(0, 31, 5)))
+    fig.savefig('koschmieder.png', dpi=600)
+    plt.show()
+
+    return fig, ax

AeroViz/plot/templates/metal_heatmap.py

@@ -0,0 +1,164 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from matplotlib.pyplot import Figure, Axes
+from pandas import DataFrame, date_range, concat
+from sklearn.preprocessing import StandardScaler
+
+from AeroViz.plot.utils import *
+
+__all__ = ['metal_heatmaps', 'process_data_with_two_df']
+
+
+def process_data(df, detected_limit=True, outlier_threshold=5, smoothing_window=6, fill_method='MDL'):
+    # Fill missing values based on the specified method
+    df = fill_missing_values(df.copy(), method=fill_method)
+
+    # Normalize the data
+    df = normalize_data(df)
+
+    # Remove outliers
+    df = remove_outliers(df, threshold=outlier_threshold)
+
+    # Interpolate missing values
+    df = df.interpolate(method='linear')
+
+    # Smooth the data
+    df = smooth_data(df, window=smoothing_window)
+
+    return df
+
+
+def process_data_with_two_df(df, df2, outlier_threshold=5, smoothing_window=6, fill_method='MDL'):
+    # Shift the first DataFrame by 30 minutes
+    df = df.shift(freq='30min')
+
+    # Fill missing values for both DataFrames
+    df = fill_missing_values(df.copy(), method=fill_method)
+    df2 = fill_missing_values(df2.copy(), method=fill_method)
+
+    # Normalize both DataFrames together
+    df, df2 = normalize_and_split(df, df2)
+
+    # Shift the first DataFrame back by 30 minutes
+    df = df.shift(freq='-30min')
+
+    # Remove outliers for both DataFrames
+    df = remove_outliers(df, threshold=outlier_threshold)
+    df2 = remove_outliers(df2, threshold=outlier_threshold)
+
+    # Interpolate missing values
+    df = df.interpolate(method='linear')
+    df2 = df2.interpolate(method='linear')
+
+    # Smooth the data
+    df = smooth_data(df, window=smoothing_window)
+    df2 = smooth_data(df2, window=smoothing_window)
+
+    return df, df2
+
+
+def fill_missing_values(df, method='MDL'):
+    if method == 'interpolate':
+        return df.interpolate(method='linear')
+    else:
+        return fill_with_mdl(df)
+
+
+def fill_with_mdl(df):
+    # Minimum detection limit (MDL) dictionary
+    MDL = {
+        'Al': 100, 'Si': 18, 'P': 5.2, 'S': 3.2,
+        'Cl': 1.7, 'K': 1.2, 'Ca': 0.3, 'Ti': 1.6,
+        'V': 0.12, 'Cr': 0.12, 'Mn': 0.14, 'Fe': 0.17,
+        'Co': 0.14, 'Ni': 0.096, 'Cu': 0.079, 'Zn': 0.067,
+        'Ga': 0.059, 'Ge': 0.056, 'As': 0.063, 'Se': 0.081,
+        'Br': 0.1, 'Rb': 0.19, 'Sr': 0.22, 'Y': 0.28,
+        'Zr': 0.33, 'Nb': 0.41, 'Mo': 0.48, 'Pd': 2.2,
+        'Ag': 1.9, 'Cd': 2.5, 'In': 3.1, 'Sn': 4.1,
+        'Sb': 5.2, 'Te': 0.6, 'I': 0.49, 'Cs': 0.37,
+        'Ba': 0.39, 'La': 0.36, 'Ce': 0.3, 'Pt': 0.12,
+        'Au': 0.1, 'Hg': 0.12, 'Tl': 0.12, 'Pb': 0.13,
+        'Bi': 0.13
+    }
+
+    # Replace values below MDL with 5/6 * MDL
+    for element, threshold in MDL.items():
+        if element in df.columns:
+            df.loc[:, element] = df[element].where(df[element] >= threshold, 5 / 6 * threshold)
+
+    return df
+
+
+def normalize_data(df):
+    # Standardize the data (z-score normalization)
+    return DataFrame(StandardScaler().fit_transform(df), index=df.index, columns=df.columns)
+
+
+def remove_outliers(df, threshold=5):
+    # Remove rows where any column value exceeds the threshold
+    return df[(np.abs(df) < threshold)]
+
+
+def smooth_data(df, window=6):
+    # Apply rolling mean to smooth the data
+    return df.rolling(window=window, min_periods=1).mean()
+
+
+def normalize_and_split(df, df2):
+    # Concatenate DataFrames for combined normalization
+    combined_df = concat([df, df2])
+    normalized_combined_df = normalize_data(combined_df)
+
+    # Split the normalized DataFrame back into df and df2
+    df = normalized_combined_df.loc[df.index]
+    df2 = normalized_combined_df.loc[df2.index]
+
+    return df, df2
+
+
+@set_figure(figsize=(6, 3), fs=8, fw='normal')
+def metal_heatmaps(df,
+                   process=True,
+                   major_freq='10d',
+                   minor_freq='1d',
+                   cmap='jet',
+                   ax: Axes | None = None,
+                   **kwargs
+                   ) -> tuple[Figure, Axes]:
+    if process:
+        df = process_data(df)
+
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+    sns.heatmap(df.T, vmin=None, vmax=3, cmap=cmap, xticklabels=True, yticklabels=True,
+                cbar_kws={'label': 'Z score', "pad": 0.02})
+    ax.grid(color='gray', linestyle='-', linewidth=0.3)
+
+    # Set x-tick positions and labels
+    major_tick = date_range(start=df.index[0], end=df.index[-1], freq=major_freq)
+    minor_tick = date_range(start=df.index[0], end=df.index[-1], freq=minor_freq)
+
+    # Set the major and minor ticks
+    ax.set_xticks(ticks=[df.index.get_loc(t) for t in major_tick])
+    ax.set_xticks(ticks=[df.index.get_loc(t) for t in minor_tick], minor=True)
+    ax.set_xticklabels(major_tick.strftime('%F'), rotation=0)
+    ax.tick_params(axis='y', rotation=0)
+
+    ax.set(xlabel='',
+           ylabel='Trace metals',
+           title=kwargs.get('title', None)
+           )
+
+    if kwargs.get('savefig'):
+        plt.savefig(kwargs.get('savefig'), dpi=600)
+
+    plt.show()
+
+    return fig, ax
+
+
+if __name__ == '__main__':
+    fig, ax = plt.subplots(1, 1, figsize=(6, 6))
+    plt.title('text', font={'weight': 'bold'})
+    plt.show()

AeroViz/plot/timeseries/__init__.py

@@ -0,0 +1,2 @@
+from .template import *
+from .timeseries import *

AeroViz/plot/timeseries/template.py

@@ -0,0 +1,47 @@
+import matplotlib.pyplot as plt
+from matplotlib.pyplot import Figure, Axes
+from pandas import DataFrame
+
+from AeroViz.plot.timeseries.timeseries import timeseries
+
+
+def timeseries_template(df: DataFrame) -> tuple[Figure, Axes]:
+    fig, ax = plt.subplots(5, 1, figsize=(len(df.index) * 0.01, 4))
+    (ax1, ax2, ax3, ax4, ax5) = ax
+
+    timeseries(df,
+               y=['Extinction', 'Scattering', 'Absorption'],
+               rolling=30,
+               ax=ax1,
+               ylabel='Coefficient',
+               ylim=[0., None],
+               set_xaxis_visible=False,
+               legend_ncol=3,
+               )
+
+    # Temp, RH
+    timeseries(df,
+               y='AT',
+               y2='RH',
+               rolling=30,
+               ax=ax2,
+               ax_plot_kws=dict(color='r'),
+               ax2_plot_kws=dict(color='b'),
+               ylim=[10, 30],
+               ylim2=[20, 100],
+               set_xaxis_visible=False,
+               legend_ncol=2,
+               )
+
+    timeseries(df, y='WS', color='WD', style='scatter', ax=ax3, scatter_kws=dict(cmap='hsv'),
+               cbar_kws=dict(ticks=[0, 90, 180, 270, 360]),
+               ylim=[0, None], set_xaxis_visible=False)
+
+    timeseries(df, y='VC', color='PBLH', style='bar', ax=ax4, bar_kws=dict(cmap='Blues'), set_xaxis_visible=False,
+               ylim=[0, 5000])
+
+    timeseries(df, y='PM2.5', color='PM1/PM25', style='scatter', ax=ax5, ylim=[0, None])
+
+    plt.show()
+
+    return fig, ax