AeroViz 0.1.21__py3-none-any.whl

AeroViz/dataProcess/SizeDistr/merge/README.md

@@ -0,0 +1,93 @@
+# SMPS-APS Merge Algorithms
+
+本資料夾包含 SMPS 與 APS 粒徑分布合併演算法的各版本實現。
+
+## 版本演進
+
+| 版本 | 檔案 | 主要特點 |
+|------|------|----------|
+| v0 | `_merge_v0.py` | 最原始版本，無 `union_index` 索引對齊 |
+| v0.1 | `_merge_v0_1.py` | 加入 `union_index` 索引對齊功能 |
+| v1 | `_merge_v1.py` | 加入 `shift_mode` 參數 (mobility/aerodynamic) |
+| v2 | `_merge_v2.py` | 簡化輸出，移除 qc_cond 過濾 |
+| v3 | `_merge_v3.py` | 加入 multiprocessing 平行運算 + dN/dS/dV 演算法 |
+| v4 | `_merge_v4.py` | 加入 PM2.5 fitness 函數 + SMPS times 校正 |
+
+## 版本詳細說明
+
+### v0 (原始版本)
+- 基本的 power law fitting 密度估算
+- 使用 UnivariateSpline 進行重疊區域平滑
+- rho 閾值: 0.3 < ρ² < 2.0
+- 輸出: `data_all`, `data_qc`, `density_all`, `density_qc`
+
+### v0.1
+- 加入 `union_index` 確保 SMPS 與 APS 時間索引對齊
+- 導出函數名稱改為 `merge_SMPS_APS`（無底線前綴）
+
+### v1
+- 加入 `shift_mode` 參數，支援：
+  - `'mobility'`: 移動 APS 粒徑到 mobility diameter
+  - `'aerodynamic'`: 移動 SMPS 粒徑到 aerodynamic diameter
+- rho 閾值放寬: 0.3 < ρ² < 2.6
+
+### v2
+- 移除 `shift_mode` 參數（固定使用 mobility）
+- 簡化輸出結構，移除 `_qc` 過濾版本
+- 加入 APS 校正迭代（2次）
+- 輸出: `data_all`, `data_all_aer`, `density_all`
+
+### v3
+- 引入 multiprocessing 平行運算加速
+- 新增 dN/dS/dV 相關性演算法 (`_corr_with_dNdSdV`)
+- 同時計算多種演算法結果：
+  - `dn`: 純 power law fitting
+  - `dndsdv`: dN/dS/dV 相關性
+  - `cor_dn`: APS 校正後的 power law
+  - `cor_dndsdv`: APS 校正後的 dN/dS/dV
+- 輸出: `data_dn`, `data_dndsdv`, `data_cor_dn`, `data_cor_dndsdv`, `density`
+
+### v4 (最新版本)
+- 加入 PM2.5 質量約束的 fitness 函數
+- 引入 SMPS times 校正因子（搜尋最佳倍率）
+- 參數 `times_range`: SMPS 數據乘數範圍 (預設 0.8~1.25)
+- 輸出新增 `times` 欄位記錄各時間點的最佳校正倍率
+
+## 使用方式
+
+```python
+from pathlib import Path
+from AeroViz.dataProcess import DataProcess
+
+dp = DataProcess('SizeDistr', Path('./output'))
+
+# v1 (基本版)
+result = dp.merge_SMPS_APS(df_smps, df_aps)
+
+# v2
+result = dp.merge_SMPS_APS_v2(df_smps, df_aps)
+
+# v3 (含 dN/dS/dV 演算法)
+result = dp.merge_SMPS_APS_v3(df_smps, df_aps, dndsdv_alg=True)
+
+# v4 (含 PM2.5 校正，推薦)
+result = dp.merge_SMPS_APS_v4(df_smps, df_aps, df_pm25)
+```
+
+## 演算法核心概念
+
+### Power Law Fitting
+利用 SMPS 上端粒徑的 power law 擬合（y = Ax^B），計算 APS 粒徑的位移因子（shift factor），用以估算有效密度。
+
+### Shift Factor
+位移因子的平方即為有效密度估計值：
+- ρ_eff = shift_factor²
+- 合理範圍: 0.6 ~ 2.6 g/cm³
+
+### dN/dS/dV 相關性
+v3+ 版本加入的演算法，同時考慮：
+- dN/dlogDp (數量分布)
+- dS/dlogDp (表面積分布)
+- dV/dlogDp (體積分布)
+
+通過最大化三者的相關性來決定最佳位移因子。

AeroViz/dataProcess/SizeDistr/merge/__init__.py

@@ -0,0 +1,20 @@
+"""
+SMPS-APS Merge Algorithms
+
+Version history:
+- v0: Original implementation
+- v0.1: Added union_index alignment
+- v1: Added shift_mode parameter
+- v2: Simplified output, removed qc filtering
+- v3: Multiprocessing + dN/dS/dV algorithm
+- v4: PM2.5 fitness + SMPS times correction
+"""
+
+from ._merge_v0 import _merge_SMPS_APS as merge_v0
+from ._merge_v0_1 import merge_SMPS_APS as merge_v0_1
+from ._merge_v1 import _merge_SMPS_APS as merge_v1
+from ._merge_v2 import merge_SMPS_APS as merge_v2
+from ._merge_v3 import merge_SMPS_APS as merge_v3
+from ._merge_v4 import merge_SMPS_APS as merge_v4
+
+__all__ = ['merge_v0', 'merge_v0_1', 'merge_v1', 'merge_v2', 'merge_v3', 'merge_v4']

AeroViz/dataProcess/SizeDistr/merge/_merge_v0.py

@@ -0,0 +1,251 @@
+from datetime import datetime as dtm
+
+import numpy as np
+from pandas import DataFrame, to_datetime
+# from scipy.interpolate import interp1d
+from scipy.interpolate import UnivariateSpline as unvpline, interp1d
+
+__all__ = ['_merge_SMPS_APS']
+
+
+def __test_plot(smpsx, smps, apsx, aps, mergex, merge, mergeox, mergeo, _sh):
+    from matplotlib.pyplot import subplots, close, show
+
+    ## 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

AeroViz/dataProcess/SizeDistr/merge/_merge_v0_1.py

@@ -0,0 +1,246 @@
+from datetime import datetime as dtm
+
+import numpy as np
+from pandas import DataFrame, to_datetime
+# from scipy.interpolate import interp1d
+from scipy.interpolate import UnivariateSpline as unvpline, interp1d
+
+from AeroViz.dataProcess.core import union_index
+
+__all__ = ['merge_SMPS_APS']
+
+
+def __test_plot(smpsx, smps, apsx, aps, mergex, merge, mergeox, mergeo, _sh):
+    from matplotlib.pyplot import subplots, close, show
+
+    ## 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, _smps_lb, _aps_hb, _coe, _shift_mode):
+    print(f"\t\t{dtm.now().strftime('%m/%d %X')} : \033[92mcreate merge data : {_shift_mode}\033[0m")
+
+    _ori_idx = _smps_ori.index
+    _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]
+
+    _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)
+
+    _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 merge_SMPS_APS(df_smps, df_aps, aps_unit='um', smps_overlap_lowbound=500, aps_fit_highbound=1000):
+    df_smps, df_aps = union_index(df_smps, df_aps)
+
+    ## set to the same units
+    smps, aps_ori = df_smps.copy(), df_aps.copy()
+    smps.columns = smps.keys().to_numpy(float)
+    aps_ori.columns = aps_ori.keys().to_numpy(float)
+
+    if aps_unit == 'um':
+        aps_ori.columns = aps_ori.keys() * 1e3
+
+    den_lst, mer_lst = [], []
+    aps_input = aps_ori.loc[:, aps_ori.keys() > 700].copy()
+
+    for _count in range(2):
+
+        ## shift infomation, calculate by powerlaw fitting
+        shift, coe = _overlap_fitting(smps, aps_input, 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_arg = (smps, aps_ori, shift, smps_overlap_lowbound, aps_fit_highbound, coe)
+        merge_data_mob, density, _corr = _merge_data(*merge_arg, 'mobility')
+        merge_data_aer, density, _ = _merge_data(*merge_arg, 'aerodynamic')
+        density.columns = ['density']
+
+        if _count == 0:
+            corr = _corr.resample('1d').mean().reindex(smps.index).ffill()
+            corr = corr.mask(corr < 1, 1)
+            aps_ori.loc[:, corr.keys()] *= corr
+
+            aps_input = aps_ori.copy()
+
+    ## out
+    out_dic = {
+        'data_all': merge_data_mob,
+        'data_qc': merge_data_mob.loc[qc_cond],
+        'data_all_aer': merge_data_aer,
+        'data_qc_aer': merge_data_aer.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(smps.index).copy()
+
+    return out_dic