Modeling Decay Heat with a Simplified Depletion Chain in OpenMC

This paper presents a method to improve the accuracy of decay heat estimates in OpenMC depletion simulations by modifying the simplified CASL chain through the addition of pseudo-nuclides and "delay nuclides" to capture the behavior of missing nuclide groups without sacrificing computational efficiency.

The Gist

The Problem: The "Short List" Chef

Imagine a nuclear power plant is a giant, high-stakes kitchen. Inside, atoms are constantly breaking apart (fission), creating a chaotic mix of new ingredients (nuclides). Even after the chef turns off the stove (shuts down the reactor), these new ingredients keep cooking themselves, releasing heat. This is called Decay Heat.

If you don't manage this heat, the kitchen melts down (like in Fukushima). So, engineers need to predict exactly how much heat will be left over.

To do this, they use a computer program called OpenMC. This program needs a "recipe book" (called a Depletion Chain) that lists every single ingredient and how it transforms into the next one.

• The Gold Standard (ENDF Chain): This recipe book has 3,800+ ingredients. It's incredibly accurate but so heavy and complex that the computer takes forever to cook the meal. It's like trying to count every single grain of sand on a beach to estimate the weight of the sandcastle.
• The Shortcut (CASL Chain): To save time, engineers created a simplified recipe book with only 228 ingredients. It's fast and great for predicting how the reactor runs while it's on. However, it's terrible at predicting the leftover heat. It's like a chef who only knows how to cook the main course but forgets the dessert and the side dishes. When the main course is done, the chef says, "No heat left!" when actually, the oven is still glowing hot.

The Result: The shortcut recipe underestimated the leftover heat by a huge margin, which is dangerous for safety.

---

The Solution: The "Magic Substitutes"

The authors (Tanmay Gupta and Benoit Forget) asked: How can we keep the shortcut recipe fast but make it accurate enough to predict the heat?

They came up with two clever tricks using "Magic Substitutes."

Trick 1: The "Grouped Ingredient" (Pseudo-Nuclides)

Instead of tracking hundreds of tiny, specific ingredients individually, they created 10 "Super-Ingredients" (called Pseudo-Nuclides).

• The Analogy: Imagine you have 500 different types of berries. Instead of tracking each one, you group them by how fast they rot.
  • Group A: Berries that rot in 1 second.
  • Group B: Berries that rot in 1 minute.
  • ...and so on.
• How it works: You create one "Super-Berry" for each group. This Super-Berry acts like the average of all the berries in that group. When the computer calculates the heat, it just tracks these 10 Super-Berries instead of 500 real ones.
• The Result: This fixed the "missing heat" problem. The computer now knew that even though it wasn't tracking every single berry, the "Super-Berries" were still generating the right amount of heat.

Trick 2: The "Waiting Room" (Delay Nuclides)

There was still a small problem. When the reactor starts up or shuts down, the timing is tricky.

• The Problem: In the real world, Ingredient A turns into Ingredient B, which then turns into Ingredient C. This takes time. In the "Super-Ingredient" version, the computer was making Ingredient C appear instantly, skipping the waiting time. This caused errors right at the start and end of the day.
• The Analogy: Imagine a factory assembly line.
  • Real Life: A car part is painted, then it waits 10 minutes to dry, then it gets assembled.
  • The Bad Shortcut: The computer painted the part and immediately assembled it, ignoring the drying time.
  • The Fix: The authors added "Waiting Rooms" (called Delay Nuclides). Now, when a Super-Ingredient is made, it has to sit in a Waiting Room for a specific amount of time before it turns into the next thing.
• The Result: This fixed the timing errors. The heat prediction was now smooth and accurate, even during the chaotic moments of startup and shutdown.

---

The Outcome: Fast AND Accurate

By adding just 10 Super-Ingredients and 10 Waiting Rooms to the simplified recipe, the authors achieved a miracle:

1. Accuracy: The new model predicted the leftover heat almost perfectly (within 0.3% to 5% error), matching the massive 3,800-ingredient model.
2. Speed: Because they didn't have to track thousands of extra ingredients, the computer still ran 50% faster than the heavy, detailed model.

The Big Picture

Think of this like a GPS app.

• The Old Way (ENDF) was like calculating the exact position of every single car on the highway to predict traffic. It's perfect but takes forever to load.
• The Bad Shortcut (CASL) was like ignoring all the cars and just guessing. It loads instantly but gives you the wrong arrival time.
• The New Method is like using a "Traffic Flow" model. It doesn't track every car, but it uses "Super-Groups" of traffic and "Waiting Times" at intersections. It loads instantly but tells you exactly when you'll arrive.

This research proves that we don't need to track every single atom to keep nuclear reactors safe; we just need smart, simplified models that understand the behavior of the heat, not just the count of the atoms.

Technical Summary

1. Problem Statement

Accurate modeling of decay heat is critical for nuclear reactor safety, particularly for post-shutdown cooling systems (as highlighted by the Fukushima accident). While the open-source Monte Carlo code OpenMC can perform depletion calculations, it relies on a depletion chain file to track nuclide transmutations and decays.

• The Benchmark: The full ENDF/B-VII.1 depletion chain contains over 3,800 nuclides and provides accurate decay heat estimates but is computationally expensive regarding memory and runtime (due to the sheer number of reaction tallies and matrix operations).
• The Simplification: The CASL depletion chain (228 nuclides) was developed to reduce computational costs while preserving reactivity and nuclide densities during operation.
• The Deficit: The CASL chain drastically underestimates decay heat (by orders of magnitude in some cases) because it omits hundreds of nuclides that contribute significantly to the total decay energy. Simply adding these missing nuclides back into the chain negates the computational benefits of the simplification.

2. Methodology

The authors propose a two-stage modification to the CASL chain to recover decay heat accuracy without sacrificing computational efficiency.

A. Pseudo-Nuclides (PNs)

To capture the decay heat of hundreds of omitted (ENDF-exclusive) nuclides without tracking them individually, the authors introduced Pseudo-Nuclides.

• Grouping: ENDF-exclusive nuclides are grouped into 10 categories based on their decay constants ($\lambda$). The grouping is logarithmic to ensure an even distribution.
• Representation: Each group is represented by a single fictitious nuclide (PN) with a representative decay constant ($\lambda_{PN}$), calculated as the average of the group members.
• Production Rate Scaling: Instead of tracking number density ($N_i$), the PN tracks the quantity $\sum Q_i N_i$ (where $Q_i$ is the recoverable energy per decay). The production rate of the PN is scaled by $Q_i$ to ensure that at equilibrium, the PN's decay heat ($\lambda_{PN} \sum Q_i N_i$) accurately matches the sum of the group's actual decay heat.
• Implementation: The CASL chain is modified so that CASL nuclides produce these PNs directly, with yields scaled by the energy release ($Q$) of the corresponding ENDF-exclusive nuclides.

B. Delay Nuclides

Initial tests with PNs showed significant errors during transient phases (startup and shutdown).

• Root Cause: The error stemmed from the assumption of instantaneous decay in the PN implementation. In reality, decay pathways often involve intermediate nuclides with non-negligible half-lives. When the reactor shuts down, the production of PNs stops immediately in the simplified model, whereas in reality, parent nuclides continue to decay into the target nuclides for a period.
• Solution: The authors introduced Delay Nuclides. These are fictitious nuclides inserted into the depletion chain to mimic the time delay of specific decay pathways.
  • A delay nuclide is assigned the decay constant of the longest-lived parent in a specific decay chain.
  • It decays into the appropriate PN.
  • This restores the temporal structure of the decay pathways, ensuring that production continues correctly after shutdown and ramps up correctly during startup.

3. Key Contributions

1. Algorithm for PN Integration: Developed a method to map hundreds of omitted nuclides into 10 PNs by scaling production yields with decay energy ($Q$), allowing the simplified chain to capture the cumulative decay heat of the full chain.
2. Introduction of Delay Nuclides: Identified that "instantaneous decay" approximations cause transient errors and solved this by inserting delay nuclides that preserve the half-life structure of critical decay pathways.
3. Generalizable Approach: Demonstrated that the method is not specific to one reactor type, successfully applying it to both a Pressurized Water Reactor (PWR) and a Sodium-Cooled Fast Reactor (SFR).

4. Results

The study utilized OpenMC to simulate a PWR pin cell and an SFR pin cell, comparing the modified chains against the full ENDF benchmark.

• Decay Heat Accuracy:
  • Original CASL: Underestimated decay heat significantly (e.g., -68% error at 1 hour post-shutdown).
  • CASL + 10 PNs: Improved accuracy but still showed spikes in error during startup/shutdown due to production rate timing issues.
  • CASL + 10 PNs + 10 Delay Nuclides (CASL+10PNs v2): Achieved high accuracy.
    • Time-Integrated Decay Heat (PWR): Relative error remained below 5% for all post-shutdown intervals (1 to 512 hours).
    • CASL+All PNs v2: Achieved relative error below 0.3%.
• Computational Performance:
  • The modified chains maintained the computational advantages of the simplified CASL chain.
  • Total Runtime: Approximately 50% faster than the full ENDF chain (dominated by transport solver time).
  • Depletion Solver Time: The CASL+10PNs chain ran 70% faster than the ENDF chain.
• SFR Validation: The method successfully generalized to the SFR model, confirming that the physics-based grouping and delay logic work across different neutron flux spectra (thermal vs. fast).

5. Significance

This work resolves a critical trade-off in nuclear simulation: accuracy vs. efficiency.

• Safety: It enables the use of computationally efficient simplified depletion chains for safety analyses requiring precise decay heat predictions, which were previously only possible with expensive full-chain simulations.
• Scalability: By reducing the number of tracked nuclides from ~3,800 to ~238 (228 CASL + 10 PNs + 10 Delay), the method significantly lowers memory requirements and transport tally overhead, making high-fidelity depletion simulations feasible for large-scale reactor models (e.g., full core simulations with millions of regions).
• Future Application: The concept of using "delay nuclides" to approximate complex decay pathways can be applied to other simplified models where time-dependent production rates are critical.