Delete app.py

app.py

@@ -1,343 +0,0 @@
-# app.py
-import math
-from typing import Dict, Any
-
-def darcy_weisbach_head_loss(f: float, L: float, D: float, V: float) -> float:
-    '''Compute head loss h_f using DarcyWeisbach: h_f = f * (L/D) * V^2/(2*g)'''
-    g = 9.80665
-    return f * (L / D) * V**2 / (2 * g)
-
-def reynolds_number(V: float, D: float, nu: float) -> float:
-    return V * D / nu
-
-def default_friction_factor(Re: float, roughness: float, D: float) -> float:
-    '''Estimate friction factor. roughness in m'''
-    if Re == 0:
-        return float('nan')
-    if Re < 2300:
-        return 64.0 / Re
-    # Haaland approximation for turbulent flow
-    e = roughness
-    return ( -1.8 * math.log10( (e/(3.7*D))**1.11 + 6.9/Re ) )**-2
-
-def bernoulli_pipe_flow(
-    P1: float, P2: float,
-    V1: float, V2: float,
-    z1: float = 0.0, z2: float = 0.0,
-    rho: float = 1000.0,
-    mu: float = 0.001,  # Pa.s dynamic viscosity
-    roughness: float = 1.5e-6,  # m
-    D: float = 0.1,  # m
-    L: float = 1.0,  # m
-    friction_factor: float = None,
-    use_darcy: bool = True,
-    g: float = 9.80665
-) -> Dict[str, Any]:
-    '''
-    Deterministic backend.
-
-    Inputs (SI units):
-      P1, P2 : Pa
-      V1, V2 : m/s
-      z1, z2 : m
-      rho : kg/m^3
-      mu : Pa.s
-      roughness : m
-      D : m
-      L : m
-
-    Returns: structured dict containing:
-      - inputs, intermediate values (Re, f, h_f),
-      - head terms, computed left/right/pump_head,
-      - explanations (text steps), summary.
-    '''
-    errors = []
-    if rho <= 0: errors.append('rho must be > 0')
-    if D <= 0: errors.append('D must be > 0')
-    if L < 0: errors.append('L must be >= 0')
-    for val in [P1,P2,V1,V2,z1,z2,rho,mu,D,L]:
-        if not (isinstance(val,(int,float)) and math.isfinite(val)):
-            errors.append('Inputs must be finite numbers')
-            break
-    if errors:
-        return {'ok': False, 'errors': errors}
-
-    nu = mu / rho
-    Re1 = reynolds_number(V1, D, nu)
-    Re2 = reynolds_number(V2, D, nu)
-
-    f = friction_factor if friction_factor is not None else default_friction_factor(max(Re1,Re2), roughness, D)
-    h_f = darcy_weisbach_head_loss(f, L, D, (V1+V2)/2.0) if use_darcy else 0.0
-
-    # Bernoulli (in head units, m): Left = Right + h_f + h_pump - h_turbine
-    left = P1/(rho*g) + V1**2/(2*g) + z1
-    right = P2/(rho*g) + V2**2/(2*g) + z2
-    # pump head required (positive => add head from 1->2)
-    h_pump = left - right + h_f
-
-    results = {
-        'ok': True,
-        'inputs': {
-            'P1_Pa': P1, 'P2_Pa': P2,
-            'V1_m_s': V1, 'V2_m_s': V2,
-            'z1_m': z1, 'z2_m': z2,
-            'rho_kg_m3': rho, 'mu_Pa_s': mu,
-            'D_m': D, 'L_m': L, 'roughness_m': roughness
-        },
-        'intermediate': {
-            'g_m_s2': g,
-            'nu_m2_s': nu,
-            'Re1': Re1, 'Re2': Re2,
-            'friction_factor_f': f,
-            'head_loss_hf_m': h_f
-        },
-        'head_terms': {
-            'P1_over_rho_g_m': P1/(rho*g),
-            'V1_sq_over_2g_m': V1**2/(2*g),
-            'z1_m': z1,
-            'P2_over_rho_g_m': P2/(rho*g),
-            'V2_sq_over_2g_m': V2**2/(2*g),
-            'z2_m': z2
-        },
-        'computed': {
-            'left_hand_side_m': left,
-            'right_hand_side_m': right,
-            'pump_head_required_m': h_pump
-        },
-        'explanations': []
-    }
-
-    # Steps (human-readable)
-    steps = []
-    steps.append(f"Compute kinematic viscosity ν = μ / ρ = {mu} / {rho} = {nu:.6g} m^2/s")
-    steps.append(f"Reynolds numbers: Re1 = V1·D/ν = {V1}·{D}/{nu:.6g} = {Re1:.3g}; Re2 = {Re2:.3g}")
-    steps.append(f"Friction factor f (estimated) = {f:.6g}")
-    steps.append(f"Head loss h_f = f·(L/D)·V_avg^2/(2g) = {h_f:.6g} m (V_avg={(V1+V2)/2.0:.6g} m/s)")
-    steps.append("Apply extended Bernoulli in head units (m):")
-    steps.append(f"Left = P1/(ρg) + V1^2/(2g) + z1 = {results['head_terms']['P1_over_rho_g_m']:.6g} + {results['head_terms']['V1_sq_over_2g_m']:.6g} + {z1} = {left:.6g} m")
-    steps.append(f"Right = P2/(ρg) + V2^2/(2g) + z2 = {results['head_terms']['P2_over_rho_g_m']:.6g} + {results['head_terms']['V2_sq_over_2g_m']:.6g} + {z2} = {right:.6g} m")
-    steps.append(f"Pump head required h_pump = Left - Right + h_f = {h_pump:.6g} m")
-
-    results['explanations'] = steps
-    results['summary'] = (f"To move fluid from point 1 -> 2 requires pump head {h_pump:.6g} m. "
-                          f"Estimated friction factor f={f:.6g} (Re ~ {max(Re1,Re2):.3g}). Head loss h_f={h_f:.6g} m.")
-    return results
-
-# Deterministic explainer (consumes the structured record and returns text)
-import json, requests, os
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-
-
-def deterministic_explainer(record: dict) -> str:
-    if not record.get('ok', False):
-        return 'Errors: ' + '; '.join(record.get('errors', ['Unknown error']))
-    lines = []
-    lines.append("--- EXPLANATION (deterministic)---")
-    # Summary (always string)
-    summary = record.get('summary', '')
-    lines.append(str(summary))
-    lines.append("Inputs (SI):")
-    for k,v in record['inputs'].items():
-        lines.append(f" - {k}: {v}")
-    lines.append('Intermediate values:')
-    for k,v in record['intermediate'].items():
-        lines.append(f" - {k}: {v}")
-    lines.append('Calculation steps:')
-    for s in record.get('explanations',[]):
-        lines.append(' * '+s)
-    lines.append('Notes: Assumptions: incompressible, single-phase, steady flow. Use within validated ranges only.')
-    return '\n'.join(lines)
-# Local LLM setup
-MODEL_ID = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
-tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-pipe = pipeline(
-    task="text-generation",
-    #model=AutoModelForCausalLM.from_pretrained(MODEL_ID),
-    model=MODEL_ID,
-    tokenizer=tokenizer
-)
-
-def _fmt_num(x, sig=4):
-    '''Safe, short formatting for numbers (returns string).'''
-    try:
-        if x is None:
-            return "N/A"
-        if isinstance(x, (int,)):
-            return str(x)
-        if isinstance(x, float):
-            # use general format with sig significant digits
-            return f"{x:.{sig}g}"
-        return str(x)
-    except Exception:
-        return str(x)
-
-def _llm_generate(prompt: str, max_tokens: int = 300) -> str:
-    '''
-    Run the local pipeline, then strip any echoed prompt and common instruction text.
-    If the model echoes instructions, do one gentle retry with a simplified prompt.
-    '''
-    # Primary generation: deterministic (no sampling) is usually safer for engineering text.
-    try:
-        out = pipe(
-            prompt,
-            max_new_tokens=max_tokens,
-            do_sample=False,
-            temperature=0.0,
-            return_full_text=True,
-        )
-    except Exception:
-        # fallback: try return_full_text=False if first attempt fails for this model
-        out = pipe(
-            prompt,
-            max_new_tokens=max_tokens,
-            do_sample=False,
-            temperature=0.0,
-            return_full_text=False,
-        )
-
-    # get text (handle both pipeline variants)
-    text = ""
-    if isinstance(out, list) and len(out) > 0:
-        text = out[0].get("generated_text", "") or out[0].get("text", "") or ""
-    text = text or ""
-    # If the model returned the prompt + output, strip the prompt if present
-    if text.startswith(prompt):
-        text = text[len(prompt):]
-    text = text.strip()
-
-    # If output looks like it merely repeated instructions, try a simpler short-prompt retry
-    low_quality_indicators = [
-        "Use bullet points", "Be sure to include", "Do not", "Do NOT",
-        "Now produce", "System:", "User:", "Instruction:"
-    ]
-    if (not text) or any(ind in text for ind in low_quality_indicators) or len(text) < 10:
-        # simple short retry prompt asking for only the final answer
-        simple_prompt = prompt + "
-
-Now produce ONLY the requested explanation below (no re-statement of the prompt or instructions):
-"
-        try:
-            out2 = pipe(
-                simple_prompt,
-                max_new_tokens=max_tokens,
-                do_sample=False,
-                temperature=0.0,
-                return_full_text=True,
-            )
-        except Exception:
-            out2 = pipe(
-                simple_prompt,
-                max_new_tokens=max_tokens,
-                do_sample=False,
-                temperature=0.0,
-                return_full_text=False,
-            )
-        text2 = out2[0].get("generated_text", "") or out2[0].get("text", "") or ""
-        if text2.startswith(simple_prompt):
-            text2 = text2[len(simple_prompt):]
-        text2 = text2.strip()
-        if text2 and len(text2) > 10 and not any(ind in text2 for ind in low_quality_indicators):
-            return text2
-        # final fallback:
-        return "[LLM failed to generate a usable explanation — try a different model or reduce the prompt size]"
-
-    return text
-
-
-def llm_explain(record: dict) -> str:
-    '''Deterministic explanation using numeric values, LLM optional for style.'''
-    if not record.get("ok", False):
-        return "Errors: " + "; ".join(record.get("errors", []))
-
-    computed = record.get("computed", {})
-    intermediate = record.get("intermediate", {})
-
-    # Extract values
-    pump_head = computed.get("pump_head_required_m", None)
-    f = intermediate.get("friction_factor_f", None)
-    hf = intermediate.get("head_loss_hf_m", None)
-    Re1 = intermediate.get("Re1", None)
-    Re2 = intermediate.get("Re2", None)
-
-    # Flow regime classification
-    Re_avg = (Re1 + Re2) / 2 if (Re1 is not None and Re2 is not None) else None
-    if Re_avg is None or Re_avg != Re_avg:
-        regime = "unknown"
-    elif Re_avg < 2300:
-        regime = "laminar"
-    else:
-        regime = "turbulent"
-
-    # Format numbers
-    ph_str = _fmt_num(pump_head)
-    f_str = _fmt_num(f)
-    hf_str = _fmt_num(hf)
-
-    # Deterministic summary
-    summary = f"Pump head is {ph_str} m, friction factor is {f_str}, and head loss is {hf_str} m. Flow is {regime}."
-
-    explanation = (
-        f"Summary paragraph: {summary}
-"
-        f"Flow regime: {regime}
-"
-        f"Warning: none
-"
-        f"Key result: {ph_str} m"
-    )
-
-    return explanation
-import gradio as gr
-import json, requests
-
-# Paste the bernoulli_pipe_flow, deterministic_explainer, hf_llm_explainer functions here
-# (copy from the Colab cells above). For brevity, this file assumes they are present.
-
-# For example, import them from a module if you split code. Here we assume they are defined above.
-
-def compute_and_explain(P1,P2,V1,V2,z1,z2,rho,mu,D,L,roughness,use_darcy,hf_token,explain_mode):
-    record = bernoulli_pipe_flow(P1,P2,V1,V2,z1,z2,rho,mu,roughness,D,L, None, use_darcy)
-    if not record.get('ok'):
-      return record, 'Errors: ' + '; '.join(record.get('errors',[]))
-    if explain_mode == 'deterministic':
-      explanation = deterministic_explainer(record)
-    elif explain_mode == 'local_llm':
-      explanation = llm_explain(record)
-    else:
-      explanation = "Unknown explanation mode selected."
-    return record, explanation
-
-with gr.Blocks() as demo:
-    gr.Markdown("# Bernoulli Pipe Flow Calculator")
-    gr.Markdown("This Space hosts a Bernoulli pipe flow calculator for calculating the pump head loss for an internal flow system through a pipe. An example of one such pipe system is shown below. To utilize this calculator, simply fill in the required system metrics and hit 'compute'.")
-    gr.Image('/file=bernoulli.png')
-    with gr.Row():
-        with gr.Column(scale=2):
-            P1 = gr.Number(value=101325, label='P1 [Pa]')
-            P2 = gr.Number(value=101325, label='P2 [Pa]')
-            V1 = gr.Number(value=1.0, label='V1 [m/s]')
-            V2 = gr.Number(value=1.0, label='V2 [m/s]')
-            z1 = gr.Number(value=0.0, label='z1 [m]')
-            z2 = gr.Number(value=0.0, label='z2 [m]')
-            rho = gr.Number(value=1000.0, label='rho [kg/m^3]')
-            mu = gr.Number(value=0.001, label='mu [Pa.s]')
-            D = gr.Number(value=0.1, label='D [m]')
-            L = gr.Number(value=10.0, label='L [m]')
-            roughness = gr.Number(value=1.5e-6, label='roughness [m]')
-            use_darcy = gr.Checkbox(value=True, label='Use Darcy–Weisbach')
-            hf_token = gr.Textbox(value='', label='HF API token (optional)')
-            run_btn = gr.Button('Compute')
-        with gr.Column(scale=3):
-            numeric_out = gr.JSON(label='Structured numeric result (JSON)')
-            gr.Markdown('---')
-            explain_mode = gr.Radio(['deterministic','local_llm'], value='deterministic', label='Explanation mode')
-            explanation_out = gr.Textbox(lines=15, label='Explanation')
-
-    run_btn.click(
-        compute_and_explain,
-        inputs=[P1,P2,V1,V2,z1,z2,rho,mu,D,L,roughness,use_darcy,hf_token,explain_mode],
-        outputs=[numeric_out, explanation_out]
-    )
-
-demo.queue().launch() 
-