CAE Evaluator

May 28

Written By Joseph McFadden

THE

Abaqus INP

Comprehensive Analyzer

From Material DNA

to Physical Prototype

A Companion Reader

Version 15.5 – 15.7

Joseph P. McFadden Sr.

The Holistic Analyst

The Abaqus INP Comprehensive Analyzer: A Companion Reader

Version 15.5 – 15.7 • March 2026

Author: Joseph P. McFadden Sr.

Email: mcfadden@snet.net

Web: www.McFaddenCAE.com

Written by Joseph P. McFadden Sr.

Built in collaboration with Claude (Anthropic)

This companion reader accompanies the audiobook of the same title.

Both are available free of charge at McFaddenCAE.com.

Contents

Why This Exists

The DNA of the Model

Giving the Orphan a Family.................................. 7

What the Tool Shows You........................................ 9

Where It All Comes Together................................ 9

From Elements to Triangles to Your Hands............. 11

When You Have No CAD..................................... 11

Holding the Simulation in Your Hand................. 12

A Virtual Mentor.................................................... 13

The Three Layers................................................ 13

Evaluate, Modify, Export.................................... 14

Growing Engineers............................................. 14

Learning by Doing.................................................. 16

Getting Started....................................................... 18

Closing................................................................... 19

Why This Exists

Let me tell you how this started. It was not a grand plan. There was no product roadmap or feature spec. It started with a frustration that I think every CAE engineer has felt at some point.

We had vendors delivering finite element models to our team, and we needed to evaluate them. Were the element types appropriate? Were the contact definitions set up correctly? Were the material assignments right? Were the output requests complete enough to actually learn anything from the results? Basic questions. But answering them meant opening each model in Abaqus, clicking through menus, and manually checking dozens of settings. And not everyone on the team had a license sitting on their desk.

So I built a small tool. A Python script that could read an Abaqus input file—the .inp file—and summarize what was inside. Nothing fancy. Just: here are the materials, here are the element types, here is how many nodes and elements you have, here are the contact pairs. A quick health check.

And that should have been the end of it. But it was not. Because once you can read a model, you start asking better questions.

I should mention how this tool was actually built, because it is part of the story. I did not write this alone. From the earliest versions, I collaborated with Claude, Anthropic’s AI. Not as a code generator that I pointed at a problem and walked away from—as a genuine collaborator. I brought the engineering knowledge, the decades of CAE experience, the understanding of what analysts actually need. Claude brought the ability to translate that knowledge into working code, to debug at speed, to explore architectural options I would not have reached on my own. We worked iteratively, the way two engineers work together: I would describe what was needed and why, Claude would build it, I would test it, find the gaps, and we would refine. Every feature in this tool went through that cycle, some of them dozens of times.

I also worked with other AI systems along the way—Grok, Gemini, Perplexity, ChatGPT—each bringing a different perspective to hard problems. But Claude was the primary collaborator from start to finish, and the depth of that partnership shaped the tool in ways I did not anticipate. It is a genuinely new way of building software: human domain expertise combined with AI capability, each making the other more effective.

If I can see the materials and the section assignments, can I figure out which elements belong to which physical part? Can I rebuild the part list from the inside out, even if the model is an orphan mesh with no part labels?

And the answer was yes.

If I can identify parts, can I calculate their volumes and masses? Can I check whether the density values make physical sense?

Yes again.

And if I can identify external surfaces, can I tessellate them into triangles and export a file that SolidWorks can open? Can I send it to a 3D printer?

Yes. Yes, you can.

What started as a vendor-model review utility kept growing, because each new capability revealed the next question worth answering. And that, I think, is how the best tools come to life—not from a specification, but from genuine curiosity about what the data is trying to tell you.

Today, the Abaqus INP Comprehensive Analyzer is both a professional engineering tool and an educational platform. It evaluates models, teaches best practices, visualizes geometry, and exports to formats you can hold in your hand. And it does all of this without requiring an Abaqus license.

This companion reader walks you through what the tool does, why each capability matters, and the thinking behind how it all fits together. We are not going through every menu and button. Instead, I want you to understand the ideas, so that when you sit down with the tool, the interface makes sense because the purpose already makes sense.

Let us start with the most fundamental idea in the entire tool.

• • •

The DNA of the Model

Every finite element model carries its own DNA. Not in the biological sense, but in the way its materials, geometry, connections, and history encode everything about what the system is designed to do and how it will respond.

Think about what a material definition really is. It is not just numbers in a table. It is the identity of a physical substance. When the input file says this material has a density of 1.2 × 10⁻⁹ tonnes per cubic millimeter and a Young’s modulus of 2,400 MPa, that is polycarbonate talking. That is the DNA of the housing of a mobile phone.

A section assignment is not just bookkeeping. It is the declaration that this specific cluster of elements behaves like that specific material. It connects the abstract mesh—the skeleton of the model—to the real-world substance it represents.

The Abaqus INP Analyzer starts here. It starts with the material, the identity, and traces outward through the section assignments to discover which elements share that identity. Elements that share a material and section type are grouped into a logical part. In a well-structured model, this confirms what the part labels already say. But in an orphan mesh, this tracing process is the only way to recover the individual components.

Giving the Orphan a Family

Let me explain what an orphan mesh is, because this is one of the most common challenges in production CAE work.

A lot of the models that arrive from vendors or from legacy archives are orphan meshes. That means all of the geometry—every node and every element—lives inside a single undifferentiated block. There are no part labels. No assembly tree. No documentation that says these elements are the battery and those elements are the circuit board and that group over there is the housing.

But the information is still there. It is encoded in the material assignments and the section definitions. The elements assigned to FR-4 with a shell section are the circuit board. The elements assigned to lithium-ion properties with a solid section are the battery cell. The elements with polycarbonate properties and a solid section are the housing.

The analyzer reads this DNA and rebuilds the family tree. It traces every material through its section assignments, collects the element sets, and groups them into logical parts. The orphan mesh now has a family.

This is not a trivial capability. In a model with a hundred and seventy-six parts, doing this by hand would take hours and would be error-prone. The tool does it in seconds, and it shows you exactly how it identified each part so you can verify the result.

• • •

What the Tool Shows You

When you open an input file in the analyzer, you land on the Summary tab. Think of this as the executive briefing. In plain language, it tells you: how many nodes, how many elements, what element types are in the model, how many analysis steps are defined, what contact pairs exist, what boundary conditions and loads are applied. In about ten seconds of reading, you know what this model is.

Move to the Materials tab, and you are looking at the model’s DNA directly. Every material in the file is listed on the left. Select one, and the right side shows you its full property definition. Elastic constants. Density. Plasticity data. Thermal expansion coefficients. Everything the solver needs to know about that substance. Below the properties, a cross-reference tells you which parts in the model use this material. So you can trace from identity to anatomy in a single click.

The Property Viewer takes this a step further. Instead of reading raw text, you see the data in formatted tables. If a material has temperature-dependent elastic properties, you see every temperature point and every modulus value laid out in columns. This is where you catch gaps. Does the data cover your operating temperature range? Is there an interpolation jump that could cause convergence issues? You can see it at a glance.

And if a table is not enough, the Plotting tab lets you chart any material property against any other. Young’s Modulus versus temperature. Stress versus plastic strain. Thermal conductivity across a temperature range. Each plot opens in its own window, so you can compare multiple materials or datasets side by side while you keep working.

Where It All Comes Together

The Parts tab is the heart of the interface. Once the analyzer has identified every part in the model, they all appear here in a searchable, sortable list. Each part shows its element count, node count, calculated volume, calculated mass, material assignment, and section type.

The volume and mass calculations are not approximations. They use Gaussian quadrature—the same numerical integration method that Abaqus itself uses internally. For a tetrahedral element, the result is mathematically exact. For distorted hexahedral elements, the quadrature uses enough integration points to capture the distortion. The masses you see in the tool should match what the solver reports.

Select a part, and you can visualize it in 3D. The viewer renders the part’s external surfaces with mouse-driven rotation, zoom, and pan. Select multiple parts, and they appear in distinct colors so you can see how they fit together as an assembly. This is where you catch interference, verify clearances, and confirm that the mesh represents the physical design you intended.

• • •

From Elements to Triangles to Your Hands

Let me talk about something that I think is genuinely cool about this tool. And it starts with a problem that most people outside of CAE never think about.

A finite element mesh is a mathematical construct. It is nodes and connectivity tables that a solver understands. But a mesh is not something you can open in SolidWorks. It is not something you can send to a 3D printer. It is not something your project manager can rotate on their screen during a design review. It lives in the solver’s world, and to get it out into the visual, physical world, you need to convert it.

That conversion is called tessellation. The analyzer knows the face definitions of over a hundred and seventeen Abaqus element types. A C3D8 hexahedron has six quadrilateral faces. A C3D10 tetrahedron has four triangular faces. A C3D20 quadratic hex has six faces defined by eight corner and mid-edge nodes each. The tool knows every single one of these definitions.

For solid elements, the algorithm figures out which faces are on the outside of the model—the ones that belong to only one element and therefore form the outer skin. Interior faces, the ones shared between adjacent elements, are discarded. For shell and membrane elements, the element itself is the surface. Once all the external faces are collected, quads are split into two triangles each, normals are oriented outward, and the result is a watertight triangulated surface. An STL file. The universal language of 3D geometry.

When You Have No CAD

You might say, just export the STL from the original CAD model. And sure, if you have the original CAD, you can do that. But here is the reality of production engineering work.

A lot of the time, you do not have the CAD. The vendor sent you an orphan mesh. Or the original CAD was modified during meshing, so the as-meshed geometry has diverged from the as-designed geometry. Or you need to verify how the meshed model fits together as an assembly, not how the ideal CAD fits together.

In all of those cases, this tool fills a gap that nothing else addresses. You go from an .inp file directly to a 3D model you can open in SolidWorks, view in MeshLab, or send to a printer.

Holding the Simulation in Your Hand

Let me talk about 3D printing from an FEA mesh, because I think this is underappreciated.

Obviously, a PLA print is not injection-molded polycarbonate. The material properties are completely different. So what is the value?

The value is physical intuition. When you hold a printed component in your hand, you perceive proportions, wall thicknesses, and clearances in a way that no screen can replicate.

Pass a printed sub-assembly around a design review table and watch what happens. People pick it up. They turn it over. They fit pieces together. The conversation changes from abstract to concrete.

For complex assemblies—mobile devices with dozens of internal components, automotive clusters, medical device housings—a printed sub-assembly from the FEA mesh lets you literally experiment with the model. Check how a flex circuit routes between components. See whether a snap feature engages. Trace the path where a drop-test failure surface runs through the geometry.

The mesh is the closest digital representation of the manufactured part. And this tool is the bridge from that mesh to something you can hold.

• • •

A Virtual Mentor

So far we have talked about reading the model, identifying parts, calculating properties, visualizing, and exporting. Those are the analytical capabilities. But there is another side to this tool that I am equally proud of, and it is the one that turns it from a utility into something more.

The Recommendations engine evaluates your loaded model against a set of best practices that come from two sources. The first is decades of hands-on production simulation experience. Running drop tests, debugging convergence failures, tracking down why a model gives a result that does not match the test. The kind of knowledge you accumulate one hard lesson at a time.

The second source is published best practices from across many industries. Aerospace, automotive, consumer electronics, medical devices, defense. Every industry has developed its own body of knowledge about what works and what does not in finite element simulation. The recommendations engine distills all of that into specific, actionable guidance for your model.

The Three Layers

Here is what makes the recommendations different from a generic checklist. Every single recommendation has three layers.

First: what did the analyzer find in the model. This is the specific condition that triggered the recommendation. For example, first-order hexahedral elements in a region that is going to experience bending.

Second: why does this matter. This is the physics. First-order hex elements suffer from shear locking in bending. The element formulation is too stiff, and it will underpredict displacements and overpredict stiffness. Your simulation results will be wrong, and they will be wrong in a way that makes the design look stronger than it actually is. That is dangerous.

Third: what should you change, and why this specific change. Upgrade to C3D10M modified tetrahedral elements, because the modified formulation eliminates volumetric locking while keeping the computation efficient. Or if hex meshing is required, switch to C3D8I incompatible-mode elements, which add internal degrees of freedom to capture the bending gradient.

The why is never omitted. Ever. Because if you just tell someone to change a setting without explaining the reason, they learn nothing. They will make the same mistake in the next model. But if you explain the physics, they carry that understanding forward into every model they build for the rest of their career.

Evaluate, Modify, Export

And here is the part that ties it all together. Once you have reviewed the recommendations, you do not have to go edit the input file by hand. The tool can apply the recommended changes and export a modified .inp file that follows the best practices.

Think about what that workflow looks like. A vendor sends you a model. You open it in the analyzer. The tool identifies the parts, calculates the masses, flags the issues, explains the physics behind each concern, and produces a corrected model. Your review is documented. Your modifications are traceable. And the vendor gets clear, reasoned feedback instead of a vague email saying the model needs work.

Growing Engineers

For junior engineers and students, the Recommendations tab might be the single most valuable feature. Every recommendation is a lesson. Not a lecture, but a real lesson tied to a real model with real consequences. Over weeks and months of reviewing models through this lens, a person builds the kind of intuition that normally takes years of trial and error at the bench.

This is not just a tool. It is a virtual mentor—offering the kind of guidance that normally comes from years at the bench, distilled from first-hand production experience and accumulated knowledge drawn from published practices across many industries.

• • •

Learning by Doing

The analyzer includes a Learning Center that goes beyond model evaluation into structured education. It covers five core simulation workflows: modal analysis, shock response, shock response spectrum, random vibration, and harmonic response.

Each topic follows the same format. First, a plain-language explanation of what the analysis type is and why you would use it. Not equations. Not textbook definitions. The kind of explanation you would give a colleague over coffee. What are we trying to learn from this analysis, and what physical behavior are we trying to capture?

Second, a step-by-step workflow. How do you set up this analysis in Abaqus? What steps, what output requests, what boundary conditions? The practical sequence from start to finish.

Third, key parameters and what they mean. Not just their names, but what they control in the physics and how to choose appropriate values.

Fourth, best practices. The things that experience teaches you. The settings that prevent convergence problems. The output requests that most people forget until they need them.

And fifth—and this is my favorite part—a Generate Example button that creates a working Abaqus input file right there on the spot. Not a toy problem. A professional-grade model setup that you can open in Abaqus/CAE, run the analysis, look at the results, modify something, run it again, and learn by doing.

Because that is how engineers actually learn. Not by reading. Not by watching. By running a model, changing something, and seeing what happens.

• • •

Getting Started

The tool is available in two forms. The easiest way is the standalone Windows executable. No Python installation, no package management, no command-line anything. You download one file, double-click it, and you are running. This is what I recommend for team distribution and for anyone who just wants to get to work.

The full Python source code is also available upon request. If you want to customize the tool, extend it, integrate it into your own workflow, or just learn from how it is built, reach out to me. My email is mcfadden@snet.net, and the website is McFaddenCAE.com. The source code and the educational content are shared freely. No commercial strings. If you find it useful, share it with a colleague or a student who might benefit.

The tool runs on Windows, Mac, and Linux. It requires Python 3.8 or higher if you are running from source, plus matplotlib and numpy. Everything else is optional. You do not need Abaqus installed. You do not need a license of any kind. Just an .inp file and some curiosity.

• • •

Closing

I started building this tool in 2025 because my team needed a better way to evaluate vendor models. What I did not expect was how far that simple need would take me, or that the collaboration with an AI would become one of the most productive engineering partnerships of my career.

The DNA metaphor came later, but it was always there underneath. A system’s response reveals its nature. That is true of materials under load, and it is true of people under pressure, and it is true of a finite element model when you know how to read it. And it turns out, it is true of a collaboration too. The way Claude and I worked together—iterating, testing, refining, each bringing what the other could not—revealed something about what this kind of partnership can produce when the human brings real domain knowledge to the table.

I hope this tool helps you read your models more clearly. I hope the recommendations teach you something you did not know before. And I hope that somewhere, someone holds a 3D-printed part made from an FEA mesh and understands their design a little better because they could turn it over in their hands.

That is the whole point. Not the software. Not the code. The understanding.

Thank you for reading. I am Joe McFadden. You can find me at McFaddenCAE.com. And this tool, like everything I share there, is free for anyone curious enough to use it.

Developed in collaboration with Claude (Anthropic)

Joseph McFadden https://www.mcfaddencae.com