Search NASA⌕ Search

SEARCH · Search NASA

Results for “Python implementation”

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 667 records · Page 37

Evaluation and development of surface layer scheme representation of temperature inversions over boreal forests in Arctic wintertime conditions

Abstract. In this study, the Noah land surface model used in conjunction with the Mellor–Yamada–Janjić surface layer scheme (hereafter, Noah-MYJ) and the Noah multiphysics scheme (Noah-MP) from the Weather Research and Forecasting (WRF) 4.5.1 mesoscale model are evaluated with regard to their performance in reproducing positive temperature gradients over forested areas in the Arctic winter. First, simplified versions of the WRF schemes, recoded in Python, are compared with conceptual models of the surface layer in order to gain insight into the dependence of the temperature gradient on the wind speed at the top of the surface layer. It is shown that the WRF schemes place strong limits on the turbulent collapse, leading to lower surface temperature gradient at low wind speeds than in the conceptual models. We implemented modifications to the WRF schemes to correct this effect. The original and modified versions of Noah-MYJ and Noah-MP are then evaluated compared to long-term measurements at the Ameriflux Poker Flat Research Range, a forest site in interior Alaska. Noah-MP is found to perform better than Noah-MYJ because the former is a two-layer model which explicitly takes into account the effect of the forest canopy. Indeed, a non-negligible temperature gradient is maintained below the canopy at high wind speeds, leading to overall larger gradients than in the absence of vegetation. Furthermore, the modified versions are found to perform better than the original versions of each scheme because they better reproduce strong temperature gradients at low wind speeds.

Geology↗

RouteE: A Vehicle Energy Consumption Prediction Engine

The emergence of connected and automated vehicles and smart cities technologies create the opportunity for new mobility modes and routing decision tools, among many others. To achieve maximum mobility and minimum energy consumption, it is critical to understand the energy cost of decisions and optimize accordingly. The Route Energy prediction model (RouteE) enables accurate estimation of energy consumption for a variety of vehicle types over trips or sub-trips where detailed drive cycle data are unavailable. Applications include vehicle route selection, energy accounting and optimization in transportation simulation, and corridor energy analyses, among others. The software is a Python package that includes a variety of pre-trained models from the National Renewable Energy Laboratory (NREL). However, RouteE also enables users to train custom models using their own data sets, making it a robust and valuable tool for both fast calculations and rigorous, data-rich research efforts. The pre-trained RouteE models are established using NREL’s Future Automotive Systems Technology Simulator paired with approximately 1 million miles of drive cycle data from the Transportation Secure Data Center, resulting in energy consumption behavior estimates over a representative sample of driving conditions for the United States. Validations have been performed using on-road fuel consumption data for conventional and electrified vehicle powertrains. Transferring the results of the on-road validation to a larger set of real-world origin-destination pairs, it is estimated that implementing the present methodology in a green-routing application would accurately select the route that consumes the least fuel 90% of the time. The novel machine learning techniques used in RouteE make it a flexible and robust tool for a variety of transportation applications.

33 ADVANCED PROPULSION SYSTEMS↗

RAVEN, a New Software for Dynamic Risk Analysis

RAVEN is a generic software driver to perform parametric and probabilistic analysis of code simulating complex systems. Initially developed to provide dynamic risk analysis capabilities to the RELAP-7 code [1] is currently being generalized with the addition of Application Programming Interfaces (APIs). These interfaces are used to extend RAVEN capabilities to any software as long as all the parameters that need to be perturbed are accessible by inputs files or directly via python interfaces. RAVEN is capable to investigate the system response probing the input space using Monte Carlo, grid strategies, or Latin Hyper Cube schemes, but its strength is its focus toward system feature discovery like limit surfaces separating regions of the input space leading to system failure using dynamic supervised learning techniques. The paper will present an overview of the software capabilities and their implementation schemes followed by same application examples.

97 MATHEMATICS AND COMPUTING↗

LANL Nuclear Data Manager Format Specification v1.0

The LANL nuclear data manager tool is a Python utility that downloads nuclear data from the Nuclear Data Team’s website at https://nucleardata.lanl.gov, arranges it, and configures directory listings for nuclear codes such as the MCNP code to consume. In this document, the Version 1.0 API that this tool relies on will be discussed, which will show how an external provider of nuclear data could set up their website to provide a compatible implementation.

97 MATHEMATICS AND COMPUTING↗

User’s Manual for Seal_Flux: A Seal Barrier Reduced-Order Model (Update)

This report provides a brief description on the use of the Seal_Flux computer program developed as part of the effort to quantify the risk of geologic storage of carbon dioxide (CO 2 ) under the U.S. Department of Energy’s (DOE) National Risk Assessment Partnership (NRAP). The Seal_Flux code simulates the flow of CO 2 through a low permeability rock horizon or seal formation overlying the storage reservoir into which CO 2 is injected. A two-phase, relative permeability approach with Darcy’s law is used for one-dimensional (1D) flow computations of CO 2 through the horizon in the vertical direction. The code also allows the simulation of time-dependent processes that can influence such flow. However, as part of its design, Seal_Flux is what can be termed a “reduced-order model” (ROM) and is not intended as a full-functioning flow code. The theory and simulation in the code is streamlined and directed towards the implementation of Monte Carlo risk analyses of CO 2 transport or as termed in this context as “leakage.” While presented in this report as a stand-alone tool, the Seal_Flux code is intended to function in the future as one of several models as part of an integrated, systems-level model of CO 2 storage performance. Finally, the code is written in Python 3.10 to provide an open framework for further development by others and to assist in linking the code with other modules in an integrated assessment model.

58 GEOSCIENCES↗

PCAfold 2.0—Novel tools and algorithms for low-dimensional manifold assessment and optimization

We describe an update to our open-source Python package, PCAfold, designed to help researchers generate, analyze and improve low-dimensional data manifolds. In the current version, PCAfold 2.0, we introduce novel tools and algorithms for assessing and optimizing low-dimensional manifolds. This includes a method that generates a “map” of local feature sizes that can help pinpoint researchers to problematic regions on a manifold. We introduce a novel cost function that characterizes the quality of a manifold topology with a single number. We develop two algorithms for feature selection based on principal component analysis (PCA) that use the cost function as an objective function to minimize. We introduce a quantity of interest (QoI)-aware dimensionality reduction strategy where data projections are computed using an artificial neural network and are directly optimized towards representing various projection-independent and projection-dependent QoIs. We also introduce an implementation of partition of unity networks (POUnets) for efficient reconstruction of QoIs from low-dimensional manifolds based on combining neural network classification with localized polynomial regression. Our software can be broadly applicable in all domains of science and engineering that aim to reduce data dimensionality, as well as in the fundamental research on representation learning.

97 MATHEMATICS AND COMPUTING↗

Investigating the application of Kalman Filters for real-time accountancy in fusion fuel cycles

Here tritium accountancy in the fusion fuel cycle is a significant concern for the operation of commercial devices. It is expected that a limit on the maximum amount of tritium inventory in the system will be implemented, meaning that accountancy of the tritium inventory in the fuel cycle will need to be as accurate as possible. This is difficult since not all locations along the fuel cycle can benefit from the implementation of a tritium accountancy sensor and measurements will inherently contain error. Commercial fusion plants will also operate continuously, challenging current accountancy techniques that rely on static processes in well-controlled environments. In this paper a simple fusion fuel cycle concept is defined and the tritium inventory over time of each component is modelled using the Euler Approximation of a series of differential Equations in Python. This information is then used to simulate sensor measurements at specific points on the fuel cycle and then passed through a Kalman Filter (KF) to improve the accuracy of the true measurement of the sensors.

70 PLASMA PHYSICS AND FUSION TECHNOLOGY↗

ThinCurr: An open-source 3D thin-wall eddy current modeling code for the analysis of large-scale systems of conducting structures

In this paper we present a new thin-wall eddy current modeling code, ThinCurr, for studying inductively-coupled currents in 3D conducting structures -- with primary application focused on the interaction between currents flowing in coils, plasma, and conducting structures of magnetically-confined plasma devices. The code utilizes a boundary finite element method on an unstructured, triangular grid to accurately capture device structures. The new code, part of the broader Open FUSION Toolkit, is open-source and designed for ease of use without sacrificing capability and speed through a combination of Python, Fortran, and C/C++ components. Scalability to large models is enabled through use of hierarchical off-diagonal low-rank compression of the inductance matrix, which is otherwise dense. Ease of handling large models of complicated geometry is further supported by automatic determination of supplemental elements through a greedy homology approach. Here, a detailed description of the numerical methods of the code and verification of the implementation of those methods using cross-code comparisons against the VALEN code and Ansys commercial analysis software is shown.

70 PLASMA PHYSICS AND FUSION TECHNOLOGY↗

Deeplynx Airflow Provider Package

The DeepLynx Airflow Provider Package is a python package used to interact with the data warehouse DeepLynx when using the workflow orchestration tool Apache Airflow. This python package is packaged together using the airflow package standard so that it can be easily installed and used in any Apache Airflow environment. This package is meant to encapsulate the DeepLynx API for use in Airflow so that any interactions with DeepLynx that a user may want to use in their Airflow workflow can be easily accomplished using this provider package. This allows us to develop, implement, and test our DeepLynx-Airflow interactions in one provider package repository, and then easily install and use this package in any airflow instance. This DeepLynx Airflow Provider Package will be used extensively by the DeepLynx DAG repository.

Cavaluzzi, JackM↗

Pyomo : Python Optimization Modeling Objects.

The Python Optimization Modeling Objects (Pyomo) package [1] is an open source tool for modeling optimization applications within Python. Pyomo provides an objected-oriented approach to optimization modeling, and it can be used to define symbolic problems, create concrete problem instances, and solve these instances with standard solvers. While Pyomo provides a capability that is commonly associated with algebraic modeling languages such as AMPL, AIMMS, and GAMS, Pyomo's modeling objects are embedded within a full-featured high-level programming language with a rich set of supporting libraries. Pyomo leverages the capabilities of the Coopr software library [2], which integrates Python packages (including Pyomo) for defining optimizers, modeling optimization applications, and managing computational experiments. A central design principle within Pyomo is extensibility. Pyomo is built upon a flexible component architecture [3] that allows users and developers to readily extend the core Pyomo functionality. Through these interface points, extensions and applications can have direct access to an optimization model's expression objects. This facilitates the rapid development and implementation of new modeling constructs and as well as high-level solution strategies (e.g. using decomposition- and reformulation-based techniques). In this presentation, we will give an overview of the Pyomo modeling environment and model syntax, and present several extensions to the core Pyomo environment, including support for Generalized Disjunctive Programming (Coopr GDP), Stochastic Programming (PySP), a generic Progressive Hedging solver [4], and a tailored implementation of Bender's Decomposition.

99 GENERAL AND MISCELLANEOUS↗

Neutron Scattering Experiment Automation with Python

The Spallation Neutron Source (SNS) at Oak Ridge National Laboratory currently holds the Guinness World Record as the world most powerful pulsed spallation neutron source. Neutrons scattered off atomic nuclei in a sample yield important information about the position, motions, and magnetic properties of atoms in materials. A neutron scattering experiment usually involves sample environment control (temperature, pressure, etc.), mechanical alignment (slits, sample and detector position), magnetic field controllers, neutron velocity selection (choppers) and neutron detectors. The SNS Data Acquisition System (DAS) consists of real-time sub-system (detector read-out with custom electronics, chopper interface), data preprocessing (soft real-time) and a cluster of control and ancillary PCs. The real-time system runs FPGA firmware and programs running on PCs (C++, LabView) typically perform one task such as motor control and communicate via TCP/IP networks. PyDas is a set of Python modules that are used to integrate various components of the SNS DAS system. It enables customized automation of neutron scattering experiments in a rapid and flexible manner. It provides wxPython GUIs for routine experiments as well as IPython command line scripting. Matplotlib and numpy are used for data presentation and simple analysis. We will present an overview of SNS Data Acquisition System and PyDas architectures and implementation along with the examples of use. We will also discuss plans for future development as well as the challenges that have to be met while maintaining PyDas for 20+ different scientific instruments.

72 PHYSICS OF ELEMENTARY PARTICLES AND FIELDS↗

JaqalPaq v.1.1

Jaqal-pup (Jaqal Programming Utilities Project) is a high-level Python metaprogramming interface for Jaqal, a quantum programming language for near-term quantum hardware (see https://arxiv.org/abs/2003.09382 for a description of Jaqal). In addition to parsing and writing out Jaqal programs, it includes the ability to read in and write out quantum programs in other languages and frameworks, e.g. Qiskit (IBM), Quil (Rigetti), Cirq (Google), Q# (Microsoft), ProjectQ (ETH Zurich), and tket (Cambridge Quantum Computing). It implements a gate scheduler, an emulator of a small-scale quantum computer programmed using Jaqal, and tie-ins for other simulation back-ends. SAND2020-12710 M Sandia National Laboratories is a multimission laboratory managed and operated by National Technology & Engineering Solutions of Sandia, LLC, a wholly owned subsidiary of Honeywell International Inc., for the U.S. Department of Energy’s National Nuclear Security Administration under contract DE-NA0003525.

Russo, Antonio↗

Tools for Assessing Performance: FY23-Q1 Report [Slides]

LANL was tasked with working with NREL to implement QUIC within the TAP API by the end of Q1, FY2023. If QUICURB cannot be implemented in a way that it can be run outside of the QUIC platform, there will be no further R&D funding for QUIC development. QUIC includes a graphical user interface that imports and preprocesses the various input data streams (3D building databases, ambient wind, vegetation, etc.) and writes them in a format that the QUICURB Fortran executable requires. In order to interface with the TAP API, a Python script was developed that would replace the functionality previously only available within QUICGUI. LANL worked with NREL to test the Python script to ensure that it was operation and fulfilled the requirements.

58 GEOSCIENCES↗

SPEARS: A Database-Invariant Spectral modeling API

The Spectral Physics Environment for Advanced Remote Sensing (SPEARS) application programming interface (API) is a Python-based, line-by-line, local thermal equilibrium (LTE) spectral modeling code which is optimized for simultaneously synthesizing optical spectra from any combination of fundamental spectroscopic databases. In this article, we contribute two novel spectral modeling techniques to the scientific literature. First we describe how SPEARS integrates a physics-based collisional model for calculating pressure broadening in the absence of available broadening coefficients. With this collisional model implementation, a generalized approach to fundamental spectroscopic databases can be achieved across multiple databases. We also detail our adaptive grid mesh algorithm developed to make the code scalable for simulating large spectral bandwidths at high spectral fidelity using intuitive grid parameters. Here, we present comparisons to other modeling tools, experiments, and provide a discussion on the SPEARS user interface.

47 OTHER INSTRUMENTATION↗

A JSON to CMake tool

As part of the conversion of the MCNP®testing system to CTest, a tool was needed to generate CMake variables from JSON formatted data structure. The system was first implemented using the JSON to CMake parser which with some slight modifications provided data useful for the MCNP CTest testing system. Upon further evaluation, we found it to be slow when setting up the 1600 tests during the CMake configuration step. Not only was it slow, it did not validate the JSON files during configuration allowing for unexpected behavior. Upon some web searching we came across a simple recursive python example that would provide the same capability needed by our testing system. This python example was effectively wrapped into a single python script that was used to convert the JSON data into CMake variables. This tool is attached as json_to_cmake.py and is listed in the appendix. In essence, the tool provides single variables for each value defined within the JSON file. The name for the variable is constructed by using the associated object names and array indicies needed to deference the variable itself. In the following sections, examples are provided to better describe how this is done.

97 MATHEMATICS AND COMPUTING↗

NGPINT V3: a containerized orchestration Python software for discovery of next-generation protein–protein interactions

Abstract Summary Batch yeast two-hybrid (Y2H) assays, leveraged with next-generation sequencing, have afforded successful innovations for the analysis of protein–protein interactions. NGPINT is a Conda-based software designed to process the millions of raw sequencing reads resulting from Y2H–next-generation interaction screens. Over time, increasing compatibility and dependency issues have prevented clean NGPINT installation and operation. A system-wide update was essential to continue effective use with its companion software, Y2H-SCORES. We present NGPINT V3, a containerized implementation built with both Singularity and Docker, allowing accessibility across virtually any operating system and computing environment. Availability and implementation This update includes streamlined dependencies and container images hosted on Sylabs (https://cloud.sylabs.io/library/schuyler/ngpint/ngpint) and Dockerhub (https://hub.docker.com/r/schuylerds/ngpint), facilitating easier adoption and integration into high-throughput and cloud-computing workflows. Full instructions and software can be also found in the GitHub repository https://github.com/Wiselab2/NGPINT_V3 and Zenodo https://doi.org/10.5281/zenodo.15256036.

Biochemistry & Molecular Biology↗

Characterization of the X-ARAPUCA systems' response for SBND's light detection

X-ARAPUCA waveform data, collected at a test stand at the Noble Liquid Test Facility (NLTF) and the Short Baseline Near Detector (SBND), were analyzed via python scripts. For the ARARA system, various distributions and correlations were studied, including the area and amplitude distributions of the waveform peaks for identifying single photoelectron peaks, which was able to be accomplished. The behavior of the baseline artifact was also characterized, which appeared only at high voltages/bright events, and separates further from the prompt peak as the voltage/brightness increases. The ARARA system is being studied in order to be implemented into SBND, just as the APSAIA X-ARAPUCAs have been.

Novotny, Andrew [Fermilab]↗

Virtual Engineering Software Framework for Integrated Biomass Conversion Modeling

This presentation covers the design and implementation of a software tool to systematically connect computational models of unit operations to simulate an integrated process of low-temperature conversion of biomass to fuel. This virtual engineering (VE) software was designed with the overarching goal of connecting unit models written in various programming languages and requiring different computational resources within a single, flexible framework. The models and features currently considered for the VE library include mechanistic models for pretreatment, enzymatic hydrolysis, and aerobic bioreaction; high-fidelity computational fluid dynamics (CFD) simulations for enzymatic hydrolysis and aerobic bioreaction; and the capability to perform techno-economic analyses (TEA) using Aspen Plus, a commercial software package. The CFD models require access to high-performance computing (HPC) resources, so in addition to handling multiple programming languages and interfaces, the VE software must also be capable of interacting with an HPC scheduler to submit, run, and post-process jobs. Using the Python programming language, a new VE software package has been developed that contains functionality to manage the input-output communication between various unit models, schedule simulations to run on NREL's HPC and analyze those results, and interface with existing TEA software workflows. A Jupyter-notebook GUI was also created to solicit user input and provide documentation. In cases where multiple models for a particular unit-operation exist, selection between models is accomplished through a simple checkbox, with the appropriate inputs and outputs being parsed and converted seamlessly in the background. Each operation makes use of a different programming language, but the flow of information from pretreatment to enzymatic hydrolysis to bioreaction is managed with an intuitive, centralized file-communication strategy. In this talk, the programming approach and implementation details of the notebook are presented for multiple possibilities of the conversion process, including a demonstration of the ability to manage HPC resources. Additionally, an example of a sensitivity study of treatment parameters governing the overall conversion outcome is shown which highlights the ease of defining new problems using the VE Notebook workflow and leads into a discussion of ongoing work to enable outer-loop optimization studies.

biofuel↗