AeroViz 0.1.0__py3-none-any.whl

AeroViz/dataProcess/SizeDistr/_merge_v4.py

@@ -0,0 +1,424 @@
+# from ContainerHandle.dataProcess.utils import _union_index
+
+from datetime import datetime as dtm
+
+import numpy as np
+from pandas import DataFrame, concat, DatetimeIndex
+# from scipy.interpolate import interp1d
+from scipy.interpolate import UnivariateSpline as unvpline, interp1d
+
+from multiprocessing import Pool, cpu_count
+from functools import partial
+
+import warnings
+
+warnings.filterwarnings("ignore")
+
+__all__ = ['_merge_SMPS_APS']
+
+
+def _powerlaw_fit(_coeA, _coeB, _aps, _idx, _factor):
+	# breakpoint()
+
+	_smps_fit_df = _coeA * (_aps.keys().values / _factor) ** _coeB
+	return DataFrame(((_smps_fit_df.copy() - _aps.copy()) ** 2).sum(axis=1), columns=[_idx])
+
+
+## Calculate S2
+## 1. SMPS and APS power law fitting
+## 2. shift factor from 0.5 ~ 3
+## 3. calculate S2
+## return : S2
+# def _S2_calculate_dN(_smps, _aps):
+def _powerlaw_fit_dN(_smps, _aps, _alg_type):
+	print(f"\t\t\t{dtm.now().strftime('%m/%d %X')} : \033[92moverlap range fitting : {_alg_type}\033[0m")
+
+	## overlap fitting
+	## parmeter
+	_dt_indx = _smps.index
+
+	## use SMPS data apply power law fitting
+	## y = Ax^B, A = e**coefa, B = coefb, x = logx, y = logy
+	## ref : http://mathworld.wolfram.com/LeastSquaresFittingPowerLaw.html
+	## power law fit to SMPS num conc at upper bins to log curve
+
+	## coefficient A, B
+	_smps_qc_cond = ((_smps != 0) & np.isfinite(_smps))
+	_smps_qc = _smps.where(_smps_qc_cond)
+
+	_size = _smps_qc_cond.sum(axis=1)
+	_size = _size.where(_size != 0.).copy()
+
+	_logx, _logy = np.log(_smps_qc.keys()._data.astype(float)), np.log(_smps_qc)
+	_x, _y, _xy, _xx = _logx.sum(), _logy.sum(axis=1), (_logx * _logy).sum(axis=1), (_logx ** 2).sum()
+
+	_coeB = ((_size * _xy - _x * _y) / (_size * _xx - _x ** 2.))
+	_coeA = np.exp((_y - _coeB * _x) / _size).values.reshape(-1, 1)
+	_coeB = _coeB.values.reshape(-1, 1)
+
+	## rebuild shift smps data by coe. A, B
+	## x_shift = (y_ori/A)**(1/B)
+	_aps_shift_x = (_aps / _coeA) ** (1 / _coeB)
+	_aps_shift_x = _aps_shift_x.where(np.isfinite(_aps_shift_x))
+
+	## the least squares of diameter
+	## the shift factor which the closest to 1
+	_shift_val = np.arange(0.3, 3.05, .05) ** .5
+	# _shift_val = np.arange(0.9, 1.805, .005)**.5
+
+	_shift_factor = DataFrame(columns=range(_shift_val.size), index=_aps_shift_x.index)
+	_shift_factor.loc[:, :] = _shift_val
+
+	# _dropna_idx = _shift_factor.dropna(how='all').index.copy()
+	_dropna_idx = _aps_shift_x.dropna(how='all').index.copy()
+
+	## use the target function to get the similar aps and smps bin
+	## S2 = sum( (smps_fit_line(dia) - aps(dia*shift_factor) )**2 )
+	## assumption : the same diameter between smps and aps should get the same conc.
+
+	## be sure they art in log value
+	_S2 = DataFrame(index=_aps_shift_x.index)
+	_dia_table = DataFrame(np.full(_aps_shift_x.shape, _aps_shift_x.keys()),
+						   columns=_aps_shift_x.keys(), index=_aps_shift_x.index)
+
+	pool = Pool(cpu_count())
+
+	_S2 = pool.starmap(partial(_powerlaw_fit, _coeA, _coeB, _aps), list(enumerate(_shift_val)))
+
+	pool.close()
+	pool.join()
+
+	S2 = concat(_S2, axis=1)[np.arange(_shift_val.size)]
+	# S2 /= S2.max(axis=1).to_frame().values
+
+	shift_factor_dN = DataFrame(
+		_shift_factor.loc[_dropna_idx].values[range(len(_dropna_idx)), S2.loc[_dropna_idx].idxmin(axis=1).values],
+		index=_dropna_idx).reindex(_dt_indx).astype(float)
+
+	shift_factor_dN = shift_factor_dN.mask((shift_factor_dN ** 2 < 0.6) | (shift_factor_dN ** 2 > 2.6))
+
+	return shift_factor_dN
+
+
+def _corr_fc(_aps_dia, _smps_dia, _smps_dn, _aps_dn, _smooth, _idx, _sh):
+	ds_fc = lambda _dt: _dt * _dt.index ** 2 * np.pi
+	dv_fc = lambda _dt: _dt * _dt.index ** 3 * np.pi / 6
+
+	_aps_sh = _aps_dia / _sh
+	_aps_sh_inp = _aps_sh.where((_aps_sh >= 500) & (_aps_sh <= 1500.)).copy()
+	_aps_sh_corr = _aps_sh.where((_aps_sh >= _smps_dia[-1]) & (_aps_sh <= 1500.)).copy()
+
+	corr_x = np.append(_smps_dia, _aps_sh_corr.dropna())
+
+	input_x = np.append(_smps_dia, _aps_sh_inp.dropna())
+	input_y = concat([_smps_dn, _aps_dn.iloc[:, ~np.isnan(_aps_sh_inp)]], axis=1)
+	input_y.columns = input_x
+
+	input_x.sort()
+	input_y = input_y[input_x]
+	corr_y = input_y[corr_x]
+
+	S2_lst = []
+	for (_tm, _inp_y_dn), (_tm, _cor_y_dn) in zip(input_y.dropna(how='all').iterrows(),
+												  corr_y.dropna(how='all').iterrows()):
+		## corr(spec_data, spec_spline)
+		_spl_dt = [unvpline(input_x, _inp_y, s=_smooth)(corr_x) for _inp_y in
+				   [_inp_y_dn, ds_fc(_inp_y_dn), dv_fc(_inp_y_dn)]]
+		_cor_dt = [_cor_y_dn, ds_fc(_cor_y_dn), dv_fc(_cor_y_dn)]
+
+		_cor_all = sum([np.corrcoef(_cor, _spl)[0, 1] for _cor, _spl in zip(_cor_dt, _spl_dt)])
+
+		S2_lst.append((3 - _cor_all) / 3)
+
+	return DataFrame(S2_lst, columns=[_idx])
+
+
+# def _S2_calculate_dSdV(_smps, _aps, _shft_dn, _S2, smps_ori, aps_ori):
+# def _S2_calculate_dSdV(_smps, _aps, smps_ori=None):
+def _corr_with_dNdSdV(_smps, _aps, _alg_type):
+	print(f"\t\t\t{dtm.now().strftime('%m/%d %X')} : \033[92moverlap range correlation : {_alg_type}\033[0m")
+
+	_smps_dia = _smps.keys().astype(float)
+	_aps_dia = _aps.keys().astype(float)
+
+	all_index = _smps.index.copy()
+	qc_index = DatetimeIndex(set(_smps.dropna(how='all').index) & set(_aps.dropna(how='all').index)).sort_values()
+
+	_smps_dn = _smps.loc[qc_index].copy()
+	_aps_dn = _aps.loc[qc_index].copy()
+
+	ds_fc = lambda _dt: _dt * _dt.index ** 2 * np.pi
+	dv_fc = lambda _dt: _dt * _dt.index ** 3 * np.pi / 6
+
+	_std_bin = np.geomspace(11.8, 19810, 230)
+	_merge_bin = _std_bin[(_std_bin >= _smps_dia[-1]) & (_std_bin < 1500)].copy()
+
+	_smooth = 50
+
+	_shift_val = np.arange(0.5, 2.605, .005) ** .5
+	_shift_val = np.arange(0.9, 2.01, .01) ** .5
+	_shift_val = np.arange(0.9, 2.65, .05) ** .5
+
+	## spline fitting with shift aps and smps
+	pool = Pool(cpu_count())
+
+	S2_lst = pool.starmap(partial(_corr_fc, _aps_dia, _smps_dia, _smps_dn, _aps_dn, _smooth),
+						  list(enumerate(_shift_val)))
+
+	pool.close()
+	pool.join()
+
+	S2_table = concat(S2_lst, axis=1).set_index(qc_index)[np.arange(_shift_val.size)].astype(float).dropna()
+	min_shft = S2_table.idxmin(axis=1).values
+
+	return DataFrame(_shift_val[min_shft.astype(int)], index=S2_table.index).astype(float).reindex(_smps.index)
+
+
+## Create merge data
+##  shift all smps bin and remove the aps bin which smaller than the latest old smps bin
+## Return : merge bins, merge data, density
+def _merge_data(_smps_ori, _aps_ori, _shift_ori, _smps_lb, _aps_hb, _shift_mode, _alg_type):
+	print(f"\t\t\t{dtm.now().strftime('%m/%d %X')} : \033[92mcreate merge data : {_shift_mode} and {_alg_type}\033[0m")
+
+	_ori_idx = _smps_ori.index.copy()
+	# _merge_idx = _smps_ori.loc[_aps_ori.dropna(how='all').index].dropna(how='all').index
+
+	_corr_aps_cond = _aps_ori.keys() < 700
+	_corr_aps_ky = _aps_ori.keys()[_corr_aps_cond]
+
+	_merge_idx = DatetimeIndex(set(_smps_ori.dropna(how='all').index) & set(_aps_ori.dropna(how='all').index) &
+							   set(_shift_ori.dropna(how='all').index)).sort_values()
+
+	_smps, _aps, _shift = _smps_ori.loc[_merge_idx], _aps_ori.loc[_merge_idx], _shift_ori.loc[_merge_idx].values
+
+	## parameter
+	_smps_key, _aps_key = _smps.keys()._data.astype(float), _aps.keys()._data.astype(float)
+
+	_cntr = 1000
+	_bin_lb = _smps_key[-1]
+
+	## make shift bins
+	_smps_bin = np.full(_smps.shape, _smps_key)
+	_aps_bin = np.full(_aps.shape, _aps_key)
+
+	_std_bin = np.geomspace(_smps_key[0], _aps_key[-1], 230)
+	_std_bin_merge = _std_bin[(_std_bin < _cntr) & (_std_bin > _bin_lb)]
+	_std_bin_inte1 = _std_bin[_std_bin <= _bin_lb]
+	_std_bin_inte2 = _std_bin[_std_bin >= _cntr]
+
+	if _shift_mode == 'mobility':
+		_aps_bin /= _shift
+
+	elif _shift_mode == 'aerodynamic':
+		_smps_bin *= _shift
+
+	## merge
+	_merge_lst, _corr_lst = [], []
+	for _bin_smps, _bin_aps, _dt_smps, _dt_aps, _sh in zip(_smps_bin, _aps_bin, _smps.values, _aps.values, _shift):
+		## keep complete smps bins and data
+		## remove the aps bin data lower than smps bin
+		_condi = _bin_aps >= _bin_smps[-1]
+
+		_merge_bin = np.hstack((_bin_smps, _bin_aps[_condi]))
+		_merge_dt = np.hstack((_dt_smps, _dt_aps[_condi]))
+
+		_merge_fit_loc = (_merge_bin < 1500) & (_merge_bin > _smps_lb)
+
+		## coeA and coeB
+		_unvpl_fc = unvpline(np.log(_merge_bin[_merge_fit_loc]), np.log(_merge_dt[_merge_fit_loc]), s=50)
+		_inte_fc = interp1d(_merge_bin, _merge_dt, kind='linear', fill_value='extrapolate')
+
+		_merge_dt_fit = np.hstack((_inte_fc(_std_bin_inte1), np.exp(_unvpl_fc(np.log(_std_bin_merge))),
+								   _inte_fc(_std_bin_inte2)))
+
+		_merge_lst.append(_merge_dt_fit)
+		_corr_lst.append(interp1d(_std_bin, _merge_dt_fit)(_bin_aps[_corr_aps_cond]))
+
+	_df_merge = DataFrame(_merge_lst, columns=_std_bin, index=_merge_idx)
+	_df_merge = _df_merge.mask(_df_merge < 0)
+
+	_df_corr = DataFrame(_corr_lst, columns=_corr_aps_ky, index=_merge_idx) / _aps_ori.loc[_merge_idx, _corr_aps_ky]
+
+	## process output df
+	## average, align with index
+	def _out_df(*_df_arg, **_df_kwarg):
+		_df = DataFrame(*_df_arg, **_df_kwarg).reindex(_ori_idx)
+		_df.index.name = 'time'
+		return _df
+
+	return _out_df(_df_merge), _out_df(_shift_ori ** 2), _out_df(_df_corr)
+
+
+def _fitness_func(psd, rho, pm25):
+	psd_pm25 = psd[psd.keys()[psd.keys().values <= 2500]] * np.diff(np.log10(psd.keys())).mean()
+	rho_pm25 = pm25 / (psd_pm25 * np.pi * psd_pm25.keys().values ** 3 / 6 * 1e-9).sum(axis=1, min_count=1)
+
+	return (rho['density'] - rho_pm25) ** 2
+
+
+def merge_SMPS_APS(df_smps, df_aps, df_pm25, aps_unit='um', smps_overlap_lowbound=500, aps_fit_highbound=1000,
+				   dndsdv_alg=True, times_range=(0.8, 1.25, .05)):
+	# merge_data, merge_data_dn, merge_data_dsdv, merge_data_cor_dn, density, density_dn, density_dsdv, density_cor_dn = [DataFrame([np.nan])] * 8
+
+	## set to the same units
+	smps, aps = df_smps.copy(), df_aps.copy()
+	smps.columns = smps.keys().to_numpy(float)
+	aps.columns = aps.keys().to_numpy(float)
+
+	if aps_unit == 'um':
+		aps.columns = aps.keys() * 1e3
+
+	fitness_typ = dict(dn=[], cor_dn=[], dndsdv=[], cor_dndsdv=[])
+	shift_typ = dict(dn=[], cor_dn=[], dndsdv=[], cor_dndsdv=[])
+	oth_typ = dict()
+
+	times_ary = np.arange(*times_range).round(4)
+	# times_ary = np.arange(*(0.8, 0.9, .05)).round(4)
+
+	for times in times_ary:
+
+		print(f"\t\t{dtm.now().strftime('%m/%d %X')} : \033[92mSMPS times value : {times}\033[0m")
+
+		aps_input = aps.copy()
+		aps_over = aps_input.loc[:, (aps.keys() > 700) & (aps.keys() < 1000)].copy()
+
+		smps_input = (smps * times).copy()
+		smps_over = smps_input[smps.keys()[smps.keys() > 500]].copy()
+
+		for _count in range(2):
+
+			## shift data calculate
+			## original
+			if _count == 0:
+				alg_type = 'dn'
+				shift = _powerlaw_fit_dN(smps_over, aps_over, alg_type)
+
+				if dndsdv_alg:
+					shift_dsdv = _corr_with_dNdSdV(smps_over, aps_over, 'dndsdv').mask(shift.isna())
+
+			## aps correct
+			else:
+				alg_type = 'cor_dndsdv'
+				shift_cor = _powerlaw_fit_dN(smps_over, aps_over, 'cor_dn')
+
+				if dndsdv_alg:
+					shift = _corr_with_dNdSdV(smps_over, aps_over, alg_type).mask(shift_cor.isna())
+
+			## merge aps and smps
+			## 1. power law fit (dn) -> return dn data and aps correct factor
+			## 2. correaltion with dn, ds, dv -> return corrected dn_ds_dv data
+			if (alg_type == 'dn') | dndsdv_alg:
+				merge_arg = (smps_input, aps_input, shift, smps_overlap_lowbound, aps_fit_highbound)
+
+				merge_data, density, _corr = _merge_data(*merge_arg, 'mobility', _alg_type=alg_type)
+				density.columns = ['density']
+
+				fitness_typ[alg_type].append(_fitness_func(merge_data, density, df_pm25))
+				shift_typ[alg_type].append(shift[0])
+
+			## without aps correct
+			if _count == 0:
+				## merge aps and smps
+				## dn_ds_dv data
+				if dndsdv_alg:
+					alg_type = 'dndsdv'
+					merge_arg = (smps_input, aps_input, shift_dsdv, smps_overlap_lowbound, aps_fit_highbound)
+
+					merge_data_dsdv, density_dsdv, _ = _merge_data(*merge_arg, 'mobility', _alg_type=alg_type)
+					density_dsdv.columns = ['density']
+
+					fitness_typ[alg_type].append(_fitness_func(merge_data_dsdv, density_dsdv, df_pm25))
+					shift_typ[alg_type].append(shift_dsdv[0])
+
+				## dn data
+				merge_data_dn, density_dn = merge_data.copy(), density.copy()
+
+				## correct aps data
+				corr = _corr.resample('1d').mean().reindex(smps.index).ffill()
+				corr = corr.mask(corr < 1, 1)
+
+				aps_input.loc[:, corr.keys()] *= corr
+				aps_over = aps_input.copy()
+
+
+			## with aps correct
+			else:
+				## merge aps and smps
+				## dn data
+				alg_type = 'cor_dn'
+				merge_arg = (smps_input, aps_input, shift_cor, smps_overlap_lowbound, aps_fit_highbound)
+
+				merge_data_cor_dn, density_cor_dn, _ = _merge_data(*merge_arg, 'mobility', _alg_type=alg_type)
+				density_cor_dn.columns = ['density']
+
+				fitness_typ[alg_type].append(_fitness_func(merge_data_cor_dn, density_cor_dn, df_pm25))
+				shift_typ[alg_type].append(shift_cor[0])
+
+	## get times value and shift value
+	out_dic = {}
+	for (_typ, _lst), (_typ, _shft) in zip(fitness_typ.items(), shift_typ.items()):
+		oth_typ[_typ] = None
+		if len(_lst) == 0: continue
+
+		df_times_min = concat(_lst, axis=1, keys=range(len(_lst))).idxmin(axis=1).dropna().astype(int)
+		df_shift = concat(_shft, axis=1, keys=times_ary.tolist()).loc[df_times_min.index].values[
+			range(len(df_times_min.index)), df_times_min.values]
+
+		oth_typ[_typ] = DataFrame(np.array([df_shift, times_ary[df_times_min.values]]).T,
+								  index=df_times_min.index, columns=['shift', 'times']).reindex(smps.index)
+
+	## re-calculate merge_data
+	alg_type = ['dn', 'cor_dn', 'dndsdv', 'cor_dndsdv'] if dndsdv_alg else ['dn', 'cor_dn']
+
+	out_dic = {}
+	den_lst, times_lst = [], []
+	for _typ in alg_type:
+		print(f"\t\t{dtm.now().strftime('%m/%d %X')} : \033[92mre-caculate merge data with times: {_typ}\033[0m")
+		typ = oth_typ[_typ]
+		smps_input = smps.copy() * typ['times'].to_frame().values
+
+		corr_typ = corr if 'cor' in _typ else 1
+		aps_input = aps.copy()
+		aps_input.loc[:, corr.keys()] *= corr_typ
+
+		merge_arg = (smps_input, aps_input, typ['shift'].to_frame(), smps_overlap_lowbound, aps_fit_highbound)
+
+		merge_data, density, _corr = _merge_data(*merge_arg, 'mobility', _alg_type=_typ)
+		density.columns = ['density']
+
+		out_dic[f'data_{_typ}'] = merge_data
+
+		den_lst.append(density)
+		times_lst.append(typ['times'])
+
+	out_rho = concat(den_lst, axis=1)
+	out_times = concat(times_lst, axis=1)
+	out_rho.columns = alg_type
+	out_times.columns = alg_type
+
+	# breakpoint()
+
+	## out
+	out_dic.update(dict(density=out_rho, times=out_times))
+
+	# out_dic = {
+	# 'data_cor_dndsdv' : merge_data,
+	# 'data_dn'     : merge_data_dn,
+	# 'data_dndsdv' : merge_data_dsdv,
+	# 'data_cor_dn' : merge_data_cor_dn,
+
+	# 'density' : out_rho,
+
+	# 'data_all_aer' : merge_data_aer,
+
+	# 'density_cor_dndsdv' : density,
+	# 'density_dn'   		 : density_dn,
+	# 'density_dndsdv'	 : density_dsdv,
+	# 'density_cor_dn'	 : density_cor_dn,
+	# }
+
+	## process data
+	for _nam, _df in out_dic.items():
+		out_dic[_nam] = _df.reindex(smps.index).copy()
+
+	return out_dic

AeroViz/dataProcess/SizeDistr/_size_distr.py

@@ -0,0 +1,93 @@
+__all__ = ['_basic']
+
+
+def _geometric_prop(_dp, _prop):
+	import numpy as n
+
+	_prop_t = _prop.sum(axis=1)
+	_prop_t = _prop_t.where(_prop_t > 0).copy()
+
+	_dp = n.log(_dp)
+	_gmd = (((_prop * _dp).sum(axis=1)) / _prop_t.copy())
+
+	_dp_mesh, _gmd_mesh = n.meshgrid(_dp, _gmd)
+	_gsd = ((((_dp_mesh - _gmd_mesh) ** 2) * _prop).sum(axis=1) / _prop_t.copy()) ** .5
+
+	return _prop_t, _gmd.apply(n.exp), _gsd.apply(n.exp)
+
+
+def _basic(df, hybrid, unit, bin_rg, input_type):
+	import numpy as n
+	from pandas import DataFrame, concat
+
+	## get number conc. data and total, mode
+	dN = df
+	dN.columns = dN.keys().to_numpy(float)
+
+	dN_ky = dN.keys()[(dN.keys() >= bin_rg[0]) & (dN.keys() <= bin_rg[-1])]
+	dN = dN[dN_ky].copy()
+
+	out_dic = {}
+	## diameter
+	dp = dN.keys().to_numpy()
+	if hybrid:
+		dlog_dp = n.diff(n.log10(dp)).mean()
+	else:
+		dlog_dp = n.ones(dp.size)
+		dlog_dp[:hybrid] = n.diff(n.log10(dp[:hybrid])).mean()
+		dlog_dp[hybrid:] = n.diff(n.log10(dp[hybrid:])).mean()
+
+	## calculate normalize and non-normalize data
+	if input_type == 'norm':
+		out_dic['number'] = (dN * dlog_dp).copy()
+		out_dic['number_norm'] = dN.copy()
+	else:
+		out_dic['number'] = dN.copy()
+		out_dic['number_norm'] = (dN / dlog_dp).copy()
+
+	out_dic['surface'] = out_dic['number'] * n.pi * dp ** 2
+	out_dic['volume'] = out_dic['number'] * n.pi * (dp ** 3) / 6
+
+	out_dic['surface_norm'] = out_dic['number_norm'] * n.pi * dp ** 2
+	out_dic['volume_norm'] = out_dic['number_norm'] * n.pi * (dp ** 3) / 6
+
+	## size range mode process
+	df_oth = DataFrame(index=dN.index)
+
+	bound = n.array([(dp.min(), dp.max() + 1), (10, 25), (25, 100), (100, 1e3), (1e3, 2.5e3), ])
+	if unit == 'um':
+		bound[1:] /= 1e3
+
+	for _tp_nam, _tp_dt in zip(['num', 'surf', 'vol'], [out_dic['number'], out_dic['surface'], out_dic['volume']]):
+
+		for _md_nam, _range in zip(['all', 'Nucleation', 'Aitken', 'Accumulation', 'Coarse'], bound):
+
+			_dia = dp[(dp >= _range[0]) & (dp < _range[-1])]
+			if ~_dia.any(): continue
+
+			_dt = _tp_dt[_dia].copy()
+
+			df_oth[f'total_{_tp_nam}_{_md_nam}'], df_oth[f'GMD_{_tp_nam}_{_md_nam}'], df_oth[
+				f'GSD_{_tp_nam}_{_md_nam}'] = _geometric_prop(_dia, _dt)
+			df_oth[f'mode_{_tp_nam}_{_md_nam}'] = _dt.idxmax(axis=1)
+
+	## out
+	out_dic['other'] = df_oth
+
+	return out_dic
+
+# old 20230113
+
+# _dN = out_dic['number'][_dia].copy()
+# df_oth[f'{_nam}_mode'] = _dN.idxmax(axis=1)
+# df_oth[f'{_nam}_TNC']  = _dN.sum(axis=1,min_count=1)
+
+## total, GMD and GSD
+# df_oth['total'], df_oth['GMD'], df_oth['GSD'] = _geometric_prop(dp,out_dic['number'])
+# df_oth['total_surf'], df_oth['GMD_surf'], df_oth['GSD_surf'] = _geometric_prop(dp,out_dic['surface'])
+# df_oth['total_volume'], df_oth['GMD_volume'], df_oth['GSD_volume'] = _geometric_prop(dp,out_dic['volume'])
+
+## mode
+# df_oth['mode']  	   = out_dic['number'].idxmax(axis=1)
+# df_oth['mode_surface'] = out_dic['surface'].idxmax(axis=1)
+# df_oth['mode_volume']  = out_dic['volume'].idxmax(axis=1)

AeroViz/dataProcess/VOC/__init__.py

@@ -0,0 +1,19 @@
+from ..core import _writter, _run_process
+
+__all__ = [
+
+	'VOC',
+
+]
+
+
+class VOC(_writter):
+
+	## Reconstruction
+	@_run_process('VOC - basic', 'voc_basic')
+	def VOC_basic(self, _df_voc):
+		from ._potential_par import _basic
+
+		out = _basic(_df_voc)
+
+		return self, out

AeroViz/dataProcess/VOC/_potential_par.py

@@ -0,0 +1,76 @@
+from datetime import datetime as dtm
+from pandas import DataFrame, to_datetime, read_json
+from pathlib import Path
+import pickle as pkl
+
+import numpy as np
+
+
+def _basic(_df_voc):
+	## parameter
+	_keys = _df_voc.keys()
+
+	with (Path(__file__).parent / 'voc_par.pkl').open('rb') as f:
+		_par = pkl.load(f)
+		_MW, _MIR, _SOAP, _KOH = _par.loc['MW', _keys], _par.loc['MIR', _keys], _par.loc['SOAP', _keys], _par.loc[
+			'KOH', _keys]
+
+	with (Path(__file__).parent / 'voc_par.json').open('r', encoding='utf-8', errors='ignore') as f:
+		_parr = read_json(f)
+		_MW, _MIR, _SOAP, _KOH = _par.loc['MW', _keys], _par.loc['MIR', _keys], _par.loc['SOAP', _keys], _par.loc[
+			'KOH', _keys]
+
+	_voc_clasfy = {
+		'alkane_total': ['Isopentane', 'n-Butane', '2-Methylhexane', 'Cyclopentane', '3-Methylpentane',
+						 '2,3-Dimethylbutane',
+						 '2-Methylheptane', 'n-Nonane', 'Methylcyclohexane', '2,4-Dimethylpentane', '2-Methylpentane',
+						 'n-Decane',
+						 'n-Heptane', 'Cyclohexane', 'n-Octane', 'Isobutane', '2,2-Dimethylbutane',
+						 'Methylcyclopentane', 'n-Hexane',
+						 '2,3,4-Trimethylpentane', '3-Methylhexane', 'n-Undecane', '3-Methylheptane', 'Hexane',
+						 '2,2,4-Trimethylpentane', 'n-Pentane', 'Ethane', 'Propane'],
+
+		'alkane_total': ['Isoprene', '1-Butene', 'cis-2-Butene', 'Propene', '1.3-Butadiene',
+						 't-2-Butene', 'cis-2-Pentene', 'Propylene', 'isoprene', '1-Pentene',
+						 'Ethylene', 't-2-Pentene', '1-Octene'],
+
+		'aromatic_total': ['o-Ethyltoluene', '1,3,5-Trimethylbenzene', 'Ethylbenzene', 'm,p-Xylene', 'n-Propylbenzene',
+						   'Benzene', 'Toluene', '1.2.4-TMB', 'Styrene', 'p-Ethyltoluene', 'o-Xylene',
+						   'm-Diethylbenzene',
+						   '1.2.3-TMB', 'Isopropylbenzene', 'm-Ethyltoluene', '2-Ethyltoluene', '1.3.5-TMB',
+						   'Iso-Propylbenzene',
+						   '3.4-Ethyltoluene', 'p-Diethylbenzene', '1,2,4-Trimethylbenzene', 'm.p-Xylene',
+						   '1,2,3-Trimethylbenzene'],
+
+		'alkyne_total': ['Acetylene'],
+
+		'OVOC': ['Acetaldehyde', 'Ethanol', 'Acetone', 'IPA', 'Ethyl Acetate', 'Butyl Acetate'],
+
+		'ClVOC': ['VCM', 'TCE', 'PCE', '1.4-DCB', '1.2-DCB'],
+	}
+
+	_df_MW = (_df_voc * _MW).copy()
+	_df_dic = {
+		'Conc': _df_voc.copy(),
+		'OFP': _df_MW / 48 * _MIR,
+		'SOAP': _df_MW / 24.5 * _SOAP / 100 * 0.054,
+		'LOH': _df_MW / 24.5 / _MW * 0.602 * _KOH,
+	}
+
+	## calculate
+	_out = {}
+	for _nam, _df in _df_dic.items():
+
+		_df_out = DataFrame(index=_df_voc.index)
+
+		for _voc_nam, _voc_lst in _voc_clasfy.items():
+			_lst = list(set(_keys) & set(_voc_lst))
+			if len(_lst) == 0: continue
+
+			_df_out[_voc_nam] = _df[_lst].sum(axis=1, min_count=1)
+
+		_df_out['Total'] = _df.sum(axis=1, min_count=1)
+
+		_out[_nam] = _df_out
+
+	return _out

AeroViz/dataProcess/__init__.py

@@ -0,0 +1,11 @@
+from .Chemistry import Chemistry
+from .Optical import Optical
+from .SizeDistr import SizeDistr
+from .VOC import VOC
+
+__all__ = [
+	'Optical',
+	'SizeDistr',
+	'Chemistry',
+	'VOC',
+]