Component-Based Reduced-Order Modeling Framework for Rocket Combustion Dynamics in Multi-Injector Configurations

This paper presents a component-based reduced-order modeling (CBROM) framework that decomposes large-scale rocket engines into individual components trained on small-domain high-fidelity simulations and coupled via an adaptive MP-LSVT projection to enable accurate, efficient parametric predictions of combustion dynamics in multi-injector configurations.

The Gist

Imagine you are trying to design a massive, complex rocket engine. To make sure it works safely, you need to simulate how the fuel burns, how the shockwaves bounce around, and how the turbulence swirls inside.

The Problem: The "Super-Computer" Bottleneck
Think of simulating a real rocket engine like trying to watch a movie of a hurricane in ultra-high definition (4K or 8K) on a super-computer. The physics are so complex (turbulence, fire, shockwaves) that even the world's fastest computers would take years to run a single simulation. If you wanted to test 100 different designs (changing the shape of the nozzle, the size of the fuel holes, etc.), you'd be waiting for centuries. This is too slow for engineers who need to iterate quickly.

The Old Solutions: "Blurring" the Picture
Previously, scientists tried to speed this up by "blurring" the picture. They would:

• Make the grid coarser (like looking at a low-resolution JPEG).
• Simplify the chemistry (pretending fire is just a simple flame, not a complex chemical reaction).
• Shrink the 3D world to 2D.

The Downside: While this was faster, it was like watching a blurry movie. You might miss the critical details that cause the engine to explode or fail. It's a trade-off: speed for accuracy.

The New Solution: The "Lego" Approach (CBROM)
This paper introduces a clever new framework called Component-Based Reduced-Order Modeling (CBROM). Instead of trying to simulate the whole giant rocket engine at once, the authors break it down into smaller, manageable "Lego bricks."

Here is how it works, using a simple analogy:

1. Breaking the Engine into "Bricks"

Imagine a rocket engine with seven fuel injectors (nozzles that spray fuel). Instead of simulating the whole thing, the researchers split it into three types of "bricks":

• The Wall Bricks: The injectors on the very edge.
• The Inner Bricks: The injectors in the middle.
• The Tail Brick: The combustion chamber and the nozzle at the back.

2. Training the "Mini-Experts"

Instead of training a super-computer to understand the entire engine, they train tiny, specialized "mini-experts" for each brick type.

• The Trick: To train the "Wall Brick" expert, they don't need to simulate the whole engine. They build a tiny, fake, reduced-size version of just that brick and its immediate neighbors. They run a high-fidelity simulation on this tiny piece to teach the model what happens there.
• The Result: They create three highly accurate, super-fast "mini-experts" (one for the wall, one for the inner, one for the tail).

3. The "Puzzle" Assembly

Once these mini-experts are trained, they can be snapped together like a puzzle to simulate the entire engine.

• When the "Wall Brick" model needs to know what the "Inner Brick" is doing, they pass information back and forth at the boundaries (like neighbors talking over a fence).
• Because the heavy lifting was done on the tiny, cheap simulations, the final assembly runs incredibly fast.

4. The "Adaptive" Superpower

The coolest part of this framework is that it's adaptive.

• Scenario: Imagine you decide to change the design of the fuel injector, making the recess (the little pocket inside) 50% longer.
• Old Way: You would have to throw away your old simulations and start all over with a new, expensive, full-engine simulation.
• New Way: The "mini-expert" for the injector is smart. It can stretch its internal map to fit the new, longer shape. It adapts on the fly without needing to be retrained from scratch. It's like having a GPS that instantly recalculates the route when you take a detour, without needing to download a new map.

The Results: Fast and Accurate

The authors tested this on a 7-injector rocket engine. They simulated three scenarios:

1. Normal operation.
2. Turning off some fuel injectors (simulating a failure).
3. Changing the shape of the injectors.

The Outcome:

• Accuracy: The "Lego" method predicted the complex fire and sound waves almost perfectly, matching the expensive, slow simulations.
• Speed: It ran 7.7 times faster than the traditional method.

Why This Matters

Think of this as moving from painting a masterpiece one tiny dot at a time (the old way) to using a set of pre-painted, perfect tiles that you can snap together in seconds (the new way).

This framework allows engineers to:

• Test hundreds of design changes in the time it used to take to test one.
• Predict how an engine will behave if a part fails.
• Design safer, more efficient rockets without waiting years for computer results.

In short, they found a way to make the "super-computer" fast enough to be useful for real-world rocket design, without sacrificing the accuracy needed to keep the rocket from blowing up.

Technical Summary

1. Problem Statement

High-fidelity computational fluid dynamics (CFD) simulations, such as Large-Eddy Simulations (LES), are essential for understanding complex rocket combustion dynamics (involving turbulence, combustion, and shock interactions). However, these simulations are computationally prohibitive for full-scale rocket engines, which often contain hundreds of injectors.

• The Gap: A full-scale high-fidelity simulation could require $>10^{10}$ CPU-hours, making it infeasible for practical design processes that require iterative parametric studies (varying flow conditions and geometries).
• Limitations of Existing Methods:
  • Reduced-Fidelity Models (RFMs): Simplify physics (e.g., coarser grids, simplified chemistry) but often lose critical accuracy needed for sensitive propulsion dynamics.
  • Machine Learning (ML) ROMs: Often lack physical consistency (violating conservation laws), have poor generalizability outside training regions, and require massive datasets.
  • Standard Projection-based ROMs: While physically consistent, they require high-fidelity data from the entire system to train, which is unavailable for large-scale engines.

2. Methodology: Component-Based Reduced-Order Modeling (CBROM)

The authors propose a Component-Based Reduced-Order Modeling (CBROM) framework that decomposes a large-scale system into representative components with identical geometries. This allows for the training of Reduced-Order Models (ROMs) on small sub-domains rather than the full system.

A. Domain Decomposition

The rocket combustor is decomposed into three types of reference components:

1. Wall-adjacent injectors ($\bar{\Omega}_I$): Injectors near the chamber wall.
2. Interior injectors ($\bar{\Omega}_{II}$): Injectors in the center of the array.
3. Downstream combustor and nozzle ($\bar{\Omega}_{III}$): The region downstream of the injectors.

B. Component-Based Training Strategies

To avoid the need for full-system high-fidelity data, the authors employ two distinct training strategies:

1. Reduced-Geometry Training (for Injectors):
   • Small training domains are constructed containing the reference injector plus "auxiliary" injectors and buffer regions.
   • These buffers use exponentially stretched meshes to capture large-scale motions (e.g., vortex shedding) while damping small-scale reactions to prevent boundary condition reflections.
   • This mimics the full-system injector dynamics at a fraction of the cost.
2. Full-Geometry Training (for Downstream):
   • The downstream component is trained using a full-domain simulation where the upstream injectors are modeled using the already-trained injector ROMs.
   • This hybrid approach reduces the cost of training the downstream ROM while ensuring it receives realistic upstream boundary conditions.

C. Adaptive Model-Order Reduction (MOR)

The framework utilizes an advanced Adaptive ROM formulation to handle the non-stationary and nonlinear nature of combustion:

• Projection: Uses Proper Orthogonal Decomposition (POD) to construct low-dimensional subspaces.
• Stability: Employs Model-Form Preserving Least-Squares with Variable Transformation (MP-LSVT) to ensure the ROM respects the underlying physics (conservation laws) and remains stable.
• Hyper-Reduction: Uses Discrete Empirical Interpolation Method (DEIM) to approximate nonlinear residual terms, reducing computational bottlenecks.
• Adaptation: The trial basis and sampling points are updated online during simulation to track evolving physics, overcoming the Kolmogorov N-width barrier (slow decay of error in complex dynamics).

D. Coupling and Deployment

• Coupling: Components are coupled via a direct flux matching method using ghost cell assignments. This ensures continuity of numerical fluxes (inviscid and viscous) at interfaces without overlap.
• Geometric Variations: The framework supports parametric studies by mapping the ROM basis from a baseline geometry to a modified geometry (e.g., changing injector recess length) and allowing the adaptive algorithm to update the basis to fit the new dynamics.

3. Key Contributions

1. Novel CBROM Framework: Established a scalable framework for full-scale rocket engines by decomposing the domain and training ROMs on representative components, bypassing the need for full-system high-fidelity data.
2. Hybrid Training Strategy: Introduced a cost-effective strategy where injector ROMs are trained on reduced geometries, and the downstream ROM is trained using a hybrid FOM-ROM approach.
3. Adaptive Physics-Preserving ROM: Integrated MP-LSVT and online basis adaptation to accurately model highly nonlinear, self-excited combustion instabilities.
4. Parametric and Geometric Flexibility: Demonstrated the ability to simulate abrupt operating condition changes (injector shutdowns) and geometric variations (recess length changes) without retraining or remeshing the entire domain.

4. Results

The framework was evaluated on a 2D seven-injector rocket combustor exhibiting self-excited transverse combustion instability. Three types of test cases were analyzed:

1. Baseline: Nominal operation.
2. Parametric Variations: Shutdown of the center injector, and shutdown of the center + right-wall injectors.
3. Geometric Variations: 50% elongation of wall injector recess lengths.

Performance Metrics:

• Dynamic Mode Decomposition (DMD): The CBROM accurately predicted shifts in dominant acoustic frequencies and amplitudes caused by injector shutdowns and geometric changes. It correctly captured the emergence of new acoustic modes.
• Statistical Fields: The framework showed excellent agreement with Full-Order Models (FOM) for:
  • Time-averaged temperature fields: Correctly predicted cold reactant penetration depths and recirculation zones.
  • Root-Mean-Square (RMS) fields: Accurately captured the intensity and asymmetry of temperature fluctuations.
• Computational Speedup: The CBROM framework achieved a consistent ~7.7x speedup in computational time compared to the FOM across all test cases.

5. Significance

This work represents a significant step toward the digital twin and design optimization of large-scale propulsion systems.

• Feasibility: It makes parametric studies of full-scale rocket engines (with hundreds of injectors) computationally feasible, which was previously impossible due to the "curse of dimensionality" in high-fidelity simulations.
• Accuracy vs. Cost: It bridges the gap between the low cost of reduced-fidelity models and the high accuracy of full-order models, maintaining physical consistency while drastically reducing runtime.
• Scalability: The component-based approach is inherently scalable; adding more injectors to a design simply requires reusing the trained component ROMs rather than re-simulating the entire system.
• Future Impact: The authors plan to extend this to 3D configurations and rotating detonation engines (RDREs), paving the way for rapid design cycles in next-generation propulsion.