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

AeroViz/plot/optical/mie_theory.py

@@ -0,0 +1,260 @@
+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/plot/optical/optical.py

@@ -6,13 +6,14 @@ import numpy as np
 # from PyMieScatt import ScatteringFunction
 from matplotlib.pyplot import Figure, Axes
 
+from AeroViz.plot.optical.PyMieScatt_update import ScatteringFunction
+from AeroViz.plot.optical.mie_theory import Mie_Q, Mie_MEE, Mie_PESD
 from AeroViz.plot.utils import *
-from temp.process.method.mie_theory import Mie_Q, Mie_MEE, Mie_PESD
 
 __all__ = ['Q_plot',
            'RI_couple',
            'RRI_2D',
-           # 'scattering_phase',
+           'scattering_phase',
            'response_surface',
            ]
 
@@ -252,59 +253,59 @@ def RRI_2D(mode: Literal["ext", "sca", "abs"] = 'ext',
     return fig, ax
 
 
-# @set_figure
-# def scattering_phase(m: complex = 1.55 + 0.01j,
-#                      wave: float = 600,
-#                      dp: float = 200) -> tuple[Figure, Axes]:
-#     """
-#     Generate a polar plot to visualize the scattering phase function.
-#
-#     Parameters
-#     ----------
-#     m : complex, optional
-#         The complex refractive index of the scattering medium. Default is 1.55 + 0.01j.
-#     wave : float, optional
-#         The wavelength of the incident light in nanometers. Default is 600 nm.
-#     dp : float, optional
-#         The particle diameter in nanometers. Default is 200 nm.
-#
-#     Returns
-#     -------
-#     ax : Axes
-#         Matplotlib Axes object containing the generated polar plot.
-#
-#     Examples
-#     --------
-#     Example usage of the scattering_phase function:
-#
-#     >>> ax = scattering_phase(m=1.55 + 0.01j, wave=600, dp=200)
-#     """
-#     theta, _SL, _SR, _SU = ScatteringFunction(m, wave, dp)
-#
-#     SL = np.append(_SL, _SL[::-1])
-#     SR = np.append(_SR, _SR[::-1])
-#     SU = np.append(_SU, _SU[::-1])
-#
-#     angles = ['0', '60', '120', '180', '240', '300']
-#
-#     fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
-#
-#     theta = np.linspace(0, 2 * np.pi, len(SL))
-#
-#     plt.thetagrids(range(0, 360, int(360 / len(angles))), angles)
-#
-#     plt.plot(theta, SL, '-', linewidth=2, color='#115162', label='SL')
-#     plt.fill(theta, SL, '#afe0f5', alpha=0.5)
-#     plt.plot(theta, SR, '-', linewidth=2, color='#7FAE80', label='SR')
-#     plt.fill(theta, SR, '#b5e6c5', alpha=0.5)
-#     plt.plot(theta, SU, '-', linewidth=2, color='#621129', label='SU')
-#     plt.fill(theta, SU, '#f5afbd', alpha=0.5)
-#
-#     plt.legend(loc='best', bbox_to_anchor=(1, 0, 0.2, 1), prop={'weight': 'bold'})
-#     plt.title(r'$\bf Scattering\ phase\ function$')
-#
-#     plt.show()
-#     return fig, ax
+@set_figure
+def scattering_phase(m: complex = 1.55 + 0.01j,
+                     wave: float = 600,
+                     dp: float = 200) -> tuple[Figure, Axes]:
+    """
+    Generate a polar plot to visualize the scattering phase function.
+
+    Parameters
+    ----------
+    m : complex, optional
+        The complex refractive index of the scattering medium. Default is 1.55 + 0.01j.
+    wave : float, optional
+        The wavelength of the incident light in nanometers. Default is 600 nm.
+    dp : float, optional
+        The particle diameter in nanometers. Default is 200 nm.
+
+    Returns
+    -------
+    ax : Axes
+        Matplotlib Axes object containing the generated polar plot.
+
+    Examples
+    --------
+    Example usage of the scattering_phase function:
+
+    >>> ax = scattering_phase(m=1.55 + 0.01j, wave=600, dp=200)
+    """
+    theta, _SL, _SR, _SU = ScatteringFunction(m, wave, dp)
+
+    SL = np.append(_SL, _SL[::-1])
+    SR = np.append(_SR, _SR[::-1])
+    SU = np.append(_SU, _SU[::-1])
+
+    angles = ['0', '60', '120', '180', '240', '300']
+
+    fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
+
+    theta = np.linspace(0, 2 * np.pi, len(SL))
+
+    plt.thetagrids(range(0, 360, int(360 / len(angles))), angles)
+
+    plt.plot(theta, SL, '-', linewidth=2, color='#115162', label='SL')
+    plt.fill(theta, SL, '#afe0f5', alpha=0.5)
+    plt.plot(theta, SR, '-', linewidth=2, color='#7FAE80', label='SR')
+    plt.fill(theta, SR, '#b5e6c5', alpha=0.5)
+    plt.plot(theta, SU, '-', linewidth=2, color='#621129', label='SU')
+    plt.fill(theta, SU, '#f5afbd', alpha=0.5)
+
+    plt.legend(loc='best', bbox_to_anchor=(1, 0, 0.2, 1), prop={'weight': 'bold'})
+    plt.title(r'$\bf Scattering\ phase\ function$')
+
+    plt.show()
+    return fig, ax
 
 
 @set_figure
@@ -368,7 +369,7 @@ def response_surface(real_range=(1.33, 1.7),
     ax.plot_surface(real, gmd, ext, rstride=1, cstride=1, cmap=plt.get_cmap('jet'), edgecolor='none')
 
     ax.set(xlabel='Real part (n)', ylabel='GMD (nm)', zlabel=Unit('Extinction'),
-           title='Sensitive tests of Extinction')
+           title='Sensitive tests of extinction')
 
     ax.zaxis.get_offset_text().set_visible(False)
     exponent = math.floor(math.log10(np.max(ext)))
@@ -381,8 +382,8 @@ def response_surface(real_range=(1.33, 1.7),
 
 
 if __name__ == '__main__':
-    # Q_plot(['AS', 'AN', 'OM', 'Soil', 'SS', 'BC'], x='dp', y='MEE')
-    # Q_plot(['AS', 'AN', 'OM', 'Soil', 'SS', 'BC'], x='dp', y='Q')
+    Q_plot(['AS', 'AN', 'OM', 'Soil', 'SS', 'BC'], x='dp', y='MEE')
+    Q_plot(['AS', 'AN', 'OM', 'Soil', 'SS', 'BC'], x='dp', y='Q')
 
-    # RI_couple()
+    RI_couple()
     response_surface()

AeroViz/plot/templates/diurnal_pattern.py

@@ -15,30 +15,47 @@ def diurnal_pattern(df: DataFrame,
                     ax: Axes | None = None,
                     **kwargs
                     ) -> tuple[Figure, Axes]:
-    if 'hour' or 'Hour' not in df.columns:
+    if 'hour' not in df.columns and 'Hour' not in df.columns:
         df['Hour'] = df.index.hour
 
     Hour = range(0, 24)
     mean = df.groupby('Hour')[y].mean()
     std = df.groupby('Hour')[y].std() * std_area
 
-    fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
+    fig, ax = plt.subplots() if ax is None else (ax.get_figure(), ax)
 
     # Plot Diurnal pattern
-    ax.plot(Hour, mean, 'blue')
-    ax.fill_between(Hour, y1=mean + std, y2=mean - std, alpha=0.2, color='blue', edgecolor=None)
+    ax.plot(Hour, mean, 'blue', zorder=3)
+    ax.fill_between(Hour, y1=mean + std, y2=mean - std, alpha=0.2, color='blue', edgecolor=None, zorder=2)
+
+    # Plot Boxplot for each hour
+    bp = ax.boxplot([df[df['Hour'] == h][y].dropna() for h in Hour],
+                    positions=Hour,
+                    widths=0.5,
+                    patch_artist=True,
+                    showfliers=False,
+                    zorder=1)
+
+    # Customize boxplot colors
+    for element in ['boxes', 'whiskers', 'fliers', 'means', 'medians', 'caps']:
+        plt.setp(bp[element], color='gray')
+
+    for patch in bp['boxes']:
+        patch.set(facecolor='lightgray', alpha=0.5)
 
     ax.set(xlabel=kwargs.get('xlabel', 'Hours'),
            ylabel=kwargs.get('ylabel', Unit(y)),
-           xlim=kwargs.get('xlim', (0, 23)),
+           xlim=kwargs.get('xlim', (-0.5, 23.5)),
            ylim=kwargs.get('ylim', (None, None)),
-           xticks=kwargs.get('xticks', [0, 4, 8, 12, 16, 20]))
+           xticks=kwargs.get('xticks', range(0, 24, 4)),
+           xticklabels=kwargs.get('xticklabels', range(0, 24, 4)))
 
     ax.tick_params(axis='both', which='major')
     ax.tick_params(axis='x', which='minor')
     ax.xaxis.set_minor_locator(AutoMinorLocator())
     ax.ticklabel_format(axis='y', style='sci', scilimits=(-2, 3), useMathText=True)
 
+    plt.tight_layout()
     plt.show()
 
-    return fig, ax
+    return fig, ax

AeroViz/plot/timeseries/template.py

@@ -2,7 +2,7 @@ import matplotlib.pyplot as plt
 from matplotlib.pyplot import Figure, Axes
 from pandas import DataFrame
 
-from AeroViz.plot.timeseries import timeseries
+from AeroViz.plot.timeseries.timeseries import timeseries
 
 
 def timeseries_template(df: DataFrame) -> tuple[Figure, Axes]:
@@ -40,7 +40,7 @@ def timeseries_template(df: DataFrame) -> tuple[Figure, Axes]:
     timeseries(df, y='VC', color='PBLH', style='bar', ax=ax4, bar_kws=dict(cmap='Blues'), set_xaxis_visible=False,
                ylim=[0, 5000])
 
-    timeseries(df, y='PM25', color='PM1/PM25', style='scatter', ax=ax5, ylim=[0, None])
+    timeseries(df, y='PM2.5', color='PM1/PM25', style='scatter', ax=ax5, ylim=[0, None])
 
     plt.show()
 

AeroViz/plot/timeseries/timeseries.py

@@ -4,8 +4,9 @@ import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib.cm import ScalarMappable
 from matplotlib.pyplot import Figure, Axes
+from mpl_toolkits.axes_grid1 import make_axes_locatable
 from mpl_toolkits.axes_grid1.inset_locator import inset_axes
-from pandas import DataFrame, date_range
+from pandas import DataFrame, date_range, Timedelta
 
 from AeroViz.plot.utils import *
 
@@ -70,6 +71,40 @@ def _plot(ax, df, _y, _color, plot_kws):
     ax.plot(df.index, df[_y], color=_color, **plot_kws)
 
 
+def _wind_arrow(ax, df, y, c, scatter_kws, cbar_kws, inset_kws):
+    """
+    Plot wind arrows on a scatter plot.
+
+    :param ax: matplotlib axes
+    :param df: pandas DataFrame
+    :param y: column name for wind speed
+    :param c: column name for wind direction
+    :param scatter_kws: keyword arguments for scatter plot
+    :param cbar_kws: keyword arguments for colorbar
+    :param inset_kws: keyword arguments for inset axes
+    """
+    # First, create a scatter plot
+    sc = ax.scatter(df.index, df[y], c=df[c], **scatter_kws)
+
+    # Add colorbar
+    divider = make_axes_locatable(ax)
+    cax = divider.append_axes("right", size="2%", pad=0.05)
+    plt.colorbar(sc, cax=cax, **cbar_kws)
+
+    # Add wind arrows
+    for idx, row in df.iterrows():
+        wind_speed = row[y]
+        wind_dir = np.radians(row[c])
+        dx = np.sin(wind_dir) * wind_speed / 20  # Scale factor can be adjusted
+        dy = np.cos(wind_dir) * wind_speed / 20
+        ax.annotate('', xy=(idx + 10 * dx * Timedelta(hours=5), wind_speed + 4 * dy),
+                    xytext=(idx - 10 * dx * Timedelta(hours=5), wind_speed - 4 * dy),
+                    arrowprops=dict(arrowstyle='->', color='k', linewidth=0.5))
+
+    # Set the x-axis limit to show all data points
+    # ax.set_xlim(df.index.min() - datetime.timedelta(days=1), df.index.max())
+
+
 def process_timeseries_data(df, rolling=None, interpolate_limit=None):
     # apply rolling window if specified
     df = df.rolling(window=rolling, min_periods=1).mean(numeric_only=True) if rolling is not None else df
@@ -90,7 +125,7 @@ def timeseries(df: DataFrame,
                interpolate_limit: int | None = 6,
                major_freq: str = '1MS',
                minor_freq: str = '10d',
-               style: list[Literal['scatter', 'bar', 'line']] | str | None = None,
+               style: list[Literal['scatter', 'bar', 'line', 'arrow']] | str | None = None,
                ax: Axes | None = None,
                set_xaxis_visible: bool | None = None,
                legend_loc: Literal['best', 'upper right', 'upper left', 'lower left', 'lower right'] = 'best',
@@ -199,16 +234,16 @@ def timeseries(df: DataFrame,
     if y2 and ('scatter' or 'bar') in style:
         fig.subplots_adjust(right=0.8)
 
-    for i, _c in enumerate(color):
-        if _c is not None and _c in df.columns:
-            style[i] = 'scatter'
+    # for i, _c in enumerate(color):
+    #     if _c is not None and _c in df.columns:
+    #         style[i] = 'scatter'
 
     for i, (_y, _c, _label, _style) in enumerate(zip(y, color, label, style)):
         scatter_kws = {**default_scatter_kws, **{'label': Unit(_y)}, **kwargs.get('scatter_kws', {})}
         bar_kws = {**default_bar_kws, **{'label': Unit(_y)}, **kwargs.get('bar_kws', {})}
         plot_kws = {**default_plot_kws, **{'label': Unit(_y)}, **kwargs.get('plot_kws', {})}
 
-        if _style in ['scatter', 'bar']:
+        if _style in ['scatter', 'bar', 'arrow']:
             cbar_kws = {**default_cbar_kws, **{'label': Unit(_c), 'ticks': None}, **kwargs.get('cbar_kws', {})}
             inset_kws = {**default_insert_kws, **{'bbox_transform': ax.transAxes}, **kwargs.get('inset_kws', {})}
 
@@ -218,6 +253,9 @@ def timeseries(df: DataFrame,
         elif _style == 'bar':
             _bar(ax, df, _y, _c, bar_kws, cbar_kws, inset_kws)
 
+        elif _style == 'arrow':
+            _wind_arrow(ax, df, _y, _c, scatter_kws, cbar_kws, inset_kws)
+
         else:
             _plot(ax, df, _y, _c, plot_kws)
 
@@ -237,6 +275,9 @@ def timeseries(df: DataFrame,
             elif _style == 'bar':
                 _bar(ax2, df, _y, _c, bar_kws, cbar_kws, inset_kws)
 
+            elif _style == 'arrow':
+                pass
+
             else:  # line plot
                 _plot(ax2, df, _y, _c, plot_kws)
 

AeroViz/rawDataReader/__init__.py

@@ -15,7 +15,7 @@ SUPPORTED_INSTRUMENTS = [
 
 
 def RawDataReader(instrument_name: str,
-                  path: Path,
+                  path: Path | str,
                   reset: bool = False,
                   qc: bool | str = True,
                   qc_freq: str | None = None,
@@ -87,7 +87,7 @@ def RawDataReader(instrument_name: str,
 
     if start and end:
         if end.hour == 0 and end.minute == 0 and end.second == 0:
-            end = end.replace(hour=23)
+            end = end.replace(hour=23, minute=59, second=59)
     else:
         raise ValueError("Both start and end times must be provided.")
     if end <= start:
@@ -98,7 +98,7 @@ def RawDataReader(instrument_name: str,
         Timedelta(mean_freq)
     except ValueError:
         raise ValueError(
-            f"Invalid mean_freq: '{mean_freq}'. It should be a valid frequency string (e.g., '1H', '30min', '1D').")
+            f"Invalid mean_freq: '{mean_freq}'. It should be a valid frequency string (e.g., '1h', '30min', '1D').")
 
     # Instantiate the class and return the instance
     reader_module = instrument_class_map[instrument_name].Reader(