# SparseModalTruncation

## Description

The `SparseModalTruncation`

object stores model order reduction
specifications for the modal truncation of sparse linear time-invariant (LTI)
models.

For sparse modal truncation, unlike the ordinary modal truncation, you cannot compute all
eigenvalues up front. The algorithm computes the *N* eigenvalues with
smallest magnitude and then performs modal decomposition in this
*N*-dimensional subspace. Hence, the modal decomposition is only
approximate.

$$G(s)\approx D+{\displaystyle \sum _{k=1}^{{n}_{c}}{G}_{k}(s)}$$

By default, the algorithm computes the first 1000 modes, which can be very time consuming.
But, you can limit the algorithm to compute a subset of modes based on the
`R.Options.Focus`

or `R.Options.MaxOrder`

settings.

## Creation

The `reducespec`

function creates a modal truncation model order reduction object when you use this
syntax.

`R = reducespec(sys,"modal")`

Here, `sys`

is a sparse LTI model (`sparss`

,
`mechss`

). The workflow uses this object to set up MOR tasks and store
results. For the full model order reduction workflow, see Task-Based Model Order Reduction Workflow.

**Tip**

Computing all modes (poles) of sparse models is very time consuming. For best results,
first set `R.Options.Focus`

or `R.Options.MaxOrder`

appropriately for your application to limit the number of modes to compute.

## Properties

## Object Functions

`process` | Run model order reduction algorithm |

`view (modal)` | Plot mode information when using modal truncation method |

`getrom (modal)` | Obtain reduced-order models when using modal truncation method |

## Examples

## Algorithms

Sparse modal truncation is applicable only to two types of symmetric semi-definite problems.

First-order problems with

*A*=*A*and^{T}*E*=*E*semi-definite (positive or negative)^{T}Second-order problems with

*K*=*K*,^{T}*M*=*M*semi-definite (positive or negative), and Rayleigh damping^{T}*C*=*αM*+*βK*

For both problems, the software uses the Krylov-Schur algorithm [1] to compute a subset of
modes (see `eigs`

).

Once you decide which modes to keep and which modes to discard, the algorithm obtains the
approximate modal decomposition *G*(*s*) =
*G*_{1}(*s*) +
*G*_{2}(*s*) +
*D*, where *G*_{1}(*s*)
contains the desired modes. Then, based on the specified method, `getrom`

returns the reduced-order model as follows.

`"truncate"`

—*G*_{r}(*s*) =*G*_{1}(*s*) +*D*`"matchDC"`

—*G*_{r}(*s*) =*G*_{1}(*s*) +*D*+*G*_{2}(0)

## References

[1] Stewart, G. W. “A Krylov--Schur
Algorithm for Large Eigenproblems.” *SIAM Journal on Matrix Analysis
and Applications* 23, no. 3 (January 2002): 601–14.
https://doi.org/10.1137/S0895479800371529.

## Version History

**Introduced in R2023b**