AeroViz 0.1.0__py3-none-any.whl

AeroViz/plot/improve/improve.py

@@ -0,0 +1,240 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.pyplot import Figure, Axes
+from pandas import DataFrame, read_json
+from scipy.optimize import curve_fit
+from pathlib import Path
+
+from AeroViz import plot
+from AeroViz.plot.utils import *
+from AeroViz.tools import DataBase, DataReader, DataClassifier
+
+# TODO: this file has to be reorganized
+
+__all__ = ['chemical_enhancement',
+		   'ammonium_rich',
+		   'pie_IMPROVE',
+		   'MLR_IMPROVE',
+		   'fRH_plot',
+		   ]
+
+
+@set_figure
+def chemical_enhancement(data_set: DataFrame = None,
+						 data_std: DataFrame = None,
+						 ax: Axes | None = None,
+						 **kwargs
+						 ) -> tuple[Figure, Axes]:
+	fig, ax = plt.subplots() if ax is None else (ax.get_figure(), ax)
+
+	ser_grp_sta, ser_grp_sta_std = DataClassifier(DataBase('/Users/chanchihyu/NTU/2020能見度計畫/data/All_data.csv'),
+												  by='State')
+	species = ['AS', 'AN', 'POC', 'SOC', 'Soil', 'SS', 'EC', 'ALWC']
+	data_set, data_std = ser_grp_sta.loc[:, species], ser_grp_sta_std.loc[:, species]
+
+	width = 0.20
+	block = width / 4
+
+	x = np.array([1, 2, 3, 4, 5, 6, 7])
+	for i, state in enumerate(['Clean', 'Transition', 'Event']):
+		val = np.array(data_set.iloc[i, :-1])
+		std = (0,) * 7, np.array(data_std.iloc[i, :-1])
+
+		plt.bar(x + (i + 1) * (width + block), val, yerr=std, width=width, color=Color.colors3[:-1],
+				alpha=0.6 + (0.2 * i),
+				edgecolor=None, capsize=None, label=state)
+
+	ax.set(xlabel=r'$\bf Chemical\ species$',
+		   ylabel=r'$\bf Mass\ concentration\ ({\mu}g/m^3)$',
+		   xticks=x + 2 * (width + block),
+		   xticklabels=species,
+		   ylim=(0, 25),
+		   title=r'$\bf Chemical\ enhancement$')
+
+	ax.vlines(8, 0, 25, linestyles='--', colors='k')
+
+	ax2 = ax.twinx()
+	for i, state in enumerate(['Clean', 'Transition', 'Event']):
+		val = np.array(data_set.iloc[i, -1])
+		std = np.array([[0], [data_std.iloc[i, -1]]])
+		plt.bar(8 + (i + 1) * (width + block), val, yerr=std, width=width, color='#96c8e6',
+				alpha=0.6 + (0.2 * i), edgecolor=None, capsize=None, label=state)
+
+	ax2.set(ylabel=r'$\bf Mass\ concentration\ ({\mu}g/m^3)$',
+			ylim=(0, 100),
+			xticks=x + 2 * (width + block),
+			xticklabels=species
+			)
+
+	a = (np.array(data_set.loc['Event']) + np.array(data_set.loc['Transition'])) / 2
+	b = (np.array(data_set.loc['Transition']) + np.array(data_set.loc['Clean'])) / 2
+	c = np.array(data_set.loc['Event']) / np.array(data_set.loc['Transition'])
+	d = np.array(data_set.loc['Transition']) / np.array(data_set.loc['Clean'])
+
+	for i, (posa, posb, vala, valb) in enumerate(zip(a, b, c, d)):
+		if i < 7:
+			ax.text(i + 1.5, posa, '{:.2f}'.format(vala), fontsize=6, weight='bold', zorder=1)
+			ax.text(i + 1.25, posb, '{:.2f}'.format(valb), fontsize=6, weight='bold', zorder=1)
+		else:
+			ax2.text(i + 1.5, posa, '{:.2f}'.format(vala), fontsize=6, weight='bold', zorder=1)
+			ax2.text(i + 1.25, posb, '{:.2f}'.format(valb), fontsize=6, weight='bold', zorder=1)
+
+	plt.show()
+
+	return fig, ax
+
+
+@set_figure
+def ammonium_rich(df: DataFrame,
+				  **kwargs
+				  ) -> tuple[Figure, Axes]:
+	df = df[['NH4+', 'SO42-', 'NO3-', 'PM25']].dropna().copy().div([18, 96, 62, 1])
+	df['required_ammonium'] = df['NO3-'] + 2 * df['SO42-']
+
+	fig, ax = plt.subplots()
+
+	scatter = ax.scatter(df['required_ammonium'].to_numpy(), df['NH4+'].to_numpy(), c=df['PM25'].to_numpy(),
+						 vmin=0, vmax=70, cmap='jet', marker='o', s=10, alpha=1)
+
+	ax.axline((0, 0), slope=1., color='k', lw=2, ls='--', alpha=0.5, label='1:1')
+	plt.text(0.97, 0.97, r'$\bf 1:1\ Line$', color='k', ha='right', va='top', transform=ax.transAxes)
+
+	ax.set(xlim=(0, 1.2),
+		   ylim=(0, 1.2),
+		   xlabel=r'$\bf NO_{3}^{-}\ +\ 2\ \times\ SO_{4}^{2-}\ (mole\ m^{-3})$',
+		   ylabel=r'$\bf NH_{4}^{+}\ (mole\ m^{-3})$',
+		   title=kwargs.get('title', ''))
+
+	color_bar = plt.colorbar(scatter, label=Unit('PM25'), extend='both')
+
+	# fig.savefig(f'Ammonium_rich_{title}')
+	plt.show()
+
+	return fig, ax
+
+
+def pie_IMPROVE():
+	Species1 = ['AS_ext_dry', 'AN_ext_dry', 'OM_ext_dry', 'Soil_ext_dry', 'SS_ext_dry', 'EC_ext_dry']
+	Species2 = ['AS_ext_dry', 'AN_ext_dry', 'OM_ext_dry', 'Soil_ext_dry', 'SS_ext_dry', 'EC_ext_dry', 'ALWC_ext']
+	Species3 = ['AS_ext', 'AN_ext', 'OM_ext', 'Soil_ext', 'SS_ext', 'EC_ext']
+
+	ser_grp_sta, _ = DataClassifier(DataBase(), by='State')
+
+	ext_dry_dict = ser_grp_sta.loc[:, Species1]
+	ext_amb_dict = ser_grp_sta.loc[:, Species2]
+	ext_mix_dict = ser_grp_sta.loc[:, Species3]
+
+	plot.donuts(data_set=ext_dry_dict, labels=['AS', 'AN', 'OM', 'Soil', 'SS', 'BC'], unit='Extinction')
+	plot.donuts(data_set=ext_mix_dict, labels=['AS', 'AN', 'OM', 'Soil', 'SS', 'BC'], unit='Extinction')
+	plot.donuts(data_set=ext_amb_dict, labels=['AS', 'AN', 'OM', 'Soil', 'SS', 'BC', 'ALWC'],
+				unit='Extinction', colors=Color.colors2)
+
+
+def MLR_IMPROVE(**kwargs):
+	"""
+	Perform multiple linear regression analysis and generate plots based on IMPROVE dataset.
+
+	Parameters
+	----------
+	**kwargs : dict
+		Additional keyword arguments for customization.
+
+	Returns
+	-------
+	None
+
+	Examples
+	--------
+	Example usage of MLR_IMPROVE function:
+
+	>>> MLR_IMPROVE()
+
+	Notes
+	-----
+	This function performs multiple linear regression analysis on the IMPROVE dataset and generates plots for analysis.
+
+	- The function first selects specific species from the dataset and drops NaN values.
+	- It calculates a 'Localized' value based on a multiplier and the sum of selected species.
+	- Data from 'modified_IMPROVE.csv' and 'revised_IMPROVE.csv' are read and concatenated with the dataset.
+	- Statistical analysis is performed using DataClassifier to calculate mean and standard deviation.
+	- Plots are generated using linear_regression for Extinction vs. Revised/Modified/Localized and Pie.donuts for a
+	  pie chart showing the distribution of species based on Extinction.
+
+	"""
+	species = ['Extinction', 'Scattering', 'Absorption',
+			   'total_ext_dry', 'AS_ext_dry', 'AN_ext_dry', 'OM_ext_dry', 'Soil_ext_dry', 'SS_ext_dry', 'EC_ext_dry',
+			   'AS', 'AN', 'POC', 'SOC', 'Soil', 'SS', 'EC', 'OM']
+
+	df = DataBase('/Users/chanchihyu/NTU/2020能見度計畫/data/All_data.csv')[species].dropna().copy()
+
+	# multiple_linear_regression(df, x=['AS', 'AN', 'POC', 'SOC', 'Soil', 'SS'], y='Scattering', add_constant=True)
+	# multiple_linear_regression(df, x=['POC', 'SOC', 'EC'], y='Absorption', add_constant=True)
+	# multiple_linear_regression(df, x=['AS', 'AN', 'POC', 'SOC', 'Soil', 'SS', 'EC'], y='Extinction', add_constant=False)
+
+	multiplier = [2.675, 4.707, 11.6, 7.272, 0, 0.131, 10.638]
+	df['Localized'] = df[['AS', 'AN', 'POC', 'SOC', 'Soil', 'SS', 'EC']].mul(multiplier).sum(axis=1)
+	# TODO: remove name
+	modify_IMPROVE = DataReader('modified_IMPROVE.csv')['total_ext_dry'].rename('Modified')
+	revised_IMPROVE = DataReader('revised_IMPROVE.csv')['total_ext_dry'].rename('Revised')
+
+	df = pd.concat([df, revised_IMPROVE, modify_IMPROVE], axis=1)
+
+	n_df = df[['AS', 'AN', 'POC', 'SOC', 'Soil', 'SS', 'EC']].mul(multiplier)
+	mean, std = DataClassifier(n_df, 'State')
+
+	ser_grp_sta, _ = DataClassifier(DataBase(), by='State')
+	mass_comp = ser_grp_sta.loc[:, ['AS', 'AN', 'POC', 'SOC', 'Soil', 'SS', 'EC']]
+
+	# plot
+	plot.linear_regression(df, x='Extinction', y=['Revised', 'Modified', 'Localized'], xlim=[0, 400], ylim=[0, 400],
+						   regression=True, diagonal=True)
+	plot.donuts(data_set=mass_comp, labels=['AS', 'AN', 'POC', 'SOC', 'Soil', 'SS', 'EC'],
+				unit='PM25', colors=Color.colors3)
+	plot.donuts(mean, labels=['AS', 'AN', 'POC', 'SOC', 'Soil', 'SS', 'EC'], unit='Extinction', colors=Color.colors3)
+
+
+@set_figure
+def fRH_plot(**kwargs) -> tuple[Figure, Axes]:
+	frh = read_json(Path(__file__).parent.parent / 'utils' / 'fRH.json')
+
+	def fitting_func(RH, a, b, c):
+		f = a + b * (RH / 100) ** c
+		return f
+
+	x = frh.index.to_numpy()
+	y = frh['fRHs'].to_numpy()
+
+	result = curve_fit(fitting_func, x, y)
+	params = result[0].tolist()
+	val_fit = fitting_func(x, *params)
+
+	fig, ax = plt.subplots(figsize=(3, 3))
+
+	ax.plot(frh.index, frh['fRH'], 'k-o', ms=2, label='$f(RH)_{original}$')
+	ax.plot(frh.index, frh['fRHs'], 'g-o', ms=2, label='$f(RH)_{small\\ mode}$')
+	ax.plot(frh.index, frh['fRHl'], 'r-o', ms=2, label='$f(RH)_{large\\ mode}$')
+	ax.plot(frh.index, frh['fRHSS'], 'b-o', ms=2, label='$f(RH)_{sea\\ salt}$')
+
+	ax.set(xlim=(0, 100),
+		   ylim=(1, None),
+		   xlabel='$RH (\\%)$',
+		   ylabel='$f(RH)$',
+		   title=f'$Hygroscopic\\ growth\\ factor$'
+		   )
+
+	ax.grid(axis='y', color='gray', linestyle='dashed', linewidth=0.4, alpha=0.4)
+
+	ax.legend()
+
+	plt.show()
+	# fig.savefig('fRH_plot')
+
+	return fig, ax
+
+
+if __name__ == '__main__':
+	# chemical_enhancement()
+	# MLR_IMPROVE()
+	# ammonium_rich()
+	fRH_plot()

AeroViz/plot/meteorology/__init__.py

@@ -0,0 +1 @@
+from .meteorology import *

AeroViz/plot/meteorology/meteorology.py

@@ -0,0 +1,317 @@
+import math
+from typing import Literal
+
+import matplotlib.colors as plc
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import windrose
+from matplotlib.pyplot import Figure, Axes
+from pandas import DataFrame, Series
+from scipy.ndimage import gaussian_filter
+
+from AeroViz.plot.utils import *
+
+__all__ = ['wind_tms',
+		   'wind_rose',
+		   'CBPF'
+		   ]
+
+
+@set_figure(fs=6)
+def wind_tms(df: DataFrame,
+			 WS: Series | str,
+			 WD: Series | str,
+			 **kwargs
+			 ) -> tuple[Figure, Axes]:
+	def drawArrow(A, B, ax: plt.Axes):  # 畫箭頭
+		_ax = ax.twinx()
+		if A[0] == B[0] and A[1] == B[1]:  # 靜風畫點
+			_ax.plot(A[0], A[1], 'ko')
+		else:
+			_ax.annotate("", xy=(B[0], B[1]), xytext=(A[0], A[1]), arrowprops=dict(arrowstyle="->"))
+
+		_ax.spines['left'].set_visible(False)
+		_ax.spines['right'].set_visible(False)
+		_ax.spines['top'].set_visible(False)
+		_ax.spines['bottom'].set_visible(False)
+		_ax.set_xlim(0, )
+		_ax.set_ylim(0, 5)
+		_ax.get_yaxis().set_visible(False)
+		_ax.set_aspect('equal')  # x轴y轴等比例
+
+		_ax.tick_params(axis='x', rotation=90)
+		ax.tick_params(axis='x', rotation=90)
+		plt.tight_layout()
+
+	fig, ax = plt.subplots(figsize=(8, 2))
+	uniform_data = [WS]
+	colors = ['lightskyblue', 'darkturquoise', 'lime', 'greenyellow', 'orangered', 'red']
+	clrmap = plc.LinearSegmentedColormap.from_list("mycmap", colors)  # 自定义色标
+	sns.heatmap(uniform_data, square=True, annot=True, fmt=".2f", linewidths=.5, cmap=clrmap,
+				yticklabels=['Wind speed (m/s)'], xticklabels=kwargs.get('xticklabels', None), cbar=False, vmin=0,
+				vmax=5, ax=ax)
+	ax.set_xticklabels(ax.get_xticklabels(), rotation=90)
+	ax.set_yticklabels(ax.get_yticklabels(), rotation=0)
+	ax.spines['bottom'].set_position(('data', 1))  # 移动x轴
+
+	for idx, (x, value) in enumerate(WD.items()):
+		if not pd.isna(value):
+			a = np.array([0.5 + 0.5 * np.sin(value / 180 * np.pi) + idx, 3.5 + 0.5 * np.cos(value / 180 * np.pi)])
+			b = np.array([0.5 - 0.5 * np.sin(value / 180 * np.pi) + idx, 3.5 - 0.5 * np.cos(value / 180 * np.pi)])
+			drawArrow(a, b, ax)
+		else:
+			a = np.array([0.5 + idx, 3.5])
+			drawArrow(a, a, ax)
+
+	plt.show()
+
+	return fig, ax
+
+
+@set_figure(figsize=(4.3, 4))
+def wind_rose(df: DataFrame,
+			  WS: Series | str,
+			  WD: Series | str,
+			  val: Series | str | None = None,
+			  typ: Literal['bar', 'scatter'] = 'scatter',
+			  rlabel_pos: float = 30,
+			  **kwargs
+			  ) -> tuple[Figure, Axes]:
+	# conditional bivariate probability function (cbpf) python
+	# https://davidcarslaw.github.io/openair/reference/polarPlot.html
+	# https://github.com/davidcarslaw/openair/blob/master/R/polarPlot.R
+	windrose.WindroseAxes._info = 'WindroseAxes'
+
+	df = df.dropna(subset=[WS, WD] + ([val] if val is not None else []))
+
+	radius = df[WS].to_numpy()
+	theta = df[WD].to_numpy()
+	radian = np.radians(theta)
+	values = df[val].to_numpy() if val is not None else None
+
+	# In this case, the windrose is a simple frequency diagram,
+	# the function automatically calculates the radians of the given wind direction.
+	if typ == 'bar':
+		fig, ax = plt.subplots(figsize=(5.5, 4), subplot_kw={'projection': 'windrose'})
+		fig.subplots_adjust(left=0)
+
+		ax.bar(theta, radius, bins=[0, 1, 2, 3], normed=True, colors=['#0F1035', '#365486', '#7FC7D9', '#DCF2F1'])
+		ax.set(
+			ylim=(0, 30),
+			yticks=[0, 15, 30],
+			yticklabels=['', '15 %', '30 %'],
+			rlabel_position=rlabel_pos
+		)
+		ax.set_thetagrids(angles=[0, 45, 90, 135, 180, 225, 270, 315],
+						  labels=["E", "NE", "N", "NW", "W", "SW", "S", "SE"])
+
+		ax.legend(units='m/s', bbox_to_anchor=[1.1, 0.5], loc='center left', ncol=1)
+
+	# In this case, the windrose is a scatter plot,
+	# in contrary, this function does not calculate the radians, so user have to input the radian.
+	else:
+		fig, ax = plt.subplots(figsize=(5, 4), subplot_kw={'projection': 'windrose'})
+		fig.subplots_adjust(left=0)
+
+		scatter = ax.scatter(radian, radius, s=15, c=values, vmax=np.quantile(values, 0.90), edgecolors='none',
+							 cmap='jet', alpha=0.8)
+		ax.set(
+			ylim=(0, 7),
+			yticks=[1, 3, 5, 7],
+			yticklabels=['1 m/s', '3 m/s', '5 m/s', '7 m/s'],
+			rlabel_position=rlabel_pos,
+			theta_direction=-1,
+			theta_zero_location='N',
+		)
+		ax.set_thetagrids(angles=[0, 45, 90, 135, 180, 225, 270, 315],
+						  labels=["N", "NE", "E", "SE", "S", "SW", "W", "NW"])
+
+		plt.colorbar(scatter, ax=ax, label=Unit(val), pad=0.1, fraction=0.04)
+
+	plt.show()
+
+	return fig, ax
+
+
+@set_figure(figsize=(4.3, 4))
+def CBPF(df: DataFrame,
+		 WS: Series | str,
+		 WD: Series | str,
+		 val: Series | str | None = None,
+		 percentile: list | float | int | None = None,
+		 max_ws: float | None = 5,
+		 resolution: int = 100,
+		 sigma: float | tuple = 2,
+		 rlabel_pos: float = 30,
+		 bottom_text: str | bool | None = None,
+		 **kwargs
+		 ) -> tuple[Figure, Axes]:
+	# conditional bivariate probability function (cbpf) python
+	# https://davidcarslaw.github.io/openair/reference/polarPlot.html
+	# https://github.com/davidcarslaw/openair/blob/master/R/polarPlot.R
+
+	df = df.dropna(subset=[WS, WD] + ([val] if val is not None else [])).copy()
+
+	df['u'] = df[WS].to_numpy() * np.sin(np.radians(df[WD].to_numpy()))
+	df['v'] = df[WS].to_numpy() * np.cos(np.radians(df[WD].to_numpy()))
+
+	u_bins = np.linspace(df.u.min(), df.u.max(), resolution)
+	v_bins = np.linspace(df.v.min(), df.v.max(), resolution)
+
+	# 使用 u_group 和 v_group 進行分組
+	df['u_group'] = pd.cut(df['u'], u_bins)
+	df['v_group'] = pd.cut(df['v'], v_bins)
+	grouped = df.groupby(['u_group', 'v_group'], observed=False)
+
+	X, Y = np.meshgrid(u_bins, v_bins)
+
+	# Note:
+	# The CBPF is the ratio between the number of points in each cell and the total number of points.
+	# So, it is not equal to the probability density function (PDF) of the wind speed and wind direction.
+
+	if percentile is None:
+		histogram = (grouped[val].count() / grouped[val].count().sum()).unstack().values.T
+		# histogram, v_edges, u_edges = np.histogram2d(df.v, df.u, bins=(v_bins, u_bins))
+		# histogram = histogram / histogram.sum()
+		histogram = np.where(histogram == 0, np.nan, histogram)
+		bottom_text = rf'$PDF\ plot$'
+
+	else:
+		if not all(0 <= p <= 100 for p in (percentile if isinstance(percentile, list) else [percentile])):
+			raise ValueError("Percentile must be between 0 and 100")
+
+		if isinstance(percentile, (float, int)):
+			bottom_text = rf'$CPF:\ >{int(percentile)}^{{th}}$'
+			thershold = df[val].quantile(percentile / 100)
+			cond = lambda x: (x >= thershold).sum()
+
+		elif isinstance(percentile, list) and len(percentile) == 1:
+			# Extract the single element from the list
+			single_percentile = percentile[0]
+			bottom_text = rf'$CPF:\ >{int(single_percentile)}^{{th}}$'
+			threshold = df[val].quantile(single_percentile / 100)
+			cond = lambda x: (x >= threshold).sum()
+
+		else:
+			bottom_text = rf'$CPF:\ {int(percentile[0])}^{{th}}\ to\ {int(percentile[1])}^{{th}}$'
+			thershold_small, thershold_large = df[val].quantile([percentile[0] / 100, percentile[1] / 100])
+			cond = lambda x: ((x >= thershold_small) & (x < thershold_large)).sum()
+
+		histogram = (grouped[val].apply(cond) / grouped[val].count()).unstack().values.T
+
+	# if np.isnan(histogram).all():
+	#     raise "CBPF_array contains only NaN values."
+	# else:
+	#     print(f"\nHistogram contains NaN before masking: {np.isnan(histogram).sum()}")
+
+	histogram_filled = np.nan_to_num(histogram, nan=0)  # 將 NaN 替換為 0
+
+	filtered_histogram = gaussian_filter(histogram_filled, sigma=sigma)
+	filtered_histogram[np.isnan(histogram)] = np.nan
+
+	def is_within_circle(center_row, center_col, row, col, radius):
+		return np.sqrt((center_row - row) ** 2 + (center_col - col) ** 2) <= radius
+
+	def remove_lonely_point(filtered_histogram, radius=3):
+		rows, cols = filtered_histogram.shape
+		data_positions = np.where(~np.isnan(filtered_histogram))
+
+		for row, col in zip(*data_positions):
+			valid_data_count = 0
+			for i in range(max(0, row - radius), min(rows, row + radius + 1)):
+				for j in range(max(0, col - radius), min(cols, col + radius + 1)):
+					if (i, j) != (row, col) and is_within_circle(row, col, i, j, radius):
+						if not np.isnan(filtered_histogram[i, j]):
+							valid_data_count += 1
+
+			if valid_data_count <= 13:
+				filtered_histogram[row, col] = np.nan
+
+		return filtered_histogram
+
+	def fill_nan_with_mean(filtered_histogram, radius=3):
+		rows, cols = filtered_histogram.shape
+		nan_positions = np.where(np.isnan(filtered_histogram))
+
+		for row, col in zip(*nan_positions):
+			surrounding_values = []
+			surrounding_values_within_one = []
+			nan_count = 0
+
+			for i in range(max(0, row - radius), min(rows, row + radius + 1)):
+				for j in range(max(0, col - radius), min(cols, col + radius + 1)):
+					if (i, j) != (row, col) and is_within_circle(row, col, i, j, radius):
+						if np.isnan(filtered_histogram[i, j]):
+							nan_count += 1
+						else:
+							surrounding_values.append(filtered_histogram[i, j])
+
+			for i in range(max(0, row - 2), min(rows, row + 2 + 1)):
+				for j in range(max(0, col - 2), min(cols, col + 2 + 1)):
+					if (i, j) != (row, col) and is_within_circle(row, col, i, j, 2):
+						if np.isnan(filtered_histogram[i, j]):
+							pass
+						else:
+							surrounding_values_within_one.append(filtered_histogram[i, j])
+
+			if nan_count < 13 and surrounding_values_within_one:
+				filtered_histogram[row, col] = np.mean(surrounding_values)
+
+		return filtered_histogram
+
+	# Apply the function to your data
+	filtered_histogram = remove_lonely_point(filtered_histogram)
+	filtered_histogram = fill_nan_with_mean(filtered_histogram)
+
+	# plot
+	fig, ax = plt.subplots()
+	fig.subplots_adjust(left=0)
+
+	surf = ax.pcolormesh(X, Y, filtered_histogram, shading='auto', cmap='jet', antialiased=True)
+
+	max_ws = max_ws or np.concatenate((abs(df.u), abs(df.v))).max()  # Get the maximum value of the wind speed
+
+	radius_lst = np.arange(1, math.ceil(max_ws) + 1)  # Create a list of radius
+
+	for i, radius in enumerate(radius_lst):
+		circle = plt.Circle((0, 0), radius, fill=False, color='gray', linewidth=1, linestyle='--', alpha=0.5)
+		ax.add_artist(circle)
+
+		for angle, label in zip(range(0, 360, 90), ["E", "N", "W", "S"]):
+			radian = np.radians(angle)
+			line_x, line_y = radius * np.cos(radian), radius * np.sin(radian)
+
+			if i + 2 == len(radius_lst):  # Add wind direction line and direction label at the edge of the circle
+				ax.plot([0, line_x * 1.05], [0, line_y * 1.05], color='k', linestyle='-', linewidth=1, alpha=0.5)
+				ax.text(line_x * 1.15, line_y * 1.15, label, ha='center', va='center')
+
+		ax.text(radius * np.cos(np.radians(rlabel_pos)), radius * np.sin(np.radians(rlabel_pos)),
+				str(radius) + ' m/s', ha='center', va='center', fontsize=8)
+
+	for radius in range(math.ceil(max_ws) + 1, 10):
+		circle = plt.Circle((0, 0), radius, fill=False, color='gray', linewidth=1, linestyle='--', alpha=0.5)
+		ax.add_artist(circle)
+
+	ax.set(xlim=(-max_ws * 1.02, max_ws * 1.02),
+		   ylim=(-max_ws * 1.02, max_ws * 1.02),
+		   xticks=[],
+		   yticks=[],
+		   xticklabels=[],
+		   yticklabels=[],
+		   aspect='equal',
+		   )
+	if bottom_text:
+		ax.text(0.50, -0.05, bottom_text, fontweight='bold', fontsize=8, va='center', ha='center',
+				transform=ax.transAxes)
+
+	ax.text(0.5, 1.05, Unit(val), fontweight='bold', fontsize=12, va='center', ha='center', transform=ax.transAxes)
+
+	cbar = plt.colorbar(surf, ax=ax, label='Frequency', pad=0.01, fraction=0.04)
+	cbar.ax.yaxis.label.set_fontsize(8)
+	cbar.ax.tick_params(labelsize=8)
+
+	plt.show()
+
+	return fig, ax

AeroViz/plot/optical/__init__.py

@@ -0,0 +1,2 @@
+from .aethalometer import *
+from .optical import *

AeroViz/plot/optical/aethalometer.py

@@ -0,0 +1,77 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from pandas import date_range
+
+from AeroViz.plot.utils import *
+
+__all__ = ['plot_MA350',
+		   'plot_MA3502',
+		   'plot_day_night']
+
+
+@set_figure(figsize=(15, 5))
+def plot_MA350(df, **kwargs):
+	fig, ax = plt.subplots()
+
+	# ax.scatter(df.index, df['UV BCc'], marker='o', c='purple', alpha=0.5, label='UV BCc')
+	# ax.scatter(df.index, df['Blue BCc'], c='b', alpha=0.5, label='Blue BCc')
+	# ax.scatter(df.index, df['Green BCc'], c='g', alpha=0.5, label='Green BCc')
+	# ax.scatter(df.index, df['Red BCc'], c='r', alpha=0.5, label='Red BCc')
+	mean, std = round(df.mean(), 2), round(df.std(), 2)
+
+	label1 = rf'$MA350-0171\ :\;{mean["MA350_0171 IR BCc"]}\;\pm\;{std["MA350_0171 IR BCc"]}\;(ng/m^3)$'
+	label2 = rf'$MA350-0176\ :\;{mean["MA350_0176 IR BCc"]}\;\pm\;{std["MA350_0176 IR BCc"]}\;(ng/m^3)$'
+	label3 = rf'$BC-1054\ :\;{mean["BC1054 IR BCc"]}\;\pm\;{std["BC1054 IR BCc"]}\;(ng/m^3)$'
+	ax.scatter(df.index, df['MA350_0171 IR BCc'], s=10, ls='-', marker='o', c='#a3b18a', alpha=0.5, label=label1)
+	ax.scatter(df.index, df['MA350_0176 IR BCc'], s=10, ls='-', marker='o', c='#3a5a40', alpha=0.5, label=label2)
+	ax.scatter(df.index, df['BC1054 IR BCc'], s=10, ls='-', marker='o', c='g', alpha=0.5, label=label3)
+	ax.legend(prop={'weight': 'bold'}, loc='upper left')
+
+	st_tm, fn_tm = df.index[0], df.index[-1]
+	tick_time = date_range(st_tm, fn_tm, freq=kwargs.get('freq', '10d'))
+
+	ax.set(xlabel=kwargs.get('xlabel', ''),
+		   ylabel=kwargs.get('ylabel', r'$BC\ (ng/m^3)$'),
+		   xticks=kwargs.get('xticks', tick_time),
+		   xticklabels=kwargs.get('xticklabels', [_tm.strftime("%F") for _tm in tick_time]),
+		   xlim=kwargs.get('xlim', (st_tm, fn_tm)),
+		   ylim=kwargs.get('ylim', (0, None)),
+		   )
+
+
+@set_figure
+def plot_MA3502(df):
+	fig, ax = plt.subplots()
+
+	bins = np.array([375, 470, 528, 625, 880])
+	vals = df.dropna().iloc[:, -5:].values
+
+	ax.boxplot(vals, positions=bins, widths=20,
+			   showfliers=False, showmeans=True, meanline=True, patch_artist=True,
+			   boxprops=dict(facecolor='#f2c872', alpha=.7),
+			   meanprops=dict(color='#000000', ls='none'),
+			   medianprops=dict(ls='-', color='#000000'))
+
+	ax.set(xlim=(355, 900),
+		   ylim=(0, None),
+		   xlabel=r'$\lambda\ (nm)$',
+		   ylabel=r'$Absorption\ (1/Mm)$', )
+
+
+@set_figure(figsize=(6, 5))
+def plot_day_night(df):
+	# Group by hour of day and calculate mean
+	df_grouped = df.groupby(df.index.hour).mean()
+
+	# Create figure and plot
+	fig, ax = plt.subplots()
+	ax.plot(df_grouped.index, df_grouped['MA350_0171 IR BCc'], marker='o', c='k', alpha=0.5, label='MA350-0171')
+	ax.plot(df_grouped.index, df_grouped['MA350_0176 IR BCc'], marker='o', c='r', alpha=0.5, label='MA350-0176')
+	ax.plot(df_grouped.index, df_grouped['BC1054 IR BCc'], marker='o', c='b', alpha=0.5, label='BC-1054')
+
+	ax.set(xlim=(0, 23),
+		   xlabel='Hour of Day',
+		   ylabel=r'$BC\ (ng/m^3)$',
+		   title=f'Diurnal pattern', )
+
+	ax.legend()