Search NASA⌕ Search

SEARCH · Search NASA

Results for “Python interface”

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 451 records · Page 25

Xopt and Badger: a machine learning ecosystem for real-time accelerator control and optimization

Machine learning (ML)-based black-box optimization algorithms have demonstrated significant improvements in accelerator optimization speed, often by orders of magnitude. However, deploying these algorithms in real-time facility control remains challenging due to the specialized expertise and infrastructure required. To bridge this gap, we introduce the Xopt ecosystem, a versatile suite of tools designed to make advanced ML-based optimization accessible to the broader accelerator community. This ecosystem includes Xopt, a modular Python framework that facilitates the integration of ML-based optimization algorithms with arbitrary control problems, and Badger, a graphical user interface built on top of Xopt, which enables seamless deployment of ML algorithms in real-time control systems. The Xopt ecosystem has been successfully applied towards solving challenging real-time control problems at leading international accelerator facilities, including SLAC, LBNL, Argonne, Fermilab, BNL, DESY, and ESRF, demonstrating its effectiveness in real-world optimization tasks. In this presentation, we provide an overview of Xopt’s capabilities and illustrate its impact through case studies from SLAC accelerator facilities including LCLS, LCLS-II, and FACET-II.

Roussel, Ryan [SLAC]↗

LaDa™

High-Throughput software platform to create/launch/analyze physics-related calculations. The front-end is a python API which allows the user to create any conceivable first-principles physics calculation. Is is coupled to an ipython interface to launch and retrieve large number of calculations. It was successfully used in high-throughput calculations of point defect formation enthalpies, compound formation enthalpies, and a genetic algorithm search of direct-gap silicon/germanium structures.

Source record↗

A software package for plasma facing component analysis and design: the Heat flux Engineering Analysis Toolkit (HEAT)

The engineering limits of plasma facing components (PFCs) constrain the allowable operational space of tokamaks. Poorly managed heat fluxes that push the PFCs beyond their limits not only degrade core plasma performance via elevated impurities, but can also result in PFC failure due to thermal stresses or melting. Simple axisymmetric assumptions fail to capture the complex interaction between 3D PFC geometry and 2D or 3D plasmas. This results in fusion systems that must either operate with increased risk or reduce PFC loads, potentially through lower core plasma performance, to maintain a nominal safety factor. High precision 3D heat flux predictions are necessary to accurately ascertain the state of a PFC given the evolution of the magnetic equilibrium. A new code, the Heat flux Engineering Analysis Toolkit (HEAT), has been developed to provide high precision 3D predictions and analysis for PFCs. HEAT couples many otherwise disparate computational tools together into a single open source python package. Magnetic equilibrium, engineering CAD, finite volume solvers, scrape off layer plasma physics, visualization, high performace computing, and more, are connected in a single web-based user interface. Linux users may use HEAT without any software prerequisites via an appImage. This manuscript introduces HEAT, discusses the software architecture, presents first HEAT results, and outlines physics modules in development.

divertor physics↗

Accessible, uniform protein property prediction with a scikit-learn based toolset AIDE

Summary Protein property prediction via machine learning with and without labeled data is becoming increasingly powerful, yet methods are disparate and capabilities vary widely over applications. The software presented here, “Artificial Intelligence Driven protein Estimation (AIDE)”, enables instantiating, optimizing, and testing many zero-shot and supervised property prediction methods for variants and variable length homologs in a single, reproducible notebook or script by defining a modular, standardized application programming interface (API), i.e. drop-in compatible with scikit-learn transformers and pipelines. Availability and implementation AIDE is an installable, importable python package inheriting from scikit-learn classes and API and is installable on Windows, Mac, and Linux. Many of the wrapped models internal to AIDE will be effectively inaccessible without a GPU, and some assume CUDA. The newest stable, tested version can be found at https://github.com/beckham-lab/aide_predict and a full user guide and API reference can be found at https://beckham-lab.github.io/aide_predict/. Static versions of both at the time of writing can be found on Zenodo.

36 MATERIALS SCIENCE↗

VERAIO Software Management Plan

VERAIO is a set of utility codes used to provide a common set of inputs and outputs to the Virtual Environment for Reactor Applications (VERA). VERA is a collection of several different computer codes that all have a common input and output. This prevents the need to manage input and output from each individual code, allowing for ease of use and reducing errors associated with code operability. The VERAIO utilities include VERAIn, VERAView, and VERARun. Each of these utilities is described below. VERAIn is an input processor that reads an ASCII input file generated by users, parses the file, performs some error checking, and writes an XML file to be read by other VERA codes. The main purpose of VERAIn is to provide a common input to all of the VERA codes, so users only need to learn one input. VERAIn is written in Perl and uses YAML configuration files to provide flexibility. VERAView is a graphical user interface (GUI) that reads a VERA hierarchical data format (HDF) output file and allows users to visualize results. VERAView is written in Python. VERARun is a script that drives the VERA execution in a high performance computing (HPC) environment. Work performed at the code level supports the quality assurance program plan (QAPP) (VERA-QA-001) and the VERA Software Quality Assurance Plan (VERA-QA-002).

97 MATHEMATICS AND COMPUTING↗

Modernizing GlideinWMS Factory Monitoring with Prometheus & Grafana

Large-scale scientific experiments like CMS and DUNE rely on the distributed workload management system GlideinWMS to efficiently utilize computing resources across heterogeneous computing environments. GlideinWMS currently records Factory statistics using Round Robin Databases (RRDBs), XML, and JSON files, and these statistics are displayed via custom monitoring Web pages, thereby limiting integration with modern observability platforms. This project investigates the use of Prometheus-based instrumentation to expose Factory metrics using OpenTelemetry principles. Factory statistics related to Glidein submission and job execution are exported as Prometheus metrics through the Prometheus Python Client Library and are served via an HTTP metrics endpoint. The collected metrics are inspected using the Prometheus web-based interface and are visualized through Grafana dashboards within the Landscape monitoring infrastructure at Fermilab. This project significantly streamlines the integration of modern monitoring technologies into GlideinWMS and establishes a framework for extending observability across additional system components.

Appiah, Gideon [Grambling State U.]↗

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↗

BaseBuddy v1

The software "BaseBuddy" (basebuddy.lbl.gov) is a user-friendly web app designed for codon optimization of heterologous genes. Codon optimization is a widely used technique to enhance the expression levels of non-native genes. Our app is built on the DNA Chisel Python library (Zulkower and Rosser, 2020), which offers highly customizable and transparent gene optimization. Unlike DNA Chisel, which is a command-line interface software with numerous optional functions, our web app simplifies the process for users. Additionally, while DNA Chisel relies on the outdated Kazusa codon usage database, our app introduces the option to utilize the most recent version of the CoCoPUTs database (Athey et al., 2017). By incorporating CoCoPUTs, we also expand the range of target organisms and maintain up-to-date sequencing data for more accurate codon optimization results.

Schmidt, Matthias↗

Achieving Robustness to Uncertainty for Financial Decision-making

This report investigates the concept of robustness analysis to support financial decision-making. Financial models, that forecast future stock returns or market conditions, depend on assumptions that might be unwarranted and variables that might exhibit large fluctuations from their last-known values. The analysis of robustness explores these sources of uncertainty, and recommends model settings such that the forecasts used for decision-making are as insensitive as possible to the uncertainty. A proof-of-concept is presented with the Capital Asset Pricing Model. The robustness of model predictions is assessed using info-gap decision theory. Info-gaps are models of uncertainty that express the “distance,” or gap of information, between what is known and what needs to be known in order to support the decision. The analysis yields a description of worst-case stock returns as a function of increasing gaps in our knowledge. The analyst can then decide on the best course of action by trading-off worst-case performance with “risk”, which is how much uncertainty they think needs to be accommodated in the future. The report also discusses the Graphical User Interface, developed using the MATLAB® programming environment, such that the user can control the analysis through an easy-to-navigate interface. Three directions of future work are identified to enhance the present software. First, the code should be re-written using the Python scientific programming software. This change will achieve greater cross-platform compatibility, better portability, allow for a more professional appearance, and render it independent from a commercial license, which MATLAB® requires. Second, a capability should be developed to allow users to quickly implement and analyze their own models. This will facilitate application of the software to the evaluation of proprietary financial models. The third enhancement proposed is to add the ability to evaluate multiple models simultaneously. When two models reflect past data with similar accuracy, the more robust of the two is preferable for decision-making because its predictions are, by definition, less sensitive to the uncertainty.

97 MATHEMATICS AND COMPUTING↗

Graph Visualization for RDF Graphs with SPARQL-EndPoints

RDF graphs are hard to visualize as triples. This software module is a web interface that connects to a SPARQL endpoint and retrieves graph data that the user can explore interactively and seamlessly. The software written in python and JavaScript has been tested to work on screens as little as the smart phones to large screens such as EVEREST.

Sukumar, Sreenivas R↗

Europa Clipper Payload Verification and Validation: Avionics-Instrument Interface Test Campaign

NASA's Europa Clipper mission will investigate Jupiter's icy moon Europa using a payload suite consisting of nine instruments to address a range of scientific objectives concerning Europa's habitability. As the project proceeds past its Critical Design Review, confidence is being built in the system's ability to achieve mission objectives through the implementation of a rigorous payload verification and validation (V&V) program. As part of this payload V&V program, instrument box-level testing was performed by the payload team to verify select instrument-avionics interface requirements. This testing was performed at JPL using the avionics testbed's Bulk Data Storage Emulator (BDSEM) with visiting instrument Test Models. This paper summarizes the Data Link test campaign involving roughly four days of functional testing per instrument, including planning, testing methods, types of issues found, and the requirement closure process. Detail is also provided on the development, deployment, and validation of a standardized analysis tool used in data reviews. This testing verified requirements related to commanding rates, loss of link, packet format, clock counters, loopback test capability, and SpaceWire jitter and skew margins. Additional risk reduction testing of basic commanding, counter behavior, science data collection and transfer, and interface swapping was also performed. Because the BDSEM venue was not originally designed to be a run for record venue, the process of characterizing venue fidelity and establishing suitability for requirement closure using data collected in this venue will also be addressed.In order to close requirements, an extensible tool was developed to post-process instrument command and telemetry data from their original binary to a human-readable format and give visibility to errors detected within the data, such as packets with Cyclic Redundancy Check errors. This tool, called payload-packet-parser, is a Python 3.9 command line tool built using a variety of open-source Python libraries. Payload-packet-parser was designed to support parsing command and telemetry packets for all Europa Clipper instruments and additional analysis tools were developed for verification of specific information interface requirements. This test campaign, including post-processing using a single parsing and verification toolset, allowed for early interface testing, alleviating testing burdens on instrument teams and buying down risk on the instrument-avionics interface by finding hardware and software issues and idiosyncrasies prior to integration with system test venues. Over twenty issues were discovered across the payload, resulting in software updates and instrument rework well in advance of any system impacts. This paper concludes with an assessment of benefits and costs of this type of testing and lessons learned.

Montanez, Leticia↗

Preserving Command Line Workflow for a Package Management System using ASCII DAG Visualization

Package managers provide ease of access to applications by removing the time-consuming and sometimes completely prohibitive barrier of successfully building, installing, and maintaining the software for a system. A package dependency contains dependencies between all packages required to build and run the target software. Package management system developers, package maintainers, and users may consult the dependency graph when a simple listing is insufficient for their analyses. However, users working in a remote command line environment must disrupt their workflow to visualize dependency graphs in graphical programs, possibly needing to move files between devices or incur forwarding lag. Such is the case for users of Spack, an open source package management system originally developed to ease the complex builds required by supercomputing environments. To preserve the command line workflow of Spack, we develop an interactive ASCII visualization for its dependency graphs. Through interviews with Spack maintainers, we identify user goals and corresponding visual tasks for dependency graphs. We evaluate the use of our visualization through a command line-centered study, comparing it to the system's two existing approaches. We observe that despite the limitations of the ASCII representation, our visualization is preferred by participants when approached from a command line interface workflow.

97 MATHEMATICS AND COMPUTING↗

CMLM (Co-Optimized Machine-Learned Manifolds) [SWR-23-41]

Co-optimized Machine-Learned Manifolds (CMLM) is a data-driven approach for developing reduced-order manifold models for high-dimensional chemically reacting systems. It involves a specially designed neural network, the training of which simultaneously optimizes linear combinations of species that define the manifold, nonlinear mapping to outputs of interest such as reaction rates, and (optionally) subfilter closure for large eddy simulation. This software package provides an implementation of the CMLM approach in Python using the PyTorch machine learning library. A few example cases are included, showing how the tool can be applied to different types of data from 0D and 1D reacting simulations performed using Cantera. The neural networks can be saved in a format that is readable by the Pele suite of combustion solvers for use in reacting computational fluid dynamics simulations. This software repository contains several python scripts to perform various tasks associated with the Co-optimized Machine Learned Manifolds (CMLM) model, which is described in Perry, Henry de Frahan, and Yellapantula, CNF, 2022 (https://doi.org/10.1016/j.combustflame.2022.112286). This includes not only the code that defines the CMLM model, but also scripts to generate suitable training data, scripts to pre-process the data, scripts to train the CMLM model, and scripts to plot the output, as well as various other helper files. The scripts depend on several commonly used python libraries for data analysis and chemical reaction computations. The trained models that result from this tool are designed to work with the an interface being implemented in the Pele suite of reacting flow solvers (https://github.com/AMReX-Combustion).

Perry, Bruce↗

PvaPy: Python API for EPICS PV Access

As the number of sites deploying and adopting EPICS Version 4 grows, so does the need to support PV Access from multiple languages. Especially important are the widely used scripting languages that tend to reduce both software development time and the learning curve for new users. In this paper we describe PvaPy, a Python API for the EPICS PV Access protocol and its accompanying structured data API. Rather than implementing the protocol itself in Python, PvaPy wraps the existing EPICS Version 4 C++ libraries using the Boost.Python framework. This approach allows us to benefit from the existing code base and functionality, and to significantly reduce the Python API development effort. PvaPy objects are based on Python dictionaries and provide users with the ability to access even the most complex of PV Data structures in a relatively straightforward way. Its interfaces are easy to use, and include support for advanced EPICS Version 4 features such as implementation of client and server Remote Procedure Calls (RPC).

Veseli, S.↗

The InSAR Scientific Computing Environment 3.0: A Flexible Framework for NISAR Operational and User-Led Science Processing

The InSAR Scientific Computing Environment (ISCE) was first developed under the NASA Advanced Information Systems Technology as a flexible, extensible object-oriented framework for Interferometric Synthetic Aperture Radar (InSAR) processing. The ISCE framework uses Python 3 at the workflow level, controlling modules of compiled code for functional processing, and managing inputs, outputs, and other flow control services. The currently released version, called ISCE 2.1, is distributed to the research community through the Western North America InSAR Consortium under a research license. The ISCE team is working on the next generation of the code in order to prepare for the NASAISRO SAR (NISAR) mission operational processing. Innovations in this code include augmentation or conversion of the custom Python framework elements in ISCE with the Pyre framework, new workflows for interferometric and polarimetric stack processing, a more intuitive and graphically based user interface, and flow control for hybrid computing environments including CPU/GPU clusters, logging and error tracking facilities, and new more efficient computational modules that exploit graphical processor units (GPUs) when available. The ISCE 3.0 framework is designed to work in an operational environment as well as on a single user’s laptop or compute cluster, with services to discover capabilities and scale computations accordingly.

Buckley, Sean M.↗

Graphical User Interface (GUI) Implementation for Agent-Based Microbial Radiobiology Model

Sending human life past the Low Earth Orbit (LEO) to explore the Moon and Mars will be challenging. The Earth’s magnetic field naturally protects life from deep-space particle radiation such as Galactic Cosmic Rays (GCR) and Solar Particle Events (SPE); these will pose health risks to humans in deep space. Research has been done to investigate these effects, like BioSentinel, the first biological CubeSat to fly beyond the LEO, designed to culture yeast in a microfluidic device and record optical measurements of growth and metabolism. However, experiments can only report cell damage as bulk growth curves, while deep-space radiation causes damage that is heterogeneous among individual cells. AMMPER is an open-source, agent-based, computational model coded in Python to simulate the effects of deep-space radiation on individual yeast cells (Saccharomyces cerevisiae) to facilitate interpretation of biological radiation experiments. Version 1.0 of the code ran in a command line interface (CLI), limiting use to those familiar with modularization, object-oriented programming, and computational models. Here we present a graphical user interface (GUI) for AMMPER to increase its accessibility. GUI development included converting input points and UI files, designing an application and logo, and expanding program packages. Additionally, we added optical assistance that corresponded with simulation parameters, which included simulation type, cell type, ROS model, and radiation dosage, as well as customizable display and file exportation features. Following a pilot testing period, its structure was updated further to enhance abilities, adding increased runs, video visualization, data plotting, and an educational/tutorial component. Future work will include creating a bit installer and runtime environment for AMMPER. Ultimately, the creation of the GUI has two main goals: to facilitate the integration of computational models into the work of researchers in microbial radiobiology, and to act as an interactive and visual resource for space biology education.

yeast↗

RF wave simulation for cold edge plasmas using the MFEM library

A newly developed generic electro-magnetic (EM) simulation tool for modeling RF wave propagation in SOL plasmas is presented. The primary motivation of this development is to extend the domain partitioning approach for incorporating arbitrarily shaped SOL plasmas and antenna to the TORIC core ICRF solver, which was previously demonstrated in the 2D geometry [S. Shiraiwa, et. al., “HISTORIC: extending core ICRF wave simulation to include realistic SOL plasmas”, Nucl. Fusion in press], to larger and more complicated simulations by including a 3D realistic antenna and integrating RF rectified sheath potential model. Such an extension requires a scalable high fidelity 3D edge plasma wave simulation. We used the MFEM [http://mfem.org], open source scalable C++ finite element method library, and developed a Python wrapper for MFEM (PyMFEM), and then a radio frequency (RF) wave physics module in Python. This approach allows for building a physics layer rapidly, while separating the physics implementation being apart from the numerical FEM implementation. An interactive modeling interface was built on pScope [S Shiraiwa, et. al. Fusion Eng. Des. 112, 835] to work with an RF simulation model in a complicated geometry.

70 PLASMA PHYSICS AND FUSION TECHNOLOGY↗

pyDiSCaMB : enabling the use of multipolar scattering factors in Phenix

Multipolar scattering models, such as the transferable aspherical atom model, account for atomic chemical interactions and provide a more accurate representation of experimental data. However, the simpler independent atom model (IAM), which assumes non-interacting atoms, is the only model available in the most widely used macromolecular refinement programs. This is primarily because IAM offers a hard-to-beat combination of computational efficiency and modelling power at typical macromolecular resolutions. By contrast, more accurate multipolar modelling has historically been limited due to its computational cost and the absence of an interface between software capable of calculating structure factors and gradients based on multipolar models and software designed for macromolecular refinement. This work introduces pyDiSCaMB , a Python software package designed to integrate between the computational crystallography toolbox ( cctbx ) and the quantum crystallography library DiSCaMB ( Densities in Structural Chemistry and Molecular Biology ), thus enabling multipolar scattering models in Phenix 's toolkit. The implementation, features and capabilities of pyDiSCaMB are presented, the runtimes for the calculation of structure factor and target gradients with respect to atomic parameters are explored, and Fourier images of electrostatic potential, electron density and deformation maps are computed as illustrative examples. The pyDiSCaMB library will make multipolar modelling widely available to the structural biology community, potentially transforming refinement and model-building for both crystallography and cryogenic electron microscopy (cryoEM).

MATTS data bank↗