mwavepy.transmissionLine.rectangularWaveguide | index /home/alex/docs/python/path/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'>