Engineering Papers⌕ Search

SEARCH · Engineering Papers

Results for “parallelization”

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.

At least 937 records · Page 52
All sourcesNASA NTRSDOE OSTI
DOE OSTI2024

Direct Numerical Simulation of Involute Channel Turbulence

A direct numerical simulation (DNS) study was performed on turbulent flow in the high flux isotope reactor involute channel geometry to develop a numerical database and determine the differences compared with a flat parallel channel. The varying channel curvature along the walls was studied for differences in mean profiles. Parameters of interest include streamwise velocity, turbulent kinetic energy (TKE), and turbulence dissipation rate, as well as Reynolds stresses and turbulence transport terms. Profile sampling was carried out at 10 locations along the span of the involute. Additional DNS studies were performed on smaller domains of comparable curvature to the involute domain: a high curvature channel (high circular), a low curvature channel (low circular), and a flat channel (flat). Here, each of these four cases was compared against each other and to other DNS studies performed on parallel flows. The results indicate that the bulk involute channel flow does not differ significantly from a flat parallel channel flow and that the curvature of the walls does not significantly alter the mean flow parameters. However, the regions of the involute channel near the side walls exhibit relatively low magnitude twin recirculation structures driven toward the side walls from the centerline of the channel, which warrants further study.

21 SPECIFIC NUCLEAR REACTORS AND ASSOCIATED PLANTS↗
DOE OSTI2024

Continental rift evolution and drainage reorganization along the Dead Sea rift since the Miocene

The Dead Sea fault is a section of the Arabian-African plate boundary. Widespread field relations indicate that three major drainage systems (stages) occupied the landscape west of the Dead Sea fault since its initiation at ca. 20 Ma. Specifically, (1) an early to middle Miocene drainage system, only minorly reconfigured by the fault (all sediments of this system belong to the Hazeva Formation); (2) a late Miocene to early Pleistocene fault-parallel drainage system named Paran-Neqarot (all sediments of this system belong to the Arava and Zehiha Formations; and (3) the early Pleistocene to present drainage configuration. The temporal and spatial frameworks of drainage stage 1 are generally constrained by radiometric dating of interfingering volcanic units, and the onset and temporal and spatial frameworks of drainage stage 3 are well constrained by cosmogenic 10 Be surface exposure ages. The timing and longevity of the rift-parallel drainage (stage 2) have until now been evasive to direct dating. The overall time gap between stages 1 and 3 is ~12–13 million years. Thus, an early age (within this time gap) of stage 2 would imply an immediate response of drainage reorganization to rift tectonics, while a later age of this drainage system would imply a delayed response. We present 11 10 Be- 26 Al cosmogenic burial ages of alluvial and colluvial units related to the fault-parallel drainage system (stage 2), which collectively constrain the time of deposition of the Arava Formation sediments in the central Negev to ca. 8 Ma. The general lack of stratigraphic order, together with the large dispersion of ages both across and within the sampling sites, attests to significant recycling of sediments from drainage stage 1 into the Arava Formation deposits. The termination of Arava and Zehiha Formation sediment deposition at ca. 1.8 Ma was determined previously using cosmogenic exposure ages of desert pavements that cover the formations. Combining the previously published data with our new data, we established the longevity and character of the Paran-Neqarot drainage system. In conlcusion, this framework highlights the temporal aspect of drainage system build-up and collapse as it responded to transform and extensional plate boundary tectonics during the Neogene.

58 GEOSCIENCES↗
DOE OSTI2020

A supernodal all-pairs shortest path algorithm

We show how to exploit graph sparsity in the Floyd-Warshall algorithm for the all-pairs shortest path (Apsp) problem. Floyd-Warshall is an attractive choice for Apsp on high-performing systems due to its structural similarity to solving dense linear systems and matrix multiplication. However, if sparsity of the input graph is not properly exploited, Floyd-Warshall will perform unnecessary asymptotic work and thus may not be a suitable choice for many input graphs. To overcome this limitation, the key idea in our approach is to use the known algebraic relationship between Floyd-Warshall and Gaussian elimination, and import several algorithmic techniques from sparse Cholesky factorization, namely, fill-in reducing ordering, symbolic analysis, supernodal traversal, and elimination tree parallelism. When combined, these techniques reduce computation, improve locality and enhance parallelism. We implement these ideas in an efficient shared memory parallel prototype that is orders of magnitude faster than an efficient multi-threaded baseline Floyd-Warshall that does not exploit sparsity. Our experiments suggest that the Floyd-Warshall algorithm can compete with Dijkstra's algorithm (the algorithmic core of Johnson's algorithm) for several classes sparse graphs.

Sao, Piyush↗
DOE OSTI2020

Toward Large-Scale Image Segmentation on Summit

Semantic segmentation of images is an important computer vision task that emerges in a variety of application domains such as medical imaging, robotic vision and autonomous vehicles to name a few. While these domain-specific image analysis tasks involve relatively small image sizes (~ 10 2 × 10 2 ), there are many applications that need to train machine learning models on image data with extents that are orders of magnitude larger (~10 4 × 10 4 ). Training deep neural network (DNN) models on large extent images is extremely memory-intensive and often exceeds the memory limitations of a single graphical processing unit, a hardware accelerator of choice for computer vision workloads. Here, an efficient, sample parallel approach to train U-Net models on large extent image data sets is presented. Its advantages and limitations are analyzed and near-linear strong-scaling speedup demonstrated on 256 nodes (1536 GPUs) of the Summit supercomputer. Using a single node of the Summit supercomputer, an early evaluation of a recently released model parallel framework called GPipe is demonstrated to deliver ~ 2X speedup in executing a U-Net model with an order of magnitude larger number of trainable parameters than reported before. Performance bottlenecks for pipelined training of U-Net models are identified and mitigation strategies to improve the speedups are discussed. Together, these results open up the possibility of combining both approaches into a unified scalable pipelined and data parallel algorithm to efficiently train U-Net models with very large receptive fields on data sets of ultra-large extent images.

Seal, Sudip↗
DOE OSTI2022

EQC: Ensembled Quantum Computing for Variational Quantum Algorithms

Variational quantum algorithms (VQA), which are comprised of a classical optimizer and a parameterized quantum circuit, emerges as one of the most promising approaches of harvesting quantum power in the noisy-intermediate-scale-quantum (NISQ) era. However, the deployment of VQAs on today's NISQ devices often faces considerable system noise and prohibitively slow training speeds. On the other hand, the expensive supporting sources and infrastructure make quantum computers extremely keen on high utilization. In this paper, we propose a novel way of thinking about a quantum backend: rather than relying on one physical device which tends to introduce platform-specific noise and bias, a quantum ensemble, which distributes quantum tasks across parallel devices, can serve as a virtualized quantum computer for offering reduced noise levels through an adaptive mixture and also provide significantly improved training speeds through parallelization. With this idea, we build a distributive VQA optimization framework called DVQA, serving as the first effort in adopting parallel quantum devices for cooperative VQA training. To further constraint noise and speed-up convergence, we design a model for individual NISQ devices concerning their properties and running conditions, and propose a weighting mechanism for regularizing the returned gradients. Extensive evaluations on 10 IBM-Q quantum devices using the VQE example show that the distributive VQA training framework can substantially boost the training speed by 10.5x on average (up to 86x and at least 5.2x) with improved training accuracy.

Stein, Samuel A.↗
DOE OSTI2022

Large Scale Caching and Streaming of Training Data for Online Deep Learning

The training of deep neural network models on large data remains a difficult problem, despite progress towards scalable techniques. In particular, there is a mismatch between the random but predetermined order in which AI flows select training samples and the streaming I/O patterns for which traditional HPC data storage (e.g., parallel file systems) are designed. In addition, as more data are obtained, it is feasible neither simply to train learning models incrementally, due to catastrophic forgetting (i.e., bias towards new samples), nor to train frequently from scratch, due to prohibitive time and/or resource constraints. In this paper, we study data management techniques that combine caching and streaming with rehearsal support in order to enable efficient access to training samples in both offline training and continual learning. We revisit state-of-art streaming approaches based on data pipelines that transparently handle prefetching, caching, shuffling, and data augmentation, and discuss the challenges and opportunities that arise when combining these methods with data-parallel training techniques. We also report on preliminary experiments that evaluate the I/O overheads involved in accessing the training samples from a parallel file system (PFS) under several concurrency scenarios, highlighting the impact of the PFS on the design of the data pipelines.

data pipelines↗
DOE OSTI2022

Automatic Differentiation of C++ Codes on Emerging Manycore Architectures with Sacado

Automatic differentiation (AD) is a well-known technique for evaluating analytic derivatives of calculations implemented on a computer, with numerous software tools available for incorporating AD technology into complex applications. However, a growing challenge for AD is the efficient differentiation of parallel computations implemented on emerging manycore computing architectures such as multicore CPUs, GPUs, and accelerators as these devices become more pervasive. In this work, we explore forward mode, operator overloading-based differentiation of C++ codes on these architectures using the widely available Sacado AD software package. In particular, we leverage Kokkos, a C++ tool providing APIs for implementing parallel computations that is portable to a wide variety of emerging architectures. Here we describe the challenges that arise when differentiating code for these architectures using Kokkos, and two approaches for overcoming them that ensure optimal memory access patterns as well as expose additional dimensions of fine-grained parallelism in the derivative calculation. We describe the results of several computational experiments that demonstrate the performance of the approach on a few contemporary CPU and GPU architectures. We then conclude with applications of these techniques to the simulation of discretized systems of partial differential equations.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2025

A Simple, Scalable Large Deformation Solid Mechanics Implementation in the MOOSE Framework

This article describes a large deformation solid mechanics solver implemented as part of the freely available and open source MOOSE finite element simulation framework. The article documents the choices made in developing the solid mechanics framework and describes novel formulations for the gradient operator and constitutive modeling framework made to simplify implementations of different coordinate systems, stabilized gradient operators, and different constitutive model inputs and outputs. In the process, the article describes a new formulation that casts objective integration of the Cauchy stress as a linear transformation of the small stress rate. Finally, the article presents key implementation details and examines the parallel efficiency of the solid mechanics solver implemented in MOOSE. The implementation retains a good weak scaling efficiency beyond 1,000 parallel processes. The article includes a discussion of the factors limiting the parallel efficiency of implicit, large deformation solid mechanics codes on current high-performance computers, with the main current limitation being the scalability of the algebraic multigrid methods used to solve the linearized equilibrium equations.

Applied computing → Computer-aided design↗
DOE OSTI2026

ChatMPI: LLM-Driven MPI Code Generation for HPC Workloads

The Message Passing Interface (MPI) standard plays a crucial role in enabling scientific applications for parallel computing and is an essential component in high-performance computing (HPC). However, implementing MPI code manually—especially applying a proper domain decomposition and communication pattern—is a challenging and error-prone task. We present ChatMPI, an AI assistant for MPI parallelization of sequential C codes. In our analysis, we focus on testing six essential HPC workloads, which are based on Basic Linear Algebra Subprograms levels 1, 2, and 3 as well as sparse, stencil, and iterative operations. We analyze the process of creating ChatMPI by using the ChatHPC library. This lightweight large language model (LLM)–based infrastructure enables HPC experts to efficiently create and supervise trustworthy AI capabilities for critical HPC software tasks. We study the data required for training (fine-tuning) ChatMPI to generate parallel codes that not only use MPI syntax correctly but also apply HPC techniques to reduce memory communication and maximize performance by using proper work decomposition. With a relatively small training dataset composed of a few dozen prompts and fewer than 15 minutes of fine-tuning on one node equipped with two NVIDIA H100 GPUs, ChatMPI elevates trustworthiness for MPI code generation of current LLMs (e.g., Code Llama, ChatGPT-4o and ChatGPT 5). Additionally, we evaluate the performance of the MPI codes generated by ChatMPI in comparison with the ones generated by ChatGPT-4o and ChatGPT-5. The codes generated by ChatMPI provide up to a 4 × boost in performance by using better problem decomposition, communication patterns, and HPC techniques (e.g., communication avoiding).

Valero Lara, Pedro [ORNL] (ORCID:0000000214794310)↗
DOE OSTI2025

Impact of Module Configuration on Lithium-Ion Battery Performance and Degradation: Part I. Energy Throughput, Voltage Spread, and Current Distribution

Batteries are commonly connected in series and parallel to create modules that fulfill the power and energy requirements of specific applications. However, conclusions about battery performance and degradation under different conditions, as well as predictive models, are often derived from single cell cycling results. In this study, we evaluate the performance of six different series-parallel configurations of commercial lithium nickel manganese cobalt cells over hundreds of cycles. Each cell within the modules was individually instrumented for voltage, current, and temperature monitoring. We quantified the impact of module configuration on overall energy throughput, the voltage spread among series-connected cells, and the current heterogeneity in parallel-connected cells. This module cycling study, one of the broadest reported to date, supports systematic evaluation of the performance trade-offs, pack penalty, and safety implications of different module configurations.

25 ENERGY STORAGE↗
DOE OSTI2021

ArborX

ArborX library tackles a problem of efficiently finding geometric objects that are close in space. Variations of this problem, such as finding the nearest neighbors of a point, or finding all objects within a certain distance, are inherent components of applications in many fields. The data may be large so that solving the problem efficiently may require significant computational resources, such as multiple processors or accelerators such as general purpose GPUs. ArborX' main advantage in its ability to solve large problems efficiently utilizing a combination of distributed and on-node parallelism. ArborX can be run efficiently on a wide variety of hardware, including GPUs from different vendors, which distinguishes it from other available libraries which typically choose only few of these. The other advantage is that it supports both types of user problems: spatial problems (useful for intersections and finding objects within certain distance), and nearest neighbor problems. ArborX also supports flexible interface in its interaction with a user. Particularly, it allows a user to call user's own function on a positive match, a functionality not rarely available in other libraries. ArborX implements construction and traversal algorithms using efficient tree structures, such as bounding volume hierarchy (BVH). At its core, it uses linear BVH for its low construction cost and sufficient quality. ArborX is written using C++, and is parallelized using the message passing interface (MPI) for the distributed communication, and the Kokkos library for on-node parallelism. This approach allows ArborX to be run on a wide variety of hardware, from common laptops and desktops to supercomputers while using the same codebase. ArborX also implements several advanced algorithms using geometric search, such as density-based clustering algorithm DBSCAN.

ECP↗
DOE OSTI2025

ArborX 2.0

ArborX library tackles a problem of efficiently finding geometric objects that are close in space. Variations of this problem, such as finding the nearest neighbors of a point, or finding all objects within a certain distance, are inherent components of applications in many fields. The data may be large so that solving the problem efficiently may require significant computational resources, such as multiple processors or accelerators such as general purpose GPUs. ArborX' main advantage in its ability to solve large problems efficiently utilizing a combination of distributed and on-node parallelism. ArborX can be run efficiently on a wide variety of hardware, including GPUs from different vendors, which distinguishes it from other available libraries which typically choose only few of these. The other advantage is that it supports both types of user problems: spatial problems (useful for intersections and finding objects within certain distance), and nearest neighbor problems. ArborX also supports flexible interface in its interaction with a user. Particularly, it allows a user to call user's own function on a positive match, a functionality not rarely available in other libraries. ArborX implements construction and traversal algorithms using efficient tree structures, such as bounding volume hierarchy (BVH). At its core, ArborX uses linear BVH for its low construction cost and sufficient quality. ArborX implements both spatial and nearest-neighbor traversal algorithms. ArborX also provides several clustering algorithms (minimum spanning tree, DBSCAN, HDBSCAN*), interpolation using minimum least squares and ray tracing. ArborX is written using C++, and is parallelized using the message passing interface (MPI) for the distributed communication, and the Kokkos library for on-node parallelism. This approach allows ArborX to be run on a wide variety of hardware, from common laptops and desktops to supercomputers while using the same codebase.

Prokopenko, Andrey [Oak Ridge National Laboratory ↗
DOE OSTI2021

Structural Simluation Toolkit (SST) v.11.0

The SST provides a parallel framework to perform system simulation of computer architectures to determine their performance and power consumption. Additionally, the SST contains basic models of a computer processor, and interconnect and can connect to an external memory simulator (DRAMSim II). The SST framework provides a simple interface by which other computer simulation models can be combined under a common parallel discrete event-based simulation environment. This allows design exploration of future architectures, analysis of how current computer programs will function on future architectures. The SST provides a parallel discrete event simulation framework, including partitioning and object distribution over MPI. It also provides a mechanism by which components can report their power consumption for analysis.

Rodrigues, ArunF.↗
DOE OSTI2022

AutoBEM-DynamicArchetypes

Automatic Building Energy Modeling (AutoBEM, https://bit.ly/AutoBEM) has been used to create an OpenStudio and EnergyPlus building energy model of 122.9 million U.S. buildings (https://bit.ly/ModelAmerica). Simulating and analyzing a model of every building for large areas (e.g. cities) is often not feasible. This dynamic archetyping capability uses a representative building and calculates a floor-space multiplier that allows millions of buildings to be represented by less than 100 buildings. This script (WRF_Archetypes_Parallel.py) calculates these building archetypes for each of the grid cells from a Weather Research and Forecasting (WRF) model in a parallel fashion. The script works by looping through each of the grid cells in the shapefile in parallel, spatially joining the building metadata table to each grid cell, aggregating relevant archetypes and calculating necessary statistics related to area and number of buildings in each cell. The output is a table (.csv) in which each row is an archetype building with properties about that building as well as statistics that relate that building to the total cell (such as an area multiplier). The following inputs are required: WRF zone shapefile (.shp) (wrf-grids-origin_Vegas_Select_100.geojson) The projection of the shapefile ("EPSG:XXXX") Input table containing building metadata for area corresponding to shapefile (.csv) (https://zenodo.org/record/4552901#.YZQEotDMJPY - ClarkCounty2.csv) The number of cores that will be parallelized (integer) The output file name for the archetype table (.csv) Sample command line inputs: python3 ~/WRF_Archetypes_Parallel.py -i ~/wrf-grids-origin_Vegas_Select_100.geojson -c ~/ClarkCounty2.csv -o ~/OutputArchetypes.csv -j 72 -e EPSG:4326 Using Geopandas Version 0.9.0

Bass, Brett (0000000240988434)↗
DOE OSTI2021

Optimization Plugin Library

The Optimization Plugin library ("op") is a lightweight general optimization solver interface. The primary purpose of op is to simplify the process of integrating different optimization solvers (serial or parallel) with scalable parallel physics engines. By design it has several features that help make this a reality. The core abstraction interface was developed to encompass a large class of optimization problems in an optimizer-agnostic way. This enables us to describe the optimization problem once and then use a variety of supported "op" optimizers with ideally no code-changes. The abstraction interface is made up of lightweight wrappers that make it easy to integrate with existing simulation codes. This makes integration less intrusive and should minimize changes to existing physics codes. The "op" interface includes an assortment of utility methods that help specify parallel communication patterns as well as methods to convert from optimization-specific interfaces to the more general "op" interface. Lastly a dynamic library linking interface is provided to allow for use of proprietary optimization engines without explicit reference in the source code, along with standard shared library interfaces for opensource engines.

Jekel, CharlesF↗
DOE OSTI2025

Homotopy Solver

This software implements parallel versions of an interior-point solver, based on the publicly available ipopt solver. Here we have full control over the linear solver and our algorithm is fully parallel thus enabling scalability to large-scale optimization problems. This package also has a parallel implementation of a homotopy solver developed under the scalable methods for contact LDRD project 23-ERD-017. This solver is an mfem-based implementation of algorithm described in ``A filter trust-region Newton continuation method for nonlinear complementarity problems''. Cosmin G. Petra, Nai-Yuan Chiang, Jingyi Wang, Tucker Hartland, and Michael Puso (submitted), LLNL-JRNL-869761.

Hartland, Tucker [Lawrence Livermore National Labo↗
DOE OSTI2026

HydraGNN v5.0

HydraGNN v5.0 expands the code base into a more portable, scalable, and flexible framework for scientific graph learning, with particular strength in atomistic machine-learning interatomic potentials and large-scale distributed training. The release adds Fully Sharded Data Parallel (FSDP) support alongside existing DDP and DeepSpeed paths, including FSDP-aware checkpointing and optimizer integration, and introduces a configurable multi-precision training workflow supporting FP32, BF16, and FP64 across GPUs and Intel XPUs. For atomistic modeling, HydraGNN v5.0 strengthens its MLIP capabilities through dynamic graph construction at every forward pass, energy-conserving force prediction via automatic differentiation, and per-atom energy loss formulations, while extending EGNN models to properly handle periodic boundary conditions. The release also broadens model expressiveness through graph-level attribute conditioning, adds new multi-task and model-parallel extensions such as MACE support and encoder/decoder branch optimization, and expands application coverage with integrated examples for datasets including OC25, Nabla2-DFT, QCML, Open Polymers 2026, and OPF. In parallel, HydraGNN v5.0 improves production readiness through performance optimizations for large-scale runs, stratified sampling and linear-regression preprocessing utilities, and tested installation scripts for DOE supercomputers including Frontier, Aurora, Perlmutter, and Andes. Overall, the release advances HydraGNN as a robust software platform for scalable graph neural networks across materials science, chemistry, and scientific machine learning workflows

Lupo Pasini, Massimiliano [Oak Ridge National Labo↗
DOE OSTI2021

The Shortwave Spectral Radiometer for Atmospheric Science: Capabilities and Applications from the ARM User Facility

Industry advances have greatly reduced the cost and size of ground-based shortwave (SW) sensors for the ultraviolet, visible, and near-infrared spectral ranges that make up the solar spectrum, while simultaneously increasing their ruggedness, reliability, and calibration accuracy needed for outdoor operation. These sensors and collocated meteorological equipment are an important part of the U.S. Department of Energy (DOE) Atmospheric Radiation Measurement (ARM) User Facility, which has supported parallel integrated measurements of atmospheric and surface properties for more than two decades at fixed and mobile sites around the world. The versatile capability of these ground-based measurements includes 1) rich spectral information required for retrieving cloud and aerosol microphysical properties, such as cloud phase, cloud particle size, and aerosol size distributions, and 2) high temporal resolution needed for capturing fast evolution of cloud microphysical properties in response to rapid changes in meteorological conditions. Here we describe examples of how ARM's spectral radiation measurements are being used to improve understanding of the complex processes governing microphysical, optical, and radiative properties of clouds and aerosol.

54 ENVIRONMENTAL SCIENCES↗