Abaqus migration#

If your starting point is an Abaqus .inp deck (Standard or Explicit), this page is the bridge into femorph-solver. The mapping is mostly mechanical — the keyword vocabulary is distinctive but every concept has a direct counterpart.

For the one-table cheat-sheet, see Cross-vendor terminology Rosetta. For the full keyword-by-keyword coverage, keep going.

Loading an INP deck#

Single call (from_inp) reads the keyword-style deck and returns a Model ready to assemble:

from femorph_solver.interop.abaqus import from_inp

model = from_inp("rotor.inp")
model.fix(nodes=clamped_nodes, dof="ALL")
result = model.solve_static()

The reader handles Abaqus 6.14+ standard / explicit decks written through *HEADING / *NODE / *ELEMENT / *MATERIAL / *BOUNDARY / *CLOAD / *STEP blocks. Decks generated through Abaqus/CAE export, abaqus2matlab, and the abaqus Python scripting API all parse cleanly.

What’s read#

The reader covers the linear-elastic structural-mechanics slice femorph-solver supports today. Element types — the core mapping table:

Abaqus element type	Maps to femorph-solver
`C3D8`	`ELEMENTS.HEX8` (plain Gauss)
`C3D8R`	`ELEMENTS.HEX8` (reduced — same kernel today)
`C3D8H`	`ELEMENTS.HEX8` (hybrid → plain HEX8)
`C3D8I`	`ELEMENTS.HEX8(integration="enhanced_strain")` — Simo-Rifai EAS
`C3D20` / `C3D20R`	`ELEMENTS.HEX20`
`C3D10` / `C3D10M`	`ELEMENTS.TET10`
`C3D15`	`ELEMENTS.WEDGE15` (degenerate HEX20)
`S4` / `S4R`	`ELEMENTS.QUAD4_SHELL` (Mindlin-Reissner)
`B31`	`ELEMENTS.BEAM2` (Bernoulli)
`T3D2`	`ELEMENTS.TRUSS2` (axial bar)
`CPS4` / `CPS4R`	`ELEMENTS.QUAD4_PLANE` plane-stress
`CPE4` / `CPE4R`	`ELEMENTS.QUAD4_PLANE` plane-strain (BC sets the regime)
`MASS`	`ELEMENTS.POINT_MASS`
`SPRING2` / `SPRINGA`	`ELEMENTS.SPRING`

Keyword blocks the reader processes:

Abaqus keyword	Effect on the Model
`*NODE`	Grid points + global coordinates
`*ELEMENT, TYPE=...`	Element connectivity (cell type chosen via the table above)
`ELSET` / `NSET`	Named sets used for BC / load assignment
`MATERIAL` + `ELASTIC`	Isotropic material (E + nu, plus optional rho)
`*DENSITY`	Material density on the in-progress material
`*ELASTIC, type=ENGINEERING_CONSTANTS`	Orthotropic material (full 9-constant form)
`*SOLID SECTION`	Property → element-set binding for solids
`*SHELL SECTION`	Shell thickness + property binding
`*BEAM SECTION`	Beam cross-section + property binding
`*BOUNDARY`	`Model.fix()` per pinned DOF
`*BOUNDARY, ENCASTRE`	Equivalent to `Model.fix(dof="ALL")`
`*BOUNDARY, XSYMM`	Symmetry plane normal to x (and Y / Z analogues)
`*CLOAD`	`Model.apply_force()` (translational + rotational components)
`*DLOAD, P`	Distributed surface pressure
`*DLOAD, GRAV`	Gravity body force
`*DSLOAD`	Distributed surface load (vector form)
`*MPC`	Multi-point constraint (cyclic-symmetry only at present)
`STEP` / `END STEP`	Step boundary — first step processed; multi-step decks warn on the rest

What’s flagged but not read#

The reader emits a warning and skips:

C3D8R, ELEMENT_TECHNIQUE=ENHANCED — Abaqus’s enhanced-hourglass-control flavour. Closest equivalent is C3D8I which we map to HEX8-EAS already.
C3D6 (linear wedge), C3D4 (linear tet), and composite S8R — not yet shipped.
CONN3D2 connector elements — connector library is on the planned roadmap.
*PLASTIC, *HYPERELASTIC, *VISCOELASTIC — non-linear material cards. Linear elastic only at present.
*INITIAL CONDITIONS — pre-stress / temperature initial state needs the planned thermal-stress workflow.
*RESTART / *OUTPUT — output-control directives. We always emit the canonical .pv file via StaticResult.save.
Multi-step *STEP blocks beyond the first — handle as separate Model instances.

Procedure / step types#

Abaqus declares the analysis type via the *STEP block’s procedure keyword. The reader is geometry + BC + load focused — it ignores the procedure keyword and lets you pick the analysis type via the Model API:

Abaqus procedure	femorph-solver call
`*STATIC`	`Model.solve_static()`
`*FREQUENCY`	`Model.solve_modal()`
`*BUCKLE`	not yet shipped (planned)
`*STEADY STATE DYNAMICS`	`Model.solve_harmonic()`
`*DYNAMIC, IMPLICIT`	`Model.solve_transient()`
`*DYNAMIC, EXPLICIT`	not shipped (explicit dynamics planned)
`*MODAL DYNAMIC`	`Model.solve_transient()` (mode-superposition mode)

This separation lets the same geometry serve multiple analysis types without re-parsing the deck.

Result-format readback#

The reader is INP-only. Reading Abaqus .odb output isn’t currently supported — the binary format is proprietary and the documented Python API requires a paid Abaqus license to import the libraries it depends on. An NPZ-format converter odb_npz is shipped in femorph_solver.interop.abaqus._odb_npz for users who exported their ODB through the Abaqus Python API to NPZ; the recommended workflow is to solve through femorph-solver and export to .pv:

from femorph_solver.interop.abaqus import from_inp

model = from_inp("model.inp")
result = model.solve_static()
result.save("model.pv", model)

Edge cases worth flagging#

DOF ordering. Abaqus orders DOFs as (U1, U2, U3, R1, R2, R3) — same content as femorph-solver’s (UX, UY, UZ, ROTX, ROTY, ROTZ), just renamed. No re-mapping needed.

Free-form vs fixed. Abaqus INP is comma-separated free-form throughout; the reader handles arbitrary whitespace.

Comment cards (**). Stripped silently.

Continuation lines (lines ending in trailing comma). Joined transparently.

Set references by name (ELSET=mybolts / NSET=clamp). Resolved against the deck’s named-set definitions — out-of-order references work because the reader does two passes.

Local coordinate systems (*ORIENTATION). Read but currently warned-and-skipped — every field is interpreted in the global Cartesian frame. Local-coordinate support is on the planned roadmap.

Step amplitude curves (*AMPLITUDE). Static decks parse them but the amplitude is currently applied as the deck’s reference value; time-varying load tables need the transient solver’s amplitude binding (planned).

Concrete migration recipe#

For a typical static-analysis deck:

from femorph_solver.interop.abaqus import from_inp

# 1. Load the deck.  All the *NODE / *ELEMENT /
#    *MATERIAL / *BOUNDARY / *CLOAD blocks above
#    populate the Model.
model = from_inp("aircraft_panel.inp")

# 2. Optionally inspect or modify:
print(f"{model.grid.n_points} nodes, {model.grid.n_cells} cells")

# 3. Solve.
result = model.solve_static()

# 4. Export to canonical ``.pv`` for downstream
#    post-processing in the femorph-solver gallery
#    recipes (:doc:`/gallery/post-processing/index`).
result.save("aircraft_panel.pv", model)

# 5. Stress recovery + design check follow the
#    standard recipes — same code regardless of which
#    deck you started from:
from femorph_solver.recover import compute_nodal_stress, stress_invariants
sigma = compute_nodal_stress(model, result.displacement.ravel())
inv = stress_invariants(sigma)
print(f"Peak σ_VM = {inv['von_mises'].max() / 1e6:.2f} MPa")

Cross-references#

Cross-vendor terminology Rosetta — the one-table Rosetta covering every concept across femorph-solver / MAPDL / NASTRAN / Abaqus / LS-DYNA.
NASTRAN migration — the NASTRAN equivalent of this page.
MAPDL interop — the MAPDL equivalent.
Element kernels — per-element technical sheets, each carrying a cross-vendor mapping table that starts from the femorph-solver name and lists the Abaqus element type.