SEARCH · Engineering Papers
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.
This is a build guide for the MCNP ® code, version 6.3.0, that expands upon the README.md included with the source code. It covers compilers, dependencies, building, testing, and installing the code in one of its supported configurations.
Full-potential linearized augmented plane wave (LAPW) and APW plus local orbital (APW+lo) codes differ widely in both their user interfaces and in capabilities for calculations and analysis beyond their common central task of all-electron solution of the Kohn–Sham equations. However, that common central task opens a possible route to performance enhancement, namely to offload the basic LAPW/APW+lo algorithms to a library optimized purely for that purpose. To explore that opportunity, we have interfaced the Exciting-Plus (“EP”) LAPW/APW+lo DFT code with the highly optimized SIRIUS multi-functional DFT package. This simplest realization of the separation of concerns approach yields substantial performance over the base EP code via additional task parallelism without significant change in the EP source code or user interface. We provide benchmarks of the interfaced code against the original EP using small bulk systems, and demonstrate performance on a spin-crossover molecule and magnetic molecule that are of size and complexity at the margins of the capability of the EP code itself.
For the past several years, Idaho National Laboratory’s MOOSE framework team has employed modern software engineering techniques (continuous integration, joint application/framework source code repos- itories, automated regression testing, etc.) in developing closed-source multiphysics simulation software (Gaston et al., Journal of Open Research Software vol. 2, article e10, 2014). In March 2014, the MOOSE framework was released under an open source license on GitHub, significantly expanding and diversifying the pool of current active and potential future contributors on the project. Despite this recent growth, the same philosophy of concurrent framework and application development continues to guide the project’s development roadmap. Several specific practices, including techniques for managing multiple repositories, conducting automated regression testing, and implementing a cascading build process are discussed in this short paper. Furthermore, special attention is given to describing the manner in which these practices naturally synergize with the GitHub API and GitHub-specific features such as issue tracking, Pull Requests, and project forks.
Prescribing inlet boundary conditions for computational fluid dynamics (CFD) simulations of internal flow in complex geometries such as anatomical vascular models is challenging. In the absence of patient-specific inlet velocity data, a common approach for long blood vessels is to assume that the inlet flow is fully developed. In vessels of irregular cross section, however, prescribing fully developed conditions is complicated due to the lack of a general closed-form analytical solution. In this study, we develop a simple Poisson equation method for prescribing fully developed inlet conditions for the flow of either Newtonian or non-Newtonian fluids in CFD models of arbitrary cross-section. We first derive the generalized Poisson equation for fully developed flow of a non-Newtonian fluid and we then develop and verify a methodology for numerically computing the solution on any planar boundary domain. In addition, we develop a simple extension of the method for prescribing a non-orthogonal inlet velocity that represents fully developed flow from an upstream tube that is connected to the CFD inlet at a non-orthogonal angle. This may be used to investigate a common source of uncertainty in CFD simulations of internal flow that is due to a lack of information concerning the exact streamwise flow direction at the inlets. Comparison to several Newtonian and non-Newtonian benchmark verification solutions shows the method to be extremely accurate. As a practical demonstration case, we use the method to prescribe fully developed conditions on multiple non-circular inlets for the non-Newtonian flow of blood in a patient-specific model of the inferior vena cava (IVC). Finally, we further demonstrate the utility of the method by performing a sensitivity study using the patient-specific IVC model, wherein we investigate the influence of inlet velocity flow direction on the non-Newtonian IVC hemodynamics. Given its simplicity and computational efficiency, the method is shown to be far superior to alternative approaches for prescribing fully developed inlet conditions in such complicated geometries. In conclusion, to facilitate the adoption of our Poisson equation method, we have distributed our OpenFOAM source code and the associated test cases from this study as open-source software.
XPlacer/Tracer is a dynamic analysis tool that finds bad memory access patterns in heterogeneous codes. XPlacer/Tracer consists of two components. (1) A configurable ROSE plugin for source code instrumentation of heterogeneous code written in the C/C++ and CUDA programming languages. (2) A sample configuration that instruments memory accesses to dynamic memory in CPU and GPU codes, and a runtime library that tracks these memory accesses at runtime. The collected information is reported in form of a textual summary or as memory map that can be converted to images.
In 2025, LLVM released its first Flang Fortran compiler version considered ready for widespread evaluation. We know of no published assessment of Flang compiling a workload- derived portfolio of high-performance computing (HPC) applications. We address this gap using workload data from the National Energy Research Scientific Computing Center (NERSC), which supports more than 10,000 scientists on approximately 1,000 projects. The NERSC workload analyses identify many Fortran components in heavily used applications. We selected 10 such packages with available source code. We compiled them with Flang 22.1.3 on NERSC’s Perlmutter system. Six compiled without code modifications, though some required build-system changes. Three compiled after minor source edits, mostly to address Fortran standard violations. One built only without OpenMP enabled. We evaluated seven additional packages selected for their use of, or enablement of, standard Fortran parallel features: multi-image execution and do concurrent. Six such codes compiled with most or all unit tests passing.
CACTUS, developed by Sandia National Laboratories, is an open-source code for the design and analysis of wind and hydrokinetic turbines. While it has undergone extensive validation for both vertical axis and horizontal axis wind turbines, and it has been demonstrated to accurately predict the performance of horizontal (axial-flow) hydrokinetic turbines, its ability to predict the performance of crossflow hydrokinetic turbines has yet to be tested. The present study addresses this problem by comparing the predicted performance curves derived from CACTUS simulations of the U.S. Department of Energy’s 1:6 scale reference model crossflow turbine to those derived by experimental measurements in a tow tank using the same model turbine at the University of New Hampshire. It shows that CACTUS cannot accurately predict the performance of this crossflow turbine, raising concerns on its application to crossflow hydrokinetic turbines generally. The lack of quality data on NACA 0021 foil aerodynamic (hydrodynamic) characteristics over the wide range of angles of attack (AoA) and Reynolds numbers is identified as the main cause for poor model prediction. A comparison of several different NACA 0021 foil data sources, derived using both physical and numerical modeling experiments, indicates significant discrepancies at the high AoA experienced by foils on crossflow turbines. Users of CACTUS for crossflow hydrokinetic turbines are, therefore, advised to limit its application to higher tip speed ratios (lower AoA), and to carefully verify the reliability and accuracy of their foil data. Accurate empirical data on the aerodynamic characteristics of the foil is the greatest limitation to predicting performance for crossflow turbines with semi-empirical models like CACTUS. Future improvements of CACTUS for crossflow turbine performance prediction will require the development of accurate foil aerodynamic characteristic data sets within the appropriate ranges of Reynolds numbers and AoA.
Energy-related occupant behaviour is crucial to design and operation of energy and control systems in buildings. Occupant behaviours are often oversimplified as static schedules or settings in building performance simulation ignoring their stochastic nature. The continuous and dynamic interaction between occupants and building systems motivates their simultaneous simulation in an efficient manner. In the past, simultaneous simulation has relied on co-simulation approaches or customized source code changes to building simulation programmes. This paper presents Buildings. Occupants, an open-source package implemented in Modelica, for the simulation of occupant behaviours of lighting, windows, blinds, heating and air conditioning systems in office and residential buildings. Examples were presented to illustrate how the models in the Occupants package are capable to simulate stochastic occupant behaviours. Furthermore, the major contribution of this work is to introduce the equation-based modelling approach to simulate occupant behaviours in buildings and to develop an open-source Occupants package in the Modelica language.
PyFlot is a combination of python and C++ which aims at tuning floating point precision inside scientific applications. PyFloT uses link time interposition for portability and generality. The set of functions of interest are wrapped with code that enables either profiling or their lowering based on the classification criteria: SLOC (Source code LOCation) or backtrace. PyFloT implementation has only be validated using the GNU compiler toolchain.
The study of heat transfer and ablation plays an important role in many problems of scientific and engineering interest. As with the computational simulation of any physical phenomenon, the first step toward establishing credibility in ablation simulations involves code verification. Code verification is typically performed using exact and manufactured solutions. However, manufactured solutions generally require the invasive introduction of an artificial forcing term within the source code such that the code solves a modified problem for which the solution is known. In this paper, we present a nonintrusive method for manufacturing solutions for a non-decomposing ablation code, which does not require the addition of a source term.
Purpose: A computational toolkit (SPEKTR 3.0) has been developed to calculate x-ray spectra based on the tungsten anode spectral model using interpolating cubic splines (TASMICS) algorithm, updating previous work based on the tungsten anode spectral model using interpolating polynomials (TASMIP) spectral model. The toolkit includes a MATLAB (The Mathworks, Natick, MA) function library and improved user interface (UI) along with an optimization algorithm to match calculated beam quality with measurements. Methods: The SPEKTR code generates x-ray spectra (photons/mm{sup 2}/mAs at 100 cm from the source) using TASMICS as default (with TASMIP as an option) in 1 keV energy bins over beam energies 20–150 kV, extensible to 640 kV using the TASMICS spectra. An optimization tool was implemented to compute the added filtration (Al and W) that provides a best match between calculated and measured x-ray tube output (mGy/mAs or mR/mAs) for individual x-ray tubes that may differ from that assumed in TASMICS or TASMIP and to account for factors such as anode angle. Results: The median percent difference in photon counts for a TASMICS and TASMIP spectrum was 4.15% for tube potentials in the range 30–140 kV with the largest percentage difference arising in the low and high energy bins due to measurement errors in the empirically based TASMIP model and inaccurate polynomial fitting. The optimization tool reported a close agreement between measured and calculated spectra with a Pearson coefficient of 0.98. Conclusions: The computational toolkit, SPEKTR, has been updated to version 3.0, validated against measurements and existing models, and made available as open source code. Video tutorials for the SPEKTR function library, UI, and optimization tool are available.
Many materials, metal alloys in particular, have features on the on micrometer or nanometer scale that have a large impact on the properties of the material. These features are known as the microstructure of the material. Understanding why and how the microstructure forms in a material is of fundamental scientific interest as well as of significant technological interest. The capability to predict microstructure evolution in a material allows the intentional design of microstructures and hence the intentional design of material properties. The phase-field method is one of the leading methods for predicting microstructure evolution. One of the most significant problems for phase-field models is their computational expense. Even limited phase-field simulations can easily require thousands of CPU core-hours to complete, which significantly limits their use. This code provides both a general framework for creating scalable, GPU-accelerated phase-field model applications as well as several applications themselves. The code is capable of using hundreds of GPUs efficiently, which greatly reduces the time required to perform simulations. The code is written with an emphasis on performance portability, that is the ability for the code to run efficiently on a number of different computing architectures without modification of the source code. The performance portability of this code is primarily enabled through the use of two libraries, Kokkos (performance portable data structures and execution patterns) and heFFTe (performance portable distributed 3D fast Fourier transforms). The code consists of a core library, applications, and tests. The core library includes shared functionality between applications. This includes interfaces with fast Fourier transform (FFT) libraries such as heFFTe, data structures based on Kokkos, file input and output capabilities, and a solver for infinitesimal strain mechanical equilibrium problems. Five applications are included in the code. The flagship application is the MEUMAPPS-SS application, which implements the Kim-Kim-Suzuki phase-field model for precipitation for an arbitrary number of phases and components in a metal alloy. Five simpler applications are also included that solve the Eshelby inclusion problem, Allen-Cahn equation, the coupled Allen-Cahn and diffusion equations, and the Cahn-Hilliard equation. The code includes two applications to solve the Cahn-Hilliard equation, one with constant-step-size first-order time integration and the second with adaptive high-order time integration.
Top supercomputers in the TOP500 list have transitioned from homogeneous node architectures toward heterogeneous manycore nodes with accelerators and CPUs. These new architectures present significant challenges to developers of large-scale multiphysics applications, especially at DOE laboratories that have invested heavily in scalable MPI codes over decades. Much of these scientific application porting efforts for the new heterogeneous architectures are focused on running the computation on the accelerators, which usually comprise > 90% of the FLOPS of the system, typically using one core per GPU to offload work. Furthermore, we describe an approach to utilizing the remaining FLOPS on a heterogeneous machine by running a portion of the computation on the CPUs cooperatively with the GPU computation. Orthogonally, we evaluate using the additional cores to also offload work to GPUs, effectively oversubscribing the GPUs. We present a proof-of-concept implementation in ARES, a multiphysics ALE-AMR code at LLNL. ARES uses a portability layer, RAJA, which enables us to utilize the same source code for both the CPU and the GPU. We develop an approach to utilize both types of processors cooperatively in a heterogeneous system. Our implementation divides the work between the computing resources via domain decomposition, and utilizes all cores of the CPU and all of the GPUs on the node for computation. Load balancing is necessary to use the heterogeneous resources effectively. We present preliminary results on early delivery pre-Sierra machines at LLNL, showing up to 40% performance benefit of oversubscribing the GPUs (with caveats), and up to an 18% performance benefit of using the CPUs on the heterogeneous nodes for computing in addition to using the GPUs.
Traditionally, high energy physics (HEP) experiments have relied on x86 CPUs for the majority of their significant computing needs. As the field looks ahead to the next generation of experiments such as DUNE and the High-Luminosity LHC, the computing demands are expected to increase dramatically. To cope with this increase, it will be necessary to take advantage of all available computing resources, including GPUs from different vendors. A broad landscape of code portability tools—including compiler pragma-based approaches, abstraction libraries, and other tools—allow the same source code to run efficiently on multiple architectures. In this paper, we use a test code taken from a HEP tracking algorithm to compare the performance and experience of implementing different portability solutions. While in several cases portable implementations perform close to the reference code version, we find that the performance varies significantly depending on the details of the implementation. Achieving optimal performance is not easy, even for relatively simple applications such as the test codes considered in this work. Several factors can affect the performance, such as the choice of the memory layout, the memory pinning strategy, and the compiler used. The compilers and tools are being actively developed, so future developments may be critical for their deployment in HEP experiments.
The dataset includes computational fluid dynamics (CFD) models and simulation files for crossflow turbines as well as a detailed project report. The report documents the project undertaken by the Ocean Renewable Power Company (ORPC) to design and optimize a modular fairing for the Modular RivGen Marine Hydrokinetic (MHK) turbine, which enhances the efficient deployment and operation of turbine arrays. The project focused on optimizing the hydrodynamic performance of the fairing using CFD, with an emphasis on two key geometric parameters: the fairing's cross-sectional shape and the spacing between the rotor and the fairing. The analysis aimed to maximize net power output while also assessing discretized loading to evaluate ultimate and fatigue loads on the turbine components. The numerical modeling was conducted using both the commercial CFD software Star-CCM+ and the open-source code openFOAM, with the latter utilizing the actuator line library, turbinesFOAM. This dual-code approach was intended to increase confidence in the results and demonstrate the viability of using open-source tools for high-fidelity marine energy modeling. This dataset includes all necessary files for actuator line simulations in openFOAM, as well as 2D blade-resolved CFD results, along with Python and Java scripts for setting up and post-processing simulations.
Abstract Summary Although advances in untargeted metabolomics have made it possible to gather data on thousands of cellular metabolites in parallel, identification of novel metabolites from these datasets remains challenging. To address this need, Metabolic in silico Network Expansions (MINEs) were developed. A MINE is an expansion of known biochemistry which can be used as a list of potential structures for unannotated metabolomics peaks. Here, we present MINE 2.0, which utilizes a new set of biochemical transformation rules that covers 93% of MetaCyc reactions (compared to 25% in MINE 1.0). This results in a 17-fold increase in database size and a 40% increase in MINE database compounds matching unannotated peaks from an untargeted metabolomics dataset. MINE 2.0 is thus a significant improvement to this community resource. Availability and implementation The MINE 2.0 website can be accessed at https://minedatabase.ci.northwestern.edu. The MINE 2.0 web API documentation can be accessed at https://mine-api.readthedocs.io/en/latest/. The data and code underlying this article are available in the MINE-2.0-Paper repository at https://github.com/tyo-nu/MINE-2.0-Paper. MINE 2.0 source code can be accessed at https://github.com/tyo-nu/MINE-Database (MINE construction), https://github.com/tyo-nu/MINE-Server (backend web API) and https://github.com/tyo-nu/MINE-app (web app). Supplementary information Supplementary data are available at Bioinformatics online.
We present a case study of porting NekBone, a skeleton version of the Nek5000 code, to a parallel GPU-accelerated system. Nek5000 is a computational fluid dynamics code based on the spectral element method used for the simulation of incompressible flow. The original NekBone Fortran source code has been used as the base and enhanced by OpenACC directives. The profiling of NekBone provided an assessment of the suitability of the code for GPU systems, and indicated possible kernel optimizations. To port NekBone to GPU systems required little effort and a small number of additional lines of code (approximately one OpenACC directive per 1000 lines of code). The naïve implementation using OpenACC leads to little performance improvement: on a single node, from 16 Gflops obtained with the version without OpenACC, we reached 20 Gflops with the naïve OpenACC implementation. An optimized NekBone version leads to a 43 Gflop performance on a single node. In addition, we ported and optimized NekBone to parallel GPU systems, reaching a parallel efficiency of 79.9% on 1024 GPUs of the Titan XK7 supercomputer at the Oak Ridge National Laboratory.
The project developed a domain specific translator enable legacy MPI source code to tolerate communication delays, which are increasing over time due to technological factors. The translator performs source-to-source translation that incorporates semantic information into the translation process. The output of the translator is a C program runs as a data driven program, and uses an existing run time to overlap communication automatically