AeroViz 0.1.0__py3-none-any.whl

AeroViz/process/method/mie_theory.py

@@ -0,0 +1,258 @@
+from typing import Sequence, Literal
+
+import numpy as np
+import pandas as pd
+from .PyMieScatt_update import AutoMieQ
+from numpy import exp, log, log10, sqrt, pi
+
+
+def Mie_Q(m: complex,
+		  wavelength: float,
+		  dp: float | Sequence[float]
+		  ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+	"""
+	Calculate Mie scattering efficiency (Q) for given spherical particle diameter(s).
+
+	Parameters
+	----------
+	m : complex
+		The complex refractive index of the particles.
+	wavelength : float
+		The wavelength of the incident light (in nm).
+	dp : float | Sequence[float]
+		Particle diameters (in nm), can be a single value or Sequence object.
+
+	Returns
+	-------
+	Q_ext : ndarray
+		The Mie extinction efficiency for each particle diameter.
+	Q_sca : ndarray
+		The Mie scattering efficiency for each particle diameter.
+	Q_abs : ndarray
+		The Mie absorption efficiency for each particle diameter.
+
+	Examples
+	--------
+	>>> Q_ext, Q_sca, Q_abs = Mie_Q(m=complex(1.5, 0.02), wavelength=550, dp=[100, 200, 300, 400])
+	"""
+	# Ensure dp is a numpy array
+	dp = np.atleast_1d(dp)
+
+	# Transpose for proper unpacking
+	Q_ext, Q_sca, Q_abs, g, Q_pr, Q_back, Q_ratio = np.array([AutoMieQ(m, wavelength, _dp) for _dp in dp]).T
+
+	return Q_ext, Q_sca, Q_abs
+
+
+def Mie_MEE(m: complex,
+			wavelength: float,
+			dp: float | Sequence[float],
+			density: float
+			) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+	"""
+	Calculate mass extinction efficiency and other parameters.
+
+	Parameters
+	----------
+	m : complex
+		The complex refractive index of the particles.
+	wavelength : float
+		The wavelength of the incident light.
+	dp : float | Sequence[float]
+		List of particle sizes or a single value.
+	density : float
+		The density of particles.
+
+	Returns
+	-------
+	MEE : ndarray
+		The mass extinction efficiency for each particle diameter.
+	MSE : ndarray
+		The mass scattering efficiency for each particle diameter.
+	MAE : ndarray
+		The mass absorption efficiency for each particle diameter.
+
+	Examples
+	--------
+	>>> MEE, MSE, MAE = Mie_MEE(m=complex(1.5, 0.02), wavelength=550, dp=[100, 200, 300, 400], density=1.2)
+	"""
+	Q_ext, Q_sca, Q_abs = Mie_Q(m, wavelength, dp)
+
+	MEE = (3 * Q_ext) / (2 * density * dp) * 1000
+	MSE = (3 * Q_sca) / (2 * density * dp) * 1000
+	MAE = (3 * Q_abs) / (2 * density * dp) * 1000
+
+	return MEE, MSE, MAE
+
+
+def Mie_PESD(m: complex,
+			 wavelength: float = 550,
+			 dp: float | Sequence[float] = None,
+			 ndp: float | Sequence[float] = None,
+			 lognormal: bool = False,
+			 dp_range: tuple = (1, 2500),
+			 geoMean: float = 200,
+			 geoStdDev: float = 2,
+			 numberOfParticles: float = 1e6,
+			 numberOfBins: int = 167,
+			 ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+	"""
+	Simultaneously calculate "extinction distribution" and "integrated results" using the Mie_Q method.
+
+	Parameters
+	----------
+	m : complex
+		The complex refractive index of the particles.
+	wavelength : float
+		The wavelength of the incident light.
+	dp : float | Sequence[float]
+		Particle sizes.
+	ndp : float | Sequence[float]
+		Number concentration from SMPS or APS in the units of dN/dlogdp.
+	lognormal : bool, optional
+		Whether to use lognormal distribution for ndp. Default is False.
+	dp_range : tuple, optional
+		Range of particle sizes. Default is (1, 2500) nm.
+	geoMean : float, optional
+		Geometric mean of the particle size distribution. Default is 200 nm.
+	geoStdDev : float, optional
+		Geometric standard deviation of the particle size distribution. Default is 2.
+	numberOfParticles : float, optional
+		Number of particles. Default is 1e6.
+	numberOfBins : int, optional
+		Number of bins for the lognormal distribution. Default is 167.
+
+	Returns
+	-------
+	ext_dist : ndarray
+		The extinction distribution for the given data.
+	sca_dist : ndarray
+		The scattering distribution for the given data.
+	abs_dist : ndarray
+		The absorption distribution for the given data.
+
+	Notes
+	-----
+	return in "dext/dlogdp", please make sure input the dNdlogdp data.
+
+	Examples
+	--------
+	>>> Ext, Sca, Abs = Mie_PESD(m=complex(1.5, 0.02), wavelength=550, dp=[100, 200, 500, 1000], ndp=[100, 50, 30, 20])
+	"""
+	if lognormal:
+		dp = np.logspace(log10(dp_range[0]), log10(dp_range[1]), numberOfBins)
+
+		ndp = numberOfParticles * (1 / (log(geoStdDev) * sqrt(2 * pi)) *
+								   exp(-(log(dp) - log(geoMean)) ** 2 / (2 * log(geoStdDev) ** 2)))
+
+	# dN / dlogdp
+	ndp = np.atleast_1d(ndp)
+
+	Q_ext, Q_sca, Q_abs = Mie_Q(m, wavelength, dp)
+
+	# The 1e-6 here is so that the final value is the same as the unit 1/10^6m.
+	Ext = Q_ext * (pi / 4 * dp ** 2) * ndp * 1e-6
+	Sca = Q_sca * (pi / 4 * dp ** 2) * ndp * 1e-6
+	Abs = Q_abs * (pi / 4 * dp ** 2) * ndp * 1e-6
+
+	return Ext, Sca, Abs
+
+
+def internal(dist: pd.Series,
+			 dp: float | Sequence[float],
+			 wavelength: float = 550,
+			 result_type: Literal['extinction', 'scattering', 'absorption'] = 'extinction'
+			 ) -> np.ndarray:
+	"""
+	Calculate the extinction distribution by internal mixing model.
+
+	Parameters
+	----------
+	dist : pd.Series
+		Particle size distribution data.
+	dp : float | Sequence[float]
+		Diameter(s) of the particles, either a single value or a sequence.
+	wavelength : float, optional
+		Wavelength of the incident light, default is 550 nm.
+	result_type : {'extinction', 'scattering', 'absorption'}, optional
+		Type of result to calculate, defaults to 'extinction'.
+
+	Returns
+	-------
+	np.ndarray
+		Extinction distribution calculated based on the internal mixing model.
+	"""
+	ext_dist, sca_dist, abs_dist = Mie_PESD(m=complex(dist['n_amb'], dist['k_amb']),
+											wavelength=wavelength,
+											dp=dp,
+											ndp=np.array(dist[:np.size(dp)]))
+
+	if result_type == 'extinction':
+		return ext_dist
+	elif result_type == 'scattering':
+		return sca_dist
+	else:
+		return abs_dist
+
+	# return dict(ext=ext_dist, sca=sca_dist, abs=abs_dist)
+
+
+def external(dist: pd.Series,
+			 dp: float | Sequence[float],
+			 wavelength: float = 550,
+			 result_type: Literal['extinction', 'scattering', 'absorption'] = 'extinction'
+			 ) -> np.ndarray:
+	"""
+	Calculate the extinction distribution by external mixing model.
+
+	Parameters
+	----------
+	dist : pd.Series
+		Particle size distribution data.
+	dp : float | Sequence[float]
+		Diameter(s) of the particles, either a single value or a sequence.
+	wavelength : float, optional
+		Wavelength of the incident light, default is 550 nm.
+	result_type : {'extinction', 'scattering', 'absorption'}, optional
+		Type of result to calculate, defaults to 'extinction'.
+
+	Returns
+	-------
+	np.ndarray
+		Extinction distribution calculated based on the external mixing model.
+	"""
+	refractive_dic = {'AS_volume_ratio': complex(1.53, 0.00),
+					  'AN_volume_ratio': complex(1.55, 0.00),
+					  'OM_volume_ratio': complex(1.54, 0.00),
+					  'Soil_volume_ratio': complex(1.56, 0.01),
+					  'SS_volume_ratio': complex(1.54, 0.00),
+					  'EC_volume_ratio': complex(1.80, 0.54),
+					  'ALWC_volume_ratio': complex(1.33, 0.00)}
+
+	ndp = np.array(dist[:np.size(dp)])
+	mie_results = (
+		Mie_PESD(refractive_dic[_specie], wavelength, dp, dist[_specie] / (1 + dist['ALWC_volume_ratio']) * ndp) for
+		_specie in refractive_dic)
+
+	ext_dist, sca_dist, abs_dist = (np.sum([res[0] for res in mie_results], axis=0),
+									np.sum([res[1] for res in mie_results], axis=0),
+									np.sum([res[2] for res in mie_results], axis=0))
+
+	if result_type == 'extinction':
+		return ext_dist
+	elif result_type == 'scattering':
+		return sca_dist
+	else:
+		return abs_dist
+
+
+def core_shell():
+	pass
+
+
+def sensitivity():
+	pass
+
+
+if __name__ == '__main__':
+	result = Mie_Q(m=complex(1.5, 0.02), wavelength=550, dp=[100., 200.])

AeroViz/process/method/prop.py

@@ -0,0 +1,62 @@
+import numpy as np
+from numpy import exp, log
+from scipy.signal import find_peaks
+
+
+def geometric(dp: np.ndarray,
+			  dist: np.ndarray
+			  ) -> tuple[float, float]:
+	""" Calculate the geometric mean and standard deviation. """
+
+	_gmd = (((dist * log(dp)).sum()) / dist.sum())
+
+	logdp_mesh, gmd_mesh = np.meshgrid(log(dp), _gmd)
+	_gsd = ((((logdp_mesh - gmd_mesh) ** 2) * dist).sum() / dist.sum()) ** .5
+
+	return exp(_gmd), exp(_gsd)
+
+
+def contribution(dp: np.ndarray,
+				 dist: np.ndarray
+				 ) -> tuple[float, float, float]:
+	""" Calculate the relative contribution of each mode. """
+
+	ultra = dist[(dp >= 11.8) & (dp < 100)].sum() / dist.sum()
+	accum = dist[(dp >= 100) & (dp < 1000)].sum() / dist.sum()
+	coars = dist[(dp >= 1000) & (dp < 2500)].sum() / dist.sum()
+
+	return ultra, accum, coars
+
+
+def mode(dp: np.ndarray,
+		 dist: np.ndarray
+		 ) -> np.ndarray:
+	""" Find three peak mode in distribution. """
+
+	min_value = np.array([dist.min()])
+	mode, _ = find_peaks(np.concatenate([min_value, dist, min_value]), distance=len(dist) - 1)
+
+	return dp[mode - 1]
+
+
+def properties(dist,
+			   dp: np.ndarray,
+			   dlogdp: np.ndarray,
+			   weighting: str
+			   ) -> dict:
+	""" for apply """
+	dist = np.array(dist)
+
+	gmd, gsd = geometric(dp, dist)
+	ultra, accum, coarse = contribution(dp, dist)
+	peak = mode(dp, dist)
+
+	return {key: round(value, 3) for key, value in
+			{f'total_{weighting}': (dist * dlogdp).sum(),
+			 f'GMD_{weighting}': gmd,
+			 f'GSD_{weighting}': gsd,
+			 f'mode_{weighting}': peak[0],
+			 f'ultra_{weighting}': ultra,
+			 f'accum_{weighting}': accum,
+			 f'coarse_{weighting}': coarse}
+			.items()}

AeroViz/process/script/AbstractDistCalc.py

@@ -0,0 +1,143 @@
+from abc import ABC, abstractmethod
+from functools import partial
+from typing import Literal
+
+import numpy as np
+from pandas import DataFrame, concat
+
+from AeroViz.process.core.SizeDist import SizeDist
+from AeroViz.process.method import properties, internal, external, core_shell, sensitivity
+
+
+class AbstractDistCalc(ABC):
+	@abstractmethod
+	def useApply(self) -> DataFrame:
+		pass
+
+
+class NumberDistCalc(AbstractDistCalc):
+	def __init__(self, psd: SizeDist):
+		self.psd = psd
+
+	def useApply(self) -> DataFrame:
+		""" Calculate number distribution """
+		return self.psd.data
+
+
+class SurfaceDistCalc(AbstractDistCalc):
+	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)
+
+
+class VolumeDistCalc(AbstractDistCalc):
+	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)
+
+
+class PropertiesDistCalc(AbstractDistCalc):
+	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)
+
+
+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)
+
+
+# TODO:
+class LungDepositsDistCalc(AbstractDistCalc):
+
+	def __init__(self, psd: SizeDist, lung_curve):
+		self.psd = psd
+		self.lung_curve = lung_curve
+
+	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")

AeroViz/process/script/Chemical.py

@@ -0,0 +1,176 @@
+from pathlib import Path
+
+import numpy as np
+from pandas import read_csv, concat, notna, DataFrame
+
+from AeroViz.process.core import DataProc
+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

AeroViz/process/script/IMPACT.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+
+from pandas import DataFrame, read_csv, concat
+
+from AeroViz.process.core import DataProc
+from AeroViz.tools.datareader import DataReader
+
+
+class ImpactProc(DataProc):
+	"""
+	A class for processing impact data.
+
+	Parameters:
+	-----------
+	reset : bool, optional
+		If True, resets the processing. Default is False.
+	save_filename : str or Path, optional
+		The name or path to save the processed data. Default is 'IMPACT.csv'.
+
+	Methods:
+	--------
+	process_data(reset: bool = False, save_filename: str | Path = 'IMPACT.csv') -> DataFrame:
+		Process data and save the result.
+
+	save_data(data: DataFrame, save_filename: str | Path):
+		Save processed data to a file.
+
+	Attributes:
+	-----------
+	DEFAULT_PATH : Path
+		The default path for data files.
+
+	Examples:
+	---------
+	>>> df_custom = ImpactProc().process_data(reset=True, save_filename='custom_file.csv')
+	"""
+
+	def __init__(self, file_paths: list[Path | str] = None):
+		super().__init__()
+		self.file_paths = [Path(fp) for fp in file_paths]
+
+	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.to_csv(save_file)
+			return _df