STORX: An Open-Source Object-Oriented Framework for Shape and Topology Optimization in MATLAB

This paper introduces STORX, an open-source, object-oriented MATLAB framework designed to facilitate the learning and research of shape and topology optimization through a modular, extensible architecture that seamlessly integrates parametric and level-set methods with finite element analysis and visualization.

The Gist

Imagine you are an architect trying to design the perfect chair. You want it to be as strong as possible while using as little wood as possible. In the past, if you wanted to change the shape of the chair, you might just shave off a little wood here or there (Shape Optimization). If you wanted to change the entire structure—maybe turning a solid block into a lattice frame—you'd have to start over with a completely different set of blueprints (Topology Optimization).

Usually, these two tasks are taught as separate subjects with different tools. STORX is a new, free software toolkit built in MATLAB that acts like a "universal translator" and a "Swiss Army knife" for these design problems. It lets students and researchers see how shape and topology optimization are actually part of the same family, just wearing different hats.

Here is a simple breakdown of what the paper says STORX does:

1. The "Lego Box" Approach (Modularity)

Think of STORX as a giant box of Lego bricks. Instead of building a whole new castle every time you want to try a different design, you just swap out specific bricks.

• The Core: The main structure of the software is fixed and stable.
• The Swappable Parts: You can easily swap in different "bricks" for things like:
  • The Goal: Do you want the lightest chair? The stiffest? The one that handles wind best?
  • The Rules: Do you have a limit on how much material you can use? Do you need to keep a specific hole open for a handle?
  • The Method: Do you want to use a method that moves boundaries smoothly (Level-Set) or one that eats away material like a sculptor (Evolutionary)?

The paper claims this makes it incredibly easy to test new ideas without rewriting the whole program.

2. The "Digital Clay" (How it Works)

STORX treats the design area like a block of digital clay.

• Step 1: The Mold: You define the outer boundary (the B-Rep), like drawing the outline of the chair on a piece of paper.
• Step 2: The Grid: The software chops this outline into thousands of tiny squares or triangles (a mesh), like a pixelated image.
• Step 3: The Test: It runs a "stress test" (Finite Element Analysis) to see how the design bends or breaks under weight.
• Step 4: The Sculpting: Based on the test, the software automatically reshapes the clay. It might thicken a weak leg or hollow out a strong part.
• Step 5: The Repeat: It repeats this cycle hundreds of times until the design is perfect.

3. The Different Sculpting Styles

The paper highlights that STORX supports several different "sculpting styles," allowing users to compare them side-by-side:

• Parametric Shape Optimization: Like adjusting the knobs on a radio. You change specific numbers (like the radius of a hole or the angle of a cut), and the software finds the best settings.
• Level-Set Optimization: Imagine the design is a cloud of fog. The software moves the "surface" of the fog to find the best shape, but it doesn't create new holes out of thin air; it just reshapes what's already there.
• Density-Based Topology Optimization: This is like having a block of sand. The software decides which grains of sand to keep (solid) and which to wash away (void) to create the strongest structure.
• Topological Sensitivity (ESO/BESO/PareTO): These are more aggressive methods.
  • ESO is like a "hard kill" method: if a piece of material isn't doing much work, it gets deleted forever.
  • BESO is "bi-directional": it can delete weak parts but also add material back if it realizes it made a mistake.
  • PareTO is like a smart navigator that traces the "perfect trade-off" path, finding designs that are the absolute best balance between weight and strength.

4. Real-World Rules (Manufacturing Constraints)

A common problem in computer design is that the software creates shapes that look cool but are impossible to build (like a bridge that is only one atom thick). STORX includes "manufacturing constraints" to fix this.

• Minimum Feature Size: It acts like a rule that says, "No part of the design can be thinner than a pencil." This prevents the software from creating impossible, microscopic details.
• Retained Regions: You can tell the software, "Keep this specific area solid because I need to bolt something there later." The software will respect this and never delete that part.

5. Beyond Just Chairs (Other Physics)

While the paper focuses heavily on structural strength (like bridges and grippers), it shows that STORX can also handle:

• Multiple Loads: Designing a part that must handle a heavy weight from the top and a strong wind from the side simultaneously.
• Self-Weight: Designing a bridge that has to support its own massive weight.
• Heat Flow: Designing a shape that moves heat away efficiently (like a computer chip cooler).
• Fluid Flow: Designing a pipe bend that lets water flow through with the least amount of energy wasted.

6. Why This Matters for Learning

The paper emphasizes that STORX is built for education.

• Transparency: Because the code is open-source and organized clearly, students can see exactly how the math turns into the picture. They aren't just pressing a "black box" button; they can see the gears turning.
• Reproducibility: Anyone can download the code, run the same examples, and get the same results.
• Flexibility: Students can take a basic example (like a cantilever beam) and quickly add a new constraint (like "make it heat-resistant") to see how the design changes.

Summary

In short, STORX is an open-source, educational software framework that unifies different ways of optimizing shapes and structures. It uses a modular "Lego-like" design so that students and researchers can easily swap out goals, rules, and methods to see how they affect the final result. It bridges the gap between abstract math formulas and visual, 3D-printable designs, making it a powerful tool for learning how to design better, stronger, and more efficient objects.

Technical Summary

Technical Summary: STORX Framework for Shape and Topology Optimization

Problem Statement

Shape and topology optimization (SO/TO) are frequently taught and implemented as distinct algorithmic families, despite sharing a common computational pipeline involving state problem solving, objective/constraint evaluation, sensitivity analysis, and design updates. Existing educational codes often follow a "script-per-method" approach, where each algorithm is implemented as a monolithic script tailored to a specific formulation (e.g., density-based compliance minimization). While effective for teaching individual methods, this style obscures the shared abstractions between SO/TO, hinders systematic comparison, and complicates the extension of code to new objectives, constraints, or coupled physics. There is a need for a unified, open-source framework that maintains the transparency of teaching codes while exposing the structural commonalities across different design representations to bridge the gap between textbook formulations and extensible research software.

Methodology

The paper presents STORX (Shape and Topology Optimization for Research and Experimentation), an open-source, MATLAB-based framework built on object-oriented programming (OOP) principles. The core design philosophy is modularity through separation of intent, utilizing abstract base classes to define stable software contracts. This allows new objective functionals, constraints (including manufacturing constraints), and problem-specific components to be implemented as derived classes without modifying the core solver infrastructure.

The framework integrates four major components:

1. Solver: Handles the state equation (e.g., Finite Element Analysis for linear elasticity or thermal conduction). It supports both structured grid meshes (for standard TO) and triangular meshes (for parametric shape optimization and stress analysis).
2. Optimizer: Updates the design variables based on sensitivity information.
3. Physical Constraints & Objectives: Modules that evaluate functionals (e.g., compliance, stress, lift, drag) and compute gradients.
4. Manufacturing & Design Constraints: Modules that act on design variables and sensitivity fields to enforce manufacturability (e.g., minimum feature size, symmetry, retained regions).

STORX supports a continuum of optimization approaches:

• Parametric Shape Optimization: Controls geometry via low-dimensional vectors (e.g., hole radius, chamfer depth) using triangular meshes and semi-analytic or finite-difference gradients.
• Level-Set Shape Optimization (LSSO): Evolves boundaries using the Hamilton-Jacobi equation (HJE) while maintaining constant topology.
• Topology Optimization (TO):
  • Density-based: Utilizes Solid Isotropic Material with Penalization (SIMP) or Rational Approximation of Material Properties (RAMP) interpolation schemes with Optimality Criteria (OC), Method of Moving Asymptotes (MMA), or Globally Convergent MMA (GCMMA) updates.
  • Level-Set TO: Extends LSSO by introducing hole nucleation via standard or modified HJE formulations.
  • Topological Sensitivity Methods: Includes Evolutionary Structural Optimization (ESO), Bi-directional ESO (BESO), and Pareto-tracing (PareTO) approaches, utilizing both Topological Sensitivity Fields (TSF) and Discrete Sensitivity Fields (DSF).

The framework also supports multi-physics extensions, including multiple load cases, self-weight (body forces), and thermal conduction, as well as fluid topology optimization via a wrapper class coupling Navier-Stokes solvers with density-based updates.

Key Contributions

The paper outlines five primary contributions:

1. Unified Computational Platform: Enables controlled comparisons between shape, level-set, and topology optimization methods under consistent physical and numerical conditions.
2. General 2D Geometry Support: Moves beyond standard rectangular domains to support complex, boundary-defined problems using Boundary Representation (B-Rep) models.
3. Highly Modular Architecture: Decouples solvers from problem definitions, facilitating the rapid implementation of new objectives and constraints via inheritance rather than rewriting core routines.
4. Efficient Vectorized Implementation: Features vectorized routines for computational efficiency, alongside optional explicit nested-loop implementations for pedagogical transparency.
5. Flexible Prototyping Environment: Allows testing of novel algorithms, material models, and constraints without altering the underlying solver infrastructure.

Results and Demonstrations

The paper validates STORX through a series of benchmark problems and comparative studies:

• Accuracy Verification: Grid-based FEA results were compared against triangular mesh discretizations for a gripper example, showing close agreement (discrepancies on the order of a few percent) in displacement and stress predictions.
• Shape Optimization: Parametric and level-set shape optimization were demonstrated on cantilever beams and grippers. The semi-analytic gradient method for triangular meshes was shown to reduce computational cost compared to direct finite differences.
• Topology Optimization Benchmarks: Standard 2D problems (cantilever beams, L-brackets, MBB beams) were solved using various TO methods.
  • Density-based TO: Comparisons between SIMP/RAMP interpolation and OC/MMA/GCMMA updates showed trade-offs between computational cost and final objective values. Runtime analysis indicated that while STORX incurs an overhead of ~60-68% per iteration compared to highly specialized codes like top88 due to its modular architecture, it remains competitive (approx. 0.4s per iteration for 50,000 elements).
  • Level-Set vs. Topological Sensitivity: Comparisons between standard HJE, modified HJE, ESO, BESO, and PareTO methods revealed that Pareto-tracing approaches generally achieved lower compliance values and more robust intermediate designs by explicitly constructing Pareto-optimal solutions.
• Manufacturing Constraints: The framework successfully enforced minimum feature sizes, retained regions, and symmetry, producing designs that were subsequently 3D printed to verify physical realizability.
• Multi-Physics Extensions: The framework was extended to handle multiple load cases (showing improved robustness over single-load designs), self-weight loading (bridge example), thermal conduction (heat flux and internal generation), and fluid flow (pipe bends and airfoil lift/drag optimization).

Significance and Claims

The paper positions STORX not as a comprehensive reference on finite element theory, but as a cohesive, extensible, and transparent environment for engaging with modern SO/TO methods. Its significance lies in:

• Educational Value: It serves as a tool for graduate-level coursework, allowing students to implement and extend optimization methods hands-on. The modular structure was successfully used in a course at the University of Kansas to teach concepts like local volume fraction constraints.
• Research Prototyping: It provides a foundation for rapid experimentation where method development requires frequent extensions and verification. The separation of concerns allows researchers to test new physics or constraints without destabilizing the core solver.
• Reproducibility: By mapping mathematical formulations directly to executable code within a consistent object-oriented structure, STORX lowers the barrier between conceptual understanding and reproducible computational experiments.

The authors emphasize that the framework is designed to be accessible and editable, encouraging community contributions and adoption in both research and instruction.