A client receives a CAD file of a part, but the design is over-engineered: safety factor of 3 when 1.5 is required. Long manual optimization begins—iterations, recalculations, new prototypes. A month of engineer work, and mass reduced by only 10%. We offer a different approach: AI finds the optimal shape in hours, not weeks. Topology optimization can reduce mass by 30-40% without losing strength (SIMP, classic method).
Example: for an aircraft bracket weighing 2.3 kg with safety factor 3, we reduced mass to 1.4 kg without strength loss. Manual optimization would take 3 weeks, AI did it in 6 hours. Material savings — 0.9 kg, which at aluminum price of $2.5/kg saves $2.25 per part, and for a series of 10,000 parts — $22,500. Design time reduced by 10x, making AI generative design 10 times faster than traditional manual optimization.
We develop a generative design system that analyzes loads and boundary conditions, then generates a structure with minimal possible weight under given strength requirements. Stack — Python, PyTorch, Scipy, OpenCASCADE. Applying machine learning in engineering (ML for CAD) automates routine tasks. Result — up to 40% material savings and 5-10x acceleration of the design cycle.
How Generative Design Works: From SIMP to VAE
Topology Optimization with SIMP (Time-Efficient)
The classic method is SIMP (Solid Isotropic Material with Penalization). The algorithm iteratively distributes material in a discrete grid, aiming to minimize compliance under a given volume. Suitable for problems with clear loads: brackets, frames, supports.
import numpy as np
from scipy.sparse import lil_matrix
from scipy.sparse.linalg import spsolve
class TopologyOptimizer:
def __init__(self, nelx=60, nely=30, volfrac=0.5, penal=3.0, rmin=1.5):
self.nelx = nelx
self.nely = nely
self.volfrac = volfrac
self.penal = penal
self.rmin = rmin
def optimize(self, load_case, boundary_conditions, max_iterations=100):
x = np.full((self.nely, self.nelx), self.volfrac)
xold = x.copy()
for iteration in range(max_iterations):
U = self._finite_element_analysis(x, load_case, boundary_conditions)
dc = self._sensitivity_analysis(x, U)
dc = self._filter_sensitivity(x, dc)
x = self._oc_update(x, dc)
change = np.max(np.abs(x - xold))
xold = x.copy()
if change < 0.01:
break
return x
# ... methods omitted for brevity
Why SIMP Isn't Suitable for Complex Parts?
SIMP is sensitive to initial conditions and can get stuck in local minima. For problems with multiple loads or nonlinear constraints, neural network methods are better — they generate diverse options from which the engineer selects the best.
How VAE Generates New Designs?
We use a variational autoencoder (VAE), trained on a dataset of 2,000 optimized designs. Input is a vector of physical conditions (loads, boundaries), output is a new shape with desired properties. This yields hundreds of options in seconds. Variational autoencoders were proposed by Kingma and Welling (Auto-Encoding Variational Bayes).
import torch
import torch.nn as nn
class DesignGeneratorVAE(nn.Module):
def __init__(self, latent_dim=64, design_resolution=64):
super().__init__()
self.latent_dim = latent_dim
res = design_resolution
self.encoder = nn.Sequential(
nn.Conv2d(1, 32, 4, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(32, 64, 4, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(64, 128, 4, stride=2, padding=1),
nn.ReLU(),
nn.Flatten()
)
encoder_out_size = 128 * (res // 8) ** 2
self.fc_mu = nn.Linear(encoder_out_size, latent_dim)
self.fc_logvar = nn.Linear(encoder_out_size, latent_dim)
self.condition_proj = nn.Linear(16, latent_dim)
self.decoder_input = nn.Linear(latent_dim * 2, 128 * (res // 8) ** 2)
self.decoder = nn.Sequential(
nn.ConvTranspose2d(128, 64, 4, stride=2, padding=1),
nn.ReLU(),
nn.ConvTranspose2d(64, 32, 4, stride=2, padding=1),
nn.ReLU(),
nn.ConvTranspose2d(32, 1, 4, stride=2, padding=1),
nn.Sigmoid()
)
self.res = res
def generate(self, conditions, n_samples=1):
with torch.no_grad():
z = torch.randn(n_samples, self.latent_dim)
c = self.condition_proj(conditions.expand(n_samples, -1))
zc = torch.cat([z, c], dim=1)
h = self.decoder_input(zc)
h = h.view(n_samples, 128, self.res // 8, self.res // 8)
return self.decoder(h)
Integration with CAD (via Python-OCC)
The obtained density matrix is converted to a 3D mesh via Marching Cubes, smoothed, and exported to STL. Then import into any CAD system for final refinement.
from OCC.Core.BRepBuilderAPI import BRepBuilderAPI_MakeSolid
from OCC.Core.TopoDS import TopoDS_Shape
import trimesh
import numpy as np
def density_to_mesh(density_matrix, threshold=0.5):
from skimage.measure import marching_cubes
density_3d = np.stack([density_matrix] * 10, axis=-1)
verts, faces, normals, _ = marching_cubes(
density_3d, level=threshold, spacing=(1.0, 1.0, 1.0))
mesh = trimesh.Trimesh(verts=verts, faces=faces, vertex_normals=normals)
mesh = trimesh.smoothing.filter_laplacian(mesh, iterations=10)
return mesh
def export_to_stl(mesh, output_path):
mesh.export(output_path)
How to Implement AI Generative Design: Step-by-Step Guide
- Audit current designs and loads — collect data on boundary conditions, materials, safety factors.
- Choose method — SIMP for clear tasks, VAE for multi-variant generation.
- Develop model — implement algorithm, train VAE on your dataset (if required).
- Generate and validate — obtain variants, verify with finite element analysis (NASTRAN, Ansys).
- Integrate with CAD — convert to STL/STEP, import into SolidWorks, CATIA, or Fusion 360.
- Test and refine — finalize design, deliver documentation (model card).
What Results Can Be Achieved with Generative Design?
| Domain | Task | Constraints | Goal | Material Savings |
|---|---|---|---|---|
| Aviation | Bracket | Shear loads | -40% weight | Significant at material cost |
| Medical | Bone implant | Biomechanical loads | Porosity for osseointegration | Custom |
| Automotive | Shock absorber bracket | Impact loads | -30% material | Substantial |
| Architecture | Load-bearing columns | Wind + snow loads | Minimal material | Custom |
Comparison of SIMP and VAE Methods
| Method | Applicability | Data Requirements | Generation Time | Outcome |
|---|---|---|---|---|
| SIMP | Clear physical problems, linear elasticity | Load parameters, boundary conditions | Minutes | Single optimal solution |
| VAE | Multiple loads, nonlinear constraints | Dataset of optimized designs (1000+) | Seconds (after training) | Multiple variants |
Typical Mistakes in Generative Design Implementation
- Ignoring boundary conditions: if attachment points are incorrectly specified, AI outputs a beautiful but useless shape.
- Overfitting VAE on a small dataset: less than 1000 samples leads to hallucinations — unrealistic designs.
- Lack of finite element validation: AI result must be verified in NASTRAN or Ansys.
What Our Work Includes (Deliverables)
We deliver turnkey projects with the following items:
- Documentation: model card, retraining instructions, and usage guide.
- Source code: complete AI pipeline and integration scripts.
- Integration: export to STL/STEP and CAD environment setup.
- Support: 12 months of updates and troubleshooting.
- Training: optional session for your engineering team.
Our Experience and Guarantees
We have been in AI engineering for over 7 years, completed 20+ projects in aviation, automotive, and medical industries. We provide a guarantee on algorithm performance in your conditions. If needed, we retrain the model on new data. All source code and model card are delivered to the customer.
Timeline
Basic SIMP prototype — 1–2 weeks. Full VAE system — 4–6 weeks. Timelines are calculated individually after problem analysis. We have experience accelerating projects through transfer learning and quantization (INT8) — p99 latency reduced by 2x.
Evaluate Potential for Your Part
In projects, we achieve 35-40% mass reduction for aluminum and titanium parts. If your current design process takes weeks of manual optimization, contact us for a demonstration. Our AI for structural optimization and neural network shape generation enable rapid iteration. Automated design engineering with AI reduces manual effort. Request an audit of your part and receive a demo calculation in 2 days — get in touch.