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

a multimoded rectangular waveguide

 
Modules
       
mwavepy.mathFunctions
numpy
pdb

 
Classes
       
__builtin__.object
RectangularWaveguide

 
class RectangularWaveguide(__builtin__.object)
    represents a homogeneously rectangular waveguide.
 
cross-section is axb, and it is homogeneously with relative
permativity and permiabilty, epsilon_R and mu_R respectivly
 
  Methods defined here:
__init__(self, a, b=None, epsilon_R=1, mu_R=1)
characteristic_admittance(self, mode_type, m, n, f)
the characteristic admittance of a given mode
 
takes:
        mode_type:      describes the mode type (TE,TM) and direction, 
                possible values are:
                        'tez','tmz'
        m: mode index in the 'a' direction 
        n: mode index in the 'b' direction 
        f: frequency [Hz]
        
TODOL: write function for  'tex','tmx','tey','tmy')
characteristic_impedance(self, mode_type, m, n, f)
the characteristic impedance of a given mode
 
takes:
        mode_type:      describes the mode type (TE,TM) and direction, 
                possible values are:
                        'tez','tmz'
        m: mode index in the 'a' direction 
        n: mode index in the 'b' direction 
        f: frequency [Hz]
        
TODOL: write function for  'tex','tmx','tey','tmy')
cutoff_frequency(self, m, n)
the cutoff freqency of mode (m,n)
cutoff_wavelength(self, m, n)
the wavelength at which mode (m,n) is cut-off
e_t(self, mode_type, m, n, x_points=201, y_points=101)
discretized transverse mode functions for the electric field. 
 
usable for numerical evaluation of eigen-space, or field 
visualization.
 
takes:
 
returns array of shape  [3,y_points, x_points]. the three 
components are: in order
        e_t_x: component of field in 'a' direction
        e_t_y: component of field in 'b' direction
        e_t_z:component of field in  longitudinal direction
        
        NOTE: all vectors returns are in (row, col) format which
        equates to (y,x).
eigenfunction_normalization(self, mode_type, m, n)
returns the normalization for a given transverse eigen function,
 so that the set is normalized to 1.
 
takes:
        mode_type:      describes the mode type (TE,TM) and direction, 
                possible values are:
                        'tez','tmz'
        m: mode index in the 'a' direction 
        n: mode index in the 'b' direction 
        
note:
        t-to-z mode normalization can be found in marcuvitz
eigenfunction_normalization2(self, field_type, mode_type, m, n)
returns the normalization factor for a given transverse eigenfunction,
 so that the set is normalized to 1.
 
takes:
        field_type: 'e' or 'h' field
        mode_type:      describes the mode type (TE,TM) and direction, 
                possible values are:
                        'tez','tmz'
        m: mode index in the 'a' direction 
        n: mode index in the 'b' direction 
        
note:
        t-to-z mode normalization can be found in marcuvitz
electrical_length(self, m, n, f, d, deg=False)
guide_phase_velocity(self, m, n, f)
the guide phase velocity at which a mode propagates.
guide_wavelength(self, m, n, f)
the guide wavelength.
 
'the distance that the field travels before the phase increases
by 2*pi'.
input_admittance(self, d, Gamma0, mode_type, m, n, f)
calculates the input admitance for a single mode, of reflection
coefficient Gamma0, at a specified disatnace d.
 
takes:
        d: distance from load ( in meters)
        Gamma0: reflection coefficient of termination (@z=0)
        mode_type:      describes the mode type (TE,TM) and direction, 
                possible values are:
                        'tez','tmz'
        m: mode index in the 'a' direction 
        n: mode index in the 'b' direction 
        f: frequency [Hz]
 
returns:
        zin: input impedance (in 1/ohms)
 
note:
        if you want to specify load in terms of its impedance, you
        can use the function:
                transmissionLine.functions.zl_2_Gamma0().
        
        see transmissionLine.functions for more info.
input_impedance(self, d, Gamma0, mode_type, m, n, f)
calculates the input impedance for a single mode, of reflection
coefficient Gamma0, at a specified disatnace d.
 
takes:
        d: distance from load ( in meters)
        Gamma0: reflection coefficient of termination (@z=0)
        mode_type:      describes the mode type (TE,TM) and direction, 
                possible values are:
                        'tez','tmz'
        m: mode index in the 'a' direction 
        n: mode index in the 'b' direction 
        f: frequency [Hz]
 
returns:
        zin: input impedance (in ohms)
 
note:
        if you want to specify load in terms of its impedance, you
        can use the function:
                transmissionLine.functions.zl_2_Gamma0().
        
        see transmissionLine.functions for more info.
intrinsic_wavelength(self, f)
the intrinisic wavelength of the waveguide at frequency f.
(different from the guide_wavelength )
k0(self, f)
characteristic wave number
kc(self, m, n)
cut-off wave number
kx(self, m)
eigen value in teh a direction
ky(self, n)
eigen-value in the b direction
kz(self, m, n, f)
the propagation constant, which is:
        REAL  for propagating modes, 
        IMAGINARY for non-propagating modes
 
takes:
        m: mode index in the 'a' direction
        n: mode index in the 'b' direction 
        f: frequency [Hz]
 
output:
        kz:a complex number, and possibly a fxmxn array, depending
                on input 
 
NOTE:
        
        a note about using arrays for input values:
        either all inputs, m,n,f can be arrays, 
        or just f
        or just m and n
        but not m or n

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
intrinsic_impedance
the intrinsic impedance of the filling material
intrinsic_phase_velocity
the intrinsic phase velocity of the waveguide. depends only on
material which fills the waveguide

 
Functions
       
array(...)
array(object, dtype=None, copy=True, order=None, subok=False, ndmin=True)
 
Create an array.
 
Parameters
----------
object : array_like
    An array, any object exposing the array interface, an
    object whose __array__ method returns an array, or any
    (nested) sequence.
dtype : data-type, optional
    The desired data-type for the array.  If not given, then
    the type will be determined as the minimum type required
    to hold the objects in the sequence.  This argument can only
    be used to 'upcast' the array.  For downcasting, use the
    .astype(t) method.
copy : bool, optional
    If true (default), then the object is copied.  Otherwise, a copy
    will only be made if __array__ returns a copy, if obj is a
    nested sequence, or if a copy is needed to satisfy any of the other
    requirements (`dtype`, `order`, etc.).
order : {'C', 'F', 'A'}, optional
    Specify the order of the array.  If order is 'C' (default), then the
    array will be in C-contiguous order (last-index varies the
    fastest).  If order is 'F', then the returned array
    will be in Fortran-contiguous order (first-index varies the
    fastest).  If order is 'A', then the returned array may
    be in any order (either C-, Fortran-contiguous, or even
    discontiguous).
subok : bool, optional
    If True, then sub-classes will be passed-through, otherwise
    the returned array will be forced to be a base-class array (default).
ndmin : int, optional
    Specifies the minimum number of dimensions that the resulting
    array should have.  Ones will be pre-pended to the shape as
    needed to meet this requirement.
 
Examples
--------
>>> np.array([1, 2, 3])
array([1, 2, 3])
 
Upcasting:
 
>>> np.array([1, 2, 3.0])
array([ 1.,  2.,  3.])
 
More than one dimension:
 
>>> np.array([[1, 2], [3, 4]])
array([[1, 2],
       [3, 4]])
 
Minimum dimensions 2:
 
>>> np.array([1, 2, 3], ndmin=2)
array([[1, 2, 3]])
 
Type provided:
 
>>> np.array([1, 2, 3], dtype=complex)
array([ 1.+0.j,  2.+0.j,  3.+0.j])
 
Data-type consisting of more than one element:
 
>>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
>>> x['a']
array([1, 3])
 
Creating an array from sub-classes:
 
>>> np.array(np.mat('1 2; 3 4'))
array([[1, 2],
       [3, 4]])
 
>>> np.array(np.mat('1 2; 3 4'), subok=True)
matrix([[1, 2],
        [3, 4]])

 
Data
        c = 299792458.0
cos = <ufunc 'cos'>
epsilon_0 = 8.8541878176203892e-12
mil = 2.5399999999999997e-05
mu_0 = 1.2566370614359173e-06
pi = 3.1415926535897931
sin = <ufunc 'sin'>
sqrt = <ufunc 'sqrt'>