193 lines
7.4 KiB
Python
193 lines
7.4 KiB
Python
"""
|
|
Test mesh quality checking system
|
|
"""
|
|
import pytest
|
|
import time
|
|
from backend.pymechanical.session_manager import ANSYSSessionManager
|
|
from backend.pymechanical.mesh_quality_checker import MeshQualityChecker, QualityMetrics, QualityResult
|
|
|
|
|
|
def test_mesh_quality_checker_simulation():
|
|
"""Test mesh quality checker in simulation mode"""
|
|
# Create session manager in simulation mode
|
|
session_manager = ANSYSSessionManager(simulation_mode=True)
|
|
|
|
# Start session
|
|
assert session_manager.start_session()
|
|
|
|
try:
|
|
# Initialize quality checker
|
|
quality_checker = MeshQualityChecker(session_manager.session)
|
|
|
|
# Perform quality check
|
|
result = quality_checker.check_mesh_quality()
|
|
|
|
# Verify result structure
|
|
assert isinstance(result, QualityResult)
|
|
assert result.check_time is not None
|
|
assert isinstance(result.metrics, QualityMetrics)
|
|
assert isinstance(result.recommendations, list)
|
|
assert isinstance(result.warnings, list)
|
|
assert isinstance(result.critical_issues, list)
|
|
|
|
# Verify metrics are reasonable
|
|
assert 0.0 <= result.metrics.min_element_quality <= 1.0
|
|
assert result.metrics.max_aspect_ratio >= 1.0
|
|
assert 0.0 <= result.metrics.max_skewness <= 1.0
|
|
assert 0.0 <= result.metrics.min_orthogonal_quality <= 1.0
|
|
assert result.metrics.total_elements > 0
|
|
assert result.metrics.failed_elements_count >= 0
|
|
|
|
# Check quality summary
|
|
summary = quality_checker.get_quality_summary(result)
|
|
assert 'overall_status' in summary
|
|
assert 'metrics' in summary
|
|
assert 'thresholds' in summary
|
|
assert 'quality_score' in summary
|
|
assert 0.0 <= summary['quality_score'] <= 100.0
|
|
|
|
print(f"✓ Quality check result: {summary['overall_status']}")
|
|
print(f"✓ Quality score: {summary['quality_score']:.1f}")
|
|
print(f"✓ Element quality: {result.metrics.min_element_quality:.3f}")
|
|
print(f"✓ Failed elements: {result.metrics.failed_elements_percentage:.1f}%")
|
|
|
|
finally:
|
|
session_manager.close_session()
|
|
|
|
|
|
def test_session_manager_quality_check():
|
|
"""Test mesh quality check through session manager"""
|
|
# Create session manager in simulation mode
|
|
session_manager = ANSYSSessionManager(simulation_mode=True)
|
|
|
|
# Start session
|
|
assert session_manager.start_session()
|
|
|
|
try:
|
|
# Perform quality check through session manager
|
|
result = session_manager.check_mesh_quality()
|
|
|
|
# Verify result structure
|
|
assert result['success'] is True
|
|
assert 'overall_status' in result
|
|
assert 'quality_score' in result
|
|
assert 'metrics' in result
|
|
assert 'thresholds' in result
|
|
assert 'recommendations' in result
|
|
assert 'warnings' in result
|
|
|
|
# Verify metrics structure
|
|
metrics = result['metrics']
|
|
assert 'min_element_quality' in metrics
|
|
assert 'max_aspect_ratio' in metrics
|
|
assert 'max_skewness' in metrics
|
|
assert 'min_orthogonal_quality' in metrics
|
|
assert 'total_elements' in metrics
|
|
assert 'failed_elements_count' in metrics
|
|
assert 'failed_elements_percentage' in metrics
|
|
|
|
# Verify thresholds
|
|
thresholds = result['thresholds']
|
|
assert 'min_element_quality' in thresholds
|
|
assert 'max_aspect_ratio' in thresholds
|
|
assert 'max_skewness' in thresholds
|
|
assert 'min_orthogonal_quality' in thresholds
|
|
|
|
# Print quality report
|
|
print(f"\n=== Mesh Quality Report ===")
|
|
print(f"Overall Status: {result['overall_status']}")
|
|
print(f"Quality Score: {result['quality_score']:.1f}/100")
|
|
print(f"Element Quality: {metrics['min_element_quality']:.3f} (threshold: {thresholds['min_element_quality']})")
|
|
print(f"Aspect Ratio: {metrics['max_aspect_ratio']:.1f} (threshold: {thresholds['max_aspect_ratio']})")
|
|
print(f"Skewness: {metrics['max_skewness']:.3f} (threshold: {thresholds['max_skewness']})")
|
|
print(f"Orthogonal Quality: {metrics['min_orthogonal_quality']:.3f} (threshold: {thresholds['min_orthogonal_quality']})")
|
|
print(f"Total Elements: {metrics['total_elements']}")
|
|
print(f"Failed Elements: {metrics['failed_elements_count']} ({metrics['failed_elements_percentage']:.1f}%)")
|
|
|
|
if result['recommendations']:
|
|
print(f"\nRecommendations:")
|
|
for rec in result['recommendations']:
|
|
print(f" - {rec}")
|
|
|
|
if result['warnings']:
|
|
print(f"\nWarnings:")
|
|
for warning in result['warnings']:
|
|
print(f" - {warning}")
|
|
|
|
if result.get('critical_issues'):
|
|
print(f"\nCritical Issues:")
|
|
for issue in result['critical_issues']:
|
|
print(f" - {issue}")
|
|
|
|
print("=== End Quality Report ===\n")
|
|
|
|
finally:
|
|
session_manager.close_session()
|
|
|
|
|
|
def test_quality_metrics_calculations():
|
|
"""Test quality metrics calculations and scoring"""
|
|
# Create quality checker in simulation mode
|
|
quality_checker = MeshQualityChecker(None) # No session needed for calculation tests
|
|
|
|
# Test case 1: Good quality metrics
|
|
good_metrics = QualityMetrics(
|
|
min_element_quality=0.35,
|
|
max_aspect_ratio=15.0,
|
|
max_skewness=0.6,
|
|
min_orthogonal_quality=0.25,
|
|
average_element_quality=0.7,
|
|
failed_elements_count=10,
|
|
total_elements=5000
|
|
)
|
|
|
|
good_result = QualityResult()
|
|
good_result.metrics = good_metrics
|
|
quality_checker._evaluate_quality_metrics(good_metrics, good_result)
|
|
|
|
assert good_result.passed is True
|
|
assert len(good_result.critical_issues) == 0
|
|
|
|
good_score = quality_checker._calculate_quality_score(good_metrics)
|
|
assert good_score >= 60.0 # Should be acceptable score (meets all thresholds)
|
|
|
|
# Test case 2: Poor quality metrics
|
|
poor_metrics = QualityMetrics(
|
|
min_element_quality=0.15, # Below threshold (0.2)
|
|
max_aspect_ratio=25.0, # Above threshold (20)
|
|
max_skewness=0.9, # Above threshold (0.8)
|
|
min_orthogonal_quality=0.1, # Below threshold (0.15)
|
|
average_element_quality=0.3,
|
|
failed_elements_count=300, # 6% failed elements
|
|
total_elements=5000
|
|
)
|
|
|
|
poor_result = QualityResult()
|
|
poor_result.metrics = poor_metrics
|
|
quality_checker._evaluate_quality_metrics(poor_metrics, poor_result)
|
|
|
|
assert poor_result.passed is False
|
|
assert len(poor_result.critical_issues) >= 4 # Should have multiple issues
|
|
|
|
poor_score = quality_checker._calculate_quality_score(poor_metrics)
|
|
assert poor_score <= 50.0 # Should be a poor score
|
|
|
|
print(f"✓ Good quality score: {good_score:.1f}")
|
|
print(f"✓ Poor quality score: {poor_score:.1f}")
|
|
print(f"✓ Good quality issues: {len(good_result.critical_issues)}")
|
|
print(f"✓ Poor quality issues: {len(poor_result.critical_issues)}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
print("Testing Mesh Quality Checking System...")
|
|
|
|
test_mesh_quality_checker_simulation()
|
|
print("✓ Quality checker simulation test passed")
|
|
|
|
test_session_manager_quality_check()
|
|
print("✓ Session manager quality check test passed")
|
|
|
|
test_quality_metrics_calculations()
|
|
print("✓ Quality metrics calculations test passed")
|
|
|
|
print("\n🎉 All mesh quality tests passed!") |