John Reynders

Comparison of C++ and Fortran 90 for object-oriented scientific programming

C++ and Fortran 90 are compared as object-oriented languages for use in scientific computing. C++ is a full-featured, object-oriented language that provides support for inheritance and polymorphism. Fortran 90 can mimic some object-oriented features through combinations of its TYPE and MODULE syntax elements, but it lacks inheritance and thus does not permit code reuse to the same extent as C++. Each language has other useful features unrelated to object-oriented programming, but the additional features of Fortran 90 can be included in C++ through the development of class libraries. In contrast, including the additional features of C++ in Fortran 90 would require further development of the Fortran 90 syntax. A critical feature missing in Fortran 90 is the template, which allows C++ programmers to build portable, reusable code and to dramatically improve the efficiency of the evaluation of complex expressions involving user-defined data types.

Array Design and Expression Evaluation in POOMA II

POOMA is a templated C++ class library for use in the development of large-scale scientific simulations on serial and parallel computers. POOMA II is a new design and implementation of POOMA intended to add richer capabilities and greater flexibility to the framework. The new design employs a generic Array class that acts as an interface to, or view on, a wide variety of data representation objects referred to as engines. This design separates the interface and the representation of multidimensional arrays. The separation is achieved using compile-time techniques rather than virtual functions, and thus code efficiency is maintained. POOMA II uses PETE, the Portable Expression Template Engine, to efficiently represent complex mathematical expressions involving arrays and other objects. The representation of expressions is kept separate from expression evaluation, allowing the use of multiple evaluator mechanisms that can support nested where-block constructs, hardware-specific optimizations and different run-time environments.

Generic Programming in POOMA and PETE

POOMA is a C++ framework for developing portable scientific applications for serial and parallel computers using high-level physical abstractions. PETE is an general-purpose expression-template library employed by POOMA to implement expression evaluation. This paper discusses generic programming techniques that are used to achieve flexibility and high performance in both POOMA and PETE. POOMAs array class factors the data representation and look-up into a generic engine concept. PETEs expression templates are used to build and operate efficiently on expressions. PETE is implemented using generic techniques that allow it to adapt to a variety of client-class interfaces, and to provide a powerful and flexible compile-time expression-tree-traversal mechanism.

The POOMA framework

The Parallel Object-Oriented Methods and Applications (POOMA) Framework is described. The POOMA FrameworK is an integrated collection of C++ classes designed to increase simulation lifetime and agility, ease data-parallel interfaces, and improve portability across rapidly evolving high-performance computing architectures. (AIP)

Optimization of Data-Parallel Field Expressions in the POOMA Framework

The POOMA framework is a C++ class library for the development of large-scale parallel scientific applications. POOMAs Field class implements a templated, multidimensional, data-parallel array that partitions data in a simulation domain into sub-blocks. These subdomain blocks are used on a parallel computer in data-parallel Field expressions. In this paper we describe the design of Fields, their implementation in the POOMA framework, and their performance on a Silicon Graphics Inc. Origin 2000. We focus on the aspects of the Field implementation which relate to efficient memory use and improvement of run-time performance: reducing the number of temporaries through expression templates, reducing the total memory used by compressing constant regions, and performing calculations on sparsely populated Fields by using sparse index lists.

Finite‐β modification of the ion‐temperature‐gradient‐driven instability in a sheared slab geometry

A coupled system of linear integral equations are derived from the electromagnetic gyrokinetic equations and solved in straight and sheared slab geometries. Simulation results of a finite‐β modified ion‐temperature‐gradient‐driven instability in a sheared geometry are presented. It is shown for typical tokamak parameters that the fundamental l=0 slab mode can be completely stabilized at β≊1% while the l=1 slab mode persists.

OOPS: an object-oriented particle simulation class library for distributed architectures

Abstract A general purpose, object-oriented particle simulation (OOPS) library has been developed for use on a variety of system architectures with a uniform high-level interface. This includes the development of library implementations for the CM5, PVM clusters, and the CRI T3D. Codes written on any of these platforms can be ported to other platforms without modifications by utilizing the high-level library. The general character of the library allows application to such diverse areas as plasma physics, suspension flows, vortex simulations, porous media, and materials science.

Tecolote: An Object-Oriented Framework for Physics Development

The authors describe a C++ physics development environment, called the Tecolote Framework, which allows model developers to work more efficiently and accurately. This Framework contains a variety of meshes, operators, and parallel fields, as well as an input/output (I/O) subsystem and graphics capabilities. Model developers can inherit Tecolote`s generic model interface and use the Framework`s high-level field and operator components to write parallel physics equations. New Tecolote models are easily registered with the Framework, and they can be built and called directly from the input file, which greatly expedites model installation. In the process of developing an extensible and robust framework, they have found appealing solutions to some of the serious problems they encounter when parallelizing and extending the older codes. They also discuss memory and performance issues for a large hydrodynamics application built in this Framework.