SEARCH · Search NASA
Search indexed NASA NTRS and DOE OSTI research on propulsion, heat transfer, battery materials and energy systems. Follow report and document links to the original sources.
Quote a phrase for an exact phrase match. Source license links do not imply unrestricted reuse.
The seismic simulation code SW4 was adapted to run on modern supercomputers. SW4 solves the elastic wave equation in second order formulation. It uses a fourth order accurate finite difference method with explicit time stepping. The approximation conserves energy perfectly, and is stable under a CFL restriction on the time step.
Reliable model-independent predictions of nuclear processes such as beta-decay and neutrinonucleus scattering are important for many fundamental science and mission-related investigations; For example, accurate descriptions of as beta-decay are required for modeling the anti-neutrino spectrum of nuclear reactor, whether for trying to detect new physics such as sterile neutrinos, or remotely identifying the purpose of that reactor. For these activities, we need accurate calculations, as well as careful and thorough analyses of theoretical error and uncertainty in the underlying models and the many-body methods and codes used in solving that model. Unfortunately, modern theoretical calculations of these processes are inadequate for this task. At the heart of this inadequacy is the interaction between nucleons and other particles known as nuclear currents. Historically, descriptions of nuclear currents took into account only the simplest of particle interactions. Recently, the development of an effective field theory known as chiral EFT has been used to derive large corrections to these particle interactions. However, the complex nature of these corrections inhibited their use in ab initio methods of predicting nuclear processes. We developed a novel method to address these complexities and applied it in a series of benchmark and demonstrative calculations using state-of-the-art quantum few-nucleon solvers. Specifically, we studied the role of two-nucleon currents in electroweak processes using light nuclei (i.e., nuclei containing fewer than five nucleons) as a workbench to compute these processes and quantify their uncertainties using Bayesian extensions of the EFT.
In addition to fixing the color-coding legend, the new figures plot Fourier phase in a more easily recognizable format: polar coordinates rather than Cartesian coordinates. The same phase data is displayed—indicating the position of the first ridge to the east of the prime meridian—but the new plots avoid unphysical jumps, e.g. from +180° to -180° as longitude increases across the International Dateline. A slight disadvantage of the new format is that each hemisphere requires a separate plot. The wavenumber-1 Northern Hemisphere phase plots give, in effect, a view from above the North Pole, with Eurasia at the top and North America at the bottom. Wavenumber-1 Southern Hemisphere plots give an analogous view from the South Pole. Plots for higher wavenumbers, however, wrap around at fractions of 360° (180°, 120°, ...) and cannot be interpreted as a geographical view.
Over many years, ROOT users have repeatedly stumbled over—and loudly rediscovered—the infamous 1 GB limit on individual I/O operations, a constraint that somehow survived long past the era when anyone thought a gigabyte was “a lot.” As experiments embraced ever-larger objects and collections, this limit became an increasingly unavoidable rite of passage. This contribution recounts the sustained, multi-year quest by ROOT I/O developers to finally retire this relic, navigating a maze of legacy APIs, memory-management assumptions, and integer boundaries that seemed determined to preserve the status quo. We describe how internal interfaces were carefully modernized to introduce fully 64-bit–capable code paths without breaking the mountains of existing user code that would definitely have noticed. With the limit now lifted, ROOT can finally handle multi-gigabyte objects in a single read or write operation, even when splitting them into an RNTuple is not an option (we’re looking at you, large RooWorkspaces and giant histograms), liberating users from yet another “fun” debugging adventure and clearing the way for the massive analyses of the HL-LHC and beyond.
Over many years, ROOT users have repeatedly stumbled over—and loudly rediscovered—the infamous 1 GB limit on individual I/O operations, a constraint that somehow survived long past the era when anyone thought a gigabyte was “a lot.” As experiments embraced ever-larger objects and collections, this limit became an increasingly unavoidable rite of passage. This contribution recounts the sustained, multi-year quest by ROOT I/O developers to finally retire this relic, navigating a maze of legacy APIs, memory-management assumptions, and integer boundaries that seemed determined to preserve the status quo. We describe how internal interfaces were carefully modernized to introduce fully 64-bit–capable code paths without breaking the mountains of existing user code that would definitely have noticed. With the limit now lifted, ROOT can finally handle multi-gigabyte objects in a single read or write operation, even when splitting them into an RNTuple is not an option (we’re looking at you, large RooWorkspaces and giant histograms), liberating users from yet another “fun” debugging adventure and clearing the way for the massive analyses of the HL-LHC and beyond.
CTF is the modernized and improved version of the subchannel code, COBRA-TF. It has been adopted by the Consortium for Advanced Simulation for Light Water Reactors (CASL) for subchannel analysis applications and thermal hydraulic feedback calculations in the Virtual Environment for Reactor Applications Core Simulator (VERA-CS). CTF is now jointly developed by Oak Ridge National Laboratory and North Carolina State University. Until now, CTF has been used for pressurized water reactor modeling and simulation in CASL, but in the future it will be extended to boiling water reactor designs. This required development activities to integrate the code into the VERA-CS workflow and to make it more ecient for full-core, pin resolved simulations. Additionally, there is a significant emphasis on producing high quality tools that follow a regimented software quality assurance plan in CASL. Part of this plan involves performing validation and verification assessments on the code that are easily repeatable and tied to specific code versions. This work has resulted in the CTF validation and verification matrix being expanded to include several two-phase flow experiments, including the General Electric 3 3 facility and the BWR Full-Size Fine Mesh Bundle Tests (BFBT). Comparisons with both experimental databases is reasonable, but the BFBT analysis reveals a tendency of CTF to overpredict void, especially in the slug flow regime. The execution of these tests is fully automated, analysis is documented in the CTF Validation and Verification manual, and the tests have become part of CASL continuous regression testing system. This paper will summarize these recent developments and some of the two-phase assessments that have been performed on CTF.
The PIDOTS radiation transport code implements a spatially decomposed Integral Transport Matrix Method (ITMM) solver, which is intended to fully utilize the capabilities of modern, massively parallel high-performance computing (HPC) systems. While the code shows promising results, there was also an unexpected loss of parallel efficiency on the test systems as the number of participating processors grew and the parallelization grain size got finer. We seek to identify and characterize the communication-latency based effects that contribute to this slowdown. Through the creation of a high-level, parameterized representation of the workload of the code, the communication methodology was identified as the likely reason. From there, low-level, InfiniBand communication performance data measured on the Falcon HPC at Idaho National Laboratory (INL) was used to produce a discrete-event model of the communication scheme. The data, as well as the model, show that infrequent, large spikes in send/receive latency drive an unexpectedly substantial increase in projected runtime of a code. Furthermore, these effects are more pronounced under the high-utilization, scattered-workload environment of Falcon. Based on results from the model, it can be shown that a high-communication volume, small message-size regime can easily lead to slowdowns of ~5-10x, when compared to ideal results, as the processor count increases.
Adopting quantum communication to modern networking requires transmitting quantum information through a fiber-based infrastructure. In this paper, we report the first demonstration of superdense coding over optical fiber links, taking advantage of a complete Bell-state measurement enabled by time-polarization hyperentanglement, linear optics, and common single-photon detectors. Finally, we demonstrate the highest single-qubit channel capacity to date utilizing linear optics, 1.665 ± 0.018, and we provide a full experimental implementation of a hybrid, quantum-classical communication protocol for image transfer.
This report considers the role of national model codes to promote grid-interactive efficient buildings (GEBs) as part of the modernization of the U.S. electricity grid. It introduces GEBs, describes their ability to support a clean, resilient grid, and considers challenges and approaches for incorporating GEB measures into national model energy codes and standards. Desirable traits of GEB include being low energy, low peaking, and responsive to grid needs, and minimizing the curtailment of renewable energy resources. In addition, the future grid incurs a time and locational value on these types of building services. Accounting for these considerations in future code development requires a continuation and expansion of code-minimum energy efficiency requirements and inclusion of demand responsive and load flexibility measures while ensuring annual use and cost reductions. Also, efforts to include GEB measures in codes will be limited until they are fully developed into an American National Standards Institute (ANSI)-approved standard. Then it would be straightforward to address GEB measures through points or packages and/or scoring requirements. Otherwise, the building code would have to describe each specific grid responsive strategy. This document reviews topics pertinent to considering codes in this context. Specifically, the study presents the status and direction of current building energy codes, the future smart grid, low-energy buildings, and grid-integrated buildings. The report concludes with recommendations for future code development activities to support low-energy, grid-interactive buildings in order to provide added value to building owners, the grid, and society.
The HPC industry is inexorably moving towards an era of extremely heterogeneous architectures, with more devices configured on any given HPC platform and potentially more kinds of devices, some of them highly specialized. Writing a separate code suitable for each target system for a given HPC application is not practical. The better solution is to use directive-based parallel programming models such as OpenMP. OpenMP provides a number of options for offloading a piece of code to devices like GPUs. To select the best option from such options during compilation, most modern compilers use analytical models to estimate the cost of executing the original code and the different offloading code variants. Building such an analytical model for compilers is a difficult task that necessitates a lot of effort on the part of a compiler engineer. Recently, machine learning techniques have been successfully applied to build cost models for a variety of compiler optimization problems. In this paper, we present COMPOFF, a cost model which uses the multi-layer perceptrons to statically estimates the Cost of OpenMP OFFloading. We used six different transformations on a parallel code of Wilson Dslash Operator to support GPU offloading, and we predicted their cost of execution on different GPUs using COMPOFF during compile time. Our results show that this model can predict offloading costs with a root mean squared error in prediction of less than 0.5 seconds. Our preliminary findings indicate that this work will make it much easier and faster for scientists and compiler developers to port legacy HPC applications that use OpenMP to new heterogeneous computing environment.
The paper is focused on the presentation of the development process, calculation procedure and main features of the eOMEGA code used for decommissioning costing of nuclear facilities. The methodology for decommissioning cost calculation implemented to the eOMEGA code is fully in line with the international recommendations, best practices and is completely based on the ISDC - The International Structure for Decommissioning Costing (ISDC) of Nuclear Installation. ISDC represents the standard and common platform for presenting the results of the cost estimates for decommissioning projects related to any type of nuclear facility. The main goal of the eOMEGA costing code is to provide the ISDC based flexible, open, modern and user-friendly tool for transparent and reliable decommissioning costing for any type of nuclear facility with any systems, structures and radiological situation at the end of the operational period. Moreover, the eOMEGA decommissioning costing code is intended to be one of the modules of the universal eOMEGA platform which should cover also the other activities within the back-end of nuclear power engineering e.g. decommissioning funding, back end of nuclear fuel cycle, site remediation. (authors)
Here, this paper presents the process, strategy, and results associated with porting a typical combustion physics flow solver to current state-of-the-art and future massively-parallel computer architectures. Major focus is placed on the distinct algorithmic structure of these types of codes and how it can be integrated with modern programming paradigms for heterogeneous platforms (i.e., distributed many-core systems with accelerators). An end-to-end case study is presented that exemplifies the process in a generic manner, which then serves as a clear guide with respect to the strategy and best practices leading to a robust and adaptable framework that performs well, is durable over time, is portable, and requires minimal human-effort. This end is accomplished beginning with the use of a mature, validated, structured, multiblock code framework optimized for application of both Large Eddy Simulation (LES) and Direct Numerical Simulation (DNS). This code has been ported to a variety of platforms over the past decade, including most recently the Oak Ridge Leadership Computing Facility’s “Summit” Platform. The experience gained on these multiple platforms provides general insights and thus the results presented are not specific to any one code or platform other than the overarching trend toward distributed many-core systems with accelerators in order to move toward exascale performance. The resultant performance and scalability of the ported code is demonstrated on a real-world application; a state-of-the-art rotating detonation rocket engine simulation that matches the complex geometry and boundary conditions imposed as part of a companion experimental campaign.
The Energy Research and Forecasting (ERF) model is a high-performance atmospheric model built on the AMReX adaptive mesh refinement (AMR) framework, enabling efficient simulations on heterogeneous computing platforms that combine multicore processors with hardware accelerators. To support land–atmosphere interactions within ERF’s AMR-based environment, a land-surface model must be capable of operating directly on hierarchically refined meshes. In this work, we present a methodology for coupling the Fortran-based Noah-Multiparameterization (Noah-MP) land-surface model with ERF’s C++ codebase. Rather than rewriting Noah-MP, we construct a Fortran–C interoperability layer using CodeScribe, a tool that leverages large language models (LLMs) to automate the generation of interface code. CodeScribe applies structured prompting techniques to generate bindings that support efficient data exchange and function calls between ERF and Noah-MP. The coupling framework also incorporates AMR-aware data handling strategies, allowing NoahMP to operate seamlessly within ERF’s hierarchical mesh structure. This work provides a structured approach for integrating legacy Fortran models into modern C++-based modeling systems using LLM-assisted code generation.
Applications ranging from nuclear safeguards to dark matter detection require accurate predictions of neutron yields and energy spectra produced by (α, n) reactions. Legacy tools like SOURCES-4C remain widely used despite significant limitations, including outdated nuclear data, missing target nuclides, and restricted accessibility. Here, we present ALPHANSO, an open-source Python package for calculating (α, n) neutron source terms. ALPHANSO incorporates modern nuclear data libraries and formats covering all naturally occurring target nuclides and provides a transparent, modular framework for updating or extending the data as new evaluations are released. Comparison with an updated version of SOURCES-4A, NeuCBOT, and experimental measurements across a range of elements and materials shows that ALPHANSO reproduces neutron yields and spectra in good agreement with experimental data and state-of-the-art (α, n) calculations. These results demonstrate that ALPHANSO is a reliable, accessible, and modern alternative to legacy (α, n) source term codes such as SOURCES-4C. Its open-source design and modular data handling make it readily extensible to future evaluated nuclear data and low-background applications.
In this paper, we report reimplementation of the core algorithms of relativistic coupled cluster theory aimed at modern heterogeneous high-performance computational infrastructures. The code is designed for parallel execution on many compute nodes with optional GPU coprocessing, accomplished via the new ExaTENSOR back end. The resulting ExaCorr module is primarily intended for calculations of molecules with one or more heavy elements, as relativistic effects on the electronic structure are included from the outset. In the current work, we thereby focus on exact two-component methods and demonstrate the accuracy and performance of the software. The module can be used as a stand-alone program requiring a set of molecular orbital coefficients as the starting point, but it is also interfaced to the DIRAC program that can be used to generate these. We therefore also briefly discuss an improvement of the parallel computing aspects of the relativistic self-consistent field algorithm of the DIRAC program.
With the development of a Fortran Interface to Trilinos, ForTrilinos, modelers using modern Fortran will be able to provide their codes the capability to use solvers and other capabilities on exascale machines via a straightforward infrastructure that accesses Trilinos. This document outlines what ForTrilinos does and explains briefly how it works. We show it provides a general access to packages via an entry point and uses an xml file from fortran code. With the first release, ForTrilinos will enable Teuchos to take xml parameter lists from Fortran code and set up data structures. It will provide access to linear solvers and eigen solvers. Several examples are provided to illustrate the capabilities in practice. We explain what the user should have already with their code and what Trilinos provides and returns to the Fortran code. We provide information about the build process for ForTrilinos, with a practical example. In future releases, nonlinear solvers, time iteration, advanced preconditioning techniques, and inversion of control (IoC), to enable callbacks to Fortran routines, will be available.
BISON is a modern finite-element based nuclear fuel performance code that has been under development at the Idaho National Laboratory (USA) since 2009 [1]. The code is applicable to both steady and transient fuel behavior and can be used to analyze 1D (spherically symmetric), 2D (axisymmetric and generalized plane strain) or 3D geometries. BISON is the fuel performance code used within CASL for LWR fuel under both normal operating and accident conditions. BISON is built using the INL Multiphysics ObjectOriented Simulation Environment, or MOOSE [2, 3]. MOOSE is a massively parallel, finite element-based framework to solve systems of coupled non-linear partial differential equations using the Jacobian-Free Newton Krylov (JFNK) method [4]. This enables investigation of computationally large problems, for example a full stack of discrete pellets in a LWR fuel rod, or every rod in a full reactor core. MOOSE supports the use of complex two and three-dimensional meshes and uses implicit time integration, important for the widely varied time scale in nuclear fuel simulation. An object-oriented architecture is employed which greatly minimizes the programming effort required to add new material and behavioral models. The flexibility of the implicit and fully coupled multiphysics approach comes with a need for constructing suitable approximations for the Jacobian matrix of the coupled system used for either preconditioning a Krylov solve or in a direct Newton solve. Preconditioning options for Bison problems need to be revisited with new preconditioning methods becoming available.
This paper examines the prerequisites and boundary conditions for extending burnup credit from pressurized water reactors to boiling water reactors with validated depletion codes by performing uncertainty and sensitivity analyses on a modern boiling water reactor fuel assembly design. We developed a computational chain consisting of an axial boiling water reactor axial irradiation model, followed by a series of depletion calculations and a three-dimensional criticality calculation. The irradiation model puts into relation the profiles of power, burnup and moderator density of the fuel assembly at 24 axial locations. In a simplified fashion it also includes the insertion of control blades. The depletion calculations of the fuel assembly were performed in axial slices with the 2D-depletion code HELIOS 1.12. The criticality calculations were done in 3D-geometry with KENO-Va from the SCALE 6.2.1 package, in which several fuel assemblies are placed into a generic transport cask. For the uncertainty and sensitivity analyses a Monte Carlo sampling based approach is used applying the GRS tool SUnCISTT. We performed several generic investigations testing the capabilities and the limitations of the whole computational chain. The impact of variations of the irradiation model on the resulting reactivity of the fuel assemblies inside a transport cask or storage pool was investigated using an uncertainty and sensitivity analysis on the whole computational chain. Geometrical uncertainties were also included in the evaluation and a parameter study on the use of control blades during irradiation was performed. The goal was to develop the procedures and tools to be able to obtain quantitative uncertainty data which can be used in the future to derive conservative irradiation profiles without unnecessary excess reactivity margins. (authors)