Engineering Papers⌕ Search

SEARCH · Engineering Papers

Results for “SOURCE CODE”

Search indexed NASA NTRS and DOE OSTI research on propulsion, heat transfer, battery materials and energy systems. Follow report and document links to the original sources.

Quote a phrase for an exact phrase match. Source license links do not imply unrestricted reuse.

At least 559 records · Page 31

NASA Operational Simulator for SmallSats (NOS3): Design Reference Mission

The NASA Operational Simulator for Small Satellites (NOS3) has undergone significant advances including updating the framework to be “component” based and expanding the open-source code to include a generic design reference mission to enable advanced technologies. This paper details the changes to the framework as well as a number of innovative use-cases the team is currently supporting such as 1) the expansion of NOS3 to support distributed systems missions in collaboration with NASA GSFC, 2) the integration of NASA JPL’s Science Yield improvement via Onboard Prioritization and Summary of Information Systems (SYNOPSIS) for on-orbit science data prioritization, and 3) the inclusion of NASA IV&V’s software-only CCSDS encryption library (CryptoLib). NOS3 continues to serve the SmallSat community by providing an open-source digital twin that can significantly reduce costs associated with spacecraft software development, test, and operations. The NOS3 team hopes to continue to expand the resources available to the community and partner with others to resolve issues and add new features requested via the NASA GitHub.

SmallSats↗

Sensitivity Coefficients Calculated for the Prompt Neutron Decay Constant at or Near Delayed Critical [Abstract]

Experimenters at Los Alamos National Laboratory (LANL) measure the prompt neutron decay constant for many experiments at the National Criticality Experiments Research Center (NCERC) to infer reactivity and the effective neutron multiplication factor. These quantities are very important for nuclear criticality safety and validating nuclear data. Uncertainty in measures of criticality of an experimental configuration can be determined prior to physically performing the experiment by applying first order perturbation theory to Monte Carlo codes, such as MCNP®. The first order perturbation theory produces first derivatives of some nuclear parameter to nuclear data (e.g., cross section data). This first derivative is commonly referred to as a sensitivity coefficient. Currently, the MCNP® software has the capability of computing effective neutron multiplication factor sensitivity coefficients to cross section data. This work builds off of this MCNP® capability and the first order perturbation theory to provide a method of calculating sensitivity coefficients for the prompt neutron decay constant at or near delayed critical to cross section data. The prompt neutron decay constant sensitivity coefficient calculated in this work does not depend on any modification of the MCNP® source code. Prompt neutron decay constant sensitivity coefficient calculations can be used to infer reactivity and effective neutron multiplication factor sensitivity coefficient values as well. By investigating the trends of prompt neutron decay constant sensitivity coefficients for nuclide-reaction pairs across energy spectra, experiments can be designed to maximize or minimize the uncertainty in the prompt neutron decay constant in a particular energy region, which can lead to further optimization studies. Prompt neutron decay constant sensitivity coefficients will be calculated for the Jezebel benchmark. Subsequently, these sensitivity coefficients will be used in a data assimilation process to determine if there is or are optimal experiments that can be performed to provide insight into adjustments of uncertain/inaccurate cross section data. Specifically, the effect of the prompt neutron decay constant sensitivity coefficients on the nuclear data-induced uncertainty in the effective neutron multiplication factor will be examined

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗

NA-42 TI Shared Software Component Library FY2011 Final Report

The NA-42 TI program initiated an effort in FY2010 to standardize its software development efforts with the long term goal of migrating toward a software management approach that will allow for the sharing and reuse of code developed within the TI program, improve integration, ensure a level of software documentation, and reduce development costs. The Pacific Northwest National Laboratory (PNNL) has been tasked with two activities that support this mission. PNNL has been tasked with the identification, selection, and implementation of a Shared Software Component Library. The intent of the library is to provide a common repository that is accessible by all authorized NA-42 software development teams. The repository facilitates software reuse through a searchable and easy to use web based interface. As software is submitted to the repository, the component registration process captures meta-data and provides version control for compiled libraries, documentation, and source code. This meta-data is then available for retrieval and review as part of library search results. In FY2010, PNNL and staff from the Remote Sensing Laboratory (RSL) teamed up to develop a software application with the goal of replacing the aging Aerial Measuring System (AMS). The application under development includes an Advanced Visualization and Integration of Data (AVID) framework and associated AMS modules. Throughout development, PNNL and RSL have utilized a common AMS code repository for collaborative code development. The AMS repository is hosted by PNNL, is restricted to the project development team, is accessed via two different geographic locations and continues to be used. The knowledge gained from the collaboration and hosting of this repository in conjunction with PNNL software development and systems engineering capabilities were used in the selection of a package to be used in the implementation of the software component library on behalf of NA-42 TI. The second task managed by PNNL is the development and continued maintenance of the NA-42 TI Software Development Questionnaire. This questionnaire is intended to help software development teams working under NA-42 TI in documenting their development activities. When sufficiently completed, the questionnaire illustrates that the software development activities recorded incorporate significant aspects of the software engineering lifecycle. The questionnaire template is updated as comments are received from NA-42 and/or its development teams and revised versions distributed to those using the questionnaire. PNNL also maintains a list of questionnaire recipients. The blank questionnaire template, the AVID and AMS software being developed, and the completed AVID AMS specific questionnaire are being used as the initial content to be established in the TI Component Library. This report summarizes the approach taken to identify requirements, search for and evaluate technologies, and the approach taken for installation of the software needed to host the component library. Additionally, it defines the process by which users request access for the contribution and retrieval of library content.

99 GENERAL AND MISCELLANEOUS↗

Snippet Open-Source Specification Synopsis

Snippet is a collaborative source code auditing tool developed by Sandia National Laboratories, in conjunction with researchers from other government agencies and partners. As a tool for use by groups of auditors, Snippet showed the value of providing in-line annotations that captured the thoughts of auditors in such a way that teams of auditors could share their insights. Snippet users found that the annotation mechanisms improved the auditing process but were frustrated at having to learn another environment. To address this issue, collaborators made extensions to existing Integrated Development Environments (IDEs) to incorporate functionality that mimics Snippet's behaviors. This document is one of a pair of documents. The other document, "Snippet Open-Source Specification", goes into details about the history and reasoning behind the requirements made in this document. That document provides for a broader understanding of the motivations backing this document. This document provides the complete specification for collaborative annotation, and a characterization of each specification as required or recommended. Tools that implement these specifications will be considered Snippet compliant. The intent is that complete implementation of these specifications will enable seamless sharing of annotation information between disjoint tools.

97 MATHEMATICS AND COMPUTING↗

Automated Instrumentation, Monitoring and Visualization of PVM Programs Using AIMS

We present views and analysis of the execution of several PVM (Parallel Virtual Machine) codes for Computational Fluid Dynamics on a networks of Sparcstations, including: (1) NAS Parallel Benchmarks CG and MG; (2) a multi-partitioning algorithm for NAS Parallel Benchmark SP; and (3) an overset grid flowsolver. These views and analysis were obtained using our Automated Instrumentation and Monitoring System (AIMS) version 3.0, a toolkit for debugging the performance of PVM programs. We will describe the architecture, operation and application of AIMS. The AIMS toolkit contains: (1) Xinstrument, which can automatically instrument various computational and communication constructs in message-passing parallel programs; (2) Monitor, a library of runtime trace-collection routines; (3) VK (Visual Kernel), an execution-animation tool with source-code clickback; and (4) Tally, a tool for statistical analysis of execution profiles. Currently, Xinstrument can handle C and Fortran 77 programs using PVM 3.2.x; Monitor has been implemented and tested on Sun 4 systems running SunOS 4.1.2; and VK uses XIIR5 and Motif 1.2. Data and views obtained using AIMS clearly illustrate several characteristic features of executing parallel programs on networked workstations: (1) the impact of long message latencies; (2) the impact of multiprogramming overheads and associated load imbalance; (3) cache and virtual-memory effects; and (4) significant skews between workstation clocks. Interestingly, AIMS can compensate for constant skew (zero drift) by calibrating the skew between a parent and its spawned children. In addition, AIMS' skew-compensation algorithm can adjust timestamps in a way that eliminates physically impossible communications (e.g., messages going backwards in time). Our current efforts are directed toward creating new views to explain the observed performance of PVM programs. Some of the features planned for the near future include: (1) ConfigView, showing the physical topology of the virtual machine, inferred using specially formatted IP (Internet Protocol) packets: and (2) LoadView, synchronous animation of PVM-program execution and resource-utilization patterns.

Mehra, Pankaj↗

A Fixed Point VHDL Component Library for a High Efficiency Reconfigurable Radio Design Methodology

Advances in Field Programmable Gate Array (FPGA) technologies enable the implementation of reconfigurable radio systems for both ground and space applications. The development of such systems challenges the current design paradigms and requires more robust design techniques to meet the increased system complexity. Among these techniques is the development of component libraries to reduce design cycle time and to improve design verification, consequently increasing the overall efficiency of the project development process while increasing design success rates and reducing engineering costs. This paper describes the reconfigurable radio component library developed at the Software Defined Radio Applications Research Center (SARC) at Goddard Space Flight Center (GSFC) Microwave and Communications Branch (Code 567). The library is a set of fixed-point VHDL components that link the Digital Signal Processing (DSP) simulation environment with the FPGA design tools. This provides a direct synthesis path based on the latest developments of the VHDL tools as proposed by the BEE VBDL 2004 which allows for the simulation and synthesis of fixed-point math operations while maintaining bit and cycle accuracy. The VHDL Fixed Point Reconfigurable Radio Component library does not require the use of the FPGA vendor specific automatic component generators and provide a generic path from high level DSP simulations implemented in Mathworks Simulink to any FPGA device. The access to the component synthesizable, source code provides full design verification capability:

Hoy, Scott D.↗

Preface to the Special Issue on TOUGH Symposium 2015

The TOUGH Symposium 2015 was held in Berkeley, California, September 28-30, 2015. The TOUGH family of codes, developed at the Energy Geosciences Division of Lawrence Berkeley National Laboratory (LBNL), is a suite of computer programs for the simulation of multiphase and multicomponent fluid and heat flows in porous and fractured media with applications in many geosciences fields, such as geothermal reservoir engineering, nuclear waste disposal, geological carbon sequestration, oil and gas reservoirs, gas hydrate research, vadose zone hydrology and environmental remediation. Since the first release in the 1980s, many modifications and enhancements have been continuously made to TOUGH and its various descendants (iTOUGH2, TOUGH+, TOUGH-MP, TOUGHREACT, TOUGH+HYDRATE, TMVOC...), at LBNL and elsewhere. Today, these codes are used worldwide in academia, government organizations and private companies in problems involving coupled hydrological, thermal, biogeochemical and geomechanical processes. The Symposia, organized every 2-3 years, bring together developers and users for an open exchange on recent code enhancements and applications. In 2015, the Symposium was attended by one hundred participants, representing thirty-four nationalities. This Special Issue in Computers & Geosciences gathers extended versions of selected Symposium proceedings related to (i) recent enhancements to the TOUGH family of codes and (ii) coupled flow and geomechanics processes modeling. In this special issue, a paper by Jung et al. provides a new base version of TOUGH, TOUGH3. This latest version addresses the computational robustness and efficiency needed for the increasing complexity of the simulated processes and the growing size of model domains. Moreover, it consolidates the serial and parallel versions into a single code, hence, inconsistencies between different versions are less likely to occur, and code maintenance and development become more efficient. Finsterle et al. present a review of the capabilities of iTOUGH2 and illustrate the workflow of an integrated simulation-optimization framework. Liu et al. present an approach to reduce the computational cost of performing Bayesian inverse modeling and demonstrate their approach using a synthetic experiment simulated with TOUGH2. Regarding the mesh generation process, the paper by Doughty presents a generalization of the grid-generation algorithm embedded in TOUGH2 (MESHMAKER) to create one-column grids with fractal dimension, useful for representing flow through fractures or highly heterogeneous media with fractal geometry, and also for inverse methods. Sentís and Gable present a module to interface the open source code Lagrit with TOUGH2, that assists in the processes of mesh generation and model setup, and that can be particularly useful for complex geometries and large models. Bonduà et al. present a pre-processing tool (VORO2MESH) that features a full 3D Voronoi approach for structured and unstructured grids, and an enhanced post-processor (TOUGH2Viewer) for the visualization of 3D Voronoi grids. The literature review shows that coupled fluid flow and geomechanics has gained increasing attention in the last years in many geosciences fields. In this context, several codes of the TOUGH family have been successfully coupled with geomechanics software. The paper by Rutqvist presents a review of some of these TOUGH-based geomechanics models, of which the TOUGH-FLAC simulator – presented for the first time in the TOUGH Symposium 2003 – is well-known worldwide and has been used in a large variety of applications, encompassing the application domains of the TOUGH codes. Blanco-Martín et al. present an extension of TOUGH-FLAC to the finite strain framework, motivated by the existence of large strains associated with rock salt deformation in the context of heat-generating nuclear waste disposal. Following a paper published in the Special Issue of the TOUGH Symposium 2012 in this journal, Kim et al. present the current status of the TOUGH-RSBN simulator for coupled hydro-mechanical modeling of hydraulic fracturing using a discrete fracture network approach, and present some validation and demonstration cases. Rinaldi and Nespoli present TOUGH-SEED, an injection-induced seismicity modeling approach using TOUGH2 and a geomechanics stochastic model, and apply it to the Basel EGS project. Finally, Rinaldi et al. use the PEST protocol implemented in iTOUGH2, combined with TOUGH-FLAC as the forward model, to perform inverse modeling for the In Salah CO2 demonstration site in Algeria. Using pore pressures and InSAR displacements as observations, this approach allows for a multi-physics joint inversion and takes advantage of the inverse capabilities of iTOUGH2 (parameter estimation, sensitivity analysis, uncertainty estimation …), applied to coupled fluid flow and geomechanics. On behalf of the members of the TOUGH Symposium 2015 Organizing Committee, I hope that this collection of papers will provide the readers of Computers & Geosciences with a recent view of the capabilities of the TOUGH family of codes, as well as with current modeling research domains in the geosciences. Last but not least, I would like to express my gratitude to all the reviewers who kindly contributed to this Special Issue, as well as the Journal staff who have made this publication possible.

99 GENERAL AND MISCELLANEOUS↗

HAPPA: A Modular Platform for HPC Application Resilience Analysis with LLMs Embedded

High-performance computing (HPC) systems are increasingly vulnerable to soft errors, which pose significant challenges in maintaining computational accuracy and reliability. Predicting the resilience of HPC applications to these errors is crucial for robust code protection and detailed resilience analysis. In this study, we present HAppA, a modular platform designed for HPC Application Resilience Analysis. Embedding Large Language Models (LLMs), HAppA addresses understanding the context information of long code sequences typical in HPC applications. HAppA implements a novel code representation module that chunks the code into fixed-size segments and aggregates the embeddings of these segments. Three aggregation methods have been explored: MeanPooling, MaxPooling, and LSTM-based techniques. We built a DAtaset for REsilience analysis using Fault Injection (FI), named DARE. Using our DARE dataset, HAppA is trained for regression prediction tasks. Our evaluation results demonstrate the predictive accuracy of HAppA compared to other models, particularly noting that the LSTM-based aggregation method -- HAppA-LSTM -- achieves a mean squared error (MSE) of 0.078 for SDC prediction, surpassing the existing state-of-the-art PARIS model, which recorded an MSE of 0.1172. Additionally, HAppA with the KeyBERT model extracts a list of keywords representing the source code. A comprehensive importance analysis of these keywords further elucidates the code patterns contributing to the error rate. These findings highlight the effectiveness of HAppA in analyzing the resilience of HPC applications and establish a new benchmark for predictive accuracy in resilience.

Jiang, Hailong [Kent State University]↗

A Concept for Run-Time Support of the Chapel Language

A document presents a concept for run-time implementation of other concepts embodied in the Chapel programming language. (Now undergoing development, Chapel is intended to become a standard language for parallel computing that would surpass older such languages in both computational performance in the efficiency with which pre-existing code can be reused and new code written.) The aforementioned other concepts are those of distributions, domains, allocations, and access, as defined in a separate document called "A Semantic Framework for Domains and Distributions in Chapel" and linked to a language specification defined in another separate document called "Chapel Specification 0.3." The concept presented in the instant report is recognition that a data domain that was invented for Chapel offers a novel approach to distributing and processing data in a massively parallel environment. The concept is offered as a starting point for development of working descriptions of functions and data structures that would be necessary to implement interfaces to a compiler for transforming the aforementioned other concepts from their representations in Chapel source code to their run-time implementations.

James, Mark↗

Progress Towards NQA-1 for Cardinal in FY25

Cardinal is a wrapping of the GPU-oriented spectral element Computational Fluid Dynamics (CFD) code NekRS and the Monte Carlo particle transport code OpenMC within the Multiphysics Object-Oriented Simulation Environment (MOOSE). Cardinal provides high-resolution thermal-hydraulics and/or radiation transport feedback to MOOSE multiphysics simulations. Multiphysics feedback is implemented in a geometry-agnostic manner which eliminates the need for rigid one-to-one mappings. A generic data transfer implementation also allows NekRS and OpenMC to couple to any MOOSE application, enabling a broad set of multiphysics capabilities. Cardinal simulations can also leverage combinations of MPI, OpenMP, and GPU resources. Cardinal continuous development and improvement efforts have led to the software being considered as a high-fidelity design and licensing tool for key areas of nuclear reactor relevant physics, including neutron transport, fluid flow, heat transfer, and mechanical processes. The fast development and expansion of the software from a pure R&D framework towards its application in the nuclear industry and regulation require a focus on developing, enhancing,and maintaining Cardinal’s software quality through strict adherence to a Software Quality Assurance (SQA) framework and SQA program. To facilitate compliance with SQA standards, the Cardinal SQA Program was initiated during Fiscal Year 2023 (FY23). During the development of the Cardinal SQA Program, multiple gaps have been identified. These gaps are primarily related to model verification and code pedigree as they relate to the use of Cardinal as an analysis tool. These gaps were captured in a report published in 2023. A second report highlighted the progress made during Fiscal Year 2024 (FY24) and described Argonne’s effort to document and integrate software verification within Cardinal’s software development process. This report documents the progress made towards NQA-1 for Cardinal in the Fiscal Year 2025 (FY25). All cases in the expanded Continuous Integration (CI) suite of NekRS are included in this report which test the solvers and modules available in NekRS exhaustively. The NekRS tests are integrated with the Cardinal CI suite and made available in publicly accessible Github documentation. Following the CI practice permits integrating of source code changes frequently and ensuring that the integrated codebase clears the verification testing for the software. Also in this report is a brief overview of the development of the Cardinal Software Quality Assurance Plan (SQAP) that was done in FY25, though it should be noted that the rest of the documentation for the SQA program needs to be developed in a future step of this task.

22 GENERAL STUDIES OF NUCLEAR REACTORS↗

LaRIS: Targeting Portability and Productivity for LAPACK Codes on Extreme Heterogeneous Systems by Using IRIS

In keeping with the trend of heterogeneity in high-performance computing, hardware manufacturers and vendors are developing new architectures and associated software stacks (e.g., libraries) to harness the best possible performance from commonly used kernels (e.g., linear algebra kernels). However, kernels tuned for one architecture are not portable to others. Moreover, the coexistence of different architectures in a single node makes orchestration difficult. To address these challenges, we introduce LaRIS, a portable framework for LAPACK functionalities. LaRIS ensures a separation between linear algebra algorithms and vendor-library kernels by using the IRIS run time and IRIS-BLAS library. Such abstraction at the algorithm level makes the implementation completely agnostic to the vendor library and architecture. LaRIS uses the IRIS run time to dynamically select the vendor-library kernel and suitable processor architecture at run time. Through LU factorization, we demonstrate that LaRIS can fully utilize different heterogeneous systems by launching and orchestrating different vendor-library kernels without any change in the source code.

Monil, M. A. H.↗

Automated Instrumentation, Monitoring and Visualization of PVM Programs Using AIMS

We present views and analysis of the execution of several PVM codes for Computational Fluid Dynamics on a network of Sparcstations, including (a) NAS Parallel benchmarks CG and MG (White, Alund and Sunderam 1993); (b) a multi-partitioning algorithm for NAS Parallel Benchmark SP (Wijngaart 1993); and (c) an overset grid flowsolver (Smith 1993). These views and analysis were obtained using our Automated Instrumentation and Monitoring System (AIMS) version 3.0, a toolkit for debugging the performance of PVM programs. We will describe the architecture, operation and application of AIMS. The AIMS toolkit contains (a) Xinstrument, which can automatically instrument various computational and communication constructs in message-passing parallel programs; (b) Monitor, a library of run-time trace-collection routines; (c) VK (Visual Kernel), an execution-animation tool with source-code clickback; and (d) Tally, a tool for statistical analysis of execution profiles. Currently, Xinstrument can handle C and Fortran77 programs using PVM 3.2.x; Monitor has been implemented and tested on Sun 4 systems running SunOS 4.1.2; and VK uses X11R5 and Motif 1.2. Data and views obtained using AIMS clearly illustrate several characteristic features of executing parallel programs on networked workstations: (a) the impact of long message latencies; (b) the impact of multiprogramming overheads and associated load imbalance; (c) cache and virtual-memory effects; and (4significant skews between workstation clocks. Interestingly, AIMS can compensate for constant skew (zero drift) by calibrating the skew between a parent and its spawned children. In addition, AIMS' skew-compensation algorithm can adjust timestamps in a way that eliminates physically impossible communications (e.g., messages going backwards in time). Our current efforts are directed toward creating new views to explain the observed performance of PVM programs. Some of the features planned for the near future include: (a) ConfigView, showing the physical topology of the virtual machine, inferred using specially formatted IP (Internet Protocol) packets; and (b) LoadView, synchronous animation of PVM-program execution and resource-utilization patterns.

Mehra, Pankaj↗

Optical second harmonic generation in anisotropic multilayers with complete multireflection of linear and nonlinear waves using ♯SHAARP.ml package

Abstract Optical second harmonic generation (SHG) is a nonlinear optical effect widely used for nonlinear optical microscopy and laser frequency conversion. Closed-form analytical solution of the nonlinear optical responses is essential for evaluating materials whose optical properties are unknown a priori. A recent open-source code, ♯SHAARP. si , can provide such closed form solutions for crystals with arbitrary symmetries, orientations, and anisotropic properties at a single interface. However, optical components are often in the form of slabs, thin films on substrates, and multilayer heterostructures with multiple reflections of both the fundamental and up to ten different SHG waves at each interface, adding significant complexity. Many approximations have therefore been employed in the existing analytical approaches, such as slowly varying approximation, weak reflection of the nonlinear polarization, transparent medium, high crystallographic symmetry, Kleinman symmetry, easy crystal orientation along a high-symmetry direction, phase matching conditions and negligible interference among nonlinear waves, which may lead to large errors in the reported material properties. To avoid these approximations, we have developed an open-source package named Second Harmonic Analysis of Anisotropic Rotational Polarimetry in Multilayers (♯SHAARP. ml ). The reliability and accuracy are established by experimentally benchmarking with both the SHG polarimetry and Maker fringes using standard and commonly used nonlinear optical materials as well as twisted 2-dimensional heterostructures.

36 MATERIALS SCIENCE↗

Argonne Reactor Code Software Verification and Validation Plan for the Versatile Test Reactor

This Argonne Reactor Code (ARC) software has taken a pivotal role in the design work of the Versatile Test Reactor. The ARC software itself consists of several independent or semiindependent pieces of software that are used in concert to carry out specific analysis and design objectives. In this report, we discuss the validation that is needed for the ARC software overall and discuss available, usable experimental data and how it relates to the VTR project. We also discuss the verification that is required for the ARC software with respect to its usage in the VTR project and give some concrete examples as to what it must accomplish. A list of goals for the verification and validation work are presented as the general procedure that will be implemented for every individual piece of software in ARC. The ARC software has been continuously developed for over 50 years and many of the features used for the VTR project have thus been rigorously tested for accuracy during that timeframe. The ARC software is presently under source code control and undergoes nightly regression testing of not only the individual pieces, but the interconnected aspects that are common to most analysis projects. Its greatest weakness, from a software verification and validation perspective, is both a lack of documentation and outdated documentation. As an example, much of the previous validation work will require contemporary effort to re-evaluate given the updated base data libraries and modifications to the software that have occurred since. This requires new documentation to be produced to support the usage of the software in the VTR project. The bulk of the ARC software is focused on steady state neutronics and TH behavior of a reactor system. In this regard, we have identified the ZPPR, FFTF, and EBR-II programs as the best candidates for sources of validation data for the VTR project. The ZPPR-15 series in the ZPPR program was chosen as it is the best representation of the VTR fuel form and reactor core layout of all of the ZPPR measurements. Additional support for it comes from the fact that most of the data has already been processed into usable ARC models for VTR validation. The FFTF and EBR-II reactors were both functional reactors that provide reactor scale measurements. FFTF is clearly a closer match to VTR and its startup measurements would be a very valuable validation basis. EBR-II has invaluable burnup related measurements that will play a key role in the ARC software validation work. Each piece of ARC software will require a report detailing the software verification. The validation work will be logically split into the results of modeling each identified experimental resource (ZPPR, EBR-II, FFTF). The intended timeline for the VTR project is to have the ARC software verified and validated by the end of fiscal year 2020. This is incumbent on sufficient funding allocated to V&V activities and no change in programmatic priorities.

21 SPECIFIC NUCLEAR REACTORS AND ASSOCIATED PLANTS↗

Developing CORBA-Based Distributed Scientific Applications from Legacy Fortran Programs

Recent progress in distributed object technology has enabled software applications to be developed and deployed easily such that objects or components can work together across the boundaries of the network, different operating systems, and different languages. A distributed object is not necessarily a complete application but rather a reusable, self-contained piece of software that co-operates with other objects in a plug-and-play fashion via a well-defined interface. The Common Object Request Broker Architecture (CORBA), a middleware standard defined by the Object Management Group (OMG), uses the Interface Definition Language (IDL) to specify such an interface for transparent communication between distributed objects. Since IDL can be mapped to any programming language, such as C++, Java, Smalltalk, etc., existing applications can be integrated into a new application and hence the tasks of code re-writing and software maintenance can be reduced. Many scientific applications in aerodynamics and solid mechanics are written in Fortran. Refitting these legacy Fortran codes with CORBA objects can increase the codes reusability. For example, scientists could link their scientific applications to vintage Fortran programs such as Partial Differential Equation(PDE) solvers in a plug-and-play fashion. Unfortunately, CORBA IDL to Fortran mapping has not been proposed and there seems to be no direct method of generating CORBA objects from Fortran without having to resort to manually writing C/C++ wrappers. In this paper, we present an efficient methodology to integrate Fortran legacy programs into a distributed object framework. Issues and strategies regarding the conversion and decomposition of Fortran codes into CORBA objects are discussed. The following diagram shows the conversion and decomposition mechanism we proposed. Our goal is to keep the Fortran codes unmodified. The conversion- aided tool takes the Fortran application program as input and helps programmers generate C/C++ header file and IDL file for wrapping the Fortran code. Programmers need to determine by themselves how to decompose the legacy application into several reusable components based on the cohesion and coupling factors among the functions and subroutines. However, programming effort still can be greatly reduced because function headings and types have been converted to C++ and IDL styles. Most Fortran applications use the COMMON block to facilitate the transfer of large amount of variables among several functions. The COMMON block plays the similar role of global variables used in C. In the CORBA-compliant programming environment, global variables can not be used to pass values between objects. One approach to dealing with this problem is to put the COMMON variables into the parameter list. We do not adopt this approach because it requires modification of the Fortran source code which violates our design consideration. Our approach is to extract the COMMON blocks and convert them into a structure-typed attribute in C++. Through attributes, each component can initialize the variables and return the computation result back to the client. We have tested successfully the proposed conversion methodology based on the f2c converter. Since f2c only translates Fortran to C, we still needed to edit the converted code to meet the C++ and IDL syntax. For example, C++/IDL requires a tag in the structure type, while C does not. In this paper, we identify the necessary changes to the f2c converter in order to directly generate the C++ header and the IDL file. Our future work is to add GUI interface to ease the decomposition task by simply dragging and dropping icons.

Sang, Janche↗

Scientific Computational Imaging Code (SCICO)

Scientific Computational Imaging Code (SCICO) is a Python package for solving the inverse problems that arise in scientific imaging applications. Its primary focus is providing methods for solving ill-posed inverse problems by using an appropriate prior model of the reconstruction space. SCICO includes a growing suite of operators, cost functionals, regularizers, and optimization routines that may be combined to solve a wide range of problems, and is designed so that it is easy to add new building blocks. SCICO is built on top of JAX rather than NumPy, enabling GPU/TPU acceleration, just-in-time compilation, and automatic gradient functionality, which is used to automatically compute the adjoints of linear operators. An example of how to solve a multi-channel tomography problem with SCICO is shown in Figure 1. The SCICO source code is available from GitHub, and pre-built packages are available from PyPI. It has extensive online documentation, including API documentation and usage examples, which can be run online at Google Colab and binder.

97 MATHEMATICS AND COMPUTING↗

RAJA Performance Suite

The RAJA Performance Suite is designed to evaluate performance of the RAJA performance portability library on a wide variety of important high performance computing (HPC) algorithmic lulmels. These kernels assess compiler optimizations and various parallel programming model backends accessible through RAJA, such as OpenMP, CUDA, etc. The Initial version of the suite contains 25 computational kernels, each of which appears in 6 variants: Baseline SequcntiaJ, RAJA SequentiaJ, Baseline OpenMP, RAJA OpenMP, Baseline CUDA, RAJA CUDA. All variants of each kernel perform essentially the same mathematical operations and the loop body code for each kernel is identical across all variants. There are a few kernels, such as those that contain reduction operations, that require CUDA-specific coding for their CUDA variants. ActuaJ computer instructions executed and how they run in parallel differs depending on the parallel programming model backend used and which optimizations are perfonned by the compiler used to build the Perfonnance Suite executable. The Suite will be used primarily by RAJA developers to perform regular assessments of RAJA performance across a range of hardware platforms and compilers as RAJA features are being developed. It will also be used by LLNL hardware and software vendor panners for new defining requirements for future computing platform procurements and acceptance testing. In particular, the RAJA Performance Suite will be used for compiler acceptance testing of the upcoming CORAUSierra machine {initial LLNL delivery expected in late-2017/early 2018) and the CORAL-2 procurement. The Suite will aJso be used to generate concise source code reproducers of compiler and runtime issues we uncover so that we may provide them to relevant vendors to be fixed.

Hornung, RichardD.↗

Integrating Sudo-Kaminaga Correlation to the Safety Analysis Code PARET-ANL

The accuracy and reliability of the reactor safety analysis code are critical because the specifications of the safety systems will depend on the analytical results for initiating events that could occur to the reactor. In safety analyses for power reactors, there exist many proficient and applicable computer codes such as RELAP5, CATHARE, RETRAN, or CATHENA. For non-power research reactors, an issue arises, however, due to lacking of such specialized codes. As a result, computer codes developed for the transient analysis of power reactors need to be applied carefully after proving their applicability to a specified research reactor. The safety analysis discussed in this paper concerns the prevention of fuel damage in hypothetical accidental scenarios for the new research reactor design at National Institute of Standards and Technology (NIST). One fuel integrity criterion is analyzed by investigating the Minimum Critical Heat Flux Ratio (MCHFR) in the core during the accidental transients. Some previous studies develop a relationship that correlates the nominal value of the minimum CHFR with the probability of CHF occurring and causing fuel damage. Using a statistical approach, the nominal value of the MCHFR for the low-enriched uranium (LEU) reactor needs to remain above the recommended limiting value to better ensure the safety of the research reactor. The probability of no fuel failure increases as the MCHFR increases. More importantly, as long as the MCHFR remains above the recommended limiting value of 1.301, the reactor will have a 90% probability that CHF is not reached. The safety analysis program PARET, developed by Argonne National Laboratory (ANL), is employed to obtain the CHFR information in this study. PARET/ANL is a digital computer programming code intended primarily for the analysis of test and research reactors that use plate-type (flat) fuel elements. This program has its own set of correlations that are used to calculate the CHFR. One of them is the Mirshak correlation, which was believed to provide the best estimation of the critical heat flux under the operating conditions of the new reactor at the time. Following the critical heat flux (CHF) experiments for vertical rectangular channels in the JRR-3 (Japan Research Reactor unit 3), the CHF calculations now use the Sudo- Kaminaga correlation. This correlation is of our interest because this method has an enhanced geometric similarity and an increased range of applicability that are more representative of the actual operating conditions of our current design, and has a more mechanistic approach [9]. Since the source code of PARET/ANL is inaccessible, a MATLAB-based utility has been written to integrate the Sudo-Kaminaga correlation as a substitute for the Mirshak correlation in the code. As a result, both the Mirshak and the Sudo-Kaminaga correlations are used to analyze the standard output from the PARET program to calculate the CHFR.

11 NUCLEAR FUEL CYCLE AND FUEL MATERIALS↗