AeroViz 0.1.0__py3-none-any.whl

AeroViz/plot/timeseries/timeseries.py

@@ -0,0 +1,317 @@
+from datetime import datetime
+from typing import Literal
+
+import matplotlib.pyplot as plt
+from matplotlib.cm import ScalarMappable
+from matplotlib.pyplot import Figure, Axes
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+from pandas import DataFrame, date_range, Timestamp
+
+from AeroViz.plot.utils import *
+
+__all__ = ['timeseries', 'timeseries_template']
+
+default_bar_kws = dict(
+	width=0.0417,
+	edgecolor=None,
+	linewidth=0,
+	cmap='jet',
+)
+
+default_scatter_kws = dict(
+	marker='o',
+	s=5,
+	edgecolor=None,
+	linewidths=0.3,
+	alpha=0.9,
+	cmap='jet',
+)
+
+default_insert_kws = dict(
+	width="1.5%",
+	height="100%",
+	loc='lower left',
+	bbox_to_anchor=(1.01, 0, 1.2, 1),
+	borderpad=0
+)
+
+default_plot_kws = dict()
+
+default_cbar_kws = dict()
+
+
+def _scatter(ax, df, _y, _c, scatter_kws, cbar_kws, inset_kws):
+	if _c is None or _c not in df.columns:
+		scatter_kws.pop('cmap')
+		ax.scatter(df.index, df[_y], **scatter_kws)
+	else:
+		ax.scatter(df.index, df[_y], c=df[_c], **scatter_kws)
+		cax = inset_axes(ax, **inset_kws)
+
+		# Filter the children to find ScalarMappable objects
+		mappable_objects = [child for child in ax.get_children() if isinstance(child, ScalarMappable)]
+
+		# Use the first mappable object for the colorbar
+		if mappable_objects:
+			plt.colorbar(mappable=mappable_objects[0], cax=cax, **cbar_kws)
+		else:
+			print("No mappable objects found.")
+
+		# plt.colorbar(mappable=ax.get_children()[0], cax=cax, **cbar_kws)
+
+
+def _bar(ax, df, _y, _c, bar_kws, cbar_kws, inset_kws):
+	scalar_map, colors = Color.color_maker(df[_c].values, cmap=bar_kws.pop('cmap'))
+	ax.bar(df.index, df[_y], color=scalar_map.to_rgba(colors), **bar_kws)
+	cax = inset_axes(ax, **inset_kws)
+	plt.colorbar(mappable=scalar_map, cax=cax, **cbar_kws)
+
+
+def _plot(ax, df, _y, _color, plot_kws):
+	ax.plot(df.index, df[_y], color=_color, **plot_kws)
+
+
+def combine_legends(axes_list: list[Axes]) -> tuple[list, list]:
+	return (
+		[legend for axes in axes_list for legend in axes.get_legend_handles_labels()[0]],
+		[label for axes in axes_list for label in axes.get_legend_handles_labels()[1]]
+	)
+
+
+@set_figure(fs=8, autolayout=False)
+def timeseries(df: DataFrame,
+			   y: list[str] | str,
+			   y2: list[str] | str = None,
+			   c: list[str] | str = None,
+			   # color: list[str] | str = None,
+			   rolling: str | int | None = None,
+			   times: tuple[datetime | Timestamp | str, datetime | Timestamp | str] = None,
+			   freq: str = '1MS',
+			   style: list[Literal['scatter', 'bar', 'line']] | str | None = None,
+			   ax: Axes | None = None,
+			   set_xaxis_visible: bool | None = None,
+			   legend_loc: Literal['best', 'upper right', 'upper left', 'lower left', 'lower right'] = 'best',
+			   legend_ncol: int = 1,
+			   **kwargs
+			   ) -> tuple[Figure, Axes]:
+	"""
+	Plot the timeseries data with the option of scatterplot, barplot, and lineplot.
+
+	Parameters
+	-----------
+	df : DataFrame
+	The data to plot.
+	y : list[str] | str
+		The primary y-axis data columns.
+	y2 : list[str] | str, optional
+		The secondary y-axis data columns. Defaults to None.
+	c : str, optional
+		The column for color mapping or the color. Defaults to None.
+	rolling : str | int | None, optional
+		Rolling window size for smoothing. Defaults to None.
+	times : tuple[datetime, datetime] | tuple[Timestamp, Timestamp], optional
+		Time range for the data. Defaults to None.
+	freq : str, optional
+		Frequency for x-axis ticks. Defaults to '2MS'.
+	style : Literal['scatter', 'bar', 'line'] | None, optional
+		Style of the plot. Defaults to 'scatter'.
+	ax : Axes | None, optional
+		Matplotlib Axes object to plot on. Defaults to None.
+	set_xaxis_visible : bool | None, optional
+		Whether to set x-axis visibility. Defaults to None.
+	legend_loc : Literal['best', 'upper right', 'upper left', 'lower left', 'lower right'], optional
+		Location of the legend. Defaults to 'best'.
+	legend_ncol : int, optional
+		Number of columns in the legend. Defaults to 1.
+	**kwargs : Additional keyword arguments for customization.
+		fig_kws : dict, optional
+			Additional keyword arguments for the figure. Defaults to {}.
+		scatter_kws : dict, optional
+			Additional keyword arguments for the scatter plot. Defaults to {}.
+		bar_kws : dict, optional
+			Additional keyword arguments for the bar plot. Defaults to {}.
+		ax_plot_kws : dict, optional
+			Additional keyword arguments for the primary y-axis plot. Defaults to {}.
+		ax2_plot_kws : dict, optional
+			Additional keyword arguments for the secondary y-axis plot. Defaults to {}.
+		cbar_kws : dict, optional
+			Additional keyword arguments for the colorbar. Defaults to {}.
+		inset_kws : dict, optional
+			Additional keyword arguments for the inset axes. Defaults to {}.
+
+	Returns
+	-------
+	ax : AxesSubplot
+		Matplotlib AxesSubplot.
+
+	Example
+	-------
+	>>> timeseries(df, y='WS', c='WD', scatter_kws=dict(cmap='hsv'), cbar_kws=dict(ticks=[0, 90, 180, 270, 360]), ylim=[0, None])
+	"""
+	# Set the time
+	st_tm, fn_tm = (df.index[0], df.index[-1]) if times is None else map(Timestamp, times)
+
+	# Apply rolling window if specified
+	df = df.loc[st_tm:fn_tm] if rolling is None else (
+		df.loc[st_tm:fn_tm].rolling(window=rolling, min_periods=1).mean(numeric_only=True))
+
+	# Initialize figure and axis if not provided
+	fig, ax = plt.subplots(**{**{'figsize': (6, 2)}, **kwargs.get('fig_kws', {})}) if ax is None else (
+		ax.get_figure(), ax)
+
+	# Ensure y, y2, c, and style are lists
+	y = [y] if isinstance(y, str) else y
+	y2 = [y2] if isinstance(y2, str) else y2 if y2 is not None else []
+	c = [c] if isinstance(c, str) else c if c is not None else [None] * (len(y) + len(y2))
+	style = [style] if isinstance(style, str) else style if style is not None else ['plot'] * (len(y) + len(y2))
+
+	if len(c) != len(y) + len(y2):
+		raise ValueError("The length of c must match the combined length of y and y2")
+
+	if len(style) != len(y) + len(y2):
+		raise ValueError("The length of style must match the combined length of y and y2")
+
+	# Create a secondary y-axis if y2 is not empty
+	ax2 = ax.twinx() if y2 else None
+
+	# # Set color cycle
+	ax.set_prop_cycle(Color.color_cycle)
+	if y2:
+		ax2.set_prop_cycle(Color.color_cycle[len(y):])
+
+	if y2 and ('scatter' or 'bar') in style:
+		fig.subplots_adjust(right=0.8)
+
+	for i, _c in enumerate(c):
+		if _c is not None and _c in df.columns:
+			style[i] = 'scatter'
+
+	for i, (_y, _c, _style) in enumerate(zip(y, c, style)):
+		scatter_kws = {**default_scatter_kws, **{'label': Unit(_y)}, **kwargs.get('scatter_kws', {})}
+		bar_kws = {**default_bar_kws, **{'label': Unit(_y)}, **kwargs.get('bar_kws', {})}
+		plot_kws = {**default_plot_kws, **{'label': Unit(_y)}, **kwargs.get('plot_kws', {})}
+
+		if _style in ['scatter', 'bar']:
+			cbar_kws = {**default_cbar_kws, **{'label': Unit(_c), 'ticks': None}, **kwargs.get('cbar_kws', {})}
+			inset_kws = {**default_insert_kws, **{'bbox_transform': ax.transAxes}, **kwargs.get('inset_kws', {})}
+
+		if _style == 'scatter':
+			_scatter(ax, df, _y, _c, scatter_kws, cbar_kws, inset_kws)
+
+		elif _style == 'bar':
+			_bar(ax, df, _y, _c, bar_kws, cbar_kws, inset_kws)
+
+		else:
+			_plot(ax, df, _y, _c, plot_kws)
+
+	if y2:
+		for i, (_y, _c, _style) in enumerate(zip(y2, c[len(y):], style[len(y):])):
+			scatter_kws = {**default_scatter_kws, **{'label': Unit(_y)}, **kwargs.get('scatter_kws2', {})}
+			bar_kws = {**default_bar_kws, **{'label': Unit(_y)}, **kwargs.get('bar_kws2', {})}
+			plot_kws = {**default_plot_kws, **{'label': Unit(_y)}, **kwargs.get('plot_kws2', {})}
+
+			if _style in ['scatter', 'bar']:
+				cbar_kws = {**default_cbar_kws, **{'label': Unit(_c), 'ticks': None}, **kwargs.get('cbar_kws2', {})}
+				inset_kws = {**default_insert_kws, **{'bbox_transform': ax.transAxes}, **kwargs.get('inset_kws2', {})}
+
+			if _style == 'scatter':
+				_scatter(ax2, df, _y, _c, scatter_kws, cbar_kws, inset_kws)
+
+			elif _style == 'bar':
+				_bar(ax2, df, _y, _c, bar_kws, cbar_kws, inset_kws)
+
+			else:  # line plot
+				_plot(ax2, df, _y, _c, plot_kws)
+
+		# Combine legends from ax and ax2
+		ax.legend(*combine_legends([ax, ax2]), loc=legend_loc, ncol=legend_ncol)
+
+	else:
+		ax.legend(loc=legend_loc, ncol=legend_ncol)
+
+	if set_xaxis_visible is not None:
+		ax.axes.xaxis.set_visible(set_xaxis_visible)
+
+	ax.set(xlabel=kwargs.get('xlabel', ''),
+		   ylabel=kwargs.get('ylabel', Unit(y) if isinstance(y, str) else Unit(y[0])),
+		   xticks=kwargs.get('xticks', date_range(start=st_tm, end=fn_tm, freq=freq).strftime("%F")),
+		   yticks=kwargs.get('yticks', ax.get_yticks()),
+		   xticklabels=kwargs.get('xticklabels', date_range(start=st_tm, end=fn_tm, freq=freq).strftime("%F")),
+		   yticklabels=kwargs.get('yticklabels', ax.get_yticklabels()),
+		   xlim=kwargs.get('xlim', (st_tm, fn_tm)),
+		   ylim=kwargs.get('ylim', (None, None)),
+		   title=kwargs.get('title', '')
+		   )
+
+	if y2:
+		ax2.set(ylabel=kwargs.get('ylabel2', Unit(y2) if isinstance(y2, str) else Unit(y2[0])),
+				yticks=kwargs.get('yticks2', ax2.get_yticks()),
+				yticklabels=kwargs.get('yticklabels2', ax2.get_yticklabels()),
+				ylim=kwargs.get('ylim2', (None, None)))
+
+	plt.show()
+
+	return fig, ax
+
+
+@set_figure(fs=8, autolayout=False)
+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, 40],
+			   ylim2=[20, 100],
+			   set_xaxis_visible=False,
+			   legend_ncol=2,
+			   )
+
+	timeseries(df, y='WS', c='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', c='PBLH', style='bar', ax=ax4, bar_kws=dict(cmap='Blues'), set_xaxis_visible=False,
+			   ylim=[0, 5000])
+
+	timeseries(df, y='PM25', c='PM1/PM25', style='scatter', ax=ax5, ylim=[0, None])
+
+	plt.show()
+
+	return fig, ax
+
+
+if __name__ == '__main__':
+	from AeroViz import *
+
+	df = DataBase('/Users/chanchihyu/NTU/2020能見度計畫/data/All_data.csv')
+
+	plot.timeseries.timeseries(df,
+							   y=['Extinction', 'Scattering', 'Absorption'],
+							   y2=['PBLH'],
+							   c=['PM25', None, None, None],
+							   style=['scatter', 'line', 'line', 'line'],
+							   times=('2020-10-01', '2020-11-30'), ylim=[0, None], ylim2=[0, None], rolling=50,
+							   inset_kws=dict(bbox_to_anchor=(1.12, 0, 1.2, 1)),
+							   legend_ncol=4)
+
+	# timeseries(df, y='WS', c='WD', style='scatter', times=('2020-10-01', '2020-11-30'), scatter_kws=dict(cmap='hsv'), cbar_kws=dict(ticks=[0, 90, 180, 270, 360]),
+	#            ylim=[0, None])
+
+	# timeseries_template(df.loc['2020-09-01':'2020-12-31'])

AeroViz/plot/utils/__init__.py

@@ -0,0 +1,3 @@
+from ._color import Color
+from ._decorator import set_figure
+from ._unit import Unit

AeroViz/plot/utils/_color.py

@@ -0,0 +1,71 @@
+import matplotlib.colors as plc
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from cycler import cycler
+from matplotlib import colormaps
+
+__all__ = ['Color']
+
+
+class Color:
+	color_cycle = cycler(color=['b', 'g', 'r', 'c', 'm', 'y', 'k'])
+
+	linecolor = [{'line': '#1a56db', 'edge': '#0F50A6', 'face': '#5983D9'},
+				 {'line': '#046c4e', 'edge': '#1B591F', 'face': '#538C4A'},
+				 {'line': '#c81e1e', 'edge': '#f05252', 'face': '#f98080'}]
+
+	# colors = ['#FF3333', '#33FF33', '#FFFF33', '#5555FF', '#B94FFF', '#AAAAAA', '#748690'] # the last one is "unknown"
+
+	colors1 = ['#A65E58', '#A5BF6B', '#F2BF5E', '#3F83BF', '#B777C2', '#D1CFCB']
+	colors2 = ['#A65E58', '#A5BF6B', '#F2BF5E', '#3F83BF', '#B777C2', '#D1CFCB', '#96c8e6']
+	colors3 = ['#A65E58', '#A5BF6B', '#a6710d', '#F2BF5E', '#3F83BF', '#B777C2', '#D1CFCB', '#96c8e6']  # POC SOC
+
+	colors_mutiWater = ['#A65E58', '#c18e8a', '#A5BF6B', '#c5d6a0', '#F2BF5E', '#3F83BF', '#c089ca', '#d3acda',
+						'#D1CFCB']
+	colors_mutiWater2 = ['#A65E58', '#96c8e6', '#A5BF6B', '#96c8e6', '#F2BF5E', '#3F83BF', '#c089ca', '#96c8e6',
+						 '#D1CFCB']  # water
+
+	color_choose = {'Clean': ['#1d4a9f', '#84a7e9'],
+					'Transition': ['#4a9f1d', '#a7e984'],
+					'Event': ['#9f1d4a', '#e984a7']}
+
+	paired = [plt.get_cmap('Paired')(i) for i in range(4)]
+
+	@staticmethod
+	def getColor(num: int = 6, cmap: str = 'jet_r'):
+		category_colors = plt.colormaps[cmap](np.linspace(0.1, 0.9, num))
+		return [plc.to_hex(category_colors[i]) for i in range(num)]
+
+	@staticmethod
+	def palplot(*args, **kwargs):
+		sns.palplot(*args, **kwargs)
+
+	@staticmethod
+	def adjust_opacity(colors: str | list[str], alpha: float):
+		if isinstance(colors, str):
+			colors = [colors]
+
+		adjusted_colors = []
+		for color in colors:
+			# 將顏色轉換為RGB表示
+			r, g, b = int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16)
+			# 調整透明度
+			r_new = int(alpha * r + (1 - alpha) * 255)
+			g_new = int(alpha * g + (1 - alpha) * 255)
+			b_new = int(alpha * b + (1 - alpha) * 255)
+			# 轉換為新的色碼
+			new_color = '#{:02X}{:02X}{:02X}'.format(r_new, g_new, b_new)
+			adjusted_colors.append(new_color)
+		return adjusted_colors
+
+	@staticmethod
+	def color_maker(obj, cmap='Blues'):
+		colors = np.nan_to_num(obj, nan=0)
+		scalar_map = plt.cm.ScalarMappable(cmap=colormaps[cmap])  # create a scalar map for the colorbar
+		scalar_map.set_array(colors)
+		return scalar_map, colors
+
+
+if __name__ == '__main__':
+	Color.palplot(Color.colors2)

AeroViz/plot/utils/_decorator.py

@@ -0,0 +1,74 @@
+from functools import wraps
+
+import matplotlib.pyplot as plt
+
+__all__ = ['set_figure']
+
+
+# For more details please see https://matplotlib.org/stable/users/explain/customizing.html
+
+
+def set_figure(func=None,
+			   *,
+			   figsize: tuple | None = None,
+			   fs: int | None = None,
+			   fw: str = None,
+			   autolayout: bool = True
+			   ):
+	def decorator(_func):
+		@wraps(_func)
+		def wrapper(*args, **kwargs):
+			print(f'\t\t Plot: \033[96m{_func.__name__}\033[0m')
+
+			plt.rcParams['mathtext.fontset'] = 'custom'
+			plt.rcParams['mathtext.rm'] = 'Times New Roman'
+			plt.rcParams['mathtext.it'] = 'Times New Roman: italic'
+			plt.rcParams['mathtext.bf'] = 'Times New Roman: bold'
+			plt.rcParams['mathtext.default'] = 'regular'
+
+			# The font properties used by `text.Text`.
+			# The text, annotate, label, title, ticks, are used to create text
+			plt.rcParams['font.family'] = 'Times New Roman'
+			plt.rcParams['font.weight'] = fw or 'normal'
+			plt.rcParams['font.size'] = fs or 8
+
+			plt.rcParams['axes.titlesize'] = 'large'
+			plt.rcParams['axes.titleweight'] = 'bold'
+			plt.rcParams['axes.labelweight'] = 'bold'
+
+			# color
+			plt.rcParams['axes.prop_cycle'] = plt.cycler(color=['b', 'g', 'r', 'c', 'm', 'y', 'k'])
+
+			plt.rcParams['xtick.labelsize'] = 'medium'
+			plt.rcParams['ytick.labelsize'] = 'medium'
+
+			# matplotlib.font_manager.FontProperties ---> matplotlib.rcParams
+			plt.rcParams['legend.loc'] = 'best'
+			plt.rcParams['legend.frameon'] = False
+			plt.rcParams['legend.fontsize'] = 'small'
+			plt.rcParams['legend.title_fontsize'] = 'medium'
+			plt.rcParams['legend.handlelength'] = 1.5
+			plt.rcParams['legend.labelspacing'] = 0.7
+
+			plt.rcParams['figure.figsize'] = figsize or (5, 4)
+			plt.rcParams['figure.dpi'] = 200
+			plt.rcParams['figure.autolayout'] = autolayout
+
+			if ~autolayout:
+				plt.rcParams['figure.subplot.left'] = 0.1
+				plt.rcParams['figure.subplot.right'] = 0.875
+				plt.rcParams['figure.subplot.top'] = 0.875
+				plt.rcParams['figure.subplot.bottom'] = 0.125
+
+			# plt.rcParams['figure.constrained_layout.use'] = True
+
+			plt.rcParams['savefig.transparent'] = True
+
+			return _func(*args, **kwargs)
+
+		return wrapper
+
+	if func is None:
+		return decorator
+
+	return decorator(func)

AeroViz/plot/utils/_unit.py

@@ -0,0 +1,55 @@
+import json
+from pathlib import Path
+
+__all__ = ['Unit']
+
+
+class Unit:
+	file_path = Path(__file__).parent / 'units.json'
+	data = None
+
+	def __new__(cls, unit: str):
+		cls.data = cls.load_jsonfile()
+		try:
+			value = cls.data[unit]
+			return r'${}$'.format(value.replace(' ', r'\ '))
+		except KeyError:
+			print(f"Attribute '{unit}' not found. Using default value.")
+			return r'${}$'.format(unit.replace(' ', r'\ ')) if unit is not None else 'None'
+
+	@classmethod
+	def load_jsonfile(cls):
+		""" 讀取 JSON 檔中數據并將其變成屬性 """
+		try:
+			with open(cls.file_path, 'r', encoding='utf-8') as f:
+				return json.load(f)
+
+		except FileNotFoundError:
+			print(f"JSON file '{cls.file_path}' not found.")
+		except json.JSONDecodeError:
+			print(f"Invalid JSON format in '{cls.file_path}'.")
+
+	@classmethod
+	def update_jsonfile(cls, key, value):
+		""" 更新JSON檔 """
+		with open(cls.file_path, 'r', encoding='utf-8') as f:
+			old_data = json.load(f)
+
+		old_data[key] = value
+
+		with open(cls.file_path, 'w', encoding='utf-8') as f:
+			json.dump(old_data, f, indent=4)
+
+	@classmethod
+	def del_jsonfile(cls, key):
+		""" 更新JSON檔 """
+		with open(cls.file_path, 'r', encoding='utf-8') as f:
+			old_data = json.load(f)
+
+		if key in old_data:
+			del old_data[key]
+
+			with open(cls.file_path, 'w', encoding='utf-8') as f:
+				json.dump(old_data, f, indent=4)
+		else:
+			print(f"Key '{key}' not found.")

AeroViz/process/__init__.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+from pandas import read_csv, concat
+
+from AeroViz.process.script import (ImpactProc, ImproveProc, ChemicalProc, ParticleSizeDistProc,
+									ExtinctionDistProc, OthersProc)
+
+__all__ = ['DataProcess']
+
+
+class DataProcess:
+	def __new__(cls, file_path, reset: bool = False, save_file: Path | str = 'All_data.csv'):
+		file_path = Path(file_path)
+
+		print(f'\t\t \033[96m --- Processing Data --- \033[0m')
+
+		if file_path.exists() and not reset:
+			return read_csv(file_path, parse_dates=['Time'], index_col='Time',
+							na_values=('-', 'E', 'F'), low_memory=False)
+
+		processor = [ImpactProc, ChemicalProc, ImproveProc, ParticleSizeDistProc, ExtinctionDistProc, OthersProc]
+		reset = [False, False, False, False, False, False]
+		save_filename = ['IMPACT.csv', 'chemical.csv', 'revised_IMPROVE.csv', 'PSD.csv', 'PESD.csv', 'Others.csv']
+
+		_df = concat([processor().process_data(reset, save_filename) for processor, reset, save_filename in
+					  zip(processor, reset, save_filename)], axis=1)
+
+		# 7. save result
+		_df.to_csv(file_path)
+
+		return _df

AeroViz/process/core/DataProc.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from pandas import DataFrame
+
+__all__ = ['DataProc']
+
+
+class DataProc(ABC):
+	def __init__(self):
+		pass
+
+	@abstractmethod
+	def process_data(self,
+					 reset: bool = False,
+					 save_filename: str | Path = None
+					 ) -> DataFrame:
+		""" Implementation of processing data """
+		pass

AeroViz/process/core/SizeDist.py

@@ -0,0 +1,90 @@
+from typing import Literal
+
+import numpy as np
+from pandas import DataFrame
+
+__all__ = ['SizeDist']
+
+
+class SizeDist:
+	"""
+	Attributes
+	----------
+
+	_data: DataFrame
+		The processed PSD data stored as a pandas DataFrame.
+
+	_dp: ndarray
+		The array of particle diameters from the PSD data.
+
+	_dlogdp: ndarray
+		The array of logarithmic particle diameter bin widths.
+
+	_index: DatetimeIndex
+		The index of the DataFrame representing time.
+
+	_state: str
+		The state of particle size distribution data.
+
+	Methods
+	-------
+	number()
+		Calculate number distribution properties.
+
+	surface(filename='PSSD_dSdlogdp.csv')
+		Calculate surface distribution properties.
+
+	volume(filename='PVSD_dVdlogdp.csv')
+		Calculate volume distribution properties.
+
+	"""
+
+	def __init__(self,
+				 data: DataFrame,
+				 state: Literal['dN', 'ddp', 'dlogdp'] = 'dlogdp',
+				 weighting: Literal['n', 's', 'v', 'ext_in', 'ext_ex'] = 'n'
+				 ):
+		self._data = data
+		self._dp = np.array(self._data.columns, dtype=float)
+		self._dlogdp = np.full_like(self._dp, 0.014)
+		self._index = self._data.index.copy()
+		self._state = state
+		self._weighting = weighting
+
+	@property
+	def data(self) -> DataFrame:
+		return self._data
+
+	@property
+	def dp(self) -> np.ndarray:
+		return self._dp
+
+	@dp.setter
+	def dp(self, new_dp: np.ndarray):
+		self._dp = new_dp
+
+	@property
+	def dlogdp(self) -> np.ndarray:
+		return self._dlogdp
+
+	@dlogdp.setter
+	def dlogdp(self, new_dlogdp: np.ndarray):
+		self._dlogdp = new_dlogdp
+
+	@property
+	def index(self):
+		return self._index
+
+	@property
+	def state(self):
+		return self._state
+
+	@state.setter
+	def state(self, value):
+		if value not in ['dN', 'dlogdp', 'ddp']:
+			raise ValueError("state must be 'dlogdp' or 'ddp'")
+		self._state = value
+
+	@property
+	def weighting(self):
+		return self._weighting

AeroViz/process/core/__init__.py

@@ -0,0 +1,4 @@
+from .DataProc import DataProc
+from .SizeDist import SizeDist
+
+__all__ = ['DataProc', 'SizeDist']