Get mean absolute error

Get mean absolute error#

Show code cell source Hide code cell source
from datetime import datetime

from boilercore.paths import ISOLIKE, dt_fromisolike

if isinstance(PARAMS, str):
    params = Params.model_validate_json(PARAMS)
else:
    params = Params(context=init(), include_patterns=const.nb_include_patterns)
params.format.set_display_options()
data = params.data
C = params.cols
context = params.context

# Physical parameters
LATENT_HEAT_OF_VAPORIZATION = 2.23e6  # J/kg
LIQUID_DENSITY = 960  # kg/m^3
LIQUID_DYNAMIC_VISCOSITY = 2.88e-4  # Pa-s
LIQUID_ISOBARIC_SPECIFIC_HEAT = 4213  # J/kg-K
LIQUID_THERMAL_CONDUCTIVITY = 0.676  # W/m-K
VAPOR_DENSITY = 0.804  # kg/m^3


# Plotting
CORRELATIONS_PALETTE = cat10
"""For plotting one approach."""

# Plotting
MAX_BETA_MAE = 0.3
"""Maximum mean absolute error of beta to plot."""
MAX_NUSSELT_MAE = 4000
"""Maximum mean absolute error of nusselt to plot."""
WIDTH_SCALE = 2.00
"""Width scale for plotting."""
HEIGHT_SCALE = 1.30
"""Height scale for plotting."""

tracks_path = one(params.tracks)
BC = find_tracks.Cols()
tracks = (
    DataFrame(read_hdf(tracks_path))
    .pipe(lambda df: df[df[BC.bub_fourier()] > 0])[
        [
            BC.bub(),
            BC.bub_reynolds(),
            BC.bub_reynolds0(),
            BC.bub_fourier(),
            BC.bub_beta(),
            BC.bub_nusselt(),
        ]
    ]
    .set_index(BC.bub())
    .pipe(
        lambda df: df[
            (df[BC.bub_beta()] > 0.05 * df[BC.bub_beta()].max())
            & (df[BC.bub_nusselt()] > 0.05 * df[BC.bub_nusselt()].max())
        ]
    )
)


def get_time() -> datetime:
    """Get time from path."""
    if match := ISOLIKE.search(tracks_path.stem):
        return dt_fromisolike(match)
    else:
        raise ValueError("No time found in path.")


time = get_time()
thermal = read_hdf(params.deps.thermal)
TC = get_thermal_data.Cols()
subcooling = thermal.set_index(TC.time())[TC.subcool()][time]

beta_correlations = beta.get_correlations()
nusselt_correlations = correlations_nusselt.get_correlations()
object_averages = tracks.groupby(BC.bub(), **GBC).mean().mean()
constants = {
    "Ja": jakob(
        liquid_density=LIQUID_DENSITY,
        vapor_density=VAPOR_DENSITY,
        liquid_isobaric_specific_heat=LIQUID_ISOBARIC_SPECIFIC_HEAT,
        subcooling=subcooling,
        latent_heat_of_vaporization=LATENT_HEAT_OF_VAPORIZATION,
    ),
    "Pr": prandtl(
        dynamic_viscosity=LIQUID_DYNAMIC_VISCOSITY,
        isobaric_specific_heat=LIQUID_ISOBARIC_SPECIFIC_HEAT,
        thermal_conductivity=LIQUID_THERMAL_CONDUCTIVITY,
    ),
    "alpha": thermal_diffusivity(
        thermal_conductivity=LIQUID_THERMAL_CONDUCTIVITY,
        density=LIQUID_DENSITY,
        isobaric_specific_heat=LIQUID_ISOBARIC_SPECIFIC_HEAT,
    ),
    "pi": pi,
}


def get_mae(df: DataFrame, kind: str, rel: bool = False) -> "Series[float]":
    """Get mean absolute error for dimensionless bubble diameter.

    Get mean absolute percentage error if `rel`.
    """
    df = (
        df.assign(**{
            label: (
                abs(
                    (
                        (
                            corr.expr(**{
                                kwd: value
                                for kwd, value in {
                                    **constants,
                                    "Re_b": df[BC.bub_reynolds()],
                                    "Re_b0": df[BC.bub_reynolds0()],
                                    "Fo_0": df[BC.bub_fourier()],
                                    **(
                                        {}
                                        if kind == "beta"
                                        else {"beta": df[BC.bub_beta()]}
                                    ),
                                }.items()
                                if kwd in Signature.from_callable(corr.expr).parameters
                            })
                        )
                        - df["experimental"]
                    )
                    / (df["experimental"] if rel else 1)
                )
            )
            for label, corr in (
                beta_correlations if kind == "beta" else nusselt_correlations
            ).items()
        })
        .drop(
            columns=[
                "experimental",
                BC.bub_reynolds(),
                BC.bub_reynolds0(),
                BC.bub_fourier(),
                BC.bub_nusselt() if kind == "beta" else BC.bub_beta(),
            ]
        )
        .replace(inf, nan)
        .dropna()
    )
    return df.sum() / len(df)


def preview(
    df: DataFrame, cols: Iterable[Col] | None = None, index: Col | None = None
) -> DataFrame:
    """Preview a dataframe in the notebook."""
    df = params.format.preview(cols=cols, df=df, index=index, f=lambda df: df.head(16))
    return df


pprint(params)