The programs to follow investigate waves on a stub matching network.

Place a MATLAB version of each routine (including the incwave and refwave functions) in the appropriate work folder before running. *********************************************************************** *
% StubMatchingWavesV1 % The input Line. % % T-Line matching networks are designed for steady % state operation. This program shows how the % matching condition is established by viewing the % initial waves launched into the network. % % There are three sections to the network: input, % thru, and stub. The input is assumed to be fed % by a matched Zo source. The load in the present % version is assumed all real to avoid the added % programming challenge of a complex load. It also % means we can represent the wave without needing a % phase shift term. % % The lines in a stub matching network tend to be % short; less than 0.5 guide wavelengths. To better % view the wave action, each section of line is % extended by 0.5 guide wavelengths. The end % results is not changed by the additional length. % % Wave velocity is angular velocity over phase % constant, of course. It is also equal to dk/dt, % where dk is the position increment to be plotted, % and dt is the time step for the plot. % % Things to do to improve the program: % a. allow for complex loads % % clc;clear; disp('starting program...') % % % % % % % % % % % % % % Variables c speed of light, m/s f frequency, Hz w angular frequency, rad/s dk differential position step, wavelengths dt differential time step, seconds jend counter for max possible length,any line (this is set to 1.0 wavelengths?) iend counter for max overall simulation time variable input line line length kI line length jIterm impedance ZoI through line kT jTterm ZoT stub line kS jSterm ZoS

% termination --ZTL ZSL % load end refl. GIL GTL GSL % input end refl. --GTI GSI % % transmission coefficients: % from input to thru and stub: TI % from thru to input and stub: TT % from stub to input and thru: TS % % Voltage amplitudes: Vxyz where % x indicates line (I, T, S) % y indicates path history % z indicates incident(i) or reflected(r) % example: VTsi is an incident wave on the % thru line that came from the stub; % example: VStsi is an indicent wave that % started on the stub, then the thru, and then % back to the stub. % % Time counters: ixyz % As above. % % Wave arrays: Vpxyz, Vmxyz % incident, or plus(p), and reflected, or (m) % the xyz is as above %Initial values c=3e8;f=1e9;w=2*pi*f; dk=.005; jend=.50/dk; iend=jend*12; %Line details kI=.50;jIterm=kI/dk; kT=.670;jTterm=kT/dk; kS=.605;jSterm=kS/dk; %note: must be an integer ZoI=50; ZoT=50; ZoS=50; ZTL=170; ZSL=0; %shorted shunt stub %reflection & transmission coefficients Ztemp=1/((1/ZoT)+(1/ZoS)); GIL=(Ztemp-ZoI)/(Ztemp+ZoI); TI=1+GIL; GTL=(ZTL-ZoT)/(ZTL+ZoT); Ztemp=1/((1/ZoI)+(1/ZoS)); GTI=(Ztemp-ZoT)/(Ztemp+ZoT); TT=1+GTI; GSL=(ZSL-ZoS)/(ZSL+ZoS); Ztemp=1/((1/ZoI)+(1/ZoT)); GSI=(Ztemp-ZoS)/(Ztemp+ZoS); TS=1+GSI; %Calculate voltage amplitudes & time counters disp('Calc voltage amplitudes & time counters.')

%order 1 VIi=2; %wave amplitude launched on input line iIi=1; %order 2 VSi=TI*VIi; iSi=jIterm+1; VIr=GIL*VIi; iIr=jIterm+1; VTi=TI*VIi; iTi=jIterm+1; VSr=GSL*VSi; iSr=iSi+jSterm; VTr=GTL*VTi; iTr=iTi+jTterm; %order 3 VSsi=GSI*VSr; iSsi=iSr+jSterm; VIsr=TS*VSr; iIsr=iSr+jSterm; VTsi=TS*VSr; iTsi=iSr+jSterm; VSti=TT*VTr; iSti=iTr+jTterm; VItr=TT*VTr; iItr=iTr+jTterm; VTti=GTI*VTr; iTti=iTr+jTterm; VSsr=GSL*VSsi; iSsr=iSsi+jSterm; VTsr=GTL*VTsi; iTsr=iTsi+jTterm; VStr=GSL*VSti; iStr=iSti+jSterm; VTtr=GTL*VTti; iTtr=iTti+jTterm; % order 4 VSssi=GSI*VSsr; iSssi=iSsr+jSterm; VIssr=TS*VSsr; iIssr=iSsr+jSterm; VTssi=TS*VSsr; iTssi=iSsr+jSterm; VStsi=TT*VTsr; iStsi=iTsr+jTterm; VItsr=TT*VTsr; iItsr=iTsr+jTterm; VTtsi=GTI*VTsr; iTtsi=iTsr+jTterm; VSsti=GSI*VStr;

iSsti=iStr+jSterm; VIstr=TS*VStr; iIstr=iStr+jSterm; VTsti=TS*VStr; iTsti=iStr+jSterm; VStti=TT*VTtr; iStti=iTtr+jTterm; VIttr=TT*VTtr; iIttr=iTtr+jTterm; VTtti=GTI*VTtr; iTtti=iTtr+jTterm; VSssr=GSL*VSssi; iSssr=iSssi+jSterm; VTssr=GTL*VTssi; iTssr=iTssi+jTterm; VStsr=GSL*VStsi; iStsr=iStsi+jSterm; VTtsr=GTL*VTtsi; iTtsr=iTtsi+jTterm; VSstr=GSL*VSsti; iSstr=iSsti+jSterm; VTstr=GTL*VTsti; iTstr=iTsti+jTterm; VSttr=GSL*VStti; iSttr=iStti+jSterm; VTttr=GTL*VTtti; iTttr=iTtti+jTterm; % order 5 VSsssi=GSI*VSssr; iSsssi=iSssr+jSterm; VIsssr=TS*VSssr; iIsssr=iSssr+jSterm; VTsssi=TS*VSssr; iTsssi=iSssr+jSterm; VStssi=TT*VTssr; iStssi=iTssr+jTterm; VItssr=TT*VTssr; iItssr=iTssr+jTterm; VTtssi=GTI*VTssr; iTtssi=iTssr+jTterm; VSstsi=GSI*VStsr; iSstsi=iStsr+jSterm; VIstsr=TS*VStsr; iIstsr=iStsr+jSterm; VTstsi=TS*VStsr; iTstsi=iStsr+jSterm; VSttsi=TT*VTtsr; iSttsi=iTtsr+jTterm;

VIttsr=TT*VTtsr; iIttsr=iTtsr+jTterm; VTttsi=GTI*VTtsr; iTttsi=iTtsr+jTterm; VSssti=GSI*VSstr; iSssti=iSstr+jSterm; VIsstr=TS*VSstr; iIsstr=iSstr+jSterm; VTssti=TS*VSstr; iTssti=iSstr+jSterm; VStsti=TT*VTstr; iStsti=iTstr+jTterm; VItstr=TT*VTstr; iItstr=iTstr+jTterm; VTtsti=GTI*VTstr; iTtsti=iTstr+jTterm; VSstti=GSI*VSttr; iSstti=iSttr+jSterm; VIsttr=TS*VSttr; iIsttr=iSttr+jSterm; VTstti=TS*VSttr; iTstti=iSttr+jSterm; VSttti=TT*VTttr; iSttti=iTttr+jTterm; VItttr=TT*VTttr; iItttr=iTttr+jTterm; VTttti=GTI*VTttr; iTttti=iTttr+jTterm; VSsssr=GSL*VSsssi; iSsssr=iSsssi+jSterm; VTsssr=GTL*VTsssi; iTsssr=iTsssi+jTterm; VStssr=GSL*VStssi; iStssr=iStssi+jSterm; VTtssr=GTL*VTtssi; iTtssr=iTtssi+jTterm; VSstsr=GSL*VSstsi; iSstsr=iSstsi+jSterm; VTstsr=GTL*VTstsi; iTstsr=iTstsi+jTterm; VSttsr=GSL*VSttsi; iSttsr=iSttsi+jSterm; VTttsr=GTL*VTttsi; iTttsr=iTttsi+jTterm; VSsstr=GSL*VSssti; iSsstr=iSssti+jSterm; VTsstr=GTL*VTssti; iTsstr=iTssti+jTterm;

VStstr=GSL*VStsti; iStstr=iStsti+jSterm; VTtstr=GTL*VTtsti; iTtstr=iTtsti+jTterm; VSsttr=GSL*VSstti; iSsttr=iSstti+jSterm; VTsttr=GTL*VTstti; iTsttr=iTstti+jTterm; VStttr=GSL*VSttti; iStttr=iSttti+jSterm; VTtttr=GTL*VTttti; iTtttr=iTttti+jTterm; %order 6: VI only VIssssr=TS*VSsssr; iIssssr=iSsssr+jSterm; VItsssr=TT*VTsssr; iItsssr=iTsssr+jTterm; VIstssr=TS*VStssr; iIstssr=iStssr+jSterm; VIttssr=TT*VTtssr; iIttssr=iTtssr+jTterm; VIsstsr=TS*VSstsr; iIsstsr=iSstsr+jSterm; VItstsr=TT*VTstsr; iItstsr=iTstsr+jTterm; VIsttsr=TS*VSttsr; iIsttsr=iSttsr+jSterm; VItttsr=TT*VTttsr; iItttsr=iTttsr+jTterm; VIssstr=TS*VSsstr; iIssstr=iSsstr+jSterm; VItsstr=TT*VTsstr; iItsstr=iTsstr+jTterm; VIststr=TS*VStstr; iIststr=iStstr+jSterm; VIttstr=TT*VTtstr; iIttstr=iTtstr+jTterm; VIssttr=TS*VSsttr; iIssttr=iSsttr+jSterm; VItsttr=TT*VTsttr; iItsttr=iTsttr+jTterm; VIstttr=TS*VStttr; iIstttr=iStttr+jSterm; VIttttr=TT*VTtttr; iIttttr=iTtttr+jTterm;

disp('Initially fill arrays with zeros.') %input line for i=1:iend for j=1:jend Vpi(i,j)=0; Vmi(i,j)=0; Vmis(i,j)=0; Vmit(i,j)=0; Vmiss(i,j)=0; Vmist(i,j)=0; Vmits(i,j)=0; Vmitt(i,j)=0; Vmisss(i,j)=0; Vmitss(i,j)=0; Vmists(i,j)=0; Vmitts(i,j)=0; Vmisst(i,j)=0; Vmitst(i,j)=0; Vmistt(i,j)=0; Vmittt(i,j)=0; Vmissss(i,j)=0; Vmitsss(i,j)=0; Vmistss(i,j)=0; Vmittss(i,j)=0; Vmissts(i,j)=0; Vmitsts(i,j)=0; Vmistts(i,j)=0; Vmittts(i,j)=0; Vmissst(i,j)=0; Vmitsst(i,j)=0; Vmistst(i,j)=0; Vmittst(i,j)=0; Vmisstt(i,j)=0; Vmitstt(i,j)=0; Vmisttt(i,j)=0; Vmitttt(i,j)=0; A(i,j)=0; B(i,j)=0; C(i,j)=0; D(i,j)=0; E(i,j)=0; VItot(i,j)=0; end end disp('Fill arrays...') Vpi=incwave(VIi,0,f,iIi,iend,jIterm,dk); Vmi=refwave(VIr,0,f,iIr,iend,jIterm,dk); Vmis=refwave(VIsr,0,f,iIsr,iend,jIterm,dk); Vmit=refwave(VItr,0,f,iItr,iend,jIterm,dk); Vmiss=refwave(VIssr,0,f,iIssr,iend,jIterm,dk); Vmits=refwave(VItsr,0,f,iItsr,iend,jIterm,dk); Vmist=refwave(VIstr,0,f,iIstr,iend,jIterm,dk); Vmitt=refwave(VIttr,0,f,iIttr,iend,jIterm,dk); Vmisss=refwave(VIsssr,0,f,iIsssr,iend,jIterm,dk); Vmitss=refwave(VItssr,0,f,iItssr,iend,jIterm,dk); Vmists=refwave(VIstsr,0,f,iIstsr,iend,jIterm,dk);

Vmitts=refwave(VIttsr,0,f,iIttsr,iend,jIterm,dk); Vmisst=refwave(VIsstr,0,f,iIsstr,iend,jIterm,dk); Vmitst=refwave(VItstr,0,f,iItstr,iend,jIterm,dk); Vmistt=refwave(VIsttr,0,f,iIsttr,iend,jIterm,dk); Vmittt=refwave(VItttr,0,f,iItttr,iend,jIterm,dk); Vmissss=refwave(VIssssr,0,f,iIssssr,iend,jIterm,dk); Vmitsss=refwave(VItsssr,0,f,iItsssr,iend,jIterm,dk); Vmistss=refwave(VIstssr,0,f,iIstssr,iend,jIterm,dk); Vmittss=refwave(VIttssr,0,f,iIttssr,iend,jIterm,dk); Vmissts=refwave(VIsstsr,0,f,iIsstsr,iend,jIterm,dk); Vmitsts=refwave(VItstsr,0,f,iItstsr,iend,jIterm,dk); Vmistts=refwave(VIsttsr,0,f,iIsttsr,iend,jIterm,dk); Vmittts=refwave(VItttsr,0,f,iItttsr,iend,jIterm,dk); Vmissst=refwave(VIssstr,0,f,iIssstr,iend,jIterm,dk); Vmitsst=refwave(VItsstr,0,f,iItsstr,iend,jIterm,dk); Vmistst=refwave(VIststr,0,f,iIststr,iend,jIterm,dk); Vmittst=refwave(VIttstr,0,f,iIttstr,iend,jIterm,dk); Vmisstt=refwave(VIssttr,0,f,iIssttr,iend,jIterm,dk); Vmitstt=refwave(VItsttr,0,f,iItsttr,iend,jIterm,dk); Vmisttt=refwave(VIstttr,0,f,iIstttr,iend,jIterm,dk); Vmitttt=refwave(VIttttr,0,f,iIttttr,iend,jIterm,dk); A=Vmi+Vmis+Vmit+Vmiss+Vmits+Vmist+Vmitt; B=A+Vmisss+Vmitss+Vmists+Vmitts+Vmisst; C=B+Vmitst+Vmistt+Vmittt+Vmissss+Vmitsss; D=C+Vmistss+Vmittss+Vmissts+Vmitsts+Vmistts; E=D+Vmittts+Vmissst+Vmitsst+Vmistst+Vmittst; VItot=E+Vmisstt+Vmitstt+Vmisttt+Vmitttt; disp('Done with VItot') disp('clear arrays other than VItot') clear Vmi;clear Vmis;clear Vmit;clear Vmiss;clear Vmits; clear Vmist;clear Vmitt;clear A; clear B;clear D;clear D; clear E;clear Vmisss;clear Vmitss;clear Vmists;clear Vmitts; clear Vmisst;clear Vmitst;clear Vmistt;clear Vmittt; clear Vmissss;clear Vmitsss;clear Vmistss;clear Vmittss; clear Vmissts;clear Vmitsts;clear Vmistts; clear Vmittts;clear Vmissst;clear Vmitsst; clear Vmisttt;clear Vmitttt;

*********************************************************************** *
% % % % % % % % % % % StubMatchingWavesV1 The Through Line. T-Line matching networks are designed for steady state operation. This program shows how the matching condition is established by viewing the initial waves launched into the network. There are three sections to the network: input, thru, and stub. The input is assumed to be fed by a matched Zo source. The load in the present

% version is assumed all real to avoid the added % programming challenge of a complex load. It also % means we can represent the wave without needing a % phase shift term. % % The lines in a stub matching network tend to be % short; less than 0.5 guide wavelengths. To better % view the wave action, each section of line is % extended by 0.5 guide wavelengths. The end % results is not changed by the additional length. % % Wave velocity is angular velocity over phase % constant, of course. It is also equal to dk/dt, % where dk is the position increment to be plotted, % and dt is the time step for the plot. % % Things to do to improve the program: % a. allow for complex loads % % clc;clear; disp('starting program...') % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % Variables c speed of light, m/s f frequency, Hz w angular frequency, rad/s dk differential position step, wavelengths dt differential time step, seconds jend counter for max possible length,any line (this is set to 1.0 wavelengths) iend counter for max overall simulation time variable input line line length kI line length jIterm impedance ZoI termination --load end refl. GIL input end refl. --through line kT jTterm ZoT ZTL GTL GTI stub line kS jSterm ZoS ZSL GSL GSI

transmission coefficients: from input to thru and stub: TI from thru to input and stub: TT from stub to input and thru: TS Voltage amplitudes: Vxyz where x indicates line (I, T, S) y indicates path history z indicates incident(i) or reflected(r) example: VTsi is an incident wave on the thru line that came from the stub; example: VStsi is an indicent wave that started on the stub, then the thru, and then back to the stub. Time counters: ixyz

% As above. % % Wave arrays: Vpxyz, Vmxyz % incident, or plus(p), and reflected, or (m) % the xyz is as above %Initial values c=3e8;f=1e9;w=2*pi*f; dk=.005; jend=0.7/dk; iend=1000; %Line details kI=.50;jIterm=kI/dk; kT=.670;jTterm=kT/dk; kS=.605;jSterm=kS/dk; %note: must be an integer ZoI=50; ZoT=50; ZoS=50; ZTL=170; ZSL=0; %shorted shunt stub %reflection & transmission coefficients Ztemp=1/((1/ZoT)+(1/ZoS)); GIL=(Ztemp-ZoI)/(Ztemp+ZoI); TI=1+GIL; GTL=(ZTL-ZoT)/(ZTL+ZoT); Ztemp=1/((1/ZoI)+(1/ZoS)); GTI=(Ztemp-ZoT)/(Ztemp+ZoT); TT=1+GTI; GSL=(ZSL-ZoS)/(ZSL+ZoS); Ztemp=1/((1/ZoI)+(1/ZoT)); GSI=(Ztemp-ZoS)/(Ztemp+ZoS); TS=1+GSI; %Calculate voltage amplitudes & time counters disp('Calc voltage amplitudes & time counters.') %order 1 VIi=2; %wave amplitude launched on input line iIi=1; %order 2 VSi=TI*VIi; iSi=jIterm+1; VIr=GIL*VIi; iIr=jIterm+1; VTi=TI*VIi; iTi=jIterm+1; VSr=GSL*VSi; iSr=iSi+jSterm; VTr=GTL*VTi; iTr=iTi+jTterm; %order 3 VSsi=GSI*VSr; iSsi=iSr+jSterm;

VIsr=TS*VSr; iIsr=iSr+jSterm; VTsi=TS*VSr; iTsi=iSr+jSterm; VSti=TT*VTr; iSti=iTr+jTterm; VItr=TT*VTr; iItr=iTr+jTterm; VTti=GTI*VTr; iTti=iTr+jTterm; VSsr=GSL*VSsi; iSsr=iSsi+jSterm; VTsr=GTL*VTsi; iTsr=iTsi+jTterm; VStr=GSL*VSti; iStr=iSti+jSterm; VTtr=GTL*VTti; iTtr=iTti+jTterm; % order 4 VSssi=GSI*VSsr; iSssi=iSsr+jSterm; VIssr=TS*VSsr; iIssr=iSsr+jSterm; VTssi=TS*VSsr; iTssi=iSsr+jSterm; VStsi=TT*VTsr; iStsi=iTsr+jTterm; VItsr=TT*VTsr; iItsr=iTsr+jTterm; VTtsi=GTI*VTsr; iTtsi=iTsr+jTterm; VSsti=GSI*VStr; iSsti=iStr+jSterm; VIstr=TS*VStr; iIstr=iStr+jSterm; VTsti=TS*VStr; iTsti=iStr+jSterm; VStti=TT*VTtr; iStti=iTtr+jTterm; VIttr=TT*VTtr; iIttr=iTtr+jTterm; VTtti=GTI*VTtr; iTtti=iTtr+jTterm; VSssr=GSL*VSssi; iSssr=iSssi+jSterm; VTssr=GTL*VTssi; iTssr=iTssi+jTterm; VStsr=GSL*VStsi; iStsr=iStsi+jSterm;

VTtsr=GTL*VTtsi; iTtsr=iTtsi+jTterm; VSstr=GSL*VSsti; iSstr=iSsti+jSterm; VTstr=GTL*VTsti; iTstr=iTsti+jTterm; VSttr=GSL*VStti; iSttr=iStti+jSterm; VTttr=GTL*VTtti; iTttr=iTtti+jTterm; % order 5 VSsssi=GSI*VSssr; iSsssi=iSssr+jSterm; VIsssr=TS*VSssr; iIsssr=iSssr+jSterm; VTsssi=TS*VSssr; iTsssi=iSssr+jSterm; VStssi=TT*VTssr; iStssi=iTssr+jTterm; VItssr=TT*VTssr; iItssr=iTssr+jTterm; VTtssi=GTI*VTssr; iTtssi=iTssr+jTterm; VSstsi=GSI*VStsr; iSstsi=iStsr+jSterm; VIstsr=TS*VStsr; iIstsr=iStsr+jSterm; VTstsi=TS*VStsr; iTstsi=iStsr+jSterm; VSttsi=TT*VTtsr; iSttsi=iTtsr+jTterm; VIttsr=TT*VTtsr; iIttsr=iTtsr+jTterm; VTttsi=GTI*VTtsr; iTttsi=iTtsr+jTterm; VSssti=GSI*VSstr; iSssti=iSstr+jSterm; VIsstr=TS*VSstr; iIsstr=iSstr+jSterm; VTssti=TS*VSstr; iTssti=iSstr+jSterm; VStsti=TT*VTstr; iStsti=iTstr+jTterm; VItstr=TT*VTstr; iItstr=iTstr+jTterm; VTtsti=GTI*VTstr; iTtsti=iTstr+jTterm; VSstti=GSI*VSttr;

iSstti=iSttr+jSterm; VIsttr=TS*VSttr; iIsttr=iSttr+jSterm; VTstti=TS*VSttr; iTstti=iSttr+jSterm; VSttti=TT*VTttr; iSttti=iTttr+jTterm; VItttr=TT*VTttr; iItttr=iTttr+jTterm; VTttti=GTI*VTttr; iTttti=iTttr+jTterm; VSsssr=GSL*VSsssi; iSsssr=iSsssi+jSterm; VTsssr=GTL*VTsssi; iTsssr=iTsssi+jTterm; VStssr=GSL*VStssi; iStssr=iStssi+jSterm; VTtssr=GTL*VTtssi; iTtssr=iTtssi+jTterm; VSstsr=GSL*VSstsi; iSstsr=iSstsi+jSterm; VTstsr=GTL*VTstsi; iTstsr=iTstsi+jTterm; VSttsr=GSL*VSttsi; iSttsr=iSttsi+jSterm; VTttsr=GTL*VTttsi; iTttsr=iTttsi+jTterm; VSsstr=GSL*VSssti; iSsstr=iSssti+jSterm; VTsstr=GTL*VTssti; iTsstr=iTssti+jTterm; VStstr=GSL*VStsti; iStstr=iStsti+jSterm; VTtstr=GTL*VTtsti; iTtstr=iTtsti+jTterm; VSsttr=GSL*VSstti; iSsttr=iSstti+jSterm; VTsttr=GTL*VTstti; iTsttr=iTstti+jTterm; VStttr=GSL*VSttti; iStttr=iSttti+jSterm; VTtttr=GTL*VTttti; iTtttr=iTttti+jTterm; disp('Initially fill arrays with zeros.') %input line for i=1:iend for j=1:jend

pVTi(i,j)=0; mVTr(i,j)=0; pVTsi(i,j)=0; mVTsr(i,j)=0; pVTti(i,j)=0; mVTtr(i,j)=0; pVTssi(i,j)=0; mVTssr(i,j)=0; pVTtsi(i,j)=0; mVTtsr(i,j)=0; pVTsti(i,j)=0; mVTstr(i,j)=0; pVTtti(i,j)=0; mVTttr(i,j)=0; A(i,j)=0; B(i,j)=0; C(i,j)=0; D(i,j)=0; E(i,j)=0; VTtot(i,j)=0; end end

disp('Fill arrays...') pVTi=incwave(VTi,0,f,iTi,iend,jTterm,dk); mVTr=refwave(VTr,0,f,iTr,iend,jTterm,dk); pVTsi=incwave(VTsi,0,f,iTsi,iend,jTterm,dk); mVTsr=refwave(VTsr,0,f,iTsr,iend,jTterm,dk); pVTti=incwave(VTti,0,f,iTti,iend,jTterm,dk); mVTtr=refwave(VTtr,0,f,iTtr,iend,jTterm,dk); pVTssi=incwave(VTssi,0,f,iTssi,iend,jTterm,dk); mVTssr=refwave(VTssr,0,f,iTssr,iend,jTterm,dk); pVTtsi=incwave(VTtsi,0,f,iTtsi,iend,jTterm,dk); mVTtsr=refwave(VTtsr,0,f,iTtsr,iend,jTterm,dk); pVTsti=incwave(VTsti,0,f,iTsti,iend,jTterm,dk); mVTstr=refwave(VTstr,0,f,iTstr,iend,jTterm,dk); pVTtti=incwave(VTtti,0,f,iTtti,iend,jTterm,dk); mVTttr=refwave(VTttr,0,f,iTttr,iend,jTterm,dk); A=pVTi+mVTr+pVTsi+mVTsr+pVTti+mVTtr; B=A+pVTssi+mVTssr+pVTtsi+mVTtsr+pVTsti+mVTstr; VTtot=B+pVTtti+mVTttr; disp('VTtot constructed!') disp('clear unused arrays') clear A;clear pVTi;clear mVTr;clear pVTsi;clear mVTsr; clear pVTti;clear mVTtr;clear B;clear pVTssi; clear mVTssr;clear pVTtsi;clear mVTtsr;clear pVTsti; disp('done')

*********************************************************************** *
% % % StubMatchingWavesV3 The Stub.

% T-Line matching networks are designed for steady % state operation. This program shows how the % matching condition is established by viewing the % initial waves launched into the network. % % There are three sections to the network: input, % thru, and stub. The input is assumed to be fed % by a matched Zo source. The load in the present % version is assumed all real to avoid the added % programming challenge of a complex load. It also % means we can represent the wave without needing a % phase shift term. % % The lines in a stub matching network tend to be % short; less than 0.5 guide wavelengths. To better % view the wave action, each section of line is % extended by 0.5 guide wavelengths. The end % results is not changed by the additional length. % % Wave velocity is angular velocity over phase % constant, of course. It is also equal to dk/dt, % where dk is the position increment to be plotted, % and dt is the time step for the plot. % % Things to do to improve the program: % a. allow for complex loads % % clc;clear; disp('starting program...') % % % % % % % % % % % % % % % % % % % % % % % % % % Variables c speed of light, m/s f frequency, Hz w angular frequency, rad/s dk differential position step, wavelengths dt differential time step, seconds jend counter for max possible length,any line (this is set to 1.0 wavelengths) iend counter for max overall simulation time variable input line line length kI line length jIterm impedance ZoI termination --load end refl. GIL input end refl. --through line kT jTterm ZoT ZTL GTL GTI stub line kS jSterm ZoS ZSL GSL GSI

transmission coefficients: from input to thru and stub: TI from thru to input and stub: TT from stub to input and thru: TS Voltage amplitudes: Vxyz where x indicates line (I, T, S) y indicates path history

% z indicates incident(i) or reflected(r) % example: VTsi is an incident wave on the % thru line that came from the stub; % example: VStsi is an indicent wave that % started on the stub, then the thru, and then % back to the stub. % % Time counters: ixyz % As above. % % Wave arrays: Vpxyz, Vmxyz % incident, or plus(p), and reflected, or (m) % the xyz is as above %Initial values c=3e8;f=1e9;w=2*pi*f; dk=.005; jend=0.7/dk; iend=1000; %Line details kI=.50;jIterm=kI/dk; kT=.670;jTterm=kT/dk; kS=.605;jSterm=kS/dk; %note: must be an integer ZoI=50; ZoT=50; ZoS=50; ZTL=170; ZSL=0; %shorted shunt stub %reflection & transmission coefficients Ztemp=1/((1/ZoT)+(1/ZoS)); GIL=(Ztemp-ZoI)/(Ztemp+ZoI); TI=1+GIL; GTL=(ZTL-ZoT)/(ZTL+ZoT); Ztemp=1/((1/ZoI)+(1/ZoS)); GTI=(Ztemp-ZoT)/(Ztemp+ZoT); TT=1+GTI; GSL=(ZSL-ZoS)/(ZSL+ZoS); Ztemp=1/((1/ZoI)+(1/ZoT)); GSI=(Ztemp-ZoS)/(Ztemp+ZoS); TS=1+GSI; %Calculate voltage amplitudes & time counters disp('Calc voltage amplitudes & time counters.') %order 1 VIi=2; %wave amplitude launched on input line iIi=1; %order 2 VSi=TI*VIi; iSi=jIterm+1; VIr=GIL*VIi; iIr=jIterm+1; VTi=TI*VIi; iTi=jIterm+1;

VSr=GSL*VSi; iSr=iSi+jSterm; VTr=GTL*VTi; iTr=iTi+jTterm; %order 3 VSsi=GSI*VSr; iSsi=iSr+jSterm; VIsr=TS*VSr; iIsr=iSr+jSterm; VTsi=TS*VSr; iTsi=iSr+jSterm; VSti=TT*VTr; iSti=iTr+jTterm; VItr=TT*VTr; iItr=iTr+jTterm; VTti=GTI*VTr; iTti=iTr+jTterm; VSsr=GSL*VSsi; iSsr=iSsi+jSterm; VTsr=GTL*VTsi; iTsr=iTsi+jTterm; VStr=GSL*VSti; iStr=iSti+jSterm; VTtr=GTL*VTti; iTtr=iTti+jTterm; % order 4 VSssi=GSI*VSsr; iSssi=iSsr+jSterm; VIssr=TS*VSsr; iIssr=iSsr+jSterm; VTssi=TS*VSsr; iTssi=iSsr+jSterm; VStsi=TT*VTsr; iStsi=iTsr+jTterm; VItsr=TT*VTsr; iItsr=iTsr+jTterm; VTtsi=GTI*VTsr; iTtsi=iTsr+jTterm; VSsti=GSI*VStr; iSsti=iStr+jSterm; VIstr=TS*VStr; iIstr=iStr+jSterm; VTsti=TS*VStr; iTsti=iStr+jSterm; VStti=TT*VTtr; iStti=iTtr+jTterm; VIttr=TT*VTtr; iIttr=iTtr+jTterm; VTtti=GTI*VTtr; iTtti=iTtr+jTterm;

VSssr=GSL*VSssi; iSssr=iSssi+jSterm; VTssr=GTL*VTssi; iTssr=iTssi+jTterm; VStsr=GSL*VStsi; iStsr=iStsi+jSterm; VTtsr=GTL*VTtsi; iTtsr=iTtsi+jTterm; VSstr=GSL*VSsti; iSstr=iSsti+jSterm; VTstr=GTL*VTsti; iTstr=iTsti+jTterm; VSttr=GSL*VStti; iSttr=iStti+jSterm; VTttr=GTL*VTtti; iTttr=iTtti+jTterm; % order 5 VSsssi=GSI*VSssr; iSsssi=iSssr+jSterm; VIsssr=TS*VSssr; iIsssr=iSssr+jSterm; VTsssi=TS*VSssr; iTsssi=iSssr+jSterm; VStssi=TT*VTssr; iStssi=iTssr+jTterm; VItssr=TT*VTssr; iItssr=iTssr+jTterm; VTtssi=GTI*VTssr; iTtssi=iTssr+jTterm; VSstsi=GSI*VStsr; iSstsi=iStsr+jSterm; VIstsr=TS*VStsr; iIstsr=iStsr+jSterm; VTstsi=TS*VStsr; iTstsi=iStsr+jSterm; VSttsi=TT*VTtsr; iSttsi=iTtsr+jTterm; VIttsr=TT*VTtsr; iIttsr=iTtsr+jTterm; VTttsi=GTI*VTtsr; iTttsi=iTtsr+jTterm; VSssti=GSI*VSstr; iSssti=iSstr+jSterm; VIsstr=TS*VSstr; iIsstr=iSstr+jSterm; VTssti=TS*VSstr; iTssti=iSstr+jSterm;

VStsti=TT*VTstr; iStsti=iTstr+jTterm; VItstr=TT*VTstr; iItstr=iTstr+jTterm; VTtsti=GTI*VTstr; iTtsti=iTstr+jTterm; VSstti=GSI*VSttr; iSstti=iSttr+jSterm; VIsttr=TS*VSttr; iIsttr=iSttr+jSterm; VTstti=TS*VSttr; iTstti=iSttr+jSterm; VSttti=TT*VTttr; iSttti=iTttr+jTterm; VItttr=TT*VTttr; iItttr=iTttr+jTterm; VTttti=GTI*VTttr; iTttti=iTttr+jTterm; VSsssr=GSL*VSsssi; iSsssr=iSsssi+jSterm; VTsssr=GTL*VTsssi; iTsssr=iTsssi+jTterm; VStssr=GSL*VStssi; iStssr=iStssi+jSterm; VTtssr=GTL*VTtssi; iTtssr=iTtssi+jTterm; VSstsr=GSL*VSstsi; iSstsr=iSstsi+jSterm; VTstsr=GTL*VTstsi; iTstsr=iTstsi+jTterm; VSttsr=GSL*VSttsi; iSttsr=iSttsi+jSterm; VTttsr=GTL*VTttsi; iTttsr=iTttsi+jTterm; VSsstr=GSL*VSssti; iSsstr=iSssti+jSterm; VTsstr=GTL*VTssti; iTsstr=iTssti+jTterm; VStstr=GSL*VStsti; iStstr=iStsti+jSterm; VTtstr=GTL*VTtsti; iTtstr=iTtsti+jTterm; VSsttr=GSL*VSstti; iSsttr=iSstti+jSterm; VTsttr=GTL*VTstti; iTsttr=iTstti+jTterm; VStttr=GSL*VSttti;

iStttr=iSttti+jSterm; VTtttr=GTL*VTttti; iTtttr=iTttti+jTterm; disp('Initially fill arrays with zeros.') %input line for i=1:iend for j=1:jend pVSi(i,j)=0; mVSr(i,j)=0; pVSsi(i,j)=0; mVSsr(i,j)=0; pVSti(i,j)=0; mVStr(i,j)=0; pVSssi(i,j)=0; mVSssr(i,j)=0; pVStsi(i,j)=0; mVStsr(i,j)=0; pVSsti(i,j)=0; mVSstr(i,j)=0; pVStti(i,j)=0; mVSttr(i,j)=0; A(i,j)=0; B(i,j)=0; C(i,j)=0; D(i,j)=0; E(i,j)=0; VStot(i,j)=0; end end disp('Fill arrays...') pVSi=incwave(VSi,0,f,iSi,iend,jSterm,dk); mVSr=refwave(VSr,0,f,iSr,iend,jSterm,dk); pVSsi=incwave(VSsi,0,f,iSsi,iend,jSterm,dk); mVSsr=refwave(VSsr,0,f,iSsr,iend,jSterm,dk); pVSti=incwave(VSti,0,f,iSti,iend,jSterm,dk); mVStr=refwave(VStr,0,f,iStr,iend,jSterm,dk); pVSssi=incwave(VSssi,0,f,iSssi,iend,jSterm,dk); mVSssr=refwave(VSssr,0,f,iSssr,iend,jSterm,dk); pVStsi=incwave(VStsi,0,f,iStsi,iend,jSterm,dk); mVStsr=refwave(VStsr,0,f,iStsr,iend,jSterm,dk); pVSsti=incwave(VSsti,0,f,iSsti,iend,jSterm,dk); mVSstr=refwave(VSstr,0,f,iSstr,iend,jSterm,dk); pVStti=incwave(VStti,0,f,iStti,iend,jSterm,dk); mVSttr=refwave(VSttr,0,f,iSttr,iend,jSterm,dk); A=pVSi+mVSr+pVSsi+mVSsr+pVSti+mVStr; B=A+pVSssi+mVSssr+pVStsi+mVStsr+pVSsti+mVSstr; VStot=B+pVStti+mVSttr; disp('VStot constructed!') disp('clear arrays') clear A;clear pVSi;clear mVSr;clear PVSsi;clear mVSsr; clear pVSti;clear mVStr;clear B;clear pVSssi; clear mVSssr;clear pVStsi;clear mVStsr;clear pVSsti; clear mVSstr;clear pVStti;clear mVSttr;

disp('done')

*********************************************************************** *
function Vp=incwave(Vo,Fo,f,istart,iend,jterm,dk) %Incident wave of magnitude Vo and Fo(rad) is %initiated on the line at a time istart*dt. It %travels to the end of the line, jterm*dk. %The result is placed in an array, where the %columns represent position along the line and %the rows correspond to time. % % Vo = amplitude of wave incident on start of line % Fo = phase of incident wave, in radians % f = frequency (Hz) % dk = position step in fraction of wavelength % time counters: % istart = counter when wave is first incident % iend = counter at end of simulation time % position counters: % jfront = counter value corresponding to the % location of wavefront % jterm = counter value corresponding to the % location of the termination % jend = counter value corresponding to the % maximum possible line length c=3e8; %speed of light, in m/s w=2*pi*f; %angular freq., rad/s B=w/c; %phase constant, rad/wavelength dkp=dk*c/f; %position step, m dt=dkp/c; %time step jfront=0; %initially the front of the wave jend=1.0/dk; %arbitrarily set the max length % of the line to be 1 wavelength for i=istart:iend; t=(i-istart+1)*dt; if jfront>=jterm jfront=jterm; %the front does not keep %going after the termination end for j=1:jfront k=j*dkp; Vp(i,j)=Vo*sin(w*t-B*k+Fo); end for j=jfront+1:jend Vp(i,j)=0; end jfront=1+i-istart;

end

%advances the wave

*********************************************************************** *
function Vm=refwave(Vo,Fo,f,istart,iend,jterm,dk) %reflected wave of magnitude Vo and Fo(rad) is %initiated from the load end of the line at a time %istart*dt. It travels to the front of the line. %The result is placed in an array, where the %columns represent position along the line and %the rows correspond to time. % % Vo = amplitude of wave launched from line end % Fo = phase of wave, in radians % f = frequency (Hz) % dk = position step in fraction of wavelength % time counters: % istart = counter when wave is launched % iend = counter at end of simulation time % position counters: % jfront = counter value corresponding to the % location of wavefront % jterm = counter value corresponding to the % location of the termination % jend = counter value corresponding to the % maximum possible line length c=3e8; %speed of light, in m/s w=2*pi*f; %angular freq., rad/s B=w/c; %phase constant, rad/wavelength dkp=dk*c/f; %position step; m dt=dkp/c; %time step jfront=jterm; %initially the front of the wave jend=1.0/dk; %arbitrarily set the max length % of the line to be 1 wavelength for i=istart:iend; t=(i-istart+1)*dt; if jfront<=1 jfront=1; %the front does not keep %going past the start of line else for j=1:jfront-1 Vm(i,j)=0; end end for j=jterm:-1:jfront k=(jterm-j+1)*dkp; Vm(i,j)=Vo*sin(w*t-B*k+Fo); end for j=jterm+1:jend Vm(i,j)=0; end

end

jfront=jfront-1;

%advances the wave

*********************************************************************** *
%movie %Run movie for the input line for i=1:500; ii=2*i; for j=1:jend k(j)=j*dk; Vp(j)=Vpi(ii,j); V1(j)=VItot(ii,j); Vtot(j)=Vp(j)+V1(j); end k0=dk:dk:1.0; V0=0; plot(k0,V0) axis([0 0.5 -4 4]) xlabel('k') ylabel('V') grid on hold on plot(k,Vp,'b',k,V1,'r',k,Vtot,'g') timestep=num2str(ii); S=strvcat('time = ',timestep); text(.42,3.4,S) MyMovie2t(i)=getframe; hold off pause(.01) end; disp('clear arrays') clear Vp;clear V1;clear Vtot; disp('Now run movie') movie(MyMovie2t) movie2avi(MyMovie2t,'input2t.avi','compression','none');

*********************************************************************** *
%movie %Run movie for the through line clear MyMovie2tt; for i=1:500; ii=2*i; for j=1:jend k(j)=j*dk; V1(j)=VTtot(ii,j); end k0=dk:dk:1.0; V0=0; plot(k0,V0) axis([0 0.7 -4 4])

end; disp('clear arrays') clear k;clear V1; disp('Now run movie') movie(MyMovie2tt) movie2avi(MyMovie2tt,'thru2b.avi','compression','none');

xlabel('through-line position(in wavelengths)') ylabel('Voltage(V)') grid on hold on plot(k,V1,'b') timestep=num2str(ii); S=strvcat('time = ',timestep); text(.82,1.8,S) MyMovie2tt(i)=getframe; hold off pause(.01)

*********************************************************************** *
%movie %Run movie for the stub line for i=1:500; ii=2*i; for j=1:jend k(j)=j*dk; V3(j)=VStot(ii,j); end k0=dk:dk:1.0; V0=0; plot(k0,V0) axis([0 0.7 -4 4]) xlabel('stub position(in wavelengths)') ylabel('Voltage(V)') grid on hold on plot(k,V3,'b') timestep=num2str(ii); S=strvcat('time = ',timestep); text(2,3.1,S) MyMovie4c(i)=getframe; hold off pause(.01) end; disp('clear arrays') clear k;clear V3; disp('Now run movie') movie(MyMovie4c) movie2avi(MyMovie4c,'stub2.avi','compression','none');

*********************************************************************** *