CAD and Mesh Generation Skill

CAD and Mesh Generation Skill

name: cad-mesh-generation
version: 1.0.0
category: programming
tags: [cad, mesh, freecad, gmsh, geometry, finite-element, marine-structures]
created: 2026-01-06
updated: 2026-01-06
author: Claude
description: |
  Expert CAD geometry and mesh generation using FreeCAD and GMSH. Create
  parametric marine structures, generate meshes for FEA/​BEM, and export to
  various analysis software formats (AQWA, WAMIT, ANSYS, etc.).

When to Use This Skill

Use this skill when you need to:

• Create parametric CAD models of vessels, platforms, or structures
• Generate meshes for finite element analysis (FEA)
• Generate panel meshes for boundary element methods (BEM/​hydrodynamics)
• Automate geometry creation for marine structures
• Export geometry to AQWA, WAMIT, ANSYS, or other analysis tools
• Create complex geometries programmatically with Python
• Perform mesh quality checks and refinement

Core Knowledge Areas

1. FreeCAD Python Scripting Basics

Creating geometry with FreeCAD Python API:

import sys
from pathlib import Path
from typing import List, Tuple, Optional
import numpy as np

# Try to import FreeCAD, provide fallback for development
try:
    import FreeCAD
    import Part
    import Mesh
    import MeshPart
    FREECAD_AVAILABLE = True
except ImportError:
    FREECAD_AVAILABLE = False
    print("Warning: FreeCAD not available, using mock functions")

    # Mock FreeCAD classes for development
    class MockFreeCAD:
        @staticmethod
        def newDocument(name: str):
            print(f"[MOCK] Creating document: {name}")
            return MockDocument()

        class Vector:
            def __init__(self, x: float, y: float, z: float):
                self.x, self.y, self.z = x, y, z

    class MockDocument:
        def __init__(self):
            self.objects = []

        def addObject(self, obj_type: str, name: str):
            print(f"[MOCK] Adding object: {obj_type} - {name}")
            obj = MockObject(name)
            self.objects.append(obj)
            return obj

        def recompute(self):
            print("[MOCK] Recomputing document")

    class MockObject:
        def __init__(self, name: str):
            self.Name = name
            self.Shape = None

    class MockPart:
        @staticmethod
        def makeCylinder(radius, height, base=None, direction=None):
            print(f"[MOCK] Creating cylinder: r={radius}, h={height}")
            return MockShape()

        @staticmethod
        def makeBox(length, width, height, base=None, direction=None):
            print(f"[MOCK] Creating box: {length}x{width}x{height}")
            return MockShape()

    class MockShape:
        def fuse(self, other):
            print("[MOCK] Fusing shapes")
            return self

        def cut(self, other):
            print("[MOCK] Cutting shapes")
            return self

        def exportStep(self, filename):
            print(f"[MOCK] Exporting STEP: {filename}")

        def exportIges(self, filename):
            print(f"[MOCK] Exporting IGES: {filename}")

    if not FREECAD_AVAILABLE:
        FreeCAD = MockFreeCAD()
        Part = MockPart()

def create_cylinder_vessel(
    diameter: float,
    length: float,
    wall_thickness: float = None,
    name: str = "Vessel"
) -> Tuple[Any, Any]:
    """
    Create cylindrical vessel geometry in FreeCAD.

    Args:
        diameter: Vessel diameter [m]
        length: Vessel length [m]
        wall_thickness: Wall thickness [m] (None = solid)
        name: Object name

    Returns:
        Tuple of (document, shape)

    Example:
        >>> doc, shape = create_cylinder_vessel(
        ...     diameter=10.0,
        ...     length=100.0,
        ...     wall_thickness=0.05,
        ...     name="FPSO_Hull"
        ... )
    """
    # Create document
    doc = FreeCAD.newDocument(name)

    # Create outer cylinder
    outer_radius = diameter / 2
    outer_cyl = Part.makeCylinder(
        outer_radius,
        length,
        FreeCAD.Vector(0, 0, 0),
        FreeCAD.Vector(1, 0, 0)  # Along x-axis
    )

    # If wall thickness specified, make hollow
    if wall_thickness:
        inner_radius = outer_radius - wall_thickness
        inner_cyl = Part.makeCylinder(
            inner_radius,
            length,
            FreeCAD.Vector(0, 0, 0),
            FreeCAD.Vector(1, 0, 0)
        )
        # Subtract inner from outer
        vessel_shape = outer_cyl.cut(inner_cyl)
    else:
        vessel_shape = outer_cyl

    # Add to document
    vessel_obj = doc.addObject("Part::Feature", name)
    vessel_obj.Shape = vessel_shape

    doc.recompute()

    return doc, vessel_shape

def create_rectangular_pontoon(
    length: float,
    width: float,
    height: float,
    wall_thickness: float,
    name: str = "Pontoon"
) -> Tuple[Any, Any]:
    """
    Create rectangular pontoon geometry.

    Args:
        length: Pontoon length [m]
        width: Pontoon width [m]
        height: Pontoon height [m]
        wall_thickness: Wall thickness [m]
        name: Object name

    Returns:
        Tuple of (document, shape)

    Example:
        >>> doc, shape = create_rectangular_pontoon(
        ...     length=50.0,
        ...     width=10.0,
        ...     height=5.0,
        ...     wall_thickness=0.025,
        ...     name="Barge_Pontoon"
        ... )
    """
    doc = FreeCAD.newDocument(name)

    # Outer box
    outer_box = Part.makeBox(
        length,
        width,
        height,
        FreeCAD.Vector(0, 0, 0)
    )

    # Inner box (hollowed)
    inner_box = Part.makeBox(
        length - 2 * wall_thickness,
        width - 2 * wall_thickness,
        height - wall_thickness,  # Bottom plate thickness
        FreeCAD.Vector(wall_thickness, wall_thickness, wall_thickness)
    )

    # Subtract
    pontoon_shape = outer_box.cut(inner_box)

    # Add to document
    pontoon_obj = doc.addObject("Part::Feature", name)
    pontoon_obj.Shape = pontoon_shape

    doc.recompute()

    return doc, pontoon_shape

def export_geometry(
    shape: Any,
    output_file: Path,
    format: str = 'step'
) -> None:
    """
    Export FreeCAD shape to file.

    Args:
        shape: FreeCAD shape object
        output_file: Output file path
        format: Export format ('step', 'iges', 'stl')

    Example:
        >>> export_geometry(vessel_shape, Path('vessel.step'), 'step')
    """
    output_file.parent.mkdir(parents=True, exist_ok=True)

    if format.lower() == 'step':
        shape.exportStep(str(output_file))
    elif format.lower() == 'iges':
        shape.exportIges(str(output_file))
    elif format.lower() == 'stl':
        if FREECAD_AVAILABLE:
            # Convert to mesh first
            mesh = MeshPart.meshFromShape(
                shape,
                LinearDeflection=0.1,
                AngularDeflection=0.5,
                Relative=False
            )
            mesh.write(str(output_file))
        else:
            print(f"[MOCK] Exporting STL: {output_file}")
    else:
        raise ValueError(f"Unsupported format: {format}")

    print(f"Geometry exported: {output_file}")

2. GMSH Mesh Generation

Creating meshes with GMSH Python API:

# Try to import gmsh
try:
    import gmsh
    GMSH_AVAILABLE = True
except ImportError:
    GMSH_AVAILABLE = False
    print("Warning: GMSH not available, using mock")

    # Mock gmsh module
    class MockGmsh:
        def initialize(self): pass
        def finalize(self): pass
        def open(self, filename): print(f"[MOCK] Opening: {filename}")
        def write(self, filename): print(f"[MOCK] Writing: {filename}")
        def clear(self): pass

        class model:
            @staticmethod
            def mesh():
                return MockGmshMesh()

            class geo:
                @staticmethod
                def addPoint(x, y, z, lc=0, tag=-1):
                    return tag if tag != -1 else 1

                @staticmethod
                def addLine(p1, p2, tag=-1):
                    return tag if tag != -1 else 1

                @staticmethod
                def addSurfaceFilling(lines, tag=-1):
                    return tag if tag != -1 else 1

                @staticmethod
                def synchronize():
                    print("[MOCK] Synchronizing geometry")

        class option:
            @staticmethod
            def setNumber(name, value):
                print(f"[MOCK] Setting option: {name} = {value}")

    class MockGmshMesh:
        def generate(self, dim):
            print(f"[MOCK] Generating {dim}D mesh")

        def setAlgorithm(self, dim, algo):
            print(f"[MOCK] Setting {dim}D algorithm: {algo}")

    if not GMSH_AVAILABLE:
        gmsh = MockGmsh()

def create_panel_mesh_cylinder(
    radius: float,
    height: float,
    n_circumferential: int = 36,
    n_vertical: int = 20,
    output_file: Path = None
) -> str:
    """
    Create panel mesh for cylindrical body using GMSH.

    Args:
        radius: Cylinder radius [m]
        height: Cylinder height [m]
        n_circumferential: Number of panels around circumference
        n_vertical: Number of panels vertically
        output_file: Output mesh file (.msh)

    Returns:
        Path to mesh file

    Example:
        >>> mesh_file = create_panel_mesh_cylinder(
        ...     radius=5.0,
        ...     height=100.0,
        ...     n_circumferential=36,
        ...     n_vertical=50,
        ...     output_file=Path('cylinder_mesh.msh')
        ... )
    """
    gmsh.initialize()

    # Create cylindrical surface
    gmsh.model.add("cylinder_mesh")

    # Characteristic length (mesh size)
    lc = 2 * np.pi * radius / n_circumferential

    # Create points on bottom circle
    bottom_points = []
    for i in range(n_circumferential):
        theta = 2 * np.pi * i / n_circumferential
        x = radius * np.cos(theta)
        y = radius * np.sin(theta)
        z = 0

        tag = gmsh.model.geo.addPoint(x, y, z, lc)
        bottom_points.append(tag)

    # Create points on top circle
    top_points = []
    for i in range(n_circumferential):
        theta = 2 * np.pi * i / n_circumferential
        x = radius * np.cos(theta)
        y = radius * np.sin(theta)
        z = height

        tag = gmsh.model.geo.addPoint(x, y, z, lc)
        top_points.append(tag)

    # Create lines connecting bottom to top
    vertical_lines = []
    for i in range(n_circumferential):
        line = gmsh.model.geo.addLine(bottom_points[i], top_points[i])
        vertical_lines.append(line)

    # Create horizontal lines (bottom and top circles)
    bottom_lines = []
    top_lines = []
    for i in range(n_circumferential):
        next_i = (i + 1) % n_circumferential

        bottom_line = gmsh.model.geo.addLine(bottom_points[i], bottom_points[next_i])
        bottom_lines.append(bottom_line)

        top_line = gmsh.model.geo.addLine(top_points[i], top_points[next_i])
        top_lines.append(top_line)

    # Create surfaces (panels)
    panels = []
    for i in range(n_circumferential):
        next_i = (i + 1) % n_circumferential

        # Define curve loop for each panel
        curve_loop = gmsh.model.geo.addCurveLoop([
            bottom_lines[i],
            vertical_lines[next_i],
            -top_lines[i],
            -vertical_lines[i]
        ])

        # Create surface
        surface = gmsh.model.geo.addSurfaceFilling([curve_loop])
        panels.append(surface)

    gmsh.model.geo.synchronize()

    # Generate 2D mesh (surface mesh)
    gmsh.model.mesh.generate(2)

    # Set mesh algorithm (Frontal-Delaunay for quality)
    gmsh.model.mesh.setAlgorithm(2, 6)

    # Save mesh
    if output_file is None:
        output_file = Path('cylinder_mesh.msh')

    output_file.parent.mkdir(parents=True, exist_ok=True)
    gmsh.write(str(output_file))

    gmsh.finalize()

    print(f"Panel mesh created: {output_file}")
    print(f"  Number of panels: {n_circumferential * n_vertical}")

    return str(output_file)

def create_tetrahedral_mesh(
    geometry_file: Path,
    element_size: float,
    output_file: Path,
    refine_surfaces: bool = True
) -> str:
    """
    Create tetrahedral volume mesh from geometry.

    Args:
        geometry_file: Input geometry (.step, .iges, .stl)
        element_size: Target element size [m]
        output_file: Output mesh file (.msh)
        refine_surfaces: Whether to refine surface mesh

    Returns:
        Path to mesh file

    Example:
        >>> mesh_file = create_tetrahedral_mesh(
        ...     geometry_file=Path('vessel.step'),
        ...     element_size=0.5,
        ...     output_file=Path('vessel_mesh.msh')
        ... )
    """
    gmsh.initialize()

    # Open geometry
    gmsh.open(str(geometry_file))

    # Set global mesh size
    gmsh.option.setNumber("Mesh.CharacteristicLengthMax", element_size)
    gmsh.option.setNumber("Mesh.CharacteristicLengthMin", element_size * 0.5)

    # Set 3D mesh algorithm (Delaunay for quality)
    gmsh.option.setNumber("Mesh.Algorithm3D", 1)  # Delaunay

    # Generate 2D surface mesh first
    gmsh.model.mesh.generate(2)

    if refine_surfaces:
        # Refine surface mesh
        gmsh.model.mesh.refine()

    # Generate 3D volume mesh
    gmsh.model.mesh.generate(3)

    # Optimize mesh quality
    gmsh.model.mesh.optimize("Netgen")

    # Save mesh
    output_file.parent.mkdir(parents=True, exist_ok=True)
    gmsh.write(str(output_file))

    gmsh.finalize()

    print(f"Tetrahedral mesh created: {output_file}")

    return str(output_file)

3. Mesh Quality Assessment

Check mesh quality metrics:

def analyze_mesh_quality(
    mesh_file: Path,
    mesh_type: str = 'surface'
) -> dict:
    """
    Analyze mesh quality metrics.

    Args:
        mesh_file: Path to mesh file (.msh)
        mesh_type: 'surface' or 'volume'

    Returns:
        Dictionary with quality metrics

    Example:
        >>> quality = analyze_mesh_quality(Path('cylinder_mesh.msh'), 'surface')
        >>> print(f"Min quality: {quality['min_quality']:.3f}")
        >>> print(f"Average quality: {quality['avg_quality']:.3f}")
    """
    if not GMSH_AVAILABLE:
        print("[MOCK] Analyzing mesh quality")
        return {
            'element_count': 1000,
            'node_count': 550,
            'min_quality': 0.75,
            'avg_quality': 0.92,
            'max_quality': 1.0
        }

    gmsh.initialize()
    gmsh.open(str(mesh_file))

    # Get mesh statistics
    element_types, element_tags, node_tags = gmsh.model.mesh.getElements()

    total_elements = sum(len(tags) for tags in element_tags)

    # Get nodes
    node_tags_all, node_coords, _ = gmsh.model.mesh.getNodes()
    total_nodes = len(node_tags_all)

    # Calculate element quality
    qualities = []

    if mesh_type == 'surface':
        # For triangular surface elements
        for elem_type, elem_tags in zip(element_types, element_tags):
            if elem_type == 2:  # Triangle
                for elem_tag in elem_tags:
                    # Get element quality (0-1, 1 = perfect)
                    quality = gmsh.model.mesh.getElementQuality([elem_tag], elem_type)
                    if quality:
                        qualities.extend(quality)

    elif mesh_type == 'volume':
        # For tetrahedral volume elements
        for elem_type, elem_tags in zip(element_types, element_tags):
            if elem_type == 4:  # Tetrahedron
                for elem_tag in elem_tags:
                    quality = gmsh.model.mesh.getElementQuality([elem_tag], elem_type)
                    if quality:
                        qualities.extend(quality)

    gmsh.finalize()

    if qualities:
        min_quality = min(qualities)
        avg_quality = np.mean(qualities)
        max_quality = max(qualities)
    else:
        min_quality = avg_quality = max_quality = 0.0

    return {
        'element_count': total_elements,
        'node_count': total_nodes,
        'min_quality': min_quality,
        'avg_quality': avg_quality,
        'max_quality': max_quality,
        'poor_elements': sum(1 for q in qualities if q < 0.3)
    }

4. Mesh Conversion for Analysis Tools

Convert meshes to various formats:

def convert_mesh_to_wamit_gdf(
    mesh_file: Path,
    output_file: Path,
    symmetry: str = 'none'
) -> None:
    """
    Convert GMSH mesh to WAMIT .gdf format.

    Args:
        mesh_file: Input GMSH mesh file (.msh)
        output_file: Output WAMIT file (.gdf)
        symmetry: 'none', 'x', 'y', or 'xy'

    Example:
        >>> convert_mesh_to_wamit_gdf(
        ...     mesh_file=Path('cylinder_mesh.msh'),
        ...     output_file=Path('cylinder.gdf'),
        ...     symmetry='y'
        ... )
    """
    if not GMSH_AVAILABLE:
        print(f"[MOCK] Converting mesh to WAMIT GDF: {output_file}")
        return

    gmsh.initialize()
    gmsh.open(str(mesh_file))

    # Get nodes
    node_tags, node_coords, _ = gmsh.model.mesh.getNodes()
    n_nodes = len(node_tags)

    # Reshape coordinates
    coords = np.array(node_coords).reshape((-1, 3))

    # Get surface elements (triangles/​quads)
    element_types, element_tags, node_tags_elem = gmsh.model.mesh.getElements(2)

    gmsh.finalize()

    # Write GDF file
    with open(output_file, 'w') as f:
        # Header
        f.write(f"WAMIT GDF File\n")
        f.write(f"Converted from GMSH mesh\n")

        # Symmetry
        if symmetry == 'x':
            f.write("1.0  0.0  ! XOZ symmetry\n")
        elif symmetry == 'y':
            f.write("0.0  1.0  ! YOZ symmetry\n")
        elif symmetry == 'xy':
            f.write("1.0  1.0  ! XOZ and YOZ symmetry\n")
        else:
            f.write("0.0  0.0  ! No symmetry\n")

        # Number of panels
        total_panels = sum(len(tags) for tags in element_tags)
        f.write(f"{total_panels}\n")

        # Write panels
        panel_id = 1
        for elem_type, elem_tags, node_tags_set in zip(
            element_types, element_tags, node_tags_elem
        ):
            if elem_type == 2:  # Triangle
                # Triangles have 3 nodes
                nodes_per_elem = 3
                node_tags_array = np.array(node_tags_set).reshape((-1, nodes_per_elem))

                for nodes in node_tags_array:
                    # Get coordinates of 3 vertices
                    vertices = coords[nodes - 1]  # GMSH uses 1-based indexing

                    # Write panel (x, y, z for each vertex)
                    f.write(f"{panel_id}  ")
                    for vertex in vertices:
                        f.write(f"{vertex[0]:.6f} {vertex[1]:.6f} {vertex[2]:.6f}  ")
                    f.write("\n")

                    panel_id += 1

            elif elem_type == 3:  # Quad
                nodes_per_elem = 4
                node_tags_array = np.array(node_tags_set).reshape((-1, nodes_per_elem))

                for nodes in node_tags_array:
                    vertices = coords[nodes - 1]

                    f.write(f"{panel_id}  ")
                    for vertex in vertices:
                        f.write(f"{vertex[0]:.6f} {vertex[1]:.6f} {vertex[2]:.6f}  ")
                    f.write("\n")

                    panel_id += 1

    print(f"WAMIT GDF file created: {output_file}")
    print(f"  Total panels: {total_panels}")

def convert_mesh_to_ansys_cdb(
    mesh_file: Path,
    output_file: Path
) -> None:
    """
    Convert GMSH mesh to ANSYS .cdb format.

    Args:
        mesh_file: Input GMSH mesh file (.msh)
        output_file: Output ANSYS command database (.cdb)

    Example:
        >>> convert_mesh_to_ansys_cdb(
        ...     mesh_file=Path('vessel_mesh.msh'),
        ...     output_file=Path('vessel.cdb')
        ... )
    """
    if not GMSH_AVAILABLE:
        print(f"[MOCK] Converting mesh to ANSYS CDB: {output_file}")
        return

    gmsh.initialize()
    gmsh.open(str(mesh_file))

    # Get nodes
    node_tags, node_coords, _ = gmsh.model.mesh.getNodes()
    coords = np.array(node_coords).reshape((-1, 3))

    # Get elements
    element_types, element_tags_list, node_tags_elem_list = gmsh.model.mesh.getElements()

    gmsh.finalize()

    # Write CDB file
    with open(output_file, 'w') as f:
        # Header
        f.write("/​PREP7\n")
        f.write("! Mesh converted from GMSH\n")

        # Write nodes
        f.write("! Nodes\n")
        for node_id, coord in enumerate(coords, start=1):
            f.write(f"N,{node_id},{coord[0]:.6f},{coord[1]:.6f},{coord[2]:.6f}\n")

        # Write elements
        f.write("! Elements\n")
        elem_id = 1

        for elem_type, elem_tags, node_tags_elem in zip(
            element_types, element_tags_list, node_tags_elem_list
        ):
            if elem_type == 4:  # Tetrahedron (SOLID187 in ANSYS)
                f.write("ET,1,SOLID187\n")
                nodes_per_elem = 4
                node_tags_array = np.array(node_tags_elem).reshape((-1, nodes_per_elem))

                for nodes in node_tags_array:
                    node_str = ','.join(map(str, nodes))
                    f.write(f"E,{node_str}\n")
                    elem_id += 1

        f.write("FINISH\n")

    print(f"ANSYS CDB file created: {output_file}")

Complete Examples

Example 1: Complete Vessel Geometry and Mesh Workflow

from pathlib import Path
import numpy as np

def complete_vessel_geometry_workflow(
    vessel_params: dict,
    mesh_params: dict,
    output_dir: Path
) -> dict:
    """
    Complete workflow: Create geometry, mesh, and export.

    Args:
        vessel_params: Vessel geometry parameters
        mesh_params: Mesh generation parameters
        output_dir: Output directory for all files

    Returns:
        Dictionary with file paths

    Example:
        >>> vessel_params = {
        ...     'type': 'cylinder',
        ...     'diameter': 20.0,
        ...     'length': 150.0,
        ...     'wall_thickness': 0.05
        ... }
        >>> mesh_params = {
        ...     'n_circumferential': 48,
        ...     'n_vertical': 75,
        ...     'element_size': 2.0
        ... }
        >>> results = complete_vessel_geometry_workflow(
        ...     vessel_params,
        ...     mesh_params,
        ...     Path('vessel_geometry')
        ... )
    """
    output_dir.mkdir(parents=True, exist_ok=True)

    print("="*70)
    print("VESSEL GEOMETRY AND MESH WORKFLOW")
    print("="*70)

    # Step 1: Create CAD geometry
    print("\n[Step 1/​5] Creating CAD geometry...")

    if vessel_params['type'] == 'cylinder':
        doc, shape = create_cylinder_vessel(
            diameter=vessel_params['diameter'],
            length=vessel_params['length'],
            wall_thickness=vessel_params['wall_thickness'],
            name="Vessel_Geometry"
        )

    # Export geometry
    step_file = output_dir / 'vessel.step'
    iges_file = output_dir / 'vessel.iges'

    export_geometry(shape, step_file, 'step')
    export_geometry(shape, iges_file, 'iges')

    print(f"Geometry exported: {step_file}, {iges_file}")

    # Step 2: Create surface mesh for hydrodynamics
    print("\n[Step 2/​5] Creating surface mesh for BEM analysis...")

    surface_mesh_file = output_dir / 'vessel_surface.msh'

    create_panel_mesh_cylinder(
        radius=vessel_params['diameter'] / 2,
        height=vessel_params['length'],
        n_circumferential=mesh_params['n_circumferential'],
        n_vertical=mesh_params['n_vertical'],
        output_file=surface_mesh_file
    )

    # Step 3: Analyze mesh quality
    print("\n[Step 3/​5] Analyzing mesh quality...")

    quality = analyze_mesh_quality(surface_mesh_file, 'surface')

    print(f"Mesh quality:")
    print(f"  Elements: {quality['element_count']}")
    print(f"  Nodes: {quality['node_count']}")
    print(f"  Min quality: {quality['min_quality']:.3f}")
    print(f"  Avg quality: {quality['avg_quality']:.3f}")
    print(f"  Poor elements: {quality['poor_elements']}")

    # Step 4: Convert to WAMIT format
    print("\n[Step 4/​5] Converting to WAMIT GDF format...")

    wamit_file = output_dir / 'vessel.gdf'
    convert_mesh_to_wamit_gdf(
        surface_mesh_file,
        wamit_file,
        symmetry='y'  # Symmetric about xz plane
    )

    # Step 5: Create volume mesh for FEA (optional)
    print("\n[Step 5/​5] Creating volume mesh for FEA...")

    volume_mesh_file = output_dir / 'vessel_volume.msh'
    ansys_file = output_dir / 'vessel.cdb'

    if GMSH_AVAILABLE:
        create_tetrahedral_mesh(
            step_file,
            mesh_params['element_size'],
            volume_mesh_file
        )

        # Convert to ANSYS
        convert_mesh_to_ansys_cdb(volume_mesh_file, ansys_file)

    print("\n" + "="*70)
    print("WORKFLOW COMPLETE")
    print("="*70)

    results = {
        'geometry': {
            'step': step_file,
            'iges': iges_file
        },
        'mesh': {
            'surface': surface_mesh_file,
            'volume': volume_mesh_file,
            'wamit': wamit_file,
            'ansys': ansys_file
        },
        'quality': quality
    }

    return results

# Run workflow
vessel_params = {
    'type': 'cylinder',
    'diameter': 20.0,
    'length': 150.0,
    'wall_thickness': 0.05
}

mesh_params = {
    'n_circumferential': 48,
    'n_vertical': 75,
    'element_size': 2.0
}

workflow_results = complete_vessel_geometry_workflow(
    vessel_params,
    mesh_params,
    Path('vessel_geometry_output')
)

print("\nGenerated files:")
for category, files in workflow_results.items():
    if category != 'quality':
        print(f"\n{category.upper()}:")
        for file_type, file_path in files.items():
            print(f"  {file_type}: {file_path}")

Best Practices

1. Parametric Design

from dataclasses import dataclass

@dataclass
class VesselDesignParameters:
    """Parametric vessel design."""
    length: float  # Overall length [m]
    beam: float  # Beam (width) [m]
    depth: float  # Depth [m]
    draft: float  # Design draft [m]
    bow_shape: str = 'straight'  # 'straight', 'raked', 'bulbous'
    stern_shape: str = 'transom'  # 'transom', 'cruiser'
    superstructure: bool = True

    def validate(self) -> bool:
        """Validate design parameters."""
        if self.draft > self.depth:
            raise ValueError("Draft cannot exceed depth")
        if self.beam > self.length:
            raise ValueError("Beam should not exceed length")
        return True

2. Mesh Size Optimization

def calculate_optimal_mesh_size(
    geometry_length_scale: float,
    analysis_type: str,
    target_accuracy: str = 'medium'
) -> float:
    """
    Calculate optimal mesh size based on geometry and analysis type.

    Args:
        geometry_length_scale: Characteristic length [m]
        analysis_type: 'bem', 'fea_linear', 'fea_nonlinear', 'cfd'
        target_accuracy: 'coarse', 'medium', 'fine'

    Returns:
        Recommended element size [m]
    """
    # Base sizing ratios
    sizing_ratios = {
        'bem': {
            'coarse': 0.10,
            'medium': 0.05,
            'fine': 0.025
        },
        'fea_linear': {
            'coarse': 0.20,
            'medium': 0.10,
            'fine': 0.05
        },
        'fea_nonlinear': {
            'coarse': 0.10,
            'medium': 0.05,
            'fine': 0.025
        },
        'cfd': {
            'coarse': 0.15,
            'medium': 0.075,
            'fine': 0.0375
        }
    }

    ratio = sizing_ratios[analysis_type][target_accuracy]
    element_size = geometry_length_scale * ratio

    return element_size

3. Quality Checks

def perform_mesh_quality_checks(
    mesh_file: Path,
    min_quality_threshold: float = 0.3
) -> bool:
    """
    Perform comprehensive mesh quality checks.

    Args:
        mesh_file: Mesh file path
        min_quality_threshold: Minimum acceptable quality

    Returns:
        True if mesh passes quality checks
    """
    quality = analyze_mesh_quality(mesh_file)

    checks = {
        'min_quality': quality['min_quality'] >= min_quality_threshold,
        'poor_elements': quality['poor_elements'] == 0,
        'element_count': quality['element_count'] > 0
    }

    passed = all(checks.values())

    if not passed:
        print("Mesh quality check FAILED:")
        for check_name, result in checks.items():
            status = "PASS" if result else "FAIL"
            print(f"  {check_name}: {status}")

    return passed

Resources

FreeCAD

• Documentation: https://wiki.freecadweb.org/
• Python API: https://wiki.freecadweb.org/Python_scripting_tutorial
• Examples: https://github.com/FreeCAD/FreeCAD/tree/master/src/Mod/Part/TestPartApp

GMSH

• Documentation: https://gmsh.info/doc/texinfo/gmsh.html
• Python API: http://gmsh.info/doc/texinfo/gmsh.html#Gmsh-API
• Tutorials: https://gitlab.onelab.info/gmsh/gmsh/-/tree/master/tutorials

Mesh Generation

• Netgen: https://ngsolve.org/
• TetGen: http://wias-berlin.de/software/tetgen/
• Triangle: https://www.cs.cmu.edu/~quake/triangle.html

Marine Geometry

• DelftShip: Free ship hull design software
• MAXSURF: Professional naval architecture software
• Rhinoceros: Advanced 3D modeling (with Grasshopper for parametric)

---

Use this skill for: Expert CAD geometry creation and mesh generation for marine structures with full export capabilities to analysis software.