Upload app.py

app.py

@@ -1207,7 +1207,132 @@ def run_sympy(problem: str) -> dict:
             except Exception:
                 pass  # safe fallback to AI
 
-        # ── 10. Matrix / Eigenvalues — delegate to AI ────────────────────
+        # ── 10. Hydro Mechanics — SymPy for computations, AI for theory ──
+        elif any(k in p for k in [
+                "continuity equation", "equation of continuity",
+                "streamline", "stream function", "stream line",
+                "velocity potential", "irrotational", "rotational motion",
+                "lagrangian", "eulerian", "vortex", "vorticity",
+                "path line", "streak line",
+                "bernoulli", "euler's equation", "euler equation of motion",
+                "torricelli", "flow rate", "discharge",
+                "reynolds number", "reynolds",
+                "hydrostatic pressure", "pressure at depth",
+                "hydrostatic", "buoyancy", "archimedes",
+                "laminar flow", "turbulent flow", "viscous flow",
+                "incompressible fluid", "steady flow",
+                "navier-stokes", "navier stokes",
+                "stokes stream function", "complex velocity potential",
+                "source", "sink", "doublet",
+                "milne thomson", "blasius theorem",
+                "dimensional analysis", "buckingham pi",
+        ]):
+            try:
+                x_h, y_h = sp.symbols('x y')
+                g_val = sp.Rational(981, 100)  # 9.81
+
+                # ── Continuity: find v2 from A1v1=A2v2 ───────────────
+                if any(k in p for k in ["continuity equation","equation of continuity"]):
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if len(nums) >= 3:
+                        A1_v,v1_v,A2_v = nums[0],nums[1],nums[2]
+                        v2_v = round(A1_v*v1_v/A2_v, 6)
+                        Q_v  = round(A1_v*v1_v, 6)
+                        return {
+                            "type": "ContinuityEq",
+                            "result": (f"A1={A1_v}, v1={v1_v}, A2={A2_v}\n"
+                                      f"v2 = A1*v1/A2 = {v2_v} m/s\n"
+                                      f"Flow rate Q = A1*v1 = {Q_v} m³/s"),
+                            "latex": f"v_2 = {v2_v}\\text{{ m/s}}"
+                        }
+
+                # ── Reynolds Number ────────────────────────────────────
+                elif any(k in p for k in ["reynolds number","reynolds"]):
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if len(nums) >= 4:
+                        rho_v,v_v,D_v,mu_v = nums[0],nums[1],nums[2],nums[3]
+                        Re = round(rho_v*v_v*D_v/mu_v, 2)
+                        flow = "Turbulent (Re>4000)" if Re>4000 else ("Transitional (2300<Re<4000)" if Re>2300 else "Laminar (Re<2300)")
+                        return {
+                            "type": "ReynoldsNumber",
+                            "result": f"Re = ρvD/μ = {rho_v}×{v_v}×{D_v}/{mu_v} = {Re} → {flow}",
+                            "latex": f"Re = {Re}"
+                        }
+
+                # ── Bernoulli: find P2 ─────────────────────────────────
+                elif "bernoulli" in p:
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if len(nums) >= 5:
+                        P1_v,v1_v,h1_v,v2_v,h2_v = nums[0],nums[1],nums[2],nums[3],nums[4]
+                        rho_v = 1000  # default water
+                        P2_v = round(P1_v + 0.5*rho_v*(v1_v**2-v2_v**2) + rho_v*9.81*(h1_v-h2_v), 4)
+                        return {
+                            "type": "Bernoulli",
+                            "result": (f"P1+½ρv1²+ρgh1 = P2+½ρv2²+ρgh2\n"
+                                      f"P2 = {P2_v} Pa"),
+                            "latex": f"P_2 = {P2_v}\\text{{ Pa}}"
+                        }
+
+                # ── Torricelli: v = √(2gh) ─────────────────────────────
+                elif "torricelli" in p:
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if nums:
+                        h_v = nums[0]
+                        v_torr = round((2*9.81*h_v)**0.5, 6)
+                        return {
+                            "type": "Torricelli",
+                            "result": f"v = √(2gh) = √(2×9.81×{h_v}) = {v_torr} m/s",
+                            "latex": f"v = {v_torr}\\text{{ m/s}}"
+                        }
+
+                # ── Hydrostatic Pressure ───────────────────────────────
+                elif any(k in p for k in ["hydrostatic pressure","pressure at depth"]):
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if nums:
+                        h_v = nums[0]
+                        rho_v = 1000
+                        P_gauge = round(rho_v*9.81*h_v, 4)
+                        P_abs = round(101325 + P_gauge, 4)
+                        return {
+                            "type": "HydrostaticPressure",
+                            "result": (f"At depth h={h_v}m:\n"
+                                      f"Gauge pressure = ρgh = {P_gauge} Pa\n"
+                                      f"Absolute pressure = P0+ρgh = {P_abs} Pa"),
+                            "latex": f"P = P_0 + \\rho g h = {P_abs}\\text{{ Pa}}"
+                        }
+
+                # ── Flow Rate ──────────────────────────────────────────
+                elif any(k in p for k in ["flow rate","discharge"]):
+                    nums = [float(n) for n in re.findall(r"[-]?\d+\.?\d*", p)]
+                    if len(nums) >= 2:
+                        A_v, v_v = nums[0], nums[1]
+                        Q_v = round(A_v*v_v, 8)
+                        return {
+                            "type": "FlowRate",
+                            "result": f"Q = A×v = {A_v}×{v_v} = {Q_v} m³/s",
+                            "latex": f"Q = {Q_v}\\text{{ m³/s}}"
+                        }
+
+                # ── Velocity Potential ─────────────────────────────────
+                elif "velocity potential" in p:
+                    m = re.search(r"(?:phi|φ|potential)\s*=\s*(.+?)(?:\s|$)", p)
+                    if m:
+                        raw = clean(m.group(1))
+                        phi_expr = parse_expr(raw, transformations=tfms, local_dict={**ld,"x":x_h,"y":y_h})
+                        u_comp = sp.diff(phi_expr, x_h)
+                        v_comp = sp.diff(phi_expr, y_h)
+                        lap = sp.diff(phi_expr,x_h,2) + sp.diff(phi_expr,y_h,2)
+                        return {
+                            "type": "VelocityPotential",
+                            "result": (f"φ={str(phi_expr)}, u=∂φ/∂x={u_comp}, v=∂φ/∂y={v_comp}\n"
+                                      f"∇²φ={sp.simplify(lap)} (irrotational: {sp.simplify(lap)==0})"),
+                            "latex": f"\\nabla^2\\phi = {sp.latex(sp.simplify(lap))}"
+                        }
+
+            except Exception:
+                pass  # safe fallback to AI
+
+        # ── 11. Matrix / Eigenvalues — delegate to AI ────────────────────
         elif any(k in p for k in ["matrix", "determinant", "eigenvalue",
                                    "eigenvector", "det("]):
             return {"type": "Matrix", "result": "matrix_detected", "latex": ""}
@@ -1353,6 +1478,18 @@ def ask_ai(problem: str, sympy_info: dict, history: list) -> str:
         "D. NEVER recompute sin(pi), cos(pi) etc — sin(pi)=0 exactly, always.\n"
         "E. For Lagrange/Newton interpolation: the polynomial is already given above — DO NOT re-expand or re-derive it. Just show the basis polynomials and state the final polynomial from the verified result.\n"
         "F. Your final answer must EXACTLY match the verified result — no exceptions.\n\n"
+        "=== HYDRO MECHANICS RULES (follow exactly) ===\n"
+        "For ANY Hydro Mechanics/Fluid Mechanics question:\n"
+        "A. Always state whether fluid is ideal/viscous, compressible/incompressible first.\n"
+        "B. Continuity equation: A1v1 = A2v2 (incompressible), ∂ρ/∂t + ∇·(ρv) = 0 (general).\n"
+        "C. Bernoulli: P + ½ρv² + ρgh = constant (along streamline, ideal fluid).\n"
+        "D. Reynolds: Re=ρvD/μ — Re<2300 laminar, Re>4000 turbulent.\n"
+        "E. Euler equations: ρ(Dv/Dt) = -∇P + ρg (inviscid flow).\n"
+        "F. Navier-Stokes: ρ(Dv/Dt) = -∇P + μ∇²v + ρg (viscous flow).\n"
+        "G. For proofs: state assumptions → derive step by step → state limitations.\n"
+        "H. Always give physical interpretation of result.\n"
+        "I. Torricelli theorem: v=√(2gh) — derived from Bernoulli.\n"
+        "J. Stream function ψ: u=∂ψ/∂y, v=-∂ψ/∂x. Velocity potential φ: u=∂φ/∂x, v=∂φ/∂y.\n\n"
         "=== DIFFERENTIAL GEOMETRY RULES (follow exactly) ===\n"
         "For ANY Differential Geometry question:\n"
         "A. ALWAYS state the definition or theorem FIRST before computing.\n"