Phalanx Documentation

Development

Index

• The Elevator Speech
• Overview
• Users Guide
• Frequently Asked Questions
• Reporting Bugs and Making Enhancement Requests
• History
• Authors and Contributors
• Copyright
• For All Questions and Comments...

The Elevator Speech

Phalanx is a local field evaluation kernel specifically designed for general partial differential equation solvers. The main goal of Phalanx is to decompose a complex problem into a number of simpler problems with managed dependencies to support rapid development and extensibility of the PDE code. Through the use of template metaprogramming concepts, Phalanx supports arbitrary user defined data types and evaluation types. This allows for unprecedented flexibility for direct integration with user applications and provides extensive support for embedded technology such as automatic differentiation for sensitivity analysis, optimization, and uncertainty quantification.

Overview

Phalanx is a local field evaluation kernel specifically designed for general partial differential equation (PDE) solvers. It can be used with any cell-based discretization techniques including finite element and finite volume. The main goal of Phalanx is to decompose a complex problem into a number of simpler problems with managed dependencies to support rapid development and extensibility of the PDE code. This approach, coupled with the template capabilities of C++ offers a number of unique and powerful capabilities:

• Fast Integration with Flexible and Extensible Models:
  • Increased flexibility because each simpler piece of the decomposed problem becomes an extension point that can be swapped out with different implementations.

  • Easier to implement new code because each piece is simpler, more focused and easier to test in isolation.

  • Easier for users to add their own models. While Phalanx is designed for maximum flexibility and efficiency, the interfaces exposed to users are very simple, requiring minimal training and/or knowledge of the C++ language to use.

  • Through the use of template metaprogramming concepts, Phalanx supports arbitrary user defined data types. This allows for unprecedented flexibility for direct integration with user applications and opens the door to embedded technology.

• Support for Advanced Embedded Technology: Phalanx is fully compatible with advanced embedded technologies. Embedded technology consists of replacing the default scalar type (i.e., "double" values) in a code with an object that overloads the typical mathematical operators. By replacing the scalar type, we can reuse the same code base to produce different information. For example, if we were to compute a function , where and . We could automatically compute the sensitivities of the function, such as the Jacobian, merely by replacing the scalar type of double with an automatic differentiation (AD) object. With the C++ template mechanism, this is a trivial task. Embedded technology provides:
  • Applications can reuse the exact same code base written to evaluate a function yet produce new information including arbitrary precision, sensitivities (via embedded automatic differentiation), and uncertainty quantification.

  • By reusing the same code for both function and sensitivity evaluation, developers avoid having to hand code time consuming and error prone analytic derivatives and ensure that the equation sets are consistent.

• Consistent field evaluations via dependency chain management: When users switch models, the dependencies for fields evaluated by the model can change. This can force field to be evaluated in a different order based on the new dependencies. Phalanx will automatically perform the sorting and ordering of the evaluator routines. For example, if density were a field to be evaluated, different models could have different dependencies. Model A could depend on temperature and pressure, whille model B could depend on temperature, pressure, and species mass fractions of a multicomponent mixture. The order of evaluation of fields could change based on the change in dependencies. Using Model B will require that the species mass fractions be evaluated and available for the density evaluation while Model A does not even require them. This is a simple example, but the dependency chain can become quite complex when solving thousands of coupled PDE equations.

• Efficient evaluation of field data: Phalanx was designed on the idea of worksets. A workset is an arbitrarily sized block of cells to be evaluated on the local processor. Phalanx evaluates all fields of interest at once for each block of cells. By using the contiguous allocator and correctly sizing the workset to fit in processor cache (if possible), one can arrange all fields to exist in a contiguous block of memory, independent of the data type objects used to store the data (one must still be careful of data alignement issues). By keeping all fields in cache, the code should run much faster. This workset idea will also, in the future, allow for multi-core distrubution of the cell evaluations.

Phalanx is a hammer. It's use should be carefully considered. We recommend its use when writing a general PDE framework where one needs support for flexibility in equation sets. It should not be used for simple sets of PDEs where the equations rarely change. There are some drawbacks to using Phalanx that should be considered:

• A potential performance loss due to fragmentation of the over-all algorithm (e.g., several small loops instead of one large loop). A judicous choice of field variables can alleviate this problem.

• A potential loss of visibility of the original, composite problem (since the code is scattered into multiple places).

Managing these trade-offs can result in application code that both performs well and supports rapid development and extensibility.

Reporting Bugs and Making Enhancement Requests

To reports bugs or make enhancement requests, visit the Trilinos Bugzilla (Bug Tracking) Database, and use the following instructions.

• Click on "Enter a new bug report"
• Choose "Phalanx"
• Either login or create a new account
• Submit your bug report

History

Phalanx grew out of the Variable Manger in the Charon code and the Expression Manager in the Aria code. It is an attempt at merging the two capabilities and is slated to provide nonlinear function evaluation to the Intrepid discretiztion package.

Authors and Contributors

The following have contributed to the design through ideas, discussions, and/or code development of Phalanx:

• Roger Pawlowski (Lead Developer), SNL 01414
• Eric Phipps, SNL 01411
• Pat Notz, SNL 01541

Copyright

************************************************************************

       Phalanx: A Partial Differential Equation Field Evaluation 
      Kernel for Flexible Management of Complex Dependency Chains
                 Copyright (2008) Sandia Corporation

Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
the U.S. Government retains certain rights in this software.

This library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of the
License, or (at your option) any later version.
 
This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA

Questions? Contact Roger Pawlowski (rppawlo@sandia.gov), Sandia
National Laboratories.

************************************************************************

For All Questions and Comments...

Please contact Roger Pawlowski (rppawlo@sandia.gov).

---