OpenFOAM Case Generator

A professional graphical tool for creating, editing, and generating OpenFOAM case files using an intuitive node-based interface. This application streamlines the process of creating complex OpenFOAM configurations through visual programming.

Overview

The OpenFOAM Case Generator provides a sophisticated node-based editor that enables users to:

• Visually construct OpenFOAM case structures
• Generate individual configuration files or complete case directories
• Validate configuration integrity before generation
• Organize files into appropriate OpenFOAM directory structures

Project Structure

The project is architected into the following modules:

• loader/: Contains functionality for loading and parsing OpenFOAM cases

  • case_loader.py: Handles loading and parsing of OpenFOAM case files
  • node_converter.py: Converts parsed objects to visual nodes
  • parser_patch.py: Customizes parser behavior for improved functionality

• nodes/: Contains all graphical node implementations

  • base_graphical_node.py: Base class for all visual nodes
  • *_graphical.py: Specialized node implementations for various data types:
    • Container nodes (Node_C, Key_C)
    • Parameter nodes (Int_P, Flt_P, Str_P, Vector_P, etc.)
    • Output nodes for file and case folder generation

• view/: Contains the UI components

  • main_window.py: Main application window and orchestration
  • editor_scene.py: Scene for the node editor with grid and management
  • editor_view.py: Interactive view for the node editor with zoom/pan controls
  • edge.py: Connection edges between nodes with routing algorithms
  • socket.py: Connection points on nodes for data flow
  • undo_redo_manager.py: Command pattern implementation for edit history
  • commands.py: Command objects for all editable operations

• config/: Contains configuration-related functionality

  • themes.py: Theme definitions for UI customization

• output/: Default directory for generated OpenFOAM cases

How It Works

Node-Based Editing

1. Node Creation: Drag nodes from the Node Library panel on the left into the editor area
2. Node Connection: Connect nodes by dragging from output sockets to input sockets
3. Node Configuration: Set parameters and properties directly within each node

Node Types

• Container Nodes:

  • Node_C: Represents an OpenFOAM dictionary structure
  • Key_C: Represents key-value pairs in OpenFOAM

• Parameter Nodes:

  • Int_P: Integer parameters
  • Flt_P: Floating-point parameters
  • Str_P: String parameters
  • Vector_P: Vector parameters
  • Tensor_P : tensor parameters
  • Dim_Set_P: Dimensional set parameters
  • Enm_P: Enumeration (selection) parameters
  • List_CP: List container parameters

• Output Nodes:

  • Output: Validates PyVNT objects and optionally generates individual OpenFOAM files
  • Case Folder: Generates complete OpenFOAM case directory structures from connected inputs

New Workflow Architecture

The application uses an optimized workflow to eliminate duplicate file generation:

1. Input Nodes → Output Node (Validation or Generation):

   • Connect your parameter and container nodes to an Output node
   • The Output node validates all connected PyVNT objects
   • Optionally generates individual files if needed for testing

2. Output Node → Case Folder Node (Generation):

   • Connect the validated Output node to a Case Folder node
   • The Case Folder node generates the complete OpenFOAM directory structure
   • No duplicate file generation occurs

3. Flexible Input Options:

   • Case Folder nodes accept 1-4 input connections
   • You can connect multiple Output nodes or use partial configurations
   • Missing inputs are gracefully handled during generation

Generation Process

When you click the "Generate" button in an Output node or "Generate File" in a Case Folder node:

1. Validation Phase:

   • The system checks all input connections
   • Validates the node tree structure
   • Ensures all nodes have proper names and configurations

2. Object Construction:

   • For Output nodes: Traverses connected node graph and validates PyVNT objects
   • For Case Folder nodes: Retrieves validated objects from connected Output nodes
   • Objects are organized into a hierarchical structure matching OpenFOAM format

3. Output Generation:

   • Output Node (Standalone Mode):

     • Gets the output path from the text field
     • Writes the configuration to the specified location

   • Output Node (Validation Mode):

     • Validates connected PyVNT objects without file generation
     • Displays validation status and prepares objects for Case Folder consumption

   • Case Folder Node:

     • Creates the OpenFOAM directory structure (0/, constant/, system/)
     • Intelligently categorizes files into appropriate subfolders
     • Generates each file with proper formatting

4. Status Update:

   • Success/failure status is displayed
   • Generated file count and locations are reported

Getting Started

1. Ensure you have Python 3.10+ installed
2. Install required dependencies:

   pip install -r requirements.txt
   

3. Run the application:

   python main.py
   

Dependencies

• PyQt6: Provides the graphical user interface framework
• PyVNT: Powers the OpenFOAM file parsing and generation (included in the project)

Working With the Application

1. Create a New Case: Use File > New Case to start fresh
2. Build Your Structure: Add nodes and connect them to define your case structure
3. Configure Parameters: Set values and properties within each node
4. Generate Files: Use output nodes to generate files or complete case structures
5. Load Existing Cases: Import and visualize existing OpenFOAM cases

Navigation and Editing Controls

Canvas Navigation

• Zoom: Use the mouse wheel to zoom in and out of the editor canvas
• Pan: Click and drag with the middle mouse button or hold Space and drag
• Reset View: Press Space to reset the view to default zoom and position
• Fit Content: Use View > Fit All to automatically frame all nodes in the view

Node Manipulation

• Select: Click on a node to select it
• Move: Click and drag a node to reposition it
• Delete: Right-click a node to delete it, or select and press Delete

Connection Management

• Create Connection: Click and drag from an output socket to an input socket
• Knife Tool: Press K or select Tools > Knife Tool to activate the connection cutting tool
  • While active, drag across connections to cut them
  • The cursor changes to indicate knife mode is active
  • Press K again or Escape to exit knife mode

Editing History

• Undo: Ctrl+Z or Edit > Undo to reverse the last action
• Redo: Ctrl+Y or Edit > Redo to reapply undone actions
• Limitations:
  • Node property changes within dialogs can't be undone
  • The undo stack has a finite depth (last 20 operations)
  • Complex operations count as a single undo step

Case Loading and Importing

The application supports loading existing OpenFOAM cases:

1. Loading Individual Files:

   • Use File > Load File to import a single OpenFOAM configuration file
   • The file will be parsed and converted to a node structure

2. Loading Case Directories:

   • Use File > Load Case Directory to import an entire OpenFOAM case
   • The system will automatically identify and parse relevant files
   • Files are organized based on the standard OpenFOAM directory structure

3. Loading Process:

   • Progress dialog shows parsing and node creation status
   • After loading, the scene will automatically fit to show all imported nodes
   • Connections are automatically established based on file references

4. Loading Limitations:

   • Complex OpenFOAM syntax may require manual adjustments
   • Very large cases may experience performance degradation
   • Custom functions and macros may not be fully supported

Development

The application uses a model-view architecture with:

• PyVNT objects as the underlying data model
• Custom graphical nodes as the view and controller
• Signal-slot communication for event handling