Deploy EngChain annotator

README.md

@@ -0,0 +1,9 @@
+---
+title: EngChain Annotator
+emoji: 🛡️
+colorFrom: blue
+colorTo: purple
+sdk: streamlit
+python_version: "3.11"
+sdk_version: "1.25.0"
+---

app.py

@@ -0,0 +1,255 @@
+import streamlit as st
+import traceback
+import random
+from src.template_loader import (
+    get_branches, 
+    get_areas, 
+    get_template_files, 
+    load_template_functions, 
+    get_source_code
+)
+from src.storage import save_review
+
+# --- Page Configuration ---
+st.set_page_config(layout="wide", page_title="EngChain Annotator")
+
+# --- 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;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# --- Helper Function: Build the Queue ---
+def build_review_queue(branch):
+    """
+    Scans the entire branch and creates a list of all templates to review.
+    Returns: List of dicts {'branch', 'area', 'file', 'name', 'func'}
+    """
+    queue = []
+    areas = get_areas(branch)
+    
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    total_steps = len(areas)
+    for i, area in enumerate(areas):
+        status_text.text(f"Loading area: {area}...")
+        files = get_template_files(branch, area)
+        for file in files:
+            # Load all functions from this file
+            try:
+                funcs = load_template_functions(branch, area, file)
+                for func_name, func_obj in funcs:
+                    queue.append({
+                        "branch": branch,
+                        "area": area,
+                        "file": file,
+                        "name": func_name,
+                        "func": func_obj
+                    })
+            except Exception as e:
+                print(f"Error loading {file}: {e}")
+        progress_bar.progress((i + 1) / total_steps)
+        
+    status_text.empty()
+    progress_bar.empty()
+    return queue
+
+# --- 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:
+    st.session_state["review_queue"] = []
+if "current_index" not in st.session_state:
+    st.session_state["current_index"] = 0
+if "annotator_name" not in st.session_state:
+    st.session_state["annotator_name"] = ""
+if "current_branch" not in st.session_state:
+    st.session_state["current_branch"] = ""
+if "review_submitted" not in st.session_state:
+    st.session_state["review_submitted"] = False
+
+# ==========================================
+# VIEW 1: LANDING PAGE
+# ==========================================
+if st.session_state["app_mode"] == "landing":
+    st.title("🛡️ EngChain Verification Portal")
+    
+    st.markdown("""
+    ### Welcome, Expert Annotator!
+    Thank you for contributing to **EngChain**. Your task is to verify the correctness and quality 
+    of our symbolic engineering templates.
+    
+    **Instructions:**
+    1. Select your Engineering Domain.
+    2. Enter your Name/ID.
+    3. You will be guided through templates one-by-one.
+    4. For each template, check the **Code** and the **Generated Trace**.
+    5. Rate it, Approve/Reject it, and click **Submit**.
+    """)
+    
+    st.markdown("---")
+    
+    with st.form("onboarding_form"):
+        st.subheader("Annotator Details")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            branches = get_branches()
+            branch_input = st.selectbox("Select Your Domain", branches)
+        
+        with col2:
+            name_input = st.text_input("Enter Your Name / ID")
+            
+        # Button styling: type="primary" gives it emphasis (color depends on theme, usually red/blue)
+        submitted = st.form_submit_button("Start Annotation Session", type="primary")
+        
+        if submitted:
+            if not name_input.strip():
+                st.error("Please enter your name to proceed.")
+            else:
+                st.session_state["annotator_name"] = name_input
+                st.session_state["current_branch"] = branch_input
+                
+                # Build the queue
+                with st.spinner(f"Gathering templates for {branch_input}..."):
+                    queue = build_review_queue(branch_input)
+                
+                st.session_state["review_queue"] = queue
+                st.session_state["current_index"] = 0
+                st.session_state["app_mode"] = "review"
+                st.rerun()
+
+# ==========================================
+# VIEW 2: REVIEW WORKSPACE
+# ==========================================
+elif st.session_state["app_mode"] == "review":
+    
+    queue = st.session_state["review_queue"]
+    idx = st.session_state["current_index"]
+    
+    # Check if we are done
+    if idx >= len(queue):
+        st.session_state["app_mode"] = "done"
+        st.rerun()
+    
+    current_item = queue[idx]
+    
+    # --- 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.subheader("Current Context")
+    
+    # Distinct styling for keys and values
+    st.sidebar.markdown("**📂 Area:**")
+    st.sidebar.info(current_item['area'])
+    
+    st.sidebar.markdown("**📄 File:**")
+    st.sidebar.info(current_item['file'])
+    
+    st.sidebar.markdown("**🧩 Function:**")
+    st.sidebar.info(current_item['name'])
+    
+    # --- 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'])
+        st.code(code_text, language="python", line_numbers=True)
+        
+    with tab2:
+        col_gen, _ = st.columns([1, 4])
+        # Renamed button for clarity
+        if col_gen.button("Generate New Random Instance"):
+            pass # Rerun trigger to get new random numbers
+            
+        try:
+            question, solution = current_item['func']()
+            st.markdown("#### Question")
+            st.info(question)
+            st.markdown("#### Solution Trace")
+            st.success(solution)
+        except Exception as e:
+            st.error("Template Execution Failed")
+            st.code(traceback.format_exc())
+
+    st.markdown("---")
+
+    # --- Scoring Form ---
+    st.subheader("Audit Decision")
+    
+    # Use a container so we can disable the form after submission
+    with st.container():
+        # Check if already submitted for this specific template
+        is_submitted = st.session_state.get("review_submitted", False)
+        
+        if not is_submitted:
+            # FORM STATE
+            with st.form("audit_form"):
+                c1, c2, c3 = st.columns(3)
+                phys = c1.slider("Physical Plausibility", 1, 5, 5)
+                math = c2.slider("Mathematical Correctness", 1, 5, 5)
+                ped = c3.slider("Pedagogical Clarity", 1, 5, 5)
+                
+                decision = st.radio("Certification:", ["Approve", "Reject"], horizontal=True)
+                feedback = st.text_area("Feedback (Required for Rejection)", placeholder="Explain any errors found...")
+                
+                # Removed emoji from button
+                submit_review = st.form_submit_button("Submit Review")
+                
+                if submit_review:
+                    if decision == "Reject" and not feedback.strip():
+                        st.error("Feedback is required for Rejection.")
+                    else:
+                        # Save to disk
+                        save_review(
+                            st.session_state["annotator_name"],
+                            current_item["branch"],
+                            current_item["area"],
+                            current_item["name"],
+                            [phys, math, ped],
+                            decision,
+                            feedback
+                        )
+                        st.success("Review Saved!")
+                        st.session_state["review_submitted"] = True
+                        st.rerun()
+        else:
+            # POST-SUBMISSION STATE (Show Next Button)
+            st.success("Review recorded for this template.")
+            
+            # Removed emoji, kept primary type for visibility
+            if st.button("Proceed to Next Template", type="primary"):
+                st.session_state["current_index"] += 1
+                st.session_state["review_submitted"] = False
+                st.rerun()
+
+# ==========================================
+# VIEW 3: COMPLETION PAGE
+# ==========================================
+elif st.session_state["app_mode"] == "done":
+    # Removed balloons()
+    st.title("Session Complete")
+    
+    st.success(f"""
+    **Thank you, {st.session_state['annotator_name']}!**
+    
+    You have successfully reviewed all **{len(st.session_state['review_queue'])}** templates 
+    in the **{st.session_state['current_branch']}** domain.
+    """)
+    
+    st.info("Your reviews have been saved securely. You may now close this tab.")
+    
+    if st.button("Start New Session"):
+        st.session_state.clear()
+        st.rerun()

data/templates/branches/chemical_engineering/constants.py

@@ -0,0 +1,629 @@
+# Standard: phases referenced at ~25 °C and 1 atm
+
+LIQUID_PHASE_REACTANTS = [
+    "Ethyl Acetate",
+    "Propylene Glycol",
+    "Benzene",
+    "Toluene",
+    "Acetone",
+    "Methanol",
+    "Ethanol",
+    "Isopropanol",     # specify "isopropanol (2-propanol)" if needed
+    "n-Butanol",       # specify isomer as needed
+    "Methyl Ethyl Ketone (MEK) / 2-butanone",
+    # Formaldehyde is typically a gas at 25°C; aqueous solution is "Formalin (37% aqueous)"
+    "Acetic Acid",
+    # Phenol is a solid at 25°C (mp ~40.5°C). Include only if working above that temperature.
+    "Glycerol",
+    "Xylene",
+    "Styrene",
+    "Aniline",
+    "Cyclohexane",
+    "Formic Acid",
+    "Nitric Acid",
+    "Sulfuric Acid",
+    "Ethylene Glycol",
+    "Diethyl Ether",
+    "Tetrahydrofuran (THF)",
+    "Chloroform",
+    "Acrylonitrile",
+    "Dimethylformamide (DMF)",
+    "Methyl Methacrylate",
+    "Acetic anhydride"   # corrected name (a.k.a. ethanoic anhydride)
+]
+
+GAS_PHASE_REACTANTS = [
+    "Methane",
+    "Ethane",
+    "Propane",
+    "Ammonia",
+    "Ethylene",
+    "Sulfur Dioxide",
+    "Hydrogen Sulfide",
+    "Vinyl Chloride",
+    "Butadiene",
+    "Hydrogen",
+    "Oxygen",
+    "Nitrogen",
+    "Chlorine",
+    "Carbon Monoxide",
+    "Carbon Dioxide",
+    "Propylene",
+    "Butane",
+    "Acetylene",
+    "Nitric Oxide (NO)",
+    "Nitrogen Dioxide (NO2)",
+    "Hydrogen Chloride (HCl)",   # gas at 1 atm
+    "Phosgene",
+    "Ethylene Oxide",
+    "Isobutane",
+    "Formaldehyde",     # moved here: gas at 25°C
+    "Acetaldehyde"      # volatile; bp ~20.2°C → effectively gas at 25°C
+]
+
+BIOCHEMICAL_SUBSTRATES = [
+    "Glucose",
+    "Sucrose",
+    "Lactose",
+    "Fructose",
+    "Pyruvate",
+    "Maltose",
+    "Galactose",
+    "Starch",        # polymeric solid
+    "Cellulose",     # polymeric solid
+    "Xylose",
+    "Glutamate",     # often used as salts (e.g., sodium glutamate)
+    "Alanine",
+    "Lactate",       # usually as salt
+    "Citrate",
+    "Acetyl-CoA",    # coenzyme (large, charged)
+    "Palmitic Acid",
+    "Oleic Acid",
+    "Triglycerides",
+    "Urea",
+    "Aspartate"
+]
+
+GENERAL_REACTANTS = LIQUID_PHASE_REACTANTS + GAS_PHASE_REACTANTS + BIOCHEMICAL_SUBSTRATES
+
+
+PRODUCTS = [
+    "Product Alpha",
+    "Product Beta",
+    "Product Gamma",
+    "Product Delta",
+    "Product Sigma",
+    "Product Omega",
+    "Product Theta",
+    "Product Lambda",
+    "Product Zeta",
+    "Product Kappa",
+
+    "Compound P",
+    "Compound Q",
+    "Compound R",
+    "Compound S",
+    "Compound T",
+    "Compound V",
+    "Compound W",
+    "Compound X",
+    "Compound Y",
+    "Compound Z",
+
+    "Species I",
+    "Species II",
+    "Species III",
+    "Species IV",
+    "Species V",
+    "Species VI",
+    "Species VII",
+    "Species VIII",
+
+    "Material A",
+    "Material B",
+    "Material C",
+    "Material D",
+    "Material E",
+    "Material F",
+
+    "Substance One",
+    "Substance Two",
+    "Substance Three",
+    "Substance Four",
+    "Substance Five",
+    "Substance Six",
+
+    "Molecule M",
+    "Molecule N",
+    "Molecule O",
+    "Molecule P",
+    "Molecule Q",
+    "Molecule R",
+
+    "Entity 1",
+    "Entity 2",
+    "Entity 3",
+    "Entity 4",
+    "Entity 5",
+    "Entity 6"
+]
+
+
+# A list of common substances used in thermodynamics problems involving phase change.
+THERMO_SUBSTANCES = [
+    # Classic working fluids
+    "Water",
+    "Ammonia",
+    "Carbon Dioxide",
+    "Sulfur Dioxide",
+
+    # Hydrocarbons (fuels and refrigerants)
+    "Methane",
+    "Ethane",
+    "Propane",
+    "Butane",
+    "Isobutane",
+    "Pentane",
+    "Iso-pentane",
+
+    # Refrigerants (with ASHRAE designations)
+    "Refrigerant-11 (R-11, Trichlorofluoromethane)",
+    "Refrigerant-12 (R-12, Dichlorodifluoromethane)",
+    "Refrigerant-22 (R-22, Chlorodifluoromethane)",
+    "Refrigerant-134a (R-134a, 1,1,1,2-Tetrafluoroethane)",
+    "Refrigerant-123 (R-123, Dichlorotrifluoroethane)",
+    "Refrigerant-410A (R-410A, blend of difluoromethane and pentafluoroethane)",
+
+    # Common industrial/organic fluids used in Rankine/Organic Rankine cycles
+    "Toluene",
+    "Benzene",
+    "Ethanol",
+    "Methanol",
+    "Acetone",
+    "n-Hexane",
+    "n-Octane",
+    "Cyclohexane"
+]
+
+
+# A dictionary with comprehensive critical properties for various substances.
+# Tc: Kelvin (K), Pc: bar, Vc: cm³/mol, Zc: dimensionless, omega: dimensionless.
+CRITICAL_PROPERTIES = {
+    "Methane": {"Tc": 190.6, "Pc": 45.99, "Vc": 99.0, "Zc": 0.286, "omega": 0.012},
+    "Ethane": {"Tc": 305.3, "Pc": 48.72, "Vc": 146.0, "Zc": 0.279, "omega": 0.100},
+    "Propane": {"Tc": 369.8, "Pc": 42.48, "Vc": 200.0, "Zc": 0.276, "omega": 0.152},
+    "n-Butane": {"Tc": 425.1, "Pc": 37.96, "Vc": 255.0, "Zc": 0.274, "omega": 0.200},
+    "n-Pentane": {"Tc": 469.7, "Pc": 33.7, "Vc": 311.0, "Zc": 0.269, "omega": 0.251},
+    "n-Hexane": {"Tc": 507.6, "Pc": 30.12, "Vc": 368.0, "Zc": 0.264, "omega": 0.301},
+    "n-Heptane": {"Tc": 540.2, "Pc": 27.36, "Vc": 426.0, "Zc": 0.263, "omega": 0.350},
+    "n-Octane": {"Tc": 568.8, "Pc": 24.86, "Vc": 492.0, "Zc": 0.259, "omega": 0.400},
+    "Ethylene": {"Tc": 282.4, "Pc": 50.42, "Vc": 131.0, "Zc": 0.281, "omega": 0.087},
+    "Propylene": {"Tc": 365.0, "Pc": 46.0, "Vc": 181.0, "Zc": 0.275, "omega": 0.140},
+    "Benzene": {"Tc": 562.2, "Pc": 48.95, "Vc": 259.0, "Zc": 0.271, "omega": 0.210},
+    "Toluene": {"Tc": 591.8, "Pc": 41.09, "Vc": 316.0, "Zc": 0.264, "omega": 0.263},
+    "p-Xylene": {"Tc": 616.2, "Pc": 35.12, "Vc": 379.0, "Zc": 0.260, "omega": 0.321},
+    "Methanol": {"Tc": 512.6, "Pc": 80.84, "Vc": 118.0, "Zc": 0.224, "omega": 0.564},
+    "Ethanol": {"Tc": 513.9, "Pc": 61.37, "Vc": 167.0, "Zc": 0.248, "omega": 0.645},
+    "Acetone": {"Tc": 508.2, "Pc": 46.99, "Vc": 209.0, "Zc": 0.232, "omega": 0.304},
+    "Water": {"Tc": 647.1, "Pc": 220.64, "Vc": 55.9, "Zc": 0.229, "omega": 0.345},
+    "Ammonia": {"Tc": 405.5, "Pc": 113.53, "Vc": 72.5, "Zc": 0.242, "omega": 0.250},
+    "Carbon dioxide": {"Tc": 304.2, "Pc": 73.83, "Vc": 94.0, "Zc": 0.274, "omega": 0.224},
+    "Carbon monoxide": {"Tc": 132.9, "Pc": 34.99, "Vc": 93.1, "Zc": 0.295, "omega": 0.045},
+    "Oxygen": {"Tc": 154.6, "Pc": 50.43, "Vc": 73.4, "Zc": 0.288, "omega": 0.022},
+    "Nitrogen": {"Tc": 126.2, "Pc": 33.98, "Vc": 89.8, "Zc": 0.290, "omega": 0.039},
+    "Hydrogen": {"Tc": 33.2, "Pc": 12.97, "Vc": 65.0, "Zc": 0.305, "omega": -0.216},
+    "Helium": {"Tc": 5.2, "Pc": 2.27, "Vc": 57.8, "Zc": 0.301, "omega": -0.365},
+    "Chlorine": {"Tc": 417.0, "Pc": 77.02, "Vc": 124.0, "Zc": 0.275, "omega": 0.090},
+    "Sulfur dioxide": {"Tc": 430.8, "Pc": 78.84, "Vc": 122.0, "Zc": 0.269, "omega": 0.245},
+    "Hydrogen sulfide": {"Tc": 373.5, "Pc": 89.63, "Vc": 98.6, "Zc": 0.284, "omega": 0.091}
+}
+
+
+# Common materials which undergo heating with their specific heat capacities in J/g·K
+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}
+]
+
+
+# A list of common substances with their molar heats of vaporization (delta_H_vap)
+# at their normal boiling points. All values are in kJ/mol.
+SUBSTANCES_FOR_VAPORIZATION = [
+    # Alcohols & Water
+    {"name": "Water", "delta_H_vap": 40.66},
+    {"name": "Methanol", "delta_H_vap": 35.3},
+    {"name": "Ethanol", "delta_H_vap": 38.6},
+    {"name": "Isopropanol", "delta_H_vap": 39.85},
+
+    # Alkanes
+    {"name": "Propane", "delta_H_vap": 19.04},
+    {"name": "n-Butane", "delta_H_vap": 22.44},
+    {"name": "n-Hexane", "delta_H_vap": 28.85},
+
+    # Organic Solvents
+    {"name": "Acetone", "delta_H_vap": 29.1},
+    {"name": "Benzene", "delta_H_vap": 30.8},
+    {"name": "Toluene", "delta_H_vap": 33.48},
+    {"name": "Carbon Tetrachloride", "delta_H_vap": 29.82},
+
+    # Inorganic & Elemental Substances
+    {"name": "Ammonia", "delta_H_vap": 23.3},
+    {"name": "Mercury", "delta_H_vap": 59.11},
+    {"name": "Nitrogen", "delta_H_vap": 5.57},
+    {"name": "Oxygen", "delta_H_vap": 6.82},
+    {"name": "Argon", "delta_H_vap": 6.43},
+]
+
+
+# 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
+    "CH4(g)": -74.8,      # Methane
+    "C2H6(g)": -84.7,     # Ethane
+    "C3H8(g)": -103.8,    # Propane
+    "C6H6(l)": 49.0,      # Benzene
+    # Alcohols
+    "CH3OH(l)": -238.6,   # Methanol
+    "C2H5OH(l)": -277.7,  # Ethanol
+    # Common Gases & Products
+    "O2(g)": 0,
+    "H2(g)": 0,
+    "N2(g)": 0,
+    "CO(g)": -110.5,
+    "CO2(g)": -393.5,
+    "H2O(g)": -241.8,
+    "H2O(l)": -285.8,
+    "NH3(g)": -46.1,      # Ammonia
+    "NO(g)": 90.3,
+    "NO2(g)": 33.2,
+}
+
+# A list of predefined, balanced chemical reactions.
+REACTIONS = [
+    {
+        "name": "Combustion of Methane",
+        "equation": "CH4(g) + 2O2(g) → CO2(g) + 2H2O(l)",
+        "reactants": {"CH4(g)": 1, "O2(g)": 2},
+        "products": {"CO2(g)": 1, "H2O(l)": 2}
+    },
+    {
+        "name": "Combustion of Propane",
+        "equation": "C3H8(g) + 5O2(g) → 3CO2(g) + 4H2O(l)",
+        "reactants": {"C3H8(g)": 1, "O2(g)": 5},
+        "products": {"CO2(g)": 3, "H2O(l)": 4}
+    },
+    {
+        "name": "Oxidation of Ammonia",
+        "equation": "4NH3(g) + 5O2(g) → 4NO(g) + 6H2O(g)",
+        "reactants": {"NH3(g)": 4, "O2(g)": 5},
+        "products": {"NO(g)": 4, "H2O(g)": 6}
+    },
+    {
+        "name": "Steam Reforming of Methane",
+        "equation": "CH4(g) + H2O(g) → CO(g) + 3H2(g)",
+        "reactants": {"CH4(g)": 1, "H2O(g)": 1},
+        "products": {"CO(g)": 1, "H2(g)": 3}
+    }
+]
+
+
+# A dictionary of substances with their heat capacity parameters for the
+# equation: Cp/R = A + B*T + C*T² + D*T⁻² where T is in Kelvin.
+# Parameters are typically valid for temperature ranges around 298-1200K
+CP_PARAMS = {
+    # Original entries
+    "CH4(g)": {"A": 1.702, "B": 9.081E-2, "C": -2.164E-5, "D": 0},
+    "CO2(g)": {"A": 5.457, "B": 1.045E-2, "C": 0, "D": -1.157E5},
+    "N2(g)": {"A": 3.280, "B": 0.593E-2, "C": 0, "D": 0.040E5},
+    "H2O(l)": {"A": 8.712, "B": 1.25E-2, "C": -0.18E-5, "D": 0},
+    "C2H5OH(g)": {"A": 3.518, "B": 20.001E-2, "C": -6.002E-5, "D": 0},
+    
+    # Common gases
+    "O2(g)": {"A": 3.630, "B": 1.794E-2, "C": -0.658E-5, "D": 0.061E5},
+    "H2(g)": {"A": 3.249, "B": 0.422E-2, "C": 0, "D": 0.083E5},
+    "NH3(g)": {"A": 3.578, "B": 3.020E-2, "C": 0, "D": -0.186E5},
+    "CO(g)": {"A": 3.376, "B": 0.557E-2, "C": 0, "D": -0.031E5},
+    "H2S(g)": {"A": 3.931, "B": 1.490E-2, "C": 0, "D": -0.232E5},
+    
+    # Hydrocarbons
+    "C2H6(g)": {"A": 1.131, "B": 19.225E-2, "C": -5.561E-5, "D": 0},
+    "C3H8(g)": {"A": 1.213, "B": 28.785E-2, "C": -8.824E-5, "D": 0},
+    "C4H10(g)": {"A": 1.935, "B": 36.915E-2, "C": -11.402E-5, "D": 0},
+    "C2H4(g)": {"A": 1.424, "B": 14.394E-2, "C": -4.392E-5, "D": 0},
+    "C2H2(g)": {"A": 6.132, "B": 8.914E-2, "C": -6.347E-5, "D": 0},
+    
+    # Common liquids
+    "C6H6(l)": {"A": -0.206, "B": 39.064E-2, "C": -13.301E-5, "D": 0},
+    "C7H8(l)": {"A": 0.290, "B": 47.052E-2, "C": -15.716E-5, "D": 0},
+    "C3H6O(l)": {"A": 1.506, "B": 30.476E-2, "C": -9.127E-5, "D": 0},
+    "CH3OH(l)": {"A": 5.052, "B": 16.561E-2, "C": -3.761E-5, "D": 0},
+    "C6H14(l)": {"A": 2.738, "B": 45.854E-2, "C": -14.518E-5, "D": 0},
+    
+    # Inorganic compounds
+    "SO2(g)": {"A": 5.699, "B": 0.801E-2, "C": 0, "D": -1.015E5},
+    "NO(g)": {"A": 3.387, "B": 0.669E-2, "C": 0, "D": 0.095E5},
+    "NO2(g)": {"A": 4.982, "B": 1.195E-2, "C": -0.792E-5, "D": -0.377E5},
+    "Cl2(g)": {"A": 4.442, "B": 0.089E-2, "C": 0, "D": -0.344E5},
+    "HCl(g)": {"A": 3.156, "B": 0.623E-2, "C": 0, "D": 0.151E5},
+    
+    # Noble gases
+    "He(g)": {"A": 2.500, "B": 0, "C": 0, "D": 0},
+    "Ar(g)": {"A": 2.500, "B": 0, "C": 0, "D": 0},
+    "Ne(g)": {"A": 2.500, "B": 0, "C": 0, "D": 0},
+    
+    # Additional common substances
+    "Air(g)": {"A": 3.355, "B": 0.575E-2, "C": 0, "D": -0.016E5},
+    "H2O(g)": {"A": 3.470, "B": 1.450E-2, "C": 0, "D": 0.121E5},
+    "H2SO4(l)": {"A": 2.850, "B": 13.400E-2, "C": 0, "D": 0},
+    "NaCl(s)": {"A": 5.526, "B": 1.963E-2, "C": 0, "D": -0.333E5},
+    "CaCO3(s)": {"A": 12.572, "B": 2.637E-2, "C": -3.120E-5, "D": -3.642E5}
+}
+
+
+# A list of predefined, balanced combustion reactions with theoretical air.
+COMBUSTION_REACTIONS = [
+    {
+        "name": "Combustion of Methane",
+        "fuel": "Methane",
+        "equation": "CH4(g) + 2O2(g) + 7.52N2(g) → CO2(g) + 2H2O(g) + 7.52N2(g)",
+        "reactants": {"CH4(g)": 1, "O2(g)": 2, "N2(g)": 7.52},
+        "products": {"CO2(g)": 1, "H2O(g)": 2, "N2(g)": 7.52}
+    },
+    {
+        "name": "Combustion of Propane",
+        "fuel": "Propane",
+        "equation": "C3H8(g) + 5O2(g) + 18.8N2(g) → 3CO2(g) + 4H2O(g) + 18.8N2(g)",
+        "reactants": {"C3H8(g)": 1, "O2(g)": 5, "N2(g)": 18.8},
+        "products": {"CO2(g)": 3, "H2O(g)": 4, "N2(g)": 18.8}
+    },
+    {
+        "name": "Combustion of Hydrogen",
+        "fuel": "Hydrogen",
+        "equation": "H2(g) + 0.5O2(g) + 1.88N2(g) → H2O(g) + 1.88N2(g)",
+        "reactants": {"H2(g)": 1, "O2(g)": 0.5, "N2(g)": 1.88},
+        "products": {"H2O(g)": 1, "N2(g)": 1.88}
+    },
+    {
+        "name": "Combustion of Carbon Monoxide",
+        "fuel": "Carbon Monoxide",
+        "equation": "CO(g) + 0.5O2(g) + 1.88N2(g) → CO2(g) + 1.88N2(g)",
+        "reactants": {"CO(g)": 1, "O2(g)": 0.5, "N2(g)": 1.88},
+        "products": {"CO2(g)": 1, "N2(g)": 1.88}
+    },
+    {
+        "name": "Combustion of Acetylene",
+        "fuel": "Acetylene",
+        "equation": "C2H2(g) + 2.5O2(g) + 9.4N2(g) → 2CO2(g) + H2O(g) + 9.4N2(g)",
+        "reactants": {"C2H2(g)": 1, "O2(g)": 2.5, "N2(g)": 9.4},
+        "products": {"CO2(g)": 2, "H2O(g)": 1, "N2(g)": 9.4}
+    },
+    {
+        "name": "Combustion of Ethane",
+        "fuel": "Ethane",
+        "equation": "C2H6(g) + 3.5O2(g) + 13.16N2(g) → 2CO2(g) + 3H2O(g) + 13.16N2(g)",
+        "reactants": {"C2H6(g)": 1, "O2(g)": 3.5, "N2(g)": 13.16},
+        "products": {"CO2(g)": 2, "H2O(g)": 3, "N2(g)": 13.16}
+    },
+    {
+        "name": "Combustion of Butane",
+        "fuel": "Butane",
+        "equation": "C4H10(g) + 6.5O2(g) + 24.44N2(g) → 4CO2(g) + 5H2O(g) + 24.44N2(g)",
+        "reactants": {"C4H10(g)": 1, "O2(g)": 6.5, "N2(g)": 24.44},
+        "products": {"CO2(g)": 4, "H2O(g)": 5, "N2(g)": 24.44}
+    },
+    {
+        "name": "Combustion of Octane",
+        "fuel": "Octane",
+        "equation": "C8H18(g) + 12.5O2(g) + 47.0N2(g) → 8CO2(g) + 9H2O(g) + 47.0N2(g)",
+        "reactants": {"C8H18(g)": 1, "O2(g)": 12.5, "N2(g)": 47.0},
+        "products": {"CO2(g)": 8, "H2O(g)": 9, "N2(g)": 47.0}
+    },
+    {
+        "name": "Combustion of Ammonia",
+        "fuel": "Ammonia", 
+        "equation": "4NH3(g) + 3O2(g) + 11.28N2(g) → 2N2(g) + 6H2O(g) + 11.28N2(g)",
+        "reactants": {"NH3(g)": 4, "O2(g)": 3, "N2(g)": 11.28},
+        "products": {"N2(g)": 13.28, "H2O(g)": 6}  # Total N2 = 2 + 11.28
+    },
+    {
+        "name": "Combustion of Methanol",
+        "fuel": "Methanol",
+        "equation": "CH3OH(g) + 1.5O2(g) + 5.64N2(g) → CO2(g) + 2H2O(g) + 5.64N2(g)",
+        "reactants": {"CH3OH(g)": 1, "O2(g)": 1.5, "N2(g)": 5.64},
+        "products": {"CO2(g)": 1, "H2O(g)": 2, "N2(g)": 5.64}
+    },
+    {
+        "name": "Combustion of Ethanol",
+        "fuel": "Ethanol",
+        "equation": "C2H5OH(g) + 3O2(g) + 11.28N2(g) → 2CO2(g) + 3H2O(g) + 11.28N2(g)",
+        "reactants": {"C2H5OH(g)": 1, "O2(g)": 3, "N2(g)": 11.28},
+        "products": {"CO2(g)": 2, "H2O(g)": 3, "N2(g)": 11.28}
+    }
+]
+
+
+# Properties are given at 20°C (293.15 K) and standard pressure (101.325 kPa) unless otherwise noted.
+# Viscosity can vary between sources. Values chosen for typical textbook accuracy.
+# Format: { "Name": (Density [kg/m³], Dynamic Viscosity [Pa·s]) }
+COMMON_LIQUIDS = {
+    # Water and Common Solvents
+    "Water": (998.2, 1.002e-3),
+    "Seawater (3.5% salinity)": (1025, 1.07e-3), # Viscosity approx. 7% higher than pure water
+    "Ethanol": (789.4, 1.074e-3),
+    "Methanol": (791.3, 0.544e-3),
+    "Isopropyl Alcohol (IPA)": (781.8, 2.04e-3),
+    "Acetone": (784.5, 0.306e-3),
+    "Benzene": (876.5, 0.601e-3),
+    "Toluene": (866.9, 0.560e-3),
+    "Diethyl Ether": (713.4, 0.223e-3),
+    "n-Hexane": (654.8, 0.294e-3),
+    
+    # Oils and Hydrocarbons
+    "Engine Oil (SAE 10W)": (870, 0.065),
+    "Engine Oil (SAE 30)": (891.0, 0.290), 
+    "Engine Oil (SAE 50)": (902, 0.860),
+    "Gear Oil (SAE 90)": (915, 0.700),
+    "Crude Oil (light)": (850, 7.5e-3),
+    "Kerosene": (810, 1.6e-3),
+    "Diesel Fuel": (850, 3.5e-3),
+    "Gasoline": (745, 0.29e-3), # ~0.4-0.8 cP, often approximated to water's order of magnitude
+    
+    # Organic & Food Grade Liquids
+    "Glycerol (100%)": (1261.3, 1.490),
+    "Olive Oil": (910, 0.081),
+    "Corn Syrup": (1380, 5.0),     # Highly variable with concentration and temp
+    "Honey": (1420, 10.0),         # Highly variable with type and temp
+    "Milk (whole)": (1035, 2.0e-3),
+    "Blood Plasma (human)": (1025, 1.5e-3),
+    "Blood (whole, human)": (1060, 4.0e-3), # Shear-thinning, this is an approx. value
+    
+    # Cryogens & Liquefied Gases (at their boiling point @ 1 atm)
+    "Liquid Nitrogen (77 K)": (804, 0.158e-3),   # Note: Temperature is 77 K (-196°C)
+    "Liquid Oxygen (90 K)": (1141, 0.189e-3),    # Temperature is 90 K (-183°C)
+    
+    # Metals and Inorganics
+    "Mercury": (13593, 1.526e-3),  
+    "Sulfuric Acid (98%)": (1831, 25.4e-3),
+    "Ethylene Glycol": (1113.4, 16.1e-3), # Common antifreeze
+}
+
+
+# Properties are given at 20°C (293.15 K) and 1 atm (101.325 kPa) unless otherwise noted.
+# Format: { "Name": (Density [kg/m³], Dynamic Viscosity [Pa·s]) }
+COMMON_GASES = {
+    # Common Gases
+    "Air": (1.204, 1.81e-5),
+    "Nitrogen (N₂)": (1.165, 1.76e-5),
+    "Oxygen (O₂)": (1.331, 2.00e-5),
+    "Carbon Dioxide (CO₂)": (1.842, 1.47e-5), # Viscosity is temperature-dependent and increases for CO2
+    "Argon": (1.661, 2.23e-5),
+    "Helium": (0.166, 1.96e-5),
+    "Neon": (0.840, 3.18e-5),
+    "Krypton": (3.479, 2.55e-5),
+    "Xenon": (5.495, 2.28e-5), # Density high, but viscosity is similar to air
+    
+    # Hydrocarbons
+    "Methane (CH₄)": (0.668, 1.09e-5),
+    "Ethane (C₂H₆)": (1.264, 9.15e-6),
+    "Propane (C₃H₈)": (1.880, 8.00e-6), # Note: Viscosity decreases slightly with molecular weight in this series
+    "Butane (C₄H₁₀)": (2.489, 7.50e-6),
+    "Natural Gas (approx.)": (0.700, 1.10e-5), # Modeled after methane
+    "Acetylene (C₂H₂)": (1.092, 9.80e-6),
+    
+    # Other Common Gases
+    "Hydrogen (H₂)": (0.0838, 8.90e-6), # Lowest density, very low viscosity
+    "Steam (Water Vapor)": (0.747, 1.02e-5), # At 100°C (373 K), 1 atm
+    "Ammonia (NH₃)": (0.718, 1.01e-5),
+    "Chlorine (Cl₂)": (2.994, 1.33e-5),
+    "Sulfur Hexafluoride (SF₆)": (6.17, 1.59e-5), # High-density gas used in industry
+    
+    # Noble Gases
+    "Radon": (9.23, 2.30e-5), # Theoretical value at 20°C; highly radioactive
+}
+
+
+# Molecular parameters for the Chapman-Enskog equation (Kinetic Theory)
+# Sources: NIST, CRC Handbook, and standard chemical engineering texts.
+# Format: { "Name": (Molar Mass [g/mol], Sigma σ [Å], Epsilon ε / k [K]) }
+# Note: Epsilon ε / k (the Lennard-Jones energy parameter) is included for calculating the collision integral.
+GAS_MOLECULAR_PARAMS = {
+    "Air": (28.97, 3.62, 97.0),
+    "Nitrogen (N₂)": (28.01, 3.70, 95.05),
+    "Oxygen (O₂)": (32.00, 3.46, 106.7),
+    "Carbon Dioxide (CO₂)": (44.01, 3.94, 195.2),
+    "Argon": (39.95, 3.54, 93.3),
+    "Helium": (4.003, 2.55, 10.22),
+    "Neon": (20.18, 2.92, 32.8),
+    "Krypton": (83.80, 3.69, 178.9),
+    "Xenon": (131.29, 4.10, 231.0),
+    "Methane (CH₄)": (16.04, 3.78, 148.6),
+    "Ethane (C₂H₆)": (30.07, 4.42, 215.7),
+    "Propane (C₃H₈)": (44.10, 5.06, 237.1),
+    "Butane (C₄H₁₀)": (58.12, 5.47, 531.4), # n-butane
+    "Hydrogen (H₂)": (2.016, 2.93, 33.3),
+    "Ammonia (NH₃)": (17.03, 2.92, 558.3), # Polar molecule, value is an effective fit.
+    "Chlorine (Cl₂)": (70.90, 4.40, 316.0),
+    "Sulfur Hexafluoride (SF₆)": (146.06, 5.51, 222.1),
+}
+
+
+# Properties for non-Newtonian power-law fluids
+# Format: { "Name": (Consistency Index K [Pa·s^n], Power-Law Index n [dimensionless]) }
+POWER_LAW_FLUIDS = {
+    # Common Household & Food (Shear-Thinning)
+    "Ketchup": (32.5, 0.22),
+    "Applesauce": (15.0, 0.3),
+    "Mustard": (50.0, 0.28),
+    "Mayonnaise": (85.0, 0.6),
+    "Tomato Puree": (25.0, 0.5),
+    "Yogurt": (12.5, 0.6),
+    "Toothpaste": (120.0, 0.4),
+    "Shampoo": (25.0, 0.6),
+    "Hand Lotion": (80.0, 0.5),
+
+    # Paints & Inks (Shear-Thinning)
+    "Latex Paint": (45.0, 0.45),
+    "Printing Ink": (10.0, 0.7),
+
+    # Biological Fluids (Mostly Shear-Thinning)
+    "Blood (Plasma)": (0.012, 0.95), # Very low K, nearly Newtonian
+    "Mucus": (10.0, 0.5),
+
+    # Polymer Solutions & Melts (Shear-Thinning)
+    "0.5% Carboxymethylcellulose (CMC) in Water": (1.5, 0.6),
+    "1.5% Polyacrylamide in Water": (5.0, 0.3),
+    "Molten Polyethylene": (5000.0, 0.6), # K is very temperature-dependent
+
+    # Newtonian Baseline (n = 1)
+    "Water": (0.001, 1.0),           # K is the dynamic viscosity
+    "Glycerol": (1.0, 1.0),
+    "Air": (1.8e-5, 1.0),            # K is the dynamic viscosity
+
+    # Shear-Thickening (Dilatant)
+    "Corn Starch Suspension (40%)": (2.0, 1.9),
+    "Corn Starch Suspension (50%)": (10.0, 2.5), # Higher concentration -> stronger effect
+    "Silica Sand Suspension (60%)": (0.5, 1.6),
+}
+
+
+# Standard gravitational acceleration in m/s²
+GRAVITATIONAL_ACCELERATION = 9.81

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

@@ -0,0 +1,311 @@
+import random
+import numpy as np
+from data.templates.branches.chemical_engineering.constants import GENERAL_REACTANTS
+
+
+# Template 1 (Advanced)
+def template_levenspiel_plot_interpretation():
+    """
+    Levenspiel Plot Data Interpretation for Reactor Volume Calculation
+
+    Scenario:
+        Experimental data of 1/(-r_A) vs. conversion (X) is provided in tabulated form.
+        The goal is to determine the reactor volumes required to achieve a target
+        conversion without explicitly knowing the rate law. Two cases are considered:
+
+            - Continuous Stirred-Tank Reactor (CSTR):
+            Volume is calculated using the rectangular approximation:
+            V_CSTR = F_A0 * X * [1/(-r_A)]_exit
+
+            - Plug Flow Reactor (PFR):
+            Volume is calculated using trapezoidal integration of the curve:
+            V_PFR = F_A0 * ∫₀ˣ (1/(-r_A)) dX
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute both CSTR and PFR volumes from tabulated data.
+            - str: A step-by-step solution showing the calculations, including trapezoidal rule details.
+    """
+    
+    # 1. Generate variable parameters with validation
+    reactant_name = random.choice(GENERAL_REACTANTS)
+    F_A0 = round(random.uniform(1.0, 5.0), 2)  # mol/s
+    
+    # Ensure F_A0 is positive
+    if F_A0 <= 0:
+        F_A0 = 2.0  # Default fallback
+    
+    # Variable target conversion instead of fixed 0.8
+    target_conversion_options = [0.5, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9]
+    target_conversion = random.choice(target_conversion_options)
+    
+    # 2. Generate conversion points dynamically based on target conversion
+    if target_conversion <= 0.6:
+        num_points = 7
+    elif target_conversion <= 0.8:
+        num_points = 9
+    else:
+        num_points = 10  # More points for higher conversions
+    
+    X_values = np.linspace(0.0, target_conversion, num_points)
+    X_values = np.round(X_values, 2)  # Clean up floating point artifacts
+    
+    # 3. Generate realistic 1/(-r_A) values with proper validation
+    # Base pattern that increases with conversion (typical behavior)
+    base_pattern = 1.5 + 2.0 * X_values + 3.0 * X_values**2
+    
+    # Add controlled randomness
+    random_factor = random.uniform(0.8, 1.4)
+    noise = 1 + 0.15 * np.random.uniform(-1, 1, num_points)
+    
+    # Ensure noise doesn't make values negative or too small
+    noise = np.maximum(noise, 0.5)
+    
+    inv_rate_values = base_pattern * random_factor * noise
+    inv_rate_values = np.round(inv_rate_values, 2)
+    
+    # 4. Data validation and correction
+    # Ensure first value is reasonable (at X=0)
+    if inv_rate_values[0] < 1.0:
+        inv_rate_values[0] = round(random.uniform(1.0, 2.5), 2)
+    
+    # Ensure all values are positive
+    inv_rate_values = np.maximum(inv_rate_values, 0.5)
+    
+    # Enforce general increasing trend (physical expectation)
+    for i in range(1, len(inv_rate_values)):
+        if inv_rate_values[i] < inv_rate_values[i-1]:
+            inv_rate_values[i] = inv_rate_values[i-1] + round(random.uniform(0.1, 0.3), 2)
+    
+    # Final validation - ensure no extremely large values
+    inv_rate_values = np.minimum(inv_rate_values, 50.0)
+    
+    # 5. Calculate CSTR volume with error checking
+    try:
+        inv_rate_at_final = inv_rate_values[-1]  # 1/(-r_A) at final X
+        X_final = X_values[-1]
+        
+        if inv_rate_at_final <= 0:
+            inv_rate_at_final = 5.0  # Fallback value
+        
+        V_CSTR = F_A0 * inv_rate_at_final * X_final
+        
+        # Ensure positive volume
+        if V_CSTR <= 0:
+            V_CSTR = F_A0 * 5.0 * X_final  # Fallback calculation
+            
+    except Exception:
+        # Fallback CSTR calculation
+        V_CSTR = F_A0 * 8.0 * target_conversion
+    
+    # 6. Calculate PFR volume with error checking
+    try:
+        # Validate data before integration
+        if len(X_values) != len(inv_rate_values):
+            raise ValueError("Data arrays have mismatched lengths")
+        
+        if np.any(inv_rate_values <= 0):
+            raise ValueError("Negative or zero rate values detected")
+        
+        # Check for monotonic X values
+        if not np.all(np.diff(X_values) >= 0):
+            raise ValueError("X values not monotonically increasing")
+        
+        area_under_curve = np.trapezoid(inv_rate_values, X_values)
+        
+        if area_under_curve <= 0:
+            raise ValueError("Negative area under curve")
+        
+        V_PFR = F_A0 * area_under_curve
+        
+        # Sanity check on PFR volume
+        if V_PFR <= 0 or V_PFR > 10 * V_CSTR:
+            raise ValueError("PFR volume unrealistic")
+            
+    except Exception:
+        # Fallback PFR calculation using simple approximation
+        avg_inv_rate = np.mean(inv_rate_values) if len(inv_rate_values) > 0 else 5.0
+        V_PFR = F_A0 * avg_inv_rate * target_conversion * 0.7  # Approximate PFR advantage
+    
+    # 7. Final physical validation
+    if V_CSTR <= 0:
+        V_CSTR = abs(V_CSTR) + 1.0
+    if V_PFR <= 0:
+        V_PFR = abs(V_PFR) + 1.0
+    
+    # Ensure PFR is typically more efficient (but allow exceptions)
+    if V_PFR > 1.5 * V_CSTR:
+        # Unusual case - might indicate data issues, but proceed with warning
+        unusual_case = True
+    else:
+        unusual_case = False
+    
+    # 8. Create data table for display
+    data_table = "X\t1/(-r_A) [L·s/mol]\n"
+    data_table += "-" * 25 + "\n"
+    for x, inv_r in zip(X_values, inv_rate_values):
+        data_table += f"{x:.2f}\t{inv_r:.2f}\n"
+    
+    # 9. Generate question 
+    question = (
+        f"A reaction involving {reactant_name} (A → products) is being studied for reactor design. "
+        f"Experimental data has been collected and plotted as a Levenspiel plot (1/(-r_A) vs X). "
+        f"The inlet molar flow rate is {F_A0} mol/s. Using the data below, calculate:\n\n"
+        f"a) The volume of a CSTR required to achieve {target_conversion*100:.0f}% conversion\n"
+        f"b) The volume of a PFR required to achieve {target_conversion*100:.0f}% conversion\n\n"
+        f"Levenspiel Plot Data:\n"
+        f"{data_table}"
+    )
+    
+    # 10. Generate solution 
+    solution = (
+        f"**Given:**\n"
+        f"- Reactant: {reactant_name}\n"
+        f"- Inlet molar flow rate: F_A0 = {F_A0} mol/s\n"
+        f"- Target conversion: X = {target_conversion} ({target_conversion*100:.0f}%)\n"
+        f"- Data points: {len(X_values)} experimental values\n\n"
+        
+        f"**Part (a): CSTR Volume Calculation**\n\n"
+        f"**Step 1:** For a CSTR, the design equation is:\n"
+        f"V_CSTR = F_A0 × X × [1/(-r_A)]_exit\n\n"
+        
+        f"**Step 2:** From the data table, at X = {target_conversion}:\n"
+        f"[1/(-r_A)]_at_X={target_conversion} = {inv_rate_at_final:.2f} L·s/mol\n\n"
+        
+        f"**Step 3:** Calculate CSTR volume:\n"
+        f"V_CSTR = {F_A0} mol/s × {target_conversion} × {inv_rate_at_final:.2f} L·s/mol\n"
+        f"V_CSTR = {round(V_CSTR, 2)} L\n\n"
+        
+        f"**Part (b): PFR Volume Calculation**\n\n"
+        f"**Step 1:** For a PFR, the design equation is:\n"
+        f"V_PFR = F_A0 × ∫[0 to X] (1/(-r_A)) dX\n\n"
+        
+        f"**Step 2:** The integral represents the area under the Levenspiel plot curve.\n"
+        f"Using trapezoidal rule for numerical integration:\n\n"
+        
+        f"**Step 3:** Apply trapezoidal rule to the data points:\n"
+        f"Area = Σ[(X_i+1 - X_i) × (y_i + y_i+1)/2]\n"
+        f"where y_i = [1/(-r_A)]_i\n\n"
+        
+        f"**Step 4:** Calculate individual trapezoid areas:\n"
+    )
+    
+    # Add detailed trapezoidal calculation with error handling
+    total_area = 0
+    try:
+        for i in range(len(X_values)-1):
+            dx = X_values[i+1] - X_values[i]
+            avg_height = (inv_rate_values[i] + inv_rate_values[i+1]) / 2
+            trap_area = dx * avg_height
+            
+            # Validate each trapezoid calculation
+            if dx <= 0 or avg_height <= 0:
+                continue  # Skip invalid intervals
+            
+            total_area += trap_area
+            
+            solution += (
+                f"Interval [{X_values[i]:.2f} to {X_values[i+1]:.2f}]: "
+                f"ΔX = {dx:.2f}, Avg height = ({inv_rate_values[i]:.2f} + {inv_rate_values[i+1]:.2f})/2 = {avg_height:.2f}\n"
+                f"Area = {dx:.2f} × {avg_height:.2f} = {trap_area:.3f}\n"
+            )
+    except Exception:
+        # Fallback area calculation
+        total_area = area_under_curve if 'area_under_curve' in locals() else np.mean(inv_rate_values) * target_conversion
+    
+    solution += (
+        f"\n**Step 5:** Total area under curve:\n"
+        f"Total area = {total_area:.3f}\n\n"
+        
+        f"**Step 6:** Calculate PFR volume:\n"
+        f"V_PFR = F_A0 × Area = {F_A0} mol/s × {total_area:.3f}\n"
+        f"V_PFR = {round(V_PFR, 2)} L\n\n"
+        
+        f"**Final Answers:**\n"
+        f"a) CSTR Volume = {round(V_CSTR, 2)} L\n"
+        f"b) PFR Volume = {round(V_PFR, 2)} L\n\n"
+    )
+    
+    # Add appropriate comparison note based on results
+    if unusual_case:
+        comparison_note = (
+            f"**Note:** In this case, the PFR volume ({round(V_PFR, 2)} L) is unusually large compared to "
+            f"the CSTR volume ({round(V_CSTR, 2)} L). This could indicate very flat kinetics or "
+            f"experimental measurement uncertainty."
+        )
+    elif V_PFR < V_CSTR:
+        efficiency = ((V_CSTR - V_PFR) / V_CSTR) * 100
+        comparison_note = (
+            f"**Note:** The PFR requires less volume than the CSTR ({round(V_PFR, 2)} L vs {round(V_CSTR, 2)} L), "
+            f"providing a {efficiency:.1f}% volume reduction due to more efficient use of reaction kinetics."
+        )
+    else:
+        comparison_note = (
+            f"**Note:** The reactor volumes are similar ({round(V_CSTR, 2)} L vs {round(V_PFR, 2)} L), "
+            f"suggesting relatively flat kinetics over this conversion range."
+        )
+    
+    solution += comparison_note
+    
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of the Levenspiel plot template with different random seeds
+    and write the results to a JSONL file.
+    """
+
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/chemical_engineering/reaction_kinetics/conversion_and_reactor_sizing.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    
+    # List of template functions with their ID and level
+    templates = [
+        (template_levenspiel_plot_interpretation, "levenspiel_plot_interpretation", "Advanced")
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template in the list
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for reproducibility
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the question and solution by calling the function
+            question, solution = template_func()
+
+            # Create a dictionary entry for the problem
+            problem_entry = {
+                "seed": seed,
+                "branch": "chemical_engineering",
+                "domain": "reaction_kinetics",
+                "area": "conversion_and_reactor_sizing",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add the new problem to our list
+            all_problems.append(problem_entry)
+
+    # Write all generated problems to a .jsonl file (JSON Lines format)
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"\nSuccess! Generated {len(all_problems)} problems and saved them to '{output_file}'")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,431 @@
+import random
+import math
+from scipy.integrate import quad
+from data.templates.branches.chemical_engineering.constants import LIQUID_PHASE_REACTANTS, GENERAL_REACTANTS
+
+
+# Template 1 (Easy)
+def template_cstr_volume_basic():
+    """
+    CSTR Volume Calculation
+
+    Scenario:
+        The General Mole Balance for a Continuous Stirred-Tank Reactor (CSTR) at steady
+        state is used to determine the necessary reactor volume to achieve a desired
+        outcome. Given the inlet and outlet molar flow rates and the reaction rate,
+        the goal is to compute the volume using:
+
+            V = (F_A0 - F_A) / (-r_A)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the CSTR volume.
+            - str: A step-by-step solution showing the calculation (the Python trace).
+    """
+    # 1. Parameterize the inputs with random values
+    reactant_name = random.choice(GENERAL_REACTANTS)
+    # Inlet molar flow rate in mol/s
+    F_A0 = round(random.uniform(1.0, 5.0), 2)
+    # Outlet molar flow rate in mol/s (must be less than inlet)
+    F_A = round(random.uniform(0.1, F_A0 - 0.1), 2)
+    # Reaction rate in mol/(L·s) - a positive value for -r_A
+    neg_r_A = round(random.uniform(0.01, 0.05), 4)
+
+    # 2. Perform the core calculation
+    volume = (F_A0 - F_A) / neg_r_A
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A steady-state CSTR is used for the consumption of {reactant_name}. "
+        f"The inlet molar flow rate of {reactant_name} is {F_A0} mol/s, and the desired "
+        f"outlet molar flow rate is {F_A} mol/s. If the rate of reaction is {neg_r_A} mol/(L·s), "
+        f"what is the required reactor volume in liters?"
+    )
+
+    solution = (
+        f"**Step 1:** State the CSTR design equation.\n"
+        f"    V = (F_A0 - F_A) / (-r_A)\n\n"
+        f"**Step 2:** Substitute the given values into the equation.\n"
+        f"    V = ({F_A0} mol/s - {F_A} mol/s) / ({neg_r_A} mol/(L·s))\n\n"
+        f"**Step 3:** Calculate the final volume.\n"
+        f"    V = {round(volume, 2)} L\n\n"
+        f"**Answer:** The required reactor volume is {round(volume, 2)} liters."
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_batch_reactor_zero_order():
+    """
+    Batch Reactor Time Calculation - Zero Order Kinetics
+
+    Scenario:
+        The time required for a reaction in a constant-volume batch reactor is 
+        determined by integrating the mole balance equation. For a zero-order 
+        reaction, the rate of reaction is constant and independent of concentration. 
+        Given the initial and final concentrations and the rate constant, the 
+        goal is to compute the necessary time using the integrated rate law:
+
+            t = (C_A0 - C_A) / k
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to calculate the required reaction time.
+            - str: A step-by-step solution showing the derivation and calculation.
+    """
+    
+    # 1. Parameterize inputs
+    reactant_name = random.choice(LIQUID_PHASE_REACTANTS)
+    C_A0 = round(random.uniform(2.0, 10.0), 2)  # Initial concentration (mol/L)
+    
+    # Generate final concentration ensuring reasonable conversion
+    conversion = round(random.uniform(0.2, 0.8), 2)
+    C_A = round(C_A0 * (1 - conversion), 2)
+    
+    # Zero-order rate constant (mol/(L·s))
+    k = round(random.uniform(0.01, 0.1), 4)
+    
+    # Calculate time
+    time = (C_A0 - C_A) / k
+    
+    # Generate question and solution
+    question = (
+        f"A zero-order liquid-phase reaction involving {reactant_name} is carried out "
+        f"in a constant-volume batch reactor. The initial concentration is {C_A0} mol/L, "
+        f"and the desired final concentration is {C_A} mol/L. If the zero-order rate "
+        f"constant is {k} mol/(L·s), calculate the required reaction time."
+    )
+    
+    solution = (
+        f"**Given:**\n"
+        f"- Initial concentration (C_A0) = {C_A0} mol/L\n"
+        f"- Final concentration (C_A) = {C_A} mol/L\n"
+        f"- Zero-order rate constant (k) = {k} mol/(L·s)\n"
+        f"- Conversion = {round(conversion * 100, 1)}%\n\n"
+        
+        f"**Step 1:** Write the mole balance for a constant-volume batch reactor.\n"
+        f"dC_A/dt = r_A\n\n"
+        
+        f"**Step 2:** For zero-order kinetics, r_A = -k (constant).\n"
+        f"dC_A/dt = -k\n\n"
+        
+        f"**Step 3:** Integrate from t=0 (C_A = C_A0) to t=t (C_A = C_A).\n"
+        f"∫[C_A0 to C_A] dC_A = -k ∫[0 to t] dt\n"
+        f"C_A - C_A0 = -k × t\n\n"
+        
+        f"**Step 4:** Solve for time.\n"
+        f"t = (C_A0 - C_A) / k\n\n"
+        
+        f"**Step 5:** Substitute values.\n"
+        f"t = ({C_A0} - {C_A}) mol/L / {k} mol/(L·s)\n"
+        f"t = {C_A0 - C_A} / {k} = {round(time, 2)} s\n\n"
+        
+        f"**Answer:** The required reaction time is {round(time, 2)} seconds."
+    )
+    
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_batch_reactor_first_order():
+    """
+    Batch Reactor Time Calculation - First Order Kinetics
+
+    Scenario:
+        This template calculates the time for a reaction in a constant-volume
+        batch reactor following first-order kinetics. Unlike zero-order reactions,
+        the rate of a first-order reaction is directly proportional to the
+        concentration of the reactant (-r_A = k*C_A). The required time is found
+        by integrating the mole balance equation. Given the initial and final
+        concentrations and the rate constant, the goal is to compute the time using:
+
+            t = (1/k) * ln(C_A0 / C_A)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to calculate the required reaction time.
+            - str: A step-by-step solution showing the derivation and calculation.
+    """
+    
+    reactant_name = random.choice(LIQUID_PHASE_REACTANTS)
+    C_A0 = round(random.uniform(1.0, 5.0), 2)
+    
+    conversion = round(random.uniform(0.3, 0.9), 2)
+    C_A = round(C_A0 * (1 - conversion), 2)
+    
+    # First-order rate constant (1/s)
+    k = round(random.uniform(0.001, 0.01), 5)
+    
+    # Calculate time
+    time = math.log(C_A0 / C_A) / k
+    
+    question = (
+        f"A first-order liquid-phase reaction of {reactant_name} occurs in a batch reactor. "
+        f"The initial concentration is {C_A0} mol/L, and after reaction, the concentration "
+        f"decreases to {C_A} mol/L. If the first-order rate constant is {k} s⁻¹, "
+        f"determine the reaction time required."
+    )
+    
+    solution = (
+        f"**Given:**\n"
+        f"- Initial concentration (C_A0) = {C_A0} mol/L\n"
+        f"- Final concentration (C_A) = {C_A} mol/L\n"
+        f"- First-order rate constant (k) = {k} s⁻¹\n"
+        f"- Conversion = {round(conversion * 100, 1)}%\n\n"
+        
+        f"**Step 1:** Write the rate law for first-order kinetics.\n"
+        f"-r_A = k × C_A\n\n"
+        
+        f"**Step 2:** Set up the mole balance equation.\n"
+        f"dC_A/dt = -k × C_A\n\n"
+        
+        f"**Step 3:** Separate variables and integrate.\n"
+        f"dC_A/C_A = -k × dt\n"
+        f"∫[C_A0 to C_A] dC_A/C_A = -k ∫[0 to t] dt\n\n"
+        
+        f"**Step 4:** Solve the integral.\n"
+        f"ln(C_A/C_A0) = -k × t\n"
+        f"ln(C_A0/C_A) = k × t\n\n"
+        
+        f"**Step 5:** Solve for time.\n"
+        f"t = (1/k) × ln(C_A0/C_A)\n\n"
+        
+        f"**Step 6:** Substitute values.\n"
+        f"t = (1/{k}) × ln({C_A0}/{C_A})\n"
+        f"t = {round(1/k, 2)} × ln({round(C_A0/C_A, 3)})\n"
+        f"t = {round(1/k, 2)} × {round(math.log(C_A0/C_A), 3)}\n"
+        f"t = {round(time, 2)} s\n\n"
+        
+        f"**Answer:** The required reaction time is {round(time, 2)} seconds."
+    )
+    
+    return question, solution
+
+
+# Template 4 (Advanced)
+def template_batch_reactor_second_order():
+    """
+    Batch Reactor Time Calculation - Second Order Kinetics
+
+    Scenario:
+        This template calculates the reaction time in a constant-volume batch
+        reactor for a second-order reaction. In this case, the reaction rate
+        depends on the square of the reactant's concentration (-r_A = k*C_A²).
+        The time required is determined by integrating the mole balance
+        equation for these kinetics. Given the initial and final concentrations
+        and the second-order rate constant, the goal is to compute the time using:
+
+            t = (1/k) * (1/C_A - 1/C_A0)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to calculate the required reaction time.
+            - str: A step-by-step solution showing the derivation and calculation.
+    """
+    
+    reactant_name = random.choice(LIQUID_PHASE_REACTANTS)
+    C_A0 = round(random.uniform(0.5, 2.0), 2)  # Lower values for second-order
+    
+    conversion = round(random.uniform(0.4, 0.85), 2)
+    C_A = round(C_A0 * (1 - conversion), 2)
+    
+    # Second-order rate constant (L/(mol·s))
+    k = round(random.uniform(0.1, 1.0), 3)
+    
+    # Calculate time
+    time = (1/C_A - 1/C_A0) / k
+    
+    question = (
+        f"A second-order reaction of {reactant_name} takes place in a batch reactor. "
+        f"Starting with {C_A0} mol/L, the concentration drops to {C_A} mol/L. "
+        f"Given that the second-order rate constant is {k} L/(mol·s), "
+        f"calculate the time required for this conversion."
+    )
+    
+    solution = (
+        f"**Given:**\n"
+        f"- Initial concentration (C_A0) = {C_A0} mol/L\n"
+        f"- Final concentration (C_A) = {C_A} mol/L\n"
+        f"- Second-order rate constant (k) = {k} L/(mol·s)\n"
+        f"- Conversion = {round(conversion * 100, 1)}%\n\n"
+        
+        f"**Step 1:** Write the rate law for second-order kinetics.\n"
+        f"-r_A = k × C_A²\n\n"
+        
+        f"**Step 2:** Set up the mole balance equation.\n"
+        f"dC_A/dt = -k × C_A²\n\n"
+        
+        f"**Step 3:** Separate variables and integrate.\n"
+        f"dC_A/C_A² = -k × dt\n"
+        f"∫[C_A0 to C_A] C_A⁻² dC_A = -k ∫[0 to t] dt\n\n"
+        
+        f"**Step 4:** Solve the integral.\n"
+        f"[-1/C_A] from C_A0 to C_A = -k × t\n"
+        f"-1/C_A + 1/C_A0 = -k × t\n"
+        f"1/C_A - 1/C_A0 = k × t\n\n"
+        
+        f"**Step 5:** Solve for time.\n"
+        f"t = (1/k) × (1/C_A - 1/C_A0)\n\n"
+        
+        f"**Step 6:** Substitute values.\n"
+        f"t = (1/{k}) × (1/{C_A} - 1/{C_A0})\n"
+        f"t = {round(1/k, 3)} × ({round(1/C_A, 3)} - {round(1/C_A0, 3)})\n"
+        f"t = {round(1/k, 3)} × {round(1/C_A - 1/C_A0, 3)}\n"
+        f"t = {round(time, 2)} s\n\n"
+        
+        f"**Answer:** The required reaction time is {round(time, 2)} seconds."
+    )
+    
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_pfr_volume_changing_rate():
+    """
+    PFR Volume Calculation - Arbitrary Order Kinetics
+
+    Scenario:
+        This template calculates the required volume for a Plug Flow Reactor (PFR)
+        to achieve a target conversion for a liquid-phase (constant-density)
+        reaction. The reaction follows an arbitrary, non-integer order, where the
+        rate law is -r_A = k * C_A^n. Because an analytical solution is often
+        complex for such cases, the PFR design equation is solved using
+        numerical integration:
+
+            V = ∫[0 to X] (F_A0 / (-r_A)) dX
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to calculate the required reactor volume.
+            - str: A step-by-step solution showing the setup and numerical result.
+    """
+    
+    reactant_name = random.choice(LIQUID_PHASE_REACTANTS)
+    F_A0 = round(random.uniform(1.0, 4.0), 2)
+    X_final = round(random.uniform(0.5, 0.85), 2)
+    
+    # Reaction order (non-integer for complexity)
+    n = round(random.uniform(1.5, 2.5), 1)
+    
+    # Rate constant and initial concentration
+    k = round(random.uniform(0.05, 0.5), 3)
+    C_A0 = round(random.uniform(0.5, 2.0), 2)  # mol/L
+    
+    def rate_function_advanced(X):
+        """Rate as function of conversion: -r_A = k * C_A0^n * (1-X)^n"""
+        return k * (C_A0**n) * ((1 - X)**n)
+    
+    def integrand_advanced(X):
+        """Integrand for PFR design equation"""
+        return F_A0 / rate_function_advanced(X)
+    
+    # Numerical integration (analytical solution complex for arbitrary n)
+    volume, integration_error = quad(integrand_advanced, 0, X_final)
+    
+    question = (
+        f"An {n}-order liquid-phase reaction of {reactant_name} (A → products) occurs in a PFR. "
+        f"The inlet conditions are: F_A0 = {F_A0} mol/s and C_A0 = {C_A0} mol/L. "
+        f"The rate expression is: -r_A = {k} × C_A^{n} mol/(L·s). "
+        f"Determine the reactor volume needed for {X_final*100}% conversion."
+    )
+    
+    solution = (
+        f"**Given:**\n"
+        f"- Inlet molar flow rate: F_A0 = {F_A0} mol/s\n"
+        f"- Initial concentration: C_A0 = {C_A0} mol/L\n"
+        f"- Rate constant: k = {k} L^{n-1}/(mol^{n-1}·s)\n"
+        f"- Reaction order: n = {n}\n"
+        f"- Desired conversion: X = {X_final}\n\n"
+        
+        f"**Step 1:** Express rate in terms of conversion.\n"
+        f"C_A = C_A0(1 - X)\n"
+        f"-r_A = k × C_A^{n} = k × C_A0^{n} × (1 - X)^{n}\n"
+        f"-r_A = {k} × {C_A0}^{n} × (1 - X)^{n}\n"
+        f"-r_A = {round(k * (C_A0**n), 4)} × (1 - X)^{n}\n\n"
+        
+        f"**Step 2:** Set up the PFR integral.\n"
+        f"V = ∫[0 to {X_final}] (F_A0 / (-r_A)) dX\n"
+        f"V = ∫[0 to {X_final}] ({F_A0} / ({round(k * (C_A0**n), 4)} × (1 - X)^{n})) dX\n\n"
+        
+        f"**Step 3:** This integral requires numerical methods for n = {n}.\n"
+        f"Using numerical integration (scipy.integrate.quad):\n\n"
+        
+        f"**Step 4:** Numerical result.\n"
+        f"V = {round(volume, 2)} L\n"
+        f"Integration error: {integration_error:.2e}\n\n"
+        
+        f"**Note:** For non-integer reaction orders, analytical solutions are complex.\n"
+        f"Numerical integration is the standard approach in reactor design.\n\n"
+        
+        f"**Answer:** The required PFR volume is {round(volume, 2)} liters."
+    )
+    
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each mole balances template with different random seeds
+    and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/chemical_engineering/reaction_kinetics/mole_balances.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_cstr_volume_basic, "cstr_volume_basic", "Easy"),
+        (template_batch_reactor_zero_order, "batch_reactor_zero_order", "Easy"),
+        (template_batch_reactor_first_order, "batch_reactor_first_order", "Intermediate"),
+        (template_batch_reactor_second_order, "batch_reactor_second_order", "Advanced"),
+        (template_pfr_volume_changing_rate, "pfr_volume_changing_rate", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "chemical_engineering",
+                "domain": "reaction_kinetics",
+                "area": "mole_balances",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,565 @@
+import random
+from data.templates.branches.chemical_engineering.constants import GENERAL_REACTANTS, LIQUID_PHASE_REACTANTS, GAS_PHASE_REACTANTS, PRODUCTS
+
+
+# Template 1 (Easy)
+def template_batch_moles_vs_conversion():
+    """
+    Batch System Moles vs. Conversion
+
+    Scenario:
+        This template tests the fundamental relationship between conversion ($X_A$)
+        and the number of moles of each species in a batch reactor. For a given
+        reaction like $aA + bB -> cC + dD$, the goal is to calculate the final
+        number of moles of all species based on the initial moles and a specific
+        conversion of the limiting reactant using the core stoichiometric relations:
+
+            $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$
+
+    Returns:
+        tuple: A tuple containing:
+            - 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)
+    
+    # Generate stoichiometric coefficients
+    a = random.choice([1, 2])
+    b = random.randint(1, 3)
+    c = random.randint(1, 3)
+    d = random.randint(1, 3)
+
+    # Generate initial moles, ensuring A is the limiting reactant
+    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)
+
+    # Generate a realistic conversion for the limiting reactant A
+    X_A = round(random.uniform(0.40, 0.95), 2)
+
+    # 2. Core Calculations
+    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
+
+    # 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"{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"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"- 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"- 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"- $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"**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"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"**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"
+    )
+
+    return question, solution
+
+
+# Template 2 (Intermediate)
+def template_flow_system_molar_flow_rates():
+    """
+    Flow System Molar Flow Rates vs. Conversion
+
+    Scenario:
+        This template tests the ability to determine the outlet molar flow rates
+        of all species in a continuous flow reactor (e.g., CSTR, PFR) given the
+        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)$
+
+        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
+    
+    # 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)
+
+    # Generate inlet molar flow rates (mol/min), ensuring A is limiting
+    F_A0 = round(random.uniform(50.0, 150.0), 2)
+    F_B0 = round((F_A0 * b / a) * random.uniform(1.2, 2.5), 2)
+    F_C0 = round(random.choice([0.0, random.uniform(5.0, 20.0)]), 2)
+    F_D0 = 0.0
+
+    # Generate a realistic conversion
+    X_A = round(random.uniform(0.50, 0.90), 2)
+
+    # 2. Core Calculations
+    
+    # Calculate Theta values for use in the solution string
+    Theta_B = F_B0 / F_A0
+    Theta_C = F_C0 / F_A0
+
+    # Calculate outlet 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
+    
+    # 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"{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"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"- 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"**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"**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"**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"**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"**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"
+
+        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"
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_limiting_reactant():
+    """
+    Finding and Using the Limiting Reactant
+
+    Scenario:
+        This template adds a crucial preliminary step to stoichiometric calculations.
+        Given a reaction and the initial moles of multiple reactants, the user must
+        first identify the limiting reactant by comparing the ratio of initial moles
+        to the stoichiometric coefficient for each species:
+
+            Compare: $N_{A0}/a$ vs. $N_{B0}/b$
+
+        The species with the smaller ratio is limiting. Then, using a given
+        conversion with respect to that limiting reactant, the user calculates the
+        final moles of all species.
+
+    Returns:
+        tuple: A tuple containing:
+            - 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)
+
+    # Randomly decide which reactant will be limiting
+    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)
+    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)
+    
+    N_C0 = 0.0
+    N_D0 = 0.0
+
+    # Generate a realistic conversion for the limiting reactant
+    X = round(random.uniform(0.60, 0.95), 2)
+
+    # 2. Core Calculations & Logic
+    
+    # Determine the limiting reactant
+    ratio_A = N_A0 / a
+    ratio_B = N_B0 / b
+
+    if ratio_A <= ratio_B:
+        # 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)
+        N_B = N_B0 - (b / a) * N_A0 * X
+        N_C = N_C0 + (c / a) * N_A0 * X
+        N_D = N_D0 + (d / a) * N_A0 * X
+    else:
+        # 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
+        N_B = N_B0 * (1 - X)
+        N_C = N_C0 + (c / b) * N_B0 * X
+        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)}"
+    )
+
+    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"First, identify the limiting reactant. Then, calculate the final number of moles for all species."
+    )
+
+    solution_step1_identification = (
+        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"
+    )
+
+    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"
+        )
+    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"
+        )
+
+    solution = f"### **Solution**\n\n{solution_step1_identification}{solution_step2_calculation}{solution_final_answer}"
+
+    return question, solution
+
+
+# Template 4 (Advanced)
+def template_gas_phase_concentration():
+    """
+    Gas-Phase Concentration with Volumetric Change
+
+    Scenario:
+        For gas-phase reactions with a change in the total number of moles, the
+        volumetric flow rate varies with conversion. This template tests the ability
+        to calculate outlet concentrations in an isothermal, isobaric flow system
+        using the specialized gas-phase concentration equations from Fogler, which
+        account for this volumetric change via the parameter epsilon ($\\epsilon$).
+
+        $C_A = C_{A0} \\frac{1 - X_A}{1 + \\epsilon X_A}$
+        $C_B = C_{A0} \\frac{\\Theta_B - (b/a)X_A}{1 + \\epsilon X_A}$
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question about calculating gas-phase outlet concentrations.
+            - str: A detailed solution showing the application of the correct formulas.
+    """
+    # 1. Randomized Parameters
+    
+    # Select unique names
+    reactant_A_name, reactant_B_name = random.sample(GAS_PHASE_REACTANTS, 2)
+    product_C_name = random.choice(PRODUCTS)
+    
+    # Stoichiometric coefficients
+    a = random.choice([1, 2])
+    b = random.randint(1, 3)
+    c = random.randint(1, 2)
+
+    # Initial concentration (gases have lower concentrations, units are mol/dm^3)
+    C_A0 = round(random.uniform(0.05, 0.25), 3)
+    
+    # Conversion
+    X_A = round(random.uniform(0.50, 0.90), 2)
+    
+    # Theta_B must be in excess of the stoichiometric requirement
+    Theta_B = round((b / a) * random.uniform(1.2, 2.5), 2)
+    
+    # Epsilon (ε) can be positive (expansion) or negative (contraction)
+    # Ensure it's not too close to zero to make the problem meaningful
+    epsilon = 0
+    while abs(epsilon) < 0.1:
+        epsilon = round(random.uniform(-0.5, 0.5), 2)
+
+    # 2. Core Calculations
+    denominator = 1 + epsilon * X_A
+    C_A = C_A0 * (1 - X_A) / denominator
+    C_B = C_A0 * (Theta_B - (b / a) * X_A) / denominator
+
+    # 3. Generate Question and Solution Strings
+    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)}"
+    )
+
+    question = (
+        f"The following elementary gas-phase reaction occurs in a steady-state PFR:\n"
+        f"**Reaction:** ${reaction_string}$\n\n"
+        f"The reaction is carried out **isothermally** and **isobarically**. The feed enters the reactor with an initial concentration of {reactant_A_name} of $C_{{A0}} = {C_A0}$ mol/dm³.\n\n"
+        f"The following parameters are known:\n"
+        f"- Molar feed ratio: $\\Theta_B = F_{{B0}}/F_{{A0}} = {Theta_B}$\n"
+        f"- Volumetric change parameter: $\\epsilon = {epsilon}$\n\n"
+        f"If the reaction achieves a final conversion of $X_A = {X_A}$, what are the outlet concentrations of {reactant_A_name} ($C_A$) and {reactant_B_name} ($C_B$)?"
+    )
+
+    solution = (
+        f"**Step 1:** Identify Given Information\n"
+        f"- Initial Concentration: $C_{{A0}} = {C_A0}$ mol/dm³\n"
+        f"- Conversion: $X_A = {X_A}$\n"
+        f"- Molar Feed Ratio: $\\Theta_B = {Theta_B}$\n"
+        f"- Volumetric Change Parameter: $\\epsilon = {epsilon}$\n"
+        f"- Stoichiometric Ratio: $b/a = {b}/{a} = {round(b/a, 2)}$\n\n"
+        
+        f"**Step 2:** State the Governing Equations\n"
+        f"For an isothermal, isobaric gas-phase reaction with a change in the number of moles, the concentration of each species is a function of conversion ($X_A$) and the volumetric change parameter ($\\epsilon$). The term $(1 + \\epsilon X_A)$ in the denominator corrects for the change in volumetric flow rate.\n\n"
+        f"For reactant A: \n$C_A = C_{{A0}} \\frac{{1 - X_A}}{{1 + \\epsilon X_A}}$\n\n"
+        f"For reactant B: \n$C_B = C_{{A0}} \\frac{{\\Theta_B - (b/a)X_A}}{{1 + \\epsilon X_A}}$\n\n"
+        
+        f"**Step 3:** Calculate the Denominator Term\n"
+        f"First, let's calculate the volumetric correction term, which is common to all species:\n"
+        f"$1 + \\epsilon X_A = 1 + ({epsilon})({X_A}) = {round(denominator, 4)}$\n\n"
+        
+        f"**Step 4:** Calculate Outlet Concentrations\n\n"
+        f"**For {reactant_A_name} ($C_A$):**\n"
+        f"$C_A = {C_A0} \\frac{{1 - {X_A}}}{{{round(denominator, 4)}}} = {C_A0} \\frac{{{round(1 - X_A, 2)}}}{{{round(denominator, 4)}}} = \\mathbf{{{round(C_A, 4)}}}$ mol/dm³\n\n"
+        
+        f"**For {reactant_B_name} ($C_B$):**\n"
+        f"First, calculate the numerator term for B: \n"
+        f"$\\Theta_B - (b/a)X_A = {Theta_B} - ({round(b/a, 2)})({X_A}) = {round(Theta_B - (b/a)*X_A, 4)}$\n"
+        f"Now, calculate the concentration:\n"
+        f"$C_B = {C_A0} \\frac{{{round(Theta_B - (b/a)*X_A, 4)}}}{{{round(denominator, 4)}}} = \\mathbf{{{round(C_B, 4)}}}$ mol/dm³\n\n"
+        
+        f"**Final Answer**\n"
+        f"The outlet concentrations are:\n"
+        f"- **$C_A$:** ${round(C_A, 4)}$ mol/dm³\n"
+        f"- **$C_B$:** ${round(C_B, 4)}$ mol/dm³"
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each stoichiometry template with different random seeds
+    and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/chemical_engineering/reaction_kinetics/stoichiometry.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [ 
+        (template_batch_moles_vs_conversion, "batch_moles_vs_conversion", "Easy"),
+        (template_flow_system_molar_flow_rates, "flow_rates_vs_conversion", "Intermediate"),
+        (template_limiting_reactant, "finding_limiting_reactant", "Intermediate"),
+        (template_gas_phase_concentration, "gas_phase_concentration", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "chemical_engineering",
+                "domain": "reaction_kinetics",
+                "area": "stoichiometry",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,476 @@
+import random
+from scipy.optimize import fsolve
+from data.templates.branches.chemical_engineering.constants import SUBSTANCES_FOR_HEATING, SUBSTANCES_FOR_VAPORIZATION, HEATS_OF_FORMATION, REACTIONS, CP_PARAMS, COMBUSTION_REACTIONS
+
+
+# Template 1 (Easy)
+def template_sensible_heat_constant_cp():
+    """
+    Sensible Heat Calculation (Constant Heat Capacity)
+
+    Scenario:
+        This template calculates the sensible heat required to change the
+        temperature of a substance without changing its phase. It uses the
+        substance's actual specific heat capacity (Cp) for a physically
+        accurate problem.
+
+        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:
+            - str: A question asking to compute the sensible heat.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs using the substance list
+    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
+
+    # Generate a random mass in grams
+    m = round(random.uniform(50.0, 1000.0), 1)  # grams
+
+    # 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)
+
+    # 2. Perform the core calculation
+    delta_T = T2_C - T1_C
+    # Q will be in Joules (g * J/g·K * K)
+    Q_J = m * Cp * delta_T
+    # Convert to kilojoules for the final answer
+    Q_kJ = Q_J / 1000
+
+    # 3. Generate the question and solution strings
+    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."
+    )
+
+    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"**Step 2:** List the given values.\n"
+        f"- Mass (m) = {m} g\n"
+        f"- Specific Heat Capacity (Cp) = {Cp} J/g·K\n"
+        f"- Initial Temperature (T1) = {T1_C}°C\n"
+        f"- Final Temperature (T2) = {T2_C}°C\n\n"
+
+        f"**Step 3:** Calculate the temperature difference (ΔT).\n"
+        f"A change in temperature has the same magnitude in Celsius and Kelvin.\n"
+        f"ΔT = T2 - T1 = {T2_C}°C - {T1_C}°C = {round(delta_T, 1)} K\n\n"
+
+        f"**Step 4:** Substitute the values into the formula to find the heat in Joules (J).\n"
+        f"Q = {m} g * {Cp} J/g·K * {round(delta_T, 1)} K\n"
+        f"Q = {round(Q_J, 1)} J\n\n"
+
+        f"**Step 5:** Convert the heat to kilojoules (kJ) as requested.\n"
+        f"Q = {round(Q_J, 1)} J * (1 kJ / 1000 J) = {round(Q_kJ, 2)} kJ\n\n"
+
+        f"**Answer:** The heat required is **{round(Q_kJ, 2)} kJ**."
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_latent_heat_vaporization():
+    """
+    Latent Heat of Vaporization
+
+    Scenario:
+        This template calculates the heat required to cause a phase change
+        (vaporization) at a constant temperature and pressure. This energy,
+        known as latent heat, is used to overcome intermolecular forces
+        rather than to increase the substance's kinetic energy (temperature).
+
+        The governing equation is:
+            Q = n * ΔH_vap
+        Where:
+        - Q: Total heat absorbed
+        - n: Number of moles
+        - ΔH_vap: Molar heat of vaporization
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the latent heat.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs using the substance list
+    substance_data = random.choice(SUBSTANCES_FOR_VAPORIZATION)
+    substance_name = substance_data["name"]
+    delta_H_vap = substance_data["delta_H_vap"]  # in kJ/mol
+
+    # Generate a random number of moles
+    n = round(random.uniform(0.5, 5.0), 2)  # moles
+
+    # 2. Perform the core calculation
+    # The result will be in kJ since ΔH_vap is in kJ/mol
+    Q_kJ = n * delta_H_vap
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"How much heat in kJ is required to completely vaporize {n} moles of "
+        f"liquid {substance_name} at its normal boiling point? The molar heat of "
+        f"vaporization for {substance_name} is {delta_H_vap} kJ/mol."
+    )
+
+    solution = (
+        f"**Step 1:** State the formula.\n"
+        f"Q = n * ΔH_vap\n\n"
+
+        f"**Step 2:** List the given values.\n"
+        f"- Moles (n) = {n} mol\n"
+        f"- Molar Heat of Vaporization (ΔH_vap) = {delta_H_vap} kJ/mol\n\n"
+
+        f"**Step 3:** Substitute the values into the formula.\n"
+        f"Q = {n} mol * {delta_H_vap} kJ/mol\n\n"
+
+        f"**Step 4:** Calculate the total heat required.\n"
+        f"Q = {round(Q_kJ, 2)} kJ\n\n"
+
+        f"**Answer:** The total heat required to vaporize the {substance_name} is **{round(Q_kJ, 2)} kJ**."
+    )
+
+    return question, solution
+
+
+# Template 3 (Easy)
+def template_heat_of_reaction_formation():
+    """
+    Standard Heat of Reaction from Heats of Formation
+
+    Scenario:
+        This template applies Hess's Law to find the standard heat of reaction
+        at 298.15 K (ΔH_rxn°). It is calculated by subtracting the sum of the
+        standard heats of formation (ΔH_f°) of the reactants from the sum of
+        the heats of formation of the products, with each being weighted by
+        its stoichiometric coefficient (v).
+
+        The governing equation is:
+            ΔH_rxn° = Σ(v * ΔH_f°)products - Σ(v * ΔH_f°)reactants
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the standard heat of reaction.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs by choosing a random reaction
+    reaction_data = random.choice(REACTIONS)
+    equation = reaction_data["equation"]
+    reactants = reaction_data["reactants"]
+    products = reaction_data["products"]
+
+    # 2. Perform the core calculation with full precision
+    products_enthalpy = sum(nu * HEATS_OF_FORMATION[species] for species, nu in products.items())
+    reactants_enthalpy = sum(nu * HEATS_OF_FORMATION[species] for species, nu in reactants.items())
+        
+    # Final calculation uses the precise, unrounded intermediate values
+    delta_H_rxn = products_enthalpy - reactants_enthalpy
+
+    # 3. Generate the question and solution strings
+    required_species = list(reactants.keys()) + list(products.keys())
+    hf_list_for_question = "\n".join(
+        f"- {s}: {HEATS_OF_FORMATION[s]} kJ/mol" for s in sorted(list(set(required_species)))
+    )
+
+    # Question updated for clarity
+    question = (
+        f"Calculate the standard enthalpy of reaction, ΔH_rxn°, at 298.15 K (in kJ) for the reaction as written:\n"
+        f"{equation}\n\n"
+        f"Use the standard heats of formation (ΔH_f°) provided below:\n{hf_list_for_question}"
+    )
+
+    # Helper functions to format the solution steps
+    def format_sum(species_dict):
+        return " + ".join([f"({nu} * ΔH_f°[{s}])" for s, nu in species_dict.items()])
+
+    def format_calc(species_dict):
+        return " + ".join([f"({nu} * {HEATS_OF_FORMATION[s]})" for s, nu in species_dict.items()])
+
+    # Solution updated to use correct rounding procedures and units
+    solution = (
+        f"**Step 1:** State the formula.\n"
+        f"ΔH_rxn° = Σ(v * ΔH_f°)products - Σ(v * ΔH_f°)reactants\n\n"
+
+        f"**Step 2:** Calculate the total enthalpy of the products.\n"
+        f"Σ_products = {format_sum(products)}\n"
+        f"Σ_products = {format_calc(products)}\n"
+        f"Σ_products = {products_enthalpy:.3f} kJ\n\n"
+
+        f"**Step 3:** Calculate the total enthalpy of the reactants.\n"
+        f"Σ_reactants = {format_sum(reactants)}\n"
+        f"Σ_reactants = {format_calc(reactants)}\n"
+        f"Σ_reactants = {reactants_enthalpy:.3f} kJ\n\n"
+
+        f"**Step 4:** Calculate the standard enthalpy of reaction using the full-precision values.\n"
+        f"ΔH_rxn° = ({products_enthalpy:.3f}) - ({reactants_enthalpy:.3f})\n"
+        f"ΔH_rxn° = {round(delta_H_rxn, 2)} kJ\n\n"
+
+        f"**Answer:** The standard enthalpy of reaction is **{round(delta_H_rxn, 2)} kJ** for the reaction as written."
+    )
+    
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_sensible_heat_temp_dependent_cp():
+    """
+    Sensible Heat (Temperature-Dependent Heat Capacity)
+
+    Scenario:
+        This template provides a more accurate calculation of sensible heat where
+        the heat capacity (Cp) is a polynomial function of temperature. The total
+        heat required is found by integrating this function over the temperature
+        range from T1 to T2.
+
+        The governing equation is:
+            Q = n * integral(Cp(T) dT) from T1 to T2
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the sensible heat via integration.
+            - str: A step-by-step solution showing the analytical integration.
+    """
+    # 1. Parameterize the inputs
+    R = 8.314  # J/(mol·K)
+    substance_name = random.choice(list(CP_PARAMS.keys()))
+    params = CP_PARAMS[substance_name]
+    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
+
+    # 2. Perform the core calculation via analytical integration
+    # integral(A + BT + CT² + DT⁻²)dT = AT + (B/2)T² + (C/3)T³ - D/T
+    def integral_mean_cp_over_r(T):
+        term_a = A * T
+        term_b = (B / 2) * (T**2)
+        term_c = (C / 3) * (T**3)
+        term_d = -D / T if T != 0 else 0
+        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))
+    
+    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⁻²"
+
+    question = (
+        f"Calculate the heat in kJ required to raise the temperature of {n} moles of "
+        f"{substance_name} from {T1} K to {T2} K. The molar heat capacity for "
+        f"{substance_name} is given by the equation:\n"
+        f"  Cp/R = {cp_eq_str}\n"
+        f"Where the constants are: A={A}, B={B:.3g}, C={C:.3g}, D={D:.3g}"
+    )
+
+    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"**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"**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 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 5:** Convert the result to kilojoules.\n"
+        f"Q = {Q_J:.2f} J * (1 kJ / 1000 J) = {Q_kJ:.2f} kJ\n\n"
+
+        f"**Answer:** The heat required is **{Q_kJ:.2f} kJ**."
+    )
+
+    return question, solution
+
+
+# Template 5 (Advanced)
+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.
+    """
+    # 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
+    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 "
+        f"process is adiabatic and there is no shaft work, estimate the "
+        f"adiabatic flame temperature in Kelvin."
+    )
+
+    solution = (
+        f"**Step 1:** Write the balanced chemical equation including inert nitrogen from air.\n"
+        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"**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"**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"**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"T_ad = {adiabatic_temp_kelvin:.2f} K\n\n"
+
+        f"**Answer:** The estimated adiabatic flame temperature is **{adiabatic_temp_kelvin:.2f} K**."
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each heat effects template with different random seeds
+    and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/chemical_engineering/thermodynamics/heat_effects.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_sensible_heat_constant_cp, "sensible_heat_constant_cp", "Easy"),
+        (template_latent_heat_vaporization, "latent_heat_vaporization", "Easy"),
+        (template_heat_of_reaction_formation, "heat_of_reaction_formation", "Easy"),
+        (template_sensible_heat_temp_dependent_cp, "sensible_heat_temp_dependent_cp", "Intermediate"),
+        (template_adiabatic_flame_temperature, "adiabatic_flame_temperature", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "chemical_engineering",
+                "domain": "thermodynamics",
+                "area": "heat_effects",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,701 @@
+import random
+import numpy as np
+import math
+from data.templates.branches.chemical_engineering.constants import GAS_PHASE_REACTANTS, THERMO_SUBSTANCES, CRITICAL_PROPERTIES
+
+
+# Template 1 (Easy)
+def template_ideal_gas_volume():
+    """
+    Ideal Gas Law Volume Calculation
+
+    Scenario:
+        The Ideal Gas Law, PV = nRT, is a fundamental equation of state that
+        describes the behavior of many gases. In this scenario, the pressure,
+        temperature, and number of moles of a gas are provided. The objective
+        is to apply the Ideal Gas Law to calculate the volume the gas occupies
+        using the formula:
+
+            V = nRT / P
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the gas volume.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs with random values
+    gas_name = random.choice(GAS_PHASE_REACTANTS)
+    # Moles of gas
+    n = round(random.uniform(0.5, 5.0), 2)
+    # Temperature in Kelvin
+    T_k = round(random.uniform(273.15, 500.0), 2)
+    # Pressure in Pascals (for calculation)
+    P_pa = round(random.uniform(100000, 500000))
+    # Pressure in Kilopascals (for the question text)
+    P_kpa = round(P_pa / 1000, 1)
+
+    # Define the ideal gas constant in SI units
+    R = 8.314  # Pa·m³/(mol·K)
+
+    # 2. Perform the core calculation
+    # Volume will be in cubic meters (m³)
+    V_m3 = (n * R * T_k) / P_pa
+    # Convert volume to Liters for the final answer
+    V_L = V_m3 * 1000
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"Calculate the volume in liters occupied by {n} moles of {gas_name} gas "
+        f"at a temperature of {T_k} K and a pressure of {P_kpa} kPa. "
+        f"Assume the gas behaves ideally."
+    )
+
+    solution = (
+        f"**Step 1:** State the Ideal Gas Law formula solved for volume (V).\n"
+        f"The formula is V = \\frac{{nRT}}{{P}}\n\n"
+
+        f"**Step 2:** List the given values and the ideal gas constant, ensuring consistent SI units.\n"
+        f"- Moles (n) = {n} mol\n"
+        f"- Temperature (T) = {T_k} K\n"
+        f"- Pressure (P) = {P_kpa} kPa = {P_pa} Pa\n"
+        f"- Ideal Gas Constant (R) = {R} Pa·m³/(mol·K)\n\n"
+
+        f"**Step 3:** Substitute the values into the equation.\n"
+        f"V = \\frac{{({n} \\text{{ mol}}) \\times ({R} \\text{{ Pa·m³/mol·K}}) \\times ({T_k} \\text{{ K}})}}{{{P_pa} \\text{{ Pa}}}}\n\n"
+
+        f"**Step 4:** Calculate the volume in cubic meters.\n"
+        f"V = {round(V_m3, 5)} \\text{{ m³}}\n\n"
+
+        f"**Step 5:** Convert the volume to liters as requested.\n"
+        f"Since 1 \\text{{ m³}} = 1000 \\text{{ L}}:\n"
+        f"V = {round(V_m3, 5)} \\text{{ m³}} \\times 1000 \\frac{{\\text{{L}}}}{{\\text{{m³}}}} = {round(V_L, 2)} \\text{{ L}}\n\n"
+
+        f"**Answer:** The volume occupied by the gas is **{round(V_L, 2)} liters**."
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_two_phase_specific_volume():
+    """
+    Specific Volume of a Two-Phase Mixture
+
+    Scenario:
+        When a substance exists as a mixture of liquid and vapor in equilibrium
+        (a saturated mixture), its overall specific volume (V) depends on the
+        proportions of the liquid and vapor phases. This proportion is defined
+        by the quality (x), which is the mass fraction of vapor. This template
+        provides the specific volumes of the saturated liquid (V^l) and
+        saturated vapor (V^v) along with the quality, and asks to calculate
+        the overall specific volume.
+
+        The governing equation is:
+            V = (1-x)V^l + xV^v
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the mixture's specific volume.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs with random values
+    substance = random.choice(THERMO_SUBSTANCES)
+    # Specific volume of saturated liquid in m³/kg
+    V_l = round(random.uniform(0.001, 0.002), 5)
+    # Specific volume of saturated vapor in m³/kg
+    V_v = round(random.uniform(0.05, 2.0), 3)
+    # Quality (mass fraction of vapor)
+    x = round(random.uniform(0.1, 0.9), 2)
+
+    # 2. Perform the core calculation
+    V = (1 - x) * V_l + x * V_v
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A closed vessel contains a saturated mixture of {substance} at a constant pressure. "
+        f"The specific volume of the saturated liquid is {V_l} m³/kg and the "
+        f"specific volume of the saturated vapor is {V_v} m³/kg. If the quality "
+        f"of the mixture is {x*100:.0f}%, what is the overall specific volume of the mixture?"
+    )
+
+    solution = (
+        f"**Step 1:** State the formula for the specific volume of a saturated mixture.\n"
+        f"The formula is V = (1-x)V^l + xV^v, where V^l is the saturated liquid specific volume and V^v is the saturated vapor specific volume.\n\n"
+
+        f"**Step 2:** List the given values.\n"
+        f"- Quality (x) = {x}\n"
+        f"- Saturated liquid specific volume (V^l) = {V_l} m³/kg\n"
+        f"- Saturated vapor specific volume (V^v) = {V_v} m³/kg\n\n"
+
+        f"**Step 3:** Substitute the values into the equation.\n"
+        f"V = (1 - {x})({V_l} \\text{{ m³/kg}}) + ({x})({V_v} \\text{{ m³/kg}})\n"
+        f"V = ({(1-x):.2f})({V_l}) + ({x})({V_v})\n"
+        f"V = {round((1-x)*V_l, 5)} + {round(x*V_v, 5)}\n\n"
+
+        f"**Step 4:** Calculate the final specific volume.\n"
+        f"V = {round(V, 5)} \\text{{ m³/kg}}\n\n"
+
+        f"**Answer:** The overall specific volume of the mixture is **{round(V, 5)} m³/kg**."
+    )
+
+    return question, solution
+
+
+# Template 3 (Easy)
+def template_rackett_equation_volume():
+    """
+    Rackett Equation for Saturated Liquid Volume
+
+    Scenario:
+        The Rackett equation is a generalized correlation used to estimate the
+        molar volume of a saturated liquid when experimental data is not
+        available. It relies on the substance's critical properties.
+
+        This template provides the critical temperature (Tc), critical volume (Vc),
+        and critical compressibility factor (Zc) for a substance. The goal is to
+        calculate the saturated liquid molar volume (V_sat) at a given
+        temperature (T).
+
+        The governing equation is:
+            V_sat = Vc * Zc**((1 - Tr)**0.2857)
+        Where:
+        - V_sat: Molar volume of the saturated liquid (cm³/mol)
+        - Vc: Critical volume (cm³/mol)
+        - Zc: Critical compressibility factor
+        - Tr: Reduced temperature (T / Tc)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the saturated liquid volume.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs with random values
+    substance_name = random.choice(list(CRITICAL_PROPERTIES.keys()))
+    properties = CRITICAL_PROPERTIES[substance_name]
+    Tc = properties["Tc"]
+    Vc = properties["Vc"]
+    Zc = properties["Zc"]
+
+    # Generate a random temperature below the critical temperature
+    T = round(random.uniform(0.5 * Tc, 0.95 * Tc), 2)
+
+    # 2. Perform the core calculation
+    # Calculate the reduced temperature
+    Tr = T / Tc
+    # Apply the Rackett equation
+    exponent = (1 - Tr)**0.2857
+    V_sat = Vc * (Zc**exponent)
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"Estimate the molar volume of saturated liquid {substance_name} at {T} K "
+        f"using the Rackett equation. The critical properties for {substance_name} are:\n"
+        f"Tc = {Tc} K\n"
+        f"Vc = {Vc} cm³/mol\n"
+        f"Zc = {Zc}"
+    )
+
+    solution = (
+        f"**Step 1:** State the Rackett equation.\n"
+        f"V_sat = Vc * Zc**((1 - Tr)**0.2857)\n\n"
+
+        f"**Step 2:** List the given properties and calculate the reduced temperature (Tr).\n"
+        f"- Critical Temperature (Tc) = {Tc} K\n"
+        f"- Critical Volume (Vc) = {Vc} cm³/mol\n"
+        f"- Critical Compressibility (Zc) = {Zc}\n"
+        f"- Temperature (T) = {T} K\n\n"
+        f"Tr = T / Tc = {T} / {Tc} = {round(Tr, 4)}\n\n"
+
+        f"**Step 3:** Substitute the values into the Rackett equation.\n"
+        f"V_sat = {Vc} * {Zc}**((1 - {round(Tr, 4)})**0.2857)\n"
+        f"V_sat = {Vc} * {Zc}**({round(1 - Tr, 4)}**0.2857)\n"
+        f"V_sat = {Vc} * {Zc}**({round(exponent, 4)})\n"
+        f"V_sat = {Vc} * {round(Zc**exponent, 4)}\n\n"
+
+        f"**Step 4:** Calculate the final molar volume.\n"
+        f"V_sat = {round(V_sat, 2)} cm³/mol\n\n"
+
+        f"**Answer:** The estimated molar volume of saturated liquid {substance_name} at {T} K is **{round(V_sat, 2)} cm³/mol**."
+    )
+
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_vdw_solve_for_pressure():
+    """
+    Van der Waals Equation for Pressure Calculation
+
+    Scenario:
+        The van der Waals equation is an equation of state that improves upon the
+        ideal gas law by including terms for intermolecular attraction ('a') and
+        molecular volume ('b'). This makes it applicable to real fluids in both
+        liquid and gas phases.
+
+        This template provides the critical properties (Tc and Pc) for a substance,
+        along with a given temperature (T) and molar volume (V). The objective is
+        to first calculate the van der Waals parameters 'a' and 'b', and then
+        use them to find the pressure (P).
+
+        The governing equations are:
+            P = (R * T) / (V - b) - a / (V**2)
+            a = (27 * R**2 * Tc**2) / (64 * Pc)
+            b = (R * Tc) / (8 * Pc)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the pressure.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs
+    # Gas constant in L·bar/(mol·K)
+    R = 0.08314
+
+    substance_name = random.choice(list(CRITICAL_PROPERTIES.keys()))
+    properties = CRITICAL_PROPERTIES[substance_name]
+    Tc = properties["Tc"]
+    Pc = properties["Pc"]
+
+    # Generate a random temperature, avoiding the critical region (0.95Tc to 1.05Tc)
+    while True:
+        T = round(random.uniform(0.8 * Tc, 2.5 * Tc), 2)
+        # Avoid temperatures too close to critical point where VdW equation is less accurate
+        if not (0.95 * Tc <= T <= 1.05 * Tc):
+            break
+
+    # First, calculate 'b' to ensure V > b
+    b = (R * Tc) / (8 * Pc)
+    # Generate a random molar volume greater than b
+    V = round(random.uniform(1.5 * b, 150 * b), 4)
+
+    # 2. Perform the core calculation
+    # Calculate parameter 'a'
+    a = (27 * (R**2) * (Tc**2)) / (64 * Pc)
+
+    # Calculate pressure using the Van der Waals equation
+    P = (R * T) / (V - b) - a / (V**2)
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"Using the van der Waals equation of state, calculate the pressure in bar "
+        f"exerted by {substance_name} at a temperature of {T} K and a molar volume "
+        f"of {V} L/mol. The critical constants for {substance_name} are:\n"
+        f"Tc = {Tc} K\n"
+        f"Pc = {Pc} bar"
+    )
+
+    solution = (
+        f"**Step 1:** State the necessary formulas.\n"
+        f"Pressure: P = (R * T) / (V - b) - a / (V**2)\n"
+        f"Parameter 'a': a = (27 * R**2 * Tc**2) / (64 * Pc)\n"
+        f"Parameter 'b': b = (R * Tc) / (8 * Pc)\n\n"
+
+        f"**Step 2:** List the given values and the gas constant.\n"
+        f"- Temperature (T) = {T} K\n"
+        f"- Molar Volume (V) = {V} L/mol\n"
+        f"- Critical Temperature (Tc) = {Tc} K\n"
+        f"- Critical Pressure (Pc) = {Pc} bar\n"
+        f"- Gas Constant (R) = {R} L·bar/(mol·K)\n\n"
+
+        f"**Step 3:** Calculate the co-volume parameter 'b'.\n"
+        f"b = ({R} * {Tc}) / (8 * {Pc}) = {round(b, 5)} L/mol\n\n"
+
+        f"**Step 4:** Calculate the attraction parameter 'a'.\n"
+        f"a = (27 * ({R})**2 * ({Tc})**2) / (64 * {Pc}) = {round(a, 4)} L²·bar/mol²\n\n"
+
+        f"**Step 5:** Substitute all values into the van der Waals equation to find P.\n"
+        f"P = ({R} * {T}) / ({V} - {round(b, 5)}) - {round(a, 4)} / ({V})**2\n"
+        f"P = {round(R * T, 2)} / {round(V - b, 5)} - {round(a, 4)} / {round(V**2, 5)}\n"
+        f"P = {round((R * T) / (V - b), 2)} - {round(a / (V**2), 2)}\n\n"
+
+        f"**Step 6:** Calculate the final pressure.\n"
+        f"P = {round(P, 2)} bar\n\n"
+
+        f"**Answer:** The pressure exerted by the {substance_name} is **{round(P, 2)} bar**."
+    )
+
+    return question, solution
+
+
+# Templat 5 (Intermediate)
+def template_pitzer_correlation_z():
+    """
+    Compressibility Factor from Pitzer's Correlation
+
+    Scenario:
+        The Pitzer correlation is a widely used application of the principle of
+        corresponding states to estimate the properties of real fluids. It
+        improves upon two-parameter correlations by introducing the acentric
+        factor (omega), which accounts for the non-sphericity of molecules.
+
+        This template uses a simplified form of the Pitzer correlation, valid
+        for gases at low to moderate pressures, to calculate the compressibility
+        factor (Z).
+
+        The governing equations are:
+            Z = 1 + (Pr / Tr) * (B0 + omega * B1)
+            B0 = 0.083 - (0.422 / Tr**1.6)
+            B1 = 0.139 - (0.172 / Tr**4.2)
+        Where:
+        - Z: Compressibility factor
+        - Tr, Pr: Reduced temperature and pressure
+        - omega: Acentric factor
+        - B0, B1: Second virial coefficients
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the compressibility factor.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs
+    R = 0.08314  # L·bar/(mol·K)
+
+    substance_name = random.choice(list(CRITICAL_PROPERTIES.keys()))
+    properties = CRITICAL_PROPERTIES[substance_name]
+    Tc = properties["Tc"]
+    Pc = properties["Pc"]
+    omega = properties["omega"]
+
+    # Generate random T and P in the gas phase (Tr > 1) and at low-moderate pressure
+    Tr = round(random.uniform(1.1, 3.0), 3)
+    Pr = round(random.uniform(0.1, 2.0), 3)
+    T = round(Tr * Tc, 2)
+    P = round(Pr * Pc, 2)
+
+    # 2. Perform the core calculation
+    # Calculate virial coefficients
+    B0 = 0.083 - 0.422 / (Tr**1.6)
+    B1 = 0.139 - 0.172 / (Tr**4.2)
+    # Calculate compressibility factor
+    Z = 1 + (Pr / Tr) * (B0 + omega * B1)
+    # Optional extension: Calculate molar volume
+    V = (Z * R * T) / P
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"For {substance_name} at a temperature of {T} K and a pressure of {P} bar, "
+        f"determine the compressibility factor, Z, using the Pitzer correlation for the "
+        f"second virial coefficient. The properties for {substance_name} are:\n"
+        f"Critical Temperature (Tc) = {Tc} K\n"
+        f"Critical Pressure (Pc) = {Pc} bar\n"
+        f"Acentric Factor (ω) = {omega}"
+    )
+
+    solution = (
+        f"**Step 1:** State the governing formulas.\n"
+        f"Z = 1 + (Pr / Tr) * (B0 + omega * B1)\n"
+        f"B0 = 0.083 - (0.422 / Tr**1.6)\n"
+        f"B1 = 0.139 - (0.172 / Tr**4.2)\n\n"
+
+        f"**Step 2:** Calculate the reduced temperature (Tr) and reduced pressure (Pr).\n"
+        f"Tr = T / Tc = {T} K / {Tc} K = {round(Tr, 4)}\n"
+        f"Pr = P / Pc = {P} bar / {Pc} bar = {round(Pr, 4)}\n\n"
+
+        f"**Step 3:** Calculate the virial equation coefficients, B0 and B1.\n"
+        f"B0 = 0.083 - (0.422 / {round(Tr, 4)}**1.6) = {round(B0, 4)}\n"
+        f"B1 = 0.139 - (0.172 / {round(Tr, 4)}**4.2) = {round(B1, 4)}\n\n"
+
+        f"**Step 4:** Substitute all values to calculate the compressibility factor (Z).\n"
+        f"Z = 1 + ({round(Pr, 4)} / {round(Tr, 4)}) * ({round(B0, 4)} + {omega} * {round(B1, 4)})\n"
+        f"Z = 1 + {round(Pr / Tr, 4)} * ({round(B0 + omega * B1, 4)})\n"
+        f"Z = {round(Z, 4)}\n\n"
+
+        f"(Optional) **Step 5:** Calculate the molar volume (V).\n"
+        f"V = Z * R * T / P = ({round(Z, 4)} * {R} * {T}) / {P} = {round(V, 4)} L/mol\n\n"
+
+        f"**Answer:** The compressibility factor, Z, for {substance_name} at the given conditions is **{round(Z, 4)}**."
+    )
+
+    return question, solution
+
+
+# Template 6 (Advanced)
+def template_vdw_solve_for_volume():
+    """
+    Molar Volume from the Van der Waals Equation
+
+    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.
+
+        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.
+
+        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
+
+    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
+    R = 0.08314  # L·bar/(mol·K)
+
+    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]
+
+    # 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"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"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 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 4:** Interpret the physical significance of the roots.\n"
+    )
+
+    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
+
+
+# Template 7 (Advanced)
+def template_work_isothermal_virial():
+    """
+    Work of Isothermal Compression for a Virial Gas
+
+    Scenario:
+        Calculating the work (W) for a mechanically reversible, isothermal
+        process requires integrating the pressure (P) with respect to volume (V).
+        For a non-ideal gas described by the virial equation, the P-V
+        relationship is more complex than the ideal gas law, leading to a
+        different result for the work of compression.
+
+        This template calculates work by first determining the second virial
+        coefficient (B) and the initial/final state properties (V1, V2), and
+        then applying the analytical integral of the virial equation.
+
+        The governing equations are:
+            P = R*T * (1/V + B/V**2)
+            W = - integral(P dV) from V1 to V2
+            W = -[R*T*ln(V2/V1) - B*R*T*(1/V2 - 1/V1)]
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the work of compression.
+            - str: A step-by-step solution showing the calculation and comparison
+                   to the ideal gas case.
+    """
+    # 1. Parameterize the inputs
+    R = 0.08314  # L·bar/(mol·K)
+
+    substance_name = random.choice(list(CRITICAL_PROPERTIES.keys()))
+    properties = CRITICAL_PROPERTIES[substance_name]
+    Tc = properties["Tc"]
+    Pc = properties["Pc"]
+    omega = properties["omega"]
+
+    # Generate conditions in the gas phase (Tr > 1) at moderate pressures
+    Tr = round(random.uniform(1.2, 3.0), 3)
+    T = round(Tr * Tc, 2)
+    
+    P1_r = round(random.uniform(0.5, 2.0), 2)
+    P2_r = round(random.uniform(2.5, 5.0), 2)
+    P1 = round(P1_r * Pc, 2)
+    P2 = round(P2_r * Pc, 2)
+
+    # 2. Perform the core calculation
+    # Calculate B
+    B0 = 0.083 - 0.422 / (Tr**1.6)
+    B1 = 0.139 - 0.172 / (Tr**4.2)
+    B = (R * Tc / Pc) * (B0 + omega * B1) # Units: L/mol
+
+    # Calculate initial and final states
+    Z1 = 1 + (B * P1) / (R * T)
+    Z2 = 1 + (B * P2) / (R * T)
+    V1 = (Z1 * R * T) / P1
+    V2 = (Z2 * R * T) / P2
+
+    # Calculate work using the integrated virial equation
+    term1 = R * T * math.log(V2 / V1)
+    term2 = -B * R * T * ((1/V2) - (1/V1))
+    W_virial_Lbar = -(term1 + term2)
+    W_virial_J = W_virial_Lbar * 100  # Convert L·bar to Joules
+
+    # For comparison, calculate ideal gas work
+    W_ideal_Lbar = -R * T * math.log(P1 / P2)
+    W_ideal_J = W_ideal_Lbar * 100
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"Calculate the work in J/mol required to isothermally and reversibly "
+        f"compress 1 mole of {substance_name} from {P1} bar to {P2} bar at a "
+        f"constant temperature of {T} K. Base your calculation on the virial "
+        f"equation of state truncated to two terms. The properties for {substance_name} are:\n"
+        f"Tc = {Tc} K, Pc = {Pc} bar, ω = {omega}"
+    )
+
+    solution = (
+        f"**Step 1:** Define the pressure from the virial equation and find the analytical integral for work.\n"
+        f"P = RT(1/V + B/V²)\n"
+        f"The integrated form is: W = -[RT·ln(V2/V1) - BRT(1/V2 - 1/V1)]\n\n"
+
+        f"**Step 2:** Calculate the second virial coefficient (B) at T = {T} K.\n"
+        f"Reduced Temperature, Tr = T/Tc = {T}/{Tc} = {Tr}\n"
+        f"B0 = 0.083 - 0.422 / ({Tr})**1.6 = {round(B0, 4)}\n"
+        f"B1 = 0.139 - 0.172 / ({Tr})**4.2 = {round(B1, 4)}\n"
+        f"B = (R·Tc/Pc) * (B0 + ω·B1) = {round(B, 5)} L/mol\n\n"
+
+        f"**Step 3:** Determine the initial (V1) and final (V2) molar volumes.\n"
+        f"Z1 = 1 + B·P1/(R·T) = 1 + ({round(B, 5)}*{P1})/({R}*{T}) = {round(Z1, 4)}\n"
+        f"V1 = Z1·R·T/P1 = {round(V1, 5)} L/mol\n"
+        f"Z2 = 1 + B·P2/(R·T) = 1 + ({round(B, 5)}*{P2})/({R}*{T}) = {round(Z2, 4)}\n"
+        f"V2 = Z2·R·T/P2 = {round(V2, 5)} L/mol\n\n"
+
+        f"**Step 4:** Substitute V1 and V2 into the integrated work equation.\n"
+        f"W = -[{round(R*T, 2)}·ln({round(V2, 5)}/{round(V1, 5)}) - {round(B*R*T, 3)}(1/{round(V2, 5)} - 1/{round(V1, 5)})]\n"
+        f"W = -[{round(term1, 2)} + {round(term2, 2)}] = {round(W_virial_Lbar, 2)} L·bar/mol\n\n"
+
+        f"**Step 5:** Convert the work to the required units (J/mol).\n"
+        f"Since 1 L·bar = 100 J:\n"
+        f"W = {round(W_virial_Lbar, 2)} L·bar/mol * 100 J/(L·bar) = {round(W_virial_J, 0)} J/mol\n\n"
+
+        f"**For Comparison:** The work required for an ideal gas is W_ideal = -RT·ln(P1/P2) = {round(W_ideal_J, 0)} J/mol. "
+        f"The deviation shows the effect of intermolecular forces accounted for by the virial equation.\n\n"
+
+        f"**Answer:** The required work of compression is approximately **{round(W_virial_J, 0)} J/mol**."
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each volumetric properties of pure fluids template with 
+    different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/chemical_engineering/thermodynamics/volumetric_properties_pure_fluids.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_ideal_gas_volume, "ideal_gas_volume", "Easy"),
+        (template_two_phase_specific_volume, "two_phase_specific_volume", "Easy"),
+        (template_rackett_equation_volume, "rackett_equation_volume", "Easy"),
+        (template_vdw_solve_for_pressure, "vdw_solve_for_pressure", "Intermediate"),
+        (template_pitzer_correlation_z, "pitzer_correlation_z", "Intermediate"),
+        (template_vdw_solve_for_volume, "vdw_solve_for_volume", "Advanced"),
+        (template_work_isothermal_virial, "work_isothermal_virial", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "chemical_engineering",
+                "domain": "thermodynamics",
+                "area": "volumetric_properties_pure_fluids",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,339 @@
+import random
+import math
+from data.templates.branches.chemical_engineering.constants import COMMON_LIQUIDS, GRAVITATIONAL_ACCELERATION
+
+
+# Template 1 (Easy)
+def template_falling_film_max_velocity():
+    """
+    Falling Film Maximum Velocity Calculation
+
+    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.
+
+        Core Equation:
+            v_z_max = (rho * g * delta^2 * cos(beta)) / (2 * mu)
+
+    Returns:
+        tuple: A tuple containing:
+            - 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
+    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)
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A thin film of {fluid_name} is flowing down a flat surface inclined at an "
+        f"angle of {inclination_angle_deg} degrees from the vertical. The film thickness is "
+        f"measured to be {film_thickness_mm} mm.\n\n"
+        f"Given the fluid's density is {fluid_density} kg/m^3 and its viscosity is "
+        f"{fluid_viscosity} Pa·s, calculate the maximum velocity of the film (at the "
+        f"liquid-air interface). Assume the flow is laminar.\n\n"
+        f"Use a value of g = {g} m/s^2."
+    )
+
+    solution = (
+        f"**Step 1:** Identify Given Information\n"
+        f"First, we list the known values from the problem statement.\n"
+        f"- Fluid: {fluid_name}\n"
+        f"- Fluid Density (rho): {fluid_density} kg/m^3\n"
+        f"- Fluid Viscosity (mu): {fluid_viscosity} Pa·s\n"
+        f"- Film Thickness (delta): {film_thickness_mm} mm\n"
+        f"- Inclination Angle (beta): {inclination_angle_deg} degrees\n"
+        f"- Gravitational Acceleration (g): {g} m/s^2\n\n"
+        
+        f"**Step 2:** Perform Unit Conversions\n"
+        f"The core equation requires all units to be in the SI base system. We must convert the film thickness from millimeters to meters.\n"
+        f"delta = {film_thickness_mm} mm * (1 m / 1000 mm) = {film_thickness_m} m\n\n"
+        
+        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"**Step 4:** Substitute Values into the Equation\n"
+        f"Now, we substitute our known values (with correct units) into the equation.\n"
+        f"v_z_max = (({fluid_density} kg/m^3) * ({g} m/s^2) * ({film_thickness_m} m)^2 * cos({inclination_angle_deg} deg)) / (2 * ({fluid_viscosity} Pa·s))\n\n"
+        
+        f"**Step 5:** Calculate the Final Velocity\n"
+        f"Performing the calculation gives the maximum velocity.\n"
+        f"v_z_max = {round(v_max, 5)} m/s\n\n"
+        
+        f"**Answer:** The maximum velocity of the {fluid_name} film is {round(v_max, 5)} m/s."
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_hagen_poiseuille_flowrate():
+    """
+    Hagen-Poiseuille Volumetric Flow Rate Calculation
+
+    Scenario:
+        This template calculates the volumetric flow rate (Q) for a fluid
+        experiencing laminar flow through a straight, circular pipe of
+        constant cross-section. It's based on the exact solution for
+        pressure-driven flow derived from a shell momentum balance.
+
+        Core Equation (Hagen-Poiseuille Equation):
+            Q = (pi * (P0 - PL) * R^4) / (8 * mu * L)
+
+    Returns:
+        tuple: A tuple containing:
+            - 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)
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A fluid, {fluid_name}, is flowing through a smooth circular pipe. "
+        f"The pipe has an inner radius of {pipe_radius_cm} cm and a total length of {pipe_length_m} m. "
+        f"The pressure drop across the length of the pipe is measured to be {pressure_drop_kPa} kPa.\n\n"
+        f"Given that the viscosity of {fluid_name} is approximately {fluid_viscosity_cP:.2f} cP, "
+        f"calculate the volumetric flow rate (Q) in m^3/s. Assume the flow is laminar."
+    )
+
+    solution = (
+        f"**Step 1:** Identify Given Information\n"
+        f"First, we list the known values from the problem statement.\n"
+        f"- Fluid: {fluid_name}\n"
+        f"- Pipe Radius (R): {pipe_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_cP:.2f} cP\n\n"
+
+        f"**Step 2:** Perform Unit Conversions\n"
+        f"The Hagen-Poiseuille equation requires all units to be in the SI base system. We must convert the radius, pressure drop, and viscosity.\n"
+        f"- Radius: R = {pipe_radius_cm} cm * (1 m / 100 cm) = {pipe_radius_m} m\n"
+        f"- Pressure Drop: P0 - PL = {pressure_drop_kPa} kPa * (1000 Pa / 1 kPa) = {pressure_drop_Pa} Pa\n"
+        f"- Viscosity: mu = {fluid_viscosity_cP:.2f} cP * (1 Pa·s / 1000 cP) = {fluid_viscosity_Pas} Pa·s\n\n"
+
+        f"**Step 3:** State the Core Equation\n"
+        f"The volumetric flow rate (Q) for laminar flow in a circular pipe is given by the Hagen-Poiseuille equation:\n"
+        f"Q = (pi * (P0 - PL) * R^4) / (8 * mu * L)\n\n"
+
+        f"**Step 4:** Substitute Values into the Equation\n"
+        f"Now, we substitute the converted SI values into the equation.\n"
+        f"Q = (pi * ({pressure_drop_Pa} Pa) * ({pipe_radius_m} m)^4) / (8 * ({fluid_viscosity_Pas} Pa·s) * ({pipe_length_m} m))\n\n"
+
+        f"**Step 5:** Calculate the Final Flow Rate\n"
+        f"Performing the calculation gives the volumetric flow rate.\n"
+        f"Q = {q_flow_rate:.6f} m^3/s\n\n"
+
+        f"**Answer:** The volumetric flow rate of {fluid_name} through the pipe is {q_flow_rate:.6f} m^3/s."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_annulus_flowrate():
+    """
+    Volumetric Flow Rate in an Annulus Calculation
+
+    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.
+
+        Core Equation:
+            Q = (pi*(P0-PL)*R^4)/(8*mu*L) * [(1-kappa^4) - ((1-kappa^2)^2 / ln(1/kappa))]
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the volumetric flow rate in an annulus.
+            - 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]
+
+    # 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
+    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
+    outer_radius_m = outer_radius_cm / 100.0
+    inner_radius_m = inner_radius_cm / 100.0
+    
+    # Convert pressure drop from kPa to Pa
+    pressure_drop_Pa = pressure_drop_kPa * 1000
+
+    # The dimensionless ratio, kappa
+    kappa_val = inner_radius_m / outer_radius_m
+
+    # 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)
+    shape_factor = (1 - kappa_val**4) - (((1 - kappa_val**2)**2) / math.log(1 / kappa_val))
+    q_flow_rate = term1 * shape_factor
+
+    # 3. Generate the question and solution strings
+    question = (
+        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"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."
+    )
+
+    solution = (
+        f"**Step 1:** Identify Given Information\n"
+        f"First, we list the known values from the problem statement.\n"
+        f"- Fluid: {fluid_name}\n"
+        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"**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"**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"**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"**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"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"Answer: The volumetric flow rate of {fluid_name} through the annular space is {q_flow_rate:.7f} m^3/s."
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each shell momentum balances and velocity distributions in 
+    laminar flow template with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/chemical_engineering/transport_phenomena/shell_momentum_balances.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_falling_film_max_velocity, "falling_film_max_velocity", "Easy"),
+        (template_hagen_poiseuille_flowrate, "hagen_poiseuille_flowrate", "Easy"),
+        (template_annulus_flowrate, "annulus_flowrate", "Intermediate"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "chemical_engineering",
+                "domain": "transport_phenomena",
+                "area": "shell_momentum_balances",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,514 @@
+import random
+import math
+from data.templates.branches.chemical_engineering.constants import COMMON_LIQUIDS, COMMON_GASES, GAS_MOLECULAR_PARAMS, POWER_LAW_FLUIDS
+
+
+# Template 1 (Easy)
+def template_newtons_law_shear_stress():
+    """
+    Shear Stress and Force Calculation for Flow Between Parallel Plates
+
+    Scenario:
+        This template models Couette flow, a classic fluid dynamics problem where a layer
+        of fluid is sheared between two parallel plates. One plate is stationary, and
+        the other moves at a constant velocity. Assuming a linear velocity profile,
+        we use Newton's Law of Viscosity to find the shear stress in the fluid and
+        the force required to move the plate.
+
+        The relevant equations are:
+            - Velocity Gradient: dvx/dy = V / Y
+            - Shear Stress: tau_yx = mu * (dvx/dy)
+            - Force: F = tau_yx * A
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute shear stress and force.
+            - str: A step-by-step solution showing the calculations.
+    """
+    # 1. Parameterize the inputs with random values
+    fluid_name, (density, viscosity) = random.choice(list(COMMON_LIQUIDS.items()))
+    V = round(random.uniform(0.1, 2.0), 2)
+    Y_cm = round(random.uniform(0.1, 2.5), 2)
+    Y_m = Y_cm / 100
+    A = round(random.uniform(0.5, 5.0), 2)
+
+    # 2. Perform the core calculation
+    velocity_gradient = V / Y_m
+    shear_stress = viscosity * velocity_gradient
+    force = shear_stress * A
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"Two large parallel plates with an area of {A} m^2 each are separated by a "
+        f"thin film of {fluid_name} that is {Y_cm} cm thick. The top plate is moved "
+        f"at a constant velocity of {V} m/s, while the bottom plate is held stationary.\n\n"
+        f"Assuming the fluid exhibits Newtonian behavior and a linear velocity profile, calculate:\n"
+        f"a) The shear stress (tau_yx) exerted on the fluid.\n"
+        f"b) The total force (F) required to move the top plate at the given velocity."
+    )
+
+    solution = (
+        f"**Given Information:**\n"
+        f"- Fluid: {fluid_name}\n"
+        f"- Dynamic Viscosity of {fluid_name} (mu): {viscosity:.2e} Pa·s\n"
+        f"- Plate Area (A): {A} m^2\n"
+        f"- Plate Velocity (V): {V} m/s\n"
+        f"- Distance between plates (Y): {Y_cm} cm = {Y_m} m\n\n"
+        
+        f"**Step 1:** Calculate the velocity gradient (dvx/dy).\n"
+        f"For a linear velocity profile between a stationary and a moving plate, the gradient is constant:\n"
+        f"dvx/dy = V / Y\n"
+        f"dvx/dy = {V} m/s / {Y_m} m = {velocity_gradient:.2f} 1/s\n\n"
+        
+        f"**Step 2:** Calculate the shear stress (tau_yx).\n"
+        f"Using Newton's Law of Viscosity:\n"
+        f"tau_yx = mu * (dvx/dy)\n"
+        f"tau_yx = ({viscosity:.2e} Pa·s) * ({velocity_gradient:.2f} 1/s)\n"
+        f"tau_yx = {shear_stress:.3f} Pa\n\n"
+        
+        f"**Step 3:** Calculate the force (F).\n"
+        f"Force is the shear stress acting over the entire area of the plate:\n"
+        f"F = tau_yx * A\n"
+        f"F = ({shear_stress:.3f} Pa) * ({A} m^2)\n"
+        f"F = {force:.3f} N\n\n"
+        
+        f"**Answer:**\n"
+        f"a) The shear stress in the fluid is **{shear_stress:.3f} Pa**.\n"
+        f"b) The force required to move the plate is **{force:.3f} N**."
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_kinematic_viscosity():
+    """
+    Kinematic Viscosity Calculation
+
+    Scenario:
+        This template tests the definition of kinematic viscosity (ν), which is the
+        ratio of the dynamic viscosity (μ) to the density (ρ) of a fluid. It is a
+        measure of a fluid's internal resistance to flow under gravitational forces.
+
+        The relevant equations are:
+            - Kinematic Viscosity: ν = μ / ρ
+            - Unit Conversion: 1 m²/s = 10,000 Stokes (St)
+
+    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.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Combine liquids and gases into one dictionary for random selection
+    all_fluids = {**COMMON_LIQUIDS, **COMMON_GASES}
+    fluid_name, (density, viscosity) = random.choice(list(all_fluids.items()))
+    
+    # Randomly choose the target units for the answer
+    target_units = random.choice(["m^2/s", "Stokes (St)"])
+
+    # 2. Perform the core calculation
+    
+    # Calculate kinematic viscosity in SI units (m²/s)
+    nu_si = viscosity / density
+    
+    # Perform unit conversion if necessary
+    final_nu = nu_si
+    if "Stokes" in target_units:
+        final_nu = nu_si * 10000
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"The dynamic viscosity (μ) of {fluid_name} at standard conditions is approximately "
+        f"{viscosity:.2e} Pa·s, and its density (ρ) is {density:.3f} kg/m³.\n\n"
+        f"Calculate the kinematic viscosity (ν) of {fluid_name} in units of **{target_units}**."
+    )
+
+    solution = (
+        f"**Given Information:**\n"
+        f"- Fluid: {fluid_name}\n"
+        f"- Dynamic Viscosity (μ): {viscosity:.2e} Pa·s\n"
+        f"- Density (ρ): {density:.3f} kg/m³\n\n"
+        
+        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"**Step 2:** Calculate the kinematic viscosity in SI units (m²/s).\n"
+        f"Substitute the given values into the formula:\n"
+        f"ν = ({viscosity:.2e} Pa·s) / ({density:.3f} kg/m³)\n"
+        f"ν = {nu_si:.3e} m²/s\n\n"
+    )
+    
+    # Add the unit conversion step only if needed
+    if "Stokes" in target_units:
+        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"
+        )
+        
+    solution += (
+        f"**Answer:**\n"
+        f"The kinematic viscosity of {fluid_name} is **{final_nu:.4f} {target_units}**."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_gas_viscosity_kinetic_theory():
+    """
+    Gas Viscosity Estimation from Kinetic Theory
+
+    Scenario:
+        This template uses the Chapman-Enskog equation, derived from the kinetic
+        theory of gases, to estimate the dynamic viscosity (μ) of a low-density gas.
+        This model connects a macroscopic property (viscosity) to molecular
+        properties (molar mass, size).
+
+        The relevant equation is:
+            μ = (2.6693e-6 * sqrt(M*T)) / (σ² * Ω_μ)
+        
+        Where:
+            - μ = viscosity in Pa·s
+            - M = Molar Mass in g/mol
+            - T = Absolute Temperature in K
+            - σ = Lennard-Jones molecular diameter in Angstroms (Å)
+            - Ω_μ = Collision integral (dimensionless)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to estimate the gas viscosity.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs with random values
+    gas_name, (molar_mass, sigma, epsilon) = random.choice(list(GAS_MOLECULAR_PARAMS.items()))
+    
+    # Temperature in Kelvin
+    temperature_K = random.randint(250, 600)
+    
+    # Collision integral (dimensionless), kept close to 1.0 for simplicity
+    omega_mu = round(random.uniform(0.95, 1.05), 3)
+
+    # 2. Perform the core calculation
+    
+    # Numerator of the Chapman-Enskog equation
+    numerator = 2.6693e-6 * math.sqrt(molar_mass * temperature_K)
+    
+    # Denominator of the Chapman-Enskog equation
+    denominator = (sigma**2) * omega_mu
+    
+    # Final viscosity calculation
+    viscosity = numerator / denominator
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"Estimate the dynamic viscosity (μ) of {gas_name} gas at a temperature of {temperature_K} K.\n\n"
+        f"Use the Chapman-Enskog equation for low-density gases:\n"
+        f"μ = (2.6693e-6 * sqrt(M*T)) / (σ^2 * Ω_μ)\n\n"
+        f"You are given the following parameters for {gas_name}:\n"
+        f"- Molar Mass (M) = {molar_mass} g/mol\n"
+        f"- Lennard-Jones diameter (σ) = {sigma} Å\n"
+        f"- Collision Integral (Ω_μ) = {omega_mu}\n\n"
+        f"Provide your answer in units of Pascal-seconds (Pa·s)."
+    )
+
+    solution = (
+        f"**Given Information:**\n"
+        f"- Gas: {gas_name}\n"
+        f"- Temperature (T): {temperature_K} K\n"
+        f"- Molar Mass (M): {molar_mass} g/mol\n"
+        f"- Lennard-Jones diameter (σ): {sigma} Å\n"
+        f"- Collision Integral (Ω_μ): {omega_mu}\n\n"
+        
+        f"**Step 1:** State the Chapman-Enskog equation.\n"
+        f"The formula for estimating the viscosity of a low-density gas is:\n"
+        f"μ = (2.6693e-6 * sqrt(M*T)) / (σ^2 * Ω_μ)\n\n"
+        
+        f"**Step 2:** Substitute the given values into the equation.\n"
+        f"μ = (2.6693e-6 * sqrt({molar_mass} * {temperature_K})) / (({sigma})^2 * {omega_mu})\n\n"
+        
+        f"**Step 3:** Calculate the numerator and denominator.\n"
+        f"- Numerator = 2.6693e-6 * sqrt({molar_mass * temperature_K:.2f}) = {numerator:.4e}\n"
+        f"- Denominator = {sigma**2:.3f} * {omega_mu} = {denominator:.3f}\n\n"
+        
+        f"**Step 4:** Calculate the final viscosity.\n"
+        f"μ = {numerator:.4e} / {denominator:.3f}\n"
+        f"μ = {viscosity:.3e} Pa·s\n\n"
+        
+        f"**Answer:**\n"
+        f"The estimated dynamic viscosity of {gas_name} at {temperature_K} K is **{viscosity:.3e} Pa·s**."
+    )
+
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_reynolds_number_flow_regime():
+    """
+    Reynolds Number and Flow Regime Calculation
+
+    Scenario:
+        This template introduces the Reynolds number (Re), the dimensionless ratio of
+        inertial forces to viscous forces in a fluid. Its value is critical for
+        predicting whether a flow is smooth (laminar) or chaotic (turbulent).
+        The calculation depends on a characteristic length, which varies with geometry.
+
+        The relevant equation is:
+            Re = (ρ * v * L) / μ
+        
+        Where:
+            - ρ = density
+            - v = average velocity
+            - L = characteristic length (e.g., pipe diameter or plate length)
+            - μ = dynamic viscosity
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute the Reynolds number and find the flow regime.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    all_fluids = {**COMMON_LIQUIDS, **COMMON_GASES}
+    fluid_name, (density, viscosity) = random.choice(list(all_fluids.items()))
+    
+    # Randomly choose a flow geometry
+    geometry = random.choice(['pipe', 'flat plate'])
+    
+    if geometry == 'pipe':
+        # Pipe flow parameters
+        characteristic_length = round(random.uniform(0.01, 0.5), 3) # Diameter in m
+        velocity = round(random.uniform(0.1, 5.0), 2)
+        length_symbol = "D"
+        length_name = "diameter"
+        scenario_description = f"{fluid_name} is flowing through a smooth circular pipe with an internal {length_name} of {characteristic_length} m."
+        
+    else: # flat plate
+        # Flat plate flow parameters
+        characteristic_length = round(random.uniform(0.1, 2.0), 2) # Length in m
+        velocity = round(random.uniform(1.0, 20.0), 1)
+        length_symbol = "L"
+        length_name = "length"
+        scenario_description = f"A flow of {fluid_name} moves over a smooth, thin flat plate with a {length_name} of {characteristic_length} m."
+
+    # 2. Perform the core calculation
+    reynolds_number = (density * velocity * characteristic_length) / viscosity
+
+    # Determine flow regime based on geometry
+    if geometry == 'pipe':
+        if reynolds_number < 2300:
+            regime = "laminar"
+            regime_explanation = f"Since Re = {reynolds_number:,.0f} is less than 2300, the flow is in the **laminar** regime."
+        elif reynolds_number < 4000:
+            regime = "transitional"
+            regime_explanation = f"Since Re = {reynolds_number:,.0f} is between 2300 and 4000, the flow is in the **transitional** regime."
+        else:
+            regime = "turbulent"
+            regime_explanation = f"Since Re = {reynolds_number:,.0f} is greater than 4000, the flow is in the **turbulent** regime."
+    else: # flat plate
+        if reynolds_number < 500000:
+            regime = "laminar"
+            regime_explanation = f"Since Re = {reynolds_number:,.0f} is less than the critical value of 500,000, the flow is considered **laminar**."
+        else:
+            regime = "turbulent"
+            regime_explanation = f"Since Re = {reynolds_number:,.0f} is greater than the critical value of 500,000, the flow is considered **turbulent**."
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"{scenario_description} The average velocity of the flow is {velocity} m/s.\n\n"
+        f"The properties of {fluid_name} are:\n"
+        f"- Density (ρ) = {density} kg/m³\n"
+        f"- Dynamic Viscosity (μ) = {viscosity:.2e} Pa·s\n\n"
+        f"Based on this information:\n"
+        f"a) Calculate the Reynolds number (Re).\n"
+        f"b) Determine the flow regime (laminar, transitional, or turbulent)."
+    )
+
+    solution = (
+        f"**Given Information:**\n"
+        f"- Fluid: {fluid_name}\n"
+        f"- Density (ρ): {density} kg/m³\n"
+        f"- Dynamic Viscosity (μ): {viscosity:.2e} Pa·s\n"
+        f"- Average Velocity (v): {velocity} m/s\n"
+        f"- Characteristic Length ({length_symbol}): {characteristic_length} m ({length_name} of the {geometry})\n\n"
+        
+        f"**Step 1:** State the formula for the Reynolds number.\n"
+        f"The Reynolds number is the ratio of inertial forces to viscous forces.\n"
+        f"Re = (ρ * v * {length_symbol}) / μ\n\n"
+        
+        f"**Step 2:** Substitute the values and calculate Re.\n"
+        f"Re = ({density} * {velocity} * {characteristic_length}) / {viscosity:.2e}\n"
+        f"Re = {reynolds_number:,.0f}\n\n"
+        
+        f"**Step 3:** Determine the flow regime.\n"
+        f"For flow in a **{geometry}**, we compare the calculated Re to the standard critical values.\n"
+        f"{regime_explanation}\n\n"
+
+        f"**Answer:**\n"
+        f"a) The Reynolds number is approximately **{reynolds_number:,.0f}**.\n"
+        f"b) The flow regime is **{regime}**."
+    )
+
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_power_law_fluid_shear():
+    """
+    Shear Stress Calculation for a Power-Law Fluid
+
+    Scenario:
+        This template extends Newton's Law of Viscosity to non-Newtonian fluids
+        that follow the Ostwald-de Waele (Power Law) model. Unlike Newtonian fluids,
+        their viscosity is dependent on the shear rate. This model is crucial for
+        describing common substances like paint, ketchup, and suspensions.
+
+        The relevant equations are:
+            - Shear Stress: τ_yx = K * (dvx/dy)^n
+            - Apparent Viscosity: η = K * |dvx/dy|^(n-1)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for shear stress and apparent viscosity.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    fluid_name, (K, n) = random.choice(list(POWER_LAW_FLUIDS.items()))
+    
+    # Velocity of the moving plate in m/s
+    V = round(random.uniform(0.1, 2.0), 2)
+    
+    # Distance between plates in cm, converted to meters for calculation
+    Y_cm = round(random.uniform(0.5, 5.0), 2)
+    Y_m = Y_cm / 100
+
+    # 2. Perform the core calculation
+    velocity_gradient = abs(V / Y_m)
+    shear_stress = K * (velocity_gradient ** n)
+    apparent_viscosity = K * (velocity_gradient ** (n - 1))
+    
+    # Determine the fluid behavior for the explanation
+    if n < 1:
+        behavior = f"shear-thinning (pseudoplastic), because its power-law index n ({n}) is less than 1."
+    elif n > 1:
+        behavior = f"shear-thickening (dilatant), because its power-law index n ({n}) is greater than 1."
+    else:
+        behavior = "Newtonian, because its power-law index n is exactly 1."
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A non-Newtonian fluid, {fluid_name.lower()}, is placed between two parallel plates "
+        f"separated by {Y_cm} cm. The top plate moves at a constant velocity of {V} m/s, "
+        f"creating a linear velocity profile in the fluid.\n\n"
+        f"The fluid follows the power-law model with the following parameters:\n"
+        f"- Consistency Index (K) = {K} Pa·s^n\n"
+        f"- Power-Law Index (n) = {n}\n\n"
+        f"Calculate:\n"
+        f"a) The shear stress (τ_yx) on the fluid.\n"
+        f"b) The apparent viscosity (η) at this shear rate."
+    )
+
+    solution = (
+        f"**Given Information:**\n"
+        f"- Fluid: {fluid_name}\n"
+        f"- Consistency Index (K): {K} Pa·s^n\n"
+        f"- Power-Law Index (n): {n}\n"
+        f"- Plate Velocity (V): {V} m/s\n"
+        f"- Plate Separation (Y): {Y_cm} cm = {Y_m} m\n\n"
+        
+        f"**Step 1:** Characterize the Fluid Behavior.\n"
+        f"The fluid is {behavior} This means its apparent viscosity will change with the rate of shear.\n\n"
+        
+        f"**Step 2:** Calculate the Velocity Gradient (Shear Rate).\n"
+        f"Assuming a linear velocity profile:\n"
+        f"Shear Rate (dvx/dy) = V / Y = {V} m/s / {Y_m} m = {velocity_gradient:.2f} 1/s\n\n"
+        
+        f"**Step 3:** Calculate the Shear Stress (τ_yx).\n"
+        f"Using the power-law formula: τ_yx = K * (dvx/dy)^n\n"
+        f"τ_yx = {K} * ({velocity_gradient:.2f})^{n}\n"
+        f"τ_yx = {shear_stress:.3f} Pa\n\n"
+        
+        f"**Step 4:** Calculate the Apparent Viscosity (η).\n"
+        f"Apparent viscosity is the effective viscosity at a specific shear rate.\n"
+        f"η = K * |dvx/dy|^(n-1)\n"
+        f"η = {K} * ({velocity_gradient:.2f})^({n - 1})\n"
+        f"η = {apparent_viscosity:.4f} Pa·s\n\n"
+        
+        f"**Answer:**\n"
+        f"a) The shear stress on the fluid is **{shear_stress:.3f} Pa**.\n"
+        f"b) The apparent viscosity at this shear rate is **{apparent_viscosity:.4f} Pa·s**."
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each viscosity and mechanisms of momentum transport template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/chemical_engineering/transport_phenomena/viscosity_and_momentum_transport.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_newtons_law_shear_stress, "newtons_law_shear_stress", "Easy"),
+        (template_kinematic_viscosity, "kinematic_viscosity", "Easy"),
+        (template_gas_viscosity_kinetic_theory, "gas_viscosity_kinetic_theory", "Intermediate"),
+        (template_reynolds_number_flow_regime, "reynolds_number_flow_regime", "Intermediate"),
+        (template_power_law_fluid_shear, "power_law_fluid_shear", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "chemical_engineering",
+                "domain": "transport_phenomena",
+                "area": "viscosity_and_momentum_transport",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

data/templates/branches/electrical_engineering/constants.py

@@ -0,0 +1,67 @@
+import math
+
+# Speed of light in vacuum (m/s)
+C0 = 299792458 
+
+# Dictionary of common media and their approximate phase velocities for EM waves
+MEDIA_VELOCITIES = {
+    # Gases (at 0°C and 1 atm, for visible light ~589 nm)
+    "Vacuum": C0,                     
+    "Air (at sea level)": C0 / 1.000293, 
+    "Helium": C0 / 1.000036,          
+    "Carbon Dioxide": C0 / 1.00045,   
+    
+    # Liquids (for visible light ~589 nm)
+    "Water (distilled, 20°C)": C0 / 1.333,  
+    "Ethanol": C0 / 1.36,             
+    "Glycerine": C0 / 1.473,          
+    "Benzene": C0 / 1.501,            
+    "Carbon Disulfide": C0 / 1.628,   # notable for high dispersion
+    
+    # Solids (for visible light ~589 nm)
+    "Ice": C0 / 1.31,                 
+    "Teflon (PTFE)": C0 / 1.35,       
+    "Fused Silica (Glass)": C0 / 1.458, 
+    "Crown Glass (typical)": C0 / 1.52, 
+    "Polyethylene": C0 / 1.54,        
+    "Polystyrene": C0 / 1.59,         
+    "Flint Glass (dense)": C0 / 1.65, 
+    "Sapphire": C0 / 1.77,            
+    "Glass (amorphous semiconductor)": C0 / 1.8, 
+    "Diamond": C0 / 2.42,             
+    "Gallium Phosphide (GaP)": C0 / 3.5, 
+    
+    # Special Cases (Important for RF/Microwave Engineering)
+    "Human Body Tissue (muscle, ~3 GHz)": C0 / 7.14, # Relative permittivity ε_r ~51, n=√ε_r
+}
+
+# Permittivity of free space in Farads per meter (F/m)
+EPSILON_0 = 8.854e-12
+
+# Value ranges for random parameter generation to ensure diverse problems.
+# Frequencies are kept as integers for clarity in the problem statement.
+FREQUENCY_RANGE_HZ = (50, 2000)
+AMPLITUDE_RANGE = (1.0, 50.0)
+PHASE_RANGE_DEG = (-180, 180)
+PHASE_RANGE_RAD = (-math.pi, math.pi)
+
+# The continuous frequency Omega will be a multiple of pi. This range defines the multiplier.
+OMEGA_MULTIPLIER_RANGE = (100, 1000)
+
+SAMPLING_FREQ_RANGE_HZ = (1000, 8000)
+
+F0_RANGE_HZ = (500, 3000) 
+
+# The gain of the discrete-time system
+GAIN_K_RANGE = (0.5, 5.0)
+
+# The delay (in samples) of the discrete-time system
+DELAY_N0_RANGE = (1, 10)
+
+
+# The integer factor by which the signal is downsampled.
+DECIMATION_FACTOR_M_RANGE = (2, 5)
+
+# Define the pool for denominators of the omega_0 fraction.
+# Using larger numbers allows for more granularity in creating frequencies.
+OMEGA_DENOMINATOR_RANGE = (8, 20)

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

@@ -0,0 +1,570 @@
+import random
+import math
+
+
+# Template 1 (Easy)
+def template_signal_energy_power():
+    """
+    Signal Energy and Power Calculation
+
+    Scenario:
+        This template tests the ability to classify a signal as either an energy
+        signal (finite energy) or a power signal (finite average power) and to
+        calculate the corresponding value. It covers time-limited, time-unlimited
+        decaying, and periodic signals.
+
+    Core Equations:
+        Signal Energy: Eg = integral from -inf to inf of |g(t)|^2 dt
+        Signal Power: Pg = lim(T->inf) (1/T) * integral from -T/2 to T/2 of |g(t)|^2 dt
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to classify and calculate the energy/power of a signal.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    signal_type = random.choice(['rect_pulse', 'exp_decay', 'periodic'])
+    amplitude = random.randint(2, 20)
+    precision = 2
+
+    # Common text for all questions to ensure unit clarity
+    unit_context = "Assume the signal g(t) represents a voltage in Volts (V) across a 1-ohm resistor."
+
+    if signal_type == 'rect_pulse':
+        # --- Energy Signal: Rectangular Pulse ---
+        duration = random.randint(2, 10)
+        start_time = 0
+        end_time = start_time + duration
+        signal_expr = f"g(t) = {amplitude} for {start_time} <= t <= {end_time}, and 0 otherwise"
+        energy = (amplitude ** 2) * duration
+
+        question = (
+            f"Consider the signal defined as:\n"
+            f"{signal_expr}\n\n"
+            f"{unit_context}\n\n"
+            f"Is this an energy signal or a power signal? Calculate its total energy or "
+            f"average power accordingly."
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"The signal is {signal_expr}.\n\n"
+
+            f"**Step 1:** Classify the signal.\n"
+            f"The signal is non-zero only for a finite duration ({duration} seconds). "
+            f"Time-limited signals have finite energy and zero average power. "
+            f"Therefore, this is an **energy signal**.\n\n"
+
+            f"**Step 2:** State the formula for signal energy.\n"
+            f"The energy (Eg) of a signal g(t) is:\n"
+            f"Eg = integral from -inf to inf of |g(t)|^2 dt\n\n"
+
+            f"**Step 3:** Apply the formula to the given signal.\n"
+            f"Since the signal is non-zero only between t = {start_time} and t = {end_time}, the integral becomes:\n"
+            f"Eg = integral from {start_time} to {end_time} of ({amplitude})^2 dt = integral from {start_time} to {end_time} of {amplitude**2} dt\n\n"
+
+            f"**Step 4:** Calculate the integral.\n"
+            f"Eg = {amplitude**2} * [t] (from t={start_time} to {end_time})\n"
+            f"Eg = {amplitude**2} * ({end_time} - {start_time}) = {amplitude**2} * {duration} = {energy}\n\n"
+
+            f"**Answer:**\n"
+            f"The signal is an **energy signal** with a total energy of **{round(energy, precision)} Joules (V^2 * s)**."
+        )
+
+    elif signal_type == 'exp_decay':
+        # --- Energy Signal: Exponential Decay ---
+        alpha = random.randint(2, 10)
+        signal_expr = f"g(t) = {amplitude} * exp(-{alpha}*t) * u(t)"
+        energy = (amplitude ** 2) / (2 * alpha)
+
+        question = (
+            f"Consider the signal defined as:\n"
+            f"{signal_expr}\n"
+            f"where u(t) is the unit step function.\n\n"
+            f"{unit_context}\n\n"
+            f"Is this an energy signal or a power signal? Calculate its total energy or "
+            f"average power accordingly."
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"The signal is {signal_expr}.\n\n"
+
+            f"**Step 1:** Classify the signal.\n"
+            f"The signal is not time-limited, but it decays to zero as t approaches infinity. "
+            f"This means its total energy is finite. Therefore, this is an **energy signal**.\n\n"
+
+            f"**Step 2:** State the formula for signal energy.\n"
+            f"Eg = integral from -inf to inf of |g(t)|^2 dt\n\n"
+
+            f"**Step 3:** Apply the formula to the given signal.\n"
+            f"Due to the unit step function u(t), the integral's limits become 0 to infinity:\n"
+            f"Eg = integral from 0 to inf of ({amplitude} * exp(-{alpha}*t))^2 dt\n"
+            f"Eg = {amplitude**2} * integral from 0 to inf of exp(-{2*alpha}*t) dt\n\n"
+
+            f"**Step 4:** Calculate the integral.\n"
+            f"Eg = {amplitude**2} * [-1/{2*alpha} * exp(-{2*alpha}*t)] (from t=0 to inf)\n"
+            f"Eg = {amplitude**2} * ( (0) - (-1/{2*alpha} * exp(0)) ) = {amplitude**2} * (1/{2*alpha})\n"
+            f"Eg = {amplitude**2} / {2*alpha} = {energy}\n\n"
+
+            f"**Answer:**\n"
+            f"The signal is an **energy signal** with a total energy of **{round(energy, precision)} Joules (V^2 * s)**."
+        )
+
+    else: # signal_type == 'periodic'
+        # --- Power Signal: Periodic Sinusoid ---
+        frequency = random.randint(10, 100)
+        signal_expr = f"g(t) = {amplitude} * cos(2 * pi * {frequency} * t)"
+        power = (amplitude ** 2) / 2
+
+        question = (
+            f"Consider the signal defined as:\n"
+            f"{signal_expr}\n\n"
+            f"{unit_context}\n\n"
+            f"Is this an energy signal or a power signal? Calculate its total energy or "
+            f"average power accordingly."
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"The signal is {signal_expr}.\n\n"
+
+            f"**Step 1:** Classify the signal.\n"
+            f"The signal is periodic and continues for all time without decaying. Its total energy would be infinite. "
+            f"However, its average power over time is finite and non-zero. "
+            f"Therefore, this is a **power signal**.\n\n"
+
+            f"**Step 2:** State the formula for signal power.\n"
+            f"For a periodic signal with period T0, the average power (Pg) is calculated over one period:\n"
+            f"Pg = (1/T0) * integral over T0 of |g(t)|^2 dt\n\n"
+
+            f"**Step 3:** Apply the formula to the given signal.\n"
+            f"For any sinusoidal signal of the form A*cos(w*t + phi), the average power is a standard result:\n"
+            f"Pg = A^2 / 2\n"
+            f"This result is derived from integrating (A * cos(...))^2 over one full period.\n\n"
+
+            f"**Step 4:** Calculate the power.\n"
+            f"In this case, the amplitude A is {amplitude}.\n"
+            f"Pg = ({amplitude})^2 / 2\n"
+            f"Pg = {amplitude**2} / 2 = {power}\n\n"
+
+            f"**Answer:**\n"
+            f"The signal is a **power signal** with an average power of **{round(power, precision)} Watts (V^2)**."
+        )
+        
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_mean_variance():
+    """
+    Mean and Variance of a Random Variable
+
+    Scenario:
+        This template assesses the understanding of basic statistical properties of a
+        discrete random variable, specifically its central tendency (mean) and
+        dispersion (variance).
+
+    Core Equations:
+        Mean (Expected Value): mu_X = E[X] = sum(x_i * P(x_i))
+        Variance: sigma_X^2 = E[(X - mu_X)^2] = sum((x_i - mu_X)^2 * P(x_i))
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the mean and variance of a discrete random variable.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    num_values = random.randint(3, 5)
+    precision = 3
+
+    # Generate a set of unique, sorted integer values for the random variable
+    values = sorted(random.sample(range(-10, 21), num_values))
+
+    # Generate clean, rational probabilities that sum to 1
+    # Create random integer parts, sum them, and use that sum as the denominator
+    parts = [random.randint(1, 10) for _ in range(num_values)]
+    total_sum = sum(parts)
+    probabilities = [p / total_sum for p in parts]
+
+    # 2. Perform the core calculations
+    # Calculate the mean (expected value)
+    mean = sum(v * p for v, p in zip(values, probabilities))
+
+    # Calculate the variance
+    variance = sum(((v - mean) ** 2) * p for v, p in zip(values, probabilities))
+
+    # 3. Generate the question and solution strings
+    
+    # Format values and probabilities for display
+    values_str = "{" + ", ".join(map(str, values)) + "}"
+    probs_str = "{" + ", ".join([f"{p:.{precision}f}" for p in probabilities]) + "}"
+
+    question = (
+        f"A discrete random variable X can take the values {values_str} with "
+        f"corresponding probabilities {probs_str}, respectively.\n\n"
+        f"Calculate the mean (mu_X) and variance (sigma_X^2) of X."
+    )
+
+    # --- Build the solution string step-by-step ---
+
+    # Mean calculation steps
+    mean_calc_lhs = "mu_X = E[X]"
+    mean_calc_rhs = " + ".join([f"({v})({p:.{precision}f})" for v, p in zip(values, probabilities)])
+    mean_interm_vals = " + ".join([f"{v * p:.{precision}f}" for v, p in zip(values, probabilities)])
+    
+    # Variance calculation steps
+    var_calc_lhs = "sigma_X^2 = E[(X - mu_X)^2]"
+    var_calc_rhs = " + ".join(
+        [f"({v} - {mean:.{precision}f})^2({p:.{precision}f})" for v, p in zip(values, probabilities)]
+    )
+    var_interm_vals = " + ".join(
+        [f"({(v - mean):.{precision}f})^2({p:.{precision}f})" for v, p in zip(values, probabilities)]
+    )
+    var_final_vals = " + ".join(
+        [f"{((v - mean)**2 * p):.{precision}f}" for v, p in zip(values, probabilities)]
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Values: X = {values_str}\n"
+        f"Probabilities: P(X) = {probs_str}\n\n"
+        
+        f"**Step 1:** Calculate the Mean (mu_X).\n"
+        f"The formula for the mean (expected value) is:\n"
+        f"mu_X = sum(x_i * P(x_i))\n\n"
+        f"Plugging in the given values:\n"
+        f"{mean_calc_lhs} = {mean_calc_rhs}\n"
+        f"{mean_calc_lhs} = {mean_interm_vals}\n"
+        f"{mean_calc_lhs} = {mean:.{precision}f}\n\n"
+
+        f"**Step 2:** Calculate the Variance (sigma_X^2).\n"
+        f"The formula for variance is:\n"
+        f"sigma_X^2 = sum((x_i - mu_X)^2 * P(x_i))\n\n"
+        f"Using the calculated mean (mu_X = {mean:.{precision}f}):\n"
+        f"{var_calc_lhs} = {var_calc_rhs}\n"
+        f"{var_calc_lhs} = {var_interm_vals}\n"
+        f"{var_calc_lhs} = {var_final_vals}\n"
+        f"{var_calc_lhs} = {variance:.{precision}f}\n\n"
+
+        f"**Answer:**\n"
+        f"The mean of the random variable X is **{mean:.{precision}f}**.\n"
+        f"The variance of the random variable X is **{variance:.{precision}f}**."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_autocorrelation_rect_pulse():
+    """
+    Autocorrelation of a Deterministic Signal
+
+    Scenario:
+        This template tests the ability to calculate the autocorrelation function of
+        a simple deterministic signal, a rectangular pulse. This measures the
+        similarity of the signal with a time-shifted version of itself and
+        introduces the concept of deriving a new function shape (a triangle) from
+        this operation.
+
+    Core Equation:
+        Autocorrelation: R_g(tau) = integral from -inf to inf of g(t) * g(t - tau) dt
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the autocorrelation of a rectangular pulse.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    amplitude = random.randint(2, 10)
+    
+    # Use a half-duration to ensure the total duration is an even number
+    # and the pulse limits are clean integers.
+    half_duration = random.randint(1, 5)
+    duration = 2 * half_duration
+
+    # 2. Perform the core calculation
+    # The autocorrelation of a rectangular pulse is a triangular function.
+    # Peak value R(0) = A^2 * T
+    peak_value = (amplitude ** 2) * duration
+    
+    # The resulting function is R(tau) = A^2 * (T - |tau|) for |tau| <= T
+    result_function_str = f"{amplitude**2}*({duration} - |tau|)"
+
+    # 3. Generate the question and solution strings
+    signal_expr = f"g(t) = {amplitude} for -{half_duration} <= t <= {half_duration}, and 0 otherwise"
+
+    question = (
+        f"Find the autocorrelation function R_g(tau) for the rectangular pulse signal defined as:\n"
+        f"    {signal_expr}"
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"The signal is a rectangular pulse: {signal_expr}.\n"
+        f"It has an amplitude A = {amplitude} and a total duration T = {duration}.\n\n"
+        
+        f"**Step 1:** Understand the Autocorrelation Integral.\n"
+        f"The autocorrelation function is defined as R_g(tau) = integral of g(t) * g(t - tau) dt.\n"
+        f"Conceptually, this measures the overlapping area between the signal g(t) and a version of itself shifted by 'tau'.\n\n"
+
+        f"**Step 2:** Analyze the Overlap of the Pulses.\n"
+        f"The original pulse g(t) exists from t = -{half_duration} to t = {half_duration}.\n"
+        f"The shifted pulse g(t - tau) exists from t = tau - {half_duration} to t = tau + {half_duration}.\n"
+        f"The product g(t) * g(t - tau) is non-zero only where these two pulses overlap.\n"
+        f"In the overlapping region, the value of the product is ({amplitude}) * ({amplitude}) = {amplitude**2}.\n"
+        f"The pulses only overlap when the shift 'tau' is between -{duration} and {duration}. Outside this range, the autocorrelation is zero.\n\n"
+
+        f"**Step 3:** Determine the Area of the Overlap.\n"
+        f"The integral is simply the area of the rectangular overlapping region.\n"
+        f"Area = (Height of Overlap) * (Width of Overlap)\n\n"
+        f"The height is constant at {amplitude**2}.\n"
+        f"The width (duration) of the overlap depends on the shift 'tau'. When tau = 0, the overlap is the entire pulse duration, {duration}. As |tau| increases, the overlap width decreases linearly. The width is given by the expression: ({duration} - |tau|).\n\n"
+        
+        f"**Step 4:** Formulate the Autocorrelation Function.\n"
+        f"Combining the height and width, the area of overlap is:\n"
+        f"R_g(tau) = {amplitude**2} * ({duration} - |tau|)\n\n"
+        f"This equation is valid for the range where overlap occurs, which is |tau| <= {duration}. For |tau| > {duration}, R_g(tau) = 0.\n\n"
+
+        f"**Answer:**\n"
+        f"The autocorrelation function is a **triangular function** described by:\n"
+        f"**R_g(tau) = {result_function_str}**, for **|tau| <= {duration}**, and **0** otherwise.\n"
+        f"This triangle has a peak value of **{peak_value}** at tau = 0."
+    )
+
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_ft_esd_rect_pulse():
+    """
+    Fourier Transform and Energy Spectral Density (ESD)
+
+    Scenario:
+        This template requires finding the Fourier Transform of a simple energy
+        signal (a rectangular pulse) and then calculating its Energy Spectral
+        Density (ESD). It demonstrates the fundamental relationship between a
+        signal's time-domain representation and its frequency-domain energy distribution.
+
+    Core Equations:
+        Fourier Transform: G(f) = integral from -inf to inf of g(t)*exp(-j*2*pi*f*t) dt
+        Energy Spectral Density (ESD): Psi_g(f) = |G(f)|^2
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the FT and ESD of a rectangular pulse.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    amplitude = random.randint(5, 20)
+    duration = random.choice([0.5, 1.0, 1.5, 2.0, 4.0])
+    half_duration = duration / 2
+    
+    # 2. Perform the core calculation and format results
+    ft_amplitude = amplitude * duration
+    esd_amplitude = ft_amplitude ** 2
+    
+    # Handle sinc argument formatting for cleaner output
+    if duration == 1.0:
+        sinc_arg_str = "f"
+    else:
+        sinc_arg_str = f"{duration}*f"
+
+    ft_result_str = f"{ft_amplitude} * sinc({sinc_arg_str})"
+    esd_result_str = f"{esd_amplitude} * sinc^2({sinc_arg_str})"
+
+    # 3. Generate the question and solution strings
+    signal_expr = f"g(t) with amplitude {amplitude} extending from t = -{half_duration} s to t = {half_duration} s"
+
+    question = (
+        f"Given a rectangular pulse {signal_expr}, find its Fourier Transform G(f) and "
+        f"its Energy Spectral Density Psi_g(f).\n\n"
+        f"Note: Use the definition sinc(x) = sin(pi*x) / (pi*x)."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"A rectangular pulse g(t) with:\n"
+        f"Amplitude (A) = {amplitude}\n"
+        f"Total Duration (T) = {duration} s (from -{half_duration} to {half_duration})\n\n"
+
+        f"**Step 1:** Identify the Fourier Transform Pair for a Rectangular Pulse.\n"
+        f"A rectangular pulse centered at the origin, g(t) = A for |t| <= T/2, has a well-known Fourier Transform which is a sinc function:\n"
+        f"G(f) = A * T * sinc(f * T)\n"
+        f"where sinc(x) is defined as sin(pi*x) / (pi*x).\n\n"
+
+        f"**Step 2:** Calculate the Fourier Transform G(f).\n"
+        f"We plug in our given values A = {amplitude} and T = {duration} into the formula:\n"
+        f"G(f) = ({amplitude}) * ({duration}) * sinc(f * {duration})\n"
+        f"G(f) = {ft_result_str}\n\n"
+
+        f"**Step 3:** State the Formula for Energy Spectral Density (ESD).\n"
+        f"The ESD, denoted Psi_g(f), describes how the energy of the signal is distributed over frequency. It is calculated as the squared magnitude of the Fourier Transform:\n"
+        f"Psi_g(f) = |G(f)|^2\n\n"
+
+        f"**Step 4:** Calculate the Energy Spectral Density Psi_g(f).\n"
+        f"We take the magnitude squared of the G(f) we found in Step 2. Since our G(f) is real-valued, this is equivalent to just squaring the function:\n"
+        f"Psi_g(f) = |{ft_result_str}|^2\n"
+        f"Psi_g(f) = ({amplitude} * {duration})^2 * sinc^2({sinc_arg_str})\n"
+        f"Psi_g(f) = {esd_result_str}\n\n"
+
+        f"**Answer:**\n"
+        f"The Fourier Transform is **G(f) = {ft_result_str}**.\n"
+        f"The Energy Spectral Density is **Psi_g(f) = {esd_result_str}**."
+    )
+
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_lowpass_equivalent_bandpass():
+    """
+    Lowpass Equivalent of a Bandpass Signal
+
+    Scenario:
+        A fundamental concept in communications is representing a high-frequency bandpass
+        signal using a lower-frequency complex equivalent. This template tests the
+        ability to derive this lowpass equivalent signal from a given bandpass
+        signal by expanding it into its canonical in-phase and quadrature components.
+
+    Core Equations:
+        Bandpass Signal: g(t) = g_I(t)*cos(2*pi*fc*t) - g_Q(t)*sin(2*pi*fc*t)
+        Lowpass Equivalent Signal: g_tilde(t) = g_I(t) + j*g_Q(t)
+        Trigonometric Identity: cos(a + b) = cos(a)*cos(b) - sin(a)*sin(b)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the components of a bandpass signal.
+            - str: A step-by-step solution showing the derivation.
+    """
+    # 1. Parameterize the inputs with random values
+    amplitude = random.randint(10, 100)
+    fc_exp = random.randint(6, 8)  # For MHz to hundreds of MHz
+    fc_mult = random.randint(1, 9)
+    phase_deg = random.choice([30, 45, 60, 90, 120, 135, 150])
+    precision = 2
+    
+    # Create a readable string for the carrier frequency
+    fc_str = f"{fc_mult} x 10^{fc_exp}"
+    
+    # 2. Perform the core calculations
+    phase_rad = math.radians(phase_deg)
+    cos_phi = math.cos(phase_rad)
+    sin_phi = math.sin(phase_rad)
+
+    # From the identity, g(t) = A*cos(phi)*cos(w_c*t) - A*sin(phi)*sin(w_c*t)
+    # We can identify the in-phase and quadrature components
+    g_I = amplitude * cos_phi
+    g_Q = amplitude * sin_phi
+
+    # 3. Generate the question and solution strings
+    signal_expr = f"g(t) = {amplitude} * cos(2*pi*({fc_str})*t + {phase_deg} deg)"
+    
+    question = (
+        f"A bandpass signal is described by the following equation:\n"
+        f"{signal_expr}\n\n"
+        f"Express this signal in its canonical form to determine its in-phase component (g_I(t)), "
+        f"quadrature component (g_Q(t)), and its complex lowpass equivalent signal (g_tilde(t))."
+    )
+    
+    solution = (
+        f"**Given:**\n"
+        f"The bandpass signal is {signal_expr}.\n\n"
+        
+        f"**Step 1:** State the Goal and the Required Identity.\n"
+        f"Our goal is to match the given signal to the canonical bandpass form:\n"
+        f"g(t) = g_I(t)*cos(2*pi*fc*t) - g_Q(t)*sin(2*pi*fc*t)\n"
+        f"To do this, we use the trigonometric angle addition identity:\n"
+        f"cos(a + b) = cos(a)*cos(b) - sin(a)*sin(b)\n\n"
+
+        f"**Step 2:** Expand the Given Signal Expression.\n"
+        f"Let a = 2*pi*fc*t and b = {phase_deg} deg. Applying the identity to g(t):\n"
+        f"g(t) = {amplitude} * [cos(2*pi*fc*t)*cos({phase_deg} deg) - sin(2*pi*fc*t)*sin({phase_deg} deg)]\n"
+        f"g(t) = ({amplitude}*cos({phase_deg} deg))*cos(2*pi*fc*t) - ({amplitude}*sin({phase_deg} deg))*sin(2*pi*fc*t)\n\n"
+
+        f"**Step 3:** Identify the In-Phase (g_I) and Quadrature (g_Q) Components.\n"
+        f"By comparing our expanded signal to the canonical form, we can identify g_I(t) and g_Q(t):\n"
+        f"g_I(t) is the term multiplying cos(2*pi*fc*t).\n"
+        f"g_Q(t) is the term multiplying sin(2*pi*fc*t) (note the minus sign is part of the formula).\n\n"
+        f"g_I(t) = {amplitude} * cos({phase_deg} deg) = {amplitude} * ({cos_phi:.{precision+1}f}) = {g_I:.{precision+1}f}\n"
+        f"g_Q(t) = {amplitude} * sin({phase_deg} deg) = {amplitude} * ({sin_phi:.{precision+1}f}) = {g_Q:.{precision+1}f}\n"
+        f"Note that for this signal, g_I and g_Q are constants because the amplitude and phase are constant.\n\n"
+        
+        f"**Step 4:** Construct the Complex Lowpass Equivalent Signal (g_tilde(t)).\n"
+        f"The complex lowpass equivalent is defined as g_tilde(t) = g_I(t) + j*g_Q(t).\n"
+        f"g_tilde(t) = {round(g_I, precision)} + j*{round(g_Q, precision)}\n\n"
+
+        f"**Answer:**\n"
+        f"In-Phase Component: **g_I(t) = {round(g_I, precision)}**\n"
+        f"Quadrature Component: **g_Q(t) = {round(g_Q, precision)}**\n"
+        f"Complex Lowpass Equivalent: **g_tilde(t) = {round(g_I, precision)} + j*{round(g_Q, precision)}**"
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each deterministic and random signal analysis template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/electrical_engineering/digital_communications/deterministic_and_random_signal_analysis.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_signal_energy_power, "signal_energy_power", "Easy"),
+        (template_mean_variance, "mean_variance_discrete_rv", "Easy"),
+        (template_autocorrelation_rect_pulse, "autocorrelation_rect_pulse", "Intermediate"),
+        (template_ft_esd_rect_pulse, "ft_esd_rect_pulse", "Intermediate"),
+        (template_lowpass_equivalent_bandpass, "lowpass_equivalent_bandpass", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "electrical_engineering",
+                "domain": "digital_communications",
+                "area": "deterministic_and_random_signal_analysis",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,664 @@
+import random
+import math
+
+
+# Template 1 (Easy)
+def template_bpsk_energy_basis():
+    """
+    BPSK/BASK Signal Energy and Basis Function
+
+    Scenario:
+        This template tests the understanding of how to analyze a basic modulated
+        signal, which is a fundamental first step in signal space analysis. It
+        involves calculating the energy of the signal (Eb) over one bit period
+        and deriving its corresponding orthonormal basis function (psi(t)). These
+        two components are essential for representing signals as vectors.
+
+    Core Equations:
+        Signal: s(t) = A * cos(2*pi*fc*t)
+        Energy Integral: Eb = integral from 0 to Tb of [s(t)]^2 dt
+        Simplified Energy: Eb = (A^2 * Tb) / 2
+        Basis Function: psi_1(t) = s(t) / sqrt(Eb) = sqrt(2 / Tb) * cos(2*pi*fc*t)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question about BPSK signal properties.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Set a standard precision for rounding in all calculations and outputs
+    precision = 2
+
+    amplitude = round(random.uniform(1.0, 10.0), precision)
+    
+    # Generate bit duration in a range from 1 microsecond to 10 milliseconds
+    bit_duration_s = random.uniform(1e-6, 1e-2)
+    
+    # Choose a carrier frequency that is an integer multiple of the bit rate (1/Tb)
+    k = random.randint(2, 20)
+    carrier_freq_hz = k / bit_duration_s
+
+    # --- Start: 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 ---
+    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
+    
+    # Calculate energy per bit: Eb = (A^2 * Tb) / 2
+    energy_joules = (amplitude**2 * bit_duration_s) / 2
+    
+    # Calculate the amplitude of the basis function: sqrt(2 / Tb)
+    basis_amplitude = math.sqrt(2 / bit_duration_s)
+
+    # --- Start: 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
+
+    question = (
+        f"A binary ASK (BASK) signal is defined by the following equation for one bit interval:\n"
+        f"s(t) = {amplitude} * cos(2*pi*{carrier_freq_str}*t)\n"
+        f"for the time interval 0 <= t <= {bit_duration_str}.\n\n"
+        f"Calculate the following:\n"
+        f"a) The energy per bit (Eb).\n"
+        f"b) The orthonormal basis function psi_1(t)."
+    )
+
+    solution = (
+        f"**Given Signal:**\n"
+        f"s(t) = {amplitude} * cos(2*pi*{carrier_freq_str}*t) for 0 <= t <= {bit_duration_str}\n\n"
+        
+        f"**Step 1:** Identify Parameters\n"
+        f"From the signal definition, we can extract the following parameters:\n"
+        f"Amplitude (A): {amplitude} V\n"
+        f"Bit Duration (Tb): {bit_duration_str} ({bit_duration_s:.4e} s)\n"
+        f"Carrier Frequency (fc): {carrier_freq_str} ({carrier_freq_hz:.4e} Hz)\n\n"
+        
+        f"**Step 2:** Calculate Energy per Bit (Eb)\n"
+        f"The energy of a signal is the integral of its squared magnitude over its duration.\n"
+        f"Eb = integral from 0 to Tb of [s(t)]^2 dt\n"
+        f"For a sinusoidal signal of the form A*cos(...), the energy over an interval Tb simplifies to:\n"
+        f"Eb = (A^2 * Tb) / 2\n"
+        f"Substituting the values:\n"
+        f"Eb = ({amplitude}^2 * {bit_duration_s:.4e}) / 2\n"
+        f"Eb = {energy_joules:.4e} J\n"
+        f"Eb = {energy_str}\n\n"
+
+        f"**Step 3:** Determine the Basis Function (psi_1(t))\n"
+        f"The orthonormal basis function is found by normalizing the signal by the square root of its energy.\n"
+        f"psi_1(t) = s(t) / sqrt(Eb)\n"
+        f"We can use the general formula derived from this relationship:\n"
+        f"psi_1(t) = sqrt(2 / Tb) * cos(2*pi*fc*t)\n"
+        f"First, calculate the amplitude of the basis function:\n"
+        f"Amplitude_psi = sqrt(2 / {bit_duration_s:.4e} s) = {round(basis_amplitude, precision)}\n"
+        f"Now, construct the full basis function:\n"
+        f"psi_1(t) = {round(basis_amplitude, precision)} * cos(2*pi*{carrier_freq_str}*t)\n\n"
+
+        f"**Answer:**\n"
+        f"a) The energy per bit (Eb) is {energy_str}.\n"
+        f"b) The basis function (psi_1(t)) is {round(basis_amplitude, precision)} * cos(2*pi*{carrier_freq_str}*t)."
+    )
+    
+    return question, solution
+
+
+# Template 2 (Intermediate)
+def template_euclidean_distance_binary():
+    """
+    Euclidean Distance for Binary Modulation
+
+    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).
+
+    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)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question about Euclidean distance.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    precision = 3
+    modulation_type = random.choice(['BPSK', 'Orthogonal BFSK'])
+    
+    # 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 ---
+    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"
+    else:
+        energy_str = "0 J"
+    # --- End: Inline formatting ---
+    
+    # 2. Perform the core calculation based on modulation type
+    
+    sqrt_eb = math.sqrt(energy_joules)
+
+    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})"
+        
+        distance = 2 * sqrt_eb
+        
+        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"**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)}"
+        )
+
+    else: # Orthogonal BFSK
+        # BFSK signals are orthogonal (90 degrees apart)
+        constellation_type = "orthogonal"
+        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})"
+
+        distance = math.sqrt(2 * energy_joules)
+
+        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"**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)}"
+        )
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A digital communication system uses {modulation_type} modulation.\n"
+        f"The energy per bit is Eb = {energy_str}.\n\n"
+        f"Determine the following:\n"
+        f"a) The signal constellation points (s1 and s2) in vector form.\n"
+        f"b) The Euclidean distance (d) between these two points."
+    )
+    
+    solution = (
+        f"**Given Information:**\n"
+        f"Modulation Scheme: {modulation_type}\n"
+        f"Energy per Bit (Eb): {energy_str} ({energy_joules:.{precision}e} J)\n\n"
+        
+        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"{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)}."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+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.
+    """
+    # 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
+    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)
+
+    # Build the solution steps string based on the value of M
+    if M == 4:
+        coordinate_set = "{+/-A}"
+        solution_steps = (
+            f"**Step 2:** List Signal Point Energies\n"
+            f"For 4-QAM, there is only one type of signal point, located at coordinates (+/-A, +/-A).\n"
+            f"There are 4 points, all with energy E = A^2 + A^2 = 2A^2.\n\n"
+            
+            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 * (2 * A^2) = 8 * A^2\n"
+            f"E_avg = (Total Energy) / M = (8 * A^2) / 4 = 2 * A^2\n"
+        )
+    
+    elif M == 16:
+        coordinate_set = "{+/-A, +/-3A}"
+        solution_steps = (
+            f"**Step 2:** List Signal Point Energies\n"
+            f"For 16-QAM, the points can be grouped by their distance from the origin (their energy).\n"
+            f"4 points at (+/-A, +/-A) have energy E1 = A^2 + A^2 = 2A^2.\n"
+            f"8 points at (+/-A, +/-3A) or (+/-3A, +/-A) have energy E2 = A^2 + (3A)^2 = 10A^2.\n"
+            f"4 points at (+/-3A, +/-3A) have energy E3 = (3A)^2 + (3A)^2 = 18A^2.\n\n"
+
+            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"E_avg = (Total Energy) / M = (160 * A^2) / 16 = 10 * A^2\n"
+        )
+        
+    else: # 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"
+            "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"
+            "E_avg = (2/3) * (64 - 1) * A^2\n"
+            "E_avg = (2/3) * 63 * A^2 = 42 * A^2\n"
+        )
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"For a square {M}-QAM constellation, the signal points are located at (xi, yj) where the coordinates xi and yj are chosen from the set {coordinate_set}.\n\n"
+        f"The fundamental distance parameter is A = {A}.\n\n"
+        f"Calculate the average energy per symbol (E_avg) for this constellation."
+    )
+    
+    solution = (
+        f"**Given Information:**\n"
+        f"Modulation Scheme: {M}-QAM\n"
+        f"Distance Parameter (A): {A}\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"
+        
+        f"{solution_steps}"
+        
+        f"**Step 4:** Final Calculation\n"
+        f"Now, we substitute the value of A = {A}.\n"
+        f"E_avg = {round(avg_energy_coeff, precision)} * ({A})^2\n"
+        f"E_avg = {round(avg_energy_coeff, precision)} * {round(A**2, precision)}\n"
+        f"E_avg = {round(avg_energy, precision)}\n\n"
+
+        f"**Answer:**\n"
+        f"The average energy per symbol is {round(avg_energy, precision)}."
+    )
+    
+    return question, solution
+
+
+# Template 4 (Advanced)
+def template_ber_estimation_mary():
+    """
+    Bit Error Rate (BER) Estimation for M-ary Schemes
+
+    Scenario:
+        Predicting the performance of a digital communication system in the presence of
+        noise is a critical engineering task. This template tests the ability to
+        estimate the bit error rate (BER) from a given signal-to-noise ratio per
+        bit (Eb/N0) for common M-ary modulation schemes. It requires using standard
+        approximation formulas that are expressed in terms of the complementary
+        Gaussian distribution function, Q(x).
+
+    Core Equations:
+        Linear SNR: (Eb/N0)_lin = 10^((Eb/N0)_dB / 10)
+        Bits per symbol: k = log2(M)
+        M-PSK SER: Ps approx 2 * Q(sqrt(2 * Es/N0) * sin(pi/M))
+        M-QAM SER: Ps approx 4 * (1 - 1/sqrt(M)) * Q(sqrt(3*k/(M-1) * Eb/N0))
+        Gray Code BER: Pb approx Ps / k
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the BER estimation.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Enhanced Parameter Randomization
+    precision = random.randint(1, 2)
+    modulation_scheme = random.choice(['M-PSK', 'M-QAM'])
+
+    if modulation_scheme == 'M-PSK':
+        M = random.choice([4, 8, 16, 32])
+    else:  # M-QAM
+        # 4-QAM is identical to 4-PSK (QPSK), so we start at 16 for variety.
+        M = random.choice([16, 64, 256])
+
+    eb_n0_db = round(random.uniform(5.0, 25.0), precision)
+
+    # 2. Perform the core calculation
+    eb_n0_lin = 10**(eb_n0_db / 10)
+    k = math.log2(M)
+
+    # Logic varies based on modulation scheme
+    if modulation_scheme == 'M-PSK':
+        # For M-PSK, the formula uses Es/N0
+        es_n0_lin = k * eb_n0_lin
+        q_arg = math.sqrt(2 * es_n0_lin) * math.sin(math.pi / M)
+        ser_coeff = 2
+        ber_coeff = ser_coeff / k
+
+        ser_approx_str = f"{ser_coeff} * Q({q_arg:.{precision+1}f})"
+        ber_approx_str = f"{ber_coeff:.{precision+1}f} * Q({q_arg:.{precision+1}f})"
+        
+        calculation_steps = (
+            f"**Step 2:** Calculate Symbol SNR (Es/N0)\n"
+            f"The number of bits per symbol is k = log2({M}) = {k:.0f}.\n"
+            f"The energy per symbol (Es) is k times the energy per bit (Eb).\n"
+            f"Es/N0 = k * (Eb/N0) = {k:.0f} * {eb_n0_lin:.{precision}f} = {es_n0_lin:.{precision}f}\n\n"
+            
+            f"**Step 3:** Calculate Symbol Error Rate (SER)\n"
+            f"For M-PSK, the SER is approximated by: Ps approx 2*Q(sqrt(2*Es/N0)*sin(pi/M)).\n"
+            f"First, calculate the argument of the Q-function:\n"
+            f"arg = sqrt(2 * {es_n0_lin:.{precision}f}) * sin(pi / {M})\n"
+            f"arg = {q_arg:.{precision+1}f}\n"
+            f"So, the SER is: Ps approx {ser_approx_str}\n"
+        )
+
+    else:  # M-QAM
+        # For square M-QAM, the formula directly uses Eb/N0
+        q_arg = math.sqrt((3 * k / (M - 1)) * eb_n0_lin)
+        ser_coeff = 4 * (1 - 1/math.sqrt(M))
+        ber_coeff = ser_coeff / k
+        
+        ser_approx_str = f"{ser_coeff:.{precision+1}f} * Q({q_arg:.{precision+1}f})"
+        ber_approx_str = f"{ber_coeff:.{precision+1}f} * Q({q_arg:.{precision+1}f})"
+
+        calculation_steps = (
+            f"**Step 2:** Calculate Bits per Symbol (k)\n"
+            f"The number of bits per symbol is k = log2({M}) = {k:.0f}.\n\n"
+
+            f"**Step 3:** Calculate Symbol Error Rate (SER)\n"
+            f"For square M-QAM, the SER is approximated by: Ps approx 4*(1-1/sqrt(M))*Q(sqrt(3*k/(M-1) * Eb/N0)).\n"
+            f"First, calculate the argument of the Q-function:\n"
+            f"arg = sqrt( (3*{k:.0f} / ({M}-1)) * {eb_n0_lin:.{precision}f} )\n"
+            f"arg = {q_arg:.{precision+1}f}\n"
+            f"So, the SER is: Ps approx {ser_approx_str}\n"
+        )
+        
+    # 3. Generate the question and solution strings
+    question = (
+        f"A digital communication system uses {M}-{modulation_scheme.split('-')[1]} modulation over an AWGN channel.\n"
+        f"The system operates with a signal-to-noise ratio per bit of Eb/N0 = {eb_n0_db} dB.\n\n"
+        "Assuming a Gray code mapping is used, provide a mathematical expression for the estimated Bit Error Rate (BER)."
+    )
+
+    solution = (
+        f"**Given Information:**\n"
+        f"Modulation: {M}-{modulation_scheme.split('-')[1]}\n"
+        f"Eb/N0: {eb_n0_db} dB\n\n"
+        
+        f"**Step 1:** Convert SNR from dB to Linear Scale\n"
+        f"The linear value of Eb/N0 is required for the error rate formulas.\n"
+        f"Eb/N0 (linear) = 10^( ({eb_n0_db}) / 10 ) = {eb_n0_lin:.{precision}f}\n\n"
+
+        f"{calculation_steps}\n"
+        
+        f"**Step 4:** Approximate Bit Error Rate (BER)\n"
+        f"For Gray-coded constellations, the BER can be approximated from the SER by Pb approx Ps / k.\n"
+        f"Pb approx ({ser_approx_str}) / {k:.0f}\n"
+        f"Pb approx {ber_approx_str}\n\n"
+        
+        f"**Answer:**\n"
+        f"The estimated Bit Error Rate (BER) is expressed as:\n"
+        f"BER approx {ber_approx_str}"
+    )
+
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_null_to_null_bandwidth():
+    """
+    Null-to-Null Bandwidth Calculation
+
+    Scenario:
+        Understanding the bandwidth requirements of a signal is essential for designing
+        and analyzing communication systems. The null-to-null bandwidth of the main
+        spectral lobe is a fundamental, albeit theoretical, measure of the spectrum
+        occupied by a signal shaped with basic rectangular pulses. This template tests
+        the ability to calculate this bandwidth by relating the user data rate (Rb)
+        to the transmission symbol rate (Rs) for various M-ary modulation schemes.
+
+    Core Equations:
+        Bits per Symbol: k = log2(M)
+        Symbol Rate: Rs = Rb / k
+        Null-to-Null RF Bandwidth: B_null = 2 * Rs
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the null-to-null bandwidth.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Enhanced Parameter Randomization
+    precision = 2
+    modulation_scheme = random.choice(['M-PSK', 'M-QAM', 'M-PAM'])
+
+    # Choose M from a scheme-appropriate set
+    if modulation_scheme == 'M-PSK':
+        M = random.choice([2, 4, 8, 16, 32, 64, 128])  
+    elif modulation_scheme == 'M-QAM':
+        M = random.choice([4, 16, 32, 64, 128, 256, 512, 1024])  
+    else:  # M-PAM
+        M = random.choice([2, 4, 8, 16, 32, 64]) 
+
+    # Randomize bit rate value and unit for diversity
+    unit_choice = random.choice(['kbps', 'Mbps', 'Gbps'])
+    if unit_choice == 'kbps':
+        value = random.randint(100, 999)
+        multiplier = 1e3
+    elif unit_choice == 'Mbps':
+        value = random.choice([1, 1.5, 2, 5, 10, 25, 50, 100])
+        multiplier = 1e6
+    else:  # Gbps
+        value = random.choice([1, 2.5, 10])
+        multiplier = 1e9
+
+    bit_rate_str = f"{value} {unit_choice}"
+    bit_rate_hz = value * multiplier
+
+    # 2. Perform the core calculation
+    k = math.log2(M)
+    symbol_rate_rs = bit_rate_hz / k
+    bandwidth_hz = 2 * symbol_rate_rs
+
+    # --- 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)
+        prefix_b = prefixes.get(exponent_b, '')
+        scaled_b = bandwidth_hz / (10**exponent_b)
+        bandwidth_str = f"{round(scaled_b, precision)} {prefix_b}Hz"
+    else:
+        bandwidth_str = "0 Hz"
+    # --- End: Inline formatting ---
+
+    # --- 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, '')
+        scaled_rs = symbol_rate_rs / (10**exponent_rs)
+        symbol_rate_str = f"{round(scaled_rs, precision)} {prefix_rs}symbols/s"
+    else:
+        symbol_rate_str = "0 symbols/s"
+    # --- End: Inline formatting ---
+
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A digital communication system transmits data at a rate of {bit_rate_str} using {M}-{modulation_scheme.split('-')[1]} modulation.\n\n"
+        "Assuming the signal is shaped with rectangular baseband pulses, what is the null-to-null RF bandwidth of the transmitted signal's main spectral lobe?"
+    )
+
+    solution = (
+        f"**Given Information:**\n"
+        f"Modulation: {M}-{modulation_scheme.split('-')[1]}\n"
+        f"Bit Rate (Rb): {bit_rate_str} ({bit_rate_hz:.2e} bps)\n\n"
+
+        f"**Step 1:** Calculate Bits per Symbol (k)\n"
+        f"This value determines how many bits are grouped together to form a single symbol.\n"
+        f"k = log2(M) = log2({M}) = {k:.0f} bits/symbol\n\n"
+
+        f"**Step 2:** Calculate Symbol Rate (Rs)\n"
+        f"The symbol rate (or baud rate) is the rate at which symbols are transmitted. It is found by dividing the bit rate by the number of bits per symbol.\n"
+        f"Rs = Rb / k\n"
+        f"Rs = {bit_rate_hz:.2e} bps / {k:.0f} bits/symbol\n"
+        f"Rs = {symbol_rate_rs:.2e} symbols/s = {symbol_rate_str}\n\n"
+
+        f"**Step 3:** Calculate Null-to-Null Bandwidth (B_null)\n"
+        f"For a signal using rectangular pulses of duration Ts, the baseband spectrum is a sinc function with its first null at frequency 1/Ts. The symbol rate Rs is equal to 1/Ts.\n"
+        f"For a passband RF signal, the main lobe bandwidth is twice the baseband null frequency.\n"
+        f"B_null = 2 * (1/Ts) = 2 * Rs\n"
+        f"B_null = 2 * {symbol_rate_rs:.2e} symbols/s\n"
+        f"B_null = {bandwidth_hz:.2e} Hz = {bandwidth_str}\n\n"
+
+        f"**Answer:**\n"
+        f"The null-to-null RF bandwidth is {bandwidth_str}."
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each digital modulation schemes template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/electrical_engineering/digital_communications/digital_modulation_schemes.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_bpsk_energy_basis, "bpsk_energy_basis", "Easy"),
+        (template_euclidean_distance_binary, "euclidean_distance_binary", "Intermediate"),
+        (template_average_energy_mqam, "average_energy_mqam", "Intermediate"),
+        (template_ber_estimation_mary, "ber_estimation_mary", "Advanced"),
+        (template_null_to_null_bandwidth, "null_to_null_bandwidth", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "electrical_engineering",
+                "domain": "digital_communications",
+                "area": "digital_modulation_schemes",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

data/templates/branches/electrical_engineering/electromagnetics_and_waves/electrostatics.py

@@ -0,0 +1,566 @@
+import random
+import math
+import numpy as np
+from data.templates.branches.electrical_engineering.constants import EPSILON_0
+
+
+# Template 1 (Easy)
+def template_coulombs_law():
+    """
+    Coulomb's Law for Two Point Charges 
+
+    Scenario:
+        This template tests the fundamental calculation of the electrostatic force
+        between two point charges in a dielectric medium. It requires finding the
+        separation vector between the charges and applying the vector form of
+        Coulomb's Law.
+
+    Core Equations:
+        R_vec = P2 - P1
+        F_vec = (1 / (4 * pi * epsilon_0 * epsilon_r)) * (q1 * q2 / |R_vec|^3) * R_vec
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the force vector between two charges.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Generate random integer charges between -15 and 15 uC (excluding 0)
+    q1_val = random.choice([i for i in range(-15, 16) if i != 0])
+    q2_val = random.choice([i for i in range(-15, 16) if i != 0])
+    
+    # Convert from microcoulombs to coulombs for calculation
+    q1_calc = q1_val * 1e-6
+    q2_calc = q2_val * 1e-6
+
+    # Generate two unique 3D points with integer coordinates from -5 to 5
+    p1 = np.array([random.randint(-5, 5) for _ in range(3)])
+    p2 = np.array([random.randint(-5, 5) for _ in range(3)])
+    while np.array_equal(p1, p2):
+        p2 = np.array([random.randint(-5, 5) for _ in range(3)])
+
+    # Choose a relative permittivity for the medium
+    epsilon_r = round(random.uniform(1.0, 5.0), 2)
+    
+    # Standardize precision for final outputs
+    precision = 3
+
+    # 2. Perform the core calculation
+    
+    # Calculate the separation vector and its magnitude
+    R_vec = p2 - p1
+    R_mag = np.linalg.norm(R_vec)
+
+    # Calculate the full permittivity of the medium
+    epsilon = epsilon_r * EPSILON_0
+    
+    # Calculate the scalar part of Coulomb's Law
+    scalar_coefficient = (q1_calc * q2_calc) / (4 * math.pi * epsilon * (R_mag**3))
+    
+    # Calculate the final force vector
+    F_vec = scalar_coefficient * R_vec
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"Two point charges are located in a medium with a relative permittivity of {epsilon_r}.\n"
+        f"Charge q1 = {q1_val} uC is at position P1 = {p1} m.\n"
+        f"Charge q2 = {q2_val} uC is at position P2 = {p2} m.\n\n"
+        f"Determine the electrostatic force vector F12 exerted by charge q1 on charge q2."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"  - Charge q1 = {q1_val} uC = {q1_val}e-6 C at P1 = {p1} m\n"
+        f"  - Charge q2 = {q2_val} uC = {q2_val}e-6 C at P2 = {p2} m\n"
+        f"  - Relative permittivity epsilon_r = {epsilon_r}\n\n"
+        f"**Constants:**\n"
+        f"  - Permittivity of free space, epsilon_0 = {EPSILON_0:.4e} F/m\n\n"
+        
+        f"**Step 1:** Find the separation vector from q1 to q2.\n"
+        f"  The vector R12 points from P1 to P2.\n"
+        f"  R12 = P2 - P1 = {p2} - {p1} = {R_vec} m.\n\n"
+        
+        f"**Step 2:** Calculate the magnitude of the separation vector.\n"
+        f"  |R12| = sqrt({R_vec[0]}^2 + {R_vec[1]}^2 + {R_vec[2]}^2)\n"
+        f"  |R12| = sqrt({R_vec[0]**2} + {R_vec[1]**2} + {R_vec[2]**2}) = sqrt({R_mag**2:.2f}) = {R_mag:.{precision}f} m.\n\n"
+        
+        f"**Step 3:** Apply the vector form of Coulomb's Law.\n"
+        f"  The formula for the force F12 is:\n"
+        f"  F12 = (1 / (4 * pi * epsilon)) * (q1 * q2 / |R12|^3) * R12\n"
+        f"  where epsilon = epsilon_r * epsilon_0.\n\n"
+        
+        f"  First, calculate the total permittivity:\n"
+        f"  epsilon = {epsilon_r} * {EPSILON_0:.4e} = {epsilon:.4e} F/m.\n\n"
+        
+        f"  Now, substitute all values into the formula:\n"
+        f"  F12 = (1 / (4 * pi * {epsilon:.4e})) * (({q1_calc:.2e}) * ({q2_calc:.2e}) / ({R_mag:.{precision}f})^3) * {R_vec}\n"
+        f"  F12 = ({1/(4 * math.pi * epsilon):.3e}) * ({(q1_calc * q2_calc):.3e} / {R_mag**3:.3e}) * {R_vec}\n"
+        f"  F12 = ({scalar_coefficient:.3e}) * {R_vec}\n"
+        f"  F12 = <{F_vec[0]:.{precision}e}, {F_vec[1]:.{precision}e}, {F_vec[2]:.{precision}e}> N.\n\n"
+        
+        f"**Answer:**\n"
+        f"  The electrostatic force vector exerted by q1 on q2 is "
+        f"<{F_vec[0]:.{precision}e}, {F_vec[1]:.{precision}e}, {F_vec[2]:.{precision}e}> N."
+    )
+
+    return question, solution
+
+
+# Template 2 (Intermediate)
+def template_superposition_electric_field():
+    """
+    Superposition of Electric Fields (Intermediate)
+
+    Scenario:
+        This template requires calculating the net electric field at a target
+        point due to two or three discrete point charges. It builds on the
+        basic E-field calculation by applying the principle of superposition,
+        which involves vector addition. The problem is constrained to 2D
+        to keep the vector calculations straightforward.
+
+    Core Equations:
+        E_i = (1 / (4 * pi * epsilon_0)) * (q_i / |R_i|^3) * R_i
+        E_net = E_1 + E_2 + ...
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the net electric field at a point.
+            - str: A step-by-step solution showing the calculation for each charge
+                   and the final vector sum.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    num_charges = random.choice([2, 3])
+    charges_val = []
+    positions = []
+    
+    # Use a set to ensure all points (charges and target) are unique
+    used_points = set()
+    
+    for i in range(num_charges):
+        # Generate random integer charges between -25 and 25 nC (excluding 0)
+        q_val = random.choice([i for i in range(-25, 26) if i != 0])
+        charges_val.append(q_val)
+
+        # Generate a unique 2D point for each charge
+        while True:
+            pos = tuple(random.randint(-10, 10) for _ in range(2))
+            if pos not in used_points:
+                positions.append(np.array(pos))
+                used_points.add(pos)
+                break
+    
+    # Generate a unique 2D target point
+    while True:
+        target_pos = tuple(random.randint(-10, 10) for _ in range(2))
+        if target_pos not in used_points:
+            P_target = np.array(target_pos)
+            used_points.add(target_pos)
+            break
+            
+    # Convert from nanocoulombs to coulombs for calculation
+    charges_calc = [q * 1e-9 for q in charges_val]
+
+    # Standardize precision for final outputs
+    precision = 2
+
+    # 2. Perform the core calculation
+    
+    E_net = np.array([0.0, 0.0])
+    solution_steps = ""
+    
+    for i in range(num_charges):
+        q_calc = charges_calc[i]
+        q_val = charges_val[i]
+        pos = positions[i]
+        
+        # Calculate separation vector and its magnitude
+        R_vec = P_target - pos
+        R_mag = np.linalg.norm(R_vec)
+        
+        # Calculate the E-field vector from this charge
+        scalar_part = q_calc / (4 * math.pi * EPSILON_0 * R_mag**3)
+        E_vec = scalar_part * R_vec
+        
+        # Add to the net field
+        E_net += E_vec
+        
+        # Build the solution string for this step
+        solution_steps += (
+            f"**Step {i+1}:** Calculate the Electric Field from q{i+1} ({q_val} nC).\n"
+            f"  The separation vector from q{i+1} to the target point P is:\n"
+            f"  R{i+1} = P - P{i+1} = {P_target} - {pos} = {R_vec} m.\n"
+            f"  The magnitude is |R{i+1}| = sqrt({R_vec[0]**2} + {R_vec[1]**2}) = {R_mag:.{precision+1}f} m.\n"
+            f"  The electric field E{i+1} is given by E = (k * q / |R|^3) * R, where k = 1/(4*pi*eps0).\n"
+            f"  E{i+1} = ({1/(4*math.pi*EPSILON_0):.2e}) * ({q_calc:.2e} / {R_mag:.{precision+1}f}^3) * {R_vec}\n"
+            f"  E{i+1} = <{E_vec[0]:.{precision}e}, {E_vec[1]:.{precision}e}> N/C.\n\n"
+        )
+
+    # 3. Generate the question and solution strings
+    
+    charge_descriptions = ""
+    for i in range(num_charges):
+        charge_descriptions += f"  - Charge q{i+1} = {charges_val[i]} nC is at position P{i+1} = {positions[i]} m.\n"
+
+    question = (
+        f"Several point charges are located in a vacuum on a 2D plane:\n"
+        f"{charge_descriptions}"
+        f"An observation point is located at P = {P_target} m.\n\n"
+        f"Using the principle of superposition, determine the net electric field vector E_net at point P."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"{charge_descriptions}"
+        f"  - Observation point P = {P_target} m.\n"
+        f"  - The medium is a vacuum (epsilon_r = 1.0).\n\n"
+        f"**Principle of Superposition:**\n"
+        f"  The total electric field at a point is the vector sum of the electric fields produced by each individual charge.\n"
+        f"  E_net = E1 + E2{' + E3' if num_charges == 3 else ''}\n\n"
+
+        f"{solution_steps}"
+        f"**Step {num_charges+1}:** Sum the vectors to find the net electric field.\n"
+        f"  E_net = E1 + E2{' + E3' if num_charges == 3 else ''}\n"
+        f"  E_net = <E1_x + E2_x{' + E3_x' if num_charges == 3 else ''}, E1_y + E2_y{' + E3_y' if num_charges == 3 else ''}>\n"
+        f"  E_net = <{E_net[0]:.{precision}e}, {E_net[1]:.{precision}e}> N/C.\n\n"
+
+        f"**Answer:**\n"
+        f"  The net electric field vector at point P is <{E_net[0]:.{precision}e}, {E_net[1]:.{precision}e}> N/C."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_gauss_law_symmetric():
+    """
+    Gauss's Law for Symmetric Charge Distributions (Intermediate)
+
+    Scenario:
+        This template tests the application of Gauss's Law to find the electric
+        field (E) and electric flux density (D) for a highly symmetric charge
+        distribution (an infinite line or an infinite sheet). The solution emphasizes
+        the conceptual steps: choosing an appropriate Gaussian surface, applying
+        Gauss's Law to find D, and then finding E.
+
+    Core Equations:
+        Gauss's Law: Integral(D . dS) = Q_enc
+        For an infinite line: D = rho_l / (2 * pi * r)
+        For an infinite sheet: D = rho_s / 2
+        Relation: D = epsilon * E
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question about the E and D fields from a charge distribution.
+            - str: A detailed, step-by-step solution explaining the derivation.
+    """
+    # 1. Parameterize the inputs
+    dist_type = random.choice(['line', 'sheet'])
+    epsilon_r = round(random.uniform(1.0, 6.0), 2)
+    epsilon = epsilon_r * EPSILON_0
+    precision = 3
+
+    # Initialize variables to be populated in the if/else block
+    question = ""
+    solution = ""
+
+    # --- Logic for an Infinite Line Charge ---
+    if dist_type == 'line':
+        rho_l_val = random.choice([i for i in range(-50, 51) if i != 0])
+        rho_l_calc = rho_l_val * 1e-9  # Convert nC/m to C/m
+        
+        r_dist = round(random.uniform(0.1, 2.5), 2)
+        point = np.array([r_dist, 0, 0])
+
+        # Core Calculation
+        D_mag = rho_l_calc / (2 * math.pi * r_dist)
+        D_vec = D_mag * np.array([1, 0, 0]) # Direction is radial (a_r)
+        E_vec = D_vec / epsilon
+
+        # Generate Question and Solution Strings
+        question = (
+            f"An infinite line of charge with a uniform density rho_l = {rho_l_val} nC/m is located "
+            f"on the z-axis in a medium with relative permittivity epsilon_r = {epsilon_r}.\n\n"
+            f"Using Gauss's Law, find the electric flux density vector (D) and the electric field "
+            f"intensity vector (E) at the point P = {point} m."
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"  - Infinite line charge with rho_l = {rho_l_val} nC/m = {rho_l_calc:.2e} C/m.\n"
+            f"  - Relative permittivity epsilon_r = {epsilon_r}.\n"
+            f"  - Observation point P = {point} m.\n\n"
+
+            f"**Step 1:** Choose a Gaussian Surface.\n"
+            f"  For an infinite line charge, the electric field is purely radial. We choose a closed "
+            f"cylindrical surface of radius r = {r_dist} m and length L, coaxial with the z-axis.\n\n"
+
+            f"**Step 2:** Apply Gauss's Law.\n"
+            f"  Gauss's Law states: Integral(D . dS) = Q_enc.\n"
+            f"  - The flux D is perpendicular to the side surface and parallel to the top/bottom caps. "
+            f"Therefore, flux only passes through the curved side surface.\n"
+            f"  - Integral(D . dS) = D_r * (Area of side) = D_r * (2 * pi * r * L).\n"
+            f"  - The charge enclosed is Q_enc = rho_l * L.\n"
+            f"  - Equating them: D_r * (2 * pi * r * L) = rho_l * L.\n"
+            f"  - Solving for D_r: D_r = rho_l / (2 * pi * r).\n\n"
+
+            f"**Step 3:** Calculate the Electric Flux Density (D).\n"
+            f"  The magnitude of D at r = {r_dist} m is:\n"
+            f"  |D| = ({rho_l_calc:.2e}) / (2 * pi * {r_dist}) = {abs(D_mag):.{precision}e} C/m^2.\n"
+            f"  At point P = {point} m, the direction is radial, which corresponds to the x-direction (a_x).\n"
+            f"  Therefore, D = <{D_vec[0]:.{precision}e}, 0, 0> C/m^2.\n\n"
+
+            f"**Step 4:** Calculate the Electric Field Intensity (E).\n"
+            f"  E = D / epsilon, where epsilon = epsilon_r * epsilon_0.\n"
+            f"  epsilon = {epsilon_r} * {EPSILON_0:.3e} = {epsilon:.3e} F/m.\n"
+            f"  E = <{D_vec[0]:.{precision}e}, 0, 0> / {epsilon:.3e}\n"
+            f"  E = <{E_vec[0]:.{precision}e}, 0, 0> V/m.\n\n"
+        )
+
+    # --- Logic for an Infinite Sheet of Charge ---
+    else: # dist_type == 'sheet'
+        rho_s_val = random.choice([i for i in range(-50, 51) if i != 0])
+        rho_s_calc = rho_s_val * 1e-9  # Convert nC/m^2 to C/m^2
+        
+        z_dist = round(random.uniform(0.1, 2.5), 2)
+        point = np.array([0, 0, z_dist])
+        
+        # Core Calculation
+        D_mag = rho_s_calc / 2.0
+        D_vec = D_mag * np.array([0, 0, 1]) # Direction is normal (a_z)
+        E_vec = D_vec / epsilon
+
+        # Generate Question and Solution Strings
+        question = (
+            f"An infinite sheet of charge with a uniform surface density rho_s = {rho_s_val} nC/m^2 is "
+            f"located on the x-y plane (z=0) in a medium with relative permittivity epsilon_r = {epsilon_r}.\n\n"
+            f"Using Gauss's Law, find the electric flux density vector (D) and the electric field "
+            f"intensity vector (E) at the point P = {point} m."
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"  - Infinite sheet charge with rho_s = {rho_s_val} nC/m^2 = {rho_s_calc:.2e} C/m^2.\n"
+            f"  - Relative permittivity epsilon_r = {epsilon_r}.\n"
+            f"  - Observation point P = {point} m.\n\n"
+
+            f"**Step 1:** Choose a Gaussian Surface.\n"
+            f"  For an infinite sheet, the electric field is purely normal to the sheet. We choose a "
+            f"small cylindrical 'pillbox' or a rectangular box of area A, piercing the sheet and centered at z=0.\n\n"
+
+            f"**Step 2:** Apply Gauss's Law.\n"
+            f"  Gauss's Law states: Integral(D . dS) = Q_enc.\n"
+            f"  - The flux D is parallel to the sides of the pillbox, so flux only passes through the top and bottom surfaces.\n"
+            f"  - Integral(D . dS) = D_z * (Top Area) + D_z * (Bottom Area) = D_z*A + D_z*A = 2*D_z*A.\n"
+            f"  - The charge enclosed is Q_enc = rho_s * A.\n"
+            f"  - Equating them: 2 * D_z * A = rho_s * A.\n"
+            f"  - Solving for D_z: D_z = rho_s / 2.\n\n"
+
+            f"**Step 3:** Calculate the Electric Flux Density (D).\n"
+            f"  The magnitude of D is independent of the distance from the sheet:\n"
+            f"  |D| = |{rho_s_calc:.2e}| / 2 = {abs(D_mag):.{precision}e} C/m^2.\n"
+            f"  At P = {point} m (where z > 0), the direction is normal to the sheet (a_z).\n"
+            f"  Therefore, D = <0, 0, {D_vec[2]:.{precision}e}> C/m^2.\n\n"
+
+            f"**Step 4:** Calculate the Electric Field Intensity (E).\n"
+            f"  E = D / epsilon, where epsilon = epsilon_r * epsilon_0.\n"
+            f"  epsilon = {epsilon_r} * {EPSILON_0:.3e} = {epsilon:.3e} F/m.\n"
+            f"  E = <0, 0, {D_vec[2]:.{precision}e}> / {epsilon:.3e}\n"
+            f"  E = <0, 0, {E_vec[2]:.{precision}e}> V/m.\n\n"
+        )
+
+    # Final Summary for both cases
+    final_answer = (
+        f"**Answer:**\n"
+        f"  The electric flux density is D = <{D_vec[0]:.{precision}e}, {D_vec[1]:.{precision}e}, {D_vec[2]:.{precision}e}> C/m^2.\n"
+        f"  The electric field intensity is E = <{E_vec[0]:.{precision}e}, {E_vec[1]:.{precision}e}, {E_vec[2]:.{precision}e}> V/m."
+    )
+    
+    solution += final_answer
+    
+    return question, solution
+
+
+# Template 4 (Advanced)
+def template_coaxial_capacitance():
+    """
+    Capacitance of a Coaxial Cable (Advanced)
+
+    Scenario:
+        This template tests the ability to derive and calculate the capacitance
+        per unit length of a coaxial cable. The solution requires a logical,
+        multi-step derivation: first, finding the electric field using the
+        premise of Gauss's Law; second, integrating the electric field to find
+        the potential difference between the conductors; and finally, using the
+        fundamental definition of capacitance (C = Q/V).
+
+    Core Equations:
+        1. E = rho_l / (2 * pi * epsilon * r)
+        2. V_ab = Integral(E . dl) = (rho_l / (2 * pi * epsilon)) * ln(b/a)
+        3. C' = rho_l / V_ab = (2 * pi * epsilon) / ln(b/a)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to derive and calculate the capacitance per unit length.
+            - str: A step-by-step solution showing the full derivation and calculation.
+    """
+    # 1. Parameterize the inputs
+    
+    # Inner radius in mm, ensuring it's not too small
+    a_mm = round(random.uniform(0.5, 2.5), 2)
+    
+    # Outer radius is 2 to 5 times larger than inner radius
+    b_mm = round(a_mm * random.uniform(2, 5), 2)
+    
+    # Convert radii to meters for calculation
+    a_m = a_mm * 1e-3
+    b_m = b_mm * 1e-3
+    
+    # Relative permittivity of a common dielectric like polyethylene or teflon
+    epsilon_r = round(random.uniform(2.0, 4.0), 2)
+    
+    # Standardize precision for final outputs
+    precision = 3
+
+    # 2. Perform the core calculation
+    
+    # Total permittivity of the dielectric
+    epsilon = epsilon_r * EPSILON_0
+    
+    # Capacitance per unit length in F/m
+    C_prime = (2 * math.pi * epsilon) / math.log(b_m / a_m)
+    
+    # Convert to a more readable unit, pF/m
+    C_prime_pF = C_prime * 1e12
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A coaxial cable consists of an inner conductor of radius a = {a_mm} mm and an "
+        f"outer conductor of radius b = {b_mm} mm.\n"
+        f"The space between the conductors is filled with a dielectric material with a "
+        f"relative permittivity of epsilon_r = {epsilon_r}.\n\n"
+        f"Derive the general expression for the capacitance per unit length (C') and then "
+        f"calculate its numerical value for this cable."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"  - Inner radius, a = {a_mm} mm = {a_m:.2e} m\n"
+        f"  - Outer radius, b = {b_mm} mm = {b_m:.2e} m\n"
+        f"  - Relative permittivity, epsilon_r = {epsilon_r}\n\n"
+
+        f"**Derivation:**\n"
+        f"The derivation involves three main steps: finding the electric field E, finding the "
+        f"potential difference V, and then finding the capacitance C' = rho_l / V.\n\n"
+
+        f"**Step 1:** Find the Electric Field (E) between the conductors.\n"
+        f"  Assume a line charge of +rho_l (C/m) on the inner conductor and -rho_l on the outer. "
+        f"By applying Gauss's Law to a cylindrical surface with radius 'r' (where a < r < b), "
+        f"the electric field is found to be purely radial:\n"
+        f"  E = (rho_l / (2 * pi * epsilon * r)) * a_r\n"
+        f"  where epsilon = epsilon_r * epsilon_0.\n\n"
+
+        f"**Step 2:** Find the Potential Difference (V_ab) between the conductors.\n"
+        f"  The potential difference is the work done to move a unit charge from the outer "
+        f"conductor (at r=b) to the inner conductor (at r=a) against the E field.\n"
+        f"  V_ab = -Integral(from b to a, E . dl)\n"
+        f"  Since the path is radial, dl = dr * a_r. The integral becomes:\n"
+        f"  V_ab = -Integral(from b to a, [rho_l / (2 * pi * epsilon * r)] dr)\n"
+        f"  V_ab = -[rho_l / (2 * pi * epsilon)] * [ln(r)](from b to a)\n"
+        f"  V_ab = -[rho_l / (2 * pi * epsilon)] * (ln(a) - ln(b))\n"
+        f"  Using log properties, ln(a) - ln(b) = -ln(b/a), this simplifies to:\n"
+        f"  V_ab = (rho_l / (2 * pi * epsilon)) * ln(b/a)\n\n"
+
+        f"**Step 3:** Derive the Capacitance per Unit Length (C').\n"
+        f"  Capacitance per unit length is defined as the charge per unit length (rho_l) "
+        f"divided by the potential difference (V_ab).\n"
+        f"  C' = rho_l / V_ab\n"
+        f"  C' = rho_l / [(rho_l / (2 * pi * epsilon)) * ln(b/a)]\n"
+        f"  The rho_l terms cancel, leaving the final expression:\n"
+        f"  C' = (2 * pi * epsilon) / ln(b/a)\n\n"
+
+        f"**Step 4:** Calculate the final value.\n"
+        f"  First, find the permittivity of the dielectric:\n"
+        f"  epsilon = {epsilon_r} * {EPSILON_0:.4e} = {epsilon:.4e} F/m.\n"
+        f"  Now, plug the values into the derived formula:\n"
+        f"  C' = (2 * pi * {epsilon:.4e}) / ln({b_mm} / {a_mm})\n"
+        f"  C' = (2 * pi * {epsilon:.4e}) / ln({b_m/a_m:.{precision}f})\n"
+        f"  C' = (2 * pi * {epsilon:.4e}) / {math.log(b_m/a_m):.{precision}f}\n"
+        f"  C' = {C_prime:.{precision}e} F/m.\n\n"
+
+        f"**Answer:**\n"
+        f"  The derived expression for capacitance per unit length is C' = (2 * pi * epsilon) / ln(b/a).\n"
+        f"  The numerical value is {C_prime:.{precision}e} F/m, which is equivalent to "
+        f"**{C_prime_pF:.{precision-1}f} pF/m**."
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each electrostatics template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/electrical_engineering/electromagnetics_and_waves/electrostatics.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_coulombs_law, "coulombs_law_two_charges", "Easy"),
+        (template_superposition_electric_field, "superposition_electric_field", "Intermediate"),
+        (template_gauss_law_symmetric, "gauss_law_symmetric_charge", "Intermediate"),
+        (template_coaxial_capacitance, "coaxial_cable_capacitance", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "electrical_engineering",
+                "domain": "electromagnetics_and_waves",
+                "area": "electrostatics",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

data/templates/branches/electrical_engineering/electromagnetics_and_waves/magnetostatics.py

@@ -0,0 +1,168 @@
+import random
+import math
+
+
+# Template 1 (Easy)
+def template_lorentz_force():
+    """
+    Lorentz Force on a Moving Charge
+
+    Scenario:
+        This template tests the fundamental calculation of the magnetic force on a moving
+        point charge in a uniform magnetic field. It requires unit conversion and the
+        correct application of the vector cross product, which is a core skill in
+        electromagnetics.
+
+    Core Equation:
+        F_m = q * (u x B)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the force vector and magnitude.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Generate charge in microcoulombs (uC)
+    q_uC = round(random.uniform(1.0, 100.0), 2)
+    if random.choice([True, False]):
+        q_uC *= -1
+    
+    # Generate velocity vector components in m/s
+    u_vec = [random.randint(-50, 50) for _ in range(3)]
+    
+    # Generate magnetic field vector components in millitesla (mT)
+    B_vec_mT = [round(random.uniform(-200.0, 200.0), 2) for _ in range(3)]
+
+    # Standardize precision for final outputs
+    precision = 3
+
+    # 2. Perform the core calculation
+    
+    # Convert units for calculation
+    q_C = q_uC * 1e-6
+    B_vec_T = [b * 1e-3 for b in B_vec_mT]
+    
+    # Calculate the cross product: u x B
+    cross_product_x = u_vec[1] * B_vec_T[2] - u_vec[2] * B_vec_T[1]
+    cross_product_y = u_vec[2] * B_vec_T[0] - u_vec[0] * B_vec_T[2]
+    cross_product_z = u_vec[0] * B_vec_T[1] - u_vec[1] * B_vec_T[0]
+    
+    # Calculate the force vector: F = q * (u x B)
+    force_x = q_C * cross_product_x
+    force_y = q_C * cross_product_y
+    force_z = q_C * cross_product_z
+    
+    # Calculate the magnitude of the force
+    force_magnitude = math.sqrt(force_x**2 + force_y**2 + force_z**2)
+    
+    # 3. Generate the question and solution strings
+    
+    # Helper function to format vectors for display
+    def format_vector(v, units=""):
+        return f"({v[0]} x_hat + {v[1]} y_hat + {v[2]} z_hat) {units}".strip()
+
+    question = (
+        f"A point charge of {q_uC} uC has a velocity of u = {format_vector(u_vec, 'm/s')} "
+        f"in a uniform magnetic field described by B = {format_vector(B_vec_mT, 'mT')}.\n\n"
+        f"Determine the magnetic force vector F_m acting on the charge and its magnitude."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"  - Charge (q): {q_uC} uC\n"
+        f"  - Velocity (u): {format_vector(u_vec, 'm/s')}\n"
+        f"  - Magnetic Field (B): {format_vector(B_vec_mT, 'mT')}\n\n"
+        
+        f"**Step 1:** Convert Units to SI\n"
+        f"  First, we convert the given values to standard SI units for the calculation.\n"
+        f"  - Charge in Coulombs: q = {q_uC} * 1e-6 = {q_C:.2e} C\n"
+        f"  - Magnetic Field in Tesla: B = ({B_vec_T[0]:.2e} x_hat + {B_vec_T[1]:.2e} y_hat + {B_vec_T[2]:.2e} z_hat) T\n\n"
+        
+        f"**Step 2:** Calculate the Cross Product (u x B)\n"
+        f"  The force is determined by the formula F_m = q * (u x B). We start by calculating the cross product.\n"
+        f"  u x B = [ (u_y * B_z - u_z * B_y) x_hat + (u_z * B_x - u_x * B_z) y_hat + (u_x * B_y - u_y * B_x) z_hat ]\n"
+        f"  (u x B)_x = ({u_vec[1]}) * ({B_vec_T[2]:.2e}) - ({u_vec[2]}) * ({B_vec_T[1]:.2e}) = {cross_product_x:.4f}\n"
+        f"  (u x B)_y = ({u_vec[2]}) * ({B_vec_T[0]:.2e}) - ({u_vec[0]}) * ({B_vec_T[2]:.2e}) = {cross_product_y:.4f}\n"
+        f"  (u x B)_z = ({u_vec[0]}) * ({B_vec_T[1]:.2e}) - ({u_vec[1]}) * ({B_vec_T[0]:.2e}) = {cross_product_z:.4f}\n"
+        f"  So, u x B = ({round(cross_product_x, precision)} x_hat + {round(cross_product_y, precision)} y_hat + {round(cross_product_z, precision)} z_hat) T*m/s\n\n"
+
+        f"**Step 3:** Calculate the Force Vector (F_m)\n"
+        f"  Now, multiply the cross product by the charge q.\n"
+        f"  F_m = ({q_C:.2e} C) * ({round(cross_product_x, precision)} x_hat + {round(cross_product_y, precision)} y_hat + {round(cross_product_z, precision)} z_hat)\n"
+        f"  F_m = ({force_x:.{precision}e} x_hat + {force_y:.{precision}e} y_hat + {force_z:.{precision}e} z_hat) N\n\n"
+        
+        f"**Step 4:** Calculate the Magnitude of the Force\n"
+        f"  The magnitude is the square root of the sum of the squares of the components.\n"
+        f"  |F_m| = sqrt( ({force_x:.2e})^2 + ({force_y:.2e})^2 + ({force_z:.2e})^2 )\n"
+        f"  |F_m| = {force_magnitude:.{precision}e} N\n\n"
+        
+        f"**Answer:**\n"
+        f"  The magnetic force vector is F_m = ({force_x:.{precision}e} x_hat + {force_y:.{precision}e} y_hat + {force_z:.{precision}e} z_hat) N.\n"
+        f"  The magnitude of the force is |F_m| = {force_magnitude:.{precision}e} N."
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each magnetostatics template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/electrical_engineering/electromagnetics_and_waves/magnetostatics.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_lorentz_force, "lorentz_force", "Easy"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "electrical_engineering",
+                "domain": "electromagnetics_and_waves",
+                "area": "magnetostatics",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

data/templates/branches/electrical_engineering/electromagnetics_and_waves/waves_and_phasors.py

@@ -0,0 +1,650 @@
+import random
+import math
+from data.templates.branches.electrical_engineering.constants import C0, MEDIA_VELOCITIES 
+
+
+# Template 1 (Easy)
+def template_wave_parameters_basic():
+    """
+    Wave Parameter Fundamentals Calculation
+
+    Scenario:
+        This template explores the fundamental relationships that define a sinusoidal
+        traveling wave. These parameters (frequency, wavelength, period, etc.) describe
+        a wave's oscillatory behavior in both time and space. The problem provides the
+        wave's propagation speed (defined by its medium) and one other key parameter
+        (either frequency or wavelength), requiring the calculation of all other
+        related properties.
+
+    Core Equations:
+        u_p = f * lambda  
+        omega = 2 * pi * f  
+        T = 1 / f          
+        k = 2 * pi / lambda 
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to compute various wave parameters.
+            - str: A step-by-step solution showing the calculations.
+    """
+    # 1. Parameterize the inputs with random values
+    medium_name, u_p = random.choice(list(MEDIA_VELOCITIES.items()))
+    start_with_frequency = random.choice([True, False])
+
+    if start_with_frequency:
+        # Scenario 1: Given frequency and medium
+        f_mhz = round(random.uniform(50, 500), 1)
+        f = f_mhz * 1e6
+
+        # 2. Perform the core calculations
+        omega = 2 * math.pi * f
+        T = 1 / f
+        lambda_ = u_p / f
+        k = 2 * math.pi / lambda_
+
+        # 3. Generate the question and solution strings (Plain Text)
+        question = (
+            f"A sinusoidal wave with a frequency of {f_mhz} MHz is propagating "
+            f"through {medium_name}. Given that the phase velocity in this medium is "
+            f"{u_p:.2e} m/s, calculate the wave's:\n"
+            f"a) Angular frequency (omega)\n"
+            f"b) Period (T)\n"
+            f"c) Wavelength (lambda)\n"
+            f"d) Wavenumber (k)"
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"- Frequency (f) = {f_mhz} MHz = {f:.2e} Hz\n"
+            f"- Medium = {medium_name}\n"
+            f"- Phase Velocity (u_p) = {u_p:.2e} m/s\n\n"
+            
+            f"**Step 1:** Calculate the Angular Frequency (omega)\n"
+            f"The angular frequency is related to frequency by omega = 2 * pi * f.\n"
+            f"   omega = 2 * {math.pi:.5f} * ({f:.2e} Hz) = {omega:.2e} rad/s\n\n"
+
+            f"**Step 2:** Calculate the Period (T)\n"
+            f"The period is the inverse of the frequency, T = 1 / f.\n"
+            f"   T = 1 / ({f:.2e} Hz) = {T:.2e} s\n\n"
+
+            f"**Step 3:** Calculate the Wavelength (lambda)\n"
+            f"The wavelength is found using the phase velocity, lambda = u_p / f.\n"
+            f"   lambda = ({u_p:.2e} m/s) / ({f:.2e} Hz) = {round(lambda_, 3)} m\n\n"
+
+            f"**Step 4:** Calculate the Wavenumber (k)\n"
+            f"The wavenumber (or phase constant) is given by k = 2 * pi / lambda.\n"
+            f"   k = 2 * {math.pi:.5f} / {round(lambda_, 3)} m = {round(k, 2)} rad/m\n\n"
+
+            f"**Answer:**\n"
+            f"- Angular Frequency (omega): {omega:.2e} rad/s\n"
+            f"- Period (T): {T:.2e} s\n"
+            f"- Wavelength (lambda): {round(lambda_, 3)} m\n"
+            f"- Wavenumber (k): {round(k, 2)} rad/m"
+        )
+
+    else:
+        # Scenario 2: Given wavelength and medium
+        lambda_ = round(random.uniform(0.1, 2.0), 2)
+
+        # 2. Perform the core calculations
+        f = u_p / lambda_
+        omega = 2 * math.pi * f
+        T = 1 / f
+        k = 2 * math.pi / lambda_
+
+        # 3. Generate the question and solution strings (Plain Text)
+        question = (
+            f"An electromagnetic wave traveling in {medium_name} is observed to have "
+            f"a wavelength of {lambda_} m. Given that the phase velocity in this "
+            f"medium is {u_p:.2e} m/s, determine the wave's:\n"
+            f"a) Frequency (f)\n"
+            f"b) Angular frequency (omega)\n"
+            f"c) Period (T)\n"
+            f"d) Wavenumber (k)"
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"- Wavelength (lambda) = {lambda_} m\n"
+            f"- Medium = {medium_name}\n"
+            f"- Phase Velocity (u_p) = {u_p:.2e} m/s\n\n"
+            
+            f"**Step 1:** Calculate the Frequency (f)\n"
+            f"Frequency is found using the relation u_p = f * lambda, so f = u_p / lambda.\n"
+            f"   f = ({u_p:.2e} m/s) / ({lambda_} m) = {f:.2e} Hz = {f/1e6:.2f} MHz\n\n"
+            
+            f"**Step 2:** Calculate the Angular Frequency (omega)\n"
+            f"The angular frequency is omega = 2 * pi * f.\n"
+            f"   omega = 2 * {math.pi:.5f} * ({f:.2e} Hz) = {omega:.2e} rad/s\n\n"
+
+            f"**Step 3:** Calculate the Period (T)\n"
+            f"The period is the inverse of the frequency, T = 1 / f.\n"
+            f"   T = 1 / ({f:.2e} Hz) = {T:.2e} s\n\n"
+
+            f"**Step 4:** Calculate the Wavenumber (k)\n"
+            f"The wavenumber is given by k = 2 * pi / lambda.\n"
+            f"   k = 2 * {math.pi:.5f} / {lambda_} m = {round(k, 2)} rad/m\n\n"
+            
+            f"**Answer:**\n"
+            f"- Frequency (f): {f/1e6:.2f} MHz\n"
+            f"- Angular Frequency (omega): {omega:.2e} rad/s\n"
+            f"- Period (T): {T:.2e} s\n"
+            f"- Wavenumber (k): {round(k, 2)} rad/m"
+        )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_time_to_phasor():
+    """
+    Time-Domain to Phasor Conversion
+
+    Scenario:
+        This template tests the ability to convert a sinusoidal time-domain function
+        into its corresponding phasor representation. This is a foundational skill for
+        AC circuit analysis and wave analysis. The conversion requires identifying the
+        amplitude and phase, and applying a phase shift if the function is a sine wave.
+
+    Core Equations:
+        For v(t) = A * cos(omega*t + phi):
+        Phasor V = A * exp(j*phi) = A < phi
+        
+        Identity: sin(theta) = cos(theta - 90 deg)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the phasor form of a given time-domain signal.
+            - str: A step-by-step solution showing the conversion.
+    """
+    # 1. Parameterize the inputs with random values
+    amplitude = round(random.uniform(5.0, 150.0), 2)
+    omega = random.randint(100, 1000)
+    func_type = random.choice(['cos', 'sin'])
+    use_degrees = random.choice([True, False])
+
+    # Standardize precision for all calculations and outputs
+    precision = 2
+
+    # Generate phase in either degrees or radians
+    if use_degrees:
+        phi_deg = round(random.uniform(-180.0, 180.0), 1)
+        phi_rad = math.radians(phi_deg)
+        phi_str = f"{phi_deg} deg"
+    else:
+        phi_rad = round(random.uniform(-math.pi, math.pi), precision)
+        phi_deg = math.degrees(phi_rad)
+        phi_str = f"{phi_rad} rad"
+
+    # Construct the time-domain function string for the question
+    time_domain_expr = f"{amplitude} * {func_type}({omega}*t + {phi_str})"
+
+    # 2. Perform the core calculation
+    
+    # The final amplitude of the phasor is the amplitude of the signal
+    phasor_amplitude = amplitude
+    
+    # The final phase depends on whether the function is cos or sin
+    if func_type == 'cos':
+        phasor_phi_deg = phi_deg
+        phasor_phi_rad = phi_rad
+        conversion_step = (
+            "**Step 2:** Identify the function type.\n"
+            "   The function is a cosine, which is the standard reference for phasors. "
+            "No phase adjustment is needed.\n"
+            f"   The initial phase is {round(phi_deg, precision)} degrees.\n"
+        )
+    else: # func_type == 'sin'
+        phasor_phi_deg = phi_deg - 90
+        phasor_phi_rad = math.radians(phasor_phi_deg)
+        conversion_step = (
+            "**Step 2:** Convert the sine function to cosine.\n"
+            "   The sine function leads the cosine function by 90 degrees. To convert, "
+            "we use the identity sin(theta) = cos(theta - 90 deg).\n"
+            f"   New phase = (Initial Phase) - 90 deg = {round(phi_deg, precision)} - 90 = {round(phasor_phi_deg, precision)} degrees.\n"
+        )
+        
+    # Normalize the final phase angle to be between -180 and 180 degrees
+    phasor_phi_deg = (phasor_phi_deg + 180) % 360 - 180
+    phasor_phi_rad = math.radians(phasor_phi_deg)
+    
+    # Calculate rectangular components
+    real_part = phasor_amplitude * math.cos(phasor_phi_rad)
+    imag_part = phasor_amplitude * math.sin(phasor_phi_rad)
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A signal is described by the time-domain function:\n"
+        f"   v(t) = {time_domain_expr}\n\n"
+        f"Determine the phasor representation of this signal in both polar (A < phi) "
+        f"and rectangular (x + jy) forms. Use degrees for the phase angle."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"   The time-domain signal is v(t) = {time_domain_expr}.\n\n"
+        
+        f"**Step 1:** Extract the amplitude and initial phase.\n"
+        f"   By inspection, the amplitude (A) is {amplitude}.\n"
+        f"   The initial phase is {phi_str}.\n\n"
+        
+        f"{conversion_step}\n"
+        
+        f"**Step 3:** Write the phasor in polar form.\n"
+        f"   Phase angles are conventionally expressed in the range [-180°, 180°].\n"
+        f"   The phasor has the signal's amplitude and the adjusted phase.\n"
+        f"   Phasor V = {round(phasor_amplitude, precision)} < {round(phasor_phi_deg, precision)} degrees.\n\n"
+        
+        f"**Step 4:** Convert the polar form to rectangular form (x + jy).\n"
+        f"   x (real part) = A * cos(phi) = {round(phasor_amplitude, precision)} * cos({round(phasor_phi_deg, precision)} deg) = {round(real_part, precision)}\n"
+        f"   y (imaginary part) = A * sin(phi) = {round(phasor_amplitude, precision)} * sin({round(phasor_phi_deg, precision)} deg) = {round(imag_part, precision)}\n"
+        f"   Phasor V = {round(real_part, precision)} + j{round(imag_part, precision)}\n\n"
+
+        f"**Answer:**\n"
+        f"   The phasor representation is {round(phasor_amplitude, precision)} < {round(phasor_phi_deg, precision)} degrees, "
+        f"which is equivalent to {round(real_part, precision)} + j{round(imag_part, precision)}."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_wave_equation_interpretation():
+    """
+    Wave Equation Interpretation
+
+    Scenario:
+        This template tests the ability to extract fundamental wave parameters directly
+        from the mathematical expression of a traveling wave. It requires matching the
+        given equation to the standard form to identify key coefficients (amplitude,
+        angular frequency, wavenumber) and then using them to calculate related properties.
+
+    Core Equations:
+        f = omega / (2 * pi)
+        lambda = 2 * pi / k
+        u_p = omega / k
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question presenting a wave equation and asking for its properties.
+            - str: A step-by-step solution showing the analysis and calculations.
+    """
+    # 1. Parameterize the inputs with random values
+    amplitude = random.randint(10, 200)
+    
+    # Generate a realistic angular frequency (omega)
+    omega_multiple = random.randint(2, 9)
+    omega = omega_multiple * math.pi * 1e8
+    
+    # Generate a realistic phase velocity (u_p) by choosing a refractive index
+    # This ensures omega and k are physically consistent.
+    refractive_index = round(random.uniform(1.0, 2.5), 2)
+    u_p = C0 / refractive_index
+    
+    # Calculate wavenumber (k) based on omega and u_p
+    k = omega / u_p
+    
+    # Randomly determine the direction of propagation and phase
+    direction_sign_str = random.choice(['+', '-'])
+    phi_deg = random.randint(-180, 180)
+    
+    # Determine direction text for the solution
+    if direction_sign_str == '-':
+        direction_text = "the positive z-direction"
+    else:
+        direction_text = "the negative z-direction"
+
+    # Construct the wave equation string for the question
+    # Format omega for better readability in the question
+    omega_str = f"{omega_multiple}pi x 10^8"
+    wave_equation = (
+        f"E(z, t) = {amplitude} * cos({omega_str}*t {direction_sign_str} {round(k, 2)}*z + {phi_deg} deg) V/m"
+    )
+
+    # 2. Perform the core calculations for the solution
+    frequency = omega / (2 * math.pi)
+    wavelength = (2 * math.pi) / k
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"An electric field wave is described by the following equation:\n"
+        f"   {wave_equation}\n\n"
+        f"Based on this expression, determine the following properties of the wave:\n"
+        f"a) Amplitude (A)\n"
+        f"b) Direction of propagation\n"
+        f"c) Frequency (f)\n"
+        f"d) Wavelength (lambda)\n"
+        f"e) Phase velocity (u_p)"
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"   The wave equation is E(z, t) = {wave_equation}.\n\n"
+        
+        f"**Step 1:** Compare the equation to the standard form.\n"
+        f"   The standard form for a traveling wave is A * cos(omega*t +/- k*z + phi).\n"
+        f"   By matching the terms, we can extract the coefficients:\n"
+        f"   - Amplitude (A) = {amplitude} V/m\n"
+        f"   - Angular Frequency (omega) = {omega_str} rad/s = {omega:.3e} rad/s\n"
+        f"   - Wavenumber (k) = {round(k, 2)} rad/m\n"
+        f"   - The sign between the t and z terms is '{direction_sign_str}'.\n\n"
+        
+        f"**Step 2:** Determine the Amplitude and Direction of Propagation.\n"
+        f"   The amplitude (A) is the value multiplying the cosine function, which is {amplitude} V/m.\n"
+        f"   The direction is determined by the sign in front of the 'k*z' term. A minus sign (-) indicates propagation in the positive direction, while a plus sign (+) indicates the negative direction.\n"
+        f"   Therefore, the wave is traveling in {direction_text}.\n\n"
+        
+        f"**Step 3:** Calculate the Frequency (f).\n"
+        f"   Frequency is related to angular frequency by f = omega / (2 * pi).\n"
+        f"   f = ({omega:.3e} rad/s) / (2 * pi) = {frequency:.3e} Hz = {frequency/1e6:.2f} MHz.\n\n"
+        
+        f"**Step 4:** Calculate the Wavelength (lambda).\n"
+        f"   Wavelength is related to the wavenumber by lambda = 2 * pi / k.\n"
+        f"   lambda = (2 * pi) / ({round(k, 2)} rad/m) = {round(wavelength, 3)} m.\n\n"
+        
+        f"**Step 5:** Calculate the Phase Velocity (u_p).\n"
+        f"   Phase velocity is the speed of the wave, given by u_p = omega / k.\n"
+        f"   u_p = ({omega:.3e} rad/s) / ({round(k, 2)} rad/m) = {u_p:.3e} m/s.\n\n"
+        
+        f"**Answer:**\n"
+        f"   - Amplitude: {amplitude} V/m\n"
+        f"   - Direction of Propagation: {direction_text}\n"
+        f"   - Frequency: {frequency/1e6:.2f} MHz\n"
+        f"   - Wavelength: {round(wavelength, 3)} m\n"
+        f"   - Phase Velocity: {u_p:.3e} m/s"
+    )
+
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_phasor_addition():
+    """
+    Phasor Addition of Sinusoidal Waves
+
+    Scenario:
+        This template assesses the ability to add two sinusoidal waves of the same
+        frequency. The standard method is to convert both signals into their phasor
+        representations, perform complex number addition in rectangular form, convert
+        the result back to polar form, and finally express it as a time-domain signal.
+
+    Core Equations:
+        V_phasor = A < phi
+        x = A * cos(phi)
+        y = A * sin(phi)
+        A_total = sqrt(x_total^2 + y_total^2)
+        phi_total = atan2(y_total, x_total)
+        v_total(t) = A_total * cos(omega*t + phi_total)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the sum of two time-domain signals.
+            - str: A step-by-step solution using the phasor addition method.
+    """
+    # 1. Parameterize the inputs
+    precision = 2
+    
+    # Amplitudes
+    A1 = round(random.uniform(10.0, 50.0), precision)
+    A2 = round(random.uniform(10.0, 50.0), precision)
+    
+    # Phases in degrees
+    phi1_deg = round(random.uniform(-180.0, 180.0), 1)
+    phi2_deg = round(random.uniform(-180.0, 180.0), 1)
+    
+    # Shared angular frequency
+    omega = random.randint(100, 500)
+    
+    # Function types (cos or sin)
+    func_type1 = random.choice(['cos', 'sin'])
+    func_type2 = random.choice(['cos', 'sin'])
+
+    # 2. Generate the question string
+    v1_str = f"{A1} * {func_type1}({omega}*t + {phi1_deg} deg)"
+    v2_str = f"{A2} * {func_type2}({omega}*t + {phi2_deg} deg)"
+    
+    question = (
+        f"Two signals, v1(t) and v2(t), are defined as:\n"
+        f"   v1(t) = {v1_str}\n"
+        f"   v2(t) = {v2_str}\n\n"
+        f"Find the sum, v_total(t) = v1(t) + v2(t), using the phasor method. "
+        f"Express the final answer as a single cosine function."
+    )
+
+    # 3. Perform the calculations for the solution
+    
+    # --- Phasor 1 Conversion ---
+    phi1_adj_deg = phi1_deg - 90 if func_type1 == 'sin' else phi1_deg
+    phi1_rad = math.radians(phi1_adj_deg)
+    x1 = A1 * math.cos(phi1_rad)
+    y1 = A1 * math.sin(phi1_rad)
+
+    # --- Phasor 2 Conversion ---
+    phi2_adj_deg = phi2_deg - 90 if func_type2 == 'sin' else phi2_deg
+    phi2_rad = math.radians(phi2_adj_deg)
+    x2 = A2 * math.cos(phi2_rad)
+    y2 = A2 * math.sin(phi2_rad)
+
+    # --- Addition ---
+    x_total = x1 + x2
+    y_total = y1 + y2
+    
+    # --- Convert Sum back to Polar ---
+    A_total = math.hypot(x_total, y_total) # sqrt(x^2 + y^2)
+    phi_total_rad = math.atan2(y_total, x_total)
+    phi_total_deg = math.degrees(phi_total_rad)
+
+    # --- Final time-domain expression ---
+    v_total_str = f"{round(A_total, precision)} * cos({omega}*t + {round(phi_total_deg, precision)} deg)"
+
+    # 4. Generate the solution string
+    
+    # Helper strings for conversion steps
+    conv1_step = f"   Since v1(t) is a {func_type1} function, we adjust the phase: {phi1_deg} - 90 = {round(phi1_adj_deg, 1)} deg." if func_type1 == 'sin' else f"   Since v1(t) is a cosine function, no phase adjustment is needed. Phase = {phi1_deg} deg."
+    conv2_step = f"   Since v2(t) is a {func_type2} function, we adjust the phase: {phi2_deg} - 90 = {round(phi2_adj_deg, 1)} deg." if func_type2 == 'sin' else f"   Since v2(t) is a cosine function, no phase adjustment is needed. Phase = {phi2_deg} deg."
+    
+    solution = (
+        f"**Given:**\n"
+        f"   v1(t) = {v1_str}\n"
+        f"   v2(t) = {v2_str}\n\n"
+        
+        f"**Step 1:** Convert v1(t) to its phasor form V1.\n"
+        f"{conv1_step}\n"
+        f"   The polar form is V1 = {A1} < {round(phi1_adj_deg, 1)} deg.\n"
+        f"   Convert to rectangular form (x1 + jy1):\n"
+        f"   x1 = {A1} * cos({round(phi1_adj_deg, 1)}) = {round(x1, precision)}\n"
+        f"   y1 = {A1} * sin({round(phi1_adj_deg, 1)}) = {round(y1, precision)}\n"
+        f"   So, V1 = {round(x1, precision)} + j{round(y1, precision)}.\n\n"
+        
+        f"**Step 2:** Convert v2(t) to its phasor form V2.\n"
+        f"{conv2_step}\n"
+        f"   The polar form is V2 = {A2} < {round(phi2_adj_deg, 1)} deg.\n"
+        f"   Convert to rectangular form (x2 + jy2):\n"
+        f"   x2 = {A2} * cos({round(phi2_adj_deg, 1)}) = {round(x2, precision)}\n"
+        f"   y2 = {A2} * sin({round(phi2_adj_deg, 1)}) = {round(y2, precision)}\n"
+        f"   So, V2 = {round(x2, precision)} + j{round(y2, precision)}.\n\n"
+        
+        f"**Step 3:** Add the phasors in rectangular form: V_total = V1 + V2.\n"
+        f"   V_total = ({round(x1, precision)} + j{round(y1, precision)}) + ({round(x2, precision)} + j{round(y2, precision)})\n"
+        f"   V_total = ({round(x1, precision)} + {round(x2, precision)}) + j({round(y1, precision)} + {round(y2, precision)})\n"
+        f"   V_total = {round(x_total, precision)} + j{round(y_total, precision)}.\n\n"
+
+        f"**Step 4:** Convert the resultant phasor V_total back to polar form (A < phi).\n"
+        f"   A_total = sqrt({round(x_total, precision)}^2 + {round(y_total, precision)}^2) = {round(A_total, precision)}\n"
+        f"   phi_total = atan2({round(y_total, precision)}, {round(x_total, precision)}) = {round(phi_total_deg, precision)} deg\n"
+        f"   So, V_total = {round(A_total, precision)} < {round(phi_total_deg, precision)} deg.\n\n"
+
+        f"**Step 5:** Convert the final phasor back to the time domain.\n"
+        f"   The resulting signal has amplitude A_total, phase phi_total, and the original angular frequency omega.\n"
+        f"   v_total(t) = {v_total_str}\n\n"
+
+        f"**Answer:**\n"
+        f"   The sum of the two signals is v_total(t) = {v_total_str}."
+    )
+    
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_standing_wave_formation():
+    """
+    Standing Wave Formation and Properties
+
+    Scenario:
+        This template models the superposition of two identical waves traveling in
+        opposite directions, which creates a standing wave. It requires using a
+        trigonometric identity to derive the mathematical form of the standing wave
+        and then interpreting this form to find the locations of nodes (zero
+        amplitude) and antinodes (maximum amplitude).
+
+    Core Equations:
+        cos(a) + cos(b) = 2 * cos((a-b)/2) * cos((a+b)/2)
+        Standing Wave: y(x,t) = [2*A*cos(k*x)] * cos(omega*t)
+        Nodes: k*x = (n + 1/2)*pi
+        Antinodes: k*x = n*pi
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to derive and analyze a standing wave.
+            - str: A step-by-step solution showing the derivation and calculations.
+    """
+    # 1. Parameterize the inputs
+    precision = 2
+    A = random.randint(5, 50)
+    omega = random.randint(100, 500)
+    k = round(random.uniform(1.0, 5.0), precision)
+
+    # 2. Generate the question string
+    y1_str = f"{A} * cos({omega}*t - {k}*x)"
+    y2_str = f"{A} * cos({omega}*t + {k}*x)"
+    
+    question = (
+        f"Two waves of the same amplitude, frequency, and wavelength travel in opposite directions, given by:\n"
+        f"   y1(x,t) = {y1_str}\n"
+        f"   y2(x,t) = {y2_str}\n\n"
+        f"a) Find the superposition of these waves, y(x,t) = y1(x,t) + y2(x,t), and show that it represents a standing wave.\n"
+        f"b) Determine the locations of the first three nodes and antinodes for x >= 0."
+    )
+
+    # 3. Perform the calculations for the solution
+    
+    # Standing wave amplitude
+    standing_wave_amplitude = 2 * A
+    
+    # Wavelength
+    wavelength = (2 * math.pi) / k
+    
+    # Node locations
+    nodes = [(n + 0.5) * math.pi / k for n in range(3)]
+    
+    # Antinode locations
+    antinodes = [n * math.pi / k for n in range(3)]
+
+    # 4. Generate the solution string
+    
+    standing_wave_eq = f"{standing_wave_amplitude} * cos({k}*x) * cos({omega}*t)"
+    
+    solution = (
+        f"**Given:**\n"
+        f"   Incident wave y1(x,t) = {y1_str}\n"
+        f"   Reflected wave y2(x,t) = {y2_str}\n\n"
+        
+        f"**Step 1:** Sum the two traveling waves using a trigonometric identity.\n"
+        f"   We use the identity: cos(alpha) + cos(beta) = 2 * cos((alpha - beta)/2) * cos((alpha + beta)/2).\n"
+        f"   Let alpha = {omega}*t - {k}*x and beta = {omega}*t + {k}*x.\n"
+        f"   (alpha - beta)/2 = (({omega}*t - {k}*x) - ({omega}*t + {k}*x))/2 = -{k}*x\n"
+        f"   (alpha + beta)/2 = (({omega}*t - {k}*x) + ({omega}*t + {k}*x))/2 = {omega}*t\n"
+        f"   Substituting these into the identity and using cos(-z) = cos(z), we get:\n"
+        f"   y(x,t) = {A} * [2 * cos(-{k}*x) * cos({omega}*t)] = {standing_wave_eq}\n"
+        f"   This is the equation of a standing wave because the spatial dependence (cos({k}*x)) is separate from the time dependence (cos({omega}*t)).\n\n"
+
+        f"**Step 2:** Find the locations of the nodes.\n"
+        f"   Nodes are points of zero amplitude, which occur when the spatial term is zero: cos({k}*x) = 0.\n"
+        f"   This condition is met when k*x = (n + 1/2)*pi, for n = 0, 1, 2, ...\n"
+        f"   Solving for x: x = (n + 1/2) * pi / k.\n"
+        f"   - For n=0: x = (0.5 * pi) / {k} = {round(nodes[0], precision)}\n"
+        f"   - For n=1: x = (1.5 * pi) / {k} = {round(nodes[1], precision)}\n"
+        f"   - For n=2: x = (2.5 * pi) / {k} = {round(nodes[2], precision)}\n\n"
+
+        f"**Step 3:** Find the locations of the antinodes.\n"
+        f"   Antinodes are points of maximum amplitude, which occur when |cos({k}*x)| = 1.\n"
+        f"   This condition is met when k*x = n*pi, for n = 0, 1, 2, ...\n"
+        f"   Solving for x: x = n * pi / k.\n"
+        f"   - For n=0: x = (0 * pi) / {k} = {round(antinodes[0], precision)}\n"
+        f"   - For n=1: x = (1 * pi) / {k} = {round(antinodes[1], precision)}\n"
+        f"   - For n=2: x = (2 * pi) / {k} = {round(antinodes[2], precision)}\n\n"
+
+        f"**Answer:**\n"
+        f"   - The standing wave equation is y(x,t) = {standing_wave_eq}.\n"
+        f"   - The first three nodes are at x = {round(nodes[0], precision)}, {round(nodes[1], precision)}, and {round(nodes[2], precision)}.\n"
+        f"   - The first three antinodes are at x = {round(antinodes[0], precision)}, {round(antinodes[1], precision)}, and {round(antinodes[2], precision)}."
+    )
+    
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each waves and phasors template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/electrical_engineering/electromagnetics_and_waves/waves_and_phasors.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_wave_parameters_basic, "wave_parameters_basic", "Easy"),
+        (template_time_to_phasor, "time_to_phasor", "Easy"),
+        (template_wave_equation_interpretation, "wave_equation_interpretation", "Intermediate"),
+        (template_phasor_addition, "phasor_addition", "Intermediate"),
+        (template_standing_wave_formation, "standing_wave_formation", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "electrical_engineering",
+                "domain": "electromagnetics_and_waves",
+                "area": "waves_and_phasors",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,621 @@
+import random
+import math
+from fractions import Fraction
+from data.templates.branches.electrical_engineering.constants import FREQUENCY_RANGE_HZ, AMPLITUDE_RANGE, PHASE_RANGE_DEG, PHASE_RANGE_RAD, OMEGA_MULTIPLIER_RANGE, SAMPLING_FREQ_RANGE_HZ, F0_RANGE_HZ, GAIN_K_RANGE, DELAY_N0_RANGE, DECIMATION_FACTOR_M_RANGE, OMEGA_DENOMINATOR_RANGE
+
+
+# Template 1 (Easy)
+def template_nyquist_rate_determination():
+    """
+    Nyquist Rate Determination
+
+    Scenario:
+        This template tests the fundamental understanding of the Nyquist-Shannon
+        sampling theorem. The user must identify the highest frequency component in a
+        continuous-time signal and use it to calculate the minimum sampling rate
+        required to prevent aliasing.
+
+    Core Equations:
+        F_nyquist = 2 * F_max
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the Nyquist rate of a given signal.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+
+    # Determine the number of sinusoidal components in the signal
+    num_components = random.choice([2, 3])
+
+    # Generate a set of unique, random frequencies to serve as the basis for the problem.
+    # Using random.sample ensures all generated frequencies are distinct.
+    frequency_pool = range(FREQUENCY_RANGE_HZ[0], FREQUENCY_RANGE_HZ[1])
+    frequencies_hz = sorted(random.sample(frequency_pool, num_components), reverse=True)
+
+    signal_terms = []
+    for freq in frequencies_hz:
+        # For each frequency, generate a random amplitude, phase, and function type (sin/cos)
+        amplitude = round(random.uniform(*AMPLITUDE_RANGE), 1)
+        phase_deg = random.randint(*PHASE_RANGE_DEG)
+        func_type = random.choice(['cos', 'sin'])
+
+        # Create the mathematical term as a string
+        # Example: "15.5 * cos(2*pi*750*t + 45 deg)"
+        term_str = f"{amplitude} * {func_type}(2*pi*{freq}*t + {phase_deg} deg)"
+        signal_terms.append(term_str)
+
+    # Join the individual terms with a " + " to form the full signal equation
+    signal_expression = " + ".join(signal_terms)
+
+    # 2. Perform the core calculation for the solution
+    # The highest frequency determines the Nyquist rate.
+    f_max = max(frequencies_hz)
+
+    # The Nyquist rate is twice the maximum frequency.
+    f_nyquist = 2 * f_max
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A continuous-time signal is defined as:\n"
+        f"  x_c(t) = {signal_expression}\n\n"
+        f"What is the minimum sampling rate (Fs), also known as the Nyquist rate, "
+        f"required to sample this signal without loss of information?"
+    )
+
+    solution = (
+        f"**Given Signal:**\n"
+        f"x_c(t) = {signal_expression}\n\n"
+
+        f"**Step 1:** Identify Frequencies\n"
+        f"First, we identify all the unique frequency components in the signal's expression. "
+        f"By inspecting the '2*pi*F*t' part of each term, we find the frequencies are:\n"
+        f"Frequencies = {', '.join(map(str, frequencies_hz))} Hz.\n\n"
+
+        f"**Step 2:** Find Maximum Frequency\n"
+        f"The Nyquist rate is determined by the highest frequency component in the signal. "
+        f"We find the maximum value from the list of frequencies.\n"
+        f"F_max = max({', '.join(map(str, frequencies_hz))}) = {f_max} Hz.\n\n"
+
+        f"**Step 3:** Apply Nyquist Theorem\n"
+        f"The Nyquist-Shannon sampling theorem states that to avoid aliasing and be able "
+        f"to perfectly reconstruct a signal, the sampling rate (Fs) must be at least "
+        f"twice its highest frequency component (F_max).\n"
+        f"Fs_min = 2 * F_max.\n\n"
+
+        f"**Step 4:** Calculate the Nyquist Rate\n"
+        f"Using the maximum frequency found in Step 2, we calculate the Nyquist rate:\n"
+        f"FNyquist = 2 * {f_max} = {f_nyquist} Hz.\n\n"
+
+        f"**Answer:**\n"
+        f"The minimum sampling rate required to sample the signal without loss of "
+        f"information is {f_nyquist} Hz."
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_continuous_to_discrete_conversion():
+    """
+    Continuous-to-Discrete Signal Conversion
+
+    Scenario:
+        This template tests the direct application of the sampling process. The user is
+        given a continuous-time sinusoid and a sampling rate and must derive the
+        corresponding discrete-time sequence by substituting t=nT. It reinforces the
+        relationship between continuous and discrete frequencies (omega = Omega * T).
+
+    Core Equations:
+        x[n] = x_c(nT)
+        T = 1 / Fs
+        omega = Omega * T
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the discrete-time representation of a signal.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    amplitude = round(random.uniform(*AMPLITUDE_RANGE), 2)
+
+    # Generate a continuous-time angular frequency as an integer multiple of pi
+    omega_multiplier = random.randint(*OMEGA_MULTIPLIER_RANGE)
+    omega_continuous = omega_multiplier * math.pi
+    omega_continuous_str = f"{omega_multiplier}*pi"
+
+    # Randomly choose to express the phase in degrees or radians for variety
+    use_degrees = random.choice([True, False])
+    if use_degrees:
+        phi_deg = random.randint(*PHASE_RANGE_DEG)
+        phi_str = f"{phi_deg} deg"
+    else:
+        phi_rad = round(random.uniform(*PHASE_RANGE_RAD), 2)
+        phi_str = f"{phi_rad} rad"
+
+    # Generate a random sampling frequency
+    sampling_freq_hz = random.randint(*SAMPLING_FREQ_RANGE_HZ)
+
+    # Construct the full continuous-time signal expression for the question
+    signal_expression = f"{amplitude} * cos({omega_continuous_str}*t + {phi_str})"
+
+    # 2. Perform the core calculation for the solution
+    sampling_period = 1 / sampling_freq_hz
+
+    # The discrete-time angular frequency
+    omega_discrete = omega_continuous * sampling_period
+
+    # To create a clean, readable solution, simplify the fraction (multiplier / Fs)
+    omega_fraction = Fraction(omega_multiplier, sampling_freq_hz).limit_denominator()
+    num = omega_fraction.numerator
+    den = omega_fraction.denominator
+
+    # Format the omega string for the solution
+    if den == 1:
+        omega_discrete_str = f"{num}*pi" if num != 1 else "pi"
+    elif num == 1:
+        omega_discrete_str = f"pi/{den}"
+    else:
+        omega_discrete_str = f"({num}*pi)/{den}"
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A continuous-time signal is given by the expression:\n"
+        f"x_c(t) = {signal_expression}\n\n"
+        f"This signal is sampled at a frequency of {sampling_freq_hz} Hz. "
+        f"Determine the resulting discrete-time signal, x[n], and identify "
+        f"its discrete-time angular frequency, omega."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Continuous-time signal: x_c(t) = {signal_expression}\n"
+        f"Sampling frequency: Fs = {sampling_freq_hz} Hz\n\n"
+
+        f"**Step 1:** State the Sampling Rule\n"
+        f"A discrete-time signal x[n] is obtained by replacing the continuous time variable 't' "
+        f"with its discrete counterpart 'nT', where T is the sampling period. The rule is:\n"
+        f"x[n] = x_c(nT)\n\n"
+
+        f"**Step 2:** Calculate Sampling Period (T)\n"
+        f"The sampling period is the reciprocal of the sampling frequency.\n"
+        f"T = 1 / Fs = 1 / {sampling_freq_hz} seconds.\n\n"
+
+        f"**Step 3:** Substitute t = nT into the Equation\n"
+        f"We replace every 't' in the original expression with 'nT'.\n"
+        f"x[n] = {amplitude} * cos({omega_continuous_str}*(nT) + {phi_str})\n\n"
+
+        f"**Step 4:** Identify Discrete Frequency (omega)\n"
+        f"Rearrange the terms to match the standard form x[n] = A * cos(omega*n + phi). "
+        f"The discrete-time angular frequency, omega, is the coefficient of 'n'.\n"
+        f"omega = Omega * T\n"
+        f"omega = ({omega_continuous_str}) * (1 / {sampling_freq_hz})\n\n"
+
+        f"**Step 5:** Calculate and Conclude\n"
+        f"Now, we calculate the numerical value for omega and write the final expression.\n"
+        f"omega = ({omega_multiplier} / {sampling_freq_hz}) * pi = {omega_discrete_str} rad/sample\n"
+        f"The final discrete-time signal is:\n"
+        f"x[n] = {amplitude} * cos({omega_discrete_str}*n + {phi_str})\n\n"
+
+        f"**Answer:**\n"
+        f"The resulting discrete-time signal is x[n] = {amplitude} * cos({omega_discrete_str}*n + {phi_str}), "
+        f"and its discrete-time angular frequency is omega = {omega_discrete_str} rad/sample."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_aliased_frequency_identification():
+    """
+    Identifying Aliased Frequencies
+
+    Scenario:
+        This template assesses the ability to predict the outcome of undersampling (aliasing).
+        When a signal is sampled below its Nyquist rate, its frequency appears as a
+        lower "folded" frequency. This function generates a problem to calculate this
+        apparent frequency.
+
+    Core Equations:
+        Fa = abs(F0 - k * Fs), where k = round(F0 / Fs)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the apparent (aliased) frequency.
+            - str: A step-by-step solution showing the calculation.
+    """
+    # 1. Parameterize the inputs with random values
+
+    # Generate a random original frequency for the continuous-time signal.
+    f0 = random.randint(*F0_RANGE_HZ)
+
+    # Calculate the corresponding Nyquist rate for this signal.
+    f_nyquist = 2 * f0
+
+    # To guarantee aliasing, generate a sampling frequency (Fs) that is strictly
+    # less than the Nyquist rate. We set the range to be between 50% and 95% of
+    # the Nyquist rate to create a non-trivial undersampling problem.
+    fs = random.randint(int(0.5 * f_nyquist), int(0.95 * f_nyquist))
+
+    # 2. Perform the core calculation for the solution
+
+    # Find the integer multiple 'k' which represents the nearest multiple of the
+    # sampling frequency to the original frequency.
+    k = round(f0 / fs)
+
+    # Calculate the aliased frequency (Fa) using the folding formula.
+    fa = abs(f0 - k * fs)
+
+    # Standardize the precision for all final outputs for consistency.
+    precision = 2
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A continuous-time signal x_c(t) = cos(2*pi*{f0}*t) is sampled at a rate "
+        f"of {fs} samples per second.\n\n"
+        f"Since this rate is below the Nyquist rate, aliasing occurs. What is the "
+        f"apparent frequency, Fa, of the resulting discrete-time signal? "
+        f"(The apparent frequency must be in the range 0 <= Fa <= {fs/2} Hz)."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Original Frequency (F0): {f0} Hz\n"
+        f"Sampling Frequency (Fs): {fs} Hz\n\n"
+
+        f"**Step 1:** State the Condition\n"
+        f"The Nyquist rate required to sample this signal without aliasing is "
+        f"2 * F0 = 2 * {f0} = {f_nyquist} Hz. "
+        f"Since the sampling frequency Fs = {fs} Hz is less than {f_nyquist} Hz, "
+        f"the original frequency will be aliased.\n\n"
+
+        f"**Step 2:** Explain Frequency Folding\n"
+        f"When aliasing occurs, the perceived frequency (Fa) is the absolute "
+        f"difference between the original frequency and the nearest integer multiple "
+        f"of the sampling frequency. The formula is:\n"
+        f"Fa = abs(F0 - k * Fs), where 'k' is an integer.\n\n"
+
+        f"**Step 3:** Find the Correct Multiple (k)\n"
+        f"We find the integer 'k' that 'folds' F0 into the principal frequency "
+        f"range [0, Fs/2]. This is found by rounding the ratio of F0 to Fs.\n"
+        f"k = round(F0 / Fs) = round({f0} / {fs}) = round({round(f0/fs, 4)}) = {k}.\n\n"
+
+        f"**Step 4:** Calculate Aliased Frequency (Fa)\n"
+        f"Now, we compute Fa using the value of k found in the previous step.\n"
+        f"Fa = abs({f0} - {k} * {fs})\n"
+        f"Fa = abs({f0} - {k * fs})\n"
+        f"Fa = {round(fa, precision)} Hz.\n\n"
+
+        f"**Answer:**\n"
+        f"The apparent (aliased) frequency of the resulting signal is {round(fa, precision)} Hz."
+    )
+
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_cd_dc_system_analysis():
+    """
+    C/D and D/C System Analysis
+
+    Scenario:
+        This template models a full signal processing chain: a continuous-time signal is
+        sampled (C/D), processed by a simple discrete-time system (a gain and delay),
+        and perfectly reconstructed back to continuous-time (D/C). It tests the
+        understanding of how each stage affects the final signal.
+
+    Core Equations:
+        x[n] = x_c(nT)
+        y_c(t) is the ideal reconstruction of y[n].
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question describing the system and asking for the final output.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+
+    # --- Signal Parameters ---
+    amplitude = round(random.uniform(*AMPLITUDE_RANGE), 2)
+    omega_multiplier = random.randint(*OMEGA_MULTIPLIER_RANGE)
+    omega_continuous = omega_multiplier * math.pi
+    omega_continuous_str = f"{omega_multiplier}*pi"
+
+    # --- Sampling Parameters ---
+    # Ensure the Nyquist criterion is satisfied by a wide margin.
+    # F0 = Omega0 / (2*pi) = (multiplier*pi) / (2*pi) = multiplier / 2.
+    # F_nyquist = 2 * F0 = multiplier.
+    f_nyquist = omega_multiplier
+    # Sample at 3 to 8 times the Nyquist rate to make it a clear "ideal" case.
+    sampling_factor = random.randint(3, 8)
+    sampling_freq_hz = f_nyquist * sampling_factor
+    sampling_period = 1 / sampling_freq_hz
+
+    # --- System Parameters ---
+    gain_k = round(random.uniform(*GAIN_K_RANGE), 2)
+    delay_n0 = random.randint(*DELAY_N0_RANGE)
+
+    # 2. Perform the core calculations for the solution
+
+    # The final output amplitude is the original amplitude scaled by the system gain.
+    output_amplitude = round(amplitude * gain_k, 2)
+
+    # The total time delay is the discrete sample delay multiplied by the sampling period.
+    time_delay_sec = delay_n0 * sampling_period
+
+    # 3. Generate the question and solution strings
+
+    # Define the strings for the mathematical expressions
+    x_c_t_expr = f"{amplitude} * cos({omega_continuous_str}*t)"
+    system_expr = f"y[n] = {gain_k} * x[n - {delay_n0}]"
+    
+    question = (
+        f"A continuous-time signal is given by:\n"
+        f"x_c(t) = {x_c_t_expr}\n\n"
+        f"The signal is sampled with a period T = {sampling_period:.2e} s to produce the "
+        f"discrete-time sequence x[n]. This sequence is then processed by a system "
+        f"defined by the equation:\n"
+        f"{system_expr}\n\n"
+        f"If the resulting output sequence, y[n], is converted back to a continuous-time "
+        f"signal, y_c(t), using an ideal D/C converter, what is the expression for y_c(t)?"
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Continuous-time signal: x_c(t) = {x_c_t_expr}\n"
+        f"Sampling period: T = {sampling_period:.2e} s\n"
+        f"Discrete-time system: {system_expr}\n\n"
+
+        f"**Step 1:** Continuous-to-Discrete (C/D) Conversion\n"
+        f"We find the discrete-time signal x[n] by substituting t = nT into x_c(t).\n"
+        f"x[n] = x_c(nT) = {amplitude} * cos({omega_continuous_str} * nT)\n\n"
+
+        f"**Step 2:** Discrete-Time Processing\n"
+        f"Next, we apply the system's equation to x[n]. This involves replacing "
+        f"x[n] with the expression from Step 1 and shifting it by n0 = {delay_n0} samples.\n"
+        f"y[n] = {gain_k} * x[n - {delay_n0}]\n"
+        f"y[n] = {gain_k} * ({amplitude} * cos({omega_continuous_str} * (n - {delay_n0})T))\n"
+        f"y[n] = {output_amplitude} * cos({omega_continuous_str}*T*(n - {delay_n0}))\n\n"
+
+        f"**Step 3: ** Discrete-to-Continuous (D/C) Conversion*\n"
+        f"An ideal D/C converter maps the discrete-time signal back to a continuous-time "
+        f"sinusoid with the original frequency Omega_0 = {omega_continuous_str}. The discrete "
+        f"time 'n' is mapped back to continuous time 't' via the relation t = nT.\n"
+        f"y_c(t) = {output_amplitude} * cos({omega_continuous_str} * (t - {delay_n0}T))\n"
+        f"The term {delay_n0}*T represents a time delay. Let's calculate its value:\n"
+        f"Time Delay = {delay_n0} * T = {delay_n0} * {sampling_period:.2e} = {time_delay_sec:.2e} s\n"
+        f"Substituting this back, we get the final expression:\n"
+        f"y_c(t) = {output_amplitude} * cos({omega_continuous_str}*(t - {time_delay_sec:.2e}))\n\n"
+
+        f"**Step 4:** Interpret the Result\n"
+        f"The output signal y_c(t) is a modified version of the input signal x_c(t). "
+        f"Its amplitude has been scaled by a factor of K = {gain_k}, and it has been "
+        f"time-delayed by {time_delay_sec:.2e} seconds.\n\n"
+
+        f"**Answer:**\n"
+        f"The final continuous-time output signal is y_c(t) = {output_amplitude} * cos({omega_continuous_str}*(t - {time_delay_sec:.2e}))."
+    )
+
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_decimation_aliasing_analysis():
+    """
+    Decimation (Downsampling) with Aliasing Analysis
+
+    Scenario:
+        This template tests the understanding of decimation and its potential to cause
+        aliasing if the signal is not properly band-limited. The generated problem may
+        or may not result in aliasing, requiring a full analysis.
+
+    Core Equations:
+        y[n] = x[Mn]
+        Aliasing is avoided if omega_0 < pi / M.
+        omega_aliased = abs(omega_prime - 2*pi*k), where omega_prime = omega_0 * M.
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A multi-part question about the downsampled signal.
+            - str: A step-by-step solution with conditional aliasing analysis.
+    """
+    # 1. Parameterize the inputs with random values
+    M = random.randint(*DECIMATION_FACTOR_M_RANGE)
+    
+    # Randomly decide whether to create a problem that results in aliasing or not.
+    will_alias = random.choice([True, False])
+
+    # Generate an initial frequency omega_0 = (num/den)*pi based on the aliasing choice.
+    # The condition for NO aliasing is omega_0 < pi/M, which means num/den < 1/M.
+    denominator = random.randint(*OMEGA_DENOMINATOR_RANGE)
+    
+    if not will_alias:
+        # We need num/den < 1/M => num < den/M.
+        max_numerator = math.floor(denominator / M) - 1
+        if max_numerator < 1: max_numerator = 1 # Ensure at least one valid choice
+        numerator = random.randint(1, max_numerator)
+    else:
+        # We need num/den > 1/M => num > den/M.
+        min_numerator = math.ceil(denominator / M)
+        if min_numerator >= denominator: min_numerator = denominator - 1 # Ensure valid range
+        numerator = random.randint(min_numerator, denominator - 1)
+
+    # The original discrete-time frequency
+    omega_0 = (numerator / denominator) * math.pi
+
+    # --- In-line formatting for omega_0_str ---
+    frac_0 = Fraction(numerator, denominator)
+    n0, d0 = frac_0.numerator, frac_0.denominator
+    if d0 == 1:
+        omega_0_str = f"{n0}*pi" if n0 != 1 else "pi"
+    elif n0 == 1:
+        omega_0_str = f"pi/{d0}"
+    else:
+        omega_0_str = f"({n0}*pi)/{d0}"
+
+    # 2. Perform the core calculations for the solution
+    aliasing_boundary = math.pi / M
+    
+    # --- In-line formatting for aliasing_boundary_str ---
+    aliasing_boundary_str = f"pi/{M}"
+
+    # The new frequency after substitution before considering the principal range.
+    omega_prime = omega_0 * M
+
+    # --- In-line formatting for omega_prime_str ---
+    frac_prime = Fraction(numerator * M, denominator)
+    np, dp = frac_prime.numerator, frac_prime.denominator
+    if dp == 1:
+        omega_prime_str = f"{np}*pi" if np != 1 else "pi"
+    elif np == 1:
+        omega_prime_str = f"pi/{dp}"
+    else:
+        omega_prime_str = f"({np}*pi)/{dp}"
+    
+    # Calculate the final perceived frequency.
+    if not will_alias:
+        final_omega_str = omega_prime_str
+        k_val = 0 # No folding needed
+    else:
+        # The frequency must be folded back into the principal range [-pi, pi].
+        k_val = round(omega_prime / (2 * math.pi))
+        final_omega = abs(omega_prime - 2 * math.pi * k_val)
+        
+        # --- In-line formatting for final_omega_str ---
+        frac_final = Fraction(final_omega / math.pi).limit_denominator(100)
+        nf, df = frac_final.numerator, frac_final.denominator
+        if df == 1:
+            final_omega_str = f"{nf}*pi" if nf != 1 else "pi"
+        elif nf == 0:
+            final_omega_str = "0"
+        elif nf == 1:
+            final_omega_str = f"pi/{df}"
+        else:
+            final_omega_str = f"({nf}*pi)/{df}"
+
+    # 3. Generate the question and solution strings
+    question = (
+        f"A discrete-time signal is given by x[n] = cos({omega_0_str}*n).\n"
+        f"This signal is downsampled by a factor of M = {M} to produce the signal y[n] = x[Mn].\n\n"
+        f"a) Find an expression for the output signal y[n] in the form cos(omega'*n).\n"
+        f"b) The condition to avoid aliasing during downsampling is omega_0 < {aliasing_boundary_str}. Based on the given values, did aliasing occur?\n"
+        f"c) What is the final perceived angular frequency, omega_a, in the signal y[n]? (The frequency must be in the range 0 <= omega_a <= pi)."
+    )
+    
+    # Build the solution string piece by piece
+    solution = (
+        f"**Given:**\n"
+        f"Signal: x[n] = cos({omega_0_str}*n)\n"
+        f"Downsampling Factor: M = {M}\n\n"
+        
+        f"**Step 1:** Find the Output Signal Expression\n"
+        f"We substitute 'n' with 'Mn' in the original expression for x[n]:\n"
+        f"  y[n] = x[Mn] = cos({omega_0_str} * (Mn)) = cos(({omega_0_str} * {M}) * n)\n"
+        f"The new angular frequency, omega', is:\n"
+        f"  omega' = {omega_0_str} * {M} = {omega_prime_str}\n"
+        f"So, the expression is y[n] = cos({omega_prime_str}*n).\n\n"
+
+        f"**Step 2:** Check for Aliasing\n"
+        f"Aliasing is avoided if the original frequency omega_0 is less than pi/M.\n"
+        f"Aliasing Boundary = pi / M = {aliasing_boundary_str} approx {round(aliasing_boundary, 3)}\n"
+        f"Original Frequency = {omega_0_str} approx {round(omega_0, 3)}\n"
+        f"Comparing the two, we find that {omega_0_str} is {'NOT less' if will_alias else 'less'} than {aliasing_boundary_str}. "
+        f"Therefore, aliasing **{'occurred' if will_alias else 'did not occur'}**.\n\n"
+
+        f"**Step 3:** Find the Final Perceived Frequency (omega_a)\n"
+    )
+    
+    if not will_alias:
+        solution += (
+            f"Since no aliasing occurred, the frequency omega' = {omega_prime_str} is already in the principal range [0, pi].\n"
+            f"Therefore, the final perceived frequency is the same.\n"
+            f"omega_a = {final_omega_str}"
+        )
+    else:
+        # For clarity, re-calculate final_omega inside the solution string
+        final_omega_val = abs(omega_prime - 2 * math.pi * k_val)
+        solution += (
+            f"Because aliasing occurred, the frequency omega' = {omega_prime_str} is outside the principal range [0, pi] and must be 'folded' back.\n"
+            f"We find an integer 'k' such that omega_a = abs(omega' - 2*pi*k) is in the range [0, pi].\n"
+            f"k = round(omega' / (2*pi)) = round({omega_prime/math.pi:.2f}*pi / (2*pi)) = round({omega_prime/(2*math.pi):.2f}) = {k_val}\n"
+            f"Now we calculate omega_a:\n"
+            f"omega_a = abs({omega_prime_str} - 2*pi*{k_val})\n"
+            f"omega_a = abs({round(omega_prime, 3)} - {round(2*math.pi*k_val, 3)}) = {round(final_omega_val, 3)}\n"
+            f"In terms of pi, this is omega_a = {final_omega_str}.\n\n"
+        )
+        
+    solution += (
+        f"\n\n**Answer:**\n"
+        f"a) The output signal is y[n] = cos({omega_prime_str}*n).\n"
+        f"b) Aliasing **{'did' if will_alias else 'did not'}** occur.\n"
+        f"c) The final perceived frequency is omega_a = {final_omega_str}."
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each continuous time signals template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/electrical_engineering/signals_and_systems/continuous_time_signals.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_nyquist_rate_determination, "nyquist_rate_determination", "Easy"),
+        (template_continuous_to_discrete_conversion, "continuous_to_discrete_conversion", "Easy"),
+        (template_aliased_frequency_identification, "aliased_frequency_identification", "Intermediate"),
+        (template_cd_dc_system_analysis, "cd_dc_system_analysis", "Intermediate"),
+        (template_decimation_aliasing_analysis, "decimation_aliasing_analysis", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "electrical_engineering",
+                "domain": "signals_and_systems",
+                "area": "continuous_time_signals",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,817 @@
+import random
+import math
+
+
+# Template 1 (Easy)
+def template_signal_operations():
+    """
+    Signal Operations: Shifting and Reversal
+
+    Scenario:
+        This template tests the fundamental understanding of transformations on the
+        independent variable (time index 'n'). It requires applying a time-shift
+        (x[n-n0]) or a time-reversal (x[-n]) to a given finite-length sequence.
+        This is a core skill for understanding more complex operations like convolution.
+
+    Core Equations:
+        1. Time-Shift: y[n] = x[n - n0]
+        2. Time-Reversal: z[n] = x[-n]
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to perform a time-shift or time-reversal on a sequence.
+            - str: A step-by-step solution showing the transformation of the sequence.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Generate a sequence x[n] as a dictionary {index: value}
+    seq_length = random.randint(4, 7)
+    # Ensure the origin (n=0) is not at the absolute ends of the sequence
+    origin_position = random.randint(1, seq_length - 2)
+    start_index = -origin_position
+    
+    x_n = {start_index + i: random.randint(-10, 10) for i in range(seq_length)}
+    
+    # Choose the operation
+    operation = random.choice(['shift', 'reversal'])
+
+    # 2. Perform the core calculation and generate explanatory text
+    
+    if operation == 'shift':
+        # Select a non-zero shift amount
+        n0 = random.choice([-3, -2, -1, 1, 2, 3])
+        output_var = "y"
+        
+        # Core calculation: Shift the keys of the dictionary
+        result_n = {k + n0: v for k, v in x_n.items()}
+        
+        # Explanations for the solution
+        op_str_symbolic = f"x[n - ({n0})]" if n0 < 0 else f"x[n - {n0}]"
+        
+        direction = "left" if n0 < 0 else "right"
+        explanation = (
+            f"The operation is a time shift, {output_var}[n] = {op_str_symbolic}.\n"
+            f"This corresponds to a shift of the sequence to the {direction} by {abs(n0)} sample(s).\n"
+            f"The value at any original index 'k' is moved to a new index 'k + {n0}'."
+        )
+
+    else: # operation == 'reversal'
+        n0 = 0 # Not used, but needed for variable scope
+        output_var = "z"
+        
+        # Core calculation: Negate the keys of the dictionary
+        result_n = {-k: v for k, v in x_n.items()}
+        
+        # Explanations for the solution
+        op_str_symbolic = "x[-n]"
+        explanation = (
+            f"The operation is a time reversal, {output_var}[n] = {op_str_symbolic}.\n"
+            f"This corresponds to flipping the sequence about the origin (n=0).\n"
+            f"The value at any original index 'k' is moved to a new index '-k'."
+        )
+
+    # Inlined logic to format the input sequence x_n into a string
+    if not x_n:
+        x_n_str = "{}"
+    else:
+        min_idx = min(x_n.keys())
+        max_idx = max(x_n.keys())
+        parts = []
+        for i in range(min_idx, max_idx + 1):
+            val = x_n.get(i, 0)
+            if i == 0:
+                parts.append(f"*{val}*") # Asterisk denotes the origin n=0
+            else:
+                parts.append(str(val))
+        x_n_str = f"{{{', '.join(parts)}}}"
+
+    # Inlined logic to format the result sequence into a string
+    if not result_n:
+        result_n_str = "{}"
+    else:
+        min_idx = min(result_n.keys())
+        max_idx = max(result_n.keys())
+        parts = []
+        for i in range(min_idx, max_idx + 1):
+            val = result_n.get(i, 0)
+            if i == 0:
+                parts.append(f"*{val}*")
+            else:
+                parts.append(str(val))
+        result_n_str = f"{{{', '.join(parts)}}}"
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A discrete-time signal is defined by the sequence:\n"
+        f"x[n] = {x_n_str}\n\n"
+        f"Determine the resulting sequence, {output_var}[n], after applying the following transformation:\n"
+        f"{output_var}[n] = {op_str_symbolic}"
+    )
+    
+    # Inlined logic to build the transformation table for the solution
+    table_header = f"""| {'Original Index (k)':<20} | {'Original Value x[k]':<22} | {"New Index (k')":<18} | {"New Value y[k')":<20} |"""
+    table_separator = "-" * len(table_header)
+
+    table_rows_list = []
+    for k in sorted(x_n.keys()):
+        val = x_n[k]
+        if operation == 'shift':
+            new_k = k + n0
+        else: # reversal
+            new_k = -k
+        table_rows_list.append(f"| {k:<20} | {val:<22} | {new_k:<18} | {val:<20} |")
+
+    # Combine all parts of the table with newlines
+    transformation_table = f"{table_header}\n{table_separator}\n" + "\n".join(table_rows_list)
+
+    solution = (
+        f"**Given:**\n"
+        f"The original sequence is x[n] = {x_n_str}.\n"
+        f"The operation is {output_var}[n] = {op_str_symbolic}.\n\n"
+        
+        f"**Step 1:** Understand the Transformation\n"
+        f"{explanation}\n\n"
+        
+        f"**Step 2:** Apply the Transformation to Each Index\n"
+        f"We can create a table to track where each value moves:\n\n"
+        f"{transformation_table}\n\n"
+        
+        f"**Step 3:** Construct the Final Sequence\n"
+        f"By collecting the values at their new indices, we get the final sequence.\n"
+        f"Remember that any index not explicitly calculated has a value of 0.\n\n"
+        
+        f"**Answer:**\n"
+        f"The resulting sequence is {output_var}[n] = {result_n_str}"
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_system_properties_memory_causality():
+    """
+    System Properties: Memory and Causality 
+
+    Scenario:
+        This template tests the ability to analyze a discrete-time system's
+        input-output equation to determine two fundamental properties: whether it
+        is memoryless and whether it is causal. This requires applying the formal
+        definitions of these properties to the given equation.
+
+    Core Definitions:
+        1. Memoryless: Output y[n] depends only on the current input x[n].
+        2. Causal: Output y[n] depends only on present and past inputs x[k], where k <= n.
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking to determine if a system is memoryless and causal.
+            - str: A step-by-step solution analyzing each property with justifications.
+    """
+    # 1. Parameterize the inputs by generating a random system type and equation
+    
+    system_type = random.choice(['memoryless_causal', 'memory_causal', 'memory_noncausal'])
+    
+    is_memoryless = False
+    is_causal = False
+    equation_str = ""
+    memory_reason = ""
+    causality_reason = ""
+
+    if system_type == 'memoryless_causal':
+        is_memoryless = True
+        is_causal = True
+        
+        form = random.choice(['power', 'affine', 'scaled_by_n'])
+        if form == 'power':
+            power = random.randint(2, 3)
+            equation_str = f"(x[n])**{power}"
+            memory_reason = f"The output y[n] is the input x[n] raised to the power of {power} at the exact same time 'n'. The system does not need to store any other input values."
+        elif form == 'affine':
+            gain = random.randint(2, 9)
+            offset = random.randint(1, 10)
+            equation_str = f"{gain} * x[n] + {offset}"
+            memory_reason = f"The output y[n] at time 'n' is a scaled and shifted version of the input x[n] at the exact same time 'n'. No past or future values of the input are needed."
+        else: # scaled_by_n
+            equation_str = f"n * x[n]"
+            memory_reason = "The output y[n] depends on the input x[n] at the same time 'n', scaled by the time index 'n' itself. The time index 'n' is not an input signal value that needs to be stored."
+
+        causality_reason = "The output y[n] depends only on the input at the present time 'n'. Since no future inputs (k > n) are required, the system is causal."
+
+    elif system_type == 'memory_causal':
+        is_memoryless = False
+        is_causal = True
+        
+        delay = random.randint(1, 4)
+        form = random.choice(['simple_delay', 'with_present_term'])
+        
+        if form == 'simple_delay':
+            equation_str = f"x[n - {delay}]"
+            memory_reason = f"To compute the output y[n], the system needs to know the input from {delay} time step(s) in the past, x[n - {delay}]. Therefore, the system must have memory."
+        else: # with_present_term
+            equation_str = f"x[n] + x[n - {delay}]"
+            memory_reason = f"The output y[n] depends on both the current input x[n] and a past input x[n - {delay}]. The system must store or 'remember' the value of x[n - {delay}] to calculate the current output."
+
+        causality_reason = f"The output y[n] depends on the present input and/or past inputs (up to time n - {delay}). Since it does not depend on any future inputs, the system is causal."
+
+    else: # system_type == 'memory_noncausal'
+        is_memoryless = False
+        is_causal = False
+        
+        advance = random.randint(1, 4)
+        form = random.choice(['simple_advance', 'with_past_term'])
+
+        if form == 'simple_advance':
+            equation_str = f"x[n + {advance}]"
+            causality_reason = f"The output y[n] depends on the input at a future time, x[n + {advance}]. To calculate y[n], the system must know what the input will be {advance} time step(s) in the future. This violates the definition of causality."
+        else: # with_past_term
+            delay = random.randint(1, 2)
+            equation_str = f"x[n - {delay}] + x[n + {advance}]"
+            causality_reason = f"The output y[n] depends on a future input, x[n + {advance}]. Even though it also depends on a past input, the dependency on a future value makes the system non-causal."
+        
+        memory_reason = "The output y[n] depends on input values at times other than 'n'. Therefore, the system is not memoryless."
+
+    # 2. Generate the question and solution strings
+    
+    question = (
+        f"A discrete-time system is described by the input-output equation:\n"
+        f"y[n] = {equation_str}\n\n"
+        f"Determine if the system is:\n"
+        f"a) Memoryless\n"
+        f"b) Causal\n\n"
+        f"Justify your answers based on the definitions of these properties."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"The system's input-output equation is y[n] = {equation_str}.\n\n"
+
+        f"**Step 1:** Analyze the Memoryless Property\n"
+        f"**Definition:** A system is **memoryless** if its output at any time 'n' depends *only* on the input at the same time 'n'.\n"
+        f"**Analysis:** {memory_reason}\n"
+        f"**Conclusion:** Based on the analysis, the system is **{'memoryless' if is_memoryless else 'not memoryless'}**.\n\n"
+
+        f"**Step 2:** Analyze the Causality Property\n"
+        f"**Definition:** A system is **causal** if its output at any time 'n' depends *only* on the input at the present time 'n' and past times (i.e., on x[k] for k <= n).\n"
+        f"**Analysis:** {causality_reason}\n"
+        f"**Conclusion:** Based on the analysis, the system is **{'causal' if is_causal else 'not causal'}**.\n\n"
+
+        f"**Answer:**\n"
+        f"a) Memoryless: **{'Yes' if is_memoryless else 'No'}**\n"
+        f"b) Causal: **{'Yes' if is_causal else 'No'}**"
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_finite_convolution():
+    """
+    Convolution of Finite-Length Sequences 
+
+    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.
+
+    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 step-by-step solution demonstrating the convolution process.
+    """
+    # 1. Parameterize the inputs with random values
+
+    # Generate sequence x[n] as a dictionary {index: value}
+    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}
+    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
+    min_idx_x = min(x_n.keys())
+    max_idx_x = max(x_n.keys())
+    x_parts = []
+    for i in range(min_idx_x, max_idx_x + 1):
+        val = x_n.get(i, 0)
+        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
+    min_idx_h = min(h_n.keys())
+    max_idx_h = max(h_n.keys())
+    h_parts = []
+    for i in range(min_idx_h, max_idx_h + 1):
+        val = h_n.get(i, 0)
+        h_parts.append(f"*{val}*" if i == 0 else str(val))
+    h_n_str = f"{{{', '.join(h_parts)}}}"
+
+
+    # 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())
+
+    all_k_indices = sorted(list(x_n.keys()))
+    
+    for n in range(y_start_idx, y_end_idx + 1):
+        current_sum = 0
+        for k in all_k_indices:
+            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
+        if current_sum != 0:
+            y_n[n] = current_sum
+    
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"An LTI system has an impulse response h[n] = {h_n_str}.\n\n"
+        f"Determine the system's output, y[n] = x[n] * h[n], for the input x[n] = {x_n_str}."
+    )
+
+    # Build the detailed calculation steps for the solution
+    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
+    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]]
+
+    for n in y_indices_to_show:
+        step_str = f"For n = {n}:\n"
+        step_str += f"y[{n}] = sum( x[k] * h[{n}-k] )\n"
+        
+        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})")
+        
+        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
+    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 = []
+        for i in range(min_idx_y, max_idx_y + 1):
+            val = y_n.get(i, 0)
+            y_parts.append(f"*{val}*" if i == 0 else str(val))
+        y_n_str = f"{{{', '.join(y_parts)}}}"
+
+    y_values_list = [f"    y[{n}] = {y_n.get(n, 0)}" for n in range(y_start_idx, y_end_idx + 1)]
+    y_values_str = "\n".join(y_values_list)
+
+    calculation_steps_str = "\n".join(calculation_steps)
+        
+    solution = (
+        f"**Given:**\n"
+        f"Input Signal: x[n] = {x_n_str}\n"
+        f"Impulse Response: h[n] = {h_n_str}\n\n"
+
+        f"**Step 1:** State the Convolution Formula\n"
+        f"The output y[n] of an LTI system is the convolution of the input x[n] with the impulse response h[n]. The convolution sum is defined as:\n"
+        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"{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"{y_values_str}\n\n" 
+
+        f"**Answer:**\n"
+        f"The complete output sequence is y[n] = {y_n_str}"
+    )
+
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_system_property_linearity():
+    """
+    System Properties: 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.
+
+    Core Definitions:
+        1. Additivity: T{x1[n] + x2[n]} = T{x1[n]} + T{x2[n]}
+        2. Homogeneity: T{a * x[n]} = a * T{x[n]}
+
+    Returns:
+        tuple: A tuple containing:
+            - 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
+    
+    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 = ""
+    add_y3_str = ""
+    add_comparison_str = ""
+    
+    hom_ay1_str = ""
+    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])"
+        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])"
+        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}]"
+
+        # 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}]"
+        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}]"
+        hom_comparison_str = "Since ya[n] is equal to a * y1[n], the system satisfies the homogeneity property."
+        
+    elif system_type == 'nonlinear_offset':
+        is_linear = False
+        C = random.randint(1, 5) * random.choice([-1, 1])
+        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}"
+        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}"
+        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}"
+        
+        # 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."
+
+        # 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."
+        
+    # 2. Generate the question and solution strings
+    
+    question = (
+        f"A discrete-time system is governed by the equation:\n"
+        f"y[n] = {equation_str}\n\n"
+        f"Determine if this system is linear by testing the properties of additivity and homogeneity."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"The system equation is y[n] = {equation_str}.\n\n"
+        
+        f"**Step 1:** State the Conditions for Linearity\n"
+        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"**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"The sum of these outputs is:\n"
+        f"y1[n] + y2[n] = {add_y1y2_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"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"
+        f"ya[n] = {hom_ya_str}\n\n"
+        f"**Comparison:** {hom_comparison_str}\n\n"
+        
+        f"**Answer:**\n"
+        f"{'The system satisfies both additivity and homogeneity, therefore, the system is **linear**.' if is_linear else 'The system fails at least one of the tests (additivity or homogeneity), therefore, the system is **not linear**.'}"
+    )
+    
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_impulse_response_from_lccde():
+    """
+    Finding the Impulse Response from a Difference Equation (Advanced)
+
+    Scenario:
+        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.
+
+    Core Definitions:
+        1. Impulse Response: h[n] = T{delta[n]}
+        2. Causality: h[n] = 0 for n < 0
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the impulse response of a system given its LCCDE.
+            - str: A step-by-step solution detailing the recursive method.
+    """
+    # 1. Parameterize by randomly choosing system order and coefficients
+    
+    order = random.choice(['first', 'second'])
+    
+    # Generate coefficients with small integer values for clarity
+    b0 = random.randint(1, 4) * random.choice([-1, 1])
+    a1 = random.randint(1, 5) * random.choice([-1, 1])
+    
+    # Helper lambda to format coefficients into strings like "+ 3" or "- 2"
+    fmt = lambda c, v: f"+ {c}" if c > 0 else f"- {abs(c)}"
+    
+    if order == 'first':
+        # For first order, we can have b0*x[n] and b1*x[n-1] terms
+        b1 = random.randint(1, 4) * random.choice([-1, 1])
+        
+        # Build equation strings
+        y_terms = f"y[n] {fmt(a1, 'y[n-1]')}y[n-1]"
+        # Randomly omit b1 term for variety
+        if random.random() < 0.4:
+            b1 = 0
+        x_terms = f"{b0}x[n]"
+        if b1 != 0:
+            x_terms += f" {fmt(b1, 'x[n-1]')}x[n-1]"
+        
+        equation_str = f"{y_terms} = {x_terms}"
+        
+        # 2. Perform the core calculation for a first-order system
+        h0 = b0
+        h1 = b1 - a1 * h0
+        
+        term1_str = f"{h0}*delta[n]"
+        
+        h_decay_expr = ""
+        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]"
+        
+        final_h_n = f"{term1_str}{h_decay_expr}"
+        
+        # 3. Generate the solution string for a first-order system
+        solution_steps = (
+            f"**Step 3:** Solve Recursively for Initial Conditions\n"
+            f"We assume the system is causal, so **h[n] = 0 for n < 0**.\n\n"
+            f"**For n = 0:**\n"
+            f"h[0] {fmt(a1, 'h[-1]')}h[-1] = {b0}*delta[0] {'+ 0' if b1==0 else ' ' + fmt(b1, 'delta[-1]')+'*delta[-1]'}\n"
+            f"h[0] {fmt(a1, '0')}*(0) = {b0}*(1) + {b1}*(0)\n"
+            f"**h[0] = {h0}**\n\n"
+            
+            f"**For n = 1:**\n"
+            f"h[1] {fmt(a1, 'h[0]')}h[0] = {b0}*delta[1] {fmt(b1, 'delta[0]')}*delta[0]\n"
+            f"h[1] {fmt(a1, h0)}*({h0}) = {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 >= 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"**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"
+        )
+
+    else: # order == 'second'
+        # To guarantee real, distinct roots: D = a1^2 - 4*a2 > 0
+        a2 = random.randint(-5, 5)
+        if a2 == 0: a2 = 1 # Avoid trivial case
+        while a1**2 - 4*a2 <= 0:
+            a1 = random.randint(-6, 6)
+            if a1 == 0: a1 = 1
+        
+        # Randomize RHS for increased diversity
+        b1 = random.randint(-3, 3) if random.random() > 0.4 else 0
+        b2 = random.randint(-2, 2) if random.random() > 0.3 else 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]"
+        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
+        h0 = b0
+        h1 = b1 - a1 * h0
+        
+        # Correctly solve r^2 + a1*r + a2 = 0
+        discriminant = a1**2 - 4*a2
+        r1 = (-a1 + math.sqrt(discriminant)) / 2
+        r2 = (-a1 - math.sqrt(discriminant)) / 2
+        r1_str, r2_str = f"{r1:.2f}", f"{r2:.2f}"
+        
+        # Correctly solve for C1 and C2 with general h[0], h[1]
+        if abs(r1 - r2) < 1e-9: # Failsafe for very close roots
+            r1, r2 = round(r1, 2), round(r2, 2)
+        C1 = (h1 - h0 * r2) / (r1 - r2)
+        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]"
+        
+        # 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"
+            f"We assume the system is causal, so **h[n] = 0 for n < 0**.\n\n"
+            f"**For n = 0:**\n"
+            f"h[0] {fmt(a1, 'h[-1]')}h[-1] {fmt(a2, 'h[-2]')}h[-2] = {b0}*delta[0] ... (other delta terms are 0)\n"
+            f"h[0] {fmt(a1, '0')}*(0) {fmt(a2, '0')}*(0) = {b0}*(1)\n"
+            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] = {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"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"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"**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"
+            f"1) For n=0: h[0] = C1 + C2  =>  {h0} = C1 + C2\n"
+            f"2) For n=1: h[1] = C1*({r1_str}) + C2*({r2_str})  =>  {h1} = {r1_str}*C1 + {r2_str}*C2\n\n"
+            f"Solving this system yields:\n"
+            f"**C1 = {C1_str}** and **C2 = {C2_str}**\n"
+        )
+        
+    question = (
+        f"A causal LTI system is described by the difference equation:\n"
+        f"{equation_str}\n\n"
+        f"Find the impulse response h[n] of the system."
+    )
+    
+    solution = (
+        f"**Given:**\n"
+        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"**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"
+        f"{equation_str.replace('y', 'h').replace('x', 'delta')}\n\n"
+        
+        f"{solution_steps}\n"
+        
+        f"**Answer:**\n"
+        f"Substituting the coefficients back into the general form, the impulse response is:\n"
+        f"h[n] = {final_h_n}"
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each discrete time signals template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/electrical_engineering/signals_and_systems/discrete_time_signals.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_signal_operations, "signal_operations", "Easy"),
+        (template_system_properties_memory_causality, "system_properties_memory_causality", "Easy"),
+        (template_finite_convolution, "finite_convolution", "Intermediate"),
+        (template_system_property_linearity, "system_property_linearity", "Intermediate"),
+        (template_impulse_response_from_lccde, "impulse_response_from_lccde", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "electrical_engineering",
+                "domain": "signals_and_systems",
+                "area": "discrete_time_signals",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

data/templates/branches/mechanical_engineering/constants.py

@@ -0,0 +1,304 @@
+# E is the Modulus of Elasticity.
+MATERIAL_PROPERTIES = {
+    # Metals (Common)
+    'Steel': {'E_GPa': 200, 'E_ksi': 29000, 'nu': 0.30},
+    'Stainless Steel': {'E_GPa': 190, 'E_ksi': 27500, 'nu': 0.30}, # 304 Stainless
+    'Aluminum': {'E_GPa': 69, 'E_ksi': 10000, 'nu': 0.33}, # General purpose 1100, 3003 Al
+    'Aluminum 6061-T6': {'E_GPa': 68.9, 'E_ksi': 10000, 'nu': 0.33}, # A common specific alloy
+    'Copper': {'E_GPa': 117, 'E_ksi': 17000, 'nu': 0.34},
+    'Brass': {'E_GPa': 102, 'E_ksi': 14800, 'nu': 0.34}, # Yellow Brass (CuZn37)
+    'Bronze': {'E_GPa': 110, 'E_ksi': 16000, 'nu': 0.34}, # Phosphor Bronze
+    'Titanium': {'E_GPa': 116, 'E_ksi': 16800, 'nu': 0.34}, # Commercially Pure
+    'Titanium Alloy (6Al-4V)': {'E_GPa': 114, 'E_ksi': 16500, 'nu': 0.34},
+    'Magnesium': {'E_GPa': 45, 'E_ksi': 6500, 'nu': 0.29}, # AZ31B alloy
+    'Tungsten': {'E_GPa': 411, 'E_ksi': 59600, 'nu': 0.28},
+    'Cast Iron': {'E_GPa': 170, 'E_ksi': 24600, 'nu': 0.26}, # Gray Cast Iron
+    'Nickel': {'E_GPa': 207, 'E_ksi': 30000, 'nu': 0.31},
+    'Lead': {'E_GPa': 16, 'E_ksi': 2300, 'nu': 0.44}, # Added a common soft metal
+    
+    # Polymers/Plastics
+    'Nylon': {'E_GPa': 2.1, 'E_ksi': 300, 'nu': 0.39}, # Nylon 6/6
+    'Polycarbonate': {'E_GPa': 2.3, 'E_ksi': 334, 'nu': 0.38},
+    'ABS': {'E_GPa': 2.0, 'E_ksi': 290, 'nu': 0.35},
+    'PVC (rigid)': {'E_GPa': 3.0, 'E_ksi': 435, 'nu': 0.38},
+    'PTFE (Teflon)': {'E_GPa': 0.5, 'E_ksi': 72, 'nu': 0.46},
+    'Polyethylene (HDPE)': {'E_GPa': 1.1, 'E_ksi': 160, 'nu': 0.42},
+    'Epoxy': {'E_GPa': 3.0, 'E_ksi': 435, 'nu': 0.38}, # Unreinforced epoxy resin
+    'Natural Rubber': {'E_GPa': 0.0015, 'E_ksi': 0.22, 'nu': 0.4999}, # ~0.5 (nearly incompressible)
+    
+    # Composites & Other
+    'Carbon Fiber Reinforced Polymer (CFRP)': {'E_GPa': 150, 'E_ksi': 21750, 'nu': 0.30}, # Direction-dependent, this is a typical in-plane value
+    'Fiberglass (GFRP)': {'E_GPa': 45, 'E_ksi': 6500, 'nu': 0.25}, # Direction-dependent, typical in-plane value
+    'Concrete': {'E_GPa': 30, 'E_ksi': 4350, 'nu': 0.15}, # Highly variable, common approx.
+    'Glass (Borosilicate)': {'E_GPa': 70, 'E_ksi': 10150, 'nu': 0.20},
+    'Ceramic (Alumina Al2O3)': {'E_GPa': 370, 'E_ksi': 53700, 'nu': 0.22},
+}
+
+
+# Typical Shear Modulus (G) Values for Engineering Materials (GPa)
+# Note: Values are representative and can vary with alloy composition and heat treatment.
+SHEAR_MODULUS_VALUES = {
+    # Metals (Common Alloys)
+    "Steel (A36)": 77.2,
+    "Stainless Steel (304)": 77.0,
+    "Aluminum 6061-T6": 26.0,
+    "Aluminum 2024-T4": 28.0,
+    "Brass (C36000)": 39.0,
+    "Copper (CDA 110)": 44.7,
+    "Bronze (Phosphor 510)": 41.4,
+    "Titanium Alloy (Ti-6Al-4V)": 41.4,
+    "Magnesium Alloy (AZ31B)": 16.5,
+    "Tungsten": 160.0,
+    "Molybdenum": 118.0,
+    "Lead": 5.9,
+    
+    # Other Materials
+    "Gray Cast Iron": 44.0, # Note: Anisotropic property, value is an approximation.
+    "Nylon 6/6": 1.1,      # Polymers have much lower moduli
+    "Polycarbonate": 0.9,
+    "Concrete": 22.0,      # Highly variable, this is a common estimate for calculation
+    "Glass": 26.2,
+    
+    # Composites (Highly variable based on fiber orientation and volume fraction)
+    # Value given is an approximate in-plane shear modulus.
+    "Carbon Fiber Epoxy (Unidirectional, in-plane)": 5.0,
+}
+
+# Standard atmospheric pressure in kPa
+ATMOSPHERIC_PRESSURE_KPA = 101.325
+
+# Standard acceleration due to gravity in m/s^2
+GRAVITY = 9.81
+
+
+# Densities of common fluids in kg/m^3 at 20°C and 1 atm, unless specified.
+FLUID_DENSITIES = {
+    # Water-based
+    "Fresh Water": 998,         # More precise value for 20°C
+    "Sea Water": 1025,
+    "Brine (20% NaCl)": 1150,   # Common industrial solution
+    
+    # Oils and Hydrocarbons
+    "SAE 10W Oil": 870,
+    "SAE 30 Oil": 917,
+    "Crude Oil": 870,           # Typical average value
+    "Kerosene": 810,
+    "Diesel Fuel": 850,
+    "Gasoline": 726,
+    "Engine Oil": 888,
+    "Hydraulic Oil": 850,       # Typical average value
+    
+    # Alcohols and Solvents
+    "Ethyl Alcohol (Ethanol)": 789,
+    "Methyl Alcohol (Methanol)": 791,
+    "Isopropyl Alcohol (IPA)": 786,
+    "Acetone": 791,
+    "Turpentine": 870,
+    "Benzene": 876,
+    "Toluene": 867,
+    "Xylene": 870,
+    
+    # Cryogens & Liquefied Gases
+    "Liquid Nitrogen (at -196°C)": 807,
+    "Liquid Oxygen (at -183°C)": 1141,
+    "Liquid Hydrogen (at -253°C)": 71,
+    "Liquid Propane": 493,      # At 25°C, under pressure
+    
+    # High-Density Liquids
+    "Mercury": 13550,
+    "Glycerin": 1260,
+    "Chloroform": 1489,
+    "Carbon Tetrachloride": 1594,
+    "Bromine": 3120,
+    "Sulfuric Acid (98%)": 1830,
+    "Hydrochloric Acid (37%)": 1190, # Also known as Muriatic Acid
+    "Nitric Acid (68%)": 1350,
+    
+    # Common Liquids
+    "Milk": 1035,
+    "Whole Blood": 1060,        # Typical value for human blood
+    "Ethylene Glycol (Antifreeze)": 1113,
+    "Corn Syrup": 1380,
+    "Olive Oil": 910,
+    "Vegetable Oil": 920,
+    "R-134a Refrigerant (Saturated Liquid at 25°C)": 1206,
+    
+    # Gases (at 1 atm, for comparison - though not for hydrostatic problems!)
+    "Air (at 20°C)": 1.2,
+    "Helium (at 20°C)": 0.166,
+    "Carbon Dioxide (at 20°C)": 1.84
+}
+
+# Densities of various solid materials in kg/m^3
+MATERIAL_DENSITIES = {
+    # Woods & Natural Materials (generally float in water)
+    "Pine Wood": 500,
+    "Oak Wood": 750,
+    "Cork": 240,
+    "Teak Wood": 630,
+    "Maple Wood": 740,
+    "Ebony Wood": 1200,  # Sinks in water
+    "Bamboo": 300,
+    "Rubber (Natural)": 950,
+    
+    # Plastics & Synthetics (range from floating to sinking)
+    "Polypropylene (PP)": 900,
+    "Polyethylene (LDPE)": 920,
+    "Polyethylene (HDPE)": 950,
+    "Nylon": 1150,
+    "Polystyrene (PS)": 1050,
+    "PVC (Rigid)": 1380,
+    "PTFE (Teflon)": 2200,
+    "Acrylic (Plexiglas)": 1180,
+    
+    # Biological Materials
+    "Human Body (avg.)": 985,  # Slightly less than water; most people float
+    "Apple": 800,
+    "Bone": 1850,
+    
+    # Lightweight & Porous Materials
+    "Aerogel": 3,
+    "Pumice": 700,  # The only rock that floats!
+    "Brick": 1700,
+    "Concrete (avg.)": 2400,
+    
+    # Common Metals & Alloys (will sink in water, float in mercury)
+    "Aluminum": 2710,
+    "Titanium": 4500,
+    "Zinc": 7140,
+    "Tin": 7280,
+    "Iron (Wrought)": 7750,
+    "Steel (Carbon)": 7850,
+    "Brass": 8600,
+    "Copper": 8940,
+    "Nickel": 8900,
+    "Silver": 10500,
+    "Lead": 11340,
+    "Uranium": 19100,
+    "Gold": 19300,
+    "Tungsten": 19600,
+    "Platinum": 21450,
+    "Osmium": 22590,  # The densest naturally occurring element
+    
+    # Other Materials
+    "Ice (0°C)": 917,
+    "Wax (Paraffin)": 900,
+    "Glass (Window)": 2500,
+    "Glass (Crystal)": 2900,
+    "Graphite": 2100,
+    "Diamond": 3500,
+    "Quartz": 2650,
+    "Granite": 2700,
+    "Marble": 2700,
+    "Sandstone": 2300,
+    "Limestone": 2500,
+    "Cork Board": 240,
+    "Paper": 800,
+    "Leather (Dry)": 860,
+    "Chalk": 2500,
+    "Asphalt": 1100,
+    "Coal (Anthracite)": 1500,
+}
+
+OBJECT_SHAPES = [
+    "sphere", "cube", "irregular block", "cylinder", "anchor",
+    "rectangular prism", "cone", "pyramid", "torpedo", "submarine hull",
+    "ball", "ingot", "pipe section", "bead", "marble",
+    "statue", "metal ball", "wooden block", "concrete piling", "boat hull",
+    "metal rod", "canister", "storage tank", "buoy", "weight",
+    "metal box", "stone", "boulder", "metal cylinder", "plastic container"
+]
+
+OBJECT_MATERIALS = [
+    "steel", "aluminum", "copper", "concrete", "plastic",
+    "wood (oak)", "wood (pine)", "glass", "gold", "lead",
+    "brass", "bronze", "iron", "titanium", "rubber",
+    "cork", "foam", "ice", "wax", "ceramic",
+    "polyethylene", "PVC", "fiberglass", "granite", "marble",
+    "ebony", "balsa wood", "uranium", "magnesium", "tungsten"
+]
+
+# Densities of common fluids in kg/m^3
+# Lighter fluids suitable for the pipe
+PIPE_FLUIDS = {
+    # Gases (Very Light)
+    "Air": 1.225,
+    "Helium": 0.1786,
+    "Hydrogen": 0.0899,
+    "Natural Gas (Methane)": 0.717,
+    "Carbon Dioxide": 1.98,
+    
+    # Light Hydrocarbons & Fuels
+    "Gasoline": 726,
+    "Kerosene": 810,
+    "Diesel Fuel": 850,
+    "Jet Fuel (JP-4)": 770,
+    "Ethanol": 789,
+    "Methanol": 791,
+    "Isopropyl Alcohol": 786,
+    
+    # Oils & Lubricants
+    "SAE 10 Oil": 870,
+    "SAE 20 Oil": 880,
+    "SAE 30 Oil": 917,
+    "SAE 40 Oil": 945,
+    "SAE 50 Oil": 960,
+    "Crude Oil (Light)": 825,
+    "Crude Oil (Heavy)": 950,
+    "Engine Oil": 888,
+    "Hydraulic Oil": 860,
+    
+    # Common Liquids
+    "Water": 1000,
+    "Sea Water": 1025,
+    "Milk": 1030,
+    "Ethylene Glycol": 1110,
+    "Antifreeze (50/50)": 1065,
+    
+    # Cryogenic Fluids
+    "Liquid Nitrogen": 810,
+    "Liquid Oxygen": 1141,
+    
+    # Chemical Solvents
+    "Acetone": 784,
+    "Toluene": 867,
+    "Benzene": 876,
+    "Hexane": 655
+}
+
+# Denser fluids suitable for the manometer
+MANOMETER_FLUIDS = {
+    # Standard Manometer Fluids
+    "Mercury": 13550,
+    "Water": 1000,  # For gas measurements
+    "Sea Water": 1025,
+    
+    # Heavy Oils & Lubricants
+    "SAE 50 Oil": 960,
+    "SAE 90 Gear Oil": 920,
+    
+    # Organic Liquids
+    "Carbon Tetrachloride": 1590,
+    "Chloroform": 1480,
+    "Bromine": 3120,
+    "Tetrabromoethane": 2960,
+    
+    # Inorganic Solutions
+    "Calcium Chloride Solution (40%)": 1390,
+    "Zinc Chloride Solution (50%)": 1520,
+    "Sodium Polysulfide": 1650,
+    
+    # Specialty Fluids
+    "Glycerin": 1260,
+    "Diiodomethane": 3325,
+    "Acetylene Tetrabromide": 2960,
+    
+    # Molten Metals (for high-temperature applications)
+    "Gallium": 6095,
+    "Tin": 6980,
+    "Zinc": 6570,
+    
+    # Very Heavy Fluids
+    "Tellurium Mercury": 8100,
+    "Tungsten Hexafluoride": 12900
+}

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

@@ -0,0 +1,734 @@
+import random
+import math
+
+
+# Template 1 (Easy)
+def template_fluid_particle_acceleration():
+    """
+    Fluid Kinematics: Fluid Particle Acceleration in a 2D Field
+
+    Scenario:
+        This template generates a problem that tests the ability to calculate the
+        acceleration of a fluid particle at a specific point and time. It requires
+        applying the material derivative to a given 2D unsteady velocity field.
+        The problem distinguishes between the local (time-based) and convective
+        (space-based) components of acceleration.
+
+    Core Equations:
+        Velocity Field: V(x, y, t) = u(x, y, t)i + v(x, y, t)j
+        Acceleration (ax) = du/dt + u*(du/dx) + v*(du/dy)
+        Acceleration (ay) = dv/dt + u*(dv/dx) + v*(dv/dy)
+        Total Acceleration (a) = sqrt(ax^2 + ay^2)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the acceleration components and magnitude.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values for high diversity
+    
+    # Coefficients for the velocity field polynomials
+    # u = A*x*t + B*y**2
+    # v = C*x*y + D*t**2
+    A = random.randint(1, 10)
+    B = random.randint(1, 10)
+    C = random.randint(1, 10)
+    D = random.randint(1, 10)
+
+    # Specific point (x, y) and time (t) for evaluation
+    x_point = round(random.uniform(0.5, 5.0), 1)
+    y_point = round(random.uniform(0.5, 5.0), 1)
+    t_point = round(random.uniform(0.1, 3.0), 1)
+
+    # Standardize precision for all calculations and outputs
+    precision = 3
+
+    # 2. Perform the core calculations for the solution
+
+    # Step A: Evaluate velocity components u and v at the given point and time
+    u_val = A * x_point * t_point + B * y_point**2
+    v_val = C * x_point * y_point + D * t_point**2
+
+    # Step B: Calculate all necessary partial derivatives
+    # For u(x, y, t) = A*x*t + B*y^2
+    du_dt = A * x_point
+    du_dx = A * t_point
+    du_dy = 2 * B * y_point
+
+    # For v(x, y, t) = C*x*y + D*t^2
+    dv_dt = 2 * D * t_point
+    dv_dx = C * y_point
+    dv_dy = C * x_point
+    
+    # Step C: Calculate the acceleration components (ax and ay)
+    # ax = (local acceleration in x) + (convective acceleration in x)
+    local_ax = du_dt
+    convective_ax = u_val * du_dx + v_val * du_dy
+    ax = local_ax + convective_ax
+
+    # ay = (local acceleration in y) + (convective acceleration in y)
+    local_ay = dv_dt
+    convective_ay = u_val * dv_dx + v_val * dv_dy
+    ay = local_ay + convective_ay
+
+    # Step D: Calculate the magnitude of the total acceleration
+    a_magnitude = math.sqrt(ax**2 + ay**2)
+
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"The velocity field of a fluid is given by the equations:\n"
+        f"u = {A}xt + {B}y^2\n"
+        f"v = {C}xy + {D}t^2\n"
+        f"where u and v are in m/s, and x and y are in meters, and t is in seconds.\n\n"
+        f"Determine the acceleration components (ax and ay) and the magnitude of the "
+        f"acceleration for a fluid particle at the point ({x_point}, {y_point}) m at time t = {t_point} s."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Velocity component u = {A}xt + {B}y^2\n"
+        f"Velocity component v = {C}xy + {D}t^2\n"
+        f"Point of interest: (x, y) = ({x_point}, {y_point}) m\n"
+        f"Time of interest: t = {t_point} s\n\n"
+
+        f"**Step 1:** Calculate the acceleration component in the x-direction (ax).\n"
+        f"The formula is: ax = du/dt + u*(du/dx) + v*(du/dy)\n\n"
+        
+        f"First, find the required partial derivatives of u:\n"
+        f"du/dt = d/dt({A}xt + {B}y^2) = {A}x  -> At ({x_point}, {t_point}), du/dt = {A} * {x_point} = {round(du_dt, precision)}\n"
+        f"du/dx = d/dx({A}xt + {B}y^2) = {A}t  -> At ({x_point}, {t_point}), du/dx = {A} * {t_point} = {round(du_dx, precision)}\n"
+        f"du/dy = d/dy({A}xt + {B}y^2) = {2*B}y  -> At ({y_point}), du/dy = {2*B} * {y_point} = {round(du_dy, precision)}\n\n"
+
+        f"Next, evaluate u and v at the specified point and time:\n"
+        f"u = {A}({x_point})({t_point}) + {B}({y_point})^2 = {round(u_val, precision)} m/s\n"
+        f"v = {C}({x_point})({y_point}) + {D}({t_point})^2 = {round(v_val, precision)} m/s\n\n"
+
+        f"Now, substitute these values into the acceleration formula for ax:\n"
+        f"ax = (du/dt) + u*(du/dx) + v*(du/dy)\n"
+        f"ax = {round(du_dt, precision)} + ({round(u_val, precision)})*({round(du_dx, precision)}) + ({round(v_val, precision)})*({round(du_dy, precision)})\n"
+        f"ax = {round(local_ax, precision)} + {round(convective_ax, precision)} = {round(ax, precision)} m/s^2\n\n"
+
+        f"**Step 2:** Calculate the acceleration component in the y-direction (ay).\n"
+        f"The formula is: ay = dv/dt + u*(dv/dx) + v*(dv/dy)\n\n"
+
+        f"First, find the required partial derivatives of v:\n"
+        f"dv/dt = d/dt({C}xy + {D}t^2) = {2*D}t  -> At ({t_point}), dv/dt = {2*D} * {t_point} = {round(dv_dt, precision)}\n"
+        f"dv/dx = d/dx({C}xy + {D}t^2) = {C}y  -> At ({y_point}), dv/dx = {C} * {y_point} = {round(dv_dx, precision)}\n"
+        f"dv/dy = d/dy({C}xy + {D}t^2) = {C}x  -> At ({x_point}), dv/dy = {C} * {x_point} = {round(dv_dy, precision)}\n\n"
+
+        f"Using the already calculated u and v values:\n"
+        f"ay = (dv/dt) + u*(dv/dx) + v*(dv/dy)\n"
+        f"ay = {round(dv_dt, precision)} + ({round(u_val, precision)})*({round(dv_dx, precision)}) + ({round(v_val, precision)})*({round(dv_dy, precision)})\n"
+        f"ay = {round(local_ay, precision)} + {round(convective_ay, precision)} = {round(ay, precision)} m/s^2\n\n"
+
+        f"**Step 3:** Calculate the magnitude of the total acceleration.\n"
+        f"The formula is: a = sqrt(ax^2 + ay^2)\n"
+        f"a = sqrt(({round(ax, precision)})^2 + ({round(ay, precision)})^2)\n"
+        f"a = {round(a_magnitude, precision)} m/s^2\n\n"
+        
+        f"**Answer:**\n"
+        f"The acceleration components are ax = {round(ax, precision)} m/s^2 and ay = {round(ay, precision)} m/s^2.\n"
+        f"The magnitude of the acceleration is {round(a_magnitude, precision)} m/s^2."
+    )
+
+    return question, solution
+
+
+# Template 2 (Intermediate)
+def template_volumetric_flow_rate():
+    """
+    Fluid Kinematics: Volumetric Flow Rate from a Velocity Profile
+
+    Scenario:
+        This template assesses the ability to calculate the volumetric flow rate (Q)
+        by integrating a given velocity profile over a cross-sectional area. It also
+        calculates the average velocity. The problem randomly selects between flow
+        in a circular pipe (parabolic profile) and flow in a rectangular channel
+        (linear profile).
+
+    Core Equations:
+        Volumetric Flow Rate: Q = integral(u dA)
+        Average Velocity: V_avg = Q / A
+        Pipe Profile: u(r) = U_max * (1 - (r/R)^2), dA = 2*pi*r dr
+        Channel Profile: u(y) = U_max * (y/H), dA = W dy
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the flow rate and average velocity.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values
+    geometry = random.choice(['pipe', 'channel'])
+    u_max = round(random.uniform(0.5, 10.0), 2)
+    precision = 4
+
+    # 2. Perform calculations and generate strings based on the chosen geometry
+    if geometry == 'pipe':
+        # --- Pipe-specific parameters ---
+        diameter_mm = random.randint(20, 200)
+        radius_m = diameter_mm / 2000.0
+
+        # --- 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 ---
+        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 "
+            f"velocity U_max is {u_max} m/s at the centerline (r=0).\n\n"
+            f"Determine the volumetric flow rate (Q) and the average velocity (V_avg) of the fluid."
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"Geometry: Circular Pipe\n"
+            f"Diameter (D) = {diameter_mm} mm\n"
+            f"Maximum Velocity (U_max) = {u_max} m/s\n"
+            f"Velocity Profile: u(r) = U_max * (1 - (r/R)^2)\n\n"
+
+            f"**Step 1:** Determine pipe dimensions in meters.\n"
+            f"Radius (R) = D / 2 = {diameter_mm} / 2 = {diameter_mm/2.0} mm = {radius_m} m\n\n"
+
+            f"**Step 2:** Set up the integral for volumetric flow rate (Q).\n"
+            f"The formula is Q = integral(u dA) over the cross-sectional area.\n"
+            f"For a circular pipe, the differential area is a thin ring: dA = 2*pi*r dr.\n"
+            f"Q = integral from 0 to R of [U_max * (1 - (r/R)^2)] * (2*pi*r dr)\n"
+            f"Q = 2*pi*U_max * integral from 0 to R of (r - r^3/R^2) dr\n\n"
+
+            f"**Step 3:** Evaluate the integral.\n"
+            f"Q = 2*pi*U_max * [r^2/2 - r^4/(4*R^2)] from 0 to R\n"
+            f"Q = 2*pi*U_max * [(R^2/2 - R^4/(4*R^2)) - 0]\n"
+            f"Q = 2*pi*U_max * [R^2/4] = (pi*R^2*U_max) / 2\n\n"
+
+            f"**Step 4:** Substitute numerical values to find Q.\n"
+            f"Q = (pi * ({radius_m})^2 * {u_max}) / 2\n"
+            f"Q = {round(flow_rate, precision)} m^3/s\n\n"
+
+            f"**Step 5:** Calculate the average velocity (V_avg).\n"
+            f"First, calculate the cross-sectional area (A) = pi*R^2\n"
+            f"A = pi * ({radius_m})^2 = {round(area, precision)} m^2\n"
+            f"V_avg = Q / A = {round(flow_rate, precision)} / {round(area, precision)}\n"
+            f"Alternatively, for this profile, V_avg is known to be U_max / 2.\n"
+            f"V_avg = {u_max} / 2 = {round(avg_velocity, precision)} m/s\n\n"
+
+            f"**Answer:**\n"
+            f"The volumetric flow rate is {round(flow_rate, precision)} m^3/s, and the average velocity is {round(avg_velocity, precision)} m/s."
+        )
+
+    else: # geometry == 'channel'
+        # --- 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 ---
+        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 ---
+        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 "
+            f"maximum velocity U_max is {u_max} m/s at the top surface (y=H).\n\n"
+            f"Determine the volumetric flow rate (Q) and the average velocity (V_avg) of the fluid."
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"Geometry: Rectangular Channel\n"
+            f"Width (W) = {width_cm} cm\n"
+            f"Height (H) = {height_cm} cm\n"
+            f"Maximum Velocity (U_max) = {u_max} m/s\n"
+            f"Velocity Profile: u(y) = U_max * (y/H)\n\n"
+
+            f"**Step 1:** Determine channel dimensions in meters.\n"
+            f"Width (W) = {width_cm} cm = {width_m} m\n"
+            f"Height (H) = {height_cm} cm = {height_m} m\n\n"
+
+            f"**Step 2:** Set up the integral for volumetric flow rate (Q).\n"
+            f"The formula is Q = integral(u dA) over the cross-sectional area.\n"
+            f"For a rectangular channel, the differential area is a thin horizontal strip: dA = W dy.\n"
+            f"Q = integral from 0 to H of [U_max * (y/H)] * (W dy)\n"
+            f"Q = (W*U_max/H) * integral from 0 to H of (y) dy\n\n"
+
+            f"**Step 3:** Evaluate the integral.\n"
+            f"Q = (W*U_max/H) * [y^2/2] from 0 to H\n"
+            f"Q = (W*U_max/H) * [(H^2/2) - 0]\n"
+            f"Q = (W*U_max*H) / 2\n\n"
+
+            f"**Step 4:** Substitute numerical values to find Q.\n"
+            f"Q = ({width_m} * {u_max} * {height_m}) / 2\n"
+            f"Q = {round(flow_rate, precision)} m^3/s\n\n"
+
+            f"**Step 5:** Calculate the average velocity (V_avg).\n"
+            f"First, calculate the cross-sectional area (A) = W * H\n"
+            f"A = {width_m} * {height_m} = {round(area, precision)} m^2\n"
+            f"V_avg = Q / A = {round(flow_rate, precision)} / {round(area, precision)}\n"
+            f"Alternatively, for this profile, V_avg is known to be U_max / 2.\n"
+            f"V_avg = {u_max} / 2 = {round(avg_velocity, precision)} m/s\n\n"
+
+            f"**Answer:**\n"
+            f"The volumetric flow rate is {round(flow_rate, precision)} m^3/s, and the average velocity is {round(avg_velocity, precision)} m/s."
+        )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_vorticity_check():
+    """
+    Fluid Kinematics: Vorticity and Rotational Flow Check
+
+    Scenario:
+        This template introduces the concept of fluid element rotation. It requires
+        calculating the curl of a given velocity field to find the vorticity vector.
+        This enhanced version uses more complex velocity fields where the vorticity
+        itself depends on the spatial coordinates, making the evaluation point critical
+        to the final answer. The problem randomly generates either a 2D or 3D field.
+
+    Core Equations:
+        Vorticity Vector: zeta = curl(V) = (dw/dy - dv/dz)i + (du/dz - dw/dx)j + (dv/dx - du/dy)k
+        Irrotational Flow: A flow is irrotational if the vorticity vector is the zero vector.
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the vorticity vector and a rotationality check.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values
+    flow_type = random.choice(['2D', '3D'])
+    precision = 3
+
+    # Random coefficients for the velocity field polynomials.
+    # Allowing zeros increases variety, sometimes creating simpler or irrotational cases.
+    A = random.randint(-4, 4)
+    B = random.randint(-4, 4)
+    C = random.randint(-4, 4)
+
+    # Evaluation point
+    x_point = round(random.uniform(0.5, 3.0), 1)
+    y_point = round(random.uniform(0.5, 3.0), 1)
+    
+    # 2. Perform calculations and generate strings based on the flow type
+    if flow_type == '2D':
+        # --- 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 ---
+        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 ---
+        question = (
+            f"A 2D fluid flow is described by the velocity field:\n"
+            f"u = {A}xy\n"
+            f"v = {B}x^2 + {C}y^2\n"
+            f"where u and v are in m/s, and x and y are in meters.\n\n"
+            f"Calculate the vorticity at the point ({x_point}, {y_point}) m and "
+            f"determine if the flow is rotational or irrotational at that point."
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"Velocity component u = {A}xy\n"
+            f"Velocity component v = {B}x^2 + {C}y^2\n"
+            f"Point of interest: (x, y) = ({x_point}, {y_point}) m\n\n"
+
+            f"**Step 1:** State the formula for vorticity in a 2D flow.\n"
+            f"For a 2D flow in the x-y plane, the vorticity vector is (0, 0, zeta_z).\n"
+            f"The formula for the z-component is: zeta_z = (dv/dx - du/dy)\n\n"
+
+            f"**Step 2:** Calculate the necessary partial derivatives.\n"
+            f"  du/dy = d/dy({A}xy) = {A}x\n"
+            f"  dv/dx = d/dx({B}x^2 + {C}y^2) = {2*B}x\n\n"
+
+            f"**Step 3:** Evaluate the partial derivatives at the point ({x_point}, {y_point}).\n"
+            f"  du/dy at x={x_point} -> {A}({x_point}) = {round(du_dy_val, precision)}\n"
+            f"  dv/dx at x={x_point} -> {2*B}({x_point}) = {round(dv_dx_val, precision)}\n\n"
+
+            f"**Step 4:** Substitute the derivative values to find the vorticity component.\n"
+            f"  zeta_z = ({round(dv_dx_val, precision)}) - ({round(du_dy_val, precision)}) = {round(zeta_z, precision)}\n"
+            f"The vorticity vector at this point is (0, 0, {round(zeta_z, precision)}) rad/s.\n\n"
+
+            f"**Step 5:** Determine if the flow is rotational at this point.\n"
+            f"A flow is irrotational at a point if its vorticity is zero there.\n"
+            f"Since the vorticity component zeta_z = {round(zeta_z, precision)}, which is {'zero' if is_irrotational else 'not zero'},\n"
+            f"the flow is {'irrotational' if is_irrotational else 'rotational'} at this specific point.\n\n"
+            
+            f"**Answer:**\n"
+            f"The vorticity at ({x_point}, {y_point}) is (0, 0, {round(zeta_z, precision)}) rad/s. The flow is {'irrotational' if is_irrotational else 'rotational'} at this point."
+        )
+
+    else: # flow_type == '3D'
+        D = random.randint(-4, 4)
+        E = random.randint(-4, 4)
+        F = random.randint(-4, 4)
+        z_point = round(random.uniform(0.5, 3.0), 1)
+
+        # --- 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 ---
+        du_dy_val = 2 * A * y_point
+        du_dz_val = 0
+        
+        dv_dx_val = C
+        dv_dz_val = 2 * B * z_point
+        
+        dw_dx_val = 2 * D * x_point
+        dw_dy_val = E
+        
+        zeta_x = dw_dy_val - dv_dz_val
+        zeta_y = du_dz_val - dw_dx_val
+        zeta_z = dv_dx_val - du_dy_val
+        
+        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 ---
+        question = (
+            f"A 3D fluid flow is described by the velocity field:\n"
+            f"u = {A}y^2\n"
+            f"v = {B}z^2 + {C}x\n"
+            f"w = {D}x^2 + {E}y\n"
+            f"where u, v, w are in m/s, and x, y, z are in meters.\n\n"
+            f"Calculate the vorticity vector at the point ({x_point}, {y_point}, {z_point}) m and "
+            f"determine if the flow is rotational or irrotational at that point."
+        )
+
+        solution = (
+            f"**Given:**\n"
+            f"Velocity field: u={A}y^2, v={B}z^2 + {C}x, w={D}x^2 + {E}y\n"
+            f"Point of interest: ({x_point}, {y_point}, {z_point}) m\n\n"
+
+            f"**Step 1:** State the formula for the 3D vorticity vector.\n"
+            f"zeta = (dw/dy - dv/dz)i + (du/dz - dw/dx)j + (dv/dx - du/dy)k\n\n"
+
+            f"**Step 2:** Calculate all necessary partial derivatives.\n"
+            f"From u = {A}y^2: du/dy = {2*A}y, du/dz = 0\n"
+            f"From v = {B}z^2 + {C}x: dv/dx = {C}, dv/dz = {2*B}z\n"
+            f"From w = {D}x^2 + {E}y: dw/dx = {2*D}x, dw/dy = {E}\n\n"
+            
+            f"**Step 3:** Evaluate the derivatives at the point ({x_point}, {y_point}, {z_point}).\n"
+            f"  du/dy = {2*A}({y_point}) = {round(du_dy_val, precision)}\n"
+            f"  dv/dx = {C}\n"
+            f"  dv/dz = {2*B}({z_point}) = {round(dv_dz_val, precision)}\n"
+            f"  dw/dx = {2*D}({x_point}) = {round(dw_dx_val, precision)}\n"
+            f"  dw/dy = {E}\n"
+            f"  (du/dz is always 0)\n\n"
+
+            f"**Step 4:** Calculate each component of the vorticity vector.\n"
+            f"zeta_x = dw/dy - dv/dz = {E} - ({round(dv_dz_val, precision)}) = {round(zeta_x, precision)}\n"
+            f"zeta_y = du/dz - dw/dx = 0 - ({round(dw_dx_val, precision)}) = {round(zeta_y, precision)}\n"
+            f"zeta_z = dv/dx - du/dy = {C} - ({round(du_dy_val, precision)}) = {round(zeta_z, precision)}\n\n"
+            
+            f"**Step 5:** Assemble the vorticity vector and determine if the flow is rotational.\n"
+            f"The vorticity vector at this point is ({round(zeta_x, precision)}, {round(zeta_y, precision)}, {round(zeta_z, precision)}) rad/s.\n"
+            f"A flow is irrotational at a point if its vorticity is the zero vector (0, 0, 0).\n"
+            f"Since the vector is {'the zero vector' if is_irrotational else 'not the zero vector'},\n"
+            f"the flow is {'irrotational' if is_irrotational else 'rotational'} at this specific point.\n\n"
+
+            f"**Answer:**\n"
+            f"The vorticity vector at ({x_point}, {y_point}, {z_point}) is ({round(zeta_x, precision)}, {round(zeta_y, precision)}, {round(zeta_z, precision)}) rad/s. "
+            f"The flow is {'irrotational' if is_irrotational else 'rotational'} at this point."
+        )
+
+    return question, solution
+
+
+# Template 4 (Advanced)
+def template_particle_pathline():
+    """
+    Fluid Kinematics: Finding a Particle's Pathline in a Steady Flow
+
+    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.
+
+    Core Equations:
+        Pathline Definition: dx/dt = u(x, y) and dy/dt = v(x, y)
+        Velocity Field Used: u = A*x, v = -B*y
+
+    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.
+    """
+    # 1. Parameterize the inputs with random values
+    A = random.randint(1, 5)
+    B = random.randint(1, 5)
+
+    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)
+
+    precision = 4
+
+    # 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)
+    yf = y0 * math.exp(-B * tf)
+
+    # 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"Determine the particle's coordinates (x, y) at time t = {tf} s."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Velocity field: u = {A}x, v = -{B}y\n"
+        f"Initial position (x0, y0) = ({x0}, {y0})\n"
+        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"**Step 2:** Solve the ODE for x(t) by separating variables.\n"
+        f"  (1/x) dx = {A} dt\n"
+        f"Integrating both sides gives:\n"
+        f"  ln(x) = {A}t + C1\n"
+        f"Solving for x by exponentiating:\n"
+        f"  x(t) = exp({A}t + C1) = C * exp({A}t)\n\n"
+
+        f"**Step 3:** Apply the initial condition x(0) = {x0} to find the constant C.\n"
+        f"  {x0} = C * exp({A}*0) = C * 1\n"
+        f"So, C = {x0}. The specific solution for the x-coordinate is:\n"
+        f"  x(t) = {x0} * exp({A}t)\n\n"
+
+        f"**Step 4:** Set up and solve the differential equation for the y-coordinate.\n"
+        f"The pathline is defined by dy/dt = v.\n"
+        f"  dy/dt = -{B}y\n"
+        f"Separating variables: (1/y) dy = -{B} dt\n"
+        f"Integrating both sides gives:\n"
+        f"  ln(y) = -{B}t + D1\n"
+        f"  y(t) = D * exp(-{B}t)\n\n"
+
+        f"**Step 5:** Apply the initial condition y(0) = {y0} to find the constant D.\n"
+        f"  {y0} = D * exp(-{B}*0) = D * 1\n"
+        f"So, D = {y0}. The specific solution for the y-coordinate is:\n"
+        f"  y(t) = {y0} * exp(-{B}t)\n\n"
+
+        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"**Answer:**\n"
+        f"At t = {tf} s, the particle's coordinates are ({round(xf, precision)}, {round(yf, precision)})."
+    )
+
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_incompressible_continuity():
+    """
+    Fluid Kinematics: Deriving a Velocity Component for Incompressible Flow
+
+    Scenario:
+        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.
+
+    Core Equation:
+        2D Incompressible Continuity: du/dx + dv/dy = 0
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the unknown velocity component.
+            - str: A step-by-step solution showing the derivation.
+    """
+    # 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
+    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"
+        
+        # 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"
+        
+        question = (
+            f"A 2D, steady, incompressible flow has a velocity component in the x-direction "
+            f"given by u = {u_expr}.\n\n"
+            f"Determine the simplest possible expression for the y-component of velocity, v(x, y)."
+        )
+
+        solution = (
+            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"**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"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"
+
+        # 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"
+
+        question = (
+            f"A 2D, steady, incompressible flow has a velocity component in the y-direction "
+            f"given by v = {v_expr}.\n\n"
+            f"Determine the simplest possible expression for the x-component of velocity, u(x, y)."
+        )
+
+        solution = (
+            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"**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"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}."
+        )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each fluid kinematics template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/mechanical_engineering/fluid_mechanics/fluid_kinematics.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_fluid_particle_acceleration, "fluid_particle_acceleration", "Easy"),
+        (template_volumetric_flow_rate, "volumetric_flow_rate", "Intermediate"),
+        (template_vorticity_check, "vorticity_check", "Intermediate"),
+        (template_particle_pathline, "particle_pathline", "Advanced"),
+        (template_incompressible_continuity, "incompressible_continuity", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "mechanical_engineering",
+                "domain": "fluid_mechanics",
+                "area": "fluid_kinematics",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,616 @@
+import random
+import math
+from data.templates.branches.mechanical_engineering.constants import GRAVITY, ATMOSPHERIC_PRESSURE_KPA, FLUID_DENSITIES, MATERIAL_DENSITIES, OBJECT_SHAPES, OBJECT_MATERIALS, PIPE_FLUIDS, MANOMETER_FLUIDS
+
+
+# Template 1 (Easy)
+def template_hydrostatic_pressure_at_depth():
+    """
+    Fluid Statics: 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.
+
+    Core Equation:
+        p_absolute = p_surface + (rho * g * h)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the absolute pressure at a certain depth.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values
+
+    # 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)
+
+    # Randomly decide if the surface pressure is atmospheric or a specified gauge pressure
+    is_surface_atmospheric = random.choice([True, False])
+
+    if is_surface_atmospheric:
+        surface_pressure_kpa = ATMOSPHERIC_PRESSURE_KPA
+        pressure_type_desc = "is atmospheric pressure"
+    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"
+
+    # 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 B: Calculate the pressure increase due to the fluid column (Gauge Pressure)
+    # This is the result of p_gauge = 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
+    absolute_pressure_kpa = absolute_pressure_pa / 1000
+
+    # 3. Generate the question and solution strings
+
+    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"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"Depth (h): {depth_h} m\n"
+        f"Surface Pressure (p_surface): {surface_pressure_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 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 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 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"**Answer:**\n"
+        f"The absolute pressure at a depth of {depth_h} m is {round(absolute_pressure_kpa, precision)} kPa."
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_basic_buoyant_force():
+    """
+    Fluid Statics: Basic Buoyant Force on a Submerged Object
+
+    Scenario:
+        This template applies Archimedes' principle to calculate the buoyant
+        force on a fully submerged object with a known volume. It reinforces
+        the direct relationship between buoyant force and the weight of the
+        displaced fluid.
+
+    Core Equation:
+        F_buoyant = rho_fluid * g * V_displaced
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the buoyant force on an object.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values
+
+    # Randomly select a fluid and its properties
+    fluid_name, density_rho = random.choice(list(FLUID_DENSITIES.items()))
+
+    # Randomly select descriptive properties for the object
+    shape = random.choice(OBJECT_SHAPES)
+    material = random.choice(OBJECT_MATERIALS)
+
+    # Randomize the object's volume in cubic meters
+    object_volume = round(random.uniform(0.05, 2.5), 3)
+
+    # Standardize precision for final outputs
+    precision = 3
+
+    # 2. Perform the core calculations for the solution
+
+    # Step A: Calculate the buoyant force in Newtons (N)
+    # Since the object is fully submerged, the displaced volume equals the object's volume.
+    buoyant_force_n = density_rho * GRAVITY * object_volume
+
+    # Step B: Convert to kilonewtons (kN) if the value is large, for better readability
+    buoyant_force_kn = buoyant_force_n / 1000
+
+    # 3. Generate the question and solution strings
+
+    question = (
+        f"A solid {material} {shape} with a total volume of {object_volume} m^3 is "
+        f"fully submerged in a tank of {fluid_name.lower()}. "
+        f"Given that the density of {fluid_name.lower()} is {density_rho} kg/m^3, "
+        f"calculate the buoyant force acting on the {shape}."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Object Volume (V): {object_volume} m^3\n"
+        f"Fluid: {fluid_name}\n"
+        f"Density of Fluid (rho): {density_rho} kg/m^3\n"
+        f"Acceleration due to Gravity (g): {GRAVITY} m/s^2\n\n"
+
+        f"**Step 1:** Identify the Principle\n"
+        f"According to Archimedes' principle, the buoyant force (F_buoyant) on a submerged "
+        f"object is equal to the weight of the fluid it displaces.\n"
+        f"Since the object is fully submerged, the volume of displaced fluid is equal to the "
+        f"volume of the object itself.\n\n"
+
+        f"**Step 2:** Apply the Buoyant Force Formula\n"
+        f"The formula for buoyant force is: F_buoyant = rho_fluid * g * V_displaced\n"
+        f"F_buoyant = {density_rho} kg/m^3 * {GRAVITY} m/s^2 * {object_volume} m^3\n"
+        f"F_buoyant = {round(buoyant_force_n, precision)} N\n\n"
+
+        f"**Step 3:** Convert the Result to Kilonewtons (kN) (Optional)\n"
+        f"For larger force values, it is common to express the result in kilonewtons.\n"
+        f"F_buoyant = {round(buoyant_force_n, precision)} N / 1000 = {round(buoyant_force_kn, precision)} kN\n\n"
+
+        f"**Answer:**\n"
+        f"The buoyant force acting on the {shape} is {round(buoyant_force_n, precision)} N, "
+        f"which is equivalent to {round(buoyant_force_kn, precision)} kN."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_utube_manometer():
+    """
+    Fluid Statics: U-Tube Manometer Pressure Measurement
+
+    Scenario:
+        This template generates a classic problem involving a U-tube manometer
+        used to measure the gauge pressure of a fluid inside a pipe. The solution
+        requires applying the principle of hydrostatic equilibrium by balancing
+        the pressure contributions from different fluid columns.
+
+    Core Equation:
+        P_gauge = (rho_2 * g * h2) - (rho_1 * g * h1)
+
+    Returns:
+        tuple: A tuple containing:
+            - 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:
+        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)
+
+    # 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
+
+    # 3. Generate the question and solution strings
+
+    question = (
+        f"A U-tube manometer using {manometer_fluid_name.lower()} (density = {rho2} kg/m^3) is "
+        f"connected to a pipe carrying {pipe_fluid_name.lower()} (density = {rho1} kg/m^3). "
+        f"The interface between the two fluids is {h1} m below the centerline of the pipe. "
+        f"The level of {manometer_fluid_name.lower()} in the arm open to the atmosphere is {h2} m "
+        f"higher than the interface. What is the gauge pressure in the pipe?"
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Pipe Fluid: {pipe_fluid_name}, Density (rho1) = {rho1} kg/m^3\n"
+        f"Manometer Fluid: {manometer_fluid_name}, Density (rho2) = {rho2} kg/m^3\n"
+        f"Height from pipe centerline to interface (h1): {h1} m\n"
+        f"Height difference in manometer fluid (h2): {h2} m\n"
+        f"Acceleration due to Gravity (g): {GRAVITY} m/s^2\n\n"
+
+        f"**Step 1:** State the Principle of Manometry\n"
+        f"We can determine the pressure in the pipe by starting at the pipe's centerline, moving "
+        f"through the fluid columns to the open end, and balancing the pressures. The pressure at the "
+        f"same level within a continuous fluid at rest is equal.\n\n"
+
+        f"**Step 2:** Formulate the Pressure Balance Equation\n"
+        f"Let's establish a pressure equation starting from the pipe (P_pipe) and ending at the atmosphere (P_atm). "
+        f"The reference level is the interface between the pipe fluid and the manometer fluid.\n"
+        f"Pressure from pipe side at interface: P_pipe + (rho1 * g * h1)\n"
+        f"Pressure from atmosphere side at interface: P_atm + (rho2 * g * h2)\n"
+        f"Equating these gives: P_pipe + (rho1 * g * h1) = P_atm + (rho2 * g * h2)\n\n"
+
+        f"**Step 3:** Solve for the Gauge Pressure\n"
+        f"Gauge pressure is P_gauge = P_pipe - P_atm. Rearranging the equation:\n"
+        f"P_gauge = (rho2 * g * h2) - (rho1 * g * h1)\n\n"
+
+        f"**Step 4:** Calculate the Individual Pressure Terms\n"
+        f"Pressure from manometer fluid column = {rho2} * {GRAVITY} * {h2} = {pressure_term2_pa:.2f} Pa\n"
+        f"Pressure from pipe fluid column = {rho1} * {GRAVITY} * {h1} = {pressure_term1_pa:.2f} Pa\n\n"
+
+        f"**Step 5:** Calculate the Final Gauge Pressure\n"
+        f"P_gauge = {pressure_term2_pa:.2f} Pa - {pressure_term1_pa:.2f} Pa = {gauge_pressure_pa:.2f} Pa\n\n"
+
+        f"**Step 6:** Convert the Answer to Kilopascals (kPa)\n"
+        f"P_gauge = {gauge_pressure_pa:.2f} Pa / 1000 = {round(gauge_pressure_kpa, precision)} kPa\n\n"
+
+        f"**Answer:**\n"
+        f"The gauge pressure in the pipe is {round(gauge_pressure_kpa, precision)} kPa."
+    )
+
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_floating_object_submersion_depth():
+    """
+    Fluid Statics: Floating Object Submersion Depth
+
+    Scenario:
+        This template applies the principle of buoyancy to determine how deep
+        an object with a uniform cross-section (like a rectangular block or
+        cylinder) will float in a liquid. The solution requires equating the
+        object's total weight to the buoyant force acting on its submerged part.
+
+    Core Equations:
+        - Weight (W) = rho_object * g * V_total
+        - Buoyant Force (F_B) = rho_fluid * g * V_submerged
+        - At equilibrium (floating): W = F_B
+        - This simplifies to: rho_object * V_total = rho_fluid * V_submerged
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the submersion depth of a floating object.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs to ensure a valid floating scenario
+
+    # Randomly select an object material and a fluid
+    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 ---
+    # Re-select until the object's density is less than the fluid's density.
+    max_attempts = 20
+    attempt = 0
+    while rho_object >= rho_fluid and attempt < max_attempts:
+        obj_material, rho_object = random.choice(list(MATERIAL_DENSITIES.items()))
+        fluid_name, rho_fluid = random.choice(list(FLUID_DENSITIES.items()))
+        attempt += 1
+    
+    # Fallback in the rare case a valid pair isn't found quickly
+    if rho_object >= rho_fluid:
+        obj_material, rho_object = "Pine Wood", 500
+        fluid_name, rho_fluid = "Fresh Water", 998
+
+    # Randomly choose the object's shape (uniform cross-section)
+    shape = random.choice(["rectangular block", "cylinder"])
+
+    # Randomize dimensions based on shape
+    if shape == "rectangular block":
+        length = round(random.uniform(0.5, 3.0), 2)
+        width = round(random.uniform(0.2, 2.0), 2)
+        height = round(random.uniform(0.1, 1.5), 2) # This is the total vertical height
+        shape_dims_str = f"dimensions {length} m (length) x {width} m (width) x {height} m (height)"
+        shape_dims_given_str = (f"  - Length (L): {length} m\n"
+                                f"  - Width (W): {width} m\n"
+                                f"  - Total Height (H): {height} m")
+    else:  # shape == "cylinder"
+        radius = round(random.uniform(0.1, 1.5), 2)
+        height = round(random.uniform(0.2, 2.5), 2) # This is the total vertical height
+        shape_dims_str = f"a radius of {radius} m and a total height of {height} m"
+        shape_dims_given_str = (f"  - Radius (r): {radius} m\n"
+                                f"  - Total Height (H): {height} m")
+
+    # Standardize precision for final outputs
+    precision = 4
+
+    # 2. Perform the core calculations for the solution
+
+    # The core insight is that for a uniform cross-section, the area cancels out.
+    # W = F_B  =>  rho_obj * g * (Area * H) = rho_fluid * g * (Area * h_sub)
+    # Simplifying gives: rho_obj * H = rho_fluid * h_sub
+    submersion_depth = (rho_object / rho_fluid) * height
+
+    # 3. Generate the question and solution strings
+
+    question = (
+        f"A {shape} made of {obj_material.lower()} (density = {rho_object} kg/m^3) has "
+        f"{shape_dims_str}. The object is placed in a large tank of {fluid_name.lower()} "
+        f"(density = {rho_fluid} kg/m^3). Assuming the object floats in a stable, upright "
+        f"position, calculate its submersion depth (the vertical height of the object "
+        f"that is below the fluid surface)."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Object Shape: {shape.capitalize()}\n"
+        f"{shape_dims_given_str}\n"
+        f"Object Density (rho_obj): {rho_object} kg/m^3\n"
+        f"Fluid Density (rho_fluid): {rho_fluid} kg/m^3\n\n"
+
+        f"**Step 1:** State the Principle of Flotation\n"
+        f"For an object to float, its total weight (W) must be equal to the buoyant force (F_B) "
+        f"exerted by the fluid. The buoyant force is the weight of the displaced fluid.\n"
+        f"Equilibrium Condition: W = F_B\n\n"
+
+        f"**Step 2:** Express Weight and Buoyant Force using Densities\n"
+        f"Weight (W) = rho_obj * g * V_total\n"
+        f"Buoyant Force (F_B) = rho_fluid * g * V_submerged\n\n"
+        f"Setting them equal: \n"
+        f"rho_obj * g * V_total = rho_fluid * g * V_submerged\n\n"
+
+        f"**Step 3:** Simplify for a Uniform Cross-Section\n"
+        f"The acceleration of gravity (g) cancels from both sides. For an object with a uniform "
+        f"cross-sectional area (A), the volumes can be expressed as V = A * height.\n"
+        f"V_total = A * H_total\n"
+        f"V_submerged = A * h_submerged\n\n"
+        f"Substituting these into the equation:\n"
+        f"rho_obj * (A * H_total) = rho_fluid * (A * h_submerged)\n\n"
+        f"The cross-sectional area (A) also cancels out, leaving a simple ratio:\n"
+        f"rho_obj * H_total = rho_fluid * h_submerged\n\n"
+
+        f"**Step 4:** Solve for the Submersion Depth (h_submerged)\n"
+        f"Rearranging the formula to solve for the unknown depth:\n"
+        f"h_submerged = (rho_obj / rho_fluid) * H_total\n\n"
+        f"Plugging in the given values:\n"
+        f"h_submerged = ({rho_object} / {rho_fluid}) * {height}\n"
+        f"h_submerged = {round(submersion_depth, precision)} m\n\n"
+
+        f"**Answer:**\n"
+        f"The submersion depth of the {shape} is {round(submersion_depth, precision)} m."
+    )
+
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_hydrostatic_force_on_plane():
+    """
+    Fluid Statics: Hydrostatic Force and Center of Pressure on a Submerged Plane
+
+    Scenario:
+        This template generates a comprehensive problem requiring the calculation of
+        the magnitude of the resultant hydrostatic force on a submerged plane
+        surface (e.g., a gate, window) and the location where this force acts,
+        known as the center of pressure.
+
+    Core Equations:
+        - Resultant Force (F_R) = rho * g * h_c * A
+        - Center of Pressure (y_R) = y_c + (I_xc / (y_c * A))
+          where:
+            - rho = fluid density
+            - g = acceleration of gravity
+            - h_c = vertical depth from free surface to the centroid of the area
+            - A = area of the submerged surface
+            - y_c = inclined distance from free surface to the centroid
+            - I_xc = area moment of inertia about the centroidal axis parallel to the surface
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question about hydrostatic force and center of pressure.
+            - str: A detailed, step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+
+    # Select fluid and shape
+    fluid_name, rho = random.choice(list(FLUID_DENSITIES.items()))
+    shape = random.choice(["rectangle", "circle"])
+
+    # Set geometric and positional parameters
+    angle_deg = random.choice([30, 45, 60, 90]) # Angle with the horizontal
+    angle_rad = math.radians(angle_deg)
+    h_top = round(random.uniform(0.5, 5.0), 2) # Vertical depth to top edge of the plane
+
+    # Randomize dimensions based on shape and calculate geometric properties
+    if shape == "rectangle":
+        b = round(random.uniform(1.0, 4.0), 2)  # width
+        h = round(random.uniform(1.0, 4.0), 2)  # height
+        area = b * h
+        I_xc = (b * h**3) / 12
+        dist_to_centroid_along_plane = h / 2
+        shape_desc = f"a rectangular gate with a width of {b} m and a height of {h} m"
+        shape_given = f"  - Shape: Rectangle (width b = {b} m, height h = {h} m)"
+    else:  # shape == "circle"
+        r = round(random.uniform(0.5, 2.0), 2) # radius
+        area = math.pi * r**2
+        I_xc = (math.pi * r**4) / 4
+        dist_to_centroid_along_plane = r
+        shape_desc = f"a circular viewport with a radius of {r} m"
+        shape_given = f"  - Shape: Circle (radius r = {r} m)"
+
+    precision = 4
+
+    # 2. Perform the core calculations for the solution
+
+    # Step A: Determine the position of the centroid (yc and hc)
+    # yc is the inclined distance from the free surface to the centroid
+    # hc is the vertical depth from the free surface to the centroid
+    if angle_deg == 90:
+        y_top = h_top
+        angle_desc = "is positioned vertically"
+    else:
+        y_top = h_top / math.sin(angle_rad)
+        angle_desc = f"is inclined at an angle of {angle_deg} degrees to the horizontal"
+
+    y_c = y_top + dist_to_centroid_along_plane
+    h_c = y_c * math.sin(angle_rad)
+
+    # Step B: Calculate the resultant force (F_R)
+    force_resultant_N = rho * GRAVITY * h_c * area
+    force_resultant_kN = force_resultant_N / 1000
+
+    # Step C: Calculate the location of the center of pressure (y_R)
+    # y_R is the inclined distance from the free surface to the center of pressure
+    y_R = y_c + (I_xc / (y_c * area))
+
+    # 3. Generate the question and solution strings
+
+    question = (
+        f"A submerged {shape_desc} {angle_desc} in a tank of {fluid_name.lower()} "
+        f"(density = {rho} kg/m^3). The top edge of the gate is {h_top} m vertically below "
+        f"the free surface. Calculate:\n"
+        f"  a) The magnitude of the resultant hydrostatic force on the gate.\n"
+        f"  b) The location of the center of pressure, measured along the incline of the gate "
+        f"from the free surface."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"{shape_given}\n"
+        f"Fluid: {fluid_name} (rho = {rho} kg/m^3)\n"
+        f"Vertical depth to top edge (h_top): {h_top} m\n"
+        f"Angle of inclination (theta): {angle_deg} degrees\n\n"
+
+        f"**Step 1:** Calculate Geometric Properties of the Gate\n"
+        f"Area (A): {area:.{precision}f} m^2\n"
+        f"Moment of Inertia about centroid (I_xc): {I_xc:.{precision}f} m^4\n\n"
+
+        f"**Step 2:** Determine the Location of the Centroid (yc and hc)\n"
+        f"The centroid is the geometric center of the gate. We need its position relative to the free surface.\n"
+        f"  - 'y' distances are measured along the plane's incline.\n"
+        f"  - 'h' distances are measured vertically.\n\n"
+        f"Inclined distance from surface to top edge (y_top) = h_top / sin(theta)\n"
+        f"  y_top = {h_top} / sin({angle_deg}°) = {y_top:.{precision}f} m\n"
+        f"Distance from top edge to centroid along plane = {dist_to_centroid_along_plane:.{precision}f} m\n"
+        f"Inclined distance from surface to centroid (y_c) = y_top + dist_to_centroid\n"
+        f"  y_c = {y_top:.{precision}f} + {dist_to_centroid_along_plane:.{precision}f} = {y_c:.{precision}f} m\n\n"
+        f"Vertical depth to centroid (h_c) = y_c * sin(theta)\n"
+        f"  h_c = {y_c:.{precision}f} * sin({angle_deg}°) = {h_c:.{precision}f} m\n\n"
+
+        f"**Step 3:** Calculate the Resultant Hydrostatic Force (F_R)\n"
+        f"The force is the pressure at the centroid multiplied by the total area.\n"
+        f"F_R = rho * g * h_c * A\n"
+        f"F_R = {rho} * {GRAVITY} * {h_c:.{precision}f} * {area:.{precision}f}\n"
+        f"F_R = {force_resultant_N:.2f} N\n"
+        f"F_R = {force_resultant_kN:.{precision}f} kN\n\n"
+
+        f"**Step 4:** Calculate the Center of Pressure (y_R)\n"
+        f"The center of pressure is the point where the resultant force acts. It is always below the centroid.\n"
+        f"y_R = y_c + (I_xc / (y_c * A))\n"
+        f"y_R = {y_c:.{precision}f} + ({I_xc:.{precision}f} / ({y_c:.{precision}f} * {area:.{precision}f}))\n"
+        f"y_R = {y_R:.{precision}f} m\n\n"
+
+        f"**Answer:**\n"
+        f"a) The magnitude of the resultant hydrostatic force is **{force_resultant_kN:.{precision}f} kN**.\n"
+        f"b) The center of pressure is located **{y_R:.{precision}f} m** from the free surface, measured down along the angle of the gate."
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each fluid statics template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/mechanical_engineering/fluid_mechanics/fluid_statics.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_hydrostatic_pressure_at_depth, "hydrostatic_pressure_at_depth", "Easy"),
+        (template_basic_buoyant_force, "basic_buoyant_force", "Easy"),
+        (template_utube_manometer, "utube_manometer", "Intermediate"),
+        (template_floating_object_submersion_depth, "floating_object_submersion_depth", "Intermediate"),
+        (template_hydrostatic_force_on_plane, "hydrostatic_force_on_plane", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "mechanical_engineering",
+                "domain": "fluid_mechanics",
+                "area": "fluid_statics",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,916 @@
+import random
+import math
+from data.templates.branches.mechanical_engineering.constants import MATERIAL_PROPERTIES
+
+
+# Template 1 (Easy)
+def template_basic_stress_strain():
+    """
+    Basic Normal Stress and Strain
+
+    Scenario:
+        This template tests the fundamental definitions of normal stress (sigma) and
+        normal strain (epsilon). Given a simple prismatic bar with a known geometry
+        and an applied axial load, the user must calculate these two basic quantities.
+
+    Core Equations:
+        Normal Stress: sigma = P / A
+        Normal Strain: epsilon = delta / L
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the normal stress and strain.
+            - str: A step-by-step solution showing the calculations.
+    """
+    # 1. Parameterize inputs with random values, choosing a unit system first.
+    use_si_units = random.choice([True, False])
+    shape = random.choice(['circular', 'square'])
+    precision = 3  # Standardize precision for numerical stability and formatting
+
+    if use_si_units:
+        # --- 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
+        
+        if shape == 'circular':
+            dimension_val = random.randint(20, 100)  # diameter in mm
+            dimension_name = "diameter"
+            area = math.pi * (dimension_val / 2)**2  # mm²
+            dim_str = f"{dimension_val} mm"
+        else:  # square
+            dimension_val = random.randint(20, 100)  # side length in mm
+            dimension_name = "side length"
+            area = dimension_val**2  # mm²
+            dim_str = f"{dimension_val} mm"
+            
+        load_str = f"{load} kN"
+        length_str = f"{length} m"
+        elongation_str = f"{elongation} mm"
+        
+        # Core Calculations (using units for clarity: N, mm, MPa)
+        # 1 MPa = 1 N/mm^2
+        stress = (load * 1000) / area  # Stress in MPa
+        # Strain (unitless, but convert units to be consistent)
+        # Elongation in mm, Length in m -> convert length to mm
+        strain = elongation / (length * 1000)
+        
+        stress_unit = "MPa"
+        strain_unit_explanation = "mm/m or unitless"
+
+    else:
+        # --- 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
+        
+        if shape == 'circular':
+            dimension_val = round(random.uniform(1.0, 5.0), 2)  # diameter in inches
+            dimension_name = "diameter"
+            area = math.pi * (dimension_val / 2)**2  # in²
+            dim_str = f"{dimension_val} in"
+        else:  # square
+            dimension_val = round(random.uniform(1.0, 5.0), 2)  # side length in inches
+            dimension_name = "side length"
+            area = dimension_val**2
+            dim_str = f"{dimension_val} in"
+            
+        load_str = f"{load} kips"
+        length_str = f"{length} in"
+        elongation_str = f"{elongation} in"
+        
+        # Core Calculations (using units for clarity: kips, in, ksi)
+        # 1 ksi = 1 kip/in^2
+        stress = load / area  # Stress in ksi
+        # Strain (unitless, since both length and elongation are in inches)
+        strain = elongation / length
+        
+        stress_unit = "ksi"
+        strain_unit_explanation = "in/in or unitless"
+
+    # 2. Generate the question and solution strings
+    question = (
+        f"A prismatic bar with a length of {length_str} has a {shape} cross-section "
+        f"with a {dimension_name} of {dim_str}. The bar is subjected to an axial "
+        f"tensile load of {load_str}, causing it to elongate by {elongation_str}.\n\n"
+        f"Determine the following:\n"
+        f"a) The normal stress in the bar.\n"
+        f"b) The normal strain in the bar."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Load (P): {load_str}\n"
+        f"Length (L): {length_str}\n"
+        f"Elongation (delta): {elongation_str}\n"
+        f"Cross-Section: {shape.capitalize()} with {dimension_name} = {dim_str}\n\n"
+        
+        f"**Step 1:** Calculate the Cross-Sectional Area (A)\n"
+        f"The area of a {shape} cross-section is calculated as follows:\n"
+    )
+    
+    if shape == 'circular':
+        solution += (
+            f"A = pi * (d/2)^2 = pi * ({dimension_val}/2)^2 = {round(area, precision+1)} "
+            f"{'mm^2' if use_si_units else 'in^2'}\n\n"
+        )
+    else: # square
+        solution += (
+            f"A = side^2 = ({dimension_val})^2 = {round(area, precision+1)} "
+            f"{'mm^2' if use_si_units else 'in^2'}\n\n"
+        )
+        
+    solution += (
+        f"**Step 2:** Calculate the Normal Stress (sigma)\n"
+        f"Normal stress is defined as the force per unit area: sigma = P / A.\n"
+    )
+    
+    if use_si_units:
+        solution += (
+            f"To get the result in Megapascals (MPa), we use the load in Newtons (N) and the area in mm^2 (1 MPa = 1 N/mm^2).\n"
+            f"P = {load} kN = {load * 1000} N\n"
+            f"A = {round(area, precision+1)} mm^2\n"
+            f"sigma = ({load * 1000} N) / ({round(area, precision+1)} mm^2) = {round(stress, precision)} MPa\n\n"
+        )
+    else: # US units
+        solution += (
+            f"To get the result in kips per square inch (ksi), we use the load in kips and the area in in^2 (1 ksi = 1 kip/in^2).\n"
+            f"P = {load} kips\n"
+            f"A = {round(area, precision+1)} in^2\n"
+            f"sigma = ({load} kips) / ({round(area, precision+1)} in^2) = {round(stress, precision)} ksi\n\n"
+        )
+
+    solution += (
+        f"**Step 3:** Calculate the Normal Strain (epsilon)\n"
+        f"Normal strain is the change in length per unit of original length: epsilon = delta / L.\n"
+        f"It is a dimensionless quantity, but units must be consistent for calculation.\n"
+    )
+
+    if use_si_units:
+        solution += (
+            f"We convert the length from meters to millimeters to match the elongation units.\n"
+            f"delta = {elongation} mm\n"
+            f"L = {length} m = {length * 1000} mm\n"
+            f"epsilon = ({elongation} mm) / ({length * 1000} mm) = {strain:.3e}\n\n"
+        )
+    else: # US units
+        solution += (
+            f"Both elongation and length are already in inches, so we can divide directly.\n"
+            f"delta = {elongation} in\n"
+            f"L = {length} in\n"
+            f"epsilon = ({elongation} in) / ({length} in) = {strain:.3e}\n\n"
+        )
+
+    solution += (
+        f"**Answer:**\n"
+        f"a) Normal Stress (sigma) = **{round(stress, precision)} {stress_unit}**\n"
+        f"b) Normal Strain (epsilon) = **{strain:.3e}** ({strain_unit_explanation})"
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_axial_deformation():
+    """
+    Axial Deformation (Hooke's Law)
+
+    Scenario:
+        This template combines stress, strain, and the material's Modulus of
+        Elasticity (E). It tests the ability to calculate the total elongation
+        or compression of a rod under an axial load. It can also be inverted
+        to find the maximum load for a given allowable deformation.
+
+    Core Equation:
+        Deformation: delta = (P * L) / (A * E)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question about axial deformation or allowable load.
+            - str: A step-by-step solution showing the calculations.
+    """
+    # 1. Parameterize inputs with random values
+    use_si_units = random.choice([True, False])
+    shape = random.choice(['circular', 'square'])
+    material_name = random.choice(list(MATERIAL_PROPERTIES.keys()))
+    solve_for_load = random.choice([True, False])  # The variation
+    precision = 3
+
+    if use_si_units:
+        # --- SI Unit System ---
+        material_E = MATERIAL_PROPERTIES[material_name]['E_GPa'] # in GPa
+        length = round(random.uniform(0.5, 5.0), 2) # in m
+        
+        if shape == 'circular':
+            dimension_val = random.randint(25, 120) # diameter in mm
+            dimension_name = "diameter"
+            area = math.pi * (dimension_val / 2)**2
+            dim_str = f"{dimension_val} mm"
+        else: # square
+            dimension_val = random.randint(25, 120) # side in mm
+            dimension_name = "side length"
+            area = dimension_val**2
+            dim_str = f"{dimension_val} mm"
+        
+        E_str = f"{material_E} GPa"
+        length_str = f"{length} m"
+        
+        if solve_for_load:
+            # We are solving for P given delta_max
+            max_elongation = round(random.uniform(1.0, 6.0), 2) # in mm
+            max_elongation_str = f"{max_elongation} mm"
+            # Core Calculation: P = (delta * A * E) / L
+            # Units: mm * mm^2 * (N/mm^2) / mm = N
+            load_N = (max_elongation * area * (material_E * 1000)) / (length * 1000)
+            load = load_N / 1000 # convert to kN
+            load_str = f"{round(load, precision)} kN"
+        else:
+            # We are solving for delta given P
+            load = random.randint(50, 800) # in kN
+            load_str = f"{load} kN"
+            # Core Calculation: delta = (P * L) / (A * E)
+            # Units: (N * mm) / (mm^2 * N/mm^2) = mm
+            elongation = ((load * 1000) * (length * 1000)) / (area * (material_E * 1000))
+            elongation_str = f"{round(elongation, precision)} mm"
+
+    else:
+        # --- 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
+        
+        if shape == 'circular':
+            dimension_val = round(random.uniform(0.5, 6.0), 2) # diameter in inches
+            dimension_name = "diameter"
+            area = math.pi * (dimension_val / 2)**2
+            dim_str = f"{dimension_val} in"
+        else: # square
+            dimension_val = round(random.uniform(0.5, 6.0), 2) # side in inches
+            dimension_name = "side length"
+            area = dimension_val**2
+            dim_str = f"{dimension_val} in"
+            
+        E_str = f"{material_E} ksi"
+        length_str = f"{length} in"
+
+        if solve_for_load:
+            # Solving for P given delta_max
+            max_elongation = round(random.uniform(0.02, 0.2), 4) # in inches
+            max_elongation_str = f"{max_elongation} in"
+            # Core Calculation: P = (delta * A * E) / L
+            # Units: in * in^2 * (kips/in^2) / in = kips
+            load = (max_elongation * area * material_E) / length
+            load_str = f"{round(load, precision)} kips"
+        else:
+            # Solving for delta given P
+            load = random.randint(10, 200) # in kips
+            load_str = f"{load} kips"
+            # Core Calculation: delta = (P * L) / (A * E)
+            # Units: (kips * in) / (in^2 * kips/in^2) = in
+            elongation = (load * length) / (area * material_E)
+            elongation_str = f"{round(elongation, precision)} in"
+    
+    # 2. Generate the question and solution strings
+    if solve_for_load:
+        question = (
+            f"A rod made of {material_name} has a length of {length_str} and a {shape} "
+            f"cross-section with a {dimension_name} of {dim_str}. The modulus of "
+            f"elasticity for {material_name} is {E_str}.\n\n"
+            f"What is the maximum allowable axial load the rod can support if the "
+            f"total elongation is not to exceed {max_elongation_str}?"
+        )
+        
+        solution = (
+            f"**Given:**\n"
+            f"Material: {material_name} (E = {E_str})\n"
+            f"Length (L): {length_str}\n"
+            f"Cross-Section: {shape.capitalize()}, {dimension_name} = {dim_str}\n"
+            f"Maximum Elongation (delta_max): {max_elongation_str}\n\n"
+            
+            f"**Step 1:** Calculate the Cross-Sectional Area (A)\n"
+        )
+        if shape == 'circular':
+            solution += (f"  A = pi * (d/2)^2 = pi * ({dimension_val}/2)^2 = {round(area, precision+1)} {'mm^2' if use_si_units else 'in^2'}\n\n")
+        else: # square
+            solution += (f"  A = side^2 = ({dimension_val})^2 = {round(area, precision+1)} {'mm^2' if use_si_units else 'in^2'}\n\n")
+
+        solution += (
+            f"**Step 2:** Calculate the Allowable Load (P)\n"
+            f"The formula for axial deformation is delta = (P * L) / (A * E).\n"
+            f"We can rearrange this to solve for the load P: P = (delta * A * E) / L.\n\n"
+            f"**Unit Conversion and Calculation:**\n"
+        )
+        if use_si_units:
+            solution += (
+                f"For consistency, we will use units of Newtons (N) and millimeters (mm).\n"
+                f"delta = {max_elongation} mm\n"
+                f"A = {round(area, precision+1)} mm^2\n"
+                f"E = {material_E} GPa = {material_E * 1000} MPa = {material_E * 1000} N/mm^2\n"
+                f"L = {length} m = {length * 1000} mm\n\n"
+                f"P = ({max_elongation} * {round(area, precision+1)} * {material_E * 1000}) / {length * 1000}\n"
+                f"P = {round(load_N, precision)} N = {round(load, precision)} kN\n\n"
+            )
+        else: # US units
+            solution += (
+                f"The units are already consistent (kips and inches).\n"
+                f"delta = {max_elongation} in\n"
+                f"A = {round(area, precision+1)} in^2\n"
+                f"E = {material_E} ksi\n"
+                f"L = {length} in\n\n"
+                f"P = ({max_elongation} * {round(area, precision+1)} * {material_E}) / {length}\n"
+                f"P = {round(load, precision)} kips\n\n"
+            )
+        solution += f"**Answer:**\n  The maximum allowable load is **{load_str}**."
+    else: # solve_for_deformation
+        question = (
+            f"A {material_name} rod with a length of {length_str} is subjected to an axial "
+            f"tensile load of {load_str}. The rod has a {shape} cross-section with a "
+            f"{dimension_name} of {dim_str}. The modulus of elasticity for "
+            f"{material_name} is {E_str}.\n\n"
+            f"Calculate the total elongation of the rod."
+        )
+        solution = (
+            f"**Given:**\n"
+            f"Material: {material_name} (E = {E_str})\n"
+            f"Load (P): {load_str}\n"
+            f"Length (L): {length_str}\n"
+            f"Cross-Section: {shape.capitalize()}, {dimension_name} = {dim_str}\n\n"
+
+            f"**Step 1:** Calculate the Cross-Sectional Area (A)\n"
+        )
+        if shape == 'circular':
+            solution += (f"  A = pi * (d/2)^2 = pi * ({dimension_val}/2)^2 = {round(area, precision+1)} {'mm^2' if use_si_units else 'in^2'}\n\n")
+        else: # square
+            solution += (f"  A = side^2 = ({dimension_val})^2 = {round(area, precision+1)} {'mm^2' if use_si_units else 'in^2'}\n\n")
+        
+        solution += (
+            f"**Step 2:** Calculate the Elongation (delta)\n"
+            f"The formula for axial deformation is delta = (P * L) / (A * E).\n\n"
+            f"**Unit Conversion and Calculation:**\n"
+        )
+        if use_si_units:
+            solution += (
+                f"For consistency, we will use units of Newtons (N) and millimeters (mm).\n"
+                f"P = {load} kN = {load * 1000} N\n"
+                f"L = {length} m = {length * 1000} mm\n"
+                f"A = {round(area, precision+1)} mm^2\n"
+                f"E = {material_E} GPa = {material_E * 1000} MPa = {material_E * 1000} N/mm^2\n\n"
+                f"delta = (({load * 1000}) * ({length * 1000})) / (({round(area, precision+1)}) * ({material_E * 1000}))\n"
+                f"delta = {round(elongation, precision)} mm\n\n"
+            )
+        else: # US units
+            solution += (
+                f"The units are already consistent (kips and inches).\n"
+                f"P = {load} kips\n"
+                f"L = {length} in\n"
+                f"A = {round(area, precision+1)} in^2\n"
+                f"E = {material_E} ksi\n\n"
+                f"delta = ({load} * {length}) / ({round(area, precision+1)} * {material_E})\n"
+                f"delta = {round(elongation, precision)} in\n\n"
+            )
+        solution += f"**Answer:**\n  The total elongation of the rod is **{elongation_str}**."
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_multi_segment_rod():
+    """
+    Deformation of a Multi-Segment Rod
+
+    Scenario:
+        This template involves a composite rod made of segments joined end-to-end and
+        fixed at one end. The segments can have different materials, lengths, or
+        cross-sectional areas. External loads are applied at the junctions. The user
+        must calculate the total deformation by summing the deformations of each segment,
+        which requires first finding the internal force in each section.
+
+    Core Equation:
+        Total Deformation: delta_total = sum(delta_i) = sum( (P_i * L_i) / (A_i * E_i) )
+
+    Returns:
+        tuple: A tuple containing:
+            - 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])
+    precision = 4
+    
+    segments = []
+    loads = {} # Loads applied at nodes {node_index: load_value}
+
+    # Generate properties for each segment
+    for i in range(num_segments):
+        material_name = random.choice(list(MATERIAL_PROPERTIES.keys()))
+        segment = {'material_name': material_name}
+        
+        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']
+        
+        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
+        
+        segments[i]['deformation'] = delta
+        total_deformation += delta
+
+    # 3. Generate Question and Solution Strings
+    question = (
+        f"A composite rod, fixed at one end, consists of {num_segments} segments "
+        f"joined end-to-end as described below:\n"
+    )
+    for i, seg in enumerate(segments):
+        unit_L = "m" if use_si_units else "in"
+        question += (
+            f"  - Segment {i+1}: Made of {seg['material_name']}, has a length of {seg['length']} {unit_L}, "
+            f"and a cross-section that is {seg['dim_str']}.\n"
+        )
+    
+    question += f"\nThe rod is subjected to the following external axial loads (positive = tension, negative = compression):\n"
+    for i in range(num_segments):
+        node_index = i + 1
+        load_val = loads[node_index]
+        unit_P = "kN" if use_si_units else "kips"
+        
+        if node_index < num_segments:
+            location_desc = f"at the junction between Segment {node_index} and {node_index+1}"
+        else:
+            location_desc = "at the free end"
+            
+        question += f"  - A load of {load_val} {unit_P} is applied {location_desc}.\n"
+
+    question += (
+        f"\nGiven the Moduli of Elasticity:\n"
+    )
+    unique_materials = {s['material_name'] for s in segments}
+    for mat in sorted(list(unique_materials)):
+        E_val = MATERIAL_PROPERTIES[mat]['E_GPa' if use_si_units else 'E_ksi']
+        unit_E = "GPa" if use_si_units else "ksi"
+        question += f"  - E_{mat} = {E_val} {unit_E}\n"
+
+    question += f"\nDetermine the total deformation of the composite rod."
+
+    # Solution
+    solution = f"**Given:** The properties and loads as described in the question.\n\n"
+    solution += (
+        f"**Step 1:** Calculate the Internal Force (P) in Each Segment\n"
+        f"To find the internal force in any segment, we make a virtual 'cut' and sum all external forces acting on one side of the cut. We will work from the free end (right) to the fixed wall (left). A positive force indicates tension, and a negative force indicates compression.\n"
+    )
+    unit_P = "kN" if use_si_units else "kips"
+    for i in range(num_segments - 1, -1, -1):
+        seg_num = i + 1
+        internal_load = segments[i]['internal_load']
+        load_desc = " (Tension)" if internal_load > 0 else " (Compression)" if internal_load < 0 else " (No force)"
+        
+        if seg_num == num_segments: # Last segment
+             solution += f"  - **Segment {seg_num}:** P{seg_num} = {loads[seg_num]} {unit_P}{load_desc}\n"
+        else:
+            prev_load_desc = " (T)" if segments[i+1]['internal_load'] > 0 else " (C)" if segments[i+1]['internal_load'] < 0 else " (0)"
+            solution += f"  - **Segment {seg_num}:** P{seg_num} = P{seg_num+1} + {loads[seg_num]} = {segments[i+1]['internal_load']}{prev_load_desc} + {loads[seg_num]} = {internal_load} {unit_P}{load_desc}\n"
+
+    solution += f"\nSummary of Internal Forces:\n"
+    for i, seg in enumerate(segments):
+        load_desc = " (Tension)" if seg['internal_load'] > 0 else " (Compression)"
+        solution += f"  - P{i+1} = {seg['internal_load']} {unit_P}{load_desc}\n"
+
+    solution += (
+        f"\n**Step 2:** Calculate the Deformation (δ) of Each Segment\n"
+        f"Using the formula δ = (P × L) / (A × E) for each segment.\n"
+    )
+    unit_L = "m" if use_si_units else "in"
+    unit_D = "mm" if use_si_units else "in"
+    unit_E = "GPa" if use_si_units else "ksi"
+
+    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"
+
+    solution += (
+        f"\n**Step 3:** Calculate the Total Deformation\n"
+        f"The total deformation is the algebraic sum of the individual segment deformations.\n"
+        f"δ_total = "
+    )
+    delta_sum_str = " + ".join([f"({round(s['deformation'], precision)})" for s in segments])
+    solution += delta_sum_str + "\n"
+    solution += f"δ_total = {round(total_deformation, precision)} {unit_D}\n\n"
+    
+    final_desc = "elongation" if total_deformation > 0 else "contraction"
+    solution += (
+        f"**Answer:**\n"
+        f"The total deformation of the rod is **{round(total_deformation, precision)} {unit_D}** "
+        f"(a net {final_desc})."
+    )
+
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_poissons_ratio():
+    """
+    Poisson's Ratio and Change in Diameter
+
+    Scenario:
+        This template tests the understanding of Poisson's Ratio (nu). A rod is
+        subjected to an axial load, causing it to elongate and contract laterally.
+        The user must calculate the change in the rod's diameter.
+
+    Core Equations:
+        Axial Strain: epsilon_axial = sigma_x / E = P / (A * E)
+        Lateral Strain: epsilon_lateral = -nu * epsilon_axial
+        Change in Diameter: delta_d = d_initial * epsilon_lateral
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the change in diameter.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize inputs
+    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
+
+    # For this problem, the cross-section is always circular
+    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
+        
+        area_mm2 = math.pi * (initial_diameter_mm / 2)**2
+        E_GPa = material['E_GPa']
+        nu = material['nu']
+
+        # Core Calculations (Units: N, mm, MPa)
+        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"
+        load_type_str = "tension" if load_kN > 0 else "compression"
+        dim_str = f"{initial_diameter_mm} mm"
+        unit_d = "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
+        
+        area_in2 = math.pi * (initial_diameter_in / 2)**2
+        E_ksi = material['E_ksi']
+        nu = material['nu']
+        
+        # Core Calculations (Units: kips, in, ksi)
+        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"
+        load_type_str = "tension" if load_kips > 0 else "compression"
+        dim_str = f"{initial_diameter_in} in"
+        unit_d = "in"
+
+    # 2. Generate Question and Solution Strings
+    question = (
+        f"A solid circular rod made of {material_name} has an initial diameter of {dim_str}. "
+        f"The rod is subjected to an axial load of {load_str} ({load_type_str}).\n\n"
+        f"Given the material properties for {material_name}:\n"
+        f"Modulus of Elasticity (E) = {material['E_GPa' if use_si_units else 'E_ksi']} {'GPa' if use_si_units else 'ksi'}\n"
+        f"Poisson's Ratio (nu) = {material['nu']}\n\n"
+        f"Determine the following:\n"
+        f"a) The change in the rod's diameter.\n"
+        f"b) The final diameter of the rod under the load."
+    )
+
+    solution = (
+        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"**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"
+    )
+
+    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"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"
+        )
+    else: # US units
+        solution += (
+            f"sigma = P / A = {load_kips} kips / {round(area_in2, 4)} in^2 = {round(stress_ksi, 3)} ksi\n"
+            f"Now, calculate axial strain using Hooke's Law: epsilon_axial = sigma / E.\n"
+            f"epsilon_axial = {round(stress_ksi, 3)} ksi / {E_ksi} ksi = {axial_strain:.4e}\n\n"
+        )
+
+    solution += (
+        f"**Step 2:** Calculate Lateral Strain (epsilon_lateral)\n"
+        f"Lateral strain is related to axial strain by Poisson's ratio: epsilon_lateral = -nu * epsilon_axial.\n"
+        f"The negative sign indicates that for positive axial strain (elongation), the lateral strain is negative (contraction), and vice-versa.\n"
+        f"epsilon_lateral = -({nu}) * ({axial_strain:.4e}) = {lateral_strain:.4e}\n\n"
+        
+        f"**Step 3:** Calculate the Change in Diameter (delta_d)\n"
+        f"The change in diameter is the lateral strain multiplied by the initial diameter.\n"
+        f"delta_d = d_0 * epsilon_lateral\n"
+        f"delta_d = ({initial_diameter_mm if use_si_units else initial_diameter_in} {unit_d}) * ({lateral_strain:.4e}) = {round(delta_diameter_mm if use_si_units else delta_diameter_in, precision)} {unit_d}\n\n"
+
+        f"**Step 4:** Calculate the Final Diameter (d_final)\n"
+        f"The final diameter is the initial diameter plus the change.\n"
+        f"d_final = d_0 + delta_d\n"
+        f"d_final = ({initial_diameter_mm if use_si_units else initial_diameter_in} {unit_d}) + ({round(delta_diameter_mm if use_si_units else delta_diameter_in, precision)} {unit_d}) = {round(final_diameter_mm if use_si_units else final_diameter_in, precision)} {unit_d}\n\n"
+
+        f"**Answer:**\n"
+        f"a) The change in diameter is **{round(delta_diameter_mm if use_si_units else delta_diameter_in, precision)} {unit_d}**.\n"
+        f"b) The final diameter is **{round(final_diameter_mm if use_si_units else final_diameter_in, precision)} {unit_d}**."
+    )
+    
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_statically_indeterminate():
+    """
+    Statically Indeterminate Axially Loaded Member
+
+    Scenario:
+        A uniform rod is fixed between two rigid walls. An external load is applied
+        at an intermediate point. This is statically indeterminate because there are
+        two unknown reaction forces (at the walls) but only one static equilibrium
+        equation. The problem is solved by using a compatibility equation based on
+        the fact that the total deformation of the rod must be zero.
+
+    Core Equations:
+        Equilibrium: Sum(F_x) = 0 => R_A + R_C = P
+        Compatibility: delta_total = 0 => delta_AB + delta_BC = 0
+                       (P_AB * L_AB / AE) + (P_BC * L_BC / AE) = 0
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for reaction forces and stresses.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize inputs
+    use_si_units = random.choice([True, False])
+    material_name = random.choice(list(MATERIAL_PROPERTIES.keys()))
+    material = MATERIAL_PROPERTIES[material_name]
+    shape = random.choice(['circular', 'square'])
+    precision = 3
+
+    if use_si_units:
+        # --- 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
+        load_P = random.randint(100, 500) # kN
+        
+        if shape == 'circular':
+            diameter = random.randint(50, 150) # mm
+            area = math.pi * (diameter / 2)**2
+            dim_str = f"a diameter of {diameter} mm"
+        else: # square
+            side = random.randint(50, 150) # mm
+            area = side**2
+            dim_str = f"a side length of {side} mm"
+        
+        E_val = material['E_GPa']
+        unit_L, unit_P, unit_S, unit_A, unit_E = "m", "kN", "MPa", "mm^2", "GPa"
+
+    else:
+        # --- 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
+        load_P = random.randint(50, 250) # kips
+        
+        if shape == 'circular':
+            diameter = round(random.uniform(2.0, 6.0), 2) # inches
+            area = math.pi * (diameter / 2)**2
+            dim_str = f"a diameter of {diameter} in"
+        else: # square
+            side = round(random.uniform(2.0, 6.0), 2) # inches
+            area = side**2
+            dim_str = f"a side length of {side} in"
+            
+        E_val = material['E_ksi']
+        unit_L, unit_P, unit_S, unit_A, unit_E = "in", "kips", "ksi", "in^2", "ksi"
+
+    # 2. Core Calculations
+    # From compatibility: R_A = P * L_BC / L_AC
+    # From equilibrium: R_C = P - R_A
+    R_A = load_P * (len_BC / total_length)
+    R_C = load_P - R_A
+
+    # Internal forces
+    P_AB = R_A  # Tension
+    P_BC = -R_C # Compression
+
+    # Stresses
+    stress_AB = P_AB / area
+    stress_BC = P_BC / area
+
+    # Unit conversion for SI stress
+    if use_si_units:
+        stress_AB_MPa = stress_AB * 1000 # Convert kN/mm^2 to MPa
+        stress_BC_MPa = stress_BC * 1000 # Convert kN/mm^2 to MPa
+
+    # 3. Generate Question and Solution Strings
+    question = (
+        f"A solid {material_name} rod with a uniform {shape} cross-section is fixed at both ends, A and C. "
+        f"The rod has a total length of {total_length} {unit_L} and {dim_str}.\n\n"
+        f"An external axial load of {load_P} {unit_P} is applied to the right at point B, "
+        f"which is located at a distance of {len_AB} {unit_L} from end A.\n\n"
+        f"The Modulus of Elasticity for {material_name} is {E_val} {unit_E}.\n\n"
+        f"Determine the following:\n"
+        f"a) The reaction forces at supports A and C.\n"
+        f"b) The normal stress in segments AB and BC of the rod."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Total Length (L_AC): {total_length} {unit_L}\n"
+        f"Length of segment AB (L_AB): {len_AB} {unit_L}\n"
+        f"Length of segment BC (L_BC): {total_length} - {len_AB} = {round(len_BC, 2)} {unit_L}\n"
+        f"Applied Load (P): {load_P} {unit_P}\n"
+        f"Area (A): {round(area, 2)} {unit_A}\n"
+        f"Modulus of Elasticity (E): {E_val} {unit_E}\n\n"
+
+        f"This is a statically indeterminate problem because there are two unknown support reactions (R_A and R_C) and only one equation of static equilibrium.\n\n"
+
+        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"**Step 2:** Equation of Compatibility\n"
+        f"Since the rod is fixed between unyielding supports, the total deformation must be zero.\n"
+        f"delta_total = delta_AB + delta_BC = 0\n"
+        f"The internal force in segment AB is the reaction R_A (in tension, P_AB = R_A).\n"
+        f"The internal force in segment BC is the reaction R_C (in compression, P_BC = -R_C).\n\n"
+        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"**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"
+        f"Substitute this into the simplified Equation 2:\n"
+        f"R_A * ({len_AB}) = ({load_P} - R_A) * ({round(len_BC, 2)})\n"
+        f"{round(len_AB, 2)}*R_A = {round(load_P * len_BC, 2)} - {round(len_BC, 2)}*R_A\n"
+        f"({round(len_AB, 2)} + {round(len_BC, 2)})*R_A = {round(load_P * len_BC, 2)}\n"
+        f"({total_length})*R_A = {round(load_P * len_BC, 2)}\n"
+        f"R_A = {round(load_P * len_BC, 2)} / {total_length} = {round(R_A, precision)} {unit_P}\n\n"
+        f"Now, find R_C using Equation 1:\n"
+        f"R_C = {load_P} - R_A = {load_P} - {round(R_A, precision)} = {round(R_C, precision)} {unit_P}\n\n"
+
+        f"**Step 4:** Calculate the Normal Stresses\n"
+        f"The stress in each segment is sigma = P_internal / A.\n"
+        f"**Segment AB:** The internal force is P_AB = R_A = {round(R_A, precision)} {unit_P} (Tension).\n"
+    )
+    if use_si_units:
+        solution += f"sigma_AB = ({round(R_A, precision)} kN) / ({round(area, 2)} mm^2) * 1000 = {round(stress_AB_MPa, precision)} MPa (Tension)\n"
+    else:
+        solution += f"sigma_AB = {round(R_A, precision)} kips / {round(area, 2)} in^2 = {round(stress_AB, precision)} ksi (Tension)\n"
+    
+    solution += f"  - **Segment BC:** The internal force is P_BC = -R_C = -{round(R_C, precision)} {unit_P} (Compression).\n"
+
+    if use_si_units:
+        solution += f"sigma_BC = (-{round(R_C, precision)} kN) / ({round(area, 2)} mm^2) * 1000 = {round(stress_BC_MPa, precision)} MPa (Compression)\n\n"
+    else:
+        solution += f"sigma_BC = -{round(R_C, precision)} kips / {round(area, 2)} in^2 = {round(stress_BC, precision)} ksi (Compression)\n\n"
+
+    solution += (
+        f"**Answer:**\n"
+        f"a) Reaction Forces: R_A = **{round(R_A, precision)} {unit_P}** and R_C = **{round(R_C, precision)} {unit_P}**.\n"
+        f"b) Normal Stresses: sigma_AB = **{round(stress_AB_MPa if use_si_units else stress_AB, precision)} {unit_S} (Tension)** and sigma_BC = **{round(abs(stress_BC_MPa if use_si_units else stress_BC), precision)} {unit_S} (Compression)**."
+    )
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each stres and strain - axial loading template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/mechanical_engineering/mechanics_of_materials/stress_and_strain.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_basic_stress_strain, "basic_stress_strain", "Easy"),
+        (template_axial_deformation, "axial_deformation", "Easy"),
+        (template_multi_segment_rod, "multi_segment_rod", "Intermediate"),
+        (template_poissons_ratio, "poissons_ratio", "Intermediate"),
+        (template_statically_indeterminate, "statically_indeterminate", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "mechanical_engineering",
+                "domain": "mechanics_of_materials",
+                "area": "stress_and_strain",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,604 @@
+import random
+import math
+from data.templates.branches.mechanical_engineering.constants import SHEAR_MODULUS_VALUES
+
+# Template 1 (Easy)
+def template_shear_stress_torsion():
+    """
+    Torsion: Shear Stress and Polar Moment of Inertia
+
+    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.
+
+    Core Equations:
+        tau_max = (T * c) / J
+        J_solid = (pi / 2) * c^4
+        J_hollow = (pi / 2) * (c_outer^4 - c_inner^4)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the maximum shearing stress in a shaft.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values
+    torque = round(random.uniform(100.0, 5000.0), 2)  # Torque in N.m
+    shaft_type = random.choice(['solid', 'hollow'])
+    
+    # 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
+    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)
+    else:
+        d_inner = 0
+
+    # Standardize precision for all calculations and outputs
+    precision = 3
+
+    # 2. Perform the core calculations for the solution
+    
+    # Step A: Convert diameters to radii in meters
+    c_outer = d_outer / 2000.0  # Convert mm to m and get radius
+    if shaft_type == 'hollow':
+        c_inner = d_inner / 2000.0
+    
+    # Step B: Calculate the polar moment of inertia (J)
+    if shaft_type == 'solid':
+        polar_moment_J = (math.pi / 2) * (c_outer ** 4)
+        j_calculation_str = f"J = (pi / 2) * c^4 = (pi / 2) * ({c_outer})^4 = {polar_moment_J:.3e} m^4"
+    else: # shaft_type == 'hollow'
+        polar_moment_J = (math.pi / 2) * (c_outer ** 4 - c_inner ** 4)
+        j_calculation_str = (
+            f"J = (pi / 2) * (c_outer^4 - c_inner^4)\n"
+            f"   J = (pi / 2) * (({c_outer})^4 - ({c_inner})^4) = {polar_moment_J:.3e} m^4"
+        )
+        
+    # Step C: Apply the torsion formula to find the stress in Pascals
+    # Note: 'c' in the formula refers to the outermost radius, c_outer.
+    tau_max_pascals = (torque * c_outer) / polar_moment_J
+    
+    # Step D: Convert the final answer to megapascals (MPa)
+    tau_max_mpa = tau_max_pascals / 1e6
+
+    # 3. Generate the question and solution strings
+    
+    # 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"
+    else: # shaft_type == 'hollow'
+        geometry_desc = (
+            f"a hollow circular shaft with an outer diameter of {d_outer} mm "
+            f"and an inner diameter of {d_inner} mm"
+        )
+
+    question = (
+        f"A {geometry_desc} is subjected to a torque of {torque} N.m. "
+        f"Determine the maximum shearing stress in the shaft."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Torque (T) = {torque} N.m\n"
+        f"Shaft Type = {shaft_type.capitalize()}\n"
+        f"Outer Diameter (d_outer) = {d_outer} mm\n"
+    )
+    if shaft_type == 'hollow':
+        solution += f"  - Inner Diameter (d_inner) = {d_inner} mm\n\n"
+    else:
+        solution += "\n"
+
+    solution += (
+        f"**Step 1:** Convert diameters to radii and express in meters.\n"
+        f"The maximum stress occurs at the outer surface, so we use the outer radius (c) for the stress calculation.\n"
+        f"Outer radius (c) = d_outer / 2 = {d_outer} / 2 = {d_outer/2.0} mm = {c_outer} m\n"
+    )
+    if shaft_type == 'hollow':
+        solution += f"  - Inner radius (c_inner) = d_inner / 2 = {d_inner} / 2 = {d_inner/2.0} mm = {c_inner} m\n"
+    solution += "\n"
+    
+    solution += (
+        f"**Step 2:** Calculate the polar moment of inertia (J) for the shaft's cross-section.\n"
+        f"For a {shaft_type} shaft:\n"
+        f"  {j_calculation_str}\n\n"
+        
+        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"T = {torque} N.m\n"
+        f"c = {c_outer} m\n"
+        f"J = {polar_moment_J:.3e} m^4\n"
+        f"tau_max = ({torque} * {c_outer}) / {polar_moment_J:.3e}\n"
+        f"tau_max = {tau_max_pascals:.3e} Pa\n\n"
+
+        f"**Step 4:** Convert the stress from Pascals (Pa) to Megapascals (MPa).\n"
+        f"1 MPa = 1,000,000 Pa\n"
+        f"tau_max = {tau_max_pascals:.3e} Pa / 1e6 = {round(tau_max_mpa, precision)} MPa\n\n"
+
+        f"**Answer:**\n"
+        f"The maximum shearing stress in the shaft is {round(tau_max_mpa, precision)} MPa."
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_angle_of_twist():
+    """
+    Torsion: Angle of Twist Calculation
+
+    Scenario:
+        This template assesses the ability to calculate the total angle of twist (phi)
+        for a uniform solid circular shaft. It requires a correct understanding of the
+        relationship between torque, length, material properties (Shear Modulus), and
+        the shaft's geometry (Polar Moment of Inertia).
+
+    Core Equations:
+        phi = (T * L) / (J * G)
+        J_solid = (pi / 2) * c^4
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the angle of twist in a shaft.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values
+    torque = round(random.uniform(500.0, 6000.0), 1)   # Torque in N.m
+    length = round(random.uniform(0.5, 4.0), 2)       # Length in m
+    diameter = random.randint(25, 100)                # Diameter in mm
+    
+    # Randomly select a material and its properties
+    material_name, shear_modulus_gpa = random.choice(list(SHEAR_MODULUS_VALUES.items()))
+    
+    # Standardize precision for final outputs
+    precision = 4
+
+    # 2. Perform the core calculations for the solution
+    
+    # Step A: Convert diameter (mm) to radius (m)
+    c_radius_m = diameter / 2000.0
+    
+    # Step B: Calculate the polar moment of inertia (J)
+    polar_moment_J = (math.pi / 2) * (c_radius_m ** 4)
+    
+    # Step C: Ensure all units are consistent (convert G from GPa to Pa)
+    shear_modulus_pa = shear_modulus_gpa * 1e9
+    
+    # Step D: Apply the angle of twist formula to find the angle in radians
+    angle_rad = (torque * length) / (polar_moment_J * shear_modulus_pa)
+    
+    # Step E: Convert the result from radians to degrees
+    angle_deg = math.degrees(angle_rad)
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A solid {material_name.lower()} shaft with a diameter of {diameter} mm and a length of {length} m "
+        f"is subjected to a torque of {torque} N.m. "
+        f"Given that the shear modulus (G) for {material_name.lower()} is {shear_modulus_gpa} GPa, "
+        f"calculate the total angle of twist. Provide the answer in both radians and degrees."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Torque (T) = {torque} N.m\n"
+        f"Length (L) = {length} m\n"
+        f"Diameter (d) = {diameter} mm\n"
+        f"Material = {material_name}\n"
+        f"Shear Modulus (G) = {shear_modulus_gpa} GPa\n\n"
+
+        f"**Step 1:** Convert the diameter to a radius in meters.\n"
+        f"Radius (c) = d / 2 = {diameter} / 2 = {diameter/2.0} mm = {c_radius_m} m\n\n"
+
+        f"**Step 2:** Calculate the polar moment of inertia (J) for the solid circular shaft.\n"
+        f"Formula: J = (pi / 2) * c^4\n"
+        f"J = (pi / 2) * ({c_radius_m})^4 = {polar_moment_J:.4e} m^4\n\n"
+        
+        f"**Step 3:** Ensure consistent units for the angle of twist calculation.\n"
+        f"The shear modulus must be in Pascals (Pa) to be consistent with N and m.\n"
+        f"G = {shear_modulus_gpa} GPa = {shear_modulus_pa:.2e} Pa\n\n"
+
+        f"**Step 4:** Apply the angle of twist formula to find the angle in radians.\n"
+        f"Formula: phi = (T * L) / (J * G)\n"
+        f"phi = ({torque} * {length}) / ({polar_moment_J:.4e} * {shear_modulus_pa:.2e})\n"
+        f"phi = {round(angle_rad, precision)} radians\n\n"
+
+        f"**Step 5:** Convert the angle from radians to degrees.\n"
+        f"Angle in degrees = Angle in radians * (180 / pi)\n"
+        f"Angle = {round(angle_rad, precision)} * (180 / pi) = {round(angle_deg, precision)} degrees\n\n"
+
+        f"**Answer:**\n"
+        f"The total angle of twist is {round(angle_rad, precision)} radians, which is equivalent to "
+        f"{round(angle_deg, precision)} degrees."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_shaft_design_power():
+    """
+    Torsion: Power Transmission and Shaft Design
+
+    Scenario:
+        This template generates a classic design problem. It tests the ability to
+        first determine the torque on a shaft from its power and rotational speed,
+        and then use that torque to calculate the minimum required shaft diameter
+        based on an allowable shearing stress.
+
+    Core Equations:
+        P = 2 * pi * f * T
+        tau_allow = (T * c) / J
+        For a solid shaft, this simplifies to: c = ( (2 * T) / (pi * tau) )^(1/3)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the minimum shaft diameter.
+            - str: A step-by-step solution to the design problem.
+    """
+    # 1. Parameterize the inputs with random values
+    power_kw = round(random.uniform(10.0, 500.0), 1)
+    allowable_stress_mpa = random.randint(40, 120)
+    
+    # Randomly choose to provide frequency in Hz or RPM to add variety
+    use_rpm = random.choice([True, False])
+    if use_rpm:
+        frequency_rpm = random.randint(500, 3000)
+        frequency_hz = frequency_rpm / 60.0
+        frequency_str = f"{frequency_rpm} RPM"
+    else:
+        frequency_hz = random.randint(10, 100)
+        frequency_rpm = frequency_hz * 60
+        frequency_str = f"{frequency_hz} Hz"
+
+    # Standardize precision for final outputs
+    precision = 2
+
+    # 2. Perform the core calculations for the solution
+    
+    # Step A: Convert primary units to base SI units (W, Pa, Hz)
+    power_w = power_kw * 1000
+    allowable_stress_pa = allowable_stress_mpa * 1e6
+    
+    # Step B: Calculate the torque (T) on the shaft using the power formula
+    # P = 2 * pi * f * T  =>  T = P / (2 * pi * f)
+    torque = power_w / (2 * math.pi * frequency_hz)
+    
+    # Step C: Calculate the required radius (c) using the rearranged torsion formula
+    # tau = (T*c) / J = (T*c) / (pi/2 * c^4) = 2*T / (pi*c^3)
+    # c^3 = (2 * T) / (pi * tau)
+    c_cubed = (2 * torque) / (math.pi * allowable_stress_pa)
+    c_radius_m = c_cubed ** (1/3)
+    
+    # Step D: Calculate the diameter in meters and then convert to millimeters
+    d_diameter_m = c_radius_m * 2
+    d_diameter_mm = d_diameter_m * 1000
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A motor is required to transmit {power_kw} kW of power at a rotational speed of {frequency_str}. "
+        f"If the solid circular shaft is to be made from a material with an allowable shearing stress of {allowable_stress_mpa} MPa, "
+        f"determine the minimum required diameter for the shaft."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Power (P) = {power_kw} kW\n"
+        f"Rotational Speed = {frequency_str}\n"
+        f"Allowable Shearing Stress (tau_allow) = {allowable_stress_mpa} MPa\n\n"
+
+        f"**Step 1:** Convert the given values to base SI units (Watts, Pascals, Hertz).\n"
+        f"Power (P) = {power_kw} kW = {power_w} W\n"
+        f"Allowable Stress (tau_allow) = {allowable_stress_mpa} MPa = {allowable_stress_pa:.1e} Pa\n"
+    )
+
+    if use_rpm:
+        solution += (
+            f"  - Frequency (f) = {frequency_rpm} RPM = {frequency_rpm} / 60 = {round(frequency_hz, 2)} Hz\n\n"
+        )
+    else:
+        solution += f"  - Frequency (f) = {frequency_hz} Hz\n\n"
+
+    solution += (
+        f"**Step 2:** Calculate the torque (T) exerted on the shaft.\n"
+        f"The relationship between power, torque, and frequency is P = 2 * pi * f * T.\n"
+        f"Rearranging for torque: T = P / (2 * pi * f)\n"
+        f"T = {power_w} / (2 * pi * {round(frequency_hz, 2)}) = {round(torque, 2)} N.m\n\n"
+        
+        f"**Step 3:** Determine the required shaft radius (c) using the torsion formula.\n"
+        f"The formula for maximum stress in a solid shaft is tau = (T * c) / J, where J = (pi/2) * c^4.\n"
+        f"This simplifies to tau = 2 * T / (pi * c^3).\n"
+        f"Rearranging to solve for the radius: c^3 = (2 * T) / (pi * tau_allow)\n"
+        f"c^3 = (2 * {round(torque, 2)}) / (pi * {allowable_stress_pa:.1e}) = {c_cubed:.3e} m^3\n"
+        f"c = ({c_cubed:.3e})^(1/3) = {round(c_radius_m, 4)} m\n\n"
+
+        f"**Step 4:** Calculate the minimum diameter from the radius.\n"
+        f"Diameter (d) = 2 * c\n"
+        f"d = 2 * {round(c_radius_m, 4)} = {round(d_diameter_m, 4)} m\n"
+        f"In millimeters, d = {round(d_diameter_mm, precision)} mm\n\n"
+        
+        f"**Answer:**\n"
+        f"The minimum required diameter for the solid circular shaft is {round(d_diameter_mm, precision)} mm."
+    )
+
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_composite_shafts_series():
+    """
+    Torsion: Composite Shafts in Series
+
+    Scenario:
+        This problem involves a shaft made of two different segments joined end-to-end.
+        It tests the understanding that the total angle of twist at the free end is
+        the algebraic sum of the angles of twist of each individual segment.
+
+    Core Equations:
+        phi_total = sum( (T_i * L_i) / (J_i * G_i) )
+        For this case: phi_total = phi_1 + phi_2
+        J_solid = (pi / 2) * c^4
+
+    Returns:
+        tuple: A tuple containing:
+            - 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)
+
+    # 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()))
+
+    # 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()))
+    
+    # Standardize precision for final outputs
+    precision = 4
+
+    # 2. Perform the core calculations
+    
+    # --- 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) ---
+    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 ---
+    phi_total_rad = phi1_rad + phi2_rad
+    phi_total_deg = math.degrees(phi_total_rad)
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A composite shaft consists of two segments, AB and BC, rigidly connected at B. "
+        f"Segment AB is a solid {mat1_name.lower()} shaft of length {l1} m and diameter {d1} mm. "
+        f"Segment BC is a solid {mat2_name.lower()} shaft of length {l2} m and diameter {d2} mm. "
+        f"The shaft is fixed at end A, and a torque of {torque} N.m is applied at the free end C. "
+        f"Calculate the total angle of twist at end C. "
+        f"(Use G = {g1_gpa} GPa for {mat1_name.lower()} and G = {g2_gpa} GPa for {mat2_name.lower()})."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Applied Torque (T) = {torque} N.m\n"
+        f"Segment AB: L1={l1} m, d1={d1} mm, Material={mat1_name} (G1={g1_gpa} GPa)\n"
+        f"Segment BC: L2={l2} m, d2={d2} mm, Material={mat2_name} (G2={g2_gpa} GPa)\n\n"
+        
+        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"**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"
+        f"Polar Moment of Inertia (J1) = (pi/2) * c1^4 = (pi/2) * ({c1_m})^4 = {j1:.3e} m^4\n"
+        f"Angle of Twist (phi_AB) = (T * L1) / (J1 * G1)\n"
+        f"phi_AB = ({torque} * {l1}) / ({j1:.3e} * {g1_pa:.2e}) = {round(phi1_rad, precision + 1)} radians\n\n"
+        
+        f"**Step 3:** Calculate Angle of Twist for Segment BC (phi_BC)\n"
+        f"Convert units: c2 = {d2}/2 mm = {c2_m} m; G2 = {g2_gpa} GPa = {g2_pa:.2e} Pa\n"
+        f"Polar Moment of Inertia (J2) = (pi/2) * c2^4 = (pi/2) * ({c2_m})^4 = {j2:.3e} m^4\n"
+        f"Angle of Twist (phi_BC) = (T * L2) / (J2 * G2)\n"
+        f"phi_BC = ({torque} * {l2}) / ({j2:.3e} * {g2_pa:.2e}) = {round(phi2_rad, precision + 1)} radians\n\n"
+        
+        f"**Step 4:** Calculate Total Angle of Twist at End C\n"
+        f"phi_total = phi_AB + phi_BC\n"
+        f"phi_total = {round(phi1_rad, precision + 1)} + {round(phi2_rad, precision + 1)} = {round(phi_total_rad, precision)} radians\n"
+        f"To convert to degrees: Angle_deg = Angle_rad * (180 / pi)\n"
+        f"phi_total = {round(phi_total_rad, precision)} * (180 / pi) = {round(phi_total_deg, precision)} degrees\n\n"
+        
+        f"**Answer:**\n"
+        f"The total angle of twist at the free end C is {round(phi_total_rad, precision)} radians, "
+        f"or {round(phi_total_deg, precision)} degrees."
+    )
+
+    return question, solution
+
+
+# Template 5 (Advanced)
+def template_statically_indeterminate_shaft():
+    """
+    Torsion: Statically Indeterminate Shaft
+
+    Scenario:
+        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).
+
+    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
+
+    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)
+    
+    # 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()))
+    
+    # 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)
+    
+    reaction_torque_A = applied_torque * (pos_L_BC / total_length)
+    reaction_torque_B = applied_torque * (pos_L_AC / total_length)
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A solid {material_name.lower()} shaft of diameter {diameter} mm and length {total_length} m is "
+        f"fixed at both ends, A and B. A torque of {int(applied_torque)} N.m is applied at point C, "
+        f"located {pos_L_AC} m from end A. The shear modulus for the material is {shear_modulus_gpa} GPa. "
+        f"Determine the reaction torques at the fixed supports, T_A and T_B."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Total Length (L) = {total_length} m\n"
+        f"Applied Torque (T_applied) = {int(applied_torque)} N.m\n"
+        f"Location of Torque from A (L_AC) = {pos_L_AC} m\n"
+        f"Diameter (d) = {diameter} mm, Material = {material_name}\n\n"
+        
+        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"**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"(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"(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"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"**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"
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each torsion template 
+    with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/mechanical_engineering/mechanics_of_materials/torsion.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_shear_stress_torsion, "shear_stress_torsion", "Easy"),
+        (template_angle_of_twist, "angle_of_twist", "Easy"),
+        (template_shaft_design_power, "shaft_design_power", "Intermediate"),
+        (template_composite_shafts_series, "composite_shafts_series", "Intermediate"),
+        (template_statically_indeterminate_shaft, "statically_indeterminate_shaft", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "mechanical_engineering",
+                "domain": "mechanics_of_materials",
+                "area": "torsion",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

data/templates/branches/mechanical_engineering/vibrations_and_acoustics/harmonically_excited_vibrations.py

@@ -0,0 +1,584 @@
+import random
+import math
+
+
+# Template 1 (Easy)
+def template_system_properties():
+    """
+    Vibrations: System Properties (Natural Frequency and Damping Ratio)
+
+    Scenario:
+        This template generates a foundational problem for analyzing a single-degree-of-freedom
+        spring-mass-damper system. Given the system's physical parameters (mass, stiffness,
+        and damping coefficient), the objective is to calculate its key dynamic properties:
+        the undamped natural frequency, the critical damping coefficient, and the damping ratio.
+        Finally, the system is classified based on its damping level.
+
+    Core Equations:
+        omega_n = sqrt(k / m)
+        c_cr = 2 * sqrt(k * m)
+        zeta = c / c_cr
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the system's dynamic properties and classification.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Mass in kg, ensuring a practical range
+    mass = round(random.uniform(2.0, 250.0), 2)
+    
+    # Stiffness in N/m
+    stiffness = round(random.uniform(1000.0, 150000.0), 1)
+    
+    # To generate diverse and meaningful scenarios (underdamped, critically damped, overdamped),
+    # we first determine the critical damping and then set the actual damping based on it.
+    
+    # We select a random damping ratio first to define the system type
+    target_zeta = round(random.uniform(0.1, 2.5), 3) 
+    
+    # Handle the edge case of m=0 or k=0, though randomization range prevents it.
+    if mass <= 0 or stiffness <= 0:
+        # Assign default safe values in the unlikely event of non-positive inputs
+        mass = 10.0
+        stiffness = 20000.0
+
+    critical_damping = 2 * math.sqrt(stiffness * mass)
+    
+    # Calculate the actual damping coefficient based on the target zeta
+    damping_coeff = round(target_zeta * critical_damping, 2)
+
+    # Standardize precision for all calculations and outputs
+    precision = 4
+
+    # 2. Perform the core calculations for the solution
+    
+    # Step A: Calculate the undamped natural frequency (omega_n)
+    omega_n = math.sqrt(stiffness / mass)
+    
+    # Step B: The critical damping coefficient (c_cr) was already calculated
+    # We re-calculate here to show the step clearly in the solution.
+    c_critical = 2 * math.sqrt(stiffness * mass)
+    
+    # Step C: Calculate the damping ratio (zeta)
+    damping_ratio = damping_coeff / c_critical
+    
+    # Step D: Classify the system based on the damping ratio
+    if abs(damping_ratio - 1.0) < 1e-9: # Use tolerance for floating point comparison
+        system_type = "critically damped"
+    elif damping_ratio < 1.0:
+        system_type = "underdamped"
+    else:
+        system_type = "overdamped"
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A spring-mass-damper system has the following properties:\n"
+        f"Mass (m) = {mass} kg\n"
+        f"Spring Stiffness (k) = {stiffness} N/m\n"
+        f"Damping Coefficient (c) = {damping_coeff} N.s/m\n\n"
+        f"Determine the following:\n"
+        f"  1. The undamped natural frequency (in rad/s).\n"
+        f"  2. The critical damping coefficient.\n"
+        f"  3. The damping ratio.\n"
+        f"  4. Classify the system as underdamped, critically damped, or overdamped."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Mass (m) = {mass} kg\n"
+        f"Stiffness (k) = {stiffness} N/m\n"
+        f"Damping Coefficient (c) = {damping_coeff} N.s/m\n\n"
+        
+        f"**Step 1:** Calculate the undamped natural frequency (omega_n).\n"
+        f"The formula is: omega_n = sqrt(k / m)\n"
+        f"omega_n = sqrt({stiffness} / {mass})\n"
+        f"omega_n = {round(omega_n, precision)} rad/s\n\n"
+
+        f"**Step 2:** Calculate the critical damping coefficient (c_cr).\n"
+        f"The formula is: c_cr = 2 * sqrt(k * m)\n"
+        f"c_cr = 2 * sqrt({stiffness} * {mass})\n"
+        f"c_cr = {round(c_critical, precision)} N.s/m\n\n"
+
+        f"**Step 3:** Calculate the damping ratio (zeta).\n"
+        f"The formula is: zeta = c / c_cr\n"
+        f"zeta = {damping_coeff} / {round(c_critical, precision)}\n"
+        f"zeta = {round(damping_ratio, precision)}\n\n"
+
+        f"**Step 4:** Classify the system based on the damping ratio.\n"
+        f"The damping ratio is {round(damping_ratio, precision)}.\n"
+        f"Since zeta is {'less than 1' if system_type == 'underdamped' else ('equal to 1' if system_type == 'critically damped' else 'greater than 1')}, "
+        f"the system is classified as **{system_type}**.\n\n"
+        
+        f"**Answer:**\n"
+        f"Undamped Natural Frequency: {round(omega_n, precision)} rad/s\n"
+        f"Critical Damping Coefficient: {round(c_critical, precision)} N.s/m\n"
+        f"Damping Ratio: {round(damping_ratio, precision)}\n"
+        f"System Type: {system_type.capitalize()}"
+    )
+
+    return question, solution
+
+
+# Template 2 (Intermediate)
+def template_rotating_unbalance():
+    """
+    Vibrations: Response to Rotating Unbalance
+
+    Scenario:
+        This template generates a problem involving a machine with a rotating component
+        that is out of balance. This common engineering scenario creates a harmonic
+        excitation force whose magnitude is dependent on the operating speed. The goal
+        is to determine the resulting steady-state vibration amplitude.
+
+    Core Equations:
+        omega_n = sqrt(k / m)
+        zeta = c / (2 * sqrt(k * m))
+        r = omega / omega_n
+        F_0 = m_e * e * omega^2
+        X = F_0 / sqrt((k - m * omega^2)^2 + (c * omega)^2)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the steady-state amplitude of vibration.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Total mass of the machine in kg
+    m_total = round(random.uniform(50.0, 500.0), 1)
+    
+    # Eccentric mass in kg (should be a small fraction of total mass)
+    m_eccentric = round(random.uniform(0.1, m_total * 0.05), 2)
+    
+    # Eccentricity in mm
+    eccentricity_mm = random.randint(10, 150)
+    
+    # Stiffness in N/m
+    stiffness = round(random.uniform(5e4, 2e6), 0)
+    
+    # Define system properties by choosing a damping ratio first for better control
+    # Lightly damped systems are common for this problem type.
+    damping_ratio_zeta = round(random.uniform(0.05, 0.6), 3)
+    
+    # Define operating speed by choosing a frequency ratio first
+    # This ensures we get a good spread of cases (below, near, and above resonance)
+    freq_ratio_r = round(random.uniform(0.3, 3.0), 3)
+
+    # Standardize precision for final outputs
+    precision = 5
+    
+    # 2. Perform the core calculations for the solution
+    
+    # Handle potential edge cases from inputs
+    if m_total <= 0 or stiffness <= 0:
+        return "Error: Mass and stiffness must be positive.", "Invalid input parameters."
+
+    # Step A: Calculate fundamental system properties
+    omega_n = math.sqrt(stiffness / m_total)
+    c_critical = 2 * math.sqrt(stiffness * m_total)
+    damping_coeff = damping_ratio_zeta * c_critical
+    
+    # Step B: Determine the operating speed from the chosen frequency ratio
+    omega = freq_ratio_r * omega_n
+    operating_speed_rpm = omega * 60 / (2 * math.pi)
+    
+    # Step C: Convert units for calculation consistency
+    eccentricity_m = eccentricity_mm / 1000.0
+    
+    # Step D: Calculate the magnitude of the unbalanced force
+    force_magnitude_F0 = m_eccentric * eccentricity_m * (omega ** 2)
+    
+    # Step E: Calculate the steady-state amplitude (X) in meters
+    # Denominator components
+    term1 = stiffness - m_total * (omega ** 2)
+    term2 = damping_coeff * omega
+    denominator = math.sqrt(term1**2 + term2**2)
+    
+    amplitude_m = force_magnitude_F0 / denominator if denominator != 0 else float('inf')
+    
+    # Step F: Convert final amplitude to millimeters for a more intuitive answer
+    amplitude_mm = amplitude_m * 1000.0
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A machine with a total mass of {m_total} kg is supported by a spring and damper system. "
+        f"The system has an equivalent stiffness of {stiffness:,.0f} N/m and an equivalent damping "
+        f"coefficient of {round(damping_coeff, 2)} N.s/m.\n\n"
+        f"The machine contains a rotating component that has an unbalance equivalent to a mass of "
+        f"{m_eccentric} kg located at an eccentricity of {eccentricity_mm} mm. "
+        f"If the machine operates at a speed of {round(operating_speed_rpm, 0):,.0f} RPM, "
+        f"determine the steady-state amplitude of vibration."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Total Mass (m) = {m_total} kg\n"
+        f"Stiffness (k) = {stiffness:,.0f} N/m\n"
+        f"Damping Coefficient (c) = {round(damping_coeff, 2)} N.s/m\n"
+        f"Eccentric Mass (m_e) = {m_eccentric} kg\n"
+        f"Eccentricity (e) = {eccentricity_mm} mm = {eccentricity_m} m\n"
+        f"Operating Speed = {round(operating_speed_rpm, 0):,.0f} RPM\n\n"
+
+        f"**Step 1:** Convert the operating speed from RPM to rad/s.\n"
+        f"omega = (Speed in RPM) * (2 * pi / 60)\n"
+        f"omega = {round(operating_speed_rpm, 0):,.0f} * (2 * pi / 60) = {round(omega, precision)} rad/s\n\n"
+
+        f"**Step 2:** Calculate the system's natural frequency (omega_n) and damping ratio (zeta).\n"
+        f"omega_n = sqrt(k / m) = sqrt({stiffness:,.0f} / {m_total}) = {round(omega_n, precision)} rad/s\n"
+        f"c_cr = 2 * sqrt(k * m) = 2 * sqrt({stiffness:,.0f} * {m_total}) = {round(c_critical, precision)} N.s/m\n"
+        f"zeta = c / c_cr = {round(damping_coeff, 2)} / {round(c_critical, precision)} = {round(damping_ratio_zeta, precision)}\n\n"
+
+        f"**Step 3:** Calculate the magnitude of the unbalanced force (F_0).\n"
+        f"The force from a rotating unbalance is given by F_0 = m_e * e * omega^2.\n"
+        f"F_0 = {m_eccentric} kg * {eccentricity_m} m * ({round(omega, precision)} rad/s)^2\n"
+        f"F_0 = {round(force_magnitude_F0, precision)} N\n\n"
+        
+        f"**Step 4:** Calculate the steady-state amplitude of vibration (X).\n"
+        f"The formula for amplitude is: X = F_0 / sqrt((k - m * omega^2)^2 + (c * omega)^2)\n"
+        f"Numerator = F_0 = {round(force_magnitude_F0, precision)} N\n"
+        f"Denominator Part 1: (k - m * omega^2) = ({stiffness:,.0f} - {m_total} * {round(omega, precision)}^2) = {round(term1, precision)}\n"
+        f"Denominator Part 2: (c * omega) = ({round(damping_coeff, 2)} * {round(omega, precision)}) = {round(term2, precision)}\n"
+        f"Denominator = sqrt(({round(term1, precision)})^2 + ({round(term2, precision)})^2) = {round(denominator, precision)}\n"
+        f"X = {round(force_magnitude_F0, precision)} / {round(denominator, precision)}\n"
+        f"X = {round(amplitude_m, precision + 2)} m\n\n"
+        
+        f"**Step 5:** Convert the amplitude to millimeters.\n"
+        f"Amplitude in mm = {round(amplitude_m, precision + 2)} m * 1000 mm/m = {round(amplitude_mm, precision)} mm\n\n"
+        
+        f"**Answer:**\n"
+        f"The steady-state amplitude of vibration is **{round(amplitude_mm, 3)} mm**."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_vibration_transmissibility():
+    """
+    Vibrations: Displacement Transmissibility from Base Excitation
+
+    Scenario:
+        This template addresses the problem of a system mounted on a vibrating foundation.
+        It is a key concept in vibration isolation, where the goal is to minimize the
+        motion transmitted from a vibrating source to a sensitive component. The template
+        calculates the ratio of the output amplitude to the input (base) amplitude
+        and the absolute amplitude of the system.
+
+    Core Equations:
+        omega_n = sqrt(k / m)
+        zeta = c / (2 * sqrt(k * m))
+        r = omega / omega_n
+        TR = X / Y = sqrt( (1 + (2*zeta*r)^2) / ( (1 - r^2)^2 + (2*zeta*r)^2 ) )
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the transmissibility and absolute amplitude.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Mass of the sensitive instrument in kg
+    mass = round(random.uniform(5.0, 150.0), 1)
+    
+    # Stiffness of the isolation mount in N/m
+    stiffness = round(random.uniform(2e3, 5e5), 0)
+    
+    # Amplitude of the base vibration in mm
+    base_amplitude_Y_mm = round(random.uniform(0.1, 8.0), 2)
+    
+    # Use frequency ratio and damping ratio to control the problem's outcome
+    # This ensures we test conditions of amplification (r~1) and isolation (r > sqrt(2))
+    freq_ratio_r = round(random.uniform(0.2, 5.0), 3)
+    damping_ratio_zeta = round(random.uniform(0.05, 0.7), 3)
+    
+    # Standardize precision for final outputs
+    precision = 4
+
+    # 2. Perform the core calculations for the solution
+    
+    # Handle potential edge cases
+    if mass <= 0 or stiffness <= 0:
+        return "Error: Mass and stiffness must be positive.", "Invalid input parameters."
+
+    # Step A: Calculate fundamental system properties
+    omega_n = math.sqrt(stiffness / mass)
+    c_critical = 2 * math.sqrt(stiffness * mass)
+    damping_coeff = damping_ratio_zeta * c_critical
+
+    # Step B: Determine the base excitation frequency from the chosen frequency ratio
+    omega = freq_ratio_r * omega_n
+    base_freq_hz = omega / (2 * math.pi)
+
+    # Step C: Convert base amplitude to meters for calculation
+    base_amplitude_Y_m = base_amplitude_Y_mm / 1000.0
+
+    # Step D: Calculate the displacement transmissibility ratio (TR)
+    tr_num = 1 + (2 * damping_ratio_zeta * freq_ratio_r)**2
+    tr_den = (1 - freq_ratio_r**2)**2 + (2 * damping_ratio_zeta * freq_ratio_r)**2
+
+    # Avoid division by zero, although highly unlikely with these random ranges
+    if tr_den == 0:
+        transmissibility_ratio = float('inf')
+    else:
+        transmissibility_ratio = math.sqrt(tr_num / tr_den)
+    
+    # Step E: Calculate the absolute amplitude of the instrument's vibration
+    amplitude_X_m = transmissibility_ratio * base_amplitude_Y_m
+    amplitude_X_mm = amplitude_X_m * 1000.0
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A sensitive instrument of mass {mass} kg is supported by an isolation mount. "
+        f"The mount has an effective stiffness of {stiffness:,.0f} N/m and provides a damping "
+        f"ratio of {damping_ratio_zeta}.\n\n"
+        f"The foundation on which the instrument is placed is vibrating harmonically at a frequency of "
+        f"{round(base_freq_hz, 2)} Hz with an amplitude of {base_amplitude_Y_mm} mm.\n\n"
+        f"Determine:\n"
+        f"1. The displacement transmissibility ratio.\n"
+        f"2. The absolute amplitude of vibration of the instrument in millimeters."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Mass (m) = {mass} kg\n"
+        f"Stiffness (k) = {stiffness:,.0f} N/m\n"
+        f"Damping Ratio (zeta) = {damping_ratio_zeta}\n"
+        f"Base Vibration Frequency (f) = {round(base_freq_hz, 2)} Hz\n"
+        f"Base Vibration Amplitude (Y) = {base_amplitude_Y_mm} mm = {base_amplitude_Y_m} m\n\n"
+
+        f"**Step 1:** Calculate the system's undamped natural frequency (omega_n).\n"
+        f"omega_n = sqrt(k / m) = sqrt({stiffness:,.0f} / {mass}) = {round(omega_n, precision)} rad/s\n\n"
+
+        f"**Step 2:** Convert the base vibration frequency to rad/s and find the frequency ratio (r).\n"
+        f"Base frequency (omega) = f * 2 * pi = {round(base_freq_hz, 2)} * 2 * pi = {round(omega, precision)} rad/s\n"
+        f"Frequency ratio (r) = omega / omega_n = {round(omega, precision)} / {round(omega_n, precision)} = {round(freq_ratio_r, precision)}\n\n"
+
+        f"**Step 3:** Calculate the displacement transmissibility ratio (TR).\n"
+        f"The formula is: TR = sqrt( (1 + (2*zeta*r)^2) / ( (1 - r^2)^2 + (2*zeta*r)^2 ) )\n"
+        f"Let's calculate the terms:\n"
+        f"r = {round(freq_ratio_r, precision)}\n"
+        f"zeta = {damping_ratio_zeta}\n"
+        f"Numerator = 1 + (2 * {damping_ratio_zeta} * {round(freq_ratio_r, precision)})^2 = {round(tr_num, precision)}\n"
+        f"Denominator = (1 - ({round(freq_ratio_r, precision)})^2)^2 + (2 * {damping_ratio_zeta} * {round(freq_ratio_r, precision)})^2 = {round(tr_den, precision)}\n"
+        f"TR = sqrt({round(tr_num, precision)} / {round(tr_den, precision)}) = {round(transmissibility_ratio, precision)}\n\n"
+
+        f"**Step 4:** Calculate the absolute amplitude of the instrument (X).\n"
+        f"The relationship is X = TR * Y.\n"
+        f"X = {round(transmissibility_ratio, precision)} * {base_amplitude_Y_mm} mm\n"
+        f"X = {round(amplitude_X_mm, precision)} mm\n\n"
+
+        f"**Answer:**\n"
+        f"The displacement transmissibility ratio is **{round(transmissibility_ratio, 3)}**.\n"
+        f"The absolute amplitude of the instrument's vibration is **{round(amplitude_X_mm, 3)} mm**."
+    )
+
+    return question, solution
+
+
+# Template 4 (Advanced)
+def template_vibration_isolator_design():
+    """
+    Vibrations: Vibration Isolator Design (Inverse Problem)
+
+    Scenario:
+        This template creates an advanced design problem. An engine generating a harmonic
+        force needs to be mounted on isolators to limit the force transmitted to its
+        foundation. Given a maximum allowable force transmission percentage, the task
+        is to determine the necessary stiffness of the isolation system. This is an
+        inverse problem, requiring algebraic manipulation to solve for a system parameter.
+
+    Core Equations:
+        TR = sqrt( (1 + (2*zeta*r)^2) / ( (1 - r^2)^2 + (2*zeta*r)^2 ) )
+        This is solved for r, which is then used to find omega_n and finally k.
+        k = m * omega_n^2
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the required stiffness of an isolator.
+            - str: A step-by-step solution to the design problem.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Mass of the engine in kg
+    mass = round(random.uniform(100.0, 2000.0), 1)
+    
+    # Operating speed in RPM
+    operating_speed_rpm = random.randint(500, 3000)
+    
+    # Desired force transmissibility in percent
+    transmissibility_percent = random.randint(5, 20)
+    
+    # Assumed damping ratio for the isolators (typically low)
+    damping_ratio_zeta = round(random.uniform(0.05, 0.25), 3)
+
+    # Standardize precision for final outputs
+    precision = 4
+
+    # 2. Perform the core calculations for the solution
+    
+    # Step A: Convert inputs to consistent units
+    omega = operating_speed_rpm * (2 * math.pi / 60)
+    transmissibility_ratio_TR = transmissibility_percent / 100.0
+
+    # Step B: Solve for the frequency ratio (r)
+    # The equation TR^2 = (1 + (2*zeta*r)^2) / ((1-r^2)^2 + (2*zeta*r)^2)
+    # rearranges into a quadratic equation in terms of r^2: A*(r^2)^2 + B*(r^2) + C = 0
+    TR_sq = transmissibility_ratio_TR**2
+    
+    A = TR_sq
+    B = 4 * (damping_ratio_zeta**2) * (TR_sq - 1) - 2 * TR_sq
+    C = TR_sq - 1
+
+    # Calculate the discriminant
+    discriminant = B**2 - 4 * A * C
+    
+    # Ensure a real solution exists (handles complex roots)
+    if discriminant < 0:
+        # This case is highly unlikely with TR < 1, but it's good practice to handle it.
+        return ("Error: No real solution for frequency ratio (complex roots).",
+                "The design parameters are not physically achievable.")
+        
+    # Solve the quadratic equation for r^2
+    r_sq_sol1 = (-B + math.sqrt(discriminant)) / (2 * A)
+    r_sq_sol2 = (-B - math.sqrt(discriminant)) / (2 * A)
+    
+    # For effective isolation (transmissibility TR < 1), the frequency ratio 'r'
+    # must be greater than sqrt(2). We therefore need the larger, positive root for r^2.
+    r_squared = max(r_sq_sol1, r_sq_sol2)
+
+    # Add validation check for non-physical results (negative roots for r^2)
+    if r_squared < 0:
+        return ("Error: Design parameters result in a non-physical solution (r^2 < 0).",
+                "The required transmissibility cannot be achieved with the given damping.")
+    
+    freq_ratio_r = math.sqrt(r_squared)
+    
+    # Step C: Calculate the required natural frequency (omega_n)
+    omega_n_req = omega / freq_ratio_r
+    
+    # Step D: Calculate the required stiffness (k)
+    stiffness_req = mass * (omega_n_req**2)
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"An engine with a mass of {mass} kg operates at a constant speed of {operating_speed_rpm} RPM. "
+        f"It needs to be mounted on a set of vibration isolators. The design specification requires that no more than "
+        f"{transmissibility_percent}% of the engine's unbalanced force is transmitted to the foundation.\n\n"
+        f"Assuming the isolators have a combined damping ratio of {damping_ratio_zeta}, "
+        f"determine the total required stiffness (k) of the isolation system."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Mass (m) = {mass} kg\n"
+        f"Operating Speed = {operating_speed_rpm} RPM\n"
+        f"Maximum Transmissibility (TR) = {transmissibility_percent}% = {transmissibility_ratio_TR}\n"
+        f"Damping Ratio (zeta) = {damping_ratio_zeta}\n\n"
+
+        f"**Step 1:** Convert the operating speed to rad/s.\n"
+        f"omega = {operating_speed_rpm} RPM * (2 * pi / 60) = {round(omega, precision)} rad/s\n\n"
+
+        f"**Step 2:** Set up the force transmissibility equation to solve for the frequency ratio (r).\n"
+        f"The formula is TR^2 = [1 + (2*zeta*r)^2] / [(1 - r^2)^2 + (2*zeta*r)^2]\n"
+        f"Rearranging this gives a quadratic equation in the form A(r^2)^2 + B(r^2) + C = 0.\n"
+        f"A = TR^2 = {round(TR_sq, precision)}\n"
+        f"B = 4*zeta^2*(TR^2 - 1) - 2*TR^2 = 4*({damping_ratio_zeta}^2)*({round(TR_sq, precision)} - 1) - 2*{round(TR_sq, precision)} = {round(B, precision)}\n"
+        f"C = TR^2 - 1 = {round(TR_sq, precision)} - 1 = {round(C, precision)}\n\n"
+        
+        f"**Step 3:** Solve the quadratic equation for r^2 using the formula r^2 = (-B +/- sqrt(B^2 - 4AC)) / 2A.\n"
+        f"Discriminant (D) = B^2 - 4AC = ({round(B, precision)})^2 - 4*({round(A, precision)})*({round(C, precision)}) = {round(discriminant, precision)}\n"
+        f"The two solutions for r^2 are: {round(r_sq_sol1, precision)} and {round(r_sq_sol2, precision)}.\n"
+        f"For effective vibration isolation, the frequency ratio 'r' must be greater than sqrt(2) (approx 1.414). This requires us to select the larger of the two positive solutions for r^2.\n"
+        f"Required r^2 = {round(r_squared, precision)}\n\n"
+        
+        f"**Step 4:** Calculate the required frequency ratio (r) and validate the isolation condition.\n"
+        f"r = sqrt({round(r_squared, precision)}) = {round(freq_ratio_r, precision)}\n"
+        f"Check: Is r > sqrt(2)? Yes, {round(freq_ratio_r, precision)} > 1.414. The condition for isolation is met.\n\n"
+        
+        f"**Step 5:** Determine the required natural frequency (omega_n) of the system.\n"
+        f"Since r = omega / omega_n, the required omega_n = omega / r.\n"
+        f"omega_n = {round(omega, precision)} / {round(freq_ratio_r, precision)} = {round(omega_n_req, precision)} rad/s\n\n"
+
+        f"**Step 6:** Calculate the total required stiffness (k).\n"
+        f"The natural frequency is defined by omega_n = sqrt(k / m). Therefore, k = m * omega_n^2.\n"
+        f"k = {mass} kg * ({round(omega_n_req, precision)} rad/s)^2\n"
+        f"k = {round(stiffness_req, 0):,.0f} N/m\n\n"
+        
+        f"**Answer:**\n"
+        f"The total required stiffness for the isolation system is **{round(stiffness_req, 0):,.0f} N/m**.\n\n"
+        f"*Note: In a practical application, this total stiffness would be distributed among several individual isolator mounts.*"
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each free harmonically excited vibrations 
+    template with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/mechanical_engineering/vibrations_and_acoustics/harmonically_excited_vibrations.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_system_properties, "system_properties", "Easy"),
+        (template_rotating_unbalance, "rotating_unbalance", "Intermediate"),
+        (template_vibration_transmissibility, "vibration_transmissibility", "Intermediate"),
+        (template_vibration_isolator_design, "vibration_isolator_design", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "mechanical_engineering",
+                "domain": "vibrations_and_acoustics",
+                "area": "harmonically_excited_vibrations",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

data/templates/branches/mechanical_engineering/vibrations_and_acoustics/single_degree_of_freedom_systems.py

@@ -0,0 +1,655 @@
+import random
+import math
+
+
+# Template 1 (Easy)
+def template_undamped_natural_frequency_translational():
+    """
+    Free Vibration: Undamped Natural Frequency of a Translational System
+
+    Scenario:
+        This template generates a fundamental problem on a simple spring-mass
+        system. It tests the ability to calculate the key characteristics of
+        its undamped free vibration: the natural frequency in both rad/s (omega_n)
+        and Hertz (f_n), and the natural period (tau_n).
+
+    Core Equations:
+        omega_n = sqrt(k / m)
+        f_n = omega_n / (2 * pi)
+        tau_n = 1 / f_n
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the system's natural frequencies and period.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values for high diversity
+    
+    # Mass (m): Chosen from a wide range to represent different scales,
+    # from small mechanical parts to larger objects.
+    mass = round(random.uniform(0.5, 750.0), 2)  # in kg
+
+    # Stiffness (k): Integer values representing a typical range for mechanical springs.
+    stiffness = random.randint(500, 250000)      # in N/m
+    
+    # Standardize precision for all calculations and final outputs
+    precision = 3
+
+    # 2. Perform the core calculations for the solution
+    
+    # Step A: Calculate the undamped natural frequency in radians per second
+    omega_n = math.sqrt(stiffness / mass)
+    
+    # Step B: Convert the natural frequency from rad/s to Hertz (Hz)
+    f_n = omega_n / (2 * math.pi)
+    
+    # Step C: Calculate the natural period of oscillation
+    tau_n = 1 / f_n
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"An undamped single-degree-of-freedom system consists of a mass of {mass} kg "
+        f"and a spring with a stiffness of {stiffness} N/m. "
+        f"Determine the system's undamped natural frequency in both radians per second (rad/s) and Hertz (Hz). "
+        f"Also, calculate the natural period of vibration."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Mass (m) = {mass} kg\n"
+        f"Spring Stiffness (k) = {stiffness} N/m\n\n"
+
+        f"**Step 1:** Calculate the undamped natural frequency in radians per second (omega_n).\n"
+        f"The formula is: omega_n = sqrt(k / m)\n"
+        f"omega_n = sqrt({stiffness} / {mass})\n"
+        f"omega_n = {round(omega_n, precision)} rad/s\n\n"
+
+        f"**Step 2:** Convert the natural frequency to Hertz (f_n).\n"
+        f"The formula is: f_n = omega_n / (2 * pi)\n"
+        f"f_n = {round(omega_n, precision)} / (2 * pi)\n"
+        f"f_n = {round(f_n, precision)} Hz\n\n"
+
+        f"**Step 3:** Calculate the natural period of vibration (tau_n).\n"
+        f"The period is the reciprocal of the frequency in Hz.\n"
+        f"The formula is: tau_n = 1 / f_n\n"
+        f"tau_n = 1 / {round(f_n, precision)}\n"
+        f"tau_n = {round(tau_n, precision)} s\n\n"
+
+        f"**Answer:**\n"
+        f"The undamped natural frequency is {round(omega_n, precision)} rad/s or {round(f_n, precision)} Hz.\n"
+        f"The natural period of vibration is {round(tau_n, precision)} seconds."
+    )
+
+    return question, solution
+
+
+# Template 2 (Easy)
+def template_undamped_natural_frequency_torsional():
+    """
+    Free Vibration: Undamped Natural Frequency of a Torsional System
+
+    Scenario:
+        This template generates a problem for a simple torsional system, which
+        typically consists of a disc or flywheel attached to a shaft. It is the
+        rotational equivalent of the spring-mass system. The goal is to calculate
+        the natural frequency and period of torsional oscillation.
+
+    Core Equations:
+        omega_n = sqrt(k_t / J_0)
+        f_n = omega_n / (2 * pi)
+        tau_n = 1 / f_n
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the system's torsional natural frequencies and period.
+            - str: A step-by-step solution to the problem.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Mass moment of inertia (J_0): Represents the rotational inertia of the disc.
+    # The range covers small rotors to medium-sized flywheels.
+    mass_moment_of_inertia = round(random.uniform(0.05, 25.0), 3)  # in kg-m^2
+
+    # Torsional stiffness (k_t): Represents the shaft's resistance to twisting.
+    torsional_stiffness = random.randint(200, 75000)                # in N-m/rad
+    
+    # Standardize precision for all calculations and final outputs
+    precision = 3
+
+    # 2. Perform the core calculations for the solution
+    
+    # Step A: Calculate the undamped natural frequency in radians per second
+    omega_n = math.sqrt(torsional_stiffness / mass_moment_of_inertia)
+    
+    # Step B: Convert the natural frequency from rad/s to Hertz (Hz)
+    f_n = omega_n / (2 * math.pi)
+    
+    # Step C: Calculate the natural period of oscillation
+    tau_n = 1 / f_n
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A torsional pendulum consists of a disc with a mass moment of inertia of "
+        f"{mass_moment_of_inertia} kg-m^2 attached to a shaft with a torsional stiffness of "
+        f"{torsional_stiffness} N-m/rad. The system is undamped. "
+        f"Calculate the natural frequency of torsional vibration in both rad/s and Hz, "
+        f"and determine the corresponding period."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Mass Moment of Inertia (J_0) = {mass_moment_of_inertia} kg-m^2\n"
+        f"Torsional Stiffness (k_t) = {torsional_stiffness} N-m/rad\n\n"
+
+        f"**Step 1:** Calculate the undamped natural frequency in radians per second (omega_n).\n"
+        f"The formula for a torsional system is: omega_n = sqrt(k_t / J_0)\n"
+        f"omega_n = sqrt({torsional_stiffness} / {mass_moment_of_inertia})\n"
+        f"omega_n = {round(omega_n, precision)} rad/s\n\n"
+
+        f"**Step 2:** Convert the natural frequency to Hertz (f_n).\n"
+        f"The relationship is: f_n = omega_n / (2 * pi)\n"
+        f"f_n = {round(omega_n, precision)} / (2 * pi)\n"
+        f"f_n = {round(f_n, precision)} Hz\n\n"
+
+        f"**Step 3:** Calculate the natural period of vibration (tau_n).\n"
+        f"The period is the reciprocal of the frequency in Hz.\n"
+        f"The formula is: tau_n = 1 / f_n\n"
+        f"tau_n = 1 / {round(f_n, precision)}\n"
+        f"tau_n = {round(tau_n, precision)} s\n\n"
+
+        f"**Answer:**\n"
+        f"The undamped torsional natural frequency is {round(omega_n, precision)} rad/s or {round(f_n, precision)} Hz.\n"
+        f"The natural period of vibration is {round(tau_n, precision)} seconds."
+    )
+
+    return question, solution
+
+
+# Template 3 (Intermediate)
+def template_undamped_response_initial_conditions():
+    """
+    Free Vibration: Response of an Undamped System to Initial Conditions
+
+    Scenario:
+        This template assesses the ability to determine the specific equation
+        of motion, x(t), for an undamped spring-mass system given a set of
+        initial conditions (displacement and velocity). This requires first
+        finding the natural frequency and then solving for the two constants
+        in the general solution.
+
+    Core Equations:
+        omega_n = sqrt(k / m)
+        General Solution: x(t) = A1 * cos(omega_n * t) + A2 * sin(omega_n * t)
+        From initial conditions: A1 = x(0) and A2 = v(0) / omega_n
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the equation of motion.
+            - str: A step-by-step solution deriving the equation.
+    """
+    # 1. Parameterize the inputs with random values
+    mass = round(random.uniform(1.0, 500.0), 2)       # in kg
+    stiffness = random.randint(1000, 200000)          # in N/m
+
+    # Randomize initial conditions, including cases where one might be zero.
+    # Displacement is given in mm for the question, velocity in m/s.
+    initial_disp_mm = 0
+    initial_vel_ms = 0.0
+    
+    # Use a chooser to create varied scenarios
+    # 1: Only displacement, 2: Only velocity, 3: Both are non-zero
+    scenario_choice = random.randint(1, 3)
+    if scenario_choice == 1:
+        initial_disp_mm = random.randint(-100, 100)
+        while initial_disp_mm == 0: initial_disp_mm = random.randint(-100, 100)
+    elif scenario_choice == 2:
+        initial_vel_ms = round(random.uniform(-5.0, 5.0), 2)
+        while initial_vel_ms == 0.0: initial_vel_ms = round(random.uniform(-5.0, 5.0), 2)
+    else: # scenario_choice == 3
+        initial_disp_mm = random.randint(-100, 100)
+        initial_vel_ms = round(random.uniform(-5.0, 5.0), 2)
+        while initial_disp_mm == 0: initial_disp_mm = random.randint(-100, 100)
+        while initial_vel_ms == 0.0: initial_vel_ms = round(random.uniform(-5.0, 5.0), 2)
+    
+    # Convert initial displacement from mm to meters for calculations
+    initial_disp_m = initial_disp_mm / 1000.0
+    
+    precision = 4
+
+    # 2. Perform the core calculations for the solution
+    
+    # Step A: Calculate the natural frequency
+    omega_n = math.sqrt(stiffness / mass)
+    
+    # Step B: Determine the constants A1 and A2 from initial conditions
+    A1 = initial_disp_m
+    A2 = initial_vel_ms / omega_n
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"An undamped spring-mass system has a mass of {mass} kg and a spring stiffness of {stiffness} N/m. "
+        f"The mass is given an initial displacement of {initial_disp_mm} mm and an initial velocity of {initial_vel_ms} m/s. "
+        f"Determine the equation of motion, x(t), for the system."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Mass (m) = {mass} kg\n"
+        f"Stiffness (k) = {stiffness} N/m\n"
+        f"Initial Displacement (x(0)) = {initial_disp_mm} mm = {initial_disp_m} m\n"
+        f"Initial Velocity (v(0)) = {initial_vel_ms} m/s\n\n"
+
+        f"**Step 1:** Calculate the undamped natural frequency (omega_n).\n"
+        f"omega_n = sqrt(k / m) = sqrt({stiffness} / {mass}) = {round(omega_n, precision)} rad/s\n\n"
+
+        f"**Step 2:** State the general form of the solution for an undamped system.\n"
+        f"The general solution is: x(t) = A1 * cos(omega_n * t) + A2 * sin(omega_n * t)\n\n"
+
+        f"**Step 3:** Apply the initial conditions to find the constants A1 and A2.\n"
+        f"First, apply the initial displacement at t=0:\n"
+        f"x(0) = A1 * cos(0) + A2 * sin(0) = A1\n"
+        f"Therefore, A1 = x(0) = {initial_disp_m} m\n\n"
+        
+        f"Next, find the derivative of x(t) to get the velocity, v(t):\n"
+        f"v(t) = dx/dt = -A1 * omega_n * sin(omega_n * t) + A2 * omega_n * cos(omega_n * t)\n"
+        f"Now apply the initial velocity at t=0:\n"
+        f"v(0) = -A1 * omega_n * sin(0) + A2 * omega_n * cos(0) = A2 * omega_n\n"
+        f"Therefore, A2 = v(0) / omega_n = {initial_vel_ms} / {round(omega_n, precision)} = {round(A2, precision)} m\n\n"
+
+        f"**Step 4:** Substitute the constants and omega_n into the general solution.\n"
+        f"x(t) = {round(A1, precision)} * cos({round(omega_n, precision)} * t) + ({round(A2, precision)}) * sin({round(omega_n, precision)} * t)\n\n"
+    )
+
+    # Clean up the final equation for better readability
+    cos_term = ""
+    if abs(A1) > 1e-9: # Use a small tolerance to handle floating point inaccuracies
+        cos_term = f"{round(A1, precision)}*cos({round(omega_n, precision)}*t)"
+
+    sin_term = ""
+    if abs(A2) > 1e-9:
+        sign = "-" if A2 < 0 else "+"
+        # If the cos_term is empty, don't start with a plus sign
+        if not cos_term and A2 > 0:
+            sign = ""
+        
+        sin_term = f" {sign} {abs(round(A2, precision))}*sin({round(omega_n, precision)}*t)"
+        # Remove leading space if it's the first term
+        if not cos_term:
+            sin_term = sin_term.lstrip()
+            
+    final_equation = cos_term + sin_term
+    if not final_equation: final_equation = "0"
+    
+    solution += (
+        f"**Answer:**\n"
+        f"The final equation of motion is:\n"
+        f"x(t) = {final_equation} (m)"
+    )
+
+    return question, solution
+
+
+# Template 4 (Intermediate)
+def template_damping_classification():
+    """
+    Free Vibration: Damping Parameters and System Classification
+
+    Scenario:
+        This template introduces viscous damping and requires the calculation of
+        key damping parameters. Given a system's physical properties (mass,
+        stiffness, damping coefficient), the goal is to determine the damping
+        ratio (zeta), classify the system's behavior (underdamped, critically
+        damped, or overdamped), and calculate the damped natural frequency
+        (omega_d) if the system is underdamped.
+
+    Core Equations:
+        omega_n = sqrt(k / m)
+        c_c = 2 * sqrt(k * m)
+        zeta = c / c_c
+        omega_d = omega_n * sqrt(1 - zeta^2)  (for zeta < 1)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for system classification and key parameters.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs to ensure all cases are generated
+    mass = round(random.uniform(2.0, 600.0), 2)       # in kg
+    stiffness = random.randint(2000, 300000)          # in N/m
+
+    # To ensure a good distribution of outcomes, we first select a damping ratio
+    # and then calculate the corresponding damping coefficient 'c'.
+    
+    # Choose a scenario: 1 for underdamped, 2 for critically damped, 3 for overdamped
+    scenario_choice = random.randint(1, 3)
+
+    if scenario_choice == 1: # Underdamped
+        zeta = round(random.uniform(0.15, 0.85), 3)
+    elif scenario_choice == 2: # Critically Damped
+        zeta = 1.0
+    else: # Overdamped
+        zeta = round(random.uniform(1.2, 2.5), 3)
+
+    # Standardize precision for final outputs
+    precision = 4
+
+    # 2. Perform the core calculations for the solution
+    
+    # Step A: Calculate the critical damping coefficient (c_c)
+    critical_damping_c = 2 * math.sqrt(stiffness * mass)
+    
+    # Step B: Calculate the actual damping coefficient (c) based on the desired zeta
+    damping_coefficient_c = zeta * critical_damping_c
+    
+    # Step C: Determine the system classification based on zeta
+    if zeta < 1:
+        classification = "Underdamped"
+        # Also calculate natural and damped frequencies for the solution
+        omega_n = math.sqrt(stiffness / mass)
+        omega_d = omega_n * math.sqrt(1 - zeta**2)
+    elif zeta == 1:
+        classification = "Critically Damped"
+    else:
+        classification = "Overdamped"
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A damped single-degree-of-freedom system has a mass of {mass} kg, "
+        f"a spring stiffness of {stiffness} N/m, and a viscous damping coefficient of "
+        f"{round(damping_coefficient_c, 2)} N-s/m. "
+        f"Calculate the damping ratio (zeta) and classify the system as underdamped, "
+        f"critically damped, or overdamped. If the system is underdamped, also "
+        f"calculate its damped natural frequency (omega_d)."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Mass (m) = {mass} kg\n"
+        f"Stiffness (k) = {stiffness} N/m\n"
+        f"Damping Coefficient (c) = {round(damping_coefficient_c, 2)} N-s/m\n\n"
+
+        f"**Step 1:** Calculate the critical damping coefficient (c_c).\n"
+        f"The formula is: c_c = 2 * sqrt(k * m)\n"
+        f"c_c = 2 * sqrt({stiffness} * {mass})\n"
+        f"c_c = {round(critical_damping_c, precision)} N-s/m\n\n"
+
+        f"**Step 2:** Calculate the damping ratio (zeta).\n"
+        f"The formula is: zeta = c / c_c\n"
+        f"zeta = {round(damping_coefficient_c, 2)} / {round(critical_damping_c, precision)}\n"
+        f"zeta = {round(zeta, precision)}\n\n"
+
+        f"**Step 3:** Classify the system based on the value of zeta.\n"
+        f"Since zeta {'>' if zeta > 1 else '<' if zeta < 1 else '='} 1, the system is **{classification}**.\n\n"
+    )
+
+    # Add the final step only if the system is underdamped
+    if classification == "Underdamped":
+        solution += (
+            f"**Step 4:** Since the system is underdamped, calculate the damped natural frequency (omega_d).\n"
+            f"First, find the undamped natural frequency (omega_n):\n"
+            f"omega_n = sqrt(k / m) = sqrt({stiffness} / {mass}) = {round(omega_n, precision)} rad/s\n\n"
+            f"Now, use the formula: omega_d = omega_n * sqrt(1 - zeta^2)\n"
+            f"omega_d = {round(omega_n, precision)} * sqrt(1 - {round(zeta, precision)}^2)\n"
+            f"omega_d = {round(omega_d, precision)} rad/s\n\n"
+            
+            f"**Answer:**\n"
+            f"The damping ratio is {round(zeta, precision)}. The system is **{classification}**.\n"
+            f"The damped natural frequency is {round(omega_d, precision)} rad/s."
+        )
+    else:
+        solution += (
+            f"**Answer:**\n"
+            f"The damping ratio is {round(zeta, precision)}. The system is **{classification}**."
+        )
+
+    return question, solution
+
+
+# Template 5 (Intermediate)
+def template_logarithmic_decrement():
+    """
+    Free Vibration: Logarithmic Decrement and Damping Ratio
+
+    Scenario:
+        This template models a practical method for determining the damping in
+        an underdamped system. By observing the amplitude of vibration at two
+        distinct points in time, separated by a known number of cycles, one can
+        calculate the logarithmic decrement, which directly relates to the system's
+        damping ratio.
+
+    Core Equations:
+        delta = (1/n) * ln(x1 / x_{n+1})
+        zeta = delta / sqrt((2*pi)^2 + delta^2)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the logarithmic decrement and damping ratio.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    
+    # Initialize variables to enter the loop
+    final_amplitude_x_n_plus_1 = 0.0
+    
+    # Use a loop to ensure the final rounded amplitude is never zero.
+    # This prevents a division-by-zero error in cases of high decay.
+    while final_amplitude_x_n_plus_1 <= 0.0:
+        # To ensure physically consistent values, we first generate a realistic
+        # damping ratio (zeta) and work backward to find the amplitudes.
+        zeta_actual = random.uniform(0.05, 0.25)
+        
+        # Calculate the corresponding logarithmic decrement
+        delta_actual = (2 * math.pi * zeta_actual) / math.sqrt(1 - zeta_actual**2)
+        
+        # Choose a number of cycles for the measurement
+        num_cycles_n = random.randint(2, 8) # Reduced max cycles to lower chance of zeroing out
+        
+        # Set a random initial amplitude in mm
+        initial_amplitude_x1 = round(random.uniform(20.0, 100.0), 1)
+        
+        # Calculate the final amplitude based on the decrement and number of cycles
+        calculated_final_amplitude = initial_amplitude_x1 / math.exp(num_cycles_n * delta_actual)
+        
+        # Round the final amplitude to make it look like a measured value
+        final_amplitude_x_n_plus_1 = round(calculated_final_amplitude, 1)
+
+    # Standardize precision for final outputs in the solution
+    precision = 4
+
+    # 2. Perform the core calculations for the solution (as the user would)
+    
+    # Step A: Calculate the logarithmic decrement from the given amplitudes
+    log_decrement_delta = (1 / num_cycles_n) * math.log(initial_amplitude_x1 / final_amplitude_x_n_plus_1)
+    
+    # Step B: Calculate the damping ratio from the decrement
+    damping_ratio_zeta = log_decrement_delta / math.sqrt((2 * math.pi)**2 + log_decrement_delta**2)
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"The amplitude of free vibration of an underdamped system is observed to decay over time. "
+        f"The initial amplitude is measured to be {initial_amplitude_x1} mm. After {num_cycles_n} complete cycles, "
+        f"the amplitude is measured to be {final_amplitude_x_n_plus_1} mm. "
+        f"Based on these observations, calculate the logarithmic decrement (delta) and the damping ratio (zeta) of the system."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Initial Amplitude (x1) = {initial_amplitude_x1} mm\n"
+        f"Amplitude after {num_cycles_n} cycles (x{num_cycles_n + 1}) = {final_amplitude_x_n_plus_1} mm\n"
+        f"Number of cycles (n) = {num_cycles_n}\n\n"
+
+        f"**Step 1:** Calculate the logarithmic decrement (delta).\n"
+        f"The formula is: delta = (1/n) * ln(x1 / x_{num_cycles_n + 1})\n"
+        f"delta = (1 / {num_cycles_n}) * ln({initial_amplitude_x1} / {final_amplitude_x_n_plus_1})\n"
+        f"delta = (1 / {num_cycles_n}) * ln({round(initial_amplitude_x1 / final_amplitude_x_n_plus_1, precision)})\n"
+        f"delta = {round(log_decrement_delta, precision)}\n\n"
+
+        f"**Step 2:** Calculate the damping ratio (zeta) from the logarithmic decrement.\n"
+        f"The formula relating zeta and delta is: zeta = delta / sqrt((2*pi)^2 + delta^2)\n"
+        f"zeta = {round(log_decrement_delta, precision)} / sqrt((2*pi)^2 + {round(log_decrement_delta, precision)}^2)\n"
+        f"zeta = {round(damping_ratio_zeta, precision)}\n\n"
+
+        f"**Answer:**\n"
+        f"The logarithmic decrement is {round(log_decrement_delta, precision)}.\n"
+        f"The damping ratio of the system is {round(damping_ratio_zeta, precision)}."
+    )
+
+    return question, solution
+
+
+# Template 6 (Advanced)
+def template_equivalent_stiffness_frequency():
+    """
+    Free Vibration: Equivalent Stiffness and Natural Frequency
+
+    Scenario:
+        This template addresses systems with multiple springs. It requires first
+        simplifying a spring network (either in series or parallel) into a single
+        equivalent spring. After finding the equivalent stiffness (k_eq), the
+        natural frequency of the overall system is calculated. This adds a
+        critical modeling step to the standard frequency calculation.
+
+    Core Equations:
+        Parallel Stiffness: k_eq = k1 + k2
+        Series Stiffness: k_eq = (k1 * k2) / (k1 + k2)
+        Natural Frequency: omega_n = sqrt(k_eq / m)
+
+    Returns:
+        tuple: A tuple containing:
+            - str: A question asking for the equivalent stiffness and natural frequency.
+            - str: A step-by-step solution.
+    """
+    # 1. Parameterize the inputs with random values
+    mass = round(random.uniform(5.0, 100.0), 2)       # in kg
+    stiffness_1 = random.randint(1000, 50000)         # in N/m
+    stiffness_2 = random.randint(1000, 50000)         # in N/m
+    
+    # Randomly choose the spring configuration
+    configuration = random.choice(['series', 'parallel'])
+    
+    # Standardize precision for final outputs
+    precision = 3
+
+    # 2. Perform the core calculations for the solution
+    
+    # Step A: Calculate the equivalent stiffness (k_eq) based on the configuration
+    if configuration == 'parallel':
+        k_eq = stiffness_1 + stiffness_2
+        formula_str = "k_eq = k1 + k2"
+        calculation_str = f"k_eq = {stiffness_1} + {stiffness_2} = {k_eq} N/m"
+    else: # configuration == 'series'
+        k_eq = (stiffness_1 * stiffness_2) / (stiffness_1 + stiffness_2)
+        formula_str = "k_eq = (k1 * k2) / (k1 + k2)"
+        calculation_str = (
+            f"k_eq = ({stiffness_1} * {stiffness_2}) / ({stiffness_1} + {stiffness_2}) = "
+            f"{round(k_eq, 2)} N/m"
+        )
+        
+    # Step B: Calculate the natural frequency using the equivalent stiffness
+    omega_n = math.sqrt(k_eq / mass)
+
+    # 3. Generate the question and solution strings
+    
+    question = (
+        f"A mass of {mass} kg is attached to a system of two springs. The first spring has a "
+        f"stiffness (k1) of {stiffness_1} N/m, and the second spring has a stiffness (k2) of {stiffness_2} N/m. "
+        f"The two springs are arranged in {configuration}. "
+        f"Determine the equivalent stiffness of the spring system and the resulting undamped "
+        f"natural frequency (omega_n) in rad/s."
+    )
+
+    solution = (
+        f"**Given:**\n"
+        f"Mass (m) = {mass} kg\n"
+        f"Stiffness 1 (k1) = {stiffness_1} N/m\n"
+        f"Stiffness 2 (k2) = {stiffness_2} N/m\n"
+        f"Configuration = {configuration.capitalize()}\n\n"
+
+        f"**Step 1:** Calculate the equivalent stiffness (k_eq) for the {configuration} configuration.\n"
+        f"The formula for springs in {configuration} is: {formula_str}\n"
+        f"{calculation_str}\n\n"
+
+        f"**Step 2:** Calculate the undamped natural frequency (omega_n) using the equivalent stiffness.\n"
+        f"The formula is: omega_n = sqrt(k_eq / m)\n"
+        f"omega_n = sqrt({round(k_eq, 2)} / {mass})\n"
+        f"omega_n = {round(omega_n, precision)} rad/s\n\n"
+
+        f"**Answer:**\n"
+        f"The equivalent stiffness of the system is {round(k_eq, 2)} N/m.\n"
+        f"The undamped natural frequency is {round(omega_n, precision)} rad/s."
+    )
+
+    return question, solution
+
+
+def main():
+    """
+    Generate numerous instances of each free vibration of single-degree-of-freedom systems 
+    template with different random seeds and write the results to a JSONL file.
+    """
+    import json
+    import os
+
+    # Define the output path (Modify this path according to where you are running the code from)
+    output_file = "testset/mechanical_engineering/vibrations_and_acoustics/single_degree_of_freedom_systems.jsonl"
+
+    # Create the directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    # List of template functions with their ID and level
+    templates = [
+        (template_undamped_natural_frequency_translational, "undamped_natural_frequency_translational", "Easy"),
+        (template_undamped_natural_frequency_torsional, "undamped_natural_frequency_torsional", "Easy"),
+        (template_undamped_response_initial_conditions, "undamped_response_initial_conditions", "Intermediate"),
+        (template_damping_classification, "damping_classification", "Intermediate"),
+        (template_logarithmic_decrement, "logarithmic_decrement", "Intermediate"),
+        (template_equivalent_stiffness_frequency, "equivalent_stiffness_frequency", "Advanced"),
+    ]
+
+    # List to store all generated problems
+    all_problems = []
+
+    # Generate problems for each template
+    for template_func, id_name, level in templates:
+        for _ in range(50):
+            # Generate a unique seed for each problem
+            seed = random.randint(1_000_000_000, 4_000_000_000)
+            random.seed(seed)
+
+            # Generate the problem and solution
+            question, solution = template_func()
+
+            # Create a JSON entry
+            problem_entry = {
+                "seed": seed,
+                "branch": "mechanical_engineering",
+                "domain": "vibrations_and_acoustics",
+                "area": "single_degree_of_freedom_systems",
+                "id": id_name,
+                "level": level,
+                "question": question,
+                "solution": solution
+            }
+
+            # Add to the list of problems
+            all_problems.append(problem_entry)
+
+    # Shuffle the problems to mix templates and levels
+    random.shuffle(all_problems)
+
+    # Write all problems to a .jsonl file
+    with open(output_file, "w") as file:
+        for problem in all_problems:
+            file.write(json.dumps(problem))
+            file.write("\n")
+
+    print(f"Successfully generated {len(all_problems)} problems and saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,4 @@
+streamlit>=1.30.0
+pandas
+numpy
+scipy

src/storage.py

@@ -0,0 +1,46 @@
+# src/storage.py
+import json
+from datetime import datetime
+from pathlib import Path
+
+def _get_review_dir() -> Path:
+    """
+    If Hugging Face Persistent Storage is enabled, it is mounted at /data.
+    Otherwise fall back to repo-local ./reviews (ephemeral on Spaces).
+    """
+    persistent_root = Path("/data")
+    if persistent_root.exists() and persistent_root.is_dir():
+        return persistent_root / "reviews"
+    return Path(__file__).parent.parent / "reviews"
+
+REVIEW_DIR = _get_review_dir()
+REVIEW_DIR.mkdir(parents=True, exist_ok=True)
+
+def save_review(annotator_name, branch, area, template_name, scores, decision, feedback):
+    """
+    Appends a single review to an annotator-specific JSONL file.
+    """
+    safe_name = "".join([c for c in annotator_name if c.isalnum() or c in (" ", "_")]).strip().replace(" ", "_")
+    safe_branch = branch.replace(" ", "_")
+
+    filename = REVIEW_DIR / f"{safe_name}_{safe_branch}.jsonl"
+
+    review_data = {
+        "timestamp": datetime.now().isoformat(),
+        "annotator_id": annotator_name,
+        "branch": branch,
+        "area": area,
+        "template": template_name,
+        "scores": {
+            "physical_plausibility": scores[0],
+            "mathematical_correctness": scores[1],
+            "pedagogical_clarity": scores[2],
+        },
+        "decision": decision,
+        "feedback": feedback,
+    }
+
+    with open(filename, "a", encoding="utf-8") as f:
+        f.write(json.dumps(review_data) + "\n")
+
+    return str(filename)

src/template_loader.py

@@ -0,0 +1,69 @@
+import sys
+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"
+
+def get_branches():
+    """Returns a list of available engineering branches."""
+    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 []
+    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)
+
+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}")
+
+    # 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
+
+    # 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()

test_loader.py

@@ -0,0 +1,78 @@
+import sys
+import traceback
+from src.template_loader import (
+    get_branches, 
+    get_areas, 
+    get_template_files, 
+    load_template_functions
+)
+
+def main():
+    print("--- Starting Template Loader Test (V2) ---")
+
+    # 1. Test Branches
+    branches = get_branches()
+    print(f"\nBranches Found: {branches}")
+    
+    if not branches:
+        print("No branches found. Check your directory structure.")
+        return
+
+    # 2. Test Areas (using the first branch found, likely 'chemical_engineering')
+    test_branch = "chemical_engineering" 
+    if test_branch not in branches:
+        test_branch = branches[0]
+        
+    areas = get_areas(test_branch)
+    print(f"Areas in '{test_branch}': {areas}")
+
+    if not areas:
+        print(f"No areas found in {test_branch}.")
+        return
+
+    # 3. Test Files (using 'reaction_kinetics' if available)
+    test_area = "reaction_kinetics"
+    if test_area not in areas:
+        test_area = areas[0]
+
+    files = get_template_files(test_branch, test_area)
+    print(f"Files in '{test_branch}/{test_area}': {files}")
+    
+    # We specifically want to test 'mole_balances' if it exists
+    target_file = "mole_balances"
+    if target_file not in files:
+        print(f"WARNING: 'mole_balances.py' not found. Using first available file: {files[0]}")
+        target_file = files[0]
+
+    # 4. Test Function Extraction (The Logic Upgrade)
+    print(f"\nInspecting file: '{target_file}.py'...")
+    try:
+        # This loads the file and finds all def template_...():
+        templates = load_template_functions(test_branch, test_area, target_file)
+        
+        if not templates:
+            print("No functions starting with 'template_' found in this file.")
+            return
+            
+        print(f"Found {len(templates)} template functions:")
+        for name, func in templates:
+            print(f"   - {name}")
+
+        # 5. Test Execution (Run the first function found)
+        first_func_name, first_func_obj = templates[0]
+        print(f"\nExecuting '{first_func_name}'...")
+        
+        question, solution = first_func_obj()
+        
+        print("\n--- [Output Preview] ---")
+        print(f"Question: {question[:100]}...") # Print first 100 chars
+        print(f"Solution: {solution[:100]}...")
+        print("------------------------")
+        print("SUCCESS: Template loaded and executed correctly.")
+
+    except Exception as e:
+        print(f"CRITICAL ERROR during loading/execution:")
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()