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

AeroViz/plot/scatter.py

@@ -22,9 +22,11 @@ def scatter(df: pd.DataFrame,
             x: str,
             y: str,
             c: str | None = None,
+            color: str | None = '#7a97c9',
             s: str | None = None,
             cmap='jet',
             regression=False,
+            regression_line_color: str | None = sns.xkcd_rgb["denim blue"],
             diagonal=False,
             ax: Axes | None = None,
             **kwargs
@@ -41,6 +43,8 @@ def scatter(df: pd.DataFrame,
     y : str
         The column name for the y-axis values.
     c : str, optional
+        The column name for c encoding. Default is None.
+    color : str, optional
         The column name for color encoding. Default is None.
     s : str, optional
         The column name for size encoding. Default is None.
@@ -48,6 +52,8 @@ def scatter(df: pd.DataFrame,
         The colormap to use for the color encoding. Default is 'jet'.
     regression : bool, optional
         If True, fits and plots a linear regression line. Default is False.
+    regression_line_color : str, optional
+        The color of the regression line. Default is 'sns.xkcd_rgb["denim blue"]'.
     diagonal : bool, optional
         If True, plots a 1:1 diagonal line. Default is False.
     ax : Axes, optional
@@ -118,7 +124,7 @@ def scatter(df: pd.DataFrame,
         x_data, y_data, s_data = df_[x].to_numpy(), df_[y].to_numpy(), df_[s].to_numpy()
         check_empty(x_data, y_data, s_data)
 
-        scatter = ax.scatter(x_data, y_data, s=50 * (s_data / s_data.max()) ** 1.5, color='#7a97c9', alpha=0.7,
+        scatter = ax.scatter(x_data, y_data, s=50 * (s_data / s_data.max()) ** 1.5, color=color, alpha=0.5,
                              edgecolors='white')
         colorbar = False
 
@@ -135,7 +141,7 @@ def scatter(df: pd.DataFrame,
         x_data, y_data = df_[x].to_numpy(), df_[y].to_numpy()
         check_empty(x_data, y_data)
 
-        scatter = ax.scatter(x_data, y_data, s=30, color='#7a97c9', alpha=0.7, edgecolors='white')
+        scatter = ax.scatter(x_data, y_data, s=30, color=color, alpha=0.5, edgecolors='white')
         colorbar = False
 
     ax.set(xlim=kwargs.get('xlim', (x_data.min(), x_data.max())),
@@ -144,21 +150,24 @@ def scatter(df: pd.DataFrame,
            ylabel=kwargs.get('ylabel', Unit(y)),
            title=kwargs.get('title', ''))
 
+    ax.xaxis.set_major_formatter(ScalarFormatter())
+    ax.yaxis.set_major_formatter(ScalarFormatter())
+
     if colorbar:
         plt.colorbar(scatter, extend='both', label=Unit(c))
 
     if regression:
         text, y_predict, slope = linear_regression_base(x_data, y_data)
-        ax.plot(x_data, y_predict, linewidth=3, color=sns.xkcd_rgb["denim blue"], alpha=1, zorder=3)
-        plt.text(0.05, 0.95, text, fontdict={'weight': 'bold'}, color=sns.xkcd_rgb["denim blue"],
+        ax.plot(x_data, y_predict, linewidth=3, color=regression_line_color, alpha=1, zorder=3)
+        plt.text(0.05, 0.95, text, fontdict={'weight': 'bold'}, color=regression_line_color,
                  ha='left', va='top', transform=ax.transAxes)
 
     if diagonal:
         ax.axline((0, 0), slope=1., color='k', lw=2, ls='--', alpha=0.5, label='1:1')
-        plt.text(0.91, 0.97, r'$\bf 1:1\ Line$', color='k', ha='right', va='top', transform=ax.transAxes)
 
-    ax.xaxis.set_major_formatter(ScalarFormatter())
-    ax.yaxis.set_major_formatter(ScalarFormatter())
+        data_range = min(ax.get_xlim()[1] - ax.get_xlim()[0], ax.get_ylim()[1] - ax.get_ylim()[0])
+        plt.text(0.9 * data_range, 0.9 * data_range, r'$\bf 1:1\ Line$', color='k', ha='left', va='bottom',
+                 bbox=dict(facecolor='white', edgecolor='none', alpha=0.1, pad=3))
 
     plt.show()
 

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/templates/koschmieder.py

@@ -10,7 +10,7 @@ from AeroViz.plot.utils import *
 __all__ = ['koschmieder']
 
 
-@set_figure
+@set_figure(figsize=(2.4, 3))
 def koschmieder(df: pd.DataFrame,
                 vis: str,
                 ext: list[str],
@@ -30,8 +30,8 @@ def koschmieder(df: pd.DataFrame,
 
     fig, ax = plt.subplots(**kwargs.get('fig_kws', {})) if ax is None else (ax.get_figure(), ax)
 
-    boxcolors = ['#3f83bf', '#a5bf6b']
-    scattercolor = ['blue', 'green']
+    boxcolors = ['#a5bf6b', '#3f83bf']
+    scattercolor = ['green', 'blue']
     arts = []
     labels = []
 
@@ -74,15 +74,18 @@ def koschmieder(df: pd.DataFrame,
                         label=f'Vis (km) = {round(coeff)} / Ext')
 
         arts.append(line)
-        labels.append(f'Vis (km) = {round(coeff)} / Ext')
+        if 'dry' in ext_col:
+            labels.append(f'Vis (km) = {round(coeff)} / Ext (dry)')
+        else:
+            labels.append(f'Vis (km) = {round(coeff)} / Ext (amb)')
 
     ax.legend(handles=arts, labels=labels, loc='upper right', prop=dict(weight='bold'), bbox_to_anchor=(0.99, 0.99))
 
-    ax.set(xlabel=kwargs.get('xlim', 'Visibility (km)'),
-           ylabel=kwargs.get('xlim', 'Extinction (1/Mm)'),
-           title=kwargs.get('ylim', 'Koschmieder relationship'),
+    ax.set(xlabel=kwargs.get('xlabel', 'Visibility (km)'),
+           ylabel=kwargs.get('ylabel', 'Extinction (1/Mm)'),
+           title=kwargs.get('title', 'Koschmieder relationship'),
            xlim=kwargs.get('xlim', (0, 30)),
-           ylim=kwargs.get('ylim', (0, 500))
+           ylim=kwargs.get('ylim', (0, 800))
            )
 
     plt.xticks(ticks=np.array(range(0, 31, 5)), labels=np.array(range(0, 31, 5)))

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)
 
@@ -348,7 +389,6 @@ def timeseries_stacked(df,
             ylabel=kwargs.get('ylabel', 'Percentage (%)'),
             xlim=kwargs.get('xlim', (st_tm, fn_tm)),
             ylim=(0, 100),
-            title=kwargs.get('title', '')
             )
 
     xticks = kwargs.get('xticks', date_range(start=st_tm, end=fn_tm, freq=major_freq))

AeroViz/rawDataReader/__init__.py

@@ -1,104 +1,111 @@
 from datetime import datetime
 from pathlib import Path
 
+from pandas import Grouper, Timedelta
+
 from AeroViz.rawDataReader.config.supported_instruments import meta
 from AeroViz.rawDataReader.script import *
 
 __all__ = ['RawDataReader']
 
+SUPPORTED_INSTRUMENTS = [
+    NEPH, Aurora, SMPS, GRIMM, APS_3321, AE33, AE43, BC1054,
+    MA350, TEOM, OCEC, IGAC, VOC, EPA, Minion
+]
+
 
 def RawDataReader(instrument_name: str,
-                  path: Path,
-                  qc: bool = True,
-                  csv_raw: bool = True,
+                  path: Path | str,
                   reset: bool = False,
+                  qc: bool | str = True,
+                  qc_freq: str | None = None,
                   rate: bool = True,
                   append_data: bool = False,
-                  start: datetime | None = None,
-                  end: datetime | None = None,
-                  mean_freq='1h',
-                  csv_out=True,
+                  start: datetime = None,
+                  end: datetime = None,
+                  mean_freq: str = '1h',
+                  csv_out: bool = True,
                   ):
     """
     Factory function to instantiate the appropriate reader module for a given instrument and
     return the processed data over the specified time range.
 
-    Parameters
-    ----------
-    instrument_name : str
-        The name of the instrument for which to read data. Must be a valid key in the `meta` dictionary.
-    path : Path
-        The directory where raw data files for the instrument are stored.
-    qc : bool, optional (default=True)
-        If True, apply quality control (QC) to the raw data.
-    csv_raw : bool, optional (default=True)
-        If True, read raw data from CSV files.
-    reset : bool, optional (default=False)
-        If True, reset the state and reprocess the data from scratch.
-    rate : bool, optional (default=False)
-        If True, calculate rates from the data.
-    append_data : bool, optional (default=False)
-        If True, append new data to the existing dataset instead of overwriting it.
-    start : datetime, optional
-        Start time for filtering the data. If None, no start time filtering will be applied.
-    end : datetime, optional
-        End time for filtering the data. If None, no end time filtering will be applied.
-    mean_freq : str, optional (default='1h')
-        Resampling frequency for averaging the data. Example: '1h' for hourly mean.
-    csv_out : bool, optional (default=True)
-        If True, output the processed data as a CSV file.
-
-    Return
-    ------
-    reader_module : Reader
-        An instance of the reader module corresponding to the specified instrument, which processes
-        the data and returns it in a usable format.
-
-    Raises
-    ------
-    ValueError
-        If the `instrument_name` provided is not a valid key in the `meta` dictionary.
-
-    Example
-    -------
+    :param instrument_name: The name of the instrument for which to read data. Must be a valid key in the `meta` dictionary.
+    :param path: The directory where raw data files for the instrument are stored.
+    :param reset: If True, reset the state and reprocess the data from scratch.
+    :param qc: If True, apply quality control (QC) to the raw data.
+    :param qc_freq: Frequency at which to perform QC. Must be one of 'W', 'M', 'Q', 'Y' for weekly, monthly, quarterly, or yearly.
+    :param rate: If True, calculate rates from the data.
+    :param append_data: If True, append new data to the existing dataset instead of overwriting it.
+    :param start: Start time for filtering the data. If None, no start time filtering will be applied.
+    :param end: End time for filtering the data. If None, no end time filtering will be applied.
+    :param mean_freq: Resampling frequency for averaging the data. Example: '1h' for hourly mean.
+    :param csv_out: If True, output the processed data as a CSV file.
+
+    :return: An instance of the reader module corresponding to the specified instrument, which processes the data and returns it in a usable format.
+
+    :raises ValueError: If the `instrument_name` provided is not a valid key in the `meta` dictionary.
+    :raises ValueError: If the specified path does not exist or is not a directory.
+    :raises ValueError: If the QC frequency is invalid.
+    :raises ValueError: If start and end times are not both provided or are invalid.
+    :raises ValueError: If the mean_freq is not a valid frequency string.
+
+    :Example:
+
     To read and process data for the BC1054 instrument:
 
     >>> from pathlib import Path
     >>> from datetime import datetime
-    >>> data = RawDataReader(instrument_name='BC1054', path=Path('/path/to/data'),
-    >>>                      start=datetime(2024, 1, 1), end=datetime(2024, 2, 1))
+    >>>
+    >>> data = RawDataReader(
+    ...     instrument_name='BC1054',
+    ...     path=Path('/path/to/data'),
+    ...     start=datetime(2024, 2, 1),
+    ...     end=datetime(2024, 7, 31, 23))
     """
     # Mapping of instrument names to their respective classes
-    instrument_class_map = {
-        'NEPH': NEPH,
-        'Aurora': Aurora,
-        'SMPS': SMPS,
-        'GRIMM': GRIMM,
-        'APS_3321': APS_3321,
-        'AE33': AE33,
-        'AE43': AE43,
-        'BC1054': BC1054,
-        'MA350': MA350,
-        'TEOM': TEOM,
-        'OCEC': OCEC,
-        'IGAC': IGAC,
-        'VOC': VOC,
-        'Table': Table,
-        'EPA_vertical': EPA_vertical,
-        'Minion': Minion
-        # Add other instruments and their corresponding classes here
-    }
+    instrument_class_map = {cls.__name__.split('.')[-1]: cls for cls in SUPPORTED_INSTRUMENTS}
 
     # Check if the instrument name is in the map
     if instrument_name not in meta.keys():
         raise ValueError(f"Instrument name '{instrument_name}' is not valid. \nMust be one of: {list(meta.keys())}")
 
+    # 檢查 path 是否存在且是一個目錄
+    if not isinstance(path, Path):
+        path = Path(path)
+    if not path.exists() or not path.is_dir():
+        raise ValueError(f"The specified path '{path}' does not exist or is not a directory.")
+
+    # Validate the QC frequency
+    if qc_freq is not None:
+        try:
+            Grouper(freq=qc_freq)
+        except ValueError as e:
+            raise ValueError(f"Invalid frequency: {qc_freq}. Error: {str(e)}")
+        except TypeError as e:
+            raise ValueError(f"Invalid frequency type: {qc_freq}. Frequency should be a string.")
+
+    if start and end:
+        if end.hour == 0 and end.minute == 0 and end.second == 0:
+            end = end.replace(hour=23, minute=59, second=59)
+    else:
+        raise ValueError("Both start and end times must be provided.")
+    if end <= start:
+        raise ValueError(f"Invalid time range: start {start} is after end {end}")
+
+    # 驗證 mean_freq 的格式是否正確
+    try:
+        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').")
+
     # Instantiate the class and return the instance
     reader_module = instrument_class_map[instrument_name].Reader(
         path=path,
-        qc=qc,
-        csv_raw=csv_raw,
         reset=reset,
+        qc=qc,
+        qc_freq=qc_freq,
         rate=rate,
         append_data=append_data
     )

AeroViz/rawDataReader/config/supported_instruments.py

@@ -95,6 +95,53 @@ meta = {
         },
     },
 
+    "XRF": {
+        "pattern": ["*.csv"],
+        "freq": "1h",
+        "deter_key": {
+            "Al": ["Al"],
+            "Si": ["Si"],
+            "P": ["P"],
+            "S": ["S"],
+            "Cl": ["Cl"],
+            "K": ["K"],
+            "Ca": ["Ca"],
+            "Ti": ["Ti"],
+            "V": ["V"],
+            "Cr": ["Cr"],
+            "Mn": ["Mn"],
+            "Fe": ["Fe"],
+            "Ni": ["Ni"],
+            "Cu": ["Cu"],
+            "Zn": ["Zn"],
+            "As": ["As"],
+            "Se": ["Se"],
+            "Br": ["Br"],
+            "Rb": ["Rb"],
+            "Sr": ["Sr"],
+            "Y": ["Y"],
+            "Zr": ["Zr"],
+            "Mo": ["Mo"],
+            "Ag": ["Ag"],
+            "Cd": ["Cd"],
+            "In": ["In"],
+            "Sn": ["Sn"],
+            "Sb": ["Sb"],
+            "Te": ["Te"],
+            "Cs": ["Cs"],
+            "Ba": ["Ba"],
+            "La": ["La"],
+            "Ce": ["Ce"],
+            "W": ["W"],
+            "Pt": ["Pt"],
+            "Au": ["Au"],
+            "Hg": ["Hg"],
+            "Tl": ["Tl"],
+            "Pb": ["Pb"],
+            "Bi": ["Bi"],
+        },
+    },
+
     "VOC": {
         "pattern": ["*.csv"],
         "freq": "1h",
@@ -116,32 +163,18 @@ meta = {
         "deter_key": None,
     },
 
-    "Table": {
+    "EPA": {
         "pattern": ["*.csv"],
         "freq": "1h",
-        "deter_key": None,
-    },
-
-    "EPA_vertical": {
-        "pattern": ["*.csv"],
-        "freq": "1h",
-        "deter_key": None,
+        "deter_key": {"Items": ["all"]},
     },
 
     "Minion": {
-        "pattern": ["*.csv"],
+        "pattern": ["*.csv", "*.xlsx"],
         "freq": "1h",
         "deter_key": {
-            "Na+": ["Na+"],
-            "NH4+": ["NH4+"],
-            "K+": ["K+"],
-            "Mg2+": ["Mg2+"],
-            "Ca2+": ["Ca2+"],
-            "Cl-": ["Cl-"],
-            "NO2-": ["NO2-"],
-            "NO3-": ["NO3-"],
-            "SO42-": ["SO42-"],
-            "Main Salt (NH4+, NO3-, SO42-)": ["NO3-", "SO42-", "NH4+"],
+            "Main Salt (Na+, NH4+, Cl-, NO3-, SO42-)": ["Na+", "NH4+", "Cl-", "NO3-", "SO42-"],
+            "XRF (Al, Ti, V, Cr, Mn, Fe)": ["Al", "Ti", "V", "Cr", "Mn", "Fe"],
         },
     },
 }