Mesh Generation

Mesh Generation

Goal

Provide a consistent workflow for selecting mesh resolution and checking mesh quality for PDE simulations.

Requirements

• Python 3.8+
• No external dependencies (uses stdlib)

Inputs to Gather

Decision Guidance

Resolution Selection

What is the smallest feature size?
├── Interface width → dx ≤ width / 5
├── Boundary layer → dx ≤ layer_thickness / 10
├── Wave length → dx ≤ lambda / 20
└── Diffusion length → dx ≤ sqrt(D × dt) / 2

Mesh Type Selection

Script Outputs (JSON Fields)

Workflow

1. Estimate resolution - From physics scales 2. Compute grid sizing - Run scripts/grid_sizing.py 3. Check quality metrics - Run scripts/mesh_quality.py 4. Adjust if needed - Fix aspect ratios, reduce skewness 5. Validate - Mesh convergence study

Conversational Workflow Example

User: I need to mesh a 1mm × 1mm domain for a phase-field simulation with interface width of 10 μm.

Agent workflow: 1. Compute grid sizing:

   python3 scripts/grid_sizing.py --length 0.001 --resolution 200 --json

2. Verify interface is resolved: dx = 5 μm, interface width = 10 μm → 2 points per interface width. 3. Recommend: Increase to 500 points (dx = 2 μm) for 5 points across interface.

Pre-Mesh Checklist

• [ ] Define target resolution per feature/interface
• [ ] Ensure dx meets stability constraints (see numerical-stability)
• [ ] Check aspect ratio < limit (typically 5:1)
• [ ] Check skewness < threshold (typically 0.8)
• [ ] Validate mesh convergence with refinement study

CLI Examples

# Compute grid sizing for 1D domain
python3 scripts/grid_sizing.py --length 1.0 --resolution 200 --json

# Check mesh quality
python3 scripts/mesh_quality.py --dx 1.0 --dy 0.5 --dz 0.5 --json

# High aspect ratio check
python3 scripts/mesh_quality.py --dx 1.0 --dy 0.1 --json

Error Handling

Interpretation Guidance

Aspect Ratio

Skewness

Resolution Guidelines

Limitations

• 2D/3D only: No unstructured mesh generation
• Quality metrics: Basic aspect ratio and skewness only
• No mesh generation: Sizing recommendations only

References

• references/mesh_types.md - Structured vs unstructured
• references/quality_metrics.md - Aspect ratio/skewness thresholds

Version History

• v1.1.0 (2024-12-24): Enhanced documentation, decision guidance, examples
• v1.0.0: Initial release with 2 mesh quality scripts

Mesh Types

Comprehensive guide for selecting mesh types in numerical simulations.

Structured Meshes

Cartesian (Regular)

Uniform spacing in each direction.

Grid points at: (i×dx, j×dy, k×dz)
where i, j, k are integers

Properties:

Best for:

• Phase-field simulations
• Spectral methods
• Regular domains (boxes)
• Prototyping and testing

Rectilinear (Non-uniform Cartesian)

Variable spacing, still axis-aligned.

Grid points at: (x_i, y_j, z_k)
where x_i, y_j, z_k are 1D arrays

Properties:

Use for:

• Boundary layer refinement
• Interface refinement
• Graded meshes

Stretching functions:

Geometric: dx_i = dx_0 × r^i
Hyperbolic tangent: concentrated at boundaries
Polynomial: smooth variation

Curvilinear (Body-Fitted)

General structured mesh, not axis-aligned.

Physical: (x, y, z)
Computational: (ξ, η, ζ) on [0,1]³

Mapping: x = x(ξ,η,ζ), etc.

Properties:

Metric terms:

∂/∂x = (1/J)[∂ξ/∂x × ∂/∂ξ + ∂η/∂x × ∂/∂η + ∂ζ/∂x × ∂/∂ζ]
where J = Jacobian of mapping

Common transformations:

• Polar/cylindrical
• Elliptic smoothing
• Algebraic stretching

Block-Structured

Multiple structured blocks patched together.

Block 1: (i,j,k) ∈ [0,N1] × [0,M1] × [0,P1]
Block 2: (i,j,k) ∈ [0,N2] × [0,M2] × [0,P2]
...
Interface: matching or non-matching

Properties:

Unstructured Meshes

Triangular (2D) / Tetrahedral (3D)

Elements: triangles (2D) or tetrahedra (3D).

Properties:

Data structures:

Nodes: [(x_0, y_0), (x_1, y_1), ...]
Elements: [(n_0, n_1, n_2), ...]  # node indices
Edges: derived from elements

Quality metrics:

• Aspect ratio
• Minimum angle
• Circumradius/inradius ratio

Quadrilateral (2D) / Hexahedral (3D)

Elements: quads (2D) or hexahedra (3D).

Properties:

Advantages over tri/tet:

• Fewer elements for same accuracy
• Better alignment with flow/field directions
• Lower numerical diffusion for advection

Mixed/Hybrid

Combine different element types.

Near walls: structured quad/hex (boundary layer)
Interior: unstructured tri/tet (flexibility)

Common patterns:

• Prism layers near walls + tets in bulk
• Quad faces on boundaries + tet interior
• Hanging nodes with transitions

Special Mesh Types

Octree/Quadtree

Hierarchical refinement by recursive subdivision.

Root cell covers domain
Subdivide cells based on criterion
Continue until resolution satisfied

Properties:

Refinement criteria:

• Gradient magnitude
• Error estimator
• Geometric features
• Distance to interface

Voronoi/Polyhedral

Cells are general polygons/polyhedra.

Properties:

Overset (Chimera)

Multiple overlapping meshes.

Background mesh: covers domain
Body-fitted mesh: around objects
Interpolation: at overlap boundaries

Use for:

• Moving bodies
• Multiple components
• Complex geometry with relative motion

Mesh Selection Guide

By Geometry Complexity

By Physics

By Method

Mesh Refinement Strategies

H-Refinement

Subdivide cells/elements.

Original: element of size h
Refined: 4 elements (2D) or 8 elements (3D) of size h/2

P-Refinement

Increase polynomial order within elements.

Original: linear elements (p=1)
Refined: quadratic elements (p=2)

R-Refinement (Mesh Movement)

Move existing nodes without changing connectivity.

Nodes move toward regions needing resolution
Total node count unchanged

HP-Refinement

Combine h and p adaptively.

Smooth regions: increase p
Non-smooth regions: decrease h

Mesh Generation Considerations

Input Requirements

Output Quality Checks

• [ ] No inverted elements
• [ ] Aspect ratio within bounds
• [ ] Skewness within bounds
• [ ] Minimum angle acceptable
• [ ] Smooth size transitions
• [ ] Boundary conformity

Common Tools

Quick Reference

Mesh Type Trade-offs

Quality Metrics

Comprehensive guide for evaluating and ensuring mesh quality.

Why Quality Matters

Poor mesh quality leads to:

• Reduced accuracy (truncation error increases)
• Solver convergence problems
• Non-physical solutions
• Instability

Primary Quality Metrics

Aspect Ratio

Ratio of longest to shortest edge (or dimension).

AR = L_max / L_min

For rectangle: AR = max(dx, dy) / min(dx, dy)
For triangle: AR = L_max / h_min (height to opposite edge)

Effect by physics:

Skewness

Measures deviation from ideal shape.

For quadrilaterals/hexahedra:

Skewness = max(|90° - θ_i|) / 90°

where θ_i are the angles at vertices
Ideal: all angles = 90°, skewness = 0

For triangles:

Equilateral skewness:
Skewness = (θ_max - 60°) / (180° - 60°)
         = (θ_max - 60°) / 120°

Or: Skewness = 1 - (θ_min / 60°)

Orthogonality

Alignment of cell faces with face normals.

Non-orthogonality angle θ:
θ = angle between face normal and line connecting cell centers

Perfect: θ = 0°

Correction in FV:

Standard gradient: uses face normal
Corrected gradient: adds non-orthogonal correction term

Cell Volume/Area Ratio

Ratio of neighboring cell sizes.

Volume ratio = max(V_i, V_j) / min(V_i, V_j)

for adjacent cells i, j

Element-Specific Metrics

Triangle Quality Measures

Radius ratio:

q = 2 × r_inscribed / r_circumscribed

Ideal: q = 1 (equilateral)
Acceptable: q > 0.5
Poor: q < 0.25

Area-based:

q = 4√3 × Area / (L₁² + L₂² + L₃²)

Ideal: q = 1 (equilateral)

Minimum angle:

θ_min ≥ 20° (minimum recommended)
θ_min ≥ 30° (good quality)

Quadrilateral Quality Measures

Jacobian ratio:

J_ratio = J_min / J_max

where J is the Jacobian at each corner

Ideal: J_ratio = 1 (parallelogram)
Acceptable: J_ratio > 0.3
Poor: J_ratio < 0.1

Warpage (3D faces):

Maximum angle between sub-triangle normals
Flat: warpage = 0°
Acceptable: warpage < 15°

Tetrahedral Quality Measures

Radius ratio:

q = 3 × r_inscribed / r_circumscribed

Ideal: q = 1 (regular tetrahedron)
Acceptable: q > 0.2

Dihedral angles:

θ_min: smallest angle between faces
θ_max: largest angle between faces

Good: 40° < θ < 120°

Volume ratio:

q = 6√2 × Volume / sum(face_areas × opposite_edge_length)

Ideal: q = 1
Acceptable: q > 0.2

Hexahedral Quality Measures

Jacobian:

J_min / J_max at all integration points

Good: > 0.3
Poor: < 0.1
Invalid: ≤ 0 (inverted element)

Edge ratio:

max(L_edge) / min(L_edge)

Good: < 5
Acceptable: < 10

Quality Thresholds by Application

Phase-Field Simulations

Fluid Dynamics

Structural Analysis

Heat Transfer

Improving Mesh Quality

Smoothing Techniques

Laplacian smoothing:

Move node to average of neighbors
x_new = (1/n) × Σ x_neighbors

Caution: can invert elements
Use with quality check

Optimization-based smoothing:

Minimize: Σ (quality penalty)
Subject to: no inverted elements

Local Reconnection

Edge/face swapping:

If swap improves minimum quality:
  Perform swap

Node insertion/deletion:

Insert node in poor element
Delete nodes causing poor quality

Refinement/Coarsening

Poor quality from size variation:
  Refine large cells
  Coarsen too-fine cells
  Maintain 2:1 balance

Quality Checking Workflow

Pre-Solve Check

1. Statistics:

• Minimum/maximum of each metric
• Distribution histograms
• Location of worst elements

2. Thresholds:

• Flag elements below threshold
• Count problem elements
• Identify clusters

3. Visualization:

• Color by quality metric
• Highlight problem regions
• Check boundary layers

During Solve (Adaptive)

def check_quality_runtime(mesh):
    """Check quality at runtime for adaptive methods."""
    min_quality = compute_min_quality(mesh)

    if min_quality < threshold_critical:
        raise MeshQualityError("Mesh degenerated")

    if min_quality < threshold_warning:
        log_warning(f"Poor mesh quality: {min_quality}")
        trigger_remesh()

Post-Solve Verification

1. Compare solution smoothness to mesh quality 2. Check conservation errors vs quality 3. Identify if quality limited accuracy

Quality Metrics Implementation

def triangle_quality(p1, p2, p3):
    """Compute triangle quality measures."""
    # Edge lengths
    L1 = np.linalg.norm(p2 - p1)
    L2 = np.linalg.norm(p3 - p2)
    L3 = np.linalg.norm(p1 - p3)

    # Semi-perimeter and area
    s = (L1 + L2 + L3) / 2
    area = np.sqrt(s * (s - L1) * (s - L2) * (s - L3))

    # Inscribed and circumscribed radii
    r_in = area / s
    r_circ = L1 * L2 * L3 / (4 * area)

    # Quality measures
    radius_ratio = 2 * r_in / r_circ
    area_quality = 4 * np.sqrt(3) * area / (L1**2 + L2**2 + L3**2)

    # Angles
    angles = []
    for i, (a, b, c) in enumerate([(L1, L2, L3), (L2, L3, L1), (L3, L1, L2)]):
        cos_angle = (b**2 + c**2 - a**2) / (2 * b * c)
        angles.append(np.arccos(np.clip(cos_angle, -1, 1)))

    min_angle = np.min(angles) * 180 / np.pi
    max_angle = np.max(angles) * 180 / np.pi

    return {
        'radius_ratio': radius_ratio,
        'area_quality': area_quality,
        'min_angle': min_angle,
        'max_angle': max_angle,
        'aspect_ratio': max(L1, L2, L3) / min(L1, L2, L3),
        'skewness': (max_angle - 60) / 120
    }

Quick Reference

Acceptable Ranges Summary

Priority by Problem Type