The effect of neutrals on the global heliosphere and interplanetary shock propagation time to the heliopause

A two-dimensional time-dependent two-fluid hydrodynamic model has been used to study numerically the effect of interstellar neutrals on the size and structure of the heliosphere. The interstellar neutrals, coupled to the plasma by charge-exchange collisions, lead to a dramatic decrease in the size of the heliosphere -- 30% for the parameters studied. We find that a build up of neutral hydrogen in front of the leading edge of the heliospbere, seen in earlier models, occurs only when the flow in the interstellar medium is supersonic. When the flow is subsonic, no such hydrogen ``wall`` is seen in the simulations, suggesting that the distribution of scattered solar H Ly a light may be quite different for this case. We have also calculated the propagation of an interplanetary shock to the heliopause as a possible trigger for the 1992 Voyager 2--3 kHz radio emission event. We find that the interstellar plasma density, observed emission cut-off frequency, and heliopause location can all b made consistent once the effect of the reduction in the size of the heliosphere by the interaction with the neutrals is included

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 the expression template library used by POOMA. This paper discusses generic programming techniques that are used to achieve flexibility and high performance in POOMA and PETE. POOMA uses an engine class that factors the data representation out of its array classes. PETE`s expression templates are used to build up and operate efficiently on expressions. PETE itself uses generic techniques to adapt to a variety of client-class interfaces, and to provide a powerful and flexible compile-time expression-tree traversal mechanism

A Parallel Three-dimensional Electromagnetic Particle-in-Cell Code for Non-Orthogonal Meshes

We describe a new parallel three dimensional electromagnetic particle-in-cell code that uses body fitted curvilinear coordinates for modeling plasma and beam devices. Cells in the structure grid are deformable hexahedra in physical space and are mapped to unit cubes in logical space for particle interpolations. The algorithms conserve particle charge and current, and update the electromagnetic fields in a divergence preserving manner. The code is modular and portable, and we present numerical results of convergence rates and benchmarks on serial, vector and parallel computers for the components separately and together. 1 Introduction An electromagnetic particle-in-cell (EMPIC) code seeks to simulate a plasma or charged particle beam through a direct simulation of the evolution of the electromagnetic fields and the charged particle positions and velocities. The overall accuracy of the code depends on (1) how well it models the geometry of the problem, (2) the algorithms it uses to upda..

SMARTS: Exploiting Temporal Locality and Parallelism through Vertical Execution

In the solution of large-scale numerical prob- lems, parallel computing is becoming simultaneously more important and more difficult. The complex organization of today's multiprocessors with several memory hierarchies has forced the scientific programmer to make a choice between simple but unscalable code and scalable but extremely com- plex code that does not port to other architectures. This paper describes how the SMARTS runtime system and the POOMA C++ class library for high-performance scientific computing work together to exploit data parallelism in scientific applications while hiding the details of manag- ing parallelism and data locality from the user. We present innovative algorithms, based on the macro -dataflow model, for detecting data parallelism and efficiently executing data- parallel statements on shared-memory multiprocessors. We also desclibe how these algorithms can be implemented on clusters of SMPS

Delayed evaluation self-optimising software components as a programming model

Abstract. We argue that delayed-evaluation, self-optimising scientific software components, which dynamically change their behaviour according to their calling context at runtime offer a possible way of bridging the apparent conflict between the quality of scientific software and its performance. Rather than equipping scientific software components with a performance interface which allows the caller to supply the context information that is lost when building abstract software components, we propose to recapture this lost context information at runtime. This paper is accompanied by a public release of a parallel linear algebra library with both C and C++ language interfaces which implements this proposal. We demonstrate the usability of this library by showing that it can be used to supply linear algebra component functionality to an existing external software package. We give preliminary performance figures and discuss avenues for future work. 1 Component-based Application Construction There is often an apparent conflict between the quality of scientific software and its performance. High quality scientific software has to be easy to re-use, easy to re-engineer

Guaranteed Optimization for Domain-Specific Programming

Abstract. For software engineering reasons, it is often best to provide domain-specific programming environments in the context of a generalpurpose language. In our view general-purpose languages are not yet general-purpose enough, and progress needs to be made before we can provide domain-specific languages that are both fast and safe. We outline some goals in this regard, and describe a possible implementation technology: guaranteed optimization, a technique for building compilers that provide proven guarantees of what optimizations they perform. Such optimizers can provide capabilities similar to staged languages, and thus provide the relevant performance improvements. They can also function as decision procedures, suggesting an approach of ’optimizers as theorem provers, ’ in which optimizing compilers can be used to check domainspecific safety properties and check proofs embedded in programs.