Search NASA⌕ Search

SEARCH · Search NASA

Results for “python code”

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 379 records · Page 21

Kamodo – An Adaptable Tool to Obtain and Compare Observations and Modeling Results

What is Kamodo? -Official NASA open-source project written in Python. -Building upon the functionalization of datasets. -It is a CCMC developed and maintained software tool for access, interpolation, and visualization of space weather models and data. -It allows model developers to represent simulation results as mathematical functions which may be manipulated directly by end users. -It handles unit conversion transparency and supports interactive science discovery through jupyter notebooks with minimal coding. -All Kamodo tools are accessible through Python, and all source code is publicly available on the Kamodo NASA GitHub repositories. -Kamodo does not generate model outputs. Users need to acquire the desired model outputs before they can be functionalized by Kamodo.

Kamodo↗

QuDPy: A Python-based tool for computing ultrafast non-linear optical responses

Nonlinear Optical Spectroscopy is a well-developed field with theoretical and experimental advances that have benefited multiple disciplines, including chemistry, biology, and physics. However, for the accurate interpretation of the corresponding multi-dimensional spectra, there is a need for precise quantum dynamical simulations based on model Hamiltonians. In this article, we present the initial release of our code, QuDPy (Quantum Dynamics in Python), which provides a robust numerical platform for performing quantum dynamics simulations based on model systems, including open quantum systems. Furthermore, a distinguishing feature of our approach is the ability to specify various high-order optical response pathways in the form of double-sided Feynman diagrams through a straightforward input syntax. This syntax outlines the time-ordering of ket-sided or bra-sided optical interactions acting on the time-evolving density matrix of the system. We utilize the quantum dynamics capabilities of QuTip to simulate the spectral response of complex systems, allowing us to compute virtually any $n$-th order optical response of the model system. To illustrate the utility of our approach, we provide a series of example calculations.

71 CLASSICAL AND QUANTUM MECHANICS, GENERAL PHYSIC↗

i- flow: High-dimensional integration and sampling with normalizing flows

In many fields of science, high-dimensional integration is required. Numerical methods have been developed to evaluate these complex integrals. We introduce the code i-flow, a python package that performs high-dimensional numerical integration utilizing normalizing flows. Normalizing flows are machine-learned, bijective mappings between two distributions. i-flow can also be used to sample random points according to complicated distributions in high dimensions. We compare i-flow to other algorithms for high-dimensional numerical integration and show that i-flow outperforms them for high dimensional correlated integrals. The i-flow code is publicly available on gitlab at https://gitlab.com/i-flow/i-flow.

72 PHYSICS OF ELEMENTARY PARTICLES AND FIELDS↗

PETSc/TAO Users Manual (Rev. 3.19)

This manual describes the use of the Portable, Extensible Toolkit for Scientific Computation (PETSc) and the Toolkit for Advanced Optimization (TAO) for the numerical solution of partial differential equations and related problems on high-performance computers. PETSc/TAO is a suite of data structures and routines that provide the building blocks for the implementation of large-scale application codes on parallel (and serial) computers. PETSc uses the MPI standard for all distributed memory communication. PETSc/TAO includes a large suite of parallel linear solvers, nonlinear solvers, time integrators, and opti mization that may be used in application codes written in Fortran, C, C++, and Python (via petsc4py; see Getting Started). PETSc provides many of the mechanisms needed within parallel application codes, such as parallel matrix and vector assembly routines. The library is organized hierarchically, enabling users to employ the level of abstraction that is most appropriate for a particular problem. By using techniques of object-oriented programming, PETSc provides enormous flexibility for users. PETSc is a sophisticated set of software tools; as such, for some users it initially has a much steeper learning curve than packages such as MATLAB or a simple subroutine library. In particular, for individuals without some computer science background, experience programming in C, C++, python, or Fortran and experience using a debugger such as gdb or lldb, it may require a significant amount of time to take full advantage of the features that enable efficient software use. However, the power of the PETSc design and the algorithms it incorporates may make the efficient implementation of many application codes simpler than “rolling them” yourself. For many tasks a package such as MATLAB is often the best tool; PETSc is not intended for the classes of problems for which effective MATLAB code can be written. There are several packages, built on PETSc, that may satisfy your needs without requiring directly using PETSc. We recommend reviewing these packages functionality before starting to code directly with PETSc. PETSc can be used to provide a “MPI parallel linear solver” in an otherwise sequential, or OpenMP parallel code. This approach cannot provide extremely large improvements in the application time by utilizing large numbers of MPI processes but can still improve the performance. Certainly all parts of a previously sequential code need not be parallelized but the matrix generation portion must be parallelized to expect true scalability to large numbers of MPI processes. See PCMPI for details on how to utilize the PETSc MPI linear solver server. Since PETSc is under continued development, small changes in usage and calling sequences of routines will occur. PETSc has been supported for twenty-five years; see mailing list information on our website for information on contacting support.

97 MATHEMATICS AND COMPUTING↗

Julia Programming Language Benchmark Using a Flight Simulation

Julia is a relatively new computer language that aims to reduce the challenge for mathmodelers to develop fast computer tools and simulations. It potentially combines the ease-of-coding feature of scripting languages (like Python) with the performance of compiled languages (like C++). A key question for Julia application to the simulation domain is, “Can Julia, with its obvious coding simplicity, provide runtime speeds comparable to conventional compiled languages for flight simulation?” A unique combination of existing elements can be employed to address the previous question: Extensively documented object-oriented simulation architecture, Industry standard rocket flight simulation, Separate versions (C++, Java, and Python) already benchmarked.

Sells, Ray↗

Orbit-averaging and deposition accuracy for runaway electron beams in hybrid kinetic-MHD simulations of the runaway plateau

We develop a new procedure that combines the kinetic orbit runaway electron code (KORC) and the NIMROD extended-magnetohydrodynamic code to simulate runaway electrons (REs) in the post-disruption plateau. KORC integrates guiding-center orbits, with a barycentric-based binary search strategy providing initial guesses for the Newton–Raphson logical-to-physical coordinate inversion, ensuring reliable particle-to-mesh mapping in NIMROD, whose fields remain static for the present study. Samples are drawn in accord with experimental parallel current profiles of RE beams during the plateau phase. Deposition in NIMROD is verified through comparison with a Python-based finite-element code that ensures periodicity in the poloidal direction and continuity at the magnetic axis. Accurate representation of near-axis fields requires finer mesh resolution to prevent under- and overshoots in current density from orbit inaccuracies. Yet, at a fixed particle count, increasing mesh resolution amplifies statistical noise in the deposited fields. An orbit-averaging method accumulates partial current deposits over multiple kinetic steps and reduces the statistical noise with little added computational cost. By coupling kinetic routines from KORC directly into the NIMROD codebase, these developments lay essential groundwork for future self-consistent KORC–NIMROD coupling.

Algorithms and data structure↗

Modeling, Performance Assessment, and Nodal Data Analysis of TRISO-Fueled Systems with Shift

This technical report documents several enhancements to the Shift Monte Carlo (MC) code under the US Department of Energy (DOE) Nuclear Energy Advanced Modeling and Simulation (NEAMS) program in fiscal year (FY) 2022. Performance enhancements were added to Shift specifically for tristructural isotropic (TRISO)–fueled reactor systems and guided based on performance analysis in FY 2021. For the pebble performance model developed in previous studies, the runtime improved by ~ 91× compared to the original model and ~ 2× compared to the user-optimized model. Compared to Serpent, Shift is ~ 3× slower if Serpent delta-tracking is enabled but ~ 2× faster when delta-tracking is disabled. The multigroup cross section generation was improved through simplifying tally input definitions, porting several post-processing tally operations from Python scripts into the Shift code base, and accounting for production reactions in the scattering multiplicity. Progress was also made on two emerging capabilities: (1) the development of Titan (a Shift reactor physics user interface) and (2) initial investigation into path-length tallies for computing multigroup scattering matrices.

11 NUCLEAR FUEL CYCLE AND FUEL MATERIALS↗

Convective Parameters Derived from Radiosonde Data (SONDEPARAM) Value-Added Product Report

Radiosondes provide fundamental observations of the vertical profile of atmospheric state (pressure, temperature, humidity, and winds), with important implications for subsequent studies on environmental controls on cloud conditions. Within convective cloud environments, there is an increasing demand for additional value-added products (VAPs) to facilitate the use of U.S. Department of Energy Atmospheric Radiation Measurement (ARM) user facility radiosonde data sets. Such VAPs should provide quick and reliable estimates for several standard radiosonde parameters or quantities of interest using common assumptions, as well as open, flexible code for visualization and user interaction. The Convective Parameters Derived from Radiosonde Data (SONDEPARAM) VAP will apply several robust algorithms used in Wang et al. (2020) for the calculation of useful radiosonde convective cloud parameters, including the convective available potential energy (CAPE), convective inhibition (CIN), and other convective parameters, for several different assumptions regarding the initial parcel characteristics (i.e., surface-based, most unstable, mixed layer). These ARM VAP codes are developed in open, flexible Python formats, with the intention that these parameters/calculations will be incorporated into traditional ARM quick-look radiosonde plotting, yet associated with user-available codes for ease in user reproduction and assumption modification.

54 ENVIRONMENTAL SCIENCES↗

Python-ARM Radar Toolkit

The Python-ARM Radar Toolkit (Py-ART) is a collection of radar quality control and retrieval codes which all work on two unifying Python objects: the PyRadar and PyGrid objects. By building ingests to several popular radar formats and then abstracting the interface Py-ART greatly simplifies data processing over several other available utilities. In addition Py-ART makes use of Numpy arrays as its primary storage mechanism enabling use of existing and extensive community software tools.

Jonathan Helmus, ScottCollis↗

Python-ARM Radar Toolkit

The Python-ARM Radar Toolkit (Py-ART) is a collection of radar quality control and retrieval codes which all work on two unifying Python objects: the PyRadar and PyGrid objects. By building ingests to several popular radar formats and then abstracting the interface Py-ART greatly simplifies data processing over several other available utilities. In addition Py-ART makes use of Numpy arrays as its primary storage mechanism enabling use of existing and extensive community software tools.

Jonathan Helmus, Scott Collis↗

SciPy 1.0: fundamental algorithms for scientific computing in Python

SciPy is an open-source scientific computing library for the Python programming language. Since its initial release in 2001, SciPy has become a de facto standard for leveraging scientific algorithms in Python, with over 600 unique code contributors, thousands of dependent packages, over 100,000 dependent repositories and millions of downloads per year. In this work, we provide an overview of the capabilities and development practices of SciPy 1.0 and highlight some recent technical developments.

97 MATHEMATICS AND COMPUTING↗

Distributed state machine supervision for long-baseline gravitational-wave detectors

The Laser Interferometer Gravitational-wave Observatory (LIGO) consists of two identical yet independent, widely separated, long-baseline gravitational-wave detectors. Each Advanced LIGO detector consists of complex optical-mechanical systems isolated from the ground by multiple layers of active seismic isolation, all controlled by hundreds of fast, digital, feedback control systems. This article describes a novel state machine-based automation platform developed to handle the automation and supervisory control challenges of these detectors. The platform, called Guardian, consists of distributed, independent, state machine automaton nodes organized hierarchically for full detector control. User code is written in standard Python and the platform is designed to facilitate the fast-paced development process associated with commissioning the complicated Advanced LIGO instruments. While developed specifically for the Advanced LIGO detectors, Guardian is a generic state machine automation platform that is useful for experimental control at all levels, from simple table-top setups to large-scale multi-million dollar facilities.

46 INSTRUMENTATION RELATED TO NUCLEAR SCIENCE AND ↗

Evaluation of a collisional radiative model for electron temperature determination in hydrogen plasma

A collisional-radiative (CR) model that extracts the electron temperature, T e , of hydrogen plasmas from Balmer-line-ratio measurements is examined for the plasma electron density, n e , and T e ranges of 10 10 –10 15 cm –3 and 5–500 eV, respectively. The CR code, developed and implemented in Python, has a forward component that computes the densities of excited states up to n = 15 as functions of T e , n e , and the molecular-to-atomic neutral ratio r(H 2 /H). The backward component provides ne and r(H 2 /H) as functions of the Balmer ratios to predict the T e . The model assumes Maxwellian electrons. Furthermore, the density profiles of the electrons and of the molecular and atomic hydrogen neutrals are shown to be of great importance, as is the accuracy of the line-ratio measurement method.

70 PLASMA PHYSICS AND FUSION TECHNOLOGY↗

JPype

JPype is a Python module to provide full access to Java from within Python. It allows Python to make use of Java only libraries, exploring and visualization of Java structures, development and testing of Java libraries, scientific computing, and much more. By gaining the best of both worlds using Python for rapid prototyping and Java for strong typed production code, JPype provides a powerful environment for engineering and code development. This is achieved not through re-implementing Python, as Jython has done, but rather through interfacing at the native level in both virtual machines. This shared memory based approach achieves decent computing performance, while providing the access to the entirety of CPython and Java libraries.

Nelson, KarlE.↗

Particle-in-cell/accelerator code for space-charge dominated beam simulation

Warp is a multidimensional discrete-particle beam simulation program designed to be applicable where the beam space-charge is non-negligible or dominant. It is being developed in a collaboration among LLNL, LBNL and the University of Maryland. It was originally designed and optimized for heave ion fusion accelerator physics studies, but has received use in a broader range of applications, including for example laser wakefield accelerators, e-cloud studies in high enery accelerators, particle traps and other areas. At present it incorporates 3-D, axisymmetric (r,z) planar (x-z) and transverse slice (x,y) descriptions, with both electrostatic and electro-magnetic fields, and a beam envelope model. The code is guilt atop the Python interpreter language.

Grote, D. P.↗

labquake_future_prediction

The labquake_future_prediction code is a collection of python modules and scripts that serves as supporting information for the article “Predicting future laboratory fault friction through deep learning” for publication in the journal of “Geophysical Research Letters”. It is designed to predict laboratory fault slips in the immediate future by scanning continuous acoustic emission (AE) waveforms recorded in laboratory biaxial shear experiments. The predictions are made with a deep learning model based on convolutional encoder-decoder (CED) models and the Transformer model primarily developed for Natural Language Processing (NLP). The deep learning model is trained with the tensorflow package using publicly available laboratory data sets in standard binary file format in numpy. The utility functions for reading data files, configuring model hyperparameters, constructing the CED and Transformer models, training and testing of the models are defined in python module files. The workflow of training the models for labquake future predictions and the multiple GPU’s rapid model hyperparameter optimization as described in the journal article, are demonstrated in accompanying python script files and Jupyter notebooks.

Wang, Kun↗

Control And Optimization Modular Modeling Application For Nuclear Deployment

The purpose of the COMMAND code is to provide a flexible, scalable tool for use in developing, integrating, and testing the technologies necessary for achieving autonomous operations of advanced nuclear reactors. The code enables users to efficiently implement custom simulations and experiments by combining key methods from different software modules. These modules are focused on: modeling and simulation tools, such as nuclear simulation tools used for high-fidelity modeling (e.g., Reactor Excursion and Leak Analysis Program [RELAP5-3D] and Monte Carlo N-Particle [MCNP]); machine learning and optimization tools (e.g., anomaly detection and data-driven modeling techniques); advanced control in its digital, high-performance, and supervisory control forms (e.g., proportional integral derivative (PID) control and model predictive control (MPC); and integration with hardware through industrial communication protocols. To ensure flexibility and scalability, COMMAND was designed to be both modular—the software “pieces” all inherit from generic building blocks and can be combined and connected to create complicated simulations—and high performing—designed for parallel processing, enabling simulations and experiments to take advantage of multi-core computers, servers, and nodes. The code is written in the Python programming language due to the language's popularity, active community, and open-source and cross-platform nature. Maintaining consistency with other simulation tools used within the nuclear energy community, users implement simulations and experiments through text input files, which define components, parameters, connections, etc., through lines of text. Given that COMMAND is written in Python, these input files are native Python scripts, and so use the standard Python structure and formatting. This also enables users to take advantage of Python's extensive package library to develop custom capabilities for their specific use cases.

Faber, Jacob [Idaho National Laboratory (INL), Ida↗

Emulsion droplets detection suite

The code is a set of Python libraries/scripts that leverage open source computer vision packages like YOLO and SAM2 to identify emulsion droplets in plate reader images and videos of microfluidic device flows.

Reddy, Tyler [LANL]↗