AeroViz 0.1.3__py3-none-any.whl → 0.1.4__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

@@ -1,19 +1,19 @@
-from ..core import _writter, _run_process
+from ..core import Writer, run_process
 
 __all__ = [
 
-	'VOC',
+    'VOC',
 
 ]
 
 
-class VOC(_writter):
+class VOC(Writer):
 
-	## 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

AeroViz/dataProcess/__init__.py

@@ -1,11 +1,33 @@
+from pathlib import Path
+
 from .Chemistry import Chemistry
 from .Optical import Optical
 from .SizeDistr import SizeDistr
 from .VOC import VOC
 
-__all__ = [
-	'Optical',
-	'SizeDistr',
-	'Chemistry',
-	'VOC',
-]
+__all__ = ['DataProcess']
+
+
+def DataProcess(method: str,
+                path_out: Path,
+                excel: bool = False,
+                csv: bool = True,
+                ):
+    # Mapping of method names to their respective classes
+    method_class_map = {
+        'Chemistry': Chemistry,
+        'Optical': Optical,
+        'SizeDistr': SizeDistr,
+        'VOC': VOC
+    }
+
+    if method not in method_class_map.keys():
+        raise ValueError(f"Method name '{method}' is not valid. \nMust be one of: {list(method_class_map.keys())}")
+
+    writer_module = method_class_map[method](
+        path_out=path_out,
+        excel=excel,
+        csv=csv
+    )
+
+    return writer_module

AeroViz/dataProcess/core/__init__.py

@@ -1,92 +1,86 @@
-from pandas import DatetimeIndex, DataFrame, concat
-from pathlib import Path
 import pickle as pkl
 from datetime import datetime as dtm
+from pathlib import Path
 
+from pandas import concat
 
-class _writter:
-
-	def __init__(self, path_out=None, excel=True, csv=False):
-
-		self.path_out = Path(path_out) if path_out is not None else path_out
-		self.excel = excel
-		self.csv = csv
-
-	def _pre_process(self, _out):
-
-		if type(_out) == dict:
-			for _ky, _df in _out.items():
-				_df.index.name = 'time'
-		else:
-			_out.index.name = 'time'
 
-		return _out
+class Writer:
 
-	def _save_out(self, _nam, _out):
+    def __init__(self, path_out=None, excel=True, csv=False):
+        self.path_out = Path(path_out) if path_out is not None else path_out
+        self.excel = excel
+        self.csv = csv
 
-		_check = True
-		while _check:
+    @staticmethod
+    def pre_process(_out):
+        if isinstance(_out, dict):
+            for _ky, _df in _out.items():
+                _df.index.name = 'time'
+        else:
+            _out.index.name = 'time'
 
-			try:
-				if self.path_out is not None:
-					self.path_out.mkdir(exist_ok=True, parents=True)
-					with (self.path_out / f'{_nam}.pkl').open('wb') as f:
-						pkl.dump(_out, f, protocol=pkl.HIGHEST_PROTOCOL)
+        return _out
 
-					if self.excel:
-						from pandas import ExcelWriter
-						with ExcelWriter(self.path_out / f'{_nam}.xlsx') as f:
-							if type(_out) == dict:
-								for _key, _val in _out.items():
-									_val.to_excel(f, sheet_name=f'{_key}')
-							else:
-								_out.to_excel(f, sheet_name=f'{_nam}')
+    def save_out(self, _nam, _out):
+        _check = True
+        while _check:
 
-					if self.csv:
-						if type(_out) == dict:
-							_path_out = self.path_out / _nam
-							_path_out.mkdir(exist_ok=True, parents=True)
+            try:
+                if self.path_out is not None:
+                    self.path_out.mkdir(exist_ok=True, parents=True)
+                    with (self.path_out / f'{_nam}.pkl').open('wb') as f:
+                        pkl.dump(_out, f, protocol=pkl.HIGHEST_PROTOCOL)
 
-							for _key, _val in _out.items():
-								_val.to_csv(_path_out / f'{_key}.csv')
-						else:
-							_out.to_csv(self.path_out / f'{_nam}.csv')
+                    if self.excel:
+                        from pandas import ExcelWriter
+                        with ExcelWriter(self.path_out / f'{_nam}.xlsx') as f:
+                            if type(_out) == dict:
+                                for _key, _val in _out.items():
+                                    _val.to_excel(f, sheet_name=f'{_key}')
+                            else:
+                                _out.to_excel(f, sheet_name=f'{_nam}')
 
-				_check = False
+                    if self.csv:
+                        if isinstance(_out, dict):
+                            _path_out = self.path_out / _nam
+                            _path_out.mkdir(exist_ok=True, parents=True)
 
-			except PermissionError as _err:
-				print('\n', _err)
-				input('\t\t\33[41m Please Close The File And Press "Enter" \33[0m\n')
+                            for _key, _val in _out.items():
+                                _val.to_csv(_path_out / f'{_key}.csv')
+                        else:
+                            _out.to_csv(self.path_out / f'{_nam}.csv')
 
+                _check = False
 
-def _run_process(*_ini_set):
-	def _decorator(_prcs_fc):
-		def _wrap(*arg, **kwarg):
-			_fc_name, _nam = _ini_set
+            except PermissionError as _err:
+                print('\n', _err)
+                input('\t\t\33[41m Please Close The File And Press "Enter" \33[0m\n')
 
-			if kwarg.get('nam') is not None:
-				_nam = kwarg.pop('nam')
 
-			print(f"\n\t{dtm.now().strftime('%m/%d %X')} : Process \033[92m{_fc_name}\033[0m -> {_nam}")
+def run_process(*_ini_set):
+    def _decorator(_prcs_fc):
+        def _wrap(*arg, **kwarg):
+            _fc_name, _nam = _ini_set
 
-			_class, _out = _prcs_fc(*arg, **kwarg)
-			_out = _class._pre_process(_out)
+            if kwarg.get('nam') is not None:
+                _nam = kwarg.pop('nam')
 
-			_class._save_out(_nam, _out)
+            print(f"\n\t{dtm.now().strftime('%m/%d %X')} : Process \033[92m{_fc_name}\033[0m -> {_nam}")
 
-			return _out
+            _class, _out = _prcs_fc(*arg, **kwarg)
+            _out = _class.pre_process(_out)
 
-		return _wrap
+            _class.save_out(_nam, _out)
 
-	return _decorator
+            return _out
 
+        return _wrap
 
-def _union_index(*_df_arg):
-	_idx = concat(_df_arg, axis=1).index
+    return _decorator
 
-	# _idx = DatetimeIndex([])
 
-	# for _df in _df_arg:
-	# _idx = _idx.union(DataFrame(_df).index)
+def union_index(*_df_arg):
+    _idx = concat(_df_arg, axis=1).index
 
-	return [_df.reindex(_idx) if _df is not None else None for _df in _df_arg]
+    return [_df.reindex(_idx) if _df is not None else None for _df in _df_arg]

AeroViz/plot/__init__.py

@@ -1,7 +1,12 @@
 from . import distribution
-from . import improve
 from . import meteorology
 from . import optical
-from . import timeseries
+from .bar import bar
+from .box import box
+from .pie import pie, donuts
+from .regression import linear_regression, multiple_linear_regression
+from .scatter import scatter
 from .templates import *
+from .timeseries import timeseries, timeseries_template, timeseries_stacked
 from .utils import *
+from .violin import violin

AeroViz/plot/bar.py

@@ -0,0 +1,126 @@
+from typing import Literal
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.pyplot import Figure, Axes
+from pandas import DataFrame
+
+from AeroViz.plot.utils import *
+
+__all__ = ['bar']
+
+
+@set_figure(fw='bold')
+def bar(data_set: DataFrame | dict,
+		data_std: DataFrame | None,
+		labels: list[str],
+		unit: str,
+		style: Literal["stacked", "dispersed"] = "dispersed",
+		orientation: Literal["va", "ha"] = 'va',
+		ax: Axes | None = None,
+		symbol=True,
+		**kwargs
+		) -> tuple[Figure, Axes]:
+	"""
+    Parameters
+    ----------
+    data_set : pd.DataFrame or dict
+        A mapping from category names to a list of species mean or a DataFrame with columns as categories and values as means.
+    data_std : pd.DataFrame or None
+        A DataFrame with standard deviations corresponding to data_set, or None if standard deviations are not provided.
+    labels : list of str
+        The species names.
+    unit : str
+        The unit for the values.
+    style : {'stacked', 'dispersed'}, default 'dispersed'
+        Whether to display the bars stacked or dispersed.
+    orientation : {'va', 'ha'}, default 'va'
+        The orientation of the bars, 'va' for vertical and 'ha' for horizontal.
+    ax : plt.Axes or None, default None
+        The Axes object to plot on. If None, a new figure and Axes are created.
+    symbol : bool, default True
+        Whether to display values for each bar.
+    kwargs : dict
+        Additional keyword arguments passed to the barplot function.
+
+    Returns
+    -------
+    matplotlib.Axes
+        The Axes object containing the plot.
+
+    """
+	# data process
+	data = data_set.values
+
+	if data_std is None:
+		data_std = np.zeros(data.shape)
+	else:
+		data_std = data_std.values
+
+	groups, species = data.shape
+	groups_arr = np.arange(groups)
+	species_arr = np.arange(species)
+
+	total = np.array([data.sum(axis=1), ] * species).T
+
+	pct_data = data / total * 100
+	data_cum = pct_data.cumsum(axis=1)
+
+	# figure info
+	category_names = kwargs.get('ticks') or list(data_set.index)
+	title = kwargs.get('title', '')
+	colors = kwargs.get('colors') or (Color.colors1 if species == 6 else Color.getColor(num=species))
+
+	fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+
+	if style == "stacked":
+		for i in range(species):
+			widths = pct_data[:, i]
+			starts = data_cum[:, i] - pct_data[:, i]
+
+			if orientation == 'va':
+				_ = ax.bar(groups_arr, widths, bottom=starts, width=0.7, color=colors[i], label=labels[i],
+						   edgecolor=None, capsize=None)
+			else:
+				_ = ax.barh(groups_arr, widths, left=starts, height=0.7, color=colors[i], label=labels[i],
+							edgecolor=None, capsize=None)
+			if symbol:
+				ax.bar_label(_, fmt=auto_label_pct, label_type='center', padding=0, fontsize=8, weight='bold')
+
+	if style == "dispersed":
+		width = 0.1
+		block = width / 4
+
+		for i in range(species):
+			val = data[:, i]
+			std = (0,) * groups, data_std[:, i]
+			if orientation == 'va':
+				_ = ax.bar(groups_arr + (i + 1) * (width + block), val, yerr=std, width=width, color=colors[i],
+						   edgecolor=None, capsize=None)
+			else:
+				_ = ax.barh(groups_arr + (i + 1) * (width + block), val, xerr=std, height=width, color=colors[i],
+							edgecolor=None, capsize=None)
+			if symbol:
+				ax.bar_label(_, fmt=auto_label_pct, label_type='center', padding=0, fontsize=8, weight='bold')
+
+	if orientation == 'va':
+		xticks = groups_arr + (species / 2 + 0.5) * (width + block) if style == "dispersed" else groups_arr
+		ax.set_xticks(xticks, category_names, weight='bold')
+		ax.set_ylabel(Unit(unit) if style == "dispersed" else '$Contribution (\\%)$')
+		ax.set_ylim(0, None if style == "dispersed" else 100)
+		ax.legend(labels, bbox_to_anchor=(1, 1), loc='upper left', prop={'size': 8})
+
+	if orientation == 'ha':
+		ax.invert_yaxis()
+		yticks = groups_arr + 3.5 * (width + block) if style == "dispersed" else groups_arr
+		ax.set_yticks(yticks, category_names, weight='bold')
+		ax.set_xlabel(Unit(unit) if style == "dispersed" else '$Contribution (\\%)$')
+		ax.set_xlim(0, None if style == "dispersed" else 100)
+		ax.legend(labels, bbox_to_anchor=(1, 1), loc='upper left', prop={'size': 8})
+
+	# fig.savefig(f"Barplot_{title}")
+
+	plt.show()
+
+	return fig, ax