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

HERO WEC Belt Test Data

The following submission includes raw and processed data from the 2024 Hydraulic and Electric Reverse Osmosis Wave Energy Converter (HERO WEC) belt tests conducted using NREL's Large Amplitude Motion Platform (LAMP). A description of the motion profiles run during testing can be found in the run log document. Data was collected using NREL's Modular Ocean Data AcQuisition (MODAQ) system in the form of TDMS files. Data was then processed using Python and MATLAB and converted to MATLAB workspace, parquet, and csv file formats. During Data processing, a low pass filter was applied to each array and the arrays were then resampled to common 10Hz timestamps. A MATLAB data viewer script is provided to quickly visualize these data sets. The following arrays are contained in each test data file: - Time: Unix seconds timestamp - Test_Time: Time in seconds since beginning of test - POS_OS_1001: Encoder position in degrees (the encoder is located on the secondary shaft of the spring return and is driven by the winch after a 4.5:1 gear reduction) - LC_ST_1001: Anchor load cell data in lbf - PRESS_OS_2002: Air spring pressure in psi This data set has been developed by the National Renewable Energy Laboratory, operated by Alliance for Sustainable Energy, LLC, for the U.S. Department of Energy (DOE) under Contract No. DE-AC36-08GO28308. Funding provided by the U.S. Department of Energy Office of Energy Efficiency and Renewable Energy Water Power Technologies Office.

16 TIDAL AND WAVE POWER↗

EGS Collab Experiment 1: Circulation Testing Processed data

This submission includes processed and reduced data for circulation testing that was conducted at the 164' fracture on the 4850 ft level of the Sanford Underground Research Facility. The circulation tests were done to test the flow through the 164' fracture in the EGS Collab Experiment 1 testbed on the 4850 ft level of the Sanford Underground Research Facility in order to validate computer models concerned with flow processes and heat exchange processes in EGS. This data was processed from raw data that is available in the GDR submission linked below: "EGS Collab Circulation Testing Raw Data and Documentation." Python scripts used to process and reduce the data are included. The scripts also serve as "documentation" as well as examples for data processing. More information about the test itself as well as the rationale and process of data processing is available at wiki page linked below.

15 GEOTHERMAL ENERGY↗

Code for "Emulating 2D Materials with Magnons"

Data related to a publication, "Emulating 2D Materials with magnons" to be published, but also as a preprint on arXiv https://arxiv.org/abs/2601.03210. It contains scripts for the simulation program Mumax3, and python scripts for conversion and analysis.

Kaman, Bobby [University of Illinois] (ORCID:00090↗

brulilo, Version 0.x

brulilo is a Python package for building and evolving thermonuclear reaction networks, such as those used in astrophysical explosion calculations. It is very much a current work in progress, and much of the intended functionality is still under development. The main goal of brulilo is an easy-to-use code for quick calculations or post-processing, as well as a learning tool to test various implementations of solvers on both CPUs and GPUs. Currently, brulilo parses an input text file that specifies the reactions to be included in the network. The notation of the inputs are in the typical astrophysical notation; i.e. hydrogen burning to deuterium in the sun, "p + p + e --> d + neutrino", is given as "p(p,)d." Each reaction is added to a list comprising the reaction network, and once completed, the network contains a list of all isotopes and reactions involved. brulilo then parses publicly available nuclear data (binding energy, spin, partition function data, etc.) for each isotope from the WebNucleo group's data at nucleo.ces.clemson.edu. Fits to reaction rate data for each reaction are obtained from the publicly available data provided by the Joint Institute for Nuclear Astrophysics' Reaclib database. Reverse reactions are calculated from detailed balance. The reaction network then consists of a sparse system of mathematically stiff ordinary differential equations (ODEs). Physically, "stiffness" here means that there are some reaction rates that are occurring much faster than others; the ratio of the fast to slow often being greater than 10^15 in astrophysics. Numerical integration of such systems typically involves implicit integration schemes, which brulilo will leverage from the scientific computing Python package, Numpy, as well as implement its own. There has recently been work from researchers at Oak Ridge National Lab who have found good results from applying quasi-equilibrium and quasi-asymptotic conditions to the stiff system of ODEs, which effectively remove some of the stiffness and allow for efficient explicit integration techniques to be used. The original intent of brulilo was to implement these stiffness-alleviating techniques with explicit integrators and compare the performance to traditional implicit integrations of the full stiff system. This is still underway, as the code is very much in an alpha-release state. Furthermore, explicit integrators are often much easier to parallelize than their implicit counterparts. brulilo will implement parallelization of these techniques, leveraging both the Python implementation of MPI, mpi4py, as well as highly parallelized versions targeted at GPUs with PyOpenCL and/or PyCUDA.

Malone, Chris↗

brulilo, Version 0.x

brulilo is a Python package for building and evolving thermonuclear reaction networks, such as those used in astrophysical explosion calculations. It is very much a current work in progress, and much of the intended functionality is still under development. The main goal of brulilo is an easy-to-use code for quick calculations or post-processing, as well as a learning tool to test various implementations of solvers on both CPUs and GPUs. Currently, brulilo parses an input text file that specifies the reactions to be included in the network. The notation of the inputs are in the typical astrophysical notation; i.e. hydrogen burning to deuterium in the sun, "p + p + e --> d + neutrino", is given as "p(p,)d." Each reaction is added to a list comprising the reaction network, and once completed, the network contains a list of all isotopes and reactions involved. brulilo then parses publicly available nuclear data (binding energy, spin, partition function data, etc.) for each isotope from the WebNucleo group's data at nucleo.ces.clemson.edu. Fits to reaction rate data for each reaction are obtained from the publicly available data provided by the Joint Institute for Nuclear Astrophysics' Reaclib database. Reverse reactions are calculated from detailed balance. The reaction network then consists of a sparse system of mathematically stiff ordinary differential equations (ODEs). Physically, "stiffness" here means that there are some reaction rates that are occurring much faster than others; the ratio of the fast to slow often being greater than 10^15 in astrophysics. Numerical integration of such systems typically involves implicit integration schemes, which brulilo will leverage from the scientific computing Python package, Numpy, as well as implement its own. There has recently been work from researchers at Oak Ridge National Lab who have found good results from applying quasi-equilibrium and quasi-asymptotic conditions to the stiff system of ODEs, which effectively remove some of the stiffness and allow for efficient explicit integration techniques to be used. The original intent of brulilo was to implement these stiffness-alleviating techniques with explicit integrators and compare the performance to traditional implicit integrations of the full stiff system. This is still underway, as the code is very much in an alpha-release state. Furthermore, explicit integrators are often much easier to parallelize than their implicit counterparts. brulilo will implement parallelization of these techniques, leveraging both the Python implementation of MPI, mpi4py, as well as highly parallelized versions targeted at GPUs with PyOpenCL and/or PyCUDA.

Malone, Chris↗

SEAS Communication Engine: An Extensible, Flexible Wrapper for Co-Simulation Agents

When modeling and analyzing the power grid and other large scale systems, researchers often express scenarios as optimization problems and feed them into advanced software solvers. In order to allow multiple solvers to communicate with each other and share data from different domains, the National Renewable Energy Laboratory (NREL) and associated Department of Energy (DOE) labs have developed a software framework called the Hierarchical Engine for Large-scale Infrastructure Co-Simulation (HELICS). HELICS allows cosimulation via a collection of client libraries for different languages that can be called from the appropriate optimization software. However, these client libraries do not provide a higher level of abstraction beyond reading and writing data off of the shared HELICS bus. In this paper, we describe a new software library called the SEAS Communication Engine that exposes a higher-level API for running cosimulation problems. The SEAS Engine provides a class-based abstraction on top of the Python HELICS client, in order to allow users to implement their domain-specific cosimulations without needing to interact with core HELICS primitives. This will make adoption of HELICS and cosimulation in general easier, by exposing a simpler API. In the second part of the paper, we validate our library on a collection of different simulation examples, including the canonical IEEE 13 Bus Feeder. Lastly, we demonstrate using the SEAS Engine to directly call domain-specific code written in the Julia programming language. Our hope is that this will serve as a template for easily calling software in different programming languages via the SEAS Engine, thereby avoiding code duplication and complexity.

co-simulation↗

Water isotope data for the TEMPEST study site, 2023-2026

This dataset contains water isotope (deuterium (dD) and oxygen (d18O)) data from porewater, experimental source water, and aquifer sources from the Terrestrial Ecosystem Manipulation to Probe the Effects of Storm Treatments (TEMPEST) experimental field site in Edgewater, MD. Samples were taken from 2023-2026 and included in file "TEMPEST_Water_Isotope_LANL_2023-2026.csv". Porewater samples were taken from 15cm depth at multiple locations in each experimental plot (i.e., control, freshwater, and saltwater). Water samples were stored in 2 ml amber glass vials with septum caps under refrigeration until analysis. A L2140-i Picarro cavity ringdown spectrometer connected to an A0211 Picarro vaporization module was used to run water samples. Standards (United States Geological Survey (USGS) 47 and 48) were used to check instrument accuracy during each run of samples. Post-processing codes were run to calculate isotopic values from raw data. Reported isotope data is post-processed. Raw data CSV files from the Picarro were processed using a Python script and output as excel files containing data calibrated to Vienna Standard Mean Ocean Water (VSMOW). Standardization is based on USGS47 and USGS48 standards that are measured before and after every 5-10 unknowns. Every measurement is comprised of 10 injections. Processing involved discarding the first 4 injections due to a known memory effect. Raw means of the last 6 injections are taken for each measurement and then corrected from the linear calibration relationship of the USGS standards expected vs measured values to obtain corrected compositions relative to VSMOW. Reported isotope data are corrected mean results.

Aquifer↗

Electron beam irradiated foil expansion simulated by a coupled HYDRA/MCNP6 application

Simulating the hydrodynamic evolution of a temporally pulsed electron beam with multiple metal foils requires coupling the nearly monoenergetic, relativistic electron beam to the foil target. This deposition may be effectively calculated by Monte Carlo transport. Once this energy is deposited on a computational mesh representing the foil target, highly developed radiation-hydrodynamic codes, such as HYDRA, can describe the subsequent evolution. Currently, HYDRA does not have an internal Monte Carlo electron transport capability. To partially rectify this deficiency, a PYTHON-based scheme to link MCNP6 to HYDRA has been developed for quadrilateral meshes. Results from a seven-foil tantalum target configuration are presented to demonstrate this capability.

42 ENGINEERING↗

FAUST - Benchmark and Validation Framework [Slides]

This presentation discusses Python packages for nuclear data applications and for benchmarking. It also discusses the goals and objectives for FAUST which include providing input and output processing for different calculation codes, allowing for exchanging results between different applications and codes, running benchmarks and processing the results, automating and simplify plot and report generation, and providing a basis for developing applications useful for nuclear data evaluators. The presentation also discusses how the packages can be used both inside and outside LANL.

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗

LINAC BEAM DYNAMICS SIMULATIONS WITH PY-ORBIT

Linac dynamics simulation capabilities of the PyORBIT code are discussed. PyORBIT is an open source code and a further development of the original ORBIT code that was created and used for design, studies, and commissioning of the SNS ring. The PyORBIT code, like the original one, has a two-layer structure. C++ is used to perform time-consuming computations, and the program flow is controlled from a Python language shell. The flexible structure makes it possible to use PyORBIT also for linac dynamics simulations. A benchmark of PyORBIT with Parmila and the XAL Online model is presented.

43 PARTICLE ACCELERATORS↗

Lightshow: a Python package for generating computational x-ray absorption spectroscopy input files

First-principles computational spectroscopy is a critical tool for interpreting experiment, per- forming structure refinement, and developing new physical understanding. Systematically setting up input files for different simulation codes and a diverse class of materials is a challeng- ing task with a very high barrier-to-entry, given the complexities and nuances of each individual simulation package. This task is non-trivial even for experts in the electronic structure field and nearly formidable for non-expert researchers. Lightshow solves this problem by providing a uniform abstraction for writing computational x-ray spectroscopy input files for multiple popular codes, including FEFF, VASP, OCEAN, exciting and XSpectra. Its extendable framework will also allow the community to easily add new functions and to incorporate new simulation codes.

36 MATERIALS SCIENCE↗

TEAMER: Numerical Modeling and Optimization of the iProTech Pitching Inertial Pump (PIP) Wave Energy Converter (WEC)

This project focused on developing an automated workflow to evaluate and optimize the iProTech Pitching Inertial Pump (PIP) wave energy converter (WEC) using open-source Python packages and the MATLAB/Simulink tool, WEC-Sim. The process involved parameterizing key design variables, running time-domain simulations, and performing sensitivity analyses to determine their impact on power output. The workflow, designed for the PIP device, is generalized and can be extended to optimize other WECs that can be simulated in WEC-Sim. This work establishes a foundation for future time-domain-based WEC design optimizations. Included in this submission are all figures from the final report and the model inputs required to generate them. This includes Python scripts with inputs that produce the meshes, boundary element method (BEM) models, hydrodynamic coefficients, and the WEC-Sim models used for time-domain analyses. Although data for every single run is not included to save space, all of it can be reproduced using the provided models. Detailed instructions for setting up the environment and running the codes are also included.

16 TIDAL AND WAVE POWER↗

Practical Multi-Cycle Refueling Simulation of Stable Salt Reactors Based on REBUS Depletion Calculation

A Python software tool ReloadPy has been developed to assistant in formulating online refueling strategies for a family of stable salt reactors. ReloadPy wraps over the legacy fast reactor analysis codes REBUS, DIF3D, and PERSENT. These codes are used to perform single cycle depletion analysis and calculate reactivity worth and power density. ReloadPy determines a refueling assembly position to achieve the user-specified primary objective while satisfying constraints on various performance parameters such as the maximum power density, the maximum reactivity worth of reloaded assembly, and the minimum cycle length. Various capabilities of prescribing refueling sequence or a range of candidate refueling positions and restarting a previous simulation with altered options are implemented to reduce the required user’s efforts to investigate different refueling strategies. This report presents the computational models and methods and also serves as a user guide. Long-term simulation capabilities with different refueling strategies are demonstrated by a series of sample SSR refueling calculations with two-dimensional surrogate core models.

22 GENERAL STUDIES OF NUCLEAR REACTORS↗

Decaf: Decoupled Dataflows for In Situ High-Performance Workflows

Decaf is a dataflow system for the parallel communication of coupled tasks in an HPC workflow. The dataflow can perform arbitrary data transformations ranging from simply forwarding data to complex data redistribution. Decaf does this by allowing the user to allocate resources and execute custom code in the dataflow. All communication through the dataflow is efficient parallel message passing over MPI. The runtime for calling tasks is entirely message-driven; Decaf executes a task when all messages for the task have been received. Such a messagedriven runtime allows cyclic task dependencies in the workflow graph, for example, to enact computational steering based on the result of downstream tasks. Decaf includes a simple Python API for describing the workflow graph. This allows Decaf to stand alone as a complete workflow system, but Decaf can also be used as the dataflow layer by one or more other workflow systems to form a heterogeneous task-based computing environment. In one experiment, we couple a molecular dynamics code with a visualization tool using the FlowVR and Damaris workflow systems and Decaf for the dataflow. In another experiment, we test the coupling of a cosmology code with Voronoi tessellation and density estimation codes using MPI for the simulation, the DIY programming model for the two analysis codes, and Decaf for the dataflow. Such workflows consisting of heterogeneous software infrastructures exist because components are developed separately with different programming models and runtimes, and this is the first time that such heterogeneous coupling of diverse components was demonstrated in situ on HPC systems.

97 MATHEMATICS AND COMPUTING↗

CTF_

CTF is a thermal-hydraulic simulation tool designed for modeling the reactor vessel region of light water reactors. The code is capable of modeling both coolant and solid regions and includes a nuclear fuel rod model. Coolant is represented with a 9-equation (two phases plus droplets and non-condensable gas) model with closure relationships being provided for normal and accident conditions. Meshing is done using the subchannel approach, which models the coolant region as a collection of parallel 1-D flow paths that communicate laterally through "gaps". CTF also includes a collection of supporting software tools that include: Xml2ctf - A utility for creating native CTF input decks from a simplified input file; pyCTF - A collection of Python utilities used for post-processing CTF results, manipulating CTF input models, and testing differences between output files; CTFFuel - A separate front-end to the CTF fuel rod solver package; Multistate - A separate driver for CTF that communicates through the code coupling interface; and veraAPI - A c++ interface to the code.

Salko, Robert K↗

Hindsight logging for model training

In modern Machine Learning, model training is an iterative, experimental process that can consume enormous computation resources and developer time. To aid in that process, experienced model developers log and visualize program variables during training runs. Exhaustive logging of all variables is infeasible, so developers are left to choose between slowing down training via extensive conservative logging, or letting training run fast via minimalist optimistic logging that may omit key information. As a compromise, optimistic logging can be accompanied by program checkpoints; this allows developers to add log statements post-hoc, and "replay" desired log statements from checkpoint---a process we refer to as hindsight logging. Unfortunately, hindsight logging raises tricky problems in data management and software engineering. Done poorly, hindsight logging can waste resources and generate technical debt embodied in multiple variants of training code. In this paper, we present methodologies for efficient and effective logging practices for model training, with a focus on techniques for hindsight logging. Our goal is for experienced model developers to learn and adopt these practices. To make this easier, we provide an open-source suite of tools for Fast Low-Overhead Recovery (flor) that embodies our design across three tasks: (i) efficient background logging in Python, (ii) adaptive periodic checkpointing, and (iii) an instrumentation library that codifies hindsight logging for efficient and automatic record-replay of model-training. Model developers can use each flor tool separately as they see fit, or they can use flor in hands-free mode, entrusting it to instrument their code end-to-end for efficient record-replay. Our solutions leverage techniques from physiological transaction logs and recovery in database systems. Evaluations on modern ML benchmarks demonstrate that flor can produce fast checkpointing with small user-specifiable overheads (e.g. 7%), and still provide hindsight log replay times orders of magnitude faster than restarting training from scratch.

Computer Science↗

VeraRun

VeraRun provides users a command-line utility that determines the sequence of VERA codes and utilities to be executed, calculates and determines PBS directives and job parameters, creates a job script, and submits the script on behalf of the user. While hiding all the details, the script allows the user to set PBS parameters explicitly. VeraRun is implemented as a Python package with host-specific configurations and job script templates. Host configurations are stored in JavaScript Object Notation (JSON) files and specify machine characteristics (e.g., number of nodes, number of processors per node, memory available per node, location of VERA installations). Job templates are Bash scripts with parameters substituting for host-specific PBS directives and controls. These files are named by the hostname, thus making VeraRun extensible to other systems and environments. VeraRun reads the VERA input file to determine code and execution environment requirements, creating and optionally submitting a job script.

Lee, Ronaldw↗

FELIX-1.0: A finite element solver for the time dependent generator coordinate method with the Gaussian overlap approximation

In this study, we describe the software package FELIX that solves the equations of the time-dependent generator coordinate method (TDGCM) in NN-dimensions (N ≥ 1) under the Gaussian overlap approximation. The numerical resolution is based on the Galerkin finite element discretization of the collective space and the Crank–Nicolson scheme for time integration. The TDGCM solver is implemented entirely in C++. Several additional tools written in C++, Python or bash scripting language are also included for convenience. In this paper, the solver is tested with a series of benchmarks calculations. We also demonstrate the ability of our code to handle a realistic calculation of fission dynamics.

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗