AeroViz 0.1.0__py3-none-any.whl

AeroViz/dataProcess/Optical/__init__.py

@@ -0,0 +1,62 @@
+from ..core import _writter, _run_process
+
+__all__ = [
+
+	'Optical',
+
+]
+
+
+class Optical(_writter):
+
+	## scatter
+	@_run_process('Optical - SAE', 'SAE')
+	def SAE(self, df_sca):
+		from ._scattering import _SAE
+
+		out = _SAE(df_sca)
+
+		return self, out
+
+	## absorption
+	@_run_process('Optical - absCoe', 'absCoe')
+	def absCoe(self, df_ae33, abs_band=[550]):
+		from ._absorption import _absCoe
+
+		out = _absCoe(df_ae33, abs_band)
+
+		return self, out
+
+	@_run_process('Optical - AAE', 'AAE')
+	def AAE(self, df_abs):
+		from ._absorption import _AAE
+
+		out = _AAE(df_abs)
+
+		return self, out
+
+	## extinction
+	@_run_process('Optical - basic', 'opt_basic')
+	def basic(self, df_abs, df_sca, df_ec=None, df_mass=None, df_no2=None):
+		from ._extinction import _basic
+
+		out = _basic(df_abs, df_sca, df_ec, df_mass, df_no2)
+
+		return self, out
+
+	@_run_process('Optical - Mie', 'Mie')
+	def Mie(self, df_psd, df_m, wave_length=550):
+		from ._mie import _mie
+
+		out = _mie(df_psd, df_m, wave_length)
+
+		return self, out
+
+	@_run_process('Optical - IMPROVE', 'IMPROVE')
+	def IMPROVE(self, df_mass, df_RH, method='revised'):
+		# _fc = __import__(f'_IMPROVE._{method}')
+		from ._IMPROVE import _revised
+
+		out = _revised(df_mass, df_RH)
+
+		return self, out

AeroViz/dataProcess/Optical/_absorption.py

@@ -0,0 +1,54 @@
+def _absCoe(df, abs_band):
+	import numpy as n
+	from scipy.optimize import curve_fit
+
+	band = n.array([370, 470, 520, 590, 660, 880, 950])
+
+	df_out = {}
+
+	def _get_slope(__df):
+		func = lambda _x, _sl, _int: _sl * _x + _int
+		popt, pcov = curve_fit(func, band, __df.values)
+
+		return func(n.array(abs_band), *popt)
+
+	MAE = n.array([18.47, 14.54, 13.14, 11.58, 10.35, 7.77, 7.19]) * 1e-3
+	df_abs = (df.copy() * MAE).dropna().copy()
+
+	df_out = df_abs.apply(_get_slope, axis=1, result_type='expand').reindex(df.index)
+	df_out.columns = [f'abs_{_band}' for _band in abs_band]
+
+	df_out['eBC'] = df['BC6']
+
+	return df_out
+
+
+def _AAE(df):
+	import numpy as n
+	from scipy.optimize import curve_fit
+
+	def _AAEcalc(_df):
+		## parameter
+		MAE = n.array([18.47, 14.54, 13.14, 11.58, 10.35, 7.77, 7.19]) * 1e-3
+		band = n.array([370, 470, 520, 590, 660, 880, 950])
+		_df *= MAE
+
+		## 7 pts fitting
+		## function
+		def _get_slope(__df):
+			func = lambda _x, _sl, _int: _sl * _x + _int
+			popt, pcov = curve_fit(func, n.log(band), n.log(__df))
+
+			return popt
+
+		## calculate
+		_AAE = _df.apply(_get_slope, axis=1, result_type='expand')
+		_AAE.columns = ['slope', 'intercept']
+
+		return _AAE
+
+	df_out = _AAEcalc(df[['BC1', 'BC2', 'BC3', 'BC4', 'BC5', 'BC6', 'BC7']].dropna())
+	df_out = df_out.mask((-df_out.slope < 0.8) | (-df_out.slope > 2.)).copy()
+
+	df_out['eBC'] = df['BC6']
+	return df_out.reindex(df.index)

AeroViz/dataProcess/Optical/_extinction.py

@@ -0,0 +1,36 @@
+from AeroViz.dataProcess.core import _union_index
+from pandas import DataFrame
+
+
+def _basic(df_abs, df_sca, df_ec, df_mass, df_no2):
+	df_abs, df_sca, df_ec, df_mass, df_no2 = _union_index(df_abs, df_sca, df_ec, df_mass, df_no2)
+
+	df_out = DataFrame()
+
+	## abs and sca coe
+	df_out['abs'] = df_abs.copy()
+	df_out['sca'] = df_sca.copy()
+
+	## extinction coe.
+	df_out['ext'] = df_out['abs'] + df_out['sca']
+
+	## SSA
+	df_out['SSA'] = df_out['sca'] / df_out['ext']
+
+	## MAE, MSE, MEE
+	if df_mass is not None:
+		df_out['MAE'] = df_out['abs'] / df_mass
+		df_out['MSE'] = df_out['sca'] / df_mass
+		df_out['MEE'] = df_out['MSE'] + df_out['MAE']
+
+	## gas absorbtion
+	if df_no2 is not None:
+		df_out['abs_gas'] = df_no2 * .33
+		df_out['sca_gas'] = 10
+		df_out['ext_all'] = df_out['ext'] + df_out['abs_gas'] + df_out['sca_gas']
+
+	## other
+	if df_ec is not None:
+		df_out['eBC'] = df_ec / 1e3
+
+	return df_out

AeroViz/dataProcess/Optical/_mie.py

@@ -0,0 +1,16 @@
+# from PyMieScatt import Mie_SD
+# from PyMieScatt import Mie_SD
+
+from ._mie_sd import Mie_SD
+from pandas import date_range, concat, DataFrame, to_numeric
+
+
+def _mie(_psd_ori, _RI_ori, _wave):
+	_ori_idx = _psd_ori.index.copy()
+	_cal_idx = _psd_ori.loc[_RI_ori.dropna().index].dropna(how='all').index
+
+	_psd, _RI = _psd_ori.loc[_cal_idx], _RI_ori.loc[_cal_idx]
+
+	_out = Mie_SD(_RI.values, 550, _psd)
+
+	return _out.reindex(_ori_idx)

AeroViz/dataProcess/Optical/_mie_sd.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+# http://pymiescatt.readthedocs.io/en/latest/forward.html
+import numpy as np
+from scipy.integrate import trapezoid
+from scipy.special import jv, yv
+import warnings
+from pandas import date_range, concat, DataFrame, to_numeric, to_datetime, Series
+
+
+def coerceDType(d):
+	if type(d) is not np.ndarray:
+		return np.array(d)
+	else:
+		return d
+
+
+def Mie_ab(m, x, nmax, df_n):
+	nu = df_n.copy() + 0.5
+	n1 = 2 * df_n.copy() + 1
+
+	sx = np.sqrt(0.5 * np.pi * x)
+	px = sx.reshape(-1, 1) * jv(nu, x.reshape(-1, 1))
+	chx = -sx.reshape(-1, 1) * yv(nu, x.reshape(-1, 1))
+
+	p1x = concat([DataFrame(np.sin(x)), px.mask(df_n == nmax.reshape(-1, 1))], axis=1)
+	p1x.columns = np.arange(len(p1x.keys()))
+	p1x = p1x[df_n.keys()]
+
+	ch1x = concat([DataFrame(np.cos(x)), chx.mask(df_n == nmax.reshape(-1, 1))], axis=1)
+	ch1x.columns = np.arange(len(ch1x.keys()))
+	ch1x = ch1x[df_n.keys()]
+
+	gsx = px - (0 + 1j) * chx
+	gs1x = p1x - (0 + 1j) * ch1x
+
+	mx = m.reshape(-1, 1) * x
+	nmx = np.round(np.max(np.hstack([[nmax] * m.size, np.abs(mx)]).reshape(m.size, 2, -1), axis=1) + 16)
+
+	df_qext = DataFrame(columns=m, index=df_n.index)
+	df_qsca = DataFrame(columns=m, index=df_n.index)
+
+	df_n /= x.reshape(-1, 1)
+	for _bin_idx, (_nmx_ary, _mx, _nmax) in enumerate(zip(nmx.T, mx.T, nmax)):
+
+		df_D = DataFrame(np.nan, index=np.arange(m.size), columns=df_n.keys())
+
+		Dn_lst = []
+		for _nmx, _uni_idx in DataFrame(_nmx_ary).groupby(0).groups.items():
+
+			_inv_mx = 1 / _mx[_uni_idx]
+
+			Dn = np.zeros((_uni_idx.size, int(_nmx)), dtype=complex)
+			for _idx in range(int(_nmx) - 1, 1, -1):
+				Dn[:, _idx - 1] = (_idx * _inv_mx) - (1 / (Dn[:, _idx] + _idx * _inv_mx))
+
+			Dn_lst.append(Dn[:, 1: int(_nmax) + 1])
+			df_D.loc[_uni_idx, 0: int(_nmax) - 1] = Dn[:, 1: int(_nmax) + 1]
+
+		## other parameter
+		_df_n, _px, _p1x, _gsx, _gs1x, _n1 = df_n.loc[_bin_idx], px.loc[_bin_idx], p1x.loc[_bin_idx], gsx.loc[_bin_idx], \
+			gs1x.loc[_bin_idx], n1.loc[_bin_idx].values
+
+		_da = df_D / m.reshape(-1, 1) + _df_n
+		_db = df_D * m.reshape(-1, 1) + _df_n
+
+		_an = (_da * _px - _p1x) / (_da * _gsx - _gs1x)
+		_bn = (_db * _px - _p1x) / (_db * _gsx - _gs1x)
+
+		_real_an, _real_bn = np.real(_an), np.real(_bn)
+		_imag_an, _imag_bn = np.imag(_an), np.imag(_bn)
+
+		_pr_qext = np.nansum(_n1 * (_real_an + _real_bn), axis=1)
+		_pr_qsca = np.nansum(_n1 * (_real_an ** 2 + _real_bn ** 2 + _imag_an ** 2 + _imag_bn ** 2), axis=1)
+
+		df_qext.loc[_bin_idx] = _pr_qext
+		df_qsca.loc[_bin_idx] = _pr_qsca
+
+	return df_qext, df_qsca
+
+
+def MieQ(m_ary, wavelength, diameter):
+	#  http://pymiescatt.readthedocs.io/en/latest/forward.html#MieQ
+
+	x = np.pi * diameter / wavelength
+
+	nmax = np.round(2 + x + 4 * (x ** (1 / 3)))
+
+	df_n = DataFrame([np.arange(1, nmax.max() + 1)] * nmax.size)
+	df_n = df_n.mask(df_n > nmax.reshape(-1, 1))
+
+	n1 = 2 * df_n + 1
+	n2 = df_n * (df_n + 2) / (df_n + 1)
+	n3 = n1 / (df_n * (df_n + 1))
+	x2 = x ** 2
+
+	_qext, _qsca = Mie_ab(m_ary, x, nmax, df_n)
+
+	qext = (2 / x2).reshape(-1, 1) * _qext
+	qsca = (2 / x2).reshape(-1, 1) * _qsca
+
+	# return qext.astype(float).values.T, qsca.astype(float).values.T,
+	return qext.values.T.astype(float), qsca.values.T.astype(float)
+
+
+def Mie_SD(m_ary, wavelength, psd, multp_m_in1psd=False, dt_chunk_size=10, q_table=False):
+	m_ary = coerceDType(m_ary)
+	if type(psd) is not DataFrame:
+		psd = DataFrame(psd).T
+
+	if (len(m_ary) != len(psd)) & ~multp_m_in1psd:
+		raise ValueError('"m array" size should be same as "psd" size')
+
+	dp = psd.keys().values
+	ndp = psd.values
+	aSDn = np.pi * ((dp / 2) ** 2) * ndp * 1e-6
+
+	if q_table:
+		qext, qsca = q_table
+	else:
+		qext, qsca = MieQ(m_ary, wavelength, dp)
+
+	if multp_m_in1psd:
+		# print('\tcalculate ext')
+
+		aSDn_all = np.repeat(aSDn, m_ary.size, axis=0).reshape(len(aSDn), m_ary.size, -1)
+
+		qext_all = np.repeat(qext[np.newaxis, :, :], len(aSDn), axis=0).reshape(*aSDn_all.shape)
+		qsca_all = np.repeat(qsca[np.newaxis, :, :], len(aSDn), axis=0).reshape(*aSDn_all.shape)
+
+		df_ext = DataFrame(trapezoid(aSDn_all * qext_all), columns=m_ary, index=psd.index).astype(float)
+		df_sca = DataFrame(trapezoid(aSDn_all * qsca_all), columns=m_ary, index=psd.index).astype(float)
+		df_abs = df_ext - df_sca
+		# print('\tdone')
+
+		return dict(ext=df_ext, sca=df_sca, abs=df_abs)
+
+	else:
+		df_out = DataFrame(index=psd.index)
+		df_out['ext'] = trapezoid(qext * aSDn).astype(float)
+		df_out['sca'] = trapezoid(qsca * aSDn).astype(float)
+		df_out['abs'] = df_out['ext'] - df_out['sca']
+
+		return df_out

AeroViz/dataProcess/Optical/_scattering.py

@@ -0,0 +1,30 @@
+import numpy as np
+from scipy.optimize import curve_fit
+
+__all__ = [
+	'_SAE',
+]
+
+
+def _SAE(df):
+	def _SAEcalc(_df):
+		## parameter
+		band = np.array([450, 550, 700]) * 1e-3
+
+		## 3 pts fitting
+		## function
+		def _get_slope(__df):
+			func = lambda _x, _sl, _int: _sl * _x + _int
+			popt, pcov = curve_fit(func, np.log(band), np.log(__df))
+
+			return popt
+
+		## calculate
+		_SAE = _df.apply(_get_slope, axis=1, result_type='expand')
+		_SAE.columns = ['slope', 'intercept']
+
+		return _SAE
+
+	df_out = _SAEcalc(df[['B', 'G', 'R']].dropna())
+
+	return df_out.reindex(df.index)

AeroViz/dataProcess/SizeDistr/__init__.py

@@ -0,0 +1,61 @@
+from ..core import _writter, _run_process
+
+__all__ = [
+
+	'SizeDistr',
+
+]
+
+
+class SizeDistr(_writter):
+
+	## basic
+	@_run_process('SizeDistr - basic', 'distr_basic')
+	def basic(self, df, hybrid_bin_start_loc=None, unit='nm', bin_range=(0, 20000), input_type='norm'):
+		from ._size_distr import _basic
+
+		out = _basic(df, hybrid_bin_start_loc, unit, bin_range, input_type)
+
+		return self, out
+
+	## merge
+	@_run_process('SizeDistr - merge_SMPS_APS_v4', 'distr_merge')
+	def merge_SMPS_APS_v4(self, 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)):
+		from ._merge_v4 import merge_SMPS_APS
+
+		out = merge_SMPS_APS(df_smps, df_aps, df_pm25, aps_unit, smps_overlap_lowbound, aps_fit_highbound, dndsdv_alg,
+							 times_range)
+
+		return self, out
+
+	## merge
+	@_run_process('SizeDistr - merge_SMPS_APS_v3', 'distr_merge')
+	def merge_SMPS_APS_v3(self, df_smps, df_aps, aps_unit='um',
+						  smps_overlap_lowbound=500, aps_fit_highbound=1000, dndsdv_alg=True):
+		from ._merge_v3 import merge_SMPS_APS
+
+		out = merge_SMPS_APS(df_smps, df_aps, aps_unit, smps_overlap_lowbound, aps_fit_highbound, dndsdv_alg)
+
+		return self, out
+
+	## merge
+	@_run_process('SizeDistr - merge_SMPS_APS_v2', 'distr_merge')
+	def merge_SMPS_APS_v2(self, df_smps, df_aps, aps_unit='um',
+						  smps_overlap_lowbound=500, aps_fit_highbound=1000):
+		from ._merge_v2 import merge_SMPS_APS
+
+		out = merge_SMPS_APS(df_smps, df_aps, aps_unit, smps_overlap_lowbound, aps_fit_highbound)
+
+		return self, out
+
+	## merge
+	@_run_process('SizeDistr - merge_SMPS_APS_v1', 'distr_merge')
+	def merge_SMPS_APS(self, df_smps, df_aps, aps_unit='um', shift_mode='mobility',
+					   smps_overlap_lowbound=523, aps_fit_highbound=800):
+		from ._merge_v1 import _merge_SMPS_APS
+
+		out = _merge_SMPS_APS(df_smps, df_aps, aps_unit, shift_mode, smps_overlap_lowbound, aps_fit_highbound)
+
+		return self, out

AeroViz/dataProcess/SizeDistr/__merge.py

@@ -0,0 +1,250 @@
+from datetime import datetime as dtm
+from pandas import DataFrame, to_datetime
+# from scipy.interpolate import interp1d
+from scipy.interpolate import UnivariateSpline as unvpline, interp1d
+import numpy as np
+
+__all__ = ['_merge_SMPS_APS']
+
+
+def __test_plot(smpsx, smps, apsx, aps, mergex, merge, mergeox, mergeo, _sh):
+	from matplotlib.pyplot import subplots, close, show, rcParams
+
+	## parameter
+	# '''
+	## plot
+	fig, ax = subplots()
+
+	ax.plot(smpsx, smps, c='#ff794c', label='smps', marker='o', lw=2)
+	ax.plot(apsx, aps, c='#4c79ff', label='aps', marker='o', lw=2)
+	ax.plot(mergex, merge, c='#79796a', label='merge')
+	# ax.plot(mergeox,mergeo,c='#111111',label='mergeo',marker='o',lw=.75)
+
+	ax.set(xscale='log', yscale='log', )
+
+	ax.legend(framealpha=0, )
+	ax.set_title((_sh ** 2)[0], fontsize=13)
+
+	show()
+	close()
+
+
+# '''
+
+
+## Overlap fitting
+## Create a fitting func. by smps data
+## return : shift factor
+def _overlap_fitting(_smps_ori, _aps_ori, _smps_lb, _aps_hb):
+	print(f"\t\t{dtm.now().strftime('%m/%d %X')} : \033[92moverlap range fitting\033[0m")
+
+	## overlap fitting
+	## parmeter
+	_dt_indx = _smps_ori.index
+
+	## overlap diameter data
+	_aps = _aps_ori[_aps_ori.keys()[_aps_ori.keys() < _aps_hb]].copy()
+	_smps = _smps_ori[_smps_ori.keys()[_smps_ori.keys() > _smps_lb]].copy()
+
+	## 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 cklosest to 1
+	_shift_factor = (_aps_shift_x.keys()._data.astype(float) / _aps_shift_x)
+	_shift_factor.columns = range(len(_aps_shift_x.keys()))
+
+	_dropna_idx = _shift_factor.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)
+	for _idx, _factor in _shift_factor.items():
+		_smps_fit_df = _coeA * (_dia_table / _factor.to_frame().values) ** _coeB
+		_S2[_idx] = ((_smps_fit_df - _aps) ** 2).sum(axis=1)
+
+	_least_squ_idx = _S2.idxmin(axis=1).loc[_dropna_idx]
+
+	_shift_factor_out = DataFrame(_shift_factor.loc[_dropna_idx].values[range(len(_dropna_idx)), _least_squ_idx.values],
+								  index=_dropna_idx).reindex(_dt_indx)
+
+	return _shift_factor_out, (DataFrame(_coeA, index=_dt_indx), DataFrame(_coeB, index=_dt_indx))
+
+
+## Remove big shift data ()
+## Return : aps, smps, shift (without big shift data)
+def _shift_data_process(_shift):
+	print(f"\t\t{dtm.now().strftime('%m/%d %X')} : \033[92mshift-data quality control\033[0m")
+
+	_rho = _shift ** 2
+	_shift = _shift.mask((~np.isfinite(_shift)) | (_rho > 2) | (_rho < 0.3))
+
+	_qc_index = _shift.mask((_rho < 0.6) | (_shift.isna())).dropna().index
+
+	return _qc_index, _shift
+
+
+# return _smps.loc[~_big_shift], _aps.loc[~_big_shift], _shift[~_big_shift].reshape(-1,1)
+
+
+## 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, _shift_mode, _smps_lb, _aps_hb, _coe):
+	print(f"\t\t{dtm.now().strftime('%m/%d %X')} : \033[92mcreate merge data\033[0m")
+
+	_ori_idx = _smps_ori.index
+	_merge_idx = _smps_ori.loc[_aps_ori.dropna(how='all').index].dropna(how='all').index
+
+	_uni_idx, _count = np.unique(np.hstack((_smps_ori.dropna(how='all').index, _aps_ori.dropna(how='all').index,
+											_shift_ori.dropna(how='all').index)), return_counts=True)
+
+	_merge_idx = to_datetime(np.unique(_uni_idx[_count == 3]))
+
+	_smps, _aps, _shift = _smps_ori.loc[_merge_idx], _aps_ori.loc[_merge_idx], _shift_ori.loc[_merge_idx].values
+
+	## parameter
+	_coeA, _coeB = _coe[0].loc[_merge_idx], _coe[1].loc[_merge_idx]
+	_smps_key, _aps_key = _smps.keys()._data.astype(float), _aps.keys()._data.astype(float)
+
+	_test = 1000
+
+	# _cntr = (_smps_lb+_aps_hb)/2
+	_cntr = _test
+	_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  = _smps_key.tolist()+_aps_key[_aps_key>_smps_key[-1]].tolist()
+	_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 = []
+	for _bin_smps, _bin_aps, _dt_smps, _dt_aps, _sh in zip(_smps_bin, _aps_bin, _smps.values, _aps.values, _shift):
+		## remove
+
+		## 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<_aps_hb)&(_merge_bin>_smps_lb)
+		_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)
+		# _unvpl_fc = unvpline(_merge_bin[_merge_fit_loc],_merge_dt[_merge_fit_loc],s=150)
+		# _inte_log_fc = interp1d(n.log10(_merge_bin[_merge_fit_loc]),n.log10(_merge_dt[_merge_fit_loc]),
+		# kind='linear',fill_value='extrapolate')
+		_inte_fc = interp1d(_merge_bin, _merge_dt, kind='linear', fill_value='extrapolate')
+
+		__merge = np.exp(_unvpl_fc(np.log(_std_bin_merge)))
+		# __merge = _unvpl_fc(_std_bin_merge)
+
+		_merge_dt_fit = np.hstack((_inte_fc(_std_bin_inte1), __merge, _inte_fc(_std_bin_inte2)))
+		# _merge_dt_fit = __merge
+		# __test_plot(_bin_smps,_dt_smps,_bin_aps,_dt_aps,_std_bin,_merge_dt_fit,_merge_bin,_merge_dt,_sh)
+
+		_merge_lst.append(_merge_dt_fit)
+
+	_df_merge = DataFrame(_merge_lst, columns=_std_bin, index=_merge_idx)
+	_df_merge = _df_merge.mask(_df_merge < 0)
+
+	## 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)
+
+
+## aps_fit_highbound : the diameter I choose randomly
+def _merge_SMPS_APS(df_smps, df_aps, aps_unit, shift_mode, smps_overlap_lowbound, aps_fit_highbound):
+	# print(f'\nMerge data :')
+	# print(f' APS fittint higher diameter : {aps_fit_highbound:4d} nm')
+	# print(f' SMPS overlap lower diameter : {smps_overlap_lowbound:4d} nm')
+	# print(f' Average time                : {self.data_freq:>4s}\n')
+
+	## get data, remove 'total' and 'mode'
+	## set to the same units
+	smps, aps = df_smps, df_aps
+	smps.columns = smps.keys().to_numpy(float)
+	aps.columns = aps.keys().to_numpy(float)
+
+	if aps_unit == 'um':
+		aps.columns = aps.keys() * 1e3
+
+	## shift infomation, calculate by powerlaw fitting
+	shift, coe = _overlap_fitting(smps, aps, smps_overlap_lowbound, aps_fit_highbound)
+
+	## process data by shift infomation, and average data
+	qc_cond, shift = _shift_data_process(shift)
+
+	## merge aps and smps..
+	merge_data, density = _merge_data(smps, aps, shift, shift_mode, smps_overlap_lowbound, aps_fit_highbound, coe)
+	density.columns = ['density']
+
+	## add total and mode
+	# merge_total = merge_data.sum(axis=1,min_count=1).copy()
+	# merge_mode  = merge_data.idxmax(axis=1).astype(float).copy()
+
+	# merge_data['total'] = merge_total
+	# merge_data['mode']  = merge_mode
+
+	## out
+	out_dic = {
+		'data_all': merge_data,
+		'data_qc': merge_data.loc[qc_cond],
+		'density_all': density,
+		'density_qc': density.loc[qc_cond],
+	}
+
+	## process data
+
+	for _nam, _df in out_dic.items():
+		out_dic[_nam] = _df.reindex(df_aps.index).copy()
+
+	# merge_data = merge_data.reindex(df_aps.index)
+	# density	   = density.reindex(df_aps.index)
+
+	return out_dic