Adding updated datasets and updated app.py and template code UI

app.py

@@ -10,20 +10,25 @@ from src.template_loader import (
 )
 from src.storage import save_review
 
-# --- Page Configuration ---
+#  Page Configuration 
 st.set_page_config(layout="wide", page_title="EngChain Annotator")
 
-# --- Custom CSS for Styling ---
+#  Custom CSS for Styling 
 # This forces the primary buttons to have a specific look (optional but helps visibility)
 st.markdown("""
 <style>
     div.stButton > button:first-child {
         font-weight: bold;
     }
+    /* FIX: Lock sidebar position and disable scrolling */
+    section[data-testid="stSidebar"] {
+        position: fixed;
+        overflow: hidden !important;
+    }
 </style>
 """, unsafe_allow_html=True)
 
-# --- Helper Function: Build the Queue ---
+#  Helper Function: Build the Queue 
 def build_review_queue(branch):
     """
     Scans the entire branch and creates a list of all templates to review.
@@ -59,7 +64,7 @@ def build_review_queue(branch):
     progress_bar.empty()
     return queue
 
-# --- Session State Initialization ---
+#  Session State Initialization 
 if "app_mode" not in st.session_state:
     st.session_state["app_mode"] = "landing" # landing, review, done
 if "review_queue" not in st.session_state:
@@ -92,7 +97,7 @@ if st.session_state["app_mode"] == "landing":
     5. Rate it, Approve/Reject it, and click **Submit**.
     """)
     
-    st.markdown("---")
+    st.markdown("")
     
     with st.form("onboarding_form"):
         st.subheader("Annotator Details")
@@ -139,12 +144,12 @@ elif st.session_state["app_mode"] == "review":
     
     current_item = queue[idx]
     
-    # --- Sidebar Info ---
+    #  Sidebar Info 
     st.sidebar.title("Progress")
     st.sidebar.progress((idx) / len(queue))
     st.sidebar.write(f"Template: {idx + 1} / {len(queue)}")
     
-    st.sidebar.markdown("---")
+    st.sidebar.markdown("")
     st.sidebar.subheader("Current Context")
     
     # Distinct styling for keys and values
@@ -157,14 +162,14 @@ elif st.session_state["app_mode"] == "review":
     st.sidebar.markdown("**🧩 Function:**")
     st.sidebar.info(current_item['name'])
     
-    # --- Main Content ---
+    #  Main Content 
     st.title(f"Reviewing: {current_item['name']}")
     
     # Tabs for Inspection
     tab1, tab2 = st.tabs(["Source Code", "Generated Trace"])
     
     with tab1:
-        code_text = get_source_code(current_item['branch'], current_item['area'], current_item['file'])
+        code_text = get_source_code(current_item['func'])
         st.code(code_text, language="python", line_numbers=True)
         
     with tab2:
@@ -183,9 +188,9 @@ elif st.session_state["app_mode"] == "review":
             st.error("Template Execution Failed")
             st.code(traceback.format_exc())
 
-    st.markdown("---")
+    st.markdown("")
 
-    # --- Scoring Form ---
+    #  Scoring Form 
     st.subheader("Audit Decision")
     
     # Use a container so we can disable the form after submission

data/templates/branches/chemical_engineering/constants.py

@@ -186,6 +186,46 @@ THERMO_SUBSTANCES = [
 ]
 
 
+# A dictionary of real-world saturation properties for common thermodynamic substances.
+# Each entry contains: temperature (°C), specific volume of saturated liquid (m³/kg),
+# and specific volume of saturated vapor (m³/kg)
+# Data sources: NIST WebBook, Engineering Toolbox, and standard thermodynamic tables.
+REAL_FLUID_DATA = {
+    #  Classic Working Fluids 
+    "Water": {"temp_C": 100, "v_f": 0.001043, "v_g": 1.6729},
+    "Ammonia": {"temp_C": 25, "v_f": 0.001658, "v_g": 0.1284},
+    "Carbon Dioxide": {"temp_C": 20, "v_f": 0.001286, "v_g": 0.0188},
+    "Sulfur Dioxide": {"temp_C": 25, "v_f": 0.000728, "v_g": 0.1165},
+    
+    #  Hydrocarbons 
+    "Methane": {"temp_C": -161, "v_f": 0.002367, "v_g": 1.8160},  # Boiling Point
+    "Ethane": {"temp_C": -89, "v_f": 0.001830, "v_g": 0.7090},  # Boiling Point
+    "Propane": {"temp_C": 25, "v_f": 0.002028, "v_g": 0.0461},
+    "Butane": {"temp_C": 25, "v_f": 0.001726, "v_g": 0.1632},
+    "Isobutane": {"temp_C": 25, "v_f": 0.001815, "v_g": 0.1118},
+    "Pentane": {"temp_C": 25, "v_f": 0.001598, "v_g": 0.5050},
+    "Iso-pentane": {"temp_C": 25, "v_f": 0.001614, "v_g": 0.4910},
+    
+    #  Refrigerants 
+    "Refrigerant-11 (R-11, Trichlorofluoromethane)": {"temp_C": 25, "v_f": 0.000675, "v_g": 0.1580},
+    "Refrigerant-12 (R-12, Dichlorodifluoromethane)": {"temp_C": 25, "v_f": 0.000763, "v_g": 0.0268},
+    "Refrigerant-22 (R-22, Chlorodifluoromethane)": {"temp_C": 25, "v_f": 0.000845, "v_g": 0.0226},
+    "Refrigerant-134a (R-134a, 1,1,1,2-Tetrafluoroethane)": {"temp_C": 25, "v_f": 0.000829, "v_g": 0.0323},
+    "Refrigerant-123 (R-123, Dichlorotrifluoroethane)": {"temp_C": 25, "v_f": 0.000680, "v_g": 0.1810},
+    "Refrigerant-410A (R-410A, blend of difluoromethane and pentafluoroethane)": {"temp_C": 25, "v_f": 0.000922, "v_g": 0.0151},
+    
+    #  Organic Solvents (Rankine Fluids) 
+    "Toluene": {"temp_C": 111, "v_f": 0.001308, "v_g": 0.3200},  # Boiling Point
+    "Benzene": {"temp_C": 80, "v_f": 0.001205, "v_g": 0.3660},  # Boiling Point
+    "Ethanol": {"temp_C": 78, "v_f": 0.001290, "v_g": 0.5770},  # Boiling Point
+    "Methanol": {"temp_C": 65, "v_f": 0.001375, "v_g": 0.8800},  # Boiling Point
+    "Acetone": {"temp_C": 56, "v_f": 0.001360, "v_g": 0.5370},  # Boiling Point
+    "n-Hexane": {"temp_C": 69, "v_f": 0.001660, "v_g": 0.3550},  # Boiling Point
+    "n-Octane": {"temp_C": 126, "v_f": 0.001690, "v_g": 0.2500},  # Boiling Point
+    "Cyclohexane": {"temp_C": 81, "v_f": 0.001420, "v_g": 0.3600}  # Boiling Point
+}
+
+
 # A dictionary with comprehensive critical properties for various substances.
 # Tc: Kelvin (K), Pc: bar, Vc: cm³/mol, Zc: dimensionless, omega: dimensionless.
 CRITICAL_PROPERTIES = {
@@ -220,47 +260,50 @@ CRITICAL_PROPERTIES = {
 
 
 # Common materials which undergo heating with their specific heat capacities in J/g·K
+# Added 'min_temp' and 'max_temp' (in °C) to ensure phase stability.
 SUBSTANCES_FOR_HEATING = [
-    # Metals & Solids
-    {"name": "Iron", "state": "solid", "Cp": 0.449},
-    {"name": "Copper", "state": "solid", "Cp": 0.385},
-    {"name": "Aluminum", "state": "solid", "Cp": 0.897},
-    {"name": "Gold", "state": "solid", "Cp": 0.129},
-    {"name": "Lead", "state": "solid", "Cp": 0.16},
-    {"name": "Silver", "state": "solid", "Cp": 0.235},
-    {"name": "Tungsten", "state": "solid", "Cp": 0.134},
-    {"name": "Silicon", "state": "solid", "Cp": 0.705},
-    {"name": "Graphite (Carbon)", "state": "solid", "Cp": 0.709},
-    {"name": "Glass (typical)", "state": "solid", "Cp": 0.84},
-    {"name": "Ice (at 0°C)", "state": "solid", "Cp": 2.09},
-    {"name": "Concrete", "state": "solid", "Cp": 0.88},
-    {"name": "Wood (typical)", "state": "solid", "Cp": 1.7},
-    {"name": "Polyethylene (plastic)", "state": "solid", "Cp": 2.3},
-
-    # Liquids
-    {"name": "Water", "state": "liquid", "Cp": 4.18},
-    {"name": "Ethanol", "state": "liquid", "Cp": 2.44},
-    {"name": "Methanol", "state": "liquid", "Cp": 2.53},
-    {"name": "Acetone", "state": "liquid", "Cp": 2.17},
-    {"name": "Mercury", "state": "liquid", "Cp": 0.14},
-    {"name": "Glycerol", "state": "liquid", "Cp": 2.43},
-    {"name": "Ethylene Glycol (Antifreeze)", "state": "liquid", "Cp": 2.36},
-    {"name": "Olive Oil", "state": "liquid", "Cp": 1.97},
-    {"name": "Engine Oil (typical)", "state": "liquid", "Cp": 1.9},
-    {"name": "Sulfuric Acid", "state": "liquid", "Cp": 1.42},
-
-    # Gases (at constant pressure, 25°C)
-    {"name": "Air (dry)", "state": "gas", "Cp": 1.005},
-    {"name": "Nitrogen", "state": "gas", "Cp": 1.04},
-    {"name": "Oxygen", "state": "gas", "Cp": 0.918},
-    {"name": "Hydrogen", "state": "gas", "Cp": 14.31},
-    {"name": "Helium", "state": "gas", "Cp": 5.193},
-    {"name": "Argon", "state": "gas", "Cp": 0.520},
-    {"name": "Carbon Dioxide", "state": "gas", "Cp": 0.839},
-    {"name": "Methane", "state": "gas", "Cp": 2.22},
-    {"name": "Ammonia", "state": "gas", "Cp": 2.06},
-    {"name": "Water Vapor (Steam, 100°C)", "state": "gas", "Cp": 2.01},
-    {"name": "Chlorine", "state": "gas", "Cp": 0.48}
+    # Metals & Solids (Generally safe 20°C - 500°C)
+    {"name": "Iron", "state": "solid", "Cp": 0.449, "min_temp": 20, "max_temp": 500},
+    {"name": "Copper", "state": "solid", "Cp": 0.385, "min_temp": 20, "max_temp": 500},
+    {"name": "Aluminum", "state": "solid", "Cp": 0.897, "min_temp": 20, "max_temp": 500},
+    {"name": "Gold", "state": "solid", "Cp": 0.129, "min_temp": 20, "max_temp": 500},
+    {"name": "Lead", "state": "solid", "Cp": 0.16, "min_temp": 20, "max_temp": 300},
+    {"name": "Silver", "state": "solid", "Cp": 0.235, "min_temp": 20, "max_temp": 500},
+    {"name": "Tungsten", "state": "solid", "Cp": 0.134, "min_temp": 20, "max_temp": 1000},
+    {"name": "Silicon", "state": "solid", "Cp": 0.705, "min_temp": 20, "max_temp": 500},
+    {"name": "Graphite (Carbon)", "state": "solid", "Cp": 0.709, "min_temp": 20, "max_temp": 1000},
+    {"name": "Glass (typical)", "state": "solid", "Cp": 0.84, "min_temp": 20, "max_temp": 500},
+    {"name": "Concrete", "state": "solid", "Cp": 0.88, "min_temp": 20, "max_temp": 500},
+    {"name": "Wood (typical)", "state": "solid", "Cp": 1.7, "min_temp": 20, "max_temp": 150},
+    {"name": "Polyethylene (plastic)", "state": "solid", "Cp": 2.3, "min_temp": 20, "max_temp": 100}, # Melts ~115°C
+
+    # Phase-Sensitive Solids
+    {"name": "Ice (at 0°C)", "state": "solid", "Cp": 2.09, "min_temp": -50, "max_temp": -2}, # Must be < 0°C
+
+    # Liquids (Must stay between Freezing and Boiling Points)
+    {"name": "Water", "state": "liquid", "Cp": 4.18, "min_temp": 5, "max_temp": 95},
+    {"name": "Ethanol", "state": "liquid", "Cp": 2.44, "min_temp": -50, "max_temp": 75}, # Boils at 78°C
+    {"name": "Methanol", "state": "liquid", "Cp": 2.53, "min_temp": -50, "max_temp": 60}, # Boils at 65°C
+    {"name": "Acetone", "state": "liquid", "Cp": 2.17, "min_temp": -50, "max_temp": 50}, # Boils at 56°C
+    {"name": "Mercury", "state": "liquid", "Cp": 0.14, "min_temp": -30, "max_temp": 300},
+    {"name": "Glycerol", "state": "liquid", "Cp": 2.43, "min_temp": 20, "max_temp": 250},
+    {"name": "Ethylene Glycol (Antifreeze)", "state": "liquid", "Cp": 2.36, "min_temp": -10, "max_temp": 190},
+    {"name": "Olive Oil", "state": "liquid", "Cp": 1.97, "min_temp": 20, "max_temp": 200},
+    {"name": "Engine Oil (typical)", "state": "liquid", "Cp": 1.9, "min_temp": 20, "max_temp": 250},
+    {"name": "Sulfuric Acid", "state": "liquid", "Cp": 1.42, "min_temp": 20, "max_temp": 300},
+
+    # Gases (Wide range, but avoid condensation for vapors)
+    {"name": "Air (dry)", "state": "gas", "Cp": 1.005, "min_temp": -50, "max_temp": 500},
+    {"name": "Nitrogen", "state": "gas", "Cp": 1.04, "min_temp": -100, "max_temp": 500},
+    {"name": "Oxygen", "state": "gas", "Cp": 0.918, "min_temp": -100, "max_temp": 500},
+    {"name": "Hydrogen", "state": "gas", "Cp": 14.31, "min_temp": -100, "max_temp": 500},
+    {"name": "Helium", "state": "gas", "Cp": 5.193, "min_temp": -200, "max_temp": 500},
+    {"name": "Argon", "state": "gas", "Cp": 0.520, "min_temp": -100, "max_temp": 500},
+    {"name": "Carbon Dioxide", "state": "gas", "Cp": 0.839, "min_temp": -50, "max_temp": 500},
+    {"name": "Methane", "state": "gas", "Cp": 2.22, "min_temp": -100, "max_temp": 500},
+    {"name": "Ammonia", "state": "gas", "Cp": 2.06, "min_temp": -20, "max_temp": 400},
+    {"name": "Water Vapor (Steam)", "state": "gas", "Cp": 2.01, "min_temp": 105, "max_temp": 400}, # Must be > 100°C
+    {"name": "Chlorine", "state": "gas", "Cp": 0.48, "min_temp": 20, "max_temp": 200}
 ]
 
 
@@ -294,16 +337,22 @@ SUBSTANCES_FOR_VAPORIZATION = [
 
 
 # Database of standard heats of formation (ΔH_f°) at 298.15 K in kJ/mol.
-# A value of 0 indicates an element in its standard state.
 HEATS_OF_FORMATION = {
-    # Hydrocarbons
+    # Hydrocarbons (Gases)
     "CH4(g)": -74.8,      # Methane
+    "C2H2(g)": 226.7,     # Acetylene (Added)
     "C2H6(g)": -84.7,     # Ethane
     "C3H8(g)": -103.8,    # Propane
+    "C4H10(g)": -125.7,   # Butane (Added)
+    "C8H18(g)": -208.4,   # Octane (Gas phase) (Added)
     "C6H6(l)": 49.0,      # Benzene
-    # Alcohols
-    "CH3OH(l)": -238.6,   # Methanol
-    "C2H5OH(l)": -277.7,  # Ethanol
+
+    # Alcohols (Liquids & Gases)
+    "CH3OH(l)": -238.6,   # Methanol (Liquid)
+    "CH3OH(g)": -200.7,   # Methanol (Gas) (Added - required for adiabatic flame temp)
+    "C2H5OH(l)": -277.7,  # Ethanol (Liquid)
+    "C2H5OH(g)": -235.1,  # Ethanol (Gas) (Added - required for adiabatic flame temp)
+
     # Common Gases & Products
     "O2(g)": 0,
     "H2(g)": 0,
@@ -312,7 +361,7 @@ HEATS_OF_FORMATION = {
     "CO2(g)": -393.5,
     "H2O(g)": -241.8,
     "H2O(l)": -285.8,
-    "NH3(g)": -46.1,      # Ammonia
+    "NH3(g)": -46.1,
     "NO(g)": 90.3,
     "NO2(g)": 33.2,
 }

data/templates/branches/chemical_engineering/reaction_kinetics/stoichiometry.py

@@ -1,5 +1,5 @@
 import random
-from data.templates.branches.chemical_engineering.constants import GENERAL_REACTANTS, LIQUID_PHASE_REACTANTS, GAS_PHASE_REACTANTS, PRODUCTS
+from data.templates.branches.chemical_engineering.constants import GENERAL_REACTANTS, LIQUID_PHASE_REACTANTS, GAS_PHASE_REACTANTS, PRODUCTS, REACTIONS
 
 
 # Template 1 (Easy)
@@ -23,25 +23,37 @@ def template_batch_moles_vs_conversion():
             - str: A question about calculating final moles in a batch reactor.
             - str: A detailed, step-by-step solution.
     """
-    # 1. Randomized Parameters
-    
-    # Select names for reactants and products
-    reactant_A_name, reactant_B_name = random.sample(LIQUID_PHASE_REACTANTS, 2)
-    product_C_name, product_D_name = random.sample(PRODUCTS, 2)
+    # 1. Parameterize Inputs using Valid Reactions
+    # Select a real, pre-balanced reaction to ensure chemical plausibility
+    reaction_data = random.choice(REACTIONS)
+    equation = reaction_data["equation"]
+
+    # Extract reactants and products
+    reactant_items = list(reaction_data["reactants"].items())
+    product_items = list(reaction_data["products"].items())
+
+    # Map to A, B, C, D variables
+    # We assume the reaction has at least 2 reactants.
+    reactant_A_name, a = reactant_items[0]
+    reactant_B_name, b = reactant_items[1]
     
-    # Generate stoichiometric coefficients
-    a = random.choice([1, 2])
-    b = random.randint(1, 3)
-    c = random.randint(1, 3)
-    d = random.randint(1, 3)
+    product_C_name, c = product_items[0]
+    # Handle case where there might be only 1 product
+    has_product_D = len(product_items) > 1
+    if has_product_D:
+        product_D_name, d = product_items[1]
+    else:
+        product_D_name, d = "None", 0
 
-    # Generate initial moles, ensuring A is the limiting reactant
+    # Generate initial moles
+    # Ensure A is the limiting reactant (N_A0/a < N_B0/b)
     N_A0 = round(random.uniform(10.0, 25.0), 2)
-    # Ensure B is in excess (at least 20% more than stoichiometrically required)
-    N_B0 = round((N_A0 * b / a) * random.uniform(1.2, 2.0), 2)
-    # Initial moles of products are often zero but can be non-zero
-    N_C0 = round(random.choice([0.0, random.uniform(1.0, 5.0)]), 2)
-    N_D0 = round(random.choice([0.0, random.uniform(1.0, 5.0)]), 2)
+    min_N_B0 = (N_A0 / a) * b
+    N_B0 = round(min_N_B0 * random.uniform(1.2, 2.0), 2)
+    
+    # Explicitly set initial product moles to zero for clarity
+    N_C0 = 0.0
+    N_D0 = 0.0
 
     # Generate a realistic conversion for the limiting reactant A
     X_A = round(random.uniform(0.40, 0.95), 2)
@@ -50,63 +62,63 @@ def template_batch_moles_vs_conversion():
     N_A = N_A0 * (1 - X_A)
     N_B = N_B0 - (b / a) * N_A0 * X_A
     N_C = N_C0 + (c / a) * N_A0 * X_A
-    N_D = N_D0 + (d / a) * N_A0 * X_A
+    N_D = N_D0 + (d / a) * N_A0 * X_A if has_product_D else 0.0
 
     # 3. Generate Question and Solution Strings
-    
-    # Helper function to format the reaction string cleanly (e.g., "A" instead of "1A")
-    def format_species(coeff, name):
-        return f"{coeff if coeff > 1 else ''}{name}"
-
-    reaction_string = (
-        f"{format_species(a, reactant_A_name)} + {format_species(b, reactant_B_name)} -> "
-        f"{format_species(c, product_C_name)} + {format_species(d, product_D_name)}"
-    )
-
     question = (
-        f"Consider the following elementary liquid-phase reaction carried out in a batch reactor:\n"
-        f"**Reaction:** ${reaction_string}$\n\n"
-        f"The reactor is initially charged with ${N_A0}$ moles of {reactant_A_name}, "
-        f"${N_B0}$ moles of {reactant_B_name}, and ${N_C0}$ moles of {product_C_name}. "
+        f"Consider the following reaction carried out in a batch reactor:\n"
+        f"**Reaction:** ${equation}$\n\n"
+        f"The reactor is initially charged with ${N_A0}$ moles of {reactant_A_name} and "
+        f"${N_B0}$ moles of {reactant_B_name}. Assume the initial amount of products is zero.\n"
         f"{reactant_A_name} is the limiting reactant.\n\n"
-        f"If the reaction is allowed to proceed until a conversion of ${X_A}$ ($_A$) is achieved, "
+        f"If the reaction is allowed to proceed until a conversion of ${X_A}$ ($X_A$) is achieved, "
         f"calculate the final number of moles of all species in the reactor."
     )
 
     solution = (
         f"**Step 1:** Identify Given Information\n"
-        f"- Reaction: ${reaction_string}$\n"
+        f"- Reaction: ${equation}$\n"
         f"- Initial Moles:\n"
         f"  - $N_{{{reactant_A_name},0}} = {N_A0}$ mol\n"
         f"  - $N_{{{reactant_B_name},0}} = {N_B0}$ mol\n"
-        f"  - $N_{{{product_C_name},0}} = {N_C0}$ mol\n"
-        f"  - $N_{{{product_D_name},0}} = {N_D0}$ mol\n"
+        f"  - Products = 0 mol\n"
         f"- Conversion of {reactant_A_name}: $X_A = {X_A}$\n\n"
         
         f"**Step 2:** Write Stoichiometric Relations in Terms of Conversion\n"
-        f"The number of moles of each species ($N_j$) at any conversion $X_A$ can be expressed using the following design equations for a batch system:\n"
+        f"The number of moles of each species ($N_j$) at any conversion $X_A$ is given by:\n"
         f"- $N_A = N_{{A,0}}(1 - X_A)$\n"
-        f"- $N_B = N_{{B,0}} - (b/a) N_{{A,0}} X_A$\n"
-        f"- $N_C = N_{{C,0}} + (c/a) N_{{A,0}} X_A$\n"
-        f"- $N_D = N_{{D,0}} + (d/a) N_{{A,0}} X_A$\n\n"
+        f"- $N_B = N_{{B,0}} - ({b}/{a}) N_{{A,0}} X_A$\n"
+        f"- $N_C = N_{{C,0}} + ({c}/{a}) N_{{A,0}} X_A$\n"
+    )
+    if has_product_D:
+        solution += f"- $N_D = N_{{D,0}} + ({d}/{a}) N_{{A,0}} X_A$\n"
+    solution += "\n"
         
+    solution += (
         f"**Step 3:** Calculate Final Moles for Each Species\n"
         f"For {reactant_A_name} (A):\n"
-        f"$N_A = {N_A0}(1 - {X_A}) = {N_A0}({1-X_A}) = {round(N_A, 3)}$ mol\n\n"
+        f"$N_A = {N_A0}(1 - {X_A}) = {N_A0}({1-X_A:.2f}) = {round(N_A, 3)}$ mol\n\n"
         f"For {reactant_B_name} (B):\n"
         f"$N_B = {N_B0} - ({b}/{a}) \\times {N_A0} \\times {X_A} = {N_B0} - {round((b/a)*N_A0*X_A, 3)} = {round(N_B, 3)}$ mol\n\n"
         f"For {product_C_name} (C):\n"
-        f"$N_C = {N_C0} + ({c}/{a}) \\times {N_A0} \\times {X_A} = {N_C0} + {round((c/a)*N_A0*X_A, 3)} = {round(N_C, 3)}$ mol\n\n"
-        f"For {product_D_name} (D):\n"
-        f"$N_D = {N_D0} + ({d}/{a}) \\times {N_A0} \\times {X_A} = {N_D0} + {round((d/a)*N_A0*X_A, 3)} = {round(N_D, 3)}$ mol\n\n"
+        f"$N_C = 0 + ({c}/{a}) \\times {N_A0} \\times {X_A} = {round((c/a)*N_A0*X_A, 3)} = {round(N_C, 3)}$ mol\n\n"
+    )
+    
+    if has_product_D:
+        solution += (
+            f"For {product_D_name} (D):\n"
+            f"$N_D = 0 + ({d}/{a}) \\times {N_A0} \\times {X_A} = {round((d/a)*N_A0*X_A, 3)} = {round(N_D, 3)}$ mol\n\n"
+        )
         
+    solution += (
         f"**Final Answer**\n"
         f"After reaching a conversion of ${X_A*100} \%$, the final number of moles in the reactor are:\n"
         f"- {reactant_A_name}: ${round(N_A, 3)}$ mol\n"
         f"- {reactant_B_name}: ${round(N_B, 3)}$ mol\n"
         f"- {product_C_name}: ${round(N_C, 3)}$ mol\n"
-        f"- {product_D_name}: ${round(N_D, 3)}$ mol"
     )
+    if has_product_D:
+        solution += f"- {product_D_name}: ${round(N_D, 3)}$ mol"
 
     return question, solution
 
@@ -122,31 +134,46 @@ def template_flow_system_molar_flow_rates():
         inlet flow rates and the conversion of a limiting reactant. The calculation
         is an application of stoichiometric principles to a flow system, using:
 
-            $F_A = F_{A0}(1 - X_A)$
-            $F_j = F_{j0} + \\nu_j F_{A0} X_A = F_{A0}(\\Theta_j + \\nu_j X_A)$
+            F_A = F_A0(1 - X_A)
+            F_j = F_j0 + nu_j * F_A0 * X_A = F_A0(Theta_j + nu_j * X_A)
 
-        where $\\nu_j$ is the stoichiometric coefficient and $\\Theta_j = F_{j0}/F_{A0}$.
+        where nu_j is the stoichiometric coefficient and Theta_j = F_j0/F_A0.
 
     Returns:
         tuple: A tuple containing:
             - str: A question about calculating outlet molar flow rates.
             - str: A detailed, step-by-step solution.
     """
-    # 1. Randomized Parameters
+    # 1. Parameterize Inputs using Valid Reactions
+    # Select a real, pre-balanced reaction to ensure chemical plausibility
+    reaction_data = random.choice(REACTIONS)
+    equation = reaction_data["equation"]
+
+    # Extract reactants and products
+    # The dictionaries are in the format {"Name": coefficient}
+    reactant_items = list(reaction_data["reactants"].items())
+    product_items = list(reaction_data["products"].items())
+
+    # Map to A, B, C, D variables
+    # We assume the reaction has at least 2 reactants.
+    reactant_A_name, a = reactant_items[0]
+    reactant_B_name, b = reactant_items[1]
     
-    # Select unique names for reactants and products
-    reactant_A_name, reactant_B_name = random.sample(GENERAL_REACTANTS, 2)
-    product_C_name, product_D_name = random.sample(PRODUCTS, 2)
-    
-    # Generate stoichiometric coefficients
-    a = random.choice([1, 2])
-    b = random.randint(1, 3)
-    c = random.randint(1, 3)
-    d = random.randint(1, 3)
+    product_C_name, c = product_items[0]
+    # Handle case where there might be only 1 product
+    has_product_D = len(product_items) > 1
+    if has_product_D:
+        product_D_name, d = product_items[1]
+    else:
+        product_D_name, d = "None", 0
 
-    # Generate inlet molar flow rates (mol/min), ensuring A is limiting
+    # Generate inlet molar flow rates (mol/min)
+    # Ensure A is the limiting reactant by providing excess B
     F_A0 = round(random.uniform(50.0, 150.0), 2)
-    F_B0 = round((F_A0 * b / a) * random.uniform(1.2, 2.5), 2)
+    min_F_B0 = (F_A0 / a) * b
+    F_B0 = round(min_F_B0 * random.uniform(1.2, 2.5), 2)
+    
+    # Inlet product flow is usually zero or small
     F_C0 = round(random.choice([0.0, random.uniform(5.0, 20.0)]), 2)
     F_D0 = 0.0
 
@@ -155,7 +182,7 @@ def template_flow_system_molar_flow_rates():
 
     # 2. Core Calculations
     
-    # Calculate Theta values for use in the solution string
+    # Calculate Theta values
     Theta_B = F_B0 / F_A0
     Theta_C = F_C0 / F_A0
 
@@ -163,75 +190,81 @@ def template_flow_system_molar_flow_rates():
     F_A = F_A0 * (1 - X_A)
     F_B = F_B0 - (b / a) * F_A0 * X_A
     F_C = F_C0 + (c / a) * F_A0 * X_A
-    F_D = F_D0 + (d / a) * F_A0 * X_A
+    F_D = F_D0 + (d / a) * F_A0 * X_A if has_product_D else 0.0
     
     # 3. Generate Question and Solution Strings
-    
-    def format_species(coeff, name):
-        return f"{coeff if coeff > 1 else ''}{' ' if coeff > 1 else ''}{name}"
-
-    reaction_string = (
-        f"{format_species(a, reactant_A_name)} + {format_species(b, reactant_B_name)} -> "
-        f"{format_species(c, product_C_name)} + {format_species(d, product_D_name)}"
-    )
-
     question = (
         f"A reaction is carried out in a steady-state Plug Flow Reactor (PFR):\n"
-        f"**Reaction:** ${reaction_string}$\n\n"
-        f"The reactor is fed with {reactant_A_name} at a rate of ${F_A0}$ mol/min, "
-        f"{reactant_B_name} at ${F_B0}$ mol/min, and {product_C_name} at ${F_C0}$ mol/min. "
+        f"**Reaction:** {equation}\n\n"
+        f"The reactor is fed with {reactant_A_name} at a rate of {F_A0} mol/min, "
+        f"{reactant_B_name} at {F_B0} mol/min, and {product_C_name} at {F_C0} mol/min. "
         f"{reactant_A_name} is the limiting reactant.\n\n"
-        f"The reactor is designed to achieve a conversion of ${X_A}$ ($X_A$) for the limiting reactant. "
+        f"The reactor is designed to achieve a conversion of {X_A} (X_A) for the limiting reactant. "
         f"Calculate the molar flow rates of all species exiting the reactor."
     )
 
     solution = (
         f"**Step 1:** Identify Given Information\n"
-        f"- Reaction: ${reaction_string}$\n"
+        f"- Reaction: {equation}\n"
         f"- Inlet Molar Flow Rates:\n"
-        f"  - $F_{{A,0}} = {F_A0}$ mol/min\n"
-        f"  - $F_{{B,0}} = {F_B0}$ mol/min\n"
-        f"  - $F_{{C,0}} = {F_C0}$ mol/min\n"
-        f"  - $F_{{D,0}} = {F_D0}$ mol/min\n"
-        f"- Conversion of {reactant_A_name}: $X_A = {X_A}$\n\n"
+        f"  - F_A0 = {F_A0} mol/min\n"
+        f"  - F_B0 = {F_B0} mol/min\n"
+        f"  - F_C0 = {F_C0} mol/min\n"
+    )
+    if has_product_D:
+        solution += f"  - F_D0 = {F_D0} mol/min\n"
+    
+    solution += (
+        f"- Conversion of {reactant_A_name}: X_A = {X_A}\n\n"
         
         f"**Step 2:** Stoichiometric Relations for a Flow System\n"
-        f"The outlet molar flow rate ($F_j$) of any species is given by:\n"
-        f"$F_j = F_{{j,0}} + \\nu_j F_{{A,0}} X_A$\n"
-        f"Alternatively, in terms of $\\Theta_j = F_{{j,0}} / F_{{A,0}}$:\n"
-        f"$F_j = F_{{A,0}}(\\Theta_j + \\nu_j X_A)$\n"
-        f"Here, the normalized stoichiometric coefficients ($\\nu_j$) are:\n"
-        f"$\\nu_A = -1$, $\\nu_B = -{b}/{a}$, $\\nu_C = +{c}/{a}$, $\\nu_D = +{d}/{a}$\n\n"
-        
+        f"The outlet molar flow rate (F_j) of any species is given by:\n"
+        f"F_j = F_j0 + nu_j * F_A0 * X_A\n"
+        f"Alternatively, in terms of Theta_j = F_j0 / F_A0:\n"
+        f"F_j = F_A0(Theta_j + nu_j * X_A)\n"
+        f"Here, the normalized stoichiometric coefficients (nu_j) relative to A are:\n"
+        f"nu_A = -1, nu_B = -{b}/{a}, nu_C = +{c}/{a}"
+    )
+    if has_product_D:
+        solution += f", nu_D = +{d}/{a}"
+    solution += "\n\n"
+
+    solution += (
         f"**Step 3:** Calculate Outlet Molar Flow Rates\n\n"
         f"**For {reactant_A_name} (A):**\n"
-        f"$F_A = F_{{A,0}}(1 - X_A) = {F_A0}(1 - {X_A}) = {round(F_A, 2)}$ mol/min\n\n"
+        f"F_A = F_A0(1 - X_A) = {F_A0}(1 - {X_A}) = {round(F_A, 2)} mol/min\n\n"
         
         f"**For {reactant_B_name} (B):**\n"
         f"*Using the Direct Method:*\n"
-        f"$F_B = F_{{B,0}} - ({b}/{a}) F_{{A,0}} X_A = {F_B0} - ({b}/{a}) \\times {F_A0} \\times {X_A} = {round(F_B, 2)}$ mol/min\n"
-        f"*Using the $\\Theta$ Method:*\n"
-        f"First, $\\Theta_B = F_{{B,0}} / F_{{A,0}} = {F_B0} / {F_A0} = {round(Theta_B, 3)}$\n"
-        f"$F_B = F_{{A,0}}(\\Theta_B - ({b}/{a})X_A) = {F_A0}({round(Theta_B, 3)} - ({b}/{a}) \\times {X_A}) = {round(F_B, 2)}$ mol/min\n\n"
+        f"F_B = F_B0 - ({b}/{a}) * F_A0 * X_A = {F_B0} - ({b}/{a}) * {F_A0} * {X_A} = {round(F_B, 2)} mol/min\n"
+        f"*Using the Theta Method:*\n"
+        f"Theta_B = F_B0 / F_A0 = {F_B0} / {F_A0} = {round(Theta_B, 3)}\n"
+        f"F_B = F_A0(Theta_B - ({b}/{a})X_A) = {F_A0}({round(Theta_B, 3)} - ({b}/{a}) * {X_A}) = {round(F_B, 2)} mol/min\n\n"
 
         f"**For {product_C_name} (C):**\n"
         f"*Using the Direct Method:*\n"
-        f"$F_C = F_{{C,0}} + ({c}/{a}) F_{{A,0}} X_A = {F_C0} + ({c}/{a}) \\times {F_A0} \\times {X_A} = {round(F_C, 2)}$ mol/min\n"
-        f"*Using the $\\Theta$ Method:*\n"
-        f"First, $\\Theta_C = F_{{C,0}} / F_{{A,0}} = {F_C0} / {F_A0} = {round(Theta_C, 3)}$\n"
-        f"$F_C = F_{{A,0}}(\\Theta_C + ({c}/{a})X_A) = {F_A0}({round(Theta_C, 3)} + ({c}/{a}) \\times {X_A}) = {round(F_C, 2)}$ mol/min\n\n"
+        f"F_C = F_C0 + ({c}/{a}) * F_A0 * X_A = {F_C0} + ({c}/{a}) * {F_A0} * {X_A} = {round(F_C, 2)} mol/min\n"
+        f"*Using the Theta Method:*\n"
+        f"Theta_C = F_C0 / F_A0 = {F_C0} / {F_A0} = {round(Theta_C, 3)}\n"
+        f"F_C = F_A0(Theta_C + ({c}/{a})X_A) = {F_A0}({round(Theta_C, 3)} + ({c}/{a}) * {X_A}) = {round(F_C, 2)} mol/min\n\n"
+    )
 
-        f"**For {product_D_name} (D):**\n"
-        f"Since $F_{{D,0}} = 0$, $\\Theta_D = 0$. The calculation is straightforward:\n"
-        f"$F_D = F_{{D,0}} + ({d}/{a}) F_{{A,0}} X_A = 0 + ({d}/{a}) \\times {F_A0} \\times {X_A} = {round(F_D, 2)}$ mol/min\n\n"
+    if has_product_D:
+        solution += (
+            f"**For {product_D_name} (D):**\n"
+            f"Since F_D0 = 0, the calculation is straightforward:\n"
+            f"F_D = F_D0 + ({d}/{a}) * F_A0 * X_A = 0 + ({d}/{a}) * {F_A0} * {X_A} = {round(F_D, 2)} mol/min\n\n"
+        )
 
+    solution += (
         f"**Final Answer**\n"
         f"The molar flow rates exiting the reactor are:\n"
-        f"- {reactant_A_name} ($F_A$): ${round(F_A, 2)}$ mol/min\n"
-        f"- {reactant_B_name} ($F_B$): ${round(F_B, 2)}$ mol/min\n"
-        f"- {product_C_name} ($F_C$): ${round(F_C, 2)}$ mol/min\n"
-        f"- {product_D_name} ($F_D$): ${round(F_D, 2)}$ mol/min"
+        f"- {reactant_A_name} (F_A): {round(F_A, 2)} mol/min\n"
+        f"- {reactant_B_name} (F_B): {round(F_B, 2)} mol/min\n"
+        f"- {product_C_name} (F_C): {round(F_C, 2)} mol/min\n"
     )
+    if has_product_D:
+        solution += f"- {product_D_name} (F_D): {round(F_D, 2)} mol/min"
 
     return question, solution
 
@@ -258,31 +291,44 @@ def template_limiting_reactant():
             - str: A question requiring identification of the limiting reactant.
             - str: A detailed solution showing the identification and calculation steps.
     """
-    # 1. Randomized Parameters
-
-    # Select unique names for reactants and products
-    reactant_A_name, reactant_B_name = random.sample(GENERAL_REACTANTS, 2)
-    product_C_name, product_D_name = random.sample(PRODUCTS, 2)
-
-    # Generate stoichiometric coefficients
-    a = random.randint(1, 3)
-    b = random.randint(1, 3)
-    c = random.randint(1, 3)
-    d = random.randint(1, 3)
+    # 1. Parameterize Inputs using Valid Reactions
+    # Select a real, pre-balanced reaction to ensure chemical plausibility
+    reaction_data = random.choice(REACTIONS)
+    
+    # Extract reactants and products
+    # The dictionaries are in the format {"Name": coefficient}
+    reactant_items = list(reaction_data["reactants"].items())
+    product_items = list(reaction_data["products"].items())
+
+    # Map to A, B, C, D variables for the template logic
+    # We assume the reaction has at least 2 reactants and 1-2 products based on the constants file
+    reactant_A_name, a = reactant_items[0]
+    reactant_B_name, b = reactant_items[1]
+    
+    product_C_name, c = product_items[0]
+    # Handle case where there might be only 1 product or 2
+    if len(product_items) > 1:
+        product_D_name, d = product_items[1]
+    else:
+        # Create a dummy placeholder if only 1 product exists to prevent errors
+        product_D_name, d = "Heat/Other", 0
 
-    # Randomly decide which reactant will be limiting
+    # Randomly decide which reactant will be limiting to vary the problem type
     is_A_limiting = random.choice([True, False])
 
     # Generate initial moles based on which reactant is limiting
     if is_A_limiting:
         N_A0 = round(random.uniform(20.0, 50.0), 2)
-        # Make B the excess reactant
-        N_B0 = round((N_A0 * b / a) * random.uniform(1.1, 2.0), 2)
+        # Make B the excess reactant (ratio N_B0/b > N_A0/a)
+        min_B = (N_A0 / a) * b
+        N_B0 = round(min_B * random.uniform(1.2, 2.0), 2)
     else: # B is limiting
         N_B0 = round(random.uniform(20.0, 50.0), 2)
-        # Make A the excess reactant
-        N_A0 = round((N_B0 * a / b) * random.uniform(1.1, 2.0), 2)
+        # Make A the excess reactant (ratio N_A0/a > N_B0/b)
+        min_A = (N_B0 / b) * a
+        N_A0 = round(min_A * random.uniform(1.2, 2.0), 2)
     
+    # Explicitly define initial product moles as zero
     N_C0 = 0.0
     N_D0 = 0.0
 
@@ -299,7 +345,6 @@ def template_limiting_reactant():
         # Case 1: A is the limiting reactant
         limiting_reactant_name = reactant_A_name
         limiting_reactant_sym = 'A'
-        excess_reactant_name = reactant_B_name
         
         # Calculate final moles based on X_A
         N_A = N_A0 * (1 - X)
@@ -310,7 +355,6 @@ def template_limiting_reactant():
         # Case 2: B is the limiting reactant
         limiting_reactant_name = reactant_B_name
         limiting_reactant_sym = 'B'
-        excess_reactant_name = reactant_A_name
 
         # Calculate final moles based on X_B
         N_A = N_A0 - (a / b) * N_B0 * X
@@ -319,20 +363,14 @@ def template_limiting_reactant():
         N_D = N_D0 + (d / b) * N_B0 * X
 
     # 3. Generate Question and Solution Strings
-    def format_species(coeff, name):
-        return f"{coeff if coeff > 1 else ''}{' ' if coeff > 1 else ''}{name}"
-
-    reaction_string = (
-        f"{format_species(a, reactant_A_name)} + {format_species(b, reactant_B_name)} -> "
-        f"{format_species(c, product_C_name)} + {format_species(d, product_D_name)}"
-    )
+    equation = reaction_data["equation"]
 
     question = (
         f"The following reaction occurs in a batch reactor:\n"
-        f"**Reaction:** ${reaction_string}$\n\n"
-        f"The reactor is initially charged with ${N_A0}$ moles of {reactant_A_name} and "
-        f"${N_B0}$ moles of {reactant_B_name}. The reaction is allowed to proceed until "
-        f"a ${X*100}\%$ conversion of the limiting reactant is achieved.\n\n"
+        f"**Reaction:** {equation}\n\n"
+        f"The reactor is initially charged with {N_A0} moles of {reactant_A_name} and "
+        f"{N_B0} moles of {reactant_B_name}. Assume the initial amount of products is zero.\n"
+        f"The reaction is allowed to proceed until a {X*100}% conversion of the limiting reactant is achieved.\n\n"
         f"First, identify the limiting reactant. Then, calculate the final number of moles for all species."
     )
 
@@ -340,55 +378,44 @@ def template_limiting_reactant():
         f"**Step 1:** Identify the Limiting Reactant\n"
         f"To find the limiting reactant, we compare the ratio of the initial moles to the "
         f"stoichiometric coefficient for each reactant.\n\n"
-        f"- For **{reactant_A_name} (A)**: $N_{{A0}}/a = {N_A0} / {a} = \\mathbf{{{round(ratio_A, 2)}}}$\n"
-        f"- For **{reactant_B_name} (B)**: $N_{{B0}}/b = {N_B0} / {b} = \\mathbf{{{round(ratio_B, 2)}}}$\n\n"
-        f"Since ${round(min(ratio_A, ratio_B), 2)} < {round(max(ratio_A, ratio_B), 2)}$, "
-        f"**{limiting_reactant_name} is the limiting reactant**. All further calculations will be based on "
-        f"a conversion of {limiting_reactant_name}, $X_{limiting_reactant_sym} = {X}$.\n\n"
-    )
-
-    solution_step2_calculation = (
-        f"**Step 2:** Calculate Final Moles\n"
-        f"Using the stoichiometric relationships based on the limiting reactant ({limiting_reactant_name}):\n\n"
-        f"**For {reactant_A_name} (A):**\n"
-        f"$N_A = {round(N_A, 2)}$ mol\n\n"
-        f"**For {reactant_B_name} (B):**\n"
-        f"$N_B = {round(N_B, 2)}$ mol\n\n"
-        f"**For {product_C_name} (C):**\n"
-        f"$N_C = {round(N_C, 2)}$ mol\n\n"
-        f"**For {product_D_name} (D):**\n"
-        f"$N_D = {round(N_D, 2)}$ mol"
+        f"- For **{reactant_A_name}**: N_A0/a = {N_A0} / {a} = **{round(ratio_A, 2)}**\n"
+        f"- For **{reactant_B_name}**: N_B0/b = {N_B0} / {b} = **{round(ratio_B, 2)}**\n\n"
+        f"Since {round(min(ratio_A, ratio_B), 2)} < {round(max(ratio_A, ratio_B), 2)}, "
+        f"**{limiting_reactant_name} is the limiting reactant**.\n"
     )
 
-    solution_final_answer = (
-        f"**Final Answer**\n"
-        f"The limiting reactant is **{limiting_reactant_name}**. The final number of moles are:\n"
-        f"- **{reactant_A_name}:** ${round(N_A, 2)}$ mol\n"
-        f"- **{reactant_B_name}:** ${round(N_B, 2)}$ mol\n"
-        f"- **{product_C_name}:** ${round(N_C, 2)}$ mol\n"
-        f"- **{product_D_name}:** ${round(N_D, 2)}$ mol"
-    )
-    
     if limiting_reactant_sym == 'A':
         solution_step2_calculation = (
-            f"\n\n**2. Calculate Final Moles**\n"
-            f"Using $X_A = {X}$ as the basis:\n\n"
-            f"$N_A = N_{{A0}}(1 - X_A) = {N_A0}(1 - {X}) = \\mathbf{{{round(N_A, 2)}}}$ mol\n"
-            f"$N_B = N_{{B0}} - (b/a)N_{{A0}}X_A = {N_B0} - ({b}/{a})({N_A0})({X}) = \\mathbf{{{round(N_B, 2)}}}$ mol\n"
-            f"$N_C = N_{{C0}} + (c/a)N_{{A0}}X_A = {N_C0} + ({c}/{a})({N_A0})({X}) = \\mathbf{{{round(N_C, 2)}}}$ mol\n"
-            f"$N_D = N_{{D0}} + (d/a)N_{{A0}}X_A = {N_D0} + ({d}/{a})({N_A0})({X}) = \\mathbf{{{round(N_D, 2)}}}$ mol"
+            f"\n**Step 2:** Calculate Final Moles\n"
+            f"Using conversion of {reactant_A_name} (X = {X}) as the basis:\n\n"
+            f"Moles {reactant_A_name} = {N_A0}(1 - {X}) = **{round(N_A, 2)}** mol\n"
+            f"Moles {reactant_B_name} = {N_B0} - ({b}/{a})({N_A0})({X}) = **{round(N_B, 2)}** mol\n"
+            f"Moles {product_C_name} = 0 + ({c}/{a})({N_A0})({X}) = **{round(N_C, 2)}** mol\n"
         )
+        if d > 0:
+            solution_step2_calculation += f"Moles {product_D_name} = 0 + ({d}/{a})({N_A0})({X}) = **{round(N_D, 2)}** mol\n"
     else: 
         solution_step2_calculation = (
-            f"\n\n**2. Calculate Final Moles**\n"
-            f"Using $X_B = {X}$ as the basis:\n\n"
-            f"$N_A = N_{{A0}} - (a/b)N_{{B0}}X_B = {N_A0} - ({a}/{b})({N_B0})({X}) = \\mathbf{{{round(N_A, 2)}}}$ mol\n"
-            f"$N_B = N_{{B0}}(1 - X_B) = {N_B0}(1 - {X}) = \\mathbf{{{round(N_B, 2)}}}$ mol\n"
-            f"$N_C = N_{{C0}} + (c/b)N_{{B0}}X_B = {N_C0} + ({c}/{b})({N_B0})({X}) = \\mathbf{{{round(N_C, 2)}}}$ mol\n"
-            f"$N_D = N_{{D0}} + (d/b)N_{{B0}}X_B = {N_D0} + ({d}/{b})({N_B0})({X}) = \\mathbf{{{round(N_D, 2)}}}$ mol"
+            f"\n**Step 2:** Calculate Final Moles\n"
+            f"Using conversion of {reactant_B_name} (X = {X}) as the basis:\n\n"
+            f"Moles {reactant_A_name} = {N_A0} - ({a}/{b})({N_B0})({X}) = **{round(N_A, 2)}** mol\n"
+            f"Moles {reactant_B_name} = {N_B0}(1 - {X}) = **{round(N_B, 2)}** mol\n"
+            f"Moles {product_C_name} = 0 + ({c}/{b})({N_B0})({X}) = **{round(N_C, 2)}** mol\n"
         )
+        if d > 0:
+            solution_step2_calculation += f"Moles {product_D_name} = 0 + ({d}/{b})({N_B0})({X}) = **{round(N_D, 2)}** mol\n"
+
+    solution_final_answer = (
+        f"\n**Final Answer**\n"
+        f"The limiting reactant is **{limiting_reactant_name}**. The final number of moles are:\n"
+        f"- **{reactant_A_name}:** {round(N_A, 2)} mol\n"
+        f"- **{reactant_B_name}:** {round(N_B, 2)} mol\n"
+        f"- **{product_C_name}:** {round(N_C, 2)} mol\n"
+    )
+    if d > 0:
+        solution_final_answer += f"- **{product_D_name}:** {round(N_D, 2)} mol"
 
-    solution = f"### **Solution**\n\n{solution_step1_identification}{solution_step2_calculation}{solution_final_answer}"
+    solution = f"{solution_step1_identification}{solution_step2_calculation}{solution_final_answer}"
 
     return question, solution
 

data/templates/branches/chemical_engineering/thermodynamics/heat_effects.py

@@ -16,11 +16,6 @@ def template_sensible_heat_constant_cp():
 
         The governing equation on a mass basis is:
             Q = m * Cp * (T2 - T1)
-        Where:
-        - Q: Total heat transferred
-        - m: Mass of the substance
-        - Cp: Constant pressure specific heat capacity
-        - T1, T2: Initial and final temperatures
 
     Returns:
         tuple: A tuple containing:
@@ -31,14 +26,23 @@ def template_sensible_heat_constant_cp():
     substance_data = random.choice(SUBSTANCES_FOR_HEATING)
     substance_name = substance_data["name"]
     substance_state = substance_data["state"]
-    Cp = substance_data["Cp"]  # J/(g·K) - Specific heat, not molar
+    Cp = substance_data["Cp"]  # J/(g·K)
+    
+    # Retrieve safe temperature limits from the constant data
+    # Defaults provided in case keys are missing in legacy data
+    min_temp = substance_data.get("min_temp", 20)
+    max_temp = substance_data.get("max_temp", 150)
 
     # Generate a random mass in grams
-    m = round(random.uniform(50.0, 1000.0), 1)  # grams
+    m = round(random.uniform(50.0, 1000.0), 1)
 
-    # Generate temperatures in Celsius
-    T1_C = round(random.uniform(10.0, 50.0), 1)
-    T2_C = round(random.uniform(T1_C + 30, 150.0), 1)
+    # Generate temperatures within the safe bounds for this specific substance
+    # Ensure there's at least a 10 degree window for T2
+    safe_max_T1 = max(min_temp, max_temp - 15) 
+    T1_C = round(random.uniform(min_temp, safe_max_T1), 1)
+    
+    # Ensure T2 is higher than T1 but within max limit
+    T2_C = round(random.uniform(T1_C + 10, max_temp), 1)
 
     # 2. Perform the core calculation
     delta_T = T2_C - T1_C
@@ -51,13 +55,15 @@ def template_sensible_heat_constant_cp():
     question = (
         f"Calculate the heat in kJ required to raise the temperature of {m} g "
         f"of {substance_state} {substance_name} from {T1_C}°C to {T2_C}°C. "
-        f"The specific heat capacity of {substance_name} is {Cp} J/g·K."
+        f"The specific heat capacity of {substance_name} is {Cp} J/g·K. "
+        f"Assume constant pressure and no phase change occurs."
     )
 
     solution = (
         f"**Step 1:** State the formula.\n"
         f"Q = m * Cp * ΔT\n\n"
-        f"**Note:** We assume the specific heat capacity (Cp) is constant over this temperature range."
+        f"**Note:** We assume the specific heat capacity (Cp) is constant over this temperature range.\n"
+        f"\n\n"
 
         f"**Step 2:** List the given values.\n"
         f"- Mass (m) = {m} g\n"
@@ -248,8 +254,16 @@ def template_sensible_heat_temp_dependent_cp():
     A, B, C, D = params["A"], params["B"], params["C"], params["D"]
 
     n = round(random.uniform(1.0, 10.0), 2)  # moles
-    T1 = round(random.uniform(298.15, 400.0), 2)  # Kelvin
-    T2 = round(random.uniform(T1 + 200, 900.0), 2)  # Kelvin
+
+    # Determine valid temperature ranges based on phase to ensure physical plausibility
+    if "(l)" in substance_name:
+        # Liquids: Keep range lower to avoid boiling (approximate general cap)
+        T1 = round(random.uniform(280.0, 300.0), 2)
+        T2 = round(random.uniform(T1 + 20, 350.0), 2) 
+    else:
+        # Gases/Solids: Can handle higher temperatures
+        T1 = round(random.uniform(298.15, 500.0), 2)
+        T2 = round(random.uniform(T1 + 100, 1200.0), 2)
 
     # 2. Perform the core calculation via analytical integration
     # integral(A + BT + CT² + DT⁻²)dT = AT + (B/2)T² + (C/3)T³ - D/T
@@ -261,17 +275,21 @@ def template_sensible_heat_temp_dependent_cp():
         return term_a + term_b + term_c + term_d
 
     # Calculate the definite integral per mole
-    integral_val = R * (integral_mean_cp_over_r(T2) - integral_mean_cp_over_r(T1))
+    val_T2 = integral_mean_cp_over_r(T2)
+    val_T1 = integral_mean_cp_over_r(T1)
+    integral_val = R * (val_T2 - val_T1)
     
     Q_J = n * integral_val  # Total heat in Joules
     Q_kJ = Q_J / 1000       # Convert to kilojoules
 
     # 3. Generate the question and solution strings
     # Dynamically create the Cp/R equation string for the question
-    cp_eq_str = f"A"
-    if B != 0: cp_eq_str += f" + B*T"
-    if C != 0: cp_eq_str += f" + C*T²"
-    if D != 0: cp_eq_str += f" + D*T⁻²"
+    cp_eq_parts = [str(A)]
+    if B != 0: cp_eq_parts.append(f"{B:.3e}*T")
+    if C != 0: cp_eq_parts.append(f"{C:.3e}*T^2")
+    if D != 0: cp_eq_parts.append(f"{D:.3e}*T^-2")
+    
+    cp_eq_str = " + ".join(cp_eq_parts).replace("+ -", "- ")
 
     question = (
         f"Calculate the heat in kJ required to raise the temperature of {n} moles of "
@@ -281,25 +299,34 @@ def template_sensible_heat_temp_dependent_cp():
         f"Where the constants are: A={A}, B={B:.3g}, C={C:.3g}, D={D:.3g}"
     )
 
+    # Helper to format the polynomial substitution string for the solution
+    def format_poly_sub(T_val):
+        terms = [f"{A}*({T_val})"]
+        if B != 0: terms.append(f"({B:.3e}/2)*({T_val})^2")
+        if C != 0: terms.append(f"({C:.3e}/3)*({T_val})^3")
+        if D != 0: terms.append(f"-({D:.3e}/{T_val})")
+        return " + ".join(terms).replace("+ -", "- ")
+
     solution = (
         f"**Step 1:** State the integral formula for total heat (Q).\n"
-        f"Q = n * ∫[from T1 to T2] Cp(T) dT\n"
-        f"Given Cp(T) = R * ({cp_eq_str}), the integral is:\n"
-        f"Q = n * R * ∫[from {T1} to {T2}] ({A} + {B:.3g}*T {'+ ' + str(C) + '*T²' if C != 0 else ''} {'+ ' + str(D) + '*T⁻²' if D != 0 else ''}) dT\n\n"
+        f"Q = n * R * ∫[from {T1} to {T2}] (Cp/R) dT\n\n"
 
         f"**Step 2:** Perform the analytical integration.\n"
-        f"The indefinite integral of Cp(T)/R is: A*T + (B/2)*T² + (C/3)*T³ - D/T\n\n"
+        f"The indefinite integral of Cp(T)/R is:\n"
+        f"I(T) = A*T + (B/2)*T^2 + (C/3)*T^3 - D/T\n\n"
 
-        f"**Step 3:** Evaluate the definite integral from T1 to T2.\n"
-        f"∫ Cp(T) dT = R * [ (A*T₂ + (B/2)*T₂² + ...) - (A*T₁ + (B/2)*T₁² + ...) ]\n"
-        f"∫ Cp(T) dT = {R} J/mol·K * [({integral_mean_cp_over_r(T2):.2f}) - ({integral_mean_cp_over_r(T1):.2f})]\n"
-        f"∫ Cp(T) dT = {R} J/mol·K * ({(integral_mean_cp_over_r(T2) - integral_mean_cp_over_r(T1)):.2f}) K = {integral_val:.2f} J/mol\n\n"
+        f"**Step 3:** Evaluate the definite integral.\n"
+        f"I({T2}) = {format_poly_sub(T2)} = {val_T2:.4f}\n"
+        f"I({T1}) = {format_poly_sub(T1)} = {val_T1:.4f}\n"
+        f"Integral Value = I({T2}) - I({T1}) = {val_T2:.4f} - {val_T1:.4f} = {val_T2 - val_T1:.4f} K\n\n"
 
-        f"**Step 4:** Calculate the total heat Q for {n} moles.\n"
-        f"Q = n * ({integral_val:.2f} J/mol) = {n} mol * {integral_val:.2f} J/mol = {Q_J:.2f} J\n\n"
+        f"**Step 4:** Calculate the total heat Q.\n"
+        f"Q = n * R * (Integral Value)\n"
+        f"Q = {n} mol * 8.314 J/(mol K) * {val_T2 - val_T1:.4f} K\n"
+        f"Q = {Q_J:.2f} J\n\n"
 
-        f"**Step 5:** Convert the result to kilojoules.\n"
-        f"Q = {Q_J:.2f} J * (1 kJ / 1000 J) = {Q_kJ:.2f} kJ\n\n"
+        f"**Step 5:** Convert to kilojoules.\n"
+        f"Q = {Q_J:.2f} J / 1000 = {Q_kJ:.2f} kJ\n\n"
 
         f"**Answer:** The heat required is **{Q_kJ:.2f} kJ**."
     )
@@ -311,70 +338,89 @@ def template_sensible_heat_temp_dependent_cp():
 def template_adiabatic_flame_temperature():
     """
     Adiabatic Flame Temperature
-
-    Scenario:
-        This template calculates the theoretical maximum temperature the products
-        of a combustion reaction can reach if it occurs adiabatically (no heat loss).
-        This requires an energy balance: the heat released by the reaction at a
-        reference temperature (298.15 K) must be completely absorbed by the
-        product gases as sensible heat, raising their temperature from the
-        reference temperature to the final adiabatic flame temperature (T_ad).
-        
-        Because the heat capacities of the products are temperature-dependent,
-        this problem requires an iterative, numerical solution.
-
-    Returns:
-        tuple: A tuple containing:
-            - str: A question asking to compute the adiabatic flame temperature.
-            - str: A step-by-step solution showing the numerical method.
+    Scenario: Calculates the theoretical maximum temperature of combustion products.
     """
     # 1. Parameterize inputs
     R = 8.314  # J/(mol·K)
     T_initial = 298.15 # K
     
-    reaction_data = random.choice(COMBUSTION_REACTIONS)
-    fuel = reaction_data["fuel"]
-    equation = reaction_data["equation"]
-    reactants = reaction_data["reactants"]
-    products = reaction_data["products"]
-
-    # 2. Perform the core calculation
-    # First, calculate the standard heat of reaction at 298.15 K
-    try:
-        products_enthalpy_298 = sum(nu * HEATS_OF_FORMATION[s] for s, nu in products.items())
-        reactants_enthalpy_298 = sum(nu * HEATS_OF_FORMATION[s] for s, nu in reactants.items())
-        delta_H_298 = products_enthalpy_298 - reactants_enthalpy_298  # result in kJ
-    except KeyError as e:
-        # Handle cases where data might be missing for a defined reaction
-        return (f"Data Error for {fuel} combustion.", f"Missing heat of formation for {e.args[0]}.")
-
-    # Define a function for the integral of Cp/R for a single species
-    def integral_mean_cp_over_r(T, A, B, C, D):
-        return A*T + (B/2)*T**2 + (C/3)*T**3 - D/T
-
-    # Define the function that represents the energy balance equation
-    # We want to find T_final where this function equals zero.
-    def energy_balance(T_final):
-        # Calculate sensible heat absorbed by products from T_initial to T_final
-        # Units will be J
-        sensible_heat_products = 0
-        for species, nu in products.items():
-            params = CP_PARAMS[species]
-            A, B, C, D = params["A"], params["B"], params["C"], params["D"]
-            
-            # Integral from T_initial to T_final
-            integral_val = integral_mean_cp_over_r(T_final, A, B, C, D) - integral_mean_cp_over_r(T_initial, A, B, C, D)
-            sensible_heat_products += nu * R * integral_val
-            
-        # Energy Balance: Sensible Heat Absorbed + Heat of Reaction = 0
-        # Convert heat of reaction from kJ to J for consistency
-        return sensible_heat_products + (delta_H_298 * 1000)
-
-    # Solve for the root of the energy_balance function
-    initial_guess = 2000  # A reasonable starting guess in Kelvin
-    adiabatic_temp_kelvin = fsolve(energy_balance, initial_guess)[0]
-
-    # 3. Generate the question and solution strings
+    # SAFETY MECHANISM: Prevent infinite loops
+    max_retries = 20
+    attempts = 0
+    
+    while attempts < max_retries:
+        attempts += 1
+        try:
+            # Pick a random reaction
+            reaction_data = random.choice(COMBUSTION_REACTIONS)
+            fuel = reaction_data["fuel"]
+            equation = reaction_data["equation"]
+            reactants = reaction_data["reactants"]
+            products = reaction_data["products"]
+
+            #  PRE-FLIGHT CHECK 
+            # Before calculating, verify we actually have data for these species.
+            # This prevents the silent KeyError loop.
+            missing_heat_data = [s for s in list(reactants.keys()) + list(products.keys()) if s not in HEATS_OF_FORMATION]
+            if missing_heat_data:
+                # Skip this reaction if we lack enthalpy data
+                continue
+
+            missing_cp_data = [s for s in products.keys() if s not in CP_PARAMS]
+            if missing_cp_data:
+                # Skip this reaction if we lack heat capacity parameters
+                continue
+
+            # 2. Perform the core calculation
+            # Calculate standard heat of reaction at 298.15 K
+            products_enthalpy_298 = sum(nu * HEATS_OF_FORMATION[s] for s, nu in products.items())
+            reactants_enthalpy_298 = sum(nu * HEATS_OF_FORMATION[s] for s, nu in reactants.items())
+            delta_H_298_kJ = products_enthalpy_298 - reactants_enthalpy_298
+            delta_H_298_J = delta_H_298_kJ * 1000 # Convert kJ to J
+
+            # Define integral of Cp/R
+            def integral_mean_cp_over_r(T, A, B, C, D):
+                return A*T + (B/2)*T**2 + (C/3)*T**3 - D/T
+
+            # Define the energy balance equation (Sensible Heat + Heat of Rxn = 0)
+            def energy_balance(T_final):
+                sensible_heat_products = 0
+                for species, nu in products.items():
+                    params = CP_PARAMS[species]
+                    A, B, C, D = params["A"], params["B"], params["C"], params["D"]
+                    
+                    # Integral from T_initial to T_final
+                    val_T = integral_mean_cp_over_r(T_final, A, B, C, D)
+                    val_T0 = integral_mean_cp_over_r(T_initial, A, B, C, D)
+                    
+                    sensible_heat_products += nu * R * (val_T - val_T0)
+                    
+                return sensible_heat_products + delta_H_298_J
+
+            # Solve for the root
+            initial_guess = 2000 
+            # fsolve returns a numpy array, we take the first element
+            result = fsolve(energy_balance, initial_guess)
+            adiabatic_temp_kelvin = result[0]
+
+            # PHYSICS SANITY CHECK 
+            # We slightly widen the range to avoid rejecting valid high-temp reactions
+            # but keep it sane (e.g. max 4500K for most hydrocarbons in air)
+            if 1000 < adiabatic_temp_kelvin < 4500:
+                break # Valid result found, exit loop (Success!)
+
+        except (KeyError, ValueError, IndexError, Exception):
+            # If solver fails or unexpected error, try next reaction
+            continue
+    
+    # FALLBACK: If we exhausted all retries (e.g., data is missing for ALL reactions)
+    else:
+        return (
+            "Error: Could not generate a valid Adiabatic Flame Temperature problem.",
+            "Possible causes: Missing thermochemical data in constants.py or solver convergence issues."
+        )
+
+    # 3. Generate the question and solution strings (Only runs if 'break' was hit)
     question = (
         f"{fuel} gas enters a furnace at {T_initial} K and is burned completely with "
         f"the theoretical amount of dry air (also at {T_initial} K). Assuming the "
@@ -387,20 +433,20 @@ def template_adiabatic_flame_temperature():
         f"  {equation}\n\n"
 
         f"**Step 2:** Calculate the standard heat of reaction at {T_initial} K (ΔH_rxn°).\n"
-        f"Using the provided heats of formation, the calculation is:\n"
-        f"ΔH_rxn° = Σ(ν·ΔH_f°)products - Σ(ν·ΔH_f°)reactants = {delta_H_298:.2f} kJ\n\n"
+        f"Using standard heats of formation:\n"
+        f"ΔH_rxn° = {delta_H_298_kJ:.2f} kJ\n\n"
 
         f"**Step 3:** Set up the energy balance equation.\n"
         f"For an adiabatic process, the heat released by the reaction must be absorbed as sensible heat by the products.\n"
         f"Heat Absorbed by Products + Heat of Reaction = 0\n"
-        f"  Σ[n_i * ∫[from {T_initial} to T_ad] Cp_i(T) dT]_products + ΔH_rxn° = 0\n\n"
+        f"  Σ [ n_i * ∫(Cp_i dT) from {T_initial} to T_ad ] + ΔH_rxn° = 0\n\n"
 
         f"**Step 4:** Solve the equation for the adiabatic flame temperature (T_ad).\n"
-        f"This equation is non-linear because Cp is a function of temperature. We must use a numerical root-finding algorithm to solve for T_ad where the energy balance function equals zero.\n"
-        f"An initial guess of {initial_guess} K is used for the solver.\n\n"
+        f"This equation is non-linear because Cp is a function of temperature. We use a numerical solver to find T_ad.\n"
+        f"Initial guess: {initial_guess} K\n\n"
 
-        f"**Step 5:** State the result from the numerical solver.\n"
-        f"The solver finds the temperature T_ad that satisfies the energy balance.\n"
+        f"**Step 5:** State the result.\n"
+        f"The calculated adiabatic flame temperature is:\n"
         f"T_ad = {adiabatic_temp_kelvin:.2f} K\n\n"
 
         f"**Answer:** The estimated adiabatic flame temperature is **{adiabatic_temp_kelvin:.2f} K**."

data/templates/branches/chemical_engineering/thermodynamics/volumetric_properties_pure_fluids.py

@@ -1,7 +1,7 @@
 import random
 import numpy as np
 import math
-from data.templates.branches.chemical_engineering.constants import GAS_PHASE_REACTANTS, THERMO_SUBSTANCES, CRITICAL_PROPERTIES
+from data.templates.branches.chemical_engineering.constants import GAS_PHASE_REACTANTS, THERMO_SUBSTANCES, CRITICAL_PROPERTIES, REAL_FLUID_DATA
 
 
 # Template 1 (Easy)
@@ -417,108 +417,111 @@ def template_vdw_solve_for_volume():
     Scenario:
         Solving for molar volume (V) from a cubic equation of state, given
         temperature (T) and pressure (P), requires finding the roots of a
-        cubic polynomial, which is done with a numerical solver.
+        cubic polynomial.
 
-        When the state (T, P) is below the critical point, the equation can yield
-        three positive real roots, corresponding to the saturated liquid volume, the
-        saturated vapor volume, and an unstable intermediate root.
+        When the state (T, P) is within the two-phase region (subcritical), 
+        the equation yields three real roots:
+        1. Smallest root: Liquid-phase molar volume.
+        2. Largest root: Vapor-phase molar volume.
+        3. Intermediate root: Unstable state (physically meaningless).
 
         The governing equation is cast into a polynomial form for root-finding:
-            V**3 + c2*V**2 + c1*V + c0 = 0
-        Where:
-        - c2 = -(b + R*T/P)
-        - c1 = a/P
-        - c0 = -(a*b)/P
+            V^3 - (b + RT/P)V^2 + (a/P)V - (ab/P) = 0
 
     Returns:
         tuple: A tuple containing:
             - str: A question asking to compute the possible molar volumes.
             - str: A step-by-step solution showing the calculation and root analysis.
     """
-    # 1. Parameterize the inputs
+    # 1. Parameterize the inputs with a Validation Loop
+    # We want to ensure we generate a problem with 3 roots (the "Two-Phase" scenario)
+    # as this is the most pedagogically valuable case for cubic EOS problems.
+    
     R = 0.08314  # L·bar/(mol·K)
+    
+    # Loop until we find a set of inputs that produces 3 distinct real roots
+    while True:
+        try:
+            substance_name = random.choice(list(CRITICAL_PROPERTIES.keys()))
+            properties = CRITICAL_PROPERTIES[substance_name]
+            Tc = properties["Tc"]
+            Pc = properties["Pc"]
+
+            # Choose T well below critical point to ensure the "loop" is wide enough
+            Tr = random.uniform(0.65, 0.85)
+            T = round(Tr * Tc, 2)
+            
+            # Estimate VdW saturation pressure to hit the 3-root region
+            # Approx VdW vapor pressure: log10(Pr) ~ -3(1/Tr - 1)
+            approx_Pr_sat = 10**(-3.0 * (1.0/Tr - 1.0))
+            
+            # Pick P close to this saturation pressure
+            Pr = approx_Pr_sat * random.uniform(0.95, 1.05)
+            P = round(Pr * Pc, 3) # Use 3 decimals for precision
+
+            # 2. Perform the core calculation
+            a = (27 * (R**2) * (Tc**2)) / (64 * Pc)
+            b = (R * Tc) / (8 * Pc)
 
-    substance_name = random.choice(list(CRITICAL_PROPERTIES.keys()))
-    properties = CRITICAL_PROPERTIES[substance_name]
-    Tc = properties["Tc"]
-    Pc = properties["Pc"]
-
-    # Choose a T and P below the critical point
-    Tr = random.uniform(0.85, 0.95)
-    T = round(Tr * Tc, 2)
-    Pr = random.uniform(Tr * 0.8, Tr * 0.9) # Estimate a realistic saturation pressure
-    P = round(Pr * Pc, 2)
-
-    # 2. Perform the core calculation
-    a = (27 * (R**2) * (Tc**2)) / (64 * Pc)
-    b = (R * Tc) / (8 * Pc)
-
-    # Coefficients of the cubic polynomial: V³ + c₂V² + c₁V + c₀ = 0
-    c2 = -(b + R * T / P)
-    c1 = a / P
-    c0 = -(a * b) / P
-    coeffs = [1, c2, c1, c0]
-
-    roots = np.roots(coeffs)
-
-    # Improved Root Handling: Filter for nearly-real, positive roots
-    tolerance = 1e-9
-    positive_real_roots = sorted([
-        root.real for root in roots if abs(root.imag) < tolerance and root.real > 0
-    ])
-
-    V_f, V_g = 0, 0
-    if len(positive_real_roots) >= 2: # Typically 3 for subcritical
-        V_f = positive_real_roots[0]
-        V_g = positive_real_roots[-1] # Safely choose the largest
-    elif len(positive_real_roots) == 1:
-        V_g = positive_real_roots[0]
+            # Coefficients of the cubic polynomial: V³ + c₂V² + c₁V + c₀ = 0
+            c2 = -(b + R * T / P)
+            c1 = a / P
+            c0 = -(a * b) / P
+            coeffs = [1, c2, c1, c0]
+
+            roots = np.roots(coeffs)
+
+            # Filter for positive, real roots
+            tolerance = 1e-9
+            positive_real_roots = sorted([
+                root.real for root in roots if abs(root.imag) < tolerance and root.real > 0
+            ])
+            
+            # If we found 3 roots, we have a valid problem. Break the loop.
+            if len(positive_real_roots) == 3:
+                V_f = positive_real_roots[0]
+                V_g = positive_real_roots[-1]
+                break
+                
+        except Exception:
+            continue
 
     # 3. Generate the question and solution strings
     question = (
         f"A vessel of {substance_name} is held at a temperature of {T} K and a pressure of {P} bar. "
         f"Using the van der Waals equation of state, determine the possible molar volumes (L/mol) "
-        f"for the liquid and/or vapor phases. The critical properties for {substance_name} are:\n"
+        f"predicted for the liquid and vapor phases.\n\n"
+        f"The critical properties for {substance_name} are:\n"
         f"Tc = {Tc} K\nPc = {Pc} bar"
     )
 
     solution = (
         f"**Step 1:** Calculate the van der Waals parameters 'a' and 'b'.\n"
-        f"a = (27 * R² * Tc²) / (64 * Pc) = {round(a, 4)} L²·bar/mol²\n"
+        f"a = (27 * R^2 * Tc^2) / (64 * Pc) = {round(a, 4)} L^2·bar/mol^2\n"
         f"b = (R * Tc) / (8 * Pc) = {round(b, 5)} L/mol\n\n"
 
-        f"**Step 2:** Formulate the cubic equation: V³ + c₂V² + c₁V + c₀ = 0.\n"
-        f"The calculated coefficients, with their respective units, are:\n"
-        f"- c₂ = {round(c2, 4)} (L/mol)\n"
-        f"- c₁ = {round(c1, 4)} (L²/mol²)\n"
-        f"- c₀ = {round(c0, 6)} (L³/mol³)\n\n"
+        f"**Step 2:** Formulate the cubic equation: V^3 + c2*V^2 + c1*V + c0 = 0.\n"
+        f"The coefficients are derived from the VdW equation:\n"
+        f"c2 = -(b + RT/P) = {round(c2, 4)} L/mol\n"
+        f"c1 = a/P = {round(c1, 4)} L^2/mol^2\n"
+        f"c0 = -(ab)/P = {round(c0, 6)} L^3/mol^3\n\n"
 
-        f"**Step 3:** Solve the polynomial for its roots using a numerical solver.\n"
-        f"The physically meaningful (positive, real) roots found are: "
-        f"{', '.join([f'{r:.4f}' for r in positive_real_roots])} L/mol\n\n"
+        f"**Step 3:** Solve the polynomial for its roots.\n"
+        f"Using a numerical solver, we find three real, positive roots:\n"
+        f"Roots: {', '.join([f'{r:.4f}' for r in positive_real_roots])} L/mol\n\n"
+        f"\n\n"
 
         f"**Step 4:** Interpret the physical significance of the roots.\n"
+        f"For a state in the subcritical region, the EOS predicts three roots:\n"
+        f"- The **smallest root** corresponds to the molar volume of the **Liquid Phase**.\n"
+        f"- The **largest root** corresponds to the molar volume of the **Vapor Phase**.\n"
+        f"- The intermediate root is physically unstable and disregarded.\n\n"
+
+        f"**Answer:**\n"
+        f"1. Liquid-phase Volume (V_liq) ≈ **{round(V_f, 4)} L/mol**\n"
+        f"2. Vapor-phase Volume (V_vap) ≈ **{round(V_g, 4)} L/mol**"
     )
 
-    if len(positive_real_roots) >= 2:
-        solution += (
-            f"For a subcritical state, we expect multiple positive real roots.\n"
-            f"- The smallest root corresponds to the molar volume of the **liquid phase (Vf)**.\n"
-            f"- The largest root corresponds to the molar volume of the **vapor phase (Vg)**.\n"
-            f"- Any intermediate root lies on the thermodynamically unstable branch of the isotherm (where pressure incorrectly increases with volume) and is disregarded.\n\n"
-            f"**Answer:**\n"
-            f"  - Saturated Liquid Volume (Vf) ≈ **{round(V_f, 4)} L/mol**\n"
-            f"  - Saturated Vapor Volume (Vg) ≈ **{round(V_g, 4)} L/mol**"
-        )
-    elif len(positive_real_roots) == 1:
-        solution += (
-            f"A single positive real root indicates the substance exists in a single phase (gas or supercritical fluid).\n\n"
-            f"**Answer:**\n"
-            f"  - Molar Volume (V) = **{round(V_g, 4)} L/mol**"
-        )
-    else:
-        solution += "No physically meaningful (positive, real) roots were found for these conditions, which may indicate an issue with the applicability of the model at this state."
-
     return question, solution
 
 

data/templates/branches/chemical_engineering/transport_phenomena/shell_momentum_balances.py

@@ -11,9 +11,7 @@ def template_falling_film_max_velocity():
     Scenario:
         This template calculates the maximum velocity of a liquid film flowing
         down an inclined plane under gravity. The maximum velocity occurs at the
-        free surface (the liquid-air interface), where shear stress is zero.
-        The calculation is based on the final velocity profile equation derived
-        from a shell momentum balance for this system.
+        free surface (the liquid-air interface).
 
         Core Equation:
             v_z_max = (rho * g * delta^2 * cos(beta)) / (2 * mu)
@@ -23,30 +21,38 @@ def template_falling_film_max_velocity():
             - str: A question asking to compute the maximum film velocity.
             - str: A step-by-step solution showing the calculation.
     """
-    # 1. Parameterize the inputs with random values
-    # Choose a random fluid name (key) from the dictionary
-    fluid_name = random.choice(list(COMMON_LIQUIDS.keys()))
-    # Get the corresponding properties (the tuple of density and viscosity)
-    fluid_density, fluid_viscosity = COMMON_LIQUIDS[fluid_name]
-    
-    # Film thickness in mm
-    film_thickness_mm = round(random.uniform(0.5, 5.0), 2)
-    
-    # Angle of inclination from the vertical in degrees
-    inclination_angle_deg = random.randint(5, 85)
-    
-    # Constants
+    # 1. Parameterize the inputs with Validation Loop for Physical Plausibility
     g = GRAVITATIONAL_ACCELERATION
-
-    # 2. Perform unit conversions and core calculation
-    # Convert film thickness from mm to m
-    film_thickness_m = film_thickness_mm / 1000.0
-    
-    # Convert inclination angle from degrees to radians for math functions
-    inclination_angle_rad = math.radians(inclination_angle_deg)
     
-    # Calculate the maximum velocity
-    v_max = (fluid_density * g * (film_thickness_m**2) * math.cos(inclination_angle_rad)) / (2 * fluid_viscosity)
+    while True:
+        # Choose a random fluid
+        fluid_name = random.choice(list(COMMON_LIQUIDS.keys()))
+        fluid_density, fluid_viscosity = COMMON_LIQUIDS[fluid_name]
+        
+        # Film thickness in mm (Reduced range for realistic laminar films)
+        film_thickness_mm = round(random.uniform(0.1, 2.0), 2)
+        
+        # Angle of inclination from the vertical in degrees
+        inclination_angle_deg = random.randint(5, 85)
+        
+        # Perform check calculation
+        film_thickness_m = film_thickness_mm / 1000.0
+        inclination_angle_rad = math.radians(inclination_angle_deg)
+        
+        v_max_check = (fluid_density * g * (film_thickness_m**2) * math.cos(inclination_angle_rad)) / (2 * fluid_viscosity)
+        
+        # PHYSICS CHECK:
+        # 1. Velocity should be reasonable (e.g., < 10 m/s)
+        # 2. Reynolds number (Re = 4*rho*v_avg*delta / mu) should be laminar (< ~1000-2000)
+        #    v_avg = (2/3) * v_max
+        v_avg = (2/3) * v_max_check
+        Re = (4 * fluid_density * v_avg * film_thickness_m) / fluid_viscosity
+        
+        if v_max_check < 10.0 and Re < 1500:
+            break # Scenario is valid
+
+    # 2. Perform the core calculation (already done in check, just finalize)
+    v_max = v_max_check
 
     # 3. Generate the question and solution strings
     question = (
@@ -75,7 +81,8 @@ def template_falling_film_max_velocity():
         
         f"**Step 3:** State the Core Equation\n"
         f"For a laminar falling film, the maximum velocity (v_z_max) at the liquid-air interface is given by the equation derived from the shell momentum balance:\n"
-        f"v_z_max = (rho * g * delta^2 * cos(beta)) / (2 * mu)\n\n"
+        f"v_z_max = (rho * g * delta^2 * cos(beta)) / (2 * mu)\n"
+        f"\n\n"
         
         f"**Step 4:** Substitute Values into the Equation\n"
         f"Now, we substitute our known values (with correct units) into the equation.\n"
@@ -110,30 +117,43 @@ def template_hagen_poiseuille_flowrate():
             - str: A question asking to compute the volumetric flow rate.
             - str: A step-by-step solution showing the calculation.
     """
-    # 1. Parameterize the inputs with random values
-    # Choose a random fluid name (key) from the dictionary
-    fluid_name = random.choice(list(COMMON_LIQUIDS.keys()))
-    # Get the corresponding properties (the tuple of density and viscosity)
-    fluid_density, fluid_viscosity_Pas = COMMON_LIQUIDS[fluid_name]
-
-    # Pipe radius in cm
-    pipe_radius_cm = round(random.uniform(0.5, 5.0), 2)
-    # Pipe length in m
-    pipe_length_m = round(random.uniform(5.0, 100.0), 1)
-    # Pressure drop in kPa
-    pressure_drop_kPa = random.randint(50, 500)
-    # Convert viscosity to cP for the problem statement (1 Pa·s = 1000 cP)
-    fluid_viscosity_cP = fluid_viscosity_Pas * 1000
-
-    # 2. Perform unit conversions and core calculation
-    # Convert radius from cm to m
-    pipe_radius_m = pipe_radius_cm / 100.0
-    # Convert pressure drop from kPa to Pa
-    pressure_drop_Pa = pressure_drop_kPa * 1000
-
-    # Calculate the volumetric flow rate (Q)
-    # Q = (pi * delta_P * R^4) / (8 * mu * L)
-    q_flow_rate = (math.pi * pressure_drop_Pa * (pipe_radius_m**4)) / (8 * fluid_viscosity_Pas * pipe_length_m)
+    # 1. Parameterize the inputs with a loop to ensure Laminar Flow (Re < 2300)
+    while True:
+        # Choose a random fluid name (key) from the dictionary
+        fluid_name = random.choice(list(COMMON_LIQUIDS.keys()))
+        # Get the corresponding properties (the tuple of density and viscosity)
+        fluid_density, fluid_viscosity_Pas = COMMON_LIQUIDS[fluid_name]
+
+        # Pipe radius in cm
+        pipe_radius_cm = round(random.uniform(0.5, 5.0), 2)
+        # Pipe length in m
+        pipe_length_m = round(random.uniform(5.0, 100.0), 1)
+        # Pressure drop in kPa
+        pressure_drop_kPa = random.randint(50, 500)
+        # Convert viscosity to cP for the problem statement (1 Pa·s = 1000 cP)
+        fluid_viscosity_cP = fluid_viscosity_Pas * 1000
+
+        # 2. Perform unit conversions and core calculation
+        # Convert radius from cm to m
+        pipe_radius_m = pipe_radius_cm / 100.0
+        # Convert pressure drop from kPa to Pa
+        pressure_drop_Pa = pressure_drop_kPa * 1000
+
+        # Calculate the volumetric flow rate (Q)
+        # Q = (pi * delta_P * R^4) / (8 * mu * L)
+        q_flow_rate = (math.pi * pressure_drop_Pa * (pipe_radius_m**4)) / (8 * fluid_viscosity_Pas * pipe_length_m)
+
+        # Check Reynolds Number
+        # V_avg = Q / Area = Q / (pi * R^2)
+        v_avg = q_flow_rate / (math.pi * pipe_radius_m**2)
+        # Diameter = 2 * Radius
+        diameter_m = 2 * pipe_radius_m
+        # Re = (rho * V_avg * D) / mu
+        reynolds_number = (fluid_density * v_avg * diameter_m) / fluid_viscosity_Pas
+
+        # Only accept if flow is laminar
+        if reynolds_number < 2300:
+            break
 
     # 3. Generate the question and solution strings
     question = (
@@ -184,47 +204,63 @@ def template_annulus_flowrate():
 
     Scenario:
         This template calculates the volumetric flow rate (Q) for a fluid in
-        laminar flow through the concentric cylindrical region between two pipes (an annulus).
-        The equation is derived from the shell momentum balance for this specific geometry.
+        laminar flow through the concentric cylindrical region between two pipes.
 
         Core Equation:
-            Q = (pi*(P0-PL)*R^4)/(8*mu*L) * [(1-kappa^4) - ((1-kappa^2)^2 / ln(1/kappa))]
+            Q = (pi*(P0-PL)*R^4)/(8*mu*L) * [(1-k^4) - ((1-k^2)^2 / ln(1/k))]
 
     Returns:
         tuple: A tuple containing:
-            - str: A question asking to compute the volumetric flow rate in an annulus.
+            - str: A question asking to compute the volumetric flow rate.
             - str: A step-by-step solution showing the calculation.
     """
-    # 1. Parameterize the inputs with random values
-    # Choose a random fluid name (key) from the dictionary
+    # 1. Parameterize inputs with Physical Plausibility Check
+    # Choose a random fluid
     fluid_name = random.choice(list(COMMON_LIQUIDS.keys()))
-    # Get the corresponding properties (the tuple of density and viscosity)
     fluid_density, fluid_viscosity_Pas = COMMON_LIQUIDS[fluid_name]
 
-    # Define radii and ensure inner radius is smaller than outer radius
-    outer_radius_cm = round(random.uniform(2.0, 10.0), 2)
-    kappa = round(random.uniform(0.2, 0.8), 2) # Ratio of inner to outer radius
+    # Define radii
+    outer_radius_cm = round(random.uniform(2.0, 5.0), 2)
+    kappa = round(random.uniform(0.3, 0.7), 2) 
     inner_radius_cm = round(kappa * outer_radius_cm, 2)
-
-    # Pipe length in m
-    pipe_length_m = round(random.uniform(10.0, 150.0), 1)
-    # Pressure drop in kPa
-    pressure_drop_kPa = random.randint(100, 1000)
-
-    # 2. Perform unit conversions and core calculation
-    # Convert radii from cm to m
+    
+    # Convert to meters
     outer_radius_m = outer_radius_cm / 100.0
     inner_radius_m = inner_radius_cm / 100.0
+    kappa_val = inner_radius_m / outer_radius_m
     
-    # Convert pressure drop from kPa to Pa
-    pressure_drop_Pa = pressure_drop_kPa * 1000
+    pipe_length_m = round(random.uniform(10.0, 50.0), 1)
 
-    # The dimensionless ratio, kappa
-    kappa_val = inner_radius_m / outer_radius_m
+    # Ensure Laminar Flow (Re < 2100) 
+    # Instead of random Pressure Drop, we pick a target Reynolds number
+    # Hydraulic Diameter Dh = 2 * (Ro - Ri)
+    Dh = 2 * (outer_radius_m - inner_radius_m)
+    
+    # Target Re between 500 and 1500 (safely laminar)
+    Re_target = random.uniform(500, 1500)
+    
+    # Calculate required velocity: v = (Re * mu) / (rho * Dh)
+    velocity_target = (Re_target * fluid_viscosity_Pas) / (fluid_density * Dh)
+    
+    # Calculate required Flow Rate: Q = v * Area
+    area = math.pi * (outer_radius_m**2 - inner_radius_m**2)
+    Q_target = velocity_target * area
 
-    # Calculate the flow rate using the annulus equation
-    term1 = (math.pi * pressure_drop_Pa * (outer_radius_m**4)) / (8 * fluid_viscosity_Pas * pipe_length_m)
+    # Back-calculate the Pressure Drop required to drive this Q
+    # Inverted Annulus Equation: DeltaP = Q * (8*mu*L) / (pi*Ro^4 * ShapeFactor)
     shape_factor = (1 - kappa_val**4) - (((1 - kappa_val**2)**2) / math.log(1 / kappa_val))
+    denominator = (math.pi * (outer_radius_m**4)) * shape_factor
+    numerator = Q_target * (8 * fluid_viscosity_Pas * pipe_length_m)
+    
+    pressure_drop_Pa_exact = numerator / denominator
+    
+    # Round Pressure Drop to look "given" (e.g., nearest 10 Pa)
+    pressure_drop_Pa = round(pressure_drop_Pa_exact / 10.0) * 10.0
+    if pressure_drop_Pa == 0: pressure_drop_Pa = 10.0
+    pressure_drop_kPa = pressure_drop_Pa / 1000.0
+
+    # 2. Perform the forward calculation with rounded inputs
+    term1 = (math.pi * pressure_drop_Pa * (outer_radius_m**4)) / (8 * fluid_viscosity_Pas * pipe_length_m)
     q_flow_rate = term1 * shape_factor
 
     # 3. Generate the question and solution strings
@@ -232,7 +268,7 @@ def template_annulus_flowrate():
         f"Laminar flow of {fluid_name} occurs in the annular space between two concentric pipes. "
         f"The inner pipe has an outer radius of {inner_radius_cm} cm, and the outer pipe has an inner radius of {outer_radius_cm} cm. "
         f"The concentric pipes have a length of {pipe_length_m} m.\n\n"
-        f"A pressure drop of {pressure_drop_kPa} kPa is maintained over the length of the pipes. "
+        f"A pressure drop of {pressure_drop_kPa:.3f} kPa is maintained over the length of the pipes. "
         f"The fluid viscosity is {fluid_viscosity_Pas} Pa·s.\n\n"
         f"Calculate the volumetric flow rate (Q) through the annular space in m^3/s."
     )
@@ -244,31 +280,34 @@ def template_annulus_flowrate():
         f"- Inner Radius (R_inner): {inner_radius_cm} cm\n"
         f"- Outer Radius (R_outer): {outer_radius_cm} cm\n"
         f"- Pipe Length (L): {pipe_length_m} m\n"
-        f"- Pressure Drop (P0 - PL): {pressure_drop_kPa} kPa\n"
-        f"- Fluid Viscosity (mu): {fluid_viscosity_Pas} Pa·s\n\n"
+        f"- Pressure Drop (P0 - PL): {pressure_drop_kPa:.3f} kPa\n"
+        f"- Fluid Viscosity (mu): {fluid_viscosity_Pas} Pa·s\n"
+        f"\n\n"
 
         f"**Step 2:** Perform Unit Conversions\n"
-        f"The equation requires all units to be in the SI base system. We must convert the radii and the pressure drop.\n"
-        f"- Inner Radius: R_inner = {inner_radius_cm} cm * (1 m / 100 cm) = {inner_radius_m} m\n"
-        f"- Outer Radius: R_outer = {outer_radius_cm} cm * (1 m / 100 cm) = {outer_radius_m} m\n"
-        f"- Pressure Drop: P0 - PL = {pressure_drop_kPa} kPa * (1000 Pa / 1 kPa) = {pressure_drop_Pa} Pa\n\n"
+        f"The equation requires all units to be in the SI base system.\n"
+        f"- Inner Radius: R_inner = {inner_radius_cm} cm / 100 = {inner_radius_m} m\n"
+        f"- Outer Radius: R_outer = {outer_radius_cm} cm / 100 = {outer_radius_m} m\n"
+        f"- Pressure Drop: P0 - PL = {pressure_drop_kPa:.3f} kPa * 1000 = {pressure_drop_Pa} Pa\n\n"
         
         f"**Step 3:** Calculate the Dimensionless Ratio (kappa)\n"
         f"Kappa (k) is the ratio of the inner radius to the outer radius.\n"
-        f"kappa = R_inner / R_outer = {inner_radius_m} m / {outer_radius_m} m = {kappa_val:.3f}\n\n"
+        f"kappa = R_inner / R_outer = {inner_radius_m} / {outer_radius_m} = {kappa_val:.3f}\n\n"
 
         f"**Step 4:** State the Core Equation\n"
         f"The volumetric flow rate (Q) for laminar flow in an annulus is:\n"
-        f"Q = (pi * (P0 - PL) * R_outer^4) / (8 * mu * L) * [ (1 - kappa^4) - ((1 - kappa^2)^2 / ln(1/kappa)) ]\n\n"
+        f"Q = (pi * (P0 - PL) * R_outer^4) / (8 * mu * L) * [ (1 - k^4) - ((1 - k^2)^2 / ln(1/k)) ]\n\n"
 
         f"**Step 5:** Substitute Values and Calculate\n"
-        f"We substitute the converted SI values into the equation. Let's calculate the main term and the shape factor separately for clarity.\n"
-        f"Main Term = (pi * {pressure_drop_Pa} Pa * ({outer_radius_m} m)^4) / (8 * {fluid_viscosity_Pas} Pa·s * {pipe_length_m} m) = {term1:.6f}\n"
+        f"Calculate the main term:\n"
+        f"Main Term = (pi * {pressure_drop_Pa} * ({outer_radius_m})^4) / (8 * {fluid_viscosity_Pas} * {pipe_length_m})\n"
+        f"Main Term = {term1:.6e}\n\n"
+        f"Calculate the shape factor:\n"
         f"Shape Factor = [ (1 - {kappa_val:.3f}^4) - ((1 - {kappa_val:.3f}^2)^2 / ln(1/{kappa_val:.3f})) ] = {shape_factor:.4f}\n\n"
         f"Q = Main Term * Shape Factor\n"
-        f"Q = {term1:.6f} * {shape_factor:.4f} = {q_flow_rate:.7f} m^3/s\n\n"
+        f"Q = {term1:.6e} * {shape_factor:.4f} = {q_flow_rate:.4e} m^3/s\n\n"
 
-        f"Answer: The volumetric flow rate of {fluid_name} through the annular space is {q_flow_rate:.7f} m^3/s."
+        f"**Answer:** The volumetric flow rate is **{q_flow_rate:.4e} m^3/s**."
     )
 
     return question, solution

data/templates/branches/chemical_engineering/transport_phenomena/viscosity_and_momentum_transport.py

@@ -97,7 +97,7 @@ def template_kinematic_viscosity():
     Returns:
         tuple: A tuple containing:
             - str: A question asking to compute the kinematic viscosity.
-            - str: A step-by-step solution showing the calculation and unit conversion.
+            - str: A step-by-step solution showing the calculation.
     """
     # 1. Parameterize the inputs with random values
     
@@ -135,6 +135,7 @@ def template_kinematic_viscosity():
         f"**Step 1:** State the formula for kinematic viscosity.\n"
         f"Kinematic viscosity (ν) is defined as the ratio of dynamic viscosity to density:\n"
         f"ν = μ / ρ\n\n"
+        f"\n\n"
         
         f"**Step 2:** Calculate the kinematic viscosity in SI units (m²/s).\n"
         f"Substitute the given values into the formula:\n"
@@ -144,16 +145,18 @@ def template_kinematic_viscosity():
     
     # Add the unit conversion step only if needed
     if "Stokes" in target_units:
+        # Fixed formatting here to avoid 0.0000 for small values
         solution += (
             f"**Step 3:** Convert the result to Stokes (St).\n"
             f"The conversion factor is 1 m²/s = 10,000 St.\n"
             f"ν = ({nu_si:.3e} m²/s) * (10,000 St / 1 m²/s)\n"
-            f"ν = {final_nu:.4f} St\n\n"
+            f"ν = {final_nu:.4e} St\n\n"
         )
         
     solution += (
         f"**Answer:**\n"
-        f"The kinematic viscosity of {fluid_name} is **{final_nu:.4f} {target_units}**."
+        # Fixed formatting here to avoid 0.0000 for small values
+        f"The kinematic viscosity of {fluid_name} is **{final_nu:.4e} {target_units}**."
     )
 
     return question, solution

data/templates/branches/electrical_engineering/digital_communications/digital_modulation_schemes.py

@@ -39,20 +39,18 @@ def template_bpsk_energy_basis():
     k = random.randint(2, 20)
     carrier_freq_hz = k / bit_duration_s
 
-    # --- Start: Inline formatting for bit_duration_s ---
+    # Inline formatting for bit_duration_s 
     prefixes = {6: 'M', 3: 'k', 0: '', -3: 'm', -6: 'u', -9: 'n'}
     exponent_td = int(math.floor(math.log10(abs(bit_duration_s)) / 3.0) * 3)
     prefix_td = prefixes.get(exponent_td, '')
     scaled_td = bit_duration_s / (10**exponent_td)
     bit_duration_str = f"{round(scaled_td, precision)} {prefix_td}s"
-    # --- End: Inline formatting ---
 
-    # --- Start: Inline formatting for carrier_freq_hz ---
+    # Inline formatting for carrier_freq_hz 
     exponent_fc = int(math.floor(math.log10(abs(carrier_freq_hz)) / 3.0) * 3)
     prefix_fc = prefixes.get(exponent_fc, '')
     scaled_fc = carrier_freq_hz / (10**exponent_fc)
     carrier_freq_str = f"{round(scaled_fc, precision)} {prefix_fc}Hz"
-    # --- End: Inline formatting ---
 
     # 2. Perform the core calculation
     
@@ -62,12 +60,11 @@ def template_bpsk_energy_basis():
     # Calculate the amplitude of the basis function: sqrt(2 / Tb)
     basis_amplitude = math.sqrt(2 / bit_duration_s)
 
-    # --- Start: Inline formatting for energy_joules ---
+    # Inline formatting for energy_joules 
     exponent_e = int(math.floor(math.log10(abs(energy_joules)) / 3.0) * 3)
     prefix_e = prefixes.get(exponent_e, '')
     scaled_e = energy_joules / (10**exponent_e)
     energy_str = f"{round(scaled_e, precision)} {prefix_e}J"
-    # --- End: Inline formatting ---
     
     # 3. Generate the question and solution strings
 
@@ -126,21 +123,11 @@ def template_euclidean_distance_binary():
     Scenario:
         This template tests the ability to represent signals as vectors in a signal
         space and calculate the Euclidean distance between them. This distance is a
-        key factor in determining the noise immunity of a modulation scheme, as a
-        larger distance between signal points implies better performance in the
-        presence of noise. The problem covers two fundamental binary schemes:
-        antipodal (BPSK) and orthogonal (BFSK).
+        key factor in determining the noise immunity of a modulation scheme.
 
     Core Equations:
-        For BPSK (antipodal signals):
-            s1 = (sqrt(Eb))
-            s2 = (-sqrt(Eb))
-            d = 2 * sqrt(Eb)
-            
-        For Orthogonal BFSK:
-            s1 = (sqrt(Eb), 0)
-            s2 = (0, sqrt(Eb))
-            d = sqrt(2 * Eb)
+        For BPSK (antipodal): d = 2 * sqrt(Eb)
+        For BFSK (orthogonal): d = sqrt(2 * Eb)
 
     Returns:
         tuple: A tuple containing:
@@ -155,43 +142,47 @@ def template_euclidean_distance_binary():
     # Generate energy per bit, Eb, in a range from picojoules to nanojoules
     energy_joules = random.uniform(1e-12, 1e-9)
     
-    # --- Start: Inline formatting for energy_joules ---
+    # Inline formatting for energy_joules 
     prefixes = {0: '', -3: 'm', -6: 'u', -9: 'n', -12: 'p'}
     if energy_joules > 0:
         exponent_e = int(math.floor(math.log10(abs(energy_joules)) / 3.0) * 3)
         prefix_e = prefixes.get(exponent_e, '')
         scaled_e = energy_joules / (10**exponent_e)
-        energy_str = f"{round(scaled_e, precision)} {prefix_e}J"
+        energy_str = f"{scaled_e:.{precision}f} {prefix_e}J"
     else:
         energy_str = "0 J"
-    # --- End: Inline formatting ---
     
     # 2. Perform the core calculation based on modulation type
     
     sqrt_eb = math.sqrt(energy_joules)
 
+    # Use scientific notation formatting for small numbers instead of round()
+    sqrt_eb_fmt = f"{sqrt_eb:.{precision}e}"
+
     if modulation_type == 'BPSK':
         # BPSK signals are antipodal (180 degrees apart)
         constellation_type = "antipodal"
         dimension = "one-dimensional"
         basis_count = "one basis function, psi_1(t)"
         
-        s1_str = f"({sqrt_eb:.{precision}e})"
-        s2_str = f"(-{sqrt_eb:.{precision}e})"
+        s1_str = f"({sqrt_eb_fmt})"
+        s2_str = f"(-{sqrt_eb_fmt})"
         
         distance = 2 * sqrt_eb
+        dist_fmt = f"{distance:.{precision}e}"
         
         derivation_steps = (
             f"The signal vectors are s1 = (sqrt(Eb)) and s2 = (-sqrt(Eb)).\n"
-            f"s1 = ({round(sqrt_eb, precision)})\n"
-            f"s2 = (-{round(sqrt_eb, precision)})\n\n"
+            f"s1 = ({sqrt_eb_fmt})\n"
+            f"s2 = (-{sqrt_eb_fmt})\n\n"
+            
 
             f"**Step 2:** Calculate Euclidean Distance (d)\n"
             f"The distance d is the magnitude of the difference vector (s1 - s2).\n"
             f"s1 - s2 = (sqrt(Eb) - (-sqrt(Eb))) = (2*sqrt(Eb))\n"
             f"d = ||s1 - s2|| = 2*sqrt(Eb)\n"
-            f"d = 2 * {round(sqrt_eb, precision)}\n"
-            f"d = {round(distance, precision)}"
+            f"d = 2 * {sqrt_eb_fmt}\n"
+            f"d = {dist_fmt}"
         )
 
     else: # Orthogonal BFSK
@@ -200,22 +191,24 @@ def template_euclidean_distance_binary():
         dimension = "two-dimensional"
         basis_count = "two basis functions, psi_1(t) and psi_2(t)"
 
-        s1_str = f"({sqrt_eb:.{precision}e}, 0)"
-        s2_str = f"(0, {sqrt_eb:.{precision}e})"
+        s1_str = f"({sqrt_eb_fmt}, 0)"
+        s2_str = f"(0, {sqrt_eb_fmt})"
 
         distance = math.sqrt(2 * energy_joules)
+        dist_fmt = f"{distance:.{precision}e}"
 
         derivation_steps = (
             f"The signal vectors are s1 = (sqrt(Eb), 0) and s2 = (0, sqrt(Eb)).\n"
-            f"s1 = ({round(sqrt_eb, precision)}, 0)\n"
-            f"s2 = (0, {round(sqrt_eb, precision)})\n\n"
+            f"s1 = ({sqrt_eb_fmt}, 0)\n"
+            f"s2 = (0, {sqrt_eb_fmt})\n\n"
+            
 
             f"**Step 2: ** Calculate Euclidean Distance (d)\n"
             f"The distance d is the magnitude of the difference vector (s1 - s2).\n"
             f"s1 - s2 = (sqrt(Eb) - 0, 0 - sqrt(Eb)) = (sqrt(Eb), -sqrt(Eb))\n"
             f"d = ||s1 - s2|| = sqrt( (sqrt(Eb))^2 + (-sqrt(Eb))^2 ) = sqrt(2*Eb)\n"
             f"d = sqrt(2 * {energy_joules:.{precision}e})\n"
-            f"d = {round(distance, precision)}"
+            f"d = {dist_fmt}"
         )
 
     # 3. Generate the question and solution strings
@@ -235,14 +228,14 @@ def template_euclidean_distance_binary():
         
         f"**Step 1:** Define Signal Vectors\n"
         f"For {modulation_type} modulation, the signals are {constellation_type}. This means we can represent them in a {dimension} signal space using {basis_count}.\n"
-        f"First, we calculate sqrt(Eb) = sqrt({energy_joules:.{precision}e}) = {round(sqrt_eb, precision)}.\n"
+        f"First, we calculate sqrt(Eb) = sqrt({energy_joules:.{precision}e}) = {sqrt_eb_fmt}.\n"
         f"{derivation_steps}\n\n"
         
         f"**Answer:**\n"
         f"a) The signal constellation points are:\n"
         f"s1 = {s1_str}\n"
         f"s2 = {s2_str}\n"
-        f"b) The Euclidean distance between the points is {round(distance, precision)}."
+        f"b) The Euclidean distance between the points is {dist_fmt}."
     )
 
     return question, solution
@@ -254,39 +247,31 @@ def template_average_energy_mqam():
     Average Energy of an M-QAM Constellation
 
     Scenario:
-        For designing power-efficient transmitters, understanding the average energy
-        per transmitted symbol is crucial. Unlike M-PSK where all symbols have the
-        same energy, square M-QAM constellations have symbols with varying energies.
         This template tests the ability to calculate the average symbol energy by
         analyzing the geometry of the constellation.
 
     Core Equations:
-        Coordinates: (xi, yj) where xi, yj are in {+/-A, +/-3A, ...}
-        Symbol Energy: Ei = xi^2 + yj^2
-        Average Energy: E_avg = (1/M) * Sum(Ei for all points)
         General Formula: E_avg = (2/3) * (M - 1) * A^2
 
     Returns:
         tuple: A tuple containing:
-            - str: A question asking for the average energy of an M-QAM constellation.
-            - str: A step-by-step solution showing the calculation.
+            - str: A question asking for the average energy.
+            - str: A step-by-step solution.
     """
     # 1. Parameterize the inputs with random values
     precision = 2
     # Add 256-QAM to the list of possible modulation orders
     M = random.choice([4, 16, 64, 256])
-    # Randomly decide whether A is an integer or a float for more variety
+    
+    # Randomly decide whether A is an integer or a float
     if random.choice([True, False]):
-        # Generate an integer A
         A = random.randint(1, 10)
     else:
-        # Generate a float A from a wider range
         A = round(random.uniform(0.2, 10.0), precision)
     
     # 2. Perform the core calculation based on M
     
     # The general formula for average energy in a square M-QAM is (2/3)(M-1)A^2
-    # We will calculate it directly for the solution steps.
     avg_energy_coeff = (2/3) * (M - 1)
     avg_energy = avg_energy_coeff * (A**2)
 
@@ -315,27 +300,39 @@ def template_average_energy_mqam():
 
             f"**Step 3:** Calculate Average Energy (E_avg)\n"
             f"We sum the energies of all points and divide by M.\n"
-            f"Total Energy = 4*(2A^2) + 8*(10A^2) + 4*(18A^2) = 8A^2 + 80A^2 + 72A^2 = 160A^2\n"
+            f"Total Energy = 4*(2A^2) + 8*(10A^2) + 4*(18A^2) = 160A^2\n"
             f"E_avg = (Total Energy) / M = (160 * A^2) / 16 = 10 * A^2\n"
         )
         
-    else: # M == 64
+    elif M == 64:
         coordinate_set = "{+/-A, +/-3A, +/-5A, +/-7A}"
-        total_energy_coeff = 64 * avg_energy_coeff
         solution_steps = (
             "**Step 2:** List Signal Point Energies\n"
             "For 64-QAM, there are many groups of points with the same energy. We list a few examples:\n"
-            "The 4 innermost points at (+/-A, +/-A) have energy E = A^2 + A^2 = 2A^2.\n"
-            "The 8 points at (+/-A, +/-3A) or (+/-3A, +/-A) have energy E = A^2 + (3A)^2 = 10A^2.\n"
-            "The 4 outermost points at (+/-7A, +/-7A) have energy E = (7A)^2 + (7A)^2 = 98A^2.\n"
+            "- The 4 innermost points at (+/-A, +/-A) have energy E = 2A^2.\n"
+            "- The 4 outermost points at (+/-7A, +/-7A) have energy E = (7A)^2 + (7A)^2 = 98A^2.\n"
             "This process is continued for all 64 points.\n\n"
 
             "**Step 3:** Calculate Average Energy (E_avg)\n"
-            "Summing the energies for all 64 points and dividing by M gives the average. We can also use the general formula for square M-QAM: E_avg = (2/3)*(M-1)*A^2.\n"
+            "Summing the energies for all 64 points and dividing by M gives the average. We use the general formula for square M-QAM: E_avg = (2/3)*(M-1)*A^2.\n"
             "E_avg = (2/3) * (64 - 1) * A^2\n"
             "E_avg = (2/3) * 63 * A^2 = 42 * A^2\n"
         )
 
+    else: # M == 256 (Explicit handling for 256-QAM)
+        coordinate_set = "{+/-A, +/-3A, ..., +/-15A}"
+        solution_steps = (
+            "**Step 2:** List Signal Point Energies\n"
+            "For 256-QAM, the grid extends from -15A to +15A. Calculating individual point energies is tedious, so we rely on the general formula derived from the sum of squares.\n"
+            "- Innermost points: (+/-A, +/-A)\n"
+            "- Outermost points: (+/-15A, +/-15A)\n\n"
+
+            "**Step 3:** Calculate Average Energy (E_avg)\n"
+            "Using the general formula for square M-QAM: E_avg = (2/3)*(M-1)*A^2.\n"
+            "E_avg = (2/3) * (256 - 1) * A^2\n"
+            "E_avg = (2/3) * 255 * A^2 = 170 * A^2\n"
+        )
+
     # 3. Generate the question and solution strings
     
     question = (
@@ -347,7 +344,8 @@ def template_average_energy_mqam():
     solution = (
         f"**Given Information:**\n"
         f"Modulation Scheme: {M}-QAM\n"
-        f"Distance Parameter (A): {A}\n\n"
+        f"Distance Parameter (A): {A}\n"
+        f"\n\n"
         
         f"**Step 1:** Understand the Constellation Structure\n"
         f"The constellation is a square grid where coordinates are odd multiples of A. The energy of any point (x, y) is simply x^2 + y^2.\n\n"
@@ -540,7 +538,7 @@ def template_null_to_null_bandwidth():
     symbol_rate_rs = bit_rate_hz / k
     bandwidth_hz = 2 * symbol_rate_rs
 
-    # --- Start: Inline formatting for bandwidth_hz ---
+    #  Start: Inline formatting for bandwidth_hz 
     prefixes = {12: 'T', 9: 'G', 6: 'M', 3: 'k', 0: ''}
     if bandwidth_hz > 0:
         exponent_b = int(math.floor(math.log10(abs(bandwidth_hz)) / 3.0) * 3)
@@ -549,9 +547,9 @@ def template_null_to_null_bandwidth():
         bandwidth_str = f"{round(scaled_b, precision)} {prefix_b}Hz"
     else:
         bandwidth_str = "0 Hz"
-    # --- End: Inline formatting ---
+    #  End: Inline formatting 
 
-    # --- Start: Inline formatting for symbol_rate_rs ---
+    #  Start: Inline formatting for symbol_rate_rs 
     if symbol_rate_rs > 0:
         exponent_rs = int(math.floor(math.log10(abs(symbol_rate_rs)) / 3.0) * 3)
         prefix_rs = prefixes.get(exponent_rs, '')
@@ -559,7 +557,7 @@ def template_null_to_null_bandwidth():
         symbol_rate_str = f"{round(scaled_rs, precision)} {prefix_rs}symbols/s"
     else:
         symbol_rate_str = "0 symbols/s"
-    # --- End: Inline formatting ---
+    #  End: Inline formatting 
 
 
     # 3. Generate the question and solution strings

data/templates/branches/electrical_engineering/signals_and_systems/discrete_time_signals.py

@@ -272,37 +272,38 @@ def template_finite_convolution():
     Scenario:
         This template tests the direct application of the convolution sum, which is
         the fundamental operation for determining the output of a Linear
-        Time-Invariant (LTI) system. It requires convolving two finite-length
-        sequences, representing an input signal and a system's impulse response.
+        Time-Invariant (LTI) system.
 
     Core Equations:
         1. Convolution Sum: y[n] = sum(x[k] * h[n-k]) for all k
 
     Returns:
         tuple: A tuple containing:
-            - str: A question asking to find the output of an LTI system for a given input.
+            - str: A question asking to find the output of an LTI system.
             - str: A step-by-step solution demonstrating the convolution process.
     """
     # 1. Parameterize the inputs with random values
 
-    # Generate sequence x[n] as a dictionary {index: value}
+    # Generate sequence x[n]
     x_len = random.randint(3, 4)
     x_origin_pos = random.randint(0, x_len - 1)
     x_start_idx = -x_origin_pos
     x_n = {x_start_idx + i: random.randint(-3, 3) for i in range(x_len)}
+    
     # Ensure the sequence isn't all zeros
     if all(v == 0 for v in x_n.values()):
         x_n[random.choice(list(x_n.keys()))] = random.randint(1, 3)
 
-    # Generate sequence h[n] as a dictionary {index: value}
+    # Generate sequence h[n]
     h_len = random.randint(3, 4)
     h_origin_pos = random.randint(0, h_len - 1)
     h_start_idx = -h_origin_pos
     h_n = {h_start_idx + i: random.randint(-2, 2) for i in range(h_len)}
+    
     if all(v == 0 for v in h_n.values()):
         h_n[random.choice(list(h_n.keys()))] = random.randint(1, 2)
 
-    # Inlined logic to format x_n into a string
+    # Format x[n] string
     min_idx_x = min(x_n.keys())
     max_idx_x = max(x_n.keys())
     x_parts = []
@@ -311,7 +312,7 @@ def template_finite_convolution():
         x_parts.append(f"*{val}*" if i == 0 else str(val))
     x_n_str = f"{{{', '.join(x_parts)}}}"
 
-    # Inlined logic to format h_n into a string
+    # Format h[n] string
     min_idx_h = min(h_n.keys())
     max_idx_h = max(h_n.keys())
     h_parts = []
@@ -322,10 +323,9 @@ def template_finite_convolution():
 
 
     # 2. Perform the core calculation (Convolution)
-
     y_n = {}
-    y_start_idx = min(x_n.keys()) + min(h_n.keys())
-    y_end_idx = max(x_n.keys()) + max(h_n.keys())
+    y_start_idx = min_idx_x + min_idx_h
+    y_end_idx = max_idx_x + max_idx_h
 
     all_k_indices = sorted(list(x_n.keys()))
     
@@ -335,7 +335,7 @@ def template_finite_convolution():
             x_k = x_n.get(k, 0)
             h_nk = h_n.get(n - k, 0)
             current_sum += x_k * h_nk
-        # Only store non-zero values, but the final string will show zeros in the range
+        # Store non-zero values (or boundary zeros if needed, but dict sparse is fine)
         if current_sum != 0:
             y_n[n] = current_sum
     
@@ -350,9 +350,8 @@ def template_finite_convolution():
     calculation_steps = []
     y_indices_to_show = sorted(y_n.keys()) if y_n else [y_start_idx]
     
-    # To avoid too much output, only show a few sample calculations
+    # To avoid too much output, show first, middle, and last
     if len(y_indices_to_show) > 3:
-        # Show first, middle, and last non-zero points
         middle_index = y_indices_to_show[len(y_indices_to_show)//2]
         y_indices_to_show = [y_indices_to_show[0], middle_index, y_indices_to_show[-1]]
 
@@ -363,28 +362,27 @@ def template_finite_convolution():
         sum_expr_terms = []
         val_expr_terms = []
         
-        # Determine the range of k where overlap can occur for clarity
-        k_min = min(x_n.keys())
-        k_max = max(x_n.keys())
-
-        for k in range(k_min, k_max + 1):
-            x_val = x_n.get(k, 0)
-            # Only show terms where x[k] contributes to the expression
-            if x_val != 0:
-                h_val = h_n.get(n - k, 0)
-                sum_expr_terms.append(f"x[{k}]h[{n-k}]")
-                val_expr_terms.append(f"({x_val})({h_val})")
+        # Iterate over ALL valid k in x[n] to show full expansion, ensuring consistency
+        # Removed the "if x_val != 0" check to show all terms explicitly
+        for k in sorted(x_n.keys()):
+            x_val = x_n[k]
+            h_val = h_n.get(n - k, 0)
+            
+            # Identify h index for clarity
+            h_idx = n - k
+            
+            sum_expr_terms.append(f"x[{k}]h[{h_idx}]")
+            val_expr_terms.append(f"({x_val})({h_val})")
         
         step_str += f"y[{n}] = {' + '.join(sum_expr_terms)}\n"
         step_str += f"y[{n}] = {' + '.join(val_expr_terms)}\n"
         step_str += f"y[{n}] = {y_n.get(n, 0)}\n"
         calculation_steps.append(step_str)
 
-    # Inlined logic to format the final sequence y_n
+    # Format the final sequence y_n
     if not y_n:
         y_n_str = "{*0*}"
     else:
-        # The full range of y[n] must be shown, including zeros between start and end
         min_idx_y = y_start_idx
         max_idx_y = y_end_idx
         y_parts = []
@@ -408,12 +406,13 @@ def template_finite_convolution():
         f"y[n] = sum over all k of (x[k] * h[n-k])\n\n"
 
         f"**Step 2:** Apply the Flip-and-Slide Method\n"
-        f"We can visualize this process by flipping the impulse response h[k] to get h[-k], and then sliding it by 'n' positions. For each slide 'n', we calculate the sum of the products of the overlapping samples.\n\n"
-        f"Let's calculate a few points:\n\n"
+        f"We can visualize this process by flipping the impulse response h[k] to get h[-k], and then sliding it by 'n' positions. For each slide 'n', we calculate the sum of the products of the overlapping samples.\n"
+        f"\n\n"
+        f"Let's calculate a few points explicitly:\n\n"
         f"{calculation_steps_str}\n"
         
         f"**Step 3: Calculate All Output Values**\n"
-        f"By continuing this process for all values of 'n' where the sequences could overlap (from n={y_start_idx} to n={y_end_idx}), we get the following values for the output:\n"
+        f"By continuing this process for all values of 'n' where the sequences overlap (from n={y_start_idx} to n={y_end_idx}), we get the full output sequence:\n"
         f"{y_values_str}\n\n" 
 
         f"**Answer:**\n"
@@ -431,8 +430,7 @@ def template_system_property_linearity():
     Scenario:
         This template tests the ability to formally prove or disprove if a system
         is linear by checking the two defining properties: additivity and
-        homogeneity (also known as scaling). This is a fundamental concept in
-        characterizing systems.
+        homogeneity (scaling).
 
     Core Definitions:
         1. Additivity: T{x1[n] + x2[n]} = T{x1[n]} + T{x2[n]}
@@ -443,16 +441,19 @@ def template_system_property_linearity():
             - str: A question asking to determine if a system is linear.
             - str: A step-by-step solution showing the formal proof.
     """
-    # 1. Parameterize the inputs by generating a random system type and equation
+    # 1. Parameterize the inputs
     
     system_type = random.choice(['linear_gain', 'linear_delay', 'nonlinear_offset', 'nonlinear_power'])
     
-    # These variables will be populated based on the system type
     equation_str = ""
     is_linear = False
     
-    # Strings for each step of the proof
-    add_y1y2_sum_str = ""
+    # We will define these explicitly for each case to avoid "replace" bugs
+    y1_str = ""
+    y2_str = ""
+    
+    # Strings for the RHS of the proof steps (excluding "y = " prefix)
+    add_sum_str = ""
     add_y3_str = ""
     add_comparison_str = ""
     
@@ -460,35 +461,41 @@ def template_system_property_linearity():
     hom_ya_str = ""
     hom_comparison_str = ""
 
-
     if system_type == 'linear_gain':
         is_linear = True
         k = random.randint(1, 10)
         equation_str = f"{k} * x[n]"
         
-        # Additivity Proof Strings
-        add_y1y2_sum_str = f"y1[n] + y2[n] = ({k} * x1[n]) + ({k} * x2[n]) = {k} * (x1[n] + x2[n])"
-        add_y3_str = f"y3[n] = {k} * (x3[n]) = {k} * (x1[n] + x2[n])"
+        y1_str = f"{k} * x1[n]"
+        y2_str = f"{k} * x2[n]"
+        
+        # Additivity
+        add_sum_str = f"({k} * x1[n]) + ({k} * x2[n]) = {k} * (x1[n] + x2[n])"
+        add_y3_str = f"{k} * (x3[n]) = {k} * (x1[n] + x2[n])"
         add_comparison_str = "Since y3[n] is equal to y1[n] + y2[n], the system satisfies the additivity property."
         
-        # Homogeneity Proof Strings
-        hom_ay1_str = f"a * y1[n] = a * ({k} * x1[n])"
-        hom_ya_str = f"ya[n] = {k} * (xa[n]) = {k} * (a * x1[n])"
+        # Homogeneity
+        hom_ay1_str = f"a * ({k} * x1[n])"
+        hom_ya_str = f"{k} * (xa[n]) = {k} * (a * x1[n])"
         hom_comparison_str = "Since ya[n] is equal to a * y1[n], the system satisfies the homogeneity property."
         
     elif system_type == 'linear_delay':
         is_linear = True
         d = random.randint(1, 10)
         equation_str = f"x[n - {d}]"
+        
+        # Explicitly constructing strings handles the 'n-d' index correctly
+        y1_str = f"x1[n - {d}]"
+        y2_str = f"x2[n - {d}]"
 
-        # Additivity Proof Strings
-        add_y1y2_sum_str = f"y1[n] + y2[n] = x1[n - {d}] + x2[n - {d}]"
-        add_y3_str = f"y3[n] = x3[n - {d}] = x1[n - {d}] + x2[n - {d}]"
+        # Additivity
+        add_sum_str = f"x1[n - {d}] + x2[n - {d}]"
+        add_y3_str = f"x3[n - {d}] = x1[n - {d}] + x2[n - {d}]"
         add_comparison_str = "Since y3[n] is equal to y1[n] + y2[n], the system satisfies the additivity property."
 
-        # Homogeneity Proof Strings
-        hom_ay1_str = f"a * y1[n] = a * x1[n - {d}]"
-        hom_ya_str = f"ya[n] = xa[n - {d}] = a * x1[n - {d}]"
+        # Homogeneity
+        hom_ay1_str = f"a * x1[n - {d}]"
+        hom_ya_str = f"xa[n - {d}] = a * x1[n - {d}]"
         hom_comparison_str = "Since ya[n] is equal to a * y1[n], the system satisfies the homogeneity property."
         
     elif system_type == 'nonlinear_offset':
@@ -497,30 +504,36 @@ def template_system_property_linearity():
         C_str = f"+ {C}" if C > 0 else f"- {abs(C)}"
         equation_str = f"x[n] {C_str}"
         
-        # Additivity Proof Strings
-        add_y1y2_sum_str = f"y1[n] + y2[n] = (x1[n] {C_str}) + (x2[n] {C_str}) = x1[n] + x2[n] + {2*C}"
-        add_y3_str = f"y3[n] = (x3[n]) {C_str} = (x1[n] + x2[n]) {C_str}"
+        y1_str = f"x1[n] {C_str}"
+        y2_str = f"x2[n] {C_str}"
+        
+        # Additivity
+        add_sum_str = f"(x1[n] {C_str}) + (x2[n] {C_str}) = x1[n] + x2[n] + {2*C}"
+        add_y3_str = f"(x3[n]) {C_str} = (x1[n] + x2[n]) {C_str}"
         add_comparison_str = f"Since x1[n] + x2[n] + {2*C} is not equal to x1[n] + x2[n] {C_str}, the system fails the additivity test."
 
-        # Homogeneity Proof Strings
-        hom_ay1_str = f"a * y1[n] = a * (x1[n] {C_str}) = a*x1[n] + {C}*a"
-        hom_ya_str = f"ya[n] = (xa[n]) {C_str} = (a * x1[n]) {C_str}"
+        # Homogeneity
+        hom_ay1_str = f"a * (x1[n] {C_str}) = a*x1[n] + {C}*a"
+        hom_ya_str = f"(xa[n]) {C_str} = (a * x1[n]) {C_str}"
         hom_comparison_str = f"Since a*x1[n] + {C}*a is not equal to a*x1[n] {C_str} (for a != 1), the system fails the homogeneity test."
 
     elif system_type == 'nonlinear_power':
         is_linear = False
         p = random.randint(2, 3)
-        equation_str = f"(x[n])**{p}"
+        equation_str = f"(x[n])^{p}"
+        
+        y1_str = f"(x1[n])^{p}"
+        y2_str = f"(x2[n])^{p}"
         
-        # Additivity Proof Strings
-        add_y1y2_sum_str = f"y1[n] + y2[n] = (x1[n])**{p} + (x2[n])**{p}"
-        add_y3_str = f"y3[n] = (x3[n])**{p} = (x1[n] + x2[n])**{p}"
-        add_comparison_str = f"In general, (x1[n] + x2[n])**{p} is not equal to (x1[n])**{p} + (x2[n])**{p}. Therefore, the system fails the additivity test."
+        # Additivity
+        add_sum_str = f"(x1[n])^{p} + (x2[n])^{p}"
+        add_y3_str = f"(x3[n])^{p} = (x1[n] + x2[n])^{p}"
+        add_comparison_str = f"In general, (x1[n] + x2[n])^{p} is not equal to (x1[n])^{p} + (x2[n])^{p}. Therefore, the system fails the additivity test."
 
-        # Homogeneity Proof Strings
-        hom_ay1_str = f"a * y1[n] = a * (x1[n])**{p}"
-        hom_ya_str = f"ya[n] = (xa[n])**{p} = (a * x1[n])**{p} = (a**{p}) * (x1[n])**{p}"
-        hom_comparison_str = f"Since a * (x1[n])**{p} is not equal to (a**{p}) * (x1[n])**{p} (for a != 1), the system fails the homogeneity test."
+        # Homogeneity
+        hom_ay1_str = f"a * (x1[n])^{p}"
+        hom_ya_str = f"(xa[n])^{p} = (a * x1[n])^{p} = (a^{p}) * (x1[n])^{p}"
+        hom_comparison_str = f"Since a * (x1[n])^{p} is not equal to (a^{p}) * (x1[n])^{p} (for a != 1), the system fails the homogeneity test."
         
     # 2. Generate the question and solution strings
     
@@ -538,20 +551,21 @@ def template_system_property_linearity():
         f"For a system to be linear, it must satisfy two properties:\n"
         f"1. **Additivity:** T{{x1[n] + x2[n]}} = T{{x1[n]}} + T{{x2[n]}}\n"
         f"2. **Homogeneity (Scaling):** T{{a*x[n]}} = a*T{{x[n]}}\n"
-        f"We must test both properties.\n\n"
+        f"We must test both properties.\n"
+        f"\n\n"
 
         f"**Step 2:** Test for Additivity\n"
         f"Let's define two arbitrary inputs, x1[n] and x2[n]. The corresponding outputs are:\n"
-        f"y1[n] = {equation_str.replace('x[n]', 'x1[n]')}\n"
-        f"y2[n] = {equation_str.replace('x[n]', 'x2[n]')}\n\n"
+        f"y1[n] = {y1_str}\n"
+        f"y2[n] = {y2_str}\n\n"
         f"The sum of these outputs is:\n"
-        f"y1[n] + y2[n] = {add_y1y2_sum_str}\n\n"
+        f"y1[n] + y2[n] = {add_sum_str}\n\n"
         f"Now, let's define a third input x3[n] = x1[n] + x2[n]. The output y3[n] is:\n"
         f"y3[n] = {add_y3_str}\n\n"
         f"**Comparison:** {add_comparison_str}\n\n"
 
         f"**Step 3:** Test for Homogeneity (Scaling)\n"
-        f"Let's define an input x1[n] and a constant 'a'. The output is y1[n] = {equation_str.replace('x[n]', 'x1[n]')}.\n"
+        f"Let's define an input x1[n] and a constant 'a'. The output is y1[n] = {y1_str}.\n"
         f"The scaled output is:\n"
         f"a * y1[n] = {hom_ay1_str}\n\n"
         f"Now, let's define a new input xa[n] = a * x1[n]. The output ya[n] is:\n"
@@ -574,8 +588,7 @@ def template_impulse_response_from_lccde():
         This template tests the ability to find the impulse response h[n] for a
         system described by a Linear Constant-Coefficient Difference Equation
         (LCCDE). The process involves setting the input to the unit impulse,
-        delta[n], and solving the resulting recurrence relation for h[n] by finding
-        initial conditions and then solving the homogeneous equation.
+        delta[n], and solving the resulting recurrence relation for h[n].
 
     Core Definitions:
         1. Impulse Response: h[n] = T{delta[n]}
@@ -583,7 +596,7 @@ def template_impulse_response_from_lccde():
 
     Returns:
         tuple: A tuple containing:
-            - str: A question asking for the impulse response of a system given its LCCDE.
+            - str: A question asking for the impulse response.
             - str: A step-by-step solution detailing the recursive method.
     """
     # 1. Parameterize by randomly choosing system order and coefficients
@@ -622,7 +635,7 @@ def template_impulse_response_from_lccde():
         if h1 != 0:
             base = -a1
             # Use fmt helper to correctly sign the term
-            h_decay_expr = f" {fmt(h1, '')}({base})**(n-1) * u[n-1]"
+            h_decay_expr = f" {fmt(h1, '')}({base})^(n-1) * u[n-1]"
         
         final_h_n = f"{term1_str}{h_decay_expr}"
         
@@ -645,11 +658,11 @@ def template_impulse_response_from_lccde():
             f"For n >= 2, the input delta terms are zero. The equation becomes homogeneous:\n"
             f"h[n] {fmt(a1, 'h[n-1]')}h[n-1] = 0  =>  h[n] = {-a1}*h[n-1]\n\n"
             f"The solution to this recurrence for n >= 1 is a decaying exponential that starts at n=1 with value h[1].\n"
-            f"This part of the response can be written as h[1]*({-a1})**(n-1)*u[n-1].\n\n"
+            f"This part of the response can be written as h[1]*({-a1})^(n-1)*u[n-1].\n\n"
             
             f"**Step 5:** Combine Results for the Final Expression\n"
             f"The total impulse response is the sum of the value at n=0 and the response for n >= 1:\n"
-            f"h[n] = h[0]*delta[n] + h[1]*({-a1})**(n-1)*u[n-1]\n"
+            f"h[n] = h[0]*delta[n] + h[1]*({-a1})^(n-1)*u[n-1]\n"
         )
 
     else: # order == 'second'
@@ -660,14 +673,16 @@ def template_impulse_response_from_lccde():
             a1 = random.randint(-6, 6)
             if a1 == 0: a1 = 1
         
-        # Randomize RHS for increased diversity
+        # Randomize RHS
         b1 = random.randint(-3, 3) if random.random() > 0.4 else 0
-        b2 = random.randint(-2, 2) if random.random() > 0.3 else 0
+        # Force b2 = 0 to ensure the coefficient fitting method is valid
+        # If b2 != 0, there is an impulse at n=2 that breaks the homogeneous assumption for n>=2
+        b2 = 0 
 
         # Build equation strings
         x_terms = f"{b0}x[n]"
         if b1 != 0: x_terms += f" {fmt(b1, 'x[n-1]')}x[n-1]"
-        if b2 != 0: x_terms += f" {fmt(b2, 'x[n-2]')}x[n-2]"
+        # b2 term removed
         equation_str = f"y[n] {fmt(a1, 'y[n-1]')}y[n-1] {fmt(a2, 'y[n-2]')}y[n-2] = {x_terms}"
         
         # 2. Perform the core calculation for a second-order system
@@ -687,13 +702,12 @@ def template_impulse_response_from_lccde():
         C2 = (h0 * r1 - h1) / (r1 - r2)
         C1_str, C2_str = f"{C1:.2f}", f"{C2:.2f}"
         
-        final_h_n = f"({C1_str}({r1_str})**n {fmt(C2, C2_str)}({r2_str})**n) * u[n]"
+        final_h_n = f"({C1_str}({r1_str})^n {fmt(C2, C2_str)}({r2_str})^n) * u[n]"
         
         # 3. Generate the solution string for a second-order system
         h_eq = f"h[n] {fmt(a1, 'h[n-1]')}h[n-1] {fmt(a2, 'h[n-2]')}h[n-2]"
         d_eq = f"{b0}*delta[n]"
         if b1 != 0: d_eq += f" {fmt(b1, 'd[n-1]')}*delta[n-1]"
-        if b2 != 0: d_eq += f" {fmt(b2, 'd[n-2]')}*delta[n-2]"
 
         solution_steps = (
             f"**Step 3:** Solve Recursively for Initial Conditions\n"
@@ -704,16 +718,16 @@ def template_impulse_response_from_lccde():
             f"**h[0] = {h0}**\n\n"
             f"**For n = 1:**\n"
             f"h[1] {fmt(a1, 'h[0]')}h[0] {fmt(a2, 'h[-1]')}h[-1] = ... {fmt(b1, 'd[0]')}*delta[0] ...\n"
-            f"h[1] {fmt(a1, h0)}*({h0}) {fmt(a2, '0')}*(0) = {b0}*(0) + {b1}*(1) + {b2}*(0)\n"
+            f"h[1] {fmt(a1, h0)}*({h0}) {fmt(a2, '0')}*(0) = {b0}*(0) + {b1}*(1)\n"
             f"h[1] = {b1} - {a1*h0}\n"
             f"**h[1] = {h1}**\n\n"
 
             f"**Step 4:** Find the Homogeneous Solution\n"
-            f"For n >= 3, the input is zero, and the equation is homogeneous:\n"
+            f"For n >= 2, the input is zero (since b2=0), so the equation becomes homogeneous:\n"
             f"h[n] {fmt(a1, 'h[n-1]')}h[n-1] {fmt(a2, 'h[n-2]')}h[n-2] = 0\n\n"
-            f"We solve this by finding the roots of the characteristic equation: r**2 {fmt(a1, 'r')}r {fmt(a2, '')} = 0\n"
+            f"We solve this by finding the roots of the characteristic equation: r^2 {fmt(a1, 'r')}r {fmt(a2, '')} = 0\n"
             f"Using the quadratic formula, the roots are r1 = {r1_str}, r2 = {r2_str}.\n"
-            f"The general solution for n >= 0 is h[n] = C1*({r1_str})**n + C2*({r2_str})**n.\n\n"
+            f"The general solution for n >= 0 is h[n] = C1*({r1_str})^n + C2*({r2_str})^n.\n\n"
             
             f"**Step 5:** Use Initial Conditions to Find Coefficients\n"
             f"We use h[0] and h[1] to create a system of two equations:\n"
@@ -734,7 +748,8 @@ def template_impulse_response_from_lccde():
         f"The system equation is {equation_str}\n\n"
 
         f"**Step 1:** Set Input to the Unit Impulse\n"
-        f"By definition, the impulse response h[n] is the output y[n] when the input x[n] is the unit impulse, delta[n].\n\n"
+        f"By definition, the impulse response h[n] is the output y[n] when the input x[n] is the unit impulse, delta[n].\n"
+        f"\n\n"
 
         f"**Step 2:** Substitute h[n] and delta[n] into the Equation\n"
         f"Replacing y[n] with h[n] and x[n] with delta[n], we get:\n"

data/templates/branches/mechanical_engineering/fluid_mechanics/fluid_kinematics.py

@@ -166,17 +166,17 @@ def template_volumetric_flow_rate():
 
     # 2. Perform calculations and generate strings based on the chosen geometry
     if geometry == 'pipe':
-        # --- Pipe-specific parameters ---
+        #  Pipe-specific parameters 
         diameter_mm = random.randint(20, 200)
         radius_m = diameter_mm / 2000.0
 
-        # --- Core calculations for the pipe ---
+        #  Core calculations for the pipe 
         area = math.pi * radius_m**2
         # For a parabolic profile in a pipe, the exact integral yields Q = (1/2) * U_max * A
         flow_rate = 0.5 * u_max * area
         avg_velocity = u_max / 2.0
 
-        # --- Generate question and solution strings for the pipe ---
+        #  Generate question and solution strings for the pipe 
         question = (
             f"The velocity profile for a fluid flowing through a circular pipe with a diameter of {diameter_mm} mm "
             f"is given by u(r) = U_max * (1 - (r/R)^2), where R is the radius of the pipe and the maximum "
@@ -221,19 +221,19 @@ def template_volumetric_flow_rate():
         )
 
     else: # geometry == 'channel'
-        # --- Channel-specific parameters ---
+        #  Channel-specific parameters 
         height_cm = random.randint(5, 50)
         width_cm = random.randint(10, 100)
         height_m = height_cm / 100.0
         width_m = width_cm / 100.0
 
-        # --- Core calculations for the channel ---
+        #  Core calculations for the channel 
         area = width_m * height_m
         # For a linear profile in a channel, the exact integral yields Q = (1/2) * U_max * A
         flow_rate = 0.5 * u_max * area
         avg_velocity = u_max / 2.0
 
-        # --- Generate question and solution strings for the channel ---
+        #  Generate question and solution strings for the channel 
         question = (
             f"A fluid flows through a rectangular channel that is {width_cm} cm wide and {height_cm} cm high. "
             f"The velocity profile is given by u(y) = U_max * (y/H), where H is the channel height and the "
@@ -319,18 +319,18 @@ def template_vorticity_check():
     
     # 2. Perform calculations and generate strings based on the flow type
     if flow_type == '2D':
-        # --- Define a more complex 2D velocity field ---
+        #  Define a more complex 2D velocity field 
         # u = A*x*y, v = B*x^2 + C*y^2
         # This makes derivatives dependent on the point (x, y).
 
-        # --- Core calculations for 2D flow ---
+        #  Core calculations for 2D flow 
         du_dy_val = A * x_point
         dv_dx_val = 2 * B * x_point
         
         zeta_z = dv_dx_val - du_dy_val
         is_irrotational = abs(zeta_z) < 1e-9 # Check for zero with floating point tolerance
 
-        # --- Generate question and solution strings for 2D flow ---
+        #  Generate question and solution strings for 2D flow 
         question = (
             f"A 2D fluid flow is described by the velocity field:\n"
             f"u = {A}xy\n"
@@ -377,11 +377,11 @@ def template_vorticity_check():
         F = random.randint(-4, 4)
         z_point = round(random.uniform(0.5, 3.0), 1)
 
-        # --- Define a more complex 3D velocity field ---
+        #  Define a more complex 3D velocity field 
         # u = A*y^2, v = B*z^2 + C*x, w = D*x^2 + E*y
         # This allows all components of vorticity to be non-zero and position-dependent.
 
-        # --- Core calculations for 3D flow ---
+        #  Core calculations for 3D flow 
         du_dy_val = 2 * A * y_point
         du_dz_val = 0
         
@@ -397,7 +397,7 @@ def template_vorticity_check():
         
         is_irrotational = (abs(zeta_x) < 1e-9 and abs(zeta_y) < 1e-9 and abs(zeta_z) < 1e-9)
 
-        # --- Generate question and solution strings for 3D flow ---
+        #  Generate question and solution strings for 3D flow 
         question = (
             f"A 3D fluid flow is described by the velocity field:\n"
             f"u = {A}y^2\n"
@@ -456,9 +456,7 @@ def template_particle_pathline():
     Scenario:
         This template distinguishes between the Eulerian description (velocity field)
         and the Lagrangian description (individual particle path). It requires solving
-        a system of ordinary differential equations (ODEs) to trace a particle's
-        movement from a starting point to its position at a later time. The velocity
-        field is steady and designed so the variables are separable.
+        a system of ordinary differential equations (ODEs).
 
     Core Equations:
         Pathline Definition: dx/dt = u(x, y) and dy/dt = v(x, y)
@@ -467,20 +465,22 @@ def template_particle_pathline():
     Returns:
         tuple: A tuple containing:
             - str: A question asking for the particle's final coordinates.
-            - str: A step-by-step solution showing the derivation of the pathline equations.
+            - str: A step-by-step solution showing the derivation.
     """
-    # 1. Parameterize the inputs with random values
-    A = random.randint(1, 5)
-    B = random.randint(1, 5)
+    # 1. Parameterize the inputs with physically realistic values
+    # We reduce the magnitude of A and B to ensure the exponential growth doesn't
+    # produce physically absurd velocities (e.g. keeping v < 100 m/s).
+    # Units for A and B are 1/s.
+    A = round(random.uniform(0.1, 0.5), 1)
+    B = round(random.uniform(0.1, 0.5), 1)
 
-    x0 = round(random.uniform(0.5, 4.0), 1)
-    y0 = round(random.uniform(0.5, 4.0), 1)
-    tf = round(random.uniform(0.1, 2.0), 2)
+    x0 = round(random.uniform(0.5, 2.0), 1)
+    y0 = round(random.uniform(0.5, 2.0), 1)
+    tf = round(random.uniform(1.0, 4.0), 1)
 
-    precision = 4
+    precision = 3
 
     # 2. Perform the core calculations for the solution
-    # Solve for the final position by integrating the velocity components
     # x(t) = x0 * exp(A*t)
     # y(t) = y0 * exp(-B*t)
     xf = x0 * math.exp(A * tf)
@@ -488,8 +488,9 @@ def template_particle_pathline():
 
     # 3. Generate the question and solution strings
     question = (
-        f"A steady, 2D velocity field is given by u = {A}x and v = -{B}y. "
-        f"A fluid particle is located at the initial position (x0, y0) = ({x0}, {y0}) at time t=0.\n\n"
+        f"A steady, 2D velocity field is defined by the equations u = {A}x and v = -{B}y, "
+        f"where u and v are in m/s, x and y are in meters, and the constants have units of s^-1.\n\n"
+        f"A fluid particle is located at the initial position (x0, y0) = ({x0} m, {y0} m) at time t = 0 s.\n"
         f"Determine the particle's coordinates (x, y) at time t = {tf} s."
     )
 
@@ -500,8 +501,9 @@ def template_particle_pathline():
         f"Final time (tf) = {tf} s\n\n"
 
         f"**Step 1:** Set up the differential equation for the x-coordinate.\n"
-        f"The pathline is defined by dx/dt = u.\n"
-        f"  dx/dt = {A}x\n\n"
+        f"The pathline is defined by the rate of change of the particle's position: dx/dt = u.\n"
+        f"  dx/dt = {A}x\n"
+        f"\n\n"
 
         f"**Step 2:** Solve the ODE for x(t) by separating variables.\n"
         f"  (1/x) dx = {A} dt\n"
@@ -530,11 +532,11 @@ def template_particle_pathline():
 
         f"**Step 6:** Calculate the final position at t = {tf} s.\n"
         f"Substitute t = {tf} into the pathline equations:\n"
-        f"  x({tf}) = {x0} * exp({A} * {tf}) = {round(xf, precision)}\n"
-        f"  y({tf}) = {y0} * exp(-{B} * {tf}) = {round(yf, precision)}\n\n"
+        f"  x({tf}) = {x0} * exp({A} * {tf}) = {round(xf, precision)} m\n"
+        f"  y({tf}) = {y0} * exp(-{B} * {tf}) = {round(yf, precision)} m\n\n"
 
         f"**Answer:**\n"
-        f"At t = {tf} s, the particle's coordinates are ({round(xf, precision)}, {round(yf, precision)})."
+        f"At t = {tf} s, the particle's coordinates are ({round(xf, precision)} m, {round(yf, precision)} m)."
     )
 
     return question, solution
@@ -549,8 +551,7 @@ def template_incompressible_continuity():
         This problem uses the differential form of the conservation of mass
         (continuity equation) for a 2D, incompressible flow. Given one velocity
         component, the user must find the other by performing partial differentiation
-        and integration. The problem asks for the simplest possible expression,
-        which implies the constant of integration is zero.
+        and integration. The problem asks for the simplest possible expression.
 
     Core Equation:
         2D Incompressible Continuity: du/dx + dv/dy = 0
@@ -560,27 +561,63 @@ def template_incompressible_continuity():
             - str: A question asking for the unknown velocity component.
             - str: A step-by-step solution showing the derivation.
     """
+    # Helper to format algebraic terms cleanly (e.g. handles + -3x -> - 3x)
+    def fmt_term(coeff, var, is_first=False):
+        if coeff == 0:
+            return ""
+        
+        # Determine sign prefix
+        if coeff < 0:
+            sign = "-" if is_first else "- "
+            val = -coeff
+        else:
+            sign = "" if is_first else "+ "
+            val = coeff
+            
+        # Format number (remove .0 if integer)
+        if isinstance(val, float) and val.is_integer():
+            val = int(val)
+        
+        # Construct string
+        # If coeff is 1 and there is a variable, omit the '1'
+        if var:
+            if val == 1:
+                return f"{sign}{var}"
+            else:
+                return f"{sign}{val}{var}"
+        else:
+            return f"{sign}{val}"
+
+    # Helper to join two terms into an expression
+    def build_poly(c1, v1, c2, v2):
+        t1 = fmt_term(c1, v1, is_first=True)
+        t2 = fmt_term(c2, v2, is_first=False)
+        return f"{t1} {t2}".strip()
+
     # 1. Parameterize the inputs with random values
-    
-    # Randomly choose which velocity component is given
     given_component = random.choice(['u', 'v'])
-
-    # Random non-zero coefficients for the polynomial terms
+    
+    # Random non-zero coefficients
     A = random.choice([i for i in range(-5, 6) if i != 0])
     B = random.choice([i for i in range(-5, 6) if i != 0])
 
     # 2. Perform calculations and generate strings based on the chosen component
     if given_component == 'u':
-        # --- The u-component is given, find v ---
-        u_expr = f"{A}x^2 + {B}xy"
+        #  The u-component is given, find v 
+        # u = Ax^2 + Bxy
+        u_expr = build_poly(A, "x^2", B, "xy")
+        
+        # du/dx = 2Ax + By
+        du_dx_c1, du_dx_c2 = 2*A, B
+        du_dx_expr = build_poly(du_dx_c1, "x", du_dx_c2, "y")
         
-        # Core calculations
-        # du/dx = 2*A*x + B*y
-        du_dx_expr = f"{2*A}x + {B}y"
-        # dv/dy = -du/dx
-        dv_dy_expr = f"-({du_dx_expr})"
-        # v = integral(dv/dy) dy = integral(-(2*A*x + B*y)) dy
-        v_expr = f"{-2*A}xy - {B/2.0}y^2"
+        # dv/dy = -du/dx = -2Ax - By
+        dv_dy_c1, dv_dy_c2 = -2*A, -B
+        dv_dy_expr = build_poly(dv_dy_c1, "x", dv_dy_c2, "y")
+        
+        # v = integral(-2Ax - By) dy = -2Axy - (B/2)y^2
+        v_c1, v_c2 = -2*A, -B/2.0
+        v_expr = build_poly(v_c1, "xy", v_c2, "y^2")
         
         question = (
             f"A 2D, steady, incompressible flow has a velocity component in the x-direction "
@@ -592,42 +629,49 @@ def template_incompressible_continuity():
             f"**Given:**\n"
             f"The flow is 2D, steady, and incompressible.\n"
             f"The u-component of velocity is u = {u_expr}\n\n"
-
+            
             f"**Step 1:** State the 2D incompressible continuity equation.\n"
             f"The equation is: du/dx + dv/dy = 0\n\n"
-
+            
+            
             f"**Step 2:** Calculate the partial derivative of the given u-component with respect to x.\n"
             f"  du/dx = d/dx({u_expr})\n"
             f"  du/dx = {du_dx_expr}\n\n"
-
+            
             f"**Step 3:** Rearrange the continuity equation to solve for dv/dy.\n"
             f"  dv/dy = -du/dx\n"
-            f"  dv/dy = -({du_dx_expr}) = {-2*A}x - {B}y\n\n"
+            f"  dv/dy = -({du_dx_expr}) = {dv_dy_expr}\n\n"
             
             f"**Step 4:** Integrate dv/dy with respect to y to find v(x, y).\n"
-            f"  v(x, y) = integral({-2*A}x - {B}y) dy\n"
-            f"  v(x, y) = {-2*A}xy - ({B}/2)y^2 + f(x)\n"
+            f"  v(x, y) = integral({dv_dy_expr}) dy\n"
+            f"  v(x, y) = {v_expr} + f(x)\n"
             f"The 'constant' of integration, f(x), is an arbitrary function of x.\n\n"
-
+            
             f"**Step 5:** Provide the simplest form for v(x, y).\n"
             f"To find the simplest expression, we set the integration constant f(x) to zero.\n"
             f"  v(x, y) = {v_expr}\n\n"
-
+            
             f"**Answer:**\n"
             f"The simplest expression for the y-component of velocity is v = {v_expr}."
         )
 
     else: # given_component == 'v'
-        # --- The v-component is given, find u ---
-        v_expr = f"{A}y^2 + {B}xy"
+        #  The v-component is given, find u 
+        # v = Ay^2 + Bxy
+        v_expr = build_poly(A, "y^2", B, "xy")
 
-        # Core calculations
-        # dv/dy = 2*A*y + B*x
-        dv_dy_expr = f"{2*A}y + {B}x"
-        # du/dx = -dv/dy
-        du_dx_expr = f"-({dv_dy_expr})"
-        # u = integral(du/dx) dx = integral(-(2*A*y + B*x)) dx
-        u_expr_sol = f"{-2*A}xy - {B/2.0}x^2"
+        # dv/dy = 2Ay + Bx
+        dv_dy_c1, dv_dy_c2 = 2*A, B
+        dv_dy_expr = build_poly(dv_dy_c1, "y", dv_dy_c2, "x")
+        
+        # du/dx = -dv/dy = -2Ay - Bx
+        # Usually written as x term first: -Bx - 2Ay
+        du_dx_c1, du_dx_c2 = -B, -2*A
+        du_dx_expr = build_poly(du_dx_c1, "x", du_dx_c2, "y")
+        
+        # u = integral(-Bx - 2Ay) dx = -(B/2)x^2 - 2Axy
+        u_c1, u_c2 = -B/2.0, -2*A
+        u_expr_sol = build_poly(u_c1, "x^2", u_c2, "xy")
 
         question = (
             f"A 2D, steady, incompressible flow has a velocity component in the y-direction "
@@ -639,27 +683,27 @@ def template_incompressible_continuity():
             f"**Given:**\n"
             f"The flow is 2D, steady, and incompressible.\n"
             f"The v-component of velocity is v = {v_expr}\n\n"
-
+            
             f"**Step 1:** State the 2D incompressible continuity equation.\n"
             f"The equation is: du/dx + dv/dy = 0\n\n"
-
+            
             f"**Step 2:** Calculate the partial derivative of the given v-component with respect to y.\n"
             f"  dv/dy = d/dy({v_expr})\n"
             f"  dv/dy = {dv_dy_expr}\n\n"
-
+            
             f"**Step 3:** Rearrange the continuity equation to solve for du/dx.\n"
             f"  du/dx = -dv/dy\n"
-            f"  du/dx = -({dv_dy_expr}) = {-B}x - {2*A}y\n\n"
+            f"  du/dx = -({dv_dy_expr}) = {du_dx_expr}\n\n"
             
             f"**Step 4:** Integrate du/dx with respect to x to find u(x, y).\n"
-            f"  u(x, y) = integral({-B}x - {2*A}y) dx\n"
-            f"  u(x, y) = -({B}/2)x^2 - {2*A}xy + g(y)\n"
+            f"  u(x, y) = integral({du_dx_expr}) dx\n"
+            f"  u(x, y) = {u_expr_sol} + g(y)\n"
             f"The 'constant' of integration, g(y), is an arbitrary function of y.\n\n"
-
+            
             f"**Step 5:** Provide the simplest form for u(x, y).\n"
             f"To find the simplest expression, we set the integration constant g(y) to zero.\n"
             f"  u(x, y) = {u_expr_sol}\n\n"
-
+            
             f"**Answer:**\n"
             f"The simplest expression for the x-component of velocity is u = {u_expr_sol}."
         )

data/templates/branches/mechanical_engineering/fluid_mechanics/fluid_statics.py

@@ -11,11 +11,10 @@ def template_hydrostatic_pressure_at_depth():
     Scenario:
         This template generates a fundamental problem to calculate the absolute
         pressure at a specified depth within a fluid. It considers both the
-        pressure exerted by the fluid column and the pressure at the free surface,
-        applying the basic hydrostatic pressure equation.
+        pressure exerted by the fluid column and the pressure at the free surface.
 
     Core Equation:
-        p_absolute = p_surface + (rho * g * h)
+        p_absolute = p_surface_absolute + (rho * g * h)
 
     Returns:
         tuple: A tuple containing:
@@ -27,36 +26,51 @@ def template_hydrostatic_pressure_at_depth():
     # Randomly select a fluid and its properties
     fluid_name, density_rho = random.choice(list(FLUID_DENSITIES.items()))
 
-    # Randomize depth in meters
-    depth_h = round(random.uniform(5.0, 500.0), 2)
+    # Randomize depth in meters (Restricted to realistic tank depths)
+    depth_h = round(random.uniform(2.0, 25.0), 2)
 
     # Randomly decide if the surface pressure is atmospheric or a specified gauge pressure
     is_surface_atmospheric = random.choice([True, False])
+    
+    # Define Atmospheric Pressure
+    P_atm_kpa = 101.325
 
     if is_surface_atmospheric:
-        surface_pressure_kpa = ATMOSPHERIC_PRESSURE_KPA
-        pressure_type_desc = "is atmospheric pressure"
+        # Surface is open to atmosphere
+        surface_pressure_input_kpa = P_atm_kpa
+        surface_pressure_abs_kpa = P_atm_kpa
+        pressure_type_desc = "is exposed to the atmosphere"
+        surface_calc_note = "Since the surface is open to the atmosphere, the surface absolute pressure is just P_atm."
     else:
-        # Generate a random gauge pressure at the surface
-        surface_pressure_kpa = round(random.uniform(10.0, 200.0), 2)
-        pressure_type_desc = f"has a gauge pressure of {surface_pressure_kpa} kPa"
+        # Surface is pressurized (Gauge Pressure given)
+        surface_gauge_kpa = round(random.uniform(10.0, 200.0), 2)
+        surface_pressure_input_kpa = surface_gauge_kpa
+        
+        # FIX: Absolute Surface Pressure = Gauge + Atm
+        surface_pressure_abs_kpa = surface_gauge_kpa + P_atm_kpa
+        
+        pressure_type_desc = f"is maintained at a gauge pressure of {surface_gauge_kpa} kPa"
+        surface_calc_note = (
+            f"The problem gives gauge pressure. To get absolute pressure at the surface, we add atmospheric pressure:\n"
+            f"P_surface_abs = P_gauge + P_atm = {surface_gauge_kpa} + {P_atm_kpa} = {surface_pressure_abs_kpa:.3f} kPa"
+        )
 
     # Standardize precision for final outputs
     precision = 3
 
     # 2. Perform the core calculations for the solution
 
-    # Step A: Ensure all units are consistent (convert surface pressure to Pascals)
-    surface_pressure_pa = surface_pressure_kpa * 1000
+    # Step A: Convert absolute surface pressure to Pascals
+    surface_pressure_pa = surface_pressure_abs_kpa * 1000
 
-    # Step B: Calculate the pressure increase due to the fluid column (Gauge Pressure)
-    # This is the result of p_gauge = rho * g * h
+    # Step B: Calculate the pressure increase due to the fluid column (Hydrostatic Pressure)
+    # p_hydro = rho * g * h
     pressure_increase_pa = density_rho * GRAVITY * depth_h
 
     # Step C: Calculate the final absolute pressure in Pascals
     absolute_pressure_pa = surface_pressure_pa + pressure_increase_pa
 
-    # Step D: Convert the final answer back to kilopascals (kPa) for readability
+    # Step D: Convert the final answer back to kilopascals (kPa)
     absolute_pressure_kpa = absolute_pressure_pa / 1000
 
     # 3. Generate the question and solution strings
@@ -64,39 +78,39 @@ def template_hydrostatic_pressure_at_depth():
     question = (
         f"An object is located {depth_h} m below the surface of a tank containing "
         f"{fluid_name.lower()}. The pressure at the free surface {pressure_type_desc}. "
-        f"Assuming the density of {fluid_name.lower()} is {density_rho} kg/m^3, "
+        f"Assuming the density of {fluid_name.lower()} is {density_rho} kg/m^3 and standard atmospheric pressure is {P_atm_kpa} kPa, "
         f"what is the absolute pressure at this depth?"
     )
 
     solution = (
         f"**Given:**\n"
-        f"Fluid: {fluid_name}\n"
-        f"Density of Fluid (rho): {density_rho} kg/m^3\n"
+        f"Fluid: {fluid_name} (Density rho = {density_rho} kg/m^3)\n"
         f"Depth (h): {depth_h} m\n"
-        f"Surface Pressure (p_surface): {surface_pressure_kpa} kPa\n"
+        f"Surface Condition: {pressure_type_desc}\n"
+        f"Standard Atmospheric Pressure (P_atm): {P_atm_kpa} kPa\n"
         f"Acceleration due to Gravity (g): {GRAVITY} m/s^2\n\n"
 
-        f"**Step 1:** Ensure Consistent Units\n"
-        f"The calculations require pressure to be in Pascals (Pa) to be consistent with other SI units.\n"
-        f"p_surface = {surface_pressure_kpa} kPa * 1000 = {surface_pressure_pa:.2f} Pa\n\n"
+        f"**Step 1:** Determine the Absolute Pressure at the Surface\n"
+        f"{surface_calc_note}\n"
+        f"Convert to Pascals: P_surface_abs = {surface_pressure_abs_kpa:.3f} kPa * 1000 = {surface_pressure_pa:.1f} Pa\n\n"
 
-        f"**Step 2:** Calculate the Pressure Increase Due to the Fluid Column\n"
-        f"The pressure exerted by the fluid at a given depth is calculated using the formula: p_increase = rho * g * h.\n"
-        f"p_increase = {density_rho} kg/m^3 * {GRAVITY} m/s^2 * {depth_h} m\n"
-        f"p_increase = {pressure_increase_pa:.2f} Pa\n\n"
+        f"**Step 2:** Calculate the Hydrostatic Pressure Increase\n"
+        f"The pressure exerted by the fluid column is calculated using: P_hydro = rho * g * h.\n"
+        f"P_hydro = {density_rho} kg/m^3 * {GRAVITY} m/s^2 * {depth_h} m\n"
+        f"P_hydro = {pressure_increase_pa:.1f} Pa\n"
+        f"\n\n"
 
-        f"**Step 3:** Calculate the Absolute Pressure at the Specified Depth\n"
-        f"The absolute pressure is the sum of the surface pressure and the pressure increase due to the fluid column.\n"
-        f"Formula: p_absolute = p_surface + p_increase\n"
-        f"p_absolute = {surface_pressure_pa:.2f} Pa + {pressure_increase_pa:.2f} Pa\n"
-        f"p_absolute = {absolute_pressure_pa:.2f} Pa\n\n"
+        f"**Step 3:** Calculate Total Absolute Pressure at Depth\n"
+        f"The absolute pressure at depth is the sum of the absolute surface pressure and the hydrostatic pressure.\n"
+        f"P_absolute = P_surface_abs + P_hydro\n"
+        f"P_absolute = {surface_pressure_pa:.1f} Pa + {pressure_increase_pa:.1f} Pa\n"
+        f"P_absolute = {absolute_pressure_pa:.1f} Pa\n\n"
 
-        f"**Step 4:** Convert the Final Answer to Kilopascals (kPa)\n"
-        f"For convenience, we convert the final pressure from Pascals back to kilopascals.\n"
-        f"p_absolute = {absolute_pressure_pa:.2f} Pa / 1000 = {round(absolute_pressure_kpa, precision)} kPa\n\n"
+        f"**Step 4:** Convert Final Answer to kPa\n"
+        f"P_absolute = {absolute_pressure_pa:.1f} Pa / 1000 = {round(absolute_pressure_kpa, precision)} kPa\n\n"
 
         f"**Answer:**\n"
-        f"The absolute pressure at a depth of {depth_h} m is {round(absolute_pressure_kpa, precision)} kPa."
+        f"The absolute pressure at a depth of {depth_h} m is **{round(absolute_pressure_kpa, precision)} kPa**."
     )
 
     return question, solution
@@ -203,40 +217,47 @@ def template_utube_manometer():
             - str: A question asking for the gauge pressure in a pipe.
             - str: A step-by-step solution to the problem.
     """
-    # 1. Parameterize the inputs with random values
-
-    # Randomly select a fluid for the pipe
-    pipe_fluid_name, rho1 = random.choice(list(PIPE_FLUIDS.items()))
-
-    # Randomly select a fluid for the manometer
-    manometer_fluid_name, rho2 = random.choice(list(MANOMETER_FLUIDS.items()))
-
-    # --- Ensure physical realism: manometer fluid must be denser ---
-    # If the chosen pipe fluid is denser than the manometer fluid, re-select
-    # the manometer fluid until it is denser. This avoids nonsensical scenarios.
-    while rho2 <= rho1:
+    # 1. Parameterize the inputs with a loop to ensure positive gauge pressure
+    # This prevents physically confusing scenarios where the description says the open arm 
+    # level is "higher" but the math yields suction (negative pressure).
+    while True:
+        # Randomly select a fluid for the pipe
+        pipe_fluid_name, rho1 = random.choice(list(PIPE_FLUIDS.items()))
+
+        # Randomly select a fluid for the manometer
         manometer_fluid_name, rho2 = random.choice(list(MANOMETER_FLUIDS.items()))
 
-    # Randomize the vertical heights, in meters
-    # h1: distance from pipe centerline down to the fluid interface
-    h1 = round(random.uniform(0.1, 0.5), 2)
-    # h2: the height difference between the two manometer fluid columns
-    h2 = round(random.uniform(0.05, 0.75), 2)
+        #  Ensure physical realism: manometer fluid must be denser 
+        # If the chosen pipe fluid is denser than the manometer fluid, re-select
+        # the manometer fluid until it is denser.
+        if rho2 <= rho1:
+            continue
+
+        # Randomize the vertical heights, in meters
+        # h1: distance from pipe centerline down to the fluid interface
+        h1 = round(random.uniform(0.1, 0.5), 2)
+        # h2: the height difference between the two manometer fluid columns
+        h2 = round(random.uniform(0.05, 0.75), 2)
+
+        # 2. Perform the core calculations for verification
+        
+        # Step A: Calculate the pressure contribution from the pipe fluid column (rho1*g*h1)
+        pressure_term1_pa = rho1 * GRAVITY * h1
+
+        # Step B: Calculate the pressure contribution from the manometer fluid column (rho2*g*h2)
+        pressure_term2_pa = rho2 * GRAVITY * h2
+
+        # Step C: Calculate the gauge pressure in Pascals (Pa)
+        gauge_pressure_pa = pressure_term2_pa - pressure_term1_pa
+        
+        # Condition: Pressure must be positive to match the problem description
+        # (open arm level is "higher" implies P_pipe > P_atm)
+        if gauge_pressure_pa > 0:
+            break
 
     # Standardize precision for final outputs
     precision = 3
 
-    # 2. Perform the core calculations for the solution
-
-    # Step A: Calculate the pressure contribution from the pipe fluid column (rho1*g*h1)
-    pressure_term1_pa = rho1 * GRAVITY * h1
-
-    # Step B: Calculate the pressure contribution from the manometer fluid column (rho2*g*h2)
-    pressure_term2_pa = rho2 * GRAVITY * h2
-
-    # Step C: Calculate the gauge pressure in Pascals (Pa)
-    gauge_pressure_pa = pressure_term2_pa - pressure_term1_pa
-
     # Step D: Convert the final answer to kilopascals (kPa) for readability
     gauge_pressure_kpa = gauge_pressure_pa / 1000
 
@@ -319,7 +340,7 @@ def template_floating_object_submersion_depth():
     obj_material, rho_object = random.choice(list(MATERIAL_DENSITIES.items()))
     fluid_name, rho_fluid = random.choice(list(FLUID_DENSITIES.items()))
 
-    # CRITICAL: Ensure the object will actually float ---
+    # CRITICAL: Ensure the object will actually float 
     # Re-select until the object's density is less than the fluid's density.
     max_attempts = 20
     attempt = 0

data/templates/branches/mechanical_engineering/mechanics_of_materials/stress_and_strain.py

@@ -28,7 +28,7 @@ def template_basic_stress_strain():
     precision = 3  # Standardize precision for numerical stability and formatting
 
     if use_si_units:
-        # --- SI Unit System ---
+        #  SI Unit System 
         load = random.randint(10, 500)  # in kN
         length = round(random.uniform(0.5, 4.0), 2)  # in meters
         elongation = round(random.uniform(0.5, 5.0), 2)  # in mm
@@ -59,7 +59,7 @@ def template_basic_stress_strain():
         strain_unit_explanation = "mm/m or unitless"
 
     else:
-        # --- US Customary Unit System ---
+        #  US Customary Unit System 
         load = random.randint(5, 100)  # in kips
         length = round(random.uniform(24.0, 120.0), 1)  # in inches
         elongation = round(random.uniform(0.05, 0.25), 3)  # in inches
@@ -197,7 +197,7 @@ def template_axial_deformation():
     precision = 3
 
     if use_si_units:
-        # --- SI Unit System ---
+        #  SI Unit System 
         material_E = MATERIAL_PROPERTIES[material_name]['E_GPa'] # in GPa
         length = round(random.uniform(0.5, 5.0), 2) # in m
         
@@ -234,7 +234,7 @@ def template_axial_deformation():
             elongation_str = f"{round(elongation, precision)} mm"
 
     else:
-        # --- US Customary Unit System ---
+        #  US Customary Unit System 
         material_E = MATERIAL_PROPERTIES[material_name]['E_ksi'] # in ksi
         length = round(random.uniform(12.0, 150.0), 1) # in inches
         
@@ -392,71 +392,78 @@ def template_multi_segment_rod():
             - str: A question about the total deformation of a composite rod.
             - str: A step-by-step solution.
     """
-    # 1. Parameterize inputs
-    use_si_units = random.choice([True, False])
-    num_segments = random.choice([2, 3])
+    # 1. Parameterize inputs with validation loop
     precision = 4
     
-    segments = []
-    loads = {} # Loads applied at nodes {node_index: load_value}
+    # Define a safe list of structural materials (exclude rubber for this high-load problem)
+    structural_materials = [k for k in MATERIAL_PROPERTIES.keys() if 'Rubber' not in k]
 
-    # Generate properties for each segment
-    for i in range(num_segments):
-        material_name = random.choice(list(MATERIAL_PROPERTIES.keys()))
-        segment = {'material_name': material_name}
+    while True:
+        use_si_units = random.choice([True, False])
+        num_segments = random.choice([2, 3])
         
-        if use_si_units:
-            segment['length'] = round(random.uniform(0.2, 1.5), 2) # meters
-            # For simplicity, all segments are circular
-            diameter = round(random.uniform(20, 75), 1) # mm
-            segment['area'] = math.pi * (diameter / 2)**2
-            segment['E'] = MATERIAL_PROPERTIES[material_name]['E_GPa']
-            segment['dim_str'] = f"{diameter} mm diameter"
-            # Node i+1 is the right end of segment i
-            loads[i+1] = random.randint(-250, 250) # kN
-        else:
-            segment['length'] = round(random.uniform(10.0, 60.0), 1) # inches
-            diameter = round(random.uniform(0.75, 3.0), 1) # inches
-            segment['area'] = math.pi * (diameter / 2)**2
-            segment['E'] = MATERIAL_PROPERTIES[material_name]['E_ksi']
-            segment['dim_str'] = f"{diameter} in diameter"
-            loads[i+1] = random.randint(-60, 60) # kips
-
-        segments.append(segment)
-
-    # 2. Perform Core Calculations
-    # A. Calculate internal forces (P_i) in each segment
-    # We work from the free end (right) to the fixed end (left)
-    total_deformation = 0
-    cumulative_load = 0
-    # Iterate backwards from the last segment to the first
-    for i in range(num_segments - 1, -1, -1):
-        # The internal force in segment 'i' is the sum of all external loads to its right
-        node_index = i + 1
-        cumulative_load += loads[node_index]
-        segments[i]['internal_load'] = cumulative_load
-
-    # B. Calculate deformation (delta_i) for each segment and sum them
-    for i in range(num_segments):
-        P = segments[i]['internal_load']
-        L = segments[i]['length']
-        A = segments[i]['area']
-        E = segments[i]['E']
+        segments = []
+        loads = {} # Loads applied at nodes {node_index: load_value}
         
-        if use_si_units:
-            # Convert units for consistency: N, mm, MPa (N/mm^2)
-            # P: kN → N (multiply by 1000)
-            # L: m → mm (multiply by 1000)  
-            # A: already in mm²
-            # E: GPa → MPa (multiply by 1000)
-            # delta = (P_N * L_mm) / (A_mm2 * E_MPa)
-            delta = (P * 1000 * L * 1000) / (A * E * 1000) # mm
-        else:
-            # Units are already consistent: kips, inches, ksi (kip/in^2)
-            delta = (P * L) / (A * E) # inches
+        # Generate properties for each segment
+        for i in range(num_segments):
+            material_name = random.choice(structural_materials)
+            segment = {'material_name': material_name}
+            
+            if use_si_units:
+                segment['length'] = round(random.uniform(0.2, 1.5), 2) # meters
+                diameter = round(random.uniform(20, 75), 1) # mm
+                segment['area'] = math.pi * (diameter / 2)**2
+                segment['E'] = MATERIAL_PROPERTIES[material_name]['E_GPa']
+                segment['dim_str'] = f"{diameter} mm diameter"
+                loads[i+1] = random.randint(-250, 250) # kN
+            else:
+                segment['length'] = round(random.uniform(10.0, 60.0), 1) # inches
+                diameter = round(random.uniform(0.75, 3.0), 1) # inches
+                segment['area'] = math.pi * (diameter / 2)**2
+                segment['E'] = MATERIAL_PROPERTIES[material_name]['E_ksi']
+                segment['dim_str'] = f"{diameter} in diameter"
+                loads[i+1] = random.randint(-60, 60) # kips
+
+            segments.append(segment)
+
+        # 2. Perform Core Calculations
+        total_deformation = 0
+        cumulative_load = 0
+        max_strain = 0
         
-        segments[i]['deformation'] = delta
-        total_deformation += delta
+        # Calculate internal forces and deformations
+        # Iterate backwards from the last segment to the first
+        for i in range(num_segments - 1, -1, -1):
+            node_index = i + 1
+            cumulative_load += loads[node_index]
+            segments[i]['internal_load'] = cumulative_load
+
+        for i in range(num_segments):
+            P = segments[i]['internal_load']
+            L = segments[i]['length']
+            A = segments[i]['area']
+            E = segments[i]['E']
+            
+            if use_si_units:
+                # delta = (P_N * L_mm) / (A_mm2 * E_MPa)
+                # P in kN -> *1000 -> N
+                # L in m -> *1000 -> mm
+                # E in GPa -> *1000 -> MPa
+                delta = (P * 1000 * L * 1000) / (A * E * 1000) # mm
+                current_strain = abs(delta / (L * 1000))
+            else:
+                delta = (P * L) / (A * E) # inches
+                current_strain = abs(delta / L)
+            
+            segments[i]['deformation'] = delta
+            total_deformation += delta
+            if current_strain > max_strain:
+                max_strain = current_strain
+
+        # Validate: Ensure max strain is < 1% (0.01) for linear elasticity to hold
+        if max_strain < 0.01:
+            break # Valid problem generated
 
     # 3. Generate Question and Solution Strings
     question = (
@@ -527,15 +534,28 @@ def template_multi_segment_rod():
 
     for i, seg in enumerate(segments):
         solution += f"  - **Segment {i+1} ({seg['material_name']}):**\n"
-        solution += (
-            f"P{i+1} = {seg['internal_load']} {unit_P}\n"
-            f"L{i+1} = {seg['length']} {unit_L}\n"
-            f"A{i+1} = {round(seg['area'], precision)} {'mm²' if use_si_units else 'in²'}\n"
-            f"E{i+1} = {seg['E']} {unit_E}\n"
-            f"δ{i+1} = ({seg['internal_load']} × {seg['length']}) / ({round(seg['area'], precision)} × {seg['E']}) = {round(seg['deformation'], precision)} {unit_D}\n"
-        )
+        
         if use_si_units:
-            solution += f"*Note:* Calculation uses consistent units (N, mm, MPa).\n"
+            # Explicitly show unit conversions in the solution string
+            P_disp = f"{seg['internal_load']} kN ({seg['internal_load']*1000:.0f} N)"
+            L_disp = f"{seg['length']} m ({seg['length']*1000:.0f} mm)"
+            E_disp = f"{seg['E']} GPa ({seg['E']*1000:.0f} MPa)"
+            
+            solution += (
+                f"P{i+1} = {P_disp}\n"
+                f"L{i+1} = {L_disp}\n"
+                f"A{i+1} = {round(seg['area'], precision)} mm²\n"
+                f"E{i+1} = {E_disp}\n"
+                f"δ{i+1} = ({seg['internal_load']*1000:.0f} × {seg['length']*1000:.0f}) / ({round(seg['area'], precision)} × {seg['E']*1000:.0f}) = {round(seg['deformation'], precision)} mm\n"
+            )
+        else:
+            solution += (
+                f"P{i+1} = {seg['internal_load']} kips\n"
+                f"L{i+1} = {seg['length']} in\n"
+                f"A{i+1} = {round(seg['area'], precision)} in²\n"
+                f"E{i+1} = {seg['E']} ksi\n"
+                f"δ{i+1} = ({seg['internal_load']} × {seg['length']}) / ({round(seg['area'], precision)} × {seg['E']}) = {round(seg['deformation'], precision)} in\n"
+            )
 
     solution += (
         f"\n**Step 3:** Calculate the Total Deformation\n"
@@ -580,54 +600,76 @@ def template_poissons_ratio():
     use_si_units = random.choice([True, False])
     material_name = random.choice(list(MATERIAL_PROPERTIES.keys()))
     material = MATERIAL_PROPERTIES[material_name]
-    precision = 5 # Use higher precision for small strain values
+    precision = 5 
 
-    # For this problem, the cross-section is always circular
+    # Generate dimensions first
     if use_si_units:
-        # SI Unit System 
-        load_kN = random.randint(50, 950) * random.choice([-1, 1]) # in kN (tensile or compressive)
-        initial_length_m = round(random.uniform(0.5, 3.0), 2) # in meters
-        initial_diameter_mm = random.randint(25, 125) # in mm
-        
+        initial_length_m = round(random.uniform(0.5, 3.0), 2)
+        initial_diameter_mm = random.randint(25, 125)
         area_mm2 = math.pi * (initial_diameter_mm / 2)**2
         E_GPa = material['E_GPa']
         nu = material['nu']
-
-        # Core Calculations (Units: N, mm, MPa)
+        
+        # Ensure Elastic Behavior 
+        # Instead of random load, pick a safe target strain (0.1% to 0.4%)
+        target_strain = random.uniform(0.001, 0.004) * random.choice([-1, 1])
+        
+        # Calculate Load required to achieve this strain: P = E * A * epsilon
+        # E in MPa (GPa * 1000), A in mm2 -> P in Newtons
+        required_load_N = (E_GPa * 1000) * area_mm2 * target_strain
+        
+        # Convert to kN and round to look like a "given" problem value
+        load_kN = round(required_load_N / 1000.0)
+        # Ensure load is not zero
+        if load_kN == 0: load_kN = 1 if target_strain > 0 else -1
+            
+        # Now recalculate exact stress/strain from this rounded load
         stress_MPa = (load_kN * 1000) / area_mm2
         axial_strain = stress_MPa / (E_GPa * 1000)
-        lateral_strain = -nu * axial_strain
-        delta_diameter_mm = initial_diameter_mm * lateral_strain
-        final_diameter_mm = initial_diameter_mm + delta_diameter_mm
-
-        # Formatting for question and solution
-        load_str = f"{load_kN} kN"
+        
+        # Formatting
+        load_str = f"{abs(load_kN)} kN"
         load_type_str = "tension" if load_kN > 0 else "compression"
         dim_str = f"{initial_diameter_mm} mm"
         unit_d = "mm"
         
+        # Secondary calculations
+        lateral_strain = -nu * axial_strain
+        delta_diameter_mm = initial_diameter_mm * lateral_strain
+        final_diameter_mm = initial_diameter_mm + delta_diameter_mm
+        
     else:
         # US Customary Unit System
-        load_kips = random.randint(15, 250) * random.choice([-1, 1]) # in kips
-        initial_length_in = round(random.uniform(20.0, 100.0), 1) # in inches
-        initial_diameter_in = round(random.uniform(1.0, 5.0), 2) # in inches
-        
+        initial_length_in = round(random.uniform(20.0, 100.0), 1)
+        initial_diameter_in = round(random.uniform(1.0, 5.0), 2)
         area_in2 = math.pi * (initial_diameter_in / 2)**2
         E_ksi = material['E_ksi']
         nu = material['nu']
         
-        # Core Calculations (Units: kips, in, ksi)
+        # Ensure Elastic Behavior 
+        target_strain = random.uniform(0.001, 0.004) * random.choice([-1, 1])
+        
+        # Calculate Load: P = E * A * epsilon
+        required_load_kips = E_ksi * area_in2 * target_strain
+        
+        # Round to integer kips
+        load_kips = round(required_load_kips)
+        if load_kips == 0: load_kips = 1 if target_strain > 0 else -1
+            
+        # Recalculate exact values
         stress_ksi = load_kips / area_in2
         axial_strain = stress_ksi / E_ksi
-        lateral_strain = -nu * axial_strain
-        delta_diameter_in = initial_diameter_in * lateral_strain
-        final_diameter_in = initial_diameter_in + delta_diameter_in
         
-        # Formatting for question and solution
-        load_str = f"{load_kips} kips"
+        # Formatting
+        load_str = f"{abs(load_kips)} kips"
         load_type_str = "tension" if load_kips > 0 else "compression"
         dim_str = f"{initial_diameter_in} in"
         unit_d = "in"
+        
+        # Secondary calculations
+        lateral_strain = -nu * axial_strain
+        delta_diameter_in = initial_diameter_in * lateral_strain
+        final_diameter_in = initial_diameter_in + delta_diameter_in
 
     # 2. Generate Question and Solution Strings
     question = (
@@ -645,16 +687,17 @@ def template_poissons_ratio():
         f"**Given:**\n"
         f"Material: {material_name} (E = {material['E_GPa' if use_si_units else 'E_ksi']} {'GPa' if use_si_units else 'ksi'}, nu = {nu})\n"
         f"Initial Diameter (d_0): {dim_str}\n"
-        f"Axial Load (P): {load_str}\n\n"
+        f"Axial Load (P): {load_str} ({load_type_str})\n\n"
 
         f"**Step 1:** Calculate Axial Strain (epsilon_axial)\n"
         f"First, we need the cross-sectional area (A) and the axial stress (sigma).\n"
         f"A = pi * (d_0 / 2)^2 = pi * ({initial_diameter_mm if use_si_units else initial_diameter_in} / 2)^2 = {round(area_mm2 if use_si_units else area_in2, 4)} {'mm^2' if use_si_units else 'in^2'}\n"
+        f"\n"
     )
 
     if use_si_units:
         solution += (
-            f"sigma = P / A = ({load_kN} * 1000 N) / ({round(area_mm2, 4)} mm^2) = {round(stress_MPa, 3)} MPa\n"
+            f"sigma = P / A = ({load_kN * 1000} N) / ({round(area_mm2, 4)} mm^2) = {round(stress_MPa, 3)} MPa\n"
             f"Now, calculate axial strain using Hooke's Law: epsilon_axial = sigma / E.\n"
             f"E = {E_GPa} GPa = {E_GPa * 1000} MPa\n"
             f"epsilon_axial = {round(stress_MPa, 3)} MPa / {E_GPa * 1000} MPa = {axial_strain:.4e}\n\n"
@@ -720,7 +763,7 @@ def template_statically_indeterminate():
     precision = 3
 
     if use_si_units:
-        # --- SI Unit System ---
+        #  SI Unit System 
         total_length = round(random.uniform(1.0, 3.0), 2) # m
         len_AB = round(random.uniform(0.2 * total_length, 0.8 * total_length), 2) # m
         len_BC = total_length - len_AB
@@ -739,7 +782,7 @@ def template_statically_indeterminate():
         unit_L, unit_P, unit_S, unit_A, unit_E = "m", "kN", "MPa", "mm^2", "GPa"
 
     else:
-        # --- US Customary Unit System ---
+        #  US Customary Unit System 
         total_length = round(random.uniform(40.0, 120.0), 1) # inches
         len_AB = round(random.uniform(0.2 * total_length, 0.8 * total_length), 1) # inches
         len_BC = total_length - len_AB
@@ -802,7 +845,7 @@ def template_statically_indeterminate():
         f"**Step 1:** Equation of Equilibrium\n"
         f"Summing forces in the x-direction (assuming right is positive):\n"
         f"Sum(F_x) = 0  =>  -R_A + P - R_C = 0\n"
-        f"R_A + R_C = {load_P} {unit_P}  ----(Equation 1)\n\n"
+        f"R_A + R_C = {load_P} {unit_P}  -(Equation 1)\n\n"
 
         f"**Step 2:** Equation of Compatibility\n"
         f"Since the rod is fixed between unyielding supports, the total deformation must be zero.\n"
@@ -812,7 +855,7 @@ def template_statically_indeterminate():
         f"Using the deformation formula delta = PL/AE:\n"
         f"(R_A * L_AB) / (A * E) - (R_C * L_BC) / (A * E) = 0\n"
         f"Since A and E are constant, they cancel out:\n"
-        f"R_A * L_AB = R_C * L_BC  ----(Equation 2)\n\n"
+        f"R_A * L_AB = R_C * L_BC  -(Equation 2)\n\n"
 
         f"**Step 3:** Solve for the Reaction Forces\n"
         f"From Equation 1, we can express R_C as: R_C = {load_P} - R_A.\n"

data/templates/branches/mechanical_engineering/mechanics_of_materials/torsion.py

@@ -2,6 +2,7 @@ import random
 import math
 from data.templates.branches.mechanical_engineering.constants import SHEAR_MODULUS_VALUES
 
+
 # Template 1 (Easy)
 def template_shear_stress_torsion():
     """
@@ -10,8 +11,7 @@ def template_shear_stress_torsion():
     Scenario:
         This template generates a foundational problem testing the ability to calculate
         the polar moment of inertia (J) for a solid or hollow circular shaft.
-        It then uses this value to determine the maximum shearing stress (tau_max)
-        resulting from an applied torque.
+        It then uses this value to determine the maximum shearing stress (tau_max).
 
     Core Equations:
         tau_max = (T * c) / J
@@ -30,11 +30,11 @@ def template_shear_stress_torsion():
     # Ensure diameters are distinct and practical
     d_outer = random.randint(30, 150)  # Outer diameter in mm
     
-    # For hollow shafts, ensure the inner diameter is smaller than the outer
+    # For hollow shafts, ensure realistic wall thickness
     if shaft_type == 'hollow':
-        # Ensure inner diameter is at least 10mm smaller to be meaningful
-        max_inner_dia = max(20, d_outer - 10) 
-        d_inner = random.randint(20, max_inner_dia)
+        # Inner diameter is 50-80% of outer diameter (realistic proportions)
+        ratio = random.uniform(0.5, 0.8)
+        d_inner = round(d_outer * ratio)
     else:
         d_inner = 0
 
@@ -70,10 +70,10 @@ def template_shear_stress_torsion():
     
     # Construct the part of the question describing the geometry
     if shaft_type == 'solid':
-        geometry_desc = f"a solid circular shaft with an outer diameter of {d_outer} mm"
+        geometry_desc = f"solid circular shaft with an outer diameter of {d_outer} mm"
     else: # shaft_type == 'hollow'
         geometry_desc = (
-            f"a hollow circular shaft with an outer diameter of {d_outer} mm "
+            f"hollow circular shaft with an outer diameter of {d_outer} mm "
             f"and an inner diameter of {d_inner} mm"
         )
 
@@ -109,6 +109,7 @@ def template_shear_stress_torsion():
         
         f"**Step 3:** Apply the torsion formula to find the maximum shearing stress (tau_max).\n"
         f"The formula is: tau_max = (T * c) / J\n"
+        f"\n"
         f"T = {torque} N.m\n"
         f"c = {c_outer} m\n"
         f"J = {polar_moment_J:.3e} m^4\n"
@@ -349,37 +350,46 @@ def template_composite_shafts_series():
             - str: A question about a composite shaft in series.
             - str: A step-by-step solution.
     """
-    # 1. Parameterize the inputs with random values
-    torque = round(random.uniform(200.0, 7500.0), 1)
+    # 1. Parameterize the inputs with physically realistic values
+    
+    # Reduce max torque to prevent plastic deformation/failure
+    torque = round(random.uniform(200.0, 3000.0), 1)
+
+    # Filter for strong materials (Metals, G > 20 GPa) to ensure elastic behavior
+    STRONG_MATERIALS = {k: v for k, v in SHEAR_MODULUS_VALUES.items() if v > 20.0}
+    
+    # Fallback if dictionary is empty
+    if not STRONG_MATERIALS:
+        STRONG_MATERIALS = {"Structural Steel": 79.3, "Aluminum Alloy": 26.0}
 
     # Properties for Segment 1 (AB)
     l1 = round(random.uniform(0.5, 2.5), 2)
     d1 = random.randint(40, 120)
-    mat1_name, g1_gpa = random.choice(list(SHEAR_MODULUS_VALUES.items()))
+    mat1_name, g1_gpa = random.choice(list(STRONG_MATERIALS.items()))
 
     # Properties for Segment 2 (BC)
     l2 = round(random.uniform(0.5, 2.5), 2)
-    d2 = random.randint(30, d1) # Ensure d2 is not larger than d1 for a typical stepped shaft
-    mat2_name, g2_gpa = random.choice(list(SHEAR_MODULUS_VALUES.items()))
+    d2 = random.randint(30, d1) # Ensure d2 is not larger than d1
+    mat2_name, g2_gpa = random.choice(list(STRONG_MATERIALS.items()))
     
     # Standardize precision for final outputs
     precision = 4
 
     # 2. Perform the core calculations
     
-    # --- Calculations for Segment 1 (AB) ---
+    #  Calculations for Segment 1 (AB) 
     c1_m = d1 / 2000.0
     g1_pa = g1_gpa * 1e9
     j1 = (math.pi / 2) * (c1_m ** 4)
     phi1_rad = (torque * l1) / (j1 * g1_pa)
 
-    # --- Calculations for Segment 2 (BC) ---
+    #  Calculations for Segment 2 (BC) 
     c2_m = d2 / 2000.0
     g2_pa = g2_gpa * 1e9
     j2 = (math.pi / 2) * (c2_m ** 4)
     phi2_rad = (torque * l2) / (j2 * g2_pa)
     
-    # --- Total Angle of Twist ---
+    #  Total Angle of Twist 
     phi_total_rad = phi1_rad + phi2_rad
     phi_total_deg = math.degrees(phi_total_rad)
 
@@ -403,7 +413,8 @@ def template_composite_shafts_series():
         f"**Step 1:** Analyze the System\n"
         f"The shaft is fixed at A, so the torque T = {torque} N.m is transmitted through both segments AB and BC. "
         f"The total angle of twist at C is the sum of the twist in segment AB and the twist in segment BC.\n"
-        f"phi_total = phi_AB + phi_BC\n\n"
+        f"phi_total = phi_AB + phi_BC\n"
+        f"\n\n"
 
         f"**Step 2:** Calculate Angle of Twist for Segment AB (phi_AB)\n"
         f"Convert units: c1 = {d1}/2 mm = {c1_m} m; G1 = {g1_gpa} GPa = {g1_pa:.2e} Pa\n"
@@ -440,43 +451,43 @@ def template_statically_indeterminate_shaft():
         This problem deals with a shaft that is fixed at both ends and has a torque
         applied at an intermediate point. Since there are two unknown reaction torques
         but only one static equilibrium equation, the problem is statically
-        indeterminate. It must be solved by considering both static equilibrium and
-        the geometric compatibility of deformation (i.e., the total angle of twist is zero).
+        indeterminate.
 
     Core Equations:
         1. Statics: T_A + T_B = T_applied
-        2. Compatibility: phi_AC + phi_CB = 0  =>  (T_A * L_AC) / (JG) = (T_B * L_BC) / (JG)
-           This simplifies to: T_A * L_AC = T_B * L_BC
+        2. Compatibility: T_A * L_AC = T_B * L_BC
 
     Returns:
         tuple: A tuple containing:
             - str: A question asking for the reaction torques.
             - str: A step-by-step solution using statics and compatibility.
     """
-    # 1. Parameterize the inputs with random values
-    total_length = round(random.uniform(2.0, 6.0), 2)
-    applied_torque = round(random.uniform(1000.0, 15000.0), -2)
-    diameter = random.randint(50, 150)
+    # 1. Parameterize the inputs with physically realistic values
+    
+    total_length = round(random.uniform(2.0, 5.0), 2)
+    # Reduce max torque to 5000 Nm to ensure elastic behavior for given diameters
+    applied_torque = round(random.uniform(500.0, 5000.0), -2) 
+    diameter = random.randint(50, 150) # mm
     
     # Ensure the torque is applied at a non-trivial location
     pos_L_AC = round(random.uniform(0.2 * total_length, 0.8 * total_length), 2)
     pos_L_BC = total_length - pos_L_AC
 
-    material_name, shear_modulus_gpa = random.choice(list(SHEAR_MODULUS_VALUES.items()))
+    # FILTER: Select only strong materials (Metals, G > 20 GPa) to avoid failure
+    # This prevents assigning 5000 Nm of torque to a Nylon shaft.
+    strong_materials = {k: v for k, v in SHEAR_MODULUS_VALUES.items() if v > 20.0}
+    if not strong_materials:
+        # Fallback if dictionary is empty or has no metals
+        material_name, shear_modulus_gpa = "Structural Steel", 79.3
+    else:
+        material_name, shear_modulus_gpa = random.choice(list(strong_materials.items()))
     
     # Standardize precision for final outputs
     precision = 2
 
     # 2. Perform the core calculations
-    # Based on the system of equations:
-    # (1) T_A + T_B = T_applied
-    # (2) T_A * L_AC = T_B * L_BC  =>  T_B = T_A * (L_AC / L_BC)
-    # Substitute (2) into (1):
-    # T_A + T_A * (L_AC / L_BC) = T_applied
-    # T_A * (1 + L_AC/L_BC) = T_applied
-    # T_A * ( (L_BC + L_AC) / L_BC ) = T_applied
-    # T_A * (L / L_BC) = T_applied
     # T_A = T_applied * (L_BC / L)
+    # T_B = T_applied * (L_AC / L)
     
     reaction_torque_A = applied_torque * (pos_L_BC / total_length)
     reaction_torque_B = applied_torque * (pos_L_AC / total_length)
@@ -499,39 +510,35 @@ def template_statically_indeterminate_shaft():
         
         f"**Analysis:**\n"
         f"This problem is statically indeterminate because there are two unknown reaction torques (T_A and T_B) "
-        f"and only one relevant equation from statics. We need an additional equation from the deformation of the shaft.\n\n"
+        f"and only one relevant equation from statics. We need an additional equation from the deformation of the shaft.\n"
+        f"\n\n"
 
         f"**Step 1:** Statics Equilibrium Equation\n"
-        f"For the shaft to be in rotational equilibrium, the sum of all torques must be zero. Let's assume T_A and T_B act in the opposite direction to T_applied.\n"
+        f"For the shaft to be in rotational equilibrium, the sum of all torques must be zero.\n"
         f"(1) T_A + T_B = T_applied = {int(applied_torque)} N.m\n\n"
 
         f"**Step 2:** Compatibility Equation\n"
-        f"Since the shaft is fixed at both ends, the total angle of twist from A to B must be zero. The twist from A to C and the twist from C to B must cancel each other out.\n"
-        f"phi_A_to_B = phi_AC + phi_CB = 0\n"
-        f"The torque in section AC is T_A. The torque in section CB is T_applied - T_A = T_B. For our compatibility equation, it is easier to think of the torque in CB as T_B acting from the other direction.\n"
-        f"phi_AC = (T_A * L_AC) / (J*G)\n"
-        f"phi_CB = -(T_B * L_BC) / (J*G)  (The negative sign indicates it twists in the opposite direction)\n"
-        f"(T_A * L_AC) / (J*G) - (T_B * L_BC) / (J*G) = 0\n"
-        f"The terms J and G are constant for the shaft and cancel out, leaving a relationship between the torques and lengths:\n"
+        f"Since the shaft is fixed at both ends, the total angle of twist from A to B must be zero. "
+        f"The twist caused by T_A acting on length AC must equal the twist caused by T_B acting on length BC.\n"
+        f"phi_AC = phi_CB\n"
+        f"(T_A * L_AC) / (J*G) = (T_B * L_BC) / (J*G)\n"
+        f"Since J and G are constant, they cancel out:\n"
         f"(2) T_A * L_AC = T_B * L_BC\n\n"
 
         f"**Step 3:** Solve the System of Two Equations\n"
-        f"We have two equations:\n"
-        f"(1) T_A + T_B = {int(applied_torque)}\n"
-        f"(2) T_A * {pos_L_AC} = T_B * {round(pos_L_BC, 2)}\n"
-        f"From equation (2), we can express T_B in terms of T_A:\n"
-        f"T_B = T_A * ({pos_L_AC} / {round(pos_L_BC, 2)})\n"
+        f"From equation (2), express T_B in terms of T_A:\n"
+        f"T_B = T_A * ({pos_L_AC} / {pos_L_BC:.2f})\n"
         f"Substitute this into equation (1):\n"
-        f"T_A + T_A * ({pos_L_AC} / {round(pos_L_BC, 2)}) = {int(applied_torque)}\n"
-        f"T_A * (1 + {round(pos_L_AC / pos_L_BC, 3)}) = {int(applied_torque)}\n"
-        f"T_A = {int(applied_torque)} / {round(1 + (pos_L_AC / pos_L_BC), 3)} = {round(reaction_torque_A, precision)} N.m\n"
-        f"Now find T_B using equation (1):\n"
-        f"T_B = {int(applied_torque)} - T_A = {int(applied_torque)} - {round(reaction_torque_A, precision)} = {round(reaction_torque_B, precision)} N.m\n\n"
+        f"T_A + T_A * ({pos_L_AC} / {pos_L_BC:.2f}) = {int(applied_torque)}\n"
+        f"T_A * (1 + {pos_L_AC/pos_L_BC:.3f}) = {int(applied_torque)}\n"
+        f"T_A = {int(applied_torque)} / {1 + (pos_L_AC / pos_L_BC):.3f} = {reaction_torque_A:.{precision}f} N.m\n"
+        f"Now find T_B:\n"
+        f"T_B = {int(applied_torque)} - {reaction_torque_A:.{precision}f} = {reaction_torque_B:.{precision}f} N.m\n\n"
 
         f"**Answer:**\n"
         f"The reaction torques at the supports are:\n"
-        f"T_A = {round(reaction_torque_A, precision)} N.m\n"
-        f"T_B = {round(reaction_torque_B, precision)} N.m"
+        f"T_A = {reaction_torque_A:.{precision}f} N.m\n"
+        f"T_B = {reaction_torque_B:.{precision}f} N.m"
     )
 
     return question, solution

src/template_loader.py

@@ -3,67 +3,94 @@ import inspect
 import importlib.util
 from pathlib import Path
 
-# Define root path relative to this script
-BASE_DIR = Path(__file__).parent.parent / "data" / "templates" / "branches"
+#  PATH CONFIGURATION 
+# 1. Get the folder where this script is (e.g., EngChain/src)
+CURRENT_DIR = Path(__file__).resolve().parent
+# 2. Get the project root (e.g., EngChain)
+PROJECT_ROOT = CURRENT_DIR.parent
+# 3. Define where templates live
+BASE_DIR = PROJECT_ROOT / "data" / "templates" / "branches"
 
 def get_branches():
-    """Returns a list of available engineering branches."""
-    if not BASE_DIR.exists():
-        return []
+    if not BASE_DIR.exists(): return []
     return sorted([d.name for d in BASE_DIR.iterdir() if d.is_dir() and not d.name.startswith("__")])
 
 def get_areas(branch_name):
-    """Returns the sub-areas (directories) for a given branch."""
     branch_path = BASE_DIR / branch_name
-    if not branch_path.exists():
-        return []
+    if not branch_path.exists(): return []
     return sorted([d.name for d in branch_path.iterdir() if d.is_dir() and not d.name.startswith("__")])
 
 def get_template_files(branch_name, area_name):
-    """Returns the python filenames (modules) in an area."""
     area_path = BASE_DIR / branch_name / area_name
-    if not area_path.exists():
-        return []
-    
-    files = [
-        f.stem for f in area_path.glob("*.py")
-        if f.name not in ["constants.py", "__init__.py"] and not f.name.startswith("__")
-    ]
-    return sorted(files)
+    if not area_path.exists(): return []
+    return sorted([f.stem for f in area_path.glob("*.py") if f.name not in ["constants.py", "__init__.py"] and not f.name.startswith("__")])
 
 def load_template_functions(branch, area, filename):
-    """
-    Loads a specific file and returns a list of its template functions.
-    Returns: List of tuples (function_name, function_object)
-    """
     file_path = BASE_DIR / branch / area / f"{filename}.py"
-    if not file_path.exists():
-        raise FileNotFoundError(f"File not found: {file_path}")
+    if not file_path.exists(): raise FileNotFoundError(f"File not found: {file_path}")
+
+    #  CRITICAL FIX: Add Project Root to sys.path 
+    # This ensures 'from data...' imports work, preventing the silent crash
+    if str(PROJECT_ROOT) not in sys.path:
+        sys.path.append(str(PROJECT_ROOT))
 
-    # Dynamic import
     spec = importlib.util.spec_from_file_location(filename, file_path)
     module = importlib.util.module_from_spec(spec)
     
-    # Add branch folder to path so imports like 'from constants import...' work
-    sys.path.append(str(file_path.parent.parent)) 
-    
     try:
         spec.loader.exec_module(module)
     except Exception as e:
-        return [] # Return empty if module crashes on load
+        print(f"!!! Error loading module '{filename}': {e}")
+        return []
 
-    # Extract all functions that start with 'template_'
     templates = []
     for name, obj in inspect.getmembers(module):
         if inspect.isfunction(obj) and name.startswith("template_"):
             templates.append((name, obj))
-            
     return sorted(templates, key=lambda x: x[0])
 
-def get_source_code(branch, area, filename):
-    """Returns the raw source code of the entire file."""
-    file_path = BASE_DIR / branch / area / f"{filename}.py"
-    if not file_path.exists():
-        return "# Error: File not found."
-    with open(file_path, "r", encoding="utf-8") as f:
-        return f.read()
+def get_source_code(func_object):
+    """Extracts ONLY the function code, not the whole file."""
+    try:
+        return inspect.getsource(func_object)
+    except OSError:
+        return "# Error: Source not available."
+    
+
+if __name__ == "__main__":
+    print(" 1. Testing get_branches ")
+    branches = get_branches()
+    print(f"Branches found: {branches}")
+
+    if branches:
+        # Test with the first available branch
+        selected_branch = branches[0]
+        print(f"\n 2. Testing get_areas for '{selected_branch}' ")
+        areas = get_areas(selected_branch)
+        print(f"Areas found: {areas}")
+
+        if areas:
+            # Test with the first available area
+            selected_area = areas[0]
+            print(f"\n 3. Testing get_template_files for '{selected_area}' ")
+            files = get_template_files(selected_branch, selected_area)
+            print(f"Files found: {files}")
+
+            if files:
+                # Test with the first available file
+                selected_file = files[1]
+                
+                print(f"\n 4. Testing load_template_functions for '{selected_file}' ")
+                funcs = load_template_functions(selected_branch, selected_area, selected_file)
+                func_names = [f[0] for f in funcs]
+                print(f"Functions found: {func_names}")
+                
+                if funcs:
+                    # Test getting source code for the FIRST function found
+                    first_func_name, first_func_obj = funcs[2]
+                    print(f"\n 5. Testing get_source_code for '{first_func_name}' ")
+                    
+                    code = get_source_code(first_func_obj)
+                    print(f"Source code preview:\n{code}...") 
+                else:
+                    print("\n 5. Skipped (No functions found to extract code from) ")