From Software User to Software Builder: Harnessing APIs in Structural Analysis

To view the figures and tables associated with this article, please refer to the flipbook above.

Modern structural engineering is advancing as quickly as the technology that supports it. What once began with hand drawn sketches and manual calculations has now evolved into a digital era where intelligent modeling, simulation, and data driven workflows define every stage of design. Powerful tools such as finite element analysis (FEA) have been a foundation of structural engineering practice for decades, with modern programs demonstrating the long-standing use of code and text-based modeling. As these tools grew more capable and complex, graphical user interfaces (GUIs) became the primary way engineers built models and reviewed results. Today, the increasing use of application programming interfaces (APIs) allows engineers to interact with these same models in ways that are often more efficient and flexible than other workflows.

As projects become larger and more intricate, many professionals are realizing that true efficiency doesn’t always come from more complex software, it often comes from simpler, smarter customization. This customization often shows up as small, focused programs that automate calculations, check results, or extract and process data, allowing engineers to tailor their workflows without overhauling their primary analysis tools, and it is called scripting. In practice, scripting appears in two common forms. Standalone scripting, often written in languages such as Python or MATLAB, is used to perform calculations or verification checks outside of commercial software. API based scripting, typically implemented using Python, C#, or VBA, allows engineers to programmatically control or query commercial FEA tools. In both cases, scripting complements traditional analysis software rather than replacing it, enabling engineers to automate repetitive tasks, verify results, and run targeted studies that deepen understanding and improve design confidence.

Recent advancements in structural engineering software have changed how engineers interact with analytical models, largely by making commercial tools more open to automation and external control. Rather than relying solely on graphical user interfaces GUIs, many widely used programs now allow engineers to interact with models programmatically through scripting tools and APIs. Commercial engineering software falls into three main categories when it comes to automation:

Together, these capabilities shift engineers away from manual data entry and repetitive clicking toward more efficient, logic-driven workflows. By defining how a model is built, analyzed, and checked through scripts, engineers can automate verification, perform parametric studies, and maintain clearer control over assumptions while continuing to rely on trusted commercial analysis software for core computation.

Engineers now have several effective options for scripting, each with clear strengths:

Most engineers start with Python for broader workflows and keep VBA for fast Excel-based tasks.

FEA is a mature and indispensable tool in structural engineering, but the quality of its results remains closely tied to the assumptions made during model development. Boundary conditions, mesh refinement, material properties, and load definitions all have a significant influence on predicted behavior, and small modeling choices can lead to meaningful differences in results.
Since these assumptions are often difficult to evaluate through a single model run, engineers frequently rely on judgment and experience to assess whether results are reasonable. This is where scripting becomes a valuable companion to FEA. By automating model variations such as adjusting boundary conditions, refining mesh density, or modifying load cases, engineers can efficiently perform parametric studies that reveal how sensitive a model is to key assumptions. Rather than replacing engineering judgment, scripting helps expose trends, confirm expectations, and build greater confidence in analytical results.

To illustrate how scripting can complement structural analysis, consider an engineer who is reviewing internal forces and reactions from a commercial FEA model of a cantilevered structural element subjected to combined loading. The desired goal is to confirm whether the shear forces, bending moments, and sign conventions are reasonable or not before relying on the full model for design decisions. In that case, the engineer can use a low code external script made up of Python that calculates shear forces and bending moments in a cantilever beam. While the full version uses a class-based structure for clarity and reusability, beginners can start with a straightforward procedural version to perform the same calculations.

The example works in U.S. customary units. Scan the QR code for the full code.
The provided script models a 15-foot cantilever beam subjected to a 12 kip point load at 6 feet from the support and a uniform load of 3 kip/ft from length 2 feet to 7 feet. It calculates and displays the shear force and bending moment at several points along the beam, as well as the fixed end reactions at the support. The output provides a clear snapshot of how the beam responds to combined loading, helping verify that the distribution of forces and moments aligns with theoretical expectations.

The example works in U.S. customary units.

# Cantilever Beam Analysis (Procedural Version)

# Units: kips, feet

# Positive load = downward

# Returns internal shear V(x) and bending moment M(x)

# Beam length

L = 15.0  # ft

# Point loads: (P, x)

point_loads = [

    (12.0, 6.0)  # 12 kips at 6 ft

]

# Uniform loads: (w, a, b)

udls = [

    (3.0, 2.0, 7.0)  # 3 k/ft from 2 ft to 7 ft

]

def shear(x):

    """Shear force at section x (kips)"""

    Vx = 0.0

    for P, xp in point_loads:

        if xp >= x:

            Vx -= P

    for w, a, b in udls:

        if x <= a:

            Vx -= w * (b - a)

        elif a < x < b:

            Vx -= w * (b - x)

    return Vx

def moment(x):

    """Bending moment at section x (kip-ft)"""

    Mx = 0.0

    for P, xp in point_loads:

        if xp >= x:

            Mx -= P * (xp - x)

    for w, a, b in udls:

        if x <= a:

            W = w * (b - a)

            xbar = (a + b) / 2.0

            Mx -= W * (xbar - x)

        elif a < x < b:

            W = w * (b - x)

            xbar = (x + b) / 2.0

            Mx -= W * (xbar - x)

    return Mx

# Evaluation points

x_points = [0, 2, 4, 6, 8, 10, 12, 14, 15]

print("x (ft) | Shear V (kips) | Moment M (kip-ft)")

for x in x_points:

    print(f"{x:5.1f} | {shear(x):13.3f} | {moment(x):15.3f}")

print("\nFixed-end reactions:")

print(f"  Shear  V(0) = {shear(0):.3f} kips")

print(f"  Moment M(0) = {moment(0):.3f} kip-ft")

# Cantilever Beam Analysis

# Loads in kips, distances in ft

# Positive load = downward

# Computes internal shear (V) and bending moment (M) at any point x

from dataclasses import dataclass

from typing import List

@dataclass

class PointLoad:

    P: float   # load in kips

    x: float   # location in ft from fixed end

@dataclass

class UDL:

    w: float   # uniform load in kips/ft

    a: float   # start position in ft

    b: float   # end position in ft

class Cantilever:

def __init__(self, L: float, point_loads: List[PointLoad]=None, udls: List[UDL]=None):

        self.L = L

        self.point_loads = point_loads

        self.udls = udls

    def V(self, x: float) -> float:

        """Shear at section x (kips)"""

        Vx = 0.0

        for pl in self.point_loads:

            if pl.x >= x:

                Vx -= pl.P

        for u in self.udls:

            if x <= u.a:

                Vx -= u.w * (u.b - u.a)

            elif u.a < x < u.b:

                Vx -= u.w * (u.b - x)

        return Vx

    def M(self, x: float) -> float:

        """Bending moment at section x (kip-ft)"""

        Mx = 0.0

        for pl in self.point_loads:

            if pl.x >= x:

                Mx -= pl.P * (pl.x - x)

        for u in self.udls:

            if x <= u.a:

                W = u.w * (u.b - u.a)

                xbar = (u.a + u.b) / 2.0

                Mx -= W * (xbar - x)

            elif u.a < x < u.b:

                W = u.w * (u.b - x)

                xbar = (x + u.b) / 2.0

                Mx -= W * (xbar - x)

        return Mx

# Example

if __name__ == "__main__":

    L = 15.0  # beam length in ft

    # Example: 12 kips point load at 6 ft, and 3 k/ft UDL from 2–7 ft

    point_loads = [PointLoad(P=12, x=6)]

    udls = [UDL(w=3, a=2, b=7)]

    beam = Cantilever(L, point_loads, udls)

    # Evaluate along beam

    x_points = [0, 2, 4, 6, 8, 10,12,14,15]

    print("x(ft) | Shear V (kips) | Moment M (kip-ft)")

    for x in x_points:

        print(f"{x:5.1f} | {beam.V(x):13.3f} | {beam.M(x):15.3f}")

    # Fixed-end reactions (at wall)

    print("\nFixed-end reactions:")

    print(f"  Shear  V(0) = {beam.V(0):.3f} kips")

    print(f"  Moment M(0) = {beam.M(0):.3f} kip-ft")

The provided script models a 15 feet cantilever beam subjected to a 12 kip point load at 6 feet from the support and a uniform load of 3 kip/feet from length 2 feet to 7 feet. It calculates and displays the shear force and bending moment at several points along the beam, as well as the fixed end reactions at the support. The output provides a clear snapshot of how the beam responds to combined loading, helping verify that the distribution of forces and moments aligns with theoretical expectations.

x(ft)     Shear V (kips) Moment M (kip-ft)

  0.0     -27.000            -139.500

  2.0     -27.000            -85.500

  4.0     -21.000            -37.500

  6.0     -15.000            -1.500

  8.0     0.000   0.000

 10.0    0.000   0.000

 12.0    0.000   0.000

 14.0    0.000   0.000

 15.0    0.000   0.000

Fixed-end reactions:

  Shear  V(0) = -27.000 kips

  Moment M(0) = -139.500 kip-ft

Scripting allows engineers to perform quick checks and automate repetitive tasks, even for truss or bridge structures. Historically, command-based tools like GT STRUDL demonstrated that structural analysis could be performed entirely without a graphical interface. Today, modern scripting environments and APIs extend the same principle, enabling engineers to control bridge models, assign loads, and extract results programmatically.

Consider a 20 foot long, 10-foot-high Howe truss, representing a small bridge span. The truss is defined by joint coordinates and member connectivity, with pinned and roller supports representing typical boundary conditions. Vertical loads are applied at interior bottom chord joints. Using a headless/scripted workflow, the stiffness-based solver computes member forces without manual GUI interaction.

Practical Connection to Bridge Design:

Key Takeaways from Scripted Truss Analysis:

STRUDL '20 ft long and 10 ft high Howe Truss'

$ Define input units

UNITS KIPS FEET DEGREES

$ Define nodes [node no.] [x] [y]

JOINT COORDINATES

1      X 0     Y 0     Z 0     S

2      X 5     Y 0     Z 0    

3      X 10    Y 0     Z 0    

4      X 15    Y 0     Z 0    

5      X 20    Y 0     Z 0     S

6      X 5     Y 5     Z 0    

7      X 10    Y 10    Z 0    

8      X 15    Y 5     Z 0            

$ Define structure type

TYPE PLANE Truss

$ Release joint degrees of freedom

JOINT RELEASES

   $ node 1 is a pin

   1 MOMENT Z

   $ node 5 is a roller

   5 MOMENT Z FORCE X

$ Define members

MEMBER INCIDENCES

1      1       2

2      2       3

3      3       4

4      4       5

5      1       6

6      6       7

7      7       8

8      8       5

9      2       6

10     3       6

11     3       7

12     3       8

13     4       8

$ Define materials

MATERIAL STEEL ALL MEMBERS

$ Define member properties

MEMBER PROPERTIES PRISMATIC

   1 TO 13   AX 10 IX 10 IY 10 IZ 10

$ Define loads

LOADING  'External Loads'

JOINT LOADS

   2 FORCE Y -2.0

   3 FORCE Y -2.0

   4 FORCE Y -2.0

$ Run analysis

STIFFNESS ANALYSIS

Fig. A. Geometry and member layout along with loads and reactions of the 20-ft Howe truss obtained from GT STRUDL

The resulting member forces in the below table confirm the expected axial force distribution for a Howe truss under vertical loading. Compression and tension patterns align with theoretical predictions, providing a clear verification of both modeling assumptions and solver behavior. When considered alongside the python cantilever example, this truss model reinforces a central message of this article, i.e. scripting whether through modern code or command window connects theory, verification, and full-scale analysis. It strengthens structural intuition and builds confidence in computational results by making the engineer’s assumptions and logic visible.

Scripting has long been used to automate tasks in structural analysis, but modern integration through APIs has expanded its role, redefining how engineers interact with FEA models. Short, customized scripts often written in different programming language or through APIs allow engineers to automate tasks, perform quick verifications, and explore “what-if” scenarios within minutes. These small, focused programs can check reactions, moments, or deflections, providing independent validation before larger models are built.

Scripting brings flexibility, transparency, and control to the design process. Every assumption such as load magnitude, span length, boundary condition, or sign convention is clearly visible in the code, making reviews and revisions straightforward. Engineers can modify parameters instantly, test different configurations, and compare results efficiently. Beyond verification, scripting automates repetitive tasks such as load combinations, geometry generation, and data extraction, saving time for more creative and analytical work. It blurs the line between programming and engineering which helps in transforming models into intelligent, adaptive systems.

The future of structural engineering is moving toward a seamless blend of coding and design. Upcoming generations of engineers will likely spend as much time in scripting environments as in drafting software, using custom code as the bridge that connects analysis, documentation, and data management. Writing a few lines of Python to analyze a beam or having a simple command code to analyze a truss might seem simple, but it represents a deeper shift of engineers gaining control over their tools rather than relying solely on commercial software updates. Through scripting, they can create solutions that are precise, transparent, and tailored to their needs. At its best, coding transforms computation into craftsmanship, empowering engineers to think critically, test ideas rapidly, and design with greater confidence and clarity. ■

About the Author

Pawan Bhattarai, M.S.C.E., EIT, graduated with a degree in civil engineering from Idaho State University and works as a bridge engineer in the state of Arkansas. His professional interests include bridge design, structural analysis, and the application of computational methods in civil engineering practice.

References