AeroViz 0.1.2__py3-none-any.whl → 0.1.3b0__py3-none-any.whl

AeroViz/dataProcess/Chemistry/_ocec.py

@@ -1,161 +1,161 @@
-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
+from pandas import concat, DataFrame
+from scipy.optimize import curve_fit
+
+from AeroViz.dataProcess.core import _union_index
 
 __all__ = [
-	'_basic',
-	# '_ocec_ratio_cal',
+    '_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)
+    _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)
+    _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()
+    ## 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)
+        _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.)
+        _tss = np.sum((_y - _y.mean()) ** 2.)
+        _rss = np.sum((_y - _func(_x, *_opt)) ** 2.)
 
-		_r2_dic[round(_ocec, 3)] = 1. - _rss / _tss
+        _r2_dic[round(_ocec, 3)] = 1. - _rss / _tss
 
-	## get the min R2
-	_ratio = DataFrame(_r2_dic, index=[0]).idxmin(axis=1).values[0]
+    ## get the min R2
+    _ratio = DataFrame(_r2_dic, index=[0]).idxmin(axis=1).values[0]
 
-	return _ratio, _out_table[_ratio]
+    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']
+    ## 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)
+    ## 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}']
+    _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 !!')
+    ## 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
+        _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
+        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
+    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
+        return _out
 
-	## OC/EC
-	_ocec_ratio = False
-	_st, _ed, _stp = _range_
+    ## 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)
+    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)
+        _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)
+    ## 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}']
+    ## 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}']]
+    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)
+    _lcres, _res, _mass = _union_index(_lcres, _res, _mass)
 
-	_out = {}
+    _out = {}
 
-	## OC1, OC2, OC3, OC4, PC
-	_df_bsc = _res / _lcres['Sample_Volume'].to_frame().values.copy()
+    ## 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 !!')
+    ## 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']
+        _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))
+    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)
+        _prcs_df = concat(_df_lst)
 
-	_df_bsc = concat((_df_bsc.copy(), _prcs_df), axis=1)
+    _df_bsc = concat((_df_bsc.copy(), _prcs_df), axis=1)
 
-	## ratio
-	_df_ratio = DataFrame(index=_df_bsc.index)
+    ## 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']
+    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
+    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'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
+        _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)
+    ## 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')
+    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
+    ## out
+    _out['ratio'] = _df_ratio
+    _out['basic'] = _df_bsc
 
-	return _out
+    return _out
 
 
 '''

AeroViz/dataProcess/Chemistry/_partition.py

@@ -1,29 +1,30 @@
-from pandas import date_range, concat, DataFrame, to_numeric
+from pandas import concat, DataFrame
+
 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
+    # parameter
+    df_all = concat(df_che, axis=1)
+    index = df_all.index.copy()
+    df_all.columns = nam_lst
 
-	df_umol = _ug2umol(df_all)
+    df_umol = _ug2umol(df_all)
 
-	# calculate
-	df_out = DataFrame(index=df_umol.index)
+    # 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['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['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['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'])
+    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
+    return df_out

AeroViz/dataProcess/Chemistry/_teom.py

@@ -1,16 +1,13 @@
-import numpy as np
-
-
 def _basic(_teom, _check):
-	_teom['Volatile_Fraction'] = (_teom['PM_Total'] - _teom['PM_NV']) / _teom['PM_Total']
+    _teom['Volatile_Fraction'] = (_teom['PM_Total'] - _teom['PM_NV']) / _teom['PM_Total']
 
-	_teom.loc[(_teom['Volatile_Fraction'] < 0) | (_teom['Volatile_Fraction'] > 1)] = n.nan
+    _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
+    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'
+        _teom.loc[_teom.dropna().index, 'status'] = 'Warning'
+        _teom.loc[(_ratio > 0) & (_ratio < 1), 'status'] = 'Normal'
 
-	return _teom
+    return _teom

AeroViz/dataProcess/Optical/_IMPROVE.py

@@ -1,61 +1,62 @@
 import pickle as pkl
 from pathlib import Path
+
 import numpy as np
+from pandas import DataFrame
 
-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)
+    _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
+    ## 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
+    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
+        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()
+    ## 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']]
+    _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):
+    ## apply IMPROVE ccoe.
+    def _ext_cal(_RH=None):
 
-		_frh, _frhss, _frhs, _frhl = fRH(_RH)
-		_df = DataFrame(index=_df_mass.index)
+        _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['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)
+        _df['total'] = _df.sum(axis=1)
 
-		return _df.dropna().reindex(_df_mass.index)
+        return _df.dropna().reindex(_df_mass.index)
 
-	## calculate
-	_out = {}
+    ## calculate
+    _out = {}
 
-	_out['dry'] = _ext_cal()
+    _out['dry'] = _ext_cal()
 
-	if _df_RH is not None:
-		_out['wet'] = _ext_cal(_df_RH)
+    if _df_RH is not None:
+        _out['wet'] = _ext_cal(_df_RH)
 
-	return _out
+    return _out

AeroViz/dataProcess/Optical/__init__.py

@@ -2,61 +2,61 @@ from ..core import _writter, _run_process
 
 __all__ = [
 
-	'Optical',
+    'Optical',
 
 ]
 
 
 class Optical(_writter):
 
-	## scatter
-	@_run_process('Optical - SAE', 'SAE')
-	def SAE(self, df_sca):
-		from ._scattering import _SAE
+    ## scatter
+    @_run_process('Optical - SAE', 'SAE')
+    def SAE(self, df_sca):
+        from ._scattering import _SAE
 
-		out = _SAE(df_sca)
+        out = _SAE(df_sca)
 
-		return self, out
+        return self, out
 
-	## absorption
-	@_run_process('Optical - absCoe', 'absCoe')
-	def absCoe(self, df_ae33, abs_band=[550]):
-		from ._absorption import _absCoe
+    ## absorption
+    @_run_process('Optical - absCoe', 'absCoe')
+    def absCoe(self, df_ae33, abs_band=[550]):
+        from ._absorption import _absCoe
 
-		out = _absCoe(df_ae33, abs_band)
+        out = _absCoe(df_ae33, abs_band)
 
-		return self, out
+        return self, out
 
-	@_run_process('Optical - AAE', 'AAE')
-	def AAE(self, df_abs):
-		from ._absorption import _AAE
+    @_run_process('Optical - AAE', 'AAE')
+    def AAE(self, df_abs):
+        from ._absorption import _AAE
 
-		out = _AAE(df_abs)
+        out = _AAE(df_abs)
 
-		return self, out
+        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
+    ## 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)
+        out = _basic(df_abs, df_sca, df_ec, df_mass, df_no2)
 
-		return self, out
+        return self, out
 
-	@_run_process('Optical - Mie', 'Mie')
-	def Mie(self, df_psd, df_m, wave_length=550):
-		from ._mie import _mie
+    @_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)
+        out = _mie(df_psd, df_m, wave_length)
 
-		return self, out
+        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
+    @_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)
+        out = _revised(df_mass, df_RH)
 
-		return self, out
+        return self, out

AeroViz/dataProcess/Optical/_absorption.py

@@ -1,54 +1,54 @@
 def _absCoe(df, abs_band):
-	import numpy as n
-	from scipy.optimize import curve_fit
+    import numpy as n
+    from scipy.optimize import curve_fit
 
-	band = n.array([370, 470, 520, 590, 660, 880, 950])
+    band = n.array([370, 470, 520, 590, 660, 880, 950])
 
-	df_out = {}
+    df_out = {}
 
-	def _get_slope(__df):
-		func = lambda _x, _sl, _int: _sl * _x + _int
-		popt, pcov = curve_fit(func, band, __df.values)
+    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)
+        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()
+    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 = 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']
+    df_out['eBC'] = df['BC6']
 
-	return df_out
+    return df_out
 
 
 def _AAE(df):
-	import numpy as n
-	from scipy.optimize import curve_fit
+    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
+    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))
+        ## 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
+            return popt
 
-		## calculate
-		_AAE = _df.apply(_get_slope, axis=1, result_type='expand')
-		_AAE.columns = ['slope', 'intercept']
+        ## calculate
+        _AAE = _df.apply(_get_slope, axis=1, result_type='expand')
+        _AAE.columns = ['slope', 'intercept']
 
-		return _AAE
+        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 = _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)
+    df_out['eBC'] = df['BC6']
+    return df_out.reindex(df.index)