Excerpt

## Contents

1 Introduction

2 Transfer Function Inversion

3 State-Space Inversion

4 Improper Inverse

5 Proper Inversion

6 The MIMO Case

6.1 Example

6.2 Numerical Inversion

6.3 Analytical Inversion

6.4 Propering Filter

6.5 Proper Inversion

6.5.1 Analytical Proper Inversion

6.5.2 Inverse via Limit

6.5.3 Root Locus

6.5.4 Implementation of the Proper Inverse .

7 Unstable Systems

8 Transmission Zeros

9 Inversion of a Nonlinear System

10 EC-135 Inversion

A Matlab Function sym2tf

## List of Figures

1 Turbulence model extraction

2 General inversion scheme

3 Transfer function inversion block diagram

4 Transfer function inversion result

5 Staroper system inversion block diagram

7 Inste-space inversion block diagram

6 Imptability resulting from inadequate solver

8 Impact of propering poles

9 Proper inversion block diagram

10 Proper inverse result

11 Pole zero map of MIMO example

12 State-space proper inversion block diagram

13 Extended root locus of proper inverse

14 Instability

15 Stabilized system block diagram

16 Stabilized system result

17 Mirrored transmissions zero block diagram

18 Time delay resulting from all-pass

19 Phase shift of system, mirrored system, and mirrored system with time delay

20 Nonlinear system inversion block diagram

21 Nonlinear system inversion result

22 Input and output signals of EC-135 model

23 EC-135 inversion block diagram

24 EC-135 inversion result

25 Zoom of EC-135 inversion result

## 1 Introduction

Under the terms of the US/German MoU (Helicopter Aeromechanics) the Task IX - Modeling and Simulation for Rotorcraft Systems - is defined:

”The overall objective of this task is to improve the modeling accuracy and understanding of helicopter dynamics and control. Improved modeling and understanding of the important issues can be used to increase the fidelity of ground-based simulations, thus allowing early pilot evaluation during the de- velopment of new control systems, compatibility checks for improved safety, decreases in experimental flight testing, and hence a reduction in costs and risks.”

One of the recent subtasks under Task IX has been a disturbance rejection study[1], resulting in a UH-60 Black Hawk control equivalent turbulence simulation model[2].

illustration not visible in this excerpt

Figure 1: Turbulence model extraction

As illustrated in Figure 1 the basic idea is to have a pilot loosely stabilize a helicopter in a turbulent (input δT ) environment (e. g. hovering on the leeward side of a high building), and measure the pilot control inputs (δP ) and the reaction (rates, velocities, . . . ) of the helicopter (x).

In the off-line extraction phase the measured reaction x (which includes the reaction of the helicopter to both the turbulence and the pilot input) is fed into an inverse model of the helicopter, resulting in the corresponding control input δP+T that would be necessary to produce the measured reaction. Again, δP+T includes turbulence and pilot input. If the measured pilot input δP is subtracted, an equivalent turbulence input δTeq remains.

This equivalent turbulence input can then directly be used as an additional control input in any kind of simulator; without the need to gain and implement more complex turbulence models.

During the actual model extraction approach[1]it became clear that

”Ideally, an exact numerical inverse of the coupled MIMO model would be used.”

This paper will therefore present and discuss different approaches to invert dynamical systems.

## 2 Transfer Function Inversion

The inversion of a general dynamic system is depicted in Figure 2

illustration not visible in this excerpt

Figure 2: General inversion scheme

where u and y are the input and the output of the system G to be inverted, while u* and y* denote the input and the output of the inverse system G*. If G* is a true dynamic inverse of G, a serial connection of both systems

u* = y (1)

produces an identity system, in which the overall input and output are identical

y* = u. (2)

If the system to be inverted is linear and time invariant (LTI) and has a single input and a single output (SISO) it can be represented as a transfer function

illustration not visible in this excerpt

where the roots of the numerator and denominator are called the zeros and the poles of the system respectively.

The inversion of a transfer function is a very straightforward exchange of numerator and denominator

illustration not visible in this excerpt

Therefore, the roots of the system are the zeros of the inverted system and vice versa. Matlab carries out the inversion via the overloaded inv command:

>> G_tf = tf ([0.1 1], [1 1])

Transfer function:

0.1 s + 1

---------

s + 1

>> G_star_tf = inv (G_tf)

Transfer function:

s + 1

---------

0.1 s + 1

Simulink can then simulate the identity system (Figure 3) according to Figure 2.

illustration not visible in this excerpt

Figure 3: Transfer function inversion block diagram

Figure 4 demonstrates that, even though the doublet with its sharp edges (and the corresponding high frequency spectrum portion) poses quite a challenge for the inverter, it is regained almost perfectly.

illustration not visible in this excerpt

Figure 4: Transfer function inversion result

Also, the influence of the transfer function zero with the time constant of 0.1 sec can be found in the immediate ”jumping” of the system output at every doublet edge.

## 3 State-Space Inversion

The inversion of a dynamic system can also be performed in state-space. The state-space representation of an LTI system is given by

illustration not visible in this excerpt

where u ∈ R^{m} and y ∈ R^{p} are the input and the output vectors, and the state vector and its derivative are denoted by x ∈ R^{n} and x ∈ R^{n}. The n × n state matrix A holds the dynamics of the system, while the n × m input matrix B and the p × n output matrix C define the impact of every single input on the derivative and the representation of every single state in the output vector, respectively. The p × m feedthrough matrix D quantifies the immediate reaction of the output with respect to the input and will obtain some importance in the scope of this paper.

If the feedthrough matrix is regular, Equation 6 can be solved for u

illustration not visible in this excerpt

which can then be substituted in Equation 5

illustration not visible in this excerpt

For the inverse system, the input and output have to be exchanged (Equations in Equations 8 and 7

illustration not visible in this excerpt

According to Equations 9 and 10, the matrices of the inverse system are

illustration not visible in this excerpt

Matlab uses Equations 11 - 14, when the overloaded inv command is applied to a state-space system:

>> G_ss = ss (G_tf);

>> [A, B, C, D] = ssdata (G_ss)

A = -1

B = 1

C = 0.9000

D = 0.1000

>> G_star_ss = inv (G_ss);

>> [A_star, B_star, C_star, D_star] = ssdata (G_star_ss)

A_star = -10

B_star = 10

C_star = -9

D_star = 10

In the corresponding Simulink block diagram (Figure 5) both systems have been explic- itly expanded, offering direct access to the state vectors, proving both to be identical.

The signals in the scopes are identical to those in Figure 4.

illustration not visible in this excerpt

Figure 5: State-space inversion block diagram

## 4 Improper Inverse

The definition of the properness of a transfer function G(s) depends on the relation between the degrees of its numerator (m) and denominator (n):

n > m: G(s) is said to be strictly proper.

n ≥ m: G(s) is said to be proper.

n = m: Consequently, G(s) is said to be proper but not strictly proper.

n < m: G(s) is said to be (strictly) improper.

According to that definition, the before-used example[illustration not visible in this excerpt]is proper but not strictly proper; its inverse having the same property. Therefore, both systems are realizable and implementable without any extra effort.

Unfortunately, many technical system representations (e. g. measuring velocities but not accelerations) are strictly proper; their inverse would therefore be improper. Improper transfer functions cannot be transformed into state-space form and they can therefore not directly be simulated in state-space-oriented simulation environments like Matlab (or Simulink):

>> G_tf = tf (1, [1 1])

Transfer function:

1

-----

s + 1

>> G_star_tf = inv (G_tf)

Transfer function: s + 1

>> G_star_ss = ss (G_star_tf)

??? Error using ==> tf/ss Improper system. Conversion to

state-space is not possible

>> step (G_star_tf)

??? Error using ==> rfinputs

Not supported for non-proper models.

And, even though it would be possible to use a Derivative-, a Gain-, and a Sum-block to construct the inverse transfer function in Simulink , the usual way to circumvent the non-realizability of improper systems is to append as many high-frequency ”propering” poles as necessary to make the transfer function proper:

>> G_filt = tf (1,[1e-3 1])

Transfer function:

1

-----------

0.001 s + 1

>> G_prop_star_tf= G_star_tf*G_filt

Transfer function:

s + 1

-----------

0.001 s + 1

The proper inverse system is now ready to be implemented under Simulink to compen- sate the original system and regain the doublet (Figure 6).

illustration not visible in this excerpt

Figure 6: Improper system inversion block diagram

Using Simulink’s default Simulation parameters (Solver type: Variable-step ode45, Relative tolerance: 1e − 3) the result is quite impressive (Figure 7).

This kind of instability is typical when using non-stiff solvers to solve moderately stiff systems. When appending the propering poles, a performance tradeoff has to be found: On the one hand the poles should be fast and placed far outside frequency range of interest, in order not to introduce additional significant parasitic dynamic; on the other hand, additional poles, much faster than the dynamic of the system, increase the band- width, make the system stiffer and therefore harder to integrate for non-stiff integration algorithms.

Fortunately, modern simulation environments supply their users with all kinds of high- sophisticated integration algorithms. For example, if the stiff solver ode15s is selected, the simulation result looks as unspectacular as Figure 4. And, if one zooms deeply in (Figure 8), the small delay caused by the propering pole becomes visible. Note that the same result could also be obtained with a fixed-step ode4 solver and a step size of 0.001.

**[...]**

- Quote paper
- Prof. Dr.-Ing. Jörg Buchholz (Author)Wolfgang v. Grünhagen (Author), 2007, Inversion Impossible?, Munich, GRIN Verlag, https://www.grin.com/document/85745

Publish now - it's free

Comments