Engineering Papers⌕ Search

SEARCH · Engineering Papers

Results for “Software algorithms”

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 757 records · Page 42

Mini-apps for high performance data analysis

Scaling-up scientific data analysis and machine learning algorithms for data-driven discovery is a grand challenge that we face today. Despite the growing need for analysis from science domains that are generating `Big Data' from instruments and simulations, building high-performance analytical workflows of data-intensive algorithms have been daunting because: (i) the `Big Data' hardware and software architecture landscape is constantly evolving, (ii) newer architectures impose new programming models, and (iii) data-parallel kernels of analysis algorithms and their performance facets on different architectures are poorly understood. To address these problems, we have: (i) identified scalable data-parallel kernels of popular data analysis algorithms, (ii) implemented `Mini-Apps' of those kernels using different programming models (e.g. Map Reduce, MPI, etc.), (iii) benchmarked and validated the performance of the kernels in diverse architectures. In this paper, we discuss two of those Mini-Apps and show the execution of principal component analysis built as a workflow of the Mini-Apps. We show that Mini-Apps enable scientists to (i) write domain-specific data analysis code that scales on most HPC hardware and (ii) and offers the ability (most times with over a 10x speed-up) to analyze data sizes 100 times the size of what off-the-shelf desktop/workstations of today can handle.

Sukumar, Sreenivas R.↗

On-demand data analytics in HPC environments at leadership computing facilities: Challenges and experiences

Scaling-up scientific data analysis and machine learning algorithms for data-driven discovery is a grand challenge that we face today. Despite the growing need for analysis from science domains that are generating `Big Data' from instruments and simulations, building high-performance analytical workflows of data-intensive algorithms have been daunting because: (i) the `Big Data' hardware and software architecture landscape is constantly evolving, (ii) newer architectures impose new programming models, and (iii) data-parallel kernels of analysis algorithms and their performance facets on different architectures are poorly understood. To address these problems, we have: (i) identified scalable data-parallel kernels of popular data analysis algorithms, (ii) implemented `Mini-Apps' of those kernels using different programming models (e.g. Map Reduce, MPI, etc.), (iii) benchmarked and validated the performance of the kernels in diverse architectures. In this paper, we discuss two of those Mini-Apps and show the execution of principal component analysis built as a workflow of the Mini-Apps. We show that Mini-Apps enable scientists to (i) write domain-specific data analysis code that scales on most HPC hardware and (ii) and offers the ability (most times with over a 10x speed-up) to analyze data sizes 100 times the size of what off-the-shelf desktop/workstations of today can handle.

Harney, John↗

Seascape Interface Control Document

This paper serves as the Interface Control Document (ICD) for the Seascape automated test harness developed at Sandia National Laboratories. The primary purposes of the Seascape system are: (1) provide a place for accruing large, curated, labeled data sets useful for developing and evaluating detection and classification algorithms (including, but not limited to, supervised machine learning applications) (2) provide an automated structure for specifying, running and generating reports on algorithm performance. Seascape uses GitLab, Nexus, Solr, and Banana, open source software, together with code written in the Python language, to automatically provision and configure computational nodes, queue up jobs to accomplish algorithms test runs against the stored data sets, gather the results and generate reports which are then stored in the Nexus artifact server.

97 MATHEMATICS AND COMPUTING↗

dfnWorks, Version 1.0

DFNWorks is a suite of software for generating and solving flow and transport physics on a Discrete Fracture Network (DFN). The suite is composed of three components: DFNGen: Stochastic fracture generation, mesh generation, model setup; DFNFlow: Flow solution using PFLOTRAN or FEHM control volume formulation solver; DFNTrans: Particle tracking transport; DFNGen Algorithm Description: This is a workflow that uses Mathematica software, Python scripts written by the authors and the LaGriT software to generate; DFNFlow; The solution of flow in porous media is accomplished by coupling DFNGen output with the existing software packages FEHM and PFLOTRAN. The DFNWorks workflow involves modules and scripts that translate DFNGen output to formats compatible with FEHM and PFLOTRAN input. FEHM LA-CC-2012-083 PFLOTRAN LA-CC-09-047 LaGriT LA-CC-07-38 DFNTrans Stand alone particle tracking algorithm that takes FEHM/PFLOTRAN flow solution as output and computes velocity field and advects particles.

Makedonska, Nataliia↗

dfnWorks, Version 1.0

DFNWorks is a suite of software for generating and solving flow and transport physics on a Discrete Fracture Network (DFN). The suite is composed of three components: DFNGen: Stochastic fracture generation, mesh generation, model setup; DFNFlow: Flow solution using PFLOTRAN or FEHM control volume formulation solver; DFNTrans: Particle tracking transport; DFNGen Algorithm Description: This is a workflow that uses Mathematica software, Python scripts written by the authors and the LaGriT software to generate; DFNFlow; The solution of flow in porous media is accomplished by coupling DFNGen output with the existing software packages FEHM and PFLOTRAN. The DFNWorks workflow involves modules and scripts that translate DFNGen output to formats compatible with FEHM and PFLOTRAN input. FEHM LA-CC-2012-083 PFLOTRAN LA-CC-09-047 LaGriT LA-CC-07-38 DFNTrans Stand alone particle tracking algorithm that takes FEHM/PFLOTRAN flow solution as output and computes velocity field and advects particles.

Makedonska, Nataliia↗

dfnWorks, Version 2.0

DFNWorks is a suite of software for generating and solving flow and transport physics on a Discrete Fracture Network (DFN). The suite is composed of three components: DFNGen: Stochastic fracture generation, mesh generation, model setup; DFNFlow: Flow solution using PFLOTRAN or FEHM control volume formulation solver; DFNTrans: Particle tracking transport; DFNGen Algorithm Description: This is a workflow that uses C++ software version for fracture generation, Python scripts written by the authors and the LaGriT software to generate computational mesh. DFNFlow The solution of flow in porous media is accomplished by coupling DFNGen output with the existing software packages FEHM and PFLOTRAN. The DFNWorks workflow involves modules and scripts that translate DFNGen output to formats compatible with FEHM and PFLOTRAN input. FEHM LA-CC-2012-083 PFLOTRAN LA-CC-09-047 LaGriT LA-CC-07-38 DFNTrans Stand-alone particle tracking algorithm that takes FEHM/PFLOTRAN flow solution as output and computes velocity field and advects particles.

Makedonska, Nataliia↗

dfnWorks, Version 2.0

DFNWorks is a suite of software for generating and solving flow and transport physics on a Discrete Fracture Network (DFN). The suite is composed of three components: DFNGen: Stochastic fracture generation, mesh generation, model setup; DFNFlow: Flow solution using PFLOTRAN or FEHM control volume formulation solver; DFNTrans: Particle tracking transport; DFNGen Algorithm Description: This is a workflow that uses C++ software version for fracture generation, Python scripts written by the authors and the LaGriT software to generate computational mesh. DFNFlow The solution of flow in porous media is accomplished by coupling DFNGen output with the existing software packages FEHM and PFLOTRAN. The DFNWorks workflow involves modules and scripts that translate DFNGen output to formats compatible with FEHM and PFLOTRAN input. FEHM LA-CC-2012-083 PFLOTRAN LA-CC-09-047 LaGriT LA-CC-07-38 DFNTrans Stand-alone particle tracking algorithm that takes FEHM/PFLOTRAN flow solution as output and computes velocity field and advects particles.

Makedonska, Nataliia↗

A reliable control system for measurement on film thickness in copper chemical mechanical planarization system

In recent years, a variety of film thickness measurement techniques for copper chemical mechanical planarization (CMP) are subsequently proposed. In this paper, the eddy-current technique is used. In the control system of the CMP tool developed in the State Key Laboratory of Tribology, there are in situ module and off-line module for measurement subsystem. The in situ module can get the thickness of copper film on wafer surface in real time, and accurately judge when the CMP process should stop. This is called end-point detection. The off-line module is used for multi-points measurement after CMP process, in order to know the thickness of remained copper film. The whole control system is structured with two levels, and the physical connection between the upper and the lower is achieved by the industrial Ethernet. The process flow includes calibration and measurement, and there are different algorithms for two modules. In the process of software development, C++ is chosen as the programming language, in combination with Qt OpenSource to design two modules’ GUI and OPC technology to implement the communication between the two levels. In addition, the drawing function is developed relying on Matlab, enriching the software functions of the off-line module. The result shows that the control system is running stably after repeated tests and practical operations for a long time.

42 ENGINEERING↗

A massively parallel time-domain coupled electrodynamics–micromagnetics solver

We present a high-performance coupled electrodynamics–micromagnetics solver for full physical modeling of signals in microelectronic circuitry. The overall strategy couples a finite-difference time-domain approach for Maxwell’s equations to a magnetization model described by the Landau–Lifshitz–Gilbert equation. The algorithm is implemented in the Exascale Computing Project software framework, AMReX, which provides effective scalability on manycore and GPU-based supercomputing architectures. Furthermore, the code leverages ongoing developments of the Exascale Application Code, WarpX, which is primarily being developed for plasma wakefield accelerator modeling. Our temporal coupling scheme provides second-order accuracy in space and time by combining the integration steps for the magnetic field and magnetization into an iterative sub-step that includes a trapezoidal temporal discretization for the magnetization. The performance of the algorithm is demonstrated by the excellent scaling results on NERSC multicore and GPU systems, with a significant (59×) speedup on the GPU using a node-by-node comparison. We demonstrate the utility of our code by performing simulations of an electromagnetic waveguide and a magnetically tunable filter.

97 MATHEMATICS AND COMPUTING↗

VAST: the Void Analysis Software Toolkit

Voids are expansive regions in the universe containing significantly fewer galaxies than surrounding galaxy clusters and filaments. They are a fundamental feature of the cosmic web and provide important information about galaxy physics and cosmology. For example, correlations between voids and luminous tracers of large-scale structure improve constraints on the expansion of the universe as compared to using tracers alone, and numerous studies have shown that the void environment influences the evolution of galaxies. However, what constitutes a void is vague and formulating a concrete definition to use in a void-finding algorithm is not trivial. As a result, several different algorithms exist to identify these cosmic underdensities. Our Void Analysis Software Toolkit, or VAST, provides Python 3 implementations of two such algorithms: VoidFinder and V 2 . This consolidation of two popular void-finding algorithms allows the user to, for example, easily compare the results of their analysis using different void definitions.

97 MATHEMATICS AND COMPUTING↗

Resilience Through Data-Driven, Intelligent Designed Control: A Formal Methods Approach

The PNNL and GTRI team developed a strategy to integrate temporal logic rule specification for detection of cyber-intrusion in the source code and control algorithms of CPS using advanced cyber-data. The GTRI team utilized its capabilities in rule synthesis and temporal logic specifications for software assurance and verification to detect and predict impact of cyber-intrusions and malware in the computational and control algorithms of cyber-physical systems. The team also developed a testing and verification approach that could be used to validate the suggested approach against a realistic use-case CPS showcasing improvements in system impact prediction performance. Temporal logic offers a compact expression of events in absolute and relative time and has a formalized translation to state machines. As such, temporal logic rules can feasibly be synthesized to any system as a rule engine, with the process being formally verified to be correct. The goal here is to utilize temporal logic rules to detect cyber-attacks and manipulations in the computational algorithms and provide real-time software assurance and verification guarantees.

97 MATHEMATICS AND COMPUTING↗

Model Based Optimal Sensor Network Design for Condition Monitoring in an IGCC Plant

This report summarizes the achievements and final results of this program. The objective of this program is to develop a general model-based sensor network design methodology and tools to address key issues in the design of an optimal sensor network configuration: the type, location and number of sensors used in a network, for online condition monitoring. In particular, the focus in this work is to develop software tools for optimal sensor placement (OSP) and use these tools to design optimal sensor network configuration for online condition monitoring of gasifier refractory wear and radiant syngas cooler (RSC) fouling. The methodology developed will be applicable to sensing system design for online condition monitoring for broad range of applications. The overall approach consists of (i) defining condition monitoring requirement in terms of OSP and mapping these requirements in mathematical terms for OSP algorithm, (ii) analyzing trade-off of alternate OSP algorithms, down selecting the most relevant ones and developing them for IGCC applications (iii) enhancing the gasifier and RSC models as required by OSP algorithms, (iv) applying the developed OSP algorithm to design the optimal sensor network required for the condition monitoring of an IGCC gasifier refractory and RSC fouling. Two key requirements for OSP for condition monitoring are desired precision for the monitoring variables (e.g. refractory wear) and reliability of the proposed sensor network in the presence of expected sensor failures. The OSP problem is naturally posed within a Kalman filtering approach as an integer programming problem where the key requirements of precision and reliability are imposed as constraints. The optimization is performed over the overall network cost. Based on extensive literature survey two formulations were identified as being relevant to OSP for condition monitoring; one based on LMI formulation and the other being standard INLP formulation. Various algorithms to solve these two formulations were developed and validated. For a given OSP problem the computation efficiency largely depends on the “size” of the problem. Initially a simplified 1-D gasifier model assuming axial and azimuthal symmetry was used to test out various OSP algorithms. Finally these algorithms were used to design the optimal sensor network for condition monitoring of IGCC gasifier refractory wear and RSC fouling. The sensors type and locations obtained as solution to the OSP problem were validated using model based sensing approach. The OSP algorithm has been developed in a modular form and has been packaged as a software tool for OSP design where a designer can explore various OSP design algorithm is a user friendly way. The OSP software tool is implemented in Matlab/Simulink© in-house. The tool also uses few optimization routines that are freely available on World Wide Web. In addition a modular Extended Kalman Filter (EKF) block has also been developed in Matlab/Simulink© which can be utilized for model based sensing of important process variables that are not directly measured through combining the online sensors with model based estimation once the hardware sensor and their locations has been finalized. The OSP algorithm details and the results of applying these algorithms to obtain optimal sensor location for condition monitoring of gasifier refractory wear and RSC fouling profile are summarized in this final report.

20 FOSSIL-FUELED POWER PLANTS↗

Microwave Cavity Simulation Using Ansys HFSS

The design of microwave cavity detectors for axion dark matter research is often accomplished using advanced full-wave electromagnetic simulation software tools. These tools provide a cost-effective approach to evaluate a wide variety of cavity configurations, frequency tuning mechanisms, and conductive or dielectric materials and coatings. One simulation software package used for this application is Ansys High Frequency Structure Simulator (HFSS), which is based upon the well-established finite element method. HFSS includes numerous features useful for microwave cavity design such as parametric geometry modeling, adaptive meshing algorithm, curvilinear mesh elements, driven modal and eigenmode matrix solvers, and optimization algorithms. This paper describes the use of the HFSS software to simulate microwave cavities for axion haloscope detectors, with an example tutorial for a cylindrical cavity. Excellent agreement between the simulated and analytical results is shown for the resonant frequency, quality factor, and form factor.

Ansys HFSS, Cavity simulation, finite element mode↗

Testing Controls to Mitigate Fatigue Loads in the Controls Advanced Research Turbine

Wind turbines are complex, nonlinear, dynamic systems forced by aerodynamic, gravitational, centrifugal, and gyroscopic loads. The aerodynamics of wind turbines is nonlinear, unsteady, and complex. Turbine rotors are subjected to a complicated three-dimensional (3D) turbulent wind inflow field with imbedded coherent vortices that drive fatigue loads and reduce lifetime. Design of control algorithms for wind turbines must account for multiple control objectives. Future large multi-megawatt turbines must be designed with lighter weight structures, using active controls to mitigate fatigue loads, maximize energy capture, and add active damping to maintain stability for these dynamically active structures operating in a complex environment. Researchers at the National Renewable Energy Laboratory are designing, implementing, and testing advanced controls to maximize energy extraction and reduce structural dynamic loads. These control designs are based on a linear model of the turbine that is generated by specialized modeling software. This paper describes testing of a control algorithm to mitigate blade, tower, and drivetrain loads using advanced state-space control methods. The controller uses independent blade pitch to regulate the turbine's speed in Region 3, mitigate the effects of shear across the rotor disk, and add active damping to the tower's first fore-aft bending mode. Additionally, a separate generator torque control loop is designed to add active damping to the tower's first side-side mode and the first drivetraintorsion mode. This paper discusses preliminary implementation and field tests of this controller in the Controls Advanced Research Turbine at the National Renewable Energy Laboratory. Also included are preliminary comparisons of the performance of this controller to results from a typical baseline Proportional-Integral-Derivative controller designed with just Region 3 speed regulation as the goal.

17 WIND ENERGY↗

An end-to-end workflow for executing a classically bootstrapped variational quantum algorithm on an academic quantum computer

Academic quantum computing platforms often face unique challenges in executing quantum workloads due to fragmented software environments and limited engineering support. Unlike commercial ecosystems, academic devices typically evolve without full-stack integration in mind, making it difficult to run complex applications—such as variational quantum algorithms (VQA)—reliably and efficiently. Issues such as incompatible software layers and lack of automated job management significantly increase the overhead of theory-experiment collaboration. To address these challenges, we develop a modular, end-to-end workflow that decouples application-layer code from low-level hardware control, automates circuit submission and result collection, and supports fine-grained circuit-level job scheduling and recovery. The architecture employs a dual-end application programming interface (API) design, enabling robust operation across unstable or resource-constrained hardware backends. For practical use, the framework is lightweight and user-friendly, allowing rapid prototyping of full-stack workflows using basic Python tools. We validate this workflow on a high-fidelity trapped-ion quantum computer by demonstrating a variational quantum eigensolver (VQE) experiment with a classically bootstrapped ansatz initialization technique. The system successfully executed over 60,000 circuits across multiple molecular test cases with minimal human intervention, highlighting the framework’s effectiveness in enabling reproducible, resilient quantum experimentation in academic settings.

Clifford↗

Investigation of Portable Event-Based Monte Carlo Transport Using the NVIDIA Thrust Library

Power consumption considerations are driving future high performance computing platforms toward many-core computing architectures. Los Alamos National Laboratory's Trinity machine, available in 2016, will use both Intel Xeon Haswell processors and Intel Xeon Phi Knights Landing many integrated core (MIC) architecture coprocessors. Lawrence Livermore National Laboratory's Sierra machine, available in 2018, will use an IBM PowerPC architecture along with Nvidia graphics processing unit (GPU) architecture accelerators. These different advanced architectures make the computing landscape in upcoming years complex. Traditional approaches to Monte Carlo transport do not work efficiently on these new computing platforms. MIC architectures require vectorization to operate efficiently, and vectorization is difficult to achieve in Monte Carlo transport. GPU architectures require additional code to explicitly use the hardware, requiring significant code changes or hardware specific branches in the source code. A significant challenge for Monte Carlo transport projects is to simultaneously support within a single source code base efficient simulations for both the current generation of architectures and the different advanced computing architectures. In order to address these challenges, two important changes are typically required: a new algorithmic approach for solving Monte Carlo transport, and explicit use of hardware specific software. In this paper, we describe initial research investigations of an event-based Monte Carlo transport algorithm implemented using the Nvidia Thrust library on a GPU for a Monte Carlo test code. The event-based algorithm targets many-core architectures by increasing SIMD (single instruction multiple data) parallelism, while Thrust potentially provides portable performance by allowing one source code base to compile code targeted for both CPUs and GPUs. We described preliminary investigations of portable event-based Monte Carlo algorithms implemented using the Nvidia Thrust library in a research Monte Carlo test code. We found that an explicit CUDA implementation of an event-based Monte Carlo algorithm performed significantly more efficiently than a Thrust implementation on GPU platforms, most likely as a result of additional flexibility in access to different memory spaces on the GPU. Additionally, we showed that on GPU platforms and at large enough problem sizes the event-based implementations perform more efficiently than the serial history-based implementation running on the host CPU. While investigating this problem, we also discovered that the performance of the event-based algorithm is affected by what tallies are being used. A zonal scalar flux tally requires atomic operations that significantly impacted the performance of the code, in some cases producing slowdowns instead of speedups. We decided to remove the tally in order to focus on the effectiveness of the event-based algorithm. Future work will be required to research more effective ways of handling such tallies. Additionally, we would like to consider new ways for optimizing both the Thrust and CUDA versions, in order to see how much performance we have yet to achieve. The potential trade-off between portability and performance was demonstrated in this investigation. Thrust provides both CPU and GPU versions of the code in one code base, but it does so at a cost. We discovered approximately a factor of 2-5 performance difference between Thrust and CUDA on each GPU platform we tested. Thrust provides a tool to access the GPUs with less effort and specialization, but it does so by giving up fine grained control where extra performance can be found for this application. Future work will be required to determine whether this performance differential between Thrust and CUDA can be reduced for event-based Monte Carlo transport. (authors)

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗

ASC-ATDM Performance Portability Requirements for 2015-2019

This report outlines the research, development, and support requirements for the Advanced Simulation and Computing (ASC ) Advanced Technology, Development, and Mitigation (ATDM) Performance Portability (a.k.a., Kokkos) project for 2015 - 2019 . The research and development (R&D) goal for Kokkos (v2) has been to create and demonstrate a thread - parallel programming model a nd standard C++ library - based implementation that enables performance portability across diverse manycore architectures such as multicore CPU, Intel Xeon Phi, and NVIDIA Kepler GPU. This R&D goal has been achieved for algorithms that use data parallel pat terns including parallel - for, parallel - reduce, and parallel - scan. Current R&D is focusing on hierarchical parallel patterns such as a directed acyclic graph (DAG) of asynchronous tasks where each task contain s nested data parallel algorithms. This five y ear plan includes R&D required to f ully and performance portably exploit thread parallelism across current and anticipated next generation platforms (NGP). The Kokkos library is being evaluated by many projects exploring algorithm s and code design for NGP. Some production libraries and applications such as Trilinos and LAMMPS have already committed to Kokkos as their foundation for manycore parallelism an d performance portability. These five year requirements includes support required for current and antic ipated ASC projects to be effective and productive in their use of Kokkos on NGP. The greatest risk to the success of Kokkos and ASC projects relying upon Kokkos is a lack of staffing resources to support Kokkos to the degree needed by these ASC projects. This support includes up - to - date tutorials, documentation, multi - platform (hardware and software stack) testing, minor feature enhancements, thread - scalable algorithm consulting, and managing collaborative R&D.

97 MATHEMATICS AND COMPUTING↗

A configurable-hardware document-similarity classifier to detect web attacks.

This paper describes our approach to adapting a text document similarity classifier based on the Term Frequency Inverse Document Frequency (TFIDF) metric to reconfigurable hardware. The TFIDF classifier is used to detect web attacks in HTTP data. In our reconfigurable hardware approach, we design a streaming, real-time classifier by simplifying an existing sequential algorithm and manipulating the classifier's model to allow decision information to be represented compactly. We have developed a set of software tools to help automate the process of converting training data to synthesizable hardware and to provide a means of trading off between accuracy and resource utilization. The Xilinx Virtex 5-LX implementation requires two orders of magnitude less memory than the original algorithm. At 166MB/s (80X the software) the hardware implementation is able to achieve Gigabit network throughput at the same accuracy as the original algorithm.

97 MATHEMATICS AND COMPUTING↗