214 lines
8.2 KiB
Python
214 lines
8.2 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Test script for Mesh Generation functionality
|
|
|
|
This script tests the mesh generator's ability to:
|
|
1. Prepare mesh generation
|
|
2. Generate mesh with progress monitoring
|
|
3. Get mesh statistics
|
|
4. Handle errors and cancellation
|
|
"""
|
|
|
|
import sys
|
|
import os
|
|
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
|
|
|
from backend.pymechanical.session_manager import ANSYSSessionManager
|
|
from backend.pymechanical.mesh_generator import MeshGenerator
|
|
import logging
|
|
|
|
# Configure logging
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format='%(levelname)s:%(name)s:%(message)s'
|
|
)
|
|
|
|
def progress_callback(percentage, message):
|
|
"""Progress callback for mesh generation"""
|
|
print(f" Progress: {percentage:.1f}% - {message}")
|
|
|
|
def test_mesh_generation_real():
|
|
"""Test mesh generation with real ANSYS session"""
|
|
print("CAE Mesh Generator Mesh Generation Test")
|
|
print("=" * 70)
|
|
print("Testing Mesh Generation...")
|
|
|
|
session_manager = None
|
|
try:
|
|
# Initialize ANSYS session
|
|
session_manager = ANSYSSessionManager(simulation_mode=False)
|
|
session_manager.start_session()
|
|
print("✓ ANSYS session started")
|
|
|
|
# Import geometry
|
|
geometry_file = "resource\\blade.step"
|
|
print(f"1. Importing geometry from {geometry_file}...")
|
|
if session_manager.import_geometry(geometry_file):
|
|
print("✓ Geometry imported successfully")
|
|
else:
|
|
print("✗ Geometry import failed")
|
|
return
|
|
|
|
# Create named selections
|
|
print("\n2. Creating named selections...")
|
|
selection_result = session_manager.create_named_selections()
|
|
if selection_result['success']:
|
|
named_selections = selection_result['selections_created']
|
|
print(f"✓ Named selections created: {named_selections}")
|
|
else:
|
|
print(f"✗ Named selection creation failed")
|
|
named_selections = ['leading_edge', 'trailing_edge', 'blade_root', 'blade_surfaces']
|
|
|
|
# Apply mesh controls
|
|
print("\n3. Applying mesh controls...")
|
|
mesh_result = session_manager.apply_mesh_controls(named_selections)
|
|
if mesh_result['success']:
|
|
print("✓ Mesh controls applied successfully")
|
|
else:
|
|
print("⚠ Some mesh controls failed, continuing with generation...")
|
|
|
|
# Validate mesh generation setup
|
|
print("\n4. Validating mesh generation setup...")
|
|
validation = session_manager.validate_mesh_generation_setup()
|
|
if validation.get('ready_for_generation', False):
|
|
print("✓ Mesh generation setup is ready")
|
|
else:
|
|
print("⚠ Mesh generation setup validation issues:")
|
|
for key, value in validation.items():
|
|
if key != 'success' and key != 'ready_for_generation':
|
|
print(f" - {key}: {value}")
|
|
|
|
# Generate mesh
|
|
print("\n5. Generating mesh...")
|
|
generation_result = session_manager.generate_mesh(progress_callback)
|
|
|
|
if generation_result['success']:
|
|
print("✓ Mesh generation completed successfully")
|
|
print(f" - Elements: {generation_result['element_count']}")
|
|
print(f" - Nodes: {generation_result['node_count']}")
|
|
print(f" - Generation time: {generation_result['generation_time']:.2f} seconds")
|
|
else:
|
|
print(f"✗ Mesh generation failed: {generation_result.get('error_message', 'Unknown error')}")
|
|
|
|
# Get mesh statistics
|
|
print("\n6. Getting mesh statistics...")
|
|
stats = session_manager.get_mesh_statistics()
|
|
if stats.get('success', True):
|
|
print("✓ Mesh statistics retrieved")
|
|
print(f" - Elements: {stats.get('element_count', 'N/A')}")
|
|
print(f" - Nodes: {stats.get('node_count', 'N/A')}")
|
|
print(f" - Has mesh: {stats.get('has_mesh', 'N/A')}")
|
|
else:
|
|
print(f"✗ Failed to get mesh statistics: {stats.get('error', 'Unknown error')}")
|
|
|
|
# Test direct mesh generator functionality
|
|
print("\n7. Testing direct mesh generator functionality...")
|
|
mesh_generator = session_manager.mesh_generator
|
|
if mesh_generator:
|
|
print("✓ Mesh generator available")
|
|
|
|
# Get generation summary
|
|
summary = mesh_generator.get_generation_summary()
|
|
print(f" - Status: {summary.get('status', 'N/A')}")
|
|
print(f" - Progress: {summary.get('progress_percentage', 0):.1f}%")
|
|
|
|
# Test mesh statistics
|
|
direct_stats = mesh_generator.get_mesh_statistics()
|
|
print(f" - Direct stats - Elements: {direct_stats.get('element_count', 'N/A')}")
|
|
else:
|
|
print("✗ Mesh generator not available")
|
|
|
|
print("\n✓ Mesh generation test completed successfully")
|
|
|
|
except Exception as e:
|
|
print(f"\n✗ Mesh generation test failed: {str(e)}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
|
|
finally:
|
|
if session_manager:
|
|
session_manager.close_session()
|
|
|
|
def test_mesh_generation_simulation():
|
|
"""Test mesh generation with simulation mode"""
|
|
print("\n" + "=" * 60)
|
|
print("Testing Mesh Generation (Simulation Mode)...")
|
|
|
|
session_manager = None
|
|
try:
|
|
# Initialize simulation session
|
|
session_manager = ANSYSSessionManager(simulation_mode=True)
|
|
session_manager.start_session()
|
|
print("✓ Simulation session started")
|
|
|
|
# Import geometry (simulated)
|
|
session_manager.import_geometry("resource/blade.step")
|
|
print("✓ Geometry imported (simulated)")
|
|
|
|
# Create named selections (simulated)
|
|
selection_result = session_manager.create_named_selections()
|
|
print(f"✓ Named selections created (simulated): {selection_result['selections_created']}")
|
|
|
|
# Apply mesh controls (simulated)
|
|
mesh_result = session_manager.apply_mesh_controls()
|
|
print("✓ Mesh controls applied (simulated)")
|
|
|
|
# Validate setup (simulated)
|
|
validation = session_manager.validate_mesh_generation_setup()
|
|
print(f"✓ Setup validation (simulated): ready = {validation.get('ready_for_generation', False)}")
|
|
|
|
# Generate mesh (simulated)
|
|
print("\nGenerating mesh (simulated)...")
|
|
generation_result = session_manager.generate_mesh(progress_callback)
|
|
|
|
print("✓ Mesh generation completed (simulated)")
|
|
print(f" - Elements: {generation_result['element_count']}")
|
|
print(f" - Nodes: {generation_result['node_count']}")
|
|
print(f" - Generation time: {generation_result['generation_time']} seconds")
|
|
|
|
# Get statistics (simulated)
|
|
stats = session_manager.get_mesh_statistics()
|
|
print(f"✓ Mesh statistics (simulated): {stats['element_count']} elements")
|
|
|
|
print("✓ Simulation mode test completed")
|
|
|
|
except Exception as e:
|
|
print(f"✗ Simulation test failed: {str(e)}")
|
|
|
|
finally:
|
|
if session_manager:
|
|
session_manager.close_session()
|
|
|
|
def test_mesh_generator_standalone():
|
|
"""Test mesh generator as standalone component"""
|
|
print("\n" + "=" * 60)
|
|
print("Testing Mesh Generator (Standalone)...")
|
|
|
|
try:
|
|
# Test with None session (simulation)
|
|
mesh_generator = MeshGenerator(None)
|
|
print("✓ Mesh generator created")
|
|
|
|
# Test progress callback
|
|
def test_callback(progress, message):
|
|
print(f" Callback: {progress:.1f}% - {message}")
|
|
|
|
mesh_generator.set_progress_callback(test_callback)
|
|
print("✓ Progress callback set")
|
|
|
|
# Test generation summary
|
|
summary = mesh_generator.get_generation_summary()
|
|
print(f"✓ Generation summary: status = {summary.get('status', 'N/A')}")
|
|
|
|
print("✓ Standalone test completed")
|
|
|
|
except Exception as e:
|
|
print(f"✗ Standalone test failed: {str(e)}")
|
|
|
|
if __name__ == "__main__":
|
|
test_mesh_generation_real()
|
|
test_mesh_generation_simulation()
|
|
test_mesh_generator_standalone()
|
|
|
|
print("\n" + "=" * 70)
|
|
print("✓ All mesh generation tests completed!") |