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 811 records · Page 45

COFFEA - Columnar Object Framework For Effective Analysis [Slides]

The COFFEA Framework provides a new approach to HEP analysis, via columnar operations, that improves time-to-insight, scalability, portability, and reproducibility of analysis. It is implemented with the Python programming language and commodity big data technologies such as Apache Spark and NoSQL databases. To achieve this suite of improvements across many use cases, COFFEA takes a factorized approach, separating the analysis implementation and data delivery scheme. All analysis operations are implemented using the NumPy or awkward-array packages which are wrapped to yield user code whose purpose is quickly intuited. Various data delivery schemes are wrapped into a common front-end which accepts user inputs and code, and returns user defined outputs. We will present published results from analysis of CMS data using the COFFEA framework along with a discussion of metrics and the user experience of arriving at those results with columnar analysis.

97 MATHEMATICS AND COMPUTING↗

Exploring MDSplus data-acquisition software and custom devices

MDSplus is a software tool designed for data acquisition, storage, and analysis of complex scientific experiments. Over the years, MDSplus has primarily been used for data management for fusion experiments. This paper demonstrates that MDSplus can be used for a much wider variety of systems and experiments. We present a step-by-step tutorial describing how to create a simple experiment, manage the data, and analyze it using MDSplus and Python. To this end, a custom example device was developed to be used as the data source. This device was built on an opensource electronic hardware platform, and it consists of a microcontroller and two sensors. We read data from these sensors, store it in MDSplus, and use JupyterLab to visualize and process it. This project and code demo are available on the GitHub site at this URL: https://github.com/santorofer/MDSplusAndCustomeDevices

70 PLASMA PHYSICS AND FUSION TECHNOLOGY↗

PyCBC Inference: A Python-based Parameter Estimation Toolkit for Compact Binary Coalescence Signals

We introduce new modules in the open-source PyCBC gravitational-wave astronomy toolkit that implement Bayesian inference for compact-object binary mergers. We review the Bayesian inference methods implemented and describe the structure of the modules. Here, we demonstrate that the PyCBC Inference modules produce unbiased estimates of the parameters of a simulated population of binary black hole mergers. We show that the parameters' posterior distributions obtained using our new code agree well with the published estimates for binary black holes in the first Advanced LIGO–Virgo observing run.

79 ASTRONOMY AND ASTROPHYSICS↗

Validation of CTF Droplet Entrainment and Annular/Mist Closure Models using Riso Steam/Water Experiments

This report summarizes the work done to validate the droplet entrainment and de-entrainment models as well as two-phase closure models in the CTF code by comparison with experimental data obtained at Riso National Laboratory. The Riso data included a series of over 250 steam/water experiments that were performed in both tube and annulus geometries over a range of various pressures and outlet qualities. Experimental conditions were set so that the majority of cases were in the annular/mist ow regime. Measurements included liquid lm ow rate, droplet ow rate, lm thickness, and two-phase pressure drop. CTF was used to model 180 of the tubular geometry cases, matching experimental geometry, outlet pressure, and outlet ow quality to experimental values. CTF results were compared to the experimental data at the outlet of the test section in terms of vapor and entrained liquid ow fractions, pressure drop per unit length, and liquid lm thickness. The entire process of generating CTF input decks, running cases, extracting data, and generating comparison plots was scripted using Python and Matplotlib for a completely automated validation process. All test cases and scripting tools have been committed to the COBRA-TF master repository and selected cases have been added to the continuous testing system to serve as regression tests. The dierences between the CTF- and experimentally-calculated ow fraction values were con- sistent with previous calculations by Wurtz, who applied the same entrainment correlation to the same data. It has been found that CTF's entrainment/de-entrainment predictive capability in the annular/mist ow regime for this particular facility is comparable to the licensed industry code, COBRAG. While lm and droplet predictions are generally good, it has been found that accuracy is diminished at lower ow qualities. This nding is consistent with the noted deciencies in the Wurtz entrainment model employed by CTF. The CTF predicted two-phase pressure drop in the annular/mist ow regime has been found to be highly inaccurate, exhibiting a clear bias with respect to the experimental data. This inaccuracy led to an investigation that revealed deciencies in the implementation of the annular/mist interfacial friction model, which should be investigated further in the future. Looking to published COBRAG results for this same facility reveal it exhibits no bias with regard to experimental pressure drop results. In addition to the problems with pressure drop prediction, the lm thickness was also signicantly under-predicted by CTF compared to both experimental data and Wurtz's analytical calculations. Film thickness is calculated using a simple geometric relationship and lm void fraction in CTF, which is dependent on slip ratio and interfacial friction. It is possible that the issues aecting the pressure drop and lm void prediction are related.

97 MATHEMATICS AND COMPUTING↗

A simple json format for storing and exchanging code calculation and experimental results

Calculation codes and code systems give their results in a plethora of different formats and/or files. For instance, MCNP gives a user the MCNP specific output file, the mctal file, the ptrac file, etc. while PARTISN has a PARTISN specific output file and a number of binary files with various kinds of information about the calculation. However, the results we are interested in are always the same. These can be single values such as the effective multiplication factor k eff or the effective delayed neutron fraction β eff . It can be histogram data (such as particle spectra, reaction rates, sensitivity profiles, etc.) or even pointwise data (for example the nuclide composition as a function of time, etc.). It is also worthwhile to note that this would also apply to experimental data that we may wish to compare with as well. Calculation and experimental results can basically be split into two components: attributes (or metadata) and the actual result itself. Attributes represent information about the result that are not necessarily required for its’ interpretation but that are still good to have. Often, these attributes are what we will want to filter results on. This means that these attributes are often the answer to specific questions we may have about the result. The following is a non exhaustive list of such basic questions: what type of result is it: e.g. the effective multiplication factor k eff , the effective delayed neutron fraction β eff , etc.; which case does it relate to: e.g. a specific ICSBEP case such as PU-MET-FAST-001-001; which code and version produced this result: e.g. MCNP 6.2, etc.; which nuclear data library was used to obtain the result: e.g. ENDF/B-VIII.0 or JEFF 3.3; which nuclide and reaction does it apply to (for reaction rates and sensitivity profiles); which volume in the geometry was it calculated in? The second component of the calculation or experimental result is the actual numerical data of the result. It is this data that we want to compare, exchange, plot, interpret, etc. It consists of values with optional uncertainties and units. It also includes the underlying structure (if any structure is required to interpret the result). Depending on the type of result, it may be a single value (e.g. the effective multiplication factor), an array of values (e.g. a reaction rate or particle spectrum) or even a multidimensional array. In order to exchange results between different organisations, for instance for benchmarking, people often resort to spreadsheets or custom text files that need to be filled out. While this approach works well if little information is to be exchanged, it can become cumbersome when dealing with large amounts of data (like for instance particle spectra for thousands of cases). In addition, such an approach does not always capture the metadata we may be interested in to allow for automated processing of these files. The purpose of this report is to propose a standardised json structure to store any type of result and present an associated python interface to interact with these results directly. For such a structure to be useful, it must fulfill a specific set of functional requirements that we try to meet with this proposal. The format must allow for the calculation result to stand by itself. This means that we should not have to look in multiple places to be able to understand it. For example, if the result relates to a particle spectrum, the group structure in which the result is given should be stored with it. The format should be code agnostic. This means that we do not need to know where it came from to understand it. The format should be result type agnostic. This means that the format must be generic enough so that we can even use it for results we have not thought of yet. The format should be relatively easy to interact with through different scripting or programming languages (i.e. the machine interface) while still providing a clean structure that can be used directly by any human.

97 MATHEMATICS AND COMPUTING↗

Tutorial: Crystal orientations and EBSD — Or which way is up?

Electron backscatter diffraction (EBSD) is an automated technique that can measure the orientation of crystals in a sample very rapidly. There are many sophisticated software packages that present measured data. Unfortunately, due to crystal symmetry and differences in the set-up of microscope and EBSD software, there may be accuracy issues when linking the crystal orientation to a particular microstructural feature. In this paper we outline a series of conventions used to describe crystal orientations and coordinate systems. These conventions have been used to successfully demonstrate that a consistent frame of reference is used in the sample, unit cell, pole figure and diffraction pattern frames of reference. We establish a coordinate system rooted in measurement of the diffraction pattern and subsequently link this to all other coordinate systems. A fundamental outcome of this analysis is to note that the beamshift coordinate system needs to be precisely defined for consistent 3D microstructure analysis. This is supported through a series of case studies examining particular features of the microscope settings and/or unambiguous crystallographic features. These case studies can be generated easily in most laboratories and represent an opportunity to demonstrate confidence in use of recorded orientation data. Finally, we include a simple software tool, written in both MATLAB® and Python, which the reader can use to compare consistency with their own microscope set-up and which may act as a springboard for further offline analysis. - Highlights: • Presentation of conventions used to describe crystal orientations • Three case studies that outline how conventions are consistent • Demonstrates a pathway for calibration and validation of EBSD based orientation measurements • EBSD computer code supplied for validation by the reader.

36 MATERIALS SCIENCE↗

optimas v0.1

optimas is a Python library that can coordinate a large number of numerical simulations on high-performance computing resources, with the aim of optimizing a given simulation result. More specifically, this library is currently used for design optimization of laser-plasma particle accelerators. In this context, the performance of particle accelerator designs are often evaluated with large-scale simulation codes, and many separate simulations need to be run - with different design parameters - in order to find the most performant design. optimas facilitates this process by providing a convenient interface to advanced optimizers (e.g. Bayesian optimization), and by coordinating the execution of the different simulations on HPC resources. (This is done by leveraging the library libensemble.) Compared to other open-source optimization libraries (e.g. Ax), optimas is more tailored towards execution on DOE HPC resources (e.g. Perlmutter, Summit, etc.) and is specialized for the type of simulation codes and workflows that are used in the community of laser-plasma acceleration.

Lehe, Remi↗

The iRage Cookbook [Slides]

iRage is a family of Zsh and Python 3 scripts designed to accelerate the process of submitting calculations for the novice xRage user. iRage reduces the time to write a new input deck and submit an xRage problem to the production queue to about 15 minutes, assuming the user has defined the initial geometry using a program like Osito or linked to problem geometries generated by codes such as Abaqus, Flag, or Pagosa. iRage runs on Linux and Mac systems.

97 MATHEMATICS AND COMPUTING↗

Enabling Catalog Simulations of Transient and Variable Sources Based on LSST Cadence Strategies

The American Astronomical Society. All rights reserved.. The Large Synoptic Survey Telescope (LSST) project will conduct a 10 year multi-band survey starting in 2022. Observing strategies for this survey are being actively investigated, and the science capabilities can be best forecasted on the basis of simulated strategies from the LSST Operations Simulator (OpSim). This paper describes the way in which OpSim simulates a stochastic realization of the sequence of LSST pointings over the survey duration, and is based on a model of the observatory (including telescope) and historical data of observational conditions. OpSim outputs contain a record of each simulated pointing of the survey along with a complete characterization of the pointing in terms of observing conditions, and some useful quantities derived from the characteristics of the pointing. Thus, each record can be efficiently used to derive the properties of observations of all astrophysical sources found in that pointing. However, in order to obtain the time series of observations (light curves) of a set of sources, it is often more convenient to compute all observations of an astrophysical source, and iterate over sources. In this document, we describe the open source python package OpSimSummary, which allows for a convenient reordering. The objectives of this package are to provide users with an Application Programming Interface for accessing all such observations and summarizing this information in the form of intermediate data products usable by third party software such as SNANA, thereby also bridging the gap between official LSST products and preexisting simulation codes.

79 ASTRONOMY AND ASTROPHYSICS↗

pynucastro: A Python Library for Nuclear Astrophysics

We describe pynucastro 2.0, an open-source library for interactively creating and exploring astrophysical nuclear reaction networks. We demonstrate new methods for approximating rates and use detailed balance to create reverse rates, show how to build networks and determine whether they are appropriate for a particular science application, and discuss the changes made to the library over the past few years. Finally, we demonstrate the validity of the networks produced and share how we use pynucastro networks in simulation codes.

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗

Reproducible, Component-based Modeling with TopoFlow, A Spatial Hydrologic Modeling Toolkit

Modern geoscientists have online access to an abundance of different data sets and models, but these resources differ from each other in myriad ways and this heterogeneity works against interoperability as well as reproducibility. The purpose of this paper is to illustrate the main issues and some best practices for addressing the challenge of reproducible science in the context of a relatively simple hydrologic modeling study for a small Arctic watershed near Fairbanks, Alaska. This study requires several different types of input data in addition to several, coupled model components. All data sets, model components and processing scripts (e.g. for preparation of data and figures, and for analysis of model output) are fully documented and made available online at persistent URLs. Similarly, all source code for the models and scripts is open-source, version controlled and made available online via GitHub. Each model component has a Basic Model Interface (BMI) to simplify coupling and its own HTML help page that includes a list of all equations and variables used. The set of all model components (TopoFlow) has also been made available as a Python package for easy installation. Three different graphical user interfaces for setting up TopoFlow runs are described, including one that allows model components to run and be coupled as web services.

58 GEOSCIENCES↗

Multiverse: Bayesian model selection for neural networks

Multiverse is a code repository for a set of tools for Bayesian model selection for neural networks. The goal of the tools is to provide capabilities for selecting among prior and model specifications for Bayesian neural networks. Multiverse will include tools for creating Bayesian neural networks, evaluating the Bayesian model evidence, and performing inference in Bayesian neural networks. These components are written in Python, a high-level programming language that takes advantage of the Python ecosystem of high-quality open-source packages for machine learning and signal processing.

Klein, Natalie↗

lasy v0.1

Lasy is a Python library that facilitates numerical simulations of the interaction of complex laser pulses with plasmas. More specifically, lasy offers many ways to define complex laser pulses (e.g. from commonly-known analytical formulas, from experimental measurements, etc.) and then computes and saves the corresponding laser field in a standardized file. This file can then be read by external plasma simulation codes, that will then simulate the interaction between the complex laser pulse and a plasma. Lasy is useful for instance for numerical simulations of plasma-based particle accelerators, plasma-based laser amplification, etc. Lasy avoids having to duplicate the code that defines complex laser pulses in each plasma simulation codes, and instead provides a trusted, centralized implementation.

Lehe, Remi↗

OpenFerro v0.1.0

OpenFerro is a Python package for on-lattice atomistic dynamics simulation of ferroic materials. OpenFerro is based on JAX, a high-performance linear algebra package supporting auto-differentiation and GPU acceleration. OpenFerro is designed to minimize the effort required to build on-lattice Hamiltonian models, and to perform molecular dynamics (MD) and Landau-Lifshitz-Gilbert simulations. Unlike existing codes, OpenFerro provides a unified interface to model different types of local order parameters.

Xie, Pinchen [Lawrence Berkeley National Laborator↗

GOOML Big Kahuna Forecast Modeling and Genetic Optimization Files

This submission includes example files associated with the Geothermal Operational Optimization using Machine Learning (GOOML) Big Kahuna fictional power plant, which uses synthetic data to model a fictional power plant. A forecast was produced using the GOOML data model framework and fictional input data, and a genetic optimization is included which determines optimal flash plant parameters. The inputs and outputs associated with the forecast and genetic optimization are included. The input and output files consist of data, configuration files, and plots. A link to the Physics-Guided Neural Networks (phygnn) GitHub repository is also included, which augments a traditional neural network loss function with a generic loss term that can be used to guide the neural network to learn physical or theoretical constraints. phygnn is used by the GOOML framework to help integrate its machine learning models into the relevant physics and engineering applications. Note that the data included in this submission are intended to provide a demonstration of GOOML's capabilities. Additional files that have not been released to the public are needed for users to run these models and reproduce these results. Units can be found in the readme data resource.

15 GEOTHERMAL ENERGY↗

Coupling Subsurface and Above-Surface Models for Optimizing the Design of Borefields and District Heating and Cooling Systems

Accurate dynamic energy simulation is important for the design and sizing of district heating and cooling systems with geothermal heat exchange for seasonal energy storage. Current modeling approaches in building and district energy simulation tools typically consider heat conduction through the ground between boreholes without flowing groundwater. While detailed simulation tools for subsurface heat and mass transfer exist, these fall short in simulating above-surface energy systems. To support the design and operation of such systems, the study developed a coupled model including a software package for building and district energy simulation, and software for detailed heat and mass transfer in the subsurface. For the first, it uses the open-source Modelica Buildings Library, which includes dynamic simulation models for building and district energy and control systems. For the heat and mass transfer in the soil, it uses the TOUGH simulator. The TOUGH family of codes can model heat and multi-phase, multi-component mass transport for a variety of fluid systems, as well as chemical reactions, in fractured porous media. The study validated the coupled modeling approach by comparing the simulation results with one from the g-function based ground response model. It then looked into effects when the water table and the regional groundwater flow are considered in the ground, from the perspective of heat exchange between borehole and ground, and the electrical consumption of the district heating and cooling systems. To access the simulation models, please find the links in the submission: -- For coupled approach validation: see model Buildings.Fluid.Geothermal.Borefields.Examples.BorefieldsWithTough and Buildings.Examples.DistrictReservoirNetworks.Examples.Reservoir3Variable_TOUGH from the "Modelica Building Library" resource, branch issue1495_tough_interface, commit a2667c0. -- For the study of the effect of water table: see model Buildings.Examples.DistrictReservoirNetworks.Examples.Reservoir3Variable_TOUGH from he "Modelica Building Library" resource, branch issue1495_tough_interface_moreIO, commit 760de49. -- For the study of the effect of regional groundwater flow: see Buildings.Examples.DistrictReservoirNetworks.Examples.Reservoir3Variable_TOUGH from he "Modelica Building Library" resource, branch issue1495_tough_interface_moreIO_3D, commit c2a2d2a. The coupling interface script "GrounResponse.py" can be found from the above links in the folder Buildings/Resources/Python-Sources. Also, the needed files for TOUGH simulation are in the folder Buildings/Resources/Python-Sources/ToughFiles that can be accessed through the above links. A brief description of these files is given below; detailed specifications for the first three files may be found in the TOUGH3 Users Guide (Jung et al., 2018) https://tough.lbl.gov/documentation/tough-manuals/. (1) INCON - initial conditions for each grid block (2) INFILE - main input file with material properties and control parameters (3) MESH - description of the computational grid (4) readsave - Modelica/TOUGH interface program: read the final output of TOUGH simulation after TOUGH time step and prepare for transfer to Modelica for next Modelica time step (5) readsave.inp - input parameters for program readsave (6) writeincon - Modelica/TOUGH interface program: write the output of Modelica after Modelica time step and prepare for transfer to TOUGH as initial conditions for the next TOUGH step (7) writeincon.inp - input parameters for program writeincon

15 GEOTHERMAL ENERGY↗

AeroDyn V15.04: Design Tool for Wind and MHK Turbines

AeroDyn is a time-domain wind and MHK turbine aerodynamics module that can be coupled into the FAST version 8 multi-physics engineering tool to enable aero-elastic simulation of horizontal-axis wind turbines. AeroDyn V15.04 has been updated to include a cavitation check for MHK turbines, and can be driven as a standalone code to compute wind turbine aerodynamic response uncoupled from FAST. Note that while AeroDyn has been updated to v15.04, FAST v8.16 has not yet been updated and still uses AeroDyn v15.03.

16 TIDAL AND WAVE POWER↗