Upload folder using huggingface_hub

README.md

@@ -1,35 +1,47 @@
 ---
-title: Playing Card Predictor
-emoji: 🃏
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-app_file: app.py
-pinned: false
+tags:
+- gradio
+- machine-learning
+- engineering
 ---
+# Reynolds Number Calculator
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This is a simple web application built with Gradio that calculates the Reynolds number for fluid flow in a circular pipe and determines the flow regime (laminar, transitional, or turbulent). It also provides a plain-English explanation of the results generated by a small language model.
 
-# Playing Card Face/Value Prediction App
+## Purpose
 
-This Gradio application uses an AutoGluon MultiModalPredictor to classify images of playing cards, identifying whether the image shows the "Face" or the "Value" of the card.
+The application serves as a demonstration of wrapping a deterministic engineering calculation with a user-friendly interface using Gradio and augmenting the numerical output with an LLM-generated explanation for broader understanding.
 
 ## How to Use
 
-1.  **Upload an Image:** Use the "Input image" section to upload a photo of a playing card. You can upload a file from your computer, use your webcam, or paste an image from your clipboard.
-2.  **View Processed Image:** The "Preprocessed image" section will display a resized version of your input image, showing how the model receives the image for processing.
-3.  **See Prediction Results:** The "Prediction Status" will indicate if the prediction was successful. The "Class probabilities" section will show the model's confidence scores for the "👑 Face" and "🔢 Value" classes. The class with the highest probability is the model's prediction.
+1.  Enter the required fluid and pipe properties in the input fields:
+    *   **Fluid density [kg/m³]:** The mass density of the fluid.
+    *   **Fluid velocity [m/s]:** The average velocity of the fluid flow.
+    *   **Pipe diameter [m]:** The inner diameter of the circular pipe.
+    *   **Dynamic viscosity [Pa*s]:** The dynamic viscosity of the fluid.
+2.  Click the "Compute Reynolds Number" button.
+3.  The "Calculation Results" panel will display the calculated Reynolds number and the determined flow regime.
+4.  The "Explanation" panel will show a simple, LLM-generated explanation of the results.
 
-## Model Information
+## Inputs
 
-This app utilizes an AutoGluon MultiModalPredictor trained on a dataset of playing card images. The model is designed to distinguish between images focusing on the face cards (King, Queen, Jack, Ace) and those showing the numerical value cards (2 through 10).
+*   `rho`: Fluid density in kilograms per cubic meter (kg/m³).
+*   `v`: Fluid velocity in meters per second (m/s).
+*   `D`: Pipe diameter in meters (m).
+*   `mu`: Dynamic viscosity in Pascal-seconds (Pa*s).
 
-The trained model is sourced from the Hugging Face Hub repository: `jennifee/nnl_automm_model`.
+## Outputs
 
-## Dataset
+*   **Reynolds Number [-]:** The dimensionless Reynolds number.
+*   **Flow Regime:** The classification of the flow as "Laminar" (Re < 2100), "Transitional" (2100 <= Re <= 4000), or "Turbulent" (Re > 4000).
+*   **Explanation:** A natural language explanation of the results provided by an instruction-tuned language model.
 
-The model was trained on a custom dataset of playing card images, specifically curated for the task of classifying images based on whether they depict a face card or a value card.
+## Libraries Used
 
-## About the Creator
+*   Gradio: For building the web interface.
+*   Transformers: For accessing and using the language model.
+*   Torch: A dependency for the Transformers library.
+*   Hugging Face Hub: For loading the pre-trained language model.
+*   Pandas: For formatting the numerical results into a table.
 
-This app was created as a demonstration of deploying AutoGluon models with Gradio on Hugging Face Spaces.
+The LLM is used to make the engineering results more accessible and understandable to a non-expert audience by providing a concise, analogy-based explanation.

app.py

@@ -1,219 +1,166 @@
-import random # Import random for selecting examples
-import os  # For reading environment variables
-import shutil  # For directory cleanup
-import zipfile  # For extracting model archives
-import pathlib  # For path manipulations
-import tempfile  # For creating temporary files/directories
-import numpy as np # For image processing
-# import pickle # No longer needed for loading from zip
-
-
-import gradio  # For interactive UI
-import pandas  # For tabular data handling
-import PIL.Image # For image I/O
-
-import huggingface_hub # For downloading model assets
-import autogluon.multimodal  # For loading AutoGluon image classifier
-
-# Hardcoded Hub model (native zip)
-MODEL_REPO_ID = "jennifee/nnl_automl_model" # Updated model ID
-ZIP_FILENAME  = "autogluon_image_predictor_dir.zip" # Updated filename
-HF_TOKEN = os.getenv("HF_TOKEN", None)
-
-# Local cache/extract dirs
-CACHE_DIR   = pathlib.Path("hf_assets")
-EXTRACT_DIR = CACHE_DIR / "predictor_native" # Keep extract dir name for consistency
-
-# Download & load the native predictor
-def _prepare_predictor_dir() -> str: # Reverted function name
-    # Clear the Hugging Face Hub cache to avoid caching issues - Keep for now, can remove if issues persist
-    from huggingface_hub import delete_repo
-    try:
-        # Use the current MODEL_REPO_ID for deletion
-        delete_repo(MODEL_REPO_ID, repo_type="model", token=HF_TOKEN)
-    except Exception as e:
-        print(f"Could not delete repo from cache (may not exist or unauthorized): {e}")
-
-    CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    local_zip = huggingface_hub.hf_hub_download(
-        repo_id=MODEL_REPO_ID,
-        filename=ZIP_FILENAME,
-        repo_type="model",
-        token=HF_TOKEN,
-        local_dir=str(CACHE_DIR),
-        local_dir_use_symlinks=False,
+import math
+import gradio
+import pandas
+
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+
+# Instantiate the model that we'll be calling. This is a tiny one!
+MODEL_ID = "HuggingFaceTB/SmolLM2-135M-Instruct"
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+pipe = pipeline(
+    task="text-generation",
+    model=AutoModelForCausalLM.from_pretrained(
+        MODEL_ID,
+    ),
+    tokenizer=tokenizer
+)
+
+# This helper function applies a chat format to help the LLM understand what
+# is going on
+def _format_chat(system_prompt: str, user_prompt: str) -> str:
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt},
+    ]
+    template = getattr(tokenizer, "chat_template", None)
+    return tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True
     )
-    if EXTRACT_DIR.exists():
-        shutil.rmtree(EXTRACT_DIR)
-    EXTRACT_DIR.mkdir(parents=True, exist_ok=True)
-    with zipfile.ZipFile(local_zip, "r") as zf:
-        zf.extractall(str(EXTRACT_DIR))
-    contents = list(EXTRACT_DIR.iterdir())
-    predictor_root = contents[0] if (len(contents) == 1 and contents[0].is_dir()) else EXTRACT_DIR
-    return str(predictor_root)
-
-
-try:
-    PREDICTOR_DIR = _prepare_predictor_dir() # Call the function to prepare the directory
-    # PREDICTOR_FILE = _prepare_predictor_file() # Old call
-    # Load the predictor from the extracted directory
-    PREDICTOR = autogluon.multimodal.MultiModalPredictor.load(PREDICTOR_DIR) # Updated load
-    # with open(PREDICTOR_FILE, 'rb') as f: # Old pickle load
-    #     PREDICTOR = pickle.load(f) # Old pickle load
-except Exception as e:
-    print(f"Error loading predictor: {e}")
-    PREDICTOR = None # Set predictor to None if loading fails
-
-
-# Explicit class labels (edit copy as desired) - Updated based on user input
-CLASS_LABELS = {
-    0: "👑 Face",
-    1: "🔢 Value",
-    # Removed suit labels and Joker as per new mapping
-    # 5: "Unknown" # Keep Unknown as a placeholder if needed
-}
-
-# Helper to map model class -> human label
-def _human_label(c):
-    try:
-        # Attempt to convert to integer first, then use get for safety
-        ci = int(c)
-        return CLASS_LABELS.get(ci, str(c))
-    except (ValueError, TypeError):
-        # If conversion fails, try getting directly by key
-        return CLASS_LABELS.get(c, str(c))
-
-
-# Function to preprocess image and return processed image - Keep as is for now
-def preprocess_image_for_display(pil_img: PIL.Image.Image):
-    if pil_img is None:
-        return None
-
-    # AutoGluon preprocessing (simplified, actual preprocessing is done internally by the predictor)
-    # Here we resize for display purposes to show a consistent "processed" image
-    processed_img = pil_img.resize((224, 224)) # Example size, adjust as needed
-    return processed_img
-
-# Do the prediction! - Adjusting outputs to match the new model's likely output
-def do_predict(pil_img: PIL.Image.Image):
-    # Make sure there's actually an image to work with and predictor is loaded
-    if pil_img is None:
-        # Returning None for the processed image output when input is None
-        # Adjusting return values to match expected outputs: status, probabilities, processed image
-        return "No image provided.", {}, None
-    if PREDICTOR is None:
-         # Returning None for the processed image output when predictor is not loaded
-         # Adjusting return values to match expected outputs: status, probabilities, processed image
-         return "Predictor not loaded. Please check the logs for errors.", {}, None
-
-
-    # Basic validation (file type is handled by Gradio, checking size)
-    # This is a placeholder; real size checks would be on file upload before PIL
-    # For now, we'll just check if the image object is valid
-    try:
-        pil_img.verify()
-    except Exception:
-        # Returning None for the processed image output for invalid image
-        # Adjusting return values to match expected outputs: status, probabilities, processed image
-        return "Invalid image file.", {}, None
-
-    # IF we have something to work with, save it and prepare the input
-    tmpdir = pathlib.Path(tempfile.mkdtemp())
-    img_path = tmpdir / "input.png"
-    pil_img.save(img_path)
-
-    df = pandas.DataFrame({"image": [str(img_path)]})  # For AutoGluon expected input format
-
-    # For class probabilities
-    # Assuming predict_proba returns a DataFrame where columns are class labels
-    proba_output = PREDICTOR.predict_proba(df)
-    print(f"Type of proba_output: {type(proba_output)}")
-    print(f"Content of proba_output: {proba_output}")
-
-    # Assuming proba_output is a pandas DataFrame with class probabilities
-    if not proba_output.empty:
-        # Get probabilities for the first (and likely only) row
-        proba_series = proba_output.iloc[0]
-        # Convert to dictionary, mapping original labels to probabilities
-        proba_dict = proba_series.to_dict()
-
-        # For user-friendly column names
-        # Map the original labels (keys in proba_dict) to human-friendly labels
-        pretty_dict = {
-            _human_label(k): float(v) for k, v in proba_dict.items()
+
+# This functoin uses hte LLM to generate a response.
+def _llm_generate(prompt: str, max_tokens: int) -> str:
+    out = pipe(
+        prompt,
+        max_new_tokens=max_tokens,
+        do_sample=True,
+        temperature=0.5,
+        return_full_text=False,
+    )
+    return out[0]["generated_text"]
+
+# Create a function to do the Reynolds number calculation
+def reynolds_number_calc(rho: float, v: float, D: float, mu: float) -> dict:
+    """
+    Calculates the Reynolds number for flow in a circular pipe.
+    Determines the flow regime (laminar, transitional, or turbulent).
+    Inputs:
+    rho: fluid density [kg/m^3]
+    v: fluid velocity [m/s]
+    D: pipe diameter [m]
+    mu: dynamic viscosity [Pa*s] or [kg/(m*s)]
+
+    Returns:
+    reynolds_number: The calculated Reynolds number
+    flow_regime: The determined flow regime
+    """
+
+    # Input validation
+    if rho <= 0 or v < 0 or D <= 0 or mu <= 0:
+        return {
+            "reynolds_number": None,
+            "flow_regime": "Invalid input: Density, velocity, diameter, and viscosity must be positive (velocity can be zero).",
         }
+
+    reynolds_number = (rho * v * D) / mu
+
+    if reynolds_number < 2100:
+        flow_regime = "Laminar"
+    elif 2100 <= reynolds_number <= 4000:
+        flow_regime = "Transitional"
     else:
-        # Handle case where predict_proba returns empty
-        pretty_dict = {}
+        flow_regime = "Turbulent"
 
+    return {
+        "reynolds_number": reynolds_number,
+        "flow_regime": flow_regime,
+    }
 
-    # Generate processed image for display
-    processed_img_display = preprocess_image_for_display(pil_img)
+# This function generates an explanation of the results for Reynolds number
+def llm_explain_reynolds(results: dict, inputs: list) -> str:
+    rho, v, D, mu = inputs
+    reynolds_number = results.get("reynolds_number")
+    flow_regime = results.get("flow_regime")
 
-    # Return prediction result, probabilities, and the processed image for display
-    # Ensure the number of return values matches the outputs in the Gradio interface
-    return "Prediction Complete", pretty_dict, processed_img_display
+    if reynolds_number is None:
+        return flow_regime # Return the error message from the calculation
 
 
-# Representative example images! These can be local or links.
-# Using the provided local file paths as examples
-EXAMPLES = [
-    ["./examples/WhatsApp Image 2025-09-12 at 22.05.40 (2).jpeg"],
-    ["./examples/WhatsApp Image 2025-09-12 at 22.05.40 (3).jpeg"],
-    ["./examples/WhatsApp Image 2025-09-12 at 22.05.40 (5).jpeg"]
-]
+    system_prompt = (
+        "You explain fluid mechanics to a smart 5-year-old. "
+        "Use food-based analogies to support the explanation."
+        "You always return CONCISE responses, only one sentence."
+    )
+
+    user_prompt = (
+        f"For a fluid with density {rho:g} kg/m³ and viscosity {mu:g} Pa*s, "
+        f"flowing at {v:g} m/s through a pipe with diameter {D:g} m, "
+        f"the Reynolds number is {reynolds_number:.2f}. "
+        f"The flow regime is {flow_regime}. "
+        "Explain the Reynolds number and the flow regime in ONE friendly sentence for a non-expert."
+    )
 
-# Gradio UI
-with gradio.Blocks() as demo:
+    formatted = _format_chat(system_prompt, user_prompt)
+    return _llm_generate(formatted, max_tokens=128)
 
-    # Provide an introduction - Updated for Playing Cards
-    gradio.Markdown("# Playing Card Detection")
-    gradio.Markdown("""
-    This is a simple app that demonstrates how to use an autogluon multimodal
-    predictor in a gradio space to predict the type of playing card in a picture. To use,
-    just upload a photo using the options below. The original and preprocessed
-    images will be displayed, and the prediction results will appear automatically.
-    """)
 
-    with gradio.Row():
-        # Interface for the incoming image
-        image_in = gradio.Image(type="pil", label="Input image", sources=["upload", "webcam", "clipboard"])
-        # Display preprocessed image
-        image_processed_out = gradio.Image(type="pil", label="Preprocessed image")
-
-
-    # Interface elements to show the result and probabilities
-    # Adjusting num_top_classes if the model has more classes
-    proba_pretty = gradio.Label(num_top_classes=len(CLASS_LABELS), label="Class probabilities")
-    prediction_status = gradio.Textbox(label="Prediction Status") # Added Textbox for status
-
-
-    # Expose key inference parameters (placeholder)
-    # gradio.Markdown("## Inference Parameters")
-    # with gradio.Row():
-        # Add parameters here if needed, e.e., a confidence threshold slider
-        # confidence_threshold = gradio.Slider(minimum=0, maximum=1, value=0.5, label="Confidence Threshold")
-
-    # Whenever a new image is uploaded, trigger the prediction directly
-    # Wrap do_predict in a lambda to ensure only the image input is passed
-    # Ensure outputs match the return values of do_predict
-    image_in.change(
-        fn=lambda img: do_predict(img),
-        inputs=[image_in],
-        outputs=[prediction_status, proba_pretty, image_processed_out]
+# This function ties everything together for the Reynolds number calculator
+def run_reynolds_once(rho, v, D, mu):
+    inputs = [rho, v, D, mu]
+    d = reynolds_number_calc(
+        rho=float(rho),
+        v=float(v),
+        D=float(D),
+        mu=float(mu)
     )
 
+    if d.get("reynolds_number") is None:
+         return pandas.DataFrame(), d["flow_regime"]
 
-    # For clickable example images - ADDED BACK
-    if EXAMPLES: # Only show examples if any were successfully fetched
-        gradio.Examples(
-            examples=EXAMPLES,
-            inputs=[image_in],
-            label="Representative examples",
-            examples_per_page=8,
-            cache_examples=False,
-        )
 
+    df = pandas.DataFrame([{
+        "Reynolds Number [-]": round(d["reynolds_number"], 3),
+        "Flow Regime": d["flow_regime"],
+    }])
 
-if __name__ == "__main__":
-    demo.launch()
+    narrative = llm_explain_reynolds(d, inputs).split("\n")[0]
+    return df, narrative
+
+# Now, let's create the Gradio interface for the Reynolds number calculator
+with gradio.Blocks() as reynolds_demo:
+
+    gradio.Markdown(
+        "# Reynolds Number Calculator"
+    )
+    gradio.Markdown(
+        "This app calculates the Reynolds number for flow in a circular pipe and determines the flow regime (laminar, transitional, or turbulent)."
+    )
+
+    with gradio.Row():
+        rho = gradio.Number(value=1000.0, label="Fluid density [kg/m³]")
+        v = gradio.Number(value=1.0, label="Fluid velocity [m/s]")
+        D = gradio.Number(value=0.1, label="Pipe diameter [m]")
+        mu = gradio.Number(value=0.001, label="Dynamic viscosity [Pa*s]")
+
+    run_btn_reynolds = gradio.Button("Compute Reynolds Number")
+
+    results_df_reynolds = gradio.Dataframe(label="Calculation Results", interactive=False)
+
+    # Add an explicit title for the explanation panel
+    gradio.Markdown("## Explanation")
+    explain_md_reynolds = gradio.Markdown(label="Explanation")
+
+    run_btn_reynolds.click(fn=run_reynolds_once, inputs=[rho, v, D, mu], outputs=[results_df_reynolds, explain_md_reynolds])
+
+    gradio.Examples(
+        examples=[
+            [1000.0, 0.1, 0.05, 0.001], # Laminar example
+            [1000.0, 0.5, 0.1, 0.001],  # Transitional example
+            [1000.0, 2.0, 0.1, 0.001],  # Turbulent example
+        ],
+        inputs=[rho, v, D, mu],
+        label="Representative cases",
+        examples_per_page=3,
+        cache_examples=False,
+    )

requirements.txt

@@ -1,5 +1,172 @@
-gradio==4.37.2 # Specify a recent Gradio version
-autogluon.multimodal
+transformers
+gradio
+torch
 huggingface_hub
-pandas
-Pillow
+
+%%writefile app.py
+import math
+import gradio
+import pandas
+
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+
+# Instantiate the model that we'll be calling. This is a tiny one!
+MODEL_ID = "HuggingFaceTB/SmolLM2-135M-Instruct"
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+pipe = pipeline(
+    task="text-generation",
+    model=AutoModelForCausalLM.from_pretrained(
+        MODEL_ID,
+    ),
+    tokenizer=tokenizer
+)
+
+# This helper function applies a chat format to help the LLM understand what
+# is going on
+def _format_chat(system_prompt: str, user_prompt: str) -> str:
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt},
+    ]
+    template = getattr(tokenizer, "chat_template", None)
+    return tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True
+    )
+
+# This functoin uses hte LLM to generate a response.
+def _llm_generate(prompt: str, max_tokens: int) -> str:
+    out = pipe(
+        prompt,
+        max_new_tokens=max_tokens,
+        do_sample=True,
+        temperature=0.5,
+        return_full_text=False,
+    )
+    return out[0]["generated_text"]
+
+# Create a function to do the Reynolds number calculation
+def reynolds_number_calc(rho: float, v: float, D: float, mu: float) -> dict:
+    """
+    Calculates the Reynolds number for flow in a circular pipe.
+    Determines the flow regime (laminar, transitional, or turbulent).
+    Inputs:
+    rho: fluid density [kg/m^3]
+    v: fluid velocity [m/s]
+    D: pipe diameter [m]
+    mu: dynamic viscosity [Pa*s] or [kg/(m*s)]
+
+    Returns:
+    reynolds_number: The calculated Reynolds number
+    flow_regime: The determined flow regime
+    """
+
+    # Input validation
+    if rho <= 0 or v < 0 or D <= 0 or mu <= 0:
+        return {
+            "reynolds_number": None,
+            "flow_regime": "Invalid input: Density, velocity, diameter, and viscosity must be positive (velocity can be zero).",
+        }
+
+    reynolds_number = (rho * v * D) / mu
+
+    if reynolds_number < 2100:
+        flow_regime = "Laminar"
+    elif 2100 <= reynolds_number <= 4000:
+        flow_regime = "Transitional"
+    else:
+        flow_regime = "Turbulent"
+
+    return {
+        "reynolds_number": reynolds_number,
+        "flow_regime": flow_regime,
+    }
+
+# This function generates an explanation of the results for Reynolds number
+def llm_explain_reynolds(results: dict, inputs: list) -> str:
+    rho, v, D, mu = inputs
+    reynolds_number = results.get("reynolds_number")
+    flow_regime = results.get("flow_regime")
+
+    if reynolds_number is None:
+        return flow_regime # Return the error message from the calculation
+
+
+    system_prompt = (
+        "You explain fluid mechanics to a smart 5-year-old. "
+        "Use food-based analogies to support the explanation."
+        "You always return CONCISE responses, only one sentence."
+    )
+
+    user_prompt = (
+        f"For a fluid with density {rho:g} kg/m³ and viscosity {mu:g} Pa*s, "
+        f"flowing at {v:g} m/s through a pipe with diameter {D:g} m, "
+        f"the Reynolds number is {reynolds_number:.2f}. "
+        f"The flow regime is {flow_regime}. "
+        "Explain the Reynolds number and the flow regime in ONE friendly sentence for a non-expert."
+    )
+
+    formatted = _format_chat(system_prompt, user_prompt)
+    return _llm_generate(formatted, max_tokens=128)
+
+
+# This function ties everything together for the Reynolds number calculator
+def run_reynolds_once(rho, v, D, mu):
+    inputs = [rho, v, D, mu]
+    d = reynolds_number_calc(
+        rho=float(rho),
+        v=float(v),
+        D=float(D),
+        mu=float(mu)
+    )
+
+    if d.get("reynolds_number") is None:
+         return pandas.DataFrame(), d["flow_regime"]
+
+
+    df = pandas.DataFrame([{
+        "Reynolds Number [-]": round(d["reynolds_number"], 3),
+        "Flow Regime": d["flow_regime"],
+    }])
+
+    narrative = llm_explain_reynolds(d, inputs).split("\n")[0]
+    return df, narrative
+
+# Now, let's create the Gradio interface for the Reynolds number calculator
+with gradio.Blocks() as reynolds_demo:
+
+    gradio.Markdown(
+        "# Reynolds Number Calculator"
+    )
+    gradio.Markdown(
+        "This app calculates the Reynolds number for flow in a circular pipe and determines the flow regime (laminar, transitional, or turbulent)."
+    )
+
+    with gradio.Row():
+        rho = gradio.Number(value=1000.0, label="Fluid density [kg/m³]")
+        v = gradio.Number(value=1.0, label="Fluid velocity [m/s]")
+        D = gradio.Number(value=0.1, label="Pipe diameter [m]")
+        mu = gradio.Number(value=0.001, label="Dynamic viscosity [Pa*s]")
+
+    run_btn_reynolds = gradio.Button("Compute Reynolds Number")
+
+    results_df_reynolds = gradio.Dataframe(label="Calculation Results", interactive=False)
+
+    # Add an explicit title for the explanation panel
+    gradio.Markdown("## Explanation")
+    explain_md_reynolds = gradio.Markdown(label="Explanation")
+
+    run_btn_reynolds.click(fn=run_reynolds_once, inputs=[rho, v, D, mu], outputs=[results_df_reynolds, explain_md_reynolds])
+
+    gradio.Examples(
+        examples=[
+            [1000.0, 0.1, 0.05, 0.001], # Laminar example
+            [1000.0, 0.5, 0.1, 0.001],  # Transitional example
+            [1000.0, 2.0, 0.1, 0.001],  # Turbulent example
+        ],
+        inputs=[rho, v, D, mu],
+        label="Representative cases",
+        examples_per_page=3,
+        cache_examples=False,
+    )