### Navigation

- index
- modules |
- next |
- previous |
- mwavepy v1.4 documentation »
- mwavepy API »
- mwavepy Package »

# 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

### Navigation

- index
- modules |
- next |
- previous |
- mwavepy v1.4 documentation »
- mwavepy API »
- mwavepy Package »