mwavepy.workingBand
index
/usr/local/lib/python2.6/dist-packages/mwavepy/workingBand.py

Contains WorkingBand class.

 
Modules
       
numpy
scipy.stats

 
Classes
       
__builtin__.object
WorkingBand

 
class WorkingBand(__builtin__.object)
    WorkingBand is an high-level object which exists solely to make 
 working with and creation of Networks within the same band,
 more concise and convenient. 
 
WorkingBand object has two properties: 
        frequency information (Frequency object)
        transmission line information   (transmission line-like object)
        
 
the methods of WorkingBand simply calls functions from createNetwork,
but it saves the user the hassle of repetitously providing a
tline and frequency type for every network creation.    
 
note: frequency and tline classes are copied, so they are passed
by value and not by-reference.
 
  Methods defined here:
__init__(self, frequency, tline)
delay_load(self, d, Gamma0, **kwargs)
creates a Network for a delayed short transmission line
 
takes:
        d: the length (in meters)
        Gamma0: reflection coefficient of load (not in dB)
        **kwargs: key word arguments passed to Network Constructor
returns:
        a 1-port Network class, representing a loaded transmission
        line of length d
delay_short(self, d, **kwargs)
creates a Network for a delayed short transmission line
 
takes:
        d: the length (in meters)
        **kwargs: key word arguments passed to Network Constructor
returns:
        a 1-port Network class, representing a shorted transmission
        line of length d
guess_length_of_delay_short(self, 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
line(self, d, **kwargs)
creates a Network for a section of transmission line
 
takes:
        d: the length (in meters)
        **kwargs: key word arguments passed to Network Constructor
returns:
        a 2-port Network class, representing a transmission line of length d
 
note: the only function called from the tline class is
propagation_constant(f,d), where f is frequency in Hz and d is
distance in meters. so you can use any class  which provides this
and it  will work .
load(self, Gamma0, **kwargs)
creates a Network for a Load termianting a transmission line 
 
takes:
        Gamma0: reflection coefficient of load (not in db)
        **kwargs: key word arguments passed to Network Constructor
returns:
        a 1-port Network class, where  S = Gamma0*ones(...)
match(self, nports=1, **kwargs)
creates a Network for a perfect matched transmission line (Gamma0=0) 
 
takes:
        **kwargs: key word arguments passed to Network Constructor
returns:
        a 1-port Network class, representing a perfect match
open(self, nports=1, **kwargs)
creates a Network for a 'open' transmission line (Gamma0=1) 
 
takes:
        **kwargs: key word arguments passed to Network Constructor
returns:
        a 1-port Network class, an open
short(self, 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
        **kwargs: key word arguments passed to Network Constructor
returns:
        a 1-port Network class, a short
thru(self, **kwargs)
creates a Network for a thru
 
takes:
        **kwargs: key word arguments passed to Network Constructor
returns:
        a 2-port Network class, representing a thru
 
note:
        this just calls line(0)
two_port_reflect(self, ntwk1, ntwk2, **kwargs)
generates a two-port reflective (S21=S12=0) network,from the
responses of 2 one-port networks
 
takes:
        ntwk1: Network type, seen from port 1
        ntwk2: Network type, seen from port 2
returns:
        result: two-port reflective Network type
 
 
example:
        wb.two_port_reflect(wb.short(), wb.match())
white_gaussian_polar(self, 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

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
frequency
tline