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

AeroViz/process/script/AbstractDistCalc.py

@@ -10,134 +10,134 @@ from AeroViz.process.method import properties, internal, external, core_shell, s
 
 
 class AbstractDistCalc(ABC):
-	@abstractmethod
-	def useApply(self) -> DataFrame:
-		pass
+    @abstractmethod
+    def useApply(self) -> DataFrame:
+        pass
 
 
 class NumberDistCalc(AbstractDistCalc):
-	def __init__(self, psd: SizeDist):
-		self.psd = psd
+    def __init__(self, psd: SizeDist):
+        self.psd = psd
 
-	def useApply(self) -> DataFrame:
-		""" Calculate number distribution """
-		return self.psd.data
+    def useApply(self) -> DataFrame:
+        """ Calculate number distribution """
+        return self.psd.data
 
 
 class SurfaceDistCalc(AbstractDistCalc):
-	def __init__(self, psd: SizeDist):
-		self.psd = psd
+    def __init__(self, psd: SizeDist):
+        self.psd = psd
 
-	def useApply(self) -> DataFrame:
-		""" Calculate surface distribution """
-		return self.psd.data.dropna().apply(lambda col: np.pi * self.psd.dp ** 2 * np.array(col),
-											axis=1, result_type='broadcast').reindex(self.psd.index)
+    def useApply(self) -> DataFrame:
+        """ Calculate surface distribution """
+        return self.psd.data.dropna().apply(lambda col: np.pi * self.psd.dp ** 2 * np.array(col),
+                                            axis=1, result_type='broadcast').reindex(self.psd.index)
 
 
 class VolumeDistCalc(AbstractDistCalc):
-	def __init__(self, psd: SizeDist):
-		self.psd = psd
+    def __init__(self, psd: SizeDist):
+        self.psd = psd
 
-	def useApply(self) -> DataFrame:
-		""" Calculate volume distribution """
-		return self.psd.data.dropna().apply(lambda col: np.pi / 6 * self.psd.dp ** 3 * np.array(col),
-											axis=1, result_type='broadcast').reindex(self.psd.index)
+    def useApply(self) -> DataFrame:
+        """ Calculate volume distribution """
+        return self.psd.data.dropna().apply(lambda col: np.pi / 6 * self.psd.dp ** 3 * np.array(col),
+                                            axis=1, result_type='broadcast').reindex(self.psd.index)
 
 
 class PropertiesDistCalc(AbstractDistCalc):
-	def __init__(self, psd: SizeDist):
-		self.psd = psd
+    def __init__(self, psd: SizeDist):
+        self.psd = psd
 
-	def useApply(self) -> DataFrame:
-		""" Calculate properties of distribution """
-		return self.psd.data.dropna().apply(partial(properties, dp=self.psd.dp, dlogdp=self.psd.dlogdp,
-													weighting=self.psd.weighting),
-											axis=1, result_type='expand').reindex(self.psd.index)
+    def useApply(self) -> DataFrame:
+        """ Calculate properties of distribution """
+        return self.psd.data.dropna().apply(partial(properties, dp=self.psd.dp, dlogdp=self.psd.dlogdp,
+                                                    weighting=self.psd.weighting),
+                                            axis=1, result_type='expand').reindex(self.psd.index)
 
 
 class ExtinctionDistCalc(AbstractDistCalc):
-	mapping = {'internal': internal,
-			   'external': external,
-			   'core_shell': core_shell,
-			   'sensitivity': sensitivity}
-
-	def __init__(self,
-				 psd: SizeDist,
-				 RI: DataFrame,
-				 method: Literal['internal', 'external', 'utils-shell', 'sensitivity'],
-				 result_type: Literal['extinction', 'scattering', 'absorption'] = 'extinction'
-				 ):
-		self.psd = psd
-		self.RI = RI
-		if method not in ExtinctionDistCalc.mapping:
-			raise ValueError(f"Invalid method: {method}. Valid methods are: {list(ExtinctionDistCalc.mapping.keys())}")
-		self.method = ExtinctionDistCalc.mapping[method]
-		self.result_type = result_type
-
-	def useApply(self) -> DataFrame:
-		""" Calculate volume distribution """
-		combined_data = concat([self.psd.data, self.RI], axis=1).dropna()
-		return combined_data.apply(partial(self.method, dp=self.psd.dp, result_type=self.result_type),
-								   axis=1, result_type='expand').reindex(self.psd.index).set_axis(self.psd.dp, axis=1)
+    mapping = {'internal': internal,
+               'external': external,
+               'core_shell': core_shell,
+               'sensitivity': sensitivity}
+
+    def __init__(self,
+                 psd: SizeDist,
+                 RI: DataFrame,
+                 method: Literal['internal', 'external', 'utils-shell', 'sensitivity'],
+                 result_type: Literal['extinction', 'scattering', 'absorption'] = 'extinction'
+                 ):
+        self.psd = psd
+        self.RI = RI
+        if method not in ExtinctionDistCalc.mapping:
+            raise ValueError(f"Invalid method: {method}. Valid methods are: {list(ExtinctionDistCalc.mapping.keys())}")
+        self.method = ExtinctionDistCalc.mapping[method]
+        self.result_type = result_type
+
+    def useApply(self) -> DataFrame:
+        """ Calculate volume distribution """
+        combined_data = concat([self.psd.data, self.RI], axis=1).dropna()
+        return combined_data.apply(partial(self.method, dp=self.psd.dp, result_type=self.result_type),
+                                   axis=1, result_type='expand').reindex(self.psd.index).set_axis(self.psd.dp, axis=1)
 
 
 # TODO:
 class LungDepositsDistCalc(AbstractDistCalc):
 
-	def __init__(self, psd: SizeDist, lung_curve):
-		self.psd = psd
-		self.lung_curve = lung_curve
+    def __init__(self, psd: SizeDist, lung_curve):
+        self.psd = psd
+        self.lung_curve = lung_curve
 
-	def useApply(self) -> DataFrame:
-		pass
+    def useApply(self) -> DataFrame:
+        pass
 
 
 class DistributionCalculator:  # 策略模式 (Strategy Pattern)
-	""" Interface for distribution calculator """
-
-	mapping = {'number': NumberDistCalc,
-			   'surface': SurfaceDistCalc,
-			   'volume': VolumeDistCalc,
-			   'property': PropertiesDistCalc,
-			   'extinction': ExtinctionDistCalc,
-			   'lung_deposit': LungDepositsDistCalc}
-
-	def __init__(self,
-				 calculator: Literal['number', 'surface', 'volume', 'property', 'extinction'],
-				 psd: SizeDist,
-				 RI: DataFrame = None,
-				 method: str = None,
-				 result_type: str = None
-				 ):
-		"""
-		Initialize the DistributionCalculator.
-
-		Parameters:
-		calculator (CalculatorType): The type of calculator.
-		psd (SizeDist): The particle size distribution data.
-		RI (Optional[DataFrame]): The refractive index data. Default is None.
-		method (Optional[str]): The method to use. Default is None.
-		result_type (Optional[str]): The result type. Default is None.
-		"""
-		if calculator not in DistributionCalculator.mapping.keys():
-			raise ValueError(
-				f"Invalid calculator: {calculator}. Valid calculators are: {list(DistributionCalculator.mapping.keys())}")
-		self.calculator = DistributionCalculator.mapping[calculator]
-		self.psd = psd
-		self.RI = RI
-		self.method = method
-		self.result_type = result_type
-
-	def useApply(self) -> DataFrame:
-		"""
-		Apply the calculator to the data.
-
-		Returns:
-		DataFrame: The calculated data.
-		"""
-		if self.RI is not None:
-			return self.calculator(self.psd, self.RI, self.method, self.result_type).useApply()
-		elif issubclass(self.calculator, (NumberDistCalc, SurfaceDistCalc, VolumeDistCalc, PropertiesDistCalc)):
-			return self.calculator(self.psd).useApply()
-		else:
-			raise ValueError("RI parameter is required for this calculator type")
+    """ Interface for distribution calculator """
+
+    mapping = {'number': NumberDistCalc,
+               'surface': SurfaceDistCalc,
+               'volume': VolumeDistCalc,
+               'property': PropertiesDistCalc,
+               'extinction': ExtinctionDistCalc,
+               'lung_deposit': LungDepositsDistCalc}
+
+    def __init__(self,
+                 calculator: Literal['number', 'surface', 'volume', 'property', 'extinction'],
+                 psd: SizeDist,
+                 RI: DataFrame = None,
+                 method: str = None,
+                 result_type: str = None
+                 ):
+        """
+        Initialize the DistributionCalculator.
+
+        Parameters:
+        calculator (CalculatorType): The type of calculator.
+        psd (SizeDist): The particle size distribution data.
+        RI (Optional[DataFrame]): The refractive index data. Default is None.
+        method (Optional[str]): The method to use. Default is None.
+        result_type (Optional[str]): The result type. Default is None.
+        """
+        if calculator not in DistributionCalculator.mapping.keys():
+            raise ValueError(
+                f"Invalid calculator: {calculator}. Valid calculators are: {list(DistributionCalculator.mapping.keys())}")
+        self.calculator = DistributionCalculator.mapping[calculator]
+        self.psd = psd
+        self.RI = RI
+        self.method = method
+        self.result_type = result_type
+
+    def useApply(self) -> DataFrame:
+        """
+        Apply the calculator to the data.
+
+        Returns:
+        DataFrame: The calculated data.
+        """
+        if self.RI is not None:
+            return self.calculator(self.psd, self.RI, self.method, self.result_type).useApply()
+        elif issubclass(self.calculator, (NumberDistCalc, SurfaceDistCalc, VolumeDistCalc, PropertiesDistCalc)):
+            return self.calculator(self.psd).useApply()
+        else:
+            raise ValueError("RI parameter is required for this calculator type")

AeroViz/process/script/Chemical.py

@@ -8,169 +8,169 @@ from AeroViz.tools.datareader import DataReader
 
 
 class ChemicalProc(DataProc):
-	"""
-	A class for process chemical data.
-
-	Parameters:
-	-----------
-	reset : bool, optional
-		If True, resets the process. Default is False.
-	filename : str, optional
-		The name of the file to process. Default is None.
-
-	Methods:
-	--------
-	mass(_df):
-		Calculate mass-related parameters.
-
-	volume(_df):
-		Calculate volume-related parameters.
-
-	volume_average_mixing(_df):
-		Calculate volume average mixing parameters.
-
-	process_data():
-		Process data and save the result.
-
-	Attributes:
-	-----------
-	DEFAULT_PATH : Path
-		The default path for data files.
-
-	Examples:
-	---------
-
-	"""
-
-	def __init__(self, file_paths: list[Path | str] = None):
-		super().__init__()
-		self.file_paths = [Path(fp) for fp in file_paths]
-
-	@staticmethod
-	def mass(_df):  # Series like
-		Ammonium, Sulfate, Nitrate, OC, Soil, SS, EC, PM25 = _df
-		status = (Ammonium / 18) / (2 * (Sulfate / 96) + (Nitrate / 62))
-
-		if status >= 1:
-			_df['NH4_status'] = 'Enough'
-			_df['AS'] = 1.375 * Sulfate
-			_df['AN'] = 1.29 * Nitrate
-
-		if status < 1:
-			_df['NH4_status'] = 'Deficiency'
-			mol_A = Ammonium / 18
-			mol_S = Sulfate / 96
-			mol_N = Nitrate / 62
-			residual = mol_A - 2 * mol_S
-
-			if residual > 0:
-				_df['AS'] = 1.375 * Sulfate
-				_df['AN'] = residual * 80 if residual <= mol_N else mol_N * 80
-
-			else:
-				_df['AS'] = mol_A / 2 * 132 if mol_A <= 2 * mol_S else mol_S * 132
-				_df['AN'] = 0
-
-		_df['OM'] = 1.8 * OC
-		_df['Soil'] = 28.57 * Soil
-		_df['SS'] = 2.54 * SS
-		_df['EC'] = EC
-		_df['SIA'] = _df['AS'] + _df['AN']
-		_df['total_mass'] = _df[['AS', 'AN', 'OM', 'Soil', 'SS', 'EC']].sum()
-		species_lst = ['AS', 'AN', 'OM', 'Soil', 'SS', 'EC', 'SIA', 'unknown_mass']
-
-		_df['unknown_mass'] = PM25 - _df['total_mass'] if PM25 >= _df['total_mass'] else 0
-		for _species, _val in _df[species_lst].items():
-			_df[f'{_species}_ratio'] = _val / PM25 if PM25 >= _df['total_mass'] else _val / _df['total_mass']
-
-		return _df['NH4_status':]
-
-	@staticmethod
-	def volume(_df):
-		_df['AS_volume'] = (_df['AS'] / 1.76)
-		_df['AN_volume'] = (_df['AN'] / 1.73)
-		_df['OM_volume'] = (_df['OM'] / 1.4)
-		_df['Soil_volume'] = (_df['Soil'] / 2.6)
-		_df['SS_volume'] = (_df['SS'] / 2.16)
-		_df['EC_volume'] = (_df['EC'] / 1.5)
-		_df['ALWC_volume'] = _df['ALWC']
-		_df['total_volume'] = sum(_df['AS_volume':'EC_volume'])
-
-		for _species, _val in _df['AS_volume':'ALWC_volume'].items():
-			_df[f'{_species}_ratio'] = _val / _df['total_volume']
-
-		_df['density'] = _df['total_mass'] / _df['total_volume']
-		return _df['AS_volume':]
-
-	@staticmethod
-	def volume_average_mixing(_df):
-		_df['n_dry'] = (1.53 * _df['AS_volume_ratio'] +
-						1.55 * _df['AN_volume_ratio'] +
-						1.55 * _df['OM_volume_ratio'] +
-						1.56 * _df['Soil_volume_ratio'] +
-						1.54 * _df['SS_volume_ratio'] +
-						1.80 * _df['EC_volume_ratio'])
-
-		_df['k_dry'] = (0.00 * _df['OM_volume_ratio'] +
-						0.01 * _df['Soil_volume_ratio'] +
-						0.54 * _df["EC_volume_ratio"])
-
-		# 檢查_df['ALWC']是否缺失 -> 有值才計算ambient的折射率
-		if notna(_df['ALWC']):
-			v_dry = _df['total_volume']
-			v_wet = _df['total_volume'] + _df['ALWC']
-
-			multiplier = v_dry / v_wet
-			_df['ALWC_volume_ratio'] = (1 - multiplier)
-
-			_df['n_amb'] = (1.53 * _df['AS_volume_ratio'] +
-							1.55 * _df['AN_volume_ratio'] +
-							1.55 * _df['OM_volume_ratio'] +
-							1.56 * _df['Soil_volume_ratio'] +
-							1.54 * _df['SS_volume_ratio'] +
-							1.80 * _df['EC_volume_ratio']) * multiplier + \
-						   (1.33 * _df['ALWC_volume_ratio'])
-
-			_df['k_amb'] = (0.00 * _df['OM_volume_ratio'] +
-							0.01 * _df['Soil_volume_ratio'] +
-							0.54 * _df['EC_volume_ratio']) * multiplier
-
-			_df['gRH'] = (v_wet / v_dry) ** (1 / 3)
-
-			return _df[['n_dry', 'k_dry', 'n_amb', 'k_amb', 'gRH']]
-
-	@staticmethod
-	def kappa(_df, diameter=0.5):
-		surface_tension, Mw, density, universal_gas_constant = 0.072, 18, 1, 8.314  # J/mole*K
-
-		A = 4 * (surface_tension * Mw) / (density * universal_gas_constant * (_df['AT'] + 273))
-		power = A / diameter
-		a_w = (_df['RH'] / 100) * (np.exp(-power))
-
-		_df['kappa_chem'] = (_df['gRH'] ** 3 - 1) * (1 - a_w) / a_w
-		_df['kappa_vam'] = np.nan
-
-	@staticmethod
-	def ISORROPIA():
-		pass
-
-	def process_data(self, reset: bool = False, save_file: Path | str = None) -> DataFrame:
-		save_file = Path(save_file)
-		if save_file.exists() and not reset:
-			return read_csv(save_file, parse_dates=['Time'], index_col='Time')
-		else:
-			df = concat([DataReader(file) for file in self.file_paths], axis=1)
-
-			df_mass = df[['NH4+', 'SO42-', 'NO3-', 'O_OC', 'Fe', 'Na+', 'O_EC', 'PM25']].dropna().apply(self.mass,
-																										axis=1)
-			df_mass['ALWC'] = df['ALWC']
-			df_volume = df_mass[['AS', 'AN', 'OM', 'Soil', 'SS', 'EC', 'total_mass', 'ALWC']].dropna().apply(
-				self.volume,
-				axis=1)
-			df_volume['ALWC'] = df['ALWC']
-			df_vam = df_volume.dropna().apply(self.volume_average_mixing, axis=1)
-
-			_df = concat([df_mass, df_volume.drop(['ALWC'], axis=1), df_vam], axis=1).reindex(df.index.copy())
-			_df.to_csv(save_file)
-
-			return _df
+    """
+    A class for process chemical data.
+
+    Parameters:
+    -----------
+    reset : bool, optional
+        If True, resets the process. Default is False.
+    filename : str, optional
+        The name of the file to process. Default is None.
+
+    Methods:
+    --------
+    mass(_df):
+        Calculate mass-related parameters.
+
+    volume(_df):
+        Calculate volume-related parameters.
+
+    volume_average_mixing(_df):
+        Calculate volume average mixing parameters.
+
+    process_data():
+        Process data and save the result.
+
+    Attributes:
+    -----------
+    DEFAULT_PATH : Path
+        The default path for data files.
+
+    Examples:
+    ---------
+
+    """
+
+    def __init__(self, file_paths: list[Path | str] = None):
+        super().__init__()
+        self.file_paths = [Path(fp) for fp in file_paths]
+
+    @staticmethod
+    def mass(_df):  # Series like
+        Ammonium, Sulfate, Nitrate, OC, Soil, SS, EC, PM25 = _df
+        status = (Ammonium / 18) / (2 * (Sulfate / 96) + (Nitrate / 62))
+
+        if status >= 1:
+            _df['NH4_status'] = 'Enough'
+            _df['AS'] = 1.375 * Sulfate
+            _df['AN'] = 1.29 * Nitrate
+
+        if status < 1:
+            _df['NH4_status'] = 'Deficiency'
+            mol_A = Ammonium / 18
+            mol_S = Sulfate / 96
+            mol_N = Nitrate / 62
+            residual = mol_A - 2 * mol_S
+
+            if residual > 0:
+                _df['AS'] = 1.375 * Sulfate
+                _df['AN'] = residual * 80 if residual <= mol_N else mol_N * 80
+
+            else:
+                _df['AS'] = mol_A / 2 * 132 if mol_A <= 2 * mol_S else mol_S * 132
+                _df['AN'] = 0
+
+        _df['OM'] = 1.8 * OC
+        _df['Soil'] = 28.57 * Soil
+        _df['SS'] = 2.54 * SS
+        _df['EC'] = EC
+        _df['SIA'] = _df['AS'] + _df['AN']
+        _df['total_mass'] = _df[['AS', 'AN', 'OM', 'Soil', 'SS', 'EC']].sum()
+        species_lst = ['AS', 'AN', 'OM', 'Soil', 'SS', 'EC', 'SIA', 'unknown_mass']
+
+        _df['unknown_mass'] = PM25 - _df['total_mass'] if PM25 >= _df['total_mass'] else 0
+        for _species, _val in _df[species_lst].items():
+            _df[f'{_species}_ratio'] = _val / PM25 if PM25 >= _df['total_mass'] else _val / _df['total_mass']
+
+        return _df['NH4_status':]
+
+    @staticmethod
+    def volume(_df):
+        _df['AS_volume'] = (_df['AS'] / 1.76)
+        _df['AN_volume'] = (_df['AN'] / 1.73)
+        _df['OM_volume'] = (_df['OM'] / 1.4)
+        _df['Soil_volume'] = (_df['Soil'] / 2.6)
+        _df['SS_volume'] = (_df['SS'] / 2.16)
+        _df['EC_volume'] = (_df['EC'] / 1.5)
+        _df['ALWC_volume'] = _df['ALWC']
+        _df['total_volume'] = sum(_df['AS_volume':'EC_volume'])
+
+        for _species, _val in _df['AS_volume':'ALWC_volume'].items():
+            _df[f'{_species}_ratio'] = _val / _df['total_volume']
+
+        _df['density'] = _df['total_mass'] / _df['total_volume']
+        return _df['AS_volume':]
+
+    @staticmethod
+    def volume_average_mixing(_df):
+        _df['n_dry'] = (1.53 * _df['AS_volume_ratio'] +
+                        1.55 * _df['AN_volume_ratio'] +
+                        1.55 * _df['OM_volume_ratio'] +
+                        1.56 * _df['Soil_volume_ratio'] +
+                        1.54 * _df['SS_volume_ratio'] +
+                        1.80 * _df['EC_volume_ratio'])
+
+        _df['k_dry'] = (0.00 * _df['OM_volume_ratio'] +
+                        0.01 * _df['Soil_volume_ratio'] +
+                        0.54 * _df["EC_volume_ratio"])
+
+        # 檢查_df['ALWC']是否缺失 -> 有值才計算ambient的折射率
+        if notna(_df['ALWC']):
+            v_dry = _df['total_volume']
+            v_wet = _df['total_volume'] + _df['ALWC']
+
+            multiplier = v_dry / v_wet
+            _df['ALWC_volume_ratio'] = (1 - multiplier)
+
+            _df['n_amb'] = (1.53 * _df['AS_volume_ratio'] +
+                            1.55 * _df['AN_volume_ratio'] +
+                            1.55 * _df['OM_volume_ratio'] +
+                            1.56 * _df['Soil_volume_ratio'] +
+                            1.54 * _df['SS_volume_ratio'] +
+                            1.80 * _df['EC_volume_ratio']) * multiplier + \
+                           (1.33 * _df['ALWC_volume_ratio'])
+
+            _df['k_amb'] = (0.00 * _df['OM_volume_ratio'] +
+                            0.01 * _df['Soil_volume_ratio'] +
+                            0.54 * _df['EC_volume_ratio']) * multiplier
+
+            _df['gRH'] = (v_wet / v_dry) ** (1 / 3)
+
+            return _df[['n_dry', 'k_dry', 'n_amb', 'k_amb', 'gRH']]
+
+    @staticmethod
+    def kappa(_df, diameter=0.5):
+        surface_tension, Mw, density, universal_gas_constant = 0.072, 18, 1, 8.314  # J/mole*K
+
+        A = 4 * (surface_tension * Mw) / (density * universal_gas_constant * (_df['AT'] + 273))
+        power = A / diameter
+        a_w = (_df['RH'] / 100) * (np.exp(-power))
+
+        _df['kappa_chem'] = (_df['gRH'] ** 3 - 1) * (1 - a_w) / a_w
+        _df['kappa_vam'] = np.nan
+
+    @staticmethod
+    def ISORROPIA():
+        pass
+
+    def process_data(self, reset: bool = False, save_file: Path | str = None) -> DataFrame:
+        save_file = Path(save_file)
+        if save_file.exists() and not reset:
+            return read_csv(save_file, parse_dates=['Time'], index_col='Time')
+        else:
+            df = concat([DataReader(file) for file in self.file_paths], axis=1)
+
+            df_mass = df[['NH4+', 'SO42-', 'NO3-', 'O_OC', 'Fe', 'Na+', 'O_EC', 'PM25']].dropna().apply(self.mass,
+                                                                                                        axis=1)
+            df_mass['ALWC'] = df['ALWC']
+            df_volume = df_mass[['AS', 'AN', 'OM', 'Soil', 'SS', 'EC', 'total_mass', 'ALWC']].dropna().apply(
+                self.volume,
+                axis=1)
+            df_volume['ALWC'] = df['ALWC']
+            df_vam = df_volume.dropna().apply(self.volume_average_mixing, axis=1)
+
+            _df = concat([df_mass, df_volume.drop(['ALWC'], axis=1), df_vam], axis=1).reindex(df.index.copy())
+            _df.to_csv(save_file)
+
+            return _df