Femis

FEM / CAE — structural · thermal · CFD · multiphysics

> This skill governs engineering claims — it does not drive solvers or sign off designs. It pairs with a > solver driver / MCP (PyMAPDL, PyMechanical, an Abaqus / OpenFOAM driver, OASiS, a CAE MCP) that > executes; this skill decides whether a result may be claimed, at what altitude, and when a human must > decide.

Overview

Govern finite-element and CAE analysis end-to-end. Paired with an executor (PyMAPDL, PyMechanical, PyFluent, an Abaqus/OpenFOAM driver, a CAE MCP — see "governance layer, not the executor" below) the executor locates the installed solver, builds the deck/script, and launches headless/batch; this skill guides and audits the idealization, reads the log for convergence, inspects/parses results, and enforces professional practice (idealization → meshing → connections → solve controls → convergence → mesh independence → V&V) on every run. The methodology is solver-agnostic; worked depth here is Ansys / Simcenter / Thermal Desktop, with breadth across Abaqus, LS-DYNA, MSC/Simcenter Nastran, COMSOL, OpenFOAM, Fluent, CFX, STAR-CCM+, CalculiX, Code_Aster (see references/software-landscape.md).

Core principles (enforce as gates):

1. No result is trusted until its discretization (mesh/time-step) error is addressed — bounded and stated in ENGINEERING (e.g. last-refinement QoI change, or a single-mesh ZZ/SPR estimate), fully demonstrated with a GCI study in the asymptotic range for SIGNOFF; a single-mesh number reported without any error statement is never a result. Plus the convergence checks below.
2. Converge the Quantity of Interest (QoI), not the peak — peaks at sharp corners/point loads/crack tips are singularities that never converge.
3. Most error is born in pre-processing (idealization, BCs, connections) — front-load those decisions.
4. Verification before validation; calibration ≠ validation — and an agent must not claim sign-off without run evidence.

This SKILL.md is the router. Depth lives in references/ — load a reference only when its topic is in play.

When to use

• Structural (static/modal/buckling/nonlinear/explicit), thermal (steady/transient/radiation), CFD (RANS/LES, CHT), electromagnetics (low-/high-frequency), vibro-acoustics/NVH, multibody, and coupled multiphysics (thermo-mechanical, FSI, EM-thermal).
• Failure & durability: fracture / damage-tolerance, fatigue (incl. vibration/spectral), composites, plasticity / shakedown / ratcheting, buckling & stability, crash / impact / drop.
• Contact, thermal contact resistance, bolted/welded/rigid connections; meshing & mesh-independence (GCI); element/solver/unit selection.
• Headless/batch solving and result parsing; optimization, calibration, inverse parameter ID / model updating.
• V&V / UQ; substructuring / ROM; cryogenic / vacuum / spacecraft thermal.
• Deciding what an agent can automate headless vs what a human must do (next section).

Not for: pure CAD modeling or problems better served by a closed-form hand calc.

★ Agent capability & headless-vs-human contract

Precisely who does what. Buckets: AGENT-HEADLESS (fully scriptable/batch, no GUI) · AGENT-VIA-API (Python/journal API, needs a session + license) · HUMAN-GUI (must be interactive at least once) · HUMAN-JUDGMENT (engineering decision the agent must not make alone) · LICENSE-GATED. Full per-platform detail: references/agent-automation-boundary.md.

| Operation | Classification | How / why | |---|---|---| | CAD import | AGENT-VIA-API | PyMAPDL/PyMechanical/run_journal import STEP/Parasolid | | Geometry cleanup / heavy defeature | AGENT-VIA-API + HUMAN-JUDGMENT | scriptable defeature/pinch; messy repair + what to defeature is judgment | | Meshing | AGENT-HEADLESS (Ansys) · SEED-IN-GUI (NX) | PyMAPDL/PyMechanical mesh fully headless; NX .fem/.sim templates don't resolve in batch → seed once in GUI | | Material create/assign | AGENT-HEADLESS | scriptable on all platforms; supply T-dependent data | | Contacts / connections | AGENT-HEADLESS (build) + HUMAN-JUDGMENT (type) | defining is scriptable; bonded vs frictional / RBE2 vs RBE3 is an engineering choice | | BCs & loads | AGENT-HEADLESS | scriptable; agent must not invent the load case | | Expose params for optimization | AGENT-HEADLESS (PyMAPDL *SET) · HUMAN-GUI (Workbench P#, NX Expressions, HEEDS tags) | only PyMAPDL is GUI-free for parameterization | | Solve (steady/transient/nonlinear) | AGENT-HEADLESS + LICENSE-GATED | ansys -b, nastran.exe, tmgnx, abaqus job=, fluent -g, OpenFOAM, cfx5solve -batch, starccm+ -batch | | Electromagnetic solve (machines/RF/eddy) | AGENT-VIA-API + LICENSE-GATED | PyAEDT (import ansys.aedt.core, non_graphical=True), COMSOL/getDP batch; ports/excitations/sweeps are engineering setup | | Optimization / DOE / calibration | AGENT-HEADLESS (PyMAPDL+SciPy, optiSLang -b, HEEDS CLI) + GUI-AUTHOR-ONCE | author the study/tags in GUI once, then run headless | | Results extraction | AGENT-HEADLESS | PyDPF, pyNastran (.op2/.f06), .odb, SINDA .out, CGNS/VTK | | Post images/plots | AGENT-HEADLESS | pyvista off-screen, ParaView pvbatch | | Correlation / model-update (MAC, node pairing) | HUMAN-GUI | interactive test↔analysis node pairing is GUI work | | Template / .sim / project authoring (NX) | HUMAN-GUI | template registry not initialized headless → pre-create a seed, then drive it | | Licensing | LICENSE-GATED | each parallel solver instance consumes its own seat |

An agent must NEVER auto-do: choose idealization / element / contact-type / BC alone (HUMAN-JUDGMENT) · accept a calibration knob pinned at its physical-corridor edge · report a singular peak or an unconverged result as a result · claim verification / mesh-independence / sign-off without the run evidence · perform an irreversible push/overwrite without authorization.

Pairing & executor contract

This skill is the governance layer, not the executor. Pair it with whatever drives the solver (PyMAPDL, PyMechanical, an Abaqus / OpenFOAM driver, OASiS, a CAE MCP): the executor runs; this skill governs the claim. Trust no solver output without provenance — a result is creditable only when the executor returns:

• Run manifest (run_manifest.json, template scripts/run_manifest_template.json) — the traceability spine (NAFEMS R0033).
• Solver name + exact version — read from the detected install's banner/-help, never assumed.
• Input-deck hash + result-file hash (e.g. SHA-256 of the .inp/.dat/.cdb and of the .rst/.rth/.op2) — ties a number to the exact deck and result that produced it.
• Command + flag evidence — the actual launch line, flags verified against that version (version-aligned-commands rule, Step 0).
• Isolated workspace — a clean working dir; outputs written there, never overwriting a prior "final" without a superseded_by pointer.

A result lacking this provenance is a SMOKE/DEBUG artifact at best — phrase it as such (references/claim-templates.md).

Execution modes (pick one per task — sets the mandatory gates and what you may claim)

| Mode | Use when | Mandatory gates | Never | |---|---|---|---| | SMOKE | prove env/deck/solve/parse runs | Step 0; solve completes; result file written and readable | claim any engineering number; tune anything | | DEBUG | find a failure's cause | the one decisive test for the symptom; connectivity gate if thermal | present a diagnostic solve as a result | | ENGINEERING | usable result + sanity checks | units; connectivity; reactions/heat/mass balance; convergence; QoI extraction; singularity check | claim sign-off; report a singular peak | | SIGNOFF | defensible deliverable | all ENGINEERING + mesh & time-step independence (GCI, asymptotic range) + traceable report + error bounds | skip any gate; hand-wave uncertainty |

A SMOKE/DEBUG result is a pipeline/physics check, never an engineering conclusion — label it.

★ Pre-claim self-check — answer ALL before stating any engineering number

This is the gate that makes the skill trustworthy. Before you type a stress, temperature, frequency, margin, drag, or "it passes," answer these. If any answer is no / unknown, you do not have a result — you have a SMOKE/DEBUG output: say so and stop.

1. Mode? Which execution mode am I in, and have its mandatory gates passed? (SMOKE/DEBUG ⇒ not an engineering conclusion.)
2. Units? Consistent system verified (1g-mass / hand-calc check); density not unit-corrupt?
3. Discretization error addressed? Mesh and time-step error bounded and stated (GCI for SIGNOFF; single-mesh ZZ/SPR estimate for ENGINEERING)? A lone single-mesh number is never a result.
4. Singularity excluded? Is the QoI at a corner / point-load / crack-tip artifact? Read away or linearize before quoting.
5. Balance checked? Reaction = applied; heat/mass/energy balance within tolerance; convergence from the residual history, not the exit code?
6. Allowable named? Is there a margin vs a NAMED criterion / design code — not a bare number?
7. Human-judgment gate crossed? Did I silently choose a load case, contact type, allowable, defeature, or sign-off? If yes — STOP and escalate (references/escalation-examples.md).

Then phrase the result with the matching template in references/claim-templates.md. The agent never claims sign-off without run evidence, and never self-authorizes an engineering decision. Exact solver flags / API calls are themselves a claim — confirm them per the version-aligned-commands rule in Step 0.

Step 0 — ALWAYS first: environment discovery

Never assume a version or path. Find what's installed/licensed, then confirm platform + physics + QoI.

Get-ChildItem "C:\Program Files\ANSYS Inc" -Recurse -Filter "ANSYS*.exe" -ErrorAction SilentlyContinue | Select FullName   # MAPDL/Mechanical/Fluent/CFX
Get-ChildItem "C:\Program Files\Siemens" -Recurse -Include "nastran.exe","run_journal.exe","tmgnx.cmd","ugraf.exe" -ErrorAction SilentlyContinue
Get-ChildItem "C:\Program Files" -Recurse -Filter "abq*.bat" -ErrorAction SilentlyContinue   # Abaqus; also `which icem`, OpenFOAM `foamVersion`
$env:ANSYSLMD_LICENSE_FILE; $env:LM_LICENSE_FILE
(Get-CimInstance Win32_Processor | Measure-Object NumberOfCores -Sum).Sum   # PHYSICAL cores

Linux: ansysNNN -b, nastran, abaqus, simpleFoam, fluent -g; check $LM_LICENSE_FILE, nproc.

Version-aligned commands (rule): never emit a solver command, flag, or API call you have not verified exists in the detected release — versions rename flags and drift APIs. Confirm against the installed version's -help/docs before relying on it, especially for ENGINEERING/SIGNOFF.

Canonical workflow (run in order)

1. Objective + QoI — the scalar that drives the decision (margin, deflection, frequency, peak T, drag). Not "run the model."
2. Analysis type — static/modal/buckling/thermal/CFD/coupled; linear vs nonlinear (material? large-deflection? contact? turbulence?).
3. Idealize (most consequential) — 1D/2D/3D; symmetry only if geometry and loads and BCs are symmetric; defeature irrelevant features. → references/meshing-convergence.md.
4. Materials — correct constitutive model; temperature-dependent properties; at cryo use ∫α(T)dT. → references/material-modeling.md.
5. Mesh — element order/family, refinement at concentrations, quality gate. → references/meshing-convergence.md.
6. Connections & contact. → references/mechanical-connections.md, references/thermal-contact-resistance.md.
7. BCs & loads — remove only the rigid-body modes appropriate to the model's dimensionality/type (an unconstrained 3D solid has 6; 2D, axisymmetric, shell-only and cyclic-symmetric models differ); loads over realistic areas (never point loads/constraints → singularities); inertia relief for free bodies. → references/advanced-methods.md.
8. Solve controls — solver type, cores, substeps + tolerances. → references/solver-numerics.md.
9. Verify — equilibrium, mesh/time-step independence, convergence history. → references/vv-uq.md.
10. Validate — vs test / hand-calc / NAFEMS benchmark (calibration ≠ validation).
11. Post & report — right measure, averaged-vs-unaveraged check, margins, stated assumptions.

Consistent units (pick ONE system; solvers are unit-free)

| System | Length | Force | Stress/E | Mass | Density (steel) | g | |---|---|---|---|---|---|---| | SI (m) | m | N | Pa | kg | 7850 kg/m³ | 9.81 m/s² | | mm-t-s (common CAE) | mm | N | MPa | tonne | 7.85e-9 t/mm³ | 9810 mm/s² |

Density is the silent corruptor: wrong-unit density passes statics but wrecks every dynamic/explicit/transient-thermal result. MAPDL /UNITS is metadata only. Verify with a 1g mass check or a hand-calc natural frequency.

Element selection & mesh quality (depth: references/meshing-convergence.md)

• Quadratic (mid-side nodes) for stress/curved geometry, esp. tets — avoid linear TET4 for stress (constant-strain → over-stiff, slow stress convergence; acceptable only as filler well away from the QoI). Linear for explicit/large-deformation. (Shear locking proper afflicts fully-integrated linear quads/hexes in bending — parasitic shear; fix with reduced integration, incompatible modes, or quadratic — not the same defect as TET4's constant-strain stiffness.) Modern quadratic solids resolve mild bending with ~1 element through thickness as a starting point (curvature-driven — confirm by convergence); linear elements need several, and accuracy-critical bending wants ≥2 quadratic.
• Shell if thickness/length ≲ 1/10–1/20; solid for 3D stress/through-thickness; beam for slender. Account for shell/beam offsets (they induce real moments).
• Locking/hourglass: linear full-integration shear-locks (~+34% stiffer in the standard bending test — magnitude problem-dependent); linear reduced-integration hourglasses (over-soft, needs control); use quadratic / enhanced-strain / B-bar / mixed u–P (near-incompressible).
• Quality gate (before solving) — thresholds depend on physics: structural FEA prioritizes Jacobian (negative = fatal), skewness, and aspect ratio (high aspect is often fine for bending/shells); CFD is far stricter on orthogonal quality (>0.2, near-wall), skewness (reject >0.95), and growth ratio (≤1.2–1.5). Common starting guide: skewness ≤0.5 · orthogonal quality >0.2 · Jacobian 1–10 · aspect ratio SMP for scaling (small models saturate ~4–8 cores; >4 needs HPC packs). Direct sparse for ill-conditioned/nonlinear/modal (keep in-core; out-of-core ~10× slower); iterative PCG for large well-conditioned 3D solids (don't loosen tolerance to force convergence — fix the model).
• Nonlinear: read the residual history, never the exit code; Newton-Raphson (+ line search); arc-length/Riks for snap-through; auto-time-step + bisection; converge force+displacement (energy). Decode pivots: negative/zero = singular (under-constraint/lost contact/bad props).
• Time integration: implicit Newmark/HHT-α (unconditional) for dynamics; explicit central-difference (Δt≤L_min/c, mass-scaling 4. |

| "Converged" by exit code / CFD residuals only | Read residual history; monitor integrated quantities + imbalance. | | Perfect/bonded thermal contact in vacuum/cryo | Use finite h_c. | | Reusing structural contacts in a thermal solve | CONTA174 KEYOPT(1)=0 → zero conduction; author fresh. | | RBE2 everywhere | Over-stiffens — RBE3 to spread load without stiffness. | | Forgetting CTE in thermal stress | Define ALPX/A+TREF or thermal stress is silently zero. | | Engineering (not true) stress–strain in plasticity | Convert; extend past UTS via a hardening law, n

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: test1card
• Source: test1card/femis-skill
• License: Apache-2.0
• Homepage: https://github.com/test1card/femis-skill

Install and usage instructions live in the source repository linked above.