Satellite Fatigue Analysis – Certification-Grade Fracture Mechanics

Advanced probabilistic fatigue and crack growth simulation for aerospace aluminum structures under orbital loading conditions.

This tool performs damage-tolerant fatigue life prediction for satellite structural components (primarily 7075-T73 aluminum) using modern fracture mechanics methods, Monte Carlo uncertainty quantification, and realistic mission load histories.

Features

• Walker mean stress correction + Paris law crack growth
• Wheeler retardation model for load sequence / overload effects
• Findley critical plane approach for multiaxial fatigue
• Neuber’s rule (vectorized) for elastic-plastic stress concentration correction
• Newman crack closure function for effective ΔK calculation
• Rainflow cycle counting (via fatpack)
• Monte Carlo simulation with material, geometry, and load scatter
• Realistic orbital load generation:
  • Sinusoidal thermal/orbital cycling
  • Launch & reentry random vibration
  • Gaussian pulse events (e.g. thruster firings)
  • Eclipse thermal stress amplification
• Temperature & environmental knockdown factors
• B-basis / A-basis life allowables + failure probability (P_f)
• Comprehensive visualization (crack growth, stress history, rainflow, life distribution, sensitivity)
• Certification-style text report + JSON export

Requirements

• Python 3.8+
• Core dependencies:

  pip install numpy scipy matplotlib fatpack

Installation

git clone https://github.com/yourusername/satellite-fatigue-analysis.git
cd satellite-fatigue-analysis
pip install -r requirements.txt    # if you create one

(Recommended: use a virtual environment)

Quick Start

from fatigue_analyzer import FatigueAnalyzer, MaterialProperties, \
    GeometryProperties, AnalysisSettings, LoadProfile
from results_visualizer import ResultsVisualizer

# Use defaults or customize
material   = MaterialProperties()
geometry   = GeometryProperties()
settings   = AnalysisSettings(num_realizations=500)   # smaller for testing
load_profile = LoadProfile()

analyzer = FatigueAnalyzer(material, geometry, settings, load_profile)

# Run Monte Carlo
results = analyzer.run_monte_carlo(num_points=500_000, verbose_freq=50)

# Visualize & report (last realization)
if results['last_history'] is not None:
    visualizer = ResultsVisualizer()
    visualizer.plot_crack_growth_history(results['last_history'])
    visualizer.plot_life_distribution(results['orbits']['finite'])
    visualizer.generate_report(results, material, geometry, settings)

Main Output Files (example)

• fatigue_report.txt – human-readable certification-style summary
• results.json – all numerical results
• Plots in /mnt/user-data/outputs/ (or customize path):
  • crack_growth.png
  • stress_history.png
  • rainflow_analysis.png
  • life_distribution.png
  • sensitivity_analysis.png (if enabled)

Key Design Choices

Aspect	Choice	Rationale
Mean stress correction	Walker (γ = 0.5)	Better behavior in compression than SWT
Crack closure	Newman polynomial	Widely accepted in aerospace
Retardation	Wheeler (φ = 2.5)	Simple yet captures sequence effects
Multiaxial criterion	Findley critical plane	Good correlation for shear-sensitive materials
Uncertainty	Lognormal sampling via COVs	Matches MMPDS / typical scatter
Life basis	10th & 1st percentile (B & A)	Aerospace certification standard

Current Limitations

• Assumes 2D edge crack geometry (constant Y factor)
• No mixed-mode (II/III) or 3D crack shape evolution
• Simplified temperature derating (lookup table)
• Single-material hard-coded (7075-T73)
• Computationally heavy for >2000 realizations with 1M time points
• No built-in parallelization

Suggested Improvements & Roadmap

Quick Wins (1–3 days effort)

• Add argparse CLI interface for main parameters
• Implement basic multiprocessing / joblib for Monte Carlo realizations
• Allow loading material data from JSON/YAML instead of hard-coding
• Add progress bar (tqdm) during Monte Carlo loop
• Save/load simulation settings as config file

Medium-term Enhancements

• Support additional materials (2024-T3, Ti-6Al-4V, etc.)
• Add NASGRO / Forman–Newman–de Jong crack growth equation option
• Include variable geometry factor Y(a/t) or lookup table
• Better thermal profile (coupled with orbit attitude)
• Add residual stress redistribution model
• Export results to HDF5 for large campaigns

Longer-term / Advanced

• Integrate with FEA stress importers (e.g. Nastran .op2 via pyNastran)
• Bayesian calibration of COVs from coupon/test data
• Global sensitivity analysis (Sobol indices)
• Surrogate modeling (Gaussian Process) to accelerate Monte Carlo
• GUI dashboard (Streamlit / Dash) for parameter sweeping & visualization

Contributions welcome — especially validation against published test data or real satellite failure cases.

License

MIT (or choose your preferred open-source license)

Acknowledgments

• Uses fatpack for rainflow cycle counting
• Material properties based on MMPDS (B-basis values)
• Inspired by NASA / ESA damage tolerance guidelines

Happy analyzing — and may your satellites last many orbits!

### Additional Suggestions for Improvement (Detailed)

Here are more concrete, prioritized recommendations beyond what's already in the README:

1. **Performance (highest priority)**
   - Parallelize the `run_monte_carlo` loop using `concurrent.futures.ProcessPoolExecutor` or `joblib.Parallel`.
   - Reduce default `num_points` to 200k–300k unless high-frequency content is critical.
   - Cache rainflow results per block when loads are stationary.

2. **Usability**
   - Create `config.yaml` with all `@dataclass` defaults → load with `dacite` or `pydantic`.
   - Add `--quick-test` flag that runs 50 realizations with 50k points.
   - Add logging (`logging` module) instead of `print()`.

3. **Robustness & Validation**
   - Add unit tests (pytest) for:
     - Neuber solver convergence
     - Wheeler retardation logic
     - Critical crack size formula
   - Compare single deterministic run against NASGRO / AFGROW for simple cases.
   - Add input validation (e.g. ensure Kic > 0, initial_a < critical_a).

4. **Extensibility**
   - Make crack growth law pluggable (abstract base class `CrackGrowthLaw`).
   - Allow user-defined temperature vs. time or knockdown functions.
   - Support variable Kt(a) for growing cracks at notches.

5. **Documentation**
   - Add docstrings with type hints to every public method.
   - Create `CONTRIBUTING.md` and basic issue/PR templates.
   - Include example Jupyter notebook showing sensitivity + parameter sweep.

6. **Scientific / Certification**
   - Document sources of every default value (e.g. MMPDS-01 or specific report).
   - Add option to apply composite knockdowns (environment × temperature × surface finish).
   - Consider adding Walker table lookup instead of fixed γ.