Maria Sosonkina

Algorithm 777: HOMPACK90: a suite of Fortran 90 codes for globally convergent homotopy algorithms

HOMPACK90 is a Fortran 90 version of the Fortran 77 package HOMPACK (Algorithm 652), a collection of codes for finding zeros or fixed points of nonlinear systems using globally convergent probability-one homotopy algorithms. Three qualitatively different algorithms— ordinary differential equation based, normal flow, quasi-Newton augmented Jacobian matrix—are provided for tracking homotopy zero curves, as well as separate routines for dense and sparse Jacobian matrices. A high level driver for the special case of polynomial systems is also provided. Changes to HOMPACK include numerous minor improvements, simpler and more elegant interfaces, use of modules, new end games, support for several sparse matrix data structures, and new iterative algorithms for large sparse Jacobian matrices.

Distributed Schur Complement Techniques for General Sparse Linear Systems

This paper presents a few preconditioning techniques for solving general sparse linear systems on distributed memory environments. These techniques utilize the Schur complement system for deriving the preconditioning matrix in a number of ways. Two of these preconditioners consist of an approximate solution process for the global system, which exploits approximate LU factorizations for diagonal blocks of the Schur complement. Another preconditioner uses a sparse approximate-inverse technique to obtain certain local approximations of the Schur complement. Comparisons are reported for systems of varying difficulty.

Note on the end game in homotopy zero curve tracking

Homotopy algorithms to solve a nonlinear system of equations <italic>f(x)</italic> = 0 involve tracking the zero curve of a homotopy map <italic>p(a, λ, x)</italic> from λ = 0 until λ = 1. When the algorithm nears or crosses the hyperplane λ = 1, an “end game” phase is begun to compute the solution <italic>x¯</italic> satisfying <italic>p(a, λ, x¯) = f(x¯)</italic> = 0. This note compares several end game strategies, including the one implemented in the normal flow code FIXPNF in the homotopy software package HOMPACK.

Non-standard Parallel Solution Strategies for Distributed Sparse Linear Systems

A number of techniques are described for solving sparse linear systems on parallel platforms. The general approach used is a domain-decomposition type method in which a processor is assigned a certain number of rows of the linear system to be solved. Strategies that are discussed include non-standard graph partitioners, and a forced load-balance technique for the local iterations. A common practice when partitioning a graph is to seek to minimize the number of cut-edges and to have an equal number of equations per processor. It is shown that partitioners that take into account the values of the matrix entries may be more effective.

Solution of Distributed Sparse Linear Systems Using PSPARSLIB

In a parallel linear system solution, an efficient usage of a multiprocessor system is usually achieved by implementing algorithms with high degree of parallelism and good convergence properties as well as by tuning parallel codes to a particular system. Among the software tools that facilitate this development is PSPARSLIB, a suite of codes for solving sparse linear systems of equations. PSPARSLIB takes a modular approach to constructing a solution method and has logic-transparent computational kernels that can be adapted to the problem at hand. Here, we outline a few parallel solution methods incorporated recently in PSPARSLIB. We give a rationale for implementing these techniques and present several numerical experiments.

Scalable parallel implementations of the GMRES algorithm via Householder reflections

Applications involving large sparse nonsymmetric linear systems encourage parallel implementations of robust iterative solution methods, such as GMRES(k). One variation of GMRES(k) is to adapt the restart value k for any given problem and use Householder reflections in the orthogonalization phase to achieve high accuracy. The Householder transformations can be performed without global communications and modified to use an arbitrary row distribution of the coefficient matrix. The effect of this modification on the GMRES(k) performance is discussed here. This paper compares the abilities of various parallel GMRES(k) implementations to maintain fixed efficiency with increase in problem size and number of processors.

Preconditioning strategies for linear systems arising in tire design

This paper discusses the application of iterative methods for solving linear systems arising in static tire equilibrium computation. The heterogeneous material properties, nonlinear constraints, and a three dimensional finite element formulation make the linear systems arising in tire design difficult to solve by iterative methods. An analysis of the matrix characteristics helps understand this behaviour. This paper focuses on two preconditioning techniques: a variation of an incomplete LU factorization with threshold and a multilevel recursive solver. We propose to adapt these techniques in a number of ways to work for a class of realistic applications. In particular, it was found that these preconditioners improve convergence only when a rather large shift value is added to the matrix diagonal. A combination of other techniques such as filtering of small entries, pivoting in preconditioning, and a special way of defining levels for the multilevel recursive solver are shown to make these preconditioning strategies efficient for problems in tire design. We compare these techniques and assess their applicability when the linear system difficulty varies for the same class of problems. Copyright

Parallel Adaptive GMRES Implementations for Homotopy Methods

The success of probability-one homotopy methods in solving large-scale optimization problems and nonlinear systems of equations on parallel architectures may be significantly enhanced by the accurate parallel solution of large sparse nonsymmetric linear systems. Iterative solution techniques, such as GMRES(k), favor parallel implementations. However, their straightforward parallelization usually leads to a poor parallel performance because of global communication incurred by processors. One variation of GMRES(k) considered here is to adapt the restart value k for any given problem and use Householder reflections in the orthogonalization phase, coupled with graph-based matrix partitioning, to achieve high accuracy and reduce the communication overhead. This particular GMRES implementation is tailored to the uniquely stringent requirements imposed on a linear system solver by probability-one homotopy algorithms: occasionally unusually high accuracy, ability to adapt to problems of widely varying difficulty, and parallelism.