Jiapeng Chen · AlexanderChan on AlexanderChan's Blog

Jone Gorman AI Learning Guide: From Foundations to Agents, Physical AI, and RSI

Mon, 19 Oct 2026 00:00:00 +0800

Expensive courses, unfamiliar terminology, and a constant stream of new technology can make getting started with AI feel overwhelming. This guide begins from the perspective of a learner with a limited budget and little computing experience, breaking “I want to learn AI” into manageable steps.

From understanding a computer to writing a first Python script, reproducing a model, and finishing a small project, each step can leave you with code and notes of your own. Courses provide an entry point; hands-on work connects the ideas.

From a Connector Simulation to a Traceable Batch Boundary Search

Sun, 18 Oct 2026 00:00:00 +0000

English PDF · Chinese PDF · Bilingual LaTeX and figure sources

What this article covers. The difficulty in connector finite element analysis is not simply solving one model. It is making the same physical model generate many reliable samples and explaining when those samples lose contact performance. This article follows an engineering route through reduction, parameterization, scheduling, postprocessing, and boundary search.

Public scope. Customer, product, and loading details are anonymized. This article contains no actual models, original tolerance vectors, unpublished contact-force data, or performance figures. The sampling plot is an independently generated method demonstration; the other figures are schematic. The added coupled search has passed offline code and coordinate checks. Actual failure boundaries still require complete solves with the matching model.

Three requirements before scaling up

A usable batch simulation system must satisfy three distinct requirements: physical interpretability, numerical checks, and recoverable execution. Reducing solve time is only the first step. If samples use different contact settings, tolerance application contaminates the baseline, or a solver interruption is counted as contact failure, faster computation does not produce a credible operating boundary.

Figure 1 summarizes the route: substructures reduce repeated computation; explicit variable mappings produce samples; and consistent contact metrics connect batch statistics to pose search. Each stage retains the identity and provenance of its inputs.

Overall method schematic. Every sample follows the same execution chain. Search changes initial pose while the manufacturing-tolerance vector can remain fixed. No actual product geometry or performance data are shown.

The problem is a family of models

Connector mating is a nonlinear contact problem. Geometry, local stiffness, initial gaps, and the loading path jointly determine the final contact state. One analysis of nominal geometry answers a question about a single configuration. Manufacturing deviations introduce a family of responses; assembly offsets and angular misalignment add further conditioning variables.

The problem can be written as $\begin{equation} \mathbf{y}=\mathcal{S}(\boldsymbol{\xi},\mathbf{q};\boldsymbol{\eta}), \end{equation}$ where $\boldsymbol{\xi}$ is the manufacturing-tolerance vector, $\mathbf{q}$ is the initial assembly pose, and $\boldsymbol{\eta}$ contains physical settings such as materials, friction, prepress, and insertion path. The operator $\mathcal{S}$ represents finite element modeling, assembly, and solving. Outputs $\mathbf{y}$ include contact-force curves and endpoint metrics.

This formulation separates manufacturing tolerances, assembly pose, sampling design, and physical settings. A comparison of sampling methods holds pose and physical settings fixed. A pose-boundary search holds the same manufacturing-tolerance vector fixed. Otherwise, changes in the response cannot be attributed clearly.

The work therefore has two layers. First, deterministic analysis must be efficient enough to support batch execution. Second, the same foundation introduces tolerances and automated failure-boundary search. The focus here is the engineering connection between these layers rather than adding a separate predictive model.

Reduce the repeated work with substructures

What CORE and SUB mean

The finite element method (FEM) discretizes a continuum into nodes and elements. Here, CORE names the retained nonlinear contact region, and SUB names a region suitable for condensation. These are engineering partition names, not material types or specific solver element names.

Figure 2 illustrates the partition with an abstract mesh. Contact and local deformation remain in CORE, while the more distant structure transfers loads through retained interface nodes. Element count alone cannot determine the partition: contact might enter the reduced region, material nonlinearity may matter there, and the interface must retain the correct motion degrees of freedom.

Schematic partition and condensation. The full mesh is on the left; the usage-level model retains interface and core detail on the right. Dots represent interface degrees of freedom. Rectangles are not actual connector geometry.

Why static condensation reduces repeated work

Partition a linear substructure into internal degrees of freedom $i$ and retained degrees of freedom $b$ : $\begin{equation} \begin{bmatrix}K_{ii}&K_{ib}\\K_{bi}&K_{bb}\end{bmatrix} \begin{bmatrix}u_i\\u_b\end{bmatrix} =\begin{bmatrix}f_i\\f_b\end{bmatrix}. \end{equation}$ Eliminating the internal degrees of freedom gives $\begin{align} \overline K_{bb}&=K_{bb}-K_{bi}K_{ii}^{-1}K_{ib},\\ \overline f_b&=f_b-K_{bi}K_{ii}^{-1}f_i,\qquad \overline K_{bb}u_b=\overline f_b. \end{align}$ The inverse is mathematical notation. Implementations normally solve linear systems rather than explicitly constructing the entire inverse. Reduction happens during substructure generation; the usage stage assembles the resulting library with CORE.

The benefit comes from reuse, not deleting a region of the model. Multiple samples that change only CORE can reuse a verified library when the substructure and its interface definition remain applicable. Changes to substructure geometry, materials, retained degrees of freedom, or generation conditions invalidate that assumption, even when the filename stays the same.

Files form a consistent set

An input deck, usually .inp, records the mesh, sets, and keywords. Substructure-related .sim, .sup, and output database (ODB, .odb) files have different purposes. They cannot be replaced independently merely by matching extensions. They must originate from a compatible generation job and agree on interface labels.

Library provenance is therefore an input: generation files, retained sets, model identity, and validation results are recorded. Batch assembly creates interface sets from labels instead of guessing nearest coordinate points in a large model. Abaqus documentation [1] describes the underlying method; suitability must still be checked for the current model.

Parameterization starts with a successful GUI operation

Record the working operation, then wrap it

A correct graphical user interface (GUI) operation is a reliable starting point for automation. HyperMesh command history records the corresponding Tool Command Language (Tcl) instructions. The process begins by completing the desired operation in the GUI, then extracting the required commands rather than guessing API arguments from panel names.

History cleanup removes view and selection-panel operations unrelated to the physical result. Explicit entity selection, shape application, and export remain; paths, amplitudes, and output names become parameters. Python manages samples, files, and processes. Tcl executes native HyperMesh operations. Notebooks are interactive entry points, while reusable logic remains in Python modules callable from the command line.

Application programming interfaces (APIs) can differ between software releases. Installed-runtime behavior and recorded commands provide the working reference. A function appearing in newer documentation does not guarantee that an older installation supports it.

A shape amplitude is not a length in millimeters

Mesh morphing parameterizes predefined shape perturbations. For shapes stored as nodal perturbations, a useful representation is $\begin{equation} \mathbf{x}(\boldsymbol{\alpha})=\mathbf{x}_0+ \sum_{j=1}^{d_g}\alpha_j\,\Delta\mathbf{x}_j, \end{equation}$ where $\alpha_j$ is dimensionless and $\Delta\mathbf{x}_j$ is the nodal displacement field stored in the baseline model. If unit amplitude changes a feature dimension by $s_j$ , its dimensional change is $\Delta L_j=s_j\alpha_j$ . Direction, units, calibration scale, and shape name must be recorded together.

What the saved nodal perturbation contains matters more than the number entered in a GUI field. Shapes involving handles, morph volumes, or constraint updates can have additional recomputation semantics. Stable combinations require checking the storage form, individual and combined application, and actual coordinates. The superposition above describes explicitly saved nodal perturbations; it does not assert that all interactive morph operations are linear or commutative.

One vector can contain several tolerance types

Parameters can also control component pre-lift or local position. The input vector can be grouped as $\begin{equation} \boldsymbol{\xi}=\bigl[\boldsymbol{\alpha}_{\mathrm{shape}},\; \boldsymbol{\alpha}_{\mathrm{prelift}},\; \boldsymbol{\alpha}_{\mathrm{local\ offset}}\bigr]. \end{equation}$ Geometry variables map to nodes; pre-lift variables map to separate control points and loading boundaries; local-offset variables map to explicitly identified components. A shared record does not require every group to use morphing. This retains vector-level traceability without turning a simple rigid translation into an unnecessary deformation operation.

Four sampling methods, one bounded probability mapping

Define the distribution before choosing a design

An ordinary normal distribution has no finite bounds. If amplitudes must lie in $[-1,1]$ , untruncated normal draws cannot be assumed to remain inside that interval. Clipping out-of-range draws to the endpoints is different: it creates point masses at the bounds and changes the distribution.

The method uses a conditionally truncated normal distribution. With standard-normal CDF $\Phi$ , density $\phi$ , and $u\in(0,1)$ , $\begin{equation} \label{eq:inverse} \alpha=\mu+\sigma\Phi^{-1}\!\left[ \Phi\!\left(\frac{a-\mu}{\sigma}\right)+u \left\{\Phi\!\left(\frac{b-\mu}{\sigma}\right) -\Phi\!\left(\frac{a-\mu}{\sigma}\right)\right\}\right], \quad a=-1,\;b=1. \end{equation}$ All four methods first generate points in the unit hypercube, then use the same inverse mapping (7) for each variable. This separates finite point placement from the probability distribution assigned to a variable.

The parameters $\mu$ and $\sigma$ describe the underlying distribution before truncation. The resulting sample standard deviation need not equal $\sigma$ , especially with narrow bounds. Identical marginal mappings also do not establish independence between manufacturing variables. Without correlation evidence, independence is an explicit modeling assumption.

What each sampling method provides

Monte Carlo (MC) uses independent pseudorandom points and is a straightforward baseline. Local clusters and gaps are normal in finite samples. A fixed seed reproduces the same design.

Latin hypercube sampling (LHS) takes one point from each equal-probability stratum of every marginal distribution, then pairs coordinates across dimensions. This provides marginal stratification; it does not ensure uniform coverage of every high-dimensional combination or reproduce the true manufacturing correlations.

Sobol and Halton sequences are low-discrepancy designs used in quasi-Monte Carlo (QMC). Sobol designs are commonly generated in sizes $2^m$ to retain their design properties. Scrambling avoids relying on a single fixed deterministic pattern. A neat low-dimensional plot alone does not prove greater accuracy for the current high-dimensional nonlinear-contact problem. References [3],[4],[5],[6] describe the methods.

Independent sampling illustration:

n=256

per method, seed 20261018. Top panels show unit-square designs before mapping; bottom panels show the first mapped marginal. The orange curve is the density of

N(0,1)

conditioned on

[-1,1]

. These are neither original project samples nor a simulation-performance comparison.

Figure 3 separates finite design coverage from the common inverse-distribution mapping. Comparisons record sample size, seed or scrambling settings, variable order, bounds, physical scale factors, and correlation assumptions. Estimation-error comparisons require appropriate repeated designs and uncertainty analysis; a smoother histogram is not sufficient evidence.

Interfaces amplify modeling mistakes during automation

A deformation boundary cannot stop abruptly

Moving a local region while the neighboring mesh or constraints remain fixed can concentrate deformation in a thin layer of elements. Obvious overlap may be absent, yet elements can become severely compressed and develop Jacobian or volume problems. A numerically small tolerance cannot replace a mesh-quality check. The relevant quantity is the deformation gradient relative to local mesh size and transition length.

Fixed interface constraints, transition regions, and post-deformation mesh checks are therefore part of the model definition. A valid baseline does not make all extreme samples valid. Extreme amplitudes and combinations are checked before scaling the batch.

Local manufacturing offsets differ from assembly pose

Figure 4 distinguishes two superficially similar operations. Moving only one terminal’s CORE while its substructure stays fixed is a local manufacturing-deviation choice and creates a nonconforming interface. Moving the entire male side relative to the female side is an initial assembly pose: male CORE and its substructure must move together.

Different physical meanings of local and whole-side motion. Dashed outlines show original positions and solid outlines show modified positions. Offsets and angles are schematic, not to scale. Assembly misalignment must not introduce an artificial internal male-side interface gap.

A tie constraint can connect a nonconforming interface. Increasing position tolerance changes which nodes or surfaces may enter that constraint; it is not a justification for repairing arbitrary geometric mismatch. Adjustment may undo an intended offset. Disabling adjustment instead requires checking actual tied coverage and its mechanical meaning. Abaqus documentation [2] explains these behaviors.

At minimum, code checks distances between corresponding labeled nodes, tolerance coverage, and whether the assembly input preserves the intended offset. The solver’s actual constraint establishment must still be verified. A large universal tolerance spanning nearby terminals makes automation more hazardous rather than more robust.

Split execution into recoverable stages

A stage matters more than one return code

Batch execution requires more than calling a solver in a loop. Each case is divided into recorded stages:

Prepare input $\longrightarrow$ Assemble $\longrightarrow$ Datacheck $\longrightarrow$ Solve $\longrightarrow$ Postprocess.

Passing datacheck does not mean a complete analysis has run. A successful outer process does not prove solver success. Logs, lock-file state, completion markers, and required steps and results in the ODB are checked together.

Each attempt has its own directory so old output cannot masquerade as a new result. Records identify inputs, selected tolerance row, substructure library, application release, CPU and memory settings, stage times, and failure locations. These records often carry more meaning than an isolated result CSV.

Concurrency, cores per job, and memory are separate controls

CPU cores per job differ from the number of concurrent cases. If each solve uses $c$ cores and up to $p$ heavy jobs run together, at least $\begin{equation} p\,c\le C_{\mathrm{available}},\qquad \sum_{k\in\mathcal{A}} M_k\le M_{\mathrm{budget}}, \end{equation}$ where $\mathcal{A}$ is the active-job set and $M_k$ is a scheduling memory budget. A solver memory percentage is a configuration cap, not a measured peak or physical memory already reserved by the operating system. Preprocessing, postprocessing, mesh export, and filesystem caches also require headroom.

Python threads may coordinate external processes, while separate native solver processes perform the finite element work. Creating a large thread pool for every search path multiplies concurrency. A shared queue instead applies separate limits to mesh export, substructure generation, and full solves.

Recovery is not deleting a lock file

Interrupting a notebook kernel can leave external solvers running. Recovery must establish whether prior jobs are alive before resubmission. A state file or deletion of .lck alone is insufficient. Completed cases are reused; failures and unknown states require explicit retry choices.

Configuration changes need separate treatment. A scheduling-concurrency change can retain the same physical results after a safe stop. Changing friction, insertion endpoint, tolerances, model, or relevant code identity cannot silently mix new outputs into an old batch. Input hashes and frozen configuration make that distinction enforceable instead of relying on operator memory.

Define contact performance before ranking it

The metric concerns normal contact performance rather than treating a total reaction as the force in a specific contact pair. For pair $i$ , let $\mathbf{F}^{\mathrm{normal}}_i$ be its total normal-contact-force vector. This implementation takes its global Y component: $\begin{equation} F_i(u)=\left|\mathbf{F}^{\mathrm{normal}}_i(u)\cdot\mathbf{e}_y\right| =|\mathrm{CFN2}_i(u)|. \end{equation}$ The output CFN2 is the second coordinate component of the normal-contact-force resultant. It is neither nodal contact pressure nor, in general, the vector’s magnitude. Changes in initial angle require checking that this global component still matches the engineering criterion. A component and a vector norm are not interchangeable.

At the specified final insertion displacement $u_\star$ , define $\begin{equation} F_{\min}(\mathbf q,\boldsymbol\xi)=\min_{1\le i\le n_c}F_i(u_\star),\qquad g(\mathbf q;\boldsymbol\xi)=F_{\min}(\mathbf q,\boldsymbol\xi)-F_{\mathrm{crit}}. \end{equation}$ Here, $n_c$ is the number of required contact pairs and $F_{\mathrm{crit}}$ is the configured engineering threshold. A negative margin $g<0$ means at least one pair is below threshold. A nonnegative margin $g\ge0$ means every required pair reaches the threshold at the verified endpoint. Actual project thresholds, insertion endpoints, and dimensional calibration values are not disclosed.

Each case is ranked by its own minimum before minima are compared across cases. The weakest pair can change with tolerance or pose; a search cannot fix one pair in advance and ignore the rest. CSV outputs retain curves for all channels, endpoint values, and the weakest-pair identity so changes in rank can be inspected.

The endpoint must actually have been reached. The final step, step time, insertion displacement, and required channel count are checked. A low force from an interrupted solve cannot enter ordinary physical-failure ranking. Missing channels are not filled with zeros.

Search an operating boundary, not only a worst sample

Change the initial pose before insertion

An initially tilted insertion differs from applying a rotation after full insertion: their contact paths are different. For a fixed manufacturing-tolerance vector $\boldsymbol\xi$ , the coordinate convention is $\begin{equation} \mathbf{x}_{\mathrm{posed}}= \mathbf{c}+R(\theta,\mathbf a) \bigl(\mathbf{x}_{\mathrm{tolerance}}-\mathbf{c}\bigr) +d\,\mathbf v, \end{equation}$ where $\mathbf c$ is the rotation center, $\mathbf a$ the unit rotation axis, $\theta$ the initial angle, $\mathbf v$ a global unit translation direction, and $d$ a signed offset. The prescribed insertion follows. Rotation and translation order is part of the model because they generally do not commute.

Existing local manufacturing offsets rotate with the entire male side. Its substructure and CORE move together, while the female stays fixed. Reference points, coupling control points, and interface nodes must be included in coordinate checks, not just the visible solid mesh.

Offset-only search: coarse scan, then refine crossings

After a verified zero-pose baseline, positive and negative offsets are scanned in parallel within the configured range. Completed points are ordered by offset magnitude. Adjacent points whose $g$ values have opposite signs bracket a sampled crossing. Refinement can divide a bracket into $k$ parts and submit up to $k-1$ interior points together instead of evaluating only one bisection midpoint at a time.

The method does not assume that force decreases monotonically with offset. If a coarse scan passes, fails, and passes again, it retains multiple crossings and refines their intervals. The primary result is the first sampled failure boundary encountered from the origin, with all observed crossings retained.

Search stops when a discovered crossing bracket meets the offset resolution or a range limit, computation budget, or unresolved error is reached. The result is a pair of verified pass/fail points, not an interpolated exact limit. If failure is not found within the configured range, that absence is reported; the search bound is not relabeled as the actual mechanical limit.

Coupled offset and angle: one queue across slices

In a two-dimensional slice $(d,\theta)$ , selected initial angles each receive positive- and negative-offset searches. Slices share one queue, so other paths can progress while one awaits a solve. Intermediate angles are added when angular gaps are large or boundary location, weakest-pair identity, or slice status changes substantially.

Figure 5 illustrates this batched adaptive bracketing process. It is not reinforcement learning. A threshold-proximity curve such as $-|g|$ can help visualize progress, but that auxiliary score does not replace the mechanical criterion or imply a learned policy or value function.

Parallel boundary-search decisions. Completed samples update crossing brackets, and rules refine angular slices. Unknown points are not represented as safe. No actual contact-force or critical-angle results are shown.

At a fixed angle, translating the entire assembly side leaves the substructure’s internal stiffness relationship unchanged. A verified library for that angle may therefore be reused with instance translation at the usage level [1]. The current implementation generates a male-side library once per distinct angle and shares a read-only cache across offsets. Cache provenance and artifact completeness must be checked; files left by a failed generation job do not make a usable library.

State what a boundary map does not cover

A slice of X translation and rotation about Y is not the full pose boundary with every translation and rotation varying simultaneously. The worst boundary for one fixed tolerance vector is not a reliability boundary for the random manufacturing population. Probability claims require a separate sampling design, coverage definition, and statistical uncertainty analysis over manufacturing variables and pose.

A finite coarse grid can miss a failure island narrower than its spacing. Two adjacent passing points do not prove that every intermediate point passes. Plots therefore retain pass/fail bracket bands, coarse-scan scale, refinement rules, and unknown regions rather than coloring everything beyond a smooth line as guaranteed safe. This is the conclusion supported by the algorithm’s actual coverage.

Acceptance checks for the complete system

Layered acceptance checks for batch simulation and boundary search.
Layer	Questions to resolve
Geometry and interfaces	Is the baseline unchanged? Are coordinates, fixed regions, control points, and interfaces correct?
Physics and numerics	Are materials, contact, prepress, and insertion consistent? Do distortion or unintended ties affect results?
Execution and recovery	Did datacheck pass and solving complete? Could a retry duplicate a still-running job?
Postprocessing	Are pair identities and global components correct? Did final time and displacement reach their endpoints?
Search and interpretation	Do completed points support the brackets? Are unknowns, budget, resolution, and coverage recorded?

Development checks can use known functions to test sampling, out-of-order parallel completion, bracket convergence, and recovery. Small artificial meshes test transformations and interfaces; real exported meshes test moved and fixed nodes. These checks establish software behavior, not a connector’s physical limit. Deployment still needs complete small-scale baseline, offset-only, and coupled offset–angle solves before expanding the search.

The implemented code connects sample generation through batch postprocessing and provides a parallel pose-search entry point with caching, budgets, and recovery state. The new whole-side-offset and coupled paths still require real-solver acceptance in a matching environment. No unverified critical angles, failure probabilities, or speedup factors are reported.

Build interpretability into automation

What makes simulation scalable is a sequence of explicit agreements: how regions and retained degrees of freedom are selected, how amplitude becomes dimensional change, which inputs remain fixed during comparison, what counts as completed solving, and which parameter subspace a boundary curve represents.

Substructures reduce repeated work. Recorded Tcl turns known GUI actions into parameterized operations. Bounded sampling makes probability assumptions reproducible. A shared queue and persistent state make batches manageable. Consistent contact metrics connect the samples to an interpretable boundary question. Every curve should lead back to its inputs, and every failure should have an explicit category. A smooth-looking plot alone is insufficient.

Reproducibility and public materials

Independent Python/Matplotlib scripts generate the figures, which are checked and exported through Tavotto and inserted as vector PDFs into the XeLaTeX text. Published sources contain only anonymized method descriptions and demonstration sampling; they do not read actual engineering files. The public website repository records the published source history.

References

Dassault Systèmes. Using Substructures. Abaqus documentation. https://docs.software.vt.edu/abaqusv2025/English/SIMACAEANLRefMap/simaanl-c-superelements.htm. Method reference; APIs must be checked against the installed runtime separately.
Dassault Systèmes. Mesh Tie Constraints. Abaqus documentation. https://docs.software.vt.edu/abaqusv2025/English/SIMACAECSTRefMap/simacst-c-tiedconstraint.htm.
McKay, M. D., Beckman, R. J., Conover, W. J. (1979). A Comparison of Three Methods for Selecting Values of Input Variables in the Analysis of Output from a Computer Code. Technometrics, 21(2), 239–245. https://doi.org/10.1080/00401706.1979.10489755.
Sobol’, I. M. (1967). On the distribution of points in a cube and the approximate evaluation of integrals. USSR Computational Mathematics and Mathematical Physics, 7(4), 86–112. https://doi.org/10.1016/0041-5553(67)90144-9.
Halton, J. H. (1960). On the efficiency of certain quasi-random sequences of points in evaluating multi-dimensional integrals. Numerische Mathematik, 2, 84–90. https://doi.org/10.1007/BF01386213.
SciPy. Quasi-Monte Carlo submodule: scipy.stats.qmc. https://docs.scipy.org/doc/scipy/reference/stats.qmc.html.
Tavotto. Technology: script, editable figure, replay and export. https://www.tavotto.com/technology/.

English PDF · Chinese PDF · Bilingual LaTeX and figure sources

An Agent-Driven CAE Toolchain: HyperMesh, Abaqus, and ParaView

Sun, 18 Oct 2026 00:00:00 +0800

English PDF · LaTeX / Tavotto sources and data · Portable task query · Task metrics CSV

Can an agent take a terminal model and two loading steps, inspect the model, allocate computing resources, complete a solve, and return verifiable curves and contour plots? This project connects HyperMesh, Abaqus, and ParaView through three MCP services. All three independent sessions completed a real terminal contact case. The session with MCP tools and engineering procedures took 21.82 minutes and produced 108 frames, with a peak actuator force of approximately 1.434141 N.

Start with a loading request

CAE automation often begins with a script: import a model, define sets, submit a job, and extract results. Agents make script generation easier, but many engineering difficulties lie between these operations. Which region does “the right end” identify? Does an application process exiting mean the solve succeeded? Can an extrapolated nodal stress be compared directly with integration-point stress? What changed after a failure, and which output should the next operation read?

This project makes those questions part of the tool interface. The agent interprets the goal and selects actions. Tools validate inputs, execute native applications, retain logs, and return actual artifacts. The focus is execution reliability and traceability. The engineering measurements described here were collected on October 12, 2026.

The terminal task retains the existing materials, sections, and mesh. The male roots and shield root are fixed. The plate first moves $0.3348\,\mathrm{mm}$ along global $+Y$ , then moves with the female terminal by $10\,\mathrm{mm}$ along global $-Z$ . The friction coefficient is 0.13. Regions, directions, and sets were confirmed before execution. For new ambiguous descriptions such as “left” or “down,” the agent presents candidate regions and a coordinate interpretation before changing the loading conditions.

Three MCP services and 54 tools

MCP is the protocol through which an agent calls tools. The project separates the native applications into three services with a shared execution layer: HyperMesh for geometry and mesh, Abaqus for models, solving, and ODB access, and ParaView for result inspection and visualization.

Application-specific tool boundaries with shared task state, input snapshots, and artifact records. The editable figure scripts were executed, composed, and exported through Tavotto.

Implemented service capabilities
Service	Tools	Capabilities
HyperMesh	13	STEP import, HM inspection, partitioning, tetrahedral mesh, INP export, Tcl.
Abaqus	29	Materials, regions, loading, resources, solve, diagnosis, repair, ODB conversion.
ParaView	12	Array/frame inspection, rendering, slices, line sampling, images, Python.

Each service includes six common management tools: capabilities, job status, job listing, artifacts, logs, and cancellation. The total of 54 includes these application-specific management interfaces; it does not represent 54 separate analysis algorithms. The full catalog is included in the article source archive.

Scripts execute in the appropriate application runtime: Tcl in HyperMesh 2017, Python or the C++ SDK in Abaqus 2025, and pvpython in ParaView 6.1. The general Python service handles protocol, scheduling, and input checks instead of mixing proprietary binary APIs and interpreters.

Three services retain the distinct input contracts, runtimes, and failure modes of preprocessing, solving, and postprocessing. Resource management belongs to the Abaqus service so different services do not independently reserve the same solver budget. The ODB2VTK executable also works directly without MCP.

Long tasks need persistent state and real files

A tool accepts a long operation and returns a job_id. An independent background dispatcher manages execution while the client polls persistent state. Only succeeded permits passing the returned artifact paths downstream. Neither queued nor running means completion.

Each job retains its request, settings snapshot, native script, logs, state, and result index. INP dependencies are copied recursively through INCLUDE files and recorded with SHA256 hashes. Resource plans bind to the same input closure. If inputs change while a job waits, the old plan cannot silently authorize the new files. Sources remain read-only, and repairs produce new inputs.

A complete Abaqus success check requires the native completion marker, both steps reaching their prescribed endpoints, and a nonempty, closed, newly generated ODB. An existing ODB or one converged increment is insufficient. ParaView then checks actual arrays, frame counts, and ranges rather than returning an image as the only evidence.

An independent dispatcher also addresses process lifetime on Windows, where closing a client can terminate descendant processes. Accepted solves should survive an individual tool connection. This is local execution management, not a replacement for an operating system or cluster scheduler.

An independent C++ ODB converter

ODB2VTK uses the official Abaqus C++ ODB API and its bulkDataBlocks() interface for contiguous field reads. It avoids accessing each FieldValue object separately. Mesh data, label mappings, and section assignments are built once and reused across frames. Binary VTU files store results, and a PVD file indexes the selected frames.

The CLI offers inspect, menu, and convert. When options are omitted, it detects the last step containing frames, its final frame, all nonempty instances, and available U and S:MISES. Explicit options select multiple steps, frame lists or ranges, section points, output position, deformation scale, and real or imaginary complex components.

.\native\odb2vtk\odb2vtk.cmd inspect --odb "input.odb"
.\native\odb2vtk\odb2vtk.cmd menu --odb "input.odb"
.\native\odb2vtk\odb2vtk.cmd convert --odb "input.odb" --step all --frames all --fields "U,S:MISES" --avg 75 --regions section --output "exports\terminal"

Exports include per-frame VTU files, collection.pvd, and manifest.json. ODB access is read-only. Missing values remain NaN, unsupported elements fail by default, and older ODBs are not silently upgraded. The Windows launcher sets the Abaqus DLL search path for its process; another machine still requires compatible native runtime libraries.

Avg 75 depends on regions and operation order

Following the Abaqus/CAE default region definition, averaging regions follow actual section assignments. Matching material or section names do not merge two assignments. Elements without an assignment are isolated and reported rather than assigned an invented common region.

For a scalar such as Mises stress, the converter extrapolates the tensor to element nodes, computes the scalar, and then applies the region and threshold test. Relative variation at a node is $v=100\frac{s_{\max}-s_{\min}}{S_{\max,R}-S_{\min,R}}.$ The numerator uses contributions at that node; the denominator uses the range of all valid extrapolated contributions in the current averaging region. For a nondegenerate region, $v<75$ permits an equal-weight average. Equality with the threshold retains discontinuities. If the regional range is zero and contributions are identical, a positive threshold permits averaging. A threshold of 0 or off disables it.

Compute the scalar before testing the threshold. Assignment boundaries and rejected averages retain separate coincident points, while NodeLabel preserves the original ODB node identity.

Arrays expose S_MISES_Avg, variation percentage, whether averaging was actually applied, and SectionAssignmentId. No subsequent Clean/Merge Points or Cell Data to Point Data operation is inserted: either could erase the discontinuities deliberately preserved by the export.

This implements scalar-before-average within section assignments. It does not reproduce additional shell/membrane feature-edge boundaries or tensor-after-average modes. Stored integration-point and extrapolated nodal values must also remain distinct: the final-frame maximum integration-point Mises is approximately 644.00 MPa, while the Avg 75 extrapolated nodal display reaches approximately 1355.07 MPa. These are different output locations.

Choosing computing resources automatically

The resource tool scans INP files, INCLUDE dependencies, and assembly instances for node counts, element types, procedures, contact, and NLGEOM. Repeated instances contribute their actual assembly multiplicity. For this solid mesh, $3N_{\mathrm{node}}$ is a sizing proxy for degrees of freedom. A factor of 1.5 accounts for the presence of contact, producing a weighted size $D$ . This is not the solver’s equation count after constraint elimination.

The initial CPU tier is $c_0(D)=\begin{cases} 1,&D<50{,}000,\\ 2,&50{,}000\le D<200{,}000,\\ 4,&200{,}000\le D<750{,}000,\\ 8,&D\ge750{,}000. \end{cases}$ Physical cores, project budgets, user limits, and any configured license allowance further constrain the result. Memory caps start at 15%, 30%, or 50%, then respect available memory and shared budgets. abaqus_plan_resources creates the plan; abaqus_submit_job consumes it and revalidates the inputs at startup.

The left panel evaluates a sizing rule, not measured parallel speedup. The right panel shows input binding, budget reservation, and native execution.

This case uses 2 CPUs and a 15% memory cap. All comparison groups received the same caps and pure-thread configuration so resource differences would not be confused with tool differences. Shared reservations constrain the aggregate CPU and memory budgets of solves started by these tools. Jobs wait when the budget is unavailable and release reservations after completion.

These are transparent initial sizing rules, not calibrated optimal configurations from repeated multi-scale CPU sweeps. Under the Abaqus execution parameter definitions, Standard memory is an allocation cap; the same interpretation does not cap the actual Explicit analysis phase. The service does not control externally launched solves or claim that a configured license limit is a live license-pool query.

Read failure evidence before generating a repair

abaqus_diagnose_job reads actual .dat, .msg, .sta, and log files. It returns bounded original context, file hashes, classifications, and eligible repairs. Unknown failures remain unknown rather than receiving a guessed universal fix.

The automatic scope of abaqus_repair_job is deliberately narrow. Evidence-supported changes can reduce the initial static increment or raise the maximum increment count. A new INP, diff, and change record are retained before replanning and datacheck. Total loading, materials, friction, fixed regions, and total step duration are preserved. Physical-condition changes require explicit confirmation.

The product session’s first datacheck actually found an empty node-based surface definition. Using native diagnostics, the agent established that the surface was unused, commented out that definition and removed a blank line through an advanced script, retained the diff, and then passed datacheck and solved. This demonstrates diagnostic tools working with native scripting; it does not mean the restricted numerical repair tool handles every syntax failure.

Material and section records, and the role of a Skill

Existing definitions may come from INP, CAE, or HyperMesh models. Library tools stage a preview before committing imports and retain original keywords, declared units, provenance, and revisions. Updates require expected_revision; sections reference a specific material revision. Export binds definitions to an explicit ELSET, and units are never silently converted.

The tetrahedral loading template supports homogeneous solid sections within its stated scope. Composite sections, unknown keywords, and unresolved orientation definitions are rejected or reported. The terminal model keeps its original materials and sections, with no invented demonstration elasticity.

A Skill supplies orchestration procedures: check units and sets, confirm ambiguous spatial descriptions, wait for long tasks to succeed, consume real artifacts, preserve averaging boundaries, interpret native warnings, and retain failed attempts. Deterministic validation stays in MCP tools. The product group enabled both MCP and engineering procedures; the comparison does not isolate the Skill’s contribution.

The terminal case: preprocessing through postprocessing

Inputs are an already-meshed single-pair terminal INP and an HM companion extracted from a larger assembly. The model contains one female terminal, two male blades, a shield, and a prepress plate. The INP is authoritative for labels, materials, sections, and eight contact pairs. HM supports native model inspection; its node labels do not replace INP labels.

The model has 11,240 C3D10M elements. Each male-root set contains 21 nodes, and the shield-root set contains 159, for 201 fixed root nodes. A 72-node region controls the female through an RP. The plate node surface has 1061 nodes and couples to a separate RP.

Confirmed conditions, in mm–N–MPa and global coordinates
Setting	Definition
Prepress	Plate $U_2=+0.3348$ mm, $U_3=0$ ; female remains stationary.
Insertion	Retain plate $U_2$ ; plate and female simultaneously reach $U_3=-10$ mm.
Contact	Friction 0.13, hard contact, finite sliding, NLGEOM=YES.
Static controls	Initial increment 0.01, duration 1, minimum $10^{-8}$ , maximum 0.05, 10000 increments.
Other constraints	Fix RP rotations and non-driven translations; fix male/shield root translations.

The execution sequence is native HM inspection, INP mesh and region checks, preparation of two new loading steps, a resource plan, datacheck, evidence-based error handling, and a complete solve. The agent then reads control-point histories, energies, and original integration-point results from the new ODB, converts all steps and frames, and checks and renders the data in ParaView.

Two endpoints from the product group’s new solve, rendered in native ParaView and composed in Tavotto. Deformation scale is 1. Each panel retains its actual color scale. Presentation camera work is excluded from task timing.

This case retains the existing mesh. Preprocessing covers model and region checks, coupling, and loading preparation. STEP import, partitioning, and tetrahedral meshing are implemented tools, but this experiment does not start with automatic CAD remeshing and reconstruction of every contact definition. The two steps cover prepress and insertion, with no added withdrawal step.

Define results numerically

Insertion force combines the two moving RPs’ global reactions and projects them onto the insertion direction: $F_{\mathrm{ins}}=-(RF_{3,\mathrm{female}}+RF_{3,\mathrm{plate}}).$ This avoids adding internal forces from both sides of contact. The new product ODB contains 25 Prepress frames and 83 Insertion frames, totaling 108. Both steps reach their endpoints, and stored control displacements match the specified values.

Independently read results from the product group’s new ODB
Metric	Value
Final prepress plate $U_2$ (mm)	0.334800005
Final insertion female / plate $U_3$ (mm)	$-10 / -10$
Peak actuator force (N)	1.434141
Final actuator force (N)	0.974671
Final maximum integration-point Mises (MPa)	644.000061
Final maximum PEEQ	0.009152083
Maximum absolute final stored RF component sum (N)	$1.95\times10^{-6}$

Independently extracted actuator and energy histories from the product group’s new ODB, retaining stored samples. Static step time is a load-path parameter, not a specified physical insertion speed.

Selected final energies are approximately ALLWK 3.4821 Nmm, ALLSE 1.5564 Nmm, ALLPD 0.2456 Nmm, and ALLFD 1.6753 Nmm. The visible remainder after subtracting the latter three from external work is approximately 0.138% of ALLWK. This checks only these stored quantities, not every solver energy term.

PVD uses sequential indices 0–107 because step-boundary time values can repeat. Original step names, frame values, and physical total time remain in the manifest and data. Sequence index 107 is not 107 seconds. If exported coordinates already include displacement, ParaView does not apply a second Warp.

Three independent sessions: all completed, with different paths

All groups received the same inputs, engineering request, and resource caps. Each had to produce a new ODB and could read vendor documentation, write scripts, and use the same standalone C++ converter. Groups could not share scripts, historical solutions, or results. Solves ran serially, without an imposed overall time limit.

Comparison conditions. A and B share a model and reasoning setting; C changes both model and client host.
Group	Tools	Distinguishing conditions
A	Three CAE MCPs and procedures	Requires actual MCP calls and a new solve.
B	Native file and terminal tools	Writes native scripts; no CAE MCP; used generic planning procedures.
C	Native file and terminal tools	Different model and host; not a single-factor comparison.

An independent evaluator reopens every new ODB to read displacements, reactions, energies, and integration-point results, and checks native success markers, mesh data, VTK files, and images. The 100-point artifact checklist assigns 5 for input preservation, 10 for model-definition preservation, 25 for a complete new solve, 15 for control displacements, 10 for reaction/energy checks, 10 for native preprocessing, 10 for 108 frames and regional averaging, 5 for images and curves, and 10 for resource records and datacheck. It is neither a general success rate nor a design-validation score.

Engineering-task measurements, one session per group
Group	Checklist	Minutes	Tool calls	MCP calls	Peak (N)
A	100/100	21.82	109	47	1.434141
B	100/100	27.24	81	0	1.434141
C	100/100	56.13	243	0	1.434150

A’s client wall time was approximately 19.9% lower than B’s in this experiment. Final native analyses took 647, 700, and 637 seconds. Remaining task times were approximately 662, 935, and 2731 seconds, including preparation, checking, diagnosis, postprocessing, network operations, and waiting. They are not isolated model-inference times. Much of the observed difference lies in engineering coordination rather than solver acceleration.

Engineering-task sessions only: elapsed time, ordinary input/output tokens, cached input reads, and tool calls. A uses MCP and engineering procedures; B and C use native tools. All complete the task.

Client-reported cumulative tokens, with ordinary and cached input separated
Group	Ordinary input	Cache reads	Output
A	119970	5048320	22840
B	121289	3867776	35711
C	132141	47289728	242125

Repeated context across turns contributes to these totals; they are not unique query lengths. An input counter can include or exclude cache reads depending on the client, so categories are separated. Reasoning tokens already counted within output are not added again. Cross-provider tokenizers and routing counters were not independently calibrated, and these figures do not establish equivalent compute or actual billing.

The measurement window spans submission of each engineering request through task completion and client exit, using only that task client’s final usage report. Article writing, LaTeX compilation, Tavotto figures, experiment setup, independent evaluation, presentation camera work, and publication are excluded.

Failure traces explain more than one total score

A completed with structured inspection and one evidence-supported input repair. B organized native scripts and delivered the same required artifacts. C repeatedly built diagnostic inputs around contact and coupling keyword layout, then completed after CAE import and export normalized the keywords.

The groups retained 1, 1, and 15 distinct datacheck data files containing errors. These counts represent diagnostic files, not 15 failed full solves. The request limited evidence-supported failed modifications to two; native groups performed more diagnostic attempts. This process deviation remains documented and is not included in the 100-point artifact checklist.

Independently extracted insertion-force curves and differences from a numerical reference. Their close agreement supports consistency for this model and loading; the reference is not experimental ground truth.

C’s peak differs from the numerical reference by approximately 0.000623%, and its normalized curve RMSE is approximately 0.000656%. All groups can complete the professional task, making execution path, context growth, and recovery behavior useful comparison targets. One case, one session per group, and simultaneous use of MCP and a Skill cannot establish a general capability ranking or isolate their causal contributions.

Engineering facts that remain after completion

The product group’s native records contain 6 dat warnings and 73 msg warnings, including 23 negative-eigenvalue warnings. They identify 618 distorted elements. C’s normalized-input inspection reports 620 distorted elements in its own context; this cannot be presented as a mesh-quality improvement.

Negative eigenvalues in nonlinear contact may accompany tangent-stiffness changes, but convergence alone cannot rule out instability or constraint problems. Distortion, material definitions, contact regions, and mesh sensitivity still affect physical credibility. This case establishes tool execution, result extraction, and traceable delivery for a specified model and confirmed conditions. It does not establish experimental correlation, lifetime performance, a complete insertion–withdrawal hysteresis loop, or industry-company endorsement.

Inputs, query, and inspectable evidence

The measured INP is 3,460,015 bytes and the HM companion is 2,313,685 bytes. Their SHA256 fingerprints are included in provenance data. Published attachments contain measured statistics, curves, a portable query, LaTeX, and editable Tavotto sources; engineering models and large solver databases are not released.

The following summarizes the portable editorial adaptation of the original task. Local absolute paths and experiment-directory isolation wording are removed, with engineering conditions preserved. The full portable query and original query fingerprint are provided with the attachments.

Inspect terminal_pair.hm and terminal_pair.inp. Retain existing mesh, materials, sections, and eight contact pairs. Fix the confirmed male and shield root sets and couple the female and plate control regions to RPs. Prepress: plate moves 0.3348 mm along global $+Y$ . Insertion: retain prepress while plate and female move 10 mm along global $-Z$ . Use friction 0.13, hard contact, finite sliding, NLGEOM, and exactly two steps. Record a resource choice capped at 2 CPUs and 15% memory, run datacheck, then submit a new solve. Read stored RP displacements and reactions, energies, and original integration-point stresses. Convert all steps and 108 frames using section-assignment Avg 75. Inspect the data in ParaView and return endpoint contours, state files, and the actuator curve. Retain native errors and input diffs without changing physics to force convergence.

Native interface references

Vendor documentation describes bulk ODB access, averaging regions, and job-execution parameters. The implementation scope is stated beside each capability.

English PDF · LaTeX / Tavotto sources and data · Portable task query · Task metrics CSV

Hello World

Tue, 14 Jul 2026 00:00:00 +0000

This is the first placeholder post on the site.

The blog now uses the original Hugo XMin theme. Future posts can be added as Markdown files without changing the layout.

Keep it simple.
Write things down.
Improve them later.

A Short Note

Mon, 13 Jul 2026 00:00:00 +0000

A short note can hold an idea before it becomes a longer article.

one question;
one useful reference;
one result to verify later.

About

Mon, 01 Jan 0001 00:00:00 +0000

Hi, I am AlexanderChan. I write about programming, machine learning, engineering simulation, and the experiments behind these projects.

You can find my public work on GitHub.