SEARCH · Engineering Papers
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.
In this professional development workshop for teachers in New Mexico, the goals are to provide practical hands-on work in Python and create a deep awareness of how programming and Python fit in what we do.
What did my team set out to accomplish:? Can I put a custom Machine Learning Model on FPGA?? Can I analyze network traffic in real time?? Can a QSFP port be used with an FPGA?? Does a visual representation of the latent space enhance our understanding of network traffic?? What is QSFP QSFP (Quad Small Form-Factor Pluggable)? QSFP supports transfer speeds generally up to 100Gb/s? Runs 4 parallel lines running up to 28 Gb/s? Why the latent space is important to our project ?Latent space is the compressed mapping of data points in a non-linear fashion? Create an understanding of the relationship of data collected? Can represent that relationship of a single network packet in 3 points (X, Y, Z) Project Outline FPGA? Custom Xilinx Petalinux Image for the operating system? Python program to collect packets and run them through the DPU (Data Processing Unit)? The program then sends the information over a socket to a computer? Display Program? Python Program that collects the information sent from the FPGA and display it in a graph
The key to success in geothermal drilling is economic feasibility, and a major cost in the development of geothermal resources is the actual drilling of the wells. In this project, a real-time drilling optimization system for geothermal drilling was developed. The system couples three individual components while drilling. The first component is a drill stem vibration analysis model, the second is Mechanical Specific Energy (MSE) analyses, and the third is a detailed PDC Rate of Penetration (ROP) drill bit model for optimum RPM and WOB combinations. The benefit of the coupled system is that the range of WOB and RPM could be selected to avoid drill stem vibrations. Secondly, MSE is used as an efficiency measure and the detailed PDC drill bit model ensures the drill bit does not endure temperatures that exceed the temperature at which the PDC cutters experience accelerated wear. The new detailed PDC bit model is based on rock/bit interaction that physically tracks the PDC cutter wear flats as the bit drills ahead giving the capability to calculate the temperature being generated underneath the worn cutters to better advise on operational parameters to avoid accelerated cutter wear and failure and to ensure that operational parameters are applied so that overall ROP is maximized. By combining the drill stem vibrations and the detailed PDC bit cutter wear and “safe” non-accelerated cutter wear temperature and optimum ranges of operating parameters, it results in higher ROP and lower cost drilling. Single cutter PDC testing performed in different lithologies at Sandia was utilized to verify the PDC cutter forces and depth of cut for new and worn cutters. Based on single cutter PDC temperature modeling, verification using single cutter data from the testing done by National Oilwell Varco (NOV) was performed. Sandia’s Hard-Rock Drilling Facility (HRDF) was utilized to test different drill bit configurations with different cutter designs and wear status with different induced modes of vibration to obtain the critical bit RPM/WOB ranges resulting in ineffective drilling and low ROP. The collected test data were further used to verify and calibrate the full hole PDC ROP model that was developed based on single cutter interaction data. A full coupled drill stem vibration model was formulated and verified with geothermal field data from the Chocolate Mountain Aerial Gunnery Range (CMAGR). A graphical user interface (GUI) was developed using Tkinter library in the computer programming language Python, which integrates all the developed models in one system. The developed system consists mainly of the PDC ROP model, PDC bit wear model, PDC cutter temperature model, Mechanical Specific Energy (MSE) model, and drillstring vibration model integrated into one system. The developed system can be used for both, post well analysis and real-time optimization using different criteria such as ROP maximization or MSE minimization. The software uses Differential Evolution Algorithm (DEA) to find optimum values for operational parameters based on last foot drilled while avoiding the drillstring vibration and cutter temperature critical operating parameters.
Abstract In a manufacturing system, production control‐related decision‐making activities occur at different levels. At the process level, one of the main control activities is to tune the parameters of individual manufacturing equipment. At the system level, the main activity is to coordinate production resources and to route parts to appropriate workstations based on their processing requirement, priority indices, and control policy. At the factory level, the goal is to plan and schedule the processing of parts at different operations for the entire system in order to optimize certain objectives. Note that the results of such activities at different levels are closely coupled and affect the overall performance of the manufacturing system as a whole. Therefore, it is important to systematically integrate these control and optimization activities into one unified platform to ensure the goal of each individual activity is aligned with the overall performance of the system. In this paper, we develop a simulation‐based virtual testbed that implements dynamic optimization, automatic information exchange, and decision‐making from the process‐level, system‐level, and factory‐level of a manufacturing system into an integrated computation environment. This is demonstrated by connecting a Python‐based numerical computation program, discrete‐event simulation software (Simul8), and an optimization solver (CPLEX) via a third‐party master program. The application of this simulation‐based virtual testbed is illustrated by a case study in a machining shop.
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.
This report details the responsibilities, outcomes, and project details of a summer R&D internship at Los Alamos National Laboratory (LANL). LANL is a multidisciplinary laboratory that focuses on current cutting-edge research in many fields such as national security, engineering, materials science, computational modeling, and advanced manufacturing. The goal of the internship project was to work with lab engineers and resources to develop an energy absorbing structure for high-velocity impact applications. The successful development of this technology and methodology would not only positively impact future project funding but also contribute to the laboratory's commitment to solve national security challenges through simultaneous excellence. Such devices would also support efforts surrounding the research and development of energy absorbing structures and would provide new vital information backed by experimentation. Different computational and modeling methods were used to design these structures, in addition to qualitative background information provided by past literature. The resultant designs were successfully tested, and the test results were successfully quantified. From these results, new computational methods were developed through python programming and modeling to predict ideal materialistic properties for these structures given a sufficiently defined application.
This manual describes the use of PETSc for the numerical solution of partial differential equations and related problems on high-performance computers. The Portable, Extensible Toolkit for Scientific Computation (PETSc) 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 message-passing communication. PETSc includes an expanding suite of parallel linear solvers, nonlinear solvers, and time integrators that may be used in application codes written in Fortran, C, C++, and Python. 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 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 dbx, 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.
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.
Research in high energy physics (HEP) requires huge amounts of computing and storage, putting strong constraints on the code speed and resource usage. To meet these requirements, a compiled high-performance language is typically used; while for physicists, who focus on the application when developing the code, better research productivity pleads for a high-level programming language. A popular approach consists of combining Python, used for the high-level interface, and C++, used for the computing intensive part of the code. A more convenient and efficient approach would be to use a language that provides both high-level programming and high-performance. The Julia programming language, developed at MIT especially to allow the use of a single language in research activities, has followed this path. In this paper the applicability of using the Julia language for HEP research is explored, covering the different aspects that are important for HEP code development: runtime performance, handling of large projects, interface with legacy code, distributed computing, training, and ease of programming. The study shows that the HEP community would benefit from a large scale adoption of this programming language. The HEP-specific foundation libraries that would need to be consolidated are identified.
We know that Python is a widely used language in scientific computing. When the goal is high performance, however, Python lags far behind low-level languages such as C and Fortran. To support applications that stress performance, Python needs to access the full capabilities of modern CPUs. That means support for parallel multithreading. In this paper, we describe PyOMP, a system that enables OpenMP in Python. Programmers write code in Python with OpenMP, Numba generates code that compiles to LLVM, and the resulting programs run with performance that approaches that from code written with C and OpenMP. In this paper we provide an update on the PyOMP project and explain how to install it and use it to write parallel multithreaded code in Python.
Given a pre-trained neural network, Inference-Engine performs maps network inputs to outputs by executing the forward pass through the provided network. Although the predominant programming language for machine-learning is Python, most high-performance computing (HPC) applications are written in Fortran, C, or C++. Inference-Engine aims to support HPC programs and is written in Fortran, a language with a large feature set supporting interoperability with C. This software exposes concurrency in a portable way by using standard language features that some modern Fortran compilers can exploit with various optimizations, including offloading computation to a Graphics Processing Unit (GPU). In particular, this software makes extensive use of Fortran's "do concurrent" parallel loop construct, implicitly parallel array statements, and pure procedures that can be invoked inside "do concurrent" blocks. Inference-Engine also supports dynamic choice of inference methods at runtime. Two current options include one method that uses Fortran's "dot_product" intrinsic function inside "do concurrent" blocks and another method that instead uses Fortran' "matmul" array intrinsic function. We plan to investigate automatic compiler offloading of "do concurrent" calculations to GPUs and compile-time substitution of optimized libraries such as the Basic Linear Algebra Library (BLAS) for "matmul" invocations. We also envision the potential for the choice of which method to use could happen at program launch based on in situ performance measurements on any given platform.
We explore the performance and portability of the novel Mojo language for scientific computing workloads on GPUs. As the first language based on the LLVM’s Multi-Level Intermediate Representation (MLIR) compiler infrastructure, Mojo aims to close performance and productivity gaps by combining Python’s interoperability and CUDA-like syntax for compile-time portable GPU programming. We target four scientific workloads: a seven-point stencil (memory-bound), BabelStream (memory-bound), miniBUDE (compute-bound), and Hartree–Fock (compute-bound with atomic operations); and compare their performance against vendor baselines on NVIDIA H100 and AMD MI300A GPUs. We show that Mojo’s performance is competitive with CUDA and HIP for memory-bound kernels, whereas gaps exist on AMD GPUs for atomic operations and for fast-math compute-bound kernels on both AMD and NVIDIA GPUs. Although the learning curve and programming requirements are still fairly low-level, Mojo can close significant gaps in the fragmented Python ecosystem in the convergence of scientific computing and AI.
Helium and Nitrogen are two significant chemical elements that are used to advance cryogenic scientific breakthroughs. Helium is a colorless, odorless, and tasteless gas that becomes liquid at (−452 °F). Nitrogen is a gas at its standard conditions; It becomes solid once temperatures reach below (-346 °F), and it boils and becomes a gas once temperatures reach above (-320 °F). During this research project I used a web-based interactive computing platform called Jupyter Lab to modify various python programs that calculate, and display helium and nitrogen inventory lost from three cryo plants
The demand for precision predictions in the field of high energy physics has dramatically increased over recent years. Experiments conducted at the LHC, as well as precision measurements at the intensity frontier such as Belle II require equally precise theoretical predictions to make full use of the acquired data. To match the experimental precision, second-, third- and, for certain quantities, even higher-order calculations in perturbative quantum field theory are required. To facilitate such calculations, computer software automating as many steps as possible is required. Yet, each calculation poses different challenges and thus, a high level of configurability is required. In this context we present tapir: a tool for identification, manipulation and minimization of Feynman integral families. It is designed to integrate in toolchains based on the computer algebra system FORM, the use of which is common practice in the field. tapir can be used to reduce the complexity of multi-loop problems with cut-filters, topology mapping, partial fraction decomposition and alike. Program Title:tapir CPC Library link to program files:https://doi.org/10.17632/ptc9t46xyn.1 Developer's repository link:https://gitlab.com/tapir-devs/tapir Licensing provisions: GPLv3 Programming language:python 3, C++ Nature of problem: Multi-loop computations require the automatization of a large number of different tasks related to Feynman integral topologies. Among them are the identification and minimization of integral topologies, partial fraction decomposition of topologies in the case of linearly dependent propagators as well as mapping scalar products of loop momenta to scalar functions. Solution method: The minimization of topologies is performed by comparison of their respective Nickel indices [1], even further minimization utilizes Pak's algorithm [2]. To efficiently map scalar products of loop momenta to scalar functions FORM [3] code is generated. Additional comments including restrictions and unusual features: Minimization based on Pak's algorithm slows down for many lines and scales. A coarser minimization using the Nickel indices, however, is still possible. [1]B. Nickel, D. Meiron, G.A.J. Baker, Compilation of 2-pt and 4-pt graphs for continuous spin model, Report, University of Guelph, 1977.[2]A. Pak, J. Phys. Conf. Ser. 368 (2012) 012049, https://doi.org/10.1088/1742-6596/368/1/012049, arXiv:1111.0868.[3]B. Ruijl, T. Ueda, J. Vermaseren, FORM version 4.2, arXiv:1707.06453, 7 2017.
Light output response of scintillators is crucial to the utilization of organic scintillators as effective tools in radiation detection and measurement. While the response is a continuous distribution, the light output corresponding to the maximum energy deposition is crucial in effectively understanding and simulating a detector. There are a variety of fits derived in literature that will vary for every detector material. The Light Output Response Fitter, or LORF Program is a python script designed to easily and quickly compute and plot fits for a variety of scintillator light output models. It includes a stopping power library constructed from SRIM including Organic Glass, EJ309, EJ301, Stilbene, EJ276, and their deuterated counterparts by default, with the ability for the user to add custom stopping power libraries. The user is also capable of importing the python package and utilizing its in-built functions as appropriate. Uses for this capability include plotting and computing a model with known parameters.
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.
Gamma-gamma coincidence spectrometers have the potential to significantly enhance detection sensitivity for ultra-trace radionuclide measurements. The implementation of these spectrometers, however, is limited by the complexity of acquisition hardware, data processing and quantification. This work reports development of a novel radionuclide quantification software for γ-γ coincidence measurements. For any radionuclide, the software parses the Evaluated Nuclear Structure Data File (ENSDF) database, recursively simulating all possible γ-γ coincidence signatures and their respective emission and detection probabilities. Implemented using Python programming language, the software employs several strategies to boost overall computational performance. Since coincidence-based spectrometers are of notable interest in monitoring compliance for the Comprehensive Nuclear-Test-Ban Treaty (CTBT), the software’s execution was tested for 84 CTBT-relevant radionuclides. To date, the software has been experimentally validated for 15 radionuclides using the Advanced Radionuclide Gamma spectrOmeter (ARGO) at Pacific Northwest National Laboratory, USA (PNNL). Notably, the software can be operated in convergence mode, whereby coincidence detection efficiency’s convergence behavior can help avoid unreliable radionuclide activity estimates. With growing number of coincidence spectrometers worldwide, this paper aims to assist the radiation metrology community in developing similar software for their system.
Synthetic biology dictates the data-driven engineering of biocatalysis, cellular functions, and organism behavior. Integral to synthetic biology is the aspiration to efficiently find, access, interoperate, and reuse high-quality data on genotype-phenotype relationships of native and engineered biosystems under FAIR principles, and from this facilitate forward-engineering strategies. However, biology is complex at the regulatory level, and noisy at the operational level, thus necessitating systematic and diligent data handling at all levels of the design, build, and test phases in order to maximize learning in the iterative design-build-test-learn engineering cycle. To enable user-friendly simulation, organization, and guidance for the engineering of biosystems, we have developed an open-source python-based computer-aided design and analysis platform operating under a literate programming user-interface hosted on Github. The platform is called teemi and is fully compliant with FAIR principles. In this study we apply teemi for i) designing and simulating bioengineering, ii) integrating and analyzing multivariate datasets, and iii) machine-learning for predictive engineering of metabolic pathway designs for production of a key precursor to medicinal alkaloids in yeast. The teemi platform is publicly available at PyPi and GitHub.