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

AeroViz/dataProcess/SizeDistr/_size_distr.py

@@ -2,79 +2,79 @@ __all__ = ['_basic']
 
 
 def _geometric_prop(_dp, _prop):
-	import numpy as n
+    import numpy as n
 
-	_prop_t = _prop.sum(axis=1)
-	_prop_t = _prop_t.where(_prop_t > 0).copy()
+    _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 = 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
+    _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)
+    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
+    import numpy as n
+    from pandas import DataFrame
 
-	## get number conc. data and total, mode
-	dN = df
-	dN.columns = dN.keys().to_numpy(float)
+    ## 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()
+    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()
+    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()
+    ## 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'] = 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
+    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)
+    ## 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
+    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 _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):
+        for _md_nam, _range in zip(['all', 'Nucleation', 'Aitken', 'Accumulation', 'Coarse'], bound):
 
-			_dia = dp[(dp >= _range[0]) & (dp < _range[-1])]
-			if ~_dia.any(): continue
+            _dia = dp[(dp >= _range[0]) & (dp < _range[-1])]
+            if ~_dia.any(): continue
 
-			_dt = _tp_dt[_dia].copy()
+            _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)
+            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
+    ## out
+    out_dic['other'] = df_oth
 
-	return out_dic
+    return out_dic
 
 # old 20230113
 

AeroViz/dataProcess/VOC/__init__.py

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

AeroViz/dataProcess/VOC/_potential_par.py

@@ -1,76 +1,74 @@
-from datetime import datetime as dtm
-from pandas import DataFrame, to_datetime, read_json
-from pathlib import Path
 import pickle as pkl
+from pathlib import Path
 
-import numpy as np
+from pandas import DataFrame, read_json
 
 
 def _basic(_df_voc):
-	## parameter
-	_keys = _df_voc.keys()
+    ## 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.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]
+    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'],
+    _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'],
+        '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'],
+        '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'],
+        'alkyne_total': ['Acetylene'],
 
-		'OVOC': ['Acetaldehyde', 'Ethanol', 'Acetone', 'IPA', 'Ethyl Acetate', 'Butyl Acetate'],
+        'OVOC': ['Acetaldehyde', 'Ethanol', 'Acetone', 'IPA', 'Ethyl Acetate', 'Butyl Acetate'],
 
-		'ClVOC': ['VCM', 'TCE', 'PCE', '1.4-DCB', '1.2-DCB'],
-	}
+        '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,
-	}
+    _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():
+    ## calculate
+    _out = {}
+    for _nam, _df in _df_dic.items():
 
-		_df_out = DataFrame(index=_df_voc.index)
+        _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
+        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[_voc_nam] = _df[_lst].sum(axis=1, min_count=1)
 
-		_df_out['Total'] = _df.sum(axis=1, min_count=1)
+        _df_out['Total'] = _df.sum(axis=1, min_count=1)
 
-		_out[_nam] = _df_out
+        _out[_nam] = _df_out
 
-	return _out
+    return _out