Structural Engineering · Course
Computational Engineering
Using computation to design, analyse and improve structures responsibly.
This is not a finite-element course, a programming course, a BIM course, an optimisation course or an AI course. It connects those subjects and teaches the judgement needed to use them safely: what to model and what to leave out, which method fits the question, how information moves between tools without being silently corrupted, how to check the output, and where automation should stop. Every number quoted anywhere in the course — in a lesson, a worked example, a figure or an interactive — is computed by a tested calculation library rather than typed in.
Who it is for
- Engineers who build analysis models and want to build better ones
- Engineers who check other people's models and want to know what to look for
- Graduates taught the finite element method as mathematics and not as modelling
- Engineers moving into parametric or optimisation work
- Anyone who has been handed a set of results and asked whether they are credible
- Engineers being asked what artificial intelligence can and cannot do for structural design
What you should already know
- Structural Behaviour, or an equivalent feel for deflected shapes and load paths
- Structural Analysis Fundamentals, or equivalent — equilibrium, stiffness and matrix analysis are recapped here, not taught
- Structural Dynamics is helpful from Module 10 onwards and is not assumed
- Basic programming knowledge is helpful and is not required; Module 4 assumes none
The syllabus
Five stages. Stage A is about the division of labour between an engineer and a computer. Stage B is about models and how information moves between them. Stage C is about the analysis methods themselves and — at greater length — about diagnosing, validating and verifying what they produce. Stage D uses computation to explore rather than to confirm. Stage E covers machine learning, connected working, carbon, and the whole thing carried through on a project.
Stage A — Engineer and computer
What a computer is good at, what it is not, and how to decide whether a problem needs one at all.
Open module →Concept design is not automated member sizing. What computation can contribute to an under-defined problem, and what it cannot.
Open module →Building a model that describes a family of structures rather than one, and knowing which parameters are worth having.
Open module →Enough programming to automate safely: the vocabulary, the decision about whether to automate at all, and why spreadsheets deserve their own lesson.
Open module →
Stage B — Data, models and workflows
How information moves between models — and why the losses that stop you are the safe ones.
Open module →Abstraction as an engineering decision — what each level keeps, what it throws away, and what it may then be asked.
Open module →Freedoms, elements, restraints, releases and offsets — the five things you actually set, and what each one does to the answer.
Open module →Trusses, frames, floors and cores — the usual model for each, its usual failure, and the hand check that catches it.
Open module →
Stage C — Analysis methods and model reliability
The glass box: element stiffness, transformation, assembly by addition, boundary conditions by striking out rows, and the recovery of everything else.
Open module →What the geometric stiffness matrix does, why a buckling load factor is not a factor of safety, and what a dynamic analysis needs from the model.
Open module →What changes when superposition fails: equilibrium paths, limit points, Newton–Raphson, arc-length, dynamic relaxation and the explicit time step.
Open module →The largest module in the course: what goes wrong, how each fault announces itself, and the discriminating check that separates it from the others.
Open module →Two different questions that get the same word. Predicting before analysing, the three-stage check, and a record somebody else can review.
Open module →
Stage D — Computational design exploration
Which inputs the answer actually depends on — and why a wide plausible range beats a large exponent.
Open module →Topology, layout, shape and size — and a measure that lets you compare layouts before a single member has been chosen.
Open module →How a search finds a good design, why the answer depends on where it started, and the result that says no method wins everywhere.
Open module →What to do when the objectives compete — and why the tool must present the trade-off rather than announce a winner.
Open module →
Stage E — Intelligent and future computation
What a trained model is, what it cannot know, and where it belongs beside a deterministic method rather than instead of one.
Open module →Model to machine, computation somewhere else, and the risks that come with both — plus a short, sceptical note on quantum computing.
Open module →Where the carbon actually is, why the grid moves it more than the material does, and whether a ranking survives the uncertainty in its own factors.
Open module →Sixteen steps from a brief to a recommendation, carried through on a real project — and the judgement that no step covers.
Open module →
References and source material
- P. Debney, Computational engineering (The Institution of Structural Engineers, version 1.3, July 2022) — private curriculum reference only. Nothing from it is reproduced, paraphrased or adapted in this course: no text, no figure, no table, no worked example and no exercise. The document itself is not stored, served or distributed by this project. No affiliation with or endorsement by The Institution of Structural Engineers is implied.
- NAFEMS publications on finite element modelling practice and terminology
- I. A. MacLeod, Modern Structural Analysis — for the checking and modelling-strategy tradition this course sits in
- The published investigation reports for the structural failures named in Module 13, cited there individually
- BS EN 1990 and the material Eurocodes — consult the current editions for any design rule. This course teaches analysis and modelling, and gives no design resistance.
On the source material
Hart and Wong was used as a private curriculum and technical reference to decide what a computational-engineering course should cover and in what order. Every explanation, derivation, diagram, worked example, question and interactive in this course is original Queensferry work. No page, paragraph, figure, structural system, numerical example or exercise from that book is reproduced, adapted or paraphrased here, and the book itself is not distributed. Where a current design standard is mentioned, it is to be verified against the published standard rather than against that reference.
The coverage matrix at docs/learning/computational-engineering-coverage.md records, chapter by chapter, which source material was reviewed and which parts of this course are Queensferry extensions beyond it.