Statics

Statics is the branch of mechanics that deals with bodies at rest or in equilibrium under the action of forces. For civil engineers, statics forms the foundation for structural analysis, enabling the design of safe and efficient structures that can withstand applied loads without moving or collapsing.

Fundamental Concepts

Force Systems

A force is a vector quantity characterized by magnitude, direction, and point of application. Forces can be classified as:

• Concentrated (Point) Forces: Applied at a single point
• Distributed Forces: Spread over an area or length
• Body Forces: Act throughout the volume (e.g., gravity)

The resultant of multiple forces is found through vector addition:

For forces in a plane:

Moments and Couples

The moment of a force about a point measures its tendency to cause rotation:

Where $d$ is the perpendicular distance from the point to the line of action of the force.

For a force with components:

A couple consists of two equal and opposite parallel forces separated by a distance $d$:

The moment of a couple is the same about any point in the plane.

Varignon's Theorem

The moment of a force about a point equals the sum of the moments of its components about the same point:

Equilibrium Conditions

For a body to be in static equilibrium, both the resultant force and resultant moment must be zero.

Two-Dimensional Equilibrium

These three equations can solve for up to three unknowns.

Three-Dimensional Equilibrium

Six equations can solve for up to six unknowns.

Support Reactions

Different support types provide different reaction forces and moments:

Statically Determinate vs. Indeterminate

A structure is statically determinate if all reactions can be found using equilibrium equations alone:

Where $r$ is the number of reactions and $n$ is the number of rigid bodies.

If $r > 3n$, the structure is statically indeterminate with degree of indeterminacy:

Distributed Loads

Distributed loads are expressed as force per unit length $w(x)$ (typically in kN/m or lb/ft).

Uniformly Distributed Load (UDL)

For a UDL of intensity $w$ over length $L$:

Acting at the centroid (midpoint for UDL).

Triangularly Distributed Load

For a triangular load varying from 0 to $w_{max}$:

Acting at $\frac{L}{3}$ from the larger end.

General Distributed Load

Truss Analysis

Trusses are structures composed of straight members connected at joints (pins). Members carry only axial forces (tension or compression).

Assumptions

1. Members are connected by frictionless pins
2. Loads are applied only at joints
3. Weight of members is negligible
4. Members are straight and carry only axial forces

Method of Joints

Analyze equilibrium of each joint sequentially:

At each joint: $\sum F_x = 0$, $\sum F_y = 0$

Start at joints with only two unknown member forces.

Method of Sections

Cut through the truss and analyze equilibrium of one section:

Useful when only specific member forces are needed.

Zero-Force Members

Members carrying no force under given loading:

1. At a joint with only two non-collinear members and no external load, both members are zero-force members
2. At a joint with three members where two are collinear, the third is a zero-force member (if no external load)

Centroids and Moments of Inertia

Centroid of an Area

Common Shapes

Moment of Inertia (Second Moment of Area)

Parallel Axis Theorem

Where $I_c$ is the moment of inertia about the centroidal axis and $d$ is the distance to the parallel axis.

Common Moments of Inertia

Friction

Static Friction

Where $\mu_s$ is the coefficient of static friction and $N$ is the normal force.

Kinetic Friction

Angle of Friction

Wedge and Screw Analysis

For self-locking condition in screws:

Where $\theta$ is the helix angle and $\phi$ is the friction angle.

Real-World Application: Bridge Truss Analysis

Analyzing forces in a bridge truss under traffic loading.

Truss Analysis Example

import math

# Bridge truss parameters
truss_params = {
    'span': 24.0,           # meters
    'height': 6.0,          # meters
    'num_panels': 4,        # number of panels
    'dead_load': 15.0,      # kN/m (self-weight)
    'live_load': 25.0,      # kN/m (traffic)
    'panel_load': 0.0       # will be calculated
}

# Calculate panel length and joint loads
panel_length = truss_params['span'] / truss_params['num_panels']
total_load = truss_params['dead_load'] + truss_params['live_load']  # kN/m
joint_load = total_load * panel_length  # kN per interior joint

# Calculate support reactions (simply supported)
total_span_load = total_load * truss_params['span']
reaction = total_span_load / 2  # Each support takes half

# Analyze member forces using method of sections
# For a Pratt truss, calculate diagonal and chord forces
theta = math.atan(truss_params['height'] / panel_length)

# Bottom chord force at midspan (maximum)
moment_at_midspan = reaction * (truss_params['span'] / 2) - total_load * (truss_params['span'] / 2) * (truss_params['span'] / 4)
bottom_chord_force = moment_at_midspan / truss_params['height']

# Diagonal force in first panel
shear_at_first_panel = reaction - joint_load / 2
diagonal_force = shear_at_first_panel / math.sin(theta)

print(f"Bridge Truss Analysis Results:")
print(f"  Span: {truss_params['span']} m")
print(f"  Panel length: {panel_length} m")
print(f"  Total load: {total_load} kN/m")
print(f"  Support reaction: {reaction:.2f} kN")
print(f"  Bottom chord force (max): {bottom_chord_force:.2f} kN (Tension)")
print(f"  First diagonal force: {abs(diagonal_force):.2f} kN ({'Tension' if diagonal_force > 0 else 'Compression'})")
print(f"  Truss angle: {math.degrees(theta):.1f} degrees")

# Member sizing recommendation
allowable_stress_tension = 250  # MPa for steel
allowable_stress_compression = 150  # MPa (reduced for buckling)

required_area_bottom = (bottom_chord_force * 1000) / allowable_stress_tension  # mm^2
required_area_diagonal = (abs(diagonal_force) * 1000) / allowable_stress_compression  # mm^2

print(f"\nMember Sizing (Steel):")
print(f"  Bottom chord minimum area: {required_area_bottom:.0f} mm^2")
print(f"  Diagonal minimum area: {required_area_diagonal:.0f} mm^2")

Your Challenge: Beam Reaction Analysis

Calculate the support reactions for a beam with multiple load types.

Goal: Determine the reactions at supports for a beam subjected to point loads and distributed loads.

Problem Setup

import math

# Beam configuration
beam_config = {
    'length': 10.0,           # meters (total span)
    'support_A_position': 0,  # left support (pin)
    'support_B_position': 10, # right support (roller)

    # Point loads
    'point_loads': [
        {'position': 3.0, 'magnitude': 50.0},   # 50 kN at 3m from left
        {'position': 7.0, 'magnitude': 30.0}    # 30 kN at 7m from left
    ],

    # Distributed load
    'udl_start': 4.0,         # start position of UDL
    'udl_end': 8.0,           # end position of UDL
    'udl_intensity': 20.0     # kN/m
}

# TODO: Calculate support reactions using equilibrium equations
# Step 1: Calculate the resultant of the distributed load
udl_length = beam_config['udl_end'] - beam_config['udl_start']
udl_resultant = beam_config['udl_intensity'] * udl_length
udl_position = beam_config['udl_start'] + udl_length / 2

# Step 2: Apply equilibrium equations
# Sum of moments about A = 0 (to find reaction at B)
# Sum of vertical forces = 0 (to find reaction at A)

moment_about_A = 0
total_vertical_load = 0

# Add point load contributions
for load in beam_config['point_loads']:
    moment_about_A += load['magnitude'] * load['position']
    total_vertical_load += load['magnitude']

# Add UDL contribution
moment_about_A += udl_resultant * udl_position
total_vertical_load += udl_resultant

# Calculate reaction at B
R_B = moment_about_A / beam_config['length']

# Calculate reaction at A
R_A = total_vertical_load - R_B

print(f"Beam Analysis Results:")
print(f"  Span: {beam_config['length']} m")
print(f"  Total applied load: {total_vertical_load:.2f} kN")
print(f"  Reaction at A (Pin): {R_A:.2f} kN")
print(f"  Reaction at B (Roller): {R_B:.2f} kN")

# Verify equilibrium
sum_forces = R_A + R_B - total_vertical_load
sum_moments = R_B * beam_config['length'] - moment_about_A

print(f"\nEquilibrium Check:")
print(f"  Sum of vertical forces: {sum_forces:.6f} kN (should be 0)")
print(f"  Sum of moments about A: {sum_moments:.6f} kN-m (should be 0)")

How would you extend this analysis to determine the maximum bending moment and its location along the beam?