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

AeroViz/dataProcess/Optical/_extinction.py

@@ -1,36 +1,37 @@
-from AeroViz.dataProcess.core import _union_index
 from pandas import DataFrame
 
+from AeroViz.dataProcess.core import _union_index
+
 
 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_abs, df_sca, df_ec, df_mass, df_no2 = _union_index(df_abs, df_sca, df_ec, df_mass, df_no2)
 
-	df_out = DataFrame()
+    df_out = DataFrame()
 
-	## abs and sca coe
-	df_out['abs'] = df_abs.copy()
-	df_out['sca'] = df_sca.copy()
+    ## 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']
+    ## extinction coe.
+    df_out['ext'] = df_out['abs'] + df_out['sca']
 
-	## SSA
-	df_out['SSA'] = df_out['sca'] / df_out['ext']
+    ## 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']
+    ## 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']
+    ## 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
+    ## other
+    if df_ec is not None:
+        df_out['eBC'] = df_ec / 1e3
 
-	return df_out
+    return df_out

AeroViz/dataProcess/Optical/_mie.py

@@ -2,15 +2,14 @@
 # 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
+    _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]
+    _psd, _RI = _psd_ori.loc[_cal_idx], _RI_ori.loc[_cal_idx]
 
-	_out = Mie_SD(_RI.values, 550, _psd)
+    _out = Mie_SD(_RI.values, 550, _psd)
 
-	return _out.reindex(_ori_idx)
+    return _out.reindex(_ori_idx)

AeroViz/dataProcess/Optical/_mie_sd.py

@@ -1,143 +1,142 @@
 # -*- coding: utf-8 -*-
 # http://pymiescatt.readthedocs.io/en/latest/forward.html
 import numpy as np
+from pandas import concat, DataFrame
 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
+    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
+    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))
+    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()]
+    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()]
+    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
+    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)
+    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_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_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())
+        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():
+        Dn_lst = []
+        for _nmx, _uni_idx in DataFrame(_nmx_ary).groupby(0).groups.items():
 
-			_inv_mx = 1 / _mx[_uni_idx]
+            _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 = 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]
+            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
+        ## 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
+        _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)
+        _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)
+        _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)
+        _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
+        df_qext.loc[_bin_idx] = _pr_qext
+        df_qsca.loc[_bin_idx] = _pr_qsca
 
-	return df_qext, df_qsca
+    return df_qext, df_qsca
 
 
 def MieQ(m_ary, wavelength, diameter):
-	#  http://pymiescatt.readthedocs.io/en/latest/forward.html#MieQ
+    #  http://pymiescatt.readthedocs.io/en/latest/forward.html#MieQ
 
-	x = np.pi * diameter / wavelength
+    x = np.pi * diameter / wavelength
 
-	nmax = np.round(2 + x + 4 * (x ** (1 / 3)))
+    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))
+    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
+    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, _qsca = Mie_ab(m_ary, x, nmax, df_n)
 
-	qext = (2 / x2).reshape(-1, 1) * _qext
-	qsca = (2 / x2).reshape(-1, 1) * _qsca
+    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)
+    # 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
+    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')
+    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
+    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 q_table:
+        qext, qsca = q_table
+    else:
+        qext, qsca = MieQ(m_ary, wavelength, dp)
 
-	if multp_m_in1psd:
-		# print('\tcalculate ext')
+    if multp_m_in1psd:
+        # print('\tcalculate ext')
 
-		aSDn_all = np.repeat(aSDn, m_ary.size, axis=0).reshape(len(aSDn), m_ary.size, -1)
+        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)
+        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')
+        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)
+        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']
+    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
+        return df_out

AeroViz/dataProcess/Optical/_scattering.py

@@ -2,29 +2,29 @@ import numpy as np
 from scipy.optimize import curve_fit
 
 __all__ = [
-	'_SAE',
+    '_SAE',
 ]
 
 
 def _SAE(df):
-	def _SAEcalc(_df):
-		## parameter
-		band = np.array([450, 550, 700]) * 1e-3
+    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))
+        ## 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
+            return popt
 
-		## calculate
-		_SAE = _df.apply(_get_slope, axis=1, result_type='expand')
-		_SAE.columns = ['slope', 'intercept']
+        ## calculate
+        _SAE = _df.apply(_get_slope, axis=1, result_type='expand')
+        _SAE.columns = ['slope', 'intercept']
 
-		return _SAE
+        return _SAE
 
-	df_out = _SAEcalc(df[['B', 'G', 'R']].dropna())
+    df_out = _SAEcalc(df[['B', 'G', 'R']].dropna())
 
-	return df_out.reindex(df.index)
+    return df_out.reindex(df.index)

AeroViz/dataProcess/SizeDistr/__init__.py

@@ -2,60 +2,60 @@ from ..core import _writter, _run_process
 
 __all__ = [
 
-	'SizeDistr',
+    '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
+    ## 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)
+        out = _basic(df, hybrid_bin_start_loc, unit, bin_range, input_type)
 
-		return self, out
+        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
+    ## 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)
+        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
+        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
+    ## 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)
+        out = merge_SMPS_APS(df_smps, df_aps, aps_unit, smps_overlap_lowbound, aps_fit_highbound, dndsdv_alg)
 
-		return self, out
+        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
+    ## 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)
+        out = merge_SMPS_APS(df_smps, df_aps, aps_unit, smps_overlap_lowbound, aps_fit_highbound)
 
-		return self, out
+        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
+    ## 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)
+        out = _merge_SMPS_APS(df_smps, df_aps, aps_unit, shift_mode, smps_overlap_lowbound, aps_fit_highbound)
 
-		return self, out
+        return self, out