Update app.py

app.py

@@ -3,7 +3,7 @@ from pint import UnitRegistry, set_application_registry
 import matplotlib.pyplot as plt
 import io
 import base64
-from sympy import symbols, Symbol, Eq, solve, Rational
+from sympy import symbols, Symbol, Eq, solve
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
 from PIL import Image
@@ -12,7 +12,7 @@ import io
 from reportlab.lib.utils import ImageReader
 import os
 import subprocess
-
+import contextlib
 
 
 # Initialize unit registry
@@ -67,35 +67,34 @@ def generate_beam_diagram(n_spans, lengths, loads, moments, R_sx, R_dx,
 
     total_length = x_positions[-1]
 
-    fig, ax = plt.subplots(figsize=(10, 2))
-
-    # Draw the beam as a line
+    fig, ax = plt.subplots(figsize=(10, 3))
+    # Draw the beam as a horizontal line
     ax.hlines(0, 0, total_length, colors='black', linewidth=2)
 
-    # Draw supports
+    # -------------------------------------------
+    # Draw supports (rotated 180° so the tip is on the beam)
+    # -------------------------------------------
     support_width = total_length / 50  # Adjust support width relative to total length
     n_supports = n_spans + 1
     support_positions = []
     idx = 0
     # Left support
     if cantilever_left_length.magnitude > 0:
-        # Support at end of cantilever
+        # Support at the end of the left cantilever (x_positions[1])
         x = x_positions[1]
         support_positions.append(x)
-        ax.plot([x, x], [0, -0.1], color='black')
-        support = plt.Polygon([[x - support_width, -0.1],
-                               [x + support_width, -0.1],
-                               [x, -0.2]], color='black')
+        support = plt.Polygon([[x - support_width, -0.2],
+                               [x + support_width, -0.2],
+                               [x, 0]], color='black')
         ax.add_patch(support)
         idx = 2
     else:
-        # Support at start
+        # Support at start (x_positions[0])
         x = x_positions[0]
         support_positions.append(x)
-        ax.plot([x, x], [0, -0.1], color='black')
-        support = plt.Polygon([[x - support_width, -0.1],
-                               [x + support_width, -0.1],
-                               [x, -0.2]], color='black')
+        support = plt.Polygon([[x - support_width, -0.2],
+                               [x + support_width, -0.2],
+                               [x, 0]], color='black')
         ax.add_patch(support)
         idx = 1
 
@@ -103,63 +102,54 @@ def generate_beam_diagram(n_spans, lengths, loads, moments, R_sx, R_dx,
     for i in range(1, n_supports - 1):
         x = x_positions[idx]
         support_positions.append(x)
-        ax.plot([x, x], [0, -0.1], color='black')
-        support = plt.Polygon([[x - support_width, -0.1],
-                               [x + support_width, -0.1],
-                               [x, -0.2]], color='black')
+        support = plt.Polygon([[x - support_width, -0.2],
+                               [x + support_width, -0.2],
+                               [x, 0]], color='black')
         ax.add_patch(support)
         idx += 1
 
     # Right support
     if cantilever_right_length.magnitude > 0:
-        # Support before cantilever
+        # Support before the right cantilever (x_positions[-2])
         x = x_positions[-2]
         support_positions.append(x)
-        ax.plot([x, x], [0, -0.1], color='black')
-        support = plt.Polygon([[x - support_width, -0.1],
-                               [x + support_width, -0.1],
-                               [x, -0.2]], color='black')
+        support = plt.Polygon([[x - support_width, -0.2],
+                               [x + support_width, -0.2],
+                               [x, 0]], color='black')
         ax.add_patch(support)
     else:
-        # Support at end
+        # Support at end (x_positions[-1])
         x = x_positions[-1]
         support_positions.append(x)
-        ax.plot([x, x], [0, -0.1], color='black')
-        support = plt.Polygon([[x - support_width, -0.1],
-                               [x + support_width, -0.1],
-                               [x, -0.2]], color='black')
+        support = plt.Polygon([[x - support_width, -0.2],
+                               [x + support_width, -0.2],
+                               [x, 0]], color='black')
         ax.add_patch(support)
 
-    # Annotate reactions
+    # -------------------------------------------
+    # Annotate the TOTAL reaction force (sum of left and right) at each support
+    # -------------------------------------------
     for i, x in enumerate(support_positions):
-        # Left-side reaction
-        R_sx_value = R_sx[i]
-        R_sx_unit = R_sx_value.to(reaction_unit)
-        R_sx_num = round(R_sx_unit.magnitude, 6)
-        # Right-side reaction
-        R_dx_value = R_dx[i]
-        R_dx_unit = R_dx_value.to(reaction_unit)
-        R_dx_num = round(R_dx_unit.magnitude, 6)
-        # Display reactions with proper offsets to avoid overlap
-        ax.text(x, 0.15, f'$R_{{{i+1},\, \\mathrm{{sx}}}} = {R_sx_num}$ {reaction_unit_str}',
-                ha='center', va='bottom', color='green')
-        ax.text(x, 0.25, f'$R_{{{i+1},\, \\mathrm{{dx}}}} = {R_dx_num}$ {reaction_unit_str}',
-                ha='center', va='bottom', color='green')
-
-    # Annotate internal moments
+        R_total = R_sx[i] + R_dx[i]
+        R_total_conv = R_total.to(reaction_unit)
+        R_total_num = round(R_total_conv.magnitude, 6)
+        ax.text(x, 0.25, f'$R_{{{i+1}}} = {R_total_num}$ {reaction_unit_str}',
+                ha='center', va='bottom', color='green', fontsize=10)
+
+    # Annotate internal moments below the beam
     for i, x in enumerate(support_positions):
         M_value = moments[i]
         M_unit = M_value.to(moment_unit)
         M_num = round(M_unit.magnitude, 6)
         ax.text(x, -0.25, f'$M_{{{i+1}}} = {M_num}$ {moment_unit_str}',
-                ha='center', va='top', color='blue')
+                ha='center', va='top', color='blue', fontsize=10)
 
-    # Remove axes
+    # Remove axes and adjust limits
     ax.axis('off')
     plt.xlim(-0.05 * total_length, total_length * 1.05)
     plt.ylim(-0.4, 0.4)
 
-    # Save plot to a buffer
+    # Save plot to a buffer and encode as base64
     buf = io.BytesIO()
     plt.savefig(buf, format='png', bbox_inches='tight', dpi=150)
     plt.close(fig)
@@ -171,69 +161,67 @@ def calculate_reactions(n_spans, lengths, distributed_loads, moments,
                         cantilever_left_length=Q_(0.0, u.meter), cantilever_left_load=Q_(0.0, u.newton / u.meter),
                         cantilever_right_length=Q_(0.0, u.meter), cantilever_right_load=Q_(0.0, u.newton / u.meter)):
     """
-    Calculate reactions using Excel formulas and print torques:
-    r1_sx = (sx cantilever * weight)
-    r1_dx = (ln-1 * weight)/2 + (torque1 - torque2)/ln-1
-    r2_sx = (ln-1 * weight) - r(m-1)_dx
-    r2_dx = (ln-1 * weight)/2 + (torque_m - torque_m+1)/ln-1
-    And so on...
+    Calculate reactions.
+    For a cantilever the reaction force is simply:
+         R = (distributed load) * (cantilever length)
     """
     n_supports = n_spans + 1
-    
-    # Print all torques (moments)
+
+    # Print all torques (moments) at supports
     print("\nTorques at each support:")
     for i, moment in enumerate(moments):
         print(f"Torque {i+1}: {moment}")
     print("\n")
-    
-    # Initialize reaction lists
+
+    # Initialize reaction lists (each support will have left (R_sx) and right (R_dx) components)
     R_sx = [Q_(0.0, 'newton') for _ in range(n_supports)]
     R_dx = [Q_(0.0, 'newton') for _ in range(n_supports)]
 
     # ---------------------------
     # First support (m = 0)
     # ---------------------------
-    print(f"Calculating R1:")
-    # r1_sx = (sx cantilever * weight)
+    print("Calculating R1:")
+    # For a left cantilever, the left reaction is the cantilever force:
     if cantilever_left_length.magnitude > 0:
         R_sx[0] = cantilever_left_load * cantilever_left_length
-        print(f"R1_sx = cantilever_load * cantilever_length = {R_sx[0]}")
+        print(f"R1_sx = cantilever_left_load * cantilever_left_length = {R_sx[0]}")
         
-    # r1_dx = (l0 * w0)/2 + (torque1 - torque2)/l0
-    R_dx[0] = (distributed_loads[0] * lengths[0]) / 2 + \
-              (moments[0] - moments[1]) / lengths[0]
+    # r1_dx = (l0 * w0)/2 + (M1 - M2)/l0
+    R_dx[0] = (distributed_loads[0] * lengths[0]) / 2 + (moments[0] - moments[1]) / lengths[0]
     print(f"R1_dx = ({distributed_loads[0]} * {lengths[0]})/2 + ({moments[0]} - {moments[1]})/{lengths[0]} = {R_dx[0]}")
-              
+
     # ---------------------------
-    # Middle supports (1..n-1)
+    # Middle supports (1 .. n-1)
     # ---------------------------
     for m in range(1, n_supports - 1):
         print(f"\nCalculating R{m+1}:")
-        # r(m)_sx = (l(m-1)*w(m-1)) - r(m-1)_dx
+        # Left reaction at support m: load from previous span minus the right reaction of previous support
         R_sx[m] = distributed_loads[m-1] * lengths[m-1] - R_dx[m-1]
         print(f"R{m+1}_sx = {distributed_loads[m-1]} * {lengths[m-1]} - {R_dx[m-1]} = {R_sx[m]}")
         
-        # r(m)_dx = (l(m)*w(m))/2 + (torque_m - torque_(m+1))/l(m)
-        R_dx[m] = (distributed_loads[m] * lengths[m]) / 2 + \
-                  (moments[m] - moments[m+1]) / lengths[m]
+        # Right reaction at support m: half the load on the next span plus moment difference contribution
+        R_dx[m] = (distributed_loads[m] * lengths[m]) / 2 + (moments[m] - moments[m+1]) / lengths[m]
         print(f"R{m+1}_dx = ({distributed_loads[m]} * {lengths[m]})/2 + ({moments[m]} - {moments[m+1]})/{lengths[m]} = {R_dx[m]}")
-    
+
     # ---------------------------
-    # Last support (m = n_supports-1)
+    # Last support (m = n_supports - 1)
     # ---------------------------
     m = n_supports - 1
     print(f"\nCalculating R{m+1}:")
-
-    # Last left reaction
+    # Left reaction at last support from the previous span
     R_sx[m] = distributed_loads[m-1] * lengths[m-1] - R_dx[m-1]
     print(f"R{m+1}_sx = {distributed_loads[m-1]} * {lengths[m-1]} - {R_dx[m-1]} = {R_sx[m]}")
 
-    # --- Key Fix: Force R_dx at the last support to always be 0 ---
-    R_dx[m] = Q_(0.0, 'newton')
-    print(f"R{m+1}_dx is forced to 0: {R_dx[m]}")
-    # --------------------------------------------------------------
+    # For a right cantilever, the right reaction is the cantilever force;
+    # otherwise it is set to zero.
+    if cantilever_right_length.magnitude > 0:
+        R_dx[m] = cantilever_right_load * cantilever_right_length
+        print(f"R{m+1}_dx = cantilever_right_load * cantilever_right_length = {R_dx[m]}")
+    else:
+        R_dx[m] = Q_(0.0, 'newton')
+        print(f"R{m+1}_dx is forced to 0: {R_dx[m]}")
 
-    # Print final summary of all reactions
+    # Print final reactions summary
     print("\nFinal Reactions Summary:")
     for i in range(n_supports):
         print(f"R{i+1}_sx = {R_sx[i]}")
@@ -242,26 +230,23 @@ def calculate_reactions(n_spans, lengths, distributed_loads, moments,
 
     return R_sx, R_dx
 
-
-
-
 def continuous_beam_solver(unit_system, n_spans, lengths_str, loads_str,
-                           cantilever_left_length_str='0', cantilever_left_load_str='0',
-                           cantilever_right_length_str='0', cantilever_right_load_str='0'):
+                             cantilever_left_length_str='0', cantilever_left_load_str='0',
+                             cantilever_right_length_str='0', cantilever_right_load_str='0'):
     # Parse the input strings into lists
     try:
         n_spans = int(n_spans)
         l_values = [float(val.strip()) for val in lengths_str.split(',')]
         p_values = [float(val.strip()) for val in loads_str.split(',')]
-        cantilever_left_length = float(cantilever_left_length_str.strip())
-        cantilever_left_load = float(cantilever_left_load_str.strip())
-        cantilever_right_length = float(cantilever_right_length_str.strip())
-        cantilever_right_load = float(cantilever_right_load_str.strip())
+        cant_left_len_val = float(cantilever_left_length_str.strip())
+        cant_left_load_val = float(cantilever_left_load_str.strip())
+        cant_right_len_val = float(cantilever_right_length_str.strip())
+        cant_right_load_val = float(cantilever_right_load_str.strip())
     except ValueError:
-        return "Invalid input. Please ensure all inputs are numbers.", "", "", "", "", ""
+        return "Invalid input. Please ensure all inputs are numbers.", "", "", "", ""
 
     if len(l_values) != n_spans or len(p_values) != n_spans:
-        return "The number of lengths and loads must match the number of spans.", "", "", "", "", ""
+        return "The number of lengths and loads must match the number of spans.", "", "", "", ""
 
     n_supports = n_spans + 1  # Total number of supports
 
@@ -286,12 +271,12 @@ def continuous_beam_solver(unit_system, n_spans, lengths_str, loads_str,
     p_SI = [load.to(u.newton / u.meter) for load in p]
 
     # Process cantilever inputs
-    cantilever_left_length = Q_(cantilever_left_length, length_unit)
-    cantilever_left_load = Q_(cantilever_left_load, load_unit)
-    cantilever_right_length = Q_(cantilever_right_length, length_unit)
-    cantilever_right_load = Q_(cantilever_right_load, load_unit)
+    cantilever_left_length = Q_(cant_left_len_val, length_unit)
+    cantilever_left_load = Q_(cant_left_load_val, load_unit)
+    cantilever_right_length = Q_(cant_right_len_val, length_unit)
+    cantilever_right_load = Q_(cant_right_load_val, load_unit)
 
-    # Convert to SI units for calculations
+    # Convert cantilever inputs to SI units for calculations
     cantilever_left_length_SI = cantilever_left_length.to(u.meter)
     cantilever_left_load_SI = cantilever_left_load.to(u.newton / u.meter)
     cantilever_right_length_SI = cantilever_right_length.to(u.meter)
@@ -303,7 +288,7 @@ def continuous_beam_solver(unit_system, n_spans, lengths_str, loads_str,
 
     # Handle single-span beam separately
     if n_spans == 1:
-        # Moments at supports A and B for a single span
+        # Cantilever moment contributions (if any)
         M_cantilever_left = 0.0
         if cantilever_left_length_SI.magnitude > 0 and cantilever_left_load_SI.magnitude != 0:
             M_cantilever_left = (cantilever_left_load_SI * cantilever_left_length_SI**2 / 2).to(u.newton * u.meter).magnitude
@@ -316,27 +301,24 @@ def continuous_beam_solver(unit_system, n_spans, lengths_str, loads_str,
         M_A = M_cantilever_left
         M_B = M_cantilever_right
 
-        # Store the moments in lists
         M_values_SI = [Q_(M_A, u.newton * u.meter), Q_(M_B, u.newton * u.meter)]
-        M_values_Imperial = [M.to(u.pound_force * u.foot) for M in M_values_SI]
+        M_values_Imperial = [M_values_SI[0].to(u.pound_force * u.foot), M_values_SI[1].to(u.pound_force * u.foot)]
 
-        # Calculate reactions
-        R_sx_SI, R_dx_SI = calculate_reactions(n_spans, l_SI, p_SI, M_values_SI)
+        # Calculate reactions+
+        f = io.StringIO()
+        with contextlib.redirect_stdout(f):
+            R_sx_SI, R_dx_SI = calculate_reactions(n_spans, l_SI, p_SI, M_values_SI)
+        reaction_log = f.getvalue()
 
-        # Convert reactions to Imperial units
         R_sx_Imperial = [R.to(u.pound_force) for R in R_sx_SI]
         R_dx_Imperial = [R.to(u.pound_force) for R in R_dx_SI]
 
-        # Prepare results
         results_SI = ""
         results_Imperial = ""
         for i in range(n_supports):
-            M_value_SI = M_values_SI[i]
-            M_value_Imperial = M_values_Imperial[i]
-            results_SI += f"M_{i+1} = {M_value_SI.magnitude:.6f} N·m\n"
-            results_Imperial += f"M_{i+1} = {M_value_Imperial.magnitude:.6f} lb·ft\n"
+            results_SI += f"M_{i+1} = {M_values_SI[i].magnitude:.6f} N·m\n"
+            results_Imperial += f"M_{i+1} = {M_values_Imperial[i].magnitude:.6f} lb·ft\n"
 
-        # Generate beam diagrams for SI and Imperial units
         beam_diagram_SI = generate_beam_diagram(
             n_spans, l, p, M_values_SI, R_sx_SI, R_dx_SI,
             cantilever_left_length=cantilever_left_length,
@@ -353,10 +335,9 @@ def continuous_beam_solver(unit_system, n_spans, lengths_str, loads_str,
             cantilever_right_load=cantilever_right_load,
             unit_system='Imperial'
         )
-
-        # There are no complex equations for the single-span beam, so leave the equations blank.
+        # For single-span, no complex equations need to be shown.
         equations_md = ""
-        return results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, equations_md, ""
+        return equations_md, results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, reaction_log
 
     # For multiple spans
     else:
@@ -369,7 +350,7 @@ def continuous_beam_solver(unit_system, n_spans, lengths_str, loads_str,
         if cantilever_right_length_SI.magnitude > 0 and cantilever_right_load_SI.magnitude != 0:
             M_cantilever_right = (cantilever_right_load_SI * cantilever_right_length_SI**2 / 2).to(u.newton * u.meter).magnitude
 
-        # Initialize moments M_i (M_1 to M_{n_supports})
+        # Initialize moments M_i (M_1 to M_n)
         M_symbols = []
         M_symbols.append(M_cantilever_left)  # M_1
 
@@ -378,42 +359,31 @@ def continuous_beam_solver(unit_system, n_spans, lengths_str, loads_str,
 
         M_symbols.append(M_cantilever_right)  # M_n
 
-        # Set up the system of equations
+        # Set up the system of equations (for supports 2 to n-1)
         equations = []
         equations_latex = []
         for k in range(1, n_supports - 1):
-            # Indices for spans and supports
-            l_prev = l_SI[k - 1].magnitude     # l_{k} in meters
-            l_curr = l_SI[k].magnitude         # l_{k+1} in meters
-            p_prev = p_SI[k - 1].magnitude     # p_{k} in N/m
-            p_curr = p_SI[k].magnitude         # p_{k+1} in N/m
-            M_prev = M_symbols[k - 1]          # M_{k}
-            M_curr = M_symbols[k]              # M_{k+1}
-            M_next = M_symbols[k + 1]          # M_{k+2}
-
-            # Left-hand side of the equation (N·m²)
-            lhs = (1/24) * (l_prev**3 * p_prev + l_curr**3 * p_curr)
+            l_prev = l_SI[k - 1].magnitude
+            l_curr = l_SI[k].magnitude
+            p_prev = p_SI[k - 1].magnitude
+            p_curr = p_SI[k].magnitude
+            M_prev = M_symbols[k - 1]
+            M_curr = M_symbols[k]
+            M_next = M_symbols[k + 1]
 
-            # Right-hand side of the equation (N·m²)
+            lhs = (1/24) * (l_prev**3 * p_prev + l_curr**3 * p_curr)
             rhs = (1/6) * (l_prev * M_prev + l_curr * M_next) + (1/3) * (l_prev + l_curr) * M_curr
-
-            # Form the equation
             equation = Eq(lhs, rhs)
             equations.append(equation)
-
-            # Convert equation to LaTeX for display
             equation_latex = f"\\frac{{1}}{{24}}(l_{{{k}}}^3 p_{{{k}}} + l_{{{k+1}}}^3 p_{{{k+1}}}) = \\frac{{1}}{{6}}(l_{{{k}}} M_{{{k}}} + l_{{{k+1}}} M_{{{k+2}}}) + \\frac{{1}}{{3}}(l_{{{k}}} + l_{{{k+1}}}) M_{{{k+1}}}"
             equations_latex.append(equation_latex)
 
-        # Solve the system of equations
-        unknown_M_symbols = [M_symbols[i] for i in range(
-            1, n_supports - 1) if isinstance(M_symbols[i], Symbol)]
-
+        # Solve the system for the unknown moments
+        unknown_M_symbols = [M_symbols[i] for i in range(1, n_supports - 1) if isinstance(M_symbols[i], Symbol)]
         solution = solve(equations, unknown_M_symbols, dict=True)
 
-        # Prepare results and collect moments for diagrams
         if solution:
-            solution = solution[0]  # Extract the solution dictionary
+            solution = solution[0]
             results_SI = ""
             results_Imperial = ""
             M_values_SI = []
@@ -424,26 +394,28 @@ def continuous_beam_solver(unit_system, n_spans, lengths_str, loads_str,
                     M_i_value = float(solution.get(M_i_value, 0))
                 else:
                     M_i_value = float(M_i_value)
-
-                # SI Units
                 M_quantity_SI = Q_(M_i_value, u.newton * u.meter)
                 M_values_SI.append(M_quantity_SI)
                 results_SI += f"M_{i+1} = {M_quantity_SI.magnitude:.6f} N·m\n"
-                # Imperial Units
                 M_quantity_Imperial = M_quantity_SI.to(u.pound_force * u.foot)
                 M_values_Imperial.append(M_quantity_Imperial)
                 results_Imperial += f"M_{i+1} = {M_quantity_Imperial.magnitude:.6f} lb·ft\n"
         else:
-            return "No solution found.", "", "", "", "", ""
+            return "No solution found.", "", "", "", ""
 
         # Calculate reactions
-        R_sx_SI, R_dx_SI = calculate_reactions(n_spans, l_SI, p_SI, M_values_SI)
+        f = io.StringIO()
+        with contextlib.redirect_stdout(f):
+            R_sx_SI, R_dx_SI = calculate_reactions(n_spans, l_SI, p_SI, M_values_SI,
+                                                    cantilever_left_length=cantilever_left_length_SI,
+                                                    cantilever_left_load=cantilever_left_load_SI,
+                                                    cantilever_right_length=cantilever_right_length_SI,
+                                                    cantilever_right_load=cantilever_right_load_SI)
+        reaction_log = f.getvalue()
 
-        # Convert reactions to Imperial units
         R_sx_Imperial = [R.to(u.pound_force) for R in R_sx_SI]
         R_dx_Imperial = [R.to(u.pound_force) for R in R_dx_SI]
 
-        # Generate beam diagrams
         beam_diagram_SI = generate_beam_diagram(
             n_spans, l, p, M_values_SI, R_sx_SI, R_dx_SI,
             cantilever_left_length=cantilever_left_length,
@@ -459,50 +431,66 @@ def continuous_beam_solver(unit_system, n_spans, lengths_str, loads_str,
             cantilever_right_load=cantilever_right_load,
             unit_system='Imperial')
 
-        # Prepare equations in LaTeX
         equations_md = "\n\n".join(
-            [f"**Equation {i+1}:**\n\n$$ {eq} $$" for i, eq in enumerate(equations_latex)])
+            [f"**Equation {i+1}:**\n\n$$ {eq} $$" for i, eq in enumerate(equations_latex)]
+        )
+        return equations_md, results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, reaction_log
 
-        return results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, equations_md, ""
 
+        
 
 def gradio_interface(unit_system, n_spans, lengths_str, loads_str,
                      cantilever_left_length, cantilever_left_load,
                      cantilever_right_length, cantilever_right_load):
-    # Call continuous beam solver to get results
-    results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, equations_md, pdf_filename = continuous_beam_solver(
+    # Call the continuous beam solver to obtain all outputs including the reaction log.
+    (equations_md, results_SI, results_Imperial,
+     beam_diagram_SI, beam_diagram_Imperial, reaction_log) = continuous_beam_solver(
         unit_system, n_spans, lengths_str, loads_str,
         cantilever_left_length, cantilever_left_load,
         cantilever_right_length, cantilever_right_load)
+    # Return outputs in the new order: equations, moments, diagrams, and then the reaction log.
+    return equations_md, results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, reaction_log
 
-    return results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, equations_md
 
+# Build the Gradio interface.
+# Note that the input labels now indicate the expected units.
 iface = gr.Interface(
     fn=gradio_interface,
     inputs=[
         gr.Radio(['SI', 'Imperial'], label="Unit System", value='SI'),
         gr.Number(label="Number of Spans (n)", value=3, precision=0),
-        gr.Textbox(label="Lengths l_i (comma-separated)", placeholder="e.g., 5, 5, 5", value='7.91667,7.91667,7.91667'),
-        gr.Textbox(label="Loads p_i (comma-separated)", placeholder="e.g., 10000, 10000, 10000", value='200,200,200'),
-        gr.Textbox(label="Cantilever Left Length", placeholder="e.g., 2.0", value='6.66667'),
-        gr.Textbox(label="Cantilever Left Load", placeholder="e.g., 5000", value='200'),
-        gr.Textbox(label="Cantilever Right Length", placeholder="e.g., 0", value='6.66667'),
-        gr.Textbox(label="Cantilever Right Load", placeholder="e.g., 0", value='200'),
+        gr.Textbox(label="Lengths l_i (comma-separated) [m (SI) or ft (Imperial)]", 
+                   placeholder="e.g., 7.92, 7.92, 7.92", value='7.91667,7.91667,7.91667'),
+        gr.Textbox(label="Loads p_i (comma-separated) [N/m (SI) or lb/ft (Imperial)]", 
+                   placeholder="e.g., 200,200,200", value='200,200,200'),
+        gr.Textbox(label="Cantilever Left Length [m (SI) or ft (Imperial)]", 
+                   placeholder="e.g., 6.67", value='6.66667'),
+        gr.Textbox(label="Cantilever Left Load [N/m (SI) or lb/ft (Imperial)]", 
+                   placeholder="e.g., 200", value='200'),
+        gr.Textbox(label="Cantilever Right Length [m (SI) or ft (Imperial)]", 
+                   placeholder="e.g., 6.67", value='6.66667'),
+        gr.Textbox(label="Cantilever Right Load [N/m (SI) or lb/ft (Imperial)]", 
+                   placeholder="e.g., 200", value='200'),
     ],
     outputs=[
+        gr.Markdown(label="Equations Used"),
         gr.Textbox(label="Internal Moments at Supports (SI Units)"),
         gr.Textbox(label="Internal Moments at Supports (Imperial Units)"),
         gr.HTML(label="Beam Diagram (SI Units)"),
         gr.HTML(label="Beam Diagram (Imperial Units)"),
-        gr.Markdown(label="Equations Used")
+        gr.Textbox(label="Reactions Calculation Log"),
     ],
     title="Continuous Beam Solver with Cantilevers",
-    description="Solve for internal moments at supports of a continuous beam with multiple spans, including cantilevers.\n"
-                "Select the unit system for input. The results will be displayed in both SI and Imperial units.\n\n"
-                "The beam diagrams and equations used will be displayed below.",
+    description=(
+        "Solve for internal moments at supports of a continuous beam with multiple spans, including cantilevers.\n\n"
+        "**Input Units:**\n"
+        "- For SI: Lengths in meters (m), Loads in Newtons per meter (N/m), Moments in N·m, Reaction forces in N.\n"
+        "- For Imperial: Lengths in feet (ft), Loads in pounds per foot (lb/ft), Moments in lb·ft, Reaction forces in lb.\n\n"
+        "The outputs are arranged with the equations on top, followed by the resulting internal moments, "
+        "then the beam diagram, and finally the complete reaction calculation log."
+    ),
     allow_flagging="never",
 )
 
-
 if __name__ == "__main__":
-    iface.launch()
+    iface.launch()