Finite-Elemented
An Interactive Finite Element Analysis Learning Platform
Master Finite Element Analysis
Build deep intuition for computational mechanics through interactive visualizations, hands-on experiments, and real-time simulations — from weak forms and meshing all the way to a live 2D stress solver running in your browser.
Discover how FEA breaks complex problems into simple pieces — from continuous domains to discrete solutions.
Follow the full pipeline — strong form, weak form, element matrices, assembly — and solve a 1D bar live while you watch K being built.
Generate meshes interactively, compare structured vs unstructured, and drag nodes to see quality metrics update live.
Explore element families from 1D bars to 3D hexahedra. Visualize shape functions as interactive 3D surfaces.
Drag element corners and watch the Jacobian respond — then discover why n Gauss points integrate degree 2n−1 exactly.
Compare h-refinement (more elements) vs p-refinement (higher order) side-by-side with live convergence tracking.
See how element polynomial order affects accuracy. Compare linear, quadratic, and cubic elements on a cantilever beam.
Run convergence studies, understand Richardson extrapolation, and learn about common pitfalls like mesh dependence.
Un-pin a structure and watch K go singular. Explore sparsity patterns, bandwidth, and the direct-vs-iterative solver trade-off.
The capstone: a full plane-stress FEM solver running live in your browser. Mesh it, load it, and watch von Mises contours respond instantly.
Decode Abaqus element names, browse element families, and follow an interactive selection flowchart.
Compare element performance, learn best practices by domain, avoid common mistakes, and test your knowledge with a quiz.
What is FEA?
Math of FEM
Meshing
Element Types
Isoparametric
h vs p
Complexity
Convergence
Solvers
2D Stress Lab
Abaqus
Pros & Cons
What is Finite Element Analysis?
Finite Element Analysis (FEA) is a numerical method that breaks a complex domain into smaller, simpler pieces called elements. By solving simple equations on each element and assembling the results, we can approximate the behavior of structures, heat flow, fluid dynamics, and more.
From Continuous to Discrete
Watch how a continuous domain gets discretized into a mesh, then solved to reveal the stress distribution.
Applications of FEA
Structural
Stress, strain, and deformation analysis of bridges, buildings, and mechanical components.
Thermal
Heat conduction, convection, and radiation in electronic devices, engines, and furnaces.
Fluid
Computational fluid dynamics for aerodynamics, pipe flow, and weather prediction.
FEA Glossary
Click a term to see its visual explanation.
Node
A point where element corners meet
DOF
Degree of freedom at each node
Element
A small sub-region of the domain
Shape Function
Interpolation within an element
Stiffness Matrix
Relates forces to displacements
Weak Form
Integral restatement of the PDE
Jacobian
Maps parent to physical element
Gauss Point
Where integrals are sampled
Isoparametric
Same functions for shape & solution
The FEA Process
Pre-processing: Define geometry, create the mesh, assign material properties and boundary conditions. This is where you set up the problem — the quality of your mesh directly affects accuracy.
From Physics to Equations
Every FEM run — no matter how complex — ends up solving the same thing: a big linear system K u = F. This module shows where that system comes from, using the simplest structural problem there is: an axial bar. Master this pipeline once and every other element type is just "more of the same."
The Model Problem: An Axial Bar
A bar of stiffness EA, fixed at the left end, stretched by a distributed load q(x) and/or an end force P. Equilibrium of an infinitesimal slice gives the strong form — a differential equation that must hold at every single point:
That pointwise requirement is too strict for simple approximations. Multiply by a test function v(x), integrate over the bar, and shift one derivative onto v using integration by parts. The result is the weak form — it only asks the equation to hold "on average":
Now approximate u(x) inside each element with shape functions (Galerkin's method uses the same functions for u and v). For a 2-node linear element of length Le, the weak form evaluates to a tiny 2×2 system — the element stiffness matrix:
Why bother with the weak form? It halves the derivative order the approximation must support (piecewise-linear functions become legal), it makes force boundary conditions appear automatically in the right-hand side, and it produces symmetric matrices. It is the reason FEM works.
Interactive 1D FEM Solver
Solve the bar live. Pick a load case, an element order, and a mesh — then compare the FEM solution (solid) against the exact solution (dashed). Watch the axial force plot: linear elements give a staircase of constant force per element, with jumps between elements.
A 1D surprise: the FEM answer is exact at the nodes for this problem — even with one element! The error lives between the nodes, and in the force plot. This nodal exactness is special to 1D problems; in 2D/3D everything is approximate, which is why convergence studies matter.
Watch the Assembly
Each element only knows about its own two nodes. Assembly scatters every 2×2 element matrix into the global K at the rows/columns of the element's nodes. Where two elements share a node, their contributions add — that overlap is exactly what ties the elements together into one structure.
Press Add Next Element to scatter ke of element 1 into the global matrix (values in units of EA/Le).
Boundary Conditions: Essential vs Natural
Essential (Dirichlet)
Prescribed displacements — supports, clamps, symmetry planes. They are enforced by modifying the equations: the constrained rows/columns are removed (or penalized) before solving. Without enough of them, K is singular and the structure floats — see the Solving the System module.
Natural (Neumann)
Prescribed forces / tractions / pressures. The weak form absorbs them automatically into the load vector F — no equation surgery needed. That P·v(L) term in the weak form above? That is a natural BC doing its job.
After solving, the reactions at essential BCs are recovered by plugging the solution back into the constrained rows of K u − F. Checking that reactions balance the applied loads is the cheapest sanity check in FEA.
Meshing: Domain Discretization
A mesh divides your domain into elements. Mesh quality — element shape, size, and distribution — directly affects solution accuracy and convergence speed.
Interactive Mesh Generator
Select a shape and adjust the density to see how the mesh changes.
Structured vs Unstructured Meshes
Structured
- Regular connectivity pattern
- Easy to generate for simple shapes
- Higher quality elements
- Limited to regular geometries
Unstructured
- Irregular connectivity
- Can handle complex geometries
- Variable element quality
- More flexible refinement
Element Shapes
Drag-Node Quality Demo
Drag the interior node to see how element quality metrics change in real-time.
Element Types Catalog
FEA elements come in many flavors — from simple 1D bars to complex 3D hexahedra. Each has its strengths, trade-offs, and ideal use cases.
Filter by Dimension
Shape Function Visualizer
Select an element type to visualize its shape functions as 3D surfaces. Hover over a node to highlight its shape function.
Element Comparison
| Element | Dim | Nodes | DOFs/Node | Order | Best For | Accuracy | Cost |
|---|---|---|---|---|---|---|---|
| Bar2 | 1D | 2 | 1 | Linear | Trusses | Medium | Low |
| Beam2 | 1D | 2 | 2 | Cubic | Frames | High | Low |
| CST (Tri3) | 2D | 3 | 2 | Linear | Simple shapes | Low | Low |
| LST (Tri6) | 2D | 6 | 2 | Quadratic | Curved boundaries | High | Medium |
| Q4 | 2D | 4 | 2 | Linear | Planar problems | Medium | Low |
| Q8 | 2D | 8 | 2 | Quadratic | Stress concentration | High | Medium |
| Tet4 | 3D | 4 | 3 | Linear | Complex 3D shapes | Low | Low |
| Tet10 | 3D | 10 | 3 | Quadratic | General 3D | High | Medium |
| Hex8 | 3D | 8 | 3 | Linear | Regular 3D regions | Medium | Medium |
| Hex20 | 3D | 20 | 3 | Quadratic | High-accuracy 3D | High | High |
Isoparametric Mapping & Numerical Integration
Real meshes are full of stretched, skewed, wonky elements — yet all the element math is derived on one perfect square: the parent element, living in natural coordinates (ξ, η) ∈ [−1, 1]². A mapping built from the element's own shape functions carries everything from parent to physical space. That trick — using the same functions for geometry and solution — is what "isoparametric" means, and it is how every commercial FE code works.
Mapping Explorer — Drag the Corners!
The right element is the physical element: drag its corner nodes. The color field shows det J across the element. Squash a corner past the diagonal and det J goes negative — the element folds over itself, and any FE solver will refuse it.
Parent element (ξ, η) with Gauss points
Physical element (x, y) — drag the corners
The Jacobian
The Jacobian matrix collects how physical coordinates change with natural ones. It converts shape-function derivatives (computed on the parent) into physical derivatives, and its determinant rescales every integral:
A healthy element keeps det J positive and roughly uniform. Rules of thumb: corner angles between 45° and 135°, aspect ratios below ~5 (below ~3 in regions of interest), and min/max det J ratio above ~0.2. This is exactly what the mesh-quality metrics in the Meshing module are protecting.
Gauss Quadrature Lab
FE integrals are evaluated numerically: sample the integrand at n magic points, multiply by magic weights, sum. Gauss chose both points and weights optimally — n points integrate any polynomial up to degree 2n−1 exactly. Try it:
Notice: 2 points nail the cubic exactly (2·2−1 = 3), but the quintic needs 3. And cos 2x is never exact — only increasingly accurate. This is why a 2×2 rule fully integrates a Q4 stiffness matrix, and why using fewer points ("reduced integration") is cheaper but risks the hourglass modes covered in the Abaqus module.
Common Quadrature Rules
| Element | Full integration | Reduced | Watch out for |
|---|---|---|---|
| Q4 quad | 2×2 | 1 point | Hourglassing when reduced |
| Q8 quad | 3×3 | 2×2 | Reduced is usually the sweet spot |
| T3 triangle | 1 point | — | Constant strain — needs fine meshes |
| T6 triangle | 3 points | — | — |
| C3D8 hex | 2×2×2 | 1 point | Hourglassing when reduced |
| C3D20 hex | 3×3×3 | 2×2×2 | Cost grows fast in 3D |
Stresses are evaluated at the Gauss points — that is where they are most accurate (superconvergence). Values you see plotted at nodes have been extrapolated and averaged, which is exactly why nodal stress contours can hide discontinuities between elements.
h-Refinement vs p-Refinement
There are two fundamental ways to improve FEA accuracy: h-refinement (using more, smaller elements) and p-refinement (using higher-order polynomial shape functions). Each has distinct convergence properties.
h-Refinement
Subdivide elements into smaller ones. The polynomial order stays the same, but you get more elements to capture variation. Like using more pixels in an image.
p-Refinement
Increase the polynomial order of shape functions within existing elements. Like increasing color depth — same pixels, more information per pixel.
Convergence Comparison
Error vs DOFs for both refinement strategies on a cantilever beam.
Element Complexity: Linear to Cubic
The polynomial order of an element determines how many nodes it has and how accurately it can represent curved displacement fields. Higher order = more accurate per element, but costlier to compute.
Polynomial Order Visualization
Cantilever Beam: Accuracy vs Element Count
Convergence Rate Comparison
See how linear, quadratic, and cubic elements converge at different rates as you increase the number of elements.
Convergence Studies
A convergence study verifies that your FEA solution is independent of the mesh. As you refine the mesh, the solution should approach the exact value. If it doesn't converge, something is wrong.
Mesh Refinement Sequence
Watch the FEA solution approach the exact value as the mesh is refined.
h-Convergence Study
Click "Run Study" to progressively refine the mesh and watch the error decrease.
Results shown on log-log scale
p-Convergence Study
Increase polynomial order on a fixed mesh and observe exponential convergence.
Results shown on log-log scale
Richardson Extrapolation
Estimate the exact solution from two mesh levels. Enter your FEA results at two refinement levels:
Common Pitfalls
Mesh Dependence
If your results change significantly with each mesh refinement and never stabilize, your model may have issues. Check for stress singularities at sharp corners, incorrect boundary conditions, or material model problems. A proper convergence study should show diminishing changes between refinement levels.
Stress Singularities
At re-entrant corners or point loads, stresses theoretically go to infinity. Refining the mesh near these points will cause stress values to keep increasing without bound. Use Saint-Venant's principle: read results away from the singularity, or introduce fillets to remove the sharp corner.
Volumetric / Shear Locking
Low-order fully-integrated elements can artificially stiffen in bending or near-incompressible situations. The cure: use reduced integration (e.g., C3D8R instead of C3D8), or switch to higher-order elements. Reduced integration requires hourglass control to prevent zero-energy modes.
Solving the System
Assembly hands you K u = F — often with millions of unknowns. This module covers the three things every analyst must understand about that system: it is singular until you constrain it, it is extremely sparse, and the choice between direct and iterative solvers decides whether your job takes minutes or days.
Rigid-Body Modes — Click the Nodes!
A chain of 4 springs, loaded at the right end. Click any node to pin / un-pin it. Remove all pins and K becomes singular — a uniform translation costs zero energy, so the structure floats away and no solver on Earth can give you an answer.
The classic Abaqus error "numerical singularity … zero pivot" is exactly this: a body (or a whole part) with a free rigid-body mode. In 2D each body needs 3 constrained DOFs; in 3D, 6. Under-constrained contact models are the most common real-world culprit.
Sparsity & Bandwidth
Each node only talks to its neighbors, so almost every K entry is zero. How the nonzeros cluster depends purely on node numbering — and for direct solvers, the cost scales with the square of the bandwidth. Same mesh, same physics, wildly different matrix:
Solvers reorder automatically (reverse Cuthill–McKee, nested dissection…), but the lesson stands: connectivity, not size, shapes the cost. A million-DOF model with a tight band solves faster than a 100k-DOF model with a terrible one.
Direct vs Iterative Solvers
Direct (LU / Cholesky)
Factorize once, solve exactly (to round-off). Robust — doesn't care about conditioning. Memory hungry: factorization creates fill-in. The default choice below ~2–5M DOFs, and for models with many load cases (one factorization, many cheap back-substitutions).
Iterative (PCG / Multigrid)
Start from a guess, improve until the residual is small. Tiny memory footprint and scales beautifully in parallel — but convergence depends on conditioning, so a good preconditioner is everything. The only practical option for very large 3D solid models.
Illustrative scaling for a 2D mesh (bandwidth b ≈ √N). Actual constants vary by implementation and hardware.
Conditioning: When Solvers Struggle
- Stiffness contrast — steel bonded to rubber (E ratio ~10⁵) makes K ill-conditioned. Expect slow iterative convergence and noisy stresses at the interface.
- Degenerate elements — slivers and needles (see the Meshing module) create near-zero pivots. One terrible element can poison the whole solve.
- Inconsistent units — mixing mm with GPa-scale moduli produces absurd magnitude spreads. Pick one consistent unit system and never look back.
- Precision — FE solvers use double precision for a reason: a condition number of 10¹⁰ eats ~10 of your 16 significant digits.
2D Stress Lab — A Real FEM Solver
Everything from the previous modules, working together: this page meshes a structure, builds Q4 or T3 element matrices with Gauss integration, assembles a banded global K, applies boundary conditions, solves with a Cholesky factorization, and recovers stresses — live, in pure JavaScript, every time you move a slider. This is the same pipeline Abaqus runs, just a few million DOFs smaller.
Simulation Setup
Try This
- Feel the locking: set density 1 with T3 triangles on the cantilever — the deflection comes out far too small. Constant-strain triangles cannot bend (Module: Element Types). Switch to Q4 and watch the answer jump toward beam theory.
- Converge it: crank the density up and watch the FEM deflection approach — then slightly exceed — Euler-Bernoulli, because the 2D model includes shear deformation that beam theory ignores. Timoshenko theory (shown) accounts for it.
- Find the singularity: on the L-bracket, look at the re-entrant corner. Refine the mesh — the peak von Mises keeps climbing. That is a stress singularity (Module: Convergence, Pitfalls). Real parts have fillets!
- Plane stress vs strain: toggle the formulation and watch stiffness rise slightly under plane strain — the suppressed out-of-plane contraction acts like extra confinement.
Mini Convergence Study
Run the cantilever at five mesh densities with both element types. One click reproduces the central lesson of this whole platform: element choice sets the starting point, refinement closes the gap.
Abaqus Element Library
Abaqus uses a systematic naming convention for its elements. Understanding the code lets you quickly identify what any element does.
Element Name Decoder
Type an Abaqus element name to decode it in real-time.
Element Family Browser
Continuum (Solid) Elements
C3D8 — 8-node linear brick, full integration
C3D8R — 8-node linear brick, reduced integration
C3D20 — 20-node quadratic brick, full integration
C3D20R — 20-node quadratic brick, reduced integration
C3D4 — 4-node linear tetrahedron
C3D10 — 10-node quadratic tetrahedron
CPE4 — 4-node plane strain quad
CPS4 — 4-node plane stress quad
Shell Elements
S4R — 4-node general-purpose shell, reduced integration
S8R — 8-node thick shell, reduced integration
S3 — 3-node triangular shell
STRI3 — 3-node triangular thin shell
Beam Elements
B31 — 2-node linear beam in 3D (Timoshenko)
B32 — 3-node quadratic beam in 3D
B21 — 2-node linear beam in 2D
B33 — 2-node cubic beam (Euler-Bernoulli)
Full vs Reduced Integration
Full Integration
Uses enough Gauss points to integrate the stiffness matrix exactly. Can suffer from shear locking in bending-dominated problems.
Reduced Integration
Uses fewer Gauss points. Avoids locking but can develop hourglass modes — zero-energy deformation patterns.
Element Selection Flowchart
Pros & Cons: Element Selection Guide
Choosing the right element is one of the most important decisions in FEA. This module summarizes trade-offs, best practices, and common mistakes.
Element Comparison Matrix
| Element | Accuracy | Speed | Mesh Ease | Bending | Locking Risk |
|---|---|---|---|---|---|
| Tet4 / C3D4 | Poor | Fast | Easy | Poor | High |
| Tet10 / C3D10 | Good | Medium | Easy | Good | Low |
| Hex8 / C3D8 | OK | Fast | Hard | Poor | High |
| Hex8R / C3D8R | OK | Fast | Hard | Good | Hourglass |
| Hex20 / C3D20R | Excellent | Slow | Hard | Excellent | Low |
| Shell S4R | Good | Fast | Medium | Good | Low |
Performance vs Accuracy
Best Practices by Domain
Structural Analysis
Thermal Analysis
Contact & Large Deformation
Common Mistakes
Using C3D4 everywhere
Linear tets are overly stiff and need extremely fine meshes. They're the "easy button" that gives poor results.
Use C3D10 instead
Quadratic tets are just as easy to mesh but dramatically more accurate. Always choose C3D10 over C3D4.
Skipping convergence study
Without verifying mesh independence, you have no idea if your answer is meaningful.
Run 3+ mesh levels
Refine the mesh at least 3 times and verify results change less than 5% between levels.
Test Your Knowledge
10 questions to test your understanding of FEA element selection.