name: bemrosetta description: BEMRosetta hydrodynamic coefficient converter - AQWA to OrcaFlex workflow with QTF and mesh support version: 1.0.0 updated: 2026-01-27 category: offshore-engineering triggers:

bemrosetta
hydrodynamic conversion
AQWA to OrcaFlex
coefficient converter
QTF conversion
mesh format conversion
GDF to STL
panel mesh
Kramers-Kronig
causality check

BEMRosetta Integration Skill

Version

Skill Version: 1.0.0
Module Version: 1.0.0
Python: 3.11+
Dependencies: numpy, scipy, click, pydantic, loguru

Changelog

1.0.0 (2026-01-27)

Initial release
AQWA parser for .LIS files
QTF parser for second-order forces
OrcaFlex converter (YAML, CSV)
Mesh handlers (GDF, DAT, STL)
Coefficient and causality validators
Click-based CLI

When to Use

Use this skill when you need to:

Convert AQWA outputs to OrcaFlex format
- Parse AQWA .LIS diffraction analysis files
- Export to OrcaFlex-compatible YAML and CSV
Handle QTF (second-order forces) data
- Parse QTF files for sum/difference frequency forces
- Export QTF to OrcaFlex format
Convert mesh formats
- Convert between GDF (WAMIT), DAT (AQWA/NEMOH), STL formats
- Validate mesh quality
Validate hydrodynamic coefficients
- Check matrix symmetry and positive definiteness
- Verify Kramers-Kronig causality relations

Agent Capabilities

The BEMRosetta skill enables agents to:

Parsing

Parse AQWA .LIS files extracting RAOs, added mass, damping
Parse QTF files for second-order wave forces
Extract solver metadata (version, water depth, frequencies, headings)

Conversion

Convert to OrcaFlex vessel type YAML
Export coefficient CSV files
Export QTF data in OrcaFlex format

Mesh Processing

Read/write WAMIT GDF format
Read/write AQWA/NEMOH DAT format
Read/write STL format (ASCII and binary)
Calculate mesh quality metrics

Validation

Coefficient symmetry checks
Positive definiteness verification
Physical limits validation
Kramers-Kronig causality checking

Prerequisites

# Module is included in digitalmodel package
uv pip install -e .

# Verify installation
bemrosetta status

CLI Commands

# Convert AQWA to OrcaFlex
bemrosetta convert analysis.LIS -o ./output

# Convert with QTF data
bemrosetta convert analysis.LIS --qtf analysis.QTF -o ./output

# Display file information
bemrosetta info analysis.LIS

# Validate coefficients
bemrosetta validate analysis.LIS --strict --causality

# Convert mesh formats
bemrosetta convert-mesh input.gdf -o output.stl
bemrosetta convert-mesh input.dat -o output.gdf

# Validate mesh quality
bemrosetta validate-mesh hull.gdf --check-normals

# Show module status
bemrosetta status

Python API

Basic Workflow

from digitalmodel.bemrosetta import (
    AQWAParser,
    OrcaFlexConverter,
    validate_coefficients,
)

# Parse AQWA results
parser = AQWAParser()
results = parser.parse("analysis.LIS")

# Access metadata
print(f"Vessel: {parser.metadata.vessel_name}")
print(f"Water depth: {parser.metadata.water_depth}")
print(f"Frequencies: {parser.metadata.frequency_count}")

# Validate coefficients
report = validate_coefficients(results, strict=True)
if not report.is_valid:
    print(f"Errors: {report.errors}")

# Convert to OrcaFlex format
converter = OrcaFlexConverter(output_dir="./output")
converter.convert(results)

QTF Handling

from digitalmodel.bemrosetta import QTFParser, OrcaFlexConverter

# Parse QTF file
qtf_parser = QTFParser()
qtf_data = qtf_parser.parse("analysis.QTF")

print(f"QTF type: {qtf_data.qtf_type}")
print(f"Frequencies: {qtf_data.n_frequencies_1} x {qtf_data.n_frequencies_2}")

# Include QTF in conversion
converter = OrcaFlexConverter(output_dir="./output")
converter.set_qtf_data(qtf_data)
converter.convert(results)

Mesh Conversion

from digitalmodel.bemrosetta import (
    GDFHandler, DATHandler, STLHandler, convert_mesh
)

# Read GDF mesh
handler = GDFHandler()
mesh = handler.read("hull.gdf")

# Check quality
report = handler.validate_mesh(mesh)
print(f"Panels: {report.n_panels}")
print(f"Quality score: {report.quality_score}/100")

# Convert to STL
convert_mesh("hull.gdf", "hull.stl")

Causality Validation

from digitalmodel.bemrosetta import (
    CoefficientValidator,
    CausalityChecker,
)

# Coefficient validation
validator = CoefficientValidator(
    check_symmetry=True,
    check_positive_definite=True,
    tolerance=0.01,
)
report = validator.validate(results)

# Kramers-Kronig causality check
checker = CausalityChecker(tolerance=0.1)
kk_report = checker.validate(results)
for key, error in kk_report.info.items():
    if error and error > 0.1:
        print(f"Warning: {key} KK error = {error:.2%}")

Key Classes

Class	Purpose
`AQWAParser`	Parse AQWA .LIS files
`QTFParser`	Parse QTF second-order force files
`OrcaFlexConverter`	Convert to OrcaFlex format
`GDFHandler`	WAMIT GDF mesh format
`DATHandler`	AQWA/NEMOH DAT mesh format
`STLHandler`	STL mesh format
`CoefficientValidator`	Validate coefficient matrices
`CausalityChecker`	Kramers-Kronig validation

Data Models

Model	Description
`BEMSolverMetadata`	Solver name, version, water depth, vessel info
`QTFData`	QTF coefficients with frequency pairs
`PanelMesh`	Vertices, panels, normals, areas
`MeshQualityReport`	Panel statistics and quality score
`ConversionResult`	Conversion operation result

Best Practices

Always validate before conversion

report = validate_coefficients(results, strict=True)
if not report.is_valid:
    raise ValueError(f"Invalid coefficients: {report.errors}")

Check mesh quality before use

report = handler.validate_mesh(mesh)
if report.quality_score < 70:
    print("Warning: Low mesh quality")

Use native parsers for reliability
- Native Python parsers don't require BEMRosetta executable
- BEMRosetta executable provides extended features when available

Handle missing data gracefully

warnings = converter.validate_input(results)
for w in warnings:
    logger.warning(w)

Integration with Other Modules

With diffraction module

from digitalmodel.diffraction import OrcaFlexExporter
from digitalmodel.bemrosetta import AQWAParser

# BEMRosetta uses diffraction module schemas
parser = AQWAParser()
results = parser.parse("analysis.LIS")  # Returns DiffractionResults

# Can use existing OrcaFlexExporter
exporter = OrcaFlexExporter(results, output_dir)
exporter.export_all()

With hydrodynamics module

from digitalmodel.hydrodynamics import CoefficientDatabase

# Store parsed coefficients in database
db = CoefficientDatabase()
db.store(results.added_mass, results.damping)

Error Handling

from digitalmodel.bemrosetta import (
    BEMRosettaError,
    ParserError,
    ConverterError,
    MeshError,
)

try:
    results = parser.parse("analysis.LIS")
except ParserError as e:
    print(f"Parse error: {e}")
    print(f"File: {e.context.get('file_path')}")
except BEMRosettaError as e:
    print(f"BEMRosetta error: {e}")

Related Skills

aqwa-analysis - AQWA .LIS processing and RAO extraction
orcawave-analysis - OrcaWave diffraction/radiation analysis
orcawave-to-orcaflex - OrcaWave to OrcaFlex conversion
orcaflex-rao-import - Multi-format RAO import
hydrodynamics - 6x6 matrices and wave spectra
diffraction-analysis - Master skill for diffraction workflows

bemrosetta

Installation

Details

Usage

Skill Instructions