pydartdiags 0.0.42__py3-none-any.whl → 0.5.0__py3-none-any.whl

pydartdiags/plots/plots.py

@@ -1,161 +1,191 @@
-
+# SPDX-License-Identifier: Apache-2.0
 import numpy as np
 import plotly.express as px
+import plotly.graph_objects as go
 import pandas as pd
+from pydartdiags.stats import stats
+
 
-def plot_rank_histogram(df):  
+def plot_rank_histogram(df, phase, ens_size):
     """
     Plots a rank histogram colored by observation type.
 
-    All histogram bars are initalized to be hidden and can be toggled visible in the plot's legend
+    All histogram bars are initialized to be hidden and can be toggled visible in the plot's legend
     """
-    _, _, df_hist = calculate_rank(df)
-    fig = px.histogram(df_hist, x='rank', color='obstype', title='Histogram Colored by obstype')
+    fig = px.histogram(
+        df,
+        x=f"{phase}_rank",
+        color="type",
+        title="Histogram Colored by obs type",
+        nbins=ens_size,
+    )
+    fig.update_xaxes(range=[1, ens_size + 1])
     for trace in fig.data:
-        trace.visible = 'legendonly'
+        trace.visible = "legendonly"
     fig.show()
 
 
-def calculate_rank(df):
-    """
-    Calculate the rank of observations within an ensemble.
-
-    This function takes a DataFrame containing ensemble predictions and observed values,
-    adds sampling noise to the ensemble predictions, and calculates the rank of the observed
-    value within the perturbed ensemble for each observation. The rank indicates the position
-    of the observed value within the sorted ensemble values, with 1 being the lowest. If the
-    observed value is larger than the largest ensemble member, its rank is set to the ensemble
-    size plus one.
-
-    Parameters:
-        df (pd.DataFrame): A DataFrame with columns for mean, standard deviation, observed values,
-                           ensemble size, and observation type. The DataFrame should have one row per observation.
+def plot_profile(df_in, verticalUnit):
+    """Assumes diag_stats has been run on the dataframe and the resulting dataframe is passed in"""
 
-    Returns:
-        tuple: A tuple containing the rank array, ensemble size, and a result DataFrame. The result
-        DataFrame contains columns for 'rank' and 'obstype'.
-    """
-    ensemble_values = df.filter(regex='prior_ensemble_member').to_numpy().copy()
-    std_dev = np.sqrt(df['obs_err_var']).to_numpy()
-    obsvalue = df['observation'].to_numpy()
-    obstype = df['type'].to_numpy()
-    ens_size = ensemble_values.shape[1]
-    mean = 0.0 # mean of the sampling noise
-    rank = np.zeros(obsvalue.shape[0], dtype=int)
-    
-    for obs in range(ensemble_values.shape[0]):
-        sampling_noise = np.random.normal(mean, std_dev[obs], ens_size)
-        ensemble_values[obs] += sampling_noise
-        ensemble_values[obs].sort()
-        for i, ens in enumerate(ensemble_values[obs]):
-            if obsvalue[obs] <= ens:
-                rank[obs] = i + 1
-                break
-
-        if rank[obs] == 0: # observation is larger than largest ensemble member
-            rank[obs] = ens_size + 1
-
-    result_df = pd.DataFrame({
-        'rank': rank,
-        'obstype': obstype
-    })
-
-    return (rank, ens_size, result_df)
-
-def plot_profile(df, levels):
-    """
-    Plots RMSE and Bias profiles for different observation types across specified pressure levels.
-
-    This function takes a DataFrame containing observational data and model predictions, categorizes
-    the data into specified pressure levels, and calculates the RMSE and Bias for each level and
-    observation type. It then plots two line charts: one for RMSE and another for Bias, both as functions
-    of pressure level. The pressure levels are plotted on the y-axis in reversed order to represent
-    the vertical profile in the atmosphere correctly.
+    df = stats.layer_statistics(df_in)
+    if "posterior_rmse" in df.columns:
+        fig_rmse = plot_profile_prior_post(df, "rmse", verticalUnit)
+        fig_rmse.show()
+        fig_bias = plot_profile_prior_post(df, "bias", verticalUnit)
+        fig_bias.show()
+        fig_ts = plot_profile_prior_post(df, "totalspread", verticalUnit)
+        fig_ts.show()
+    else:
+        fig_rmse = plot_profile_prior(df, "rmse", verticalUnit)
+        fig_rmse.show()
+        fig_bias = plot_profile_prior(df, "bias", verticalUnit)
+        fig_bias.show()
+        fig_ts = plot_profile_prior(df, "totalspread", verticalUnit)
+        fig_ts.show()
 
-    Parameters:
-        df (pd.DataFrame): The input DataFrame containing at least the 'vertical' column for pressure levels,
-        and other columns required by the `rmse_bias` function for calculating RMSE and Bias.
-        levels (array-like): The bin edges for categorizing the 'vertical' column values into pressure levels.
+    return fig_rmse, fig_ts, fig_bias
 
-    Returns:
-        tuple: A tuple containing the DataFrame with RMSE and Bias calculations, the RMSE plot figure, and the
-        Bias plot figure. The DataFrame includes a 'plevels' column representing the categorized pressure levels
-        and 'hPa' column representing the midpoint of each pressure level bin.
-
-    Raises:
-        ValueError: If there are missing values in the 'vertical' column of the input DataFrame.
-
-    Note:
-        - The function modifies the input DataFrame by adding 'plevels' and 'hPa' columns.
-        - The 'hPa' values are calculated as half the midpoint of each pressure level bin, which may need
-          adjustment based on the specific requirements for pressure level representation.
-        - The plots are generated using Plotly Express and are displayed inline. The y-axis of the plots is
-          reversed to align with standard atmospheric pressure level representation.
-    """
 
-    pd.options.mode.copy_on_write = True
-    if df['vertical'].isnull().values.any(): # what about horizontal observations?
-        raise ValueError("Missing values in 'vertical' column.")
-    else:
-        df.loc[:,'plevels'] = pd.cut(df['vertical'], levels)
-        df.loc[:,'hPa'] = df['plevels'].apply(lambda x: x.mid / 1000.) # HK todo units
-
-    df_profile = rmse_bias(df)
-    fig_rmse = px.line(df_profile, y='hPa', x='rmse', title='RMSE by Level', markers=True, color='type', width=800, height=800)
-    fig_rmse.update_yaxes(autorange="reversed")
-    fig_rmse.show()
-
-    fig_bias = px.line(df_profile, y='hPa', x='bias', title='Bias by Level', markers=True, color='type', width=800, height=800)
-    fig_bias.update_yaxes(autorange="reversed")
-    fig_bias.show()
-
-    return df_profile, fig_rmse, fig_bias
-    
-    
-def mean_then_sqrt(x):
+def plot_profile_prior_post(df_profile, stat, verticalUnit):
     """
-    Calculates the mean of an array-like object and then takes the square root of the result.
+    Plots prior and posterior statistics by vertical level for different observation types.
 
     Parameters:
-        arr (array-like): An array-like object (such as a list or a pandas Series). 
-                          The elements should be numeric.
+        df_profile (pd.DataFrame): DataFrame containing the prior and posterior statistics.
+        stat (str): The statistic to plot (e.g., 'rmse', 'bias', 'totalspread').
+        verticalUnit (str): The unit of the vertical axis (e.g., 'pressure (Pa)').
 
     Returns:
-        float: The square root of the mean of the input array.
-
-    Raises:
-        TypeError: If the input is not an array-like object containing numeric values.
-         ValueError: If the input array is empty.
+        plotly.graph_objects.Figure: The generated Plotly figure.
     """
-        
-    return np.sqrt(np.mean(x))
-
-def rmse_bias(df):
-    rmse_bias_df = df.groupby(['hPa', 'type']).agg({'sq_err':mean_then_sqrt, 'bias':'mean'}).reset_index()
-    rmse_bias_df.rename(columns={'sq_err':'rmse'}, inplace=True)
-    
-    return rmse_bias_df
-
-
-def rmse_bias_by_obs_type(df, obs_type):
+    # Filter the DataFrame to include only rows with the required verticalUnit
+    df_filtered = df_profile[df_profile["vert_unit"] == verticalUnit]
+
+    # Reshape DataFrame to long format for easier plotting
+    df_long = pd.melt(
+        df_profile,
+        id_vars=["midpoint", "type"],
+        value_vars=["prior_" + stat, "posterior_" + stat],
+        var_name=stat + "_type",
+        value_name=stat + "_value",
+    )
+
+    # Define a color mapping for observation each type
+    unique_types = df_long["type"].unique()
+    colors = px.colors.qualitative.Plotly
+    color_mapping = {
+        type_: colors[i % len(colors)] for i, type_ in enumerate(unique_types)
+    }
+
+    # Create a mapping for line styles based on stat
+    line_styles = {"prior_" + stat: "solid", "posterior_" + stat: "dash"}
+
+    # Create the figure
+    fig_stat = go.Figure()
+
+    # Loop through each type and type to add traces
+    for t in df_long["type"].unique():
+        for stat_type, dash_style in line_styles.items():
+            # Filter the DataFrame for this type and stat
+            df_filtered = df_long[
+                (df_long[stat + "_type"] == stat_type) & (df_long["type"] == t)
+            ]
+
+            # Add a trace
+            fig_stat.add_trace(
+                go.Scatter(
+                    x=df_filtered[stat + "_value"],
+                    y=df_filtered["midpoint"],
+                    mode="lines+markers",
+                    name=(
+                        "prior " + t if stat_type == "prior_" + stat else "post "
+                    ),  # Show legend for "prior_stat OBS TYPE" only
+                    line=dict(
+                        dash=dash_style, color=color_mapping[t]
+                    ),  # Same color for all traces in group
+                    marker=dict(size=8, color=color_mapping[t]),
+                    legendgroup=t,  # Group traces by type
+                )
+            )
+
+        # Update layout
+        fig_stat.update_layout(
+            title=stat + " by Level",
+            xaxis_title=stat,
+            yaxis_title=verticalUnit,
+            width=800,
+            height=800,
+            template="plotly_white",
+        )
+
+    if verticalUnit == "pressure (Pa)":
+        fig_stat.update_yaxes(autorange="reversed")
+
+    return fig_stat
+
+
+def plot_profile_prior(df_profile, stat, verticalUnit):
     """
-    Calculate the RMSE and bias for a given observation type.
+    Plots prior statistics by vertical level for different observation types.
 
     Parameters:
-        df (DataFrame): A pandas DataFrame.
-        obs_type (str): The observation type for which to calculate the RMSE and bias.
+        df_profile (pd.DataFrame): DataFrame containing the prior statistics.
+        stat (str): The statistic to plot (e.g., 'rmse', 'bias', 'totalspread').
+        verticalUnit (str): The unit of the vertical axis (e.g., 'pressure (Pa)').
 
     Returns:
-        DataFrame: A DataFrame containing the RMSE and bias for the given observation type.
-
-    Raises:
-        ValueError: If the observation type is not present in the DataFrame.
+        plotly.graph_objects.Figure: The generated Plotly figure.
     """
-    if obs_type not in df['type'].unique():
-        raise ValueError(f"Observation type '{obs_type}' not found in DataFrame.")
-    else:
-        obs_type_df = df[df['type'] == obs_type]
-        obs_type_agg = obs_type_df.groupby('plevels').agg({'sq_err':mean_then_sqrt, 'bias':'mean'}).reset_index()
-        obs_type_agg.rename(columns={'sq_err':'rmse'}, inplace=True)
-        return obs_type_agg
-
+    # Reshape DataFrame to long format for easier plotting - not needed for prior only, but
+    #   leaving it in for consistency with the plot_profile_prior_post function for now
+    df_long = pd.melt(
+        df_profile,
+        id_vars=["midpoint", "type"],
+        value_vars=["prior_" + stat],
+        var_name=stat + "_type",
+        value_name=stat + "_value",
+    )
+
+    # Define a color mapping for observation each type
+    unique_types = df_long["type"].unique()
+    colors = px.colors.qualitative.Plotly
+    color_mapping = {
+        type_: colors[i % len(colors)] for i, type_ in enumerate(unique_types)
+    }
+
+    # Create the figure
+    fig_stat = go.Figure()
+
+    # Loop through each type to add traces
+    for t in df_long["type"].unique():
+        # Filter the DataFrame for this type and stat
+        df_filtered = df_long[(df_long["type"] == t)]
+
+        # Add a trace
+        fig_stat.add_trace(
+            go.Scatter(
+                x=df_filtered[stat + "_value"],
+                y=df_filtered["midpoint"],
+                mode="lines+markers",
+                name="prior " + t,
+                line=dict(color=color_mapping[t]),  # Same color for all traces in group
+                marker=dict(size=8, color=color_mapping[t]),
+                legendgroup=t,  # Group traces by type
+            )
+        )
+
+    # Update layout
+    fig_stat.update_layout(
+        title=stat + " by Level",
+        xaxis_title=stat,
+        yaxis_title=verticalUnit,
+        width=800,
+        height=800,
+        template="plotly_white",
+    )
+
+    if verticalUnit == "pressure (Pa)":
+        fig_stat.update_yaxes(autorange="reversed")
+
+    return fig_stat

pydartdiags/stats/stats.py

@@ -0,0 +1,323 @@
+# SPDX-License-Identifier: Apache-2.0
+import pandas as pd
+import numpy as np
+from functools import wraps
+
+# from pydartdiags.obs_sequence import obs_sequence as obsq
+
+
+def apply_to_phases_in_place(func):
+    """
+    Decorator to apply a function to both 'prior' and 'posterior' phases
+    and modify the DataFrame in place.
+
+    The decorated function should accept 'phase' as its first argument.
+    """
+
+    @wraps(func)
+    def wrapper(df, *args, **kwargs):
+        for phase in ["prior", "posterior"]:
+            if f"{phase}_ensemble_spread" in df.columns:
+                func(df, phase, *args, **kwargs)
+        return df
+
+    return wrapper
+
+
+def apply_to_phases_by_type_return_df(func):
+    """
+    Decorator to apply a function to both 'prior' and 'posterior' phases and return a new DataFrame.
+
+    The decorated function should accept 'phase' as its first argument and return a DataFrame.
+    """
+
+    @wraps(func)
+    def wrapper(df, *args, **kwargs):
+        results = []
+        for phase in ["prior", "posterior"]:
+            if f"{phase}_ensemble_mean" in df.columns:
+                result = func(df, phase, *args, **kwargs)
+                results.append(result)
+
+        if "midpoint" in result.columns:
+            if len(results) == 2:
+                return pd.merge(
+                    results[0],
+                    results[1],
+                    on=["midpoint", "vlevels", "type", "vert_unit"],
+                )
+            else:
+                return results[0]
+        else:
+            if len(results) == 2:
+                return pd.merge(results[0], results[1], on="type")
+            else:
+                return results[0]
+
+    return wrapper
+
+
+def apply_to_phases_by_obs(func):
+    """
+    Decorator to apply a function to both 'prior' and 'posterior' phases and return a new DataFrame.
+
+    The decorated function should accept 'phase' as its first argument and return a DataFrame.
+    """
+
+    @wraps(func)
+    def wrapper(df, *args, **kwargs):
+
+        res_df = func(df, "prior", *args, **kwargs)
+        if "posterior_ensemble_mean" in df.columns:
+            posterior_df = func(df, "posterior", *args, **kwargs)
+            res_df["posterior_rank"] = posterior_df["posterior_rank"]
+
+        return res_df
+
+    return wrapper
+
+
+@apply_to_phases_by_obs
+def calculate_rank(df, phase):
+    """
+    Calculate the rank of observations within an ensemble.
+
+    This function takes a DataFrame containing ensemble predictions and observed values,
+    adds sampling noise to the ensemble predictions, and calculates the rank of the observed
+    value within the perturbed ensemble for each observation. The rank indicates the position
+    of the observed value within the sorted ensemble values, with 1 being the lowest. If the
+    observed value is larger than the largest ensemble member, its rank is set to the ensemble
+    size plus one.
+
+    Parameters:
+        df (pd.DataFrame): A DataFrame with columns for rank, and observation type.
+
+        phase (str): The phase for which to calculate the statistics ('prior' or 'posterior')
+
+    Returns:
+        DataFrame containing columns for 'rank' and observation 'type'.
+    """
+    column = f"{phase}_ensemble_member"
+    ensemble_values = df.filter(regex=column).to_numpy().copy()
+    std_dev = np.sqrt(df["obs_err_var"]).to_numpy()
+    obsvalue = df["observation"].to_numpy()
+    obstype = df["type"].to_numpy()
+    ens_size = ensemble_values.shape[1]
+    mean = 0.0  # mean of the sampling noise
+    rank = np.zeros(obsvalue.shape[0], dtype=int)
+
+    for obs in range(ensemble_values.shape[0]):
+        sampling_noise = np.random.normal(mean, std_dev[obs], ens_size)
+        ensemble_values[obs] += sampling_noise
+        ensemble_values[obs].sort()
+        for i, ens in enumerate(ensemble_values[obs]):
+            if obsvalue[obs] <= ens:
+                rank[obs] = i + 1
+                break
+
+        if rank[obs] == 0:  # observation is larger than largest ensemble member
+            rank[obs] = ens_size + 1
+
+    result_df = pd.DataFrame({"type": obstype, f"{phase}_rank": rank})
+
+    return result_df
+
+
+def mean_then_sqrt(x):
+    """
+    Calculates the mean of an array-like object and then takes the square root of the result.
+
+    Parameters:
+        arr (array-like): An array-like object (such as a list or a pandas Series).
+                          The elements should be numeric.
+
+    Returns:
+        float: The square root of the mean of the input array.
+
+    Raises:
+        TypeError: If the input is not an array-like object containing numeric values.
+         ValueError: If the input array is empty.
+    """
+
+    return np.sqrt(np.mean(x))
+
+
+@apply_to_phases_in_place
+def diag_stats(df, phase):
+    """
+    Calculate diagnostic statistics for a given phase and add them to the DataFrame.
+
+    Args:
+        df (pandas.DataFrame): The input DataFrame containing observation data and ensemble statistics.
+                               The DataFrame must include the following columns:
+                               - 'observation': The actual observation values.
+                               - 'obs_err_var': The variance of the observation error.
+                               - 'prior_ensemble_mean' and/or 'posterior_ensemble_mean': The mean of the ensemble.
+                               - 'prior_ensemble_spread' and/or 'posterior_ensemble_spread': The spread of the ensemble.
+
+        phase (str): The phase for which to calculate the statistics ('prior' or 'posterior')
+
+    Returns:
+        None: The function modifies the DataFrame in place by adding the following columns:
+            - 'prior_sq_err' and/or 'posterior_sq_err': The square error for the 'prior' and 'posterior' phases.
+            - 'prior_bias' and/or 'posterior_bias': The bias for the 'prior' and 'posterior' phases.
+            - 'prior_totalvar' and/or 'posterior_totalvar': The total variance for the 'prior' and 'posterior' phases.
+
+    Notes:
+        - Spread is the standard deviation of the ensemble.
+        - The function modifies the input DataFrame by adding new columns for the calculated statistics.
+    """
+    pd.options.mode.copy_on_write = True
+
+    # input from the observation sequence
+    spread_column = f"{phase}_ensemble_spread"
+    mean_column = f"{phase}_ensemble_mean"
+
+    # Calculated from the observation sequence
+    sq_err_column = f"{phase}_sq_err"
+    bias_column = f"{phase}_bias"
+    totalvar_column = f"{phase}_totalvar"
+
+    df[sq_err_column] = (df[mean_column] - df["observation"]) ** 2
+    df[bias_column] = df[mean_column] - df["observation"]
+    df[totalvar_column] = df["obs_err_var"] + df[spread_column] ** 2
+
+
+def bin_by_layer(df, levels, verticalUnit="pressure (Pa)"):
+    """
+    Bin observations by vertical layers and add 'vlevels' and 'midpoint' columns to the DataFrame.
+
+    This function bins the observations in the DataFrame based on the specified vertical levels and adds two new columns:
+    'vlevels', which represents the categorized vertical levels, and 'midpoint', which represents the midpoint of each
+    vertical level bin. Only observations (row) with the specified vertical unit are binned.
+
+    Args:
+        df (pandas.DataFrame): The input DataFrame containing observation data. The DataFrame must include the following columns:
+                               - 'vertical': The vertical coordinate values of the observations.
+                               - 'vert_unit': The unit of the vertical coordinate values.
+        levels (list): A list of bin edges for the vertical levels.
+        verticalUnit (str, optional): The unit of the vertical axis (e.g., 'pressure (Pa)'). Default is 'pressure (Pa)'.
+
+    Returns:
+        pandas.DataFrame: The input DataFrame with additional columns for the binned vertical levels and their midpoints:
+                          - 'vlevels': The categorized vertical levels.
+                          - 'midpoint': The midpoint of each vertical level bin.
+
+    Notes:
+        - The function modifies the input DataFrame by adding 'vlevels' and 'midpoint' columns.
+        - The 'midpoint' values are calculated as half the midpoint of each vertical level bin.
+    """
+    pd.options.mode.copy_on_write = True
+    df.loc[df["vert_unit"] == verticalUnit, "vlevels"] = pd.cut(
+        df.loc[df["vert_unit"] == verticalUnit, "vertical"], levels
+    )
+    if verticalUnit == "pressure (Pa)":
+        df.loc[:, "midpoint"] = df["vlevels"].apply(
+            lambda x: x.mid
+        )  # HK todo units HPa - change now or in plotting?
+        df.loc[:, "vlevels"] = df["vlevels"].apply(
+            lambda x: x
+        )  # HK todo units HPa - change now or in plotting?
+    else:
+        df.loc[:, "midpoint"] = df["vlevels"].apply(lambda x: x.mid)
+
+
+@apply_to_phases_by_type_return_df
+def grand_statistics(df, phase):
+
+    # assuming diag_stats has been called
+    grand = (
+        df.groupby(["type"], observed=False)
+        .agg(
+            {
+                f"{phase}_sq_err": mean_then_sqrt,
+                f"{phase}_bias": "mean",
+                f"{phase}_totalvar": mean_then_sqrt,
+            }
+        )
+        .reset_index()
+    )
+
+    grand.rename(columns={f"{phase}_sq_err": f"{phase}_rmse"}, inplace=True)
+    grand.rename(columns={f"{phase}_totalvar": f"{phase}_totalspread"}, inplace=True)
+
+    return grand
+
+
+@apply_to_phases_by_type_return_df
+def layer_statistics(df, phase):
+
+    # assuming diag_stats has been called
+    layer_stats = (
+        df.groupby(["midpoint", "type"], observed=False)
+        .agg(
+            {
+                f"{phase}_sq_err": mean_then_sqrt,
+                f"{phase}_bias": "mean",
+                f"{phase}_totalvar": mean_then_sqrt,
+                "vert_unit": "first",
+                "vlevels": "first",
+            }
+        )
+        .reset_index()
+    )
+
+    layer_stats.rename(columns={f"{phase}_sq_err": f"{phase}_rmse"}, inplace=True)
+    layer_stats.rename(
+        columns={f"{phase}_totalvar": f"{phase}_totalspread"}, inplace=True
+    )
+
+    return layer_stats
+
+
+def possible_vs_used(df):
+    """
+    Calculates the count of possible vs. used observations by type.
+
+    This function takes a DataFrame containing observation data, including a 'type' column for the observation
+    type and an 'observation' column. The number of used observations ('used'), is the total number
+    minus the observations that failed quality control checks (as determined by the `select_failed_qcs` function).
+    The result is a DataFrame with each observation type, the count of possible observations, and the count of
+    used observations.
+
+    Returns:
+        pd.DataFrame: A DataFrame with three columns: 'type', 'possible', and 'used'. 'type' is the observation type,
+        'possible' is the count of all observations of that type, and 'used' is the count of observations of that type
+        that passed quality control checks.
+    """
+    possible = df.groupby("type")["observation"].count()
+    possible.rename("possible", inplace=True)
+
+    failed_qcs = select_failed_qcs(df).groupby("type")["observation"].count()
+    used = possible - failed_qcs.reindex(possible.index, fill_value=0)
+    used.rename("used", inplace=True)
+
+    return pd.concat([possible, used], axis=1).reset_index()
+
+
+def possible_vs_used_by_layer(df):
+    """
+    Calculates the count of possible vs. used observations by type and vertical level.
+    """
+    possible = df.groupby(["type", "midpoint"], observed=False)["type"].count()
+    possible.rename("possible", inplace=True)
+
+    failed_qcs = (
+        select_failed_qcs(df)
+        .groupby(["type", "midpoint"], observed=False)["type"]
+        .count()
+    )
+    used = possible - failed_qcs.reindex(possible.index, fill_value=0)
+    used.rename("used", inplace=True)
+
+    return pd.concat([possible, used], axis=1).reset_index()
+
+
+def select_failed_qcs(df):
+    """
+    Select rows from the DataFrame where the DART quality control flag is greater than 0.
+
+    Returns:
+        pandas.DataFrame: A DataFrame containing only the rows with a DART quality control flag greater than 0.
+    """
+    return df[df["DART_quality_control"] > 0]