Search NASA⌕ Search

SEARCH · Search NASA

Results for “API”

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 325 records · Page 18
All sourcesNASA NTRSDOE OSTI
DOE OSTI2020

Caspian: A Neuromorphic Development Platform

Current neuromorphic systems often may be difficult to use and costly to deploy. There exists a need for a simple yet flexible neuromorphic development platform which can allow researchers to quickly prototype ideas and applications. Caspian offers a high-level API along with a fast spiking simulator to enable the rapid development of neuromorphic solutions. It further offers an FPGA architecture that allows for simplified deployment -- particularly in SWaP (size, weight, and power) constrained environments. Leveraging both software and hardware, Caspian aims to accelerate development and deployment while enabling new researchers to quickly become productive with a spiking neural network system.

Mitchell, Parker↗
DOE OSTI2023

A Backend-agnostic, Quantum-classical Framework for Simulations of Chemistry in C ++

As quantum computing hardware systems continue to advance, the research and development of performant, scalable, and extensible software architectures, languages, models, and compilers is equally as important to bring this novel coprocessing capability to a diverse group of domain computational scientists. For the field of quantum chemistry, applications and frameworks exist for modeling and simulation tasks that scale on heterogeneous classical architectures, and we envision the need for similar frameworks on heterogeneous quantum-classical platforms. Furthermore, we present the XACC system-level quantum computing framework as a platform for prototyping, developing, and deploying quantum-classical software that specifically targets chemistry applications. We review the fundamental design features in XACC, with special attention to its extensibility and modularity for key quantum programming workflow interfaces and provide an overview of the interfaces most relevant to simulations of chemistry. A series of examples demonstrating some of the state-of-the-art chemistry algorithms currently implemented in XACC are presented, while also illustrating the various APIs that would enable the community to extend, modify, and devise new algorithms and applications in the realm of chemistry.

37 INORGANIC, ORGANIC, PHYSICAL, AND ANALYTICAL CH↗
DOE OSTI2022

Performance Analysis of Speculative Parallel Adaptive Local Timestepping for Conservation Laws

Stable simulation of conservation laws, such as those used to model fluid dynamics and plasma physics applications, requires the satisfaction of the so-called Courant-Friedrichs-Lewy condition. By allowing regions of the mesh to advance with different timesteps that locally satisfy this stability constraint, significant work reduction can be attained when compared to a time integration scheme using a single timestep size. However, parallelizing this algorithm presents considerable difficulty. Since the stability condition depends on the state of the system, dependencies become dynamic and potentially non-local. In this article, we present an adaptive local timestepping algorithm using an optimistic (Timewarp-based) parallel discrete event simulation. We introduce waiting heuristics to limit misspeculation and a semi-static load balancing scheme to eliminate load imbalance as parts of the mesh require finer or coarser timesteps. Last, we outline an interface for separating the physics of the specific conservation law from the temporal integration allowing for productive adoption of our proposed algorithm. We present a misspeculation study for three conservation laws, demonstrating both the productivity of the local timestepping API, for which 74% of the lines of code are reused across different conservation laws, and the robustness of the waiting heuristics—at most 1.5% of element updates are rolled back. Our performance studies demonstrate up to a 2.8× speedup versus a baseline unoptimized local timestepping approach, a 4x improvement in per-node throughput compared to an MPI parallelization of synchronous timestepping, and scalability up to 3,072 cores on NERSC’s Cori Haswell partition.

97 MATHEMATICS AND COMPUTING↗
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 OSTI2023

Optimizing Irregular Communication with Neighborhood Collectives and Locality-Aware Parallelism

Irregular communication often limits both the performance and scalability of parallel applications. Typically, applications individually implement irregular communication as point-to-point, and any optimizations are integrated directly into the application. As a result, these optimizations lack portability. It is difficult to optimize point-to-point messages within MPI, as the interface for single messages provides no information on the collection of all communication to be performed. However, the persistent neighbor collective API, released in the MPI 4 standard, provides an interface for portable optimizations of irregular communication within MPI libraries. This paper presents methods for implementing existing optimizations for irregular communication within neighborhood collectives, analyzes the impact of replacing point-to-point communication in existing codebases such as Hypre BoomerAMG with neighborhood collectives, and finally shows up to a 1.38x speedup on sparse matrix-vector multiplication communication within a BoomerAMG solve through the use of our optimized neighbor collectives. Here, the authors analyze three implementations of persistent neighborhood collectives for Alltoallv: an unoptimized wrapper of standard point-to-point communication, and two locality-aware aggregating methods. The second locality-aware implementation exposes an non-standard interface to perform additional optimization, and the authors present the additional 0.07x speedup from the extended interface. All optimizations are available in an open-source codebase, MPI Advance, which sits on top of MPI, allowing for optimizations to be added into existing codebases regardless of the system MPI install.

AMG↗
DOE OSTI2023

Cross-Facility Orchestration of Electrochemistry Experiments and Computations

Instrument-computing ecosystems supporting automated electrochemical workflows typically require the integration of disparate instruments such as syringe pump, fraction collector, and potentiostat, all connected to an electrochemical cell. These specialized instruments with custom software and interfaces are not typically designed for network integration and remote automation. We developed a networked ecosystem of these instruments and computing platforms, which includes software to enable automated workflow orchestration from remote computers. Specifically, we developed Python wrappers of APIs and custom Pyro client-server modules to support remote operation of these instruments over the ecosystem network. Herein, we describe a specific workflow for generating and validating voltammogram (I-V) measurements of an electrolyte solution pumped into the electrochemical cell. We demonstrate the orchestration of this workflow which is composed using a Jupyter notebook and executed on a remote computer.

Al Najjar, Anees↗
DOE OSTI2025

Streaming Data in HPC Workflows Using ADIOS

The “IO Wall” problem, in which the gap between computation rate and data access rate grows continuously, poses significant problems to scientific workflows which have traditionally relied upon using the filesystem for intermediate storage between workflow stages. One way to avoid this problem in scientific workflows is to stream data directly from producers to consumers and avoiding storage entirely. However, the manner in which this is accomplished is key to both performance and usability. This paper presents the Sustainable Staging Transport, an approach which allows direct streaming between traditional file writers and readers with few application changes. SST is an ADIOS “engine”, accessible via standard ADIOS APIs, and because ADIOS allows engines to be chosen at run-time, many existing file-oriented ADIOS workflows can utilize SST for direct application-to-application communication without any source code changes. This paper describes the design of SST and presents performance results from various applications that use SST, for feeding model training with simulation data with substantially higher bandwidth than the theoretical limits of Frontier’s file system, for strong coupling of separately developed applications for multiphysics multiscale simulation, or for in situ analysis and visualization of data to complete all data processing shortly after the simulation finishes.

Podhorszki, Norbert [ORNL] (ORCID:000000019647542X↗
DOE OSTI2018

Simulation INsight and Analysis

Sina is a tool set for modern scientific data management that provides flexible, light-weight support of non-bulk data capture for retention in and queries against SQL and noSQL data stores. HPC simulations traditionally maintain their data in files. Extracting data of interest for subsequent analysis then requires the time-consuming process of traversing directories and scraping data from files in a variety of formats. Sina facilitates capturing relevant data during execution or post-processing of simulation runs for retention in and queries from a modern data store. The tools are sufficiently general to allow for the inclusion of new fields as scientists learn more about their data. Libraries, currently in C++ and Python, and a command line interface (CLI) are provided. Sina's flexibility starts with a general schema, in JSON, for the collection of non-bulk simulation data. JSON provides a flexible, human-readable representation of the data that of interest. Sina currently has a C++ library for simulations to write data to and read from a schema-compliant file for subsequent ingestion into one of the supported data stores. However, applications are free to write their data directly into a schema-compliant file. Python packages provide data ingestion, management, query, and export capabilities. A command line interface (CLI) provides simplified access to these features. A common application programming interface (API) is used to maintain and query data in any of the supported data stores, which are currently limited to SQL and Apache Cassandra (a column store). Tutorials, demonstrations, and examples illustrate aspects of the process using scripts and Jupyter notebooks.

Pauli, EstebanT↗
DOE OSTI2019

General Interaction Data Interface

The General Interaction Data Interface (GIDI) is a C++ API that reads and writes nuclear reaction data stored in the General Nuclear Data Structure (GNDS). GNDS is a new "format" for storing nuclear reaction data developed by the Working Party on Evaluation Co-operation (OECD/NEA/WPEC) Subgroup 38. GNDS can store evaluated nuclear data as well as nuclear data processed for deterministic (multi-group) and Monte Carlo transport. GIDI handles and provides accesses to all forms of the GNDS nuclear data. For multi-group data, GIDI provides functions to sum the data over all reactions. It also has functions for collapsing multi-group data to a small subset of groups and can transport correct multi-group data using the Pendlebury/Underhill formalism. The GNDS definition supports data for a PROjectile hitting a TARget for a given Evaluation. In GIDI this is called a PROTARE. For example, a neutron hitting O-16 from the ENDF/B-VIII.0 evaluation. To support a collection of protares, GIDI adds a Map class. The map class reads in a "map" file which specifies a list of projectile/target/evalaution's and their associated protare files. With a map instance, a user can request a specific projectile/target/evaluation and the map instance will return the requested protare.

Beck, Bret↗
DOE OSTI2019

Broker for Assimilation, Synthesis and Integration of eNvironmental Diverse, Distributed Datasets v1.1.0

BASIN-3D (Broker for Assimilation, Synthesis and Integration of eNvironmental Diverse, Distributed Datasets) uses a data brokering approach to synthesize diverse earth science data from a variety of remote sources in real-time without the need for additional storage. BASIN-3D is an extendable Django web framework application using a generalized data synthesis model that makes the synthesized data available via REpresentational State Transfer (REST) Application Programming Interface (API). We have currently implemented our data synthesis model to represent sensor-based time series earth science observations across a hierarchy of spatial locations. Supporting our data synthesis model is a plugin framework that allows developers to map data sources of interest to the BASIN-3D synthesis model

Varadharajan, Charuleka↗
DOE OSTI2019

ServiceNow/CrayPort Integration v2.1.5

The National Energy Research Scientific Computing Center (NERSC) is the primary scientific computing facility for the Office of Science in the U.S. Department of Energy. NERSC houses top-ranked Cray supercomputers, and our staff works very closely with on-site Cray engineers, submitting 75 Cray cases per month on average. Until recently, submitting a Cray case was only possible by phone or email, and all subsequent updates were delivered manually. This process led to delays, errors during manual data entry, and greatly increased incident processing and resolution time. In 2018, NERSC deployed an API-based bidirectional integration that allowed to submit and update Cray cases directly from our Incident Management platform, thus streamlining our 24x7 operations and enhancing communication between our engineering teams. This solution is applicable to any Incident Management platform.

Gens, Daniel↗
DOE OSTI2020

DEPRECATED EVOLVE [SWR-20-79]

DEPRECATED This repository was archived by the owner on Jun 30, 2026. It is now read-only. EVOLVE is a combination of a dashboard developed in React, which enables user to visualize the net load evolution with emerging technologies such as PV, energy storage, and electric vehicles, and a Python backend processes data. A user can choose settings for solar, energy storage, and electric vehicles in the dashboard. Modules that are developed to model the impact of these DERs can also be used independently without being integrated into the dashboard. We used a RESTful API to expose these modules to the React front-end.

Duwadi, Kapil↗
DOE OSTI2019

Pressio

Reduced-order Models (ROMs). ROMs are "compressed" approximations of high-fidelity computational models. Implementing ROM methods in production codes is typically intrusive, i.e. the native codes must be adapted and modified, with individual ROM methods reimplemented in every application code. This clearly constitutes an obstacle to users who want to use ROMs. To address this, we have developed Pressio, which is a C++ header-only ROM library that can be used by an application code in a non-intrusive fashion. The main objectives behind the design of Pressio are: (a) support for general computational models (data structures, PDE types); (b) heterogeneous hardware (CPU, GPU); (c) performance; and (d) extensibility. Using metaprogramming techniques, Pressio detects and leverages the application?s native linear algebra data structures (e.g. vector and matrix) to run the ROM methods. The application only needs to expose the velocity vector and Jacobian matrix via an adapter class. Pressio checks at compile time that the target application meets the correct API. The library is structured in several modular packages including (a) non-linear least-square solvers (e.g. Gauss-Newton with and without line-search); (b) singular value decomposition (for the computation of the ROM generalized coordinates) and (c) algebraic hyper-reduction.SAND2019-5878 M

Blonigan, Patrick↗
DOE OSTI2020

chimes_calculator

The Chebyshev Interaction Model for Efficient Simulation (ChIMES) is a machine-learned interatomic potential targeting chemistry in condensed phase systems. ChIMES models are able to approach quantum-accuracy through a systematically improvable explicitly many-bodied basis comprised of linear combinations of Chebyshev polynomials. Though originally developed as to enable description of organic molecular materials, ChIMES has successfully been applied to systems spanning ambient water to molten carbon, and leveraged as correction for density functional based tight binding simulations. The ChIMES calculator comprises a flexible toolset for evaluating ChIMES interactions (e.g. in simulations, single point calculations, etc). Users have the option of directly imbedding the ChIMES calculator within their codes, or evaluating interactions through the beginner-friendly serial interface, each of which have Python, C++, C, and Fortran API's.

Goldman, Nir↗
DOE OSTI2020

Saloon

Saloon is a Vim plugin that simplifies Python code linter / fixer configuration and usage. Saloon's menu lets developers toggle which static analysis tools to use and delegates those changes to ALE's (Asynchronous Lint Engine) API. Since prospector (python linter aggregate) already handles multiple tools, and is integrated with ALE, most of the actual linting will initially be handled via prospector calls.

Bloss, DavidK.↗
DOE OSTI2021

fvGP v2.2.0

fvGP is a flexible Gaussian process API that enables gpCAM, a software recently submitted, to do uncertainty quantification and steer data acquisition autonomously. In short, given a bunch of data, fvGP can find the most likely model creating the data and the model's uncertainty.

Noack, Marcus↗
DOE OSTI2020

Consistent Space Runtime (CSPACER) v1.0

This software provides a runtime for communication-bound applications, especially with irregular communication patterns. The target programming abstraction for the runtime is the space consistency model, which defines consistency guarantees at the granularity of memory spaces. This model has relaxed consistency semantics that enables a wide range of runtime optimizations. The runtime leverages threading to accelerate communication primitives, especially collective operations. It also allows efficient pipelining of communication operations and enable constructing a consistent state of multiple unordered communication activities targeting a memory space. The runtime uses a reduced API design that decomposes complex communication primitives in traditional general-purpose runtime into a sequence of simpler steps. To improve the productivity of using this runtime, we provide communication patterns commonly used for regular scientific computing applications and irregular data analytics. These communication patterns offer skeletons for the integration with application computation to allow efficient overlap.

Ibrahim, Khaled↗
DOE OSTI2021

Adapter Python IO (Adapter) v1.0

The Adapter Python IO software, in short Adapter or the Adapter software, encapsulates certain Python IO capabilities used for loading in and writing out data when performing analytical Python code runs. More specificcally, it provides a Python API to load data tables from various formats such as XLSX (MS Excel), CSV, and database, into Python code as Pandas DataFrames, as well as to write out tables into a database or CSV files. The Adapter software standardizes a way to point the code to one or multiple input files of one or multiple formats. Therefore, its main feature is the ability to convert data tables identified in one main and, optionally, one or more additional input files, into database tables and Pandas DataFrames for downstream usage in any compatible software. In addition to the loading capability, an instance of the Adapter IO object has the capability to write data out. If the write capability is invoked, all loaded tables are written as either a single database or a set of CSV files, or both, to a location specified in the dedicated input table.

Grahovac, Milica↗