Dakota: Optimization and Uncertainty Quantification Algorithms for Design Exploration and Simulation Credibility.

The Dakota toolkit provides a flexible, extensible interface between analysis codes and iterative systems analysis methods. Dakota contains algorithms for:

• optimization with gradient and nongradient-based methods;
• uncertainty quantification with sampling, reliability, stochastic expansion, and epistemic methods;
• parameter estimation with nonlinear least squares methods; and
• sensitivity/variance analysis with design of experiments and parameter study methods.

These capabilities may be used on their own or as components within advanced strategies such as hybrid optimization, surrogate-based optimization, mixed integer nonlinear programming, or optimization under uncertainty.

With the growth of simulation data, finding relevant data within the sea of raw data can be a much more daunting task than running the simulation at scale in the first place. EMPRESS provides a separate metadata system allowing storing detailed run information as well as user-defined at runtime different data characteristics and associate those characteristics with a variable, a timestep, or run.

It has been published at PDSW-DISCS @ SC17 and SC18 and is available as open source on github.com

Kitten is a current-generation lightweight kernel (LWK) compute node operating system designed for large-scale parallel computing systems. Kitten is the latest in a long line of successful LWKs, including SUNMOS, Puma, Cougar, and Catamount. Kitten distinguishes itself from these prior LWKs by providing a Linux-compatible user environment, a more modern and extendable open-source codebase, and a virtual machine monitor capability via Palacios that allows full-featured guest operating systems to be loaded on-demand.

ParaView is an open-source, multi-platform data analysis and visualization application. ParaView users can quickly build visualizations to analyze their data using qualitative and quantitative techniques. The data exploration can be done interactively in 3D or programmatically using ParaView’s batch processing capabilities.

ParaView was developed to analyze extremely large datasets using distributed memory computing resources. It can be run on supercomputers to analyze datasets of exascale size as well as on laptops for smaller data.

ParaView is maintained by Kitware, Inc. Sandia collaborates with Kitware to address our large-scale data analysis and visualization needs through ParaView.

Peridigm is an open-source computational peridynamics code. It is a massively-parallel simulation code for implicit and explicit multi-physics simulations centering on solid mechanics and material failure. Peridigm is a C++ code utilizing foundational software components from Sandia’s Trilinos project and is fully compatible with the Cubit mesh generator and Paraview visualization codes.

Portals is a message passing interface intended to allow scalable, high-performance network communication between nodes of a parallel computing system. Portals is designed to operate on scales ranging from a small number of commodity desktops connected via Ethernet to massively parallel platforms connected with custom designed networks.

Portals attempts to provide a cohesive set of building blocks with which a wide variety of upper layer protocols (such as MPI, SHMEM, or UPC) may be built, while maintaining high performance and scalability. Many interfaces today either provide a simple mapping to hardware which may not be conducive to building upper layer protocols (InfiniBand/Open Fabrics Enterprise Distribution) or which are only a good fit for a subset of upper layer protocols (PSM, UCX).

Prove-It uses a powerful yet simple approach to theorem-proving. It is not designed with automation as the primary goal. The primary goal is flexibility in order to be able to follow, ideally, any valid and complete (indivisible) chain of reasoning. To that end, users can write additional Python scripts to make their own mathematical operations and LaTeX formatting rules. Axioms are statements that are taken to be true without proof. They can be added by the user at will in order to define their new mathematical objects and operations. Users can also add theorems that are to be proven. Theorems may be proven in any order.  Theorem proofs are constructed in Jupyter notebooks (interactive Python sessions in a web browser). These notebooks render LaTeX-formatted mathematical expressions inline. Proofs are constructed by invoking axioms and other theorems and employing fundamental derivation steps (modus ponens, deduction, instantiation, generalization, or axiom elimination).  Axioms and theorems may be invoked indirectly via convenience methods or automation (methods that are automatically invoked when attempting to prove something or as side-effects when something is proven). Theorem proofs and their axiom/theorem dependencies are stored in a kind of database (filesystem based). This database is used to prevent circular logic. It also allows users to track axioms and unproven theorems required by any particular proof. Convenience methods and automation tools may be added which utilize new theorems and aid future proofs. Mathematical objects and operations, axioms, and theorems are organized into built-in and user-defined packages.

PyApprox provides flexible and efficient tools for credible data-informed decision making. PyApprox implements methods addressing various issues surrounding high-dimensional parameter spaces and limited evaluations of expensive simulation models with the goal of facilitating simulation-aided knowledge discovery, prediction and design. Methods are available for: low-rank tensor-decomposition; Gaussian processes; polynomial chaos expansions; sparse-grids; risk-adverse regression; compressed sensing; Bayesian inference; push-forward based inference; optimal design of computer experiments for interpolation regression and compressed sensing; and risk-adverse optimal experimental design.

Pyomo is a Python-based open-source software package that supports a diverse set of capabilities for formulating, solving, and analyzing optimization models.

A core capability of Pyomo is modeling structured optimization applications.  The Pyomo software package can be used to define general symbolic problems, create specific problem instances, and solve these instances using standard commercial and open-source solvers.  Pyomo’s modeling objects are embedded within a full-featured high-level programming language with a rich set of supporting libraries that distinguishes it from other algebraic modeling languages such as AMPL, AIMMS and GAMS.

Pyomo supports a wide range of problem types, including:

• Linear programming
• Quadratic programming
• Nonlinear programming
• Mixed-integer linear programming
• Mixed-integer quadratic programming
• Mixed-integer nonlinear programming
• Mixed-integer stochastic programming
• Generalized disjunctive programming
• Differential algebraic equations
• Bilevel programming
• Mathematical programming with equilibrium constraints

Pyomo also supports iterative analysis and scripting within a full-featured programming language providing an effective framework for developing high-level optimization and analysis tools. 

The Qthreads API is designed to make using large numbers of threads convenient and easy, and to allow portable access to threading constructs used in massively parallel shared memory environments. The API maps well to both MTA-style threading and PIM-style threading, and we provide an implementation of this interface in both a standard SMP context as well as the SST context. The qthreads API provides access to full/empty-bit (FEB) semantics, where every word of memory can be marked either full or empty, and a thread can wait for any word to attain either state.

Rapid Optimization Library (ROL) is a high-performance C++ library for numerical optimization. ROL brings an extensive collection of state-of-the-art optimization algorithms to virtually any application. Its programming interface supports any computational hardware, including heterogeneous many-core systems with digital and analog accelerators. ROL has been used with great success for optimal control, optimal design, inverse problems, image processing and mesh optimization, in application areas including geophysics, structural dynamics, fluid dynamics, electromagnetics, quantum computing, hypersonics and geospatial imaging.

The Trilinos Project is an effort to develop algorithms and enabling technologies within an object-oriented software framework for the solution of large-scale, complex multi-physics engineering and scientific problems. A unique design feature of Trilinos is its focus on packages.

One of the biggest recent changes in high-performance computing is the increasing use of accelerators. Accelerators contain processing cores that independently are inferior to a core in a typical CPU, but these cores are replicated and grouped such that their aggregate execution provides a very high computation rate at a much lower power. Current and future CPU processors also require much more explicit parallelism. Each successive version of the hardware packs more cores into each processor, and technologies like hyperthreading and vector operations require even more parallel processing to leverage each core’s full potential.

VTK-m is a toolkit of scientific visualization algorithms for emerging processor architectures. VTK-m supports the fine-grained concurrency for data analysis and visualization algorithms required to drive extreme scale computing by providing abstract models for data and execution that can be applied to a variety of algorithms across many different processor architectures.