ansys-simulation - SKILL.md Agent Skill

name: ansys-simulation description: "Automate ANSYS Fluent CFD simulations via Python scripting and journal files" category: integrations domain: fluids complexity: advanced dependencies: []

ANSYS Simulation Integration

Comprehensive guide for automating ANSYS Fluent CFD (Computational Fluid Dynamics) simulations using Python scripting, journal files, and the PyAnsys ecosystem.

Overview

ANSYS Fluent is a leading commercial CFD solver used for simulating fluid flow, heat transfer, and related phenomena in complex geometries. This skill covers automation approaches for:

ANSYS Workbench: Unified platform for CAD integration, meshing, and workflow management
ANSYS Fluent: Advanced CFD solver with extensive physics models
PyAnsys: Python API ecosystem for programmatic control
Journal Files: Text-based scripting for batch operations

ANSYS Workbench and Fluent Architecture

ANSYS Workbench

Project-based workflow environment
Integrates multiple ANSYS tools (Fluent, CFX, Mechanical, etc.)
Supports parametric studies and design optimization
Provides geometry and meshing tools (DesignModeler, SpaceClaim, Meshing)

ANSYS Fluent

Finite volume-based CFD solver
Extensive turbulence models (k-epsilon, k-omega SST, LES, DES)
Multiphase flow capabilities
Heat transfer and combustion modeling
User-defined functions (UDFs) in C
Text User Interface (TUI) for scripting

Licensing Requirements

Commercial Licensing

ANSYS products require commercial licenses managed through the ANSYS License Manager:

Fluent License Types:
- HPC licenses for parallel computing
- Solver licenses (increment-based)
- PrepPost licenses for pre/post-processing

License Server Setup:

# Set license server environment variable
export ANSYSLMD_LICENSE_FILE=1055@license-server.company.com

# Or in Windows
set ANSYSLMD_LICENSE_FILE=1055@license-server.company.com

License Checkout: Licenses are checked out when starting Fluent and returned on exit
HPC Licensing: Additional licenses required for parallel runs (typically cores/4)

Academic Licensing

Student/teaching licenses available with limitations
Typically limited mesh size and solver capabilities
Separate license file required

Important Notes

Always verify license availability before batch runs
Consider license usage in automated workflows
Use -t flag to specify number of processors for HPC licensing

PyAnsys - Python API Introduction

PyAnsys provides a Pythonic interface to ANSYS products, enabling:

Remote or local session management
Programmatic control of simulation setup
Data extraction and post-processing
Integration with Python data science stack

Installation

# Install PyFluent (for Fluent automation)
pip install ansys-fluent-core

# Install other PyAnsys packages as needed
pip install ansys-mapdl-core      # For Mechanical
pip install ansys-dpf-core        # For post-processing
pip install ansys-geometry        # For geometry operations

Basic PyFluent Usage

from ansys.fluent.core import launch_fluent

# Launch Fluent session
session = launch_fluent(precision='double', processor_count=4, mode='solver')

# Access TUI commands
session.tui.file.read_case('case_file.cas')

# Execute commands
session.tui.solve.iterate(100)

# Clean exit
session.exit()

Key PyAnsys Components

ansys-fluent-core: Main Fluent automation package
ansys-fluent-visualization: Post-processing and visualization
ansys-geometry: CAD operations and geometry manipulation
ansys-meshing: Automated meshing workflows

Journal File Scripting

Journal files are text-based scripts containing TUI commands executed sequentially by Fluent.

Journal File Format

; Comments start with semicolon
; Commands follow TUI menu structure

/file/read-case case_file.cas

/solve/initialize/initialize-flow
/solve/iterate 1000

/file/write-data result.dat

/exit yes

Running Journal Files

# Run Fluent in batch mode with journal file
fluent 3ddp -g -i journal.jou > fluent.log

# Flags:
# 3ddp: 3D double precision
# -g: Run without GUI
# -i: Input journal file
# -t4: Use 4 processors

Journal File Best Practices

Use absolute paths for file I/O
Include error checking where possible
Add comments for maintainability
Test interactively before batch execution
Redirect output to log files for debugging

Common Workflow

1. Geometry Import

Via PyFluent:

from ansys.fluent.core import launch_fluent

solver = launch_fluent(precision='double', processor_count=4)

# Import geometry
solver.tui.file.import_.cad_geometry(
    'geometry.scdoc',
    'yes'  # Confirm import
)

Via Journal File:

/file/import/cad-geometry geometry.step yes

2. Meshing Setup

Mesh Generation Strategy:

Surface mesh extraction from CAD
Volume mesh generation (tetrahedral, hex, poly)
Boundary layer refinement for wall-bounded flows
Mesh quality checks

PyFluent Meshing:

from ansys.fluent.core import launch_fluent

meshing = launch_fluent(precision='double', processor_count=4, mode='meshing')

# Import geometry
meshing.workflow.InitializeWorkflow(WorkflowType='Watertight Geometry')

# Set meshing parameters
meshing.meshing.GlobalSettings.set_state({
    'MaxSize': 0.1,
    'MinSize': 0.001,
    'GrowthRate': 1.2
})

# Generate mesh
meshing.meshing.GenerateMesh()

# Switch to solver
solver = meshing.switch_to_solver()

Journal File Meshing:

/mesh/scale 0.001 0.001 0.001
/mesh/check
/mesh/repair-improve/repair

3. Physics Setup

Turbulence Models:

k-epsilon: General purpose, wall functions
k-omega SST: Better for adverse pressure gradients, boundary layers
LES/DES: Large eddy simulation for transient, high-fidelity

Material Properties:

Fluid properties (density, viscosity, thermal conductivity)
Solid properties for conjugate heat transfer

PyFluent Physics Setup:

# Enable energy equation
solver.tui.define.models.energy('yes')

# Set turbulence model (k-omega SST)
solver.tui.define.models.viscous.kw_sst('yes')

# Define material properties
solver.tui.define.materials.change_create(
    'water-liquid',
    'water',
    'yes',
    'constant',
    998.2,  # Density
    'yes',
    'constant',
    0.001003  # Viscosity
)

# Assign material to cell zone
solver.tui.define.boundary_conditions.fluid(
    'fluid-zone',
    'yes',
    'water',
    'no',
    'no',
    'no',
    'no',
    0,
    'no',
    0,
    'no',
    0,
    'no',
    'no'
)

Journal File Physics:

/define/models/energy yes no no no no
/define/models/viscous kw-sst yes
/define/materials/change-create air air yes constant 1.225 yes constant 1.7894e-05

4. Boundary Conditions

Common BC Types:

Velocity inlet
Pressure outlet
Wall (stationary, moving, rotating)
Symmetry
Periodic

PyFluent BC Setup:

# Velocity inlet
solver.tui.define.boundary_conditions.velocity_inlet(
    'inlet',
    'yes',
    'no',
    'yes',
    'yes',
    'no',
    10,  # Velocity magnitude (m/s)
    'no',
    0,
    'no',
    0,
    'no',
    300,  # Temperature
    'no'
)

# Pressure outlet
solver.tui.define.boundary_conditions.pressure_outlet(
    'outlet',
    'yes',
    'no',
    0,  # Gauge pressure
    'no',
    300,
    'no',
    'yes'
)

# Wall with no-slip
solver.tui.define.boundary_conditions.wall(
    'wall',
    'yes',
    'no',
    'no',
    0,
    'no',
    0,
    'no',
    'yes',
    'no',
    0
)

5. Solver Settings

Solution Methods:

Pressure-velocity coupling (SIMPLE, SIMPLEC, PISO, Coupled)
Discretization schemes (first-order, second-order upwind, QUICK)
Gradient evaluation (least squares, Green-Gauss)

PyFluent Solver Configuration:

# Set pressure-velocity coupling
solver.tui.solve.set.p_v_coupling(24)  # 24 = Coupled

# Set discretization schemes
solver.tui.solve.set.discretization_scheme.pressure(12)  # Second order
solver.tui.solve.set.discretization_scheme.mom(1)  # Second order upwind
solver.tui.solve.set.discretization_scheme.k(1)
solver.tui.solve.set.discretization_scheme.omega(1)

# Set under-relaxation factors
solver.tui.solve.set.under_relaxation.pressure(0.3)
solver.tui.solve.set.under_relaxation.mom(0.7)

# Initialize flow field
solver.tui.solve.initialize.initialize_flow()

# Run iterations
solver.tui.solve.iterate(1000)

Convergence Criteria:

# Set residual convergence criteria
solver.tui.solve.monitors.residual.convergence_criteria(
    '1e-6',  # continuity
    '1e-6',  # x-velocity
    '1e-6',  # y-velocity
    '1e-6',  # z-velocity
    '1e-6',  # energy
    '1e-6',  # k
    '1e-6'   # omega
)

6. Post-Processing

Data Extraction:

# Create surface for reporting
solver.tui.surface.iso_surface(
    'pressure',
    'iso-surface-1',
    'fluid-zone',
    '()',
    101325
)

# Export data
solver.tui.file.export.ascii(
    'surface-data.csv',
    'iso-surface-1',
    '()',
    'yes',
    'pressure',
    'velocity-magnitude',
    '()'
)

# Calculate force on wall
solver.tui.report.forces.wall_forces(
    'yes',
    'wall-zone',
    '()',
    'yes',
    'no',
    'yes'
)

Visualization:

# Generate contour plot (requires GUI mode or visualization package)
solver.tui.display.set.contours.filled_contours('yes')
solver.tui.display.contour(
    'pressure',
    'pressure',
    0,
    0,
    'surface-1',
    '()'
)

# Save image
solver.tui.display.save_picture('pressure_contour.png')

Batch Mode Execution

Linux/Unix Batch Execution

#!/bin/bash
# batch_fluent.sh

# Set license server
export ANSYSLMD_LICENSE_FILE=1055@license-server.com

# Set number of processors
NPROCS=8

# Run Fluent in batch mode
fluent 3ddp -g -t${NPROCS} -i simulation.jou > fluent_${NPROCS}cores.log 2>&1

# Check exit status
if [ $? -eq 0 ]; then
    echo "Simulation completed successfully"
else
    echo "Simulation failed - check log file"
    exit 1
fi

Windows Batch Execution

@echo off
REM batch_fluent.bat

set ANSYSLMD_LICENSE_FILE=1055@license-server.com
set NPROCS=8

"C:\Program Files\ANSYS Inc\v241\fluent\ntbin\win64\fluent.exe" 3ddp -g -t%NPROCS% -i simulation.jou > fluent.log 2>&1

if %ERRORLEVEL% EQU 0 (
    echo Simulation completed successfully
) else (
    echo Simulation failed - check log file
    exit /b 1
)

Python-Based Batch Execution

import subprocess
import os
from pathlib import Path

def run_fluent_batch(journal_file, num_procs=4, log_file='fluent.log'):
    """
    Run Fluent in batch mode with journal file.

    Args:
        journal_file: Path to journal file
        num_procs: Number of processors
        log_file: Output log file name

    Returns:
        bool: True if successful, False otherwise
    """
    # Set license server
    os.environ['ANSYSLMD_LICENSE_FILE'] = '1055@license-server.com'

    # Build command
    cmd = [
        'fluent',
        '3ddp',           # 3D double precision
        '-g',             # No GUI
        f'-t{num_procs}', # Number of processors
        '-i', journal_file
    ]

    # Run simulation
    with open(log_file, 'w') as log:
        result = subprocess.run(
            cmd,
            stdout=log,
            stderr=subprocess.STDOUT,
            text=True
        )

    return result.returncode == 0

# Example usage
if __name__ == '__main__':
    success = run_fluent_batch(
        journal_file='simulation.jou',
        num_procs=8,
        log_file='fluent_run.log'
    )

    if success:
        print("Simulation completed successfully")
    else:
        print("Simulation failed - check log file")

Parametric Studies

import numpy as np
from ansys.fluent.core import launch_fluent

def parametric_study(velocities, case_file):
    """
    Run parametric study varying inlet velocity.

    Args:
        velocities: List of inlet velocities to test
        case_file: Base case file
    """
    results = {}

    for velocity in velocities:
        print(f"Running simulation with velocity = {velocity} m/s")

        # Launch Fluent
        solver = launch_fluent(precision='double', processor_count=4)

        # Read base case
        solver.tui.file.read_case(case_file)

        # Modify inlet velocity
        solver.tui.define.boundary_conditions.velocity_inlet(
            'inlet',
            'yes', 'no', 'yes', 'yes', 'no',
            velocity,
            'no', 0, 'no', 0, 'no', 300, 'no'
        )

        # Initialize and solve
        solver.tui.solve.initialize.initialize_flow()
        solver.tui.solve.iterate(500)

        # Extract results
        # (Add result extraction here)

        # Save case and data
        output_file = f'result_v{velocity}.cas.h5'
        solver.tui.file.write_case_data(output_file)

        solver.exit()

        results[velocity] = output_file

    return results

# Run parametric study
velocities = np.linspace(5, 25, 5)  # 5 to 25 m/s
results = parametric_study(velocities, 'base_case.cas.h5')

Best Practices

License Management: Always check license availability before long batch runs
Mesh Quality: Verify mesh quality before solving (skewness, aspect ratio)
Convergence Monitoring: Set appropriate convergence criteria and monitor residuals
File Management: Use clear naming conventions for parametric studies
Error Handling: Implement robust error checking in automation scripts
Documentation: Comment journal files and Python scripts thoroughly
Version Control: Track journal files and scripts in version control
Testing: Test automation workflows on small cases before production runs
Resource Management: Monitor memory and disk usage for large simulations
Reproducibility: Document all settings for reproducible results

Troubleshooting

Common Issues

License checkout failures: Check license server connectivity and availability
Mesh issues: Review mesh quality metrics and refine problematic regions
Convergence problems: Adjust under-relaxation factors, check BC consistency
Memory errors: Reduce mesh size or use more nodes in parallel
File I/O errors: Verify file paths and permissions

Debugging Tips

Run interactively first to validate workflow
Check transcript files for TUI command syntax
Use -print flag in journal files for debugging
Monitor residual plots for convergence behavior
Review warning and error messages in log files

Additional Resources

ANSYS Documentation: Help system within ANSYS products
PyAnsys Documentation: https://docs.pyansys.com
ANSYS Learning Hub: Online training and tutorials
ANSYS Community: User forums and knowledge base
Fluent User's Guide: Comprehensive theory and usage manual
Fluent TUI Reference: Complete TUI command listing