Detailed Breakdown: Composite Beam Deflection Calculation Logic

This document explains the step-by-step process used by the "Composite Beam Deflection Calculator" to determine the deflection of a composite beam. The explanation refers to the JavaScript functions within the provided HTML file.

1. User Input and Initial Processing

When you click the "Calculate Deflection" button:

1. Event Trigger: An event listener attached to the form (beamForm) captures the submit event.
2. Input Collection: Values from all input fields in the HTML form are read. These include:
   • Beam and support dimensions (Total Length, Support A Location, Support B Location) - Input in feet (ft).
   • Loading properties (Surface Load at Start, Surface Load at End, Tributary Width, Load Mode Toggle, Number of Data Points, Deflection Limit Denominator).
     • Surface Loads - Input in lbf/ft² (psf).
     • Tributary Width - Input in feet (ft).
   • Material 1 properties (E, A, I_cg, ycg, h, Start X, End X).
     • Material 1 Start/End X - Input in feet (ft).
     • Other Material 1 properties - Input in inch/psi based units (psi, in², in⁴, inches).
   • Material 2 properties (E, A, I_cg, ycg, h) - Input in inch/psi based units.
3. Unit Conversion to Internal Standards (Inches, lbf/in):
   • Lengths: Total beam length, support locations, and Material 1 start/end x-positions (initially in feet) are converted to inches by multiplying by 12.
     • Example (using testvalues.png defaults): Total Beam Length: 8 ft * 12 = 96 inches.
   • Line Loads:
     1. The surface loads (psf) are first multiplied by the tributary width (ft) to get a line load in lbf/ft.
        • Example: Surface Load at Start = 106 psf, Tributary Width = 2 ft => Initial Line Load at Start = 106 * 2 = 212 lbf/ft.
     2. These line loads (lbf/ft) are then converted to lbf/in by dividing by 12.
        • Example: Line Load at Start = 212 lbf/ft / 12 = 17.667 lbf/in.
   • All other material properties (E, A, I_cg, ycg, h) are assumed to be already in the consistent internal units (psi, in², in⁴, inches).
4. Parameter Packaging: All these processed and converted values are packaged into an object (params_inch_based) which is then passed to the main calculation function, calculateBeamDeflection. This object also includes the state of the isPointLoadMode toggle.

2. Core Calculation: calculateBeamDeflection Function

This function is the heart of the analysis. It takes the params_inch_based object.

2.1. Discretization (X-Coordinates)

• The beam's total length (now in inches) is divided into num_points - 1 equal segments.
• An array x is created containing the x-coordinates (in inches) of these points, from 0 to L_beam_total.

2.2. Local Beam Properties (EI_eff, y_NA, I_transformed)

• For each x-coordinate in the x array, the function getLocalBeamProperties(xi, mat1_props, mat2_props) is called.
• getLocalBeamProperties Function:
  1. Determines Material Presence: Checks if the current xi falls within the defined start and end x-positions of Material 1 (mat1_props.x_start_mat1 to mat1_props.x_end_mat1).
  2. If Material 1 is Present (and Material 2's E ≠ 0):
     • Transformed Section Method: Material 1 is transformed into an equivalent area of Material 2.
       • Modular Ratio (n): mat1_E / mat2_E.
       • Transformed Area of Mat 1 (A1_transformed): mat1_A * n.
       • Transformed I_cg of Mat 1 (I1_cg_transformed): mat1_I_cg * n.
     • Neutral Axis (NA) Calculation:
       • Global y-centroids of Material 1 and Material 2 (from the bottom of Material 2) are determined.
       • The composite Neutral Axis (y_NA_val) is found using the formula: y_NA = (A1_transformed * y1_cg_global + A2 * y2_cg_global) / (A1_transformed + A2).
     • Transformed Moment of Inertia (I_transformed_val):
       • The Parallel Axis Theorem is used to find the moment of inertia of each material's (transformed, if applicable) section about the composite NA.
       • I_transformed_val = I1_NA_transformed + I2_NA. This I is relative to mat2_E.
     • Effective Flexural Rigidity (EI_val): mat2_E * I_transformed_val.
  3. If Material 1 is Present BUT Material 2's E = 0 (and Material 1's E ≠ 0):
     • The section behaves as Material 1 alone.
     • y_NA_val is the centroid of Material 1 (relative to the bottom of Material 2).
     • I_transformed_val becomes mat1_I_cg (Material 1's own moment of inertia).
     • EI_val becomes mat1_E * mat1_I_cg.
  4. If Only Material 2 is Present (or Material 1 has no stiffness/area):
     • y_NA_val is the centroid of Material 2.
     • I_transformed_val is mat2_I_cg.
     • EI_val is mat2_E * mat2_I_cg.
  5. Edge Cases: Handles NaN or negative EI values by setting them to 0.
• The results (EI_eff_array[i], y_NA_array[i], I_transformed_total_array[i]) are stored for each point.

2.3. Support Reactions (R_a_reaction, R_b_reaction)

The method depends on isPointLoadMode:

• If isPointLoadMode is true (Point Load Mode):
  1. Hypothetical End Reactions: The code first calculates the reactions (derived_P1_lbf_at_0, derived_P2_lbf_at_L) that would occur if the entire tapered distributed line load (defined by w_start_line_load_lbf_in and w_end_line_load_lbf_in) were applied to a beam of length L_beam_total simply supported at its extreme ends (x=0 and x=L_beam_total).
     • derived_P1_lbf_at_0 = (L_beam_total / 6) * (2 * w_start_line_load_lbf_in + w_end_line_load_lbf_in)
     • derived_P2_lbf_at_L = (L_beam_total / 6) * (w_start_line_load_lbf_in + 2 * w_end_line_load_lbf_in)
  2. Actual Support Reactions: These derived_P1_lbf_at_0 and derived_P2_lbf_at_L are then treated as the point loads applied at x=0 and x=L_beam_total respectively on the actual beam (which has supports at a_support and b_support).
     • Reactions are found by summing moments about one support (e.g., a_support) to find the other reaction, then summing vertical forces.
       • R_b_reaction = (derived_P1_lbf_at_0 * a_support + derived_P2_lbf_at_L * (L_beam_total - a_support)) / (b_support - a_support)
       • R_a_reaction = derived_P1_lbf_at_0 + derived_P2_lbf_at_L - R_b_reaction
       • (Note: The moment arms are relative to the support a_support. a_support itself is the distance from x=0 to the first support. The moment of derived_P1_lbf_at_0 (at x=0) about a_support is derived_P1_lbf_at_0 * (a_support - 0)).
• If isPointLoadMode is false (Distributed Load Mode):
  1. Total Load & Centroid: The total force from the tapered distributed load (F_total_load) and the location of its resultant (x_bar_load) are calculated.
     • k_slope = (w_end_line_load_lbf_in - w_start_line_load_lbf_in) / L_beam_total
     • F_total_load = (w_start_line_load_lbf_in + w_end_line_load_lbf_in) * L_beam_total / 2
     • x_bar_load = L_beam_total * (w_start_line_load_lbf_in + 2 * w_end_line_load_lbf_in) / (3 * (w_start_line_load_lbf_in + w_end_line_load_lbf_in)) (with handling for zero denominator).
  2. Actual Support Reactions: Reactions are found by summing moments and forces.
     • R_b_reaction = F_total_load * (x_bar_load - a_support) / (b_support - a_support)
     • R_a_reaction = F_total_load - R_b_reaction

2.4. Bending Moment (M_vals)

For each point xi in the x array, the bending moment is calculated using singularity functions (eval_s(value, power) which returns value^power if value > 0, else 0).

• If isPointLoadMode is true:
  M(xi) = R_a * <xi - a_support>^1 + R_b * <xi - b_support>^1 - derived_P1_at_0 * <xi - 0>^1 - derived_P2_at_L * <xi - L_beam_total>^1
• If isPointLoadMode is false:
  M(xi) = R_a * <xi - a_support>^1 + R_b * <xi - b_support>^1 - (w_start_line_load_lbf_in / 2) * xi^2 - (k_slope / 6) * xi^3
  (Note: The distributed load terms <xi-0>^2 and <xi-0>^3 are simplified to xi^2 and xi^3 as they start at x=0).

2.5. Curvature (kappa_vals)

• For each point, curvature κ = M / EI.
• kappa_vals[i] = M_vals[i] / EI_eff_array[i].
• Handles cases where EI_eff might be zero (if M is also zero, curvature is zero; if M is non-zero and EI_eff is zero, an error is thrown).

2.6. Numerical Integration for Slope and Raw Deflection

The cumtrapz(x_array, y_array) function performs cumulative numerical integration using the trapezoidal rule.

1. Slope (slope_raw): slope_raw = ∫ κ dx = cumtrapz(x, kappa_vals). This gives the slope at each point relative to an unknown integration constant.
2. Raw Deflection (deflection_raw): deflection_raw = ∫ slope_raw dx = cumtrapz(x, slope_raw). This gives a deflection profile that satisfies the curvature but doesn't yet meet the boundary conditions (zero deflection at supports). It's off by C1*x + C2.

2.7. Applying Boundary Conditions (Solving for Integration Constants)

The beam is supported, so deflection at the support locations (a_support, b_support) must be zero.

1. Interpolate Raw Deflection: The interp1(x, deflection_raw, target_x) function (linear interpolation) is used to find the raw deflection values at a_support and b_support:
   • val_def_raw_at_a = interp1(x, deflection_raw, a_support)
   • val_def_raw_at_b = interp1(x, deflection_raw, b_support)
2. Solve for Constants C1_num and C2_num:
   We have two equations based on y(support) = 0:
   • deflection_raw(a_support) + C1_num * a_support + C2_num = 0
   • deflection_raw(b_support) + C1_num * b_support + C2_num = 0
   This 2x2 system is solved for C1_num and C2_num.

2.8. Final Deflection

• The final deflection at each point xi is calculated:
  deflection[i] = deflection_raw[i] + C1_num * x[i] + C2_num.

2.9. Maximum Deflection and Location

• The code iterates through the deflection array to find the maximum absolute deflection (overall_max_deflection) and its corresponding x-coordinate (overall_x_max_deflection).

2.10. Deflection Limit Checks

1. Segment Lengths: Lengths of the left overhang (L_oh_left_in), span between supports (L_span_in), and right overhang (L_oh_right_in) are calculated.
2. Allowable Limits:
   • Overhangs: limit = (2 * L_overhang) / deflectionLimitDenominator
   • Span: limit = L_span / deflectionLimitDenominator
   • (The deflectionLimitDenominator is taken from user input, defaulting to 180).
3. Segment Max Deflections: The code iterates through the deflection array again to find the maximum absolute deflection (and its signed value and location) specifically within each of these three segments.
4. Status: For each segment, the calculated maximum absolute deflection is compared to its allowable limit to determine a "Pass," "Fail," or "N/A" (if the segment doesn't exist or has no finite deflection) status.

3. Output

The function returns an object containing:

• deflection array (inches)
• x array (inches)
• Overall maximum deflection and its location
• Arrays for y_NA and I_transformed_total at each point
• Support reactions R_a_reaction, R_b_reaction (lbf)
• Detailed results for the deflection limit checks for each segment.

This data is then used by the JavaScript in the HTML file to populate the results tables.