Upload 4 files

app.py

@@ -0,0 +1,234 @@
+import gradio as gr
+import pandas as pd
+from continuous_beam import ContinuousBeam
+import matplotlib.pyplot as plt
+import numpy as np
+import io
+import base64
+
+class GradioBeamApp:
+    def __init__(self):
+        self.beam = ContinuousBeam()
+        self.spans_data = []
+    
+    def parse_point_loads(self, point_loads_text):
+        """Parse point loads from text input"""
+        if not point_loads_text or point_loads_text.strip() == "":
+            return []
+        
+        point_loads = []
+        try:
+            # Expected format: "position1,load1; position2,load2; ..."
+            # Example: "2.0,50; 4.0,30"
+            load_pairs = point_loads_text.split(';')
+            for pair in load_pairs:
+                if pair.strip():
+                    pos_str, load_str = pair.split(',')
+                    position = float(pos_str.strip())
+                    load = float(load_str.strip())
+                    point_loads.append((position, load))
+        except:
+            raise ValueError("Invalid point load format. Use: position1,load1; position2,load2")
+        
+        return point_loads
+    
+    def add_span(self, length, distributed_load, point_loads_text, spans_display):
+        """Add a span to the beam"""
+        try:
+            length = float(length)
+            distributed_load = float(distributed_load)
+            
+            if length <= 0 or distributed_load < 0:
+                return spans_display, "Error: Please enter valid values (length > 0, distributed_load >= 0)"
+            
+            # Parse point loads
+            point_loads = self.parse_point_loads(point_loads_text)
+            
+            # Validate point load positions
+            for pos, load in point_loads:
+                if pos < 0 or pos > length:
+                    return spans_display, f"Error: Point load at {pos}m is outside span length {length}m"
+                if load < 0:
+                    return spans_display, f"Error: Point load {load}kN must be positive"
+            
+            self.beam.add_span(length, distributed_load, point_loads)
+            
+            # Create span description
+            span_info = f"Span {len(self.beam.spans)}: L={length}m, w={distributed_load}kN/m"
+            if point_loads:
+                point_load_str = ", ".join([f"P={load}kN@{pos}m" for pos, load in point_loads])
+                span_info += f", {point_load_str}"
+            
+            self.spans_data.append(span_info)
+            
+            # Update display
+            updated_display = "\n".join(self.spans_data)
+            return updated_display, f"Added: {span_info}"
+            
+        except ValueError as e:
+            return spans_display, f"Error: {str(e)}"
+    
+    def clear_spans(self):
+        """Clear all spans"""
+        self.beam = ContinuousBeam()
+        self.spans_data = []
+        return "", "All spans cleared"
+    
+    def design_beam(self, width, depth, fc, fy, cover, spans_display):
+        """Design the beam and return results"""
+        if not self.beam.spans:
+            return "No spans added. Please add at least one span.", None, None, None, None, None
+        
+        try:
+            # Update beam properties
+            self.beam.beam_width = float(width)
+            self.beam.beam_depth = float(depth)
+            self.beam.fc = float(fc)
+            self.beam.fy = float(fy)
+            self.beam.cover = float(cover)
+            self.beam.d = self.beam.beam_depth - self.beam.cover
+            
+            # Perform design
+            design_results = self.beam.design_beam()
+            
+            # Generate report
+            report = self.beam.generate_report(design_results)
+            
+            # Create summary table
+            summary_data = []
+            for span_data in design_results:
+                span_num = span_data['span']
+                for i, (reinf, stirrup) in enumerate(zip(span_data['reinforcement'], span_data['stirrups'])):
+                    if reinf['moment'] != 0 or stirrup['shear'] != 0:
+                        summary_data.append([
+                            span_num if i == 0 else '',
+                            reinf['location'],
+                            f"{reinf['moment']:.2f}" if reinf['moment'] != 0 else '-',
+                            reinf['bars'] if reinf['moment'] != 0 else '-',
+                            f"{stirrup['shear']:.2f}" if stirrup['shear'] != 0 else '-',
+                            stirrup['stirrup_spacing'] if stirrup['shear'] != 0 else '-'
+                        ])
+            
+            # Create DataFrame for table display
+            df = pd.DataFrame(summary_data, columns=[
+                'Span', 'Location', 'Moment (kN-m)', 'Reinforcement', 'Shear (kN)', 'Stirrups'
+            ])
+            
+            # Generate plots
+            bmd_sfd_plot = self.beam.plot_bmd_sfd(design_results)
+            reinforcement_plot = self.beam.plot_reinforcement_layout(design_results)
+            stirrup_plot = self.beam.plot_stirrup_layout(design_results)
+            
+            return report, df, bmd_sfd_plot, reinforcement_plot, stirrup_plot, "Design completed successfully!"
+            
+        except Exception as e:
+            return f"Design calculation failed: {str(e)}", None, None, None, None, f"Error: {str(e)}"
+
+def create_interface():
+    app = GradioBeamApp()
+    
+    with gr.Blocks(title="Continuous Beam RC Design - ACI Code", theme=gr.themes.Default()) as interface:
+        
+        gr.Markdown("# Continuous Beam RC Design - ACI Code")
+        gr.Markdown("*Using Finite Element Analysis for accurate structural behavior*")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("## Beam Properties")
+                
+                with gr.Row():
+                    width_input = gr.Number(label="Beam Width (mm)", value=300)
+                    depth_input = gr.Number(label="Beam Depth (mm)", value=500)
+                
+                with gr.Row():
+                    fc_input = gr.Number(label="f'c (MPa)", value=28)
+                    fy_input = gr.Number(label="fy (MPa)", value=420)
+                
+                cover_input = gr.Number(label="Cover (mm)", value=40)
+                
+                gr.Markdown("## Spans Configuration")
+                
+                with gr.Row():
+                    span_length_input = gr.Number(label="Span Length (m)", value=6.0)
+                    distributed_load_input = gr.Number(label="Distributed Load (kN/m)", value=25.0)
+                
+                point_loads_input = gr.Textbox(
+                    label="Point Loads (position,load; position,load; ...)", 
+                    placeholder="Example: 2.0,50; 4.0,30 (means 50kN at 2m and 30kN at 4m)",
+                    value=""
+                )
+                
+                with gr.Row():
+                    add_span_btn = gr.Button("Add Span", variant="primary")
+                    clear_spans_btn = gr.Button("Clear All", variant="secondary")
+                
+                spans_display = gr.Textbox(
+                    label="Added Spans", 
+                    lines=5, 
+                    interactive=False,
+                    placeholder="No spans added yet..."
+                )
+                
+                design_btn = gr.Button("Design Beam", variant="primary", size="lg")
+                
+                status_output = gr.Textbox(label="Status", interactive=False)
+            
+            with gr.Column(scale=2):
+                gr.Markdown("## Design Results")
+                
+                with gr.Tabs():
+                    with gr.TabItem("Summary"):
+                        summary_table = gr.Dataframe(
+                            label="Design Summary",
+                            headers=["Span", "Location", "Moment (kN-m)", "Reinforcement", "Shear (kN)", "Stirrups"],
+                            interactive=False
+                        )
+                    
+                    with gr.TabItem("BMD & SFD"):
+                        bmd_sfd_plot = gr.Plot(label="Bending Moment and Shear Force Diagrams")
+                    
+                    with gr.TabItem("Reinforcement Layout"):
+                        reinforcement_plot = gr.Plot(label="Reinforcement Bar Layout")
+                    
+                    with gr.TabItem("Stirrup Layout"):
+                        stirrup_plot = gr.Plot(label="Shear Stirrup Layout")
+                    
+                    with gr.TabItem("Detailed Report"):
+                        results_output = gr.Textbox(
+                            label="Detailed Design Report", 
+                            lines=20, 
+                            interactive=False,
+                            show_copy_button=True
+                        )
+        
+        # Event handlers
+        add_span_btn.click(
+            fn=lambda length, dist_load, point_loads, spans: app.add_span(length, dist_load, point_loads, spans),
+            inputs=[span_length_input, distributed_load_input, point_loads_input, spans_display],
+            outputs=[spans_display, status_output]
+        )
+        
+        clear_spans_btn.click(
+            fn=lambda: app.clear_spans(),
+            outputs=[spans_display, status_output]
+        )
+        
+        design_btn.click(
+            fn=lambda w, d, fc, fy, c, spans: app.design_beam(w, d, fc, fy, c, spans),
+            inputs=[width_input, depth_input, fc_input, fy_input, cover_input, spans_display],
+            outputs=[results_output, summary_table, bmd_sfd_plot, reinforcement_plot, stirrup_plot, status_output]
+        )
+    
+    return interface
+
+def main():
+    interface = create_interface()
+    interface.launch(
+        server_name="0.0.0.0",  # Allow external access
+        server_port=8000,       # Default Gradio port
+        share=False,            # Set to True if you want a public link
+        debug=True
+    )
+
+if __name__ == "__main__":
+    main()

beam_design_app.py

@@ -0,0 +1,202 @@
+import tkinter as tk
+from tkinter import ttk, messagebox, scrolledtext
+from continuous_beam import ContinuousBeam
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+import numpy as np
+
+class BeamDesignApp:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("Continuous Beam RC Design - ACI Code")
+        self.root.geometry("1200x800")
+        
+        self.beam = ContinuousBeam()
+        self.setup_ui()
+        
+    def setup_ui(self):
+        # Create main frame
+        main_frame = ttk.Frame(self.root, padding="10")
+        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
+        
+        # Configure grid weights
+        self.root.columnconfigure(0, weight=1)
+        self.root.rowconfigure(0, weight=1)
+        main_frame.columnconfigure(1, weight=1)
+        main_frame.rowconfigure(3, weight=1)
+        
+        # Title
+        title_label = ttk.Label(main_frame, text="Continuous Beam RC Design", 
+                               font=('Arial', 16, 'bold'))
+        title_label.grid(row=0, column=0, columnspan=2, pady=(0, 20))
+        
+        # Input frame
+        input_frame = ttk.LabelFrame(main_frame, text="Beam Properties", padding="10")
+        input_frame.grid(row=1, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
+        
+        # Beam properties
+        ttk.Label(input_frame, text="Beam Width (mm):").grid(row=0, column=0, sticky=tk.W)
+        self.width_var = tk.StringVar(value="300")
+        ttk.Entry(input_frame, textvariable=self.width_var, width=10).grid(row=0, column=1, sticky=tk.W, padx=(5, 20))
+        
+        ttk.Label(input_frame, text="Beam Depth (mm):").grid(row=0, column=2, sticky=tk.W)
+        self.depth_var = tk.StringVar(value="500")
+        ttk.Entry(input_frame, textvariable=self.depth_var, width=10).grid(row=0, column=3, sticky=tk.W, padx=(5, 20))
+        
+        ttk.Label(input_frame, text="f'c (MPa):").grid(row=1, column=0, sticky=tk.W)
+        self.fc_var = tk.StringVar(value="28")
+        ttk.Entry(input_frame, textvariable=self.fc_var, width=10).grid(row=1, column=1, sticky=tk.W, padx=(5, 20))
+        
+        ttk.Label(input_frame, text="fy (MPa):").grid(row=1, column=2, sticky=tk.W)
+        self.fy_var = tk.StringVar(value="420")
+        ttk.Entry(input_frame, textvariable=self.fy_var, width=10).grid(row=1, column=3, sticky=tk.W, padx=(5, 20))
+        
+        ttk.Label(input_frame, text="Cover (mm):").grid(row=2, column=0, sticky=tk.W)
+        self.cover_var = tk.StringVar(value="40")
+        ttk.Entry(input_frame, textvariable=self.cover_var, width=10).grid(row=2, column=1, sticky=tk.W, padx=(5, 20))
+        
+        # Spans frame
+        spans_frame = ttk.LabelFrame(main_frame, text="Spans Configuration", padding="10")
+        spans_frame.grid(row=2, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
+        
+        # Span input
+        ttk.Label(spans_frame, text="Span Length (m):").grid(row=0, column=0, sticky=tk.W)
+        self.span_length_var = tk.StringVar(value="6.0")
+        ttk.Entry(spans_frame, textvariable=self.span_length_var, width=10).grid(row=0, column=1, sticky=tk.W, padx=(5, 20))
+        
+        ttk.Label(spans_frame, text="Distributed Load (kN/m):").grid(row=0, column=2, sticky=tk.W)
+        self.load_var = tk.StringVar(value="25.0")
+        ttk.Entry(spans_frame, textvariable=self.load_var, width=10).grid(row=0, column=3, sticky=tk.W, padx=(5, 20))
+        
+        # Buttons
+        button_frame = ttk.Frame(spans_frame)
+        button_frame.grid(row=1, column=0, columnspan=4, pady=10)
+        
+        ttk.Button(button_frame, text="Add Span", command=self.add_span).pack(side=tk.LEFT, padx=(0, 10))
+        ttk.Button(button_frame, text="Clear All", command=self.clear_spans).pack(side=tk.LEFT, padx=(0, 10))
+        ttk.Button(button_frame, text="Design Beam", command=self.design_beam).pack(side=tk.LEFT, padx=(0, 10))
+        
+        # Spans list
+        self.spans_listbox = tk.Listbox(spans_frame, height=4)
+        self.spans_listbox.grid(row=2, column=0, columnspan=4, sticky=(tk.W, tk.E), pady=(10, 0))
+        spans_frame.columnconfigure(0, weight=1)
+        spans_frame.columnconfigure(1, weight=1)
+        spans_frame.columnconfigure(2, weight=1)
+        spans_frame.columnconfigure(3, weight=1)
+        
+        # Results frame
+        results_frame = ttk.LabelFrame(main_frame, text="Design Results", padding="10")
+        results_frame.grid(row=3, column=0, columnspan=2, sticky=(tk.W, tk.E, tk.N, tk.S))
+        results_frame.columnconfigure(0, weight=1)
+        results_frame.rowconfigure(0, weight=1)
+        
+        # Results text area
+        self.results_text = scrolledtext.ScrolledText(results_frame, width=80, height=20, font=('Courier', 9))
+        self.results_text.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
+        
+    def add_span(self):
+        try:
+            length = float(self.span_length_var.get())
+            load = float(self.load_var.get())
+            
+            if length <= 0 or load < 0:
+                messagebox.showerror("Error", "Please enter valid values (length > 0, load >= 0)")
+                return
+            
+            self.beam.add_span(length, load)
+            
+            # Update spans list
+            span_text = f"Span {len(self.beam.spans)}: L={length}m, w={load}kN/m"
+            self.spans_listbox.insert(tk.END, span_text)
+            
+            # Clear input fields
+            self.span_length_var.set("")
+            self.load_var.set("")
+            
+        except ValueError:
+            messagebox.showerror("Error", "Please enter valid numeric values")
+    
+    def clear_spans(self):
+        self.beam = ContinuousBeam()
+        self.spans_listbox.delete(0, tk.END)
+        self.results_text.delete('1.0', tk.END)
+    
+    def design_beam(self):
+        if not self.beam.spans:
+            messagebox.showwarning("Warning", "Please add at least one span")
+            return
+        
+        try:
+            # Update beam properties
+            self.beam.beam_width = float(self.width_var.get())
+            self.beam.beam_depth = float(self.depth_var.get())
+            self.beam.fc = float(self.fc_var.get())
+            self.beam.fy = float(self.fy_var.get())
+            self.beam.cover = float(self.cover_var.get())
+            self.beam.d = self.beam.beam_depth - self.beam.cover
+            
+            # Perform design
+            design_results = self.beam.design_beam()
+            
+            # Generate and display report
+            report = self.beam.generate_report(design_results)
+            
+            self.results_text.delete('1.0', tk.END)
+            self.results_text.insert('1.0', report)
+            
+            # Show summary dialog
+            self.show_summary(design_results)
+            
+        except Exception as e:
+            messagebox.showerror("Error", f"Design calculation failed: {str(e)}")
+    
+    def show_summary(self, design_results):
+        """Show design summary in a popup window"""
+        summary_window = tk.Toplevel(self.root)
+        summary_window.title("Design Summary")
+        summary_window.geometry("600x400")
+        
+        # Create treeview for summary
+        tree = ttk.Treeview(summary_window, columns=('Span', 'Location', 'Moment', 'Reinforcement', 'Shear', 'Stirrups'))
+        tree.heading('#0', text='', anchor='w')
+        tree.heading('Span', text='Span')
+        tree.heading('Location', text='Location')
+        tree.heading('Moment', text='Moment (kN-m)')
+        tree.heading('Reinforcement', text='Reinforcement')
+        tree.heading('Shear', text='Shear (kN)')
+        tree.heading('Stirrups', text='Stirrups')
+        
+        tree.column('#0', width=0, stretch=False)
+        tree.column('Span', width=60)
+        tree.column('Location', width=100)
+        tree.column('Moment', width=100)
+        tree.column('Reinforcement', width=120)
+        tree.column('Shear', width=80)
+        tree.column('Stirrups', width=120)
+        
+        for span_data in design_results:
+            span_num = span_data['span']
+            for i, (reinf, stirrup) in enumerate(zip(span_data['reinforcement'], span_data['stirrups'])):
+                if reinf['moment'] != 0 or stirrup['shear'] != 0:
+                    tree.insert('', 'end', values=(
+                        span_num if i == 0 else '',
+                        reinf['location'],
+                        f"{reinf['moment']:.2f}" if reinf['moment'] != 0 else '-',
+                        reinf['bars'] if reinf['moment'] != 0 else '-',
+                        f"{stirrup['shear']:.2f}" if stirrup['shear'] != 0 else '-',
+                        stirrup['stirrup_spacing'] if stirrup['shear'] != 0 else '-'
+                    ))
+        
+        tree.pack(expand=True, fill='both', padx=10, pady=10)
+        
+        # Close button
+        ttk.Button(summary_window, text="Close", 
+                  command=summary_window.destroy).pack(pady=10)
+
+def main():
+    root = tk.Tk()
+    app = BeamDesignApp(root)
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()

continuous_beam.py

@@ -0,0 +1,1036 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from typing import List, Dict, Tuple
+import math
+
+class ContinuousBeam:
+    """
+    Continuous beam analysis and RC design according to ACI code
+    """
+    
+    def __init__(self):
+        self.spans = []
+        self.loads = []
+        self.supports = []
+        self.moments = []
+        self.shears = []
+        self.fc = 28  # Concrete compressive strength (MPa)
+        self.fy = 420  # Steel yield strength (MPa)
+        self.beam_width = 300  # mm
+        self.beam_depth = 500  # mm
+        self.cover = 40  # mm
+        self.d = self.beam_depth - self.cover  # Effective depth
+        
+    def add_span(self, length: float, distributed_load: float = 0, point_loads: List[Tuple[float, float]] = None):
+        """
+        Add a span to the continuous beam
+        length: span length in meters
+        distributed_load: uniformly distributed load in kN/m
+        point_loads: list of (position, load) tuples in (m, kN)
+        """
+        span = {
+            'length': length,
+            'distributed_load': distributed_load,
+            'point_loads': point_loads or []
+        }
+        self.spans.append(span)
+        
+    def create_beam_element_stiffness(self, length, E, I):
+        """
+        Create local stiffness matrix for a beam element
+        [k] = EI/L^3 * [[12, 6L, -12, 6L],
+                        [6L, 4L^2, -6L, 2L^2],
+                        [-12, -6L, 12, -6L],
+                        [6L, 2L^2, -6L, 4L^2]]
+        DOFs: [v1, θ1, v2, θ2] where v=deflection, θ=rotation
+        """
+        L = length
+        EI_L3 = E * I / (L**3)
+        
+        k = EI_L3 * np.array([
+            [12,    6*L,   -12,   6*L],
+            [6*L,   4*L**2, -6*L,  2*L**2],
+            [-12,   -6*L,   12,   -6*L],
+            [6*L,   2*L**2, -6*L,  4*L**2]
+        ])
+        
+        return k
+    
+    def create_distributed_load_vector(self, length, w):
+        """
+        Create equivalent nodal force vector for distributed load
+        For uniformly distributed load w:
+        [F] = wL/12 * [6, L, 6, -L]
+        """
+        L = length
+        wL_12 = w * L / 12
+        
+        f = wL_12 * np.array([6, L, 6, -L])
+        return f
+    
+    def create_point_load_vector(self, length, point_loads):
+        """
+        Create equivalent nodal force vector for point loads
+        """
+        L = length
+        f = np.zeros(4)
+        
+        for pos, load in point_loads:
+            a = pos  # distance from left node
+            b = L - pos  # distance from right node
+            
+            # Shape functions at load position
+            xi = pos / L  # normalized position
+            
+            # Equivalent nodal forces using shape functions
+            N1 = 1 - 3*xi**2 + 2*xi**3
+            N2 = L * (xi - 2*xi**2 + xi**3)
+            N3 = 3*xi**2 - 2*xi**3
+            N4 = L * (-xi**2 + xi**3)
+            
+            f += load * np.array([N1, N2, N3, N4])
+        
+        return f
+    
+    def finite_element_analysis(self):
+        """
+        Perform finite element analysis of continuous beam
+        """
+        if len(self.spans) == 0:
+            raise ValueError("No spans defined")
+        
+        # Material properties (assumed values for analysis)
+        E = 30000  # MPa (typical for concrete)
+        # Calculate moment of inertia from beam dimensions
+        b = self.beam_width / 1000  # Convert mm to m
+        h = self.beam_depth / 1000  # Convert mm to m
+        I = b * h**3 / 12  # m^4
+        
+        # Create mesh - each span divided into elements
+        elements_per_span = 10  # Number of elements per span
+        total_elements = len(self.spans) * elements_per_span
+        total_nodes = total_elements + 1
+        
+        # Node coordinates
+        node_coords = []
+        current_x = 0
+        
+        for span in self.spans:
+            span_length = span['length']
+            element_length = span_length / elements_per_span
+            
+            for i in range(elements_per_span):
+                node_coords.append(current_x + i * element_length)
+            
+            current_x += span_length
+        
+        # Add final node
+        node_coords.append(current_x)
+        node_coords = np.array(node_coords)
+        
+        # Global stiffness matrix (2 DOFs per node: deflection and rotation)
+        n_dofs = 2 * total_nodes
+        K_global = np.zeros((n_dofs, n_dofs))
+        F_global = np.zeros(n_dofs)
+        
+        # Assembly process
+        for elem_idx in range(total_elements):
+            # Element properties
+            span_idx = elem_idx // elements_per_span
+            local_elem_idx = elem_idx % elements_per_span
+            
+            span = self.spans[span_idx]
+            element_length = span['length'] / elements_per_span
+            
+            # Local stiffness matrix
+            k_local = self.create_beam_element_stiffness(element_length, E, I)
+            
+            # Global DOF indices for this element
+            node1 = elem_idx
+            node2 = elem_idx + 1
+            
+            dofs = [2*node1, 2*node1+1, 2*node2, 2*node2+1]  # [v1, θ1, v2, θ2]
+            
+            # Assemble into global matrix
+            for i in range(4):
+                for j in range(4):
+                    K_global[dofs[i], dofs[j]] += k_local[i, j]
+            
+            # Create load vector for this element
+            # Distributed load
+            w = span['distributed_load'] * 1000  # Convert kN/m to N/m
+            f_dist = self.create_distributed_load_vector(element_length, w)
+            
+            # Point loads (only if they fall within this element)
+            point_loads = span.get('point_loads', [])
+            f_point = np.zeros(4)
+            
+            span_start = sum(self.spans[j]['length'] for j in range(span_idx))
+            elem_start = span_start + local_elem_idx * element_length
+            elem_end = elem_start + element_length
+            
+            for pos, load in point_loads:
+                global_pos = span_start + pos
+                if elem_start <= global_pos <= elem_end:
+                    local_pos = global_pos - elem_start
+                    f_point += self.create_point_load_vector(element_length, [(local_pos, load * 1000)])
+            
+            f_total = f_dist + f_point
+            
+            # Assemble into global force vector
+            for i in range(4):
+                F_global[dofs[i]] += f_total[i]
+        
+        # Apply boundary conditions (pin supports at all support locations)
+        # Support locations are at the ends of each span
+        support_nodes = [0]  # First support
+        current_node = 0
+        for span in self.spans:
+            current_node += elements_per_span
+            support_nodes.append(current_node)
+        
+        # Create arrays for free DOFs (removing constrained deflections)
+        constrained_dofs = [2 * node for node in support_nodes]  # Vertical deflections at supports
+        free_dofs = [i for i in range(n_dofs) if i not in constrained_dofs]
+        
+        # Extract free DOF matrices
+        K_free = K_global[np.ix_(free_dofs, free_dofs)]
+        F_free = F_global[free_dofs]
+        
+        # Solve for displacements
+        try:
+            U_free = np.linalg.solve(K_free, F_free)
+        except np.linalg.LinAlgError:
+            # Fallback to least squares if matrix is singular
+            U_free = np.linalg.lstsq(K_free, F_free, rcond=None)[0]
+        
+        # Reconstruct full displacement vector
+        U_global = np.zeros(n_dofs)
+        U_global[free_dofs] = U_free
+        
+        # Store results for post-processing
+        self.node_coords = node_coords
+        self.displacements = U_global
+        self.elements_per_span = elements_per_span
+        self.element_properties = {'E': E, 'I': I}
+        self.K_global = K_global  # Store for reaction calculation
+        
+        return node_coords, U_global
+    
+    def calculate_element_forces(self):
+        """
+        Calculate internal forces (moment and shear) for each element
+        """
+        if not hasattr(self, 'displacements'):
+            self.finite_element_analysis()
+        
+        E = self.element_properties['E']
+        I = self.element_properties['I']
+        
+        moments = []
+        shears = []
+        x_coords = []
+        
+        # Calculate reactions first for proper shear calculation
+        reactions = self.calculate_reactions()
+        
+        elem_idx = 0
+        for span_idx, span in enumerate(self.spans):
+            span_length = span['length']
+            element_length = span_length / self.elements_per_span
+            
+            span_start_x = sum(self.spans[j]['length'] for j in range(span_idx))
+            
+            for local_elem in range(self.elements_per_span):
+                # Element nodes
+                node1 = elem_idx
+                node2 = elem_idx + 1
+                
+                # Element displacements
+                u1 = self.displacements[2*node1]     # deflection at node 1
+                theta1 = self.displacements[2*node1+1]  # rotation at node 1
+                u2 = self.displacements[2*node2]     # deflection at node 2
+                theta2 = self.displacements[2*node2+1]  # rotation at node 2
+                
+                # Calculate forces at multiple points within element
+                n_points = 10
+                for i in range(n_points):
+                    xi = i / (n_points - 1)  # 0 to 1
+                    x_local = xi * element_length
+                    x_global = span_start_x + local_elem * element_length + x_local
+                    
+                    # Shape function derivatives for moment calculation
+                    # M = -EI * d²v/dx²
+                    d2N1_dx2 = (-6 + 12*xi) / element_length**2
+                    d2N2_dx2 = (-4 + 6*xi) / element_length
+                    d2N3_dx2 = (6 - 12*xi) / element_length**2
+                    d2N4_dx2 = (-2 + 6*xi) / element_length
+                    
+                    curvature = (d2N1_dx2 * u1 + d2N2_dx2 * theta1 + 
+                               d2N3_dx2 * u2 + d2N4_dx2 * theta2)
+                    moment = -E * I * curvature / 1000  # Convert to kN-m
+                    
+                    # Calculate shear using equilibrium method (more reliable)
+                    shear = self.calculate_shear_at_position(x_global, reactions)
+                    
+                    x_coords.append(x_global)
+                    moments.append(moment)
+                    shears.append(shear)
+                
+                elem_idx += 1
+        
+        return np.array(x_coords), np.array(moments), np.array(shears)
+    
+    def calculate_reactions(self):
+        """
+        Calculate support reactions from finite element solution
+        """
+        if not hasattr(self, 'K_global') or not hasattr(self, 'displacements'):
+            self.finite_element_analysis()
+        
+        # Get support node indices
+        support_nodes = [0]  # First support
+        current_node = 0
+        for span in self.spans:
+            current_node += self.elements_per_span
+            support_nodes.append(current_node)
+        
+        # Calculate reactions using R = K*U - F for constrained DOFs
+        reactions = []
+        
+        # Build complete force vector including applied loads
+        n_dofs = len(self.displacements)
+        F_complete = np.zeros(n_dofs)
+        
+        # Assemble applied load vector (same as in FE analysis)
+        elem_idx = 0
+        for span_idx, span in enumerate(self.spans):
+            element_length = span['length'] / self.elements_per_span
+            
+            for local_elem_idx in range(self.elements_per_span):
+                # Global DOF indices for this element
+                node1 = elem_idx
+                node2 = elem_idx + 1
+                dofs = [2*node1, 2*node1+1, 2*node2, 2*node2+1]
+                
+                # Create load vector for this element
+                w = span['distributed_load'] * 1000  # Convert to N/m
+                f_dist = self.create_distributed_load_vector(element_length, w)
+                
+                # Point loads (only if they fall within this element)
+                point_loads = span.get('point_loads', [])
+                f_point = np.zeros(4)
+                
+                span_start = sum(self.spans[j]['length'] for j in range(span_idx))
+                elem_start = span_start + local_elem_idx * element_length
+                elem_end = elem_start + element_length
+                
+                for pos, load in point_loads:
+                    global_pos = span_start + pos
+                    if elem_start <= global_pos <= elem_end:
+                        local_pos = global_pos - elem_start
+                        f_point += self.create_point_load_vector(element_length, [(local_pos, load * 1000)])
+                
+                f_total = f_dist + f_point
+                
+                # Assemble into global force vector
+                for i in range(4):
+                    F_complete[dofs[i]] += f_total[i]
+                
+                elem_idx += 1
+        
+        # Calculate reactions at each support
+        for support_node in support_nodes:
+            # Vertical DOF for this support
+            dof = 2 * support_node
+            
+            # Reaction = K*U - F at constrained DOF
+            # Since displacement is zero at support, reaction = -F_applied + K*U_other
+            reaction_force = 0
+            
+            # Sum contributions from all DOFs
+            for j in range(n_dofs):
+                reaction_force += self.K_global[dof, j] * self.displacements[j]
+            
+            # Subtract applied force (if any) at this DOF
+            reaction_force -= F_complete[dof]
+            
+            # Convert to kN and store (positive = upward reaction)
+            # Note: FE convention may give negative values for upward reactions
+            reactions.append(-reaction_force / 1000)
+        
+        # Store for debugging
+        self.reactions = reactions
+        return reactions
+    
+    def calculate_shear_at_position(self, x_global, reactions):
+        """
+        Calculate shear force at any position using equilibrium
+        """
+        shear = 0
+        current_pos = 0
+        
+        # Add reaction at first support
+        if len(reactions) > 0:
+            shear += reactions[0]
+        
+        # Subtract loads to the left of current position
+        support_idx = 1
+        for span_idx, span in enumerate(self.spans):
+            span_start = current_pos
+            span_end = current_pos + span['length']
+            
+            if x_global <= span_start:
+                break
+                
+            # Check if we passed a support
+            if x_global > span_end and support_idx < len(reactions):
+                shear += reactions[support_idx]
+                support_idx += 1
+            
+            # Calculate how much of this span is to the left of current position
+            span_length_to_left = min(x_global - span_start, span['length'])
+            
+            if span_length_to_left > 0:
+                # Distributed load effect
+                w = span['distributed_load']
+                shear -= w * span_length_to_left
+                
+                # Point load effects
+                point_loads = span.get('point_loads', [])
+                for pos, load in point_loads:
+                    if pos <= span_length_to_left:
+                        shear -= load
+            
+            current_pos += span['length']
+        
+        return shear
+    
+    def analyze_moments(self):
+        """
+        Analyze continuous beam using finite element method
+        """
+        num_spans = len(self.spans)
+        if num_spans == 0:
+            raise ValueError("No spans defined")
+        
+        # Perform finite element analysis
+        self.finite_element_analysis()
+        
+        # Calculate detailed forces along the beam
+        x_coords, moments_detailed, shears_detailed = self.calculate_element_forces()
+        
+        # Extract critical moments and shears for each span (for compatibility with existing code)
+        self.moments = []
+        self.shears = []
+        
+        current_pos = 0
+        for i, span in enumerate(self.spans):
+            span_length = span['length']
+            span_start = current_pos
+            span_mid = current_pos + span_length / 2
+            span_end = current_pos + span_length
+            
+            # Find indices closest to critical points
+            start_idx = np.argmin(np.abs(x_coords - span_start))
+            mid_idx = np.argmin(np.abs(x_coords - span_mid))
+            end_idx = np.argmin(np.abs(x_coords - span_end))
+            
+            # Extract moments and shears at critical points
+            M_start = moments_detailed[start_idx]
+            M_mid = moments_detailed[mid_idx]
+            M_end = moments_detailed[end_idx]
+            
+            V_start = shears_detailed[start_idx]
+            V_mid = shears_detailed[mid_idx]
+            V_end = shears_detailed[end_idx]
+            
+            # Store for span (maintaining compatibility with existing design methods)
+            self.moments.append([M_start, M_mid, M_end])
+            self.shears.append([V_start, V_mid, V_end])
+            
+            current_pos += span_length
+        
+        # Store detailed results for plotting
+        self.detailed_x = x_coords
+        self.detailed_moments = moments_detailed
+        self.detailed_shears = shears_detailed
+    
+    
+    def calculate_required_reinforcement(self, moment: float, beam_type: str = "rectangular"):
+        """
+        Calculate required area of reinforcement according to ACI code
+        moment: Design moment in kN-m
+        beam_type: Type of beam section
+        """
+        if moment == 0:
+            return 0
+            
+        # Convert moment to N-mm
+        Mu = abs(moment) * 1e6
+        
+        # Material properties
+        fc = self.fc  # MPa
+        fy = self.fy  # MPa
+        b = self.beam_width  # mm
+        d = self.d  # mm
+        
+        # Strength reduction factor
+        phi = 0.9
+        
+        # Calculate required reinforcement
+        # Using simplified rectangular stress block
+        beta1 = 0.85 if fc <= 28 else max(0.65, 0.85 - 0.05 * (fc - 28) / 7)
+        
+        # Calculate Rn
+        Rn = Mu / (phi * b * d**2)
+        
+        # Calculate reinforcement ratio
+        rho = (0.85 * fc / fy) * (1 - math.sqrt(1 - 2 * Rn / (0.85 * fc)))
+        
+        # Minimum reinforcement ratio
+        rho_min = max(1.4 / fy, 0.25 * math.sqrt(fc) / fy)
+        
+        # Maximum reinforcement ratio (75% of balanced ratio)
+        rho_b = (0.85 * fc * beta1 * 600) / (fy * (600 + fy))
+        rho_max = 0.75 * rho_b
+        
+        # Check limits
+        rho = max(rho, rho_min)
+        if rho > rho_max:
+            raise ValueError(f"Required reinforcement ratio {rho:.4f} exceeds maximum {rho_max:.4f}")
+        
+        # Calculate required area
+        As_required = rho * b * d
+        
+        return As_required
+    
+    def calculate_shear_reinforcement(self, shear: float):
+        """
+        Calculate shear reinforcement (stirrups) according to ACI code
+        shear: Design shear force in kN
+        """
+        if shear == 0:
+            return {"stirrup_spacing": "No stirrups required", "Av": 0}
+            
+        # Convert shear to N
+        Vu = abs(shear) * 1000
+        
+        # Material properties
+        fc = self.fc  # MPa
+        fy = self.fy  # MPa (for stirrups)
+        b = self.beam_width  # mm
+        d = self.d  # mm
+        
+        # Strength reduction factor for shear
+        phi_v = 0.75
+        
+        # Concrete shear capacity
+        Vc = 0.17 * math.sqrt(fc) * b * d  # N
+        
+        # Check if shear reinforcement is required
+        if Vu <= phi_v * Vc / 2:
+            return {"stirrup_spacing": "No stirrups required", "Av": 0}
+        
+        # Calculate required shear reinforcement
+        Vs = Vu / phi_v - Vc  # Required steel shear capacity
+        
+        # Maximum shear that can be carried by steel
+        Vs_max = 0.66 * math.sqrt(fc) * b * d
+        
+        if Vs > Vs_max:
+            raise ValueError("Shear exceeds maximum capacity - increase beam size")
+        
+        # Calculate required stirrup area
+        # Assuming #10 stirrups (2 legs, Area = 2 × 71 = 142 mm²)
+        Av = 142  # mm² (2-leg #10 stirrups)
+        
+        # Calculate required spacing
+        s_required = Av * fy * d / Vs  # mm
+        
+        # Maximum spacing limits
+        s_max = min(d / 2, 600)  # mm
+        
+        # Minimum stirrup requirements
+        if Vu > phi_v * Vc:
+            Av_min = 0.35 * b * s_required / fy
+            s_max_min = min(d / 4, 300)  # More restrictive for high shear
+            s_required = min(s_required, s_max_min)
+        
+        s_required = min(s_required, s_max)
+        s_required = max(s_required, 50)  # Minimum practical spacing
+        
+        return {
+            "stirrup_spacing": f"{s_required:.0f} mm c/c",
+            "Av": Av,
+            "Vs": Vs / 1000,  # Convert back to kN
+            "Vc": Vc / 1000   # Convert back to kN
+        }
+    
+    def design_beam(self):
+        """
+        Complete beam design including flexural and shear design
+        """
+        if not self.moments:
+            self.analyze_moments()
+        
+        design_results = []
+        
+        for i, (moments, shears) in enumerate(zip(self.moments, self.shears)):
+            span_design = {
+                'span': i + 1,
+                'length': self.spans[i]['length'],
+                'moments': moments,
+                'shears': shears,
+                'reinforcement': [],
+                'stirrups': []
+            }
+            
+            # Design for each critical section
+            moment_locations = ['Left Support', 'Mid-span', 'Right Support']
+            
+            for j, (moment, shear) in enumerate(zip(moments, shears)):
+                # Flexural design
+                if moment != 0:
+                    As_required = self.calculate_required_reinforcement(moment)
+                    
+                    # Select reinforcement bars
+                    bar_areas = {10: 79, 12: 113, 16: 201, 20: 314, 25: 491}  # mm²
+                    
+                    # Try different bar sizes
+                    for bar_size, bar_area in bar_areas.items():
+                        num_bars = math.ceil(As_required / bar_area)
+                        if num_bars <= 8:  # Practical limit
+                            As_provided = num_bars * bar_area
+                            break
+                    else:
+                        # Use largest bars if can't fit
+                        bar_size = 25
+                        bar_area = 491
+                        num_bars = math.ceil(As_required / bar_area)
+                        As_provided = num_bars * bar_area
+                    
+                    reinforcement = {
+                        'location': moment_locations[j],
+                        'moment': moment,
+                        'As_required': As_required,
+                        'As_provided': As_provided,
+                        'bars': f"{num_bars}T{bar_size}",
+                        'ratio': As_provided / (self.beam_width * self.d) * 100
+                    }
+                else:
+                    reinforcement = {
+                        'location': moment_locations[j],
+                        'moment': 0,
+                        'As_required': 0,
+                        'As_provided': 0,
+                        'bars': "No reinforcement",
+                        'ratio': 0
+                    }
+                
+                span_design['reinforcement'].append(reinforcement)
+                
+                # Shear design
+                stirrup_design = self.calculate_shear_reinforcement(shear)
+                stirrup_design['location'] = moment_locations[j]
+                stirrup_design['shear'] = shear
+                span_design['stirrups'].append(stirrup_design)
+            
+            design_results.append(span_design)
+        
+        return design_results
+    
+    def generate_report(self, design_results):
+        """
+        Generate design report
+        """
+        report = []
+        report.append("="*60)
+        report.append("CONTINUOUS BEAM RC DESIGN REPORT")
+        report.append("According to ACI Code")
+        report.append("="*60)
+        report.append(f"Beam dimensions: {self.beam_width}mm × {self.beam_depth}mm")
+        report.append(f"Concrete strength (f'c): {self.fc} MPa")
+        report.append(f"Steel strength (fy): {self.fy} MPa")
+        report.append(f"Effective depth (d): {self.d} mm")
+        report.append("")
+        
+        for span_data in design_results:
+            report.append(f"SPAN {span_data['span']} - Length: {span_data['length']} m")
+            report.append("-" * 40)
+            
+            # Moments and reinforcement
+            report.append("FLEXURAL DESIGN:")
+            for reinf in span_data['reinforcement']:
+                if reinf['moment'] != 0:
+                    report.append(f"  {reinf['location']}:")
+                    report.append(f"    Moment: {reinf['moment']:.2f} kN-m")
+                    report.append(f"    As required: {reinf['As_required']:.0f} mm²")
+                    report.append(f"    As provided: {reinf['As_provided']:.0f} mm²")
+                    report.append(f"    Reinforcement: {reinf['bars']}")
+                    report.append(f"    Reinforcement ratio: {reinf['ratio']:.2f}%")
+                    report.append("")
+            
+            # Shear and stirrups
+            report.append("SHEAR DESIGN:")
+            for stirrup in span_data['stirrups']:
+                if stirrup['shear'] != 0:
+                    report.append(f"  {stirrup['location']}:")
+                    report.append(f"    Shear: {stirrup['shear']:.2f} kN")
+                    if 'Vs' in stirrup:
+                        report.append(f"    Vc: {stirrup['Vc']:.2f} kN")
+                        report.append(f"    Vs: {stirrup['Vs']:.2f} kN")
+                    report.append(f"    Stirrup spacing: {stirrup['stirrup_spacing']}")
+                    report.append("")
+            
+            report.append("")
+        
+        return "\n".join(report)
+    
+    def plot_bmd_sfd(self, design_results=None):
+        """
+        Generate BMD and SFD plots
+        """
+        if design_results is None:
+            design_results = self.design_beam()
+        
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
+        
+        # Calculate total beam length and positions
+        total_length = 0
+        span_positions = [0]
+        
+        for span in self.spans:
+            total_length += span['length']
+            span_positions.append(total_length)
+        
+        # Use detailed FE results if available, otherwise fall back to approximate method
+        if hasattr(self, 'detailed_x') and hasattr(self, 'detailed_moments'):
+            # Use finite element results
+            x_coords = self.detailed_x
+            moments_detailed = self.detailed_moments
+            shears_detailed = self.detailed_shears
+        else:
+            # Fallback to approximate method for backwards compatibility
+            x_coords = []
+            moments_detailed = []
+            shears_detailed = []
+            
+            for i, span_data in enumerate(design_results):
+                span_length = span_data['length']
+                start_pos = span_positions[i]
+                
+                # Create x coordinates for this span
+                x_span = np.linspace(start_pos, start_pos + span_length, 100)
+                
+                # Get moments and shears for this span
+                moments = span_data['moments']  # [left, mid, right]
+                shears = span_data['shears']
+                
+                # Simple interpolation between critical points
+                moment_curve = np.interp(x_span, 
+                                       [start_pos, start_pos + span_length/2, start_pos + span_length],
+                                       moments)
+                shear_curve = np.interp(x_span,
+                                      [start_pos, start_pos + span_length/2, start_pos + span_length],
+                                      shears)
+                
+                x_coords.extend(x_span)
+                moments_detailed.extend(moment_curve)
+                shears_detailed.extend(shear_curve)
+        
+        # Plot BMD
+        ax1.plot(x_coords, moments_detailed, 'b-', linewidth=2, label='Bending Moment')
+        ax1.fill_between(x_coords, moments_detailed, alpha=0.3, color='blue')
+        ax1.axhline(y=0, color='k', linestyle='-', alpha=0.3)
+        ax1.set_ylabel('Bending Moment (kN-m)', fontsize=12)
+        ax1.set_title('Bending Moment Diagram (BMD)', fontsize=14, fontweight='bold')
+        ax1.grid(True, alpha=0.3)
+        ax1.legend()
+        
+        # Add support symbols
+        for pos in span_positions:
+            ax1.axvline(x=pos, color='red', linestyle='--', alpha=0.7)
+            ax1.plot(pos, 0, 'rs', markersize=8, label='Support' if pos == span_positions[0] else "")
+        
+        # Plot SFD  
+        ax2.plot(x_coords, shears_detailed, 'r-', linewidth=2, label='Shear Force')
+        ax2.fill_between(x_coords, shears_detailed, alpha=0.3, color='red')
+        ax2.axhline(y=0, color='k', linestyle='-', alpha=0.3)
+        ax2.set_ylabel('Shear Force (kN)', fontsize=12)
+        ax2.set_xlabel('Distance along beam (m)', fontsize=12)
+        ax2.set_title('Shear Force Diagram (SFD)', fontsize=14, fontweight='bold')
+        ax2.grid(True, alpha=0.3)
+        ax2.legend()
+        
+        # Add support symbols
+        for pos in span_positions:
+            ax2.axvline(x=pos, color='red', linestyle='--', alpha=0.7)
+            ax2.plot(pos, 0, 'rs', markersize=8, label='Support' if pos == span_positions[0] else "")
+        
+        plt.tight_layout()
+        return fig
+    
+    def plot_reinforcement_layout(self, design_results=None):
+        """
+        Generate reinforcement layout diagram
+        """
+        if design_results is None:
+            design_results = self.design_beam()
+        
+        fig, ax = plt.subplots(1, 1, figsize=(14, 8))
+        
+        # Calculate positions
+        total_length = sum(span['length'] for span in self.spans)
+        span_positions = [0]
+        current_pos = 0
+        
+        for span in self.spans:
+            current_pos += span['length']
+            span_positions.append(current_pos)
+        
+        # Draw beam outline
+        beam_height = 0.5  # Normalized height for drawing
+        ax.add_patch(plt.Rectangle((0, -beam_height/2), total_length, beam_height, 
+                                  fill=False, edgecolor='black', linewidth=2))
+        
+        # Add beam dimensions text
+        ax.text(total_length/2, beam_height/2 + 0.1, 
+               f'{self.beam_width}mm × {self.beam_depth}mm', 
+               ha='center', va='bottom', fontsize=10, fontweight='bold')
+        
+        # Draw reinforcement for each span
+        colors = ['blue', 'green', 'orange', 'purple', 'brown']
+        
+        for i, span_data in enumerate(design_results):
+            span_start = span_positions[i]
+            span_end = span_positions[i + 1]
+            span_center = (span_start + span_end) / 2
+            color = colors[i % len(colors)]
+            
+            # Process reinforcement
+            for j, reinf in enumerate(span_data['reinforcement']):
+                if reinf['As_provided'] > 0:
+                    location = reinf['location']
+                    bars = reinf['bars']
+                    
+                    if location == 'Left Support':
+                        x_pos = span_start
+                        y_pos = beam_height/3  # Top reinforcement
+                        marker = '^'
+                        label_pos = 'top'
+                    elif location == 'Mid-span':
+                        x_pos = span_center
+                        y_pos = -beam_height/3  # Bottom reinforcement
+                        marker = 'v'
+                        label_pos = 'bottom'
+                    else:  # Right Support
+                        x_pos = span_end
+                        y_pos = beam_height/3  # Top reinforcement
+                        marker = '^'
+                        label_pos = 'top'
+                    
+                    # Draw reinforcement symbol
+                    ax.scatter(x_pos, y_pos, s=100, c=color, marker=marker, 
+                             edgecolor='black', linewidth=1, zorder=5)
+                    
+                    # Add reinforcement label
+                    if label_pos == 'top':
+                        ax.text(x_pos, y_pos + 0.15, bars, ha='center', va='bottom', 
+                               fontsize=9, fontweight='bold', rotation=0)
+                    else:
+                        ax.text(x_pos, y_pos - 0.15, bars, ha='center', va='top', 
+                               fontsize=9, fontweight='bold', rotation=0)
+        
+        # Draw supports
+        for i, pos in enumerate(span_positions):
+            # Support triangle
+            triangle_height = 0.2
+            triangle_width = 0.1
+            
+            triangle = plt.Polygon([
+                [pos - triangle_width/2, -beam_height/2],
+                [pos + triangle_width/2, -beam_height/2],
+                [pos, -beam_height/2 - triangle_height]
+            ], fill=True, facecolor='red', edgecolor='black')
+            
+            ax.add_patch(triangle)
+            
+            # Support label
+            ax.text(pos, -beam_height/2 - triangle_height - 0.1, 
+                   f'Support {i+1}', ha='center', va='top', fontsize=8)
+        
+        # Add span labels and loads
+        for i, span in enumerate(self.spans):
+            span_start = span_positions[i]
+            span_end = span_positions[i + 1]
+            span_center = (span_start + span_end) / 2
+            
+            # Create span label text
+            label_text = f'Span {i+1}\nL = {span["length"]}m\nw = {span["distributed_load"]}kN/m'
+            
+            # Add point loads to label if any
+            if span.get('point_loads'):
+                point_load_text = '\nPoint Loads:'
+                for pos, load in span['point_loads']:
+                    point_load_text += f'\n{load}kN @ {pos}m'
+                label_text += point_load_text
+            
+            # Span label
+            ax.text(span_center, -beam_height/2 - 0.4, label_text, 
+                   ha='center', va='top', fontsize=9,
+                   bbox=dict(boxstyle="round,pad=0.3", facecolor="lightyellow", alpha=0.7))
+            
+            # Distributed load arrows
+            if span["distributed_load"] > 0:
+                num_arrows = 5
+                for j in range(num_arrows):
+                    x_arrow = span_start + (span_end - span_start) * j / (num_arrows - 1)
+                    ax.arrow(x_arrow, beam_height/2 + 0.3, 0, -0.2, 
+                            head_width=0.05, head_length=0.05, fc='red', ec='red')
+            
+            # Point load arrows
+            if span.get('point_loads'):
+                for pos, load in span['point_loads']:
+                    x_point = span_start + pos
+                    # Larger arrow for point loads
+                    ax.arrow(x_point, beam_height/2 + 0.5, 0, -0.4, 
+                            head_width=0.08, head_length=0.08, fc='blue', ec='blue', linewidth=2)
+                    # Point load label
+                    ax.text(x_point, beam_height/2 + 0.6, f'{load}kN', 
+                           ha='center', va='bottom', fontsize=8, fontweight='bold', color='blue')
+        
+        # Formatting
+        ax.set_xlim(-0.5, total_length + 0.5)
+        ax.set_ylim(-1.2, 1.0)
+        ax.set_xlabel('Distance along beam (m)', fontsize=12)
+        ax.set_title('Reinforcement Layout', fontsize=14, fontweight='bold')
+        ax.grid(True, alpha=0.3)
+        ax.set_aspect('equal')
+        
+        # Legend
+        legend_elements = [
+            plt.scatter([], [], s=100, c='blue', marker='^', edgecolor='black', 
+                       label='Top Reinforcement (Negative Moment)'),
+            plt.scatter([], [], s=100, c='blue', marker='v', edgecolor='black', 
+                       label='Bottom Reinforcement (Positive Moment)')
+        ]
+        ax.legend(handles=legend_elements, loc='upper right')
+        
+        plt.tight_layout()
+        return fig
+    
+    def plot_stirrup_layout(self, design_results=None):
+        """
+        Generate shear stirrup layout diagram
+        """
+        if design_results is None:
+            design_results = self.design_beam()
+        
+        fig, ax = plt.subplots(1, 1, figsize=(14, 6))
+        
+        # Calculate positions
+        total_length = sum(span['length'] for span in self.spans)
+        span_positions = [0]
+        current_pos = 0
+        
+        for span in self.spans:
+            current_pos += span['length']
+            span_positions.append(current_pos)
+        
+        # Draw beam outline (side view)
+        beam_height = 0.5
+        ax.add_patch(plt.Rectangle((0, 0), total_length, beam_height, 
+                                  fill=False, edgecolor='black', linewidth=2))
+        
+        # Draw stirrups for each span
+        for i, span_data in enumerate(design_results):
+            span_start = span_positions[i]
+            span_end = span_positions[i + 1]
+            span_length = span_end - span_start
+            
+            # Get stirrup information
+            stirrup_info = []
+            for stirrup in span_data['stirrups']:
+                if 'No stirrups' not in stirrup['stirrup_spacing']:
+                    spacing_str = stirrup['stirrup_spacing'].replace(' mm c/c', '')
+                    try:
+                        spacing = float(spacing_str) / 1000  # Convert mm to m
+                        stirrup_info.append({
+                            'location': stirrup['location'],
+                            'spacing': spacing,
+                            'shear': stirrup['shear']
+                        })
+                    except:
+                        pass
+            
+            if stirrup_info:
+                # Determine stirrup spacing pattern
+                # For simplicity, use average spacing
+                avg_spacing = np.mean([s['spacing'] for s in stirrup_info])
+                
+                # Draw stirrups
+                num_stirrups = int(span_length / avg_spacing) + 1
+                for j in range(num_stirrups):
+                    x_pos = span_start + j * avg_spacing
+                    if x_pos <= span_end:
+                        # Draw stirrup as vertical line
+                        ax.plot([x_pos, x_pos], [0, beam_height], 'g-', linewidth=2, alpha=0.7)
+                        
+                        # Add stirrup symbol (small rectangle)
+                        stirrup_width = avg_spacing * 0.1
+                        ax.add_patch(plt.Rectangle((x_pos - stirrup_width/2, beam_height*0.1), 
+                                                  stirrup_width, beam_height*0.8, 
+                                                  fill=False, edgecolor='green', linewidth=1))
+                
+                # Add spacing annotation
+                mid_span = (span_start + span_end) / 2
+                ax.annotate(f'Stirrups @ {avg_spacing*1000:.0f}mm c/c', 
+                           xy=(mid_span, beam_height + 0.1), 
+                           ha='center', va='bottom', fontsize=9,
+                           bbox=dict(boxstyle="round,pad=0.2", facecolor="lightgreen", alpha=0.7))
+        
+        # Draw supports
+        for pos in span_positions:
+            # Support line
+            ax.plot([pos, pos], [-0.1, beam_height + 0.05], 'r--', linewidth=2, alpha=0.7)
+            
+            # Support symbol
+            triangle = plt.Polygon([
+                [pos - 0.05, -0.1],
+                [pos + 0.05, -0.1],
+                [pos, -0.2]
+            ], fill=True, facecolor='red', edgecolor='black')
+            ax.add_patch(triangle)
+        
+        # Add dimension lines and labels
+        for i, span in enumerate(self.spans):
+            span_start = span_positions[i]
+            span_end = span_positions[i + 1]
+            span_center = (span_start + span_end) / 2
+            
+            # Dimension line
+            ax.annotate('', xy=(span_start, -0.3), xytext=(span_end, -0.3),
+                       arrowprops=dict(arrowstyle='<->', color='black', lw=1))
+            
+            # Span length label
+            ax.text(span_center, -0.35, f'{span["length"]}m', 
+                   ha='center', va='top', fontsize=10)
+        
+        # Formatting
+        ax.set_xlim(-0.2, total_length + 0.2)
+        ax.set_ylim(-0.5, beam_height + 0.4)
+        ax.set_xlabel('Distance along beam (m)', fontsize=12)
+        ax.set_ylabel('Beam Height', fontsize=12)
+        ax.set_title('Shear Stirrup Layout', fontsize=14, fontweight='bold')
+        ax.grid(True, alpha=0.3)
+        
+        # Add legend
+        legend_elements = [
+            plt.Line2D([0], [0], color='green', linewidth=2, alpha=0.7, label='Stirrups'),
+            plt.Line2D([0], [0], color='red', linestyle='--', linewidth=2, alpha=0.7, label='Supports')
+        ]
+        ax.legend(handles=legend_elements, loc='upper right')
+        
+        plt.tight_layout()
+        return fig

requirements.txt

@@ -0,0 +1,4 @@
+numpy>=1.21.0
+matplotlib>=3.5.0
+gradio>=4.0.0
+pandas>=1.3.0