media Package

media Package

Provides Media super-Class and instances of Media Class’s for various transmission-line mediums.

Instances of the Media Class are objects which provide methods to create network objects. See media for more detailed information.

cpw Module

contains CPW class

class mwavepy.media.cpw.CPW(frequency, w, s, ep_r, t=None, rho=None, *args, **kwargs)

Bases: mwavepy.media.media.Media

Coplanar waveguide class

This class was made from the the documentation from the qucs project ( qucs.sourceforge.net/ ).

K_ratio

intermediary parameter. see qucs docs on cpw lines.

Z0()

characterisitc impedance

alpha_conductor

losses due to conductor resistivity

ep_re

intermediary parameter. see qucs docs on cpw lines.

gamma()

propagation constant

k1

intermediary parameter. see qucs docs on cpw lines.

distributedCircuit Module

A transmission line defined in terms of distributed circuit components

class mwavepy.media.distributedCircuit.DistributedCircuit(frequency, C, I, R, G, *args, **kwargs)

Bases: mwavepy.media.media.Media

A TEM transmission line, defined in terms of distributed impedance

and admittance values. This class takes the following information,

distributed Capacitance, C distributed Inductance, I distributed Resistance, R distributed Conductance, G

from these the following quantities may be calculated, which are functions of angular frequency (w):

distributed Impedance, Z’(w) = wR + jwI distributed Admittance, Y’(w) = wG + jwC

from these we can calculate properties which define their wave behavior:

characteristic Impedance, Z0(w) = sqrt(Z(w)/Y’(w)) [ohms] propagation Constant, gamma(w) = sqrt(Z(w)*Y’(w)) [none]

given the following definitions, the components of propagation constant are interpreted as follows:

positive real(gamma) = attenuation positive imag(gamma) = forward propagation
Y

distributed Admittance,in ohms^-1 /m

Y’(w) = wG + jwC
Z

distributed Impedance, ohms/m.

Z’(w) = wR + jwI
Z0()

The characteristic impedance in ohms

classmethod from_Media(my_media, *args, **kwargs)

initializer which creates DistributedCircuit from a Media instance

gamma()
possibly complex propagation constant, [rad/m]
gamma = sqrt(Z’*Y’)

note: the components of propagation constant are interpreted as follows:

positive real(gamma) = attenuation positive imag(gamma) = forward propagation

freespace Module

A Plane-wave in Freespace.

class mwavepy.media.freespace.Freespace(frequency, ep_r=1, mu_r=1, *args, **kwargs)

Bases: mwavepy.media.distributedCircuit.DistributedCircuit

Represents a plane-wave in a homogeneous freespace, defined by [possibly complex] values of relative permativity and relative permeability.

The field properties of space are related to a disctributed circuit transmission line model given in circuit theory by:

distributed_capacitance = real(ep_0*ep_r) distributed_resistance = imag(ep_0*ep_r) distributed_inductance = real(mu_0*mu_r) distributed_conductance = imag(mu_0*mu_r)
note: this class’s inheritence is;
Media->DistributedCircuit->FreeSpace

media Module

Contains Media class.

class mwavepy.media.media.Media(frequency, propagation_constant, characteristic_impedance, z0=None)

Bases: object

The super-class for all transmission line media.

It provides methods to produce generic network components for any transmision line medium, such as line, delay_short, etc.

Network Components specific to an instance of the Media super-class such as cpw_short, microstrip_bend, are implemented within the Media instances themselves.

capacitor(C, **kwargs)

A lumped capacitor

takes:
C: capacitance, in Farads, [number]
returns:
mwavepy.Network
characteristic_impedance
delay_load(Gamma0, d, unit='m', **kwargs)

creates a Network for a delayed load transmission line

takes:

Gamma0: reflection coefficient of load (not in dB) d: the length (see unit argument) [number] unit: string specifying the units of d. possible options are

‘m’: meters, physical length in meters (default) ‘deg’:degrees, electrical length in degrees ‘rad’:radians, electrical length in radians
**kwargs: key word arguments passed to match(), which is
called initially to create a ‘blank’ network. the kwarg ‘z0’ can be used to create a line of a given impedance
returns:
a 1-port Network class, representing a loaded transmission line of length d

note: this just calls, self.line(d,**kwargs) ** self.load(Gamma0, **kwargs)

delay_open(d, unit='m', **kwargs)

creates a Network for a delayed open transmission line

takes:

d: the length (see unit argument) [number] unit: string specifying the units of d. possible options are

‘m’: meters, physical length in meters (default) ‘deg’:degrees, electrical length in degrees ‘rad’:radians, electrical length in radians
**kwargs: key word arguments passed to match(), which is
called initially to create a ‘blank’ network. the kwarg ‘z0’ can be used to create a line of a given impedance
returns:
a 1-port Network class, representing a shorted transmission line of length d

note: this just calls, self.line(d,**kwargs) ** self.open(**kwargs)

delay_short(d, unit='m', **kwargs)

creates a Network for a delayed short transmission line

takes:

d: the length (see unit argument) [number] unit: string specifying the units of d. possible options are

‘m’: meters, physical length in meters (default) ‘deg’:degrees, electrical length in degrees ‘rad’:radians, electrical length in radians
**kwargs: key word arguments passed to match(), which is
called initially to create a ‘blank’ network. the kwarg ‘z0’ can be used to create a line of a given impedance
returns:
a 1-port Network class, representing a shorted transmission line of length d

note: this just calls, self.line(d,**kwargs) ** self.short(**kwargs)

electrical_length(d, deg=False)

calculates the electrical length for a given distance, at the center frequency.

takes:
d: distance, in meters deg: is d in deg?[Boolean]
returns:
theta: electrical length in radians or degrees,
depending on value of deg.
guess_length_of_delay_short(aNtwk)

guess length of physical length of a Delay Short given by aNtwk

takes:
aNtwk: a mwavepy.ntwk type . (note: if this is a measurment
it needs to be normalized to the reference plane)
tline: transmission line class of the medium. needed for the
calculation of propagation constant
impedance_mismatch(z1, z2, **kwargs)

returns a two-port network for a impedance mis-match

takes:
z1: complex impedance of port 1 [ number, list, or 1D ndarray] z2: complex impedance of port 2 [ number, list, or 1D ndarray] **kwargs: passed to mwavepy.Network constructor
returns:
a 2-port network [mwavepy.Network]
note:
if z1 and z2 are arrays or lists, they must be of same length as the self.frequency.npoints
inductor(L, **kwargs)

A lumped inductor

takes:
L: inductance in Henrys [number]
returns:
mwavepy.Network
line(d, unit='m', **kwargs)

creates a Network for a section of matched transmission line

takes:

d: the length (see unit argument) [number] unit: string specifying the units of d. possible options are

‘m’: meters, physical length in meters (default) ‘deg’:degrees, electrical length in degrees ‘rad’:radians, electrical length in radians
**kwargs: key word arguments passed to match(), which is
called initially to create a ‘blank’ network. the kwarg ‘z0’ can be used to create a line of a given impedance
returns:
a 2-port Network class, representing a transmission line of length d
example:
my_media = mwavepy.Freespace(...) my_media.line(90, ‘deg’, z0=50)
load(Gamma0, nports=1, **kwargs)

creates a Network for a Load termianting a transmission line

takes:

Gamma0: reflection coefficient of load (not in db) nports: number of ports. creates a short on all ports,

default is 1 [int]
**kwargs: key word arguments passed to match(), which is
called initially to create a ‘blank’ network
returns:
a n-port Network class, where S = Gamma0*eye(...)
match(nports=1, z0=None, **kwargs)

creates a Network for a perfect matched transmission line (Gamma0=0)

takes:

nports: number of ports [int] z0: characterisitc impedance [number of array]. defaults is

None, in which case the Media’s z0 is used. Otherwise this sets the resultant network’s z0. See Network.z0 property for more info

**kwargs: key word arguments passed to Network Constructor

returns:
a n-port Network [mwavepy.Network]
example:
mymatch = wb.match(2,z0 = 50, name=’Super Awesome Match’)
open(nports=1, **kwargs)

creates a Network for a ‘open’ transmission line (Gamma0=1)

takes:
nports: number of ports. creates a short on all ports,
default is 1 [int]
**kwargs: key word arguments passed to match(), which is
called initially to create a ‘blank’ network
returns:
a n-port Network [mwavepy.Network]
propagation_constant
short(nports=1, **kwargs)

creates a Network for a short transmission line (Gamma0=-1)

takes:
nports: number of ports. creates a short on all ports,
default is 1 [int]
**kwargs: key word arguments passed to match(), which is
called initially to create a ‘blank’ network
returns:
a n-port Network [mwavepy.Network]
shunt(ntwk, **kwargs)

returns a shunted ntwk. this creates a ‘tee’, connects ‘ntwk’ to port 1, and returns the result

takes:
ntwk: the network to be shunted. [mwavepy.Network] **kwargs: passed to the self.tee() function
returns:
a 2-port network [mwavepy.Network]
shunt_capacitor(C, *args, **kwargs)

a shunt capacitor

takes:
C: capacitance in farads *args: passed to self.capacitor **kwargs:passed to self.capacitor
returns:
a 2-port mwavepy.Network
shunt_delay_load(*args, **kwargs)

a shunted delayed load:

takes:
*args: passed to self.delay_load **kwargs:passed to self.delay_load
returns:
a 2-port network [mwavepy.Network]
shunt_delay_open(*args, **kwargs)

a shunted delayed open:

takes:
*args: passed to self.delay_load **kwargs:passed to self.delay_load
returns:
a 2-port network [mwavepy.Network]
shunt_delay_short(*args, **kwargs)

a shunted delayed short:

takes:
*args: passed to self.delay_load **kwargs:passed to self.delay_load
returns:
a 2-port network [mwavepy.Network]
shunt_inductor(L, *args, **kwargs)

a shunt inductor

takes:
L: inductance in henrys *args: passed to self.inductor **kwargs:passed to self.inductor
returns:
a 2-port mwavepy.Network
splitter(nports, **kwargs)

returns an ideal, lossless n-way splitter.

takes:

nports: number of ports [int] **kwargs: key word arguments passed to match(), which is

called initially to create a ‘blank’ network.
returns:
a n-port Network [mwavepy.Network]
tee(**kwargs)

makes a ideal, lossless tee. (aka three port splitter)

takes:
**kwargs: key word arguments passed to match(), which is
called initially to create a ‘blank’ network.
returns:
a 3-port Network [mwavepy.Network]
note:
this just calls splitter(3)
theta_2_d(theta, deg=True)

converts electrical length to physical distance. The electrical length is given at center frequency of self.frequency

takes:
theta: electrical length, at band center (see deg for unit)
[number]

deg: is theta in degrees? [boolean]

returns:
d: physical distance in meters
thru(**kwargs)

creates a Network for a thru

takes:
**kwargs: key word arguments passed to match(), which is
called initially to create a ‘blank’ network
returns:
a 2-port Network class, representing a thru
note:
this just calls self.line(0)
white_gaussian_polar(phase_dev, mag_dev, n_ports=1, **kwargs)

creates a complex zero-mean gaussian white-noise signal of given standard deviations for phase and magnitude

takes:
phase_mag: standard deviation of magnitude phase_dev: standard deviation of phase n_ports: number of ports. defualt to 1 **kwargs: passed to Network() initializer
returns:
result: Network type
z0

rectangularWaveguide Module

Rectangular Waveguide class

class mwavepy.media.rectangularWaveguide.RectangularWaveguide(frequency, a, b=None, mode_type='te', m=1, n=0, ep_r=1, mu_r=1, *args, **kwargs)

Bases: mwavepy.media.media.Media

Rectangular Waveguide medium.

Can be used to represent any mode of a homogeneously filled rectangular waveguide of arbitrary cross-section, mode-type, and mode index.

Z0()

the characteristic impedance of a given mode

ep

the permativity of the filling material

k0

characteristic wave number

kc

cut-off wave number

kx

eigen value in the ‘a’ direction

ky

eigen-value in the ‘b’ direction

kz()
the propagation constant, which is:
IMAGINARY for propagating modes REAL for non-propagating modes,
mu

the permeability of the filling material

Table Of Contents

Previous topic

mwavepy Package

Next topic

calibration Package

This Page