AeroViz 0.1.0__tar.gz

aeroviz-0.1.0/AeroViz/__init__.py

@@ -0,0 +1,15 @@
+# This file is used to import all the modules in the DataPlot package
+from AeroViz import plot
+from AeroViz.dataProcess import Optical, SizeDistr, Chemistry, VOC
+from AeroViz.plot import Color, Unit, set_figure
+from AeroViz.process import DataProcess
+from AeroViz.rawDataReader import RawDataReader
+from AeroViz.tools import DataBase, DataReader, DataClassifier
+
+__all__ = [
+	'plot',
+	'Color', 'Unit', 'set_figure',
+	'RawDataReader',
+	'Optical', 'SizeDistr', 'Chemistry', 'VOC',
+	'DataProcess', 'DataBase', 'DataReader', 'DataClassifier',
+]

aeroviz-0.1.0/AeroViz/dataProcess/Chemistry/__init__.py

@@ -0,0 +1,63 @@
+from ..core import _writter, _run_process
+
+__all__ = [
+
+	'Chemistry',
+
+]
+
+
+class Chemistry(_writter):
+
+	## Reconstruction
+	@_run_process('Chemistry - reconstruction basic', 'reconstrc_basic')
+	def ReConstrc_basic(self, *df_chem, df_ref=None, df_water=None, df_density=None,
+						nam_lst=['NH4+', 'SO42-', 'NO3-', 'Fe', 'Na+', 'OC', 'EC']):
+		from ._mass_volume import _basic
+
+		out = _basic(df_chem, df_ref, df_water, df_density, nam_lst=nam_lst)
+
+		return self, out
+
+	## Partition
+	@_run_process('Chemistry -  Partition', 'partition')
+	def Partition(self, *df_chem, nam_lst=['NH4+', 'SO42-', 'NO3-', 'Cl-', 'NO2', 'HNO3', 'SO2', 'NH3', 'HCl', 'temp']):
+		from ._partition import _basic
+
+		out = _basic(df_chem, nam_lst=nam_lst)
+
+		return self, out
+
+	## ISOROPIA
+	@_run_process('Chemistry - ISOROPIA', 'isoropia')
+	def ISOROPIA(self, *df_chem,
+				 nam_lst=['Na+', 'SO42-', 'NH4+', 'NO3-', 'Cl-', 'Ca2+', 'K+', 'Mg2+', 'NH3', 'HNO3', 'HCl', 'RH',
+						  'temp']):
+		from ._isoropia import _basic
+
+		if self.path_out is None:
+			raise ValueError('Please Input "path_out" !!')
+
+		out = _basic(df_chem, self.path_out, nam_lst=nam_lst)
+
+		return self, out
+
+	## OCEC
+	@_run_process('Chemistry - OC/EC basic', 'ocec_basic')
+	def OCEC_basic(self, df_lcres, df_res, df_mass=None, ocec_ratio=None, ocec_ratio_month=1, hr_lim=200,
+				   least_square_range=(0.1, 2.5, 0.1), WISOC_OC_range=(0.2, 0.7, 0.01), ):
+		from ._ocec import _basic
+
+		out = _basic(df_lcres, df_res, df_mass, ocec_ratio, ocec_ratio_month, hr_lim, least_square_range,
+					 WISOC_OC_range)
+
+		return self, out
+
+	## TEOM
+	@_run_process('Chemistry - TEOM basic', 'teom_basic')
+	def TEOM_basic(self, df_teom, df_check=None):
+		from ._teom import _basic
+
+		out = _basic(df_teom, df_check)
+
+		return self, out

aeroviz-0.1.0/AeroViz/dataProcess/Chemistry/_calculate.py

@@ -0,0 +1,27 @@
+from pandas import concat, DataFrame
+
+# parameter
+_mol_wg = {
+	'SO42-': 96.06,
+	'NO3-': 62.00,
+	'Cl-': 35.4,
+
+	'Ca2+': 40.078,
+	'K+': 39.098,
+	'Mg2+': 24.305,
+	'Na+': 22.99,
+	'NH4+': 18.04,
+}
+
+
+# ug -> umol
+def _ug2umol(_df):
+	_pt_ky = list(set(_df.keys()) & set(_mol_wg.keys()))
+	_gas_ky = list(set(_df.keys()) - set(_mol_wg.keys()) - set(['temp', 'RH']))
+
+	_par = (_df['temp'].to_frame() + 273.15) * .082
+
+	_df_pt = concat([(_df[_ky] / _mol_wg[_ky]).copy() for _ky in _pt_ky], axis=1)
+	_df_gas = _df[_gas_ky] / _par.values
+
+	return concat([_df_pt, _df_gas], axis=1)

aeroviz-0.1.0/AeroViz/dataProcess/Chemistry/_isoropia.py

@@ -0,0 +1,99 @@
+from subprocess import Popen, PIPE
+from pandas import date_range, concat, DataFrame, to_numeric, read_csv
+from ._calculate import _ug2umol
+import numpy as np
+
+from pathlib import Path
+
+
+def _basic(df_che, path_out, nam_lst):
+	# parameter
+	df_all = concat(df_che, axis=1)
+	index = df_all.index.copy()
+	df_all.columns = nam_lst
+
+	df_umol = _ug2umol(df_all)
+
+	## output
+	## Na, SO4, NH3, NO3, Cl, Ca, K, Mg, RH, TEMP
+	df_input = DataFrame(index=index)
+	df_out = DataFrame(index=index)
+
+	pth_input = path_out / '_temp_input.txt'
+	pth_output = path_out / '_temp_input.dat'
+
+	pth_input.unlink(missing_ok=True)
+	pth_output.unlink(missing_ok=True)
+
+	## header
+	_header = 'Input units (0=umol/m3, 1=ug/m3)\n' + '0\n\n' + \
+			  'Problem type (0=forward, 1=reverse); Phase state (0=solid+liquid, 1=metastable)\n' + '0, 1\n\n' + \
+			  'NH4-SO4 system case\n'
+
+	## software
+	path_iso = Path(__file__).parent / 'isrpia2.exe'
+
+	# make input file and output temp input (without index)
+	## NH3
+	df_input['NH3'] = df_umol['NH4+'].fillna(0).copy() + df_umol['NH3']
+
+	## NO3
+	df_input['NO3'] = df_umol['HNO3'].fillna(0).copy() + df_umol['NO3-']
+
+	## Cl
+	df_input['Cl'] = df_umol['HCl'].fillna(0).copy() + df_umol['Cl-']
+
+	## temp, RH
+	df_input['RH'] = df_all['RH'] / 100
+	df_input['TEMP'] = df_all['temp'] + 273.15
+
+	df_input[['Na', 'SO4', 'Ca', 'K', 'Mg']] = df_umol[['Na+', 'SO42-', 'Ca2+', 'K+', 'Mg2+']].copy()
+
+	df_input = df_input[['Na', 'SO4', 'NH3', 'NO3', 'Cl', 'Ca', 'K', 'Mg', 'RH', 'TEMP']].fillna('-').copy()
+
+	## output the input data
+	df_input.to_csv(pth_input, index=False)
+	with (pth_input).open('r+', encoding='utf-8', errors='ignore') as _f:
+		_cont = _f.read()
+		_f.seek(0)
+
+		_f.write(_header)
+		_f.write(_cont)
+
+	# use ISOROPIA2
+	run = Popen([path_iso], stdin=PIPE, stdout=PIPE, stderr=PIPE)
+	scrn_res, run_res = run.communicate(input=str(pth_input.resolve()).encode())
+
+	# read dat file and transform to the normal name
+	cond_idx = df_all[['SO42-', 'NH4+', 'NO3-']].dropna().index
+
+	with (pth_output).open('r', encoding='utf-8', errors='ignore') as f:
+		df_res = read_csv(f, delimiter='\s+').apply(to_numeric, errors='coerce').set_index(index)
+
+	df_out['H'] = df_res['HLIQ'] / (df_res['WATER'] / 1000)
+
+	df_out.loc[cond_idx, 'pH'] = -np.log10(df_out['H'].loc[cond_idx])
+	df_out['pH'] = df_out['pH'].where((df_all['RH'] <= 95) & (df_all['RH'] >= 20))
+
+	cond_idx = df_out['pH'].dropna().index
+	df_out.loc[cond_idx, 'ALWC'] = df_res['WATER'].loc[cond_idx]
+
+	df_out[['NH3', 'HNO3', 'HCl', 'NH4+', 'NO3-', 'Cl-']] = df_res[
+		['GNH3', 'GHNO3', 'GHCL', 'NH4AER', 'NO3AER', 'CLAER']]
+
+	# calculate partition
+	# df_out['epls_NO3-'] = df_umol['NO3-'] / (df_umol['NO3-'] + df_umol['HNO3'])
+	# df_out['epls_NH4+'] = df_umol['NH4+'] / (df_umol['NH4+'] + df_umol['NH3'])
+	# df_out['epls_Cl-']  = df_umol['Cl-'] / (df_umol['Cl-'] + df_umol['HCl'])
+
+	# remove _temp file (input and output)
+	pth_input.unlink(missing_ok=True)
+	pth_output.unlink(missing_ok=True)
+
+	# output input and output
+	out = {
+		'input': df_input,
+		'output': df_out,
+	}
+
+	return out

aeroviz-0.1.0/AeroViz/dataProcess/Chemistry/_mass_volume.py

@@ -0,0 +1,175 @@
+from pandas import date_range, concat, DataFrame, to_numeric
+
+
+def _basic(df_che, df_ref, df_water, df_density, nam_lst):
+	df_all = concat(df_che, axis=1)
+	index = df_all.index.copy()
+	df_all.columns = nam_lst
+
+	## parameter
+	mol_A, mol_S, mol_N = df_all['NH4+'] / 18, df_all['SO42-'] / 96, df_all['NO3-'] / 62
+	df_all['status'] = (mol_A) / (2 * mol_S + mol_N)
+
+	convert_nam = {'AS': 'SO42-',
+				   'AN': 'NO3-',
+				   'OM': 'OC',
+				   'Soil': 'Fe',
+				   'SS': 'Na+',
+				   'EC': 'EC',
+				   }
+
+	mass_coe = {'AS': 1.375,
+				'AN': 1.29,
+				'OM': 1.8,
+				'Soil': 28.57,
+				'SS': 2.54,
+				'EC': 1,
+				}
+
+	vol_coe = {'AS': 1.76,
+			   'AN': 1.73,
+			   'OM': 1.4,
+			   'Soil': 2.6,
+			   'SS': 2.16,
+			   'EC': 1.5,
+			   }
+
+	RI_coe = {'550': {'ALWC': 1.333 + 0j,
+					  'AS': 1.53 + 0j,
+					  'AN': 1.55 + 0j,
+					  'OM': 1.55 + 0.0163j,
+					  'Soil': 1.56 + 0.006j,
+					  'SS': 1.54 + 0j,
+					  'EC': 1.80 + 0.72j,
+					  },
+
+			  ## m + kj -> m value is same as 550 current
+			  '450': {'ALWC': 1.333 + 0j,
+					  'AS': 1.57 + 0j,
+					  'AN': 1.57 + 0j,
+					  'OM': 1.58 + 0.056,
+					  'Soil': 1.56 + 0.009j,
+					  'SS': 1.54 + 0j,
+					  'EC': 1.80 + 0.79j,
+					  },
+			  }
+
+	## mass
+	## NH4 Enough
+	df_mass = DataFrame()
+	df_enough = df_all.where(df_all['status'] >= 1).dropna().copy()
+
+	for _mass_nam, _coe in mass_coe.items():
+		df_mass[_mass_nam] = df_all[convert_nam[_mass_nam]] * _coe
+
+	## NH4 Deficiency
+	defic_idx = df_all['status'] < 1
+
+	if defic_idx.any():
+		residual = mol_A - 2 * mol_S
+
+		## residual > 0
+		_status = residual > 0
+		if _status.any():
+			_cond = _status & (residual <= mol_N)
+			df_mass.loc[_cond, 'AN'] = residual.loc[_cond] * 80
+
+			_cond = _status & (residual > mol_N)
+			df_mass.loc[_cond, 'AN'] = mol_N.loc[_cond] * 80
+
+		## residual < 0
+		_status = residual <= 0
+		if _status.any():
+			df_mass.loc[_status, 'AN'] = 0
+
+			_cond = _status & (mol_A <= 2 * mol_S)
+			df_mass.loc[_cond, 'AS'] = mol_A.loc[_cond] / 2 * 132
+
+			_cond = _status & (mol_A > 2 * mol_S)
+			df_mass.loc[_cond, 'AS'] = mol_S.loc[_cond] * 132
+
+	df_mass_cal = df_mass.dropna().copy()
+	df_mass['total'] = df_mass.sum(axis=1, min_count=6)
+
+	qc_ratio = df_mass['total'] / df_ref
+	qc_cond = (qc_ratio >= 0.7) & (qc_ratio <= 1.3)
+
+	## volume
+	df_vol = DataFrame()
+	for _vol_nam, _coe in vol_coe.items():
+		df_vol[_vol_nam] = df_mass_cal[_vol_nam] / _coe
+
+	if df_water is not None:
+		df_vol['ALWC'] = df_water
+		df_vol = df_vol.dropna()
+		df_vol['total_wet'] = df_vol.sum(axis=1, min_count=6)
+
+	df_vol['total_dry'] = df_vol[vol_coe.keys()].sum(axis=1, min_count=6)
+
+	## density
+	df_vol_cal = DataFrame()
+	df_den_rec = df_mass['total'] / df_vol['total_dry']
+	if df_density is not None:
+		df_den_all = concat([df_all[['SO42-', 'NO3-', 'NH4+', 'EC']], df_density, df_mass['OM']], axis=1).dropna()
+
+		df_vol_cal = (df_den_all[['SO42-', 'NO3-', 'NH4+']].sum(axis=1) / 1.75) + \
+					 df_den_all['Cl-'] / 1.52 + \
+					 df_den_all['OM'] / 1.4 + df_den_all['EC'] / 1.77
+
+		df_den = df_den_all.sum(axis=1, min_count=6) / df_vol_cal
+	# df_den = df_den_all.sum(axis=1) / df_vol_cal
+	# df_den = df_mass['total'].loc[df_den_all.index] / df_vol_cal
+
+	## refractive index
+	ri_dic = {}
+	for _lambda, _coe in RI_coe.items():
+
+		df_RI = DataFrame()
+
+		for _ky, _df in df_vol.items():
+			if 'total' in _ky: continue
+			df_RI[_ky] = (_df * _coe[_ky])
+
+		df_RI['RI_wet'] = None
+		if df_water is not None:
+			df_RI['RI_wet'] = (df_RI / df_vol['total_wet'].to_frame().values).sum(axis=1)
+
+		df_RI['RI_dry'] = (df_RI[vol_coe.keys()] / df_vol['total_dry'].to_frame().values).sum(axis=1)
+
+		ri_dic[f'RI_{_lambda}'] = df_RI[['RI_dry', 'RI_wet']]
+
+	## mole and equivalent
+	df_eq = concat((mol_A, mol_S, mol_N, mol_A * 1, mol_S * 2, mol_N * 1), axis=1)
+	df_eq.columns = ['mol_NH4', 'mol_SO4', 'mol_NO3', 'eq_NH4', 'eq_SO4', 'eq_NO3', ]
+
+	## out
+	out = {'mass': df_mass,
+		   'volume': df_vol,
+		   'vol_cal': df_vol_cal,
+		   'eq': df_eq,
+		   'density_mat': df_den,
+		   'density_rec': df_den_rec,
+		   }
+	out.update(ri_dic)
+
+	for _ky, _df in out.items():
+		out[_ky] = _df.reindex(index).where(qc_cond)
+
+	return out
+
+
+# '''
+
+
+def mass_ratio(_df):
+	if _df['PM25'] >= _df['total_mass']:
+		_df['others'] = _df['PM25'] - _df['total_mass']
+		for _val, _species in zip(_df.values, _df.index):
+			_df[f'{_species}_ratio'] = _val / _df['PM25'].__round__(3)
+
+	if _df['PM25'] < _df['total_mass']:
+		_df['others'] = 0
+		for _val, _species in zip(_df.values, _df.index):
+			_df[f'{_species}_ratio'] = _val / _df['PM25'].__round__(3)
+
+	return _df['others':].drop(labels=['PM25_ratio', 'total_mass_ratio'])

aeroviz-0.1.0/AeroViz/dataProcess/Chemistry/_ocec.py

@@ -0,0 +1,184 @@
+from AeroViz.dataProcess.core import _union_index
+
+from pandas import date_range, concat, DataFrame, to_numeric
+from scipy.optimize import curve_fit
+import numpy as np
+
+__all__ = [
+	'_basic',
+	# '_ocec_ratio_cal',
+]
+
+
+def _min_Rsq(_oc, _ec, _rng):
+	_val_mesh, _oc_mesh = np.meshgrid(_rng, _oc)
+	_val_mesh, _ec_mesh = np.meshgrid(_rng, _ec)
+
+	_out_table = DataFrame(_oc_mesh - _val_mesh * _ec_mesh, index=_oc.index, columns=_rng)
+
+	## calculate R2
+	_r2_dic = {}
+	_func = lambda _x, _sl, _inte: _sl * _x + _inte
+	for _ocec, _out in _out_table.items():
+		_df = DataFrame([_out.values, _ec.values]).T.dropna()
+
+		_x, _y = _df[0], _df[1]
+		_opt, _ = curve_fit(_func, _x, _y)
+
+		_tss = np.sum((_y - _y.mean()) ** 2.)
+		_rss = np.sum((_y - _func(_x, *_opt)) ** 2.)
+
+		_r2_dic[round(_ocec, 3)] = 1. - _rss / _tss
+
+	## get the min R2
+	_ratio = DataFrame(_r2_dic, index=[0]).idxmin(axis=1).values[0]
+
+	return _ratio, _out_table[_ratio]
+
+
+def _ocec_ratio_cal(_nam, _lcres_splt, _hr_lim, _range_, _wisoc_range_):
+	## parameter
+	_out = DataFrame(index=_lcres_splt.index)
+	(_, _oc), (_, _ec) = _lcres_splt.items()
+	# _oc, _ec = _lcres_splt['Thermal_OC'], _lcres_splt['Thermal_EC']
+
+	## real data OC/EC
+	_ocec_ratio_real = (_oc / _ec).quantile(.5)
+
+	_out[f'OC/EC_real_{_nam}'] = _ocec_ratio_real
+	_out[f'POC_real_{_nam}'] = _ocec_ratio_real * _ec
+	_out[f'SOC_real_{_nam}'] = _oc - _out[f'POC_real_{_nam}']
+
+	## the least R2 method
+	## estimated OC/EC
+	if (len(_lcres_splt) <= _hr_lim):
+		print(f"\t\t{_lcres_splt.index[0].strftime('%Y-%m-%d %X')} to {_lcres_splt.index[-1].strftime('%Y-%m-%d %X')}")
+		print('\t\tPlease Modify the Values of "hour_limit" or Input Sufficient Amount of Data !!')
+
+		_out[[f'OC/EC_{_nam}', f'POC_{_nam}', f'SOC_{_nam}', f'WISOC/OC_{_nam}', f'WSOC_{_nam}',
+			  f'WISOC_{_nam}']] = np.nan
+
+		return _out
+
+	if (len(_lcres_splt.dropna()) == 0):
+		_out[[f'OC/EC_{_nam}', f'POC_{_nam}', f'SOC_{_nam}', f'WISOC/OC_{_nam}', f'WSOC_{_nam}',
+			  f'WISOC_{_nam}']] = np.nan
+
+		return _out
+
+	## OC/EC
+	_ocec_ratio = False
+	_st, _ed, _stp = _range_
+
+	for _ in range(2):
+		if _ocec_ratio:
+			_ocec_rng = np.arange(_ocec_ratio - _stp / 2, _ocec_ratio + _stp / 2, .01).round(3)
+		else:
+			_ocec_rng = np.arange(_st, _ed + _stp, _stp).round(3)
+
+		_ocec_ratio, _soc = _min_Rsq(_oc, _ec, _ocec_rng)
+
+	## WISOC
+	_st, _ed, _stp = _wisoc_range_
+	_wisoc_rng = (np.arange(_st, _ed + _stp, _stp) * _ocec_ratio).round(5)
+	_wisoc_ratio, _wsoc = _min_Rsq(_oc, _ec, _wisoc_rng)
+
+	## out
+	_out[f'OC/EC_{_nam}'] = _ocec_ratio
+	_out[f'SOC_{_nam}'] = _soc
+	_out[f'POC_{_nam}'] = _oc - _out[f'SOC_{_nam}']
+	_out[f'WISOC/OC_{_nam}'] = _wisoc_ratio
+	_out[f'WSOC_{_nam}'] = _wsoc
+	_out[f'WISOC_{_nam}'] = _oc - _out[f'WSOC_{_nam}']
+
+	return _out[[f'OC/EC_{_nam}', f'POC_{_nam}', f'SOC_{_nam}', f'WISOC/OC_{_nam}', f'WSOC_{_nam}', f'WISOC_{_nam}',
+				 f'OC/EC_real_{_nam}', f'POC_real_{_nam}', f'SOC_real_{_nam}']]
+
+
+def _basic(_lcres, _res, _mass, _ocec_ratio, _ocec_ratio_month, _hr_lim, _range, _wisoc_range):
+	_lcres, _res, _mass = _union_index(_lcres, _res, _mass)
+
+	_out = {}
+
+	## OC1, OC2, OC3, OC4, PC
+	_df_bsc = _res / _lcres['Sample_Volume'].to_frame().values.copy()
+
+	## SOC, POC, OC/EC
+	if _ocec_ratio is not None:
+		try:
+			iter(_ocec_ratio)
+		except TypeError:
+			raise TypeError('"ocec_ratio" Only Accept a Single Value !!')
+
+		_prcs_df = DataFrame(index=_df_bsc.index)
+		_prcs_df['OC/EC'] = _ocec_ratio
+		_prcs_df['POC'] = _ocec_ratio * _lcres['Thermal_EC']
+		_prcs_df['SOC'] = _lcres['Thermal_OC'] - _prcs_df['POC']
+
+	else:
+		_df_lst = []
+		for _, _df in _lcres.resample(f'{_ocec_ratio_month}MS', closed='left'):
+			_thm_cal = _ocec_ratio_cal('thm', _df[['Thermal_OC', 'Thermal_EC']], _hr_lim, _range, _wisoc_range)
+			_opt_cal = _ocec_ratio_cal('opt', _df[['Optical_OC', 'Optical_EC']], _hr_lim, _range, _wisoc_range)
+			_df_lst.append(concat([_thm_cal, _opt_cal], axis=1))
+
+		_prcs_df = concat(_df_lst)
+
+	_df_bsc = concat((_df_bsc.copy(), _prcs_df), axis=1)
+
+	## ratio
+	_df_ratio = DataFrame(index=_df_bsc.index)
+
+	for _ky, _val in _df_bsc.items():
+		if 'OC/EC' in _ky: continue
+		_df_ratio[f'{_ky}/Thermal_OC'] = _val / _lcres['Thermal_OC']
+		_df_ratio[f'{_ky}/Optical_OC'] = _val / _lcres['Optical_OC']
+
+	if _mass is not None:
+		for _ky, _val in _df_bsc.items():
+			_df_ratio[f'{_ky}/PM'] = _val / _mass
+
+		_df_ratio[f'Thermal_OC/PM'] = _lcres['Thermal_OC'] / _mass
+		_df_ratio[f'Thermal_EC/PM'] = _lcres['Thermal_EC'] / _mass
+
+		_df_ratio[f'Optical_OC/PM'] = _lcres['Optical_OC'] / _mass
+		_df_ratio[f'Optical_EC/PM'] = _lcres['Optical_EC'] / _mass
+
+	## ratio status
+	_df_bsc = concat((_lcres, _df_bsc.copy()), axis=1)
+
+	for _ky, _df in _df_ratio.items():
+		_df_bsc[f'{_ky}_status'] = 'Normal'
+		_df_bsc[f'{_ky}_status'] = _df_bsc[f'{_ky}_status'].mask(_df > 1, 'Warning')
+
+	## out
+	_out['ratio'] = _df_ratio
+	_out['basic'] = _df_bsc
+
+	return _out
+
+
+'''
+_ocec_mesh, _oc_mesh = n.meshgrid(_ocec_rng, _oc)
+_ocec_mesh, _ec_mesh = n.meshgrid(_ocec_rng, _ec)
+
+_soc_table = DataFrame(_oc_mesh-_ocec_mesh*_ec_mesh, index=_oc.index, columns=_ocec_rng)
+
+## calculate R2
+_r2_dic = {}
+_func = lambda _x, _sl, _inte : _sl*_x+_inte
+for _ocec, _soc in _soc_table.items():
+
+	_df = DataFrame([_soc.values, _ec.values]).T.dropna()
+	_x, _y = _df[0], _df[1]
+
+	_opt, _ = curve_fit(_func, _x, _y)
+
+	_tss = n.sum((_y - _y.mean())**2.)
+	_rss = n.sum((_y - _func(_x, *_opt))**2.)
+
+	_r2_dic[round(_ocec,2)] = 1. - _rss / _tss
+
+## get the min R2
+_ocec_ratio = DataFrame(_r2_dic, index=[0]).idxmin(axis=1).values[0]
+# '''

aeroviz-0.1.0/AeroViz/dataProcess/Chemistry/_partition.py

@@ -0,0 +1,29 @@
+from pandas import date_range, concat, DataFrame, to_numeric
+from ._calculate import _ug2umol
+
+
+def _basic(df_che, nam_lst):
+	# parameter
+	df_all = concat(df_che, axis=1)
+	index = df_all.index.copy()
+	df_all.columns = nam_lst
+
+	df_umol = _ug2umol(df_all)
+
+	# calculate
+	df_out = DataFrame(index=df_umol.index)
+
+	# df_out['NTR'] = df_umol['NH4+'] / (df_umol['NH4+'] + df_all['NH3'] / 22.4)
+	df_out['NTR+'] = df_umol['NH4+'] / (df_umol['NH4+'] + df_umol['NH3'])
+
+	df_out['NOR'] = df_umol['NO3-'] / (df_umol['NO3-'] + df_umol['NO2'])
+	df_out['NOR_2'] = (df_umol['NO3-'] + df_umol['HNO3']) / (df_umol['NO3-'] + df_umol['NO2'] + df_umol['HNO3'])
+
+	df_out['SOR'] = df_umol['SO42-'] / (df_umol['SO42-'] + df_umol['SO2'])
+
+	df_out['epls_NO3-'] = df_umol['NO3-'] / (df_umol['NO3-'] + df_umol['HNO3'])
+	df_out['epls_NH4+'] = df_umol['NH4+'] / (df_umol['NH4+'] + df_umol['NH3'])
+	df_out['epls_SO42-'] = df_out['SOR']
+	df_out['epls_Cl-'] = df_umol['Cl-'] / (df_umol['Cl-'] + df_umol['HCl'])
+
+	return df_out

aeroviz-0.1.0/AeroViz/dataProcess/Chemistry/_teom.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+
+def _basic(_teom, _check):
+	_teom['Volatile_Fraction'] = (_teom['PM_Total'] - _teom['PM_NV']) / _teom['PM_Total']
+
+	_teom.loc[(_teom['Volatile_Fraction'] < 0) | (_teom['Volatile_Fraction'] > 1)] = n.nan
+
+	if _check is not None:
+		_ratio = _teom['PM_NV'] / _check
+		_teom['PM_Check'] = _check
+
+		_teom.loc[_teom.dropna().index, 'status'] = 'Warning'
+		_teom.loc[(_ratio > 0) & (_ratio < 1), 'status'] = 'Normal'
+
+	return _teom

aeroviz-0.1.0/AeroViz/dataProcess/Optical/_IMPROVE.py

@@ -0,0 +1,61 @@
+import pickle as pkl
+from pathlib import Path
+import numpy as np
+
+from pandas import date_range, concat, DataFrame, to_numeric
+from AeroViz.dataProcess.core import _union_index
+
+
+def _revised(_df_mass, _df_RH):
+	_df_mass, _df_RH = _union_index(_df_mass, _df_RH)
+
+	## fRH
+	with (Path(__file__).parent / 'fRH.pkl').open('rb') as f:
+		_fRH = pkl.load(f)
+		_fRH.loc[np.nan] = np.nan
+
+	def fRH(_RH):
+		if _RH is not None:
+			_RH = _RH.mask(_RH > 95, 95).round(0)
+			return _fRH.loc[_RH].values.T
+
+		return 1, 1, 1, 1
+
+	## different mode
+	## mass < 20 :
+	## 				large = mass**2/20
+	## 				small = mass-large
+	## mass >= 20 :
+	## 				large = mass
+	## 				small = 0
+	_df_mode = _df_mass[['AS', 'AN', 'OM']].copy()
+
+	_df_mass[['L_AS', 'L_AN', 'L_OM']] = _df_mode.mask(_df_mode < 20, _df_mode ** 2 / 20)
+	_df_mass[['S_AS', 'S_AN', 'S_OM']] = _df_mode.values - _df_mass[['L_AS', 'L_AN', 'L_OM']]
+
+	## apply IMPROVE ccoe.
+	def _ext_cal(_RH=None):
+
+		_frh, _frhss, _frhs, _frhl = fRH(_RH)
+		_df = DataFrame(index=_df_mass.index)
+
+		_df['AS'] = 2.2 * _frhs * _df_mass['S_AS'] + 4.8 * _frhl * _df_mass['L_AS']
+		_df['AN'] = 2.4 * _frhs * _df_mass['S_AN'] + 5.1 * _frhl * _df_mass['L_AN']
+		_df['OM'] = 2.8 * _df_mass['S_OM'] + 6.1 * _frhl * _df_mass['L_OM']
+		_df['Soil'] = _df_mass['Soil']
+		_df['SS'] = 1.7 * _frhss * _df_mass['SS']
+		_df['EC'] = 10 * _df_mass['EC']
+
+		_df['total'] = _df.sum(axis=1)
+
+		return _df.dropna().reindex(_df_mass.index)
+
+	## calculate
+	_out = {}
+
+	_out['dry'] = _ext_cal()
+
+	if _df_RH is not None:
+		_out['wet'] = _ext_cal(_df_RH)
+
+	return _out