Upload 16 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Dump/solution_breakdown.pdf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,57 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+.venv/
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Database
+*.db
+*.sqlite3
+
+# OS
+.DS_Store
+Thumbs.db
+Desktop.ini
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# Distribution
+*.manifest
+*.spec
+
+# Logs
+*.log

Dump/example_4_1.tex

@@ -0,0 +1,212 @@
+\documentclass[12pt, letterpaper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{geometry}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{graphicx}
+\usepackage{tikz}
+\usetikzlibrary{positioning,arrows.meta,calc}
+\usepackage{siunitx}
+\usepackage{fancyhdr}
+\usepackage{parskip}
+
+% Geometry settings
+\geometry{margin=1in}
+
+% Header and Footer
+\pagestyle{fancy}
+\fancyhf{}
+\rhead{Example 4-1}
+\lhead{Nominal Moment Strength Calculation}
+\cfoot{\thepage}
+
+\title{\textbf{Example 4-1: Nominal Moment Strength Calculation for a Singly Reinforced Concrete Beam}}
+\author{}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+\section*{Introduction}
+This document provides a detailed, step-by-step breakdown of the example problem (referenced as Fig. 4-19a). The goal is to calculate the nominal moment strength $M_n$ for the beam and confirm that the area of tension steel exceeds the required minimum steel area as per Equation (4-11) from the relevant design code (specifically ACI 318). All calculations are performed without skipping any micro-steps, including unit conversions and intermediate arithmetic operations.
+
+\textbf{Problem statement (paraphrased from the provided excerpt).} The task is to compute $M_n$ for the singly reinforced beam and verify that the provided tension reinforcement area exceeds the minimum required by code.
+
+\textbf{Source excerpt (short quote).} ``Calculate $M_n$ and confirm that the area of tension steel exceeds the required minimum steel area.''
+
+\begin{figure}[h]
+\centering
+\begin{tikzpicture}[
+  font=\small,
+  dim/.style={-Latex, thin},
+  outline/.style={draw, line width=0.8pt},
+  bar/.style={fill=black, draw=black},
+  note/.style={font=\scriptsize}
+]
+
+% Parameters (in cm for drawing convenience)
+% Use a simple scale: 12 in -> 6 cm, 20 in -> 10 cm
+\def\W{6}
+\def\H{10}
+\def\cover{1.25} % corresponds to 2.5 in in this scale
+
+% Concrete section
+\draw[outline] (0,0) rectangle (\W,\H);
+
+% Bars (4 No. 8) near the bottom
+\foreach \x in {1.2,2.4,3.6,4.8} {
+  \draw[bar] (\x,\cover) circle (0.12);
+}
+
+% Dimension: height 20 in
+\draw[dim] (-0.8,0) -- (-0.8,\H);
+\draw[outline] (-0.9,0) -- (-0.7,0);
+\draw[outline] (-0.9,\H) -- (-0.7,\H);
+\node[rotate=90] at (-1.2,\H/2) {20 in.};
+
+% Dimension: width 12 in
+\draw[dim] (0,-0.8) -- (\W,-0.8);
+\draw[outline] (0,-0.9) -- (0,-0.7);
+\draw[outline] (\W,-0.9) -- (\W,-0.7);
+\node at (\W/2,-1.2) {12 in.};
+
+% Dimension: 2.5 in to steel layer (approx)
+\draw[dim] (\W+0.8,0) -- (\W+0.8,\cover);
+\draw[outline] (\W+0.7,0) -- (\W+0.9,0);
+\draw[outline] (\W+0.7,\cover) -- (\W+0.9,\cover);
+\node[rotate=90] at (\W+1.2,\cover/2) {2.5 in.};
+
+% Label bars
+\node[note] at (\W/2,\cover+0.6) {4 No. 8 bars};
+
+\end{tikzpicture}
+\caption{Beam cross-section used in Example 4-1 (redrawn from the provided image).}
+\label{fig:beam-4-19a-redraw}
+\end{figure}
+
+The beam is a rectangular section made of concrete with compressive strength $f'_c = 4000$ psi, reinforced with four No. 8 bars in tension having yield strength $f_y = 60$ ksi. The beam dimensions are width $b = 12$ in. and total height $h = 20$ in. The effective depth $d$ is approximated as $h - 2.5$ in. to account for concrete cover, stirrup diameter, and half the longitudinal bar diameter.
+
+\section*{Given Data}
+\begin{itemize}
+    \item \textbf{Concrete compressive strength:} $f'_c = 4000$ psi
+    \item \textbf{Steel yield strength:} $f_y = 60$ ksi = $60,000$ psi
+    \item \textbf{Beam width:} $b = 12$ in.
+    \item \textbf{Beam total height:} $h = 20$ in.
+    \item \textbf{Effective depth (assumed):} $d = h - 2.5 = 20 - 2.5 = 17.5$ in.
+    \item \textbf{Tension reinforcement:} 4 No. 8 bars
+    \item \textbf{Diameter of No. 8 bar:} 1.0 in. (standard ASTM A615/A706 bar size)
+    \item \textbf{Area of one No. 8 bar (tabulated):} $A_{bar} = 0.79\ \text{in}^2$.
+    \item \textbf{Total tension steel area:} 
+    \[
+    A_s = 4 \times 0.79 = 3.16 \text{ in}^2
+    \]
+    \item \textbf{Compression reinforcement:} Ignored (not designed for compression resistance).
+    \item \textbf{Rectangular stress block factor:} $\beta_1 = 0.85$ (for $f'_c = 4000$ psi).
+    \item \textbf{Minimum steel area rule:} $A_{s,min} = \max\left( \frac{3\sqrt{f'_c}}{f_y} bd, \frac{200}{f_y} bd \right)$
+\end{itemize}
+
+\textbf{Note on Effective Depth $d$:} The approximation of 2.5 in. accounts for:
+\begin{itemize}
+    \item Clear concrete cover: 1.5 in.
+    \item Stirrup diameter: $\approx 0.5$ in.
+    \item Half the longitudinal bar diameter: 0.5 in.
+\end{itemize}
+Total: $1.5 + 0.5 + 0.5 = 2.5$ in.
+
+\section*{Step 1: Confirm Tension Steel Area Exceeds Minimum Required}
+
+\subsection*{Step 1.1: Calculate $\rho_{min}$ Using Equation (4-11)}
+The minimum reinforcement ratio $\rho_{min}$ is the maximum of two values:
+\begin{enumerate}
+    \item $\frac{3 \sqrt{f'_c}}{f_y}$
+    \item $\frac{200}{f_y}$ (in psi units)
+\end{enumerate}
+
+\subsubsection*{Micro-Calculation for First Term: $\frac{3 \sqrt{f'_c}}{f_y}$}
+\begin{itemize}
+    \item Calculate $\sqrt{f'_c} = \sqrt{4000} \approx 63.2456$.
+    \item $3 \times 63.2456 = 189.7368$.
+    \item $\frac{189.7368}{60,000} = 0.00316228$.
+\end{itemize}
+
+\subsubsection*{Micro-Calculation for Second Term: $\frac{200}{f_y}$}
+\[
+\frac{200}{60,000} = 0.00333333
+\]
+
+\subsubsection*{Select $\rho_{min}$}
+\[
+\rho_{min} = \max(0.00316228, 0.00333333) = 0.00333333
+\]
+
+\subsection*{Step 1.2: Calculate Minimum Steel Area $A_{s,min}$}
+\[
+A_{s,min} = \rho_{min} \times b \times d
+\]
+\begin{itemize}
+    \item $b \times d = 12 \times 17.5 = 210 \text{ in}^2$
+    \item $A_{s,min} = 0.00333333 \times 210 = 0.6999993 \approx 0.70 \text{ in}^2$
+\end{itemize}
+
+\subsection*{Step 1.3: Compare Actual $A_s$ with $A_{s,min}$}
+\begin{itemize}
+    \item Actual $A_s = 3.16 \text{ in}^2$.
+    \item Since $3.16 > 0.70$, the tension steel area exceeds the minimum required.
+    \item Reinforcement ratio $\rho = \frac{A_s}{b d} = \frac{3.16}{210} = 0.015048$, which is greater than $\rho_{min} = 0.003333$.
+\end{itemize}
+
+\section*{Step 2: Calculate Nominal Moment Strength $M_n$}
+
+For a singly reinforced beam, utilizing the rectangular stress block assumption (Whitney block):
+\[
+M_n = A_s f_y \left( d - \frac{a}{2} \right)
+\]
+where $a$ is the depth of the equivalent rectangular stress block:
+\[
+a = \frac{A_s f_y}{0.85 f'_c b}
+\]
+
+\subsection*{Step 2.1: Calculate Depth of Stress Block $a$}
+
+\subsubsection*{Micro-Calculation for Numerator: $A_s f_y$}
+\[
+A_s f_y = 3.16 \times 60,000 = 189,600 \text{ lb}
+\]
+
+\subsubsection*{Micro-Calculation for Denominator: $0.85 f'_c b$}
+\[
+0.85 \times 4000 \times 12 = 3,400 \times 12 = 40,800 \text{ lb/in}
+\]
+
+\subsubsection*{Calculate $a$}
+\[\na = \frac{189,600}{40,800} \approx 4.6471 \text{ in.}\n\]
+
+\subsection*{Step 2.2: Calculate Lever Arm $d - \frac{a}{2}$}
+\begin{itemize}
+    \item $\frac{a}{2} = \frac{4.6471}{2} = 2.3236$ in.
+    \item $d - \frac{a}{2} = 17.5 - 2.3236 = 15.1764$ in.
+\end{itemize}
+
+\subsection*{Step 2.3: Calculate $M_n$ in in.-lb}
+\[
+M_n = 189,600 \times 15.1764 = 2,877,445.44 \text{ in.-lb}
+\]
+
+\subsection*{Step 2.4: Convert $M_n$ to ft-kip}
+\begin{itemize}
+    \item Convert to ft-lb (divide by 12): $2,877,445.44 / 12 = 239,787.12 \text{ ft-lb}$.
+    \item Convert to ft-kip (divide by 1000): $239,787.12 / 1000 = 239.78712 \text{ ft-kip}$.
+    \item Rounded: \textbf{240 ft-kip}.
+\end{itemize}
+
+\section*{Step 3: Verify Assumptions and Additional Notes}
+
+\begin{itemize}
+    \item \textbf{Strain compatibility (qualitative check):} The section is expected to be under-reinforced because the provided steel ratio ($\rho \approx 0.015$) is modest for the given section; thus tension steel yielding is the likely controlling behavior for this example.
+    \item \textbf{Compression Zone Bars:} Ignored as per problem statement.
+    \item \textbf{Accuracy of $d$:} The 2.5 in. assumption is sufficient. Using a No. 3 stirrup would result in $d \approx 17.625$ in., slightly increasing capacity, but 2.5 is conservative/standard for this example.
+    \item \textbf{Units:} All consistency checks passed.
+\end{itemize}
+
+\end{document}

Dump/solution_breakdown.md

@@ -0,0 +1,107 @@
+# Solution Breakdown: RecrBeam Calculator
+
+This document details the **RecrBeam Calculator**, a software solution designed to solve the concrete beam design problem described in **Example 4-1**. It bridges the gap between the theoretical engineering calculations and the Python-based application mechanics.
+
+---
+
+## 1. Theoretical Foundation (Example 4-1)
+
+The core engineering problem is to calculate the **Nominal Moment Strength ($M_n$)** of a singly reinforced concrete beam.
+
+### Problem Statement
+Given a rectangular beam with the following properties:
+*   **Dimensions**: Width ($b$) = 12 in, Total Height ($h$) = 20 in.
+*   **Effective Depth**: $d \approx 17.5$ in (Derived from $h - 2.5$).
+*   **Materials**: 
+    *   Concrete Strength ($f'_c$) = 4000 psi.
+    *   Steel Yield Strength ($f_y$) = 60000 psi.
+*   **Reinforcement**: 4 No. 8 bars.
+    *   Area of one No. 8 bar = 0.79 in².
+    *   Total Area ($A_s$) = $4 \times 0.79 = 3.16$ in².
+
+**Goal**: Calculate $M_n$ and verify $A_s > A_{s,min}$.
+
+### Manual Calculation Steps
+
+#### Step 1: Verify Minimum Steel
+The code requires $A_s$ to exceed $A_{s,min}$.
+$$ \rho_{min} = \max\left( \frac{3\sqrt{f'_c}}{f_y}, \frac{200}{f_y} \right) $$
+*   $\frac{3\sqrt{4000}}{60000} \approx 0.00316$
+*   $\frac{200}{60000} \approx 0.00333$ (Governs)
+
+$$ A_{s,min} = \rho_{min} \cdot b \cdot d = 0.00333 \cdot 12 \cdot 17.5 = 0.70 \text{ in}^2 $$
+**Result**: $3.16 > 0.70$ (OK).
+
+#### Step 2: Calculate Depth of Stress Block ($a$)
+$$ a = \frac{A_s f_y}{0.85 f'_c b} $$
+$$ a = \frac{3.16 \cdot 60000}{0.85 \cdot 4000 \cdot 12} = \frac{189,600}{40,800} \approx 4.647 \text{ in} $$
+
+#### Step 3: Calculate Nominal Moment ($M_n$)
+$$ M_n = A_s f_y \left( d - \frac{a}{2} \right) $$
+*   Lever Arm: $d - a/2 = 17.5 - 2.3235 = 15.1765$ in.
+*   $M_n = 189,600 \text{ lb} \cdot 15.1765 \text{ in} = 2,877,464 \text{ lb-in}$
+*   Convert to k-ft: $2,877,464 / 12 / 1000 \approx \textbf{239.79 k-ft}$
+
+---
+
+## 2. Application Mechanics
+
+The software implementation automates the above logic using Python.
+
+### Core Logic: `calculator.py`
+The `RectangularBeam` class mimics the manual steps.
+
+```python
+class RectangularBeam:
+    def calculate_mn(self):
+        # 1. Compute 'a' (Matches Step 2 above)
+        # a = (As * fy) / (0.85 * fc * b)
+        a = (self.As * self.fy) / (0.85 * self.fc * self.b)
+        
+        # 2. Compute Nominal Moment Mn (Matches Step 3 above)
+        # Mn = As * fy * (d - a/2)
+        Mn_force = self.As * self.fy 
+        arm = self.d - (a / 2)
+        Mn_kin = Mn_force * arm 
+        
+        # ... Conversions to k-ft
+```
+
+### Validation: `test_calculator.py`
+The unit test acts as proof that the software aligns with the theory. It explicitly uses the Example 4-1 values as the "Golden Record".
+
+```python
+def test_example_4_19a(self):
+    # Inputs from Example 4-1
+    beam = RectangularBeam(
+        width=12.0, effective_depth=17.5,
+        f_c=4000.0, f_y=60000.0, rebar_area=3.16
+    )
+    results = beam.calculate_mn()
+    
+    # Assert correctness within tolerance
+    self.assertAlmostEqual(results['a'], 4.647, delta=0.01)
+    self.assertAlmostEqual(results['Mn_kft'], 239.79, delta=0.5)
+```
+
+### User Interface: `app.py`
+The Streamlit app provides an interactive layer:
+*   **Inputs**: Sidebar allows modifying $b, h, f'_c, f_y$ and bar sizes.
+*   **Visualization**: Uses `matplotlib` to draw the cross-section (showing $b, h, d$ and rebar placement).
+*   **Math Rendering**: Uses `st.latex` to display the equations dynamically, showing students exactly how inputs flow into the formula.
+    ```python
+    st.latex(fr"M_n = {As_total:.2f} \cdot {fy} \left({d:.2f} - \frac{{{results['a']:.3f}}}{{2}}\right)")
+    ```
+
+### Data Resilience: `db_manager.py`
+*   **History**: Every calculation can be saved to a local SQLite database (`beam_calc.db`).
+*   **Persistence**: Enables review of past design iterations.
+
+---
+
+## 3. Conclusion
+
+The **RecrBeam Calculator** is a faithful digital twin of the manual engineering process defined in ACI 318.
+*   **Input**: Manual engineering parameters.
+*   **Process**: Standard Whitney Stress Block methodology (`calculator.py`).
+*   **Output**: Verified against text book examples (`test_calculator.py`).

Dump/solution_breakdown.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4d7c4ed55a03ce2c7d443840f50f4de7e424740ecf5d16f911b3a03fb3d776f
+size 150837

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 callmerem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MATLAB/app.m

@@ -0,0 +1,651 @@
+classdef BeamAnalysisApp < matlab.apps.AppBase
+    % BeamAnalysisApp - Interactive Analysis of Nominal Moment Strength (Mn)
+    % Based on Example 4-1 and 4-1M from ACI 318 Provisions
+    %
+    % Variables from Example:
+    %   fc' - Concrete compressive strength
+    %   fy  - Steel yield strength
+    %   Es  - Modulus of elasticity of steel
+    %   b   - Beam width
+    %   h   - Total beam depth
+    %   d   - Effective depth (to centroid of tension steel)
+    %   As  - Total area of tension steel
+    %   beta1 - Stress block factor (0.85 for fc' <= 4000 psi)
+    %   epsilon_cu - Ultimate concrete strain (0.003)
+    %
+    % Calculated:
+    %   T       - Tension force in steel
+    %   a       - Depth of equivalent stress block
+    %   c       - Neutral axis depth
+    %   epsilon_y - Yield strain of steel
+    %   epsilon_s - Strain in steel at ultimate
+    %   Mn      - Nominal moment strength
+    %   As_min  - Minimum steel area per ACI
+
+    properties (Access = public)
+        UIFigure      matlab.ui.Figure
+        MainGrid      matlab.ui.container.GridLayout
+        
+        % Panels
+        InputPanel    matlab.ui.container.Panel
+        DiagramPanel  matlab.ui.container.Panel
+        ResultsPanel  matlab.ui.container.Panel
+        EquationsPanel matlab.ui.container.Panel
+        
+        % Inputs - Material
+        UnitSwitch    matlab.ui.control.Switch
+        EditFc        matlab.ui.control.NumericEditField
+        EditFy        matlab.ui.control.NumericEditField
+        EditEs        matlab.ui.control.NumericEditField
+        EditBeta1     matlab.ui.control.NumericEditField
+        EditEpsCu     matlab.ui.control.NumericEditField
+        
+        % Inputs - Geometry
+        EditB         matlab.ui.control.NumericEditField
+        EditH         matlab.ui.control.NumericEditField
+        EditD         matlab.ui.control.NumericEditField
+        
+        % Inputs - Reinforcement
+        EditBars      matlab.ui.control.NumericEditField
+        EditBarArea   matlab.ui.control.NumericEditField
+        
+        % Visualization Axes
+        AxSection     matlab.ui.control.UIAxes
+        AxStrain      matlab.ui.control.UIAxes
+        AxStress      matlab.ui.control.UIAxes
+        AxEquations   matlab.ui.control.UIAxes
+        
+        % Results
+        ResultsText   matlab.ui.control.TextArea
+    end
+
+    properties (Access = private)
+        Units struct
+        % Color scheme
+        Colors struct
+    end
+
+    methods (Access = private)
+
+        function updateApp(app, ~)
+            % === 1. GET INPUTS ===
+            is_imperial = strcmp(app.UnitSwitch.Value, 'Imperial');
+            
+            fc = app.EditFc.Value;
+            fy = app.EditFy.Value;
+            Es = app.EditEs.Value;
+            beta1 = app.EditBeta1.Value;
+            epsilon_cu = app.EditEpsCu.Value;
+            b  = app.EditB.Value;
+            h  = app.EditH.Value;
+            d  = app.EditD.Value;
+            n_bars = app.EditBars.Value;
+            bar_A  = app.EditBarArea.Value;
+            As = n_bars * bar_A;
+
+            % Set units
+            if is_imperial
+                app.Units = struct('len', 'in', 'area', 'in2', 'force', 'lb', ...
+                    'stress', 'psi', 'moment', 'lb-in', 'moment_k', 'k-in', 'moment_alt', 'k-ft');
+            else
+                app.Units = struct('len', 'mm', 'area', 'mm2', 'force', 'N', ...
+                    'stress', 'MPa', 'moment', 'N-mm', 'moment_k', 'N-mm', 'moment_alt', 'kN-m');
+            end
+            u = app.Units;
+            clr = app.Colors;
+
+            % === 2. CALCULATIONS ===
+            T = As * fy;
+            a = (As * fy) / (0.85 * fc * b);
+            c = a / beta1;
+            epsilon_y = fy / Es;
+            epsilon_s = epsilon_cu * (d - c) / c;
+            
+            if epsilon_s >= epsilon_y
+                yield_check = true;
+                fs = fy;
+            else
+                yield_check = false;
+                fs = epsilon_s * Es;
+            end
+            
+            Mn = As * fs * (d - a/2);
+            
+            if is_imperial
+                Mn_disp = Mn / 12000;
+                T_disp = T / 1000;
+                Mn_k = Mn / 1000;
+            else
+                Mn_disp = Mn / 1e6;
+                T_disp = T / 1000;
+                Mn_k = Mn;
+            end
+
+            if is_imperial
+                term1 = (3 * sqrt(fc) / fy) * b * d;
+                term2 = (200 / fy) * b * d;
+            else
+                term1 = (0.25 * sqrt(fc) / fy) * b * d;
+                term2 = (1.4 / fy) * b * d;
+            end
+            As_min = max(term1, term2);
+            As_check = As >= As_min;
+            
+            % === 3. CROSS SECTION DIAGRAM ===
+            ax = app.AxSection;
+            cla(ax); hold(ax, 'on');
+            
+            % Concrete beam
+            rectangle(ax, 'Position', [0, 0, b, h], ...
+                'FaceColor', clr.concrete, 'EdgeColor', clr.outline, 'LineWidth', 1.5);
+            
+            % Compression zone
+            patch(ax, [0, b, b, 0], [h, h, h-a, h-a], clr.compression, ...
+                'EdgeColor', 'none', 'FaceAlpha', 0.6);
+            
+            % Neutral axis line
+            plot(ax, [0, b], [h-c, h-c], '--', 'Color', clr.neutral, 'LineWidth', 1.2);
+            
+            % Steel bars
+            bar_r = sqrt(bar_A/pi) * 0.7;
+            steel_y = h - d;
+            if n_bars == 1
+                cx = b/2;
+            else
+                cx = linspace(b*0.12, b*0.88, n_bars);
+            end
+            for i = 1:n_bars
+                rectangle(ax, 'Position', [cx(i)-bar_r, steel_y-bar_r, 2*bar_r, 2*bar_r], ...
+                    'FaceColor', clr.steel, 'EdgeColor', [0.1 0.1 0.1], 'Curvature', [1 1], 'LineWidth', 0.5);
+            end
+            
+            % Dimension: h
+            xh = b + b*0.08;
+            plot(ax, [xh, xh], [0, h], 'k-', 'LineWidth', 0.8);
+            plot(ax, [b, xh+b*0.02], [0, 0], 'k-', 'LineWidth', 0.8);
+            plot(ax, [b, xh+b*0.02], [h, h], 'k-', 'LineWidth', 0.8);
+            text(ax, xh+b*0.04, h/2, sprintf('h=%.1f', h), 'FontSize', 9, 'FontName', 'Arial');
+            
+            % Dimension: d
+            xd = b + b*0.22;
+            plot(ax, [xd, xd], [steel_y, h], 'Color', clr.dimension, 'LineWidth', 0.8);
+            text(ax, xd+b*0.04, (h+steel_y)/2, sprintf('d=%.1f', d), 'FontSize', 9, 'Color', clr.dimension, 'FontName', 'Arial');
+            
+            % Dimension: a
+            xa = -b*0.08;
+            plot(ax, [xa, xa], [h-a, h], 'Color', clr.compression_line, 'LineWidth', 1.5);
+            text(ax, xa-b*0.15, h-a/2, sprintf('a=%.2f', a), 'FontSize', 9, 'Color', clr.compression_line, 'FontName', 'Arial');
+            
+            % Dimension: b
+            text(ax, b/2, -h*0.06, sprintf('b=%.1f', b), 'HorizontalAlignment', 'center', 'FontSize', 9, 'FontName', 'Arial');
+            
+            % c label (neutral axis depth)
+            text(ax, b+b*0.04, h-c, sprintf('c=%.2f', c), 'FontSize', 8, 'Color', clr.neutral, 'FontName', 'Arial');
+            
+            axis(ax, 'equal');
+            ax.XLim = [-b*0.25, b*1.4];
+            ax.YLim = [-h*0.12, h*1.08];
+            ax.XTick = []; ax.YTick = [];
+            ax.XColor = 'none'; ax.YColor = 'none';
+            title(ax, 'Cross Section', 'FontWeight', 'bold', 'FontSize', 11, 'FontName', 'Arial');
+            
+            % === 4. STRAIN DIAGRAM ===
+            ax = app.AxStrain;
+            cla(ax); hold(ax, 'on');
+            
+            strain_w = 0.4;
+            
+            % Beam outline (reference)
+            plot(ax, [0, 0], [0, h], 'Color', [0.7 0.7 0.7], 'LineWidth', 1);
+            
+            % Strain profile fill
+            x_top = epsilon_cu * strain_w / 0.003;
+            x_bot = epsilon_s * strain_w / 0.003;
+            patch(ax, [0, x_top, x_bot, 0], [h, h, steel_y, steel_y], clr.strain, ...
+                'EdgeColor', clr.strain_edge, 'LineWidth', 1.2, 'FaceAlpha', 0.5);
+            
+            % Neutral axis
+            plot(ax, [-0.05, strain_w*1.2], [h-c, h-c], '--', 'Color', clr.neutral, 'LineWidth', 1);
+            text(ax, -0.03, h-c, sprintf('c=%.2f', c), 'FontSize', 8, 'HorizontalAlignment', 'right', 'Color', clr.neutral, 'FontName', 'Arial');
+            
+            % Labels
+            text(ax, x_top+0.02, h, sprintf('ecu=%.4f', epsilon_cu), 'FontSize', 9, 'Color', clr.strain_edge, 'FontName', 'Arial');
+            text(ax, x_bot+0.02, steel_y, sprintf('es=%.5f', epsilon_s), 'FontSize', 9, 'Color', clr.strain_edge, 'FontName', 'Arial');
+            
+            ax.XLim = [-0.1, strain_w*1.5];
+            ax.YLim = [-h*0.12, h*1.08];
+            ax.XTick = []; ax.YTick = [];
+            ax.XColor = 'none'; ax.YColor = 'none';
+            title(ax, 'Strain Distribution', 'FontWeight', 'bold', 'FontSize', 11, 'FontName', 'Arial');
+            
+            % === 5. STRESS/FORCE DIAGRAM ===
+            ax = app.AxStress;
+            cla(ax); hold(ax, 'on');
+            
+            stress_w = 0.5;
+            
+            % Compression block
+            patch(ax, [0, stress_w, stress_w, 0], [h, h, h-a, h-a], clr.compression, ...
+                'EdgeColor', clr.compression_line, 'LineWidth', 1.2, 'FaceAlpha', 0.7);
+            text(ax, stress_w/2, h-a/2, '0.85fc''', 'HorizontalAlignment', 'center', 'FontSize', 9, 'FontName', 'Arial');
+            
+            % Compression force arrow
+            quiver(ax, stress_w+0.05, h-a/2, 0.2, 0, 0, 'Color', clr.compression_line, 'LineWidth', 2, 'MaxHeadSize', 0.8);
+            text(ax, stress_w+0.28, h-a/2, sprintf('C=%.0f k', T_disp), 'FontSize', 9, 'Color', clr.compression_line, 'FontName', 'Arial');
+            
+            % Steel location
+            plot(ax, [0, stress_w*0.3], [steel_y, steel_y], 'Color', clr.steel, 'LineWidth', 2);
+            
+            % Tension force arrow
+            quiver(ax, 0, steel_y, 0.25, 0, 0, 'Color', clr.tension, 'LineWidth', 2, 'MaxHeadSize', 0.8);
+            text(ax, 0.28, steel_y, sprintf('T=%.0f k', T_disp), 'FontSize', 9, 'Color', clr.tension, 'FontName', 'Arial');
+            
+            % Neutral axis
+            plot(ax, [-0.05, stress_w+0.3], [h-c, h-c], '--', 'Color', clr.neutral, 'LineWidth', 1);
+            
+            % Moment arm
+            xa_arm = stress_w + 0.45;
+            plot(ax, [xa_arm, xa_arm], [h-a/2, steel_y], 'Color', clr.moment_arm, 'LineWidth', 1.5);
+            plot(ax, [xa_arm-0.02, xa_arm+0.02], [h-a/2, h-a/2], 'Color', clr.moment_arm, 'LineWidth', 1.5);
+            plot(ax, [xa_arm-0.02, xa_arm+0.02], [steel_y, steel_y], 'Color', clr.moment_arm, 'LineWidth', 1.5);
+            text(ax, xa_arm+0.03, (h-a/2+steel_y)/2, 'd-a/2', 'FontSize', 9, 'Color', clr.moment_arm, 'FontName', 'Arial');
+            
+            ax.XLim = [-0.1, stress_w+0.65];
+            ax.YLim = [-h*0.12, h*1.08];
+            ax.XTick = []; ax.YTick = [];
+            ax.XColor = 'none'; ax.YColor = 'none';
+            title(ax, 'Stress Block & Forces', 'FontWeight', 'bold', 'FontSize', 11, 'FontName', 'Arial');
+            
+            % === 6. EQUATIONS PANEL ===
+            ax = app.AxEquations;
+            cla(ax); hold(ax, 'on');
+            axis(ax, 'off');
+            ax.XLim = [0 1]; ax.YLim = [0 1];
+            
+            y = 0.92; 
+            dy = 0.115;
+            fs = 10;
+            
+            % Header
+            text(ax, 0.01, y, 'STEP-BY-STEP CALCULATIONS', 'FontWeight', 'bold', 'FontSize', 12, 'FontName', 'Arial');
+            y = y - dy*0.7;
+            
+            % Step 1
+            eq1 = sprintf('$$A_s = n \\times A_{bar} = %.0f \\times %.3f = %.3f \\; \\mathrm{%s}$$', n_bars, bar_A, As, u.area);
+            text(ax, 0.01, y, eq1, 'Interpreter', 'latex', 'FontSize', fs);
+            y = y - dy*0.6;
+            
+            eq2 = sprintf('$$T = A_s \\cdot f_y = %.3f \\times %.0f = %.0f \\; \\mathrm{%s} \\;\\; (%.1f \\; \\mathrm{kips})$$', As, fy, T, u.force, T_disp);
+            text(ax, 0.01, y, eq2, 'Interpreter', 'latex', 'FontSize', fs);
+            y = y - dy;
+            
+            % Step 2
+            eq3 = sprintf('$$a = \\frac{A_s f_y}{0.85 f''_c b} = \\frac{%.0f}{0.85 \\times %.0f \\times %.1f} = %.4f \\; \\mathrm{%s}$$', T, fc, b, a, u.len);
+            text(ax, 0.01, y, eq3, 'Interpreter', 'latex', 'FontSize', fs);
+            y = y - dy*0.6;
+            
+            eq4 = sprintf('$$c = \\frac{a}{\\beta_1} = \\frac{%.4f}{%.3f} = %.4f \\; \\mathrm{%s}$$', a, beta1, c, u.len);
+            text(ax, 0.01, y, eq4, 'Interpreter', 'latex', 'FontSize', fs);
+            y = y - dy;
+            
+            % Step 3
+            eq5 = sprintf('$$\\varepsilon_y = \\frac{f_y}{E_s} = \\frac{%.0f}{%.0f} = %.6f$$', fy, Es, epsilon_y);
+            text(ax, 0.01, y, eq5, 'Interpreter', 'latex', 'FontSize', fs);
+            
+            eq6 = sprintf('$$\\varepsilon_s = \\left(\\frac{d-c}{c}\\right)\\varepsilon_{cu} = \\left(\\frac{%.2f-%.2f}{%.2f}\\right)(%.4f) = %.6f$$', d, c, c, epsilon_cu, epsilon_s);
+            text(ax, 0.45, y, eq6, 'Interpreter', 'latex', 'FontSize', fs);
+            
+            if yield_check
+                text(ax, 0.92, y, '[OK]', 'FontSize', 10, 'Color', clr.ok, 'FontWeight', 'bold', 'FontName', 'Arial');
+            else
+                text(ax, 0.92, y, '[NG]', 'FontSize', 10, 'Color', clr.ng, 'FontWeight', 'bold', 'FontName', 'Arial');
+            end
+            y = y - dy;
+            
+            % Step 4
+            eq7 = sprintf('$$M_n = A_s f_y \\left(d - \\frac{a}{2}\\right) = %.0f \\left(%.2f - \\frac{%.4f}{2}\\right) = %.0f \\; \\mathrm{%s}$$', T, d, a, Mn_k, u.moment_k);
+            text(ax, 0.01, y, eq7, 'Interpreter', 'latex', 'FontSize', fs);
+            y = y - dy*0.6;
+            
+            result_txt = sprintf('Mn = %.1f %s', Mn_disp, u.moment_alt);
+            text(ax, 0.01, y, result_txt, 'FontSize', 13, 'Color', clr.result, 'FontWeight', 'bold', 'FontName', 'Arial');
+            y = y - dy;
+            
+            % Step 5
+            if is_imperial
+                eq9 = sprintf('$$A_{s,min} = \\max\\left(\\frac{3\\sqrt{f''_c}}{f_y}b_wd,\\;\\frac{200}{f_y}b_wd\\right) = %.4f \\; \\mathrm{%s}$$', As_min, u.area);
+            else
+                eq9 = sprintf('$$A_{s,min} = \\max\\left(\\frac{0.25\\sqrt{f''_c}}{f_y}b_wd,\\;\\frac{1.4}{f_y}b_wd\\right) = %.1f \\; \\mathrm{%s}$$', As_min, u.area);
+            end
+            text(ax, 0.01, y, eq9, 'Interpreter', 'latex', 'FontSize', fs);
+            
+            if As_check
+                text(ax, 0.75, y, sprintf('As >= As,min [OK]'), 'FontSize', 10, 'Color', clr.ok, 'FontWeight', 'bold', 'FontName', 'Arial');
+            else
+                text(ax, 0.75, y, sprintf('As < As,min [NG]'), 'FontSize', 10, 'Color', clr.ng, 'FontWeight', 'bold', 'FontName', 'Arial');
+            end
+            
+            % === 7. RESULTS TEXT ===
+            if yield_check
+                yield_str = 'Yes (Steel Yields)';
+            else
+                yield_str = 'No (Steel Elastic)';
+            end
+            
+            if As_check
+                asmin_str = 'OK';
+            else
+                asmin_str = 'NOT OK';
+            end
+            
+            results_str = sprintf([...
+                'RESULTS SUMMARY\n' ...
+                '================\n\n' ...
+                'Steel Area:\n' ...
+                '  As = %.4f %s\n\n' ...
+                'Forces:\n' ...
+                '  T = C = %.2f kips\n\n' ...
+                'Geometry:\n' ...
+                '  a = %.4f %s\n' ...
+                '  c = %.4f %s\n\n' ...
+                'Strain Check:\n' ...
+                '  ey = %.6f\n' ...
+                '  es = %.6f\n' ...
+                '  Yield: %s\n\n' ...
+                'NOMINAL MOMENT:\n' ...
+                '  Mn = %.1f %s\n\n' ...
+                'Min Steel Check:\n' ...
+                '  As,min = %.4f %s\n' ...
+                '  Status: %s'], ...
+                As, u.area, T_disp, a, u.len, c, u.len, ...
+                epsilon_y, epsilon_s, yield_str, ...
+                Mn_disp, u.moment_alt, As_min, u.area, asmin_str);
+            
+            app.ResultsText.Value = results_str;
+        end
+        
+        function switchUnits(app, ~)
+            if strcmp(app.UnitSwitch.Value, 'Imperial')
+                app.EditFc.Value = 4000;
+                app.EditFy.Value = 60000;
+                app.EditEs.Value = 29000000;
+                app.EditBeta1.Value = 0.85;
+                app.EditEpsCu.Value = 0.003;
+                app.EditB.Value = 12;
+                app.EditH.Value = 20;
+                app.EditD.Value = 17.5;
+                app.EditBars.Value = 4;
+                app.EditBarArea.Value = 0.79;
+            else
+                app.EditFc.Value = 20;
+                app.EditFy.Value = 420;
+                app.EditEs.Value = 200000;
+                app.EditBeta1.Value = 0.85;
+                app.EditEpsCu.Value = 0.003;
+                app.EditB.Value = 250;
+                app.EditH.Value = 565;
+                app.EditD.Value = 500;
+                app.EditBars.Value = 3;
+                app.EditBarArea.Value = 510;
+            end
+            updateApp(app);
+        end
+    end
+
+    methods (Access = public)
+        function app = BeamAnalysisApp()
+            createComponents(app);
+            initializeColors(app);
+            updateApp(app);
+            registerApp(app, app.UIFigure);
+            if nargout == 0
+                clear app
+            end
+        end
+
+        function delete(app)
+            delete(app.UIFigure);
+        end
+    end
+    
+    methods (Access = private)
+        
+        function initializeColors(app)
+            % Professional color scheme
+            app.Colors = struct(...
+                'concrete', [0.88 0.88 0.86], ...
+                'outline', [0.3 0.3 0.3], ...
+                'compression', [0.85 0.55 0.55], ...
+                'compression_line', [0.7 0.2 0.2], ...
+                'tension', [0.2 0.4 0.7], ...
+                'steel', [0.25 0.25 0.3], ...
+                'neutral', [0.4 0.4 0.4], ...
+                'dimension', [0.2 0.5 0.7], ...
+                'strain', [0.7 0.85 0.95], ...
+                'strain_edge', [0.2 0.4 0.6], ...
+                'moment_arm', [0.2 0.6 0.3], ...
+                'result', [0.1 0.3 0.6], ...
+                'ok', [0.1 0.5 0.2], ...
+                'ng', [0.7 0.15 0.15], ...
+                'bg', [0.97 0.97 0.97], ...
+                'panel_bg', [1 1 1]);
+        end
+        
+        function createComponents(app)
+            % === MAIN FIGURE ===
+            app.UIFigure = uifigure('Visible', 'off');
+            app.UIFigure.Position = [80 60 1400 800];
+            app.UIFigure.Name = 'Beam Analysis - Nominal Moment Strength (ACI 318)';
+            app.UIFigure.Color = [0.94 0.94 0.94];
+            app.UIFigure.Resize = 'on';
+
+            % === MAIN GRID ===
+            app.MainGrid = uigridlayout(app.UIFigure);
+            app.MainGrid.ColumnWidth = {'0.18x', '0.82x'};
+            app.MainGrid.RowHeight = {'1x'};
+            app.MainGrid.Padding = [8 8 8 8];
+            app.MainGrid.ColumnSpacing = 8;
+
+            % === LEFT: INPUT PANEL ===
+            app.InputPanel = uipanel(app.MainGrid);
+            app.InputPanel.Layout.Row = 1;
+            app.InputPanel.Layout.Column = 1;
+            app.InputPanel.Title = 'INPUT PARAMETERS';
+            app.InputPanel.FontWeight = 'bold';
+            app.InputPanel.FontSize = 11;
+            app.InputPanel.BackgroundColor = [1 1 1];
+
+            inpGrid = uigridlayout(app.InputPanel);
+            inpGrid.ColumnWidth = {'1.3x', '1x'};
+            inpGrid.RowHeight = repmat({'fit'}, 1, 16);
+            inpGrid.RowSpacing = 4;
+            inpGrid.Padding = [8 8 8 8];
+            
+            % Unit Switch
+            lbl = uilabel(inpGrid); lbl.Text = 'Unit System'; lbl.FontWeight = 'bold';
+            app.UnitSwitch = uiswitch(inpGrid, 'slider');
+            app.UnitSwitch.Items = {'Imperial', 'SI'};
+            app.UnitSwitch.ValueChangedFcn = createCallbackFcn(app, @switchUnits, true);
+            
+            % Separator - Materials
+            lbl = uilabel(inpGrid); lbl.Text = 'MATERIALS'; lbl.FontWeight = 'bold'; lbl.FontColor = [0.3 0.3 0.5];
+            uilabel(inpGrid);
+            
+            % fc
+            lbl = uilabel(inpGrid); lbl.Text = 'fc'' (Concrete)';
+            app.EditFc = uieditfield(inpGrid, 'numeric');
+            app.EditFc.ValueChangedFcn = createCallbackFcn(app, @updateApp, true);
+            
+            % fy
+            lbl = uilabel(inpGrid); lbl.Text = 'fy (Steel Yield)';
+            app.EditFy = uieditfield(inpGrid, 'numeric');
+            app.EditFy.ValueChangedFcn = createCallbackFcn(app, @updateApp, true);
+            
+            % Es
+            lbl = uilabel(inpGrid); lbl.Text = 'Es (Modulus)';
+            app.EditEs = uieditfield(inpGrid, 'numeric');
+            app.EditEs.ValueChangedFcn = createCallbackFcn(app, @updateApp, true);
+            
+            % beta1
+            lbl = uilabel(inpGrid); lbl.Text = 'Beta1';
+            app.EditBeta1 = uieditfield(inpGrid, 'numeric');
+            app.EditBeta1.ValueChangedFcn = createCallbackFcn(app, @updateApp, true);
+            
+            % epsilon_cu
+            lbl = uilabel(inpGrid); lbl.Text = 'ecu (Ult. Strain)';
+            app.EditEpsCu = uieditfield(inpGrid, 'numeric');
+            app.EditEpsCu.ValueDisplayFormat = '%.4f';
+            app.EditEpsCu.ValueChangedFcn = createCallbackFcn(app, @updateApp, true);
+            
+            % Separator - Geometry
+            lbl = uilabel(inpGrid); lbl.Text = 'GEOMETRY'; lbl.FontWeight = 'bold'; lbl.FontColor = [0.3 0.3 0.5];
+            uilabel(inpGrid);
+            
+            % b
+            lbl = uilabel(inpGrid); lbl.Text = 'b (Width)';
+            app.EditB = uieditfield(inpGrid, 'numeric');
+            app.EditB.ValueChangedFcn = createCallbackFcn(app, @updateApp, true);
+            
+            % h
+            lbl = uilabel(inpGrid); lbl.Text = 'h (Total Depth)';
+            app.EditH = uieditfield(inpGrid, 'numeric');
+            app.EditH.ValueChangedFcn = createCallbackFcn(app, @updateApp, true);
+            
+            % d
+            lbl = uilabel(inpGrid); lbl.Text = 'd (Eff. Depth)';
+            app.EditD = uieditfield(inpGrid, 'numeric');
+            app.EditD.ValueChangedFcn = createCallbackFcn(app, @updateApp, true);
+            
+            % Separator - Reinforcement
+            lbl = uilabel(inpGrid); lbl.Text = 'REINFORCEMENT'; lbl.FontWeight = 'bold'; lbl.FontColor = [0.3 0.3 0.5];
+            uilabel(inpGrid);
+            
+            % Bars
+            lbl = uilabel(inpGrid); lbl.Text = 'Number of Bars';
+            app.EditBars = uieditfield(inpGrid, 'numeric');
+            app.EditBars.ValueDisplayFormat = '%.0f';
+            app.EditBars.ValueChangedFcn = createCallbackFcn(app, @updateApp, true);
+            
+            % Bar Area
+            lbl = uilabel(inpGrid); lbl.Text = 'Bar Area (each)';
+            app.EditBarArea = uieditfield(inpGrid, 'numeric');
+            app.EditBarArea.ValueChangedFcn = createCallbackFcn(app, @updateApp, true);
+
+            % === RIGHT PANEL ===
+            rightGrid = uigridlayout(app.MainGrid);
+            rightGrid.Layout.Row = 1;
+            rightGrid.Layout.Column = 2;
+            rightGrid.ColumnWidth = {'1x', '1x', '1x', '0.6x'};
+            rightGrid.RowHeight = {'1.2x', '1.5x'};
+            rightGrid.Padding = [0 0 0 0];
+            rightGrid.ColumnSpacing = 6;
+            rightGrid.RowSpacing = 6;
+
+            % --- Diagram Panels ---
+            % Section
+            sectionPanel = uipanel(rightGrid);
+            sectionPanel.Layout.Row = 1;
+            sectionPanel.Layout.Column = 1;
+            sectionPanel.BackgroundColor = [1 1 1];
+            sectionPanel.BorderType = 'line';
+            
+            secGrid = uigridlayout(sectionPanel);
+            secGrid.ColumnWidth = {'1x'};
+            secGrid.RowHeight = {'1x'};
+            secGrid.Padding = [2 2 2 2];
+            
+            app.AxSection = uiaxes(secGrid);
+            app.AxSection.Layout.Row = 1;
+            app.AxSection.Layout.Column = 1;
+            
+            % Strain
+            strainPanel = uipanel(rightGrid);
+            strainPanel.Layout.Row = 1;
+            strainPanel.Layout.Column = 2;
+            strainPanel.BackgroundColor = [1 1 1];
+            strainPanel.BorderType = 'line';
+            
+            strGrid = uigridlayout(strainPanel);
+            strGrid.ColumnWidth = {'1x'};
+            strGrid.RowHeight = {'1x'};
+            strGrid.Padding = [2 2 2 2];
+            
+            app.AxStrain = uiaxes(strGrid);
+            app.AxStrain.Layout.Row = 1;
+            app.AxStrain.Layout.Column = 1;
+            
+            % Stress
+            stressPanel = uipanel(rightGrid);
+            stressPanel.Layout.Row = 1;
+            stressPanel.Layout.Column = 3;
+            stressPanel.BackgroundColor = [1 1 1];
+            stressPanel.BorderType = 'line';
+            
+            stressGrid = uigridlayout(stressPanel);
+            stressGrid.ColumnWidth = {'1x'};
+            stressGrid.RowHeight = {'1x'};
+            stressGrid.Padding = [2 2 2 2];
+            
+            app.AxStress = uiaxes(stressGrid);
+            app.AxStress.Layout.Row = 1;
+            app.AxStress.Layout.Column = 1;
+            
+            % Results
+            app.ResultsPanel = uipanel(rightGrid);
+            app.ResultsPanel.Layout.Row = 1;
+            app.ResultsPanel.Layout.Column = 4;
+            app.ResultsPanel.Title = 'Results';
+            app.ResultsPanel.FontWeight = 'bold';
+            app.ResultsPanel.BackgroundColor = [0.98 0.98 0.95];
+            
+            resGrid = uigridlayout(app.ResultsPanel);
+            resGrid.ColumnWidth = {'1x'};
+            resGrid.RowHeight = {'1x'};
+            resGrid.Padding = [4 4 4 4];
+            
+            app.ResultsText = uitextarea(resGrid);
+            app.ResultsText.Layout.Row = 1;
+            app.ResultsText.Layout.Column = 1;
+            app.ResultsText.FontName = 'Consolas';
+            app.ResultsText.FontSize = 9;
+            app.ResultsText.Editable = 'off';
+            app.ResultsText.BackgroundColor = [0.98 0.98 0.95];
+            
+            % --- Equations Panel ---
+            app.EquationsPanel = uipanel(rightGrid);
+            app.EquationsPanel.Layout.Row = 2;
+            app.EquationsPanel.Layout.Column = [1 4];
+            app.EquationsPanel.Title = 'Calculation Procedure (ACI 318)';
+            app.EquationsPanel.FontWeight = 'bold';
+            app.EquationsPanel.BackgroundColor = [1 1 1];
+            
+            eqGrid = uigridlayout(app.EquationsPanel);
+            eqGrid.ColumnWidth = {'1x'};
+            eqGrid.RowHeight = {'1x'};
+            eqGrid.Padding = [4 4 4 4];
+            
+            app.AxEquations = uiaxes(eqGrid);
+            app.AxEquations.Layout.Row = 1;
+            app.AxEquations.Layout.Column = 1;
+            app.AxEquations.XTick = [];
+            app.AxEquations.YTick = [];
+            app.AxEquations.XColor = 'none';
+            app.AxEquations.YColor = 'none';
+
+            % === SET INITIAL VALUES ===
+            app.EditFc.Value = 4000;
+            app.EditFy.Value = 60000;
+            app.EditEs.Value = 29000000;
+            app.EditBeta1.Value = 0.85;
+            app.EditEpsCu.Value = 0.003;
+            app.EditB.Value = 12;
+            app.EditH.Value = 20;
+            app.EditD.Value = 17.5;
+            app.EditBars.Value = 4;
+            app.EditBarArea.Value = 0.79;
+
+            app.UIFigure.Visible = 'on';
+        end
+    end
+end
+

README.md

@@ -0,0 +1,175 @@
+# RecrBeam Calculator
+
+[![Python](https://img.shields.io/badge/Python-3.9+-3776AB?style=flat&logo=python&logoColor=white)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![ACI 318](https://img.shields.io/badge/Code-ACI%20318-blue.svg)](https://www.concrete.org/)
+[![CustomTkinter](https://img.shields.io/badge/UI-CustomTkinter-green.svg)](https://github.com/TomSchimansky/CustomTkinter)
+
+A professional desktop application for calculating the **Nominal Moment Strength (Mn)** of rectangular reinforced concrete beams per ACI 318 provisions.
+
+## Features
+
+- Native Windows desktop application (no browser/localhost required)
+- Professional dark theme UI
+- Real-time calculations as you type
+- **Unit system toggle**: Imperial (psi, in) / SI (MPa, mm)
+- **Visual diagrams**: Cross Section, Strain Distribution, Stress Block & Forces
+- **Step-by-step equations**: Detailed calculation breakdown with OK/NG indicators
+- Minimum steel area check per ACI 318
+
+## Installation
+
+### Prerequisites
+
+- Python 3.9 or higher
+- pip (Python package manager)
+
+### Setup
+
+1. **Clone the repository**
+   ```bash
+   git clone https://github.com/algorembrant/RecrBeam-Calculator.git
+   cd RecrBeam-Calculator
+   ```
+
+2. **Create a virtual environment** (recommended)
+   ```bash
+   python -m venv .venv
+   ```
+
+3. **Activate the virtual environment**
+   
+   Windows (PowerShell):
+   ```powershell
+   .\.venv\Scripts\Activate.ps1
+   ```
+   
+   Windows (Command Prompt):
+   ```cmd
+   .venv\Scripts\activate.bat
+   ```
+   
+   macOS/Linux:
+   ```bash
+   source .venv/bin/activate
+   ```
+
+4. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Usage
+
+### Run the Application
+
+```bash
+python app.py
+```
+
+The application will launch as a native desktop window.
+
+### Input Parameters
+
+| Parameter | Description | Imperial | SI |
+|-----------|-------------|----------|-----|
+| fc' | Concrete compressive strength | psi | MPa |
+| fy | Steel yield strength | psi | MPa |
+| Es | Modulus of elasticity | psi | MPa |
+| Beta1 | Stress block factor | - | - |
+| ecu | Ultimate concrete strain | - | - |
+| b | Beam width | in | mm |
+| h | Total beam depth | in | mm |
+| d | Effective depth | in | mm |
+| n | Number of bars | - | - |
+| Ab | Bar area (each) | in2 | mm2 |
+
+### Default Values (Example 4-1)
+
+**Imperial:**
+- fc' = 4000 psi, fy = 60,000 psi
+- b = 12 in, h = 20 in, d = 17.5 in
+- 4 bars at 0.79 in2 each (No. 8 bars)
+
+**SI:**
+- fc' = 20 MPa, fy = 420 MPa
+- b = 250 mm, h = 565 mm, d = 500 mm
+- 3 bars at 510 mm2 each
+
+## Project Structure
+
+```
+RecrBeam-Calculator/
+├── app.py              # Main desktop application (CustomTkinter)
+├── calculator.py       # Beam calculation engine
+├── test_calculator.py  # Unit tests
+├── requirements.txt    # Python dependencies
+├── README.md           # This file
+├── LICENSE             # MIT License
+├── MATLAB/
+│   └── app.m           # Original MATLAB implementation
+└── Dump/
+    └── example_4_1.tex # LaTeX documentation
+```
+
+## Theory
+
+Based on ACI 318 provisions for nominal moment strength:
+
+### Key Equations
+
+**Stress block depth:**
+```
+a = (As * fy) / (0.85 * fc' * b)
+```
+
+**Neutral axis depth:**
+```
+c = a / Beta1
+```
+
+**Nominal moment strength:**
+```
+Mn = As * fy * (d - a/2)
+```
+
+**Minimum steel area (Imperial):**
+```
+As,min = max(3*sqrt(fc')/fy * b*d, 200/fy * b*d)
+```
+
+## Running Tests
+
+```bash
+python -m unittest test_calculator -v
+```
+
+## Dependencies
+
+- [CustomTkinter](https://github.com/TomSchimansky/CustomTkinter) - Modern UI framework
+- [Matplotlib](https://matplotlib.org/) - Diagram plotting
+- [NumPy](https://numpy.org/) - Numerical operations
+
+## License
+
+MIT License - see [LICENSE](LICENSE)
+
+## References
+
+- ACI 318-19: Building Code Requirements for Structural Concrete
+- Example 4-1 and 4-1M from ACI 318 Design Handbook
+
+## Citation
+
+If you use this software in your research or project, please cite it as:
+
+```bibtex
+@software{recrbeam_calculator,
+  author       = {algorembrant},
+  title        = {RecrBeam Calculator: Nominal Moment Strength Calculator for Rectangular Beams},
+  year         = {2026},
+  publisher    = {GitHub},
+  url          = {https://github.com/algorembrant/RecrBeam-Calculator},
+  note         = {Based on ACI 318 provisions}
+}
+```

STRUCTURE.md

@@ -0,0 +1,22 @@
+## Project Structure
+
+```text
+RBC/
+├── Dump/
+│   ├── example_4_1.tex
+│   ├── note.txt
+│   ├── solution_breakdown.md
+│   └── solution_breakdown.pdf
+├── MATLAB/
+│   └── app.m
+├── .gitignore
+├── app.py
+├── beam_calc.db
+├── calculator.py
+├── db_manager.py
+├── LICENSE
+├── README.md
+├── requirements.txt
+├── TECHSTACK.md
+└── test_calculator.py
+```

TECHSTACK.md

@@ -0,0 +1,15 @@
+## Techstack
+
+Audit of **RBC** project files (excluding environment and cache):
+
+| File Type | Count | Size (KB) |
+| :--- | :--- | :--- |
+| Python (.py) | 4 | 34.8 |
+| (no extension) | 2 | 1.5 |
+| Markdown (.md) | 2 | 8.7 |
+| Plain Text (.txt) | 2 | 0.0 |
+| Database (.db) | 1 | 12.0 |
+| LaTeX (.tex) | 1 | 8.1 |
+| Objective-C / MATLAB (.m) | 1 | 27.7 |
+| PDF (.pdf) | 1 | 147.3 |
+| **Total** | **14** | **240.1** |

app.py

@@ -0,0 +1,542 @@
+"""
+Beam Analysis - Nominal Moment Strength Calculator
+Native Desktop Application using CustomTkinter
+Based on ACI 318 Example 4-1 and 4-1M
+"""
+
+import customtkinter as ctk
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+import matplotlib.patches as patches
+import numpy as np
+from calculator import RectangularBeam
+
+# Set appearance
+ctk.set_appearance_mode("dark")
+ctk.set_default_color_theme("blue")
+
+# Color Scheme
+COLORS = {
+    "concrete": "#E0E0DC",
+    "outline": "#4D4D4D",
+    "compression": "#D98C8C",
+    "compression_line": "#B33333",
+    "tension": "#336699",
+    "steel": "#404050",
+    "neutral": "#666666",
+    "dimension": "#3380B3",
+    "strain": "#B3D9F2",
+    "strain_edge": "#336699",
+    "moment_arm": "#339933",
+    "result": "#1A4D99",
+    "ok": "#2ECC71",
+    "ng": "#E74C3C",
+    "bg_dark": "#1a1a2e",
+    "panel_bg": "#16213e",
+    "accent": "#0f3460",
+    "text": "#eaeaea",
+    "text_dim": "#a0a0a0",
+}
+
+
+class BeamAnalysisApp(ctk.CTk):
+    def __init__(self):
+        super().__init__()
+        
+        self.title("Beam Analysis - Nominal Moment Strength (ACI 318)")
+        self.geometry("1400x850")
+        self.minsize(1200, 700)
+        
+        # Configure grid
+        self.grid_columnconfigure(0, weight=0, minsize=280)
+        self.grid_columnconfigure(1, weight=1)
+        self.grid_rowconfigure(0, weight=1)
+        
+        # Variables
+        self.unit_system = ctk.StringVar(value="Imperial")
+        self.input_vars = {}
+        
+        # Create UI
+        self._create_input_panel()
+        self._create_main_panel()
+        
+        # Initialize with default values
+        self._set_defaults()
+        self._update_calculations()
+    
+    def _create_input_panel(self):
+        """Create the left input panel."""
+        self.input_frame = ctk.CTkScrollableFrame(
+            self,
+            width=260,
+            corner_radius=0,
+            fg_color=COLORS["panel_bg"]
+        )
+        self.input_frame.grid(row=0, column=0, sticky="nsew", padx=0, pady=0)
+        
+        # Title
+        title_label = ctk.CTkLabel(
+            self.input_frame,
+            text="INPUT PARAMETERS",
+            font=ctk.CTkFont(size=16, weight="bold"),
+            text_color=COLORS["text"]
+        )
+        title_label.pack(pady=(20, 15), padx=20)
+        
+        # Unit System Toggle
+        unit_frame = ctk.CTkFrame(self.input_frame, fg_color="transparent")
+        unit_frame.pack(fill="x", padx=20, pady=(0, 15))
+        
+        ctk.CTkLabel(
+            unit_frame,
+            text="Unit System",
+            font=ctk.CTkFont(size=12, weight="bold"),
+            text_color=COLORS["text"]
+        ).pack(anchor="w")
+        
+        self.unit_toggle = ctk.CTkSegmentedButton(
+            unit_frame,
+            values=["Imperial", "SI"],
+            variable=self.unit_system,
+            command=self._on_unit_change,
+            font=ctk.CTkFont(size=12)
+        )
+        self.unit_toggle.pack(fill="x", pady=(5, 0))
+        
+        # Separator
+        self._add_separator()
+        
+        # Materials Section
+        self._add_section_header("MATERIALS")
+        self._create_input_field("fc", "fc' (Concrete)", "psi")
+        self._create_input_field("fy", "fy (Steel Yield)", "psi")
+        self._create_input_field("Es", "Es (Modulus)", "psi")
+        self._create_input_field("beta1", "Beta1", "")
+        self._create_input_field("epsilon_cu", "ecu (Ult. Strain)", "")
+        
+        self._add_separator()
+        
+        # Geometry Section
+        self._add_section_header("GEOMETRY")
+        self._create_input_field("b", "b (Width)", "in")
+        self._create_input_field("h", "h (Total Depth)", "in")
+        self._create_input_field("d", "d (Eff. Depth)", "in")
+        
+        self._add_separator()
+        
+        # Reinforcement Section
+        self._add_section_header("REINFORCEMENT")
+        self._create_input_field("n_bars", "Number of Bars", "")
+        self._create_input_field("bar_area", "Bar Area (each)", "in2")
+    
+    def _add_separator(self):
+        """Add a subtle separator line."""
+        sep = ctk.CTkFrame(self.input_frame, height=1, fg_color=COLORS["accent"])
+        sep.pack(fill="x", padx=20, pady=15)
+    
+    def _add_section_header(self, text):
+        """Add a section header."""
+        label = ctk.CTkLabel(
+            self.input_frame,
+            text=text,
+            font=ctk.CTkFont(size=11, weight="bold"),
+            text_color=COLORS["dimension"]
+        )
+        label.pack(anchor="w", padx=20, pady=(5, 10))
+    
+    def _create_input_field(self, key, label_text, unit):
+        """Create an input field with label."""
+        frame = ctk.CTkFrame(self.input_frame, fg_color="transparent")
+        frame.pack(fill="x", padx=20, pady=3)
+        
+        # Label
+        display_label = f"{label_text}" if not unit else f"{label_text} [{unit}]"
+        label = ctk.CTkLabel(
+            frame,
+            text=display_label,
+            font=ctk.CTkFont(size=11),
+            text_color=COLORS["text_dim"]
+        )
+        label.pack(anchor="w")
+        
+        # Store label reference for unit updates
+        if not hasattr(self, '_unit_labels'):
+            self._unit_labels = {}
+        self._unit_labels[key] = (label, label_text, unit)
+        
+        # Entry
+        var = ctk.StringVar()
+        self.input_vars[key] = var
+        
+        entry = ctk.CTkEntry(
+            frame,
+            textvariable=var,
+            font=ctk.CTkFont(size=12),
+            height=32,
+            corner_radius=6
+        )
+        entry.pack(fill="x", pady=(2, 0))
+        entry.bind("<KeyRelease>", lambda e: self._update_calculations())
+        entry.bind("<FocusOut>", lambda e: self._update_calculations())
+    
+    def _create_main_panel(self):
+        """Create the main content area."""
+        self.main_frame = ctk.CTkFrame(self, fg_color=COLORS["bg_dark"], corner_radius=0)
+        self.main_frame.grid(row=0, column=1, sticky="nsew", padx=0, pady=0)
+        
+        self.main_frame.grid_columnconfigure((0, 1, 2), weight=1)
+        self.main_frame.grid_columnconfigure(3, weight=0, minsize=200)
+        self.main_frame.grid_rowconfigure(0, weight=3)
+        self.main_frame.grid_rowconfigure(1, weight=2)
+        
+        # Create diagram frames
+        self._create_diagram_frame("Cross Section", 0)
+        self._create_diagram_frame("Strain Distribution", 1)
+        self._create_diagram_frame("Stress Block & Forces", 2)
+        self._create_results_panel()
+        self._create_equations_panel()
+    
+    def _create_diagram_frame(self, title, col):
+        """Create a diagram frame with matplotlib canvas."""
+        frame = ctk.CTkFrame(self.main_frame, fg_color=COLORS["panel_bg"], corner_radius=8)
+        frame.grid(row=0, column=col, sticky="nsew", padx=5, pady=5)
+        
+        # Title
+        label = ctk.CTkLabel(
+            frame,
+            text=title,
+            font=ctk.CTkFont(size=12, weight="bold"),
+            text_color=COLORS["text"]
+        )
+        label.pack(pady=(10, 5))
+        
+        # Figure
+        fig, ax = plt.subplots(figsize=(4, 3.5), facecolor=COLORS["bg_dark"])
+        ax.set_facecolor(COLORS["bg_dark"])
+        
+        canvas = FigureCanvasTkAgg(fig, frame)
+        canvas.get_tk_widget().pack(fill="both", expand=True, padx=5, pady=5)
+        
+        # Store references
+        if col == 0:
+            self.fig_section, self.ax_section, self.canvas_section = fig, ax, canvas
+        elif col == 1:
+            self.fig_strain, self.ax_strain, self.canvas_strain = fig, ax, canvas
+        else:
+            self.fig_stress, self.ax_stress, self.canvas_stress = fig, ax, canvas
+    
+    def _create_results_panel(self):
+        """Create the results summary panel."""
+        frame = ctk.CTkFrame(self.main_frame, fg_color=COLORS["panel_bg"], corner_radius=8)
+        frame.grid(row=0, column=3, sticky="nsew", padx=5, pady=5)
+        
+        # Title
+        ctk.CTkLabel(
+            frame,
+            text="Results",
+            font=ctk.CTkFont(size=12, weight="bold"),
+            text_color=COLORS["text"]
+        ).pack(pady=(10, 5))
+        
+        # Results text
+        self.results_text = ctk.CTkTextbox(
+            frame,
+            font=ctk.CTkFont(family="Consolas", size=10),
+            fg_color=COLORS["bg_dark"],
+            text_color=COLORS["text"],
+            corner_radius=6,
+            wrap="word"
+        )
+        self.results_text.pack(fill="both", expand=True, padx=8, pady=8)
+    
+    def _create_equations_panel(self):
+        """Create the equations panel."""
+        frame = ctk.CTkFrame(self.main_frame, fg_color=COLORS["panel_bg"], corner_radius=8)
+        frame.grid(row=1, column=0, columnspan=4, sticky="nsew", padx=5, pady=5)
+        
+        # Title
+        ctk.CTkLabel(
+            frame,
+            text="Calculation Procedure (ACI 318)",
+            font=ctk.CTkFont(size=12, weight="bold"),
+            text_color=COLORS["text"]
+        ).pack(pady=(10, 5), anchor="w", padx=15)
+        
+        # Equations text
+        self.equations_text = ctk.CTkTextbox(
+            frame,
+            font=ctk.CTkFont(family="Consolas", size=11),
+            fg_color=COLORS["bg_dark"],
+            text_color=COLORS["text"],
+            corner_radius=6,
+            height=150
+        )
+        self.equations_text.pack(fill="both", expand=True, padx=10, pady=(5, 10))
+    
+    def _set_defaults(self):
+        """Set default values based on unit system."""
+        if self.unit_system.get() == "Imperial":
+            defaults = {
+                "fc": "4000", "fy": "60000", "Es": "29000000",
+                "beta1": "0.85", "epsilon_cu": "0.003",
+                "b": "12", "h": "20", "d": "17.5",
+                "n_bars": "4", "bar_area": "0.79"
+            }
+            units = {"fc": "psi", "fy": "psi", "Es": "psi", "b": "in", "h": "in", "d": "in", "bar_area": "in2"}
+        else:
+            defaults = {
+                "fc": "20", "fy": "420", "Es": "200000",
+                "beta1": "0.85", "epsilon_cu": "0.003",
+                "b": "250", "h": "565", "d": "500",
+                "n_bars": "3", "bar_area": "510"
+            }
+            units = {"fc": "MPa", "fy": "MPa", "Es": "MPa", "b": "mm", "h": "mm", "d": "mm", "bar_area": "mm2"}
+        
+        for key, val in defaults.items():
+            self.input_vars[key].set(val)
+        
+        # Update labels
+        for key, (label, text, _) in self._unit_labels.items():
+            unit = units.get(key, "")
+            display = f"{text}" if not unit else f"{text} [{unit}]"
+            label.configure(text=display)
+    
+    def _on_unit_change(self, value):
+        """Handle unit system change."""
+        self._set_defaults()
+        self._update_calculations()
+    
+    def _get_input_value(self, key, default=0.0):
+        """Get input value as float."""
+        try:
+            return float(self.input_vars[key].get())
+        except (ValueError, KeyError):
+            return default
+    
+    def _update_calculations(self):
+        """Update all calculations and displays."""
+        try:
+            # Get values
+            fc = self._get_input_value("fc", 4000)
+            fy = self._get_input_value("fy", 60000)
+            Es = self._get_input_value("Es", 29000000)
+            beta1 = self._get_input_value("beta1", 0.85)
+            epsilon_cu = self._get_input_value("epsilon_cu", 0.003)
+            b = self._get_input_value("b", 12)
+            h = self._get_input_value("h", 20)
+            d = self._get_input_value("d", 17.5)
+            n_bars = int(self._get_input_value("n_bars", 4))
+            bar_area = self._get_input_value("bar_area", 0.79)
+            
+            if any(v <= 0 for v in [fc, fy, Es, b, h, d, n_bars, bar_area]):
+                return
+            
+            # Create beam and calculate
+            beam = RectangularBeam(
+                b=b, h=h, d=d, fc=fc, fy=fy,
+                n_bars=n_bars, bar_area=bar_area,
+                Es=Es, beta1=beta1, epsilon_cu=epsilon_cu,
+                unit_system=self.unit_system.get().lower()
+            )
+            results = beam.calculate_mn()
+            units = beam.get_units()
+            
+            # Update diagrams
+            self._draw_cross_section(b, h, d, results["a"], results["c"], n_bars, bar_area)
+            self._draw_strain_diagram(h, d, results["c"], epsilon_cu, results["epsilon_s"])
+            self._draw_stress_diagram(h, d, results["a"], results["c"], results["T_display"], units)
+            
+            # Update results
+            self._update_results_text(results, units)
+            self._update_equations_text(results, units, n_bars, bar_area, fc, fy, Es, beta1, epsilon_cu, b, d)
+            
+        except Exception as e:
+            pass  # Silently handle errors during typing
+    
+    def _draw_cross_section(self, b, h, d, a, c, n_bars, bar_area):
+        """Draw the beam cross section."""
+        ax = self.ax_section
+        ax.clear()
+        ax.set_facecolor(COLORS["bg_dark"])
+        
+        # Concrete beam
+        rect = patches.Rectangle((0, 0), b, h, facecolor=COLORS["concrete"],
+                                   edgecolor=COLORS["outline"], linewidth=1.5)
+        ax.add_patch(rect)
+        
+        # Compression zone
+        comp = patches.Rectangle((0, h - a), b, a, facecolor=COLORS["compression"],
+                                   edgecolor="none", alpha=0.6)
+        ax.add_patch(comp)
+        
+        # Neutral axis
+        ax.plot([0, b], [h - c, h - c], '--', color=COLORS["neutral"], linewidth=1.2)
+        
+        # Steel bars
+        bar_r = np.sqrt(bar_area / np.pi) * 0.7
+        steel_y = h - d
+        cx = [b / 2] if n_bars == 1 else np.linspace(b * 0.12, b * 0.88, n_bars)
+        
+        for x in cx:
+            circle = patches.Circle((x, steel_y), bar_r, facecolor=COLORS["steel"],
+                                      edgecolor="#1A1A1A", linewidth=0.5)
+            ax.add_patch(circle)
+        
+        # Dimensions
+        ax.text(b / 2, -h * 0.06, f'b={b:.1f}', ha='center', fontsize=8, color=COLORS["text"])
+        ax.text(b + b * 0.1, h / 2, f'h={h:.1f}', fontsize=8, color=COLORS["text"])
+        ax.text(-b * 0.12, h - a / 2, f'a={a:.2f}', fontsize=8, color=COLORS["compression_line"])
+        ax.text(b + b * 0.04, h - c, f'c={c:.2f}', fontsize=7, color=COLORS["neutral"])
+        
+        ax.set_xlim(-b * 0.2, b * 1.3)
+        ax.set_ylim(-h * 0.1, h * 1.05)
+        ax.set_aspect('equal')
+        ax.axis('off')
+        
+        self.canvas_section.draw()
+    
+    def _draw_strain_diagram(self, h, d, c, epsilon_cu, epsilon_s):
+        """Draw the strain distribution."""
+        ax = self.ax_strain
+        ax.clear()
+        ax.set_facecolor(COLORS["bg_dark"])
+        
+        steel_y = h - d
+        strain_w = 0.4
+        
+        # Beam outline
+        ax.plot([0, 0], [0, h], color='#555', linewidth=1)
+        
+        # Strain profile
+        x_top = epsilon_cu * strain_w / 0.003
+        x_bot = epsilon_s * strain_w / 0.003
+        
+        ax.fill([0, x_top, x_bot, 0], [h, h, steel_y, steel_y],
+                facecolor=COLORS["strain"], edgecolor=COLORS["strain_edge"],
+                linewidth=1.2, alpha=0.5)
+        
+        # Neutral axis
+        ax.plot([-0.05, strain_w * 1.2], [h - c, h - c], '--', color=COLORS["neutral"], linewidth=1)
+        ax.text(-0.03, h - c, f'c={c:.2f}', fontsize=7, ha='right', color=COLORS["neutral"])
+        
+        # Labels
+        ax.text(x_top + 0.02, h, f'ecu={epsilon_cu:.4f}', fontsize=8, color=COLORS["text"])
+        ax.text(x_bot + 0.02, steel_y, f'es={epsilon_s:.5f}', fontsize=8, color=COLORS["text"])
+        
+        ax.set_xlim(-0.1, strain_w * 1.5)
+        ax.set_ylim(-h * 0.1, h * 1.05)
+        ax.axis('off')
+        
+        self.canvas_strain.draw()
+    
+    def _draw_stress_diagram(self, h, d, a, c, T_display, units):
+        """Draw the stress block and forces."""
+        ax = self.ax_stress
+        ax.clear()
+        ax.set_facecolor(COLORS["bg_dark"])
+        
+        steel_y = h - d
+        stress_w = 0.5
+        
+        # Compression block
+        comp = patches.Rectangle((0, h - a), stress_w, a, facecolor=COLORS["compression"],
+                                   edgecolor=COLORS["compression_line"], linewidth=1.2, alpha=0.7)
+        ax.add_patch(comp)
+        ax.text(stress_w / 2, h - a / 2, "0.85fc'", ha='center', fontsize=8, color=COLORS["text"])
+        
+        # Force arrows
+        ax.annotate('', xy=(stress_w + 0.2, h - a / 2), xytext=(stress_w + 0.05, h - a / 2),
+                    arrowprops=dict(arrowstyle='->', color=COLORS["compression_line"], lw=2))
+        ax.text(stress_w + 0.22, h - a / 2, f'C={T_display:.0f} {units["force_k"]}',
+                fontsize=8, color=COLORS["compression_line"])
+        
+        # Steel and tension
+        ax.plot([0, stress_w * 0.3], [steel_y, steel_y], color=COLORS["steel"], linewidth=2)
+        ax.annotate('', xy=(0.2, steel_y), xytext=(0, steel_y),
+                    arrowprops=dict(arrowstyle='->', color=COLORS["tension"], lw=2))
+        ax.text(0.22, steel_y, f'T={T_display:.0f} {units["force_k"]}',
+                fontsize=8, color=COLORS["tension"])
+        
+        # Neutral axis
+        ax.plot([-0.05, stress_w + 0.25], [h - c, h - c], '--', color=COLORS["neutral"], linewidth=1)
+        
+        # Moment arm
+        xa = stress_w + 0.35
+        ax.plot([xa, xa], [h - a / 2, steel_y], color=COLORS["moment_arm"], linewidth=1.5)
+        ax.text(xa + 0.02, (h - a / 2 + steel_y) / 2, 'd-a/2', fontsize=7, color=COLORS["moment_arm"])
+        
+        ax.set_xlim(-0.1, stress_w + 0.55)
+        ax.set_ylim(-h * 0.1, h * 1.05)
+        ax.set_aspect('equal')
+        ax.axis('off')
+        
+        self.canvas_stress.draw()
+    
+    def _update_results_text(self, results, units):
+        """Update the results text panel."""
+        yield_str = "Yes (Yields)" if results["yield_check"] else "No (Elastic)"
+        as_str = "OK" if results["as_check"] else "NOT OK"
+        
+        text = f"""RESULTS SUMMARY
+================
+
+Steel Area:
+  As = {results['As']:.4f} {units['area']}
+
+Forces:
+  T = C = {results['T_display']:.2f} {units['force_k']}
+
+Geometry:
+  a = {results['a']:.4f} {units['length']}
+  c = {results['c']:.4f} {units['length']}
+
+Strain Check:
+  ey = {results['epsilon_y']:.6f}
+  es = {results['epsilon_s']:.6f}
+  Yield: {yield_str}
+
+NOMINAL MOMENT:
+  Mn = {results['Mn_display']:.1f} {units['moment_display']}
+
+Min Steel Check:
+  As,min = {results['As_min']:.4f} {units['area']}
+  Status: {as_str}
+"""
+        self.results_text.delete("1.0", "end")
+        self.results_text.insert("1.0", text)
+    
+    def _update_equations_text(self, results, units, n_bars, bar_area, fc, fy, Es, beta1, epsilon_cu, b, d):
+        """Update the equations panel."""
+        yield_ok = "[OK]" if results["yield_check"] else "[NG]"
+        as_ok = "[OK]" if results["as_check"] else "[NG]"
+        
+        text = f"""STEP-BY-STEP CALCULATIONS
+
+Step 1: Steel Area and Tension Force
+  As = n x A_bar = {n_bars} x {bar_area:.3f} = {results['As']:.3f} {units['area']}
+  T = As x fy = {results['As']:.3f} x {fy:.0f} = {results['T']:.0f} {units['force']}  ({results['T_display']:.1f} {units['force_k']})
+
+Step 2: Stress Block Depth
+  a = (As x fy) / (0.85 x fc' x b) = {results['T']:.0f} / (0.85 x {fc:.0f} x {b:.1f}) = {results['a']:.4f} {units['length']}
+  c = a / beta1 = {results['a']:.4f} / {beta1:.3f} = {results['c']:.4f} {units['length']}
+
+Step 3: Strain Check  {yield_ok}
+  ey = fy / Es = {fy:.0f} / {Es:.0f} = {results['epsilon_y']:.6f}
+  es = ((d - c) / c) x ecu = (({d:.2f} - {results['c']:.2f}) / {results['c']:.2f}) x {epsilon_cu:.4f} = {results['epsilon_s']:.6f}
+
+Step 4: Nominal Moment
+  Mn = As x fy x (d - a/2) = {results['T']:.0f} x ({d:.2f} - {results['a']:.4f}/2) = {results['Mn_k']:.0f} {units['moment_k']}
+  
+  >>> Mn = {results['Mn_display']:.1f} {units['moment_display']} <<<
+
+Step 5: Minimum Steel Check  {as_ok}
+  As,min = {results['As_min']:.4f} {units['area']}
+  As {'>' if results['as_check'] else '<'} As,min
+"""
+        self.equations_text.delete("1.0", "end")
+        self.equations_text.insert("1.0", text)
+
+
+if __name__ == "__main__":
+    app = BeamAnalysisApp()
+    app.mainloop()

calculator.py

@@ -0,0 +1,234 @@
+"""
+Rectangular Beam Nominal Moment Strength Calculator
+Based on ACI 318 Provisions (Example 4-1 and 4-1M)
+
+Variables:
+    fc' - Concrete compressive strength
+    fy  - Steel yield strength
+    Es  - Modulus of elasticity of steel
+    b   - Beam width
+    h   - Total beam depth
+    d   - Effective depth (to centroid of tension steel)
+    As  - Total area of tension steel
+    beta1 - Stress block factor
+    epsilon_cu - Ultimate concrete strain (0.003)
+
+Calculated:
+    T       - Tension force in steel
+    a       - Depth of equivalent stress block
+    c       - Neutral axis depth
+    epsilon_y - Yield strain of steel
+    epsilon_s - Strain in steel at ultimate
+    Mn      - Nominal moment strength
+    As_min  - Minimum steel area per ACI
+"""
+
+import math
+
+
+class RectangularBeam:
+    def __init__(
+        self,
+        b: float,
+        h: float,
+        d: float,
+        fc: float,
+        fy: float,
+        n_bars: int,
+        bar_area: float,
+        Es: float = None,
+        beta1: float = None,
+        epsilon_cu: float = 0.003,
+        unit_system: str = "imperial"
+    ):
+        """
+        Initialize the Rectangular Beam.
+        
+        Args:
+            b: Beam width (in or mm)
+            h: Total beam depth (in or mm)
+            d: Effective depth (in or mm)
+            fc: Concrete compressive strength (psi or MPa)
+            fy: Steel yield strength (psi or MPa)
+            n_bars: Number of reinforcement bars
+            bar_area: Area of each bar (in2 or mm2)
+            Es: Modulus of elasticity of steel (psi or MPa). Default based on unit system.
+            beta1: Stress block factor. Default calculated from fc.
+            epsilon_cu: Ultimate concrete strain. Default 0.003.
+            unit_system: 'imperial' (psi, in) or 'si' (MPa, mm)
+        """
+        self.b = b
+        self.h = h
+        self.d = d
+        self.fc = fc
+        self.fy = fy
+        self.n_bars = n_bars
+        self.bar_area = bar_area
+        self.As = n_bars * bar_area
+        self.epsilon_cu = epsilon_cu
+        self.unit_system = unit_system.lower()
+        
+        # Set Es default based on unit system
+        if Es is None:
+            self.Es = 29000000 if self.unit_system == "imperial" else 200000
+        else:
+            self.Es = Es
+        
+        # Set beta1 - calculate if not provided
+        if beta1 is None:
+            self.beta1 = self._calculate_beta1()
+        else:
+            self.beta1 = beta1
+
+    def _calculate_beta1(self) -> float:
+        """Calculates beta1 based on fc per ACI 318."""
+        if self.unit_system == "imperial":
+            # fc in psi
+            if self.fc <= 4000:
+                return 0.85
+            elif self.fc >= 8000:
+                return 0.65
+            else:
+                return 0.85 - 0.05 * (self.fc - 4000) / 1000
+        else:
+            # fc in MPa
+            if self.fc <= 28:
+                return 0.85
+            elif self.fc >= 55:
+                return 0.65
+            else:
+                return 0.85 - 0.05 * (self.fc - 28) / 7
+
+    def calculate_as_min(self) -> float:
+        """
+        Calculate minimum steel area per ACI 318.
+        
+        Imperial: As_min = max(3*sqrt(fc)/fy * b*d, 200/fy * b*d)
+        SI: As_min = max(0.25*sqrt(fc)/fy * b*d, 1.4/fy * b*d)
+        """
+        if self.unit_system == "imperial":
+            term1 = (3 * math.sqrt(self.fc) / self.fy) * self.b * self.d
+            term2 = (200 / self.fy) * self.b * self.d
+        else:
+            term1 = (0.25 * math.sqrt(self.fc) / self.fy) * self.b * self.d
+            term2 = (1.4 / self.fy) * self.b * self.d
+        return max(term1, term2)
+
+    def calculate_mn(self) -> dict:
+        """
+        Calculates Nominal Moment Capacity (Mn) and related values.
+        
+        Returns:
+            dict with all calculated values including:
+            - T: Tension force
+            - a: Depth of stress block
+            - c: Neutral axis depth
+            - epsilon_y: Yield strain
+            - epsilon_s: Steel strain at ultimate
+            - yield_check: Whether steel yields
+            - fs: Steel stress
+            - Mn: Nominal moment
+            - Mn_display: Moment in display units (k-ft or kN-m)
+            - As_min: Minimum steel area
+            - as_check: Whether As >= As_min
+            - phi: Strength reduction factor
+            - Mu: Design moment capacity
+        """
+        # Tension force
+        T = self.As * self.fy
+        
+        # Stress block depth
+        a = (self.As * self.fy) / (0.85 * self.fc * self.b)
+        
+        # Neutral axis depth
+        c = a / self.beta1
+        
+        # Strains
+        epsilon_y = self.fy / self.Es
+        epsilon_s = self.epsilon_cu * (self.d - c) / c
+        
+        # Check if steel yields
+        yield_check = epsilon_s >= epsilon_y
+        fs = self.fy if yield_check else epsilon_s * self.Es
+        
+        # Nominal moment
+        Mn = self.As * fs * (self.d - a / 2)
+        
+        # Convert to display units
+        if self.unit_system == "imperial":
+            Mn_display = Mn / 12000  # lb-in to k-ft
+            T_display = T / 1000  # lb to kips
+            Mn_k = Mn / 1000  # lb-in to k-in
+        else:
+            Mn_display = Mn / 1e6  # N-mm to kN-m
+            T_display = T / 1000  # N to kN
+            Mn_k = Mn  # N-mm
+        
+        # Minimum steel check
+        As_min = self.calculate_as_min()
+        as_check = self.As >= As_min
+        
+        # Phi factor (ACI 318)
+        epsilon_t = epsilon_s  # For tension-controlled check
+        if epsilon_t >= 0.005:
+            phi = 0.9
+        elif epsilon_t <= 0.002:
+            phi = 0.65
+        else:
+            phi = 0.65 + 0.25 * (epsilon_t - 0.002) / 0.003
+        
+        Mu = phi * Mn
+        if self.unit_system == "imperial":
+            Mu_display = Mu / 12000
+        else:
+            Mu_display = Mu / 1e6
+        
+        return {
+            "T": T,
+            "T_display": T_display,
+            "a": a,
+            "c": c,
+            "epsilon_y": epsilon_y,
+            "epsilon_s": epsilon_s,
+            "yield_check": yield_check,
+            "fs": fs,
+            "Mn": Mn,
+            "Mn_k": Mn_k,
+            "Mn_display": Mn_display,
+            "As": self.As,
+            "As_min": As_min,
+            "as_check": as_check,
+            "epsilon_t": epsilon_t,
+            "phi": phi,
+            "Mu": Mu,
+            "Mu_display": Mu_display,
+            # Legacy compatibility
+            "Mn_kft": Mn_display if self.unit_system == "imperial" else None,
+            "Mn_kin": Mn_k / 1000 if self.unit_system == "imperial" else None,
+            "Mu_kft": Mu_display if self.unit_system == "imperial" else None,
+        }
+
+    def get_units(self) -> dict:
+        """Get unit labels based on current unit system."""
+        if self.unit_system == "imperial":
+            return {
+                "length": "in",
+                "area": "in^2",
+                "force": "lb",
+                "force_k": "kips",
+                "stress": "psi",
+                "moment": "lb-in",
+                "moment_k": "k-in",
+                "moment_display": "k-ft",
+            }
+        else:
+            return {
+                "length": "mm",
+                "area": "mm^2",
+                "force": "N",
+                "force_k": "kN",
+                "stress": "MPa",
+                "moment": "N-mm",
+                "moment_k": "N-mm",
+                "moment_display": "kN-m",
+            }

db_manager.py

@@ -0,0 +1,45 @@
+import sqlite3
+import json
+from datetime import datetime
+
+DB_NAME = "beam_calc.db"
+
+def init_db():
+    conn = sqlite3.connect(DB_NAME)
+    c = conn.cursor()
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS calculations (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp TEXT,
+            inputs TEXT,
+            results TEXT
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def save_calculation(inputs: dict, results: dict):
+    conn = sqlite3.connect(DB_NAME)
+    c = conn.cursor()
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    c.execute('INSERT INTO calculations (timestamp, inputs, results) VALUES (?, ?, ?)',
+              (timestamp, json.dumps(inputs), json.dumps(results)))
+    conn.commit()
+    conn.close()
+
+def get_history(limit=10):
+    conn = sqlite3.connect(DB_NAME)
+    c = conn.cursor()
+    c.execute('SELECT id, timestamp, inputs, results FROM calculations ORDER BY id DESC LIMIT ?', (limit,))
+    rows = c.fetchall()
+    conn.close()
+    
+    history = []
+    for row in rows:
+        history.append({
+            'id': row[0],
+            'timestamp': row[1],
+            'inputs': json.loads(row[2]),
+            'results': json.loads(row[3])
+        })
+    return history

requirements.txt

@@ -0,0 +1,3 @@
+customtkinter
+matplotlib
+numpy

test_calculator.py

@@ -0,0 +1,163 @@
+"""
+Unit tests for RectangularBeam calculator
+Tests based on ACI 318 Example 4-1 (Imperial) and 4-1M (SI)
+"""
+
+import unittest
+import math
+from calculator import RectangularBeam
+
+
+class TestRectangularBeamImperial(unittest.TestCase):
+    """Tests for Imperial unit calculations (Example 4-1)."""
+    
+    def setUp(self):
+        """Set up beam with Example 4-1 values."""
+        self.beam = RectangularBeam(
+            b=12.0,
+            h=20.0,
+            d=17.5,
+            fc=4000.0,
+            fy=60000.0,
+            n_bars=4,
+            bar_area=0.79,  # 4 x No. 8 bars
+            unit_system="imperial"
+        )
+        self.results = self.beam.calculate_mn()
+    
+    def test_steel_area(self):
+        """Test As = n_bars * bar_area."""
+        expected_As = 4 * 0.79  # 3.16 in2
+        self.assertAlmostEqual(self.results["As"], expected_As, places=2)
+    
+    def test_stress_block_depth_a(self):
+        """Test a = (As * fy) / (0.85 * fc * b)."""
+        # a = (3.16 * 60000) / (0.85 * 4000 * 12) = 4.647 in
+        self.assertAlmostEqual(self.results["a"], 4.647, delta=0.01)
+    
+    def test_neutral_axis_depth_c(self):
+        """Test c = a / beta1."""
+        # c = 4.647 / 0.85 = 5.467 in
+        expected_c = self.results["a"] / 0.85
+        self.assertAlmostEqual(self.results["c"], expected_c, delta=0.01)
+    
+    def test_nominal_moment(self):
+        """Test Mn calculation."""
+        # Mn = As * fy * (d - a/2) / 12000 k-ft
+        # Mn = 3.16 * 60000 * (17.5 - 4.647/2) / 12000 = 239.79 k-ft
+        self.assertAlmostEqual(self.results["Mn_display"], 239.79, delta=0.5)
+    
+    def test_tension_controlled(self):
+        """Test that beam is tension controlled (epsilon_t >= 0.005)."""
+        self.assertGreaterEqual(self.results["epsilon_t"], 0.005)
+        self.assertEqual(self.results["phi"], 0.9)
+    
+    def test_yield_check(self):
+        """Test that steel yields."""
+        self.assertTrue(self.results["yield_check"])
+    
+    def test_minimum_steel_check(self):
+        """Test minimum steel area calculation."""
+        # As_min for fc=4000, fy=60000, b=12, d=17.5
+        As_min = self.results["As_min"]
+        self.assertGreater(As_min, 0)
+        self.assertTrue(self.results["as_check"])  # As >= As_min
+
+
+class TestRectangularBeamSI(unittest.TestCase):
+    """Tests for SI unit calculations (Example 4-1M)."""
+    
+    def setUp(self):
+        """Set up beam with Example 4-1M values."""
+        self.beam = RectangularBeam(
+            b=250.0,
+            h=565.0,
+            d=500.0,
+            fc=20.0,
+            fy=420.0,
+            n_bars=3,
+            bar_area=510.0,  # 3 x 510 mm2 bars
+            unit_system="si"
+        )
+        self.results = self.beam.calculate_mn()
+    
+    def test_steel_area(self):
+        """Test As = n_bars * bar_area."""
+        expected_As = 3 * 510  # 1530 mm2
+        self.assertAlmostEqual(self.results["As"], expected_As, places=0)
+    
+    def test_stress_block_depth_a(self):
+        """Test a = (As * fy) / (0.85 * fc * b)."""
+        # a = (1530 * 420) / (0.85 * 20 * 250) = 151.76 mm
+        self.assertAlmostEqual(self.results["a"], 151.76, delta=1.0)
+    
+    def test_yield_check(self):
+        """Test that steel yields."""
+        self.assertTrue(self.results["yield_check"])
+    
+    def test_minimum_steel_check(self):
+        """Test minimum steel area calculation for SI."""
+        As_min = self.results["As_min"]
+        self.assertGreater(As_min, 0)
+
+
+class TestBeta1Calculation(unittest.TestCase):
+    """Tests for beta1 calculation based on fc."""
+    
+    def test_beta1_low_fc_imperial(self):
+        """Beta1 = 0.85 for fc <= 4000 psi."""
+        beam = RectangularBeam(
+            b=12, h=20, d=17.5, fc=4000, fy=60000,
+            n_bars=4, bar_area=0.79, unit_system="imperial"
+        )
+        self.assertEqual(beam.beta1, 0.85)
+    
+    def test_beta1_high_fc_imperial(self):
+        """Beta1 = 0.65 for fc >= 8000 psi."""
+        beam = RectangularBeam(
+            b=12, h=20, d=17.5, fc=8000, fy=60000,
+            n_bars=4, bar_area=0.79, unit_system="imperial"
+        )
+        self.assertEqual(beam.beta1, 0.65)
+    
+    def test_beta1_mid_fc_imperial(self):
+        """Beta1 interpolated for 4000 < fc < 8000 psi."""
+        beam = RectangularBeam(
+            b=12, h=20, d=17.5, fc=6000, fy=60000,
+            n_bars=4, bar_area=0.79, unit_system="imperial"
+        )
+        # beta1 = 0.85 - 0.05 * (6000 - 4000) / 1000 = 0.75
+        self.assertAlmostEqual(beam.beta1, 0.75, places=2)
+    
+    def test_beta1_override(self):
+        """Test that beta1 can be overridden."""
+        beam = RectangularBeam(
+            b=12, h=20, d=17.5, fc=4000, fy=60000,
+            n_bars=4, bar_area=0.79, beta1=0.70, unit_system="imperial"
+        )
+        self.assertEqual(beam.beta1, 0.70)
+
+
+class TestEdgeCases(unittest.TestCase):
+    """Tests for edge cases."""
+    
+    def test_single_bar(self):
+        """Test with single bar."""
+        beam = RectangularBeam(
+            b=12, h=20, d=17.5, fc=4000, fy=60000,
+            n_bars=1, bar_area=0.79, unit_system="imperial"
+        )
+        results = beam.calculate_mn()
+        self.assertEqual(results["As"], 0.79)
+    
+    def test_custom_epsilon_cu(self):
+        """Test with custom ultimate concrete strain."""
+        beam = RectangularBeam(
+            b=12, h=20, d=17.5, fc=4000, fy=60000,
+            n_bars=4, bar_area=0.79, epsilon_cu=0.0035, unit_system="imperial"
+        )
+        self.assertEqual(beam.epsilon_cu, 0.0035)
+
+
+if __name__ == '__main__':
+    unittest.main()