Random Notes...
Impedance Matching Networks

Michael F. Hutt

Abstract

A computer aided design method was developed for the purpose of designing a multi-section lumped-parameter impedance matching network. An L-section consisting of lumped-elements, which is a simple type of matching network, was used. An iterative optimization routine was implemented to obtain the values of the elements for each L-section. The general case of a complex load impedance was examined. Several n-dimensional function minimization methods were also examined. A C program for the Nelder-Mead simplex method was written to test minmax criteria for the reflection coefficient, and was successfully applied to impedance matching.

Introduction

Impedance matching networks are necessary for the following reasons [1]:

Impedance matching networks at a single frequency can be designed without much difficulty to provide a reflection coefficient of zero at the desired frequency. However, in many applications it is desirable to match impedances over a range of frequencies. One method of improving control over the bandwidth of the matching network is by adding one more element to the simple L-section lumped-element ( lumped-elements are feasible for frequencies up to about 1 GHz [1]. ) matching circuit [2] thereby creating a T-section. However, with the use of an iterative optimization routine, L-sections can simply be added to provide the required impedance matching over a given bandwidth. It should be noted that an iterative procedure is not necessary for fixed known loads. However, it is very useful for loads that vary with frequency and parasitic effects.

There are two optimization techniques available to accomplish this task; gradient methods, and direct search methods. To use a gradient method to minimize a function it would be necessary to obtain the partial derivatives of that function. Therefore, if the function is n-dimensional, it would require finding n-partial derivatives. On the other hand, direct search methods require only function evaluations. The particular direct search method that will be used here is the Nelder-Mead simplex method. Nelder-Mead is an improvement to the simplex method which starts out with an n-dimensional simplex ( a simplex in 2 dimensions is a triangle, in 3 dimensions a tetrahedron, etc. ) and evaluates the function at each vertex. It then decides which is the worst value and reflects that vertex through the centroid of the remaining n vertices, thus forming a new simplex. The Nelder-Mead simplex method will be developed using C and compared with results obtained by using Matlab (Matlab implements Nelder-Mead in an M-file called fmins.m. ).

Formulation

A two stage impedance matching network is shown below in Fig. 1.

Fig. 1. Two-stage L-section matching network

The formulas given in [3] which are shown below are good for single frequency impedance matching of real loads as well as providing a good starting point for an iterative optimization routine.

For RL > Zo:

(1a)

(1b)

For RL < Zo:

(2a)

(2b)

To utilize these formulas in the two stage L-section network shown above we first need to match Zo to Zoo, where Zoo is given as the geometric mean of Zo and RL. Then Zoo can be matched to RL in the second L-section. These initial values are then read into a program which implements the previously mentioned Nelder-Mead simplex method to minimize the reflection coefficient; Gamma. The function to be evaluated [4] is shown below in Fig.2.

float gain(float p[], float f)
{
        complex zin,s1,gamma;
        int i,n2;
        s1 = complex(0.0,2*PI*f);
        zin = zl;
        n2 = n/2;
        for (i=1;i<=n2;i++) {
        zin = zin/(s1*p[n-i]*zin+1.0);
        zin = zin+s1*p[n2-i];
        }
        gamma = (zin-ro)/(zin+ro);
        return (norm(gamma));
}
Fig. 2. Function to be optimized.

Note that the initial component values are read into the program as follows:

p[0] = L1, p[1] = L2, p[2] = C1, p[3] = C2

The program will currently handle up to a 25 section network. This should be large enough for most applications. As evident in the gain function shown above, the program is written to handle complex loads. Fig.1 is also applicable to complex loads by simply changing RL to ZL. However, the initial values will have to be modified for a complex load. The following formulas given in [1] can be used to find the initial values.

For RL > Zo:

(3a)

(3b)

For RL < Zo:

(4a)

(4b)

Note that in the case of a complex load the initial values are given in terms of a reactance X, and a susceptance B. If X is positive, then it is an inductance. If X is negative, then it is a capacitance. If B is positive it is a capacitance. If B is negative, it is an inductance. Even though the load is now complex we will still take Zoo to be the geometric mean of Zo and RL. Assuming the load in Fig.1 is ZL = 50 +j30, one of the values of B will be 0.093. This will in turn give a value of 7.352 for X. Therefore L1 = 3.901e-09 and C1 = 4.934e-11. In addition L2 = 1.524e-08 and C2 = 1.886e-11 .

Results

The graph in Fig.3 shows the initial response obtained by using the values above, along with the optimized signal from the C programs fmins.c and msimplex.c and from Matlab's fmins.m function. The specified frequency range for this particular problem was 200 MHz to 400 MHz.

Fig. 3. Reflection Coefficient Magnitude

It should be noted that fmins.c uses the same initial simplex as Matlab, however, the results are different. Since Matlab makes the source code for all the functions available, it should be possible to see the differences between them.

The msimplex.c implementation uses an initial simplex derived from [5]. The equations are as follows:

(5)

(6)

x0 = 0 
x1 = ( PN, qN, qN, ... qN) 
x2 = (qN, PN, qN, ... qN) 
xn = (qN, ..., qN, PN)
Equations (5) and (6) generate coordinates for a symmetrical simplex. It does however require that the initial simplex be scaled. For this problem it had to be scaled by a factor of 1.0e-9.

The basic difference between this implementation and that of fmins.c and fmins.m is the definition of the initial simplex. The initial simplex in msimplex.c is symmetrical, whereas the initial simplex in fmins.c is defined by the following lines of code:

/* create the initial simplex */
           for (i=0;i<n;i++) {
                v[0][i] = start[i];
           }
           for (i=1;i<=n;i++) {
                for (j=0;j<n;j++) {
                  if (v[i][j] != 0.0) {
                   v[i][j]=(1+0.05)*start[j];
                  }
                else {
                   v[i][j]=0.00025;
                }
                }
           }
Fig.4. Initial simplex created by fmins.

Obviously this creates an initial simplex that is not symmetrical. It does however remove the overhead of having to scale the simplex.

It can also be seen below in Fig.5 that the response from the msimplex.c program resembles that of a Chebyshev transformer. Matlab also appears as if it is beginning to produce a Chebyshev response, however, it is incomplete within the given frequency range.

Fig. 5. Chebyshev response.

The next logical step brought about by this result would be to start out with a Chebyshev response, and then optimize that. There are tables given in [1] which provide impedance and reflection coefficient ratios for Chebyshev multisection matching transformers. The problem here is that the design is done with quarter wave transmission lines. Since a transmission line can be modeled by an LC section, it should be possible to find the values of L and C for each section.

The impedance of a transmission line can be represented by:

(7)

However, L and C must also be chosen to provide for the required frequency response. In other words a bandpass Chebyshev filter would have to be designed for unequal terminations which is beyond the scope of this paper.

Conclusions

The results obtained, shown above in Fig.3 indicate that an iterative optimization routine can effectively be applied to the design of impedance matching networks. The use of different initial simplexes in the different routines is apparent from the graph. This emphasizes the effect of initial values in optimization routines, which is why equations (3a) through (4b) were used to generate the initial values. It was also noted that the Nelder-Mead simplex method used in msimplex.c provided results that resembled a Chebyshev response. This response suggests that initial values of LC that correspond to a Chebyshev bandpass filter may provide even better results. For the case of a 1 section impedance matching network, equations (1a) and (1b) can be used along with the tables in [1] to find the values of L and C to match that of a Chebyshev transformer. However, this does not appear to be the case for a transformer with two or more sections. Further investigation would be necessary to find a closed form solution for finding the LC values of an N section Chebyshev multisection matching transformer.

Output from C program Wmatch

The screen shot below is of the program mentioned in this paper. However, the program has since been modified to select the best initial conditions as per the formulas given in [1]. Selecting an asymmetrical initial simplex for dimensions above 8, seems to work better. The reason for this is still being investigated.


 

References

[1] Pozar, Microwave Engineering. Addison-Wesley Publishing Co., 1990.

[2] J.S. Chakmanlan "Control VSWR Bandwidth in T-Section Networks", Microwaves, vol. 20, pp.87-94, July 1981.

[3] Rizzi, Microwave Engineering Passive Circuits. Prentice-Hall, Inc.

[4] S. J. Blank, "FORTRAN Optimization Routine", New York Institute of Technology, Dept. of Electrical Engineering.

[5] D. J. Wilde and C. S. Beightler, Foundations of Optimization. Englewood Cliffs, N.J., Prentice-Hall, 1967.

Notes

The wmatch program was developed using Microsoft Visual C++ 4.0.

Throughout this project the programming interfaces of both Mathcad and Matlab were used. Mathcad provides access to built in and custom functions through DLLs. The DLLs provided by Mathcad are known as function packs. The "Numerical Recipes" function pack provides some of the routines found in the book Numerical Recipes in C. Matlab provides access to functions via script files called M-files. M files are ASCII script files written in the Matlab programming language that are then interpreted upon execution.

© 2003-2011 Michael F. Hutt. All Rights Reserved.