Broadband analysis of microstrip patch antenna using 3D FDTD - UPML

Srikumar Sandeep
ECEN 5134- Term paper University of Colorado at Boulder Abstract This paper presents the analysis of microstrip patch antenna using the three dimensional Finite Difference Time Domain (FDTD) method. The derivation and implementation of the three dimensional FDTD method is described. This is done along with the implementation of an artificial absorbing boundary medium known as the Uniaxial Perfectly Matched Layer (UPML). This medium enables to limit the computational domain required for simulation. This is followed by the broadband analysis of a microstrip line fed rectangular patch antenna using Gaussian pulse excitation. The broadband analysis is used to estimate the return loss of the line fed antenna. The results are compared with the solution obtained from Ansoft planar EM simulator. Furthermore, the input resistance and reactance of the antenna near resonance are estimated. I .INTRODUCTION Microstrip patch antennas are low profile antennas that are simple and inexpensive to manufacture. They are mechanically robust and are conformable to planar and nonplanar surfaces. One of the main features of the microstrip antenna is the extremely narrow frequency bandwidth. Several methods exist for the analysis of microstrip antennas. They can be classified as the Transmission Line Model (TLM), cavity model and full wave models. Finite Element Method (FEM), FDTD, Integral Equation Method of Moment (IE MoM) are some of the prominent full wave models. The primary advantage of FDTD over other full-wave models is that, FDTD being a time domain method allows broadband analysis of the antenna by Gaussian pulse excitation. The antenna characteristics over a wide frequency range can be obtained by taking the Fourier transform of the FDTD simulation results obtained when a wideband Gaussian pulse is used as an excitation. Moreover, most of widely used electromagnetic simulation software's use frequency domain methods like FEM. The disadvantages of the FDTD are high memory and computational requirements. Since the computational power will continue to grow exponentially in the future, this drawback will become less significant.

FDTD has received tremendous attention in the literature recently. FDTD has been used to simulate and analyze a plethora of electromagnetic problems ranging from antennas, microwave wave circuits, electromagnetic compatibility (EMC) issues, bioelectromagnetics, electromagnetic scattering to novel materials and nanophotonics [2]. In this paper, we explore the analysis of microstrip patch antennas using FDTD. The technique described in this paper can be used to analyze other planar microwave circuits such as filters, hybrids, impedance transformers etc. FDTD analysis of microstrip antennas can be found in [3] [5]. But most of these papers use either Berengers PML or Mur Absorbing Boundary Conditions (ABC) for terminating the computational domain. In this paper, we use the UPML as the absorbing boundary to terminate the computational domain. UPML is superior in performance to either Berengers PML or Mur ABC. II. FINITE DIFFERENCE TIME DOMAIN (FDTD) METHOD The Finite Difference Time Domain (FDTD) method is a computational electromagnetic method that can be used to simulate any electromagnetic problem. In the FDTD method, Maxwells curl equations are converted to their corresponding scalar Partial Differential Equations (PDE). This is followed by the discretization of space and time domain. Central difference approximations are applied to the scalar Partial Differential Equations (PDE) with respect to the discretized time and space domain. This will result in discrete equations for each field component, which can be used to evaluate these field components. These equations are called update equations or time stepping equations. The update equation for a particular field component can be defined as the discrete equation that expresses the future value of the same field component using previous value of the same field component and the spatial derivatives of other field components at the present time. A. Three dimensional FDTD formulation One of the most important considerations in FDTD simulation is that of Absorbing Boundary Conditions

(ABC). In solving electromagnetic wave problems, it is assumed that geometries of interest are defined in an open region, i.e. only the geometries of interest are the scattering objects present. But computational resources are limited and hence the spatial domain needs to be truncated in such way that there are no wave reflections from the boundaries. Such boundary conditions are called ABCs. The Uniaxial Perfectly Matched Layer (UPML) is the most efficient of the ABCs available in literature [2]. The computational domain will be surrounded by the UPML, which will absorb waves of any polarization, angle of incidence and frequency. In FDTD UPML formulation, the entire spatial domain is assumed to be an anisotropic medium [2]. Maxwells curl equations in the anisotropic medium can be expressed as follows = =

(5) 0 0

Substituting (5) in (4) results in (6)

= 0 0

0 0

(6)

where , are the electric and magnetic field intensity vectors with components in phasor form and is the diagonal tensor given by (2). (1)

The PDEs in (6) are in frequency domain. They are converted to time domain, by using the transformation, . This is followed by substituting (3) in (6). The resultant time domain PDEs relating magnetic field intensity components and electric flux density components are as follows. 0 = 0 0 0 0 0 1 0 0 0 0

= 0 0

In (2), , and are the relative complex permittivities along x, y and z directions. They are given by (3).

0 0

(2)

0 0 + (7)

= + = +

= +

The first equation of (1) is a vector PDE and hence it can be expanded into three scalar PDEs as below.

The second equation of (1) can be treated similarly leading to (8). = 0 0 0 0 1 0 0 0 0

(3)

0 0

0 0 (8)

0 = 0

The electric flux density components are related to the electric field intensity components as shown in (5).

0 0

(4)

Thus (7) and (8) are time domain PDEs relating magnetic field intensity to electric flux density and electric field intensity to magnetic flux density respectively. It should be noted that in (7) and (8), the quantities are in time domain, and hence they are represented without bar. Using (5), we can derive time domain PDEs relating electric field intensity components to electric flux density components. The first equation of (5) is expanded as follows.

Multiplying both sides of (8) by and transforming to time domain leads to (10). A similar treatment of the remaining equations in (5) will result in (11) and (12).

= +

(9)

centers. The computation space is assumed to be filled with a number of Yee cells. Each Yee cell is identified by the spatial discretization indices (, , ). The indices (, , ) are mapped to the physical space as per the following relation. where , and are the dimensions of the Yee cell along the x, y and z axis respectively. Temporal discretization is done by dividing the time axis into segments of duration each. The temporal discretization index n corresponds to the real time, . In order to apply central difference approximations to the differential equations, the magnetic and electric field vector components are assigned to the discrertized space and time domain, in such a way that they are interleaved in both space and time. Spatial interleaving can be seen in figure. In order to have temporal interleaving, electric field / electric flux components are evaluated at . . , ( + 1).. and magnetic field / magnetic flux components are evaluated at . ( 0.5), ( + 0.5)...For convenience we will use a shorthand notation to represent the field components at a particular time. Two examples of this notation are given below. (16) 0.5 ; + 0.5) C. | ,+0.5 (, , + 0.5 ; ) ,
+0.5

( ) + ( ) +

Similarly time domain PDEs relating magnetic field intensities and flux densities can be derived from their constitutive relations. They are given by (13), (14) and (15).

= ( ) +

= +

= +

(10) (11)

(, , ) (, , )

(12) (13) (14)

( ) + ( ) +

B. Discretization of space and time domain Spatial discretization is done by dividing the computational space into cuboidal cells called Yee cells. The Yee cell is shown in figure 1.

= ( ) +

= +

= +

(15)

+0.5, ,+0.5 ( + 0.5, , +

(17)

Figure 1. Electric and magnetic field vector components in a Yee cell. From figure 1, it can be seen that electric field components are located at Yee cell edge centers and magnetic field components are located at face

Derivation of FDTD update equations The three dimensional FDTD is implemented using 12 update equations. They are for , , , , , , , , , , , . In this section, the derivation of update equations for and are shown. The rest of the equations can be derived in the same way. The figure 1 and the shorthand notation in (17), should be used to understand the derivation of these update equations. The starting point for the derivation of update equations are the continuous time PDEs given by (7), (8), (10) (12), (13) (15). The equations (7), (8) are used for the derivation of electric and magnetic flux density update equations respectively. (10) (12), (13) (15) are used for the derivation of electric and magnetic field intensity update equations. In order to derive update equation, we use the first row of (7). The first row of (7) is given by (18).

( ) +

(18)

From (18), it is obvious that future value of , and the spatial depends on the past value of derivatives of , at the current time. The update equation will be used to evaluate, the future value of , i.e. |+1 , . This will depend on the +0.5, previous value of , i.e. | +0.5, , and the spatial derivatives of , at the current time, i.e. n + 0.5 .The spatial derivatives of , are obtained around the position of , i.e. the same position of in figure 1. The spatial derivatives approximated in such a way using central difference approximation are as follows.

(20) and (21). The right hand side of (10) is substituted with (23) and (24).

In (18), the time derivative of is replaced with the central difference approximation of the derivative around current time n + 0.5. This is given by

+0.5 +0.5 |+0.5, +0.5, |+0.5, 0.5,

+0.5 |+0.5, ,+0.5 | +0.5 ,0.5 +0.5,

|+1 , = 1. |+1 , 2. | +0.5, +0.5, +0.5, , + 3. |+0.5,,

|+0.5 , = +0.5, 1 = 2 = 2 =

This will result in update equation as follows.

2 + (2 + ) 2 (2 + )

+1 |+0.5, , | +0.5, ,

+1 | +0.5, , + |+0.5, , 2

(23) (24)

(19)

The last term on the right hand side of (18), denotes the value of at the current time, i.e. |+0.5 , . +0.5, Since we evaluate the values of at . . , ( + 1).., |+0.5 , is substituted by the following +0.5, approximation. |+0.5 , = +0.5, Substituting (19), (20) and (21) in (18) will result in the update equation as shown below.
+1 |+0.5, , = 1. | +0.5, , +
+0.5 +0.5 |+0.5, ,+0.5 |+0.5, ,0.5 +0.5 +0.5 |+0.5, +0.5, |+0.5, 0.5,
+1 | +0.5, , + |+0.5, ,

+1 |+0.5, , | +0.5, ,

(20)

Similar to the derivation of update equation, update equations for , , , and can be derived. All the 12 update equations were carefully derived and are given in appendix I for reference. D. Computer implementation of FDTD FDTD is implemented in software by iterating the 12 update equations given in appendix I. In each iteration, the flux / field components in the entire computational space are updated. For instance, the updating of the components can be in this order, D, E, B, H. The computational space is divided into two regions, the inner problem space and the UPML region surrounding the problem space. The UPML is terminated by Perfect Electric Conductor (PEC) on all the six sides. Figure 2, shows the cross sectional view of the computational domain in a constant y plane. The problem space, UPML and PEC boundary can be seen. In figure 2, it should be noted that the UPML region is divided into different regions. These are the , , , UPML slabs and the corner regions. A cross sectional cut of the domain in a constant z plane will show , UPML regions. Corner UPML regions are the overlap of two or more UPML slabs. There will be 4 corner regions near the vertices of the computational domain, where x, y an z UPML slabs overlap (i.e. overlap of three UPML regions). In FDTD, different materials are modeled by varying the values of , , , , , . The computational space will be divided into Yee cells. Each Yee cell will have its corresponding constitutive parameters. The variations of and in

2 2 +

(25)

(21)

2.

1 = 2 2 =

2
+

Similar to the derivation of update equation, update equations for , , , and can be derived. In order to derive update equation, (10) is used. The left hand side of (10) is substituted with

2 2 +

(22)

different regions of the computational domain are given below. Problem space : Isotropic materials in problem space are modeled by allowing = = = 1, = = = , where is the conductivity of the material. Furthermore, in all the update equations should be multiplied by the of the corresponding Yee cell, i.e. the of the material. , UPML slabs : = = 0, = = 1. , varies. , UPML slabs : = = 0, = = 1. , varies. , UPML slabs : = = 0, = = 1. , varies. Corner UPML regions : Depending on which UPML slabs are overlapping, a combination of two or more of the UPML slab conditions should be used. For instance, when all the UPML slabs overlap in the corners near the computational space vertices, , , , , , will vary. For the corners in figure 2, only , , , varies.
Corner

where u is the normal distance between the point where the parameter is calculated and the UPML problem space boundary. is the spatial discretization interval, i.e. = = = . , are constants. It should be noted that , are calculated at the location of the field component. For instance, , for the update equations of , of the same Yee cell will be different. This is because the two field components are at different locations in the same Yee cell. Since the exterior of the UPML is a PEC layer, the tangential electric field components on this surface will be zero. From figure 1, it can be seen that , and on the PEC surface will be zero. This zero electric field condition acts as the stopping criterion for the FDTD update equation loops in software. E. Precision and stability of FDTD method The precision and algorithmic stability of the FDTD method is governed by the value of , , and . In this paper, we will be using cubical Yee cells, so = = = . In order to minimize dispersive effects, (28) should be satisfied [2].

,, () =
1

(27)

zmax UPML slab

Corner

xmin
UPML

Problem space

slab

xmax UPML slab

where is the minimum wavelength corresponding to the maximum frequency of simulation. The time discretization interval, is determined by the Courant condition [2], given by (29).

10

(28)

Corner

Corner

zmin UPML slab

z y x

PEC boundary

where n is the dimension of the FDTD formulation and is the velocity of light in vacuum. For 3D simulation, it is usual practice to use, = 2 . III. BROADBAND ANALYSIS USING FDTD Three dimensional FDTD with UPML ABC was implemented in C++. The main objective was to simulate the rectangular patch antenna shown in figure 3. The code is given in appendix II. The code can be used with update equations in appendix I, to gain a clear understanding. The length of the antenna, = 16.2 and width, = 12.45 . The height of the substrate h = 0.795 mm and substrate dielectric constant is 2.2. The simulation results can be used to obtain 11 () vs. frequency of this

(29)

,, () = 0
1

In order to obtain gradual attenuation of any wave incident on the UPML, the parameters and are geometrically graded along the normal axes of the UPML regions. These normal axis directions of each UPML slab is shown as arrows in figure 2. The geometric grading equations are given by

Figure 2. Cross sectional view of the computational space in a plane parallel to XZ plane.

(26)

antenna. Port 1 is the port represented by the terminal plane (TP) in figure 3. 12.45 mm

16.2 mm

TP SP

7.945 mm 22 mm

FDTD simulation details The spatial discretization interval used was = 0.265 . Using this interval all the relevant dimensions of the antenna in figure 3 can be represented by integer number of cells. By using (28), it can be seen that this value of will allow the use of high excitation frequencies without causing numerical dispersion. The maximum excitation frequency can easily be more than 50 GHz. The temporal discretization interval is calculated using the Courant condition listed in section II.E. The used for simulation is 0.441 ps. The UPML parameters , given in (26), (27) are found after performing several simulations. They are chosen so that reflection from the problem space UPML boundary is very low. The following values were found suitable: = 1.4, = 0.5. The number of UPML layers used was 19. Few results of the UPML experiments are given in Appendix III. The size of the problem space was 70 x 150 x 16 cells. Since there are 19 layers of UPML adjoining each of the six faces of the problem space, the total size of the computational space is 106 x 186 x 52 cells. From appendix I, it can be seen that there are a total of 30 update equation coefficients. In addition to this, there are 12 field / flux components. Therefore the code needs 42 three dimensional matrices, where each matrix is of size 106 x 186 x 52. A floating point number requires 8 bytes of memory for storage. Hence the total amount of RAM required for the A.

Figure 3. Microstrip line fed rectangular patch antenna (not to scale)

= 2.2

2.385 mm 0.795 mm

B. Estimation of 11 In this section, the procedure used for estimating 11 is outlined. Port 1 is associated with the terminal plane (TP) in figure 3. 11 can be defined as follows.

simulation was around 330 MB. The simulation environment was Win32 x86. The microstrip antenna is modeled by modifying the constitutive parameters corresponding to the Yee cells. The procedure was explained in section II . D. The conductor used as microstrip and ground plane is Copper ( = 5.87). It should be noted that ground plane fills the entire computational XY plane and the substrate fills the entire problem space XY plane. The ground plane is one cell thick, while the substrate is 3 cells thick, i.e 3 cells along the Z direction.

The estimation of 11 consists of two parts. The objective of the first part is just to sample the incident wave at the terminal plane. In this part, only the microstrip feed line is used. The feed line will extend at the other from = 0 at one end to = end. At both ends the strip will extend into the UPML regions and touch the PEC boundary. If the strip is not extended into UPML, the microstrip discontinuity will result in reflection. The incident wave simulation setup is shown in figure 4. In figure 4, it should be noted that the ground plane extends throughout the XY plane, while the feed line is only 9 cells wide on the XY plane. UPML

11 () =

() ()

() ()

(30)

Feed line

Substrate Ground plane

z SP TP Figure 4. Incident wave simulation setup y x

Since we are interested in the broadband response of the patch antenna, the excitation source used should be a broadband pulse. A very narrow Gaussian pulse will approximate a time domain impulse function. Therefore the response we obtain from FDTD will approximate impulse response. The frequency response can be obtained by taking the Fourier transform of the response. The excitation pulse that is used for the simulation is a Gaussian pulse of the functional form given below.

The Fourier transform of a time domain Gaussian function is Gaussian in functional form. The lower the value of , larger the frequency bandwidth of the pulse. The system is excited by adding (31) to all the components under the feed line strip in the source plane. Source plane is denoted by SP in figures 3 and 4. The SP is placed 4 cells away from the UPML problem space boundary. The values used for the simulation are: = 120, = 30. The idea is to generate a TEM wave under the strip which has a Gaussian time signature. For estimating 11 , the incident wave at the terminal plane (TP) is sampled, after excitation at the the source plane. TP is located at about 10 cells away from SP. The transverse field components, i.e. , were sampled. It was found that there is significant distortion in the field. This is because of the simple source condition that is used. In FDTD, to generate a plane wave, the Total field / Scattered field (TF / SF) formulation is used. By using TF / SF a clean Gaussian plane wave can be generated. However, sampled at the terminal plane showed considerably less distortion. The incident wave at TP is shown in figure 5.

() =

(31)

From figure 5, it can be seen that there is some distortion after the trailing edge of the Gaussian pulse. It can be noticed that once pulse has through the terminal plane, the field is nearly zero. This is because of the UPML, which will absorb the pulse. This shows the effectiveness of the UPML. In the second part, the simulation model is the structure shown in figure 3. From figure 3, it can be seen that the length of the feed line from the UPML problem space boundary to the edge of the patch antenna is 22 cm. The other end of the feed line is extended into the UPML till it touched PEC boundary at y = 0. This will make sure that the only reflection is from that of the patch antenna. The simulation result is shown in figure 6. By comparing figure 6 with 5, it can be seen that after 500 time steps, the incident wave simulation field is nearly zero. That means the pulse has passed the terminal plane. On the other hand, from figure 6, it can be seen that after 500 steps, there is a reflected wave due to microstrip discontinuities. The reflected wave will be completely absorbed by the UPML at the y = 0 end of the feed line. After about 3500 time steps, the terminal plane field settled down to zero. The reflected wave can be obtained by subtracting the incident wave from the total wave. This is depicted in figure 7. Since we know the incident and reflected waves at the terminal plane, 11 can be found out as follows.

11 () =

11 () can be calculated using (33). 11 () = 10 log(|11 |)

() ()

() { ()}

(32)

(33)

Source distortion

Figure 5. Incident wave at the terminal plane with only the microstrip feed line.

Figure 6. Total wave at the terminal plane with the microstrip patch antenna.

C. Microstrip antenna resonant frequencies Cavity model of microstrip antennas can be used to obtain approximate values of resonant frequencies. For a microstrip antenna with > > , the dominant mode is 010 and its resonant frequency is given by (34). where is the velocity of light in free space. This value can be evaluated as ( )010 = 6.25 GHz. This resonance frequency can be seen in the planar EM solution result of figure 8. However from figure 7, it can be noticed that 11 () is not low enough at this resonant frequency. Hence the operating resonance of this antenna is the next resonance. From figure 8, it can be seen that the operating resonance of the antenna is about 7.8 GHz. Both the FDTD and Ansoft planar EM simulation confirms this. The higher order mode after the dominant mode is 020 . The resonant frequency for this mode is given below. This value is evaluated as ( )020 = 8.1 GHz. This is slightly different from the estimated value of 7.8 GHz. This may be because the cavity model which is used to derive (35) is an approximate model. The Ansoft simulation and FDTD simulation as full wave models and gives much more accurate results. Microstrip antennas resemble dielectric filled rectangular cavities and hence they exhibit higher order resonances. These resonant frequencies can be seen in figure 8 at frequencies higher than 7.8 GHz.

( )010 =

(34)

Figure 7. Reflected wave at the terminal plane with the microstrip patch antenna. MATLAB Fast Fourier Transform (FFT) was used to evaluate (32). Zero padding was used to increase the frequency resolution. MATLAB code written for this purpose is given in appendix IV. The estimated 11 () is plotted against frequency in figure 8. In order to validate the result obtained by FDTD simulation, Ansoft planar EM simulator was used to simulate the patch antenna of figure 3. The 11 () obtained by this simulation is also shown in figure 7. It can be seen that there is a reasonable match between the results, especially the frequencies at which resonance occurs. A better result can be obtained if there was no source distortion that is seen in figure 5. In order to remove this distortion, more advanced incident source models should be used. In figure 7, only frequencies above 5 GHz are shown. This is because of the erroneous results obtained from FDTD simulation at frequencies below 5 GHz, which can be attributed to source distortion. Three dimensional plots of the patch antenna simulation are given in figure 9.

( )020 =

(35)

D. Estimation of antenna input impedance around resonance In this section, the input impedance of the patch antenna around resonance is estimated. In the last section, we estimated the 11 at the terminal plane. Input impedance at the terminal plane is given by (36).

= 1 11
1+
11

Figure 8. 11 () vs. frequency (GHz) of the rectangular patch antenna.

where = 50 is the characteristic impedance of the feed line. The input impedance around the resonant frequency of 7.8 GHz was estimated. The input resistance and reactance versus frequency are shown in figure 10 and 11. From figure 10, it can be seen that at the resonant frequency of 7.8 GHz, the input resistance is about 46 .

(36)

n = 60

n = 100

This is close to feed line characteristic impedance of 50 resulting in low value of 11 . From figure 11, it can be noticed that input reactance at the resonant frequency is zero. This is typical for resonance. Once we know the input impedance at the terminal plane, the input impedance of the antenna, i.e. the input impedance at the antenna feed line junction can be found out using the transmission line impedance transformation equation. The antenna input impedance, can be evaluated as follows. where is the characteristic impedance of the microstrip feed line.

Figure 9 . Microstrip patch antenna simulation : Three dimensional plots of in the computational space at different times n = 200 n = 300

(37)

Figure 10. Input resistance vs. frequency (GHz) for the line fed rectangular patch antenna

easily obtained by using TF / SF for plane wave generation. The work can be extended to the analysis of fractal patch antennas such as Minkowski fractal square patch antennas. Furthermore, radiation patterns of antennas can be evaluated by using Near Field Far Field (NF FF) transformation.

REFERENCES [1] C. A. Balanis, Antenna Theory: Analysis and Design, 3rd Edition, John Wiley & Sons 2005. [2] A. Taflove and S. Hagness, Computational Electrodynamics : The Finite Difference Time Domain method, 3rd Edition, Artech House, Inc., 2005. [3] C. Wu, K. Wu, Z. Bi and J. Litva, Accurate Characterization of Planar Printed Antennas using Finite Difference Time Domain method, IEEE Transactions on Antennas and Propagation, vol. 40, May 1992. [4] M. Zweki, R. A. Abd Alhameed, M. A. Mangoud, P. S. Excell, and J. A. Vaul, Broadband Analysis of Finite Microstrip Patch Antenna Structure using FDTD , 11th International Conference on Antennas and Propagation, UMIST, Manchester, UK, April 2001. [5] D. M. Sheen, S. M. Ali, M. D. Abouzahra and J. A. Kong, Application of the Three Dimensional Finite Difference Time Domain Method to the Analysis of Planar Microstrip Circuits, IEEE Transactions on Microwave Theory and Techniques, vol. 38, No. 7, July 1990.

( ) is the phase constant of the feed line and l is the distance of the antenna feed line junction from the terminal plane, i.e. l = 18.55 mm. For a microstrip line of width 2.385 mm on a substrate of thickness h = 0.795 mm and dielectric constant 2.2, the characteristic impedance = 50.5 . This was verified using Ansoft designer SV. In order to find , we need to know the phase velocity in the transmission feed line. To calculate the phase velocity, the effective dielectric constant of the feed line, is found out as follows.

Figure 11. Input reactance vs. frequency (GHz) for the line fed rectangular patch antenna.

where = 2.2, = 0.795 mm and = 2.385 mm. was found to be 1.86. The phase constant can be calculated as follows.

= =
2

+ 1 + 2

1 1 2 1+12/

(38)

Once for varying frequency is known, it can be substituted in (37) to estimate antenna input impedance. (40) IV. CONCLUSIONS In this paper, we described the three dimensional FDTD UPML and used it to perform broadband analysis of microstrip patch antenna. The results obtained showed reasonable match with the Ansoft designer simulated results. Better results can be

where is the phase velocity calculated using (40).

(39)

Appendix I : 3D FDTD UPML update equations

1. |+1 , = 1. | +0.5, +0.5, , + 2. update equation 1 = 1 =
2 + 2

update equation 1 =
2 + 2

2.

3.

update equation update equation

2 + 2 2 + 2

|+1 , +0.5, = 1. |, +0.5, + 2. |+1 , ,+0.5 = 1. |, ,+0.5 + 2.

2 =

2 +

| +0.5 +0.5, | +0.5 0.5, +0.5, +0.5,

2 = 2 =

2 + 2

| +0.5 +0.5 | +0.5 0.5 , +0.5, , +0.5,

| +0.5 , +0.5 | +0.5 ,0.5 +0.5, +0.5,

4.

+1 |+1 , = 1. | +0.5, +0.5, , + 2. |+0.5, , 3. |+0.5, ,

2 +

| +0.5 ,+0.5 | +0.5 ,+0.5 +0.5, 0.5,

| +0.5 +0.5, | +0.5 +0.5, +0.5, 0.5,

+0.5 | +0.5 , +0.5,+0.5 |, 0.5,+0.5

5.

1 =

+1 |+1 , +0.5, = 1. |, +0.5, + 2. |, +0.5, 3. |, +0.5,

6.

1 = 1 = 1 =

update equation update equation

2 + 2 2 + 2

2 =

(2 + ) 2 +

2 +

3 =

(2 + ) 2

+1 |+1 , ,+0.5 = 1. |, ,+0.5 + 2. |, ,+0.5 3. |, ,+0.5 +0.5 |+1.5 , +0.5,+0.5 = 1. |, +0.5,+0.5 2.

2 = 2 =

(2 + ) 2 +

3 = 3 =

(2 + ) 2

7.

update equation
2 + 2

2 + 2

8.

|+1.5 ,+0.5 = 1. |+0.5 ,+0.5 2. +0.5, +0.5, |+1.5 +0.5, = 1. |+0.5 +0.5, 2. +0.5, +0.5, 1 =
2 + 2

update equation update equation 1 =

2 + 2

2 =

2 +

+1 | +1 , +1,+0.5 |, ,+0.5

2 +

+1 | +1 , +0.5,+1 |, +0.5,

9.

2 = 2 =

2 + 2

| +1 ,+1 | +1 , +0.5, +0.5,

| +1 ,+0.5 | +1 +1, , ,+0.5

10. update equation

+0.5 +1.5 +0.5 |+1.5 , +0.5,+0.5 = 1. |, +0.5,+0.5 + 2. |, +0.5,+0.5 3. |, +0.5,+0.5

2 +

| +1 +0.5, | +1 +1, , +0.5,

| +1 +1, | +1 , +0.5, +0.5,

11. update equation 12. update equation 1 =

2 + 2

1 =

|+1.5 ,+0.5 = 1. |+0.5 ,+0.5 + 2. |+1.5 ,+0.5 3. |+0.5 ,+0.5 +0.5, +0.5, +0.5, +0.5, 1 = |+1.5 +0.5, = 1. |+0.5 +0.5, + 2. |+1.5 +0.5, 3. |+0.5 +0.5, +0.5, +0.5, +0.5, +0.5, 2 =
2 + 2 + 2 + 2

2 +

2 =

(2 + ) 2 +

2 +

3 =

(2 + ) 2

2 =

(2 + )

3 = 3 =

(2 + ) 2

2 +

Appendix II : C++ code for 3D FDTD - UPML simulation of microstrip patch antenna
/* Fdtd3D.cpp : 3D FDTD + UPML Author : Srikumar Sandeep E,D vectors on yee cell edge centres and H,B vectors on Yee cell face centres. Ex[i + 0.5][j][k], Ey[i][j + 0.5][k], Ez[i][j][k + 0.5] Dx[i + 0.5][j][k], Dy[i][j + 0.5][k], Dz[i][j][k + 0.5] Hx[i][j + 0.5][k + 0.5], Hy[i + 0.5][j][k + 0.5], Hz[i + 0.5][j + 0.5][k] Bx[i][j + 0.5][k + 0.5], By[i + 0.5][j][k + 0.5], Bz[i + 0.5][j + 0.5][k] 2) Constitutive parameter matrices epsr [XCELLS] [YCELLS] [ZCELLS] sigma[XCELLS] [YCELLS] [ZCELLS]

1)

*/ #include #include #include #include #define #define #define #define "iostream.h" "math.h" "stdlib.h" "fstream.h" PL PSX PSY PSZ 19 70 150 16 //Number //Number //Number //Number of of of of PML yee yee yee layers. cells in problem space along x-direction cells in problem space along y-direction cells in problem space along z-direction //Total number of yee cells along x-direction //Total number of yee cells along y-direction //Total number of yee cells along z-direction //3D matrix

#define XCELLS #define YCELLS #define ZCELLS

PSX + (2 * PL) PSY + (2 * PL) PSZ + (2 * PL)

typedef double*** MatPtr;

const double muo = 12.5664e-7; const double epso = 8.85e-12; const double CuSigma = 5.8e78; //Matrices MatPtr epsr, sigma; MatPtr Dx,Dy,Dz,Bx,By,Bz,Ex,Ey,Ez,Hx,Hy,Hz; MatPtr C1Dx,C2Dx,C1Dy,C2Dy,C1Dz,C2Dz; MatPtr C1Bx,C2Bx,C1By,C2By,C1Bz,C2Bz; MatPtr C1Ex,C2Ex,C3Ex,C1Ey,C2Ey,C3Ey,C1Ez,C2Ez,C3Ez; MatPtr C1Hx,C2Hx,C3Hx,C1Hy,C2Hy,C3Hy,C1Hz,C2Hz,C3Hz; //Function prototypes void CreateAllMatrices(); void DeleteAllMatrices(); void CreateMatrix(MatPtr&,int dimx,int dimy,int dimz); void DeleteMatrix(MatPtr, int dimx,int dimy,int dimz); void FillUpdateEqnConstantMatrices(double g, double sigmao,double dt); void main() { cout<<"--------------FDTD 3D simulator--------------------\n"; //T //i,j,k //n int T = - Number of time steps - x,y,z direction yee cell index - Temporal index 5000;

int i,j,k,n; //Text files to write the simulation data ofstream Ezfile,Hxfile; Ezfile.open("Ezfile.txt"); Hxfile.open("Hxfile.txt"); //dx, dy, dz ,dt Spatial and temporal discretization interval double dx,dy,dz,dt; //UPML parameters double g = 1.4; double sigmao = 0.5; // Source plane at j = SP // Terminal plane at j = TP // GP Ground plane location at k = PL + 1 int SP = 22; int TP = 32; int GP = PL + 1; //Initiliazation of discretization interval dx = 0.000265; dy = 0.000265; dz = 0.000265; dt = dz/(6e8); // Create all the 3D matrices and initialize the elements to zero // matrices include field / flux components and precomputed update equation // coefficients CreateAllMatrices(); //Fill the constitutive parameter matrices for(i = 0;i < XCELLS;i++) { for(j = 0;j < YCELLS;j++) { for(k = 0;k < ZCELLS;k++) { epsr [i][j][k] = 1.0; sigma[i][j][k] = 0.0; //Ground plane at k = 17 //Ground plane extends throughout the entire XY plane if(k == GP && i >= 0 && i < XCELLS && j >= 0 && j < YCELLS) { sigma[i][j][k] = Cusigma; } //3 layers of substrate corresponding to substrate //thickness = 0.795 mm. The substrate extends in the whole //XY plane of the problem space. But does not extend into //UPML if((k == GP + 1 || k == GP + 2 || k == GP + 3) && i >= PL && i < XCELLS - PL && j >= PL && j < YCELLS - PL) { epsr[i][j][k] = 2.2; }

//Feed line width is 9dx //Feed line is 8dx offset from the edge of the patch

//i.e it starts from i = 35 if(k == GP + 4) { if(i >= 35 && i <= 43) { //For incident wave simulation : j >=0 && j <= //YCELLS 1 //For patch antenna simulation : j >= 0 && j //<= 102 if(j >= 0 && j <= 102) { sigma[i][j][k] = CuSigma; } } } //Patch antenna if(k == GP + 4) { //The width of patch = 12.45 mm = 47dx if(i >= 27 && i <= 73) { //The length of patch = 16 mm = 60 dx if(j >= 102 && j <= 162) { sigma[i][j][k] = CuSigma; } } } } } } //Precomputer update equation coefficient matrices FillUpdateEqnConstantMatrices(g,sigmao,dt); //Temp double double double double variables to hold previous field values and field differential values. Dxo,Exo,Dyo,Eyo,Dzo,Ezo; dHx,dHy,dHz; Hxo,Hyo,Hzo,Bxo,Byo,Bzo; dEx,dEy,dEz;

//----------------------FDTD update loop starts here--------------------------for(n = 0;n < T;n++) { //to = 4T double temp = -1*(((n*dt - 120*dt)*(n*dt - 120*dt))/(30*30*dt*dt)); double source = exp(temp); double Ezinc = source; /*Dx,Ex update Dx,Ex[XCELLS][YCELLS + 1][ZCELLS + 1] Dx,Ex at j = 0 or j = YCELLS or k = 0 or k = ZCELLS are on the PEC surface. So they are zero and need not be calculated. */ for(i = 0;i < XCELLS;i++) { for(j = 1;j < YCELLS;j++) { for(k = 1;k < ZCELLS;k++) { Dxo = Dx[i][j][k]; Exo = Ex[i][j][k];

//Dx update equation dHz = (Hz[i][j][k] - Hz[i][j - 1][k]) / dy; dHy = (Hy[i][j][k] - Hy[i][j][k - 1]) / dz; Dx[i][j][k] = C1Dx[i][j][k] * Dxo + C2Dx[i][j][k] * (dHz - dHy); //Ex update equation Ex[i][j][k] = C2Ex[i][j][k] * Dx[i][j][k] - C3Ex[i][j][k] * Dxo + C1Ex[i][j][k] * Exo; } } } /*Dy,Ey update Dy,Ey[XCELLS + 1][YCELLS][ZCELLS + 1] Dy,Ey at i = 0 or i = XCELLS or k = 0 or k = ZCELLS are on the PEC surface. So they are zero and need not be calculated. */ for(i = 1;i < XCELLS;i++) { for(j = 0;j < YCELLS;j++) { for(k = 1;k < ZCELLS;k++) { Dyo = Dy[i][j][k]; Eyo = Ey[i][j][k]; //Dy update equation dHx = (Hx[i][j][k] - Hx[i][j][k - 1]) / dz; dHz = (Hz[i][j][k] - Hz[i - 1][j][k]) / dx; Dy[i][j][k] = C1Dy[i][j][k] * Dyo + C2Dy[i][j][k] * (dHx - dHz); //Ey update equation Ey[i][j][k] = C2Ey[i][j][k] * Dy[i][j][k] - C3Ey[i][j][k] * Dyo + C1Ey[i][j][k] * Eyo; } } } //Dz,Ez update for(i = 1;i < XCELLS;i++) { for(j = 1;j < YCELLS;j++) { for(k = 0;k < ZCELLS;k++) { Dzo = Dz[i][j][k]; Ezo = Ez[i][j][k]; //Dy update equation dHx = (Hx[i][j][k] - Hx[i][j - 1][k]) / dy; dHy = (Hy[i][j][k] - Hy[i - 1][j][k]) / dx; Dz[i][j][k] = C1Dz[i][j][k] * Dzo + C2Dz[i][j][k] * (dHy - dHx); //Ez update equation Ez[i][j][k] = C2Ez[i][j][k] * Dz[i][j][k]

- C3Ez[i][j][k] * Dzo + C1Ez[i][j][k] * Ezo;

//Excitation of the all Ez components under the feed //line microstrip at j = Source plane if(j == SP && i >= 35 && i <= 43 && k >= GP + 1 && k <= GP + 3) { Ez[i][j][k] += Ezinc; } } } } //Write simulation data to text file Hxfile<<Hx[39][TP][GP + 2]<<"\n"; Ezfile<<Ez[35][TP][GP + 2]<<"\n"; //Hx,Bx update for(i = 0;i < XCELLS;i++) { for(int j = 0;j < YCELLS;j++) { for(int k = 0;k < ZCELLS;k++) { Hxo = Hx[i][j][k]; Bxo = Bx[i][j][k]; dEz = (Ez[i][j + 1][k] - Ez[i][j][k]) / dy; dEy = (Ey[i][j][k + 1] - Ey[i][j][k]) / dz;

Bx[i][j][k] = C1Bx[i][j][k] * Bxo - C2Bx[i][j][k] * (dEz - dEy); Hx[i][j][k] = C1Hx[i][j][k] * Hxo + C2Hx[i][j][k] * Bx[i][j][k] - C3Hx[i][j][k] * Bxo; } } }

//Hy,By update for(i = 0;i < XCELLS;i++) { for(int j = 0;j < YCELLS;j++) { for(int k = 0;k < ZCELLS;k++) { Hyo = Hy[i][j][k]; Byo = By[i][j][k]; dEx = (Ex[i][j][k + 1] - Ex[i][j][k]) / dz; dEz = (Ez[i + 1][j][k] - Ez[i][j][k]) / dx; By[i][j][k] = C1By[i][j][k] * Byo - C2By[i][j][k] * (dEx - dEz); Hy[i][j][k] = C1Hy[i][j][k] * Hyo + C2Hy[i][j][k] * By[i][j][k] - C3Hy[i][j][k] * Byo; } }

} //Hz,Bz update for(i = 0;i < XCELLS;i++) { for(int j = 0;j < YCELLS;j++) { for(int k = 0;k < ZCELLS;k++) { Hzo = Hz[i][j][k]; Bzo = Bz[i][j][k]; dEy = (Ey[i + 1][j][k] - Ey[i][j][k]) / dx; dEx = (Ex[i][j + 1][k] - Ex[i][j][k]) / dy; Bz[i][j][k] = C1Bz[i][j][k] * Bzo - C2Bz[i][j][k] * (dEy - dEx); Hz[i][j][k] = C1Hz[i][j][k] * Hzo + C2Hz[i][j][k] * Bz[i][j][k] - C3Hz[i][j][k] * Bzo; } } } } DeleteAllMatrices(); Hxfile.close(); Ezfile.close(); } //-----------------------------------------------------------------------------------void FillUpdateEqnConstantMatrices(double g, double sigmao, double dt) { double Dx_ky,Dx_sigmay,Dy_kz,Dy_sigmaz,Dz_kx,Dz_sigmax; double Bx_ky,Bx_sigmay,By_kz,By_sigmaz,Bz_kx,Bz_sigmax; double Ex_kx,Ex_sigmax,Ex_kz,Ex_sigmaz,Ey_ky,Ey_sigmay, Ey_kx,Ey_sigmax,Ez_kz,Ez_sigmaz,Ez_ky,Ez_sigmay; double Hx_kx,Hx_sigmax,Hx_kz,Hx_sigmaz,Hy_ky,Hy_sigmay, Hy_kx,Hy_sigmax,Hz_kz,Hz_sigmaz,Hz_ky,Hz_sigmay;

//C1Dx,C2Dx,C1Ex,C2Ex,C3Ex for(int i = 0;i < XCELLS; i++) { for(int j = 1;j < YCELLS; j++) { for(int k = 1;k < ZCELLS; k++) { Dx_ky = 1; Dx_sigmay = sigma[i][j][k]; Ex_kx = 1; Ex_sigmax = sigma[i][j][k]; Ex_kz = 1; Ex_sigmaz = sigma[i][j][k]; //Dx_ky,Dx_sigmay if(j < PL) { Dx_ky = pow(g,PL - j); Dx_sigmay = sigmao * Dx_ky; } else if (j >= PL + PSY) {

Dx_ky = pow(g,j - PL - PSY); Dx_sigmay = sigmao * Dx_ky; } //Ex_kx, Ex_sigmax if(i < PL) { Ex_kx = pow(g,PL - i - 0.5); Ex_sigmax = sigmao * Ex_kx; } else if(i >= PL + PSX) { Ex_kx = pow(g,i - PL - PSX + 0.5); Ex_sigmax = sigmao * Ex_kx; } //Ex_kz,Ex_sigmaz if(k < PL) { Ex_kz = pow(g,PL - k); Ex_sigmaz = sigmao * Ex_kz; } else if(k >= PL + PSZ) { Ex_kz = pow(g,k - PL - PSZ); Ex_sigmaz = sigmao * Ex_kz; } //C1Dx,C2Dx C1Dx[i][j][k] = (2 * epso * epsr[i][j][k] * Dx_ky Dx_sigmay * dt)/(2 * epso * epsr[i][j][k] * Dx_ky + Dx_sigmay * dt); C2Dx[i][j][k] = (2 * epso * epsr[i][j][k] * dt) /(2 * epso * epsr[i][j][k] * Dx_ky + Dx_sigmay * dt); //C1Ex,C2Ex,C3Ex,C1Ey,C2Ey,C3Ey,C1Ez,C2Ez,C3Ez C1Ex[i][j][k] = (2 * epso * epsr[i][j][k] * Ex_kz Ex_sigmaz * dt) /(2* epso * epsr[i][j][k] * Ex_kz + Ex_sigmaz * dt); C2Ex[i][j][k] = (2 * epso * epsr[i][j][k] * Ex_kx + Ex_sigmax * dt)/((2 * epso * epsr[i][j][k] * Ex_kz + Ex_sigmaz * dt)* epso * epsr[i][j][k]); C3Ex[i][j][k] = (2 * epso * epsr[i][j][k] * Ex_kx Ex_sigmax * dt)/((2 * epso * epsr[i][j][k] * Ex_kz + Ex_sigmaz * dt)* epso * epsr[i][j][k]); } } } //C1Dy,C2Dy,C1Ey,C2Ey,C3Ey for(i = 1;i < XCELLS; i++) { for(int j = 0;j < YCELLS; j++) { for(int k = 1;k < ZCELLS; k++) { Dy_kz = Dy_sigmaz = Ey_ky = 1; sigma[i][j][k]; 1;

Ey_sigmay = Ey_kx = Ey_sigmax =

sigma[i][j][k]; 1; sigma[i][j][k];

//Dy_kz,Dy_sigmaz if(k < PL) { Dy_kz = Dy_sigmaz = } else if (k >= PL + { Dy_kz = Dy_sigmaz = }

pow(g,PL - k); sigmao * Dy_kz; PSZ) pow(g,k - PL - PSZ); sigmao * Dy_kz;

//Ey_ky, Ey_sigmay if(j < PL) { Ey_ky = pow(g,PL - j - 0.5); Ey_sigmay = sigmao * Ey_ky; } else if(j >= PL + PSY) { Ey_ky = pow(g,j - PL - PSY + 0.5); Ey_sigmay = sigmao * Ey_ky; }

//Ey_kx,Ey_sigmax if(i < PL) { Ey_kx = pow(g,PL - i); Ey_sigmax = sigmao * Ey_kx; } else if(i >= PL + PSX) { Ey_kx = pow(g,i - PL - PSX); Ey_sigmax = sigmao * Ey_kx; } //C1Dy,C2Dy C1Dy[i][j][k] = (2 * epso * epsr[i][j][k] * Dy_kz Dy_sigmaz * dt)/(2 * epso * epsr[i][j][k] * Dy_kz + Dy_sigmaz * dt); C2Dy[i][j][k] = (2 * epso * epsr[i][j][k] * dt) /(2 * epso * epsr[i][j][k] * Dy_kz + Dy_sigmaz * dt); //C1Ey,C2Ey,C3Ey C1Ey[i][j][k] = (2 * epso * epsr[i][j][k] Ey_sigmax * dt)/(2* epso * epsr[i][j][k] Ey_sigmax * dt);

* Ey_kx * Ey_kx +

C2Ey[i][j][k] = (2 * epso * epsr[i][j][k] * Ey_ky + Ey_sigmay * dt)/((2 * epso * epsr[i][j][k] * Ey_kx + Ey_sigmax * dt)* epso * epsr[i][j][k]); C3Ey[i][j][k] = (2 * epso * epsr[i][j][k] * Ey_ky Ey_sigmay * dt)/((2 * epso * epsr[i][j][k] * Ey_kx + Ey_sigmax * dt)* epso * epsr[i][j][k]); } }

} //C1Dz,C2Dz,C1Ez,C2Ez,C3Ez for(i = 1;i < XCELLS; i++) { for(int j = 1;j < YCELLS; j++) { for(int k = 0;k < ZCELLS; k++) { Dz_kx = 1; Dz_sigmax = sigma[i][j][k]; Ez_kz = 1; Ez_sigmaz = sigma[i][j][k]; Ez_ky = 1; Ez_sigmay = sigma[i][j][k]; //Dz_kx,Dz_sigmax if(i < PL) { Dz_kx = pow(g,PL - i); Dz_sigmax = sigmao * Dz_kx; } else if (i >= PL + PSX) { Dz_kx = pow(g,i - PL - PSX); Dz_sigmax = sigmao * Dz_kx; } //Ez_kz, Ez_sigmaz if(k < PL) { Ez_kz = pow(g,PL - k - 0.5); Ez_sigmaz = sigmao * Ez_kz; } else if(k >= PL + PSZ) { Ez_kz = pow(g,k - PL - PSZ + 0.5); Ez_sigmaz = sigmao * Ez_kz; }

//Ez_ky,Ez_sigmay if(j < PL) { Ez_ky = pow(g,PL - j); Ez_sigmay = sigmao * Ez_ky; } else if(j >= PL + PSY) { Ez_ky = pow(g,j - PL - PSY); Ez_sigmay = sigmao * Ez_ky; }

//C1Dz,C2Dz C1Dz[i][j][k] = (2 * epso * epsr[i][j][k] * Dz_kx Dz_sigmax * dt) /(2 * epso * epsr[i][j][k] * Dz_kx + Dz_sigmax * dt); C2Dz[i][j][k] = (2 * epso * epsr[i][j][k] * dt) /(2 * epso * epsr[i][j][k] * Dz_kx + Dz_sigmax * dt); //C1Ez,C2Ez,C3Ez

C1Ez[i][j][k] = (2 * epso * epsr[i][j][k] Ez_sigmay * dt)/(2* epso * epsr[i][j][k] Ez_sigmay * dt);

* Ez_ky * Ez_ky +

C2Ez[i][j][k] = (2 * epso * epsr[i][j][k] * Ez_kz + Ez_sigmaz * dt)/((2 * epso * epsr[i][j][k] * Ez_ky + Ez_sigmay * dt) * epso * epsr[i][j][k]); C3Ez[i][j][k] = (2 * epso * epsr[i][j][k] * Ez_kz Ez_sigmaz * dt)/((2 * epso * epsr[i][j][k] * Ez_ky + Ez_sigmay * dt)* epso * epsr[i][j][k]); } } }

//C1Bx,C2Bx,C1Hx,C2Hx,C3Hx for(i = 0;i < XCELLS;i++) { for(int j = 0;j < YCELLS;j++) { for(int k = 0;k < ZCELLS;k++) { Bx_ky = 1; Bx_sigmay = sigma[i][j][k]; Hx_kx = 1; Hx_sigmax = sigma[i][j][k]; Hx_kz = 1; Hx_sigmaz = sigma[i][j][k]; //Bx_ky,Bx_sigmay if(j < PL) { Bx_ky = pow(g,PL - j - 0.5); Bx_sigmay = sigmao * Bx_ky; } else if(j >= PL + PSY) { Bx_ky = pow(g,j - PL - PSY + 0.5); Bx_sigmay = sigmao * Bx_ky; } //} //Hx_kx,Hx_sigmax if(i < PL) { Hx_kx = pow(g,PL - i); Hx_sigmax = sigmao * Hx_kx; } else if(i >= PL + PSX) { Hx_kx = pow(g,i - PL - PSX); Hx_sigmax = sigmao * Hx_kx; } //Hx_kz,Hx_sigmaz if(k < PL) { Hx_kz = pow(g,PL - k - 0.5); Hx_sigmaz = sigmao * Hx_kz; } else if(k >= PL + PSZ) {

Hx_kz = pow(g,k - PL - PSZ + 0.5); Hx_sigmaz = sigmao * Hx_kz; }

//C1Bx,C2Bx,C1By,C2By,C1Bz,C2Bz C1Bx[i][j][k] = (2 * epso * epsr[i][j][k] * Bx_ky Bx_sigmay * dt)/(2 * epso * epsr[i][j][k] * Bx_ky + Bx_sigmay * dt); C2Bx[i][j][k] = (2 * epso * epsr[i][j][k] * dt) /(2 * epso * epsr[i][j][k] * Bx_ky + Bx_sigmay * dt); //C1Hx,C2Hx,C3Hx,C1Hy,C2Hy,C3Hy,C1Hz,C2Hz,C3Hz C2Hx[i][j][k] = (2 * epso * epsr[i][j][k] * Hx_kx + Hx_sigmax * dt)/((2 * epso * epsr[i][j][k] * Hx_kz + Hx_sigmaz * dt)* muo ); C3Hx[i][j][k] = (2 * epso * epsr[i][j][k] * Hx_kx Hx_sigmax * dt)/((2 * epso * epsr[i][j][k] * Hx_kz + Hx_sigmaz * dt)* muo ); C1Hx[i][j][k] = (2 * epso * epsr[i][j][k] Hx_sigmaz * dt) /(2* epso * epsr[i][j][k] Hx_sigmaz * dt); } } } * Hx_kz * Hx_kz +

//C1By,C2By,C1Hy,C2Hy,C3Hy for(i = 0;i < XCELLS;i++) { for(int j = 0;j < YCELLS;j++) { for(int k = 0;k < ZCELLS;k++) { By_kz = 1; By_sigmaz = sigma[i][j][k]; Hy_ky = 1; Hy_sigmay = sigma[i][j][k]; Hy_kx = 1; Hy_sigmax = sigma[i][j][k]; //By_kz,By_sigmaz if(k < PL) { By_kz = pow(g,PL - k - 0.5); By_sigmaz = sigmao * By_kz; } else if(k >= PL + PSZ) { By_kz = pow(g,k - PL - PSZ + 0.5); By_sigmaz = sigmao * By_kz; } //Hy_ky,Hy_sigmay if(j < PL) { Hy_ky = pow(g,PL - j); Hy_sigmay = sigmao * Hy_ky; } else if(j >= PL + PSY)

{ Hy_ky = pow(g,j - PL - PSY); Hy_sigmay = sigmao * Hy_ky; } //} //Hy_kx,Hy_sigmax if(i < PL) { Hy_kx = pow(g,PL - i - 0.5); Hy_sigmax = sigmao * Hy_kx; } else if(i >= PL + PSX) { Hy_kx = pow(g,i - PL - PSX + 0.5); Hy_sigmax = sigmao * Hy_kx; } //C1By,C2By C1By[i][j][k] = (2 * epso * epsr[i][j][k] * By_kz By_sigmaz * dt)/(2 * epso * epsr[i][j][k] * By_kz + By_sigmaz * dt); C2By[i][j][k] = (2 * epso * epsr[i][j][k] * dt) /(2 * epso * epsr[i][j][k] * By_kz + By_sigmaz * dt); //C1Hy,C2Hy,C3Hy C2Hy[i][j][k] = (2 * epso * epsr[i][j][k] * Hy_ky + Hy_sigmay * dt)/((2 * epso * epsr[i][j][k] * Hy_kx + Hy_sigmax * dt)* muo ); C3Hy[i][j][k] = (2 * epso * epsr[i][j][k] * Hy_ky Hy_sigmay * dt)/((2 * epso * epsr[i][j][k] * Hy_kx + Hy_sigmax * dt)* muo ); C1Hy[i][j][k] = (2 * epso * epsr[i][j][k] Hy_sigmax * dt)/(2* epso * epsr[i][j][k] Hy_sigmax * dt); } } } //C1Bz,C2Bz,C1Hz,C2Hz,C3Hz for(i = 0;i < XCELLS;i++) { for(int j = 0;j < YCELLS;j++) { for(int k = 0;k < ZCELLS;k++) { Bz_kx = 1; Bz_sigmax = sigma[i][j][k]; Hz_kz = 1; Hz_sigmaz = sigma[i][j][k]; Hz_ky = 1; Hz_sigmay = sigma[i][j][k]; //Bz_kx,Bz_sigmax if(i < PL) { Bz_kx = pow(g,PL - i - 0.5); Bz_sigmax = sigmao * Bz_kx; } else if(i >= PL + PSX) * Hy_kx * Hy_kx +

{ Bz_kx = pow(g,i - PL - PSX + 0.5); Bz_sigmax = sigmao * Bz_kx; } //Hz_kz,Hz_sigmaz if(k < PL) { Hz_kz = pow(g,PL - k); Hz_sigmaz = sigmao * Hz_kz; } else if(k >= PL + PSZ) { Hz_kz = pow(g,k - PL - PSZ); Hz_sigmaz = sigmao * Hz_kz; }

//Hz_ky,Hz_sigmay if(j < PL) { Hz_ky = pow(g,PL - j - 0.5); Hz_sigmay = sigmao * Hz_ky; } else if(j >= PL + PSY) { Hz_ky = pow(g,j - PL - PSY + 0.5); Hz_sigmay = sigmao * Hz_ky; } //} //C1Bz,C2Bz C1Bz[i][j][k] = (2 * epso * epsr[i][j][k] * Bz_kx Bz_sigmax * dt)/(2 * epso * epsr[i][j][k] * Bz_kx + Bz_sigmax * dt); C2Bz[i][j][k] = (2 * epso * epsr[i][j][k] * dt) /(2 * epso * epsr[i][j][k] * Bz_kx + Bz_sigmax * dt); //C1Hz,C2Hz,C3Hz C2Hz[i][j][k] = (2 * epso * epsr[i][j][k] * Hz_kz + Hz_sigmaz * dt)/((2 * epso * epsr[i][j][k] * Hz_ky + Hz_sigmay * dt)* muo ); C3Hz[i][j][k] = (2 * epso * epsr[i][j][k] * Hz_kz Hz_sigmaz * dt)/((2 * epso * epsr[i][j][k] * Hz_ky + Hz_sigmay * dt)* muo ); C1Hz[i][j][k] = (2 * epso * epsr[i][j][k] Hz_sigmay * dt)/(2* epso * epsr[i][j][k] Hz_sigmay * dt); } } } } * Hz_ky * Hz_ky +

void CreateAllMatrices() { //Create the parameter matrices CreateMatrix(epsr, XCELLS,YCELLS,ZCELLS); CreateMatrix(sigma,XCELLS,YCELLS,ZCELLS);

//Field matrices CreateMatrix(Dx,XCELLS,YCELLS + 1,ZCELLS + 1); CreateMatrix(Dy,XCELLS + 1,YCELLS,ZCELLS + 1); CreateMatrix(Dz,XCELLS + 1,YCELLS + 1,ZCELLS); CreateMatrix(Ex,XCELLS,YCELLS + 1,ZCELLS + 1); CreateMatrix(Ey,XCELLS + 1,YCELLS,ZCELLS + 1); CreateMatrix(Ez,XCELLS + 1,YCELLS + 1,ZCELLS); CreateMatrix(Bx,XCELLS,YCELLS,ZCELLS); CreateMatrix(By,XCELLS,YCELLS,ZCELLS); CreateMatrix(Bz,XCELLS,YCELLS,ZCELLS); CreateMatrix(Hx,XCELLS,YCELLS,ZCELLS); CreateMatrix(Hy,XCELLS,YCELLS,ZCELLS); CreateMatrix(Hz,XCELLS,YCELLS,ZCELLS);

//Create the update eqn constant matrices CreateMatrix(C1Dx,XCELLS,YCELLS + 1,ZCELLS + 1); CreateMatrix(C2Dx,XCELLS,YCELLS + 1,ZCELLS + 1); CreateMatrix(C1Dy,XCELLS + 1,YCELLS,ZCELLS + 1); CreateMatrix(C2Dy,XCELLS + 1,YCELLS,ZCELLS + 1); CreateMatrix(C1Dz,XCELLS + 1,YCELLS + 1,ZCELLS); CreateMatrix(C2Dz,XCELLS + 1,YCELLS + 1,ZCELLS); CreateMatrix(C1Bx,XCELLS,YCELLS,ZCELLS); CreateMatrix(C2Bx,XCELLS,YCELLS,ZCELLS); CreateMatrix(C1By,XCELLS,YCELLS,ZCELLS); CreateMatrix(C2By,XCELLS,YCELLS,ZCELLS); CreateMatrix(C1Bz,XCELLS,YCELLS,ZCELLS); CreateMatrix(C2Bz,XCELLS,YCELLS,ZCELLS); CreateMatrix(C1Ex,XCELLS,YCELLS + 1,ZCELLS + 1); CreateMatrix(C2Ex,XCELLS,YCELLS + 1,ZCELLS + 1); CreateMatrix(C3Ex,XCELLS,YCELLS + 1,ZCELLS + 1); CreateMatrix(C1Ey,XCELLS + 1,YCELLS,ZCELLS + 1); CreateMatrix(C2Ey,XCELLS + 1,YCELLS,ZCELLS + 1); CreateMatrix(C3Ey,XCELLS + 1,YCELLS,ZCELLS + 1); CreateMatrix(C1Ez,XCELLS + 1,YCELLS + 1,ZCELLS); CreateMatrix(C2Ez,XCELLS + 1,YCELLS + 1,ZCELLS); CreateMatrix(C3Ez,XCELLS + 1,YCELLS + 1,ZCELLS); CreateMatrix(C1Hx,XCELLS,YCELLS,ZCELLS); CreateMatrix(C2Hx,XCELLS,YCELLS,ZCELLS); CreateMatrix(C3Hx,XCELLS,YCELLS,ZCELLS); CreateMatrix(C1Hy,XCELLS,YCELLS,ZCELLS); CreateMatrix(C2Hy,XCELLS,YCELLS,ZCELLS); CreateMatrix(C3Hy,XCELLS,YCELLS,ZCELLS); CreateMatrix(C1Hz,XCELLS,YCELLS,ZCELLS); CreateMatrix(C2Hz,XCELLS,YCELLS,ZCELLS); CreateMatrix(C3Hz,XCELLS,YCELLS,ZCELLS); } void DeleteAllMatrices() { //Delete the constitute parameter matrices DeleteMatrix(epsr ,XCELLS,YCELLS,ZCELLS); DeleteMatrix(sigma,XCELLS,YCELLS,ZCELLS); //Delete the field component matrices DeleteMatrix(Dx,XCELLS,YCELLS + 1,ZCELLS + 1); DeleteMatrix(Dy,XCELLS + 1,YCELLS,ZCELLS + 1);

DeleteMatrix(Dz,XCELLS + 1,YCELLS + 1,ZCELLS); DeleteMatrix(Ex,XCELLS,YCELLS + 1,ZCELLS + 1); DeleteMatrix(Ey,XCELLS + 1,YCELLS,ZCELLS + 1); DeleteMatrix(Ez,XCELLS + 1,YCELLS + 1,ZCELLS); DeleteMatrix(Bx,XCELLS,YCELLS,ZCELLS); DeleteMatrix(By,XCELLS,YCELLS,ZCELLS); DeleteMatrix(Bz,XCELLS,YCELLS,ZCELLS); DeleteMatrix(Hx,XCELLS,YCELLS,ZCELLS); DeleteMatrix(Hy,XCELLS,YCELLS,ZCELLS); DeleteMatrix(Hz,XCELLS,YCELLS,ZCELLS); //Delete the update eqn constant matrices DeleteMatrix(C1Dx,XCELLS,YCELLS + 1,ZCELLS + 1); DeleteMatrix(C2Dx,XCELLS,YCELLS + 1,ZCELLS + 1); DeleteMatrix(C1Dy,XCELLS + 1,YCELLS,ZCELLS + 1); DeleteMatrix(C2Dy,XCELLS + 1,YCELLS,ZCELLS + 1); DeleteMatrix(C1Dz,XCELLS + 1,YCELLS + 1,ZCELLS); DeleteMatrix(C2Dz,XCELLS + 1,YCELLS + 1,ZCELLS); DeleteMatrix(C1Bx,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C2Bx,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C1By,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C2By,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C1Bz,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C2Bz,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C1Ex,XCELLS,YCELLS + 1,ZCELLS + 1); DeleteMatrix(C2Ex,XCELLS,YCELLS + 1,ZCELLS + 1); DeleteMatrix(C3Ex,XCELLS,YCELLS + 1,ZCELLS + 1); DeleteMatrix(C1Ey,XCELLS + 1,YCELLS,ZCELLS + 1); DeleteMatrix(C2Ey,XCELLS + 1,YCELLS,ZCELLS + 1); DeleteMatrix(C3Ey,XCELLS + 1,YCELLS,ZCELLS + 1); DeleteMatrix(C1Ez,XCELLS + 1,YCELLS + 1,ZCELLS); DeleteMatrix(C2Ez,XCELLS + 1,YCELLS + 1,ZCELLS); DeleteMatrix(C3Ez,XCELLS + 1,YCELLS + 1,ZCELLS);

DeleteMatrix(C1Hx,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C2Hx,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C3Hx,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C1Hy,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C2Hy,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C3Hy,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C1Hz,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C2Hz,XCELLS,YCELLS,ZCELLS); DeleteMatrix(C3Hz,XCELLS,YCELLS,ZCELLS); } //Create 3 dimensional matrix of dimx X dimy X dimz //All elements are set to 0.0 as default void CreateMatrix(MatPtr& mat,int dimx,int dimy,int dimz) { mat = new double**[dimx]; for(int i = 0; i < dimx; i++) { mat[i] = new double*[dimy]; for(int j = 0;j < dimy; j++) { mat[i][j] = new double[dimz]; for(int k = 0;k < dimz; k++)

{ mat[i][j][k] = 0.0; } } } } //Delete the 3 D matrix. Free the memory void DeleteMatrix(MatPtr mat,int dimx,int dimy,int dimz) { for(int i = 0;i < dimx;i++) { for(int j = 0;j<dimy;j++) { free(mat[i][j]); } free(mat[i]); } free(mat); }

Appendix III : UPML experiments Gaussian source at one end and Hx is sampled near the other end (near the UPML at the other end). The figures show the incident Gaussian and the reflection from the UPML problem space boundary for varying values of UPML parameters.
0.00025 0.0002 0.00015 0.0001 Series1 0.00005 0 0 -0.00005 -0.0001 200 400 600 800 1000 1200 1400 1600 1800

= . , = .

0.00025 0.0002 0.00015 0.0001 Series1 0.00005 0 0 -0.00005 -0.0001 200 400 600 800 1000 1200 1400 1600 1800

= = . , = .

0.00025 0.0002 0.00015 0.0001 Series1 0.00005 0 0 -0.00005 -0.0001 200 400 600 800 1000 1200 1400 1600

= = . , = .

Appendix IV : MATLAB code to evaluate from simulation results

%Total -> Simulation data from the microstrip patch simulation %Incident -> Simulation data from the incident wave simulation %Size of Total and Incident is 4000 dt = 0.265 / 6e8; Ref = Total - Incident; %Zero padding to increase frequency resolution Incident = [Incident zeros(1,46000)]; Ref = [Ref zeros(1,46000)]; reffft = fft(ref); incfft = fft(Incident); S11 = reffft ./ incfft; k = 0 : 450; plot(k/(50000*dt*1e9),10*log10(abs(S11(k + 1))) ); xlabel('Frequency (GHz)'); ylabel('S11 (dB)');