OTHER NEWTON-TYPE METHODS

Several other methods based on the Newton iterative procedure are known for nonlinear one-parameter eigenvalue problems. A sample of these methods may be found in [5], and many of them are straightforward to extend to the multiparameter case – though due to constraints of size we cannot perform numerical experiments on all of them. Here we give a brief overview of these methods, as applied to multiparameter problems.

Chapter 6 – page 152 6.5.1 Iteration based on minimum singular value

At any flutter point of the problem ( ) , one of the singular values of the matrix must be zero. We can thus reformulate the eigenvalue problem into a minimisation problem, the objective being to minimise the minimum singular value ( ) of , subject to the constraint . Note that we do not required the eigenvector to evaluate , and so we need only iterate over the eigenvalue space. We can evaluate either by computing the singular value decomposition of or by performing an inverse iteration on the Hermitian conjugate of multiplied by ( ) and taking the square root of the resulting converged eigenvalue1. This minimisation problem can of be treated with Newton’s method by reformulating it again into the problem of finding the roots of the gradient of (i.e. solving ). Newton’s method can then be applied to the residual function . As far as we know this method has not been presented before for even one-parameter problems, but it is not particularly novel and does not have much to recommend it.

There are of course other many methods of solving the minimisation problem, and these are perhaps more interesting. Other iterative algorithms, such as the conjugate gradient methods, may be most appropriate to problems with simpler flutter behaviour; for larger problems with more complex behaviour (discontinuities and the like) a simulated annealing or particle swarm optimisation may be attractive. Treating the flutter problem as a minimisation problem does appear to have some potential, particularly when dealing with large and complex problems, where particle swarm optimisation (or a related heuristic method) has the potential to provide near-global convergence, something that is difficult to obtain with standard iterative methods. However, it should be noted that the minimisation approach does have the disadvantage of introducing spurious solutions (minima of where

) which will attract the minimisation algorithm but are not flutter points. If there are many such minima then the real flutter points will be difficult to locate, and the problem will probably have to be treated with a particle-swarm method. But there may be ways to modify the residual definition to eliminate the nonzero flutter points, and this is still a promising avenue for future research. When the flutter problem is defined in more than two

1

Inverse iteration (with zero shift) being well-known to converge to the smallest eigenvalue of a system [7]. Note that the singular values of are the square root of the eigenvalues of [11,15]

Chapter 6 – page 153

dimensions, with more than one matrix function (i.e. not simply and ̅, but a set of ) then it is possible to compute the flutter points by minimising the sum of the minimum singular values of each function (∑ ). Because the singular values are by definition always

real and non-negative, the case (a flutter point) will always correspond to a

global minimum. Spurious flutter points at local minima will still exist.

A possible alternative approach to problems with more than one matrix function is to define a vector residual containing the minimum singular values of each matrix function ( ( ) [ ]). This has the advantage that no spurious flutter points are

introduced. However, it requires that each matrix function be distinct, else the Jacobian of the residual function will be singular. As such it is not applicable to the flutter problems that we have been focusing on (i.e. systems with only and ̅), but it remains a useful possibility for more general systems.

6.5.2 Full eigenvalue / eigenvector iteration

Consider first the general two-parameter unstructured problem:

( )

( ) (6.5.1)

We observe that these two equation are already in the form of a vector residual function

( ) . However, to evaluate these residual functions we require the eigenvectors . When we devised the SLP algorithm in Section 6.2 we avoided this problem by linearising the matrix function and solving it with a direct solver (allowing us to advance the iteration without having to compute the residual, except as part of convergence criterion after the iteration was complete).

Alternately, we could simply include the eigenvectors in our iteration vector, and define

[ ]. However, our iteration vector is now larger than the combined residual function ( ( ) [ ( ) ( ) ]). Two elements are missing. The under- constrained nature of this system makes perfect physical sense, as when the eigenvalues are at the flutter point the eigenvectors can be scaled arbitrarily. We must define the scaling, and a convenient way of doing this is to apply a normalisation. We then define two

Chapter 6 – page 154

extra elements of the residual, and . The residual function and iteration vector are now

( ) [ ( ) ( ) ] [ ] (6.5.2)

Newton’s method can then be applied directly to Eq. 6.5.2. Note that it is easy to generalise Eq. 6.5.2 to the -parameter case (with vector of eigenvalues ): we simply have

( ) [ ( ) ( ) ] [ ] (6.5.3)

However, we find that when we are dealing with the two-parameter flutter problems that we consider in this work, Eq. 6.5.2 is somewhat redundant, as we have ̅ and

̅ . The two eigenproblem residuals ( ) and ̅( ) ̅ will give residuals that are simply conjugate to each other, and the two normalisation equations are equivalent, as

̅ ̅

̅̅̅̅̅ ̅̅̅̅̅ ̅̅ ̅ , but is always real, and so ̅ ̅ . The fact that the eigenproblem residuals are conjugate to each other will probably not cause the Newton iteration to fail, but the fact that the normalisation conditions are the same will do so, as the Jacobian will be singular. Note that we should be very careful about describing the two parameter problem (Eq. 6.5.1) with ̅ and ̅ as being redundant or overconstrained – as we have seen in Chapter 4, the second equation is entirely necessary when using a direct solver. It is only in the context of this method that we can describe the second equation as redundant, and the reasons behind this are not fully understood. We discuss this issue of constrainedness in Chapter 7.

If we simply remove the second eigenvector normalisation condition and the second eigenproblem residual from the residual definition (and the conjugate eigenvector from the iteration variable), the problem then becomes underconstrained, as we have one more element in the iteration variable than in the residual definition. One possibility of

Chapter 6 – page 155

circumventing this problem is to reformulate the two real eigenvalues into one complex- valued eigenvalue . This yields

( ) [ ( ( ) ( ))

] [ ] (6.5.4)

which is fully constrained. Whether this reformulation is numerically effective remains to be seen. However, the approach of reformulating the real two-parameter eigenproblem into a complex one-parameter problem is very interesting, and is something we will discuss in Chapter 7.

This application of Newton’s method to the multiparameter eigenvalue problems has been presented previously in [4], though this reference modifies the algorithm further to become the tensor Rayleigh quotient iteration, and does not consider the case ̅ . However, in an unusual and apparently unmotivated variant, Khazanov [10] applies this method to a system with one linear -parameter eigenvalue problem of size coupled with a constraint equation of the form ( ) , where is the eigenvalue of the linear problem and is of size , . However, this implementation on Newton’s method is new to aeroelasticity.

6.5.3 Tensor Rayleigh quotient iteration (TRQI)

The tensor Rayleigh quotient iteration is an iterative method for linear two-parameter eigenvalue problems that is based around modifying the full eigenvalue / eigenvector iteration to use the information from the Rayleigh quotient of the solution at the previous timestep. For an eigenvalue problem , the Rayleigh quotient provides a further relationship between the eigenvalues and eigenvectors:

( )

(6.5.5)

We will not go over the derivation of the TRQI algorithm, but essentially it reduces the full eigenvalue / eigenvector Newton iteration to an iteration that acts only on the eigenvalues (making for a much smaller system). Plestenjak [4] devises the TRQI algorithm but uses alongside a continuation method to solve a linear problem. The method is extendable to

Chapter 6 – page 156

multiparameter problems, though the algebraic expressions involved become increasingly unwieldy. We note that the singular vector iteration that we present in Section 6.6 borrows many elements of tensor Rayleigh quotient iteration, but also has significant differences (representing a Picard-type implementation instead of a Newton-type).

6.6 SINGULAR VECTOR ITERATION (SVI)