Automating Embedded Analysis Capabilities and Managing Software Complexity in Multiphysics Simulation, Part II: Application to Partial Differential Equations (original) (raw)
Related papers
Albany: A Component-Based Partial Differential Equation Code Build on Trilinos
Albany is a multiphysics code constructed by assembling a set of reusable, general components. It is an implicit, unstruc-tured grid finite element code that hosts a set of advanced features that are readily combined within a single analysis run. Albany uses template-based generic programming methods to provide extensibility and flexibility; it employs a generic residual evaluation interface to support the easy addition and modification of physics. This interface is coupled to powerful automatic differentiation utilities that are used to implement efficient nonlinear solvers and preconditioners, and also to enable sensitivity analysis and embedded uncertainty quantification capabilities as part of the forward solve. The flexible application programming interfaces in Albany couple to two different adaptive mesh libraries; it internally employs generic integration machinery that supports tetrahedral, hexahedral, and hybrid meshes of user specified order. We present the overall design of Albany, and focus on the specifics of the integration of many of its advanced features. As Albany and the components that form it are openly available on the internet, it is our goal that the reader might find some of the design concepts useful in their own work. Albany results in a code that enables the rapid development of parallel, numerically efficient multiphysics software tools. In discussing the features and details of the integration of many of the components involved, we show the reader the wide variety of solution components that are available and what is possible when they are combined within a simulation capability. KEY WORDS: partial differential equations, finite element analysis, template-based generic programming
2006
Object-oriented platforms developed for the numerical solution of PDEs must combine flexibility and reusability, in order to ease the integration of new functionalities and algorithms. While designing similar frameworks, a built-in support for high performance should be provided and enforced transparently, especially in parallel simulations. The paper presents solutions developed to effectively tackle these and other more specific problems (data handling and storage, implementation of physical models and numerical methods) that have arisen in the development of COOLFluiD, an environment for PDE solvers. Particular attention is devoted to describe a data storage facility, highly suitable for both serial and parallel computing, and to discuss the application of two design patterns, Perspective and Method-Command-Strategy, that support extensibility and run-time flexibility in the implementation of physical models and generic numerical algorithms respectively.
Paraiso: an automated tuning framework for explicit solvers of partial differential equations
We propose Paraiso, a domain-specific language embedded in the functional programming language Haskell, for the automated tuning of explicit solvers of partial differential equations (PDEs) on graphic processing units (GPUs), and also multicore central processing units (CPUs). In Paraiso, one can describe PDE-solving algorithms succinctly using tensor equations notation. Hydrodynamic properties, interpolation methods and other building blocks are described in abstract, modular, re-usable and combinable forms, which lets us generate versatile solvers from a small set of Paraiso source codes. We demonstrate Paraiso by implementing a compressive hydrodynamics solver. A single source code of less than 500 lines can be used to generate solvers of arbitrary dimensions, for both multicore CPUs and GPUs. We demonstrate both manual annotation-based tuning and evolutionary computingbased automated tuning of the program.
Parallel PDE-Based Simulations Using the Common Component Architecture
Lecture Notes in Computational Science and Engineering, 2006
The complexity of parallel PDE-based simulations continues to increase as multimodel, multiphysics, and multi-institutional projects become widespread. A goal of componentbased software engineering in such large-scale simulations is to help manage this complexity by enabling better interoperability among various codes that have been independently developed by different groups. The Common Component Architecture (CCA) Forum is defining a component architecture specification to address the challenges of high-performance scientific computing. In addition, several execution frameworks, supporting infrastructure, and generalpurpose components are being developed. Furthermore, this group is collaborating with others in the high-performance computing community to design suites of domain-specific component interface specifications and underlying implementations.
Robust algorithms and software for parallel PDE-based simulations
2004
The solution of nonlinear partial differential equations (PDEs), such as those arising in computational fluid dynamics, forms an important class of applications in scientific computing. Simulation times typically depend to a large extent on the robustness and efficiency of the sparse linear solver used at each iteration of the nonlinear PDE solver. We consider algorithms and software to develop robust and efficient solvers as composites of multiple preconditioned iterative methods. Iterative solvers allow scalable parallel implementation but can often converge slowly or fail to converge. Our methods address this deficiency by using a sequence of iterative methods to provide a highly reliable solution with good parallel performance. We describe our algorithms and software for instantiating such multimethod composite solvers and report on their performance in a driven cavity flow application. §
Firedrake: automating the finite element method by composing abstractions
Firedrake is a new tool for automating the numerical solution of partial differential equations. Firedrake adopts the domain-specific language for the finite element method of the FEniCS project, but with a pure Python runtime-only implementation centred on the composition of several existing and new abstractions for particular aspects of scientific computing. The result is a more complete separation of concerns which eases the incorporation of separate contributions from computer scientists, numerical analysts and application specialists. These contributions may add functionality, or improve performance.
2013
This paper describes the history, objectives, structure, and current capabilities of the Stanford University Unstructured (SU 2) tool suite. This computational analysis and design software collection is being developed to solve complex, multi-physics analysis and optimization tasks using arbitrary unstructured meshes, and it has been designed so that it is easily extensible for the solution of Partial Differential Equation-based (PDE) problems not directly envisioned by the authors. At its core, SU 2 is an open-source collection of C++ software tools to discretize and solve problems described by PDEs and is able to solve PDE-constrained optimization problems, including optimal shape design. Although the toolset has been designed with Computational Fluid Dynamics (CFD) and aerodynamic shape optimization in mind, it has also been extended to treat other sets of governing equations including potential flow, electrodynamics, chemically reacting flows, and several others. In our experience, capabilities for computational analysis and optimization have improved considerably over the past two decades. However, the ability to integrate the resulting software packages into coupled multi-physics analysis and design optimization solvers has remained a challenge: the variety of approaches chosen for the independent components of the overall problem (flow solvers, adjoint solvers, optimizers, shape parameterization, shape deformation, mesh adaption, mesh deformation, etc) make it difficult to (a) expand the range of applicability to situations not originally envisioned, and (b) to reduce the overall burden of creating integrated applications. By leveraging well-established object-oriented software architectures (using C++) and by enabling a common interface for all the necessary components, SU 2 is able to remove these barriers for both the beginner and the seasoned analyst. In this paper we attempt to describe our efforts to develop SU 2 as an integrated platform. In some senses, the paper can also be used as a software reference manual for those who might be interested in modifying it to suit their own needs. We carefully describe the C++ framework and object hierarchy, the sets of equations that can be currently modeled by SU 2 , the available choices for numerical discretization, and conclude with a set of relevant validation and verification test cases that are included with the SU 2 distribution. We intend for SU 2 to remain open source and to serve as a starting point for new capabilities not included in SU 2 today, that will hopefully be contributed by users in both academic and industrial environments.
Embedded boundary algorithms and software for partial differential equations
Journal of Physics: …, 2008
In this paper, we give an overview of a set of methods being developed for solving classical PDEs in irregular geometries, or in the presence of free boundaries. In this approach, the irregular geometry is represented on a rectangular grid by specifying the intersection of each grid cell with the region on one or the other side of the boundary. This leads to a natural conservative discretization of the solution to the PDE on either side of the boundary. Stable and robust hyperbolic and linear elliptic/parabolic solvers have been designed and implemented. Example applications of this approach are shown for compressible and incompressible gas dynamics problems in complex geometries, and for surface diffusion in a cell membrane.
Design principles of reusable software components for the numerical solution of PDE problems
1999
We rst present some general considerations about software for Scienti c Computing and argue in favor of a component-oriented approach. Algorithmic components are identi ed as rewarding but also demanding targets for reuse by means of generic programming. In the second part we examine in more detail the interaction of algorithms and grid data structures, and show how numerical procedures can be formulated in a way that is independent of concrete grid implementations. Finally, extensions of these grid-related concepts are introduced that ease the development of parallel computing software for the numerical solution of PDEs.