Engineering Papers⌕ Search

SEARCH · Engineering Papers

Results for “Handling”

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 1,729 records · Page 96

Enhancing Lithium-Ion Battery Aging Simulations: Coupling a High-Resolution, 3D, Grain-Scale Electromechanical Model to a Single-Particle Model

One of the main goals in modeling lithium-ion batteries is to improve/predict longevity and resilience of new chemistries. Unfortunately, this requires simulation of thousands of charge/discharge cycles, which can be rather time consuming depending on the fidelity of the simulation. The purpose of this talk is to discuss a new modeling framework that couples a high-resolution, continuous damage model (CDM) to a single particle model (SPM) resulting in a good combination of speed and fidelity. In previous work, a 3D, continuum-level chemo-mechanical model was developed to investigate cracking within a single cathode particle comprised of hundreds to thousands of randomly oriented grains. The CDM predicted that particle fracture is primarily due to non-ideal grain interactions with slight dependence on high-rate charge demands. Essentially, when neighboring grains were misaligned, they expanded different rates relative to one another leading to high stresses and ultimately the formation of intraparticle cracks. The model predicted that small particles with large grains develop significantly less damage than larger particles with small grains. Finally, the model predicted most of the chemo-mechanical damage accumulates in the first charge after formation. This chemo-mechanical "damage saturation" effect indicated that initial particle fracture occurs within the first few cycles, while long-term cathode degradation is not solely chemo-mechanically induced. This led to a need for simulating fatigue-like mechanism that degrade the battery over longer time scales. In order to reach the time scales, need to resolve fatigue-like degradation, the CDM needs to be complemented by a faster model. Therefore, recent efforts have been focused on using results from the CDM to inform parameters within the SPM. These parameters are homogenization factors that are associated with diffusion, particle radius, and/or exchange current density. By coupling the CDM to the SPM, the aging simulation is broken up into two domains: short-term and long-term degradation. The short-term degradation occurs over a single cycle and is handled by the CDM due of its high fidelity, but relatively expensive computational cost. Such mechanism include break-in crack caused by mismatches in grain orientation. The long-term degradation occurs over tens of cycles and is handled by the SPM due it's computational efficiency. Most of the fatigue-like mechanism fall into this category. The eventual goal of this modeling framework is to upscale to a psudo-2D model allowing for full electrode simulation, which are informed by high-fidelity grain-scale simulations.

electrochemistry↗

Analysis of Electric Vehicle Charging Behavior Patterns with Function Principal Component Analysis Approach

This manuscript focused on analyzing electric vehicles’ (EV) charging behavior patterns with a functional data analysis (FDA) approach, with the goal of providing theoretical support to the EV infrastructure planning and regulation, as well as the power grid load management. 5-year real-world charging log data from a total of 455 charging stations in Kansas City, Missouri, was used. The focuses were placed on analyzing the daily usage occupancy variability, daily energy consumption variability, and station-level usage variability. Compared with the traditional discrete-based analysis models, the proposed FDA modeling approach had unique advantages in preserving the smooth function behavior of the data, bringing more flexibility in the modeling process with little required assumptions or background knowledge on independent variables, as well as the capability of handling time series data with different lengths or sizes. In addition to the patterns revealed in the EV charging station’s occupancy and energy consumption, the differences between EV driver’s charging time and parking time were analyzed and called for the needs for parking regulation and enforcement. The different usage patterns observed at charging stations located on different land-use types were also analyzed.

Engineering↗

UPC++ V1.0

UPC++ is a C++11 library providing classes and functions that support Partitioned Global Address Space (PGAS) programming. We are revising the library under the auspices of the DOE's Exascale Computing Project, to meet the needs of applications requiring PGAS support. UPC++ is intended for implementing elaborate distributed data structures where communication is irregular or fine-grained. The UPC++ interfaces for moving non-contiguous data and handling memories with different optimal access methods are composable and similar to those used in conventional C++. The UPC++ programmer can expect communication to run at close to hardware speeds. The key facilities in UPC++ are global pointers, that enable the programmer to express ownership information for improving locality, one-sided communication, both put/get and RPC, futures and continuations. Futures capture data readiness state, which is useful in making scheduling decisions, and continuations provide for completion handling via callbacks. Together, these enable the programmer to chain together a DAG of operations to execute asynchronously as high-latency dependencies become satisfied.

ECP↗

Sandia Cloud Forensics and Incident Response Platform v 1.0

As systems and devices become virtualized and deployed in the cloud, the hypervisor becomes an increasingly appropriate place to collect performance data, system state, system landscape, function calls, transaction traces, and other characteristics. We developed a method by which an introspection application may be coupled with a hypervisor to “reach into” the VM with minimal intrusiveness to collect data critical to the reconstruction of events, files, and operations. Such a capability is required to take advantage of the hypervisor as an instrumentation platform and to integrate that data with more traditional collection mechanisms. The concept of a VM serviced by a lightweight hypervisor is a relatively new paradigm for forensic practitioners. Traditional forensic techniques, based on assumptions that the filesystem was directly interacting with the hardware through an abstraction, afforded the forensic practitioner the assumption that there was nothing controlling the application below the filesystem. This is not the case when using virtualized technologies. Hypervisors can covertly monitor, introspect and interact with the guest in a transparent fashion. The problems of storage and collection of actionable data are exhausting. The current challenge is most hypervisors do not expose a useful application programming interface (API) at a sufficient level to do transparent, fine-grained and customizable introspection. Scalable VM instrumentation and introspection at an in-depth level requires fast handling of events, as well as direct access to VM state. Furthermore, deep introspection benefits greatly from the ability to gather data from the hardware during the VM’s exit to the hypervisor. All of this requires identical access to the system as the hypervisor itself; improper use of this ability could easily cause system instability. It is for this reason we believe that the hypervisor developers have been hesitant to grant this much control through their APIs. However, our approach leverages other means to collect and monitor the guests in a targeted fashion. Virtual machine introspection (VMI) is a technique used to monitor the runtime state of a system-level virtual machine. The runtime state can be may include processor registers, memory, disk, network, and any other hardware-level events A review of research literature and current VMI technologies exposed several limitations and tradeoffs in VMI approaches, including: the use of in-guest agents; kernel to user space transitions (dramatically slowing down processing); VMI tool pre-configuration requirements; hypervisor version lock-in or source code patching; reliance on operating system symbols; limited processor features due to hypervisor (even if the hardware could do more). To address these constraints, a VMI tool was envisioned to provide the cloud forensic capabilities while having as few of these limitations as possible. The Kernel-based Virtual Machine Introspection (KVMi) tool was developed for hypervisors on Intel’s x86-64 architecture. To meet performance, scoping and use-case demands, the follow criteria were applied to KVMi to support live, forensic data collection: • Shall not require in-guest agents. • Shall work with any recent version of modern hypervisors. • Shall introspect upon any guest (VM) running modern versions of Windows, Linux and OS X. • Shall have the ability to find and track operating system artifacts • Shall not require operating system symbol files. • Shall be able to fully handle VM-exits, bypassing execution of the hypervisor if necessary, to facilitate new features the hypervisor may not support. • Shall be compilable/loadable on a running system with standard build tools.

Stout, WilliamM.S.↗

OpenMSI Arrayed Analysis Tools (OMAAT) v2.0

Mass spectrometry (MS) is an analytical technique that enables all chemical species within a complex mixture to be resolved and identified based on their mass:charge ratio. MS is an increasingly important tool in life science research and development because it can resolve or separate small molecules, peptides, lipids, proteins, biopolymers and fragments of all of these structures. Unfortunately, the use of MS has been limited for lack of software tools to visualize, manipulate, store and transfer MS data. Ben Bowen, Oliver Ruebel and colleagues made a huge advance on the resolution of these limitations with the invention of "OpenMSI" (#2013-004), a computational method that makes the handling of these very large files (up to 50 Tb) much easier, especially for scientists with limited background in bioinformatics or sophisticated software applications of the type needed to handle such data files. With the OpenMSI Arrayed Analysis Tool (OMAAT, #2016-188) invention, the authors take MS data analysis one step further by providing tolls for automatic sample position optimization and ion selection. Even though sample deposition technologies have improved greatly, there is always the chance of encountering outliers in a predefined roster, especially in very large sample sets. Manual curation of the data would be extremely time consuming, so the inventors have included an algorithm that automatically finds the outliers. OMAAT is written in Python with accompanying Jupyter (formerly iPython) notebook and is fully integrated with OpenMSI.

Bowen, Benjamin↗

plexos-coad (Plexos Class-Object-Attribute Data manipulation tool)

Clean energy systems including the future power grid are enabled via the development, analysis and application of advanced simulation of complex systems based on large datasets. The ability to handle and enable the simulation of complex systems allows researchers and analysts to address significant problems with greater confidence and greater levels of integrity. Parallel execution of complex systems is paramount to addressing increasing complexity. Programmatic interfaces for software configuration and parallel execution enable handling greater complexity and improving simulation integrity. The Class Object Attribute Data (COAD) software is written as a programmatic interface to the PLEXOS dataset that enables the decomposition of the dataset in time and execution in parallel without loss of integrity. COAD also enable the recomposition of solution datasets that are the output of distributed parallel execution of the core simulator.

Jones, Wes↗

numericalFunctions

The numericalFunction C library is designed to handle point-wise interpolative data representing a mathematical function. The library currently handles 1-d functions (i.e., functions of the format f(x)). The main object is the ptwXYPoints C struct that holds list of x,y pairs sorted by ascending x-values with an interpolation rule. That is, it contains the 1-d function f(x) = y(x). Functions are included that support common unitary and binary operations (e.g., negation, addition, multiplication). As example, if f(x) and g(x) are two ptwXYPoints instances, then routines to calculate f(x) + g(x) and f(x) * g(x) are included. The library support storage of data with lin-lin, lin-log, log-lin, log-log and flat (or histogram) interpolation. Functions to convert any of the supported interpolation to lin-lin are included. However, many of the binary functions only support lin-lin interpolation. The library also contains a C struct for storing a Legendre series representation of a 1-d function, and functions to convert Legendre series to and from a ptwXYPoints instance. A python interface to the library is included, with the ptwXYPoints C struct treated as a class. This class has many of the standard python math methods (e.g., __add__, __mul__).

Beck, Bret↗

statusMessageReporting

Unlike computer languages like C++ which has throw/catch, Python which has try/except and other newer computer languages, C has no built-in mechanism for handling exceptions (e.g., memory allocate failure or a divide by zero exceptions). While simple exception handling in the form of an integer parameter (e.g, errno) or an enum are often implemented in C programs, the richer types of exception reporting possible with newer computer languages are rarely implemented in C. The statusMessageReporting package was created to facilitate rich exception reporting by C functions to their calling functions. The statusMessageReporting (smr) package allows a function, called the generator, to communicate an exception to its calling function using a statusMessageReporting report. The main parts of a report are: 1)the level of the report called the status (valid levels are smr_status_Ok, smr_status_Info, smr_statusWarning and smr_status_Error) 2) a string called the report's message and 3) two integer values, one representing the generator's ID, called the libraryID, and the other is the library's specific integer, called the code, that represents the type of exception the generator is reporting. The code is similar to the errno for the C standard library. Since libraries are often developed independent of one another, they often use the same code values to represent different exceptions (e.g., one library may define the code 3 to be an error opening a file while another library may define the code 3 to be a divide-by-zero error) which is why the libraryID is needed. That is, the equivalent of errno is the combination libraryID:code. To insure that each library's libraryID is unique, libraryIDs must be obtained from the function smr_registerLibrary.

Beck, Bret↗

Bindee

Bindee is a clang tool that outputs a simple pybind11 template given a C++ file for efficient generation of C++-Python bindings. Bindee is intended to be a helper tool for minimizing initial user effort and safeguarding against common runtime errors. Bindee relies on two open-source software to produce bindings. Clang's LibTooling enables bindee to traverse a C++ file's AST to pick out bindable variables and functions, or "bindees." PyBind11 is templated, header-only library for generating C++-Python bindings for variables and functions. Operating purely in C++, bindee does not require learning any new API for accomplishing its task. Additionally, picking the correct pybind11 API for a given bindable element is handled without interaction from the user. Any user input is denoted by '@TEXT@' string substitution. Bindee is capable of generating modular bindings for public class methods, public class variables, enumerations, and free functions and variables. Bindings for templates are also supported. For those familiar with pybind11, bindee does not handle trampolines, C++ extensions through lambdas, or custom type casters.

Kimkno, JasonS.↗

Saloon

Saloon is a Vim plugin that simplifies Python code linter / fixer configuration and usage. Saloon's menu lets developers toggle which static analysis tools to use and delegates those changes to ALE's (Asynchronous Lint Engine) API. Since prospector (python linter aggregate) already handles multiple tools, and is integrated with ALE, most of the actual linting will initially be handled via prospector calls.

Bloss, DavidK.↗

amerifluxr v1.0.0

An R programmatic interface for querying, handling, and summarizing AmeriFlux (https://ameriflux.lbl.gov/) data and metadata. The target users are those 1) who use data from many AmeriFlux sites, and 2) who handle data from multiple sources, e.g., AmeriFlux, PhenoCam, MODIS. The tentative features include 1) listing the sites with basic site general info, 2) querying how much data & metadata are available, 3) subsetting a target site list for download, 4) parsing data & metadata, 5) cleaning & summarizing data, 6) data visualization and 7) listing target sites' contacts & DOI.

Chu, Housen↗

Smart Preprocessing & Robust Integration Emulator

To achieve the desired particle size of biomass feedstocks during preprocessing for trouble-free handling and conversion to produce biofuels and bioproducts, the raw materials must undergo a crucial milling process. The particle size of biomass plays a critical role in subsequent biofuel manufacturing, where a larger area-to-volume ratio facilitates efficient synthesis while balancing the impact of moisture on biomass storage. To optimize biofuel production efficiency and overcome these challenges, it is imperative to accurately predict the particle size distribution (PSD) of the biomass in the design of efficient preprocessing systems. The population balance model (PBM), upon empirical calibration and validation, can provide rapid prediction of post-milling PSD of granular biomass. However, PSD has limitations related to mass conservation and the absence of moisture considerations. To overcome these drawbacks, a deep learning model called the enhanced deep neural operator (DNO+) is implemented in the code. This model not only retains the capabilities of the PBM in handling complex mapping functions but also incorporates additional factors influencing the system. By considering various experimental conditions such as sieve size and moisture content, the trained DNO+ model can effectively predict the PSD after milling for any given feed PSD. To further reduce the reliance on experimental data, the PBM is integrated into the DNO+ model, resulting in a physics-informed DNO+ (PIDNO+). The PIDNO+ model addresses the non-conservation of quality exhibited by the PBM while inheriting the advantages of the DNO+ model in considering multiple influencing factors. Moreover, the PIDNO+ model significantly reduces the amount of data required for model training. Both deep learning models, i.e., DNO+ and PIDNO+, are excellent in predictive performance, offering swift and accurate machine learning-based predictions. The use of this code that contains these models will assist in guiding the proper milling equipment selection and operational conditions to achieve the desired biomass particle sizes, ensuring the efficiency of subsequent biofuel and bioproduct production processes.

Xia, Yidong [Idaho National Laboratory (INL), Idah↗

DualSPHysics-INL

Funded by the DOE's Bioenergy Technology Office through the Feedstock-Conversion Interface Consortium, INL researchers developed this code to model biomass freestock flow in various handling equipment, such as hoppers and augers. Built on top of an existing open-source code DualSPHysics (https://dual.sphysics.org/) , the enrichment includes modification of the mass conservation equation that switching tracking density to void ratio, adding a hypoplastic constitutive law to better capture the flow physics of this type of material and implementing a novel boundary condition that can handle the dynamic contact between material and equipment. All implementation were realized via Nvidia CUDA, so GPU accelaration can be leveraged to signifiantly speed up the computational process.

Jin, Wencheng [Idaho National Laboratory (INL), Id↗

Pando

SAND2025-02006O Pando is a distributed data analysis software tool. It is designed to handle large-scale graph analysis problems, often with a specific focus on blockchain/cryptocurrency data. Pando handles scalability by running on a distributed cluster of servers. Users can customize the output using the program’s plugin/extension design methodology. Sandia National Laboratories is a multimission laboratory managed and operated by National Technology & Engineering Solutions of Sandia, LLC, a wholly owned subsidiary of Honeywell International Inc., for the U.S. Department of Energy’s National Nuclear Security Administration under contract DE-NA0003525.

Gabert, Kasimir↗

Openpronghorn

OpenPronghorn is a simulation tool specifically tailored for modeling thermal-hydraulic phenomena in advanced nuclear reactors. It is built on the Multiphysics Object-Oriented Simulation Environment (MOOSE), an open-source platform that facilitates the development of high-performance scientific computing applications. OpenPronghorn solves the Navier-Stokes equations, which describe the conservation of mass, momentum, and energy in fluid flows, using the finite volume numerical method. The code supports a wide range of fluid flow conditions that are applicable to nuclear reactors, including incompressible and weakly compressible flows, as well as single-phase and multiphase flows. It is capable of modeling diverse flow regimes, including laminar and turbulent flows, using various turbulence models such as the standard k-epsilon models, the v2f model, and the mixing length model. For multiphase flows, OpenPronghorn employs a mixture a Eulerian modeling approach with mixture, drift-flux, and full Eulerian models, and includes open-sourced interfacial transfer correlations for drag, exchange, and heat transfer coming from the scientific literature. OpenPronghorn's modular design allows it to handle multiscale simulations, ranging from detailed Reynolds-Averaged Navier Stokes (RANS) simulations to coarse-mesh and lumped parameter models. This flexibility enables users to perform high-fidelity simulations of specific reactor components as well as system-level analyses of entire reactor circuits. The code can be coupled with other MOOSE-based tools using the MultiApp system, allowing for the transfer of coupling quantities such as mass flow rates, heat fluxes, and boundary conditions between different simulation scales. One of the main features of OpenPronghorn is the it includes built-in validation cases from the open-source scientific literature and supports the implementation of user-defined models and correlations through MOOSE's FunctorMaterial system. OpenPronghorn is designed to be computationally efficient, leveraging the SIMPLE projection method for large-scale problems, and can be run on high-performance computing systems to handle the extensive computational demands of detailed reactor simulations. Overall, OpenPronghorn is a versatile and robust tool that provides critical insights into the thermal-hydraulic behavior of advanced nuclear reactors, supporting the design, safety, and optimization of next-generation nuclear energy systems.

Retamales, Mauricio Eduardo Tano [Idaho National L↗

Python Library For Reading Endf Files

Evaluated Nuclear Data Files (ENDFs) are the most common way to store nuclear data. However, they are a hard-to-read format that few people or programs can read. OpenMC, an open source project, developed a way to read Evaluated Nuclear Data Files (ENDF) into a useful form for python. This library will remove all unnecessary code from OpenMC to focus solely on reading nuclear data. In addition, it will handle parsing Grouped cross-section data from an ENDF file, which OpenMC does not currently handle.

Gale, MicahD.↗

Energy Exascale Earth System Model v2.0.2

Second patch release of v2.0.0 Changes since v2.0.1 [Important change] Add and update SSP370 and SSP585 cases, add tests, fix use-case files, Change ocean and sea-ice IC for ARRM60to10. [EAM] allow thetaxx as a CAM_TARGET, enable northamericax4v1pg2_WC14to60E2r3 for AMIP, fix ndrop initialization, allow up to 15 history files. [EAMxx] allow use of readnl [EAM-MMF] allow transient SST case for C++ MMF, remove specific task/thread count for ESMT test, modify the variance transport diagnostic, reorg tests, [HOMME] Allow optional sponge layer. [ELM] add 2 land-atm compsets, update FATES to API 17.0.0, allow FATES sp mode, allow ELM harvest to drive FATES harvest, fix memleaks, reduce test build times, modified parameters for miscanthus and switchgrass based on calibration [MPAS-Ocean] turn on ocean BGC in BGC cases, fix interface locations for 60L PHC grid, add mode spec to conservation check streams, allow oRRS18to6v3 grid to run with JRA, update ocean and sea ice ICs for ARRM60to10 (needed for v2), GPU port of thickness tendency, add CMPASO-JRA1p4, [MPAS framework] Add new reproducible global sum module for MPAS components, Add mostRecentAccessTime attribute to streams [MPAS-landice] Update MALI version and Greenland mesh [MPAS-seaice] add single-cell test case, fix BGC restart, Adds omp critical directives for ice warnings seen on cori. [CIME] Fix component namelist creation bugs when NINST>1, add OpenACC, OpenMP and CXX GPU tests, fix nonBFB tests, stop using config_compilers, reduce ELM test build times with shared executable, update OpenMPI on Chrysalis. fix baseline handling, provenance handling with update to cime6.0.33, also use component-specific config_pes files and add the ones from master [Machine updates] cori modules after maint, Chrysalis to OpenMPI-4.1.3 [run_e3sm] replace default case name and group. [Externals] update SCORPIO to 1.3.2

ECP↗

Using Median Point in Keeling Plot to Reduce the Uncertainty of the Isotopic Composition of Evapotranspiration

Abstract The isotopic composition of evapotranspirationδ ET is a crucial parameter in isotope-based evapotranspiration (ET) partitioning and moisture recycling studies. The Keeling plot method is the most prevalent method to calculateδ ET , though it contains large extrapolated uncertainties from the least squares regression. Traditional Keeling regression uses the mean point of individual measurements. Here, a modified Keeling plot framework was proposed using the median point of individual measurements. We tested theδ ET uncertainty using the mean point [σ ET (mean)] and median point [σ ET (median)]. Multiple resolutions of input and output data from six independent sites were used to test the performance of the two methods. Theσ ET (mean) would be greater thanσ ET (median) when the mean value of inverse vapor concentration () is greater than the median value of inverse vapor concentration []. When applying the filter ofr 2 > 0.8, around 70% ofσ ET (mean) was greater thanσ ET (median). This phenomenon might be due to the normality of the vapor concentrationC υ producing the asymmetric distribution of 1/C υ . The median method could perform significantly better than the mean method when inputting high-resolution measurements (e.g., 1 Hz) and when the water vapor concentrationC υ is relatively low. Compared to the mean method, applying the median method could on average reduce 6.88% of ET partitioning uncertainties and could on average reduce 9.00% of moisture recycling uncertainties. This study provided a new insight of the Keeling plot method and emphasized handling model output uncertainty from multiple perspectives instead of only from input parameters.

Meteorology & Atmospheric Sciences↗