Publications

A rezone stencil for ALE shock calculations has been developed based on a stabilized variant of the serendipity element. This rezone stencil is compared to the Winslow rezone stencil. Unlike the Winslow stencil, which equalizes element volumes as well as node angles, the serendipity stencil equalizes node angles only. This may be advantageous for calculations involving strong density gradients such as those associated with shock compression.

ALEGRA is an arbitrary Lagrangian-Eulerian finite element code that emphasizes large distortion and shock propagation. This document describes the user input language for the code.

Abstract not provided.

The ALEGRA radiation transport package implements diffusion, flux-limited diffusion, and SPn radiation transport for both gray and multigroup photon spectra. Comparisons of ALEGRA calculations with known solutions for a selection of benchmark problems for these transport theories are presented. ALEGRA returns accurate solutions in each case. This verifies that each transport theory has been implemented correctly, though it does not prove that the transport theories are valid for problems of interest at Sandia. A validation study will be presented in a future report.

ALEGRA is a coupled physics framework originally written to simulate inertial confinement fusion (ICF) experiments being conducted at the PBFA-II facility at Sandia National Laboratories. It has since grown into a large software development project supporting a number of computational programs at Sandia. As the project has grown, so has the development team, from the original two authors to a group of over fifteen programmers crossing several departments. In addition, ALEGRA now runs on a wide variety of platforms, from large PCs to the ASCI Teraflops massively parallel supercomputer. The authors discuss the reasons for ALEGRA`s success, which include the intelligent use of object-oriented techniques and the choice of C++ as the programming language. They argue that the intelligent use of development tools, such as build tools (e.g. make), compiler, debugging environment (e.g. dbx), version control system (e.g. cvs), and bug management software (e.g. ClearDDTS), is nearly as important as the choice of language and paradigm.

The author presents a novel method for calculating the penetration of soft targets by hard projectiles by using a combination of ALE and contact surface techniques. This method allows the bifurcation in the softer material (at the point of the projectile) to be represented without sacrificing the Lagrangian representation of either the harder material or the contact interface. A series of calculations using this method show good agreement with the experimental data of Forrestal et al. This method may prove useful for a range of semi-fluid/structure interactions with friction, including simulations of manufacturing processes.

C++ is commonly described as an object-oriented programming language because of its strong support for classes with multiple inheritance and polymorphism. However, for a growing community of numerical programmers, an equally important feature of C++ is its support of operator overloading on abstract data types. The authors choose to call the resulting style of programming object-oriented numerics. They believe that much of object-oriented numerics is orthogonal to conventional object-oriented programming. As a case study, they discuss two strong shock physics codes written in C++ that they`re currently developing. These codes use both polymorphic classes (typical of traditional object-oriented programming) and abstract data types with overloaded operators (typical of object-oriented numerics). They believe that C++ translators can generate efficient code for many numerical objects. However, for the important case of smart arrays (which are used to represent matrices and the fields found in partial differential equations) fundamental difficulties remain. The authors discuss the two most important of these, namely, the aliasing ambiguity and the proliferation of temporaries, and present some possible solutions.

One of the most widely recognized inadequacies of C is its low-level treatment of arrays. Arrays are not first-class objects in C; an array name in an expression almost always decays into a pointer to the underlying type. This is unfortunate, especially since an increasing number of high-performance computers are optimized for calculations involving arrays of numbers. On such machines, double [] may be regarded as an intrinsic data type comparable to double or int and quite distinct from double. This weakness of C is acknowledged in the ARM where it is suggested that the inadequacies of the C array can be overcome in C++ by wrapping it in a class that supplies dynamic memory management, bounds checking, operator syntax, and other useful features. Such ``smart arrays`` can in fact supply the same functionality as the first-class arrays found in other high-level, general-purpose programming languages. Unfortunately, they are expensive in both time and memory and make poor use of advanced floating-point architectures. Is there a better solution? The most obvious solution is to make arrays first-class objects and add the functionality mentioned in the previous paragraph. However, this would destroy C compatibility and significantly alter the C++ language. Major conflicts with existing practice would seem inevitable. I propose instead that numerical array classes be adopted as part of the C++ standard library. These classes will have the functionality appropriate for the intrinsic arrays found on most high-performance computers, and the compilers written for these computers will be free to implement them as built-in classes. On other platforms, these classes may be defined normally, and will provide users with basic army functionality without imposing an excessive burden on the implementor.

This report discusses the relationship between the New and Malloc operators used in programming C++.

C++ is rapidly gaining in popularity as a scientific programming language. The data encapsulation inherent in the class concept and the availability of operator overloading for compact representation of operations make it an ideal language for translating concepts in mathematical physics into computer code. Furthermore, its strong type checking and memory management features facilitate correct coding of algorithms. Unfortunately, C++ code which is written in the true spirit of the language is often very inefficient under current compiler implementations. Many of the inefficiency issues, such as unnecessary copy operations or proliferation of temporaries, have been well-characterized. Some may be alleviated by clever C++ coding, but others cannot be alleviated except by writing C-like code that sacrifices one or more of the best features of the language. This document describes a major source of efficiency problems in expressions using overloaded operators on array classes, and proposes certain minor modifications to the C++ language standard which will facilitate optimization of these expressions.

C++ is the first object-oriented programming language which produces sufficiently efficient code for consideration in computation-intensive physics and engineering applications. In addition, the increasing availability of massively parallel architectures requires novel programming techniques which may prove to be relatively easy to implement in C++. For these reasons, Division 1541 at Sandia National Laboratories is devoting considerable resources to the development of C++ libraries. This document describes the first of these libraries to be released, PHYSLIB, which defines classes representing Cartesian vectors and (second-order) tensors. This library consists of the header file physlib.h, the inline code file physlib.inl, and the source file physlib.C. The library is applicable to both three-dimensional and two-dimensional problems; the user selects the 2-D version of the library by defining the symbol TWO D in the header file physlib.h and recompiling physlib.C and his own code. Alternately, system managers may wish to provide duplicate header and object modules of each dimensionality. This code was produced under the auspices of Sandia National Laboratories, a federally-funded research center administered for the United States Department of Energy on a non-profit basis by AT T. This code is available to US citizens, and institutions under research, government use and/or commercial license agreements.