Cauchy Desktop

Engineering Design Process

Problem Statement

Commercial FEA tools like Abaqus and ANSYS are powerful, but their black-box nature hides implementation details. A native desktop application provides direct access to the solver internals, custom visualization of intermediate results, and a transparent workflow for educational and prototyping use. The goal is not to replace commercial tools, but to build a working application that demonstrates the full FEA pipeline from mesh generation to stress recovery.

Why Qt 6?

The GUI framework choice was driven by three constraints: direct C++ solver linkage (no IPC overhead), native look and feel, and cross-platform packaging. Qt 6 satisfies all three. The comparison below shows why alternatives were rejected.

Solver Integration

The desktop application links directly to the existing header-only solver. A SolveConfig struct is populated from the GUI, passed to run_case(), and the returned SolveResult struct feeds into visualization models. No JSON serialization, no process spawning, no IPC -- direct struct passing at function-call speed.

struct SolveConfig {
    CaseType case_type;
    ElementType element_type;
    PlaneType plane_type;
    int nx, ny;
    Material material;
    std::vector<BoundaryCondition> boundary_conditions;
    SolverType solver_type;
    double cg_tolerance;
    int cg_max_iterations;
    bool use_adaptivity;
    int adaptive_iterations;
};

struct SolveResult {
    bool success;
    std::string error_message;
    Mesh mesh;
    std::vector<NodeDisplacement> displacements;
    std::vector<ElementStress> stresses;
    double max_displacement;
    double strain_energy;
    // ... convergence data, timing, etc.
};

Async Execution

Solver runs execute on a dedicated QThread. The main thread remains responsive -- the progress bar updates, the cancel button works, and the viewport stays interactive. The thread emits finished(SolveResult) when complete, and the UI switches to the results view automatically.

Visualization Strategy

All rendering uses QPainter on CPU. For a 2D FEA tool with meshes under 100K elements, CPU rendering is more than sufficient. It avoids GPU driver dependencies, works on headless systems, and produces deterministic output. The tradeoff is acceptable for the target use case: engineering analysis, not real-time gaming.

Cross-Platform Packaging

CMake builds a native .app bundle on macOS, a .desktop entry on Linux, and an NSIS installer on Windows. The same build system produces all three artifacts from a single CMakeLists.txt. No separate build scripts per platform.

Application Walkthrough

Cauchy Desktop provides a complete FEA workflow organized into dockable panels. The left dock handles input (mesh, boundary conditions, materials), the center is the 2D viewport, and the right dock controls the solver and displays results. A collapsible bottom dock holds analysis plots.

a. Mesh Editor

Generate structured Q4 or Q8 meshes with configurable element counts (nx, ny). Mesh grading allows biased element sizing toward edges or corners. Real-time quality metrics show aspect ratio, skewness, and Jacobian ratio for each element before solving.

b. Boundary Condition Editor

Point-and-click boundary condition assignment. Select nodes or edges in the viewport, choose Dirichlet (fixed displacement) or Neumann (applied force), pick the active DOFs (ux, uy), and enter the value. Boundary conditions appear as colored symbols on the mesh: yellow triangles for fixed, green arrows for forces.

c. Material Properties

Configure material properties for the analysis: Young's modulus (E), Poisson's ratio (ν), density (ρ), thickness (t), and thermal expansion coefficient (α). Preset materials (steel, aluminum, titanium) fill common values. The plane stress/strain toggle adjusts the constitutive matrix automatically.

d. Solver Panel

Choose between Cholesky (direct, for small meshes) or Conjugate Gradient (iterative, for large meshes). Set the CG tolerance and maximum iterations. The progress bar shows assembly and solve phases in real time. The cancel button interrupts the solver mid-run without crashing the application.

e. 2D Viewport

Pan and zoom the mesh with mouse controls. The viewport renders the wireframe mesh, deformed shape (with adjustable scale factor), and contour coloring for any selected field. Toggle between original and deformed configurations. Coordinate axes and grid snapping provide spatial reference.

f. Stress Analysis

Visualize six stress components: sigma_xx, sigma_yy, sigma_xy, Von Mises, sigma_1 (max principal), and sigma_2 (min principal). Scientific colormaps (turbo, viridis, RdBu_r) ensure perceptual accuracy. The colorbar at the bottom shows the exact min/max range. Nodal stress recovery via superconvergent patch recovery (SPR) provides smooth contours.

g. Principal Stress Arrows

Element-based arrow visualization shows the principal stress directions at each element centroid. Red arrows indicate tension (sigma > 0), blue arrows indicate compression (sigma < 0). Arrow length is proportional to stress magnitude. Toggle on/off via the toolbar to reduce visual clutter.

h. Mesh Quality Overlay

A color-coded overlay shows mesh quality metrics per element: aspect ratio, Jacobian ratio, and skewness. Red elements indicate poor quality that may affect solution accuracy. This overlay helps identify problematic regions before running the solver, saving computation time on meshes that need refinement.

i. Probe Tool

Click any point in the viewport to read the local stress and displacement values. The probe tool performs ray-casting from the mouse position to the mesh, interpolates shape functions at the hit point, and displays a tooltip with all six stress components, both displacement components, and the element ID. Essential for quick spot-checks without exporting data.

j. Analysis Plots (Bottom Dock)

A collapsible bottom dock contains a QTabWidget with six analysis plots. Each tab provides a different perspective on the solution data, all rendered with custom QPainter widgets.

k. Project Files

Save and load complete project state as JSON files with the .cauchy extension. Project files store the mesh, boundary conditions, material properties, solver settings, and results. Reopen a project to resume analysis without re-entering parameters. The JSON format is human-readable and compatible with the existing CLI pipeline.

l. PNG Export

Export the current viewport state as a high-resolution PNG at 1920x1080. The export includes the mesh contour, colorbar with min/max labels, boundary condition symbols, and title text. Suitable for reports, presentations, and the portfolio website.

Architecture Deep-Dive

System Architecture

+-------------------------------------------------------------+
|                      Cauchy Desktop                         |
+-------------------------------------------------------------+
|                                                             |
|  +------------------+   +------------------+   +----------+ |
|  |   Mesh Editor    |   |  2D Viewport     |   | Solver   | |
|  |   (Left Dock)    |   |  (Center)        |   | Panel    | |
|  |                  |   |                  |   | (Right)  | |
|  |  - nx, ny        |   |  - QPainter      |   |          | |
|  |  - Element type  |   |  - Mesh wire     |   | - Cholesky| |
|  |  - Grading       |   |  - Deformed shape|   | - CG     | |
|  |  - Quality       |   |  - Contours      |   | - Progress| |
|  +------------------+   |  - Arrows        |   | - Cancel  | |
|                         |  - Probes        |   +----------+ |
|  +------------------+   +------------------+                  |
|  |  BC Editor       |          |               +----------+  |
|  |  Material Props  |          |               | Analysis |  |
|  |  (Left Dock)     |          |               | Plots    |  |
|  +------------------+          |               | (Bottom) |  |
|                                |               | - 6 tabs |  |
|                     +----------+----------+    +----------+  |
|                     |   Qt Signal/Slot    |                  |
|                     |   Communication     |                  |
|                     +----------+----------+                  |
|                                |                             |
|                     +----------+----------+                  |
|                     |   Solver Runner     |                  |
|                     |   (QThread)         |                  |
|                     |   - Assembly        |                  |
|                     |   - Solve           |                  |
|                     |   - Postprocess     |                  |
|                     +----------+----------+                  |
|                                |                             |
|                     +----------+----------+                  |
|                     |   Solver Backend    |                  |
|                     |   (Header-only C++) |                  |
|                     |   - fea.hpp         |                  |
|                     |   - elements.hpp    |                  |
|                     |   - sparse.hpp      |                  |
|                     |   - solver.hpp      |                  |
|                     |   - mesh.hpp        |                  |
|                     +---------------------+                  |
+-------------------------------------------------------------+

Component Breakdown

Data Flow

User Input
    |
    v
Mesh Editor / BC Editor / Material Props
    |
    v
SolveConfig (struct)
    |
    v
SolverRunner (QThread)  -->  run_case(config)
    |                            |
    |                            v
    |                       Solver Backend (fea.hpp)
    |                            |
    |                            v
    |                       SolveResult (struct)
    |                            |
    v                            v
Result Model  <-----------  UI Update
    |
    v
Viewport / Analysis Plots / Probe Tool

Thread Model

The solver thread is short-lived: created when the user clicks "Solve," destroyed when results are received. No shared state between threads -- the solver reads from a const SolveConfig and returns a new SolveResult. The UI thread never blocks.

Technical Specifications

Build & Install

One command builds, installs, and launches the application:

./build-desktop.sh

Under the hood, this script runs:

# Build
cmake -B build-desktop -S . -DCMAKE_BUILD_TYPE=Release
cmake --build build-desktop -j$(nproc)

# Install (macOS: copies to /Applications)
cmake --install build-desktop

# Launch
open /Applications/Cauchy.app  # macOS
# or: ./build-desktop/bin/Cauchy  # Linux

Prerequisites: Qt 6 (Homebrew on macOS, apt on Linux), C++20 compiler (Clang 14+ or GCC 12+), CMake 3.20+.

Comparison with Commercial Tools

Verification Checklist