AeroViz 0.1.2__py3-none-any.whl → 0.1.3b0__py3-none-any.whl

AeroViz/plot/distribution/distribution.py

@@ -16,567 +16,561 @@ from tabulate import tabulate
 from AeroViz.plot.utils import *
 
 __all__ = [
-	'plot_dist',
-	'heatmap',
-	'heatmap_tms',
-	'three_dimension',
-	'curve_fitting'
+    'plot_dist',
+    'heatmap',
+    'heatmap_tms',
+    'three_dimension',
+    'curve_fitting'
 ]
 
 
 @set_figure
 def plot_dist(data: DataFrame | np.ndarray,
-			  data_std: DataFrame | None = None,
-			  std_scale: float | None = 1,
-			  unit: Literal["Number", "Surface", "Volume", "Extinction"] = 'Number',
-			  additional: Literal["Std", "Enhancement", "Error"] = None,
-			  fig: Figure | None = None,
-			  ax: Axes | None = None,
-			  **kwargs
-			  ) -> tuple[Figure, Axes]:
-	"""
-	Plot particle size distribution curves and optionally show enhancements.
-
-	Parameters
-	----------
-	data : dict or list
-		If dict, keys are labels and values are arrays of distribution values.
-		If listed, it should contain three arrays for different curves.
-	data_std : dict
-		Dictionary containing standard deviation data for ambient extinction distribution.
-	std_scale : float
-		The width of standard deviation.
-	unit : {'Number', 'Surface', 'Volume', 'Extinction'}
-		Unit of measurement for the data.
-	additional : {'std', 'enhancement', 'error'}
-		Whether to show enhancement curves.
-	fig : Figure, optional
-		Matplotlib Figure object to use.
-	ax : AxesSubplot, optional
-		Matplotlib AxesSubplot  object to use. If not provided, a new subplot will be created.
-	**kwargs : dict
-		Additional keyword arguments.
-
-	Returns
-	-------
-	ax : AxesSubplot
-		Matplotlib AxesSubplot.
-
-	Examples
-	--------
-	>>> plot_dist(DataFrame(...), additional="Enhancement")
-	"""
-	fig, ax = plt.subplots(**{**{'figsize': (6, 2)}, **kwargs.get('fig_kws', {})}) if ax is None else (
-		ax.get_figure(), ax)
-
-	# plot_kws
-	plot_kws = dict(ls='solid', lw=2, alpha=0.8, **kwargs.get('plot_kws', {}))
-
-	# Receive input data
-	dp = np.array(data.columns, dtype=float)
-	states = np.array(data.index)
-
-	for state in states:
-		mean = data.loc[state].to_numpy()
-		ax.plot(dp, mean, label=state, color=Color.color_choose[state][0], **plot_kws)
-
-		if additional == 'Std':
-			std = data_std.loc[state].to_numpy() * std_scale
-			ax.fill_between(dp, y1=mean - std, y2=mean + std, alpha=0.4, color=Color.color_choose[state][1],
-							edgecolor=None, label='__nolegend__')
-
-	# figure_set
-	ax.set(xlim=(dp.min(), dp.max()), ylim=(0, None), xscale='log',
-		   xlabel=r'$D_{p} (nm)$', ylabel=Unit(f'{unit}_dist'), title=kwargs.get('title', unit))
-
-	ax.ticklabel_format(axis='y', style='sci', scilimits=(0, 3), useMathText=True)
-	ax.grid(axis='x', which='major', color='k', linestyle='dashdot', linewidth=0.4, alpha=0.4)
-
-	Clean = data.loc['Clean'].to_numpy()
-	Transition = data.loc['Transition'].to_numpy()
-	Event = data.loc['Event'].to_numpy()
-
-	if additional == "Enhancement":
-		ax2 = ax.twinx()
-		ax2.plot(dp, Transition / Clean, ls='dashed', color='k', label=f'{additional} ratio 1')
-		ax2.plot(dp, Event / Transition, ls='dashed', color='gray', label=f'{additional} ratio 2')
-		ax2.set(ylabel='Enhancement ratio')
-
-	elif additional == "Error":
-		ax2 = ax.twinx()
-		error1 = np.where(Transition != 0, np.abs(Clean - Transition) / Clean * 100, 0)
-		error2 = np.where(Event != 0, np.abs(Transition - Event) / Transition * 100, 0)
-
-		ax2.plot(dp, error1, ls='--', color='k', label='Error 1 ')
-		ax2.plot(dp, error2, ls='--', color='gray', label='Error 2')
-		ax2.set(ylabel='Error (%)')
-
-	# Combine legends from ax and ax2
-	axes_list = fig.get_axes()
-	legends_combined = [legend for axes in axes_list for legend in axes.get_legend_handles_labels()[0]]
-	labels_combined = [label for axes in axes_list for label in axes.get_legend_handles_labels()[1]]
-
-	ax.legend(legends_combined, labels_combined, prop={'weight': 'bold'})
-
-	plt.show()
-
-	return fig, ax
+              data_std: DataFrame | None = None,
+              std_scale: float | None = 1,
+              unit: Literal["Number", "Surface", "Volume", "Extinction"] = 'Number',
+              additional: Literal["Std", "Enhancement", "Error"] = None,
+              fig: Figure | None = None,
+              ax: Axes | None = None,
+              **kwargs
+              ) -> tuple[Figure, Axes]:
+    """
+    Plot particle size distribution curves and optionally show enhancements.
+
+    Parameters
+    ----------
+    data : dict or list
+        If dict, keys are labels and values are arrays of distribution values.
+        If listed, it should contain three arrays for different curves.
+    data_std : dict
+        Dictionary containing standard deviation data for ambient extinction distribution.
+    std_scale : float
+        The width of standard deviation.
+    unit : {'Number', 'Surface', 'Volume', 'Extinction'}
+        Unit of measurement for the data.
+    additional : {'std', 'enhancement', 'error'}
+        Whether to show enhancement curves.
+    fig : Figure, optional
+        Matplotlib Figure object to use.
+    ax : AxesSubplot, optional
+        Matplotlib AxesSubplot  object to use. If not provided, a new subplot will be created.
+    **kwargs : dict
+        Additional keyword arguments.
+
+    Returns
+    -------
+    ax : AxesSubplot
+        Matplotlib AxesSubplot.
+
+    Examples
+    --------
+    >>> plot_dist(DataFrame(...), additional="Enhancement")
+    """
+    fig, ax = plt.subplots(**{**{'figsize': (6, 2)}, **kwargs.get('fig_kws', {})}) if ax is None else (
+        ax.get_figure(), ax)
+
+    # plot_kws
+    plot_kws = dict(ls='solid', lw=2, alpha=0.8, **kwargs.get('plot_kws', {}))
+
+    # Receive input data
+    dp = np.array(data.columns, dtype=float)
+    states = np.array(data.index)
+
+    for state in states:
+        mean = data.loc[state].to_numpy()
+        ax.plot(dp, mean, label=state, color=Color.color_choose[state][0], **plot_kws)
+
+        if additional == 'Std':
+            std = data_std.loc[state].to_numpy() * std_scale
+            ax.fill_between(dp, y1=mean - std, y2=mean + std, alpha=0.4, color=Color.color_choose[state][1],
+                            edgecolor=None, label='__nolegend__')
+
+    # figure_set
+    ax.set(xlim=(dp.min(), dp.max()), ylim=(0, None), xscale='log',
+           xlabel=r'$D_{p} (nm)$', ylabel=Unit(f'{unit}_dist'), title=kwargs.get('title', unit))
+
+    ax.ticklabel_format(axis='y', style='sci', scilimits=(0, 3), useMathText=True)
+    ax.grid(axis='x', which='major', color='k', linestyle='dashdot', linewidth=0.4, alpha=0.4)
+
+    Clean = data.loc['Clean'].to_numpy()
+    Transition = data.loc['Transition'].to_numpy()
+    Event = data.loc['Event'].to_numpy()
+
+    if additional == "Enhancement":
+        ax2 = ax.twinx()
+        ax2.plot(dp, Transition / Clean, ls='dashed', color='k', label=f'{additional} ratio 1')
+        ax2.plot(dp, Event / Transition, ls='dashed', color='gray', label=f'{additional} ratio 2')
+        ax2.set(ylabel='Enhancement ratio')
+
+    else:
+        ax2 = ax.twinx()
+        error1 = np.where(Transition != 0, np.abs(Clean - Transition) / Clean * 100, 0)
+        error2 = np.where(Event != 0, np.abs(Transition - Event) / Transition * 100, 0)
+
+        ax2.plot(dp, error1, ls='--', color='k', label='Error 1 ')
+        ax2.plot(dp, error2, ls='--', color='gray', label='Error 2')
+        ax2.set(ylabel='Error (%)')
+
+    ax.legend(*combine_legends(fig.get_axes()), prop={'weight': 'bold'})
+
+    plt.show()
+
+    return fig, ax
 
 
 @set_figure
 def heatmap(data: DataFrame,
-			unit: Literal["Number", "Surface", "Volume", "Extinction"],
-			cmap: str = 'Blues',
-			colorbar: bool = False,
-			magic_number: int = 11,
-			ax: Axes | None = None,
-			**kwargs
-			) -> tuple[Figure, Axes]:
-	"""
-	Plot a heatmap of particle size distribution.
+            unit: Literal["Number", "Surface", "Volume", "Extinction"],
+            cmap: str = 'Blues',
+            colorbar: bool = False,
+            magic_number: int = 11,
+            ax: Axes | None = None,
+            **kwargs
+            ) -> tuple[Figure, Axes]:
+    """
+    Plot a heatmap of particle size distribution.
 
-	Parameters
-	----------
-	data : pandas.DataFrame
-		The data containing particle size distribution values. Each column corresponds to a size bin,
-		and each row corresponds to a different distribution.
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        The data containing particle size distribution values. Each column corresponds to a size bin,
+        and each row corresponds to a different distribution.
 
-	unit : {'Number', 'Surface', 'Volume', 'Extinction'}, optional
-		The unit of measurement for the data.
+    unit : {'Number', 'Surface', 'Volume', 'Extinction'}, optional
+        The unit of measurement for the data.
 
-	cmap : str, default='Blues'
-		The colormap to use for the heatmap.
+    cmap : str, default='Blues'
+        The colormap to use for the heatmap.
 
-	colorbar : bool, default=False
-		Whether to show the colorbar.
+    colorbar : bool, default=False
+        Whether to show the colorbar.
 
-	magic_number : int, default=11
-		The number of bins to use for the histogram.
+    magic_number : int, default=11
+        The number of bins to use for the histogram.
 
-	ax : matplotlib.axes.Axes, optional
-		The axes to plot the heatmap on. If not provided, a new subplot will be created.
+    ax : matplotlib.axes.Axes, optional
+        The axes to plot the heatmap on. If not provided, a new subplot will be created.
 
-	**kwargs
-		Additional keyword arguments to pass to matplotlib functions.
+    **kwargs
+        Additional keyword arguments to pass to matplotlib functions.
 
-	Returns
-	-------
-	matplotlib.axes.Axes
-		The Axes object containing the heatmap.
+    Returns
+    -------
+    matplotlib.axes.Axes
+        The Axes object containing the heatmap.
 
-	Examples
-	--------
-	>>> heatmap(DataFrame(...), unit='Number')
+    Examples
+    --------
+    >>> heatmap(DataFrame(...), unit='Number')
 
-	Notes
-	-----
-	This function calculates a 2D histogram of the log-transformed particle sizes and the distribution values.
-	It then plots the heatmap using a logarithmic color scale.
+    Notes
+    -----
+    This function calculates a 2D histogram of the log-transformed particle sizes and the distribution values.
+    It then plots the heatmap using a logarithmic color scale.
 
-	"""
-	fig, ax = plt.subplots(**{**{'figsize': (3, 3)}, **kwargs.get('fig_kws', {})}) if ax is None else (
-		ax.get_figure(), ax)
+    """
+    fig, ax = plt.subplots(**{**{'figsize': (3, 3)}, **kwargs.get('fig_kws', {})}) if ax is None else (
+        ax.get_figure(), ax)
 
-	min_value = 1e-8
-	dp = np.array(data.columns, dtype=float)
-	x = np.append(np.tile(dp, data.to_numpy().shape[0]), np.log(dp).max())
-	y = np.append(data.to_numpy().flatten(), min_value)
+    min_value = 1e-8
+    dp = np.array(data.columns, dtype=float)
+    x = np.append(np.tile(dp, data.to_numpy().shape[0]), np.log(dp).max())
+    y = np.append(data.to_numpy().flatten(), min_value)
 
-	# mask NaN
-	x = x[~np.isnan(y)]
-	y = y[~np.isnan(y)]
+    # mask NaN
+    x = x[~np.isnan(y)]
+    y = y[~np.isnan(y)]
 
-	# using log(x)
-	histogram, xedges, yedges = np.histogram2d(np.log(x), y, bins=len(dp) + magic_number)
-	histogram[histogram == 0] = min_value  # Avoid log(0)
+    # using log(x)
+    histogram, xedges, yedges = np.histogram2d(np.log(x), y, bins=len(dp) + magic_number)
+    histogram[histogram == 0] = min_value  # Avoid log(0)
 
-	plot_kws = dict(norm=colors.LogNorm(vmin=1, vmax=histogram.max()), cmap=cmap, **kwargs.get('plot_kws', {}))
+    plot_kws = dict(norm=colors.LogNorm(vmin=1, vmax=histogram.max()), cmap=cmap, **kwargs.get('plot_kws', {}))
 
-	pco = ax.pcolormesh(xedges[:-1], yedges[:-1], histogram.T, shading='gouraud', **plot_kws)
+    pco = ax.pcolormesh(xedges[:-1], yedges[:-1], histogram.T, shading='gouraud', **plot_kws)
 
-	# TODO:
-	ax.plot(np.log(dp), data.mean() + data.std(), ls='dashed', color='r', label='pollutant')
-	ax.plot(np.log(dp), data.mean(), ls='dashed', color='k', alpha=0.5, label='mean')
-	ax.plot(np.log(dp), data.mean() - data.std(), ls='dashed', color='b', label='clean')
+    ax.plot(np.log(dp), data.mean() + data.std(), ls='dashed', color='r', label='pollutant')
+    ax.plot(np.log(dp), data.mean(), ls='dashed', color='k', alpha=0.5, label='mean')
+    ax.plot(np.log(dp), data.mean() - data.std(), ls='dashed', color='b', label='clean')
 
-	ax.set(xlim=(np.log(dp).min(), np.log(dp).max()), ylim=(0, None),
-		   xlabel=r'$D_{p} (nm)$', ylabel=Unit(f'{unit}_dist'), title=kwargs.get('title', unit))
+    ax.set(xlim=(np.log(dp).min(), np.log(dp).max()), ylim=(0, None),
+           xlabel=r'$D_{p} (nm)$', ylabel=Unit(f'{unit}_dist'), title=kwargs.get('title', unit))
 
-	major_ticks = np.power(10, np.arange(np.ceil(np.log10(dp.min())), np.floor(np.log10(dp.max())) + 1))
-	minor_ticks = [v for v in np.concatenate([_ * np.arange(2, 10) for _ in major_ticks]) if min(dp) <= v <= max(dp)]
+    major_ticks = np.power(10, np.arange(np.ceil(np.log10(dp.min())), np.floor(np.log10(dp.max())) + 1))
+    minor_ticks = [v for v in np.concatenate([_ * np.arange(2, 10) for _ in major_ticks]) if min(dp) <= v <= max(dp)]
 
-	ax.set_xticks(np.log(major_ticks))
-	ax.set_xticks(np.log(minor_ticks), minor=True)
-	ax.xaxis.set_major_formatter(FuncFormatter(lambda tick, pos: "{:.0f}".format(np.exp(tick))))
+    ax.set_xticks(np.log(major_ticks))
+    ax.set_xticks(np.log(minor_ticks), minor=True)
+    ax.xaxis.set_major_formatter(FuncFormatter(lambda tick, pos: "{:.0f}".format(np.exp(tick))))
 
-	ax.ticklabel_format(axis='y', style='sci', scilimits=(0, 3), useMathText=True)
-	ax.grid(axis='x', which='major', color='k', linestyle='dashdot', linewidth=0.4, alpha=0.4)
-	ax.legend(prop={'weight': 'bold'})
+    ax.ticklabel_format(axis='y', style='sci', scilimits=(0, 3), useMathText=True)
+    ax.grid(axis='x', which='major', color='k', linestyle='dashdot', linewidth=0.4, alpha=0.4)
+    ax.legend(prop={'weight': 'bold'})
 
-	if colorbar:
-		plt.colorbar(pco, pad=0.02, fraction=0.05, label='Counts', **kwargs.get('cbar_kws', {}))
+    if colorbar:
+        plt.colorbar(pco, pad=0.02, fraction=0.05, label='Counts', **kwargs.get('cbar_kws', {}))
 
-	plt.show()
+    plt.show()
 
-	return fig, ax
+    return fig, ax
 
 
 @set_figure
 def heatmap_tms(data: DataFrame,
-				unit: Literal["Number", "Surface", "Volume", "Extinction"],
-				cmap: str = 'jet',
-				ax: Axes | None = None,
-				**kwargs
-				) -> tuple[Figure, Axes]:
-	""" Plot the size distribution over time.
+                unit: Literal["Number", "Surface", "Volume", "Extinction"],
+                cmap: str = 'jet',
+                ax: Axes | None = None,
+                **kwargs
+                ) -> tuple[Figure, Axes]:
+    """ Plot the size distribution over time.
 
-	Parameters
-	----------
-	data : DataFrame
-		A DataFrame of particle concentrations to plot the heatmap.
+    Parameters
+    ----------
+    data : DataFrame
+        A DataFrame of particle concentrations to plot the heatmap.
 
-	ax : matplotlib.axis.Axis
-		An axis object to plot on. If none is provided, one will be created.
+    ax : matplotlib.axis.Axis
+        An axis object to plot on. If none is provided, one will be created.
 
-	unit : Literal["Number", "Surface", "Volume", "Extinction"]
-		default='Number'
+    unit : Literal["Number", "Surface", "Volume", "Extinction"]
+        default='Number'
 
-	cmap : matplotlib.colormap, default='viridis'
-		The colormap to use. Can be anything other that 'jet'.
+    cmap : matplotlib.colormap, default='viridis'
+        The colormap to use. Can be anything other that 'jet'.
 
-	Returns
-	-------
-	ax : matplotlib.axis.Axis
+    Returns
+    -------
+    ax : matplotlib.axis.Axis
 
-	Notes
-	-----
-		Do not dropna when using this code.
+    Notes
+    -----
+        Do not dropna when using this code.
 
-	Examples
-	--------
-	Plot a SPMS + APS data:
-	>>> heatmap_tms(DataFrame(...), cmap='jet')
-	"""
-	fig, ax = plt.subplots(
-		**{**{'figsize': (len(data.index) * 0.01, 2)}, **kwargs.get('fig_kws', {})}) if ax is None else (
-		ax.get_figure(), ax)
+    Examples
+    --------
+    Plot a SPMS + APS data:
+    >>> heatmap_tms(DataFrame(...), cmap='jet')
+    """
+    fig, ax = plt.subplots(
+        **{**{'figsize': (len(data.index) * 0.01, 2)}, **kwargs.get('fig_kws', {})}) if ax is None else (
+        ax.get_figure(), ax)
 
-	time = data.index
-	dp = np.array(data.columns, dtype=float)
+    time = data.index
+    dp = np.array(data.columns, dtype=float)
 
-	# data = data.interpolate(method='linear', axis=0)
-	data = np.nan_to_num(data.to_numpy())
+    # data = data.interpolate(method='linear', axis=0)
+    data = np.nan_to_num(data.to_numpy())
 
-	vmin_mapping = {'Number': 1e2, 'Surface': 1e8, 'Volume': 1e9, 'Extinction': 1}
+    vmin_mapping = {'Number': 1e2, 'Surface': 1e8, 'Volume': 1e9, 'Extinction': 1}
 
-	# Set the colorbar min and max based on the min and max of the values
-	cbar_min = kwargs.get('cbar_kws', {}).pop('cbar_min', vmin_mapping[unit])
-	cbar_max = kwargs.get('cbar_kws', {}).pop('cbar_max', np.nanmax(data))
+    # Set the colorbar min and max based on the min and max of the values
+    cbar_min = kwargs.get('cbar_kws', {}).pop('cbar_min', vmin_mapping[unit])
+    cbar_max = kwargs.get('cbar_kws', {}).pop('cbar_max', np.nanmax(data))
 
-	# Set the plot_kws
-	plot_kws = dict(norm=colors.LogNorm(vmin=cbar_min, vmax=cbar_max), cmap=cmap, **kwargs.get('plot_kws', {}))
+    # Set the plot_kws
+    plot_kws = dict(norm=colors.LogNorm(vmin=cbar_min, vmax=cbar_max), cmap=cmap, **kwargs.get('plot_kws', {}))
 
-	# main plot
-	pco = ax.pcolormesh(time, dp, data.T, shading='auto', **plot_kws)
+    # main plot
+    pco = ax.pcolormesh(time, dp, data.T, shading='auto', **plot_kws)
 
-	# Set ax
-	st_tm, fn_tm = time[0], time[-1]
-	tick_time = date_range(st_tm, fn_tm, freq=kwargs.get('freq', '10d')).strftime("%F")
+    # Set ax
+    st_tm, fn_tm = time[0], time[-1]
+    tick_time = date_range(st_tm, fn_tm, freq=kwargs.get('freq', '10d')).strftime("%F")
 
-	ax.set(xlim=(st_tm, fn_tm),
-		   ylim=(dp.min(), dp.max()),
-		   ylabel='$D_p (nm)$',
-		   xticks=tick_time,
-		   xticklabels=tick_time,
-		   yscale='log',
-		   title=kwargs.get('title', f'{st_tm.strftime("%F")} - {fn_tm.strftime("%F")}'))
+    ax.set(xlim=(st_tm, fn_tm),
+           ylim=(dp.min(), dp.max()),
+           ylabel='$D_p (nm)$',
+           xticks=tick_time,
+           xticklabels=tick_time,
+           yscale='log',
+           title=kwargs.get('title', f'{st_tm.strftime("%F")} - {fn_tm.strftime("%F")}'))
 
-	plt.colorbar(pco, pad=0.02, fraction=0.02, label=Unit(f'{unit}_dist'), **kwargs.get('cbar_kws', {}))
+    plt.colorbar(pco, pad=0.02, fraction=0.02, label=Unit(f'{unit}_dist'), **kwargs.get('cbar_kws', {}))
 
-	plt.show()
+    plt.show()
 
-	return fig, ax
+    return fig, ax
 
 
 @set_figure
 def three_dimension(data: DataFrame | np.ndarray,
-					unit: Literal["Number", "Surface", "Volume", "Extinction"],
-					cmap: str = 'Blues',
-					ax: Axes | None = None,
-					**kwargs
-					) -> tuple[Figure, Axes]:
-	"""
-	Create a 3D plot with data from a pandas DataFrame or numpy array.
+                    unit: Literal["Number", "Surface", "Volume", "Extinction"],
+                    cmap: str = 'Blues',
+                    ax: Axes | None = None,
+                    **kwargs
+                    ) -> tuple[Figure, Axes]:
+    """
+    Create a 3D plot with data from a pandas DataFrame or numpy array.
 
-	Parameters
-	----------
-	data : DataFrame or ndarray
-		Input data containing the values to be plotted.
+    Parameters
+    ----------
+    data : DataFrame or ndarray
+        Input data containing the values to be plotted.
 
-	unit : {'Number', 'Surface', 'Volume', 'Extinction'}
-		Unit of measurement for the data.
+    unit : {'Number', 'Surface', 'Volume', 'Extinction'}
+        Unit of measurement for the data.
 
-	cmap : str, default='Blues'
-		The colormap to use for the facecolors.
+    cmap : str, default='Blues'
+        The colormap to use for the facecolors.
 
-	ax : AxesSubplot, optional
-		Matplotlib AxesSubplot. If not provided, a new subplot will be created.
-	**kwargs
-		Additional keyword arguments to customize the plot.
+    ax : AxesSubplot, optional
+        Matplotlib AxesSubplot. If not provided, a new subplot will be created.
+    **kwargs
+        Additional keyword arguments to customize the plot.
 
-	Returns
-	-------
-	Axes
-		Matplotlib Axes object representing the 3D plot.
+    Returns
+    -------
+    Axes
+        Matplotlib Axes object representing the 3D plot.
 
-	Notes
-	-----
-	- The function creates a 3D plot with data provided in a pandas DataFrame or numpy array.
-	- The x-axis is logarithmically scaled, and ticks and labels are formatted accordingly.
-	- Additional customization can be done using the **kwargs.
+    Notes
+    -----
+    - The function creates a 3D plot with data provided in a pandas DataFrame or numpy array.
+    - The x-axis is logarithmically scaled, and ticks and labels are formatted accordingly.
+    - Additional customization can be done using the **kwargs.
 
-	Example
-	-------
-	>>> three_dimension(DataFrame(...), unit='Number', cmap='Blues')
-	"""
-	fig, ax = plt.subplots(figsize=(4, 4), subplot_kw={"projection": "3d"},
-						   **kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+    Example
+    -------
+    >>> three_dimension(DataFrame(...), unit='Number', cmap='Blues')
+    """
+    fig, ax = plt.subplots(figsize=(4, 4), subplot_kw={"projection": "3d"},
+                           **kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
 
-	dp = np.array(['11.7', *data.columns, '2437.4'], dtype=float)
-	lines = data.shape[0]
+    dp = np.array(['11.7', *data.columns, '2437.4'], dtype=float)
+    lines = data.shape[0]
 
-	_X, _Y = np.meshgrid(np.log(dp), np.arange(lines))
-	_Z = np.pad(data, ((0, 0), (1, 1)), 'constant')
+    _X, _Y = np.meshgrid(np.log(dp), np.arange(lines))
+    _Z = np.pad(data, ((0, 0), (1, 1)), 'constant')
 
-	verts = []
-	for i in range(_X.shape[0]):
-		verts.append(list(zip(_X[i, :], _Z[i, :])))
+    verts = []
+    for i in range(_X.shape[0]):
+        verts.append(list(zip(_X[i, :], _Z[i, :])))
 
-	facecolors = plt.colormaps[cmap](np.linspace(0, 1, len(verts)))
-	poly = PolyCollection(verts, facecolors=facecolors, edgecolors='k', lw=0.5, alpha=.7)
-	ax.add_collection3d(poly, zs=range(1, lines + 1), zdir='y')
+    facecolors = plt.colormaps[cmap](np.linspace(0, 1, len(verts)))
+    poly = PolyCollection(verts, facecolors=facecolors, edgecolors='k', lw=0.5, alpha=.7)
+    ax.add_collection3d(poly, zs=range(1, lines + 1), zdir='y')
 
-	ax.set(xlim=(np.log(11.7), np.log(2437.4)), ylim=(1, lines), zlim=(0, np.nanmax(_Z)),
-		   xlabel='$D_{p} (nm)$', ylabel='Class', zlabel=Unit(f'{unit}_dist'))
+    ax.set(xlim=(np.log(11.7), np.log(2437.4)), ylim=(1, lines), zlim=(0, np.nanmax(_Z)),
+           xlabel='$D_{p} (nm)$', ylabel='Class', zlabel=Unit(f'{unit}_dist'))
 
-	ax.set_xticks(np.log([10, 100, 1000]))
-	ax.set_xticks(np.log([20, 30, 40, 50, 60, 70, 80, 90, 200, 300, 400, 500, 600, 700, 800, 900, 2000]), minor=True)
-	ax.xaxis.set_major_formatter(FuncFormatter((lambda tick, pos: "{:.0f}".format(np.exp(tick)))))
-	ax.ticklabel_format(axis='z', style='sci', scilimits=(0, 3), useMathText=True)
+    ax.set_xticks(np.log([10, 100, 1000]))
+    ax.set_xticks(np.log([20, 30, 40, 50, 60, 70, 80, 90, 200, 300, 400, 500, 600, 700, 800, 900, 2000]), minor=True)
+    ax.xaxis.set_major_formatter(FuncFormatter((lambda tick, pos: "{:.0f}".format(np.exp(tick)))))
+    ax.ticklabel_format(axis='z', style='sci', scilimits=(0, 3), useMathText=True)
 
-	ax.zaxis.get_offset_text().set_visible(False)
-	exponent = np.floor(np.log10(np.nanmax(data))).astype(int)
-	ax.text(ax.get_xlim()[1] * 1.05, ax.get_ylim()[1], ax.get_zlim()[1] * 1.1, s=fr'${{\times}}\ 10^{exponent}$')
+    ax.zaxis.get_offset_text().set_visible(False)
+    exponent = np.floor(np.log10(np.nanmax(data))).astype(int)
+    ax.text(ax.get_xlim()[1] * 1.05, ax.get_ylim()[1], ax.get_zlim()[1] * 1.1, s=fr'${{\times}}\ 10^{exponent}$')
 
-	plt.show()
+    plt.show()
 
-	return fig, ax
+    return fig, ax
 
 
 @set_figure
 def curve_fitting(dp: np.ndarray,
-				  dist: np.ndarray | Series | DataFrame,
-				  mode: int = None,
-				  unit: Literal["Number", "Surface", "Volume", "Extinction"] = None,
-				  ax: Axes | None = None,
-				  **kwargs
-				  ) -> tuple[Figure, Axes]:
-	"""
-	Fit a log-normal distribution to the given data and plot the result.
+                  dist: np.ndarray | Series | DataFrame,
+                  mode: int = None,
+                  unit: Literal["Number", "Surface", "Volume", "Extinction"] = None,
+                  ax: Axes | None = None,
+                  **kwargs
+                  ) -> tuple[Figure, Axes]:
+    """
+    Fit a log-normal distribution to the given data and plot the result.
 
-	Parameters
-	----------
-	- dp (array): Array of diameter values.
-	- dist (array): Array of distribution values corresponding to each diameter.
-	- mode (int, optional): Number of log-normal distribution to fit (default is None).
-	- **kwargs: Additional keyword arguments to be passed to the plot_function.
+    Parameters
+    ----------
+    - dp (array): Array of diameter values.
+    - dist (array): Array of distribution values corresponding to each diameter.
+    - mode (int, optional): Number of log-normal distribution to fit (default is None).
+    - **kwargs: Additional keyword arguments to be passed to the plot_function.
 
-	Returns
-	-------
-	None
+    Returns
+    -------
+    None
 
-	Notes
-	-----
-	- The function fits a sum of log-normal distribution to the input data.
-	- The number of distribution is determined by the 'mode' parameter.
-	- Additional plotting customization can be done using the **kwargs.
+    Notes
+    -----
+    - The function fits a sum of log-normal distribution to the input data.
+    - The number of distribution is determined by the 'mode' parameter.
+    - Additional plotting customization can be done using the **kwargs.
 
-	Example
-	-------
-	>>> curve_fitting(dp, dist, mode=2, xlabel="Diameter (nm)", ylabel="Distribution")
-	"""
-	fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+    Example
+    -------
+    >>> curve_fitting(dp, dist, mode=2, xlabel="Diameter (nm)", ylabel="Distribution")
+    """
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
 
-	# Calculate total number concentration and normalize distribution
-	total_num = np.sum(dist * log(dp))
-	norm_data = dist / total_num
+    # Calculate total number concentration and normalize distribution
+    total_num = np.sum(dist * log(dp))
+    norm_data = dist / total_num
 
-	def lognorm_func(x, *params):
-		num_distributions = len(params) // 3
-		result = np.zeros_like(x)
+    def lognorm_func(x, *params):
+        num_distributions = len(params) // 3
+        result = np.zeros_like(x)
 
-		for i in range(num_distributions):
-			offset = i * 3
-			_number, _geomean, _geostd = params[offset: offset + 3]
+        for i in range(num_distributions):
+            offset = i * 3
+            _number, _geomean, _geostd = params[offset: offset + 3]
 
-			result += (_number / (log(_geostd) * sqrt(2 * pi)) *
-					   exp(-(log(x) - log(_geomean)) ** 2 / (2 * log(_geostd) ** 2)))
+            result += (_number / (log(_geostd) * sqrt(2 * pi)) *
+                       exp(-(log(x) - log(_geomean)) ** 2 / (2 * log(_geostd) ** 2)))
 
-		return result
+        return result
 
-	# initial gauss
-	min_value = np.array([min(dist)])
-	extend_ser = np.concatenate([min_value, dist, min_value])
-	_mode, _ = find_peaks(extend_ser, distance=20)
-	peak = dp[_mode - 1]
-	mode = mode or len(peak)
+    # initial gauss
+    min_value = np.array([min(dist)])
+    extend_ser = np.concatenate([min_value, dist, min_value])
+    _mode, _ = find_peaks(extend_ser, distance=20)
+    peak = dp[_mode - 1]
+    mode = mode or len(peak)
 
-	# 初始參數猜測
-	initial_guess = [0.05, 20., 2.] * mode
+    # 初始參數猜測
+    initial_guess = [0.05, 20., 2.] * mode
 
-	# 設定參數範圍
-	bounds = ([1e-6, 10, 1] * mode, [1, 3000, 8] * mode)
+    # 設定參數範圍
+    bounds = ([1e-6, 10, 1] * mode, [1, 3000, 8] * mode)
 
-	# 使用 curve_fit 函數進行擬合
-	result = curve_fit(lognorm_func, dp, norm_data, p0=initial_guess, bounds=bounds)
+    # 使用 curve_fit 函數進行擬合
+    result = curve_fit(lognorm_func, dp, norm_data, p0=initial_guess, bounds=bounds)
 
-	# 獲取擬合的參數
-	params = result[0].tolist()
+    # 獲取擬合的參數
+    params = result[0].tolist()
 
-	print('\n' + "Fitting Results:")
-	table = []
+    print('\n' + "Fitting Results:")
+    table = []
 
-	for i in range(mode):
-		offset = i * 3
-		num, mu, sigma = params[offset:offset + 3]
-		table.append([f'log-{i + 1}', f"{num * total_num:.3f}", f"{mu:.3f}", f"{sigma:.3f}"])
+    for i in range(mode):
+        offset = i * 3
+        num, mu, sigma = params[offset:offset + 3]
+        table.append([f'log-{i + 1}', f"{num * total_num:.3f}", f"{mu:.3f}", f"{sigma:.3f}"])
 
-	# 使用 tabulate 來建立表格並印出
-	print(tabulate(table, headers=["log-", "number", "mu", "sigma"], floatfmt=".3f", tablefmt="fancy_grid"))
+    # 使用 tabulate 來建立表格並印出
+    print(tabulate(table, headers=["log-", "number", "mu", "sigma"], floatfmt=".3f", tablefmt="fancy_grid"))
 
-	fit_curve = total_num * lognorm_func(dp, *params)
+    fit_curve = total_num * lognorm_func(dp, *params)
 
-	plt.plot(dp, fit_curve, color='#c41b1b', label='Fitting curve', lw=2.5)
-	plt.plot(dp, dist, color='b', label='Observed curve', lw=2.5)
+    plt.plot(dp, fit_curve, color='#c41b1b', label='Fitting curve', lw=2.5)
+    plt.plot(dp, dist, color='b', label='Observed curve', lw=2.5)
 
-	ax.set(xlim=(dp.min(), dp.max()), ylim=(0, None), xscale='log',
-		   xlabel=r'$\bf D_{p}\ (nm)$', ylabel=Unit(f'{unit}_dist'), title=kwargs.get('title'))
+    ax.set(xlim=(dp.min(), dp.max()), ylim=(0, None), xscale='log',
+           xlabel=r'$\bf D_{p}\ (nm)$', ylabel=Unit(f'{unit}_dist'), title=kwargs.get('title'))
 
-	plt.grid(color='k', axis='x', which='major', linestyle='dashdot', linewidth=0.4, alpha=0.4)
-	ax.ticklabel_format(axis='y', style='sci', scilimits=(0, 3), useMathText=True)
-	ax.legend(prop={'weight': 'bold'})
+    plt.grid(color='k', axis='x', which='major', linestyle='dashdot', linewidth=0.4, alpha=0.4)
+    ax.ticklabel_format(axis='y', style='sci', scilimits=(0, 3), useMathText=True)
+    ax.legend(prop={'weight': 'bold'})
 
-	plt.show(block=True)
+    plt.show(block=True)
 
-	return fig, ax
+    return fig, ax
 
 
 @set_figure
 def ls_mode(**kwargs) -> tuple[Figure, Axes]:
-	"""
-	Plot log-normal mass size distribution for small mode, large mode, and sea salt particles.
+    """
+    Plot log-normal mass size distribution for small mode, large mode, and sea salt particles.
 
-	Parameters
-	----------
-	**kwargs : dict
-		Additional keyword arguments.
+    Parameters
+    ----------
+    **kwargs : dict
+        Additional keyword arguments.
 
-	Examples
-	--------
-	Example : Plot log-normal mass size distribution with default settings
-	>>> ls_mode()
-	"""
+    Examples
+    --------
+    Example : Plot log-normal mass size distribution with default settings
+    >>> ls_mode()
+    """
 
-	fig, ax = plt.subplots(**kwargs.get('fig_kws', {}))
+    fig, ax = plt.subplots(**kwargs.get('fig_kws', {}))
 
-	geoMean = [0.2, 0.5, 2.5]
-	geoStdv = [2.2, 1.5, 2.0]
-	color = ['g', 'r', 'b']
-	label = [r'$\bf Small\ mode\ :D_{g}\ =\ 0.2\ \mu m,\ \sigma_{{g}}\ =\ 2.2$',
-			 r'$\bf Large\ mode\ :D_{g}\ =\ 0.5\ \mu m,\ \sigma_{{g}}\ =\ 1.5$',
-			 r'$\bf Sea\ salt\ :D_{g}\ =\ 2.5\ \mu m,\ \sigma_{{g}}\ =\ 2.0$']
+    geoMean = [0.2, 0.5, 2.5]
+    geoStdv = [2.2, 1.5, 2.0]
+    color = ['g', 'r', 'b']
+    label = [r'$\bf Small\ mode\ :D_{g}\ =\ 0.2\ \mu m,\ \sigma_{{g}}\ =\ 2.2$',
+             r'$\bf Large\ mode\ :D_{g}\ =\ 0.5\ \mu m,\ \sigma_{{g}}\ =\ 1.5$',
+             r'$\bf Sea\ salt\ :D_{g}\ =\ 2.5\ \mu m,\ \sigma_{{g}}\ =\ 2.0$']
 
-	x = np.geomspace(0.001, 20, 10000)
-	for _gmd, _gsd, _color, _label in zip(geoMean, geoStdv, color, label):
-		lognorm = 1 / (log(_gsd) * sqrt(2 * pi)) * (exp(-(log(x) - log(_gmd)) ** 2 / (2 * log(_gsd) ** 2)))
+    x = np.geomspace(0.001, 20, 10000)
+    for _gmd, _gsd, _color, _label in zip(geoMean, geoStdv, color, label):
+        lognorm = 1 / (log(_gsd) * sqrt(2 * pi)) * (exp(-(log(x) - log(_gmd)) ** 2 / (2 * log(_gsd) ** 2)))
 
-		ax.semilogx(x, lognorm, color=_color, label=_label)
-		ax.fill_between(x, lognorm, 0, where=(lognorm > 0), color=_color, alpha=0.3, label='__nolegend__')
+        ax.semilogx(x, lognorm, color=_color, label=_label)
+        ax.fill_between(x, lognorm, 0, where=(lognorm > 0), color=_color, alpha=0.3, label='__nolegend__')
 
-	ax.set(xlim=(0.001, 20), ylim=(0, None), xscale='log', xlabel=r'$\bf D_{p}\ (nm)$',
-		   ylabel=r'$\bf Probability\ (dM/dlogdp)$', title=r'Log-normal Mass Size Distribution')
+    ax.set(xlim=(0.001, 20), ylim=(0, None), xscale='log', xlabel=r'$\bf D_{p}\ (nm)$',
+           ylabel=r'$\bf Probability\ (dM/dlogdp)$', title=r'Log-normal Mass Size Distribution')
 
-	ax.grid(color='k', axis='x', which='major', linestyle='dashdot', linewidth=0.4, alpha=0.4)
-	ax.legend(prop={'weight': 'bold'})
+    ax.grid(color='k', axis='x', which='major', linestyle='dashdot', linewidth=0.4, alpha=0.4)
+    ax.legend(prop={'weight': 'bold'})
 
-	plt.show()
+    plt.show()
 
-	return fig, ax
+    return fig, ax
 
 
 @set_figure
 def lognorm_dist(**kwargs) -> tuple[Figure, Axes]:
-	#
-	"""
-	Plot various particle size distribution to illustrate log-normal distribution and transformations.
+    #
+    """
+    Plot various particle size distribution to illustrate log-normal distribution and transformations.
 
-	Parameters
-	----------
-	**kwargs : dict
-		Additional keyword arguments.
+    Parameters
+    ----------
+    **kwargs : dict
+        Additional keyword arguments.
 
-	Examples
-	--------
-	Example : Plot default particle size distribution
-	>>> lognorm_dist()
-	"""
+    Examples
+    --------
+    Example : Plot default particle size distribution
+    >>> lognorm_dist()
+    """
 
-	fig, ax = plt.subplots(2, 2, **kwargs.get('fig_kws', {}))
-	([ax1, ax2], [ax3, ax4]) = ax
-	fig.suptitle('Particle Size Distribution', fontweight='bold')
-	plt.subplots_adjust(left=0.125, right=0.925, bottom=0.1, top=0.93, wspace=0.4, hspace=0.4)
+    fig, ax = plt.subplots(2, 2, **kwargs.get('fig_kws', {}))
+    ([ax1, ax2], [ax3, ax4]) = ax
+    fig.suptitle('Particle Size Distribution', fontweight='bold')
+    plt.subplots_adjust(left=0.125, right=0.925, bottom=0.1, top=0.93, wspace=0.4, hspace=0.4)
 
-	# pdf
-	normpdf = lambda x, mu, sigma: (1 / (sigma * sqrt(2 * pi))) * exp(-(x - mu) ** 2 / (2 * sigma ** 2))
-	lognormpdf = lambda x, gmean, gstd: (1 / (log(gstd) * sqrt(2 * pi))) * exp(
-		-(log(x) - log(gmean)) ** 2 / (2 * log(gstd) ** 2))
-	lognormpdf2 = lambda x, gmean, gstd: (1 / (x * log(gstd) * sqrt(2 * pi))) * exp(
-		-(log(x) - log(gmean)) ** 2 / (2 * log(gstd) ** 2))
+    # pdf
+    normpdf = lambda x, mu, sigma: (1 / (sigma * sqrt(2 * pi))) * exp(-(x - mu) ** 2 / (2 * sigma ** 2))
+    lognormpdf = lambda x, gmean, gstd: (1 / (log(gstd) * sqrt(2 * pi))) * exp(
+        -(log(x) - log(gmean)) ** 2 / (2 * log(gstd) ** 2))
+    lognormpdf2 = lambda x, gmean, gstd: (1 / (x * log(gstd) * sqrt(2 * pi))) * exp(
+        -(log(x) - log(gmean)) ** 2 / (2 * log(gstd) ** 2))
 
-	# 生成x
-	x = np.linspace(-10, 10, 1000)
-	x2 = np.geomspace(0.01, 100, 1000)
+    # 生成x
+    x = np.linspace(-10, 10, 1000)
+    x2 = np.geomspace(0.01, 100, 1000)
 
-	# Question 1
-	# 若對數常態分布x有gmd=3, gstd=2，ln(x) ~ 常態分佈，試問其分布的平均值與標準差??  Y ~ N(mu=log(gmean), sigma=log(gstd))
-	data1 = lognorm(scale=3, s=log(2)).rvs(size=5000)
+    # Question 1
+    # 若對數常態分布x有gmd=3, gstd=2，ln(x) ~ 常態分佈，試問其分布的平均值與標準差??  Y ~ N(mu=log(gmean), sigma=log(gstd))
+    data1 = lognorm(scale=3, s=log(2)).rvs(size=5000)
 
-	# Question 2
-	# 若常態分布x有平均值3 標準差1，exp(x)則為一對數常態分佈? 由對數常態分佈的定義 若隨機變數ln(Z)是常態分布 則Z為對數常態分布
-	# 因此已知Z = exp(x), so ln(Z)=x，Z ~ 對數常態分佈，試問其分布的幾何平均值與幾何標準差是??  Z ~ LN(geoMean=exp(mu), geoStd=exp(sigma))
-	data2 = norm(loc=3, scale=1).rvs(size=5000)
+    # Question 2
+    # 若常態分布x有平均值3 標準差1，exp(x)則為一對數常態分佈? 由對數常態分佈的定義 若隨機變數ln(Z)是常態分布 則Z為對數常態分布
+    # 因此已知Z = exp(x), so ln(Z)=x，Z ~ 對數常態分佈，試問其分布的幾何平均值與幾何標準差是??  Z ~ LN(geoMean=exp(mu), geoStd=exp(sigma))
+    data2 = norm(loc=3, scale=1).rvs(size=5000)
 
-	def plot_distribution(ax, x, pdf, color='k-', xscale='linear'):
-		ax.plot(x, pdf, color)
-		ax.set(xlabel='Particle Size (micron)', ylabel='Probability Density', xlim=(x.min(), x.max()), xscale=xscale)
+    def plot_distribution(ax, x, pdf, color='k-', xscale='linear'):
+        ax.plot(x, pdf, color)
+        ax.set(xlabel='Particle Size (micron)', ylabel='Probability Density', xlim=(x.min(), x.max()), xscale=xscale)
 
-	# 繪製粒徑分布
-	plot_distribution(ax1, x, normpdf(x, mu=0, sigma=2))
+    # 繪製粒徑分布
+    plot_distribution(ax1, x, normpdf(x, mu=0, sigma=2))
 
-	plot_distribution(ax2, x2, lognormpdf(x2, gmean=0.8, gstd=1.5), 'g-', xscale='log')
-	plot_distribution(ax2, x2, lognormpdf2(x2, gmean=0.8, gstd=1.5), 'r--', xscale='log')
-	plot_distribution(ax2, x2, lognorm(scale=0.8, s=log(1.5)).pdf(x2), 'b--', xscale='log')
+    plot_distribution(ax2, x2, lognormpdf(x2, gmean=0.8, gstd=1.5), 'g-', xscale='log')
+    plot_distribution(ax2, x2, lognormpdf2(x2, gmean=0.8, gstd=1.5), 'r--', xscale='log')
+    plot_distribution(ax2, x2, lognorm(scale=0.8, s=log(1.5)).pdf(x2), 'b--', xscale='log')
 
-	plot_distribution(ax3, x, normpdf(x, mu=log(3), sigma=log(2)), 'k-')
-	ax3.hist(log(data1), bins=100, density=True, alpha=0.6, color='g')
+    plot_distribution(ax3, x, normpdf(x, mu=log(3), sigma=log(2)), 'k-')
+    ax3.hist(log(data1), bins=100, density=True, alpha=0.6, color='g')
 
-	plot_distribution(ax4, x2, lognormpdf2(x2, gmean=exp(3), gstd=exp(1)), 'r-', xscale='log')
-	ax4.hist(exp(data2), bins=100, density=True, alpha=0.6, color='g')
+    plot_distribution(ax4, x2, lognormpdf2(x2, gmean=exp(3), gstd=exp(1)), 'r-', xscale='log')
+    ax4.hist(exp(data2), bins=100, density=True, alpha=0.6, color='g')
 
-	plt.show()
+    plt.show()
 
-	return fig, ax
+    return fig, ax
 
 
 if __name__ == '__main__':
-	lognorm_dist()
+    lognorm_dist()