mwavepy.transmissionLine.rectangularWaveguideTE10
index
/home/alex/docs/python/path/mwavepy/transmissionLine/rectangularWaveguideTE10.py

#       rectangularWaveguideTE10.py
#       
#       Copyright 2010 alex arsenovic <arsenovic@virginia.edu>
#       
#       This program is free software; you can redistribute it and/or modify
#       it under the terms of the GNU General Public License as published by
#       the Free Software Foundation; either version 2 of the License, or
#       (at your option) any later versionpy.
#       
#       This program is distributed in the hope that it will be useful,
#       but WITHOUT ANY WARRANTY; without even the implied warranty of
#       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#       GNU General Public License for more details.
#       
#       You should have received a copy of the GNU General Public License
#       along with this program; if not, write to the Free Software
#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
#       MA 02110-1301, USA.

 
Classes
       
mwavepy.transmissionLine.rectangularWaveguide.RectangularWaveguide(__builtin__.object)
RectangularWaveguideTE10

 
class RectangularWaveguideTE10(mwavepy.transmissionLine.rectangularWaveguide.RectangularWaveguide)
    
Method resolution order:
RectangularWaveguideTE10
mwavepy.transmissionLine.rectangularWaveguide.RectangularWaveguide
__builtin__.object

Methods defined here:
__init__(self, a, b=None, epsilon_R=1, mu_R=1)
characteristic_admittance(self, f, *args)
the characteristic admittance of a given mode
 
takes:
        f: frequency [Hz]
characteristic_impedance(self, f, *args)
the characteristic impedance of a given mode
 
takes:
        f: frequency [Hz]
cutoff_frequency(self)
cutoff_wavelength(self)
electrical_length(self, f, d, deg=False)
calculate electrical length of a section fo waveguide.
 
takes:
        f: frequency at which to calculate [Hz]
        d: length fo delay [m]
        deg: True/False
kc(self, *args)
cut-off wave number
kz(self, f, *args)
the propagation constant, which is:
        REAL  for propagating modes, 
        IMAGINARY for non-propagating modes
 
takes:
        f: frequency [Hz]

Data and other attributes defined here:
__slotnames__ = []

Methods inherited from mwavepy.transmissionLine.rectangularWaveguide.RectangularWaveguide:
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
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
kx(self, m)
eigen value in teh a direction
ky(self, n)
eigen-value in the b direction

Data descriptors inherited from mwavepy.transmissionLine.rectangularWaveguide.RectangularWaveguide:
__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