AeroViz 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

AeroViz/process/method/mie_theory.py

@@ -1,260 +0,0 @@
-from typing import Sequence, Literal
-
-import numpy as np
-import pandas as pd
-from numpy import exp, log, log10, sqrt, pi
-
-from .PyMieScatt_update import AutoMieQ
-
-
-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

@@ -1,62 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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', 'config-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

@@ -1,177 +0,0 @@
-from pathlib import Path
-
-import numpy as np
-from pandas import read_csv, concat, notna, DataFrame, to_numeric
-
-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 / 1000
-        _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).apply(to_numeric, errors='coerce')
-
-            df_mass = df[['NH4+', 'SO42-', 'NO3-', 'Optical_OC', 'Fe', 'Na+', 'Optical_EC', 'PM2.5']].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

@@ -1,49 +0,0 @@
-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